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