Changeset 107986 in git

Timestamp:

Jul 25, 2008, 4:37:55 PM (15 years ago)

Author:

Hans Schönemann <hannes@…>

Branches:

(u'jengelh-datetime', 'ceac47cbc86fe4a15902392bdbb9bd2ae0ea02c6')(u'spielwiese', 'a657104b677b4c461d018cbf3204d72d34ad66a9')

Children:

356960f1a09d63bc25ab2b04269bb1f6ce67fd28

Parents:

7a6c062bb1546ba06ab19b759243b02e83b52197

Message:

*hannes: part stuff ,const ring


git-svn-id: file:///usr/local/Singular/svn/trunk@10909 2c84dea3-7e68-4137-9b89-c4e89433aadc

Location:

kernel

Files:

• kutil.cc (modified) (4 diffs)
• p_polys.cc (modified) (25 diffs)
• polys-impl.cc (modified) (2 diffs)
• polys.cc (modified) (4 diffs)
• polys.h (modified) (6 diffs)
• polys1.cc (modified) (2 diffs)

kernel/kutil.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: kutil.cc,v 1.102 2008-07-24 10:26:21 Singular Exp $ */
+/* $Id: kutil.cc,v 1.103 2008-07-25 14:37:55 Singular Exp $ */
 /*
 * ABSTRACT: kernel: utils for kStd
@@ -159 +159 @@
   if (pGetComp(p) == pGetComp(q))
   {
+#ifdef HAVE_PLURAL
+    if (currRing->real_var_start>0)
+    {
+      if (_p_LmDivisibleByPart(p,currRing,
+                           q,currRing,
+                           currRing->real_var_start, currRing->real_var_end))
+        return 0; 
+      return pLmCmp(q,p); // ONLY FOR GLOBAL ORDER!
+    }
+#endif
     BOOLEAN a=FALSE, b=FALSE;
     int i;
@@ -185 +195 @@
       }
     }
-    if (a) return 1;
-    if (b) return -1;
+    if (a) { /*assume(pLmCmp(q,p)==1);*/ return 1; }
+    if (b) { /*assume(pLmCmp(q,p)==-1);*/return -1; }
+    /*assume(pLmCmp(q,p)==0);*/
   }
   return 0;
@@ -1914 +1925 @@
             && (!pLmEqual(strat->L[i].p,strat->L[l].p))
             && pDivisibleBy(p,strat->L[l].lcm))
+            {
+              /*
+              *"NOT equal(...)" because in case of "equal" the element L[l]
+              *is "older" and has to be from theoretical point of view behind
+              *L[i], but we do not want to reorder L
+              */
+              strat->L[i].p2 = strat->tail;
+              /*
+              *L[l] will be canceled, we cannot cancel L[i] later on,
+              *so we mark it with "tail"
+              */
+              deleteInL(strat->L,&strat->Ll,l,strat);
+              i--;
+            }
+            else
+            {
+              deleteInL(strat->L,&strat->Ll,i,strat);
+            }
+            j--;
+          }
+          i--;
+        }
+      }
+      else if (strat->L[j].p2 == strat->tail)
+      {
+        /*now L[j] cannot be canceled any more and the tail can be removed*/
+        strat->L[j].p2 = p;
+      }
+      j--;
+    }
+  }
+}
+void chainCritPart (poly p,int ecart,kStrategy strat)
+{
+  int i,j,l;
+
+  /*
+  *pairtest[i] is TRUE if spoly(S[i],p) == 0.
+  *In this case all elements in B such
+  *that their lcm is divisible by the leading term of S[i] can be canceled
+  */
+  if (strat->pairtest!=NULL)
+  {
+    {
+      /*- i.e. there is an i with pairtest[i]==TRUE -*/
+      for (j=0; j<=strat->sl; j++)
+      {
+        if (strat->pairtest[j])
+        {
+          for (i=strat->Bl; i>=0; i--)
+          {
+            if (_p_LmDivisibleByPart(strat->S[j],currRing,
+               strat->B[i].lcm,currRing,
+               currRing->real_var_start,currRing->real_var_end))
+            {
+              deleteInL(strat->B,&strat->Bl,i,strat);
+              strat->c3++;
+            }
+          }
+        }
+      }
+    }
+    omFreeSize(strat->pairtest,(strat->sl+2)*sizeof(BOOLEAN));
+    strat->pairtest=NULL;
+  }
+  if (strat->Gebauer || strat->fromT)
+  {
+    if (strat->sugarCrit)
+    {
+    /*
+    *suppose L[j] == (s,r) and p/lcm(s,r)
+    *and lcm(s,r)#lcm(s,p) and lcm(s,r)#lcm(r,p)
+    *and in case the sugar is o.k. then L[j] can be canceled
+    */
+      for (j=strat->Ll; j>=0; j--)
+      {
+        if (sugarDivisibleBy(ecart,strat->L[j].ecart)
+        && ((pNext(strat->L[j].p) == strat->tail) || (pOrdSgn==1))
+        && pCompareChainPart(p,strat->L[j].p1,strat->L[j].p2,strat->L[j].lcm))
+        {
+          if (strat->L[j].p == strat->tail)
+          {
+              deleteInL(strat->L,&strat->Ll,j,strat);
+              strat->c3++;
+          }
+        }
+      }
+      /*
+      *this is GEBAUER-MOELLER:
+      *in B all elements with the same lcm except the "best"
+      *(i.e. the last one in B with this property) will be canceled
+      */
+      j = strat->Bl;
+      loop /*cannot be changed into a for !!! */
+      {
+        if (j <= 0) break;
+        i = j-1;
+        loop
+        {
+          if (i <  0) break;
+          if (pLmEqual(strat->B[j].lcm,strat->B[i].lcm))
+          {
+            strat->c3++;
+            if (sugarDivisibleBy(strat->B[j].ecart,strat->B[i].ecart))
+            {
+              deleteInL(strat->B,&strat->Bl,i,strat);
+              j--;
+            }
+            else
+            {
+              deleteInL(strat->B,&strat->Bl,j,strat);
+              break;
+            }
+          }
+          i--;
+        }
+        j--;
+      }
+    }
+    else /*sugarCrit*/
+    {
+      /*
+      *suppose L[j] == (s,r) and p/lcm(s,r)
+      *and lcm(s,r)#lcm(s,p) and lcm(s,r)#lcm(r,p)
+      *and in case the sugar is o.k. then L[j] can be canceled
+      */
+      for (j=strat->Ll; j>=0; j--)
+      {
+        if (pCompareChainPart(p,strat->L[j].p1,strat->L[j].p2,strat->L[j].lcm))
+        {
+          if ((pNext(strat->L[j].p) == strat->tail)||(pOrdSgn==1))
+          {
+            deleteInL(strat->L,&strat->Ll,j,strat);
+            strat->c3++;
+          }
+        }
+      }
+      /*
+      *this is GEBAUER-MOELLER:
+      *in B all elements with the same lcm except the "best"
+      *(i.e. the last one in B with this property) will be canceled
+      */
+      j = strat->Bl;
+      loop   /*cannot be changed into a for !!! */
+      {
+        if (j <= 0) break;
+        for(i=j-1; i>=0; i--)
+        {
+          if (pLmEqual(strat->B[j].lcm,strat->B[i].lcm))
+          {
+            strat->c3++;
+            deleteInL(strat->B,&strat->Bl,i,strat);
+            j--;
+          }
+        }
+        j--;
+      }
+    }
+    /*
+    *the elements of B enter L/their order with respect to B is kept
+    *j = posInL(L,j,B[i]) would permutate the order
+    *if once B is ordered different from L
+    *then one should use j = posInL(L,Ll,B[i])
+    */
+    j = strat->Ll+1;
+    for (i=strat->Bl; i>=0; i--)
+    {
+      j = strat->posInL(strat->L,j-1,&(strat->B[i]),strat);
+      enterL(&strat->L,&strat->Ll,&strat->Lmax,strat->B[i],j);
+    }
+    strat->Bl = -1;
+  }
+  else
+  {
+    for (j=strat->Ll; j>=0; j--)
+    {
+      if (pCompareChainPart(p,strat->L[j].p1,strat->L[j].p2,strat->L[j].lcm))
+      {
+        if ((pNext(strat->L[j].p) == strat->tail)||(pOrdSgn==1))
+        {
+          deleteInL(strat->L,&strat->Ll,j,strat);
+          strat->c3++;
+        }
+      }
+    }
+    /*
+    *this is our MODIFICATION of GEBAUER-MOELLER:
+    *First the elements of B enter L,
+    *then we fix a lcm and the "best" element in L
+    *(i.e the last in L with this lcm and of type (s,p))
+    *and cancel all the other elements of type (r,p) with this lcm
+    *except the case the element (s,r) has also the same lcm
+    *and is on the worst position with respect to (s,p) and (r,p)
+    */
+    /*
+    *B enters to L/their order with respect to B is permutated for elements
+    *B[i].p with the same leading term
+    */
+    j = strat->Ll;
+    for (i=strat->Bl; i>=0; i--)
+    {
+      j = strat->posInL(strat->L,j,&(strat->B[i]),strat);
+      enterL(&strat->L,&strat->Ll,&strat->Lmax,strat->B[i],j);
+    }
+    strat->Bl = -1;
+    j = strat->Ll;
+    loop  /*cannot be changed into a for !!! */
+    {
+      if (j <= 0)
+      {
+        /*now L[0] cannot be canceled any more and the tail can be removed*/
+        if (strat->L[0].p2 == strat->tail) strat->L[0].p2 = p;
+        break;
+      }
+      if (strat->L[j].p2 == p)
+      {
+        i = j-1;
+        loop
+        {
+          if (i < 0)  break;
+          if ((strat->L[i].p2 == p) && pLmEqual(strat->L[j].lcm,strat->L[i].lcm))
+          {
+            /*L[i] could be canceled but we search for a better one to cancel*/
+            strat->c3++;
+            if (isInPairsetL(i-1,strat->L[j].p1,strat->L[i].p1,&l,strat)
+            && (pNext(strat->L[l].p) == strat->tail)
+            && (!pLmEqual(strat->L[i].p,strat->L[l].p))
+            && _p_LmDivisibleByPart(p,currRing,
+                           strat->L[l].lcm,currRing,
+                           currRing->real_var_start, currRing->real_var_end))
+
             {
               /*

kernel/p_polys.cc

@@ -7 +7 @@
  *  Author:  obachman (Olaf Bachmann)
  *  Created: 8/00
- *  Version: $Id: p_polys.cc,v 1.12 2007-11-16 18:37:28 Singular Exp $
+ *  Version: $Id: p_polys.cc,v 1.13 2008-07-25 14:37:55 Singular Exp $
  *******************************************************************/
 
@@ -230 +230 @@
 * the ordering is compatible with degree, use a->order
 */
-inline long _pDeg(poly a, ring r)
+inline long _pDeg(poly a, const ring r)
 {
   p_LmCheckPolyRing(a, r);
@@ -237 +237 @@
 }
 
-long pDeg(poly a, ring r)
+long pDeg(poly a, const ring r)
 {
   return _pDeg(a, r);
@@ -248 +248 @@
 * the ordering is not compatible with degree so do not use p->Order
 */
-inline long _pTotaldegree(poly p, ring r)
+inline long _pTotaldegree(poly p, const ring r)
 {
   p_LmCheckPolyRing(p, r);
   return (long) p_ExpVectorQuerSum(p, r);
 }
-long pTotaldegree(poly p, ring r)
+long pTotaldegree(poly p, const ring r)
 {
   return (long) _pTotaldegree(p, r);
@@ -260 +260 @@
 // pWTotalDegree for weighted orderings
 // whose first block covers all variables
-inline long _pWFirstTotalDegree(poly p, ring r)
+inline long _pWFirstTotalDegree(poly p, const ring r)
 {
   int i;
@@ -272 +272 @@
 }
 
-long pWFirstTotalDegree(poly p, ring r)
+long pWFirstTotalDegree(poly p, const ring r)
 {
   return (long) _pWFirstTotalDegree(p, r);
@@ -282 +282 @@
 * the ordering is not compatible with degree so do not use p->Order
 */
-long pWTotaldegree(poly p, ring r)
+long pWTotaldegree(poly p, const ring r)
 {
   p_LmCheckPolyRing(p, r);
@@ -366 +366 @@
 }
 
-long pWDegree(poly p, ring r)
+long pWDegree(poly p, const ring r)
 {
   if (r->firstwv==NULL) return pTotaldegree(p, r);
@@ -391 +391 @@
 * and the degree of the monomial with maximal degree: the last one
 */
-long pLDeg0(poly p,int *l, ring r)
+long pLDeg0(poly p,int *l, const ring r)
 {
   p_CheckPolyRing(p, r);
@@ -422 +422 @@
 * but search in all components before syzcomp
 */
-long pLDeg0c(poly p,int *l, ring r)
+long pLDeg0c(poly p,int *l, const ring r)
 {
   assume(p!=NULL);
@@ -467 +467 @@
 * (both c,dp and dp,c)
 */
-long pLDegb(poly p,int *l, ring r)
+long pLDegb(poly p,int *l, const ring r)
 {
   p_CheckPolyRing(p, r);
@@ -497 +497 @@
 * this is NOT the last one, we have to look for it
 */
-long pLDeg1(poly p,int *l, ring r)
+long pLDeg1(poly p,int *l, const ring r)
 {
   p_CheckPolyRing(p, r);
@@ -533 +533 @@
 * in all components
 */
-long pLDeg1c(poly p,int *l, ring r)
+long pLDeg1c(poly p,int *l, const ring r)
 {
   p_CheckPolyRing(p, r);
@@ -566 +566 @@
 
 // like pLDeg1, only pFDeg == pDeg
-long pLDeg1_Deg(poly p,int *l, ring r)
+long pLDeg1_Deg(poly p,int *l, const ring r)
 {
   assume(r->pFDeg == pDeg);
@@ -597 +597 @@
 }
 
-long pLDeg1c_Deg(poly p,int *l, ring r)
+long pLDeg1c_Deg(poly p,int *l, const ring r)
 {
   assume(r->pFDeg == pDeg);
@@ -631 +631 @@
 
 // like pLDeg1, only pFDeg == pTotoalDegree
-long pLDeg1_Totaldegree(poly p,int *l, ring r)
+long pLDeg1_Totaldegree(poly p,int *l, const ring r)
 {
   p_CheckPolyRing(p, r);
@@ -661 +661 @@
 }
 
-long pLDeg1c_Totaldegree(poly p,int *l, ring r)
+long pLDeg1c_Totaldegree(poly p,int *l, const ring r)
 {
   p_CheckPolyRing(p, r);
@@ -694 +694 @@
 
 // like pLDeg1, only pFDeg == pWFirstTotalDegree
-long pLDeg1_WFirstTotalDegree(poly p,int *l, ring r)
+long pLDeg1_WFirstTotalDegree(poly p,int *l, const ring r)
 {
   p_CheckPolyRing(p, r);
@@ -724 +724 @@
 }
 
-long pLDeg1c_WFirstTotalDegree(poly p,int *l, ring r)
+long pLDeg1c_WFirstTotalDegree(poly p,int *l, const ring r)
 {
   p_CheckPolyRing(p, r);
@@ -763 +763 @@
 
 static inline unsigned long
-p_GetMaxExpL2(unsigned long l1, unsigned long l2, ring r,
+p_GetMaxExpL2(unsigned long l1, unsigned long l2, const ring r,
               unsigned long number_of_exp)
 {
@@ -789 +789 @@
 
 static inline unsigned long
-p_GetMaxExpL2(unsigned long l1, unsigned long l2, ring r)
+p_GetMaxExpL2(unsigned long l1, unsigned long l2, const ring r)
 {
   return p_GetMaxExpL2(l1, l2, r, r->ExpPerLong);
 }
 
-poly p_GetMaxExpP(poly p, ring r)
+poly p_GetMaxExpP(poly p, const ring r)
 {
   p_CheckPolyRing(p, r);
@@ -831 +831 @@
 }
 
-unsigned long p_GetMaxExpL(poly p, ring r, unsigned long l_max)
+unsigned long p_GetMaxExpL(poly p, const ring r, unsigned long l_max)
 {
   unsigned long l_p, divmask = r->divmask;
@@ -864 +864 @@
  ***************************************************************/
 // returns TRUE, if all monoms have the same component
-BOOLEAN p_OneComp(poly p, ring r)
+BOOLEAN p_OneComp(poly p, const ring r)
 {
   if(p!=NULL)
@@ -952 +952 @@
 * returns a polynomial representing the integer i
 */
-poly p_ISet(int i, ring r)
+poly p_ISet(int i, const ring r)
 {
   poly rc = NULL;
@@ -969 +969 @@
 * destroys n
 */
-poly p_NSet(number n, ring r)
+poly p_NSet(number n, const ring r)
 {
   if (r->cf->nIsZero(n))

kernel/polys-impl.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: polys-impl.cc,v 1.2 2005-12-02 12:25:43 Singular Exp $ */
+/* $Id: polys-impl.cc,v 1.3 2008-07-25 14:37:55 Singular Exp $ */
 
 /***************************************************************
@@ -47 +47 @@
 
 
-void ppDelete(poly* p, ring rg)
+void ppDelete(poly* p, const ring rg)
 {
   ring origRing = currRing;

kernel/polys.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: polys.cc,v 1.33 2008-07-15 15:29:15 wienand Exp $ */
+/* $Id: polys.cc,v 1.34 2008-07-25 14:37:55 Singular Exp $ */
 
 /*
@@ -209 +209 @@
 * convert monomial given as string to poly, e.g. 1x3y5z
 */
-const char * p_Read(const char *st, poly &rc, ring r)
+const char * p_Read(const char *st, poly &rc, const ring r)
 {
   if (r==NULL) { rc=NULL;return st;}
@@ -782 +782 @@
 *normalize all coefficients
 */
-void p_Normalize(poly p, ring r)
+void p_Normalize(poly p,const ring r)
 {
   if (rField_has_simple_inverse(r)) return; /* Z/p, GF(p,n), R, long R/C */
@@ -1041 +1041 @@
   return FALSE;
 }
+BOOLEAN pCompareChainPart (poly p,poly p1,poly p2,poly lcm)
+{
+  int k, j;
+
+  if (lcm==NULL) return FALSE;
+
+  for (j=currRing->real_var_end; j>=currRing->real_var_start; j--)
+    if ( pGetExp(p,j) >  pGetExp(lcm,j)) return FALSE;
+  if ( pGetComp(p) !=  pGetComp(lcm)) return FALSE;
+  for (j=currRing->real_var_end; j>=currRing->real_var_start; j--)
+  {
+    if (pGetExp(p1,j)!=pGetExp(lcm,j))
+    {
+      if (pGetExp(p,j)!=pGetExp(lcm,j))
+      {
+        for (k=pVariables; k>j; k--)
+        for (k=currRing->real_var_end; k>j; k--)
+        {
+          if ((pGetExp(p,k)!=pGetExp(lcm,k))
+          && (pGetExp(p2,k)!=pGetExp(lcm,k)))
+            return TRUE;
+        }
+        for (k=j-1; k>=currRing->real_var_start; k--)
+        {
+          if ((pGetExp(p,k)!=pGetExp(lcm,k))
+          && (pGetExp(p2,k)!=pGetExp(lcm,k)))
+            return TRUE;
+        }
+        return FALSE;
+      }
+    }
+    else if (pGetExp(p2,j)!=pGetExp(lcm,j))
+    {
+      if (pGetExp(p,j)!=pGetExp(lcm,j))
+      {
+        for (k=currRing->real_var_end; k>j; k--)
+        {
+          if ((pGetExp(p,k)!=pGetExp(lcm,k))
+          && (pGetExp(p1,k)!=pGetExp(lcm,k)))
+            return TRUE;
+        }
+        for (k=j-1; k>=currRing->real_var_start; k--)
+        {
+          if ((pGetExp(p,k)!=pGetExp(lcm,k))
+          && (pGetExp(p1,k)!=pGetExp(lcm,k)))
+            return TRUE;
+        }
+        return FALSE;
+      }
+    }
+  }
+  return FALSE;
+}
 
 int pSize(poly p)

kernel/polys.h

@@ -4 +4 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: polys.h,v 1.16 2008-03-19 17:44:11 Singular Exp $ */
+/* $Id: polys.h,v 1.17 2008-07-25 14:37:55 Singular Exp $ */
 /*
 * ABSTRACT - all basic methods to manipulate polynomials of the
@@ -302 +302 @@
 extern pFDegProc pFDeg;
 int  pWeight(int c, const ring r = currRing);
-long pDeg(poly p, ring r = currRing);
-long pTotaldegree(poly p, ring r = currRing);
-long pWTotaldegree(poly p, ring r = currRing);
-long pWDegree(poly p, ring r = currRing);
-long pLDeg0(poly p,int *l, ring r = currRing);
-long pLDeg0c(poly p,int *l, ring r = currRing);
-long pLDegb(poly p,int *l, ring r = currRing);
-long pLDeg1(poly p,int *l, ring r = currRing);
-long pLDeg1c(poly p,int *l, ring r = currRing);
-long pLDeg1_Deg(poly p,int *l, ring r = currRing);
-long pLDeg1c_Deg(poly p,int *l, ring r = currRing);
-long pLDeg1_Totaldegree(poly p,int *l, ring r = currRing);
-long pLDeg1c_Totaldegree(poly p,int *l, ring r = currRing);
-long pLDeg1_WFirstTotalDegree(poly p,int *l, ring r=currRing);
-long pLDeg1c_WFirstTotalDegree(poly p,int *l, ring r=currRing);
+long pDeg(poly p,const ring r = currRing);
+long pTotaldegree(poly p,const ring r = currRing);
+long pWTotaldegree(poly p,const ring r = currRing);
+long pWDegree(poly p,const ring r = currRing);
+long pLDeg0(poly p,int *l,const ring r = currRing);
+long pLDeg0c(poly p,int *l,const ring r = currRing);
+long pLDegb(poly p,int *l,const ring r = currRing);
+long pLDeg1(poly p,int *l,const ring r = currRing);
+long pLDeg1c(poly p,int *l,const ring r = currRing);
+long pLDeg1_Deg(poly p,int *l,const ring r = currRing);
+long pLDeg1c_Deg(poly p,int *l,const ring r = currRing);
+long pLDeg1_Totaldegree(poly p,int *l,const ring r = currRing);
+long pLDeg1c_Totaldegree(poly p,int *l,const ring r = currRing);
+long pLDeg1_WFirstTotalDegree(poly p,int *l,const ring r=currRing);
+long pLDeg1c_WFirstTotalDegree(poly p,int *l,const ring r=currRing);
 
 /*-------------pComp for syzygies:-------------------*/
@@ -326 +326 @@
 
 poly      pmInit(const char *s, BOOLEAN &ok); /* monom -> poly, interpreter */
-const char *    p_Read(const char *s, poly &p, ring r); /* monom -> poly */
-void      ppDelete(poly * a, ring r);
+const char *    p_Read(const char *s, poly &p,const ring r); /* monom -> poly */
+void      ppDelete(poly * a,const ring r);
 
 /*-------------operations on polynomials:------------*/
@@ -364 +364 @@
 void      pCleardenom(poly p);
 void      pCleardenom_n(poly p,number &c);
-void      p_Normalize(poly p, ring r);
+void      p_Normalize(poly p,const ring r);
 #define   pNormalize(p) p_Normalize(p,currRing)
 int       pSize( poly p );
@@ -385 +385 @@
 void      pCancelPolyByMonom (poly p1,poly p2,polyset * P,int * SizeOfSet);
 
-poly      pPermPoly (poly p, int * perm, ring OldRing, nMapFunc nMap,
+poly      pPermPoly (poly p, int * perm,const ring OldRing, nMapFunc nMap,
                      int *par_perm=NULL, int OldPar=0);
 
@@ -427 +427 @@
 /*-----------specials for spoly-computations--------------*/
 BOOLEAN pCompareChain (poly p,poly p1,poly p2,poly lcm);
+BOOLEAN pCompareChainPart (poly p,poly p1,poly p2,poly lcm);
 #define  pEqualPolys(p1,p2) p_EqualPolys(p1,p2,currRing)
 BOOLEAN pComparePolys(poly p1,poly p2);

kernel/polys1.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: polys1.cc,v 1.31 2008-02-06 09:12:47 wienand Exp $ */
+/* $Id: polys1.cc,v 1.32 2008-07-25 14:37:55 Singular Exp $ */
 
 /*
@@ -1240 +1240 @@
 *returns a re-ordered copy of a polynomial, with permutation of the variables
 */
-poly pPermPoly (poly p, int * perm, ring oldRing, nMapFunc nMap,
+poly pPermPoly (poly p, int * perm, const ring oldRing, nMapFunc nMap,
    int *par_perm, int OldPar)
 {