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);
52unsigned long p_GetShortExpVector0(const poly a, const ring r);
53unsigned long p_GetShortExpVector1(const poly a, const ring r);
54
55#ifdef HAVE_RINGS
56/*! divisibility check over ground ring (which may contain zero divisors);
57 TRUE iff LT(f) divides LT(g), i.e., LT(f)*c*m = LT(g), for some
58 coefficient c and some monomial m;
59 does not take components into account
60 */
61BOOLEAN p_DivisibleByRingCase(poly f, poly g, const ring r);
62#endif
63
64/***************************************************************
65 *
66 * Misc things on polys
67 *
68 ***************************************************************/
69
70poly p_One(const ring r);
71
72int p_MinDeg(poly p,intvec *w, const ring R);
73
74long p_DegW(poly p, const int *w, const ring R);
75
76/// return TRUE if all monoms have the same component
77BOOLEAN p_OneComp(poly p, const ring r);
78
79/// return i, if head depends only on var(i)
80int p_IsPurePower(const poly p, const ring r);
81
82/// return i, if poly depends only on var(i)
83int p_IsUnivariate(poly p, const ring r);
84
85/// set entry e[i] to 1 if var(i) occurs in p, ignore var(j) if e[j]>0
86/// return #(e[i]>0)
87int p_GetVariables(poly p, int * e, const ring r);
88
89/// returns the poly representing the integer i
90poly p_ISet(long i, const ring r);
91
92/// returns the poly representing the number n, destroys n
93poly p_NSet(number n, const ring r);
94
95void p_Vec2Polys(poly v, poly**p, int *len, const ring r);
96poly p_Vec2Poly(poly v, int k, const ring r);
97
98/// julia: vector to already allocated array (len=p_MaxComp(v,r))
99void p_Vec2Array(poly v, poly *p, int len, const ring r);
100
101/***************************************************************
102 *
103 * Copying/Deletion of polys: args may be NULL
104 *
105 ***************************************************************/
106
107// simply deletes monomials, does not free coeffs
108void p_ShallowDelete(poly *p, const ring r);
109
110
111
112/***************************************************************
113 *
114 * Copying/Deletion of polys: args may be NULL
115 * - p/q as arg mean a poly
116 * - m a monomial
117 * - n a number
118 * - pp (resp. qq, mm, nn) means arg is constant
119 * - p (resp, q, m, n) means arg is destroyed
120 *
121 ***************************************************************/
122
123poly p_Sub(poly a, poly b, const ring r);
124
125poly p_Power(poly p, int i, const ring r);
126
127
128/***************************************************************
129 *
130 * PDEBUG stuff
131 *
132 ***************************************************************/
133#ifdef PDEBUG
134// Returns TRUE if m is monom of p, FALSE otherwise
135BOOLEAN pIsMonomOf(poly p, poly m);
136// Returns TRUE if p and q have common monoms
137BOOLEAN pHaveCommonMonoms(poly p, poly q);
138
139// p_Check* routines return TRUE if everything is ok,
140// else, they report error message and return false
141
142// check if Lm(p) is from ring r
143BOOLEAN p_LmCheckIsFromRing(poly p, ring r);
144// check if Lm(p) != NULL, r != NULL and initialized && Lm(p) is from r
145BOOLEAN p_LmCheckPolyRing(poly p, ring r);
146// check if all monoms of p are from ring r
147BOOLEAN p_CheckIsFromRing(poly p, ring r);
148// check r != NULL and initialized && all monoms of p are from r
149BOOLEAN p_CheckPolyRing(poly p, ring r);
150// check if r != NULL and initialized
151BOOLEAN p_CheckRing(ring r);
152// only do check if cond
153
154
155#define pIfThen(cond, check) do {if (cond) {check;}} while (0)
156
157BOOLEAN _p_Test(poly p, ring r, int level);
158BOOLEAN _p_LmTest(poly p, ring r, int level);
159BOOLEAN _pp_Test(poly p, ring lmRing, ring tailRing, int level);
160
161#define p_Test(p,r) _p_Test(p, r, PDEBUG)
162#define p_LmTest(p,r) _p_LmTest(p, r, PDEBUG)
163#define pp_Test(p, lmRing, tailRing) _pp_Test(p, lmRing, tailRing, PDEBUG)
164
165#else // ! PDEBUG
166
167#define pIsMonomOf(p, q) (TRUE)
168#define pHaveCommonMonoms(p, q) (TRUE)
169#define p_LmCheckIsFromRing(p,r) (TRUE)
170#define p_LmCheckPolyRing(p,r) (TRUE)
171#define p_CheckIsFromRing(p,r) (TRUE)
172#define p_CheckPolyRing(p,r) (TRUE)
173#define p_CheckRing(r) (TRUE)
174#define P_CheckIf(cond, check) (TRUE)
175
176#define p_Test(p,r) (TRUE)
177#define p_LmTest(p,r) (TRUE)
178#define pp_Test(p, lmRing, tailRing) (TRUE)
179
180#endif
181
182/***************************************************************
183 *
184 * Misc stuff
185 *
186 ***************************************************************/
187/*2
188* returns the length of a polynomial (numbers of monomials)
189*/
190static inline int pLength(poly a)
191{
192 int l = 0;
193 while (a!=NULL)
194 {
195 pIter(a);
196 l++;
197 }
198 return l;
199}
200
201// returns the length of a polynomial (numbers of monomials) and the last mon.
202// respect syzComp
203poly p_Last(const poly a, int &l, const ring r);
204
205/*----------------------------------------------------*/
206
207void p_Norm(poly p1, const ring r);
208void p_Normalize(poly p,const ring r);
209void p_ProjectiveUnique(poly p,const ring r);
210
211void p_ContentForGB(poly p, const ring r);
212void p_Content(poly p, const ring r);
213#if 1
214// currently only used by Singular/janet
215void p_SimpleContent(poly p, int s, const ring r);
216number p_InitContent(poly ph, const ring r);
217#endif
218
219poly p_Cleardenom(poly p, const ring r);
220void p_Cleardenom_n(poly p, const ring r,number &c);
221//number p_GetAllDenom(poly ph, const ring r);// unused
222
223int p_Size( poly p, const ring r );
224
225// homogenizes p by multiplying certain powers of the varnum-th variable
226poly p_Homogen (poly p, int varnum, const ring r);
227
228BOOLEAN p_IsHomogeneous (poly p, const ring r);
229BOOLEAN p_IsHomogeneousW (poly p, const intvec *w, const ring r);
230BOOLEAN p_IsHomogeneousW (poly p, const intvec *w, const intvec *module_w,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 module 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 explanations
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/Initialization/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) || defined(XALLOC_BIN)
681static inline void p_LmFree(poly p, ring r)
682#else
683static inline void p_LmFree(poly p, ring)
684#endif
685{
687 #ifdef XALLOC_BIN
688 omFreeBin(p,r->PolyBin);
689 #else
691 #endif
692}
693#if (PDEBUG > 2) || defined(XALLOC_BIN)
694static inline void p_LmFree(poly *p, ring r)
695#else
696static inline void p_LmFree(poly *p, ring)
697#endif
698{
700 poly h = *p;
701 *p = pNext(h);
702 #ifdef XALLOC_BIN
703 omFreeBin(h,r->PolyBin);
704 #else
706 #endif
707}
708#if (PDEBUG > 2) || defined(XALLOC_BIN)
709static inline poly p_LmFreeAndNext(poly p, ring r)
710#else
711static inline poly p_LmFreeAndNext(poly p, ring)
712#endif
713{
715 poly pnext = pNext(p);
716 #ifdef XALLOC_BIN
717 omFreeBin(p,r->PolyBin);
718 #else
720 #endif
721 return pnext;
722}
723static inline void p_LmDelete(poly p, const ring r)
724{
726 n_Delete(&pGetCoeff(p), r->cf);
727 #ifdef XALLOC_BIN
728 omFreeBin(p,r->PolyBin);
729 #else
731 #endif
732}
733static inline void p_LmDelete0(poly p, const ring r)
734{
736 if (pGetCoeff(p)!=NULL) n_Delete(&pGetCoeff(p), r->cf);
737 #ifdef XALLOC_BIN
738 omFreeBin(p,r->PolyBin);
739 #else
741 #endif
742}
743static inline void p_LmDelete(poly *p, const ring r)
744{
746 poly h = *p;
747 *p = pNext(h);
748 n_Delete(&pGetCoeff(h), r->cf);
749 #ifdef XALLOC_BIN
750 omFreeBin(h,r->PolyBin);
751 #else
753 #endif
754}
755static inline poly p_LmDeleteAndNext(poly p, const ring r)
756{
758 poly pnext = pNext(p);
759 n_Delete(&pGetCoeff(p), r->cf);
760 #ifdef XALLOC_BIN
761 omFreeBin(p,r->PolyBin);
762 #else
764 #endif
765 return pnext;
766}
767
768/***************************************************************
769 *
770 * Misc routines
771 *
772 ***************************************************************/
773
774/// return the maximal exponent of p in form of the maximal long var
775unsigned long p_GetMaxExpL(poly p, const ring r, unsigned long l_max = 0);
776
777/// return monomial r such that GetExp(r,i) is maximum of all
778/// monomials in p; coeff == 0, next == NULL, ord is not set
779poly p_GetMaxExpP(poly p, ring r);
780
781static inline unsigned long p_GetMaxExp(const unsigned long l, const ring r)
782{
783 unsigned long bitmask = r->bitmask;
784 unsigned long max = (l & bitmask);
785 unsigned long j = r->ExpPerLong - 1;
786
787 if (j > 0)
788 {
789 unsigned long i = r->BitsPerExp;
790 long e;
791 loop
792 {
793 e = ((l >> i) & bitmask);
794 if ((unsigned long) e > max)
795 max = e;
796 j--;
797 if (j==0) break;
798 i += r->BitsPerExp;
799 }
800 }
801 return max;
802}
803
804static inline unsigned long p_GetMaxExp(const poly p, const ring r)
805{
806 return p_GetMaxExp(p_GetMaxExpL(p, r), r);
807}
808
809static inline unsigned long
810p_GetTotalDegree(const unsigned long l, const ring r, const int number_of_exps)
811{
812 const unsigned long bitmask = r->bitmask;
813 unsigned long sum = (l & bitmask);
814 unsigned long j = number_of_exps - 1;
815
816 if (j > 0)
817 {
818 unsigned long i = r->BitsPerExp;
819 loop
820 {
821 sum += ((l >> i) & bitmask);
822 j--;
823 if (j==0) break;
824 i += r->BitsPerExp;
825 }
826 }
827 return sum;
828}
829
830/***************************************************************
831 *
832 * Dispatcher to r->p_Procs, they do the tests/checks
833 *
834 ***************************************************************/
835/// returns a copy of p (without any additional testing)
836static inline poly p_Copy_noCheck(poly p, const ring r)
837{
838 /*assume(p!=NULL);*/
839 assume(r != NULL);
840 assume(r->p_Procs != NULL);
841 assume(r->p_Procs->p_Copy != NULL);
842 return r->p_Procs->p_Copy(p, r);
843}
844
845/// returns a copy of p
846static inline poly p_Copy(poly p, const ring r)
847{
848 if (p!=NULL)
849 {
850 p_Test(p,r);
851 const poly pp = p_Copy_noCheck(p, r);
852 p_Test(pp,r);
853 return pp;
854 }
855 else
856 return NULL;
857}
858
859/// copy the (leading) term of p
860static inline poly p_Head(const poly p, const ring r)
861{
862 if (p == NULL) return NULL;
864 poly np;
865 omTypeAllocBin(poly, np, r->PolyBin);
866 p_SetRingOfLm(np, r);
867 memcpy(np->exp, p->exp, r->ExpL_Size*sizeof(long));
868 pNext(np) = NULL;
869 pSetCoeff0(np, n_Copy(pGetCoeff(p), r->cf));
870 return np;
871}
872
873/// like p_Head, but allow NULL coeff
874poly p_Head0(const poly p, const ring r);
875
876/// like p_Head, but with coefficient 1
877poly p_CopyPowerProduct(const poly p, const ring r);
878
879/// like p_Head, but with coefficient n
880poly p_CopyPowerProduct0(const poly p, const number n, const ring r);
881
882/// returns a copy of p with Lm(p) from lmRing and Tail(p) from tailRing
883static inline poly p_Copy(poly p, const ring lmRing, const ring tailRing)
884{
885 if (p != NULL)
886 {
887#ifndef PDEBUG
888 if (tailRing == lmRing)
889 return p_Copy_noCheck(p, tailRing);
890#endif
891 poly pres = p_Head(p, lmRing);
892 if (pNext(p)!=NULL)
893 pNext(pres) = p_Copy_noCheck(pNext(p), tailRing);
894 return pres;
895 }
896 else
897 return NULL;
898}
899
900// deletes *p, and sets *p to NULL
901static inline void p_Delete(poly *p, const ring r)
902{
903 assume( p!= NULL );
904 assume( r!= NULL );
905 if ((*p)!=NULL) r->p_Procs->p_Delete(p, r);
906}
907
908static inline void p_Delete(poly *p, const ring lmRing, const ring tailRing)
909{
910 assume( p!= NULL );
911 if (*p != NULL)
912 {
913#ifndef PDEBUG
914 if (tailRing == lmRing)
915 {
916 p_Delete(p, tailRing);
917 return;
918 }
919#endif
920 if (pNext(*p) != NULL)
921 p_Delete(&pNext(*p), tailRing);
922 p_LmDelete(p, lmRing);
923 }
924}
925
926// copies monomials of p, allocates new monomials from bin,
927// deletes monomials of p
928static inline poly p_ShallowCopyDelete(poly p, const ring r, omBin bin)
929{
931 pAssume2(omSizeWOfBin(r->PolyBin) == omSizeWOfBin(bin));
932 return r->p_Procs->p_ShallowCopyDelete(p, r, bin);
933}
934
935// returns p+q, destroys p and q
936static inline poly p_Add_q(poly p, poly q, const ring r)
937{
938 assume( (p != q) || (p == NULL && q == NULL) );
939 if (q==NULL) return p;
940 if (p==NULL) return q;
941 int shorter;
942 return r->p_Procs->p_Add_q(p, q, shorter, r);
943}
944
945/// like p_Add_q, except that if lp == pLength(lp) lq == pLength(lq) then lp == pLength(p+q)
946static inline poly p_Add_q(poly p, poly q, int &lp, int lq, const ring r)
947{
948 assume( (p != q) || (p == NULL && q == NULL) );
949 if (q==NULL) return p;
950 if (p==NULL) { lp=lq; return q; }
951 int shorter;
952 poly res = r->p_Procs->p_Add_q(p, q, shorter, r);
953 lp += lq - shorter;
954 return res;
955}
956
957// returns p*n, destroys p
958static inline poly p_Mult_nn(poly p, number n, const ring r)
959{
960 if (p==NULL) return NULL;
961 if (n_IsOne(n, r->cf))
962 return p;
963 else if (n_IsZero(n, r->cf))
964 {
965 p_Delete(&p, r); // NOTE: without p_Delete - memory leak!
966 return NULL;
967 }
968 else
969 return r->p_Procs->p_Mult_nn(p, n, r);
970}
971#define __p_Mult_nn(p,n,r) r->p_Procs->p_Mult_nn(p, n, r)
972
973static inline poly p_Mult_nn(poly p, number n, const ring lmRing,
974 const ring tailRing)
975{
976 assume(p!=NULL);
977#ifndef PDEBUG
978 if (lmRing == tailRing)
979 return p_Mult_nn(p, n, tailRing);
980#endif
981 poly pnext = pNext(p);
982 pNext(p) = NULL;
983 p = lmRing->p_Procs->p_Mult_nn(p, n, lmRing);
984 if (pnext!=NULL)
985 {
986 pNext(p) = tailRing->p_Procs->p_Mult_nn(pnext, n, tailRing);
987 }
988 return p;
989}
990
991// returns p*n, does not destroy p
992static inline poly pp_Mult_nn(poly p, number n, const ring r)
993{
994 if (p==NULL) return NULL;
995 if (n_IsOne(n, r->cf))
996 return p_Copy(p, r);
997 else if (n_IsZero(n, r->cf))
998 return NULL;
999 else
1000 return r->p_Procs->pp_Mult_nn(p, n, r);
1001}
1002#define __pp_Mult_nn(p,n,r) r->p_Procs->pp_Mult_nn(p, n, r)
1003
1004// test if the monomial is a constant as a vector component
1005// i.e., test if all exponents are zero
1006static inline BOOLEAN p_LmIsConstantComp(const poly p, const ring r)
1007{
1008 //p_LmCheckPolyRing(p, r);
1009 int i = r->VarL_Size - 1;
1010
1011 do
1012 {
1013 if (p->exp[r->VarL_Offset[i]] != 0)
1014 return FALSE;
1015 i--;
1016 }
1017 while (i >= 0);
1018 return TRUE;
1019}
1020
1021// test if monomial is a constant, i.e. if all exponents and the component
1022// is zero
1023static inline BOOLEAN p_LmIsConstant(const poly p, const ring r)
1024{
1025 if (p_LmIsConstantComp(p, r))
1026 return (p_GetComp(p, r) == 0);
1027 return FALSE;
1028}
1029
1030// returns Copy(p)*m, does neither destroy p nor m
1031static inline poly pp_Mult_mm(poly p, poly m, const ring r)
1032{
1033 if (p==NULL) return NULL;
1034 if (p_LmIsConstant(m, r))
1035 return __pp_Mult_nn(p, pGetCoeff(m), r);
1036 else
1037 return r->p_Procs->pp_Mult_mm(p, m, r);
1038}
1039
1040// returns m*Copy(p), does neither destroy p nor m
1041static inline poly pp_mm_Mult(poly p, poly m, const ring r)
1042{
1043 if (p==NULL) return NULL;
1044 if (p_LmIsConstant(m, r))
1045 return __pp_Mult_nn(p, pGetCoeff(m), r);
1046 else
1047 return r->p_Procs->pp_mm_Mult(p, m, r);
1048}
1049
1050// returns p*m, destroys p, const: m
1051static inline poly p_Mult_mm(poly p, poly m, const ring r)
1052{
1053 if (p==NULL) return NULL;
1054 if (p_LmIsConstant(m, r))
1055 return __p_Mult_nn(p, pGetCoeff(m), r);
1056 else
1057 return r->p_Procs->p_Mult_mm(p, m, r);
1058}
1059
1060// returns m*p, destroys p, const: m
1061static inline poly p_mm_Mult(poly p, poly m, const ring r)
1062{
1063 if (p==NULL) return NULL;
1064 if (p_LmIsConstant(m, r))
1065 return __p_Mult_nn(p, pGetCoeff(m), r);
1066 else
1067 return r->p_Procs->p_mm_Mult(p, m, r);
1068}
1069
1070static inline poly p_Minus_mm_Mult_qq(poly p, const poly m, const poly q, int &lp, int lq,
1071 const poly spNoether, const ring r)
1072{
1073 int shorter;
1074 const poly res = r->p_Procs->p_Minus_mm_Mult_qq(p, m, q, shorter, spNoether, r);
1075 lp += lq - shorter;
1076// assume( lp == pLength(res) );
1077 return res;
1078}
1079
1080// return p - m*Copy(q), destroys p; const: p,m
1081static inline poly p_Minus_mm_Mult_qq(poly p, const poly m, const poly q, const ring r)
1082{
1083 int shorter;
1084
1085 return r->p_Procs->p_Minus_mm_Mult_qq(p, m, q, shorter, NULL, r);
1086}
1087
1088
1089// returns p*Coeff(m) for such monomials pm of p, for which m is divisible by pm
1090static inline poly pp_Mult_Coeff_mm_DivSelect(poly p, const poly m, const ring r)
1091{
1092 int shorter;
1093 return r->p_Procs->pp_Mult_Coeff_mm_DivSelect(p, m, shorter, r);
1094}
1095
1096// returns p*Coeff(m) for such monomials pm of p, for which m is divisible by pm
1097// if lp is length of p on input then lp is length of returned poly on output
1098static inline poly pp_Mult_Coeff_mm_DivSelect(poly p, int &lp, const poly m, const ring r)
1099{
1100 int shorter;
1101 poly pp = r->p_Procs->pp_Mult_Coeff_mm_DivSelect(p, m, shorter, r);
1102 lp -= shorter;
1103 return pp;
1104}
1105
1106// returns -p, destroys p
1107static inline poly p_Neg(poly p, const ring r)
1108{
1109 return r->p_Procs->p_Neg(p, r);
1110}
1111
1112poly _p_Mult_q(poly p, poly q, const int copy, const ring r);
1113#ifdef HAVE_RINGS
1114poly _p_Mult_q_Normal_ZeroDiv(poly p, poly q, const int copy, const ring r);
1115#endif
1116
1117// returns p*q, destroys p and q
1118static inline poly p_Mult_q(poly p, poly q, const ring r)
1119{
1120 assume( (p != q) || (p == NULL && q == NULL) );
1121
1122 if (UNLIKELY(p == NULL))
1123 {
1124 p_Delete(&q, r);
1125 return NULL;
1126 }
1127 if (UNLIKELY(q == NULL))
1128 {
1129 p_Delete(&p, r);
1130 return NULL;
1131 }
1132
1133 if (pNext(p) == NULL)
1134 {
1135 q = r->p_Procs->p_mm_Mult(q, p, r);
1136 p_LmDelete(&p, r);
1137 return q;
1138 }
1139
1140 if (pNext(q) == NULL)
1141 {
1142 p = r->p_Procs->p_Mult_mm(p, q, r);
1143 p_LmDelete(&q, r);
1144 return p;
1145 }
1146#if defined(HAVE_PLURAL) || defined(HAVE_SHIFTBBA)
1147 if (UNLIKELY(rIsNCRing(r)))
1148 return _nc_p_Mult_q(p, q, r);
1149 else
1150#endif
1151#ifdef HAVE_RINGS
1152 if (UNLIKELY(!nCoeff_is_Domain(r->cf)))
1153 return _p_Mult_q_Normal_ZeroDiv(p, q, 0, r);
1154 else
1155#endif
1156 return _p_Mult_q(p, q, 0, r);
1157}
1158
1159// returns p*q, does neither destroy p nor q
1160static inline poly pp_Mult_qq(poly p, poly q, const ring r)
1161{
1162 if (UNLIKELY(p == NULL || q == NULL)) return NULL;
1163
1164 if (pNext(p) == NULL)
1165 {
1166 return r->p_Procs->pp_mm_Mult(q, p, r);
1167 }
1168
1169 if (pNext(q) == NULL)
1170 {
1171 return r->p_Procs->pp_Mult_mm(p, q, r);
1172 }
1173
1174 poly qq = q;
1175 if (UNLIKELY(p == q))
1176 qq = p_Copy(q, r);
1177
1178 poly res;
1179#if defined(HAVE_PLURAL) || defined(HAVE_SHIFTBBA)
1180 if (UNLIKELY(rIsNCRing(r)))
1181 res = _nc_pp_Mult_qq(p, qq, r);
1182 else
1183#endif
1184#ifdef HAVE_RINGS
1185 if (UNLIKELY(!nCoeff_is_Domain(r->cf)))
1186 res = _p_Mult_q_Normal_ZeroDiv(p, qq, 1, r);
1187 else
1188#endif
1189 res = _p_Mult_q(p, qq, 1, r);
1190
1191 if (UNLIKELY(qq != q))
1192 p_Delete(&qq, r);
1193 return res;
1194}
1195
1196// returns p + m*q destroys p, const: q, m
1197static inline poly p_Plus_mm_Mult_qq(poly p, poly m, poly q, int &lp, int lq,
1198 const ring r)
1199{
1200#ifdef HAVE_PLURAL
1201 if (rIsPluralRing(r))
1202 return nc_p_Plus_mm_Mult_qq(p, m, q, lp, lq, r);
1203#endif
1204
1205// this should be implemented more efficiently
1206 poly res;
1207 int shorter;
1208 number n_old = pGetCoeff(m);
1209 number n_neg = n_Copy(n_old, r->cf);
1210 n_neg = n_InpNeg(n_neg, r->cf);
1211 pSetCoeff0(m, n_neg);
1212 res = r->p_Procs->p_Minus_mm_Mult_qq(p, m, q, shorter, NULL, r);
1213 lp = (lp + lq) - shorter;
1214 pSetCoeff0(m, n_old);
1215 n_Delete(&n_neg, r->cf);
1216 return res;
1217}
1218
1219static inline poly p_Plus_mm_Mult_qq(poly p, poly m, poly q, const ring r)
1220{
1221 int lp = 0, lq = 0;
1222 return p_Plus_mm_Mult_qq(p, m, q, lp, lq, r);
1223}
1224
1225// returns merged p and q, assumes p and q have no monomials which are equal
1226static inline poly p_Merge_q(poly p, poly q, const ring r)
1227{
1228 assume( (p != q) || (p == NULL && q == NULL) );
1229 return r->p_Procs->p_Merge_q(p, q, r);
1230}
1231
1232// like p_SortMerge, except that p may have equal monomials
1233static inline poly p_SortAdd(poly p, const ring r, BOOLEAN revert= FALSE)
1234{
1235 if (revert) p = pReverse(p);
1236 return sBucketSortAdd(p, r);
1237}
1238
1239// sorts p using bucket sort: returns sorted poly
1240// assumes that monomials of p are all different
1241// reverses it first, if revert == TRUE, use this if input p is "almost" sorted
1242// correctly
1243static inline poly p_SortMerge(poly p, const ring r, BOOLEAN revert= FALSE)
1244{
1245 if (revert) p = pReverse(p);
1246 return sBucketSortMerge(p, r);
1247}
1248
1249/***************************************************************
1250 *
1251 * I/O
1252 *
1253 ***************************************************************/
1254static inline char* p_String(poly p, ring p_ring)
1255{
1256 return p_String(p, p_ring, p_ring);
1257}
1258static inline void p_String0(poly p, ring p_ring)
1259{
1260 p_String0(p, p_ring, p_ring);
1261}
1262static inline void p_Write(poly p, ring p_ring)
1263{
1264 p_Write(p, p_ring, p_ring);
1265}
1266static inline void p_Write0(poly p, ring p_ring)
1267{
1268 p_Write0(p, p_ring, p_ring);
1269}
1270static inline void p_wrp(poly p, ring p_ring)
1271{
1272 p_wrp(p, p_ring, p_ring);
1273}
1274
1275
1276#if PDEBUG > 0
1277
1278#define _p_LmCmpAction(p, q, r, actionE, actionG, actionS) \
1279do \
1280{ \
1281 int _cmp = p_LmCmp(p,q,r); \
1282 if (_cmp == 0) actionE; \
1283 if (_cmp == 1) actionG; \
1284 actionS; \
1285} \
1286while(0)
1287
1288#else
1289
1290#define _p_LmCmpAction(p, q, r, actionE, actionG, actionS) \
1291 p_MemCmp_LengthGeneral_OrdGeneral(p->exp, q->exp, r->CmpL_Size, r->ordsgn, \
1292 actionE, actionG, actionS)
1293
1294#endif
1295
1296#define pDivAssume(x) do {} while (0)
1297
1298
1299
1300/***************************************************************
1301 *
1302 * Allocation/Initialization/Deletion
1303 *
1304 ***************************************************************/
1305// adjustments for negative weights
1306static inline void p_MemAdd_NegWeightAdjust(poly p, const ring r)
1307{
1308 if (r->NegWeightL_Offset != NULL)
1309 {
1310 for (int i=r->NegWeightL_Size-1; i>=0; i--)
1311 {
1312 p->exp[r->NegWeightL_Offset[i]] -= POLY_NEGWEIGHT_OFFSET;
1313 }
1314 }
1315}
1316static inline void p_MemSub_NegWeightAdjust(poly p, const ring r)
1317{
1318 if (r->NegWeightL_Offset != NULL)
1319 {
1320 for (int i=r->NegWeightL_Size-1; i>=0; i--)
1321 {
1322 p->exp[r->NegWeightL_Offset[i]] += POLY_NEGWEIGHT_OFFSET;
1323 }
1324 }
1325}
1326// ExpVextor(d_p) = ExpVector(s_p)
1327static inline void p_ExpVectorCopy(poly d_p, poly s_p, const ring r)
1328{
1329 p_LmCheckPolyRing1(d_p, r);
1330 p_LmCheckPolyRing1(s_p, r);
1331 memcpy(d_p->exp, s_p->exp, r->ExpL_Size*sizeof(long));
1332}
1333
1334static inline poly p_Init(const ring r, omBin bin)
1335{
1336 p_CheckRing1(r);
1337 pAssume1(bin != NULL && omSizeWOfBin(r->PolyBin) == omSizeWOfBin(bin));
1338 poly p;
1339 omTypeAlloc0Bin(poly, p, bin);
1341 p_SetRingOfLm(p, r);
1342 return p;
1343}
1344static inline poly p_Init(const ring r)
1345{
1346 return p_Init(r, r->PolyBin);
1347}
1348
1349static inline poly p_LmInit(poly p, const ring r)
1350{
1352 poly np;
1353 omTypeAllocBin(poly, np, r->PolyBin);
1354 p_SetRingOfLm(np, r);
1355 memcpy(np->exp, p->exp, r->ExpL_Size*sizeof(long));
1356 pNext(np) = NULL;
1357 pSetCoeff0(np, NULL);
1358 return np;
1359}
1360static inline poly p_LmInit(poly s_p, const ring s_r, const ring d_r, omBin d_bin)
1361{
1362 p_LmCheckPolyRing1(s_p, s_r);
1363 p_CheckRing(d_r);
1364 pAssume1(d_r->N <= s_r->N);
1365 poly d_p = p_Init(d_r, d_bin);
1366 for (unsigned i=d_r->N; i!=0; i--)
1367 {
1368 p_SetExp(d_p, i, p_GetExp(s_p, i,s_r), d_r);
1369 }
1370 if (rRing_has_Comp(d_r))
1371 {
1372 p_SetComp(d_p, p_GetComp(s_p,s_r), d_r);
1373 }
1374 p_Setm(d_p, d_r);
1375 return d_p;
1376}
1377static inline poly p_LmInit(poly s_p, const ring s_r, const ring d_r)
1378{
1379 pAssume1(d_r != NULL);
1380 return p_LmInit(s_p, s_r, d_r, d_r->PolyBin);
1381}
1382
1383// set all exponents l..k to 0, assume exp. k+1..n and 1..l-1 are in
1384// different blocks
1385// set coeff to 1
1386static inline poly p_GetExp_k_n(poly p, int l, int k, const ring r)
1387{
1388 if (p == NULL) return NULL;
1390 poly np;
1391 omTypeAllocBin(poly, np, r->PolyBin);
1392 p_SetRingOfLm(np, r);
1393 memcpy(np->exp, p->exp, r->ExpL_Size*sizeof(long));
1394 pNext(np) = NULL;
1395 pSetCoeff0(np, n_Init(1, r->cf));
1396 int i;
1397 for(i=l;i<=k;i++)
1398 {
1399 //np->exp[(r->VarOffset[i] & 0xffffff)] =0;
1400 p_SetExp(np,i,0,r);
1401 }
1402 p_Setm(np,r);
1403 return np;
1404}
1405
1406// simialar to p_ShallowCopyDelete but does it only for leading monomial
1407static inline poly p_LmShallowCopyDelete(poly p, const ring r)
1408{
1410 pAssume1(omSizeWOfBin(bin) == omSizeWOfBin(r->PolyBin));
1411 poly new_p = p_New(r);
1412 memcpy(new_p->exp, p->exp, r->ExpL_Size*sizeof(long));
1413 pSetCoeff0(new_p, pGetCoeff(p));
1414 pNext(new_p) = pNext(p);
1416 return new_p;
1417}
1418
1419/***************************************************************
1420 *
1421 * Operation on ExpVectors
1422 *
1423 ***************************************************************/
1424// ExpVector(p1) += ExpVector(p2)
1425static inline void p_ExpVectorAdd(poly p1, poly p2, const ring r)
1426{
1427 p_LmCheckPolyRing1(p1, r);
1428 p_LmCheckPolyRing1(p2, r);
1429#if PDEBUG >= 1
1430 for (int i=1; i<=r->N; i++)
1431 pAssume1((unsigned long) (p_GetExp(p1, i, r) + p_GetExp(p2, i, r)) <= r->bitmask);
1432 pAssume1(p_GetComp(p1, r) == 0 || p_GetComp(p2, r) == 0);
1433#endif
1434
1435 p_MemAdd_LengthGeneral(p1->exp, p2->exp, r->ExpL_Size);
1437}
1438// ExpVector(pr) = ExpVector(p1) + ExpVector(p2)
1439static inline void p_ExpVectorSum(poly pr, poly p1, poly p2, const ring r)
1440{
1441 p_LmCheckPolyRing1(p1, r);
1442 p_LmCheckPolyRing1(p2, r);
1443 p_LmCheckPolyRing1(pr, r);
1444#if PDEBUG >= 1
1445 for (int i=1; i<=r->N; i++)
1446 pAssume1((unsigned long) (p_GetExp(p1, i, r) + p_GetExp(p2, i, r)) <= r->bitmask);
1447 pAssume1(p_GetComp(p1, r) == 0 || p_GetComp(p2, r) == 0);
1448#endif
1449
1450 p_MemSum_LengthGeneral(pr->exp, p1->exp, p2->exp, r->ExpL_Size);
1452}
1453// ExpVector(p1) -= ExpVector(p2)
1454static inline void p_ExpVectorSub(poly p1, poly p2, const ring r)
1455{
1456 p_LmCheckPolyRing1(p1, r);
1457 p_LmCheckPolyRing1(p2, r);
1458#if PDEBUG >= 1
1459 for (int i=1; i<=r->N; i++)
1460 pAssume1(p_GetExp(p1, i, r) >= p_GetExp(p2, i, r));
1461 pAssume1(p_GetComp(p1, r) == 0 || p_GetComp(p2, r) == 0 ||
1462 p_GetComp(p1, r) == p_GetComp(p2, r));
1463#endif
1464
1465 p_MemSub_LengthGeneral(p1->exp, p2->exp, r->ExpL_Size);
1467}
1468
1469// ExpVector(p1) += ExpVector(p2) - ExpVector(p3)
1470static inline void p_ExpVectorAddSub(poly p1, poly p2, poly p3, const ring r)
1471{
1472 p_LmCheckPolyRing1(p1, r);
1473 p_LmCheckPolyRing1(p2, r);
1474 p_LmCheckPolyRing1(p3, r);
1475#if PDEBUG >= 1
1476 for (int i=1; i<=r->N; i++)
1477 pAssume1(p_GetExp(p1, i, r) + p_GetExp(p2, i, r) >= p_GetExp(p3, i, r));
1478 pAssume1(p_GetComp(p1, r) == 0 ||
1479 (p_GetComp(p2, r) - p_GetComp(p3, r) == 0) ||
1480 (p_GetComp(p1, r) == p_GetComp(p2, r) - p_GetComp(p3, r)));
1481#endif
1482
1483 p_MemAddSub_LengthGeneral(p1->exp, p2->exp, p3->exp, r->ExpL_Size);
1484 // no need to adjust in case of NegWeights
1485}
1486
1487// ExpVector(pr) = ExpVector(p1) - ExpVector(p2)
1488static inline void p_ExpVectorDiff(poly pr, poly p1, poly p2, const ring r)
1489{
1490 p_LmCheckPolyRing1(p1, r);
1491 p_LmCheckPolyRing1(p2, r);
1492 p_LmCheckPolyRing1(pr, r);
1493#if PDEBUG >= 2
1494 for (int i=1; i<=r->N; i++)
1495 pAssume1(p_GetExp(p1, i, r) >= p_GetExp(p2, i, r));
1496 pAssume1(!rRing_has_Comp(r) || p_GetComp(p1, r) == p_GetComp(p2, r));
1497#endif
1498
1499 p_MemDiff_LengthGeneral(pr->exp, p1->exp, p2->exp, r->ExpL_Size);
1501}
1502
1503static inline BOOLEAN p_ExpVectorEqual(poly p1, poly p2, const ring r)
1504{
1505 p_LmCheckPolyRing1(p1, r);
1506 p_LmCheckPolyRing1(p2, r);
1507
1508 unsigned i = r->ExpL_Size;
1509 unsigned long *ep = p1->exp;
1510 unsigned long *eq = p2->exp;
1511
1512 do
1513 {
1514 i--;
1515 if (ep[i] != eq[i]) return FALSE;
1516 }
1517 while (i!=0);
1518 return TRUE;
1519}
1520
1521static inline long p_Totaldegree(poly p, const ring r)
1522{
1524 unsigned long s = p_GetTotalDegree(p->exp[r->VarL_Offset[0]],
1525 r,
1526 r->ExpPerLong);
1527 for (unsigned i=r->VarL_Size-1; i!=0; i--)
1528 {
1529 s += p_GetTotalDegree(p->exp[r->VarL_Offset[i]], r,r->ExpPerLong);
1530 }
1531 return (long)s;
1532}
1533
1534static inline void p_GetExpV(poly p, int *ev, const ring r)
1535{
1537 for (unsigned j = r->N; j!=0; j--)
1538 ev[j] = p_GetExp(p, j, r);
1539
1540 ev[0] = p_GetComp(p, r);
1541}
1542// p_GetExpVL is used in Singular,jl
1543static inline void p_GetExpVL(poly p, int64 *ev, const ring r)
1544{
1546 for (unsigned j = r->N; j!=0; j--)
1547 ev[j-1] = p_GetExp(p, j, r);
1548}
1549// p_GetExpVLV is used in Singular,jl
1550static inline int64 p_GetExpVLV(poly p, int64 *ev, const ring r)
1551{
1553 for (unsigned j = r->N; j!=0; j--)
1554 ev[j-1] = p_GetExp(p, j, r);
1555 return (int64)p_GetComp(p,r);
1556}
1557// p_GetExpVL is used in Singular,jl
1558static inline void p_SetExpV(poly p, int *ev, const ring r)
1559{
1561 for (unsigned j = r->N; j!=0; j--)
1562 p_SetExp(p, j, ev[j], r);
1563
1564 if(ev[0]!=0) p_SetComp(p, ev[0],r);
1565 p_Setm(p, r);
1566}
1567static inline void p_SetExpVL(poly p, int64 *ev, const ring r)
1568{
1570 for (unsigned j = r->N; j!=0; j--)
1571 p_SetExp(p, j, ev[j-1], r);
1572 p_SetComp(p, 0,r);
1573
1574 p_Setm(p, r);
1575}
1576
1577// p_SetExpVLV is used in Singular,jl
1578static inline void p_SetExpVLV(poly p, int64 *ev, int64 comp, const ring r)
1579{
1581 for (unsigned j = r->N; j!=0; j--)
1582 p_SetExp(p, j, ev[j-1], r);
1583 p_SetComp(p, comp,r);
1584
1585 p_Setm(p, r);
1586}
1587
1588/***************************************************************
1589 *
1590 * Comparison w.r.t. monomial ordering
1591 *
1592 ***************************************************************/
1593
1594static inline int p_LmCmp(poly p, poly q, const ring r)
1595{
1597 p_LmCheckPolyRing1(q, r);
1598
1599 const unsigned long* _s1 = ((unsigned long*) p->exp);
1600 const unsigned long* _s2 = ((unsigned long*) q->exp);
1601 REGISTER unsigned long _v1;
1602 REGISTER unsigned long _v2;
1603 const unsigned long _l = r->CmpL_Size;
1604
1605 REGISTER unsigned long _i=0;
1606
1607 LengthGeneral_OrdGeneral_LoopTop:
1608 _v1 = _s1[_i];
1609 _v2 = _s2[_i];
1610 if (_v1 == _v2)
1611 {
1612 _i++;
1613 if (_i == _l) return 0;
1614 goto LengthGeneral_OrdGeneral_LoopTop;
1615 }
1616 const long* _ordsgn = (long*) r->ordsgn;
1617#if 1 /* two variants*/
1618 if (_v1 > _v2)
1619 {
1620 return _ordsgn[_i];
1621 }
1622 return -(_ordsgn[_i]);
1623#else
1624 if (_v1 > _v2)
1625 {
1626 if (_ordsgn[_i] == 1) return 1;
1627 return -1;
1628 }
1629 if (_ordsgn[_i] == 1) return -1;
1630 return 1;
1631#endif
1632}
1633
1634// The coefficient will be compared in absolute value
1635static inline int p_LtCmp(poly p, poly q, const ring r)
1636{
1637 int res = p_LmCmp(p,q,r);
1638 if(res == 0)
1639 {
1640 if(p_GetCoeff(p,r) == NULL || p_GetCoeff(q,r) == NULL)
1641 return res;
1642 number pc = n_Copy(p_GetCoeff(p,r),r->cf);
1643 number qc = n_Copy(p_GetCoeff(q,r),r->cf);
1644 if(!n_GreaterZero(pc,r->cf))
1645 pc = n_InpNeg(pc,r->cf);
1646 if(!n_GreaterZero(qc,r->cf))
1647 qc = n_InpNeg(qc,r->cf);
1648 if(n_Greater(pc,qc,r->cf))
1649 res = 1;
1650 else if(n_Greater(qc,pc,r->cf))
1651 res = -1;
1652 else if(n_Equal(pc,qc,r->cf))
1653 res = 0;
1654 n_Delete(&pc,r->cf);
1655 n_Delete(&qc,r->cf);
1656 }
1657 return res;
1658}
1659
1660// The coefficient will be compared in absolute value
1661static inline int p_LtCmpNoAbs(poly p, poly q, const ring r)
1662{
1663 int res = p_LmCmp(p,q,r);
1664 if(res == 0)
1665 {
1666 if(p_GetCoeff(p,r) == NULL || p_GetCoeff(q,r) == NULL)
1667 return res;
1668 number pc = p_GetCoeff(p,r);
1669 number qc = p_GetCoeff(q,r);
1670 if(n_Greater(pc,qc,r->cf))
1671 res = 1;
1672 if(n_Greater(qc,pc,r->cf))
1673 res = -1;
1674 if(n_Equal(pc,qc,r->cf))
1675 res = 0;
1676 }
1677 return res;
1678}
1679
1680#ifdef HAVE_RINGS
1681// This is the equivalent of pLmCmp(p,q) != -currRing->OrdSgn for rings
1682// It is used in posInTRing
1683static inline int p_LtCmpOrdSgnDiffM(poly p, poly q, const ring r)
1684{
1685 return(p_LtCmp(p,q,r) == r->OrdSgn);
1686}
1687#endif
1688
1689#ifdef HAVE_RINGS
1690// This is the equivalent of pLmCmp(p,q) != currRing->OrdSgn for rings
1691// It is used in posInTRing
1692static inline int p_LtCmpOrdSgnDiffP(poly p, poly q, const ring r)
1693{
1694 if(r->OrdSgn == 1)
1695 {
1696 return(p_LmCmp(p,q,r) == -1);
1697 }
1698 else
1699 {
1700 return(p_LtCmp(p,q,r) != -1);
1701 }
1702}
1703#endif
1704
1705#ifdef HAVE_RINGS
1706// This is the equivalent of pLmCmp(p,q) == -currRing->OrdSgn for rings
1707// It is used in posInTRing
1708static inline int p_LtCmpOrdSgnEqM(poly p, poly q, const ring r)
1709{
1710 return(p_LtCmp(p,q,r) == -r->OrdSgn);
1711}
1712#endif
1713
1714#ifdef HAVE_RINGS
1715// This is the equivalent of pLmCmp(p,q) == currRing->OrdSgn for rings
1716// It is used in posInTRing
1717static inline int p_LtCmpOrdSgnEqP(poly p, poly q, const ring r)
1718{
1719 return(p_LtCmp(p,q,r) == r->OrdSgn);
1720}
1721#endif
1722
1723/// returns TRUE if p1 is a skalar multiple of p2
1724/// assume p1 != NULL and p2 != NULL
1725BOOLEAN p_ComparePolys(poly p1,poly p2, const ring r);
1726
1727
1728/***************************************************************
1729 *
1730 * Comparisons: they are all done without regarding coeffs
1731 *
1732 ***************************************************************/
1733#define p_LmCmpAction(p, q, r, actionE, actionG, actionS) \
1734 _p_LmCmpAction(p, q, r, actionE, actionG, actionS)
1735
1736// returns 1 if ExpVector(p)==ExpVector(q): does not compare numbers !!
1737#define p_LmEqual(p1, p2, r) p_ExpVectorEqual(p1, p2, r)
1738
1739// pCmp: args may be NULL
1740// returns: (p2==NULL ? 1 : (p1 == NULL ? -1 : p_LmCmp(p1, p2)))
1741static inline int p_Cmp(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_LmCmp(p1,p2,r);
1751}
1752
1753static inline int p_CmpPolys(poly p1, poly p2, ring r)
1754{
1755 if (p2==NULL)
1756 {
1757 if (p1==NULL) return 0;
1758 return 1;
1759 }
1760 if (p1==NULL)
1761 return -1;
1762 return p_ComparePolys(p1,p2,r);
1763}
1764
1765
1766/***************************************************************
1767 *
1768 * divisibility
1769 *
1770 ***************************************************************/
1771/// return: FALSE, if there exists i, such that a->exp[i] > b->exp[i]
1772/// TRUE, otherwise
1773/// (1) Consider long vars, instead of single exponents
1774/// (2) Clearly, if la > lb, then FALSE
1775/// (3) Suppose la <= lb, and consider first bits of single exponents in l:
1776/// if TRUE, then value of these bits is la ^ lb
1777/// if FALSE, then la-lb causes an "overflow" into one of those bits, i.e.,
1778/// la ^ lb != la - lb
1779static inline BOOLEAN _p_LmDivisibleByNoComp(poly a, poly b, const ring r)
1780{
1781 int i=r->VarL_Size - 1;
1782 unsigned long divmask = r->divmask;
1783 unsigned long la, lb;
1784
1785 if (r->VarL_LowIndex >= 0)
1786 {
1787 i += r->VarL_LowIndex;
1788 do
1789 {
1790 la = a->exp[i];
1791 lb = b->exp[i];
1792 if ((la > lb) ||
1793 (((la & divmask) ^ (lb & divmask)) != ((lb - la) & divmask)))
1794 {
1796 return FALSE;
1797 }
1798 i--;
1799 }
1800 while (i>=r->VarL_LowIndex);
1801 }
1802 else
1803 {
1804 do
1805 {
1806 la = a->exp[r->VarL_Offset[i]];
1807 lb = b->exp[r->VarL_Offset[i]];
1808 if ((la > lb) ||
1809 (((la & divmask) ^ (lb & divmask)) != ((lb - la) & divmask)))
1810 {
1812 return FALSE;
1813 }
1814 i--;
1815 }
1816 while (i>=0);
1817 }
1818/*#ifdef HAVE_RINGS
1819 pDivAssume(p_DebugLmDivisibleByNoComp(a, b, r) == n_DivBy(p_GetCoeff(b, r), p_GetCoeff(a, r), r->cf));
1820 return (!rField_is_Ring(r)) || n_DivBy(p_GetCoeff(b, r), p_GetCoeff(a, r), r->cf);
1821#else
1822*/
1824 return TRUE;
1825//#endif
1826}
1827
1828static inline BOOLEAN _p_LmDivisibleByNoComp(poly a, const ring r_a, poly b, const ring r_b)
1829{
1830 int i=r_a->N;
1831 pAssume1(r_a->N == r_b->N);
1832
1833 do
1834 {
1835 if (p_GetExp(a,i,r_a) > p_GetExp(b,i,r_b))
1836 {
1837 return FALSE;
1838 }
1839 i--;
1840 }
1841 while (i);
1842/*#ifdef HAVE_RINGS
1843 return n_DivBy(p_GetCoeff(b, r_b), p_GetCoeff(a, r_a), r_a->cf);
1844#else
1845*/
1846 return TRUE;
1847//#endif
1848}
1849
1850#ifdef HAVE_RATGRING
1851static inline BOOLEAN _p_LmDivisibleByNoCompPart(poly a, const ring r_a, poly b, const ring r_b,const int start, const int end)
1852{
1853 int i=end;
1854 pAssume1(r_a->N == r_b->N);
1855
1856 do
1857 {
1858 if (p_GetExp(a,i,r_a) > p_GetExp(b,i,r_b))
1859 return FALSE;
1860 i--;
1861 }
1862 while (i>=start);
1863/*#ifdef HAVE_RINGS
1864 return n_DivBy(p_GetCoeff(b, r_b), p_GetCoeff(a, r_a), r_a->cf);
1865#else
1866*/
1867 return TRUE;
1868//#endif
1869}
1870static inline BOOLEAN _p_LmDivisibleByPart(poly a, const ring r_a, poly b, const ring r_b,const int start, const int end)
1871{
1872 if (p_GetComp(a, r_a) == 0 || p_GetComp(a,r_a) == p_GetComp(b,r_b))
1873 return _p_LmDivisibleByNoCompPart(a, r_a, b, r_b,start,end);
1874 return FALSE;
1875}
1876static inline BOOLEAN p_LmDivisibleByPart(poly a, poly b, const ring r,const int start, const int end)
1877{
1879 pIfThen1(a != NULL, p_LmCheckPolyRing1(b, r));
1880 if (p_GetComp(a, r) == 0 || p_GetComp(a,r) == p_GetComp(b,r))
1881 return _p_LmDivisibleByNoCompPart(a, r, b, r,start, end);
1882 return FALSE;
1883}
1884#endif
1885static inline BOOLEAN _p_LmDivisibleBy(poly a, poly b, const ring r)
1886{
1887 if (p_GetComp(a, r) == 0 || p_GetComp(a,r) == p_GetComp(b,r))
1888 return _p_LmDivisibleByNoComp(a, b, r);
1889 return FALSE;
1890}
1891static inline BOOLEAN p_LmDivisibleByNoComp(poly a, poly b, const ring r)
1892{
1893 p_LmCheckPolyRing1(a, r);
1895 return _p_LmDivisibleByNoComp(a, b, r);
1896}
1897
1898static inline BOOLEAN p_LmDivisibleByNoComp(poly a, const ring ra, poly b, const ring rb)
1899{
1900 p_LmCheckPolyRing1(a, ra);
1901 p_LmCheckPolyRing1(b, rb);
1902 return _p_LmDivisibleByNoComp(a, ra, b, rb);
1903}
1904
1905static inline BOOLEAN p_LmDivisibleBy(poly a, poly b, const ring r)
1906{
1908 pIfThen1(a != NULL, p_LmCheckPolyRing1(b, r));
1909 if (p_GetComp(a, r) == 0 || p_GetComp(a,r) == p_GetComp(b,r))
1910 return _p_LmDivisibleByNoComp(a, b, r);
1911 return FALSE;
1912}
1913
1914static inline BOOLEAN p_DivisibleBy(poly a, poly b, const ring r)
1915{
1917 pIfThen1(a!=NULL, p_LmCheckPolyRing1(a, r));
1918
1919 if (a != NULL && (p_GetComp(a, r) == 0 || p_GetComp(a,r) == p_GetComp(b,r)))
1920 return _p_LmDivisibleByNoComp(a,b,r);
1921 return FALSE;
1922}
1923
1924static inline BOOLEAN p_LmShortDivisibleBy(poly a, unsigned long sev_a,
1925 poly b, unsigned long not_sev_b, const ring r)
1926{
1927 p_LmCheckPolyRing1(a, r);
1929#ifndef PDIV_DEBUG
1930 _pPolyAssume2(p_GetShortExpVector(a, r) == sev_a, a, r);
1931 _pPolyAssume2(p_GetShortExpVector(b, r) == ~ not_sev_b, b, r);
1932
1933 if (sev_a & not_sev_b)
1934 {
1936 return FALSE;
1937 }
1938 return p_LmDivisibleBy(a, b, r);
1939#else
1940 return pDebugLmShortDivisibleBy(a, sev_a, r, b, not_sev_b, r);
1941#endif
1942}
1943
1944static inline BOOLEAN p_LmShortDivisibleByNoComp(poly a, unsigned long sev_a,
1945 poly b, unsigned long not_sev_b, const ring r)
1946{
1947 p_LmCheckPolyRing1(a, r);
1949#ifndef PDIV_DEBUG
1950 _pPolyAssume2(p_GetShortExpVector(a, r) == sev_a, a, r);
1951 _pPolyAssume2(p_GetShortExpVector(b, r) == ~ not_sev_b, b, r);
1952
1953 if (sev_a & not_sev_b)
1954 {
1956 return FALSE;
1957 }
1958 return p_LmDivisibleByNoComp(a, b, r);
1959#else
1960 return pDebugLmShortDivisibleByNoComp(a, sev_a, r, b, not_sev_b, r);
1961#endif
1962}
1963
1964/***************************************************************
1965 *
1966 * Misc things on Lm
1967 *
1968 ***************************************************************/
1969
1970
1971/// like the respective p_LmIs* routines, except that p might be empty
1972static inline BOOLEAN p_IsConstantComp(const poly p, const ring r)
1973{
1974 if (p == NULL) return TRUE;
1975 return (pNext(p)==NULL) && p_LmIsConstantComp(p, r);
1976}
1977
1978static inline BOOLEAN p_IsConstant(const poly p, const ring r)
1979{
1980 if (p == NULL) return TRUE;
1981 return (pNext(p)==NULL) && p_LmIsConstant(p, r);
1982}
1983
1984/// either poly(1) or gen(k)?!
1985static inline BOOLEAN p_IsOne(const poly p, const ring R)
1986{
1987 if (p == NULL) return FALSE; /* TODO check if 0 == 1 */
1988 p_Test(p, R);
1989 return (p_IsConstant(p, R) && n_IsOne(p_GetCoeff(p, R), R->cf));
1990}
1991
1992static inline BOOLEAN p_IsConstantPoly(const poly p, const ring r)
1993{
1994 p_Test(p, r);
1995 poly pp=p;
1996 while(pp!=NULL)
1997 {
1998 if (! p_LmIsConstantComp(pp, r))
1999 return FALSE;
2000 pIter(pp);
2001 }
2002 return TRUE;
2003}
2004
2005static inline BOOLEAN p_IsUnit(const poly p, const ring r)
2006{
2007 if (p == NULL) return FALSE;
2008 if (rField_is_Ring(r))
2009 return (p_LmIsConstant(p, r) && n_IsUnit(pGetCoeff(p),r->cf));
2010 return p_LmIsConstant(p, r);
2011}
2012
2013static inline BOOLEAN p_LmExpVectorAddIsOk(const poly p1, const poly p2,
2014 const ring r)
2015{
2016 p_LmCheckPolyRing(p1, r);
2017 p_LmCheckPolyRing(p2, r);
2018 unsigned long l1, l2, divmask = r->divmask;
2019 int i;
2020
2021 for (i=0; i<r->VarL_Size; i++)
2022 {
2023 l1 = p1->exp[r->VarL_Offset[i]];
2024 l2 = p2->exp[r->VarL_Offset[i]];
2025 // do the divisiblity trick
2026 if ( (l1 > ULONG_MAX - l2) ||
2027 (((l1 & divmask) ^ (l2 & divmask)) != ((l1 + l2) & divmask)))
2028 return FALSE;
2029 }
2030 return TRUE;
2031}
2032void p_Split(poly p, poly * r); /*p => IN(p), r => REST(p) */
2033BOOLEAN p_HasNotCF(poly p1, poly p2, const ring r);
2034BOOLEAN p_HasNotCFRing(poly p1, poly p2, const ring r);
2035poly p_mInit(const char *s, BOOLEAN &ok, const ring r); /* monom s -> poly, interpreter */
2036const char * p_Read(const char *s, poly &p,const ring r); /* monom -> poly */
2037poly p_MDivide(poly a, poly b, const ring r);
2038poly p_DivideM(poly a, poly b, const ring r);
2039poly pp_DivideM(poly a, poly b, const ring r);
2040poly p_Div_nn(poly p, const number n, const ring r);
2041
2042// returns the LCM of the head terms of a and b in *m, does not p_Setm
2043void p_Lcm(const poly a, const poly b, poly m, const ring r);
2044// returns the LCM of the head terms of a and b, does p_Setm
2045poly p_Lcm(const poly a, const poly b, const ring r);
2046
2047#ifdef HAVE_RATGRING
2048poly p_LcmRat(const poly a, const poly b, const long lCompM, const ring r);
2049poly p_GetCoeffRat(poly p, int ishift, ring r);
2050void p_LmDeleteAndNextRat(poly *p, int ishift, ring r);
2051void p_ContentRat(poly &ph, const ring r);
2052#endif /* ifdef HAVE_RATGRING */
2053
2054
2055poly p_Diff(poly a, int k, const ring r);
2056poly p_DiffOp(poly a, poly b,BOOLEAN multiply, const ring r);
2057int p_Weight(int c, const ring r);
2058
2059/// assumes that p and divisor are univariate polynomials in r,
2060/// mentioning the same variable;
2061/// assumes divisor != NULL;
2062/// p may be NULL;
2063/// assumes a global monomial ordering in r;
2064/// performs polynomial division of p by divisor:
2065/// - afterwards p contains the remainder of the division, i.e.,
2066/// p_before = result * divisor + p_afterwards;
2067/// - if needResult == TRUE, then the method computes and returns 'result',
2068/// otherwise NULL is returned (This parametrization can be used when
2069/// one is only interested in the remainder of the division. In this
2070/// case, the method will be slightly faster.)
2071/// leaves divisor unmodified
2072poly p_PolyDiv(poly &p, const poly divisor, const BOOLEAN needResult, const ring r);
2073
2074/* syszygy stuff */
2075BOOLEAN p_VectorHasUnitB(poly p, int * k, const ring r);
2076void p_VectorHasUnit(poly p, int * k, int * len, const ring r);
2077/// Splits *p into two polys: *q which consists of all monoms with
2078/// component == comp and *p of all other monoms *lq == pLength(*q)
2079/// On return all components pf *q == 0
2080void p_TakeOutComp(poly *p, long comp, poly *q, int *lq, const ring r);
2081
2082// This is something weird -- Don't use it, unless you know what you are doing
2083poly p_TakeOutComp(poly * p, int k, const ring r);
2084
2085void p_DeleteComp(poly * p,int k, const ring r);
2086
2087/*-------------ring management:----------------------*/
2088
2089// resets the pFDeg and pLDeg: if pLDeg is not given, it is
2090// set to currRing->pLDegOrig, i.e. to the respective LDegProc which
2091// only uses pFDeg (and not pDeg, or pTotalDegree, etc).
2092// If you use this, make sure your procs does not make any assumptions
2093// on ordering and/or OrdIndex -- otherwise they might return wrong results
2094// on strat->tailRing
2095void pSetDegProcs(ring r, pFDegProc new_FDeg, pLDegProc new_lDeg = NULL);
2096// restores pFDeg and pLDeg:
2097void pRestoreDegProcs(ring r, pFDegProc old_FDeg, pLDegProc old_lDeg);
2098
2099/*-------------pComp for syzygies:-------------------*/
2100void p_SetModDeg(intvec *w, ring r);
2101
2102/*------------ Jet ----------------------------------*/
2103poly pp_Jet(poly p, int m, const ring R);
2104poly pp_Jet0(poly p, const ring R); /*pp_Jet(p,0,R)*/
2105poly p_Jet(poly p, int m,const ring R);
2106poly pp_JetW(poly p, int m, int *w, const ring R);
2107poly p_JetW(poly p, int m, int *w, const ring R);
2108
2109poly n_PermNumber(const number z, const int *par_perm, const int OldPar, const ring src, const ring dst);
2110
2111poly p_PermPoly (poly p, const int * perm,const ring OldRing, const ring dst,
2112 nMapFunc nMap, const int *par_perm=NULL, int OldPar=0,
2113 BOOLEAN use_mult=FALSE);
2114
2115/*----------------------------------------------------*/
2116poly p_Series(int n,poly p,poly u, intvec *w, const ring R);
2117
2118/*----------------------------------------------------*/
2119int p_Var(poly mi, const ring r);
2120/// the minimal index of used variables - 1
2121int p_LowVar (poly p, const ring r);
2122
2123/*----------------------------------------------------*/
2124/// shifts components of the vector p by i
2125void p_Shift (poly * p,int i, const ring r);
2126/*----------------------------------------------------*/
2127
2128int p_Compare(const poly a, const poly b, const ring R);
2129
2130/// polynomial gcd for f=mon
2131poly p_GcdMon(poly f, poly g, const ring r);
2132
2133/// divide polynomial by monomial
2134poly p_Div_mm(poly p, const poly m, const ring r);
2135
2136
2137/// max exponent of variable x_i in p
2138int p_MaxExpPerVar(poly p, int i, const ring r);
2139#endif // P_POLYS_H
2140
long int64
Definition auxiliary.h:68
#define UNLIKELY(X)
Definition auxiliary.h:404
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:4090
int p
Definition cfModGcd.cc:4086
g
Definition cfModGcd.cc:4098
CanonicalForm b
Definition cfModGcd.cc:4111
FILE * f
Definition checklibs.c:9
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:455
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:519
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:498
static FORCE_INLINE BOOLEAN nCoeff_is_Domain(const coeffs r)
returns TRUE, if r is a field or r has no zero divisors (i.e is a domain)
Definition coeffs.h:734
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:558
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:515
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff 'n' represents the zero element.
Definition coeffs.h:468
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
Definition coeffs.h:459
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:539
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:464
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition coeffs.h:80
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
Definition coeffs.h:472
return result
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
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 lq.h:40
#define omTypeAlloc0Bin(type, addr, bin)
#define omTypeAllocBin(type, addr, bin)
#define omFreeBin(addr, bin)
#define omFreeBinAddr(addr)
#define omSizeWOfBin(bin_ptr)
#define NULL
Definition omList.c:12
omBin_t * omBin
Definition omStructs.h:12
#define REGISTER
Definition omalloc.h:27
BOOLEAN p_DebugLmDivisibleByNoComp(poly a, poly b, ring r)
Definition pDebug.cc:144
#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:1107
poly p_Diff(poly a, int k, const ring r)
Definition p_polys.cc:1902
long pLDeg1c_WFirstTotalDegree(poly p, int *l, ring r)
Definition p_polys.cc:1069
static int p_CmpPolys(poly p1, poly p2, ring r)
Definition p_polys.h:1753
long pLDeg0(poly p, int *l, ring r)
Definition p_polys.cc:740
static int pLength(poly a)
Definition p_polys.h:190
poly p_DivideM(poly a, poly b, const ring r)
Definition p_polys.cc:1582
int p_IsPurePower(const poly p, const ring r)
return i, if head depends only on var(i)
Definition p_polys.cc:1227
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:1439
poly pp_Jet(poly p, int m, const ring R)
Definition p_polys.cc:4380
static poly p_Add_q(poly p, poly q, const ring r)
Definition p_polys.h:936
static void p_LmDelete(poly p, const ring r)
Definition p_polys.h:723
static poly p_Mult_q(poly p, poly q, const ring r)
Definition p_polys.h:1118
void pSetDegProcs(ring r, pFDegProc new_FDeg, pLDegProc new_lDeg=NULL)
Definition p_polys.cc:3658
BOOLEAN pIsMonomOf(poly p, poly m)
Definition pDebug.cc:164
BOOLEAN p_LmCheckPolyRing(poly p, ring r)
Definition pDebug.cc:123
static void p_MemAdd_NegWeightAdjust(poly p, const ring r)
Definition p_polys.h:1306
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:211
static void p_ExpVectorAdd(poly p1, poly p2, const ring r)
Definition p_polys.h:1425
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:911
BOOLEAN p_CheckIsFromRing(poly p, ring r)
Definition pDebug.cc:105
void pRestoreDegProcs(ring r, pFDegProc old_FDeg, pLDegProc old_lDeg)
Definition p_polys.cc:3670
long pLDeg1_WFirstTotalDegree(poly p, int *l, ring r)
Definition p_polys.cc:1039
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:1870
poly p_Sub(poly a, poly b, const ring r)
Definition p_polys.cc:1994
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:1874
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:1972
int p_Size(poly p, const ring r)
Definition p_polys.cc:3257
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:1349
poly p_GcdMon(poly f, poly g, const ring r)
polynomial gcd for f=mon
Definition p_polys.cc:4980
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:4626
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:781
int p_LowVar(poly p, const ring r)
the minimal index of used variables - 1
Definition p_polys.cc:4730
poly p_CopyPowerProduct0(const poly p, const number n, const ring r)
like p_Head, but with coefficient n
Definition p_polys.cc:5018
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:1646
poly p_Homogen(poly p, int varnum, const ring r)
Definition p_polys.cc:3274
static void p_ExpVectorCopy(poly d_p, poly s_p, const ring r)
Definition p_polys.h:1327
poly p_Subst(poly p, int n, poly e, const ring r)
Definition p_polys.cc:3980
static void p_LmDelete0(poly p, const ring r)
Definition p_polys.h:733
long pLDeg1c_Deg(poly p, int *l, ring r)
Definition p_polys.cc:942
static int p_Cmp(poly p1, poly p2, ring r)
Definition p_polys.h:1741
BOOLEAN _p_LmTest(poly p, ring r, int level)
Definition pDebug.cc:322
#define __pp_Mult_nn(p, n, r)
Definition p_polys.h:1002
static void p_SetExpVL(poly p, int64 *ev, const ring r)
Definition p_polys.h:1567
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:1330
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:842
poly p_CopyPowerProduct(const poly p, const ring r)
like p_Head, but with coefficient 1
Definition p_polys.cc:5030
static void p_SetExpV(poly p, int *ev, const ring r)
Definition p_polys.h:1558
void p_ShallowDelete(poly *p, const ring r)
static poly pp_mm_Mult(poly p, poly m, const ring r)
Definition p_polys.h:1041
static poly pp_Mult_mm(poly p, poly m, const ring r)
Definition p_polys.h:1031
static int p_LtCmpNoAbs(poly p, poly q, const ring r)
Definition p_polys.h:1661
static void p_MemSub_NegWeightAdjust(poly p, const ring r)
Definition p_polys.h:1316
poly pp_DivideM(poly a, poly b, const ring r)
Definition p_polys.cc:1637
long p_WFirstTotalDegree(poly p, ring r)
Definition p_polys.cc:595
int p_Weight(int c, const ring r)
Definition p_polys.cc:706
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:1298
static int p_LtCmpOrdSgnEqP(poly p, poly q, const ring r)
Definition p_polys.h:1717
void p_ContentForGB(poly p, const ring r)
Definition p_polys.cc:2359
void p_Vec2Polys(poly v, poly **p, int *len, const ring r)
Definition p_polys.cc:3646
poly p_DiffOp(poly a, poly b, BOOLEAN multiply, const ring r)
Definition p_polys.cc:1977
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:4436
static void p_ExpVectorDiff(poly pr, poly p1, poly p2, const ring r)
Definition p_polys.h:1488
const char * p_Read(const char *s, poly &p, const ring r)
Definition p_polys.cc:1371
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:4756
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:2201
poly p_Div_nn(poly p, const number n, const ring r)
Definition p_polys.cc:1506
static poly p_mm_Mult(poly p, poly m, const ring r)
Definition p_polys.h:1061
void p_Normalize(poly p, const ring r)
Definition p_polys.cc:3835
void p_DeleteComp(poly *p, int k, const ring r)
Definition p_polys.cc:3564
poly p_MDivide(poly a, poly b, const ring r)
Definition p_polys.cc:1493
void p_Content(poly p, const ring r)
Definition p_polys.cc:2299
void p_ProjectiveUnique(poly p, const ring r)
Definition p_polys.cc:3147
void p_ContentRat(poly &ph, const ring r)
Definition p_polys.cc:1748
void p_Norm(poly p1, const ring r)
Definition p_polys.cc:3740
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:1542
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:1139
poly pp_Jet0(poly p, const ring R)
Definition p_polys.cc:4408
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:1268
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:4498
static void p_ExpVectorSub(poly p1, poly p2, const ring r)
Definition p_polys.h:1454
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:5042
int p_Var(poly mi, const ring r)
Definition p_polys.cc:4706
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:309
int p_Compare(const poly a, const poly b, const ring R)
Definition p_polys.cc:4946
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:1443
void p_LmDeleteAndNextRat(poly *p, int ishift, ring r)
Definition p_polys.cc:1704
static poly p_Copy_noCheck(poly p, const ring r)
returns a copy of p (without any additional testing)
Definition p_polys.h:836
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:1243
static poly p_LmShallowCopyDelete(poly p, const ring r)
Definition p_polys.h:1407
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:1226
BOOLEAN p_IsHomogeneousW(poly p, const intvec *w, const ring r)
Definition p_polys.cc:3347
long pLDegb(poly p, int *l, ring r)
Definition p_polys.cc:812
static void p_GetExpVL(poly p, int64 *ev, const ring r)
Definition p_polys.h:1543
static int p_LtCmp(poly p, poly q, const ring r)
Definition p_polys.h:1635
static BOOLEAN p_LmIsConstantComp(const poly p, const ring r)
Definition p_polys.h:1006
static poly p_Head(const poly p, const ring r)
copy the (leading) term of p
Definition p_polys.h:860
static int p_LmCmp(poly p, poly q, const ring r)
Definition p_polys.h:1594
poly p_Series(int n, poly p, poly u, intvec *w, const ring R)
Definition p_polys.cc:4548
long p_WTotaldegree(poly p, const ring r)
Definition p_polys.cc:612
static BOOLEAN p_LmShortDivisibleBy(poly a, unsigned long sev_a, poly b, unsigned long not_sev_b, const ring r)
Definition p_polys.h:1924
long p_DegW(poly p, const int *w, const ring R)
Definition p_polys.cc:691
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:1023
p_SetmProc p_GetSetmProc(const ring r)
Definition p_polys.cc:559
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:1891
static BOOLEAN p_IsOne(const poly p, const ring R)
either poly(1) or gen(k)?!
Definition p_polys.h:1985
static BOOLEAN p_IsConstant(const poly p, const ring r)
Definition p_polys.h:1978
static void p_SetExpVLV(poly p, int64 *ev, int64 comp, const ring r)
Definition p_polys.h:1578
BOOLEAN p_OneComp(poly p, const ring r)
return TRUE if all monoms have the same component
Definition p_polys.cc:1209
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:1851
BOOLEAN p_CheckRing(ring r)
Definition pDebug.cc:131
poly p_Cleardenom(poly p, const ring r)
Definition p_polys.cc:2849
poly _p_Mult_q_Normal_ZeroDiv(poly p, poly q, const int copy, const ring r)
Definition p_Mult_q.cc:195
static BOOLEAN _p_LmDivisibleBy(poly a, poly b, const ring r)
Definition p_polys.h:1885
static unsigned long p_GetTotalDegree(const unsigned long l, const ring r, const int number_of_exps)
Definition p_polys.h:810
BOOLEAN p_LmCheckIsFromRing(poly p, ring r)
Definition pDebug.cc:74
static poly p_New(const ring, omBin bin)
Definition p_polys.h:664
void p_Split(poly p, poly *r)
Definition p_polys.cc:1321
poly n_PermNumber(const number z, const int *par_perm, const int OldPar, const ring src, const ring dst)
Definition p_polys.cc:4049
static poly p_GetExp_k_n(poly p, int l, int k, const ring r)
Definition p_polys.h:1386
static BOOLEAN p_LmShortDivisibleByNoComp(poly a, unsigned long sev_a, poly b, unsigned long not_sev_b, const ring r)
Definition p_polys.h:1944
static poly pp_Mult_nn(poly p, number n, const ring r)
Definition p_polys.h:992
poly p_GetCoeffRat(poly p, int ishift, ring r)
Definition p_polys.cc:1726
BOOLEAN p_VectorHasUnitB(poly p, int *k, const ring r)
Definition p_polys.cc:3383
poly p_Vec2Poly(poly v, int k, const ring r)
Definition p_polys.cc:3594
static BOOLEAN p_LmDivisibleBy(poly a, poly b, const ring r)
Definition p_polys.h:1905
poly p_LcmRat(const poly a, const poly b, const long lCompM, const ring r)
Definition p_polys.cc:1681
static BOOLEAN p_DivisibleBy(poly a, poly b, const ring r)
Definition p_polys.h:1914
static BOOLEAN p_ExpVectorEqual(poly p1, poly p2, const ring r)
Definition p_polys.h:1503
long pLDeg1_Totaldegree(poly p, int *l, ring r)
Definition p_polys.cc:976
void p_SetModDeg(intvec *w, ring r)
Definition p_polys.cc:3694
static poly p_ShallowCopyDelete(poly p, const ring r, omBin bin)
Definition p_polys.h:928
static int64 p_GetExpVLV(poly p, int64 *ev, const ring r)
Definition p_polys.h:1550
void p_TakeOutComp(poly *p, long comp, poly *q, int *lq, const ring r)
Splits *p into two polys: *q which consists of all monoms with component == comp and *p of all other ...
Definition p_polys.cc:3516
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:958
static void p_Delete(poly *p, const ring r)
Definition p_polys.h:901
BOOLEAN p_HasNotCFRing(poly p1, poly p2, const ring r)
Definition p_polys.cc:1346
poly p_One(const ring r)
Definition p_polys.cc:1314
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:1683
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:1779
void p_VectorHasUnit(poly p, int *k, int *len, const ring r)
Definition p_polys.cc:3406
static void p_GetExpV(poly p, int *ev, const ring r)
Definition p_polys.h:1534
BOOLEAN p_CheckPolyRing(poly p, ring r)
Definition pDebug.cc:115
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:1006
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:1248
poly p_NSet(number n, const ring r)
returns the poly representing the number n, destroys n
Definition p_polys.cc:1474
static poly pp_Mult_qq(poly p, poly q, const ring r)
Definition p_polys.h:1160
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:4152
static int p_LtCmpOrdSgnEqM(poly p, poly q, const ring r)
Definition p_polys.h:1708
static poly p_LmFreeAndNext(poly p, ring)
Definition p_polys.h:711
#define pDivAssume(x)
Definition p_polys.h:1296
static poly p_Mult_mm(poly p, poly m, const ring r)
Definition p_polys.h:1051
void p_Cleardenom_n(poly p, const ring r, number &c)
Definition p_polys.cc:2958
long p_WDegree(poly p, const ring r)
Definition p_polys.cc:715
long pLDeg1c(poly p, int *l, ring r)
Definition p_polys.cc:878
poly p_Last(const poly a, int &l, const ring r)
Definition p_polys.cc:4671
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:1070
static poly p_Plus_mm_Mult_qq(poly p, poly m, poly q, int &lp, int lq, const ring r)
Definition p_polys.h:1197
void pEnlargeSet(poly **p, int length, int increment)
Definition p_polys.cc:3717
static BOOLEAN p_IsUnit(const poly p, const ring r)
Definition p_polys.h:2005
static poly p_Init(const ring r, omBin bin)
Definition p_polys.h:1334
BOOLEAN p_IsHomogeneous(poly p, const ring r)
Definition p_polys.cc:3323
unsigned long p_GetShortExpVector0(const poly a, const ring r)
Definition p_polys.cc:4881
poly p_Head0(const poly p, const ring r)
like p_Head, but allow NULL coeff
Definition p_polys.cc:5036
static poly p_LmDeleteAndNext(poly p, const ring r)
Definition p_polys.h:755
unsigned long p_GetShortExpVector1(const poly a, const ring r)
Definition p_polys.cc:4896
BOOLEAN pHaveCommonMonoms(poly p, poly q)
Definition pDebug.cc:174
unsigned long p_GetShortExpVector(const poly a, const ring r)
Definition p_polys.cc:4830
static poly pp_Mult_Coeff_mm_DivSelect(poly p, const poly m, const ring r)
Definition p_polys.h:1090
poly pp_JetW(poly p, int m, int *w, const ring R)
Definition p_polys.cc:4453
static BOOLEAN p_LmDivisibleByPart(poly a, poly b, const ring r, const int start, const int end)
Definition p_polys.h:1876
long p_Deg(poly a, const ring r)
Definition p_polys.cc:586
static poly p_SortAdd(poly p, const ring r, BOOLEAN revert=FALSE)
Definition p_polys.h:1233
void p_SimpleContent(poly p, int s, const ring r)
Definition p_polys.cc:2568
static poly p_Copy(poly p, const ring r)
returns a copy of p
Definition p_polys.h:846
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:2639
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:3616
static long p_Totaldegree(poly p, const ring r)
Definition p_polys.h:1521
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:1176
static BOOLEAN p_LmExpVectorAddIsOk(const poly p1, const poly p2, const ring r)
Definition p_polys.h:2013
static int p_LtCmpOrdSgnDiffP(poly p, poly q, const ring r)
Definition p_polys.h:1692
BOOLEAN _pp_Test(poly p, ring lmRing, ring tailRing, int level)
Definition pDebug.cc:332
void p_Lcm(const poly a, const poly b, poly m, const ring r)
Definition p_polys.cc:1659
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:161
#define __p_Mult_nn(p, n, r)
Definition p_polys.h:971
poly p_JetW(poly p, int m, int *w, const ring R)
Definition p_polys.cc:4480
static BOOLEAN p_IsConstantPoly(const poly p, const ring r)
Definition p_polys.h:1992
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:4562
long pLDeg0c(poly p, int *l, ring r)
Definition p_polys.cc:771
static void p_ExpVectorAddSub(poly p1, poly p2, poly p3, const ring r)
Definition p_polys.h:1470
BOOLEAN rOrd_SetCompRequiresSetm(const ring r)
return TRUE if p_SetComp requires p_Setm
Definition ring.cc:1996
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:405
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:426
#define rField_is_Ring(R)
Definition ring.h:490
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