Changeset 36b81ac in git

Timestamp:

Sep 1, 2015, 3:13:14 PM (8 years ago)

Author:

Stephan Oberfranz <oberfran@…>

Branches:

(u'spielwiese', '0d6b7fcd9813a1ca1ed4220cfa2b104b97a0a003')

Children:

510257fc6c7ff9c0c28e81f62f6fe06e63f024f8b430ca2b1337f52e1932f689e451e9abb002ec4a

Parents:

74fe3587102ed73b3858258975abbe6d63139abfcd38fbd954495900afc188a0e871f8586db00535

Message:

update
Merge branch 'spielwiese' of github.com:Singular/Sources into spielwiese

Files:

• Singular/LIB/chern.lib (added)
• Singular/LIB/grwalk.lib (modified) (10 diffs)
• Singular/LIB/modstd.lib (modified) (2 diffs)
• Singular/LIB/modwalk.lib (modified) (1 diff, 1 prop)
• Singular/LIB/multigrading.lib (modified) (1 diff)
• Singular/LIB/primdec.lib (modified) (1 diff)
• Singular/LIB/rwalk.lib (modified) (11 diffs, 1 prop)
• Singular/LIB/swalk.lib (modified) (1 prop)
• Singular/extra.cc (modified) (11 diffs)
• Singular/iparith.cc (modified) (2 diffs)
• Singular/walk.cc (modified) (171 diffs, 1 prop)
• Singular/walk.h (modified) (1 diff, 1 prop)
• Tst/Long/primdec_l.res.gz.uu (modified) (1 diff)
• Tst/Long/primdec_l.stat (modified) (1 diff)
• Tst/New/quotient_cleardenom.res.gz.uu (modified) (1 diff)
• Tst/New/quotient_cleardenom.stat (modified) (1 diff)
• Tst/New/sat_cleardenom.res.gz.uu (modified) (1 diff)
• Tst/New/sat_cleardenom.stat (modified) (1 diff)
• Tst/Short/bug_42.res.gz.uu (modified) (1 diff)
• Tst/Short/bug_42.stat (modified) (1 diff)
• Tst/Short/bug_tr224.res.gz.uu (modified) (1 diff)
• Tst/Short/bug_tr224.stat (modified) (1 diff)
• Tst/Short/bug_tr707.res.gz.uu (modified) (1 diff)
• Tst/Short/bug_tr707.stat (modified) (1 diff)
• Tst/Short/bug_tr712.res.gz.uu (added)
• Tst/Short/bug_tr712.stat (added)
• Tst/Short/bug_tr712.tst (added)
• Tst/Short/bug_tr723.res.gz.uu (modified) (1 diff)
• Tst/Short/bug_tr723.stat (modified) (1 diff)
• Tst/Short/bug_tr723.tst (modified) (1 diff)
• Tst/Short/ok_s.lst (modified) (1 diff)
• doc/NEWS.texi (modified) (1 diff)
• doc/plural.doc (modified) (previous)
• kernel/GBEngine/kstd1.cc (modified) (2 diffs)
• kernel/GBEngine/kstd2.cc (modified) (4 diffs)
• kernel/GBEngine/kutil.cc (modified) (4 diffs)
• kernel/GBEngine/kutil.h (modified) (1 diff)
• libpolys/polys/monomials/p_polys.cc (modified) (1 diff)
• libpolys/polys/prCopy.cc (modified) (2 diffs)

Singular/LIB/grwalk.lib

@@ -255 +255 @@
 }
 
-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
@@ -274 +274 @@
    string ord_str =   OSCTW[2];
    intvec curr_weight   =   OSCTW[3]; /* original weight vector */
-   intvec target_weight =   OSCTW[4]; /* terget weight vector */
+   intvec target_weight =   OSCTW[4]; /* target weight vector */
    kill OSCTW;
    option(redSB);
@@ -284 +284 @@
    //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;
@@ -299 +299 @@
   //** compute a Groebner basis of I w.r.t. lp.
   ring r = 32003,(z,y,x), lp;
-  ideal I = y3+xyz+y2z+xz3, 3+xy+x2y+y2z;
-  gwalk(I);
+  ideal I = zy2+yx2+yx+3,
+            z3x+y3+zyx-yx2-yx-3,
+            z2yx3-y5+z2yx2+y3x2+y2x3+y3x+y2x2+3z2x+3y2+3yx,
+            zyx5+y6-y4x2-y3x3+2zyx4-y4x-y3x2+zyx3-3z2yx+3zx3-3y3-3y2x+3zx2,
+            yx7-y7+y5x2+y4x3+3yx6+y5x+y4x2+3yx5-6zyx3+yx4+3x5+3y4+3y3x-6zyx2+6x4+3x3-9zx;
+  gwalk(I,0,1);
 }
 
@@ -346 +350 @@
 }
 
-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
@@ -372 +376 @@
 
    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;
@@ -387 +391 @@
     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);
 }
 
@@ -437 +443 @@
 }
 
-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
@@ -477 +483 @@
   ideal G = fetch(xR, Go);
 
-  G = system("Mpwalk", G, n1, n2, curr_weight, target_weight,nP);
-
+  G = system("Mpwalk",G,n1,n2,curr_weight,target_weight,nP,reduction,printout);
+ 
   setring xR;
-  //kill Go;
+  //kill Go; //unused
 
   keepring basering;
@@ -492 +498 @@
     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/modstd.lib

@@ -1 +1 @@
 ///////////////////////////////////////////////////////////////////////////////
-version="version modstd.lib 4.0.0.0 May_2014 "; // $Id$
+version="version modstd.lib 4.0.2.0 Aug_2015 "; // $Id$
 category="Commutative Algebra";
 info="
@@ -219 +219 @@
 /* test if 'command' applied to 'args' in characteristic p is the same as
    'result' mapped to characteristic p */
-static proc pTest_std(string command, list args, ideal result, int p)
+static proc pTest_std(string command, alias list args, alias ideal result,
+    int p)
 {
     /* change to characteristic p */

Singular/LIB/modwalk.lib

@@ -16 +16 @@
 
 PROCEDURES:
-modWalk(ideal,int,int[,int,int,int,int]);        standard basis conversion of I using modular methods (chinese remainder)
+
+modWalk(I,#);                   standard basis conversion of I by Groebner Walk using modular methods
+modrWalk(I,radius,pertdeg,#);   standard basis conversion of I by Random Walk using modular methods
+modfWalk(I,#);                  standard basis conversion of I by Fractal Walk using modular methods
+modfrWalk(I,radius,#);          standard basis conversion of I by Random Fractal Walk using modular methods
 ";
 
-LIB "poly.lib";
-LIB "ring.lib";
-LIB "parallel.lib";
 LIB "rwalk.lib";
 LIB "grwalk.lib";
-LIB "modstd.lib";
-
-
-////////////////////////////////////////////////////////////////////////////////
-
-static proc modpWalk(def II, int p, int variant, list #)
-"USAGE:  modpWalk(I,p,#); I ideal, p integer, variant integer
-ASSUME:  If size(#) > 0, then
-           #[1] is an intvec describing the current weight vector
-           #[2] is an intvec describing the target weight vector
-RETURN:  ideal - a standard basis of I mod p, integer - p
-NOTE:    The procedure computes a standard basis of the ideal I modulo p and
-         fetches the result to the basering.
-EXAMPLE: example modpWalk; shows an example
-"
-{
-  option(redSB);
-  int k,nvar@r;
-  def R0 = basering;
-  string ordstr_R0 = ordstr(R0);
-  list rl = ringlist(R0);
-  int sizerl = size(rl);
-  int neg = 1 - attrib(R0,"global");
-  if(typeof(II) == "ideal")
-  {
-    ideal I = II;
+LIB "modular.lib";
+
+proc modWalk(ideal I, list #)
+"USAGE:   modWalk(I, [, v, w]); I ideal, v intvec, w intvec
+RETURN:   a standard basis of I
+NOTE:     The procedure computes a standard basis of I (over the rational
+          numbers) by using modular methods.
+SEE ALSO: modular
+EXAMPLE:  example modWalk; shows an example"
+{
+    /* read optional parameter */
+    if (size(#) > 0) {
+        if (size(#) == 1) {
+            intvec w = #[1];
+        }
+        if (size(#) == 2) {
+            intvec v = #[1];
+            intvec w = #[2];
+        }
+        if (size(#) > 2 || typeof(#[1]) != "intvec") {
+            ERROR("wrong optional parameter");
+        }
+    }
+
+    /* save options */
+    intvec opt = option(get);
+    option(redSB);
+
+    /* set additional parameters */
+    int reduction = 1;
+    int printout = 0;
+
+    /* call modular() */
+    if (size(#) > 0) {
+        I = modular("gwalk", list(I,reduction,printout,#));
+    }
+    else {
+        I = modular("gwalk", list(I,reduction,printout));
+    }
+
+    /* return the result */
+    attrib(I, "isSB", 1);
+    option(set, opt);
+    return(I);
+}
+example
+{
+    "EXAMPLE:";
+    echo = 2;
+    ring R1 = 0, (x,y,z,t), dp;
+    ideal I = 3x3+x2+1, 11y5+y3+2, 5z4+z2+4;
+    I = std(I);
+    ring R2 = 0, (x,y,z,t), lp;
+    ideal I = fetch(R1, I);
+    ideal J = modWalk(I);
+    J;
+}
+
+proc modrWalk(ideal I, int radius, int pertdeg, list #)
+"USAGE:   modrWalk(I, radius, pertdeg[, v, w]);
+          I ideal, radius int, pertdeg int, v intvec, w intvec
+RETURN:   a standard basis of I
+NOTE:     The procedure computes a standard basis of I (over the rational
+          numbers) by using modular methods.
+SEE ALSO: modular
+EXAMPLE:  example modrWalk; shows an example"
+{
+    /* read optional parameter */
+    if (size(#) > 0) {
+        if (size(#) == 1) {
+            intvec w = #[1];
+        }
+        if (size(#) == 2) {
+            intvec v = #[1];
+            intvec w = #[2];
+        }
+        if (size(#) > 2 || typeof(#[1]) != "intvec") {
+            ERROR("wrong optional parameter");
+        }
+    }
+
+    /* save options */
+    intvec opt = option(get);
+    option(redSB);
+
+    /* set additional parameters */
+    int reduction = 1;
+    int printout = 0;
+
+    /* call modular() */
+    if (size(#) > 0) {
+        I = modular("rwalk", list(I,radius,pertdeg,reduction,printout,#));
+    }
+    else {
+        I = modular("rwalk", list(I,radius,pertdeg,reduction,printout));
+    }
+
+    /* return the result */
+    attrib(I, "isSB", 1);
+    option(set, opt);
+    return(I);
+}
+example
+{
+    "EXAMPLE:";
+    echo = 2;
+    ring R1 = 0, (x,y,z,t), dp;
+    ideal I = 3x3+x2+1, 11y5+y3+2, 5z4+z2+4;
+    I = std(I);
+    ring R2 = 0, (x,y,z,t), lp;
+    ideal I = fetch(R1, I);
     int radius = 2;
-    int pert_deg = 2;
-  }
-  if(typeof(II) == "list" && typeof(II[1]) == "ideal")
-  {
-    ideal I = II[1];
-    if(size(II) == 2)
-    {
-      int radius = II[2];
-      int pert_deg = 2;
-    }
-    if(size(II) == 3)
-    {
-      int radius = II[2];
-      int pert_deg = II[3];
-    }
-  }
-  rl[1] = p;
-  int h = homog(I);
-  def @r = ring(rl);
-  setring @r;
-  ideal i = fetch(R0,I);
-  string order;
-  if(system("nblocks") <= 2)
-  {
-    if(find(ordstr_R0, "M") + find(ordstr_R0, "lp") + find(ordstr_R0, "rp") <= 0)
-    {
-      order = "simple";
-    }
-  }
-
-//-------------------------  make i homogeneous  -----------------------------
-  if(!mixedTest() && !h)
-  {
-    if(!((find(ordstr_R0, "M") > 0) || (find(ordstr_R0, "a") > 0) || neg))
-    {
-      if(!((order == "simple") || (sizerl > 4)))
-      {
-        list rl@r = ringlist(@r);
-        nvar@r = nvars(@r);
-        intvec w;
-        for(k = 1; k <= nvar@r; k++)
-        {
-          w[k] = deg(var(k));
-        }
-        w[nvar@r + 1] = 1;
-        rl@r[2][nvar@r + 1] = "homvar";
-        rl@r[3][2][2] = w;
-        def HomR = ring(rl@r);
-        setring HomR;
-        ideal i = imap(@r, i);
-        i = homog(i, homvar);
-      }
-    }
-  }
-
-//-------------------------  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);
-    }
-    else
-    {
-      i = rwalk(i,radius,pert_deg);
-    }
-  }
-  if(variant == 2)
-  {
-    if(size(#) == 2)
-    {
-      i = gwalk(i,#);
-    }
-    else
-    {
-      i = gwalk(i);
-    }
-  }
-  if(variant == 3)
-  {
-    if(size(#) == 2)
-    {
-      i = frandwalk(i,radius,#);
-    }
-    else
-    {
-      i = frandwalk(i,radius);
-    }
-  }
-  if(variant == 4)
-  {
-    if(size(#) == 2)
-    {
-      i=fwalk(i,#);
-    }
-    else
-    {
-      i=fwalk(i);
-    }
-  }
-  if(variant == 5)
-  {
-    if(size(#) == 2)
-    {
-     i=prwalk(i,radius,pert_deg,pert_deg,#);
-    }
-    else
-    {
-      i=prwalk(i,radius,pert_deg,pert_deg);
-    }
-  }
-  if(variant == 6)
-  {
-    if(size(#) == 2)
-    {
-      i=pwalk(i,pert_deg,pert_deg,#);
-    }
-    else
-    {
-      i=pwalk(i,pert_deg,pert_deg);
-    }
-  }
-
-  if(!mixedTest() && !h)
-  {
-    if(!((find(ordstr_R0, "M") > 0) || (find(ordstr_R0, "a") > 0) || neg))
-    {
-      if(!((order == "simple") || (sizerl > 4)))
-      {
-        i = subst(i, homvar, 1);
-        i = simplify(i, 34);
-        setring @r;
-        i = imap(HomR, i);
-        i = interred(i);
-        kill HomR;
-      }
-    }
-  }
-  setring R0;
-  return(list(fetch(@r,i),p));
-}
-example
-{
-  "EXAMPLE:"; echo = 2;
-  option(redSB);
-
-  int p = 181;
-  intvec a = 2,1,3,4;
-  intvec b = 1,9,1,1;
-  ring ra = 0,x(1..4),(a(a),lp);
-  ideal I = std(cyclic(4));
-  ring rb = 0,x(1..4),(a(b),lp);
-  ideal I = imap(ra,I);
-  modpWalk(I,p,1,a,b);
-  std(I);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-proc modWalk(def II, int variant, list #)
-"USAGE:  modWalk(II); II ideal or list(ideal,int)
-ASSUME:  If variant =
-@*       - 1 the Random Walk algorithm with radius II[2] is applied
-           to II[1] if II = list(ideal, int). It is applied to II with radius 2
-           if II is an ideal.
-@*       - 2, the Groebner Walk algorithm is applied to II[1] or to II, respectively.
-@*       - 3, the Fractal Walk algorithm with random element is applied to II[1] or II,
-           respectively.
-@*       - 4, the Fractal Walk algorithm is applied to II[1] or II, respectively.
-@*       - 5, the Perturbation Walk algorithm with random element is applied to II[1]
-           or II, respectively, with radius II[3] and perturbation degree II[2].
-@*       - 6, the Perturbation Walk algorithm is applied to II[1] or II, respectively,
-           with perturbation degree II[3].
-         If size(#) > 0, then # contains either 1, 2 or 4 integers such that
-@*       - #[1] is the number of available processors for the computation,
-@*       - #[2] is an optional parameter for the exactness of the computation,
-                if #[2] = 1, the procedure computes a standard basis for sure,
-@*       - #[3] is the number of primes until the first lifting,
-@*       - #[4] is the constant number of primes between two liftings until
-           the computation stops.
-RETURN:  a standard basis of I if no warning appears.
-NOTE:    The procedure converts a standard basis of I (over the rational
-         numbers) from the ordering \"a(v),lp\", "dp\" or \"Dp\" to the ordering
-         \"(a(w),lp\" or \"a(1,0,...,0),lp\" by using modular methods.
-         By default the procedure computes a standard basis of I for sure, but
-         if the optional parameter #[2] = 0, it computes a standard basis of I
-         with high probability.
-EXAMPLE: example modWalk; shows an example
-"
-{
-  int TT = timer;
-  int RT = rtimer;
-  int i,j,pTest,sizeTest,weighted,n1;
-  bigint N;
-
-  def R0 = basering;
-  list rl = ringlist(R0);
-  if((npars(R0) > 0) || (rl[1] > 0))
-  {
-    ERROR("Characteristic of basering should be zero, basering should have no parameters.");
-  }
-
-  if(typeof(II) == "ideal")
-  {
-    ideal I = II;
-    kill II;
-    list II;
-    II[1] = I;
-    II[2] = 2;
-    II[3] = 2;
-  }
-  else
-  {
-    if(typeof(II) == "list" && typeof(II[1]) == "ideal")
-    {
-      ideal I = II[1];
-      if(size(II) == 1)
-      {
-        II[2] = 2;
-        II[3] = 2;
-      }
-      if(size(II) == 2)
-      {
-        II[3] = 2;
-      }
-
-    }
-    else
-    {
-      ERROR("Unexpected type of input.");
-    }
-  }
-
-//--------------------  Initialize optional parameters  ------------------------
-  n1 = system("--cpus");
-  if(size(#) == 0)
-  {
-    int exactness = 1;
-    int n2 = 10;
-    int n3 = 10;
-  }
-  else
-  {
-    if(size(#) == 1)
-    {
-      if(typeof(#[1]) == "int")
-      {
-        if(#[1] < n1)
-        {
-          n1 = #[1];
-        }
-        int exactness = 1;
-        if(n1 >= 10)
-        {
-          int n2 = n1 + 1;
-          int n3 = n1;
-        }
-        else
-        {
-          int n2 = 10;
-          int n3 = 10;
-        }
-      }
-      else
-      {
-        ERROR("Unexpected type of input.");
-      }
-    }
-    if(size(#) == 2)
-    {
-      if(typeof(#[1]) == "int" && typeof(#[2]) == "int")
-      {
-        if(#[1] < n1)
-        {
-          n1 = #[1];
-        }
-        int exactness = #[2];
-        if(n1 >= 10)
-        {
-          int n2 = n1 + 1;
-          int n3 = n1;
-        }
-        else
-        {
-          int n2 = 10;
-          int n3 = 10;
-        }
-      }
-      else
-      {
-        if(typeof(#[1]) == "intvec" && typeof(#[2]) == "intvec")
-        {
-          intvec curr_weight = #[1];
-          intvec target_weight = #[2];
-          weighted = 1;
-          int n2 = 10;
-          int n3 = 10;
-          int exactness = 1;
-        }
-        else
-        {
-          ERROR("Unexpected type of input.");
-        }
-      }
-    }
-    if(size(#) == 3)
-    {
-      if(typeof(#[1]) == "intvec" && typeof(#[2]) == "intvec" && typeof(#[3]) == "int")
-      {
-        intvec curr_weight = #[1];
-        intvec target_weight = #[2];
-        weighted = 1;
-        n1 = #[3];
-        int n2 = 10;
-        int n3 = 10;
-        int exactness = 1;
-      }
-      else
-      {
-        ERROR("Unexpected type of input.");
-      }
-    }
-    if(size(#) == 4)
-    {
-      if(typeof(#[1]) == "intvec" && typeof(#[2]) == "intvec" && typeof(#[3]) == "int"
-          && typeof(#[4]) == "int")
-      {
-        intvec curr_weight = #[1];
-        intvec target_weight = #[2];
-        weighted = 1;
-        if(#[1] < n1)
-        {
-          n1 = #[3];
-        }
-        int exactness = #[4];
-        if(n1 >= 10)
-        {
-          int n2 = n1 + 1;
-          int n3 = n1;
-        }
-        else
-        {
-          int n2 = 10;
-          int n3 = 10;
-        }
-      }
-      else
-      {
-        if(typeof(#[1]) == "int" && typeof(#[2]) == "int" && typeof(#[3]) == "int" && typeof(#[4]) == "int")
-        {
-          if(#[1] < n1)
-          {
-            n1 = #[1];
-          }
-          int exactness = #[2];
-          if(n1 >= #[3])
-          {
-            int n2 = n1 + 1;
-          }
-          else
-          {
-            int n2 = #[3];
-          }
-          if(n1 >= #[4])
-          {
-            int n3 = n1;
-          }
-          else
-          {
-            int n3 = #[4];
-          }
-        }
-        else
-        {
-          ERROR("Unexpected type of input.");
-        }
-      }
-    }
-    if(size(#) == 6)
-    {
-      if(typeof(#[1]) == "intvec" && typeof(#[2]) == "intvec" && typeof(#[3]) == "int" && typeof(#[4]) == "int" && typeof(#[5]) == "int" && typeof(#[6]) == "int")
-      {
-        intvec curr_weight = #[1];
-        intvec target_weight = #[2];
-        weighted = 1;
-        if(#[3] < n1)
-        {
-          n1 = #[3];
-        }
-        int exactness = #[4];
-        if(n1 >= #[5])
-        {
-          int n2 = n1 + 1;
-        }
-        else
-        {
-          int n2 = #[5];
-        }
-        if(n1 >= #[6])
-        {
-          int n3 = n1;
-        }
-        else
-        {
-          int n3 = #[6];
-        }
-      }
-      else
-      {
-        ERROR("Expected list(intvec,intvec,int,int,int,int) as optional parameter list.");
-      }
-    }
-    if(size(#) == 1 || size(#) == 5 || size(#) > 6)
-    {
-      ERROR("Expected 0,2,3,4 or 5 optional arguments.");
-    }
-  }
-  if(printlevel >= 10)
-  {
-  "n1 = "+string(n1)+", n2 = "+string(n2)+", n3 = "+string(n3)+", exactness = "+string(exactness);
-  }
-
-//-------------------------  Save current options  -----------------------------
-  intvec opt = option(get);
-  //option(redSB);
-
-//--------------------  Initialize the list of primes  -------------------------
-  int tt = timer;
-  int rt = rtimer;
-  int en = 2134567879;
-  int an = 1000000000;
-  intvec L = primeList(I,n2);
-  if(n2 > 4)
-  {
-  //  L[5] = prime(random(an,en));
-  }
-  if(printlevel >= 10)
-  {
-    "CPU-time for primeList: "+string(timer-tt)+" seconds.";
-    "Real-time for primeList: "+string(rtimer-rt)+" seconds.";
-  }
-  int h = homog(I);
-  list P,T1,T2,LL,Arguments,PP;
-  ideal J,K,H;
-
-//-------------------  parallelized Groebner Walk in positive characteristic  --------------------
-
-  if(weighted)
-  {
-    for(i=1; i<=size(L); i++)
-    {
-      Arguments[i] = list(II,L[i],variant,list(curr_weight,target_weight));
-    }
-  }
-  else
-  {
-    for(i=1; i<=size(L); i++)
-    {
-      Arguments[i] = list(II,L[i],variant);
-    }
-  }
-  P = parallelWaitAll("modpWalk",Arguments);
-  for(i=1; i<=size(P); i++)
-  {
-    T1[i] = P[i][1];
-    T2[i] = bigint(P[i][2]);
-  }
-
-  while(1)
-  {
-    LL = deleteUnluckyPrimes(T1,T2,h);
-    T1 = LL[1];
-    T2 = LL[2];
-//-------------------  Now all leading ideals are the same  --------------------
-//-------------------  Lift results to basering via farey  ---------------------
-
-    tt = timer; rt = rtimer;
-    N = T2[1];
-    for(i=2; i<=size(T2); i++)
-    {
-      N = N*T2[i];
-    }
-    H = chinrem(T1,T2);
-    J = parallelFarey(H,N,n1);
-    //J=farey(H,N);
-    if(printlevel >= 10)
-    {
-      "CPU-time for lifting-process is "+string(timer - tt)+" seconds.";
-      "Real-time for lifting-process is "+string(rtimer - rt)+" seconds.";
-    }
-
-//----------------  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);
-    if(printlevel >= 10)
-    {
-      "CPU-time for pTest is "+string(timer - tt)+" seconds.";
-      "Real-time for pTest is "+string(rtimer - rt)+" seconds.";
-    }
-    if(pTest)
-    {
-      if(printlevel >= 10)
-      {
-        "CPU-time for computation without final tests is "+string(timer - TT)+" seconds.";
-        "Real-time for computation without final tests is "+string(rtimer - RT)+" seconds.";
-      }
-      attrib(J,"isSB",1);
-      if(exactness == 0)
-      {
-        option(set, opt);
-        return(J);
-      }
-      else
-      {
-        tt = timer;
-        rt = rtimer;
-        sizeTest = 1 - isIdealIncluded(I,J,n1);
-        if(printlevel >= 10)
-        {
-          "CPU-time for checking if I subset <G> is "+string(timer - tt)+" seconds.";
-          "Real-time for checking if I subset <G> is "+string(rtimer - rt)+" seconds.";
-        }
-        if(sizeTest == 0)
-        {
-          tt = timer;
-          rt = rtimer;
-          K = std(J);
-          if(printlevel >= 10)
-          {
-            "CPU-time for last std-computation is "+string(timer - tt)+" seconds.";
-            "Real-time for last std-computation is "+string(rtimer - rt)+" seconds.";
-          }
-          if(size(reduce(K,J)) == 0)
-          {
-            option(set, opt);
-            return(J);
-          }
-        }
-      }
-    }
-//--------------  We do not already have a standard basis of I, therefore do the main computation for more primes  --------------
-
-    T1 = H;
-    T2 = N;
-    j = size(L)+1;
-    tt = timer; rt = rtimer;
-    L = primeList(I,n3,L,n1);
-    if(printlevel >= 10)
-    {
-      "CPU-time for primeList: "+string(timer-tt)+" seconds.";
-      "Real-time for primeList: "+string(rtimer-rt)+" seconds.";
-    }
-    Arguments = list();
-    PP = list();
-    if(weighted)
-    {
-      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));
-      }
-    }
-    else
-    {
-      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);
-      }
-    }
-    PP = parallelWaitAll("modpWalk",Arguments);
-    if(printlevel >= 10)
-    {
-      "parallel modpWalk";
-    }
-    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]);
-    }
-  }
-  if(printlevel >= 10)
-  {
-    "CPU-time for computation with final tests is "+string(timer - TT)+" seconds.";
-    "Real-time for computation with final tests is "+string(rtimer - RT)+" seconds.";
-  }
-}
-
-example
-{
-  "EXAMPLE:";
-  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);
-  J;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-static proc isIdealIncluded(ideal I, ideal J, int n1)
-"USAGE:  isIdealIncluded(I,J,int n1); I ideal, J ideal, n1 integer
-"
-{
-  if(n1 > 1)
-  {
-    int k;
-    list args,results;
-    for(k=1; k<=size(I); k++)
-    {
-      args[k] = list(ideal(I[k]),J,1);
-    }
-    results = parallelWaitAll("reduce",args);
-    for(k=1; k<=size(results); k++)
-    {
-      if(results[k] == 0)
-      {
-        return(1);
-      }
-    }
-    return(0);
-  }
-  else
-  {
-    if(reduce(I,J,1) == 0)
-    {
-      return(1);
-    }
-    else
-    {
-      return(0);
-    }
-  }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-static proc parallelChinrem(list T1, list T2, int n1)
-"USAGE:  parallelChinrem(T1,T2); T1 list of ideals, T2 list of primes, n1 integer"
-{
-  int i,j,k;
-
-  ideal H,J;
-
-  list arguments_chinrem,results_chinrem;
-  for(i=1; i<=size(T1); i++)
-  {
-    J = ideal(T1[i]);
-    attrib(J,"isSB",1);
-    arguments_chinrem[size(arguments_chinrem)+1] = list(list(J),T2);
-  }
-  results_chinrem = parallelWaitAll("chinrem",arguments_chinrem);
-    for(j=1; j <= size(results_chinrem); j++)
-    {
-      J = results_chinrem[j];
-      attrib(J,"isSB",1);
-      if(isIdealIncluded(J,H,n1) == 0)
-      {
-        if(H == 0)
-        {
-          H = J;
-        }
-        else
-        {
-          H = H,J;
-        }
-      }
-    }
-  return(H);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-static proc parallelFarey(ideal H, bigint N, int n1)
-"USAGE:  parallelFarey(H,N,n1); H ideal, N bigint, n1 integer
-"
-{
-  int i,j;
-  int ii = 1;
-  list arguments_farey,results_farey;
-  for(i=1; i<=size(H); i++)
-  {
-    for(j=1; j<=size(H[i]); j++)
-    {
-      arguments_farey[size(arguments_farey)+1] = list(H[i][j],N);
-    }
-  }
-  results_farey = parallelWaitAll("farey",arguments_farey);
-  ideal J,K;
-  poly f_farey;
-  while(ii<=size(results_farey))
-  {
-    for(i=1; i<=size(H); i++)
-    {
-      f_farey = 0;
-      for(j=1; j<=size(H[i]); j++)
-      {
-        f_farey = f_farey + results_farey[ii][1];
-        ii++;
-      }
-      K = ideal(f_farey);
-      attrib(K,"isSB",1);
-      attrib(J,"isSB",1);
-      if(isIdealIncluded(K,J,n1) == 0)
-      {
-        if(J == 0)
-        {
-          J = K;
-        }
-        else
-        {
-          J = J,K;
-        }
-      }
-    }
-  }
-  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()
-"USAGE:  mixedTest();
-RETURN:  1 if ordering of basering is mixed, 0 else
-EXAMPLE: example mixedTest(); shows an example
-"
-{
-   int i,p,m;
-   for(i = 1; i <= nvars(basering); i++)
-   {
-      if(var(i) > 1)
-      {
-         p++;
-      }
-      else
-      {
-         m++;
-      }
-   }
-   if((p > 0) && (m > 0)) { return(1); }
-   return(0);
-}
-example
-{ "EXAMPLE:"; echo = 2;
-   ring R1 = 0,(x,y,z),dp;
-   mixedTest();
-   ring R2 = 31,(x(1..4),y(1..3)),(ds(4),lp(3));
-   mixedTest();
-   ring R3 = 181,x(1..9),(dp(5),lp(4));
-   mixedTest();
-}
+    int pertdeg = 3;
+    ideal J = modrWalk(I,radius,pertdeg);
+    J;
+}
+
+proc modfWalk(ideal I, list #)
+"USAGE:   modfWalk(I, [, v, w]); I ideal, v intvec, w intvec
+RETURN:   a standard basis of I
+NOTE:     The procedure computes a standard basis of I (over the rational
+          numbers) by using modular methods.
+SEE ALSO: modular
+EXAMPLE:  example modfWalk; shows an example"
+{
+    /* read optional parameter */
+    if (size(#) > 0) {
+        if (size(#) == 1) {
+            intvec w = #[1];
+        }
+        if (size(#) == 2) {
+            intvec v = #[1];
+            intvec w = #[2];
+        }
+        if (size(#) > 2 || typeof(#[1]) != "intvec") {
+            ERROR("wrong optional parameter");
+        }
+    }
+
+    /* save options */
+    intvec opt = option(get);
+    option(redSB);
+
+    /* set additional parameters */
+    int reduction = 1;
+    int printout = 0;
+
+    /* call modular() */
+    if (size(#) > 0) {
+        I = modular("fwalk", list(I,reduction,printout,#));
+    }
+    else {
+        I = modular("fwalk", list(I,reduction,printout));
+    }
+
+    /* return the result */
+    attrib(I, "isSB", 1);
+    option(set, opt);
+    return(I);
+}
+example
+{
+    "EXAMPLE:";
+    echo = 2;
+    ring R1 = 0, (x,y,z,t), dp;
+    ideal I = 3x3+x2+1, 11y5+y3+2, 5z4+z2+4;
+    I = std(I);
+    ring R2 = 0, (x,y,z,t), lp;
+    ideal I = fetch(R1, I);
+    ideal J = modfWalk(I);
+    J;
+}
+
+proc modfrWalk(ideal I, int radius, list #)
+"USAGE:   modfrWalk(I, radius [, v, w]); I ideal, radius int, v intvec, w intvec
+RETURN:   a standard basis of I
+NOTE:     The procedure computes a standard basis of I (over the rational
+          numbers) by using modular methods.
+SEE ALSO: modular
+EXAMPLE:  example modfrWalk; shows an example"
+{
+    /* read optional parameter */
+    if (size(#) > 0) {
+        if (size(#) == 1) {
+            intvec w = #[1];
+        }
+        if (size(#) == 2) {
+            intvec v = #[1];
+            intvec w = #[2];
+        }
+        if (size(#) > 2 || typeof(#[1]) != "intvec") {
+            ERROR("wrong optional parameter");
+        }
+    }
+
+    /* save options */
+    intvec opt = option(get);
+    option(redSB);
+
+    /* set additional parameters */
+    int reduction = 1;
+    int printout = 0;
+
+    /* call modular() */
+    if (size(#) > 0) {
+        I = modular("frandwalk", list(I,radius,reduction,printout,#));
+    }
+    else {
+        I = modular("frandwalk", list(I,radius,reduction,printout));
+    }
+
+    /* return the result */
+    attrib(I, "isSB", 1);
+    option(set, opt);
+    return(I);
+}
+example
+{
+    "EXAMPLE:";
+    echo = 2;
+    ring R1 = 0, (x,y,z,t), dp;
+    ideal I = 3x3+x2+1, 11y5+y3+2, 5z4+z2+4;
+    I = std(I);
+    ring R2 = 0, (x,y,z,t), lp;
+    ideal I = fetch(R1, I);
+    int radius = 2;
+    ideal J = modfrWalk(I,radius);
+    J;
+}

Singular/LIB/multigrading.lib

@@ -3276 +3276 @@
 /******************************************************/
 proc multiDegBasis(intvec d)
-"USAGE: multidegree d
+"USAGE: multiDegBasis(d), multidegree: intvec d
 ASSUME: current ring is multigraded, monomial ordering is global
 PURPOSE: compute all monomials of multidegree d

Singular/LIB/primdec.lib

@@ -7997 +7997 @@
 
   ideal jkeep=@j;
-  if(ordstr(@P)[1]=="w")
+  if((ordstr(@P)[1]=="w")&&(size(ringlist(@P)[3])==2)) // weighted ordering
   {
     def @Phelp=ring(ringlist(gnir));

Singular/LIB/rwalk.lib

@@ -10 +10 @@
 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
 ";
 
@@ -141 +141 @@
  * 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
@@ -178 +179 @@
 
 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;
@@ -196 +197 @@
   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);
 }
 
@@ -202 +205 @@
  * 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);
@@ -227 +230 @@
   OSCTW= OrderStringalp_NP("al", #);
   }
+int nP = OSCTW[1];
 string ord_str = OSCTW[2];
 intvec curr_weight = OSCTW[3]; // original weight vector
@@ -238 +242 @@
 
 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;
@@ -257 +262 @@
   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);
 }
 
@@ -263 +270 @@
  * 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
@@ -299 +306 @@
    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;
@@ -314 +322 @@
     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/extra.cc

@@ -1864 +1864 @@
     if (strcmp(sys_cmd, "Mwalk") == 0)
     {
-      const short t[]={4,IDEAL_CMD,INTVEC_CMD,INTVEC_CMD,RING_CMD};
+      const short t[]={6,IDEAL_CMD,INTVEC_CMD,INTVEC_CMD,RING_CMD,INT_CMD,INT_CMD};
       if (!iiCheckTypes(h,t,1)) return TRUE;
       if (((intvec*) h->next->Data())->length() != currRing->N &&
@@ -1875 +1875 @@
       ideal arg1 = (ideal) h->Data();
       intvec* arg2 = (intvec*) h->next->Data();
-      intvec* arg3   =  (intvec*) h->next->next->Data();
-      ring arg4   =  (ring) h->next->next->next->Data();
-      ideal result = (ideal) Mwalk(arg1, arg2, arg3,arg4);
+      intvec* arg3 = (intvec*) h->next->next->Data();
+      ring arg4 = (ring) h->next->next->next->Data();
+      int arg5 = (int) (long) h->next->next->next->next->Data();
+      int arg6 = (int) (long) h->next->next->next->next->next->Data();
+      ideal result = (ideal) Mwalk(arg1, arg2, arg3, arg4, arg5, arg6);
       res->rtyp = IDEAL_CMD;
       res->data =  result;
@@ -1913 +1915 @@
     if (strcmp(sys_cmd, "Mpwalk") == 0)
     {
-      const short t[]={6,IDEAL_CMD,INT_CMD,INT_CMD,INTVEC_CMD,INTVEC_CMD,INT_CMD};
+      const short t[]={8,IDEAL_CMD,INT_CMD,INT_CMD,INTVEC_CMD,INTVEC_CMD,INT_CMD,INT_CMD,INT_CMD};
       if (!iiCheckTypes(h,t,1)) return TRUE;
       if(((intvec*) h->next->next->next->Data())->length() != currRing->N &&
@@ -1927 +1929 @@
       intvec* arg5 = (intvec*) h->next->next->next->next->Data();
       int arg6 = (int) (long) h->next->next->next->next->next->Data();
-      ideal result = (ideal) Mpwalk(arg1, arg2, arg3, arg4, arg5,arg6);
+      int arg7 = (int) (long) h->next->next->next->next->next->next->Data();
+      int arg8 = (int) (long) h->next->next->next->next->next->next->next->Data();
+      ideal result = (ideal) Mpwalk(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
       res->rtyp = IDEAL_CMD;
       res->data =  result;
@@ -1939 +1943 @@
     if (strcmp(sys_cmd, "Mrwalk") == 0)
     {
-      const short t[]={6,IDEAL_CMD,INTVEC_CMD,INTVEC_CMD,INT_CMD,INT_CMD,RING_CMD};
+      const short t[]={7,IDEAL_CMD,INTVEC_CMD,INTVEC_CMD,INT_CMD,INT_CMD,INT_CMD,INT_CMD};
       if (!iiCheckTypes(h,t,1)) return TRUE;
-      if((((intvec*) h->next->Data())->length() != currRing->N &&
-         ((intvec*) h->next->next->Data())->length() != currRing->N ) &&
-         (((intvec*) h->next->Data())->length() != (currRing->N)*(currRing->N) &&
-         ((intvec*) h->next->next->Data())->length() != (currRing->N)*(currRing->N) ))
+      if(((intvec*) h->next->Data())->length() != currRing->N &&
+         ((intvec*) h->next->Data())->length() != (currRing->N)*(currRing->N) &&
+         ((intvec*) h->next->next->Data())->length() != currRing->N &&
+         ((intvec*) h->next->next->Data())->length() != (currRing->N)*(currRing->N) )
       {
         Werror("system(\"Mrwalk\" ...) intvecs not of length %d or %d\n",
@@ -1955 +1959 @@
       int arg4 = (int)(long) h->next->next->next->Data();
       int arg5 = (int)(long) h->next->next->next->next->Data();
-      ring arg6 = (ring) h->next->next->next->next->next->Data();
-      ideal result = (ideal) Mrwalk(arg1, arg2, arg3, arg4, arg5, arg6);
+      int arg6 = (int)(long) h->next->next->next->next->next->Data();
+      int arg7 = (int)(long) h->next->next->next->next->next->next->Data();
+      ideal result = (ideal) Mrwalk(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
       res->rtyp = IDEAL_CMD;
       res->data =  result;
@@ -2018 +2023 @@
     if (strcmp(sys_cmd, "Mfwalk") == 0)
     {
-      const short t[]={3,IDEAL_CMD,INTVEC_CMD,INTVEC_CMD};
+      const short t[]={5,IDEAL_CMD,INTVEC_CMD,INTVEC_CMD,INT_CMD,INT_CMD};
       if (!iiCheckTypes(h,t,1)) return TRUE;
       if (((intvec*) h->next->Data())->length() != currRing->N &&
@@ -2025 +2030 @@
         Werror("system(\"Mfwalk\" ...) intvecs not of length %d\n",
                  currRing->N);
-        return TRUE;
-      }
-      ideal arg1 = (ideal) h->Data();
-      intvec* arg2 = (intvec*) h->next->Data();
-      intvec* arg3   =  (intvec*) h->next->next->Data();
-      ideal result = (ideal) Mfwalk(arg1, arg2, arg3);
-      res->rtyp = IDEAL_CMD;
-      res->data =  result;
-      return FALSE;
-    }
-    else
-  #endif
-  /*==================== Mfrwalk =================*/
-  #ifdef HAVE_WALK
-    if (strcmp(sys_cmd, "Mfrwalk") == 0)
-    {
-      const short t[]={6,IDEAL_CMD,INTVEC_CMD,INTVEC_CMD,INT_CMD,INT_CMD,RING_CMD};
-      if (!iiCheckTypes(h,t,1)) return TRUE;
-      if (((intvec*) h->next->Data())->length() != currRing->N &&
-          ((intvec*) h->next->next->Data())->length() != currRing->N)
-      {
-        Werror("system(\"Mfrwalk\" ...) intvecs not of length %d\n",currRing->N);
         return TRUE;
       }
@@ -2053 +2036 @@
       intvec* arg3 = (intvec*) h->next->next->Data();
       int arg4 = (int)(long) h->next->next->next->Data();
-      ideal result = (ideal) Mfrwalk(arg1, arg2, arg3, arg4);
+      int arg5 = (int)(long) h->next->next->next->next->Data();
+      ideal result = (ideal) Mfwalk(arg1, arg2, arg3, arg4, arg5);
       res->rtyp = IDEAL_CMD;
       res->data =  result;
@@ -2059 +2043 @@
     }
     else
+  #endif
+  /*==================== Mfrwalk =================*/
+  #ifdef HAVE_WALK
+    if (strcmp(sys_cmd, "Mfrwalk") == 0)
+    {
+      const short t[]={6,IDEAL_CMD,INTVEC_CMD,INTVEC_CMD,INT_CMD,INT_CMD,INT_CMD};
+      if (!iiCheckTypes(h,t,1)) return TRUE;
+/*
+      if (((intvec*) h->next->Data())->length() != currRing->N &&
+          ((intvec*) h->next->next->Data())->length() != currRing->N)
+      {
+        Werror("system(\"Mfrwalk\" ...) intvecs not of length %d\n",currRing->N);
+        return TRUE;
+      }
+*/
+      if((((intvec*) h->next->Data())->length() != currRing->N &&
+         ((intvec*) h->next->next->Data())->length() != currRing->N ) &&
+         (((intvec*) h->next->Data())->length() != (currRing->N)*(currRing->N) &&
+         ((intvec*) h->next->next->Data())->length() != (currRing->N)*(currRing->N) ))
+      {
+        Werror("system(\"Mfrwalk\" ...) intvecs not of length %d or %d\n",
+               currRing->N,(currRing->N)*(currRing->N));
+        return TRUE;
+      }
+
+      ideal arg1 = (ideal) h->Data();
+      intvec* arg2 = (intvec*) h->next->Data();
+      intvec* arg3 = (intvec*) h->next->next->Data();
+      int arg4 = (int)(long) h->next->next->next->Data();
+      int arg5 = (int)(long) h->next->next->next->next->Data();
+      int arg6 = (int)(long) h->next->next->next->next->next->Data();
+      ideal result = (ideal) Mfrwalk(arg1, arg2, arg3, arg4, arg5, arg6);
+      res->rtyp = IDEAL_CMD;
+      res->data =  result;
+      return FALSE;
+    }
+    else
   /*==================== Mprwalk =================*/
     if (strcmp(sys_cmd, "Mprwalk") == 0)
     {
-      const short t[]={7,IDEAL_CMD,INTVEC_CMD,INTVEC_CMD,INT_CMD,INT_CMD,INT_CMD,RING_CMD};
+      const short t[]={9,IDEAL_CMD,INTVEC_CMD,INTVEC_CMD,INT_CMD,INT_CMD,INT_CMD,INT_CMD,INT_CMD,INT_CMD};
       if (!iiCheckTypes(h,t,1)) return TRUE;
-      if (((intvec*) h->next->Data())->length() != currRing->N &&
-          ((intvec*) h->next->next->Data())->length() != currRing->N )
-      {
-        Werror("system(\"Mrwalk\" ...) intvecs not of length %d\n",
-               currRing->N);
+      if((((intvec*) h->next->Data())->length() != currRing->N &&
+         ((intvec*) h->next->next->Data())->length() != currRing->N ) &&
+         (((intvec*) h->next->Data())->length() != (currRing->N)*(currRing->N) &&
+         ((intvec*) h->next->next->Data())->length() != (currRing->N)*(currRing->N) ))
+      {
+        Werror("system(\"Mrwalk\" ...) intvecs not of length %d or %d\n",
+               currRing->N,(currRing->N)*(currRing->N));
         return TRUE;
       }
@@ -2077 +2100 @@
       int arg5 = (int)(long) h->next->next->next->next->Data();
       int arg6 = (int)(long) h->next->next->next->next->next->Data();
-      ring arg7 = (ring) h->next->next->next->next->next->next->Data();
-      ideal result = (ideal) Mprwalk(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
+      int arg7 = (int)(long) h->next->next->next->next->next->next->Data();
+      int arg8 = (int)(long) h->next->next->next->next->next->next->next->Data();
+      int arg9 = (int)(long) h->next->next->next->next->next->next->next->next->Data();
+      ideal result = (ideal) Mprwalk(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
       res->rtyp = IDEAL_CMD;
       res->data =  result;

Singular/iparith.cc

@@ -3479 +3479 @@
   return FALSE;
 }
-static BOOLEAN jjSTD_1(leftv res, leftv u, leftv v);
-static void jjSTD_1_ID(leftv res, ideal i0, int t0, ideal p0, attr a)
-/* destroys i0, p0 */
-/* result (with attributes) in res */
-/* i0: SB*/
-/* t0: type of p0*/
-/* p0 new elements*/
-/* a attributes of i0*/
-{
-  int tp;
-  if (t0==IDEAL_CMD) tp=POLY_CMD;
-  else               tp=VECTOR_CMD;
-  for (int i=IDELEMS(p0)-1; i>=0; i--)
-  {
-    poly p=p0->m[i];
-    p0->m[i]=NULL;
-    if (p!=NULL)
-    {
-      sleftv u0,v0;
-      memset(&u0,0,sizeof(sleftv));
-      memset(&v0,0,sizeof(sleftv));
-      v0.rtyp=tp;
-      v0.data=(void*)p;
-      u0.rtyp=t0;
-      u0.data=i0;
-      u0.attribute=a;
-      setFlag(&u0,FLAG_STD);
-      jjSTD_1(res,&u0,&v0);
-      i0=(ideal)res->data;
-      res->data=NULL;
-      a=res->attribute;
-      res->attribute=NULL;
-      u0.CleanUp();
-      v0.CleanUp();
-      res->CleanUp();
-    }
-  }
-  idDelete(&p0);
-  res->attribute=a;
-  res->data=(void *)i0;
-  res->rtyp=t0;
-}
 static BOOLEAN jjSTD_1(leftv res, leftv u, leftv v)
 {
@@ -3567 +3525 @@
   else /*IDEAL/MODULE*/
   {
-    attr *aa=u->Attribute();
-    attr a=NULL;
-    if ((aa!=NULL)&&(*aa!=NULL)) a=(*aa)->Copy();
-    jjSTD_1_ID(res,(ideal)u->CopyD(),r,(ideal)v->CopyD(),a);
+    i0=(ideal)v->CopyD();
+    int ii0=idElem(i0); /* size of i0 */
+    i1=idSimpleAdd(i1,i0); //
+    memset(i0->m,0,sizeof(poly)*IDELEMS(i0));
+    idDelete(&i0);
+    intvec *w=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
+    tHomog hom=testHomog;
+
+    if (w!=NULL)
+    {
+      if (!idTestHomModule(i1,currRing->qideal,w))
+      {
+        // no warnung: this is legal, if i in std(i,p)
+        // is homogeneous, but p not
+        w=NULL;
+      }
+      else
+      {
+        w=ivCopy(w);
+        hom=isHomog;
+      }
+    }
+    if (ii0*4 >= 3*IDELEMS(i1)) // MAGIC: add few poly to large SB: 3/4
+    {
+      BITSET save1;
+      SI_SAVE_OPT1(save1);
+      si_opt_1|=Sy_bit(OPT_SB_1);
+      /* ii0 appears to be the position of the first element of il that
+       does not belong to the old SB ideal */
+      result=kStd(i1,currRing->qideal,hom,&w,NULL,0,ii0);
+      SI_RESTORE_OPT1(save1);
+    }
+    else
+    {
+      result=kStd(i1,currRing->qideal,hom,&w);
+    }
+    idDelete(&i1);
+    idSkipZeroes(result);
+    if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
+    res->data = (char *)result;
   }
   if(!TEST_OPT_DEGBOUND) setFlag(res,FLAG_STD);

Singular/walk.cc

@@ -16 +16 @@
 
 //#define TEST_OVERFLOW
-//#define CHECK_IDEAL
-//#define CHECK_IDEAL_MWALK
+
+#define CHECK_IDEAL_MWALK //to print intermediate results
 
 //#define NEXT_VECTORS_CC
-//#define PRINT_VECTORS //to print vectors (sigma, tau, omega)
+#define PRINT_VECTORS //to print weight vectors
 
 #define INVEPS_SMALL_IN_FRACTAL  //to choose the small invers of epsilon
@@ -27 +27 @@
 
 #define FIRST_STEP_FRACTAL // to define the first step of the fractal
-//#define MSTDCC_FRACTAL // apply Buchberger alg to compute a red GB, if
-//                          tau doesn't stay in the correct cone
+#define MSTDCC_FRACTAL // apply Buchberger alg to compute a red GB, if tau doesn't stay in the correct cone
 
 //#define TIME_TEST // print the used time of each subroutine
@@ -42 +41 @@
 #include <Singular/ipshell.h>
 #include <Singular/ipconv.h>
+#include <coeffs/ffields.h>
 #include <coeffs/coeffs.h>
 #include <Singular/subexpr.h>
+#include <polys/templates/p_Procs.h>
 
 #include <polys/monomials/maps.h>
@@ -120 +121 @@
  ************************************/
 // unused
-#if 0
+/*
 static void initSSpecialCC (ideal F, ideal Q, ideal P,kStrategy strat)
 {
@@ -268 +269 @@
 #endif
 }
-#endif
+*/
 
 /*****************
@@ -277 +278 @@
   int j;
   kStrategy strat = new skStrategy;
-
-//  if (TEST_OPT_PROT)
-//  {
-//    writeTime("start InterRed:");
-//    mflush();
-//  }
-  //strat->syzComp     = 0;
+/*
+  if (TEST_OPT_PROT)
+  {
+    writeTime("start InterRed:");
+    mflush();
+  }
+  strat->syzComp     = 0;
+*/
   strat->kHEdgeFound = (currRing->ppNoether) != NULL;
   strat->kNoether=pCopy((currRing->ppNoether));
@@ -346 +348 @@
     strat->fromQ = NULL;
   }
-//  if (TEST_OPT_PROT)
-//  {
-//    writeTime("end Interred:");
-//    mflush();
-//  }
+/*
+  if (TEST_OPT_PROT)
+  {
+    writeTime("end Interred:");
+    mflush();
+  }
+*/
   ideal shdl=strat->Shdl;
   idSkipZeroes(shdl);
@@ -358 +362 @@
 }
 
-//unused
-#if 0
+#ifdef TIME_TEST
 static void TimeString(clock_t tinput, clock_t tostd, clock_t tif,clock_t tstd,
                        clock_t tlf,clock_t tred, clock_t tnw, int step)
@@ -397 +400 @@
         ((((double) xtextra)/1000000)/totm)*100);
 }
-#endif
-
-//unused
-#if 0
+
 static void TimeStringFractal(clock_t tinput, clock_t tostd, clock_t tif,clock_t tstd,
                        clock_t textra, clock_t tlf,clock_t tred, clock_t tnw)
@@ -442 +442 @@
 }
 #endif
-
+/*
 #if defined(CHECK_IDEAL_MWALK) || defined(ENDWALKS)
 static void headidString(ideal L, char* st)
@@ -496 +496 @@
 }
 #endif
-
+*/
 
 static void ivString(intvec* iv, const char* ch)
@@ -510 +510 @@
 }
 
-//unused
-#if 0
+#ifdef PRINT_VECTORS
 static void MivString(intvec* iva, intvec* ivb, intvec* ivc)
 {
@@ -558 +557 @@
   }
   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;
 }
 
@@ -774 +803 @@
   for(i=nG-1; i>=0; i--)
   {
-    mi = MpolyInitialForm(G->m[i], iv);
-    gi = G->m[i];
-
+    mi = pHead(MpolyInitialForm(G->m[i], iv));
+    //Print("\n **// test_w_in_ConeCC: lm(initial)= %s \n",pString(mi));
+    gi = pHead(G->m[i]);
+    //Print("\n **// test_w_in_ConeCC: lm(ideal)= %s \n",pString(gi));
     if(mi == NULL)
     {
@@ -953 +983 @@
 }
 
-/*****************************************************************************
-* 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)
 {
-  assume(iv->length() == iw->length());
-  int i, nR = iv->length();
-
+  assume((iv->length())*(iv->length()) == iw->length());
+  int i,j, nR = iv->length();
+  
   intvec* ivm = new intvec(nR*nR);
 
@@ -966 +996 @@
   {
     (*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;
@@ -1005 +1037 @@
  * print the max total degree and the max coefficient of G                   *
  *****************************************************************************/
-#if 0
+/*
 static void checkComplexity(ideal G, char* cG)
 {
@@ -1046 +1078 @@
   PrintLn();
 }
-#endif
+*/
 
 /*****************************************************************************
@@ -1068 +1100 @@
   intvec* v_null =  new intvec(nV);
 
-
   // Check that the perturbed degree is valid
   if(pdeg > nV || pdeg <= 0)
@@ -1082 +1113 @@
   }
   mpz_t *pert_vector = (mpz_t*)omAlloc(nV*sizeof(mpz_t));
-  //mpz_t *pert_vector1 = (mpz_t*)omAlloc(nV*sizeof(mpz_t));
+  mpz_t *pert_vector1 = (mpz_t*)omAlloc(nV*sizeof(mpz_t));
 
   for(i=0; i<nV; i++)
   {
     mpz_init_set_si(pert_vector[i], (*ivtarget)[i]);
-   // mpz_init_set_si(pert_vector1[i], (*ivtarget)[i]);
+    mpz_init_set_si(pert_vector1[i], (*ivtarget)[i]);
   }
   // Calculate max1 = Max(A2)+Max(A3)+...+Max(Apdeg),
@@ -1167 +1198 @@
     }
   }
+
+  // 2147483647 is max. integer representation in SINGULAR
+  mpz_t sing_int;
+  mpz_init_set_ui(sing_int,  2147483647);
+
+  mpz_t check_int;
+  mpz_init_set_ui(check_int,  100000);
+
   mpz_t ztemp;
   mpz_init(ztemp);
@@ -1186 +1225 @@
   }
 
-  intvec *pert_vector1= new intvec(nV);
-  j = 0;
   for(i=0; i<nV; i++)
   {
-    (* pert_vector1)[i] = mpz_get_si(pert_vector[i]);
-    (* pert_vector1)[i] = 0.1*(* pert_vector1)[i];
-    (* pert_vector1)[i] = floor((* pert_vector1)[i] + 0.5);
-    if((* pert_vector1)[i] == 0)
-    {
-      j++;
-    }
-  }
-  if(j > nV - 1)
-  {
-    // Print("\n//  MPertVectors: geaenderter vector gleich Null! \n");
-    delete pert_vector1;
-    goto CHECK_OVERFLOW;
-  }
-
-// check that the perturbed weight vector lies in the Groebner cone
-  if(test_w_in_ConeCC(G,pert_vector1) != 0)
-  {
-    // Print("\n//  MPertVectors: geaenderter vector liegt in Groebnerkegel! \n");
+    if(mpz_cmp(pert_vector[i], check_int)>=0)
+    {
+      for(j=0; j<nV; j++)
+      {
+        mpz_fdiv_q_ui(pert_vector1[j], pert_vector[j], 100);
+      }
+    }
+  }
+
+  intvec* result = new intvec(nV);
+
+  int ntrue=0;
+
+  for(i=0; i<nV; i++)
+  {
+    (*result)[i] = mpz_get_si(pert_vector1[i]);
+    if(mpz_cmp(pert_vector1[i], sing_int)>=0)
+    {
+      ntrue++;
+    }
+  }
+  if(ntrue > 0 || test_w_in_ConeCC(G,result)==0)
+  {
+    ntrue=0;
     for(i=0; i<nV; i++)
     {
-      mpz_set_si(pert_vector[i], (*pert_vector1)[i]);
-    }
-  }
-  else
-  {
-    //Print("\n// MpertVectors: geaenderter vector liegt nicht in Groebnerkegel! \n");
-  }
-  delete pert_vector1;
-
-  CHECK_OVERFLOW:
-  intvec* result = new intvec(nV);
-
-  /* 2147483647 is max. integer representation in SINGULAR */
-  mpz_t sing_int;
-  mpz_init_set_ui(sing_int,  2147483647);
-
-  int ntrue=0;
-  for(i=0; i<nV; i++)
-  {
-    (*result)[i] = mpz_get_si(pert_vector[i]);
-    if(mpz_cmp(pert_vector[i], sing_int)>=0)
-    {
-      ntrue++;
-      if(Overflow_Error == FALSE)
-      {
-        Overflow_Error = TRUE;
-        PrintS("\n// ** OVERFLOW in \"MPertvectors\": ");
-        mpz_out_str( stdout, 10, pert_vector[i]);
-        PrintS(" is greater than 2147483647 (max. integer representation)");
-        Print("\n//  So vector[%d] := %d is wrong!!", i+1, (*result)[i]);
-      }
-    }
-  }
-
-  if(Overflow_Error == TRUE)
-  {
-    ivString(result, "pert_vector");
-    Print("\n// %d element(s) of it is overflow!!", ntrue);
+      (*result)[i] = mpz_get_si(pert_vector[i]);
+      if(mpz_cmp(pert_vector[i], sing_int)>=0)
+      {
+        ntrue++;
+        if(Overflow_Error == FALSE)
+        {
+          Overflow_Error = TRUE;
+          PrintS("\n// ** OVERFLOW in \"MPertvectors\": ");
+          mpz_out_str( stdout, 10, pert_vector[i]);
+          PrintS(" is greater than 2147483647 (max. integer representation)");
+          Print("\n//  So vector[%d] := %d is wrong!!", i+1, (*result)[i]);
+        }
+      }
+    }
+
+    if(Overflow_Error == TRUE)
+    {
+      ivString(result, "pert_vector");
+      Print("\n// %d element(s) of it is overflow!!", ntrue);
+    }
   }
 
   mpz_clear(ztemp);
   mpz_clear(sing_int);
+  mpz_clear(check_int);
   omFree(pert_vector);
-  //omFree(pert_vector1);
+  omFree(pert_vector1);
   mpz_clear(tot_deg);
   mpz_clear(maxdeg);
@@ -1456 +1481 @@
 
 //unused
-#if 0
+/*
 static intvec* MatrixOrderdp(int nV)
 {
@@ -1472 +1497 @@
   return(ivM);
 }
-#endif
+*/
 
 intvec* MivUnit(int nV)
@@ -1549 +1574 @@
     mpz_cdiv_q_ui(inveps, inveps, nV);
   }
-  //PrintS("\n// choose the \"small\" inverse epsilon!");
+  // choose the small inverse epsilon
 #endif
 
@@ -1583 +1608 @@
 
     for(j=0; j<nV; j++)
-      {
+    {
       mpz_init_set(pert_vector[i*nV+j],ivtemp[j]);
-      }
-  }
-
-  /* 2147483647 is max. integer representation in SINGULAR */
+    }
+  }
+
+  // 2147483647 is max. integer representation in SINGULAR
   mpz_t sing_int;
   mpz_init_set_ui(sing_int,  2147483647);
@@ -1611 +1636 @@
     mpz_divexact(pert_vector[i], pert_vector[i], ztmp);
     (* result)[i] = mpz_get_si(pert_vector[i]);
-  }
-
-  j = 0;
-  for(i=0; i<nV; i++)
-  {
-    (* result1)[i] = mpz_get_si(pert_vector[i]);
-    (* result1)[i] = 0.1*(* result1)[i];
-    (* result1)[i] = floor((* result1)[i] + 0.5);
-    if((* result1)[i] == 0)
-    {
-      j++;
-    }
-  }
-  if(j > nV - 1)
-  {
-    // Print("\n//  MfPertwalk: geaenderter vector gleich Null! \n");
-    delete result1;
-    goto CHECK_OVERFLOW;
-  }
-
-// check that the perturbed weight vector lies in the Groebner cone
-  if(test_w_in_ConeCC(G,result1) != 0)
-  {
-    // Print("\n//  MfPertwalk: geaenderter vector liegt in Groebnerkegel! \n");
-    delete result;
-    result = result1;
-    for(i=0; i<nV; i++)
-    {
-      mpz_set_si(pert_vector[i], (*result1)[i]);
-    }
-  }
-  else
-  {
-    delete result1;
-    // Print("\n// Mfpertwalk: geaenderter vector liegt nicht in Groebnerkegel! \n");
   }
 
@@ -1685 +1675 @@
     while(p!=NULL)
     {
-      p_Setm(p,currRing); pIter(p);
+      p_Setm(p,currRing);
+      pIter(p);
     }
   }
@@ -1768 +1759 @@
 
 //unused
-#if 0
+/*
 static void checkidealCC(ideal G, char* Ch)
 {
@@ -1794 +1785 @@
   PrintLn();
 }
-#endif
+*/
 
 //unused
-#if 0
+/*
 static void HeadidString(ideal L, char* st)
 {
@@ -1809 +1800 @@
   Print(" %s;\n", pString(pHead(L->m[nL])));
 }
-#endif
-
+
+*/
 static inline int MivComp(intvec* iva, intvec* ivb)
 {
@@ -1859 +1850 @@
 }
 
+
+/**************************************************************
+ * 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 *
  * with respect to an ideal <G>.                                      *
 **********************************************************************/
+/*
 static intvec* MwalkNextWeightCC(intvec* curr_weight, intvec* target_weight,
                                  ideal G)
@@ -1873 +1885 @@
 
   int nRing = currRing->N;
-  int checkRed, j, kkk, nG = IDELEMS(G);
+  int checkRed, j, nG = IDELEMS(G);
   intvec* ivtemp;
 
@@ -1911 +1923 @@
   mpz_init(dcw);
 
-  //int tn0, tn1, tz1, ncmp, gcd_tmp, ntmp;
   int gcd_tmp;
   intvec* diff_weight = MivSub(target_weight, curr_weight);
@@ -1917 +1928 @@
   intvec* diff_weight1 = MivSub(target_weight, curr_weight);
   poly g;
-  //poly g, gw;
+
   for (j=0; j<nG; j++)
   {
@@ -1934 +1945 @@
         mpz_set_si(MwWd, MivDotProduct(ivtemp, curr_weight));
         mpz_sub(s_zaehler, deg_w0_p1, MwWd);
-
         if(mpz_cmp(s_zaehler, t_null) != 0)
         {
           mpz_set_si(MwWd, MivDotProduct(ivtemp, diff_weight));
           mpz_sub(s_nenner, MwWd, deg_d0_p1);
-
           // check for 0 < s <= 1
           if( (mpz_cmp(s_zaehler,t_null) > 0 &&
@@ -1979 +1988 @@
     }
   }
-//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)
   {
-    #ifndef SING_NDEBUG
-    Print("\n//MwalkNextWeightCC: t_nenner ist Null!");
-    #endif
+#ifndef SING_NDEBUG
+    Print("\n//MwalkNextWeightCC: t_nenner=0\n");
+#endif
     delete diff_weight;
     diff_weight = ivCopy(curr_weight);//take memory
@@ -2054 +2064 @@
 #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++)
   {
@@ -2100 +2113 @@
     }
   }
-
+  // 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: ");
@@ -2106 +2126 @@
 #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++)
-    {
+  {
     if(mpz_cmp(vec[j], sing_int_half) >= 0)
-      {
+    {
       goto REDUCTION;
-      }
-    }
+    }
+  }
   checkRed = 1;
   for (j=0; j<nRing; j++)
@@ -2129 +2141 @@
 
   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;
   }
 
@@ -2222 +2211 @@
    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)
     {
@@ -2240 +2227 @@
 return diff_weight;
 }
+*/
+/**********************************************************************
+ * Compute a next weight vector between curr_weight and target_weight *
+ * with respect to an ideal <G>.                                      *
+**********************************************************************/
+static intvec* MwalkNextWeightCC(intvec* curr_weight, intvec* target_weight,
+                                 ideal G)
+{
+  BOOLEAN nError = Overflow_Error;
+  Overflow_Error = FALSE;
+
+  assume(currRing != NULL && curr_weight != NULL &&
+         target_weight != NULL && G != NULL);
+
+  int nRing = currRing->N;
+  int checkRed, j, nG = IDELEMS(G);
+  intvec* ivtemp;
+
+  mpz_t t_zaehler, t_nenner;
+  mpz_init(t_zaehler);
+  mpz_init(t_nenner);
+
+  mpz_t s_zaehler, s_nenner, temp, MwWd;
+  mpz_init(s_zaehler);
+  mpz_init(s_nenner);
+  mpz_init(temp);
+  mpz_init(MwWd);
+
+  mpz_t sing_int;
+  mpz_init(sing_int);
+  mpz_set_si(sing_int,  2147483647);
+
+  mpz_t sing_int_half;
+  mpz_init(sing_int_half);
+  mpz_set_si(sing_int_half,  3*(1073741824/2));
+
+  mpz_t deg_w0_p1, deg_d0_p1;
+  mpz_init(deg_w0_p1);
+  mpz_init(deg_d0_p1);
+
+  mpz_t sztn, sntz;
+  mpz_init(sztn);
+  mpz_init(sntz);
+
+  mpz_t t_null;
+  mpz_init(t_null);
+
+  mpz_t ggt;
+  mpz_init(ggt);
+
+  mpz_t dcw;
+  mpz_init(dcw);
+
+  int gcd_tmp;
+  //intvec* diff_weight = MivSub(target_weight, curr_weight);
+
+  intvec* diff_weight1 = new intvec(nRing); //MivSub(target_weight, curr_weight);
+  poly g;
+
+  // reduce the size of the entries of the current weight vector
+  if(TEST_OPT_REDSB)
+  {
+    for (j=0; j<nRing; j++)
+    {
+      (*diff_weight1)[j] = (*curr_weight)[j];
+    }
+    while(MivAbsMax(diff_weight1)>10000 && test_w_in_ConeCC(G,diff_weight1)==1)
+    {
+      for(j=0; j<nRing; j++)
+      {
+        (*curr_weight)[j] = (*diff_weight1)[j];  
+      }
+      for(j=0; j<nRing; j++)
+      {
+        (*diff_weight1)[j] = floor(0.1*(*diff_weight1)[j] + 0.5);
+      }
+    }
+
+    if(MivAbsMax(curr_weight)>100000)
+    {
+      for(j=0; j<nRing; j++)
+      {
+        (*diff_weight1)[j] = (*curr_weight)[j];
+      }
+      j = 0;
+      while(test_w_in_ConeCC(G,diff_weight1)==1 && MivAbsMax(diff_weight1)>1000)
+      {
+        (*curr_weight)[j] = (*diff_weight1)[j];
+        j = MivAbsMaxArg(diff_weight1);
+        (*diff_weight1)[j] = floor(0.1*(*diff_weight1)[j] + 0.5);
+      }
+    }
+
+  }
+  intvec* diff_weight = MivSub(target_weight, curr_weight);
+
+  // compute a suitable next weight vector
+  for (j=0; j<nG; j++)
+  {
+    g = G->m[j];
+    if (g != NULL)
+    {
+      ivtemp = MExpPol(g);
+      mpz_set_si(deg_w0_p1, MivDotProduct(ivtemp, curr_weight));
+      mpz_set_si(deg_d0_p1, MivDotProduct(ivtemp, diff_weight));
+      delete ivtemp;
+
+      pIter(g);
+      while (g != NULL)
+      {
+        ivtemp = MExpPol(g);
+        mpz_set_si(MwWd, MivDotProduct(ivtemp, curr_weight));
+        mpz_sub(s_zaehler, deg_w0_p1, MwWd);
+        if(mpz_cmp(s_zaehler, t_null) != 0)
+        {
+          mpz_set_si(MwWd, MivDotProduct(ivtemp, diff_weight));
+          mpz_sub(s_nenner, MwWd, deg_d0_p1);
+          // check for 0 < s <= 1
+          if( (mpz_cmp(s_zaehler,t_null) > 0 &&
+               mpz_cmp(s_nenner, s_zaehler)>=0) ||
+              (mpz_cmp(s_zaehler, t_null) < 0 &&
+               mpz_cmp(s_nenner, s_zaehler)<=0))
+          {
+            // make both positive
+            if (mpz_cmp(s_zaehler, t_null) < 0)
+            {
+              mpz_neg(s_zaehler, s_zaehler);
+              mpz_neg(s_nenner, s_nenner);
+            }
+
+            //compute a simple fraction of s
+            cancel(s_zaehler, s_nenner);
+
+            if(mpz_cmp(t_nenner, t_null) != 0)
+            {
+              mpz_mul(sztn, s_zaehler, t_nenner);
+              mpz_mul(sntz, s_nenner, t_zaehler);
+
+              if(mpz_cmp(sztn,sntz) < 0)
+              {
+                mpz_add(t_nenner, t_null, s_nenner);
+                mpz_add(t_zaehler,t_null, s_zaehler);
+              }
+            }
+            else
+            {
+              mpz_add(t_nenner, t_null, s_nenner);
+              mpz_add(t_zaehler,t_null, s_zaehler);
+            }
+          }
+        }
+        pIter(g);
+        delete ivtemp;
+      }
+    }
+  }
+  //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
+  if(mpz_cmp(t_nenner, t_null) == 0)
+  {
+#ifndef SING_NDEBUG
+    Print("\n//MwalkNextWeightCC: t_nenner=0\n");
+#endif
+    delete diff_weight;
+    diff_weight = ivCopy(curr_weight);//take memory
+    goto FINISH;
+  }
+
+  // define the target vector as the next weight vector, if t = 1
+  if(mpz_cmp_si(t_nenner, 1)==0 && mpz_cmp_si(t_zaehler,1)==0)
+  {
+    delete diff_weight;
+    diff_weight = ivCopy(target_weight); //this takes memory
+    goto FINISH;
+  }
+
+   //checkRed = 0;
+
+  SIMPLIFY_GCD:
+
+  // simplify the vectors curr_weight and diff_weight (C-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;
+      }
+    }
+  }
+  if(gcd_tmp != 1)
+  {
+    for (j=0; j<nRing; j++)
+    {
+      (*curr_weight)[j] =  (*curr_weight)[j]/gcd_tmp;
+      (*diff_weight)[j] =  (*diff_weight)[j]/gcd_tmp;
+    }
+  }
+  if(checkRed > 0)
+  {
+    for (j=0; j<nRing; j++)
+    {
+      mpz_set_si(vec[j], (*diff_weight)[j]);
+    }
+    goto TEST_OVERFLOW;
+  }
+
+#ifdef  NEXT_VECTORS_CC
+  Print("\n// gcd of the weight vectors (current and target) = %d", gcd_tmp);
+  ivString(curr_weight, "new cw");
+  ivString(diff_weight, "new dw");
+
+  PrintS("\n// t_zaehler: ");  mpz_out_str( stdout, 10, t_zaehler);
+  PrintS(", t_nenner: ");  mpz_out_str( stdout, 10, t_nenner);
+#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
+
+  for (j=0; j<nRing; j++)
+  {
+    mpz_set_si(dcw, (*curr_weight)[j]);
+    mpz_mul(s_nenner, t_nenner, dcw);
+
+    if( (*diff_weight)[j]>0)
+    {
+      mpz_mul_ui(s_zaehler, t_zaehler, (*diff_weight)[j]);
+    }
+    else
+    {
+      mpz_mul_ui(s_zaehler, t_zaehler, -(*diff_weight)[j]);
+      mpz_neg(s_zaehler, s_zaehler);
+    }
+    mpz_add(sntz, s_nenner, s_zaehler);
+    mpz_init_set(vec[j], sntz);
+
+#ifdef NEXT_VECTORS_CC
+    Print("\n//   j = %d ==> ", j);
+    PrintS("(");
+    mpz_out_str( stdout, 10, t_nenner);
+    Print(" * %d)", (*curr_weight)[j]);
+    Print(" + ("); mpz_out_str( stdout, 10, t_zaehler);
+    Print(" * %d) =  ",  (*diff_weight)[j]);
+    mpz_out_str( stdout, 10, s_nenner);
+    PrintS(" + ");
+    mpz_out_str( stdout, 10, s_zaehler);
+    PrintS(" = "); mpz_out_str( stdout, 10, sntz);
+    Print(" ==> vector[%d]: ", j); mpz_out_str(stdout, 10, vec[j]);
+#endif
+
+    if(j==0)
+    {
+      mpz_set(ggt, sntz);
+    }
+    else
+    {
+      if(mpz_cmp_si(ggt,1) != 0)
+      {
+        mpz_gcd(ggt, ggt, sntz);
+      }
+    }
+  }
+  // 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: ");
+  mpz_out_str( stdout, 10, ggt);
+#endif
+
+  for (j=0; j<nRing; j++)
+  {
+    (*diff_weight)[j] = mpz_get_si(vec[j]);
+  }
+
+ TEST_OVERFLOW:
+
+  for (j=0; j<nRing; j++)
+  {
+    if(mpz_cmp(vec[j], sing_int)>=0)
+    {
+      if(Overflow_Error == FALSE)
+      {
+        Overflow_Error = TRUE;
+        PrintS("\n// ** OVERFLOW in \"MwalkNextWeightCC\": ");
+        mpz_out_str( stdout, 10, vec[j]);
+        PrintS(" is greater than 2147483647 (max. integer representation)\n");
+        Print("//  So vector[%d] := %d is wrong!!\n",j+1, vec[j]);// vec[j] is mpz_t
+      }
+    }
+  }
+
+ FINISH:
+   delete diff_weight1;
+   mpz_clear(t_zaehler);
+   mpz_clear(t_nenner);
+   mpz_clear(s_zaehler);
+   mpz_clear(s_nenner);
+   mpz_clear(sntz);
+   mpz_clear(sztn);
+   mpz_clear(temp);
+   mpz_clear(MwWd);
+   mpz_clear(deg_w0_p1);
+   mpz_clear(deg_d0_p1);
+   mpz_clear(ggt);
+   omFree(vec);
+   mpz_clear(sing_int_half);
+   mpz_clear(sing_int);
+   mpz_clear(dcw);
+   mpz_clear(t_null);
+
+  if(Overflow_Error == FALSE)
+  {
+    Overflow_Error = nError;
+  }
+  rComplete(currRing);
+  for(j=0; j<IDELEMS(G); j++)
+  {
+    poly p=G->m[j];
+    while(p!=NULL)
+    {
+      p_Setm(p,currRing);
+      pIter(p);
+    }
+  }
+return diff_weight;
+}
+
 
 /**********************************************************************
@@ -2271 +2609 @@
 }
 
-/**************************************************************
+/********************************************************************
  * define and execute a new ring which order is (a(vb),a(va),lp,C)  *
- * ************************************************************/
-#if 0
-// unused
+ * ******************************************************************/
 static void VMrHomogeneous(intvec* va, intvec* vb)
 {
@@ -2353 +2689 @@
   rChangeCurrRing(r);
 }
-#endif
+
 
 /**************************************************************
@@ -2428 +2764 @@
 }
 
-static ring VMrDefault1(intvec* va)
-{
-
-  if ((currRing->ppNoether)!=NULL)
-  {
-    pDelete(&(currRing->ppNoether));
-  }
-  if (((sLastPrinted.rtyp>BEGIN_RING) && (sLastPrinted.rtyp<END_RING)) ||
-      ((sLastPrinted.rtyp==LIST_CMD)&&(lRingDependend((lists)sLastPrinted.data))))
-  {
-    sLastPrinted.CleanUp();
-  }
-
-  ring r = (ring) omAlloc0Bin(sip_sring_bin);
-  int i, nv = currRing->N;
-
-  r->cf  = currRing->cf;
-  r->N   = currRing->N;
-
-  int nb = 4;
-
-  //names
-  char* Q; // In order to avoid the corrupted memory, do not change.
-  r->names = (char **) omAlloc0(nv * sizeof(char_ptr));
-  for(i=0; i<nv; i++)
-  {
-    Q = currRing->names[i];
-    r->names[i]  = omStrDup(Q);
-  }
-
-  /*weights: entries for 3 blocks: NULL Made:???*/
-  r->wvhdl = (int **)omAlloc0(nb * sizeof(int_ptr));
-  r->wvhdl[0] = (int*) omAlloc(nv*sizeof(int));
-  for(i=0; i<nv; i++)
-    r->wvhdl[0][i] = (*va)[i];
-
-  /* order: a,lp,C,0 */
-  r->order = (int *) omAlloc(nb * sizeof(int *));
-  r->block0 = (int *)omAlloc0(nb * sizeof(int *));
-  r->block1 = (int *)omAlloc0(nb * sizeof(int *));
-
-  // ringorder a for the first block: var 1..nv
-  r->order[0]  = ringorder_a;
-  r->block0[0] = 1;
-  r->block1[0] = nv;
-
-  // ringorder lp for the second block: var 1..nv
-  r->order[1]  = ringorder_lp;
-  r->block0[1] = 1;
-  r->block1[1] = nv;
-
-  // ringorder C for the third block
-  // it is very important within "idLift",
-  // especially, by ring syz_ring=rCurrRingAssure_SyzComp();
-  // therefore, nb  must be (nBlocks(currRing)  + 1)
-  r->order[2]  = ringorder_C;
-
-  // the last block: everything is 0
-  r->order[3]  = 0;
-
-  // polynomial ring
-  r->OrdSgn    = 1;
-
-  // complete ring intializations
-
-  rComplete(r);
-
-  //rChangeCurrRing(r);
-  return r;
-}
-
 /****************************************************************
  * define and execute a new ring with ordering (a(va),Wp(vb),C) *
  * **************************************************************/
-
 static ring VMrRefine(intvec* va, intvec* vb)
 {
@@ -2576 +2840 @@
 
   // complete ring intializations
-
+  
   rComplete(r);
 
@@ -2806 +3070 @@
 }
 
-
-/* define a ring with parameters und change to it */
-/* DefRingPar and DefRingParlp corrupt still memory */
+/***************************************************
+* define a ring with parameters und change to it   *
+* DefRingPar and DefRingParlp corrupt still memory *
+****************************************************/
 static void DefRingPar(intvec* va)
 {
@@ -2956 +3221 @@
 }
 
-//unused
-/**************************************************************
- * check wheather one or more components of a vector are zero *
- **************************************************************/
-#if 0
+/*************************************************************
+ * check whether one or more components of a vector are zero *
+ *************************************************************/
 static int isNolVector(intvec* hilb)
 {
@@ -2973 +3236 @@
   return 0;
 }
-#endif
+
+/*************************************************************
+ * check whether one or more components of a vector are <= 0 *
+ *************************************************************/
+static int isNegNolVector(intvec* hilb)
+{
+  int i;
+  for(i=hilb->length()-1; i>=0; i--)
+  {
+    if((* hilb)[i]<=0)
+    {
+      return 1;
+    }
+  }
+  return 0;
+}
+
+/**************************************************************************
+* Gomega is the initial ideal of G w. r. t. the current weight vector     *
+* curr_weight. Check whether curr_weight lies on a border of the Groebner *
+* cone, i. e. check whether a monomial is divisible by a leading monomial *
+***************************************************************************/
+static ideal middleOfCone(ideal G, ideal Gomega)
+{
+  BOOLEAN middle = FALSE;
+  int i,j,N = IDELEMS(Gomega);
+  poly p,lm,factor1,factor2;
+
+  ideal Go = idCopy(G);
+  
+  // check whether leading monomials of G and Gomega coincide
+  // and return NULL if not
+  for(i=0; i<N; i++)
+  {
+    if(!pIsConstant(pSub(pCopy(Gomega->m[i]),pCopy(pHead(G->m[i])))))
+    {
+      idDelete(&Go);
+      return NULL; 
+    }
+  }
+  for(i=0; i<N; i++)
+  {
+    for(j=0; j<N; j++)
+    {
+      if(i!=j)
+      {
+        p = pCopy(Gomega->m[i]);
+        lm = pCopy(Gomega->m[j]);
+        pIter(p);
+        while(p!=NULL)
+        {
+          if(pDivisibleBy(lm,p))
+          {
+            if(middle == FALSE)
+            {
+              middle = TRUE;
+            }
+            factor1 = singclap_pdivide(pHead(p),lm,currRing);
+            factor2 = pMult(pCopy(factor1),pCopy(Go->m[j]));
+            pDelete(&factor1);
+            Go->m[i] = pAdd((Go->m[i]),pNeg(pCopy(factor2)));
+            pDelete(&factor2);
+          }
+          pIter(p);
+        }
+        pDelete(&lm);
+        pDelete(&p);
+      }
+    }
+  }
+
+  if(middle == TRUE)
+  {
+    return Go;
+  }
+  idDelete(&Go);
+  return NULL; 
+}
 
 /******************************  Februar 2002  ****************************
@@ -3104 +3444 @@
     {
       Print("\n// ring r%d_%d = %s;\n", tp_deg, nwalk, rString(currRing));
+/*
       idElements(Gomega, "Gw");
       headidString(Gomega, "Gw");
+*/
     }
 #endif
@@ -3128 +3470 @@
     else
     {
-      rChangeCurrRing(VMrDefault(curr_weight)); //Aenderung
+      rChangeCurrRing(VMrDefault(curr_weight));
     }
     newRing = currRing;
@@ -3255 +3597 @@
 
 /**********************************************************
- * check whether a polynomial of G has least 3 monomials  *
+ * check whether a polynomial of G has least 4 monomials  *
  **********************************************************/
 static int lengthpoly(ideal G)
@@ -3262 +3604 @@
   for(i=IDELEMS(G)-1; i>=0; i--)
   {
-#if 0
-    if(pLength(G->m[i])>2)
-    {
-      return 1;
-    }
-#else
     if((G->m[i]!=NULL) /* len >=0 */
        && (G->m[i]->next!=NULL) /* len >=1 */
        && (G->m[i]->next->next!=NULL) /* len >=2 */
        && (G->m[i]->next->next->next!=NULL) /* len >=3 */
-      //&& (G->m[i]->next->next->next->next!=NULL) /* len >=4 */
-       )
-    {
-    return 1;
-    }
-#endif
+       && (G->m[i]->next->next->next->next!=NULL) /* len >=4*/ )
+    {
+      return 1;
+    }
   }
   return 0;
+}
+
+/*****************************************
+ * return maximal polynomial length of G *
+ *****************************************/
+static int maxlengthpoly(ideal G)
+{
+  int i,k,length=0;
+  for(i=IDELEMS(G)-1; i>=0; i--)
+  {
+    k = pLength(G->m[i]);
+    if(k>length)
+    {
+      length = k;
+    }
+  }
+  return length;
 }
 
@@ -3350 +3701 @@
   for(i=nG-1; i>=0; i--)
   {
-#if 0
+/*
     poly t;
     if((t=pSub(pCopy(H0->m[i]), pCopy(H1->m[i]))) != NULL)
@@ -3358 +3709 @@
     }
     pDelete(&t);
-#else
+*/
     if(!pEqualPolys(H0->m[i],H1->m[i]))
     {
       return 0;
     }
-#endif
   }
   return 1;
@@ -3372 +3722 @@
  * find the maximal total degree of polynomials in G *
  *****************************************************/
-#if 0
+/*
 static int Trandegreebound(ideal G)
 {
@@ -3393 +3743 @@
   return result;
 }
-#endif
+*/
 
 //unused
@@ -3740 +4090 @@
  * basis or n times, where n is the numbers of variables.                    *
  *****************************************************************************/
-
-//unused
-#if 0
-static int testnegintvec(intvec* v)
-{
-  int n = v->length();
-  int i;
-  for(i=0; i<n; i++)
-  {
-    if((*v)[i]<0)
-    {
-      return(1);
-    }
-  }
-  return(0);
-}
-#endif
 
 // npwinc = 0, if curr_weight doesn't stay in the correct Groebner cone
@@ -3884 +4217 @@
     else
     {
-      rChangeCurrRing(VMrDefault(curr_weight)); //Aenderung
+      rChangeCurrRing(VMrDefault(curr_weight));
     }
     newRing = currRing;
@@ -3968 +4301 @@
         //nOverflow_Error = Overflow_Error;
         tproc=tproc+clock()-tinput;
-        /*
-          Print("\n// takes %d steps and calls \"Rec_LastGB\" (%d):",
-          nwalk, tp_deg+1);
-        */
+        
+        Print("\n// takes %d steps and calls \"Rec_LastGB\" (%d):",
+        nwalk, tp_deg+1);
+        
         G = Rec_LastGB(G,curr_weight, orig_target_weight, tp_deg+1,nnwinC);
         newRing = currRing;
@@ -4005 +4338 @@
     {
       // nOverflow_Error = Overflow_Error;
-      //Print("\n//  takes %d steps and calls \"Rec_LastGB (%d):", tp_deg+1);
+      Print("\n//  takes %d steps and calls \"Rec_LastGB (%d):", tp_deg+1);
       tproc=tproc+clock()-tinput;
       F1 = Rec_LastGB(F1,curr_weight, orig_target_weight, tp_deg+1,nnwinC);
@@ -4059 +4392 @@
     Overflow_Error=nError;
     }
-// Print("\n// \"Rec_LastGB\" (%d) took %d steps and %.2f sec.Overflow_Error (%d)", tp_deg, nwalk, ((double) tproc)/1000000, nOverflow_Error);
+#ifdef TIME_TEST
+   Print("\n// \"Rec_LastGB\" (%d) took %d steps and %.2f sec.Overflow_Error (%d)", tp_deg, nwalk, ((double) tproc)/1000000, nOverflow_Error);
+#endif
   return(result);
 }
@@ -4081 +4416 @@
   //BOOLEAN nOverflow_Error = FALSE;
   //Print("// pSetm_Error = (%d)", ErrorCheck());
-
+#ifdef TIME_TEST
   xtif=0; xtstd=0; xtlift=0; xtred=0; xtnw=0; xtextra=0;
   xftinput = clock();
   clock_t tostd, tproc;
-
+#endif
   nstep = 0;
   int i, nV = currRing->N;
@@ -4096 +4431 @@
   intvec* ivNull = new intvec(nV);
   intvec* next_weight;
-#if 0
-  intvec* extra_curr_weight = new intvec(nV);
-#endif
+  //intvec* extra_curr_weight = new intvec(nV);
   //intvec* hilb_func;
   intvec* exivlp = Mivlp(nV);
-
   ring XXRing = currRing;
 
   //Print("\n// ring r_input = %s;", rString(currRing));
+#ifdef TIME_TEST
   to = clock();
+#endif
   /* compute the reduced Groebner basis of the given ideal w.r.t.
      a "fast" monomial order, e.g. degree reverse lex. order (dp) */
   G = MstdCC(Go);
+#ifdef TIME_TEST
   tostd=clock()-to;
 
-  /*
   Print("\n// Computation of the first std took = %.2f sec",
         ((double) tostd)/1000000);
-  */
+#endif
   if(currRing->order[0] == ringorder_a)
   {
@@ -4123 +4457 @@
     nwalk ++;
     nstep ++;
+#ifdef TIME_TEST
     to = clock();
+#endif
     /* compute an initial form ideal of <G> w.r.t. "curr_vector" */
     Gomega = MwalkInitialForm(G, curr_weight);
+#ifdef TIME_TEST
     xtif=xtif+clock()-to;
-#if 0
+#endif
+/*
     if(Overflow_Error == TRUE)
     {
@@ -4135 +4473 @@
       goto LAST_GB_ALT2;
     }
-#endif
+*/
     oldRing = currRing;
 
@@ -4145 +4483 @@
     else
     {
-      rChangeCurrRing(VMrDefault(curr_weight)); // Aenderung
+      rChangeCurrRing(VMrDefault(curr_weight));
     }
     newRing = currRing;
     Gomega1 = idrMoveR(Gomega, oldRing,currRing);
+#ifdef TIME_TEST
     to = clock();
+#endif
     /* compute a reduced Groebner basis of <Gomega> w.r.t. "newRing" */
     M = MstdhomCC(Gomega1);
+#ifdef TIME_TEST
     xtstd=xtstd+clock()-to;
+#endif
     /* change the ring to oldRing */
     rChangeCurrRing(oldRing);
     M1 =  idrMoveR(M, newRing,currRing);
     Gomega2 =  idrMoveR(Gomega1, newRing,currRing);
-
+#ifdef TIME_TEST
     to = clock();
+#endif
     /* compute the reduced Groebner basis of <G> w.r.t. "newRing"
        by the liftig process */
     F = MLifttwoIdeal(Gomega2, M1, G);
+#ifdef TIME_TEST
     xtlift=xtlift+clock()-to;
+#endif
     idDelete(&M1);
     idDelete(&Gomega2);
@@ -4170 +4515 @@
     rChangeCurrRing(newRing);
     F1 = idrMoveR(F, oldRing,currRing);
-
+#ifdef TIME_TEST
     to = clock();
+#endif
     /* reduce the Groebner basis <G> w.r.t. newRing */
     G = kInterRedCC(F1, NULL);
+#ifdef TIME_TEST
     xtred=xtred+clock()-to;
+#endif
     idDelete(&F1);
 
@@ -4181 +4529 @@
 
   NEXT_VECTOR:
+#ifdef TIME_TEST
     to = clock();
+#endif
     /* compute a next weight vector */
     next_weight = MkInterRedNextWeight(curr_weight,target_weight, G);
+#ifdef TIME_TEST
     xtnw=xtnw+clock()-to;
+#endif
 #ifdef PRINT_VECTORS
     MivString(curr_weight, target_weight, next_weight);
@@ -4228 +4580 @@
      // LAST_GB_ALT2:
         //nOverflow_Error = Overflow_Error;
+#ifdef TIME_TEST
         tproc = clock()-xftinput;
+#endif
         //Print("\n// takes %d steps and calls the recursion of level 2:",  nwalk);
         /* call the changed perturbation walk algorithm with degree 2 */
@@ -4255 +4609 @@
 
 #ifdef TIME_TEST
- // Print("\n// \"Main procedure\"  took %d steps dnd %.2f sec. Overflow_Error (%d)", nwalk, ((double) tproc)/1000000, nOverflow_Error);
+  Print("\n// \"Main procedure\"  took %d steps dnd %.2f sec. Overflow_Error (%d)",
+        nwalk, ((double) tproc)/1000000, nOverflow_Error);
 
   TimeStringFractal(xftinput, tostd, xtif, xtstd, xtextra,xtlift, xtred,xtnw);
@@ -4287 +4642 @@
 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)
+static intvec* MWalkRandomNextWeight(ideal G, intvec* orig_M, intvec* target_weight,
+       int weight_rad, int pert_deg)
 {
-  int i, weight_norm;
-  int nV = currRing->N;
-  intvec* next_weight2;
+  assume(currRing != NULL && orig_M != NULL &&
+         target_weight != NULL && G->m[0] != NULL);
+
+  //BOOLEAN nError = Overflow_Error;
+  Overflow_Error = FALSE;
+
+  BOOLEAN found_random_weight = FALSE;
+  int i,nV = currRing->N;
+  intvec* curr_weight = new intvec(nV);
+
+  for(i=0; i<nV; i++)
+  {
+    (*curr_weight)[i] = (*orig_M)[i];
+  }
+
+  int k=0,weight_norm;
+  intvec* next_weight;
+  intvec* next_weight1 = MkInterRedNextWeight(curr_weight,target_weight,G);
+  intvec* next_weight2 = new intvec(nV);
   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)
+  intvec* result = new intvec(nV);
+  intvec* curr_weight1;
+  ideal G_test, G_test1, G_test2;
+
+  //try to find a random next weight vector "next_weight2"
+  if(weight_rad > 0){ while(k<10)
+  {
+    weight_norm = 0;
+    while(weight_norm == 0)
+    {
+
+      for(i=0; i<nV; i++)
+      {
+        (*next_weight2)[i] = rand() % 60000 - 30000;
+        weight_norm = weight_norm + (*next_weight2)[i]*(*next_weight2)[i];
+      }
+      weight_norm = 1 + floor(sqrt(weight_norm));
+    }
+
+    for(i=0; i<nV; i++)
+    {
+      if((*next_weight2)[i] < 0)
+      {
+        (*next_weight2)[i] = 1 + (*curr_weight)[i] + floor(weight_rad*(*next_weight2)[i]/weight_norm);
+      }
+      else
+      {
+        (*next_weight2)[i] = (*curr_weight)[i] + floor(weight_rad*(*next_weight2)[i]/weight_norm);
+      }
+    }
+    
+    if(test_w_in_ConeCC(G,next_weight2) == 1)
+    {
+      if(maxlengthpoly(MwalkInitialForm(G,next_weight2))<2)
+      {
+        next_weight2 = MkInterRedNextWeight(next_weight2,target_weight,G);
+      }
+/*
+      if(MivAbsMax(next_weight2)>1147483647)
       {
         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];
+          (*next_weight22)[i] = (*next_weight2)[i];
         }
-        weight_norm = 1 + floor(sqrt(weight_norm));
-      }
-
-      for(i=nV-1; i>=0; i--)
-      {
-        if((*next_weight22)[i] < 0)
+        i = 0;
+        // reduce the size of the maximal entry of the vector
+        while(test_w_in_ConeCC(G,next_weight22) == 1)
         {
-          (*next_weight22)[i] = 1 + (*curr_weight)[i] + floor(weight_rad*(*next_weight22)[i]/weight_norm);
+          (*next_weight2)[i] = (*next_weight22)[i];
+          i = MivAbsMaxArg(next_weight22);
+          (*next_weight22)[i] = floor(0.1*(*next_weight22)[i] + 0.5);
+        }
+        delete next_weight22;
+      }
+*/
+      G_test2 = MwalkInitialForm(G, next_weight2);
+      found_random_weight = TRUE;
+      break;
+    }
+    k++;
+  }}
+Print("\n MWalkRandomNextWeight: compute perurbation...\n");
+  // compute "perturbed" next weight vector
+  if(pert_deg > 1)
+  {
+    curr_weight1 = MPertVectors(G,orig_M,pert_deg);
+    next_weight = MkInterRedNextWeight(curr_weight1,target_weight,G);
+    delete curr_weight1;
+  }
+  else
+  {
+    next_weight = MkInterRedNextWeight(curr_weight,target_weight,G);
+  }
+  if(MivSame(curr_weight,next_weight)==1 || Overflow_Error == TRUE)
+  { 
+    Overflow_Error = FALSE;
+    delete next_weight;
+    next_weight = MkInterRedNextWeight(curr_weight,target_weight,G);
+  }
+  G_test=MwalkInitialForm(G,next_weight);
+  G_test1=MwalkInitialForm(G,next_weight1);
+Print("\n MWalkRandomNextWeight: finished...\n");
+  // compare next weights
+  if(Overflow_Error == FALSE)
+  {
+    if(found_random_weight == TRUE)
+    {
+    // random next weight vector found
+      if(G_test1->m[0] != NULL && maxlengthpoly(G_test1) < maxlengthpoly(G_test))
+      {
+        if(G_test2->m[0] != NULL && maxlengthpoly(G_test2) < maxlengthpoly(G_test1))
+        {
+          for(i=0; i<nV; i++)
+          {
+            (*result)[i] = (*next_weight2)[i];
+          }
         }
         else
         {
-          (*next_weight22)[i] = (*curr_weight)[i] + floor(weight_rad*(*next_weight22)[i]/weight_norm);
+          for(i=0; i<nV; i++)
+          {
+            (*result)[i] = (*next_weight1)[i];
+          }
+        }    
+      }
+      else
+      {
+        if(G_test2->m[0] != NULL && maxlengthpoly(G_test2) < maxlengthpoly(G_test))
+        {
+          for(i=0; i<nV; i++)
+          {
+            (*result)[i] = (*next_weight2)[i];
+          }
         }
-      //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++)
+        else
         {
-          (*result)[i] = (*next_weight2)[i];
+          for(i=0; i<nV; i++)
+          {
+            (*result)[i] = (*next_weight)[i];
+          }
         }
       }
-      else // |G_test1| < |G_test|, |G_test1| < |G_test2|
-      {
-        for(i=0; i<nV; i++)
+    }
+    else
+    {
+      // no random next weight vector found
+      if(G_test1->m[0] != NULL && maxlengthpoly(G_test1) < maxlengthpoly(G_test))
+      {
+       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|
+      else
       {
         for(i=0; i<nV; i++)
@@ -4384 +4810 @@
       }
     }
-    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 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 randCount=0;
-  int nV = currRing->N;
-  intvec* next_weight2;
-  intvec* next_weight22 = new intvec(nV);
-  intvec* result = new intvec(nV);
-
-  //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"
-  while(1)
-  {
-    weight_norm = 0;
-    while(weight_norm == 0)
-    {
-      for(i=0; i<nV; 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=0; i<nV; 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);
-      }
-    }
-    if(test_w_in_ConeCC(G, next_weight22) == 1)
-    {
-      next_weight2 = MkInterRedNextWeight(next_weight22,target_weight,G);
-      delete next_weight22;
-      break;
-    }
-  }
-  // compute "usual" next weight vector
-  intvec* next_weight = MwalkNextWeightCC(curr_weight,target_weight, G);
-  ideal G_test = MwalkInitialForm(G, next_weight);
-  ideal G_test2 = MwalkInitialForm(G, next_weight2);
-
-  // compare next weights
-  if(Overflow_Error == FALSE)
-  {
-    ideal G_test1 = MwalkInitialForm(G, next_weight1);
-    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++)
+  }
+  else
+  {
+    Overflow_Error = FALSE;
+    if(found_random_weight == TRUE)
+    {
+      if(G_test2->m[0] != NULL && maxlengthpoly(G_test2) < maxlengthpoly(G_test))
+      {
+        for(i=1; i<nV; i++)
         {
           (*result)[i] = (*next_weight2)[i];
@@ -4470 +4825 @@
       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++)
         {
@@ -4495 +4831 @@
       }
     }
-    idDelete(&G_test1);
-  }
-  else
-  {
-    Overflow_Error = FALSE;
-    if(IDELEMS(G_test2) < IDELEMS(G_test))
-    {
-      for(i=1; i<nV; i++)
-      {
-        (*result)[i] = (*next_weight2)[i];
-      }
-    }
     else
     {
@@ -4515 +4839 @@
     }
   }
+ // delete curr_weight1;
+  delete next_weight;
+  delete next_weight2;
   idDelete(&G_test);
-  idDelete(&G_test2);
-  if(test_w_in_ConeCC(G, result) == 1)
-  {
-    delete next_weight2;
-    delete next_weight;
+  idDelete(&G_test1);
+  if(found_random_weight == TRUE)
+  {
+    idDelete(&G_test2);
+  }
+  if(test_w_in_ConeCC(G, result) == 1 && MivSame(curr_weight,result)==0)
+  { 
+    delete curr_weight;
     delete next_weight1;
     return result;
@@ -4526 +4856 @@
   else
   {
+    delete curr_weight;
     delete result;
-    delete next_weight2;
-    delete next_weight1;
-    return next_weight;
+    return next_weight1;
   }
 }
@@ -4537 +4866 @@
  * The procedur REC_GB_Mwalk computes a GB for <G> w.r.t. the weight order *
  * otw, where G is a reduced GB w.r.t. the weight order cw.                *
- * The new procedur Mwalk calls REC_GB.                                    *
+ * The new procedure Mwalk calls REC_GB.                                   *
  ***************************************************************************/
 static ideal REC_GB_Mwalk(ideal G, intvec* curr_weight, intvec* orig_target_weight,
@@ -4575 +4904 @@
     else
     {
-      rChangeCurrRing(VMrDefault(orig_target_weight)); // Aenderung
+      rChangeCurrRing(VMrDefault(orig_target_weight));
     }
     TargetRing = currRing;
@@ -4646 +4975 @@
     else
     {
-      rChangeCurrRing(VMrDefault(curr_weight)); // Aenderung
+      rChangeCurrRing(VMrDefault(curr_weight));
     }
     newRing = currRing;
@@ -4755 +5084 @@
     else
     {
-      rChangeCurrRing(VMrDefault(orig_target_weight)); // Aenderung
+      rChangeCurrRing(VMrDefault(orig_target_weight));
     }
     F1 = idrMoveR(G, newRing,currRing);
@@ -4786 +5115 @@
       else
       {
-        rChangeCurrRing(VMrDefault(orig_target_weight)); // Aenderung
+        rChangeCurrRing(VMrDefault(orig_target_weight));
       }
     KSTD_Finish:
@@ -4840 +5169 @@
 
   ideal Gomega, M, F, Gomega1, Gomega2, M1, F1, G;
-  //ideal G1;
-  //ring endRing;
+
   ring newRing, oldRing;
   intvec* ivNull = new intvec(nV);
@@ -4883 +5211 @@
          the recursive changed perturbation walk alg. */
       tim = clock();
-      /*
-        Print("\n// **** Grï¿œbnerwalk took %d steps and ", nwalk);
+#ifdef CHECK_IDEAL_MWALK
+        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");
-      */
+        idString(Gomega, "Gomega");
+#endif
 
       if(MivSame(exivlp, target_weight)==1)
@@ -4893 +5221 @@
       else
         goto NORMAL_GW;
-      /*
+#ifdef TIME_TEST
         Print("\n//  time for the last std(Gw)  = %.2f sec",
         ((double) (clock()-tim)/1000000));
-        PrintS("\n// ***************************************************\n");
-      */
+#endif
+/*
 #ifdef CHECK_IDEAL_MWALK
       idElements(Gomega, "G_omega");
@@ -4904 +5232 @@
       //headidString(M, "M");
 #endif
+*/
       to = clock();
       F = MLifttwoIdeal(Gomega, M, G);
@@ -4914 +5243 @@
       oldRing = currRing;
 
-      /* create a new ring newRing */
+      // create a new ring newRing
        if (rParameter(currRing) != NULL)
        {
@@ -4921 +5250 @@
        else
        {
-         rChangeCurrRing(VMrDefault(curr_weight)); // Aenderung
+         rChangeCurrRing(VMrDefault(curr_weight));
        }
       newRing = currRing;
@@ -4947 +5276 @@
       else
       {
-        rChangeCurrRing(VMrDefault(curr_weight));  //Aenderung
+        rChangeCurrRing(VMrDefault(curr_weight));
       }
       newRing = currRing;
@@ -4959 +5288 @@
       M=kStd(Gomega1,NULL,isHomog,NULL,hilb_func,0,NULL,curr_weight);
       delete hilb_func;
-#endif // BUCHBERGER_ALG
+#endif
       tstd = tstd + clock() - to;
 
@@ -4968 +5297 @@
 
       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;
@@ -5018 +5349 @@
       else
       {
-        rChangeCurrRing(VMrDefault(target_weight)); // Aenderung
+        rChangeCurrRing(VMrDefault(target_weight));
       }
       F1 = idrMoveR(G, newRing,currRing);
@@ -5061 +5392 @@
 }
 
-
 /*******************************
  * 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)
+  {
+    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;
+  //BOOLEAN endwalks = FALSE;
 #ifdef TIME_TEST
   clock_t tinput, tostd, tif=0, tstd=0, tlift=0, tred=0, tnw=0;
@@ -5080 +5415 @@
 #endif
   nstep=0;
-  int i,nwalk,endwalks = 0;
+  int i,nwalk;
   int nV = baseRing->N;
 
-  ideal Gomega, M, F, Gomega1, Gomega2, M1; //, F1;
+  ideal Gomega, M, F, FF, Gomega1, Gomega2, M1;
   ring newRing;
   ring XXRing = baseRing;
+  ring targetRing;
   intvec* ivNull = new intvec(nV);
   intvec* curr_weight = new intvec(nV);
   intvec* target_weight = new intvec(nV);
   intvec* exivlp = Mivlp(nV);
+/*
   intvec* tmp_weight = new intvec(nV);
   for(i=0; i<nV; i++)
   {
-    (*tmp_weight)[i] = (*target_M)[i];
-  }
+    (*tmp_weight)[i] = (*orig_M)[i];
+  }
+*/
   for(i=0; i<nV; i++)
   {
@@ -5112 +5450 @@
   rComplete(currRing);
 #ifdef CHECK_IDEAL_MWALK
-    idString(Go,"Go");
-#endif
+  if(printout > 2)
+  {
+    idString(Go,"//** Mwalk: Go");
+  }
+#endif
+
+  if(target_M->length() == nV)
+  {
+   // define the target ring
+    targetRing = VMrDefault(target_weight);
+  }
+  else
+  {
+    targetRing = VMatrDefault(target_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);
+
 #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);
-      }
-  rChangeCurrRing(newRing);
   ideal G = MstdCC(idrMoveR(Go,baseRing,currRing));
+#ifdef TIME_TEST
+  tostd = clock()-to;
+#endif
+
   baseRing = currRing;
-#ifdef TIME_TEST
-  tostd = clock()-to;
-#endif
-
   nwalk = 0;
+
   while(1)
   {
     nwalk ++;
     nstep ++;
+    //compute an initial form ideal of <G> w.r.t. "curr_vector"
 #ifdef TIME_TEST
     to = clock();
 #endif
+    Gomega = MwalkInitialForm(G, curr_weight);
+#ifdef TIME_TEST
+    tif = tif + clock()-to;
+#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 TIME_TEST
-    tif = tif + clock()-to; //time for computing initial form ideal
-#endif
-#ifdef CHECK_IDEAL_MWALK
-    idString(Gomega,"Gomega");
-#endif
+    if(printout > 1)
+    {
+      idString(Gomega,"//** Mwalk: Gomega");
+    }
+#endif
+
+    if(reduction == 0)
+    {
+      FF = middleOfCone(G,Gomega);
+      if(FF != NULL)
+      {
+        idDelete(&G);
+        G = idCopy(FF);
+        idDelete(&FF);
+        goto NEXT_VECTOR;
+      } 
+    }
+
 #ifndef  BUCHBERGER_ALG
     if(isNolVector(curr_weight) == 0)
     {
       hilb_func = hFirstSeries(Gomega,NULL,NULL,curr_weight,currRing);
-    }
+    }   
     else
     {
@@ -5160 +5529 @@
     }
 #endif
+
     if(nwalk == 1)
     {
       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
@@ -5175 +5546 @@
      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),lp)"
+       newRing = VMrDefault(curr_weight);
      }
      else
      {
+       //define a new ring with matrix ordering
        newRing = VMatrRefine(target_M,curr_weight);
      }
@@ -5200 +5573 @@
     idSkipZeroes(M);
 #ifdef CHECK_IDEAL_MWALK
-    PrintS("\n//** Mwalk: computed M.\n");
-    idString(M, "M");
+    if(printout > 2)
+    {
+      idString(M, "//** Mwalk: M");
+    }
 #endif
     //change the ring to baseRing
@@ -5212 +5587 @@
     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
@@ -5218 +5594 @@
 #endif
 #ifdef CHECK_IDEAL_MWALK
-    idString(F, "F");
+    if(printout > 2)
+    {
+      idString(F, "//** Mwalk: F");
+    }
+#endif
+    idDelete(&Gomega2);
+    idDelete(&M1);
+
+    rChangeCurrRing(newRing); // change the ring to newRing
+    G = idrMoveR(F,baseRing,currRing);
+    idDelete(&F);
+    idSkipZeroes(G);
+
+#ifdef CHECK_IDEAL_MWALK
+    if(printout > 2)
+    {
+      idString(G, "//** Mwalk: G");
+    }
+#endif
+
+    rChangeCurrRing(targetRing);
+    G = idrMoveR(G,newRing,currRing);
+    // test whether target cone is reached
+    if(reduction !=0 && test_w_in_ConeCC(G,curr_weight) == 1)
+    {
+      baseRing = currRing;
+      break;
+      //endwalks = TRUE;
+    }
+
+    rChangeCurrRing(newRing);
+    G = idrMoveR(G,targetRing,currRing);
+    baseRing = currRing;
+
+    NEXT_VECTOR:
+#ifdef TIME_TEST
+    to = clock();
+#endif
+    intvec* next_weight = MwalkNextWeightCC(curr_weight,target_weight,G);
+#ifdef TIME_TEST
+    tnw = tnw + clock() - to;
+#endif
+#ifdef PRINT_VECTORS
+    if(printout > 0)
+    {
+      MivString(curr_weight, target_weight, next_weight);
+    }
+#endif
+    if(MivComp(target_weight,curr_weight) == 1)// || endwalks == TRUE)
+    {
+/*
+#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)
+      {
+        newRing = VMrDefault(target_weight); // define a new ring with ordering "(a(curr_weight),lp)
+      }
+      else
+      {
+        newRing = VMatrDefault(target_M);
+      }
+      rChangeCurrRing(newRing);
+      Gomega1 = idrMoveR(Gomega, baseRing,currRing);
+      idDelete(&Gomega);
+#ifdef CHECK_IDEAL_MWALK
+      if(printout > 1)
+      {
+        idString(Gomega1, "//** Mwalk: Gomega");
+      }
+      PrintS("\n //** Mwalk: kStd(Gomega)");
+#endif
+      M = kStd(Gomega1,NULL,testHomog,NULL,NULL,0,0,NULL);
+#ifdef CHECK_IDEAL_MWALK
+      if(printout > 1)
+      {
+        idString(M,"//** Mwalk: M");
+      }
+#endif
+      rChangeCurrRing(baseRing);
+      M1 =  idrMoveR(M, newRing,currRing);
+      idDelete(&M);
+      Gomega2 = idrMoveR(Gomega1, newRing,currRing);
+      idDelete(&Gomega1);
+      //PrintS("\n //** Mwalk: MLifttwoIdeal");
+      F = MLifttwoIdeal(Gomega2, M1, G);
+#ifdef CHECK_IDEAL_MWALK
+      if(printout > 2)
+      {
+        idString(F,"//** Mwalk: F");
+      }
+#endif
+      idDelete(&Gomega2);
+      idDelete(&M1);
+      rChangeCurrRing(newRing); // change the ring to newRing
+      G = idrMoveR(F,baseRing,currRing);
+      idDelete(&F);
+      baseRing = currRing;
+      idSkipZeroes(G);
+#ifdef TIME_TEST
+      to = clock();
+#endif
+      //PrintS("\n //**Mwalk: Interreduce");
+      //interreduce the Groebner basis <G> w.r.t. currRing
+      //G = kInterRedCC(G,NULL);
+#ifdef TIME_TEST
+      tred = tred + clock() - to;
+#endif
+      idSkipZeroes(G);
+      delete next_weight;
+*/
+      break;
+    }
+
+    for(i=nV-1; i>=0; i--)
+    {
+      //(*tmp_weight)[i] = (*curr_weight)[i];
+      (*curr_weight)[i] = (*next_weight)[i];
+    }
+    delete next_weight;
+  }
+  rChangeCurrRing(XXRing);
+  ideal result = idrMoveR(G,baseRing,currRing);
+  idDelete(&Go);
+  idDelete(&G);
+  //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);
+  //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);
+  si_opt_1 = save1; //set original options
+  return(result);
+}
+
+// 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
+  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;
+  BOOLEAN endwalks = FALSE;
+#ifdef TIME_TEST
+  clock_t tinput, tostd, tif=0, tstd=0, tlift=0, tred=0, tnw=0;
+  xtif=0; xtstd=0; xtlift=0; xtred=0; xtnw=0;
+  tinput = clock();
+  clock_t tim;
+#endif
+  nstep=0;
+  int i,nwalk;//polylength;
+  int nV = currRing->N;
+
+  //check that weight radius is valid
+  if(weight_rad < 0)
+  {
+    Werror("Invalid radius.\n");
+    return NULL;
+  }
+
+  //check that perturbation degree is valid
+  if(pert_deg > nV || pert_deg < 1)
+  {
+    Werror("Invalid perturbation degree.\n");
+    return NULL;
+  }
+
+  ideal Gomega, M, F,FF, Gomega1, Gomega2, M1;
+  ring newRing;
+  ring targetRing;
+  ring baseRing = currRing;
+  ring XXRing = currRing;
+  intvec* iv_M;
+  intvec* ivNull = new intvec(nV);
+  intvec* curr_weight = new intvec(nV);
+  intvec* target_weight = new intvec(nV);
+  intvec* next_weight= new intvec(nV);
+
+  for(i=0; i<nV; i++)
+  {
+    (*curr_weight)[i] = (*orig_M)[i];
+    (*target_weight)[i] = (*target_M)[i];
+  }
+
+#ifndef BUCHBERGER_ALG
+  intvec* hilb_func;
+   // 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;
+#endif
+  rComplete(currRing);
+
+  if(target_M->length() == nV)
+  {
+    targetRing = VMrDefault(target_weight); // define the target ring
+  }
+  else
+  {
+    targetRing = VMatrDefault(target_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);
+#ifdef TIME_TEST
+  to = clock();
+#endif
+  ideal G = MstdCC(idrMoveR(Go,baseRing,currRing));
+#ifdef TIME_TEST
+  tostd = clock()-to;
+#endif
+  baseRing = currRing;
+  nwalk = 0;
+
+#ifdef TIME_TEST
+  to = clock();
+#endif
+  Gomega = MwalkInitialForm(G, curr_weight); // compute an initial form ideal of <G> w.r.t. "curr_vector"
+#ifdef TIME_TEST
+  tif = tif + clock()-to; //time for computing initial form ideal
+#endif
+
+  while(1)
+  {
+    nwalk ++;
+    nstep ++;
+#ifdef CHECK_IDEAL_MWALK
+    if(printout > 1)
+    {
+      idString(Gomega,"//** Mrwalk: Gomega");
+    }
+#endif
+    if(reduction == 0)
+    {
+      FF = middleOfCone(G,Gomega);
+      if(FF != NULL)
+      {
+        idDelete(&G);
+        G = idCopy(FF);
+        idDelete(&FF);
+        goto NEXT_VECTOR;
+      } 
+    }
+#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
+    if(nwalk == 1)
+    {
+      if(orig_M->length() == nV)
+      {
+        newRing = VMrDefault(curr_weight); // define a new ring with ordering "(a(curr_weight),lp)
+      }
+      else
+      {
+        newRing = VMatrDefault(orig_M);
+      }
+    }
+    else
+    {
+     if(target_M->length() == nV)
+     {
+       newRing = VMrDefault(curr_weight); // define a new ring with ordering "(a(curr_weight),lp)
+     }
+     else
+     {
+       newRing = VMatrRefine(target_M,curr_weight);
+     }
+    }
+    rChangeCurrRing(newRing);
+    Gomega1 = idrMoveR(Gomega, baseRing,currRing);
+    idDelete(&Gomega);
+    // compute a reduced Groebner basis of <Gomega> w.r.t. "newRing"
+#ifdef TIME_TEST
+    to = clock();
+#endif
+#ifndef BUCHBERGER_ALG
+    M=kStd(Gomega1,NULL,isHomog,NULL,hilb_func,0,NULL,curr_weight);
+    delete hilb_func;
+#else
+    M = kStd(Gomega1,NULL,testHomog,NULL,NULL,0,0,NULL);
+#endif
+#ifdef TIME_TEST
+    tstd = tstd + clock() - to;
+#endif
+    idSkipZeroes(M);
+#ifdef CHECK_IDEAL_MWALK
+    if(printout > 2)
+    {
+      idString(M, "//** Mrwalk: M");
+    }
+#endif
+    //change the ring to baseRing
+    rChangeCurrRing(baseRing);
+    M1 =  idrMoveR(M, newRing,currRing);
+    idDelete(&M);
+    Gomega2 = idrMoveR(Gomega1, newRing,currRing);
+    idDelete(&Gomega1);
+#ifdef TIME_TEST
+    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
+    F = MLifttwoIdeal(Gomega2, M1, G);
+#ifdef TIME_TEST
+    tlift = tlift + clock() - to;
+#endif
+#ifdef CHECK_IDEAL_MWALK
+    if(printout > 2)
+    {
+      idString(F,"//** Mrwalk: F");
+    }
 #endif
     idDelete(&Gomega2);
@@ -5228 +5947 @@
 #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
+    if(printout > 2)
+    {
+      idString(G,"//** Mrwalk: G");
+    }
+#endif
+
+    rChangeCurrRing(targetRing);
+    G = idrMoveR(G,newRing,currRing);
+
+    // test whether target cone is reached
+    if(reduction !=0 && test_w_in_ConeCC(G,curr_weight) == 1)
+    {
+      baseRing = currRing;
+      break;
+    }
+
+    rChangeCurrRing(newRing);
+    G = idrMoveR(G,targetRing,currRing);
+    baseRing = currRing;
+
+    NEXT_VECTOR:
 #ifdef TIME_TEST
     to = clock();
 #endif
-    intvec* next_weight = MwalkNextWeightCC(curr_weight,target_weight,G);
+    next_weight = MwalkNextWeightCC(curr_weight,target_weight,G);
 #ifdef TIME_TEST
     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
-      Gomega = MwalkInitialForm(G, curr_weight); // compute an initial form ideal of <G> w.r.t. "curr_vector"
+
+#ifdef TIME_TEST
+    to = clock();
+#endif
+    Gomega = MwalkInitialForm(G, next_weight); // compute an initial form ideal of <G> w.r.t. "curr_vector"
+#ifdef TIME_TEST
+    tif = tif + clock()-to; //time for computing initial form ideal
+#endif
+
+    //lengthpoly(Gomega) = 1 if there is a polynomial in Gomega with at least 3 monomials and 0 otherwise
+    //polylength = lengthpoly(Gomega);
+    if(lengthpoly(Gomega) > 0)
+    {
+      //there is a polynomial in Gomega with at least 3 monomials,
+      //low-dimensional facet of the cone
+      delete next_weight;
       if(target_M->length() == nV)
       {
-        newRing = VMrDefault(target_weight); // define a new ring with ordering "(a(curr_weight),lp)
+        iv_M = MivMatrixOrder(curr_weight);
       }
       else
       {
-        newRing = VMatrDefault(target_M);
-      }
-      rChangeCurrRing(newRing);
-      Gomega1 = idrMoveR(Gomega, baseRing,currRing);
+        iv_M = MivMatrixOrderRefine(curr_weight,target_M);
+      }
+#ifdef TIME_TEST
+      to = clock();
+#endif
+      next_weight = MWalkRandomNextWeight(G, iv_M, target_weight, weight_rad, pert_deg);
+#ifdef TIME_TEST
+      tnw = tnw + clock() - to;
+#endif
       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
-      rChangeCurrRing(baseRing);
-      M1 =  idrMoveR(M, newRing,currRing);
-      idDelete(&M);
-      Gomega2 = idrMoveR(Gomega1, newRing,currRing);
-      idDelete(&Gomega1);
-      F = MLifttwoIdeal(Gomega2, M1, G);
-#ifdef CHECK_IDEAL_MWALK
-      idString(F,"F");
-#endif
-      idDelete(&Gomega2);
-      idDelete(&M1);
-      rChangeCurrRing(newRing); // change the ring to newRing
-      G = idrMoveR(F,baseRing,currRing);
-      idDelete(&F);
+#ifdef TIME_TEST
+      to = clock();
+#endif
+      Gomega = MwalkInitialForm(G, next_weight);
+#ifdef TIME_TEST
+      tif = tif + clock()-to; //time for computing initial form ideal
+#endif
+      delete iv_M;
+    }
+
+    // test whether target weight vector is reached
+    if(MivComp(next_weight, ivNull) == 1 || MivComp(target_weight,curr_weight) == 1)
+    {
       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 TIME_TEST
-      tred = tred + clock() - to;
-#endif
-      idSkipZeroes(G);
       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
+    }
+
+#ifdef PRINT_VECTORS
+    if(printout > 0)
+    {
+      MivString(curr_weight, target_weight, next_weight);
+    }
+#endif
+
     for(i=nV-1; i>=0; i--)
     {
-      (*tmp_weight)[i] = (*curr_weight)[i];
       (*curr_weight)[i] = (*next_weight)[i];
     }
     delete next_weight;
   }
+  baseRing = currRing;
   rChangeCurrRing(XXRing);
   ideal result = idrMoveR(G,baseRing,currRing);
   idDelete(&G);
-/*#ifdef CHECK_IDEAL_MWALK
-  pDelete(&p);
-#endif*/
-  delete tmp_weight;
   delete ivNull;
-  delete exivlp;
 #ifndef BUCHBERGER_ALG
   delete last_omega;
 #endif
-#ifdef TIME_TEST
-  Print("\n//** Mwalk: Groebner Walk took %d steps.\n", nstep);
+  Print("\n//** Mrwalk: Groebner Walk took %d steps.\n", nstep);
+#ifdef TIME_TEST
   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
+  si_opt_1 = save1; //set original options
   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)
-{
-  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));
-  Set_Error(FALSE);
-  Overflow_Error = FALSE;
-#ifdef TIME_TEST
-  clock_t tinput, tostd, tif=0, tstd=0, tlift=0, tred=0, tnw=0;
-  xtif=0; xtstd=0; xtlift=0; xtred=0; xtnw=0;
-  tinput = clock();
-  clock_t tim;
-#endif
-  nstep=0;
-  int i,nwalk,endwalks = 0;
-  int nV = baseRing->N;
-
-  ideal Gomega, M, F, Gomega1, Gomega2, M1; //, F1;
-  ring newRing;
-  ring XXRing = baseRing;
-  intvec* ivNull = new intvec(nV);
-  intvec* curr_weight = new intvec(nV);
-  intvec* target_weight = new intvec(nV);
-  intvec* exivlp = Mivlp(nV);
-  intvec* tmp_weight = new intvec(nV);
-  for(i=0; i<nV; i++)
-  {
-    (*tmp_weight)[i] = (*target_M)[i];
-  }
-  for(i=0; i<nV; i++)
-  {
-    (*curr_weight)[i] = (*orig_M)[i];
-    (*target_weight)[i] = (*target_M)[i];
-  }
-#ifndef BUCHBERGER_ALG
-  intvec* hilb_func;
-   // 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;
-#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);
-      }
-  rChangeCurrRing(newRing);
-  ideal G = MstdCC(idrMoveR(Go,baseRing,currRing));
-  baseRing = currRing;
-#ifdef TIME_TEST
-  tostd = clock()-to;
-#endif
-
-  nwalk = 0;
-  while(1)
-  {
-    nwalk ++;
-    nstep ++;
-#ifdef TIME_TEST
-    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 TIME_TEST
-    tif = tif + clock()-to; //time for computing initial form ideal
-#endif
-#ifdef CHECK_IDEAL_MWALK
-    idString(Gomega,"Gomega");
-#endif
-#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
-    if(nwalk == 1)
-    {
-      if(orig_M->length() == nV)
-      {
-        newRing = VMrDefault(curr_weight); // define a new ring with ordering "(a(curr_weight),lp)
-      }
-      else
-      {
-        newRing = VMatrDefault(orig_M);
-      }
-    }
-    else
-    {
-     if(target_M->length() == nV)
-     {
-       newRing = VMrRefine(curr_weight,target_weight); //define a new ring with ordering "(a(curr_weight),Wp(target_weight))"
-     }
-     else
-     {
-       newRing = VMatrRefine(target_M,curr_weight);
-     }
-    }
-    rChangeCurrRing(newRing);
-    Gomega1 = idrMoveR(Gomega, baseRing,currRing);
-    idDelete(&Gomega);
-    // compute a reduced Groebner basis of <Gomega> w.r.t. "newRing"
-#ifdef TIME_TEST
-    to = clock();
-#endif
-#ifndef  BUCHBERGER_ALG
-    M=kStd(Gomega1,NULL,isHomog,NULL,hilb_func,0,NULL,curr_weight);
-    delete hilb_func;
-#else
-    M = kStd(Gomega1,NULL,testHomog,NULL,NULL,0,0,NULL);
-#endif
-#ifdef TIME_TEST
-    tstd = tstd + clock() - to;
-#endif
-    idSkipZeroes(M);
-#ifdef CHECK_IDEAL_MWALK
-    PrintS("\n//** Mwalk: computed M.\n");
-    idString(M, "M");
-#endif
-    //change the ring to baseRing
-    rChangeCurrRing(baseRing);
-    M1 =  idrMoveR(M, newRing,currRing);
-    idDelete(&M);
-    Gomega2 = idrMoveR(Gomega1, newRing,currRing);
-    idDelete(&Gomega1);
-#ifdef TIME_TEST
-    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
-    F = MLifttwoIdeal(Gomega2, M1, G);
-#ifdef TIME_TEST
-    tlift = tlift + clock() - to;
-#endif
-#ifdef CHECK_IDEAL_MWALK
-    idString(F, "F");
-#endif
-    idDelete(&Gomega2);
-    idDelete(&M1);
-    rChangeCurrRing(newRing); // change the ring to newRing
-    G = idrMoveR(F,baseRing,currRing);
-    idDelete(&F);
-    baseRing = currRing;
-#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 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);
-#ifdef TIME_TEST
-    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
-      Gomega = MwalkInitialForm(G, curr_weight); // compute an initial form ideal of <G> w.r.t. "curr_vector"
-      if(target_M->length() == nV)
-      {
-        newRing = VMrDefault(target_weight); // define a new ring with ordering "(a(curr_weight),lp)
-      }
-      else
-      {
-        newRing = VMatrDefault(target_M);
-      }
-      rChangeCurrRing(newRing);
-      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
-      rChangeCurrRing(baseRing);
-      M1 =  idrMoveR(M, newRing,currRing);
-      idDelete(&M);
-      Gomega2 = idrMoveR(Gomega1, newRing,currRing);
-      idDelete(&Gomega1);
-      F = MLifttwoIdeal(Gomega2, M1, G);
-#ifdef CHECK_IDEAL_MWALK
-      idString(F,"F");
-#endif
-      idDelete(&Gomega2);
-      idDelete(&M1);
-      rChangeCurrRing(newRing); // change the ring to newRing
-      G = idrMoveR(F,baseRing,currRing);
-      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 TIME_TEST
-      tred = tred + clock() - to;
-#endif
-      idSkipZeroes(G);
-      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--)
-    {
-      (*tmp_weight)[i] = (*curr_weight)[i];
-      (*curr_weight)[i] = (*next_weight)[i];
-    }
-    delete next_weight;
-  }
-  rChangeCurrRing(XXRing);
-  ideal result = idrMoveR(G,baseRing,currRing);
-  idDelete(&G);
-/*#ifdef CHECK_IDEAL_MWALK
-  pDelete(&p);
-#endif*/
-  delete tmp_weight;
-  delete ivNull;
-  delete exivlp;
-#ifndef BUCHBERGER_ALG
-  delete last_omega;
-#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
-  return(result);
-}
-
-//unused
-#if 0
-ideal Mwalk_tst(ideal Go, intvec* curr_weight, intvec* target_weight)
-{
-  //clock_t tinput=clock();
-  //idString(Go,"Ginp");
-  int i, nV = currRing->N;
-  int nwalk=0, endwalks=0;
-
-  ideal Gomega, M, F, Gomega1, Gomega2, M1, F1, G;
-  // ideal G1; ring endRing;
-  ring newRing, oldRing;
-  intvec* ivNull = new intvec(nV);
-  ring XXRing = currRing;
-
-  intvec* tmp_weight = new intvec(nV);
-  for(i=nV-1; i>=0; i--)
-  {
-    (*tmp_weight)[i] = (*curr_weight)[i];
-  }
-  /* the monomial ordering of this current ring would be "dp" */
-  G = MstdCC(Go);
-#ifndef BUCHBERGER_ALG
-  intvec* hilb_func;
-#endif
-  /* 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;
-
-  while(1)
-  {
-    nwalk ++;
-    //Print("\n// Entering the %d-th step:", nwalk);
-    //Print("\n// ring r[%d] = %s;", nwalk, rString(currRing));
-    idString(G,"G");
-    /* compute an initial form ideal of <G> w.r.t. "curr_vector" */
-    Gomega = MwalkInitialForm(G, curr_weight);
-    //ivString(curr_weight, "omega");
-    idString(Gomega,"Gw");
-
-#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;
-
-    /* define a new ring that its ordering is "(a(curr_weight),lp) */
-    VMrDefault(curr_weight);
-    newRing = currRing;
-
-    Gomega1 = idrMoveR(Gomega, oldRing,currRing);
-
-    /* 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 // BUCHBERGER_ALG
-
-    idString(M,"M");
-
-      /* change the ring to oldRing */
-    rChangeCurrRing(oldRing);
-    M1 =  idrMoveR(M, newRing,currRing);
-    Gomega2 =  idrMoveR(Gomega1, newRing,currRing);
-
-      /* 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);
-    idDelete(&M1);
-    idDelete(&Gomega2);
-    idDelete(&G);
-    idString(F,"F");
-
-    /* change the ring to newRing */
-    rChangeCurrRing(newRing);
-    F1 = idrMoveR(F, oldRing,currRing);
-
-    /* reduce the Groebner basis <G> w.r.t. new ring */
-    G = kInterRedCC(F1, NULL);
-    //idSkipZeroes(G);//done by kInterRed
-    idDelete(&F1);
-    idString(G,"G");
-    if(endwalks == 1)
-      break;
-
-    /* compute a next weight vector */
-    intvec* next_weight = MkInterRedNextWeight(curr_weight,target_weight,G);
-#ifdef PRINT_VECTORS
-    MivString(curr_weight, target_weight, next_weight);
-#endif
-
-    if(MivComp(next_weight, ivNull) == 1)
-    {
-      delete next_weight;
-      break;
-    }
-    if(MivComp(next_weight, target_weight) == 1)
-      endwalks = 1;
-
-    for(i=nV-1; i>=0; i--)
-      (*tmp_weight)[i] = (*curr_weight)[i];
-
-    /* 06.11.01 to free the memory: NOT Changed!!*/
-    for(i=nV-1; i>=0; i--)
-      (*curr_weight)[i] = (*next_weight)[i];
-    delete next_weight;
-  }
-  rChangeCurrRing(XXRing);
-  G = idrMoveR(G, newRing,currRing);
-
-  delete tmp_weight;
-  delete ivNull;
-  PrintLn();
-  return(G);
-}
-#endif
 
 /**************************************************************/
@@ -5749 +6072 @@
    2) the changed perturbation walk algorithm with a decreased degree.
 */
-// use kStd, if nP = 0, else call LastGB
+// if nP = 0 use kStd, 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
+  }
   Set_Error(FALSE  );
   Overflow_Error = FALSE;
   //Print("// pSetm_Error = (%d)", ErrorCheck());
-
+#ifdef TIME_TEST
   clock_t  tinput, tostd, tif=0, tstd=0, tlift=0, tred=0, tnw=0;
   xtextra=0;
@@ -5763 +6092 @@
 
   clock_t tim;
-
+#endif
   nstep = 0;
   int i, ntwC=1, ntestw=1,  nV = currRing->N;
-  int endwalks=0;
-
-  ideal Gomega, M, F, G, Gomega1, Gomega2, M1,F1,Eresult,ssG;
+
+  //check that perturbation degree is valid
+  if(op_deg < 1 || tp_deg < 1 || op_deg > nV || tp_deg > nV)
+  {
+    Werror("Invalid perturbation degree.\n");
+    return NULL;
+  }
+
+  BOOLEAN endwalks = FALSE;
+  ideal Gomega, M, F, FF, G, Gomega1, Gomega2, M1,F1,Eresult,ssG;
   ring newRing, oldRing, TargetRing;
   intvec* iv_M_dp;
@@ -5789 +6125 @@
 
   ring XXRing = currRing;
-
-
+#ifdef TIME_TEST
   to = clock();
-  /* perturbs the original vector */
+#endif
+  // perturbs the original vector
   if(MivComp(curr_weight, iv_dp) == 1) //rOrdStr(currRing) := "dp"
   {
     G = MstdCC(Go);
+#ifdef TIME_TEST
     tostd = clock()-to;
+#endif
     if(op_deg != 1){
       iv_M_dp = MivMatrixOrderdp(nV);
@@ -5809 +6147 @@
       DefRingPar(curr_weight);
     else
-      rChangeCurrRing(VMrDefault(curr_weight)); //Aenderung 1
+      rChangeCurrRing(VMrDefault(curr_weight));
 
     G = idrMoveR(Go, XXRing,currRing);
     G = MstdCC(G);
+#ifdef TIME_TEST
     tostd = clock()-to;
+#endif
     if(op_deg != 1){
       iv_M_dp = MivMatrixOrder(curr_weight);
@@ -5824 +6164 @@
   ring HelpRing = currRing;
 
-  /* perturbs the target weight vector */
+  // perturbs the target weight vector
   if(tp_deg > 1 && tp_deg <= nV)
   {
@@ -5830 +6170 @@
       DefRingPar(target_weight);
     else
-      rChangeCurrRing(VMrDefault(target_weight)); // Aenderung 2
+      rChangeCurrRing(VMrDefault(target_weight));
 
     TargetRing = currRing;
@@ -5837 +6177 @@
     {
       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);
     }
@@ -5844 +6182 @@
     {
       iv_M_lp = MivMatrixOrder(target_weight);
-      //target_weight = MPertVectorslp(ssG, iv_M_lp, tp_deg);
       target_weight = MPertVectors(ssG, iv_M_lp, tp_deg);
     }
@@ -5852 +6189 @@
     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);
+#ifdef PRINT_VECTORS
+    ivString(curr_weight, "//** Mpwalk: new current weight");
+    ivString(target_weight, "//** Mpwalk: new target weight");
+#endif
+  }
   while(1)
   {
     nstep ++;
+#ifdef TIME_TEST
     to = clock();
-    /* compute an initial form ideal of <G> w.r.t. the weight vector
-       "curr_weight" */
+#endif
+    // compute an initial form ideal of <G> w.r.t. the weight vector
+    // "curr_weight"
     Gomega = MwalkInitialForm(G, curr_weight);
-
+#ifdef TIME_TEST
+    tif = tif + clock()-to;
+#endif
+#ifdef CHECK_IDEAL_MWALK
+    if(printout > 1)
+    {
+      idString(Gomega,"//** Mpwalk: Gomega");
+    }
+#endif
+    if(reduction == 0 && nstep > 1)
+    {
+/*
+      // check whether weight vector is in the interior of the cone
+      while(1)
+      {
+        FF = middleOfCone(G,Gomega);
+        if(FF != NULL)
+        {
+          idDelete(&G);
+          G = idCopy(FF);
+          idDelete(&FF);
+          next_weight = MwalkNextWeightCC(curr_weight,target_weight,G);
+#ifdef PRINT_VECTORS
+          if(printout > 0)
+          {
+            MivString(curr_weight, target_weight, next_weight);
+          }
+#endif
+        }
+        else
+        {
+          break;
+        }
+        for(i=nV-1; i>=0; i--)
+        {
+          (*curr_weight)[i] = (*next_weight)[i];
+        }
+        Gomega = MwalkInitialForm(G, curr_weight);
+#ifdef CHECK_IDEAL_MWALK
+        if(printout > 1)
+        {
+          idString(Gomega,"//** Mpwalk: Gomega");
+        }
+#endif
+      }
+*/
+      FF = middleOfCone(G,Gomega);
+      if(FF != NULL)
+      {
+        idDelete(&G);
+        G = idCopy(FF);
+        idDelete(&FF); 
+        goto NEXT_VECTOR;
+      }
+    }
 
 #ifdef ENDWALKS
-    if(endwalks == 1){
+    if(endwalks == TRUE)
+    {
       Print("\n// ring r%d = %s;\n", nstep, rString(currRing));
+/*
       idElements(G, "G");
-      // idElements(Gomega, "Gw");
       headidString(G, "G");
-      //headidString(Gomega, "Gw");
-    }
-#endif
-
-    tif = tif + clock()-to;
+*/
+    }
+#endif
 
 #ifndef  BUCHBERGER_ALG
@@ -5891 +6286 @@
       DefRingPar(curr_weight);
     else
-      rChangeCurrRing(VMrDefault(curr_weight)); //Aenderung 3
+      rChangeCurrRing(VMrDefault(curr_weight));
 
     newRing = currRing;
@@ -5897 +6292 @@
 
 #ifdef ENDWALKS
-    if(endwalks==1)
+    if(endwalks==TRUE)
     {
       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");
@@ -5909 +6305 @@
     }
 #endif
-
+#ifdef TIME_TEST
     tim = clock();
     to = clock();
-    /* compute a reduced Groebner basis of <Gomega> w.r.t. "newRing" */
+#endif
+    // compute a reduced Groebner basis of <Gomega> w.r.t. "newRing"
 #ifdef  BUCHBERGER_ALG
     M = MstdhomCC(Gomega1);
@@ -5918 +6315 @@
     M=kStd(Gomega1,NULL,isHomog,NULL,hilb_func,0,NULL,curr_weight);
     delete hilb_func;
-#endif // BUCHBERGER_ALG
-
-    if(endwalks == 1){
+#endif
+
+    if(endwalks == TRUE)
+    {
+#ifdef TIME_TEST
       xtstd = xtstd+clock()-to;
+#endif
 #ifdef ENDWALKS
       Print("\n// time for the last std(Gw)  = %.2f sec\n",
@@ -5928 +6328 @@
     }
     else
+    {
+#ifdef TIME_TEST
       tstd=tstd+clock()-to;
-
-    /* change the ring to oldRing */
+#endif
+    }
+#ifdef CHECK_IDEAL_MWALK
+    if(printout > 2)
+    {
+      idString(M,"//** Mpwalk: M");
+    }
+#endif
+    // change the ring to oldRing
     rChangeCurrRing(oldRing);
     M1 =  idrMoveR(M, newRing,currRing);
     Gomega2 =  idrMoveR(Gomega1, newRing,currRing);
-
-    //if(endwalks==1)  PrintS("\n// Lifting is working:..");
-
+#ifdef TIME_TEST
     to=clock();
+#endif
     /* 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)
+#ifdef TIME_TEST
+    if(endwalks == FALSE)
       tlift = tlift+clock()-to;
     else
       xtlift=clock()-to;
+#endif
+#ifdef CHECK_IDEAL_MWALK
+    if(printout > 2)
+    {
+      idString(F,"//** Mpwalk: F");
+    }
+#endif
 
     idDelete(&M1);
@@ -5951 +6367 @@
     idDelete(&G);
 
-    /* change the ring to newRing */
+    // change the ring to newRing
     rChangeCurrRing(newRing);
-    F1 = idrMoveR(F, oldRing,currRing);
-
-    //if(endwalks==1)PrintS("\n// InterRed is working now:");
-
+    if(reduction == 0)
+    {
+      G = idrMoveR(F,oldRing,currRing);
+    }
+    else
+    {
+      F1 = idrMoveR(F, oldRing,currRing);
+      if(printout > 2)
+      {
+        PrintS("\n //** Mpwalk: reduce the Groebner basis.\n");
+      }
+#ifdef TIME_TEST
+      to=clock();
+#endif
+      G = kInterRedCC(F1, NULL);
+#ifdef TIME_TEST
+      if(endwalks == FALSE)
+        tred = tred+clock()-to;
+      else
+        xtred=clock()-to;
+#endif
+      idDelete(&F1);
+    }
+    if(endwalks == TRUE)
+      break;
+
+    NEXT_VECTOR:
+#ifdef TIME_TEST
     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 */
+#endif
+    // compute a next weight vector
     next_weight = MkInterRedNextWeight(curr_weight,target_weight, G);
+#ifdef TIME_TEST
     tnw=tnw+clock()-to;
+#endif
 #ifdef PRINT_VECTORS
-    MivString(curr_weight, target_weight, next_weight);
+    if(printout > 0)
+    {
+      MivString(curr_weight, target_weight, next_weight);
+    }
 #endif
 
@@ -5994 +6427 @@
     }
     if(MivComp(next_weight, target_weight) == 1)
-      endwalks = 1;
+      endwalks = TRUE;
 
     for(i=nV-1; i>=0; i--)
@@ -6000 +6433 @@
 
     delete next_weight;
-  }//while
+  }//end of while-loop
 
   if(tp_deg != 1)
@@ -6014 +6447 @@
         DefRingPar(orig_target);
       else
-        rChangeCurrRing(VMrDefault(orig_target)); //Aenderung
+        rChangeCurrRing(VMrDefault(orig_target));
 
     TargetRing=currRing;
     F1 = idrMoveR(G, newRing,currRing);
-#ifdef CHECK_IDEAL
+/*
+#ifdef CHECK_IDEAL_MWALK
       headidString(G, "G");
 #endif
-
+*/
 
     // check whether the pertubed target vector stays in the correct cone
@@ -6030 +6464 @@
     if( ntestw != 1 || ntwC == 0)
     {
-      /*
-      if(ntestw != 1){
+      if(ntestw != 1 && printout >2)
+      {
         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");
-      }
-      */
+        //idElements(F1, "G");
+      }
       // LastGB is "better" than the kStd subroutine
       to=clock();
@@ -6068 +6501 @@
     Eresult = idrMoveR(G, newRing,currRing);
   }
+  si_opt_1 = save1; //set original options, e. g. option(RedSB)
   delete ivNull;
   if(tp_deg != 1)
@@ -6082 +6516 @@
              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
+  }
+  Set_Error(FALSE);
+  Overflow_Error = FALSE;
+  //Print("// pSetm_Error = (%d)", ErrorCheck());
+#ifdef TIME_TEST
+  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;
+#endif
+  nstep = 0;
+  int i, ntwC=1, ntestw=1, nV = currRing->N; //polylength
+
+  //check that weight radius is valid
+  if(weight_rad < 0)
+  {
+    Werror("Invalid radius.\n");
+    return NULL;
+  }
+
+  //check that perturbation degree is valid
+  if(op_deg < 1 || tp_deg < 1 || op_deg > nV || tp_deg > nV)
+  {
+    Werror("Invalid perturbation degree.\n");
+    return NULL;
+  }
+
+  BOOLEAN endwalks = FALSE;
+
+  ideal Gomega, M, F, FF, G, Gomega1, Gomega2, M1,F1,Eresult,ssG;
+  ring newRing, oldRing, TargetRing;
+  intvec* iv_M;
+  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;
+
+  // perturbs the original vector
+  if(orig_M->length() == nV)
+  {
+    if(MivComp(curr_weight, iv_dp) == 1) //rOrdStr(currRing) := "dp"
+    {
+#ifdef TIME_TEST
+  to = clock();
+#endif
+      G = MstdCC(Go);
+#ifdef TIME_TEST
+      tostd = clock()-to;
+#endif
+      if(op_deg != 1)
+      {
+        iv_M_dp = MivMatrixOrderdp(nV);
+        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);
+#ifdef TIME_TEST
+  to = clock();
+#endif
+      G = MstdCC(G);
+#ifdef TIME_TEST
+      tostd = clock()-to;
+#endif
+      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);
+#ifdef TIME_TEST
+    to = clock();
+#endif
+    G = MstdCC(G);
+#ifdef TIME_TEST
+    tostd = clock()-to;
+#endif
+    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);
+        target_weight = MPertVectors(ssG, iv_M_lp, tp_deg);
+      }
+      else
+      {
+        iv_M_lp = MivMatrixOrder(target_weight);
+        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");
+  }
+
+#ifdef TIME_TEST
+  to = clock();
+#endif
+  Gomega = MwalkInitialForm(G, curr_weight); // compute an initial form ideal of <G> w.r.t. "curr_vector"
+#ifdef TIME_TEST
+  tif = tif + clock()-to; //time for computing initial form ideal
+#endif
+
+  while(1)
+  {
+    nstep ++;
+#ifdef CHECK_IDEAL_MWALK
+    if(printout > 1)
+    {
+      idString(Gomega,"//** Mprwalk: Gomega");
+    }
+#endif
+
+    if(reduction == 0 && nstep > 1)
+    {
+/*
+      // check whether weight vector is in the interior of the cone
+      while(1)
+      {
+        FF = middleOfCone(G,Gomega);
+        if(FF != NULL)
+        {
+          idDelete(&G);
+          G = idCopy(FF);
+          idDelete(&FF);
+          next_weight = MwalkNextWeightCC(curr_weight,target_weight,G);
+#ifdef PRINT_VECTORS
+          if(printout > 0)
+          {
+            MivString(curr_weight, target_weight, next_weight);
+          }
+#endif
+        }
+        else
+        {
+          break;
+        }
+        for(i=nV-1; i>=0; i--)
+        {
+          (*curr_weight)[i] = (*next_weight)[i];
+        }
+        Gomega = MwalkInitialForm(G, curr_weight);
+#ifdef CHECK_IDEAL_MWALK
+        if(printout > 1)
+        {
+          idString(Gomega,"//** Mprwalk: Gomega");
+        }
+#endif
+      }
+*/
+      FF = middleOfCone(G,Gomega);
+      if(FF != NULL)
+      {
+        idDelete(&G);
+        G = idCopy(FF);
+        idDelete(&FF); 
+        goto NEXT_VECTOR;
+      } 
+    }
+
+#ifdef ENDWALKS
+    if(endwalks == TRUE)
+    {
+      Print("\n// ring r%d = %s;\n", nstep, rString(currRing));
+/*
+      idElements(G, "G");
+      headidString(G, "G");
+*/
+    }
+#endif
+
+#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 == TRUE)
+    {
+      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
+#ifdef TIME_TEST
+    tim = clock();
+    to = clock();
+#endif
+    // 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
+#ifdef TIME_TEST
+    if(endwalks == TRUE)
+    {
+      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;
+#endif
+    /* change the ring to oldRing */
+    rChangeCurrRing(oldRing);
+    M1 =  idrMoveR(M, newRing,currRing);
+    Gomega2 =  idrMoveR(Gomega1, newRing,currRing);
+#ifdef TIME_TEST
+    to=clock();
+#endif
+    /* 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);
+#ifdef TIME_TEST
+    if(endwalks == FALSE)
+      tlift = tlift+clock()-to;
+    else
+      xtlift=clock()-to;
+#endif
+#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);
+    if(reduction == 0)
+    {
+      G = idrMoveR(F,oldRing,currRing);
+    }
+    else
+    {
+      F1 = idrMoveR(F, oldRing,currRing);
+      if(printout > 2)
+      {
+        PrintS("\n //** Mprwalk: reduce the Groebner basis.\n");
+      }
+#ifdef TIME_TEST
+      to=clock();
+#endif
+      G = kInterRedCC(F1, NULL);
+#ifdef TIME_TEST
+      if(endwalks == FALSE)
+        tred = tred+clock()-to;
+      else
+        xtred=clock()-to;
+#endif
+      idDelete(&F1);
+    }
+
+    if(endwalks == TRUE)
+      break;
+
+    NEXT_VECTOR:
+#ifdef TIME_TEST
+    to = clock();
+#endif
+    next_weight = next_weight = MkInterRedNextWeight(curr_weight,target_weight, G);
+#ifdef TIME_TEST
+    tnw = tnw + clock() - to;
+#endif
+
+#ifdef TIME_TEST
+    to = clock();
+#endif
+    // compute an initial form ideal of <G> w.r.t. "next_vector"
+    Gomega = MwalkInitialForm(G, next_weight);
+#ifdef TIME_TEST
+    tif = tif + clock()-to; //time for computing initial form ideal
+#endif
+
+    //lengthpoly(Gomega) = 1 if there is a polynomial in Gomega with at least 3 monomials and 0 otherwise
+    if(lengthpoly(Gomega) > 0)
+    {
+      Print("\n there is a polynomial in Gomega with at least 3 monomials,\n");
+      // low-dimensional facet of the cone
+      delete next_weight;
+      if(target_M->length() == nV)
+      {
+        iv_M = MivMatrixOrder(curr_weight);
+      }
+      else
+      {
+        iv_M = MivMatrixOrderRefine(curr_weight,target_M);
+      }
+#ifdef TIME_TEST
+      to = clock();
+#endif
+      next_weight = MWalkRandomNextWeight(G, iv_M, target_weight, weight_rad, op_deg);
+#ifdef TIME_TEST
+      tnw = tnw + clock() - to;
+#endif
+      idDelete(&Gomega);
+#ifdef TIME_TEST
+      to = clock();
+#endif
+      Gomega = MwalkInitialForm(G, next_weight);
+#ifdef TIME_TEST
+      tif = tif + clock()-to; //time for computing initial form ideal
+#endif
+  Print("delete\n");
+      delete iv_M;
+    }
+
+/*
+    to=clock();
+    next_weight = MkInterRedNextWeight(curr_weight,target_weight, G);
+    if(polylength > 0)
+    {
+      if(printout > 2)
+      {
+        Print("\n //**Mprwalk: there is a polynomial in Gomega with at least 3 monomials, low-dimensional facet of the cone.\n");
+      }
+      delete next_weight;
+      next_weight = MWalkRandomNextWeight(G, curr_weight, target_weight, weight_rad, op_deg);
+    }
+    tnw=tnw+clock()-to;
+*/
+#ifdef PRINT_VECTORS
+    if(printout > 0)
+    {
+      MivString(curr_weight, target_weight, next_weight);
+    }
+#endif
+
+    if(Overflow_Error == TRUE)
+    {
+      ntwC = 0;
+      //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 = TRUE;
+
+    for(i=nV-1; i>=0; i--)
+      (*curr_weight)[i] = (*next_weight)[i];
+
+    delete next_weight;
+  }// end of while-loop
+
+  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);
+
+    // 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 && printout > 2)
+      {
+#ifdef PRINT_VECTORS
+        ivString(pert_target_vector, "tau");
+#endif
+        PrintS("\n// **Mprwalk: 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
+#ifdef TIME_TEST
+      to=clock();
+#endif
+      ideal eF1;
+      if(nP == 0 || tp_deg == 1 || MivSame(orig_target, exivlp) != 1 || target_M->length() != nV)
+      {
+        if(printout > 2)
+        {
+          PrintS("\n// ** Mprwalk: Call \"std\" to compute a Groebner basis.\n");
+        }
+        eF1 = MstdCC(F1);
+        idDelete(&F1);
+      }
+      else
+      {
+        if(printout > 2)
+        {
+          PrintS("\n// **Mprwalk: Call \"LastGB\" to compute a Groebner basis.\n");
+        }
+        rChangeCurrRing(newRing);
+        ideal F2 = idrMoveR(F1, TargetRing,currRing);
+        eF1 = LastGB(F2, curr_weight, tp_deg-1);
+        F2=NULL;
+      }
+#ifdef TIME_TEST
+      xtextra=clock()-to;
+#endif
+      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);
 }
@@ -6110 +7125 @@
  * 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 reduction, int printout)
 {
   Overflow_Error =  FALSE;
-  //Print("\n\n// Entering the %d-th recursion:", nlev);
-
+  if(printout >0)
+  {
+    Print("\n\n// Entering the %d-th recursion:", nlev);
+  }
   int i, nV = currRing->N;
   ring new_ring, testring;
   //ring extoRing;
-  ideal Gomega, Gomega1, Gomega2, F, F1, Gresult, Gresult1, G1, Gt;
+  ideal Gomega, Gomega1, Gomega2, FF, F, F1, Gresult, Gresult1, G1, Gt;
   int nwalks = 0;
   intvec* Mwlp;
@@ -6124 +7142 @@
   intvec* hilb_func;
 #endif
-//  intvec* extXtau;
+  //intvec* extXtau;
   intvec* next_vect;
   intvec* omega2 = new intvec(nV);
-  intvec* altomega = 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;
 
@@ -6168 +7191 @@
     nwalks ++;
     NEXT_VECTOR_FRACTAL:
+#ifdef TIME_TEST
     to=clock();
-    /* determine the next border */
+#endif
+    // determine the next border
     next_vect = MkInterRedNextWeight(omega,omega2,G);
+#ifdef TIME_TEST
     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");
+      if (MivComp(next_vect, omega2) == 1)
+      {
+        // 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);
@@ -6215 +7256 @@
 
         delete next_vect;
+#ifdef TIME_TEST
         to=clock();
-
-        /* to avoid the value of Overflow_Error that occur in Mfpertvector*/
+#endif
+        // to avoid the value of Overflow_Error that occur in Mfpertvector
         Overflow_Error = FALSE;
-
         next_vect = MkInterRedNextWeight(omega,omega2,G);
+#ifdef TIME_TEST
         xtnw=xtnw+clock()-to;
+#endif
+      }// end of (if MivComp(next_vect, omega2) == 1)
 
 #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
-       computed by Buchberger algorithm and stop this recursion step*/
-    //if(test_w_in_ConeCC(G, next_vect) != 1) //e.g. Example s7, cyc6
-    if(Overflow_Error == TRUE)
+      }
+#endif
+
+    // check whether the the computed vector is in the correct cone.
+    // If no, compute the reduced Groebner basis of an omega-homogeneous
+    // ideal with Buchberger's algorithm and stop this recursion step
+    if(Overflow_Error == TRUE || 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
@@ -6248 +7295 @@
       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));
+      }
+#ifdef TIME_TEST
       to=clock();
+#endif
       Gt = idrMoveR(G, oRing,currRing);
       G1 = MstdCC(Gt);
+#ifdef TIME_TEST