Typedefs | Functions
prCopy.cc File Reference
#include <misc/auxiliary.h>
#include <omalloc/omalloc.h>
#include <polys/monomials/ring.h>
#include <polys/monomials/p_polys.h>
#include <coeffs/numbers.h>
#include <polys/simpleideals.h>
#include <polys/prCopy.inc>

Go to the source code of this file.

Typedefs

typedef poly(* prCopyProc_t) (poly &src_p, ring src_r, ring dest_r)
 

Functions

static void prCopyEvector (poly dest, ring dest_r, poly src, ring src_r, int max)
 
poly prCopyR (poly p, ring src_r, ring dest_r)
 
poly prMapR (poly src, nMapFunc nMap, ring src_r, ring dest_r)
 
poly prCopyR_NoSort (poly p, ring src_r, ring dest_r)
 
poly prMoveR (poly &p, ring src_r, ring dest_r)
 
poly prMoveR_NoSort (poly &p, ring src_r, ring dest_r)
 
poly prShallowCopyR_NoSort (poly p, ring r, ring dest_r)
 
poly prShallowCopyR (poly p, ring r, ring dest_r)
 
poly prHeadR (poly p, ring src_r, ring dest_r, prCopyProc_t prproc)
 
poly prHeadR (poly p, ring src_r, ring dest_r)
 
ideal idrHeadR (ideal id, ring r, ring dest_r)
 Copy leading terms of id[i] via prHeeadR into dest_r. More...
 
static ideal idrCopy (ideal id, ring src_r, ring dest_r, prCopyProc_t prproc)
 
ideal idrCopyR (ideal id, ring src_r, ring dest_r)
 
ideal idrCopyR_NoSort (ideal id, ring src_r, ring dest_r)
 
ideal idrShallowCopyR (ideal id, ring src_r, ring dest_r)
 
ideal idrShallowCopyR_NoSort (ideal id, ring src_r, ring dest_r)
 
static ideal idrMove (ideal &id, ring src_r, ring dest_r, prCopyProc_t prproc)
 
ideal idrMoveR (ideal &id, ring src_r, ring dest_r)
 
ideal idrMoveR_NoSort (ideal &id, ring src_r, ring dest_r)
 

Typedef Documentation

§ prCopyProc_t

typedef poly(* prCopyProc_t) (poly &src_p, ring src_r, ring dest_r)

Definition at line 125 of file prCopy.cc.

Function Documentation

§ idrCopy()

static ideal idrCopy ( ideal  id,
ring  src_r,
ring  dest_r,
prCopyProc_t  prproc 
)
inlinestatic

Definition at line 176 of file prCopy.cc.

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 }
return P p
Definition: myNF.cc:203
poly res
Definition: myNF.cc:322
#define assume(x)
Definition: mod2.h:403
int i
Definition: cfEzgcd.cc:123
#define IDELEMS(i)
Definition: simpleideals.h:24
#define p_Test(p, r)
Definition: p_polys.h:160
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:38
#define NULL
Definition: omList.c:10
polyrec * poly
Definition: hilb.h:10

§ idrCopyR()

ideal idrCopyR ( ideal  id,
ring  src_r,
ring  dest_r 
)

Definition at line 193 of file prCopy.cc.

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 }
static BOOLEAN rField_has_simple_Alloc(const ring r)
Z/p, GF(p,n), R: nCopy, nNew, nDelete are dummies.
Definition: ring.h:541
static ideal idrCopy(ideal id, ring src_r, ring dest_r, prCopyProc_t prproc)
Definition: prCopy.cc:176
poly res
Definition: myNF.cc:322
#define assume(x)
Definition: mod2.h:403
poly(* prCopyProc_t)(poly &src_p, ring src_r, ring dest_r)
Definition: prCopy.cc:125

§ idrCopyR_NoSort()

ideal idrCopyR_NoSort ( ideal  id,
ring  src_r,
ring  dest_r 
)

Definition at line 206 of file prCopy.cc.

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 }
static BOOLEAN rField_has_simple_Alloc(const ring r)
Z/p, GF(p,n), R: nCopy, nNew, nDelete are dummies.
Definition: ring.h:541
static ideal idrCopy(ideal id, ring src_r, ring dest_r, prCopyProc_t prproc)
Definition: prCopy.cc:176
poly res
Definition: myNF.cc:322
#define assume(x)
Definition: mod2.h:403
poly(* prCopyProc_t)(poly &src_p, ring src_r, ring dest_r)
Definition: prCopy.cc:125

§ idrHeadR()

ideal idrHeadR ( ideal  id,
ring  r,
ring  dest_r 
)

Copy leading terms of id[i] via prHeeadR into dest_r.

Definition at line 157 of file prCopy.cc.

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 }
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 res
Definition: myNF.cc:322
const ring r
Definition: syzextra.cc:208
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:49
int i
Definition: cfEzgcd.cc:123
#define IDELEMS(i)
Definition: simpleideals.h:24
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:38
#define NULL
Definition: omList.c:10
poly(* prCopyProc_t)(poly &src_p, ring src_r, ring dest_r)
Definition: prCopy.cc:125

§ idrMove()

static ideal idrMove ( ideal &  id,
ring  src_r,
ring  dest_r,
prCopyProc_t  prproc 
)
inlinestatic

Definition at line 234 of file prCopy.cc.

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 }
poly res
Definition: myNF.cc:322
#define assume(x)
Definition: mod2.h:403
int i
Definition: cfEzgcd.cc:123
#define IDELEMS(i)
Definition: simpleideals.h:24
#define NULL
Definition: omList.c:10

§ idrMoveR()

ideal idrMoveR ( ideal &  id,
ring  src_r,
ring  dest_r 
)

Definition at line 249 of file prCopy.cc.

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 }
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 res
Definition: myNF.cc:322
#define assume(x)
Definition: mod2.h:403
poly(* prCopyProc_t)(poly &src_p, ring src_r, ring dest_r)
Definition: prCopy.cc:125
static ideal idrMove(ideal &id, ring src_r, ring dest_r, prCopyProc_t prproc)
Definition: prCopy.cc:234

§ idrMoveR_NoSort()

ideal idrMoveR_NoSort ( ideal &  id,
ring  src_r,
ring  dest_r 
)

Definition at line 262 of file prCopy.cc.

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 }
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 res
Definition: myNF.cc:322
#define assume(x)
Definition: mod2.h:403
poly(* prCopyProc_t)(poly &src_p, ring src_r, ring dest_r)
Definition: prCopy.cc:125
static ideal idrMove(ideal &id, ring src_r, ring dest_r, prCopyProc_t prproc)
Definition: prCopy.cc:234

§ idrShallowCopyR()

ideal idrShallowCopyR ( ideal  id,
ring  src_r,
ring  dest_r 
)

Definition at line 221 of file prCopy.cc.

222 {
223  return idrCopy(id, src_r, dest_r, pr_Copy_NoREqual_NSimple_Sort);
224 }
static ideal idrCopy(ideal id, ring src_r, ring dest_r, prCopyProc_t prproc)
Definition: prCopy.cc:176

§ idrShallowCopyR_NoSort()

ideal idrShallowCopyR_NoSort ( ideal  id,
ring  src_r,
ring  dest_r 
)

Definition at line 226 of file prCopy.cc.

227 {
228  return idrCopy(id, src_r, dest_r, pr_Copy_NoREqual_NSimple_NoSort);
229 }
static ideal idrCopy(ideal id, ring src_r, ring dest_r, prCopyProc_t prproc)
Definition: prCopy.cc:176

§ prCopyEvector()

static void prCopyEvector ( poly  dest,
ring  dest_r,
poly  src,
ring  src_r,
int  max 
)
inlinestatic

Definition at line 20 of file prCopy.cc.

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 }
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
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 int max(int a, int b)
Definition: fast_mult.cc:264
int i
Definition: cfEzgcd.cc:123
#define rRing_has_Comp(r)
Definition: monomials.h:274
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
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:228

§ prCopyR()

poly prCopyR ( poly  p,
ring  src_r,
ring  dest_r 
)

Definition at line 36 of file prCopy.cc.

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 }
static BOOLEAN rField_has_simple_Alloc(const ring r)
Z/p, GF(p,n), R: nCopy, nNew, nDelete are dummies.
Definition: ring.h:541
return P p
Definition: myNF.cc:203
poly res
Definition: myNF.cc:322
#define p_Test(p, r)
Definition: p_polys.h:160
polyrec * poly
Definition: hilb.h:10

§ prCopyR_NoSort()

poly prCopyR_NoSort ( poly  p,
ring  src_r,
ring  dest_r 
)

Definition at line 78 of file prCopy.cc.

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 }
static BOOLEAN rField_has_simple_Alloc(const ring r)
Z/p, GF(p,n), R: nCopy, nNew, nDelete are dummies.
Definition: ring.h:541
return P p
Definition: myNF.cc:203
poly res
Definition: myNF.cc:322
#define p_Test(p, r)
Definition: p_polys.h:160
polyrec * poly
Definition: hilb.h:10

§ prHeadR() [1/2]

poly prHeadR ( poly  p,
ring  src_r,
ring  dest_r,
prCopyProc_t  prproc 
)

Definition at line 127 of file prCopy.cc.

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 }
return P p
Definition: myNF.cc:203
#define p_Test(p, r)
Definition: p_polys.h:160
#define NULL
Definition: omList.c:10
CanonicalForm head(const CanonicalForm &f)
#define pNext(p)
Definition: monomials.h:43
polyrec * poly
Definition: hilb.h:10

§ prHeadR() [2/2]

poly prHeadR ( poly  p,
ring  src_r,
ring  dest_r 
)

Definition at line 142 of file prCopy.cc.

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 }
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
return P p
Definition: myNF.cc:203
poly res
Definition: myNF.cc:322
#define p_Test(p, r)
Definition: p_polys.h:160
polyrec * poly
Definition: hilb.h:10
poly(* prCopyProc_t)(poly &src_p, ring src_r, ring dest_r)
Definition: prCopy.cc:125

§ prMapR()

poly prMapR ( poly  src,
nMapFunc  nMap,
ring  src_r,
ring  dest_r 
)

Definition at line 47 of file prCopy.cc.

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 }
static int si_min(const int a, const int b)
Definition: auxiliary.h:124
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
#define pIter(p)
Definition: monomials.h:44
static poly p_SortAdd(poly p, const ring r, BOOLEAN revert=FALSE)
Definition: p_polys.h:1142
static void prCopyEvector(poly dest, ring dest_r, poly src, ring src_r, int max)
Definition: prCopy.cc:20
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 NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
#define pSetCoeff0(p, n)
Definition: monomials.h:67
static void p_LmDelete(poly p, const ring r)
Definition: p_polys.h:706
polyrec * poly
Definition: hilb.h:10
static poly p_Init(const ring r, omBin bin)
Definition: p_polys.h:1243

§ prMoveR()

poly prMoveR ( poly p,
ring  src_r,
ring  dest_r 
)

Definition at line 91 of file prCopy.cc.

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 }
static BOOLEAN rField_has_simple_Alloc(const ring r)
Z/p, GF(p,n), R: nCopy, nNew, nDelete are dummies.
Definition: ring.h:541
return P p
Definition: myNF.cc:203
poly res
Definition: myNF.cc:322
#define p_Test(p, r)
Definition: p_polys.h:160
polyrec * poly
Definition: hilb.h:10

§ prMoveR_NoSort()

poly prMoveR_NoSort ( poly p,
ring  src_r,
ring  dest_r 
)

Definition at line 102 of file prCopy.cc.

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 }
static BOOLEAN rField_has_simple_Alloc(const ring r)
Z/p, GF(p,n), R: nCopy, nNew, nDelete are dummies.
Definition: ring.h:541
return P p
Definition: myNF.cc:203
poly res
Definition: myNF.cc:322
#define p_Test(p, r)
Definition: p_polys.h:160
polyrec * poly
Definition: hilb.h:10

§ prShallowCopyR()

poly prShallowCopyR ( poly  p,
ring  r,
ring  dest_r 
)

Definition at line 118 of file prCopy.cc.

119 {
120  return pr_Copy_NoREqual_NSimple_Sort(p, r, dest_r);
121 }
return P p
Definition: myNF.cc:203
const ring r
Definition: syzextra.cc:208

§ prShallowCopyR_NoSort()

poly prShallowCopyR_NoSort ( poly  p,
ring  r,
ring  dest_r 
)

Definition at line 113 of file prCopy.cc.

114 {
115  return pr_Copy_NoREqual_NSimple_NoSort(p, r, dest_r);
116 }
return P p
Definition: myNF.cc:203
const ring r
Definition: syzextra.cc:208