 |
My Project
debian-1:4.1.1-p2+ds-4build1
|
Go to the source code of this file.
|
void | deleteHC (poly *p, int *e, int *l, kStrategy strat) |
|
void | deleteHC (LObject *L, kStrategy strat, BOOLEAN fromNext=FALSE) |
|
void | deleteInS (int i, kStrategy strat) |
|
void | deleteInSSba (int i, kStrategy strat) |
|
void | cleanT (kStrategy strat) |
|
static LSet | initL (int nr=setmaxL) |
|
void | deleteInL (LSet set, int *length, int j, kStrategy strat) |
|
void | enterL (LSet *set, int *length, int *LSetmax, LObject p, int at) |
|
void | enterSBba (LObject &p, int atS, kStrategy strat, int atR=-1) |
|
void | enterSSba (LObject &p, int atS, kStrategy strat, int atR=-1) |
|
void | initEcartPairBba (LObject *Lp, poly f, poly g, int ecartF, int ecartG) |
|
void | initEcartPairMora (LObject *Lp, poly f, poly g, int ecartF, int ecartG) |
|
int | posInS (const kStrategy strat, const int length, const poly p, const int ecart_p) |
|
int | posInSMonFirst (const kStrategy strat, const int length, const poly p) |
|
int | posInIdealMonFirst (const ideal F, const poly p, int start=0, int end=-1) |
|
int | posInT0 (const TSet set, const int length, LObject &p) |
|
int | posInT1 (const TSet set, const int length, LObject &p) |
|
int | posInT2 (const TSet set, const int length, LObject &p) |
|
int | posInT11 (const TSet set, const int length, LObject &p) |
|
int | posInTSig (const TSet set, const int length, LObject &p) |
|
int | posInT110 (const TSet set, const int length, LObject &p) |
|
int | posInT13 (const TSet set, const int length, LObject &p) |
|
int | posInT15 (const TSet set, const int length, LObject &p) |
|
int | posInT17 (const TSet set, const int length, LObject &p) |
|
int | posInT17_c (const TSet set, const int length, LObject &p) |
|
int | posInT19 (const TSet set, const int length, LObject &p) |
|
int | posInT_EcartpLength (const TSet set, const int length, LObject &p) |
|
int | posInT_EcartFDegpLength (const TSet set, const int length, LObject &p) |
|
int | posInT_FDegpLength (const TSet set, const int length, LObject &p) |
|
int | posInT_pLength (const TSet set, const int length, LObject &p) |
|
void | reorderS (int *suc, kStrategy strat) |
|
int | posInLF5C (const LSet set, const int length, LObject *L, const kStrategy strat) |
|
int | posInLSig (const LSet set, const int length, LObject *L, const kStrategy strat) |
|
int | posInLSigRing (const LSet set, const int length, LObject *L, const kStrategy strat) |
|
int | posInLRing (const LSet set, const int length, LObject *L, const kStrategy strat) |
|
int | posInSyz (const kStrategy strat, const poly sig) |
|
int | posInL0 (const LSet set, const int length, LObject *L, const kStrategy strat) |
|
int | posInL11 (const LSet set, const int length, LObject *L, const kStrategy strat) |
|
int | posInL11Ring (const LSet set, const int length, LObject *L, const kStrategy strat) |
|
int | posInLF5CRing (const LSet set, int start, const int length, LObject *L, const kStrategy strat) |
|
int | posInL11Ringls (const LSet set, const int length, LObject *L, const kStrategy strat) |
|
int | posInL13 (const LSet set, const int length, LObject *L, const kStrategy strat) |
|
int | posInL15 (const LSet set, const int length, LObject *L, const kStrategy strat) |
|
int | posInL15Ring (const LSet set, const int length, LObject *L, const kStrategy strat) |
|
int | posInL17 (const LSet set, const int length, LObject *L, const kStrategy strat) |
|
int | posInL10 (const LSet set, const int length, LObject *L, const kStrategy strat) |
|
int | posInL10Ring (const LSet set, const int length, LObject *L, const kStrategy strat) |
|
int | posInL110 (const LSet set, const int length, LObject *L, const kStrategy strat) |
|
KINLINE poly | redtailBba (poly p, int end_pos, kStrategy strat, BOOLEAN normalize=FALSE) |
|
KINLINE poly | redtailBbaBound (poly p, int end_pos, kStrategy strat, int bound, BOOLEAN normalize=FALSE) |
|
KINLINE poly | redtailBba_Z (poly p, int end_pos, kStrategy strat) |
|
poly | redtailBba_Z (LObject *L, int end_pos, kStrategy strat) |
|
poly | redtailBba (LObject *L, int end_pos, kStrategy strat, BOOLEAN withT=FALSE, BOOLEAN normalize=FALSE) |
|
poly | redtailBbaBound (LObject *L, int end_pos, kStrategy strat, int bound, BOOLEAN withT=FALSE, BOOLEAN normalize=FALSE) |
|
poly | redtailSba (LObject *L, int end_pos, kStrategy strat, BOOLEAN withT=FALSE, BOOLEAN normalize=FALSE) |
|
poly | redtailBba (TObject *T, int end_pos, kStrategy strat) |
|
poly | redtail (poly p, int end_pos, kStrategy strat) |
|
poly | redtail (LObject *L, int end_pos, kStrategy strat) |
|
poly | redNF (poly h, int &max_ind, int nonorm, kStrategy strat) |
|
int | redNF0 (LObject *P, kStrategy strat) |
|
poly | redNFTail (poly h, const int sl, kStrategy strat) |
|
int | redHoney (LObject *h, kStrategy strat) |
|
int | redRing (LObject *h, kStrategy strat) |
|
int | redRiloc (LObject *h, kStrategy strat) |
|
void | enterExtendedSpoly (poly h, kStrategy strat) |
|
void | enterExtendedSpolySig (poly h, poly hSig, kStrategy strat) |
|
void | superenterpairs (poly h, int k, int ecart, int pos, kStrategy strat, int atR=-1) |
|
void | superenterpairsSig (poly h, poly hSig, int hFrom, int k, int ecart, int pos, kStrategy strat, int atR=-1) |
|
poly | kCreateZeroPoly (long exp[], long cabsind, poly *t_p, ring leadRing, ring tailRing) |
|
long | ind2 (long arg) |
|
long | ind_fact_2 (long arg) |
|
long | twoPow (long arg) |
|
ideal | createG0 () |
|
int | redLazy (LObject *h, kStrategy strat) |
|
int | redHomog (LObject *h, kStrategy strat) |
|
int | redSig (LObject *h, kStrategy strat) |
|
int | redSigRing (LObject *h, kStrategy strat) |
|
void | enterpairsSig (poly h, poly hSig, int from, int k, int ec, int pos, kStrategy strat, int atR=-1) |
|
void | enterpairs (poly h, int k, int ec, int pos, kStrategy strat, int atR=-1) |
|
void | entersets (LObject h) |
|
void | pairs () |
|
BOOLEAN | sbaCheckGcdPair (LObject *h, kStrategy strat) |
|
void | message (int i, int *reduc, int *olddeg, kStrategy strat, int red_result) |
|
void | messageStat (int hilbcount, kStrategy strat) |
|
void | messageStatSBA (int hilbcount, kStrategy strat) |
|
void | initEcartNormal (TObject *h) |
|
void | initEcartBBA (TObject *h) |
|
void | initS (ideal F, ideal Q, kStrategy strat) |
|
void | initSL (ideal F, ideal Q, kStrategy strat) |
|
void | initSLSba (ideal F, ideal Q, kStrategy strat) |
|
void | initSyzRules (kStrategy strat) |
|
void | updateS (BOOLEAN toT, kStrategy strat) |
|
void | enterSyz (LObject &p, kStrategy strat, int atT) |
|
void | enterT (LObject &p, kStrategy strat, int atT=-1) |
|
void | enterT_strong (LObject &p, kStrategy strat, int atT=-1) |
|
void | cancelunit (LObject *p, BOOLEAN inNF=FALSE) |
|
void | HEckeTest (poly pp, kStrategy strat) |
|
void | initBuchMoraCrit (kStrategy strat) |
|
void | initSbaCrit (kStrategy strat) |
|
void | initHilbCrit (ideal F, ideal Q, intvec **hilb, kStrategy strat) |
|
void | initBuchMoraPos (kStrategy strat) |
|
void | initBuchMoraPosRing (kStrategy strat) |
|
void | initSbaPos (kStrategy strat) |
|
void | initBuchMora (ideal F, ideal Q, kStrategy strat) |
|
void | initSbaBuchMora (ideal F, ideal Q, kStrategy strat) |
|
void | exitBuchMora (kStrategy strat) |
|
void | exitSba (kStrategy strat) |
|
void | updateResult (ideal r, ideal Q, kStrategy strat) |
|
void | completeReduce (kStrategy strat, BOOLEAN withT=FALSE) |
|
void | kFreeStrat (kStrategy strat) |
|
void | enterOnePairNormal (int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR) |
|
void | chainCritNormal (poly p, int ecart, kStrategy strat) |
|
void | chainCritOpt_1 (poly, int, kStrategy strat) |
|
void | chainCritSig (poly p, int ecart, kStrategy strat) |
|
BOOLEAN | homogTest (polyset F, int Fmax) |
|
BOOLEAN | newHEdge (kStrategy strat) |
|
BOOLEAN | syzCriterion (poly sig, unsigned long not_sevSig, kStrategy strat) |
|
BOOLEAN | syzCriterionInc (poly sig, unsigned long not_sevSig, kStrategy strat) |
|
KINLINE BOOLEAN | arriRewDummy (poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start) |
|
BOOLEAN | arriRewCriterion (poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start) |
|
BOOLEAN | arriRewCriterionPre (poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start) |
|
BOOLEAN | faugereRewCriterion (poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start) |
|
BOOLEAN | findMinLMPair (poly sig, unsigned long not_sevSig, kStrategy strat, int start) |
|
int | kFindInT (poly p, TSet T, int tlength) |
| returns index of p in TSet, or -1 if not found More...
|
|
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 More...
|
|
int | kFindDivisibleByInS (const kStrategy strat, int *max_ind, LObject *L) |
| return -1 if no divisor is found number of first divisor in S, otherwise More...
|
|
int | kFindNextDivisibleByInS (const kStrategy strat, int start, int max_ind, LObject *L) |
|
TObject * | kFindDivisibleByInS_T (kStrategy strat, int end_pos, LObject *L, TObject *T, long ecart=LONG_MAX) |
|
KINLINE TSet | initT () |
|
KINLINE TObject ** | initR () |
|
KINLINE unsigned long * | initsevT () |
|
KINLINE poly | k_LmInit_currRing_2_tailRing (poly p, ring tailRing, omBin bin) |
|
KINLINE poly | k_LmInit_tailRing_2_currRing (poly p, ring tailRing, omBin bin) |
|
KINLINE poly | k_LmShallowCopyDelete_currRing_2_tailRing (poly p, ring tailRing, omBin bin) |
|
KINLINE poly | k_LmShallowCopyDelete_tailRing_2_currRing (poly p, ring tailRing, omBin bin) |
|
KINLINE poly | k_LmInit_currRing_2_tailRing (poly p, ring tailRing) |
|
KINLINE poly | k_LmInit_tailRing_2_currRing (poly p, ring tailRing) |
|
KINLINE poly | k_LmShallowCopyDelete_currRing_2_tailRing (poly p, ring tailRing) |
|
KINLINE poly | k_LmShallowCopyDelete_tailRing_2_currRing (poly p, ring tailRing) |
|
KINLINE BOOLEAN | k_GetLeadTerms (const poly p1, const poly p2, const ring p_r, poly &m1, poly &m2, const ring m_r) |
|
KINLINE void | k_GetStrongLeadTerms (const poly p1, const poly p2, const ring leadRing, poly &m1, poly &m2, poly &lcm, const ring taiRing) |
|
poly | kFindZeroPoly (poly input_p, ring leadRing, ring tailRing) |
|
ideal | bba (ideal F, ideal Q, intvec *w, intvec *hilb, kStrategy strat) |
|
ideal | sba (ideal F, ideal Q, intvec *w, intvec *hilb, kStrategy strat) |
|
poly | kNF2 (ideal F, ideal Q, poly q, kStrategy strat, int lazyReduce) |
|
ideal | kNF2 (ideal F, ideal Q, ideal q, kStrategy strat, int lazyReduce) |
|
poly | kNF2Bound (ideal F, ideal Q, poly q, int bound, kStrategy strat, int lazyReduce) |
|
ideal | kNF2Bound (ideal F, ideal Q, ideal q, int bound, kStrategy strat, int lazyReduce) |
|
void | initBba (kStrategy strat) |
|
void | initSba (ideal F, kStrategy strat) |
|
void | f5c (kStrategy strat, int &olddeg, int &minimcnt, int &hilbeledeg, int &hilbcount, int &srmax, int &lrmax, int &reduc, ideal Q, intvec *w, intvec *hilb) |
|
int | ksReducePoly (LObject *PR, TObject *PW, poly spNoether=NULL, number *coef=NULL, kStrategy strat=NULL) |
|
int | ksReducePolyBound (LObject *PR, TObject *PW, int bound, poly spNoether=NULL, number *coef=NULL, kStrategy strat=NULL) |
|
int | ksReducePolySig (LObject *PR, TObject *PW, long idx, poly spNoether=NULL, number *coef=NULL, kStrategy strat=NULL) |
|
int | ksReducePolySigRing (LObject *PR, TObject *PW, long idx, poly spNoether=NULL, number *coef=NULL, kStrategy strat=NULL) |
|
int | ksReducePolyTail (LObject *PR, TObject *PW, poly Current, poly spNoether=NULL) |
|
KINLINE int | ksReducePolyTail (LObject *PR, TObject *PW, LObject *Red) |
|
void | ksCreateSpoly (LObject *Pair, poly spNoether=NULL, int use_buckets=0, ring tailRing=currRing, poly m1=NULL, poly m2=NULL, TObject **R=NULL) |
|
poly | ksCreateShortSpoly (poly p1, poly p2, ring tailRing) |
|
KINLINE poly | ksOldSpolyRed (poly p1, poly p2, poly spNoether=NULL) |
|
KINLINE poly | ksOldSpolyRedNew (poly p1, poly p2, poly spNoether=NULL) |
|
KINLINE poly | ksOldCreateSpoly (poly p1, poly p2, poly spNoether=NULL, ring r=currRing) |
|
KINLINE void | ksOldSpolyTail (poly p1, poly q, poly q2, poly spNoether, ring r=currRing) |
|
BOOLEAN | kCheckSpolyCreation (LObject *L, kStrategy strat, poly &m1, poly &m2) |
|
BOOLEAN | kCheckStrongCreation (int atR, poly m1, int atS, poly m2, kStrategy strat) |
|
poly | preIntegerCheck (ideal F, ideal Q) |
| used for GB over ZZ: look for constant and monomial elements in the ideal background: any known constant element of ideal suppresses intermediate coefficient swell More...
|
|
void | postReduceByMon (LObject *h, kStrategy strat) |
| used for GB over ZZ: intermediate reduction by monomial elements background: any known constant element of ideal suppresses intermediate coefficient swell More...
|
|
void | postReduceByMonSig (LObject *h, kStrategy strat) |
|
void | finalReduceByMon (kStrategy strat) |
| used for GB over ZZ: final reduction by constant elements background: any known constant element of ideal suppresses intermediate coefficient swell and beautifies output More...
|
|
BOOLEAN | kStratChangeTailRing (kStrategy strat, LObject *L=NULL, TObject *T=NULL, unsigned long new_expbound=0) |
|
void | kStratInitChangeTailRing (kStrategy strat) |
|
void | kDebugPrint (kStrategy strat) |
| Output some debug info about a given strategy. More...
|
|
ring | sbaRing (kStrategy strat, const ring r=currRing, BOOLEAN complete=TRUE, int sgn=1) |
|
KINLINE void | clearS (poly p, unsigned long p_sev, int *at, int *k, kStrategy strat) |
|
poly | pMove2CurrTail (poly p, kStrategy strat) |
|
poly | pMoveCurrTail2poly (poly p, kStrategy strat) |
|
poly | pCopyL2p (LObject h, kStrategy strat) |
|
void | enterTShift (LObject p, kStrategy strat, int atT, int uptodeg, int lV) |
|
void | initBuchMoraShift (ideal F, ideal Q, kStrategy strat) |
|
void | enterOnePairSelfShifts (poly qq, poly p, int ecart, int isFromQ, kStrategy strat, int atR, int uptodeg, int lV) |
|
void | enterOnePairShift (poly q, poly p, int ecart, int isFromQ, kStrategy strat, int atR, int ecartq, int qisFromQ, int shiftcount, int ifromS, int uptodeg, int lV) |
|
void | enterpairsShift (poly h, int k, int ecart, int pos, kStrategy strat, int atR, int uptodeg, int lV) |
|
void | updateSShift (kStrategy strat, int uptodeg, int lV) |
|
void | initBbaShift (kStrategy strat) |
|
poly | redtailBbaShift (LObject *L, int pos, kStrategy strat, BOOLEAN withT, BOOLEAN normalize) |
|
int | redFirstShift (LObject *h, kStrategy strat) |
|
ideal | freegb (ideal I, int uptodeg, int lVblock) |
|
ideal | bbaShift (ideal F, ideal Q, intvec *w, intvec *hilb, kStrategy strat, int uptodeg, int lV) |
|
◆ denominator_list_s
struct denominator_list_s |
◆ ALLOW_PROD_CRIT
#define ALLOW_PROD_CRIT |
( |
|
A | ) |
(!(A)->no_prod_crit) |
◆ HAVE_TAIL_RING
◆ KINLINE
◆ kTest
#define kTest |
( |
|
A | ) |
(TRUE) |
◆ kTest_L
#define kTest_L |
( |
|
T | ) |
(TRUE) |
◆ kTest_S
#define kTest_S |
( |
|
T | ) |
(TRUE) |
◆ kTest_T
#define kTest_T |
( |
|
T | ) |
(TRUE) |
◆ kTest_TS
#define kTest_TS |
( |
|
A | ) |
(TRUE) |
◆ messageSets
#define messageSets |
( |
|
s | ) |
do {} while (0) |
◆ NO_KINLINE
◆ setmax
◆ setmaxL
#define setmaxL ((4096-12)/sizeof(LObject)) |
◆ setmaxLinc
#define setmaxLinc ((4096)/sizeof(LObject)) |
◆ setmaxT
#define setmaxT ((4096-12)/sizeof(TObject)) |
◆ setmaxTinc
#define setmaxTinc ((4096)/sizeof(TObject)) |
◆ denominator_list
◆ intset
◆ LObject
◆ LSet
◆ TObject
◆ TSet
◆ wlen_set
◆ wlen_type
◆ arriRewCriterion()
BOOLEAN arriRewCriterion |
( |
poly |
sig, |
|
|
unsigned long |
not_sevSig, |
|
|
poly |
lm, |
|
|
kStrategy |
strat, |
|
|
int |
start |
|
) |
| |
Definition at line 7087 of file kutil.cc.
7094 for (
int ii=strat->
sl; ii>start; ii--)
7100 if (!(
pLmCmp(p1,p2) == 1))
◆ arriRewCriterionPre()
BOOLEAN arriRewCriterionPre |
( |
poly |
sig, |
|
|
unsigned long |
not_sevSig, |
|
|
poly |
lm, |
|
|
kStrategy |
strat, |
|
|
int |
start |
|
) |
| |
Definition at line 7112 of file kutil.cc.
7119 for (
int i=strat->
Bl;
i>-1;
i--) {
7139 for (
int ii=strat->
sl; ii>-1; ii--)
7145 if (!(
pLmCmp(p1,p2) == 1))
◆ arriRewDummy()
◆ bba()
Definition at line 1919 of file kstd2.cc.
1923 int hilbeledeg=1,hilbcount=0,minimcnt=0;
1946 withT = ! strat->
homog;
1951 #ifdef HAVE_TAIL_RING
1967 while (strat->
Ll >= 0)
1974 while (strat->
Ll >= 0)
1987 while ((strat->
Ll >= 0)
1988 && (strat->
L[strat->
Ll].p1!=
NULL) && (strat->
L[strat->
Ll].p2!=
NULL)
1993 if (strat->
Ll<0)
break;
1998 strat->
P = strat->
L[strat->
Ll];
2028 else if (strat->
P.p1 ==
NULL)
2030 if (strat->
minim > 0)
2036 if (strat->
P.p ==
NULL && strat->
P.t_p ==
NULL)
2044 &olddeg,&reduc,strat, red_result);
2047 red_result = strat->red(&strat->P,strat);
2051 if (strat->overflow)
2057 if (red_result == 1)
2060 strat->P.GetP(strat->lmBin);
2064 if (strat->homog) strat->initEcart(&(strat->P));
2069 int pos=
posInS(strat,strat->sl,strat->P.p,strat->P.ecart);
2074 strat->redTailChange=
FALSE;
2077 strat->P.pCleardenom();
2081 strat->P.pCleardenom();
2082 if (strat->redTailChange) { strat->P.t_p=
NULL; }
2090 strat->P.p =
redtailBba(&(strat->P),pos-1,strat, withT);
2091 if (strat->redTailChange) { strat->P.t_p=
NULL; }
2100 if ((strat->P.p1==
NULL) && (strat->minim>0))
2102 if (strat->minim==1)
2104 strat->M->m[minimcnt]=
p_Copy(strat->P.p,
currRing,strat->tailRing);
2109 strat->M->m[minimcnt]=strat->P.p2;
2113 pNext(strat->M->m[minimcnt])
2114 = strat->p_shallow_copy_delete(
pNext(strat->M->m[minimcnt]),
2125 superenterpairs(strat->P.p,strat->sl,strat->P.ecart,pos,strat, strat->tl);
2127 enterpairs(strat->P.p,strat->sl,strat->P.ecart,pos,strat, strat->tl);
2129 strat->enterS(strat->P, pos, strat, strat->tl);
2144 if (hilb!=
NULL)
khCheck(
Q,
w,hilb,hilbeledeg,hilbcount,strat);
2146 if (strat->P.lcm!=
NULL)
2152 if (strat->s_poly!=
NULL)
2157 if (strat->s_poly(strat))
2162 int pos=
posInS(strat,strat->sl,strat->P.p,strat->P.ecart);
2165 superenterpairs(strat->P.p,strat->sl,strat->P.ecart,pos,strat, strat->tl);
2167 enterpairs(strat->P.p,strat->sl,strat->P.ecart,pos,strat, strat->tl);
2168 strat->enterS(strat->P, pos, strat, strat->tl);
2172 else if (strat->P.p1 ==
NULL && strat->minim > 0)
2178 memset(&(strat->P), 0,
sizeof(strat->P));
2198 clearS(strat->S[
j],strat->sevS[
j],&
k,&
j,strat);
2209 if (strat->completeReduce_retry)
2214 #ifdef HAVE_TAIL_RING
2215 if(
currRing->bitmask>strat->tailRing->bitmask)
2217 strat->completeReduce_retry=
FALSE;
2220 for(
i=strat->sl;
i>=0;
i--) strat->S_2_R[
i]=-1;
2223 if (strat->completeReduce_retry)
2233 for(
int i = 0;
i<=strat->sl;
i++)
2237 strat->S[
i] =
pNeg(strat->S[
i]);
2241 for(
int i = 0;
i<=strat->sl;
i++)
2245 strat->S[
i] =
pNeg(strat->S[
i]);
2269 return (strat->Shdl);
◆ bbaShift()
Definition at line 3860 of file kstd2.cc.
3866 int hilbeledeg=1,hilbcount=0,minimcnt=0;
3896 #ifdef HAVE_TAIL_RING
3902 while (strat->
Ll >= 0)
3917 while ((strat->
Ll >= 0)
3918 && (strat->
L[strat->
Ll].p1!=
NULL) && (strat->
L[strat->
Ll].p2!=
NULL)
3923 if (strat->
Ll<0)
break;
3927 strat->
P = strat->
L[strat->
Ll];
3950 else if (strat->
P.p1 ==
NULL)
3952 if (strat->
minim > 0)
3962 if ( ! strat->
homog)
3964 strat->
P.GetP(strat->
lmBin);
3971 strat->
P.t_p =
NULL;
3972 strat->
P.GetP(strat->
lmBin);
3987 strat->
P.t_p =
NULL;
3992 if (strat->
P.p ==
NULL && strat->
P.t_p ==
NULL)
4000 &olddeg,&reduc,strat, red_result);
4003 red_result = strat->red(&strat->P,strat);
4007 if (red_result == 1)
4013 strat->P.GetP(strat->lmBin);
4015 int pos=
posInS(strat,strat->sl,strat->P.p,strat->P.ecart);
4020 strat->P.pCleardenom();
4023 strat->P.p =
redtailBba(&(strat->P),pos-1,strat, withT);
4024 strat->P.pCleardenom();
4031 strat->P.p =
redtailBba(&(strat->P),pos-1,strat, withT);
4042 if ((strat->P.p1==
NULL) && (strat->minim>0))
4044 if (strat->minim==1)
4046 strat->M->m[minimcnt]=
p_Copy(strat->P.p,
currRing,strat->tailRing);
4051 strat->M->m[minimcnt]=strat->P.p2;
4055 pNext(strat->M->m[minimcnt])
4056 = strat->p_shallow_copy_delete(
pNext(strat->M->m[minimcnt]),
4064 if ( ! strat->homog)
4066 strat->P.GetP(strat->lmBin);
4068 if (strat->P.p!=
NULL)
4075 strat->P.t_p =
NULL;
4076 strat->P.GetP(strat->lmBin);
4078 strat->initEcart(&(strat->P));
4088 strat->P.t_p =
NULL;
4089 goto red_shrink2zero;
4099 strat->P.t_p =
NULL;
4101 strat->initEcart(&(strat->P));
4111 strat->P.t_p =
NULL;
4112 goto red_shrink2zero;
4126 int atR=strat->tl+1;
4129 enterpairsShift(strat->P.p,strat->sl,strat->P.ecart,pos,strat, atR,uptodeg,lV);
4132 strat->enterS(strat->P, pos, strat, atR);
4134 if (hilb!=
NULL)
khCheck(
Q,
w,hilb,hilbeledeg,hilbcount,strat);
4141 if (strat->P.p1 ==
NULL && strat->minim > 0)
4147 memset(&(strat->P), 0,
sizeof(strat->P));
4170 Ln.SetShortExpVector();
4172 if (
j<0) {
k++;
j=-1;}
4175 if (
pLmCmp(strat->S[
k],strat->T[
j].p) == 0)
4178 if (
j<0) {
k++;
j=-1;}
4194 if (strat->completeReduce_retry)
4199 #ifdef HAVE_TAIL_RING
4200 if(
currRing->bitmask>strat->tailRing->bitmask)
4202 strat->completeReduce_retry=
FALSE;
4205 for(
i=strat->sl;
i>=0;
i--) strat->S_2_R[
i]=-1;
4208 if (strat->completeReduce_retry)
◆ cancelunit()
Definition at line 331 of file kutil.cc.
339 ring r = L->tailRing;
340 poly
p = L->GetLmTailRing();
419 number eins=
nInit(1);
◆ chainCritNormal()
void chainCritNormal |
( |
poly |
p, |
|
|
int |
ecart, |
|
|
kStrategy |
strat |
|
) |
| |
Definition at line 3123 of file kutil.cc.
3136 for (
j=0;
j<=strat->
sl;
j++)
3140 for (
i=strat->
Bl;
i>=0;
i--)
3162 for (
j=strat->
Ll;
j>=0;
j--)
3168 if (strat->
L[
j].p == strat->
tail)
3214 for (
j=strat->
Ll;
j>=0;
j--)
3234 for(
i=
j-1;
i>=0;
i--)
3253 for (
j=strat->
Ll;
j>=0;
j--)
3284 if (strat->
L[0].p2 == strat->
tail) strat->
L[0].p2 =
p;
3287 if (strat->
L[
j].p2 ==
p)
3293 if ((strat->
L[
i].p2 ==
p) &&
pLmEqual(strat->
L[
j].lcm,strat->
L[
i].lcm))
3307 strat->
L[
i].p2 = strat->
tail;
3324 else if (strat->
L[
j].p2 == strat->
tail)
◆ chainCritOpt_1()
void chainCritOpt_1 |
( |
poly |
, |
|
|
int |
, |
|
|
kStrategy |
strat |
|
) |
| |
◆ chainCritSig()
void chainCritSig |
( |
poly |
p, |
|
|
int |
ecart, |
|
|
kStrategy |
strat |
|
) |
| |
Definition at line 3352 of file kutil.cc.
3363 if (strat->
L[0].p2 == strat->
tail) strat->
L[0].p2 =
p;
3366 if (strat->
L[
j].p2 ==
p)
3372 if ((strat->
L[
i].p2 ==
p) &&
pLmEqual(strat->
L[
j].lcm,strat->
L[
i].lcm))
3386 strat->
L[
i].p2 = strat->
tail;
3403 else if (strat->
L[
j].p2 == strat->
tail)
◆ cleanT()
Definition at line 536 of file kutil.cc.
547 for (
j=0;
j<=strat->
tl;
j++)
551 if (strat->
T[
j].max_exp !=
NULL)
561 if (strat->
T[
j].t_p !=
NULL)
572 if (
p == strat->
S[
i])
574 if (strat->
T[
j].t_p !=
NULL)
576 if (p_shallow_copy_delete!=
NULL)
◆ clearS()
KINLINE void clearS |
( |
poly |
p, |
|
|
unsigned long |
p_sev, |
|
|
int * |
at, |
|
|
int * |
k, |
|
|
kStrategy |
strat |
|
) |
| |
◆ completeReduce()
Definition at line 10392 of file kutil.cc.
10422 for (
i=strat->
sl;
i>=low;
i--)
10424 int end_pos=strat->
sl;
10426 if (strat->
ak==0) end_pos=
i-1;
10428 if ((T_j !=
NULL)&&(T_j->p==strat->
S[
i]))
10446 Print(
"to (tailR) S[%d]:",
i);
10458 T_j->max_exp =
NULL;
10461 T_j->pCleardenom();
10501 Print(
"to (-tailR) S[%d]:",
i);
◆ createG0()
Definition at line 4388 of file kutil.cc.
4411 PrintS(
"-------------\npoly :");
4414 Print(
"cexp : (%d, %d)\n", cexp[1], cexp[2]);
4415 Print(
"cind : (%d, %d)\n", cind[1], cind[2]);
4417 Print(
"cind : %d\n", cabsind);
4435 Print(
"%d, (%d, %d), ind = (%d, %d)\n", cabsind, cexp[1], cexp[2], cind[1], cind[2]);
4443 G0->m[
IDELEMS(G0) - 1] = zeroPoly;
◆ deleteHC() [1/2]
Definition at line 242 of file kutil.cc.
249 poly
p = L->GetLmTailRing();
252 if (L->bucket !=
NULL)
290 L->ecart = L->pLDeg() - L->GetpFDeg();
299 L->ecart = L->pLDeg(strat->
LDegLast) - L->GetpFDeg();
◆ deleteHC() [2/2]
void deleteHC |
( |
poly * |
p, |
|
|
int * |
e, |
|
|
int * |
l, |
|
|
kStrategy |
strat |
|
) |
| |
◆ deleteInL()
void deleteInL |
( |
LSet |
set, |
|
|
int * |
length, |
|
|
int |
j, |
|
|
kStrategy |
strat |
|
) |
| |
Definition at line 1151 of file kutil.cc.
1164 if (set[
j].sig!=
NULL)
1198 #ifdef ENTER_USE_MEMMOVE
1202 for (
i=
j;
i < (*length);
i++)
◆ deleteInS()
Definition at line 1044 of file kutil.cc.
1047 #ifdef ENTER_USE_MEMMOVE
1048 memmove(&(strat->
S[
i]), &(strat->
S[
i+1]), (strat->
sl -
i)*
sizeof(poly));
1050 memmove(&(strat->
sevS[
i]),&(strat->
sevS[
i+1]),(strat->
sl -
i)*
sizeof(
unsigned long));
1051 memmove(&(strat->
S_2_R[
i]),&(strat->
S_2_R[
i+1]),(strat->
sl -
i)*
sizeof(
int));
1054 for (
j=
i;
j<strat->
sl;
j++)
1056 strat->
S[
j] = strat->
S[
j+1];
1064 #ifdef ENTER_USE_MEMMOVE
1065 memmove(&(strat->
lenS[
i]),&(strat->
lenS[
i+1]),(strat->
sl -
i)*
sizeof(
int));
1072 #ifdef ENTER_USE_MEMMOVE
1080 #ifdef ENTER_USE_MEMMOVE
1081 memmove(&(strat->
fromQ[
i]),&(strat->
fromQ[
i+1]),(strat->
sl -
i)*
sizeof(
int));
1083 for (
j=
i;
j<strat->
sl;
j++)
◆ deleteInSSba()
Definition at line 1096 of file kutil.cc.
1099 #ifdef ENTER_USE_MEMMOVE
1100 memmove(&(strat->
S[
i]), &(strat->
S[
i+1]), (strat->
sl -
i)*
sizeof(poly));
1101 memmove(&(strat->
sig[
i]), &(strat->
sig[
i+1]), (strat->
sl -
i)*
sizeof(poly));
1103 memmove(&(strat->
sevS[
i]),&(strat->
sevS[
i+1]),(strat->
sl -
i)*
sizeof(
unsigned long));
1104 memmove(&(strat->
sevSig[
i]),&(strat->
sevSig[
i+1]),(strat->
sl -
i)*
sizeof(
unsigned long));
1105 memmove(&(strat->
S_2_R[
i]),&(strat->
S_2_R[
i+1]),(strat->
sl -
i)*
sizeof(
int));
1108 for (
j=
i;
j<strat->
sl;
j++)
1110 strat->
S[
j] = strat->
S[
j+1];
1120 #ifdef ENTER_USE_MEMMOVE
1121 memmove(&(strat->
lenS[
i]),&(strat->
lenS[
i+1]),(strat->
sl -
i)*
sizeof(
int));
1128 #ifdef ENTER_USE_MEMMOVE
1136 #ifdef ENTER_USE_MEMMOVE
1137 memmove(&(strat->
fromQ[
i]),&(strat->
fromQ[
i+1]),(strat->
sl -
i)*
sizeof(
int));
1139 for (
j=
i;
j<strat->
sl;
j++)
◆ enterExtendedSpoly()
void enterExtendedSpoly |
( |
poly |
h, |
|
|
kStrategy |
strat |
|
) |
| |
Definition at line 4503 of file kutil.cc.
4538 PrintS(
"--- create zero spoly: ");
4567 posx = strat->
posInL(strat->
L,strat->
Ll,&Lp,strat);
◆ enterExtendedSpolySig()
void enterExtendedSpolySig |
( |
poly |
h, |
|
|
poly |
hSig, |
|
|
kStrategy |
strat |
|
) |
| |
Definition at line 4586 of file kutil.cc.
4620 PrintS(
"--- create zero spoly: ");
4648 int red_result =
redRing(&Lp,strat);
4658 strat->
enterS(strat->
P,strat->
sl+1,strat, strat->
tl+1);
4660 strat->
enterS(Lp,0,strat,strat->
tl);
◆ enterL()
void enterL |
( |
LSet * |
set, |
|
|
int * |
length, |
|
|
int * |
LSetmax, |
|
|
LObject |
p, |
|
|
int |
at |
|
) |
| |
Definition at line 1214 of file kutil.cc.
1225 memmove(&((*set)[at+1]), &((*set)[at]), ((*
length)-at+1)*
sizeof(
LObject));
1227 for (
i=(*
length)+1;
i>=at+1;
i--) (*set)[
i] = (*set)[
i-1];
◆ enterOnePairNormal()
void enterOnePairNormal |
( |
int |
i, |
|
|
poly |
p, |
|
|
int |
ecart, |
|
|
int |
isFromQ, |
|
|
kStrategy |
strat, |
|
|
int |
atR |
|
) |
| |
Definition at line 1860 of file kutil.cc.
1870 Lp.ecart=0; Lp.length=0;
1875 #ifndef HAVE_RATGRING
1877 #elif defined(HAVE_RATGRING)
1888 if((!((strat->
ecartS[
i]>0)&&(ecart>0)))
1988 for(
j = strat->
Bl;
j>=0;
j--)
2087 Lp.p1 = strat->
S[
i];
2101 Lp.i_r1 = strat->
S_2_R[
i];
2115 && (Lp.p->coef!=
NULL))
2119 l = strat->
posInL(strat->
B,strat->
Bl,&Lp,strat);
◆ enterOnePairSelfShifts()
void enterOnePairSelfShifts |
( |
poly |
qq, |
|
|
poly |
p, |
|
|
int |
ecart, |
|
|
int |
isFromQ, |
|
|
kStrategy |
strat, |
|
|
int |
atR, |
|
|
int |
uptodeg, |
|
|
int |
lV |
|
) |
| |
◆ enterOnePairShift()
void enterOnePairShift |
( |
poly |
q, |
|
|
poly |
p, |
|
|
int |
ecart, |
|
|
int |
isFromQ, |
|
|
kStrategy |
strat, |
|
|
int |
atR, |
|
|
int |
ecartq, |
|
|
int |
qisFromQ, |
|
|
int |
shiftcount, |
|
|
int |
ifromS, |
|
|
int |
uptodeg, |
|
|
int |
lV |
|
) |
| |
Definition at line 12080 of file kutil.cc.
12113 int qfromQ = qisFromQ;
12122 Lp.ecart=0; Lp.length=0;
12128 if (!
isInV(Lp.lcm, lV))
12133 PrintS(
"V crit applied to q = ");
12148 if((!((ecartq>0)&&(ecart>0)))
12170 Lp.ecart =
si_max(ecart,ecartq);
12171 if (strat->
fromT && (ecartq>ecart))
12193 if ((strat->
fromQ==
NULL) || (isFromQ==0) || (qfromQ==0))
12236 if (strat->
fromT && (ecartq>ecart))
12248 for(
j = strat->
Bl;
j>=0;
j--)
12254 if ((strat->
fromQ==
NULL) || (isFromQ==0) || (qfromQ==0))
12278 if ((strat->
fromQ!=
NULL) && (isFromQ!=0) && (qfromQ!=0))
12345 if ( (atR >= 0) && (shiftcount==0) && (ifromS >=0) )
◆ enterpairs()
void enterpairs |
( |
poly |
h, |
|
|
int |
k, |
|
|
int |
ec, |
|
|
int |
pos, |
|
|
kStrategy |
strat, |
|
|
int |
atR = -1 |
|
) |
| |
◆ enterpairsShift()
void enterpairsShift |
( |
poly |
h, |
|
|
int |
k, |
|
|
int |
ecart, |
|
|
int |
pos, |
|
|
kStrategy |
strat, |
|
|
int |
atR, |
|
|
int |
uptodeg, |
|
|
int |
lV |
|
) |
| |
◆ enterpairsSig()
void enterpairsSig |
( |
poly |
h, |
|
|
poly |
hSig, |
|
|
int |
from, |
|
|
int |
k, |
|
|
int |
ec, |
|
|
int |
pos, |
|
|
kStrategy |
strat, |
|
|
int |
atR = -1 |
|
) |
| |
◆ enterSBba()
Definition at line 9028 of file kutil.cc.
9043 *
sizeof(
unsigned long));
9070 strat->
Shdl->m=strat->
S;
9072 if (atS <= strat->sl)
9074 #ifdef ENTER_USE_MEMMOVE
9075 memmove(&(strat->
S[atS+1]), &(strat->
S[atS]),
9076 (strat->
sl - atS + 1)*
sizeof(poly));
9077 memmove(&(strat->
ecartS[atS+1]), &(strat->
ecartS[atS]),
9078 (strat->
sl - atS + 1)*
sizeof(
int));
9079 memmove(&(strat->
sevS[atS+1]), &(strat->
sevS[atS]),
9080 (strat->
sl - atS + 1)*
sizeof(
unsigned long));
9081 memmove(&(strat->
S_2_R[atS+1]), &(strat->
S_2_R[atS]),
9082 (strat->
sl - atS + 1)*
sizeof(
int));
9084 memmove(&(strat->
lenS[atS+1]), &(strat->
lenS[atS]),
9085 (strat->
sl - atS + 1)*
sizeof(
int));
9087 memmove(&(strat->
lenSw[atS+1]), &(strat->
lenSw[atS]),
9090 for (
i=strat->
sl+1;
i>=atS+1;
i--)
9092 strat->
S[
i] = strat->
S[
i-1];
9098 for (
i=strat->
sl+1;
i>=atS+1;
i--)
9101 for (
i=strat->
sl+1;
i>=atS+1;
i--)
9107 #ifdef ENTER_USE_MEMMOVE
9108 memmove(&(strat->
fromQ[atS+1]), &(strat->
fromQ[atS]),
9109 (strat->
sl - atS + 1)*
sizeof(
int));
9111 for (
i=strat->
sl+1;
i>=atS+1;
i--)
9116 strat->
fromQ[atS]=0;
◆ entersets()
◆ enterSSba()
Definition at line 9131 of file kutil.cc.
9146 *
sizeof(
unsigned long));
9150 *
sizeof(
unsigned long));
9178 strat->
Shdl->m=strat->
S;
9185 if (atS <= strat->sl)
9187 #ifdef ENTER_USE_MEMMOVE
9188 memmove(&(strat->
S[atS+1]), &(strat->
S[atS]),
9189 (strat->
sl - atS + 1)*
sizeof(poly));
9190 memmove(&(strat->
sig[atS+1]), &(strat->
sig[atS]),
9191 (strat->
sl - atS + 1)*
sizeof(poly));
9192 memmove(&(strat->
sevSig[atS+1]), &(strat->
sevSig[atS]),
9193 (strat->
sl - atS + 1)*
sizeof(
unsigned long));
9194 memmove(&(strat->
ecartS[atS+1]), &(strat->
ecartS[atS]),
9195 (strat->
sl - atS + 1)*
sizeof(
int));
9196 memmove(&(strat->
sevS[atS+1]), &(strat->
sevS[atS]),
9197 (strat->
sl - atS + 1)*
sizeof(
unsigned long));
9198 memmove(&(strat->
S_2_R[atS+1]), &(strat->
S_2_R[atS]),
9199 (strat->
sl - atS + 1)*
sizeof(
int));
9201 memmove(&(strat->
lenS[atS+1]), &(strat->
lenS[atS]),
9202 (strat->
sl - atS + 1)*
sizeof(
int));
9204 memmove(&(strat->
lenSw[atS+1]), &(strat->
lenSw[atS]),
9207 for (
i=strat->
sl+1;
i>=atS+1;
i--)
9209 strat->
S[
i] = strat->
S[
i-1];
9217 for (
i=strat->
sl+1;
i>=atS+1;
i--)
9220 for (
i=strat->
sl+1;
i>=atS+1;
i--)
9226 #ifdef ENTER_USE_MEMMOVE
9227 memmove(&(strat->
fromQ[atS+1]), &(strat->
fromQ[atS]),
9228 (strat->
sl - atS + 1)*
sizeof(
int));
9230 for (
i=strat->
sl+1;
i>=atS+1;
i--)
9235 strat->
fromQ[atS]=0;
9239 strat->
S[atS] =
p.p;
9240 strat->
sig[atS] =
p.sig;
9246 strat->
sevS[atS] =
p.sev;
9256 strat->
sevSig[atS] =
p.sevSig;
9259 strat->
S_2_R[atS] = atR;
9263 Print(
"--- LIST S: %d ---\n",strat->
sl);
9264 for(
k=0;
k<=strat->
sl;
k++)
◆ enterSyz()
Definition at line 9452 of file kutil.cc.
9466 (strat->
syzmax)*
sizeof(
unsigned long),
9468 *
sizeof(
unsigned long));
9471 if (atT < strat->syzl)
9473 #ifdef ENTER_USE_MEMMOVE
9474 memmove(&(strat->
syz[atT+1]), &(strat->
syz[atT]),
9475 (strat->
syzl-atT+1)*
sizeof(poly));
9476 memmove(&(strat->
sevSyz[atT+1]), &(strat->
sevSyz[atT]),
9477 (strat->
syzl-atT+1)*
sizeof(
unsigned long));
9479 for (
i=strat->
syzl;
i>=atT+1;
i--)
9481 #ifndef ENTER_USE_MEMMOVE
9494 strat->
syz[atT] =
p.sig;
9495 strat->
sevSyz[atT] =
p.sevSig;
9498 Print(
"element in strat->syz: %d--%d ",atT+1,strat->
syzmax);
9508 strat->
L[cc].sig, ~strat->
L[cc].sevSig,
currRing)
9522 PrintS(
"--- Syzygies ---\n");
9525 PrintS(
"--------------------------------\n");
◆ enterT()
Definition at line 9269 of file kutil.cc.
9289 for(
i=strat->
tl;
i>=0;
i--)
9291 if (
p.p==strat->
T[
i].p)
9293 printf(
"already in T at pos %d of %d, atT=%d\n",
i,strat->
tl,atT);
9299 #ifdef HAVE_TAIL_RING
9302 p.t_p=
p.GetLmTailRing();
9308 if (strat->
tl == strat->
tmax-1)
9310 if (atT <= strat->tl)
9312 #ifdef ENTER_USE_MEMMOVE
9313 memmove(&(strat->
T[atT+1]), &(strat->
T[atT]),
9315 memmove(&(strat->
sevT[atT+1]), &(strat->
sevT[atT]),
9316 (strat->
tl-atT+1)*
sizeof(
unsigned long));
9318 for (
i=strat->
tl+1;
i>=atT+1;
i--)
9320 #ifndef ENTER_USE_MEMMOVE
9321 strat->
T[
i] = strat->
T[
i-1];
9324 strat->
R[strat->
T[
i].i_r] = &(strat->
T[
i]);
9342 strat->
T[atT].max_exp =
NULL;
◆ enterT_strong()
Definition at line 9350 of file kutil.cc.
9371 for(
i=strat->
tl;
i>=0;
i--)
9373 if (
p.p==strat->
T[
i].p)
9375 printf(
"already in T at pos %d of %d, atT=%d\n",
i,strat->
tl,atT);
9381 #ifdef HAVE_TAIL_RING
9384 p.t_p=
p.GetLmTailRing();
9390 if (strat->
tl == strat->
tmax-1)
9392 if (atT <= strat->tl)
9394 #ifdef ENTER_USE_MEMMOVE
9395 memmove(&(strat->
T[atT+1]), &(strat->
T[atT]),
9397 memmove(&(strat->
sevT[atT+1]), &(strat->
sevT[atT]),
9398 (strat->
tl-atT+1)*
sizeof(
unsigned long));
9400 for (
i=strat->
tl+1;
i>=atT+1;
i--)
9402 #ifndef ENTER_USE_MEMMOVE
9403 strat->
T[
i] = strat->
T[
i-1];
9406 strat->
R[strat->
T[
i].i_r] = &(strat->
T[
i]);
9424 strat->
T[atT].max_exp =
NULL;
9427 strat->
R[strat->
tl] = &(strat->
T[atT]);
9428 strat->
T[atT].i_r = strat->
tl;
9435 for(
i=strat->
tl;
i>=0;
i--)
◆ enterTShift()
◆ exitBuchMora()
◆ exitSba()
◆ f5c()
void f5c |
( |
kStrategy |
strat, |
|
|
int & |
olddeg, |
|
|
int & |
minimcnt, |
|
|
int & |
hilbeledeg, |
|
|
int & |
hilbcount, |
|
|
int & |
srmax, |
|
|
int & |
lrmax, |
|
|
int & |
reduc, |
|
|
ideal |
Q, |
|
|
intvec * |
w, |
|
|
intvec * |
hilb |
|
) |
| |
Definition at line 3540 of file kstd2.cc.
3546 int Ll_old, red_result = 1;
3552 reduc = olddeg = lrmax = 0;
3557 while (strat->
tl >= 0)
3559 if(!strat->
T[strat->
tl].is_redundant)
3562 h.p = strat->
T[strat->
tl].p;
3563 h.tailRing = strat->
T[strat->
tl].tailRing;
3564 h.t_p = strat->
T[strat->
tl].t_p;
3603 while (strat->
Ll>Ll_old)
3605 strat->
P = strat->
L[strat->
Ll];
3609 PrintS(
"NEXT PAIR TO HANDLE IN INTERRED ALGORITHM\n");
3610 PrintS(
"-------------------------------------------------\n");
3614 printf(
"%d\n",strat->
tl);
3615 PrintS(
"-------------------------------------------------\n");
3648 else if (strat->
P.p1 ==
NULL)
3650 if (strat->
minim > 0)
3657 if (strat->
P.p ==
NULL && strat->
P.t_p ==
NULL)
3665 &olddeg,&reduc,strat, red_result);
3668 PrintS(
"Poly before red: ");
3672 red_result = strat->red2(&strat->P,strat);
3676 if (strat->overflow)
3682 if (red_result == 1)
3685 strat->P.GetP(strat->lmBin);
3689 if (strat->homog) strat->initEcart(&(strat->P));
3696 pos =
posInS(strat,strat->sl,strat->P.p,strat->P.ecart);
3700 pos =
posInS(strat,strat->sl,strat->P.p,strat->P.ecart);
3709 strat->P.pCleardenom();
3712 strat->P.p =
redtailBba(&(strat->P),pos-1,strat, withT);
3713 strat->P.pCleardenom();
3720 strat->P.p =
redtailBba(&(strat->P),pos-1,strat, withT);
3728 if ((strat->P.p1==
NULL) && (strat->minim>0))
3730 if (strat->minim==1)
3732 strat->M->m[minimcnt]=
p_Copy(strat->P.p,
currRing,strat->tailRing);
3737 strat->M->m[minimcnt]=strat->P.p2;
3741 pNext(strat->M->m[minimcnt])
3742 = strat->p_shallow_copy_delete(
pNext(strat->M->m[minimcnt]),
3754 strat->enterS(strat->P, pos, strat, strat->tl);
3757 PrintS(
"ELEMENT ADDED TO GCURR DURING INTERRED: ");
3759 pWrite(strat->sig[strat->sl]);
3761 if (hilb!=
NULL)
khCheck(
Q,
w,hilb,hilbeledeg,hilbcount,strat);
3764 if (strat->P.lcm!=
NULL)
3770 if (strat->sl>srmax) srmax = strat->sl;
3779 if (strat->P.p1 ==
NULL && strat->minim > 0)
3786 memset(&(strat->P), 0,
sizeof(strat->P));
3790 while (cc<strat->tl+1)
3792 strat->T[cc].sig =
pOne();
3795 strat->sig[cc] = strat->T[cc].sig;
3796 strat->sevSig[cc] = strat->T[cc].sevSig;
3797 strat->T[cc].is_sigsafe =
TRUE;
3800 strat->max_lower_index = strat->tl;
3804 strat->currIdx = cc+1;
3805 for (
int cd=strat->Ll;
cd>=0;
cd--)
3810 for (cc=strat->sl+1; cc<
IDELEMS(strat->Shdl); ++cc)
3811 strat->Shdl->m[cc] =
NULL;
3813 printf(
"\nAfter f5c sorting\n");
3814 for(
int i=0;
i<=strat->sl;
i++)
3820 PrintS(
"------------------- STRAT S ---------------------\n");
3822 while (cc<strat->tl+1)
3826 printf(
"- - - - - -\n");
3829 PrintS(
"-------------------------------------------------\n");
3830 PrintS(
"------------------- STRAT T ---------------------\n");
3832 while (cc<strat->tl+1)
3835 pWrite(strat->T[cc].sig);
3836 printf(
"- - - - - -\n");
3839 PrintS(
"-------------------------------------------------\n");
3840 PrintS(
"------------------- STRAT L ---------------------\n");
3842 while (cc<strat->Ll+1)
3847 pWrite(strat->L[cc].sig);
3848 printf(
"- - - - - -\n");
3851 PrintS(
"-------------------------------------------------\n");
3852 printf(
"F5C DONE\nSTRAT SL: %d -- %d\n",strat->sl, strat->currIdx);
◆ faugereRewCriterion()
BOOLEAN faugereRewCriterion |
( |
poly |
sig, |
|
|
unsigned long |
not_sevSig, |
|
|
poly |
lm, |
|
|
kStrategy |
strat, |
|
|
int |
start |
|
) |
| |
Definition at line 7028 of file kutil.cc.
7036 PrintS(
"rewritten criterion checks: ");
7039 for(
int k = strat->
sl;
k>=start;
k--)
7043 PrintS(
"checking with: ");
7059 PrintS(
"ALL ELEMENTS OF S\n----------------------------------------\n");
7060 for(
int kk = 0; kk<strat->
sl+1; kk++)
7064 PrintS(
"------------------------------\n");
◆ finalReduceByMon()
used for GB over ZZ: final reduction by constant elements background: any known constant element of ideal suppresses intermediate coefficient swell and beautifies output
Definition at line 10962 of file kutil.cc.
10976 for(
int j = 0;
j<=strat->
sl;
j++)
10980 for(
int i = 0;
i<=strat->
sl;
i++)
10982 if((
i !=
j) && (strat->
S[
i] !=
NULL))
◆ findMinLMPair()
BOOLEAN findMinLMPair |
( |
poly |
sig, |
|
|
unsigned long |
not_sevSig, |
|
|
kStrategy |
strat, |
|
|
int |
start |
|
) |
| |
◆ freegb()
ideal freegb |
( |
ideal |
I, |
|
|
int |
uptodeg, |
|
|
int |
lVblock |
|
) |
| |
Definition at line 4230 of file kstd2.cc.
4244 WerrorS(
"The input ideal contains incorrectly encoded elements! ");
◆ HEckeTest()
◆ homogTest()
◆ ind2()
◆ ind_fact_2()
long ind_fact_2 |
( |
long |
arg | ) |
|
◆ initBba()
◆ initBbaShift()
◆ initBuchMora()
void initBuchMora |
( |
ideal |
F, |
|
|
ideal |
Q, |
|
|
kStrategy |
strat |
|
) |
| |
◆ initBuchMoraCrit()
Definition at line 9548 of file kutil.cc.
9567 #ifdef HAVE_RATGRING
◆ initBuchMoraPos()
◆ initBuchMoraPosRing()
◆ initBuchMoraShift()
void initBuchMoraShift |
( |
ideal |
F, |
|
|
ideal |
Q, |
|
|
kStrategy |
strat |
|
) |
| |
◆ initEcartBBA()
◆ initEcartNormal()
void initEcartNormal |
( |
TObject * |
h | ) |
|
Definition at line 1238 of file kutil.cc.
1241 h->FDeg =
h->pFDeg();
1242 h->ecart =
h->pLDeg() -
h->FDeg;
◆ initEcartPairBba()
void initEcartPairBba |
( |
LObject * |
Lp, |
|
|
poly |
f, |
|
|
poly |
g, |
|
|
int |
ecartF, |
|
|
int |
ecartG |
|
) |
| |
Definition at line 1253 of file kutil.cc.
1256 Lp->FDeg = Lp->pFDeg();
◆ initEcartPairMora()
void initEcartPairMora |
( |
LObject * |
Lp, |
|
|
poly |
f, |
|
|
poly |
g, |
|
|
int |
ecartF, |
|
|
int |
ecartG |
|
) |
| |
Definition at line 1260 of file kutil.cc.
1263 Lp->FDeg = Lp->pFDeg();
1264 (*Lp).ecart =
si_max(ecartF,ecartG);
1265 (*Lp).ecart = (*Lp).ecart- (Lp->FDeg -
p_FDeg((*Lp).lcm,
currRing));
◆ initHilbCrit()
◆ initL()
◆ initR()
◆ initS()
void initS |
( |
ideal |
F, |
|
|
ideal |
Q, |
|
|
kStrategy |
strat |
|
) |
| |
Definition at line 7846 of file kutil.cc.
7859 strat->
S=strat->
Shdl->m;
7864 memset(strat->
fromQ,0,
i*
sizeof(
int));
7893 strat->
enterS(
h,pos,strat,-1);
7894 strat->
fromQ[pos]=1;
7927 strat->
enterS(
h,pos,strat,-1);
◆ initSba()
◆ initSbaBuchMora()
void initSbaBuchMora |
( |
ideal |
F, |
|
|
ideal |
Q, |
|
|
kStrategy |
strat |
|
) |
| |
◆ initSbaCrit()
Definition at line 9612 of file kutil.cc.
9644 #ifdef HAVE_RATGRING
◆ initSbaPos()
◆ initsevT()
KINLINE unsigned long* initsevT |
( |
| ) |
|
◆ initSL()
void initSL |
( |
ideal |
F, |
|
|
ideal |
Q, |
|
|
kStrategy |
strat |
|
) |
| |
Definition at line 7940 of file kutil.cc.
7953 strat->
S=strat->
Shdl->m;
7958 memset(strat->
fromQ,0,
i*
sizeof(
int));
7987 strat->
enterS(
h,pos,strat,-1);
7988 strat->
fromQ[pos]=1;
8020 pos = strat->
posInL(strat->
L,strat->
Ll,&
h,strat);
◆ initSLSba()
void initSLSba |
( |
ideal |
F, |
|
|
ideal |
Q, |
|
|
kStrategy |
strat |
|
) |
| |
Definition at line 8037 of file kutil.cc.
8050 strat->
S = strat->
Shdl->m;
8063 memset(strat->
fromQ,0,
i*
sizeof(
int));
8092 strat->
enterS(
h,pos,strat,-1);
8093 strat->
fromQ[pos]=1;
◆ initSyzRules()
Definition at line 8187 of file kutil.cc.
8203 for(
i=1;
i<=strat->
sl;
i++)
8215 strat->
syz = (poly *)
omAlloc(ps*
sizeof(poly));
8219 #if defined(DEBUGF5) || defined(DEBUGF51)
8220 PrintS(
"------------- GENERATING SYZ RULES NEW ---------------\n");
8227 while (i <= strat->sl)
8257 for (
k = 0;
k<
i;
k++)
8301 for (
k = 0;
k<strat->
sl+1;
k++)
8322 PrintS(
"Principal syzygies:\n");
8325 Print(
"ps %d\n",ps);
8326 PrintS(
"--------------------------------\n");
◆ initT()
◆ k_GetLeadTerms()
Definition at line 933 of file kInline.h.
947 m1 =
p_Init(m_r,m_r->PolyBin);
948 m2 =
p_Init(m_r,m_r->PolyBin);
950 for (
i = p_r->N;
i;
i--)
955 if (
x > (
long) m_r->bitmask)
goto false_return;
961 if (-
x > (
long) m_r->bitmask)
goto false_return;
◆ k_GetStrongLeadTerms()
KINLINE void k_GetStrongLeadTerms |
( |
const poly |
p1, |
|
|
const poly |
p2, |
|
|
const ring |
leadRing, |
|
|
poly & |
m1, |
|
|
poly & |
m2, |
|
|
poly & |
lcm, |
|
|
const ring |
taiRing |
|
) |
| |
Definition at line 976 of file kInline.h.
993 m1 =
p_Init(tailRing,tailRing->PolyBin);
994 m2 =
p_Init(tailRing,tailRing->PolyBin);
995 lcm =
p_Init(leadRing,leadRing->PolyBin);
997 for (
i = leadRing->N;
i>=0;
i--)
◆ k_LmInit_currRing_2_tailRing() [1/2]
KINLINE poly k_LmInit_currRing_2_tailRing |
( |
poly |
p, |
|
|
ring |
tailRing |
|
) |
| |
◆ k_LmInit_currRing_2_tailRing() [2/2]
KINLINE poly k_LmInit_currRing_2_tailRing |
( |
poly |
p, |
|
|
ring |
tailRing, |
|
|
omBin |
bin |
|
) |
| |
◆ k_LmInit_tailRing_2_currRing() [1/2]
KINLINE poly k_LmInit_tailRing_2_currRing |
( |
poly |
p, |
|
|
ring |
tailRing |
|
) |
| |
◆ k_LmInit_tailRing_2_currRing() [2/2]
KINLINE poly k_LmInit_tailRing_2_currRing |
( |
poly |
p, |
|
|
ring |
tailRing, |
|
|
omBin |
bin |
|
) |
| |
◆ k_LmShallowCopyDelete_currRing_2_tailRing() [1/2]
KINLINE poly k_LmShallowCopyDelete_currRing_2_tailRing |
( |
poly |
p, |
|
|
ring |
tailRing |
|
) |
| |
◆ k_LmShallowCopyDelete_currRing_2_tailRing() [2/2]
KINLINE poly k_LmShallowCopyDelete_currRing_2_tailRing |
( |
poly |
p, |
|
|
ring |
tailRing, |
|
|
omBin |
bin |
|
) |
| |
◆ k_LmShallowCopyDelete_tailRing_2_currRing() [1/2]
KINLINE poly k_LmShallowCopyDelete_tailRing_2_currRing |
( |
poly |
p, |
|
|
ring |
tailRing |
|
) |
| |
◆ k_LmShallowCopyDelete_tailRing_2_currRing() [2/2]
KINLINE poly k_LmShallowCopyDelete_tailRing_2_currRing |
( |
poly |
p, |
|
|
ring |
tailRing, |
|
|
omBin |
bin |
|
) |
| |
◆ kCheckSpolyCreation()
Definition at line 10577 of file kutil.cc.
10590 assume(L->i_r1 >= -1 && L->i_r1 <= strat->
tl);
10591 assume(L->i_r2 >= -1 && L->i_r2 <= strat->
tl);
10597 if ((L->i_r1 == -1) || (L->i_r2 == -1) )
10601 poly p1_max = (strat->
R[L->i_r1])->max_exp;
10602 poly p2_max = (strat->
R[L->i_r2])->max_exp;
◆ kCheckStrongCreation()
BOOLEAN kCheckStrongCreation |
( |
int |
atR, |
|
|
poly |
m1, |
|
|
int |
atS, |
|
|
poly |
m2, |
|
|
kStrategy |
strat |
|
) |
| |
Definition at line 10614 of file kutil.cc.
10628 poly p1_max = (strat->
R[atR])->max_exp;
◆ kCreateZeroPoly()
poly kCreateZeroPoly |
( |
long |
exp[], |
|
|
long |
cabsind, |
|
|
poly * |
t_p, |
|
|
ring |
leadRing, |
|
|
ring |
tailRing |
|
) |
| |
Definition at line 4259 of file kutil.cc.
4263 poly zeroPoly =
NULL;
4271 for (
int i = 1;
i <= leadRing->N;
i++)
4277 if (cabsind < leadRing->ch)
4279 zeroPoly =
p_ISet(
twoPow(leadRing->ch - cabsind), tailRing);
4283 zeroPoly =
p_ISet(1, tailRing);
4285 for (
int i = 1;
i <= leadRing->N;
i++)
4287 for (
long j = 1;
j <=
exp[
i];
j++)
4305 for (
int i = 1;
i <= leadRing->N;
i++)
4311 zeroPoly =
pNext(zeroPoly);
◆ kDebugPrint()
Output some debug info about a given strategy.
Definition at line 11574 of file kutil.cc.
11590 else Print(
"%p\n",(
void*)strat->
red);
11609 #ifdef HAVE_MORE_POS_IN_T
11647 PrintS(
"initEcartPair: ");
11651 Print(
"homog=%d, LazyDegree=%d, LazyPass=%d, ak=%d,\n",
11653 Print(
"honey=%d, sugarCrit=%d, Gebauer=%d, noTailReduction=%d, use_buckets=%d\n",
11659 Print(
"posInLDependsOnLength=%d\n",
11691 PrintS(
"currRing->pFDeg: ");
11706 PrintS(
"ecartWeights: ");
◆ kFindDivisibleByInS()
return -1 if no divisor is found number of first divisor in S, otherwise
Definition at line 196 of file kstd2.cc.
198 unsigned long not_sev = ~L->sev;
199 poly
p = L->GetLmCurrRing();
213 ende=
posInS(strat,*max_ind,
p,0)+1;
214 if (ende>(*max_ind)) ende=(*max_ind);
223 if (
j > ende)
return -1;
224 #if defined(PDEBUG) || defined(PDIV_DEBUG)
232 if ( !(strat->
sevS[
j] & not_sev) &&
246 if (
j > ende)
return -1;
247 #if defined(PDEBUG) || defined(PDIV_DEBUG)
254 if ( !(strat->
sevS[
j] & not_sev) &&
◆ kFindDivisibleByInS_T()
Definition at line 7161 of file kutil.cc.
7166 const unsigned long not_sev = ~L->sev;
7167 const unsigned long* sev = strat->
sevS;
7180 if (
j > end_pos)
return NULL;
7181 #if defined(PDEBUG) || defined(PDIV_DEBUG)
7183 (ecart== LONG_MAX || ecart>= strat->
ecartS[
j]))
7188 if (!(sev[
j] & not_sev) &&
7189 (ecart== LONG_MAX || ecart>= strat->
ecartS[
j]) &&
7203 if (
j > end_pos)
return NULL;
7204 #if defined(PDEBUG) || defined(PDIV_DEBUG)
7211 if (!(sev[
j] & not_sev) &&
7212 (ecart== LONG_MAX || ecart>= strat->
ecartS[
j]) &&
7223 if (strat->
tl < 0 || strat->
S_2_R[
j] == -1)
7244 if (
j > end_pos)
return NULL;
7246 #if defined(PDEBUG) || defined(PDIV_DEBUG)
7250 (ecart== LONG_MAX || ecart>= strat->
ecartS[
j]))
7256 if (! (sev[
j] & not_sev) && (ecart== LONG_MAX || ecart>= strat->
ecartS[
j]))
7259 assume(t !=
NULL && t->t_p !=
NULL && t->tailRing == r && t->p == strat->
S[
j]);
7275 if (
j > end_pos)
return NULL;
7277 #if defined(PDEBUG) || defined(PDIV_DEBUG)
7287 if (! (sev[
j] & not_sev) && (ecart== LONG_MAX || ecart>= strat->
ecartS[
j]))
7290 assume(t !=
NULL && t->t_p !=
NULL && t->tailRing == r && t->p == strat->
S[
j]);
◆ kFindDivisibleByInT()
return -1 if no divisor is found number of first divisor in T, otherwise
Definition at line 86 of file kstd2.cc.
88 unsigned long not_sev = ~L->sev;
92 const unsigned long* sevT=strat->
sevT;
105 if (
j > strat->
tl)
return -1;
106 #if defined(PDEBUG) || defined(PDIV_DEBUG)
113 if (!(sevT[
j] & not_sev) &&
127 if (
j > strat->
tl)
return -1;
128 #if defined(PDEBUG) || defined(PDIV_DEBUG)
134 if (!(sevT[
j] & not_sev) &&
152 if (
j > strat->
tl)
return -1;
153 #if defined(PDEBUG) || defined(PDIV_DEBUG)
161 if (!(sevT[
j] & not_sev) &&
175 if (
j > strat->
tl)
return -1;
176 #if defined(PDEBUG) || defined(PDIV_DEBUG)
183 if (!(sevT[
j] & not_sev) &&
◆ kFindInT()
int kFindInT |
( |
poly |
p, |
|
|
TSet |
T, |
|
|
int |
tlength |
|
) |
| |
returns index of p in TSet, or -1 if not found
Definition at line 703 of file kutil.cc.
708 for (
i=0;
i<=tlength;
i++)
710 if (
T[
i].
p ==
p)
return i;
◆ kFindNextDivisibleByInS()
Definition at line 265 of file kstd2.cc.
267 unsigned long not_sev = ~L->sev;
268 poly
p = L->GetLmCurrRing();
281 if (
j > ende)
return -1;
282 #if defined(PDEBUG) || defined(PDIV_DEBUG)
290 if ( !(strat->
sevS[
j] & not_sev) &&
304 if (
j > ende)
return -1;
305 #if defined(PDEBUG) || defined(PDIV_DEBUG)
312 if ( !(strat->
sevS[
j] & not_sev) &&
◆ kFindZeroPoly()
poly kFindZeroPoly |
( |
poly |
input_p, |
|
|
ring |
leadRing, |
|
|
ring |
tailRing |
|
) |
| |
Definition at line 324 of file kstd2.cc.
331 poly zeroPoly =
NULL;
332 unsigned long a = (
unsigned long)
pGetCoeff(
p);
335 int a_ind2 =
ind2(a);
339 for (
int i = 1;
i <= leadRing->N;
i++)
348 poly lead_mult =
p_ISet(1, tailRing);
349 if (
n_GetChar(leadRing->cf) <= k_ind2 + a_ind2)
351 int too_much = k_ind2 + a_ind2 -
n_GetChar(leadRing->cf);
353 zeroPoly =
p_ISet(a, tailRing);
354 for (
int i = 1;
i <= leadRing->N;
i++)
361 while ( (0 <
ind2(s_exp)) && (
ind2(s_exp) <= too_much) )
363 too_much = too_much -
ind2(s_exp);
367 for (
int j = 1;
j <= s_exp;
j++)
384 p_Setm(lead_mult, tailRing);
385 zeroPoly =
p_Mult_mm(zeroPoly, lead_mult, tailRing);
387 for (
int i = 1;
i <= leadRing->N;
i++)
◆ kFreeStrat()
◆ kNF2() [1/2]
ideal kNF2 |
( |
ideal |
F, |
|
|
ideal |
Q, |
|
|
ideal |
q, |
|
|
kStrategy |
strat, |
|
|
int |
lazyReduce |
|
) |
| |
◆ kNF2() [2/2]
poly kNF2 |
( |
ideal |
F, |
|
|
ideal |
Q, |
|
|
poly |
q, |
|
|
kStrategy |
strat, |
|
|
int |
lazyReduce |
|
) |
| |
◆ kNF2Bound() [1/2]
ideal kNF2Bound |
( |
ideal |
F, |
|
|
ideal |
Q, |
|
|
ideal |
q, |
|
|
int |
bound, |
|
|
kStrategy |
strat, |
|
|
int |
lazyReduce |
|
) |
| |
◆ kNF2Bound() [2/2]
poly kNF2Bound |
( |
ideal |
F, |
|
|
ideal |
Q, |
|
|
poly |
q, |
|
|
int |
bound, |
|
|
kStrategy |
strat, |
|
|
int |
lazyReduce |
|
) |
| |
◆ ksCreateShortSpoly()
poly ksCreateShortSpoly |
( |
poly |
p1, |
|
|
poly |
p2, |
|
|
ring |
tailRing |
|
) |
| |
Definition at line 998 of file kspoly.cc.
1000 * 1. the coefficient is 0 (
p_Init)
1001 * 1. a) in the
case of coefficient ring, the coefficient is calculated
1002 * 2.
pNext is undefined
1056 if ((c1==c2)||(c2!=0))
1106 if ((c1==c2)||(c1!=0))
◆ ksCreateSpoly()
Definition at line 753 of file kspoly.cc.
769 Pair->tailRing = tailRing;
809 if (Pair->i_r1 == -1)
815 l1 = (
R[Pair->i_r1])->GetpLength() - 1;
817 if ((Pair->i_r2 == -1)||(
R[Pair->i_r2]==
NULL))
823 l2 = (
R[Pair->i_r2])->GetpLength() - 1;
828 if (spNoether !=
NULL)
831 a2 = tailRing->p_Procs->pp_Mult_mm_Noether(a2, m2, spNoether, l2, tailRing);
835 a2 = tailRing->p_Procs->pp_Mult_mm(a2, m2, tailRing);
840 Pair->SetLmTail(m2, a2, l2, use_buckets, tailRing);
843 Pair->Tail_Minus_mm_Mult_qq(m1, a1, l1, spNoether);
846 Pair->LmDeleteAndIter();
862 #ifdef HAVE_SHIFTBBA_NONEXISTENT
◆ ksOldCreateSpoly()
◆ ksOldSpolyRed()
KINLINE poly ksOldSpolyRed |
( |
poly |
p1, |
|
|
poly |
p2, |
|
|
poly |
spNoether = NULL |
|
) |
| |
◆ ksOldSpolyRedNew()
KINLINE poly ksOldSpolyRedNew |
( |
poly |
p1, |
|
|
poly |
p2, |
|
|
poly |
spNoether = NULL |
|
) |
| |
◆ ksOldSpolyTail()
KINLINE void ksOldSpolyTail |
( |
poly |
p1, |
|
|
poly |
q, |
|
|
poly |
q2, |
|
|
poly |
spNoether, |
|
|
ring |
r = currRing |
|
) |
| |
◆ ksReducePoly()
Definition at line 39 of file kspoly.cc.
49 #ifdef TEST_OPT_DEBUG_RED
60 ring tailRing = PR->tailRing;
64 poly p1 = PR->GetLmTailRing();
65 poly p2 = PW->GetLmTailRing();
66 poly t2 =
pNext(p2), lm = p1;
87 poly _p = (PR->t_p !=
NULL ? PR->t_p : PR->p);
90 if (PR->t_p!=
NULL) PR->t_p=_p;
else PR->p=_p;
99 PR->LmDeleteAndIter();
100 if (coef !=
NULL) *coef =
n_Init(1, tailRing->cf);
113 if (strat ==
NULL)
return 2;
116 p1 = PR->GetLmTailRing();
117 p2 = PW->GetLmTailRing();
132 if ((ct == 0) || (ct == 2))
133 PR->Tail_Mult_nn(an);
134 if (coef !=
NULL) *coef = an;
139 if (coef !=
NULL) *coef =
n_Init(1, tailRing->cf);
144 PR->Tail_Minus_mm_Mult_qq(lm, t2,
pLength(t2) , spNoether);
146 PR->LmDeleteAndIter();
149 #ifdef HAVE_SHIFTBBA_NONEXISTENT
158 PR->SetShortExpVector();
162 #if defined(KDEBUG) && defined(TEST_OPT_DEBUG_RED)
◆ ksReducePolyBound()
Definition at line 170 of file kspoly.cc.
181 #ifdef TEST_OPT_DEBUG_RED
192 ring tailRing = PR->tailRing;
196 poly p1 = PR->GetLmTailRing();
197 poly p2 = PW->GetLmTailRing();
198 poly t2 =
pNext(p2), lm = p1;
219 poly _p = (PR->t_p !=
NULL ? PR->t_p : PR->p);
222 if (PR->t_p!=
NULL) PR->t_p=_p;
else PR->p=_p;
231 PR->LmDeleteAndIter();
232 if (coef !=
NULL) *coef =
n_Init(1, tailRing);
245 if (strat ==
NULL)
return 2;
248 p1 = PR->GetLmTailRing();
249 p2 = PW->GetLmTailRing();
264 if ((ct == 0) || (ct == 2))
265 PR->Tail_Mult_nn(an);
266 if (coef !=
NULL) *coef = an;
271 if (coef !=
NULL) *coef =
n_Init(1, tailRing);
276 PR->Tail_Minus_mm_Mult_qq(lm, t2,
pLength(t2) , spNoether);
278 PR->LmDeleteAndIter();
281 #ifdef HAVE_SHIFTBBA_NONEXISTENT
290 PR->SetShortExpVector();
294 #if defined(KDEBUG) && defined(TEST_OPT_DEBUG_RED)
◆ ksReducePolySig()
Definition at line 308 of file kspoly.cc.
320 #ifdef TEST_OPT_DEBUG_RED
329 ring tailRing = PR->tailRing;
363 poly sigMult =
pCopy(PW->sig);
366 printf(
"IN KSREDUCEPOLYSIG: \n");
370 printf(
"--------------\n");
375 printf(
"------------------- IN KSREDUCEPOLYSIG: --------------------\n");
380 printf(
"--------------\n");
387 printf(
"%d -- %d sig\n",sigSafe,PW->is_sigsafe);
396 PR->is_redundant =
TRUE;
401 PR->is_redundant =
FALSE;
402 poly p1 = PR->GetLmTailRing();
403 poly p2 = PW->GetLmTailRing();
404 poly t2 =
pNext(p2), lm = p1;
425 poly _p = (PR->t_p !=
NULL ? PR->t_p : PR->p);
428 if (PR->t_p!=
NULL) PR->t_p=_p;
else PR->p=_p;
437 PR->LmDeleteAndIter();
438 if (coef !=
NULL) *coef =
n_Init(1, tailRing->cf);
451 if (strat ==
NULL)
return 2;
454 p1 = PR->GetLmTailRing();
455 p2 = PW->GetLmTailRing();
470 if ((ct == 0) || (ct == 2))
471 PR->Tail_Mult_nn(an);
472 if (coef !=
NULL) *coef = an;
477 if (coef !=
NULL) *coef =
n_Init(1, tailRing->cf);
482 PR->Tail_Minus_mm_Mult_qq(lm, t2, PW->GetpLength() - 1, spNoether);
484 PR->LmDeleteAndIter();
487 #ifdef HAVE_SHIFTBBA_NONEXISTENT
496 PR->SetShortExpVector();
500 #if defined(KDEBUG) && defined(TEST_OPT_DEBUG_RED)
◆ ksReducePolySigRing()
Definition at line 505 of file kspoly.cc.
518 #ifdef TEST_OPT_DEBUG_RED
527 ring tailRing = PR->tailRing;
561 poly sigMult =
pCopy(PW->sig);
564 printf(
"IN KSREDUCEPOLYSIG: \n");
568 printf(
"--------------\n");
582 printf(
"------------------- IN KSREDUCEPOLYSIG: --------------------\n");
587 printf(
"--------------\n");
596 printf(
"%d -- %d sig\n",sigSafe,PW->is_sigsafe);
602 poly origsig =
pCopy(PR->sig);
613 if(
pLtCmp(PR->sig,origsig) == 1)
617 PR->is_redundant =
TRUE;
623 if(
pLtCmp(PR->sig,origsig) == -1)
635 PR->is_redundant =
TRUE;
640 PR->is_redundant =
FALSE;
641 poly p1 = PR->GetLmTailRing();
642 poly p2 = PW->GetLmTailRing();
643 poly t2 =
pNext(p2), lm = p1;
664 poly _p = (PR->t_p !=
NULL ? PR->t_p : PR->p);
667 if (PR->t_p!=
NULL) PR->t_p=_p;
else PR->p=_p;
676 PR->LmDeleteAndIter();
677 if (coef !=
NULL) *coef =
n_Init(1, tailRing->cf);
690 if (strat ==
NULL)
return 2;
693 p1 = PR->GetLmTailRing();
694 p2 = PW->GetLmTailRing();
705 if (coef !=
NULL) *coef =
n_Init(1, tailRing->cf);
715 if (((ct == 0) || (ct == 2)))
716 PR->Tail_Mult_nn(an);
717 if (coef !=
NULL) *coef = an;
722 if (coef !=
NULL) *coef =
n_Init(1, tailRing->cf);
727 PR->Tail_Minus_mm_Mult_qq(lm, t2, PW->GetpLength() - 1, spNoether);
729 PR->LmDeleteAndIter();
732 #ifdef HAVE_SHIFTBBA_NONEXISTENT
741 PR->SetShortExpVector();
744 #if defined(KDEBUG) && defined(TEST_OPT_DEBUG_RED)
◆ ksReducePolyTail() [1/2]
Definition at line 1023 of file kInline.h.
1035 assume(PR->GetLmCurrRing() != PW->GetLmCurrRing());
1036 Red->HeadNormalize();
◆ ksReducePolyTail() [2/2]
Definition at line 871 of file kspoly.cc.
881 poly Lp = PR->GetLmCurrRing();
882 poly Save = PW->GetLmCurrRing();
902 if (Current == PR->p && PR->t_p !=
NULL)
908 pNext(Current) = Red.GetLmTailRing();
909 if (Current == PR->p && PR->t_p !=
NULL)
917 #ifdef HAVE_SHIFTBBA_NONEXISTENT
◆ kStratChangeTailRing()
Definition at line 11028 of file kutil.cc.
11042 if (expbound == 0) expbound = strat->
tailRing->bitmask << 1;
11059 new_tailRing->pFDeg =
currRing->pFDeg;
11060 new_tailRing->pLDeg =
currRing->pLDeg;
11064 Print(
"[%lu:%d", (
unsigned long) new_tailRing->bitmask, new_tailRing->ExpL_Size);
11073 for (
i=0;
i<=strat->
tl;
i++)
11075 strat->
T[
i].ShallowCopyDelete(new_tailRing, new_tailBin,
11076 p_shallow_copy_delete);
11078 for (
i=0;
i<=strat->
Ll;
i++)
11082 strat->
L[
i].ShallowCopyDelete(new_tailRing, p_shallow_copy_delete);
11084 if ((strat->
P.t_p !=
NULL) ||
11086 strat->
P.ShallowCopyDelete(new_tailRing, p_shallow_copy_delete);
11088 if ((L !=
NULL) && (L->tailRing != new_tailRing))
11091 L->ShallowCopyDelete(new_tailRing, p_shallow_copy_delete);
11097 L->tailRing = new_tailRing;
11100 L->max_exp = t_l->max_exp;
11104 if ((
T !=
NULL) && (
T->tailRing != new_tailRing &&
T->i_r < 0))
11105 T->ShallowCopyDelete(new_tailRing, new_tailBin, p_shallow_copy_delete);
11112 strat->
tailBin = new_tailBin;
◆ kStratInitChangeTailRing()
void kStratInitChangeTailRing |
( |
kStrategy |
strat | ) |
|
Definition at line 11127 of file kutil.cc.
11138 unsigned long l = 0;
11144 for (
i=0;
i<= strat->
Ll;
i++)
11148 for (
i=0;
i<=strat->
tl;
i++)
◆ message()
void message |
( |
int |
i, |
|
|
int * |
reduc, |
|
|
int * |
olddeg, |
|
|
kStrategy |
strat, |
|
|
int |
red_result |
|
) |
| |
Definition at line 7727 of file kutil.cc.
7738 if (strat->
Ll != *reduc)
7740 if (strat->
Ll != *reduc-1)
7752 if (red_result == 0)
7754 else if (red_result < 0)
7756 if ((red_result > 0) || ((strat->
Ll % 100)==99))
7758 if (strat->
Ll != *reduc && strat->
Ll > 0)
◆ messageStat()
void messageStat |
( |
int |
hilbcount, |
|
|
kStrategy |
strat |
|
) |
| |
Definition at line 7768 of file kutil.cc.
7775 Print(
"product criterion:%d chain criterion:%d\n",strat->
cp,strat->
c3);
7776 if (hilbcount!=0)
Print(
"hilbert series criterion:%d\n",hilbcount);
7778 if (strat->
cv!=0)
Print(
"shift V criterion:%d\n",strat->
cv);
◆ messageStatSBA()
void messageStatSBA |
( |
int |
hilbcount, |
|
|
kStrategy |
strat |
|
) |
| |
Definition at line 7780 of file kutil.cc.
7789 if (hilbcount!=0)
Print(
"hilbert series criterion:%d\n",hilbcount);
7791 if (strat->
cv!=0)
Print(
"shift V criterion:%d\n",strat->
cv);
◆ newHEdge()
◆ pairs()
◆ pCopyL2p()
Definition at line 11741 of file kutil.cc.
11749 #ifdef HAVE_SHIFTBBA
◆ pMove2CurrTail()
poly pMove2CurrTail |
( |
poly |
p, |
|
|
kStrategy |
strat |
|
) |
| |
◆ pMoveCurrTail2poly()
poly pMoveCurrTail2poly |
( |
poly |
p, |
|
|
kStrategy |
strat |
|
) |
| |
Definition at line 11724 of file kutil.cc.
11732 #ifdef HAVE_SHIFTBBA
◆ posInIdealMonFirst()
int posInIdealMonFirst |
( |
const ideal |
F, |
|
|
const poly |
p, |
|
|
int |
start = 0 , |
|
|
int |
end = -1 |
|
) |
| |
Definition at line 5112 of file kutil.cc.
5115 if(end < 0 || end >=
IDELEMS(F))
5117 if (end<0)
return 0;
5124 for(
i=start;
i<end;
i++)
5138 || ((op == o) && (
pLtCmp(set[an],
p) == -1)))
5145 || ((op == o) && (
pLtCmp(set[
i],
p) == -1)))
◆ posInL0()
◆ posInL10()
Definition at line 1009 of file kstd1.cc.
1017 int op=
p->GetpFDeg() +
p->ecart;
1025 && (set[
j].GetpFDeg()+set[
j].ecart >= op))
◆ posInL10Ring()
◆ posInL11()
Definition at line 6222 of file kutil.cc.
6228 int o =
p->GetpFDeg();
6229 int op = set[
length].GetpFDeg();
6241 op = set[an].GetpFDeg();
6248 op = set[
i].GetpFDeg();
◆ posInL110()
Definition at line 6520 of file kutil.cc.
6526 int o =
p->GetpFDeg();
6527 int op = set[
length].GetpFDeg();
6531 || ((op == o) && (set[
length].length <=
p->length)
6541 op = set[an].GetpFDeg();
6543 || ((op == o) && (set[an].
length >
p->length))
6544 || ((op == o) && (set[an].length <=
p->length)
6550 op = set[
i].GetpFDeg();
6552 || ((op == o) && (set[
i].
length >
p->length))
6553 || ((op == o) && (set[
i].length <=
p->length)
◆ posInL11Ring()
Definition at line 6264 of file kutil.cc.
6270 int o =
p->GetpFDeg();
6271 int op = set[
length].GetpFDeg();
6283 op = set[an].GetpFDeg();
6290 op = set[
i].GetpFDeg();
◆ posInL11Ringls()
Definition at line 6334 of file kutil.cc.
6338 if (
length < 0)
return 0;
6348 if (set[an].FDeg >
p->FDeg)
6350 if (set[an].FDeg < p->FDeg)
6352 if (set[an].FDeg ==
p->FDeg)
6360 if (set[an].t_p!=
NULL)
6382 if (set[
i].FDeg >
p->FDeg)
6384 if (set[
i].FDeg < p->FDeg)
6386 if (set[
i].FDeg ==
p->FDeg)
6394 if (set[
i].t_p!=
NULL)
◆ posInL13()
Definition at line 6608 of file kutil.cc.
6614 int o =
p->GetpFDeg();
6616 if (set[
length].GetpFDeg() > o)
6626 if (set[an].GetpFDeg() >= o)
6631 if (set[
i].GetpFDeg() >= o)
◆ posInL15()
Definition at line 6643 of file kutil.cc.
6649 int o =
p->GetpFDeg() +
p->ecart;
6662 op = set[an].GetpFDeg() + set[an].ecart;
6669 op = set[
i].GetpFDeg() + set[
i].ecart;
◆ posInL15Ring()
Definition at line 6678 of file kutil.cc.
6684 int o =
p->GetpFDeg() +
p->ecart;
6697 op = set[an].GetpFDeg() + set[an].ecart;
6704 op = set[
i].GetpFDeg() + set[
i].ecart;
◆ posInL17()
Definition at line 6719 of file kutil.cc.
6725 int o =
p->GetpFDeg() +
p->ecart;
6729 && (set[
length].ecart >
p->ecart))
6731 && (set[
length].ecart ==
p->ecart)
6741 if ((set[an].GetpFDeg() + set[an].ecart > o)
6742 || ((set[an].GetpFDeg() + set[an].ecart == o)
6743 && (set[an].ecart >
p->ecart))
6744 || ((set[an].GetpFDeg() + set[an].ecart == o)
6745 && (set[an].ecart ==
p->ecart)
6751 if ((set[
i].GetpFDeg() + set[
i].ecart > o)
6752 || ((set[
i].GetpFDeg() + set[
i].ecart == o)
6753 && (set[
i].ecart >
p->ecart))
6754 || ((set[
i].GetpFDeg() +set[
i].ecart == o)
6755 && (set[
i].ecart ==
p->ecart)
◆ posInLF5C()
◆ posInLF5CRing()
Definition at line 6298 of file kutil.cc.
6304 int o =
p->GetpFDeg();
6305 int op = set[
length].GetpFDeg();
6317 op = set[an].GetpFDeg();
6324 op = set[
i].GetpFDeg();
◆ posInLRing()
Definition at line 6109 of file kutil.cc.
6113 if (
length < 0)
return 0;
6114 if (set[
length].FDeg >
p->FDeg)
6116 if (set[
length].FDeg ==
p->FDeg)
6117 if(set[
length].GetpLength() >
p->GetpLength())
6128 if (set[an].FDeg >
p->FDeg)
6130 if(set[an].FDeg ==
p->FDeg)
6132 if(set[an].GetpLength() >
p->GetpLength())
6136 if(set[an].GetpLength() ==
p->GetpLength())
6153 if (set[
i].FDeg >
p->FDeg)
6157 if(set[
i].FDeg ==
p->FDeg)
6159 if(set[
i].GetpLength() >
p->GetpLength())
6163 if(set[
i].GetpLength() ==
p->GetpLength())
◆ posInLSig()
◆ posInLSigRing()
Definition at line 6046 of file kutil.cc.
6065 cmp =
pLtCmp(set[an].sig,
p->sig);
6072 if (set[an].FDeg >
p->FDeg)
6074 if (set[an].FDeg < p->FDeg)
6076 if (set[an].FDeg ==
p->FDeg)
6094 if (set[
i].FDeg >
p->FDeg)
6096 if (set[
i].FDeg < p->FDeg)
6098 if (set[
i].FDeg ==
p->FDeg)
◆ posInS()
Definition at line 4934 of file kutil.cc.
4987 if (cmp == cmp_int)
return an;
4988 if (cmp == -cmp_int)
return en;
4994 if (cmp == cmp_int) en =
i;
4995 else if (cmp == -cmp_int) an =
i;
5011 if (
pLmCmp(set[an],
p) == cmp_int)
return an;
5012 if (
pLmCmp(set[an],
p) == -cmp_int)
return en;
5014 && ((strat->
ecartS[an])>ecart_p))
5020 else if (
pLmCmp(set[
i],
p) == -cmp_int) an=
i;
5024 &&((strat->
ecartS[
i])<ecart_p))
◆ posInSMonFirst()
Definition at line 5035 of file kutil.cc.
5052 || ((op == o) && (
pLtCmp(set[mon],
p) == -1)))
5063 || ((op == o) && (
pLtCmp(set[an],
p) == -1)))
5070 || ((op == o) && (
pLtCmp(set[
i],
p) == -1)))
5096 || ((op == o) && (
pLtCmp(set[an],
p) == -1)))
5103 || ((op == o) && (
pLtCmp(set[
i],
p) == -1)))
◆ posInSyz()
Definition at line 6182 of file kutil.cc.
6185 if (strat->
syzl==0)
return 0;
6190 int en= strat->
syzl-1;
◆ posInT0()
◆ posInT1()
◆ posInT11()
Definition at line 5225 of file kutil.cc.
5228 if (
length==-1)
return 0;
5230 int o =
p.GetpFDeg();
5231 int op = set[
length].GetpFDeg();
5245 op= set[an].GetpFDeg();
5252 op = set[
i].GetpFDeg();
◆ posInT110()
Definition at line 5378 of file kutil.cc.
5382 if (
length==-1)
return 0;
5384 int o =
p.GetpFDeg();
5385 int op = set[
length].GetpFDeg();
5389 || (( op == o) && (set[
length].length ==
p.length)
5400 op = set[an].GetpFDeg();
5402 || (( op == o) && (set[an].
length >
p.length))
5403 || (( op == o) && (set[an].length ==
p.length)
5409 op = set[
i].GetpFDeg();
5411 || (( op == o) && (set[
i].
length >
p.length))
5412 || (( op == o) && (set[
i].length ==
p.length)
◆ posInT13()
Definition at line 5467 of file kutil.cc.
5470 if (
length==-1)
return 0;
5472 int o =
p.GetpFDeg();
5474 if (set[
length].GetpFDeg() <= o)
5484 if (set[an].GetpFDeg() > o)
5489 if (set[
i].GetpFDeg() > o)
◆ posInT15()
Definition at line 5535 of file kutil.cc.
5556 if (
length==-1)
return 0;
5558 int o =
p.GetpFDeg() +
p.ecart;
5573 op = set[an].GetpFDeg()+set[an].ecart;
5580 op = set[
i].GetpFDeg()+set[
i].ecart;
◆ posInT17()
Definition at line 5630 of file kutil.cc.
5653 if (
length==-1)
return 0;
5655 int o =
p.GetpFDeg() +
p.ecart;
5659 || (( op == o) && (set[
length].ecart >
p.ecart))
5660 || (( op == o) && (set[
length].ecart==
p.ecart)
5671 op = set[an].GetpFDeg()+set[an].ecart;
5673 || (( op == o) && (set[an].ecart <
p.ecart))
5674 || (( op == o) && (set[an].ecart==
p.ecart)
5680 op = set[
i].GetpFDeg()+set[
i].ecart;
5682 || (( op == o) && (set[
i].ecart <
p.ecart))
5683 || (( op == o) && (set[
i].ecart ==
p.ecart)
◆ posInT17_c()
Definition at line 5737 of file kutil.cc.
5740 if (
length==-1)
return 0;
5744 int o =
p.GetpFDeg() +
p.ecart;
5753 || ((op == o) && (set[
length].ecart >
p.ecart))
5754 || ((op == o) && (set[
length].ecart==
p.ecart)
5770 int op = set[an].GetpFDeg()+set[an].ecart;
5772 || ((op == o) && (set[an].ecart <
p.ecart))
5773 || ((op == o) && (set[an].ecart==
p.ecart)
5784 int op = set[
i].GetpFDeg()+set[
i].ecart;
5786 || ((op == o) && (set[
i].ecart <
p.ecart))
5787 || ((op == o) && (set[
i].ecart ==
p.ecart)
◆ posInT19()
Definition at line 5864 of file kutil.cc.
5868 if (
length==-1)
return 0;
5871 int op=
p.GetpFDeg();
5873 if (set[
length].ecart < o)
5875 if (set[
length].ecart == o)
5877 int oo=set[
length].GetpFDeg();
5878 if ((oo < op) || ((oo==op) && (set[
length].
length <
p.length)))
5889 if (set[an].ecart > o)
5891 if (set[an].ecart == o)
5893 int oo=set[an].GetpFDeg();
5895 || ((oo==op) && (set[an].
length >
p.length)))
5901 if (set[
i].ecart > o)
5903 else if (set[
i].ecart == o)
5905 int oo=set[
i].GetpFDeg();
5907 || ((oo == op) && (set[
i].
length >
p.length)))
◆ posInT2()
◆ posInT_EcartFDegpLength()
Definition at line 11449 of file kutil.cc.
11461 if (
length==-1)
return 0;
11464 int op=
p.GetpFDeg();
11465 int ol =
p.GetpLength();
11467 if (set[
length].ecart < o)
11469 if (set[
length].ecart == o)
11471 int oo=set[
length].GetpFDeg();
11472 if ((oo < op) || ((oo==op) && (set[
length].
length < ol)))
11483 if (set[an].ecart > o)
11485 if (set[an].ecart == o)
11487 int oo=set[an].GetpFDeg();
11489 || ((oo==op) && (set[an].
pLength > ol)))
11495 if (set[
i].ecart > o)
11497 else if (set[
i].ecart == o)
11499 int oo=set[
i].GetpFDeg();
◆ posInT_EcartpLength()
Definition at line 5496 of file kutil.cc.
5499 int ol =
p.GetpLength();
5500 if (
length==-1)
return 0;
5504 int oo=set[
length].ecart;
5505 if ((oo < op) || ((oo==op) && (set[
length].
length < ol)))
5515 int oo=set[an].ecart;
5517 || ((oo==op) && (set[an].
pLength > ol)))
5522 int oo=set[
i].ecart;
5524 || ((oo == op) && (set[
i].
pLength > ol)))
◆ posInT_FDegpLength()
Definition at line 11503 of file kutil.cc.
11515 if (
length==-1)
return 0;
11517 int op=
p.GetpFDeg();
11518 int ol =
p.GetpLength();
11520 int oo=set[
length].GetpFDeg();
11521 if ((oo < op) || ((oo==op) && (set[
length].
length < ol)))
11531 int oo=set[an].GetpFDeg();
11533 || ((oo==op) && (set[an].
pLength > ol)))
◆ posInT_pLength()
Definition at line 11540 of file kutil.cc.
11551 int ol =
p.GetpLength();
◆ posInTSig()
◆ postReduceByMon()
used for GB over ZZ: intermediate reduction by monomial elements background: any known constant element of ideal suppresses intermediate coefficient swell
Definition at line 10805 of file kutil.cc.
10818 poly pH =
h->GetP();
10822 for(
int i = 0;
i<=strat->
sl;
i++)
◆ postReduceByMonSig()
Definition at line 10873 of file kutil.cc.
10886 poly hSig =
h->sig;
10887 poly pH =
h->GetP();
10891 for(
int i = 0;
i<=strat->
sl;
i++)
10902 if(sigMult!=
NULL &&
pLtCmp(hSig,sigMult) == 1)
10929 if(sigMult!=
NULL &&
pLtCmp(hSig,sigMult) == 1)
◆ preIntegerCheck()
poly preIntegerCheck |
( |
ideal |
F, |
|
|
ideal |
Q |
|
) |
| |
used for GB over ZZ: look for constant and monomial elements in the ideal background: any known constant element of ideal suppresses intermediate coefficient swell
Definition at line 10637 of file kutil.cc.
10651 ideal F =
idCopy(Forig);
10655 ideal monred =
idInit(1,1);
10662 if((posconst != -1) && (!
nIsZero(F->m[posconst]->coef)))
10672 for(
int i=0;
i<idelemQ;
i++)
10680 if((posconst != -1) && (!
nIsZero(monred->m[posconst]->coef)))
10682 pmon =
pCopy(monred->m[posconst]);
10697 II->m[
j++] =
prMapR(F->m[
i], nMap, origR, QQ_ring);
10699 II->m[
j++] =
prMapR(
Q->m[
i], nMap, origR, QQ_ring);
10706 if(II->m[
i] !=
NULL)
10707 II->m[
i+1] = II->m[
i];
10710 poly integer =
NULL;
10718 integer =
pHead(syz->m[
i]);
10725 pmon =
prMapR(integer, nMap2, QQ_ring, origR);
10739 poly mindegmon =
NULL;
10744 if(mindegmon ==
NULL)
10745 mindegmon =
pCopy(one->m[
i]);
10748 if(
p_Deg(one->m[
i], QQ_ring) <
p_Deg(mindegmon, QQ_ring))
10749 mindegmon =
pCopy(one->m[
i]);
10753 if(mindegmon !=
NULL)
10756 if(II->m[
i] !=
NULL)
10757 II->m[
i+1] = II->m[
i];
10758 II->m[0] =
pCopy(mindegmon);
10787 pmon =
prMapR(mindegmon, nMap2, QQ_ring, origR);
◆ redFirstShift()
Definition at line 4264 of file kstd2.cc.
4268 if (
h->IsNull())
return 0;
4276 d =
h->GetpFDeg() +
h->ecart;
4279 h->SetShortExpVector();
4285 h->SetDegStuffReturnLDeg(strat->
LDegLast);
4290 strat->
T[
j].pNorm();
4322 h->SetShortExpVector();
4335 h->SetDegStuffReturnLDeg(strat->
LDegLast);
4345 if (strat->
T[
j].ecart <=
h->ecart)
4346 h->ecart = d -
h->GetpFDeg();
4348 h->ecart = d -
h->GetpFDeg() + strat->
T[
j].ecart -
h->ecart;
4350 d =
h->GetpFDeg() +
h->ecart;
4353 d =
h->SetDegStuffReturnLDeg(strat->
LDegLast);
4362 && ((d >= reddeg) || (pass > strat->
LazyPass)))
4367 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
4368 if (at <= strat->Ll)
◆ redHomog()
Definition at line 548 of file kstd2.cc.
550 if (strat->
tl<0)
return 1;
556 unsigned long not_sev;
561 h->SetShortExpVector();
563 h_p =
h->GetLmTailRing();
570 li = strat->
T[
j].pLength;
571 if (li<=0) li=strat->
T[
j].GetpLength();
588 if ((strat->
T[
i].pLength < li)
596 li = strat->
T[
i].pLength;
597 if (li<=0) li=strat->
T[
i].GetpLength();
618 #if SBA_PRINT_REDUCTION_STEPS
619 sba_interreduction_steps++;
621 #if SBA_PRINT_OPERATIONS
622 sba_interreduction_operations +=
pLength(strat->
T[ii].p);
634 h_p =
h->GetLmTailRing();
643 h->SetShortExpVector();
655 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
664 Print(
" lazy: -> L%d\n",at);
◆ redHoney()
Definition at line 1402 of file kstd2.cc.
1404 if (strat->
tl<0)
return 1;
1408 int i,
j,at,pass,ei, ii, h_d;
1409 unsigned long not_sev;
1413 d = reddeg =
h->GetpFDeg() +
h->ecart;
1414 h->SetShortExpVector();
1416 h_p =
h->GetLmTailRing();
1423 if (
j < 0)
return 1;
1425 ei = strat->
T[
j].ecart;
1426 li = strat->
T[
j].pLength;
1427 if (li<=0) li=strat->
T[
j].GetpLength();
1445 if ((((strat->
T[
i].ecart < ei) && (ei>
h->ecart))
1446 || ((strat->
T[
i].ecart <=
h->ecart) && (strat->
T[
i].pLength < li)))
1454 ei = strat->
T[
i].ecart;
1455 li = strat->
T[
i].pLength;
1456 if (li<=0) li=strat->
T[
i].GetpLength();
1475 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
1493 Print(
"\nwith T[%d]:",ii);
1500 #if SBA_PRINT_REDUCTION_STEPS
1501 sba_interreduction_steps++;
1503 #if SBA_PRINT_OPERATIONS
1504 sba_interreduction_operations +=
pLength(strat->
T[ii].p);
1533 else if (
h->t_p!=
NULL)
1542 h->SetShortExpVector();
1544 h_d =
h->SetpFDeg();
1549 h->ecart = d-h_d+ei-
h->ecart;
1563 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
1564 if (at <= strat->Ll)
1566 int dummy=strat->
sl;
1572 Print(
" degree jumped: -> L%d\n",at);
1578 else if (d > reddeg)
1580 if (d>=(
long)strat->
tailRing->bitmask)
1582 if (
h->pTotalDeg()+
h->ecart >= (long)strat->
tailRing->bitmask)
1587 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
◆ redLazy()
TEST_OPT_REDTHROUGH &&
Definition at line 1254 of file kstd2.cc.
1256 if (strat->
tl<0)
return 1;
1261 long reddeg =
h->GetpFDeg();
1263 unsigned long not_sev;
1265 h->SetShortExpVector();
1266 poly h_p =
h->GetLmTailRing();
1271 if (
j < 0)
return 1;
1273 li = strat->
T[
j].pLength;
1274 if (li<=0) li=strat->
T[
j].GetpLength();
1292 if ((strat->
T[
i].pLength < li)
1300 li = strat->
T[
i].pLength;
1301 if (li<=0) li=strat->
T[
i].GetpLength();
1323 #if SBA_PRINT_REDUCTION_STEPS
1324 sba_interreduction_steps++;
1326 #if SBA_PRINT_OPERATIONS
1327 sba_interreduction_operations +=
pLength(strat->
T[ii].p);
1339 h_p=
h->GetLmTailRing();
1349 h->SetShortExpVector();
1355 (strat->
Ll >= 0) && ((d > reddeg) || (pass > strat->
LazyPass)))
1358 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
1359 if (at <= strat->Ll)
1362 int dummy=strat->
sl;
1374 else if (d != reddeg)
1376 if (d>=(
long)strat->
tailRing->bitmask)
1378 if (
h->pTotalDeg() >= (long)strat->
tailRing->bitmask)
1383 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
◆ redNF()
poly redNF |
( |
poly |
h, |
|
|
int & |
max_ind, |
|
|
int |
nonorm, |
|
|
kStrategy |
strat |
|
) |
| |
Definition at line 1607 of file kstd2.cc.
1609 #define REDNF_CANONICALIZE 60
1620 P.SetShortExpVector();
1726 P.SetShortExpVector();
◆ redNF0()
◆ redNFTail()
◆ redRiloc()
Definition at line 343 of file kstd1.cc.
351 d =
h->GetpFDeg()+
h->ecart;
353 h->SetShortExpVector();
372 if (
h->GetLmTailRing() ==
NULL)
381 ei = strat->
T[
j].ecart;
383 if (ei >
h->ecart && ii < strat->tl)
385 li = strat->
T[
j].length;
395 if (
i > strat->
tl)
break;
396 if ((strat->
T[
i].ecart < ei || (strat->
T[
i].ecart == ei &&
397 strat->
T[
i].length < li))
406 if (strat->
T[
i].ecart < ei || (strat->
T[
i].ecart == ei &&
407 strat->
T[
i].length < li))
412 ei = strat->
T[
i].ecart;
413 if (ei <= h->ecart)
break;
414 li = strat->
T[
i].length;
432 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
433 if (at <= strat->Ll &&
pLmCmp(
h->p, strat->
L[strat->
Ll].p) != 0 && !
nEqual(
h->p->coef, strat->
L[strat->
Ll].p->coef))
462 h->SetShortExpVector();
467 h->ecart = d-
h->GetpFDeg();
469 h->ecart = d-
h->GetpFDeg()+ei-
h->ecart;
473 h->ecart =
h->pLDeg(strat->
LDegLast) -
h->GetpFDeg();
476 d =
h->GetpFDeg()+
h->ecart;
483 && ((d >= reddeg) || (pass > strat->
LazyPass)))
489 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
511 if (
h->pTotalDeg()+
h->ecart >= (int)strat->
tailRing->bitmask)
516 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
◆ redRing()
Definition at line 438 of file kstd2.cc.
440 if (
h->IsNull())
return 0;
441 if (strat->
tl<0)
return 1;
452 long reddeg =
h->GetpFDeg();
454 h->SetShortExpVector();
476 if (
h->GetLmTailRing() ==
NULL)
489 if (
h->GetLmTailRing() ==
NULL)
498 h->SetShortExpVector();
503 (strat->
Ll >= 0) && ((d > reddeg) || (pass > strat->
LazyPass)))
508 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
521 if (d >= (
long)strat->
tailRing->bitmask)
523 if (
h->pTotalDeg() >= (long)strat->
tailRing->bitmask)
528 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
◆ redSig()
Definition at line 711 of file kstd2.cc.
713 if (strat->
tl<0)
return 1;
719 PrintS(
"------- IN REDSIG -------\n");
726 PrintS(
"---------------------------\n");
732 unsigned long not_sev;
737 h->SetShortExpVector();
739 h_p =
h->GetLmTailRing();
749 li = strat->
T[
j].pLength;
750 if (li<=0) li=strat->
T[
j].GetpLength();
767 if ((strat->
T[
i].pLength < li)
775 li = strat->
T[
i].pLength;
776 if (li<=0) li=strat->
T[
i].GetpLength();
798 Print(
"BEFORE REDUCTION WITH %d:\n",ii);
799 PrintS(
"--------------------------------\n");
806 PrintS(
"--------------------------------\n");
807 printf(
"INDEX OF REDUCER T: %d\n",ii);
810 #if SBA_PRINT_REDUCTION_STEPS
812 sba_reduction_steps++;
814 #if SBA_PRINT_OPERATIONS
816 sba_operations +=
pLength(strat->
T[ii].p);
823 Print(
"SigSAFE: %d\n",sigSafe);
838 h_p =
h->GetLmTailRing();
847 h->SetShortExpVector();
859 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
870 Print(
" lazy: -> L%d\n",at);
◆ redSigRing()
Definition at line 881 of file kstd2.cc.
894 beforeredsig =
pCopy(
h->sig);
896 if (strat->
tl<0)
return 1;
902 Print(
"------- IN REDSIG -------\n");
909 Print(
"---------------------------\n");
915 unsigned long not_sev;
920 h->SetShortExpVector();
922 h_p =
h->GetLmTailRing();
947 if (
h->GetLmTailRing() ==
NULL)
954 if(
pLtCmp(beforeredsig,
h->sig) == 1)
977 li = strat->
T[
j].pLength;
978 if (li<=0) li=strat->
T[
j].GetpLength();
994 if ((strat->
T[
i].pLength < li)
1002 li = strat->
T[
i].pLength;
1003 if (li<=0) li=strat->
T[
i].GetpLength();
1025 Print(
"BEFORE REDUCTION WITH %d:\n",ii);
1026 Print(
"--------------------------------\n");
1033 Print(
"--------------------------------\n");
1034 printf(
"INDEX OF REDUCER T: %d\n",ii);
1062 #if SBA_PRINT_REDUCTION_STEPS
1064 sba_reduction_steps++;
1066 #if SBA_PRINT_OPERATIONS
1068 sba_operations +=
pLength(strat->
T[ii].p);
1075 Print(
"SigSAFE: %d\n",sigSafe);
1090 h_p =
h->GetLmTailRing();
1099 h->SetShortExpVector();
1111 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
1112 if (at <= strat->Ll)
1114 int dummy=strat->
sl;
1122 Print(
" lazy: -> L%d\n",at);
◆ redtail() [1/2]
Definition at line 7303 of file kutil.cc.
7341 if (With ==
NULL)
break;
7351 return redtail(L, end_pos, strat);
7357 if (hn ==
NULL)
goto all_done;
◆ redtail() [2/2]
poly redtail |
( |
poly |
p, |
|
|
int |
end_pos, |
|
|
kStrategy |
strat |
|
) |
| |
◆ redtailBba() [1/3]
Definition at line 7379 of file kutil.cc.
7383 #define REDTAIL_CANONICALIZE 100
7387 p =
h = L->GetLmTailRing();
7389 return L->GetLmCurrRing();
7424 Ln.SetShortExpVector();
7430 With = &(strat->
T[
j]);
7431 assume(With->GetpLength()==
pLength(With->p != __null ? With->p : With->t_p));
7436 if (With ==
NULL)
break;
7437 assume(With->GetpLength()==
pLength(With->p != __null ? With->p : With->t_p));
7464 pNext(
h) = Ln.LmExtractAndIter();
7467 }
while (!Ln.IsNull());
7470 if (Ln.IsNull())
goto all_done;
7471 if (! withT) With_s.Init(
currRing);
7473 pNext(
h) = Ln.LmExtractAndIter();
◆ redtailBba() [2/3]
◆ redtailBba() [3/3]
◆ redtailBba_Z() [1/2]
Definition at line 7609 of file kutil.cc.
7617 p =
h = L->GetLmTailRing();
7619 return L->GetLmCurrRing();
7626 Ln.pLength = L->GetpLength() - 1;
7639 Ln.SetShortExpVector();
7641 if (With ==
NULL)
break;
7651 poly p_Ln=Ln.GetLmCurrRing();
7652 poly p_With=With->GetLmCurrRing();
7664 if (Ln.bucket!=
NULL)
7695 pNext(
h) = Ln.LmExtractAndIter();
7698 }
while (!Ln.IsNull());
7701 if (Ln.IsNull())
goto all_done;
7704 pNext(
h) = Ln.LmExtractAndIter();
◆ redtailBba_Z() [2/2]
◆ redtailBbaBound() [1/2]
Definition at line 7493 of file kutil.cc.
7500 p =
h = L->GetLmTailRing();
7502 return L->GetLmCurrRing();
7509 Ln.pLength = L->GetpLength() - 1;
7533 Ln.SetShortExpVector();
7539 With = &(strat->
T[
j]);
7544 if (With ==
NULL)
break;
7571 pNext(
h) = Ln.LmExtractAndIter();
7574 }
while (!Ln.IsNull());
7586 if (! withT) With_s.Init(
currRing);
7588 pNext(
h) = Ln.LmExtractAndIter();
◆ redtailBbaBound() [2/2]
◆ redtailBbaShift()
Definition at line 12520 of file kutil.cc.
12535 p =
h = L->GetLmTailRing();
12537 return L->GetLmCurrRing();
12544 Ln.pLength = L->GetpLength() - 1;
12552 while(!Ln.IsNull())
12556 Ln.SetShortExpVector();
12562 With = &(strat->
T[
j]);
12567 if (With ==
NULL)
break;
12583 pNext(
h) = Ln.LmExtractAndIter();
12586 }
while (!Ln.IsNull());
12589 if (Ln.IsNull())
goto all_done;
12590 if (! withT) With_s.Init(
currRing);
12592 pNext(
h) = Ln.LmExtractAndIter();
◆ redtailSba()
Definition at line 1133 of file kstd2.cc.
1135 #define REDTAIL_CANONICALIZE 100
1139 p =
h = L->GetLmTailRing();
1141 return L->GetLmCurrRing();
1149 Ln.sevSig = L->sevSig;
1150 Ln.pLength = L->GetpLength() - 1;
1165 Ln.SetShortExpVector();
1171 With = &(strat->
T[
j]);
1176 if (With ==
NULL)
break;
1200 #if SBA_PRINT_REDUCTION_STEPS
1202 sba_reduction_steps++;
1204 #if SBA_PRINT_OPERATIONS
1206 sba_operations +=
pLength(With->p);
1216 pNext(
h) = Ln.LmExtractAndIter();
1219 }
while (!Ln.IsNull());
1222 if (Ln.IsNull())
goto all_done;
1223 if (! withT) With_s.Init(
currRing);
1230 pNext(
h) = Ln.LmExtractAndIter();
1247 return L->GetLmCurrRing();
◆ reorderS()
Definition at line 4881 of file kutil.cc.
4884 int i,
j,at,ecart, s2r;
4888 int new_suc=strat->
sl+1;
4892 for (;
i<=strat->
sl;
i++)
4897 if (new_suc > at) new_suc = at;
4900 sev = strat->
sevS[
i];
4903 for (
j=
i;
j>=at+1;
j--)
4905 strat->
S[
j] = strat->
S[
j-1];
4911 strat->
ecartS[at] = ecart;
4912 strat->
sevS[at] = sev;
4913 strat->
S_2_R[at] = s2r;
4916 for (
j=
i;
j>=at+1;
j--)
4920 strat->
fromQ[at]=fq;
4924 if (new_suc <= strat->sl) *suc=new_suc;
◆ sba()
Definition at line 2272 of file kstd2.cc.
2281 #if SBA_PRINT_ZERO_REDUCTIONS
2282 long zeroreductions = 0;
2284 #if SBA_PRINT_PRODUCT_CRITERION
2285 long product_criterion = 0;
2287 #if SBA_PRINT_SIZE_G
2289 int size_g_non_red = 0;
2291 #if SBA_PRINT_SIZE_SYZ
2295 #if SBA_PRINT_REDUCTION_STEPS
2296 sba_reduction_steps = 0;
2297 sba_interreduction_steps = 0;
2299 #if SBA_PRINT_OPERATIONS
2301 sba_interreduction_operations = 0;
2305 ring sRing, currRingOld;
2310 if (sRing!=currRingOld)
2329 dummy =
pCopy(F->m[0]);
2331 F->m[
i] = F->m[
i+1];
2352 dummy =
pCopy(F->m[0]);
2354 F->m[
i] = F->m[
i+1];
2372 for (
int i=0;
i<
sort->length();++
i)
2373 F->m[
i] = F1->m[(*
sort)[
i]-1];
2387 F->m[
j] = F->m[
j-1];
2405 printf(
"SBA COMPUTATIONS DONE IN THE FOLLOWING RING:\n");
2407 printf(
"ordSgn = %d\n",
currRing->OrdSgn);
2410 int srmax,lrmax, red_result = 1;
2412 int hilbeledeg=1,hilbcount=0,minimcnt=0;
2426 reduc = olddeg = lrmax = 0;
2439 #ifdef HAVE_TAIL_RING
2457 strat->
enterS(strat->
L[strat->
Ll-(
i)], strat->
sl+1, strat, strat->
tl);
2467 while (strat->
Ll >= 0)
2469 if (strat->
Ll > lrmax) lrmax =strat->
Ll;
2499 f5c ( strat, olddeg, minimcnt, hilbeledeg, hilbcount, srmax,
2500 lrmax, reduc,
Q,
w, hilb );
2510 strat->
P = strat->
L[strat->
Ll];
2516 if (!strat->
rewCrit2(strat->
P.sig, ~strat->
P.sevSig, strat->
P.GetLmCurrRing(), strat, strat->
P.checked+1))
2520 PrintS(
"SIG OF NEXT PAIR TO HANDLE IN SIG-BASED ALGORITHM\n");
2521 PrintS(
"-------------------------------------------------\n");
2526 PrintS(
"-------------------------------------------------\n");
2561 else if (strat->
P.p1 ==
NULL)
2563 if (strat->
minim > 0)
2569 if (strat->
P.p ==
NULL && strat->
P.t_p ==
NULL)
2577 PrintS(
"Poly before red: ");
2581 #if SBA_PRODUCT_CRITERION
2582 if (strat->
P.prod_crit)
2584 #if SBA_PRINT_PRODUCT_CRITERION
2585 product_criterion++;
2587 int pos =
posInSyz(strat, strat->
P.sig);
2589 if (strat->
P.lcm!=
NULL)
2595 red_result = strat->
red(&strat->
P,strat);
2598 red_result = strat->
red(&strat->
P,strat);
2614 strat->
P.p =
pNeg(strat->
P.p);
2615 strat->
P.sig =
pNeg(strat->
P.sig);
2618 if(strat->
P.sig !=
NULL)
2620 if(strat->
P.p !=
NULL)
2627 red_result =
redRing(&strat->
P,strat);
2632 strat->
P.sig =
NULL;
2636 strat->
enterS(strat->
P, 0, strat, strat->
tl);
2652 if (red_result != 0)
2654 PrintS(
"Poly after red: ");
2656 pWrite(strat->
P.GetLmCurrRing());
2658 printf(
"%d\n",red_result);
2663 if(strat->
P.p !=
NULL)
2665 &olddeg,&reduc,strat, red_result);
2667 message((strat->honey ? strat->P.ecart : 0),
2668 &olddeg,&reduc,strat, red_result);
2671 if (strat->overflow)
2676 if (red_result == 1)
2679 strat->P.GetP(strat->lmBin);
2683 (strat->P).FDeg = (strat->P).pFDeg();
2687 if (strat->homog) strat->initEcart(&(strat->P));
2695 int pos = strat->sl+1;
2703 beforetailred =
pCopy(strat->P.sig);
2709 strat->P.p =
redtailSba(&(strat->P),pos-1,strat, withT);
2713 if (strat->sbaOrder != 2)
2717 strat->P.pCleardenom();
2720 strat->P.p =
redtailSba(&(strat->P),pos-1,strat, withT);
2721 strat->P.pCleardenom();
2728 strat->P.p =
redtailSba(&(strat->P),pos-1,strat, withT);
2737 strat->enterS(strat->P, 0, strat, strat->tl);
2743 if(strat->P.sig ==
NULL ||
pLtCmp(beforetailred,strat->P.sig) == 1)
2745 strat->sigdrop =
TRUE;
2747 red_result =
redRing(&strat->P,strat);
2751 strat->sigdrop =
FALSE;
2756 strat->enterS(strat->P, 0, strat, strat->tl);
2762 if(strat->P.p ==
NULL)
2763 goto case_when_red_result_changed;
2767 if (strat->sbaOrder == 1)
2769 for (
int jj = 0; jj<strat->tl+1; jj++)
2771 if (
pGetComp(strat->T[jj].sig) == strat->currIdx)
2773 strat->T[jj].is_sigsafe =
FALSE;
2779 for (
int jj = 0; jj<strat->tl+1; jj++)
2781 strat->T[jj].is_sigsafe =
FALSE;
2789 if ((strat->P.p1==
NULL) && (strat->minim>0))
2791 if (strat->minim==1)
2793 strat->M->m[minimcnt]=
p_Copy(strat->P.p,
currRing,strat->tailRing);
2798 strat->M->m[minimcnt]=strat->P.p2;
2802 pNext(strat->M->m[minimcnt])
2803 = strat->p_shallow_copy_delete(
pNext(strat->M->m[minimcnt]),
2812 strat->T[strat->tl].is_sigsafe =
FALSE;
2819 superenterpairsSig(strat->P.p,strat->P.sig,strat->sl+1,strat->sl,strat->P.ecart,pos,strat, strat->tl);
2821 enterpairsSig(strat->P.p,strat->P.sig,strat->sl+1,strat->sl,strat->P.ecart,pos,strat, strat->tl);
2826 strat->enterS(strat->P, pos, strat, strat->tl);
2827 if(strat->sbaOrder != 1)
2830 for (
int tk=0; tk<strat->sl+1; tk++)
2851 for(
int ps=0;ps<strat->sl+1;ps++)
2855 if (strat->syzl == strat->syzmax)
2859 (strat->syzmax)*
sizeof(
unsigned long),
2861 *
sizeof(
unsigned long));
2864 Q.sig =
pCopy(strat->P.sig);
2867 if (strat->sbaOrder == 0)
2890 if(strat->sbaOrder == 0 || strat->sbaOrder == 3)
2901 if (strat->currIdx < idx)
2903 for (
int i=0;
i<strat->sl; ++
i)
2914 strat->currIdx = idx;
2920 for (
int i=cmp+1;
i<=max_cmp; ++
i)
2923 for (
int j=0;
j<strat->sl; ++
j)
2941 if (strat->sbaOrder == 0)
2961 printf(
"---------------------------\n");
2962 Print(
" %d. ELEMENT ADDED TO GCURR:\n",strat->sl+1);
2985 if (hilb!=
NULL)
khCheck(
Q,
w,hilb,hilbeledeg,hilbcount,strat);
2987 if (strat->P.lcm!=
NULL)
2993 if (strat->sl>srmax) srmax = strat->sl;
2997 case_when_red_result_changed:
3005 #if SBA_PRINT_ZERO_REDUCTIONS
3014 int pos =
posInSyz(strat, strat->P.sig);
3018 Print(
"ADDING STUFF TO SYZ : ");
3024 if (strat->P.p1 ==
NULL && strat->minim > 0)
3031 memset(&(strat->P), 0,
sizeof(strat->P));
3037 printf(
"\nSigDrop!\n");
3039 printf(
"\nEnded with no SigDrop\n");
3045 if(strat->P.sig !=
NULL)
3046 strat->sbaEnterS =
pGetComp(strat->P.sig)-1;
3049 memset(&(strat->P), 0,
sizeof(strat->P));
3068 clearS(strat->S[
j],strat->sevS[
j],&
k,&
j,strat);
3079 if (strat->completeReduce_retry)
3084 #ifdef HAVE_TAIL_RING
3085 if(
currRing->bitmask>strat->tailRing->bitmask)
3087 strat->completeReduce_retry=
FALSE;
3090 for(
i=strat->sl;
i>=0;
i--) strat->S_2_R[
i]=-1;
3093 if (strat->completeReduce_retry)
3100 #if SBA_PRINT_SIZE_SYZ
3102 size_syz = strat->syzl;
3115 #if SBA_PRINT_SIZE_G
3116 size_g_non_red =
IDELEMS(strat->Shdl);
3130 for(;
k>=0 && (strat->L[
k].p1 !=
NULL || strat->L[
k].p2 !=
NULL);
k--)
3140 for(;
k>=0 && strat->L[
k].p1 ==
NULL && strat->L[
k].p2 ==
NULL;
k--)
3143 strat->enterS(strat->L[
k], strat->sl+1, strat, strat->tl);
3151 for(
k=strat->sl;
k>=0;
k--)
3153 printf(
"\nsig[%i] = ",
i);
pWrite(strat->sig[
k]);
3154 if(strat->sig[
k] ==
NULL)
3155 strat->sig[
k] =
pCopy(strat->sig[
k-1]);
3164 if ((strat->sbaOrder == 1 || strat->sbaOrder == 3) && sRing!=currRingOld)
3173 if(strat->tailRing == sRing)
3184 #if SBA_PRINT_SIZE_G
3185 size_g =
IDELEMS(strat->Shdl);
3188 printf(
"SIZE OF SHDL: %d\n",
IDELEMS(strat->Shdl));
3190 while (oo<
IDELEMS(strat->Shdl))
3192 printf(
" %d. ",oo+1);
3197 #if SBA_PRINT_ZERO_REDUCTIONS
3198 printf(
"----------------------------------------------------------\n");
3199 printf(
"ZERO REDUCTIONS: %ld\n",zeroreductions);
3202 #if SBA_PRINT_REDUCTION_STEPS
3203 printf(
"----------------------------------------------------------\n");
3204 printf(
"S-REDUCTIONS: %ld\n",sba_reduction_steps);
3206 #if SBA_PRINT_OPERATIONS
3207 printf(
"OPERATIONS: %ld\n",sba_operations);
3209 #if SBA_PRINT_REDUCTION_STEPS
3210 printf(
"- - - - - - - - - - - - - - - - - - - - - - - - - - - - - \n");
3211 printf(
"INTERREDUCTIONS: %ld\n",sba_interreduction_steps);
3213 #if SBA_PRINT_OPERATIONS
3214 printf(
"INTERREDUCTION OPERATIONS: %ld\n",sba_interreduction_operations);
3216 #if SBA_PRINT_REDUCTION_STEPS
3217 printf(
"- - - - - - - - - - - - - - - - - - - - - - - - - - - - - \n");
3218 printf(
"ALL REDUCTIONS: %ld\n",sba_reduction_steps+sba_interreduction_steps);
3219 sba_interreduction_steps = 0;
3220 sba_reduction_steps = 0;
3222 #if SBA_PRINT_OPERATIONS
3223 printf(
"ALL OPERATIONS: %ld\n",sba_operations+sba_interreduction_operations);
3224 sba_interreduction_operations = 0;
3227 #if SBA_PRINT_SIZE_G
3228 printf(
"----------------------------------------------------------\n");
3229 printf(
"SIZE OF G: %d / %d\n",size_g,size_g_non_red);
3233 #if SBA_PRINT_SIZE_SYZ
3234 printf(
"SIZE OF SYZ: %ld\n",size_syz);
3235 printf(
"----------------------------------------------------------\n");
3238 #if SBA_PRINT_PRODUCT_CRITERION
3239 printf(
"PRODUCT CRITERIA: %ld\n",product_criterion);
3240 product_criterion = 0;
3242 return (strat->Shdl);
◆ sbaCheckGcdPair()
Definition at line 1607 of file kutil.cc.
1610 if(strat->
sl < 0)
return FALSE;
1612 for(
i=0;
i<strat->
sl;
i++)
1648 h->i_r1 = -1;
h->i_r2 = -1;
◆ sbaRing()
Definition at line 11154 of file kutil.cc.
11175 res->block0 = (
int *)
omAlloc0((n+1)*
sizeof(int));
11176 res->block1 = (
int *)
omAlloc0((n+1)*
sizeof(int));
11177 int **wvhdl = (
int **)
omAlloc0((n+1)*
sizeof(
int*));
11178 res->wvhdl = wvhdl;
11179 for (
int i=1;
i<n;
i++)
11181 res->order[
i] = r->order[
i-1];
11182 res->block0[
i] = r->block0[
i-1];
11183 res->block1[
i] = r->block1[
i-1];
11184 res->wvhdl[
i] = r->wvhdl[
i-1];
11203 #ifndef SING_NDEBUG
11204 WarnS(
"error in nc_rComplete");
11223 res->block0 = (
int *)
omAlloc0((n+2)*
sizeof(int));
11224 res->block1 = (
int *)
omAlloc0((n+2)*
sizeof(int));
11225 int **wvhdl = (
int **)
omAlloc0((n+2)*
sizeof(
int*));
11226 res->wvhdl = wvhdl;
11227 for (
int i=2;
i<n+2;
i++)
11229 res->order[
i] = r->order[
i-2];
11230 res->block0[
i] = r->block0[
i-2];
11231 res->block1[
i] = r->block1[
i-2];
11232 res->wvhdl[
i] = r->wvhdl[
i-2];
11237 res->block0[0] = 1;
11239 for (
int i=0;
i<
res->N; ++
i)
11240 res->wvhdl[0][
i] = 1;
11259 #ifndef SING_NDEBUG
11260 WarnS(
"error in nc_rComplete");
◆ superenterpairs()
void superenterpairs |
( |
poly |
h, |
|
|
int |
k, |
|
|
int |
ecart, |
|
|
int |
pos, |
|
|
kStrategy |
strat, |
|
|
int |
atR = -1 |
|
) |
| |
◆ superenterpairsSig()
void superenterpairsSig |
( |
poly |
h, |
|
|
poly |
hSig, |
|
|
int |
hFrom, |
|
|
int |
k, |
|
|
int |
ecart, |
|
|
int |
pos, |
|
|
kStrategy |
strat, |
|
|
int |
atR = -1 |
|
) |
| |
◆ syzCriterion()
Definition at line 6944 of file kutil.cc.
6949 PrintS(
"syzygy criterion checks: ");
6952 for (
int k=0;
k<strat->
syzl;
k++)
6957 Print(
"checking with: %d / %d -- \n",
k,strat->
syzl);
◆ syzCriterionInc()
Definition at line 6979 of file kutil.cc.
6986 PrintS(
"--- syzygy criterion checks: ");
7011 Print(
"checking with: %d -- ",
k);
◆ twoPow()
◆ updateResult()
void updateResult |
( |
ideal |
r, |
|
|
ideal |
Q, |
|
|
kStrategy |
strat |
|
) |
| |
Definition at line 10180 of file kutil.cc.
10205 if ((r->m[
l]!=
NULL)
10212 if ((
Q->m[q]!=
NULL)
10236 if ((r->m[
l]!=
NULL)
10243 if ((
Q->m[q]!=
NULL)
10287 reduction_found=
TRUE;
10318 reduction_found=
TRUE;
10332 if ( reduction_found)
◆ updateS()
Definition at line 8801 of file kutil.cc.
8827 while (i<=strat->sl)
8838 if (
pCmp(redSi,strat->
S[
i])!=0)
8895 if (any_change)
reorderS(&suc,strat);
8900 for (
i=0;
i<=strat->
sl;
i++)
8934 while (i<=strat->sl)
8946 else if (
pCmp((strat->
S)[
i],redSi)!=0)
8987 if (any_change)
reorderS(&suc,strat);
8988 else { suc=-1;
break; }
8999 for (
i=0;
i<=strat->
sl;
i++)
◆ updateSShift()
void updateSShift |
( |
kStrategy |
strat, |
|
|
int |
uptodeg, |
|
|
int |
lV |
|
) |
| |
Definition at line 11834 of file kutil.cc.
11851 for (
i=0;
i<=strat->
sl;
i++)
11853 memset(&
h,0,
sizeof(
h));
◆ DENOMINATOR_LIST
◆ HCord
◆ strat_nr
◆ test_PosInL
◆ test_PosInT
static FORCE_INLINE number n_IntMod(number a, number b, const coeffs r)
for r a field, return n_Init(0,r) always: n_Div(a,b,r)*b+n_IntMod(a,b,r)==a n_IntMod(a,...
void chainCritSig(poly p, int, kStrategy strat)
void kEcartWeights(poly *s, int sl, short *eweight, const ring R)
KINLINE void clearS(poly p, unsigned long p_sev, int *at, int *k, kStrategy strat)
BOOLEAN rHasGlobalOrdering(const ring r)
KINLINE TObject * S_2_T(int i)
static int si_min(const int a, const int b)
int ksCheckCoeff(number *a, number *b)
#define pDivisibleBy(a, b)
returns TRUE, if leading monom of a divides leading monom of b i.e., if there exists a expvector c > ...
void kStratInitChangeTailRing(kStrategy strat)
void enterpairsSig(poly h, poly hSig, int hFrom, int k, int ecart, int pos, kStrategy strat, int atR)
poly redNF(poly h, int &max_ind, int nonorm, kStrategy strat)
void chainCritRing(poly p, int, kStrategy strat)
int posInLSig(const LSet set, const int length, LObject *p, const kStrategy)
KINLINE poly k_LmShallowCopyDelete_currRing_2_tailRing(poly p, ring tailRing, omBin tailBin)
KINLINE poly k_LmInit_tailRing_2_currRing(poly t_p, ring tailRing, omBin lmBin)
int idElem(const ideal F)
count non-zero elements
static poly p_LmFreeAndNext(poly p, ring)
long pLDeg1(poly p, int *l, const ring r)
int kBucketCanonicalize(kBucket_pt bucket)
static poly p_LmDeleteAndNext(poly p, const ring r)
void nc_PolyPolyRed(poly &b, poly p, number *c, const ring r)
void deleteHC(LObject *L, kStrategy strat, BOOLEAN fromNext)
ideal kStdShift(ideal F, ideal Q, tHomog h, intvec **w, intvec *hilb, int syzComp, int newIdeal, intvec *vw, int uptodeg, int lV)
#define pIsConstant(p)
like above, except that Comp might be != 0
void initBuchMoraCrit(kStrategy strat)
void enterExtendedSpolySig(poly h, poly hSig, kStrategy strat)
void initPairtest(kStrategy strat)
int redRiloc(LObject *h, kStrategy strat)
#define pGetComp(p)
Component.
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent @Note: the integer VarOffset encodes:
int posInT17_c(const TSet set, const int length, LObject &p)
void pNorm(poly p, const ring R=currRing)
#define TEST_OPT_INFREDTAIL
void cleanT(kStrategy strat)
void pRestoreDegProcs(ring r, pFDegProc old_FDeg, pLDegProc old_lDeg)
void(* enterS)(LObject &h, int pos, kStrategy strat, int atR)
#define SBA_INTERRED_START
long pLDeg0c(poly p, int *l, const ring r)
int redEcart(LObject *h, kStrategy strat)
#define pHasNotCF(p1, p2)
#define idDelete(H)
delete an ideal
void scComputeHC(ideal S, ideal Q, int ak, poly &hEdge, ring tailRing)
static void pLmFree(poly p)
frees the space of the monomial m, assumes m != NULL coef is not freed, m is not advanced
static BOOLEAN enterOneStrongPoly(int i, poly p, int, int, kStrategy strat, int atR, bool enterTstrong)
void khCheck(ideal Q, intvec *w, intvec *hilb, int &eledeg, int &count, kStrategy strat)
int kFindDivisibleByInS(const kStrategy strat, int *max_ind, LObject *L)
return -1 if no divisor is found number of first divisor in S, otherwise
int posInL0(const LSet set, const int length, LObject *p, const kStrategy)
static BOOLEAN rField_is_Domain(const ring r)
long pLDeg0(poly p, int *l, const ring r)
void rChangeCurrRing(ring r)
#define TEST_OPT_DEGBOUND
poly nc_p_Bracket_qq(poly p, const poly q, const ring r)
returns [p,q], destroys p
int posInL17_c(const LSet set, const int length, LObject *p, const kStrategy)
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
#define REDTAIL_CANONICALIZE
int isInV(poly p, int lV)
long pLDeg1_Totaldegree(poly p, int *l, const ring r)
#define pGetExp(p, i)
Exponent.
ideal idrMoveR_NoSort(ideal &id, ring src_r, ring dest_r)
void initBbaShift(kStrategy strat)
int posInT_EcartFDegpLength(const TSet set, const int length, LObject &p)
void pEnlargeSet(poly **p, int l, int increment)
poly redtail(LObject *L, int end_pos, kStrategy strat)
int posInT17(const TSet set, const int length, LObject &p)
BOOLEAN isInPairsetL(int length, poly p1, poly p2, int *k, kStrategy strat)
int posInT110Ring(const TSet set, const int length, LObject &p)
static poly p_Mult_mm(poly p, poly m, const ring r)
int(* posInLOld)(const LSet Ls, const int Ll, LObject *Lo, const kStrategy strat)
void(* chainCrit)(poly p, int ecart, kStrategy strat)
static nc_type & ncRingType(nc_struct *p)
KINLINE unsigned long * initsevT()
number kBucketPolyRed(kBucket_pt bucket, poly p1, int l1, poly spNoether)
void initBuchMoraShift(ideal F, ideal Q, kStrategy strat)
static poly p_Neg(poly p, const ring r)
static void p_SetCompP(poly p, int i, ring r)
void rKillModifiedRing(ring r)
void updateResult(ideal r, ideal Q, kStrategy strat)
void id_DelDiv(ideal id, const ring r)
delete id[j], if LT(j) == coeff*mon*LT(i) and vice versa, i.e., delete id[i], if LT(i) == coeff*mon*L...
BOOLEAN kCheckSpolyCreation(LObject *L, kStrategy strat, poly &m1, poly &m2)
void superenterpairs(poly h, int k, int ecart, int pos, kStrategy strat, int atR)
long totaldegreeWecart(poly p, ring r)
int posInT110(const TSet set, const int length, LObject &p)
BOOLEAN idInsertPoly(ideal h1, poly h2)
insert h2 into h1 (if h2 is not the zero polynomial) return TRUE iff h2 was indeed inserted
poly redtailBba(LObject *L, int end_pos, kStrategy strat, BOOLEAN withT, BOOLEAN normalize)
static BOOLEAN length(leftv result, leftv arg)
long ind_fact_2(long arg)
static poly p_ShallowCopyDelete(poly p, const ring r, omBin bin)
static void p_ExpVectorCopy(poly d_p, poly s_p, const ring r)
int itoInsert(poly p, int uptodeg, int lV, const ring r)
#define TEST_OPT_CONTENTSB
#define __p_GetComp(p, r)
KINLINE int ksReducePolyTailSig(LObject *PR, TObject *PW, LObject *Red, kStrategy strat)
poly prMapR(poly src, nMapFunc nMap, ring src_r, ring dest_r)
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
long pLDeg1c_Deg(poly p, int *l, const ring r)
BOOLEAN nc_rComplete(const ring src, ring dest, bool bSetupQuotient)
void p_wrp(poly p, ring lmRing, ring tailRing)
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
#define pGetShortExpVector(a)
returns the "Short Exponent Vector" – used to speed up divisibility tests (see polys-impl....
#define REDTAIL_CANONICALIZE
static poly pp_Mult_mm(poly p, poly m, const ring r)
int posInS(const kStrategy strat, const int length, const poly p, const int ecart_p)
void initSbaCrit(kStrategy strat)
const poly kBucketGetLm(kBucket_pt bucket)
long pLDeg1c_WFirstTotalDegree(poly p, int *l, const ring r)
void f5c(kStrategy strat, int &olddeg, int &minimcnt, int &hilbeledeg, int &hilbcount, int &srmax, int &lrmax, int &reduc, ideal Q, intvec *w, intvec *hilb)
int posInT_EcartpLength(const TSet set, const int length, LObject &p)
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
int posInL0Ring(const LSet set, const int length, LObject *p, const kStrategy)
void postReduceByMon(LObject *h, kStrategy strat)
used for GB over ZZ: intermediate reduction by monomial elements background: any known constant eleme...
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
static void enlargeL(LSet *L, int *length, const int incr)
int posInT_FDegpLength(const TSet set, const int length, LObject &p)
BOOLEAN syzCriterion(poly sig, unsigned long not_sevSig, kStrategy strat)
void p_Lcm(const poly a, const poly b, poly m, const ring r)
static intset initec(const int maxnr)
static BOOLEAN p_LmDivisibleBy(poly a, poly b, const ring r)
int posInSyz(const kStrategy strat, poly sig)
int posInT17_cRing(const TSet set, const int length, LObject &p)
static void p_ExpVectorSub(poly p1, poly p2, const ring r)
long pLDegb(poly p, int *l, const ring r)
BOOLEAN p_LmCheckIsFromRing(poly p, ring r)
void enterSMoraNF(LObject &p, int atS, kStrategy strat, int atR=-1)
BOOLEAN hasPurePower(const poly p, int last, int *length, kStrategy strat)
int posInT19(const TSet set, const int length, LObject &p)
poly p_LPshiftT(poly p, int sh, int uptodeg, int lV, kStrategy strat, const ring r)
int(* test_PosInL)(const LSet set, const int length, LObject *L, const kStrategy strat)
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent @Note: VarOffset encodes the position in p->exp
KINLINE poly k_LmInit_currRing_2_tailRing(poly p, ring tailRing, omBin tailBin)
ring rCopy0(const ring r, BOOLEAN copy_qideal, BOOLEAN copy_ordering)
BOOLEAN p_LmCheckPolyRing(poly p, ring r)
poly prMoveR(poly &p, ring src_r, ring dest_r)
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
static int rGetCurrSyzLimit(const ring r)
static unsigned pLength(poly a)
ring rAssure_c_dp(const ring r)
BOOLEAN newHEdge(kStrategy strat)
KINLINE poly redtailBba_Z(poly p, int pos, kStrategy strat)
void kMergeBintoLSba(kStrategy strat)
void chainCritOpt_1(poly, int, kStrategy strat)
static void p_SetExpV(poly p, int *ev, const ring r)
poly ksCreateShortSpoly(poly p1, poly p2, ring tailRing)
BOOLEAN syzCriterionInc(poly sig, unsigned long not_sevSig, kStrategy strat)
int kFindNextDivisibleByInS(const kStrategy strat, int start, int max_ind, LObject *L)
long p_WFirstTotalDegree(poly p, const ring r)
static poly p_Copy(poly p, const ring r)
returns a copy of p
int posInLSigRing(const LSet set, const int length, LObject *p, const kStrategy)
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
void ksCreateSpoly(LObject *Pair, poly spNoether, int use_buckets, ring tailRing, poly m1, poly m2, TObject **R)
int(* red2)(LObject *L, kStrategy strat)
void initEcartPairBba(LObject *Lp, poly, poly, int, int)
static short rVar(const ring r)
#define rVar(r) (r->N)
denominator_list_s * denominator_list
int posInLSpecial(const LSet set, const int length, LObject *p, const kStrategy)
#define ALLOW_PROD_CRIT(A)
int(* test_PosInT)(const TSet T, const int tl, LObject &h)
static void p_ExpVectorAdd(poly p1, poly p2, const ring r)
static BOOLEAN rField_is_Ring_Z(const ring r)
KINLINE TObject * s_2_t(int i)
#define TEST_OPT_INTSTRATEGY
poly redtailSba(LObject *L, int pos, kStrategy strat, BOOLEAN withT, BOOLEAN normalize)
BOOLEAN p_OneComp(poly p, const ring r)
return TRUE if all monoms have the same component
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
BOOLEAN rHasLocalOrMixedOrdering(const ring r)
int ksReducePoly(LObject *PR, TObject *PW, poly spNoether, number *coef, kStrategy strat)
void kBucket_Add_q(kBucket_pt bucket, poly q, int *l)
Add to Bucket a poly ,i.e. Bpoly == q+Bpoly.
static FORCE_INLINE number n_Ann(number a, const coeffs r)
if r is a ring with zero divisors, return an annihilator!=0 of b otherwise return NULL
ideal idrMoveR(ideal &id, ring src_r, ring dest_r)
void kBucketDestroy(kBucket_pt *bucket_pt)
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
int posInSMonFirst(const kStrategy strat, const int length, const poly p)
int redRing(LObject *h, kStrategy strat)
char posInLDependsOnLength
void enterSBba(LObject &p, int atS, kStrategy strat, int atR)
CanonicalForm cd(bCommonDen(FF))
int posInT2(const TSet set, const int length, LObject &p)
#define TEST_OPT_NOT_BUCKETS
void initEcartNormal(TObject *h)
void PrintS(const char *s)
#define omFreeSize(addr, size)
#define TEST_OPT_NOT_SUGAR
long pLDeg1_WFirstTotalDegree(poly p, int *l, const ring r)
static int p_Cmp(poly p1, poly p2, ring r)
void kBucketInit(kBucket_pt bucket, poly lm, int length)
void message(int i, int *reduc, int *olddeg, kStrategy strat, int red_result)
BOOLEAN kbTest(kBucket_pt bucket)
Tests.
void finalReduceByMon(kStrategy strat)
used for GB over ZZ: final reduction by constant elements background: any known constant element of i...
KINLINE int ksReducePolyTail(LObject *PR, TObject *PW, LObject *Red)
int posInT_pLength(const TSet set, const int length, LObject &p)
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size
static BOOLEAN rField_is_Ring(const ring r)
int posInTrg0(const TSet set, const int length, LObject &p)
void completeReduce(kStrategy strat, BOOLEAN withT)
int posInL11Ringls(const LSet set, const int length, LObject *p, const kStrategy)
int(* posInL)(const LSet set, const int length, LObject *L, const kStrategy strat)
KINLINE poly kNoetherTail()
static int * initS_2_R(const int maxnr)
void exitBuchMora(kStrategy strat)
void enterSSba(LObject &p, int atS, kStrategy strat, int atR)
static BOOLEAN rIsRatGRing(const ring r)
#define ENTER_USE_MEMMOVE
int redFirst(LObject *h, kStrategy strat)
void initenterpairs(poly h, int k, int ecart, int isFromQ, kStrategy strat, int atR=-1)
int ksReducePolySig(LObject *PR, TObject *PW, long, poly spNoether, number *coef, kStrategy strat)
static int max(int a, int b)
pFDegProc pOrigFDeg_TailRing
int posInL17Ring(const LSet set, const int length, LObject *p, const kStrategy)
static void initenterstrongPairsSig(poly h, poly hSig, int k, int ecart, int isFromQ, kStrategy strat, int atR=-1)
static LSet initL(int nr=setmaxL)
static void p_LmDelete(poly p, const ring r)
void initBuchMora(ideal F, ideal Q, kStrategy strat)
#define pInit()
allocates a new monomial and initializes everything to 0
static poly redMora(poly h, int maxIndex, kStrategy strat)
KINLINE BOOLEAN k_GetLeadTerms(const poly p1, const poly p2, const ring p_r, poly &m1, poly &m2, const ring m_r)
poly pCopyL2p(LObject H, kStrategy strat)
void kMergeBintoL(kStrategy strat)
void enterSyz(LObject &p, kStrategy strat, int atT)
int posInL10(const LSet set, const int length, LObject *p, const kStrategy strat)
void cancelunit1(LObject *p, int *suc, int index, kStrategy strat)
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
static void enterOnePairLift(int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR=-1)
long pLDeg1c_Totaldegree(poly p, int *l, const ring r)
poly p_Cleardenom(poly p, const ring r)
static void p_ExpVectorAddSub(poly p1, poly p2, poly p3, const ring r)
int posInL11Ring(const LSet set, const int length, LObject *p, const kStrategy)
void initenterpairsSigRing(poly h, poly hSig, int hFrom, int k, int ecart, int isFromQ, kStrategy strat, int atR=-1)
pShallowCopyDeleteProc pGetShallowCopyDeleteProc(ring, ring)
long pLDeg1c(poly p, int *l, const ring r)
static BOOLEAN p_LmExpVectorAddIsOk(const poly p1, const poly p2, const ring r)
int posInLF5CRing(const LSet set, int start, const int length, LObject *p, const kStrategy)
void initBuchMoraPos(kStrategy strat)
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
static BOOLEAN p_DivisibleBy(poly a, poly b, const ring r)
void clearSbatch(poly h, int k, int pos, kStrategy strat)
static BOOLEAN sugarDivisibleBy(int ecart1, int ecart2)
static void p_GetExpV(poly p, int *ev, const ring r)
static poly p_Init(const ring r, omBin bin)
static int p_LmCmp(poly p, poly q, const ring r)
void chainCritPart(poly p, int ecart, kStrategy strat)
static void p_ExpVectorSum(poly pr, poly p1, poly p2, const ring r)
poly p_GetMaxExpP(poly p, const ring r)
return monomial r such that GetExp(r,i) is maximum of all monomials in p; coeff == 0,...
void kBucketClear(kBucket_pt bucket, poly *p, int *length)
TObject * kFindDivisibleByInS_T(kStrategy strat, int end_pos, LObject *L, TObject *T, long ecart)
static int rBlocks(ring r)
#define __pp_Mult_nn(p, n, r)
void messageStat(int hilbcount, kStrategy strat)
#define pLtCmpOrdSgnDiffM(p, q)
void initSyzRules(kStrategy strat)
void pLcmRat(poly a, poly b, poly m, int rat_shift)
int posInL15Ring(const LSet set, const int length, LObject *p, const kStrategy)
BOOLEAN pCompareChain(poly p, poly p1, poly p2, poly lcm, const ring R)
Returns TRUE if.
poly kNF(ideal F, ideal Q, poly p, int syzComp, int lazyReduce)
void sort(CFArray &A, int l=0)
quick sort A
void kDebugPrint(kStrategy strat)
#define pLmInit(p)
like pInit, except that expvector is initialized to that of p, p must be != NULL
denominator_list DENOMINATOR_LIST
int posInT13(const TSet set, const int length, LObject &p)
int posInL13(const LSet set, const int length, LObject *p, const kStrategy)
#define pSetCoeff(p, n)
deletes old coeff before setting the new one
int kFindInT(poly p, TSet T, int tlength)
returns index of p in TSet, or -1 if not found
int posInL110Ring(const LSet set, const int length, LObject *p, const kStrategy)
gmp_float exp(const gmp_float &a)
int ideal_isInV(ideal I, int lV)
int(* posInLSba)(const LSet set, const int length, LObject *L, const kStrategy strat)
void rDelete(ring r)
unconditionally deletes fields in r
pLDegProc pOrigLDeg_TailRing
static void p_LmFree(poly p, ring)
BOOLEAN(* rewCrit2)(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
int redSig(LObject *h, kStrategy strat)
void initBba(kStrategy strat)
poly nc_CreateShortSpoly(poly p1, poly p2, const ring r)
void initSbaPos(kStrategy strat)
long p_Deg(poly a, const ring r)
int posInL11(const LSet set, const int length, LObject *p, const kStrategy)
poly redNFBound(poly h, int &max_ind, int nonorm, kStrategy strat, int bound)
int posInIdealMonFirst(const ideal F, const poly p, int start, int end)
int posInL17_cRing(const LSet set, const int length, LObject *p, const kStrategy)
static void p_Delete(poly *p, const ring r)
void initSL(ideal F, ideal Q, kStrategy strat)
static poly p_Add_q(poly p, poly q, const ring r)
static int min(int a, int b)
int posInL17(const LSet set, const int length, LObject *p, const kStrategy)
void postReduceByMonSig(LObject *h, kStrategy strat)
BOOLEAN sbaCheckGcdPair(LObject *h, kStrategy strat)
void enterpairsShift(poly h, int k, int ecart, int pos, kStrategy strat, int atR, int uptodeg, int lV)
long maxdegreeWecart(poly p, int *l, ring r)
int posInT15Ring(const TSet set, const int length, LObject &p)
KINLINE poly redtailBba(poly p, int pos, kStrategy strat, BOOLEAN normalize)
static poly normalize(poly next_p, ideal add_generators, syStrategy syzstr, int *g_l, int *p_l, int crit_comp)
void initBuchMoraPosRing(kStrategy strat)
void rWrite(ring r, BOOLEAN details)
void chainCritNormal(poly p, int ecart, kStrategy strat)
static int si_max(const int a, const int b)
static CanonicalForm bound(const CFMatrix &M)
poly p_Shrink(poly p, int lV, const ring r)
void mult(unsigned long *result, unsigned long *a, unsigned long *b, unsigned long p, int dega, int degb)
void enterSMora(LObject &p, int atS, kStrategy strat, int atR=-1)
pShallowCopyDeleteProc p_shallow_copy_delete
long pLDeg1_Deg(poly p, int *l, const ring r)
KINLINE poly redtailBbaBound(poly p, int pos, kStrategy strat, int bound, BOOLEAN normalize)
BOOLEAN p_CheckPolyRing(poly p, ring r)
#define rRing_has_Comp(r)
int posInL110(const LSet set, const int length, LObject *p, const kStrategy)
static poly redBba(poly h, int maxIndex, kStrategy strat)
void initSLSba(ideal F, ideal Q, kStrategy strat)
void(* initEcartPair)(LObject *h, poly f, poly g, int ecartF, int ecartG)
void initSbaBuchMora(ideal F, ideal Q, kStrategy strat)
#define TEST_OPT_SUGARCRIT
void cleanTSbaRing(kStrategy strat)
void omMergeStickyBinIntoBin(omBin sticky_bin, omBin into_bin)
void reorderS(int *suc, kStrategy strat)
poly p_NSet(number n, const ring r)
returns the poly representing the number n, destroys n
void Werror(const char *fmt,...)
ideal idInit(int idsize, int rank)
initialise an ideal / module
static number p_SetCoeff(poly p, number n, ring r)
#define pp_Test(p, lmRing, tailRing)
int posInLF5C(const LSet, const int, LObject *, const kStrategy strat)
BOOLEAN idInsertPolyOnPos(ideal I, poly p, int pos)
insert p into I on position pos
static unsigned long * initsevS(const int maxnr)
ring rModifyRing(ring r, BOOLEAN omit_degree, BOOLEAN try_omit_comp, unsigned long exp_limit)
static FORCE_INLINE number n_Gcd(number a, number b, const coeffs r)
in Z: return the gcd of 'a' and 'b' in Z/nZ, Z/2^kZ: computed as in the case Z in Z/pZ,...
void WerrorS(const char *s)
static long p_GetExpDiff(poly p1, poly p2, int i, ring r)
static void enterOnePairRing(int i, poly p, int, int isFromQ, kStrategy strat, int atR)
void HEckeTest(poly pp, kStrategy strat)
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:...
unsigned long p_GetMaxExpL(poly p, const ring r, unsigned long l_max)
return the maximal exponent of p in form of the maximal long var
#define pLmDelete(p)
assume p != NULL, deletes Lm(p)->coef and Lm(p)
int posInT1(const TSet set, const int length, LObject &p)
ideal idSyzygies(ideal h1, tHomog h, intvec **w, BOOLEAN setSyzComp, BOOLEAN setRegularity, int *deg, GbVariant alg)
#define pLmShortDivisibleBy(a, sev_a, b, not_sev_b)
Divisibility tests based on Short Exponent vectors sev_a == pGetShortExpVector(a) not_sev_b == ~ pGet...
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
int lcm(unsigned long *l, unsigned long *a, unsigned long *b, unsigned long p, int dega, int degb)
static void enlargeT(TSet &T, TObject **&R, unsigned long *&sevT, int &length, const int incr)
int posInLrg0(const LSet set, const int length, LObject *p, const kStrategy)
long p_WTotaldegree(poly p, const ring r)
#define omRealloc0Size(addr, o_size, size)
void initSSpecialSba(ideal F, ideal Q, ideal P, kStrategy strat)
int posInT11Ring(const TSet set, const int length, LObject &p)
char completeReduce_retry
static void p_Setm(poly p, const ring r)
int posInL15(const LSet set, const int length, LObject *p, const kStrategy)
#define TEST_OPT_CANCELUNIT
void initenterpairsShift(poly h, int k, int ecart, int isFromQ, kStrategy strat, int atR, int uptodeg, int lV)
#define pLmDivisibleBy(a, b)
like pDivisibleBy, except that it is assumed that a!=NULL, b!=NULL
void updateSShift(kStrategy strat, int uptodeg, int lV)
void initenterstrongPairs(poly h, int k, int ecart, int isFromQ, kStrategy strat, int atR=-1)
static int doRed(LObject *h, TObject *with, BOOLEAN intoT, kStrategy strat, bool redMoraNF)
void cancelunit(LObject *L, BOOLEAN inNF)
static int pDivComp(poly p, poly q)
#define TEST_OPT_REDTHROUGH
static long p_Totaldegree(poly p, const ring r)
void initSba(ideal F, kStrategy strat)
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...
#define REDNF_CANONICALIZE
kBucket_pt kBucketCreate(const ring bucket_ring)
Creation/Destruction of buckets.
int posInT17Ring(const TSet set, const int length, LObject &p)
void messageStatSBA(int hilbcount, kStrategy strat)
void enterL(LSet *set, int *length, int *LSetmax, LObject p, int at)
int redLazy(LObject *h, kStrategy strat)
void deleteInL(LSet set, int *length, int j, kStrategy strat)
void(* initEcart)(TObject *L)
const CanonicalForm int s
static unsigned long p_GetMaxExp(const unsigned long l, const ring r)
#define pLmCmp(p, q)
returns 0|1|-1 if p=q|p>q|p<q w.r.t monomial ordering
void initSSpecial(ideal F, ideal Q, ideal P, kStrategy strat)
static BOOLEAN rIsSyzIndexRing(const ring r)
int(* red)(LObject *L, kStrategy strat)
long kHomModDeg(poly p, ring r)
void initEcartBBA(TObject *h)
void enterpairs(poly h, int k, int ecart, int pos, kStrategy strat, int atR)
#define pCopy(p)
return a copy of the poly
#define SI_RESTORE_OPT1(A)
static FORCE_INLINE nMapFunc n_SetMap(const coeffs src, const coeffs dst)
set the mapping function pointers for translating numbers from src to dst
int(* posInT)(const TSet T, const int tl, LObject &h)
int posInT15(const TSet set, const int length, LObject &p)
void initenterpairsSig(poly h, poly hSig, int hFrom, int k, int ecart, int isFromQ, kStrategy strat, int atR=-1)
ideal kStd(ideal F, ideal Q, tHomog h, intvec **w, intvec *hilb, int syzComp, int newIdeal, intvec *vw, s_poly_proc_t sp)
poly p_ISet(long i, const ring r)
returns the poly representing the integer i
int comp(const CanonicalForm &A, const CanonicalForm &B)
compare polynomials
int posInT0(const TSet, const int length, LObject &)
static poly p_Mult_q(poly p, poly q, const ring r)
void deleteInS(int i, kStrategy strat)
#define pHead(p)
returns newly allocated copy of Lm(p), coef is copied, next=NULL, p might be NULL
KINLINE void k_GetStrongLeadTerms(const poly p1, const poly p2, const ring leadRing, poly &m1, poly &m2, poly &lcm, const ring tailRing)
void initEcartPairMora(LObject *Lp, poly, poly, int ecartF, int ecartG)
BOOLEAN rHasMixedOrdering(const ring r)
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
int redFirstShift(LObject *h, kStrategy strat)
void enterOnePairNormal(int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR=-1)
ideal kInterRed(ideal F, ideal Q)
ring sbaRing(kStrategy strat, const ring r, BOOLEAN, int)
static bool rIsSCA(const ring r)
BOOLEAN kStratChangeTailRing(kStrategy strat, LObject *L, TObject *T, unsigned long expbound)
unsigned long p_GetShortExpVector(const poly p, const ring r)
KINLINE TObject ** initR()
poly p_LPshift(poly p, int sh, int uptodeg, int lV, const ring r)
omBin omGetStickyBinOfBin(omBin bin)
BOOLEAN(* syzCrit)(poly sig, unsigned long not_sevSig, kStrategy strat)
BOOLEAN pHaveCommonMonoms(poly p, poly q)
static long p_FDeg(const poly p, const ring r)
poly kCreateZeroPoly(long exp[], long cabsind, poly *t_p, ring leadRing, ring tailRing)
void enterExtendedSpoly(poly h, kStrategy strat)
void initHilbCrit(ideal, ideal, intvec **hilb, kStrategy strat)
static long p_MaxComp(poly p, ring lmRing, ring tailRing)
void exitSba(kStrategy strat)
int redHoney(LObject *h, kStrategy strat)
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_Z(const coeffs r)
static FORCE_INLINE number n_ExtGcd(number a, number b, number *s, number *t, const coeffs r)
beware that ExtGCD is only relevant for a few chosen coeff. domains and may perform something unexpec...
static FORCE_INLINE BOOLEAN n_IsUnit(number n, const coeffs r)
TRUE iff n has a multiplicative inverse in the given coeff field/ring r.
int ksReducePolySigRing(LObject *PR, TObject *PW, long, poly spNoether, number *coef, kStrategy strat)
void superenterpairsSig(poly h, poly hSig, int hFrom, int k, int ecart, int pos, kStrategy strat, int atR)
void enterT(LObject &p, kStrategy strat, int atT)
static intvec * idSort(ideal id, BOOLEAN nolex=TRUE)
static BOOLEAN p_LmShortDivisibleBy(poly a, unsigned long sev_a, poly b, unsigned long not_sev_b, const ring r)
#define pCmp(p1, p2)
pCmp: args may be NULL returns: (p2==NULL ? 1 : (p1 == NULL ? -1 : p_LmCmp(p1, p2)))
static void nc_kBucketPolyRed(kBucket_pt b, poly p, number *c)
int posInT11(const TSet set, const int length, LObject &p)
void enterTShift(LObject p, kStrategy strat, int atT, int uptodeg, int lV)
int redSigRing(LObject *h, kStrategy strat)
void nKillChar(coeffs r)
undo all initialisations
void(* enterOnePair)(int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR)
#define idPosConstant(I)
index of generator with leading term in ground ring (if any); otherwise -1
int redHomog(LObject *h, kStrategy strat)
poly pMoveCurrTail2poly(poly p, kStrategy strat)
BOOLEAN pIsMonomOf(poly p, poly m)
void initS(ideal F, ideal Q, kStrategy strat)
int nextZeroSimplexExponent(long exp[], long ind[], long cexp[], long cind[], long *cabsind, long step[], long bound, long N)
BOOLEAN rComplete(ring r, int force)
this needs to be called whenever a new ring is created: new fields in ring are created (like VarOffse...
#define omReallocSize(addr, o_size, size)
void p_Cleardenom_n(poly ph, const ring r, number &c)
BOOLEAN p_CheckIsFromRing(poly p, ring r)