prCopy.cc
Go to the documentation of this file.
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 <omalloc/omalloc.h>
12 #include <polys/monomials/ring.h>
14 #include <coeffs/numbers.h>
15 #include <polys/monomials/ring.h>
16 #include <polys/simpleideals.h>
17 // #include <polys/sbuckets.h>
18 
19 static inline void
20 prCopyEvector(poly dest, ring dest_r, poly src, ring src_r,int max)
21 {
22  //memset(dest->exp,0,dest_r->ExpL_Size*sizeof(long));
23  int i;
24  for (i=max; i>0; i--)
25  {
26  p_SetExp(dest, i, p_GetExp( src, i,src_r), dest_r);
27  }
28  if (rRing_has_Comp(dest_r) && rRing_has_Comp(src_r))
29  p_SetComp(dest, p_GetComp( src,src_r), dest_r);
30  p_Setm(dest, dest_r);
31 }
32 
33 #include <polys/prCopy.inc>
34 
35 /////////////////////////////////////////////////////////////////////////
36 poly prCopyR(poly p, ring src_r, ring dest_r)
37 {
38  poly res;
39  if (rField_has_simple_Alloc(dest_r))
40  res = pr_Copy_NoREqual_NSimple_Sort(p, src_r, dest_r);
41  else
42  res = pr_Copy_NoREqual_NoNSimple_Sort(p, src_r, dest_r);
43  p_Test(res, dest_r);
44  return res;
45 }
46 
47 poly prMapR(poly src, nMapFunc nMap, ring src_r, ring dest_r)
48 {
49  if (src==NULL) return NULL;
50  int _min = si_min(dest_r->N, src_r->N);
51 
52  spolyrec dest_s;
53 
54  poly dest = &dest_s;
55 
56  poly prev;
57  while (src != NULL)
58  {
59  pNext(dest) = (poly) p_Init(dest_r);
60  prev = dest;
61  pIter(dest);
62 
63  pSetCoeff0(dest, nMap(pGetCoeff(src),src_r->cf,dest_r->cf));
64  prCopyEvector(dest, dest_r, src, src_r, _min);
65  if (n_IsZero(pGetCoeff(dest),dest_r->cf))
66  {
67  p_LmDelete(&pNext(prev),dest_r);
68  }
69  pIter(src);
70  }
71  pNext(dest) = NULL;
72  dest = pNext(&dest_s);
73  dest=p_SortAdd(dest, dest_r);
74  p_Test(dest, dest_r);
75  return dest;
76 }
77 
78 poly prCopyR_NoSort(poly p, ring src_r, ring dest_r)
79 {
80  poly res;
81  if (rField_has_simple_Alloc(dest_r))
82  res = pr_Copy_NoREqual_NSimple_NoSort(p, src_r, dest_r);
83  else
84  res = pr_Copy_NoREqual_NoNSimple_NoSort(p, src_r, dest_r);
85  p_Test(res, dest_r);
86  return res;
87 }
88 
89 /////////////////////////////////////////////////////////////////////////
90 // prMove
91 poly prMoveR(poly &p, ring src_r, ring dest_r)
92 {
93  poly res;
94  if (rField_has_simple_Alloc(dest_r))
95  res = pr_Move_NoREqual_NSimple_Sort(p, src_r, dest_r);
96  else
97  res = pr_Move_NoREqual_NoNSimple_Sort(p, src_r, dest_r);
98  p_Test(res, dest_r);
99  return res;
100 }
101 
102 poly prMoveR_NoSort(poly &p, ring src_r, ring dest_r)
103 {
104  poly res;
105  if (rField_has_simple_Alloc(dest_r))
106  res = pr_Move_NoREqual_NSimple_NoSort(p, src_r, dest_r);
107  else
108  res = pr_Move_NoREqual_NoNSimple_NoSort(p, src_r, dest_r);
109  p_Test(res, dest_r);
110  return res;
111 }
112 
113 poly prShallowCopyR_NoSort(poly p, ring r, ring dest_r)
114 {
115  return pr_Copy_NoREqual_NSimple_NoSort(p, r, dest_r);
116 }
117 
118 poly prShallowCopyR(poly p, ring r, ring dest_r)
119 {
120  return pr_Copy_NoREqual_NSimple_Sort(p, r, dest_r);
121 }
122 
123 /////////////////////////////////////////////////////////////////////////
124 // prHead
125 typedef poly (*prCopyProc_t)(poly &src_p, ring src_r, ring dest_r);
126 
127 poly prHeadR(poly p, ring src_r, ring dest_r, prCopyProc_t prproc)
128 {
129  if (p == NULL) return NULL;
130  poly tail, head, q = p;
131  tail = pNext(p);
132  pNext(p) = NULL;
133  head = prproc(q, src_r, dest_r);
134  pNext(p) = tail;
135 
136  p_Test(p, src_r);
137  p_Test(head, dest_r);
138 
139  return head;
140 }
141 
142 poly prHeadR(poly p, ring src_r, ring dest_r)
143 {
144  prCopyProc_t prproc;
145  if (rField_has_simple_Alloc(dest_r))
146  prproc = pr_Copy_NoREqual_NSimple_NoSort;
147  else
148  prproc = pr_Copy_NoREqual_NoNSimple_NoSort;
149 
150  const poly res = prHeadR(p, src_r, dest_r, prproc);
151  p_Test(res, dest_r);
152  return res;
153 }
154 
155 /////////////////////////////////////////////////////////////////////////
156 /// Copy leading terms of id[i] via prHeeadR into dest_r
157 ideal idrHeadR(ideal id, ring r, ring dest_r)
158 {
159  if (id == NULL) return NULL;
160 
161  prCopyProc_t prproc = pr_Copy_NoREqual_NoNSimple_NoSort;
162  if (rField_has_simple_Alloc(dest_r))
163  prproc = pr_Copy_NoREqual_NSimple_NoSort;
164 
165  const int N = IDELEMS(id);
166  ideal res = idInit(N, id->rank);
167 
168  for (int i = N - 1; i >= 0; i--)
169  res->m[i] = prHeadR(id->m[i], r, dest_r, prproc); // !!!
170 
171  return res;
172 }
173 
174 
175 static inline ideal
176 idrCopy(ideal id, ring src_r, ring dest_r, prCopyProc_t prproc)
177 {
178  if (id == NULL) return NULL;
179  assume(src_r->cf==dest_r->cf);
180  poly p;
181  ideal res = idInit(IDELEMS(id), id->rank);
182  int i;
183 
184  for (i=IDELEMS(id)-1; i>=0; i--)
185  {
186  p = id->m[i];
187  res->m[i] = prproc(p, src_r, dest_r);
188  p_Test(res->m[i], dest_r);
189  }
190  return res;
191 }
192 
193 ideal idrCopyR(ideal id, ring src_r, ring dest_r)
194 {
195  assume(src_r->cf==dest_r->cf);
196  ideal res;
197  prCopyProc_t prproc;
198  if (rField_has_simple_Alloc(dest_r))
199  prproc = pr_Copy_NoREqual_NSimple_Sort;
200  else
201  prproc = pr_Copy_NoREqual_NoNSimple_Sort;
202  res = idrCopy(id, src_r, dest_r, prproc);
203  return res;
204 }
205 
206 ideal idrCopyR_NoSort(ideal id, ring src_r, ring dest_r)
207 {
208  assume(src_r->cf==dest_r->cf);
209  ideal res;
210  prCopyProc_t prproc;
211  if (rField_has_simple_Alloc(dest_r))
212  prproc = pr_Copy_NoREqual_NSimple_NoSort;
213  else
214  prproc = pr_Copy_NoREqual_NoNSimple_NoSort;
215  res = idrCopy(id, src_r, dest_r, prproc);
216  return res;
217 }
218 
219 /////////////////////////////////////////////////////////////////////////
220 // idrShallowCopy
221 ideal idrShallowCopyR(ideal id, ring src_r, ring dest_r)
222 {
223  return idrCopy(id, src_r, dest_r, pr_Copy_NoREqual_NSimple_Sort);
224 }
225 
226 ideal idrShallowCopyR_NoSort(ideal id, ring src_r, ring dest_r)
227 {
228  return idrCopy(id, src_r, dest_r, pr_Copy_NoREqual_NSimple_NoSort);
229 }
230 
231 /////////////////////////////////////////////////////////////////////////
232 // idrMove
233 static inline ideal
234 idrMove(ideal &id, ring src_r, ring dest_r, prCopyProc_t prproc)
235 {
236  assume(src_r->cf==dest_r->cf);
237  assume( prproc != NULL );
238 
239  if (id == NULL) return NULL;
240 
241  ideal res = id; id = NULL;
242 
243  for (int i = IDELEMS(res) - 1; i >= 0; i--)
244  res->m[i] = prproc(res->m[i], src_r, dest_r);
245 
246  return res;
247 }
248 
249 ideal idrMoveR(ideal &id, ring src_r, ring dest_r)
250 {
251  assume(src_r->cf==dest_r->cf);
252  prCopyProc_t prproc;
253  ideal res;
254  if (rField_has_simple_Alloc(dest_r))
255  prproc = pr_Move_NoREqual_NSimple_Sort;
256  else
257  prproc = pr_Move_NoREqual_NoNSimple_Sort;
258  res = idrMove(id, src_r, dest_r, prproc);
259  return res;
260 }
261 
262 ideal idrMoveR_NoSort(ideal &id, ring src_r, ring dest_r)
263 {
264  assume(src_r->cf==dest_r->cf);
265  prCopyProc_t prproc;
266  ideal res;
267  if (rField_has_simple_Alloc(dest_r))
268  prproc = pr_Move_NoREqual_NSimple_NoSort;
269  else
270  prproc = pr_Move_NoREqual_NoNSimple_NoSort;
271  res = idrMove(id, src_r, dest_r, prproc);
272  return res;
273 }
274 
275 
static BOOLEAN rField_has_simple_Alloc(const ring r)
Z/p, GF(p,n), R: nCopy, nNew, nDelete are dummies.
Definition: ring.h:541
poly prHeadR(poly p, ring src_r, ring dest_r, prCopyProc_t prproc)
Definition: prCopy.cc:127
poly prCopyR_NoSort(poly p, ring src_r, ring dest_r)
Definition: prCopy.cc:78
poly prCopyR(poly p, ring src_r, ring dest_r)
Definition: prCopy.cc:36
static ideal idrCopy(ideal id, ring src_r, ring dest_r, prCopyProc_t prproc)
Definition: prCopy.cc:176
static int si_min(const int a, const int b)
Definition: auxiliary.h:124
return P p
Definition: myNF.cc:203
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
Definition: p_polys.h:242
#define p_GetComp(p, r)
Definition: monomials.h:72
poly prMoveR(poly &p, ring src_r, ring dest_r)
Definition: prCopy.cc:91
ideal idrShallowCopyR(ideal id, ring src_r, ring dest_r)
Definition: prCopy.cc:221
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
poly prShallowCopyR_NoSort(poly p, ring r, ring dest_r)
Definition: prCopy.cc:113
ideal idrHeadR(ideal id, ring r, ring dest_r)
Copy leading terms of id[i] via prHeeadR into dest_r.
Definition: prCopy.cc:157
poly prMapR(poly src, nMapFunc nMap, ring src_r, ring dest_r)
Definition: prCopy.cc:47
#define pIter(p)
Definition: monomials.h:44
poly res
Definition: myNF.cc:322
static poly p_SortAdd(poly p, const ring r, BOOLEAN revert=FALSE)
Definition: p_polys.h:1142
ideal idrShallowCopyR_NoSort(ideal id, ring src_r, ring dest_r)
Definition: prCopy.cc:226
const ring r
Definition: syzextra.cc:208
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:49
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:464
static void prCopyEvector(poly dest, ring dest_r, poly src, ring src_r, int max)
Definition: prCopy.cc:20
static int max(int a, int b)
Definition: fast_mult.cc:264
#define assume(x)
Definition: mod2.h:403
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition: coeffs.h:73
ideal idrMoveR(ideal &id, ring src_r, ring dest_r)
Definition: prCopy.cc:249
All the auxiliary stuff.
int i
Definition: cfEzgcd.cc:123
#define IDELEMS(i)
Definition: simpleideals.h:24
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the zero element.
Definition: coeffs.h:468
#define p_Test(p, r)
Definition: p_polys.h:160
#define rRing_has_Comp(r)
Definition: monomials.h:274
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:38
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent : VarOffset encodes the position in p->exp
Definition: p_polys.h:483
#define NULL
Definition: omList.c:10
CanonicalForm head(const CanonicalForm &f)
poly prShallowCopyR(poly p, ring r, ring dest_r)
Definition: prCopy.cc:118
#define pNext(p)
Definition: monomials.h:43
ideal idrCopyR(ideal id, ring src_r, ring dest_r)
Definition: prCopy.cc:193
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:228
#define pSetCoeff0(p, n)
Definition: monomials.h:67
poly prMoveR_NoSort(poly &p, ring src_r, ring dest_r)
Definition: prCopy.cc:102
static void p_LmDelete(poly p, const ring r)
Definition: p_polys.h:706
polyrec * poly
Definition: hilb.h:10
poly(* prCopyProc_t)(poly &src_p, ring src_r, ring dest_r)
Definition: prCopy.cc:125
static poly p_Init(const ring r, omBin bin)
Definition: p_polys.h:1243
ideal idrCopyR_NoSort(ideal id, ring src_r, ring dest_r)
Definition: prCopy.cc:206
ideal idrMoveR_NoSort(ideal &id, ring src_r, ring dest_r)
Definition: prCopy.cc:262
static ideal idrMove(ideal &id, ring src_r, ring dest_r, prCopyProc_t prproc)
Definition: prCopy.cc:234