Changeset 7e29aa in git

Timestamp:

Feb 23, 2018, 5:33:43 PM (6 years ago)

Author:

Hans Schoenemann <hannes@…>

Branches:

(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')

Children:

0277c5dd6af4f887925e06b299068d0c17f5d324f604741c372d3b9a9e1e1d8f7ab9e71e18f5ae74

Parents:

6198629402663b11697d755d8512ff5ca032226c6cfe0d505bc5446671956e0849011c8be946d571

git-author:

Hans Schoenemann <hannes@mathematik.uni-kl.de>2018-02-23 17:33:43+01:00

git-committer:

GitHub <noreply@github.com>2018-02-23 17:33:43+01:00

Message:

Merge pull request #856 from kabouzeid/fix-ivMaxIdeal

Add missing return statement in ivMaxIdeal() proc from fpadim.lib

Files:

• Singular/LIB/fpadim.lib (modified) (3 diffs)
• Singular/links/asciiLink.cc (modified) (1 diff)
• Singular/misc_ip.cc (modified) (1 diff)
• Singular/tesths.cc (modified) (2 diffs)
• doc/reference.doc (modified) (previous)
• factory/cf_factory.h (modified) (1 diff)
• kernel/GBEngine/janet.cc (modified) (1 diff)
• kernel/GBEngine/kInline.h (modified) (1 diff)
• kernel/GBEngine/kstdfac.cc (modified) (1 diff)
• kernel/GBEngine/tgb.cc (modified) (33 diffs)
• kernel/GBEngine/tgb_internal.h (modified) (3 diffs)
• kernel/combinatorics/hilb.cc (modified) (3 diffs)
• kernel/ideals.cc (modified) (1 diff)
• libpolys/polys/kbuckets.cc (modified) (12 diffs)
• libpolys/polys/monomials/p_polys.cc (modified) (2 diffs)
• libpolys/polys/monomials/p_polys.h (modified) (10 diffs)
• libpolys/polys/pDebug.cc (modified) (1 diff)
• libpolys/polys/sbuckets.cc (modified) (1 diff)

Singular/LIB/fpadim.lib

@@ -2385 +2385 @@
   ivMaxIdeal(2,0);
   ivMaxIdeal(2,1);
-  ivMaxIdeal(4,0);
-  ivMaxIdeal(4,1);
 }
 
@@ -2399 +2397 @@
   "
 {
-  ivL2lpI(ivMaxIdeal(d, donly));
+  return(ivL2lpI(ivMaxIdeal(d, donly)));
 }
 example {
@@ -2408 +2406 @@
   lpMaxIdeal(2,0);
   lpMaxIdeal(2,1);
-  lpMaxIdeal(4,0);
-  lpMaxIdeal(4,1);
 }
 

Singular/links/asciiLink.cc

@@ -426 +426 @@
   {
     #define MAX_LIBS 256
-    (*list_of_libs)=(char**)omalloc0(MAX_LIBS*sizeof(char**));
+    (*list_of_libs)=(char**)omAlloc0(MAX_LIBS*sizeof(char**));
     (*list_of_libs)[0]=name;
     (*list_of_libs)[MAX_LIBS-1]=(char*)1;

Singular/misc_ip.cc

@@ -74 +74 @@
 
 #ifdef HAVE_NTL
-#include<NTL/version.h>
-#include<NTL/tools.h>
+#include <NTL/version.h>
+#include <NTL/tools.h>
 #ifdef NTL_CLIENT
 NTL_CLIENT

Singular/tesths.cc

@@ -36 +36 @@
 
 #include <unistd.h>
+#ifdef HAVE_NTL
+#include <NTL/config.h>
+#endif
 
 
@@ -67 +70 @@
   siInit(argv[0]);
   init_signals();
+  #ifdef HAVE_NTL
+  #if NTL_MAJOR_VERSION>=10
+  #ifdef NTL_THREAD_BOOST
+  SetNumThreads(feOptValue(FE_OPT_CPUS));
+  #endif
+  #endif
+  #endif
 
   // parse command line options

factory/cf_factory.h

@@ -16 +16 @@
 
 #include "factory/cf_gmp.h"
-#include "factory/cf_assert.h"
+#include "cf_assert.h"
 
 class InternalCF;

kernel/GBEngine/janet.cc

@@ -237 +237 @@
     {
       pLmFree(&f->history);
-      f->history=p_Copy_noCheck(p->history,currRing); /* cf of p->history is NULL */
+      if (p->history!=NULL)
+        f->history=p_Copy_noCheck(p->history,currRing); /* cf of p->history is NULL */
     }
   }

kernel/GBEngine/kInline.h

@@ -207 +207 @@
     if (p != NULL) /* and t_p!=NULL*/
     {
-      p = p_Head(p, currRing);
-      n_Delete(&pGetCoeff(p),currRing->cf);
+      p = p_LmInit(p, currRing);
       pGetCoeff(p)=pGetCoeff(t_p);
       pNext(p) = pNext(t_p);

kernel/GBEngine/kstdfac.cc

@@ -79 +79 @@
     else
     {
-      l[j].p=p_LmHead(o->L[j].p,currRing);
+      l[j].p=p_LmInit(o->L[j].p,currRing);
       if (pGetCoeff(o->L[j].p)!=NULL) pSetCoeff0(l[j].p,nCopy(pGetCoeff(o->L[j].p)));
       pNext(l[j].p)=n->tail;

kernel/GBEngine/tgb.cc

@@ -793 +793 @@
     p[a[i] + i] = q[i];
   }
-  omfree (a);
+  omFree (a);
   return p;
 }
@@ -900 +900 @@
     }
   }
-  omfree (i_con);
+  omFree (i_con);
 
   return FALSE;
@@ -1157 +1157 @@
             connected[connected_length] = -1;
           }
-          omfree (cans);
+          omFree (cans);
           return connected;
         }
@@ -1198 +1198 @@
     connected[connected_length] = -1;
   }
-  omfree (cans);
+  omFree (cans);
   return connected;
 }
@@ -1285 +1285 @@
 
   //can also try dependend search
-  omfree (i_con);
-  omfree (j_con);
+  omFree (i_con);
+  omFree (j_con);
   return;
 }
@@ -1754 +1754 @@
 
   assume (spc_final <= spc);
-  omfree (nodes);
+  omFree (nodes);
   nodes = NULL;
 
@@ -1826 +1826 @@
     c->pair_top += spc_final;
     clean_top_of_pair_list (c);
-    omfree (nodes_final);
+    omFree (nodes_final);
     return NULL;
   }
@@ -2174 +2174 @@
   c->pair_top += sum;
   clean_top_of_pair_list (c);
-  omfree (big_sbuf);
-  omfree (sbuf);
-  omfree (ibuf);
+  omFree (big_sbuf);
+  omFree (sbuf);
+  omFree (ibuf);
   //omfree(buf);
 #ifdef TGB_DEBUG
@@ -2664 +2664 @@
   int rank = reduced_c;
   linalg_step_modp (reduced, p, rank, terms, nterms, c);
-  omfree (terms);
+  omFree (terms);
 
   pn = rank;
-  omfree (reduced);
+  omFree (reduced);
 
   if(TEST_OPT_PROT)
@@ -2700 +2700 @@
     max_pairs = bundle_size_noro;
 #endif
-  poly *p = (poly *) omalloc ((max_pairs + 1) * sizeof (poly)); //nullterminated
+  poly *p = (poly *) omAlloc ((max_pairs + 1) * sizeof (poly)); //nullterminated
 
   int curr_deg = -1;
@@ -2775 +2775 @@
   if(i == 0)
   {
-    omfree (p);
+    omFree (p);
     return;
   }
@@ -2793 +2793 @@
     if(pn == 0)
     {
-      omfree (p);
+      omFree (p);
       return;
     }
@@ -2819 +2819 @@
     //}
     mass_add (p, pn, c);
-    omfree (p);
+    omFree (p);
     return;
     /*if (TEST_OPT_PROT)
@@ -2828 +2828 @@
   }
 #endif
-  red_object *buf = (red_object *) omalloc (i * sizeof (red_object));
+  red_object *buf = (red_object *) omAlloc (i * sizeof (red_object)); /*i>0*/
   for(j = 0; j < i; j++)
   {
@@ -2841 +2841 @@
     assume (buf[j].initial_quality >= 0);
   }
-  omfree (p);
+  omFree (p);
   qsort (buf, i, sizeof (red_object), red_object_better_gen);
 //    Print("\ncurr_deg:%i\n",curr_deg);
@@ -2919 +2919 @@
   }
   mass_add (add_those, i, c);
-  omfree (add_those);
-  omfree (buf);
+  omFree (add_those);
+  omFree (buf);
 
   if(TEST_OPT_PROT)
@@ -3107 +3107 @@
     return;
   sorted_pair_node **si_array =
-    (sorted_pair_node **) omalloc (s * sizeof (sorted_pair_node *));
+    (sorted_pair_node **) omAlloc (s * sizeof (sorted_pair_node *));
 
   for(int i = 0; i < s; i++)
   {
     sorted_pair_node *si =
-      (sorted_pair_node *) omalloc (sizeof (sorted_pair_node));
+      (sorted_pair_node *) omAlloc (sizeof (sorted_pair_node));
     si->i = -1;
     si->j = -2;
@@ -3135 +3135 @@
   apairs = spn_merge (apairs, pair_top + 1, si_array, s, this);
   pair_top += s;
-  omfree (si_array);
+  omFree (si_array);
 }
 
@@ -3203 +3203 @@
 
   apairs =
-    (sorted_pair_node **) omalloc (sizeof (sorted_pair_node *) * max_pairs);
+    (sorted_pair_node **) omAlloc (sizeof (sorted_pair_node *) * max_pairs);
   pair_top = -1;
 
@@ -3212 +3212 @@
   i = 0;
   this->n = 0;
-  T_deg = (int *) omalloc (n * sizeof (int));
+  T_deg = (int *) omAlloc (n * sizeof (int));
   if(eliminationProblem)
-    T_deg_full = (int *) omalloc (n * sizeof (int));
+    T_deg_full = (int *) omAlloc (n * sizeof (int));
   else
     T_deg_full = NULL;
-  tmp_pair_lm = (poly *) omalloc (n * sizeof (poly));
-  tmp_spn = (sorted_pair_node **) omalloc (n * sizeof (sorted_pair_node *));
+  tmp_pair_lm = (poly *) omAlloc (n * sizeof (poly));
+  tmp_spn = (sorted_pair_node **) omAlloc (n * sizeof (sorted_pair_node *));
   lm_bin = omGetSpecBin (POLYSIZE + (r->ExpL_Size) * sizeof (long));
 #ifdef HEAD_BIN
@@ -3227 +3227 @@
 #ifdef USE_STDVECBOOL
 #else
-  h = omalloc (n * sizeof (char *));
+  h = omAlloc (n * sizeof (char *));
 
   states = (char **) h;
 #endif
 #endif
-  h = omalloc (n * sizeof (int));
+  h = omAlloc (n * sizeof (int));
   lengths = (int *) h;
   weighted_lengths = (wlen_type *) omAllocAligned (n * sizeof (wlen_type));
   gcd_of_terms = (poly *) omAlloc (n * sizeof (poly));
 
-  short_Exps = (long *) omalloc (n * sizeof (long));
+  short_Exps = (long *) omAlloc (n * sizeof (long));
   if(F4_mode)
     S = idInit (n, I->rank);
@@ -3331 +3331 @@
   if(!(completed))
   {
-    poly *add = (poly *) omalloc ((pair_top + 2) * sizeof (poly));
+    poly *add = (poly *) omAlloc ((pair_top + 2) * sizeof (poly));
     int piter;
     int pos = 0;
@@ -3374 +3374 @@
     poly_list_node *old = c->to_destroy;
     c->to_destroy = c->to_destroy->next;
-    omfree (old);
+    omFree (old);
   }
   while(c->F)
@@ -3382 +3382 @@
       pDelete (&(c->F->mp[i].m));
     }
-    omfree (c->F->mp);
+    omFree (c->F->mp);
     c->F->mp = NULL;
     mp_array_list *old = c->F;
     c->F = c->F->next;
-    omfree (old);
+    omFree (old);
   }
   while(c->F_minus)
@@ -3394 +3394 @@
       pDelete (&(c->F_minus->p[i]));
     }
-    omfree (c->F_minus->p);
+    omFree (c->F_minus->p);
     c->F_minus->p = NULL;
     poly_array_list *old = c->F_minus;
     c->F_minus = c->F_minus->next;
-    omfree (old);
+    omFree (old);
   }
 #ifndef HAVE_BOOST
@@ -3404 +3404 @@
   for(int z = 1 /* zero length at 0 */ ; z < c->n; z++)
   {
-    omfree (c->states[z]);
-  }
-  omfree (c->states);
-#endif
-#endif
-
-  omfree (c->lengths);
-  omfree (c->weighted_lengths);
+    omFree (c->states[z]);
+  }
+  omFree (c->states);
+#endif
+#endif
+
+  omFree (c->lengths);
+  omFree (c->weighted_lengths);
   for(int z = 0; z < c->n; z++)
   {
     pDelete (&c->tmp_pair_lm[z]);
-    omfree (c->tmp_spn[z]);
-  }
-  omfree (c->tmp_pair_lm);
-  omfree (c->tmp_spn);
-
-  omfree (c->T_deg);
-  if(c->T_deg_full)
-    omfree (c->T_deg_full);
+    omFree (c->tmp_spn[z]);
+  }
+  omFree (c->tmp_pair_lm);
+  omFree (c->tmp_spn);
+
+  omFree (c->T_deg);
+  omfree (c->T_deg_full); /*c->T_deg_full my be NULL*/
 
   omFree (c->strat->ecartS);
@@ -3440 +3439 @@
       pDelete (&(c->gcd_of_terms[i]));
   }
-  omfree (c->gcd_of_terms);
-
-  omfree (c->apairs);
+  omFree (c->gcd_of_terms);
+
+  omFree (c->apairs);
   if(TEST_OPT_PROT)
   {
@@ -3508 +3507 @@
     }
   }
-  omfree (c->short_Exps);
+  omFree (c->short_Exps);
 
   ideal I = c->S;
@@ -3917 +3916 @@
 }
 
-void free_sorted_pair_node (sorted_pair_node * s, ring r)
+void free_sorted_pair_node (sorted_pair_node * s, const ring r)
 {
   if(s->i >= 0)
     p_Delete (&s->lcm_of_lm, r);
-  omfree (s);
+  omFree (s);
 }
 
@@ -4628 +4627 @@
     }
   }
-  omfree (los_region);
-  omfree (new_indices);
+  omFree (los_region);
+  omFree (new_indices);
 }
 
@@ -4635 +4634 @@
 static void multi_reduction (red_object * los, int &losl, slimgb_alg * c)
 {
-  poly *delay = (poly *) omalloc (losl * sizeof (poly));
+  poly *delay = (poly *) omAlloc (losl * sizeof (poly));
   int delay_s = 0;
   //initialize;
@@ -4665 +4664 @@
     {
       int pn_noro = curr_pos + 1;
-      poly *p_noro = (poly *) omalloc (pn_noro * sizeof (poly));
+      poly *p_noro = (poly *) omAlloc (pn_noro * sizeof (poly));
       for(i = 0; i < pn_noro; i++)
       {
@@ -4811 +4810 @@
      c->apairs=spn_merge(c->apairs,c->pair_top+1,pairs,delay_s,c);
      c->pair_top+=delay_s; */
-  omfree (delay);
+  omFree (delay);
   //omfree(pairs);
   return;

kernel/GBEngine/tgb_internal.h

@@ -14 +14 @@
 //#define TGB_DEBUG
 #define FULLREDUCTIONS
-#define HANS_IDEA
 //#define HALFREDUCTIONS
 //#define HEAD_BIN
@@ -328 +327 @@
   };
 template <class len_type, class set_type>  int pos_helper(kStrategy strat, poly p, len_type len, set_type setL, polyset set);
-void free_sorted_pair_node(sorted_pair_node* s, ring r);
+void free_sorted_pair_node(sorted_pair_node* s, const ring r);
 ideal do_t_rep_gb(ring r,ideal arg_I, int syz_comp, BOOLEAN F4_mode,int deg_pos);
 void now_t_rep(const int & arg_i, const int & arg_j, slimgb_alg* c);
@@ -1423 +1422 @@
   bool dense=true;
   if (max_density<0.3) dense=false;
-  if (dense){
+  if (dense)
+  {
     SparseRow<number_type>* res=noro_red_to_non_poly_dense(mon,len,cache);
     omfree(mon);
     return res;
-  } else   {
-      SparseRow<number_type>* res=noro_red_to_non_poly_sparse(mon,len,cache);
-      omfree(mon);
-      return res;
-    }
+  }
+  else
+  {
+    SparseRow<number_type>* res=noro_red_to_non_poly_sparse(mon,len,cache);
+    omfree(mon);
+    return res;
+  }
   //in the loop before nIrreducibleMonomials increases, so position here is important
 

kernel/combinatorics/hilb.cc

@@ -2150 +2150 @@
   if(!mgrad)
   {
-    tt=(char**)omalloc(sizeof(char*));
+    tt=(char**)omAlloc(sizeof(char*));
     tt[0] = omStrDup("t");
     npar = 1;
@@ -2159 +2159 @@
     for(is = 0; is < lV; is++)
     {
-      tt[is] = (char*)omalloc(7*sizeof(char)); //if required enlarge it later
+      tt[is] = (char*)omAlloc(7*sizeof(char)); //if required enlarge it later
       sprintf (tt[is], "t%d", is+1);
     }
@@ -2167 +2167 @@
   p.r = rDefault(0, npar, tt);
   coeffs cf = nInitChar(n_transExt, &p);
-  char** xx = (char**)omalloc(sizeof(char*));
+  char** xx = (char**)omAlloc(sizeof(char*));
   xx[0] = omStrDup("x");
   ring R = rDefault(cf, 1, xx);

kernel/ideals.cc

@@ -1427 +1427 @@
       if (h4->m[i-1]!=NULL)
       {
-        p = p_Copy_noCheck(h4->m[i-1], currRing);
+        p = p_Copy_noCheck(h4->m[i-1], currRing); /*h4->m[i-1]!=NULL*/
         p_Shift(&p,1,currRing);
         h4->m[i] = p;

libpolys/polys/kbuckets.cc

@@ -5 +5 @@
 #include "omalloc/omalloc.h"
 #include "misc/auxiliary.h"
+#include "misc/options.h"
 
 #include "polys/monomials/p_polys.h"
 #include "coeffs/coeffs.h"
+#include "coeffs/numbers.h"
 #include "polys/monomials/ring.h"
 #include "polys/kbuckets.h"
@@ -102 +104 @@
   #endif
   pFalseReturn(p_Test(bucket->buckets[i], bucket->bucket_ring));
-  if (bucket->buckets_length[i] != pLength(bucket->buckets[i]))
+  if ((unsigned)bucket->buckets_length[i] != pLength(bucket->buckets[i]))
   {
     dReportError("Bucket %d lengths difference should:%d has:%d",
@@ -223 +225 @@
   for (i=0; i<= bucket->buckets_used; i++)
   {
-
-    if (bucket->buckets[i] != NULL)
-    {
-      p_Delete(&(bucket->buckets[i]), bucket->bucket_ring);
+    p_Delete(&(bucket->buckets[i]), bucket->bucket_ring);
 #ifdef USE_COEF_BUCKETS
-      if (bucket->coef[i]!=NULL)
-        p_Delete(&(bucket->coef[i]), bucket->bucket_ring);
-#endif
-    }
+    p_Delete(&(bucket->coef[i]), bucket->bucket_ring);
+#endif
   }
   omFreeBin(bucket, kBucket_bin);
@@ -337 +334 @@
   //assume(false);
   assume(bucket != NULL);
-  assume(length <= 0 || length == pLength(lm));
+  assume(length <= 0 || (unsigned)length == pLength(lm));
   assume(kBucketIsCleared(bucket));
 
@@ -437 +434 @@
     assume(bucket->coef[i]==NULL);
   #endif
-  assume(pLength(p) == (int) pl);
+  assume(pLength(p) == (unsigned)pl);
   //if (TEST_OPT_PROT) { Print("C(%d)",pl); }
   kbTest(bucket);
@@ -737 +734 @@
     if ((i <= bucket->buckets_used) && (bucket->buckets[i] != NULL))
     {
-      assume(pLength(bucket->buckets[i])==bucket->buckets_length[i]);
+      assume(pLength(bucket->buckets[i])==(unsigned)bucket->buckets_length[i]);
 //#ifdef USE_COEF_BUCKETS
 //     if(bucket->coef[i]!=NULL)
@@ -807 +804 @@
 {
     assume((!rIsPluralRing(bucket->bucket_ring))||p_IsConstant(m, bucket->bucket_ring));
-  assume(l <= 0 || pLength(p) == l);
+  assume(l <= 0 || pLength(p) == (unsigned)l);
   int i, l1;
   poly p1 = p;
@@ -975 +972 @@
   }
 
-  if ((p1==NULL) && (bucket->coef[i]!=NULL))
+  if (p1==NULL)
     p_Delete(&bucket->coef[i],r);
 #endif
@@ -1038 +1035 @@
       if (q != NULL)
       {
-        assume(pLength(q) == lq);
+        assume(pLength(q) == (unsigned)lq);
         bucket->buckets_length[i] -= lq;
-        assume(pLength(bucket->buckets[i]) == bucket->buckets_length[i]);
+        assume(pLength(bucket->buckets[i]) == (unsigned)bucket->buckets_length[i]);
         p = p_Add_q(p, q, lp, lq, bucket->bucket_ring);
       }
@@ -1070 +1067 @@
   assume(p1 != NULL &&
          p_DivisibleBy(p1,  kBucketGetLm(bucket), r));
-  assume(pLength(p1) == (int) l1);
+  assume(pLength(p1) == (unsigned) l1);
 
   poly a1 = pNext(p1), lm = kBucketExtractLm(bucket);
@@ -1128 +1125 @@
   l1--;
 
-  assume(l1==pLength(a1));
+  assume((unsigned)l1==pLength(a1));
 #if 0
   BOOLEAN backuped=FALSE;
@@ -1163 +1160 @@
 
 #ifndef USE_COEF_BUCKETS
-void kBucketSimpleContent(kBucket_pt) {}
+void kBucketSimpleContent(kBucket_pt bucket)
+{
+  if (bucket->buckets[0]==NULL) return;
+
+  ring r=bucket->bucket_ring;
+  if (rField_is_Ring(r)) return;
+
+  coeffs cf=r->cf;
+  if (cf->cfSubringGcd==ndGcd) /* trivial gcd*/ return;
+
+  number nn=pGetCoeff(bucket->buckets[0]);
+  //if ((bucket->buckets_used==0)
+  //&&(!n_IsOne(nn,cf)))
+  //{
+  //  if (TEST_OPT_PROT) PrintS("@");
+  //  p_SetCoeff(bucket->buckets[0],n_Init(1,cf),r);
+  //  return;
+  //}
+
+  if (n_Size(nn,cf)<2) return;
+
+  //kBucketAdjustBucketsUsed(bucket);
+  number coef=n_Copy(nn,cf);
+  // find an initial guess of a gcd
+  for (int i=1; i<=bucket->buckets_used;i++)
+  {
+    if (bucket->buckets[i]!=NULL)
+    {
+      number t=p_InitContent(bucket->buckets[i],r);
+      if (n_Size(t,cf)<2)
+      {
+        n_Delete(&t,cf);
+        n_Delete(&coef,cf);
+        return;
+      }
+      number t2=n_SubringGcd(coef,t,cf);
+      n_Delete(&t,cf);
+      n_Delete(&coef,cf);
+      coef=t2;
+      if (n_Size(coef,cf)<2) { n_Delete(&coef,cf);return;}
+    }
+  }
+  // find the gcd
+  for (int i=0; i<=bucket->buckets_used;i++)
+  {
+    if (bucket->buckets[i]!=NULL)
+    {
+      poly p=bucket->buckets[i];
+      while(p!=NULL)
+      {
+        number t=n_SubringGcd(coef,pGetCoeff(p),cf);
+        if (n_Size(t,cf)<2)
+        {
+          n_Delete(&t,cf);
+          n_Delete(&coef,cf);
+          return;
+        }
+        pIter(p);
+      }
+    }
+  }
+  // divided by the gcd
+  if (TEST_OPT_PROT) PrintS("@");
+  for (int i=bucket->buckets_used;i>=0;i--)
+  {
+    if (bucket->buckets[i]!=NULL)
+    {
+      poly p=bucket->buckets[i];
+      while(p!=NULL)
+      {
+        number d = n_ExactDiv(pGetCoeff(p),coef,cf);
+        p_SetCoeff(p,d,r);
+        pIter(p);
+      }
+    }
+  }
+  n_Delete(&coef,cf);
+}
 #else
 static BOOLEAN nIsPseudoUnit(number n, ring r)

libpolys/polys/monomials/p_polys.cc

@@ -2234 +2234 @@
 /* --------------------------------------------------------------------------------*/
 /* content suff                                                                   */
-static number p_InitContent(poly ph, const ring r);
+//number p_InitContent(poly ph, const ring r);
 
 void p_Content(poly ph, const ring r)
@@ -2543 +2543 @@
 #endif
 
-static number p_InitContent(poly ph, const ring r)
+number p_InitContent(poly ph, const ring r)
 // only for coefficients in Q and rational functions
 #if 0

libpolys/polys/monomials/p_polys.h

@@ -213 +213 @@
 // currently only used by Singular/janet
 void      p_SimpleContent(poly p, int s, const ring r);
+number    p_InitContent(poly ph, const ring r);
 #endif
 
@@ -798 +799 @@
 static inline poly p_Copy_noCheck(poly p, const ring r)
 {
-  assume(r != NULL); assume(r->p_Procs != NULL); assume(r->p_Procs->p_Copy != NULL);
+  /*assume(p!=NULL);*/
+  assume(r != NULL);
+  assume(r->p_Procs != NULL);
+  assume(r->p_Procs->p_Copy != NULL);
   return r->p_Procs->p_Copy(p, r);
 }
@@ -805 +809 @@
 static inline poly p_Copy(poly p, const ring r)
 {
-  p_Test(p,r);
-  const poly pp = p_Copy_noCheck(p, r);
-  p_Test(pp,r);
-  return pp;
+  if (p!=NULL)
+  {
+    p_Test(p,r);
+    const poly pp = p_Copy_noCheck(p, r);
+    p_Test(pp,r);
+    return pp;
+  }
+  else
+    return NULL;
 }
 
@@ -824 +833 @@
 }
 
-static inline poly p_LmHead(poly p, const ring r)
-{
-  p_LmCheckPolyRing1(p, r);
-  poly np;
-  omTypeAllocBin(poly, np, r->PolyBin);
-  p_SetRingOfLm(np, r);
-  memcpy(np->exp, p->exp, r->ExpL_Size*sizeof(long));
-  pNext(np) = NULL;
-  pSetCoeff0(np, NULL);
-  return np;
-}
-
 // returns a copy of p with Lm(p) from lmRing and Tail(p) from tailRing
 static inline poly p_Copy(poly p, const ring lmRing, const ring tailRing)
@@ -846 +843 @@
 #endif
     poly pres = p_Head(p, lmRing);
-    pNext(pres) = p_Copy_noCheck(pNext(p), tailRing);
+    if (pNext(p)!=NULL)
+      pNext(pres) = p_Copy_noCheck(pNext(p), tailRing);
     return pres;
   }
@@ -858 +856 @@
   assume( p!= NULL );
   assume( r!= NULL );
-  r->p_Procs->p_Delete(p, r);
+  if ((*p)!=NULL) r->p_Procs->p_Delete(p, r);
 }
 
@@ -918 +916 @@
   else if (n_IsZero(n, r->cf))
   {
-    r->p_Procs->p_Delete(&p, r); // NOTE: without p_Delete - memory leak!
+    p_Delete(&p, r); // NOTE: without p_Delete - memory leak!
     return NULL;
   }
@@ -1053 +1051 @@
   if (p == NULL)
   {
-    r->p_Procs->p_Delete(&q, r);
+    p_Delete(&q, r);
     return NULL;
   }
   if (q == NULL)
   {
-    r->p_Procs->p_Delete(&p, r);
+    p_Delete(&p, r);
     return NULL;
   }
@@ -1071 +1069 @@
       q = r->p_Procs->p_Mult_mm(q, p, r);
 
-    r->p_Procs->p_Delete(&p, r);
+    p_LmDelete(&p, r);
     return q;
   }
@@ -1078 +1076 @@
   {
     p = r->p_Procs->p_Mult_mm(p, q, r);
-    r->p_Procs->p_Delete(&q, r);
+    p_LmDelete(&q, r);
     return p;
   }

libpolys/polys/pDebug.cc

@@ -90 +90 @@
     #ifndef X_OMALLOC
     {
-      _pPolyAssumeReturn(omIsBinPageAddr(p) && omSizeWOfAddr(p)==omSizeWOfBin(r->PolyBin),p,r);
+      _pPolyAssumeReturn(omIsBinPageAddr(p),p,r);
+      _pPolyAssumeReturn(omSizeWOfAddr(p)==omSizeWOfBin(r->PolyBin),p,r);
       return TRUE;
     }

libpolys/polys/sbuckets.cc

@@ -117 +117 @@
   for (i=0; i<= bucket->max_bucket; i++)
   {
-
-    if (bucket->buckets[i].p != NULL)
-    {
-      p_Delete(&(bucket->buckets[i].p), bucket->bucket_ring);
-    }
+    p_Delete(&(bucket->buckets[i].p), bucket->bucket_ring);
   }
   omFreeBin(bucket, sBucket_bin);