 |
My Project
debian-1:4.1.2-p1+ds-2
|
Go to the documentation of this file.
21 #define EXT_POLY_NEW 0
51 #define ENTER_USE_MEMMOVE
91 #ifdef ENTER_USE_MYMEMMOVE
92 inline void _my_memmove_d_gt_s(
unsigned long* d,
unsigned long*
s,
long l)
94 REGISTER unsigned long* _dl = (
unsigned long*) d;
95 REGISTER unsigned long* _sl = (
unsigned long*)
s;
106 inline void _my_memmove_d_lt_s(
unsigned long* d,
unsigned long*
s,
long l)
109 REGISTER unsigned long* _dl = (
unsigned long*) d;
110 REGISTER unsigned long* _sl = (
unsigned long*)
s;
121 inline void _my_memmove(
void* d,
void*
s,
long l)
123 unsigned long _d = (
unsigned long) d;
124 unsigned long _s = (
unsigned long)
s;
125 unsigned long _l = ((
l) + SIZEOF_LONG - 1) >> LOG_SIZEOF_LONG;
127 if (_d > _s) _my_memmove_d_gt_s(_d, _s, _l);
128 else _my_memmove_d_lt_s(_d, _s, _l);
132 #define memmove(d,s,l) _my_memmove(d, s, l)
139 #define pDivComp_EQUAL 2
140 #define pDivComp_LESS 1
141 #define pDivComp_GREATER -1
142 #define pDivComp_INCOMP 0
155 unsigned long la, lb;
156 unsigned long divmask =
currRing->divmask;
166 if (((la & divmask) ^ (lb & divmask)) != ((lb - la) & divmask))
173 if (((la & divmask) ^ (lb & divmask)) != ((la - lb) & divmask))
187 static inline int pDivComp(poly
p, poly q)
204 unsigned long la, lb;
205 unsigned long divmask =
currRing->divmask;
215 if (((la & divmask) ^ (lb & divmask)) != ((lb - la) & divmask))
222 if (((la & divmask) ^ (lb & divmask)) != ((la - lb) & divmask))
229 if (
b) {
return -1; }
250 poly
p = L->GetLmTailRing();
253 if (L->bucket !=
NULL)
291 L->ecart = L->pLDeg() - L->GetpFDeg();
300 L->ecart = L->pLDeg(strat->
LDegLast) - L->GetpFDeg();
340 ring r = L->tailRing;
341 poly
p = L->GetLmTailRing();
420 number eins=
nInit(1);
508 inline static unsigned long*
initsevS (
const int maxnr)
510 return (
unsigned long*)
omAlloc0(maxnr*
sizeof(
unsigned long));
512 inline static int*
initS_2_R (
const int maxnr)
514 return (
int*)
omAlloc0(maxnr*
sizeof(
int));
518 int &
length,
const int incr)
530 (
length+incr)*
sizeof(
long*));
548 for (
j=0;
j<=strat->
tl;
j++)
552 if (strat->
T[
j].max_exp !=
NULL)
562 if (strat->
T[
j].t_p !=
NULL)
570 if (
currRing->isLPring && strat->
T[
j].shift > 0)
579 if (
p == strat->
S[
i])
581 if (strat->
T[
j].t_p !=
NULL)
583 if (p_shallow_copy_delete!=
NULL)
607 for (
j=0;
j<=strat->
tl;
j++)
611 if (strat->
T[
j].max_exp !=
NULL)
621 if (strat->
T[
j].t_p !=
NULL)
633 if (
p == strat->
S[
i])
635 if (strat->
T[
j].t_p !=
NULL)
682 if ((*
k) < 0)
return FALSE;
683 if (((p1 == (*p).p1) && (p2 == (*p).p2))
684 || ((p1 == (*p).p2) && (p2 == (*p).p1)))
703 if ((*
k) < 0)
return FALSE;
715 for (
i=0;
i<=tlength;
i++)
717 if (
T[
i].
p ==
p)
return i;
728 if (
i >= 0)
return i;
731 while (strat !=
NULL);
744 #define kFalseReturn(x) do { if (!x) return FALSE;} while (0)
747 static const char* kTest_LmEqual(poly
p, poly t_p, ring tailRing)
750 for (
i=1;
i<=tailRing->N;
i++)
753 return "Lm[i] different";
756 return "Lm[0] different";
758 return "Lm.next different";
760 return "Lm.coeff different";
767 ring tailRing =
T->tailRing;
768 if (strat_tailRing ==
NULL) strat_tailRing = tailRing;
769 r_assume(strat_tailRing == tailRing);
791 if (
T->t_p ==
NULL &&
i > 0)
797 const char* msg = kTest_LmEqual(
T->p,
T->t_p,
T->tailRing);
808 if (
T->t_p !=
NULL &&
i >= 0 && TN ==
'T')
812 if (
T->max_exp !=
NULL)
813 return dReportError(
"%c[%d].max_exp is not NULL as it should be", TN,
i);
817 if (
T->max_exp ==
NULL)
829 p_Setm(test_max, tailRing);
841 if (
T->p ==
NULL &&
i > 0)
857 if ((
i >= 0) && (
T->pLength != 0)
862 return dReportError(
"%c[%d] pLength error: has %d, specified to have %d",
867 if (
i >= 0 && (TN ==
'T' || TN ==
'L'))
870 if (
T->FDeg !=
T->pFDeg())
874 return dReportError(
"%c[%d] FDeg error: has %d, specified to have %d",
875 TN,
i ,
T->pFDeg(), d);
880 if (
i >= 0 && TN ==
'T')
916 if (L->bucket !=
NULL)
918 kFalseReturn(
kbTest(L->bucket));
919 r_assume(L->bucket->bucket_ring == L->tailRing);
926 if (testp!=2) kFalseReturn(
kTest_T(L, strat_tailRing, lpos,
'L'));
935 return dReportError(
"L[%d] wrong sev: has %o, specified to have %o",
944 else if (tlength > 0 &&
T !=
NULL && (lpos >=0) && (testp!=2))
966 -1, strat->
T, strat->
tl));
969 if (strat->
T !=
NULL)
971 for (
i=0;
i<=strat->
tl;
i++)
980 if (strat->
L !=
NULL)
985 for (
i=0;
i<=strat->
Ll;
i++)
989 strat->
T, strat->
tl));
994 for (
i=0;
i<=strat->
Ll;
i++)
997 strat->
L[
i].Next() != strat->
tail,
i,
998 strat->
T, strat->
tl));
1009 if (strat->
S !=
NULL)
1019 for (
i=0;
i<=strat->
sl;
i++)
1021 if (strat->
S[
i] !=
NULL &&
1024 return dReportError(
"S[%d] wrong sev: has %o, specified to have %o",
1037 kFalseReturn(
kTest(strat));
1040 for (
i=0;
i<=strat->
tl;
i++)
1042 if (strat->
T[
i].i_r < 0 || strat->
T[
i].i_r > strat->
tl)
1043 return dReportError(
"strat->T[%d].i_r == %d out of bounds",
i,
1045 if (strat->
R[strat->
T[
i].i_r] != &(strat->
T[
i]))
1049 if (strat->
S !=
NULL)
1051 for (
i=0;
i<=strat->
sl;
i++)
1056 if (strat->
S_2_R[
i] != strat->
T[
j].i_r)
1062 #ifdef HAVE_SHIFTBBA
1065 for (
i=0;
i<=strat->
Ll;
i++)
1067 if (strat->
L[
i].p1 !=
NULL && strat->
L[
i].p2)
1069 if (strat->
L[
i].i_r1 < 0 ||
1070 strat->
L[
i].i_r1 > strat->
tl ||
1071 strat->
L[
i].T_1(strat)->p != strat->
L[
i].p1)
1073 if (strat->
L[
i].i_r2 < 0 ||
1074 strat->
L[
i].i_r2 > strat->
tl ||
1075 strat->
L[
i].T_2(strat)->p != strat->
L[
i].p2)
1080 if (strat->
L[
i].i_r1 != -1)
1082 if (strat->
L[
i].i_r2 != -1)
1085 if (strat->
L[
i].i_r != -1)
1098 #ifdef ENTER_USE_MEMMOVE
1099 memmove(&(strat->
S[
i]), &(strat->
S[
i+1]), (strat->
sl -
i)*
sizeof(poly));
1101 memmove(&(strat->
sevS[
i]),&(strat->
sevS[
i+1]),(strat->
sl -
i)*
sizeof(
unsigned long));
1102 memmove(&(strat->
S_2_R[
i]),&(strat->
S_2_R[
i+1]),(strat->
sl -
i)*
sizeof(
int));
1105 for (
j=
i;
j<strat->
sl;
j++)
1107 strat->
S[
j] = strat->
S[
j+1];
1115 #ifdef ENTER_USE_MEMMOVE
1116 memmove(&(strat->
lenS[
i]),&(strat->
lenS[
i+1]),(strat->
sl -
i)*
sizeof(
int));
1123 #ifdef ENTER_USE_MEMMOVE
1131 #ifdef ENTER_USE_MEMMOVE
1132 memmove(&(strat->
fromQ[
i]),&(strat->
fromQ[
i+1]),(strat->
sl -
i)*
sizeof(
int));
1134 for (
j=
i;
j<strat->
sl;
j++)
1150 #ifdef ENTER_USE_MEMMOVE
1151 memmove(&(strat->
S[
i]), &(strat->
S[
i+1]), (strat->
sl -
i)*
sizeof(poly));
1152 memmove(&(strat->
sig[
i]), &(strat->
sig[
i+1]), (strat->
sl -
i)*
sizeof(poly));
1154 memmove(&(strat->
sevS[
i]),&(strat->
sevS[
i+1]),(strat->
sl -
i)*
sizeof(
unsigned long));
1155 memmove(&(strat->
sevSig[
i]),&(strat->
sevSig[
i+1]),(strat->
sl -
i)*
sizeof(
unsigned long));
1156 memmove(&(strat->
S_2_R[
i]),&(strat->
S_2_R[
i+1]),(strat->
sl -
i)*
sizeof(
int));
1159 for (
j=
i;
j<strat->
sl;
j++)
1161 strat->
S[
j] = strat->
S[
j+1];
1171 #ifdef ENTER_USE_MEMMOVE
1172 memmove(&(strat->
lenS[
i]),&(strat->
lenS[
i+1]),(strat->
sl -
i)*
sizeof(
int));
1179 #ifdef ENTER_USE_MEMMOVE
1187 #ifdef ENTER_USE_MEMMOVE
1188 memmove(&(strat->
fromQ[
i]),&(strat->
fromQ[
i+1]),(strat->
sl -
i)*
sizeof(
int));
1190 for (
j=
i;
j<strat->
sl;
j++)
1209 if (set[
j].sig!=
NULL)
1243 #ifdef ENTER_USE_MEMMOVE
1247 for (
i=
j;
i < (*length);
i++)
1270 memmove(&((*set)[at+1]), &((*set)[at]), ((*
length)-at+1)*
sizeof(
LObject));
1272 for (
i=(*
length)+1;
i>=at+1;
i--) (*set)[
i] = (*set)[
i-1];
1286 h->FDeg =
h->pFDeg();
1287 h->ecart =
h->pLDeg() -
h->FDeg;
1294 h->FDeg =
h->pFDeg();
1301 Lp->FDeg = Lp->pFDeg();
1308 Lp->FDeg = Lp->pFDeg();
1309 (*Lp).ecart =
si_max(ecartF,ecartG);
1310 (*Lp).ecart = (*Lp).ecart- (Lp->FDeg -
p_FDeg((*Lp).lcm,
currRing));
1319 return (ecart1 <= ecart2);
1351 int j,compare,compareCoeff;
1355 h.ecart=0;
h.length=0;
1379 for(
j = strat->
Bl;
j>=0;
j--)
1500 h.i_r1 = -1;
h.i_r2 = -1;
1516 posx = strat->
posInL(strat->
B,strat->
Bl,&
h,strat);
1533 poly m1, m2,
gcd,si;
1561 for (
int j = 0;
j < strat->
sl;
j++) {
1566 !(strat->
sevS[
j] & ~sev) &&
1608 PrintS(
"\n--- create strong gcd poly: ");
1611 Print(
"\n strat->S[%d]: ",
i);
1635 h.i_r1 = -1;
h.i_r2 = -1;
1641 h.p1 =
p;
h.p2 = strat->
S[
i];
1656 posx = strat->
posInL(strat->
L,strat->
Ll,&
h,strat);
1661 if(
h.IsNull())
return FALSE;
1678 if(strat->
sl < 0)
return FALSE;
1680 for(
i=0;
i<strat->
sl;
i++)
1716 h->i_r1 = -1;
h->i_r2 = -1;
1738 poly m1, m2,
gcd,si;
1786 PrintS(
"\n--- create strong gcd poly: ");
1789 Print(
"\n strat->S[%d]: ",
i);
1813 if(
pLmCmp(pSigMult,sSigMult) == 0)
1822 if(
pLtCmp(pSigMult,sSigMult)==1)
1842 h.i_r1 = -1;
h.i_r2 = -1;
1850 int red_result =
redRing(&
h,strat);
1860 strat->
enterS(strat->
P,strat->
sl+1,strat, strat->
tl+1);
1877 int red_result =
redRing(&
h,strat);
1887 strat->
enterS(strat->
P,strat->
sl+1,strat, strat->
tl+1);
1900 strat->
enterS(strat->
P,strat->
sl+1,strat, strat->
tl+1);
1904 h.p1 =
p;
h.p2 = strat->
S[
i];
1938 Lp.ecart=0; Lp.length=0;
1943 #ifndef HAVE_RATGRING
1945 #elif defined(HAVE_RATGRING)
1956 if((!((strat->
ecartS[
i]>0)&&(ecart>0)))
2056 for(
j = strat->
Bl;
j>=0;
j--)
2155 Lp.p1 = strat->
S[
i];
2169 Lp.i_r1 = strat->
S_2_R[
i];
2183 && (Lp.p->coef!=
NULL))
2187 l = strat->
posInL(strat->
B,strat->
Bl,&Lp,strat);
2225 Lp.ecart=0; Lp.length=0;
2232 if((!((strat->
ecartS[
i]>0)&&(ecart>0)))
2328 for(
j = strat->
Bl;
j>=0;
j--)
2384 Lp.p1 = strat->
S[
i];
2391 Lp.i_r1 = strat->
S_2_R[
i];
2405 && (Lp.p->coef!=
NULL))
2409 l = strat->
posInL(strat->
B,strat->
Bl,&Lp,strat);
2433 unsigned long pSigMultNegSev,sSigMultNegSev;
2437 Lp.ecart=0; Lp.length=0;
2442 #ifndef HAVE_RATGRING
2444 #elif defined(HAVE_RATGRING)
2474 PrintS(
"----------------\n");
2477 PrintS(
"----------------\n");
2483 Print(
"IN PAIR GENERATION - COMPARING SIGS: %d\n",sigCmp);
2504 if ( strat->
syzCrit(pSigMult,pSigMultNegSev,strat) ||
2505 strat->
syzCrit(sSigMult,sSigMultNegSev,strat)
2506 || strat->
rewCrit1(sSigMult,sSigMultNegSev,Lp.lcm,strat,
i+1)
2583 Lp.sevSig = ~pSigMultNegSev;
2590 Lp.sevSig = ~sSigMultNegSev;
2601 if (strat->
rewCrit3(Lp.sig,~Lp.sevSig,Lp.p,strat,strat->
sl+1))
2615 Lp.checked = strat->
sl+1;
2622 Lp.prod_crit =
TRUE;
2634 PrintS(
"SIGNATURE OF PAIR: ");
2638 Lp.p1 = strat->
S[
i];
2652 Lp.i_r1 = strat->
S_2_R[
i];
2666 && (Lp.p->coef!=
NULL))
2708 unsigned long pSigMultNegSev,sSigMultNegSev;
2712 Lp.ecart=0; Lp.length=0;
2717 #ifndef HAVE_RATGRING
2719 #elif defined(HAVE_RATGRING)
2755 if(pSigMult !=
NULL)
2758 if(sSigMult !=
NULL)
2762 Print(
"----------------\n");
2765 Print(
"----------------\n");
2769 if(pSigMult !=
NULL && sSigMult !=
NULL)
2778 if(pSigMult ==
NULL)
2780 if(sSigMult ==
NULL)
2790 Print(
"IN PAIR GENERATION - COMPARING SIGS: %d\n",sigCmp);
2812 int red_result =
redRing(&Lp,strat);
2822 strat->
enterS(strat->
P,strat->
sl+1,strat, strat->
tl+1);
2824 strat->
enterS(Lp,0,strat,strat->
tl);
2838 Lp.sig =
pCopy(pSigMult);
2867 if ( strat->
syzCrit(pSigMult,pSigMultNegSev,strat) ||
2868 strat->
syzCrit(sSigMult,sSigMultNegSev,strat)
2950 Lp.sig =
pNeg(Lp.sig);
2961 Lp.sevSig = ~pSigMultNegSev;
2968 Lp.sevSig = ~sSigMultNegSev;
2980 if (strat->
rewCrit3(Lp.sig,~Lp.sevSig,Lp.p,strat,strat->
sl+1))
2994 Lp.checked = strat->
sl+1;
3001 Lp.prod_crit =
TRUE;
3013 PrintS(
"SIGNATURE OF PAIR: ");
3017 Lp.p1 = strat->
S[
i];
3032 Lp.i_r1 = strat->
S_2_R[
i];
3046 && (Lp.p->coef!=
NULL))
3054 int red_result =
redRing(&Lp,strat);
3064 strat->
enterS(strat->
P,strat->
sl+1,strat, strat->
tl+1);
3067 strat->
enterS(Lp,0,strat, strat->
tl+1);
3119 Lp.p1 = strat->
S[
i];
3123 Lp.i_r1 = strat->
S_2_R[
i];
3138 && (Lp.p->coef!=
NULL))
3141 l = strat->
posInL(strat->
L,strat->
Ll,&Lp,strat);
3152 int j=strat->
Ll+strat->
Bl+1;
3160 for (
i=strat->
Bl;
i>=0;
i--)
3162 j = strat->
posInL(strat->
L,
j,&(strat->
B[
i]),strat);
3173 int j=strat->
Ll+strat->
Bl+1;
3181 for (
i=strat->
Bl;
i>=0;
i--)
3204 for (
j=0;
j<=strat->
sl;
j++)
3208 for (
i=strat->
Bl;
i>=0;
i--)
3230 for (
j=strat->
Ll;
j>=0;
j--)
3236 if (strat->
L[
j].p == strat->
tail)
3282 for (
j=strat->
Ll;
j>=0;
j--)
3302 for(
i=
j-1;
i>=0;
i--)
3321 for (
j=strat->
Ll;
j>=0;
j--)
3352 if (strat->
L[0].p2 == strat->
tail) strat->
L[0].p2 =
p;
3355 if (strat->
L[
j].p2 ==
p)
3361 if ((strat->
L[
i].p2 ==
p) &&
pLmEqual(strat->
L[
j].lcm,strat->
L[
i].lcm))
3375 strat->
L[
i].p2 = strat->
tail;
3392 else if (strat->
L[
j].p2 == strat->
tail)
3431 if (strat->
L[0].p2 == strat->
tail) strat->
L[0].p2 =
p;
3434 if (strat->
L[
j].p2 ==
p)
3440 if ((strat->
L[
i].p2 ==
p) &&
pLmEqual(strat->
L[
j].lcm,strat->
L[
i].lcm))
3454 strat->
L[
i].p2 = strat->
tail;
3471 else if (strat->
L[
j].p2 == strat->
tail)
3479 #ifdef HAVE_RATGRING
3492 for (
j=0;
j<=strat->
sl;
j++)
3496 for (
i=strat->
Bl;
i>=0;
i--)
3504 Print(
"chain-crit-part: S[%d]=",
j);
3506 Print(
" divide B[%d].lcm=",
i);
3528 for (
j=strat->
Ll;
j>=0;
j--)
3534 if (strat->
L[
j].p == strat->
tail)
3538 PrintS(
"chain-crit-part: pCompareChainPart p=");
3540 Print(
" delete L[%d]",
j);
3569 Print(
"chain-crit-part: sugar B[%d].lcm=",
j);
3571 Print(
" delete B[%d]",
i);
3582 Print(
"chain-crit-part: sugar B[%d].lcm=",
i);
3584 Print(
" delete B[%d]",
j);
3604 for (
j=strat->
Ll;
j>=0;
j--)
3612 PrintS(
"chain-crit-part: sugar:pCompareChainPart p=");
3614 Print(
" delete L[%d]",
j);
3632 for(
i=
j-1;
i>=0;
i--)
3638 Print(
"chain-crit-part: equal lcm B[%d].lcm=",
j);
3640 Print(
" delete B[%d]\n",
i);
3657 for (
j=strat->
Ll;
j>=0;
j--)
3665 PrintS(
"chain-crit-part: pCompareChainPart p=");
3667 Print(
" delete L[%d]",
j);
3696 if (strat->
L[0].p2 == strat->
tail) strat->
L[0].p2 =
p;
3699 if (strat->
L[
j].p2 ==
p)
3705 if ((strat->
L[
i].p2 ==
p) &&
pLmEqual(strat->
L[
j].lcm,strat->
L[
i].lcm))
3722 strat->
L[
i].p2 = strat->
tail;
3729 PrintS(
"chain-crit-part: divisible_by p=");
3731 Print(
" delete L[%d]",
l);
3742 PrintS(
"chain-crit-part: divisible_by(2) p=");
3744 Print(
" delete L[%d]",
i);
3755 else if (strat->
L[
j].p2 == strat->
tail)
3783 for (
j=0;
j<=
k;
j++)
3796 for (
j=0;
j<=
k;
j++)
3805 for (
j=0;
j<=
k;
j++)
3818 #ifdef HAVE_RATGRING
3848 for (
j=0;
j<=
k;
j++)
3861 for (
j=0;
j<=
k;
j++)
3870 for (
j=0;
j<=
k;
j++)
3884 #ifdef HAVE_RATGRING
3941 #ifdef HAVE_RATGRING
3968 for (
j=0;
j<=strat->
sl;
j++)
3972 for (
i=strat->
Bl;
i>=0;
i--)
3979 PrintS(
"--- chain criterion func chainCritRing type 1\n");
3982 PrintS(
" strat->B[i].lcm:");
3987 wrp(strat->
B[
i].lcm);
4002 for (
j=strat->
Ll;
j>=0;
j--)
4015 PrintS(
"--- chain criterion func chainCritRing type 2\n");
4016 PrintS(
"strat->L[j].p:");
4047 if (strat->
L[0].p2 == strat->
tail) strat->
L[0].p2 =
p;
4050 if (strat->
L[
j].p2 ==
p)
4065 PrintS(
"--- chain criterion func chainCritRing type 3\n");
4066 PrintS(
"strat->L[j].lcm:");
4067 wrp(strat->
L[
j].lcm);
4068 PrintS(
" strat->L[i].lcm:");
4069 wrp(strat->
L[
i].lcm);
4083 strat->
L[
i].p2 = strat->
tail;
4100 else if (strat->
L[
j].p2 == strat->
tail)
4114 if (arg <= 0)
return 0;
4126 if (arg <= 0)
return 0;
4127 if (arg%2 == 1) { arg--; }
4137 #ifdef HAVE_VANIDEAL
4148 int l,
j,compare,compareCoeff;
4152 Lp.ecart=0; Lp.length=0;
4165 for(
j = strat->
Bl;
j>=0;
j--)
4169 if (compareCoeff == 0 || compare == compareCoeff)
4187 if (compareCoeff == 1)
4194 if (compareCoeff == -1)
4237 tmp_h.SetShortExpVector();
4242 enterT(tmp_h, strat, strat->
tl + 1);
4247 Lp.i_r1 = strat->
tl;
4251 l = strat->
posInL(strat->
B,strat->
Bl,&Lp,strat);
4265 if ((*cabsind <
bound) && (*cabsind - step[1] +
add <
bound))
4274 if (
N == 1)
return 0;
4276 while (
exp[
i] == cexp[
i] &&
i <=
N)
i++;
4278 *cabsind -= cind[
i];
4281 *cabsind += cind[
i];
4284 if (
i >
N)
return 0;
4288 for (
int j =
i + 1;
j <=
N;
j++)
4290 if (step[1] > step[
j]) step[1] = step[
j];
4293 if (*cabsind - step[1] +
add >=
bound)
4296 *cabsind -= cind[
i];
4298 *cabsind += cind[
i];
4301 if (
i >
N)
return 0;
4304 }
while (step[1] != -1);
4310 for (
i = 2;
i <=
N;
i++)
4312 if (step[1] > step[
i]) step[1] = step[
i];
4327 poly
kCreateZeroPoly(
long exp[],
long cabsind, poly* t_p, ring leadRing, ring tailRing)
4330 poly zeroPoly =
NULL;
4338 for (
int i = 1;
i <= leadRing->N;
i++)
4344 if (cabsind < leadRing->ch)
4346 zeroPoly =
p_ISet(
twoPow(leadRing->ch - cabsind), tailRing);
4350 zeroPoly =
p_ISet(1, tailRing);
4352 for (
int i = 1;
i <= leadRing->N;
i++)
4354 for (
long j = 1;
j <=
exp[
i];
j++)
4372 for (
int i = 1;
i <= leadRing->N;
i++)
4378 zeroPoly =
pNext(zeroPoly);
4404 if (
exp[
i] & 1 != 0)
4419 PrintS(
"-------------\npoly :");
4422 Print(
"cexp : (%d, %d)\n", cexp[1], cexp[2]);
4423 Print(
"cind : (%d, %d)\n", cind[1], cind[2]);
4425 Print(
"cind : %d\n", cabsind);
4442 Print(
"%d, (%d, %d), ind = (%d, %d)\n", cabsind, cexp[1], cexp[2], cind[1], cind[2]);
4478 PrintS(
"-------------\npoly :");
4481 Print(
"cexp : (%d, %d)\n", cexp[1], cexp[2]);
4482 Print(
"cind : (%d, %d)\n", cind[1], cind[2]);
4484 Print(
"cind : %d\n", cabsind);
4502 Print(
"%d, (%d, %d), ind = (%d, %d)\n", cabsind, cexp[1], cexp[2], cind[1], cind[2]);
4510 G0->m[
IDELEMS(G0) - 1] = zeroPoly;
4534 for (
j=0;
j<=
k;
j++)
4546 for (
j=0;
j<=
k;
j++)
4554 for (
j=0;
j<=
k;
j++)
4566 #ifdef HAVE_RATGRING
4591 && ((iCompH<=strat->syzComp)||(strat->
syzComp==0)))
4638 PrintS(
"--- create zero spoly: ");
4667 posx = strat->
posInL(strat->
L,strat->
Ll,&Lp,strat);
4720 PrintS(
"--- create zero spoly: ");
4748 int red_result =
redRing(&Lp,strat);
4758 strat->
enterS(strat->
P,strat->
sl+1,strat, strat->
tl+1);
4760 strat->
enterS(Lp,0,strat,strat->
tl);
4808 if ( (!strat->
fromT)
4865 if ( (!strat->
fromT)
4890 if ( (!strat->
fromT)
4915 for (
j=0;
j<=
k;
j++)
4918 if ((iCompH==iCompSj)
4929 for (
j=0;
j<=
k;
j++)
4932 if ((iCompH==iCompSj)
4984 int i,
j,at,ecart, s2r;
4988 int new_suc=strat->
sl+1;
4992 for (;
i<=strat->
sl;
i++)
4997 if (new_suc > at) new_suc = at;
5000 sev = strat->
sevS[
i];
5003 for (
j=
i;
j>=at+1;
j--)
5005 strat->
S[
j] = strat->
S[
j-1];
5011 strat->
ecartS[at] = ecart;
5012 strat->
sevS[at] = sev;
5013 strat->
S_2_R[at] = s2r;
5016 for (
j=
i;
j>=at+1;
j--)
5020 strat->
fromQ[at]=fq;
5024 if (new_suc <= strat->sl) *suc=new_suc;
5087 if (cmp == cmp_int)
return an;
5088 if (cmp == -cmp_int)
return en;
5094 if (cmp == cmp_int) en =
i;
5095 else if (cmp == -cmp_int) an =
i;
5111 if (
pLmCmp(set[an],
p) == cmp_int)
return an;
5112 if (
pLmCmp(set[an],
p) == -cmp_int)
return en;
5114 && ((strat->
ecartS[an])>ecart_p))
5120 else if (
pLmCmp(set[
i],
p) == -cmp_int) an=
i;
5124 &&((strat->
ecartS[
i])<ecart_p))
5152 || ((op == o) && (
pLtCmp(set[mon],
p) == -1)))
5163 || ((op == o) && (
pLtCmp(set[an],
p) == -1)))
5170 || ((op == o) && (
pLtCmp(set[
i],
p) == -1)))
5196 || ((op == o) && (
pLtCmp(set[an],
p) == -1)))
5203 || ((op == o) && (
pLtCmp(set[
i],
p) == -1)))
5215 if(end < 0 || end >=
IDELEMS(F))
5217 if (end<0)
return 0;
5224 for(
i=start;
i<end;
i++)
5238 || ((op == o) && (
pLtCmp(set[an],
p) == -1)))
5245 || ((op == o) && (
pLtCmp(set[
i],
p) == -1)))
5270 if (
length==-1)
return 0;
5312 if (set[an].
length>
p.length)
return an;
5328 if (
length==-1)
return 0;
5330 int o =
p.GetpFDeg();
5331 int op = set[
length].GetpFDeg();
5345 op= set[an].GetpFDeg();
5352 op = set[
i].GetpFDeg();
5364 if (
length==-1)
return 0;
5366 int o =
p.GetpFDeg();
5367 int op = set[
length].GetpFDeg();
5381 op= set[an].GetpFDeg();
5388 op = set[
i].GetpFDeg();
5405 if (
length==-1)
return 0;
5406 int o =
p.GetpFDeg();
5407 int op = set[
length].GetpFDeg();
5419 op = set[an].GetpFDeg();
5420 if (op > o)
return an;
5421 if (op < 0)
return en;
5423 if (cmp == cmp_int)
return an;
5424 if (cmp == -cmp_int)
return en;
5429 op = set[
i].GetpFDeg();
5431 else if (op < o) an =
i;
5435 if (cmp == cmp_int) en =
i;
5436 else if (cmp == -cmp_int) an =
i;
5482 if (
length==-1)
return 0;
5484 int o =
p.GetpFDeg();
5485 int op = set[
length].GetpFDeg();
5489 || (( op == o) && (set[
length].length ==
p.length)
5500 op = set[an].GetpFDeg();
5502 || (( op == o) && (set[an].
length >
p.length))
5503 || (( op == o) && (set[an].length ==
p.length)
5509 op = set[
i].GetpFDeg();
5511 || (( op == o) && (set[
i].
length >
p.length))
5512 || (( op == o) && (set[
i].length ==
p.length)
5524 if (
length==-1)
return 0;
5526 int o =
p.GetpFDeg();
5527 int op = set[
length].GetpFDeg();
5531 || (( op == o) && (set[
length].length ==
p.length)
5542 op = set[an].GetpFDeg();
5544 || (( op == o) && (set[an].
length >
p.length))
5545 || (( op == o) && (set[an].length ==
p.length)
5551 op = set[
i].GetpFDeg();
5553 || (( op == o) && (set[
i].
length >
p.length))
5554 || (( op == o) && (set[
i].length ==
p.length)
5570 if (
length==-1)
return 0;
5572 int o =
p.GetpFDeg();
5574 if (set[
length].GetpFDeg() <= o)
5584 if (set[an].GetpFDeg() > o)
5589 if (set[
i].GetpFDeg() > o)
5599 int ol =
p.GetpLength();
5600 if (
length==-1)
return 0;
5604 int oo=set[
length].ecart;
5605 if ((oo < op) || ((oo==op) && (set[
length].
length <= ol)))
5615 int oo=set[an].ecart;
5617 || ((oo==op) && (set[an].
pLength > ol)))
5622 int oo=set[
i].ecart;
5624 || ((oo == op) && (set[
i].
pLength > ol)))
5656 if (
length==-1)
return 0;
5658 int o =
p.GetpFDeg() +
p.ecart;
5673 op = set[an].GetpFDeg()+set[an].ecart;
5680 op = set[
i].GetpFDeg()+set[
i].ecart;
5692 if (
length==-1)
return 0;
5694 int o =
p.GetpFDeg() +
p.ecart;
5709 op = set[an].GetpFDeg()+set[an].ecart;
5716 op = set[
i].GetpFDeg()+set[
i].ecart;
5753 if (
length==-1)
return 0;
5755 int o =
p.GetpFDeg() +
p.ecart;
5759 || (( op == o) && (set[
length].ecart >
p.ecart))
5760 || (( op == o) && (set[
length].ecart==
p.ecart)
5771 op = set[an].GetpFDeg()+set[an].ecart;
5773 || (( op == o) && (set[an].ecart <
p.ecart))
5774 || (( op == o) && (set[an].ecart==
p.ecart)
5780 op = set[
i].GetpFDeg()+set[
i].ecart;
5782 || (( op == o) && (set[
i].ecart <
p.ecart))
5783 || (( op == o) && (set[
i].ecart ==
p.ecart)
5794 if (
length==-1)
return 0;
5796 int o =
p.GetpFDeg() +
p.ecart;
5800 || (( op == o) && (set[
length].ecart >
p.ecart))
5801 || (( op == o) && (set[
length].ecart==
p.ecart)
5812 op = set[an].GetpFDeg()+set[an].ecart;
5814 || (( op == o) && (set[an].ecart <
p.ecart))
5815 || (( op == o) && (set[an].ecart==
p.ecart)
5821 op = set[
i].GetpFDeg()+set[
i].ecart;
5823 || (( op == o) && (set[
i].ecart <
p.ecart))
5824 || (( op == o) && (set[
i].ecart ==
p.ecart)
5840 if (
length==-1)
return 0;
5844 int o =
p.GetpFDeg() +
p.ecart;
5853 || ((op == o) && (set[
length].ecart >
p.ecart))
5854 || ((op == o) && (set[
length].ecart==
p.ecart)
5870 int op = set[an].GetpFDeg()+set[an].ecart;
5872 || ((op == o) && (set[an].ecart <
p.ecart))
5873 || ((op == o) && (set[an].ecart==
p.ecart)
5884 int op = set[
i].GetpFDeg()+set[
i].ecart;
5886 || ((op == o) && (set[
i].ecart <
p.ecart))
5887 || ((op == o) && (set[
i].ecart ==
p.ecart)
5901 if (
length==-1)
return 0;
5905 int o =
p.GetpFDeg() +
p.ecart;
5914 || ((op == o) && (set[
length].ecart >
p.ecart))
5915 || ((op == o) && (set[
length].ecart==
p.ecart)
5931 int op = set[an].GetpFDeg()+set[an].ecart;
5933 || ((op == o) && (set[an].ecart <
p.ecart))
5934 || ((op == o) && (set[an].ecart==
p.ecart)
5945 int op = set[
i].GetpFDeg()+set[
i].ecart;
5947 || ((op == o) && (set[
i].ecart <
p.ecart))
5948 || ((op == o) && (set[
i].ecart ==
p.ecart)
5968 if (
length==-1)
return 0;
5971 int op=
p.GetpFDeg();
5973 if (set[
length].ecart < o)
5975 if (set[
length].ecart == o)
5977 int oo=set[
length].GetpFDeg();
5978 if ((oo < op) || ((oo==op) && (set[
length].
length <
p.length)))
5989 if (set[an].ecart > o)
5991 if (set[an].ecart == o)
5993 int oo=set[an].GetpFDeg();
5995 || ((oo==op) && (set[an].
length >
p.length)))
6001 if (set[
i].ecart > o)
6003 else if (set[
i].ecart == o)
6005 int oo=set[
i].GetpFDeg();
6007 || ((oo == op) && (set[
i].
length >
p.length)))
6027 int d=
p->GetpFDeg();
6028 int op=set[
length].GetpFDeg();
6042 op=set[an].GetpFDeg();
6044 || ((op == d) && (
p->p1!=
NULL) && (set[an].p1==
NULL))
6050 op=set[
i].GetpFDeg();
6052 || ((op==d) && (
p->p1!=
NULL) && (set[
i].p1==
NULL))
6165 cmp =
pLtCmp(set[an].sig,
p->sig);
6172 if (set[an].FDeg >
p->FDeg)
6174 if (set[an].FDeg < p->FDeg)
6176 if (set[an].FDeg ==
p->FDeg)
6194 if (set[
i].FDeg >
p->FDeg)
6196 if (set[
i].FDeg < p->FDeg)
6198 if (set[
i].FDeg ==
p->FDeg)
6213 if (
length < 0)
return 0;
6214 if (set[
length].FDeg >
p->FDeg)
6216 if (set[
length].FDeg ==
p->FDeg)
6217 if(set[
length].GetpLength() >
p->GetpLength())
6228 if (set[an].FDeg >
p->FDeg)
6230 if(set[an].FDeg ==
p->FDeg)
6232 if(set[an].GetpLength() >
p->GetpLength())
6236 if(set[an].GetpLength() ==
p->GetpLength())
6253 if (set[
i].FDeg >
p->FDeg)
6257 if(set[
i].FDeg ==
p->FDeg)
6259 if(set[
i].GetpLength() >
p->GetpLength())
6263 if(set[
i].GetpLength() ==
p->GetpLength())
6285 if (strat->
syzl==0)
return 0;
6290 int en= strat->
syzl-1;
6328 int o =
p->GetpFDeg();
6329 int op = set[
length].GetpFDeg();
6341 op = set[an].GetpFDeg();
6348 op = set[
i].GetpFDeg();
6370 int o =
p->GetpFDeg();
6371 int op = set[
length].GetpFDeg();
6383 op = set[an].GetpFDeg();
6390 op = set[
i].GetpFDeg();
6404 int o =
p->GetpFDeg();
6405 int op = set[
length].GetpFDeg();
6417 op = set[an].GetpFDeg();
6424 op = set[
i].GetpFDeg();
6438 if (
length < 0)
return 0;
6448 if (set[an].FDeg >
p->FDeg)
6450 if (set[an].FDeg < p->FDeg)
6452 if (set[an].FDeg ==
p->FDeg)
6460 if (set[an].t_p!=
NULL)
6482 if (set[
i].FDeg >
p->FDeg)
6484 if (set[
i].FDeg < p->FDeg)
6486 if (set[
i].FDeg ==
p->FDeg)
6494 if (set[
i].t_p!=
NULL)
6526 if (coeff == 0)
return -1;
6529 while (tmp % 2 == 0)
6548 if (
length < 0)
return 0;
6550 int o =
p->GetpFDeg();
6551 int op = set[
length].GetpFDeg();
6562 op = set[an].GetpFDeg();
6563 if ((op > o) || ((op == o) && (
pLmCmp(set[an].
p,
p->p) != -
currRing->OrdSgn)))
6568 op = set[
i].GetpFDeg();
6626 int o =
p->GetpFDeg();
6627 int op = set[
length].GetpFDeg();
6631 || ((op == o) && (set[
length].length <=
p->length)
6641 op = set[an].GetpFDeg();
6643 || ((op == o) && (set[an].
length >
p->length))
6644 || ((op == o) && (set[an].length <=
p->length)
6650 op = set[
i].GetpFDeg();
6652 || ((op == o) && (set[
i].
length >
p->length))
6653 || ((op == o) && (set[
i].length <=
p->length)
6667 int o =
p->GetpFDeg();
6668 int op = set[
length].GetpFDeg();
6672 || ((op == o) && (set[
length].length <=
p->length)
6682 op = set[an].GetpFDeg();
6684 || ((op == o) && (set[an].
length >
p->length))
6685 || ((op == o) && (set[an].length <=
p->length)
6691 op = set[
i].GetpFDeg();
6693 || ((op == o) && (set[
i].
length >
p->length))
6694 || ((op == o) && (set[
i].length <=
p->length)
6714 int o =
p->GetpFDeg();
6716 if (set[
length].GetpFDeg() > o)
6726 if (set[an].GetpFDeg() >= o)
6731 if (set[
i].GetpFDeg() >= o)
6749 int o =
p->GetpFDeg() +
p->ecart;
6762 op = set[an].GetpFDeg() + set[an].ecart;
6769 op = set[
i].GetpFDeg() + set[
i].ecart;
6784 int o =
p->GetpFDeg() +
p->ecart;
6797 op = set[an].GetpFDeg() + set[an].ecart;
6804 op = set[
i].GetpFDeg() + set[
i].ecart;
6825 int o =
p->GetpFDeg() +
p->ecart;
6829 && (set[
length].ecart >
p->ecart))
6831 && (set[
length].ecart ==
p->ecart)
6841 if ((set[an].GetpFDeg() + set[an].ecart > o)
6842 || ((set[an].GetpFDeg() + set[an].ecart == o)
6843 && (set[an].ecart >
p->ecart))
6844 || ((set[an].GetpFDeg() + set[an].ecart == o)
6845 && (set[an].ecart ==
p->ecart)
6851 if ((set[
i].GetpFDeg() + set[
i].ecart > o)
6852 || ((set[
i].GetpFDeg() + set[
i].ecart == o)
6853 && (set[
i].ecart >
p->ecart))
6854 || ((set[
i].GetpFDeg() +set[
i].ecart == o)
6855 && (set[
i].ecart ==
p->ecart)
6869 int o =
p->GetpFDeg() +
p->ecart;
6873 && (set[
length].ecart >
p->ecart))
6875 && (set[
length].ecart ==
p->ecart)
6885 if ((set[an].GetpFDeg() + set[an].ecart > o)
6886 || ((set[an].GetpFDeg() + set[an].ecart == o)
6887 && (set[an].ecart >
p->ecart))
6888 || ((set[an].GetpFDeg() + set[an].ecart == o)
6889 && (set[an].ecart ==
p->ecart)
6895 if ((set[
i].GetpFDeg() + set[
i].ecart > o)
6896 || ((set[
i].GetpFDeg() + set[
i].ecart == o)
6897 && (set[
i].ecart >
p->ecart))
6898 || ((set[
i].GetpFDeg() +set[
i].ecart == o)
6899 && (set[
i].ecart ==
p->ecart)
6922 int o =
p->GetpFDeg() +
p->ecart;
6930 && (set[
length].ecart >
p->ecart))
6932 && (set[
length].ecart ==
p->ecart)
6947 if ((set[an].GetpFDeg() + set[an].ecart > o)
6948 || ((set[an].GetpFDeg() + set[an].ecart == o)
6949 && (set[an].ecart >
p->ecart))
6950 || ((set[an].GetpFDeg() + set[an].ecart == o)
6951 && (set[an].ecart ==
p->ecart)
6962 if ((set[
i].GetpFDeg() + set[
i].ecart > o)
6963 || ((set[
i].GetpFDeg() + set[
i].ecart == o)
6964 && (set[
i].ecart >
p->ecart))
6965 || ((set[
i].GetpFDeg() +set[
i].ecart == o)
6966 && (set[
i].ecart ==
p->ecart)
6986 int o =
p->GetpFDeg() +
p->ecart;
6994 && (set[
length].ecart >
p->ecart))
6996 && (set[
length].ecart ==
p->ecart)
7011 if ((set[an].GetpFDeg() + set[an].ecart > o)
7012 || ((set[an].GetpFDeg() + set[an].ecart == o)
7013 && (set[an].ecart >
p->ecart))
7014 || ((set[an].GetpFDeg() + set[an].ecart == o)
7015 && (set[an].ecart ==
p->ecart)
7026 if ((set[
i].GetpFDeg() + set[
i].ecart > o)
7027 || ((set[
i].GetpFDeg() + set[
i].ecart == o)
7028 && (set[
i].ecart >
p->ecart))
7029 || ((set[
i].GetpFDeg() +set[
i].ecart == o)
7030 && (set[
i].ecart ==
p->ecart)
7049 PrintS(
"syzygy criterion checks: ");
7052 for (
int k=0;
k<strat->
syzl;
k++)
7057 Print(
"checking with: %d / %d -- \n",
k,strat->
syzl);
7086 PrintS(
"--- syzygy criterion checks: ");
7111 Print(
"checking with: %d -- ",
k);
7136 PrintS(
"rewritten criterion checks: ");
7139 for(
int k = strat->
sl;
k>=start;
k--)
7143 PrintS(
"checking with: ");
7159 PrintS(
"ALL ELEMENTS OF S\n----------------------------------------\n");
7160 for(
int kk = 0; kk<strat->
sl+1; kk++)
7164 PrintS(
"------------------------------\n");
7194 for (
int ii=strat->
sl; ii>start; ii--)
7200 if (!(
pLmCmp(p1,p2) == 1))
7219 for (
int i=strat->
Bl;
i>-1;
i--) {
7239 for (
int ii=strat->
sl; ii>-1; ii--)
7245 if (!(
pLmCmp(p1,p2) == 1))
7266 const unsigned long not_sev = ~L->sev;
7267 const unsigned long* sev = strat->
sevS;
7280 if (
j > end_pos)
return NULL;
7281 #if defined(PDEBUG) || defined(PDIV_DEBUG)
7283 (ecart== LONG_MAX || ecart>= strat->
ecartS[
j]))
7288 if (!(sev[
j] & not_sev) &&
7289 (ecart== LONG_MAX || ecart>= strat->
ecartS[
j]) &&
7303 if (
j > end_pos)
return NULL;
7304 #if defined(PDEBUG) || defined(PDIV_DEBUG)
7311 if (!(sev[
j] & not_sev) &&
7312 (ecart== LONG_MAX || ecart>= strat->
ecartS[
j]) &&
7323 if (strat->
tl < 0 || strat->
S_2_R[
j] == -1)
7344 if (
j > end_pos)
return NULL;
7346 #if defined(PDEBUG) || defined(PDIV_DEBUG)
7350 (ecart== LONG_MAX || ecart>= strat->
ecartS[
j]))
7356 if (! (sev[
j] & not_sev) && (ecart== LONG_MAX || ecart>= strat->
ecartS[
j]))
7359 assume(t !=
NULL && t->t_p !=
NULL && t->tailRing == r && t->p == strat->
S[
j]);
7375 if (
j > end_pos)
return NULL;
7377 #if defined(PDEBUG) || defined(PDIV_DEBUG)
7387 if (! (sev[
j] & not_sev) && (ecart== LONG_MAX || ecart>= strat->
ecartS[
j]))
7390 assume(t !=
NULL && t->t_p !=
NULL && t->tailRing == r && t->p == strat->
S[
j]);
7441 if (With ==
NULL)
break;
7451 return redtail(L, end_pos, strat);
7457 if (hn ==
NULL)
goto all_done;
7478 return redtail(&L, end_pos, strat);
7483 #define REDTAIL_CANONICALIZE 100
7487 p =
h = L->GetLmTailRing();
7489 return L->GetLmCurrRing();
7524 Ln.SetShortExpVector();
7530 With = &(strat->
T[
j]);
7531 assume(With->GetpLength()==
pLength(With->p != __null ? With->p : With->t_p));
7536 if (With ==
NULL)
break;
7537 assume(With->GetpLength()==
pLength(With->p != __null ? With->p : With->t_p));
7564 pNext(
h) = Ln.LmExtractAndIter();
7567 }
while (!Ln.IsNull());
7570 if (Ln.IsNull())
goto all_done;
7571 if (! withT) With_s.Init(
currRing);
7573 pNext(
h) = Ln.LmExtractAndIter();
7592 return L->GetLmCurrRing();
7600 p =
h = L->GetLmTailRing();
7602 return L->GetLmCurrRing();
7609 Ln.pLength = L->GetpLength() - 1;
7633 Ln.SetShortExpVector();
7639 With = &(strat->
T[
j]);
7644 if (With ==
NULL)
break;
7671 pNext(
h) = Ln.LmExtractAndIter();
7674 }
while (!Ln.IsNull());
7686 if (! withT) With_s.Init(
currRing);
7688 pNext(
h) = Ln.LmExtractAndIter();
7707 return L->GetLmCurrRing();
7717 p =
h = L->GetLmTailRing();
7752 Ln.SetShortExpVector();
7761 With = &(strat->
T[
j]);
7762 assume(With->GetpLength()==
pLength(With->p != __null ? With->p : With->t_p));
7779 pNext(
h) = Ln.LmExtractAndIter();
7782 }
while (!Ln.IsNull());
7790 With = &(strat->
T[
j]);
7791 assume(With->GetpLength()==
pLength(With->p != __null ? With->p : With->t_p));
7808 pNext(
h) = Ln.LmExtractAndIter();
7811 }
while (!Ln.IsNull());
7815 if (Ln.IsNull())
goto all_done;
7817 pNext(
h) = Ln.LmExtractAndIter();
7842 p =
h = L->GetLmTailRing();
7844 return L->GetLmCurrRing();
7851 Ln.pLength = L->GetpLength() - 1;
7864 Ln.SetShortExpVector();
7866 if (With ==
NULL)
break;
7876 poly p_Ln=Ln.GetLmCurrRing();
7877 poly p_With=With->GetLmCurrRing();
7889 if (Ln.bucket!=
NULL)
7920 pNext(
h) = Ln.LmExtractAndIter();
7923 }
while (!Ln.IsNull());
7926 if (Ln.IsNull())
goto all_done;
7929 pNext(
h) = Ln.LmExtractAndIter();
7947 return L->GetLmCurrRing();
7963 if (strat->
Ll != *reduc)
7965 if (strat->
Ll != *reduc-1)
7977 if (red_result == 0)
7979 else if (red_result < 0)
7981 if ((red_result > 0) || ((strat->
Ll % 100)==99))
7983 if (strat->
Ll != *reduc && strat->
Ll > 0)
8000 Print(
"product criterion:%d chain criterion:%d\n",strat->
cp,strat->
c3);
8001 if (hilbcount!=0)
Print(
"hilbert series criterion:%d\n",hilbcount);
8002 #ifdef HAVE_SHIFTBBA
8004 if (strat->
cv!=0)
Print(
"shift V criterion:%d\n",strat->
cv);
8015 if (hilbcount!=0)
Print(
"hilbert series criterion:%d\n",hilbcount);
8016 #ifdef HAVE_SHIFTBBA
8018 if (strat->
cv!=0)
Print(
"shift V criterion:%d\n",strat->
cv);
8033 for (
i=0;
i<=strat->
sl;
i++)
8045 for (
i=0;
i<=strat->
tl;
i++)
8049 if (strat->
T[
i].length==0) strat->
T[
i].length=
pLength(strat->
T[
i].p);
8050 Print(
" o:%ld e:%d l:%d",
8051 strat->
T[
i].pFDeg(),strat->
T[
i].ecart,strat->
T[
i].length);
8056 for (
i=strat->
Ll;
i>=0;
i--)
8065 Print(
" o:%ld e:%d l:%d",
8066 strat->
L[
i].pFDeg(),strat->
L[
i].ecart,strat->
L[
i].length);
8088 strat->
S=strat->
Shdl->m;
8093 memset(strat->
fromQ,0,
i*
sizeof(
int));
8122 strat->
enterS(
h,pos,strat,-1);
8123 strat->
fromQ[pos]=1;
8156 strat->
enterS(
h,pos,strat,-1);
8182 strat->
S=strat->
Shdl->m;
8187 memset(strat->
fromQ,0,
i*
sizeof(
int));
8216 strat->
enterS(
h,pos,strat,-1);
8217 strat->
fromQ[pos]=1;
8249 pos = strat->
posInL(strat->
L,strat->
Ll,&
h,strat);
8279 strat->
S = strat->
Shdl->m;
8292 memset(strat->
fromQ,0,
i*
sizeof(
int));
8321 strat->
enterS(
h,pos,strat,-1);
8322 strat->
fromQ[pos]=1;
8432 for(
i=1;
i<=strat->
sl;
i++)
8444 strat->
syz = (poly *)
omAlloc(ps*
sizeof(poly));
8448 #if defined(DEBUGF5) || defined(DEBUGF51)
8449 PrintS(
"------------- GENERATING SYZ RULES NEW ---------------\n");
8456 while (i <= strat->sl)
8486 for (
k = 0;
k<
i;
k++)
8530 for (
k = 0;
k<strat->
sl+1;
k++)
8551 PrintS(
"Principal syzygies:\n");
8554 Print(
"ps %d\n",ps);
8555 PrintS(
"--------------------------------\n");
8565 PrintS(
"--------------------------------\n");
8585 strat->
S=strat->
Shdl->m;
8591 memset(strat->
fromQ,0,
i*
sizeof(
int));
8620 strat->
enterS(
h,pos,strat, strat->
tl+1);
8622 strat->
fromQ[pos]=1;
8650 strat->
enterS(
h,pos,strat, strat->
tl+1);
8692 h.is_normalized = 0;
8699 strat->
enterS(
h,pos,strat, strat->
tl+1);
8729 strat->
S=strat->
Shdl->m;
8735 memset(strat->
fromQ,0,
i*
sizeof(
int));
8764 strat->
enterS(
h,pos,strat, strat->
tl+1);
8766 strat->
fromQ[pos]=1;
8794 strat->
enterS(
h,pos,strat, strat->
tl+1);
8836 h.is_normalized = 0;
8843 strat->
enterS(
h,pos,strat, strat->
tl+1);
8867 while (
j <= maxIndex)
8884 if (!
pIsVector((*p).p) && ((*p).ecart != 0))
8893 h1 = r =
pCopy((*p).p);
8946 while ((j <= strat->sl) && (
pGetComp(strat->
S[
j])!=0))
j++;
8948 while (j<=strat->sl)
8972 while (
j <= maxIndex)
9026 while (
j <= maxIndex);
9056 while (i<=strat->sl)
9067 if (
pCmp(redSi,strat->
S[
i])!=0)
9124 if (any_change)
reorderS(&suc,strat);
9129 for (
i=0;
i<=strat->
sl;
i++)
9155 #ifdef HAVE_SHIFTBBA
9167 while (i<=strat->sl)
9179 else if (
pCmp((strat->
S)[
i],redSi)!=0)
9220 if (any_change)
reorderS(&suc,strat);
9221 else { suc=-1;
break; }
9232 for (
i=0;
i<=strat->
sl;
i++)
9255 #ifdef HAVE_SHIFTBBA
9260 if (suc!= -1)
updateS(toT,strat);
9280 *
sizeof(
unsigned long));
9307 strat->
Shdl->m=strat->
S;
9309 if (atS <= strat->sl)
9311 #ifdef ENTER_USE_MEMMOVE
9312 memmove(&(strat->
S[atS+1]), &(strat->
S[atS]),
9313 (strat->
sl - atS + 1)*
sizeof(poly));
9314 memmove(&(strat->
ecartS[atS+1]), &(strat->
ecartS[atS]),
9315 (strat->
sl - atS + 1)*
sizeof(
int));
9316 memmove(&(strat->
sevS[atS+1]), &(strat->
sevS[atS]),
9317 (strat->
sl - atS + 1)*
sizeof(
unsigned long));
9318 memmove(&(strat->
S_2_R[atS+1]), &(strat->
S_2_R[atS]),
9319 (strat->
sl - atS + 1)*
sizeof(
int));
9321 memmove(&(strat->
lenS[atS+1]), &(strat->
lenS[atS]),
9322 (strat->
sl - atS + 1)*
sizeof(
int));
9324 memmove(&(strat->
lenSw[atS+1]), &(strat->
lenSw[atS]),
9327 for (
i=strat->
sl+1;
i>=atS+1;
i--)
9329 strat->
S[
i] = strat->
S[
i-1];
9335 for (
i=strat->
sl+1;
i>=atS+1;
i--)
9338 for (
i=strat->
sl+1;
i>=atS+1;
i--)
9344 #ifdef ENTER_USE_MEMMOVE
9345 memmove(&(strat->
fromQ[atS+1]), &(strat->
fromQ[atS]),
9346 (strat->
sl - atS + 1)*
sizeof(
int));
9348 for (
i=strat->
sl+1;
i>=atS+1;
i--)
9353 strat->
fromQ[atS]=0;
9364 strat->
sevS[atS] =
p.sev;
9366 strat->
S_2_R[atS] = atR;
9370 #ifdef HAVE_SHIFTBBA
9374 for (
int i = maxPossibleShift;
i > 0;
i--)
9399 *
sizeof(
unsigned long));
9403 *
sizeof(
unsigned long));
9431 strat->
Shdl->m=strat->
S;
9438 if (atS <= strat->sl)
9440 #ifdef ENTER_USE_MEMMOVE
9441 memmove(&(strat->
S[atS+1]), &(strat->
S[atS]),
9442 (strat->
sl - atS + 1)*
sizeof(poly));
9443 memmove(&(strat->
sig[atS+1]), &(strat->
sig[atS]),
9444 (strat->
sl - atS + 1)*
sizeof(poly));
9445 memmove(&(strat->
sevSig[atS+1]), &(strat->
sevSig[atS]),
9446 (strat->
sl - atS + 1)*
sizeof(
unsigned long));
9447 memmove(&(strat->
ecartS[atS+1]), &(strat->
ecartS[atS]),
9448 (strat->
sl - atS + 1)*
sizeof(
int));
9449 memmove(&(strat->
sevS[atS+1]), &(strat->
sevS[atS]),
9450 (strat->
sl - atS + 1)*
sizeof(
unsigned long));
9451 memmove(&(strat->
S_2_R[atS+1]), &(strat->
S_2_R[atS]),
9452 (strat->
sl - atS + 1)*
sizeof(
int));
9454 memmove(&(strat->
lenS[atS+1]), &(strat->
lenS[atS]),
9455 (strat->
sl - atS + 1)*
sizeof(
int));
9457 memmove(&(strat->
lenSw[atS+1]), &(strat->
lenSw[atS]),
9460 for (
i=strat->
sl+1;
i>=atS+1;
i--)
9462 strat->
S[
i] = strat->
S[
i-1];
9470 for (
i=strat->
sl+1;
i>=atS+1;
i--)
9473 for (
i=strat->
sl+1;
i>=atS+1;
i--)
9479 #ifdef ENTER_USE_MEMMOVE
9480 memmove(&(strat->
fromQ[atS+1]), &(strat->
fromQ[atS]),
9481 (strat->
sl - atS + 1)*
sizeof(
int));
9483 for (
i=strat->
sl+1;
i>=atS+1;
i--)
9488 strat->
fromQ[atS]=0;
9492 strat->
S[atS] =
p.p;
9493 strat->
sig[atS] =
p.sig;
9499 strat->
sevS[atS] =
p.sev;
9509 strat->
sevSig[atS] =
p.sevSig;
9512 strat->
S_2_R[atS] = atR;
9516 Print(
"--- LIST S: %d ---\n",strat->
sl);
9517 for(
k=0;
k<=strat->
sl;
k++)
9521 PrintS(
"--- LIST S END ---\n");
9544 poly tp = strat->
T[tj].p;
9549 for (
j = 0;
j <= strat->
sl; ++
j) {
9550 if (
pLtCmp(tp, strat->
S[
j]) == 0) {
9556 if (j <= strat->sl) {
9560 pos =
posInS(strat, strat->
sl,
p.p,
p.ecart);
9566 for (
i = 0;
i <= strat->
Ll; ++
i) {
9591 #ifdef HAVE_SHIFTBBA
9613 for(
i=strat->
tl;
i>=0;
i--)
9615 if (
p.p==strat->
T[
i].p)
9617 printf(
"already in T at pos %d of %d, atT=%d\n",
i,strat->
tl,atT);
9623 #ifdef HAVE_TAIL_RING
9626 p.t_p=
p.GetLmTailRing();
9632 if (strat->
tl == strat->
tmax-1)
9634 if (atT <= strat->tl)
9636 #ifdef ENTER_USE_MEMMOVE
9637 memmove(&(strat->
T[atT+1]), &(strat->
T[atT]),
9639 memmove(&(strat->
sevT[atT+1]), &(strat->
sevT[atT]),
9640 (strat->
tl-atT+1)*
sizeof(
unsigned long));
9642 for (
i=strat->
tl+1;
i>=atT+1;
i--)
9644 #ifndef ENTER_USE_MEMMOVE
9645 strat->
T[
i] = strat->
T[
i-1];
9648 strat->
R[strat->
T[
i].i_r] = &(strat->
T[
i]);
9654 #ifdef HAVE_SHIFTBBA
9656 if (!(
currRing->isLPring &&
p.shift > 0))
9672 strat->
T[atT].max_exp =
NULL;
9675 strat->
R[strat->
tl] = &(strat->
T[atT]);
9676 strat->
T[atT].i_r = strat->
tl;
9701 for(
i=strat->
tl;
i>=0;
i--)
9703 if (
p.p==strat->
T[
i].p)
9705 printf(
"already in T at pos %d of %d, atT=%d\n",
i,strat->
tl,atT);
9711 #ifdef HAVE_TAIL_RING
9714 p.t_p=
p.GetLmTailRing();
9720 if (strat->
tl == strat->
tmax-1)
9722 if (atT <= strat->tl)
9724 #ifdef ENTER_USE_MEMMOVE
9725 memmove(&(strat->
T[atT+1]), &(strat->
T[atT]),
9727 memmove(&(strat->
sevT[atT+1]), &(strat->
sevT[atT]),
9728 (strat->
tl-atT+1)*
sizeof(
unsigned long));
9730 for (
i=strat->
tl+1;
i>=atT+1;
i--)
9732 #ifndef ENTER_USE_MEMMOVE
9733 strat->
T[
i] = strat->
T[
i-1];
9736 strat->
R[strat->
T[
i].i_r] = &(strat->
T[
i]);
9754 strat->
T[atT].max_exp =
NULL;
9757 strat->
R[strat->
tl] = &(strat->
T[atT]);
9758 strat->
T[atT].i_r = strat->
tl;
9765 for(
i=strat->
tl;
i>=0;
i--)
9796 (strat->
syzmax)*
sizeof(
unsigned long),
9798 *
sizeof(
unsigned long));
9801 if (atT < strat->syzl)
9803 #ifdef ENTER_USE_MEMMOVE
9804 memmove(&(strat->
syz[atT+1]), &(strat->
syz[atT]),
9805 (strat->
syzl-atT+1)*
sizeof(poly));
9806 memmove(&(strat->
sevSyz[atT+1]), &(strat->
sevSyz[atT]),
9807 (strat->
syzl-atT+1)*
sizeof(
unsigned long));
9809 for (
i=strat->
syzl;
i>=atT+1;
i--)
9811 #ifndef ENTER_USE_MEMMOVE
9824 strat->
syz[atT] =
p.sig;
9825 strat->
sevSyz[atT] =
p.sevSig;
9828 Print(
"element in strat->syz: %d--%d ",atT+1,strat->
syzmax);
9838 strat->
L[cc].sig, ~strat->
L[cc].sevSig,
currRing)
9852 PrintS(
"--- Syzygies ---\n");
9855 PrintS(
"--------------------------------\n");
9861 PrintS(
"--------------------------------\n");
9897 #ifdef HAVE_RATGRING
9943 else PrintS(
"ideal/module is not homogeneous\n");
9974 #ifdef HAVE_RATGRING
10013 if (strat->
homog)
PrintS(
"ideal/module is homogeneous\n");
10014 else PrintS(
"ideal/module is not homogeneous\n");
10216 #ifdef HAVE_SHIFTBBA
10239 strat->
P.pLength=0;
10282 #ifdef HAVE_SHIFTBBA
10309 #ifdef HAVE_SHIFTBBA
10551 if ((r->m[
l]!=
NULL)
10558 if ((
Q->m[q]!=
NULL)
10582 if ((r->m[
l]!=
NULL)
10589 if ((
Q->m[q]!=
NULL)
10633 reduction_found=
TRUE;
10664 reduction_found=
TRUE;
10678 if ( reduction_found)
10768 for (
i=strat->
sl;
i>=low;
i--)
10770 int end_pos=strat->
sl;
10772 if (strat->
ak==0) end_pos=
i-1;
10774 if ((T_j !=
NULL)&&(T_j->p==strat->
S[
i]))
10792 Print(
"to (tailR) S[%d]:",
i);
10804 T_j->max_exp =
NULL;
10807 T_j->pCleardenom();
10847 Print(
"to (-tailR) S[%d]:",
i);
10858 sloppy_max =
FALSE;
10895 if (j < strat->
HCord)
10936 assume(L->i_r1 >= -1 && L->i_r1 <= strat->
tl);
10937 assume(L->i_r2 >= -1 && L->i_r2 <= strat->
tl);
10943 if ((L->i_r1 == -1) || (L->i_r2 == -1) )
10948 if (L->i_r1>=0) p1_max = (strat->
R[L->i_r1])->max_exp;
10950 if (L->i_r2>=0) p2_max = (strat->
R[L->i_r2])->max_exp;
10976 poly p1_max = (strat->
R[atR])->max_exp;
10977 poly p2_max = (strat->
R[strat->
S_2_R[atS]])->max_exp;
10998 ideal F =
idCopy(Forig);
11002 ideal monred =
idInit(1,1);
11009 if((posconst != -1) && (!
nIsZero(F->m[posconst]->coef)))
11019 for(
int i=0;
i<idelemQ;
i++)
11027 if((posconst != -1) && (!
nIsZero(monred->m[posconst]->coef)))
11029 pmon =
pCopy(monred->m[posconst]);
11044 II->m[
j++] =
prMapR(F->m[
i], nMap, origR, QQ_ring);
11046 II->m[
j++] =
prMapR(
Q->m[
i], nMap, origR, QQ_ring);
11053 if(II->m[
i] !=
NULL)
11054 II->m[
i+1] = II->m[
i];
11057 poly integer =
NULL;
11065 integer =
pHead(syz->m[
i]);
11072 pmon =
prMapR(integer, nMap2, QQ_ring, origR);
11086 poly mindegmon =
NULL;
11091 if(mindegmon ==
NULL)
11092 mindegmon =
pCopy(one->m[
i]);
11095 if(
p_Deg(one->m[
i], QQ_ring) <
p_Deg(mindegmon, QQ_ring))
11096 mindegmon =
pCopy(one->m[
i]);
11100 if(mindegmon !=
NULL)
11103 if(II->m[
i] !=
NULL)
11104 II->m[
i+1] = II->m[
i];
11105 II->m[0] =
pCopy(mindegmon);
11134 pmon =
prMapR(mindegmon, nMap2, QQ_ring, origR);
11165 poly pH =
h->GetP();
11169 for(
int i = 0;
i<=strat->
sl;
i++)
11224 h->SetLmCurrRing();
11225 if((deleted)&&(
h->p!=
NULL))
11233 poly hSig =
h->sig;
11234 poly pH =
h->GetP();
11238 for(
int i = 0;
i<=strat->
sl;
i++)
11249 if(sigMult!=
NULL &&
pLtCmp(hSig,sigMult) == 1)
11276 if(sigMult!=
NULL &&
pLtCmp(hSig,sigMult) == 1)
11307 h->SetLmCurrRing();
11408 if (expbound == 0) expbound = strat->
tailRing->bitmask << 1;
11425 new_tailRing->pFDeg =
currRing->pFDeg;
11426 new_tailRing->pLDeg =
currRing->pLDeg;
11430 Print(
"[%lu:%d", (
unsigned long) new_tailRing->bitmask, new_tailRing->ExpL_Size);
11439 for (
i=0;
i<=strat->
tl;
i++)
11441 strat->
T[
i].ShallowCopyDelete(new_tailRing, new_tailBin,
11442 p_shallow_copy_delete);
11444 for (
i=0;
i<=strat->
Ll;
i++)
11448 strat->
L[
i].ShallowCopyDelete(new_tailRing, p_shallow_copy_delete);
11450 if ((strat->
P.t_p !=
NULL) ||
11452 strat->
P.ShallowCopyDelete(new_tailRing, p_shallow_copy_delete);
11454 if ((L !=
NULL) && (L->tailRing != new_tailRing))
11457 L->ShallowCopyDelete(new_tailRing, p_shallow_copy_delete);
11463 L->tailRing = new_tailRing;
11466 L->max_exp = t_l->max_exp;
11470 if ((
T !=
NULL) && (
T->tailRing != new_tailRing &&
T->i_r < 0))
11471 T->ShallowCopyDelete(new_tailRing, new_tailBin, p_shallow_copy_delete);
11478 strat->
tailBin = new_tailBin;
11504 unsigned long l = 0;
11510 for (
i=0;
i<= strat->
Ll;
i++)
11514 for (
i=0;
i<=strat->
tl;
i++)
11541 res->block0 = (
int *)
omAlloc0((n+1)*
sizeof(int));
11542 res->block1 = (
int *)
omAlloc0((n+1)*
sizeof(int));
11543 int **wvhdl = (
int **)
omAlloc0((n+1)*
sizeof(
int*));
11544 res->wvhdl = wvhdl;
11545 for (
int i=1;
i<n;
i++)
11547 res->order[
i] = r->order[
i-1];
11548 res->block0[
i] = r->block0[
i-1];
11549 res->block1[
i] = r->block1[
i-1];
11550 res->wvhdl[
i] = r->wvhdl[
i-1];
11569 #ifndef SING_NDEBUG
11570 WarnS(
"error in nc_rComplete");
11589 res->block0 = (
int *)
omAlloc0((n+2)*
sizeof(int));
11590 res->block1 = (
int *)
omAlloc0((n+2)*
sizeof(int));
11591 int **wvhdl = (
int **)
omAlloc0((n+2)*
sizeof(
int*));
11592 res->wvhdl = wvhdl;
11593 for (
int i=2;
i<n+2;
i++)
11595 res->order[
i] = r->order[
i-2];
11596 res->block0[
i] = r->block0[
i-2];
11597 res->block1[
i] = r->block1[
i-2];
11598 res->wvhdl[
i] = r->wvhdl[
i-2];
11603 res->block0[0] = 1;
11605 for (
int i=0;
i<
res->N; ++
i)
11606 res->wvhdl[0][
i] = 1;
11625 #ifndef SING_NDEBUG
11626 WarnS(
"error in nc_rComplete");
11763 #ifdef HAVE_TAIL_BIN
11790 Timings
for the different possibilities of posInT:
11791 T15 EDL DL EL L 1-2-3
11792 Gonnet 43.26 42.30 38.34 41.98 38.40 100.04
11793 Hairer_2_1 1.11 1.15 1.04 1.22 1.08 4.7
11794 Twomat3 1.62 1.69 1.70 1.65 1.54 11.32
11795 ahml 4.48 4.03 4.03 4.38 4.96 26.50
11796 c7 15.02 13.98 15.16 13.24 17.31 47.89
11797 c8 505.09 407.46 852.76 413.21 499.19 n/a
11798 f855 12.65 9.27 14.97 8.78 14.23 33.12
11799 gametwo6 11.47 11.35 14.57 11.20 12.02 35.07
11800 gerhard_3 2.73 2.83 2.93 2.64 3.12 6.24
11801 ilias13 22.89 22.46 24.62 20.60 23.34 53.86
11802 noon8 40.68 37.02 37.99 36.82 35.59 877.16
11803 rcyclic_19 48.22 42.29 43.99 45.35 51.51 204.29
11804 rkat9 82.37 79.46 77.20 77.63 82.54 267.92
11805 schwarz_11 16.46 16.81 16.76 16.81 16.72 35.56
11806 test016 16.39 14.17 14.40 13.50 14.26 34.07
11807 test017 34.70 36.01 33.16 35.48 32.75 71.45
11808 test042 10.76 10.99 10.27 11.57 10.45 23.04
11809 test058 6.78 6.75 6.51 6.95 6.22 9.47
11810 test066 10.71 10.94 10.76 10.61 10.56 19.06
11811 test073 10.75 11.11 10.17 10.79 8.63 58.10
11812 test086 12.23 11.81 12.88 12.24 13.37 66.68
11813 test103 5.05 4.80 5.47 4.64 4.89 11.90
11814 test154 12.96 11.64 13.51 12.46 14.61 36.35
11815 test162 65.27 64.01 67.35 59.79 67.54 196.46
11816 test164 7.50 6.50 7.68 6.70 7.96 17.13
11817 virasoro 3.39 3.50 3.35 3.47 3.70 7.66
11827 if (
length==-1)
return 0;
11830 int op=
p.GetpFDeg();
11831 int ol =
p.GetpLength();
11833 if (set[
length].ecart < o)
11835 if (set[
length].ecart == o)
11837 int oo=set[
length].GetpFDeg();
11838 if ((oo < op) || ((oo==op) && (set[
length].
length < ol)))
11849 if (set[an].ecart > o)
11851 if (set[an].ecart == o)
11853 int oo=set[an].GetpFDeg();
11855 || ((oo==op) && (set[an].
pLength > ol)))
11861 if (set[
i].ecart > o)
11863 else if (set[
i].ecart == o)
11865 int oo=set[
i].GetpFDeg();
11867 || ((oo == op) && (set[
i].
pLength > ol)))
11881 if (
length==-1)
return 0;
11883 int op=
p.GetpFDeg();
11884 int ol =
p.GetpLength();
11886 int oo=set[
length].GetpFDeg();
11887 if ((oo < op) || ((oo==op) && (set[
length].
length < ol)))
11897 int oo=set[an].GetpFDeg();
11899 || ((oo==op) && (set[an].
pLength > ol)))
11904 int oo=set[
i].GetpFDeg();
11917 int ol =
p.GetpLength();
11931 if (set[an].
pLength>ol)
return an;
11956 else Print(
"%p\n",(
void*)strat->
red);
11975 #ifdef HAVE_MORE_POS_IN_T
12013 PrintS(
"initEcartPair: ");
12017 Print(
"homog=%d, LazyDegree=%d, LazyPass=%d, ak=%d,\n",
12019 Print(
"honey=%d, sugarCrit=%d, Gebauer=%d, noTailReduction=%d, use_buckets=%d\n",
12025 Print(
"posInLDependsOnLength=%d\n",
12057 PrintS(
"currRing->pFDeg: ");
12072 PrintS(
"ecartWeights: ");
12079 #ifndef SING_NDEBUG
12084 #ifdef HAVE_SHIFTBBA
12098 #ifdef HAVE_SHIFTBBA
12115 #ifdef HAVE_SHIFTBBA
12207 #ifdef HAVE_SHIFTBBA
12212 assume(q_inS < 0 || strat->S[q_inS] == q);
12222 if (strat->
fromQ !=
NULL && q_inS >= 0)
12223 q_isFromQ = strat->
fromQ[q_inS];
12226 int neededShift = p_lastVblock - 1;
12227 int maxPossibleShift =
degbound - q_lastVblock;
12228 int maxShift =
si_min(neededShift, maxPossibleShift);
12229 int firstShift = (q ==
p ? 1 : 0);
12230 for (
int j = firstShift;
j <= maxShift;
j++)
12238 #ifdef HAVE_SHIFTBBA
12243 assume(p_inS < 0 || strat->S[p_inS] ==
p);
12252 if (strat->
fromQ !=
NULL && p_inS >= 0)
12253 p_isFromQ = strat->
fromQ[p_inS];
12255 int maxNeededShift = p_lastVblock - 1;
12256 if (q_shift <= maxNeededShift)
12257 enterOnePairShift(q,
p, ecartp, p_isFromQ, strat, -1, ecartq, q_isFromQ, q_shift, -1);
12261 #ifdef HAVE_SHIFTBBA
12270 void enterOnePairShift (poly q, poly
p,
int ecart,
int isFromQ,
kStrategy strat,
int atR,
int ecartq,
int qisFromQ,
int shiftcount,
int ifromS)
12272 #ifdef CRITERION_DEBUG
12277 poly lmq =
pHead(q);
12298 int qfromQ = qisFromQ;
12307 Lp.ecart=0; Lp.length=0;
12317 #ifdef CRITERION_DEBUG
12325 if((!((ecartq>0)&&(ecart>0)))
12344 #ifdef CRITERION_DEBUG
12350 Lp.ecart =
si_max(ecart,ecartq);
12351 if (strat->
fromT && (ecartq>ecart))
12354 #ifdef CRITERION_DEBUG
12376 if ((strat->
fromQ==
NULL) || (isFromQ==0) || (qfromQ==0))
12379 #ifdef CRITERION_DEBUG
12391 #ifdef CRITERION_DEBUG
12423 #ifdef CRITERION_DEBUG
12428 if (strat->
fromT && (ecartq>ecart))
12431 #ifdef CRITERION_DEBUG
12443 for(
j = strat->
Bl;
j>=0;
j--)
12449 if ((strat->
fromQ==
NULL) || (isFromQ==0) || (qfromQ==0))
12452 #ifdef CRITERION_DEBUG
12463 #ifdef CRITERION_DEBUG
12479 #ifdef CRITERION_DEBUG
12484 if ((strat->
fromQ!=
NULL) && (isFromQ!=0) && (qfromQ!=0))
12487 #ifdef CRITERION_DEBUG
12548 #ifdef CRITERION_DEBUG
12564 if ( (atR >= 0) && (shiftcount==0) && (ifromS >=0) )
12581 && (Lp.p->coef!=
NULL))
12585 l = strat->
posInL(strat->
B,strat->
Bl,&Lp,strat);
12587 #ifdef CRITERION_DEBUG
12594 #ifdef HAVE_SHIFTBBA
12605 if (h_lastVblock == 0)
return;
12616 int maxShift =
degbound - h_lastVblock;
12625 for (
i=0;
i<=maxShift;
i++)
12628 for (
j=0;
j<=
k;
j++)
12633 poly
s = strat->
S[
j];
12642 for (
j=0;
j<=
k;
j++)
12644 poly
s = strat->
S[
j];
12659 else if ((isFromQ)&&(strat->
fromQ!=
NULL))
12662 for (
j=0;
j<=
k;
j++) {
12666 poly
s = strat->
S[
j];
12673 for (
i=1;
i<=maxShift;
i++)
12676 for (
j=0;
j<=
k;
j++)
12680 poly
s = strat->
S[
j];
12691 for (
j=0;
j<=
k;
j++) {
12692 poly
s = strat->
S[
j];
12697 for (
i=1;
i<=maxShift;
i++)
12700 for (
j=0;
j<=
k;
j++)
12702 poly
s = strat->
S[
j];
12714 for (
j=0;
j<=
k;
j++)
12720 poly
s = strat->
S[
j];
12737 for (
j=0;
j<=
k;
j++) {
12741 poly
s = strat->
S[
j];
12746 for (
i=1;
i<=maxShift;
i++)
12749 for (
j=0;
j<=
k;
j++)
12754 poly
s = strat->
S[
j];
12772 #ifdef HAVE_SHIFTBBA
12785 if ( (!strat->
fromT)
12802 #ifdef HAVE_SHIFTBBA
12817 for (
int i = 1;
i <= maxPossibleShift;
i++)
12829 #ifdef HAVE_SHIFTBBA
12836 p =
h = L->GetLmTailRing();
12838 return L->GetLmCurrRing();
12845 Ln.pLength = L->GetpLength() - 1;
12853 while(!Ln.IsNull())
12857 Ln.SetShortExpVector();
12863 With = &(strat->
T[
j]);
12868 if (With ==
NULL)
break;
12884 pNext(
h) = Ln.LmExtractAndIter();
12887 }
while (!Ln.IsNull());
12890 if (Ln.IsNull())
goto all_done;
12891 if (! withT) With_s.Init(
currRing);
12893 pNext(
h) = Ln.LmExtractAndIter();
12908 return L->GetLmCurrRing();
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)
int ksCheckCoeff(number *a, number *b)
void kStratInitChangeTailRing(kStrategy strat)
#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 enterpairsSig(poly h, poly hSig, int hFrom, int k, int ecart, int pos, kStrategy strat, int atR)
void enterOnePairShift(poly q, poly p, int ecart, int isFromQ, kStrategy strat, int atR, int ecartq, int qisFromQ, int shiftcount, int ifromS)
void chainCritRing(poly p, int, kStrategy strat)
int posInLSig(const LSet set, const int length, LObject *p, const kStrategy)
int dReportError(const char *fmt,...)
#define pLPCopyAndShiftLM(p, sh)
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 must be 0
void initBuchMoraCrit(kStrategy strat)
void enterExtendedSpolySig(poly h, poly hSig, kStrategy strat)
void initPairtest(kStrategy strat)
void enterOneZeroPairRing(poly f, poly t_p, poly p, int ecart, kStrategy strat, int atR=-1)
#define pGetComp(p)
Component.
poly redtailBbaBound(LObject *L, int end_pos, kStrategy strat, int bound, BOOLEAN withT, BOOLEAN normalize)
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)
static BOOLEAN rIsLPRing(const ring r)
void pRestoreDegProcs(ring r, pFDegProc old_FDeg, pLDegProc old_lDeg)
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 FORCE_INLINE BOOLEAN nCoeff_is_Z(const coeffs r)
static void pLmFree(poly p)
frees the space of the monomial m, assumes m != NULL coef is not freed, m is not advanced
void enterT_strong(LObject &p, kStrategy strat, int atT)
static BOOLEAN enterOneStrongPoly(int i, poly p, int, int, kStrategy strat, int atR, bool enterTstrong)
void rDebugPrint(const ring r)
int posInL0(const LSet set, const int length, LObject *p, const kStrategy)
static BOOLEAN rField_is_Domain(const ring r)
long pLDeg0(poly p, int *l, const ring r)
void rChangeCurrRing(ring r)
#define TEST_OPT_DEGBOUND
poly nc_p_Bracket_qq(poly p, const poly q, const ring r)
returns [p,q], destroys p
int posInL17_c(const LSet set, const int length, LObject *p, const kStrategy)
BOOLEAN arriRewCriterion(poly, unsigned long, poly, kStrategy strat, int start=0)
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)
void initenterpairsShift(poly h, int k, int ecart, int isFromQ, kStrategy strat, int atR)
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)
BOOLEAN kCheckStrongCreation(int atR, poly m1, int atS, poly m2, 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)
void updateResult(ideal r, ideal Q, kStrategy strat)
BOOLEAN kCheckSpolyCreation(LObject *L, kStrategy strat, poly &m1, poly &m2)
void superenterpairs(poly h, int k, int ecart, int pos, kStrategy strat, int atR)
long totaldegreeWecart(poly p, ring r)
int posInT110(const TSet set, const int length, LObject &p)
BOOLEAN idInsertPoly(ideal h1, poly h2)
insert h2 into h1 (if h2 is not the zero polynomial) return TRUE iff h2 was indeed inserted
poly redtailBba(LObject *L, int end_pos, kStrategy strat, BOOLEAN withT, BOOLEAN normalize)
static BOOLEAN length(leftv result, leftv arg)
long ind_fact_2(long arg)
static poly p_ShallowCopyDelete(poly p, const ring r, omBin bin)
static void p_ExpVectorCopy(poly d_p, poly s_p, const ring r)
#define TEST_OPT_CONTENTSB
#define __p_GetComp(p, r)
void updateS(BOOLEAN toT, kStrategy strat)
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 omGetStickyBinOfBin(B)
#define REDTAIL_CANONICALIZE
static poly pp_Mult_mm(poly p, poly m, const ring r)
int posInS(const kStrategy strat, const int length, const poly p, const int ecart_p)
void initSbaCrit(kStrategy strat)
void kDebugPrint(kStrategy strat)
Output some debug info about a given strategy.
long pLDeg1c_WFirstTotalDegree(poly p, int *l, const ring r)
void initenterzeropairsRing(poly p, int ecart, kStrategy strat, int atR)
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)
void deleteInSSba(int i, kStrategy strat)
void postReduceByMon(LObject *h, kStrategy strat)
used for GB over ZZ: intermediate reduction by monomial elements background: any known constant eleme...
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
static void enlargeL(LSet *L, int *length, const int incr)
int posInT_FDegpLength(const TSet set, const int length, LObject &p)
BOOLEAN syzCriterion(poly sig, unsigned long not_sevSig, kStrategy strat)
#define pLmIsConstantComp(p)
like above, except that p must be != NULL
void enterpairsShift(poly h, int k, int ecart, int pos, kStrategy strat, int atR)
void p_Lcm(const poly a, const poly b, poly m, const ring r)
BOOLEAN isInPairsetB(poly q, int *k, kStrategy strat)
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)
BOOLEAN arriRewCriterionPre(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int)
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)
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)
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)
VAR denominator_list DENOMINATOR_LIST
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
int posInSMonFirst(const kStrategy strat, const int length, const poly p)
int redRing(LObject *h, kStrategy strat)
char posInLDependsOnLength
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)
void enterTShift(LObject p, kStrategy strat, int atT)
#define TEST_OPT_NOT_SUGAR
long pLDeg1_WFirstTotalDegree(poly p, int *l, const ring r)
static int p_Cmp(poly p1, poly p2, ring r)
void kBucketInit(kBucket_pt bucket, poly lm, int length)
void message(int i, int *reduc, int *olddeg, kStrategy strat, int red_result)
BOOLEAN kbTest(kBucket_pt bucket)
Tests.
void finalReduceByMon(kStrategy strat)
used for GB over ZZ: final reduction by constant elements background: any known constant element of i...
int posInT_pLength(const TSet set, const int length, LObject &p)
KINLINE int ksReducePolyTail(LObject *PR, TObject *PW, LObject *Red)
static void enterOnePairWithShifts(int q_inS, poly q, poly p, int ecartp, int p_isFromQ, kStrategy strat, int atR, int p_lastVblock, int q_lastVblock)
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size
static BOOLEAN rField_is_Ring(const ring r)
int posInTrg0(const TSet set, const int length, LObject &p)
void completeReduce(kStrategy strat, BOOLEAN withT)
#define pFalseReturn(cond)
int posInL11Ringls(const LSet set, const int length, LObject *p, const kStrategy)
int(* posInL)(const LSet set, const int length, LObject *L, const kStrategy strat)
KINLINE poly kNoetherTail()
static int * initS_2_R(const int maxnr)
void exitBuchMora(kStrategy strat)
void enterSSba(LObject &p, int atS, kStrategy strat, int atR)
static BOOLEAN rIsRatGRing(const ring r)
#define ENTER_USE_MEMMOVE
int redFirst(LObject *h, kStrategy strat)
void initenterpairs(poly h, int k, int ecart, int isFromQ, kStrategy strat, int atR=-1)
static int max(int a, int b)
pFDegProc pOrigFDeg_TailRing
int posInL17Ring(const LSet set, const int length, LObject *p, const kStrategy)
static void initenterstrongPairsSig(poly h, poly hSig, int k, int ecart, int isFromQ, kStrategy strat, int atR=-1)
static LSet initL(int nr=setmaxL)
static void p_LmDelete(poly p, const ring r)
void initBuchMora(ideal F, ideal Q, kStrategy strat)
#define pInit()
allocates a new monomial and initializes everything to 0
static poly redMora(poly h, int maxIndex, kStrategy strat)
KINLINE BOOLEAN k_GetLeadTerms(const poly p1, const poly p2, const ring p_r, poly &m1, poly &m2, const ring m_r)
poly pCopyL2p(LObject H, kStrategy strat)
void kMergeBintoL(kStrategy strat)
void enterSyz(LObject &p, kStrategy strat, int atT)
int posInL10(const LSet set, const int length, LObject *p, const kStrategy strat)
poly redtailBbaShift(LObject *L, int pos, kStrategy strat, BOOLEAN withT, BOOLEAN normalize)
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)
int p_mLPmaxPossibleShift(poly p, const ring r)
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)
KINLINE int ksReducePolyTailLC_Z(LObject *PR, TObject *PW, LObject *Red)
static BOOLEAN p_LmExpVectorAddIsOk(const poly p1, const poly p2, const ring r)
int posInLF5CRing(const LSet set, int start, const int length, LObject *p, const kStrategy)
void replaceInLAndSAndT(LObject &p, int tj, kStrategy strat)
void initBuchMoraPos(kStrategy strat)
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
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 kBucketClear(kBucket_pt bucket, poly *p, int *length)
TObject * kFindDivisibleByInS_T(kStrategy strat, int end_pos, LObject *L, TObject *T, long ecart)
void enterSBbaShift(LObject &p, int atS, kStrategy strat, int atR)
int posInLRing(const LSet set, const int length, LObject *p, const kStrategy)
static int rBlocks(ring r)
#define __pp_Mult_nn(p, n, r)
void messageStat(int hilbcount, kStrategy strat)
#define pLtCmpOrdSgnDiffM(p, q)
void initSyzRules(kStrategy strat)
void pLcmRat(poly a, poly b, poly m, int rat_shift)
int posInL15Ring(const LSet set, const int length, LObject *p, const kStrategy)
static void enterOnePairWithoutShifts(int p_inS, poly q, poly p, int ecartq, int q_isFromQ, kStrategy strat, int atR, int p_lastVblock, int q_shift)
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
int posInT13(const TSet set, const int length, LObject &p)
poly redtailBba_Z(LObject *L, int end_pos, kStrategy strat)
poly pMove2CurrTail(poly p, kStrategy strat)
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 getIndexRng(long coeff)
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)
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 const...
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)
void initSbaPos(kStrategy strat)
int posInL11(const LSet set, const int length, LObject *p, const kStrategy)
long p_Deg(poly a, const ring r)
int posInIdealMonFirst(const ideal F, const poly p, int start, int end)
int posInL17_cRing(const LSet set, const int length, LObject *p, const kStrategy)
static void p_Delete(poly *p, const ring r)
void initSL(ideal F, ideal Q, kStrategy strat)
static poly p_Add_q(poly p, poly q, const ring r)
static int min(int a, int b)
int posInL17(const LSet set, const int length, LObject *p, const kStrategy)
static poly redBba1(poly h, int maxIndex, kStrategy strat)
void postReduceByMonSig(LObject *h, kStrategy strat)
BOOLEAN sbaCheckGcdPair(LObject *h, kStrategy strat)
long maxdegreeWecart(poly p, int *l, ring r)
int posInT15Ring(const TSet set, const int length, LObject &p)
BOOLEAN faugereRewCriterion(poly sig, unsigned long not_sevSig, poly, kStrategy strat, int start=0)
int kFindDivisibleByInT_Z(const kStrategy strat, const LObject *L, const int start)
static poly normalize(poly next_p, ideal add_generators, syStrategy syzstr, int *g_l, int *p_l, int crit_comp)
void initBuchMoraPosRing(kStrategy strat)
void chainCritNormal(poly p, int ecart, kStrategy strat)
static int si_max(const int a, const int b)
static CanonicalForm bound(const CFMatrix &M)
void mult(unsigned long *result, unsigned long *a, unsigned long *b, unsigned long p, int dega, int degb)
#define pSetmComp(p)
TODO:
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)
BOOLEAN p_CheckPolyRing(poly p, ring r)
#define rRing_has_Comp(r)
int posInL110(const LSet set, const int length, LObject *p, const kStrategy)
static poly redBba(poly h, int maxIndex, kStrategy strat)
void initSLSba(ideal F, ideal Q, kStrategy strat)
void(* initEcartPair)(LObject *h, poly f, poly g, int ecartF, int ecartG)
void initSbaBuchMora(ideal F, ideal Q, kStrategy strat)
#define TEST_OPT_SUGARCRIT
void cleanTSbaRing(kStrategy strat)
void reorderS(int *suc, kStrategy strat)
poly p_NSet(number n, const ring r)
returns the poly representing the number n, destroys n
#define omSizeWOfBin(bin_ptr)
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)
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)
#define omMergeStickyBinIntoBin(A, B)
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 redtailBbaAlsoLC_Z(LObject *L, int end_pos, kStrategy strat)
#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)
KINLINE int ksReducePolyTail_Z(LObject *PR, TObject *PW, LObject *Red)
void cancelunit(LObject *L, BOOLEAN inNF)
static int pDivComp(poly p, poly q)
static long p_Totaldegree(poly p, const ring r)
static BOOLEAN p_ExpVectorEqual(poly p1, poly p2, const ring r1, const ring r2)
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 messageStatSBA(int hilbcount, kStrategy strat)
void enterL(LSet *set, int *length, int *LSetmax, LObject p, int at)
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
void deleteInL(LSet set, int *length, int j, kStrategy strat)
STATIC_VAR unsigned add[]
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)
void enterpairs(poly h, int k, int ecart, int pos, kStrategy strat, int atR)
#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)
static void kDeleteLcm(LObject *P)
#define pHead(p)
returns newly allocated copy of Lm(p), coef is copied, next=NULL, p might be NULL
KINLINE void k_GetStrongLeadTerms(const poly p1, const poly p2, const ring leadRing, poly &m1, poly &m2, poly &lcm, const ring tailRing)
void initEcartPairMora(LObject *Lp, poly, poly, int ecartF, int ecartG)
BOOLEAN rHasMixedOrdering(const ring r)
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
int redFirstShift(LObject *h, kStrategy strat)
void enterOnePairNormal(int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR=-1)
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)
EXTERN_VAR short * ecartWeights
unsigned long p_GetShortExpVector(const poly p, const ring r)
KINLINE TObject ** initR()
BOOLEAN(* syzCrit)(poly sig, unsigned long not_sevSig, kStrategy strat)
STATIC_VAR gmp_float * diff
#define omCheckBinAddrSize(addr, size)
static long p_FDeg(const poly p, const ring r)
poly kCreateZeroPoly(long exp[], long cabsind, poly *t_p, ring leadRing, ring tailRing)
void enterExtendedSpoly(poly h, kStrategy strat)
void initHilbCrit(ideal, ideal, intvec **hilb, kStrategy strat)
void exitSba(kStrategy strat)
static int index(p_Length length, p_Ord ord)
int redHoney(LObject *h, kStrategy strat)
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.
#define pHasNotCFRing(p1, p2)
void superenterpairsSig(poly h, poly hSig, int hFrom, int k, int ecart, int pos, kStrategy strat, int atR)
void enterT(LObject &p, kStrategy strat, int atT)
static 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 initS(ideal F, ideal Q, kStrategy strat)
KINLINE poly ksOldSpolyRedNew(poly p1, poly p2, poly spNoether)
int nextZeroSimplexExponent(long exp[], long ind[], long cexp[], long cind[], long *cabsind, long step[], long bound, long N)
BOOLEAN rComplete(ring r, int force)
this needs to be called whenever a new ring is created: new fields in ring are created (like VarOffse...
#define omReallocSize(addr, o_size, size)
void p_Cleardenom_n(poly ph, const ring r, number &c)
BOOLEAN p_CheckIsFromRing(poly p, ring r)