My Project
Typedefs | Functions
prCopy.h File Reference
#include "polys/monomials/ring.h"

Go to the source code of this file.

Typedefs

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

◆ nMapFunc

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

Definition at line 12 of file prCopy.h.

Function Documentation

◆ idrCopyR()

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

Definition at line 191 of file prCopy.cc.

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

◆ idrCopyR_NoSort()

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

Definition at line 204 of file prCopy.cc.

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}

◆ idrHeadR()

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

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

Definition at line 155 of file prCopy.cc.

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}
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:56
int i
Definition: cfEzgcd.cc:132
#define NULL
Definition: omList.c:12
poly prHeadR(poly p, ring src_r, ring dest_r, prCopyProc_t prproc)
Definition: prCopy.cc:125
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:35
#define IDELEMS(i)
Definition: simpleideals.h:23

◆ idrMoveR()

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

Definition at line 247 of file prCopy.cc.

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}
static ideal idrMove(ideal &id, ring src_r, ring dest_r, prCopyProc_t prproc)
Definition: prCopy.cc:232

◆ idrMoveR_NoSort()

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

Definition at line 260 of file prCopy.cc.

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}

◆ idrShallowCopyR()

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

Definition at line 219 of file prCopy.cc.

220{
221 return idrCopy(id, src_r, dest_r, pr_Copy_NoREqual_NSimple_Sort);
222}

◆ idrShallowCopyR_NoSort()

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

Definition at line 224 of file prCopy.cc.

225{
226 return idrCopy(id, src_r, dest_r, pr_Copy_NoREqual_NSimple_NoSort);
227}

◆ prCopyR()

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

Definition at line 34 of file prCopy.cc.

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}
int p
Definition: cfModGcd.cc:4077
#define p_Test(p, r)
Definition: p_polys.h:162

◆ prCopyR_NoSort()

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

Definition at line 76 of file prCopy.cc.

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}

◆ prHeadR()

poly prHeadR ( poly  p,
ring  r,
ring  dest_rg 
)

Definition at line 140 of file prCopy.cc.

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}

◆ prMapR()

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

Definition at line 45 of file prCopy.cc.

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}
static int si_min(const int a, const int b)
Definition: auxiliary.h:125
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff 'n' represents the zero element.
Definition: coeffs.h:464
#define pIter(p)
Definition: monomials.h:37
#define pNext(p)
Definition: monomials.h:36
#define pSetCoeff0(p, n)
Definition: monomials.h:59
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
static void p_LmDelete(poly p, const ring r)
Definition: p_polys.h:711
static poly p_Init(const ring r, omBin bin)
Definition: p_polys.h:1292
static poly p_SortAdd(poly p, const ring r, BOOLEAN revert=FALSE)
Definition: p_polys.h:1191
static void prCopyEvector(poly dest, ring dest_r, poly src, ring src_r, int max)
Definition: prCopy.cc:18

◆ prMoveR()

poly prMoveR ( poly &  p,
ring  r,
ring  dest_r 
)

Definition at line 89 of file prCopy.cc.

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}

◆ prMoveR_NoSort()

poly prMoveR_NoSort ( poly &  p,
ring  r,
ring  dest_r 
)

Definition at line 100 of file prCopy.cc.

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}

◆ prShallowCopyR()

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

Definition at line 116 of file prCopy.cc.

117{
118 return pr_Copy_NoREqual_NSimple_Sort(p, r, dest_r);
119}

◆ prShallowCopyR_NoSort()

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

Definition at line 111 of file prCopy.cc.

112{
113 return pr_Copy_NoREqual_NSimple_NoSort(p, r, dest_r);
114}