singular-dev-doc/html/kutil_8h_source.html

 #ifndef KUTIL_H

 #define KUTIL_H

 /****************************************

 *  Computer Algebra System SINGULAR     *

 ****************************************/

 /*

 * ABSTRACT: kernel: utils for kStd

 */


 #include <string.h>


 #include <omalloc/omalloc.h>

 #include <misc/mylimits.h>


 #include <kernel/polys.h>

 #include <polys/operations/pShallowCopyDelete.h>


 #include <kernel/structs.h>


 // define if tailrings should be used

 #define HAVE_TAIL_RING


 #if 1

 #define setmax 16

 #define setmaxL ((4096-12)/sizeof(LObject))

 #define setmaxLinc ((4096)/sizeof(LObject))


 #define setmaxT 64

 #define setmaxTinc 32

 #else

 #define setmax 16

 #define setmaxL 16

 #define setmaxLinc 16

 #define setmaxT 16

 #define setmaxTinc 16

 #endif


 // if you want std computations as in Singular version < 2:

 // This disables RedThrough, tailReductions against T (bba),

 // sets posInT = posInT15 (bba, strat->honey), and enables redFirst with LDeg

 // NOTE: can be achieved with option(oldStd)


 #undef NO_KINLINE

 #if !defined(KDEBUG) && !defined(NO_INLINE)

 #define KINLINE inline

 #else

 #define KINLINE

 #define NO_KINLINE 1

 #endif


 typedef int* intset;

 typedef int64  wlen_type;

 typedef wlen_type* wlen_set;


 typedef class sTObject TObject;

 typedef class sLObject LObject;

 typedef TObject * TSet;

 typedef LObject * LSet;


 typedef struct denominator_list_s denominator_list_s;

 typedef denominator_list_s *denominator_list;


 struct denominator_list_s{number n; denominator_list next;};

 extern denominator_list DENOMINATOR_LIST;


 class sTObject

 {

 public:

   unsigned long sevSig;

   poly sig;   // the signature of the element

   poly p;       // Lm(p) \in currRing Tail(p) \in tailRing

   poly t_p;     // t_p \in tailRing: as monomials Lm(t_p) == Lm(p)

   poly max;     // p_GetMaxExpP(pNext(p))

   ring tailRing;

   long FDeg;    // pFDeg(p)

   int ecart,

     length,     // as of pLDeg

     pLength,    // either == 0, or == pLength(p)

     i_r;        // index of TObject in R set, or -1 if not in T

   BOOLEAN is_normalized; // true, if pNorm was called on p, false otherwise

   // used in incremental sba() with F5C:

   // we know some of the redundant elements in

   // strat->T beforehand, so we can just discard

   // them and do not need to consider them in the

   // interreduction process

   BOOLEAN is_redundant;

   // used in sba's sig-safe reduction:

   // sometimes we already know that a reducer

   // is sig-safe, so no need for a real

   // sig-safeness check

   BOOLEAN is_sigsafe;


 #ifdef HAVE_PLURAL

   BOOLEAN is_special; // true, it is a new special S-poly (e.g. for SCA)

 #endif


   // initialization

   KINLINE void Init(ring r = currRing);

   KINLINE sTObject(ring tailRing = currRing);

   KINLINE sTObject(poly p, ring tailRing = currRing);

   KINLINE sTObject(poly p, ring c_r, ring tailRing);

   KINLINE sTObject(sTObject* T, int copy);


   KINLINE void Set(ring r=currRing);

   KINLINE void Set(poly p_in, ring r=currRing);

   KINLINE void Set(poly p_in, ring c_r, ring t_r);


   // Frees the polys of T

   KINLINE void Delete();

   // Sets polys to NULL

   KINLINE void Clear();

   // makes a copy of the poly of T

   KINLINE void Copy();


   // ring-dependent Lm access: these might result in allocation of monomials

   KINLINE poly GetLmCurrRing();

   KINLINE poly GetLmTailRing();

   KINLINE poly GetLm(ring r);

   // this returns Lm and ring r (preferably from tailRing), but does not

   // allocate a new poly

   KINLINE void GetLm(poly &p, ring &r) const;


 #ifdef OLIVER_PRIVAT_LT

   // routines for calc. with rings

   KINLINE poly GetLtCurrRing();

   KINLINE poly GetLtTailRing();

   KINLINE poly GetLt(ring r);

   KINLINE void GetLt(poly &p, ring &r) const;

 #endif


   KINLINE BOOLEAN IsNull() const;


   KINLINE int GetpLength();


   // makes sure that T.p exists

   KINLINE void SetLmCurrRing();


   // Iterations

   // simply get the next monomial

   KINLINE poly Next();

   KINLINE void LmDeleteAndIter();


   // deg stuff

   // compute pTotalDegree

   KINLINE long pTotalDeg() const;

   // computes pFDeg

   KINLINE long pFDeg() const;

   // computes and sets FDeg

   KINLINE long SetpFDeg();

   // gets stored FDeg

   KINLINE long GetpFDeg() const;


   // computes pLDeg

   KINLINE long pLDeg();

   // sets length, FDeg, returns LDeg

   KINLINE long SetDegStuffReturnLDeg();


   // arithmetic

   KINLINE void Mult_nn(number n);

   KINLINE void ShallowCopyDelete(ring new_tailRing, omBin new_tailBin,

                                  pShallowCopyDeleteProc p_shallow_copy_delete,

                                  BOOLEAN set_max = TRUE);

   // manipulations

   KINLINE void pNorm();

   KINLINE void pCleardenom();


 #ifdef KDEBUG

   void wrp();

 #endif

 };


 #ifndef SING_NDEBUG

 extern int strat_nr;

 extern int strat_fac_debug;

 #endif


 class sLObject : public sTObject

 {


 public:

   unsigned long sev;

   unsigned long checked; // this is the index of S up to which

                       // the corresponding LObject was already checked in

                       // critical pair creation => when entering the

                       // reduction process it is enough to start a second

                       // rewritten criterion check from checked+1 onwards

   BOOLEAN prod_crit;

                       // NOTE: If prod_crit = TRUE then the corresponding pair is

                       // detected by Buchberger's Product Criterion and can be

                       // deleted

   poly  p1,p2; /*- the pair p comes from,

                  lm(pi) in currRing, tail(pi) in tailring -*/


   poly  lcm;   /*- the lcm of p1,p2 -*/

   kBucket_pt bucket;

   int   i_r1, i_r2;


   // initialization

   KINLINE void Init(ring tailRing = currRing);

   KINLINE sLObject(ring tailRing = currRing);

   KINLINE sLObject(poly p, ring tailRing = currRing);

   KINLINE sLObject(poly p, ring c_r, ring tailRing);


   // Frees the polys of L

   KINLINE void Delete();

   KINLINE void Clear();


   // Iterations

   KINLINE void LmDeleteAndIter();

   KINLINE poly LmExtractAndIter();


   // spoly related things

   // preparation for reduction if not spoly

   KINLINE void PrepareRed(BOOLEAN use_bucket);

   KINLINE void SetLmTail(poly lm, poly new_p, int length,

                          int use_bucket, ring r);

   KINLINE void Tail_Minus_mm_Mult_qq(poly m, poly qq, int lq, poly spNoether);

   KINLINE void Tail_Mult_nn(number n);

   // deletes bucket, makes sure that p and t_p exists

   KINLINE poly GetP(omBin lmBin = NULL);

   // similar, except that only t_p exists

   KINLINE poly GetTP();


   // does not delete bucket, just canonicalizes it

   // returned poly is such that Lm(p) \in currRing, Tail(p) \in tailRing

   KINLINE poly CanonicalizeP();


   // makes a copy of the poly of L

   KINLINE void Copy();

   // gets the poly and makes a copy of it

   KINLINE poly CopyGetP();


   KINLINE int GetpLength();

   KINLINE long pLDeg(BOOLEAN use_last);

   KINLINE long pLDeg();

   KINLINE int SetLength(BOOLEAN lengt_pLength = FALSE);

   KINLINE long SetDegStuffReturnLDeg();

   KINLINE long SetDegStuffReturnLDeg(BOOLEAN use_last);


   // returns minimal component of p

   KINLINE long MinComp();

   // returns component of p

   KINLINE long Comp();


   KINLINE void ShallowCopyDelete(ring new_tailRing,

                                  pShallowCopyDeleteProc p_shallow_copy_delete);


   // sets sev

   KINLINE void SetShortExpVector();


   // enable assignment from TObject

   KINLINE sLObject& operator=(const sTObject&);


   // get T's corresponding to p1, p2: they might return NULL

   KINLINE TObject* T_1(const skStrategy* strat);

   KINLINE TObject* T_2(const skStrategy* strat);

   KINLINE void     T_1_2(const skStrategy* strat,

                          TObject* &T_1, TObject* &T_2);


   // simplify coefficients

   KINLINE void Normalize();

   KINLINE void HeadNormalize();

 };


 extern int HCord;


 class skStrategy;

 typedef skStrategy * kStrategy;

 class skStrategy

 {

 public:

   kStrategy next;

   int (*red)(LObject * L,kStrategy strat);

   int (*red2)(LObject * L,kStrategy strat);

   void (*initEcart)(TObject * L);

   int (*posInT)(const TSet T,const int tl,LObject &h);

   int (*posInLSba)(const LSet set, const int length,

                 LObject* L,const kStrategy strat);

   int (*posInL)(const LSet set, const int length,

                 LObject* L,const kStrategy strat);

   void (*enterS)(LObject h, int pos,kStrategy strat, int atR/* =-1*/ );

   void (*initEcartPair)(LObject * h, poly f, poly g, int ecartF, int ecartG);

   int (*posInLOld)(const LSet Ls,const int Ll,

                    LObject* Lo,const kStrategy strat);

   void (*enterOnePair) (int i,poly p,int ecart, int isFromQ,kStrategy strat, int atR /*= -1*/);

   void (*chainCrit) (poly p,int ecart,kStrategy strat);

   BOOLEAN (*syzCrit) (poly sig, unsigned long not_sevSig, kStrategy strat);

   BOOLEAN (*rewCrit1) (poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start /*= 0*/);

   BOOLEAN (*rewCrit2) (poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start /*= 0*/);

   BOOLEAN (*rewCrit3) (poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start /*= 0*/);

   pFDegProc pOrigFDeg;

   pLDegProc pOrigLDeg;

   pFDegProc pOrigFDeg_TailRing;

   pLDegProc pOrigLDeg_TailRing;


   LObject P;

   ideal Shdl;

   ideal D; /*V(S) is in D(D)*/

   ideal M; /*set of minimal generators*/

   polyset S;

   polyset syz;

   polyset sig;

   intset ecartS;

   intset fromS; // from which S[i] S[j] comes from

                 // this is important for signature-based

                 // algorithms

   intset syzIdx;// index in the syz array at which the first

                 // syzygy of component i comes up

                 // important for signature-based algorithms

   unsigned sbaOrder;

   unsigned long currIdx;

   int max_lower_index;

   intset lenS;

   wlen_set lenSw; /* for tgb.ccc */

   intset fromQ;

   unsigned long* sevS;

   unsigned long* sevSyz;

   unsigned long* sevSig;

   unsigned long* sevT;

   TSet T;

   LSet L;

   LSet    B;

   poly    kHEdge;

   poly    kNoether;

   poly    t_kHEdge; // same polys in tailring

   KINLINE poly    kNoetherTail();

   poly    t_kNoether;

   BOOLEAN * NotUsedAxis;

   BOOLEAN * pairtest;/*used for enterOnePair*/

   poly tail;

   intvec * kModW;

   intvec * kHomW;

   // procedure for ShalloCopy from tailRing  to currRing

   pShallowCopyDeleteProc p_shallow_copy_delete;

   // pointers to Tobjects R[i] is ith Tobject which is generated

   TObject**  R;

   // S_2_R[i] yields Tobject which corresponds to S[i]

   int*      S_2_R;

   ring tailRing;

   omBin lmBin;

   omBin tailBin;

 #ifndef SING_NDEBUG

   int nr;

 #endif

   int cp,c3;

   int cv; // in shift bases: counting V criterion

   int sl,mu;

   int syzl,syzmax,syzidxmax;

   int tl,tmax;

   int Ll,Lmax;

   int Bl,Bmax;

   int ak,LazyDegree,LazyPass;

   int syzComp;

   int HCord;

   int lastAxis;

   int newIdeal;

   int minim;

   #ifdef HAVE_SHIFTBBA

   int lV;

   #endif

   BOOLEAN interpt;

   BOOLEAN homog;

 #ifdef HAVE_PLURAL

   BOOLEAN z2homog; // Z_2 - homogeneous input allows product criterion in commutative and SCA cases!

 #endif

   BOOLEAN kHEdgeFound;

   BOOLEAN honey,sugarCrit;

   BOOLEAN Gebauer,noTailReduction;

   BOOLEAN fromT;

   BOOLEAN noetherSet;

   BOOLEAN update;

   BOOLEAN posInLOldFlag;

   BOOLEAN use_buckets;

   BOOLEAN interred_flag;

   // if set, pLDeg(p, l) == (pFDeg(pLast(p), pLength)

   BOOLEAN LDegLast;

   // if set, then L.length == L.pLength

   BOOLEAN length_pLength;

   // if set, then posInL does not depend on L.length

   BOOLEAN posInLDependsOnLength;

   /*FALSE, if posInL == posInL10*/

 #ifdef HAVE_PLURAL

   // set this flag to 1 to stop the product criteria

   // use ALLOW_PROD_CRIT(strat) to test

   BOOLEAN no_prod_crit;

 #define ALLOW_PROD_CRIT(A) (!(A)->no_prod_crit)

 #else

 #define ALLOW_PROD_CRIT(A) (1)

 #endif

   char    redTailChange;

   char    news;

   char    newt;/*used for messageSets*/

   char    noClearS;

   char    completeReduce_retry;

   char    overflow;


   skStrategy();

   ~skStrategy();


   // return TObject corresponding to S[i]: assume that it exists

   // i.e. no error checking is done

   KINLINE TObject* S_2_T(int i);

   // like S_2_T, except that NULL is returned if it can not be found

   KINLINE TObject* s_2_t(int i);

 };


 void deleteHC(poly *p, int *e, int *l, kStrategy strat);

 void deleteHC(LObject* L, kStrategy strat, BOOLEAN fromNext = FALSE);

 void deleteInS (int i,kStrategy strat);

 void deleteInSSba (int i,kStrategy strat);

 void cleanT (kStrategy strat);

 static inline LSet initL (int nr=setmaxL)

 { return (LSet)omAlloc(nr*sizeof(LObject)); }

 void deleteInL(LSet set, int *length, int j,kStrategy strat);

 void enterL (LSet *set,int *length, int *LSetmax, LObject p,int at);

 void enterSBba (LObject p,int atS,kStrategy strat, int atR = -1);

 void enterSSba (LObject p,int atS,kStrategy strat, int atR = -1);

 void initEcartPairBba (LObject* Lp,poly f,poly g,int ecartF,int ecartG);

 void initEcartPairMora (LObject* Lp,poly f,poly g,int ecartF,int ecartG);

 int posInS (const kStrategy strat, const int length, const poly p,

             const int ecart_p);

 int posInT0 (const TSet set,const int length,LObject &p);

 int posInT1 (const TSet set,const int length,LObject &p);

 int posInT2 (const TSet set,const int length,LObject &p);

 int posInT11 (const TSet set,const int length,LObject &p);

 int posInTSig (const TSet set,const int length,LObject &p);

 int posInT110 (const TSet set,const int length,LObject &p);

 int posInT13 (const TSet set,const int length,LObject &p);

 int posInT15 (const TSet set,const int length,LObject &p);

 int posInT17 (const TSet set,const int length,LObject &p);

 int posInT19 (const TSet set,const int length,LObject &p);

 int posInT_EcartpLength(const TSet set,const int length,LObject &p);


 #ifdef HAVE_MORE_POS_IN_T

 int posInT_EcartFDegpLength(const TSet set,const int length,LObject &p);

 int posInT_FDegpLength(const TSet set,const int length,LObject &p);

 int posInT_pLength(const TSet set,const int length,LObject &p);

 #endif


 void reorderS (int* suc,kStrategy strat);

 int posInLF5C (const LSet set, const int length,

                LObject* L,const kStrategy strat);

 int posInLSig (const LSet set, const int length,

                LObject* L,const kStrategy strat);

 int posInSyz (const kStrategy strat, const poly sig);

 int posInL0 (const LSet set, const int length,

              LObject* L,const kStrategy strat);

 int posInL11 (const LSet set, const int length,

              LObject* L,const kStrategy strat);

 int posInL13 (const LSet set, const int length,

              LObject* L,const kStrategy strat);

 int posInL15 (const LSet set, const int length,

              LObject* L,const kStrategy strat);

 int posInL17 (const LSet set, const int length,

              LObject* L,const kStrategy strat);

 int posInL10 (const LSet set, const int length,

              LObject* L,const kStrategy strat);

 int posInL110 (const LSet set, const int length,

              LObject* L,const kStrategy strat);

 KINLINE poly redtailBba (poly p,int pos,kStrategy strat,BOOLEAN normalize=FALSE);

 #ifdef HAVE_RINGS

 KINLINE poly redtailBba_Z (poly p,int pos,kStrategy strat);

 poly redtailBba_Z (LObject* L, int pos, kStrategy strat );

 #endif

 poly redtailBba (LObject *L, int pos,kStrategy strat,

                  BOOLEAN withT = FALSE,BOOLEAN normalize=FALSE);

 poly redtailSba (LObject *L, int pos,kStrategy strat,

                  BOOLEAN withT = FALSE,BOOLEAN normalize=FALSE);

 poly redtailBba (TObject *T, int pos,kStrategy strat);

 poly redtail (poly p,int pos,kStrategy strat);

 poly redtail (LObject *L,int pos,kStrategy strat);

 poly redNF (poly h,int & max_ind,int nonorm,kStrategy strat);

 int redNF0 (LObject *P,kStrategy strat);

 poly redNFTail (poly h,const int sl,kStrategy strat);

 int redHoney (LObject* h, kStrategy strat);

 #ifdef HAVE_RINGS

 int redRing (LObject* h,kStrategy strat);

 int redRiloc (LObject* h,kStrategy strat);

 void enterExtendedSpoly(poly h,kStrategy strat);

 void superenterpairs (poly h,int k,int ecart,int pos,kStrategy strat, int atR = -1);

 poly kCreateZeroPoly(long exp[], long cabsind, poly* t_p, ring leadRing, ring tailRing);

 long ind2(long arg);


 long ind_fact_2(long arg);

 long twoPow(long arg);

 ideal createG0();

 #endif

 int redLazy (LObject* h,kStrategy strat);

 int redHomog (LObject* h,kStrategy strat);

 int redSig (LObject* h,kStrategy strat);

 //adds hSig to be able to check with F5's criteria when entering pairs!

 void enterpairsSig (poly h, poly hSig, int from, int k, int ec, int pos,kStrategy strat, int atR = -1);

 void enterpairs (poly h, int k, int ec, int pos,kStrategy strat, int atR = -1);

 void entersets (LObject h);

 void pairs ();

 void message (int i,int* reduc,int* olddeg,kStrategy strat,int red_result);

 void messageStat (int hilbcount,kStrategy strat);

 #ifdef KDEBUG

 void messageSets (kStrategy strat);

 #else

 #define messageSets(s)  do {} while (0)

 #endif


 void initEcartNormal (TObject* h);

 void initEcartBBA (TObject* h);

 void initS (ideal F, ideal Q,kStrategy strat);

 void initSL (ideal F, ideal Q,kStrategy strat);

 void initSLSba (ideal F, ideal Q,kStrategy strat);

 /*************************************************

  * when initializing a new bunch of principal

  * syzygies at the beginning of a new iteration

  * step in a signature-based algorithm we

  * compute ONLY the leading elements of those

  * syzygies, NOT the whole syzygy

  * NOTE: this needs to be adjusted for a more

  * general approach on signature-based algorithms

  ***********************************************/

 void initSyzRules (kStrategy strat);

 void updateS(BOOLEAN toT,kStrategy strat);

 void enterSyz (LObject p,kStrategy strat, int atT);

 void enterT (LObject p,kStrategy strat, int atT = -1);

 void cancelunit (LObject* p,BOOLEAN inNF=FALSE);

 void HEckeTest (poly pp,kStrategy strat);

 void initBuchMoraCrit(kStrategy strat);

 void initSbaCrit(kStrategy strat);

 void initHilbCrit(ideal F, ideal Q, intvec **hilb,kStrategy strat);

 void initBuchMoraPos(kStrategy strat);

 void initSbaPos(kStrategy strat);

 void initBuchMora (ideal F, ideal Q,kStrategy strat);

 void initSbaBuchMora (ideal F, ideal Q,kStrategy strat);

 void exitBuchMora (kStrategy strat);

 void exitSba (kStrategy strat);

 void updateResult(ideal r,ideal Q,kStrategy strat);

 void completeReduce (kStrategy strat, BOOLEAN withT=FALSE);

 void kFreeStrat(kStrategy strat);

 void enterOnePairNormal (int i,poly p,int ecart, int isFromQ,kStrategy strat, int atR);

 void enterOnePairSig (int i,poly p,poly pSig,int ecart, int isFromQ,kStrategy strat, int atR);

 void chainCritNormal (poly p,int ecart,kStrategy strat);

 void chainCritSig (poly p,int ecart,kStrategy strat);

 BOOLEAN homogTest(polyset F, int Fmax);

 BOOLEAN newHEdge(kStrategy strat);

 BOOLEAN syzCriterion(poly sig, unsigned long not_sevSig, kStrategy strat);

 BOOLEAN syzCriterionInc(poly sig, unsigned long not_sevSig, kStrategy strat);

 KINLINE BOOLEAN arriRewDummy(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start);

 BOOLEAN arriRewCriterion(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start);

 BOOLEAN arriRewCriterionPre(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start);

 BOOLEAN faugereRewCriterion(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start);

 BOOLEAN findMinLMPair(poly sig, unsigned long not_sevSig, kStrategy strat, int start);


 /// returns index of p in TSet, or -1 if not found

 int kFindInT(poly p, TSet T, int tlength);


 /// return -1 if no divisor is found

 ///        number of first divisor in T, otherwise

 int kFindDivisibleByInT(const TSet &T, const unsigned long* sevT,

                         const int tl, const LObject* L, const int start=0);


 /// return -1 if no divisor is found

 ///        number of first divisor in S, otherwise

 int kFindDivisibleByInS(const kStrategy strat, int *max_ind, LObject* L);


 int kFindNextDivisibleByInS(const kStrategy strat, int start,int max_ind, LObject* L);

 TObject*

 kFindDivisibleByInS(kStrategy strat, int pos, LObject* L, TObject *T,

                     long ecart = LONG_MAX);


 /***************************************************************

  *

  * stuff to be inlined

  *

  ***************************************************************/


 KINLINE TSet initT ();

 KINLINE TObject** initR();

 KINLINE unsigned long* initsevT();

 KINLINE poly k_LmInit_currRing_2_tailRing(poly p, ring tailRing, omBin bin);

 KINLINE poly k_LmInit_tailRing_2_currRing(poly p, ring tailRing, omBin bin);

 KINLINE poly k_LmShallowCopyDelete_currRing_2_tailRing(poly p, ring tailRing, omBin bin);

 KINLINE poly k_LmShallowCopyDelete_tailRing_2_currRing(poly p, ring tailRing,  omBin bin);


 KINLINE poly k_LmInit_currRing_2_tailRing(poly p, ring tailRing);

 KINLINE poly k_LmInit_tailRing_2_currRing(poly p, ring tailRing);

 KINLINE poly k_LmShallowCopyDelete_currRing_2_tailRing(poly p, ring tailRing);

 KINLINE poly k_LmShallowCopyDelete_tailRing_2_currRing(poly p, ring tailRing);


 // if exp bound is not violated, return TRUE and

 //                               get m1 = LCM(LM(p1), LM(p2))/LM(p1)

 //                                   m2 = LCM(LM(p1), LM(p2))/LM(p2)

 // return FALSE and m1 == NULL, m2 == NULL     , otherwise

 KINLINE BOOLEAN k_GetLeadTerms(const poly p1, const poly p2, const ring p_r,

                                poly &m1, poly &m2, const ring m_r);

 #ifdef HAVE_RINGS

 KINLINE void k_GetStrongLeadTerms(const poly p1, const poly p2, const ring leadRing,

                                poly &m1, poly &m2, poly &lcm, const ring taiRing);

 #endif

 #ifdef KDEBUG

 // test strat

 BOOLEAN kTest(kStrategy strat);

 // test strat, and test that S is contained in T

 BOOLEAN kTest_TS(kStrategy strat);

 // test LObject

 BOOLEAN kTest_L(LObject* L, ring tailRing = NULL,

                  BOOLEAN testp = FALSE, int lpos = -1,

                  TSet T = NULL, int tlength = -1);

 // test TObject

 BOOLEAN kTest_T(TObject* T, ring tailRing = NULL, int tpos = -1, char TN = '?');

 // test set strat->SevS

 BOOLEAN kTest_S(kStrategy strat);

 #else

 #define kTest(A)        (TRUE)

 #define kTest_TS(A)     (TRUE)

 #define kTest_T(T)      (TRUE)

 #define kTest_S(T)      (TRUE)

 #define kTest_L(T)      (TRUE)

 #endif


 /***************************************************************

  *

  * From kstd2.cc

  *

  ***************************************************************/

 poly kFindZeroPoly(poly input_p, ring leadRing, ring tailRing);

 ideal bba (ideal F, ideal Q,intvec *w,intvec *hilb,kStrategy strat);

 ideal sba (ideal F, ideal Q,intvec *w,intvec *hilb,kStrategy strat);

 poly kNF2 (ideal F, ideal Q, poly q, kStrategy strat, int lazyReduce);

 ideal kNF2 (ideal F,ideal Q,ideal q, kStrategy strat, int lazyReduce);

 void initBba(ideal F,kStrategy strat);

 void initSba(ideal F,kStrategy strat);

 void f5c (kStrategy strat, int& olddeg, int& minimcnt, int& hilbeledeg,

           int& hilbcount, int& srmax, int& lrmax, int& reduc, ideal Q,

           intvec *w,intvec *hilb );


 /***************************************************************

  *

  * From kspoly.cc

  *

  ***************************************************************/

 // Reduces PR with PW

 // Assumes PR != NULL, PW != NULL, Lm(PW) divides Lm(PR)

 // Changes: PR

 // Const:   PW

 // If coef != NULL, then *coef is a/gcd(a,b), where a = LC(PR), b = LC(PW)

 // If strat != NULL, tailRing is changed if reduction would violate exp bound

 // of tailRing

 // Returns: 0 everything ok, no tailRing change

 //          1 tailRing has successfully changed (strat != NULL)

 //          2 no reduction performed, tailRing needs to be changed first

 //            (strat == NULL)

 //         -1 tailRing change could not be performed due to exceeding exp

 //            bound of currRing

 int ksReducePoly(LObject* PR,

                  TObject* PW,

                  poly spNoether = NULL,

                  number *coef = NULL,

                  kStrategy strat = NULL);


 // Reduces PR with PW

 // Assumes PR != NULL, PW != NULL, Lm(PW) divides Lm(PR)

 // Changes: PR

 // Const:   PW

 // If coef != NULL, then *coef is a/gcd(a,b), where a = LC(PR), b = LC(PW)

 // If strat != NULL, tailRing is changed if reduction would violate exp bound

 // of tailRing

 // Returns: 0 everything ok, no tailRing change

 //          1 tailRing has successfully changed (strat != NULL)

 //          2 no reduction performed, tailRing needs to be changed first

 //            (strat == NULL)

 //          3 no reduction performed, not sig-safe!!!

 //         -1 tailRing change could not be performed due to exceeding exp

 //            bound of currRing

 int ksReducePolySig(LObject* PR,

                  TObject* PW,

                  long idx,

                  poly spNoether = NULL,

                  number *coef = NULL,

                  kStrategy strat = NULL);


 // Reduces PR at Current->next with PW

 // Assumes PR != NULL, Current contained in PR

 //         Current->next != NULL, LM(PW) devides LM(Current->next)

 // Changes: PR

 // Const:   PW

 // Return: see ksReducePoly

 int ksReducePolyTail(LObject* PR,

                      TObject* PW,

                      poly Current,

                      poly spNoether = NULL);


 KINLINE int ksReducePolyTail(LObject* PR, TObject* PW, LObject* Red);


 // Creates S-Poly of Pair

 // Const:   Pair->p1, Pair->p2

 // Changes: Pair->p == S-Poly of p1, p2

 // Assume:  Pair->p1 != NULL && Pair->p2

 void ksCreateSpoly(LObject* Pair, poly spNoether = NULL,

                    int use_buckets=0, ring tailRing=currRing,

                    poly m1 = NULL, poly m2 = NULL, TObject** R = NULL);


 /*2

 * creates the leading term of the S-polynomial of p1 and p2

 * do not destroy p1 and p2

 * remarks:

 *   1. the coefficient is 0 (nNew)

 *   2. pNext is undefined

 */

 poly ksCreateShortSpoly(poly p1, poly p2, ring tailRing);


 // old stuff

 KINLINE poly ksOldSpolyRed(poly p1, poly p2, poly spNoether = NULL);

 KINLINE poly ksOldSpolyRedNew(poly p1, poly p2, poly spNoether = NULL);

 KINLINE poly ksOldCreateSpoly(poly p1, poly p2, poly spNoether = NULL, ring r = currRing);

 KINLINE void ksOldSpolyTail(poly p1, poly q, poly q2, poly spNoether, ring r = currRing);


 /***************************************************************

  *

  * Routines related for ring changes during std computations

  *

  ***************************************************************/

 // return TRUE and set m1, m2 to k_GetLcmTerms,

 //             if spoly creation of strat->P does not violate

 //             exponent bound of strat->tailRing

 //      FALSE, otherwise

 BOOLEAN kCheckSpolyCreation(LObject* L, kStrategy strat, poly &m1, poly &m2);

 #ifdef HAVE_RINGS

 // return TRUE if gcdpoly creation of R[atR] and S[atS] does not violate

 //             exponent bound of strat->tailRing

 //      FALSE, otherwise

 BOOLEAN kCheckStrongCreation(int atR, poly m1, int atS, poly m2, kStrategy strat);

 #endif

 // change strat->tailRing and adjust all data in strat, L, and T:

 // new tailRing has larger exponent bound

 // do nothing and return FALSE if exponent bound increase would result in

 // larger exponent bound that that of currRing

 BOOLEAN kStratChangeTailRing(kStrategy strat,

                              LObject* L = NULL, TObject* T = NULL,

                              // take this as new_expbound: if 0

                              // new expbound is 2*expbound of tailRing

                              unsigned long new_expbound = 0);

 // initiate a change of the tailRing of strat -- should be called

 // right before main loop in bba

 void kStratInitChangeTailRing(kStrategy strat);


 /// Output some debug info about a given strategy

 void kDebugPrint(kStrategy strat);


 // getting sb order for sba computations

 ring sbaRing(kStrategy strat, const ring r=currRing, BOOLEAN complete=TRUE, int sgn=1);


 KINLINE void clearS (poly p, unsigned long p_sev, int* at, int* k,

   kStrategy strat);


 #include <kernel/GBEngine/kInline.h>


 /* shiftgb stuff */

 #include <kernel/GBEngine/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);


 void initBuchMoraShift (ideal F,ideal Q,kStrategy strat);


 void enterOnePairManyShifts (int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR, int uptodeg, int lV); // ok


 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 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);


 void initenterpairsShift (poly h,int k,int ecart,int isFromQ,kStrategy strat, int atR,int uptodeg, int lV);


 void updateSShift(kStrategy strat,int uptodeg,int lV);


 void initBbaShift(ideal F,kStrategy strat);


 poly redtailBbaShift (LObject* L, int pos, kStrategy strat, BOOLEAN withT, BOOLEAN normalize);


 int redFirstShift (LObject* h,kStrategy strat); // ok


 ideal freegb(ideal I, int uptodeg, int lVblock);


 ideal bbaShift(ideal F, ideal Q,intvec *w,intvec *hilb,kStrategy strat, int uptodeg, int lV);

 // test syz strategy: // will be removed soon

 extern  int (*test_PosInT)(const TSet T,const int tl,LObject &h);

 extern  int (*test_PosInL)(const LSet set, const int length,

                 LObject* L,const kStrategy strat);

 #endif

initR
KINLINE TObject ** initR()
Definition: kInline.h:92

skStrategy::sevSig
unsigned long * sevSig
Definition: kutil.h:322

sLObject::Init
KINLINE void Init(ring tailRing=currRing)
Definition: kInline.h:506

kFindInT
int kFindInT(poly p, TSet T, int tlength)
returns index of p in TSet, or -1 if not found
Definition: kutil.cc:603

kStrategy
skStrategy * kStrategy
Definition: kutil.h:271

deleteHC
void deleteHC(poly *p, int *e, int *l, kStrategy strat)
Definition: kutil.cc:310

sLObject::GetpLength
KINLINE int GetpLength()
Definition: kInline.h:809

sLObject::GetP
KINLINE poly GetP(omBin lmBin=NULL)
Definition: kInline.h:679

int
const const intvec const intvec const ring _currRing const const intvec const intvec const ring _currRing int
Definition: gb_hack.h:53

denominator_list
denominator_list_s * denominator_list
Definition: kutil.h:63

skStrategy::sig
polyset sig
Definition: kutil.h:306

posInT_pLength
int posInT_pLength(const TSet set, const int length, LObject &p)
Definition: kutil.cc:8746

posInLSig
int posInLSig(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.cc:4599

skStrategy::posInL
int(* posInL)(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.h:283

skStrategy::nr
int nr
Definition: kutil.h:347

skStrategy::honey
BOOLEAN honey
Definition: kutil.h:371

skStrategy
Definition: kutil.h:273

copy
CFArray copy(const CFList &list)
write elements of list into an array
Definition: facFqBivarUtil.cc:364

initSba
void initSba(ideal F, kStrategy strat)
Definition: kstd1.cc:1334

entersets
void entersets(LObject h)

structs.h

normalize
static poly normalize(poly next_p, ideal add_generators, syStrategy syzstr, int *g_l, int *p_l, int crit_comp)
Definition: syz3.cc:1028

initSyzRules
void initSyzRules(kStrategy strat)
Definition: kutil.cc:6087

setmaxL
#define setmaxL
Definition: kutil.h:27

sLObject::SetShortExpVector
KINLINE void SetShortExpVector()
Definition: kInline.h:717

lcm
int lcm(unsigned long *l, unsigned long *a, unsigned long *b, unsigned long p, int dega, int degb)
Definition: minpoly.cc:711

initSbaCrit
void initSbaCrit(kStrategy strat)
Definition: kutil.cc:7382

omBin
omBin_t * omBin
Definition: omStructs.h:12

skStrategy::syzComp
int syzComp
Definition: kutil.h:357

updateResult
void updateResult(ideal r, ideal Q, kStrategy strat)
Definition: kutil.cc:7864

sTObject::is_redundant
BOOLEAN is_redundant
Definition: kutil.h:88

initEcartNormal
void initEcartNormal(TObject *h)
Definition: kutil.cc:1125

enterOnePairSelfShifts
void enterOnePairSelfShifts(poly qq, poly p, int ecart, int isFromQ, kStrategy strat, int atR, int uptodeg, int lV)
Definition: kutil.cc:9210

message
void message(int i, int *reduc, int *olddeg, kStrategy strat, int red_result)
Definition: kutil.cc:5628

sTObject::Set
KINLINE void Set(ring r=currRing)
Definition: kInline.h:103

skStrategy::rewCrit1
BOOLEAN(* rewCrit1)(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
Definition: kutil.h:292

sLObject::i_r1
int i_r1
Definition: kutil.h:199

skStrategy::syzmax
int syzmax
Definition: kutil.h:352

sTObject::is_normalized
BOOLEAN is_normalized
Definition: kutil.h:82

ksOldSpolyRed
KINLINE poly ksOldSpolyRed(poly p1, poly p2, poly spNoether=NULL)
Definition: kInline.h:1082

sLObject::bucket
kBucket_pt bucket
Definition: kutil.h:198

skStrategy::kHEdge
poly kHEdge
Definition: kutil.h:327

posInT11
int posInT11(const TSet set, const int length, LObject &p)
Definition: kutil.cc:4034

skStrategy::pOrigLDeg_TailRing
pLDegProc pOrigLDeg_TailRing
Definition: kutil.h:298

LObject
class sLObject LObject
Definition: kutil.h:58

skStrategy::length_pLength
BOOLEAN length_pLength
Definition: kutil.h:382

TSet
TObject * TSet
Definition: kutil.h:59

mylimits.h

posInL15
int posInL15(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.cc:4899

skStrategy::lenSw
wlen_set lenSw
Definition: kutil.h:318

skStrategy::Ll
int Ll
Definition: kutil.h:354

kTest_S
#define kTest_S(T)
Definition: kutil.h:618

sgn
int sgn(const Rational &a)
Definition: GMPrat.cc:437

sLObject::operator=
KINLINE sLObject & operator=(const sTObject &)
Definition: kInline.h:850

sTObject::Next
KINLINE poly Next()
Definition: kInline.h:280

FALSE
#define FALSE
Definition: auxiliary.h:140

skStrategy::noTailReduction
BOOLEAN noTailReduction
Definition: kutil.h:372

polys.h
Compatiblity layer for legacy polynomial operations (over currRing)

skStrategy::S_2_R
int * S_2_R
Definition: kutil.h:342

p
return P p
Definition: myNF.cc:203

kStratChangeTailRing
BOOLEAN kStratChangeTailRing(kStrategy strat, LObject *L=NULL, TObject *T=NULL, unsigned long new_expbound=0)
Definition: kutil.cc:8231

f
f
Definition: cfModGcd.cc:4022

initSbaBuchMora
void initSbaBuchMora(ideal F, ideal Q, kStrategy strat)
Definition: kutil.cc:7751

skStrategy::c3
int c3
Definition: kutil.h:349

f5c
void f5c(kStrategy strat, int &olddeg, int &minimcnt, int &hilbeledeg, int &hilbcount, int &srmax, int &lrmax, int &reduc, ideal Q, intvec *w, intvec *hilb)
Definition: kstd2.cc:2551

ksReducePolySig
int ksReducePolySig(LObject *PR, TObject *PW, long idx, poly spNoether=NULL, number *coef=NULL, kStrategy strat=NULL)
Definition: kspoly.cc:172

syzCriterion
BOOLEAN syzCriterion(poly sig, unsigned long not_sevSig, kStrategy strat)
Definition: kutil.cc:5071

redtailBbaShift
poly redtailBbaShift(LObject *L, int pos, kStrategy strat, BOOLEAN withT, BOOLEAN normalize)
Definition: kutil.cc:9721

skStrategy::news
char news
Definition: kutil.h:395

posInT15
int posInT15(const TSet set, const int length, LObject &p)
Definition: kutil.cc:4281

redNF
poly redNF(poly h, int &max_ind, int nonorm, kStrategy strat)
Definition: kstd2.cc:1189

kFindDivisibleByInS
int kFindDivisibleByInS(const kStrategy strat, int *max_ind, LObject *L)
return -1 if no divisor is found number of first divisor in S, otherwise
Definition: kstd2.cc:149

enterpairsShift
void enterpairsShift(poly h, int k, int ecart, int pos, kStrategy strat, int atR, int uptodeg, int lV)
Definition: kutil.cc:9571

skStrategy::newt
char newt
Definition: kutil.h:396

chainCritNormal
void chainCritNormal(poly p, int ecart, kStrategy strat)
Definition: kutil.cc:2186

ksCreateShortSpoly
poly ksCreateShortSpoly(poly p1, poly p2, ring tailRing)
Definition: kspoly.cc:563

skStrategy::NotUsedAxis
BOOLEAN * NotUsedAxis
Definition: kutil.h:332

tailRing
BEGIN_NAMESPACE_SINGULARXX const ring const ring tailRing
Definition: DebugPrint.h:30

skStrategy::posInLDependsOnLength
BOOLEAN posInLDependsOnLength
Definition: kutil.h:384

k_GetLeadTerms
KINLINE BOOLEAN k_GetLeadTerms(const poly p1, const poly p2, const ring p_r, poly &m1, poly &m2, const ring m_r)
Definition: kInline.h:964

skStrategy::posInLSba
int(* posInLSba)(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.h:281

sLObject::sLObject
KINLINE sLObject(ring tailRing=currRing)
Definition: kInline.h:514

k_LmShallowCopyDelete_tailRing_2_currRing
KINLINE poly k_LmShallowCopyDelete_tailRing_2_currRing(poly p, ring tailRing, omBin bin)
Definition: kInline.h:930

skStrategy::rewCrit2
BOOLEAN(* rewCrit2)(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
Definition: kutil.h:293

sTObject::Init
KINLINE void Init(ring r=currRing)
Definition: kInline.h:107

ideal
const ideal
Definition: gb_hack.h:42

sTObject::length
int length
Definition: kutil.h:78

n
const CanonicalForm CFMap CFMap int &both_non_zero int n
Definition: cfEzgcd.cc:52

skStrategy::noetherSet
BOOLEAN noetherSet
Definition: kutil.h:374

enterOnePairManyShifts
void enterOnePairManyShifts(int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR, int uptodeg, int lV)
Definition: kutil.cc:9134

skStrategy::cv
int cv
Definition: kutil.h:350

messageStat
void messageStat(int hilbcount, kStrategy strat)
Definition: kutil.cc:5669

sTObject::IsNull
KINLINE BOOLEAN IsNull() const
Definition: kInline.h:263

k_LmInit_tailRing_2_currRing
KINLINE poly k_LmInit_tailRing_2_currRing(poly p, ring tailRing, omBin bin)
Definition: kInline.h:914

skStrategy::pairtest
BOOLEAN * pairtest
Definition: kutil.h:333

max_ind
int & max_ind
Definition: myNF.cc:67

skStrategy::z2homog
BOOLEAN z2homog
Definition: kutil.h:368

skStrategy::kNoether
poly kNoether
Definition: kutil.h:328

skStrategy::tl
int tl
Definition: kutil.h:353

sLObject::HeadNormalize
KINLINE void HeadNormalize()
Definition: kInline.h:334

skStrategy::Bl
int Bl
Definition: kutil.h:355

bba
ideal bba(ideal F, ideal Q, intvec *w, intvec *hilb, kStrategy strat)
Definition: kstd2.cc:1338

int64
long int64
Definition: auxiliary.h:112

initSbaPos
void initSbaPos(kStrategy strat)
Definition: kutil.cc:7655

enterOnePairSig
void enterOnePairSig(int i, poly p, poly pSig, int ecart, int isFromQ, kStrategy strat, int atR)

skStrategy::noClearS
char noClearS
Definition: kutil.h:397

TRUE
#define TRUE
Definition: auxiliary.h:144

kTest
#define kTest(A)
Definition: kutil.h:615

kCreateZeroPoly
poly kCreateZeroPoly(long exp[], long cabsind, poly *t_p, ring leadRing, ring tailRing)
Definition: kutil.cc:3256

skStrategy::p_shallow_copy_delete
pShallowCopyDeleteProc p_shallow_copy_delete
Definition: kutil.h:338

skStrategy::sevT
unsigned long * sevT
Definition: kutil.h:323

skStrategy::rewCrit3
BOOLEAN(* rewCrit3)(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
Definition: kutil.h:294

skStrategy::initEcartPair
void(* initEcartPair)(LObject *h, poly f, poly g, int ecartF, int ecartG)
Definition: kutil.h:286

enterpairsSig
void enterpairsSig(poly h, poly hSig, int from, int k, int ec, int pos, kStrategy strat, int atR=-1)
Definition: kutil.cc:3703

pMove2CurrTail
poly pMove2CurrTail(poly p, kStrategy strat)
Definition: kutil.cc:8897

kCheckStrongCreation
BOOLEAN kCheckStrongCreation(int atR, poly m1, int atS, poly m2, kStrategy strat)
Definition: kutil.cc:8214

superenterpairs
void superenterpairs(poly h, int k, int ecart, int pos, kStrategy strat, int atR=-1)
Definition: kutil.cc:3597

skStrategy::ak
int ak
Definition: kutil.h:356

initS
void initS(ideal F, ideal Q, kStrategy strat)
Definition: kutil.cc:5733

g
g
Definition: cfModGcd.cc:4031

bbaShift
ideal bbaShift(ideal F, ideal Q, intvec *w, intvec *hilb, kStrategy strat, int uptodeg, int lV)
Definition: kstd2.cc:2868

initHilbCrit
void initHilbCrit(ideal F, ideal Q, intvec **hilb, kStrategy strat)
Definition: kutil.cc:7305

k
int k
Definition: cfEzgcd.cc:93

sTObject::pNorm
KINLINE void pNorm()
Definition: kInline.h:473

test_PosInT
int(* test_PosInT)(const TSet T, const int tl, LObject &h)
Definition: kstd2.cc:95

initBuchMora
void initBuchMora(ideal F, ideal Q, kStrategy strat)
Definition: kutil.cc:7558

Q
#define Q
Definition: sirandom.c:25

twoPow
long twoPow(long arg)
Definition: kutil.cc:3063

initsevT
KINLINE unsigned long * initsevT()
Definition: kInline.h:97

redHomog
int redHomog(LObject *h, kStrategy strat)
Definition: kstd2.cc:406

enterExtendedSpoly
void enterExtendedSpoly(poly h, kStrategy strat)
Definition: kutil.cc:3481

initEcartBBA
void initEcartBBA(TObject *h)
Definition: kutil.cc:1133

sLObject::Tail_Minus_mm_Mult_qq
KINLINE void Tail_Minus_mm_Mult_qq(poly m, poly qq, int lq, poly spNoether)
Definition: kInline.h:580

skStrategy::red
int(* red)(LObject *L, kStrategy strat)
Definition: kutil.h:277

omAlloc
#define omAlloc(size)
Definition: omAllocDecl.h:210

KINLINE
#define KINLINE
Definition: kutil.h:49

HEckeTest
void HEckeTest(poly pp, kStrategy strat)
Definition: kutil.cc:422

skStrategy::posInT
int(* posInT)(const TSet T, const int tl, LObject &h)
Definition: kutil.h:280

skStrategy::currIdx
unsigned long currIdx
Definition: kutil.h:315

pLDegProc
long(* pLDegProc)(poly p, int *length, ring r)
Definition: ring.h:45

exitBuchMora
void exitBuchMora(kStrategy strat)
Definition: kutil.cc:7637

skStrategy::minim
int minim
Definition: kutil.h:361

posInLF5C
int posInLF5C(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.cc:4652

initBuchMoraCrit
void initBuchMoraCrit(kStrategy strat)
Definition: kutil.cc:7325

skStrategy::Bmax
int Bmax
Definition: kutil.h:355

sLObject::PrepareRed
KINLINE void PrepareRed(BOOLEAN use_bucket)
Definition: kInline.h:530

createG0
ideal createG0()
Definition: kutil.cc:3385

pp
poly pp
Definition: myNF.cc:296

skStrategy::lastAxis
int lastAxis
Definition: kutil.h:359

initSLSba
void initSLSba(ideal F, ideal Q, kStrategy strat)
Definition: kutil.cc:5935

skStrategy::syzCrit
BOOLEAN(* syzCrit)(poly sig, unsigned long not_sevSig, kStrategy strat)
Definition: kutil.h:291

sLObject::Tail_Mult_nn
KINLINE void Tail_Mult_nn(number n)
Definition: kInline.h:566

sTObject::LmDeleteAndIter
KINLINE void LmDeleteAndIter()
Definition: kInline.h:288

sLObject::Copy
KINLINE void Copy()
Definition: kInline.h:729

sLObject::SetLmTail
KINLINE void SetLmTail(poly lm, poly new_p, int length, int use_bucket, ring r)
Definition: kInline.h:548

skStrategy::skStrategy
skStrategy()
Definition: kutil.cc:8579

skStrategy::completeReduce_retry
char completeReduce_retry
Definition: kutil.h:398

chainCritSig
void chainCritSig(poly p, int ecart, kStrategy strat)
Definition: kutil.cc:2401

sTObject::i_r
int i_r
Definition: kutil.h:78

sTObject::sTObject
KINLINE sTObject(ring tailRing=currRing)
Definition: kInline.h:113

strat_fac_debug
int strat_fac_debug
Definition: kstdfac.cc:29

skStrategy::HCord
int HCord
Definition: kutil.h:358

updateS
void updateS(BOOLEAN toT, kStrategy strat)
Definition: kutil.cc:6695

sTObject::t_p
poly t_p
Definition: kutil.h:74

sTObject::GetpLength
KINLINE int GetpLength()
Definition: kInline.h:268

skStrategy::pOrigFDeg
pFDegProc pOrigFDeg
Definition: kutil.h:295

ksOldSpolyTail
KINLINE void ksOldSpolyTail(poly p1, poly q, poly q2, poly spNoether, ring r=currRing)
Definition: kInline.h:1112

skStrategy::interpt
BOOLEAN interpt
Definition: kutil.h:365

posInT2
int posInT2(const TSet set, const int length, LObject &p)
Definition: kutil.cc:4004

skStrategy::initEcart
void(* initEcart)(TObject *L)
Definition: kutil.h:279

kStratInitChangeTailRing
void kStratInitChangeTailRing(kStrategy strat)
Definition: kutil.cc:8334

currRing
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12

ind2
long ind2(long arg)
Definition: kutil.cc:3036

redRiloc
int redRiloc(LObject *h, kStrategy strat)
Definition: kstd1.cc:351

redNFTail
poly redNFTail(poly h, const int sl, kStrategy strat)

ksOldCreateSpoly
KINLINE poly ksOldCreateSpoly(poly p1, poly p2, poly spNoether=NULL, ring r=currRing)
Definition: kInline.h:1102

skStrategy::enterOnePair
void(* enterOnePair)(int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR)
Definition: kutil.h:289

ind_fact_2
long ind_fact_2(long arg)
Definition: kutil.cc:3048

sTObject::Copy
KINLINE void Copy()
Definition: kInline.h:200

skStrategy::lV
int lV
Definition: kutil.h:363

sTObject::max
poly max
Definition: kutil.h:75

skStrategy::fromT
BOOLEAN fromT
Definition: kutil.h:373

r
const ring r
Definition: syzextra.cc:208

posInT13
int posInT13(const TSet set, const int length, LObject &p)
Definition: kutil.cc:4213

skStrategy::pOrigLDeg
pLDegProc pOrigLDeg
Definition: kutil.h:296

posInT0
int posInT0(const TSet set, const int length, LObject &p)
Definition: kutil.cc:3965

skStrategy::homog
BOOLEAN homog
Definition: kutil.h:366

initEcartPairMora
void initEcartPairMora(LObject *Lp, poly f, poly g, int ecartF, int ecartG)
Definition: kutil.cc:1147

initBuchMoraPos
void initBuchMoraPos(kStrategy strat)
Definition: kutil.cc:7466

skStrategy::S_2_T
KINLINE TObject * S_2_T(int i)
Definition: kInline.h:35

sLObject::pLDeg
KINLINE long pLDeg()
Definition: kInline.h:764

intvec
Definition: intvec.h:16

sTObject::FDeg
long FDeg
Definition: kutil.h:77

posInL17
int posInL17(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.cc:4957

kTest_TS
#define kTest_TS(A)
Definition: kutil.h:616

posInL110
int posInL110(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.cc:4818

skStrategy::max_lower_index
int max_lower_index
Definition: kutil.h:316

j
int j
Definition: myNF.cc:70

sLObject::p1
poly p1
Definition: kutil.h:194

sTObject::pTotalDeg
KINLINE long pTotalDeg() const
Definition: kInline.h:400

pairs
void pairs()

sTObject::Clear
KINLINE void Clear()
Definition: kInline.h:189

sLObject::LmDeleteAndIter
KINLINE void LmDeleteAndIter()
Definition: kInline.h:602

skStrategy::Gebauer
BOOLEAN Gebauer
Definition: kutil.h:372

poly
polyrec * poly
Definition: hilb.h:10

skStrategy::fromQ
intset fromQ
Definition: kutil.h:319

messageSets
#define messageSets(s)
Definition: kutil.h:506

kInline.h

denominator_list_s::n
number n
Definition: kutil.h:65

enterOnePairNormal
void enterOnePairNormal(int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR)
Definition: kutil.cc:1490

k_LmShallowCopyDelete_currRing_2_tailRing
KINLINE poly k_LmShallowCopyDelete_currRing_2_tailRing(poly p, ring tailRing, omBin bin)
Definition: kInline.h:923

posInTSig
int posInTSig(const TSet set, const int length, LObject &p)

ksCreateSpoly
void ksCreateSpoly(LObject *Pair, poly spNoether=NULL, int use_buckets=0, ring tailRing=currRing, poly m1=NULL, poly m2=NULL, TObject **R=NULL)
Definition: kspoly.cc:376

LSet
LObject * LSet
Definition: kutil.h:60

sLObject::T_2
KINLINE TObject * T_2(const skStrategy *strat)
Definition: kInline.h:867

sLObject::CanonicalizeP
KINLINE poly CanonicalizeP()
Definition: kInline.h:648

initBbaShift
void initBbaShift(ideal F, kStrategy strat)
Definition: kstd2.cc:3374

initT
KINLINE TSet initT()
Definition: kInline.h:81

posInL0
int posInL0(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.cc:4568

enterSSba
void enterSSba(LObject p, int atS, kStrategy strat, int atR=-1)
Definition: kutil.cc:7030

sTObject::ShallowCopyDelete
KINLINE void ShallowCopyDelete(ring new_tailRing, omBin new_tailBin, pShallowCopyDeleteProc p_shallow_copy_delete, BOOLEAN set_max=TRUE)
Definition: kInline.h:348

sba
ideal sba(ideal F, ideal Q, intvec *w, intvec *hilb, kStrategy strat)
Definition: kstd2.cc:1670

kTest_L
#define kTest_L(T)
Definition: kutil.h:619

kDebugPrint
void kDebugPrint(kStrategy strat)
Output some debug info about a given strategy.
Definition: kutil.cc:8780

freegb
ideal freegb(ideal I, int uptodeg, int lVblock)
Definition: kstd2.cc:3214

deleteInSSba
void deleteInSSba(int i, kStrategy strat)
Definition: kutil.cc:984

posInS
int posInS(const kStrategy strat, const int length, const poly p, const int ecart_p)
Definition: kutil.cc:3860

redRing
int redRing(LObject *h, kStrategy strat)
Definition: kstd2.cc:324

initBba
void initBba(ideal F, kStrategy strat)
Definition: kstd1.cc:1279

sTObject::SetLmCurrRing
KINLINE void SetLmCurrRing()
Definition: kInline.h:274

m
int m
Definition: cfEzgcd.cc:119

arriRewDummy
KINLINE BOOLEAN arriRewDummy(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
Definition: kInline.h:1158

skStrategy::P
LObject P
Definition: kutil.h:300

HCord
int HCord
Definition: kutil.cc:227

skStrategy::M
ideal M
Definition: kutil.h:303

skStrategy::sbaOrder
unsigned sbaOrder
Definition: kutil.h:314

skStrategy::update
BOOLEAN update
Definition: kutil.h:375

i
int i
Definition: cfEzgcd.cc:123

sLObject
Definition: kutil.h:180

skStrategy::tail
poly tail
Definition: kutil.h:334

sLObject::Normalize
KINLINE void Normalize()
Definition: kInline.h:321

initenterpairsShift
void initenterpairsShift(poly h, int k, int ecart, int isFromQ, kStrategy strat, int atR, int uptodeg, int lV)
Definition: kutil.cc:9605

redtailSba
poly redtailSba(LObject *L, int pos, kStrategy strat, BOOLEAN withT=FALSE, BOOLEAN normalize=FALSE)
Definition: kstd2.cc:733

skStrategy::posInLOld
int(* posInLOld)(const LSet Ls, const int Ll, LObject *Lo, const kStrategy strat)
Definition: kutil.h:287

skStrategy::R
TObject ** R
Definition: kutil.h:340

sLObject::lcm
poly lcm
Definition: kutil.h:197

sLObject::Comp
KINLINE long Comp()
Definition: kInline.h:841

skStrategy::S
polyset S
Definition: kutil.h:304

posInSyz
int posInSyz(const kStrategy strat, const poly sig)
Definition: kutil.cc:4624

skStrategy::sugarCrit
BOOLEAN sugarCrit
Definition: kutil.h:371

skStrategy::lenS
intset lenS
Definition: kutil.h:317

redFirstShift
int redFirstShift(LObject *h, kStrategy strat)
Definition: kstd2.cc:3248

posInT110
int posInT110(const TSet set, const int length, LObject &p)
Definition: kutil.cc:4167

skStrategy::tmax
int tmax
Definition: kutil.h:353

initBuchMoraShift
void initBuchMoraShift(ideal F, ideal Q, kStrategy strat)
Definition: kutil.cc:9049

cleanT
void cleanT(kStrategy strat)
Definition: kutil.cc:491

skStrategy::cp
int cp
Definition: kutil.h:349

sLObject::checked
unsigned long checked
Definition: kutil.h:185

posInT17
int posInT17(const TSet set, const int length, LObject &p)
Definition: kutil.cc:4339

sTObject::pCleardenom
KINLINE void pCleardenom()
Definition: kInline.h:431

sTObject::pLength
int pLength
Definition: kutil.h:78

newHEdge
BOOLEAN newHEdge(kStrategy strat)
Definition: kutil.cc:8113

initEcartPairBba
void initEcartPairBba(LObject *Lp, poly f, poly g, int ecartF, int ecartG)
Definition: kutil.cc:1140

sTObject::sig
poly sig
Definition: kutil.h:72

denominator_list_s
Definition: kutil.h:65

strat
kStrategy strat
Definition: myNF.cc:319

cancelunit
void cancelunit(LObject *p, BOOLEAN inNF=FALSE)
Definition: kutil.cc:324

posInT_EcartFDegpLength
int posInT_EcartFDegpLength(const TSet set, const int length, LObject &p)
Definition: kutil.cc:8655

sTObject
Definition: kutil.h:68

skStrategy::kHEdgeFound
BOOLEAN kHEdgeFound
Definition: kutil.h:370

skStrategy::ecartS
intset ecartS
Definition: kutil.h:307

exitSba
void exitSba(kStrategy strat)
Definition: kutil.cc:7830

pMoveCurrTail2poly
poly pMoveCurrTail2poly(poly p, kStrategy strat)
Definition: kutil.cc:8911

skStrategy::t_kHEdge
poly t_kHEdge
Definition: kutil.h:329

skStrategy::interred_flag
BOOLEAN interred_flag
Definition: kutil.h:378

reorderS
void reorderS(int *suc, kStrategy strat)
Definition: kutil.cc:3807

pShallowCopyDeleteProc
poly(* pShallowCopyDeleteProc)(poly s_p, ring source_r, ring dest_r, omBin dest_bin)
returns a poly from dest_r which is a ShallowCopy of s_p from source_r assumes that source_r->N == de...
Definition: ring.h:52

sTObject::GetLmCurrRing
KINLINE poly GetLmCurrRing()
Definition: kInline.h:217

skStrategy::chainCrit
void(* chainCrit)(poly p, int ecart, kStrategy strat)
Definition: kutil.h:290

sLObject::p2
poly p2
Definition: kutil.h:194

ksReducePolyTail
int ksReducePolyTail(LObject *PR, TObject *PW, poly Current, poly spNoether=NULL)
Definition: kspoly.cc:491

skStrategy::L
LSet L
Definition: kutil.h:325

skStrategy::LDegLast
BOOLEAN LDegLast
Definition: kutil.h:380

NULL
#define NULL
Definition: omList.c:10

skStrategy::kHomW
intvec * kHomW
Definition: kutil.h:336

polyset
poly * polyset
Definition: hutil.h:17

skStrategy::B
LSet B
Definition: kutil.h:326

skStrategy::Lmax
int Lmax
Definition: kutil.h:354

sTObject::Mult_nn
KINLINE void Mult_nn(number n)
Definition: kInline.h:309

wlen_type
int64 wlen_type
Definition: kutil.h:54

skStrategy::mu
int mu
Definition: kutil.h:351

enterpairs
void enterpairs(poly h, int k, int ec, int pos, kStrategy strat, int atR=-1)
Definition: kutil.cc:3671

redtailBba_Z
KINLINE poly redtailBba_Z(poly p, int pos, kStrategy strat)
Definition: kInline.h:1127

enterOnePairShift
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)
Definition: kutil.cc:9275

skStrategy::tailRing
ring tailRing
Definition: kutil.h:343

updateSShift
void updateSShift(kStrategy strat, int uptodeg, int lV)
Definition: kutil.cc:9021

homogTest
BOOLEAN homogTest(polyset F, int Fmax)

pFDegProc
long(* pFDegProc)(poly p, ring r)
Definition: ring.h:46

sTObject::GetLmTailRing
KINLINE poly GetLmTailRing()
Definition: kInline.h:224

completeReduce
void completeReduce(kStrategy strat, BOOLEAN withT=FALSE)
Definition: kutil.cc:7991

sTObject::pLDeg
KINLINE long pLDeg()
Definition: kInline.h:415

enterL
void enterL(LSet *set, int *length, int *LSetmax, LObject p, int at)
Definition: kutil.cc:1101

clearS
KINLINE void clearS(poly p, unsigned long p_sev, int *at, int *k, kStrategy strat)
Definition: kInline.h:1145

sLObject::GetTP
KINLINE poly GetTP()
Definition: kInline.h:663

R
#define R
Definition: sirandom.c:26

denominator_list_s::next
denominator_list next
Definition: kutil.h:65

sTObject::is_special
BOOLEAN is_special
Definition: kutil.h:97

skStrategy::t_kNoether
poly t_kNoether
Definition: kutil.h:331

skStrategy::tailBin
omBin tailBin
Definition: kutil.h:345

skStrategy::D
ideal D
Definition: kutil.h:302

w
const CanonicalForm & w
Definition: facAbsFact.cc:55

shiftgb.h

arriRewCriterionPre
BOOLEAN arriRewCriterionPre(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
Definition: kutil.cc:5224

skStrategy::overflow
char overflow
Definition: kutil.h:399

sLObject::SetLength
KINLINE int SetLength(BOOLEAN lengt_pLength=FALSE)
Definition: kInline.h:816

skStrategy::syzidxmax
int syzidxmax
Definition: kutil.h:352

skStrategy::kModW
intvec * kModW
Definition: kutil.h:335

skStrategy::no_prod_crit
BOOLEAN no_prod_crit
Definition: kutil.h:389

skStrategy::~skStrategy
~skStrategy()
Definition: kutil.cc:8602

skStrategy::sevS
unsigned long * sevS
Definition: kutil.h:320

sTObject::SetDegStuffReturnLDeg
KINLINE long SetDegStuffReturnLDeg()
Definition: kInline.h:419

deleteInS
void deleteInS(int i, kStrategy strat)
Definition: kutil.cc:932

arriRewCriterion
BOOLEAN arriRewCriterion(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
Definition: kutil.cc:5201

faugereRewCriterion
BOOLEAN faugereRewCriterion(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
Definition: kutil.cc:5145

skStrategy::posInLOldFlag
BOOLEAN posInLOldFlag
Definition: kutil.h:376

skStrategy::fromS
intset fromS
Definition: kutil.h:308

skStrategy::sevSyz
unsigned long * sevSyz
Definition: kutil.h:321

enterSyz
void enterSyz(LObject p, kStrategy strat, int atT)
Definition: kutil.cc:7240

omalloc.h

posInL10
int posInL10(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kstd1.cc:947

DENOMINATOR_LIST
denominator_list DENOMINATOR_LIST
Definition: kutil.cc:81

kFindZeroPoly
poly kFindZeroPoly(poly input_p, ring leadRing, ring tailRing)
Definition: kstd2.cc:210

intset
int * intset
Definition: kutil.h:53

sLObject::Delete
KINLINE void Delete()
Definition: kInline.h:499

kFindDivisibleByInT
int kFindDivisibleByInT(const TSet &T, const unsigned long *sevT, const int tl, const LObject *L, const int start=0)
return -1 if no divisor is found number of first divisor in T, otherwise
Definition: kstd2.cc:101

skStrategy::s_2_t
KINLINE TObject * s_2_t(int i)
Definition: kInline.h:44

posInT_EcartpLength
int posInT_EcartpLength(const TSet set, const int length, LObject &p)
Definition: kutil.cc:4242

kFindNextDivisibleByInS
int kFindNextDivisibleByInS(const kStrategy strat, int start, int max_ind, LObject *L)
Definition: kstd2.cc:181

skStrategy::syz
polyset syz
Definition: kutil.h:305

deleteInL
void deleteInL(LSet set, int *length, int j, kStrategy strat)
Definition: kutil.cc:1039

skStrategy::sl
int sl
Definition: kutil.h:351

posInL13
int posInL13(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.cc:4864

enterT
void enterT(LObject p, kStrategy strat, int atT=-1)
Definition: kutil.cc:7161

sTObject::pFDeg
KINLINE long pFDeg() const
Definition: kInline.h:395

findMinLMPair
BOOLEAN findMinLMPair(poly sig, unsigned long not_sevSig, kStrategy strat, int start)

skStrategy::T
TSet T
Definition: kutil.h:324

kCheckSpolyCreation
BOOLEAN kCheckSpolyCreation(LObject *L, kStrategy strat, poly &m1, poly &m2)
Definition: kutil.cc:8176

exp
p exp[i]
Definition: DebugPrint.cc:39

sTObject::GetpFDeg
KINLINE long GetpFDeg() const
Definition: kInline.h:410

sLObject::i_r2
int i_r2
Definition: kutil.h:199

wlen_set
wlen_type * wlen_set
Definition: kutil.h:55

skStrategy::lmBin
omBin lmBin
Definition: kutil.h:344

enterTShift
void enterTShift(LObject p, kStrategy strat, int atT, int uptodeg, int lV)
Definition: kutil.cc:9678

sLObject::LmExtractAndIter
KINLINE poly LmExtractAndIter()
Definition: kInline.h:622

redtail
poly redtail(poly p, int pos, kStrategy strat)
Definition: kutil.cc:5406

test_PosInL
int(* test_PosInL)(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kstd2.cc:96

syzCriterionInc
BOOLEAN syzCriterionInc(poly sig, unsigned long not_sevSig, kStrategy strat)
Definition: kutil.cc:5103

sTObject::sevSig
unsigned long sevSig
Definition: kutil.h:71

skStrategy::use_buckets
BOOLEAN use_buckets
Definition: kutil.h:377

p2
END_NAMESPACE const void * p2
Definition: syzextra.cc:202

kFreeStrat
void kFreeStrat(kStrategy strat)

redtailBba
KINLINE poly redtailBba(poly p, int pos, kStrategy strat, BOOLEAN normalize=FALSE)
Definition: kInline.h:1120

kNF2
poly kNF2(ideal F, ideal Q, poly q, kStrategy strat, int lazyReduce)
Definition: kstd2.cc:2395

ksOldSpolyRedNew
KINLINE poly ksOldSpolyRedNew(poly p1, poly p2, poly spNoether=NULL)
Definition: kInline.h:1092

sTObject::GetLm
KINLINE poly GetLm(ring r)
Definition: kInline.h:237

wrp
void wrp(poly p)
Definition: polys.h:281

posInT19
int posInT19(const TSet set, const int length, LObject &p)
Definition: kutil.cc:4468

kTest_T
#define kTest_T(T)
Definition: kutil.h:617

kBucket
Definition: kbuckets.h:177

strat_nr
int strat_nr
Definition: kstdfac.cc:28

P
kBucketDestroy & P
Definition: myNF.cc:191

skStrategy::LazyPass
int LazyPass
Definition: kutil.h:356

sLObject::Clear
KINLINE void Clear()
Definition: kInline.h:493

T
static jList * T
Definition: janet.cc:37

initL
static LSet initL(int nr=setmaxL)
Definition: kutil.h:416

skStrategy::newIdeal
int newIdeal
Definition: kutil.h:360

sLObject::CopyGetP
KINLINE poly CopyGetP()
Definition: kInline.h:745

k_LmInit_currRing_2_tailRing
KINLINE poly k_LmInit_currRing_2_tailRing(poly p, ring tailRing, omBin bin)
Definition: kInline.h:905

redNF0
int redNF0(LObject *P, kStrategy strat)

skStrategy::Shdl
ideal Shdl
Definition: kutil.h:301

posInT_FDegpLength
int posInT_FDegpLength(const TSet set, const int length, LObject &p)
Definition: kutil.cc:8709

sLObject::prod_crit
BOOLEAN prod_crit
Definition: kutil.h:190

skStrategy::enterS
void(* enterS)(LObject h, int pos, kStrategy strat, int atR)
Definition: kutil.h:285

skStrategy::red2
int(* red2)(LObject *L, kStrategy strat)
Definition: kutil.h:278

posInT1
int posInT1(const TSet set, const int length, LObject &p)
Definition: kutil.cc:3976

h
static Poly * h
Definition: janet.cc:978

nonorm
int int nonorm
Definition: myNF.cc:67

BOOLEAN
int BOOLEAN
Definition: auxiliary.h:131

sTObject::SetpFDeg
KINLINE long SetpFDeg()
Definition: kInline.h:405

redLazy
int redLazy(LObject *h, kStrategy strat)
Definition: kstd2.cc:844

skStrategy::next
kStrategy next
Definition: kutil.h:276

skStrategy::kNoetherTail
KINLINE poly kNoetherTail()
Definition: kInline.h:63

sLObject::sev
unsigned long sev
Definition: kutil.h:184

redHoney
int redHoney(LObject *h, kStrategy strat)
Definition: kstd2.cc:1004

sTObject::ecart
int ecart
Definition: kutil.h:78

sLObject::T_1_2
KINLINE void T_1_2(const skStrategy *strat, TObject *&T_1, TObject *&T_2)
Definition: kInline.h:878

enterSBba
void enterSBba(LObject p, int atS, kStrategy strat, int atR=-1)
Definition: kutil.cc:6927

skStrategy::redTailChange
char redTailChange
Definition: kutil.h:394

skStrategy::pOrigFDeg_TailRing
pFDegProc pOrigFDeg_TailRing
Definition: kutil.h:297

posInL11
int posInL11(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.cc:4664

skStrategy::syzl
int syzl
Definition: kutil.h:352

sTObject::is_sigsafe
BOOLEAN is_sigsafe
Definition: kutil.h:93

skStrategy::LazyDegree
int LazyDegree
Definition: kutil.h:356

pShallowCopyDelete.h

l
int l
Definition: cfEzgcd.cc:94

redSig
int redSig(LObject *h, kStrategy strat)
Definition: kstd2.cc:565

lazyReduce
END_NAMESPACE BEGIN_NAMESPACE_SINGULARXX ideal poly int int lazyReduce
Definition: myNF.cc:292

sLObject::SetDegStuffReturnLDeg
KINLINE long SetDegStuffReturnLDeg()
Definition: kInline.h:795

pCopyL2p
poly pCopyL2p(LObject h, kStrategy strat)
Definition: kutil.cc:8928

TObject
class sTObject TObject
Definition: kutil.h:57

sTObject::tailRing
ring tailRing
Definition: kutil.h:76

sTObject::Delete
KINLINE void Delete()
Definition: kInline.h:175

initSL
void initSL(ideal F, ideal Q, kStrategy strat)
Definition: kutil.cc:5836

sTObject::p
poly p
Definition: kutil.h:73

skStrategy::syzIdx
intset syzIdx
Definition: kutil.h:311

sLObject::MinComp
KINLINE long MinComp()
Definition: kInline.h:826

k_GetStrongLeadTerms
KINLINE void k_GetStrongLeadTerms(const poly p1, const poly p2, const ring leadRing, poly &m1, poly &m2, poly &lcm, const ring taiRing)
Definition: kInline.h:1007

ksReducePoly
int ksReducePoly(LObject *PR, TObject *PW, poly spNoether=NULL, number *coef=NULL, kStrategy strat=NULL)
Definition: kspoly.cc:38

sLObject::T_1
KINLINE TObject * T_1(const skStrategy *strat)
Definition: kInline.h:857

sLObject::ShallowCopyDelete
KINLINE void ShallowCopyDelete(ring new_tailRing, pShallowCopyDeleteProc p_shallow_copy_delete)
Definition: kInline.h:706

sbaRing
ring sbaRing(kStrategy strat, const ring r=currRing, BOOLEAN complete=TRUE, int sgn=1)
Definition: kutil.cc:8361