My Project
p_polys.h
Go to the documentation of this file.
1/****************************************
2* Computer Algebra System SINGULAR *
3****************************************/
4/***************************************************************
5 * File: p_polys.h
6 * Purpose: declaration of poly stuf which are independent of
7 * currRing
8 * Author: obachman (Olaf Bachmann)
9 * Created: 9/00
10 *******************************************************************/
11/***************************************************************
12 * Purpose: implementation of poly procs which iter over ExpVector
13 * Author: obachman (Olaf Bachmann)
14 * Created: 8/00
15 *******************************************************************/
16#ifndef P_POLYS_H
17#define P_POLYS_H
18
19#include "misc/mylimits.h"
20#include "misc/intvec.h"
21#include "coeffs/coeffs.h"
22
25
29
30#include "polys/sbuckets.h"
31
32#ifdef HAVE_PLURAL
33#include "polys/nc/nc.h"
34#endif
35
36poly p_Farey(poly p, number N, const ring r);
37/*
38* xx,q: arrays of length 0..rl-1
39* xx[i]: SB mod q[i]
40* assume: char=0
41* assume: q[i]!=0
42* destroys xx
43*/
44poly p_ChineseRemainder(poly *xx, number *x,number *q, int rl, CFArray &inv_cache, const ring R);
45/***************************************************************
46 *
47 * Divisiblity tests, args must be != NULL, except for
48 * pDivisbleBy
49 *
50 ***************************************************************/
51unsigned long p_GetShortExpVector(const poly a, const ring r);
52
53/// p_GetShortExpVector of p * pp
54unsigned long p_GetShortExpVector(const poly p, const poly pp, const ring r);
55
56#ifdef HAVE_RINGS
57/*! divisibility check over ground ring (which may contain zero divisors);
58 TRUE iff LT(f) divides LT(g), i.e., LT(f)*c*m = LT(g), for some
59 coefficient c and some monomial m;
60 does not take components into account
61 */
62BOOLEAN p_DivisibleByRingCase(poly f, poly g, const ring r);
63#endif
64
65/***************************************************************
66 *
67 * Misc things on polys
68 *
69 ***************************************************************/
70
71poly p_One(const ring r);
72
73int p_MinDeg(poly p,intvec *w, const ring R);
74
75long p_DegW(poly p, const int *w, const ring R);
76
77/// return TRUE if all monoms have the same component
78BOOLEAN p_OneComp(poly p, const ring r);
79
80/// return i, if head depends only on var(i)
81int p_IsPurePower(const poly p, const ring r);
82
83/// return i, if poly depends only on var(i)
84int p_IsUnivariate(poly p, const ring r);
85
86/// set entry e[i] to 1 if var(i) occurs in p, ignore var(j) if e[j]>0
87/// return #(e[i]>0)
88int p_GetVariables(poly p, int * e, const ring r);
89
90/// returns the poly representing the integer i
91poly p_ISet(long i, const ring r);
92
93/// returns the poly representing the number n, destroys n
94poly p_NSet(number n, const ring r);
95
96void p_Vec2Polys(poly v, poly**p, int *len, const ring r);
97poly p_Vec2Poly(poly v, int k, const ring r);
98
99/// julia: vector to already allocated array (len=p_MaxComp(v,r))
100void p_Vec2Array(poly v, poly *p, int len, const ring r);
101
102/***************************************************************
103 *
104 * Copying/Deletion of polys: args may be NULL
105 *
106 ***************************************************************/
107
108// simply deletes monomials, does not free coeffs
109void p_ShallowDelete(poly *p, const ring r);
110
111
112
113/***************************************************************
114 *
115 * Copying/Deleteion of polys: args may be NULL
116 * - p/q as arg mean a poly
117 * - m a monomial
118 * - n a number
119 * - pp (resp. qq, mm, nn) means arg is constant
120 * - p (resp, q, m, n) means arg is destroyed
121 *
122 ***************************************************************/
123
124poly p_Sub(poly a, poly b, const ring r);
125
126poly p_Power(poly p, int i, const ring r);
127
128
129/***************************************************************
130 *
131 * PDEBUG stuff
132 *
133 ***************************************************************/
134#ifdef PDEBUG
135// Returns TRUE if m is monom of p, FALSE otherwise
136BOOLEAN pIsMonomOf(poly p, poly m);
137// Returns TRUE if p and q have common monoms
138BOOLEAN pHaveCommonMonoms(poly p, poly q);
139
140// p_Check* routines return TRUE if everything is ok,
141// else, they report error message and return false
142
143// check if Lm(p) is from ring r
144BOOLEAN p_LmCheckIsFromRing(poly p, ring r);
145// check if Lm(p) != NULL, r != NULL and initialized && Lm(p) is from r
146BOOLEAN p_LmCheckPolyRing(poly p, ring r);
147// check if all monoms of p are from ring r
148BOOLEAN p_CheckIsFromRing(poly p, ring r);
149// check r != NULL and initialized && all monoms of p are from r
150BOOLEAN p_CheckPolyRing(poly p, ring r);
151// check if r != NULL and initialized
152BOOLEAN p_CheckRing(ring r);
153// only do check if cond
154
155
156#define pIfThen(cond, check) do {if (cond) {check;}} while (0)
157
158BOOLEAN _p_Test(poly p, ring r, int level);
159BOOLEAN _p_LmTest(poly p, ring r, int level);
160BOOLEAN _pp_Test(poly p, ring lmRing, ring tailRing, int level);
161
162#define p_Test(p,r) _p_Test(p, r, PDEBUG)
163#define p_LmTest(p,r) _p_LmTest(p, r, PDEBUG)
164#define pp_Test(p, lmRing, tailRing) _pp_Test(p, lmRing, tailRing, PDEBUG)
165
166#else // ! PDEBUG
167
168#define pIsMonomOf(p, q) (TRUE)
169#define pHaveCommonMonoms(p, q) (TRUE)
170#define p_LmCheckIsFromRing(p,r) (TRUE)
171#define p_LmCheckPolyRing(p,r) (TRUE)
172#define p_CheckIsFromRing(p,r) (TRUE)
173#define p_CheckPolyRing(p,r) (TRUE)
174#define p_CheckRing(r) (TRUE)
175#define P_CheckIf(cond, check) (TRUE)
176
177#define p_Test(p,r) (TRUE)
178#define p_LmTest(p,r) (TRUE)
179#define pp_Test(p, lmRing, tailRing) (TRUE)
180
181#endif
182
183/***************************************************************
184 *
185 * Misc stuff
186 *
187 ***************************************************************/
188/*2
189* returns the length of a polynomial (numbers of monomials)
190*/
191static inline unsigned pLength(poly a)
192{
193 unsigned l = 0;
194 while (a!=NULL)
195 {
196 pIter(a);
197 l++;
198 }
199 return l;
200}
201
202// returns the length of a polynomial (numbers of monomials) and the last mon.
203// respect syzComp
204poly p_Last(const poly a, int &l, const ring r);
205
206/*----------------------------------------------------*/
207
208void p_Norm(poly p1, const ring r);
209void p_Normalize(poly p,const ring r);
210void p_ProjectiveUnique(poly p,const ring r);
211
212void p_ContentForGB(poly p, const ring r);
213void p_Content(poly p, const ring r);
214void p_Content_n(poly p, number &c,const ring r);
215#if 1
216// currently only used by Singular/janet
217void p_SimpleContent(poly p, int s, const ring r);
218number p_InitContent(poly ph, const ring r);
219#endif
220
221poly p_Cleardenom(poly p, const ring r);
222void p_Cleardenom_n(poly p, const ring r,number &c);
223//number p_GetAllDenom(poly ph, const ring r);// unused
224
225int p_Size( poly p, const ring r );
226
227// homogenizes p by multiplying certain powers of the varnum-th variable
228poly p_Homogen (poly p, int varnum, const ring r);
229
230BOOLEAN p_IsHomogeneous (poly p, const ring r);
231BOOLEAN p_IsHomogeneousW (poly p, const intvec *w, const ring r);
232BOOLEAN p_IsHomogeneousW (poly p, const intvec *w, const intvec *module_w,const ring r);
233
234// Setm
235static inline void p_Setm(poly p, const ring r)
236{
237 p_CheckRing2(r);
238 r->p_Setm(p, r);
239}
240
241p_SetmProc p_GetSetmProc(const ring r);
242
243poly p_Subst(poly p, int n, poly e, const ring r);
244
245// TODO:
246#define p_SetmComp p_Setm
247
248// component
249static inline unsigned long p_SetComp(poly p, unsigned long c, ring r)
250{
252 if (r->pCompIndex>=0) __p_GetComp(p,r) = c;
253 return c;
254}
255// sets component of poly a to i
256static inline void p_SetCompP(poly p, int i, ring r)
257{
258 if (p != NULL)
259 {
260 p_Test(p, r);
262 {
263 do
264 {
265 p_SetComp(p, i, r);
266 p_SetmComp(p, r);
267 pIter(p);
268 }
269 while (p != NULL);
270 }
271 else
272 {
273 do
274 {
275 p_SetComp(p, i, r);
276 pIter(p);
277 }
278 while(p != NULL);
279 }
280 }
281}
282
283static inline void p_SetCompP(poly p, int i, ring lmRing, ring tailRing)
284{
285 if (p != NULL)
286 {
287 p_SetComp(p, i, lmRing);
288 p_SetmComp(p, lmRing);
289 p_SetCompP(pNext(p), i, tailRing);
290 }
291}
292
293// returns maximal column number in the modul element a (or 0)
294static inline long p_MaxComp(poly p, ring lmRing, ring tailRing)
295{
296 long result,i;
297
298 if(p==NULL) return 0;
299 result = p_GetComp(p, lmRing);
300 if (result != 0)
301 {
302 loop
303 {
304 pIter(p);
305 if(p==NULL) break;
306 i = p_GetComp(p, tailRing);
307 if (i>result) result = i;
308 }
309 }
310 return result;
311}
312
313static inline long p_MaxComp(poly p,ring lmRing) {return p_MaxComp(p,lmRing,lmRing);}
314
315static inline long p_MinComp(poly p, ring lmRing, ring tailRing)
316{
317 long result,i;
318
319 if(p==NULL) return 0;
320 result = p_GetComp(p,lmRing);
321 if (result != 0)
322 {
323 loop
324 {
325 pIter(p);
326 if(p==NULL) break;
327 i = p_GetComp(p,tailRing);
328 if (i<result) result = i;
329 }
330 }
331 return result;
332}
333
334static inline long p_MinComp(poly p,ring lmRing) {return p_MinComp(p,lmRing,lmRing);}
335
336
337static inline poly pReverse(poly p)
338{
339 if (p == NULL || pNext(p) == NULL) return p;
340
341 poly q = pNext(p), // == pNext(p)
342 qn;
343 pNext(p) = NULL;
344 do
345 {
346 qn = pNext(q);
347 pNext(q) = p;
348 p = q;
349 q = qn;
350 }
351 while (qn != NULL);
352 return p;
353}
354void pEnlargeSet(poly**p, int length, int increment);
355
356
357/***************************************************************
358 *
359 * I/O
360 *
361 ***************************************************************/
362/// print p according to ShortOut in lmRing & tailRing
363void p_String0(poly p, ring lmRing, ring tailRing);
364char* p_String(poly p, ring lmRing, ring tailRing);
365void p_Write(poly p, ring lmRing, ring tailRing);
366void p_Write0(poly p, ring lmRing, ring tailRing);
367void p_wrp(poly p, ring lmRing, ring tailRing);
368
369/// print p in a short way, if possible
370void p_String0Short(const poly p, ring lmRing, ring tailRing);
371
372/// print p in a long way
373void p_String0Long(const poly p, ring lmRing, ring tailRing);
374
375
376/***************************************************************
377 *
378 * Degree stuff -- see p_polys.cc for explainations
379 *
380 ***************************************************************/
381
382static inline long p_FDeg(const poly p, const ring r) { return r->pFDeg(p,r); }
383static inline long p_LDeg(const poly p, int *l, const ring r) { return r->pLDeg(p,l,r); }
384
385long p_WFirstTotalDegree(poly p, ring r);
386long p_WTotaldegree(poly p, const ring r);
387long p_WDegree(poly p,const ring r);
388long pLDeg0(poly p,int *l, ring r);
389long pLDeg0c(poly p,int *l, ring r);
390long pLDegb(poly p,int *l, ring r);
391long pLDeg1(poly p,int *l, ring r);
392long pLDeg1c(poly p,int *l, ring r);
393long pLDeg1_Deg(poly p,int *l, ring r);
394long pLDeg1c_Deg(poly p,int *l, ring r);
395long pLDeg1_Totaldegree(poly p,int *l, ring r);
396long pLDeg1c_Totaldegree(poly p,int *l, ring r);
397long pLDeg1_WFirstTotalDegree(poly p,int *l, ring r);
398long pLDeg1c_WFirstTotalDegree(poly p,int *l, ring r);
399
400BOOLEAN p_EqualPolys(poly p1, poly p2, const ring r);
401
402/// same as the usual p_EqualPolys for polys belonging to *equal* rings
403BOOLEAN p_EqualPolys(poly p1, poly p2, const ring r1, const ring r2);
404
405long p_Deg(poly a, const ring r);
406
407
408/***************************************************************
409 *
410 * Primitives for accessing and setting fields of a poly
411 *
412 ***************************************************************/
413
414static inline number p_SetCoeff(poly p, number n, ring r)
415{
417 n_Delete(&(p->coef), r->cf);
418 (p)->coef=n;
419 return n;
420}
421
422// order
423static inline long p_GetOrder(poly p, ring r)
424{
426 if (r->typ==NULL) return ((p)->exp[r->pOrdIndex]);
427 int i=0;
428 loop
429 {
430 switch(r->typ[i].ord_typ)
431 {
432 case ro_am:
433 case ro_wp_neg:
434 return ((p->exp[r->pOrdIndex])-POLY_NEGWEIGHT_OFFSET);
435 case ro_syzcomp:
436 case ro_syz:
437 case ro_cp:
438 i++;
439 break;
440 //case ro_dp:
441 //case ro_wp:
442 default:
443 return ((p)->exp[r->pOrdIndex]);
444 }
445 }
446}
447
448
449static inline unsigned long p_AddComp(poly p, unsigned long v, ring r)
450{
453 return __p_GetComp(p,r) += v;
454}
455static inline unsigned long p_SubComp(poly p, unsigned long v, ring r)
456{
459 _pPolyAssume2(__p_GetComp(p,r) >= v,p,r);
460 return __p_GetComp(p,r) -= v;
461}
462
463#ifndef HAVE_EXPSIZES
464
465/// get a single variable exponent
466/// @Note:
467/// the integer VarOffset encodes:
468/// 1. the position of a variable in the exponent vector p->exp (lower 24 bits)
469/// 2. number of bits to shift to the right in the upper 8 bits (which takes at most 6 bits for 64 bit)
470/// Thus VarOffset always has 2 zero higher bits!
471static inline long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
472{
473 pAssume2((VarOffset >> (24 + 6)) == 0);
474#if 0
475 int pos=(VarOffset & 0xffffff);
476 int bitpos=(VarOffset >> 24);
477 unsigned long exp=(p->exp[pos] >> bitmask) & iBitmask;
478 return exp;
479#else
480 return (long)
481 ((p->exp[(VarOffset & 0xffffff)] >> (VarOffset >> 24))
482 & iBitmask);
483#endif
484}
485
486
487/// set a single variable exponent
488/// @Note:
489/// VarOffset encodes the position in p->exp @see p_GetExp
490static inline unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
491{
492 pAssume2(e>=0);
493 pAssume2(e<=iBitmask);
494 pAssume2((VarOffset >> (24 + 6)) == 0);
495
496 // shift e to the left:
497 REGISTER int shift = VarOffset >> 24;
498 unsigned long ee = e << shift /*(VarOffset >> 24)*/;
499 // find the bits in the exponent vector
500 REGISTER int offset = (VarOffset & 0xffffff);
501 // clear the bits in the exponent vector:
502 p->exp[offset] &= ~( iBitmask << shift );
503 // insert e with |
504 p->exp[ offset ] |= ee;
505 return e;
506}
507
508
509#else // #ifdef HAVE_EXPSIZES // EXPERIMENTAL!!!
510
511static inline unsigned long BitMask(unsigned long bitmask, int twobits)
512{
513 // bitmask = 00000111111111111
514 // 0 must give bitmask!
515 // 1, 2, 3 - anything like 00011..11
516 pAssume2((twobits >> 2) == 0);
517 static const unsigned long _bitmasks[4] = {-1, 0x7fff, 0x7f, 0x3};
518 return bitmask & _bitmasks[twobits];
519}
520
521
522/// @Note: we may add some more info (6 ) into VarOffset and thus encode
523static inline long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
524{
525 int pos =(VarOffset & 0xffffff);
526 int hbyte= (VarOffset >> 24); // the highest byte
527 int bitpos = hbyte & 0x3f; // last 6 bits
528 long bitmask = BitMask(iBitmask, hbyte >> 6);
529
530 long exp=(p->exp[pos] >> bitpos) & bitmask;
531 return exp;
532
533}
534
535static inline long p_SetExp(poly p, const long e, const unsigned long iBitmask, const int VarOffset)
536{
537 pAssume2(e>=0);
538 pAssume2(e <= BitMask(iBitmask, VarOffset >> 30));
539
540 // shift e to the left:
541 REGISTER int hbyte = VarOffset >> 24;
542 int bitmask = BitMask(iBitmask, hbyte >> 6);
543 REGISTER int shift = hbyte & 0x3f;
544 long ee = e << shift;
545 // find the bits in the exponent vector
546 REGISTER int offset = (VarOffset & 0xffffff);
547 // clear the bits in the exponent vector:
548 p->exp[offset] &= ~( bitmask << shift );
549 // insert e with |
550 p->exp[ offset ] |= ee;
551 return e;
552}
553
554#endif // #ifndef HAVE_EXPSIZES
555
556
557static inline long p_GetExp(const poly p, const ring r, const int VarOffset)
558{
560 pAssume2(VarOffset != -1);
561 return p_GetExp(p, r->bitmask, VarOffset);
562}
563
564static inline long p_SetExp(poly p, const long e, const ring r, const int VarOffset)
565{
567 pAssume2(VarOffset != -1);
568 return p_SetExp(p, e, r->bitmask, VarOffset);
569}
570
571
572
573/// get v^th exponent for a monomial
574static inline long p_GetExp(const poly p, const int v, const ring r)
575{
577 pAssume2(v>0 && v <= r->N);
578 pAssume2(r->VarOffset[v] != -1);
579 return p_GetExp(p, r->bitmask, r->VarOffset[v]);
580}
581
582
583/// set v^th exponent for a monomial
584static inline long p_SetExp(poly p, const int v, const long e, const ring r)
585{
587 pAssume2(v>0 && v <= r->N);
588 pAssume2(r->VarOffset[v] != -1);
589 return p_SetExp(p, e, r->bitmask, r->VarOffset[v]);
590}
591
592// the following should be implemented more efficiently
593static inline long p_IncrExp(poly p, int v, ring r)
594{
596 int e = p_GetExp(p,v,r);
597 e++;
598 return p_SetExp(p,v,e,r);
599}
600static inline long p_DecrExp(poly p, int v, ring r)
601{
603 int e = p_GetExp(p,v,r);
604 pAssume2(e > 0);
605 e--;
606 return p_SetExp(p,v,e,r);
607}
608static inline long p_AddExp(poly p, int v, long ee, ring r)
609{
611 int e = p_GetExp(p,v,r);
612 e += ee;
613 return p_SetExp(p,v,e,r);
614}
615static inline long p_SubExp(poly p, int v, long ee, ring r)
616{
618 long e = p_GetExp(p,v,r);
619 pAssume2(e >= ee);
620 e -= ee;
621 return p_SetExp(p,v,e,r);
622}
623static inline long p_MultExp(poly p, int v, long ee, ring r)
624{
626 long e = p_GetExp(p,v,r);
627 e *= ee;
628 return p_SetExp(p,v,e,r);
629}
630
631static inline long p_GetExpSum(poly p1, poly p2, int i, ring r)
632{
633 p_LmCheckPolyRing2(p1, r);
634 p_LmCheckPolyRing2(p2, r);
635 return p_GetExp(p1,i,r) + p_GetExp(p2,i,r);
636}
637static inline long p_GetExpDiff(poly p1, poly p2, int i, ring r)
638{
639 return p_GetExp(p1,i,r) - p_GetExp(p2,i,r);
640}
641
642static inline int p_Comp_k_n(poly a, poly b, int k, ring r)
643{
644 if ((a==NULL) || (b==NULL) ) return FALSE;
645 p_LmCheckPolyRing2(a, r);
647 pAssume2(k > 0 && k <= r->N);
648 int i=k;
649 for(;i<=r->N;i++)
650 {
651 if (p_GetExp(a,i,r) != p_GetExp(b,i,r)) return FALSE;
652 // if (a->exp[(r->VarOffset[i] & 0xffffff)] != b->exp[(r->VarOffset[i] & 0xffffff)]) return FALSE;
653 }
654 return TRUE;
655}
656
657
658/***************************************************************
659 *
660 * Allocation/Initalization/Deletion
661 *
662 ***************************************************************/
663#if (OM_TRACK > 2) && defined(OM_TRACK_CUSTOM)
664static inline poly p_New(const ring r, omBin bin)
665#else
666static inline poly p_New(const ring /*r*/, omBin bin)
667#endif
668{
669 p_CheckRing2(r);
670 pAssume2(bin != NULL && omSizeWOfBin(r->PolyBin) == omSizeWOfBin(bin));
671 poly p;
672 omTypeAllocBin(poly, p, bin);
673 p_SetRingOfLm(p, r);
674 return p;
675}
676
677static inline poly p_New(ring r)
678{
679 return p_New(r, r->PolyBin);
680}
681
682#if (PDEBUG > 2) || defined(XALLOC_BIN)
683static inline void p_LmFree(poly p, ring r)
684#else
685static inline void p_LmFree(poly p, ring)
686#endif
687{
689 #ifdef XALLOC_BIN
690 omFreeBin(p,r->PolyBin);
691 #else
693 #endif
694}
695#if (PDEBUG > 2) || defined(XALLOC_BIN)
696static inline void p_LmFree(poly *p, ring r)
697#else
698static inline void p_LmFree(poly *p, ring)
699#endif
700{
702 poly h = *p;
703 *p = pNext(h);
704 #ifdef XALLOC_BIN
705 omFreeBin(h,r->PolyBin);
706 #else
708 #endif
709}
710#if (PDEBUG > 2) || defined(XALLOC_BIN)
711static inline poly p_LmFreeAndNext(poly p, ring r)
712#else
713static inline poly p_LmFreeAndNext(poly p, ring)
714#endif
715{
717 poly pnext = pNext(p);
718 #ifdef XALLOC_BIN
719 omFreeBin(p,r->PolyBin);
720 #else
722 #endif
723 return pnext;
724}
725static inline void p_LmDelete(poly p, const ring r)
726{
728 n_Delete(&pGetCoeff(p), r->cf);
729 #ifdef XALLOC_BIN
730 omFreeBin(p,r->PolyBin);
731 #else
733 #endif
734}
735static inline void p_LmDelete0(poly p, const ring r)
736{
738 if (pGetCoeff(p)!=NULL) n_Delete(&pGetCoeff(p), r->cf);
739 #ifdef XALLOC_BIN
740 omFreeBin(p,r->PolyBin);
741 #else
743 #endif
744}
745static inline void p_LmDelete(poly *p, const ring r)
746{
748 poly h = *p;
749 *p = pNext(h);
750 n_Delete(&pGetCoeff(h), r->cf);
751 #ifdef XALLOC_BIN
752 omFreeBin(h,r->PolyBin);
753 #else
755 #endif
756}
757static inline poly p_LmDeleteAndNext(poly p, const ring r)
758{
760 poly pnext = pNext(p);
761 n_Delete(&pGetCoeff(p), r->cf);
762 #ifdef XALLOC_BIN
763 omFreeBin(p,r->PolyBin);
764 #else
766 #endif
767 return pnext;
768}
769
770/***************************************************************
771 *
772 * Misc routines
773 *
774 ***************************************************************/
775
776/// return the maximal exponent of p in form of the maximal long var
777unsigned long p_GetMaxExpL(poly p, const ring r, unsigned long l_max = 0);
778
779/// return monomial r such that GetExp(r,i) is maximum of all
780/// monomials in p; coeff == 0, next == NULL, ord is not set
781poly p_GetMaxExpP(poly p, ring r);
782
783static inline unsigned long p_GetMaxExp(const unsigned long l, const ring r)
784{
785 unsigned long bitmask = r->bitmask;
786 unsigned long max = (l & bitmask);
787 unsigned long j = r->ExpPerLong - 1;
788
789 if (j > 0)
790 {
791 unsigned long i = r->BitsPerExp;
792 long e;
793 loop
794 {
795 e = ((l >> i) & bitmask);
796 if ((unsigned long) e > max)
797 max = e;
798 j--;
799 if (j==0) break;
800 i += r->BitsPerExp;
801 }
802 }
803 return max;
804}
805
806static inline unsigned long p_GetMaxExp(const poly p, const ring r)
807{
808 return p_GetMaxExp(p_GetMaxExpL(p, r), r);
809}
810
811static inline unsigned long
812p_GetTotalDegree(const unsigned long l, const ring r, const int number_of_exps)
813{
814 const unsigned long bitmask = r->bitmask;
815 unsigned long sum = (l & bitmask);
816 unsigned long j = number_of_exps - 1;
817
818 if (j > 0)
819 {
820 unsigned long i = r->BitsPerExp;
821 loop
822 {
823 sum += ((l >> i) & bitmask);
824 j--;
825 if (j==0) break;
826 i += r->BitsPerExp;
827 }
828 }
829 return sum;
830}
831
832/***************************************************************
833 *
834 * Dispatcher to r->p_Procs, they do the tests/checks
835 *
836 ***************************************************************/
837/// returns a copy of p (without any additional testing)
838static inline poly p_Copy_noCheck(poly p, const ring r)
839{
840 /*assume(p!=NULL);*/
841 assume(r != NULL);
842 assume(r->p_Procs != NULL);
843 assume(r->p_Procs->p_Copy != NULL);
844 return r->p_Procs->p_Copy(p, r);
845}
846
847/// returns a copy of p
848static inline poly p_Copy(poly p, const ring r)
849{
850 if (p!=NULL)
851 {
852 p_Test(p,r);
853 const poly pp = p_Copy_noCheck(p, r);
854 p_Test(pp,r);
855 return pp;
856 }
857 else
858 return NULL;
859}
860
861/// copy the (leading) term of p
862static inline poly p_Head(const poly p, const ring r)
863{
864 if (p == NULL) return NULL;
866 poly np;
867 omTypeAllocBin(poly, np, r->PolyBin);
868 p_SetRingOfLm(np, r);
869 memcpy(np->exp, p->exp, r->ExpL_Size*sizeof(long));
870 pNext(np) = NULL;
871 pSetCoeff0(np, n_Copy(pGetCoeff(p), r->cf));
872 return np;
873}
874
875/// like p_Head, but allow NULL coeff
876poly p_Head0(const poly p, const ring r);
877
878/// like p_Head, but with coefficient 1
879poly p_CopyPowerProduct(const poly p, const ring r);
880
881/// like p_Head, but with coefficient n
882poly p_CopyPowerProduct0(const poly p, const number n, const ring r);
883
884/// returns a copy of p with Lm(p) from lmRing and Tail(p) from tailRing
885static inline poly p_Copy(poly p, const ring lmRing, const ring tailRing)
886{
887 if (p != NULL)
888 {
889#ifndef PDEBUG
890 if (tailRing == lmRing)
891 return p_Copy_noCheck(p, tailRing);
892#endif
893 poly pres = p_Head(p, lmRing);
894 if (pNext(p)!=NULL)
895 pNext(pres) = p_Copy_noCheck(pNext(p), tailRing);
896 return pres;
897 }
898 else
899 return NULL;
900}
901
902// deletes *p, and sets *p to NULL
903static inline void p_Delete(poly *p, const ring r)
904{
905 assume( p!= NULL );
906 assume( r!= NULL );
907 if ((*p)!=NULL) r->p_Procs->p_Delete(p, r);
908}
909
910static inline void p_Delete(poly *p, const ring lmRing, const ring tailRing)
911{
912 assume( p!= NULL );
913 if (*p != NULL)
914 {
915#ifndef PDEBUG
916 if (tailRing == lmRing)
917 {
918 p_Delete(p, tailRing);
919 return;
920 }
921#endif
922 if (pNext(*p) != NULL)
923 p_Delete(&pNext(*p), tailRing);
924 p_LmDelete(p, lmRing);
925 }
926}
927
928// copys monomials of p, allocates new monomials from bin,
929// deletes monomials of p
930static inline poly p_ShallowCopyDelete(poly p, const ring r, omBin bin)
931{
933 pAssume2(omSizeWOfBin(r->PolyBin) == omSizeWOfBin(bin));
934 return r->p_Procs->p_ShallowCopyDelete(p, r, bin);
935}
936
937// returns p+q, destroys p and q
938static inline poly p_Add_q(poly p, poly q, const ring r)
939{
940 assume( (p != q) || (p == NULL && q == NULL) );
941 if (q==NULL) return p;
942 if (p==NULL) return q;
943 int shorter;
944 return r->p_Procs->p_Add_q(p, q, shorter, r);
945}
946
947/// like p_Add_q, except that if lp == pLength(lp) lq == pLength(lq) then lp == pLength(p+q)
948static inline poly p_Add_q(poly p, poly q, int &lp, int lq, const ring r)
949{
950 assume( (p != q) || (p == NULL && q == NULL) );
951 if (q==NULL) return p;
952 if (p==NULL) { lp=lq; return q; }
953 int shorter;
954 poly res = r->p_Procs->p_Add_q(p, q, shorter, r);
955 lp += lq - shorter;
956 return res;
957}
958
959// returns p*n, destroys p
960static inline poly p_Mult_nn(poly p, number n, const ring r)
961{
962 if (p==NULL) return NULL;
963 if (n_IsOne(n, r->cf))
964 return p;
965 else if (n_IsZero(n, r->cf))
966 {
967 p_Delete(&p, r); // NOTE: without p_Delete - memory leak!
968 return NULL;
969 }
970 else
971 return r->p_Procs->p_Mult_nn(p, n, r);
972}
973#define __p_Mult_nn(p,n,r) r->p_Procs->p_Mult_nn(p, n, r)
974
975static inline poly p_Mult_nn(poly p, number n, const ring lmRing,
976 const ring tailRing)
977{
978 assume(p!=NULL);
979#ifndef PDEBUG
980 if (lmRing == tailRing)
981 return p_Mult_nn(p, n, tailRing);
982#endif
983 poly pnext = pNext(p);
984 pNext(p) = NULL;
985 p = lmRing->p_Procs->p_Mult_nn(p, n, lmRing);
986 if (pnext!=NULL)
987 {
988 pNext(p) = tailRing->p_Procs->p_Mult_nn(pnext, n, tailRing);
989 }
990 return p;
991}
992
993// returns p*n, does not destroy p
994static inline poly pp_Mult_nn(poly p, number n, const ring r)
995{
996 if (p==NULL) return NULL;
997 if (n_IsOne(n, r->cf))
998 return p_Copy(p, r);
999 else if (n_IsZero(n, r->cf))
1000 return NULL;
1001 else
1002 return r->p_Procs->pp_Mult_nn(p, n, r);
1003}
1004#define __pp_Mult_nn(p,n,r) r->p_Procs->pp_Mult_nn(p, n, r)
1005
1006// test if the monomial is a constant as a vector component
1007// i.e., test if all exponents are zero
1008static inline BOOLEAN p_LmIsConstantComp(const poly p, const ring r)
1009{
1010 //p_LmCheckPolyRing(p, r);
1011 int i = r->VarL_Size - 1;
1012
1013 do
1014 {
1015 if (p->exp[r->VarL_Offset[i]] != 0)
1016 return FALSE;
1017 i--;
1018 }
1019 while (i >= 0);
1020 return TRUE;
1021}
1022
1023// test if monomial is a constant, i.e. if all exponents and the component
1024// is zero
1025static inline BOOLEAN p_LmIsConstant(const poly p, const ring r)
1026{
1027 if (p_LmIsConstantComp(p, r))
1028 return (p_GetComp(p, r) == 0);
1029 return FALSE;
1030}
1031
1032// returns Copy(p)*m, does neither destroy p nor m
1033static inline poly pp_Mult_mm(poly p, poly m, const ring r)
1034{
1035 if (p==NULL) return NULL;
1036 if (p_LmIsConstant(m, r))
1037 return __pp_Mult_nn(p, pGetCoeff(m), r);
1038 else
1039 return r->p_Procs->pp_Mult_mm(p, m, r);
1040}
1041
1042// returns m*Copy(p), does neither destroy p nor m
1043static inline poly pp_mm_Mult(poly p, poly m, const ring r)
1044{
1045 if (p==NULL) return NULL;
1046 if (p_LmIsConstant(m, r))
1047 return __pp_Mult_nn(p, pGetCoeff(m), r);
1048 else
1049 return r->p_Procs->pp_mm_Mult(p, m, r);
1050}
1051
1052// returns p*m, destroys p, const: m
1053static inline poly p_Mult_mm(poly p, poly m, const ring r)
1054{
1055 if (p==NULL) return NULL;
1056 if (p_LmIsConstant(m, r))
1057 return __p_Mult_nn(p, pGetCoeff(m), r);
1058 else
1059 return r->p_Procs->p_Mult_mm(p, m, r);
1060}
1061
1062// returns m*p, destroys p, const: m
1063static inline poly p_mm_Mult(poly p, poly m, const ring r)
1064{
1065 if (p==NULL) return NULL;
1066 if (p_LmIsConstant(m, r))
1067 return __p_Mult_nn(p, pGetCoeff(m), r);
1068 else
1069 return r->p_Procs->p_mm_Mult(p, m, r);
1070}
1071
1072static inline poly p_Minus_mm_Mult_qq(poly p, const poly m, const poly q, int &lp, int lq,
1073 const poly spNoether, const ring r)
1074{
1075 int shorter;
1076 const poly res = r->p_Procs->p_Minus_mm_Mult_qq(p, m, q, shorter, spNoether, r);
1077 lp += lq - shorter;
1078// assume( lp == pLength(res) );
1079 return res;
1080}
1081
1082// return p - m*Copy(q), destroys p; const: p,m
1083static inline poly p_Minus_mm_Mult_qq(poly p, const poly m, const poly q, const ring r)
1084{
1085 int shorter;
1086
1087 return r->p_Procs->p_Minus_mm_Mult_qq(p, m, q, shorter, NULL, r);
1088}
1089
1090
1091// returns p*Coeff(m) for such monomials pm of p, for which m is divisble by pm
1092static inline poly pp_Mult_Coeff_mm_DivSelect(poly p, const poly m, const ring r)
1093{
1094 int shorter;
1095 return r->p_Procs->pp_Mult_Coeff_mm_DivSelect(p, m, shorter, r);
1096}
1097
1098// returns p*Coeff(m) for such monomials pm of p, for which m is divisble by pm
1099// if lp is length of p on input then lp is length of returned poly on output
1100static inline poly pp_Mult_Coeff_mm_DivSelect(poly p, int &lp, const poly m, const ring r)
1101{
1102 int shorter;
1103 poly pp = r->p_Procs->pp_Mult_Coeff_mm_DivSelect(p, m, shorter, r);
1104 lp -= shorter;
1105 return pp;
1106}
1107
1108// returns -p, destroys p
1109static inline poly p_Neg(poly p, const ring r)
1110{
1111 return r->p_Procs->p_Neg(p, r);
1112}
1113
1114extern poly _p_Mult_q(poly p, poly q, const int copy, const ring r);
1115// returns p*q, destroys p and q
1116static inline poly p_Mult_q(poly p, poly q, const ring r)
1117{
1118 assume( (p != q) || (p == NULL && q == NULL) );
1119
1120 if (p == NULL)
1121 {
1122 p_Delete(&q, r);
1123 return NULL;
1124 }
1125 if (q == NULL)
1126 {
1127 p_Delete(&p, r);
1128 return NULL;
1129 }
1130
1131 if (pNext(p) == NULL)
1132 {
1133 q = r->p_Procs->p_mm_Mult(q, p, r);
1134 p_LmDelete(&p, r);
1135 return q;
1136 }
1137
1138 if (pNext(q) == NULL)
1139 {
1140 p = r->p_Procs->p_Mult_mm(p, q, r);
1141 p_LmDelete(&q, r);
1142 return p;
1143 }
1144#if defined(HAVE_PLURAL) || defined(HAVE_SHIFTBBA)
1145 if (rIsNCRing(r))
1146 return _nc_p_Mult_q(p, q, r);
1147 else
1148#endif
1149 return _p_Mult_q(p, q, 0, r);
1150}
1151
1152// returns p*q, does neither destroy p nor q
1153static inline poly pp_Mult_qq(poly p, poly q, const ring r)
1154{
1155 if (p == NULL || q == NULL) return NULL;
1156
1157 if (pNext(p) == NULL)
1158 {
1159 return r->p_Procs->pp_mm_Mult(q, p, r);
1160 }
1161
1162 if (pNext(q) == NULL)
1163 {
1164 return r->p_Procs->pp_Mult_mm(p, q, r);
1165 }
1166
1167 poly qq = q;
1168 if (p == q)
1169 qq = p_Copy(q, r);
1170
1171 poly res;
1172#if defined(HAVE_PLURAL) || defined(HAVE_SHIFTBBA)
1173 if (rIsNCRing(r))
1174 res = _nc_pp_Mult_qq(p, qq, r);
1175 else
1176#endif
1177 res = _p_Mult_q(p, qq, 1, r);
1178
1179 if (qq != q)
1180 p_Delete(&qq, r);
1181 return res;
1182}
1183
1184// returns p + m*q destroys p, const: q, m
1185static inline poly p_Plus_mm_Mult_qq(poly p, poly m, poly q, int &lp, int lq,
1186 const ring r)
1187{
1188#ifdef HAVE_PLURAL
1189 if (rIsPluralRing(r))
1190 return nc_p_Plus_mm_Mult_qq(p, m, q, lp, lq, r);
1191#endif
1192
1193// this should be implemented more efficiently
1194 poly res;
1195 int shorter;
1196 number n_old = pGetCoeff(m);
1197 number n_neg = n_Copy(n_old, r->cf);
1198 n_neg = n_InpNeg(n_neg, r->cf);
1199 pSetCoeff0(m, n_neg);
1200 res = r->p_Procs->p_Minus_mm_Mult_qq(p, m, q, shorter, NULL, r);
1201 lp = (lp + lq) - shorter;
1202 pSetCoeff0(m, n_old);
1203 n_Delete(&n_neg, r->cf);
1204 return res;
1205}
1206
1207static inline poly p_Plus_mm_Mult_qq(poly p, poly m, poly q, const ring r)
1208{
1209 int lp = 0, lq = 0;
1210 return p_Plus_mm_Mult_qq(p, m, q, lp, lq, r);
1211}
1212
1213// returns merged p and q, assumes p and q have no monomials which are equal
1214static inline poly p_Merge_q(poly p, poly q, const ring r)
1215{
1216 assume( (p != q) || (p == NULL && q == NULL) );
1217 return r->p_Procs->p_Merge_q(p, q, r);
1218}
1219
1220// like p_SortMerge, except that p may have equal monimals
1221static inline poly p_SortAdd(poly p, const ring r, BOOLEAN revert= FALSE)
1222{
1223 if (revert) p = pReverse(p);
1224 return sBucketSortAdd(p, r);
1225}
1226
1227// sorts p using bucket sort: returns sorted poly
1228// assumes that monomials of p are all different
1229// reverses it first, if revert == TRUE, use this if input p is "almost" sorted
1230// correctly
1231static inline poly p_SortMerge(poly p, const ring r, BOOLEAN revert= FALSE)
1232{
1233 if (revert) p = pReverse(p);
1234 return sBucketSortMerge(p, r);
1235}
1236
1237/***************************************************************
1238 *
1239 * I/O
1240 *
1241 ***************************************************************/
1242static inline char* p_String(poly p, ring p_ring)
1243{
1244 return p_String(p, p_ring, p_ring);
1245}
1246static inline void p_String0(poly p, ring p_ring)
1247{
1248 p_String0(p, p_ring, p_ring);
1249}
1250static inline void p_Write(poly p, ring p_ring)
1251{
1252 p_Write(p, p_ring, p_ring);
1253}
1254static inline void p_Write0(poly p, ring p_ring)
1255{
1256 p_Write0(p, p_ring, p_ring);
1257}
1258static inline void p_wrp(poly p, ring p_ring)
1259{
1260 p_wrp(p, p_ring, p_ring);
1261}
1262
1263
1264#if PDEBUG > 0
1265
1266#define _p_LmCmpAction(p, q, r, actionE, actionG, actionS) \
1267do \
1268{ \
1269 int _cmp = p_LmCmp(p,q,r); \
1270 if (_cmp == 0) actionE; \
1271 if (_cmp == 1) actionG; \
1272 actionS; \
1273} \
1274while(0)
1275
1276#else
1277
1278#define _p_LmCmpAction(p, q, r, actionE, actionG, actionS) \
1279 p_MemCmp_LengthGeneral_OrdGeneral(p->exp, q->exp, r->CmpL_Size, r->ordsgn, \
1280 actionE, actionG, actionS)
1281
1282#endif
1283
1284#define pDivAssume(x) do {} while (0)
1285
1286
1287
1288/***************************************************************
1289 *
1290 * Allocation/Initalization/Deletion
1291 *
1292 ***************************************************************/
1293// adjustments for negative weights
1294static inline void p_MemAdd_NegWeightAdjust(poly p, const ring r)
1295{
1296 if (r->NegWeightL_Offset != NULL)
1297 {
1298 for (int i=r->NegWeightL_Size-1; i>=0; i--)
1299 {
1300 p->exp[r->NegWeightL_Offset[i]] -= POLY_NEGWEIGHT_OFFSET;
1301 }
1302 }
1303}
1304static inline void p_MemSub_NegWeightAdjust(poly p, const ring r)
1305{
1306 if (r->NegWeightL_Offset != NULL)
1307 {
1308 for (int i=r->NegWeightL_Size-1; i>=0; i--)
1309 {
1310 p->exp[r->NegWeightL_Offset[i]] += POLY_NEGWEIGHT_OFFSET;
1311 }
1312 }
1313}
1314// ExpVextor(d_p) = ExpVector(s_p)
1315static inline void p_ExpVectorCopy(poly d_p, poly s_p, const ring r)
1316{
1317 p_LmCheckPolyRing1(d_p, r);
1318 p_LmCheckPolyRing1(s_p, r);
1319 memcpy(d_p->exp, s_p->exp, r->ExpL_Size*sizeof(long));
1320}
1321
1322static inline poly p_Init(const ring r, omBin bin)
1323{
1324 p_CheckRing1(r);
1325 pAssume1(bin != NULL && omSizeWOfBin(r->PolyBin) == omSizeWOfBin(bin));
1326 poly p;
1327 omTypeAlloc0Bin(poly, p, bin);
1329 p_SetRingOfLm(p, r);
1330 return p;
1331}
1332static inline poly p_Init(const ring r)
1333{
1334 return p_Init(r, r->PolyBin);
1335}
1336
1337static inline poly p_LmInit(poly p, const ring r)
1338{
1340 poly np;
1341 omTypeAllocBin(poly, np, r->PolyBin);
1342 p_SetRingOfLm(np, r);
1343 memcpy(np->exp, p->exp, r->ExpL_Size*sizeof(long));
1344 pNext(np) = NULL;
1345 pSetCoeff0(np, NULL);
1346 return np;
1347}
1348static inline poly p_LmInit(poly s_p, const ring s_r, const ring d_r, omBin d_bin)
1349{
1350 p_LmCheckPolyRing1(s_p, s_r);
1351 p_CheckRing(d_r);
1352 pAssume1(d_r->N <= s_r->N);
1353 poly d_p = p_Init(d_r, d_bin);
1354 for (unsigned i=d_r->N; i!=0; i--)
1355 {
1356 p_SetExp(d_p, i, p_GetExp(s_p, i,s_r), d_r);
1357 }
1358 if (rRing_has_Comp(d_r))
1359 {
1360 p_SetComp(d_p, p_GetComp(s_p,s_r), d_r);
1361 }
1362 p_Setm(d_p, d_r);
1363 return d_p;
1364}
1365static inline poly p_LmInit(poly s_p, const ring s_r, const ring d_r)
1366{
1367 pAssume1(d_r != NULL);
1368 return p_LmInit(s_p, s_r, d_r, d_r->PolyBin);
1369}
1370
1371// set all exponents l..k to 0, assume exp. k+1..n and 1..l-1 are in
1372// different blocks
1373// set coeff to 1
1374static inline poly p_GetExp_k_n(poly p, int l, int k, const ring r)
1375{
1376 if (p == NULL) return NULL;
1378 poly np;
1379 omTypeAllocBin(poly, np, r->PolyBin);
1380 p_SetRingOfLm(np, r);
1381 memcpy(np->exp, p->exp, r->ExpL_Size*sizeof(long));
1382 pNext(np) = NULL;
1383 pSetCoeff0(np, n_Init(1, r->cf));
1384 int i;
1385 for(i=l;i<=k;i++)
1386 {
1387 //np->exp[(r->VarOffset[i] & 0xffffff)] =0;
1388 p_SetExp(np,i,0,r);
1389 }
1390 p_Setm(np,r);
1391 return np;
1392}
1393
1394// simialar to p_ShallowCopyDelete but does it only for leading monomial
1395static inline poly p_LmShallowCopyDelete(poly p, const ring r)
1396{
1398 pAssume1(omSizeWOfBin(bin) == omSizeWOfBin(r->PolyBin));
1399 poly new_p = p_New(r);
1400 memcpy(new_p->exp, p->exp, r->ExpL_Size*sizeof(long));
1401 pSetCoeff0(new_p, pGetCoeff(p));
1402 pNext(new_p) = pNext(p);
1404 return new_p;
1405}
1406
1407/***************************************************************
1408 *
1409 * Operation on ExpVectors
1410 *
1411 ***************************************************************/
1412// ExpVector(p1) += ExpVector(p2)
1413static inline void p_ExpVectorAdd(poly p1, poly p2, const ring r)
1414{
1415 p_LmCheckPolyRing1(p1, r);
1416 p_LmCheckPolyRing1(p2, r);
1417#if PDEBUG >= 1
1418 for (int i=1; i<=r->N; i++)
1419 pAssume1((unsigned long) (p_GetExp(p1, i, r) + p_GetExp(p2, i, r)) <= r->bitmask);
1420 pAssume1(p_GetComp(p1, r) == 0 || p_GetComp(p2, r) == 0);
1421#endif
1422
1423 p_MemAdd_LengthGeneral(p1->exp, p2->exp, r->ExpL_Size);
1425}
1426// ExpVector(pr) = ExpVector(p1) + ExpVector(p2)
1427static inline void p_ExpVectorSum(poly pr, poly p1, poly p2, const ring r)
1428{
1429 p_LmCheckPolyRing1(p1, r);
1430 p_LmCheckPolyRing1(p2, r);
1431 p_LmCheckPolyRing1(pr, r);
1432#if PDEBUG >= 1
1433 for (int i=1; i<=r->N; i++)
1434 pAssume1((unsigned long) (p_GetExp(p1, i, r) + p_GetExp(p2, i, r)) <= r->bitmask);
1435 pAssume1(p_GetComp(p1, r) == 0 || p_GetComp(p2, r) == 0);
1436#endif
1437
1438 p_MemSum_LengthGeneral(pr->exp, p1->exp, p2->exp, r->ExpL_Size);
1440}
1441// ExpVector(p1) -= ExpVector(p2)
1442static inline void p_ExpVectorSub(poly p1, poly p2, const ring r)
1443{
1444 p_LmCheckPolyRing1(p1, r);
1445 p_LmCheckPolyRing1(p2, r);
1446#if PDEBUG >= 1
1447 for (int i=1; i<=r->N; i++)
1448 pAssume1(p_GetExp(p1, i, r) >= p_GetExp(p2, i, r));
1449 pAssume1(p_GetComp(p1, r) == 0 || p_GetComp(p2, r) == 0 ||
1450 p_GetComp(p1, r) == p_GetComp(p2, r));
1451#endif
1452
1453 p_MemSub_LengthGeneral(p1->exp, p2->exp, r->ExpL_Size);
1455}
1456
1457// ExpVector(p1) += ExpVector(p2) - ExpVector(p3)
1458static inline void p_ExpVectorAddSub(poly p1, poly p2, poly p3, const ring r)
1459{
1460 p_LmCheckPolyRing1(p1, r);
1461 p_LmCheckPolyRing1(p2, r);
1462 p_LmCheckPolyRing1(p3, r);
1463#if PDEBUG >= 1
1464 for (int i=1; i<=r->N; i++)
1465 pAssume1(p_GetExp(p1, i, r) + p_GetExp(p2, i, r) >= p_GetExp(p3, i, r));
1466 pAssume1(p_GetComp(p1, r) == 0 ||
1467 (p_GetComp(p2, r) - p_GetComp(p3, r) == 0) ||
1468 (p_GetComp(p1, r) == p_GetComp(p2, r) - p_GetComp(p3, r)));
1469#endif
1470
1471 p_MemAddSub_LengthGeneral(p1->exp, p2->exp, p3->exp, r->ExpL_Size);
1472 // no need to adjust in case of NegWeights
1473}
1474
1475// ExpVector(pr) = ExpVector(p1) - ExpVector(p2)
1476static inline void p_ExpVectorDiff(poly pr, poly p1, poly p2, const ring r)
1477{
1478 p_LmCheckPolyRing1(p1, r);
1479 p_LmCheckPolyRing1(p2, r);
1480 p_LmCheckPolyRing1(pr, r);
1481#if PDEBUG >= 2
1482 for (int i=1; i<=r->N; i++)
1483 pAssume1(p_GetExp(p1, i, r) >= p_GetExp(p2, i, r));
1484 pAssume1(!rRing_has_Comp(r) || p_GetComp(p1, r) == p_GetComp(p2, r));
1485#endif
1486
1487 p_MemDiff_LengthGeneral(pr->exp, p1->exp, p2->exp, r->ExpL_Size);
1489}
1490
1491static inline BOOLEAN p_ExpVectorEqual(poly p1, poly p2, const ring r)
1492{
1493 p_LmCheckPolyRing1(p1, r);
1494 p_LmCheckPolyRing1(p2, r);
1495
1496 unsigned i = r->ExpL_Size;
1497 unsigned long *ep = p1->exp;
1498 unsigned long *eq = p2->exp;
1499
1500 do
1501 {
1502 i--;
1503 if (ep[i] != eq[i]) return FALSE;
1504 }
1505 while (i!=0);
1506 return TRUE;
1507}
1508
1509static inline long p_Totaldegree(poly p, const ring r)
1510{
1512 unsigned long s = p_GetTotalDegree(p->exp[r->VarL_Offset[0]],
1513 r,
1514 r->ExpPerLong);
1515 for (unsigned i=r->VarL_Size-1; i!=0; i--)
1516 {
1517 s += p_GetTotalDegree(p->exp[r->VarL_Offset[i]], r,r->ExpPerLong);
1518 }
1519 return (long)s;
1520}
1521
1522static inline void p_GetExpV(poly p, int *ev, const ring r)
1523{
1525 for (unsigned j = r->N; j!=0; j--)
1526 ev[j] = p_GetExp(p, j, r);
1527
1528 ev[0] = p_GetComp(p, r);
1529}
1530// p_GetExpVL is used in Singular,jl
1531static inline void p_GetExpVL(poly p, int64 *ev, const ring r)
1532{
1534 for (unsigned j = r->N; j!=0; j--)
1535 ev[j-1] = p_GetExp(p, j, r);
1536}
1537// p_GetExpVLV is used in Singular,jl
1538static inline int64 p_GetExpVLV(poly p, int64 *ev, const ring r)
1539{
1541 for (unsigned j = r->N; j!=0; j--)
1542 ev[j-1] = p_GetExp(p, j, r);
1543 return (int64)p_GetComp(p,r);
1544}
1545// p_GetExpVL is used in Singular,jl
1546static inline void p_SetExpV(poly p, int *ev, const ring r)
1547{
1549 for (unsigned j = r->N; j!=0; j--)
1550 p_SetExp(p, j, ev[j], r);
1551
1552 if(ev[0]!=0) p_SetComp(p, ev[0],r);
1553 p_Setm(p, r);
1554}
1555static inline void p_SetExpVL(poly p, int64 *ev, const ring r)
1556{
1558 for (unsigned j = r->N; j!=0; j--)
1559 p_SetExp(p, j, ev[j-1], r);
1560 p_SetComp(p, 0,r);
1561
1562 p_Setm(p, r);
1563}
1564
1565// p_SetExpVLV is used in Singular,jl
1566static inline void p_SetExpVLV(poly p, int64 *ev, int64 comp, const ring r)
1567{
1569 for (unsigned j = r->N; j!=0; j--)
1570 p_SetExp(p, j, ev[j-1], r);
1571 p_SetComp(p, comp,r);
1572
1573 p_Setm(p, r);
1574}
1575
1576/***************************************************************
1577 *
1578 * Comparison w.r.t. monomial ordering
1579 *
1580 ***************************************************************/
1581
1582static inline int p_LmCmp(poly p, poly q, const ring r)
1583{
1585 p_LmCheckPolyRing1(q, r);
1586
1587 const unsigned long* _s1 = ((unsigned long*) p->exp);
1588 const unsigned long* _s2 = ((unsigned long*) q->exp);
1589 REGISTER unsigned long _v1;
1590 REGISTER unsigned long _v2;
1591 const unsigned long _l = r->CmpL_Size;
1592
1593 REGISTER unsigned long _i=0;
1594
1595 LengthGeneral_OrdGeneral_LoopTop:
1596 _v1 = _s1[_i];
1597 _v2 = _s2[_i];
1598 if (_v1 == _v2)
1599 {
1600 _i++;
1601 if (_i == _l) return 0;
1602 goto LengthGeneral_OrdGeneral_LoopTop;
1603 }
1604 const long* _ordsgn = (long*) r->ordsgn;
1605#if 1 /* two variants*/
1606 if (_v1 > _v2)
1607 {
1608 return _ordsgn[_i];
1609 }
1610 return -(_ordsgn[_i]);
1611#else
1612 if (_v1 > _v2)
1613 {
1614 if (_ordsgn[_i] == 1) return 1;
1615 return -1;
1616 }
1617 if (_ordsgn[_i] == 1) return -1;
1618 return 1;
1619#endif
1620}
1621
1622// The coefficient will be compared in absolute value
1623static inline int p_LtCmp(poly p, poly q, const ring r)
1624{
1625 int res = p_LmCmp(p,q,r);
1626 if(res == 0)
1627 {
1628 if(p_GetCoeff(p,r) == NULL || p_GetCoeff(q,r) == NULL)
1629 return res;
1630 number pc = n_Copy(p_GetCoeff(p,r),r->cf);
1631 number qc = n_Copy(p_GetCoeff(q,r),r->cf);
1632 if(!n_GreaterZero(pc,r->cf))
1633 pc = n_InpNeg(pc,r->cf);
1634 if(!n_GreaterZero(qc,r->cf))
1635 qc = n_InpNeg(qc,r->cf);
1636 if(n_Greater(pc,qc,r->cf))
1637 res = 1;
1638 else if(n_Greater(qc,pc,r->cf))
1639 res = -1;
1640 else if(n_Equal(pc,qc,r->cf))
1641 res = 0;
1642 n_Delete(&pc,r->cf);
1643 n_Delete(&qc,r->cf);
1644 }
1645 return res;
1646}
1647
1648// The coefficient will be compared in absolute value
1649static inline int p_LtCmpNoAbs(poly p, poly q, const ring r)
1650{
1651 int res = p_LmCmp(p,q,r);
1652 if(res == 0)
1653 {
1654 if(p_GetCoeff(p,r) == NULL || p_GetCoeff(q,r) == NULL)
1655 return res;
1656 number pc = p_GetCoeff(p,r);
1657 number qc = p_GetCoeff(q,r);
1658 if(n_Greater(pc,qc,r->cf))
1659 res = 1;
1660 if(n_Greater(qc,pc,r->cf))
1661 res = -1;
1662 if(n_Equal(pc,qc,r->cf))
1663 res = 0;
1664 }
1665 return res;
1666}
1667
1668#ifdef HAVE_RINGS
1669// This is the equivalent of pLmCmp(p,q) != -currRing->OrdSgn for rings
1670// It is used in posInLRing and posInTRing
1671static inline int p_LtCmpOrdSgnDiffM(poly p, poly q, const ring r)
1672{
1673 return(p_LtCmp(p,q,r) == r->OrdSgn);
1674}
1675#endif
1676
1677#ifdef HAVE_RINGS
1678// This is the equivalent of pLmCmp(p,q) != currRing->OrdSgn for rings
1679// It is used in posInLRing and posInTRing
1680static inline int p_LtCmpOrdSgnDiffP(poly p, poly q, const ring r)
1681{
1682 if(r->OrdSgn == 1)
1683 {
1684 return(p_LmCmp(p,q,r) == -1);
1685 }
1686 else
1687 {
1688 return(p_LtCmp(p,q,r) != -1);
1689 }
1690}
1691#endif
1692
1693#ifdef HAVE_RINGS
1694// This is the equivalent of pLmCmp(p,q) == -currRing->OrdSgn for rings
1695// It is used in posInLRing and posInTRing
1696static inline int p_LtCmpOrdSgnEqM(poly p, poly q, const ring r)
1697{
1698 return(p_LtCmp(p,q,r) == -r->OrdSgn);
1699}
1700#endif
1701
1702#ifdef HAVE_RINGS
1703// This is the equivalent of pLmCmp(p,q) == currRing->OrdSgn for rings
1704// It is used in posInLRing and posInTRing
1705static inline int p_LtCmpOrdSgnEqP(poly p, poly q, const ring r)
1706{
1707 return(p_LtCmp(p,q,r) == r->OrdSgn);
1708}
1709#endif
1710
1711/// returns TRUE if p1 is a skalar multiple of p2
1712/// assume p1 != NULL and p2 != NULL
1713BOOLEAN p_ComparePolys(poly p1,poly p2, const ring r);
1714
1715
1716/***************************************************************
1717 *
1718 * Comparisons: they are all done without regarding coeffs
1719 *
1720 ***************************************************************/
1721#define p_LmCmpAction(p, q, r, actionE, actionG, actionS) \
1722 _p_LmCmpAction(p, q, r, actionE, actionG, actionS)
1723
1724// returns 1 if ExpVector(p)==ExpVector(q): does not compare numbers !!
1725#define p_LmEqual(p1, p2, r) p_ExpVectorEqual(p1, p2, r)
1726
1727// pCmp: args may be NULL
1728// returns: (p2==NULL ? 1 : (p1 == NULL ? -1 : p_LmCmp(p1, p2)))
1729static inline int p_Cmp(poly p1, poly p2, ring r)
1730{
1731 if (p2==NULL)
1732 {
1733 if (p1==NULL) return 0;
1734 return 1;
1735 }
1736 if (p1==NULL)
1737 return -1;
1738 return p_LmCmp(p1,p2,r);
1739}
1740
1741static inline int p_CmpPolys(poly p1, poly p2, ring r)
1742{
1743 if (p2==NULL)
1744 {
1745 if (p1==NULL) return 0;
1746 return 1;
1747 }
1748 if (p1==NULL)
1749 return -1;
1750 return p_ComparePolys(p1,p2,r);
1751}
1752
1753
1754/***************************************************************
1755 *
1756 * divisibility
1757 *
1758 ***************************************************************/
1759/// return: FALSE, if there exists i, such that a->exp[i] > b->exp[i]
1760/// TRUE, otherwise
1761/// (1) Consider long vars, instead of single exponents
1762/// (2) Clearly, if la > lb, then FALSE
1763/// (3) Suppose la <= lb, and consider first bits of single exponents in l:
1764/// if TRUE, then value of these bits is la ^ lb
1765/// if FALSE, then la-lb causes an "overflow" into one of those bits, i.e.,
1766/// la ^ lb != la - lb
1767static inline BOOLEAN _p_LmDivisibleByNoComp(poly a, poly b, const ring r)
1768{
1769 int i=r->VarL_Size - 1;
1770 unsigned long divmask = r->divmask;
1771 unsigned long la, lb;
1772
1773 if (r->VarL_LowIndex >= 0)
1774 {
1775 i += r->VarL_LowIndex;
1776 do
1777 {
1778 la = a->exp[i];
1779 lb = b->exp[i];
1780 if ((la > lb) ||
1781 (((la & divmask) ^ (lb & divmask)) != ((lb - la) & divmask)))
1782 {
1784 return FALSE;
1785 }
1786 i--;
1787 }
1788 while (i>=r->VarL_LowIndex);
1789 }
1790 else
1791 {
1792 do
1793 {
1794 la = a->exp[r->VarL_Offset[i]];
1795 lb = b->exp[r->VarL_Offset[i]];
1796 if ((la > lb) ||
1797 (((la & divmask) ^ (lb & divmask)) != ((lb - la) & divmask)))
1798 {
1800 return FALSE;
1801 }
1802 i--;
1803 }
1804 while (i>=0);
1805 }
1806/*#ifdef HAVE_RINGS
1807 pDivAssume(p_DebugLmDivisibleByNoComp(a, b, r) == n_DivBy(p_GetCoeff(b, r), p_GetCoeff(a, r), r->cf));
1808 return (!rField_is_Ring(r)) || n_DivBy(p_GetCoeff(b, r), p_GetCoeff(a, r), r->cf);
1809#else
1810*/
1812 return TRUE;
1813//#endif
1814}
1815
1816static inline BOOLEAN _p_LmDivisibleByNoComp(poly a, const ring r_a, poly b, const ring r_b)
1817{
1818 int i=r_a->N;
1819 pAssume1(r_a->N == r_b->N);
1820
1821 do
1822 {
1823 if (p_GetExp(a,i,r_a) > p_GetExp(b,i,r_b))
1824 return FALSE;
1825 i--;
1826 }
1827 while (i);
1828/*#ifdef HAVE_RINGS
1829 return n_DivBy(p_GetCoeff(b, r_b), p_GetCoeff(a, r_a), r_a->cf);
1830#else
1831*/
1832 return TRUE;
1833//#endif
1834}
1835
1836#ifdef HAVE_RATGRING
1837static inline BOOLEAN _p_LmDivisibleByNoCompPart(poly a, const ring r_a, poly b, const ring r_b,const int start, const int end)
1838{
1839 int i=end;
1840 pAssume1(r_a->N == r_b->N);
1841
1842 do
1843 {
1844 if (p_GetExp(a,i,r_a) > p_GetExp(b,i,r_b))
1845 return FALSE;
1846 i--;
1847 }
1848 while (i>=start);
1849/*#ifdef HAVE_RINGS
1850 return n_DivBy(p_GetCoeff(b, r_b), p_GetCoeff(a, r_a), r_a->cf);
1851#else
1852*/
1853 return TRUE;
1854//#endif
1855}
1856static inline BOOLEAN _p_LmDivisibleByPart(poly a, const ring r_a, poly b, const ring r_b,const int start, const int end)
1857{
1858 if (p_GetComp(a, r_a) == 0 || p_GetComp(a,r_a) == p_GetComp(b,r_b))
1859 return _p_LmDivisibleByNoCompPart(a, r_a, b, r_b,start,end);
1860 return FALSE;
1861}
1862static inline BOOLEAN p_LmDivisibleByPart(poly a, poly b, const ring r,const int start, const int end)
1863{
1865 pIfThen1(a != NULL, p_LmCheckPolyRing1(b, r));
1866 if (p_GetComp(a, r) == 0 || p_GetComp(a,r) == p_GetComp(b,r))
1867 return _p_LmDivisibleByNoCompPart(a, r, b, r,start, end);
1868 return FALSE;
1869}
1870#endif
1871static inline BOOLEAN _p_LmDivisibleBy(poly a, poly b, const ring r)
1872{
1873 if (p_GetComp(a, r) == 0 || p_GetComp(a,r) == p_GetComp(b,r))
1874 return _p_LmDivisibleByNoComp(a, b, r);
1875 return FALSE;
1876}
1877static inline BOOLEAN _p_LmDivisibleBy(poly a, const ring r_a, poly b, const ring r_b)
1878{
1879 if (p_GetComp(a, r_a) == 0 || p_GetComp(a,r_a) == p_GetComp(b,r_b))
1880 return _p_LmDivisibleByNoComp(a, r_a, b, r_b);
1881 return FALSE;
1882}
1883static inline BOOLEAN p_LmDivisibleByNoComp(poly a, poly b, const ring r)
1884{
1885 p_LmCheckPolyRing1(a, r);
1887 return _p_LmDivisibleByNoComp(a, b, r);
1888}
1889
1890static inline BOOLEAN p_LmDivisibleByNoComp(poly a, const ring ra, poly b, const ring rb)
1891{
1892 p_LmCheckPolyRing1(a, ra);
1893 p_LmCheckPolyRing1(b, rb);
1894 return _p_LmDivisibleByNoComp(a, ra, b, rb);
1895}
1896
1897static inline BOOLEAN p_LmDivisibleBy(poly a, poly b, const ring r)
1898{
1900 pIfThen1(a != NULL, p_LmCheckPolyRing1(b, r));
1901 if (p_GetComp(a, r) == 0 || p_GetComp(a,r) == p_GetComp(b,r))
1902 return _p_LmDivisibleByNoComp(a, b, r);
1903 return FALSE;
1904}
1905
1906static inline BOOLEAN p_DivisibleBy(poly a, poly b, const ring r)
1907{
1909 pIfThen1(a!=NULL, p_LmCheckPolyRing1(a, r));
1910
1911 if (a != NULL && (p_GetComp(a, r) == 0 || p_GetComp(a,r) == p_GetComp(b,r)))
1912 return _p_LmDivisibleByNoComp(a,b,r);
1913 return FALSE;
1914}
1915static inline BOOLEAN p_DivisibleBy(poly a, const ring r_a, poly b, const ring r_b)
1916{
1918 pIfThen1(a!=NULL, p_LmCheckPolyRing1(a, r_a));
1919 if (a != NULL) {
1920 return _p_LmDivisibleBy(a, r_a, b, r_b);
1921 }
1922 return FALSE;
1923}
1924static inline BOOLEAN p_LmDivisibleBy(poly a, const ring r_a, poly b, const ring r_b)
1925{
1926 p_LmCheckPolyRing(a, r_a);
1927 p_LmCheckPolyRing(b, r_b);
1928 return _p_LmDivisibleBy(a, r_a, b, r_b);
1929}
1930
1931static inline BOOLEAN p_LmShortDivisibleBy(poly a, unsigned long sev_a,
1932 poly b, unsigned long not_sev_b, const ring r)
1933{
1934 p_LmCheckPolyRing1(a, r);
1936#ifndef PDIV_DEBUG
1937 _pPolyAssume2(p_GetShortExpVector(a, r) == sev_a, a, r);
1938 _pPolyAssume2(p_GetShortExpVector(b, r) == ~ not_sev_b, b, r);
1939
1940 if (sev_a & not_sev_b)
1941 {
1943 return FALSE;
1944 }
1945 return p_LmDivisibleBy(a, b, r);
1946#else
1947 return pDebugLmShortDivisibleBy(a, sev_a, r, b, not_sev_b, r);
1948#endif
1949}
1950
1951static inline BOOLEAN p_LmShortDivisibleByNoComp(poly a, unsigned long sev_a,
1952 poly b, unsigned long not_sev_b, const ring r)
1953{
1954 p_LmCheckPolyRing1(a, r);
1956#ifndef PDIV_DEBUG
1957 _pPolyAssume2(p_GetShortExpVector(a, r) == sev_a, a, r);
1958 _pPolyAssume2(p_GetShortExpVector(b, r) == ~ not_sev_b, b, r);
1959
1960 if (sev_a & not_sev_b)
1961 {
1963 return FALSE;
1964 }
1965 return p_LmDivisibleByNoComp(a, b, r);
1966#else
1967 return pDebugLmShortDivisibleByNoComp(a, sev_a, r, b, not_sev_b, r);
1968#endif
1969}
1970
1971static inline BOOLEAN p_LmShortDivisibleBy(poly a, unsigned long sev_a, const ring r_a,
1972 poly b, unsigned long not_sev_b, const ring r_b)
1973{
1974 p_LmCheckPolyRing1(a, r_a);
1975 p_LmCheckPolyRing1(b, r_b);
1976#ifndef PDIV_DEBUG
1977 _pPolyAssume2(p_GetShortExpVector(a, r_a) == sev_a, a, r_a);
1978 _pPolyAssume2(p_GetShortExpVector(b, r_b) == ~ not_sev_b, b, r_b);
1979
1980 if (sev_a & not_sev_b)
1981 {
1982 pAssume1(_p_LmDivisibleByNoComp(a, r_a, b, r_b) == FALSE);
1983 return FALSE;
1984 }
1985 return _p_LmDivisibleBy(a, r_a, b, r_b);
1986#else
1987 return pDebugLmShortDivisibleBy(a, sev_a, r_a, b, not_sev_b, r_b);
1988#endif
1989}
1990
1991/***************************************************************
1992 *
1993 * Misc things on Lm
1994 *
1995 ***************************************************************/
1996
1997
1998/// like the respective p_LmIs* routines, except that p might be empty
1999static inline BOOLEAN p_IsConstantComp(const poly p, const ring r)
2000{
2001 if (p == NULL) return TRUE;
2002 return (pNext(p)==NULL) && p_LmIsConstantComp(p, r);
2003}
2004
2005static inline BOOLEAN p_IsConstant(const poly p, const ring r)
2006{
2007 if (p == NULL) return TRUE;
2008 return (pNext(p)==NULL) && p_LmIsConstant(p, r);
2009}
2010
2011/// either poly(1) or gen(k)?!
2012static inline BOOLEAN p_IsOne(const poly p, const ring R)
2013{
2014 if (p == NULL) return FALSE; /* TODO check if 0 == 1 */
2015 p_Test(p, R);
2016 return (p_IsConstant(p, R) && n_IsOne(p_GetCoeff(p, R), R->cf));
2017}
2018
2019static inline BOOLEAN p_IsConstantPoly(const poly p, const ring r)
2020{
2021 p_Test(p, r);
2022 poly pp=p;
2023 while(pp!=NULL)
2024 {
2025 if (! p_LmIsConstantComp(pp, r))
2026 return FALSE;
2027 pIter(pp);
2028 }
2029 return TRUE;
2030}
2031
2032static inline BOOLEAN p_IsUnit(const poly p, const ring r)
2033{
2034 if (p == NULL) return FALSE;
2035 if (rField_is_Ring(r))
2036 return (p_LmIsConstant(p, r) && n_IsUnit(pGetCoeff(p),r->cf));
2037 return p_LmIsConstant(p, r);
2038}
2039
2040static inline BOOLEAN p_LmExpVectorAddIsOk(const poly p1, const poly p2,
2041 const ring r)
2042{
2043 p_LmCheckPolyRing(p1, r);
2044 p_LmCheckPolyRing(p2, r);
2045 unsigned long l1, l2, divmask = r->divmask;
2046 int i;
2047
2048 for (i=0; i<r->VarL_Size; i++)
2049 {
2050 l1 = p1->exp[r->VarL_Offset[i]];
2051 l2 = p2->exp[r->VarL_Offset[i]];
2052 // do the divisiblity trick
2053 if ( (l1 > ULONG_MAX - l2) ||
2054 (((l1 & divmask) ^ (l2 & divmask)) != ((l1 + l2) & divmask)))
2055 return FALSE;
2056 }
2057 return TRUE;
2058}
2059void p_Split(poly p, poly * r); /*p => IN(p), r => REST(p) */
2060BOOLEAN p_HasNotCF(poly p1, poly p2, const ring r);
2061BOOLEAN p_HasNotCFRing(poly p1, poly p2, const ring r);
2062poly p_mInit(const char *s, BOOLEAN &ok, const ring r); /* monom s -> poly, interpreter */
2063const char * p_Read(const char *s, poly &p,const ring r); /* monom -> poly */
2064poly p_MDivide(poly a, poly b, const ring r);
2065poly p_DivideM(poly a, poly b, const ring r);
2066poly pp_DivideM(poly a, poly b, const ring r);
2067poly p_Div_nn(poly p, const number n, const ring r);
2068
2069// returns the LCM of the head terms of a and b in *m, does not p_Setm
2070void p_Lcm(const poly a, const poly b, poly m, const ring r);
2071// returns the LCM of the head terms of a and b, does p_Setm
2072poly p_Lcm(const poly a, const poly b, const ring r);
2073
2074#ifdef HAVE_RATGRING
2075poly p_LcmRat(const poly a, const poly b, const long lCompM, const ring r);
2076poly p_GetCoeffRat(poly p, int ishift, ring r);
2077void p_LmDeleteAndNextRat(poly *p, int ishift, ring r);
2078void p_ContentRat(poly &ph, const ring r);
2079#endif /* ifdef HAVE_RATGRING */
2080
2081
2082poly p_Diff(poly a, int k, const ring r);
2083poly p_DiffOp(poly a, poly b,BOOLEAN multiply, const ring r);
2084int p_Weight(int c, const ring r);
2085
2086/// assumes that p and divisor are univariate polynomials in r,
2087/// mentioning the same variable;
2088/// assumes divisor != NULL;
2089/// p may be NULL;
2090/// assumes a global monomial ordering in r;
2091/// performs polynomial division of p by divisor:
2092/// - afterwards p contains the remainder of the division, i.e.,
2093/// p_before = result * divisor + p_afterwards;
2094/// - if needResult == TRUE, then the method computes and returns 'result',
2095/// otherwise NULL is returned (This parametrization can be used when
2096/// one is only interested in the remainder of the division. In this
2097/// case, the method will be slightly faster.)
2098/// leaves divisor unmodified
2099poly p_PolyDiv(poly &p, const poly divisor, const BOOLEAN needResult, const ring r);
2100
2101/* syszygy stuff */
2102BOOLEAN p_VectorHasUnitB(poly p, int * k, const ring r);
2103void p_VectorHasUnit(poly p, int * k, int * len, const ring r);
2104poly p_TakeOutComp1(poly * p, int k, const ring r);
2105// Splits *p into two polys: *q which consists of all monoms with
2106// component == comp and *p of all other monoms *lq == pLength(*q)
2107// On return all components pf *q == 0
2108void p_TakeOutComp(poly *p, long comp, poly *q, int *lq, const ring r);
2109
2110// This is something weird -- Don't use it, unless you know what you are doing
2111poly p_TakeOutComp(poly * p, int k, const ring r);
2112
2113void p_DeleteComp(poly * p,int k, const ring r);
2114
2115/*-------------ring management:----------------------*/
2116
2117// resets the pFDeg and pLDeg: if pLDeg is not given, it is
2118// set to currRing->pLDegOrig, i.e. to the respective LDegProc which
2119// only uses pFDeg (and not pDeg, or pTotalDegree, etc).
2120// If you use this, make sure your procs does not make any assumptions
2121// on ordering and/or OrdIndex -- otherwise they might return wrong results
2122// on strat->tailRing
2123void pSetDegProcs(ring r, pFDegProc new_FDeg, pLDegProc new_lDeg = NULL);
2124// restores pFDeg and pLDeg:
2125void pRestoreDegProcs(ring r, pFDegProc old_FDeg, pLDegProc old_lDeg);
2126
2127/*-------------pComp for syzygies:-------------------*/
2128void p_SetModDeg(intvec *w, ring r);
2129
2130/*------------ Jet ----------------------------------*/
2131poly pp_Jet(poly p, int m, const ring R);
2132poly p_Jet(poly p, int m,const ring R);
2133poly pp_JetW(poly p, int m, int *w, const ring R);
2134poly p_JetW(poly p, int m, int *w, const ring R);
2135
2136poly n_PermNumber(const number z, const int *par_perm, const int OldPar, const ring src, const ring dst);
2137
2138poly p_PermPoly (poly p, const int * perm,const ring OldRing, const ring dst,
2139 nMapFunc nMap, const int *par_perm=NULL, int OldPar=0,
2140 BOOLEAN use_mult=FALSE);
2141
2142/*----------------------------------------------------*/
2143poly p_Series(int n,poly p,poly u, intvec *w, const ring R);
2144
2145/*----------------------------------------------------*/
2146int p_Var(poly mi, const ring r);
2147/// the minimal index of used variables - 1
2148int p_LowVar (poly p, const ring r);
2149
2150/*----------------------------------------------------*/
2151/// shifts components of the vector p by i
2152void p_Shift (poly * p,int i, const ring r);
2153/*----------------------------------------------------*/
2154
2155int p_Compare(const poly a, const poly b, const ring R);
2156
2157/// polynomial gcd for f=mon
2158poly p_GcdMon(poly f, poly g, const ring r);
2159
2160/// divide polynomial by monomial
2161poly p_Div_mm(poly p, const poly m, const ring r);
2162
2163
2164/// max exponent of variable x_i in p
2165int p_MaxExpPerVar(poly p, int i, const ring r);
2166#endif // P_POLYS_H
2167
long int64
Definition: auxiliary.h:68
int BOOLEAN
Definition: auxiliary.h:87
#define TRUE
Definition: auxiliary.h:100
#define FALSE
Definition: auxiliary.h:96
CanonicalForm FACTORY_PUBLIC pp(const CanonicalForm &)
CanonicalForm pp ( const CanonicalForm & f )
Definition: cf_gcd.cc:676
int level(const CanonicalForm &f)
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:56
int l
Definition: cfEzgcd.cc:100
int m
Definition: cfEzgcd.cc:128
int i
Definition: cfEzgcd.cc:132
int k
Definition: cfEzgcd.cc:99
Variable x
Definition: cfModGcd.cc:4082
int p
Definition: cfModGcd.cc:4078
g
Definition: cfModGcd.cc:4090
CanonicalForm b
Definition: cfModGcd.cc:4103
FILE * f
Definition: checklibs.c:9
Definition: intvec.h:23
Coefficient rings, fields and other domains suitable for Singular polynomials.
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of 'n'
Definition: coeffs.h:451
static FORCE_INLINE BOOLEAN n_IsUnit(number n, const coeffs r)
TRUE iff n has a multiplicative inverse in the given coeff field/ring r.
Definition: coeffs.h:515
static FORCE_INLINE BOOLEAN n_GreaterZero(number n, const coeffs r)
ordered fields: TRUE iff 'n' is positive; in Z/pZ: TRUE iff 0 < m <= roundedBelow(p/2),...
Definition: coeffs.h:494
static FORCE_INLINE number n_InpNeg(number n, const coeffs r)
in-place negation of n MUST BE USED: n = n_InpNeg(n) (no copy is returned)
Definition: coeffs.h:557
static FORCE_INLINE BOOLEAN n_Greater(number a, number b, const coeffs r)
ordered fields: TRUE iff 'a' is larger than 'b'; in Z/pZ: TRUE iff la > lb, where la and lb are the l...
Definition: coeffs.h:511
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff 'n' represents the zero element.
Definition: coeffs.h:464
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
Definition: coeffs.h:455
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
Definition: coeffs.h:538
static FORCE_INLINE BOOLEAN n_Equal(number a, number b, const coeffs r)
TRUE iff 'a' and 'b' represent the same number; they may have different representations.
Definition: coeffs.h:460
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition: coeffs.h:73
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
Definition: coeffs.h:468
return result
Definition: facAbsBiFact.cc:75
const CanonicalForm int s
Definition: facAbsFact.cc:51
CanonicalForm res
Definition: facAbsFact.cc:60
const CanonicalForm & w
Definition: facAbsFact.cc:51
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:39
CFArray copy(const CFList &list)
write elements of list into an array
int j
Definition: facHensel.cc:110
int comp(const CanonicalForm &A, const CanonicalForm &B)
compare polynomials
static int max(int a, int b)
Definition: fast_mult.cc:264
if(!FE_OPT_NO_SHELL_FLAG)(void) system(sys)
static BOOLEAN length(leftv result, leftv arg)
Definition: interval.cc:257
STATIC_VAR int offset
Definition: janet.cc:29
STATIC_VAR Poly * h
Definition: janet.cc:971
poly nc_p_Plus_mm_Mult_qq(poly p, const poly m, const poly q, int &lp, const int, const ring r)
Definition: old.gring.cc:168
poly _nc_pp_Mult_qq(const poly p, const poly q, const ring r)
general NC-multiplication without destruction
Definition: old.gring.cc:254
poly _nc_p_Mult_q(poly p, poly q, const ring r)
general NC-multiplication with destruction
Definition: old.gring.cc:215
#define assume(x)
Definition: mod2.h:389
#define p_GetComp(p, r)
Definition: monomials.h:64
#define pIfThen1(cond, check)
Definition: monomials.h:179
#define pIter(p)
Definition: monomials.h:37
#define pNext(p)
Definition: monomials.h:36
#define p_LmCheckPolyRing1(p, r)
Definition: monomials.h:177
#define pAssume1(cond)
Definition: monomials.h:171
#define p_LmCheckPolyRing2(p, r)
Definition: monomials.h:199
#define pSetCoeff0(p, n)
Definition: monomials.h:59
#define p_CheckRing2(r)
Definition: monomials.h:200
#define p_GetCoeff(p, r)
Definition: monomials.h:50
#define p_CheckRing1(r)
Definition: monomials.h:178
#define pAssume2(cond)
Definition: monomials.h:193
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
#define _pPolyAssume2(cond, p, r)
Definition: monomials.h:195
#define POLY_NEGWEIGHT_OFFSET
Definition: monomials.h:236
#define __p_GetComp(p, r)
Definition: monomials.h:63
#define p_SetRingOfLm(p, r)
Definition: monomials.h:144
#define rRing_has_Comp(r)
Definition: monomials.h:266
gmp_float exp(const gmp_float &a)
Definition: mpr_complex.cc:357
Definition: lq.h:40
#define omTypeAlloc0Bin(type, addr, bin)
Definition: omAllocDecl.h:204
#define omTypeAllocBin(type, addr, bin)
Definition: omAllocDecl.h:203
#define omFreeBin(addr, bin)
Definition: omAllocDecl.h:259
#define omFreeBinAddr(addr)
Definition: omAllocDecl.h:258
#define omSizeWOfBin(bin_ptr)
#define NULL
Definition: omList.c:12
omBin_t * omBin
Definition: omStructs.h:12
#define REGISTER
Definition: omalloc.h:27
BOOLEAN pDebugLmShortDivisibleByNoComp(poly p1, unsigned long sev_1, ring r_1, poly p2, unsigned long not_sev_2, ring r_2)
Definition: pDebug.cc:389
BOOLEAN pDebugLmShortDivisibleBy(poly p1, unsigned long sev_1, ring r_1, poly p2, unsigned long not_sev_2, ring r_2)
Definition: pDebug.cc:366
BOOLEAN p_DebugLmDivisibleByNoComp(poly a, poly b, ring r)
Definition: pDebug.cc:141
#define p_MemDiff_LengthGeneral(r, s1, s2, length)
Definition: p_MemAdd.h:262
#define p_MemSub_LengthGeneral(r, s, length)
Definition: p_MemAdd.h:291
#define p_MemAdd_LengthGeneral(r, s, length)
Definition: p_MemAdd.h:173
#define p_MemAddSub_LengthGeneral(r, s, t, length)
Definition: p_MemAdd.h:312
#define p_MemSum_LengthGeneral(r, s1, s2, length)
Definition: p_MemAdd.h:86
static poly p_Neg(poly p, const ring r)
Definition: p_polys.h:1109
void p_Content_n(poly p, number &c, const ring r)
Definition: p_polys.cc:2349
poly p_Diff(poly a, int k, const ring r)
Definition: p_polys.cc:1894
long pLDeg1c_WFirstTotalDegree(poly p, int *l, ring r)
Definition: p_polys.cc:1068
static int p_CmpPolys(poly p1, poly p2, ring r)
Definition: p_polys.h:1741
long pLDeg0(poly p, int *l, ring r)
Definition: p_polys.cc:739
poly p_DivideM(poly a, poly b, const ring r)
Definition: p_polys.cc:1574
int p_IsPurePower(const poly p, const ring r)
return i, if head depends only on var(i)
Definition: p_polys.cc:1226
static long p_GetExpDiff(poly p1, poly p2, int i, ring r)
Definition: p_polys.h:637
static void p_ExpVectorSum(poly pr, poly p1, poly p2, const ring r)
Definition: p_polys.h:1427
poly pp_Jet(poly p, int m, const ring R)
Definition: p_polys.cc:4474
static poly p_Add_q(poly p, poly q, const ring r)
Definition: p_polys.h:938
static void p_LmDelete(poly p, const ring r)
Definition: p_polys.h:725
static poly p_Mult_q(poly p, poly q, const ring r)
Definition: p_polys.h:1116
void pSetDegProcs(ring r, pFDegProc new_FDeg, pLDegProc new_lDeg=NULL)
Definition: p_polys.cc:3753
BOOLEAN pIsMonomOf(poly p, poly m)
Definition: pDebug.cc:165
BOOLEAN p_LmCheckPolyRing(poly p, ring r)
Definition: pDebug.cc:120
static void p_MemAdd_NegWeightAdjust(poly p, const ring r)
Definition: p_polys.h:1294
poly p_Farey(poly p, number N, const ring r)
Definition: p_polys.cc:54
BOOLEAN _p_Test(poly p, ring r, int level)
Definition: pDebug.cc:212
static void p_ExpVectorAdd(poly p1, poly p2, const ring r)
Definition: p_polys.h:1413
static unsigned long p_SubComp(poly p, unsigned long v, ring r)
Definition: p_polys.h:455
long pLDeg1_Deg(poly p, int *l, ring r)
Definition: p_polys.cc:910
BOOLEAN p_CheckIsFromRing(poly p, ring r)
Definition: pDebug.cc:102
void pRestoreDegProcs(ring r, pFDegProc old_FDeg, pLDegProc old_lDeg)
Definition: p_polys.cc:3765
long pLDeg1_WFirstTotalDegree(poly p, int *l, ring r)
Definition: p_polys.cc:1038
static long p_SubExp(poly p, int v, long ee, ring r)
Definition: p_polys.h:615
static BOOLEAN _p_LmDivisibleByPart(poly a, const ring r_a, poly b, const ring r_b, const int start, const int end)
Definition: p_polys.h:1856
poly p_Sub(poly a, poly b, const ring r)
Definition: p_polys.cc:1986
poly p_PolyDiv(poly &p, const poly divisor, const BOOLEAN needResult, const ring r)
assumes that p and divisor are univariate polynomials in r, mentioning the same variable; assumes div...
Definition: p_polys.cc:1866
static BOOLEAN p_IsConstantComp(const poly p, const ring r)
like the respective p_LmIs* routines, except that p might be empty
Definition: p_polys.h:1999
int p_Size(poly p, const ring r)
Definition: p_polys.cc:3318
static long p_AddExp(poly p, int v, long ee, ring r)
Definition: p_polys.h:608
static poly p_LmInit(poly p, const ring r)
Definition: p_polys.h:1337
poly p_GcdMon(poly f, poly g, const ring r)
polynomial gcd for f=mon
Definition: p_polys.cc:5057
BOOLEAN p_ComparePolys(poly p1, poly p2, const ring r)
returns TRUE if p1 is a skalar multiple of p2 assume p1 != NULL and p2 != NULL
Definition: p_polys.cc:4692
static long p_FDeg(const poly p, const ring r)
Definition: p_polys.h:382
static unsigned long p_GetMaxExp(const unsigned long l, const ring r)
Definition: p_polys.h:783
int p_LowVar(poly p, const ring r)
the minimal index of used variables - 1
Definition: p_polys.cc:4796
poly p_CopyPowerProduct0(const poly p, const number n, const ring r)
like p_Head, but with coefficient n
Definition: p_polys.cc:5095
BOOLEAN p_DivisibleByRingCase(poly f, poly g, const ring r)
divisibility check over ground ring (which may contain zero divisors); TRUE iff LT(f) divides LT(g),...
Definition: p_polys.cc:1638
poly p_Homogen(poly p, int varnum, const ring r)
Definition: p_polys.cc:3335
static void p_ExpVectorCopy(poly d_p, poly s_p, const ring r)
Definition: p_polys.h:1315
poly p_Subst(poly p, int n, poly e, const ring r)
Definition: p_polys.cc:4074
static void p_LmDelete0(poly p, const ring r)
Definition: p_polys.h:735
long pLDeg1c_Deg(poly p, int *l, ring r)
Definition: p_polys.cc:941
static int p_Cmp(poly p1, poly p2, ring r)
Definition: p_polys.h:1729
BOOLEAN _p_LmTest(poly p, ring r, int level)
Definition: pDebug.cc:323
#define __pp_Mult_nn(p, n, r)
Definition: p_polys.h:1004
static void p_SetExpVL(poly p, int64 *ev, const ring r)
Definition: p_polys.h:1555
char * p_String(poly p, ring lmRing, ring tailRing)
Definition: polys0.cc:322
BOOLEAN p_HasNotCF(poly p1, poly p2, const ring r)
Definition: p_polys.cc:1329
void p_String0(poly p, ring lmRing, ring tailRing)
print p according to ShortOut in lmRing & tailRing
Definition: polys0.cc:223
void p_Write(poly p, ring lmRing, ring tailRing)
Definition: polys0.cc:342
long pLDeg1(poly p, int *l, ring r)
Definition: p_polys.cc:841
poly p_CopyPowerProduct(const poly p, const ring r)
like p_Head, but with coefficient 1
Definition: p_polys.cc:5107
static void p_SetExpV(poly p, int *ev, const ring r)
Definition: p_polys.h:1546
void p_ShallowDelete(poly *p, const ring r)
static poly pp_mm_Mult(poly p, poly m, const ring r)
Definition: p_polys.h:1043
static poly pp_Mult_mm(poly p, poly m, const ring r)
Definition: p_polys.h:1033
static int p_LtCmpNoAbs(poly p, poly q, const ring r)
Definition: p_polys.h:1649
static void p_MemSub_NegWeightAdjust(poly p, const ring r)
Definition: p_polys.h:1304
poly pp_DivideM(poly a, poly b, const ring r)
Definition: p_polys.cc:1629
long p_WFirstTotalDegree(poly p, ring r)
Definition: p_polys.cc:596
int p_Weight(int c, const ring r)
Definition: p_polys.cc:705
static int p_Comp_k_n(poly a, poly b, int k, ring r)
Definition: p_polys.h:642
poly p_ISet(long i, const ring r)
returns the poly representing the integer i
Definition: p_polys.cc:1297
static int p_LtCmpOrdSgnEqP(poly p, poly q, const ring r)
Definition: p_polys.h:1705
void p_ContentForGB(poly p, const ring r)
Definition: p_polys.cc:2420
void p_Vec2Polys(poly v, poly **p, int *len, const ring r)
Definition: p_polys.cc:3741
poly p_DiffOp(poly a, poly b, BOOLEAN multiply, const ring r)
Definition: p_polys.cc:1969
static void p_SetCompP(poly p, int i, ring r)
Definition: p_polys.h:256
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:490
poly p_Jet(poly p, int m, const ring R)
Definition: p_polys.cc:4502
poly p_TakeOutComp1(poly *p, int k, const ring r)
Definition: p_polys.cc:3500
static void p_ExpVectorDiff(poly pr, poly p1, poly p2, const ring r)
Definition: p_polys.h:1476
const char * p_Read(const char *s, poly &p, const ring r)
Definition: p_polys.cc:1370
static long p_MinComp(poly p, ring lmRing, ring tailRing)
Definition: p_polys.h:315
void p_String0Long(const poly p, ring lmRing, ring tailRing)
print p in a long way
Definition: polys0.cc:203
void p_String0Short(const poly p, ring lmRing, ring tailRing)
print p in a short way, if possible
Definition: polys0.cc:184
void p_Shift(poly *p, int i, const ring r)
shifts components of the vector p by i
Definition: p_polys.cc:4822
static long p_GetExpSum(poly p1, poly p2, int i, ring r)
Definition: p_polys.h:631
poly p_Power(poly p, int i, const ring r)
Definition: p_polys.cc:2193
poly p_Div_nn(poly p, const number n, const ring r)
Definition: p_polys.cc:1501
static poly p_mm_Mult(poly p, poly m, const ring r)
Definition: p_polys.h:1063
void p_Normalize(poly p, const ring r)
Definition: p_polys.cc:3929
void p_DeleteComp(poly *p, int k, const ring r)
Definition: p_polys.cc:3660
poly p_MDivide(poly a, poly b, const ring r)
Definition: p_polys.cc:1488
void p_Content(poly p, const ring r)
Definition: p_polys.cc:2291
void p_ProjectiveUnique(poly p, const ring r)
Definition: p_polys.cc:3208
void p_ContentRat(poly &ph, const ring r)
Definition: p_polys.cc:1740
void p_Norm(poly p1, const ring r)
Definition: p_polys.cc:3835
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
Definition: p_polys.h:249
poly p_Div_mm(poly p, const poly m, const ring r)
divide polynomial by monomial
Definition: p_polys.cc:1534
poly p_GetMaxExpP(poly p, ring r)
return monomial r such that GetExp(r,i) is maximum of all monomials in p; coeff == 0,...
Definition: p_polys.cc:1138
int p_GetVariables(poly p, int *e, const ring r)
set entry e[i] to 1 if var(i) occurs in p, ignore var(j) if e[j]>0 return #(e[i]>0)
Definition: p_polys.cc:1267
static long p_IncrExp(poly p, int v, ring r)
Definition: p_polys.h:593
int p_MinDeg(poly p, intvec *w, const ring R)
Definition: p_polys.cc:4564
static void p_ExpVectorSub(poly p1, poly p2, const ring r)
Definition: p_polys.h:1442
static unsigned long p_AddComp(poly p, unsigned long v, ring r)
Definition: p_polys.h:449
int p_MaxExpPerVar(poly p, int i, const ring r)
max exponent of variable x_i in p
Definition: p_polys.cc:5119
int p_Var(poly mi, const ring r)
Definition: p_polys.cc:4772
poly _p_Mult_q(poly p, poly q, const int copy, const ring r)
Returns: p * q, Destroys: if !copy then p, q Assumes: pLength(p) >= 2 pLength(q) >=2,...
Definition: p_Mult_q.cc:313
int p_Compare(const poly a, const poly b, const ring R)
Definition: p_polys.cc:5023
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:235
#define p_SetmComp
Definition: p_polys.h:246
poly p_mInit(const char *s, BOOLEAN &ok, const ring r)
Definition: p_polys.cc:1442
void p_LmDeleteAndNextRat(poly *p, int ishift, ring r)
Definition: p_polys.cc:1696
static poly p_Copy_noCheck(poly p, const ring r)
returns a copy of p (without any additional testing)
Definition: p_polys.h:838
static number p_SetCoeff(poly p, number n, ring r)
Definition: p_polys.h:414
static poly p_SortMerge(poly p, const ring r, BOOLEAN revert=FALSE)
Definition: p_polys.h:1231
static poly p_LmShallowCopyDelete(poly p, const ring r)
Definition: p_polys.h:1395
static poly pReverse(poly p)
Definition: p_polys.h:337
static poly p_Merge_q(poly p, poly q, const ring r)
Definition: p_polys.h:1214
BOOLEAN p_IsHomogeneousW(poly p, const intvec *w, const ring r)
Definition: p_polys.cc:3408
long pLDegb(poly p, int *l, ring r)
Definition: p_polys.cc:811
static void p_GetExpVL(poly p, int64 *ev, const ring r)
Definition: p_polys.h:1531
static int p_LtCmp(poly p, poly q, const ring r)
Definition: p_polys.h:1623
static BOOLEAN p_LmIsConstantComp(const poly p, const ring r)
Definition: p_polys.h:1008
static poly p_Head(const poly p, const ring r)
copy the (leading) term of p
Definition: p_polys.h:862
static int p_LmCmp(poly p, poly q, const ring r)
Definition: p_polys.h:1582
poly p_Series(int n, poly p, poly u, intvec *w, const ring R)
Definition: p_polys.cc:4614
long p_WTotaldegree(poly p, const ring r)
Definition: p_polys.cc:613
static BOOLEAN p_LmShortDivisibleBy(poly a, unsigned long sev_a, poly b, unsigned long not_sev_b, const ring r)
Definition: p_polys.h:1931
long p_DegW(poly p, const int *w, const ring R)
Definition: p_polys.cc:690
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:471
static BOOLEAN p_LmIsConstant(const poly p, const ring r)
Definition: p_polys.h:1025
p_SetmProc p_GetSetmProc(const ring r)
Definition: p_polys.cc:560
static long p_MultExp(poly p, int v, long ee, ring r)
Definition: p_polys.h:623
static BOOLEAN p_LmDivisibleByNoComp(poly a, poly b, const ring r)
Definition: p_polys.h:1883
static BOOLEAN p_IsOne(const poly p, const ring R)
either poly(1) or gen(k)?!
Definition: p_polys.h:2012
static BOOLEAN p_IsConstant(const poly p, const ring r)
Definition: p_polys.h:2005
static void p_SetExpVLV(poly p, int64 *ev, int64 comp, const ring r)
Definition: p_polys.h:1566
BOOLEAN p_OneComp(poly p, const ring r)
return TRUE if all monoms have the same component
Definition: p_polys.cc:1208
static BOOLEAN _p_LmDivisibleByNoCompPart(poly a, const ring r_a, poly b, const ring r_b, const int start, const int end)
Definition: p_polys.h:1837
BOOLEAN p_CheckRing(ring r)
Definition: pDebug.cc:128
poly p_Cleardenom(poly p, const ring r)
Definition: p_polys.cc:2910
static BOOLEAN _p_LmDivisibleBy(poly a, poly b, const ring r)
Definition: p_polys.h:1871
static unsigned long p_GetTotalDegree(const unsigned long l, const ring r, const int number_of_exps)
Definition: p_polys.h:812
BOOLEAN p_LmCheckIsFromRing(poly p, ring r)
Definition: pDebug.cc:71
static poly p_New(const ring, omBin bin)
Definition: p_polys.h:666
void p_Split(poly p, poly *r)
Definition: p_polys.cc:1320
poly n_PermNumber(const number z, const int *par_perm, const int OldPar, const ring src, const ring dst)
Definition: p_polys.cc:4143
static poly p_GetExp_k_n(poly p, int l, int k, const ring r)
Definition: p_polys.h:1374
static BOOLEAN p_LmShortDivisibleByNoComp(poly a, unsigned long sev_a, poly b, unsigned long not_sev_b, const ring r)
Definition: p_polys.h:1951
static poly pp_Mult_nn(poly p, number n, const ring r)
Definition: p_polys.h:994
poly p_GetCoeffRat(poly p, int ishift, ring r)
Definition: p_polys.cc:1718
BOOLEAN p_VectorHasUnitB(poly p, int *k, const ring r)
Definition: p_polys.cc:3444
poly p_Vec2Poly(poly v, int k, const ring r)
Definition: p_polys.cc:3689
static BOOLEAN p_LmDivisibleBy(poly a, poly b, const ring r)
Definition: p_polys.h:1897
poly p_LcmRat(const poly a, const poly b, const long lCompM, const ring r)
Definition: p_polys.cc:1673
static BOOLEAN p_DivisibleBy(poly a, poly b, const ring r)
Definition: p_polys.h:1906
static BOOLEAN p_ExpVectorEqual(poly p1, poly p2, const ring r)
Definition: p_polys.h:1491
long pLDeg1_Totaldegree(poly p, int *l, ring r)
Definition: p_polys.cc:975
void p_SetModDeg(intvec *w, ring r)
Definition: p_polys.cc:3789
static poly p_ShallowCopyDelete(poly p, const ring r, omBin bin)
Definition: p_polys.h:930
static int64 p_GetExpVLV(poly p, int64 *ev, const ring r)
Definition: p_polys.h:1538
void p_TakeOutComp(poly *p, long comp, poly *q, int *lq, const ring r)
Definition: p_polys.cc:3612
static long p_MaxComp(poly p, ring lmRing, ring tailRing)
Definition: p_polys.h:294
static poly p_Mult_nn(poly p, number n, const ring r)
Definition: p_polys.h:960
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:903
BOOLEAN p_HasNotCFRing(poly p1, poly p2, const ring r)
Definition: p_polys.cc:1345
poly p_One(const ring r)
Definition: p_polys.cc:1313
static long p_DecrExp(poly p, int v, ring r)
Definition: p_polys.h:600
static int p_LtCmpOrdSgnDiffM(poly p, poly q, const ring r)
Definition: p_polys.h:1671
static BOOLEAN _p_LmDivisibleByNoComp(poly a, poly b, const ring r)
return: FALSE, if there exists i, such that a->exp[i] > b->exp[i] TRUE, otherwise (1) Consider long v...
Definition: p_polys.h:1767
void p_VectorHasUnit(poly p, int *k, int *len, const ring r)
Definition: p_polys.cc:3467
static unsigned pLength(poly a)
Definition: p_polys.h:191
static void p_GetExpV(poly p, int *ev, const ring r)
Definition: p_polys.h:1522
BOOLEAN p_CheckPolyRing(poly p, ring r)
Definition: pDebug.cc:112
void p_Write0(poly p, ring lmRing, ring tailRing)
Definition: polys0.cc:332
long pLDeg1c_Totaldegree(poly p, int *l, ring r)
Definition: p_polys.cc:1005
static long p_GetOrder(poly p, ring r)
Definition: p_polys.h:423
int p_IsUnivariate(poly p, const ring r)
return i, if poly depends only on var(i)
Definition: p_polys.cc:1247
poly p_NSet(number n, const ring r)
returns the poly representing the number n, destroys n
Definition: p_polys.cc:1469
static poly pp_Mult_qq(poly p, poly q, const ring r)
Definition: p_polys.h:1153
poly p_PermPoly(poly p, const int *perm, const ring OldRing, const ring dst, nMapFunc nMap, const int *par_perm=NULL, int OldPar=0, BOOLEAN use_mult=FALSE)
Definition: p_polys.cc:4246
static int p_LtCmpOrdSgnEqM(poly p, poly q, const ring r)
Definition: p_polys.h:1696
static poly p_LmFreeAndNext(poly p, ring)
Definition: p_polys.h:713
#define pDivAssume(x)
Definition: p_polys.h:1284
static poly p_Mult_mm(poly p, poly m, const ring r)
Definition: p_polys.h:1053
void p_Cleardenom_n(poly p, const ring r, number &c)
Definition: p_polys.cc:3019
long p_WDegree(poly p, const ring r)
Definition: p_polys.cc:714
long pLDeg1c(poly p, int *l, ring r)
Definition: p_polys.cc:877
poly p_Last(const poly a, int &l, const ring r)
Definition: p_polys.cc:4737
static void p_LmFree(poly p, ring)
Definition: p_polys.h:685
static poly p_Minus_mm_Mult_qq(poly p, const poly m, const poly q, int &lp, int lq, const poly spNoether, const ring r)
Definition: p_polys.h:1072
static poly p_Plus_mm_Mult_qq(poly p, poly m, poly q, int &lp, int lq, const ring r)
Definition: p_polys.h:1185
void pEnlargeSet(poly **p, int length, int increment)
Definition: p_polys.cc:3812
static BOOLEAN p_IsUnit(const poly p, const ring r)
Definition: p_polys.h:2032
static poly p_Init(const ring r, omBin bin)
Definition: p_polys.h:1322
BOOLEAN p_IsHomogeneous(poly p, const ring r)
Definition: p_polys.cc:3384
poly p_Head0(const poly p, const ring r)
like p_Head, but allow NULL coeff
Definition: p_polys.cc:5113
static poly p_LmDeleteAndNext(poly p, const ring r)
Definition: p_polys.h:757
BOOLEAN pHaveCommonMonoms(poly p, poly q)
Definition: pDebug.cc:175
unsigned long p_GetShortExpVector(const poly a, const ring r)
Definition: p_polys.cc:4897
static poly pp_Mult_Coeff_mm_DivSelect(poly p, const poly m, const ring r)
Definition: p_polys.h:1092
poly pp_JetW(poly p, int m, int *w, const ring R)
Definition: p_polys.cc:4519
static BOOLEAN p_LmDivisibleByPart(poly a, poly b, const ring r, const int start, const int end)
Definition: p_polys.h:1862
long p_Deg(poly a, const ring r)
Definition: p_polys.cc:587
static poly p_SortAdd(poly p, const ring r, BOOLEAN revert=FALSE)
Definition: p_polys.h:1221
void p_SimpleContent(poly p, int s, const ring r)
Definition: p_polys.cc:2629
static poly p_Copy(poly p, const ring r)
returns a copy of p
Definition: p_polys.h:848
static long p_LDeg(const poly p, int *l, const ring r)
Definition: p_polys.h:383
number p_InitContent(poly ph, const ring r)
Definition: p_polys.cc:2700
void p_Vec2Array(poly v, poly *p, int len, const ring r)
julia: vector to already allocated array (len=p_MaxComp(v,r))
Definition: p_polys.cc:3711
static long p_Totaldegree(poly p, const ring r)
Definition: p_polys.h:1509
unsigned long p_GetMaxExpL(poly p, const ring r, unsigned long l_max=0)
return the maximal exponent of p in form of the maximal long var
Definition: p_polys.cc:1175
static BOOLEAN p_LmExpVectorAddIsOk(const poly p1, const poly p2, const ring r)
Definition: p_polys.h:2040
static int p_LtCmpOrdSgnDiffP(poly p, poly q, const ring r)
Definition: p_polys.h:1680
BOOLEAN _pp_Test(poly p, ring lmRing, ring tailRing, int level)
Definition: pDebug.cc:333
void p_Lcm(const poly a, const poly b, poly m, const ring r)
Definition: p_polys.cc:1651
poly p_ChineseRemainder(poly *xx, number *x, number *q, int rl, CFArray &inv_cache, const ring R)
Definition: p_polys.cc:88
#define p_Test(p, r)
Definition: p_polys.h:162
#define __p_Mult_nn(p, n, r)
Definition: p_polys.h:973
poly p_JetW(poly p, int m, int *w, const ring R)
Definition: p_polys.cc:4546
static BOOLEAN p_IsConstantPoly(const poly p, const ring r)
Definition: p_polys.h:2019
void p_wrp(poly p, ring lmRing, ring tailRing)
Definition: polys0.cc:373
BOOLEAN p_EqualPolys(poly p1, poly p2, const ring r)
Definition: p_polys.cc:4628
long pLDeg0c(poly p, int *l, ring r)
Definition: p_polys.cc:770
static void p_ExpVectorAddSub(poly p1, poly p2, poly p3, const ring r)
Definition: p_polys.h:1458
BOOLEAN rOrd_SetCompRequiresSetm(const ring r)
return TRUE if p_SetComp requires p_Setm
Definition: ring.cc:1993
void(* p_SetmProc)(poly p, const ring r)
Definition: ring.h:39
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
Definition: ring.h:400
long(* pFDegProc)(poly p, ring r)
Definition: ring.h:38
long(* pLDegProc)(poly p, int *length, ring r)
Definition: ring.h:37
@ ro_syz
Definition: ring.h:60
@ ro_cp
Definition: ring.h:58
@ ro_wp_neg
Definition: ring.h:56
@ ro_am
Definition: ring.h:54
@ ro_syzcomp
Definition: ring.h:59
static BOOLEAN rIsNCRing(const ring r)
Definition: ring.h:421
#define rField_is_Ring(R)
Definition: ring.h:486
poly sBucketSortMerge(poly p, const ring r)
Sorts p with bucketSort: assumes all monomials of p are different.
Definition: sbuckets.cc:332
poly sBucketSortAdd(poly p, const ring r)
Sorts p with bucketSort: p may have equal monomials.
Definition: sbuckets.cc:368
#define R
Definition: sirandom.c:27
#define loop
Definition: structs.h:75