Changeset 755d41 in git for kernel

Timestamp:

Oct 17, 2018, 12:38:55 PM (6 years ago)

Author:

Christian Eder

Branches:

(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', 'd08f5f0bb3329b8ca19f23b74cb1473686415c3a')

Children:

b2bceb6030806c7016ffc929e51bb5db6615e546

Parents:

194f79909c91c263131614aafc678fe53c3c3d4a

Message:

adds special ksReducePoly function for Z: if the reducer consists of only 1 term, we still might need to multiply the element to be reduced with a corresponding coefficient multiple

Location:

kernel/GBEngine

Files:

• kspoly.cc (modified) (1 diff)
• kutil.h (modified) (1 diff)

kernel/GBEngine/kspoly.cc

@@ -39 +39 @@
  *
  ***************************************************************/
+int ksReducePolyZ(LObject* PR,
+                 TObject* PW,
+                 poly spNoether,
+                 number *coef,
+                 kStrategy strat)
+{
+#ifdef KDEBUG
+  red_count++;
+#ifdef TEST_OPT_DEBUG_RED
+//  if (TEST_OPT_DEBUG)
+//  {
+//    Print("Red %d:", red_count); PR->wrp(); Print(" with:");
+//    PW->wrp();
+//    //printf("\necart(PR)-ecart(PW): %i\n",PR->ecart-PW->ecart);
+//    //pWrite(PR->p);
+//  }
+#endif
+#endif
+  int ret = 0;
+  ring tailRing = PR->tailRing;
+  kTest_L(PR,tailRing);
+  kTest_T(PW);
+
+  poly p1 = PR->GetLmTailRing();   // p2 | p1
+  poly p2 = PW->GetLmTailRing();   // i.e. will reduce p1 with p2; lm = LT(p1) / LM(p2)
+  poly t2 = pNext(p2), lm = p1;    // t2 = p2 - LT(p2); really compute P = LC(p2)*p1 - LT(p1)/LM(p2)*p2
+  assume(p1 != NULL && p2 != NULL);// Attention, we have rings and there LC(p2) and LC(p1) are special
+  p_CheckPolyRing(p1, tailRing);
+  p_CheckPolyRing(p2, tailRing);
+
+  pAssume1(p2 != NULL && p1 != NULL &&
+           p_DivisibleBy(p2,  p1, tailRing));
+
+  pAssume1(p_GetComp(p1, tailRing) == p_GetComp(p2, tailRing) ||
+           (p_GetComp(p2, tailRing) == 0 &&
+            p_MaxComp(pNext(p2),tailRing) == 0));
+
+#ifdef HAVE_PLURAL
+  if (rIsPluralRing(currRing))
+  {
+    // for the time being: we know currRing==strat->tailRing
+    // no exp-bound checking needed
+    // (only needed if exp-bound(tailring)<exp-b(currRing))
+    if (PR->bucket!=NULL)  nc_kBucketPolyRed_Z(PR->bucket, p2,coef);
+    else
+    {
+      poly _p = (PR->t_p != NULL ? PR->t_p : PR->p);
+      assume(_p != NULL);
+      nc_PolyPolyRed(_p, p2,coef, currRing);
+      if (PR->t_p!=NULL) PR->t_p=_p; else PR->p=_p;
+      PR->pLength=0; // usually not used, GetpLength re-computes it if needed
+    }
+    return 0;
+  }
+#endif
+
+  /* if (t2==NULL)           // Divisor is just one term, therefore it will
+   * {                       // just cancel the leading term
+   *   PR->LmDeleteAndIter();
+   *   if (coef != NULL) *coef = n_Init(1, tailRing->cf);
+   *   return 0;
+   * } */
+
+  p_ExpVectorSub(lm, p2, tailRing); // Calculate the Monomial we must multiply to p2
+
+  //if (tailRing != currRing)
+  {
+    // check that reduction does not violate exp bound
+    while (PW->max_exp != NULL && !p_LmExpVectorAddIsOk(lm, PW->max_exp, tailRing))
+    {
+      // undo changes of lm
+      p_ExpVectorAdd(lm, p2, tailRing);
+      if (strat == NULL) return 2;
+      if (! kStratChangeTailRing(strat, PR, PW)) return -1;
+      tailRing = strat->tailRing;
+      p1 = PR->GetLmTailRing();
+      p2 = PW->GetLmTailRing();
+      t2 = pNext(p2);
+      lm = p1;
+      p_ExpVectorSub(lm, p2, tailRing);
+      ret = 1;
+    }
+  }
+
+  // take care of coef buisness
+  if (! n_IsOne(pGetCoeff(p2), tailRing->cf))
+  {
+    number bn = pGetCoeff(lm);
+    number an = pGetCoeff(p2);
+    int ct = ksCheckCoeff(&an, &bn, tailRing->cf);    // Calculate special LC
+    p_SetCoeff(lm, bn, tailRing);
+    if ((ct == 0) || (ct == 2))
+      PR->Tail_Mult_nn(an);
+    if (coef != NULL) *coef = an;
+    else n_Delete(&an, tailRing->cf);
+  }
+  else
+  {
+    if (coef != NULL) *coef = n_Init(1, tailRing->cf);
+  }
+
+
+  // and finally,
+  PR->Tail_Minus_mm_Mult_qq(lm, t2, pLength(t2) /*PW->GetpLength() - 1*/, spNoether);
+  assume(PW->GetpLength() == pLength(PW->p != NULL ? PW->p : PW->t_p));
+  PR->LmDeleteAndIter();
+
+  // the following is commented out: shrinking
+#ifdef HAVE_SHIFTBBA_NONEXISTENT
+  if ( (currRing->isLPring) && (!strat->homog) )
+  {
+    // assume? h->p in currRing
+    PR->GetP();
+    poly qq = p_Shrink(PR->p, currRing->isLPring, currRing);
+    PR->Clear(); // does the right things
+    PR->p = qq;
+    PR->t_p = NULL;
+    PR->SetShortExpVector();
+  }
+#endif
+
+  return ret;
+}
+
 int ksReducePoly(LObject* PR,
                  TObject* PW,

kernel/GBEngine/kutil.h

@@ -698 +698 @@
                  kStrategy strat = NULL);
 
+/* like ksReducePoly, but if the reducer has only 1 term we still
+ * compute a possible coefficient multiplier for PR. this comes from
+ * a special situation in redRing_Z and it is used only there. */
+int ksReducePolyZ(LObject* PR,
+                 TObject* PW,
+                 poly spNoether = NULL,
+                 number *coef = NULL,
+                 kStrategy strat = NULL);
+
 int ksReducePolyLC(LObject* PR,
                  TObject* PW,