Typedefs | Functions
prCopy.h File Reference

Go to the source code of this file.

Typedefs

typedef polyrec * poly
 
typedef number(* nMapFunc) (number a, const coeffs src, const coeffs dst)
 

Functions

poly prMoveR_NoSort (poly &p, ring r, ring dest_r)
 
poly prMoveR (poly &p, ring r, ring dest_r)
 
poly prCopyR_NoSort (poly p, ring r, ring dest_r)
 
poly prCopyR (poly p, ring r, ring dest_r)
 
poly prShallowCopyR_NoSort (poly p, ring r, ring dest_t)
 
poly prShallowCopyR (poly p, ring r, ring dest_t)
 
poly prHeadR (poly p, ring r, ring dest_rg)
 
ideal idrMoveR_NoSort (ideal &id, ring r, ring dest_r)
 
ideal idrMoveR (ideal &id, ring r, ring dest_r)
 
ideal idrCopyR_NoSort (ideal id, ring r, ring dest_r)
 
ideal idrCopyR (ideal id, ring r, ring dest_r)
 
ideal idrShallowCopyR_NoSort (ideal id, ring r, ring dest_r)
 
ideal idrShallowCopyR (ideal id, ring 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...
 
poly prMapR (poly src, nMapFunc nMap, ring src_r, ring dest_r)
 

Typedef Documentation

typedef number(* nMapFunc) (number a, const coeffs src, const coeffs dst)

Definition at line 17 of file prCopy.h.

typedef polyrec* poly

Definition at line 10 of file prCopy.h.

Function Documentation

ideal idrCopyR ( ideal  id,
ring  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:498
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:405
poly(* prCopyProc_t)(poly &src_p, ring src_r, ring dest_r)
Definition: prCopy.cc:125
ideal idrCopyR_NoSort ( ideal  id,
ring  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:498
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:405
poly(* prCopyProc_t)(poly &src_p, ring src_r, ring dest_r)
Definition: prCopy.cc:125
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:498
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
ideal idrMoveR ( ideal &  id,
ring  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:498
poly res
Definition: myNF.cc:322
#define assume(x)
Definition: mod2.h:405
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
ideal idrMoveR_NoSort ( ideal &  id,
ring  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:498
poly res
Definition: myNF.cc:322
#define assume(x)
Definition: mod2.h:405
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
ideal idrShallowCopyR ( ideal  id,
ring  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
ideal idrShallowCopyR_NoSort ( ideal  id,
ring  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
poly prCopyR ( poly  p,
ring  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:498
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 prCopyR_NoSort ( poly  p,
ring  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:498
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 prHeadR ( poly  p,
ring  r,
ring  dest_rg 
)

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:498
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
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:167
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:1148
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 'n' represents the zero element.
Definition: coeffs.h:465
#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:1249
poly prMoveR ( poly p,
ring  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:498
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 prMoveR_NoSort ( poly p,
ring  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:498
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 prShallowCopyR ( poly  p,
ring  r,
ring  dest_t 
)

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
poly prShallowCopyR_NoSort ( poly  p,
ring  r,
ring  dest_t 
)

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