12 #define MORA_USE_BUCKETS 152 h->length=h->pLength=
pLength(h->p);
156 if (ret < 0)
return ret;
158 h->ShallowCopyDelete(strat->
tailRing,
186 d = h->GetpFDeg()+ h->ecart;
188 h->SetShortExpVector();
198 ei = strat->
T[
j].ecart;
201 if (ei > h->ecart && ii < strat->tl)
203 li = strat->
T[
j].length;
213 if (i > strat->
tl)
break;
214 if ((strat->
T[i].ecart < ei || (strat->
T[i].ecart == ei &&
215 strat->
T[i].length < li))
222 if (strat->
T[i].ecart < ei || (strat->
T[i].ecart == ei &&
223 strat->
T[i].length < li))
228 ei = strat->
T[
i].ecart;
229 if (ei <= h->ecart)
break;
230 li = strat->
T[
i].length;
247 assume(h->FDeg == h->pFDeg());
248 at = strat->
posInL(strat->
L,strat->
Ll,h,strat);
277 h->SetShortExpVector();
282 h->ecart = d-h->GetpFDeg();
284 h->ecart = d-h->GetpFDeg()+ei-h->ecart;
288 h->ecart = h->pLDeg(strat->
LDegLast) - h->GetpFDeg();
295 if (strat->
honey) h->SetLength();
305 d = h->GetpFDeg()+h->ecart;
312 && ((d >= reddeg) || (pass > strat->
LazyPass)))
317 assume(h->FDeg == h->pFDeg());
318 at = strat->
posInL(strat->
L,strat->
Ll,h,strat);
340 if (h->pTotalDeg()+h->ecart >= (int)strat->
tailRing->bitmask)
345 at = strat->
posInL(strat->
L,strat->
Ll,h,strat);
365 PrintS(
"\n---------------------------- NEW REDRILOC COMPUTATION ----------------------------\n");
366 PrintS(
" The pair h :\n");
370 PrintS(
"\n The actual reducer T is: ");
375 for (iii=0;iii<=strat->
tl;iii++)
382 d = h->GetpFDeg()+ h->ecart;
384 h->SetShortExpVector();
386 Print(
"\n Searching for a poly in T that divides h (of ecart %i) ...\n",h->ecart);
394 ei = strat->
T[
j].ecart;
395 Print(
"\n Found one: T[%i] of ecart %i: ",j,ei);
397 PrintS(
"\n Try to find another with smaller ecart:\n");
401 PrintS(
"\n No poly in T divides h.\n");
420 if (h->GetLmTailRing() ==
NULL)
429 ei = strat->
T[
j].ecart;
434 if (ei > h->ecart && ii < strat->tl)
436 li = strat->
T[
j].length;
446 if (i > strat->
tl)
break;
447 if ((strat->
T[i].ecart < ei || (strat->
T[i].ecart == ei &&
448 strat->
T[i].length < li))
457 if (strat->
T[i].ecart < ei || (strat->
T[i].ecart == ei &&
458 strat->
T[i].length < li))
463 printf(
"\n Intermidiate one, h.ecart = %i < ecart = %i < ei = %i: ",h->ecart,strat->
T[i].ecart, ei);
467 ei = strat->
T[
i].ecart;
468 if (ei <= h->ecart)
break;
469 li = strat->
T[
i].length;
476 PrintS(
"\n None was found.\n");
480 Print(
"\n A better one (ecart = %i): T[%i] = ",ei,ii);
491 printf(
"\nHAD TO REDUCE WITH BIGGER ECART!!!\n");
502 assume(h->FDeg == h->pFDeg());
503 at = strat->
posInL(strat->
L,strat->
Ll,h,strat);
509 if (at <= strat->Ll &&
pLmCmp(h->p, strat->
L[strat->
Ll].p) != 0 && !
nEqual(h->p->coef, strat->
L[strat->
Ll].p->coef))
533 printf(
"\nReduced to 0. Exit\n");
541 h->SetShortExpVector();
546 h->ecart = d-h->GetpFDeg();
548 h->ecart = d-h->GetpFDeg()+ei-h->ecart;
552 h->ecart = h->pLDeg(strat->
LDegLast) - h->GetpFDeg();
554 printf(
"\n Partial Reduced (ecart %i) h = ",h->ecart);
p_Write(h->p,strat->
tailRing);
559 d = h->GetpFDeg()+h->ecart;
566 && ((d >= reddeg) || (pass > strat->
LazyPass)))
571 assume(h->FDeg == h->pFDeg());
572 at = strat->
posInL(strat->
L,strat->
Ll,h,strat);
594 if (h->pTotalDeg()+h->ecart >= (int)strat->
tailRing->bitmask)
599 at = strat->
posInL(strat->
L,strat->
Ll,h,strat);
615 if (h->IsNull())
return 0;
624 d = h->GetpFDeg() + h->ecart;
627 h->SetShortExpVector();
633 h->SetDegStuffReturnLDeg(strat->
LDegLast);
664 h->SetShortExpVector();
677 h->SetDegStuffReturnLDeg(strat->
LDegLast);
687 if (strat->
T[j].ecart <= h->ecart)
688 h->ecart = d - h->GetpFDeg();
690 h->ecart = d - h->GetpFDeg() + strat->
T[
j].ecart - h->ecart;
692 d = h->GetpFDeg() + h->ecart;
695 d = h->SetDegStuffReturnLDeg(strat->
LDegLast);
704 && ((d >= reddeg) || (pass > strat->
LazyPass)))
709 at = strat->
posInL(strat->
L,strat->
Ll,h,strat);
727 if (h->pTotalDeg()+h->ecart >= (int)strat->
tailRing->bitmask)
732 at = strat->
posInL(strat->
L,strat->
Ll,h,strat);
753 int o = H.SetpFDeg();
757 unsigned long not_sev = ~
H.sev;
761 for(
int ii=0;ii<=strat->
tl;ii++)
763 printf(
"\nT[%i]:\nt^%i ",ii,strat->
T[ii].ecart);
778 printf(
"\nSearching for a reducer...\n");
789 int ei = strat->
T[
j].ecart;
790 int li = strat->
T[
j].length;
793 printf(
"\nFound: j = %i, ecart = %i\nTrying to find a better one...\n",j,ei);
pWrite(strat->
T[j].p);
804 if (j > strat->
tl)
break;
805 if (ei <= H.ecart)
break;
806 if (((strat->
T[j].ecart < ei)
807 || ((strat->
T[j].ecart == ei)
808 && (strat->
T[j].length < li)))
820 ei = strat->
T[
j].ecart;
821 li = strat->
T[
j].length;
824 printf(
"\nFound a better one: j = %i, ecart = %i\nTrying to find a better one...\n",j,ei);
845 printf(
"\nHAVE TO REDUCE IT WITH BIGGER ECART\n");
854 for(
int ii=0; ii<=strat->
tl;ii++)
858 printf(
"\nFound one:\n");
pWrite(strat->
T[ii].p);
859 if(dummy==0 && strat->
T[ii].ecart < strat->
T[z].ecart)
863 if(dummy == 1 && strat->
T[ii].length < strat->
T[z].length)
869 printf(
"\n!!!!!!!!!!!!!!!!! z = %i\n",z);
886 printf(
"\nAfter the small reduction it looks like this:\n");
pWrite(H.p);
912 for (i=1; i<=strat->
Ll; i++)
914 at = strat->
posInL(strat->
L,i-1,&(strat->
L[i]),strat);
918 for (j=i-1; j>=at; j--) strat->
L[j+1] = strat->
L[j];
934 for (i=1; i<=strat->
tl; i++)
936 if (strat->
T[i-1].length > strat->
T[i].length)
939 sev = strat->
sevT[
i];
945 if (strat->
T[i].length > strat->
T[at].length)
break;
947 for (j = i-1; j>at; j--)
949 strat->
T[j+1]=strat->
T[
j];
951 strat->
R[strat->
T[j+1].i_r] = &(strat->
T[j+1]);
954 strat->
sevT[at+1] = sev;
955 strat->
R[p.i_r] = &(strat->
T[at+1]);
1019 if (i==last)
return TRUE;
1029 if (L->bucket !=
NULL)
1031 poly p = L->CanonicalizeP();
1050 if (length<0)
return 0;
1053 int op= p->GetpFDeg() +p->ecart;
1054 for (j=length; j>=0; j--)
1061 && (
set[j].GetpFDeg()+
set[j].ecart >= op))
1089 p=strat->
L[strat->
Ll];
1090 strat->
L[strat->
Ll]=strat->
L[
j];
1126 strat->
L[
j].SetLmCurrRing();
1138 p=strat->
L[strat->
Ll];
1139 strat->
L[strat->
Ll]=strat->
L[
j];
1158 while (i <= strat->Ll)
1195 if (! strat->
L[i].IsNull())
1197 strat->
L[
i].SetLmCurrRing();
1198 strat->
L[
i].SetpFDeg();
1200 = strat->
L[
i].pLDeg(strat->
LDegLast) - strat->
L[
i].GetpFDeg();
1207 if (strat->
L[i].IsNull())
1229 while (i <= strat->tl)
1237 if (p.p != strat->
T[i].p)
1265 for (i=strat->
Ll; i>=0; i--)
1267 strat->
L[
i].SetpFDeg();
1269 for (i=strat->
tl; i>=0; i--)
1271 strat->
T[
i].SetpFDeg();
1327 Print(
"new s%d:",atS);
1399 #ifdef HAVE_RINGS //TODO Oliver 1456 #if defined(HAVE_RINGS) 1534 strat->
HCord = 32000;
1579 int hilbeledeg=1,hilbcount=0;
1620 #ifdef HAVE_TAIL_RING 1631 while (strat->
Ll >= 0)
1634 printf(
"\n ------------------------NEW LOOP\n");
1635 printf(
"\nShdl = \n");
1636 for(
int iii = 0; iii<= strat->
sl; iii++)
1638 printf(
"S[%i]:",iii);
1641 printf(
"\n list L has %i\n", strat->
Ll);
1644 for(iii = 0; iii<= strat->
Ll; iii++)
1646 printf(
"L[%i]:",iii);
1665 && (strat->
L[strat->
Ll].ecart+strat->
L[strat->
Ll].GetpFDeg()>
Kstd1_deg))
1672 while ((strat->
Ll >= 0)
1673 && (strat->
L[strat->
Ll].p1!=
NULL) && (strat->
L[strat->
Ll].p2!=
NULL)
1674 && (strat->
L[strat->
Ll].ecart+strat->
L[strat->
Ll].GetpFDeg()>
Kstd1_deg)
1683 if (strat->
Ll<0)
break;
1686 strat->
P = strat->
L[strat->
Ll];
1716 else if (strat->
P.p1 ==
NULL)
1724 if (!strat->
P.IsNull())
1728 message(strat->
P.ecart+strat->
P.GetpFDeg(),&olddeg,&reduc,
strat, red_result);
1731 printf(
"\nThis is P vor red:\n");
p_Write(strat->P.p,strat->tailRing);
p_Write(strat->P.p1,strat->tailRing);
p_Write(strat->P.p2,strat->tailRing);
1732 printf(
"\nBefore Ll = %i\n", strat->Ll);
1738 red_result = strat->red(&strat->P,strat);
1743 red_result = strat->red(&strat->P,strat);
1745 printf(
"\nThis is P nach red:\n");
p_Write(strat->P.p,strat->tailRing);
p_Write(strat->P.p1,strat->tailRing);
p_Write(strat->P.p2,strat->tailRing);
1746 printf(
"\nAfter Ll = %i\n", strat->Ll);
1751 if (! strat->
P.IsNull())
1758 strat->
P.pCleardenom();
1762 strat->
P.p =
redtail(&(strat->
P),strat->
sl,strat);
1763 if (strat->
P.p==
NULL)
1765 WerrorS(
"expoent overflow - wrong ordering");
1774 if ((strat->
P.p->next==
NULL)
1776 strat->
P.pCleardenom();
1806 Print(
"\n The new pair list L -- after superenterpairs in loop %d -- is:\n",loop_count);
1807 for(
int iii=0;iii<=strat->
Ll;iii++)
1809 printf(
"\n L[%d]:\n",iii);
1817 posInS(strat,strat->
sl,strat->
P.p, strat->
P.ecart),
1820 printf(
"\nThis pair has been added to S:\n");
1830 khCheck(Q,w,hilb,hilbeledeg,hilbcount,strat);
1836 if (strat->
P.lcm!=
NULL)
1838 #if defined(HAVE_RINGS) 1847 memset(&strat->
P,0,
sizeof(strat->
P));
1870 Print(
"\n The new reducer list T -- at the end of loop %d -- is\n",loop_count);
1871 for(
int iii=0;iii<=strat->
tl;iii++)
1873 printf(
"\n T[%d]:",iii);
1916 return (strat->
Shdl);
1988 for (i=strat->
sl; i>=0; i--)
1992 for (i=0; i<=strat->
sl; i++)
1999 h.sev = strat->
sevS[
i];
2013 if ((p!=
NULL)&&((lazyReduce & KSTD_NF_LAZY)==0))
2122 for (i=strat->
sl; i>=0; i--)
2136 for (j=0; j<=strat->
sl; j++)
2140 h.pLength = h.length =
pLength(h.p);
2143 h.sev = strat->
sevS[
j];
2154 if ((p!=
NULL)&&((lazyReduce & KSTD_NF_LAZY)==0))
2208 if (i<=kModW->length())
2209 return o+(*kModW)[i-1];
2217 for (i=r->N;i>0;i--)
2219 if (kModW ==
NULL)
return j;
2222 return j+(*kModW)[i-1];
2229 return idInit(1,F->rank);
2256 strat->
kHomW=kHomW=vw;
2277 if (strat->
ak > 0 && (w!=
NULL) && (*w!=
NULL))
2279 strat->
kModW = kModW = *
w;
2299 PrintS(
"// kSTD: currRing: ");
2331 printf(
"\nPreintegerCheck found this constant:\n");
pWrite(pFmon);
2350 if (strat->
ak > 0 && (w!=
NULL) && (*w!=
NULL))
2352 strat->
kModW = kModW = *
w;
2369 r=
bba(FCopy,Q,
NULL,hilb,strat);
2394 r=
mora(F,Q,*w,hilb,strat);
2401 r=
bba(F,Q,*w,hilb,strat);
2418 if ((delete_w)&&(w!=
NULL)&&(*w!=
NULL))
delete *w;
2423 int newIdeal,
intvec *vw)
2426 return idInit(1,F->rank);
2467 strat->
kHomW=kHomW=vw;
2488 if (strat->
ak > 0 && (w!=
NULL) && (*w!=
NULL))
2490 strat->
kModW = kModW = *
w;
2510 PrintS(
"// kSTD: currRing: ");
2537 r=
mora(F,Q,*w,hilb,strat);
2544 r=
sba(F,Q,*w,hilb,strat);
2561 if ((delete_w)&&(w!=
NULL)&&(*w!=
NULL))
delete *w;
2565 #ifdef HAVE_SHIFTBBA 2567 int newIdeal,
intvec *vw,
int uptodeg,
int lV)
2592 strat->
kHomW=kHomW=vw;
2613 if (strat->
ak > 0 && (w!=
NULL) && (*w!=
NULL))
2615 strat->
kModW = kModW = *
w;
2634 Print(
"No local ordering possible for shifts");
2641 r=
bbaShift(F,Q,*w,hilb,strat,uptodeg,lV);
2657 if ((delete_w)&&(w!=
NULL)&&(*w!=
NULL))
delete *w;
2674 return idInit(1,F->rank);
2680 sb =
kStd(F, Q, h, w, hilb);
2711 strat->
minim=(reduced % 2)+1;
2732 if (strat->
ak > 0 && (w!=
NULL) && (*w!=
NULL))
2760 r=
mora(F,Q,*w,hilb,strat);
2767 r=
bba(F,Q,*w,hilb,strat);
2785 if ((delete_w)&&(temp_w!=
NULL))
delete temp_w;
2793 else if (strat->
M==
NULL)
2796 Warn(
"no minimal generating set computed");
2853 res=
kNF1(F,Q,pp,strat,lazyReduce);
2855 res=
kNF2(F,Q,pp,strat,lazyReduce);
2906 res=
kNF1(F,Q,pp,strat,lazyReduce);
2908 res=
kNF2(F,Q,pp,strat,lazyReduce);
2923 poly ret =
kNF(F, Q, p, syzComp, lazyReduce);
2977 initS(tempF, tempQ, strat);
3006 ideal shdl=strat->
Shdl;
3056 strat->
kModW = kModW =
w;
3085 withT = ! strat->
homog;
3090 #ifdef HAVE_TAIL_RING 3095 while (strat->
Ll >= 0)
3102 strat->
P = strat->
L[strat->
Ll];
3105 if (strat->
P.p1 ==
NULL)
3111 if (strat->
P.p ==
NULL && strat->
P.t_p ==
NULL)
3119 &olddeg,&reduc,
strat, red_result);
3122 red_result = strat->red(&strat->P,strat);
3126 if (red_result == 1)
3132 strat->
P.GetP(strat->
lmBin);
3134 int pos=
posInS(strat,strat->
sl,strat->
P.p,strat->
P.ecart);
3141 strat->
P.pCleardenom();
3145 strat->
P.p =
redtailBba(&(strat->
P),pos-1,strat, withT);
3146 strat->
P.pCleardenom();
3154 strat->
P.p =
redtailBba(&(strat->
P),pos-1,strat, withT);
3166 strat->
enterS(strat->
P, pos, strat, strat->
tl);
3174 for(;ii<=strat->
sl;ii++)
3177 memset(&h,0,
sizeof(h));
3179 h.p=strat->
S[ii]; strat->
S[ii]=
NULL;
3181 h.sev=strat->
sevS[ii];
3185 if (strat->
T[jj].p==h.p)
3187 strat->
T[jj].p=
NULL;
3190 memmove(&(strat->
T[jj]),&(strat->
T[jj+1]),
3191 (strat->
tl-jj)*
sizeof(strat->
T[jj]));
3192 memmove(&(strat->
sevT[jj]),&(strat->
sevT[jj+1]),
3193 (strat->
tl-jj)*
sizeof(strat->
sevT[jj]));
3200 int lpos=strat->
posInL(strat->
L,strat->
Ll,&h,strat);
3205 Print(
"move S[%d] -> L[%d]: ",ii,pos);
3213 for(ii=pos+1;ii<=strat->
sl;ii++) strat->
fromQ[ii]=0;
3222 if (strat->
P.lcm!=
NULL)
3235 memset(&(strat->
P), 0,
sizeof(strat->
P));
3247 #ifdef HAVE_TAIL_RING 3255 for(i=strat->
sl;i>=0;i--) strat->
S_2_R[
i]=-1;
3278 if (w!=
NULL)
delete w;
3323 res1=
kNF(null,Q,res);
3328 if (
idElem(res)<=1) need_retry=0;
3329 while (need_retry && (counter>0))
3335 int new_elems=
idElem(res1);
3336 counter -= (new_elems >= elems);
3339 if (
idElem(res1)<=1) need_retry=0;
3345 res=
kNF(null,Q,res1);
3350 if (
idElem(res)<=1) need_retry=0;
3361 #ifdef MORA_USE_BUCKETS BOOLEAN rHasLocalOrMixedOrdering(const ring r)
#define pSetmComp(p)
TODO:
void initEcartPairBba(LObject *Lp, poly, poly, int, int)
void updateT(kStrategy strat)
poly k_NF(ideal F, ideal Q, poly p, int syzComp, int lazyReduce, const ring _currRing)
NOTE: this is just a wrapper which sets currRing for the actual kNF call.
int(* posInL)(const LSet set, const int length, LObject *L, const kStrategy strat)
ideal SCAQuotient(const ring r)
KINLINE TObject ** initR()
poly redtail(LObject *L, int pos, kStrategy strat)
void enterSSba(LObject &p, int atS, kStrategy strat, int atR)
poly kNF(ideal F, ideal Q, poly p, int syzComp, int lazyReduce)
int redRing(LObject *h, kStrategy strat)
int posInT2(const TSet set, const int length, LObject &p)
int redEcart(LObject *h, kStrategy strat)
KINLINE unsigned long * initsevT()
#define TEST_OPT_DEGBOUND
void initBuchMoraPos(kStrategy strat)
BOOLEAN(* rewCrit1)(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
poly preIntegerCheck(ideal FOrig, ideal Q)
used for GB over ZZ: look for constant and monomial elements in the ideal background: any known const...
void message(int i, int *reduc, int *olddeg, kStrategy strat, int red_result)
pLDegProc pOrigLDeg_TailRing
void initMora(ideal F, kStrategy strat)
#define idDelete(H)
delete an ideal
void messageStat(int hilbcount, kStrategy strat)
void kEcartWeights(poly *s, int sl, short *eweight, const ring R)
BOOLEAN faugereRewCriterion(poly sig, unsigned long not_sevSig, poly, kStrategy strat, int start=0)
Compatiblity layer for legacy polynomial operations (over currRing)
ideal kSba(ideal F, ideal Q, tHomog h, intvec **w, int sbaOrder, int arri, intvec *hilb, int syzComp, int newIdeal, intvec *vw)
long totaldegreeWecart(poly p, ring r)
void chainCritNormal(poly p, int ecart, kStrategy strat)
void initBuchMora(ideal F, ideal Q, kStrategy strat)
#define pLmCmp(p, q)
returns 0|1|-1 if p=q|p>q|p<q w.r.t monomial ordering
int redFirst(LObject *h, kStrategy strat)
BOOLEAN posInLDependsOnLength
long p_WDegree(poly p, const ring r)
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_Z(const coeffs r)
static int doRed(LObject *h, TObject *with, BOOLEAN intoT, kStrategy strat, bool redMoraNF)
#define omFreeSize(addr, size)
#define idSimpleAdd(A, B)
BOOLEAN(* rewCrit2)(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
void initSba(ideal F, kStrategy strat)
static short rVar(const ring r)
#define rVar(r) (r->N)
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
long pLDeg0c(poly p, int *l, const ring r)
void enterpairs(poly h, int k, int ecart, int pos, kStrategy strat, int atR)
#define pLmDelete(p)
assume p != NULL, deletes Lm(p)->coef and Lm(p)
#define TEST_OPT_MULTBOUND
ideal kStd(ideal F, ideal Q, tHomog h, intvec **w, intvec *hilb, int syzComp, int newIdeal, intvec *vw, s_poly_proc_t sp)
int ksReducePoly(LObject *PR, TObject *PW, poly spNoether, number *coef, kStrategy strat)
BOOLEAN(* rewCrit3)(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
void(* initEcartPair)(LObject *h, poly f, poly g, int ecartF, int ecartG)
void cancelunit(LObject *L, BOOLEAN inNF)
void WerrorS(const char *s)
void initBba(kStrategy strat)
void enterL(LSet *set, int *length, int *LSetmax, LObject p, int at)
int redSig(LObject *h, kStrategy strat)
ideal bba(ideal F, ideal Q, intvec *w, intvec *hilb, kStrategy strat)
ideal sba(ideal F0, ideal Q, intvec *w, intvec *hilb, kStrategy strat)
int(* red)(LObject *L, kStrategy strat)
int redHomog(LObject *h, kStrategy strat)
KINLINE poly redtailBba(poly p, int pos, kStrategy strat, BOOLEAN normalize)
poly p_KillSquares(const poly p, const short iFirstAltVar, const short iLastAltVar, const ring r)
int(* posInT)(const TSet T, const int tl, LObject &h)
void HEckeTest(poly pp, kStrategy strat)
long(* pLDegProc)(poly p, int *length, ring r)
static void p_LmFree(poly p, ring)
#define pGetComp(p)
Component.
static int pLength(poly a)
void updateL(kStrategy strat)
void enterOnePairNormal(int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR=-1)
char completeReduce_retry
void kStratInitChangeTailRing(kStrategy strat)
#define TEST_OPT_NOT_BUCKETS
static BOOLEAN rField_has_simple_inverse(const ring r)
pShallowCopyDeleteProc pGetShallowCopyDeleteProc(ring, ring)
void enterT(LObject &p, kStrategy strat, int atT)
void missingAxis(int *last, kStrategy strat)
int redHoney(LObject *h, kStrategy strat)
void deleteInL(LSet set, int *length, int j, kStrategy strat)
ideal kStdShift(ideal F, ideal Q, tHomog h, intvec **w, intvec *hilb, int syzComp, int newIdeal, intvec *vw, int uptodeg, int lV)
int redRiloc(LObject *h, kStrategy strat)
void(* initEcart)(TObject *L)
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
int redLazy(LObject *h, kStrategy strat)
void(* enterOnePair)(int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR)
void initS(ideal F, ideal Q, kStrategy strat)
poly kNF2(ideal F, ideal Q, poly q, kStrategy strat, int lazyReduce)
ideal kInterRedBba(ideal F, ideal Q, int &need_retry)
omError_t omTestMemory(int check_level)
void initEcartPairMora(LObject *Lp, poly, poly, int ecartF, int ecartG)
#define TEST_OPT_INTSTRATEGY
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
#define TEST_OPT_STAIRCASEBOUND
END_NAMESPACE BEGIN_NAMESPACE_SINGULARXX ideal poly int syzComp
void pSetDegProcs(ring r, pFDegProc new_FDeg, pLDegProc new_lDeg)
void initHilbCrit(ideal, ideal, intvec **hilb, kStrategy strat)
void enterSMora(LObject &p, int atS, kStrategy strat, int atR=-1)
int scMult0Int(ideal S, ideal Q, const ring tailRing)
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
poly kNF1(ideal F, ideal Q, poly q, kStrategy strat, int lazyReduce)
void initEcartBBA(TObject *h)
void updateLHC(kStrategy strat)
#define pGetShortExpVector(a)
returns the "Short Exponent Vector" – used to speed up divisibility tests (see polys-impl.cc )
static FORCE_INLINE BOOLEAN n_DivBy(number a, number b, const coeffs r)
test whether 'a' is divisible 'b'; for r encoding a field: TRUE iff 'b' does not represent zero in Z:...
long pLDeg0(poly p, int *l, const ring r)
#define pLmShortDivisibleBy(a, sev_a, b, not_sev_b)
Divisibility tests based on Short Exponent vectors sev_a == pGetShortExpVector(a) not_sev_b == ~ pGet...
#define pp_Test(p, lmRing, tailRing)
void(* enterS)(LObject &h, int pos, kStrategy strat, int atR)
long kHomModDeg(poly p, ring r)
static BOOLEAN p_LmShortDivisibleBy(poly a, unsigned long sev_a, poly b, unsigned long not_sev_b, const ring r)
ideal kInterRed(ideal F, ideal Q)
void ksCreateSpoly(LObject *Pair, poly spNoether, int use_buckets, ring tailRing, poly m1, poly m2, TObject **R)
int kFindDivisibleByInS(const kStrategy strat, int *max_ind, LObject *L)
return -1 if no divisor is found number of first divisor in S, otherwise
BOOLEAN idInsertPoly(ideal h1, poly h2)
insert h2 into h1 (if h2 is not the zero polynomial) return TRUE iff h2 was indeed inserted ...
BOOLEAN kStratChangeTailRing(kStrategy strat, LObject *L, TObject *T, unsigned long expbound)
int posInL0(const LSet set, const int length, LObject *p, const kStrategy)
#define pIsConstant(p)
like above, except that Comp might be != 0
void initBuchMoraCrit(kStrategy strat)
static int si_max(const int a, const int b)
void reorderL(kStrategy strat)
ideal kInterRedOld(ideal F, ideal Q)
void PrintS(const char *s)
void deleteHC(LObject *L, kStrategy strat, BOOLEAN fromNext)
static long p_MinComp(poly p, ring lmRing, ring tailRing)
static void kOptimizeLDeg(pLDegProc ldeg, kStrategy strat)
int posInT17(const TSet set, const int length, LObject &p)
int(* posInLOld)(const LSet Ls, const int Ll, LObject *Lo, const kStrategy strat)
void rWrite(ring r, BOOLEAN details)
#define pHead(p)
returns newly allocated copy of Lm(p), coef is copied, next=NULL, p might be NULL ...
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size
static short scaFirstAltVar(ring r)
void enterT_strong(LObject &p, kStrategy strat, int atT)
void pRestoreDegProcs(ring r, pFDegProc old_FDeg, pLDegProc old_lDeg)
void rChangeCurrRing(ring r)
BOOLEAN kCheckSpolyCreation(LObject *L, kStrategy strat, poly &m1, poly &m2)
BOOLEAN arriRewCriterion(poly, unsigned long, poly, kStrategy strat, int start=0)
#define TEST_OPT_RETURN_SB
static void p_Delete(poly *p, const ring r)
void khCheck(ideal Q, intvec *w, intvec *hilb, int &eledeg, int &count, kStrategy strat)
ideal idInit(int idsize, int rank)
initialise an ideal / module
BOOLEAN arriRewCriterionPre(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int)
int p_IsPurePower(const poly p, const ring r)
return i, if head depends only on var(i)
void(* chainCrit)(poly p, int ecart, kStrategy strat)
void postReduceByMon(LObject *h, kStrategy strat)
used for GB over ZZ: intermediate reduction by monomial elements background: any known constant eleme...
static BOOLEAN rField_is_Ring(const ring r)
BOOLEAN idHomIdeal(ideal id, ideal Q=NULL)
void cleanT(kStrategy strat)
ideal id_KillSquares(const ideal id, const short iFirstAltVar, const short iLastAltVar, const ring r, const bool bSkipZeroes)
void superenterpairs(poly h, int k, int ecart, int pos, kStrategy strat, int atR)
void firstUpdate(kStrategy strat)
BOOLEAN rHasGlobalOrdering(const ring r)
BOOLEAN enterOneStrongPoly(int i, poly p, int, int, kStrategy strat, int atR, bool enterTstrong)
void khCheckLocInhom(ideal Q, intvec *w, intvec *hilb, int &count, kStrategy strat)
ideal kMin_std(ideal F, ideal Q, tHomog h, intvec **w, ideal &M, intvec *hilb, int syzComp, int reduced)
void pNorm(poly p, const ring R=currRing)
BOOLEAN hasPurePower(const poly p, int last, int *length, kStrategy strat)
void reorderT(kStrategy strat)
BOOLEAN(* s_poly_proc_t)(kStrategy strat)
int posInS(const kStrategy strat, const int length, const poly p, const int ecart_p)
static short scaLastAltVar(ring r)
void updateS(BOOLEAN toT, kStrategy strat)
ideal bbaShift(ideal F, ideal Q, intvec *w, intvec *hilb, kStrategy strat, int uptodeg, int lV)
static bool rIsSCA(const ring r)
void completeReduce(kStrategy strat, BOOLEAN withT)
static poly redMoraNF(poly h, kStrategy strat, int flag)
long kModDeg(poly p, ring r)
void chainCritOpt_1(poly, int, kStrategy strat)
long maxdegreeWecart(poly p, int *l, ring r)
void updateResult(ideal r, ideal Q, kStrategy strat)
static void pLmFree(poly p)
frees the space of the monomial m, assumes m != NULL coef is not freed, m is not advanced ...
int idElem(const ideal F)
count non-zero elements
static BOOLEAN kMoraUseBucket(kStrategy strat)
void p_wrp(poly p, ring lmRing, ring tailRing)
void p_Write(poly p, ring lmRing, ring tailRing)
int kFindDivisibleByInT(const kStrategy strat, const LObject *L, const int start)
return -1 if no divisor is found number of first divisor in T, otherwise
BOOLEAN newHEdge(kStrategy strat)
void enterSMoraNF(LObject &p, int atS, kStrategy strat, int atR=-1)
void initEcartNormal(TObject *h)
#define OPT_NOTREGULARITY
#define TEST_OPT_REDTHROUGH
void finalReduceByMon(kStrategy strat)
used for GB over ZZ: final reduction by constant elements background: any known constant element of i...
static ideal nc_GB(const ideal F, const ideal Q, const intvec *w, const intvec *hilb, kStrategy strat, const ring r)
int(* red2)(LObject *L, kStrategy strat)
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
KINLINE poly kNoetherTail()
#define SI_RESTORE_OPT1(A)
KINLINE BOOLEAN arriRewDummy(poly, unsigned long, poly, kStrategy, int)
static BOOLEAN rField_is_numeric(const ring r)
void exitBuchMora(kStrategy strat)
BOOLEAN idHomModule(ideal m, ideal Q, intvec **w)
pFDegProc pOrigFDeg_TailRing
int posInL10(const LSet set, const int length, LObject *p, const kStrategy strat)
void kDebugPrint(kStrategy strat)
END_NAMESPACE BEGIN_NAMESPACE_SINGULARXX ideal poly int int lazyReduce
ideal mora(ideal F, ideal Q, intvec *w, intvec *hilb, kStrategy strat)
void enterSBba(LObject &p, int atS, kStrategy strat, int atR)
#define pCopy(p)
return a copy of the poly