# source:git/libpolys/polys/monomials/p_polys.h@608ba4

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