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