Changeset ca3864 – Singular

Makefile.am

-                      r4083fa
+                      rca3864
 libpolys gfanlib IntegerProgramming \
 kernel Singular \
 dox emacs debian redhat desktop
+dox emacs desktop
 EXTRA_DIST = README README.md autogen.sh git-version-gen doxy
+EXTRA_DIST = README README.md README.pkg autogen.sh git-version-gen doxy singular.spec.in
 bin_SCRIPTS = libsingular-config

Singular/LIB/grwalk.lib

-                      r4e3305
+                      rca3864
+}
 proc gwalk(ideal Go, list #)
 "SYNTAX: gwalk(ideal i);
          gwalk(ideal i, intvec v, intvec w);
+proc gwalk(ideal Go, int reduction,int printout, list #)
+"SYNTAX: gwalk(ideal i, int reduction, int printout);
+         gwalk(ideal i, int reduction, int printout, intvec v, intvec w);
 TYPE:    ideal
 PURPOSE: compute the standard basis of the ideal, calculated via
 …
    //print("//** help ring = " + string(basering));
    ideal G = fetch(xR, Go);
    G = system("Mwalk", G, curr_weight, target_weight,basering);
+   G = system("Mwalk", G, curr_weight, target_weight,basering,reduction,printout);
    setring xR;
 …
   ring r = 32003,(z,y,x), lp;
   ideal I = y3+xyz+y2z+xz3, 3+xy+x2y+y2z;
   gwalk(I);
+  gwalk(I,0,1);
+}
 …
+}
 proc fwalk(ideal Go, list #)
 "SYNTAX: fwalk(ideal i);
          fwalk(ideal i, intvec v, intvec w);
+proc fwalk(ideal Go, int reduction, int printout, list #)
+"SYNTAX: fwalk(ideal i,int reductioin);
+         fwalk(ideal i, int reduction intvec v, intvec w);
 TYPE:    ideal
 PURPOSE: compute the standard basis of the ideal w.r.t. the
 …
    ideal G = fetch(xR, Go);
    G = system("Mfwalk", G, curr_weight, target_weight);
+   G = system("Mfwalk", G, curr_weight, target_weight, reduction, printout);
    setring xR;
 …
     ring r = 32003,(z,y,x), lp;
     ideal I = y3+xyz+y2z+xz3, 3+xy+x2y+y2z;
+    fwalk(I);
+    int reduction = 1;
+    int printout = 1;
+    fwalk(I,reduction,printout);
+}
 …
+}
 proc pwalk(ideal Go, int n1, int n2, list #)
 "SYNTAX: pwalk(int d, ideal i, int n1, int n2);
          pwalk(int d, ideal i, int n1, int n2, intvec v, intvec w);
+proc pwalk(ideal Go, int n1, int n2, int reduction, int printout, list #)
+"SYNTAX: pwalk(int d, ideal i, int n1, int n2, int reduction, int printout);
+         pwalk(int d, ideal i, int n1, int n2, int reduction, int printout, intvec v, intvec w);
 TYPE:    ideal
 PURPOSE: compute the standard basis of the ideal, calculated via
 …
   ideal G = fetch(xR, Go);
+<<<<<<< HEAD
+  G = system("Mpwalk",G,n1,n2,curr_weight,target_weight,nP,reduction,printout);
+=======
   G = system("Mpwalk", G, n1, n2, curr_weight, target_weight,nP);
+>>>>>>> f533f6f7667328bccb271b19b2f603aaebe41596
   setring xR;
   //kill Go;
 …
     ring r = 32003,(z,y,x), lp;
     ideal I = y3+xyz+y2z+xz3, 3+xy+x2y+y2z;
+    //I = std(I);
+    //ring rr = 32003,(z,y,x),lp;
+    //ideal I = fetch(r,I);
+    pwalk(I,2,2);
+    int reduction = 1;
+    int printout = 2;
+    pwalk(I,2,2,reduction,printout);
+}

Singular/LIB/modwalk.lib

Property mode changed from 100644 to 100755

-                      r4e3305
+                      rca3864
 PROCEDURES:
+modpWalk(ideal,int,int,int[,int,int,int,int])    standard basis conversion of I in prime characteristic
 modWalk(ideal,int,int[,int,int,int,int]);        standard basis conversion of I using modular methods (chinese remainder)
 ";
 …
 ////////////////////////////////////////////////////////////////////////////////
 static proc modpWalk(def II, int p, int variant, list #)
+proc modpWalk(def II, int p, int variant, int reduction, list #)
 "USAGE:  modpWalk(I,p,#); I ideal, p integer, variant integer
 ASSUME:  If size(#) > 0, then
 …
+    }
+  }
+<<<<<<< HEAD
+=======
 //-------------------------  make i homogeneous  -----------------------------
 …
+  }
+>>>>>>> f533f6f7667328bccb271b19b2f603aaebe41596
 //-------------------------  compute a standard basis mod p  -----------------------------
   if(variant == 1)
+  {
     if(size(#)>0)
+    {
+      i = rwalk(i,radius,pert_deg,#);
+     // rwalk(i,radius,pert_deg,#); std(i);
+      i = rwalk(i,radius,pert_deg,reduction,#);
+    }
     else
+    {
       i = rwalk(i,radius,pert_deg);
+      i = rwalk(i,radius,pert_deg,reduction);
+    }
+  }
 …
     if(size(#) == 2)
+    {
       i = gwalk(i,#);
+      i = gwalk(i,reduction,#);
+    }
     else
+    {
       i = gwalk(i);
+      i = gwalk(i,reduction);
+    }
+  }
 …
     if(size(#) == 2)
+    {
       i = frandwalk(i,radius,#);
+      i = frandwalk(i,radius,reduction,#);
+    }
     else
+    {
       i = frandwalk(i,radius);
+      i = frandwalk(i,radius,reduction);
+    }
+  }
 …
     if(size(#) == 2)
+    {
      i=prwalk(i,radius,pert_deg,pert_deg,#);
+     i=prwalk(i,radius,pert_deg,pert_deg,reduction,#);
+    }
     else
+    {
       i=prwalk(i,radius,pert_deg,pert_deg);
+      i=prwalk(i,radius,pert_deg,pert_deg,reduction);
+    }
+  }
 …
     if(size(#) == 2)
+    {
       i=pwalk(i,pert_deg,pert_deg,#);
+      i=pwalk(i,pert_deg,pert_deg,reduction,#);
+    }
     else
+    {
+<<<<<<< HEAD
+      i=pwalk(i,pert_deg,pert_deg,reduction);
+=======
       i=pwalk(i,pert_deg,pert_deg);
+    }
 …
         kill HomR;
+      }
+    }
+  }
+>>>>>>> f533f6f7667328bccb271b19b2f603aaebe41596
+    }
+  }
   setring R0;
   return(list(fetch(@r,i),p));
 …
   ring ra = 0,x(1..4),(a(a),lp);
   ideal I = std(cyclic(4));
+  int reduction = 1;
   ring rb = 0,x(1..4),(a(b),lp);
   ideal I = imap(ra,I);
   modpWalk(I,p,1,a,b);
+  modpWalk(I,p,1,reduction,a,b);
   std(I);
+}
 …
 ////////////////////////////////////////////////////////////////////////////////
 proc modWalk(def II, int variant, list #)
+proc modWalk(def II, int variant, int reduction, list #)
 "USAGE:  modWalk(II); II ideal or list(ideal,int)
 ASSUME:  If variant =
 …
   if(n2 > 4)
+  {
   //  L[5] = prime(random(an,en));
+    L[5] = prime(random(an,en));
+  }
   if(printlevel >= 10)
 …
     for(i=1; i<=size(L); i++)
+    {
       Arguments[i] = list(II,L[i],variant,list(curr_weight,target_weight));
+      Arguments[i] = list(II,L[i],variant,reduction,list(curr_weight,target_weight));
+    }
+  }
 …
     for(i=1; i<=size(L); i++)
+    {
       Arguments[i] = list(II,L[i],variant);
+      Arguments[i] = list(II,L[i],variant,reduction);
+    }
+  }
 …
 //-------------------  Now all leading ideals are the same  --------------------
 //-------------------  Lift results to basering via farey  ---------------------
     tt = timer; rt = rtimer;
     N = T2[1];
 …
 //----------------  Test if we already have a standard basis of I --------------
     tt = timer; rt = rtimer;
+    pTest = pTestSB(I,J,L,variant);
+    //pTest = primeTestSB(I,J,L,variant);
+    pTest = primeTest(J, prime(random(1000000000,2134567879)));
     if(printlevel >= 10)
+    {
 …
+    }
 //--------------  We do not already have a standard basis of I, therefore do the main computation for more primes  --------------
     T1 = H;
     T2 = N;
 …
       for(i=j; i<=size(L); i++)
+      {
+        //Arguments[i-j+1] = list(II,L[i],variant,list(curr_weight,target_weight));
+        Arguments[size(Arguments)+1] = list(II,L[i],variant,list(curr_weight,target_weight));
+        Arguments[size(Arguments)+1] = list(II,L[i],variant,reduction,list(curr_weight,target_weight));
+      }
+    }
 …
       for(i=j; i<=size(L); i++)
+      {
+        //Arguments[i-j+1] = list(II,L[i],variant);
+        Arguments[size(Arguments)+1] = list(II,L[i],variant);
+        Arguments[size(Arguments)+1] = list(II,L[i],variant,reduction);
+      }
+    }
 …
     for(i=1; i<=size(PP); i++)
+    {
-      //P[size(P) + 1] = PP[i];
       T1[size(T1) + 1] = PP[i][1];
       T2[size(T2) + 1] = bigint(PP[i][2]);
 …
   echo = 2;
   ring R=0,(x,y,z),lp;
   ideal I=-x+y2z-z,xz+1,x2+y2-1;
   // I is a standard basis in dp
   ideal J = modWalk(I,1);
+  ideal I= y3+xyz+y2z+xz3, 3+xy+x2y+y2z;
+  int reduction = 0;
+  ideal J = modWalk(I,1,1);
   J;
+}
 …
   return(J);
+}
+//////////////////////////////////////////////////////////////////////////////////
+static proc primeTestSB(def II, ideal J, list L, int variant, list #)
+"USAGE:  primeTestSB(I,J,L,variant,#); I,J ideals, L intvec of primes, variant int
+RETURN:  1 (resp. 0) if for a randomly chosen prime p that is not in L
+         J mod p is (resp. is not) a standard basis of I mod p
+EXAMPLE: example primeTestSB; shows an example
+"
+{
+if(typeof(II) == "ideal")
+  {
+  ideal I = II;
+  int radius = 2;
+  }
+if(typeof(II) == "list")
+  {
+  ideal I = II[1];
+  int radius = II[2];
+  }
+int i,j,k,p;
+def R = basering;
+list r = ringlist(R);
+while(!j)
+  {
+  j = 1;
+  p = prime(random(1000000000,2134567879));
+  for(i = 1; i <= size(L); i++)
+    {
+    if(p == L[i])
+      {
+      j = 0;
+      break;
+      }
+    }
+  if(j)
+    {
+    for(i = 1; i <= ncols(I); i++)
+      {
+      for(k = 2; k <= size(I[i]); k++)
+        {
+        if((denominator(leadcoef(I[i][k])) mod p) == 0)
+          {
+          j = 0;
+          break;
+          }
+        }
+      if(!j)
+        {
+        break;
+        }
+      }
+    }
+  if(j)
+    {
+    if(!primeTest(I,p))
+      {
+      j = 0;
+      }
+    }
+  }
+r[1] = p;
+def @R = ring(r);
+setring @R;
+ideal I = imap(R,I);
+ideal J = imap(R,J);
+attrib(J,"isSB",1);
+int t = timer;
+j = 1;
+if(isIncluded(I,J) == 0)
+  {
+  j = 0;
+  }
+if(printlevel >= 11)
+  {
+  "isIncluded(I,J) takes "+string(timer - t)+" seconds";
+  "j = "+string(j);
+  }
+t = timer;
+if(j)
+  {
+  if(size(#) > 0)
+    {
+    ideal K = modpWalk(I,p,variant,#)[1];
+    }
+  else
+    {
+    ideal K = modpWalk(I,p,variant)[1];
+    }
+  t = timer;
+  if(isIncluded(J,K) == 0)
+    {
+    j = 0;
+    }
+  if(printlevel >= 11)
+    {
+    "isIncluded(K,J) takes "+string(timer - t)+" seconds";
+    "j = "+string(j);
+    }
+  }
+setring R;
+return(j);
+}
+example
+{ "EXAMPLE:"; echo = 2;
+   intvec L = 2,3,5;
+   ring r = 0,(x,y,z),lp;
+   ideal I = x+1,x+y+1;
+   ideal J = x+1,y;
+   primeTestSB(I,I,L,1);
+   primeTestSB(I,J,L,1);
+}
+////////////////////////////////////////////////////////////////////////////////
+static proc pTestSB(ideal I, ideal J, list L, int variant, list #)
+"USAGE:  pTestSB(I,J,L,variant,#); I,J ideals, L intvec of primes, variant int
+RETURN:  1 (resp. 0) if for a randomly chosen prime p that is not in L
+         J mod p is (resp. is not) a standard basis of I mod p
+EXAMPLE: example pTestSB; shows an example
+"
+{
+   int i,j,k,p;
+   def R = basering;
+   list r = ringlist(R);
+   while(!j)
+   {
+      j = 1;
+      p = prime(random(1000000000,2134567879));
+      for(i = 1; i <= size(L); i++)
+      {
+         if(p == L[i]) { j = 0; break; }
+      }
+      if(j)
+      {
+         for(i = 1; i <= ncols(I); i++)
+         {
+            for(k = 2; k <= size(I[i]); k++)
+            {
+               if((denominator(leadcoef(I[i][k])) mod p) == 0) { j = 0; break; }
+            }
+            if(!j){ break; }
+         }
+      }
+      if(j)
+      {
+         if(!primeTest(I,p)) { j = 0; }
+      }
+   }
+   r[1] = p;
+   def @R = ring(r);
+   setring @R;
+   ideal I = imap(R,I);
+   ideal J = imap(R,J);
+   attrib(J,"isSB",1);
+   int t = timer;
+   j = 1;
+   if(isIncluded(I,J) == 0) { j = 0; }
+   if(printlevel >= 11)
+   {
+      "isIncluded(I,J) takes "+string(timer - t)+" seconds";
+      "j = "+string(j);
+   }
+   t = timer;
+   if(j)
+   {
+      if(size(#) > 0)
+      {
+         ideal K = modpStd(I,p,variant,#[1])[1];
+      }
+      else
+      {
+         ideal K = groebner(I);
+      }
+      t = timer;
+      if(isIncluded(J,K) == 0) { j = 0; }
+      if(printlevel >= 11)
+      {
+         "isIncluded(J,K) takes "+string(timer - t)+" seconds";
+         "j = "+string(j);
+      }
+   }
+   setring R;
+   return(j);
+}
+example
+{ "EXAMPLE:"; echo = 2;
+   intvec L = 2,3,5;
+   ring r = 0,(x,y,z),dp;
+   ideal I = x+1,x+y+1;
+   ideal J = x+1,y;
+   pTestSB(I,I,L,2);
+   pTestSB(I,J,L,2);
+}
 ////////////////////////////////////////////////////////////////////////////////
 static proc mixedTest()

Singular/LIB/normaliz.lib

-                      r4083fa
+                      rca3864
 //// Singular library normaliz.lib
 version="version normaliz.lib 4.0.0.0 Jun_2013 "; // $Id$
+version="version normaliz.lib 4.0.1.0 Jan_2015 "; // $Id$
 category="Commutative Algebra";
 info="
 LIBRARY: normaliz.lib  Provides an interface for the use of Normaliz 2.7
          within SINGULAR.
 AUTHORS:  Winfried Bruns, Winfried.Bruns@Uni-Osnabrueck.de
           Christof Soeger, Christof.Soeger@Uni-Osnabrueck.de
+LIBRARY: normaliz.lib  Provides an interface for the use of Normaliz 2.8 or
+         newer within SINGULAR.
+AUTHORS: Winfried Bruns, Winfried.Bruns@Uni-Osnabrueck.de
+         Christof Soeger, Christof.Soeger@Uni-Osnabrueck.de
 OVERVIEW:
+The library normaliz.lib provides an interface for the use of Normaliz 2.7
+within SINGULAR. The exchange of data is via files.
+@texinfo
+The library normaliz.lib provides an interface for the use of Normaliz 2.8 or
+newer within SINGULAR. The exchange of data is via files.
 In addition to the top level
 functions that aim at objects of type ideal or ring, several other auxiliary
 functions allow the user to apply Normaliz to data of type intmat. Therefore
 SINGULAR can be used as a comfortable environment for the work with Normaliz.
 @* Please see the @code{Normaliz2.7Documentation.pdf} (included in the Normaliz
+@* Please see the @code{Normaliz.pdf} (included in the Normaliz
 distribution) for a more extensive documentation of Normaliz.
+@code{nmz_sing.pdf} describes this library version 2.2, but most points are
+still valid.
+@*Singular and Normaliz exchange data via files. These files are automatically
+Normaliz allows the use of a grading. In the Singular functions that access
+Normaliz the parameter grading is an intvec that assigns a (not necessarily
+positive) degree to every variable of the ambient polynomial ring.
+But it must give positive degrees to the generators given to function.
+Singular and Normaliz exchange data via files. These files are automatically
 created and erased behind the scenes. As long as one wants to use only the
 ring-theoretic functions there is no need for file management.
 @*Note that the numerical invariants computed by Normaliz can be
 accessed in this \"automatic file mode\".
 @*However, if Singular is used as a frontend for Normaliz or the user
 wants to inspect data not automatically returned to Singular, then
 …
 Deletion of the files is left to the user.
 @* Use of this library requires the program Normaliz to be installed.
+Use of this library requires the program Normaliz to be installed.
 You can download it from
 @uref{http://www.mathematik.uni-osnabrueck.de/normaliz/}. Please make sure
 that the executables are in the search path or use setNmzExecPath
 (@ref{setNmzExecPath}).
+KEYWORDS: integral closure; normalization
+@end texinfo
+KEYWORDS: integral closure; normalization; toric ring
 PROCEDURES:
 …
                               elements of I
  normalToricRingFromBinomials(ideal I)  computes the normalization of the
+                              polynomial ring modulo the unique minimal prime
+                              ideal of the binomial ideal I
+ ehrhartRing(ideal I)         computes the monomials representing the lattice
+                              points of the polytop generated leading monomials
+                              of the elements of I
+ intclMonIdeal(ideal I)       the exponent vectors of the leading monomials of
+                              the elements of I are considered as generators of
+                              a monomial ideal whose Rees algebra is computed
+                              polynomial ring modulo the unique minimal binomial
+                              prime ideal of the binomial ideal I
+ ehrhartRing(ideal I)         considers the exponent vectors of the elements of I
+                              as points of a lattice polytope and computes the
+                              integral cloure of the polytopal algebra
+ intclMonIdeal(ideal I)       Computes the integral closure of the Rees algebra
+                              of the ideal generated by the leading monomials of
+                              the elements of I
  torusInvariants(intmat T)    computes the ring of invariants of a torus action
  finiteDiagInvariants(intmat C)  computes the ring of invariants of a finite
 …
  intersectionValRingIdeals(intmat V)       computes ideals of monomial valuations
  showNuminvs()                prints the numerical invariants
  exportNuminvs()              exports the numerical invariants
+ showNuminvs()                prints the numerical invariants found by Normaliz
+ exportNuminvs()              exports the numerical invariants found by Normaliz
  setNmzOption(string s, int onoff) sets the option s to onoff
 …
     desString("nmz_data_path",nmz_data_path_name);
     nmz_data_path=appendSlash(nmz_data_path);
+}example
+}
+example
 { "EXAMPLE:";echo = 2;
   setNmzDataPath("examples/");
 …
+    {
         f=getNmzFile()+"."+suffixes[i];
+        if (fileExists(f)) { dummy=system("sh","rm "+f+ "&> /dev/null"); }
+        if (fileExists(f))
+        {
+            dummy=system("sh","rm "+f+ "&> /dev/null");
+        }
+    }
+}
 …
     for (int k=1; k+1<=size(#); k=k+2) {
     //get data from the parameter list
+      sgr   = #[k];
+      num_rows = nrows(sgr);
+      num_cols = ncols(sgr);
+                n_mode   = #[k+1];
+      write(outf,num_rows);
+      write(outf,num_cols);
+      for(i=1;i<=nrows(sgr);i++)
+      {
+        s="";
+        for(j=1;j<=num_cols;j++)
+        {
+           s=s+string(sgr[i,j])+" ";
+        }
+        write(outf,s);
+      }
+      write(outf,n_mode);
+      write(outf,"");
+        n_mode   = #[k+1];
+        if (n_mode != -1) { //skip -1 mode
+            sgr = #[k];
+            num_rows = nrows(sgr);
+            num_cols = ncols(sgr);
+            write(outf,num_rows);
+            write(outf,num_cols);
+            for(i=1;i<=nrows(sgr);i++)
+            {
+                s="";
+                for(j=1;j<=num_cols;j++)
+                {
+                    s=s+string(sgr[i,j])+" ";
+                }
+                write(outf,s);
+            }
+            if (n_mode == 20) {
+                write(outf,"grading");
+            } else {
+                write(outf,n_mode);
+            }
+            write(outf,"");
+        }
+    }
     close(outf);
+}
+static proc prepareGrading(list #)
+{
+    if (size(#)==0) {
+        return(0,-1); // mode -1 specifies discard the matrix
+    }
+    if (size(#)>1) {
+        print(#);
+        ERROR("To many parameters!");
+    }
+    intmat g = intmat(#[1],1,size(#[1]));
+    return (g,20);
+}
 …
           mode. See the Normaliz documentation for more information.
+                         It is also possible to give more than one pair of matrix and mode. In
+                         this case all matrices and modes are written. This can be used to
+                         combine modes 4,5,6.
+          It is also possible to give more than one pair of matrix and mode. In
+          this case all matrices and modes are written. This can be used to
+          combine modes 4,5,6.
+          Use mode=20 to specify a grading.
 NOTE:     Needs an explicit filename set. The filename is created from the
           current filename.
 …
     (n_cols,p)=getInt(s,p);
     if (n_rows <= 0 || n_cols <= 0) {
              intmat empty;
              return(empty);
+    }
          intmat nmz_gen[n_rows][n_cols];
+         intmat empty;
+         return(empty);
+    }
+    intmat nmz_gen[n_rows][n_cols];
     for(i=1;i<=n_rows;i++)
+    {
 …
   intmat sgrnormal=normaliz(sgr,0);
   readNmzData("cst");
-  readNmzData("typ");
+}
 …
         list nmz_options=
         list("supp",0,"-s",0),
         list("triang",0,"-v",0),
         list("volume",0,"-V",0),
+        list("triang",0,"-tT",0),
+        list("volume",0,"-v",0),
         list("hvect",0,"-p",0),
-        list("hvect_l",0,"-P",0),
         list("height1",0,"-1",0),
         list("normal",0,"-n",1),
         list("normal_l",0,"-N",1),
         list("hilb",0,"-h",1),
-        list("hilb_l",0,"-H",1),
         list("dual",0,"-d",1),
         list("control",0,"-c",2),
 …
 The Normaliz options are accessible via the following names:
 @* @code{-s:  supp}
 @* @code{-v:  triang}
 @* @code{-V:  volume}
+@* @code{-t:  triang}
+@* @code{-v:  volume}
 @* @code{-p:  hvect}
-@* @code{-P:  hvect_l}
 @* @code{-1:  height1}
 @* @code{-n:  normal}
 @* @code{-N:  normal_l}
 @* @code{-h:  hilb}
-@* @code{-H:  hilb_l}
 @* @code{-d:  dual}
 @* @code{-a:  allf}
 …
+        {
             run_options=run_options+nmz_options[i][3];
                                 if (nmz_options[i][1]=="threads") {
                                         run_options=run_options+string(nmz_options[i][2]);
+                                }
                                 run_options=run_options+" ";
+                if (nmz_options[i][1]=="threads") {
+                    run_options=run_options+string(nmz_options[i][2]);
+                }
+                run_options=run_options+" ";
             if(nmz_options[i][4]!=2)
+            {
 …
 static proc runNormaliz(intmat sgr,def nmz_mode, list #)
+static proc runNormaliz(intmat sgr, int nmz_mode, list #)
+{
     if(!queryInt("nmz_files_keep_switch"))
 …
           It is also possible to give more than one pair of matrix and mode. In
+                         this case all matrices and modes are used. This can be used to
+                         combine modes 4,5,6.
+          this case all matrices and modes are used. This can be used to
+          combine modes 4,5,6.
+          Use nmz_mode=20 to specify a grading.
 NOTE:     You will find procedures for many applications of Normaliz in this
           library, so the explicit call of this procedure may not be necessary.
 SEE ALSO: intclToricRing, normalToricRing, ehrhartRing, intclMonIdeal,
           torusInvariants, diagInvariants, finiteDiagInvariants, intersectionValRings,
                          intersectionValRingIdeals
+             intersectionValRingIdeals
 EXAMPLE:  example normaliz; shows an example
+"
 …
                 name_inv="h_vector";
+            }
+            if(name_inv!="hilbert_polynomial")
+            if(name_inv!="hilbert_polynomial"
+              && name_inv!="hilbert_quasipolynomial")
+            {
                 for(i=1;i<=v_length;i++)
 …
             (sw,p)=nextWord(s,p);
             name_inv=s[sw..p-1];
+            (dummy_int,p)=getInt(s,p);
+            num_invs=num_invs+list(list(name_inv,dummy_int,"int"));
+            if (name_inv!="hilbert_quasipolynomial_denom") {
+              (dummy_int,p)=getInt(s,p);
+              num_invs=num_invs+list(list(name_inv,dummy_int,"int"));
+            }
+        }
         if(type_inv=="boolean")
 …
 { "EXAMPLE:"; echo=2;
   ring R=0,(x,y,z,t),dp;
   ideal I=x^2,y^2,z^3;
+  ideal I=x3,x2y,y3;
   list l=intclMonIdeal(I);
   showNuminvs();
 …
 { "EXAMPLE:"; echo=2;
   ring R=0,(x,y,z,t),dp;
   ideal I=x^2,y^2,z^3;
+  ideal I=x3,x2y,y3;
   list l=intclMonIdeal(I);
   exportNuminvs();
   // now the following variables are set:
+  // for example, now the following variables are set:
   nmz_hilbert_basis_elements;
   nmz_number_extreme_rays;
 …
   nmz_index;
   nmz_number_support_hyperplanes;
   nmz_homogeneous;
+  nmz_multiplicity;
   nmz_primary;
-  nmz_ideal_multiplicity;
+}
 …
         if(expo_vecs[i,ncols(expo_vecs)]==d)
+        {
             m=1;
             for(j=1;j<=ncols(expo_vecs)-1;j++)
 …
+        }
+    }
      mons=simplify(mons,2);    // get rid of starting 0
      return(mons);
+    mons=simplify(mons,2);    // get rid of starting 0
+    return(mons);
+}
 …
 RETURN:   Returns the intmat whose rows represent the exponents of the
           (non-zero) elements of I which have to be binomials.
                          The length of each row is nvars(basering).
+          The length of each row is nvars(basering).
 SEE ALSO: mons2intmat, intmat2mons
 EXAMPLE:  example binomials2intmat; shows an example"
+{
+  int i,j,k;
+  intmat expo_vecs[size(I)][nvars(basering)];
+  intvec expo_v;
+  k=0;
+  poly f;
+  for(i=1; i<=ncols(I); i++)
+  {
+    if( I[i] != 0 )
+    {
+      k++;
+      f = I[i];
+      if (leadcoef(f) != 1) {f = -f};  //works in all characteristics
+      if (size(f)!=2 || leadcoef(f)!=1 || leadcoef(f[2])!=-1)
+      {
+        ERROR(string("normalToricRing: binomial ideal expected: generator ",i,": ",I[i]));
+      }
+      expo_v = leadexp(f)-leadexp(f[2]);
+      for(j=1;j<=nvars(basering);j++)
+      {
+        expo_vecs[k,j]=expo_v[j];
+      }
+    }
+  }
+  return(expo_vecs);
+    int i,j,k;
+    intmat expo_vecs[size(I)][nvars(basering)];
+    intvec expo_v;
+    k=0;
+    poly f;
+    for(i=1; i<=ncols(I); i++)
+    {
+        if( I[i] != 0 )
+        {
+            k++;
+            f = I[i];
+            if (leadcoef(f) != 1) {f = -f};  //works in all characteristics
+            if (size(f)!=2 || leadcoef(f)!=1 || leadcoef(f[2])!=-1)
+            {
+                ERROR(string("normalToricRing: binomial ideal expected: generator ",i,": ",I[i]));
+            }
+            expo_v = leadexp(f)-leadexp(f[2]);
+            for(j=1;j<=nvars(basering);j++)
+            {
+                expo_vecs[k,j]=expo_v[j];
+            }
+        }
+    }
+    return(expo_vecs);
+}
 example
 …
 // integral closure of rings and ideals
 static proc runIntclToricRing(ideal I, int nmz_mode)
+static proc runIntclToricRing(ideal I, int nmz_mode, list #)
+{
     intmat expo_vecs=mons2intmat(I);
     string dummy=collectNmzOptions(); // only to set GenGen
+    return( intmat2mons( runNormaliz(expo_vecs,nmz_mode) ) );
+}
+proc intclToricRing(ideal I)
+    return( intmat2mons( runNormaliz(expo_vecs,nmz_mode, prepareGrading(#)) ) );
+}
+proc intclToricRing(ideal I, list #)
 "USAGE:   intclToricRing(ideal I);
+RETURN:   The toric ring S is the subalgebra of the basering generated by the
+          leading monomials of the elements of I. The function computes the
+          integral closure T of S in the basering and returns an ideal listing
+          intclToricRing(ideal I, intvec grading);
+RETURN:   The toric ring S is the subalgebra of the basering generated by
+          the leading monomials of the elements of I (considered as a list
+          of polynomials). The function computes the integral
+          closure T of S in the basering and returns an ideal listing
           the algebra generators of T over the coefficient field.
 @*        The function returns the input ideal I if one of the options
+          @code{supp}, @code{triang}, or @code{hvect} has been activated.
+          @code{supp}, @code{triang}, @code{volume}, or @code{hseries}
+          has been activated.
           However, in this case some numerical invariants are computed, and
           some other data may be contained in files that you can read into
 …
+"
+{
     return(runIntclToricRing(I,0));
+    return(runIntclToricRing(I,0,#));
+}
 example
 …
   ideal I=x3,x2y,y3;
   intclToricRing(I);
+}
+proc normalToricRing(ideal I)
+  showNuminvs();
+  //now the same example with another grading
+  intvec grading = 2,3,1;
+  intclToricRing(I,grading);
+  showNuminvs();
+}
+proc normalToricRing(ideal I, list #)
 "USAGE:   normalToricRing(ideal I);
+          normalToricRing(ideal I, intvec grading);
 RETURN:   The toric ring S is the subalgebra of the basering generated by the
+          leading monomials of the elements of I. The function computes the
+          leading monomials of the elements of I (considered as a list of
+          polynomials). The function computes the
           normalisation T of S and returns an ideal listing the algebra
           generators of T over the coefficient field.
 @*        The function returns the input ideal I if one of the options
+          @code{supp}, @code{triang}, or @code{hvect} has been activated.
+          @code{supp}, @code{triang}, @code{volume}, or @code{hseries}
+          has been activated.
           However, in this case some numerical invariants are computed, and
           some other data may be contained in files that you can read into
 …
+"
+{
     return(runIntclToricRing(I,1));
+    return(runIntclToricRing(I,1,#));
+}
 example
 …
 proc normalToricRingFromBinomials(ideal I)
+proc normalToricRingFromBinomials(ideal I, list #)
 "USAGE:   normalToricRingFromBinomials(ideal I);
+RETURN:
+          normalToricRingFromBinomials(ideal I, intvec grading);
+RETURN:   @texinfo
 @tex
 The ideal $I$ is generated by binomials of type $X^a-X^b$ (multiindex notation)
 …
 generators of the normalization of $K[N]$.
 @end tex
+@end texinfo
 @*        The function returns the input ideal I if one of the options
+          @code{supp}, @code{triang}, or @code{hvect} has been activated.
+          @code{supp}, @code{triang}, @code{volume}, or @code{hseries}
+          has been activated.
           However, in this case some numerical invariants are computed, and
           some other data may be contained in files that you can read into
           Singular.
+          Singular (see @ref{showNuminvs}, @ref{exportNuminvs}).
 SEE ALSO: intclToricRing, normalToricRing, ehrhartRing, intclMonIdeal
 EXAMPLE:  example normalToricRing; shows an example
+"
+{
         intmat expo_vecs = binomials2intmat(I);
         string dummy=collectNmzOptions(); // only to set GenGen
         intmat result = runNormaliz(expo_vecs,10);
         list baseringlist = ringlist(basering);
         ring S = (baseringlist[1]),(x(1..ncols(result))),dp;
         ideal I = intmat2mons(result);
         export(I);
         return (S);
+    intmat expo_vecs = binomials2intmat(I);
+    string dummy=collectNmzOptions(); // only to set GenGen
+    intmat result = runNormaliz(expo_vecs,10,prepareGrading(#));
+    list baseringlist = ringlist(basering);
+    ring S = (baseringlist[1]),(x(1..ncols(result))),dp;
+    ideal I = intmat2mons(result);
+    export(I);
+    return (S);
+}
 example
 …
+}
 static proc runIntclMonIdeal(ideal I, int nmz_mode)
+static proc runIntclMonIdeal(ideal I, int nmz_mode, list #)
+{
     intmat expo_vecs=mons2intmat(I);
 …
     //adjust size of input matrix
+         if (!last_comp) { // remove last component
+             intmat tmp[nrows(expo_vecs)][ncols(expo_vecs)-1] = expo_vecs[1..nrows(expo_vecs),1..(ncols(expo_vecs)-1)];
+                  expo_vecs = tmp;
+         }
+    intmat nmz_data=runNormaliz(expo_vecs,nmz_mode);
+    if (!last_comp) { // remove last component
+        intmat tmp[nrows(expo_vecs)][ncols(expo_vecs)-1]
+               = expo_vecs[1..nrows(expo_vecs),1..(ncols(expo_vecs)-1)];
+        expo_vecs = tmp;
+    }
+    intmat nmz_data=runNormaliz(expo_vecs,nmz_mode,prepareGrading(#));
     if(last_comp)
 …
 "USAGE:    ehrhartRing(ideal I);
 RETURN:    The exponent vectors of the leading monomials of the elements of I
            are considered as vertices of a lattice polytope P.
+           are considered as points of a lattice polytope P.
            The Ehrhart ring of a (lattice) polytope P is the monoid algebra
            defined by the monoid of lattice points in the cone over the
 …
                treated as the auxiliary variable of the Ehrhart ring. The
                function returns two ideals, the first containing the monomials
                representing the lattice points of the polytope, the second
+               representing all the lattice points of the polytope, the second
                containing the algebra generators of the Ehrhart ring over the
                     coefficient field.
+               coefficient field.
 @*         (ii) If the last ring variable is used by the monomials, the list
                 returned contains only one ideal, namely the monomials
 …
 @*
 @*        The function returns the a list containing the input ideal I if one
           of the options @code{supp}, @code{triang}, or @code{hvect} has been
                          activated.
+          of the options @code{supp}, @code{triang}, @code{volume}, or
+          @code{hseries} has been activated.
           However, in this case some numerical invariants are computed, and
           some other data may be contained in files that you can read into
           Singular.
+          Singular (see @ref{showNuminvs}, @ref{exportNuminvs}).
 NOTE:      A mathematical remark: the Ehrhart ring depends on the list of
            monomials given, and not only on the ideal they generate!
 …
+}
 proc intclMonIdeal(ideal I)
+proc intclMonIdeal(ideal I, list #)
 "USAGE:   intclMonIdeal(ideal I);
+          intclMonIdeal(ideal I, intvec grading);
 RETURN:   The exponent vectors of the leading monomials of the elements of I
           are considered as generators of a monomial ideal for which the
 …
         closure of the ideal.
 @*        The function returns the a list containing the input ideal I if one
           of the options @code{supp}, @code{triang}, or @code{hvect} has been
                          activated.
+          of the options @code{supp}, @code{triang}, @code{volume}, or
+          @code{hseries} has been activated.
           However, in this case some numerical invariants are computed, and
           some other data may be contained in files that you can read into
 …
+"
+{
     return(runIntclMonIdeal(I,3));
+    return(runIntclMonIdeal(I,3,#));
+}
 example
 …
 // torus invariants and valuation rings and ideals
 proc torusInvariants(intmat E)
+proc torusInvariants(intmat E, list #)
 "USAGE:   torusInvariants(intmat A);
+RETURN:
+          torusInvariants(intmat A, intvec grading);
+RETURN:   @texinfo
 Returns an ideal representing the list of monomials generating the ring of
 invariants as an algebra over the coefficient field.
 …
 $R^T$.
 @end tex
+@*The function returns the ideal given by the input matrix A if one of
+the options @code{supp}, @code{triang}, or @code{hvect} has been
+activated.
+However, in this case some numerical invariants are computed, and
+some other data may be contained in files that you can read into
+Singular.
+BACKGROUND:
+@*        The function returns the ideal given by the input matrix A if one of
+          the options @code{supp}, @code{triang}, @code{volume}, or
+          @code{hseries} has been activated.
+          However, in this case some numerical invariants are computed, and
+          some other data may be contained in files that you can read into
+          Singular (see @ref{showNuminvs}, @ref{exportNuminvs}).
+@end texinfo
+BACKGROUND: @texinfo
 @tex
  Let $T = (K^*)^r$ be the $r$-dimensional torus acting on the polynomial ring
 …
 $A=(a_{i,j})$.
 @end tex
+@end texinfo
 SEE ALSO: diagInvariants, finiteDiagInvariants, intersectionValRings,
           intersectionValRingIdeals
 …
     string dummy=collectNmzOptions();  // only to set GenGen
     return( intmat2mons( runNormaliz(E,5) ) );
+    return( intmat2mons( runNormaliz(E,5,prepareGrading(#)) ) );
+}
 example
 …
+}
 proc finiteDiagInvariants(intmat C)
+proc finiteDiagInvariants(intmat C, list #)
 "USAGE:   finiteDiagInvariants(intmat U);
+RETURN:
+          finiteDiagInvariants(intmat U, intvec grading);
+RETURN:   @texinfo
 @tex
 This function computes the ring of invariants of a finite abelian group $G$
 …
 {$R^G=\{f\in R : g_i f = f$ for all $i=1,\ldots,w\}$}.
 @end tex
+@*The function returns the ideal given by the input matrix C if one of
+the options @code{supp}, @code{triang}, or @code{hvect} has been
+activated.
+However, in this case some numerical invariants are computed, and
+some other data may be contained in files that you can read into
+Singular.
+@end texinfo
+@*        The function returns the ideal given by the input matrix C if one of
+          the options @code{supp}, @code{triang}, @code{volume}, or
+          @code{hseries} has been activated.
+          However, in this case some numerical invariants are computed, and
+          some other data may be contained in files that you can read into
+          Singular (see @ref{showNuminvs}, @ref{exportNuminvs}).
 NOTE:
 SEE ALSO: torusInvariants, diagInvariants, intersectionValRings,
           intersectionValRingIdeals,showNuminvs,exportNuminvs
+          intersectionValRingIdeals
 EXAMPLE:  example finiteDiagInvariants; shows an example
+"
 …
     string dummy=collectNmzOptions();  // only to set GenGen
     return( intmat2mons( runNormaliz(C,6) ) );
+    return( intmat2mons( runNormaliz(C,6,prepareGrading(#)) ) );
+}
 example
 …
+}
 proc diagInvariants(intmat E, intmat C)
+proc diagInvariants(intmat E, intmat C, list #)
 "USAGE:   diagInvariants(intmat A, intmat U);
+RETURN:
+          diagInvariants(intmat A, intmat U, intvec grading);
+RETURN:   @texinfo
 @tex
 This function computes the ring of invariants of a diagonalizable group
 …
 monomial ideal listing the algebra generators of the subalgebra of invariants.
 @end tex
+@*The function returns the ideal given by the input matrix A if one of
+the options @code{supp}, @code{triang}, or @code{hvect} has been
+activated.
+However, in this case some numerical invariants are computed, and
+some other data may be contained in files that you can read into
+Singular.
+SEE ALSO: torusInvariants, finiteDiagInvariants, intersectionValRings, intersectionValRingIdeals,showNuminvs,exportNuminvs
+@end texinfo
+@*        The function returns the ideal given by the input matrix A if one of
+          the options @code{supp}, @code{triang}, @code{volume}, or
+          @code{hseries} has been activated.
+          However, in this case some numerical invariants are computed, and
+          some other data may be contained in files that you can read into
+          Singular (see @ref{showNuminvs}, @ref{exportNuminvs}).
+SEE ALSO: torusInvariants, finiteDiagInvariants, intersectionValRings, intersectionValRingIdeals
 EXAMPLE:  example diagInvariants; shows an example
+"
 …
     string dummy=collectNmzOptions();  // only to set GenGen
     return( intmat2mons( runNormaliz(E,5,C,6) ) );
+    return( intmat2mons( runNormaliz(E,5,C,6,prepareGrading(#)) ) );
+}
 example
 …
+}
 proc intersectionValRings(intmat V)
 "USAGE:   intersectionValRings(intmat V);
+proc intersectionValRings(intmat V, list #)
+"USAGE:   intersectionValRings(intmat V, intvec grading);
 RETURN:   The function returns a monomial ideal, to be considered as the list
           of monomials generating @math{S} as an algebra over the coefficient
           field.
 BACKGROUND:
+BACKGROUND: @texinfo
 @tex
 A discrete monomial valuation $v$ on $R = K[X_1 ,\ldots,X_n]$ is determined by
 …
 its input.
 @end tex
+@*The function returns the ideal given by the input matrix V if one of
+the options @code{supp}, @code{triang}, or @code{hvect} has been
+activated.
+However, in this case some numerical invariants are computed, and
+some other data may be contained in files that you can read into
+Singular.
+SEE ALSO: torusInvariants, diagInvariants, finiteDiagInvariants, intersectionValRingIdeals,showNuminvs,exportNuminvs
+@end texinfo
+@*        The function returns the ideal given by the input matrix V if one of
+          the options @code{supp}, @code{triang}, @code{volume}, or
+          @code{hseries} has been activated.
+          However, in this case some numerical invariants are computed, and
+          some other data may be contained in files that you can read into
+          Singular (see @ref{showNuminvs}, @ref{exportNuminvs}).
+SEE ALSO: torusInvariants, diagInvariants, finiteDiagInvariants, intersectionValRingIdeals
 EXAMPLE:  example intersectionValRings; shows an example
+"
 …
 /*    if(!GenGen) // return V
+    {
         runNormaliz(V1,4);
+        runNormaliz(V1,4,prepareGrading(#));
         return(V);
+    }
 */
     return(intmat2mons(runNormaliz(V1,4)));
+    return(intmat2mons(runNormaliz(V1,4,prepareGrading(#))));
+}
 example
 …
+}
 proc intersectionValRingIdeals(intmat V)
+proc intersectionValRingIdeals(intmat V, list #)
 "USAGE:   intersectionValRingIdeals(intmat V);
+          intersectionValRingIdeals(intmat V, intvec grading);
 RETURN:   The function returns two ideals, both to be considered as lists of
           monomials which generate an algebra over the coefficient field. The
+          monomials. The
           first is the system of monomial generators of @math{S}, the second
           the system of generators of @math{M}.
 …
           some other data may be contained in files that you can read into
           Singular (see @ref{showNuminvs}, @ref{exportNuminvs}).
 BACKGROUND:
+BACKGROUND: @texinfo
 @tex
 A discrete monomial valuation $v$ on $R = K[X_1 ,\ldots,X_n]$ is determined by
 …
 The numbers $w_i$ form the $(n+1)$th column of the input matrix.
 @end tex
+@end texinfo
 NOTE:   The function also gives an error message if the matrix V has the
         wrong number of columns.
 …
     string dummy=collectNmzOptions();  // only to set GenGen
     intmat nmz_data=runNormaliz(V1,4);
+    intmat nmz_data=runNormaliz(V1,4,prepareGrading(#));
     ideal I1=intmat2monsSel(nmz_data,0);

Singular/LIB/primdec.lib

-                      r4083fa
+                      rca3864
         for(@n=1;@n<=size(lres0) div 2;@n++)
+        {
+          if(specialIdealsEqual(lres0[2*@n-1],lres0[2*@n])==1)
+          {
+            lres0[2*@n-1]=groebner(lres0[2*@n-1]);
+            lres0[2*@n]=lres0[2*@n-1];
+            attrib(lres0[2*@n],"isSB",1);
+          }
+          else
+          {
+            lres0[2*@n-1]=groebner(lres0[2*@n-1]);
+            lres0[2*@n]=groebner(lres0[2*@n]);
+          }
+          lres0[2*@n-1]=groebner(lres0[2*@n-1]);
+          lres0[2*@n]=groebner(lres0[2*@n]);
+        }
+      }
 …
     rl[1]=list(p,
             list(rl2[nnp+1..nvars(basering)]),
             list(list("lp",1:(nvars(basering)-nnp))),
             ideal(0));
+            list(list("lp",1:(nvars(basering)-nnp))),
+            ideal(0));
     rl[2]=list(rl2[1..nnp]);
     rl[3]=list(list(order,1:nnp),list("C",0));
 …
+  {
     if (typeof(rl[1])=="list")
+    list rl1=rl[1];
+    list rl2=rl[2];
+    rl1[1]=list(rl1[1][1],
+            rl[1][2]+list(rl2[nnp+1..nvars(basering)]),
+            list(list("lp",1:(size(rl[1][2])+nvars(basering)-nnp))),
+            ideal(0));
+    rl[1]=rl1;
+    rl[2]=list(rl2[1..nnp]);
+    rl[3]=list(list(order,1:nnp),list("C",0));
+  }
+    {
+        list rl1=rl[1];
+        list rl2=rl[2];
+        rl1=list(rl1[1][1],
+                rl[1][2]+list(rl2[nnp+1..nvars(basering)]),
+                list(list("lp",1:(size(rl[1][2])+nvars(basering)-nnp))),
+                ideal(0));
+        rl[1]=rl1;
+        rl[2]=list(rl2[1..nnp]);
+        rl[3]=list(list(order,1:nnp),list("C",0));
+    }
+    else
+    {
+        ERROR("Unexpected case in prepareQuotientring. Please inform the authors");
+    }
+  }
   def quotring=ring(rl);
   return(quotring);
 …
    i=qr[1];
+   execute ("ring gnir = ("+charstr(basering)+"),("+varstr(basering)+"),("
+             +ordstr(basering)+");");
+   def gnir=ring(ringlist(@P));
+   setring gnir;
    ideal i=fetch(@P,i);
 …
                                 &&(find(ordstr(basering),"s")==0))
+  {
      execute("ring gnir = ("+charstr(basering)+"),("+varstr(basering)+"),("
                               +ordstr(basering)+");");
+     def gnir=ring(ringlist(basering));
+     setring gnir;
      ideal i=imap(P,i);
      ideal j=i;
 …
                                 &&(find(ordstr(basering),"s")==0))
+  {
      execute("ring gnir = ("+charstr(basering)+"),("+varstr(basering)+"),("
                               +ordstr(basering)+");");
+     def gnir=ring(ringlist(basering));
+     setring gnir;
      ideal i=imap(P,i);
      ideal j=i;
 …
    ASSUME(0, not isQuotientRing(basering) ) ;
    ASSUME(0, hasGlobalOrdering(basering) ) ;
+// the really needed things:
+   ASSUME(1, typeof(ringlist(basering)[1])=="list"); // in alg. extension
 //reduces primery decomposition over algebraic extensions to
 …
+   }
 //---Ende Provisorium
+   string mp="poly @p="+string(minpoly)+";";
+   string gnir="ring RH="+string(char(R))+",("+varstr(R)+","+string(par(1))
+                +"),dp;";
+   execute(gnir);
+   execute(mp);
+   list R_l=ringlist(R);
+   ideal @p=R_l[1][4]; // minpoly
+   R_l[2]=R_l[2]+R_l[1][2]; // vars
+   R_l[1]=R_l[1][1];  // char
+   R_l[3]=list(list("dp",1:size(R_l[2])),list("C",0)); // ord
+   def RH=ring(R_l); kill R_l;setring RH;
+   ideal @pp=imap(R,@p); poly @p=@pp[1];
    ideal i=imap(R,i);
    ideal I=subst(i,var(nvars(basering)),0);
 …
      setring R;
      kill RH;
+     kill gnir;
+     string gnir="ring RH="+string(char(R))+",("+varstr(R)+"),dp;";
+     execute(gnir);
+     // remove extension, set order to dp:
+     list R_l=ringlist(R);
+     R_l[1]=R_l[1][1]; // char
+     R_l[3]=list(list("dp",1:nvars(R)),list("C",0)); // ord
+     def RH=ring(R_l); kill R_l; setring RH;
      ideal i=imap(R,i);
      ideal J;
 …
    if(n<nvars(basering))
+   {
+      gnir="ring RS="+string(char(R))+",("+varstr(RH)
+                +"),(dp("+string(n)+"),lp);";
+      execute(gnir);
+      // remove extension, set order to dp(n),lp:
+      list R_l=ringlist(basering);
+      if (typeof(R_l[1])=="list") { R_l[1]=R_l[1][1]; }
+      R_l[3]=list(list("dp",1:n),list("lp",1:(nvars(basering)-n)),list("C",0));
+      def RS=ring(R_l); kill R_l; setring RS;
       list pr=imap(RH,pr);
       ideal K;
 …
   if(ordstr(@P)[1]=="w")
+  {
+    execute("ring @Phelp=("+charstr(gnir)+"),("+varstr(gnir)+"),("+ordstr(@P)+");");
+    list gnir_l=ringlist(gnir);
+    list @P_l=ringlist(@P);
+    gnir_l[3]=@P_l[3]; // ord
+    def @Phelp=ring(gnir_l);
+    setring @Phelp;
+    kill gnir_l,@P_l;
+  }
   else
 …
     //change the ring
+    {
       execute("ring gnir1 = ("+charstr(basering)+"),("+varstr(basering)+"),("
                               +ordstr(basering)+");");
+      def gnir1=ring(ringlist(basering));
+      setring gnir1;
       ideal @j=fetch(gnir,@j);
       attrib(@j,"isSB",1);
 …
            //change the ring
+        {
           execute("ring gnir1 = ("+charstr(basering)+"),("+
                varstr(basering)+"),("+ordstr(basering)+");");
+          def gnir1=ring(ringlist(basering));
+          setring gnir1;
           ideal @j=fetch(gnir,jkeep);
           attrib(@j,"isSB",1);
 …
 ///////////////////////////////////////////////////////////////////////////////
  proc zeroRad(ideal I,list #)
+proc zeroRad(ideal I,list #)
 "USAGE:  zeroRad(I) , I a zero-dimensional ideal
  RETURN: the radical of I
  NOTE:  Algorithm of Kemper
+ EXAMPLE: example zeroRad; shows an example
+RETURN: the radical of I
+NOTE:  Algorithm of Kemper
+EXAMPLE: example zeroRad; shows an example"
+{
    ASSUME(0, hasFieldCoefficient(basering) );
 …
    for(i=1;i<=n;i++)
+   {
       l[i]=sep(F[i],i);
       F[i]=l[i][1];
       if(l[i][2]>k){k=l[i][2];}  //computation of the maximal k
+     l[i]=sep(F[i],i);
+     F[i]=l[i][1];
+     if(l[i][2]>k){k=l[i][2];}  //computation of the maximal k
+   }
    if((k==0)||(m==0)) //the separable case
+   {
+    intvec save=option(get);option(redSB);
+    I=interred(I+F);option(set,save);return(I);
+     intvec save=option(get);
+     option(redSB);
+     I=interred(I+F);
+     option(set,save);
+     return(I);
+   }
    //I=simplify(I,1);
 …
    ideal F=imap(R,F);
+   string nR1="ring @S1="+string(p)+",("+varstr(R)+","+parstr(R)+",@y(1..m)),dp;";
+   execute(nR1);
+   list lR=ringlist(@S1)[2];
+   lR=lR[(size(lR)-m+1)..(size(lR))];
+   string nR="ring @S="+string(p)+",("+string(lR)+","+varstr(R)+","+parstr(R)+"),dp;";
+   string nR="ring @S="+string(p)+",(@y(1..m),"+varstr(R)+","+parstr(R)+"),dp;";
    execute(nR);
 …
    for(i=1;i<=m;i++)
+   {
       J=J,var(i)^k-var(m+n+i);
       el=el*var(i);
+     J=J,var(i)^k-var(m+n+i);
+     el=el*var(i);
+   }
 …
   if(n < 0)
+    {
+      ideal ann = ideal(1);
+      return(ann);
+    }
+  {
+    return(ideal(1));
+  }
   int l = size(re);
   if(n < l)
+    {
+      matrix f = transpose(re[n+1]);
+      if(n == 0)
+        {
+          matrix g = 0*gen(ncols(f));
+        }
+      else
+        {
+          matrix g = transpose(re[n]);
+        }
+      module k = syz(f);
+      ideal ann = quotient1(g,k);
+      return(ann);
+    }
+  {
+    matrix f = transpose(re[n+1]);
+    if(n == 0)
+    {
+      matrix g = matrix(0,1,ncols(f));
+    }
+    else
+    {
+      matrix g = transpose(re[n]);
+    }
+    module k = syz(f);
+    return(quotient1(g,k));
+  }
   if(n == l)
+    {
+      ideal ann = Ann(transpose(re[n]));
+      return(ann);
+    }
+  ideal ann = ideal(1);
+  return(ann);
+  {
+    return(Ann(transpose(re[n])));
+  }
+  return(ideal(1));
+}
 ///////////////////////////////////////////////////////////////////////////////
 …
     //change the ring
+    {
       execute("ring gnir1 = ("+charstr(basering)+"),("+varstr(basering)+"),("
                               +ordstr(basering)+");");
+      def gnir1=ring(ringlist(basering));
+      setring gnir1;
       ideal @j = fetch(@P, I);
       attrib(@j, "isSB", 1);
 …
   matrix n=imap(R,n);
   time = timer;
   poly charpol=det(n-T*freemodule(d));
+  poly charpol=det(n-var(1)*freemodule(d));
   dbprint(printlevel-voice+2,"// time for computing char poly: "+
          string(timer-time));
 …
     option(redSB);
     list re1;
     ideal new = T-imap(R,p),imap(R,J);
+    ideal new = var(1)-imap(R,p),imap(R,J);
     attrib(new, "isSB",1);    //we know that new is a standard basis
     for(j=1;j<=f;j++)
 …
   op@P = option(get);
+  execute("ring gnir = ("+charstr(basering)+"),("+varstr(basering)+"),(C,lp);");
+  def gnir=changeordTo(basering,"lp");
+  setring gnir;
   op=option(get);
 …
       if (intersectOption == "intersect")
+      {
        list pr = result[1];
        ideal intersection = result[2];
+        list pr = result[1];
+        ideal intersection = result[2];
+      }
       else
 …
   if(ordstr(@P)[1]=="w")
+  {
+    execute("ring @Phelp=("+charstr(gnir)+"),("+varstr(gnir)+"),("+ordstr(@P)+");");
+    def @Phelp=ring(ringlist(gnir));
+    setring @Phelp;
+  }
   else
+  {
+    execute( "ring @Phelp=("+charstr(gnir)+"),("+varstr(gnir)+"),(C,dp);");
+    def @Phelp=changeordTo(gnir,"dp");
+    setring @Phelp;
+  }
 …
            //change the ring
+           {
               execute("ring gnir1 = ("+charstr(basering)+"),("+
                 varstr(basering)+"),("+ordstr(basering)+");");
+              def gnir1=ring(ringlist(basering));
+              setring gnir1;
               ideal @j=fetch(gnir,jkeep);
               attrib(@j,"isSB",1);
 …
    //change the ring
+   {
      execute("ring gnir1 = ("+charstr(basering)+"),("+varstr(basering)+"),("
                               +ordstr(basering)+");");
+     def gnir1=ring(ringlist(basering));
+     setring gnir1;
      ideal @j = fetch(gnir, @j);
      attrib(@j,"isSB",1);

Singular/LIB/ring.lib

-                      r4083fa
+                      rca3864
  isQuotientRing(rng)      ring is a qotient ring
  isSubModule(I,J)         check if I is in J as submodule
+ changeordTo(r,o)         change the ordering of a ring to a simple one
+ addvarsTo(r,vars,i)      add variables to a ring
+ addNvarsTo(r,N,name,i)   add N variables to a ring
 ";
 …
 proc changeordTo(def r,string o)
+"USAGE:  changeordTo(ring, string s);
+RETURN:  a ring with the oderinging changed to the (simple) ordering s
+EXAMPLE: example changeordTo(); shows an example
+"
+{
   list rl=ringlist(r);
 …
 example
+{
+  "EXAMPLE:"; echo = 2;
   ring r=0,(x,y),lp;
   def rr=changeordToCdp(r,"dp");
+  def rr=changeordTo(r,"dp");
   rr;
+}
+proc addvarsTo(def r,list vars,int blockorder)
+"USAGE:  addvarsTo(ring,list_of_strings, int);
+         int may be: 0:ordering: dp
+:ordering dp,dp
+:oring.ordering,dp
+RETURN:  a ring with the addtional variables
+EXAMPLE: example addvarsTo(); shows an example
+"
+{
+  list rl=ringlist(r);
+  int n=nvars(r);
+  rl[2]=rl[2]+vars;
+  if (blockorder==0)
+  {
+    rl[3]=list(list("C",0),list("dp",1:(nvars(r)+size(vars))));
+  }
+  else
+  {
+    if (blockorder==2)
+    {
+      rl[3]=rl[3]+list(list("dp",1:size(vars)));
+    }
+    else
+    {
+      rl[3]=list(list("C",0),list("dp",1:nvars(r)),list("dp",1:size(vars)));
+    }
+  }
+  def rr=ring(rl);
+  return(rr);
+}
+example
+{
+  "EXAMPLE:"; echo = 2;
+  ring r=0,(x,y),lp;
+  def rr=addvarsTo(r,list("a","b"),0);
+  rr; kill rr;
+  def rr=addvarsTo(r,list("a","b"),1);
+  rr; kill rr;
+  def rr=addvarsTo(r,list("a","b"),2);
+  rr;
+}
+proc addNvarsTo(def r,int N,string n,int blockorder)
+"USAGE:  addNvarsTo(ring,int N, string name, int b);
+         b may be: 0:ordering: dp
+:ordering dp,dp
+:oring.ordering,dp
+RETURN:  a ring with N addtional variables
+EXAMPLE: example addNvarsTo(); shows an example
+"
+{
+  list v;
+  for(int i=N;i>0;i--) { v[i]=n+"("+string(i)+")"; }
+  return(addvarsTo(r,v,blockorder));
+}
+example
+{
+  "EXAMPLE:"; echo = 2;
+  ring r=0,(x,y),lp;
+  def rr=addNvarsTo(r,2,"@",0);
+  rr; kill rr;
+  def rr=addNvarsTo(r,2,"@",1);
+  rr; kill rr;
+  def rr=addNvarsTo(r,2,"@",2);
+  rr;
+}

Singular/LIB/rinvar.lib

-                      r4083fa
+                      rca3864
 LIB "elim.lib";
 LIB "zeroset.lib";
+LIB "ring.lib";
 ///////////////////////////////////////////////////////////////////////////////
 …
   int i, dbPrt, nrNewVars;
   intvec wt, wth, hs1;
-  string ringSTR1, ringSTR2, order;
   def RARB = basering;
   nrNewVars = size(F);
+  nrNewVars = ncols(F);
   dbPrt = printlevel-voice+2;
 …
   string @mPoly = string(minpoly);
+  order = "(dp(" + string(nvars(basering)) + "), dp);";
+  ringSTR1 = "ring RAR1 = (" + charstr(basering) + "), (" + varstr(basering) + ", Y(1.." + string(nrNewVars) + ")), " + order;
+  ringSTR2 = "ring RAR2 = (" + charstr(basering) + "), Y(1.." + string(nrNewVars) + "), dp;";
+  execute(ringSTR1);
+  execute("minpoly = number(" + @mPoly + ");");
+  def RAR1=addNvarsTo(basering,nrNewVars,"Y",1); setring RAR1;
+  string ringSTR2 = "ring RAR2 = (" + charstr(basering) + "), Y(1.." + string(nrNewVars) + "), dp;";
   ideal I, J1, J2, Fm;

Singular/LIB/rwalk.lib

Property mode changed from 100644 to 100755

-                      r4e3305
+                      rca3864
 rwalk(ideal,int,int[,intvec,intvec]);   standard basis of ideal via Random Walk algorithm
 rwalk(ideal,int[,intvec,intvec]);       standard basis of ideal via Random Perturbation Walk algorithm
 frwalk(ideal,int[,intvec,intvec]);      standard basis of ideal via Random Fractal Walk algorithm
+frandwalk(ideal,int[,intvec,intvec]);      standard basis of ideal via Random Fractal Walk algorithm
 ";
 …
  * Random Walk  *
  ****************/
 proc rwalk(ideal Go, int radius, int pert_deg, list #)
+proc rwalk(ideal Go, int radius, int pert_deg, int reduction, int printout, list #)
 "SYNTAX: rwalk(ideal i, int radius);
          if size(#)>0 then rwalk(ideal i, int radius, intvec v, intvec w);
+         intermediate Groebner bases are not reduced if reduction = 0
 TYPE:    ideal
 PURPOSE: compute the standard basis of the ideal, calculated via
 …
 ideal G = fetch(xR, Go);
 G = system("Mrwalk", G, curr_weight, target_weight, radius, pert_deg, basering);
+G = system("Mrwalk", G, curr_weight, target_weight, radius, pert_deg, reduction, printout);
 setring xR;
 …
   int radius = 1;
   int perturb_deg = 2;
+  rwalk(I,radius,perturb_deg);
+  int reduction = 0;
+  int printout = 1;
+  rwalk(I,radius,perturb_deg,reduction,printout);
+}
 …
  * Perturbation Walk with random element *
  *****************************************/
 proc prwalk(ideal Go, int radius, int o_pert_deg, int t_pert_deg, list #)
+proc prwalk(ideal Go, int radius, int o_pert_deg, int t_pert_deg, int reduction, int printout, list #)
 "SYNTAX: rwalk(ideal i, int radius);
          if size(#)>0 then rwalk(ideal i, int radius, intvec v, intvec w);
 …
   OSCTW= OrderStringalp_NP("al", #);
+  }
+int nP = OSCTW[1];
 string ord_str = OSCTW[2];
 intvec curr_weight = OSCTW[3]; // original weight vector
 …
 ideal G = fetch(xR, Go);
+G = system("Mprwalk", G, curr_weight, target_weight, radius, o_pert_deg, t_pert_deg, basering);
+G = system("Mprwalk", G, curr_weight, target_weight, radius, o_pert_deg, t_pert_deg,
+           nP, reduction, printout);
 setring xR;
 …
   int o_perturb_deg = 2;
   int t_perturb_deg = 2;
+  prwalk(I,radius,o_perturb_deg,t_perturb_deg);
+  int reduction = 0;
+  int printout = 2;
+  prwalk(I,radius,o_perturb_deg,t_perturb_deg,reduction,printout);
+}
 …
  * Fractal Walk with random element *
  ************************************/
 proc frandwalk(ideal Go, int radius, list #)
 "SYNTAX: frwalk(ideal i, int radius);
          frwalk(ideal i, int radius, intvec v, intvec w);
+proc frandwalk(ideal Go, int radius, int reduction, int printout, list #)
+"SYNTAX: frwalk(ideal i, int radius, int reduction, int printout);
+         frwalk(ideal i, int radius, int reduction, int printout, intvec v, intvec w);
 TYPE:    ideal
 PURPOSE: compute the standard basis of the ideal, calculated via
 …
    ideal G = fetch(xR, Go);
    int pert_deg = 2;
+   G = system("Mfrwalk", G, curr_weight, target_weight, radius);
+   G = system("Mfrwalk", G, curr_weight, target_weight, radius, reduction, printout);
    setring xR;
 …
     ring r = 0,(z,y,x), lp;
     ideal I = y3+xyz+y2z+xz3, 3+xy+x2y+y2z;
+    frandwalk(I,2);
+}
+    int reduction = 0;
+    frandwalk(I,2,0,1);
+}

Singular/LIB/sagbi.lib

-                      r4083fa
+                      rca3864
 LIB "toric.lib";
 LIB "algebra.lib";
+LIB "ring.lib";
 //////////////////////////////////////////////////////////////////////////////
 …
     //------------- change the basering bsr to bsr[@(0),...,@(z)] ----------
     execute("ring s=("+charstr(basering)+"),("+varstr(basering)+",@(0..z)),dp;");
+    def s=addNvarsTo(basering,z+1,,"@",0); setring s;
     // Ev hier die Reihenfolge der Vars aendern. Dazu muss unten aber entsprechend
     // geaendert werden:

Singular/LIB/schreyer.lib

-                      r4083fa
+                      rca3864
+  }
+  int @IS_A_SB = attrib(M, "isSB"); // ??? only if all weights were zero?!
+  if( !@IS_A_SB )
+  {
+    def opts = option(get);
+    option(redSB); option(redTail);
+    M = std(M);
+    option(set, opts);
+    kill opts;
+  }
+  M = simplify(M, 1 + 2 + 4 + 32);
+  def opts = option(get);
+  option(redSB); option(redTail);
+    M = simplify(interred(groebner(M)), 1 + 2 + 4 + 32); // NOTE: we require interreduced GB for input
+  option(set, opts); kill opts;
+//  int @IS_A_SB = attrib(M, "isSB");  if( !@IS_A_SB )  {  } else  {  }
+// attrib(M, "isSB", 1);
   if( @IGNORETAILS )
 …
     attrib(S, "HYBRIDNF", 0);
+  }
+  if( typeof( attrib(SSinit, "NOCACHING") ) == "int" )
+  {
+    attrib(S, "NOCACHING", attrib(SSinit, "NOCACHING") );
+  } else
+  {
+    attrib(S, "NOCACHING", 0);
+  }
   // maybe resetting existing ring attributes!
 …
   if(size(#) > 0) { DEBUG = #[1]; }
+  def TREE = 0;
+  if(size(#) > 1) { TREE = #[2]; }
   system("--min-time", "0.01");
   system("--ticks-per-sec", 100);
 …
   attrib(SSinit, "KERCHECK", (DEBUG > 0) );
   attrib(SSinit, "TREEOUTPUT", 0);
+  attrib(SSinit, "TREEOUTPUT", TREE);
   attrib(SSinit, "PROFILE", 0);
   attrib(SSinit, "IGNORETAILS", 0); // not only frame
+  attrib(SSinit, "NOCACHING", 0);
   int @treeout = attrib(SSinit, "TREEOUTPUT");
 …
   M = a*b+7*a*c-16*b*c-27*a*d+37*b*d-2*c*d, d^3, c*d^2, b*d^2, a*d^2, c^2*d, b*c*d, a*c*d, b^2*d, a^2*d, c^3, b*c^2, a*c^2, b^2*c, a^2*c, b^3, a^3;
   TestSSresAttribs(M, "medium: AGR@101n3d004s009%1");
+  kill AGR;
+  string Name = "bordiga"; int @p=31991; ring R = (@p),(x,y,z,u,v), dp;
+  ideal I = -x2y+26/17xy2+70/17y3+96/121x2z+63/82xyz+115/11y2z-8114xz2-40/79yz2+16/125z3+3023x2u-123/70xyu+3395y2u-81/119xzu-23/66yzu+3626z2u+18/53xu2+111/58yu2-34/39zu2+53/40u3-94/17x2v-10/19xyv+81/88y2v-91/33xzv-9967yzv-103/4z2v-26/109xuv+69/97yuv+92/17zuv-19/96u2v+10/21xv2+6147yv2+32/113zv2-79/82uv2-77/51v3,4347x2y-9017xy2+11327y3+18/79x2z-93/43xyz-35/47y2z+14704xz2+10727yz2-1764z3-612x2u+20/107xyu-103/89y2u-39/2xzu+2345yzu+10251z2u-9984xu2-10299yu2+113/118zu2+37/91u3+2/31x2v+9552xyv-47/100y2v-3242xzv+113/27yzv-11271z2v-13/79xuv+15917yuv+5/114zuv+103/119u2v-21/55xv2-59/19yv2+101/68zv2-7817uv2-112/29v3,7228x2y-111/113xy2+5913y3+6/43x2z-11251xyz+27/121y2z+97/96xz2-7398yz2-97/114z3+38/15x2u+5005xyu-41/126y2u-61/116xzu+89/9yzu-4087z2u+26/15xu2-92/103yu2+21/68zu2-4027u3+97/91x2v+5150xyv-4/47y2v-2310xzv+7307yzv-77/86z2v+30/83xuv+413yuv-50zuv-103/106u2v+105/73xv2-109/98yv2+59/63zv2+715uv2+963v3,x3+3487x2y-9744xy2-13276y3-15213x2z-118/51xyz+101/104y2z+2754xz2+9111yz2-17/94z3+11136x2u-43/82xyu-9/41y2u-7306xzu-6839yzu+5692z2u-14682xu2+37/80yu2-85/97zu2-6186u3+34/15x2v+84/109xyv+5086y2v+27/112xzv-3/40yzv+19/120z2v+11222xuv+38/55yuv-24/83zuv+15814u2v-111/61xv2+49/44yv2+125/81zv2+1933uv2-19/71v3;
+  TestSSresAttribs(I, Name);
+  kill @p, Name, R;
+  string Name = "rat.d8.g6"; int @p=31991; ring R = (@p),(x,y,z,u,v), dp;
+  ideal I = -19/125x2y2-87/119xy3-97/21y4+36/53x2yz+2069xy2z-59/50y3z-65/33x2z2-14322xyz2+79/60y2z2-9035xz3-14890yz3+87/47z4-23/48x2yu+45/44xy2u+1972y3u+79/118x2zu-5173xyzu+115/121y2zu+1239xz2u-115/17yz2u-15900z3u-78/95x2u2+67/101xyu2-12757y2u2+12752xzu2+68/21yzu2+103/90z2u2-12917xu3+97/92yu3-24/49zu3-13/79u4-51/61x2yv-3103xy2v+77/117y3v+73/115x2zv-79/33xyzv+123/110y2zv+11969xz2v-31/95yz2v-123/95z3v-105/124x2uv+12624xyuv+2/63y2uv+6579xzuv+13/62yzuv+4388z2uv-12747xu2v-26/105yu2v-78/61zu2v-125/53u3v-5/71xyv2+62/77y2v2+21/44xzv2-9806yzv2+3/91z2v2+361xuv2+568yuv2+2926zuv2+53/38u2v2-14523yv3+2082zv3+113/115uv3,108/73x2y2+4028xy3+38/43y4-1944x2yz+39/80xy2z+8/109y3z+52/27x2z2+103/45xyz2+5834y2z2+63/101xz3+107/80yz3+1178z4-1/6x2yu+78/25xy2u-21/43y3u+50/71x2zu-14693xyzu+15074y2zu+9/103xz2u-7396yz2u-14493z3u+93/25x2u2+61/4xyu2-11306y2u2-79/81xzu2+59/82yzu2-5/106z2u2+89/71xu3-34/11yu3+15/103zu3-115/52u4-54/65x2yv+67/16xy2v-7/68y3v-10/13x2zv+32/85xyzv+1/91y2zv+107/118xz2v+7594yz2v-98/103z3v+9919x2uv-965xyuv+53/34y2uv+119/11xzuv-3400yzuv-8329z2uv+75/98xu2v-24yu2v+55/87zu2v-82/71u3v-73/115x2v2+85/19xyv2-213y2v2-7704xzv2-15347yzv2+14960z2v2+15065xuv2-125/17yuv2+32/83zuv2-14/73u2v2-21/44xv3+79/2yv3-61/32zv3+46/119uv3-2082v4,9/20x2y2+113/71xy3-88/65y4+9983x2yz-6722xy2z+87/68y3z+1893x2z2+65/32xyz2+51/55y2z2-102/53xz3+58/5yz3-7187z4-96/7x2yu-14/87xy2u-3532y3u+95/54x2zu+19/65xyzu-6728y2zu+31/121xz2u+73/106yz2u-91/5z3u-12928x2u2+707xyu2-55/48y2u2-96/25xzu2+15869yzu2-20/107z2u2-10030xu3-13786yu3-122/9zu3+19/59u4-7/52x2yv+101/74xy2v+83/6y3v-91/55x2zv-5266xyzv+85/61y2zv+126/95xz2v+56/51yz2v+13073z3v-50/21x2uv-13553xyuv-116/53y2uv+68/71xzuv-111/98yzuv-11037z2uv+68/121xu2v-124/53yu2v+54/55zu2v+5862u3v+12318x2v2-119/29xyv2+101/17y2v2-51/40xzv2-82/33yzv2-30/41z2v2-29/52xuv2+7817yuv2+8121zuv2-28/99u2v2+1125xv3-73/55yv3-14141zv3+8742uv3-1203v4,x2y2+11357xy3+295y4+144x2yz-31/54xy2z+89/119y3z+1/46x2z2+29/26xyz2+1384y2z2+1461xz3+113/91yz3+9494z4-7/32x2yu+12850xy2u-3626y3u-33/106x2zu-7/60xyzu-5935y2zu-8597xz2u+5527yz2u+1708z3u+6182x2u2-15780xyu2+4669y2u2-38/69xzu2+8412yzu2+9265z2u2-5679xu3-67/18yu3-34/67zu3-7178u4+113/56x2yv-3669xy2v+17/113y3v-87/35x2zv-4871xyzv-111/11y2zv-1131xz2v-72/13yz2v+838z3v-115/4x2uv+3395xyuv-43/68y2uv-82/13xzuv+7042yzuv-88/119z2uv+100/19xu2v+24/11yu2v+89/3zu2v+7395u3v-119/109x2v2+1/104xyv2+18/25y2v2+700xzv2-59/9yzv2-92/87z2v2+2486xuv2-67/103yuv2+1469zuv2-101/91u2v2-79/33xv3+10838yv3+81/4zv3-11843uv3+7204v4,19/125x3-15698x2y-22/117xy2-95/107y3+2027x2z-7750xyz+85/104y2z-15326xz2+31/101yz2+67/81z3-7879x2u-112/115xyu+124/81y2u+99/61xzu-7458yzu+40/33z2u-1502xu2+6591yu2-7/73zu2-42/95u3+93/83x2v-15/112xyv-84/95y2v+35/36xzv+5/24yzv-12768z2v+13232xuv-76/103yuv-79/52zuv-7217u2v+75/92xv2-49/64yv2+17/14zv2-6109uv2+1695v3;
+  TestSSresAttribs(I, Name);
+  kill R, Name, @p;
   if( @treeout)

Singular/LIB/solve.lib

-                      r4083fa
+                      rca3864
 LIB "triang.lib";    // needed for triang_solve
+LIB "ring.lib";      // needed for changeordTo
 ///////////////////////////////////////////////////////////////////////////////
 …
     if (sb==0)
+    {
+      execute("ring dphom=("+charstr(rin)+"),("+
+      varstr(rin)+"),dp;");
+      def dphom=changeordTo(rin,"dp"); setring dphom;
       ideal G = std(imap(rin,G));
       if (dim(G)!=0){ERROR("ideal not zero-dimensional");}
 …
     if (sb==0)
+    {
       execute("ring dphilb=("+charstr(rin)+"),("+ varstr(rin)+"),dp;");
+      def dphilb=changeordTo(rin,"dp"); setring dphilb;
       ideal G = imap(rin,G);
       G = std(G);
 …
       attrib(G,"isSB",1);
+    }
     execute("ring lexhilb=("+charstr(rin)+"),("+ varstr(rin)+"),lp;");
+    def lexhilb=changeordTo(rin,"lp"); setring lexhilb;
     option(redTail);
     ideal H = fglm(dphilb,G);
 …
     else
+    {
       execute("ring lplex=("+charstr(rin)+"),("+varstr(rin)+"),lp;");
+      def lplex=changeordTo(rin,"lp"); setring lplex;
+    }
     ideal H = imap(lexhilb,H);

Singular/LIB/swalk.lib

Property mode changed from 100644 to 100755

Singular/LIB/tropical.lib

-                      r4083fa
+                      rca3864
 LIB "absfact.lib";
 LIB "hnoether.lib";
+LIB "ring.lib";
 //////////////////////////////////////////////////////////////////////////////
 …
+  {
     def GLOBALRING=basering;
     number mp=minpoly;
     execute("ring LOCALRING=("+charstr(basering)+"),("+varstr(basering)+"),ds;");
+    def LOCALRING=changeordTo(GLOBALRING,"ds");
+    setring LOCALRING;
     poly f=imap(GLOBALRING,f);
-    minpoly=imap(GLOBALRING,mp);
+  }
   // check if a substitution is necessary
 …
 NOTE:        the procedure is called by texDrawTropical"
+{
   execute("ring REALRING=(real,50,100),x,lp;");
+  ring REALRING=(real,50,100),x,lp;
   execute("number aa,bb,cc="+AA[1]+","+AA[2]+","+AA[3]+";");
   number ascale,bscale=1,1;
 …
 NOTE:        the procedure is called by texDrawTropical"
+{
   execute("ring REALRING=(real,50,100),x,lp;");
+  ring REALRING=(real,50,100),x,lp;
   execute("poly aa,bb="+a+","+b+";");
   if (aa<bb)

Singular/dyn_modules/Order/nforder_elt.cc

r4083fa	rca3864
143	143	}
144	144	/// convertion to int, 0 if impossible
145		static ~~int~~ EltInt(number &n, const coeffs r)
	145	static long EltInt(number &n, const coeffs r)
146	146
147	147	{

Singular/dyn_modules/syzextra/mod_main.cc

r4083fa	rca3864
315	315	const ring save = currRing;
316	316	const ring r = syzstr->syRing;
317		const ring rr = (r != NULL) ? r: save;
	317	// const ring rr = (r != NULL) ? r: save;
318	318
319	319

Singular/dyn_modules/syzextra/syzextra.cc

-                      r4083fa
+                      rca3864
   if( UNLIKELY( !(  (!OPT__TAILREDSYZ)   ||   m_lcm.Check(multiplier)     )) )
+  {
+    if( UNLIKELY(OPT__TAILREDSYZ && OPT__PROT) ) ++ m_stat[5]; // PrintS("%"); // check LCM !
+    if( UNLIKELY(OPT__TAILREDSYZ && OPT__PROT) )
+    {
+      ++ m_stat[5]; // PrintS("%"); // check LCM !
+#ifndef SING_NDEBUG
+      if( OPT__DEBUG )
+      {
+        PrintS("\nTT,%:"); dPrint(multiplier, r, r, 0);
+        PrintS(",  *  :"); dPrint(tail, r, r, 0);
+        PrintLn();
+      }
+#endif
+    }
     return NULL;
+  }
 …
   if( s == NULL ) // No Reducer?
+  {
+    if( UNLIKELY(OPT__TAILREDSYZ && OPT__PROT) ) ++ m_stat[5]; // PrintS("%"); // check LCM !
+    if( UNLIKELY( OPT__TAILREDSYZ && OPT__PROT) )
+    {
+      ++ m_stat[5]; // PrintS("%"); // check LCM !
+#ifndef SING_NDEBUG
+      if( OPT__DEBUG )
+      {
+        PrintS("\n%: RedTail("); dPrint(multiplier, r, r, 0);
+        PrintS(" * : "); dPrint(term4reduction, r,r,0 );
+        PrintS(", {  "); dPrint(syztermCheck,r,r,0 );
+        PrintS("  }) ");  PrintLn();
+      }
+#endif
+    }
     return NULL;
+  }
 …
     OPT__TREEOUTPUT( atGetInt(rootRingHdl, "TREEOUTPUT", 0) ),
     OPT__SYZCHECK( atGetInt(rootRingHdl, "SYZCHECK", 0) ),
+    OPT__PROT(TEST_OPT_PROT),
     OPT__NOCACHING( atGetInt(rootRingHdl, "NOCACHING", 0) ),
-    OPT__PROT(TEST_OPT_PROT),
     m_rBaseRing( rootRingHdl->data.uring )
+{

Singular/dyn_modules/syzextra/test.sh

r4083fa	rca3864
4	4	#"$SINGULAR_EXECUTABLE" -teq "$srcdir/ederc.tst" \|\| exit 1
5	5	#"$SINGULAR_EXECUTABLE" -teq "$srcdir/syzextra.tst" \|\| exit 1
6		"$SINGULAR_EXECUTABLE" -tec 'LIB "schreyer.lib"; listvar(Top); proc T(){ Schreyer::testSimple(1); /* Schreyer::testAGR(0); Schreyer::testAGRhard(0); */ } T(); $' \|\| exit 1
	6	"$SINGULAR_EXECUTABLE" -tec 'LIB "schreyer.lib"; listvar(Top); proc T(){ Schreyer::testSimple(1, 0); /* Schreyer::testAGR(0); Schreyer::testAGRhard(0); */ } T(); $' \|\| exit 1

Singular/emacs.cc

-                      r4083fa
+                      rca3864
+#include <kernel/mod2.h>
+#include <omalloc/omalloc.h>
+#include <resources/feResource.h>
+#include <Singular/feOpt.h>
 #ifdef __CYGWIN__
 #define BOOLEAN boolean
 #endif
-#include <kernel/mod2.h>
 #include <stdio.h>
 …
 #endif
-#include <omalloc/omalloc.h>
-#include <resources/feResource.h>
-#include <Singular/feOpt.h>
 #if !defined(TSINGULAR) && !defined(ESINGULAR)
 …
+}
 #else
 void error(char* fmt, ...)
+void error(const char* fmt, ...)
+{
    char buf[4096];

Singular/extra.cc

-                      r4083fa
+                      rca3864
+      {
         WerrorS("field required");
         return TRUE;
+        return TRUE;
+      }
       matrix pMat  = (matrix)h->Data();
 …
     else
   #endif
+/*==================== test64 =================*/
+  #if 0
+    if(strcmp(sys_cmd,"test64")==0)
+    {
+      long l=8;int i;
+      for(i=1;i<62;i++)
+      {
+        l=l<<1;
+        number n=n_Init(l,coeffs_BIGINT);
+        Print("%ld= ",l);n_Print(n,coeffs_BIGINT);
+        CanonicalForm nn=n_convSingNFactoryN(n,TRUE,coeffs_BIGINT);
+        n_Delete(&n,coeffs_BIGINT);
+        n=n_convFactoryNSingN(nn,coeffs_BIGINT);
+        PrintS(" F:");
+        n_Print(n,coeffs_BIGINT);
+        PrintLn();
+        n_Delete(&n,coeffs_BIGINT);
+      }
+      Print("SIZEOF_LONG=%d\n",SIZEOF_LONG);
+      return FALSE;
+    }
+    else
+   #endif
 /*==================== Error =================*/
       Werror( "(extended) system(\"%s\",...) %s", sys_cmd, feNotImplemented );

Singular/iparith.cc

-                      r4083fa
+                      rca3864
 /*=================== simple helpers =================*/
+static int iin_Int(number &n,coeffs cf)
+{
+  long l=n_Int(n,cf);
+  int i=(int)l;
+  if ((long)i==l) return l;
+  return 0;
+}
 poly pHeadProc(poly p)
+{
 …
     return TRUE;
+  }
   res->data = (char *)(long)n_Int(pGetCoeff(p),currRing->cf);
+  res->data = (char *)(long)iin_Int(pGetCoeff(p),currRing->cf);
   return FALSE;
+}
 …
+{
   number n=(number)u->CopyD(); // n_Int may call n_Normalize
   res->data=(char *)(long)n_Int(n,currRing->cf);
+  res->data=(char *)(long)iin_Int(n,currRing->cf);
   n_Delete(&n,currRing->cf);
   return FALSE;
 …
+{
   number n=(number)u->Data();
   res->data=(char *)(long)n_Int(n,coeffs_BIGINT );
+  res->data=(char *)(long)iin_Int(n,coeffs_BIGINT );
   return FALSE;
+}

Singular/ipshell.cc

-                      r4083fa
+                      rca3864
     //Print("branchTo: %s\n",h->Name());
     iiCurrProc=(idhdl)h->data;
+    err=iiAllStart(IDPROC(iiCurrProc),IDPROC(iiCurrProc)->data.s.body,BT_proc,IDPROC(iiCurrProc)->data.s.body_lineno-(iiCurrArgs==NULL));
+    procinfo * pi=IDPROC(iiCurrProc);
+    if( pi->data.s.body==NULL )
+    {
+      iiGetLibProcBuffer(pi);
+      if (pi->data.s.body==NULL) return TRUE;
+    }
+    if ((pi->pack!=NULL)&&(currPack!=pi->pack))
+    {
+      currPack=pi->pack;
+      iiCheckPack(currPack);
+      currPackHdl=packFindHdl(currPack);
+      //Print("set pack=%s\n",IDID(currPackHdl));
+    }
+    err=iiAllStart(pi,pi->data.s.body,BT_proc,pi->data.s.body_lineno-(iiCurrArgs==NULL));
     exitBuffer(BT_proc);
     if (iiCurrArgs!=NULL)
 …
         //ringtype = 1;       // Use Z/2^ch
         cf=nInitChar(n_Z2m,(void*)(long)modExponent);
         mpz_clear(modBase);
+        mpz_clear(modBase);
         omFreeSize (modBase, sizeof (mpz_t));
+      }

Singular/test.cc

r4083fa	rca3864
376	376	errorreported = 0; // reset error handling
377	377	else
378		printf("typeof returned type %d, >>%s<<\n",r1.Typ(),r1.Data());
	378	printf("typeof returned type %d, >>%s<<\n",r1.Typ(),(char*)r1.Data());
379	379
380	380	// clean up r1:

Singular/walk.cc

Property mode changed from 100644 to 100755

-                      r4e3305
+                      rca3864
 #endif
 #ifdef CHECK_IDEAL_MWALK
+//#ifdef CHECK_IDEAL_MWALK
 static void idString(ideal L, const char* st)
+{
 …
   Print(" %s;", pString(L->m[nL-1]));
+}
 #endif
+//#endif
 #if defined(CHECK_IDEAL_MWALK) || defined(ENDWALKS)
 …
+  }
   return p0;
+}
+/*****************************************************************************
+ * compute the gcd of the entries of the vectors curr_weight and diff_weight *
+ *****************************************************************************/
+static int simplify_gcd(intvec* curr_weight, intvec* diff_weight)
+{
+  int j;
+  int nRing = currRing->N;
+  int gcd_tmp = (*curr_weight)[0];
+  for (j=1; j<nRing; j++)
+  {
+    gcd_tmp = gcd(gcd_tmp, (*curr_weight)[j]);
+    if(gcd_tmp == 1)
+    {
+      break;
+    }
+  }
+  if(gcd_tmp != 1)
+  {
+    for (j=0; j<nRing; j++)
+    {
+    gcd_tmp = gcd(gcd_tmp, (*diff_weight)[j]);
+    if(gcd_tmp == 1)
+      {
+        break;
+      }
+    }
+  }
+  return gcd_tmp;
+}
 …
+}
 /*****************************************************************************
 * create a weight matrix order as intvec of an extra weight vector (a(iv),lp)*
 ******************************************************************************/
+/*********************************************************************************
+* create a weight matrix order as intvec of an extra weight vector (a(iv),M(iw)) *
+**********************************************************************************/
 intvec* MivMatrixOrderRefine(intvec* iv, intvec* iw)
+{
+<<<<<<< HEAD
+  assume((iv->length())*(iv->length()) == iw->length());
+  int i,j, nR = iv->length();
+=======
   assume(iv->length() == iw->length());
   int i, nR = iv->length();
+>>>>>>> f533f6f7667328bccb271b19b2f603aaebe41596
   intvec* ivm = new intvec(nR*nR);
 …
+  {
     (*ivm)[i] = (*iv)[i];
+    (*ivm)[i+nR] = (*iw)[i];
+  }
+  for(i=2; i<nR; i++)
+  {
+    (*ivm)[i*nR+i-2] = 1;
+  }
+  for(i=1; i<nR; i++)
+  {
+    for(j=0; j<nR; j++)
+    {
+      (*ivm)[j+i*nR] = (*iw)[j+i*nR];
+    }
+  }
   return ivm;
 …
+}
+/**************************************************************
+ * Look for the position of the smallest absolut value in vec *
+ **************************************************************/
+static int MivAbsMaxArg(intvec* vec)
+{
+  int k = MivAbsMax(vec);
+  int i=0;
+  while(1)
+  {
+    if((*vec)[i] == k || (*vec)[i] == -k)
+    {
+      break;
+    }
+    i++;
+  }
+  return i;
+}
 /**********************************************************************
  * Compute a next weight vector between curr_weight and target_weight *
 …
   int nRing = currRing->N;
   int checkRed, j, kkk, nG = IDELEMS(G);
+  int checkRed, j, nG = IDELEMS(G);
   intvec* ivtemp;
 …
   mpz_init(dcw);
-  //int tn0, tn1, tz1, ncmp, gcd_tmp, ntmp;
   int gcd_tmp;
   intvec* diff_weight = MivSub(target_weight, curr_weight);
 …
   intvec* diff_weight1 = MivSub(target_weight, curr_weight);
   poly g;
+  //poly g, gw;
   for (j=0; j<nG; j++)
+  {
 …
+    }
+  }
 //Print("\n// Alloc Size = %d \n", nRing*sizeof(mpz_t));
+  //Print("\n// Alloc Size = %d \n", nRing*sizeof(mpz_t));
   mpz_t *vec=(mpz_t*)omAlloc(nRing*sizeof(mpz_t));
+  // there is no 0<t<1 and define the next weight vector that is equal to the current weight vector
+  // there is no 0<t<1 and define the next weight vector that is equal
+  // to the current weight vector
   if(mpz_cmp(t_nenner, t_null) == 0)
+  {
 …
 #endif
+  //  BOOLEAN isdwpos;
+  // construct a new weight vector
+// construct a new weight vector and check whether vec[j] is overflow,
+// i.e. vec[j] > 2^31.
+// If vec[j] doesn't overflow, define a weight vector. Otherwise,
+// report that overflow appears. In the second case, test whether the
+// the correctness of the new vector plays an important role
   for (j=0; j<nRing; j++)
+  {
 …
+    }
+  }
+  // reduce the vector with the gcd
+  if(mpz_cmp_si(ggt,1) != 0)
+  {
+    for (j=0; j<nRing; j++)
+    {
+      mpz_divexact(vec[j], vec[j], ggt);
+    }
+  }
 #ifdef  NEXT_VECTORS_CC
   PrintS("\n// gcd of elements of the vector: ");
 …
 #endif
-/**********************************************************************
-* construct a new weight vector and check whether vec[j] is overflow, *
-* i.e. vec[j] > 2^31.                                                 *
-* If vec[j] doesn't overflow, define a weight vector. Otherwise,      *
-* report that overflow appears. In the second case, test whether the  *
-* the correctness of the new vector plays an important role           *
-**********************************************************************/
-  kkk=0;
   for(j=0; j<nRing; j++)
+    {
 …
   REDUCTION:
+  checkRed = 1;
   for (j=0; j<nRing; j++)
+  {
+    (*diff_weight)[j] = mpz_get_si(vec[j]);
+  }
+  while(MivAbsMax(diff_weight) >= 5)
+  {
+    for (j=0; j<nRing; j++)
+    {
+      if(mpz_cmp_si(ggt,1)==0)
+      {
+        (*diff_weight1)[j] = floor(0.1*(*diff_weight)[j] + 0.5);
+        // Print("\n//  vector[%d] = %d \n",j+1, (*diff_weight1)[j]);
+      }
+      else
+      {
+        mpz_divexact(vec[j], vec[j], ggt);
+        (*diff_weight1)[j] = floor(0.1*(*diff_weight)[j] + 0.5);
+        // Print("\n//  vector[%d] = %d \n",j+1, (*diff_weight1)[j]);
+      }
+/*
+      if((*diff_weight1)[j] == 0)
+      {
+        kkk = kkk + 1;
+      }
+*/
+    }
+/*
+    if(kkk > nRing - 1)
+    {
+      // diff_weight was reduced to zero
+      // Print("\n // MwalkNextWeightCC: geaenderter Vector gleich Null! \n");
+      goto TEST_OVERFLOW;
+    }
+*/
+    if(test_w_in_ConeCC(G,diff_weight1) != 0)
+    {
+      Print("\n// MwalkNextWeightCC: geaenderter vector liegt in Groebnerkegel! \n");
+      for (j=0; j<nRing; j++)
+      {
+        (*diff_weight)[j] = (*diff_weight1)[j];
+      }
+      if(MivAbsMax(diff_weight) < 5)
+      {
+        checkRed = 1;
+        goto SIMPLIFY_GCD;
+      }
+    }
+    else
+    {
+      // Print("\n// MwalkNextWeightCC: geaenderter vector liegt nicht in Groebnerkegel! \n");
+      break;
+    }
+    (*diff_weight1)[j] = mpz_get_si(vec[j]);
+  }
+  while(test_w_in_ConeCC(G,diff_weight1))
+  {
+    for(j=0; j<nRing; j++)
+    {
+      (*diff_weight)[j] = (*diff_weight1)[j];
+      mpz_set_si(vec[j], (*diff_weight)[j]);
+    }
+    for(j=0; j<nRing; j++)
+    {
+      (*diff_weight1)[j] = floor(0.1*(*diff_weight)[j] + 0.5);
+    }
+  }
+  if(MivAbsMax(diff_weight)>10000)
+  {
+    for(j=0; j<nRing; j++)
+    {
+      (*diff_weight1)[j] = (*diff_weight)[j];
+    }
+    j = 0;
+    while(test_w_in_ConeCC(G,diff_weight1))
+    {
+      (*diff_weight)[j] = (*diff_weight1)[j];
+      mpz_set_si(vec[j], (*diff_weight)[j]);
+      j = MivAbsMaxArg(diff_weight1);
+      (*diff_weight1)[j] = floor(0.1*(*diff_weight1)[j] + 0.5);
+    }
+    goto SIMPLIFY_GCD;
+  }
 …
    mpz_clear(t_null);
   if(Overflow_Error == FALSE)
+  {
     Overflow_Error = nError;
+  }
  rComplete(currRing);
   for(kkk=0; kkk<IDELEMS(G);kkk++)
+  {
     poly p=G->m[kkk];
+  rComplete(currRing);
+  for(j=0; j<IDELEMS(G); j++)
+  {
+    poly p=G->m[j];
     while(p!=NULL)
+    {
 …
+}
 /**************************************************************
+/********************************************************************
  * define and execute a new ring which order is (a(vb),a(va),lp,C)  *
  * ************************************************************/
+ * ******************************************************************/
 static void VMrHomogeneous(intvec* va, intvec* vb)
+{
 …
   //rChangeCurrRing(r);
+}
+//unused
+#if 0
 static ring VMrDefault1(intvec* va)
+{
 …
   return r;
+}
+#endif
 /****************************************************************
  * define and execute a new ring with ordering (a(va),Wp(vb),C) *
 …
     else
+    {
       rChangeCurrRing(VMrDefault(curr_weight)); //Aenderung
+      rChangeCurrRing(VMrDefault(curr_weight));
+    }
     newRing = currRing;
 …
     else
+    {
       rChangeCurrRing(VMrDefault(curr_weight)); //Aenderung
+      rChangeCurrRing(VMrDefault(curr_weight));
+    }
     newRing = currRing;
 …
     else
+    {
       rChangeCurrRing(VMrDefault(curr_weight)); // Aenderung
+      rChangeCurrRing(VMrDefault(curr_weight));
+    }
     newRing = currRing;
 …
 intvec* Xivlp;
-#if 0
-/********************************
- * compute a next weight vector *
- ********************************/
-static intvec* MWalkRandomNextWeight(ideal G, intvec* curr_weight, intvec* target_weight, int weight_rad, int pert_deg)
+{
-  int i, weight_norm;
-  int nV = currRing->N;
-  intvec* next_weight2;
-  intvec* next_weight22 = new intvec(nV);
-  intvec* next_weight = MwalkNextWeightCC(curr_weight,target_weight, G);
-  if(MivComp(next_weight, target_weight) == 1)
+  {
-    return(next_weight);
+  }
-  else
+  {
-    //compute a perturbed next weight vector "next_weight1"
-    intvec* next_weight1 = MkInterRedNextWeight(MPertVectors(G, MivMatrixOrder(curr_weight), pert_deg), target_weight, G);
-    //Print("\n // size of next_weight1 = %d", sizeof((*next_weight1)));
-    //compute a random next weight vector "next_weight2"
-    while(1)
+    {
-      weight_norm = 0;
-      while(weight_norm == 0)
+      {
-        for(i=0; i<nV; i++)
+        {
-          //Print("\n//  next_weight[%d]  = %d", i, (*next_weight)[i]);
-          (*next_weight22)[i] = rand() % 60000 - 30000;
-          weight_norm = weight_norm + (*next_weight22)[i]*(*next_weight22)[i];
+        }
-        weight_norm = 1 + floor(sqrt(weight_norm));
+      }
-      for(i=nV-1; i>=0; i--)
+      {
-        if((*next_weight22)[i] < 0)
+        {
-          (*next_weight22)[i] = 1 + (*curr_weight)[i] + floor(weight_rad*(*next_weight22)[i]/weight_norm);
+        }
-        else
+        {
-          (*next_weight22)[i] = (*curr_weight)[i] + floor(weight_rad*(*next_weight22)[i]/weight_norm);
+        }
-      //Print("\n//  next_weight22[%d]  = %d", i, (*next_weight22)[i]);
+      }
-      if(test_w_in_ConeCC(G, next_weight22) == 1)
+      {
-        //Print("\n//MWalkRandomNextWeight: next_weight2 im Kegel\n");
-        next_weight2 = MkInterRedNextWeight(next_weight22, target_weight, G);
-        delete next_weight22;
-        break;
+      }
+    }
-    intvec* result = new intvec(nV);
-    ideal G_test = MwalkInitialForm(G, next_weight);
-    ideal G_test1 = MwalkInitialForm(G, next_weight1);
-    ideal G_test2 = MwalkInitialForm(G, next_weight2);
-    // compare next_weights
-    if(IDELEMS(G_test1) < IDELEMS(G_test))
+    {
-      if(IDELEMS(G_test2) <= IDELEMS(G_test1)) // |G_test2| <= |G_test1| < |G_test|
+      {
-        for(i=0; i<nV; i++)
+        {
-          (*result)[i] = (*next_weight2)[i];
+        }
+      }
-      else // |G_test1| < |G_test|, |G_test1| < |G_test2|
+      {
-        for(i=0; i<nV; i++)
+        {
-          (*result)[i] = (*next_weight1)[i];
+        }
+      }
+    }
-    else
+    {
-      if(IDELEMS(G_test2) <= IDELEMS(G_test)) // |G_test2| <= |G_test| <= |G_test1|
+      {
-        for(i=0; i<nV; i++)
+        {
-          (*result)[i] = (*next_weight2)[i];
+        }
+      }
-      else // |G_test| <= |G_test1|, |G_test| < |G_test2|
+      {
-        for(i=0; i<nV; i++)
+        {
-          (*result)[i] = (*next_weight)[i];
+        }
+      }
+    }
-    delete next_weight;
-    delete next_weight1;
-    idDelete(&G_test);
-    idDelete(&G_test1);
-    idDelete(&G_test2);
-    if(test_w_in_ConeCC(G, result) == 1)
+    {
-      delete next_weight2;
-      return result;
+    }
-    else
+    {
-      delete result;
-      return next_weight2;
+    }
+  }
+}
-#endif
 /********************************
 …
   //compute a perturbed next weight vector "next_weight1"
-  //intvec* next_weight1 = MkInterRedNextWeight(MPertVectors(G,MivMatrixOrderRefine(curr_weight,target_weight),pert_deg),target_weight,G);
   intvec* next_weight1 =MkInterRedNextWeight(curr_weight,target_weight,G);
   //compute a random next weight vector "next_weight2"
 …
+    {
       next_weight2 = MkInterRedNextWeight(next_weight22,target_weight,G);
+      if(MivAbsMax(next_weight2)>1147483647)
+      {
+        for(i=0; i<nV; i++)
+        {
+          (*next_weight22)[i] = (*next_weight2)[i];
+        }
+        i = 0;
+        while(test_w_in_ConeCC(G,next_weight22))
+        {
+          (*next_weight2)[i] = (*next_weight22)[i];
+          i = MivAbsMaxArg(next_weight22);
+          (*next_weight22)[i] = floor(0.1*(*next_weight22)[i] + 0.5);
+        }
+      }
       delete next_weight22;
       break;
 …
     else
+    {
       rChangeCurrRing(VMrDefault(orig_target_weight)); // Aenderung
+      rChangeCurrRing(VMrDefault(orig_target_weight));
+    }
     TargetRing = currRing;
 …
     else
+    {
       rChangeCurrRing(VMrDefault(curr_weight)); // Aenderung
+      rChangeCurrRing(VMrDefault(curr_weight));
+    }
     newRing = currRing;
 …
     else
+    {
       rChangeCurrRing(VMrDefault(orig_target_weight)); // Aenderung
+      rChangeCurrRing(VMrDefault(orig_target_weight));
+    }
     F1 = idrMoveR(G, newRing,currRing);
 …
       else
+      {
         rChangeCurrRing(VMrDefault(orig_target_weight)); // Aenderung
+        rChangeCurrRing(VMrDefault(orig_target_weight));
+      }
     KSTD_Finish:
 …
       tim = clock();
       /*
         Print("\n// **** Grï¿œbnerwalk took %d steps and ", nwalk);
+        Print("\n// **** Groebnerwalk took %d steps and ", nwalk);
         PrintS("\n// **** call the rec. Pert. Walk to compute a red GB of:");
         idElements(Gomega, "G_omega");
 …
       oldRing = currRing;
       /* create a new ring newRing */
+      // create a new ring newRing
        if (rParameter(currRing) != NULL)
+       {
 …
        else
+       {
          rChangeCurrRing(VMrDefault(curr_weight)); // Aenderung
+         rChangeCurrRing(VMrDefault(curr_weight));
+       }
       newRing = currRing;
 …
       else
+      {
         rChangeCurrRing(VMrDefault(curr_weight));  //Aenderung
+        rChangeCurrRing(VMrDefault(curr_weight));
+      }
       newRing = currRing;
 …
       M=kStd(Gomega1,NULL,isHomog,NULL,hilb_func,0,NULL,curr_weight);
       delete hilb_func;
 #endif // BUCHBERGER_ALG
+#endif
       tstd = tstd + clock() - to;
 …
       to = clock();
+      // compute a representation of the generators of submod (M) with respect to those of mod (Gomega). Gomega is a reduced Groebner basis w.r.t. the current ring.
+      // compute a representation of the generators of submod (M) with respect
+      // to those of mod (Gomega).
+      // Gomega is a reduced Groebner basis w.r.t. the current ring.
       F = MLifttwoIdeal(Gomega2, M1, G);
       tlift = tlift + clock() - to;
 …
       else
+      {
         rChangeCurrRing(VMrDefault(target_weight)); // Aenderung
+        rChangeCurrRing(VMrDefault(target_weight));
+      }
       F1 = idrMoveR(G, newRing,currRing);
 …
  * THE GROEBNER WALK ALGORITHM *
  *******************************/
+ideal Mwalk(ideal Go, intvec* orig_M, intvec* target_M, ring baseRing)
+ideal Mwalk(ideal Go, intvec* orig_M, intvec* target_M,
+            ring baseRing, int reduction, int printout)
+{
+  BITSET save1 = si_opt_1; // save current options
+  //si_opt_1 &= (~Sy_bit(OPT_REDSB)); // no reduced Groebner basis
+  //si_opt_1 &= (~Sy_bit(OPT_REDTAIL)); // not tail reductions
+  //si_opt_1|=(Sy_bit(OPT_REDTAIL)|Sy_bit(OPT_REDSB));
+  // save current options
+  BITSET save1 = si_opt_1;
+  if(reduction == 0)
+  {
+    // no reduced Groebner basis
+    si_opt_1 &= (~Sy_bit(OPT_REDSB));
+    // not tail reductions
+    //si_opt_1 &= (~Sy_bit(OPT_REDTAIL));
+  }
   Set_Error(FALSE);
   Overflow_Error = FALSE;
 …
 #endif
   rComplete(currRing);
+#ifdef CHECK_IDEAL_MWALK
+    idString(Go,"Go");
+#endif
+//#ifdef CHECK_IDEAL_MWALK
+  if(printout > 2)
+  {
+    idString(Go,"//** Mwalk: Go");
+  }
+//#endif
 #ifdef TIME_TEST
   to = clock();
 #endif
+     if(orig_M->length() == nV)
+      {
+        newRing = VMrDefault(curr_weight); // define a new ring with ordering "(a(curr_weight),lp)
+      }
+      else
+      {
+        newRing = VMatrDefault(orig_M);
+      }
+  if(orig_M->length() == nV)
+  {
+    // define a new ring with ordering "(a(curr_weight),lp)
+    newRing = VMrDefault(curr_weight);
+  }
+  else
+  {
+    newRing = VMatrDefault(orig_M);
+  }
   rChangeCurrRing(newRing);
   ideal G = MstdCC(idrMoveR(Go,baseRing,currRing));
 …
     to = clock();
 #endif
+#ifdef CHECK_IDEAL_MWALK
+    idString(G,"G");
+#endif
+    Gomega = MwalkInitialForm(G, curr_weight); // compute an initial form ideal of <G> w.r.t. "curr_vector"
+//#ifdef CHECK_IDEAL_MWALK
+    if(printout > 2)
+    {
+      idString(G,"//** Mwalk: G");
+    }
+//#endif
+    // compute an initial form ideal of <G> w.r.t. "curr_vector"
+    Gomega = MwalkInitialForm(G, curr_weight);
 #ifdef TIME_TEST
+    tif = tif + clock()-to; //time for computing initial form ideal
+#endif
+#ifdef CHECK_IDEAL_MWALK
+    idString(Gomega,"Gomega");
+#endif
+    //time for computing initial form ideal
+    tif = tif + clock()-to;
+#endif
+//#ifdef CHECK_IDEAL_MWALK
+    if(printout > 1)
+    {
+      idString(Gomega,"//** Mwalk: Gomega");
+    }
+//#endif
 #ifndef  BUCHBERGER_ALG
     if(isNolVector(curr_weight) == 0)
 …
       if(orig_M->length() == nV)
+      {
+        newRing = VMrDefault(curr_weight); // define a new ring with ordering "(a(curr_weight),lp)
+        // define a new ring with ordering "(a(curr_weight),lp)
+        newRing = VMrDefault(curr_weight);
+      }
       else
 …
      if(target_M->length() == nV)
+     {
+       newRing = VMrRefine(curr_weight,target_weight); //define a new ring with ordering "(a(curr_weight),Wp(target_weight))"
+       //define a new ring with ordering "(a(curr_weight),Wp(target_weight))"
+       newRing = VMrRefine(curr_weight,target_weight);
+     }
      else
+     {
+       //define a new ring with matrix ordering
        newRing = VMatrRefine(target_M,curr_weight);
+     }
 …
 #endif
     idSkipZeroes(M);
+#ifdef CHECK_IDEAL_MWALK
+    PrintS("\n//** Mwalk: computed M.\n");
+    idString(M, "M");
+#endif
+//#ifdef CHECK_IDEAL_MWALK
+    if(printout > 2)
+    {
+      idString(M, "//** Mwalk: M");
+    }
+//#endif
     //change the ring to baseRing
     rChangeCurrRing(baseRing);
 …
     to = clock();
 #endif
+    // compute a representation of the generators of submod (M) with respect to those of mod (Gomega), where Gomega is a reduced Groebner basis w.r.t. the current ring
+    // compute a representation of the generators of submod (M) with respect to those of mod (Gomega),
+    // where Gomega is a reduced Groebner basis w.r.t. the current ring
     F = MLifttwoIdeal(Gomega2, M1, G);
 #ifdef TIME_TEST
     tlift = tlift + clock() - to;
 #endif
+#ifdef CHECK_IDEAL_MWALK
+    idString(F, "F");
+#endif
+//#ifdef CHECK_IDEAL_MWALK
+    if(printout > 2)
+    {
+      idString(F, "//** Mwalk: F");
+    }
+//#endif
     idDelete(&Gomega2);
     idDelete(&M1);
 …
     to = clock();
 #endif
+    //G = kStd(F1,NULL,testHomog,NULL,NULL,0,0,NULL);
 #ifdef TIME_TEST
     tstd = tstd + clock() - to;
 #endif
     idSkipZeroes(G);
+#ifdef CHECK_IDEAL_MWALK
+    idString(G, "G");
+#endif
+//#ifdef CHECK_IDEAL_MWALK
+    if(printout > 2)
+    {
+      idString(G, "//** Mwalk: G");
+    }
+//#endif
 #ifdef TIME_TEST
     to = clock();
 …
     tnw = tnw + clock() - to;
 #endif
+#ifdef PRINT_VECTORS
+    MivString(curr_weight, target_weight, next_weight);
+#endif
+    if(MivComp(next_weight, ivNull) == 1 || MivComp(target_weight,curr_weight) == 1)// || test_w_in_ConeCC(G, target_weight) == 1 || MivComp(next_weight,curr_weight) == 1)
+    {
+#ifdef CHECK_IDEAL_MWALK
+      PrintS("\n//** Mwalk: entering last cone.\n");
+#endif
+//#ifdef PRINT_VECTORS
+    if(printout > 0)
+    {
+      MivString(curr_weight, target_weight, next_weight);
+    }
+//#endif
+    if(MivComp(next_weight, ivNull) == 1 || MivComp(target_weight,curr_weight) == 1 || test_w_in_ConeCC(G, target_weight) == 1)
+    {
+//#ifdef CHECK_IDEAL_MWALK
+      if(printout > 0)
+      {
+        PrintS("\n//** Mwalk: entering last cone.\n");
+      }
+//#endif
       Gomega = MwalkInitialForm(G, curr_weight); // compute an initial form ideal of <G> w.r.t. "curr_vector"
       if(target_M->length() == nV)
 …
       Gomega1 = idrMoveR(Gomega, baseRing,currRing);
       idDelete(&Gomega);
+#ifdef CHECK_IDEAL_MWALK
+      idString(Gomega1, "Gomega");
+#endif
+//#ifdef CHECK_IDEAL_MWALK
+      if(printout > 1)
+      {
+        idString(Gomega1, "//** Mwalk: Gomega");
+      }
+//#endif
       M = kStd(Gomega1,NULL,testHomog,NULL,NULL,0,0,NULL);
+#ifdef CHECK_IDEAL_MWALK
+      idString(M,"M");
+#endif
+//#ifdef CHECK_IDEAL_MWALK
+      if(printout > 1)
+      {
+        idString(M,"//** Mwalk: M");
+      }
+//#endif
       rChangeCurrRing(baseRing);
       M1 =  idrMoveR(M, newRing,currRing);
 …
       idDelete(&Gomega1);
       F = MLifttwoIdeal(Gomega2, M1, G);
+#ifdef CHECK_IDEAL_MWALK
+      idString(F,"F");
+#endif
+//#ifdef CHECK_IDEAL_MWALK
+    if(printout > 2)
+    {
+      idString(F,"//** Mwalk: F");
+    }
+//#endif
       idDelete(&Gomega2);
       idDelete(&M1);
 …
       to = clock();
 #endif
+ //     if(si_opt_1 == (Sy_bit(OPT_REDSB)))
+  //    {
+        G = kInterRedCC(G,NULL); //reduce the Groebner basis <G> w.r.t. currRing, if option(redSB) is set
+  //    }
+      //interreduce the Groebner basis <G> w.r.t. currRing
+      G = kInterRedCC(G,NULL);
 #ifdef TIME_TEST
       tred = tred + clock() - to;
 …
       delete next_weight;
       break;
+#ifdef CHECK_IDEAL_MWALK
+      PrintS("\n//** Mwalk: last cone.\n");
+#endif
+    }
+#ifdef CHECK_IDEAL_MWALK
+    PrintS("\n//** Mwalk: update weight vectors.\n");
+#endif
+    }
     for(i=nV-1; i>=0; i--)
+    {
 …
   ideal result = idrMoveR(G,baseRing,currRing);
   idDelete(&G);
-/*#ifdef CHECK_IDEAL_MWALK
-  pDelete(&p);
-#endif*/
   delete tmp_weight;
   delete ivNull;
 …
 #endif
 #ifdef TIME_TEST
-  Print("\n//** Mwalk: Groebner Walk took %d steps.\n", nstep);
   TimeString(tinput, tostd, tif, tstd, tlift, tred, tnw, nstep);
-  Print("\n//** Mwalk: Ergebnis.\n");
   //Print("\n// pSetm_Error = (%d)", ErrorCheck());
   //Print("\n// Overflow_Error? (%d)\n", Overflow_Error);
 #endif
+  Print("\n//** Mwalk: Groebner Walk took %d steps.\n", nstep);
   return(result);
+}
 // 07.11.2012
+// THE RANDOM WALK ALGORITHM  ideal Go, intvec* orig_M, intvec* target_M, ring baseRing
 ideal Mrwalk(ideal Go, intvec* orig_M, intvec* target_M, int weight_rad, int pert_deg, ring baseRing)
+// THE RANDOM WALK ALGORITHM
+ideal Mrwalk(ideal Go, intvec* orig_M, intvec* target_M, int weight_rad, int pert_deg,
+             int reduction, int printout)
+{
   BITSET save1 = si_opt_1; // save current options
+  //si_opt_1 &= (~Sy_bit(OPT_REDSB)); // no reduced Groebner basis
+  //si_opt_1 &= (~Sy_bit(OPT_REDTAIL)); // not tail reductions
+  //si_opt_1|=(Sy_bit(OPT_REDTAIL)|Sy_bit(OPT_REDSB));
+  if(reduction == 0)
+  {
+    si_opt_1 &= (~Sy_bit(OPT_REDSB)); // no reduced Groebner basis
+    //si_opt_1 &= (~Sy_bit(OPT_REDTAIL)); // not tail reductions
+    //si_opt_1|=(Sy_bit(OPT_REDTAIL)|Sy_bit(OPT_REDSB));
+  }
   Set_Error(FALSE);
   Overflow_Error = FALSE;
 …
 #endif
   nstep=0;
   int i,nwalk,endwalks = 0;
   int nV = baseRing->N;
+  int i,polylength,nwalk,endwalks = 0;
+  int nV = currRing->N;
   ideal Gomega, M, F, Gomega1, Gomega2, M1; //, F1;
   ring newRing;
+  ring XXRing = baseRing;
+  ring baseRing = currRing;
+  ring XXRing = currRing;
   intvec* ivNull = new intvec(nV);
   intvec* curr_weight = new intvec(nV);
 …
   intvec* exivlp = Mivlp(nV);
   intvec* tmp_weight = new intvec(nV);
+  intvec* next_weight= new intvec(nV);
   for(i=0; i<nV; i++)
+  {
 …
 #endif
   rComplete(currRing);
-#ifdef CHECK_IDEAL_MWALK
-    idString(Go,"Go");
-#endif
 #ifdef TIME_TEST
   to = clock();
 #endif
      if(orig_M->length() == nV)
+      {
         newRing = VMrDefault(curr_weight); // define a new ring with ordering "(a(curr_weight),lp)
+      }
       else
+      {
         newRing = VMatrDefault(orig_M);
+      }
+  if(orig_M->length() == nV)
+  {
+    newRing = VMrDefault(curr_weight); // define a new ring with ordering "(a(curr_weight),lp)
+  }
+  else
+  {
+    newRing = VMatrDefault(orig_M);
+  }
   rChangeCurrRing(newRing);
   ideal G = MstdCC(idrMoveR(Go,baseRing,currRing));
 …
     to = clock();
 #endif
+#ifdef CHECK_IDEAL_MWALK
+    idString(G,"G");
+#endif
+//#ifdef CHECK_IDEAL_MWALK
+    if(printout > 2)
+    {
+      idString(G,"//** Mrwalk: G");
+    }
+//#endif
     Gomega = MwalkInitialForm(G, curr_weight); // compute an initial form ideal of <G> w.r.t. "curr_vector"
+    //polylength = 1 if there is a polynomial in Gomega with at least 3 monomials and 0 otherwise
+    polylength = lengthpoly(Gomega);
 #ifdef TIME_TEST
     tif = tif + clock()-to; //time for computing initial form ideal
 #endif
+#ifdef CHECK_IDEAL_MWALK
+    idString(Gomega,"Gomega");
+#endif
+//#ifdef CHECK_IDEAL_MWALK
+    if(printout > 1)
+    {
+      idString(Gomega,"//** Mrwalk: Gomega");
+    }
+//#endif
 #ifndef  BUCHBERGER_ALG
     if(isNolVector(curr_weight) == 0)
 …
 #endif
     idSkipZeroes(M);
+#ifdef CHECK_IDEAL_MWALK
+    PrintS("\n//** Mwalk: computed M.\n");
+    idString(M, "M");
+#endif
+//#ifdef CHECK_IDEAL_MWALK
+    if(printout > 2)
+    {
+      idString(M, "//** Mrwalk: M");
+    }
+//#endif
     //change the ring to baseRing
     rChangeCurrRing(baseRing);
 …
     to = clock();
 #endif
+    // compute a representation of the generators of submod (M) with respect to those of mod (Gomega), where Gomega is a reduced Groebner basis w.r.t. the current ring
+    // compute a representation of the generators of submod (M) with respect to those of mod (Gomega),
+    // where Gomega is a reduced Groebner basis w.r.t. the current ring
     F = MLifttwoIdeal(Gomega2, M1, G);
 #ifdef TIME_TEST
     tlift = tlift + clock() - to;
 #endif
+#ifdef CHECK_IDEAL_MWALK
+    idString(F, "F");
+#endif
+//#ifdef CHECK_IDEAL_MWALK
+    if(printout > 2)
+    {
+      idString(F, "//** Mrwalk: F");
+    }
+//#endif
     idDelete(&Gomega2);
     idDelete(&M1);
 …
 #ifdef TIME_TEST
     to = clock();
-#endif
-    //G = kStd(F1,NULL,testHomog,NULL,NULL,0,0,NULL);
-#ifdef TIME_TEST
     tstd = tstd + clock() - to;
 #endif
     idSkipZeroes(G);
+#ifdef CHECK_IDEAL_MWALK
+    idString(G, "G");
+#endif
+//#ifdef CHECK_IDEAL_MWALK
+    if(printout > 2)
+    {
+      idString(G, "//** Mrwalk: G");
+    }
+//#endif
 #ifdef TIME_TEST
     to = clock();
 #endif
+    intvec* next_weight = MWalkRandomNextWeight(G, curr_weight, target_weight, weight_rad, pert_deg);//next_weight = MwalkNextWeightCC(curr_weight,target_weight,G);
+    next_weight = MwalkNextWeightCC(curr_weight,target_weight,G);
+    if(polylength > 0)
+    {
+      //there is a polynomial in Gomega with at least 3 monomials,
+      //low-dimensional facet of the cone
+      delete next_weight;
+      next_weight = MWalkRandomNextWeight(G, curr_weight, target_weight, weight_rad, pert_deg);
+    }
 #ifdef TIME_TEST
     tnw = tnw + clock() - to;
 #endif
+#ifdef PRINT_VECTORS
+    MivString(curr_weight, target_weight, next_weight);
+#endif
+//#ifdef PRINT_VECTORS
+    if(printout > 0)
+    {
+      MivString(curr_weight, target_weight, next_weight);
+    }
+//#endif
     if(MivComp(next_weight, ivNull) == 1 || MivComp(target_weight,curr_weight) == 1)// || test_w_in_ConeCC(G, target_weight) == 1 || MivComp(next_weight,curr_weight) == 1)
+    {
 …
 #endif
       Gomega = MwalkInitialForm(G, curr_weight); // compute an initial form ideal of <G> w.r.t. "curr_vector"
+//#ifdef CHECK_IDEAL_MWALK
+      if(printout > 1)
+      {
+        idString(Gomega, "//** Mrwalk: Gomega");
+      }
+//#endif
       if(target_M->length() == nV)
+      {
 …
       Gomega1 = idrMoveR(Gomega, baseRing,currRing);
       idDelete(&Gomega);
-#ifdef CHECK_IDEAL_MWALK
-      idString(Gomega1, "Gomega");
-#endif
       M = kStd(Gomega1,NULL,testHomog,NULL,NULL,0,0,NULL);
+#ifdef CHECK_IDEAL_MWALK
+      idString(M,"M");
+#endif
+//#ifdef CHECK_IDEAL_MWALK
+      if(printout > 2)
+      {
+        idString(M,"//** Mrwalk: M");
+      }
+//#endif
       rChangeCurrRing(baseRing);
       M1 =  idrMoveR(M, newRing,currRing);
 …
       idDelete(&Gomega1);
       F = MLifttwoIdeal(Gomega2, M1, G);
-#ifdef CHECK_IDEAL_MWALK
-      idString(F,"F");
-#endif
       idDelete(&Gomega2);
       idDelete(&M1);
 …
       idDelete(&F);
       baseRing = currRing;
-      si_opt_1 = save1; //set original options, e. g. option(RedSB)
       idSkipZeroes(G);
 #ifdef TIME_TEST
       to = clock();
 #endif
+ //     if(si_opt_1 == (Sy_bit(OPT_REDSB)))
+  //    {
+        //G = kInterRedCC(G,NULL); //reduce the Groebner basis <G> w.r.t. currRing, if option(redSB) is set
+  //    }
+//#ifdef CHECK_IDEAL_MWALK
+      if(printout > 2)
+      {
+        idString(G,"//** Mrwalk: G");
+      }
+/*#endif
+      if(si_opt_1 == (Sy_bit(OPT_REDSB)))
+      {*/
+        G = kInterRedCC(G,NULL); //interreduce the Groebner basis <G> w.r.t. currRing
+//      }
 #ifdef TIME_TEST
       tred = tred + clock() - to;
 …
       delete next_weight;
       break;
+#ifdef CHECK_IDEAL_MWALK
+      PrintS("\n//** Mwalk: last cone.\n");
+#endif
+    }
+#ifdef CHECK_IDEAL_MWALK
+    PrintS("\n//** Mwalk: update weight vectors.\n");
+#endif
+    }
     for(i=nV-1; i>=0; i--)
+    {
 …
     delete next_weight;
+  }
+  baseRing = currRing;
   rChangeCurrRing(XXRing);
   ideal result = idrMoveR(G,baseRing,currRing);
   idDelete(&G);
+/*#ifdef CHECK_IDEAL_MWALK
+  pDelete(&p);
+#endif*/
+  si_opt_1 = save1; //set original options, e. g. option(RedSB)
   delete tmp_weight;
   delete ivNull;
 …
   delete last_omega;
 #endif
+  Print("\n//** Mrwalk: Groebner Walk took %d steps.\n", nstep);
 #ifdef TIME_TEST
-  Print("\n//** Mwalk: Groebner Walk took %d steps.\n", nstep);
   TimeString(tinput, tostd, tif, tstd, tlift, tred, tnw, nstep);
-  Print("\n//** Mwalk: Ergebnis.\n");
   //Print("\n// pSetm_Error = (%d)", ErrorCheck());
   //Print("\n// Overflow_Error? (%d)\n", Overflow_Error);
 …
 // use kStd, if nP = 0, else call LastGB
 ideal Mpwalk(ideal Go, int op_deg, int tp_deg,intvec* curr_weight,
              intvec* target_weight, int nP)
+             intvec* target_weight, int nP, int reduction, int printout)
+{
+  BITSET save1 = si_opt_1; // save current options
+  if(reduction == 0)
+  {
+    si_opt_1 &= (~Sy_bit(OPT_REDSB)); // no reduced Groebner basis
+    //si_opt_1 &= (~Sy_bit(OPT_REDTAIL)); // not tail reductions
+    //si_opt_1|=(Sy_bit(OPT_REDTAIL)|Sy_bit(OPT_REDSB));
+  }
   Set_Error(FALSE  );
   Overflow_Error = FALSE;
 …
   ring XXRing = currRing;
   to = clock();
   /* perturbs the original vector */
+  // perturbs the original vector
   if(MivComp(curr_weight, iv_dp) == 1) //rOrdStr(currRing) := "dp"
+  {
 …
       DefRingPar(curr_weight);
     else
       rChangeCurrRing(VMrDefault(curr_weight)); //Aenderung 1
+      rChangeCurrRing(VMrDefault(curr_weight));
     G = idrMoveR(Go, XXRing,currRing);
 …
   ring HelpRing = currRing;
   /* perturbs the target weight vector */
+  // perturbs the target weight vector
   if(tp_deg > 1 && tp_deg <= nV)
+  {
 …
       DefRingPar(target_weight);
     else
       rChangeCurrRing(VMrDefault(target_weight)); // Aenderung 2
+      rChangeCurrRing(VMrDefault(target_weight));
     TargetRing = currRing;
 …
     G = idrMoveR(ssG, TargetRing,currRing);
+  }
+  /*
+    Print("\n// Perturbationwalkalg. vom Gradpaar (%d,%d):",op_deg,tp_deg);
+    ivString(curr_weight, "new sigma");
+    ivString(target_weight, "new tau");
+  */
+    if(printout > 0)
+    {
+      Print("\n//** Mpwalk: Perturbation Walk of degree (%d,%d):",op_deg,tp_deg);
+      ivString(curr_weight, "//** Mpwalk: new current weight");
+      ivString(target_weight, "//** Mpwalk: new target weight");
+    }
   while(1)
+  {
 …
        "curr_weight" */
     Gomega = MwalkInitialForm(G, curr_weight);
+//#ifdef CHECK_IDEAL_MWALK
+      if(printout > 1)
+      {
+        idString(Gomega,"//** Mpwalk: Gomega");
+      }
+//#endif
 #ifdef ENDWALKS
+    if(endwalks == 1){
+    if(endwalks == 1)
+    {
       Print("\n// ring r%d = %s;\n", nstep, rString(currRing));
       idElements(G, "G");
-      // idElements(Gomega, "Gw");
       headidString(G, "G");
-      //headidString(Gomega, "Gw");
+    }
 #endif
 …
       DefRingPar(curr_weight);
     else
       rChangeCurrRing(VMrDefault(curr_weight)); //Aenderung 3
+      rChangeCurrRing(VMrDefault(curr_weight));
     newRing = currRing;
 …
     M=kStd(Gomega1,NULL,isHomog,NULL,hilb_func,0,NULL,curr_weight);
     delete hilb_func;
+#endif // BUCHBERGER_ALG
+#endif
+//#ifdef CHECK_IDEAL_MWALK
+      if(printout > 2)
+      {
+        idString(M,"//** Mpwalk: M");
+      }
+//#endif
     if(endwalks == 1){
 …
     M1 =  idrMoveR(M, newRing,currRing);
     Gomega2 =  idrMoveR(Gomega1, newRing,currRing);
-    //if(endwalks==1)  PrintS("\n// Lifting is working:..");
     to=clock();
 …
       xtlift=clock()-to;
+//#ifdef CHECK_IDEAL_MWALK
+    if(printout > 2)
+    {
+      idString(F,"//** Mpwalk: F");
+    }
+//#endif
     idDelete(&M1);
     idDelete(&Gomega2);
 …
     rChangeCurrRing(newRing);
     F1 = idrMoveR(F, oldRing,currRing);
-    //if(endwalks==1)PrintS("\n// InterRed is working now:");
     to=clock();
 …
     to=clock();
     /* compute a next weight vector */
+    // compute a next weight vector
     next_weight = MkInterRedNextWeight(curr_weight,target_weight, G);
     tnw=tnw+clock()-to;
+#ifdef PRINT_VECTORS
+    MivString(curr_weight, target_weight, next_weight);
+#endif
+//#ifdef PRINT_VECTORS
+    if(printout > 2)
+    {
+      MivString(curr_weight, target_weight, next_weight);
+    }
+//#endif
     if(Overflow_Error == TRUE)
 …
         DefRingPar(orig_target);
       else
         rChangeCurrRing(VMrDefault(orig_target)); //Aenderung
+        rChangeCurrRing(VMrDefault(orig_target));
     TargetRing=currRing;
 …
     Eresult = idrMoveR(G, newRing,currRing);
+  }
+  si_opt_1 = save1; //set original options, e. g. option(RedSB)
   delete ivNull;
   if(tp_deg != 1)
 …
              tnw+xtnw);
+  Print("\n// pSetm_Error = (%d)", ErrorCheck());
+  Print("\n// It took %d steps and Overflow_Error? (%d)\n", nstep,  Overflow_Error);
+#endif
+  //Print("\n// pSetm_Error = (%d)", ErrorCheck());
+  //Print("\n// It took %d steps and Overflow_Error? (%d)\n", nstep,  Overflow_Error);
+#endif
+  Print("\n//** Mpwalk: Perturbation Walk took %d steps.\n", nstep);
+  return(Eresult);
+}
+/*******************************************************
+ * THE PERTURBATION WALK ALGORITHM WITH RANDOM ELEMENT *
+ *******************************************************/
+ideal Mprwalk(ideal Go, intvec* orig_M, intvec* target_M, int weight_rad,
+              int op_deg, int tp_deg, int nP, int reduction, int printout)
+{
+  BITSET save1 = si_opt_1; // save current options
+  if(reduction == 0)
+  {
+    si_opt_1 &= (~Sy_bit(OPT_REDSB)); // no reduced Groebner basis
+    //si_opt_1 &= (~Sy_bit(OPT_REDTAIL)); // not tail reductions
+    //si_opt_1|=(Sy_bit(OPT_REDTAIL)|Sy_bit(OPT_REDSB));
+  }
+  Set_Error(FALSE);
+  Overflow_Error = FALSE;
+  //Print("// pSetm_Error = (%d)", ErrorCheck());
+  clock_t  tinput, tostd, tif=0, tstd=0, tlift=0, tred=0, tnw=0;
+  xtextra=0;
+  xtif=0; xtstd=0; xtlift=0; xtred=0; xtnw=0;
+  tinput = clock();
+  clock_t tim;
+  nstep = 0;
+  int i, ntwC=1, ntestw=1, polylength, nV = currRing->N;
+  int endwalks=0;
+  ideal Gomega, M, F, G, Gomega1, Gomega2, M1,F1,Eresult,ssG;
+  ring newRing, oldRing, TargetRing;
+  intvec* iv_M_dp;
+  intvec* iv_M_lp;
+  intvec* exivlp = Mivlp(nV);
+  intvec* curr_weight = new intvec(nV);
+  intvec* target_weight = new intvec(nV);
+  for(i=0; i<nV; i++)
+  {
+    (*curr_weight)[i] = (*orig_M)[i];
+    (*target_weight)[i] = (*target_M)[i];
+  }
+  intvec* orig_target = target_weight;
+  intvec* pert_target_vector = target_weight;
+  intvec* ivNull = new intvec(nV);
+  intvec* iv_dp = MivUnit(nV);// define (1,1,...,1)
+#ifndef BUCHBERGER_ALG
+  intvec* hilb_func;
+#endif
+  intvec* next_weight;
+  // to avoid (1,0,...,0) as the target vector
+  intvec* last_omega = new intvec(nV);
+  for(i=nV-1; i>0; i--)
+    (*last_omega)[i] = 1;
+  (*last_omega)[0] = 10000;
+  ring XXRing = currRing;
+  to = clock();
+  // perturbs the original vector
+  if(orig_M->length() == nV)
+  {
+    if(MivComp(curr_weight, iv_dp) == 1) //rOrdStr(currRing) := "dp"
+    {
+      G = MstdCC(Go);
+      tostd = clock()-to;
+      if(op_deg != 1)
+      {
+        iv_M_dp = MivMatrixOrderdp(nV);
+        //ivString(iv_M_dp, "iv_M_dp");
+        curr_weight = MPertVectors(G, iv_M_dp, op_deg);
+      }
+    }
+    else
+    {
+      //define ring order := (a(curr_weight),lp);
+      if (rParameter(currRing) != NULL)
+        DefRingPar(curr_weight);
+      else
+        rChangeCurrRing(VMrDefault(curr_weight));
+      G = idrMoveR(Go, XXRing,currRing);
+      G = MstdCC(G);
+      tostd = clock()-to;
+      if(op_deg != 1)
+      {
+        iv_M_dp = MivMatrixOrder(curr_weight);
+        curr_weight = MPertVectors(G, iv_M_dp, op_deg);
+      }
+    }
+  }
+  else
+  {
+    rChangeCurrRing(VMatrDefault(orig_M));
+    G = idrMoveR(Go, XXRing,currRing);
+    G = MstdCC(G);
+    tostd = clock()-to;
+    if(op_deg != 1)
+    {
+      curr_weight = MPertVectors(G, orig_M, op_deg);
+    }
+  }
+  delete iv_dp;
+  if(op_deg != 1) delete iv_M_dp;
+  ring HelpRing = currRing;
+  // perturbs the target weight vector
+  if(target_M->length() == nV)
+  {
+    if(tp_deg > 1 && tp_deg <= nV)
+    {
+      if (rParameter(currRing) != NULL)
+        DefRingPar(target_weight);
+      else
+        rChangeCurrRing(VMrDefault(target_weight));
+      TargetRing = currRing;
+      ssG = idrMoveR(G,HelpRing,currRing);
+      if(MivSame(target_weight, exivlp) == 1)
+      {
+        iv_M_lp = MivMatrixOrderlp(nV);
+        //ivString(iv_M_lp, "iv_M_lp");
+        //target_weight = MPertVectorslp(ssG, iv_M_lp, tp_deg);
+        target_weight = MPertVectors(ssG, iv_M_lp, tp_deg);
+      }
+      else
+      {
+        iv_M_lp = MivMatrixOrder(target_weight);
+        //target_weight = MPertVectorslp(ssG, iv_M_lp, tp_deg);
+        target_weight = MPertVectors(ssG, iv_M_lp, tp_deg);
+      }
+      delete iv_M_lp;
+      pert_target_vector = target_weight;
+      rChangeCurrRing(HelpRing);
+      G = idrMoveR(ssG, TargetRing,currRing);
+    }
+  }
+  else
+  {
+    if(tp_deg > 1 && tp_deg <= nV)
+    {
+      rChangeCurrRing(VMatrDefault(target_M));
+      TargetRing = currRing;
+      ssG = idrMoveR(G,HelpRing,currRing);
+      target_weight = MPertVectors(ssG, target_M, tp_deg);
+    }
+  }
+  if(printout > 0)
+  {
+    Print("\n//** Mprwalk: Random Perturbation Walk of degree (%d,%d):",op_deg,tp_deg);
+    ivString(curr_weight, "//** Mprwalk: new current weight");
+    ivString(target_weight, "//** Mprwalk: new target weight");
+  }
+  while(1)
+  {
+    nstep ++;
+    to = clock();
+    /* compute an initial form ideal of <G> w.r.t. the weight vector
+       "curr_weight" */
+    Gomega = MwalkInitialForm(G, curr_weight);
+//#ifdef CHECK_IDEAL_MWALK
+    if(printout > 1)
+    {
+      idString(Gomega,"//** Mprwalk: Gomega");
+    }
+//#endif
+    polylength = lengthpoly(Gomega);
+#ifdef ENDWALKS
+    if(endwalks == 1)
+    {
+      Print("\n// ring r%d = %s;\n", nstep, rString(currRing));
+      idElements(G, "G");
+      headidString(G, "G");
+    }
+#endif
+    tif = tif + clock()-to;
+#ifndef  BUCHBERGER_ALG
+    if(isNolVector(curr_weight) == 0)
+      hilb_func = hFirstSeries(Gomega,NULL,NULL,curr_weight,currRing);
+    else
+      hilb_func = hFirstSeries(Gomega,NULL,NULL,last_omega,currRing);
+#endif // BUCHBERGER_ALG
+    oldRing = currRing;
+    if(target_M->length() == nV)
+    {
+      // define a new ring with ordering "(a(curr_weight),lp)
+      if (rParameter(currRing) != NULL)
+        DefRingPar(curr_weight);
+      else
+        rChangeCurrRing(VMrDefault(curr_weight));
+    }
+    else
+    {
+      rChangeCurrRing(VMatrRefine(target_M,curr_weight));
+    }
+    newRing = currRing;
+    Gomega1 = idrMoveR(Gomega, oldRing,currRing);
+#ifdef ENDWALKS
+    if(endwalks==1)
+    {
+      Print("\n// ring r%d = %s;\n", nstep, rString(currRing));
+      idElements(Gomega1, "Gw");
+      headidString(Gomega1, "headGw");
+      PrintS("\n// compute a rGB of Gw:\n");
+#ifndef  BUCHBERGER_ALG
+      ivString(hilb_func, "w");
+#endif
+    }
+#endif
+    tim = clock();
+    to = clock();
+    /* compute a reduced Groebner basis of <Gomega> w.r.t. "newRing" */
+#ifdef  BUCHBERGER_ALG
+    M = MstdhomCC(Gomega1);
+#else
+    M=kStd(Gomega1,NULL,isHomog,NULL,hilb_func,0,NULL,curr_weight);
+    delete hilb_func;
+#endif
+//#ifdef CHECK_IDEAL_MWALK
+    if(printout > 2)
+    {
+      idString(M,"//** Mprwalk: M");
+    }
+//#endif
+    if(endwalks == 1)
+    {
+      xtstd = xtstd+clock()-to;
+#ifdef ENDWALKS
+      Print("\n// time for the last std(Gw)  = %.2f sec\n",
+            ((double) clock())/1000000 -((double)tim) /1000000);
+#endif
+    }
+    else
+      tstd=tstd+clock()-to;
+    /* change the ring to oldRing */
+    rChangeCurrRing(oldRing);
+    M1 =  idrMoveR(M, newRing,currRing);
+    Gomega2 =  idrMoveR(Gomega1, newRing,currRing);
+    to=clock();
+    /* compute a representation of the generators of submod (M)
+       with respect to those of mod (Gomega).
+       Gomega is a reduced Groebner basis w.r.t. the current ring */
+    F = MLifttwoIdeal(Gomega2, M1, G);
+    if(endwalks != 1)
+      tlift = tlift+clock()-to;
+    else
+      xtlift=clock()-to;
+//#ifdef CHECK_IDEAL_MWALK
+    if(printout > 2)
+    {
+      idString(F,"//** Mprwalk: F");
+    }
+//#endif
+    idDelete(&M1);
+    idDelete(&Gomega2);
+    idDelete(&G);
+    /* change the ring to newRing */
+    rChangeCurrRing(newRing);
+    F1 = idrMoveR(F, oldRing,currRing);
+    to=clock();
+    /* reduce the Groebner basis <G> w.r.t. new ring */
+    G = kInterRedCC(F1, NULL);
+    if(endwalks != 1)
+      tred = tred+clock()-to;
+    else
+      xtred=clock()-to;
+    idDelete(&F1);
+    if(endwalks == 1)
+      break;
+    to=clock();
+    // compute a next weight vector
+    next_weight = MkInterRedNextWeight(curr_weight,target_weight, G);
+    if(polylength > 0)
+    {
+      //there is a polynomial in Gomega with at least 3 monomials,
+      //low-dimensional facet of the cone
+      delete next_weight;
+      next_weight = MWalkRandomNextWeight(G, curr_weight, target_weight, weight_rad, op_deg);
+    }
+    tnw=tnw+clock()-to;
+//#ifdef PRINT_VECTORS
+    if(printout > 2)
+    {
+      MivString(curr_weight, target_weight, next_weight);
+    }
+//#endif
+    if(Overflow_Error == TRUE)
+    {
+      ntwC = 0;
+      //ntestomega = 1;
+      //Print("\n// ring r%d = %s;\n", nstep, rString(currRing));
+      //idElements(G, "G");
+      delete next_weight;
+      goto FINISH_160302;
+    }
+    if(MivComp(next_weight, ivNull) == 1){
+      newRing = currRing;
+      delete next_weight;
+      //Print("\n// ring r%d = %s;\n", nstep, rString(currRing));
+      break;
+    }
+    if(MivComp(next_weight, target_weight) == 1)
+      endwalks = 1;
+    for(i=nV-1; i>=0; i--)
+      (*curr_weight)[i] = (*next_weight)[i];
+    delete next_weight;
+  }//while
+  if(tp_deg != 1)
+  {
+    FINISH_160302:
+    if(target_M->length() == nV)
+    {
+      if(MivSame(orig_target, exivlp) == 1)
+        if (rParameter(currRing) != NULL)
+          DefRingParlp();
+        else
+          VMrDefaultlp();
+      else
+        if (rParameter(currRing) != NULL)
+          DefRingPar(orig_target);
+        else
+          rChangeCurrRing(VMrDefault(orig_target));
+    }
+    else
+    {
+      rChangeCurrRing(VMatrDefault(target_M));
+    }
+    TargetRing=currRing;
+    F1 = idrMoveR(G, newRing,currRing);
+#ifdef CHECK_IDEAL
+      headidString(G, "G");
+#endif
+    // check whether the pertubed target vector stays in the correct cone
+    if(ntwC != 0){
+      ntestw = test_w_in_ConeCC(F1, pert_target_vector);
+    }
+    if( ntestw != 1 || ntwC == 0)
+    {
+      /*
+      if(ntestw != 1){
+        ivString(pert_target_vector, "tau");
+        PrintS("\n// ** perturbed target vector doesn't stay in cone!!");
+        Print("\n// ring r%d = %s;\n", nstep, rString(currRing));
+        idElements(F1, "G");
+      }
+      */
+      // LastGB is "better" than the kStd subroutine
+      to=clock();
+      ideal eF1;
+      if(nP == 0 || tp_deg == 1 || MivSame(orig_target, exivlp) != 1 || target_M->length() != nV){
+        // PrintS("\n// ** calls \"std\" to compute a GB");
+        eF1 = MstdCC(F1);
+        idDelete(&F1);
+      }
+      else {
+        // PrintS("\n// ** calls \"LastGB\" to compute a GB");
+        rChangeCurrRing(newRing);
+        ideal F2 = idrMoveR(F1, TargetRing,currRing);
+        eF1 = LastGB(F2, curr_weight, tp_deg-1);
+        F2=NULL;
+      }
+      xtextra=clock()-to;
+      ring exTargetRing = currRing;
+      rChangeCurrRing(XXRing);
+      Eresult = idrMoveR(eF1, exTargetRing,currRing);
+    }
+    else{
+      rChangeCurrRing(XXRing);
+      Eresult = idrMoveR(F1, TargetRing,currRing);
+    }
+  }
+  else {
+    rChangeCurrRing(XXRing);
+    Eresult = idrMoveR(G, newRing,currRing);
+  }
+  si_opt_1 = save1; //set original options, e. g. option(RedSB)
+  delete ivNull;
+  if(tp_deg != 1)
+    delete target_weight;
+  if(op_deg != 1 )
+    delete curr_weight;
+  delete exivlp;
+  delete last_omega;
+#ifdef TIME_TEST
+  TimeStringFractal(tinput, tostd, tif+xtif, tstd+xtstd,0, tlift+xtlift, tred+xtred,
+             tnw+xtnw);
+  //Print("\n// pSetm_Error = (%d)", ErrorCheck());
+  //Print("\n// It took %d steps and Overflow_Error? (%d)\n", nstep,  Overflow_Error);
+#endif
+  Print("\n//** Mprwalk: Perturbation Walk took %d steps.\n", nstep);
   return(Eresult);
+}
 …
  * Perturb the start weight vector at the top level, i.e. nlev = 1     *
  ***********************************************************************/
 static ideal rec_fractal_call(ideal G, int nlev, intvec* omtmp)
+static ideal rec_fractal_call(ideal G, int nlev, intvec* ivtarget, int printout)
+{
   Overflow_Error =  FALSE;
 …
   intvec* next_vect;
   intvec* omega2 = new intvec(nV);
+  intvec* omtmp = new intvec(nV);
   intvec* altomega = new intvec(nV);
+  for(i = nV -1; i>0; i--)
+  {
+    (*omtmp)[i] = (*ivtarget)[i];
+  }
   //BOOLEAN isnewtarget = FALSE;
 …
     NEXT_VECTOR_FRACTAL:
     to=clock();
     /* determine the next border */
+    // determine the next border
     next_vect = MkInterRedNextWeight(omega,omega2,G);
     xtnw=xtnw+clock()-to;
+#ifdef PRINT_VECTORS
+    MivString(omega, omega2, next_vect);
+#endif
     oRing = currRing;
     /* We only perturb the current target vector at the recursion  level 1 */
+    // We only perturb the current target vector at the recursion  level 1
     if(Xngleich == 0 && nlev == 1) //(ngleich == 0) important, e.g. ex2, ex3
       if (MivComp(next_vect, omega2) == 1)
+      {
+        /* to dispense with taking initial (and lifting/interreducing
+           after the call of recursion */
+        //Print("\n\n// ** Perturb the both vectors with degree %d with",nlev);
+        //idElements(G, "G");
+        // to dispense with taking initial (and lifting/interreducing
+        // after the call of recursion
+        if(printout > 0)
+        {
+          Print("\n//** rec_fractal_call: Perturb the both vectors with degree %d.",nlev);
+          //idElements(G, "G");
+        }
         Xngleich = 1;
         nlev +=1;
+        if (rParameter(currRing) != NULL)
+          DefRingPar(omtmp);
+        if(ivtarget->length() == nV)
+        {
+          if (rParameter(currRing) != NULL)
+            DefRingPar(omtmp);
+          else
+            rChangeCurrRing(VMrDefault(omtmp));
+        }
         else
+          rChangeCurrRing(VMrDefault1(omtmp)); //Aenderung3
+        {
+          rChangeCurrRing(VMatrDefault(ivtarget));
+        }
         testring = currRing;
         Gt = idrMoveR(G, oRing,currRing);
+        /* perturb the original target vector w.r.t. the current GB */
+        delete Xtau;
+        Xtau = NewVectorlp(Gt);
+        // perturb the original target vector w.r.t. the current GB
+        if(ivtarget->length() == nV)
+        {
+          delete Xtau;
+          Xtau = NewVectorlp(Gt);
+        }
+        else
+        {
+          delete Xtau;
+          Xtau = Mfpertvector(Gt,ivtarget);
+        }
         rChangeCurrRing(oRing);
         G = idrMoveR(Gt, testring,currRing);
         /* perturb the current vector w.r.t. the current GB */
+        // perturb the current vector w.r.t. the current GB
         Mwlp = MivWeightOrderlp(omega);
         Xsigma = Mfpertvector(G, Mwlp);
 …
         next_vect = MkInterRedNextWeight(omega,omega2,G);
         xtnw=xtnw+clock()-to;
+#ifdef PRINT_VECTORS
+      }
+//#ifdef PRINT_VECTORS
+      if(printout > 0)
+      {
         MivString(omega, omega2, next_vect);
+#endif
+      }
+      }
+//#endif
     /* check whether the the computed vector is in the correct cone */
 …
+    {
       delete next_vect;
+      if (rParameter(currRing) != NULL)
+      {
+        DefRingPar(omtmp);
+      if(ivtarget->length() == nV)
+      {
+        if (rParameter(currRing) != NULL)
+          DefRingPar(omtmp);
+        else
+          rChangeCurrRing(VMrDefault(omtmp));
+      }
       else
+      {
         rChangeCurrRing(VMrDefault1(omtmp)); // Aenderung4
+        rChangeCurrRing(VMatrDefault(ivtarget));
+      }
 #ifdef TEST_OVERFLOW
 …
       Gt = NULL; return(Gt);
 #endif
+      //Print("\n\n// apply BB's alg. in ring r = %s;", rString(currRing));
+      if(printout > 0)
+      {
+        Print("\n//** rec_fractal_call: applying Buchberger's algorithm in ring r = %s;",
+              rString(currRing));
+      }
       to=clock();
       Gt = idrMoveR(G, oRing,currRing);
 …
       delete omega2;
       delete altomega;
+      //Print("\n// Leaving the %d-th recursion with %d steps", nlev, nwalks);
+      //Print("  ** Overflow_Error? (%d)", Overflow_Error);
+      if(printout > 0)
+      {
+        Print("\n//** rec_fractal_call: Leaving the %d-th recursion with %d steps.\n",
+              nlev, nwalks);
+        //Print(" ** Overflow_Error? (%d)", Overflow_Error);
+      }
       nnflow ++;
 …
     if (MivComp(next_vect, XivNull) == 1)
+    {
+      if (rParameter(currRing) != NULL)
+        DefRingPar(omtmp);
+      if(ivtarget->length() == nV)
+      {
+        if (rParameter(currRing) != NULL)
+          DefRingPar(omtmp);
+        else
+          rChangeCurrRing(VMrDefault(omtmp));
+      }
       else
+        rChangeCurrRing(VMrDefault1(omtmp)); //Aenderung5
+      {
+        rChangeCurrRing(VMatrDefault(ivtarget));
+      }
       testring = currRing;
 …
         delete next_vect;
         delete altomega;
+        //Print("\n// Leaving the %d-th recursion with %d steps ",nlev, nwalks);
+        //Print(" ** Overflow_Error? (%d)", Overflow_Error);
+        if(printout > 0)
+        {
+          Print("\n//** rec_fractal_call: Leaving the %d-th recursion with %d steps.\n",
+              nlev, nwalks);
+          //Print(" ** Overflow_Error? (%d)", Overflow_Error);
+        }
         return (Gt);
+      }
 …
         //07.08.03
         //ivString(Xtau, "old Xtau");
+        intvec* Xtautmp = Mfpertvector(Gt, MivMatrixOrder(omtmp));
+        intvec* Xtautmp;
+        if(ivtarget->length() == nV)
+        {
+          Xtautmp = Mfpertvector(Gt, MivMatrixOrder(omtmp));
+        }
+        else
+        {
+          Xtautmp = Mfpertvector(Gt, ivtarget);
+        }
 #ifdef TEST_OVERFLOW
       if(Overflow_Error == TRUE)
 …
       FRACTAL_MSTDCC:
+        //Print("\n//  apply BB-Alg in ring = %s;", rString(currRing));
+        if(printout > 0)
+        {
+          Print("\n//** rec_fractal_call: apply Buchberger's algorithm in ring = %s.\n",
+                rString(currRing));
+        }
         to=clock();
         G = MstdCC(Gt);
 …
         // update the original target vector w.r.t. the current GB
+        if(MivSame(Xivinput, Xivlp) == 1)
+          if (rParameter(currRing) != NULL)
+            DefRingParlp();
+        if(ivtarget->length() == nV)
+        {
+          if(MivSame(Xivinput, Xivlp) == 1)
+            if (rParameter(currRing) != NULL)
+              DefRingParlp();
+            else
+              VMrDefaultlp();
           else
+            VMrDefaultlp();
+            if (rParameter(currRing) != NULL)
+              DefRingPar(Xivinput);
+            else
+              rChangeCurrRing(VMrDefault(Xivinput));
+        }
         else
+          if (rParameter(currRing) != NULL)
+            DefRingPar(Xivinput);
+          else
+            rChangeCurrRing(VMrDefault1(Xivinput)); //Aenderung6
+        {
+          rChangeCurrRing(VMatrRefine(ivtarget,Xivinput));
+        }
         testring = currRing;
         Gt = idrMoveR(G, oRing,currRing);
 …
         delete next_vect;
         delete altomega;
+        /*
+          Print("\n// Leaving the %d-th recursion with %d steps,", nlev,nwalks);
+          Print(" ** Overflow_Error? (%d)", Overflow_Error);
+        */
+        if(printout > 0)
+        {
+          Print("\n//** rec_fractal_call: Leaving the %d-th recursion with %d steps.\n",
+              nlev, nwalks);
+          //Print(" ** Overflow_Error? (%d)", Overflow_Error);
+        }
         if(Overflow_Error == TRUE)
           nnflow ++;
 …
     Gomega = MwalkInitialForm(G, omega);
     xtif=xtif+clock()-to;
+    if(printout > 1)
+    {
+      idString(Gomega,"//** rec_fractal_call: Gomega");
+    }
 #ifndef  BUCHBERGER_ALG
     if(isNolVector(omega) == 0)
 …
       hilb_func = hFirstSeries(Gomega,NULL,NULL,last_omega,currRing);
 #endif // BUCHBERGER_ALG
+    if (rParameter(currRing) != NULL)
+      DefRingPar(omega);
+    if(ivtarget->length() == nV)
+    {
+      if (rParameter(currRing) != NULL)
+        DefRingPar(omega);
+      else
+        rChangeCurrRing(VMrDefault(omega));
+    }
     else
+      rChangeCurrRing(VMrDefault1(omega)); //Aenderung7
+    {
+      rChangeCurrRing(VMatrRefine(ivtarget,omega));
+    }
     Gomega1 = idrMoveR(Gomega, oRing,currRing);
     /* Maximal recursion depth, to compute a red. GB */
     /* Fractal walk with the alternative recursion */
     /* alternative recursion */
+    // Maximal recursion depth, to compute a red. GB
+    // Fractal walk with the alternative recursion
+    // alternative recursion
     // if(nlev == nV || lengthpoly(Gomega1) == 0)
     if(nlev == Xnlev || lengthpoly(Gomega1) == 0)
       //if(nlev == nV) // blind recursion
+    {
-      /*
-      if(Xnlev != nV)
+      {
-        Print("\n// ** Xnlev = %d", Xnlev);
-        ivString(Xtau, "Xtau");
+      }
-      */
       to=clock();
 #ifdef  BUCHBERGER_ALG
 …
       xtstd=xtstd+clock()-to;
+    }
+    else {
+    else
+    {
       rChangeCurrRing(oRing);
       Gomega1 = idrMoveR(Gomega1, oRing,currRing);
+      Gresult = rec_fractal_call(idCopy(Gomega1),nlev+1,omega);
+    }
+    //convert a Groebner basis from a ring to another ring,
+      Gresult = rec_fractal_call(idCopy(Gomega1),nlev+1,omega,printout);
+    }
+    if(printout > 2)
+    {
+      idString(Gresult,"//** rec_fractal_call: M");
+    }
+    //convert a Groebner basis from a ring to another ring
     new_ring = currRing;
 …
     to=clock();
     /* Lifting process */
+    // Lifting process
     F = MLifttwoIdeal(Gomega2, Gresult1, G);
     xtlift=xtlift+clock()-to;
+    if(printout > 2)
+    {
+      idString(F,"//** rec_fractal_call: F");
+    }
     idDelete(&Gresult1);
     idDelete(&Gomega2);
 …
  * Perturb the start weight vector at the top level with random element *
  ************************************************************************/
+static ideal rec_r_fractal_call(ideal G, int nlev, intvec* omtmp, int weight_rad)
+static ideal rec_r_fractal_call(ideal G, int nlev, intvec* ivtarget,
+                int weight_rad, int printout)
+{
   Overflow_Error =  FALSE;
   //Print("\n\n// Entering the %d-th recursion:", nlev);
   int i, nV = currRing->N;
+  int i, polylength, nV = currRing->N;
   ring new_ring, testring;
   //ring extoRing;
 …
   intvec* next_vect;
   intvec* omega2 = new intvec(nV);
+  intvec* omtmp = new intvec(nV);
   intvec* altomega = new intvec(nV);
   //BOOLEAN isnewtarget = FALSE;
+  for(i = nV -1; i>0; i--)
+  {
+    (*omtmp)[i] = (*ivtarget)[i];
+  }
   // to avoid (1,0,...,0) as the target vector (Hans)
   intvec* last_omega = new intvec(nV);
 …
     to=clock();
     /* determine the next border */
+    next_vect = MWalkRandomNextWeight(G, omega,omega2, weight_rad, 1+nlev);
+    //next_vect = MkInterRedNextWeight(omega,omega2,G);
+    next_vect = MkInterRedNextWeight(omega,omega2,G);
+    if(polylength > 0)
+    {
+      //there is a polynomial in Gomega with at least 3 monomials,
+      //low-dimensional facet of the cone
+      delete next_vect;
+      next_vect = MWalkRandomNextWeight(G,omega,omega2,weight_rad,1+nlev);
+      if(isNolVector(next_vect))
+      {
+        delete next_vect;
+        next_vect = MkInterRedNextWeight(omega,omega2,G);
+      }
+    }
     xtnw=xtnw+clock()-to;
+#ifdef PRINT_VECTORS
+    MivString(omega, omega2, next_vect);
+#endif
     oRing = currRing;
     /* We only perturb the current target vector at the recursion  level 1 */
+    // We only perturb the current target vector at the recursion  level 1
     if(Xngleich == 0 && nlev == 1) //(ngleich == 0) important, e.g. ex2, ex3
       if (MivComp(next_vect, omega2) == 1)
+      {
+        /* to dispense with taking initial (and lifting/interreducing
+           after the call of recursion */
+        //Print("\n\n// ** Perturb the both vectors with degree %d with",nlev);
+        //idElements(G, "G");
+        // to dispense with taking initials and lifting/interreducing
+        // after the call of recursion.
+        if(printout > 0)
+        {
+          Print("\n//** rec_r_fractal_call: Perturb the both vectors with degree %d.",nlev);
+          //idElements(G, "G");
+        }
         Xngleich = 1;
         nlev +=1;
+        if (rParameter(currRing) != NULL)
+          DefRingPar(omtmp);
+        if(ivtarget->length() == nV)
+        {
+          if (rParameter(currRing) != NULL)
+            DefRingPar(omtmp);
+          else
+            rChangeCurrRing(VMrDefault(omtmp));
+        }
         else
+          rChangeCurrRing(VMrDefault1(omtmp)); //Aenderung3
+        {
+          rChangeCurrRing(VMatrDefault(ivtarget));
+        }
         testring = currRing;
         Gt = idrMoveR(G, oRing,currRing);
+        /* perturb the original target vector w.r.t. the current GB */
+        delete Xtau;
+        Xtau = NewVectorlp(Gt);
+        // perturb the original target vector w.r.t. the current GB
+        if(ivtarget->length() == nV)
+        {
+          delete Xtau;
+          Xtau = NewVectorlp(Gt);
+        }
+        else
+        {
+          delete Xtau;
+          Xtau = Mfpertvector(Gt,ivtarget);
+        }
         rChangeCurrRing(oRing);
         G = idrMoveR(Gt, testring,currRing);
         /* perturb the current vector w.r.t. the current GB */
+        G = idrMoveR(Gt,testring,currRing);
+        // perturb the current vector w.r.t. the current GB
         Mwlp = MivWeightOrderlp(omega);
+        if(ivtarget->length() > nV)
+        {
+          delete Mwlp;
+          Mwlp = MivMatrixOrderRefine(omega,ivtarget);
+        }
         Xsigma = Mfpertvector(G, Mwlp);
         delete Mwlp;
 …
         next_vect = MkInterRedNextWeight(omega,omega2,G);
+        if(polylength > 0)
+        {
+          //there is a polynomial in Gomega with at least 3 monomials,
+          //low-dimensional facet of the cone
+          delete next_vect;
+          next_vect = MWalkRandomNextWeight(G,omega,omega2,weight_rad,1+nlev);
+          if(isNolVector(next_vect))
+          {
+            delete next_vect;
+            next_vect = MkInterRedNextWeight(omega,omega2,G);
+          }
+        }
         xtnw=xtnw+clock()-to;
+#ifdef PRINT_VECTORS
+      }
+//#ifdef PRINT_VECTORS
+      if(printout > 0)
+      {
         MivString(omega, omega2, next_vect);
+#endif
+      }
+    /* check whether the the computed vector is in the correct cone */
+    /* If no, the reduced GB of an omega-homogeneous ideal will be
+      }
+//#endif
+    /* check whether the the computed vector is in the correct cone
+       If no, the reduced GB of an omega-homogeneous ideal will be
        computed by Buchberger algorithm and stop this recursion step*/
     //if(test_w_in_ConeCC(G, next_vect) != 1) //e.g. Example s7, cyc6
 …
+    {
       delete next_vect;
+      if (rParameter(currRing) != NULL)
+      {
+        DefRingPar(omtmp);
+      if(ivtarget->length() == nV)
+      {
+        if (rParameter(currRing) != NULL)
+        {
+          DefRingPar(omtmp);
+        }
+        else
+        {
+          rChangeCurrRing(VMrDefault(omtmp));
+        }
+      }
       else
+      {
         rChangeCurrRing(VMrDefault1(omtmp)); // Aenderung4
+        rChangeCurrRing(VMatrDefault(ivtarget));
+      }
 #ifdef TEST_OVERFLOW
       Gt = idrMoveR(G, oRing,currRing);
+      Gt = NULL; return(Gt);
+#endif
+      //Print("\n\n// apply BB's alg. in ring r = %s;", rString(currRing));
+      Gt = NULL;
+      return(Gt);
+#endif
+      if(printout > 0)
+      {
+        Print("\n//** rec_r_fractal_call: applying Buchberger's algorithm in ring r = %s;",
+              rString(currRing));
+      }
       to=clock();
       Gt = idrMoveR(G, oRing,currRing);
 …
       delete omega2;
       delete altomega;
+      //Print("\n// Leaving the %d-th recursion with %d steps", nlev, nwalks);
+      //Print("  ** Overflow_Error? (%d)", Overflow_Error);
+      if(printout > 0)
+      {
+        Print("\n//** rec_r_fractal_call: Leaving the %d-th recursion with %d steps.\n",
+              nlev, nwalks);
+        //Print(" ** Overflow_Error? (%d)", Overflow_Error);
+      }
       nnflow ++;
       Overflow_Error = FALSE;
       return (G1);
+    }
+    /* If the perturbed target vector stays in the correct cone,
+       return the current GB,
+       otherwise, return the computed  GB by the Buchberger-algorithm.
+       Then we update the perturbed target vectors w.r.t. this GB. */
+    /* the computed vector is equal to the origin vector, since
+       t is not defined */
+    /*
+       If the perturbed target vector stays in the correct cone,
+       return the current Groebner basis.
+       Otherwise, return the Groebner basis computed with Buchberger's
+       algorithm.
+       Then we update the perturbed target vectors w.r.t. this GB.
+    */
     if (MivComp(next_vect, XivNull) == 1)
+    {
+      if (rParameter(currRing) != NULL)
+        DefRingPar(omtmp);
+      // The computed vector is equal to the origin vector,
+      // because t is not defined
+      if(ivtarget->length() == nV)
+      {
+        if (rParameter(currRing) != NULL)
+          DefRingPar(omtmp);
+        else
+          rChangeCurrRing(VMrDefault(omtmp));
+      }
       else
+        rChangeCurrRing(VMrDefault1(omtmp)); //Aenderung5
+      {
+        rChangeCurrRing(VMatrDefault(ivtarget));
+      }
       testring = currRing;
       Gt = idrMoveR(G, oRing,currRing);
+      if(test_w_in_ConeCC(Gt, omega2) == 1) {
+      if(test_w_in_ConeCC(Gt, omega2) == 1)
+      {
         delete omega2;
         delete next_vect;
         delete altomega;
+        //Print("\n// Leaving the %d-th recursion with %d steps ",nlev, nwalks);
+        //Print(" ** Overflow_Error? (%d)", Overflow_Error);
+        if(printout > 0)
+        {
+          Print("\n//** rec_r_fractal_call: Leaving the %d-th recursion with %d steps.\n",
+                nlev, nwalks);
+          //Print(" ** Overflow_Error? (%d)", Overflow_Error);
+        }
         return (Gt);
+      }
       else
+      {
+        //ivString(omega2, "tau'");
+        //Print("\n//  tau' doesn't stay in the correct cone!!");
+      {
+        if(printout > 0)
+        {
+          Print("\n//** rec_r_fractal_call: target weight doesn't stay in the correct cone.\n");
+        }
 #ifndef  MSTDCC_FRACTAL
-        //07.08.03
         //ivString(Xtau, "old Xtau");
+        intvec* Xtautmp = Mfpertvector(Gt, MivMatrixOrder(omtmp));
+        intvec* Xtautmp;
+        if(ivtarget->length() == nV)
+        {
+          Xtautmp = Mfpertvector(Gt, MivMatrixOrder(omtmp));
+        }
+        else
+        {
+          Xtautmp = Mfpertvector(Gt, ivtarget);
+        }
 #ifdef TEST_OVERFLOW
       if(Overflow_Error == TRUE)
 …
       FRACTAL_MSTDCC:
+        //Print("\n//  apply BB-Alg in ring = %s;", rString(currRing));
+        if(printout > 0)
+        {
+          Print("\n//** rec_r_fractal_call: apply Buchberge's algorithm in ring = %s.\n",
+                rString(currRing));
+        }
         to=clock();
         G = MstdCC(Gt);
 …
         // update the original target vector w.r.t. the current GB
+        if(MivSame(Xivinput, Xivlp) == 1)
+          if (rParameter(currRing) != NULL)
+            DefRingParlp();
+        if(ivtarget->length() == nV)
+        {
+          if(MivSame(Xivinput, Xivlp) == 1)
+            if (rParameter(currRing) != NULL)
+              DefRingParlp();
+            else
+              VMrDefaultlp();
           else
+            VMrDefaultlp();
+            if (rParameter(currRing) != NULL)
+              DefRingPar(Xivinput);
+            else
+              rChangeCurrRing(VMrDefault(Xivinput));
+        }
         else
+          if (rParameter(currRing) != NULL)
+            DefRingPar(Xivinput);
+          else
+            rChangeCurrRing(VMrDefault1(Xivinput)); //Aenderung6
+        {
+          rChangeCurrRing(VMatrRefine(ivtarget,Xivinput));
+        }
         testring = currRing;
         Gt = idrMoveR(G, oRing,currRing);
 …
         delete next_vect;
         delete altomega;
+        /*
+          Print("\n// Leaving the %d-th recursion with %d steps,", nlev,nwalks);
+          Print(" ** Overflow_Error? (%d)", Overflow_Error);
+        */
+        if(printout > 0)
+        {
+          Print("\n//** rec_r_fractal_call: Leaving the %d-th recursion with %d steps.\n",
+                nlev,nwalks);
+          //Print(" ** Overflow_Error? (%d)", Overflow_Error);
+        }
         if(Overflow_Error == TRUE)
           nnflow ++;
 …
     to=clock();
     /* Take the initial form of <G> w.r.t. omega */
+    // Take the initial form of <G> w.r.t. omega
     Gomega = MwalkInitialForm(G, omega);
     xtif=xtif+clock()-to;
+    //polylength = 1 if there is a polynomial in Gomega with at least 3 monomials and 0 otherwise
+    polylength = lengthpoly(Gomega);
+    if(printout > 1)
+    {
+      idString(Gomega,"//** rec_r_fractal_call: Gomega");
+    }
 #ifndef  BUCHBERGER_ALG
     if(isNolVector(omega) == 0)
 …
     else
       hilb_func = hFirstSeries(Gomega,NULL,NULL,last_omega,currRing);
+#endif // BUCHBERGER_ALG
+    if (rParameter(currRing) != NULL)
+      DefRingPar(omega);
+#endif
+    if(ivtarget->length() == nV)
+    {
+      if (rParameter(currRing) != NULL)
+        DefRingPar(omega);
+      else
+        rChangeCurrRing(VMrDefault(omega));
+    }
     else
+      rChangeCurrRing(VMrDefault1(omega)); //Aenderung7
+    {
+      rChangeCurrRing(VMatrRefine(ivtarget,omega));
+    }
     Gomega1 = idrMoveR(Gomega, oRing,currRing);
+    /* Maximal recursion depth, to compute a red. GB */
+    /* Fractal walk with the alternative recursion */
+    /* alternative recursion */
+    // if(nlev == nV || lengthpoly(Gomega1) == 0)
+    // Maximal recursion depth, to compute a red. GB
+    // Fractal walk with the alternative recursion
+    // alternative recursion
     if(nlev == Xnlev || lengthpoly(Gomega1) == 0)
+      //if(nlev == nV) // blind recursion
+    {
+      /*
+      if(Xnlev != nV)
+      {
+        Print("\n// ** Xnlev = %d", Xnlev);
+        ivString(Xtau, "Xtau");
+      }
+      */
+    {
       to=clock();
 #ifdef  BUCHBERGER_ALG
 …
       Gresult =kStd(Gomega1,NULL,isHomog,NULL,hilb_func,0,NULL,omega);
       delete hilb_func;
 #endif // BUCHBERGER_ALG
+#endif
       xtstd=xtstd+clock()-to;
+    }
+    else {
+    else
+    {
       rChangeCurrRing(oRing);
       Gomega1 = idrMoveR(Gomega1, oRing,currRing);
+      Gresult = rec_fractal_call(idCopy(Gomega1),nlev+1,omega);
+    }
+    //convert a Groebner basis from a ring to another ring,
+      Gresult = rec_fractal_call(idCopy(Gomega1),nlev+1,omega,printout);
+    }
+    if(printout > 2)
+    {
+      idString(Gresult,"//** rec_r_fractal_call: M");
+    }
+    //convert a Groebner basis from a ring to another ring
     new_ring = currRing;
 …
     to=clock();
     /* Lifting process */
+    // Lifting process
     F = MLifttwoIdeal(Gomega2, Gresult1, G);
     xtlift=xtlift+clock()-to;
+    if(printout > 2)
+    {
+      idString(F,"//** rec_r_fractal_call: F");
+    }
     idDelete(&Gresult1);
     idDelete(&Gomega2);
 …
     to=clock();
     /* Interreduce G */
+    // Interreduce G
     G = kInterRedCC(F1, NULL);
     xtred=xtred+clock()-to;
 …
+  }
+}
 …
  *                                                                             *
  * The main procedur Mfwalk calls the recursive Subroutine                     *
  * rec_fractal_call to compute the wanted Grï¿œbner basis.                       *
  * At the main procedur we compute the reduced Grï¿œbner basis w.r.t. a "fast"   *
+ * rec_fractal_call to compute the wanted Groebner basis.                      *
+ * At the main procedur we compute the reduced Groebner basis w.r.t. a "fast"  *
  * order, e.g. "dp" and a sequence of weight vectors which are row vectors     *
  * of a matrix. This matrix defines the given monomial order, e.g. "lp"        *
  *******************************************************************************/
+ideal Mfwalk(ideal G, intvec* ivstart, intvec* ivtarget)
+ideal Mfwalk(ideal G, intvec* ivstart, intvec* ivtarget,
+             int reduction, int printout)
+{
+  BITSET save1 = si_opt_1; // save current options
+  if(reduction == 0)
+  {
+    si_opt_1 &= (~Sy_bit(OPT_REDSB)); // no reduced Groebner basis
+    //si_opt_1 &= (~Sy_bit(OPT_REDTAIL)); // not tail reductions
+  }
   Set_Error(FALSE);
   Overflow_Error = FALSE;
 …
       intvec* iv_dp = MivUnit(nV); // define (1,1,...,1)
       intvec* Mdp;
+      if(MivSame(ivstart, iv_dp) != 1)
+        Mdp = MivWeightOrderdp(ivstart);
+      if(ivstart->length() == nV)
+      {
+        if(MivSame(ivstart, iv_dp) != 1)
+          Mdp = MivWeightOrderdp(ivstart);
+        else
+          Mdp = MivMatrixOrderdp(nV);
+      }
       else
+        Mdp = MivMatrixOrderdp(nV);
+      {
+        Mdp = ivstart;
+      }
       Xsigma = Mfpertvector(I, Mdp);
 …
   Xivlp = Mivlp(nV);
+  if(MivComp(ivtarget, Xivlp)  != 1)
+  {
+    if (rParameter(currRing) != NULL)
+      DefRingPar(ivtarget);
+  if(ivtarget->length() == nV)
+  {
+    if(MivComp(ivtarget, Xivlp)  != 1)
+    {
+      if (rParameter(currRing) != NULL)
+        DefRingPar(ivtarget);
+      else
+        rChangeCurrRing(VMrDefault(ivtarget));
+      I1 = idrMoveR(I, oldRing,currRing);
+      Mlp = MivWeightOrderlp(ivtarget);
+      Xtau = Mfpertvector(I1, Mlp);
+    }
     else
+      rChangeCurrRing(VMrDefault1(ivtarget)); //Aenderung1
+    I1 = idrMoveR(I, oldRing,currRing);
+    Mlp = MivWeightOrderlp(ivtarget);
+    Xtau = Mfpertvector(I1, Mlp);
+    {
+      if (rParameter(currRing) != NULL)
+        DefRingParlp();
+      else
+        VMrDefaultlp();
+      I1 = idrMoveR(I, oldRing,currRing);
+      Mlp =  MivMatrixOrderlp(nV);
+      Xtau = Mfpertvector(I1, Mlp);
+    }
+  }
   else
+  {
+    if (rParameter(currRing) != NULL)
+      DefRingParlp();
+    else
+      VMrDefaultlp();
+    I1 = idrMoveR(I, oldRing,currRing);
+    Mlp =  MivMatrixOrderlp(nV);
+    rChangeCurrRing(VMatrDefault(ivtarget));
+    I1 = idrMoveR(I,oldRing,currRing);
+    Mlp =  ivtarget;
     Xtau = Mfpertvector(I1, Mlp);
+  }
 …
   id_Delete(&I, oldRing);
   ring tRing = currRing;
+  if (rParameter(currRing) != NULL)
+    DefRingPar(ivstart);
+  if(ivtarget->length() == nV)
+  {
+    if (rParameter(currRing) != NULL)
+      DefRingPar(ivstart);
+    else
+      rChangeCurrRing(VMrDefault(ivstart));
+  }
   else
+    rChangeCurrRing(VMrDefault1(ivstart)); //Aenderung2
+  {
+    rChangeCurrRing(VMatrDefault(ivstart));
+  }
   I = idrMoveR(I1,tRing,currRing);
 …
   ring helpRing = currRing;
   J = rec_fractal_call(J, 1, ivtarget);
+  J = rec_fractal_call(J,1,ivtarget,printout);
   rChangeCurrRing(oldRing);
 …
   idSkipZeroes(resF);
+  si_opt_1 = save1; //set original options, e. g. option(RedSB)
   delete Xivlp;
   delete Xsigma;
 …
+}
+ideal Mfrwalk(ideal G, intvec* ivstart, intvec* ivtarget,int weight_rad)
+/*******************************************************************************
+ * The implementation of the fractal walk algorithm with random element        *
+ *                                                                             *
+ * The main procedur Mfwalk calls the recursive Subroutine                     *
+ * rec_r_fractal_call to compute the wanted Groebner basis.                    *
+ * At the main procedure we compute the reduced Groebner basis w.r.t. a "fast" *
+ * order, e.g. "dp" and a sequence of weight vectors which are row vectors     *
+ * of a matrix. This matrix defines the given monomial order, e.g. "lp"        *
+ *******************************************************************************/
+ideal Mfrwalk(ideal G, intvec* ivstart, intvec* ivtarget,
+              int weight_rad, int reduction, int printout)
+{
+  BITSET save1 = si_opt_1; // save current options
+  if(reduction == 0)
+  {
+    si_opt_1 &= (~Sy_bit(OPT_REDSB)); // no reduced Groebner basis
+    //si_opt_1 &= (~Sy_bit(OPT_REDTAIL)); // not tail reductions
+  }
   Set_Error(FALSE);
   Overflow_Error = FALSE;
 …
       intvec* iv_dp = MivUnit(nV); // define (1,1,...,1)
       intvec* Mdp;
+      if(MivSame(ivstart, iv_dp) != 1)
+        Mdp = MivWeightOrderdp(ivstart);
+      if(ivstart->length() == nV)
+      {
+        if(MivSame(ivstart, iv_dp) != 1)
+          Mdp = MivWeightOrderdp(ivstart);
+        else
+          Mdp = MivMatrixOrderdp(nV);
+      }
       else
+        Mdp = MivMatrixOrderdp(nV);
+      {
+        Mdp = ivstart;
+      }
       Xsigma = Mfpertvector(I, Mdp);
 …
   Xivlp = Mivlp(nV);
+  if(MivComp(ivtarget, Xivlp)  != 1)
+  {
+    if (rParameter(currRing) != NULL)
+      DefRingPar(ivtarget);
+  if(ivtarget->length() == nV)
+  {
+    if(MivComp(ivtarget, Xivlp)  != 1)
+    {
+      if (rParameter(currRing) != NULL)
+        DefRingPar(ivtarget);
+      else
+        rChangeCurrRing(VMrDefault(ivtarget));
+      I1 = idrMoveR(I, oldRing,currRing);
+      Mlp = MivWeightOrderlp(ivtarget);
+      Xtau = Mfpertvector(I1, Mlp);
+    }
     else
+      rChangeCurrRing(VMrDefault1(ivtarget)); //Aenderung1
+    I1 = idrMoveR(I, oldRing,currRing);
+    Mlp = MivWeightOrderlp(ivtarget);
+    Xtau = Mfpertvector(I1, Mlp);
+    {
+      if (rParameter(currRing) != NULL)
+        DefRingParlp();
+      else
+        VMrDefaultlp();
+      I1 = idrMoveR(I, oldRing,currRing);
+      Mlp =  MivMatrixOrderlp(nV);
+      Xtau = Mfpertvector(I1, Mlp);
+    }
+  }
   else
+  {
+    if (rParameter(currRing) != NULL)
+      DefRingParlp();
+    else
+      VMrDefaultlp();
+    I1 = idrMoveR(I, oldRing,currRing);
+    Mlp =  MivMatrixOrderlp(nV);
+    rChangeCurrRing(VMatrDefault(ivtarget));
+    I1 = idrMoveR(I,oldRing,currRing);
+    Mlp =  ivtarget;
     Xtau = Mfpertvector(I1, Mlp);
+  }
 …
   id_Delete(&I, oldRing);
   ring tRing = currRing;
+  if (rParameter(currRing) != NULL)
+    DefRingPar(ivstart);
+  if(ivtarget->length() == nV)
+  {
+    if (rParameter(currRing) != NULL)
+      DefRingPar(ivstart);
+    else
+      rChangeCurrRing(VMrDefault(ivstart));
+  }
   else
+    rChangeCurrRing(VMrDefault1(ivstart)); //Aenderung2
+  {
+    rChangeCurrRing(VMatrDefault(ivstart));
+  }
   I = idrMoveR(I1,tRing,currRing);
 …
   ideal resF;
   ring helpRing = currRing;
+//ideal G, int nlev, intvec* omtmp, int weight_rad)
   J = rec_r_fractal_call(J, 1, ivtarget,weight_rad);
+  J = rec_r_fractal_call(J,1,ivtarget,weight_rad,printout);
   rChangeCurrRing(oldRing);
 …
   idSkipZeroes(resF);
+  si_opt_1 = save1; //set original options, e. g. option(RedSB)
   delete Xivlp;
   delete Xsigma;
 …
   intvec* hilb_func;
 #endif
   /* to avoid (1,0,...,0) as the target vector */
+  // to avoid (1,0,...,0) as the target vector
   intvec* last_omega = new intvec(nV);
   for(i=nV-1; i>0; i--)
 …
   to=clock();
   /* compute a red. GB w.r.t. the help ring */
+  // compute a red. GB w.r.t. the help ring
   if(MivComp(curr_weight, iv_dp) == 1) //rOrdStr(currRing) = "dp"
     G = MstdCC(G);
 …
       DefRingPar(curr_weight);
     else
       rChangeCurrRing(VMrDefault(curr_weight)); // Aenderung 4
+      rChangeCurrRing(VMrDefault(curr_weight));
     G = idrMoveR(G, XXRing,currRing);
     G = MstdCC(G);
 …
       DefRingPar(curr_weight);
     else
       rChangeCurrRing(VMrDefault(curr_weight)); //Aenderung 5
+      rChangeCurrRing(VMrDefault(curr_weight));
     to=clock();
     Gw = idrMoveR(G, exring,currRing);
 …
       DefRingPar(curr_weight);
     else
       rChangeCurrRing(VMrDefault(curr_weight)); //Aenderung 6
+      rChangeCurrRing(VMrDefault(curr_weight));
     newRing = currRing;
 …
           DefRingPar(target_tmp);
         else
           rChangeCurrRing(VMrDefault(target_tmp)); // Aenderung 8
+          rChangeCurrRing(VMrDefault(target_tmp));
       lpRing = currRing;
 …
           DefRingPar(target_tmp);
         else
           rChangeCurrRing(VMrDefault(target_tmp)); //Aenderung 9
+          rChangeCurrRing(VMrDefault(target_tmp));
       lpRing = currRing;
 …
     else
+    {
       rChangeCurrRing(VMrDefault(curr_weight)); // Aenderung 10
+      rChangeCurrRing(VMrDefault(curr_weight));
+    }
     G = idrMoveR(G, XXRing,currRing);
 …
     else
+    {
       rChangeCurrRing(VMrDefault(curr_weight)); //Aenderung 11
+      rChangeCurrRing(VMrDefault(curr_weight));
+    }
     to=clock();
 …
     else
+    {
       rChangeCurrRing(VMrDefault(curr_weight)); // Aenderung 12
+      rChangeCurrRing(VMrDefault(curr_weight));
+    }
     newRing = currRing;
 …
         else
+        {
           rChangeCurrRing(VMrDefault(target_tmp)); // Aenderung 13
+          rChangeCurrRing(VMrDefault(target_tmp));
+        }
+      }
 …
         else
+        {
           rChangeCurrRing(VMrDefault(target_tmp)); // Aenderung 14
+          rChangeCurrRing(VMrDefault(target_tmp));
+        }
+      }
 …
     else
+    {
       rChangeCurrRing(VMrDefault(curr_weight)); // Aenderung 15
+      rChangeCurrRing(VMrDefault(curr_weight));
+    }
     newRing = currRing;
 …
   //Print("\n// \"Mpwalk\" (1,%d) took %d steps and %.2f sec. Overflow_Error (%d)", tp_deg, nwalk, ((double) clock()-tinput)/1000000, nOverflow_Error);
+<<<<<<< HEAD
+=======
   return(result);
 …
     delete next_weight;
   } //end of while-loop
+>>>>>>> f533f6f7667328bccb271b19b2f603aaebe41596
   Print("\n// Mprwalk took %d steps. Ring= %s;\n", nwalk, rString(currRing));
+  idSkipZeroes(G);
+  si_opt_1 = save1; //set original options, e. g. option(RedSB)
+  baseRing = currRing;
+  rChangeCurrRing(XXRing);
+  ideal Res = idrMoveR(G,baseRing,currRing);
+  delete tmp_weight;
+  delete ivNull;
+  delete exivlp;
+#ifndef BUCHBERGER_ALG
+  delete last_omega;
+#endif
+#ifdef TIME_TEST
+  TimeString(tinput, tostd, tif, tstd, tlift, tred, tnw, nstep);
+#endif
+  return(Res);
+  return(result);
+}
 …
         else
+        {
           rChangeCurrRing(VMrDefault(cw_tmp)); // Aenderung 16
+          rChangeCurrRing(VMrDefault(cw_tmp));
+        }
         G = idrMoveR(Go, XXRing,currRing);
 …
     else
+    {
       rChangeCurrRing(VMrDefault(curr_weight)); // Aenderung 17
+      rChangeCurrRing(VMrDefault(curr_weight));
+    }
     newRing = currRing;
 …
       else
+      {
         rChangeCurrRing(VMrDefault(target_weight)); // Aenderung 18
+        rChangeCurrRing(VMrDefault(target_weight));
+      }
       F1 = idrMoveR(G, newRing,currRing);

Singular/walk.h

Property mode changed from 100644 to 100755

-                      r4e3305
+                      rca3864
 // compute a Groebner basis of an ideal G w.r.t. lexicographic order
 //ideal Mwalk(ideal Go, intvec* orig_M, intvec* target_M);
 ideal Mwalk(ideal Go, intvec* orig_M, intvec* target_M, ring baseRing);
+ideal Mwalk(ideal Go, intvec* orig_M, intvec* target_M, ring baseRing, int reduction, int printout);
 // random walk algorithm to compute a Groebner basis
+ideal Mrwalk(ideal Go, intvec* curr_weight, intvec* target_weight, int weight_rad, int pert_deg, ring baseRing);
+ideal Mrwalk(ideal Go, intvec* orig_M, intvec* target_M, int weight_rad, int pert_deg, int reduction, int printout);
 /* the perturbation walk algorithm */
 ideal Mpwalk(ideal Go, int op_deg, int tp_deg,intvec* curr_weight,intvec* target_weight, int nP);
+ideal Mpwalk(ideal Go, int op_deg, int tp_deg,intvec* curr_weight,intvec* target_weight, int nP, int reduction, int printout);
 /* the perturbation walk algorithm with random element */
+ideal Mprwalk(ideal Go, intvec* curr_weight, intvec* target_weight, int weight_rad, int op_deg, int tp_deg, ring baseRing);
+ideal Mprwalk(ideal Go, intvec* orig_M, intvec* target_M, int weight_rad, int op_deg, int tp_deg, int nP, int reduction, int printout);
 /* The fractal walk algorithm */
 ideal Mfwalk(ideal G, intvec* ivstart, intvec* ivtarget);
+ideal Mfwalk(ideal G, intvec* ivstart, intvec* ivtarget, int reduction, int printout);
 /* The fractal walk algorithm with random element */
 ideal Mfrwalk(ideal G, intvec* ivstart, intvec* ivtarget,int weight_rad);
+ideal Mfrwalk(ideal G, intvec* ivstart, intvec* ivtarget, int weight_rad, int reduction, int printout);
 /* Implement Tran's idea */

Tst/Long/std_l.res.gz.uu

-                      r4083fa
+                      rca3864
+begin 644 std_l.res.gz
+M'XL(")L9OU```W-T9%]L+G)E<P#L_5N3),F5'@B^YZ_P!45F*\+2T:%V<8]@
+M-R"R2[Y09&5>."+[$)+5`@+%9J$+!1`HDNC9F?^^;F9Z.9?O'#7W\(CTR-!Z
+MR`HWO1\]>F[ZJ>I__C_^XW_ZWW>[7?CM[A_^8?>W7_[PSS_]^I>__;+;[W<_
+M_?GG?]G]\L/??OG;[K_^^:]SVJ?_''/WOYYS_X^__?"WW5]__V^__^G'W^]^
+M^/OO_O27GTX?_NM?__RGW7_ZS__Y__4?_I]/C[N__.XO/_PUEQM^O<M_C[_>
+M_7_^T_][]ZM3:[_^Z<?_\JM_S"G3;W>GC__\X\\__O+=W3]^FO^_^^UO8^=^
+M_N%__?IOO_SNEYS[\-M2Y_'7N[_\]<^_W_WI;S_\\M<??_Z7[W[\^9?=[__;
+M[_[ZN]]_WLU___P_/Y_JF9-V?_[K'WZ8_[C+I1]_O?O_Y1]/OS[]\\/??_C]
+M__CEA^]^M93XZ^XWNU_MNEC!=VN]=Z</O_K\]^_"KW]-TG[^G\OWN\]S@51G
+M"'.=J=TY_1]_=?>/N?=AF)/_]8<?_K*VE@D2IE_O_N_\@XPWI/'^L$["/_^X
+M#/C'=:R___.?_O*W/+I`1Q>6T<V9_OAY]Z^?=S_EMOJECW_Y\T__MOO+Y]U_
+M+]_)U/73G&?FB>_^^)OPC[L__M-OEK9.?W5=;K`_SKERD_W2Y&[WWT]$#+G:
+M(:Q??SI]_6/Y.JQ?ER;^=6[B7__I-S^>_B75#].:)S<P'-</:Q/_?7?_/W_W
+MU^]^NBN5/J7TN;&?3N1?.YW2Q]B53.DQ]N(OI^Q_.64OQ!B7MDO&I>6__O#+
+M__CKS[OO_E*:')_(Q$T/OSWERK]"G+J_HJD[=?UO:!*GGDSB-%B3.$UX$J=C
+MF<3I:<LD'@*;Q,.`)O$PH4D\'.N3>'@2DW@,_B0>AY3^XW_=?7=J\#<+K7*%
+MQRFEERHS7ZP]+/T^9H[(D_28V__AI[_]D+\.JM;'B=<Z\U.I^?&H:WX2[/44
+M+/9Z&AA[/4T&>ST="7L]/1:Y\/0DF&L5A`97A8>'PE7A8>G6CW_XX7<_G?[]
+MQ_PY,]N/Y=O2L?SKF!GJQWFV?_RGN;W3_\M\AX<GRDXA1!+\^(?G'[^<R$#6
+MPN?8V[6GN<G`2!-FR9C_9JOPQS^00F09AOXATRGT:1'^R]HPH=)//YZ4X+_+
+M'>_)P@O]2HL3`\YY=_^T"R7?Q`;81SY8\OUFU^<NK=(P=VH5@WEF=BM7Y]RK
+M/(QZZU]__/D/LR+Z^5<EG9!A%8-SY_[VX__YPW?_[F[WV]U#[M_`)R#)O#G[
+M+__VEQ_^_%^_^W?/X<O=O*Y^M;;WJUPVR<-2.J^!N?Q<<"GWUU_M_J__:Y=_
+M_C=20UX6I8Z\!G=I9'/)/+0I+\A,K(G)@#+*,@N3D@)A(E*`C;:/HST1_U>[
+M_^U_V\U?YLKRW__$)$R82(=S[8=0/N[R',[%\T`.0\F2AW*8U.B2V"P?8H-$
+M((4D)G,'N%Q44SD/+H]`R\AP%-19)B\3(2@B'!$1'@TBD-E\1$2@HM2:T<<C
+M:O")-KCVN^<\V"L>?&*]S'4]#?0SX44RA4\3S9/[_W0$@WI2NJ5_$`9&_\"$
+M6?]05G'_D%?QTI'_!QM#S\5HG\1HMGK_Y:<__Y??_?3/LX&:Y&C\E(W>?\R%
+M>2?",D;":WTX\L:>:HUUP6ENM2]S<\2L[%?9F>W?__*[ORUE2]$CR?M$M111
+M'?_R'=(;_4#,6FH#](/6:ST1I_W`)V)EIIFW\L^?R[QPZ=HGZ4IUXF^44NRE
+M7.V+7%UM@_N9K-_]6$8S"AG1)REZ4J1S_;,N_4O./1$A3P:1VY]D^T5\DOKR
+MG_NE-^M$WWU/]50_R7Y-6G;U!R&[^B(987-EKI*TS-6OLK+\?"KSMDI(8`WT
+MLZC,18[C;TN1*5D#/_S\PU]_]\L/__R_?OCQ7_[;+_]\4H2+9?#'3++CH9@#
+M_2H\.0NM`C)J[+_^\+>YCEEI?Y>5=K^*R_QKD-;3'SF7/#++HD\"L=2=_LH^
+MZ(^K:TI:9$9'_\1(I(K_<?5@?U4H]T0I]T0H]Y0H]\/??_GAYS_D9?^W[Q8S
+MZL_SOZOA64CX1$GX!$CXE'W4WV<6&!Z*H=27C]0\^C/)/-'O)/^1?A_*]Z7%
+MI<L_9V=J6*5KS%TX8O[U&\@J?[PK99>>_3F<<BY$(+IP6"5M5GA+.E-Z`Y>\
+M0Y*\?^YS=44Y#3U9Y;S"/E?8BY4^]'FE_WG(E0ZD4K&@AUXOZ&$0"WH8!E`K
+MZ>H@UO$PL'4\K&*4-C$R-W1($G.E1)GP)#C79LEW7G^Q.=.7543^PS_L?O>'
+M/\0YSG&:OY5<ZVPN#!*'=5HB\_^^^]7_]R]S](>QQ^?=K_Z7_EJ88RIJ9DB2
+M,_\NWGE2'&12F608N(\^)''Z\^R6_OQ3ZN$Z"S]^.?7JN__P>>Y6^K(N\_G[
+M[]'W7"^S?O)_)Y$FRGS^#VMMZOOOB3`9N.P>B.P>CG0V3G+E#__C]V0Z<J[L
+MA?V1K9HC$Y1#,FU_/R_"/^[^\./_+&[8D.S8N993AF[)]9LBI89'R=O%@OW]
+MS'Q$-#U*KDXBFC+RHPAX#,4<C?71.,*0K-)<9S)!Q>1&8L^%US]3B#+$,.2O
+MNGFQR-1^3273Y=<PV#64B4WF\#Q_/__A\ZP3_OJ[M*C^YP^__^7/?\U9GXS1
+M_$XMFU65[>`P-G9Q'N12,13:^W"7F]"5T"8TC305Q@=FYXX/Q<X='U@\Y^>?
+M2*$CR46"%F,H08LQI*#%G_ZMA.3'0`(48\A&[2\SU__RXY]^R-'D<=4[?_CA
+MOYYLK'\^:?U3AE,]J[-8,BV36$J?K+Y?0DG-JCFKZW'5/[':Q=#^36R`*+VQ
+M5V;.*M?6G%RPC3R8,B9EQ.I?_NI22S^2ELC2)DV<LC"=.&;M5:3O6!383S_\
+M[@^DY&?QX406D>.41;26>R35WCAH`3$.0D",8Q80>HRC$`\C#TR/J]Z+5"JE
+MEB:6'99_^?G/?_WANU].#MNOYFDF_+MJ1)+I3S_\Z<]__;?OPKREL?Y-<Q/+
+M<)R*93A.Q*;^_9__\F_Y.['^QE7YK:PC(@;CE%GM9^&.CX=L"_[XN<2=QU7_
+M_>FD-7[Z8?>G\ID&*\=5^^1?AK:=W0;&D4>F:L<4=?G3&KY<PIBYP11F82'V
+MGUEX?4S*J=2839-8YY]6Y7DBWVR0W^]$(X\BIC`^,G=^?&2RYD]EQAY)['A\
+M?"1;$^-C4<7CTT.<OWGS;;7N?SBQX>]^_I<?%I=HWNQ;+?M?_AQ#RW&W;;7\
+MD]+.(Y[U71[M4Y]F\%_I##Z-V0[/QE:JJ&0ZS)E(\&'6GDO;)<MC'L@TQ[CS
+M7L3<ZV4[XI<_L_V(Z:&G\SL]C-&>C+U0[DW^Z_/N7S-MIX>#FOG=/_UFQPRX
+M/])6'SD73.$A<8&(HV1K^H^9!:;0I\QY!:5P]HFJP^<Y&%;Z%L;,8+/ZH)[Q
+M%`X\+:[94Y[/)X%)\CVF?/_ZXT\_J4#-U#\4NO>Y=TOXX;?93IOZW),\[CYW
+M``UF'];A_#<RG/ZQE-`#&AYDJC6DH2\Y\:"&W-W_.W\Z_%I\>*2+;QH??DU^
+MA"P5I[$GJ^KRQ33-\C\3;QS18IK&0WTQ3>-C;3%-TP.1F-/4;UE.T\B6TW3F
+MNICDNCB<LRX.9ZV+@[,N#@>?WP]$SAP?+'X_]HK?C^.Y_'X\>/Q^?*QQ\>.#
+MXN+'7G#QX\BX^/%`N/CQ6+CX\=3:S&Z<;8;^X6$H[3W]-H5.])3]Z@]_R<&I
+MZ:F8N-.L)/[A'_[\EU]^_///WYT6RB]EB+/*B`FS67*BVH\__T"2!U++:1P+
+MQXN6_Q:;/I'VI^7?_[C^_;?YWS\L__['OY&.3:3*0YGIV<\!6K'_O#M\7JF@
+MPN!S0/KO)Q.J^_MW)P.TOU_^GO]W^G5REXJU]>]G:VSW[__][D^_^]/O_M?_
+M^.7__/</(L-J@K$L_?CP.(Z/2POWL\%P<DO6-I9?)Q=F_$1^]W?=2%-C1VA:
+MG]*NW+L]&?_^BN/O3^9/?^GX]VS\^^N/O_3NM>9?CY^,2(U>SW?AA=<<_=O-
+M_MX9_MX9_CN>_.>YVB^[Y[G:+Z<Q/[.&/N<.?'E7DYI&M1?#VI-A[5]C6&^W
+M4F])4G^-M?JA)?5IQ/MP>'@(=-"<"$M?H/".O8PI[Y,!SB;`GA%@_WH$:!*@
+M28!FJS5;K=EJS59KDKI)ZF:K-5NM28`/+0&:K=9LM6:KW?!D-4G=)'6SU6[9
+M5NO71C^MK75K=Z[<`ET!O5@!QBKOG-5QY=[MR?CWMS+^/5?EKSG^MYM_S?D]

r4083fa	rca3864
4	4	#"$SINGULAR_EXECUTABLE" -teq "$srcdir/ederc.tst" \|\| exit 1
5	5	#"$SINGULAR_EXECUTABLE" -teq "$srcdir/syzextra.tst" \|\| exit 1
6		"$SINGULAR_EXECUTABLE" -tec 'LIB "schreyer.lib"; listvar(Top); proc T(){ Schreyer::testSimple(1); /* Schreyer::testAGR(0); Schreyer::testAGRhard(0); */ } T(); $' \|\| exit 1
	6	"$SINGULAR_EXECUTABLE" -tec 'LIB "schreyer.lib"; listvar(Top); proc T(){ Schreyer::testSimple(1, 0); /* Schreyer::testAGR(0); Schreyer::testAGRhard(0); */ } T(); $' \|\| exit 1

Context Navigation

Changeset ca3864 in git

Legend:

Makefile.am

Singular/LIB/grwalk.lib

Singular/LIB/modwalk.lib

Singular/LIB/normaliz.lib

Singular/LIB/primdec.lib

Singular/LIB/ring.lib

Singular/LIB/rinvar.lib

Singular/LIB/rwalk.lib

Singular/LIB/sagbi.lib

Singular/LIB/schreyer.lib

Singular/LIB/solve.lib

Singular/LIB/swalk.lib

Singular/LIB/tropical.lib

Singular/dyn_modules/Order/nforder_elt.cc

Singular/dyn_modules/syzextra/mod_main.cc

Singular/dyn_modules/syzextra/syzextra.cc

Singular/dyn_modules/syzextra/test.sh

Singular/emacs.cc

Singular/extra.cc

Singular/iparith.cc

Singular/ipshell.cc

Singular/test.cc

Singular/walk.cc

Singular/walk.h

Tst/Long/std_l.res.gz.uu