My Project
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 #ifdef HAVE_OMALLOC
15 #include "omalloc/omallocClass.h"
16 #endif
17 
18 #include "misc/mylimits.h"
19 
20 #include "kernel/polys.h"
22 
23 #include "kernel/structs.h"
24 #include "kernel/GBEngine/kstd1.h" /* for s_poly_proc_t */
25 
26 // define if tailrings should be used
27 #define HAVE_TAIL_RING
28 
29 #define setmax 128
30 #define setmaxL ((4096-12)/sizeof(LObject))
31 #define setmaxLinc ((4096)/sizeof(LObject))
32 
33 #define setmaxT ((4096-12)/sizeof(TObject))
34 #define setmaxTinc ((4096)/sizeof(TObject))
35 
36 #define RED_CANONICALIZE 200
37 #define REDNF_CANONICALIZE 60
38 #define REDTAIL_CANONICALIZE 100
39 
40 // if you want std computations as in Singular version < 2:
41 // This disables RedThrough, tailReductions against T (bba),
42 // sets posInT = posInT15 (bba, strat->honey), and enables redFirst with LDeg
43 // NOTE: can be achieved with option(oldStd)
44 
45 #undef NO_KINLINE
46 #if !defined(KDEBUG) && !defined(NO_INLINE)
47 #define KINLINE inline
48 #else
49 #define KINLINE
50 #define NO_KINLINE 1
51 #endif
52 
53 typedef int* intset;
54 typedef int64 wlen_type;
56 
57 typedef class sTObject TObject;
58 typedef class sLObject LObject;
59 typedef TObject * TSet;
60 typedef LObject * LSet;
61 
64 
67 
68 class sTObject
69 {
70 public:
71  unsigned long sevSig;
72  poly sig; // the signature of the element
73  poly p; // Lm(p) \in currRing Tail(p) \in tailRing
74  poly t_p; // t_p \in tailRing: as monomials Lm(t_p) == Lm(p)
75  poly max_exp; // p_GetMaxExpP(pNext(p))
76  ring tailRing;
77  long FDeg; // pFDeg(p)
78  int ecart,
79  length, // as of pLDeg
80  pLength, // either == 0, or == pLength(p)
81  i_r; // index of TObject in R set, or -1 if not in T
82 
83 #ifdef HAVE_SHIFTBBA
84  int shift;
85 #endif
86 
87  /*BOOLEAN*/ char is_normalized; // true, if pNorm was called on p, false otherwise
88  // used in incremental sba() with F5C:
89  // we know some of the redundant elements in
90  // strat->T beforehand, so we can just discard
91  // them and do not need to consider them in the
92  // interreduction process
93  /*BOOLEAN*/ char is_redundant;
94  // used in sba's sig-safe reduction:
95  // sometimes we already know that a reducer
96  // is sig-safe, so no need for a real
97  // sig-safeness check
98  /*BOOLEAN*/ char is_sigsafe;
99 
100 
101 #ifdef HAVE_PLURAL
102  /*BOOLEAN*/ char is_special; // true, it is a new special S-poly (e.g. for SCA)
103 #endif
104 
105  // initialization
106  KINLINE void Init(ring r = currRing);
108  KINLINE sTObject(poly p, ring tailRing = currRing);
109  KINLINE sTObject(poly p, ring c_r, ring tailRing);
110  KINLINE sTObject(sTObject* T, int copy);
111 
112  KINLINE void Set(ring r=currRing);
113  KINLINE void Set(poly p_in, ring r=currRing);
114  KINLINE void Set(poly p_in, ring c_r, ring t_r);
115 
116  // Frees the polys of T
117  KINLINE void Delete();
118  // Sets polys to NULL
119  KINLINE void Clear();
120  // makes a copy of the poly of T
121  KINLINE void Copy();
122 
123  // ring-dependent Lm access: these might result in allocation of monomials
124  KINLINE poly GetLmCurrRing();
125  KINLINE poly GetLmTailRing();
126  KINLINE poly GetLm(ring r);
127  // this returns Lm and ring r (preferably from tailRing), but does not
128  // allocate a new poly
129  KINLINE void GetLm(poly &p, ring &r) const;
130 
131 #ifdef OLIVER_PRIVAT_LT
132  // routines for calc. with rings
133  KINLINE poly GetLtCurrRing();
134  KINLINE poly GetLtTailRing();
135  KINLINE poly GetLt(ring r);
136  KINLINE void GetLt(poly &p, ring &r) const;
137 #endif
138 
139  KINLINE BOOLEAN IsNull() const;
140 
141  KINLINE int GetpLength();
142 
143  // makes sure that T.p exists
144  KINLINE void SetLmCurrRing();
145 
146  // Iterations
147  // simply get the next monomial
148  KINLINE poly Next();
149  KINLINE void LmDeleteAndIter();
150 
151  // deg stuff
152  // compute pTotalDegree
153  KINLINE long pTotalDeg() const;
154  // computes pFDeg
155  KINLINE long pFDeg() const;
156  // computes and sets FDeg
157  KINLINE long SetpFDeg();
158  // gets stored FDeg
159  KINLINE long GetpFDeg() const;
160 
161  // computes pLDeg
162  KINLINE long pLDeg();
163  // sets length, FDeg, returns LDeg
165 
166  // arithmetic
167  KINLINE void Mult_nn(number n);
168  KINLINE void ShallowCopyDelete(ring new_tailRing, omBin new_tailBin,
169  pShallowCopyDeleteProc p_shallow_copy_delete,
170  BOOLEAN set_max = TRUE);
171  // manipulations
172  KINLINE void pNorm();
173  KINLINE void pCleardenom();
174  KINLINE void pContent();
175 
176 #ifdef KDEBUG
177  void wrp();
178 #endif
179 };
180 
182 
183 class sLObject : public sTObject
184 {
185 
186 public:
187  unsigned long sev;
188  poly p1,p2; /*- the pair p comes from,
189  lm(pi) in currRing, tail(pi) in tailring -*/
190 
191  poly lcm; /*- the lcm of p1,p2 -*/
193  int i_r1, i_r2;
194  unsigned checked; // this is the index of S up to which
195  // the corresponding LObject was already checked in
196  // critical pair creation => when entering the
197  // reduction process it is enough to start a second
198  // rewritten criterion check from checked+1 onwards
200  // NOTE: If prod_crit = TRUE then the corresponding pair is
201  // detected by Buchberger's Product Criterion and can be
202  // deleted
203 
204  // initialization
205  KINLINE void Init(ring tailRing = currRing);
207  KINLINE sLObject(poly p, ring tailRing = currRing);
208  KINLINE sLObject(poly p, ring c_r, ring tailRing);
209 
210  // Frees the polys of L
211  KINLINE void Delete();
212  KINLINE void Clear();
213 
214  // Iterations
215  KINLINE void LmDeleteAndIter();
216  KINLINE poly LmExtractAndIter();
217 
218  // spoly related things
219  // preparation for reduction if not spoly
220  KINLINE void PrepareRed(BOOLEAN use_bucket);
221  KINLINE void SetLmTail(poly lm, poly new_p, int length,
222  int use_bucket, ring r);
223  KINLINE void Tail_Minus_mm_Mult_qq(poly m, poly qq, int lq, poly spNoether);
224  KINLINE void Tail_Mult_nn(number n);
225  // deletes bucket, makes sure that p and t_p exists
226  KINLINE poly GetP(omBin lmBin = (omBin)NULL);
227  // similar, except that only t_p exists
228  KINLINE poly GetTP();
229 
230  // does not delete bucket, just canonicalizes it
231  // returned poly is such that Lm(p) \in currRing, Tail(p) \in tailRing
232  KINLINE void CanonicalizeP();
233 
234  // makes a copy of the poly of L
235  KINLINE void Copy();
236 
237  KINLINE int GetpLength();
238  KINLINE long pLDeg(BOOLEAN use_last);
239  KINLINE long pLDeg();
240  KINLINE int SetLength(BOOLEAN lengt_pLength = FALSE);
242  KINLINE long SetDegStuffReturnLDeg(BOOLEAN use_last);
243 
244  // returns minimal component of p
245  KINLINE long MinComp();
246  // returns component of p
247  KINLINE long Comp();
248 
249  KINLINE void ShallowCopyDelete(ring new_tailRing,
250  pShallowCopyDeleteProc p_shallow_copy_delete);
251 
252  // sets sev
253  KINLINE void SetShortExpVector();
254 
255  // enable assignment from TObject
257 
258  // get T's corresponding to p1, p2: they might return NULL
259  KINLINE TObject* T_1(const skStrategy* strat);
260  KINLINE TObject* T_2(const skStrategy* strat);
261  KINLINE void T_1_2(const skStrategy* strat,
262  TObject* &T_1, TObject* &T_2);
263 
264  // simplify coefficients
265  KINLINE void Normalize();
266  KINLINE void HeadNormalize();
267 };
268 
270 
272 #ifdef HAVE_OMALLOC
273  : public omallocClass
274 #endif
275 {
276 public:
278  int (*red)(LObject * L,kStrategy strat);
279  int (*red2)(LObject * L,kStrategy strat);
280  void (*initEcart)(TObject * L);
281  int (*posInT)(const TSet T,const int tl,LObject &h);
282  int (*posInLSba)(const LSet set, const int length,
283  LObject* L,const kStrategy strat);
284  int (*posInL)(const LSet set, const int length,
285  LObject* L,const kStrategy strat);
286  void (*enterS)(LObject &h, int pos,kStrategy strat, int atR/* =-1*/ );
287  void (*initEcartPair)(LObject * h, poly f, poly g, int ecartF, int ecartG);
288  int (*posInLOld)(const LSet Ls,const int Ll,
289  LObject* Lo,const kStrategy strat);
290  void (*enterOnePair) (int i,poly p,int ecart, int isFromQ,kStrategy strat, int atR /*= -1*/);
291  void (*chainCrit) (poly p,int ecart,kStrategy strat);
292  BOOLEAN (*syzCrit) (poly sig, unsigned long not_sevSig, kStrategy strat);
293  BOOLEAN (*rewCrit1) (poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start /*= 0*/);
294  BOOLEAN (*rewCrit2) (poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start /*= 0*/);
295  BOOLEAN (*rewCrit3) (poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start /*= 0*/);
301 
303  ideal Shdl;
304  ideal D; /*V(S) is in D(D)*/
305  ideal M; /*set of minimal generators*/
310  intset fromS; // from which S[i] S[j] comes from
311  // this is important for signature-based
312  // algorithms
313  intset syzIdx;// index in the syz array at which the first
314  // syzygy of component i comes up
315  // important for signature-based algorithms
316  unsigned sbaOrder;
317  int currIdx;
320  wlen_set lenSw; /* for tgb.ccc */
322  unsigned long* sevS;
323  unsigned long* sevSyz;
324  unsigned long* sevSig;
325  unsigned long* sevT;
329  poly kNoether;
330  poly t_kNoether; // same polys in tailring
331  KINLINE poly kNoetherTail();
333  BOOLEAN * pairtest;/*used for enterOnePair*/
334  poly tail;
337  // procedure for ShalloCopy from tailRing to currRing
339  // pointers to Tobjects R[i] is ith Tobject which is generated
341  // S_2_R[i] yields Tobject which corresponds to S[i]
342  int* S_2_R;
343  ring tailRing;
346  int nr;
347  int cp,c3;
348  int sl,mu;
350  int tl,tmax;
351  int Ll,Lmax;
352  int Bl,Bmax;
354  int syzComp;
355  int lastAxis;
356  int newIdeal;
357  int minim;
358  #ifdef HAVE_RINGS
359  bool sigdrop; //This is used to check sigdrop in sba over Z
360  int nrsyzcrit; // counts how many pairs are deleted by SyzCrit
361  int nrrewcrit; // counts how many pairs are deleted by FaugereRewCrit
362  int sbaEnterS; // sba over Z strategy: if sigdrop element has _*gen(sbaEnterS+1), then
363  // add directly sbaEnterS elements into S
364  int blockred; // counter for blocked reductions in redSig
366  #endif
367  #ifdef HAVE_SHIFTBBA
368  int cv; // in shift bases: counting V criterion
369  /*BOOLEAN*/ char rightGB;
370  #endif
371  /*BOOLEAN*/ char interpt;
372  /*BOOLEAN*/ char homog;
373 #ifdef HAVE_PLURAL
374  /*BOOLEAN*/ char z2homog; // Z_2 - homogeneous input allows product criterion in commutative and SCA cases!
375 #endif
376  /*BOOLEAN*/ char kAllAxis; // all axis are used -> (re)compute noether
377  /*BOOLEAN*/ char honey,sugarCrit;
378  /*BOOLEAN*/ char Gebauer,noTailReduction;
379  /*BOOLEAN*/ char fromT;
380  /*BOOLEAN*/ char noetherSet;
381  /*BOOLEAN*/ char update;
382  /*BOOLEAN*/ char posInLOldFlag;
383  /*BOOLEAN*/ char use_buckets;
384  // if set, pLDeg(p, l) == (pFDeg(pLast(p), pLength)
385  /*BOOLEAN*/ char LDegLast;
386  // if set, then L.length == L.pLength
387  /*BOOLEAN*/ char length_pLength;
388  // if set, then posInL does not depend on L.length
389  /*BOOLEAN*/ char posInLDependsOnLength;
390  /*FALSE, if posInL == posInL10*/
391 #ifdef HAVE_PLURAL
392  // set this flag to 1 to stop the product criteria
393  // use ALLOW_PROD_CRIT(strat) to test
394  /*BOOLEAN*/ char no_prod_crit;
395 #define ALLOW_PROD_CRIT(A) (!(A)->no_prod_crit)
396 #else
397 #define ALLOW_PROD_CRIT(A) (1)
398 #endif
400  char news;
401  char newt;/*used for messageSets*/
402  char noClearS;
404  char overflow;
405 
406  skStrategy();
407  ~skStrategy();
408 
409  // return TObject corresponding to S[i]: assume that it exists
410  // i.e. no error checking is done
411  KINLINE TObject* S_2_T(int i);
412  // like S_2_T, except that NULL is returned if it can not be found
413  KINLINE TObject* s_2_t(int i);
414 };
415 
416 void deleteHC(poly *p, int *e, int *l, kStrategy strat);
417 void deleteHC(LObject* L, kStrategy strat, BOOLEAN fromNext = FALSE);
418 void deleteInS (int i,kStrategy strat);
419 void deleteInSSba (int i,kStrategy strat);
420 void cleanT (kStrategy strat);
421 static inline LSet initL (int nr=setmaxL)
422 { return (LSet)omAlloc(nr*sizeof(LObject)); }
423 void deleteInL(LSet set, int *length, int j,kStrategy strat);
424 void enterL (LSet *set,int *length, int *LSetmax, LObject p,int at);
425 void enterSBba (LObject &p,int atS,kStrategy strat, int atR = -1);
426 void enterSBbaShift (LObject &p,int atS,kStrategy strat, int atR = -1);
427 void enterSSba (LObject &p,int atS,kStrategy strat, int atR = -1);
428 void initEcartPairBba (LObject* Lp,poly f,poly g,int ecartF,int ecartG);
429 void initEcartPairMora (LObject* Lp,poly f,poly g,int ecartF,int ecartG);
430 int posInS (const kStrategy strat, const int length, const poly p,
431  const int ecart_p);
432 int posInSMonFirst (const kStrategy strat, const int length, const poly p);
433 int posInIdealMonFirst (const ideal F, const poly p,int start = 0,int end = -1);
434 int posInT0 (const TSet set,const int length,LObject &p);
435 int posInT1 (const TSet set,const int length,LObject &p);
436 int posInT2 (const TSet set,const int length,LObject &p);
437 int posInT11 (const TSet set,const int length,LObject &p);
438 int posInTSig (const TSet set,const int length,LObject &p);
439 int posInT110 (const TSet set,const int length,LObject &p);
440 int posInT13 (const TSet set,const int length,LObject &p);
441 int posInT15 (const TSet set,const int length,LObject &p);
442 int posInT17 (const TSet set,const int length,LObject &p);
443 int posInT17_c (const TSet set,const int length,LObject &p);
444 int posInT19 (const TSet set,const int length,LObject &p);
445 int posInT_EcartpLength(const TSet set,const int length,LObject &p);
446 int posInT_EcartFDegpLength(const TSet set,const int length,LObject &p);
447 int posInT_FDegpLength(const TSet set,const int length,LObject &p);
448 int posInT_pLength(const TSet set,const int length,LObject &p);
449 
450 #ifdef HAVE_MORE_POS_IN_T
451 int posInT_EcartFDegpLength(const TSet set,const int length,LObject &p);
452 int posInT_FDegpLength(const TSet set,const int length,LObject &p);
453 int posInT_pLength(const TSet set,const int length,LObject &p);
454 #endif
455 
456 
457 void reorderS (int* suc,kStrategy strat);
458 int posInLF5C (const LSet set, const int length,
459  LObject* L,const kStrategy strat);
460 int posInLSig (const LSet set, const int length,
461  LObject* L,const kStrategy strat);
462 int posInLSigRing (const LSet set, const int length,
463  LObject* L,const kStrategy strat);
464 int posInLRing (const LSet set, const int length,
465  LObject* L,const kStrategy strat);
466 int posInSyz (const kStrategy strat, const poly sig);
467 int posInL0 (const LSet set, const int length,
468  LObject* L,const kStrategy strat);
469 int posInL11 (const LSet set, const int length,
470  LObject* L,const kStrategy strat);
471 int posInL11Ring (const LSet set, const int length,
472  LObject* L,const kStrategy strat);
473 int posInLF5CRing (const LSet set, int start , const int length,
474  LObject* L,const kStrategy strat);
475 int posInL11Ringls (const LSet set, const int length,
476  LObject* L,const kStrategy strat);
477 int posInL13 (const LSet set, const int length,
478  LObject* L,const kStrategy strat);
479 int posInL15 (const LSet set, const int length,
480  LObject* L,const kStrategy strat);
481 int posInL15Ring (const LSet set, const int length,
482  LObject* L,const kStrategy strat);
483 int posInL17 (const LSet set, const int length,
484  LObject* L,const kStrategy strat);
485 int posInL10 (const LSet set, const int length,
486  LObject* L,const kStrategy strat);
487 int posInL10Ring (const LSet set, const int length,
488  LObject* L,const kStrategy strat);
489 int posInL110 (const LSet set, const int length,
490  LObject* L,const kStrategy strat);
491 KINLINE poly redtailBba (poly p,int end_pos,kStrategy strat,BOOLEAN normalize=FALSE);
492 KINLINE poly redtailBbaBound (poly p,int end_pos,kStrategy strat,int bound,BOOLEAN normalize=FALSE);
493 #ifdef HAVE_RINGS
494 KINLINE poly redtailBba_Ring (poly p,int end_pos,kStrategy strat);
495 KINLINE poly redtailBba_Z (poly p,int end_pos,kStrategy strat);
496 poly redtailBba_Ring (LObject* L, int end_pos, kStrategy strat );
497 poly redtailBba_Z (LObject* L, int end_pos, kStrategy strat );
498 void redtailBbaAlsoLC_Z (LObject* L, int end_pos, kStrategy strat );
499 #endif
500 poly redtailBba (LObject *L, int end_pos,kStrategy strat,
502 poly redtailBbaBound (LObject *L, int end_pos,kStrategy strat,int bound,
504 poly redtailSba (LObject *L, int end_pos,kStrategy strat,
506 poly redtailBba (TObject *T, int end_pos,kStrategy strat);
507 poly redtail (poly p,int end_pos,kStrategy strat);
508 poly redtail (LObject *L,int end_pos,kStrategy strat);
509 poly redNF (poly h,int & max_ind,int nonorm,kStrategy strat);
510 int redNF0 (LObject *P,kStrategy strat);
511 poly redNFTail (poly h,const int sl,kStrategy strat);
512 int redHoney (LObject* h, kStrategy strat);
513 int redLiftstd (LObject* h, kStrategy strat);
514 #ifdef HAVE_RINGS
515 int redRing (LObject* h,kStrategy strat);
516 int redRing_Z (LObject* h,kStrategy strat);
517 int redRiloc (LObject* h,kStrategy strat);
518 void enterExtendedSpoly(poly h,kStrategy strat);
519 void enterExtendedSpolySig(poly h,poly hSig,kStrategy strat);
520 void superenterpairs (poly h,int k,int ecart,int pos,kStrategy strat, int atR = -1);
521 void superenterpairsSig (poly h,poly hSig,int hFrom,int k,int ecart,int pos,kStrategy strat, int atR = -1);
522 #endif
523 int redLazy (LObject* h,kStrategy strat);
524 int redHomog (LObject* h,kStrategy strat);
525 int redSig (LObject* h,kStrategy strat);
526 int redSigRing (LObject* h,kStrategy strat);
527 //adds hSig to be able to check with F5's criteria when entering pairs!
528 void enterpairsSig (poly h, poly hSig, int from, int k, int ec, int pos,kStrategy strat, int atR = -1);
529 void enterpairs (poly h, int k, int ec, int pos,kStrategy strat, int atR = -1);
531 void pairs ();
533 void message (int i,int* reduc,int* olddeg,kStrategy strat,int red_result);
534 void messageStat (int hilbcount,kStrategy strat);
535 void messageStatSBA (int hilbcount,kStrategy strat);
536 #ifdef KDEBUG
537 void messageSets (kStrategy strat);
538 #else
539 #define messageSets(s) do {} while (0)
540 #endif
541 
542 void initEcartNormal (TObject* h);
543 void initEcartBBA (TObject* h);
544 void initS (ideal F, ideal Q,kStrategy strat);
545 void initSL (ideal F, ideal Q,kStrategy strat);
546 void initSLSba (ideal F, ideal Q,kStrategy strat);
547 /*************************************************
548  * when initializing a new bunch of principal
549  * syzygies at the beginning of a new iteration
550  * step in a signature-based algorithm we
551  * compute ONLY the leading elements of those
552  * syzygies, NOT the whole syzygy
553  * NOTE: this needs to be adjusted for a more
554  * general approach on signature-based algorithms
555  ***********************************************/
556 void initSyzRules (kStrategy strat);
557 void updateS(BOOLEAN toT,kStrategy strat);
558 void enterSyz (LObject &p,kStrategy strat, int atT);
559 void enterT (LObject &p,kStrategy strat, int atT = -1);
560 void replaceInLAndSAndT(LObject &p, int tj, kStrategy strat);
561 #ifdef HAVE_RINGS
562 void enterT_strong (LObject &p,kStrategy strat, int atT = -1);
563 #endif
564 void cancelunit (LObject* p,BOOLEAN inNF=FALSE);
565 void HEckeTest (poly pp,kStrategy strat);
566 void initBuchMoraCrit(kStrategy strat);
567 void initSbaCrit(kStrategy strat);
568 void initHilbCrit(ideal F, ideal Q, intvec **hilb,kStrategy strat);
569 void initBuchMoraPos(kStrategy strat);
570 void initBuchMoraPosRing(kStrategy strat);
571 void initSbaPos(kStrategy strat);
572 void initBuchMora (ideal F, ideal Q,kStrategy strat);
573 void initSbaBuchMora (ideal F, ideal Q,kStrategy strat);
574 void exitBuchMora (kStrategy strat);
575 void exitSba (kStrategy strat);
576 void updateResult(ideal r,ideal Q,kStrategy strat);
577 void completeReduce (kStrategy strat, BOOLEAN withT=FALSE);
578 void kFreeStrat(kStrategy strat);
579 void enterOnePairNormal (int i,poly p,int ecart, int isFromQ,kStrategy strat, int atR);
580 void chainCritNormal (poly p,int ecart,kStrategy strat);
581 void chainCritOpt_1 (poly,int,kStrategy strat);
582 void chainCritSig (poly p,int ecart,kStrategy strat);
583 BOOLEAN homogTest(polyset F, int Fmax);
584 BOOLEAN newHEdge(kStrategy strat);
585 BOOLEAN syzCriterion(poly sig, unsigned long not_sevSig, kStrategy strat);
586 BOOLEAN syzCriterionInc(poly sig, unsigned long not_sevSig, kStrategy strat);
587 KINLINE BOOLEAN arriRewDummy(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start);
588 BOOLEAN arriRewCriterion(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start);
589 BOOLEAN arriRewCriterionPre(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start);
590 BOOLEAN faugereRewCriterion(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start);
591 BOOLEAN findMinLMPair(poly sig, unsigned long not_sevSig, kStrategy strat, int start);
592 
593 /// returns index of p in TSet, or -1 if not found
594 int kFindInT(poly p, TSet T, int tlength);
595 #ifdef HAVE_SHIFTBBA
596 int kFindInTShift(poly p, TSet T, int tlength);
597 #endif
598 
599 /// return -1 if no divisor is found
600 /// number of first divisor in T, otherwise
601 int kFindDivisibleByInT(const kStrategy strat, const LObject* L, const int start=0);
602 int kFindDivisibleByInT_Z(const kStrategy strat, const LObject* L, const int start=0);
603 int kFindSameLMInT_Z(const kStrategy strat, const LObject* L, const int start=0);
604 
605 /// tests if T[0] divides the leading monomial of L, returns -1 if not
606 int kTestDivisibleByT0_Z(const kStrategy strat, const LObject* L);
607 /// return -1 if no divisor is found
608 /// number of first divisor in S, otherwise
609 int kFindDivisibleByInS(const kStrategy strat, int *max_ind, LObject* L);
610 
611 int kFindNextDivisibleByInS(const kStrategy strat, int start,int max_ind, LObject* L);
612 TObject* kFindDivisibleByInS_T(kStrategy strat, int end_pos, LObject* L, TObject *T, long ecart = LONG_MAX);
613 
614 /***************************************************************
615  *
616  * stuff to be inlined
617  *
618  ***************************************************************/
619 
620 KINLINE TSet initT ();
621 KINLINE TObject** initR();
622 KINLINE unsigned long* initsevT();
623 KINLINE poly k_LmInit_currRing_2_tailRing(poly p, ring tailRing, omBin bin);
624 KINLINE poly k_LmInit_tailRing_2_currRing(poly p, ring tailRing, omBin bin);
625 KINLINE poly k_LmShallowCopyDelete_currRing_2_tailRing(poly p, ring tailRing, omBin bin);
626 KINLINE poly k_LmShallowCopyDelete_tailRing_2_currRing(poly p, ring tailRing, omBin bin);
627 
628 KINLINE poly k_LmInit_currRing_2_tailRing(poly p, ring tailRing);
629 KINLINE poly k_LmInit_tailRing_2_currRing(poly p, ring tailRing);
630 KINLINE poly k_LmShallowCopyDelete_currRing_2_tailRing(poly p, ring tailRing);
631 KINLINE poly k_LmShallowCopyDelete_tailRing_2_currRing(poly p, ring tailRing);
632 
633 // if exp bound is not violated, return TRUE and
634 // get m1 = LCM(LM(p1), LM(p2))/LM(p1)
635 // m2 = LCM(LM(p1), LM(p2))/LM(p2)
636 // return FALSE and m1 == NULL, m2 == NULL , otherwise
637 KINLINE BOOLEAN k_GetLeadTerms(const poly p1, const poly p2, const ring p_r,
638  poly &m1, poly &m2, const ring m_r);
639 #ifdef HAVE_RINGS
640 KINLINE void k_GetStrongLeadTerms(const poly p1, const poly p2, const ring leadRing,
641  poly &m1, poly &m2, poly &lcm, const ring taiRing);
642 #endif
643 #ifdef KDEBUG
644 // test strat
645 BOOLEAN kTest(kStrategy strat);
646 // test strat, and test that S is contained in T
647 BOOLEAN kTest_TS(kStrategy strat);
648 // test LObject
649 BOOLEAN kTest_L(LObject* L, kStrategy strat,
650  BOOLEAN testp = FALSE, int lpos = -1,
651  TSet T = NULL, int tlength = -1);
652 // test TObject
653 BOOLEAN kTest_T(TObject* T, kStrategy strat, int tpos = -1, char TN = '?');
654 // test set strat->SevS
655 BOOLEAN kTest_S(kStrategy strat);
656 #else
657 #define kTest(A) (TRUE)
658 #define kTest_TS(A) (TRUE)
659 #define kTest_T(T,S) (TRUE)
660 #define kTest_S(T) (TRUE)
661 #define kTest_L(T,R) (TRUE)
662 #endif
663 
664 
665 /***************************************************************
666  *
667  * From kstd2.cc
668  *
669  ***************************************************************/
670 poly kFindZeroPoly(poly input_p, ring leadRing, ring tailRing);
671 ideal bba (ideal F, ideal Q,intvec *w,intvec *hilb,kStrategy strat);
672 ideal sba (ideal F, ideal Q,intvec *w,intvec *hilb,kStrategy strat);
673 poly kNF2 (ideal F, ideal Q, poly q, kStrategy strat, int lazyReduce);
674 ideal kNF2 (ideal F,ideal Q,ideal q, kStrategy strat, int lazyReduce);
675 poly kNF2Bound (ideal F, ideal Q, poly q,int bound, kStrategy strat, int lazyReduce);
676 ideal kNF2Bound (ideal F,ideal Q,ideal q,int bound, kStrategy strat, int lazyReduce);
677 void initBba(kStrategy strat);
678 void initSba(ideal F,kStrategy strat);
679 void f5c (kStrategy strat, int& olddeg, int& minimcnt, int& hilbeledeg,
680  int& hilbcount, int& srmax, int& lrmax, int& reduc, ideal Q,
681  intvec *w,intvec *hilb );
682 
683 /***************************************************************
684  *
685  * From kspoly.cc
686  *
687  ***************************************************************/
688 // Reduces PR with PW
689 // Assumes PR != NULL, PW != NULL, Lm(PW) divides Lm(PR)
690 // Changes: PR
691 // Const: PW
692 // If coef != NULL, then *coef is a/gcd(a,b), where a = LC(PR), b = LC(PW)
693 // If strat != NULL, tailRing is changed if reduction would violate exp bound
694 // of tailRing
695 // Returns: 0 everything ok, no tailRing change
696 // 1 tailRing has successfully changed (strat != NULL)
697 // 2 no reduction performed, tailRing needs to be changed first
698 // (strat == NULL)
699 // -1 tailRing change could not be performed due to exceeding exp
700 // bound of currRing
701 int ksReducePoly(LObject* PR,
702  TObject* PW,
703  poly spNoether = NULL,
704  number *coef = NULL,
705  poly *mon =NULL,
706  kStrategy strat = NULL);
707 
708 /* like ksReducePoly, but if the reducer has only 1 term we still
709  * compute a possible coefficient multiplier for PR. this comes from
710  * a special situation in redRing_Z and it is used only there. */
711 int ksReducePolyZ(LObject* PR,
712  TObject* PW,
713  poly spNoether = NULL,
714  number *coef = NULL,
715  kStrategy strat = NULL);
716 
717 int ksReducePolyLC(LObject* PR,
718  TObject* PW,
719  poly spNoether = NULL,
720  number *coef = NULL,
721  kStrategy strat = NULL);
722 
723 
724 int ksReducePolyGCD(LObject* PR,
725  TObject* PW,
726  poly spNoether = NULL,
727  number *coef = NULL,
728  kStrategy strat = NULL);
729 
730 int ksReducePolyBound(LObject* PR,
731  TObject* PW,
732  int bound,
733  poly spNoether = NULL,
734  number *coef = NULL,
735  kStrategy strat = NULL);
736 
737 // Reduces PR with PW
738 // Assumes PR != NULL, PW != NULL, Lm(PW) divides Lm(PR)
739 // Changes: PR
740 // Const: PW
741 // If coef != NULL, then *coef is a/gcd(a,b), where a = LC(PR), b = LC(PW)
742 // If strat != NULL, tailRing is changed if reduction would violate exp bound
743 // of tailRing
744 // Returns: 0 everything ok, no tailRing change
745 // 1 tailRing has successfully changed (strat != NULL)
746 // 2 no reduction performed, tailRing needs to be changed first
747 // (strat == NULL)
748 // 3 no reduction performed, not sig-safe!!!
749 // -1 tailRing change could not be performed due to exceeding exp
750 // bound of currRing
751 int ksReducePolySig(LObject* PR,
752  TObject* PW,
753  long idx,
754  poly spNoether = NULL,
755  number *coef = NULL,
756  kStrategy strat = NULL);
757 
759  TObject* PW,
760  long idx,
761  poly spNoether = NULL,
762  number *coef = NULL,
763  kStrategy strat = NULL);
764 
765 // Reduces PR at Current->next with PW
766 // Assumes PR != NULL, Current contained in PR
767 // Current->next != NULL, LM(PW) devides LM(Current->next)
768 // Changes: PR
769 // Const: PW
770 // Return: see ksReducePoly
771 int ksReducePolyTail(LObject* PR,
772  TObject* PW,
773  poly Current,
774  poly spNoether = NULL);
775 
776 KINLINE int ksReducePolyTail(LObject* PR, TObject* PW, LObject* Red);
777 
778 // Creates S-Poly of Pair
779 // Const: Pair->p1, Pair->p2
780 // Changes: Pair->p == S-Poly of p1, p2
781 // Assume: Pair->p1 != NULL && Pair->p2
782 void ksCreateSpoly(LObject* Pair, poly spNoether = NULL,
783  int use_buckets=0, ring tailRing=currRing,
784  poly m1 = NULL, poly m2 = NULL, TObject** R = NULL);
785 
786 /*2
787 * creates the leading term of the S-polynomial of p1 and p2
788 * do not destroy p1 and p2
789 * remarks:
790 * 1. the coefficient is 0 (nNew)
791 * 2. pNext is undefined
792 */
793 poly ksCreateShortSpoly(poly p1, poly p2, ring tailRing);
794 
795 
796 // old stuff
797 KINLINE poly ksOldSpolyRed(poly p1, poly p2, poly spNoether = NULL);
798 KINLINE poly ksOldSpolyRedNew(poly p1, poly p2, poly spNoether = NULL);
799 KINLINE poly ksOldCreateSpoly(poly p1, poly p2, poly spNoether = NULL, ring r = currRing);
800 KINLINE void ksOldSpolyTail(poly p1, poly q, poly q2, poly spNoether, ring r = currRing);
801 
802 /***************************************************************
803  *
804  * Routines related for ring changes during std computations
805  *
806  ***************************************************************/
807 // return TRUE and set m1, m2 to k_GetLcmTerms,
808 // if spoly creation of strat->P does not violate
809 // exponent bound of strat->tailRing
810 // FALSE, otherwise
811 BOOLEAN kCheckSpolyCreation(LObject* L, kStrategy strat, poly &m1, poly &m2);
812 #ifdef HAVE_RINGS
813 // return TRUE if gcdpoly creation of R[atR] and S[atS] does not violate
814 // exponent bound of strat->tailRing
815 // FALSE, otherwise
816 BOOLEAN kCheckStrongCreation(int atR, poly m1, int atS, poly m2, kStrategy strat);
817 poly preIntegerCheck(ideal F, ideal Q);
818 void postReduceByMon(LObject* h, kStrategy strat);
819 void postReduceByMonSig(LObject* h, kStrategy strat);
820 void finalReduceByMon(kStrategy strat);
821 #endif
822 // change strat->tailRing and adjust all data in strat, L, and T:
823 // new tailRing has larger exponent bound
824 // do nothing and return FALSE if exponent bound increase would result in
825 // larger exponent bound that that of currRing
827  LObject* L = NULL, TObject* T = NULL,
828  // take this as new_expbound: if 0
829  // new expbound is 2*expbound of tailRing
830  unsigned long new_expbound = 0);
831 // initiate a change of the tailRing of strat -- should be called
832 // right before main loop in bba
834 
835 /// Output some debug info about a given strategy
836 void kDebugPrint(kStrategy strat);
837 
838 // getting sb order for sba computations
839 ring sbaRing(kStrategy strat, const ring r=currRing, BOOLEAN complete=TRUE, int sgn=1);
840 
841 KINLINE void clearS (poly p, unsigned long p_sev, int* at, int* k,
842  kStrategy strat);
843 
844 #include "kernel/GBEngine/kInline.h"
845 
846 /* shiftgb stuff */
847 #include "kernel/GBEngine/shiftgb.h"
848 
849 poly pMove2CurrTail(poly p, kStrategy strat);
850 
851 poly pMoveCurrTail2poly(poly p, kStrategy strat);
852 
853 poly pCopyL2p(LObject h, kStrategy strat);
854 
855 void enterTShift(LObject p, kStrategy strat, int atT = -1);
856 
857 void enterOnePairShift (poly q, poly p, int ecart, int isFromQ, kStrategy strat, int atR, int ecartq, int qisFromQ, int shiftcount, int ifromS);
858 
859 void enterpairsShift (poly h,int k,int ecart,int pos,kStrategy strat, int atR);
860 
861 void superenterpairsShift (poly h,int k,int ecart,int pos,kStrategy strat, int atR);
862 
863 poly redtailBbaShift (LObject* L, int pos, kStrategy strat, BOOLEAN withT, BOOLEAN normalize);
864 
865 int redFirstShift (LObject* h,kStrategy strat); // ok
866 
867 ideal bbaShift(ideal F, ideal Q,intvec *w,intvec *hilb,kStrategy strat);
868 // test syz strategy: // will be removed soon
869 EXTERN_VAR int (*test_PosInT)(const TSet T,const int tl,LObject &h);
870 EXTERN_VAR int (*test_PosInL)(const LSet set, const int length,
871  LObject* L,const kStrategy strat);
872 
873 static inline void kDeleteLcm(LObject *P)
874 {
875  if (P->lcm!=NULL)
876  {
877  #ifdef HAVE_RINGS
879  pLmDelete(P->lcm);
880  else
881  #endif
882  pLmFree(P->lcm);
883  P->lcm=NULL;
884  }
885 }
886 
887 void initenterpairs (poly h,int k,int ecart,int isFromQ,kStrategy strat, int atR = -1);
888 #endif
int sgn(const Rational &a)
Definition: GMPrat.cc:430
long int64
Definition: auxiliary.h:68
int BOOLEAN
Definition: auxiliary.h:87
#define TRUE
Definition: auxiliary.h:100
#define FALSE
Definition: auxiliary.h:96
CanonicalForm FACTORY_PUBLIC pp(const CanonicalForm &)
CanonicalForm pp ( const CanonicalForm & f )
Definition: cf_gcd.cc:676
int l
Definition: cfEzgcd.cc:100
int m
Definition: cfEzgcd.cc:128
int i
Definition: cfEzgcd.cc:132
int k
Definition: cfEzgcd.cc:99
int p
Definition: cfModGcd.cc:4078
g
Definition: cfModGcd.cc:4090
static CanonicalForm bound(const CFMatrix &M)
Definition: cf_linsys.cc:460
FILE * f
Definition: checklibs.c:9
Definition: intvec.h:23
KINLINE long SetDegStuffReturnLDeg()
Definition: kInline.h:859
KINLINE void Tail_Mult_nn(number n)
Definition: kInline.h:664
int i_r1
Definition: kutil.h:193
KINLINE void Copy()
Definition: kInline.h:812
KINLINE void Delete()
Definition: kInline.h:597
KINLINE void LmDeleteAndIter()
Definition: kInline.h:700
KINLINE TObject * T_2(const skStrategy *strat)
Definition: kInline.h:931
KINLINE void PrepareRed(BOOLEAN use_bucket)
Definition: kInline.h:628
unsigned checked
Definition: kutil.h:194
KINLINE void CanonicalizeP()
Definition: kInline.h:372
KINLINE void SetLmTail(poly lm, poly new_p, int length, int use_bucket, ring r)
Definition: kInline.h:646
KINLINE void T_1_2(const skStrategy *strat, TObject *&T_1, TObject *&T_2)
Definition: kInline.h:942
KINLINE void Normalize()
Definition: kInline.h:358
unsigned long sev
Definition: kutil.h:187
KINLINE void Init(ring tailRing=currRing)
Definition: kInline.h:604
KINLINE long MinComp()
Definition: kInline.h:890
kBucket_pt bucket
Definition: kutil.h:192
poly p2
Definition: kutil.h:188
BOOLEAN prod_crit
Definition: kutil.h:199
KINLINE TObject * T_1(const skStrategy *strat)
Definition: kInline.h:921
KINLINE int GetpLength()
Definition: kInline.h:873
KINLINE int SetLength(BOOLEAN lengt_pLength=FALSE)
Definition: kInline.h:880
poly lcm
Definition: kutil.h:191
KINLINE void Clear()
Definition: kInline.h:591
KINLINE void Tail_Minus_mm_Mult_qq(poly m, poly qq, int lq, poly spNoether)
Definition: kInline.h:678
KINLINE void ShallowCopyDelete(ring new_tailRing, pShallowCopyDeleteProc p_shallow_copy_delete)
Definition: kInline.h:789
KINLINE poly GetTP()
Definition: kInline.h:746
KINLINE long pLDeg()
Definition: kInline.h:828
KINLINE sLObject & operator=(const sTObject &)
Definition: kInline.h:914
KINLINE void SetShortExpVector()
Definition: kInline.h:800
KINLINE void HeadNormalize()
Definition: kInline.h:378
KINLINE poly GetP(omBin lmBin=(omBin) NULL)
Definition: kInline.h:762
KINLINE sLObject(ring tailRing=currRing)
Definition: kInline.h:612
poly p1
Definition: kutil.h:188
KINLINE long Comp()
Definition: kInline.h:905
KINLINE poly LmExtractAndIter()
Definition: kInline.h:720
int i_r2
Definition: kutil.h:193
Definition: kutil.h:69
KINLINE poly GetLm(ring r)
Definition: kInline.h:273
KINLINE poly GetLmCurrRing()
Definition: kInline.h:253
char is_redundant
Definition: kutil.h:93
poly sig
Definition: kutil.h:72
KINLINE void Init(ring r=currRing)
Definition: kInline.h:110
KINLINE void Mult_nn(number n)
Definition: kInline.h:345
int length
Definition: kutil.h:79
KINLINE long SetDegStuffReturnLDeg()
Definition: kInline.h:457
KINLINE poly GetLmTailRing()
Definition: kInline.h:260
KINLINE void pCleardenom()
Definition: kInline.h:469
int ecart
Definition: kutil.h:78
KINLINE long GetpFDeg() const
Definition: kInline.h:448
KINLINE sTObject(ring tailRing=currRing)
Definition: kInline.h:116
KINLINE void ShallowCopyDelete(ring new_tailRing, omBin new_tailBin, pShallowCopyDeleteProc p_shallow_copy_delete, BOOLEAN set_max=TRUE)
Definition: kInline.h:392
char is_special
Definition: kutil.h:102
KINLINE void SetLmCurrRing()
Definition: kInline.h:310
poly max_exp
Definition: kutil.h:75
char is_normalized
Definition: kutil.h:87
KINLINE long pLDeg()
Definition: kInline.h:453
char is_sigsafe
Definition: kutil.h:98
KINLINE void LmDeleteAndIter()
Definition: kInline.h:324
int pLength
Definition: kutil.h:80
KINLINE long pFDeg() const
Definition: kInline.h:433
int i_r
Definition: kutil.h:81
poly p
Definition: kutil.h:73
KINLINE BOOLEAN IsNull() const
Definition: kInline.h:299
KINLINE void Set(ring r=currRing)
Definition: kInline.h:106
KINLINE void Delete()
Definition: kInline.h:210
poly t_p
Definition: kutil.h:74
ring tailRing
Definition: kutil.h:76
KINLINE int GetpLength()
Definition: kInline.h:304
KINLINE void pNorm()
Definition: kInline.h:571
KINLINE void Clear()
Definition: kInline.h:224
long FDeg
Definition: kutil.h:77
KINLINE poly Next()
Definition: kInline.h:316
void wrp()
Definition: kutil.cc:797
int shift
Definition: kutil.h:84
KINLINE void pContent()
Definition: kInline.h:549
KINLINE long pTotalDeg() const
Definition: kInline.h:438
KINLINE long SetpFDeg()
Definition: kInline.h:443
unsigned long sevSig
Definition: kutil.h:71
KINLINE void Copy()
Definition: kInline.h:235
KINLINE poly kNoetherTail()
Definition: kInline.h:66
unsigned long * sevSyz
Definition: kutil.h:323
kStrategy next
Definition: kutil.h:277
intvec * kModW
Definition: kutil.h:335
bool sigdrop
Definition: kutil.h:359
poly t_kNoether
Definition: kutil.h:330
int syzComp
Definition: kutil.h:354
int * S_2_R
Definition: kutil.h:342
ring tailRing
Definition: kutil.h:343
void(* chainCrit)(poly p, int ecart, kStrategy strat)
Definition: kutil.h:291
ideal D
Definition: kutil.h:304
char noTailReduction
Definition: kutil.h:378
int currIdx
Definition: kutil.h:317
~skStrategy()
Definition: kutil.cc:11603
skStrategy()
Definition: kutil.cc:11583
int nrsyzcrit
Definition: kutil.h:360
intset lenS
Definition: kutil.h:319
int nrrewcrit
Definition: kutil.h:361
char posInLOldFlag
Definition: kutil.h:382
pFDegProc pOrigFDeg_TailRing
Definition: kutil.h:298
int Ll
Definition: kutil.h:351
TSet T
Definition: kutil.h:326
BOOLEAN(* rewCrit1)(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
Definition: kutil.h:293
char news
Definition: kutil.h:400
omBin lmBin
Definition: kutil.h:344
int syzmax
Definition: kutil.h:349
int Bl
Definition: kutil.h:352
intset ecartS
Definition: kutil.h:309
int syzidxmax
Definition: kutil.h:349
char honey
Definition: kutil.h:377
char rightGB
Definition: kutil.h:369
polyset S
Definition: kutil.h:306
int minim
Definition: kutil.h:357
poly kNoether
Definition: kutil.h:329
BOOLEAN * NotUsedAxis
Definition: kutil.h:332
LSet B
Definition: kutil.h:328
BOOLEAN * pairtest
Definition: kutil.h:333
int cp
Definition: kutil.h:347
int ak
Definition: kutil.h:353
TObject ** R
Definition: kutil.h:340
BOOLEAN(* rewCrit3)(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
Definition: kutil.h:295
int lastAxis
Definition: kutil.h:355
ideal M
Definition: kutil.h:305
int tl
Definition: kutil.h:350
int(* red2)(LObject *L, kStrategy strat)
Definition: kutil.h:279
unsigned long * sevT
Definition: kutil.h:325
unsigned long * sevSig
Definition: kutil.h:324
int nr
Definition: kutil.h:346
intvec * kHomW
Definition: kutil.h:336
int max_lower_index
Definition: kutil.h:318
poly tail
Definition: kutil.h:334
char sugarCrit
Definition: kutil.h:377
int(* posInL)(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.h:284
KINLINE TObject * s_2_t(int i)
Definition: kInline.h:47
int blockred
Definition: kutil.h:364
intset syzIdx
Definition: kutil.h:313
ideal Shdl
Definition: kutil.h:303
int syzl
Definition: kutil.h:349
unsigned sbaOrder
Definition: kutil.h:316
pFDegProc pOrigFDeg
Definition: kutil.h:296
int blockredmax
Definition: kutil.h:365
int tmax
Definition: kutil.h:350
int(* posInLOld)(const LSet Ls, const int Ll, LObject *Lo, const kStrategy strat)
Definition: kutil.h:288
polyset sig
Definition: kutil.h:308
polyset syz
Definition: kutil.h:307
char LDegLast
Definition: kutil.h:385
void(* initEcartPair)(LObject *h, poly f, poly g, int ecartF, int ecartG)
Definition: kutil.h:287
BOOLEAN(* syzCrit)(poly sig, unsigned long not_sevSig, kStrategy strat)
Definition: kutil.h:292
wlen_set lenSw
Definition: kutil.h:320
char kAllAxis
Definition: kutil.h:376
int cv
Definition: kutil.h:368
char noetherSet
Definition: kutil.h:380
pShallowCopyDeleteProc p_shallow_copy_delete
Definition: kutil.h:338
char Gebauer
Definition: kutil.h:378
intset fromQ
Definition: kutil.h:321
void(* enterS)(LObject &h, int pos, kStrategy strat, int atR)
Definition: kutil.h:286
char newt
Definition: kutil.h:401
char use_buckets
Definition: kutil.h:383
int mu
Definition: kutil.h:348
char interpt
Definition: kutil.h:371
char redTailChange
Definition: kutil.h:399
int newIdeal
Definition: kutil.h:356
char fromT
Definition: kutil.h:379
char completeReduce_retry
Definition: kutil.h:403
void(* initEcart)(TObject *L)
Definition: kutil.h:280
omBin tailBin
Definition: kutil.h:345
LObject P
Definition: kutil.h:302
KINLINE TObject * S_2_T(int i)
Definition: kInline.h:38
char noClearS
Definition: kutil.h:402
int Lmax
Definition: kutil.h:351
char z2homog
Definition: kutil.h:374
int LazyPass
Definition: kutil.h:353
char no_prod_crit
Definition: kutil.h:394
char overflow
Definition: kutil.h:404
void(* enterOnePair)(int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR)
Definition: kutil.h:290
LSet L
Definition: kutil.h:327
char length_pLength
Definition: kutil.h:387
int(* posInT)(const TSet T, const int tl, LObject &h)
Definition: kutil.h:281
int(* red)(LObject *L, kStrategy strat)
Definition: kutil.h:278
BOOLEAN(* rewCrit2)(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
Definition: kutil.h:294
int sl
Definition: kutil.h:348
int sbaEnterS
Definition: kutil.h:362
int LazyDegree
Definition: kutil.h:353
char posInLDependsOnLength
Definition: kutil.h:389
unsigned long * sevS
Definition: kutil.h:322
char homog
Definition: kutil.h:372
pLDegProc pOrigLDeg
Definition: kutil.h:297
intset fromS
Definition: kutil.h:310
char update
Definition: kutil.h:381
s_poly_proc_t s_poly
Definition: kutil.h:300
int(* posInLSba)(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.h:282
pLDegProc pOrigLDeg_TailRing
Definition: kutil.h:299
int Bmax
Definition: kutil.h:352
int c3
Definition: kutil.h:347
const CanonicalForm & w
Definition: facAbsFact.cc:51
CFArray copy(const CFList &list)
write elements of list into an array
int j
Definition: facHensel.cc:110
#define EXTERN_VAR
Definition: globaldefs.h:6
static BOOLEAN length(leftv result, leftv arg)
Definition: interval.cc:257
STATIC_VAR jList * T
Definition: janet.cc:30
STATIC_VAR Poly * h
Definition: janet.cc:971
STATIC_VAR jList * Q
Definition: janet.cc:30
BOOLEAN(* s_poly_proc_t)(kStrategy strat)
Definition: kstd1.h:14
int posInLF5C(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.cc:5998
int posInLRing(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.cc:5897
KINLINE void ksOldSpolyTail(poly p1, poly q, poly q2, poly spNoether, ring r=currRing)
Definition: kInline.h:1214
void initSbaPos(kStrategy strat)
Definition: kutil.cc:10130
void message(int i, int *reduc, int *olddeg, kStrategy strat, int red_result)
Definition: kutil.cc:7730
BOOLEAN findMinLMPair(poly sig, unsigned long not_sevSig, kStrategy strat, int start)
int ksReducePolyGCD(LObject *PR, TObject *PW, poly spNoether=NULL, number *coef=NULL, kStrategy strat=NULL)
Definition: kspoly.cc:325
int ksReducePolyLC(LObject *PR, TObject *PW, poly spNoether=NULL, number *coef=NULL, kStrategy strat=NULL)
Definition: kspoly.cc:458
void initenterpairs(poly h, int k, int ecart, int isFromQ, kStrategy strat, int atR=-1)
Definition: kutil.cc:3864
int posInSyz(const kStrategy strat, const poly sig)
Definition: kutil.cc:5970
int redLiftstd(LObject *h, kStrategy strat)
Definition: kLiftstd.cc:167
int ksReducePolyBound(LObject *PR, TObject *PW, int bound, poly spNoether=NULL, number *coef=NULL, kStrategy strat=NULL)
Definition: kspoly.cc:572
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:290
int redRing_Z(LObject *h, kStrategy strat)
Definition: kstd2.cc:669
int posInT17(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5418
int posInL13(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.cc:6396
void initBuchMora(ideal F, ideal Q, kStrategy strat)
Definition: kutil.cc:10019
void initEcartPairBba(LObject *Lp, poly f, poly g, int ecartF, int ecartG)
Definition: kutil.cc:1366
poly pMove2CurrTail(poly p, kStrategy strat)
Definition: kutil.cc:11917
denominator_list_s * denominator_list
Definition: kutil.h:63
wlen_type * wlen_set
Definition: kutil.h:55
poly kFindZeroPoly(poly input_p, ring leadRing, ring tailRing)
Definition: kstd2.cc:555
int redFirstShift(LObject *h, kStrategy strat)
Definition: kstd2.cc:4724
BOOLEAN arriRewCriterionPre(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
Definition: kutil.cc:6900
void enterSyz(LObject &p, kStrategy strat, int atT)
Definition: kutil.cc:9598
int posInL15(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.cc:6431
int redNF0(LObject *P, kStrategy strat)
int posInT11(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5014
int posInLSigRing(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.cc:5834
int ksReducePolySigRing(LObject *PR, TObject *PW, long idx, poly spNoether=NULL, number *coef=NULL, kStrategy strat=NULL)
Definition: kspoly.cc:925
int posInTSig(const TSet set, const int length, LObject &p)
int posInT1(const TSet set, const int length, LObject &p)
Definition: kutil.cc:4958
EXTERN_VAR int(* test_PosInT)(const TSet T, const int tl, LObject &h)
Definition: kutil.h:869
int ksReducePolySig(LObject *PR, TObject *PW, long idx, poly spNoether=NULL, number *coef=NULL, kStrategy strat=NULL)
Definition: kspoly.cc:719
void enterT_strong(LObject &p, kStrategy strat, int atT=-1)
Definition: kutil.cc:9496
BOOLEAN kTest(kStrategy strat)
Definition: kutil.cc:1036
void chainCritSig(poly p, int ecart, kStrategy strat)
Definition: kutil.cc:3516
int posInT_EcartpLength(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5285
poly pMoveCurrTail2poly(poly p, kStrategy strat)
Definition: kutil.cc:11931
BOOLEAN kTest_TS(kStrategy strat)
Definition: kutil.cc:1097
KINLINE unsigned long * initsevT()
Definition: kInline.h:100
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:400
int kFindInT(poly p, TSet T, int tlength)
returns index of p in TSet, or -1 if not found
Definition: kutil.cc:742
BOOLEAN kCheckStrongCreation(int atR, poly m1, int atS, poly m2, kStrategy strat)
Definition: kutil.cc:10792
int kTestDivisibleByT0_Z(const kStrategy strat, const LObject *L)
tests if T[0] divides the leading monomial of L, returns -1 if not
Definition: kstd2.cc:142
BOOLEAN kTest_L(LObject *L, kStrategy strat, BOOLEAN testp=FALSE, int lpos=-1, TSet T=NULL, int tlength=-1)
Definition: kutil.cc:950
TObject * TSet
Definition: kutil.h:59
void enterL(LSet *set, int *length, int *LSetmax, LObject p, int at)
Definition: kutil.cc:1327
int posInL17(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.cc:6507
#define setmaxL
Definition: kutil.h:30
void enterT(LObject &p, kStrategy strat, int atT=-1)
Definition: kutil.cc:9396
int kFindSameLMInT_Z(const kStrategy strat, const LObject *L, const int start=0)
Definition: kstd2.cc:86
void enterTShift(LObject p, kStrategy strat, int atT=-1)
Definition: kutil.cc:13365
int posInT2(const TSet set, const int length, LObject &p)
Definition: kutil.cc:4986
int posInL15Ring(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.cc:6466
void superenterpairsSig(poly h, poly hSig, int hFrom, int k, int ecart, int pos, kStrategy strat, int atR=-1)
Definition: kutil.cc:4531
int posInT_pLength(const TSet set, const int length, LObject &p)
Definition: kutil.cc:11745
void completeReduce(kStrategy strat, BOOLEAN withT=FALSE)
Definition: kutil.cc:10559
void enterOnePairNormal(int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR)
Definition: kutil.cc:1999
int posInT13(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5256
void redtailBbaAlsoLC_Z(LObject *L, int end_pos, kStrategy strat)
Definition: kutil.cc:7398
poly kNF2(ideal F, ideal Q, poly q, kStrategy strat, int lazyReduce)
Definition: kstd2.cc:3704
BOOLEAN syzCriterionInc(poly sig, unsigned long not_sevSig, kStrategy strat)
Definition: kutil.cc:6767
void deleteHC(poly *p, int *e, int *l, kStrategy strat)
Definition: kutil.cc:359
poly pCopyL2p(LObject h, kStrategy strat)
Definition: kutil.cc:11948
int posInSMonFirst(const kStrategy strat, const int length, const poly p)
Definition: kutil.cc:4826
KINLINE BOOLEAN arriRewDummy(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
Definition: kInline.h:1272
ideal sba(ideal F, ideal Q, intvec *w, intvec *hilb, kStrategy strat)
Definition: kstd2.cc:2738
EXTERN_VAR denominator_list DENOMINATOR_LIST
Definition: kutil.h:66
void initBuchMoraPos(kStrategy strat)
Definition: kutil.cc:9846
void initS(ideal F, ideal Q, kStrategy strat)
Definition: kutil.cc:7853
int posInIdealMonFirst(const ideal F, const poly p, int start=0, int end=-1)
Definition: kutil.cc:4903
KINLINE poly redtailBbaBound(poly p, int end_pos, kStrategy strat, int bound, BOOLEAN normalize=FALSE)
Definition: kInline.h:1228
int redHoney(LObject *h, kStrategy strat)
Definition: kstd2.cc:1897
EXTERN_VAR int strat_nr
Definition: kutil.h:181
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:10815
KINLINE poly k_LmShallowCopyDelete_currRing_2_tailRing(poly p, ring tailRing, omBin bin)
Definition: kInline.h:987
BOOLEAN kStratChangeTailRing(kStrategy strat, LObject *L=NULL, TObject *T=NULL, unsigned long new_expbound=0)
Definition: kutil.cc:11240
int64 wlen_type
Definition: kutil.h:54
int posInLSig(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.cc:5810
KINLINE poly k_LmInit_tailRing_2_currRing(poly p, ring tailRing, omBin bin)
Definition: kInline.h:978
int posInL11(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.cc:6010
TObject * kFindDivisibleByInS_T(kStrategy strat, int end_pos, LObject *L, TObject *T, long ecart=LONG_MAX)
Definition: kutil.cc:6951
void chainCritOpt_1(poly, int, kStrategy strat)
Definition: kutil.cc:3500
int kFindNextDivisibleByInS(const kStrategy strat, int start, int max_ind, LObject *L)
Definition: kstd2.cc:469
static LSet initL(int nr=setmaxL)
Definition: kutil.h:421
KINLINE TSet initT()
Definition: kInline.h:84
void cancelunit(LObject *p, BOOLEAN inNF=FALSE)
Definition: kutil.cc:373
EXTERN_VAR int(* test_PosInL)(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.h:870
int posInL11Ringls(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.cc:6122
KINLINE poly k_LmShallowCopyDelete_tailRing_2_currRing(poly p, ring tailRing, omBin bin)
Definition: kInline.h:994
KINLINE poly redtailBba_Ring(poly p, int end_pos, kStrategy strat)
Definition: kInline.h:1235
int kFindDivisibleByInT_Z(const kStrategy strat, const LObject *L, const int start=0)
Definition: kstd2.cc:209
LObject * LSet
Definition: kutil.h:60
int redHomog(LObject *h, kStrategy strat)
Definition: kstd2.cc:934
int posInT17_c(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5525
poly redtailBbaShift(LObject *L, int pos, kStrategy strat, BOOLEAN withT, BOOLEAN normalize)
Definition: kutil.cc:13388
denominator_list next
Definition: kutil.h:65
int posInT_EcartFDegpLength(const TSet set, const int length, LObject &p)
Definition: kutil.cc:11654
int posInT15(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5323
void kFreeStrat(kStrategy strat)
void pairs()
void postReduceByMon(LObject *h, kStrategy strat)
used for GB over ZZ: intermediate reduction by monomial elements background: any known constant eleme...
Definition: kutil.cc:10982
BOOLEAN syzCriterion(poly sig, unsigned long not_sevSig, kStrategy strat)
Definition: kutil.cc:6732
EXTERN_VAR int HCord
Definition: kutil.h:269
void HEckeTest(poly pp, kStrategy strat)
Definition: kutil.cc:505
ideal bba(ideal F, ideal Q, intvec *w, intvec *hilb, kStrategy strat)
Definition: kstd2.cc:2379
int redLazy(LObject *h, kStrategy strat)
Definition: kstd2.cc:1692
void enterExtendedSpolySig(poly h, poly hSig, kStrategy strat)
Definition: kutil.cc:4374
void enterpairsSig(poly h, poly hSig, int from, int k, int ec, int pos, kStrategy strat, int atR=-1)
Definition: kutil.cc:4575
void enterpairsShift(poly h, int k, int ecart, int pos, kStrategy strat, int atR)
Definition: kutil.cc:13335
KINLINE poly k_LmInit_currRing_2_tailRing(poly p, ring tailRing, omBin bin)
Definition: kInline.h:969
void initBba(kStrategy strat)
Definition: kstd1.cc:1676
void enterOnePairShift(poly q, poly p, int ecart, int isFromQ, kStrategy strat, int atR, int ecartq, int qisFromQ, int shiftcount, int ifromS)
Definition: kutil.cc:12561
void exitBuchMora(kStrategy strat)
Definition: kutil.cc:10104
void messageStatSBA(int hilbcount, kStrategy strat)
Definition: kutil.cc:7784
int redRiloc(LObject *h, kStrategy strat)
Definition: kstd1.cc:387
void initEcartNormal(TObject *h)
Definition: kutil.cc:1351
static void kDeleteLcm(LObject *P)
Definition: kutil.h:873
int posInS(const kStrategy strat, const int length, const poly p, const int ecart_p)
Definition: kutil.cc:4725
void updateS(BOOLEAN toT, kStrategy strat)
Definition: kutil.cc:8812
int posInL0(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.cc:5752
int redSigRing(LObject *h, kStrategy strat)
Definition: kstd2.cc:1322
int * intset
Definition: kutil.h:53
void initSLSba(ideal F, ideal Q, kStrategy strat)
Definition: kutil.cc:8044
void enterSBbaShift(LObject &p, int atS, kStrategy strat, int atR=-1)
Definition: kutil.cc:9147
void initSba(ideal F, kStrategy strat)
Definition: kstd1.cc:1734
int ksReducePolyTail(LObject *PR, TObject *PW, poly Current, poly spNoether=NULL)
Definition: kspoly.cc:1334
void initSyzRules(kStrategy strat)
Definition: kutil.cc:8194
void initSbaBuchMora(ideal F, ideal Q, kStrategy strat)
Definition: kutil.cc:10232
BOOLEAN kCheckSpolyCreation(LObject *L, kStrategy strat, poly &m1, poly &m2)
Definition: kutil.cc:10753
void cleanT(kStrategy strat)
Definition: kutil.cc:569
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:1071
int posInT110(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5167
BOOLEAN kTest_S(kStrategy strat)
Definition: kutil.cc:1079
void replaceInLAndSAndT(LObject &p, int tj, kStrategy strat)
Definition: kutil.cc:9305
poly redNF(poly h, int &max_ind, int nonorm, kStrategy strat)
Definition: kstd2.cc:2131
void reorderS(int *suc, kStrategy strat)
Definition: kutil.cc:4672
KINLINE poly ksOldSpolyRed(poly p1, poly p2, poly spNoether=NULL)
Definition: kInline.h:1184
void enterExtendedSpoly(poly h, kStrategy strat)
Definition: kutil.cc:4291
void enterpairs(poly h, int k, int ec, int pos, kStrategy strat, int atR=-1)
Definition: kutil.cc:4549
void superenterpairs(poly h, int k, int ecart, int pos, kStrategy strat, int atR=-1)
Definition: kutil.cc:4518
int redSig(LObject *h, kStrategy strat)
Definition: kstd2.cc:1154
KINLINE poly redtailBba_Z(poly p, int end_pos, kStrategy strat)
Definition: kInline.h:1240
KINLINE poly ksOldSpolyRedNew(poly p1, poly p2, poly spNoether=NULL)
Definition: kInline.h:1194
int posInL10(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kstd1.cc:1352
KINLINE poly redtailBba(poly p, int end_pos, kStrategy strat, BOOLEAN normalize=FALSE)
Definition: kInline.h:1222
void updateResult(ideal r, ideal Q, kStrategy strat)
Definition: kutil.cc:10347
int posInT0(const TSet set, const int length, LObject &p)
Definition: kutil.cc:4947
#define KINLINE
Definition: kutil.h:49
int posInT19(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5652
void exitSba(kStrategy strat)
Definition: kutil.cc:10307
ring sbaRing(kStrategy strat, const ring r=currRing, BOOLEAN complete=TRUE, int sgn=1)
Definition: kutil.cc:11361
void enterSSba(LObject &p, int atS, kStrategy strat, int atR=-1)
Definition: kutil.cc:9170
void kDebugPrint(kStrategy strat)
Output some debug info about a given strategy.
Definition: kutil.cc:11779
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:4035
void deleteInL(LSet set, int *length, int j, kStrategy strat)
Definition: kutil.cc:1270
void initHilbCrit(ideal F, ideal Q, intvec **hilb, kStrategy strat)
Definition: kutil.cc:9676
KINLINE poly ksOldCreateSpoly(poly p1, poly p2, poly spNoether=NULL, ring r=currRing)
Definition: kInline.h:1204
void kStratInitChangeTailRing(kStrategy strat)
Definition: kutil.cc:11333
BOOLEAN arriRewCriterion(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
Definition: kutil.cc:6875
void initBuchMoraCrit(kStrategy strat)
Definition: kutil.cc:9694
void deleteInSSba(int i, kStrategy strat)
Definition: kutil.cc:1215
void initBuchMoraPosRing(kStrategy strat)
Definition: kutil.cc:9932
poly kNF2Bound(ideal F, ideal Q, poly q, int bound, kStrategy strat, int lazyReduce)
Definition: kstd2.cc:3786
int kFindInTShift(poly p, TSet T, int tlength)
Definition: kutil.cc:767
int ksReducePoly(LObject *PR, TObject *PW, poly spNoether=NULL, number *coef=NULL, poly *mon=NULL, kStrategy strat=NULL)
Definition: kspoly.cc:187
void postReduceByMonSig(LObject *h, kStrategy strat)
Definition: kutil.cc:11058
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:1185
int posInL11Ring(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.cc:6052
void enterSBba(LObject &p, int atS, kStrategy strat, int atR=-1)
Definition: kutil.cc:9047
void messageSets(kStrategy strat)
Definition: kutil.cc:7803
int redRing(LObject *h, kStrategy strat)
Definition: kstd2.cc:827
void deleteInS(int i, kStrategy strat)
Definition: kutil.cc:1163
int posInT_FDegpLength(const TSet set, const int length, LObject &p)
Definition: kutil.cc:11708
BOOLEAN sbaCheckGcdPair(LObject *h, kStrategy strat)
Definition: kutil.cc:1747
int posInL110(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.cc:6308
poly redtail(poly p, int end_pos, kStrategy strat)
Definition: kutil.cc:7163
int posInL10Ring(const LSet set, const int length, LObject *L, const kStrategy strat)
void initEcartPairMora(LObject *Lp, poly f, poly g, int ecartF, int ecartG)
Definition: kutil.cc:1373
void superenterpairsShift(poly h, int k, int ecart, int pos, kStrategy strat, int atR)
void entersets(LObject h)
void chainCritNormal(poly p, int ecart, kStrategy strat)
Definition: kutil.cc:3264
void initEcartBBA(TObject *h)
Definition: kutil.cc:1359
class sTObject TObject
Definition: kutil.h:57
KINLINE void clearS(poly p, unsigned long p_sev, int *at, int *k, kStrategy strat)
Definition: kInline.h:1247
ideal bbaShift(ideal F, ideal Q, intvec *w, intvec *hilb, kStrategy strat)
Definition: kstd2.cc:4347
int posInLF5CRing(const LSet set, int start, const int length, LObject *L, const kStrategy strat)
Definition: kutil.cc:6086
int ksReducePolyZ(LObject *PR, TObject *PW, poly spNoether=NULL, number *coef=NULL, kStrategy strat=NULL)
Definition: kspoly.cc:44
KINLINE TObject ** initR()
Definition: kInline.h:95
poly redNFTail(poly h, const int sl, kStrategy strat)
poly ksCreateShortSpoly(poly p1, poly p2, ring tailRing)
Definition: kspoly.cc:1430
void messageStat(int hilbcount, kStrategy strat)
Definition: kutil.cc:7771
void initSL(ideal F, ideal Q, kStrategy strat)
Definition: kutil.cc:7947
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:1028
void finalReduceByMon(kStrategy strat)
used for GB over ZZ: final reduction by constant elements background: any known constant element of i...
Definition: kutil.cc:11147
BOOLEAN kTest_T(TObject *T, kStrategy strat, int tpos=-1, char TN='?')
Definition: kutil.cc:825
void initSbaCrit(kStrategy strat)
Definition: kutil.cc:9759
BOOLEAN newHEdge(kStrategy strat)
Definition: kutil.cc:10681
BOOLEAN homogTest(polyset F, int Fmax)
class sLObject LObject
Definition: kutil.h:58
poly redtailSba(LObject *L, int end_pos, kStrategy strat, BOOLEAN withT=FALSE, BOOLEAN normalize=FALSE)
Definition: kstd2.cc:1572
BOOLEAN faugereRewCriterion(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
Definition: kutil.cc:6816
int lcm(unsigned long *l, unsigned long *a, unsigned long *b, unsigned long p, int dega, int degb)
Definition: minpoly.cc:709
Definition: lq.h:40
#define omAlloc(size)
Definition: omAllocDecl.h:210
#define NULL
Definition: omList.c:12
omBin_t * omBin
Definition: omStructs.h:12
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
Compatiblity layer for legacy polynomial operations (over currRing)
#define pLmDelete(p)
assume p != NULL, deletes Lm(p)->coef and Lm(p)
Definition: polys.h:76
static void pLmFree(poly p)
frees the space of the monomial m, assumes m != NULL coef is not freed, m is not advanced
Definition: polys.h:70
poly * polyset
Definition: polys.h:259
long(* pFDegProc)(poly p, ring r)
Definition: ring.h:38
long(* pLDegProc)(poly p, int *length, ring r)
Definition: ring.h:37
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:44
#define rField_is_Ring(R)
Definition: ring.h:486
#define R
Definition: sirandom.c:27
static poly normalize(poly next_p, ideal add_generators, syStrategy syzstr, int *g_l, int *p_l, int crit_comp)
Definition: syz3.cc:1026