18#define PLURAL_INTERNAL_DECLARATIONS 1
21#define STDZ_EXHANGE_DURING_REDUCTION 0
39#define SBA_INTERRED_START 0
41#define SBA_PRODUCT_CRITERION 0
42#define SBA_PRINT_ZERO_REDUCTIONS 0
43#define SBA_PRINT_REDUCTION_STEPS 0
44#define SBA_PRINT_OPERATIONS 0
45#define SBA_PRINT_SIZE_G 0
46#define SBA_PRINT_SIZE_SYZ 0
47#define SBA_PRINT_PRODUCT_CRITERION 0
50#if SBA_PRINT_REDUCTION_STEPS
54#if SBA_PRINT_OPERATIONS
86#ifdef STDZ_EXCHANGE_DURING_REDUCTION
89 unsigned long not_sev = ~L->sev;
94 const unsigned long* sevT=strat->
sevT;
106 if (
j > strat->
tl)
return o;
127 if (
j > strat->
tl)
return o;
151 unsigned long not_sev = ~L->sev;
152 const unsigned long sevT0 = strat->
sevT[0];
156 const poly
T0p = strat->
T[0].p;
163#if defined(PDEBUG) || defined(PDIV_DEBUG)
185 const poly
T0p = strat->
T[0].t_p;
187 const poly
p = L->t_p;
189#if defined(PDEBUG) || defined(PDIV_DEBUG)
215 unsigned long not_sev = ~L->sev;
220 const unsigned long* sevT=strat->
sevT;
232 if (
j > strat->
tl)
return o;
233#if defined(PDEBUG) || defined(PDIV_DEBUG)
256 if (
j > strat->
tl)
return o;
257#if defined(PDEBUG) || defined(PDIV_DEBUG)
278 unsigned long not_sev = ~L->sev;
283 const unsigned long* sevS=strat->
sevS;
296 if (
j > strat->
sl)
return o;
297#if defined(PDEBUG) || defined(PDIV_DEBUG)
323 unsigned long not_sev = ~L->sev;
327 const unsigned long* sevT=strat->
sevT;
340 if (
j > strat->
tl)
return -1;
341#if defined(PDEBUG) || defined(PDIV_DEBUG)
360 if (
j > strat->
tl)
return -1;
361#if defined(PDEBUG) || defined(PDIV_DEBUG)
384 if (
j > strat->
tl)
return -1;
385#if defined(PDEBUG) || defined(PDIV_DEBUG)
403 if (
j > strat->
tl)
return -1;
404#if defined(PDEBUG) || defined(PDIV_DEBUG)
423 unsigned long not_sev = ~L->sev;
424 poly
p = L->GetLmCurrRing();
448 if (
j >
ende)
return -1;
449#if defined(PDEBUG) || defined(PDIV_DEBUG)
467 if (
j >
ende)
return -1;
468#if defined(PDEBUG) || defined(PDIV_DEBUG)
486 unsigned long not_sev = ~L->sev;
487 poly
p = L->GetLmCurrRing();
509 if (
j >
ende)
return -1;
510#if defined(PDEBUG) || defined(PDIV_DEBUG)
526 unsigned long not_sev = ~L->sev;
527 poly
p = L->GetLmCurrRing();
538 if (
j >
ende)
return -1;
539#if defined(PDEBUG) || defined(PDIV_DEBUG)
555 if (arg <= 0)
return 0;
557 if (arg%2 == 1) { arg--; }
679 if (
h->IsNull())
return 0;
680 if (strat->
tl<0)
return 1;
692 h->SetShortExpVector();
699#if STDZ_EXCHANGE_DURING_REDUCTION
727 if (
h->GetLmTailRing() ==
NULL)
756#if STDZ_EXCHANGE_DURING_REDUCTION
781 if (
h->GetLmTailRing() ==
NULL)
790 h->SetShortExpVector();
815 if (
h->pTotalDeg() >= (
long)strat->
tailRing->bitmask)
837 if (
h->IsNull())
return 0;
838 if (strat->
sl<0)
return 1;
846 h->SetShortExpVector();
856#if STDZ_EXCHANGE_DURING_REDUCTION
880 if (
h->GetLmTailRing() ==
NULL)
906#if STDZ_EXCHANGE_DURING_REDUCTION
933 if (
h->GetLmCurrRing() ==
NULL)
938 h->SetShortExpVector();
947 if (strat->
tl<0)
return 1;
948 if (
h->IsNull())
return 0;
961 h->SetShortExpVector();
983 if (
h->GetLmTailRing() ==
NULL)
996 if (
h->GetLmTailRing() ==
NULL)
1002 h->SetShortExpVector();
1027 if (
h->pTotalDeg() >= (
long)strat->
tailRing->bitmask)
1049 if (strat->
sl<0)
return 1;
1050 if (
h->IsNull())
return 0;
1060 h->SetShortExpVector();
1079 if (
h->GetLmTailRing() ==
NULL)
1092 if (
h->GetLmTailRing() ==
NULL)
1097 h->SetShortExpVector();
1109 if (strat->
tl<0)
return 1;
1121 h->SetShortExpVector();
1122 h_p =
h->GetLmTailRing();
1127 if (
j < 0)
return 1;
1129 li = strat->
T[
j].pLength;
1139 if (li<=0) li=strat->
T[
j].GetpLength();
1149 if ((strat->
T[
i].pLength < li)
1157 li = strat->
T[
i].pLength;
1158 if (li<=0) li=strat->
T[
i].GetpLength();
1182#if SBA_PRINT_REDUCTION_STEPS
1185#if SBA_PRINT_OPERATIONS
1198 h_p =
h->GetLmTailRing();
1214 else if (
h->t_p!=
NULL)
1233 else if (
h->t_p!=
NULL)
1242 h->SetShortExpVector();
1292 assume(
PR->GetLmCurrRing() !=
PW->GetLmCurrRing());
1294 Red->HeadNormalize();
1328 if (strat->
tl<0)
return 1;
1334 PrintS(
"------- IN REDSIG -------\n");
1341 PrintS(
"---------------------------\n");
1353 h->SetShortExpVector();
1354 h_p =
h->GetLmTailRing();
1364 li = strat->
T[
j].pLength;
1365 if (li<=0) li=strat->
T[
j].GetpLength();
1382 if ((strat->
T[
i].pLength < li)
1390 li = strat->
T[
i].pLength;
1391 if (li<=0) li=strat->
T[
i].GetpLength();
1413 Print(
"BEFORE REDUCTION WITH %d:\n",
ii);
1414 PrintS(
"--------------------------------\n");
1421 PrintS(
"--------------------------------\n");
1422 printf(
"INDEX OF REDUCER T: %d\n",
ii);
1425#if SBA_PRINT_REDUCTION_STEPS
1429#if SBA_PRINT_OPERATIONS
1453 h_p =
h->GetLmTailRing();
1459 h->SetShortExpVector();
1508 if (strat->
tl<0)
return 1;
1514 Print(
"------- IN REDSIG -------\n");
1521 Print(
"---------------------------\n");
1533 h->SetShortExpVector();
1534 h_p =
h->GetLmTailRing();
1556 h->i_r1 = strat->
tl;
1559 if (
h->GetLmTailRing() ==
NULL)
1589 li = strat->
T[
j].pLength;
1590 if (li<=0) li=strat->
T[
j].GetpLength();
1606 if ((strat->
T[
i].pLength < li)
1614 li = strat->
T[
i].pLength;
1615 if (li<=0) li=strat->
T[
i].GetpLength();
1637 Print(
"BEFORE REDUCTION WITH %d:\n",
ii);
1638 Print(
"--------------------------------\n");
1645 Print(
"--------------------------------\n");
1646 printf(
"INDEX OF REDUCER T: %d\n",
ii);
1674#if SBA_PRINT_REDUCTION_STEPS
1678#if SBA_PRINT_OPERATIONS
1702 h_p =
h->GetLmTailRing();
1708 h->SetShortExpVector();
1747 p =
h = L->GetLmTailRing();
1749 return L->GetLmCurrRing();
1757 Ln.sevSig = L->sevSig;
1758 Ln.pLength = L->GetpLength() - 1;
1773 Ln.SetShortExpVector();
1808#if SBA_PRINT_REDUCTION_STEPS
1812#if SBA_PRINT_OPERATIONS
1827 }
while (!
Ln.IsNull());
1855 return L->GetLmCurrRing();
1864 if (strat->
tl<0)
return 1;
1874 h->SetShortExpVector();
1875 poly
h_p =
h->GetLmTailRing();
1880 if (
j < 0)
return 1;
1882 li = strat->
T[
j].pLength;
1893 if (li<=0) li=strat->
T[
j].GetpLength();
1903 if ((strat->
T[
i].pLength < li)
1911 li = strat->
T[
i].pLength;
1912 if (li<=0) li=strat->
T[
i].GetpLength();
1937#if SBA_PRINT_REDUCTION_STEPS
1940#if SBA_PRINT_OPERATIONS
1953 h_p=
h->GetLmTailRing();
1970 else if (
h->t_p!=
NULL)
1989 else if (
h->t_p!=
NULL)
1998 h->SetShortExpVector();
2037 if (
h->pTotalDeg() >= (
long)strat->
tailRing->bitmask)
2069 if (strat->
tl<0)
return 1;
2079 d =
reddeg =
h->GetpFDeg() +
h->ecart;
2080 h->SetShortExpVector();
2081 h_p =
h->GetLmTailRing();
2087 if (
j < 0)
return 1;
2089 ei = strat->
T[
j].ecart;
2090 li = strat->
T[
j].pLength;
2099 if (li<=0) li=strat->
T[
j].GetpLength();
2107 if (
i > strat->
tl)
break;
2112 strat->
T[
i].GetpLength();
2113 if (((strat->
T[
i].ecart <
ei) && (
ei>
h->ecart))
2114 || ((strat->
T[
i].ecart <=
h->ecart) && (strat->
T[
i].pLength < li)))
2119 ei = strat->
T[
i].ecart;
2120 li = strat->
T[
i].pLength;
2169#if SBA_PRINT_REDUCTION_STEPS
2172#if SBA_PRINT_OPERATIONS
2199 else if (
h->t_p!=
NULL)
2218 else if (
h->t_p!=
NULL)
2226 h->SetShortExpVector();
2227 h_d =
h->SetpFDeg();
2267 Print(
" degree jumped: -> L%d\n",
at);
2277 if (
h->pTotalDeg()+
h->ecart >= (
long)strat->
tailRing->bitmask)
2314 P.SetShortExpVector();
2435 P.SetShortExpVector();
2510 P.SetShortExpVector();
2573 P.SetShortExpVector();
2587 P.SetShortExpVector();
2641#ifdef HAVE_TAIL_RING
2657 while (strat->
Ll >= 0)
2664 while (strat->
Ll >= 0)
2677 while ((strat->
Ll >= 0)
2678 && (strat->
L[strat->
Ll].p1!=
NULL) && (strat->
L[strat->
Ll].p2!=
NULL)
2683 if (strat->
Ll<0)
break;
2688 strat->
P = strat->
L[strat->
Ll];
2718 else if (strat->
P.p1 ==
NULL)
2720 if (strat->
minim > 0)
2726 if ((strat->
P.p ==
NULL) && (strat->
P.t_p ==
NULL))
2750 strat->
P.GetP(strat->
lmBin);
2759 int pos=
posInS(strat,strat->
sl,strat->
P.p,strat->
P.ecart);
2774 strat->
P.pCleardenom();
2778 strat->
P.pCleardenom();
2799 if (strat->
minim==1)
2820 strat->
P.SetShortExpVector();
2827 strat->
enterS(strat->
P, pos, strat, strat->
tl);
2850 if (strat->
s_poly(strat))
2855 int pos=
posInS(strat,strat->
sl,strat->
P.p,strat->
P.ecart);
2861 strat->
enterS(strat->
P, pos, strat, strat->
tl);
2865 else if (strat->
P.p1 ==
NULL && strat->
minim > 0)
2907#ifdef HAVE_TAIL_RING
2929 for(
int i = 0;
i<=strat->
sl;
i++)
2964 return (strat->
Shdl);
2976#if SBA_PRINT_ZERO_REDUCTIONS
2979#if SBA_PRINT_PRODUCT_CRITERION
2986#if SBA_PRINT_SIZE_SYZ
2990#if SBA_PRINT_REDUCTION_STEPS
2994#if SBA_PRINT_OPERATIONS
3026 F->m[
i] = F->m[
i+1];
3049 F->m[
i] = F->m[
i+1];
3082 F->m[
j] = F->m[
j-1];
3096#if SBA_INTERRED_START
3100 printf(
"SBA COMPUTATIONS DONE IN THE FOLLOWING RING:\n");
3134#ifdef HAVE_TAIL_RING
3152 strat->
enterS(strat->
L[strat->
Ll-(
i)], strat->
sl+1, strat, strat->
tl);
3162 while (strat->
Ll >= 0)
3205 strat->
P = strat->
L[strat->
Ll];
3211 if (!strat->
rewCrit2(strat->
P.sig, ~strat->
P.sevSig, strat->
P.GetLmCurrRing(), strat, strat->
P.checked+1))
3215 PrintS(
"SIG OF NEXT PAIR TO HANDLE IN SIG-BASED ALGORITHM\n");
3216 PrintS(
"-------------------------------------------------\n");
3221 PrintS(
"-------------------------------------------------\n");
3256 else if (strat->
P.p1 ==
NULL)
3258 if (strat->
minim > 0)
3264 if (strat->
P.p ==
NULL && strat->
P.t_p ==
NULL)
3272 PrintS(
"Poly before red: ");
3276#if SBA_PRODUCT_CRITERION
3277 if (strat->
P.prod_crit)
3279#if SBA_PRINT_PRODUCT_CRITERION
3282 int pos =
posInSyz(strat, strat->
P.sig);
3308 strat->
P.p =
pNeg(strat->
P.p);
3309 strat->
P.sig =
pNeg(strat->
P.sig);
3312 if(strat->
P.sig !=
NULL)
3314 if(strat->
P.p !=
NULL)
3326 strat->
P.sig =
NULL;
3330 strat->
enterS(strat->
P, 0, strat, strat->
tl);
3348 PrintS(
"Poly after red: ");
3350 pWrite(strat->
P.GetLmCurrRing());
3357 if(strat->
P.p !=
NULL)
3361 message((strat->honey ? strat->P.ecart : 0),
3373 strat->
P.GetP(strat->
lmBin);
3377 (strat->
P).FDeg = (strat->
P).pFDeg();
3389 int pos = strat->
sl+1;
3408 strat->
P.pCleardenom();
3412 strat->
P.pCleardenom();
3428 strat->
enterS(strat->
P, 0, strat, strat->
tl);
3447 strat->
enterS(strat->
P, 0, strat, strat->
tl);
3453 if(strat->
P.p ==
NULL)
3460 for (
int jj = 0;
jj<strat->
tl+1;
jj++)
3470 for (
int jj = 0;
jj<strat->
tl+1;
jj++)
3482 if (strat->
minim==1)
3503 strat->
T[strat->
tl].is_sigsafe =
FALSE;
3517 strat->
enterS(strat->
P, pos, strat, strat->
tl);
3521 for (
int tk=0;
tk<strat->
sl+1;
tk++)
3552 *
sizeof(
unsigned long));
3594 for (
int i=0;
i<strat->
sl; ++
i)
3614 for (
int j=0;
j<strat->
sl; ++
j)
3652 printf(
"---------------------------\n");
3653 Print(
" %d. ELEMENT ADDED TO GCURR:\n",strat->
sl+1);
3691#if SBA_PRINT_ZERO_REDUCTIONS
3700 int pos =
posInSyz(strat, strat->
P.sig);
3704 Print(
"ADDING STUFF TO SYZ : ");
3725 printf(
"\nEnded with no SigDrop\n");
3731 if(strat->
P.sig !=
NULL)
3770#ifdef HAVE_TAIL_RING
3786#if SBA_PRINT_SIZE_SYZ
3815 for(;
k>=0 && (strat->
L[
k].p1 !=
NULL || strat->
L[
k].p2 !=
NULL);
k--)
3825 for(;
k>=0 && strat->
L[
k].p1 ==
NULL && strat->
L[
k].p2 ==
NULL;
k--)
3828 strat->
enterS(strat->
L[
k], strat->
sl+1, strat, strat->
tl);
3836 for(
k=strat->
sl;
k>=0;
k--)
3881#if SBA_PRINT_ZERO_REDUCTIONS
3882 printf(
"----------------------------------------------------------\n");
3886#if SBA_PRINT_REDUCTION_STEPS
3887 printf(
"----------------------------------------------------------\n");
3890#if SBA_PRINT_OPERATIONS
3893#if SBA_PRINT_REDUCTION_STEPS
3894 printf(
"- - - - - - - - - - - - - - - - - - - - - - - - - - - - - \n");
3897#if SBA_PRINT_OPERATIONS
3900#if SBA_PRINT_REDUCTION_STEPS
3901 printf(
"- - - - - - - - - - - - - - - - - - - - - - - - - - - - - \n");
3906#if SBA_PRINT_OPERATIONS
3912 printf(
"----------------------------------------------------------\n");
3917#if SBA_PRINT_SIZE_SYZ
3919 printf(
"----------------------------------------------------------\n");
3922#if SBA_PRINT_PRODUCT_CRITERION
3926 return (strat->
Shdl);
4277 while (strat->
tl >= 0)
4279 if(!strat->
T[strat->
tl].is_redundant)
4282 h.p = strat->
T[strat->
tl].p;
4283 h.tailRing = strat->
T[strat->
tl].tailRing;
4284 h.t_p = strat->
T[strat->
tl].t_p;
4325 strat->
P = strat->
L[strat->
Ll];
4329 PrintS(
"NEXT PAIR TO HANDLE IN INTERRED ALGORITHM\n");
4330 PrintS(
"-------------------------------------------------\n");
4335 PrintS(
"-------------------------------------------------\n");
4368 else if (strat->
P.p1 ==
NULL)
4370 if (strat->
minim > 0)
4377 if (strat->
P.p ==
NULL && strat->
P.t_p ==
NULL)
4388 PrintS(
"Poly before red: ");
4405 strat->
P.GetP(strat->
lmBin);
4416 pos =
posInS(strat,strat->
sl,strat->
P.p,strat->
P.ecart);
4420 pos =
posInS(strat,strat->
sl,strat->
P.p,strat->
P.ecart);
4428 strat->
P.pCleardenom();
4432 strat->
P.pCleardenom();
4449 if (strat->
minim==1)
4473 strat->
enterS(strat->
P, pos, strat, strat->
tl);
4476 PrintS(
"ELEMENT ADDED TO GCURR DURING INTERRED: ");
4511 strat->
T[
cc].is_sigsafe =
TRUE;
4519 for (
int cd=strat->
Ll;
cd>=0;
cd--)
4527 printf(
"\nAfter f5c sorting\n");
4528 for(
int i=0;
i<=strat->
sl;
i++)
4534 PrintS(
"------------------- STRAT S ---------------------\n");
4543 PrintS(
"-------------------------------------------------\n");
4544 PrintS(
"------------------- STRAT T ---------------------\n");
4553 PrintS(
"-------------------------------------------------\n");
4554 PrintS(
"------------------- STRAT L ---------------------\n");
4565 PrintS(
"-------------------------------------------------\n");
4606#ifdef HAVE_TAIL_RING
4622 while (strat->
Ll >= 0)
4629 while (strat->
Ll >= 0)
4642 while ((strat->
Ll >= 0)
4643 && (strat->
L[strat->
Ll].p1!=
NULL) && (strat->
L[strat->
Ll].p2!=
NULL)
4648 if (strat->
Ll<0)
break;
4653 strat->
P = strat->
L[strat->
Ll];
4683 else if (strat->
P.p1 ==
NULL)
4685 if (strat->
minim > 0)
4691 if ((strat->
P.p ==
NULL) && (strat->
P.t_p ==
NULL))
4715 strat->
P.GetP(strat->
lmBin);
4724 int pos=
posInS(strat,strat->
sl,strat->
P.p,strat->
P.ecart);
4739 strat->
P.pCleardenom();
4743 strat->
P.pCleardenom();
4772 if (strat->
minim==1)
4797 strat->
enterS(strat->
P, pos, strat, strat->
tl);
4810 if (strat->
s_poly(strat))
4815 int pos=
posInS(strat,strat->
sl,strat->
P.p,strat->
P.ecart);
4818 strat->
enterS(strat->
P, pos, strat, strat->
tl);
4824 else if (strat->
P.p1 ==
NULL && strat->
minim > 0)
4841 for (
int k = 0;
k <= strat->
sl; ++
k)
4844 for (
int j = 0;
j<=strat->
tl; ++
j)
4874#ifdef HAVE_TAIL_RING
4881 WarnS(
"reduction with S is not yet supported by Letterplace");
4898 for(
int i = 0;
i<=strat->
sl;
i++)
4933 return (strat->
Shdl);
4956 if (
h->IsNull())
return 0;
4964 d =
h->GetpFDeg() +
h->ecart;
4967 h->SetShortExpVector();
4973 h->SetDegStuffReturnLDeg(strat->
LDegLast);
4978 strat->
T[
j].pNorm();
5004 h->SetShortExpVector();
5017 h->SetDegStuffReturnLDeg(strat->
LDegLast);
5027 if (strat->
T[
j].ecart <=
h->ecart)
5028 h->ecart = d -
h->GetpFDeg();
5030 h->ecart = d -
h->GetpFDeg() + strat->
T[
j].ecart -
h->ecart;
5032 d =
h->GetpFDeg() +
h->ecart;
5035 d =
h->SetDegStuffReturnLDeg(strat->
LDegLast);
static int si_max(const int a, const int b)
CanonicalForm cd(bCommonDen(FF))
static void sort(int **points, int sizePoints)
static CanonicalForm bound(const CFMatrix &M)
KINLINE poly kNoetherTail()
int(* posInL)(const LSet set, const int length, LObject *L, const kStrategy strat)
pShallowCopyDeleteProc p_shallow_copy_delete
void(* enterS)(LObject &h, int pos, kStrategy strat, int atR)
char completeReduce_retry
void(* initEcart)(TObject *L)
int(* posInT)(const TSet T, const int tl, LObject &h)
int(* red)(LObject *L, kStrategy strat)
BOOLEAN(* rewCrit2)(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
char posInLDependsOnLength
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 number n_EucNorm(number a, const coeffs r)
static FORCE_INLINE number n_QuotRem(number a, number b, number *q, const coeffs r)
static FORCE_INLINE BOOLEAN n_Greater(number a, number b, const coeffs r)
ordered fields: TRUE iff 'a' is larger than 'b'; in Z/pZ: TRUE iff la > lb, where la and lb are the l...
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff 'n' represents the zero element.
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
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 BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
void WerrorS(const char *s)
#define idDelete(H)
delete an ideal
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
BOOLEAN idInsertPolyOnPos(ideal I, poly p, int pos)
insert p into I on position pos
static intvec * idSort(ideal id, BOOLEAN nolex=TRUE)
static BOOLEAN length(leftv result, leftv arg)
KINLINE poly redtailBba_Ring(poly p, int pos, kStrategy strat)
KINLINE poly redtailBba(poly p, int pos, kStrategy strat, BOOLEAN normalize)
KINLINE poly redtailBbaBound(poly p, int pos, kStrategy strat, int bound, BOOLEAN normalize)
KINLINE void clearS(poly p, unsigned long p_sev, int *at, int *k, kStrategy strat)
KINLINE poly redtailBba_Z(poly p, int pos, kStrategy strat)
void kBucketClear(kBucket_pt bucket, poly *p, int *length)
BOOLEAN kbTest(kBucket_pt bucket)
Tests.
void kBucket_Minus_m_Mult_p(kBucket_pt bucket, poly m, poly p, int *l, poly spNoether)
Bpoly == Bpoly - m*p; where m is a monom Does not destroy p and m assume (*l <= 0 || pLength(p) == *l...
void kBucketDestroy(kBucket_pt *bucket_pt)
void kBucketInit(kBucket_pt bucket, poly lm, int length)
kBucket_pt kBucketCreate(const ring bucket_ring)
Creation/Destruction of buckets.
void kBucketPolyRedNF(kBucket_pt bucket, poly p1, int l1, poly spNoether)
const poly kBucketGetLm(kBucket_pt bucket)
int kBucketCanonicalize(kBucket_pt bucket)
Canonicalizes Bpoly, i.e. converts polys of buckets into one poly in one bucket: Returns number of bu...
void khCheck(ideal Q, intvec *w, intvec *hilb, int &eledeg, int &count, kStrategy strat)
int ksReducePolyLC(LObject *PR, TObject *PW, poly spNoether, number *coef, kStrategy strat)
void ksCreateSpoly(LObject *Pair, poly spNoether, int use_buckets, ring tailRing, poly m1, poly m2, TObject **R)
int ksReducePoly(LObject *PR, TObject *PW, poly spNoether, number *coef, poly *mon, kStrategy strat, BOOLEAN reduce)
int ksReducePolySig(LObject *PR, TObject *PW, long, poly spNoether, number *coef, kStrategy strat)
int ksReducePolySigRing(LObject *PR, TObject *PW, long, poly spNoether, number *coef, kStrategy strat)
ideal kStdShift(ideal F, ideal Q, tHomog h, intvec **w, intvec *hilb, int syzComp, int newIdeal, intvec *vw, BOOLEAN rightGB)
ideal kInterRed(ideal F, const ideal Q)
void initBba(kStrategy strat)
void initSba(ideal F, kStrategy strat)
int redRing_Z(LObject *h, kStrategy strat)
poly kFindZeroPoly(poly input_p, ring leadRing, ring tailRing)
int redFirstShift(LObject *h, kStrategy strat)
int kFindDivisibleByInT_Z(const kStrategy strat, const LObject *L, const int start)
int kFindDivisibleByInS(const kStrategy strat, int *max_ind, LObject *L)
return -1 if no divisor is found number of first divisor in S, otherwise
int kTestDivisibleByT0_Z(const kStrategy strat, const LObject *L)
tests if T[0] divides the leading monomial of L, returns -1 if not
poly redNFBound(poly h, int &max_ind, int nonorm, kStrategy strat, int bound)
poly kNF2(ideal F, ideal Q, poly q, kStrategy strat, int lazyReduce)
VAR int(* test_PosInL)(const LSet set, const int length, LObject *L, const kStrategy strat)
int redHoney(LObject *h, kStrategy strat)
static int kFindDivisibleByInS_Z(const kStrategy strat, LObject *L)
int kFindNextDivisibleByInS(const kStrategy strat, int start, int max_ind, LObject *L)
static long ind_fact_2(long arg)
int redHomog(LObject *h, kStrategy strat)
ideal sba(ideal F0, ideal Q, intvec *w, intvec *hilb, kStrategy strat)
ideal bba(ideal F, ideal Q, intvec *w, intvec *hilb, kStrategy strat)
int redLazy(LObject *h, kStrategy strat)
int redSigRing(LObject *h, kStrategy strat)
int kFindDivisibleByInS_noCF(const kStrategy strat, int *max_ind, LObject *L)
poly redtailSba(LObject *L, int pos, kStrategy strat, BOOLEAN withT, BOOLEAN normalize)
KINLINE int ksReducePolyTailSig(LObject *PR, TObject *PW, LObject *Red, kStrategy strat)
ideal rightgb(ideal F, const ideal Q)
poly redNF(poly h, int &max_ind, int nonorm, kStrategy strat)
static int redRing_S(LObject *h, kStrategy strat)
int redSig(LObject *h, kStrategy strat)
void kDebugPrint(kStrategy strat)
void f5c(kStrategy strat, int &olddeg, int &minimcnt, int &hilbeledeg, int &hilbcount, int &srmax, int &lrmax, int &reduc, ideal Q, intvec *w, intvec *hilb)
VAR int(* test_PosInT)(const TSet T, const int tl, LObject &h)
poly kNF2Bound(ideal F, ideal Q, poly q, int bound, kStrategy strat, int lazyReduce)
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
ideal bbaShift(ideal F, ideal Q, intvec *w, intvec *hilb, kStrategy strat)
static int redRing_Z_S(LObject *h, kStrategy strat)
void initSbaPos(kStrategy strat)
void message(int i, int *reduc, int *olddeg, kStrategy strat, int red_result)
void initBuchMora(ideal F, ideal Q, kStrategy strat)
void enterSyz(LObject &p, kStrategy strat, int atT)
void enterT(LObject &p, kStrategy strat, int atT)
void enterTShift(LObject p, kStrategy strat, int atT)
BOOLEAN kTest(kStrategy strat)
TObject * kFindDivisibleByInS_T(kStrategy strat, int end_pos, LObject *L, TObject *T, long ecart)
BOOLEAN kTest_TS(kStrategy strat)
void enterpairsSig(poly h, poly hSig, int hFrom, int k, int ecart, int pos, kStrategy strat, int atR)
void enterL(LSet *set, int *length, int *LSetmax, LObject p, int at)
void enterpairs(poly h, int k, int ecart, int pos, kStrategy strat, int atR)
void redtailBbaAlsoLC_Z(LObject *L, int end_pos, kStrategy strat)
void initHilbCrit(ideal, ideal, intvec **hilb, kStrategy strat)
int posInSMonFirst(const kStrategy strat, const int length, const poly p)
void superenterpairsSig(poly h, poly hSig, int hFrom, int k, int ecart, int pos, kStrategy strat, int atR)
void initBuchMoraPos(kStrategy strat)
void initS(ideal F, ideal Q, kStrategy strat)
BOOLEAN kStratChangeTailRing(kStrategy strat, LObject *L, TObject *T, unsigned long expbound)
ring sbaRing(kStrategy strat, const ring r, BOOLEAN, int)
void postReduceByMon(LObject *h, kStrategy strat)
used for GB over ZZ: intermediate reduction by monomial elements background: any known constant eleme...
void enterpairsShift(poly h, int k, int ecart, int pos, kStrategy strat, int atR)
BOOLEAN kTest_L(LObject *L, kStrategy strat, BOOLEAN testp, int lpos, TSet T, int tlength)
void exitBuchMora(kStrategy strat)
void messageStatSBA(int hilbcount, kStrategy strat)
int posInS(const kStrategy strat, const int length, const poly p, const int ecart_p)
void initSyzRules(kStrategy strat)
void initSbaBuchMora(ideal F, ideal Q, kStrategy strat)
BOOLEAN kCheckSpolyCreation(LObject *L, kStrategy strat, poly &m1, poly &m2)
void cleanT(kStrategy strat)
int posInSyz(const kStrategy strat, poly sig)
void replaceInLAndSAndT(LObject &p, int tj, 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)
poly redtailBba_NF(poly p, kStrategy strat)
void exitSba(kStrategy strat)
void deleteInL(LSet set, int *length, int j, kStrategy strat)
void kStratInitChangeTailRing(kStrategy strat)
void initBuchMoraCrit(kStrategy strat)
void completeReduce(kStrategy strat, BOOLEAN withT)
void initBuchMoraPosRing(kStrategy strat)
void postReduceByMonSig(LObject *h, kStrategy strat)
void messageSets(kStrategy strat)
void deleteInS(int i, kStrategy strat)
BOOLEAN sbaCheckGcdPair(LObject *h, kStrategy strat)
int posInLF5CRing(const LSet set, int start, const int length, LObject *p, const kStrategy)
void initEcartBBA(TObject *h)
void enterSBbaShift(LObject &p, int atS, kStrategy strat, int atR)
void messageStat(int hilbcount, 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)
void cancelunit(LObject *L, BOOLEAN inNF)
int ksReducePolyGCD(LObject *PR, TObject *PW, poly spNoether=NULL, number *coef=NULL, kStrategy strat=NULL)
int kFindSameLMInT_Z(const kStrategy strat, const LObject *L, const int start=0)
#define REDNF_CANONICALIZE
static void kDeleteLcm(LObject *P)
int ksReducePolyZ(LObject *PR, TObject *PW, poly spNoether=NULL, number *coef=NULL, kStrategy strat=NULL)
#define REDTAIL_CANONICALIZE
static void nc_kBucketPolyRed_NF(kBucket_pt b, poly p, number *c, BOOLEAN reduce)
void mult(unsigned long *result, unsigned long *a, unsigned long *b, unsigned long p, int dega, int degb)
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)
number ndQuotRem(number a, number b, number *r, const coeffs R)
#define omRealloc0Size(addr, o_size, size)
#define TEST_OPT_INTSTRATEGY
#define SI_RESTORE_OPT1(A)
#define TEST_OPT_DEGBOUND
#define TEST_OPT_REDTHROUGH
#define TEST_OPT_REDTAIL_SYZ
#define TEST_OPT_CONTENTSB
#define TEST_OPT_NOT_BUCKETS
poly p_ISet(long i, const ring r)
returns the poly representing the integer i
unsigned long p_GetShortExpVector(const poly p, const ring r)
poly p_NSet(number n, const ring r)
returns the poly representing the number n, destroys n
void pEnlargeSet(poly **p, int l, int increment)
static int pLength(poly a)
static poly p_Add_q(poly p, poly q, const ring r)
static poly p_Mult_q(poly p, poly q, const ring r)
static void p_ExpVectorAdd(poly p1, poly p2, const ring r)
#define p_LmEqual(p1, p2, r)
static void p_SetExpV(poly p, int *ev, const ring r)
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent @Note: VarOffset encodes the position in p->exp
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
static void p_ExpVectorSub(poly p1, poly p2, const ring r)
static void p_Setm(poly p, const ring r)
static number p_SetCoeff(poly p, number n, ring r)
static poly p_Head(const poly p, const ring r)
copy the (leading) term of p
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:
static BOOLEAN p_LmDivisibleBy(poly a, poly b, const ring r)
static void p_Delete(poly *p, const ring r)
static void p_GetExpV(poly p, int *ev, const ring r)
static poly p_Mult_mm(poly p, poly m, const ring r)
static poly p_LmDeleteAndNext(poly p, const ring r)
static poly p_Copy(poly p, const ring r)
returns a copy of p
void rChangeCurrRing(ring r)
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Compatibility layer for legacy polynomial operations (over currRing)
#define pHead(p)
returns newly allocated copy of Lm(p), coef is copied, next=NULL, p might be NULL
#define pGetComp(p)
Component.
#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 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....
static void pLmFree(poly p)
frees the space of the monomial m, assumes m != NULL coef is not freed, m is not advanced
#define pLmCmp(p, q)
returns 0|1|-1 if p=q|p>q|p<q w.r.t monomial ordering
#define pCopy(p)
return a copy of the poly
ideal idrMoveR(ideal &id, ring src_r, ring dest_r)
ideal idrMoveR_NoSort(ideal &id, ring src_r, ring dest_r)
void PrintS(const char *s)
void Werror(const char *fmt,...)
void rWrite(ring r, BOOLEAN details)
void rDelete(ring r)
unconditionally deletes fields in r
static BOOLEAN rField_is_Z(const ring r)
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
static BOOLEAN rField_is_Zn(const ring r)
static BOOLEAN rIsLPRing(const ring r)
BOOLEAN rHasLocalOrMixedOrdering(const ring r)
#define rField_is_Ring(R)
static int SI_LOG2_LONG(long v)
ideal idInit(int idsize, int rank)
initialise an ideal / module
void id_DelDiv(ideal id, const ring r)
delete id[j], if LT(j) == coeff*mon*LT(i) and vice versa, i.e., delete id[i], if LT(i) == coeff*mon*L...
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size
static poly normalize(poly next_p, ideal add_generators, syStrategy syzstr, int *g_l, int *p_l, int crit_comp)
int F1(int a1, int &r1)
F1.