47#define ENTER_USE_MEMMOVE
87#ifdef ENTER_USE_MYMEMMOVE
88inline void _my_memmove_d_gt_s(
unsigned long* d,
unsigned long*
s,
long l)
90 REGISTER unsigned long* _dl = (
unsigned long*) d;
91 REGISTER unsigned long* _sl = (
unsigned long*)
s;
102inline void _my_memmove_d_lt_s(
unsigned long* d,
unsigned long*
s,
long l)
105 REGISTER unsigned long* _dl = (
unsigned long*) d;
106 REGISTER unsigned long* _sl = (
unsigned long*)
s;
117inline void _my_memmove(
void* d,
void*
s,
long l)
119 unsigned long _d = (
unsigned long) d;
120 unsigned long _s = (
unsigned long)
s;
121 unsigned long _l = ((
l) + SIZEOF_LONG - 1) >> LOG_SIZEOF_LONG;
123 if (_d > _s) _my_memmove_d_gt_s(_d, _s, _l);
124 else _my_memmove_d_lt_s(_d, _s, _l);
128#define memmove(d,s,l) _my_memmove(d, s, l)
135#define pDivComp_EQUAL 2
136#define pDivComp_LESS 1
137#define pDivComp_GREATER -1
138#define pDivComp_INCOMP 0
151 unsigned long la, lb;
152 unsigned long divmask =
currRing->divmask;
162 if (((la & divmask) ^ (lb & divmask)) != ((lb - la) & divmask))
169 if (((la & divmask) ^ (lb & divmask)) != ((la - lb) & divmask))
200 unsigned long la, lb;
201 unsigned long divmask =
currRing->divmask;
211 if (((la & divmask) ^ (lb & divmask)) != ((lb - la) & divmask))
218 if (((la & divmask) ^ (lb & divmask)) != ((la - lb) & divmask))
225 if (
b) {
return -1; }
260 poly
p = L->GetLmTailRing();
263 if (L->bucket !=
NULL)
301 L->ecart = L->pLDeg() - L->GetpFDeg();
310 L->ecart = L->pLDeg(strat->
LDegLast) - L->GetpFDeg();
348 ring r = L->tailRing;
349 poly
p = L->GetLmTailRing();
427 number eins=
nInit(1);
515inline static unsigned long*
initsevS (
const int maxnr)
517 return (
unsigned long*)
omAlloc0(maxnr*
sizeof(
unsigned long));
521 return (
int*)
omAlloc0(maxnr*
sizeof(
int));
525 int &
length,
const int incr)
537 (
length+incr)*
sizeof(
long*));
555 for (
j=0;
j<=strat->
tl;
j++)
559 if (strat->
T[
j].max_exp !=
NULL)
569 if (strat->
T[
j].t_p !=
NULL)
577 if (
currRing->isLPring && strat->
T[
j].shift > 0)
586 if (
p == strat->
S[
i])
588 if (strat->
T[
j].t_p !=
NULL)
590 if (p_shallow_copy_delete!=
NULL)
614 for (
j=0;
j<=strat->
tl;
j++)
618 if (strat->
T[
j].max_exp !=
NULL)
628 if (strat->
T[
j].t_p !=
NULL)
640 if (
p == strat->
S[
i])
642 if (strat->
T[
j].t_p !=
NULL)
689 if ((*
k) < 0)
return FALSE;
690 if (((p1 == (*p).p1) && (p2 == (*p).p2))
691 || ((p1 == (*p).p2) && (p2 == (*p).p1)))
710 if ((*
k) < 0)
return FALSE;
722 for (
i=0;
i<=tlength;
i++)
724 if (
T[
i].
p ==
p)
return i;
735 if (
i >= 0)
return i;
738 while (strat !=
NULL);
747 for (
i=0;
i<=tlength;
i++)
763 if (
i >= 0)
return i;
766 while (strat !=
NULL);
780#define kFalseReturn(x) do { if (!x) return FALSE;} while (0)
786 for (
i=1;
i<=tailRing->N;
i++)
789 return "Lm[i] different";
792 return "Lm[0] different";
794 return "Lm.next different";
796 return "Lm.coeff different";
803 ring tailRing =
T->tailRing;
804 if (strat_tailRing ==
NULL) strat_tailRing = tailRing;
805 r_assume(strat_tailRing == tailRing);
827 if (
T->t_p ==
NULL &&
i > 0)
844 if (
T->t_p !=
NULL &&
i >= 0 && TN ==
'T')
848 if (
T->max_exp !=
NULL)
849 return dReportError(
"%c[%d].max_exp is not NULL as it should be", TN,
i);
853 if (
T->max_exp ==
NULL)
865 p_Setm(test_max, tailRing);
877 if (
T->p ==
NULL &&
i > 0)
893 if ((
i >= 0) && (
T->pLength != 0)
898 return dReportError(
"%c[%d] pLength error: has %d, specified to have %d",
903 if (
i >= 0 && (TN ==
'T' || TN ==
'L'))
906 if (
T->FDeg !=
T->pFDeg())
910 return dReportError(
"%c[%d] FDeg error: has %d, specified to have %d",
911 TN,
i ,
T->pFDeg(), d);
916 if (
i >= 0 && TN ==
'T')
952 if (L->bucket !=
NULL)
955 r_assume(L->bucket->bucket_ring == L->tailRing);
973 return dReportError(
"L[%d] wrong sev: has %lo, specified to have %lo",
983 else if (tlength > 0 &&
T !=
NULL && (lpos >=0))
1016 -1, strat->
T, strat->
tl));
1019 if (strat->
T !=
NULL)
1021 for (
i=0;
i<=strat->
tl;
i++)
1030 if (strat->
L !=
NULL)
1032 for (
i=0;
i<=strat->
Ll;
i++)
1035 strat->
L[
i].Next() != strat->
tail,
i,
1036 strat->
T, strat->
tl));
1047 if (strat->
S !=
NULL)
1057 for (
i=0;
i<=strat->
sl;
i++)
1059 if (strat->
S[
i] !=
NULL &&
1062 return dReportError(
"S[%d] wrong sev: has %o, specified to have %o",
1078 for (
i=0;
i<=strat->
tl;
i++)
1080 if (strat->
T[
i].i_r < 0 || strat->
T[
i].i_r > strat->
tl)
1081 return dReportError(
"strat->T[%d].i_r == %d out of bounds",
i,
1083 if (strat->
R[strat->
T[
i].i_r] != &(strat->
T[
i]))
1087 if ((strat->
S !=
NULL)&&(strat->
tl>=0))
1089 for (
i=0;
i<=strat->
sl;
i++)
1094 if (strat->
S_2_R[
i] != strat->
T[
j].i_r)
1100 #ifdef HAVE_SHIFTBBA
1105 for (
i=0;
i<=strat->
Ll;
i++)
1107 if (strat->
L[
i].p1 !=
NULL && strat->
L[
i].p2)
1109 if (strat->
L[
i].i_r1 < 0 ||
1110 strat->
L[
i].i_r1 > strat->
tl ||
1111 strat->
L[
i].T_1(strat)->p != strat->
L[
i].p1)
1113 if (strat->
L[
i].i_r2 < 0 ||
1114 strat->
L[
i].i_r2 > strat->
tl ||
1115 strat->
L[
i].T_2(strat)->p != strat->
L[
i].p2)
1120 if (strat->
L[
i].i_r1 != -1)
1122 if (strat->
L[
i].i_r2 != -1)
1125 if (strat->
L[
i].i_r != -1)
1139#ifdef ENTER_USE_MEMMOVE
1140 memmove(&(strat->
S[
i]), &(strat->
S[
i+1]), (strat->
sl -
i)*
sizeof(poly));
1142 memmove(&(strat->
sevS[
i]),&(strat->
sevS[
i+1]),(strat->
sl -
i)*
sizeof(
unsigned long));
1143 memmove(&(strat->
S_2_R[
i]),&(strat->
S_2_R[
i+1]),(strat->
sl -
i)*
sizeof(
int));
1146 for (
j=
i;
j<strat->
sl;
j++)
1148 strat->
S[
j] = strat->
S[
j+1];
1156#ifdef ENTER_USE_MEMMOVE
1157 memmove(&(strat->
lenS[
i]),&(strat->
lenS[
i+1]),(strat->
sl -
i)*
sizeof(
int));
1164#ifdef ENTER_USE_MEMMOVE
1172#ifdef ENTER_USE_MEMMOVE
1173 memmove(&(strat->
fromQ[
i]),&(strat->
fromQ[
i+1]),(strat->
sl -
i)*
sizeof(
int));
1175 for (
j=
i;
j<strat->
sl;
j++)
1191#ifdef ENTER_USE_MEMMOVE
1192 memmove(&(strat->
S[
i]), &(strat->
S[
i+1]), (strat->
sl -
i)*
sizeof(poly));
1193 memmove(&(strat->
sig[
i]), &(strat->
sig[
i+1]), (strat->
sl -
i)*
sizeof(poly));
1195 memmove(&(strat->
sevS[
i]),&(strat->
sevS[
i+1]),(strat->
sl -
i)*
sizeof(
unsigned long));
1196 memmove(&(strat->
sevSig[
i]),&(strat->
sevSig[
i+1]),(strat->
sl -
i)*
sizeof(
unsigned long));
1197 memmove(&(strat->
S_2_R[
i]),&(strat->
S_2_R[
i+1]),(strat->
sl -
i)*
sizeof(
int));
1200 for (
j=
i;
j<strat->
sl;
j++)
1202 strat->
S[
j] = strat->
S[
j+1];
1212#ifdef ENTER_USE_MEMMOVE
1213 memmove(&(strat->
lenS[
i]),&(strat->
lenS[
i+1]),(strat->
sl -
i)*
sizeof(
int));
1220#ifdef ENTER_USE_MEMMOVE
1228#ifdef ENTER_USE_MEMMOVE
1229 memmove(&(strat->
fromQ[
i]),&(strat->
fromQ[
i+1]),(strat->
sl -
i)*
sizeof(
int));
1231 for (
j=
i;
j<strat->
sl;
j++)
1250 if (set[
j].sig!=
NULL)
1284#ifdef ENTER_USE_MEMMOVE
1288 for (
i=
j;
i < (*length);
i++)
1310#ifdef ENTER_USE_MEMMOVE
1311 memmove(&((*set)[at+1]), &((*set)[at]), ((*
length)-at+1)*
sizeof(
LObject));
1313 for (
i=(*
length)+1;
i>=at+1;
i--) (*set)[
i] = (*set)[
i-1];
1327 h->FDeg =
h->pFDeg();
1328 h->ecart =
h->pLDeg() -
h->FDeg;
1335 h->FDeg =
h->pFDeg();
1342 Lp->FDeg = Lp->pFDeg();
1349 Lp->FDeg = Lp->pFDeg();
1350 (*Lp).ecart =
si_max(ecartF,ecartG);
1351 (*Lp).ecart = (*Lp).ecart- (Lp->FDeg -
p_FDeg((*Lp).lcm,
currRing));
1360 return (ecart1 <= ecart2);
1392 int j,compare,compareCoeff;
1396 h.ecart=0;
h.length=0;
1420 for(
j = strat->
Bl;
j>=0;
j--)
1541 h.i_r1 = -1;
h.i_r2 = -1;
1557 posx = strat->
posInL(strat->
B,strat->
Bl,&
h,strat);
1562 else strat->
P.sev=0L;
1576 poly m1, m2,
gcd,si;
1605 for (
int j = 0;
j < strat->
sl;
j++)
1611 && !(strat->
sevS[
j] & ~sev)
1654 PrintS(
"\n--- create strong gcd poly: ");
1657 Print(
"\n strat->S[%d]: ",
i);
1681 h.i_r1 = -1;
h.i_r2 = -1;
1687 h.p1 =
p;
h.p2 = strat->
S[
i];
1702 posx = strat->
posInL(strat->
L,strat->
Ll,&
h,strat);
1707 if(
h.IsNull())
return FALSE;
1724 if(strat->
sl < 0)
return FALSE;
1726 for(
i=0;
i<strat->
sl;
i++)
1762 h->i_r1 = -1;
h->i_r2 = -1;
1784 poly m1, m2,
gcd,si;
1832 PrintS(
"\n--- create strong gcd poly: ");
1835 Print(
"\n strat->S[%d]: ",
i);
1859 if(
pLmCmp(pSigMult,sSigMult) == 0)
1868 if(
pLtCmp(pSigMult,sSigMult)==1)
1888 h.i_r1 = -1;
h.i_r2 = -1;
1896 int red_result =
redRing(&
h,strat);
1906 strat->
enterS(strat->
P,strat->
sl+1,strat, strat->
tl+1);
1923 int red_result =
redRing(&
h,strat);
1933 strat->
enterS(strat->
P,strat->
sl+1,strat, strat->
tl+1);
1946 strat->
enterS(strat->
P,strat->
sl+1,strat, strat->
tl+1);
1950 h.p1 =
p;
h.p2 = strat->
S[
i];
1984 Lp.ecart=0; Lp.length=0;
1989#ifndef HAVE_RATGRING
1991#elif defined(HAVE_RATGRING)
2008 if((!((strat->
ecartS[
i]>0)&&(ecart>0)))
2101 for(
j = strat->
Bl;
j>=0;
j--)
2200 Lp.p1 = strat->
S[
i];
2214 Lp.i_r1 = strat->
S_2_R[
i];
2228 && (Lp.p->coef!=
NULL))
2232 l = strat->
posInL(strat->
B,strat->
Bl,&Lp,strat);
2272 Lp.ecart=0; Lp.length=0;
2279 if((!((strat->
ecartS[
i]>0)&&(ecart>0)))
2375 for(
j = strat->
Bl;
j>=0;
j--)
2431 Lp.p1 = strat->
S[
i];
2438 Lp.i_r1 = strat->
S_2_R[
i];
2452 && (Lp.p->coef!=
NULL))
2456 l = strat->
posInL(strat->
B,strat->
Bl,&Lp,strat);
2480 unsigned long pSigMultNegSev,sSigMultNegSev;
2484 Lp.ecart=0; Lp.length=0;
2489#ifndef HAVE_RATGRING
2491#elif defined(HAVE_RATGRING)
2515 pSigMultNegSev = ~p_GetShortExpVector(pSigMult,
currRing);
2517 sSigMultNegSev = ~p_GetShortExpVector(sSigMult,
currRing);
2521 PrintS(
"----------------\n");
2524 PrintS(
"----------------\n");
2530 Print(
"IN PAIR GENERATION - COMPARING SIGS: %d\n",sigCmp);
2551 if ( strat->
syzCrit(pSigMult,pSigMultNegSev,strat) ||
2552 strat->
syzCrit(sSigMult,sSigMultNegSev,strat)
2553 || strat->
rewCrit1(sSigMult,sSigMultNegSev,Lp.lcm,strat,
i+1)
2630 Lp.sevSig = ~pSigMultNegSev;
2637 Lp.sevSig = ~sSigMultNegSev;
2648 if (strat->
rewCrit3(Lp.sig,~Lp.sevSig,Lp.p,strat,strat->
sl+1))
2662 Lp.checked = strat->
sl+1;
2669 Lp.prod_crit =
TRUE;
2681 PrintS(
"SIGNATURE OF PAIR: ");
2685 Lp.p1 = strat->
S[
i];
2699 Lp.i_r1 = strat->
S_2_R[
i];
2713 && (Lp.p->coef!=
NULL))
2755 unsigned long pSigMultNegSev,sSigMultNegSev;
2759 Lp.ecart=0; Lp.length=0;
2764#ifndef HAVE_RATGRING
2766#elif defined(HAVE_RATGRING)
2802 if(pSigMult !=
NULL)
2803 pSigMultNegSev = ~p_GetShortExpVector(pSigMult,
currRing);
2805 if(sSigMult !=
NULL)
2806 sSigMultNegSev = ~p_GetShortExpVector(sSigMult,
currRing);
2809 Print(
"----------------\n");
2812 Print(
"----------------\n");
2816 if(pSigMult !=
NULL && sSigMult !=
NULL)
2825 if(pSigMult ==
NULL)
2827 if(sSigMult ==
NULL)
2837 Print(
"IN PAIR GENERATION - COMPARING SIGS: %d\n",sigCmp);
2859 int red_result =
redRing(&Lp,strat);
2869 strat->
enterS(strat->
P,strat->
sl+1,strat, strat->
tl+1);
2871 strat->
enterS(Lp,0,strat,strat->
tl);
2885 Lp.sig =
pCopy(pSigMult);
2914 if ( strat->
syzCrit(pSigMult,pSigMultNegSev,strat) ||
2915 strat->
syzCrit(sSigMult,sSigMultNegSev,strat)
2997 Lp.sig =
pNeg(Lp.sig);
3008 Lp.sevSig = ~pSigMultNegSev;
3015 Lp.sevSig = ~sSigMultNegSev;
3027 if (strat->
rewCrit3(Lp.sig,~Lp.sevSig,Lp.p,strat,strat->
sl+1))
3041 Lp.checked = strat->
sl+1;
3048 Lp.prod_crit =
TRUE;
3060 PrintS(
"SIGNATURE OF PAIR: ");
3064 Lp.p1 = strat->
S[
i];
3079 Lp.i_r1 = strat->
S_2_R[
i];
3093 && (Lp.p->coef!=
NULL))
3101 int red_result =
redRing(&Lp,strat);
3111 strat->
enterS(strat->
P,strat->
sl+1,strat, strat->
tl+1);
3114 strat->
enterS(Lp,0,strat, strat->
tl+1);
3166 Lp.p1 = strat->
S[
i];
3170 Lp.i_r1 = strat->
S_2_R[
i];
3185 && (Lp.p->coef!=
NULL))
3188 l = strat->
posInL(strat->
L,strat->
Ll,&Lp,strat);
3199 int j=strat->
Ll+strat->
Bl+1;
3207 for (
i=strat->
Bl;
i>=0;
i--)
3209 j = strat->
posInL(strat->
L,
j,&(strat->
B[
i]),strat);
3220 int j=strat->
Ll+strat->
Bl+1;
3228 for (
i=strat->
Bl;
i>=0;
i--)
3255 for (
j=0;
j<=strat->
sl;
j++)
3259 for (
i=strat->
Bl;
i>=0;
i--)
3274 for (
j=0;
j<=strat->
sl;
j++)
3278 for (
i=strat->
Bl;
i>=0;
i--)
3301 for (
j=strat->
Ll;
j>=0;
j--)
3307 if (strat->
L[
j].p == strat->
tail)
3353 for (
j=strat->
Ll;
j>=0;
j--)
3373 for(
i=
j-1;
i>=0;
i--)
3392 for (
j=strat->
Ll;
j>=0;
j--)
3423 if (strat->
L[0].p2 == strat->
tail) strat->
L[0].p2 =
p;
3426 if (strat->
L[
j].p2 ==
p)
3432 if ((strat->
L[
i].p2 ==
p) &&
pLmEqual(strat->
L[
j].lcm,strat->
L[
i].lcm))
3446 strat->
L[
i].p2 = strat->
tail;
3463 else if (strat->
L[
j].p2 == strat->
tail)
3502 if (strat->
L[0].p2 == strat->
tail) strat->
L[0].p2 =
p;
3505 if (strat->
L[
j].p2 ==
p)
3511 if ((strat->
L[
i].p2 ==
p) &&
pLmEqual(strat->
L[
j].lcm,strat->
L[
i].lcm))
3525 strat->
L[
i].p2 = strat->
tail;
3542 else if (strat->
L[
j].p2 == strat->
tail)
3563 for (
j=0;
j<=strat->
sl;
j++)
3567 for (
i=strat->
Bl;
i>=0;
i--)
3575 Print(
"chain-crit-part: S[%d]=",
j);
3577 Print(
" divide B[%d].lcm=",
i);
3599 for (
j=strat->
Ll;
j>=0;
j--)
3605 if (strat->
L[
j].p == strat->
tail)
3609 PrintS(
"chain-crit-part: pCompareChainPart p=");
3611 Print(
" delete L[%d]",
j);
3640 Print(
"chain-crit-part: sugar B[%d].lcm=",
j);
3642 Print(
" delete B[%d]",
i);
3653 Print(
"chain-crit-part: sugar B[%d].lcm=",
i);
3655 Print(
" delete B[%d]",
j);
3675 for (
j=strat->
Ll;
j>=0;
j--)
3683 PrintS(
"chain-crit-part: sugar:pCompareChainPart p=");
3685 Print(
" delete L[%d]",
j);
3703 for(
i=
j-1;
i>=0;
i--)
3709 Print(
"chain-crit-part: equal lcm B[%d].lcm=",
j);
3711 Print(
" delete B[%d]\n",
i);
3728 for (
j=strat->
Ll;
j>=0;
j--)
3736 PrintS(
"chain-crit-part: pCompareChainPart p=");
3738 Print(
" delete L[%d]",
j);
3767 if (strat->
L[0].p2 == strat->
tail) strat->
L[0].p2 =
p;
3770 if (strat->
L[
j].p2 ==
p)
3776 if ((strat->
L[
i].p2 ==
p) &&
pLmEqual(strat->
L[
j].lcm,strat->
L[
i].lcm))
3793 strat->
L[
i].p2 = strat->
tail;
3800 PrintS(
"chain-crit-part: divisible_by p=");
3802 Print(
" delete L[%d]",
l);
3813 PrintS(
"chain-crit-part: divisible_by(2) p=");
3815 Print(
" delete L[%d]",
i);
3826 else if (strat->
L[
j].p2 == strat->
tail)
3854 for (
j=0;
j<=
k;
j++)
3867 for (
j=0;
j<=
k;
j++)
3876 for (
j=0;
j<=
k;
j++)
3889 #ifdef HAVE_RATGRING
3919 for (
j=0;
j<=
k;
j++)
3932 for (
j=0;
j<=
k;
j++)
3941 for (
j=0;
j<=
k;
j++)
4039 for (
j=0;
j<=strat->
sl;
j++)
4043 for (
i=strat->
Bl;
i>=0;
i--)
4050 PrintS(
"--- chain criterion func chainCritRing type 1\n");
4053 PrintS(
" strat->B[i].lcm:");
4058 wrp(strat->
B[
i].lcm);
4073 for (
j=strat->
Ll;
j>=0;
j--)
4086 PrintS(
"--- chain criterion func chainCritRing type 2\n");
4087 PrintS(
"strat->L[j].p:");
4118 if (strat->
L[0].p2 == strat->
tail) strat->
L[0].p2 =
p;
4121 if (strat->
L[
j].p2 ==
p)
4136 PrintS(
"--- chain criterion func chainCritRing type 3\n");
4137 PrintS(
"strat->L[j].lcm:");
4138 wrp(strat->
L[
j].lcm);
4139 PrintS(
" strat->L[i].lcm:");
4140 wrp(strat->
L[
i].lcm);
4154 strat->
L[
i].p2 = strat->
tail;
4171 else if (strat->
L[
j].p2 == strat->
tail)
4197 for (
j=0;
j<=
k;
j++)
4209 for (
j=0;
j<=
k;
j++)
4217 for (
j=0;
j<=
k;
j++)
4229 #ifdef HAVE_RATGRING
4254 && ((iCompH<=strat->syzComp)||(strat->
syzComp==0)))
4301 PrintS(
"--- create zero spoly: ");
4330 posx = strat->
posInL(strat->
L,strat->
Ll,&Lp,strat);
4383 PrintS(
"--- create zero spoly: ");
4411 int red_result =
redRing(&Lp,strat);
4421 strat->
enterS(strat->
P,strat->
sl+1,strat, strat->
tl+1);
4423 strat->
enterS(Lp,0,strat,strat->
tl);
4471 if ( (!strat->
fromT)
4531 if ( (!strat->
fromT)
4556 if ( (!strat->
fromT)
4581 for (
j=0;
j<=
k;
j++)
4584 if ((iCompH==iCompSj)
4595 for (
j=0;
j<=
k;
j++)
4598 if ((iCompH==iCompSj)
4650 int i,
j,at,ecart, s2r;
4654 int new_suc=strat->
sl+1;
4658 for (;
i<=strat->
sl;
i++)
4663 if (new_suc > at) new_suc = at;
4666 sev = strat->
sevS[
i];
4669 for (
j=
i;
j>=at+1;
j--)
4671 strat->
S[
j] = strat->
S[
j-1];
4677 strat->
ecartS[at] = ecart;
4678 strat->
sevS[at] = sev;
4679 strat->
S_2_R[at] = s2r;
4682 for (
j=
i;
j>=at+1;
j--)
4686 strat->
fromQ[at]=fq;
4690 if (new_suc <= strat->sl) *suc=new_suc;
4753 if (cmp == cmp_int)
return an;
4754 if (cmp == -cmp_int)
return en;
4760 if (cmp == cmp_int) en =
i;
4761 else if (cmp == -cmp_int) an =
i;
4777 if (
pLmCmp(set[an],
p) == cmp_int)
return an;
4778 if (
pLmCmp(set[an],
p) == -cmp_int)
return en;
4780 && ((strat->
ecartS[an])>ecart_p))
4786 else if (
pLmCmp(set[
i],
p) == -cmp_int) an=
i;
4790 &&((strat->
ecartS[
i])<ecart_p))
4818 || ((op == o) && (
pLtCmp(set[mon],
p) == -1)))
4829 || ((op == o) && (
pLtCmp(set[an],
p) == -1)))
4836 || ((op == o) && (
pLtCmp(set[
i],
p) == -1)))
4862 || ((op == o) && (
pLtCmp(set[an],
p) == -1)))
4869 || ((op == o) && (
pLtCmp(set[
i],
p) == -1)))
4881 if(end < 0 || end >=
IDELEMS(F))
4883 if (end<0)
return 0;
4890 for(
i=start;
i<end;
i++)
4904 || ((op == o) && (
pLtCmp(set[an],
p) == -1)))
4911 || ((op == o) && (
pLtCmp(set[
i],
p) == -1)))
4936 if (
length==-1)
return 0;
4964 if (
length==-1)
return 0;
4976 if (set[an].
length>
p.length)
return an;
4992 if (
length==-1)
return 0;
4994 int o =
p.GetpFDeg();
4995 int op = set[
length].GetpFDeg();
5009 op= set[an].GetpFDeg();
5016 op = set[
i].GetpFDeg();
5028 if (
length==-1)
return 0;
5030 int o =
p.GetpFDeg();
5031 int op = set[
length].GetpFDeg();
5045 op= set[an].GetpFDeg();
5052 op = set[
i].GetpFDeg();
5069 if (
length==-1)
return 0;
5070 int o =
p.GetpFDeg();
5071 int op = set[
length].GetpFDeg();
5083 op = set[an].GetpFDeg();
5084 if (op > o)
return an;
5085 if (op < 0)
return en;
5087 if (cmp == cmp_int)
return an;
5088 if (cmp == -cmp_int)
return en;
5093 op = set[
i].GetpFDeg();
5095 else if (op < o) an =
i;
5099 if (cmp == cmp_int) en =
i;
5100 else if (cmp == -cmp_int) an =
i;
5145 if (
length==-1)
return 0;
5148 int o =
p.GetpFDeg();
5149 int op = set[
length].GetpFDeg();
5153 || (( op == o) && (set[
length].length ==
p.length)
5164 op = set[an].GetpFDeg();
5166 || (( op == o) && (set[an].
length >
p.length))
5167 || (( op == o) && (set[an].length ==
p.length)
5173 op = set[
i].GetpFDeg();
5175 || (( op == o) && (set[
i].
length >
p.length))
5176 || (( op == o) && (set[
i].length ==
p.length)
5187 if (
length==-1)
return 0;
5190 int o =
p.GetpFDeg();
5191 int op = set[
length].GetpFDeg();
5195 || (( op == o) && (set[
length].length ==
p.length)
5206 op = set[an].GetpFDeg();
5208 || (( op == o) && (set[an].
length >
p.length))
5209 || (( op == o) && (set[an].length ==
p.length)
5215 op = set[
i].GetpFDeg();
5217 || (( op == o) && (set[
i].
length >
p.length))
5218 || (( op == o) && (set[
i].length ==
p.length)
5234 if (
length==-1)
return 0;
5236 int o =
p.GetpFDeg();
5238 if (set[
length].GetpFDeg() <= o)
5248 if (set[an].GetpFDeg() > o)
5253 if (set[
i].GetpFDeg() > o)
5263 if (
length==-1)
return 0;
5264 int ol =
p.GetpLength();
5266 int oo=set[
length].ecart;
5268 if ((oo < op) || ((oo==op) && (set[
length].
length <= ol)))
5278 int oo=set[an].ecart;
5280 || ((oo==op) && (set[an].
pLength > ol)))
5285 int oo=set[
i].ecart;
5287 || ((oo == op) && (set[
i].
pLength > ol)))
5319 if (
length==-1)
return 0;
5321 int o =
p.GetpFDeg() +
p.ecart;
5336 op = set[an].GetpFDeg()+set[an].ecart;
5343 op = set[
i].GetpFDeg()+set[
i].ecart;
5355 if (
length==-1)
return 0;
5357 int o =
p.GetpFDeg() +
p.ecart;
5372 op = set[an].GetpFDeg()+set[an].ecart;
5379 op = set[
i].GetpFDeg()+set[
i].ecart;
5416 if (
length==-1)
return 0;
5418 int o =
p.GetpFDeg() +
p.ecart;
5422 || (( op == o) && (set[
length].ecart >
p.ecart))
5423 || (( op == o) && (set[
length].ecart==
p.ecart)
5434 op = set[an].GetpFDeg()+set[an].ecart;
5436 || (( op == o) && (set[an].ecart <
p.ecart))
5437 || (( op == o) && (set[an].ecart==
p.ecart)
5443 op = set[
i].GetpFDeg()+set[
i].ecart;
5445 || (( op == o) && (set[
i].ecart <
p.ecart))
5446 || (( op == o) && (set[
i].ecart ==
p.ecart)
5457 if (
length==-1)
return 0;
5459 int o =
p.GetpFDeg() +
p.ecart;
5463 || (( op == o) && (set[
length].ecart >
p.ecart))
5464 || (( op == o) && (set[
length].ecart==
p.ecart)
5475 op = set[an].GetpFDeg()+set[an].ecart;
5477 || (( op == o) && (set[an].ecart <
p.ecart))
5478 || (( op == o) && (set[an].ecart==
p.ecart)
5484 op = set[
i].GetpFDeg()+set[
i].ecart;
5486 || (( op == o) && (set[
i].ecart <
p.ecart))
5487 || (( op == o) && (set[
i].ecart ==
p.ecart)
5503 if (
length==-1)
return 0;
5507 int o =
p.GetpFDeg() +
p.ecart;
5516 || ((op == o) && (set[
length].ecart >
p.ecart))
5517 || ((op == o) && (set[
length].ecart==
p.ecart)
5533 int op = set[an].GetpFDeg()+set[an].ecart;
5535 || ((op == o) && (set[an].ecart <
p.ecart))
5536 || ((op == o) && (set[an].ecart==
p.ecart)
5547 int op = set[
i].GetpFDeg()+set[
i].ecart;
5549 || ((op == o) && (set[
i].ecart <
p.ecart))
5550 || ((op == o) && (set[
i].ecart ==
p.ecart)
5564 if (
length==-1)
return 0;
5568 int o =
p.GetpFDeg() +
p.ecart;
5577 || ((op == o) && (set[
length].ecart >
p.ecart))
5578 || ((op == o) && (set[
length].ecart==
p.ecart)
5594 int op = set[an].GetpFDeg()+set[an].ecart;
5596 || ((op == o) && (set[an].ecart <
p.ecart))
5597 || ((op == o) && (set[an].ecart==
p.ecart)
5608 int op = set[
i].GetpFDeg()+set[
i].ecart;
5610 || ((op == o) && (set[
i].ecart <
p.ecart))
5611 || ((op == o) && (set[
i].ecart ==
p.ecart)
5631 if (
length==-1)
return 0;
5634 int op=
p.GetpFDeg();
5636 if (set[
length].ecart < o)
5638 if (set[
length].ecart == o)
5640 int oo=set[
length].GetpFDeg();
5641 if ((oo < op) || ((oo==op) && (set[
length].
length <
p.length)))
5652 if (set[an].ecart > o)
5654 if (set[an].ecart == o)
5656 int oo=set[an].GetpFDeg();
5658 || ((oo==op) && (set[an].
length >
p.length)))
5664 if (set[
i].ecart > o)
5666 else if (set[
i].ecart == o)
5668 int oo=set[
i].GetpFDeg();
5670 || ((oo == op) && (set[
i].
length >
p.length)))
5690 int d=
p->GetpFDeg();
5691 int op=set[
length].GetpFDeg();
5705 op=set[an].GetpFDeg();
5707 || ((op == d) && (
p->p1!=
NULL) && (set[an].p1==
NULL))
5713 op=set[
i].GetpFDeg();
5715 || ((op==d) && (
p->p1!=
NULL) && (set[
i].p1==
NULL))
5828 cmp =
pLtCmp(set[an].sig,
p->sig);
5835 if (set[an].FDeg >
p->FDeg)
5837 if (set[an].FDeg < p->FDeg)
5839 if (set[an].FDeg ==
p->FDeg)
5857 if (set[
i].FDeg >
p->FDeg)
5859 if (set[
i].FDeg < p->FDeg)
5861 if (set[
i].FDeg ==
p->FDeg)
5876 if (
length < 0)
return 0;
5877 if (set[
length].FDeg >
p->FDeg)
5879 if (set[
length].FDeg ==
p->FDeg)
5880 if(set[
length].GetpLength() >
p->GetpLength())
5891 if (set[an].FDeg >
p->FDeg)
5893 if(set[an].FDeg ==
p->FDeg)
5895 if(set[an].GetpLength() >
p->GetpLength())
5899 if(set[an].GetpLength() ==
p->GetpLength())
5916 if (set[
i].FDeg >
p->FDeg)
5920 if(set[
i].FDeg ==
p->FDeg)
5922 if(set[
i].GetpLength() >
p->GetpLength())
5926 if(set[
i].GetpLength() ==
p->GetpLength())
5948 if (strat->
syzl==0)
return 0;
5953 int en= strat->
syzl-1;
5991 int o =
p->GetpFDeg();
5992 int op = set[
length].GetpFDeg();
6004 op = set[an].GetpFDeg();
6011 op = set[
i].GetpFDeg();
6033 int o =
p->GetpFDeg();
6034 int op = set[
length].GetpFDeg();
6046 op = set[an].GetpFDeg();
6053 op = set[
i].GetpFDeg();
6067 int o =
p->GetpFDeg();
6068 int op = set[
length].GetpFDeg();
6080 op = set[an].GetpFDeg();
6087 op = set[
i].GetpFDeg();
6101 if (
length < 0)
return 0;
6111 if (set[an].FDeg >
p->FDeg)
6113 if (set[an].FDeg < p->FDeg)
6115 if (set[an].FDeg ==
p->FDeg)
6123 if (set[an].t_p!=
NULL)
6145 if (set[
i].FDeg >
p->FDeg)
6147 if (set[
i].FDeg < p->FDeg)
6149 if (set[
i].FDeg ==
p->FDeg)
6157 if (set[
i].t_p!=
NULL)
6189 if (coeff == 0)
return -1;
6192 while (tmp % 2 == 0)
6211 if (
length < 0)
return 0;
6213 int o =
p->GetpFDeg();
6214 int op = set[
length].GetpFDeg();
6225 op = set[an].GetpFDeg();
6226 if ((op > o) || ((op == o) && (
pLmCmp(set[an].
p,
p->p) != -
currRing->OrdSgn)))
6231 op = set[
i].GetpFDeg();
6289 int o =
p->GetpFDeg();
6290 int op = set[
length].GetpFDeg();
6294 || ((op == o) && (set[
length].length <=
p->length)
6304 op = set[an].GetpFDeg();
6306 || ((op == o) && (set[an].
length >
p->length))
6307 || ((op == o) && (set[an].length <=
p->length)
6313 op = set[
i].GetpFDeg();
6315 || ((op == o) && (set[
i].
length >
p->length))
6316 || ((op == o) && (set[
i].length <=
p->length)
6330 int o =
p->GetpFDeg();
6331 int op = set[
length].GetpFDeg();
6335 || ((op == o) && (set[
length].length <=
p->length)
6345 op = set[an].GetpFDeg();
6347 || ((op == o) && (set[an].
length >
p->length))
6348 || ((op == o) && (set[an].length <=
p->length)
6354 op = set[
i].GetpFDeg();
6356 || ((op == o) && (set[
i].
length >
p->length))
6357 || ((op == o) && (set[
i].length <=
p->length)
6377 int o =
p->GetpFDeg();
6379 if (set[
length].GetpFDeg() > o)
6389 if (set[an].GetpFDeg() >= o)
6394 if (set[
i].GetpFDeg() >= o)
6412 int o =
p->GetpFDeg() +
p->ecart;
6425 op = set[an].GetpFDeg() + set[an].ecart;
6432 op = set[
i].GetpFDeg() + set[
i].ecart;
6447 int o =
p->GetpFDeg() +
p->ecart;
6460 op = set[an].GetpFDeg() + set[an].ecart;
6467 op = set[
i].GetpFDeg() + set[
i].ecart;
6488 int o =
p->GetpFDeg() +
p->ecart;
6492 && (set[
length].ecart >
p->ecart))
6494 && (set[
length].ecart ==
p->ecart)
6504 if ((set[an].GetpFDeg() + set[an].ecart > o)
6505 || ((set[an].GetpFDeg() + set[an].ecart == o)
6506 && (set[an].ecart >
p->ecart))
6507 || ((set[an].GetpFDeg() + set[an].ecart == o)
6508 && (set[an].ecart ==
p->ecart)
6514 if ((set[
i].GetpFDeg() + set[
i].ecart > o)
6515 || ((set[
i].GetpFDeg() + set[
i].ecart == o)
6516 && (set[
i].ecart >
p->ecart))
6517 || ((set[
i].GetpFDeg() +set[
i].ecart == o)
6518 && (set[
i].ecart ==
p->ecart)
6532 int o =
p->GetpFDeg() +
p->ecart;
6536 && (set[
length].ecart >
p->ecart))
6538 && (set[
length].ecart ==
p->ecart)
6548 if ((set[an].GetpFDeg() + set[an].ecart > o)
6549 || ((set[an].GetpFDeg() + set[an].ecart == o)
6550 && (set[an].ecart >
p->ecart))
6551 || ((set[an].GetpFDeg() + set[an].ecart == o)
6552 && (set[an].ecart ==
p->ecart)
6558 if ((set[
i].GetpFDeg() + set[
i].ecart > o)
6559 || ((set[
i].GetpFDeg() + set[
i].ecart == o)
6560 && (set[
i].ecart >
p->ecart))
6561 || ((set[
i].GetpFDeg() +set[
i].ecart == o)
6562 && (set[
i].ecart ==
p->ecart)
6585 int o =
p->GetpFDeg() +
p->ecart;
6593 && (set[
length].ecart >
p->ecart))
6595 && (set[
length].ecart ==
p->ecart)
6610 if ((set[an].GetpFDeg() + set[an].ecart > o)
6611 || ((set[an].GetpFDeg() + set[an].ecart == o)
6612 && (set[an].ecart >
p->ecart))
6613 || ((set[an].GetpFDeg() + set[an].ecart == o)
6614 && (set[an].ecart ==
p->ecart)
6625 if ((set[
i].GetpFDeg() + set[
i].ecart > o)
6626 || ((set[
i].GetpFDeg() + set[
i].ecart == o)
6627 && (set[
i].ecart >
p->ecart))
6628 || ((set[
i].GetpFDeg() +set[
i].ecart == o)
6629 && (set[
i].ecart ==
p->ecart)
6649 int o =
p->GetpFDeg() +
p->ecart;
6657 && (set[
length].ecart >
p->ecart))
6659 && (set[
length].ecart ==
p->ecart)
6674 if ((set[an].GetpFDeg() + set[an].ecart > o)
6675 || ((set[an].GetpFDeg() + set[an].ecart == o)
6676 && (set[an].ecart >
p->ecart))
6677 || ((set[an].GetpFDeg() + set[an].ecart == o)
6678 && (set[an].ecart ==
p->ecart)
6689 if ((set[
i].GetpFDeg() + set[
i].ecart > o)
6690 || ((set[
i].GetpFDeg() + set[
i].ecart == o)
6691 && (set[
i].ecart >
p->ecart))
6692 || ((set[
i].GetpFDeg() +set[
i].ecart == o)
6693 && (set[
i].ecart ==
p->ecart)
6712 PrintS(
"syzygy criterion checks: ");
6715 for (
int k=0;
k<strat->
syzl;
k++)
6720 Print(
"checking with: %d / %d -- \n",
k,strat->
syzl);
6749 PrintS(
"--- syzygy criterion checks: ");
6774 Print(
"checking with: %d -- ",
k);
6799 PrintS(
"rewritten criterion checks: ");
6802 for(
int k = strat->
sl;
k>=start;
k--)
6806 PrintS(
"checking with: ");
6822 PrintS(
"ALL ELEMENTS OF S\n----------------------------------------\n");
6823 for(
int kk = 0; kk<strat->
sl+1; kk++)
6827 PrintS(
"------------------------------\n");
6857 for (
int ii=strat->
sl; ii>start; ii--)
6863 if (!(
pLmCmp(p1,p2) == 1))
6882 for (
int i=strat->
Bl;
i>-1;
i--)
6903 for (
int ii=strat->
sl; ii>-1; ii--)
6909 if (!(
pLmCmp(p1,p2) == 1))
6930 const unsigned long not_sev = ~L->sev;
6931 const unsigned long* sev = strat->
sevS;
6944 if (
j > end_pos)
return NULL;
6945 #if defined(PDEBUG) || defined(PDIV_DEBUG)
6947 (ecart== LONG_MAX || ecart>= strat->
ecartS[
j]))
6952 if (!(sev[
j] & not_sev) &&
6953 (ecart== LONG_MAX || ecart>= strat->
ecartS[
j]) &&
6967 if (
j > end_pos)
return NULL;
6968 #if defined(PDEBUG) || defined(PDIV_DEBUG)
6975 if (!(sev[
j] & not_sev) &&
6976 (ecart== LONG_MAX || ecart>= strat->
ecartS[
j]) &&
6987 if (strat->
tl < 0 || strat->
S_2_R[
j] == -1)
7008 if (
j > end_pos)
return NULL;
7010 #if defined(PDEBUG) || defined(PDIV_DEBUG)
7014 (ecart== LONG_MAX || ecart>= strat->
ecartS[
j]))
7020 if (! (sev[
j] & not_sev) && (ecart== LONG_MAX || ecart>= strat->
ecartS[
j]))
7023 assume(t !=
NULL && t->t_p !=
NULL && t->tailRing == r && t->p == strat->
S[
j]);
7039 if (
j > end_pos)
return NULL;
7041 #if defined(PDEBUG) || defined(PDIV_DEBUG)
7051 if (! (sev[
j] & not_sev) && (ecart== LONG_MAX || ecart>= strat->
ecartS[
j]))
7054 assume(t !=
NULL && t->t_p !=
NULL && t->tailRing == r && t->p == strat->
S[
j]);
7105 if (With ==
NULL)
break;
7115 return redtail(L, end_pos, strat);
7121 if (hn ==
NULL)
goto all_done;
7142 return redtail(&L, end_pos, strat);
7150 p =
h = L->GetLmTailRing();
7152 return L->GetLmCurrRing();
7187 Ln.SetShortExpVector();
7193 With = &(strat->
T[
j]);
7194 assume(With->GetpLength()==
pLength(With->p != __null ? With->p : With->t_p));
7199 if (With ==
NULL)
break;
7200 assume(With->GetpLength()==
pLength(With->p != __null ? With->p : With->t_p));
7227 pNext(
h) = Ln.LmExtractAndIter();
7230 }
while (!Ln.IsNull());
7233 if (Ln.IsNull())
goto all_done;
7234 if (! withT) With_s.Init(
currRing);
7236 pNext(
h) = Ln.LmExtractAndIter();
7255 return L->GetLmCurrRing();
7263 p =
h = L->GetLmTailRing();
7265 return L->GetLmCurrRing();
7272 Ln.pLength = L->GetpLength() - 1;
7296 Ln.SetShortExpVector();
7302 With = &(strat->
T[
j]);
7307 if (With ==
NULL)
break;
7334 pNext(
h) = Ln.LmExtractAndIter();
7337 }
while (!Ln.IsNull());
7349 if (! withT) With_s.Init(
currRing);
7351 pNext(
h) = Ln.LmExtractAndIter();
7370 return L->GetLmCurrRing();
7380 p =
h = L->GetLmTailRing();
7415 Ln.SetShortExpVector();
7428 With = &(strat->
T[
j]);
7429 assume(With->GetpLength()==
pLength(With->p != __null ? With->p : With->t_p));
7446 pNext(
h) = Ln.LmExtractAndIter();
7449 }
while (!Ln.IsNull());
7457 With = &(strat->
T[
j]);
7458 assume(With->GetpLength()==
pLength(With->p != __null ? With->p : With->t_p));
7475 pNext(
h) = Ln.LmExtractAndIter();
7478 }
while (!Ln.IsNull());
7482 if (Ln.IsNull())
goto all_done;
7484 pNext(
h) = Ln.LmExtractAndIter();
7509 p =
h = L->GetLmTailRing();
7511 return L->GetLmCurrRing();
7518 Ln.pLength = L->GetpLength() - 1;
7531 Ln.SetShortExpVector();
7533 if (With ==
NULL)
break;
7543 poly p_Ln=Ln.GetLmCurrRing();
7544 poly p_With=With->GetLmCurrRing();
7556 if (Ln.bucket!=
NULL)
7587 pNext(
h) = Ln.LmExtractAndIter();
7590 }
while (!Ln.IsNull());
7593 if (Ln.IsNull())
goto all_done;
7596 pNext(
h) = Ln.LmExtractAndIter();
7614 return L->GetLmCurrRing();
7623 p =
h = L->GetLmTailRing();
7625 return L->GetLmCurrRing();
7632 Ln.pLength = L->GetpLength() - 1;
7645 Ln.SetShortExpVector();
7648 if (With ==
NULL)
break;
7657 poly p_Ln=Ln.GetLmCurrRing();
7658 poly p_With=With->GetLmCurrRing();
7671 pNext(
h) = Ln.LmExtractAndIter();
7674 }
while (!Ln.IsNull());
7679 if (Ln.IsNull())
goto all_done;
7681 pNext(
h) = Ln.LmExtractAndIter();
7699 return L->GetLmCurrRing();
7715 if (strat->
Ll != *reduc)
7717 if (strat->
Ll != *reduc-1)
7729 if (red_result == 0)
7731 else if (red_result < 0)
7733 if ((red_result > 0) || ((strat->
Ll % 100)==99))
7735 if (strat->
Ll != *reduc && strat->
Ll > 0)
7752 Print(
"product criterion:%d chain criterion:%d\n",strat->
cp,strat->
c3);
7753 if (hilbcount!=0)
Print(
"hilbert series criterion:%d\n",hilbcount);
7754 #ifdef HAVE_SHIFTBBA
7756 if (strat->
cv!=0)
Print(
"shift V criterion:%d\n",strat->
cv);
7767 if (hilbcount!=0)
Print(
"hilbert series criterion:%d\n",hilbcount);
7768 #ifdef HAVE_SHIFTBBA
7770 if (strat->
cv!=0)
Print(
"shift V criterion:%d\n",strat->
cv);
7785 for (
i=0;
i<=strat->
sl;
i++)
7797 for (
i=0;
i<=strat->
tl;
i++)
7801 if (strat->
T[
i].length==0) strat->
T[
i].length=
pLength(strat->
T[
i].p);
7802 Print(
" o:%ld e:%d l:%d",
7803 strat->
T[
i].pFDeg(),strat->
T[
i].ecart,strat->
T[
i].length);
7808 for (
i=strat->
Ll;
i>=0;
i--)
7817 Print(
" o:%ld e:%d l:%d",
7818 strat->
L[
i].pFDeg(),strat->
L[
i].ecart,strat->
L[
i].length);
7840 strat->
S=strat->
Shdl->m;
7845 memset(strat->
fromQ,0,
i*
sizeof(
int));
7874 strat->
enterS(
h,pos,strat,-1);
7875 strat->
fromQ[pos]=1;
7908 strat->
enterS(
h,pos,strat,-1);
7934 strat->
S=strat->
Shdl->m;
7939 memset(strat->
fromQ,0,
i*
sizeof(
int));
7968 strat->
enterS(
h,pos,strat,-1);
7969 strat->
fromQ[pos]=1;
8001 pos = strat->
posInL(strat->
L,strat->
Ll,&
h,strat);
8031 strat->
S = strat->
Shdl->m;
8044 memset(strat->
fromQ,0,
i*
sizeof(
int));
8073 strat->
enterS(
h,pos,strat,-1);
8074 strat->
fromQ[pos]=1;
8184 for(
i=1;
i<=strat->
sl;
i++)
8196 strat->
syz = (poly *)
omAlloc(ps*
sizeof(poly));
8200#if defined(DEBUGF5) || defined(DEBUGF51)
8201 PrintS(
"------------- GENERATING SYZ RULES NEW ---------------\n");
8208 while (i <= strat->sl)
8238 for (
k = 0;
k<
i;
k++)
8282 for (
k = 0;
k<strat->
sl+1;
k++)
8303 PrintS(
"Principal syzygies:\n");
8306 Print(
"ps %d\n",ps);
8307 PrintS(
"--------------------------------\n");
8317 PrintS(
"--------------------------------\n");
8337 strat->
S=strat->
Shdl->m;
8343 memset(strat->
fromQ,0,
i*
sizeof(
int));
8372 strat->
enterS(
h,pos,strat, strat->
tl+1);
8374 strat->
fromQ[pos]=1;
8402 strat->
enterS(
h,pos,strat, strat->
tl+1);
8444 h.is_normalized = 0;
8451 strat->
enterS(
h,pos,strat, strat->
tl+1);
8481 strat->
S=strat->
Shdl->m;
8487 memset(strat->
fromQ,0,
i*
sizeof(
int));
8516 strat->
enterS(
h,pos,strat, strat->
tl+1);
8518 strat->
fromQ[pos]=1;
8546 strat->
enterS(
h,pos,strat, strat->
tl+1);
8588 h.is_normalized = 0;
8595 strat->
enterS(
h,pos,strat, strat->
tl+1);
8617 unsigned long not_sev = ~ pGetShortExpVector(
h);
8619 while (
j <= maxIndex)
8636 if (!
pIsVector((*p).p) && ((*p).ecart != 0))
8645 h1 = r =
pCopy((*p).p);
8697 unsigned long not_sev = ~ pGetShortExpVector(
h);
8698 while ((j <= strat->sl) && (
pGetComp(strat->
S[
j])!=0))
j++;
8700 while (j<=strat->sl)
8707 not_sev = ~ pGetShortExpVector(
h);
8722 unsigned long not_sev = ~ pGetShortExpVector(
h);
8724 while (
j <= maxIndex)
8731 not_sev = ~ pGetShortExpVector(
h);
8747 unsigned long not_sev = ~ pGetShortExpVector(
h);
8774 not_sev = ~ pGetShortExpVector(
h);
8778 while (
j <= maxIndex);
8808 while (i<=strat->sl)
8819 if (
pCmp(redSi,strat->
S[
i])!=0)
8876 if (any_change)
reorderS(&suc,strat);
8881 for (
i=0;
i<=strat->
sl;
i++)
8919 while (i<=strat->sl)
8931 else if (
pCmp((strat->
S)[
i],redSi)!=0)
8972 if (any_change)
reorderS(&suc,strat);
8973 else { suc=-1;
break; }
8984 for (
i=0;
i<=strat->
sl;
i++)
9012 if (suc!= -1)
updateS(toT,strat);
9032 *
sizeof(
unsigned long));
9059 strat->
Shdl->m=strat->
S;
9061 if (atS <= strat->sl)
9063#ifdef ENTER_USE_MEMMOVE
9064 memmove(&(strat->
S[atS+1]), &(strat->
S[atS]),
9065 (strat->
sl - atS + 1)*
sizeof(poly));
9066 memmove(&(strat->
ecartS[atS+1]), &(strat->
ecartS[atS]),
9067 (strat->
sl - atS + 1)*
sizeof(
int));
9068 memmove(&(strat->
sevS[atS+1]), &(strat->
sevS[atS]),
9069 (strat->
sl - atS + 1)*
sizeof(
unsigned long));
9070 memmove(&(strat->
S_2_R[atS+1]), &(strat->
S_2_R[atS]),
9071 (strat->
sl - atS + 1)*
sizeof(
int));
9073 memmove(&(strat->
lenS[atS+1]), &(strat->
lenS[atS]),
9074 (strat->
sl - atS + 1)*
sizeof(
int));
9076 memmove(&(strat->
lenSw[atS+1]), &(strat->
lenSw[atS]),
9079 for (
i=strat->
sl+1;
i>=atS+1;
i--)
9081 strat->
S[
i] = strat->
S[
i-1];
9087 for (
i=strat->
sl+1;
i>=atS+1;
i--)
9090 for (
i=strat->
sl+1;
i>=atS+1;
i--)
9096#ifdef ENTER_USE_MEMMOVE
9097 memmove(&(strat->
fromQ[atS+1]), &(strat->
fromQ[atS]),
9098 (strat->
sl - atS + 1)*
sizeof(
int));
9100 for (
i=strat->
sl+1;
i>=atS+1;
i--)
9105 strat->
fromQ[atS]=0;
9116 strat->
sevS[atS] =
p.sev;
9118 strat->
S_2_R[atS] = atR;
9128 for (
int i = maxPossibleShift;
i > 0;
i--)
9136 int atS =
posInS(strat, strat->
sl, qq.p, qq.ecart);
9155 *
sizeof(
unsigned long));
9159 *
sizeof(
unsigned long));
9187 strat->
Shdl->m=strat->
S;
9194 if (atS <= strat->sl)
9196#ifdef ENTER_USE_MEMMOVE
9197 memmove(&(strat->
S[atS+1]), &(strat->
S[atS]),
9198 (strat->
sl - atS + 1)*
sizeof(poly));
9199 memmove(&(strat->
sig[atS+1]), &(strat->
sig[atS]),
9200 (strat->
sl - atS + 1)*
sizeof(poly));
9201 memmove(&(strat->
sevSig[atS+1]), &(strat->
sevSig[atS]),
9202 (strat->
sl - atS + 1)*
sizeof(
unsigned long));
9203 memmove(&(strat->
ecartS[atS+1]), &(strat->
ecartS[atS]),
9204 (strat->
sl - atS + 1)*
sizeof(
int));
9205 memmove(&(strat->
sevS[atS+1]), &(strat->
sevS[atS]),
9206 (strat->
sl - atS + 1)*
sizeof(
unsigned long));
9207 memmove(&(strat->
S_2_R[atS+1]), &(strat->
S_2_R[atS]),
9208 (strat->
sl - atS + 1)*
sizeof(
int));
9210 memmove(&(strat->
lenS[atS+1]), &(strat->
lenS[atS]),
9211 (strat->
sl - atS + 1)*
sizeof(
int));
9213 memmove(&(strat->
lenSw[atS+1]), &(strat->
lenSw[atS]),
9216 for (
i=strat->
sl+1;
i>=atS+1;
i--)
9218 strat->
S[
i] = strat->
S[
i-1];
9226 for (
i=strat->
sl+1;
i>=atS+1;
i--)
9229 for (
i=strat->
sl+1;
i>=atS+1;
i--)
9235#ifdef ENTER_USE_MEMMOVE
9236 memmove(&(strat->
fromQ[atS+1]), &(strat->
fromQ[atS]),
9237 (strat->
sl - atS + 1)*
sizeof(
int));
9239 for (
i=strat->
sl+1;
i>=atS+1;
i--)
9244 strat->
fromQ[atS]=0;
9248 strat->
S[atS] =
p.p;
9249 strat->
sig[atS] =
p.sig;
9255 strat->
sevS[atS] =
p.sev;
9265 strat->
sevSig[atS] =
p.sevSig;
9268 strat->
S_2_R[atS] = atR;
9272 Print(
"--- LIST S: %d ---\n",strat->
sl);
9273 for(
k=0;
k<=strat->
sl;
k++)
9277 PrintS(
"--- LIST S END ---\n");
9303 else strat->
P.sev=0;
9311 poly tp = strat->
T[tj].p;
9316 for (
j = 0;
j <= strat->
sl; ++
j)
9330 pos =
posInS(strat, strat->
sl,
p.p,
p.ecart);
9336 for (
i = 0;
i <= strat->
Ll; ++
i)
9360 strat->
enterS(
p, pos, strat, strat->
tl);
9399 for(
i=strat->
tl;
i>=0;
i--)
9401 if (
p.p==strat->
T[
i].p)
9403 printf(
"already in T at pos %d of %d, atT=%d\n",
i,strat->
tl,atT);
9409#ifdef HAVE_TAIL_RING
9412 p.t_p=
p.GetLmTailRing();
9418 if (strat->
tl == strat->
tmax-1)
9420 if (atT <= strat->tl)
9422#ifdef ENTER_USE_MEMMOVE
9423 memmove(&(strat->
T[atT+1]), &(strat->
T[atT]),
9425 memmove(&(strat->
sevT[atT+1]), &(strat->
sevT[atT]),
9426 (strat->
tl-atT+1)*
sizeof(
unsigned long));
9428 for (
i=strat->
tl+1;
i>=atT+1;
i--)
9430#ifndef ENTER_USE_MEMMOVE
9431 strat->
T[
i] = strat->
T[
i-1];
9434 strat->
R[strat->
T[
i].i_r] = &(strat->
T[
i]);
9442 if (!(
currRing->isLPring &&
p.shift > 0))
9458 strat->
T[atT].max_exp =
NULL;
9461 strat->
R[strat->
tl] = &(strat->
T[atT]);
9462 strat->
T[atT].i_r = strat->
tl;
9487 for(
i=strat->
tl;
i>=0;
i--)
9489 if (
p.p==strat->
T[
i].p)
9491 printf(
"already in T at pos %d of %d, atT=%d\n",
i,strat->
tl,atT);
9497#ifdef HAVE_TAIL_RING
9500 p.t_p=
p.GetLmTailRing();
9506 if (strat->
tl == strat->
tmax-1)
9508 if (atT <= strat->tl)
9510#ifdef ENTER_USE_MEMMOVE
9511 memmove(&(strat->
T[atT+1]), &(strat->
T[atT]),
9513 memmove(&(strat->
sevT[atT+1]), &(strat->
sevT[atT]),
9514 (strat->
tl-atT+1)*
sizeof(
unsigned long));
9516 for (
i=strat->
tl+1;
i>=atT+1;
i--)
9518#ifndef ENTER_USE_MEMMOVE
9519 strat->
T[
i] = strat->
T[
i-1];
9522 strat->
R[strat->
T[
i].i_r] = &(strat->
T[
i]);
9540 strat->
T[atT].max_exp =
NULL;
9543 strat->
R[strat->
tl] = &(strat->
T[atT]);
9544 strat->
T[atT].i_r = strat->
tl;
9551 for(
i=strat->
tl;
i>=0;
i--)
9582 (strat->
syzmax)*
sizeof(
unsigned long),
9584 *
sizeof(
unsigned long));
9587 if (atT < strat->syzl)
9589#ifdef ENTER_USE_MEMMOVE
9590 memmove(&(strat->
syz[atT+1]), &(strat->
syz[atT]),
9591 (strat->
syzl-atT+1)*
sizeof(poly));
9592 memmove(&(strat->
sevSyz[atT+1]), &(strat->
sevSyz[atT]),
9593 (strat->
syzl-atT+1)*
sizeof(
unsigned long));
9595 for (
i=strat->
syzl;
i>=atT+1;
i--)
9597#ifndef ENTER_USE_MEMMOVE
9610 strat->
syz[atT] =
p.sig;
9611 strat->
sevSyz[atT] =
p.sevSig;
9614 Print(
"element in strat->syz: %d--%d ",atT+1,strat->
syzmax);
9624 strat->
L[cc].sig, ~strat->
L[cc].sevSig,
currRing)
9638 PrintS(
"--- Syzygies ---\n");
9641 PrintS(
"--------------------------------\n");
9647 PrintS(
"--------------------------------\n");
9729 if (strat->
homog)
PrintS(
"ideal/module is homogeneous\n");
9730 else PrintS(
"ideal/module is not homogeneous\n");
9800 if (strat->
homog)
PrintS(
"ideal/module is homogeneous\n");
9801 else PrintS(
"ideal/module is not homogeneous\n");
10003#ifdef HAVE_SHIFTBBA
10026 strat->
P.pLength=0;
10069#ifdef HAVE_SHIFTBBA
10096#ifdef HAVE_SHIFTBBA
10338 if ((r->m[
l]!=
NULL)
10345 if ((
Q->m[q]!=
NULL)
10369 if ((r->m[
l]!=
NULL)
10376 if ((
Q->m[q]!=
NULL)
10420 reduction_found=
TRUE;
10451 reduction_found=
TRUE;
10465 if ( reduction_found)
10555 for (
i=strat->
sl;
i>=low;
i--)
10557 int end_pos=strat->
sl;
10559 if (strat->
ak==0) end_pos=
i-1;
10561 if ((T_j !=
NULL)&&(T_j->p==strat->
S[
i]))
10579 Print(
"to (tailR) S[%d]:",
i);
10591 T_j->max_exp =
NULL;
10594 T_j->pCleardenom();
10634 Print(
"to (-tailR) S[%d]:",
i);
10682 if (j < strat->
HCord)
10723 assume(L->i_r1 >= -1 && L->i_r1 <= strat->
tl);
10724 assume(L->i_r2 >= -1 && L->i_r2 <= strat->
tl);
10729 if ((L->i_r1 == -1) || (L->i_r2 == -1) )
10734 if ((L->i_r1>=0)&&(strat->
R[L->i_r1]!=
NULL)) p1_max = (strat->
R[L->i_r1])->max_exp;
10736 if ((L->i_r2>=0)&&(strat->
R[L->i_r2]!=
NULL)) p2_max = (strat->
R[L->i_r2])->max_exp;
10762 poly p1_max = (strat->
R[atR])->max_exp;
10763 poly p2_max = (strat->
R[strat->
S_2_R[atS]])->max_exp;
10784 ideal F =
idCopy(Forig);
10788 ideal monred =
idInit(1,1);
10795 if((posconst != -1) && (!
nIsZero(F->m[posconst]->coef)))
10805 for(
int i=0;
i<idelemQ;
i++)
10813 if((posconst != -1) && (!
nIsZero(monred->m[posconst]->coef)))
10815 pmon =
pCopy(monred->m[posconst]);
10830 II->m[
j++] =
prMapR(F->m[
i], nMap, origR, QQ_ring);
10832 II->m[
j++] =
prMapR(
Q->m[
i], nMap, origR, QQ_ring);
10839 if(II->m[
i] !=
NULL)
10840 II->m[
i+1] = II->m[
i];
10843 poly integer =
NULL;
10851 integer =
pHead(syz->m[
i]);
10858 pmon =
prMapR(integer, nMap2, QQ_ring, origR);
10872 poly mindegmon =
NULL;
10877 if(mindegmon ==
NULL)
10878 mindegmon =
pCopy(one->m[
i]);
10881 if(
p_Deg(one->m[
i], QQ_ring) <
p_Deg(mindegmon, QQ_ring))
10882 mindegmon =
pCopy(one->m[
i]);
10886 if(mindegmon !=
NULL)
10889 if(II->m[
i] !=
NULL)
10890 II->m[
i+1] = II->m[
i];
10891 II->m[0] =
pCopy(mindegmon);
10920 pmon =
prMapR(mindegmon, nMap2, QQ_ring, origR);
10951 poly pH =
h->GetP();
10955 for(
int i = 0;
i<=strat->
sl;
i++)
10965#ifdef HAVE_SHIFTBBA
10990#ifdef HAVE_SHIFTBBA
11018 h->SetLmCurrRing();
11019 if((deleted)&&(
h->p!=
NULL))
11027 poly hSig =
h->sig;
11028 poly pH =
h->GetP();
11032 for(
int i = 0;
i<=strat->
sl;
i++)
11043 if(sigMult!=
NULL &&
pLtCmp(hSig,sigMult) == 1)
11070 if(sigMult!=
NULL &&
pLtCmp(hSig,sigMult) == 1)
11101 h->SetLmCurrRing();
11211 if (expbound == 0) expbound = strat->
tailRing->bitmask << 1;
11228 new_tailRing->pFDeg =
currRing->pFDeg;
11229 new_tailRing->pLDeg =
currRing->pLDeg;
11233 Print(
"[%lu:%d", (
unsigned long) new_tailRing->bitmask, new_tailRing->ExpL_Size);
11242 for (
i=0;
i<=strat->
tl;
i++)
11244 strat->
T[
i].ShallowCopyDelete(new_tailRing, new_tailBin,
11245 p_shallow_copy_delete);
11247 for (
i=0;
i<=strat->
Ll;
i++)
11251 strat->
L[
i].ShallowCopyDelete(new_tailRing, p_shallow_copy_delete);
11253 if ((strat->
P.t_p !=
NULL) ||
11255 strat->
P.ShallowCopyDelete(new_tailRing, p_shallow_copy_delete);
11257 if ((L !=
NULL) && (L->tailRing != new_tailRing))
11260 L->ShallowCopyDelete(new_tailRing, p_shallow_copy_delete);
11266 L->tailRing = new_tailRing;
11269 L->max_exp = t_l->max_exp;
11273 if ((
T !=
NULL) && (
T->tailRing != new_tailRing &&
T->i_r < 0))
11274 T->ShallowCopyDelete(new_tailRing, new_tailBin, p_shallow_copy_delete);
11281 strat->
tailBin = new_tailBin;
11307 unsigned long l = 0;
11313 for (
i=0;
i<= strat->
Ll;
i++)
11317 for (
i=0;
i<=strat->
tl;
i++)
11345 res->block0 = (
int *)
omAlloc0((n+1)*
sizeof(int));
11346 res->block1 = (
int *)
omAlloc0((n+1)*
sizeof(int));
11347 int **wvhdl = (
int **)
omAlloc0((n+1)*
sizeof(
int*));
11348 res->wvhdl = wvhdl;
11349 for (
int i=1;
i<n;
i++)
11351 res->order[
i] = r->order[
i-1];
11352 res->block0[
i] = r->block0[
i-1];
11353 res->block1[
i] = r->block1[
i-1];
11354 res->wvhdl[
i] = r->wvhdl[
i-1];
11374 WarnS(
"error in nc_rComplete");
11393 res->block0 = (
int *)
omAlloc0((n+2)*
sizeof(int));
11394 res->block1 = (
int *)
omAlloc0((n+2)*
sizeof(int));
11395 int **wvhdl = (
int **)
omAlloc0((n+2)*
sizeof(
int*));
11396 res->wvhdl = wvhdl;
11397 for (
int i=2;
i<n+2;
i++)
11399 res->order[
i] = r->order[
i-2];
11400 res->block0[
i] = r->block0[
i-2];
11401 res->block1[
i] = r->block1[
i-2];
11402 res->wvhdl[
i] = r->wvhdl[
i-2];
11407 res->block0[0] = 1;
11409 for (
int i=0;
i<
res->N; ++
i)
11410 res->wvhdl[0][
i] = 1;
11430 WarnS(
"error in nc_rComplete");
11567#ifdef HAVE_TAIL_BIN
11594Timings
for the different possibilities of posInT:
11595 T15 EDL DL EL L 1-2-3
11596Gonnet 43.26 42.30 38.34 41.98 38.40 100.04
11597Hairer_2_1 1.11 1.15 1.04 1.22 1.08 4.7
11598Twomat3 1.62 1.69 1.70 1.65 1.54 11.32
11599ahml 4.48 4.03 4.03 4.38 4.96 26.50
11600c7 15.02 13.98 15.16 13.24 17.31 47.89
11601c8 505.09 407.46 852.76 413.21 499.19 n/a
11602f855 12.65 9.27 14.97 8.78 14.23 33.12
11603gametwo6 11.47 11.35 14.57 11.20 12.02 35.07
11604gerhard_3 2.73 2.83 2.93 2.64 3.12 6.24
11605ilias13 22.89 22.46 24.62 20.60 23.34 53.86
11606noon8 40.68 37.02 37.99 36.82 35.59 877.16
11607rcyclic_19 48.22 42.29 43.99 45.35 51.51 204.29
11608rkat9 82.37 79.46 77.20 77.63 82.54 267.92
11609schwarz_11 16.46 16.81 16.76 16.81 16.72 35.56
11610test016 16.39 14.17 14.40 13.50 14.26 34.07
11611test017 34.70 36.01 33.16 35.48 32.75 71.45
11612test042 10.76 10.99 10.27 11.57 10.45 23.04
11613test058 6.78 6.75 6.51 6.95 6.22 9.47
11614test066 10.71 10.94 10.76 10.61 10.56 19.06
11615test073 10.75 11.11 10.17 10.79 8.63 58.10
11616test086 12.23 11.81 12.88 12.24 13.37 66.68
11617test103 5.05 4.80 5.47 4.64 4.89 11.90
11618test154 12.96 11.64 13.51 12.46 14.61 36.35
11619test162 65.27 64.01 67.35 59.79 67.54 196.46
11620test164 7.50 6.50 7.68 6.70 7.96 17.13
11621virasoro 3.39 3.50 3.35 3.47 3.70 7.66
11631 if (
length==-1)
return 0;
11634 int op=
p.GetpFDeg();
11635 int ol =
p.GetpLength();
11637 if (set[
length].ecart < o)
11639 if (set[
length].ecart == o)
11641 int oo=set[
length].GetpFDeg();
11642 if ((oo < op) || ((oo==op) && (set[
length].
length < ol)))
11653 if (set[an].ecart > o)
11655 if (set[an].ecart == o)
11657 int oo=set[an].GetpFDeg();
11659 || ((oo==op) && (set[an].
pLength > ol)))
11665 if (set[
i].ecart > o)
11667 else if (set[
i].ecart == o)
11669 int oo=set[
i].GetpFDeg();
11671 || ((oo == op) && (set[
i].
pLength > ol)))
11685 if (
length==-1)
return 0;
11687 int op=
p.GetpFDeg();
11688 int ol =
p.GetpLength();
11690 int oo=set[
length].GetpFDeg();
11691 if ((oo < op) || ((oo==op) && (set[
length].
length < ol)))
11701 int oo=set[an].GetpFDeg();
11703 || ((oo==op) && (set[an].
pLength > ol)))
11708 int oo=set[
i].GetpFDeg();
11710 || ((oo == op) && (set[
i].
pLength > ol)))
11721 int ol =
p.GetpLength();
11735 if (set[an].
pLength>ol)
return an;
11762 else Print(
"%p\n",(
void*)strat->
red);
11781#ifdef HAVE_MORE_POS_IN_T
11819 PrintS(
"initEcartPair: ");
11823 Print(
"homog=%d, LazyDegree=%d, LazyPass=%d, ak=%d,\n",
11825 Print(
"honey=%d, sugarCrit=%d, Gebauer=%d, noTailReduction=%d, use_buckets=%d\n",
11831 Print(
"posInLDependsOnLength=%d\n",
11863 PrintS(
"currRing->pFDeg: ");
11878 PrintS(
"ecartWeights: ");
11890#ifdef HAVE_SHIFTBBA
11904#ifdef HAVE_SHIFTBBA
11921#ifdef HAVE_SHIFTBBA
12016#ifdef HAVE_SHIFTBBA
12021 assume(ifromS <= strat->sl);
12120 PrintS(
"\n--- create strong gcd poly: ");
12123 Print(
"\n q (strat->S[%d]): ", ifromS);
12129 pNext(
gcd) =
p_Add_q(
pp_Mult_mm(
pp_mm_Mult(
pNext(
p), m1, strat->
tailRing), m12, strat->
tailRing),
pp_Mult_mm(
pp_mm_Mult(
pNext(q), m2, strat->
tailRing), m22, strat->
tailRing), strat->
tailRing);
12152 h.i_r1 = -1;
h.i_r2 = -1;
12159 if (atR >= 0 && shiftcount == 0 && ifromS >= 0)
12172 posx = strat->
posInL(strat->
L,strat->
Ll,&
h,strat);
12186#ifdef HAVE_SHIFTBBA
12213 int j,compare,compareCoeff;
12217 h.ecart=0;
h.length=0;
12249 for(
j = strat->
Bl;
j>=0;
j--)
12258 if ((strat->
fromQ==
NULL) || (isFromQ==0) || (qisFromQ==0))
12273 if ((strat->
fromQ==
NULL) || (isFromQ==0) || (qisFromQ==0))
12286 if ((strat->
fromQ==
NULL) || (isFromQ==0) || (qisFromQ==0))
12390 h.i_r1 = -1;
h.i_r2 = -1;
12399 if (atR >= 0 && shiftcount == 0 && ifromS >= 0)
12414 posx = strat->
posInL(strat->
B,strat->
Bl,&
h,strat);
12429#ifdef HAVE_SHIFTBBA
12438#ifdef HAVE_SHIFTBBA
12443 assume(q_inS < 0 || strat->S[q_inS] == q);
12453 if (strat->
fromQ !=
NULL && q_inS >= 0)
12454 q_isFromQ = strat->
fromQ[q_inS];
12456 void (*enterPair)(poly, poly, int, int,
kStrategy, int, int, int, int, int);
12465 int neededShift = p_lastVblock - ((
pGetComp(
p) > 0 ||
pGetComp(q) > 0) ? 0 : 1);
12466 int maxPossibleShift =
degbound - q_lastVblock;
12467 int maxShift =
si_min(neededShift, maxPossibleShift);
12468 int firstShift = (q ==
p ? 1 : 0);
12469 for (
int j = firstShift;
j <= maxShift;
j++)
12472 enterPair(qq,
p, ecartp, p_isFromQ, strat, -1, ecartq, q_isFromQ,
j, q_inS);
12479 for (
int j = p_lastVblock;
j <= maxPossibleShift;
j++)
12485 enterPair(qq,
p, ecartp, p_isFromQ, strat, -1, ecartq, q_isFromQ, p_lastVblock, q_inS);
12494#ifdef HAVE_SHIFTBBA
12499 assume(p_inS < 0 || strat->S[p_inS] ==
p);
12508 if (strat->
fromQ !=
NULL && p_inS >= 0)
12509 p_isFromQ = strat->
fromQ[p_inS];
12514 assume(q_shift <= p_lastVblock);
12521 enterOnePairShift(q,
p, ecartp, p_isFromQ, strat, -1, ecartq, q_isFromQ, q_shift, -1);
12534#ifdef HAVE_SHIFTBBA
12537#ifdef CRITERION_DEBUG
12542 poly lmq =
pHead(q);
12563 int qfromQ = qisFromQ;
12572 Lp.ecart=0; Lp.length=0;
12582#ifdef CRITERION_DEBUG
12590 if((!((ecartq>0)&&(ecart>0)))
12609#ifdef CRITERION_DEBUG
12615 Lp.ecart =
si_max(ecart,ecartq);
12616 if (strat->
fromT && (ecartq>ecart))
12619#ifdef CRITERION_DEBUG
12641 if ((strat->
fromQ==
NULL) || (isFromQ==0) || (qfromQ==0))
12644#ifdef CRITERION_DEBUG
12647 Print(
"--- chain crit using B[%d].lcm=%s\n",
j,
pString(strat->
B[
j].lcm));
12658#ifdef CRITERION_DEBUG
12661 Print(
"--- chain crit using pair to remove B[%d].lcm=%s\n",
j,
pString(strat->
B[
j].lcm));
12694#ifdef CRITERION_DEBUG
12699 if (strat->
fromT && (ecartq>ecart))
12702#ifdef CRITERION_DEBUG
12714 for(
j = strat->
Bl;
j>=0;
j--)
12720 if ((strat->
fromQ==
NULL) || (isFromQ==0) || (qfromQ==0))
12723#ifdef CRITERION_DEBUG
12726 Print(
"--- chain crit using B[%d].lcm=%s\n",
j,
pString(strat->
B[
j].lcm));
12736#ifdef CRITERION_DEBUG
12739 Print(
"--- chain crit using pair to remove B[%d].lcm=%s\n",
j,
pString(strat->
B[
j].lcm));
12756#ifdef CRITERION_DEBUG
12761 if ((strat->
fromQ!=
NULL) && (isFromQ!=0) && (qfromQ!=0))
12764#ifdef CRITERION_DEBUG
12824#ifdef CRITERION_DEBUG
12840 if ( (atR >= 0) && (shiftcount==0) && (ifromS >=0) )
12857 && (Lp.p->coef!=
NULL))
12861 l = strat->
posInL(strat->
B,strat->
Bl,&Lp,strat);
12863#ifdef CRITERION_DEBUG
12875#ifdef HAVE_SHIFTBBA
12881 if (h_lastVblock == 0)
return;
12892 int maxShift =
degbound - h_lastVblock;
12901 for (
i=0;
i<=maxShift;
i++)
12904 for (
j=0;
j<=
k;
j++)
12909 poly
s = strat->
S[
j];
12918 for (
j=0;
j<=
k;
j++)
12920 poly
s = strat->
S[
j];
12935 else if ((isFromQ)&&(strat->
fromQ!=
NULL))
12938 for (
j=0;
j<=
k;
j++)
12943 poly
s = strat->
S[
j];
12950 for (
i=1;
i<=maxShift;
i++)
12953 for (
j=0;
j<=
k;
j++)
12957 poly
s = strat->
S[
j];
12959 if (
i < s_lastVblock || (
pGetComp(
s) > 0 &&
i == s_lastVblock))
12983 for (
j=0;
j<=
k;
j++)
12985 poly
s = strat->
S[
j];
12989 for (
i=1;
i<=maxShift;
i++)
12992 for (
j=0;
j<=
k;
j++)
12994 poly
s = strat->
S[
j];
12996 if (
i < s_lastVblock || (
pGetComp(
s) > 0 &&
i == s_lastVblock))
13012 if (
i < h_lastVblock)
13036 for (
j=0;
j<=
k;
j++)
13041 poly
s = strat->
S[
j];
13058 for (
j=0;
j<=
k;
j++)
13063 poly
s = strat->
S[
j];
13068 for (
i=1;
i<=maxShift;
i++)
13071 for (
j=0;
j<=
k;
j++)
13076 poly
s = strat->
S[
j];
13078 if (
i <= s_lastVblock)
13095 if (
i <= h_lastVblock)
13128#ifdef HAVE_SHIFTBBA
13134 if (h_lastVblock == 0)
return;
13145 int maxShift =
degbound - h_lastVblock;
13154 for (
i=0;
i<=maxShift;
i++)
13157 for (
j=0;
j<=
k;
j++)
13162 poly
s = strat->
S[
j];
13171 for (
j=0;
j<=
k;
j++)
13173 poly
s = strat->
S[
j];
13188 else if ((isFromQ)&&(strat->
fromQ!=
NULL))
13191 for (
j=0;
j<=
k;
j++)
13196 poly
s = strat->
S[
j];
13203 for (
i=1;
i<=maxShift;
i++)
13206 for (
j=0;
j<=
k;
j++)
13210 poly
s = strat->
S[
j];
13221 for (
j=0;
j<=
k;
j++)
13223 poly
s = strat->
S[
j];
13228 for (
i=1;
i<=maxShift;
i++)
13231 for (
j=0;
j<=
k;
j++)
13233 poly
s = strat->
S[
j];
13245 for (
j=0;
j<=
k;
j++)
13251 poly
s = strat->
S[
j];
13268 for (
j=0;
j<=
k;
j++)
13273 poly
s = strat->
S[
j];
13278 for (
i=1;
i<=maxShift;
i++)
13281 for (
j=0;
j<=
k;
j++)
13286 poly
s = strat->
S[
j];
13308#ifdef HAVE_SHIFTBBA
13317 if ( (!strat->
fromT)
13338#ifdef HAVE_SHIFTBBA
13349 for (
int i = 1;
i <= maxPossibleShift;
i++)
13361#ifdef HAVE_SHIFTBBA
13368 p =
h = L->GetLmTailRing();
13370 return L->GetLmCurrRing();
13377 Ln.pLength = L->GetpLength() - 1;
13385 while(!Ln.IsNull())
13389 Ln.SetShortExpVector();
13395 With = &(strat->
T[
j]);
13400 if (With ==
NULL)
break;
13416 pNext(
h) = Ln.LmExtractAndIter();
13419 }
while (!Ln.IsNull());
13422 if (Ln.IsNull())
goto all_done;
13423 if (! withT) With_s.Init(
currRing);
13425 pNext(
h) = Ln.LmExtractAndIter();
13440 return L->GetLmCurrRing();
static int si_max(const int a, const int b)
static int si_min(const int a, const int b)
CanonicalForm normalize(const CanonicalForm &F)
normalize a poly, i.e. in char 0 clear denominators, remove integer content in char p divide by leadi...
static CanonicalForm bound(const CFMatrix &M)
KINLINE poly kNoetherTail()
void(* chainCrit)(poly p, int ecart, kStrategy strat)
pFDegProc pOrigFDeg_TailRing
BOOLEAN(* rewCrit1)(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
BOOLEAN(* rewCrit3)(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
int(* posInL)(const LSet set, const int length, LObject *L, const kStrategy strat)
KINLINE TObject * s_2_t(int i)
void(* initEcartPair)(LObject *h, poly f, poly g, int ecartF, int ecartG)
BOOLEAN(* syzCrit)(poly sig, unsigned long not_sevSig, kStrategy strat)
pShallowCopyDeleteProc p_shallow_copy_delete
void(* enterS)(LObject &h, int pos, kStrategy strat, int atR)
char completeReduce_retry
void(* initEcart)(TObject *L)
KINLINE TObject * S_2_T(int i)
void(* enterOnePair)(int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR)
int(* posInT)(const TSet T, const int tl, LObject &h)
int(* red)(LObject *L, kStrategy strat)
char posInLDependsOnLength
int(* posInLSba)(const LSet set, const int length, LObject *L, const kStrategy strat)
pLDegProc pOrigLDeg_TailRing
static FORCE_INLINE BOOLEAN nCoeff_is_Z(const coeffs r)
@ n_Q
rational (GMP) numbers
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 FORCE_INLINE BOOLEAN n_IsUnit(number n, const coeffs r)
TRUE iff n has a multiplicative inverse in the given coeff field/ring r.
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
static FORCE_INLINE nMapFunc n_SetMap(const coeffs src, const coeffs dst)
set the mapping function pointers for translating numbers from src to dst
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
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,...
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 number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
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,...
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:...
static FORCE_INLINE int n_DivComp(number a, number b, const coeffs r)
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
void nKillChar(coeffs r)
undo all initialisations
const CanonicalForm int s
int comp(const CanonicalForm &A, const CanonicalForm &B)
compare polynomials
static int min(int a, int b)
static int max(int a, int b)
void scComputeHC(ideal S, ideal Q, int ak, poly &hEdge, ring tailRing)
ideal idSyzygies(ideal h1, tHomog h, intvec **w, BOOLEAN setSyzComp, BOOLEAN setRegularity, int *deg, GbVariant alg)
#define idDelete(H)
delete an ideal
BOOLEAN idInsertPoly(ideal h1, poly h2)
insert h2 into h1 (if h2 is not the zero polynomial) return TRUE iff h2 was indeed inserted
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
#define idPosConstant(I)
index of generator with leading term in ground ring (if any); otherwise -1
static BOOLEAN length(leftv result, leftv arg)
KINLINE poly k_LmInit_currRing_2_tailRing(poly p, ring tailRing, omBin tailBin)
KINLINE void k_GetStrongLeadTerms(const poly p1, const poly p2, const ring leadRing, poly &m1, poly &m2, poly &lcm, const ring tailRing)
KINLINE int ksReducePolyTailLC_Z(LObject *PR, TObject *PW, LObject *Red)
KINLINE poly ksOldSpolyRed(poly p1, poly p2, poly spNoether)
KINLINE TObject ** initR()
KINLINE int ksReducePolyTail(LObject *PR, TObject *PW, LObject *Red)
KINLINE poly ksOldSpolyRedNew(poly p1, poly p2, poly spNoether)
KINLINE void clearS(poly p, unsigned long p_sev, int *at, int *k, kStrategy strat)
KINLINE BOOLEAN k_GetLeadTerms(const poly p1, const poly p2, const ring p_r, poly &m1, poly &m2, const ring m_r)
KINLINE int ksReducePolyTail_Z(LObject *PR, TObject *PW, LObject *Red)
KINLINE unsigned long * initsevT()
int redLiftstd(LObject *h, kStrategy strat)
void kBucketClear(kBucket_pt bucket, poly *p, int *length)
BOOLEAN kbTest(kBucket_pt bucket)
Tests.
void kBucketDestroy(kBucket_pt *bucket_pt)
void kBucketInit(kBucket_pt bucket, poly lm, int length)
void kBucket_Add_q(kBucket_pt bucket, poly q, int *l)
Add to Bucket a poly ,i.e. Bpoly == q+Bpoly.
int ksCheckCoeff(number *a, number *b)
BOOLEAN pCompareChainPart(poly p, poly p1, poly p2, poly lcm, const ring R)
BOOLEAN pCompareChain(poly p, poly p1, poly p2, poly lcm, const ring R)
Returns TRUE if.
poly ksCreateShortSpoly(poly p1, poly p2, ring tailRing)
int posInL10(const LSet set, const int length, LObject *p, const kStrategy strat)
long kHomModDeg(poly p, ring r)
poly kNF(ideal F, ideal Q, poly p, int syzComp, int lazyReduce)
ideal kStd(ideal F, ideal Q, tHomog h, intvec **w, intvec *hilb, int syzComp, int newIdeal, intvec *vw, s_poly_proc_t sp)
int kFindDivisibleByInT_Z(const kStrategy strat, const LObject *L, const int start)
int redHoney(LObject *h, kStrategy strat)
int redHomog(LObject *h, kStrategy strat)
int redLazy(LObject *h, kStrategy strat)
int redRing(LObject *h, 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
void initSbaPos(kStrategy strat)
void message(int i, int *reduc, int *olddeg, kStrategy strat, int red_result)
poly redtail(LObject *L, int end_pos, kStrategy strat)
int posInL17Ring(const LSet set, const int length, LObject *p, const kStrategy)
int posInL17_cRing(const LSet set, const int length, LObject *p, const kStrategy)
int getIndexRng(long coeff)
int posInL110(const LSet set, const int length, LObject *p, const kStrategy)
int posInT17(const TSet set, const int length, LObject &p)
void initBuchMora(ideal F, ideal Q, kStrategy strat)
poly pMove2CurrTail(poly p, kStrategy strat)
int posInTrg0(const TSet set, const int length, LObject &p)
int redFirst(LObject *h, kStrategy strat)
void kMergeBintoL(kStrategy strat)
static void enlargeT(TSet &T, TObject **&R, unsigned long *&sevT, int &length, const int incr)
BOOLEAN arriRewCriterionPre(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int)
void enterSyz(LObject &p, kStrategy strat, int atT)
int posInL11Ring(const LSet set, const int length, LObject *p, const kStrategy)
int redEcart(LObject *h, kStrategy strat)
int posInT11(const TSet set, const int length, LObject &p)
void enterT(LObject &p, kStrategy strat, int atT)
int posInT1(const TSet set, const int length, LObject &p)
void enterTShift(LObject p, kStrategy strat, int atT)
int posInT110Ring(const TSet set, const int length, LObject &p)
BOOLEAN arriRewCriterion(poly, unsigned long, poly, kStrategy strat, int start=0)
void enterSSba(LObject &p, int atS, kStrategy strat, int atR)
BOOLEAN kTest(kStrategy strat)
void initenterpairsSigRing(poly h, poly hSig, int hFrom, int k, int ecart, int isFromQ, kStrategy strat, int atR=-1)
void enterSMoraNF(LObject &p, int atS, kStrategy strat, int atR=-1)
poly redtailBbaBound(LObject *L, int end_pos, kStrategy strat, int bound, BOOLEAN withT, BOOLEAN normalize)
int posInT_EcartpLength(const TSet set, const int length, LObject &p)
TObject * kFindDivisibleByInS_T(kStrategy strat, int end_pos, LObject *L, TObject *T, long ecart)
int posInT0(const TSet, const int length, LObject &)
poly pMoveCurrTail2poly(poly p, kStrategy strat)
BOOLEAN kTest_TS(kStrategy strat)
void enterOnePairNormal(int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR=-1)
int kFindInT(poly p, TSet T, int tlength)
returns index of p in TSet, or -1 if not found
BOOLEAN kCheckStrongCreation(int atR, poly m1, int atS, poly m2, kStrategy strat)
void initenterstrongPairsShift(poly h, int k, int ecart, int isFromQ, kStrategy strat, int atR)
void enterpairsSig(poly h, poly hSig, int hFrom, int k, int ecart, int pos, kStrategy strat, int atR)
static void enterOnePairRingShift(poly q, poly p, int, int isFromQ, kStrategy strat, int atR, int, int qisFromQ, int shiftcount, int ifromS)
static const char * kTest_LmEqual(poly p, poly t_p, ring tailRing)
void enterL(LSet *set, int *length, int *LSetmax, LObject p, int at)
BOOLEAN faugereRewCriterion(poly sig, unsigned long not_sevSig, poly, kStrategy strat, int start=0)
void clearSbatch(poly h, int k, int pos, kStrategy strat)
static int pLPDivComp(poly p, poly q)
int posInT2(const TSet set, const int length, LObject &p)
BOOLEAN kTest_L(LObject *L, ring strat_tailRing, BOOLEAN testp, int lpos, TSet T, int tlength)
int posInL13(const LSet set, const int length, LObject *p, const kStrategy)
int posInL110Ring(const LSet set, const int length, LObject *p, const kStrategy)
int posInT_pLength(const TSet set, const int length, LObject &p)
static intset initec(const int maxnr)
BOOLEAN kPosInLDependsOnLength(int(*pos_in_l)(const LSet set, const int length, LObject *L, const kStrategy strat))
void enterpairs(poly h, int k, int ecart, int pos, kStrategy strat, int atR)
int posInT13(const TSet set, const int length, LObject &p)
void redtailBbaAlsoLC_Z(LObject *L, int end_pos, kStrategy strat)
BOOLEAN syzCriterionInc(poly sig, unsigned long not_sevSig, kStrategy strat)
void initHilbCrit(ideal, ideal, intvec **hilb, kStrategy strat)
void chainCritSig(poly p, int, kStrategy strat)
int posInSMonFirst(const kStrategy strat, const int length, const poly p)
void initEcartPairMora(LObject *Lp, poly, poly, int ecartF, int ecartG)
void initenterstrongPairs(poly h, int k, int ecart, int isFromQ, kStrategy strat, int atR=-1)
void superenterpairsSig(poly h, poly hSig, int hFrom, int k, int ecart, int pos, kStrategy strat, int atR)
static poly redMora(poly h, int maxIndex, kStrategy strat)
int posInL0Ring(const LSet set, const int length, LObject *p, const kStrategy)
static int pDivCompRing(poly p, poly q)
BOOLEAN isInPairsetB(poly q, int *k, kStrategy strat)
void initBuchMoraPos(kStrategy strat)
void initenterpairs(poly h, int k, int ecart, int isFromQ, kStrategy strat, int atR)
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)
void initS(ideal F, ideal Q, kStrategy strat)
BOOLEAN kStratChangeTailRing(kStrategy strat, LObject *L, TObject *T, unsigned long expbound)
poly redtailBba(LObject *L, int end_pos, kStrategy strat, BOOLEAN withT, BOOLEAN normalize)
poly redtailBba_Z(LObject *L, int end_pos, kStrategy strat)
ring sbaRing(kStrategy strat, const ring r, BOOLEAN, int)
void initPairtest(kStrategy strat)
static BOOLEAN p_HasNotCF_Lift(poly p1, poly p2, const ring r)
p_HasNotCF for the IDLIFT case and syzComp==1: ignore component
int posInL0(const LSet set, const int length, LObject *p, const kStrategy)
void initSSpecial(ideal F, ideal Q, ideal P, kStrategy strat)
void chainCritOpt_1(poly, int, kStrategy strat)
int posInT11Ring(const TSet set, const int length, LObject &p)
static void enterOnePairRing(int i, poly p, int, int isFromQ, kStrategy strat, int atR)
static poly redBba(poly h, int maxIndex, kStrategy strat)
void cancelunit1(LObject *p, int *suc, int index, kStrategy strat)
poly pCopyL2p(LObject H, kStrategy strat)
void initenterpairsShift(poly h, int k, int ecart, int isFromQ, kStrategy strat, int atR)
static void initenterstrongPairsSig(poly h, poly hSig, 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)
static BOOLEAN enterOneStrongPolyShift(poly q, poly p, int, int, kStrategy strat, int atR, int, int qisFromQ, int shiftcount, int ifromS)
int posInL15(const LSet set, const int length, LObject *p, const kStrategy)
static void enlargeL(LSet *L, int *length, const int incr)
int posInT17_c(const TSet set, const int length, LObject &p)
poly redtailBbaShift(LObject *L, int pos, kStrategy strat, BOOLEAN withT, BOOLEAN normalize)
int posInT_EcartFDegpLength(const TSet set, const int length, LObject &p)
int posInT15(const TSet set, const int length, LObject &p)
void enterT_strong(LObject &p, kStrategy strat, int atT)
void postReduceByMon(LObject *h, kStrategy strat)
used for GB over ZZ: intermediate reduction by monomial elements background: any known constant eleme...
BOOLEAN syzCriterion(poly sig, unsigned long not_sevSig, kStrategy strat)
void HEckeTest(poly pp, kStrategy strat)
int posInLSpecial(const LSet set, const int length, LObject *p, const kStrategy)
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)
STATIC_VAR BOOLEAN sloppy_max
void enterExtendedSpolySig(poly h, poly hSig, kStrategy strat)
void enterpairsShift(poly h, int k, int ecart, int pos, kStrategy strat, int atR)
static void enterOnePairSig(int i, poly p, poly pSig, int, int ecart, int isFromQ, kStrategy strat, int atR=-1)
void enterOnePairShift(poly q, poly p, int ecart, int isFromQ, kStrategy strat, int atR, int ecartq, int qisFromQ, int shiftcount, int ifromS)
void exitBuchMora(kStrategy strat)
void messageStatSBA(int hilbcount, kStrategy strat)
void initEcartNormal(TObject *h)
int posInS(const kStrategy strat, const int length, const poly p, const int ecart_p)
void updateS(BOOLEAN toT, kStrategy strat)
void initSLSba(ideal F, ideal Q, kStrategy strat)
int posInL11Ringls(const LSet set, const int length, LObject *p, const kStrategy)
void enterOnePairSpecial(int i, poly p, int ecart, kStrategy strat, int atR=-1)
static int * initS_2_R(const int maxnr)
int posInL17(const LSet set, const int length, LObject *p, const kStrategy)
void initSyzRules(kStrategy strat)
int posInLSig(const LSet set, const int length, LObject *p, const kStrategy)
void initSbaBuchMora(ideal F, ideal Q, kStrategy strat)
BOOLEAN kCheckSpolyCreation(LObject *L, kStrategy strat, poly &m1, poly &m2)
void cleanT(kStrategy strat)
static void enterOnePairLift(int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR=-1)
int posInT110(const TSet set, const int length, LObject &p)
BOOLEAN kTest_S(kStrategy strat)
int posInSyz(const kStrategy strat, poly sig)
void replaceInLAndSAndT(LObject &p, int tj, kStrategy strat)
void reorderS(int *suc, kStrategy strat)
void enterExtendedSpoly(poly h, kStrategy strat)
int posInL15Ring(const LSet set, const int length, LObject *p, const kStrategy)
void kMergeBintoLSba(kStrategy strat)
void deleteHC(LObject *L, kStrategy strat, BOOLEAN fromNext)
void updateResult(ideal r, ideal Q, kStrategy strat)
void superenterpairs(poly h, int k, int ecart, int pos, kStrategy strat, int atR)
static BOOLEAN sugarDivisibleBy(int ecart1, int ecart2)
int posInT19(const TSet set, const int length, LObject &p)
static void enterOneStrongPolyAndEnterOnePairRingShift(poly q, poly p, int ecart, int isFromQ, kStrategy strat, int atR, int ecartq, int qisFromQ, int shiftcount, int ifromS)
void exitSba(kStrategy strat)
int posInT15Ring(const TSet set, const int length, LObject &p)
int posInT17Ring(const TSet set, const int length, LObject &p)
static BOOLEAN enterOneStrongPoly(int i, poly p, int, int, kStrategy strat, int atR, bool enterTstrong)
void kDebugPrint(kStrategy strat)
Output some debug info about a given strategy.
int posInLrg0(const LSet set, const int length, LObject *p, const kStrategy)
void deleteInL(LSet set, int *length, int j, kStrategy strat)
void kStratInitChangeTailRing(kStrategy strat)
void chainCritPart(poly p, int ecart, kStrategy strat)
void enterSMora(LObject &p, int atS, kStrategy strat, int atR=-1)
void initBuchMoraCrit(kStrategy strat)
void cleanTSbaRing(kStrategy strat)
int posInT17_cRing(const TSet set, const int length, LObject &p)
void deleteInSSba(int i, kStrategy strat)
static int pDivComp(poly p, poly q)
void completeReduce(kStrategy strat, BOOLEAN withT)
int posInL17_c(const LSet set, const int length, LObject *p, const kStrategy)
void initBuchMoraPosRing(kStrategy strat)
int kFindInTShift(poly p, TSet T, int tlength)
void postReduceByMonSig(LObject *h, kStrategy strat)
BOOLEAN kTest_T(TObject *T, ring strat_tailRing, int i, char TN)
void messageSets(kStrategy strat)
void deleteInS(int i, kStrategy strat)
static poly redBba1(poly h, int maxIndex, kStrategy strat)
int posInT_FDegpLength(const TSet set, const int length, LObject &p)
int posInLSigRing(const LSet set, const int length, LObject *p, const kStrategy)
BOOLEAN isInPairsetL(int length, poly p1, poly p2, int *k, kStrategy strat)
BOOLEAN sbaCheckGcdPair(LObject *h, kStrategy strat)
int posInLF5CRing(const LSet set, int start, const int length, LObject *p, const kStrategy)
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...
static unsigned long * initsevS(const int maxnr)
void enterpairsSpecial(poly h, int k, int ecart, int pos, kStrategy strat, int atR=-1)
void chainCritNormal(poly p, int ecart, kStrategy strat)
void initEcartBBA(TObject *h)
VAR denominator_list DENOMINATOR_LIST
int posInLRing(const LSet set, const int length, LObject *p, const kStrategy)
static void enterOnePairSigRing(int i, poly p, poly pSig, int, int ecart, int isFromQ, kStrategy strat, int atR=-1)
void enterSBbaShift(LObject &p, int atS, kStrategy strat, int atR)
int posInL11(const LSet set, const int length, LObject *p, const kStrategy)
poly redtailBba_Ring(LObject *L, int end_pos, kStrategy strat)
int posInLF5C(const LSet, const int, LObject *, const kStrategy strat)
void initEcartPairBba(LObject *Lp, poly, poly, int, int)
void messageStat(int hilbcount, kStrategy strat)
static BOOLEAN enterOneStrongPolySig(int i, poly p, poly sig, int, int, kStrategy strat, int atR)
void chainCritRing(poly p, int, kStrategy strat)
void initSSpecialSba(ideal F, ideal Q, ideal P, kStrategy strat)
void initSL(ideal F, ideal Q, kStrategy strat)
int posInIdealMonFirst(const ideal F, const poly p, int start, int end)
void finalReduceByMon(kStrategy strat)
used for GB over ZZ: final reduction by constant elements background: any known constant element of i...
void enterSBba(LObject &p, int atS, kStrategy strat, int atR)
void initSbaCrit(kStrategy strat)
BOOLEAN newHEdge(kStrategy strat)
void cancelunit(LObject *L, BOOLEAN inNF)
denominator_list_s * denominator_list
static LSet initL(int nr=setmaxL)
static void kDeleteLcm(LObject *P)
#define ALLOW_PROD_CRIT(A)
#define REDTAIL_CANONICALIZE
static bool rIsSCA(const ring r)
poly nc_CreateShortSpoly(poly p1, poly p2, const ring r)
static nc_type & ncRingType(nc_struct *p)
poly nc_p_Bracket_qq(poly p, const poly q, const ring r)
returns [p,q], destroys p
int dReportError(const char *fmt,...)
#define pFalseReturn(cond)
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
#define __p_GetComp(p, r)
#define rRing_has_Comp(r)
STATIC_VAR gmp_float * diff
#define omFreeSize(addr, size)
#define omCheckBinAddrSize(addr, size)
#define omReallocSize(addr, o_size, size)
#define omRealloc0Size(addr, o_size, size)
#define omSizeWOfBin(bin_ptr)
#define TEST_OPT_INTSTRATEGY
#define TEST_OPT_INFREDTAIL
#define TEST_OPT_SUGARCRIT
#define TEST_OPT_DEGBOUND
#define TEST_OPT_NOT_SUGAR
#define TEST_OPT_CANCELUNIT
#define TEST_OPT_CONTENTSB
pShallowCopyDeleteProc pGetShallowCopyDeleteProc(ring, ring)
static int index(p_Length length, p_Ord ord)
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 p_Cleardenom_n(poly ph, const ring r, number &c)
long pLDegb(poly p, int *l, const ring r)
long pLDeg1_Totaldegree(poly p, int *l, const ring r)
long p_WFirstTotalDegree(poly p, const ring r)
long pLDeg1_WFirstTotalDegree(poly p, int *l, const ring r)
void pRestoreDegProcs(ring r, pFDegProc old_FDeg, pLDegProc old_lDeg)
long pLDeg1c_WFirstTotalDegree(poly p, int *l, const ring r)
static BOOLEAN p_ExpVectorEqual(poly p1, poly p2, const ring r1, const ring r2)
long pLDeg1c_Deg(poly p, int *l, const ring r)
long pLDeg1(poly p, int *l, const ring r)
unsigned long p_GetShortExpVector(const poly p, const ring r)
long pLDeg1_Deg(poly p, int *l, const ring r)
long p_WTotaldegree(poly p, const ring r)
BOOLEAN p_OneComp(poly p, const ring r)
return TRUE if all monoms have the same component
poly p_Cleardenom(poly p, const ring r)
long pLDeg1c(poly p, int *l, const ring r)
long pLDeg1c_Totaldegree(poly p, int *l, const ring r)
long pLDeg0c(poly p, int *l, const ring r)
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
long pLDeg0(poly p, int *l, const ring r)
poly p_Sub(poly p1, poly p2, const ring r)
void pEnlargeSet(poly **p, int l, int increment)
long p_Deg(poly a, const ring r)
void p_Lcm(const poly a, const poly b, poly m, const ring r)
static poly p_Neg(poly p, const ring r)
static void p_ExpVectorSum(poly pr, poly p1, poly p2, const ring r)
static poly p_Add_q(poly p, poly q, const ring r)
static void p_LmDelete(poly p, const ring r)
static void p_ExpVectorAdd(poly p1, poly p2, const ring r)
BOOLEAN p_CheckIsFromRing(poly p, ring r)
static BOOLEAN _p_LmDivisibleByPart(poly a, const ring r_a, poly b, const ring r_b, const int start, const int end)
static long p_FDeg(const poly p, const ring r)
static unsigned long p_GetMaxExp(const unsigned long l, const ring r)
static void p_ExpVectorCopy(poly d_p, poly s_p, const ring r)
static int p_Cmp(poly p1, poly p2, ring r)
#define __pp_Mult_nn(p, n, r)
static poly pp_mm_Mult(poly p, poly m, const ring r)
static poly pp_Mult_mm(poly p, poly m, const ring r)
static int p_LtCmpNoAbs(poly p, poly q, const ring r)
static void p_SetCompP(poly p, int i, ring r)
#define pp_Test(p, lmRing, tailRing)
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
static void p_Setm(poly p, const ring r)
static number p_SetCoeff(poly p, number n, ring r)
static int p_LmCmp(poly p, poly q, const ring r)
static BOOLEAN p_LmShortDivisibleBy(poly a, unsigned long sev_a, poly b, unsigned long not_sev_b, const ring r)
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent @Note: the integer VarOffset encodes:
BOOLEAN p_LmCheckIsFromRing(poly p, ring r)
static BOOLEAN p_LmDivisibleBy(poly a, poly b, const ring r)
static poly p_ShallowCopyDelete(poly p, const ring r, omBin bin)
static void p_Delete(poly *p, const ring r)
static unsigned pLength(poly a)
BOOLEAN p_CheckPolyRing(poly p, ring r)
static poly p_LmFreeAndNext(poly p, ring)
static poly p_Mult_mm(poly p, poly m, const ring r)
static void p_LmFree(poly p, ring)
static poly p_Copy(poly p, const ring r)
returns a copy of p
static long p_Totaldegree(poly p, const ring r)
static BOOLEAN p_LmExpVectorAddIsOk(const poly p1, const poly p2, const ring r)
void p_wrp(poly p, ring lmRing, ring tailRing)
void rChangeCurrRing(ring r)
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Compatiblity layer for legacy polynomial operations (over currRing)
#define pLtCmpOrdSgnDiffM(p, q)
#define pHead(p)
returns newly allocated copy of Lm(p), coef is copied, next=NULL, p might be NULL
#define pLmIsConstantComp(p)
like above, except that p must be != NULL
#define pIsConstant(p)
like above, except that Comp must be 0
#define pHasNotCF(p1, p2)
#define pLtCmpOrdSgnDiffP(p, q)
#define pGetComp(p)
Component.
#define pSetCoeff(p, n)
deletes old coeff before setting the new one
#define pLmShortDivisibleBy(a, sev_a, b, not_sev_b)
Divisibility tests based on Short Exponent vectors sev_a == pGetShortExpVector(a) not_sev_b == ~ pGet...
#define pCmp(p1, p2)
pCmp: args may be NULL returns: (p2==NULL ? 1 : (p1 == NULL ? -1 : p_LmCmp(p1, p2)))
#define pLmInit(p)
like pInit, except that expvector is initialized to that of p, p must be != NULL
#define pLmDelete(p)
assume p != NULL, deletes Lm(p)->coef and Lm(p)
#define pGetShortExpVector(a)
returns the "Short Exponent Vector" – used to speed up divisibility tests (see polys-impl....
#define pLmDivisibleBy(a, b)
like pDivisibleBy, except that it is assumed that a!=NULL, b!=NULL
static void pLmFree(poly p)
frees the space of the monomial m, assumes m != NULL coef is not freed, m is not advanced
#define pGetExp(p, i)
Exponent.
#define pSetmComp(p)
TODO:
void pNorm(poly p, const ring R=currRing)
#define pHasNotCFRing(p1, p2)
#define pInit()
allocates a new monomial and initializes everything to 0
#define pEqualPolys(p1, p2)
#define pDivisibleBy(a, b)
returns TRUE, if leading monom of a divides leading monom of b i.e., if there exists a expvector c > ...
#define pLmCmp(p, q)
returns 0|1|-1 if p=q|p>q|p<q w.r.t monomial ordering
#define pLtCmpOrdSgnEqP(p, q)
#define pCopy(p)
return a copy of the poly
poly prMoveR(poly &p, ring src_r, ring dest_r)
poly prMapR(poly src, nMapFunc nMap, ring src_r, ring dest_r)
void pLcmRat(poly a, poly b, poly m, int rat_shift)
void PrintS(const char *s)
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...
BOOLEAN nc_rComplete(const ring src, ring dest, bool bSetupQuotient)
void rKillModifiedRing(ring r)
ring rAssure_c_dp(const ring r)
ring rModifyRing(ring r, BOOLEAN omit_degree, BOOLEAN try_omit_comp, unsigned long exp_limit)
ring rCopy0(const ring r, BOOLEAN copy_qideal, BOOLEAN copy_ordering)
void rDebugPrint(const ring r)
void rDelete(ring r)
unconditionally deletes fields in r
static BOOLEAN rField_is_Ring(const ring r)
static int rBlocks(ring r)
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
static int rGetCurrSyzLimit(const ring r)
static BOOLEAN rField_is_Domain(const ring r)
static BOOLEAN rIsRatGRing(const ring r)
static BOOLEAN rIsLPRing(const ring r)
BOOLEAN rHasMixedOrdering(const ring r)
static BOOLEAN rIsSyzIndexRing(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 short rVar(const ring r)
#define rVar(r) (r->N)
BOOLEAN rHasGlobalOrdering(const ring r)
BOOLEAN rHasLocalOrMixedOrdering(const ring r)
int p_mLPmaxPossibleShift(poly p, const ring r)
#define pLPCopyAndShiftLM(p, sh)
BOOLEAN _p_LPLmDivisibleByNoComp(poly a, poly b, const ring r)
int p_mFirstVblock(poly p, const ring ri)
void k_SplitFrame(poly &m1, poly &m2, int at, const ring r)
void p_mLPshift(poly m, int sh, const ring ri)
#define pLPDivisibleBy(a, b)
#define pLPLmDivisibleBy(a, b)
ideal idInit(int idsize, int rank)
initialise an ideal / module
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
int idElem(const ideal F)
count non-zero elements
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
ideal id_MaxIdeal(const ring r)
initialise the maximal ideal (at 0)
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size
long totaldegreeWecart(poly p, ring r)
long maxdegreeWecart(poly p, int *l, ring r)
EXTERN_VAR short * ecartWeights
#define omGetStickyBinOfBin(B)
#define omMergeStickyBinIntoBin(A, B)