Changeset 8e682d in git

Timestamp:

Dec 3, 2014, 5:18:10 PM (9 years ago)

Author:

Stephan Oberfranz <oberfran@…>

Branches:

(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')

Children:

8af63a71de0015f0413204e1a7a8620a8d37cc7a

Parents:

41c9e458d3df4f560848651c9fc0710d72f703dc

Message:

---

Location:

Singular

Files:

• LIB/grwalk.lib (modified) (3 diffs)
• LIB/rwalk.lib (modified) (4 diffs)
• extra.cc (modified) (3 diffs)
• walk.cc (modified) (60 diffs)
• walk.h (modified) (1 diff)

Singular/LIB/grwalk.lib

@@ -346 +346 @@
 }
 
-proc fwalk(ideal Go, int reduction, list #)
+proc fwalk(ideal Go, int reduction, int printout, list #)
 "SYNTAX: fwalk(ideal i,int reductioin);
          fwalk(ideal i, int reduction intvec v, intvec w);
@@ -372 +372 @@
 
    ideal G = fetch(xR, Go);
-   G = system("Mfwalk", G, curr_weight, target_weight, reduction);
+   G = system("Mfwalk", G, curr_weight, target_weight, reduction, printout);
 
    setring xR;
@@ -388 +388 @@
     ideal I = y3+xyz+y2z+xz3, 3+xy+x2y+y2z;
     int reduction = 1;
-    fwalk(I,reduction);
+    int printout = 1;
+    fwalk(I,reduction,printout);
 }
 

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
 ";
 
@@ -270 +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
@@ -306 +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;
@@ -322 +323 @@
     ideal I = y3+xyz+y2z+xz3, 3+xy+x2y+y2z;
     int reduction = 0;
-    frandwalk(I,2,0);
-}
+    frandwalk(I,2,0,1);
+}

Singular/extra.cc

@@ -1936 +1936 @@
     if (strcmp(sys_cmd, "Mfwalk") == 0)
     {
-      const short t[]={4,IDEAL_CMD,INTVEC_CMD,INTVEC_CMD,INT_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 &&
@@ -1943 +1943 @@
         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();
-      int arg4 = (int)(long) h->next->next->next->Data();
-      ideal result = (ideal) Mfwalk(arg1, arg2, arg3, arg4);
-      res->rtyp = IDEAL_CMD;
-      res->data =  result;
-      return FALSE;
-    }
-    else
-  #endif
-  /*==================== Mfrwalk =================*/
-  #ifdef HAVE_WALK
-    if (strcmp(sys_cmd, "Mfrwalk") == 0)
-    {
-      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 &&
-          ((intvec*) h->next->next->Data())->length() != currRing->N)
-      {
-        Werror("system(\"Mfrwalk\" ...) intvecs not of length %d\n",currRing->N);
         return TRUE;
       }
@@ -1973 +1950 @@
       int arg4 = (int)(long) h->next->next->next->Data();
       int arg5 = (int)(long) h->next->next->next->next->Data();
-      ideal result = (ideal) Mfrwalk(arg1, arg2, arg3, arg4, arg5);
+      ideal result = (ideal) Mfwalk(arg1, arg2, arg3, arg4, arg5);
+      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,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;

Singular/walk.cc

@@ -985 +985 @@
 }
 
-/*****************************************************************************
-* 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);
@@ -998 +998 @@
   {
     (*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;
@@ -2454 +2456 @@
   //rChangeCurrRing(r);
 }
-
+//unused
+#if 0
 static ring VMrDefault1(intvec* va)
 {
@@ -2525 +2528 @@
   return r;
 }
-
+#endif
 /****************************************************************
  * define and execute a new ring with ordering (a(va),Wp(vb),C) *
@@ -4314 +4317 @@
 intvec* Xivlp;
 
-#if 0
-/********************************
- * compute a next weight vector *
- ********************************/
-static intvec* MWalkRandomNextWeight(ideal G, intvec* curr_weight, intvec* target_weight, int weight_rad, int pert_deg)
-{
-  int i, weight_norm;
-  int nV = currRing->N;
-  intvec* next_weight2;
-  intvec* next_weight22 = new intvec(nV);
-  intvec* next_weight = MwalkNextWeightCC(curr_weight,target_weight, G);
-  if(MivComp(next_weight, target_weight) == 1)
-  {
-    return(next_weight);
-  }
-  else
-  {
-    //compute a perturbed next weight vector "next_weight1"
-    intvec* next_weight1 = MkInterRedNextWeight(MPertVectors(G, MivMatrixOrder(curr_weight), pert_deg), target_weight, G);
-    //Print("\n // size of next_weight1 = %d", sizeof((*next_weight1)));
-
-    //compute a random next weight vector "next_weight2"
-    while(1)
-    {
-      weight_norm = 0;
-      while(weight_norm == 0)
-      {
-        for(i=0; i<nV; i++)
-        {
-          //Print("\n//  next_weight[%d]  = %d", i, (*next_weight)[i]);
-          (*next_weight22)[i] = rand() % 60000 - 30000;
-          weight_norm = weight_norm + (*next_weight22)[i]*(*next_weight22)[i];
-        }
-        weight_norm = 1 + floor(sqrt(weight_norm));
-      }
-
-      for(i=nV-1; i>=0; i--)
-      {
-        if((*next_weight22)[i] < 0)
-        {
-          (*next_weight22)[i] = 1 + (*curr_weight)[i] + floor(weight_rad*(*next_weight22)[i]/weight_norm);
-        }
-        else
-        {
-          (*next_weight22)[i] = (*curr_weight)[i] + floor(weight_rad*(*next_weight22)[i]/weight_norm);
-        }
-      //Print("\n//  next_weight22[%d]  = %d", i, (*next_weight22)[i]);
-      }
-
-      if(test_w_in_ConeCC(G, next_weight22) == 1)
-      {
-        //Print("\n//MWalkRandomNextWeight: next_weight2 im Kegel\n");
-        next_weight2 = MkInterRedNextWeight(next_weight22, target_weight, G);
-        delete next_weight22;
-        break;
-      }
-    }
-    intvec* result = new intvec(nV);
-    ideal G_test = MwalkInitialForm(G, next_weight);
-    ideal G_test1 = MwalkInitialForm(G, next_weight1);
-    ideal G_test2 = MwalkInitialForm(G, next_weight2);
-
-    // compare next_weights
-    if(IDELEMS(G_test1) < IDELEMS(G_test))
-    {
-      if(IDELEMS(G_test2) <= IDELEMS(G_test1)) // |G_test2| <= |G_test1| < |G_test|
-      {
-        for(i=0; i<nV; i++)
-        {
-          (*result)[i] = (*next_weight2)[i];
-        }
-      }
-      else // |G_test1| < |G_test|, |G_test1| < |G_test2|
-      {
-        for(i=0; i<nV; i++)
-        {
-          (*result)[i] = (*next_weight1)[i];
-        }
-      }
-    }
-    else
-    {
-      if(IDELEMS(G_test2) <= IDELEMS(G_test)) // |G_test2| <= |G_test| <= |G_test1|
-      {
-        for(i=0; i<nV; i++)
-        {
-          (*result)[i] = (*next_weight2)[i];
-        }
-      }
-      else // |G_test| <= |G_test1|, |G_test| < |G_test2|
-      {
-        for(i=0; i<nV; i++)
-        {
-          (*result)[i] = (*next_weight)[i];
-        }
-      }
-    }
-    delete next_weight;
-    delete next_weight1;
-    idDelete(&G_test);
-    idDelete(&G_test1);
-    idDelete(&G_test2);
-    if(test_w_in_ConeCC(G, result) == 1)
-    {
-      delete next_weight2;
-      return result;
-    }
-    else
-    {
-      delete result;
-      return next_weight2;
-    }
-  }
-}
-#endif
 
 /********************************
@@ -4443 +4331 @@
 
   //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"
@@ -5111 +4998 @@
             ring baseRing, int reduction, int printout)
 {
-  BITSET save1 = si_opt_1; // save current options
+  // 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
+    // no reduced Groebner basis
+    si_opt_1 &= (~Sy_bit(OPT_REDSB));
+    // not tail reductions
+    //si_opt_1 &= (~Sy_bit(OPT_REDTAIL));
   }
   Set_Error(FALSE);
@@ -5166 +5056 @@
   to = clock();
 #endif
-     if(orig_M->length() == nV)
-      {
-        newRing = VMrDefault(curr_weight); // define a new ring with ordering "(a(curr_weight),lp)
-      }
-      else
-      {
-        newRing = VMatrDefault(orig_M);
-      }
+  if(orig_M->length() == nV)
+  {
+    // define a new ring with ordering "(a(curr_weight),lp)
+    newRing = VMrDefault(curr_weight);
+  }
+  else
+  {
+    newRing = VMatrDefault(orig_M);
+  }
   rChangeCurrRing(newRing);
   ideal G = MstdCC(idrMoveR(Go,baseRing,currRing));
@@ -5195 +5086 @@
     }
 //#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
+    //time for computing initial form ideal
+    tif = tif + clock()-to;
 #endif
 //#ifdef CHECK_IDEAL_MWALK
@@ -5219 +5112 @@
       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
@@ -5230 +5124 @@
      if(target_M->length() == nV)
      {
-       newRing = VMrRefine(curr_weight,target_weight); //define a new ring with ordering "(a(curr_weight),Wp(target_weight))"
+       //define a new ring with ordering "(a(curr_weight),Wp(target_weight))"
+       newRing = VMrRefine(curr_weight,target_weight);
      }
      else
      {
+       //define a new ring with matrix ordering
        newRing = VMatrRefine(target_M,curr_weight);
      }
@@ -5269 +5165 @@
     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
@@ -5289 +5186 @@
     to = clock();
 #endif
-    //G = kStd(F1,NULL,testHomog,NULL,NULL,0,0,NULL);
+
 #ifdef TIME_TEST
     tstd = tstd + clock() - to;
@@ -5313 +5210 @@
     }
 //#endif
-    if(MivComp(next_weight, ivNull) == 1 || MivComp(target_weight,curr_weight) == 1)// || test_w_in_ConeCC(G, target_weight) == 1
-    {
-#ifdef CHECK_IDEAL_MWALK
-      PrintS("\n//** Mwalk: entering last cone.\n");
-#endif
+    if(MivComp(next_weight, ivNull) == 1 || MivComp(target_weight,curr_weight) == 1 || test_w_in_ConeCC(G, target_weight) == 1)
+    {
+//#ifdef CHECK_IDEAL_MWALK
+      if(printout > 0)
+      {
+        PrintS("\n//** Mwalk: entering last cone.\n");
+      }
+//#endif
       Gomega = MwalkInitialForm(G, curr_weight); // compute an initial form ideal of <G> w.r.t. "curr_vector"
       if(target_M->length() == nV)
@@ -5366 +5266 @@
       to = clock();
 #endif
-//   if(si_opt_1 == (Sy_bit(OPT_REDSB))){
-      G = kInterRedCC(G,NULL); //interreduce the Groebner basis <G> w.r.t. currRing
-//  }
+      //interreduce the Groebner basis <G> w.r.t. currRing
+      G = kInterRedCC(G,NULL);
 #ifdef TIME_TEST
       tred = tred + clock() - to;
@@ -5386 +5285 @@
   ideal result = idrMoveR(G,baseRing,currRing);
   idDelete(&G);
-/*#ifdef CHECK_IDEAL_MWALK
-  pDelete(&p);
-#endif*/
   delete tmp_weight;
   delete ivNull;
@@ -5404 +5300 @@
 }
 
-// 07.11.2012
 // THE RANDOM WALK ALGORITHM
 ideal Mrwalk(ideal Go, intvec* orig_M, intvec* target_M, int weight_rad, int pert_deg,
@@ -6651 +6546 @@
  * Perturb the start weight vector at the top level, i.e. nlev = 1     *
  ***********************************************************************/
-static ideal rec_fractal_call(ideal G, int nlev, intvec* omtmp)
+static ideal rec_fractal_call(ideal G, int nlev, intvec* ivtarget, int printout)
 {
   Overflow_Error =  FALSE;
@@ -6668 +6563 @@
   intvec* next_vect;
   intvec* omega2 = new intvec(nV);
+  intvec* omtmp = new intvec(nV);
   intvec* altomega = new intvec(nV);
 
+  for(i = nV -1; i>0; i--)
+  {
+    (*omtmp)[i] = (*ivtarget)[i];
+  }
   //BOOLEAN isnewtarget = FALSE;
 
@@ -6710 +6610 @@
     NEXT_VECTOR_FRACTAL:
     to=clock();
-    /* determine the next border */
+    // determine the next border
     next_vect = MkInterRedNextWeight(omega,omega2,G);
     xtnw=xtnw+clock()-to;
-#ifdef PRINT_VECTORS
-    MivString(omega, omega2, next_vect);
-#endif
+
     oRing = currRing;
 
-    /* We only perturb the current target vector at the recursion  level 1 */
+    // We only perturb the current target vector at the recursion  level 1
     if(Xngleich == 0 && nlev == 1) //(ngleich == 0) important, e.g. ex2, ex3
       if (MivComp(next_vect, omega2) == 1)
       {
-        /* to dispense with taking initial (and lifting/interreducing
-           after the call of recursion */
-        //Print("\n\n// ** Perturb the both vectors with degree %d with",nlev);
-        //idElements(G, "G");
+        // to dispense with taking initial (and lifting/interreducing
+        // after the call of recursion
+        if(printout > 0)
+        {
+          Print("\n//** rec_fractal_call: Perturb the both vectors with degree %d.",nlev);
+          //idElements(G, "G");
+        }
 
         Xngleich = 1;
         nlev +=1;
 
-        if (rParameter(currRing) != NULL)
-          DefRingPar(omtmp);
+        if(ivtarget->length() == nV)
+        {
+          if (rParameter(currRing) != NULL)
+            DefRingPar(omtmp);
+          else
+            rChangeCurrRing(VMrDefault(omtmp));
+        }
         else
-          rChangeCurrRing(VMrDefault1(omtmp));
-
+        {
+          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);
@@ -6763 +6678 @@
         next_vect = MkInterRedNextWeight(omega,omega2,G);
         xtnw=xtnw+clock()-to;
-
-#ifdef PRINT_VECTORS
+      }
+//#ifdef PRINT_VECTORS
+      if(printout > 0)
+      {
         MivString(omega, omega2, next_vect);
-#endif
-      }
-
+      }
+//#endif
 
     /* check whether the the computed vector is in the correct cone */
@@ -6777 +6693 @@
     {
       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));
+        rChangeCurrRing(VMatrDefault(ivtarget));
       }
 #ifdef TEST_OVERFLOW
@@ -6789 +6708 @@
       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);
@@ -6799 +6721 @@
       delete omega2;
       delete altomega;
-
-      //Print("\n// Leaving the %d-th recursion with %d steps", nlev, nwalks);
-      //Print("  ** Overflow_Error? (%d)", Overflow_Error);
+      if(printout > 0)
+      {
+        Print("\n//** rec_fractal_call: Leaving the %d-th recursion with %d steps.\n",
+              nlev, nwalks);
+        //Print(" ** Overflow_Error? (%d)", Overflow_Error);
+      }
+
       nnflow ++;
 
@@ -6818 +6744 @@
     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));
+      {
+        rChangeCurrRing(VMatrDefault(ivtarget));
+      }
 
       testring = currRing;
@@ -6830 +6763 @@
         delete next_vect;
         delete altomega;
-        //Print("\n// Leaving the %d-th recursion with %d steps ",nlev, nwalks);
-        //Print(" ** Overflow_Error? (%d)", Overflow_Error);
-
+        if(printout > 0)
+        {
+          Print("\n//** rec_fractal_call: Leaving the %d-th recursion with %d steps.\n",
+              nlev, nwalks);
+          //Print(" ** Overflow_Error? (%d)", Overflow_Error);
+        }
         return (Gt);
       }
@@ -6843 +6779 @@
         //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)
@@ -6871 +6815 @@
 
       FRACTAL_MSTDCC:
-        //Print("\n//  apply BB-Alg in ring = %s;", rString(currRing));
+        if(printout > 0)
+        {
+          Print("\n//** rec_fractal_call: apply Buchberger's algorithm in ring = %s.\n",
+                rString(currRing));
+        }
         to=clock();
         G = MstdCC(Gt);
@@ -6879 +6827 @@
 
         // 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));
-
+        {
+          rChangeCurrRing(VMatrRefine(ivtarget,Xivinput));
+        }
         testring = currRing;
         Gt = idrMoveR(G, oRing,currRing);
@@ -6902 +6856 @@
         delete next_vect;
         delete altomega;
-        /*
-          Print("\n// Leaving the %d-th recursion with %d steps,", nlev,nwalks);
-          Print(" ** Overflow_Error? (%d)", Overflow_Error);
-        */
+        if(printout > 0)
+        {
+          Print("\n//** rec_fractal_call: Leaving the %d-th recursion with %d steps.\n",
+              nlev, nwalks);
+          //Print(" ** Overflow_Error? (%d)", Overflow_Error);
+        }
         if(Overflow_Error == TRUE)
           nnflow ++;
@@ -6924 +6880 @@
     Gomega = MwalkInitialForm(G, omega);
     xtif=xtif+clock()-to;
-
+    if(printout > 1)
+    {
+      idString(Gomega,"//** rec_fractal_call: Gomega");
+    }
 #ifndef  BUCHBERGER_ALG
     if(isNolVector(omega) == 0)
@@ -6931 +6890 @@
       hilb_func = hFirstSeries(Gomega,NULL,NULL,last_omega,currRing);
 #endif // BUCHBERGER_ALG
-
-    if (rParameter(currRing) != NULL)
-      DefRingPar(omega);
+    if(ivtarget->length() == nV)
+    {
+      if (rParameter(currRing) != NULL)
+        DefRingPar(omega);
+      else
+        rChangeCurrRing(VMrDefault(omega));
+    }
     else
-      rChangeCurrRing(VMrDefault1(omega));
-
+    {
+      rChangeCurrRing(VMatrRefine(ivtarget,omega));
+    }
     Gomega1 = idrMoveR(Gomega, oRing,currRing);
 
-    /* Maximal recursion depth, to compute a red. GB */
-    /* Fractal walk with the alternative recursion */
-    /* alternative recursion */
+    // Maximal recursion depth, to compute a red. GB
+    // Fractal walk with the alternative recursion
+    // alternative recursion
     // if(nlev == nV || lengthpoly(Gomega1) == 0)
     if(nlev == Xnlev || lengthpoly(Gomega1) == 0)
       //if(nlev == nV) // blind recursion
     {
-      /*
-      if(Xnlev != nV)
-      {
-        Print("\n// ** Xnlev = %d", Xnlev);
-        ivString(Xtau, "Xtau");
-      }
-      */
       to=clock();
 #ifdef  BUCHBERGER_ALG
@@ -6962 +6919 @@
       xtstd=xtstd+clock()-to;
     }
-    else {
+    else
+    {
       rChangeCurrRing(oRing);
       Gomega1 = idrMoveR(Gomega1, oRing,currRing);
-      Gresult = rec_fractal_call(idCopy(Gomega1),nlev+1,omega);
-    }
-
-    //convert a Groebner basis from a ring to another ring,
+      Gresult = rec_fractal_call(idCopy(Gomega1),nlev+1,omega,printout);
+    }
+    if(printout > 2)
+    {
+      idString(Gresult,"//** rec_fractal_call: M");
+    }
+    //convert a Groebner basis from a ring to another ring
     new_ring = currRing;
 
@@ -6976 +6937 @@
 
     to=clock();
-    /* Lifting process */
+    // Lifting process
     F = MLifttwoIdeal(Gomega2, Gresult1, G);
     xtlift=xtlift+clock()-to;
+    if(printout > 2)
+    {
+      idString(F,"//** rec_fractal_call: F");
+    }
     idDelete(&Gresult1);
     idDelete(&Gomega2);
@@ -6997 +6962 @@
  * Perturb the start weight vector at the top level with random element *
  ************************************************************************/
-static ideal rec_r_fractal_call(ideal G, int nlev, intvec* omtmp, int weight_rad)
+static ideal rec_r_fractal_call(ideal G, int nlev, intvec* ivtarget,
+                int weight_rad, int printout)
 {
   Overflow_Error =  FALSE;
   //Print("\n\n// Entering the %d-th recursion:", nlev);
 
-  int i, nV = currRing->N;
+  int i, polylength, nV = currRing->N;
   ring new_ring, testring;
   //ring extoRing;
@@ -7014 +6980 @@
   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);
@@ -7057 +7028 @@
     to=clock();
     /* determine the next border */
-    next_vect = MWalkRandomNextWeight(G, omega,omega2, weight_rad, 1+nlev);
-    if(isNolVector(next_vect))
-    {
-      next_vect = MkInterRedNextWeight(omega,omega2,G);
+    next_vect = MkInterRedNextWeight(omega,omega2,G);
+    if(polylength > 0)
+    {
+      //there is a polynomial in Gomega with at least 3 monomials,
+      //low-dimensional facet of the cone
+      delete next_vect;
+      next_vect = MWalkRandomNextWeight(G,omega,omega2,weight_rad,1+nlev);
+      if(isNolVector(next_vect))
+      {
+        delete next_vect;
+        next_vect = MkInterRedNextWeight(omega,omega2,G);
+      }
     }
     xtnw=xtnw+clock()-to;
-#ifdef PRINT_VECTORS
-    MivString(omega, omega2, next_vect);
-#endif
+
     oRing = currRing;
 
-    /* We only perturb the current target vector at the recursion  level 1 */
+    // We only perturb the current target vector at the recursion  level 1
     if(Xngleich == 0 && nlev == 1) //(ngleich == 0) important, e.g. ex2, ex3
       if (MivComp(next_vect, omega2) == 1)
       {
-        /* to dispense with taking initial (and lifting/interreducing
-           after the call of recursion */
-        //Print("\n\n// ** Perturb the both vectors with degree %d with",nlev);
-        //idElements(G, "G");
-
+        // to dispense with taking initials and lifting/interreducing
+        // after the call of recursion.
+        if(printout > 0)
+        {
+          Print("\n//** rec_r_fractal_call: Perturb the both vectors with degree %d.",nlev);
+          //idElements(G, "G");
+        }
         Xngleich = 1;
         nlev +=1;
-
-        if (rParameter(currRing) != NULL)
-          DefRingPar(omtmp);
+        if(ivtarget->length() == nV)
+        {
+          if (rParameter(currRing) != NULL)
+            DefRingPar(omtmp);
+          else
+            rChangeCurrRing(VMrDefault(omtmp));
+        }
         else
-          rChangeCurrRing(VMrDefault1(omtmp));
-
+        {
+          rChangeCurrRing(VMatrDefault(ivtarget));
+        }
         testring = currRing;
         Gt = idrMoveR(G, oRing,currRing);
 
-        /* perturb the original target vector w.r.t. the current GB */
-        delete Xtau;
-        Xtau = NewVectorlp(Gt);
+        // perturb the original target vector w.r.t. the current GB
+        if(ivtarget->length() == nV)
+        {
+          delete Xtau;
+          Xtau = NewVectorlp(Gt);
+        }
+        else
+        {
+          delete Xtau;
+          Xtau = Mfpertvector(Gt,ivtarget);
+        }
 
         rChangeCurrRing(oRing);
-        G = idrMoveR(Gt, testring,currRing);
-
-        /* perturb the current vector w.r.t. the current GB */
+        G = idrMoveR(Gt,testring,currRing);
+
+        // perturb the current vector w.r.t. the current GB
         Mwlp = MivWeightOrderlp(omega);
+        if(ivtarget->length() > nV)
+        {
+          delete Mwlp;
+          Mwlp = MivMatrixOrderRefine(omega,ivtarget);
+        }
         Xsigma = Mfpertvector(G, Mwlp);
         delete Mwlp;
@@ -7112 +7109 @@
 
         next_vect = MkInterRedNextWeight(omega,omega2,G);
+        if(polylength > 0)
+        {
+          //there is a polynomial in Gomega with at least 3 monomials,
+          //low-dimensional facet of the cone
+          delete next_vect;
+          next_vect = MWalkRandomNextWeight(G,omega,omega2,weight_rad,1+nlev);
+          if(isNolVector(next_vect))
+          {
+            delete next_vect;
+            next_vect = MkInterRedNextWeight(omega,omega2,G);
+          }
+        }
         xtnw=xtnw+clock()-to;
-
-#ifdef PRINT_VECTORS
+      }
+//#ifdef PRINT_VECTORS
+      if(printout > 0)
+      {
         MivString(omega, omega2, next_vect);
-#endif
-      }
-
-
-    /* check whether the the computed vector is in the correct cone */
-    /* If no, the reduced GB of an omega-homogeneous ideal will be
+      }
+//#endif
+
+    /* check whether the the computed vector is in the correct cone
+       If no, the reduced GB of an omega-homogeneous ideal will be
        computed by Buchberger algorithm and stop this recursion step*/
     //if(test_w_in_ConeCC(G, next_vect) != 1) //e.g. Example s7, cyc6
@@ -7127 +7137 @@
     {
       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));
+        rChangeCurrRing(VMatrDefault(ivtarget));
       }
 #ifdef TEST_OVERFLOW
       Gt = idrMoveR(G, oRing,currRing);
-      Gt = NULL; return(Gt);
-#endif
-
-      //Print("\n\n// apply BB's alg. in ring r = %s;", rString(currRing));
+      Gt = NULL;
+      return(Gt);
+#endif
+      if(printout > 0)
+      {
+        Print("\n//** rec_r_fractal_call: applying Buchberger's algorithm in ring r = %s;",
+              rString(currRing));
+      }
       to=clock();
       Gt = idrMoveR(G, oRing,currRing);
@@ -7149 +7170 @@
       delete omega2;
       delete altomega;
-
-      //Print("\n// Leaving the %d-th recursion with %d steps", nlev, nwalks);
-      //Print("  ** Overflow_Error? (%d)", Overflow_Error);
+      if(printout > 0)
+      {
+        Print("\n//** rec_r_fractal_call: Leaving the %d-th recursion with %d steps.\n",
+              nlev, nwalks);
+        //Print(" ** Overflow_Error? (%d)", Overflow_Error);
+      }
       nnflow ++;
-
       Overflow_Error = FALSE;
       return (G1);
     }
-
-
-    /* If the perturbed target vector stays in the correct cone,
-       return the current GB,
-       otherwise, return the computed  GB by the Buchberger-algorithm.
-       Then we update the perturbed target vectors w.r.t. this GB. */
-
-    /* the computed vector is equal to the origin vector, since
-       t is not defined */
+    /*
+       If the perturbed target vector stays in the correct cone,
+       return the current Groebner basis.
+       Otherwise, return the Groebner basis computed with Buchberger's
+       algorithm.
+       Then we update the perturbed target vectors w.r.t. this GB.
+    */
     if (MivComp(next_vect, XivNull) == 1)
     {
-      if (rParameter(currRing) != NULL)
-        DefRingPar(omtmp);
+      // The computed vector is equal to the origin vector,
+      // because t is not defined
+      if(ivtarget->length() == nV)
+      {
+        if (rParameter(currRing) != NULL)
+          DefRingPar(omtmp);
+        else
+          rChangeCurrRing(VMrDefault(omtmp));
+      }
       else
-        rChangeCurrRing(VMrDefault1(omtmp));
-
+      {
+        rChangeCurrRing(VMatrDefault(ivtarget));
+      }
       testring = currRing;
       Gt = idrMoveR(G, oRing,currRing);
 
-      if(test_w_in_ConeCC(Gt, omega2) == 1) {
+      if(test_w_in_ConeCC(Gt, omega2) == 1)
+      {
         delete omega2;
         delete next_vect;
         delete altomega;
-        //Print("\n// Leaving the %d-th recursion with %d steps ",nlev, nwalks);
-        //Print(" ** Overflow_Error? (%d)", Overflow_Error);
-
+        if(printout > 0)
+        {
+          Print("\n//** rec_r_fractal_call: Leaving the %d-th recursion with %d steps.\n",
+                nlev, nwalks);
+          //Print(" ** Overflow_Error? (%d)", Overflow_Error);
+        }
         return (Gt);
       }
       else
-      {
-        //ivString(omega2, "tau'");
-        //Print("\n//  tau' doesn't stay in the correct cone!!");
-
+      { 
+        if(printout > 0)
+        {
+          Print("\n//** rec_r_fractal_call: target weight doesn't stay in the correct cone.\n");
+        }
 #ifndef  MSTDCC_FRACTAL
-        //07.08.03
         //ivString(Xtau, "old Xtau");
-        intvec* Xtautmp = Mfpertvector(Gt, MivMatrixOrder(omtmp));
+        intvec* Xtautmp;
+        if(ivtarget->length() == nV)
+        {
+          Xtautmp = Mfpertvector(Gt, MivMatrixOrder(omtmp));
+        }
+        else
+        {
+          Xtautmp = Mfpertvector(Gt, ivtarget);
+        }
 #ifdef TEST_OVERFLOW
       if(Overflow_Error == TRUE)
@@ -7221 +7262 @@
 
       FRACTAL_MSTDCC:
-        //Print("\n//  apply BB-Alg in ring = %s;", rString(currRing));
+        if(printout > 0)
+        {
+          Print("\n//** rec_r_fractal_call: apply Buchberge's algorithm in ring = %s.\n",
+                rString(currRing));
+        }
         to=clock();
         G = MstdCC(Gt);
@@ -7229 +7274 @@
 
         // 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));
-
+        {
+          rChangeCurrRing(VMatrRefine(ivtarget,Xivinput));
+        }
         testring = currRing;
         Gt = idrMoveR(G, oRing,currRing);
@@ -7252 +7303 @@
         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 ++;
@@ -7271 +7324 @@
 
     to=clock();
-    /* Take the initial form of <G> w.r.t. omega */
+    // Take the initial form of <G> w.r.t. omega
     Gomega = MwalkInitialForm(G, omega);
     xtif=xtif+clock()-to;
-
+    //polylength = 1 if there is a polynomial in Gomega with at least 3 monomials and 0 otherwise
+    polylength = lengthpoly(Gomega);
+    if(printout > 1)
+    {
+      idString(Gomega,"//** rec_r_fractal_call: Gomega");
+    }
 #ifndef  BUCHBERGER_ALG
     if(isNolVector(omega) == 0)
@@ -7280 +7338 @@
     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));
-
+    {
+      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
@@ -7309 +7363 @@
       Gresult =kStd(Gomega1,NULL,isHomog,NULL,hilb_func,0,NULL,omega);
       delete hilb_func;
-#endif // BUCHBERGER_ALG
+#endif
       xtstd=xtstd+clock()-to;
     }
-    else {
+    else
+    {
       rChangeCurrRing(oRing);
       Gomega1 = idrMoveR(Gomega1, oRing,currRing);
-      Gresult = rec_fractal_call(idCopy(Gomega1),nlev+1,omega);
-    }
-
-    //convert a Groebner basis from a ring to another ring,
+      Gresult = rec_fractal_call(idCopy(Gomega1),nlev+1,omega,printout);
+    }
+    if(printout > 2)
+    {
+      idString(Gresult,"//** rec_r_fractal_call: M");
+    }
+    //convert a Groebner basis from a ring to another ring
     new_ring = currRing;
 
@@ -7326 +7384 @@
 
     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);
@@ -7337 +7401 @@
 
     to=clock();
-    /* Interreduce G */
+    // Interreduce G
     G = kInterRedCC(F1, NULL);
     xtred=xtred+clock()-to;
@@ -7343 +7407 @@
   }
 }
-
-
 
 
@@ -7351 +7413 @@
  *                                                                             *
  * 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, int reduction)
+ideal Mfwalk(ideal G, intvec* ivstart, intvec* ivtarget,
+             int reduction, int printout)
 {
   BITSET save1 = si_opt_1; // save current options
@@ -7363 +7426 @@
     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);
@@ -7399 +7461 @@
       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);
@@ -7420 +7488 @@
   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));
-
-    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);
   }
@@ -7450 +7528 @@
   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));
+  {
+    rChangeCurrRing(VMatrDefault(ivstart));
+  }
 
   I = idrMoveR(I1,tRing,currRing);
@@ -7465 +7549 @@
   ring helpRing = currRing;
 
-  J = rec_fractal_call(J, 1, ivtarget);
+  J = rec_fractal_call(J,1,ivtarget,printout);
 
   rChangeCurrRing(oldRing);
@@ -7495 +7579 @@
  * The main procedur Mfwalk calls the recursive Subroutine                     *
  * rec_r_fractal_call to compute the wanted Groebner basis.                    *
- * At the main procedur we compute the reduced Groebner basis w.r.t. a "fast"  *
+ * 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 weight_rad, int reduction, int printout)
 {
   BITSET save1 = si_opt_1; // save current options
@@ -7542 +7626 @@
       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);
@@ -7563 +7653 @@
   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));
-
-    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);
   }
@@ -7593 +7693 @@
   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));
+  {
+    rChangeCurrRing(VMatrDefault(ivstart));
+  }
 
   I = idrMoveR(I1,tRing,currRing);
@@ -7608 +7714 @@
   ring helpRing = currRing;
 
-  J = rec_r_fractal_call(J, 1, ivtarget,weight_rad);
+  J = rec_r_fractal_call(J,1,ivtarget,weight_rad,printout);
 
   rChangeCurrRing(oldRing);

Singular/walk.h

@@ -68 +68 @@
 
 /* The fractal walk algorithm */
-ideal Mfwalk(ideal G, intvec* ivstart, intvec* ivtarget, int reduction);
+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, int reduction);
+ideal Mfrwalk(ideal G, intvec* ivstart, intvec* ivtarget, int weight_rad, int reduction, int printout);
 
 /* Implement Tran's idea */