 |
My Project
debian-1:4.1.1-p2+ds-4
|
Go to the source code of this file.
|
static poly | redMora (poly h, int maxIndex, kStrategy strat) |
|
static poly | redBba (poly h, int maxIndex, kStrategy strat) |
|
static int | pDivCompRing (poly p, poly q) |
|
static int | pDivComp (poly p, poly q) |
|
void | deleteHC (LObject *L, kStrategy strat, BOOLEAN fromNext) |
|
void | deleteHC (poly *p, int *e, int *l, kStrategy strat) |
|
void | cancelunit (LObject *L, BOOLEAN inNF) |
|
void | HEckeTest (poly pp, kStrategy strat) |
|
static intset | initec (const int maxnr) |
|
static unsigned long * | initsevS (const int maxnr) |
|
static int * | initS_2_R (const int maxnr) |
|
static void | enlargeT (TSet &T, TObject **&R, unsigned long *&sevT, int &length, const int incr) |
|
void | cleanT (kStrategy strat) |
|
void | cleanTSbaRing (kStrategy strat) |
|
static void | enlargeL (LSet *L, int *length, const int incr) |
|
void | initPairtest (kStrategy strat) |
|
BOOLEAN | isInPairsetL (int length, poly p1, poly p2, int *k, kStrategy strat) |
|
BOOLEAN | isInPairsetB (poly q, int *k, kStrategy strat) |
|
int | kFindInT (poly p, TSet T, int tlength) |
| returns index of p in TSet, or -1 if not found More...
|
|
int | kFindInT (poly p, kStrategy strat) |
|
void | deleteInS (int i, kStrategy strat) |
|
void | deleteInSSba (int i, kStrategy strat) |
|
void | deleteInL (LSet set, int *length, int j, kStrategy strat) |
|
void | enterL (LSet *set, int *length, int *LSetmax, LObject p, int at) |
|
void | initEcartNormal (TObject *h) |
|
void | initEcartBBA (TObject *h) |
|
void | initEcartPairBba (LObject *Lp, poly, poly, int, int) |
|
void | initEcartPairMora (LObject *Lp, poly, poly, int ecartF, int ecartG) |
|
static BOOLEAN | sugarDivisibleBy (int ecart1, int ecart2) |
|
static void | enterOnePairRing (int i, poly p, int, int isFromQ, kStrategy strat, int atR) |
|
static BOOLEAN | enterOneStrongPoly (int i, poly p, int, int, kStrategy strat, int atR, bool enterTstrong) |
|
BOOLEAN | sbaCheckGcdPair (LObject *h, kStrategy strat) |
|
static BOOLEAN | enterOneStrongPolySig (int i, poly p, poly sig, int, int, kStrategy strat, int atR) |
|
void | enterOnePairNormal (int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR=-1) |
|
static BOOLEAN | p_HasNotCF_Lift (poly p1, poly p2, const ring r) |
| p_HasNotCF for the IDLIFT case: ignore component More...
|
|
static void | enterOnePairLift (int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR=-1) |
|
static void | enterOnePairSig (int i, poly p, poly pSig, int, int ecart, int isFromQ, kStrategy strat, int atR=-1) |
|
static void | enterOnePairSigRing (int i, poly p, poly pSig, int, int ecart, int isFromQ, kStrategy strat, int atR=-1) |
|
void | enterOnePairSpecial (int i, poly p, int ecart, kStrategy strat, int atR=-1) |
|
void | kMergeBintoL (kStrategy strat) |
|
void | kMergeBintoLSba (kStrategy strat) |
|
void | chainCritNormal (poly p, int ecart, kStrategy strat) |
|
void | chainCritOpt_1 (poly, int, kStrategy strat) |
|
void | chainCritSig (poly p, int, kStrategy strat) |
|
void | chainCritPart (poly p, int ecart, kStrategy strat) |
|
void | initenterpairs (poly h, int k, int ecart, int isFromQ, kStrategy strat, int atR=-1) |
|
void | initenterpairsSig (poly h, poly hSig, int hFrom, int k, int ecart, int isFromQ, kStrategy strat, int atR=-1) |
|
void | initenterpairsSigRing (poly h, poly hSig, int hFrom, int k, int ecart, int isFromQ, kStrategy strat, int atR=-1) |
|
void | chainCritRing (poly p, int, kStrategy strat) |
|
long | ind2 (long arg) |
|
long | ind_fact_2 (long arg) |
|
long | twoPow (long arg) |
|
void | enterOneZeroPairRing (poly f, poly t_p, poly p, int ecart, kStrategy strat, int atR=-1) |
|
int | nextZeroSimplexExponent (long exp[], long ind[], long cexp[], long cind[], long *cabsind, long step[], long bound, long N) |
|
poly | kCreateZeroPoly (long exp[], long cabsind, poly *t_p, ring leadRing, ring tailRing) |
|
void | initenterzeropairsRing (poly p, int ecart, kStrategy strat, int atR) |
|
ideal | createG0 () |
|
void | initenterstrongPairs (poly h, int k, int ecart, int isFromQ, kStrategy strat, int atR=-1) |
|
static void | initenterstrongPairsSig (poly h, poly hSig, int k, int ecart, int isFromQ, kStrategy strat, int atR=-1) |
|
void | enterExtendedSpoly (poly h, kStrategy strat) |
|
void | enterExtendedSpolySig (poly h, poly hSig, kStrategy strat) |
|
void | clearSbatch (poly h, int k, int pos, kStrategy strat) |
|
void | superenterpairs (poly h, int k, int ecart, int pos, kStrategy strat, int atR) |
|
void | superenterpairsSig (poly h, poly hSig, int hFrom, int k, int ecart, int pos, kStrategy strat, int atR) |
|
void | enterpairs (poly h, int k, int ecart, int pos, kStrategy strat, int atR) |
|
void | enterpairsSig (poly h, poly hSig, int hFrom, int k, int ecart, int pos, kStrategy strat, int atR) |
|
void | enterpairsSpecial (poly h, int k, int ecart, int pos, kStrategy strat, int atR=-1) |
|
void | reorderS (int *suc, kStrategy strat) |
|
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, int end) |
|
int | posInT0 (const TSet, const int length, LObject &) |
|
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 | posInT11Ring (const TSet set, const int length, LObject &p) |
|
int | posInTrg0 (const TSet set, const int length, LObject &p) |
|
int | posInT110 (const TSet set, const int length, LObject &p) |
|
int | posInT110Ring (const TSet set, const int length, LObject &p) |
|
int | posInT13 (const TSet set, const int length, LObject &p) |
|
int | posInT_EcartpLength (const TSet set, const int length, LObject &p) |
|
int | posInT15 (const TSet set, const int length, LObject &p) |
|
int | posInT15Ring (const TSet set, const int length, LObject &p) |
|
int | posInT17 (const TSet set, const int length, LObject &p) |
|
int | posInT17Ring (const TSet set, const int length, LObject &p) |
|
int | posInT17_c (const TSet set, const int length, LObject &p) |
|
int | posInT17_cRing (const TSet set, const int length, LObject &p) |
|
int | posInT19 (const TSet set, const int length, LObject &p) |
|
int | posInLSpecial (const LSet set, const int length, LObject *p, const kStrategy) |
|
int | posInL0 (const LSet set, const int length, LObject *p, const kStrategy) |
|
int | posInL0Ring (const LSet set, const int length, LObject *p, const kStrategy) |
|
int | posInLSig (const LSet set, const int length, LObject *p, const kStrategy) |
|
int | posInLSigRing (const LSet set, const int length, LObject *p, const kStrategy) |
|
int | posInLRing (const LSet set, const int length, LObject *p, const kStrategy) |
|
int | posInSyz (const kStrategy strat, poly sig) |
|
int | posInLF5C (const LSet, const int, LObject *, const kStrategy strat) |
|
int | posInL11 (const LSet set, const int length, LObject *p, const kStrategy) |
|
int | posInL11Ring (const LSet set, const int length, LObject *p, const kStrategy) |
|
int | posInLF5CRing (const LSet set, int start, const int length, LObject *p, const kStrategy) |
|
int | posInL11Ringls (const LSet set, const int length, LObject *p, const kStrategy) |
|
int | getIndexRng (long coeff) |
|
int | posInLrg0 (const LSet set, const int length, LObject *p, const kStrategy) |
|
int | posInL110 (const LSet set, const int length, LObject *p, const kStrategy) |
|
int | posInL110Ring (const LSet set, const int length, LObject *p, const kStrategy) |
|
int | posInL13 (const LSet set, const int length, LObject *p, const kStrategy) |
|
int | posInL15 (const LSet set, const int length, LObject *p, const kStrategy) |
|
int | posInL15Ring (const LSet set, const int length, LObject *p, const kStrategy) |
|
int | posInL17 (const LSet set, const int length, LObject *p, const kStrategy) |
|
int | posInL17Ring (const LSet set, const int length, LObject *p, const kStrategy) |
|
int | posInL17_c (const LSet set, const int length, LObject *p, const kStrategy) |
|
int | posInL17_cRing (const LSet set, const int length, LObject *p, const kStrategy) |
|
BOOLEAN | syzCriterion (poly sig, unsigned long not_sevSig, kStrategy strat) |
|
BOOLEAN | syzCriterionInc (poly sig, unsigned long not_sevSig, kStrategy strat) |
|
BOOLEAN | faugereRewCriterion (poly sig, unsigned long not_sevSig, poly, kStrategy strat, int start=0) |
|
BOOLEAN | arriRewCriterion (poly, unsigned long, poly, kStrategy strat, int start=0) |
|
BOOLEAN | arriRewCriterionPre (poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int) |
|
TObject * | kFindDivisibleByInS_T (kStrategy strat, int end_pos, LObject *L, TObject *T, long ecart) |
|
poly | redtail (LObject *L, int end_pos, kStrategy strat) |
|
poly | redtail (poly p, int end_pos, kStrategy strat) |
|
poly | redtailBba (LObject *L, int end_pos, kStrategy strat, BOOLEAN withT, BOOLEAN normalize) |
|
poly | redtailBbaBound (LObject *L, int end_pos, kStrategy strat, int bound, BOOLEAN withT, BOOLEAN normalize) |
|
poly | redtailBba_Z (LObject *L, int end_pos, 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 | 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 | initSSpecial (ideal F, ideal Q, ideal P, kStrategy strat) |
|
void | initSSpecialSba (ideal F, ideal Q, ideal P, kStrategy strat) |
|
static poly | redBba1 (poly h, int maxIndex, kStrategy strat) |
|
void | cancelunit1 (LObject *p, int *suc, int index, kStrategy strat) |
|
void | updateS (BOOLEAN toT, kStrategy strat) |
|
void | enterSBba (LObject &p, int atS, kStrategy strat, int atR) |
|
void | enterSSba (LObject &p, int atS, kStrategy strat, int atR) |
|
void | enterT (LObject &p, kStrategy strat, int atT) |
|
void | enterT_strong (LObject &p, kStrategy strat, int atT) |
|
void | enterSyz (LObject &p, kStrategy strat, int atT) |
|
void | initHilbCrit (ideal, ideal, intvec **hilb, kStrategy strat) |
|
void | initBuchMoraCrit (kStrategy strat) |
|
void | initSbaCrit (kStrategy strat) |
|
BOOLEAN | kPosInLDependsOnLength (int(*pos_in_l)(const LSet set, const int length, LObject *L, const kStrategy strat)) |
|
void | initBuchMoraPos (kStrategy strat) |
|
void | initBuchMoraPosRing (kStrategy strat) |
|
void | initBuchMora (ideal F, ideal Q, kStrategy strat) |
|
void | exitBuchMora (kStrategy strat) |
|
void | initSbaPos (kStrategy strat) |
|
void | initSbaBuchMora (ideal F, ideal Q, kStrategy strat) |
|
void | exitSba (kStrategy strat) |
|
void | updateResult (ideal r, ideal Q, kStrategy strat) |
|
void | completeReduce (kStrategy strat, BOOLEAN withT) |
|
BOOLEAN | newHEdge (kStrategy strat) |
|
BOOLEAN | kCheckSpolyCreation (LObject *L, kStrategy strat, poly &m1, poly &m2) |
|
BOOLEAN | kCheckStrongCreation (int atR, poly m1, int atS, poly m2, kStrategy strat) |
|
poly | preIntegerCheck (const ideal Forig, const 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, TObject *T, unsigned long expbound) |
|
void | kStratInitChangeTailRing (kStrategy strat) |
|
ring | sbaRing (kStrategy strat, const ring r, BOOLEAN, int) |
|
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) |
|
int | redFirst (LObject *h, kStrategy strat) |
|
int | redEcart (LObject *h, kStrategy strat) |
|
void | enterSMora (LObject &p, int atS, kStrategy strat, int atR=-1) |
|
void | enterSMoraNF (LObject &p, int atS, kStrategy strat, int atR=-1) |
|
char * | showOption () |
|
void | kDebugPrint (kStrategy strat) |
| Output some debug info about a given strategy. More...
|
|
poly | pMove2CurrTail (poly p, kStrategy strat) |
|
poly | pMoveCurrTail2poly (poly p, kStrategy strat) |
|
poly | pCopyL2p (LObject H, kStrategy strat) |
|
void | updateSShift (kStrategy strat, int uptodeg, int lV) |
|
void | initBuchMoraShift (ideal F, ideal Q, kStrategy strat) |
|
static void | enterOnePairManyShifts (int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR, int uptodeg, int lV) |
|
void | enterOnePairSelfShifts (poly qq, poly p, int ecart, int isFromQ, kStrategy strat, int, 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, int lV) |
|
void | initenterpairsShift (poly h, int k, int ecart, int isFromQ, kStrategy strat, int atR, int uptodeg, int lV) |
|
void | enterpairsShift (poly h, int k, int ecart, int pos, kStrategy strat, int atR, int uptodeg, int lV) |
|
void | enterTShift (LObject p, kStrategy strat, int atT, int uptodeg, int lV) |
|
poly | redtailBbaShift (LObject *L, int pos, kStrategy strat, BOOLEAN withT, BOOLEAN normalize) |
|
◆ ALL_VS_JUST
◆ ENTER_USE_MEMMOVE
#define ENTER_USE_MEMMOVE |
◆ EXT_POLY_NEW
◆ KDEBUG
◆ KUTIL_CC
◆ MYTEST
◆ pDivComp_EQUAL
◆ pDivComp_GREATER
#define pDivComp_GREATER -1 |
◆ pDivComp_INCOMP
#define pDivComp_INCOMP 0 |
◆ pDivComp_LESS
◆ REDTAIL_CANONICALIZE
#define REDTAIL_CANONICALIZE 100 |
◆ arriRewCriterion()
BOOLEAN arriRewCriterion |
( |
poly |
, |
|
|
unsigned long |
, |
|
|
poly |
, |
|
|
kStrategy |
strat, |
|
|
int |
start = 0 |
|
) |
| |
Definition at line 7087 of file kutil.cc.
7094 for (
int ii=strat->
sl; ii>start; ii--)
7100 if (!(
pLmCmp(p1,p2) == 1))
◆ arriRewCriterionPre()
BOOLEAN arriRewCriterionPre |
( |
poly |
sig, |
|
|
unsigned long |
not_sevSig, |
|
|
poly |
lm, |
|
|
kStrategy |
strat, |
|
|
int |
|
|
) |
| |
Definition at line 7112 of file kutil.cc.
7119 for (
int i=strat->
Bl;
i>-1;
i--) {
7139 for (
int ii=strat->
sl; ii>-1; ii--)
7145 if (!(
pLmCmp(p1,p2) == 1))
◆ cancelunit()
Definition at line 331 of file kutil.cc.
339 ring r = L->tailRing;
340 poly
p = L->GetLmTailRing();
419 number eins=
nInit(1);
◆ cancelunit1()
◆ chainCritNormal()
void chainCritNormal |
( |
poly |
p, |
|
|
int |
ecart, |
|
|
kStrategy |
strat |
|
) |
| |
Definition at line 3123 of file kutil.cc.
3136 for (
j=0;
j<=strat->
sl;
j++)
3140 for (
i=strat->
Bl;
i>=0;
i--)
3162 for (
j=strat->
Ll;
j>=0;
j--)
3168 if (strat->
L[
j].p == strat->
tail)
3214 for (
j=strat->
Ll;
j>=0;
j--)
3234 for(
i=
j-1;
i>=0;
i--)
3253 for (
j=strat->
Ll;
j>=0;
j--)
3284 if (strat->
L[0].p2 == strat->
tail) strat->
L[0].p2 =
p;
3287 if (strat->
L[
j].p2 ==
p)
3293 if ((strat->
L[
i].p2 ==
p) &&
pLmEqual(strat->
L[
j].lcm,strat->
L[
i].lcm))
3307 strat->
L[
i].p2 = strat->
tail;
3324 else if (strat->
L[
j].p2 == strat->
tail)
◆ chainCritOpt_1()
void chainCritOpt_1 |
( |
poly |
, |
|
|
int |
, |
|
|
kStrategy |
strat |
|
) |
| |
◆ chainCritPart()
void chainCritPart |
( |
poly |
p, |
|
|
int |
ecart, |
|
|
kStrategy |
strat |
|
) |
| |
Definition at line 3411 of file kutil.cc.
3424 for (
j=0;
j<=strat->
sl;
j++)
3428 for (
i=strat->
Bl;
i>=0;
i--)
3436 Print(
"chain-crit-part: S[%d]=",
j);
3438 Print(
" divide B[%d].lcm=",
i);
3460 for (
j=strat->
Ll;
j>=0;
j--)
3466 if (strat->
L[
j].p == strat->
tail)
3470 PrintS(
"chain-crit-part: pCompareChainPart p=");
3472 Print(
" delete L[%d]",
j);
3501 Print(
"chain-crit-part: sugar B[%d].lcm=",
j);
3503 Print(
" delete B[%d]",
i);
3514 Print(
"chain-crit-part: sugar B[%d].lcm=",
i);
3516 Print(
" delete B[%d]",
j);
3536 for (
j=strat->
Ll;
j>=0;
j--)
3544 PrintS(
"chain-crit-part: sugar:pCompareChainPart p=");
3546 Print(
" delete L[%d]",
j);
3564 for(
i=
j-1;
i>=0;
i--)
3570 Print(
"chain-crit-part: equal lcm B[%d].lcm=",
j);
3572 Print(
" delete B[%d]\n",
i);
3589 for (
j=strat->
Ll;
j>=0;
j--)
3597 PrintS(
"chain-crit-part: pCompareChainPart p=");
3599 Print(
" delete L[%d]",
j);
3628 if (strat->
L[0].p2 == strat->
tail) strat->
L[0].p2 =
p;
3631 if (strat->
L[
j].p2 ==
p)
3637 if ((strat->
L[
i].p2 ==
p) &&
pLmEqual(strat->
L[
j].lcm,strat->
L[
i].lcm))
3654 strat->
L[
i].p2 = strat->
tail;
3661 PrintS(
"chain-crit-part: divisible_by p=");
3663 Print(
" delete L[%d]",
l);
3674 PrintS(
"chain-crit-part: divisible_by(2) p=");
3676 Print(
" delete L[%d]",
i);
3687 else if (strat->
L[
j].p2 == strat->
tail)
◆ chainCritRing()
void chainCritRing |
( |
poly |
p, |
|
|
int |
, |
|
|
kStrategy |
strat |
|
) |
| |
Definition at line 3888 of file kutil.cc.
3901 for (
j=0;
j<=strat->
sl;
j++)
3905 for (
i=strat->
Bl;
i>=0;
i--)
3912 PrintS(
"--- chain criterion func chainCritRing type 1\n");
3915 PrintS(
" strat->B[i].lcm:");
3920 wrp(strat->
B[
i].lcm);
3935 for (
j=strat->
Ll;
j>=0;
j--)
3948 PrintS(
"--- chain criterion func chainCritRing type 2\n");
3949 PrintS(
"strat->L[j].p:");
3980 if (strat->
L[0].p2 == strat->
tail) strat->
L[0].p2 =
p;
3983 if (strat->
L[
j].p2 ==
p)
3998 PrintS(
"--- chain criterion func chainCritRing type 3\n");
3999 PrintS(
"strat->L[j].lcm:");
4000 wrp(strat->
L[
j].lcm);
4001 PrintS(
" strat->L[i].lcm:");
4002 wrp(strat->
L[
i].lcm);
4016 strat->
L[
i].p2 = strat->
tail;
4033 else if (strat->
L[
j].p2 == strat->
tail)
◆ chainCritSig()
void chainCritSig |
( |
poly |
p, |
|
|
int |
, |
|
|
kStrategy |
strat |
|
) |
| |
Definition at line 3352 of file kutil.cc.
3363 if (strat->
L[0].p2 == strat->
tail) strat->
L[0].p2 =
p;
3366 if (strat->
L[
j].p2 ==
p)
3372 if ((strat->
L[
i].p2 ==
p) &&
pLmEqual(strat->
L[
j].lcm,strat->
L[
i].lcm))
3386 strat->
L[
i].p2 = strat->
tail;
3403 else if (strat->
L[
j].p2 == strat->
tail)
◆ cleanT()
Definition at line 536 of file kutil.cc.
547 for (
j=0;
j<=strat->
tl;
j++)
551 if (strat->
T[
j].max_exp !=
NULL)
561 if (strat->
T[
j].t_p !=
NULL)
572 if (
p == strat->
S[
i])
574 if (strat->
T[
j].t_p !=
NULL)
576 if (p_shallow_copy_delete!=
NULL)
◆ cleanTSbaRing()
Definition at line 589 of file kutil.cc.
600 for (
j=0;
j<=strat->
tl;
j++)
604 if (strat->
T[
j].max_exp !=
NULL)
614 if (strat->
T[
j].t_p !=
NULL)
626 if (
p == strat->
S[
i])
628 if (strat->
T[
j].t_p !=
NULL)
◆ clearSbatch()
void clearSbatch |
( |
poly |
h, |
|
|
int |
k, |
|
|
int |
pos, |
|
|
kStrategy |
strat |
|
) |
| |
◆ completeReduce()
Definition at line 10392 of file kutil.cc.
10422 for (
i=strat->
sl;
i>=low;
i--)
10424 int end_pos=strat->
sl;
10426 if (strat->
ak==0) end_pos=
i-1;
10428 if ((T_j !=
NULL)&&(T_j->p==strat->
S[
i]))
10446 Print(
"to (tailR) S[%d]:",
i);
10458 T_j->max_exp =
NULL;
10461 T_j->pCleardenom();
10501 Print(
"to (-tailR) S[%d]:",
i);
◆ createG0()
Definition at line 4388 of file kutil.cc.
4411 PrintS(
"-------------\npoly :");
4414 Print(
"cexp : (%d, %d)\n", cexp[1], cexp[2]);
4415 Print(
"cind : (%d, %d)\n", cind[1], cind[2]);
4417 Print(
"cind : %d\n", cabsind);
4435 Print(
"%d, (%d, %d), ind = (%d, %d)\n", cabsind, cexp[1], cexp[2], cind[1], cind[2]);
4443 G0->m[
IDELEMS(G0) - 1] = zeroPoly;
◆ deleteHC() [1/2]
Definition at line 242 of file kutil.cc.
249 poly
p = L->GetLmTailRing();
252 if (L->bucket !=
NULL)
290 L->ecart = L->pLDeg() - L->GetpFDeg();
299 L->ecart = L->pLDeg(strat->
LDegLast) - L->GetpFDeg();
◆ deleteHC() [2/2]
void deleteHC |
( |
poly * |
p, |
|
|
int * |
e, |
|
|
int * |
l, |
|
|
kStrategy |
strat |
|
) |
| |
◆ deleteInL()
void deleteInL |
( |
LSet |
set, |
|
|
int * |
length, |
|
|
int |
j, |
|
|
kStrategy |
strat |
|
) |
| |
Definition at line 1151 of file kutil.cc.
1164 if (set[
j].sig!=
NULL)
1198 #ifdef ENTER_USE_MEMMOVE
1202 for (
i=
j;
i < (*length);
i++)
◆ deleteInS()
Definition at line 1044 of file kutil.cc.
1047 #ifdef ENTER_USE_MEMMOVE
1048 memmove(&(strat->
S[
i]), &(strat->
S[
i+1]), (strat->
sl -
i)*
sizeof(poly));
1050 memmove(&(strat->
sevS[
i]),&(strat->
sevS[
i+1]),(strat->
sl -
i)*
sizeof(
unsigned long));
1051 memmove(&(strat->
S_2_R[
i]),&(strat->
S_2_R[
i+1]),(strat->
sl -
i)*
sizeof(
int));
1054 for (
j=
i;
j<strat->
sl;
j++)
1056 strat->
S[
j] = strat->
S[
j+1];
1064 #ifdef ENTER_USE_MEMMOVE
1065 memmove(&(strat->
lenS[
i]),&(strat->
lenS[
i+1]),(strat->
sl -
i)*
sizeof(
int));
1072 #ifdef ENTER_USE_MEMMOVE
1080 #ifdef ENTER_USE_MEMMOVE
1081 memmove(&(strat->
fromQ[
i]),&(strat->
fromQ[
i+1]),(strat->
sl -
i)*
sizeof(
int));
1083 for (
j=
i;
j<strat->
sl;
j++)
◆ deleteInSSba()
Definition at line 1096 of file kutil.cc.
1099 #ifdef ENTER_USE_MEMMOVE
1100 memmove(&(strat->
S[
i]), &(strat->
S[
i+1]), (strat->
sl -
i)*
sizeof(poly));
1101 memmove(&(strat->
sig[
i]), &(strat->
sig[
i+1]), (strat->
sl -
i)*
sizeof(poly));
1103 memmove(&(strat->
sevS[
i]),&(strat->
sevS[
i+1]),(strat->
sl -
i)*
sizeof(
unsigned long));
1104 memmove(&(strat->
sevSig[
i]),&(strat->
sevSig[
i+1]),(strat->
sl -
i)*
sizeof(
unsigned long));
1105 memmove(&(strat->
S_2_R[
i]),&(strat->
S_2_R[
i+1]),(strat->
sl -
i)*
sizeof(
int));
1108 for (
j=
i;
j<strat->
sl;
j++)
1110 strat->
S[
j] = strat->
S[
j+1];
1120 #ifdef ENTER_USE_MEMMOVE
1121 memmove(&(strat->
lenS[
i]),&(strat->
lenS[
i+1]),(strat->
sl -
i)*
sizeof(
int));
1128 #ifdef ENTER_USE_MEMMOVE
1136 #ifdef ENTER_USE_MEMMOVE
1137 memmove(&(strat->
fromQ[
i]),&(strat->
fromQ[
i+1]),(strat->
sl -
i)*
sizeof(
int));
1139 for (
j=
i;
j<strat->
sl;
j++)
◆ enlargeL()
static void enlargeL |
( |
LSet * |
L, |
|
|
int * |
length, |
|
|
const int |
incr |
|
) |
| |
|
inlinestatic |
◆ enlargeT()
static void enlargeT |
( |
TSet & |
T, |
|
|
TObject **& |
R, |
|
|
unsigned long *& |
sevT, |
|
|
int & |
length, |
|
|
const int |
incr |
|
) |
| |
|
inlinestatic |
◆ enterExtendedSpoly()
void enterExtendedSpoly |
( |
poly |
h, |
|
|
kStrategy |
strat |
|
) |
| |
Definition at line 4503 of file kutil.cc.
4538 PrintS(
"--- create zero spoly: ");
4567 posx = strat->
posInL(strat->
L,strat->
Ll,&Lp,strat);
◆ enterExtendedSpolySig()
void enterExtendedSpolySig |
( |
poly |
h, |
|
|
poly |
hSig, |
|
|
kStrategy |
strat |
|
) |
| |
Definition at line 4586 of file kutil.cc.
4620 PrintS(
"--- create zero spoly: ");
4648 int red_result =
redRing(&Lp,strat);
4658 strat->
enterS(strat->
P,strat->
sl+1,strat, strat->
tl+1);
4660 strat->
enterS(Lp,0,strat,strat->
tl);
◆ enterL()
void enterL |
( |
LSet * |
set, |
|
|
int * |
length, |
|
|
int * |
LSetmax, |
|
|
LObject |
p, |
|
|
int |
at |
|
) |
| |
Definition at line 1214 of file kutil.cc.
1225 memmove(&((*set)[at+1]), &((*set)[at]), ((*
length)-at+1)*
sizeof(
LObject));
1227 for (
i=(*
length)+1;
i>=at+1;
i--) (*set)[
i] = (*set)[
i-1];
◆ enterOnePairLift()
static void enterOnePairLift |
( |
int |
i, |
|
|
poly |
p, |
|
|
int |
ecart, |
|
|
int |
isFromQ, |
|
|
kStrategy |
strat, |
|
|
int |
atR = -1 |
|
) |
| |
|
static |
Definition at line 2141 of file kutil.cc.
2157 Lp.ecart=0; Lp.length=0;
2164 if((!((strat->
ecartS[
i]>0)&&(ecart>0)))
2260 for(
j = strat->
Bl;
j>=0;
j--)
2316 Lp.p1 = strat->
S[
i];
2323 Lp.i_r1 = strat->
S_2_R[
i];
2337 && (Lp.p->coef!=
NULL))
2341 l = strat->
posInL(strat->
B,strat->
Bl,&Lp,strat);
◆ enterOnePairManyShifts()
static void enterOnePairManyShifts |
( |
int |
i, |
|
|
poly |
p, |
|
|
int |
ecart, |
|
|
int |
isFromQ, |
|
|
kStrategy |
strat, |
|
|
int |
atR, |
|
|
int |
uptodeg, |
|
|
int |
lV |
|
) |
| |
|
static |
Definition at line 11941 of file kutil.cc.
11960 poly qq = strat->
S[
i];
11986 qfromQ = strat->
fromQ[
i];
11998 enterOnePairShift(qq,
p, ecart, isFromQ, strat, -1, ecartq, qfromQ, 0,
i, uptodeg, lV);
12000 for (
j=1;
j<= toInsert;
j++)
◆ enterOnePairNormal()
void enterOnePairNormal |
( |
int |
i, |
|
|
poly |
p, |
|
|
int |
ecart, |
|
|
int |
isFromQ, |
|
|
kStrategy |
strat, |
|
|
int |
atR = -1 |
|
) |
| |
Definition at line 1860 of file kutil.cc.
1870 Lp.ecart=0; Lp.length=0;
1875 #ifndef HAVE_RATGRING
1877 #elif defined(HAVE_RATGRING)
1888 if((!((strat->
ecartS[
i]>0)&&(ecart>0)))
1988 for(
j = strat->
Bl;
j>=0;
j--)
2087 Lp.p1 = strat->
S[
i];
2101 Lp.i_r1 = strat->
S_2_R[
i];
2115 && (Lp.p->coef!=
NULL))
2119 l = strat->
posInL(strat->
B,strat->
Bl,&Lp,strat);
◆ enterOnePairRing()
static void enterOnePairRing |
( |
int |
i, |
|
|
poly |
p, |
|
|
int |
, |
|
|
int |
isFromQ, |
|
|
kStrategy |
strat, |
|
|
int |
atR |
|
) |
| |
|
static |
Definition at line 1280 of file kutil.cc.
1305 int j,compare,compareCoeff;
1309 h.ecart=0;
h.length=0;
1328 for(
j = strat->
Bl;
j>=0;
j--)
1451 h.i_r1 = -1;
h.i_r2 = -1;
1467 posx = strat->
posInL(strat->
B,strat->
Bl,&
h,strat);
◆ enterOnePairSelfShifts()
void enterOnePairSelfShifts |
( |
poly |
qq, |
|
|
poly |
p, |
|
|
int |
ecart, |
|
|
int |
isFromQ, |
|
|
kStrategy |
strat, |
|
|
int |
, |
|
|
int |
uptodeg, |
|
|
int |
lV |
|
) |
| |
◆ enterOnePairShift()
void enterOnePairShift |
( |
poly |
q, |
|
|
poly |
p, |
|
|
int |
ecart, |
|
|
int |
isFromQ, |
|
|
kStrategy |
strat, |
|
|
int |
atR, |
|
|
int |
ecartq, |
|
|
int |
qisFromQ, |
|
|
int |
shiftcount, |
|
|
int |
ifromS, |
|
|
int |
, |
|
|
int |
lV |
|
) |
| |
Definition at line 12080 of file kutil.cc.
12113 int qfromQ = qisFromQ;
12122 Lp.ecart=0; Lp.length=0;
12128 if (!
isInV(Lp.lcm, lV))
12133 PrintS(
"V crit applied to q = ");
12148 if((!((ecartq>0)&&(ecart>0)))
12170 Lp.ecart =
si_max(ecart,ecartq);
12171 if (strat->
fromT && (ecartq>ecart))
12193 if ((strat->
fromQ==
NULL) || (isFromQ==0) || (qfromQ==0))
12236 if (strat->
fromT && (ecartq>ecart))
12248 for(
j = strat->
Bl;
j>=0;
j--)
12254 if ((strat->
fromQ==
NULL) || (isFromQ==0) || (qfromQ==0))
12278 if ((strat->
fromQ!=
NULL) && (isFromQ!=0) && (qfromQ!=0))
12345 if ( (atR >= 0) && (shiftcount==0) && (ifromS >=0) )
◆ enterOnePairSig()
static void enterOnePairSig |
( |
int |
i, |
|
|
poly |
p, |
|
|
poly |
pSig, |
|
|
int |
, |
|
|
int |
ecart, |
|
|
int |
isFromQ, |
|
|
kStrategy |
strat, |
|
|
int |
atR = -1 |
|
) |
| |
|
static |
Definition at line 2353 of file kutil.cc.
2365 unsigned long pSigMultNegSev,sSigMultNegSev;
2369 Lp.ecart=0; Lp.length=0;
2374 #ifndef HAVE_RATGRING
2376 #elif defined(HAVE_RATGRING)
2406 PrintS(
"----------------\n");
2409 PrintS(
"----------------\n");
2415 Print(
"IN PAIR GENERATION - COMPARING SIGS: %d\n",sigCmp);
2436 if ( strat->
syzCrit(pSigMult,pSigMultNegSev,strat) ||
2437 strat->
syzCrit(sSigMult,sSigMultNegSev,strat)
2438 || strat->
rewCrit1(sSigMult,sSigMultNegSev,Lp.lcm,strat,
i+1)
2515 Lp.sevSig = ~pSigMultNegSev;
2522 Lp.sevSig = ~sSigMultNegSev;
2533 if (strat->
rewCrit3(Lp.sig,~Lp.sevSig,Lp.p,strat,strat->
sl+1))
2547 Lp.checked = strat->
sl+1;
2554 Lp.prod_crit =
TRUE;
2566 PrintS(
"SIGNATURE OF PAIR: ");
2570 Lp.p1 = strat->
S[
i];
2584 Lp.i_r1 = strat->
S_2_R[
i];
2598 && (Lp.p->coef!=
NULL))
◆ enterOnePairSigRing()
static void enterOnePairSigRing |
( |
int |
i, |
|
|
poly |
p, |
|
|
poly |
pSig, |
|
|
int |
, |
|
|
int |
ecart, |
|
|
int |
isFromQ, |
|
|
kStrategy |
strat, |
|
|
int |
atR = -1 |
|
) |
| |
|
static |
Definition at line 2610 of file kutil.cc.
2640 unsigned long pSigMultNegSev,sSigMultNegSev;
2644 Lp.ecart=0; Lp.length=0;
2649 #ifndef HAVE_RATGRING
2651 #elif defined(HAVE_RATGRING)
2687 if(pSigMult !=
NULL)
2690 if(sSigMult !=
NULL)
2694 Print(
"----------------\n");
2697 Print(
"----------------\n");
2701 if(pSigMult !=
NULL && sSigMult !=
NULL)
2710 if(pSigMult ==
NULL)
2712 if(sSigMult ==
NULL)
2722 Print(
"IN PAIR GENERATION - COMPARING SIGS: %d\n",sigCmp);
2744 int red_result =
redRing(&Lp,strat);
2754 strat->
enterS(strat->
P,strat->
sl+1,strat, strat->
tl+1);
2756 strat->
enterS(Lp,0,strat,strat->
tl);
2770 Lp.sig =
pCopy(pSigMult);
2799 if ( strat->
syzCrit(pSigMult,pSigMultNegSev,strat) ||
2800 strat->
syzCrit(sSigMult,sSigMultNegSev,strat)
2882 Lp.sig =
pNeg(Lp.sig);
2893 Lp.sevSig = ~pSigMultNegSev;
2900 Lp.sevSig = ~sSigMultNegSev;
2912 if (strat->
rewCrit3(Lp.sig,~Lp.sevSig,Lp.p,strat,strat->
sl+1))
2926 Lp.checked = strat->
sl+1;
2933 Lp.prod_crit =
TRUE;
2945 PrintS(
"SIGNATURE OF PAIR: ");
2949 Lp.p1 = strat->
S[
i];
2964 Lp.i_r1 = strat->
S_2_R[
i];
2978 && (Lp.p->coef!=
NULL))
2986 int red_result =
redRing(&Lp,strat);
2996 strat->
enterS(strat->
P,strat->
sl+1,strat, strat->
tl+1);
2999 strat->
enterS(Lp,0,strat, strat->
tl+1);
◆ enterOnePairSpecial()
void enterOnePairSpecial |
( |
int |
i, |
|
|
poly |
p, |
|
|
int |
ecart, |
|
|
kStrategy |
strat, |
|
|
int |
atR = -1 |
|
) |
| |
Definition at line 3012 of file kutil.cc.
3051 Lp.p1 = strat->
S[
i];
3055 Lp.i_r1 = strat->
S_2_R[
i];
3070 && (Lp.p->coef!=
NULL))
3073 l = strat->
posInL(strat->
L,strat->
Ll,&Lp,strat);
◆ enterOneStrongPoly()
static BOOLEAN enterOneStrongPoly |
( |
int |
i, |
|
|
poly |
p, |
|
|
int |
, |
|
|
int |
, |
|
|
kStrategy |
strat, |
|
|
int |
atR, |
|
|
bool |
enterTstrong |
|
) |
| |
|
static |
Definition at line 1479 of file kutil.cc.
1484 poly m1, m2,
gcd,si;
1540 PrintS(
"\n--- create strong gcd poly: ");
1543 Print(
"\n strat->S[%d]: ",
i);
1567 h.i_r1 = -1;
h.i_r2 = -1;
1573 h.p1 =
p;
h.p2 = strat->
S[
i];
1588 posx = strat->
posInL(strat->
L,strat->
Ll,&
h,strat);
1593 if(
h.IsNull())
return FALSE;
◆ enterOneStrongPolySig()
static BOOLEAN enterOneStrongPolySig |
( |
int |
i, |
|
|
poly |
p, |
|
|
poly |
sig, |
|
|
int |
, |
|
|
int |
, |
|
|
kStrategy |
strat, |
|
|
int |
atR |
|
) |
| |
|
static |
Definition at line 1665 of file kutil.cc.
1670 poly m1, m2,
gcd,si;
1718 PrintS(
"\n--- create strong gcd poly: ");
1721 Print(
"\n strat->S[%d]: ",
i);
1745 if(
pLmCmp(pSigMult,sSigMult) == 0)
1754 if(
pLtCmp(pSigMult,sSigMult)==1)
1774 h.i_r1 = -1;
h.i_r2 = -1;
1782 int red_result =
redRing(&
h,strat);
1792 strat->
enterS(strat->
P,strat->
sl+1,strat, strat->
tl+1);
1809 int red_result =
redRing(&
h,strat);
1819 strat->
enterS(strat->
P,strat->
sl+1,strat, strat->
tl+1);
1832 strat->
enterS(strat->
P,strat->
sl+1,strat, strat->
tl+1);
1836 h.p1 =
p;
h.p2 = strat->
S[
i];
◆ enterOneZeroPairRing()
void enterOneZeroPairRing |
( |
poly |
f, |
|
|
poly |
t_p, |
|
|
poly |
p, |
|
|
int |
ecart, |
|
|
kStrategy |
strat, |
|
|
int |
atR = -1 |
|
) |
| |
Definition at line 4078 of file kutil.cc.
4081 int l,
j,compare,compareCoeff;
4085 Lp.ecart=0; Lp.length=0;
4098 for(
j = strat->
Bl;
j>=0;
j--)
4102 if (compareCoeff == 0 || compare == compareCoeff)
4120 if (compareCoeff == 1)
4127 if (compareCoeff == -1)
4170 tmp_h.SetShortExpVector();
4175 enterT(tmp_h, strat, strat->
tl + 1);
4180 Lp.i_r1 = strat->
tl;
4184 l = strat->
posInL(strat->
B,strat->
Bl,&Lp,strat);
◆ enterpairs()
void enterpairs |
( |
poly |
h, |
|
|
int |
k, |
|
|
int |
ecart, |
|
|
int |
pos, |
|
|
kStrategy |
strat, |
|
|
int |
atR |
|
) |
| |
◆ 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 |
hFrom, |
|
|
int |
k, |
|
|
int |
ecart, |
|
|
int |
pos, |
|
|
kStrategy |
strat, |
|
|
int |
atR |
|
) |
| |
◆ enterpairsSpecial()
void enterpairsSpecial |
( |
poly |
h, |
|
|
int |
k, |
|
|
int |
ecart, |
|
|
int |
pos, |
|
|
kStrategy |
strat, |
|
|
int |
atR = -1 |
|
) |
| |
Definition at line 4807 of file kutil.cc.
4815 for (
j=0;
j<=
k;
j++)
4818 if ((iCompH==iCompSj)
4829 for (
j=0;
j<=
k;
j++)
4832 if ((iCompH==iCompSj)
◆ enterSBba()
Definition at line 9028 of file kutil.cc.
9043 *
sizeof(
unsigned long));
9070 strat->
Shdl->m=strat->
S;
9072 if (atS <= strat->sl)
9074 #ifdef ENTER_USE_MEMMOVE
9075 memmove(&(strat->
S[atS+1]), &(strat->
S[atS]),
9076 (strat->
sl - atS + 1)*
sizeof(poly));
9077 memmove(&(strat->
ecartS[atS+1]), &(strat->
ecartS[atS]),
9078 (strat->
sl - atS + 1)*
sizeof(
int));
9079 memmove(&(strat->
sevS[atS+1]), &(strat->
sevS[atS]),
9080 (strat->
sl - atS + 1)*
sizeof(
unsigned long));
9081 memmove(&(strat->
S_2_R[atS+1]), &(strat->
S_2_R[atS]),
9082 (strat->
sl - atS + 1)*
sizeof(
int));
9084 memmove(&(strat->
lenS[atS+1]), &(strat->
lenS[atS]),
9085 (strat->
sl - atS + 1)*
sizeof(
int));
9087 memmove(&(strat->
lenSw[atS+1]), &(strat->
lenSw[atS]),
9090 for (
i=strat->
sl+1;
i>=atS+1;
i--)
9092 strat->
S[
i] = strat->
S[
i-1];
9098 for (
i=strat->
sl+1;
i>=atS+1;
i--)
9101 for (
i=strat->
sl+1;
i>=atS+1;
i--)
9107 #ifdef ENTER_USE_MEMMOVE
9108 memmove(&(strat->
fromQ[atS+1]), &(strat->
fromQ[atS]),
9109 (strat->
sl - atS + 1)*
sizeof(
int));
9111 for (
i=strat->
sl+1;
i>=atS+1;
i--)
9116 strat->
fromQ[atS]=0;
◆ enterSMora()
◆ enterSMoraNF()
◆ enterSSba()
Definition at line 9131 of file kutil.cc.
9146 *
sizeof(
unsigned long));
9150 *
sizeof(
unsigned long));
9178 strat->
Shdl->m=strat->
S;
9185 if (atS <= strat->sl)
9187 #ifdef ENTER_USE_MEMMOVE
9188 memmove(&(strat->
S[atS+1]), &(strat->
S[atS]),
9189 (strat->
sl - atS + 1)*
sizeof(poly));
9190 memmove(&(strat->
sig[atS+1]), &(strat->
sig[atS]),
9191 (strat->
sl - atS + 1)*
sizeof(poly));
9192 memmove(&(strat->
sevSig[atS+1]), &(strat->
sevSig[atS]),
9193 (strat->
sl - atS + 1)*
sizeof(
unsigned long));
9194 memmove(&(strat->
ecartS[atS+1]), &(strat->
ecartS[atS]),
9195 (strat->
sl - atS + 1)*
sizeof(
int));
9196 memmove(&(strat->
sevS[atS+1]), &(strat->
sevS[atS]),
9197 (strat->
sl - atS + 1)*
sizeof(
unsigned long));
9198 memmove(&(strat->
S_2_R[atS+1]), &(strat->
S_2_R[atS]),
9199 (strat->
sl - atS + 1)*
sizeof(
int));
9201 memmove(&(strat->
lenS[atS+1]), &(strat->
lenS[atS]),
9202 (strat->
sl - atS + 1)*
sizeof(
int));
9204 memmove(&(strat->
lenSw[atS+1]), &(strat->
lenSw[atS]),
9207 for (
i=strat->
sl+1;
i>=atS+1;
i--)
9209 strat->
S[
i] = strat->
S[
i-1];
9217 for (
i=strat->
sl+1;
i>=atS+1;
i--)
9220 for (
i=strat->
sl+1;
i>=atS+1;
i--)
9226 #ifdef ENTER_USE_MEMMOVE
9227 memmove(&(strat->
fromQ[atS+1]), &(strat->
fromQ[atS]),
9228 (strat->
sl - atS + 1)*
sizeof(
int));
9230 for (
i=strat->
sl+1;
i>=atS+1;
i--)
9235 strat->
fromQ[atS]=0;
9239 strat->
S[atS] =
p.p;
9240 strat->
sig[atS] =
p.sig;
9246 strat->
sevS[atS] =
p.sev;
9256 strat->
sevSig[atS] =
p.sevSig;
9259 strat->
S_2_R[atS] = atR;
9263 Print(
"--- LIST S: %d ---\n",strat->
sl);
9264 for(
k=0;
k<=strat->
sl;
k++)
◆ enterSyz()
Definition at line 9452 of file kutil.cc.
9466 (strat->
syzmax)*
sizeof(
unsigned long),
9468 *
sizeof(
unsigned long));
9471 if (atT < strat->syzl)
9473 #ifdef ENTER_USE_MEMMOVE
9474 memmove(&(strat->
syz[atT+1]), &(strat->
syz[atT]),
9475 (strat->
syzl-atT+1)*
sizeof(poly));
9476 memmove(&(strat->
sevSyz[atT+1]), &(strat->
sevSyz[atT]),
9477 (strat->
syzl-atT+1)*
sizeof(
unsigned long));
9479 for (
i=strat->
syzl;
i>=atT+1;
i--)
9481 #ifndef ENTER_USE_MEMMOVE
9494 strat->
syz[atT] =
p.sig;
9495 strat->
sevSyz[atT] =
p.sevSig;
9498 Print(
"element in strat->syz: %d--%d ",atT+1,strat->
syzmax);
9508 strat->
L[cc].sig, ~strat->
L[cc].sevSig,
currRing)
9522 PrintS(
"--- Syzygies ---\n");
9525 PrintS(
"--------------------------------\n");
◆ enterT()
Definition at line 9269 of file kutil.cc.
9289 for(
i=strat->
tl;
i>=0;
i--)
9291 if (
p.p==strat->
T[
i].p)
9293 printf(
"already in T at pos %d of %d, atT=%d\n",
i,strat->
tl,atT);
9299 #ifdef HAVE_TAIL_RING
9302 p.t_p=
p.GetLmTailRing();
9308 if (strat->
tl == strat->
tmax-1)
9310 if (atT <= strat->tl)
9312 #ifdef ENTER_USE_MEMMOVE
9313 memmove(&(strat->
T[atT+1]), &(strat->
T[atT]),
9315 memmove(&(strat->
sevT[atT+1]), &(strat->
sevT[atT]),
9316 (strat->
tl-atT+1)*
sizeof(
unsigned long));
9318 for (
i=strat->
tl+1;
i>=atT+1;
i--)
9320 #ifndef ENTER_USE_MEMMOVE
9321 strat->
T[
i] = strat->
T[
i-1];
9324 strat->
R[strat->
T[
i].i_r] = &(strat->
T[
i]);
9342 strat->
T[atT].max_exp =
NULL;
◆ enterT_strong()
Definition at line 9350 of file kutil.cc.
9371 for(
i=strat->
tl;
i>=0;
i--)
9373 if (
p.p==strat->
T[
i].p)
9375 printf(
"already in T at pos %d of %d, atT=%d\n",
i,strat->
tl,atT);
9381 #ifdef HAVE_TAIL_RING
9384 p.t_p=
p.GetLmTailRing();
9390 if (strat->
tl == strat->
tmax-1)
9392 if (atT <= strat->tl)
9394 #ifdef ENTER_USE_MEMMOVE
9395 memmove(&(strat->
T[atT+1]), &(strat->
T[atT]),
9397 memmove(&(strat->
sevT[atT+1]), &(strat->
sevT[atT]),
9398 (strat->
tl-atT+1)*
sizeof(
unsigned long));
9400 for (
i=strat->
tl+1;
i>=atT+1;
i--)
9402 #ifndef ENTER_USE_MEMMOVE
9403 strat->
T[
i] = strat->
T[
i-1];
9406 strat->
R[strat->
T[
i].i_r] = &(strat->
T[
i]);
9424 strat->
T[atT].max_exp =
NULL;
9427 strat->
R[strat->
tl] = &(strat->
T[atT]);
9428 strat->
T[atT].i_r = strat->
tl;
9435 for(
i=strat->
tl;
i>=0;
i--)
◆ enterTShift()
◆ exitBuchMora()
◆ exitSba()
◆ faugereRewCriterion()
BOOLEAN faugereRewCriterion |
( |
poly |
sig, |
|
|
unsigned long |
not_sevSig, |
|
|
poly |
, |
|
|
kStrategy |
strat, |
|
|
int |
start = 0 |
|
) |
| |
Definition at line 7028 of file kutil.cc.
7036 PrintS(
"rewritten criterion checks: ");
7039 for(
int k = strat->
sl;
k>=start;
k--)
7043 PrintS(
"checking with: ");
7059 PrintS(
"ALL ELEMENTS OF S\n----------------------------------------\n");
7060 for(
int kk = 0; kk<strat->
sl+1; kk++)
7064 PrintS(
"------------------------------\n");
◆ finalReduceByMon()
used for GB over ZZ: final reduction by constant elements background: any known constant element of ideal suppresses intermediate coefficient swell and beautifies output
Definition at line 10962 of file kutil.cc.
10976 for(
int j = 0;
j<=strat->
sl;
j++)
10980 for(
int i = 0;
i<=strat->
sl;
i++)
10982 if((
i !=
j) && (strat->
S[
i] !=
NULL))
◆ getIndexRng()
int getIndexRng |
( |
long |
coeff | ) |
|
|
inline |
Definition at line 6423 of file kutil.cc.
6426 if (coeff == 0)
return -1;
6429 while (tmp % 2 == 0)
◆ HEckeTest()
◆ ind2()
◆ ind_fact_2()
long ind_fact_2 |
( |
long |
arg | ) |
|
◆ initBuchMora()
void initBuchMora |
( |
ideal |
F, |
|
|
ideal |
Q, |
|
|
kStrategy |
strat |
|
) |
| |
◆ initBuchMoraCrit()
Definition at line 9548 of file kutil.cc.
9567 #ifdef HAVE_RATGRING
◆ initBuchMoraPos()
◆ initBuchMoraPosRing()
◆ initBuchMoraShift()
void initBuchMoraShift |
( |
ideal |
F, |
|
|
ideal |
Q, |
|
|
kStrategy |
strat |
|
) |
| |
◆ initec()
◆ initEcartBBA()
◆ initEcartNormal()
void initEcartNormal |
( |
TObject * |
h | ) |
|
Definition at line 1238 of file kutil.cc.
1241 h->FDeg =
h->pFDeg();
1242 h->ecart =
h->pLDeg() -
h->FDeg;
◆ initEcartPairBba()
void initEcartPairBba |
( |
LObject * |
Lp, |
|
|
poly |
, |
|
|
poly |
, |
|
|
int |
, |
|
|
int |
|
|
) |
| |
Definition at line 1253 of file kutil.cc.
1256 Lp->FDeg = Lp->pFDeg();
◆ initEcartPairMora()
void initEcartPairMora |
( |
LObject * |
Lp, |
|
|
poly |
, |
|
|
poly |
, |
|
|
int |
ecartF, |
|
|
int |
ecartG |
|
) |
| |
Definition at line 1260 of file kutil.cc.
1263 Lp->FDeg = Lp->pFDeg();
1264 (*Lp).ecart =
si_max(ecartF,ecartG);
1265 (*Lp).ecart = (*Lp).ecart- (Lp->FDeg -
p_FDeg((*Lp).lcm,
currRing));
◆ initenterpairs()
void initenterpairs |
( |
poly |
h, |
|
|
int |
k, |
|
|
int |
ecart, |
|
|
int |
isFromQ, |
|
|
kStrategy |
strat, |
|
|
int |
atR = -1 |
|
) |
| |
Definition at line 3700 of file kutil.cc.
3715 for (
j=0;
j<=
k;
j++)
3728 for (
j=0;
j<=
k;
j++)
3737 for (
j=0;
j<=
k;
j++)
3750 #ifdef HAVE_RATGRING
◆ initenterpairsShift()
void initenterpairsShift |
( |
poly |
h, |
|
|
int |
k, |
|
|
int |
ecart, |
|
|
int |
isFromQ, |
|
|
kStrategy |
strat, |
|
|
int |
atR, |
|
|
int |
uptodeg, |
|
|
int |
lV |
|
) |
| |
◆ initenterpairsSig()
void initenterpairsSig |
( |
poly |
h, |
|
|
poly |
hSig, |
|
|
int |
hFrom, |
|
|
int |
k, |
|
|
int |
ecart, |
|
|
int |
isFromQ, |
|
|
kStrategy |
strat, |
|
|
int |
atR = -1 |
|
) |
| |
Definition at line 3765 of file kutil.cc.
3780 for (
j=0;
j<=
k;
j++)
3793 for (
j=0;
j<=
k;
j++)
3802 for (
j=0;
j<=
k;
j++)
3816 #ifdef HAVE_RATGRING
◆ initenterpairsSigRing()
void initenterpairsSigRing |
( |
poly |
h, |
|
|
poly |
hSig, |
|
|
int |
hFrom, |
|
|
int |
k, |
|
|
int |
ecart, |
|
|
int |
isFromQ, |
|
|
kStrategy |
strat, |
|
|
int |
atR = -1 |
|
) |
| |
Definition at line 3825 of file kutil.cc.
3873 #ifdef HAVE_RATGRING
◆ initenterstrongPairs()
void initenterstrongPairs |
( |
poly |
h, |
|
|
int |
k, |
|
|
int |
ecart, |
|
|
int |
isFromQ, |
|
|
kStrategy |
strat, |
|
|
int |
atR = -1 |
|
) |
| |
Definition at line 4454 of file kutil.cc.
4462 for (
j=0;
j<=
k;
j++)
4469 && ((iCompH<=strat->syzComp)||(strat->
syzComp==0)))
◆ initenterstrongPairsSig()
static void initenterstrongPairsSig |
( |
poly |
h, |
|
|
poly |
hSig, |
|
|
int |
k, |
|
|
int |
ecart, |
|
|
int |
isFromQ, |
|
|
kStrategy |
strat, |
|
|
int |
atR = -1 |
|
) |
| |
|
static |
Definition at line 4476 of file kutil.cc.
4491 && ((iCompH<=strat->syzComp)||(strat->
syzComp==0)))
◆ initenterzeropairsRing()
void initenterzeropairsRing |
( |
poly |
p, |
|
|
int |
ecart, |
|
|
kStrategy |
strat, |
|
|
int |
atR |
|
) |
| |
Definition at line 4322 of file kutil.cc.
4337 if (
exp[
i] & 1 != 0)
4352 PrintS(
"-------------\npoly :");
4355 Print(
"cexp : (%d, %d)\n", cexp[1], cexp[2]);
4356 Print(
"cind : (%d, %d)\n", cind[1], cind[2]);
4358 Print(
"cind : %d\n", cabsind);
4375 Print(
"%d, (%d, %d), ind = (%d, %d)\n", cabsind, cexp[1], cexp[2], cind[1], cind[2]);
◆ initHilbCrit()
◆ initPairtest()
◆ initS()
void initS |
( |
ideal |
F, |
|
|
ideal |
Q, |
|
|
kStrategy |
strat |
|
) |
| |
Definition at line 7846 of file kutil.cc.
7859 strat->
S=strat->
Shdl->m;
7864 memset(strat->
fromQ,0,
i*
sizeof(
int));
7893 strat->
enterS(
h,pos,strat,-1);
7894 strat->
fromQ[pos]=1;
7927 strat->
enterS(
h,pos,strat,-1);
◆ initS_2_R()
static int* initS_2_R |
( |
const int |
maxnr | ) |
|
|
inlinestatic |
◆ initSbaBuchMora()
void initSbaBuchMora |
( |
ideal |
F, |
|
|
ideal |
Q, |
|
|
kStrategy |
strat |
|
) |
| |
◆ initSbaCrit()
Definition at line 9612 of file kutil.cc.
9644 #ifdef HAVE_RATGRING
◆ initSbaPos()
◆ initsevS()
static unsigned long* initsevS |
( |
const int |
maxnr | ) |
|
|
inlinestatic |
Definition at line 506 of file kutil.cc.
509 return (
unsigned long*)
omAlloc0(maxnr*
sizeof(
unsigned long));
◆ initSL()
void initSL |
( |
ideal |
F, |
|
|
ideal |
Q, |
|
|
kStrategy |
strat |
|
) |
| |
Definition at line 7940 of file kutil.cc.
7953 strat->
S=strat->
Shdl->m;
7958 memset(strat->
fromQ,0,
i*
sizeof(
int));
7987 strat->
enterS(
h,pos,strat,-1);
7988 strat->
fromQ[pos]=1;
8020 pos = strat->
posInL(strat->
L,strat->
Ll,&
h,strat);
◆ initSLSba()
void initSLSba |
( |
ideal |
F, |
|
|
ideal |
Q, |
|
|
kStrategy |
strat |
|
) |
| |
Definition at line 8037 of file kutil.cc.
8050 strat->
S = strat->
Shdl->m;
8063 memset(strat->
fromQ,0,
i*
sizeof(
int));
8092 strat->
enterS(
h,pos,strat,-1);
8093 strat->
fromQ[pos]=1;
◆ initSSpecial()
void initSSpecial |
( |
ideal |
F, |
|
|
ideal |
Q, |
|
|
ideal |
P, |
|
|
kStrategy |
strat |
|
) |
| |
Definition at line 8338 of file kutil.cc.
8356 strat->
S=strat->
Shdl->m;
8362 memset(strat->
fromQ,0,
i*
sizeof(
int));
8391 strat->
enterS(
h,pos,strat, strat->
tl+1);
8393 strat->
fromQ[pos]=1;
8421 strat->
enterS(
h,pos,strat, strat->
tl+1);
8463 h.is_normalized = 0;
8470 strat->
enterS(
h,pos,strat, strat->
tl+1);
◆ initSSpecialSba()
void initSSpecialSba |
( |
ideal |
F, |
|
|
ideal |
Q, |
|
|
ideal |
P, |
|
|
kStrategy |
strat |
|
) |
| |
Definition at line 8482 of file kutil.cc.
8500 strat->
S=strat->
Shdl->m;
8506 memset(strat->
fromQ,0,
i*
sizeof(
int));
8535 strat->
enterS(
h,pos,strat, strat->
tl+1);
8537 strat->
fromQ[pos]=1;
8565 strat->
enterS(
h,pos,strat, strat->
tl+1);
8607 h.is_normalized = 0;
8614 strat->
enterS(
h,pos,strat, strat->
tl+1);
◆ initSyzRules()
Definition at line 8187 of file kutil.cc.
8203 for(
i=1;
i<=strat->
sl;
i++)
8215 strat->
syz = (poly *)
omAlloc(ps*
sizeof(poly));
8219 #if defined(DEBUGF5) || defined(DEBUGF51)
8220 PrintS(
"------------- GENERATING SYZ RULES NEW ---------------\n");
8227 while (i <= strat->sl)
8257 for (
k = 0;
k<
i;
k++)
8301 for (
k = 0;
k<strat->
sl+1;
k++)
8322 PrintS(
"Principal syzygies:\n");
8325 Print(
"ps %d\n",ps);
8326 PrintS(
"--------------------------------\n");
◆ isInPairsetB()
◆ isInPairsetL()
Definition at line 667 of file kutil.cc.
675 if ((*
k) < 0)
return FALSE;
676 if (((p1 == (*p).p1) && (p2 == (*p).p2))
677 || ((p1 == (*p).p2) && (p2 == (*p).p1)))
◆ kCheckSpolyCreation()
Definition at line 10577 of file kutil.cc.
10590 assume(L->i_r1 >= -1 && L->i_r1 <= strat->
tl);
10591 assume(L->i_r2 >= -1 && L->i_r2 <= strat->
tl);
10597 if ((L->i_r1 == -1) || (L->i_r2 == -1) )
10601 poly p1_max = (strat->
R[L->i_r1])->max_exp;
10602 poly p2_max = (strat->
R[L->i_r2])->max_exp;
◆ kCheckStrongCreation()
BOOLEAN kCheckStrongCreation |
( |
int |
atR, |
|
|
poly |
m1, |
|
|
int |
atS, |
|
|
poly |
m2, |
|
|
kStrategy |
strat |
|
) |
| |
Definition at line 10614 of file kutil.cc.
10628 poly p1_max = (strat->
R[atR])->max_exp;
◆ kCreateZeroPoly()
poly kCreateZeroPoly |
( |
long |
exp[], |
|
|
long |
cabsind, |
|
|
poly * |
t_p, |
|
|
ring |
leadRing, |
|
|
ring |
tailRing |
|
) |
| |
Definition at line 4259 of file kutil.cc.
4263 poly zeroPoly =
NULL;
4271 for (
int i = 1;
i <= leadRing->N;
i++)
4277 if (cabsind < leadRing->ch)
4279 zeroPoly =
p_ISet(
twoPow(leadRing->ch - cabsind), tailRing);
4283 zeroPoly =
p_ISet(1, tailRing);
4285 for (
int i = 1;
i <= leadRing->N;
i++)
4287 for (
long j = 1;
j <=
exp[
i];
j++)
4305 for (
int i = 1;
i <= leadRing->N;
i++)
4311 zeroPoly =
pNext(zeroPoly);
◆ kDebugPrint()
Output some debug info about a given strategy.
Definition at line 11574 of file kutil.cc.
11590 else Print(
"%p\n",(
void*)strat->
red);
11609 #ifdef HAVE_MORE_POS_IN_T
11647 PrintS(
"initEcartPair: ");
11651 Print(
"homog=%d, LazyDegree=%d, LazyPass=%d, ak=%d,\n",
11653 Print(
"honey=%d, sugarCrit=%d, Gebauer=%d, noTailReduction=%d, use_buckets=%d\n",
11659 Print(
"posInLDependsOnLength=%d\n",
11691 PrintS(
"currRing->pFDeg: ");
11706 PrintS(
"ecartWeights: ");
◆ kFindDivisibleByInS_T()
Definition at line 7161 of file kutil.cc.
7166 const unsigned long not_sev = ~L->sev;
7167 const unsigned long* sev = strat->
sevS;
7180 if (
j > end_pos)
return NULL;
7181 #if defined(PDEBUG) || defined(PDIV_DEBUG)
7183 (ecart== LONG_MAX || ecart>= strat->
ecartS[
j]))
7188 if (!(sev[
j] & not_sev) &&
7189 (ecart== LONG_MAX || ecart>= strat->
ecartS[
j]) &&
7203 if (
j > end_pos)
return NULL;
7204 #if defined(PDEBUG) || defined(PDIV_DEBUG)
7211 if (!(sev[
j] & not_sev) &&
7212 (ecart== LONG_MAX || ecart>= strat->
ecartS[
j]) &&
7223 if (strat->
tl < 0 || strat->
S_2_R[
j] == -1)
7244 if (
j > end_pos)
return NULL;
7246 #if defined(PDEBUG) || defined(PDIV_DEBUG)
7250 (ecart== LONG_MAX || ecart>= strat->
ecartS[
j]))
7256 if (! (sev[
j] & not_sev) && (ecart== LONG_MAX || ecart>= strat->
ecartS[
j]))
7259 assume(t !=
NULL && t->t_p !=
NULL && t->tailRing == r && t->p == strat->
S[
j]);
7275 if (
j > end_pos)
return NULL;
7277 #if defined(PDEBUG) || defined(PDIV_DEBUG)
7287 if (! (sev[
j] & not_sev) && (ecart== LONG_MAX || ecart>= strat->
ecartS[
j]))
7290 assume(t !=
NULL && t->t_p !=
NULL && t->tailRing == r && t->p == strat->
S[
j]);
◆ kFindInT() [1/2]
Definition at line 714 of file kutil.cc.
721 if (
i >= 0)
return i;
724 while (strat !=
NULL);
◆ kFindInT() [2/2]
int kFindInT |
( |
poly |
p, |
|
|
TSet |
T, |
|
|
int |
tlength |
|
) |
| |
returns index of p in TSet, or -1 if not found
Definition at line 703 of file kutil.cc.
708 for (
i=0;
i<=tlength;
i++)
710 if (
T[
i].
p ==
p)
return i;
◆ kMergeBintoL()
Definition at line 3081 of file kutil.cc.
3084 int j=strat->
Ll+strat->
Bl+1;
3092 for (
i=strat->
Bl;
i>=0;
i--)
3094 j = strat->
posInL(strat->
L,
j,&(strat->
B[
i]),strat);
◆ kMergeBintoLSba()
◆ kPosInLDependsOnLength()
Definition at line 9682 of file kutil.cc.
9683 if (strat->homog)
PrintS(
"ideal/module is homogeneous\n");
9684 else PrintS(
"ideal/module is not homogeneous\n");
◆ kStratChangeTailRing()
Definition at line 11028 of file kutil.cc.
11042 if (expbound == 0) expbound = strat->
tailRing->bitmask << 1;
11059 new_tailRing->pFDeg =
currRing->pFDeg;
11060 new_tailRing->pLDeg =
currRing->pLDeg;
11064 Print(
"[%lu:%d", (
unsigned long) new_tailRing->bitmask, new_tailRing->ExpL_Size);
11073 for (
i=0;
i<=strat->
tl;
i++)
11075 strat->
T[
i].ShallowCopyDelete(new_tailRing, new_tailBin,
11076 p_shallow_copy_delete);
11078 for (
i=0;
i<=strat->
Ll;
i++)
11082 strat->
L[
i].ShallowCopyDelete(new_tailRing, p_shallow_copy_delete);
11084 if ((strat->
P.t_p !=
NULL) ||
11086 strat->
P.ShallowCopyDelete(new_tailRing, p_shallow_copy_delete);
11088 if ((L !=
NULL) && (L->tailRing != new_tailRing))
11091 L->ShallowCopyDelete(new_tailRing, p_shallow_copy_delete);
11097 L->tailRing = new_tailRing;
11100 L->max_exp = t_l->max_exp;
11104 if ((
T !=
NULL) && (
T->tailRing != new_tailRing &&
T->i_r < 0))
11105 T->ShallowCopyDelete(new_tailRing, new_tailBin, p_shallow_copy_delete);
11112 strat->
tailBin = new_tailBin;
◆ kStratInitChangeTailRing()
void kStratInitChangeTailRing |
( |
kStrategy |
strat | ) |
|
Definition at line 11127 of file kutil.cc.
11138 unsigned long l = 0;
11144 for (
i=0;
i<= strat->
Ll;
i++)
11148 for (
i=0;
i<=strat->
tl;
i++)
◆ message()
void message |
( |
int |
i, |
|
|
int * |
reduc, |
|
|
int * |
olddeg, |
|
|
kStrategy |
strat, |
|
|
int |
red_result |
|
) |
| |
Definition at line 7727 of file kutil.cc.
7738 if (strat->
Ll != *reduc)
7740 if (strat->
Ll != *reduc-1)
7752 if (red_result == 0)
7754 else if (red_result < 0)
7756 if ((red_result > 0) || ((strat->
Ll % 100)==99))
7758 if (strat->
Ll != *reduc && strat->
Ll > 0)
◆ messageStat()
void messageStat |
( |
int |
hilbcount, |
|
|
kStrategy |
strat |
|
) |
| |
Definition at line 7768 of file kutil.cc.
7775 Print(
"product criterion:%d chain criterion:%d\n",strat->
cp,strat->
c3);
7776 if (hilbcount!=0)
Print(
"hilbert series criterion:%d\n",hilbcount);
7778 if (strat->
cv!=0)
Print(
"shift V criterion:%d\n",strat->
cv);
◆ messageStatSBA()
void messageStatSBA |
( |
int |
hilbcount, |
|
|
kStrategy |
strat |
|
) |
| |
Definition at line 7780 of file kutil.cc.
7789 if (hilbcount!=0)
Print(
"hilbert series criterion:%d\n",hilbcount);
7791 if (strat->
cv!=0)
Print(
"shift V criterion:%d\n",strat->
cv);
◆ newHEdge()
◆ nextZeroSimplexExponent()
int nextZeroSimplexExponent |
( |
long |
exp[], |
|
|
long |
ind[], |
|
|
long |
cexp[], |
|
|
long |
cind[], |
|
|
long * |
cabsind, |
|
|
long |
step[], |
|
|
long |
bound, |
|
|
long |
N |
|
) |
| |
Definition at line 4193 of file kutil.cc.
4198 if ((*cabsind <
bound) && (*cabsind - step[1] +
add <
bound))
4207 if (
N == 1)
return 0;
4209 while (
exp[
i] == cexp[
i] &&
i <=
N)
i++;
4211 *cabsind -= cind[
i];
4214 *cabsind += cind[
i];
4217 if (
i >
N)
return 0;
4221 for (
int j =
i + 1;
j <=
N;
j++)
4223 if (step[1] > step[
j]) step[1] = step[
j];
4226 if (*cabsind - step[1] +
add >=
bound)
4229 *cabsind -= cind[
i];
4231 *cabsind += cind[
i];
4234 if (
i >
N)
return 0;
4237 }
while (step[1] != -1);
4243 for (
i = 2;
i <=
N;
i++)
4245 if (step[1] > step[
i]) step[1] = step[
i];
◆ p_HasNotCF_Lift()
static BOOLEAN p_HasNotCF_Lift |
( |
poly |
p1, |
|
|
poly |
p2, |
|
|
const ring |
r |
|
) |
| |
|
static |
p_HasNotCF for the IDLIFT case: ignore component
Definition at line 2124 of file kutil.cc.
◆ pCopyL2p()
Definition at line 11741 of file kutil.cc.
11749 #ifdef HAVE_SHIFTBBA
◆ pDivComp()
static int pDivComp |
( |
poly |
p, |
|
|
poly |
q |
|
) |
| |
|
inlinestatic |
Definition at line 185 of file kutil.cc.
203 unsigned long la, lb;
204 unsigned long divmask =
currRing->divmask;
214 if (((la & divmask) ^ (lb & divmask)) != ((lb - la) & divmask))
221 if (((la & divmask) ^ (lb & divmask)) != ((la - lb) & divmask))
228 if (
b) {
return -1; }
◆ pDivCompRing()
static int pDivCompRing |
( |
poly |
p, |
|
|
poly |
q |
|
) |
| |
|
inlinestatic |
Definition at line 146 of file kutil.cc.
154 unsigned long la, lb;
155 unsigned long divmask =
currRing->divmask;
165 if (((la & divmask) ^ (lb & divmask)) != ((lb - la) & divmask))
172 if (((la & divmask) ^ (lb & divmask)) != ((la - lb) & divmask))
◆ pMove2CurrTail()
poly pMove2CurrTail |
( |
poly |
p, |
|
|
kStrategy |
strat |
|
) |
| |
◆ pMoveCurrTail2poly()
poly pMoveCurrTail2poly |
( |
poly |
p, |
|
|
kStrategy |
strat |
|
) |
| |
Definition at line 11724 of file kutil.cc.
11732 #ifdef HAVE_SHIFTBBA
◆ posInIdealMonFirst()
int posInIdealMonFirst |
( |
const ideal |
F, |
|
|
const poly |
p, |
|
|
int |
start, |
|
|
int |
end |
|
) |
| |
Definition at line 5112 of file kutil.cc.
5115 if(end < 0 || end >=
IDELEMS(F))
5117 if (end<0)
return 0;
5124 for(
i=start;
i<end;
i++)
5138 || ((op == o) && (
pLtCmp(set[an],
p) == -1)))
5145 || ((op == o) && (
pLtCmp(set[
i],
p) == -1)))
◆ posInL0()
◆ posInL0Ring()
◆ posInL11()
Definition at line 6222 of file kutil.cc.
6228 int o =
p->GetpFDeg();
6229 int op = set[
length].GetpFDeg();
6241 op = set[an].GetpFDeg();
6248 op = set[
i].GetpFDeg();
◆ posInL110()
Definition at line 6520 of file kutil.cc.
6526 int o =
p->GetpFDeg();
6527 int op = set[
length].GetpFDeg();
6531 || ((op == o) && (set[
length].length <=
p->length)
6541 op = set[an].GetpFDeg();
6543 || ((op == o) && (set[an].
length >
p->length))
6544 || ((op == o) && (set[an].length <=
p->length)
6550 op = set[
i].GetpFDeg();
6552 || ((op == o) && (set[
i].
length >
p->length))
6553 || ((op == o) && (set[
i].length <=
p->length)
◆ posInL110Ring()
Definition at line 6561 of file kutil.cc.
6567 int o =
p->GetpFDeg();
6568 int op = set[
length].GetpFDeg();
6572 || ((op == o) && (set[
length].length <=
p->length)
6582 op = set[an].GetpFDeg();
6584 || ((op == o) && (set[an].
length >
p->length))
6585 || ((op == o) && (set[an].length <=
p->length)
6591 op = set[
i].GetpFDeg();
6593 || ((op == o) && (set[
i].
length >
p->length))
6594 || ((op == o) && (set[
i].length <=
p->length)
◆ posInL11Ring()
Definition at line 6264 of file kutil.cc.
6270 int o =
p->GetpFDeg();
6271 int op = set[
length].GetpFDeg();
6283 op = set[an].GetpFDeg();
6290 op = set[
i].GetpFDeg();
◆ posInL11Ringls()
Definition at line 6334 of file kutil.cc.
6338 if (
length < 0)
return 0;
6348 if (set[an].FDeg >
p->FDeg)
6350 if (set[an].FDeg < p->FDeg)
6352 if (set[an].FDeg ==
p->FDeg)
6360 if (set[an].t_p!=
NULL)
6382 if (set[
i].FDeg >
p->FDeg)
6384 if (set[
i].FDeg < p->FDeg)
6386 if (set[
i].FDeg ==
p->FDeg)
6394 if (set[
i].t_p!=
NULL)
◆ posInL13()
Definition at line 6608 of file kutil.cc.
6614 int o =
p->GetpFDeg();
6616 if (set[
length].GetpFDeg() > o)
6626 if (set[an].GetpFDeg() >= o)
6631 if (set[
i].GetpFDeg() >= o)
◆ posInL15()
Definition at line 6643 of file kutil.cc.
6649 int o =
p->GetpFDeg() +
p->ecart;
6662 op = set[an].GetpFDeg() + set[an].ecart;
6669 op = set[
i].GetpFDeg() + set[
i].ecart;
◆ posInL15Ring()
Definition at line 6678 of file kutil.cc.
6684 int o =
p->GetpFDeg() +
p->ecart;
6697 op = set[an].GetpFDeg() + set[an].ecart;
6704 op = set[
i].GetpFDeg() + set[
i].ecart;
◆ posInL17()
Definition at line 6719 of file kutil.cc.
6725 int o =
p->GetpFDeg() +
p->ecart;
6729 && (set[
length].ecart >
p->ecart))
6731 && (set[
length].ecart ==
p->ecart)
6741 if ((set[an].GetpFDeg() + set[an].ecart > o)
6742 || ((set[an].GetpFDeg() + set[an].ecart == o)
6743 && (set[an].ecart >
p->ecart))
6744 || ((set[an].GetpFDeg() + set[an].ecart == o)
6745 && (set[an].ecart ==
p->ecart)
6751 if ((set[
i].GetpFDeg() + set[
i].ecart > o)
6752 || ((set[
i].GetpFDeg() + set[
i].ecart == o)
6753 && (set[
i].ecart >
p->ecart))
6754 || ((set[
i].GetpFDeg() +set[
i].ecart == o)
6755 && (set[
i].ecart ==
p->ecart)
◆ posInL17_c()
Definition at line 6813 of file kutil.cc.
6822 int o =
p->GetpFDeg() +
p->ecart;
6830 && (set[
length].ecart >
p->ecart))
6832 && (set[
length].ecart ==
p->ecart)
6847 if ((set[an].GetpFDeg() + set[an].ecart > o)
6848 || ((set[an].GetpFDeg() + set[an].ecart == o)
6849 && (set[an].ecart >
p->ecart))
6850 || ((set[an].GetpFDeg() + set[an].ecart == o)
6851 && (set[an].ecart ==
p->ecart)
6862 if ((set[
i].GetpFDeg() + set[
i].ecart > o)
6863 || ((set[
i].GetpFDeg() + set[
i].ecart == o)
6864 && (set[
i].ecart >
p->ecart))
6865 || ((set[
i].GetpFDeg() +set[
i].ecart == o)
6866 && (set[
i].ecart ==
p->ecart)
◆ posInL17_cRing()
Definition at line 6877 of file kutil.cc.
6886 int o =
p->GetpFDeg() +
p->ecart;
6894 && (set[
length].ecart >
p->ecart))
6896 && (set[
length].ecart ==
p->ecart)
6911 if ((set[an].GetpFDeg() + set[an].ecart > o)
6912 || ((set[an].GetpFDeg() + set[an].ecart == o)
6913 && (set[an].ecart >
p->ecart))
6914 || ((set[an].GetpFDeg() + set[an].ecart == o)
6915 && (set[an].ecart ==
p->ecart)
6926 if ((set[
i].GetpFDeg() + set[
i].ecart > o)
6927 || ((set[
i].GetpFDeg() + set[
i].ecart == o)
6928 && (set[
i].ecart >
p->ecart))
6929 || ((set[
i].GetpFDeg() +set[
i].ecart == o)
6930 && (set[
i].ecart ==
p->ecart)
◆ posInL17Ring()
Definition at line 6763 of file kutil.cc.
6769 int o =
p->GetpFDeg() +
p->ecart;
6773 && (set[
length].ecart >
p->ecart))
6775 && (set[
length].ecart ==
p->ecart)
6785 if ((set[an].GetpFDeg() + set[an].ecart > o)
6786 || ((set[an].GetpFDeg() + set[an].ecart == o)
6787 && (set[an].ecart >
p->ecart))
6788 || ((set[an].GetpFDeg() + set[an].ecart == o)
6789 && (set[an].ecart ==
p->ecart)
6795 if ((set[
i].GetpFDeg() + set[
i].ecart > o)
6796 || ((set[
i].GetpFDeg() + set[
i].ecart == o)
6797 && (set[
i].ecart >
p->ecart))
6798 || ((set[
i].GetpFDeg() +set[
i].ecart == o)
6799 && (set[
i].ecart ==
p->ecart)
◆ posInLF5C()
◆ posInLF5CRing()
Definition at line 6298 of file kutil.cc.
6304 int o =
p->GetpFDeg();
6305 int op = set[
length].GetpFDeg();
6317 op = set[an].GetpFDeg();
6324 op = set[
i].GetpFDeg();
◆ posInLrg0()
Definition at line 6436 of file kutil.cc.
6448 if (
length < 0)
return 0;
6450 int o =
p->GetpFDeg();
6451 int op = set[
length].GetpFDeg();
6462 op = set[an].GetpFDeg();
6463 if ((op > o) || ((op == o) && (
pLmCmp(set[an].
p,
p->p) != -
currRing->OrdSgn)))
6468 op = set[
i].GetpFDeg();
◆ posInLRing()
Definition at line 6109 of file kutil.cc.
6113 if (
length < 0)
return 0;
6114 if (set[
length].FDeg >
p->FDeg)
6116 if (set[
length].FDeg ==
p->FDeg)
6117 if(set[
length].GetpLength() >
p->GetpLength())
6128 if (set[an].FDeg >
p->FDeg)
6130 if(set[an].FDeg ==
p->FDeg)
6132 if(set[an].GetpLength() >
p->GetpLength())
6136 if(set[an].GetpLength() ==
p->GetpLength())
6153 if (set[
i].FDeg >
p->FDeg)
6157 if(set[
i].FDeg ==
p->FDeg)
6159 if(set[
i].GetpLength() >
p->GetpLength())
6163 if(set[
i].GetpLength() ==
p->GetpLength())
◆ posInLSig()
◆ posInLSigRing()
Definition at line 6046 of file kutil.cc.
6065 cmp =
pLtCmp(set[an].sig,
p->sig);
6072 if (set[an].FDeg >
p->FDeg)
6074 if (set[an].FDeg < p->FDeg)
6076 if (set[an].FDeg ==
p->FDeg)
6094 if (set[
i].FDeg >
p->FDeg)
6096 if (set[
i].FDeg < p->FDeg)
6098 if (set[
i].FDeg ==
p->FDeg)
◆ posInLSpecial()
Definition at line 5921 of file kutil.cc.
5927 int d=
p->GetpFDeg();
5928 int op=set[
length].GetpFDeg();
5942 op=set[an].GetpFDeg();
5944 || ((op == d) && (
p->p1!=
NULL) && (set[an].p1==
NULL))
5950 op=set[
i].GetpFDeg();
5952 || ((op==d) && (
p->p1!=
NULL) && (set[
i].p1==
NULL))
◆ posInS()
Definition at line 4934 of file kutil.cc.
4987 if (cmp == cmp_int)
return an;
4988 if (cmp == -cmp_int)
return en;
4994 if (cmp == cmp_int) en =
i;
4995 else if (cmp == -cmp_int) an =
i;
5011 if (
pLmCmp(set[an],
p) == cmp_int)
return an;
5012 if (
pLmCmp(set[an],
p) == -cmp_int)
return en;
5014 && ((strat->
ecartS[an])>ecart_p))
5020 else if (
pLmCmp(set[
i],
p) == -cmp_int) an=
i;
5024 &&((strat->
ecartS[
i])<ecart_p))
◆ posInSMonFirst()
Definition at line 5035 of file kutil.cc.
5052 || ((op == o) && (
pLtCmp(set[mon],
p) == -1)))
5063 || ((op == o) && (
pLtCmp(set[an],
p) == -1)))
5070 || ((op == o) && (
pLtCmp(set[
i],
p) == -1)))
5096 || ((op == o) && (
pLtCmp(set[an],
p) == -1)))
5103 || ((op == o) && (
pLtCmp(set[
i],
p) == -1)))
◆ posInSyz()
Definition at line 6182 of file kutil.cc.
6185 if (strat->
syzl==0)
return 0;
6190 int en= strat->
syzl-1;
◆ posInT0()
◆ posInT1()
◆ posInT11()
Definition at line 5225 of file kutil.cc.
5228 if (
length==-1)
return 0;
5230 int o =
p.GetpFDeg();
5231 int op = set[
length].GetpFDeg();
5245 op= set[an].GetpFDeg();
5252 op = set[
i].GetpFDeg();
◆ posInT110()
Definition at line 5378 of file kutil.cc.
5382 if (
length==-1)
return 0;
5384 int o =
p.GetpFDeg();
5385 int op = set[
length].GetpFDeg();
5389 || (( op == o) && (set[
length].length ==
p.length)
5400 op = set[an].GetpFDeg();
5402 || (( op == o) && (set[an].
length >
p.length))
5403 || (( op == o) && (set[an].length ==
p.length)
5409 op = set[
i].GetpFDeg();
5411 || (( op == o) && (set[
i].
length >
p.length))
5412 || (( op == o) && (set[
i].length ==
p.length)
◆ posInT110Ring()
Definition at line 5420 of file kutil.cc.
5424 if (
length==-1)
return 0;
5426 int o =
p.GetpFDeg();
5427 int op = set[
length].GetpFDeg();
5431 || (( op == o) && (set[
length].length ==
p.length)
5442 op = set[an].GetpFDeg();
5444 || (( op == o) && (set[an].
length >
p.length))
5445 || (( op == o) && (set[an].length ==
p.length)
5451 op = set[
i].GetpFDeg();
5453 || (( op == o) && (set[
i].
length >
p.length))
5454 || (( op == o) && (set[
i].length ==
p.length)
◆ posInT11Ring()
Definition at line 5261 of file kutil.cc.
5264 if (
length==-1)
return 0;
5266 int o =
p.GetpFDeg();
5267 int op = set[
length].GetpFDeg();
5281 op= set[an].GetpFDeg();
5288 op = set[
i].GetpFDeg();
◆ posInT13()
Definition at line 5467 of file kutil.cc.
5470 if (
length==-1)
return 0;
5472 int o =
p.GetpFDeg();
5474 if (set[
length].GetpFDeg() <= o)
5484 if (set[an].GetpFDeg() > o)
5489 if (set[
i].GetpFDeg() > o)
◆ posInT15()
Definition at line 5535 of file kutil.cc.
5556 if (
length==-1)
return 0;
5558 int o =
p.GetpFDeg() +
p.ecart;
5573 op = set[an].GetpFDeg()+set[an].ecart;
5580 op = set[
i].GetpFDeg()+set[
i].ecart;
◆ posInT15Ring()
Definition at line 5589 of file kutil.cc.
5592 if (
length==-1)
return 0;
5594 int o =
p.GetpFDeg() +
p.ecart;
5609 op = set[an].GetpFDeg()+set[an].ecart;
5616 op = set[
i].GetpFDeg()+set[
i].ecart;
◆ posInT17()
Definition at line 5630 of file kutil.cc.
5653 if (
length==-1)
return 0;
5655 int o =
p.GetpFDeg() +
p.ecart;
5659 || (( op == o) && (set[
length].ecart >
p.ecart))
5660 || (( op == o) && (set[
length].ecart==
p.ecart)
5671 op = set[an].GetpFDeg()+set[an].ecart;
5673 || (( op == o) && (set[an].ecart <
p.ecart))
5674 || (( op == o) && (set[an].ecart==
p.ecart)
5680 op = set[
i].GetpFDeg()+set[
i].ecart;
5682 || (( op == o) && (set[
i].ecart <
p.ecart))
5683 || (( op == o) && (set[
i].ecart ==
p.ecart)
◆ posInT17_c()
Definition at line 5737 of file kutil.cc.
5740 if (
length==-1)
return 0;
5744 int o =
p.GetpFDeg() +
p.ecart;
5753 || ((op == o) && (set[
length].ecart >
p.ecart))
5754 || ((op == o) && (set[
length].ecart==
p.ecart)
5770 int op = set[an].GetpFDeg()+set[an].ecart;
5772 || ((op == o) && (set[an].ecart <
p.ecart))
5773 || ((op == o) && (set[an].ecart==
p.ecart)
5784 int op = set[
i].GetpFDeg()+set[
i].ecart;
5786 || ((op == o) && (set[
i].ecart <
p.ecart))
5787 || ((op == o) && (set[
i].ecart ==
p.ecart)
◆ posInT17_cRing()
Definition at line 5798 of file kutil.cc.
5801 if (
length==-1)
return 0;
5805 int o =
p.GetpFDeg() +
p.ecart;
5814 || ((op == o) && (set[
length].ecart >
p.ecart))
5815 || ((op == o) && (set[
length].ecart==
p.ecart)
5831 int op = set[an].GetpFDeg()+set[an].ecart;
5833 || ((op == o) && (set[an].ecart <
p.ecart))
5834 || ((op == o) && (set[an].ecart==
p.ecart)
5845 int op = set[
i].GetpFDeg()+set[
i].ecart;
5847 || ((op == o) && (set[
i].ecart <
p.ecart))
5848 || ((op == o) && (set[
i].ecart ==
p.ecart)
◆ posInT17Ring()
Definition at line 5691 of file kutil.cc.
5694 if (
length==-1)
return 0;
5696 int o =
p.GetpFDeg() +
p.ecart;
5700 || (( op == o) && (set[
length].ecart >
p.ecart))
5701 || (( op == o) && (set[
length].ecart==
p.ecart)
5712 op = set[an].GetpFDeg()+set[an].ecart;
5714 || (( op == o) && (set[an].ecart <
p.ecart))
5715 || (( op == o) && (set[an].ecart==
p.ecart)
5721 op = set[
i].GetpFDeg()+set[
i].ecart;
5723 || (( op == o) && (set[
i].ecart <
p.ecart))
5724 || (( op == o) && (set[
i].ecart ==
p.ecart)
◆ posInT19()
Definition at line 5864 of file kutil.cc.
5868 if (
length==-1)
return 0;
5871 int op=
p.GetpFDeg();
5873 if (set[
length].ecart < o)
5875 if (set[
length].ecart == o)
5877 int oo=set[
length].GetpFDeg();
5878 if ((oo < op) || ((oo==op) && (set[
length].
length <
p.length)))
5889 if (set[an].ecart > o)
5891 if (set[an].ecart == o)
5893 int oo=set[an].GetpFDeg();
5895 || ((oo==op) && (set[an].
length >
p.length)))
5901 if (set[
i].ecart > o)
5903 else if (set[
i].ecart == o)
5905 int oo=set[
i].GetpFDeg();
5907 || ((oo == op) && (set[
i].
length >
p.length)))
◆ posInT2()
◆ posInT_EcartFDegpLength()
Definition at line 11449 of file kutil.cc.
11461 if (
length==-1)
return 0;
11464 int op=
p.GetpFDeg();
11465 int ol =
p.GetpLength();
11467 if (set[
length].ecart < o)
11469 if (set[
length].ecart == o)
11471 int oo=set[
length].GetpFDeg();
11472 if ((oo < op) || ((oo==op) && (set[
length].
length < ol)))
11483 if (set[an].ecart > o)
11485 if (set[an].ecart == o)
11487 int oo=set[an].GetpFDeg();
11489 || ((oo==op) && (set[an].
pLength > ol)))
11495 if (set[
i].ecart > o)
11497 else if (set[
i].ecart == o)
11499 int oo=set[
i].GetpFDeg();
◆ posInT_EcartpLength()
Definition at line 5496 of file kutil.cc.
5499 int ol =
p.GetpLength();
5500 if (
length==-1)
return 0;
5504 int oo=set[
length].ecart;
5505 if ((oo < op) || ((oo==op) && (set[
length].
length < ol)))
5515 int oo=set[an].ecart;
5517 || ((oo==op) && (set[an].
pLength > ol)))
5522 int oo=set[
i].ecart;
5524 || ((oo == op) && (set[
i].
pLength > ol)))
◆ posInT_FDegpLength()
Definition at line 11503 of file kutil.cc.
11515 if (
length==-1)
return 0;
11517 int op=
p.GetpFDeg();
11518 int ol =
p.GetpLength();
11520 int oo=set[
length].GetpFDeg();
11521 if ((oo < op) || ((oo==op) && (set[
length].
length < ol)))
11531 int oo=set[an].GetpFDeg();
11533 || ((oo==op) && (set[an].
pLength > ol)))
◆ posInT_pLength()
Definition at line 11540 of file kutil.cc.
11551 int ol =
p.GetpLength();
◆ posInTrg0()
Definition at line 5302 of file kutil.cc.
5305 if (
length==-1)
return 0;
5306 int o =
p.GetpFDeg();
5307 int op = set[
length].GetpFDeg();
5319 op = set[an].GetpFDeg();
5320 if (op > o)
return an;
5321 if (op < 0)
return en;
5323 if (cmp == cmp_int)
return an;
5324 if (cmp == -cmp_int)
return en;
5329 op = set[
i].GetpFDeg();
5331 else if (op < o) an =
i;
5335 if (cmp == cmp_int) en =
i;
5336 else if (cmp == -cmp_int) an =
i;
◆ postReduceByMon()
used for GB over ZZ: intermediate reduction by monomial elements background: any known constant element of ideal suppresses intermediate coefficient swell
Definition at line 10805 of file kutil.cc.
10818 poly pH =
h->GetP();
10822 for(
int i = 0;
i<=strat->
sl;
i++)
◆ postReduceByMonSig()
Definition at line 10873 of file kutil.cc.
10886 poly hSig =
h->sig;
10887 poly pH =
h->GetP();
10891 for(
int i = 0;
i<=strat->
sl;
i++)
10902 if(sigMult!=
NULL &&
pLtCmp(hSig,sigMult) == 1)
10929 if(sigMult!=
NULL &&
pLtCmp(hSig,sigMult) == 1)
◆ preIntegerCheck()
poly preIntegerCheck |
( |
const ideal |
Forig, |
|
|
const ideal |
Q |
|
) |
| |
used for GB over ZZ: look for constant and monomial elements in the ideal background: any known constant element of ideal suppresses intermediate coefficient swell
Definition at line 10637 of file kutil.cc.
10651 ideal F =
idCopy(Forig);
10655 ideal monred =
idInit(1,1);
10662 if((posconst != -1) && (!
nIsZero(F->m[posconst]->coef)))
10672 for(
int i=0;
i<idelemQ;
i++)
10680 if((posconst != -1) && (!
nIsZero(monred->m[posconst]->coef)))
10682 pmon =
pCopy(monred->m[posconst]);
10697 II->m[
j++] =
prMapR(F->m[
i], nMap, origR, QQ_ring);
10699 II->m[
j++] =
prMapR(
Q->m[
i], nMap, origR, QQ_ring);
10706 if(II->m[
i] !=
NULL)
10707 II->m[
i+1] = II->m[
i];
10710 poly integer =
NULL;
10718 integer =
pHead(syz->m[
i]);
10725 pmon =
prMapR(integer, nMap2, QQ_ring, origR);
10739 poly mindegmon =
NULL;
10744 if(mindegmon ==
NULL)
10745 mindegmon =
pCopy(one->m[
i]);
10748 if(
p_Deg(one->m[
i], QQ_ring) <
p_Deg(mindegmon, QQ_ring))
10749 mindegmon =
pCopy(one->m[
i]);
10753 if(mindegmon !=
NULL)
10756 if(II->m[
i] !=
NULL)
10757 II->m[
i+1] = II->m[
i];
10758 II->m[0] =
pCopy(mindegmon);
10787 pmon =
prMapR(mindegmon, nMap2, QQ_ring, origR);
◆ redBba()
static poly redBba |
( |
poly |
h, |
|
|
int |
maxIndex, |
|
|
kStrategy |
strat |
|
) |
| |
|
static |
Definition at line 8732 of file kutil.cc.
8743 while (
j <= maxIndex)
◆ redBba1()
static poly redBba1 |
( |
poly |
h, |
|
|
int |
maxIndex, |
|
|
kStrategy |
strat |
|
) |
| |
|
static |
Definition at line 8627 of file kutil.cc.
8638 while (
j <= maxIndex)
◆ redEcart()
Definition at line 167 of file kstd1.cc.
175 d =
h->GetpFDeg()+
h->ecart;
177 h->SetShortExpVector();
187 ei = strat->
T[
j].ecart;
190 if (ei >
h->ecart && ii < strat->tl)
192 li = strat->
T[
j].length;
202 if (
i > strat->
tl)
break;
203 if ((strat->
T[
i].ecart < ei || (strat->
T[
i].ecart == ei &&
204 strat->
T[
i].length < li))
211 if (strat->
T[
i].ecart < ei || (strat->
T[
i].ecart == ei &&
212 strat->
T[
i].length < li))
217 ei = strat->
T[
i].ecart;
218 if (ei <= h->ecart)
break;
219 li = strat->
T[
i].length;
237 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
266 h->SetShortExpVector();
271 h->ecart = d-
h->GetpFDeg();
273 h->ecart = d-
h->GetpFDeg()+ei-
h->ecart;
277 h->ecart =
h->pLDeg(strat->
LDegLast) -
h->GetpFDeg();
284 if (strat->
honey)
h->SetLength();
294 d =
h->GetpFDeg()+
h->ecart;
301 && ((d >= reddeg) || (pass > strat->
LazyPass)))
307 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
329 if (
h->pTotalDeg()+
h->ecart >= (int)strat->
tailRing->bitmask)
334 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
◆ redFirst()
Definition at line 529 of file kstd1.cc.
532 if (
h->IsNull())
return 0;
541 d =
h->GetpFDeg() +
h->ecart;
544 h->SetShortExpVector();
550 h->SetDegStuffReturnLDeg(strat->
LDegLast);
581 h->SetShortExpVector();
594 h->SetDegStuffReturnLDeg(strat->
LDegLast);
604 if (strat->
T[
j].ecart <=
h->ecart)
605 h->ecart = d -
h->GetpFDeg();
607 h->ecart = d -
h->GetpFDeg() + strat->
T[
j].ecart -
h->ecart;
609 d =
h->GetpFDeg() +
h->ecart;
612 d =
h->SetDegStuffReturnLDeg(strat->
LDegLast);
621 && ((d >= reddeg) || (pass > strat->
LazyPass)))
626 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
644 if (
h->pTotalDeg()+
h->ecart >= (int)strat->
tailRing->bitmask)
649 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
◆ redMora()
static poly redMora |
( |
poly |
h, |
|
|
int |
maxIndex, |
|
|
kStrategy |
strat |
|
) |
| |
|
static |
◆ redtail() [1/2]
Definition at line 7303 of file kutil.cc.
7341 if (With ==
NULL)
break;
7351 return redtail(L, end_pos, strat);
7357 if (hn ==
NULL)
goto all_done;
◆ redtail() [2/2]
poly redtail |
( |
poly |
p, |
|
|
int |
end_pos, |
|
|
kStrategy |
strat |
|
) |
| |
◆ redtailBba()
Definition at line 7379 of file kutil.cc.
7383 #define REDTAIL_CANONICALIZE 100
7387 p =
h = L->GetLmTailRing();
7389 return L->GetLmCurrRing();
7424 Ln.SetShortExpVector();
7430 With = &(strat->
T[
j]);
7431 assume(With->GetpLength()==
pLength(With->p != __null ? With->p : With->t_p));
7436 if (With ==
NULL)
break;
7437 assume(With->GetpLength()==
pLength(With->p != __null ? With->p : With->t_p));
7464 pNext(
h) = Ln.LmExtractAndIter();
7467 }
while (!Ln.IsNull());
7470 if (Ln.IsNull())
goto all_done;
7471 if (! withT) With_s.Init(
currRing);
7473 pNext(
h) = Ln.LmExtractAndIter();
◆ redtailBba_Z()
Definition at line 7609 of file kutil.cc.
7617 p =
h = L->GetLmTailRing();
7619 return L->GetLmCurrRing();
7626 Ln.pLength = L->GetpLength() - 1;
7639 Ln.SetShortExpVector();
7641 if (With ==
NULL)
break;
7651 poly p_Ln=Ln.GetLmCurrRing();
7652 poly p_With=With->GetLmCurrRing();
7664 if (Ln.bucket!=
NULL)
7695 pNext(
h) = Ln.LmExtractAndIter();
7698 }
while (!Ln.IsNull());
7701 if (Ln.IsNull())
goto all_done;
7704 pNext(
h) = Ln.LmExtractAndIter();
◆ redtailBbaBound()
Definition at line 7493 of file kutil.cc.
7500 p =
h = L->GetLmTailRing();
7502 return L->GetLmCurrRing();
7509 Ln.pLength = L->GetpLength() - 1;
7533 Ln.SetShortExpVector();
7539 With = &(strat->
T[
j]);
7544 if (With ==
NULL)
break;
7571 pNext(
h) = Ln.LmExtractAndIter();
7574 }
while (!Ln.IsNull());
7586 if (! withT) With_s.Init(
currRing);
7588 pNext(
h) = Ln.LmExtractAndIter();
◆ redtailBbaShift()
Definition at line 12520 of file kutil.cc.
12535 p =
h = L->GetLmTailRing();
12537 return L->GetLmCurrRing();
12544 Ln.pLength = L->GetpLength() - 1;
12552 while(!Ln.IsNull())
12556 Ln.SetShortExpVector();
12562 With = &(strat->
T[
j]);
12567 if (With ==
NULL)
break;
12583 pNext(
h) = Ln.LmExtractAndIter();
12586 }
while (!Ln.IsNull());
12589 if (Ln.IsNull())
goto all_done;
12590 if (! withT) With_s.Init(
currRing);
12592 pNext(
h) = Ln.LmExtractAndIter();
◆ reorderS()
Definition at line 4881 of file kutil.cc.
4884 int i,
j,at,ecart, s2r;
4888 int new_suc=strat->
sl+1;
4892 for (;
i<=strat->
sl;
i++)
4897 if (new_suc > at) new_suc = at;
4900 sev = strat->
sevS[
i];
4903 for (
j=
i;
j>=at+1;
j--)
4905 strat->
S[
j] = strat->
S[
j-1];
4911 strat->
ecartS[at] = ecart;
4912 strat->
sevS[at] = sev;
4913 strat->
S_2_R[at] = s2r;
4916 for (
j=
i;
j>=at+1;
j--)
4920 strat->
fromQ[at]=fq;
4924 if (new_suc <= strat->sl) *suc=new_suc;
◆ sbaCheckGcdPair()
Definition at line 1607 of file kutil.cc.
1610 if(strat->
sl < 0)
return FALSE;
1612 for(
i=0;
i<strat->
sl;
i++)
1648 h->i_r1 = -1;
h->i_r2 = -1;
◆ sbaRing()
Definition at line 11154 of file kutil.cc.
11175 res->block0 = (
int *)
omAlloc0((n+1)*
sizeof(int));
11176 res->block1 = (
int *)
omAlloc0((n+1)*
sizeof(int));
11177 int **wvhdl = (
int **)
omAlloc0((n+1)*
sizeof(
int*));
11178 res->wvhdl = wvhdl;
11179 for (
int i=1;
i<n;
i++)
11181 res->order[
i] = r->order[
i-1];
11182 res->block0[
i] = r->block0[
i-1];
11183 res->block1[
i] = r->block1[
i-1];
11184 res->wvhdl[
i] = r->wvhdl[
i-1];
11203 #ifndef SING_NDEBUG
11204 WarnS(
"error in nc_rComplete");
11223 res->block0 = (
int *)
omAlloc0((n+2)*
sizeof(int));
11224 res->block1 = (
int *)
omAlloc0((n+2)*
sizeof(int));
11225 int **wvhdl = (
int **)
omAlloc0((n+2)*
sizeof(
int*));
11226 res->wvhdl = wvhdl;
11227 for (
int i=2;
i<n+2;
i++)
11229 res->order[
i] = r->order[
i-2];
11230 res->block0[
i] = r->block0[
i-2];
11231 res->block1[
i] = r->block1[
i-2];
11232 res->wvhdl[
i] = r->wvhdl[
i-2];
11237 res->block0[0] = 1;
11239 for (
int i=0;
i<
res->N; ++
i)
11240 res->wvhdl[0][
i] = 1;
11259 #ifndef SING_NDEBUG
11260 WarnS(
"error in nc_rComplete");
◆ showOption()
◆ sugarDivisibleBy()
static BOOLEAN sugarDivisibleBy |
( |
int |
ecart1, |
|
|
int |
ecart2 |
|
) |
| |
|
inlinestatic |
Definition at line 1271 of file kutil.cc.
1274 return (ecart1 <= ecart2);
◆ superenterpairs()
void superenterpairs |
( |
poly |
h, |
|
|
int |
k, |
|
|
int |
ecart, |
|
|
int |
pos, |
|
|
kStrategy |
strat, |
|
|
int |
atR |
|
) |
| |
◆ superenterpairsSig()
void superenterpairsSig |
( |
poly |
h, |
|
|
poly |
hSig, |
|
|
int |
hFrom, |
|
|
int |
k, |
|
|
int |
ecart, |
|
|
int |
pos, |
|
|
kStrategy |
strat, |
|
|
int |
atR |
|
) |
| |
◆ syzCriterion()
Definition at line 6944 of file kutil.cc.
6949 PrintS(
"syzygy criterion checks: ");
6952 for (
int k=0;
k<strat->
syzl;
k++)
6957 Print(
"checking with: %d / %d -- \n",
k,strat->
syzl);
◆ syzCriterionInc()
Definition at line 6979 of file kutil.cc.
6986 PrintS(
"--- syzygy criterion checks: ");
7011 Print(
"checking with: %d -- ",
k);
◆ twoPow()
◆ updateResult()
void updateResult |
( |
ideal |
r, |
|
|
ideal |
Q, |
|
|
kStrategy |
strat |
|
) |
| |
Definition at line 10180 of file kutil.cc.
10205 if ((r->m[
l]!=
NULL)
10212 if ((
Q->m[q]!=
NULL)
10236 if ((r->m[
l]!=
NULL)
10243 if ((
Q->m[q]!=
NULL)
10287 reduction_found=
TRUE;
10318 reduction_found=
TRUE;
10332 if ( reduction_found)
◆ updateS()
Definition at line 8801 of file kutil.cc.
8827 while (i<=strat->sl)
8838 if (
pCmp(redSi,strat->
S[
i])!=0)
8895 if (any_change)
reorderS(&suc,strat);
8900 for (
i=0;
i<=strat->
sl;
i++)
8934 while (i<=strat->sl)
8946 else if (
pCmp((strat->
S)[
i],redSi)!=0)
8987 if (any_change)
reorderS(&suc,strat);
8988 else { suc=-1;
break; }
8999 for (
i=0;
i<=strat->
sl;
i++)
◆ updateSShift()
void updateSShift |
( |
kStrategy |
strat, |
|
|
int |
uptodeg, |
|
|
int |
lV |
|
) |
| |
Definition at line 11834 of file kutil.cc.
11851 for (
i=0;
i<=strat->
sl;
i++)
11853 memset(&
h,0,
sizeof(
h));
◆ DENOMINATOR_LIST
◆ HCord
◆ Kstd1_deg
◆ Kstd1_mu
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)
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)
void updateL(kStrategy strat)
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 chainCritRing(poly p, int, kStrategy strat)
int posInLSig(const LSet set, const int length, LObject *p, const kStrategy)
static BOOLEAN _p_LmDivisibleByPart(poly a, const ring r_a, poly b, const ring r_b, const int start, const int end)
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)
#define pLtCmpOrdSgnEqP(p, q)
void deleteHC(LObject *L, kStrategy strat, BOOLEAN fromNext)
#define pIsConstant(p)
like above, except that Comp might be != 0
void initBuchMoraCrit(kStrategy strat)
void enterExtendedSpolySig(poly h, poly hSig, kStrategy strat)
void StringAppendS(const char *st)
void initPairtest(kStrategy strat)
void enterOneZeroPairRing(poly f, poly t_p, poly p, int ecart, kStrategy strat, int atR=-1)
#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)
BOOLEAN pCompareChainPart(poly p, poly p1, poly p2, poly lcm, const ring R)
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)
int kFindDivisibleByInS(const kStrategy strat, int *max_ind, LObject *L)
return -1 if no divisor is found number of first divisor in S, otherwise
int posInL0(const LSet set, const int length, LObject *p, const kStrategy)
static BOOLEAN rField_is_Domain(const ring r)
long pLDeg0(poly p, int *l, const ring r)
void rChangeCurrRing(ring r)
#define TEST_OPT_DEGBOUND
poly nc_p_Bracket_qq(poly p, const poly q, const ring r)
returns [p,q], destroys p
int posInL17_c(const LSet set, const int length, LObject *p, const kStrategy)
int isInV(poly p, int lV)
void reorderL(kStrategy strat)
long pLDeg1_Totaldegree(poly p, int *l, const ring r)
#define pGetExp(p, i)
Exponent.
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()
static poly p_Neg(poly p, const ring r)
static void p_SetCompP(poly p, int i, ring r)
void rKillModifiedRing(ring r)
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)
const struct soptionStruct optionStruct[]
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)
poly prMapR(poly src, nMapFunc nMap, ring src_r, ring dest_r)
long pLDeg1c_Deg(poly p, int *l, const ring r)
BOOLEAN nc_rComplete(const ring src, ring dest, bool bSetupQuotient)
void p_wrp(poly p, ring lmRing, ring tailRing)
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
#define pGetShortExpVector(a)
returns the "Short Exponent Vector" – used to speed up divisibility tests (see polys-impl....
#define REDTAIL_CANONICALIZE
static poly pp_Mult_mm(poly p, poly m, const ring r)
int posInS(const kStrategy strat, const int length, const poly p, const int ecart_p)
long pLDeg1c_WFirstTotalDegree(poly p, int *l, const ring r)
const CanonicalForm CFMap CFMap & N
int posInT_EcartpLength(const TSet set, const int length, LObject &p)
int posInL0Ring(const LSet set, const int length, LObject *p, const kStrategy)
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)
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)
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)
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)
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)
void kMergeBintoLSba(kStrategy strat)
void chainCritOpt_1(poly, int, kStrategy strat)
poly ksCreateShortSpoly(poly p1, poly p2, ring tailRing)
BOOLEAN syzCriterionInc(poly sig, unsigned long not_sevSig, kStrategy strat)
long p_WFirstTotalDegree(poly p, const ring r)
static poly p_Copy(poly p, const ring r)
returns a copy of p
int posInLSigRing(const LSet set, const int length, LObject *p, const kStrategy)
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
void 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)
static void p_ExpVectorAdd(poly p1, poly p2, const ring r)
KINLINE TObject * s_2_t(int i)
#define TEST_OPT_INTSTRATEGY
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)
poly p_Sub(poly p1, poly p2, const ring r)
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
void kBucketDestroy(kBucket_pt *bucket_pt)
void firstUpdate(kStrategy strat)
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 redRing(LObject *h, kStrategy strat)
char posInLDependsOnLength
static int pDivCompRing(poly p, poly q)
void enterSBba(LObject &p, int atS, kStrategy strat, int atR)
int posInT2(const TSet set, const int length, LObject &p)
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)
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)
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)
static BOOLEAN rIsRatGRing(const ring r)
#define ENTER_USE_MEMMOVE
int redFirst(LObject *h, kStrategy strat)
void initenterpairs(poly h, int k, int ecart, int isFromQ, kStrategy strat, int atR=-1)
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)
#define pInit()
allocates a new monomial and initializes everything to 0
static poly redMora(poly h, int maxIndex, kStrategy strat)
KINLINE BOOLEAN k_GetLeadTerms(const poly p1, const poly p2, const ring p_r, poly &m1, poly &m2, const ring m_r)
poly pCopyL2p(LObject H, kStrategy strat)
void kMergeBintoL(kStrategy strat)
void enterSyz(LObject &p, kStrategy strat, int atT)
int posInL10(const LSet set, const int length, LObject *p, const kStrategy strat)
void cancelunit1(LObject *p, int *suc, int index, kStrategy strat)
int kFindDivisibleByInT(const kStrategy strat, const LObject *L, const int start)
return -1 if no divisor is found number of first divisor in T, otherwise
static void enterOnePairLift(int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR=-1)
long pLDeg1c_Totaldegree(poly p, int *l, const ring r)
#define pLtCmpOrdSgnDiffP(p, q)
poly p_Cleardenom(poly p, const ring r)
int posInL11Ring(const LSet set, const int length, LObject *p, const kStrategy)
BOOLEAN(* rewCrit1)(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
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)
void clearSbatch(poly h, int k, int pos, kStrategy strat)
static BOOLEAN sugarDivisibleBy(int ecart1, int ecart2)
static int p_LmCmp(poly p, poly q, const ring r)
static void enterOnePairSig(int i, poly p, poly pSig, int, int ecart, int isFromQ, kStrategy strat, int atR=-1)
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 enterOnePairSelfShifts(poly qq, poly p, int ecart, int isFromQ, kStrategy strat, int, int uptodeg, int lV)
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)
#define pLtCmpOrdSgnDiffM(p, q)
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.
static int p_LtCmpNoAbs(poly p, poly q, const ring r)
poly kNF(ideal F, ideal Q, poly p, int syzComp, int lazyReduce)
KINLINE poly ksOldSpolyRed(poly p1, poly p2, poly spNoether)
#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)
static void enterOnePairManyShifts(int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR, int uptodeg, int lV)
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)
static void enterOnePairSigRing(int i, poly p, poly pSig, int, int ecart, int isFromQ, kStrategy strat, int atR=-1)
static FORCE_INLINE int n_DivComp(number a, number b, const coeffs r)
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)
static FORCE_INLINE number n_Lcm(number a, number b, const coeffs r)
in Z: return the lcm of 'a' and 'b' in Z/nZ, Z/2^kZ: computed as in the case Z in Z/pZ,...
poly nc_CreateShortSpoly(poly p1, poly p2, const ring r)
long p_Deg(poly a, const ring r)
int posInL11(const LSet set, const int length, LObject *p, const kStrategy)
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)
static poly redBba1(poly h, int maxIndex, kStrategy strat)
long maxdegreeWecart(poly p, int *l, ring r)
int posInT15Ring(const TSet set, const int length, LObject &p)
static poly normalize(poly next_p, ideal add_generators, syStrategy syzstr, int *g_l, int *p_l, int crit_comp)
void StringSetS(const char *st)
void chainCritNormal(poly p, int ecart, kStrategy strat)
static int si_max(const int a, const int b)
static CanonicalForm bound(const CFMatrix &M)
#define pSetmComp(p)
TODO:
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)
#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
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)
char name(const Variable &v)
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,...
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:...
void enterpairsSpecial(poly h, int k, int ecart, int pos, kStrategy strat, int atR=-1)
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)
static FORCE_INLINE long n_Int(number &n, const coeffs r)
conversion of n to an int; 0 if not possible in Z/pZ: the representing int lying in (-p/2 ....
long p_WTotaldegree(poly p, const ring r)
#define omRealloc0Size(addr, o_size, size)
BOOLEAN(* rewCrit3)(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
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 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)
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...
static BOOLEAN enterOneStrongPolySig(int i, poly p, poly sig, int, int, kStrategy strat, int atR)
int posInT17Ring(const TSet set, const int length, LObject &p)
void enterL(LSet *set, int *length, int *LSetmax, LObject p, int at)
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)
static BOOLEAN p_HasNotCF_Lift(poly p1, poly p2, const ring r)
p_HasNotCF for the IDLIFT case: ignore component
long kHomModDeg(poly p, ring r)
void initEcartBBA(TObject *h)
#define pCopy(p)
return a copy of the poly
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
void initEcartPairMora(LObject *Lp, poly, poly, int ecartF, int ecartG)
KINLINE void k_GetStrongLeadTerms(const poly p1, const poly p2, const ring leadRing, poly &m1, poly &m2, poly &lcm, const ring tailRing)
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
void enterOnePairNormal(int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR=-1)
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)
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)
static int index(p_Length length, p_Ord ord)
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.
void missingAxis(int *last, kStrategy strat)
void enterT(LObject &p, kStrategy strat, int atT)
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)))
int posInT11(const TSet set, const int length, LObject &p)
void enterOnePairSpecial(int i, poly p, int ecart, kStrategy strat, int atR=-1)
void nKillChar(coeffs r)
undo all initialisations
void(* enterOnePair)(int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR)
#define idPosConstant(I)
index of generator with leading term in ground ring (if any); otherwise -1
int redHomog(LObject *h, kStrategy strat)
poly pMoveCurrTail2poly(poly p, kStrategy strat)
void updateLHC(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)
const struct soptionStruct verboseStruct[]
BOOLEAN p_CheckIsFromRing(poly p, ring r)