 |
My Project
debian-1:4.1.1-p2+ds-4build2
|
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 7088 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 7113 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);
2057 if (red_result == 1)
2060 strat->
P.GetP(strat->
lmBin);
2069 int pos=
posInS(strat,strat->
sl,strat->
P.p,strat->
P.ecart);
2077 strat->
P.pCleardenom();
2081 strat->
P.pCleardenom();
2090 strat->
P.p =
redtailBba(&(strat->
P),pos-1,strat, withT);
2102 if (strat->
minim==1)
2109 strat->
M->m[minimcnt]=strat->
P.p2;
2113 pNext(strat->
M->m[minimcnt])
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)
2157 if (strat->
s_poly(strat))
2162 int pos=
posInS(strat,strat->
sl,strat->
P.p,strat->
P.ecart);
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));
2214 #ifdef HAVE_TAIL_RING
2233 for(
int i = 0;
i<=strat->
sl;
i++)
2241 for(
int i = 0;
i<=strat->
sl;
i++)
2269 return (strat->
Shdl);
◆ bbaShift()
Definition at line 3862 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);
4044 if (strat->
minim==1)
4051 strat->
M->m[minimcnt]=strat->
P.p2;
4055 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);
4088 strat->
P.t_p =
NULL;
4089 goto red_shrink2zero;
4099 strat->
P.t_p =
NULL;
4111 strat->
P.t_p =
NULL;
4112 goto red_shrink2zero;
4126 int atR=strat->
tl+1;
4132 strat->
enterS(strat->
P, pos, strat, atR);
4134 if (hilb!=
NULL)
khCheck(
Q,
w,hilb,hilbeledeg,hilbcount,strat);
4147 memset(&(strat->
P), 0,
sizeof(strat->
P));
4170 Ln.SetShortExpVector();
4172 if (
j<0) {
k++;
j=-1;}
4178 if (
j<0) {
k++;
j=-1;}
4199 #ifdef HAVE_TAIL_RING
4228 return (strat->
Shdl);
◆ cancelunit()
Definition at line 332 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 3124 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 3353 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 537 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 10399 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);
10512 sloppy_max =
FALSE;
◆ createG0()
Definition at line 4389 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 243 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 1152 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 1045 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 1097 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 4504 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 4587 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 1215 of file kutil.cc.
1224 #ifdef ENTER_USE_MEMMOVE
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 1861 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 |
|
) |
| |
Definition at line 12026 of file kutil.cc.
12063 for (;
j<= toInsert;
j++)
12080 enterOnePairShift(q,
p, ecart, isFromQ, strat, -1, ecartq, qfromQ,
j, -1, uptodeg, 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 12089 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) )
12362 && (Lp.p->coef!=
NULL))
12366 l = strat->
posInL(strat->
B,strat->
Bl,&Lp,strat);
◆ 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 9034 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;
9127 strat->
sevS[atS] =
p.sev;
9129 strat->
S_2_R[atS] = atR;
◆ entersets()
◆ enterSSba()
Definition at line 9137 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++)
9268 PrintS(
"--- LIST S END ---\n");
◆ enterSyz()
Definition at line 9458 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");
9531 PrintS(
"--------------------------------\n");
◆ enterT()
Definition at line 9275 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;
9345 strat->
R[strat->
tl] = &(strat->
T[atT]);
9346 strat->
T[atT].i_r = strat->
tl;
◆ enterT_strong()
Definition at line 9356 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()
Definition at line 12482 of file kutil.cc.
12497 atT = strat->
posInT(strat->
T, strat->
tl,
p);
12504 for (
i=1;
i<=toInsert;
i++)
12519 atT = strat->
posInT(strat->
T, strat->
tl, qq);
◆ 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 3542 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);
3682 if (red_result == 1)
3685 strat->
P.GetP(strat->
lmBin);
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);
3730 if (strat->
minim==1)
3737 strat->
M->m[minimcnt]=strat->
P.p2;
3741 pNext(strat->
M->m[minimcnt])
3754 strat->
enterS(strat->
P, pos, strat, strat->
tl);
3757 PrintS(
"ELEMENT ADDED TO GCURR DURING INTERRED: ");
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;
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;
3805 for (
int cd=strat->
Ll;
cd>=0;
cd--)
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)
3836 printf(
"- - - - - -\n");
3839 PrintS(
"-------------------------------------------------\n");
3840 PrintS(
"------------------- STRAT L ---------------------\n");
3842 while (cc<strat->Ll+1)
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 7029 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 10971 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 4232 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 9554 of file kutil.cc.
9567 #ifdef HAVE_RATGRING
9612 if (strat->
homog)
PrintS(
"ideal/module is homogeneous\n");
9613 else PrintS(
"ideal/module is not homogeneous\n");
◆ initBuchMoraPos()
◆ initBuchMoraPosRing()
◆ initBuchMoraShift()
void initBuchMoraShift |
( |
ideal |
F, |
|
|
ideal |
Q, |
|
|
kStrategy |
strat |
|
) |
| |
◆ initEcartBBA()
◆ initEcartNormal()
void initEcartNormal |
( |
TObject * |
h | ) |
|
Definition at line 1239 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 1254 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 1261 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 7848 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 9618 of file kutil.cc.
9644 #ifdef HAVE_RATGRING
9683 if (strat->
homog)
PrintS(
"ideal/module is homogeneous\n");
9684 else PrintS(
"ideal/module is not homogeneous\n");
◆ initSbaPos()
◆ initsevT()
KINLINE unsigned long* initsevT |
( |
| ) |
|
◆ initSL()
void initSL |
( |
ideal |
F, |
|
|
ideal |
Q, |
|
|
kStrategy |
strat |
|
) |
| |
Definition at line 7942 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 8039 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 8189 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");
8336 PrintS(
"--------------------------------\n");
◆ initT()
◆ k_GetLeadTerms()
Definition at line 939 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 982 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 10585 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 10623 of file kutil.cc.
10628 poly p1_max = (strat->
R[atR])->max_exp;
10629 poly p2_max = (strat->
R[strat->
S_2_R[atS]])->max_exp;
◆ kCreateZeroPoly()
poly kCreateZeroPoly |
( |
long |
exp[], |
|
|
long |
cabsind, |
|
|
poly * |
t_p, |
|
|
ring |
leadRing, |
|
|
ring |
tailRing |
|
) |
| |
Definition at line 4260 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 11583 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: ");
11713 #ifndef SING_NDEBUG
◆ 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 7163 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 704 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 1005 of file kspoly.cc.
1056 if ((c1==c2)||(c2!=0))
1106 if ((c1==c2)||(c1!=0))
◆ ksCreateSpoly()
Definition at line 759 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
871 Pair->SetShortExpVector();
◆ ksOldCreateSpoly()
Definition at line 1077 of file kInline.h.
1084 return L.GetLmCurrRing();
◆ ksOldSpolyRed()
KINLINE poly ksOldSpolyRed |
( |
poly |
p1, |
|
|
poly |
p2, |
|
|
poly |
spNoether = NULL |
|
) |
| |
Definition at line 1057 of file kInline.h.
1064 return L.GetLmCurrRing();
◆ ksOldSpolyRedNew()
KINLINE poly ksOldSpolyRedNew |
( |
poly |
p1, |
|
|
poly |
p2, |
|
|
poly |
spNoether = NULL |
|
) |
| |
Definition at line 1067 of file kInline.h.
1074 return L.GetLmCurrRing();
◆ ksOldSpolyTail()
KINLINE void ksOldSpolyTail |
( |
poly |
p1, |
|
|
poly |
q, |
|
|
poly |
q2, |
|
|
poly |
spNoether, |
|
|
ring |
r = currRing |
|
) |
| |
◆ ksReducePoly()
Definition at line 41 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 172 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 311 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 509 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 1030 of file kInline.h.
1035 assume(PR->GetLmCurrRing() != PW->GetLmCurrRing());
1036 Red->HeadNormalize();
◆ ksReducePolyTail() [2/2]
Definition at line 877 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
926 PR->SetShortExpVector();
◆ kStratChangeTailRing()
Definition at line 11037 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 11136 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 7729 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 7770 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 7782 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()
◆ pMove2CurrTail()
poly pMove2CurrTail |
( |
poly |
p, |
|
|
kStrategy |
strat |
|
) |
| |
◆ pMoveCurrTail2poly()
poly pMoveCurrTail2poly |
( |
poly |
p, |
|
|
kStrategy |
strat |
|
) |
| |
◆ posInIdealMonFirst()
int posInIdealMonFirst |
( |
const ideal |
F, |
|
|
const poly |
p, |
|
|
int |
start = 0 , |
|
|
int |
end = -1 |
|
) |
| |
Definition at line 5113 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 1010 of file kstd1.cc.
1017 int op=
p->GetpFDeg() +
p->ecart;
1025 && (set[
j].GetpFDeg()+set[
j].ecart >= op))
◆ posInL10Ring()
◆ posInL11()
Definition at line 6223 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 6521 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 6265 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 6335 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 6609 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 6644 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 6679 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 6720 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 6299 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 6110 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 6047 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 4935 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 5036 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 6183 of file kutil.cc.
6185 if (strat->
syzl==0)
return 0;
6190 int en= strat->
syzl-1;
◆ posInT0()
◆ posInT1()
◆ posInT11()
Definition at line 5226 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 5379 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 5468 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 5536 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 5631 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 5738 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 5865 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 11458 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();
11501 || ((oo == op) && (set[
i].
pLength > ol)))
◆ posInT_EcartpLength()
Definition at line 5497 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 11512 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)))
11538 int oo=set[
i].GetpFDeg();
11540 || ((oo == op) && (set[
i].
pLength > ol)))
◆ posInT_pLength()
Definition at line 11549 of file kutil.cc.
11551 int ol =
p.GetpLength();
11565 if (set[an].
pLength>ol)
return an;
◆ 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 10814 of file kutil.cc.
10818 poly pH =
h->GetP();
10822 for(
int i = 0;
i<=strat->
sl;
i++)
10877 h->SetLmCurrRing();
10878 if((deleted)&&(
h->p!=
NULL))
◆ postReduceByMonSig()
Definition at line 10882 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)
10960 h->SetLmCurrRing();
◆ 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 10646 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 4266 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 344 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 7305 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 7381 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();
7492 return L->GetLmCurrRing();
◆ redtailBba() [2/3]
◆ redtailBba() [3/3]
◆ redtailBba_Z() [1/2]
Definition at line 7611 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();
7722 return L->GetLmCurrRing();
◆ redtailBba_Z() [2/2]
◆ redtailBbaBound() [1/2]
Definition at line 7495 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();
7607 return L->GetLmCurrRing();
◆ redtailBbaBound() [2/2]
◆ redtailBbaShift()
Definition at line 12529 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();
12607 return L->GetLmCurrRing();
◆ 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 4882 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];
2401 #if SBA_INTERRED_START
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);
2668 &olddeg,&reduc,strat, red_result);
2676 if (red_result == 1)
2679 strat->
P.GetP(strat->
lmBin);
2683 (strat->
P).FDeg = (strat->
P).pFDeg();
2695 int pos = strat->
sl+1;
2703 beforetailred =
pCopy(strat->
P.sig);
2709 strat->
P.p =
redtailSba(&(strat->
P),pos-1,strat, withT);
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)
2747 red_result =
redRing(&strat->
P,strat);
2756 strat->
enterS(strat->
P, 0, strat, strat->
tl);
2762 if(strat->
P.p ==
NULL)
2763 goto case_when_red_result_changed;
2769 for (
int jj = 0; jj<strat->
tl+1; jj++)
2773 strat->
T[jj].is_sigsafe =
FALSE;
2779 for (
int jj = 0; jj<strat->
tl+1; jj++)
2781 strat->
T[jj].is_sigsafe =
FALSE;
2791 if (strat->
minim==1)
2798 strat->
M->m[minimcnt]=strat->
P.p2;
2802 pNext(strat->
M->m[minimcnt])
2812 strat->
T[strat->
tl].is_sigsafe =
FALSE;
2826 strat->
enterS(strat->
P, pos, strat, strat->
tl);
2830 for (
int tk=0; tk<strat->
sl+1; tk++)
2851 for(
int ps=0;ps<strat->
sl+1;ps++)
2859 (strat->
syzmax)*
sizeof(
unsigned long),
2861 *
sizeof(
unsigned long));
2903 for (
int i=0;
i<strat->
sl; ++
i)
2920 for (
int i=cmp+1;
i<=max_cmp; ++
i)
2923 for (
int j=0;
j<strat->
sl; ++
j)
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 : ");
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)
3049 memset(&(strat->
P), 0,
sizeof(strat->
P));
3084 #ifdef HAVE_TAIL_RING
3100 #if SBA_PRINT_SIZE_SYZ
3102 size_syz = strat->
syzl;
3115 #if SBA_PRINT_SIZE_G
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--)
3184 #if SBA_PRINT_SIZE_G
3188 printf(
"SIZE OF SHDL: %d\n",
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 1608 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 11163 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 6945 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 6980 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 10187 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 8807 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++)
9023 if (suc!= -1)
updateS(toT,strat);
◆ updateSShift()
void updateSShift |
( |
kStrategy |
strat, |
|
|
int |
uptodeg, |
|
|
int |
lV |
|
) |
| |
Definition at line 11843 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)
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
void rDebugPrint(const ring r)
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 poly p_LmInit(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)
void updateS(BOOLEAN toT, 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....
@ n_Q
rational (GMP) numbers
#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
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)
void enterOnePairShift(poly q, poly p, int ecart, int isFromQ, kStrategy strat, int atR, int ecartq, int qisFromQ, int shiftcount, int ifromS, int, int lV)
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)
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)
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)
KINLINE poly k_LmShallowCopyDelete_tailRing_2_currRing(poly p, ring tailRing, omBin lmBin)
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)
BOOLEAN kPosInLDependsOnLength(int(*pos_in_l)(const LSet set, const int length, LObject *L, const kStrategy strat))
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)
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)