Changeset eb55f8a in git

Timestamp:

Sep 16, 2014, 4:56:19 PM (9 years ago)

Author:

Oleksandr Motsak <motsak@…>

Branches:

(u'spielwiese', 'f6c3dc58b0df4bd712574325fe76d0626174ad97')

Children:

5b45a4ff15d0998cc64c730af75c1c1f773d4a77

Parents:

4ec0f01d431893a4c0997d2bdfab87cb8d37e03e

git-author:

Oleksandr Motsak <motsak@mathematik.uni-kl.de>2014-09-16 16:56:19+02:00

git-committer:

Oleksandr Motsak <motsak@mathematik.uni-kl.de>2014-09-23 20:10:49+02:00

Message:

There should be no *Test in assume call (and no assume in *Test definition)

Files:

• Singular/dyn_modules/syzextra/mod_main.cc (modified) (2 diffs)
• Singular/dyn_modules/syzextra/myNF.cc (modified) (1 diff)
• Singular/dyn_modules/syzextra/syzextra.cc (modified) (5 diffs)
• Singular/maps_ip.cc (modified) (3 diffs)
• kernel/GBEngine/kspoly.cc (modified) (4 diffs)
• kernel/GBEngine/kstd1.cc (modified) (9 diffs)
• kernel/GBEngine/kstd2.cc (modified) (8 diffs)
• kernel/GBEngine/kstdfac.cc (modified) (9 diffs)
• kernel/GBEngine/kutil.cc (modified) (10 diffs)
• kernel/GBEngine/sca.cc (modified) (4 diffs)
• libpolys/coeffs/coeffs.h (modified) (1 diff)
• libpolys/coeffs/modulop.cc (modified) (22 diffs)
• libpolys/polys/ext_fields/algext.cc (modified) (3 diffs)
• libpolys/polys/ext_fields/transext.cc (modified) (16 diffs)
• libpolys/polys/kbuckets.cc (modified) (1 diff)
• libpolys/polys/monomials/p_polys.cc (modified) (3 diffs)
• libpolys/polys/monomials/p_polys.h (modified) (10 diffs)

Singular/dyn_modules/syzextra/mod_main.cc

@@ -1361 +1361 @@
     {
       assume( p != NULL );
-      assume( p_LmTest(p, r) );
+      p_LmTest(p, r);
 
       const unsigned long iComp = p_GetComp(p, r);
@@ -1394 +1394 @@
 
     assume( p != NULL );
-    assume( p_LmTest(p, r) );
+    p_LmTest(p, r);
 
     const int iExpSize = r->ExpL_Size;

Singular/dyn_modules/syzextra/myNF.cc

@@ -246 +246 @@
   //    pNorm(strat->S[i]);
   //}
-  assume(kTest(strat));
+  kTest(strat);
   if (TEST_OPT_PROT) { PrintS("r"); mflush(); }
 

Singular/dyn_modules/syzextra/syzextra.cc

@@ -87 +87 @@
   assume( b != NULL );
 
-  assume( p_LmTest(a, r) );
-  assume( p_LmTest(b, r) );
+  p_LmTest(a, r);
+  p_LmTest(b, r);
 
 
@@ -165 +165 @@
   assume( b != NULL );
 
-  assume( p_LmTest(a, r) );
-  assume( p_LmTest(b, r) );
+  p_LmTest(a, r);
+  p_LmTest(b, r);
   assume( p_GetComp(a, r) == 0 );
   assume( p_GetComp(b, r) == 0 );
@@ -336 +336 @@
   {
     assume( p != NULL );
-    assume( p_LmTest(p, r) );
+    p_LmTest(p, r);
 
     m = p_LmInit(p, r);
@@ -348 +348 @@
     assume( m != NULL );
     assume( pNext(m) == NULL );
-    assume( p_LmTest(m, r) );
+    p_LmTest(m, r);
 
     if( bSetZeroComp )
@@ -1210 +1210 @@
 
   sBucket_pt& tail   = m_sum_bucket; assume( tail != NULL );
-  kBucket_pt& bucket = m_spoly_bucket; assume( bucket != NULL ); kbTest(bucket);
+  kBucket_pt& bucket = m_spoly_bucket; assume( bucket != NULL ); 
+  kbTest(bucket);
 
 

Singular/maps_ip.cc

@@ -265 +265 @@
 
       number d = n_GetDenom(p_GetCoeff(p, currRing), currRing);
-      assume( p_Test((poly)NUM(d), R) );
+      p_Test((poly)NUM(d), R);
 
       if ( n_IsOne (d, currRing->cf) )
@@ -280 +280 @@
       memset(&tmpW,0,sizeof(sleftv));
       tmpW.rtyp = POLY_CMD;
-      assume( p_Test((poly)NUM(num), R) );
+      p_Test((poly)NUM(num), R);
 
       tmpW.data = NUM (num); // a copy of this poly will be used
@@ -318 +318 @@
       memset(&tmpW,0,sizeof(sleftv));
       tmpW.rtyp = POLY_CMD;
-      assume( p_Test((poly)num, R) );
+      p_Test((poly)num, R);
 
 

kernel/GBEngine/kspoly.cc

@@ -54 +54 @@
   int ret = 0;
   ring tailRing = PR->tailRing;
-  assume(kTest_L(PR));
-  assume(kTest_T(PW));
+  kTest_L(PR);
+  kTest_T(PW);
 
   poly p1 = PR->GetLmTailRing();   // p2 | p1
@@ -189 +189 @@
   int ret = 0;
   ring tailRing = PR->tailRing;
-  assume(kTest_L(PR));
-  assume(kTest_T(PW));
+  kTest_L(PR);
+  kTest_T(PW);
 
   // signature-based stuff:
@@ -381 +381 @@
   create_count++;
 #endif
-  assume(kTest_L(Pair));
+  kTest_L(Pair);
   poly p1 = Pair->p1;
   poly p2 = Pair->p2;
@@ -496 +496 @@
   poly Save =   PW->GetLmCurrRing();
 
-  assume(kTest_L(PR));
-  assume(kTest_T(PW));
+  kTest_L(PR);
+  kTest_T(PW);
   pAssume(pIsMonomOf(Lp, Current));
 

kernel/GBEngine/kstd1.cc

@@ -130 +130 @@
   int ret;
 #if KDEBUG > 0
-  assume(kTest_L(h));
-  assume(kTest_T(with));
+  kTest_L(h);
+  kTest_T(with);
 #endif
   // Hmmm ... why do we do this -- polys from T should already be normalized
@@ -1068 +1068 @@
 
   int i = 0;
-  assume(kTest_TS(strat));
+  kTest_TS(strat);
   while (i <= strat->Ll)
   {
@@ -1113 +1113 @@
     {
 #ifdef KDEBUG
-      assume(kTest_L(&(strat->L[i]), strat->tailRing, TRUE, i, strat->T, strat->tl));
+      kTest_L(&(strat->L[i]), strat->tailRing, TRUE, i, strat->T, strat->tl);
 #endif
       i++;
     }
   }
-  assume(kTest_TS(strat));
+  kTest_TS(strat);
 }
 
@@ -1152 +1152 @@
   if (strat->update)
   {
-    assume(kTest_TS(strat));
+    kTest_TS(strat);
     strat->update = (strat->tl == -1);
     if (TEST_OPT_WEIGHTM)
@@ -1209 +1209 @@
 #endif
   }
-  assume(kTest_TS(strat));
+  kTest_TS(strat);
 }
 
@@ -1531 +1531 @@
     reorderL(strat);
   }
-  assume(kTest_TS(strat));
+  kTest_TS(strat);
   strat->use_buckets = kMoraUseBucket(strat);
   /*- compute-------------------------------------------*/
@@ -1758 +1758 @@
       }
     }
-    assume(kTest_TS(strat));
+    kTest_TS(strat);
 
       #if ADIDEBUG
@@ -1899 +1899 @@
   p = pCopy(q);
   deleteHC(&p,&o,&j,strat);
-  assume(kTest(strat));
+  kTest(strat);
   if (TEST_OPT_PROT) { PrintS("r"); mflush(); }
   if (BVERBOSE(23)) kDebugPrint(strat);
@@ -2908 +2908 @@
 
   // strat->posInT = posInT_pLength;
-  assume(kTest_TS(strat));
+  kTest_TS(strat);
 
 #ifdef HAVE_TAIL_RING

kernel/GBEngine/kstd2.cc

@@ -834 +834 @@
   //if (TEST_OPT_PROT) { PrintS("N"); mflush(); }
   //L->Normalize(); // HANNES: should have a test
-  assume(kTest_L(L));
+  kTest_L(L);
   return L->GetLmCurrRing();
 }
@@ -1367 +1367 @@
 
   // strat->posInT = posInT_pLength;
-  assume(kTest_TS(strat));
+  kTest_TS(strat);
 
 #ifdef KDEBUG
@@ -1594 +1594 @@
     memset(&(strat->P), 0, sizeof(strat->P));
 #endif /* KDEBUG */
-    assume(kTest_TS(strat));
+    kTest_TS(strat);
   }
 #ifdef KDEBUG
@@ -1759 +1759 @@
 
   // strat->posInT = posInT_pLength;
-  assume(kTest_TS(strat));
+  kTest_TS(strat);
 
 #ifdef KDEBUG
@@ -2246 +2246 @@
     memset(&(strat->P), 0, sizeof(strat->P));
 #endif /* KDEBUG */
-    assume(kTest_TS(strat));
+    kTest_TS(strat);
   }
 #ifdef KDEBUG
@@ -2428 +2428 @@
   //    pNorm(strat->S[i]);
   //}
-  assume(kTest(strat));
+  kTest(strat);
   if (TEST_OPT_PROT) { PrintS("r"); mflush(); }
   if (BVERBOSE(23)) kDebugPrint(strat);
@@ -2899 +2899 @@
 
   // strat->posInT = posInT_pLength;
-  assume(kTest_TS(strat));
+  kTest_TS(strat);
 
 #ifdef HAVE_TAIL_RING
@@ -3137 +3137 @@
     memset(&(strat->P), 0, sizeof(strat->P));
 #endif
-    assume(kTest_TS(strat));
+    kTest_TS(strat);
   }
 #ifdef KDEBUG

kernel/GBEngine/kstdfac.cc

@@ -158 +158 @@
 {
   // int i;
-  assume(kTest_TS(o));
+  kTest_TS(o);
   kStrategy s=new skStrategy;
   s->next=NULL;
@@ -242 +242 @@
   s->no_prod_crit=o->no_prod_crit;
 #endif
-  assume(kTest_TS(s));
+  kTest_TS(s);
   return s;
 }
@@ -542 +542 @@
     if (TEST_OPT_REDSB) completeReduceFac(strat,FL);
   }
-  assume(kTest_TS(strat));
+  kTest_TS(strat);
   while (strat->Ll >= 0)
   {
@@ -583 +583 @@
     }
     /* reduction of the element choosen from L */
-    assume(kTest_TS(strat));
+    kTest_TS(strat);
     red_result = strat->red(&strat->P,strat);
     if (strat->P.p != NULL)
@@ -630 +630 @@
         {
           n=kStratCopy(strat); // includes memset(&n->P,0,sizeof(n->P));
-          assume(kTest_TS(n));
+          kTest_TS(n);
           n->next=strat->next;
           strat->next=n;
@@ -642 +642 @@
         n->P.p=fac->m[i];
         n->initEcart(&n->P);
-        assume(kTest_TS(n));
+        kTest_TS(n);
 
         /* enter P.p into s and L */
@@ -668 +668 @@
           }
         }
-        assume(kTest_TS(n));
+        kTest_TS(n);
 
         if (TEST_OPT_DEBUG)
@@ -695 +695 @@
           }
         }
-        assume(kTest_TS(n));
+        kTest_TS(n);
         /* construct D */
         if (IDELEMS(fac)>1)
@@ -851 +851 @@
     strat->P.lcm=NULL;
 #endif
-    assume(kTest_TS(strat));
+    kTest_TS(strat);
     if ((strat->Ll==-1) && (strat->sl>=0))
     {
       if (TEST_OPT_REDSB) completeReduceFac(strat,FL);
     }
-    assume(kTest_TS(strat));
+    kTest_TS(strat);
   }
   if (TEST_OPT_DEBUG) messageSets(strat);

kernel/GBEngine/kutil.cc

@@ -237 +237 @@
   if (strat->kHEdgeFound)
   {
-    assume(kTest_L(L));
+    kTest_L(L);
     poly p1;
     poly p = L->GetLmTailRing();
@@ -304 +304 @@
         kBucketDestroy(&bucket);
     }
-    assume(kTest_L(L));
+    kTest_L(L);
   }
 }
@@ -5509 +5509 @@
   //if (TEST_OPT_PROT) { PrintS("N"); mflush(); }
   //L->Normalize(); // HANNES: should have a test
-  assume(kTest_L(L));
+  kTest_L(L);
   return L->GetLmCurrRing();
 }
@@ -5615 +5615 @@
   //if (TEST_OPT_PROT) { PrintS("N"); mflush(); }
   //L->Normalize(); // HANNES: should have a test
-  assume(kTest_L(L));
+  kTest_L(L);
   return L->GetLmCurrRing();
 }
@@ -6868 +6868 @@
           }
           pLmDelete(&redSi);
-          assume(kTest(strat));
+          kTest(strat);
         }
         i++;
       }
 #ifdef KDEBUG
-      assume(kTest(strat));
+      kTest(strat);
 #endif
       if (any_change) reorderS(&suc,strat);
@@ -6914 +6914 @@
   }
 #ifdef KDEBUG
-  assume(kTest(strat));
+  kTest(strat);
 #endif
 }
@@ -7229 +7229 @@
   assume(p.sev == 0 || pGetShortExpVector(p.p) == p.sev);
   strat->sevT[atT] = (p.sev == 0 ? pGetShortExpVector(p.p) : p.sev);
-  assume(kTest_T(&(strat->T[atT])));
+  kTest_T(&(strat->T[atT]));
 }
 
@@ -8259 +8259 @@
   if (TEST_OPT_PROT)
     Print("[%lu:%d", (unsigned long) new_tailRing->bitmask, new_tailRing->ExpL_Size);
-  assume(kTest_TS(strat));
+  kTest_TS(strat);
   assume(new_tailRing != strat->tailRing);
   pShallowCopyDeleteProc p_shallow_copy_delete
@@ -8324 +8324 @@
                                                    new_tailRing);
   }
-  assume(kTest_TS(strat));
+  kTest_TS(strat);
   if (TEST_OPT_PROT)
     PrintS("]");
@@ -9794 +9794 @@
   }
   L->Normalize(); // HANNES: should have a test
-  assume(kTest_L(L));
+  kTest_L(L);
   return L->GetLmCurrRing();
 }

kernel/GBEngine/sca.cc

@@ -470 +470 @@
 
   // strat->posInT = posInT_pLength;
-  assume(kTest_TS(strat));
+  kTest_TS(strat);
 
 #undef HAVE_TAIL_RING
@@ -799 +799 @@
 #endif
 
-    assume(kTest_TS(strat)); // even of T is not used!
+    kTest_TS(strat); // even of T is not used!
 
 //     Print("\n$\n");
@@ -963 +963 @@
   strat->use_buckets = kMoraUseBucket(strat);
 
-  assume(kTest_TS(strat));
+  kTest_TS(strat);
 
 
@@ -1197 +1197 @@
     }
 #endif
-    assume(kTest_TS(strat));
+    kTest_TS(strat);
   }
   // - complete reduction of the standard basis------------------------ -

libpolys/coeffs/coeffs.h

@@ -708 +708 @@
 static inline BOOLEAN n_DBTest(number n, const char *filename, const int linenumber, const coeffs r)
 #else
-static inline BOOLEAN n_DBTest(number, const char*, const int, const coeffs)
+static inline BOOLEAN n_DBTest(number, const char*, const int, const coeffs) // is it really necessary to define this function in any case?
 #endif
 {
-  assume(r != NULL);
-#ifdef LDEBUG
-  assume(r->cfDBTest != NULL);
+#ifndef LDEBUG
+  return TRUE;
+#else
+  assume(r != NULL); assume(r->cfDBTest != NULL);
   return r->cfDBTest(n, filename, linenumber, r);
-#else
-  return TRUE;
 #endif
 }

libpolys/coeffs/modulop.cc

@@ -54 +54 @@
 BOOLEAN npGreaterZero (number k, const coeffs r)
 {
-  assume( n_Test(k, r) );
+  n_Test(k, r);
 
   int h = (int)((long) k);
@@ -70 +70 @@
 number npMult (number a,number b, const coeffs r)
 {
-  assume( n_Test(a, r) );
-  assume( n_Test(b, r) );
+  n_Test(a, r);
+  n_Test(b, r);
 
   if (((long)a == 0) || ((long)b == 0))
     return (number)0;
   number c = npMultM(a,b, r);
-  assume( n_Test(c, r) );
+  n_Test(c, r);
   return c;
 }
@@ -89 +89 @@
 
   number c = (number)ii;
-  assume( n_Test(c, r) );
+  n_Test(c, r);
   return c;
 
@@ -100 +100 @@
 int npInt(number &n, const coeffs r)
 {
-  assume( n_Test(n, r) );
+  n_Test(n, r);
 
   if ((long)n > (((long)r->ch) >>1)) return (int)((long)n -((long)r->ch));
@@ -108 +108 @@
 number npAdd (number a, number b, const coeffs r)
 {
-  assume( n_Test(a, r) );
-  assume( n_Test(b, r) );
+  n_Test(a, r);
+  n_Test(b, r);
 
   number c = npAddM(a,b, r);
 
-  assume( n_Test(c, r) );
+  n_Test(c, r);
 
   return c;
@@ -120 +120 @@
 number npSub (number a, number b, const coeffs r)
 {
-  assume( n_Test(a, r) );
-  assume( n_Test(b, r) );
+  n_Test(a, r);
+  n_Test(b, r);
 
   number c = npSubM(a,b,r);
 
-  assume( n_Test(c, r) );
+  n_Test(c, r);
 
   return c;
@@ -132 +132 @@
 BOOLEAN npIsZero (number  a, const coeffs r)
 {
-  assume( n_Test(a, r) );
+  n_Test(a, r);
 
   return 0 == (long)a;
@@ -139 +139 @@
 BOOLEAN npIsOne (number a, const coeffs r)
 {
-  assume( n_Test(a, r) );
+  n_Test(a, r);
 
   return 1 == (long)a;
@@ -146 +146 @@
 BOOLEAN npIsMOne (number a, const coeffs r)
 {
-  assume( n_Test(a, r) );
+  n_Test(a, r);
 
   return ((r->npPminus1M == (long)a)&&((long)1!=(long)a));
@@ -201 +201 @@
 inline number npInversM (number c, const coeffs r)
 {
-  assume( n_Test(c, r) );
+  n_Test(c, r);
 #ifndef HAVE_DIV_MOD
   number d = (number)(long)r->npExpTable[r->npPminus1M - r->npLogTable[(long)c]];
@@ -213 +213 @@
   number d = (number)inv;
 #endif
-  assume( n_Test(d, r) );
+  n_Test(d, r);
   return d;
 
@@ -220 +220 @@
 number npDiv (number a,number b, const coeffs r)
 {
-  assume( n_Test(a, r) );
-  assume( n_Test(b, r) );
+  n_Test(a, r);
+  n_Test(b, r);
 
 //#ifdef NV_OPS
@@ -247 +247 @@
 #endif
 
-  assume( n_Test(d, r) );
+  n_Test(d, r);
   return d;
 
@@ -253 +253 @@
 number  npInvers (number c, const coeffs r)
 {
-  assume( n_Test(c, r) );
+  n_Test(c, r);
 
   if ((long)c==0)
@@ -262 +262 @@
   number d = npInversM(c,r);
 
-  assume( n_Test(d, r) );
+  n_Test(d, r);
   return d;
 
@@ -269 +269 @@
 number npNeg (number c, const coeffs r)
 {
-  assume( n_Test(c, r) );
+  n_Test(c, r);
 
   if ((long)c==0) return c;
@@ -275 +275 @@
 #if 0
   number d = npNegM(c,r);
-  assume( n_Test(d, r) );
+  n_Test(d, r);
   return d;
 #else
   c = npNegM(c,r);
-  assume( n_Test(c, r) );
+  n_Test(c, r);
   return c;
 #endif
@@ -286 +286 @@
 BOOLEAN npGreater (number a,number b, const coeffs r)
 {
-  assume( n_Test(a, r) );
-  assume( n_Test(b, r) );
+  n_Test(a, r);
+  n_Test(b, r);
 
   //return (long)a != (long)b;
@@ -295 +295 @@
 BOOLEAN npEqual (number a,number b, const coeffs r)
 {
-  assume( n_Test(a, r) );
-  assume( n_Test(b, r) );
+  n_Test(a, r);
+  n_Test(b, r);
 
 //  return (long)a == (long)b;
@@ -305 +305 @@
 void npWrite (number &a, const coeffs r)
 {
-  assume( n_Test(a, r) );
+  n_Test(a, r);
 
   if ((long)a>(((long)r->ch) >>1)) StringAppend("-%d",(int)(((long)r->ch)-((long)a)));
@@ -314 +314 @@
 void npPower (number a, int i, number * result, const coeffs r)
 {
-  assume( n_Test(a, r) );
+  n_Test(a, r);
 
   if (i==0)
@@ -379 +379 @@
     }
   }
-  assume( n_Test(*a, r) );
+  n_Test(*a, r);
   return s;
 }

libpolys/polys/ext_fields/algext.cc

@@ -936 +936 @@
   }
   definiteReduce(p, dst->extRing->qideal->m[0], dst);
-  assume (p_Test (p, dst->extRing));
+  p_Test (p, dst->extRing);
   if (!DENIS1(fa))
   {
     definiteReduce(q, dst->extRing->qideal->m[0], dst);
-    assume (p_Test (q, dst->extRing));
+    p_Test (q, dst->extRing);
     if (q != NULL)
     {
@@ -999 +999 @@
   poly g = prMapR(f, nMap, rSrc, rDst);
 
-  assume(n_Test((number)g, dst));
+  n_Test((number)g, dst);
   return (number)g;
 }
@@ -1029 +1029 @@
     result=(number)g;
 
-  assume(n_Test((number)result, dst));
+  n_Test((number)result, dst);
   return (number)result;
 }

libpolys/polys/ext_fields/transext.cc

@@ -80 +80 @@
 
 #ifdef LDEBUG
-#define ntTest(a) assume(ntDBTest(a,__FILE__,__LINE__,cf))
+#define ntTest(a) ntDBTest(a,__FILE__,__LINE__,cf)
 BOOLEAN  ntDBTest(number a, const char *f, const int l, const coeffs r);
 #else
@@ -193 +193 @@
   const poly num = NUM(t);
   assume(num != NULL);   /**< t != 0 ==> numerator(t) != 0 */
-  assume( _p_Test(num, ntRing,1) );
+  
+  p_Test(num, ntRing); 
 
   const poly den = DEN(t);
@@ -199 +200 @@
   if (den != NULL) // !DENIS1(f)
   {
-    assume( _p_Test(den, ntRing,1) );
+    p_Test(den, ntRing);
 
     if(p_IsConstant(den, ntRing) && (n_IsOne(pGetCoeff(den), ntCoeffs)))
@@ -1760 +1761 @@
 {
   if (n_IsZero(a, src)) return NULL;
-  assume(n_Test(a, src));
+  n_Test(a, src);
   assume(src->rep == dst->extRing->cf->rep);
   if ((SR_HDL(a) & SR_INT) || (a->s==3))
@@ -1782 +1783 @@
 {
   if (n_IsZero(a, src)) return NULL;
-  assume(n_Test(a, src));
+  n_Test(a, src);
   nMapFunc nMap=n_SetMap(src,dst->extRing->cf);
   poly p=p_NSet(nMap(a, src,dst->extRing->cf), dst->extRing);
@@ -1796 +1797 @@
 {
   if (n_IsZero(a, src)) return NULL;
-  assume(n_Test(a, src));
+  n_Test(a, src);
   /* mapping via intermediate int: */
   int n = n_Int(a, src);
@@ -1834 +1835 @@
   COM(result) = COM(f);
   //check_N((number)result,dst);
-  assume(n_Test((number)result, dst));
+  n_Test((number)result, dst);
   return (number)result;
 }
@@ -1861 +1862 @@
   COM(result) = COM(f);
   //check_N((number)result,dst);
-  assume(n_Test((number)result, dst));
+  n_Test((number)result, dst);
   return (number)result;
 }
@@ -1867 +1868 @@
 number ntCopyAlg(number a, const coeffs cf, const coeffs dst)
 {
-  assume( n_Test(a, cf) );
+  n_Test(a, cf) ;
   if (n_IsZero(a, cf)) return NULL;
   return ntInit(prCopyR((poly)a, cf->extRing, dst->extRing),dst);
@@ -1874 +1875 @@
 number ntGenAlg(number a, const coeffs cf, const coeffs dst)
 {
-  assume( n_Test(a, cf) );
+  n_Test(a, cf) ;
   if (n_IsZero(a, cf)) return NULL;
 
@@ -1884 +1885 @@
 number ntMap0P(number a, const coeffs src, const coeffs dst)
 {
-  assume( n_Test(a, src) );
+  n_Test(a, src) ;
   if (n_IsZero(a, src)) return NULL;
   // int p = rChar(dst->extRing);
@@ -1899 +1900 @@
   fraction f = (fraction)omAlloc0Bin(fractionObjectBin);
   NUM(f) = g; // DEN(f) = NULL; COM(f) = 0;
-  assume(n_Test((number)f, dst));
+  n_Test((number)f, dst);
   //check_N((number)f,dst);
   return (number)f;
@@ -1907 +1908 @@
 number ntMapPP(number a, const coeffs src, const coeffs dst)
 {
-  assume( n_Test(a, src) );
+  n_Test(a, src) ;
   if (n_IsZero(a, src)) return NULL;
   assume(src == dst->extRing->cf);
@@ -1914 +1915 @@
   fraction f = (fraction)omAlloc0Bin(fractionObjectBin);
   NUM(f) = p; // DEN(f) = NULL; COM(f) = 0;
-  assume(n_Test((number)f, dst));
+  n_Test((number)f, dst);
   //check_N((number)f,dst);
   return (number)f;
@@ -1922 +1923 @@
 number ntMapUP(number a, const coeffs src, const coeffs dst)
 {
-  assume( n_Test(a, src) );
+  n_Test(a, src) ;
   if (n_IsZero(a, src)) return NULL;
   /* mapping via intermediate int: */
@@ -1937 +1938 @@
   fraction f = (fraction)omAlloc0Bin(fractionObjectBin);
   NUM(f) = p; // DEN(f) = NULL; COM(f) = 0;
-  assume(n_Test((number)f, dst));
+  n_Test((number)f, dst);
   //check_N((number)f,dst);
   return (number)f;

libpolys/polys/kbuckets.cc

@@ -92 +92 @@
   {
     assume(bucket->buckets[i]!=NULL);
-    _p_Test(bucket->coef[i],bucket->bucket_ring,PDEBUG);
-    }
+    p_Test(bucket->coef[i],bucket->bucket_ring);
+  }
   #endif
   pFalseReturn(p_Test(bucket->buckets[i], bucket->bucket_ring));

libpolys/polys/monomials/p_polys.cc

@@ -694 +694 @@
 long p_DegW(poly p, const short *w, const ring R)
 {
-  assume( p_Test(p, R) );
+  p_Test(p, R);
   assume( w != NULL );
   long r=-LONG_MAX;
@@ -3882 +3882 @@
     qq = p_PermPoly(zz, par_perm-1, srcExtRing, dst, nMap, NULL, rVar (srcExtRing)-1);
 
-  assume (p_Test (qq, dst));
+  p_Test (qq, dst);
 
 //       poly p_PermPoly (poly p, int * perm, const ring oldRing, const ring dst, nMapFunc nMap, int *par_perm, int OldPar)
@@ -3922 +3922 @@
       number n = nMap(p_GetCoeff(p, oldRing), oldRing->cf, dst->cf);
 
-      assume (n_Test (n,dst->cf));
+      n_Test (n,dst->cf);
 
       if ( nCoeff_is_algExt(dst->cf) )

libpolys/polys/monomials/p_polys.h

@@ -245 +245 @@
   if (p != NULL)
   {
-#ifdef PDEBUG
     p_Test(p, r);
-#endif
     if (rOrd_SetCompRequiresSetm(r))
     {
@@ -806 +804 @@
 static inline poly p_Copy(poly p, const ring r)
 {
-#ifdef PDEBUG
-  poly pp= r->p_Procs->p_Copy(p, r);
+  const poly pp = r->p_Procs->p_Copy(p, r);
   p_Test(pp,r);
   return pp;
-#else
-  return r->p_Procs->p_Copy(p, r);
-#endif
 }
 
@@ -831 +825 @@
 static inline poly p_Copy(poly p, const ring lmRing, const ring tailRing)
 {
+  if (p != NULL)
+  {
 #ifndef PDEBUG
-  if (tailRing == lmRing)
-    return tailRing->p_Procs->p_Copy(p, tailRing);
-#endif
-  if (p != NULL)
-  {
+    if (tailRing == lmRing)
+      return tailRing->p_Procs->p_Copy(p, tailRing);
+#endif
     poly pres = p_Head(p, lmRing);
     pNext(pres) = tailRing->p_Procs->p_Copy(pNext(p), tailRing);
@@ -848 +842 @@
 static inline void p_Delete(poly *p, const ring r)
 {
+  assume( p!= NULL ); 
   r->p_Procs->p_Delete(p, r);
 }
@@ -853 +848 @@
 static inline void p_Delete(poly *p,  const ring lmRing, const ring tailRing)
 {
+  assume( p!= NULL ); 
+  if (*p != NULL)
+  {
 #ifndef PDEBUG
-  if (tailRing == lmRing)
-  {
-    tailRing->p_Procs->p_Delete(p, tailRing);
-    return;
-  }
-#endif
-  if (*p != NULL)
-  {
+    if (tailRing == lmRing)
+    {
+      p_Delete(p, tailRing);
+      return;
+    }
+#endif
     if (pNext(*p) != NULL)
-      tailRing->p_Procs->p_Delete(&pNext(*p), tailRing);
+      p_Delete(&pNext(*p), tailRing);
     p_LmDelete(p, lmRing);
   }
@@ -911 +907 @@
 #ifndef PDEBUG
   if (lmRing == tailRing)
-  {
     return p_Mult_nn(p, n, tailRing);
-  }
 #endif
   poly pnext = pNext(p);
@@ -1774 +1768 @@
 {
   if (p == NULL) return TRUE;
+  p_Test(p, r);
   return (pNext(p)==NULL) && p_LmIsConstantComp(p, r);
 }
@@ -1779 +1774 @@
 static inline BOOLEAN p_IsConstant(const poly p, const ring r)
 {
-  assume( p_Test(p, r) );
   if (p == NULL) return TRUE;
+  p_Test(p, r);
   return (pNext(p)==NULL) && p_LmIsConstant(p, r);
 }
@@ -1787 +1782 @@
 static inline BOOLEAN p_IsOne(const poly p, const ring R)
 {
-  assume( p_Test(p, R) );
+  p_Test(p, R);
   return (p_IsConstant(p, R) && n_IsOne(p_GetCoeff(p, R), R->cf));
 }
@@ -1793 +1788 @@
 static inline BOOLEAN p_IsConstantPoly(const poly p, const ring r)
 {
+  p_Test(p, r);
   poly pp=p;
   while(pp!=NULL)