Changeset 4d2ab5c in git

Timestamp:

Feb 23, 2008, 9:12:53 PM (15 years ago)

Author:

Viktor Levandovskyy <levandov@…>

Branches:

(u'spielwiese', '0d6b7fcd9813a1ca1ed4220cfa2b104b97a0a003')

Children:

51e69e6599c603806d7fea8cc97d5e9f1bec09e9

Parents:

8c35baa560440cca9bb7bbb44be0232fce1c79c9

Message:

*levandov: major update in freegb impl


git-svn-id: file:///usr/local/Singular/svn/trunk@10602 2c84dea3-7e68-4137-9b89-c4e89433aadc

Location:

kernel

Files:

• kstd2.cc (modified) (3 diffs)
• kutil.cc (modified) (27 diffs)
• kutil.h (modified) (3 diffs)
• shiftgb.cc (modified) (10 diffs)
• shiftgb.h (modified) (3 diffs)

kernel/kstd2.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: kstd2.cc,v 1.61 2008-02-15 17:14:21 levandov Exp $ */
+/* $Id: kstd2.cc,v 1.62 2008-02-23 20:12:51 levandov Exp $ */
 /*
 *  ABSTRACT -  Kernel: alg. of Buchberger
@@ -1600 +1600 @@
       //        enterT(strat->P, strat); // this was here before Shift stuff
       //enterTShift(LObject p, kStrategy strat, int atT, int uptodeg, int lV); // syntax
-      // the default value for atT = -1
+      // the default value for atT = -1 as in bba
+      strat->P.GetP(); // because shifts are counted with .p structure
       enterTShift(strat->P,strat,-1,uptodeg, lV);
+//       poly vw;
+//       if (strat->P.t_p!=NULL)
+//       {
+//          vw = pCopyL2p(strat->P,strat);      
+//       }
+//       else
+//       {
+//          vw = pCopy(strat->P.p);
+//       }
       enterpairsShift(strat->P.p,strat->sl,strat->P.ecart,pos,strat, strat->tl,uptodeg,lV);
+      //      enterpairsShift(vw,strat->sl,strat->P.ecart,pos,strat, strat->tl,uptodeg,lV);
+      // delete vw ?
       // posInS only depends on the leading term
       if ((!TEST_OPT_IDLIFT) || (pGetComp(strat->P.p) <= strat->syzComp))
@@ -1693 +1705 @@
   */
   ideal RS = bbaShift(I,NULL, NULL, NULL, strat, uptodeg, lVblock);
+  idSkipZeroes(RS);
   return(RS);
 }

kernel/kutil.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: kutil.cc,v 1.84 2008-02-15 17:14:22 levandov Exp $ */
+/* $Id: kutil.cc,v 1.85 2008-02-23 20:12:52 levandov Exp $ */
 /*
 * ABSTRACT: kernel: utils for kStd
@@ -53 +53 @@
 /* shiftgb stuff */
 #include "shiftgb.h"
+#include "prCopy.h"
 
 #ifdef KDEBUG
@@ -5674 +5675 @@
 {
   assume(L->p1 != NULL && L->p2 != NULL);
-  assume(L->i_r1 >= 0 && L->i_r1 <= strat->tl);
-  assume(L->i_r2 >= 0 && L->i_r2 <= strat->tl);
+  // shift changes: from 0 to -1
+  assume(L->i_r1 >= -1 && L->i_r1 <= strat->tl);
+  assume(L->i_r2 >= -1 && L->i_r2 <= strat->tl);
   assume(strat->tailRing != currRing);
 
   if (! k_GetLeadTerms(L->p1, L->p2, currRing, m1, m2, strat->tailRing))
     return FALSE;
+  // shift changes: extra case inserted
+  if ((L->i_r1 == -1) || (L->i_r2 == -1) )
+  {
+    return TRUE;
+  }
   poly p1_max = (strat->R[L->i_r1])->max;
   poly p2_max = (strat->R[L->i_r2])->max;
@@ -6010 +6017 @@
 
 #ifdef HAVE_PLURAL
-/* including the self pairs? */
-
+
+poly pMove2CurrTail(poly p, kStrategy strat)
+{
+  /* assume: p is completely in currRing */
+  /* produces an object with LM in curring 
+     and TAIL in tailring */
+  if (pNext(p)!=NULL)
+  {
+    pNext(p) = prMoveR(pNext(p), /* src */ currRing, /* dest */ strat->tailRing);
+  }
+  return(p);
+}
+
+poly pMoveCurrTail2poly(poly p, kStrategy strat)
+{
+  /* assume: p has  LM in curring and TAIL in tailring */
+  /* convert it to complete currRing */
+
+  /* check that LM is in currRing */
+  assume(p_LmCheckIsFromRing(p, currRing));
+
+  if (pNext(p)!=NULL)
+  {
+    pNext(p) = prMoveR(pNext(p), /* src */ strat->tailRing, /* dest */currRing);
+  }
+  return(p);
+}
+
+poly pCopyL2p(LObject H, kStrategy strat)
+{
+    /* restores a poly in currRing from LObject */
+    LObject h = H;
+    h.Copy();
+    poly p;
+    if (h.p == NULL)
+    {
+      if (h.t_p != NULL)
+      {
+         p = prMoveR(h.t_p, /* source ring: */ strat->tailRing, /* dest. ring: */ currRing);
+        return(p);
+      }
+      else
+      {
+        /* h.tp == NULL -> the object is NULL */
+        return(NULL);
+      }
+    }
+    /* we're here if h.p != NULL */
+    if (h.t_p == NULL)
+    {
+       /* then h.p is the whole poly in currRing */
+       p = h.p;
+      return(p);
+    }
+    /* we're here if h.p != NULL and h.t_p != NULL */
+    // clean h.p, get poly from t_p
+     pNext(h.p)=NULL;
+     pDelete(&h.p);
+     p = prMoveR(h.t_p, /* source ring: */ strat->tailRing,
+                         /* dest. ring: */ currRing);
+     // no need to clean h: we re-used the polys
+    return(p);
+}
+
+//LObject pCopyp2L(poly p, kStrategy strat)
+//{
+    /* creates LObject from the poly in currRing */
+  /* actually put p into L.p and make L.t_p=NULL : does not work */
+ 
+//}
+
+// poly pCopyL2p(LObject H, kStrategy strat)
+// {
+//   /* restores a poly in currRing from LObject */
+//   LObject h = H;
+//   h.Copy();
+//   poly p;
+//   if (h.p == NULL)
+//   {
+//     if (h.t_p != NULL)
+//     {
+//       p = p_ShallowCopyDelete(h.t_p, (strat->tailRing != NULL ? strat->tailRing : currRing), strat->tailBin);
+//       return(p);
+//     }
+//     else
+//     {
+//       /* h.tp == NULL -> the object is NULL */
+//       return(NULL);
+//     }
+//   }
+//   /* we're here if h.p != NULL */
+
+//   if (h.t_p == NULL)
+//   {
+//     /* then h.p is the whole poly in tailRing */
+//     if (strat->tailBin != NULL && (pNext(h.p) != NULL))
+//     {
+//       p = p_ShallowCopyDelete(h.p, (strat->tailRing != NULL ? strat->tailRing : currRing), strat->tailBin);
+//     } 
+//     return(p);
+//   }
+//   /* we're here if h.p != NULL and h.t_p != NULL */
+//   p = pCopy(pHead(h.p)); // in currRing
+//   if (strat->tailBin != NULL && (pNext(h.p) != NULL))
+//   {
+//     //    pNext(p) = p_ShallowCopyDelete(pNext(h.t_p), (strat->tailRing != NULL ? strat->tailRing : currRing), strat->tailBin);
+//     poly pp = p_Copy(pNext(h.p), strat->tailRing);
+//     //    poly p3 = p_Copy(pNext(h.p), currRing); // error
+//       // p_ShallowCopyDelete(pNext(h.p), currRing, strat->tailBin); // the same as pp
+//     poly p5 = p_ShallowCopyDelete(pNext(h.p), strat->tailRing, strat->tailBin);
+//     pNext(p) = p_ShallowCopyDelete(h.t_p, strat->tailRing, strat->tailBin);
+//     poly p4 = p_Copy(h.t_p, strat->tailRing);
+//     //    if (p.t_p != NULL) pNext(p.t_p) = pNext(p.p);
+//   }
+//   //  pTest(p);
+//   return(p);
+// }
+
+/* including the self pairs */
 void updateSShift(kStrategy strat,int uptodeg,int lV)
 {
@@ -6022 +6146 @@
   for (i=0; i<=strat->sl; i++)
   {
-    h.p =  strat->S[i];
+    memset(&h,0,sizeof(h));
+    h.p =  strat->S[i]; // lm in currRing, tail in TR
     strat->initEcart(&h);
     h.sev = strat->sevS[i];
+    h.t_p = NULL;
+    h.GetTP(); // creates correct t_p
     /*puts the elements of S with their shifts to T*/
     //    int atT, int uptodeg, int lV)
+    strat->S_2_R[i] = strat->tl + 1; // the el't with shift 0 will be inserted first
+    // need a small check for above; we insert >=1 elements
+    // insert this check into kTest_TS ?
     enterTShift(h,strat,atT,uptodeg,lV);
   }
@@ -6092 +6222 @@
   if (!TEST_OPT_SB_1)
   {
-    /* the only change: do not fill the set T*/
+    /* the only change: we do not fill the set T*/
     updateS(FALSE,strat);
   }
@@ -6101 +6231 @@
 }
 
-// void initBuchMoraShift(ideal F,ideal Q,kStrategy strat)
-// {
-//   initBuchMora(F,Q,strat);
-//   strat->fromT = TRUE;
-// }
-
 /*1
 * put the pairs (sh \dot s[i],p)  into the set B, ecart=ecart(p)
@@ -6112 +6236 @@
 void enterOnePairManyShifts (int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR, int uptodeg, int lV)
 {
-
-  /* should cycle through all shifts of s[i] until uptodeg - lastVblock(s[i]) */
+  /* p comes from strat->P.p, that is LObject with LM in currRing and Tail in tailRing */
+
+  assume(p_LmCheckIsFromRing(p,currRing));
+  assume(p_CheckIsFromRing(pNext(p),strat->tailRing));
+
+  /* cycles through all shifts of s[i] until uptodeg - lastVblock(s[i]) */
   /* that is create the pairs (f, s \dot g)  */
 
-  poly q;
-  q = pCopy(strat->S[i]); // zero shift
+  poly qq = strat->S[i]; // previously thought and now again: lm in currRing, tail in tailRing
+// elt's of S are compl. in currRing 
+// previously thought: lm in currRing, tail in tailRing
+
+  //  poly q = pCopy(pHead(strat->S[i])); // lm in currRing
+  //  pNext(q) = prCopyR(pNext(strat->S[i]),strat->tailRing,currRing); // zero shift
 
  /* determine how many elements we have to insert for a given s[i] */
@@ -6123 +6255 @@
   /* hence, a total number of elt's to add is: */
   /*  int toInsert = 1 + (uptodeg-1) - (pLastVblock(p.p, lV) -1);  */
-  int toInsert = uptodeg  - pLastVblock(q, lV) +1; 
+  //  int toInsert = uptodeg  - pLastVblock(q, lV) +1; 
+  int toInsert =  itoInsert(qq, uptodeg,  lV, strat->tailRing);
+
+#ifdef KDEBUG
+    if (TEST_OPT_DEBUG)
+    {
+      Print("entered ManyShifts: with toInsert=%d",toInsert); PrintLn();
+    }
+#endif
 
   assume(i<=strat->sl); // from OnePair
@@ -6130 +6270 @@
   /* these vars hold for all shifts of s[i] */
   int ecartq = 0; //Hans says it's ok; we're in the homog case, no ecart
-  int qfromQ = strat->fromQ[i]; 
+  
+  int qfromQ;
+  if (strat->fromQ != NULL)
+  {
+    qfromQ = strat->fromQ[i]; 
+  }
+  else
+  {
+    qfromQ = -1;
+  }
 
   int j;
 
-  for (j=1; j<= toInsert -1; j++)
+  poly q, s;
+
+  // for the 0th shift: insert the orig. pair
+
+  enterOnePairShift(qq, p, ecart, isFromQ, strat, -1, ecartq, qfromQ, j, i, uptodeg, lV);
+
+  for (j=1; j<= toInsert; j++) // toIns - 1?
   {
     //    q = pLPshift(strat->S[i],j,uptodeg,lV);
-    /* we increase shifts by one; must delete q there*/
-    q = pLPshift(q,1,uptodeg,lV);
+    q = p_LPshiftT(qq, j, uptodeg, lV, strat, currRing); 
+    //    q = p_mLPshift(qq,j,uptodeg,lV,currRing); // lm in currRing, shift this monomial
+    //    s = p_LPshift(pNext(qq), j, uptodeg, lV, strat->tailRing); // from tailRing
+    //    pNext(q) = s; // in tailRing
+    //    qq = pLPshift(q,j,uptodeg,lV); // need move
+    // ??? no move needed: in currRing
+    //    qq = pMoveCurrTail2poly(qq,strat);
     /* here we need to call enterOnePair with two polys ... */
-    enterOnePairShift(q, p, ecart, isFromQ, strat, -1, ecartq, qfromQ, uptodeg, lV);
-  }
-  /* delete q? */
-  pDelete(&q);
+
+#ifdef KDEBUG
+    if (TEST_OPT_DEBUG)
+    {
+      PrintS("ManyShifts: calling enterOnePairShift(q,p)");
+//       wrp(q); //     wrp(pHead(q));
+//       PrintS(", p = ");
+//       wrp(p); //wrp(pHead(p)); 
+      PrintLn();
+    }
+#endif
+    enterOnePairShift(q, p, ecart, isFromQ, strat, -1, ecartq, qfromQ, j, i, uptodeg, lV);
+  }
+  /* delete qq */
+  //  pDelete(&qq);
 }
 
@@ -6151 +6322 @@
 void enterOnePairSelfShifts (poly qq, poly p, int ecart, int isFromQ, kStrategy strat, int atR, int uptodeg, int lV)
 {
+
+  /* format: p,qq are in LObject form: lm in CR, tail in TR */
+  /* for true self pairs qq ==p  */
+  /* we test both */
+  assume(p_LmCheckIsFromRing(qq,currRing));
+  assume(p_CheckIsFromRing(pNext(qq),strat->tailRing));
+  assume(p_LmCheckIsFromRing(p,currRing));
+  assume(p_CheckIsFromRing(pNext(p),strat->tailRing));
+
+  int j = 0;
+
+  /* for such pairs start with 1, not with 0 */
+  if (qq == p) j=1;
 
   /* should cycle through all shifts of q until uptodeg - lastVblock(q) */
@@ -6159 +6343 @@
   /* hence, a total number of elt's to add is: */
   /*  int toInsert = 1 + (uptodeg-1) - (pLastVblock(p.p, lV) -1);  */
-  int toInsert = uptodeg  - pLastVblock(qq, lV) +1; 
+
+  //  poly q = pHead(qq); // lm in currRing
+  //  pNext(q) = prCopyR(pNext(qq), strat->tailRing, currRing);
+  //  pTest(q);
+
+  int toInsert =  itoInsert(qq, uptodeg,  lV, strat->tailRing);
+
+#ifdef KDEBUG
+    if (TEST_OPT_DEBUG)
+    {
+      Print("entered SelfShifts: with toInsert=%d",toInsert); PrintLn();
+    }
+#endif
+
+//   int toInsert = p_mLastVblock(qq, lV,currRing);
+//   if (pNext(qq) != NULL)
+//   {
+//     toInsert = si_max(toInsert, p_LastVblock(pNext(qq), lV,strat->tailRing) );
+//   }
+//   toInsert = uptodeg  - toInsert +1; 
+
+  poly q, s;
 
   //  assume(i<=strat->sl); // from OnePair
@@ -6168 +6373 @@
   int qfromQ = 0; // strat->fromQ[i]; 
 
-  int j;
-  poly q = pCopy(qq);   // q has zero shift
-  for (j=1; j<= toInsert -1; j++)
+  for (; j<= toInsert; j++) // toIns - 1?
   {
     //    q = pLPshift(strat->S[i],j,uptodeg,lV);
     /* we increase shifts by one; must delete q there*/
-    q = pLPshift(q,1,uptodeg,lV);
+    //    q = qq; q = pMoveCurrTail2poly(q,strat);
+    //    q = pLPshift(q,j,uptodeg,lV); //,currRing);
+    q = p_LPshiftT(qq, j, uptodeg, lV, strat, currRing);
+    //    q = p_mLPshift(qq,j,uptodeg,lV,currRing); // lm in currRing, shift this monomial
+    //    s = p_LPshift(pNext(qq), j, uptodeg, lV, strat->tailRing); // from tailRing
+    //    pNext(q) = s; // in tailRing
+    //prMoveR(s,strat->tailRing,currRing); // in currRing
     /* here we need to call enterOnePair with two polys ... */
-    enterOnePairShift(q, p, ecart, isFromQ, strat, -1, ecartq, qfromQ, uptodeg, lV);
+#ifdef KDEBUG
+    if (TEST_OPT_DEBUG)
+    {
+      PrintS("SelfShifts: calling enterOnePairShift(q,p)");
+//       wrp(q); //     wrp(pHead(q));
+//       PrintS(", p = ");
+//       wrp(p); //wrp(pHead(p)); 
+      PrintLn();
+    }
+#endif
+    enterOnePairShift(q, p, ecart, isFromQ, strat, -1, ecartq, qfromQ, j, -1, uptodeg, lV);
   }
   /* delete q? */
-  pDelete(&q);
+  //  pDelete(&q);
 }
 
@@ -6185 +6404 @@
 * put the pair (q,p)  into the set B, ecart=ecart(p), q is the shift of some s[i]
 */
-void enterOnePairShift (poly q, poly p, int ecart, int isFromQ, kStrategy strat, int atR, int ecartq, int qisFromQ, int uptodeg, int lV)
-{
-
+void enterOnePairShift (poly q, poly p, int ecart, int isFromQ, kStrategy strat, int atR, int ecartq, int qisFromQ, int shiftcount, int ifromS, int uptodeg, int lV)
+{
+
+  /* New Format: q and p are like strat->P.p, so lm in CR, tail in TR */
+  /* Format: q is a poly compl. in currRing, p is like strat->P.p, so lm in CR, tail in TR */
+
+  /* check this Formats: */
+  //  assume(p_CheckIsFromRing(q,currRing));
+  assume(p_LmCheckIsFromRing(q,currRing));
+  assume(p_CheckIsFromRing(pNext(q),strat->tailRing));
+  assume(p_LmCheckIsFromRing(p,currRing));
+  assume(p_CheckIsFromRing(pNext(p),strat->tailRing));
+
+#ifdef KDEBUG
+    if (TEST_OPT_DEBUG)
+    {
+      PrintS("enterOnePairShift(q,p) invoked with q = ");
+      wrp(q); //      wrp(pHead(q));
+      PrintS(", p = ");
+      wrp(p); //wrp(pHead(p)); 
+      PrintLn();
+    }
+#endif
+
+  /* indeed we need LM only before real spoly */
   /* poly q stays for s[i], ecartq = ecart(q), qisFromQ = applies to q */
 
@@ -6194 +6435 @@
   /* need additionally: int up_to_degree, poly V0 with the variables in (0)  or just the number lV = the length of the first block */
 
-  atR = -1;
+  //  atR = -1;
   //  assume(i<=strat->sl); // satisfied automatically
   if (strat->interred_flag) return;
@@ -6208 +6449 @@
   Lp.lcm = pInit();
 
-  pLcm(p,q,Lp.lcm);
+  pLcm(p,q, Lp.lcm); // q is what was strat->S[i], so a poly in LM/TR presentation
   pSetm(Lp.lcm);
 
@@ -6219 +6460 @@
     {
       PrintS("V crit applied to q = ");
-      wrp(pHead(q));
+      wrp(q); //      wrp(pHead(q));
       PrintS(", p = ");
-      wrp(pHead(p)); 
+      wrp(p); //wrp(pHead(p)); 
       PrintLn();
     }
@@ -6400 +6641 @@
 //     else
 //     {
-    Lp.p = ksCreateShortSpoly(q,p, strat->tailRing);
+    
+    /* ksCreateShortSpoly needs two Lobject-kind presentations */
+    /* p is already in this form, so convert q */
+    //    q = pMove2CurrTail(q, strat);
+    Lp.p = ksCreateShortSpoly(q, p, strat->tailRing);
       //  }
   }
@@ -6406 +6651 @@
   {
     /*- the case that the s-poly is 0 -*/
-    /* TEMPORARILY DISABLED FOR SHIFTS */
-//     if (strat->pairtest==NULL) initPairtest(strat);
-//     strat->pairtest[i] = TRUE;/*- hint for spoly(S^[i],p)=0 -*/
-//     strat->pairtest[strat->sl+1] = TRUE;
+    /* TEMPORARILY DISABLED FOR SHIFTS because there is no i*/
+//      if (strat->pairtest==NULL) initPairtest(strat);
+//      strat->pairtest[i] = TRUE;/*- hint for spoly(S^[i],p)=0 -*/
+//      strat->pairtest[strat->sl+1] = TRUE;
     /* END _ TEMPORARILY DISABLED FOR SHIFTS */
     /*hint for spoly(S[i],p) == 0 for some i,0 <= i <= sl*/
@@ -6426 +6671 @@
   {
     /*- the pair (S[i],p) enters B -*/
-    Lp.p1 = q;
-    Lp.p2 = p;
+    /* both of them should have their LM in currRing and TAIL in tailring */
+    Lp.p1 = q;  // already converted with pMove2CurrTail(q,strat);
+    Lp.p2 = p; // already in the needed form 
 
     if ( !bIsPluralRing )
       pNext(Lp.p) = strat->tail;
 
-    /* TEMPORARILY DISABLED FOR SHIFTS */
-    /* at the beginning we set atR = -1 */
-//     if (atR >= 0)
-//     {
-      /*      Lp.i_r1 = strat->S_2_R[i]; */
-//       Lp.i_r2 = atR;
-//     }
-//     else
-//     {
-    /* END _ TEMPORARILY DISABLED FOR SHIFTS */
+    /* TEMPORARILY DISABLED FOR SHIFTS because there's no i*/
+    /* at the beginning we DO NOT set atR = -1 ANYMORE*/
+    if ( (atR >= 0) && (shiftcount==0) && (ifromS >=0) )
+    {
+      Lp.i_r1 = kFindInT(Lp.p1,strat); //strat->S_2_R[ifromS]; 
+      Lp.i_r2 = atR;
+    }
+    else
+    {
+      /* END _ TEMPORARILY DISABLED FOR SHIFTS */
       Lp.i_r1 = -1;
       Lp.i_r2 = -1;
-      //    }
+     }
     strat->initEcartPair(&Lp,q,p,ecartq,ecart);
 
@@ -6465 +6711 @@
 void enterpairsShift (poly h,int k,int ecart,int pos,kStrategy strat, int atR,int uptodeg, int lV)
 {
-  /* Q: what is exactly the strat->fromT ? */
+  /* h is strat->P.p, that is LObject with LM in currRing and Tail in tailRing */
+  /* Q: what is exactly the strat->fromT ? A: a local case trick; don't need it yet*/
   int j=pos;
 
@@ -6490 +6737 @@
 
 /*3
-*(s[0],h),...,(s[k],h) will be put to the pairset L
+*(s[0], s \dot h),...,(s[k],s \dot h) will be put to the pairset L
+* also the pairs (h, s\dot s[0]), ..., (h, s\dot s[k]) enter L
 * additionally we put the pairs (h, s \sdot h) for s>=1 to L
 */
 void initenterpairsShift (poly h,int k,int ecart,int isFromQ, kStrategy strat, int atR, int uptodeg, int lV)
 {
-  atR = -1;
+  /* h comes from strat->P.p, that is LObject with LM in currRing and Tail in tailRing */
+  //  atR = -1;
   if ((strat->syzComp==0)
   || (pGetComp(h)<=strat->syzComp))
@@ -6513 +6762 @@
             new_pair=TRUE;
             enterOnePairManyShifts(j,h,ecart,isFromQ,strat, atR,uptodeg,lV);
+            // other side pairs:
+            enterOnePairSelfShifts(h,strat->S[j],ecart,isFromQ,strat, atR,uptodeg,lV);
           //Print("j:%d, Ll:%d\n",j,strat->Ll);
           }
@@ -6523 +6774 @@
         {
           enterOnePairManyShifts(j,h,ecart,isFromQ,strat, atR,uptodeg,lV);
+          // other side pairs
+          enterOnePairSelfShifts(h,strat->S[j],ecart,isFromQ,strat, atR,uptodeg,lV);
         }
         /* HERE we put (h, s*h) pairs */
@@ -6538 +6791 @@
           new_pair=TRUE;
           enterOnePairManyShifts(j,h,ecart,isFromQ,strat, atR, uptodeg, lV);
+          // other side pairs
+          enterOnePairSelfShifts(h,strat->S[j],ecart,isFromQ,strat, atR,uptodeg,lV);
         //Print("j:%d, Ll:%d\n",j,strat->Ll);
         }
       }
-      /* HERE we put (h, s*h) pairs TOO */
+      /* HERE we put (h, s*h) pairs */
       enterOnePairSelfShifts (h, h, ecart, isFromQ, strat, atR, uptodeg, lV);
     }
@@ -6565 +6820 @@
   /*  int toInsert = 1 + (uptodeg-1) - (pLastVblock(p.p, lV) -1);  */
 
-  pp_Test(p.p, currRing, p.tailRing);
-
-  int toInsert = uptodeg  - pLastVblock(pCopy(p.p), lV) +1; 
-
+  //  int toInsert = uptodeg  - pLastVblock(pCopy(p.p), lV) +1; 
+  //  int toInsert = uptodeg  - pLastVblock(p.p, lV) +1; 
+  
+  int toInsert =  itoInsert(p.p, uptodeg,  lV, strat->tailRing);
+
+#ifdef PDEBUG
+  Print("enterTShift uses toInsert: %d", toInsert);  PrintLn();
+#endif
   int i;
 
@@ -6574 +6833 @@
     atT = strat->posInT(strat->T, strat->tl, p);
   
-  LObject q;
-  poly s;
+  //  LObject q;
+  //  poly s;
   /* can call enterT in a sequence, e.g. */
-  for (i=0; i<=toInsert-1; i++)
-  {
-    q = p;
+
+  /* first we create the 0th shift */
+  //  q = p;
+//   if (q.t_p!=NULL)
+//   {
+//     q.p = pHead(s); // in currRing
+//     q.t_p = prMoveR(s, /* sourcering: */currRing, /* destring: */ strat->tailRing);
+//     if (pNext(q.t_p)!=NULL)
+//     {
+//       pNext(q.p)=pNext(q.t_p);
+//     }
+//   }
+//   else
+//   {
+//     q.p=s;
+//   }
+  /* shift0 = it's our model for further shifts */
+  enterT(p,strat,atT);
+  LObject qq;
+  for (i=1; i<=toInsert; i++) // toIns - 1?
+  {
+    qq       = p; //qq.Copy();
+    qq.p    = NULL; 
+    qq.t_p = p_LPshift(p.t_p, i, uptodeg, lV, strat->tailRing); // direct shift
+    qq.GetP();
     /* shift p, that is create another LObject and shift its poly */
     /* change: p.p, p.t_p, */
     /* change: i_r (must be -1 because we're not yet in T ? */
-    q.Copy(); // following
-    /*   pLPshift(poly p, int sh, int uptodeg, int lV); */
-    s = pLPshift(pCopy(q.p), i, uptodeg, lV); // deletes 1st arg, hence pCopy
-    q.p = pCopy(s); pDelete(&s);
-    if (q.t_p != NULL) pNext(q.t_p) = pNext(q.p); // from enterT
-    /* enter it into T */
-    enterT(q,strat,atT+i);
+    //    s = pLPshift(pCopyL2p(q,strat), i, uptodeg, lV); // deletes 1st arg, hence pCopy
+    //    q.p = pLPshift(q.p, 1, uptodeg, lV);
+//       qq.p = pHead(s); // in currRing
+//       qq.t_p = prMoveR(s, /* sourcering: */currRing, /* destring: */ strat->tailRing);
+//       if (pNext(q.t_p)!=NULL)
+//       {
+//         pNext(q.p)=pNext(q.t_p);
+//       }
+//     }
+//     else
+//     {
+//       q.p=s;
+//     }
+    // update q.sev
+    qq.sev = pGetShortExpVector(qq.p);
+    /* enter it into T, first el't is with the shift 0 */
+    // compute the position for qq
+    atT = strat->posInT(strat->T, strat->tl, qq);
+    enterT(qq,strat,atT);
   }
 

kernel/kutil.h

@@ -4 +4 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: kutil.h,v 1.32 2008-02-21 18:20:06 Singular Exp $ */
+/* $Id: kutil.h,v 1.33 2008-02-23 20:12:52 levandov Exp $ */
 /*
 * ABSTRACT: kernel: utils for kStd
@@ -620 +620 @@
 #include "shiftgb.h"
 
+poly pMove2CurrTail(poly p, kStrategy strat);
+
+poly pMoveCurrTail2poly(poly p, kStrategy strat);
+
+poly pCopyL2p(LObject h, kStrategy strat);
+
 void enterTShift(LObject p, kStrategy strat, int atT, int uptodeg, int lV);
 
@@ -628 +634 @@
 void enterOnePairSelfShifts (poly qq, poly p, int ecart, int isFromQ, kStrategy strat, int atR, int uptodeg, int lV);
 
-void enterOnePairShift (poly q, poly p, int ecart, int isFromQ, kStrategy strat, int atR, int ecartq, int qisFromQ, int uptodeg, int lV); // ok
+void enterOnePairShift (poly q, poly p, int ecart, int isFromQ, kStrategy strat, int atR, int ecartq, int qisFromQ, int shiftcount, int ifromS, int uptodeg, int lV); // ok
 
 void enterpairsShift (poly h,int k,int ecart,int pos,kStrategy strat, int atR,int uptodeg, int lV);

kernel/shiftgb.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: shiftgb.cc,v 1.4 2008-02-15 17:14:23 levandov Exp $ */
+/* $Id: shiftgb.cc,v 1.5 2008-02-23 20:12:53 levandov Exp $ */
 /*
 * ABSTRACT: kernel: utils for shift GB and free GB
@@ -39 +39 @@
 #define freeT(A,v) omFreeSize((ADDRESS)A,(v+1)*sizeof(int))
 
-poly pLPshift(poly p, int sh, int uptodeg, int lV)
+
+/* TODO: write p* stuff as instances of p_* for all the functions */
+
+poly p_LPshiftT(poly p, int sh, int uptodeg, int lV, kStrategy strat, const ring r)
+{
+  /* assume shift takes place, shifts the poly p by sh */
+  /* p is like TObject: lm in currRing = r, tail in tailRing  */
+
+  if (p==NULL) return(p);
+
+  assume(p_LmCheckIsFromRing(p,r));
+  assume(p_CheckIsFromRing(pNext(p),strat->tailRing));
+
+  /* assume sh and uptodeg agree */
+
+  if (sh == 0) return(p); /* the zero shift */
+
+  poly q   = NULL;
+  poly s   = p_mLPshift(p, sh, uptodeg, lV, r); // lm in currRing
+  poly pp = pNext(p);
+  
+  while (pp != NULL)
+  {
+    q = p_Add_q(q, p_mLPshift(pp,sh,uptodeg,lV,strat->tailRing),strat->tailRing);
+    pIter(pp);
+  }
+  pNext(s) = q;
+  /* int version: returns TRUE if it was successful */
+  return(s);
+}
+
+
+poly p_LPshift(poly p, int sh, int uptodeg, int lV, const ring r)
 {
   /* assume shift takes place */
@@ -47 +79 @@
   /* assume sh and uptodeg agree */
 
+  if (p==NULL) return(p);
   if (sh == 0) return(p); /* the zero shift */
 
@@ -53 +86 @@
   while (pp!=NULL)
   {
-    q = p_Add_q(q, pmLPshift(pp,sh,uptodeg,lV),currRing);
+    q = p_Add_q(q, p_mLPshift(pp,sh,uptodeg,lV,r),r);
     pIter(pp);
   }
@@ -61 +94 @@
 }
 
+poly p_mLPshift(poly p, int sh, int uptodeg, int lV, const ring r)
+{
+  /* pm is a monomial */
+
+  if (sh == 0) return(p); /* the zero shift */
+
+  if (sh < 0 )
+  {
+#ifdef PDEBUG
+    Print("pmLPshift: negative shift requested");
+#endif
+    return(NULL); /* violation, 2check */
+  }
+
+  int L = p_mLastVblock(p,lV,r);
+  if (L+sh-1 > uptodeg)
+  {
+#ifdef PDEBUG
+    Print("p_mLPshift: too big shift requested");
+#endif
+    return(NULL); /* violation, 2check */
+  }
+  int *e=(int *)omAlloc0((r->N+1)*sizeof(int));
+  int *s=(int *)omAlloc0((r->N+1)*sizeof(int));
+  p_GetExpV(p,e,r);
+  number c = pGetCoeff(p);
+  int j;
+  //  for (j=1; j<=r->N; j++) 
+  // L*lV gives the last position of the last block
+  for (j=1; j<= L*lV ; j++)
+  {
+    if (e[j]==1)
+    {
+      s[j + (sh*lV)] = e[j]; /* actually 1 */
+      omCheckAddr(s);
+    }
+    else 
+    {
+      if (e[j]!=0)
+      {
+#ifdef PDEBUG
+         Print("p_mLPshift: ex[%d]=%d\n",j,e[j]);
+#endif
+      }
+    }
+  }
+  poly m = p_ISet(1,r);
+  p_SetExpV(m,s,r);
+  /*  pSetm(m); */ /* done in the pSetExpV */
+  /* think on the component */
+  pSetCoeff0(m,c);
+  freeT(e, r->N);
+  freeT(s, r->N);
+  return(m);
+}
+
+poly pLPshift(poly p, int sh, int uptodeg, int lV)
+{
+  /* assume shift takes place */
+  /* shifts the poly p by sh */
+  /* deletes p */
+
+  /* assume sh and uptodeg agree */
+
+  if (sh == 0) return(p); /* the zero shift */
+
+  poly q  = NULL;
+  poly pp = p; // pCopy(p);
+  while (pp!=NULL)
+  {
+    q = p_Add_q(q, pmLPshift(pp,sh,uptodeg,lV),currRing);
+    pIter(pp);
+  }
+  /* delete pp? */
+  /* int version: returns TRUE if it was successful */
+  return(q);
+}
+
 poly pmLPshift(poly p, int sh, int uptodeg, int lV)
 {
+  /* TODO: use a shortcut with p_ version */
   /* pm is a monomial */
 
@@ -110 +222 @@
   /* appearing among the monomials of p */
   /* the 0th block is the 1st one */
-  poly q = p_Copy(p,currRing); /* need it ? */
+  poly q = p; //p_Copy(p,currRing); /* need it ? */
   int ans = 0; 
   int ansnew = 0;
@@ -127 +239 @@
   /* for a monomial p, returns the number of the last block */
   /* where a nonzero exponent is sitting */
+  if (pIsConstantPoly(p))
+  {
+    return(int(0));
+  }
   int *e=(int *)omAlloc0((currRing->N+1)*sizeof(int));
   pGetExpV(p,e);
@@ -143 +259 @@
   return (b);
 }
+
+int p_LastVblockT(poly p, int lV, kStrategy strat, const ring r)
+{
+  /* returns the number of maximal block */
+  /* appearing among the monomials of p */
+  /* the 0th block is the 1st one */
+
+  /* p is like TObject: lm in currRing = r, tail in tailRing  */
+  assume(p_LmCheckIsFromRing(p,r));
+  assume(p_CheckIsFromRing(pNext(p),strat->tailRing));
+
+  int ans = p_mLastVblock(p, lV, r); // Block of LM
+  poly q = pNext(p); 
+  int ansnew = 0;
+  while (q != NULL)
+  {
+    ansnew = p_mLastVblock(q, lV, strat->tailRing);
+    ans       = si_max(ans,ansnew);
+    pIter(q);
+  }
+  /* do not need to delete q */
+  return(ans);
+}
+
+int p_LastVblock(poly p, int lV, const ring r)
+{
+  /* returns the number of maximal block */
+  /* appearing among the monomials of p */
+  /* the 0th block is the 1st one */
+  poly q = p; //p_Copy(p,currRing); /* need it ? */
+  int ans = 0; 
+  int ansnew = 0;
+  while (q!=NULL)
+  {
+    ansnew = p_mLastVblock(q, lV, r);
+    ans    = si_max(ans,ansnew);
+    pIter(q);
+  }
+  /* do not need to delete q */
+  return(ans);
+}
+
+int p_mLastVblock(poly p, int lV, const ring r)
+{
+  /* for a monomial p, returns the number of the last block */
+  /* where a nonzero exponent is sitting */
+  if (p_LmIsConstant(p,r))
+  {
+    return(0);
+  }
+  int *e=(int *)omAlloc0((r->N+1)*sizeof(int));
+  p_GetExpV(p,e,r);
+  int j,b;
+  j = r->N;
+  while ( (!e[j]) && (j>=1) ) j--;
+  if (j==0) 
+  {
+#ifdef PDEBUG
+    Print("pmLastVblock: unexpected zero exponent vector");
+    PrintLn();
+#endif   
+    return(j);
+  }
+  b = (int)((j+lV-1)/lV); /* the number of the block, >=1 */
+  freeT(e,r->N);
+  return (b);
+}
+
+int pFirstVblock(poly p, int lV)
+{
+  /* returns the number of maximal block */
+  /* appearing among the monomials of p */
+  /* the 0th block is the 1st one */
+  poly q = p; //p_Copy(p,currRing); /* need it ? */
+  int ans = 0; 
+  int ansnew = 0;
+  while (q!=NULL)
+  {
+    ansnew = pmFirstVblock(q,lV);
+    ans    = si_min(ans,ansnew);
+    pIter(q);
+  }
+  /* do not need to delete q */
+  return(ans);
+}
+
+int pmFirstVblock(poly p, int lV)
+{
+  if (pIsConstantPoly(p))
+  {
+    return(int(0));
+  }
+  /* for a monomial p, returns the number of the first block */
+  /* where a nonzero exponent is sitting */
+  int *e=(int *)omAlloc0((currRing->N+1)*sizeof(int));
+  pGetExpV(p,e);
+  int j,b;
+  j = 1;
+  while ( (!e[j]) && (j<=currRing->N-1) ) j++;
+  if (j==currRing->N + 1) 
+  {
+#ifdef PDEBUG
+    Print("pmFirstVblock: unexpected zero exponent vector");
+    PrintLn();
+#endif   
+    return(j);
+  }
+  b = (int)(j/lV)+1; /* the number of the block, 1<= N <= currRing->N  */
+  return (b);
+}
+
 
 int isInV(poly p, int lV)
@@ -161 +388 @@
     for (i=(j-1)*lV + 1; i<= j*lV; i++)
     {
-      if (!e[i]) B[j] = B[j]+1;
+      if (e[i]) B[j] = B[j]+1;
     }
   }
@@ -187 +414 @@
 }
 
+int itoInsert(poly p, int uptodeg, int lV, const ring r)
+{
+  /* for poly in lmCR/tailTR presentation */
+  /* the below situation might happen! */
+//   if (r == currRing)
+//   {
+//     "Current ring is not expected in toInsert";
+//     return(0);
+//   }
+  /* compute the number of insertions */
+  int i = p_mLastVblock(p, lV, currRing);
+  if (pNext(p) != NULL)
+  {
+    i = si_max(i, p_LastVblock(pNext(p), lV, r) );
+  }
+  //  i = uptodeg  - i +1; 
+  i = uptodeg  - i; 
+  p_wrp(p,currRing,r); Print("----i:%d",i); PrintLn();
+  return(i);
+}
+
+
 /* shiftgb stuff */
 

kernel/shiftgb.h

@@ -4 +4 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: shiftgb.h,v 1.2 2007-06-24 16:44:42 levandov Exp $ */
+/* $Id: shiftgb.h,v 1.3 2008-02-23 20:12:53 levandov Exp $ */
 /*
 * ABSTRACT: kernel: utils for kStd
@@ -12 +12 @@
 #include "gring.h"
 
+poly p_LPshiftT(poly p, int sh, int uptodeg, int lV, kStrategy strat, const ring r);
+int p_LastVblockT(poly p, int lV, kStrategy strat, const ring r);
+
+poly p_LPshift(poly p, int sh, int uptodeg, int lV,const ring r);
+poly p_mLPshift(poly p, int sh, int uptodeg, int lV,const ring r);
+
+int p_mLastVblock(poly p, int lV,const ring r);
+int p_LastVblock(poly p, int lV, const ring r);
+
 poly pLPshift(poly p, int sh, int uptodeg, int lV);
 poly pmLPshift(poly p, int sh, int uptodeg, int lV);
@@ -18 +27 @@
 int pmLastVblock(poly p, int lV);
 
+int pFirstVblock(poly p, int lV);
+int pmFirstVblock(poly p, int lV);
+
 int isInV(poly p, int lV);
 
+int itoInsert(poly p, int uptodeg, int lV, const ring r);
+
 #endif