kutil.h
Go to the documentation of this file.
1 #ifndef KUTIL_H
2 #define KUTIL_H
3 /****************************************
4 * Computer Algebra System SINGULAR *
5 ****************************************/
6 /*
7 * ABSTRACT: kernel: utils for kStd
8 */
9 
10 
11 #include <string.h>
12 
13 #include <omalloc/omalloc.h>
14 #include <omalloc/omallocClass.h>
15 #include <misc/mylimits.h>
16 
17 
18 #include <kernel/polys.h>
20 
21 #include <kernel/structs.h>
22 #include <kernel/GBEngine/kstd1.h> /* for s_poly_proc_t */
23 
24 // define if tailrings should be used
25 #define HAVE_TAIL_RING
26 
27 #if 1
28 #define setmax 16
29 #define setmaxL ((4096-12)/sizeof(LObject))
30 #define setmaxLinc ((4096)/sizeof(LObject))
31 
32 #define setmaxT 64
33 #define setmaxTinc 32
34 #else
35 #define setmax 16
36 #define setmaxL 16
37 #define setmaxLinc 16
38 #define setmaxT 16
39 #define setmaxTinc 16
40 #endif
41 
42 // if you want std computations as in Singular version < 2:
43 // This disables RedThrough, tailReductions against T (bba),
44 // sets posInT = posInT15 (bba, strat->honey), and enables redFirst with LDeg
45 // NOTE: can be achieved with option(oldStd)
46 
47 #undef NO_KINLINE
48 #if !defined(KDEBUG) && !defined(NO_INLINE)
49 #define KINLINE inline
50 #else
51 #define KINLINE
52 #define NO_KINLINE 1
53 #endif
54 
55 typedef int* intset;
56 typedef int64 wlen_type;
58 
59 typedef class sTObject TObject;
60 typedef class sLObject LObject;
61 typedef TObject * TSet;
62 typedef LObject * LSet;
63 
66 
69 
70 class sTObject
71 {
72 public:
73  unsigned long sevSig;
74  poly sig; // the signature of the element
75  poly p; // Lm(p) \in currRing Tail(p) \in tailRing
76  poly t_p; // t_p \in tailRing: as monomials Lm(t_p) == Lm(p)
77  poly max; // p_GetMaxExpP(pNext(p))
78  ring tailRing;
79  long FDeg; // pFDeg(p)
80  int ecart,
81  length, // as of pLDeg
82  pLength, // either == 0, or == pLength(p)
83  i_r; // index of TObject in R set, or -1 if not in T
84  BOOLEAN is_normalized; // true, if pNorm was called on p, false otherwise
85  // used in incremental sba() with F5C:
86  // we know some of the redundant elements in
87  // strat->T beforehand, so we can just discard
88  // them and do not need to consider them in the
89  // interreduction process
91  // used in sba's sig-safe reduction:
92  // sometimes we already know that a reducer
93  // is sig-safe, so no need for a real
94  // sig-safeness check
96 
97 
98 #ifdef HAVE_PLURAL
99  BOOLEAN is_special; // true, it is a new special S-poly (e.g. for SCA)
100 #endif
101 
102  // initialization
103  KINLINE void Init(ring r = currRing);
104  KINLINE sTObject(ring tailRing = currRing);
105  KINLINE sTObject(poly p, ring tailRing = currRing);
106  KINLINE sTObject(poly p, ring c_r, ring tailRing);
107  KINLINE sTObject(sTObject* T, int copy);
108 
109  KINLINE void Set(ring r=currRing);
110  KINLINE void Set(poly p_in, ring r=currRing);
111  KINLINE void Set(poly p_in, ring c_r, ring t_r);
112 
113  // Frees the polys of T
114  KINLINE void Delete();
115  // Sets polys to NULL
116  KINLINE void Clear();
117  // makes a copy of the poly of T
118  KINLINE void Copy();
119 
120  // ring-dependent Lm access: these might result in allocation of monomials
123  KINLINE poly GetLm(ring r);
124  // this returns Lm and ring r (preferably from tailRing), but does not
125  // allocate a new poly
126  KINLINE void GetLm(poly &p, ring &r) const;
127 
128 #ifdef OLIVER_PRIVAT_LT
129  // routines for calc. with rings
130  KINLINE poly GetLtCurrRing();
131  KINLINE poly GetLtTailRing();
132  KINLINE poly GetLt(ring r);
133  KINLINE void GetLt(poly &p, ring &r) const;
134 #endif
135 
136  KINLINE BOOLEAN IsNull() const;
137 
138  KINLINE int GetpLength();
139 
140  // makes sure that T.p exists
141  KINLINE void SetLmCurrRing();
142 
143  // Iterations
144  // simply get the next monomial
145  KINLINE poly Next();
146  KINLINE void LmDeleteAndIter();
147 
148  // deg stuff
149  // compute pTotalDegree
150  KINLINE long pTotalDeg() const;
151  // computes pFDeg
152  KINLINE long pFDeg() const;
153  // computes and sets FDeg
154  KINLINE long SetpFDeg();
155  // gets stored FDeg
156  KINLINE long GetpFDeg() const;
157 
158  // computes pLDeg
159  KINLINE long pLDeg();
160  // sets length, FDeg, returns LDeg
162 
163  // arithmetic
164  KINLINE void Mult_nn(number n);
165  KINLINE void ShallowCopyDelete(ring new_tailRing, omBin new_tailBin,
166  pShallowCopyDeleteProc p_shallow_copy_delete,
167  BOOLEAN set_max = TRUE);
168  // manipulations
169  KINLINE void pNorm();
170  KINLINE void pCleardenom();
171 
172 #ifdef KDEBUG
173  void wrp();
174 #endif
175 };
176 
177 extern int strat_nr;
178 
179 class sLObject : public sTObject
180 {
181 
182 public:
183  unsigned long sev;
184  poly p1,p2; /*- the pair p comes from,
185  lm(pi) in currRing, tail(pi) in tailring -*/
186 
187  poly lcm; /*- the lcm of p1,p2 -*/
189  int i_r1, i_r2;
190  unsigned checked; // this is the index of S up to which
191  // the corresponding LObject was already checked in
192  // critical pair creation => when entering the
193  // reduction process it is enough to start a second
194  // rewritten criterion check from checked+1 onwards
196  // NOTE: If prod_crit = TRUE then the corresponding pair is
197  // detected by Buchberger's Product Criterion and can be
198  // deleted
199 
200  // initialization
201  KINLINE void Init(ring tailRing = currRing);
204  KINLINE sLObject(poly p, ring c_r, ring tailRing);
205 
206  // Frees the polys of L
207  KINLINE void Delete();
208  KINLINE void Clear();
209 
210  // Iterations
211  KINLINE void LmDeleteAndIter();
213 
214  // spoly related things
215  // preparation for reduction if not spoly
216  KINLINE void PrepareRed(BOOLEAN use_bucket);
217  KINLINE void SetLmTail(poly lm, poly new_p, int length,
218  int use_bucket, ring r);
219  KINLINE void Tail_Minus_mm_Mult_qq(poly m, poly qq, int lq, poly spNoether);
220  KINLINE void Tail_Mult_nn(number n);
221  // deletes bucket, makes sure that p and t_p exists
222  KINLINE poly GetP(omBin lmBin = NULL);
223  // similar, except that only t_p exists
224  KINLINE poly GetTP();
225 
226  // does not delete bucket, just canonicalizes it
227  // returned poly is such that Lm(p) \in currRing, Tail(p) \in tailRing
229 
230  // makes a copy of the poly of L
231  KINLINE void Copy();
232  // gets the poly and makes a copy of it
234 
235  KINLINE int GetpLength();
236  KINLINE long pLDeg(BOOLEAN use_last);
237  KINLINE long pLDeg();
238  KINLINE int SetLength(BOOLEAN lengt_pLength = FALSE);
240  KINLINE long SetDegStuffReturnLDeg(BOOLEAN use_last);
241 
242  // returns minimal component of p
243  KINLINE long MinComp();
244  // returns component of p
245  KINLINE long Comp();
246 
247  KINLINE void ShallowCopyDelete(ring new_tailRing,
248  pShallowCopyDeleteProc p_shallow_copy_delete);
249 
250  // sets sev
251  KINLINE void SetShortExpVector();
252 
253  // enable assignment from TObject
255 
256  // get T's corresponding to p1, p2: they might return NULL
259  KINLINE void T_1_2(const skStrategy* strat,
260  TObject* &T_1, TObject* &T_2);
261 
262  // simplify coefficients
263  KINLINE void Normalize();
264  KINLINE void HeadNormalize();
265 };
266 
267 
268 extern int HCord;
269 
270 class skStrategy : public omallocClass
271 {
272 public:
276  void (*initEcart)(TObject * L);
277  int (*posInT)(const TSet T,const int tl,LObject &h);
278  int (*posInLSba)(const LSet set, const int length,
279  LObject* L,const kStrategy strat);
280  int (*posInL)(const LSet set, const int length,
281  LObject* L,const kStrategy strat);
282  void (*enterS)(LObject &h, int pos,kStrategy strat, int atR/* =-1*/ );
283  void (*initEcartPair)(LObject * h, poly f, poly g, int ecartF, int ecartG);
284  int (*posInLOld)(const LSet Ls,const int Ll,
285  LObject* Lo,const kStrategy strat);
286  void (*enterOnePair) (int i,poly p,int ecart, int isFromQ,kStrategy strat, int atR /*= -1*/);
287  void (*chainCrit) (poly p,int ecart,kStrategy strat);
288  BOOLEAN (*syzCrit) (poly sig, unsigned long not_sevSig, kStrategy strat);
289  BOOLEAN (*rewCrit1) (poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start /*= 0*/);
290  BOOLEAN (*rewCrit2) (poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start /*= 0*/);
291  BOOLEAN (*rewCrit3) (poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start /*= 0*/);
297 
299  ideal Shdl;
300  ideal D; /*V(S) is in D(D)*/
301  ideal M; /*set of minimal generators*/
306  intset fromS; // from which S[i] S[j] comes from
307  // this is important for signature-based
308  // algorithms
309  intset syzIdx;// index in the syz array at which the first
310  // syzygy of component i comes up
311  // important for signature-based algorithms
312  unsigned sbaOrder;
313  int currIdx;
316  wlen_set lenSw; /* for tgb.ccc */
318  unsigned long* sevS;
319  unsigned long* sevSyz;
320  unsigned long* sevSig;
321  unsigned long* sevT;
327  poly t_kHEdge; // same polys in tailring
331  BOOLEAN * pairtest;/*used for enterOnePair*/
335  // procedure for ShalloCopy from tailRing to currRing
337  // pointers to Tobjects R[i] is ith Tobject which is generated
339  // S_2_R[i] yields Tobject which corresponds to S[i]
340  int* S_2_R;
341  ring tailRing;
344  int nr;
345  int cp,c3;
346  int sl,mu;
348  int tl,tmax;
349  int Ll,Lmax;
350  int Bl,Bmax;
352  int syzComp;
353  int HCord;
354  int lastAxis;
355  int newIdeal;
356  int minim;
357  #ifdef HAVE_SHIFTBBA
358  int lV;
359  int cv; // in shift bases: counting V criterion
360  #endif
363 #ifdef HAVE_PLURAL
364  BOOLEAN z2homog; // Z_2 - homogeneous input allows product criterion in commutative and SCA cases!
365 #endif
374  // if set, pLDeg(p, l) == (pFDeg(pLast(p), pLength)
376  // if set, then L.length == L.pLength
378  // if set, then posInL does not depend on L.length
380  /*FALSE, if posInL == posInL10*/
381 #ifdef HAVE_PLURAL
382  // set this flag to 1 to stop the product criteria
383  // use ALLOW_PROD_CRIT(strat) to test
385 #define ALLOW_PROD_CRIT(A) (!(A)->no_prod_crit)
386 #else
387 #define ALLOW_PROD_CRIT(A) (1)
388 #endif
390  char news;
391  char newt;/*used for messageSets*/
392  char noClearS;
394  char overflow;
395 
396  skStrategy();
397  ~skStrategy();
398 
399  // return TObject corresponding to S[i]: assume that it exists
400  // i.e. no error checking is done
401  KINLINE TObject* S_2_T(int i);
402  // like S_2_T, except that NULL is returned if it can not be found
403  KINLINE TObject* s_2_t(int i);
404 };
405 
406 void deleteHC(poly *p, int *e, int *l, kStrategy strat);
407 void deleteHC(LObject* L, kStrategy strat, BOOLEAN fromNext = FALSE);
408 void deleteInS (int i,kStrategy strat);
409 void deleteInSSba (int i,kStrategy strat);
410 void cleanT (kStrategy strat);
411 static inline LSet initL (int nr=setmaxL)
412 { return (LSet)omAlloc(nr*sizeof(LObject)); }
413 void deleteInL(LSet set, int *length, int j,kStrategy strat);
414 void enterL (LSet *set,int *length, int *LSetmax, LObject p,int at);
415 void enterSBba (LObject &p,int atS,kStrategy strat, int atR = -1);
416 void enterSSba (LObject &p,int atS,kStrategy strat, int atR = -1);
417 void initEcartPairBba (LObject* Lp,poly f,poly g,int ecartF,int ecartG);
418 void initEcartPairMora (LObject* Lp,poly f,poly g,int ecartF,int ecartG);
419 int posInS (const kStrategy strat, const int length, const poly p,
420  const int ecart_p);
421 int posInT0 (const TSet set,const int length,LObject &p);
422 int posInT1 (const TSet set,const int length,LObject &p);
423 int posInT2 (const TSet set,const int length,LObject &p);
424 int posInT11 (const TSet set,const int length,LObject &p);
425 int posInTSig (const TSet set,const int length,LObject &p);
426 int posInT110 (const TSet set,const int length,LObject &p);
427 int posInT13 (const TSet set,const int length,LObject &p);
428 int posInT15 (const TSet set,const int length,LObject &p);
429 int posInT17 (const TSet set,const int length,LObject &p);
430 int posInT19 (const TSet set,const int length,LObject &p);
431 int posInT_EcartpLength(const TSet set,const int length,LObject &p);
432 
433 #ifdef HAVE_MORE_POS_IN_T
434 int posInT_EcartFDegpLength(const TSet set,const int length,LObject &p);
435 int posInT_FDegpLength(const TSet set,const int length,LObject &p);
436 int posInT_pLength(const TSet set,const int length,LObject &p);
437 #endif
438 
439 
440 void reorderS (int* suc,kStrategy strat);
441 int posInLF5C (const LSet set, const int length,
442  LObject* L,const kStrategy strat);
443 int posInLSig (const LSet set, const int length,
444  LObject* L,const kStrategy strat);
445 int posInLRing (const LSet set, const int length,
446  LObject* L,const kStrategy strat);
447 int posInSyz (const kStrategy strat, const poly sig);
448 int posInL0 (const LSet set, const int length,
449  LObject* L,const kStrategy strat);
450 int posInL11 (const LSet set, const int length,
451  LObject* L,const kStrategy strat);
452 int posInL11Ring (const LSet set, const int length,
453  LObject* L,const kStrategy strat);
454 int posInL11Ringls (const LSet set, const int length,
455  LObject* L,const kStrategy strat);
456 int posInL13 (const LSet set, const int length,
457  LObject* L,const kStrategy strat);
458 int posInL15 (const LSet set, const int length,
459  LObject* L,const kStrategy strat);
460 int posInL17 (const LSet set, const int length,
461  LObject* L,const kStrategy strat);
462 int posInL10 (const LSet set, const int length,
463  LObject* L,const kStrategy strat);
464 int posInL110 (const LSet set, const int length,
465  LObject* L,const kStrategy strat);
467 #ifdef HAVE_RINGS
469 poly redtailBba_Z (LObject* L, int pos, kStrategy strat );
470 #endif
471 poly redtailBba (LObject *L, int pos,kStrategy strat,
473 poly redtailSba (LObject *L, int pos,kStrategy strat,
475 poly redtailBba (TObject *T, int pos,kStrategy strat);
476 poly redtail (poly p,int pos,kStrategy strat);
477 poly redtail (LObject *L,int pos,kStrategy strat);
480 poly redNFTail (poly h,const int sl,kStrategy strat);
482 #ifdef HAVE_RINGS
486 void superenterpairs (poly h,int k,int ecart,int pos,kStrategy strat, int atR = -1);
487 poly kCreateZeroPoly(long exp[], long cabsind, poly* t_p, ring leadRing, ring tailRing);
488 long ind2(long arg);
489 
490 long ind_fact_2(long arg);
491 long twoPow(long arg);
492 ideal createG0();
493 #endif
497 //adds hSig to be able to check with F5's criteria when entering pairs!
498 void enterpairsSig (poly h, poly hSig, int from, int k, int ec, int pos,kStrategy strat, int atR = -1);
499 void enterpairs (poly h, int k, int ec, int pos,kStrategy strat, int atR = -1);
500 void entersets (LObject h);
501 void pairs ();
502 BOOLEAN enterOneStrongPoly (int i,poly p,int /*ecart*/, int /*isFromQ*/,kStrategy strat, int atR = -1, bool enterTstrong = FALSE);
503 void message (int i,int* reduc,int* olddeg,kStrategy strat,int red_result);
504 void messageStat (int hilbcount,kStrategy strat);
505 #ifdef KDEBUG
507 #else
508 #define messageSets(s) do {} while (0)
509 #endif
510 
511 void initEcartNormal (TObject* h);
512 void initEcartBBA (TObject* h);
513 void initS (ideal F, ideal Q,kStrategy strat);
514 void initSL (ideal F, ideal Q,kStrategy strat);
515 void initSLSba (ideal F, ideal Q,kStrategy strat);
516 /*************************************************
517  * when initializing a new bunch of principal
518  * syzygies at the beginning of a new iteration
519  * step in a signature-based algorithm we
520  * compute ONLY the leading elements of those
521  * syzygies, NOT the whole syzygy
522  * NOTE: this needs to be adjusted for a more
523  * general approach on signature-based algorithms
524  ***********************************************/
526 void updateS(BOOLEAN toT,kStrategy strat);
527 void enterSyz (LObject &p,kStrategy strat, int atT);
528 void enterT (LObject &p,kStrategy strat, int atT = -1);
529 void enterT_strong (LObject &p,kStrategy strat, int atT = -1);
530 void cancelunit (LObject* p,BOOLEAN inNF=FALSE);
534 void initHilbCrit(ideal F, ideal Q, intvec **hilb,kStrategy strat);
537 void initBuchMora (ideal F, ideal Q,kStrategy strat);
538 void initSbaBuchMora (ideal F, ideal Q,kStrategy strat);
540 void exitSba (kStrategy strat);
541 void updateResult(ideal r,ideal Q,kStrategy strat);
544 void enterOnePairNormal (int i,poly p,int ecart, int isFromQ,kStrategy strat, int atR);
545 void enterOnePairLift (int i,poly p,int ecart, int isFromQ,kStrategy strat, int atR);
546 void enterOnePairSig (int i,poly p,poly pSig,int ecart, int isFromQ,kStrategy strat, int atR);
547 void chainCritNormal (poly p,int ecart,kStrategy strat);
549 void chainCritSig (poly p,int ecart,kStrategy strat);
550 BOOLEAN homogTest(polyset F, int Fmax);
552 BOOLEAN syzCriterion(poly sig, unsigned long not_sevSig, kStrategy strat);
553 BOOLEAN syzCriterionInc(poly sig, unsigned long not_sevSig, kStrategy strat);
554 KINLINE BOOLEAN arriRewDummy(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start);
555 BOOLEAN arriRewCriterion(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start);
556 BOOLEAN arriRewCriterionPre(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start);
557 BOOLEAN faugereRewCriterion(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start);
558 BOOLEAN findMinLMPair(poly sig, unsigned long not_sevSig, kStrategy strat, int start);
559 
560 /// returns index of p in TSet, or -1 if not found
561 int kFindInT(poly p, TSet T, int tlength);
562 
563 /// return -1 if no divisor is found
564 /// number of first divisor in T, otherwise
565 int kFindDivisibleByInT(const kStrategy strat, const LObject* L, const int start=0);
566 
567 /// return -1 if no divisor is found
568 /// number of first divisor in S, otherwise
569 int kFindDivisibleByInS(const kStrategy strat, int *max_ind, LObject* L);
570 
571 int kFindNextDivisibleByInS(const kStrategy strat, int start,int max_ind, LObject* L);
572 TObject*
574  long ecart = LONG_MAX);
575 
576 /***************************************************************
577  *
578  * stuff to be inlined
579  *
580  ***************************************************************/
581 
582 KINLINE TSet initT ();
583 KINLINE TObject** initR();
584 KINLINE unsigned long* initsevT();
589 
594 
595 // if exp bound is not violated, return TRUE and
596 // get m1 = LCM(LM(p1), LM(p2))/LM(p1)
597 // m2 = LCM(LM(p1), LM(p2))/LM(p2)
598 // return FALSE and m1 == NULL, m2 == NULL , otherwise
599 KINLINE BOOLEAN k_GetLeadTerms(const poly p1, const poly p2, const ring p_r,
600  poly &m1, poly &m2, const ring m_r);
601 #ifdef HAVE_RINGS
602 KINLINE void k_GetStrongLeadTerms(const poly p1, const poly p2, const ring leadRing,
603  poly &m1, poly &m2, poly &lcm, const ring taiRing);
604 #endif
605 #ifdef KDEBUG
606 // test strat
608 // test strat, and test that S is contained in T
610 // test LObject
611 BOOLEAN kTest_L(LObject* L, ring tailRing = NULL,
612  BOOLEAN testp = FALSE, int lpos = -1,
613  TSet T = NULL, int tlength = -1);
614 // test TObject
615 BOOLEAN kTest_T(TObject* T, ring tailRing = NULL, int tpos = -1, char TN = '?');
616 // test set strat->SevS
618 #else
619 #define kTest(A) (TRUE)
620 #define kTest_TS(A) (TRUE)
621 #define kTest_T(T) (TRUE)
622 #define kTest_S(T) (TRUE)
623 #define kTest_L(T) (TRUE)
624 #endif
625 
626 
627 /***************************************************************
628  *
629  * From kstd2.cc
630  *
631  ***************************************************************/
632 poly kFindZeroPoly(poly input_p, ring leadRing, ring tailRing);
633 ideal bba (ideal F, ideal Q,intvec *w,intvec *hilb,kStrategy strat);
634 ideal sba (ideal F, ideal Q,intvec *w,intvec *hilb,kStrategy strat);
635 poly kNF2 (ideal F, ideal Q, poly q, kStrategy strat, int lazyReduce);
636 ideal kNF2 (ideal F,ideal Q,ideal q, kStrategy strat, int lazyReduce);
637 void initBba(ideal F,kStrategy strat);
638 void initSba(ideal F,kStrategy strat);
639 void f5c (kStrategy strat, int& olddeg, int& minimcnt, int& hilbeledeg,
640  int& hilbcount, int& srmax, int& lrmax, int& reduc, ideal Q,
641  intvec *w,intvec *hilb );
642 
643 /***************************************************************
644  *
645  * From kspoly.cc
646  *
647  ***************************************************************/
648 // Reduces PR with PW
649 // Assumes PR != NULL, PW != NULL, Lm(PW) divides Lm(PR)
650 // Changes: PR
651 // Const: PW
652 // If coef != NULL, then *coef is a/gcd(a,b), where a = LC(PR), b = LC(PW)
653 // If strat != NULL, tailRing is changed if reduction would violate exp bound
654 // of tailRing
655 // Returns: 0 everything ok, no tailRing change
656 // 1 tailRing has successfully changed (strat != NULL)
657 // 2 no reduction performed, tailRing needs to be changed first
658 // (strat == NULL)
659 // -1 tailRing change could not be performed due to exceeding exp
660 // bound of currRing
661 int ksReducePoly(LObject* PR,
662  TObject* PW,
663  poly spNoether = NULL,
664  number *coef = NULL,
665  kStrategy strat = NULL);
666 
667 // Reduces PR with PW
668 // Assumes PR != NULL, PW != NULL, Lm(PW) divides Lm(PR)
669 // Changes: PR
670 // Const: PW
671 // If coef != NULL, then *coef is a/gcd(a,b), where a = LC(PR), b = LC(PW)
672 // If strat != NULL, tailRing is changed if reduction would violate exp bound
673 // of tailRing
674 // Returns: 0 everything ok, no tailRing change
675 // 1 tailRing has successfully changed (strat != NULL)
676 // 2 no reduction performed, tailRing needs to be changed first
677 // (strat == NULL)
678 // 3 no reduction performed, not sig-safe!!!
679 // -1 tailRing change could not be performed due to exceeding exp
680 // bound of currRing
681 int ksReducePolySig(LObject* PR,
682  TObject* PW,
683  long idx,
684  poly spNoether = NULL,
685  number *coef = NULL,
686  kStrategy strat = NULL);
687 
688 // Reduces PR at Current->next with PW
689 // Assumes PR != NULL, Current contained in PR
690 // Current->next != NULL, LM(PW) devides LM(Current->next)
691 // Changes: PR
692 // Const: PW
693 // Return: see ksReducePoly
694 int ksReducePolyTail(LObject* PR,
695  TObject* PW,
696  poly Current,
697  poly spNoether = NULL);
698 
699 KINLINE int ksReducePolyTail(LObject* PR, TObject* PW, LObject* Red);
700 
701 // Creates S-Poly of Pair
702 // Const: Pair->p1, Pair->p2
703 // Changes: Pair->p == S-Poly of p1, p2
704 // Assume: Pair->p1 != NULL && Pair->p2
705 void ksCreateSpoly(LObject* Pair, poly spNoether = NULL,
706  int use_buckets=0, ring tailRing=currRing,
707  poly m1 = NULL, poly m2 = NULL, TObject** R = NULL);
708 
709 /*2
710 * creates the leading term of the S-polynomial of p1 and p2
711 * do not destroy p1 and p2
712 * remarks:
713 * 1. the coefficient is 0 (nNew)
714 * 2. pNext is undefined
715 */
717 
718 
719 // old stuff
720 KINLINE poly ksOldSpolyRed(poly p1, poly p2, poly spNoether = NULL);
721 KINLINE poly ksOldSpolyRedNew(poly p1, poly p2, poly spNoether = NULL);
722 KINLINE poly ksOldCreateSpoly(poly p1, poly p2, poly spNoether = NULL, ring r = currRing);
723 KINLINE void ksOldSpolyTail(poly p1, poly q, poly q2, poly spNoether, ring r = currRing);
724 
725 /***************************************************************
726  *
727  * Routines related for ring changes during std computations
728  *
729  ***************************************************************/
730 // return TRUE and set m1, m2 to k_GetLcmTerms,
731 // if spoly creation of strat->P does not violate
732 // exponent bound of strat->tailRing
733 // FALSE, otherwise
735 #ifdef HAVE_RINGS
736 // return TRUE if gcdpoly creation of R[atR] and S[atS] does not violate
737 // exponent bound of strat->tailRing
738 // FALSE, otherwise
739 BOOLEAN kCheckStrongCreation(int atR, poly m1, int atS, poly m2, kStrategy strat);
740 poly preIntegerCheck(ideal F, ideal Q);
743 #endif
744 // change strat->tailRing and adjust all data in strat, L, and T:
745 // new tailRing has larger exponent bound
746 // do nothing and return FALSE if exponent bound increase would result in
747 // larger exponent bound that that of currRing
749  LObject* L = NULL, TObject* T = NULL,
750  // take this as new_expbound: if 0
751  // new expbound is 2*expbound of tailRing
752  unsigned long new_expbound = 0);
753 // initiate a change of the tailRing of strat -- should be called
754 // right before main loop in bba
756 
757 /// Output some debug info about a given strategy
759 
760 // getting sb order for sba computations
761 ring sbaRing(kStrategy strat, const ring r=currRing, BOOLEAN complete=TRUE, int sgn=1);
762 
763 KINLINE void clearS (poly p, unsigned long p_sev, int* at, int* k,
764  kStrategy strat);
765 
766 #include <kernel/GBEngine/kInline.h>
767 
768 /* shiftgb stuff */
769 #include <kernel/GBEngine/shiftgb.h>
770 
772 
774 
776 
777 void enterTShift(LObject p, kStrategy strat, int atT, int uptodeg, int lV);
778 
779 void initBuchMoraShift (ideal F,ideal Q,kStrategy strat);
780 
781 void enterOnePairManyShifts (int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR, int uptodeg, int lV); // ok
782 
783 void enterOnePairSelfShifts (poly qq, poly p, int ecart, int isFromQ, kStrategy strat, int atR, int uptodeg, int lV);
784 
785 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
786 
787 void enterpairsShift (poly h,int k,int ecart,int pos,kStrategy strat, int atR,int uptodeg, int lV);
788 
789 void initenterpairsShift (poly h,int k,int ecart,int isFromQ,kStrategy strat, int atR,int uptodeg, int lV);
790 
791 void updateSShift(kStrategy strat,int uptodeg,int lV);
792 
793 void initBbaShift(ideal F,kStrategy strat);
794 
796 
797 int redFirstShift (LObject* h,kStrategy strat); // ok
798 
799 ideal freegb(ideal I, int uptodeg, int lVblock);
800 
801 ideal bbaShift(ideal F, ideal Q,intvec *w,intvec *hilb,kStrategy strat, int uptodeg, int lV);
802 // test syz strategy: // will be removed soon
803 extern int (*test_PosInT)(const TSet T,const int tl,LObject &h);
804 extern int (*test_PosInL)(const LSet set, const int length,
805  LObject* L,const kStrategy strat);
806 #endif
KINLINE TObject ** initR()
Definition: kInline.h:92
unsigned long * sevSig
Definition: kutil.h:320
KINLINE void Init(ring tailRing=currRing)
Definition: kInline.h:506
int kFindInT(poly p, TSet T, int tlength)
returns index of p in TSet, or -1 if not found
Definition: kutil.cc:617
void deleteHC(poly *p, int *e, int *l, kStrategy strat)
Definition: kutil.cc:310
KINLINE int GetpLength()
Definition: kInline.h:809
KINLINE poly GetP(omBin lmBin=NULL)
Definition: kInline.h:679
int posInLRing(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.cc:4964
denominator_list_s * denominator_list
Definition: kutil.h:65
polyset sig
Definition: kutil.h:304
int posInT_pLength(const TSet set, const int length, LObject &p)
Definition: kutil.cc:9873
int posInLSig(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.cc:4940
int(* posInL)(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.h:280
int nr
Definition: kutil.h:344
BOOLEAN honey
Definition: kutil.h:367
CFArray copy(const CFList &list)
write elements of list into an array
void initSba(ideal F, kStrategy strat)
Definition: kstd1.cc:1443
void entersets(LObject h)
static poly normalize(poly next_p, ideal add_generators, syStrategy syzstr, int *g_l, int *p_l, int crit_comp)
Definition: syz3.cc:1028
void initSyzRules(kStrategy strat)
Definition: kutil.cc:6737
#define setmaxL
Definition: kutil.h:29
KINLINE void SetShortExpVector()
Definition: kInline.h:717
int lcm(unsigned long *l, unsigned long *a, unsigned long *b, unsigned long p, int dega, int degb)
Definition: minpoly.cc:711
void initSbaCrit(kStrategy strat)
Definition: kutil.cc:8159
omBin_t * omBin
Definition: omStructs.h:12
int syzComp
Definition: kutil.h:352
void updateResult(ideal r, ideal Q, kStrategy strat)
Definition: kutil.cc:8648
BOOLEAN is_redundant
Definition: kutil.h:90
void initEcartNormal(TObject *h)
Definition: kutil.cc:1139
void enterOnePairSelfShifts(poly qq, poly p, int ecart, int isFromQ, kStrategy strat, int atR, int uptodeg, int lV)
Definition: kutil.cc:10339
void message(int i, int *reduc, int *olddeg, kStrategy strat, int red_result)
Definition: kutil.cc:6278
KINLINE void Set(ring r=currRing)
Definition: kInline.h:103
BOOLEAN(* rewCrit1)(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
Definition: kutil.h:289
int i_r1
Definition: kutil.h:189
int syzmax
Definition: kutil.h:347
BOOLEAN is_normalized
Definition: kutil.h:84
KINLINE poly ksOldSpolyRed(poly p1, poly p2, poly spNoether=NULL)
Definition: kInline.h:1082
kBucket_pt bucket
Definition: kutil.h:188
poly kHEdge
Definition: kutil.h:325
int posInT11(const TSet set, const int length, LObject &p)
Definition: kutil.cc:4375
pLDegProc pOrigLDeg_TailRing
Definition: kutil.h:295
class sLObject LObject
Definition: kutil.h:60
BOOLEAN length_pLength
Definition: kutil.h:377
TObject * TSet
Definition: kutil.h:61
int posInL15(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.cc:5504
wlen_set lenSw
Definition: kutil.h:316
int Ll
Definition: kutil.h:349
#define kTest_S(T)
Definition: kutil.h:622
int sgn(const Rational &a)
Definition: GMPrat.cc:437
KINLINE sLObject & operator=(const sTObject &)
Definition: kInline.h:850
KINLINE poly Next()
Definition: kInline.h:280
#define FALSE
Definition: auxiliary.h:140
BOOLEAN noTailReduction
Definition: kutil.h:368
unsigned checked
Definition: kutil.h:190
Compatiblity layer for legacy polynomial operations (over currRing)
int * S_2_R
Definition: kutil.h:340
return P p
Definition: myNF.cc:203
BOOLEAN kStratChangeTailRing(kStrategy strat, LObject *L=NULL, TObject *T=NULL, unsigned long new_expbound=0)
Definition: kutil.cc:9361
void initSbaBuchMora(ideal F, ideal Q, kStrategy strat)
Definition: kutil.cc:8535
int c3
Definition: kutil.h:345
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:2748
int ksReducePolySig(LObject *PR, TObject *PW, long idx, poly spNoether=NULL, number *coef=NULL, kStrategy strat=NULL)
Definition: kspoly.cc:175
BOOLEAN syzCriterion(poly sig, unsigned long not_sevSig, kStrategy strat)
Definition: kutil.cc:5676
poly redtailBbaShift(LObject *L, int pos, kStrategy strat, BOOLEAN withT, BOOLEAN normalize)
Definition: kutil.cc:10846
char news
Definition: kutil.h:390
int posInT15(const TSet set, const int length, LObject &p)
Definition: kutil.cc:4622
poly preIntegerCheck(ideal F, ideal Q)
used for GB over ZZ: look for constant and monomial elements in the ideal background: any known const...
Definition: kutil.cc:9052
poly redNF(poly h, int &max_ind, int nonorm, kStrategy strat)
Definition: kstd2.cc:1320
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:202
void enterpairsShift(poly h, int k, int ecart, int pos, kStrategy strat, int atR, int uptodeg, int lV)
Definition: kutil.cc:10696
char newt
Definition: kutil.h:391
void chainCritNormal(poly p, int ecart, kStrategy strat)
Definition: kutil.cc:2451
poly ksCreateShortSpoly(poly p1, poly p2, ring tailRing)
Definition: kspoly.cc:566
BOOLEAN * NotUsedAxis
Definition: kutil.h:330
BEGIN_NAMESPACE_SINGULARXX const ring const ring tailRing
Definition: DebugPrint.h:30
BOOLEAN posInLDependsOnLength
Definition: kutil.h:379
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
int(* posInLSba)(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.h:278
KINLINE sLObject(ring tailRing=currRing)
Definition: kInline.h:514
KINLINE poly k_LmShallowCopyDelete_tailRing_2_currRing(poly p, ring tailRing, omBin bin)
Definition: kInline.h:930
BOOLEAN(* rewCrit2)(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
Definition: kutil.h:290
KINLINE void Init(ring r=currRing)
Definition: kInline.h:107
int length
Definition: kutil.h:80
const CanonicalForm CFMap CFMap int &both_non_zero int n
Definition: cfEzgcd.cc:52
BOOLEAN noetherSet
Definition: kutil.h:370
void enterOnePairManyShifts(int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR, int uptodeg, int lV)
Definition: kutil.cc:10264
int cv
Definition: kutil.h:359
void messageStat(int hilbcount, kStrategy strat)
Definition: kutil.cc:6319
KINLINE BOOLEAN IsNull() const
Definition: kInline.h:263
KINLINE poly k_LmInit_tailRing_2_currRing(poly p, ring tailRing, omBin bin)
Definition: kInline.h:914
BOOLEAN * pairtest
Definition: kutil.h:331
int & max_ind
Definition: myNF.cc:67
BOOLEAN z2homog
Definition: kutil.h:364
poly kNoether
Definition: kutil.h:326
int tl
Definition: kutil.h:348
KINLINE void HeadNormalize()
Definition: kInline.h:334
int Bl
Definition: kutil.h:350
ideal bba(ideal F, ideal Q, intvec *w, intvec *hilb, kStrategy strat)
Definition: kstd2.cc:1466
long int64
Definition: auxiliary.h:112
void initSbaPos(kStrategy strat)
Definition: kutil.cc:8437
void enterOnePairSig(int i, poly p, poly pSig, int ecart, int isFromQ, kStrategy strat, int atR)
char noClearS
Definition: kutil.h:392
#define TRUE
Definition: auxiliary.h:144
#define kTest(A)
Definition: kutil.h:619
poly kCreateZeroPoly(long exp[], long cabsind, poly *t_p, ring leadRing, ring tailRing)
Definition: kutil.cc:3558
pShallowCopyDeleteProc p_shallow_copy_delete
Definition: kutil.h:336
unsigned long * sevT
Definition: kutil.h:321
BOOLEAN(* rewCrit3)(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
Definition: kutil.h:291
void(* initEcartPair)(LObject *h, poly f, poly g, int ecartF, int ecartG)
Definition: kutil.h:283
void enterpairsSig(poly h, poly hSig, int from, int k, int ec, int pos, kStrategy strat, int atR=-1)
Definition: kutil.cc:4044
poly pMove2CurrTail(poly p, kStrategy strat)
Definition: kutil.cc:10028
BOOLEAN kCheckStrongCreation(int atR, poly m1, int atS, poly m2, kStrategy strat)
Definition: kutil.cc:9032
void superenterpairs(poly h, int k, int ecart, int pos, kStrategy strat, int atR=-1)
Definition: kutil.cc:3904
int ak
Definition: kutil.h:351
void initS(ideal F, ideal Q, kStrategy strat)
Definition: kutil.cc:6383
g
Definition: cfModGcd.cc:4031
ideal bbaShift(ideal F, ideal Q, intvec *w, intvec *hilb, kStrategy strat, int uptodeg, int lV)
Definition: kstd2.cc:3065
void initHilbCrit(ideal F, ideal Q, intvec **hilb, kStrategy strat)
Definition: kutil.cc:8072
int k
Definition: cfEzgcd.cc:93
KINLINE void pNorm()
Definition: kInline.h:473
int(* test_PosInT)(const TSet T, const int tl, LObject &h)
Definition: kstd2.cc:98
void initBuchMora(ideal F, ideal Q, kStrategy strat)
Definition: kutil.cc:8338
void enterT(LObject &p, kStrategy strat, int atT=-1)
Definition: kutil.cc:7811
#define Q
Definition: sirandom.c:25
long twoPow(long arg)
Definition: kutil.cc:3366
KINLINE unsigned long * initsevT()
Definition: kInline.h:97
void chainCritOpt_1(poly, int, kStrategy strat)
Definition: kutil.cc:2666
int redHomog(LObject *h, kStrategy strat)
Definition: kstd2.cc:518
void enterExtendedSpoly(poly h, kStrategy strat)
Definition: kutil.cc:3784
void initEcartBBA(TObject *h)
Definition: kutil.cc:1147
KINLINE void Tail_Minus_mm_Mult_qq(poly m, poly qq, int lq, poly spNoether)
Definition: kInline.h:580
int(* red)(LObject *L, kStrategy strat)
Definition: kutil.h:274
#define omAlloc(size)
Definition: omAllocDecl.h:210
#define KINLINE
Definition: kutil.h:51
void HEckeTest(poly pp, kStrategy strat)
Definition: kutil.cc:436
int(* posInT)(const TSet T, const int tl, LObject &h)
Definition: kutil.h:277
int currIdx
Definition: kutil.h:313
long(* pLDegProc)(poly p, int *length, ring r)
Definition: ring.h:45
int kFindDivisibleByInT(const kStrategy strat, const LObject *L, const int start=0)
return -1 if no divisor is found number of first divisor in T, otherwise
Definition: kstd2.cc:104
void exitBuchMora(kStrategy strat)
Definition: kutil.cc:8419
void postReduceByMon(LObject *h, kStrategy strat)
used for GB over ZZ: intermediate reduction by monomial elements background: any known constant eleme...
Definition: kutil.cc:9225
int minim
Definition: kutil.h:356
int posInLF5C(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.cc:5073
void initBuchMoraCrit(kStrategy strat)
Definition: kutil.cc:8092
int Bmax
Definition: kutil.h:350
KINLINE void PrepareRed(BOOLEAN use_bucket)
Definition: kInline.h:530
ideal createG0()
Definition: kutil.cc:3687
poly pp
Definition: myNF.cc:296
int lastAxis
Definition: kutil.h:354
void initSLSba(ideal F, ideal Q, kStrategy strat)
Definition: kutil.cc:6585
BOOLEAN(* syzCrit)(poly sig, unsigned long not_sevSig, kStrategy strat)
Definition: kutil.h:288
KINLINE void Tail_Mult_nn(number n)
Definition: kInline.h:566
KINLINE void LmDeleteAndIter()
Definition: kInline.h:288
KINLINE void Copy()
Definition: kInline.h:729
KINLINE void SetLmTail(poly lm, poly new_p, int length, int use_bucket, ring r)
Definition: kInline.h:548
skStrategy()
Definition: kutil.cc:9709
char completeReduce_retry
Definition: kutil.h:393
void chainCritSig(poly p, int ecart, kStrategy strat)
Definition: kutil.cc:2682
int i_r
Definition: kutil.h:80
KINLINE sTObject(ring tailRing=currRing)
Definition: kInline.h:113
int HCord
Definition: kutil.h:353
void updateS(BOOLEAN toT, kStrategy strat)
Definition: kutil.cc:7345
poly t_p
Definition: kutil.h:76
KINLINE int GetpLength()
Definition: kInline.h:268
pFDegProc pOrigFDeg
Definition: kutil.h:292
KINLINE void ksOldSpolyTail(poly p1, poly q, poly q2, poly spNoether, ring r=currRing)
Definition: kInline.h:1112
BOOLEAN interpt
Definition: kutil.h:361
int posInT2(const TSet set, const int length, LObject &p)
Definition: kutil.cc:4345
void(* initEcart)(TObject *L)
Definition: kutil.h:276
void kStratInitChangeTailRing(kStrategy strat)
Definition: kutil.cc:9464
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
long ind2(long arg)
Definition: kutil.cc:3339
int redRiloc(LObject *h, kStrategy strat)
Definition: kstd1.cc:355
poly redNFTail(poly h, const int sl, kStrategy strat)
KINLINE poly ksOldCreateSpoly(poly p1, poly p2, poly spNoether=NULL, ring r=currRing)
Definition: kInline.h:1102
void(* enterOnePair)(int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR)
Definition: kutil.h:286
long ind_fact_2(long arg)
Definition: kutil.cc:3351
KINLINE void Copy()
Definition: kInline.h:200
int lV
Definition: kutil.h:358
poly max
Definition: kutil.h:77
BOOLEAN fromT
Definition: kutil.h:369
const ring r
Definition: syzextra.cc:208
int posInT13(const TSet set, const int length, LObject &p)
Definition: kutil.cc:4554
pLDegProc pOrigLDeg
Definition: kutil.h:293
int posInT0(const TSet set, const int length, LObject &p)
Definition: kutil.cc:4306
BOOLEAN homog
Definition: kutil.h:362
void initEcartPairMora(LObject *Lp, poly f, poly g, int ecartF, int ecartG)
Definition: kutil.cc:1161
void initBuchMoraPos(kStrategy strat)
Definition: kutil.cc:8244
KINLINE TObject * S_2_T(int i)
Definition: kInline.h:35
KINLINE long pLDeg()
Definition: kInline.h:764
Definition: intvec.h:16
long FDeg
Definition: kutil.h:79
int posInL17(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.cc:5562
#define kTest_TS(A)
Definition: kutil.h:620
int posInL110(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.cc:5423
int max_lower_index
Definition: kutil.h:314
int j
Definition: myNF.cc:70
poly p1
Definition: kutil.h:184
KINLINE long pTotalDeg() const
Definition: kInline.h:400
void pairs()
KINLINE void Clear()
Definition: kInline.h:189
KINLINE void LmDeleteAndIter()
Definition: kInline.h:602
BOOLEAN Gebauer
Definition: kutil.h:368
intset fromQ
Definition: kutil.h:317
#define messageSets(s)
Definition: kutil.h:508
void enterOnePairNormal(int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR)
Definition: kutil.cc:1536
KINLINE poly k_LmShallowCopyDelete_currRing_2_tailRing(poly p, ring tailRing, omBin bin)
Definition: kInline.h:923
int posInTSig(const TSet set, const int length, LObject &p)
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:379
LObject * LSet
Definition: kutil.h:62
KINLINE TObject * T_2(const skStrategy *strat)
Definition: kInline.h:867
KINLINE poly CanonicalizeP()
Definition: kInline.h:648
void initBbaShift(ideal F, kStrategy strat)
Definition: kstd2.cc:3567
KINLINE TSet initT()
Definition: kInline.h:81
BOOLEAN enterOneStrongPoly(int i, poly p, int, int, kStrategy strat, int atR=-1, bool enterTstrong=FALSE)
Definition: kutil.cc:1399
void(* enterS)(LObject &h, int pos, kStrategy strat, int atR)
Definition: kutil.h:282
int posInL0(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.cc:4909
void enterSSba(LObject &p, int atS, kStrategy strat, int atR=-1)
Definition: kutil.cc:7680
KINLINE void ShallowCopyDelete(ring new_tailRing, omBin new_tailBin, pShallowCopyDeleteProc p_shallow_copy_delete, BOOLEAN set_max=TRUE)
Definition: kInline.h:348
ideal sba(ideal F, ideal Q, intvec *w, intvec *hilb, kStrategy strat)
Definition: kstd2.cc:1872
#define kTest_L(T)
Definition: kutil.h:623
void kDebugPrint(kStrategy strat)
Output some debug info about a given strategy.
Definition: kutil.cc:9907
ideal freegb(ideal I, int uptodeg, int lVblock)
Definition: kstd2.cc:3406
void deleteInSSba(int i, kStrategy strat)
Definition: kutil.cc:998
int posInS(const kStrategy strat, const int length, const poly p, const int ecart_p)
Definition: kutil.cc:4201
int redRing(LObject *h, kStrategy strat)
Definition: kstd2.cc:409
void initBba(ideal F, kStrategy strat)
Definition: kstd1.cc:1388
KINLINE void SetLmCurrRing()
Definition: kInline.h:274
int m
Definition: cfEzgcd.cc:119
KINLINE BOOLEAN arriRewDummy(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
Definition: kInline.h:1172
LObject P
Definition: kutil.h:298
int HCord
Definition: kutil.cc:227
ideal M
Definition: kutil.h:301
unsigned sbaOrder
Definition: kutil.h:312
BOOLEAN update
Definition: kutil.h:371
FILE * f
Definition: checklibs.c:7
int i
Definition: cfEzgcd.cc:123
poly tail
Definition: kutil.h:332
KINLINE void Normalize()
Definition: kInline.h:321
void initenterpairsShift(poly h, int k, int ecart, int isFromQ, kStrategy strat, int atR, int uptodeg, int lV)
Definition: kutil.cc:10730
poly redtailSba(LObject *L, int pos, kStrategy strat, BOOLEAN withT=FALSE, BOOLEAN normalize=FALSE)
Definition: kstd2.cc:845
void enterOnePairLift(int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR)
Definition: kutil.cc:1841
int(* posInLOld)(const LSet Ls, const int Ll, LObject *Lo, const kStrategy strat)
Definition: kutil.h:284
TObject ** R
Definition: kutil.h:338
poly lcm
Definition: kutil.h:187
KINLINE long Comp()
Definition: kInline.h:841
polyset S
Definition: kutil.h:302
int posInSyz(const kStrategy strat, const poly sig)
Definition: kutil.cc:5045
BOOLEAN sugarCrit
Definition: kutil.h:367
intset lenS
Definition: kutil.h:315
int redFirstShift(LObject *h, kStrategy strat)
Definition: kstd2.cc:3440
int posInT110(const TSet set, const int length, LObject &p)
Definition: kutil.cc:4508
int tmax
Definition: kutil.h:348
void initBuchMoraShift(ideal F, ideal Q, kStrategy strat)
Definition: kutil.cc:10180
void cleanT(kStrategy strat)
Definition: kutil.cc:505
int cp
Definition: kutil.h:345
void enterT_strong(LObject &p, kStrategy strat, int atT=-1)
Definition: kutil.cc:7895
int posInT17(const TSet set, const int length, LObject &p)
Definition: kutil.cc:4680
KINLINE void pCleardenom()
Definition: kInline.h:431
int posInL11Ringls(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.cc:5231
int pLength
Definition: kutil.h:80
BOOLEAN newHEdge(kStrategy strat)
Definition: kutil.cc:8924
void initEcartPairBba(LObject *Lp, poly f, poly g, int ecartF, int ecartG)
Definition: kutil.cc:1154
poly sig
Definition: kutil.h:74
kStrategy strat
Definition: myNF.cc:319
void cancelunit(LObject *p, BOOLEAN inNF=FALSE)
Definition: kutil.cc:324
int posInT_EcartFDegpLength(const TSet set, const int length, LObject &p)
Definition: kutil.cc:9782
Definition: kutil.h:70
BOOLEAN kHEdgeFound
Definition: kutil.h:366
intset ecartS
Definition: kutil.h:305
void exitSba(kStrategy strat)
Definition: kutil.cc:8614
poly pMoveCurrTail2poly(poly p, kStrategy strat)
Definition: kutil.cc:10042
poly t_kHEdge
Definition: kutil.h:327
void reorderS(int *suc, kStrategy strat)
Definition: kutil.cc:4148
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
KINLINE poly GetLmCurrRing()
Definition: kInline.h:217
s_poly_proc_t s_poly
Definition: kutil.h:296
void(* chainCrit)(poly p, int ecart, kStrategy strat)
Definition: kutil.h:287
poly p2
Definition: kutil.h:184
int ksReducePolyTail(LObject *PR, TObject *PW, poly Current, poly spNoether=NULL)
Definition: kspoly.cc:494
LSet L
Definition: kutil.h:323
BOOLEAN LDegLast
Definition: kutil.h:375
#define NULL
Definition: omList.c:10
intvec * kHomW
Definition: kutil.h:334
poly * polyset
Definition: hutil.h:17
LSet B
Definition: kutil.h:324
int Lmax
Definition: kutil.h:349
KINLINE void Mult_nn(number n)
Definition: kInline.h:309
int64 wlen_type
Definition: kutil.h:56
int mu
Definition: kutil.h:346
void enterSyz(LObject &p, kStrategy strat, int atT)
Definition: kutil.cc:8007
void enterpairs(poly h, int k, int ec, int pos, kStrategy strat, int atR=-1)
Definition: kutil.cc:3988
KINLINE poly redtailBba_Z(poly p, int pos, kStrategy strat)
Definition: kInline.h:1127
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:10402
ring tailRing
Definition: kutil.h:341
void updateSShift(kStrategy strat, int uptodeg, int lV)
Definition: kutil.cc:10152
BOOLEAN homogTest(polyset F, int Fmax)
long(* pFDegProc)(poly p, ring r)
Definition: ring.h:46
KINLINE poly GetLmTailRing()
Definition: kInline.h:224
void completeReduce(kStrategy strat, BOOLEAN withT=FALSE)
Definition: kutil.cc:8801
KINLINE long pLDeg()
Definition: kInline.h:415
void enterL(LSet *set, int *length, int *LSetmax, LObject p, int at)
Definition: kutil.cc:1115
KINLINE void clearS(poly p, unsigned long p_sev, int *at, int *k, kStrategy strat)
Definition: kInline.h:1145
KINLINE poly GetTP()
Definition: kInline.h:663
#define R
Definition: sirandom.c:26
denominator_list next
Definition: kutil.h:67
BOOLEAN is_special
Definition: kutil.h:99
poly t_kNoether
Definition: kutil.h:329
omBin tailBin
Definition: kutil.h:343
BOOLEAN(* s_poly_proc_t)(kStrategy strat)
Definition: kstd1.h:14
ideal D
Definition: kutil.h:300
const CanonicalForm & w
Definition: facAbsFact.cc:55
BOOLEAN arriRewCriterionPre(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
Definition: kutil.cc:5829
char overflow
Definition: kutil.h:394
KINLINE int SetLength(BOOLEAN lengt_pLength=FALSE)
Definition: kInline.h:816
int syzidxmax
Definition: kutil.h:347
intvec * kModW
Definition: kutil.h:333
BOOLEAN no_prod_crit
Definition: kutil.h:384
~skStrategy()
Definition: kutil.cc:9729
unsigned long * sevS
Definition: kutil.h:318
KINLINE long SetDegStuffReturnLDeg()
Definition: kInline.h:419
void deleteInS(int i, kStrategy strat)
Definition: kutil.cc:946
BOOLEAN arriRewCriterion(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
Definition: kutil.cc:5806
BOOLEAN faugereRewCriterion(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
Definition: kutil.cc:5750
void enterSBba(LObject &p, int atS, kStrategy strat, int atR=-1)
Definition: kutil.cc:7577
BOOLEAN posInLOldFlag
Definition: kutil.h:372
intset fromS
Definition: kutil.h:306
unsigned long * sevSyz
Definition: kutil.h:319
void finalReduceByMon(kStrategy strat)
used for GB over ZZ: final reduction by constant elements background: any known constant element of i...
Definition: kutil.cc:9294
int posInL10(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kstd1.cc:1046
denominator_list DENOMINATOR_LIST
Definition: kutil.cc:81
poly kFindZeroPoly(poly input_p, ring leadRing, ring tailRing)
Definition: kstd2.cc:295
int * intset
Definition: kutil.h:55
KINLINE void Delete()
Definition: kInline.h:499
KINLINE TObject * s_2_t(int i)
Definition: kInline.h:44
int posInT_EcartpLength(const TSet set, const int length, LObject &p)
Definition: kutil.cc:4583
int kFindNextDivisibleByInS(const kStrategy strat, int start, int max_ind, LObject *L)
Definition: kstd2.cc:250
polyset syz
Definition: kutil.h:303
void deleteInL(LSet set, int *length, int j, kStrategy strat)
Definition: kutil.cc:1053
int sl
Definition: kutil.h:346
int posInL13(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.cc:5469
KINLINE long pFDeg() const
Definition: kInline.h:395
BOOLEAN findMinLMPair(poly sig, unsigned long not_sevSig, kStrategy strat, int start)
TSet T
Definition: kutil.h:322
BOOLEAN kCheckSpolyCreation(LObject *L, kStrategy strat, poly &m1, poly &m2)
Definition: kutil.cc:8994
p exp[i]
Definition: DebugPrint.cc:39
KINLINE long GetpFDeg() const
Definition: kInline.h:410
int i_r2
Definition: kutil.h:189
wlen_type * wlen_set
Definition: kutil.h:57
omBin lmBin
Definition: kutil.h:342
void enterTShift(LObject p, kStrategy strat, int atT, int uptodeg, int lV)
Definition: kutil.cc:10803
KINLINE poly LmExtractAndIter()
Definition: kInline.h:622
poly redtail(poly p, int pos, kStrategy strat)
Definition: kutil.cc:6045
int(* test_PosInL)(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kstd2.cc:99
BOOLEAN syzCriterionInc(poly sig, unsigned long not_sevSig, kStrategy strat)
Definition: kutil.cc:5708
unsigned long sevSig
Definition: kutil.h:73
BOOLEAN use_buckets
Definition: kutil.h:373
END_NAMESPACE const void * p2
Definition: syzextra.cc:202
void kFreeStrat(kStrategy strat)
KINLINE poly redtailBba(poly p, int pos, kStrategy strat, BOOLEAN normalize=FALSE)
Definition: kInline.h:1120
poly kNF2(ideal F, ideal Q, poly q, kStrategy strat, int lazyReduce)
Definition: kstd2.cc:2592
KINLINE poly ksOldSpolyRedNew(poly p1, poly p2, poly spNoether=NULL)
Definition: kInline.h:1092
KINLINE poly GetLm(ring r)
Definition: kInline.h:237
void wrp(poly p)
Definition: polys.h:281
int posInT19(const TSet set, const int length, LObject &p)
Definition: kutil.cc:4809
#define kTest_T(T)
Definition: kutil.h:621
int strat_nr
Definition: kstdfac.cc:27
kBucketDestroy & P
Definition: myNF.cc:191
int LazyPass
Definition: kutil.h:351
KINLINE void Clear()
Definition: kInline.h:493
static jList * T
Definition: janet.cc:37
polyrec * poly
Definition: hilb.h:10
static LSet initL(int nr=setmaxL)
Definition: kutil.h:411
int newIdeal
Definition: kutil.h:355
KINLINE poly CopyGetP()
Definition: kInline.h:745
KINLINE poly k_LmInit_currRing_2_tailRing(poly p, ring tailRing, omBin bin)
Definition: kInline.h:905
int redNF0(LObject *P, kStrategy strat)
ideal Shdl
Definition: kutil.h:299
int posInT_FDegpLength(const TSet set, const int length, LObject &p)
Definition: kutil.cc:9836
BOOLEAN prod_crit
Definition: kutil.h:195
int(* red2)(LObject *L, kStrategy strat)
Definition: kutil.h:275
int posInT1(const TSet set, const int length, LObject &p)
Definition: kutil.cc:4317
static Poly * h
Definition: janet.cc:978
int int nonorm
Definition: myNF.cc:67
int BOOLEAN
Definition: auxiliary.h:131
int posInL11Ring(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.cc:5143
KINLINE long SetpFDeg()
Definition: kInline.h:405
int redLazy(LObject *h, kStrategy strat)
Definition: kstd2.cc:956
kStrategy next
Definition: kutil.h:273
KINLINE poly kNoetherTail()
Definition: kInline.h:63
unsigned long sev
Definition: kutil.h:183
int redHoney(LObject *h, kStrategy strat)
Definition: kstd2.cc:1116
int ecart
Definition: kutil.h:80
KINLINE void T_1_2(const skStrategy *strat, TObject *&T_1, TObject *&T_2)
Definition: kInline.h:878
char redTailChange
Definition: kutil.h:389
pFDegProc pOrigFDeg_TailRing
Definition: kutil.h:294
int posInL11(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.cc:5085
int syzl
Definition: kutil.h:347
BOOLEAN is_sigsafe
Definition: kutil.h:95
int LazyDegree
Definition: kutil.h:351
int l
Definition: cfEzgcd.cc:94
int redSig(LObject *h, kStrategy strat)
Definition: kstd2.cc:677
END_NAMESPACE BEGIN_NAMESPACE_SINGULARXX ideal poly int int lazyReduce
Definition: myNF.cc:292
KINLINE long SetDegStuffReturnLDeg()
Definition: kInline.h:795
poly pCopyL2p(LObject h, kStrategy strat)
Definition: kutil.cc:10059
class sTObject TObject
Definition: kutil.h:59
ring tailRing
Definition: kutil.h:78
KINLINE void Delete()
Definition: kInline.h:175
void initSL(ideal F, ideal Q, kStrategy strat)
Definition: kutil.cc:6486
poly p
Definition: kutil.h:75
intset syzIdx
Definition: kutil.h:309
KINLINE long MinComp()
Definition: kInline.h:826
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
int ksReducePoly(LObject *PR, TObject *PW, poly spNoether=NULL, number *coef=NULL, kStrategy strat=NULL)
Definition: kspoly.cc:38
KINLINE TObject * T_1(const skStrategy *strat)
Definition: kInline.h:857
KINLINE void ShallowCopyDelete(ring new_tailRing, pShallowCopyDeleteProc p_shallow_copy_delete)
Definition: kInline.h:706
ring sbaRing(kStrategy strat, const ring r=currRing, BOOLEAN complete=TRUE, int sgn=1)
Definition: kutil.cc:9491