My Project
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 "polys/monomials/ring.h"
13 #include "coeffs/numbers.h"
14 #include "polys/monomials/ring.h"
15 #include "polys/simpleideals.h"
16 
17 static inline void
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 /////////////////////////////////////////////////////////////////////////
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 
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 
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
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 
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 
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 
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 
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 
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
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
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 
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 
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
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 
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
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 
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 
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 
All the auxiliary stuff.
static int si_min(const int a, const int b)
Definition: auxiliary.h:125
CanonicalForm head(const CanonicalForm &f)
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:56
int i
Definition: cfEzgcd.cc:132
int p
Definition: cfModGcd.cc:4080
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff 'n' represents the zero element.
Definition: coeffs.h:465
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition: coeffs.h:74
CanonicalForm res
Definition: facAbsFact.cc:60
static int max(int a, int b)
Definition: fast_mult.cc:264
#define assume(x)
Definition: mod2.h:387
#define p_GetComp(p, r)
Definition: monomials.h:64
#define pIter(p)
Definition: monomials.h:37
#define pNext(p)
Definition: monomials.h:36
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
Definition: monomials.h:44
#define pSetCoeff0(p, n)
Definition: monomials.h:59
#define rRing_has_Comp(r)
Definition: monomials.h:266
#define NULL
Definition: omList.c:12
static void p_LmDelete(poly p, const ring r)
Definition: p_polys.h:711
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent @Note: VarOffset encodes the position in p->exp
Definition: p_polys.h:488
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
Definition: p_polys.h:247
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:233
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent @Note: the integer VarOffset encodes:
Definition: p_polys.h:469
static poly p_Init(const ring r, omBin bin)
Definition: p_polys.h:1280
static poly p_SortAdd(poly p, const ring r, BOOLEAN revert=FALSE)
Definition: p_polys.h:1179
#define p_Test(p, r)
Definition: p_polys.h:162
poly prMoveR(poly &p, ring src_r, ring dest_r)
Definition: prCopy.cc:89
ideal idrMoveR(ideal &id, ring src_r, ring dest_r)
Definition: prCopy.cc:247
poly prHeadR(poly p, ring src_r, ring dest_r, prCopyProc_t prproc)
Definition: prCopy.cc:125
poly prMapR(poly src, nMapFunc nMap, ring src_r, ring dest_r)
Definition: prCopy.cc:45
static void prCopyEvector(poly dest, ring dest_r, poly src, ring src_r, int max)
Definition: prCopy.cc:18
ideal idrShallowCopyR_NoSort(ideal id, ring src_r, ring dest_r)
Definition: prCopy.cc:224
poly prCopyR(poly p, ring src_r, ring dest_r)
Definition: prCopy.cc:34
ideal idrCopyR(ideal id, ring src_r, ring dest_r)
Definition: prCopy.cc:191
poly prShallowCopyR(poly p, ring r, ring dest_r)
Definition: prCopy.cc:116
ideal idrMoveR_NoSort(ideal &id, ring src_r, ring dest_r)
Definition: prCopy.cc:260
static ideal idrMove(ideal &id, ring src_r, ring dest_r, prCopyProc_t prproc)
Definition: prCopy.cc:232
static ideal idrCopy(ideal id, ring src_r, ring dest_r, prCopyProc_t prproc)
Definition: prCopy.cc:174
poly prMoveR_NoSort(poly &p, ring src_r, ring dest_r)
Definition: prCopy.cc:100
poly prCopyR_NoSort(poly p, ring src_r, ring dest_r)
Definition: prCopy.cc:76
ideal idrCopyR_NoSort(ideal id, ring src_r, ring dest_r)
Definition: prCopy.cc:204
ideal idrHeadR(ideal id, ring r, ring dest_r)
Copy leading terms of id[i] via prHeeadR into dest_r.
Definition: prCopy.cc:155
ideal idrShallowCopyR(ideal id, ring src_r, ring dest_r)
Definition: prCopy.cc:219
poly(* prCopyProc_t)(poly &src_p, ring src_r, ring dest_r)
Definition: prCopy.cc:123
poly prShallowCopyR_NoSort(poly p, ring r, ring dest_r)
Definition: prCopy.cc:111
static BOOLEAN rField_has_simple_Alloc(const ring r)
Z/p, GF(p,n), R: nCopy, nNew, nDelete are dummies.
Definition: ring.h:557
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:35
#define IDELEMS(i)
Definition: simpleideals.h:23