Changeset bbfc4a8 in git

Timestamp:

Jul 2, 2015, 7:32:53 PM (9 years ago)

Author:

Stephan Oberfranz <oberfran@…>

Branches:

(u'spielwiese', '4a9821a93ffdc22a6696668bd4f6b8c9de3e6c5f')

Children:

8d7ca03d4444afafa6c2111db95d65216b93ad46

Parents:

500e4b69e2df574c6ae8023f32cbdfbdbd0d5e8ef34cd445520f5220554ca71a6324d2a0ecd2c7f6

Message:

update

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

Files:

• Singular/LIB/grwalk.lib (modified) (10 diffs)
• Singular/LIB/modwalk.lib (modified) (1 diff, 1 prop)
• Singular/LIB/rwalk.lib (modified) (11 diffs, 1 prop)
• Singular/LIB/swalk.lib (modified) (1 prop)
• Singular/extra.cc (modified) (11 diffs)
• Singular/maps_ip.cc (modified) (3 diffs)
• Singular/walk.cc (modified) (137 diffs, 1 prop)
• Singular/walk.h (modified) (1 diff, 1 prop)
• Tst/Short/bug_tr723.res.gz.uu (added)
• Tst/Short/bug_tr723.stat (added)
• Tst/Short/bug_tr723.tst (added)
• Tst/Short/ok_s.lst (modified) (1 diff)
• libpolys/coeffs/numbers.cc (modified) (1 diff)
• libpolys/coeffs/rintegers.cc (modified) (1 diff)
• libpolys/polys/ext_fields/transext.cc (modified) (10 diffs)
• libpolys/polys/monomials/p_polys.cc (modified) (12 diffs)
• libpolys/polys/polys0.cc (modified) (1 diff)

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/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/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/maps_ip.cc

@@ -83 +83 @@
       {
         assume( nMap != NULL );
-
         number a = nMap((number)data, preimage_r->cf, currRing->cf);
         if (nCoeff_is_Extension(currRing->cf))
@@ -146 +145 @@
         }
       }
-      else
-      if ( (what==IMAP_CMD) || /*(*/ (what==FETCH_CMD) /*)*/) /* && (nMap!=nCopy)*/
+      else if ((what==IMAP_CMD) || (what==FETCH_CMD))
       {
         for (i=R*C-1;i>=0;i--)
@@ -156 +154 @@
         }
       }
-      else /* if(what==MAP_CMD) */
-      {
+      else /* (what==MAP_CMD) */
+      {
+        assume(what==MAP_CMD);
         matrix s=mpNew(N,maMaxDeg_Ma((ideal)data,preimage_r));
         for (i=R*C-1;i>=0;i--)

Singular/walk.cc

@@ -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
+#define MSTDCC_FRACTAL // apply Buchberger alg to compute a red GB, if
 //                          tau doesn't stay in the correct cone
 
@@ -42 +42 @@
 #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>
@@ -429 +431 @@
 #endif
 
-#ifdef CHECK_IDEAL_MWALK
+//#ifdef CHECK_IDEAL_MWALK
 static void idString(ideal L, const char* st)
 {
@@ -441 +443 @@
   Print(" %s;", pString(L->m[nL-1]));
 }
-#endif
+//#endif
 
 #if defined(CHECK_IDEAL_MWALK) || defined(ENDWALKS)
@@ -511 +513 @@
 
 //unused
-#if 0
+//#if 0
 static void MivString(intvec* iva, intvec* ivb, intvec* ivc)
 {
@@ -534 +536 @@
   Print("%d)", (*ivc)[nV]);
 }
-#endif
+//#endif
 
 /********************************************************************
@@ -558 +560 @@
   }
   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 +806 @@
   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 +986 @@
 }
 
-/*****************************************************************************
-* 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 +999 @@
   {
     (*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;
@@ -1612 +1647 @@
     (* result)[i] = mpz_get_si(pert_vector[i]);
   }
-
+/*
   j = 0;
-  for(i=0; i<nV; i++)
+  for(i=0; i<niv; i++)
   {
     (* result1)[i] = mpz_get_si(pert_vector[i]);
@@ -1624 +1659 @@
     }
   }
-  if(j > nV - 1)
+  if(j > niv - 1)
   {
     // Print("\n//  MfPertwalk: geaenderter vector gleich Null! \n");
@@ -1630 +1665 @@
     goto CHECK_OVERFLOW;
   }
-
+/*
 // check that the perturbed weight vector lies in the Groebner cone
+  Print("\n========================================\n//** MfPertvector: test in Cone.\n");
   if(test_w_in_ConeCC(G,result1) != 0)
   {
@@ -1647 +1683 @@
     // Print("\n// Mfpertwalk: geaenderter vector liegt nicht in Groebnerkegel! \n");
   }
-
+  Print("\n ========================================\n");*/
   CHECK_OVERFLOW:
 
@@ -1859 +1895 @@
 }
 
+
+/**************************************************************
+ * 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 *
@@ -1873 +1929 @@
 
   int nRing = currRing->N;
-  int checkRed, j, kkk, nG = IDELEMS(G);
+  int checkRed, j, nG = IDELEMS(G);
   intvec* ivtemp;
 
@@ -1911 +1967 @@
   mpz_init(dcw);
 
-  //int tn0, tn1, tz1, ncmp, gcd_tmp, ntmp;
   int gcd_tmp;
   intvec* diff_weight = MivSub(target_weight, curr_weight);
@@ -1917 +1972 @@
   intvec* diff_weight1 = MivSub(target_weight, curr_weight);
   poly g;
-  //poly g, gw;
+
   for (j=0; j<nG; j++)
   {
@@ -1934 +1989 @@
         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 +2032 @@
     }
   }
-//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)
   {
@@ -2054 +2108 @@
 #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 +2157 @@
     }
   }
-
+  // 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 +2170 @@
 #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++)
     {
@@ -2129 +2185 @@
 
   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 +2255 @@
    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)
     {
@@ -2271 +2302 @@
 }
 
-/**************************************************************
+/********************************************************************
  * 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 +2382 @@
   rChangeCurrRing(r);
 }
-#endif
+
 
 /**************************************************************
@@ -2428 +2457 @@
 }
 
-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 +2533 @@
 
   // complete ring intializations
-
+  
   rComplete(r);
 
@@ -2806 +2763 @@
 }
 
-
-/* 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 +2914 @@
 }
 
-//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 +2929 @@
   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;
+  //PrintS("\n//** idCopy\n");
+  ideal Go = idCopy(G);
+  
+  //PrintS("\n//** jetzt for-Loop!\n");
+
+  // check whether leading monomials of G and Gomega coincide
+  // and return NULL if not
+  for(i=0; i<N; i++)
+  {
+    p = pCopy(Gomega->m[i]);
+    lm = pCopy(pHead(G->m[i]));
+    if(!pIsConstant(pSub(p,lm)))
+    {
+      //pDelete(&p);
+      //pDelete(&lm);
+      idDelete(&Go);
+      return NULL; 
+    }
+    //pDelete(&p);
+    //pDelete(&lm);
+  }
+  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);
+      }
+    }
+  }
+  
+  //PrintS("\n//** jetzt Delete!\n");
+  //pDelete(&p);
+  //pDelete(&factor);
+  //pDelete(&lm);
+  if(middle == TRUE)
+  {
+    //PrintS("\n//** middle TRUE!\n");
+    return Go;
+  }
+  //PrintS("\n//** middle FALSE!\n");
+  idDelete(&Go);
+  return NULL; 
+}
 
 /******************************  Februar 2002  ****************************
@@ -3128 +3175 @@
     else
     {
-      rChangeCurrRing(VMrDefault(curr_weight)); //Aenderung
+      rChangeCurrRing(VMrDefault(curr_weight));
     }
     newRing = currRing;
@@ -3280 +3327 @@
   }
   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;
 }
 
@@ -3884 +3948 @@
     else
     {
-      rChangeCurrRing(VMrDefault(curr_weight)); //Aenderung
+      rChangeCurrRing(VMrDefault(curr_weight));
     }
     newRing = currRing;
@@ -4145 +4209 @@
     else
     {
-      rChangeCurrRing(VMrDefault(curr_weight)); // Aenderung
+      rChangeCurrRing(VMrDefault(curr_weight));
     }
     newRing = currRing;
@@ -4287 +4351 @@
 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* curr_weight,
+               intvec* target_weight, int weight_rad, int pert_deg)
 {
-  int i, weight_norm;
-  int nV = currRing->N;
-  intvec* next_weight2;
+  assume(currRing != NULL && curr_weight != NULL &&
+         target_weight != NULL && G->m[0] != NULL);
+
+  intvec* next_weight1 = MkInterRedNextWeight(curr_weight,target_weight,G);
+  if(weight_rad == 0)
+  {
+    return(next_weight1);
+  }
+
+  int i,weight_norm,nV = currRing->N;
+  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);
+
+  ideal G_test, G_test2;
+
+  //compute a random next weight vector "next_weight2"
+  while(1)
+  {
+    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)
+    {
+      PrintS("\n Hier 1\n");
+      G_test2 = MwalkInitialForm(G, next_weight2);
+      PrintS("\n Hier 2\n");
+      if(maxlengthpoly(G_test2) <= 1)
+      {
+        next_weight2 = MkInterRedNextWeight(next_weight2,target_weight,G);
+      }
+      idDelete(&G_test2);
+
+      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);
         }
-        else
-        {
-          (*next_weight22)[i] = (*curr_weight)[i] + floor(weight_rad*(*next_weight22)[i]/weight_norm);
-        }
-      //Print("\n//  next_weight22[%d]  = %d", i, (*next_weight22)[i]);
-      }
-
-      if(test_w_in_ConeCC(G, next_weight22) == 1)
-      {
-        //Print("\n//MWalkRandomNextWeight: next_weight2 im Kegel\n");
-        next_weight2 = MkInterRedNextWeight(next_weight22, target_weight, G);
         delete next_weight22;
-        break;
-      }
-    }
-    intvec* result = new intvec(nV);
-    ideal G_test = MwalkInitialForm(G, next_weight);
+      }
+      break;
+    }
+    weight_rad++;
+  }
+  
+  // compute "usual" next weight vector
+  intvec* next_weight = MwalkNextWeightCC(curr_weight,target_weight, G);
+  G_test = MwalkInitialForm(G, next_weight);
+  G_test2 = MwalkInitialForm(G, next_weight2);
+
+  // compare next weights
+  if(Overflow_Error == FALSE)
+  {
     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|
+    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++)
@@ -4359 +4451 @@
         }
       }
-      else // |G_test1| < |G_test|, |G_test1| < |G_test2|
+      else
       {
         for(i=0; i<nV; i++)
@@ -4365 +4457 @@
           (*result)[i] = (*next_weight1)[i];
         }
-      }
+      }    
     }
     else
     {
-      if(IDELEMS(G_test2) <= IDELEMS(G_test)) // |G_test2| <= |G_test| <= |G_test1|
+      if(G_test2->m[0] != NULL && maxlengthpoly(G_test2) < maxlengthpoly(G_test))
       {
         for(i=0; i<nV; i++)
@@ -4376 +4468 @@
         }
       }
-      else // |G_test| <= |G_test1|, |G_test| < |G_test2|
+      else
       {
         for(i=0; i<nV; i++)
@@ -4384 +4476 @@
       }
     }
-    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
+  {
+    Overflow_Error = FALSE;
+    if(G_test2->m[0] != NULL && maxlengthpoly(G_test2) < maxlengthpoly(G_test))
+    {
+      for(i=1; i<nV; i++)
+      {
+        (*result)[i] = (*next_weight2)[i];
+      }
     }
     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++)
-        {
-          (*result)[i] = (*next_weight2)[i];
-        }
-      }
-      else
-      {
-        // |G_test1| < |G_test|, |G_test1| <= |G_test2|
-        for(i=0; i<nV; i++)
-        {
-          (*result)[i] = (*next_weight1)[i];
-        }
-      }
-    }
-    else
-    {
-      if(IDELEMS(G_test2) < IDELEMS(G_test)) // |G_test2| < |G_test| <= |G_test1|
-      {
-        for(i=0; i<nV; i++)
-        {
-          (*result)[i] = (*next_weight2)[i];
-        }
-      }
-      else
-      {
-        // |G_test| < |G_test1|, |G_test| <= |G_test2|
-        for(i=0; i<nV; i++)
-        {
-          (*result)[i] = (*next_weight)[i];
-        }
-      }
-    }
-    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
-    {
-      for(i=0; i<nV; i++)
-      {
         (*result)[i] = (*next_weight)[i];
       }
     }
   }
+
   idDelete(&G_test);
   idDelete(&G_test2);
@@ -4575 +4557 @@
     else
     {
-      rChangeCurrRing(VMrDefault(orig_target_weight)); // Aenderung
+      rChangeCurrRing(VMrDefault(orig_target_weight));
     }
     TargetRing = currRing;
@@ -4646 +4628 @@
     else
     {
-      rChangeCurrRing(VMrDefault(curr_weight)); // Aenderung
+      rChangeCurrRing(VMrDefault(curr_weight));
     }
     newRing = currRing;
@@ -4755 +4737 @@
     else
     {
-      rChangeCurrRing(VMrDefault(orig_target_weight)); // Aenderung
+      rChangeCurrRing(VMrDefault(orig_target_weight));
     }
     F1 = idrMoveR(G, newRing,currRing);
@@ -4786 +4768 @@
       else
       {
-        rChangeCurrRing(VMrDefault(orig_target_weight)); // Aenderung
+        rChangeCurrRing(VMrDefault(orig_target_weight));
       }
     KSTD_Finish:
@@ -4884 +4866 @@
       tim = clock();
       /*
-        Print("\n// **** Grï¿œbnerwalk took %d steps and ", nwalk);
+        Print("\n// **** Groebnerwalk took %d steps and ", nwalk);
         PrintS("\n// **** call the rec. Pert. Walk to compute a red GB of:");
         idElements(Gomega, "G_omega");
@@ -4914 +4896 @@
       oldRing = currRing;
 
-      /* create a new ring newRing */
+      // create a new ring newRing
        if (rParameter(currRing) != NULL)
        {
@@ -4921 +4903 @@
        else
        {
-         rChangeCurrRing(VMrDefault(curr_weight)); // Aenderung
+         rChangeCurrRing(VMrDefault(curr_weight));
        }
       newRing = currRing;
@@ -4947 +4929 @@
       else
       {
-        rChangeCurrRing(VMrDefault(curr_weight));  //Aenderung
+        rChangeCurrRing(VMrDefault(curr_weight));
       }
       newRing = currRing;
@@ -4959 +4941 @@
       M=kStd(Gomega1,NULL,isHomog,NULL,hilb_func,0,NULL,curr_weight);
       delete hilb_func;
-#endif // BUCHBERGER_ALG
+#endif
       tstd = tstd + clock() - to;
 
@@ -4968 +4950 @@
 
       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 +5002 @@
       else
       {
-        rChangeCurrRing(VMrDefault(target_weight)); // Aenderung
+        rChangeCurrRing(VMrDefault(target_weight));
       }
       F1 = idrMoveR(G, newRing,currRing);
@@ -5065 +5049 @@
  * 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 +5069 @@
 #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++)
   {
@@ -5111 +5103 @@
 #endif
   rComplete(currRing);
-#ifdef CHECK_IDEAL_MWALK
-    idString(Go,"Go");
-#endif
+//#ifdef CHECK_IDEAL_MWALK
+  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));
-  baseRing = currRing;
+
 #ifdef TIME_TEST
   tostd = clock()-to;
 #endif
 
+  baseRing = currRing;
   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"
+    // compute an initial form ideal of <G> w.r.t. "curr_vector"
+    Gomega = MwalkInitialForm(G, curr_weight);
 #ifdef TIME_TEST
-    tif = tif + clock()-to; //time for computing initial form ideal
-#endif
-#ifdef CHECK_IDEAL_MWALK
-    idString(Gomega,"Gomega");
-#endif
+    tif = tif + clock()-to;
+#endif
+
+//#ifdef CHECK_IDEAL_MWALK
+    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 +5186 @@
     }
 #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 +5203 @@
      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);
      }
@@ -5199 +5229 @@
 #endif
     idSkipZeroes(M);
-#ifdef CHECK_IDEAL_MWALK
-    PrintS("\n//** Mwalk: computed M.\n");
-    idString(M, "M");
-#endif
+//#ifdef CHECK_IDEAL_MWALK
+    if(printout > 2)
+    {
+      idString(M, "//** Mwalk: M");
+    }
+//#endif
     //change the ring to baseRing
     rChangeCurrRing(baseRing);
@@ -5212 +5244 @@
     to = clock();
 #endif
-    // compute a representation of the generators of submod (M) with respect to those of mod (Gomega), where Gomega is a reduced Groebner basis w.r.t. the current ring
+    // compute a representation of the generators of submod (M) with respect to those of mod (Gomega),
+    // where Gomega is a reduced Groebner basis w.r.t. the current ring
     F = MLifttwoIdeal(Gomega2, M1, G);
+
 #ifdef TIME_TEST
     tlift = tlift + clock() - to;
 #endif
-#ifdef CHECK_IDEAL_MWALK
-    idString(F, "F");
-#endif
+//#ifdef CHECK_IDEAL_MWALK
+    if(printout > 2)
+    {
+      idString(F, "//** Mwalk: F");
+    }
+//#endif
     idDelete(&Gomega2);
     idDelete(&M1);
+
     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;
+
+/*
 #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
+    NEXT_VECTOR:
     intvec* 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
+//#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)
@@ -5264 +5332 @@
       Gomega1 = idrMoveR(Gomega, baseRing,currRing);
       idDelete(&Gomega);
-#ifdef CHECK_IDEAL_MWALK
-      idString(Gomega1, "Gomega");
-#endif
+//#ifdef CHECK_IDEAL_MWALK
+      if(printout > 1)
+      {
+        idString(Gomega1, "//** Mwalk: Gomega");
+      }
+      PrintS("\n //** Mwalk: kStd(Gomega)");
+//#endif
       M = kStd(Gomega1,NULL,testHomog,NULL,NULL,0,0,NULL);
-#ifdef CHECK_IDEAL_MWALK
-      idString(M,"M");
-#endif
+//#ifdef CHECK_IDEAL_MWALK
+      if(printout > 1)
+      {
+        idString(M,"//** Mwalk: M");
+      }
+//#endif
       rChangeCurrRing(baseRing);
       M1 =  idrMoveR(M, newRing,currRing);
@@ -5276 +5351 @@
       Gomega2 = idrMoveR(Gomega1, newRing,currRing);
       idDelete(&Gomega1);
+      //PrintS("\n //** Mwalk: MLifttwoIdeal");
       F = MLifttwoIdeal(Gomega2, M1, G);
-#ifdef CHECK_IDEAL_MWALK
-      idString(F,"F");
-#endif
+//#ifdef CHECK_IDEAL_MWALK
+      if(printout > 2)
+      {
+        idString(F,"//** Mwalk: F");
+      }
+//#endif
       idDelete(&Gomega2);
       idDelete(&M1);
@@ -5291 +5370 @@
       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
-  //    }
+      //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;
+      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];
+      //(*tmp_weight)[i] = (*curr_weight)[i];
       (*curr_weight)[i] = (*next_weight)[i];
     }
@@ -5317 +5390 @@
   rChangeCurrRing(XXRing);
   ideal result = idrMoveR(G,baseRing,currRing);
+  idDelete(&Go);
   idDelete(&G);
-/*#ifdef CHECK_IDEAL_MWALK
-  pDelete(&p);
-#endif*/
-  delete tmp_weight;
+  //delete tmp_weight;
   delete ivNull;
   delete exivlp;
@@ -5328 +5399 @@
 #endif
 #ifdef TIME_TEST
-  Print("\n//** Mwalk: Groebner Walk took %d steps.\n", nstep);
   TimeString(tinput, tostd, tif, tstd, tlift, tred, tnw, nstep);
-  Print("\n//** Mwalk: Ergebnis.\n");
   //Print("\n// pSetm_Error = (%d)", ErrorCheck());
   //Print("\n// Overflow_Error? (%d)\n", Overflow_Error);
 #endif
+  Print("\n//** Mwalk: Groebner Walk took %d steps.\n", nstep);
   return(result);
 }
 
-// 07.11.2012
-// THE RANDOM WALK ALGORITHM  ideal Go, intvec* orig_M, intvec* target_M, ring baseRing
-ideal Mrwalk(ideal Go, intvec* orig_M, intvec* target_M, int weight_rad, int pert_deg, ring baseRing)
+// THE RANDOM WALK ALGORITHM
+ideal Mrwalk(ideal Go, intvec* orig_M, intvec* target_M, int weight_rad, int pert_deg,
+             int reduction, int printout)
 {
   BITSET save1 = si_opt_1; // save current options
-  //si_opt_1 &= (~Sy_bit(OPT_REDSB)); // no reduced Groebner basis
-  //si_opt_1 &= (~Sy_bit(OPT_REDTAIL)); // not tail reductions
-  //si_opt_1|=(Sy_bit(OPT_REDTAIL)|Sy_bit(OPT_REDSB));
+  if(reduction == 0)
+  {
+    si_opt_1 &= (~Sy_bit(OPT_REDSB)); // no reduced Groebner basis
+    si_opt_1 &= (~Sy_bit(OPT_REDTAIL)); // not tail reductions
+  }
   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;
@@ -5354 +5427 @@
 #endif
   nstep=0;
-  int i,nwalk,endwalks = 0;
-  int nV = baseRing->N;
-
-  ideal Gomega, M, F, Gomega1, Gomega2, M1; //, F1;
+  int i,polylength,nwalk;
+  int nV = currRing->N;
+
+  ideal Gomega, M, F,FF, Gomega1, Gomega2, M1;
   ring newRing;
-  ring XXRing = baseRing;
+  ring targetRing;
+  ring baseRing = currRing;
+  ring XXRing = currRing;
   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];
-  }
+  intvec* next_weight= new intvec(nV);
+
   for(i=0; i<nV; i++)
   {
@@ -5385 +5456 @@
 #endif
   rComplete(currRing);
-#ifdef CHECK_IDEAL_MWALK
-    idString(Go,"Go");
-#endif
 #ifdef TIME_TEST
   to = clock();
 #endif
-     if(orig_M->length() == nV)
-      {
-        newRing = VMrDefault(curr_weight); // define a new ring with ordering "(a(curr_weight),lp)
-      }
-      else
-      {
-        newRing = VMatrDefault(orig_M);
-      }
+
+  if(target_M->length() == nV)
+  {
+   // define the target ring
+    targetRing = VMrDefault(target_weight);
+  }
+  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);
   ideal G = MstdCC(idrMoveR(Go,baseRing,currRing));
@@ -5407 +5485 @@
 
   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 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
+    if(printout > 1)
+    {
+      idString(Gomega,"//** Mrwalk: Gomega");
+    }
+    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
     {
@@ -5449 +5539 @@
      if(target_M->length() == nV)
      {
-       newRing = VMrRefine(curr_weight,target_weight); //define a new ring with ordering "(a(curr_weight),Wp(target_weight))"
+       newRing = VMrDefault(curr_weight); // define a new ring with ordering "(a(curr_weight),lp)
      }
      else
@@ -5473 +5563 @@
 #endif
     idSkipZeroes(M);
-#ifdef CHECK_IDEAL_MWALK
-    PrintS("\n//** Mwalk: computed M.\n");
-    idString(M, "M");
-#endif
+//#ifdef CHECK_IDEAL_MWALK
+    if(printout > 2)
+    {
+      idString(M, "//** Mrwalk: M");
+    }
+//#endif
     //change the ring to baseRing
     rChangeCurrRing(baseRing);
@@ -5486 +5578 @@
     to = clock();
 #endif
-    // compute a representation of the generators of submod (M) with respect to those of mod (Gomega), where Gomega is a reduced Groebner basis w.r.t. the current ring
+    // compute a representation of the generators of submod (M) with respect to those of mod (Gomega),
+    // where Gomega is a reduced Groebner basis w.r.t. the current ring
     F = MLifttwoIdeal(Gomega2, M1, G);
 #ifdef TIME_TEST
     tlift = tlift + clock() - to;
 #endif
-#ifdef CHECK_IDEAL_MWALK
-    idString(F, "F");
-#endif
+//#ifdef CHECK_IDEAL_MWALK
+    if(printout > 2)
+    {
+      idString(F, "//** Mrwalk: F");
+    }
+//#endif
     idDelete(&Gomega2);
     idDelete(&M1);
@@ -5502 +5598 @@
 #ifdef TIME_TEST
     to = clock();
-#endif
-    //G = kStd(F1,NULL,testHomog,NULL,NULL,0,0,NULL);
-#ifdef TIME_TEST
     tstd = tstd + clock() - to;
 #endif
     idSkipZeroes(G);
-#ifdef CHECK_IDEAL_MWALK
-    idString(G, "G");
-#endif
+//#ifdef CHECK_IDEAL_MWALK
+    if(printout > 2)
+    {
+      idString(G, "//** Mrwalk: G");
+    }
+//#endif
+
+    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 = MWalkRandomNextWeight(G, curr_weight, target_weight, weight_rad, pert_deg);//next_weight = MwalkNextWeightCC(curr_weight,target_weight,G);
+    next_weight = MwalkNextWeightCC(curr_weight,target_weight,G);
 #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);
+
+#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
+
+    //polylength = 1 if there is a polynomial in Gomega with at least 3 monomials and 0 otherwise
+    polylength = lengthpoly(Gomega);
+    if(polylength > 0)
+    {
+      //there is a polynomial in Gomega with at least 3 monomials,
+      //low-dimensional facet of the cone
+      delete next_weight;
+#ifdef TIME_TEST
+    to = clock();
+#endif
+      next_weight = MWalkRandomNextWeight(G, curr_weight, 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
+    }
+
+    // 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;
+  si_opt_1 = save1; //set original options, e. g. option(RedSB)
   delete ivNull;
-  delete exivlp;
 #ifndef BUCHBERGER_ALG
   delete last_omega;
 #endif
+  Print("\n//** Mrwalk: Groebner Walk took %d steps.\n", nstep);
 #ifdef TIME_TEST
-  Print("\n//** Mwalk: Groebner Walk took %d steps.\n", nstep);
   TimeString(tinput, tostd, tif, tstd, tlift, tred, tnw, nstep);
-  Print("\n//** Mwalk: Ergebnis.\n");
   //Print("\n// pSetm_Error = (%d)", ErrorCheck());
   //Print("\n// Overflow_Error? (%d)\n", Overflow_Error);
@@ -5751 +5842 @@
 // use kStd, if nP = 0, else call LastGB
 ideal Mpwalk(ideal Go, int op_deg, int tp_deg,intvec* curr_weight,
-             intvec* target_weight, int nP)
+             intvec* target_weight, int nP, int reduction, int printout)
 {
+  BITSET save1 = si_opt_1; // save current options
+  if(reduction == 0)
+  {
+    si_opt_1 &= (~Sy_bit(OPT_REDSB)); // no reduced Groebner basis
+    //si_opt_1 &= (~Sy_bit(OPT_REDTAIL)); // not tail reductions
+    //si_opt_1|=(Sy_bit(OPT_REDTAIL)|Sy_bit(OPT_REDSB));
+  }
   Set_Error(FALSE  );
   Overflow_Error = FALSE;
@@ -5766 +5864 @@
   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;
+  BOOLEAN endwalks = FALSE;
+
+  ideal Gomega, M, F, FF, G, Gomega1, Gomega2, M1,F1,Eresult,ssG;
   ring newRing, oldRing, TargetRing;
   intvec* iv_M_dp;
@@ -5790 +5888 @@
   ring XXRing = currRing;
 
-
   to = clock();
-  /* perturbs the original vector */
+  // perturbs the original vector
   if(MivComp(curr_weight, iv_dp) == 1) //rOrdStr(currRing) := "dp"
   {
@@ -5809 +5906 @@
       DefRingPar(curr_weight);
     else
-      rChangeCurrRing(VMrDefault(curr_weight)); //Aenderung 1
+      rChangeCurrRing(VMrDefault(curr_weight));
 
     G = idrMoveR(Go, XXRing,currRing);
@@ -5824 +5921 @@
   ring HelpRing = currRing;
 
-  /* perturbs the target weight vector */
+  // perturbs the target weight vector
   if(tp_deg > 1 && tp_deg <= nV)
   {
@@ -5830 +5927 @@
       DefRingPar(target_weight);
     else
-      rChangeCurrRing(VMrDefault(target_weight)); // Aenderung 2
+      rChangeCurrRing(VMrDefault(target_weight));
 
     TargetRing = currRing;
@@ -5837 +5934 @@
     {
       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 +5939 @@
     {
       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 +5946 @@
     G = idrMoveR(ssG, TargetRing,currRing);
   }
-  /*
-    Print("\n// Perturbationwalkalg. vom Gradpaar (%d,%d):",op_deg,tp_deg);
-    ivString(curr_weight, "new sigma");
-    ivString(target_weight, "new tau");
-  */
+    if(printout > 0)
+    {
+      Print("\n//** Mpwalk: Perturbation Walk of degree (%d,%d):",op_deg,tp_deg);
+      ivString(curr_weight, "//** Mpwalk: new current weight");
+      ivString(target_weight, "//** Mpwalk: new target weight");
+    }
   while(1)
   {
     nstep ++;
     to = clock();
-    /* compute an initial form ideal of <G> w.r.t. the weight vector
-       "curr_weight" */
+    // compute an initial form ideal of <G> w.r.t. the weight vector
+    // "curr_weight"
     Gomega = MwalkInitialForm(G, curr_weight);
-
+//#ifdef CHECK_IDEAL_MWALK
+    if(printout > 1)
+    {
+      idString(Gomega,"//** 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);
+          if(printout > 0)
+          {
+            MivString(curr_weight, target_weight, next_weight);
+          }
+        }
+        else
+        {
+          break;
+        }
+        for(i=nV-1; i>=0; i--)
+        {
+          (*curr_weight)[i] = (*next_weight)[i];
+        }
+        Gomega = MwalkInitialForm(G, curr_weight);
+        if(printout > 1)
+        {
+          idString(Gomega,"//** Mpwalk: Gomega");
+        }
+      }
+*/
+      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
@@ -5891 +6032 @@
       DefRingPar(curr_weight);
     else
-      rChangeCurrRing(VMrDefault(curr_weight)); //Aenderung 3
+      rChangeCurrRing(VMrDefault(curr_weight));
 
     newRing = currRing;
@@ -5897 +6038 @@
 
 #ifdef ENDWALKS
-    if(endwalks==1)
+    if(endwalks==TRUE)
     {
       Print("\n// ring r%d = %s;\n", nstep, rString(currRing));
@@ -5912 +6053 @@
     tim = clock();
     to = clock();
-    /* compute a reduced Groebner basis of <Gomega> w.r.t. "newRing" */
+    // compute a reduced Groebner basis of <Gomega> w.r.t. "newRing"
 #ifdef  BUCHBERGER_ALG
     M = MstdhomCC(Gomega1);
@@ -5918 +6059 @@
     M=kStd(Gomega1,NULL,isHomog,NULL,hilb_func,0,NULL,curr_weight);
     delete hilb_func;
-#endif // BUCHBERGER_ALG
-
-    if(endwalks == 1){
+#endif
+//#ifdef CHECK_IDEAL_MWALK
+      if(printout > 2)
+      {
+        idString(M,"//** Mpwalk: M");
+      }
+//#endif
+
+    if(endwalks == TRUE){
       xtstd = xtstd+clock()-to;
 #ifdef ENDWALKS
@@ -5930 +6077 @@
       tstd=tstd+clock()-to;
 
-    /* change the ring to oldRing */
+    // 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:..");
 
     to=clock();
@@ -5942 +6087 @@
        Gomega is a reduced Groebner basis w.r.t. the current ring */
     F = MLifttwoIdeal(Gomega2, M1, G);
-    if(endwalks != 1)
+    if(endwalks == FALSE)
       tlift = tlift+clock()-to;
     else
       xtlift=clock()-to;
 
+//#ifdef CHECK_IDEAL_MWALK
+    if(printout > 2)
+    {
+      idString(F,"//** Mpwalk: F");
+    }
+//#endif
+
     idDelete(&M1);
     idDelete(&Gomega2);
     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");
+      }
+      to=clock();
+      G = kInterRedCC(F1, NULL);
+      if(endwalks == FALSE)
+        tred = tred+clock()-to;
+      else
+        xtred=clock()-to;
+      idDelete(&F1);
+    }
+    if(endwalks == TRUE)
+      break;
+
+    NEXT_VECTOR:
     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 */
+    // compute a next weight vector
     next_weight = MkInterRedNextWeight(curr_weight,target_weight, G);
     tnw=tnw+clock()-to;
-#ifdef PRINT_VECTORS
-    MivString(curr_weight, target_weight, next_weight);
-#endif
+//#ifdef PRINT_VECTORS
+    if(printout > 0)
+    {
+      MivString(curr_weight, target_weight, next_weight);
+    }
+//#endif
 
     if(Overflow_Error == TRUE)
@@ -5994 +6155 @@
     }
     if(MivComp(next_weight, target_weight) == 1)
-      endwalks = 1;
+      endwalks = TRUE;
 
     for(i=nV-1; i>=0; i--)
@@ -6000 +6161 @@
 
     delete next_weight;
-  }//while
+  }//end of while-loop
 
   if(tp_deg != 1)
@@ -6014 +6175 @@
         DefRingPar(orig_target);
       else
-        rChangeCurrRing(VMrDefault(orig_target)); //Aenderung
+        rChangeCurrRing(VMrDefault(orig_target));
 
     TargetRing=currRing;
@@ -6030 +6191 @@
     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 +6228 @@
     Eresult = idrMoveR(G, newRing,currRing);
   }
+  si_opt_1 = save1; //set original options, e. g. option(RedSB)
   delete ivNull;
   if(tp_deg != 1)
@@ -6082 +6243 @@
              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());
+
+  clock_t  tinput, tostd, tif=0, tstd=0, tlift=0, tred=0, tnw=0;
+  xtextra=0;
+  xtif=0; xtstd=0; xtlift=0; xtred=0; xtnw=0;
+  tinput = clock();
+
+  clock_t tim;
+
+  nstep = 0;
+  int i, ntwC=1, ntestw=1, polylength, nV = currRing->N;
+  BOOLEAN endwalks = FALSE;
+
+  ideal Gomega, M, F, FF, G, Gomega1, Gomega2, M1,F1,Eresult,ssG;
+  ring newRing, oldRing, TargetRing;
+  intvec* iv_M_dp;
+  intvec* iv_M_lp;
+  intvec* exivlp = Mivlp(nV);
+  intvec* curr_weight = new intvec(nV);
+  intvec* target_weight = new intvec(nV);
+  for(i=0; i<nV; i++)
+  {
+    (*curr_weight)[i] = (*orig_M)[i];
+    (*target_weight)[i] = (*target_M)[i];
+  }
+  intvec* orig_target = target_weight;
+  intvec* pert_target_vector = target_weight;
+  intvec* ivNull = new intvec(nV);
+  intvec* iv_dp = MivUnit(nV);// define (1,1,...,1)
+#ifndef BUCHBERGER_ALG
+  intvec* hilb_func;
+#endif
+  intvec* next_weight;
+
+  // to avoid (1,0,...,0) as the target vector
+  intvec* last_omega = new intvec(nV);
+  for(i=nV-1; i>0; i--)
+    (*last_omega)[i] = 1;
+  (*last_omega)[0] = 10000;
+
+  ring XXRing = currRing;
+
+  to = clock();
+  // perturbs the original vector
+  if(orig_M->length() == nV)
+  {
+    if(MivComp(curr_weight, iv_dp) == 1) //rOrdStr(currRing) := "dp"
+    {
+      G = MstdCC(Go);
+      tostd = clock()-to;
+      if(op_deg != 1)
+      {
+        iv_M_dp = MivMatrixOrderdp(nV);
+        curr_weight = MPertVectors(G, iv_M_dp, op_deg);
+      }
+    }
+    else
+    {
+      //define ring order := (a(curr_weight),lp);
+      if (rParameter(currRing) != NULL)
+        DefRingPar(curr_weight);
+      else
+        rChangeCurrRing(VMrDefault(curr_weight));
+
+      G = idrMoveR(Go, XXRing,currRing);
+      G = MstdCC(G);
+      tostd = clock()-to;
+      if(op_deg != 1)
+      {
+        iv_M_dp = MivMatrixOrder(curr_weight);
+        curr_weight = MPertVectors(G, iv_M_dp, op_deg);
+      }
+    }
+  }
+  else
+  {
+    rChangeCurrRing(VMatrDefault(orig_M));
+    G = idrMoveR(Go, XXRing,currRing);
+    G = MstdCC(G);
+    tostd = clock()-to;
+    if(op_deg != 1)
+    {
+      curr_weight = MPertVectors(G, orig_M, op_deg);
+    }
+  }
+
+  delete iv_dp;
+  if(op_deg != 1) delete iv_M_dp;
+
+  ring HelpRing = currRing;
+
+  // perturbs the target weight vector
+  if(target_M->length() == nV)
+  {
+    if(tp_deg > 1 && tp_deg <= nV)
+    {
+      if (rParameter(currRing) != NULL)
+        DefRingPar(target_weight);
+      else
+        rChangeCurrRing(VMrDefault(target_weight));
+
+      TargetRing = currRing;
+      ssG = idrMoveR(G,HelpRing,currRing);
+      if(MivSame(target_weight, exivlp) == 1)
+      {
+        iv_M_lp = MivMatrixOrderlp(nV);
+        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 ++;
+    to = clock();
+    // compute an initial form ideal of G w.r.t. the weight vector "curr_weight"
+/*    Gomega = MwalkInitialForm(G, curr_weight);
+    polylength = lengthpoly(Gomega);
+*/
+//#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);
+          if(printout > 0)
+          {
+            MivString(curr_weight, target_weight, next_weight);
+          }
+        }
+        else
+        {
+          break;
+        }
+        for(i=nV-1; i>=0; i--)
+        {
+          (*curr_weight)[i] = (*next_weight)[i];
+        }
+        Gomega = MwalkInitialForm(G, curr_weight);
+        if(printout > 1)
+        {
+          idString(Gomega,"//** Mprwalk: Gomega");
+        }
+      }
+*/
+      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
+
+    tim = clock();
+    to = clock();
+    // compute a reduced Groebner basis of <Gomega> w.r.t. "newRing"
+#ifdef  BUCHBERGER_ALG
+    M = MstdhomCC(Gomega1);
+#else
+    M=kStd(Gomega1,NULL,isHomog,NULL,hilb_func,0,NULL,curr_weight);
+    delete hilb_func;
+#endif
+//#ifdef CHECK_IDEAL_MWALK
+    if(printout > 2)
+    {
+      idString(M,"//** Mprwalk: M");
+    }
+//#endif
+
+    if(endwalks == 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;
+
+    /* change the ring to oldRing */
+    rChangeCurrRing(oldRing);
+    M1 =  idrMoveR(M, newRing,currRing);
+    Gomega2 =  idrMoveR(Gomega1, newRing,currRing);
+
+    to=clock();
+    /* compute a representation of the generators of submod (M)
+       with respect to those of mod (Gomega).
+       Gomega is a reduced Groebner basis w.r.t. the current ring */
+    F = MLifttwoIdeal(Gomega2, M1, G);
+    if(endwalks == FALSE)
+      tlift = tlift+clock()-to;
+    else
+      xtlift=clock()-to;
+
+//#ifdef CHECK_IDEAL_MWALK
+    if(printout > 2)
+    {
+      idString(F,"//** Mprwalk: F");
+    }
+//#endif
+
+    idDelete(&M1);
+    idDelete(&Gomega2);
+    idDelete(&G);
+
+    // change the ring to newRing
+    rChangeCurrRing(newRing);
+    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");
+      }
+      to=clock();
+      G = kInterRedCC(F1, NULL);
+      if(endwalks == FALSE)
+        tred = tred+clock()-to;
+      else
+        xtred=clock()-to;
+      idDelete(&F1);
+    }
+
+    if(endwalks == TRUE)
+      break;
+
+Print("\n Next weight");
+    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
+    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
+
+    //polylength = 1 if there is a polynomial in Gomega with at least 3 monomials and 0 otherwise
+    polylength = lengthpoly(Gomega);
+    if(polylength > 0)
+    {
+      Print("\n there is a polynomial in Gomega with at least 3 monomials");
+      //low-dimensional facet of the cone
+      delete next_weight;
+#ifdef TIME_TEST
+      to = clock();
+#endif
+      next_weight = MWalkRandomNextWeight(G, curr_weight, 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
+    }
+
+/*
+    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;
+  }//while
+
+  if(tp_deg != 1)
+  {
+    FINISH_160302:
+    if(target_M->length() == nV)
+    {
+      if(MivSame(orig_target, exivlp) == 1)
+        if (rParameter(currRing) != NULL)
+          DefRingParlp();
+        else
+          VMrDefaultlp();
+      else
+        if (rParameter(currRing) != NULL)
+          DefRingPar(orig_target);
+        else
+          rChangeCurrRing(VMrDefault(orig_target));
+    }
+    else
+    {
+      rChangeCurrRing(VMatrDefault(target_M));
+    }
+    TargetRing=currRing;
+    F1 = idrMoveR(G, newRing,currRing);
+#ifdef CHECK_IDEAL
+      headidString(G, "G");
+#endif
+
+    // check whether the pertubed target vector stays in the correct cone
+    if(ntwC != 0)
+    {
+      ntestw = test_w_in_ConeCC(F1, pert_target_vector);
+    }
+    if(ntestw != 1 || ntwC == 0)
+    {
+      if(ntestw != 1 && printout > 2)
+      {
+        ivString(pert_target_vector, "tau");
+        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
+      to=clock();
+      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;
+      }
+      xtextra=clock()-to;
+      ring exTargetRing = currRing;
+
+      rChangeCurrRing(XXRing);
+      Eresult = idrMoveR(eF1, exTargetRing,currRing);
+    }
+    else
+    {
+      rChangeCurrRing(XXRing);
+      Eresult = idrMoveR(F1, TargetRing,currRing);
+    }
+  }
+  else
+  {
+    rChangeCurrRing(XXRing);
+    Eresult = idrMoveR(G, newRing,currRing);
+  }
+  si_opt_1 = save1; //set original options, e. g. option(RedSB)
+  delete ivNull;
+  if(tp_deg != 1)
+    delete target_weight;
+
+  if(op_deg != 1 )
+    delete curr_weight;
+
+  delete exivlp;
+  delete last_omega;
+
+#ifdef TIME_TEST
+  TimeStringFractal(tinput, tostd, tif+xtif, tstd+xtstd,0, tlift+xtlift, tred+xtred,
+             tnw+xtnw);
+
+  //Print("\n// pSetm_Error = (%d)", ErrorCheck());
+  //Print("\n// It took %d steps and Overflow_Error? (%d)\n", nstep,  Overflow_Error);
+#endif
+  Print("\n//** Mprwalk: Perturbation Walk took %d steps.\n", nstep);
   return(Eresult);
 }
@@ -6110 +6800 @@
  * 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;
@@ -6127 +6820 @@
   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;
 
@@ -6169 +6867 @@
     NEXT_VECTOR_FRACTAL:
     to=clock();
-    /* determine the next border */
+    // determine the next border
     next_vect = MkInterRedNextWeight(omega,omega2,G);
     xtnw=xtnw+clock()-to;
-#ifdef PRINT_VECTORS
-    MivString(omega, omega2, next_vect);
-#endif
+
     oRing = currRing;
 
-    /* We only perturb the current target vector at the recursion  level 1 */
+    // We only perturb the current target vector at the recursion level 1
     if(Xngleich == 0 && nlev == 1) //(ngleich == 0) important, e.g. ex2, ex3
-      if (MivComp(next_vect, omega2) != 1)
-      {
-        /* to dispense with taking initial (and lifting/interreducing
-           after the call of recursion */
-        //Print("\n\n// ** Perturb the both vectors with degree %d with",nlev);
-        //idElements(G, "G");
+      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);
@@ -6217 +6930 @@
         to=clock();
 
-        /* to avoid the value of Overflow_Error that occur in Mfpertvector*/
+        // to avoid the value of Overflow_Error that occur in Mfpertvector
         Overflow_Error = FALSE;
-
         next_vect = MkInterRedNextWeight(omega,omega2,G);
         xtnw=xtnw+clock()-to;
-
-#ifdef PRINT_VECTORS
+      }// 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 +6964 @@
       Gt = NULL; return(Gt);
 #endif
-
-      //Print("\n\n// apply BB's alg. in ring r = %s;", rString(currRing));
+      if(printout > 0)
+      {
+        Print("\n//** rec_fractal_call: Applying Buchberger's algorithm in ring r = %s;",
+              rString(currRing));
+      }
       to=clock();
       Gt = idrMoveR(G, oRing,currRing);
@@ -6257 +6976 @@
 
       delete omega2;
-      delete altomega;
-
-      //Print("\n// Leaving the %d-th recursion with %d steps", nlev, nwalks);
-      //Print("  ** Overflow_Error? (%d)", Overflow_Error);
+      //delete altomega;
+      if(printout > 0)
+      {
+        Print("\n//** rec_fractal_call: Overflow. Leaving the %d-th recursion with %d steps.\n",
+              nlev, nwalks);
+        //Print(" ** Overflow_Error? (%d)", Overflow_Error);
+      }
+
       nnflow ++;
-
       Overflow_Error = FALSE;
       return (G1);
@@ -6277 +6999 @@
     if (MivComp(next_vect, XivNull) == 1)
     {
-      if (rParameter(currRing) != NULL)
-        DefRingPar(omtmp);
+      if(ivtarget->length() == nV)
+      {
+        if (rParameter(currRing) != NULL)
+          DefRingPar(omtmp);
+        else
+          rChangeCurrRing(VMrDefault(omtmp));
+      }
       else
-        rChangeCurrRing(VMrDefault1(omtmp)); //Aenderung5
+      {
+        rChangeCurrRing(VMatrDefault(ivtarget));
+      }
 
       testring = currRing;
       Gt = idrMoveR(G, oRing,currRing);
 
-      if(test_w_in_ConeCC(Gt, omega2) == 1) {
+      if(test_w_in_ConeCC(Gt, omega2) == 1)
+      {
+        delete omega2;
+        delete next_vect;
+        //delete altomega;
+        if(printout > 0)
+        {
+          Print("\n//** rec_fractal_call: Correct cone. Leaving the %d-th recursion with %d steps.\n",
+              nlev, nwalks);
+        }
+        return (Gt);
+      }
+      else
+      {
+        if(printout > 0)
+        {
+          Print("\n//** rec_fractal_call: Wrong cone. Tau doesn't stay in the correct cone.\n");
+        }
+
+#ifndef  MSTDCC_FRACTAL
+        intvec* Xtautmp;
+        if(ivtarget->length() == nV)
+        {
+          Xtautmp = Mfpertvector(Gt, MivMatrixOrder(omtmp));
+        }
+        else
+        {
+          Xtautmp = Mfpertvector(Gt, ivtarget);
+        }
+#ifdef TEST_OVERFLOW
+      if(Overflow_Error == TRUE)
+      Gt = NULL; return(Gt);
+#endif
+
+        if(MivSame(Xtau, Xtautmp) == 1)
+        {
+          if(printout > 0)
+          {
+            Print("\n//** rec_fractal_call: Updated vectors are equal to the old vectors.\n");
+          }
+          delete Xtautmp;
+          goto FRACTAL_MSTDCC;
+        }
+
+        Xtau = Xtautmp;
+        Xtautmp = NULL;
+
+        for(i=nV-1; i>=0; i--)
+          (*omega2)[i] = (*Xtau)[(nlev-1)*nV+i];
+
+        rChangeCurrRing(oRing);
+        G = idrMoveR(Gt, testring,currRing);
+
+        goto NEXT_VECTOR_FRACTAL;
+#endif
+
+      FRACTAL_MSTDCC:
+        if(printout > 0)
+        {
+          Print("\n//** rec_fractal_call: Wrong cone. Applying Buchberger's algorithm in ring = %s.\n",
+                rString(currRing));
+        }
+        to=clock();
+        G = MstdCC(Gt);
+        xtextra=xtextra+clock()-to;
+
+        oRing = currRing;
+
+        // update the original target vector w.r.t. the current GB
+        if(ivtarget->length() == nV)
+        {
+          if(MivSame(Xivinput, Xivlp) == 1)
+            if (rParameter(currRing) != NULL)
+              DefRingParlp();
+            else
+              VMrDefaultlp();
+          else
+            if (rParameter(currRing) != NULL)
+              DefRingPar(Xivinput);
+            else
+              rChangeCurrRing(VMrDefault(Xivinput));
+        }
+        else
+        {
+          rChangeCurrRing(VMatrRefine(ivtarget,Xivinput));
+        }
+        testring = currRing;
+        Gt = idrMoveR(G, oRing,currRing);
+
+        // 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);
+
+        delete omega2;
+        delete next_vect;
+        //delete altomega;
+        if(printout > 0)
+        {
+          Print("\n//** rec_fractal_call: Vectors updated. Leaving the %d-th recursion with %d steps.\n",
+              nlev, nwalks);
+          //Print(" ** Overflow_Error? (%d)", Overflow_Error);
+        }
+        if(Overflow_Error == TRUE)
+          nnflow ++;
+
+        Overflow_Error = FALSE;
+        return(G);
+      }
+    }// end of (if next_vect==nullvector)
+
+    for(i=nV-1; i>=0; i--) {
+      //(*altomega)[i] = (*omega)[i];
+      (*omega)[i] = (*next_vect)[i];
+    }
+    delete next_vect;
+
+    to=clock();
+    // Take the initial form of <G> w.r.t. omega
+    Gomega = MwalkInitialForm(G, omega);
+    xtif=xtif+clock()-to;
+    if(printout > 1)
+    {
+      idString(Gomega,"//** rec_fractal_call: Gomega");
+    }
+
+    if(reduction == 0)
+    {
+      // Check whether the intermediate weight vector lies in the interior of the cone.
+      // If so, only perform reductions. Otherwise apply Buchberger's algorithm.
+      FF = middleOfCone(G,Gomega);
+      if( FF != NULL)
+      {
+        idDelete(&G);
+        G = idCopy(FF);
+        idDelete(&FF);
+        // Compue next vector. 
+        goto NEXT_VECTOR_FRACTAL;
+      } 
+    }
+
+#ifndef  BUCHBERGER_ALG
+    if(isNolVector(omega) == 0)
+      hilb_func = hFirstSeries(Gomega,NULL,NULL,omega,currRing);
+    else
+      hilb_func = hFirstSeries(Gomega,NULL,NULL,last_omega,currRing);
+#endif
+
+    if(ivtarget->length() == nV)
+    {
+      if (rParameter(currRing) != NULL)
+        DefRingPar(omega);
+      else
+        rChangeCurrRing(VMrDefault(omega));
+    }
+    else
+    {
+      rChangeCurrRing(VMatrRefine(ivtarget,omega));
+    }
+    Gomega1 = idrMoveR(Gomega, oRing,currRing);
+
+    // Maximal recursion depth, to compute a red. GB
+    // Fractal walk with the alternative recursion
+    // alternative recursion
+    if(nlev == Xnlev || lengthpoly(Gomega1) == 0)
+    {
+      if(printout > 1)
+      {
+        Print("\n//** rec_fractal_call: Maximal recursion depth.\n");
+      }
+
+      to=clock();
+#ifdef  BUCHBERGER_ALG
+      Gresult = MstdhomCC(Gomega1);
+#else
+      Gresult =kStd(Gomega1,NULL,isHomog,NULL,hilb_func,0,NULL,omega);
+      delete hilb_func;
+#endif
+      xtstd=xtstd+clock()-to;
+    }
+    else
+    {
+      rChangeCurrRing(oRing);
+      Gomega1 = idrMoveR(Gomega1, oRing,currRing);
+      Gresult = rec_fractal_call(idCopy(Gomega1),nlev+1,omega,reduction,printout);
+    }
+    if(printout > 2)
+    {
+      idString(Gresult,"//** rec_fractal_call: M");
+    }
+    //convert a Groebner basis from a ring to another ring
+    new_ring = currRing;
+
+    rChangeCurrRing(oRing);
+    Gresult1 = idrMoveR(Gresult, new_ring,currRing);
+    Gomega2 = idrMoveR(Gomega1, new_ring,currRing);
+
+    to=clock();
+    // Lifting process
+    F = MLifttwoIdeal(Gomega2, Gresult1, G);
+    xtlift=xtlift+clock()-to;
+    if(printout > 2)
+    {
+      idString(F,"//** rec_fractal_call: F");
+    }
+    idDelete(&Gresult1);
+    idDelete(&Gomega2);
+    idDelete(&G);
+
+    rChangeCurrRing(new_ring);
+    //F1 = idrMoveR(F, oRing,currRing);
+    G = idrMoveR(F,oRing,currRing);
+    to=clock();
+    // Interreduce G
+    // G = kInterRedCC(F1, NULL);
+    xtred=xtred+clock()-to;
+    //idDelete(&F1);
+  }
+}
+
+/************************************************************************
+ * Perturb the start weight vector at the top level with random element *
+ ************************************************************************/
+static ideal rec_r_fractal_call(ideal G, int nlev, intvec* ivtarget,
+                int weight_rad, int reduction, int printout)
+{
+  Overflow_Error =  FALSE;
+  //Print("\n\n// Entering the %d-th recursion:", nlev);
+
+  int i, polylength, nV = currRing->N;
+  ring new_ring, testring;
+  //ring extoRing;
+  ideal Gomega, Gomega1, Gomega2, F, FF, F1, Gresult, Gresult1, G1, Gt;
+  int nwalks = 0;
+  intvec* Mwlp;
+#ifndef BUCHBERGER_ALG
+  intvec* hilb_func;
+#endif
+//  intvec* extXtau;
+  intvec* next_vect;
+  intvec* omega2 = new intvec(nV);
+  intvec* omtmp = new intvec(nV);
+  intvec* altomega = new intvec(nV);
+
+  //BOOLEAN isnewtarget = FALSE;
+
+  for(i = nV -1; i>0; i--)
+  {
+    (*omtmp)[i] = (*ivtarget)[i];
+  }
+  // to avoid (1,0,...,0) as the target vector (Hans)
+  intvec* last_omega = new intvec(nV);
+  for(i=nV-1; i>0; i--)
+    (*last_omega)[i] = 1;
+  (*last_omega)[0] = 10000;
+
+  intvec* omega = new intvec(nV);
+  for(i=0; i<nV; i++) {
+    if(Xsigma->length() == nV)
+      (*omega)[i] =  (*Xsigma)[i];
+    else
+      (*omega)[i] = (*Xsigma)[(nV*(nlev-1))+i];
+
+    (*omega2)[i] = (*Xtau)[(nlev-1)*nV+i];
+  }
+
+   if(nlev == 1)  Xcall = 1;
+   else Xcall = 0;
+
+  ring oRing = currRing;
+
+  while(1)
+  {
+#ifdef FIRST_STEP_FRACTAL
+    /*
+    perturb the current weight vector only on the top level or
+    after perturbation of the both vectors, nlev = 2 as the top level
+    */
+    if((nlev == 1 && Xcall == 0) || (nlev == 2 && Xngleich == 1))
+      if(islengthpoly2(G) == 1)
+      {
+        Mwlp = MivWeightOrderlp(omega);
+        Xsigma = Mfpertvector(G, Mwlp);
+        delete Mwlp;
+        Overflow_Error = FALSE;
+      }
+#endif
+    nwalks ++;
+    NEXT_VECTOR_FRACTAL:
+    to=clock();
+    /* determine the next border */
+    next_vect = MkInterRedNextWeight(omega,omega2,G);
+    if(polylength > 0 && G->m[0] != NULL)
+    {
+      if(printout > 0)
+      {
+        PrintS("\n**// rec_r_fractal_call: there is a polynomial in Gomega with at least 3 monomials, low-dimensional facet of the cone.\n");
+      }
+      delete next_vect;
+      next_vect = MWalkRandomNextWeight(G,omega,omega2,weight_rad,nlev);
+      if(isNegNolVector(next_vect) == 1)
+      {
+        delete next_vect;
+        next_vect = MkInterRedNextWeight(omega,omega2,G);
+      }
+    }
+    xtnw=xtnw+clock()-to;
+
+    oRing = currRing;
+
+    // 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 initials and lifting/interreducing
+        // after the call of recursion.
+        if(printout > 0)
+        {
+          Print("\n//** rec_r_fractal_call: Perturb both vectors with degree %d.",nlev);
+          //idElements(G, "G");
+        }
+        Xngleich = 1;
+        nlev +=1;
+        if(ivtarget->length() == nV)
+        {
+          if (rParameter(currRing) != NULL)
+            DefRingPar(omtmp);
+          else
+            rChangeCurrRing(VMrDefault(omtmp));
+        }
+        else
+        {
+          rChangeCurrRing(VMatrDefault(ivtarget));
+        }
+        testring = currRing;
+        Gt = idrMoveR(G, oRing,currRing);
+
+        // 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
+        Mwlp = MivWeightOrderlp(omega);
+        if(ivtarget->length() > nV)
+        {
+          delete Mwlp;
+          Mwlp = MivMatrixOrderRefine(omega,ivtarget);
+        }
+        Xsigma = Mfpertvector(G, Mwlp);
+        delete Mwlp;
+
+        for(i=nV-1; i>=0; i--) {
+          (*omega2)[i] = (*Xtau)[nV+i];
+          (*omega)[i] = (*Xsigma)[nV+i];
+        }
+
+        delete next_vect;
+        to=clock();
+
+        /*
+        to avoid the value of Overflow_Error that occur in
+        Mfpertvector
+        */
+        Overflow_Error = FALSE;
+
+        next_vect = MkInterRedNextWeight(omega,omega2,G);
+        if(G->m[0] != NULL && polylength > 0)
+        {
+          
+          PrintS("//** rec_r_fractal_call: there is a polynomial in Gomega with at least 3 monomials, low-dimensional facet of the cone");
+          
+          delete next_vect;
+          next_vect = MWalkRandomNextWeight(G,omega,omega2,weight_rad,nlev);
+          if(isNegNolVector(next_vect) == 1)
+          {
+            delete next_vect;
+            next_vect = MkInterRedNextWeight(omega,omega2,G);
+          }
+        }
+        xtnw=xtnw+clock()-to;
+      }
+//#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 || test_w_in_ConeCC(G,next_vect) != 1)
+    {
+      delete next_vect;
+      if(ivtarget->length() == nV)
+      {
+        if (rParameter(currRing) != NULL)
+        {
+          DefRingPar(omtmp);
+        }
+        else
+        {
+          rChangeCurrRing(VMrDefault(omtmp));
+        }
+      }
+      else
+      {
+        rChangeCurrRing(VMatrDefault(ivtarget));
+      }
+#ifdef TEST_OVERFLOW
+      Gt = idrMoveR(G, oRing,currRing);
+      Gt = NULL;
+      return(Gt);
+#endif
+      if(printout > 0)
+      {
+        Print("\n//** rec_r_fractal_call: applying Buchberger's algorithm in ring r = %s;",
+              rString(currRing));
+      }
+      to=clock();
+      Gt = idrMoveR(G, oRing,currRing);
+      G1 = MstdCC(Gt);
+      xtextra=xtextra+clock()-to;
+      Gt = NULL;
+
+      delete omega2;
+      delete altomega;
+      if(printout > 0)
+      {
+        Print("\n//** rec_r_fractal_call: Leaving the %d-th recursion with %d steps.\n",
+              nlev, nwalks);
+        //Print(" ** Overflow_Error? (%d)", Overflow_Error);
+      }
+      nnflow ++;
+      Overflow_Error = FALSE;
+      return (G1);
+    }
+    /*
+       If the perturbed target vector stays in the correct cone,
+       return the current Groebner basis.
+       Otherwise, return the Groebner basis computed with Buchberger's
+       algorithm.
+       Then we update the perturbed target vectors w.r.t. this GB.
+    */
+    if (MivComp(next_vect, XivNull) == 1)
+    {
+      // The computed vector is equal to the origin vector,
+      // because t is not defined
+      if(ivtarget->length() == nV)
+      {
+        if (rParameter(currRing) != NULL)
+          DefRingPar(omtmp);
+        else
+          rChangeCurrRing(VMrDefault(omtmp));
+      }
+      else
+      {
+        rChangeCurrRing(VMatrDefault(ivtarget));
+      }
+      testring = currRing;
+      Gt = idrMoveR(G, oRing,currRing);
+
+      if(test_w_in_ConeCC(Gt, omega2) == 1)
+      {
         delete omega2;
         delete next_vect;
         delete altomega;
-        //Print("\n// Leaving the %d-th recursion with %d steps ",nlev, nwalks);
-        //Print(" ** Overflow_Error? (%d)", Overflow_Error);
-
+        if(printout > 0)
+        {
+          Print("\n//** rec_r_fractal_call: Leaving the %d-th recursion with %d steps.\n",
+                nlev, nwalks);
+          //Print(" ** Overflow_Error? (%d)", Overflow_Error);
+        }
         return (Gt);
       }
       else
-      {
-        //ivString(omega2, "tau'");
-        //Print("\n//  tau' doesn't stay in the correct cone!!");
+      { 
+        if(printout > 0)
+        {
+          Print("\n//** rec_r_fractal_call: target weight doesn't stay in the correct cone.\n");
+        }
 
 #ifndef  MSTDCC_FRACTAL
-        //07.08.03
         //ivString(Xtau, "old Xtau");
-        intvec* Xtautmp = Mfpertvector(Gt, MivMatrixOrder(omtmp));
+        intvec* Xtautmp;
+        if(ivtarget->length() == nV)
+        {
+          Xtautmp = Mfpertvector(Gt, MivMatrixOrder(omtmp));
+        }
+        else
+        {
+          Xtautmp = Mfpertvector(Gt, ivtarget);
+        }
 #ifdef TEST_OVERFLOW
       if(Overflow_Error == TRUE)
@@ -6330 +7556 @@
 
       FRACTAL_MSTDCC:
-        //Print("\n//  apply BB-Alg in ring = %s;", rString(currRing));
+        if(printout > 0)
+        {
+          Print("\n//** rec_r_fractal_call: apply Buchberger's algorithm in ring = %s.\n",
+                rString(currRing));
+        }
         to=clock();
         G = MstdCC(Gt);
@@ -6338 +7568 @@
 
         // update the original target vector w.r.t. the current GB
-        if(MivSame(Xivinput, Xivlp) == 1)
-          if (rParameter(currRing) != NULL)
-            DefRingParlp();
+        if(ivtarget->length() == nV)
+        {
+          if(MivSame(Xivinput, Xivlp) == 1)
+            if (rParameter(currRing) != NULL)
+              DefRingParlp();
+            else
+              VMrDefaultlp();
           else
-            VMrDefaultlp();
+            if (rParameter(currRing) != NULL)
+              DefRingPar(Xivinput);
+            else
+              rChangeCurrRing(VMrDefault(Xivinput));
+        }
         else
-          if (rParameter(currRing) != NULL)
-            DefRingPar(Xivinput);
-          else
-            rChangeCurrRing(VMrDefault1(Xivinput)); //Aenderung6
-
+        {
+          rChangeCurrRing(VMatrRefine(ivtarget,Xivinput));
+        }
         testring = currRing;
         Gt = idrMoveR(G, oRing,currRing);
 
-        delete 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);
@@ -6361 +7606 @@
         delete next_vect;
         delete altomega;
-        /*
-          Print("\n// Leaving the %d-th recursion with %d steps,", nlev,nwalks);
-          Print(" ** Overflow_Error? (%d)", Overflow_Error);
-        */
+        if(printout > 0)
+        {
+          Print("\n//** rec_r_fractal_call: Leaving the %d-th recursion with %d steps.\n",
+                nlev,nwalks);
+          //Print(" ** Overflow_Error? (%d)", Overflow_Error);
+        }
         if(Overflow_Error == TRUE)
           nnflow ++;
@@ -6371 +7618 @@
         return(G);
       }
-    }
-
-    for(i=nV-1; i>=0; i--) {
+    } //end of if(MivComp(next_vect, XivNull) == 1)
+
+    for(i=nV-1; i>=0; i--)
+    {
       (*altomega)[i] = (*omega)[i];
       (*omega)[i] = (*next_vect)[i];
@@ -6380 +7628 @@
 
     to=clock();
-    /* Take the initial form of <G> w.r.t. omega */
+    // Take the initial form of <G> w.r.t. omega
     Gomega = MwalkInitialForm(G, omega);
     xtif=xtif+clock()-to;
+    //polylength = 1 if there is a polynomial in Gomega with at least 3 monomials and 0 otherwise
+    polylength = lengthpoly(Gomega);
+    if(printout > 1)
+    {
+      idString(Gomega,"//** rec_r_fractal_call: Gomega");
+    }
+
+    if(reduction == 0)
+    {
+      /* Check whether the intermediate weight vector lies in the interior of the cone.
+       * If so, only perform reductions. Otherwise apply Buchberger's algorithm. */
+      FF = middleOfCone(G,Gomega);
+      if( FF != NULL)
+      {
+        idDelete(&G);
+        G = idCopy(FF);
+        idDelete(&FF);
+        /* Compue next vector. */
+        goto NEXT_VECTOR_FRACTAL;
+      } 
+    }
 
 #ifndef  BUCHBERGER_ALG
@@ -6389 +7658 @@
     else
       hilb_func = hFirstSeries(Gomega,NULL,NULL,last_omega,currRing);
-#endif // BUCHBERGER_ALG
-
-    if (rParameter(currRing) != NULL)
-      DefRingPar(omega);
+#endif
+    if(ivtarget->length() == nV)
+    {
+      if (rParameter(currRing) != NULL)
+        DefRingPar(omega);
+      else
+        rChangeCurrRing(VMrDefault(omega));
+    }
     else
-      rChangeCurrRing(VMrDefault1(omega)); //Aenderung7
-
+    {
+      rChangeCurrRing(VMatrRefine(ivtarget,omega));
+    }
     Gomega1 = idrMoveR(Gomega, oRing,currRing);
 
-    /* Maximal recursion depth, to compute a red. GB */
-    /* Fractal walk with the alternative recursion */
-    /* alternative recursion */
-    // if(nlev == nV || lengthpoly(Gomega1) == 0)
+    // Maximal recursion depth, to compute a red. GB
+    // Fractal walk with the alternative recursion
+    // alternative recursion
     if(nlev == Xnlev || lengthpoly(Gomega1) == 0)
-      //if(nlev == nV) // blind recursion
-    {
-      /*
-      if(Xnlev != nV)
-      {
-        Print("\n// ** Xnlev = %d", Xnlev);
-        ivString(Xtau, "Xtau");
-      }
-      */
+    {
       to=clock();
 #ifdef  BUCHBERGER_ALG
@@ -6418 +7683 @@
       Gresult =kStd(Gomega1,NULL,isHomog,NULL,hilb_func,0,NULL,omega);
       delete hilb_func;
-#endif // BUCHBERGER_ALG
+#endif
       xtstd=xtstd+clock()-to;
     }
-    else {
+    else
+    {
       rChangeCurrRing(oRing);
       Gomega1 = idrMoveR(Gomega1, oRing,currRing);
-      Gresult = rec_fractal_call(idCopy(Gomega1),nlev+1,omega);
-    }
-
-    //convert a Groebner basis from a ring to another ring,
+      Gresult = rec_r_fractal_call(idCopy(Gomega1),nlev+1,omega,weight_rad,reduction,printout);
+    }
+    if(printout > 2)
+    {
+      idString(Gresult,"//** rec_r_fractal_call: M");
+    }
+    //convert a Groebner basis from a ring to another ring
     new_ring = currRing;
 
@@ -6435 +7704 @@
 
     to=clock();
-    /* Lifting process */
+    // Lifting process
     F = MLifttwoIdeal(Gomega2, Gresult1, G);
     xtlift=xtlift+clock()-to;
+
+    if(printout > 2)
+    {
+      idString(F,"//** rec_r_fractal_call: F");
+    }
+
     idDelete(&Gresult1);
     idDelete(&Gomega2);
@@ -6443 +7718 @@
 
     rChangeCurrRing(new_ring);
-    F1 = idrMoveR(F, oRing,currRing);
-
+    //F1 = idrMoveR(F, oRing,currRing);
+    G = idrMoveR(F,oRing,currRing);
     to=clock();
-    /* Interreduce G */
-    G = kInterRedCC(F1, NULL);
+    // Interreduce G
+    //G = kInterRedCC(F1, NULL);
     xtred=xtred+clock()-to;
-    idDelete(&F1);
+    //idDelete(&F1);
   }
 }
-
-/************************************************************************
- * Perturb the start weight vector at the top level with random element *
- ************************************************************************/
-static ideal rec_r_fractal_call(ideal G, int nlev, intvec* omtmp, int weight_rad)
-{
-  Overflow_Error =  FALSE;
-  //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;
-  int nwalks = 0;
-  intvec* Mwlp;
-#ifndef BUCHBERGER_ALG
-  intvec* hilb_func;
-#endif
-//  intvec* extXtau;
-  intvec* next_vect;
-  intvec* omega2 = new intvec(nV);
-  intvec* altomega = new intvec(nV);
-
-  //BOOLEAN isnewtarget = FALSE;
-
-  // to avoid (1,0,...,0) as the target vector (Hans)
-  intvec* last_omega = new intvec(nV);
-  for(i=nV-1; i>0; i--)
-    (*last_omega)[i] = 1;
-  (*last_omega)[0] = 10000;
-
-  intvec* omega = new intvec(nV);
-  for(i=0; i<nV; i++) {
-    if(Xsigma->length() == nV)
-      (*omega)[i] =  (*Xsigma)[i];
-    else
-      (*omega)[i] = (*Xsigma)[(nV*(nlev-1))+i];
-
-    (*omega2)[i] = (*Xtau)[(nlev-1)*nV+i];
-  }
-
-   if(nlev == 1)  Xcall = 1;
-   else Xcall = 0;
-
-  ring oRing = currRing;
-
-  while(1)
-  {
-#ifdef FIRST_STEP_FRACTAL
-    // perturb the current weight vector only on the top level or
-    // after perturbation of the both vectors, nlev = 2 as the top level
-    if((nlev == 1 && Xcall == 0) || (nlev == 2 && Xngleich == 1))
-      if(islengthpoly2(G) == 1)
-      {
-        Mwlp = MivWeightOrderlp(omega);
-        Xsigma = Mfpertvector(G, Mwlp);
-        delete Mwlp;
-        Overflow_Error = FALSE;
-      }
-#endif
-    nwalks ++;
-    NEXT_VECTOR_FRACTAL:
-    to=clock();
-    /* determine the next border */
-    next_vect = MWalkRandomNextWeight(G, omega,omega2, weight_rad, 1+nlev);
-    //next_vect = MkInterRedNextWeight(omega,omega2,G);
-    xtnw=xtnw+clock()-to;
-#ifdef PRINT_VECTORS
-    MivString(omega, omega2, next_vect);
-#endif
-    oRing = currRing;
-
-    /* We only perturb the current target vector at the recursion  level 1 */
-    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");
-
-        Xngleich = 1;
-        nlev +=1;
-
-        if (rParameter(currRing) != NULL)
-          DefRingPar(omtmp);
-        else
-          rChangeCurrRing(VMrDefault1(omtmp)); //Aenderung3
-
-        testring = currRing;
-        Gt = idrMoveR(G, oRing,currRing);
-
-        /* perturb the original target vector w.r.t. the current GB */
-        delete Xtau;
-        Xtau = NewVectorlp(Gt);
-
-        rChangeCurrRing(oRing);
-        G = idrMoveR(Gt, testring,currRing);
-
-        /* perturb the current vector w.r.t. the current GB */
-        Mwlp = MivWeightOrderlp(omega);
-        Xsigma = Mfpertvector(G, Mwlp);
-        delete Mwlp;
-
-        for(i=nV-1; i>=0; i--) {
-          (*omega2)[i] = (*Xtau)[nV+i];
-          (*omega)[i] = (*Xsigma)[nV+i];
-        }
-
-        delete next_vect;
-        to=clock();
-
-        /* to avoid the value of Overflow_Error that occur in Mfpertvector*/
-        Overflow_Error = FALSE;
-
-        next_vect = MkInterRedNextWeight(omega,omega2,G);
-        xtnw=xtnw+clock()-to;
-
-#ifdef PRINT_VECTORS
-        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)
-    {
-      delete next_vect;
-      if (rParameter(currRing) != NULL)
-      {
-        DefRingPar(omtmp);
-      }
-      else
-      {
-        rChangeCurrRing(VMrDefault1(omtmp)); // Aenderung4
-      }
-#ifdef TEST_OVERFLOW
-      Gt = idrMoveR(G, oRing,currRing);
-      Gt = NULL; return(Gt);
-#endif
-
-      //Print("\n\n// apply BB's alg. in ring r = %s;", rString(currRing));
-      to=clock();
-      Gt = idrMoveR(G, oRing,currRing);
-      G1 = MstdCC(Gt);
-      xtextra=xtextra+clock()-to;
-      Gt = NULL;
-
-      delete omega2;
-      delete altomega;
-
-      //Print("\n// Leaving the %d-th recursion with %d steps", nlev, nwalks);
-      //Print("  ** Overflow_Error? (%d)", Overflow_Error);
-      nnflow ++;
-
-      Overflow_Error = FALSE;
-      return (G1);
-    }
-
-
-    /* If the perturbed target vector stays in the correct cone,
-       return the current GB,
-       otherwise, return the computed  GB by the Buchberger-algorithm.
-       Then we update the perturbed target vectors w.r.t. this GB. */
-
-    /* the computed vector is equal to the origin vector, since
-       t is not defined */
-    if (MivComp(next_vect, XivNull) == 1)
-    {
-      if (rParameter(currRing) != NULL)
-        DefRingPar(omtmp);
-      else
-        rChangeCurrRing(VMrDefault1(omtmp)); //Aenderung5
-
-      testring = currRing;
-      Gt = idrMoveR(G, oRing,currRing);
-
-      if(test_w_in_ConeCC(Gt, omega2) == 1) {
-        delete omega2;
-        delete next_vect;
-        delete altomega;
-        //Print("\n// Leaving the %d-th recursion with %d steps ",nlev, nwalks);
-        //Print(" ** Overflow_Error? (%d)", Overflow_Error);
-
-        return (Gt);
-      }
-      else
-      {
-        //ivString(omega2, "tau'");
-        //Print("\n//  tau' doesn't stay in the correct cone!!");
-
-#ifndef  MSTDCC_FRACTAL
-        //07.08.03
-        //ivString(Xtau, "old Xtau");
-        intvec* Xtautmp = Mfpertvector(Gt, MivMatrixOrder(omtmp));
-#ifdef TEST_OVERFLOW
-      if(Overflow_Error == TRUE)
-      Gt = NULL; return(Gt);
-#endif
-
-        if(MivSame(Xtau, Xtautmp) == 1)
-        {
-          //PrintS("\n// Update vectors are equal to the old vectors!!");
-          delete Xtautmp;
-          goto FRACTAL_MSTDCC;
-        }
-
-        Xtau = Xtautmp;
-        Xtautmp = NULL;
-        //ivString(Xtau, "new  Xtau");
-
-        for(i=nV-1; i>=0; i--)
-          (*omega2)[i] = (*Xtau)[(nlev-1)*nV+i];
-
-        //Print("\n//  ring tau = %s;", rString(currRing));
-        rChangeCurrRing(oRing);
-        G = idrMoveR(Gt, testring,currRing);
-
-        goto NEXT_VECTOR_FRACTAL;
-#endif
-
-      FRACTAL_MSTDCC:
-        //Print("\n//  apply BB-Alg in ring = %s;", rString(currRing));
-        to=clock();
-        G = MstdCC(Gt);
-        xtextra=xtextra+clock()-to;
-
-        oRing = currRing;
-
-        // update the original target vector w.r.t. the current GB
-        if(MivSame(Xivinput, Xivlp) == 1)
-          if (rParameter(currRing) != NULL)
-            DefRingParlp();
-          else
-            VMrDefaultlp();
-        else
-          if (rParameter(currRing) != NULL)
-            DefRingPar(Xivinput);
-          else
-            rChangeCurrRing(VMrDefault1(Xivinput)); //Aenderung6
-
-        testring = currRing;
-        Gt = idrMoveR(G, oRing,currRing);
-
-        delete Xtau;
-        Xtau = NewVectorlp(Gt);
-
-        rChangeCurrRing(oRing);
-        G = idrMoveR(Gt, testring,currRing);
-
-        delete omega2;
-        delete next_vect;
-        delete altomega;
-        /*
-          Print("\n// Leaving the %d-th recursion with %d steps,", nlev,nwalks);
-          Print(" ** Overflow_Error? (%d)", Overflow_Error);
-        */
-        if(Overflow_Error == TRUE)
-          nnflow ++;
-
-        Overflow_Error = FALSE;
-        return(G);
-      }
-    }
-
-    for(i=nV-1; i>=0; i--) {
-      (*altomega)[i] = (*omega)[i];
-      (*omega)[i] = (*next_vect)[i];
-    }
-    delete next_vect;
-
-    to=clock();
-    /* Take the initial form of <G> w.r.t. omega */
-    Gomega = MwalkInitialForm(G, omega);
-    xtif=xtif+clock()-to;
-
-#ifndef  BUCHBERGER_ALG
-    if(isNolVector(omega) == 0)
-      hilb_func = hFirstSeries(Gomega,NULL,NULL,omega,currRing);
-    else
-      hilb_func = hFirstSeries(Gomega,NULL,NULL,last_omega,currRing);
-#endif // BUCHBERGER_ALG
-
-    if (rParameter(currRing) != NULL)
-      DefRingPar(omega);
-    else
-      rChangeCurrRing(VMrDefault1(omega)); //Aenderung7
-
-    Gomega1 = idrMoveR(Gomega, oRing,currRing);
-
-    /* Maximal recursion depth, to compute a red. GB */
-    /* Fractal walk with the alternative recursion */
-    /* alternative recursion */
-    // if(nlev == nV || lengthpoly(Gomega1) == 0)
-    if(nlev == Xnlev || lengthpoly(Gomega1) == 0)
-      //if(nlev == nV) // blind recursion
-    {
-      /*
-      if(Xnlev != nV)
-      {
-        Print("\n// ** Xnlev = %d", Xnlev);
-        ivString(Xtau, "Xtau");
-      }
-      */
-      to=clock();
-#ifdef  BUCHBERGER_ALG
-      Gresult = MstdhomCC(Gomega1);
-#else
-      Gresult =kStd(Gomega1,NULL,isHomog,NULL,hilb_func,0,NULL,omega);
-      delete hilb_func;
-#endif // BUCHBERGER_ALG
-      xtstd=xtstd+clock()-to;
-    }
-    else {
-      rChangeCurrRing(oRing);
-      Gomega1 = idrMoveR(Gomega1, oRing,currRing);
-      Gresult = rec_fractal_call(idCopy(Gomega1),nlev+1,omega);
-    }
-
-    //convert a Groebner basis from a ring to another ring,
-    new_ring = currRing;
-
-    rChangeCurrRing(oRing);
-    Gresult1 = idrMoveR(Gresult, new_ring,currRing);
-    Gomega2 = idrMoveR(Gomega1, new_ring,currRing);
-
-    to=clock();
-    /* Lifting process */
-    F = MLifttwoIdeal(Gomega2, Gresult1, G);
-    xtlift=xtlift+clock()-to;
-    idDelete(&Gresult1);
-    idDelete(&Gomega2);
-    idDelete(&G);
-
-    rChangeCurrRing(new_ring);
-    F1 = idrMoveR(F, oRing,currRing);
-
-    to=clock();
-    /* Interreduce G */
-    G = kInterRedCC(F1, NULL);
-    xtred=xtred+clock()-to;
-    idDelete(&F1);
-  }
-}
-
-
 
 
@@ -6807 +7733 @@
  *                                                                             *
  * The main procedur Mfwalk calls the recursive Subroutine                     *
- * rec_fractal_call to compute the wanted Grï¿œbner basis.                       *
- * At the main procedur we compute the reduced Grï¿œbner basis w.r.t. a "fast"   *
+ * rec_fractal_call to compute the wanted Groebner basis.                      *
+ * At the main procedur we compute the reduced Groebner basis w.r.t. a "fast"  *
  * order, e.g. "dp" and a sequence of weight vectors which are row vectors     *
  * of a matrix. This matrix defines the given monomial order, e.g. "lp"        *
  *******************************************************************************/
-ideal Mfwalk(ideal G, intvec* ivstart, intvec* ivtarget)
+ideal Mfwalk(ideal G, intvec* ivstart, intvec* ivtarget,
+             int reduction, int printout)
 {
+  BITSET save1 = si_opt_1; // save current options
+  if(reduction == 0)
+  {
+    si_opt_1 &= (~Sy_bit(OPT_REDSB)); // no reduced Groebner basis
+    //si_opt_1 &= (~Sy_bit(OPT_REDTAIL)); // not tail reductions
+  }
   Set_Error(FALSE);
   Overflow_Error = FALSE;
@@ -6848 +7781 @@
       intvec* iv_dp = MivUnit(nV); // define (1,1,...,1)
       intvec* Mdp;
-
-      if(MivSame(ivstart, iv_dp) != 1)
-        Mdp = MivWeightOrderdp(ivstart);
+      if(ivstart->length() == nV)
+      {
+        if(MivSame(ivstart, iv_dp) != 1)
+          Mdp = MivWeightOrderdp(ivstart);
+        else
+          Mdp = MivMatrixOrderdp(nV);
+      }
       else
-        Mdp = MivMatrixOrderdp(nV);
+      {
+        Mdp = ivstart;
+      }
 
       Xsigma = Mfpertvector(I, Mdp);
@@ -6869 +7808 @@
   Xivlp = Mivlp(nV);
 
-  if(MivComp(ivtarget, Xivlp)  != 1)
-  {
-    if (rParameter(currRing) != NULL)
-      DefRingPar(ivtarget);
+  if(ivtarget->length() == nV)
+  {
+    if(MivComp(ivtarget, Xivlp)  != 1)
+    {
+      if (rParameter(currRing) != NULL)
+        DefRingPar(ivtarget);
+      else
+        rChangeCurrRing(VMrDefault(ivtarget));
+
+      I1 = idrMoveR(I, oldRing,currRing);
+      Mlp = MivWeightOrderlp(ivtarget);
+      Xtau = Mfpertvector(I1, Mlp);
+    }
     else
-      rChangeCurrRing(VMrDefault1(ivtarget)); //Aenderung1
-
-    I1 = idrMoveR(I, oldRing,currRing);
-    Mlp = MivWeightOrderlp(ivtarget);
-    Xtau = Mfpertvector(I1, Mlp);
+    {
+      if (rParameter(currRing) != NULL)
+        DefRingParlp();
+      else
+        VMrDefaultlp();
+
+      I1 = idrMoveR(I, oldRing,currRing);
+      Mlp =  MivMatrixOrderlp(nV);
+      Xtau = Mfpertvector(I1, Mlp);
+    }
   }
   else
   {
-    if (rParameter(currRing) != NULL)
-      DefRingParlp();
-    else
-      VMrDefaultlp();
-
-    I1 = idrMoveR(I, oldRing,currRing);
-    Mlp =  MivMatrixOrderlp(nV);
+    rChangeCurrRing(VMatrDefault(ivtarget));
+    I1 = idrMoveR(I,oldRing,currRing);
+    Mlp =  ivtarget;
     Xtau = Mfpertvector(I1, Mlp);
   }
@@ -6899 +7848 @@
   id_Delete(&I, oldRing);
   ring tRing = currRing;
-
-  if (rParameter(currRing) != NULL)
-    DefRingPar(ivstart);
+  if(ivtarget->length() == nV)
+  {
+    if (rParameter(currRing) != NULL)
+      DefRingPar(ivstart);
+    else
+      rChangeCurrRing(VMrDefault(ivstart));
+  }
   else
-    rChangeCurrRing(VMrDefault1(ivstart)); //Aenderung2
+  {
+    rChangeCurrRing(VMatrDefault(ivstart));
+  }
 
   I = idrMoveR(I1,tRing,currRing);
@@ -6914 +7869 @@
   ring helpRing = currRing;
 
-  J = rec_fractal_call(J, 1, ivtarget);
+  J = rec_fractal_call(J,1,ivtarget,reduction,printout);
 
   rChangeCurrRing(oldRing);
@@ -6920 +7875 @@
   idSkipZeroes(resF);
 
+  si_opt_1 = save1; //set original options, e. g. option(RedSB)
   delete Xivlp;
   delete Xsigma;
@@ -6938 +7894 @@
 }
 
-ideal Mfrwalk(ideal G, intvec* ivstart, intvec* ivtarget,int weight_rad)
+/*******************************************************************************
+ * The implementation of the fractal walk algorithm with random element        *
+ *                                                                             *
+ * The main procedur Mfwalk calls the recursive Subroutine                     *
+ * rec_r_fractal_call to compute the wanted Groebner basis.                    *
+ * At the main procedure we compute the reduced Groebner basis w.r.t. a "fast" *
+ * order, e.g. "dp" and a sequence of weight vectors which are row vectors     *
+ * of a matrix. This matrix defines the given monomial order, e.g. "lp"        *
+ *******************************************************************************/
+ideal Mfrwalk(ideal G, intvec* ivstart, intvec* ivtarget,
+              int weight_rad, int reduction, int printout)
 {
+  BITSET save1 = si_opt_1; // save current options
+  if(reduction == 0)
+  {
+    si_opt_1 &= (~Sy_bit(OPT_REDSB)); // no reduced Groebner basis
+    //si_opt_1 &= (~Sy_bit(OPT_REDTAIL)); // not tail reductions
+  }
   Set_Error(FALSE);
   Overflow_Error = FALSE;
@@ -6974 +7946 @@
       intvec* iv_dp = MivUnit(nV); // define (1,1,...,1)
       intvec* Mdp;
-
-      if(MivSame(ivstart, iv_dp) != 1)
-        Mdp = MivWeightOrderdp(ivstart);
+      if(ivstart->length() == nV)
+      {
+        if(MivSame(ivstart, iv_dp) != 1)
+          Mdp = MivWeightOrderdp(ivstart);
+        else
+          Mdp = MivMatrixOrderdp(nV);
+      }
       else
-        Mdp = MivMatrixOrderdp(nV);
+      {
+        Mdp = ivstart;
+      }
 
       Xsigma = Mfpertvector(I, Mdp);
@@ -6995 +7973 @@
   Xivlp = Mivlp(nV);
 
-  if(MivComp(ivtarget, Xivlp)  != 1)
-  {
-    if (rParameter(currRing) != NULL)
-      DefRingPar(ivtarget);
+  if(ivtarget->length() == nV)
+  {
+    if(MivComp(ivtarget, Xivlp)  != 1)
+    {
+      if (rParameter(currRing) != NULL)
+        DefRingPar(ivtarget);
+      else
+        rChangeCurrRing(VMrDefault(ivtarget));
+
+      I1 = idrMoveR(I, oldRing,currRing);
+      Mlp = MivWeightOrderlp(ivtarget);
+      Xtau = Mfpertvector(I1, Mlp);
+    }
     else
-      rChangeCurrRing(VMrDefault1(ivtarget)); //Aenderung1
-
-    I1 = idrMoveR(I, oldRing,currRing);
-    Mlp = MivWeightOrderlp(ivtarget);
-    Xtau = Mfpertvector(I1, Mlp);
+    {
+      if (rParameter(currRing) != NULL)
+        DefRingParlp();
+      else
+        VMrDefaultlp();
+
+      I1 = idrMoveR(I, oldRing,currRing);
+      Mlp =  MivMatrixOrderlp(nV);
+      Xtau = Mfpertvector(I1, Mlp);
+    }
   }
   else
   {
-    if (rParameter(currRing) != NULL)
-      DefRingParlp();
-    else
-      VMrDefaultlp();
-
-    I1 = idrMoveR(I, oldRing,currRing);
-    Mlp =  MivMatrixOrderlp(nV);
+    rChangeCurrRing(VMatrDefault(ivtarget));
+    I1 = idrMoveR(I,oldRing,currRing);
+    Mlp =  ivtarget;
     Xtau = Mfpertvector(I1, Mlp);
   }
@@ -7025 +8013 @@
   id_Delete(&I, oldRing);
   ring tRing = currRing;
-
-  if (rParameter(currRing) != NULL)
-    DefRingPar(ivstart);
+  if(ivtarget->length() == nV)
+  {
+    if (rParameter(currRing) != NULL)
+      DefRingPar(ivstart);
+    else
+      rChangeCurrRing(VMrDefault(ivstart));
+  }
   else
-    rChangeCurrRing(VMrDefault1(ivstart)); //Aenderung2
+  {
+    rChangeCurrRing(VMatrDefault(ivstart));
+  }
 
   I = idrMoveR(I1,tRing,currRing);
@@ -7039 +8033 @@
   ideal resF;
   ring helpRing = currRing;
-//ideal G, int nlev, intvec* omtmp, int weight_rad)
-  J = rec_r_fractal_call(J, 1, ivtarget,weight_rad);
+
+  J = rec_r_fractal_call(J,1,ivtarget,weight_rad,reduction,printout);
 
   rChangeCurrRing(oldRing);
@@ -7046 +8040 @@
   idSkipZeroes(resF);
 
+  si_opt_1 = save1; //set original options, e. g. option(RedSB)
   delete Xivlp;
   delete Xsigma;
@@ -7101 +8096 @@
   intvec* hilb_func;
 #endif
-  /* to avoid (1,0,...,0) as the target vector */
+  // to avoid (1,0,...,0) as the target vector
   intvec* last_omega = new intvec(nV);
   for(i=nV-1; i>0; i--)
@@ -7116 +8111 @@
 
   to=clock();
-  /* compute a red. GB w.r.t. the help ring */
+  // compute a red. GB w.r.t. the help ring
   if(MivComp(curr_weight, iv_dp) == 1) //rOrdStr(currRing) = "dp"
     G = MstdCC(G);
@@ -7125 +8120 @@
       DefRingPar(curr_weight);
     else
-      rChangeCurrRing(VMrDefault(curr_weight)); // Aenderung 4
+      rChangeCurrRing(VMrDefault(curr_weight));
     G = idrMoveR(G, XXRing,currRing);
     G = MstdCC(G);
@@ -7151 +8146 @@
       DefRingPar(curr_weight);
     else
-      rChangeCurrRing(VMrDefault(curr_weight)); //Aenderung 5
+      rChangeCurrRing(VMrDefault(curr_weight));
     to=clock();
     Gw = idrMoveR(G, exring,currRing);
@@ -7186 +8181 @@
       DefRingPar(curr_weight);
     else
-      rChangeCurrRing(VMrDefault(curr_weight)); //Aenderung 6
+      rChangeCurrRing(VMrDefault(curr_weight));
 
     newRing = currRing;
@@ -7271 +8266 @@
           DefRingPar(target_tmp);
         else
-          rChangeCurrRing(VMrDefault(target_tmp)); // Aenderung 8
+          rChangeCurrRing(VMrDefault(target_tmp));
 
       lpRing = currRing;
@@ -7331 +8326 @@
           DefRingPar(target_tmp);
         else
-          rChangeCurrRing(VMrDefault(target_tmp)); //Aenderung 9
+          rChangeCurrRing(VMrDefault(target_tmp));
 
       lpRing = currRing;
@@ -7534 +8529 @@
     else
     {
-      rChangeCurrRing(VMrDefault(curr_weight)); // Aenderung 10
+      rChangeCurrRing(VMrDefault(curr_weight));
     }
     G = idrMoveR(G, XXRing,currRing);
@@ -7567 +8562 @@
     else
     {
-      rChangeCurrRing(VMrDefault(curr_weight)); //Aenderung 11
+      rChangeCurrRing(VMrDefault(curr_weight));
     }
     to=clock();
@@ -7610 +8605 @@
     else
     {
-      rChangeCurrRing(VMrDefault(curr_weight)); // Aenderung 12
+      rChangeCurrRing(VMrDefault(curr_weight));
     }
     newRing = currRing;
@@ -7779 +8774 @@
         else
         {
-          rChangeCurrRing(VMrDefault(target_tmp)); // Aenderung 13
+          rChangeCurrRing(VMrDefault(target_tmp));
         }
       }
@@ -7852 +8847 @@
         else
         {
-          rChangeCurrRing(VMrDefault(target_tmp)); // Aenderung 14
+          rChangeCurrRing(VMrDefault(target_tmp));
         }
       }
@@ -8095 +9090 @@
     else
     {
-      rChangeCurrRing(VMrDefault(curr_weight)); // Aenderung 15
+      rChangeCurrRing(VMrDefault(curr_weight));
     }
     newRing = currRing;
@@ -8237 +9232 @@
 
   //Print("\n// \"Mpwalk\" (1,%d) took %d steps and %.2f sec. Overflow_Error (%d)", tp_deg, nwalk, ((double) clock()-tinput)/1000000, nOverflow_Error);
-
+  Print("\n// Mprwalk took %d steps. Ring= %s;\n", nwalk, rString(currRing));
   return(result);
-}
-
-/*******************************************************
- * THE PERTURBATION WALK ALGORITHM WITH RANDOM ELEMENT *
- *******************************************************/
-ideal Mprwalk(ideal Go, intvec* curr_weight, intvec* target_weight, int weight_rad, int op_deg, int tp_deg, ring baseRing)
-{
-  BITSET save1 = si_opt_1; // save current options
-  si_opt_1 &= (~Sy_bit(OPT_REDSB)); // no reduced Groebner basis
-  Set_Error(FALSE);
-  Overflow_Error = FALSE;
-#ifdef TIME_TEST
-  clock_t tinput=0, tostd=0, 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
-  int i,nwalk,nV = baseRing->N;
-
-  ideal G, Gomega, M, F, Gomega1, Gomega2, M1;
-  ring newRing;
-  ring XXRing = baseRing;
-  intvec* exivlp = Mivlp(nV);
-  intvec* orig_target = target_weight;
-  intvec* pert_target_vector = target_weight;
-  intvec* ivNull = new intvec(nV);
-  intvec* tmp_weight = new intvec(nV);
-#ifdef CHECK_IDEAL_MWALK
-  poly p;
-#endif
-  for(i=0; i<nV; i++)
-  {
-    (*tmp_weight)[i] = (*curr_weight)[i];
-  }
-#ifndef BUCHBERGER_ALG
-  intvec* hilb_func;
-   // to avoid (1,0,...,0) as the target vector
-  intvec* last_omega = new intvec(nV);
-  for(i=0 i<nV; i++)
-  {
-    (*last_omega)[i] = 1;
-  }
-  (*last_omega)[0] = 10000;
-#endif
-  baseRing = currRing;
-  newRing = VMrDefault(curr_weight);
-  rChangeCurrRing(newRing);
-  G = idrMoveR(Go,baseRing,currRing);
-#ifdef TIME_TEST
-  to = clock();
-#endif
-  G = kStd(G,NULL,testHomog,NULL,NULL,0,0,NULL);
-  idSkipZeroes(G);
-#ifdef TIME_TEST
-  tostd = tostd + to - clock();
-#endif
-#ifdef CHECK_IDEAL_MWALK
-  idString(G,"G");
-#endif
-  if(op_deg >1)
-  {
-    if(MivComp(curr_weight,MivUnit(nV)) == 1) //ring order is "dp"
-    {
-      curr_weight = MPertVectors(G, MivMatrixOrderdp(nV), op_deg);
-    }
-    else //ring order is not "dp"
-    {
-      curr_weight = MPertVectors(G, MivMatrixOrder(curr_weight), op_deg);
-    }
-  }
-  baseRing = currRing;
-  if(tp_deg > 1 && tp_deg <= nV)
-  {
-    pert_target_vector = target_weight;
-  }
-#ifdef CHECK_IDEAL_MWALK
-  ivString(curr_weight, "new curr_weight");
-  ivString(target_weight, "new target_weight");
-#endif
-  nwalk = 0;
-  while(1)
-  {
-    nwalk ++;
-#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
-#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)
-    {
-      newRing = VMrDefault(curr_weight); // define a new ring with ordering "(a(curr_weight),lp)
-    }
-    else
-    {
-      newRing = VMrRefine(curr_weight,target_weight); //define a new ring with ordering "(a(curr_weight),Wp(target_weight))"
-    }
-    rChangeCurrRing(newRing);
-    Gomega1 = idrMoveR(Gomega, baseRing,currRing);
-    idDelete(&Gomega);
-    // compute a 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
-    idSkipZeroes(M);
-#ifdef TIME_TEST
-    tstd = tstd + clock() - to;
-#endif
-#ifdef CHECK_IDEAL_MWALK
-    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);
-    to = clock();
-    // 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);
-    idSkipZeroes(F);
-#ifdef TIME_TEST
-    tlift = tlift + clock() - to;
-#endif
-#ifdef CHECK_IDEAL_MWALK
-    idString(F,"F");
-#endif
-    rChangeCurrRing(newRing); // change the ring to newRing
-    G = idrMoveR(F,baseRing,currRing);
-    idDelete(&F);
-    baseRing = currRing; // set baseRing equal to newRing
-#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, op_deg);
-#ifdef TIME_TEST
-    tnw = tnw + clock() - to;
-#endif
-#ifdef PRINT_VECTORS
-    MivString(curr_weight, target_weight, next_weight);
-#endif
-    if(Overflow_Error == TRUE)
-    {
-      PrintS("\n//**Mprwalk: OVERFLOW: The computed vector does not stay in cone, the result may be wrong.\n");
-      delete next_weight;
-      break;
-    }
-
-    if(test_w_in_ConeCC(G,target_weight) == 1 || MivComp(next_weight, ivNull) == 1)
-    {
-      delete next_weight;
-      break;
-    }
-    //update tmp_weight and curr_weight
-    for(i=nV-1; i>=0; i--)
-    {
-      (*tmp_weight)[i] = (*curr_weight)[i];
-      (*curr_weight)[i] = (*next_weight)[i];
-    }
-    delete next_weight;
-  } //end of while-loop
-  Print("\n// Mprwalk took %d steps. Ring= %s;\n", nwalk, rString(currRing));
-  idSkipZeroes(G);
-  si_opt_1 = save1; //set original options, e. g. option(RedSB)
-  baseRing = currRing;
-  rChangeCurrRing(XXRing);
-  ideal Res = idrMoveR(G,baseRing,currRing);
-  delete tmp_weight;
-  delete ivNull;
-  delete exivlp;
-#ifndef BUCHBERGER_ALG
-  delete last_omega;
-#endif
-#ifdef TIME_TEST
-  TimeString(tinput, tostd, tif, tstd, tlift, tred, tnw, nstep);
-#endif
-  return(Res);
 }
 
@@ -8517 +9312 @@
         else
         {
-          rChangeCurrRing(VMrDefault(cw_tmp)); // Aenderung 16
+          rChangeCurrRing(VMrDefault(cw_tmp));
         }
         G = idrMoveR(Go, XXRing,currRing);
@@ -8591 +9386 @@
     else
     {
-      rChangeCurrRing(VMrDefault(curr_weight)); // Aenderung 17
+      rChangeCurrRing(VMrDefault(curr_weight));
     }
     newRing = currRing;
@@ -8653 +9448 @@
       else
       {
-        rChangeCurrRing(VMrDefault(target_weight)); // Aenderung 18
+        rChangeCurrRing(VMrDefault(target_weight));
       }
       F1 = idrMoveR(G, newRing,currRing);

Singular/walk.h

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

Tst/Short/ok_s.lst

@@ -44 +44 @@
 bug_tr707
 bug_tr709
+bug_tr723
 bug_tr724
 bug_genus_etc

libpolys/coeffs/numbers.cc

@@ -228 +228 @@
 number ndCopyMap(number a, const coeffs aRing, const coeffs r)
 {
-  assume( getCoeffType(r) == getCoeffType(aRing) );
+  // aRing and r need not be the same, but must be the same representation
+  assume(aRing->rep==r->rep);
   if ( nCoeff_has_simple_Alloc(r) && nCoeff_has_simple_Alloc(aRing) )
     return a;

libpolys/coeffs/rintegers.cc

@@ -339 +339 @@
 {
   /* dst = currRing */
-  if (nCoeff_is_Ring_Z(src) || nCoeff_is_Ring_ModN(src) || nCoeff_is_Ring_PtoM(src))
+  /* dst = nrn */
+  if ((src->rep==n_rep_gmp)
+  && (nCoeff_is_Ring_Z(src) || nCoeff_is_Ring_ModN(src) || nCoeff_is_Ring_PtoM(src)))
+  {
+    return ndCopyMap; //nrzCopyMap;
+  }
+  if ((src->rep==n_rep_gap_gmp) /*&& nCoeff_is_Ring_Z(src)*/)
   {
     return ndCopyMap; //nrzCopyMap;

libpolys/polys/ext_fields/transext.cc

@@ -193 +193 @@
   {
     p_Test(den, ntRing);
-
     if(p_IsConstant(den, ntRing) && (n_IsOne(pGetCoeff(den), ntCoeffs)))
     {
@@ -199 +198 @@
       return FALSE;
     }
-
     if( !n_GreaterZero(pGetCoeff(den), ntCoeffs) )
     {
@@ -205 +203 @@
       return FALSE;
     }
-
     // test that den is over integers!?
-
-  } else
+  }
+  else
   {  // num != NULL // den == NULL
-
 //    if( COM(t) != 0 )
 //    {
@@ -343 +339 @@
   if (IS0(a)) return NULL;
   fraction f = (fraction)a;
-  poly g = p_Copy(NUM(f), ntRing);
-  poly h = NULL; if (!DENIS1(f)) h = p_Copy(DEN(f), ntRing);
-  fraction result = (fraction)omAllocBin(fractionObjectBin);
-  NUM(result) = g;
-  DEN(result) = h;
+  poly g = NUM(f);
+  poly h = NULL;
+  h =DEN(f);
+  fraction result = (fraction)omAlloc0Bin(fractionObjectBin);
+  NUM(result) = p_Copy(g,cf->extRing);
+  DEN(result) = p_Copy(h,cf->extRing);
   COM(result) = COM(f);
   ntTest((number)result);
@@ -384 +381 @@
     if( !n_GreaterZero(g, ntCoeffs) )
     {
-      NUM (f) = p_Neg(NUM (f), ntRing); // Ugly :(((
+      NUM (f) = p_Neg(NUM (f), ntRing);
       g = n_InpNeg(g, ntCoeffs);
     }
@@ -393 +390 @@
     if( !n_IsOne(g, ntCoeffs) )
     {
-      DEN (f) = p_NSet(g, ntRing); // update COM(f)???
+      DEN (f) = p_NSet(g, ntRing);
       COM (f) ++;
       assume( DEN (f) != NULL );
@@ -1250 +1247 @@
 
   if (IS0(a)) return;
+  if (DENIS1(f) || NUMIS1(f)) { COM(f) = 0; return; }
   if (!simpleTestsHaveAlreadyBeenPerformed)
   {
-    if (DENIS1(f) || NUMIS1(f)) { COM(f) = 0; return; }
 
     /* check whether NUM(f) = DEN(f), and - if so - replace 'a' by 1 */
@@ -1260 +1257 @@
       p_Delete(&DEN(f), ntRing); DEN(f) = NULL;
       COM(f) = 0;
-      ntTest(a); // !!!!
+      ntTest(a);
       return;
     }
@@ -1455 +1452 @@
     //PrintS(" den=");p_wrp(DEN(a),ntRing);PrintLn();
     definiteGcdCancellation(a, cf, FALSE);
-    fraction f=(fraction)a;
-    if ((DEN(f)!=NULL)
-    &&(!n_GreaterZero(pGetCoeff(DEN(f)),ntCoeffs)))
-    {
-      NUM(f)=p_Neg(NUM(f),ntRing);
-      DEN(f)=p_Neg(DEN(f),ntRing);
-      a=(number)f;
+    if ((DEN((fraction)a)!=NULL)
+    &&(!n_GreaterZero(pGetCoeff(DEN((fraction)a)),ntCoeffs)))
+    {
+      NUM((fraction)a)=p_Neg(NUM((fraction)a),ntRing);
+      DEN((fraction)a)=p_Neg(DEN((fraction)a),ntRing);
     }
   }
@@ -1843 +1838 @@
   fraction f = (fraction)a;
   poly g = prMapR(NUM(f), nMap, rSrc, rDst);
+  /* g may contain summands with coeff 0 */
+  poly hh=g;
+  poly prev=NULL;
+  while(hh!=NULL)
+  {
+    if (n_IsZero(pGetCoeff(hh),rDst->cf))
+    {
+      if (prev==NULL)
+      {
+        g=p_LmFreeAndNext(g,rDst);
+        hh=g;
+      }
+      else
+      {
+        prev->next=p_LmFreeAndNext(prev->next,rDst);
+        hh=prev->next;
+      }
+    }
+    else
+    {
+      prev=hh;
+      pIter(hh);
+    }
+  }
+  if (g==NULL) return NULL;
 
   poly h = NULL;
 
   if (!DENIS1(f))
+  {
      h = prMapR(DEN(f), nMap, rSrc, rDst);
+     /* h may contain summands with coeff 0 */
+    hh=h;
+    prev=NULL;
+    while(hh!=NULL)
+    {
+      if (n_IsZero(pGetCoeff(hh),rDst->cf))
+      {
+        if (prev==NULL)
+        {
+          h=p_LmFreeAndNext(h,rDst);
+          hh=h;
+        }
+        else
+        {
+          prev->next=p_LmFreeAndNext(prev->next,rDst);
+          hh=prev->next;
+        }
+      }
+      else
+      {
+        prev=hh;
+        pIter(hh);
+      }
+    }
+    if (h==NULL) WerrorS("mapping to */0");
+  }
 
   fraction result = (fraction)omAllocBin(fractionObjectBin);

libpolys/polys/monomials/p_polys.cc

@@ -3847 +3847 @@
     if( !DENIS1((fraction)z) )
     {
-      if (p_IsConstant(DEN((fraction)z),srcExtRing))
-      {
-        number n=pGetCoeff(DEN((fraction)z));
-        zz=p_Div_nn(zz,n,srcExtRing);
-        p_Normalize(zz,srcExtRing);
-      }
-      else
+      if (!p_IsConstant(DEN((fraction)z),srcExtRing))
         WarnS("Not defined: Cannot map a rational fraction and make a polynomial out of it! Ignoring the denumerator.");
     }
@@ -3885 +3879 @@
     qq = p_PermPoly(zz, par_perm-1, srcExtRing, dst, nMap, NULL, rVar (srcExtRing)-1);
 
+  if(nCoeff_is_transExt(srcCf)
+  && (!DENIS1((fraction)z))
+  && p_IsConstant(DEN((fraction)z),srcExtRing))
+  {
+    number n=nMap(pGetCoeff(DEN((fraction)z)),srcExtRing->cf, dstCf);
+    qq=p_Div_nn(qq,n,dst);
+    n_Delete(&n,dstCf);
+    p_Normalize(qq,dst);
+  }
   p_Test (qq, dst);
-
-//       poly p_PermPoly (poly p, int * perm, const ring oldRing, const ring dst, nMapFunc nMap, int *par_perm, int OldPar)
-
-//  assume( FALSE );  WarnS("longalg missing 2");
 
   return qq;
@@ -3905 +3904 @@
     PrintS("\np_PermPoly::p: "); p_Write(p, oldRing, oldRing); PrintLn();
 #endif
-
   const int OldpVariables = rVar(oldRing);
   poly result = NULL;
@@ -3911 +3909 @@
   poly aq = NULL; /* the map coefficient */
   poly qq; /* the mapped monomial */
-
   assume(dst != NULL);
   assume(dst->cf != NULL);
-
   while (p != NULL)
   {
@@ -3922 +3918 @@
       qq = p_Init(dst);
       assume( nMap != NULL );
-
       number n = nMap(p_GetCoeff(p, oldRing), oldRing->cf, dst->cf);
-
       n_Test (n,dst->cf);
-
       if ( nCoeff_is_algExt(dst->cf) )
         n_Normalize(n, dst->cf);
-
       p_GetCoeff(qq, dst) = n;// Note: n can be a ZERO!!!
-      // coef may be zero:
-//      p_Test(qq, dst);
     }
     else
     {
       qq = p_One(dst);
-
 //      aq = naPermNumber(p_GetCoeff(p, oldRing), par_perm, OldPar, oldRing); // no dst???
 //      poly    n_PermNumber(const number z, const int *par_perm, const int P, const ring src, const ring dst)
       aq = n_PermNumber(p_GetCoeff(p, oldRing), par_perm, OldPar, oldRing, dst);
-
       p_Test(aq, dst);
-
       if ( nCoeff_is_algExt(dst->cf) )
         p_Normalize(aq,dst);
-
       if (aq == NULL)
         p_SetCoeff(qq, n_Init(0, dst->cf),dst); // Very dirty trick!!!
-
       p_Test(aq, dst);
     }
-
     if (rRing_has_Comp(dst))
        p_SetComp(qq, p_GetComp(p, oldRing), dst);
-
     if ( n_IsZero(pGetCoeff(qq), dst->cf) )
     {
@@ -3981 +3964 @@
               assume( dst->cf->extRing == NULL );
               number ee = n_Param(1, dst);
-
               number eee;
               n_Power(ee, e, &eee, dst->cf); //nfDelete(ee,dst);
-
               ee = n_Mult(c, eee, dst->cf);
               //nfDelete(c,dst);nfDelete(eee,dst);
@@ -3993 +3974 @@
               const int par = -perm[i];
               assume( par > 0 );
-
 //              WarnS("longalg missing 3");
 #if 1
               const coeffs C = dst->cf;
               assume( C != NULL );
-
               const ring R = C->extRing;
               assume( R != NULL );
-
               assume( par <= rVar(R) );
-
               poly pcn; // = (number)c
-
               assume( !n_IsZero(c, C) );
-
               if( nCoeff_is_algExt(C) )
                  pcn = (poly) c;
                else //            nCoeff_is_transExt(C)
                  pcn = NUM((fraction)c);
-
               if (pNext(pcn) == NULL) // c->z
                 p_AddExp(pcn, -perm[i], e, R);
@@ -4020 +3994 @@
                 p_SetExp(mmc, -perm[i], e, R);
                 p_Setm(mmc, R);
-
                 number nnc;
                 // convert back to a number: number nnc = mmc;
@@ -4027 +4000 @@
                 else //            nCoeff_is_transExt(C)
                   nnc = ntInit(mmc, C);
-
                 p_GetCoeff(qq, dst) = n_Mult((number)c, nnc, C);
                 n_Delete((number *)&c, C);
                 n_Delete((number *)&nnc, C);
               }
-
               mapped_to_par=1;
 #endif
@@ -4075 +4046 @@
       if (aq!=NULL)
          qq=p_Mult_q(aq,qq,dst);
-
       aq = qq;
-
       while (pNext(aq) != NULL) pIter(aq);
-
       if (result_last==NULL)
       {
@@ -4096 +4064 @@
     }
   }
-
   result=p_SortAdd(result,dst);
 #else
@@ -4127 +4094 @@
 #endif
   p_Test(result,dst);
-
 #if 0
   p_Test(result,dst);

libpolys/polys/polys0.cc

@@ -142 +142 @@
   }
   p_Normalize(p,lmRing);
-  p_Normalize(p,lmRing); /* Manual/absfact.tst */
+  if ((n_GetChar(lmRing->cf) == 0)
+  && (nCoeff_is_transExt(lmRing->cf)))
+    p_Normalize(p,lmRing); /* Manual/absfact.tst */
   if ((p_GetComp(p, lmRing) == 0) || (!lmRing->VectorOut))
   {