1 /****************************************
2 * Computer Algebra System SINGULAR *
3 ****************************************/
4 /*
5 * ABSTRACT - implementation of functions for Copy/Move/Delete for Polys
6 */
7
8
9 #include "misc/auxiliary.h"
10
11 #include "polys/monomials/ring.h"
12 #include "polys/monomials/p_polys.h"
13 #include "coeffs/numbers.h"
14 #include "polys/monomials/ring.h"
15 #include "polys/simpleideals.h"
16
17 static inline void
prCopyEvector(poly dest,ring dest_r,poly src,ring src_r,int max)18 prCopyEvector(poly dest, ring dest_r, poly src, ring src_r,int max)
19 {
20 //memset(dest->exp,0,dest_r->ExpL_Size*sizeof(long));
21 int i;
22 for (i=max; i>0; i--)
23 {
24 p_SetExp(dest, i, p_GetExp( src, i,src_r), dest_r);
25 }
26 if (rRing_has_Comp(dest_r) && rRing_has_Comp(src_r))
27 p_SetComp(dest, p_GetComp( src,src_r), dest_r);
28 p_Setm(dest, dest_r);
29 }
30
31 #include "polys/prCopy.inc"
32
33 /////////////////////////////////////////////////////////////////////////
prCopyR(poly p,ring src_r,ring dest_r)34 poly prCopyR(poly p, ring src_r, ring dest_r)
35 {
36 poly res;
37 if (rField_has_simple_Alloc(dest_r))
38 res = pr_Copy_NoREqual_NSimple_Sort(p, src_r, dest_r);
39 else
40 res = pr_Copy_NoREqual_NoNSimple_Sort(p, src_r, dest_r);
41 p_Test(res, dest_r);
42 return res;
43 }
44
prMapR(poly src,nMapFunc nMap,ring src_r,ring dest_r)45 poly prMapR(poly src, nMapFunc nMap, ring src_r, ring dest_r)
46 {
47 if (src==NULL) return NULL;
48 int _min = si_min(dest_r->N, src_r->N);
49
50 spolyrec dest_s;
51
52 poly dest = &dest_s;
53
54 poly prev;
55 while (src != NULL)
56 {
57 pNext(dest) = (poly) p_Init(dest_r);
58 prev = dest;
59 pIter(dest);
60
61 pSetCoeff0(dest, nMap(pGetCoeff(src),src_r->cf,dest_r->cf));
62 prCopyEvector(dest, dest_r, src, src_r, _min);
63 if (n_IsZero(pGetCoeff(dest),dest_r->cf))
64 {
65 p_LmDelete(&pNext(prev),dest_r);
66 }
67 pIter(src);
68 }
69 pNext(dest) = NULL;
70 dest = pNext(&dest_s);
71 dest=p_SortAdd(dest, dest_r);
72 p_Test(dest, dest_r);
73 return dest;
74 }
75
prCopyR_NoSort(poly p,ring src_r,ring dest_r)76 poly prCopyR_NoSort(poly p, ring src_r, ring dest_r)
77 {
78 poly res;
79 if (rField_has_simple_Alloc(dest_r))
80 res = pr_Copy_NoREqual_NSimple_NoSort(p, src_r, dest_r);
81 else
82 res = pr_Copy_NoREqual_NoNSimple_NoSort(p, src_r, dest_r);
83 p_Test(res, dest_r);
84 return res;
85 }
86
87 /////////////////////////////////////////////////////////////////////////
88 // prMove
prMoveR(poly & p,ring src_r,ring dest_r)89 poly prMoveR(poly &p, ring src_r, ring dest_r)
90 {
91 poly res;
92 if (rField_has_simple_Alloc(dest_r))
93 res = pr_Move_NoREqual_NSimple_Sort(p, src_r, dest_r);
94 else
95 res = pr_Move_NoREqual_NoNSimple_Sort(p, src_r, dest_r);
96 p_Test(res, dest_r);
97 return res;
98 }
99
prMoveR_NoSort(poly & p,ring src_r,ring dest_r)100 poly prMoveR_NoSort(poly &p, ring src_r, ring dest_r)
101 {
102 poly res;
103 if (rField_has_simple_Alloc(dest_r))
104 res = pr_Move_NoREqual_NSimple_NoSort(p, src_r, dest_r);
105 else
106 res = pr_Move_NoREqual_NoNSimple_NoSort(p, src_r, dest_r);
107 p_Test(res, dest_r);
108 return res;
109 }
110
prShallowCopyR_NoSort(poly p,ring r,ring dest_r)111 poly prShallowCopyR_NoSort(poly p, ring r, ring dest_r)
112 {
113 return pr_Copy_NoREqual_NSimple_NoSort(p, r, dest_r);
114 }
115
prShallowCopyR(poly p,ring r,ring dest_r)116 poly prShallowCopyR(poly p, ring r, ring dest_r)
117 {
118 return pr_Copy_NoREqual_NSimple_Sort(p, r, dest_r);
119 }
120
121 /////////////////////////////////////////////////////////////////////////
122 // prHead
123 typedef poly (*prCopyProc_t)(poly &src_p, ring src_r, ring dest_r);
124
prHeadR(poly p,ring src_r,ring dest_r,prCopyProc_t prproc)125 poly prHeadR(poly p, ring src_r, ring dest_r, prCopyProc_t prproc)
126 {
127 if (p == NULL) return NULL;
128 poly tail, head, q = p;
129 tail = pNext(p);
130 pNext(p) = NULL;
131 head = prproc(q, src_r, dest_r);
132 pNext(p) = tail;
133
134 p_Test(p, src_r);
135 p_Test(head, dest_r);
136
137 return head;
138 }
139
prHeadR(poly p,ring src_r,ring dest_r)140 poly prHeadR(poly p, ring src_r, ring dest_r)
141 {
142 prCopyProc_t prproc;
143 if (rField_has_simple_Alloc(dest_r))
144 prproc = pr_Copy_NoREqual_NSimple_NoSort;
145 else
146 prproc = pr_Copy_NoREqual_NoNSimple_NoSort;
147
148 const poly res = prHeadR(p, src_r, dest_r, prproc);
149 p_Test(res, dest_r);
150 return res;
151 }
152
153 /////////////////////////////////////////////////////////////////////////
154 /// Copy leading terms of id[i] via prHeeadR into dest_r
idrHeadR(ideal id,ring r,ring dest_r)155 ideal idrHeadR(ideal id, ring r, ring dest_r)
156 {
157 if (id == NULL) return NULL;
158
159 prCopyProc_t prproc = pr_Copy_NoREqual_NoNSimple_NoSort;
160 if (rField_has_simple_Alloc(dest_r))
161 prproc = pr_Copy_NoREqual_NSimple_NoSort;
162
163 const int N = IDELEMS(id);
164 ideal res = idInit(N, id->rank);
165
166 for (int i = N - 1; i >= 0; i--)
167 res->m[i] = prHeadR(id->m[i], r, dest_r, prproc); // !!!
168
169 return res;
170 }
171
172
173 static inline ideal
idrCopy(ideal id,ring src_r,ring dest_r,prCopyProc_t prproc)174 idrCopy(ideal id, ring src_r, ring dest_r, prCopyProc_t prproc)
175 {
176 if (id == NULL) return NULL;
177 assume(src_r->cf==dest_r->cf);
178 poly p;
179 ideal res = idInit(IDELEMS(id), id->rank);
180 int i;
181
182 for (i=IDELEMS(id)-1; i>=0; i--)
183 {
184 p = id->m[i];
185 res->m[i] = prproc(p, src_r, dest_r);
186 p_Test(res->m[i], dest_r);
187 }
188 return res;
189 }
190
idrCopyR(ideal id,ring src_r,ring dest_r)191 ideal idrCopyR(ideal id, ring src_r, ring dest_r)
192 {
193 assume(src_r->cf==dest_r->cf);
194 ideal res;
195 prCopyProc_t prproc;
196 if (rField_has_simple_Alloc(dest_r))
197 prproc = pr_Copy_NoREqual_NSimple_Sort;
198 else
199 prproc = pr_Copy_NoREqual_NoNSimple_Sort;
200 res = idrCopy(id, src_r, dest_r, prproc);
201 return res;
202 }
203
idrCopyR_NoSort(ideal id,ring src_r,ring dest_r)204 ideal idrCopyR_NoSort(ideal id, ring src_r, ring dest_r)
205 {
206 assume(src_r->cf==dest_r->cf);
207 ideal res;
208 prCopyProc_t prproc;
209 if (rField_has_simple_Alloc(dest_r))
210 prproc = pr_Copy_NoREqual_NSimple_NoSort;
211 else
212 prproc = pr_Copy_NoREqual_NoNSimple_NoSort;
213 res = idrCopy(id, src_r, dest_r, prproc);
214 return res;
215 }
216
217 /////////////////////////////////////////////////////////////////////////
218 // idrShallowCopy
idrShallowCopyR(ideal id,ring src_r,ring dest_r)219 ideal idrShallowCopyR(ideal id, ring src_r, ring dest_r)
220 {
221 return idrCopy(id, src_r, dest_r, pr_Copy_NoREqual_NSimple_Sort);
222 }
223
idrShallowCopyR_NoSort(ideal id,ring src_r,ring dest_r)224 ideal idrShallowCopyR_NoSort(ideal id, ring src_r, ring dest_r)
225 {
226 return idrCopy(id, src_r, dest_r, pr_Copy_NoREqual_NSimple_NoSort);
227 }
228
229 /////////////////////////////////////////////////////////////////////////
230 // idrMove
231 static inline ideal
idrMove(ideal & id,ring src_r,ring dest_r,prCopyProc_t prproc)232 idrMove(ideal &id, ring src_r, ring dest_r, prCopyProc_t prproc)
233 {
234 assume(src_r->cf==dest_r->cf);
235 assume( prproc != NULL );
236
237 if (id == NULL) return NULL;
238
239 ideal res = id; id = NULL;
240
241 for (int i = IDELEMS(res) - 1; i >= 0; i--)
242 res->m[i] = prproc(res->m[i], src_r, dest_r);
243
244 return res;
245 }
246
idrMoveR(ideal & id,ring src_r,ring dest_r)247 ideal idrMoveR(ideal &id, ring src_r, ring dest_r)
248 {
249 assume(src_r->cf==dest_r->cf);
250 prCopyProc_t prproc;
251 ideal res;
252 if (rField_has_simple_Alloc(dest_r))
253 prproc = pr_Move_NoREqual_NSimple_Sort;
254 else
255 prproc = pr_Move_NoREqual_NoNSimple_Sort;
256 res = idrMove(id, src_r, dest_r, prproc);
257 return res;
258 }
259
idrMoveR_NoSort(ideal & id,ring src_r,ring dest_r)260 ideal idrMoveR_NoSort(ideal &id, ring src_r, ring dest_r)
261 {
262 assume(src_r->cf==dest_r->cf);
263 prCopyProc_t prproc;
264 ideal res;
265 if (rField_has_simple_Alloc(dest_r))
266 prproc = pr_Move_NoREqual_NSimple_NoSort;
267 else
268 prproc = pr_Move_NoREqual_NoNSimple_NoSort;
269 res = idrMove(id, src_r, dest_r, prproc);
270 return res;
271 }
272
273
274