Changeset ff4e34f in git

Timestamp:

Oct 4, 2000, 3:12:05 PM (24 years ago)

Author:

Olaf Bachmann <obachman@…>

Branches:

(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')

Children:

f103fb07c2e69147dd1bca55b8421e35361355a8

Parents:

122d498cedb975079e9eff3554a721e5e8f3af86

Message:

* buckets, lmBin, tailBin


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

Location:

Singular

Files:

• kInline.cc (modified) (6 diffs)
• kspoly.cc (modified) (2 diffs)
• kstd1.cc (modified) (6 diffs)
• kstd2.cc (modified) (3 diffs)
• kstdfac.cc (modified) (2 diffs)
• kutil.cc (modified) (4 diffs)
• kutil.h (modified) (5 diffs)
• pInline1.h (modified) (3 diffs)
• pInline2.h (modified) (3 diffs)
• p_Procs.cc (modified) (2 diffs)
• p_polys.h (modified) (3 diffs)

Singular/kInline.cc

@@ -7 +7 @@
  *  Author:  obachman (Olaf Bachmann)
  *  Created: 8/00
- *  Version: $Id: kInline.cc,v 1.3 2000-09-25 12:26:31 obachman Exp $
+ *  Version: $Id: kInline.cc,v 1.4 2000-10-04 13:12:01 obachman Exp $
  *******************************************************************/
 #ifndef KINLINE_CC
@@ -17 +17 @@
 #include "p_Procs.h"
 #include "kbuckets.h"
-
+#include "omalloc.h"
+
+#define HAVE_TAIL_BIN
+// #define HAVE_LM_BIN
+
+KINLINE skStrategy::skStrategy()
+{
+  memset(this, 0, sizeof(skStrategy));
+  tailRing = currRing;
+  P.tailRing = currRing;
+  P.lmRing = currRing;
+#ifdef HAVE_LM_BIN
+  lmBin = omGetStickyBinOfBin(currRing->PolyBin);
+#endif
+#ifdef HAVE_TAIL_BIN
+  tailBin = omGetStickyBinOfBin(currRing->PolyBin);
+#endif
+}
+
+KINLINE skStrategy::~skStrategy()
+{
+  if (lmBin != NULL)
+    omMergeStickyBinIntoBin(lmBin, currRing->PolyBin);
+  if (tailBin != NULL)
+    omMergeStickyBinIntoBin(tailBin, 
+                            (tailRing!= NULL ? tailRing->PolyBin:
+                             currRing->PolyBin));
+}
+  
 KINLINE TSet initT () { return (TSet)omAlloc0(setmax*sizeof(TObject)); }
 
@@ -97 +125 @@
 }
 
-KINLINE poly sLObject::GetP(ring get_lmRing = currRing)
+KINLINE poly sLObject::GetP(ring get_lmRing = currRing, omBin lmBin = NULL)
 {
   kTest_L(this);
@@ -112 +140 @@
     if (get_lmRing != lmRing)
     {
-      p = k_LmShallowCopyDelete_tailRing_2_lmRing(p, tailRing, lmRing);
-      get_lmRing = lmRing;
-    }
-  }
+      if (lmBin == NULL) lmBin = get_lmRing->PolyBin;
+      p = k_LmShallowCopyDelete_tailRing_2_lmRing(p,lmRing, get_lmRing,lmBin);
+      lmRing = get_lmRing;
+    }
+    else if (lmBin != NULL)
+    {
+      p = p_LmShallowCopyDelete(p, lmRing, lmBin);
+    }
+  }
+    
   kTest_L(this);
   return p;
@@ -126 +160 @@
  *
  ***************************************************************/
-
-KINLINE poly k_LmInit_lmRing_2_tailRing(poly p, ring lmRing, ring tailRing)
+  
+KINLINE poly k_LmInit_lmRing_2_tailRing(poly p, ring lmRing, ring tailRing, omBin tailBin)
 {
   int i;
-  poly np = p_New(tailRing);
+  poly np = p_Init(tailRing, tailBin);
   pNext(np) = pNext(p);
   pSetCoeff0(np, pGetCoeff(p));
@@ -147 +181 @@
 }
 
-KINLINE poly k_LmInit_tailRing_2_lmRing(poly p, ring tailRing, ring lmRing)
-{
-  return k_LmInit_lmRing_2_tailRing(p, tailRing, lmRing);
+KINLINE poly k_LmInit_tailRing_2_lmRing(poly p, ring tailRing, ring lmRing, omBin lmBin)
+{
+  return k_LmInit_lmRing_2_tailRing(p, tailRing, lmRing, lmBin);
 }
 
 // this should be made more efficient
-KINLINE poly k_LmShallowCopyDelete_lmRing_2_tailRing(poly p, ring lmRing, ring tailRing)
-{
-  poly np = k_LmInit_lmRing_2_tailRing(p, lmRing, tailRing);
+KINLINE poly k_LmShallowCopyDelete_lmRing_2_tailRing(poly p, ring lmRing, ring tailRing, omBin tailBin)
+{
+  poly np = k_LmInit_lmRing_2_tailRing(p, lmRing, tailRing, tailBin);
   p_LmFree(p, lmRing);
   return np;
 }
 
-KINLINE poly k_LmShallowCopyDelete_tailRing_2_lmRing(poly p, ring tailRing, ring lmRing)
-{
-  poly np = k_LmInit_tailRing_2_lmRing(p, tailRing, lmRing);
+KINLINE poly k_LmShallowCopyDelete_tailRing_2_lmRing(poly p, ring tailRing, ring lmRing, omBin lmBin)
+{
+  poly np = k_LmInit_tailRing_2_lmRing(p, tailRing, lmRing, lmBin);
   p_LmFree(p, tailRing);
   return np;
 }
 
+KINLINE poly k_LmInit_lmRing_2_tailRing(poly p, ring lmRing, ring tailRing)
+{
+  return k_LmInit_lmRing_2_tailRing(p, lmRing, tailRing, tailRing->PolyBin);
+}
+
+KINLINE poly k_LmInit_tailRing_2_lmRing(poly p, ring tailRing, ring lmRing)
+{
+  return  k_LmInit_tailRing_2_lmRing(p, tailRing, lmRing, lmRing->PolyBin);
+}
+
+KINLINE poly k_LmShallowCopyDelete_lmRing_2_tailRing(poly p, ring lmRing, ring tailRing)
+{
+  return k_LmShallowCopyDelete_lmRing_2_tailRing(p, lmRing, tailRing, tailRing->PolyBin);
+}
+
+KINLINE poly k_LmShallowCopyDelete_tailRing_2_lmRing(poly p, ring tailRing, ring lmRing)
+{
+  return  k_LmShallowCopyDelete_tailRing_2_lmRing(p, tailRing, lmRing, lmRing->PolyBin);
+}
+
 #endif // defined(KINLINE) || defined(KUTIL_CC)
 #endif // KINLINE_CC

Singular/kspoly.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: kspoly.cc,v 1.10 2000-09-25 12:26:32 obachman Exp $ */
+/* $Id: kspoly.cc,v 1.11 2000-10-04 13:12:01 obachman Exp $ */
 /*
 *  ABSTRACT -  Routines for Spoly creation and reductions
@@ -111 +111 @@
                    int use_buckets, ring tailRing)
 {
-  assume(kTest_L(Pair));
+  kTest_L(Pair);
   poly p1 = Pair->p1;
   poly p2 = Pair->p2;

Singular/kstd1.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: kstd1.cc,v 1.54 2000-09-18 09:19:07 obachman Exp $ */
+/* $Id: kstd1.cc,v 1.55 2000-10-04 13:12:01 obachman Exp $ */
 /*
 * ABSTRACT:
@@ -1771 +1771 @@
 //Print("%d reductions canceled \n",strat->cel);
   HCord=strat->HCord;
-  kFreeStrat(strat);
+  delete(strat);
   if ((delete_w)&&(w!=NULL)&&(*w!=NULL)) delete *w;
   return r;
@@ -1897 +1897 @@
     l->m[1].data=(void *)strat->M;
   }
-  kFreeStrat(strat);
+  delete(strat);
   if (reduced>2)
   {
@@ -1917 +1917 @@
   else
     p=kNF2(F,Q,p,strat,lazyReduce);
-  kFreeStrat(strat);
+  delete(strat);
   return p;
 }
@@ -1934 +1934 @@
   else
     res=kNF2(F,Q,p,strat,lazyReduce);
-  kFreeStrat(strat);
+  delete(strat);
   return res;
 }
@@ -1993 +1993 @@
 //  }
   ideal shdl=strat->Shdl;
-  kFreeStrat(strat);
+  delete(strat);
   return shdl;
 }

Singular/kstd2.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: kstd2.cc,v 1.48 2000-09-25 12:26:32 obachman Exp $ */
+/* $Id: kstd2.cc,v 1.49 2000-10-04 13:12:02 obachman Exp $ */
 /*
 *  ABSTRACT -  Kernel: alg. of Buchberger
@@ -623 +623 @@
       /* statistic */
       if (TEST_OPT_PROT) PrintS("s");
-      strat->P.GetP();
+      strat->P.GetP(currRing, strat->lmBin);
       /* enter P.p into s and L */
       {
@@ -877 +877 @@
   }
   pLexOrder = b;
-  kFreeStrat(strat);
+  delete(strat);
   if ((delete_w)&&(w!=NULL)&&(*w!=NULL)) delete *w;
   idSkipZeroes(r);

Singular/kstdfac.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: kstdfac.cc,v 1.41 2000-09-25 12:26:32 obachman Exp $ */
+/* $Id: kstdfac.cc,v 1.42 2000-10-04 13:12:02 obachman Exp $ */
 /*
 *  ABSTRACT -  Kernel: factorizing alg. of Buchberger
@@ -884 +884 @@
   {
     orgstrat=strat->next;
-    kFreeStrat(strat);
+    delete(strat);
     strat=orgstrat;
   }

Singular/kutil.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: kutil.cc,v 1.63 2000-09-25 12:26:33 obachman Exp $ */
+/* $Id: kutil.cc,v 1.64 2000-10-04 13:12:03 obachman Exp $ */
 /*
 * ABSTRACT: kernel: utils for kStd
@@ -3243 +3243 @@
   }
   else atT = 0;
+
+  if (strat->tailBin != NULL)
+    pNext(p.p)=p_ShallowCopyDelete(pNext(p.p),
+                                   (strat->tailRing != NULL ? 
+                                    strat->tailRing : currRing),
+                                   strat->tailBin);
   strat->T[atT].p = p.p;
   strat->T[atT].ecart = p.ecart;
@@ -3282 +3288 @@
     strat->T[atT].length = p.length;
 
-  strat->T[atT].pLength = p.pLength;
+  if (strat->tailBin != NULL)
+    pNext(p.p)=p_ShallowCopyDelete(pNext(p.p),
+                                   (strat->tailRing != NULL ? 
+                                    strat->tailRing : currRing),
+                                   strat->tailBin);
+  if (strat->use_buckets && p.pLength <= 0)
+    strat->T[atT].pLength = pLength(p.p);
+  else
+    strat->T[atT].pLength = p.pLength;
+
   if (p.sev == 0)
   {
@@ -3624 +3639 @@
 }
 
-void kFreeStrat(kStrategy strat)
-{
-  omFreeSize(strat, sizeof(skStrategy));
-}
-
 rOrderType_t spGetOrderType(ring r, int modrank, int syzcomp)
 {

Singular/kutil.h

@@ -4 +4 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: kutil.h,v 1.31 2000-09-25 12:26:34 obachman Exp $ */
+/* $Id: kutil.h,v 1.32 2000-10-04 13:12:03 obachman Exp $ */
 /*
 * ABSTRACT: kernel: utils for kStd
@@ -58 +58 @@
   KINLINE void Tail_Minus_mm_Mult_qq(poly m, poly qq, int lq, poly spNoether);
   KINLINE void sLObject::Tail_Mult_nn(number n);
-  KINLINE poly GetP(ring LmRing = currRing);
+  KINLINE poly GetP(ring LmRing = currRing, omBin bin = NULL);
   KINLINE void CanonicalizeP();
 };
@@ -126 +126 @@
   BOOLEAN use_buckets;
   ring tailRing;
+  omBin lmBin;
+  omBin tailBin;
   /*FALSE, if posInL == posInL10*/
   char    redTailChange;
@@ -131 +133 @@
   char    newt;/*used for messageSets*/
 
-  skStrategy()
-    {
-      memset(this, 0, sizeof(skStrategy));
-      tailRing = currRing;
-      P.tailRing = currRing;
-      P.lmRing = currRing;
-    };
-  
+  KINLINE skStrategy();
+  KINLINE ~skStrategy();
 };
 
@@ -208 +204 @@
 
 KINLINE TSet initT ();
+KINLINE poly k_LmInit_lmRing_2_tailRing(poly p, ring lmRing, ring tailRing, omBin bin);
+KINLINE poly k_LmInit_tailRing_2_lmRing(poly p, ring tailRing, ring lmRing, omBin bin);
+KINLINE poly k_LmShallowCopyDelete_lmRing_2_tailRing(poly p, ring lmRing, ring tailRing, omBin bin);
+KINLINE poly k_LmShallowCopyDelete_tailRing_2_lmRing(poly p, ring tailRing, ring lmRing,  omBin bin);
+
 KINLINE poly k_LmInit_lmRing_2_tailRing(poly p, ring lmRing, ring tailRing);
 KINLINE poly k_LmInit_tailRing_2_lmRing(poly p, ring tailRing, ring lmRing);

Singular/pInline1.h

@@ -7 +7 @@
  *  Author:  obachman (Olaf Bachmann)
  *  Created: 8/00
- *  Version: $Id: pInline1.h,v 1.4 2000-09-20 12:56:36 obachman Exp $
+ *  Version: $Id: pInline1.h,v 1.5 2000-10-04 13:12:04 obachman Exp $
  *******************************************************************/
 #ifndef PINLINE1_H
@@ -60 +60 @@
  *
  ***************************************************************/
-PINLINE1 poly p_Init(ring r)
+PINLINE1 poly p_Init(ring r, omBin bin)
 {
   p_CheckRing1(r);
+  pAssume1(bin != NULL && r->PolyBin->sizeW == bin->sizeW);
   poly p;
-  omTypeAlloc0Bin(poly, p, r->PolyBin);
+  omTypeAlloc0Bin(poly, p, bin);
   p_SetRingOfPoly(p, r);
   return p;
 }
+PINLINE1 poly p_Init(ring r)
+{
+  return p_Init(r, r->PolyBin);
+}
+
 PINLINE1 poly p_LmInit(poly p, ring r)
 {
@@ -90 +96 @@
   _pSetCoeff0(np, n_Copy(_pGetCoeff(p), r));
   return np;
+}
+
+PINLINE1 poly p_LmShallowCopyDelete(poly p, const ring r, omBin bin)
+{
+  p_CheckPolyRing1(p, r);
+  pAssume1(bin->sizeW == r->PolyBin->sizeW);
+  poly new_p = p_New(r);
+  p_MemCopy_LengthGeneral(new_p->exp, p->exp, r->ExpLSize);
+  pSetCoeff0(new_p, pGetCoeff(p));
+  pNext(new_p) = pNext(p);
+  omFreeBinAddr(p);
+  return new_p;
 }
 

Singular/pInline2.h

@@ -7 +7 @@
  *  Author:  obachman (Olaf Bachmann)
  *  Created: 8/00
- *  Version: $Id: pInline2.h,v 1.6 2000-09-25 12:26:35 obachman Exp $
+ *  Version: $Id: pInline2.h,v 1.7 2000-10-04 13:12:04 obachman Exp $
  *******************************************************************/
 #ifndef PINLINE2_H
@@ -169 +169 @@
  *
  ***************************************************************/
-PINLINE2 poly p_New(ring r)
+PINLINE2 poly p_New(ring r, omBin bin)
 {
   p_CheckRing2(r);
+  pAssume2(bin != NULL && r->PolyBin->sizeW == bin->sizeW);
   poly p;
-  omTypeAllocBin(poly, p, r->PolyBin);
+  omTypeAllocBin(poly, p, bin);
   p_SetRingOfPoly(p, r);
   return p;
+}
+
+PINLINE2 poly p_New(ring r)
+{
+  return p_New(r, r->PolyBin);
 }
 
@@ -302 +308 @@
     p_LmDelete(p, lmRing);
   }
+}
+
+PINLINE2 poly p_ShallowCopyDelete(poly p, const ring r, omBin bin)
+{
+  p_CheckPolyRing2(p, r);
+  pAssume2(r->PolyBin->sizeW == bin->sizeW);
+  return r->p_Procs->p_ShallowCopyDelete(p, r, bin);
 }
 

Singular/p_Procs.cc

@@ -7 +7 @@
  *  Author:  obachman (Olaf Bachmann)
  *  Created: 8/00
- *  Version: $Id: p_Procs.cc,v 1.12 2000-09-25 12:26:35 obachman Exp $
+ *  Version: $Id: p_Procs.cc,v 1.13 2000-10-04 13:12:04 obachman Exp $
  *******************************************************************/
 #include <string.h>
@@ -64 +64 @@
 //   3 -- special cases for length <= 4
 //   4 -- special cases for length <= 8
-const int HAVE_FAST_LENGTH = 3;
+const int HAVE_FAST_LENGTH = 4;
 
 // Set HAVE_FAST_ORD to:

Singular/p_polys.h

@@ -8 +8 @@
  *  Author:  obachman (Olaf Bachmann)
  *  Created: 9/00
- *  Version: $Id: p_polys.h,v 1.2 2000-09-20 12:56:37 obachman Exp $
+ *  Version: $Id: p_polys.h,v 1.3 2000-10-04 13:12:05 obachman Exp $
  *******************************************************************/
 #ifndef P_POLYS_H
@@ -97 +97 @@
  ***************************************************************/
 PINLINE2 poly p_New(ring r);
+PINLINE2 poly p_New(ring r, omBin bin);
 PINLINE1 poly p_Init(ring r);
+PINLINE1 poly p_Init(ring rm, omBin bin);
 PINLINE1 poly p_LmInit(poly p, ring r);
 PINLINE1 poly p_Head(poly p, ring r);
@@ -180 +182 @@
 PINLINE2 void p_Delete(poly *p, const ring lmRing, const ring tailRing);
 
+// copys monomials of p, allocates nwe monomials from bin,
+// deletes monomoals of p
+PINLINE2 poly p_ShallowCopyDelete(poly p, const ring r, omBin bin);
+// simial but does it only for leading monomial
+PINLINE1 poly p_LmShallowCopyDelete(poly p, const ring r, omBin bin);
 
 /***************************************************************