My Project  UNKNOWN_GIT_VERSION
polys.h
Go to the documentation of this file.
1 /*! \file kernel/polys.h Compatiblity layer for legacy polynomial operations (over @ref currRing)
2 
3  Macro defines for legacy polynomial operations used in @ref kernel_page and @ref singular_page.
4  They take no ring argument since they work with @ref currRing by default.
5  Notice that they have different prefix: `p` instead of `p_`.
6 
7  See also related global ring variable and the correct ring changeing routine:
8  - \ref currRing
9  - \ref rChangeCurrRing
10 */
11 
12 #ifndef POLYS_H
13 #define POLYS_H
14 
15 #include "polys/monomials/ring.h"
17 
18 extern ring currRing;
19 void rChangeCurrRing(ring r);
20 
21 #include "coeffs/numbers.h"
22 
23 /***************************************************************
24  *
25  * Primitives for accessing and setting fields of a poly
26  * poly must be != NULL
27  *
28  ***************************************************************/
29 
30 /// deletes old coeff before setting the new one
31 #define pSetCoeff(p,n) p_SetCoeff(p,n,currRing)
32 
33 /// Order
34 #define pGetOrder(p) p_GetOrder(p, currRing)
35 
36 /// Component
37 #define pGetComp(p) (int)__p_GetComp(p, currRing)
38 #define pSetComp(p,v) p_SetComp(p,v, currRing)
39 
40 /// Exponent
41 #define pGetExp(p,i) p_GetExp(p, i, currRing)
42 #define pSetExp(p,i,v) p_SetExp(p, i, v, currRing)
43 #define pIncrExp(p,i) p_IncrExp(p,i, currRing)
44 #define pDecrExp(p,i) p_DecrExp(p,i, currRing)
45 #define pAddExp(p,i,v) p_AddExp(p,i,v, currRing)
46 #define pSubExp(p,i,v) p_SubExp(p,i,v, currRing)
47 #define pMultExp(p,i,v) p_MultExp(p,i,v, currRing)
48 #define pGetExpSum(p1, p2, i) p_GetExpSum(p1, p2, i, currRing)
49 #define pGetExpDiff(p1, p2, i) p_GetExpDiff(p1, p2, i, currRing)
50 
51 
52 /***************************************************************
53  *
54  * Allocation/Initalization/Deletion
55  * except for pHead, all polys must be != NULL
56  *
57  ***************************************************************/
58 /// allocates the space for a new monomial -- no initialization !!!
59 #define pNew() p_New(currRing)
60 /// allocates a new monomial and initializes everything to 0
61 #define pInit() p_Init(currRing,currRing->PolyBin)
62 /// like pInit, except that expvector is initialized to that of p,
63 /// p must be != NULL
64 #define pLmInit(p) p_LmInit(p, currRing)
65 /// returns newly allocated copy of Lm(p), coef is copied, next=NULL,
66 /// p might be NULL
67 #define pHead(p) p_Head(p, currRing)
68 /// frees the space of the monomial m, assumes m != NULL
69 /// coef is not freed, m is not advanced
70 static inline void pLmFree(poly p) {p_LmFree(p, currRing);}
71 /// like pLmFree, but advances p
72 static inline void pLmFree(poly *p) {p_LmFree(p, currRing);}
73 /// assumes p != NULL, deletes p, returns pNext(p)
74 #define pLmFreeAndNext(p) p_LmFreeAndNext(p, currRing)
75 /// assume p != NULL, deletes Lm(p)->coef and Lm(p)
76 #define pLmDelete(p) p_LmDelete(p, currRing)
77 /// like pLmDelete, returns pNext(p)
78 #define pLmDeleteAndNext(p) p_LmDeleteAndNext(p, currRing)
79 
80 /***************************************************************
81  *
82  * Operation on ExpVectors: assumes polys != NULL
83  *
84  ***************************************************************/
85 
86 #define pExpVectorCopy(d_p, s_p) p_ExpVectorCopy(d_p, s_p, currRing)
87 #define pExpVectorAdd(p1, p2) p_ExpVectorAdd(p1, p2, currRing)
88 #define pExpVectorSub(p1, p2) p_ExpVectorSub(p1, p2, currRing)
89 #define pExpVectorAddSub(p1, p2, p3) p_ExpVectorAddSub(p1, p2, p3, currRing)
90 #define pExpVectorSum(pr, p1, p2) p_ExpVectorSum(pr, p1, p2, currRing)
91 #define pExpVectorDiff(pr, p1, p2) p_ExpVectorDiff(pr, p1, p2, currRing)
92 
93 /// Gets a copy of (resp. set) the exponent vector, where e is assumed
94 /// to point to (r->N +1)*sizeof(long) memory. Exponents are
95 /// filled in as follows: comp, e_1, .., e_n
96 #define pGetExpV(p, e) p_GetExpV(p, e, currRing)
97 #define pSetExpV(p, e) p_SetExpV(p, e, currRing)
98 
99 /***************************************************************
100  *
101  * Comparisons: they are all done without regarding coeffs
102  *
103  ***************************************************************/
104 /// returns 0|1|-1 if p=q|p>q|p<q w.r.t monomial ordering
105 #define pLmCmp(p,q) p_LmCmp(p,q,currRing)
106 /// executes axtionE|actionG|actionS if p=q|p>q|p<q w.r.t monomial ordering
107 /// action should be a "goto ..."
108 #define pLmCmpAction(p,q, actionE, actionG, actionS) \
109  _p_LmCmpAction(p,q,currRing, actionE, actionG,actionS)
110 
111 #define pLmEqual(p1, p2) p_ExpVectorEqual(p1, p2, currRing)
112 
113 /// pCmp: args may be NULL
114 /// returns: (p2==NULL ? 1 : (p1 == NULL ? -1 : p_LmCmp(p1, p2)))
115 #define pCmp(p1, p2) p_Cmp(p1, p2, currRing)
116 
117 /***************************************************************
118  *
119  * Comparisons: these are all done regarding coeffs
120  *
121  ***************************************************************/
122 
123 #define pLtCmp(p,q) p_LtCmp(p,q,currRing)
124 #define pLtCmpNoAbs(p,q) p_LtCmpNoAbs(p,q,currRing)
125 #define pLtCmpOrdSgnDiffM(p,q) p_LtCmpOrdSgnDiffM(p,q,currRing)
126 #define pLtCmpOrdSgnDiffP(p,q) p_LtCmpOrdSgnDiffP(p,q,currRing)
127 #define pLtCmpOrdSgnEqM(p,q) p_LtCmpOrdSgnEqM(p,q,currRing)
128 #define pLtCmpOrdSgnEqP(p,q) p_LtCmpOrdSgnEqP(p,q,currRing)
129 
130 /***************************************************************
131  *
132  * Divisiblity tests, args must be != NULL, except for
133  * pDivisbleBy
134  *
135  ***************************************************************/
136 /// returns TRUE, if leading monom of a divides leading monom of b
137 /// i.e., if there exists a expvector c > 0, s.t. b = a + c;
138 #define pDivisibleBy(a, b) p_DivisibleBy(a,b,currRing)
139 /// like pDivisibleBy, except that it is assumed that a!=NULL, b!=NULL
140 #define pLmDivisibleBy(a,b) p_LmDivisibleBy(a,b,currRing)
141 /// like pLmDivisibleBy, does not check components
142 #define pLmDivisibleByNoComp(a, b) p_LmDivisibleByNoComp(a,b,currRing)
143 /// Divisibility tests based on Short Exponent vectors
144 /// sev_a == pGetShortExpVector(a)
145 /// not_sev_b == ~ pGetShortExpVector(b)
146 #define pLmShortDivisibleBy(a, sev_a, b, not_sev_b) \
147  p_LmShortDivisibleBy(a, sev_a, b, not_sev_b, currRing)
148 #define pLmRingShortDivisibleBy(a, sev_a, b, not_sev_b) \
149  p_LmRingShortDivisibleBy(a, sev_a, b, not_sev_b, currRing)
150 /// returns the "Short Exponent Vector" -- used to speed up divisibility
151 /// tests (see polys-impl.cc )
152 #define pGetShortExpVector(a) p_GetShortExpVector(a, currRing)
153 
154 #ifdef HAVE_RINGS
155 /// divisibility check over ground ring (which may contain zero divisors);
156 /// TRUE iff LT(f) divides LT(g), i.e., LT(f)*c*m = LT(g), for some
157 /// coefficient c and some monomial m;
158 /// does not take components into account */
159 #define pDivisibleByRingCase(f,g) p_DivisibleByRingCase(f,g,currRing)
160 #endif
161 
162 /// polynomial division, ignoring the rest
163 /// via singclap_pdivide resp. idLift
164 /// destroyes a,b
165 poly p_Divide(poly a, poly b, const ring r);
166 
167 /// polynomial gcd
168 /// via singclap_gcd_r resp. idSyzygies
169 /// destroys f and g
170 poly singclap_gcd ( poly f, poly g, const ring r );
171 
172 
173 
174 /***************************************************************
175  *
176  * Copying/Deletion of polys: args may be NULL
177  *
178  ***************************************************************/
179 /// return a copy of the poly
180 #define pCopy(p) p_Copy(p, currRing)
181 #define pDelete(p_ptr) p_Delete(p_ptr, currRing)
182 
183 /***************************************************************
184  *
185  * Copying/Deletion of polys: args may be NULL
186  * - p/q as arg mean a poly
187  * - m a monomial
188  * - n a number
189  * - pp (resp. qq, mm, nn) means arg is constant
190  * - p (resp, q, m, n) means arg is destroyed
191  *
192  ***************************************************************/
193 #define pNeg(p) p_Neg(p, currRing)
194 #define ppMult_nn(p, n) pp_Mult_nn(p, n, currRing)
195 #define pMult_nn(p, n) p_Mult_nn(p, n, currRing)
196 #define ppMult_mm(p, m) pp_Mult_mm(p, m, currRing)
197 #define pMult_mm(p, m) p_Mult_mm(p, m, currRing)
198 #define pAdd(p, q) p_Add_q(p, q, currRing)
199 #define pPower(p, q) p_Power(p, q, currRing)
200 #define pMinus_mm_Mult_qq(p, m, q) p_Minus_mm_Mult_qq(p, m, q, currRing)
201 #define pPlus_mm_Mult_qq(p, m, q) p_Plus_mm_Mult_qq(p, m, q, currRing)
202 #define pMult(p, q) p_Mult_q(p, q, currRing)
203 #define ppMult_qq(p, q) pp_Mult_qq(p, q, currRing)
204 // p*Coeff(m) for such monomials pm of p, for which m is divisble by pm
205 #define ppMult_Coeff_mm_DivSelect(p, m) pp_Mult_Coeff_mm_DivSelect(p, m, currRing)
206 /*************************************************************************
207  *
208  * Sort routines
209  *
210  *************************************************************************/
211 /// sorts p, assumes all monomials in p are different
212 #define pSortMerger(p) p_SortMerge(p, currRing)
213 #define pSort(p) p_SortMerge(p, currRing)
214 
215 /// sorts p, p may have equal monomials
216 #define pSortAdd(p) p_SortAdd(p, currRing)
217 
218 
219 /// Assume: If considerd only as poly in any component of p
220 /// (say, monomials of other components of p are set to 0),
221 /// then p is already sorted correctly
222 #define pSortCompCorrect(p) pSort(p)
223 
224 /***************************************************************
225  *
226  * Predicates on polys/Lm's
227  *
228  ***************************************************************/
229 /// return true if all p is eihter NULL, or if all exponents
230 /// of p are 0 and Comp of p is zero
231 #define pIsConstantComp(p) p_IsConstantComp(p, currRing)
232 /// like above, except that Comp might be != 0
233 #define pIsConstant(p) p_IsConstant(p,currRing)
234 /// return true if the Lm is a constant <>0
235 #define pIsUnit(p) p_IsUnit(p,currRing)
236 /// like above, except that p must be != NULL
237 #define pLmIsConstantComp(p) p_LmIsConstantComp(p, currRing)
238 #define pLmIsConstant(p) p_LmIsConstant(p,currRing)
239 
240 /// return TRUE if all monomials of p are constant
241 #define pIsConstantPoly(p) p_IsConstantPoly(p, currRing)
242 
243 #define pIsPurePower(p) p_IsPurePower(p, currRing)
244 #define pIsUnivariate(p) p_IsUnivariate(p, currRing)
245 #define pIsVector(p) (pGetComp(p)>0)
246 #define pGetVariables(p,e) p_GetVariables(p, e, currRing)
247 
248 /***************************************************************
249  *
250  * Old stuff
251  *
252  ***************************************************************/
253 
254 typedef poly* polyset;
255 
256 /*-------------predicate on polys ----------------------*/
257 #define pHasNotCF(p1,p2) p_HasNotCF(p1,p2,currRing)
258  /*has no common factor ?*/
259 #define pSplit(p,r) p_Split(p,r)
260  /*p => IN(p), r => REST(p) */
261 
262 
263 
264 /*-----------the ordering of monomials:-------------*/
265 #define pSetm(p) p_Setm(p, currRing)
266 /// TODO:
267 #define pSetmComp(p) p_Setm(p, currRing)
268 
269 /***************************************************************
270  *
271  * Degree stuff -- see p_polys.cc for explainations
272  *
273  ***************************************************************/
274 #define pWeight(i) p_Weight(i,currRing)
275 
276 static inline long pTotaldegree(poly p) { return p_Totaldegree(p,currRing); }
277 #define pWTotaldegree(p) p_WTotaldegree(p,currRing)
278 #define pWDegree(p) p_WDegree(p,currRing)
279 
280 /*-------------operations on polynomials:------------*/
281 #define pSub(a,b) p_Sub(a,b,currRing)
282 
283 #define pmInit(a,b) p_mInit(a,b,currRing)
284 
285 /* ----------------- define to enable new p_procs -----*/
286 
287 #define pMDivide(a,b) p_MDivide(a,b,currRing)
288 #define pDivideM(a,b) p_DivideM(a,b,currRing)
289 #define pLcm(a,b,m) p_Lcm(a,b,m,currRing)
290 #define pDiff(a,b) p_Diff(a,b,currRing)
291 #define pDiffOp(a,b,m) p_DiffOp(a,b,m,currRing)
292 
293 #define pMaxComp(p) p_MaxComp(p, currRing)
294 #define pMinComp(p) p_MinComp(p, currRing)
295 
296 #define pOneComp(p) p_OneComp(p, currRing)
297 #define pSetCompP(a,i) p_SetCompP(a, i, currRing)
298 
299 // let's inline those, so that we can call them from the debugger
300 inline char* pString(poly p) {return p_String(p, currRing, currRing);}
301 inline void pString0(poly p) {p_String0(p, currRing, currRing);}
302 inline void pWrite(poly p) {p_Write(p, currRing, currRing);}
303 inline void pWrite0(poly p) {p_Write0(p, currRing, currRing);}
304 inline void wrp(poly p) {p_wrp(p, currRing, currRing);}
305 
306 #define pISet(i) p_ISet(i,currRing)
307 #define pNSet(n) p_NSet(n,currRing)
308 
309 #define pOne() p_One(currRing)
310 
311 #define pNormalize(p) p_Normalize(p,currRing)
312 #define pSize(p) p_Size(p,currRing)
313 
314 
315 /// homogenizes p by multiplying certain powers of the varnum-th variable
316 #define pHomogen(p,varnum) p_Homogen(p,varnum,currRing)
317 
318 BOOLEAN pIsHomogeneous (poly p);
319 // // replaces the maximal powers of the leading monomial of p2 in p1 by
320 // // the same powers of n, utility for dehomogenization
321 // #define pDehomogen(p1,p2,n) p_Dehomgen(p1,p2,n,currRing)
322 // #define pIsHomogen(p) p_IsHomggen(p,currRing)
323 #define pIsHomogen(p) p_IsHomogen(p,currRing)
324 
325 /*BOOLEAN pVectorHasUnitM(poly p, int * k);*/
326 #define pVectorHasUnitB(p,k) p_VectorHasUnitB(p,k,currRing)
327 #define pVectorHasUnit(p,k,l) p_VectorHasUnit(p,k,l,currRing)
328 #define pTakeOutComp1(p,k) p_TakeOutComp1(p,k,currRing)
329 
330 /// Splits *p into two polys: *q which consists of all monoms with
331 /// component == comp and *p of all other monoms *lq == pLength(*q)
332 /// On return all components pf *q == 0
333 inline void pTakeOutComp(poly *p, long comp, poly *q, int *lq, const ring R = currRing)
334 {
335  return p_TakeOutComp(p, comp, q, lq, R);
336 }
337 
338 
339 /// This is something weird -- Don't use it, unless you know what you are doing
340 inline poly pTakeOutComp(poly * p, int k, const ring R = currRing)
341 {
342  return p_TakeOutComp(p, k, R);
343 }
344 
345 /* old spielwiese
346 #define pTakeOutComp(p,k,q,lq) p_TakeOutComp(p,k,q,lq,currRing)
347 
348 // Similar to pTakeOutComp, except that only those components are
349 // taken out whose Order == order
350 // ASSUME: monomial ordering is Order compatible, i.e., if m1, m2 Monoms then
351 // m1 >= m2 ==> pGetOrder(m1) >= pGetOrder(m2)
352 #define pDecrOrdTakeOutComp(p,c,o,q,lq) p_DecrOrdTakeOutComp(p,c,o,q,lq,currRing)
353 */
354 void pSetPolyComp(poly p, int comp);
355 #define pDeleteComp(p,k) p_DeleteComp(p,k,currRing)
356 
357 inline void pNorm(poly p, const ring R = currRing){ p_Norm(p, R); }
358 
359 
360 #define pSubst(p,n,e) p_Subst(p,n,e,currRing)
361 #define ppJet(p,m) pp_Jet(p,m,currRing)
362 #define pJet(p,m) p_Jet(p,m,currRing)
363 #define ppJetW(p,m,iv) pp_JetW(p,m,iv,currRing)
364 #define pJetW(p,m,iv) p_JetW(p,m,iv,currRing)
365 #define pMinDeg(p,w) p_MinDeg(p,w,currRing)
366 #define pSeries(n,p,u,w) p_Series(n,p,u,w,currRing)
367 // maximum weigthed degree of all monomials of p, w is indexed from
368 // 1..pVariables
369 
370 /// Deprecated: only for compatibility with older code!
371 #define pDegW(p,w) p_DegW(p,w,currRing)
372 
373 /*-----------type conversions ----------------------------*/
374 // void pVec2Polys(poly v, polyset *p, int *len);
375 #define pVar(m) p_Var(m,currRing)
376 
377 /*-----------specials for spoly-computations--------------*/
378 
379 /// Returns TRUE if
380 /// * LM(p) | LM(lcm)
381 /// * LC(p) | LC(lcm) only if ring
382 /// * Exists i, j:
383 /// * LE(p, i) != LE(lcm, i)
384 /// * LE(p1, i) != LE(lcm, i) ==> LCM(p1, p) != lcm
385 /// * LE(p, j) != LE(lcm, j)
386 /// * LE(p2, j) != LE(lcm, j) ==> LCM(p2, p) != lcm
387 BOOLEAN pCompareChain (poly p, poly p1, poly p2, poly lcm, const ring R = currRing);
388 
389 #ifdef HAVE_RATGRING
390 BOOLEAN pCompareChainPart (poly p, poly p1, poly p2, poly lcm, const ring R = currRing);
391 #endif
392 
393 
394 #define pEqualPolys(p1,p2) p_EqualPolys(p1,p2,currRing)
395 
396 
397 
398 /// returns the length of a polynomial (numbers of monomials)
399 /// respect syzComp
400 static inline poly pLast(poly a, int &length) { return p_Last (a, length, currRing); }
401 static inline poly pLast(poly a) { int l; return pLast(a, l); }
402 
403 /***************************************************************
404  *
405  * PDEBUG stuff
406  *
407  ***************************************************************/
408 #ifdef PDEBUG
409 #define pTest(p) _p_Test(p, currRing, PDEBUG)
410 #define pLmTest(p) _p_LmTest(p, currRing, PDEBUG)
411 
412 #else // ! PDEBUG
413 
414 #define pTest(p) do {} while (0)
415 #define pLmTest(p) do {} while (0)
416 #endif
417 
418 #endif // POLYS_H
pTakeOutComp
void pTakeOutComp(poly *p, long comp, poly *q, int *lq, const ring R=currRing)
Splits *p into two polys: *q which consists of all monoms with component == comp and *p of all other ...
Definition: polys.h:333
singclap_gcd
poly singclap_gcd(poly f, poly g, const ring r)
polynomial gcd via singclap_gcd_r resp. idSyzygies destroys f and g
Definition: polys.cc:165
f
FILE * f
Definition: checklibs.c:9
pNorm
void pNorm(poly p, const ring R=currRing)
Definition: polys.h:357
pWrite0
void pWrite0(poly p)
Definition: polys.h:303
k
int k
Definition: cfEzgcd.cc:92
p_Write0
void p_Write0(poly p, ring lmRing, ring tailRing)
Definition: polys0.cc:194
pLmFree
static void pLmFree(poly p)
frees the space of the monomial m, assumes m != NULL coef is not freed, m is not advanced
Definition: polys.h:70
pIsHomogeneous
BOOLEAN pIsHomogeneous(poly p)
lq
Definition: lq.h:39
polyset
poly * polyset
Definition: polys.h:254
pString0
void pString0(poly p)
Definition: polys.h:301
pCompareChainPart
BOOLEAN pCompareChainPart(poly p, poly p1, poly p2, poly lcm, const ring R=currRing)
Definition: kpolys.cc:74
length
static BOOLEAN length(leftv result, leftv arg)
Definition: interval.cc:263
pSetPolyComp
void pSetPolyComp(poly p, int comp)
g
g
Definition: cfModGcd.cc:4031
p_wrp
void p_wrp(poly p, ring lmRing, ring tailRing)
Definition: polys0.cc:235
pString
char * pString(poly p)
Definition: polys.h:300
currRing
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
b
CanonicalForm b
Definition: cfModGcd.cc:4044
pTotaldegree
static long pTotaldegree(poly p)
Definition: polys.h:276
BOOLEAN
int BOOLEAN
Definition: auxiliary.h:85
pCompareChain
BOOLEAN pCompareChain(poly p, poly p1, poly p2, poly lcm, const ring R=currRing)
Returns TRUE if.
Definition: kpolys.cc:20
p_String
char * p_String(poly p, ring lmRing, ring tailRing)
Definition: polys0.cc:184
pLast
static poly pLast(poly a, int &length)
returns the length of a polynomial (numbers of monomials) respect syzComp
Definition: polys.h:400
p_String0
void p_String0(poly p, ring lmRing, ring tailRing)
print p according to ShortOut in lmRing & tailRing
Definition: polys0.cc:134
p_Write
void p_Write(poly p, ring lmRing, ring tailRing)
Definition: polys0.cc:204
p_polys.h
p_Last
poly p_Last(const poly p, int &l, const ring r)
Definition: p_polys.cc:4519
p_LmFree
static void p_LmFree(poly p, ring)
Definition: p_polys.h:684
ring.h
rChangeCurrRing
void rChangeCurrRing(ring r)
Definition: polys.cc:15
p_TakeOutComp
void p_TakeOutComp(poly *p, long comp, poly *q, int *lq, const ring r)
Definition: p_polys.cc:3446
l
int l
Definition: cfEzgcd.cc:93
lcm
int lcm(unsigned long *l, unsigned long *a, unsigned long *b, unsigned long p, int dega, int degb)
Definition: minpoly.cc:709
R
#define R
Definition: sirandom.c:26
p_Divide
poly p_Divide(poly a, poly b, const ring r)
polynomial division, ignoring the rest via singclap_pdivide resp. idLift destroyes a,...
Definition: polys.cc:31
p_Totaldegree
static long p_Totaldegree(poly p, const ring r)
Definition: p_polys.h:1444
p
int p
Definition: cfModGcd.cc:4019
p_Norm
void p_Norm(poly p1, const ring r)
Definition: p_polys.cc:3670
comp
int comp(const CanonicalForm &A, const CanonicalForm &B)
compare polynomials
Definition: facSparseHensel.h:25
numbers.h
pWrite
void pWrite(poly p)
Definition: polys.h:302
wrp
void wrp(poly p)
Definition: polys.h:304