Changeset 8a8c9e in git for libpolys

Timestamp:

Jan 12, 2011, 7:17:19 PM (13 years ago)

Author:

Hans Schoenemann <hannes@…>

Branches:

(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', 'fc741b6502fd8a97288eaa3eba6e5220f3c3df87')

Children:

56790491568061b8fda62ac136d56bb3bca12583

Parents:

ce2120e7219cf5bd8e6ce5db355bc0cd410f02f6

git-author:

Hans Schoenemann <hannes@mathematik.uni-kl.de>2011-01-12 19:17:19+01:00

git-committer:

Mohamed Barakat <mohamed.barakat@rwth-aachen.de>2011-11-09 11:59:24+01:00

Message:

syntax fixes for libpoly, part 1

Location:

libpolys

Files:

• coeffs/coeffs.h (modified) (4 diffs)
• polys/Makefile.am (modified) (2 diffs)
• polys/monomials/monomials.cc (modified) (1 diff)
• polys/monomials/p_polys.cc (modified) (27 diffs)
• polys/monomials/p_polys.h (modified) (19 diffs)
• polys/monomials/ring.h (modified) (9 diffs)
• polys/polys.cc (modified) (1 diff)
• polys/sbuckets.cc (moved) (moved from kernel/sbuckets.cc)
• polys/sbuckets.h (moved) (moved from kernel/sbuckets.h) (1 diff)

libpolys/coeffs/coeffs.h

@@ -159 +159 @@
            (*cfIsMOne)(number a, const coeffs r),
            (*cfGreaterZero)(number a, const coeffs r);
-   
+
    void    (*cfPower)(number a, int i, number * result, const coeffs r);
    number  (*cfGetDenom)(number &n, const coeffs r);
@@ -219 +219 @@
   short      float_len2; /* additional char-flags, rInit */
 
-  BOOLEAN   ShortOut; /// ffields need this. 
+  BOOLEAN   ShortOut; /// ffields need this.
 
 // ---------------------------------------------------
@@ -265 +265 @@
 
 /// return a copy of a
-static inline number n_Copy(number n,    const coeffs r){ return (r)->cfCopy(n, r); }
-static inline void   n_Delete(number* p, const coeffs r){ return (r)->cfDelete(p, r); }
-
-static inline BOOLEAN n_Equal(number a, number b, const coeffs r){ return (r)->cfEqual(a, b, r); }
-static inline BOOLEAN n_IsZero(number n, const coeffs r){ return (r)->cfIsZero(n,r); }
-static inline BOOLEAN n_IsOne(number n,  const coeffs r){ return (r)->cfIsOne(n,r); }
-static inline BOOLEAN n_IsMOne(number n, const coeffs r){ return (r)->cfIsMOne(n,r); }
-static inline BOOLEAN n_GreaterZero(number n, const coeffs r){ return (r)->cfGreaterZero(n,r); }
+static inline number n_Copy(number n,    const coeffs r)
+{ return (r)->cfCopy(n, r); }
+static inline void   n_Delete(number* p, const coeffs r)
+{ return (r)->cfDelete(p, r); }
+
+static inline BOOLEAN n_Equal(number a, number b, const coeffs r)
+{ return (r)->cfEqual(a, b, r); }
+static inline BOOLEAN n_IsZero(number n, const coeffs r)
+{ return (r)->cfIsZero(n,r); }
+static inline BOOLEAN n_IsOne(number n,  const coeffs r)
+{ return (r)->cfIsOne(n,r); }
+static inline BOOLEAN n_IsMOne(number n, const coeffs r)
+{ return (r)->cfIsMOne(n,r); }
+static inline BOOLEAN n_GreaterZero(number n, const coeffs r)
+{ return (r)->cfGreaterZero(n,r); }
 // cfGreater?
 #ifdef HAVE_RINGS
-static inline BOOLEAN n_IsUnit(number n, const coeffs r) { return r->cfIsUnit(n,r); }
+static inline BOOLEAN n_IsUnit(number n, const coeffs r)
+{ return r->cfIsUnit(n,r); }
+static inline BOOLEAN n_DivBy(number a, number b, const coeffs r)
+{ return r->cfDivBy(a,b,r); }
 #endif
 
 /// init with an integer
-static inline number n_Init(int i,       const coeffs r){ return (r)->cfInit(i,r); }
+static inline number n_Init(int i,       const coeffs r)
+{ return (r)->cfInit(i,r); }
 
 /// changes argument  inline: a:= -a
-static inline number n_Neg(number n,     const coeffs r){ return (r)->cfNeg(n,r); }
+static inline number n_Neg(number n,     const coeffs r)
+{ return (r)->cfNeg(n,r); }
 
 /// return 1/a
-static inline number n_Invers(number a,  const coeffs r){ return (r)->cfInvers(a,r); }
+static inline number n_Invers(number a,  const coeffs r)
+{ return (r)->cfInvers(a,r); }
 
 /// use for pivot strategies, (0) => 0, otherwise positive
-static inline int    n_Size(number n,    const coeffs r){ return (r)->cfSize(n,r); }
+static inline int    n_Size(number n,    const coeffs r)
+{ return (r)->cfSize(n,r); }
 
 /// normalize the number. i.e. go to some canonnical representation (inplace)
-static inline void   n_Normalize(number& n, const coeffs r){ return (r)->cfNormalize(n,r); }
+static inline void   n_Normalize(number& n, const coeffs r)
+{ return (r)->cfNormalize(n,r); }
 
 /// Normalize and Write to the output buffer of reporter
-static inline void   n_Write(number& n,  const coeffs r){ return (r)->cfWrite(n,r); }
+static inline void   n_Write(number& n,  const coeffs r)
+{ return (r)->cfWrite(n,r); }
 
 /// Normalize and get denomerator
-static inline number n_GetDenom(number& n, const coeffs r){ return (r)->cfGetDenom(n, r); }
+static inline number n_GetDenom(number& n, const coeffs r)
+{ return (r)->cfGetDenom(n, r); }
 
 /// Normalize and get numerator
-static inline number n_GetNumerator(number& n, const coeffs r){ return (r)->cfGetNumerator(n, r); }
-
-static inline void   n_Power(number a, int b, number *res, const coeffs r){ return (r)->cfPower(a,b,res,r); }
-
-
-static inline number n_Mult(number a, number b, const coeffs r){ return (r)->cfMult(a, b, r); }
+static inline number n_GetNumerator(number& n, const coeffs r)
+{ return (r)->cfGetNumerator(n, r); }
+
+static inline void   n_Power(number a, int b, number *res, const coeffs r)
+{ return (r)->cfPower(a,b,res,r); }
+
+static inline number n_Mult(number a, number b, const coeffs r)
+{ return (r)->cfMult(a, b, r); }
 
 /// Inplace multiplication: a := a * b
-static inline void n_InpMult(number &a, number b, const coeffs r){ return (r)->cfInpMult(a,b,r); }
-
-static inline number n_Sub(number a, number b, const coeffs r){ return (r)->cfSub(a, b, r); }
-static inline number n_Add(number a, number b, const coeffs r){ return (r)->cfAdd(a, b, r); }
-
-static inline number n_Div(number a, number b, const coeffs r){ return (r)->cfDiv(a,b,r); }
-static inline number n_IntDiv(number a, number b, const coeffs r){ return (r)->cfIntDiv(a,b,r); }
-static inline number n_ExactDiv(number a, number b, const coeffs r){ return (r)->cfExactDiv(a,b,r); }
-
-static inline number n_Gcd(number a, number b, const coeffs r){ return (r)->cfGcd(a,b,r); }
+static inline void n_InpMult(number &a, number b, const coeffs r)
+{ return (r)->cfInpMult(a,b,r); }
+
+static inline number n_Sub(number a, number b, const coeffs r)
+{ return (r)->cfSub(a, b, r); }
+
+static inline number n_Add(number a, number b, const coeffs r)
+{ return (r)->cfAdd(a, b, r); }
+
+static inline number n_Div(number a, number b, const coeffs r)
+{ return (r)->cfDiv(a,b,r); }
+
+static inline number n_IntDiv(number a, number b, const coeffs r)
+{ return (r)->cfIntDiv(a,b,r); }
+
+static inline number n_ExactDiv(number a, number b, const coeffs r)
+{ return (r)->cfExactDiv(a,b,r); }
+
+static inline number n_Gcd(number a, number b, const coeffs r)
+{ return (r)->cfGcd(a,b,r); }
 
 /// Tests whether n is a correct number: only used if LDEBUG is defined
 static inline BOOLEAN n_DBTest(number n, const char *filename, const int linenumber, const coeffs r)
 {
-#ifdef LDEBUG  
+#ifdef LDEBUG
   return (r)->cfDBTest(n, filename, linenumber, r);
 #else
   return TRUE;
 #endif
-
 }
 
@@ -339 +367 @@
 
 // Deprecated:
-static inline int n_GetChar(const coeffs r){ return nInternalChar(r); }
-
-#endif
-
+static inline int n_GetChar(const coeffs r)
+{ return nInternalChar(r); }
+
+#endif
+

libpolys/polys/Makefile.am

@@ -13 +13 @@
         operations/pShallowCopyDelete.cc operations/p_Mult_q.cc \
         p_Procs_Lib.cc polys-impl.cc polys.cc \
-        polys0.cc polys1.cc prCopy.cc prCopyTemplate.cc
+        polys0.cc polys1.cc prCopy.cc prCopyTemplate.cc \
+        sbucktes.cc
 
 noinst_HEADERS =
@@ -22 +23 @@
         p_MemAdd.h p_MemCmp.h p_MemCopy.h operations/p_Mult_q.h p_Numbers.h p_Procs.h \
         p_Procs_Dynamic.h p_Procs_Impl.h p_Procs_Set.h p_Procs_Static.h \
-        monomials/p_polys.h monomials/polys-impl.h monomials/polys.h prCopy.h prCopyMacros.h
+        monomials/p_polys.h monomials/polys-impl.h monomials/polys.h prCopy.h prCopyMacros.h \
+        sbuckets.h
 
 lib_LIBRARIES=libpolys.a libpolys_g.a

libpolys/polys/monomials/monomials.cc

@@ -31 +31 @@
 #include <reporter/reporter.h>
 #include <coeffs/numbers.h>
-#include <polys/polys.h>
 #include <polys/monomials/ring.h>
+#include <polys/monomials/p_polys.h>
 #include <polys/templates/p_Procs.h>
 #include <reporter/reporter.h>

libpolys/polys/monomials/p_polys.cc

@@ -10 +10 @@
  *******************************************************************/
 
+#include <ctype.h>
 
 #include <misc/auxiliary.h>
@@ -16 +17 @@
 #include <polys/monomials/p_polys.h>
 #include <polys/monomials/ring.h>
+#include <coeffs/longrat.h>
 // #include <???/ideals.h>
 // #include <???/int64vec.h>
@@ -536 +538 @@
 
   for (;i<=r->N;i++)
-    j+=p_GetExp(p,i, r)*pWeight(i, r);
+    j+=p_GetExp(p,i, r)*p_Weight(i, r);
 
   return j;
@@ -1117 +1119 @@
   {
     rc = p_Init(r);
-    pSetCoeff0(rc,n_Init(i,r));
-    if (r->cf->nIsZero(p_GetCoeff(rc,r)))
+    pSetCoeff0(rc,n_Init(i,r->cf));
+    if (n_IsZero(pGetCoeff(rc),r->cf))
       p_LmDelete(&rc,r);
   }
@@ -1130 +1132 @@
 {
   poly rc = p_Init(r);
-  pSetCoeff0(rc,n_Init(1,r));
+  pSetCoeff0(rc,n_Init(1,r->cf));
   return rc;
 }
@@ -1167 +1169 @@
   int i,j;
   rc = p_Init(r);
-  const char *s = r->cf->nRead(st,&(rc->coef));
+  const char *s = r->cf->cfRead(st,&(rc->coef),r->cf);
   if (s==st)
   /* i.e. it does not start with a coeff: test if it is a ringvar*/
@@ -1206 +1208 @@
   }
 done:
-  if (r->cf->nIsZero(pGetCoeff(rc))) p_LmDelete(&rc,r);
+  if (n_IsZero(pGetCoeff(rc),r->cf)) p_LmDelete(&rc,r);
   else
   {
@@ -1260 +1262 @@
 poly p_NSet(number n, const ring r)
 {
-  if (r->cf->nIsZero(n))
-  {
-    r->cf->cfDelete(&n, r);
+  if (n_IsZero(n,r->cf))
+  {
+    n_Delete(&n, r->cf);
     return NULL;
   }
@@ -1283 +1285 @@
   assume((p_GetComp(a,r)==p_GetComp(b,r)) || (p_GetComp(b,r)==0));
   int i;
-  poly result = pInit();
+  poly result = p_Init(r);
 
   for(i=(int)r->N; i; i--)
@@ -1291 +1293 @@
   return result;
 }
+
+#ifdef HAVE_RINGS   //TODO Oliver
+
+poly p_Div_nn(poly p, const number n, const ring r)
+{
+  pAssume(!n_IsZero(n,r));
+  p_Test(p, r);
+
+  poly q = p;
+  while (p != NULL)
+  {
+    number nc = pGetCoeff(p);
+    pSetCoeff0(p, n_Div(nc, n, r->cf));
+    n_Delete(&nc, r->cf);
+    pIter(p);
+  }
+  p_Test(q, r);
+  return q;
+}
+#endif
 
 /*2
@@ -1323 +1345 @@
       if (prev==NULL)
       {
-        p_DeleteLm(&result,r);
+        p_LmDelete(&result,r);
         a=result;
       }
       else
       {
-        p_DeleteLm(&pNext(prev),r);
+        p_LmDelete(&pNext(prev),r);
         a=pNext(prev);
       }
@@ -1406 +1428 @@
 }
 
-static poly pDiffOpM(poly a, poly b,BOOLEAN multiply, const ring r)
+static poly p_DiffOpM(poly a, poly b,BOOLEAN multiply, const ring r)
 {
   int i,j,s;
@@ -1476 +1498 @@
   int i;
 
-  if(!n_IsOne(pGetCoeff(p),r))
+  if(!n_IsOne(pGetCoeff(p),r->cf))
   {
     number x, y;
     y = pGetCoeff(p);
-    n_Power(y,exp,&x,r);
-    n_Delete(&y,r);
+    n_Power(y,exp,&x,r->cf);
+    n_Delete(&y,r->cf);
     pSetCoeff0(p,x);
   }
@@ -1502 +1524 @@
 
   y = pGetCoeff(p);
-  x = n_Mult(y,pGetCoeff(q),r);
-  n_Delete(&y,r);
+  x = n_Mult(y,pGetCoeff(q),r->cf);
+  n_Delete(&y,r->cf);
   pSetCoeff0(p,x);
   //for (i=pVariables; i!=0; i--)
@@ -1523 +1545 @@
   poly r = p_Init(rr);
 
-  x = n_Mult(pGetCoeff(p),pGetCoeff(q),rr);
+  x = n_Mult(pGetCoeff(p),pGetCoeff(q),rr->cf);
   pSetCoeff0(r,x);
   p_ExpVectorSum(r,p, q, rr);
@@ -1566 +1588 @@
   {
     h = a[e];
-    x = n_Mult(bin[exp-e],pGetCoeff(h),r);
+    x = n_Mult(bin[exp-e],pGetCoeff(h),r->cf);
     p_SetCoeff(h,x,r);
     p_MonMult(h,b,r);
@@ -1575 +1597 @@
   {
     h = a[e];
-    x = n_Mult(bin[e],pGetCoeff(h),r);
+    x = n_Mult(bin[e],pGetCoeff(h),r->cf);
     p_SetCoeff(h,x,r);
     p_MonMult(h,b,r);
@@ -1710 +1732 @@
     if ((ph!=NULL) && rField_has_Units(r))
     {
-      number k = nGetUnit(pGetCoeff(ph));
+      number k = n_GetUnit(pGetCoeff(ph),r->cf);
       if (!n_IsOne(k,r->cf))
       {
@@ -1735 +1757 @@
   if(pNext(ph)==NULL)
   {
-    p_SetCoeff(ph,n_Init(1,r),r->cf);
+    p_SetCoeff(ph,n_Init(1,r->cf),r);
   }
   else
@@ -1741 +1763 @@
     n_Normalize(pGetCoeff(ph),r->cf);
     if(!n_GreaterZero(pGetCoeff(ph),r->cf)) ph = p_Neg(ph,r);
-    if (rField_is_Q())
+    if (rField_is_Q(r))
     {
       h=p_InitContent(ph,r);
@@ -1805 +1827 @@
       { // each monom: coeff in Q_a
         lnumber c_n_n=(lnumber)pGetCoeff(p);
-        napoly c_n=c_n_n->z;
+        poly c_n=c_n_n->z;
         while (c_n!=NULL)
         { // each monom: coeff in Q
@@ -1843 +1865 @@
         { // each monom: coeff in Q_a
           lnumber c_n_n=(lnumber)pGetCoeff(p);
-          napoly c_n=c_n_n->z;
+          poly c_n=c_n_n->z;
           while (c_n!=NULL)
           { // each monom: coeff in Q
@@ -2201 +2223 @@
     while (p!=NULL)
     {
-      n_Normalize(pGetCoeff(p,r->cf));
+      n_Normalize(pGetCoeff(p),r->cf);
       d=n_Lcm(h,pGetCoeff(p),r->cf);
       n_Delete(&h,r->cf);
@@ -2480 +2502 @@
   else 
     d=pFDeg;
-  o = d(p,currRing);
+  o = d(p,r);
   do
   {
@@ -2783 +2805 @@
 static BOOLEAN pOldLexOrder;
 
-static long pModDeg(poly p, ring r = currRing)
+static long pModDeg(poly p, ring r)
 {
   long d=pOldFDeg(p, r);
@@ -2881 +2903 @@
               number c=pGetCoeff(qq);
               number ee=nfPar(1);
-              number eee;nfPower(ee,e,&eee); //nfDelete(ee,currRing);
+              number eee;nfPower(ee,e,&eee); //nfDelete(ee,dst);
               ee=nfMult(c,eee);
-              //nfDelete(c,currRing);nfDelete(eee,currRing);
+              //nfDelete(c,dst);nfDelete(eee,dst);
               pSetCoeff0(qq,ee);
             }
@@ -2893 +2915 @@
               else /* more difficult: we have really to multiply: */
               {
-                lnumber mmc=(lnumber)naInit(1,currRing);
+                lnumber mmc=(lnumber)naInit(1,dst);
                 napSetExp(mmc->z,-perm[i],e/*p_GetExp( p,i,oldRing)*/);
                 napSetm(mmc->z);

libpolys/polys/monomials/p_polys.h

@@ -14 +14 @@
 
 #include <polys/monomials/ring.h>
+#include <polys/monomials/monomials.h>
 #include <polys/monomials/polys-impl.h>
+#include <polys/templates/p_Procs.h>
+#include <polys/templates/p_Procs.h>
+#include <polys/sbuckets.h>
 
 /***************************************************************
@@ -39 +43 @@
 
 // Component
-#define p_GetComp(p, r)     _p_GetComp(p, r)
 static inline unsigned long p_SetComp(poly p, unsigned long c, ring r);
 static inline unsigned long p_AddComp(poly p, unsigned long v, ring r);
@@ -181 +184 @@
 static inline BOOLEAN p_IsConstantComp(const poly p, const ring r);
 static inline BOOLEAN p_IsConstant(const poly p, const ring r);
-PINLINE0 BOOLEAN p_IsConstantPoly(const poly p, const ring r);
+static inline BOOLEAN p_IsConstantPoly(const poly p, const ring r);
 
 // return TRUE if all monoms have the same component
@@ -320 +323 @@
 
 // sets component of poly a to i, returns length of a
-PINLINE0   void p_SetCompP(poly a, int i, ring r);
-PINLINE0   void p_SetCompP(poly a, int i, ring lmRing, ring tailRing);
-PINLINE0   long p_MaxComp(poly p, ring lmRing, ring tailRing);
+static inline   void p_SetCompP(poly a, int i, ring r);
+static inline   void p_SetCompP(poly a, int i, ring lmRing, ring tailRing);
+static inline   long p_MaxComp(poly p, ring lmRing, ring tailRing);
 inline long p_MaxComp(poly p,ring lmRing) {return p_MaxComp(p,lmRing,lmRing);}
-PINLINE0   long p_MinComp(poly p, ring lmRing, ring tailRing);
+static inline   long p_MinComp(poly p, ring lmRing, ring tailRing);
 inline long p_MinComp(poly p,ring lmRing) {return p_MinComp(p,lmRing,lmRing);}
 
@@ -332 +335 @@
  *
  ***************************************************************/
-PINLINE0 int       pLength(poly a);
-PINLINE0 poly      pLast(poly a, int &length);
+static inline int       pLength(poly a);
+static inline poly      pLast(poly a, int &length);
 inline   poly      pLast(poly a) { int l; return pLast(a, l);}
-PINLINE0 poly pReverse(poly p);
+static inline poly pReverse(poly p);
 
 
@@ -441 +444 @@
 {
   p_LmCheckPolyRing2(p, r);
-  n_Delete(&(p->coef), r);
+  n_Delete(&(p->coef), r->cf);
   (p)->coef=n;
   return n;
@@ -496 +499 @@
   p_LmCheckPolyRing2(p, r);
   pAssume2(rRing_has_Comp(r));
-  pPolyAssume2(__p_GetComp(p,r) >= v,p,r);
+  _pPolyAssume2(__p_GetComp(p,r) >= v,p,r);
   return __p_GetComp(p,r) -= v;
 }
@@ -737 +740 @@
   return pnext;
 }
-static inline void p_LmDelete(poly p, ring r)
+static inline void p_LmDelete(poly p, const ring r)
 {
   p_LmCheckPolyRing2(p, r);
-  n_Delete(&pGetCoeff(p), r);
+  n_Delete(&pGetCoeff(p), r->cf);
   omFreeBinAddr(p);
 }
-static inline void p_LmDelete(poly *p, ring r)
+static inline void p_LmDelete(poly *p, const ring r)
 {
   p_LmCheckPolyRing2(*p, r);
   poly h = *p;
   *p = pNext(h);
-  n_Delete(&pGetCoeff(h), r);
+  n_Delete(&pGetCoeff(h), r->cf);
   omFreeBinAddr(h);
 }
-static inline poly p_LmDeleteAndNext(poly p, ring r)
+static inline poly p_LmDeleteAndNext(poly p, const ring r)
 {
   p_LmCheckPolyRing2(p, r);
   poly pnext = pNext(p);
-  n_Delete(&pGetCoeff(p), r);
+  n_Delete(&pGetCoeff(p), r->cf);
   omFreeBinAddr(p);
   return pnext;
@@ -910 +913 @@
 static inline poly p_Mult_nn(poly p, number n, const ring r)
 {
-  if (n_IsOne(n, r))
+  if (n_IsOne(n, r->cf))
     return p;
   else
@@ -935 +938 @@
 static inline poly pp_Mult_nn(poly p, number n, const ring r)
 {
-  if (n_IsOne(n, r))
+  if (n_IsOne(n, r->cf))
     return p_Copy(p, r);
   else
@@ -1114 +1117 @@
   int shorter;
   number n_old = pGetCoeff(m);
-  number n_neg = n_Copy(n_old, r);
-  n_neg = n_Neg(n_neg, r);
+  number n_neg = n_Copy(n_old, r->cf);
+  n_neg = n_Neg(n_neg, r->cf);
   pSetCoeff0(m, n_neg);
   res = r->p_Procs->p_Minus_mm_Mult_qq(p, m, q, shorter, NULL, r, last);
   lp = (lp + lq) - shorter;
   pSetCoeff0(m, n_old);
-  n_Delete(&n_neg, r);
+  n_Delete(&n_neg, r->cf);
   return res;
 }
@@ -1304 +1307 @@
   p_MemCopy_LengthGeneral(np->exp, p->exp, r->ExpL_Size);
   pNext(np) = NULL;
-  pSetCoeff0(np, n_Copy(pGetCoeff(p), r));
+  pSetCoeff0(np, n_Copy(pGetCoeff(p), r->cf));
   return np;
 }
@@ -1319 +1322 @@
   p_MemCopy_LengthGeneral(np->exp, p->exp, r->ExpL_Size);
   pNext(np) = NULL;
-  pSetCoeff0(np, n_Init(1, r));
+  pSetCoeff0(np, n_Init(1, r->cf));
   int i;
   for(i=l;i<=k;i++)
@@ -1544 +1547 @@
 #ifdef HAVE_RINGS
   pDivAssume(p_DebugLmDivisibleByNoComp(a, b, r) == nDivBy(p_GetCoeff(b, r), p_GetCoeff(a, r)));
-  return (!rField_is_Ring(r)) || nDivBy(p_GetCoeff(b, r), p_GetCoeff(a, r));
+  return (!rField_is_Ring(r)) || n_DivBy(p_GetCoeff(b, r), p_GetCoeff(a, r), r->cf);
 #else
   pDivAssume(p_DebugLmDivisibleByNoComp(a, b, r) == TRUE);
@@ -1564 +1567 @@
   while (i);
 #ifdef HAVE_RINGS
-  return nDivBy(p_GetCoeff(b, r), p_GetCoeff(a, r));
+  return n_DivBy(p_GetCoeff(b, r_b), p_GetCoeff(a, r_a), r_a->cf);
 #else
   return TRUE;
@@ -1661 +1664 @@
   p_LmCheckPolyRing1(b, r);
 #ifndef PDIV_DEBUG
-  pPolyAssume2(p_GetShortExpVector(a, r) == sev_a, a, r);
-  pPolyAssume2(p_GetShortExpVector(b, r) == ~ not_sev_b, b, r);
+  _pPolyAssume2(p_GetShortExpVector(a, r) == sev_a, a, r);
+  _pPolyAssume2(p_GetShortExpVector(b, r) == ~ not_sev_b, b, r);
 
   if (sev_a & not_sev_b)
@@ -1681 +1684 @@
   p_LmCheckPolyRing1(b, r_b);
 #ifndef PDIV_DEBUG
-  pPolyAssume2(p_GetShortExpVector(a, r_a) == sev_a, a, r_a);
-  pPolyAssume2(p_GetShortExpVector(b, r_b) == ~ not_sev_b, b, r_b);
+  _pPolyAssume2(p_GetShortExpVector(a, r_a) == sev_a, a, r_a);
+  _pPolyAssume2(p_GetShortExpVector(b, r_b) == ~ not_sev_b, b, r_b);
 
   if (sev_a & not_sev_b)
@@ -1777 +1780 @@
 poly      p_DiffOp(poly a, poly b,BOOLEAN multiply, const ring r);
 int       p_Weight(int c, const ring r);
-static inline long pTotaldegree(poly p) { return p_Totaldegree(p,currRing); }
 
 /* syszygy stuff */
@@ -1802 +1804 @@
 // on ordering and/or OrdIndex -- otherwise they might return wrong results
 // on strat->tailRing
-void pSetDegProcs(ring r. pFDegProc new_FDeg, pLDegProc new_lDeg = NULL);
+void pSetDegProcs(ring r, pFDegProc new_FDeg, pLDegProc new_lDeg = NULL);
 // restores pFDeg and pLDeg:
-void pRestoreDegProcs(ring r. pFDegProc old_FDeg, pLDegProc old_lDeg);
+void pRestoreDegProcs(ring r, pFDegProc old_FDeg, pLDegProc old_lDeg);
 
 /*-------------pComp for syzygies:-------------------*/

libpolys/polys/monomials/ring.h

@@ -11 +11 @@
 /* includes */
 #include <coeffs/coeffs.h>
+#include <omalloc/omalloc.h>
 //#include <polys/monomials/polys-impl.h>
+//
+
+/* constants */
+#define SHORT_REAL_LENGTH 6 // use short reals for real <= 6 digits
+
+/* forward declaration of types */
+class idrec;
+typedef idrec *   idhdl;
+struct sip_sideal;
+typedef struct sip_sideal *       ideal;
+struct ip_sring;
+typedef struct ip_sring *         ring;
+struct  spolyrec;
+typedef struct spolyrec    polyrec;
+typedef polyrec *          poly;
+class intvec;
+struct p_Procs_s;
+typedef struct p_Procs_s p_Procs_s;
+class slists;
+typedef slists *           lists;
+class kBucket;
+typedef kBucket*           kBucket_pt;
+
+#if SIZEOF_LONG == 4
+typedef long long int64;
+#elif SIZEOF_LONG == 8
+typedef long int64;
+#else
+#error int64 undefined
+#endif
+
+/* the function pointer types */
+
+typedef long     (*pLDegProc)(poly p, int *length, ring r);
+typedef long     (*pFDegProc)(poly p, ring r);
+typedef void     (*p_SetmProc)(poly p, const ring r);
+
+typedef enum
+{
+  ro_dp, // ordering is a degree ordering
+  ro_wp, // ordering is a weighted degree ordering
+  ro_wp64, // ordering is a weighted64 degree ordering
+  ro_wp_neg, // ordering is a weighted degree ordering
+             // with possibly negative weights
+  ro_cp,    // ordering duplicates variables
+  ro_syzcomp, // ordering indicates "subset" of component number (ringorder_S)
+  ro_syz, // ordering  with component number >syzcomp is lower (ringorder_s)
+  ro_isTemp, ro_is, // Induced Syzygy (Schreyer) ordering (and prefix data placeholder dummy) (ringorder_IS)
+  ro_none
+}
+ro_typ;
+
+// ordering is a degree ordering
+struct sro_dp
+{
+  short place;  // where degree is stored (in L):
+  short start;  // bounds of ordering (in E):
+  short end;
+};
+typedef struct sro_dp sro_dp;
+
+// ordering is a weighted degree ordering
+struct sro_wp
+{
+  short place;  // where weighted degree is stored (in L)
+  short start;  // bounds of ordering (in E)
+  short end;
+  int *weights; // pointers into wvhdl field
+};
+typedef struct sro_wp sro_wp;
+
+// ordering is a weighted degree ordering
+struct sro_wp64
+{
+    short place;  // where weighted degree is stored (in L)
+    short start;  // bounds of ordering (in E)
+    short end;
+    int64 *weights64; // pointers into wvhdl field
+};
+typedef struct sro_wp64 sro_wp64;
+
+// ordering duplicates variables
+struct sro_cp
+{
+  short place;  // where start is copied to (in E)
+  short start;  // bounds of sources of copied variables (in E)
+  short end;
+};
+typedef struct sro_cp sro_cp;
+
+// ordering indicates "subset" of component number
+struct sro_syzcomp
+{
+  short place;  // where the index is stored (in L)
+  long *ShiftedComponents; // pointer into index field
+  int* Components;
+#ifdef PDEBUG
+  long length;
+#endif
+};
+typedef struct sro_syzcomp sro_syzcomp;
+
+// ordering  with component number >syzcomp is lower
+struct sro_syz
+{
+  short place;       // where the index is stored (in L)
+  int limit;         // syzcomp
+  int* syz_index;    // mapping Component -> SyzIndex for Comp <= limit
+  int  curr_index;   // SyzIndex for Component > limit
+};
+
+typedef struct sro_syz sro_syz;
+// Induced Syzygy (Schreyer) ordering is built inductively as follows:
+// we look for changes made by ordering blocks which are between prefix/suffix markers:
+// that is: which variables where placed by them and where (judging by v)
+
+// due to prefix/suffix nature we need some placeholder:
+// prefix stores here initial state
+// suffix cleares this up
+struct sro_ISTemp
+{
+  short start; // 1st member SHOULD be short "place"
+  int   suffixpos;
+  int*  pVarOffset; // copy!
+};
+
+// So this is the actuall thing!
+// suffix uses last sro_ISTemp (cleares it up afterwards) and
+// creates this block
+struct sro_IS
+{
+  short start, end;  // which part of L we want to want to update...
+  int*  pVarOffset; // same as prefix!
+
+  int limit; // first referenced component
+
+  // reference poly set?? // Should it be owned by ring?!!!
+  ideal F; // reference leading (module)-monomials set. owned by ring...
+  const intvec* componentWeights; // component weights! owned by ring...
+};
+
+typedef struct sro_IS sro_IS;
+typedef struct sro_ISTemp sro_ISTemp;
+
+struct sro_ord
+{
+  ro_typ  ord_typ;
+  int     order_index; // comes from r->order[order_index]
+  union
+  {
+     sro_dp dp;
+     sro_wp wp;
+     sro_wp64 wp64;
+     sro_cp cp;
+     sro_syzcomp syzcomp;
+     sro_syz syz;
+     sro_IS is;
+     sro_ISTemp isTemp;
+  } data;
+};
+struct ip_sring
+{
+// each entry must have a description and a procedure defining it,
+// general ordering: pointer/structs, long, int, short, BOOLEAN/char/enum
+// general defining procedures: rInit, rComplete, interpreter, ??
+  idhdl      idroot; /* local objects , interpreter*/
+  int*       order;  /* array of orderings, rInit/rSleftvOrdering2Ordering */
+  int*       block0; /* starting pos., rInit/rSleftvOrdering2Ordering*/
+  int*       block1; /* ending pos., rInit/rSleftvOrdering2Ordering*/
+  char**     parameter; /* names of parameters, rInit */
+  number     minpoly;  /* for Q_a/Zp_a, rInit */
+  ideal      minideal;
+  int**      wvhdl;  /* array of weight vectors, rInit/rSleftvOrdering2Ordering */
+  char **    names;  /* array of variable names, rInit */
+
+  // what follows below here should be set by rComplete, _only_
+  long      *ordsgn;  /* array of +/- 1 (or 0) for comparing monomials */
+                       /*  ExpL_Size entries*/
+
+  // is NULL for lp or N == 1, otherwise non-NULL (with OrdSize > 0 entries) */
+  sro_ord*   typ;   /* array of orderings + sizes, OrdSize entries */
+  /* if NegWeightL_Size > 0, then NegWeightL_Offset[0..size_1] is index of longs
+  in ExpVector whose values need an offset due to negative weights */
+  /* array of NegWeigtL_Size indicies */
+  int*      NegWeightL_Offset;
+
+  int*     VarOffset;
+
+  ideal      qideal; /* extension to the ring structure: qring, rInit */
+
+  int*     firstwv;
+
+  omBin    PolyBin; /* Bin from where monoms are allocated */
+#ifdef HAVE_RINGS
+  unsigned int  ringtype;  /* cring = 0 => coefficient field, cring = 1 => coeffs from Z/2^m */
+  int_number    ringflaga; /* Z/(ringflag^ringflagb)=Z/nrnModul*/
+  unsigned long ringflagb;
+  unsigned long nr2mModul;  /* Z/nr2mModul */
+  int_number    nrnModul;
+#endif
+  unsigned long options; /* ring dependent options */
+
+  int        ch;  /* characteristic, rInit */
+  int        ref; /* reference counter to the ring, interpreter */
+
+  short      float_len; /* additional char-flags, rInit */
+  short      float_len2; /* additional char-flags, rInit */
+
+  short      N;      /* number of vars, rInit */
+
+  short      P;      /* number of pars, rInit */
+  short      OrdSgn; /* 1 for polynomial rings, -1 otherwise, rInit */
+
+  short     firstBlockEnds;
+#ifdef HAVE_PLURAL
+  short     real_var_start, real_var_end;
+#endif
+
+#ifdef HAVE_SHIFTBBA
+  short          isLPring; /* 0 for non-letterplace rings, otherwise the number of LP blocks, at least 1, known also as lV */
+#endif
+
+  BOOLEAN   VectorOut;
+  BOOLEAN   ShortOut;
+  BOOLEAN   CanShortOut;
+  BOOLEAN   LexOrder; // TRUE if the monomial ordering has polynomial and power series blocks
+  BOOLEAN   MixedOrder; // TRUE for global/local mixed orderings, FALSE otherwise
+
+  BOOLEAN   ComponentOrder; // ???
+
+  // what follows below here should be set by rComplete, _only_
+  // contains component, but no weight fields in E */
+  short      ExpL_Size; // size of exponent vector in long
+  short      CmpL_Size; // portions which need to be compared
+  /* number of long vars in exp vector:
+     long vars are those longs in the exponent vector which are
+     occupied by variables, only */
+  short      VarL_Size;
+  short      BitsPerExp; /* number of bits per exponent */
+  short      ExpPerLong; /* maximal number of Exponents per long */
+  short      pCompIndex; /* p->exp.e[pCompIndex] is the component */
+  short      pOrdIndex; /* p->exp[pOrdIndex] is pGetOrd(p) */
+  short      OrdSize; /* size of ord vector (in sro_ord) */
+
+  /* if >= 0, long vars in exp vector are consecutive and start there
+     if <  0, long vars in exp vector are not consecutive */
+  short     VarL_LowIndex;
+  // number of exponents in r->VarL_Offset[0]
+  // is minimal number of exponents in a long var
+  short     MinExpPerLong;
+
+  short     NegWeightL_Size;
+  /* array of size VarL_Size,
+     VarL_Offset[i] gets i-th long var in exp vector */
+  int*      VarL_Offset;
+
+  /* mask for getting single exponents */
+  unsigned long bitmask;
+  /* mask used for divisiblity tests */
+  unsigned long divmask; // rComplete
+
+  p_Procs_s*    p_Procs; // rComplete/p_ProcsSet
+
+  /* FDeg and LDeg */
+  pFDegProc     pFDeg; // rComplete/rSetDegStuff
+  pLDegProc     pLDeg; // rComplete/rSetDegStuff
+
+  /* as it was determined by rComplete */
+  pFDegProc     pFDegOrig;
+  /* and as it was determined before rOptimizeLDeg */
+  pLDegProc     pLDegOrig;
+
+  p_SetmProc    p_Setm;
+  n_Procs_s*    cf;
+  ring          algring;
+#ifdef HAVE_PLURAL
+  private:
+    nc_struct*    _nc; // private
+  public:
+    inline const nc_struct* GetNC() const { return _nc; }; // public!!!
+    inline nc_struct*& GetNC() { return _nc; }; // public!!!
+#endif
+};
 
 enum tHomog
@@ -42 +326 @@
 #ifdef HAVE_PLURAL
   nc_struct *n;
-  return (r != NULL) && ((n=r->GetNC()) != NULL) /*&& (n->type != nc_error)*/; 
+  return (r != NULL) && ((n=r->GetNC()) != NULL) /*&& (n->type != nc_error)*/;
 #else
   return false;
@@ -53 +337 @@
   /* nc_struct *n; */
   return (r != NULL) /* && ((n=r->GetNC()) != NULL) */
-          && (r->real_var_start>1);
+          && (r->real_var_start>1);
 #else
   return false;
@@ -69 +353 @@
                      long* currShiftedComponents,
                      int length,
-                     ring r = currRing);
+                     ring r);
 void rDBGetSComps(int** currComponents,
                   long** currShiftedComponents,
                   int *length,
-                  ring r = currRing);
+                  ring r);
 #else
 #define rChangeSComps(c,s,l) rNChangeSComps(c,s)
@@ -79 +363 @@
 #endif
 
-void rNChangeSComps(int* currComponents, long* currShiftedComponents, ring r = currRing);
-void rNGetSComps(int** currComponents, long** currShiftedComponents, ring r = currRing);
+void rNChangeSComps(int* currComponents, long* currShiftedComponents, ring r);
+void rNGetSComps(int** currComponents, long** currShiftedComponents, ring r);
 
 //idhdl  rFindHdl(ring r, idhdl n, idhdl w);
@@ -94 +378 @@
 #define rVar(r) (r->N)
 char * rParStr(ring r);
-int    rIsExtension(const ring r=currRing);
+int    rIsExtension(const ring r);
 int    rSum(ring r1, ring r2, ring &sum);
 int rSumInternal(ring r1, ring r2, ring &sum, BOOLEAN vartest, BOOLEAN dp_dp);
@@ -271 +555 @@
 
 // misc things
-static inline char* rRingVar(short i)
-{
-  return currRing->names[i];
-}
-static inline char* rRingVar(short i, ring r)
+static inline char* rRingVar(short i, const ring r)
 {
   return r->names[i];
 }
-static inline BOOLEAN rShortOut(ring r)
+static inline BOOLEAN rShortOut(const ring r)
 {
   return (r->ShortOut);
@@ -332 +612 @@
 { return r->order[0] == ringorder_s;}
 
-static inline int rGetCurrSyzLimit(const ring r = currRing)
+static inline int rGetCurrSyzLimit(const ring r)
 { return (rIsSyzIndexRing(r)? r->typ[0].data.syz.limit : 0);}
 
@@ -375 +655 @@
 
 /// returns TRUE if var(i) belongs to p-block
-BOOLEAN rIsPolyVar(int i, ring r = currRing);
+BOOLEAN rIsPolyVar(int i, ring r);
 
 static inline BOOLEAN rOrd_is_Comp_dp(ring r)

libpolys/polys/polys.cc

@@ -35 +35 @@
 poly      ppNoether = NULL;
 
-#ifdef HAVE_RINGS   //TODO Oliver
-#define pDiv_nn(p, n)              p_Div_nn(p, n, currRing)
-
-poly p_Div_nn(poly p, const number n, const ring r)
-{
-  pAssume(!n_IsZero(n,r));
-  p_Test(p, r);
-
-  poly q = p;
-  while (p != NULL)
-  {
-    number nc = pGetCoeff(p);
-    pSetCoeff0(p, n_Div(nc, n, r));
-    n_Delete(&nc, r);
-    pIter(p);
-  }
-  p_Test(q, r);
-  return q;
-}
-#endif
-
 #ifdef HAVE_RINGS
 /* TRUE iff LT(f) | LT(g) */

libpolys/polys/sbuckets.h

@@ -15 +15 @@
 #define S_BUCKETS_H
 
-#include <kernel/structs.h>
-#include <kernel/ring.h>
+#include <polys/monomials/ring.h>
 
 
-
+class sBucket;
+typedef sBucket*           sBucket_pt;
 //////////////////////////////////////////////////////////////////////////
 // Creation/Destruction of buckets
 //
-sBucket_pt    sBucketCreate(ring r = currRing);
+sBucket_pt    sBucketCreate(ring r);
 void          sBucketDestroy(sBucket_pt *bucket);