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
51VAR long sba_reduction_steps;
52VAR long sba_interreduction_steps;
54#if SBA_PRINT_OPERATIONS
55VAR long sba_operations;
56VAR long sba_interreduction_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];
153 number orest,rest,
mult;
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;
221 number rest, orest,
mult;
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;
284 number rest, orest,
mult;
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)
345 if (!(sevT[
j] & not_sev)
360 if (
j > strat->
tl)
return -1;
361#if defined(PDEBUG) || defined(PDIV_DEBUG)
365 if (!(sevT[
j] & not_sev)
384 if (
j > strat->
tl)
return -1;
385#if defined(PDEBUG) || defined(PDIV_DEBUG)
389 if (!(sevT[
j] & not_sev) &&
403 if (
j > strat->
tl)
return -1;
404#if defined(PDEBUG) || defined(PDIV_DEBUG)
408 if (!(sevT[
j] & not_sev) &&
423 unsigned long not_sev = ~L->sev;
424 poly
p = L->GetLmCurrRing();
438 ende=
posInS(strat,*max_ind,
p,0)+1;
439 if (ende>(*max_ind)) ende=(*max_ind);
448 if (
j > ende)
return -1;
449#if defined(PDEBUG) || defined(PDIV_DEBUG)
453 if ( !(strat->
sevS[
j] & not_sev) &&
467 if (
j > ende)
return -1;
468#if defined(PDEBUG) || defined(PDIV_DEBUG)
472 if ( !(strat->
sevS[
j] & not_sev) &&
486 unsigned long not_sev = ~L->sev;
487 poly
p = L->GetLmCurrRing();
501 ende=
posInS(strat,*max_ind,
p,0)+1;
502 if (ende>(*max_ind)) ende=(*max_ind);
509 if (
j > ende)
return -1;
510#if defined(PDEBUG) || defined(PDIV_DEBUG)
514 if ( !(strat->
sevS[
j] & not_sev) &&
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)
543 if ( !(strat->
sevS[
j] & not_sev) &&
556 if (arg <= 0)
return 0;
558 if (arg%2 == 1) { arg--; }
576 poly zeroPoly =
NULL;
577 unsigned long a = (
unsigned long)
pGetCoeff(
p);
584 for (
int i = 1;
i <= leadRing->N;
i++)
593 poly lead_mult =
p_ISet(1, tailRing);
594 if (
n_GetChar(leadRing->cf) <= k_ind2 + a_ind2)
596 int too_much = k_ind2 + a_ind2 -
n_GetChar(leadRing->cf);
598 zeroPoly =
p_ISet(a, tailRing);
599 for (
int i = 1;
i <= leadRing->N;
i++)
612 for (
int j = 1;
j <= s_exp;
j++)
629 p_Setm(lead_mult, tailRing);
630 zeroPoly =
p_Mult_mm(zeroPoly, lead_mult, tailRing);
632 for (
int i = 1;
i <= leadRing->N;
i++)
685 if (
h->IsNull())
return 0;
686 if (strat->
tl<0)
return 1;
696 long reddeg =
h->GetpFDeg();
698 h->SetShortExpVector();
705#if STDZ_EXCHANGE_DURING_REDUCTION
733 if (
h->GetLmTailRing() ==
NULL)
762#if STDZ_EXCHANGE_DURING_REDUCTION
787 if (
h->GetLmTailRing() ==
NULL)
796 h->SetShortExpVector();
801 (strat->
Ll >= 0) && ((d > reddeg) || (pass > strat->
LazyPass)))
806 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
821 if (
h->pTotalDeg() >= (
long)strat->
tailRing->bitmask)
826 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
843 if (
h->IsNull())
return 0;
844 if (strat->
sl<0)
return 1;
854 long reddeg =
h->GetpFDeg();
855 h->SetShortExpVector();
856 int max_ind=strat->
sl;
865#if STDZ_EXCHANGE_DURING_REDUCTION
889 if (
h->GetLmTailRing() ==
NULL)
915#if STDZ_EXCHANGE_DURING_REDUCTION
929 redtailBbaAlsoLC_Z_S(&h2,
j, strat);
942 if (
h->GetLmCurrRing() ==
NULL)
947 h->SetShortExpVector();
956 if (strat->
tl<0)
return 1;
957 if (
h->IsNull())
return 0;
968 long reddeg =
h->GetpFDeg();
970 h->SetShortExpVector();
992 if (
h->GetLmTailRing() ==
NULL)
1005 if (
h->GetLmTailRing() ==
NULL)
1011 h->SetShortExpVector();
1016 (strat->
Ll >= 0) && ((d > reddeg) || (pass > strat->
LazyPass)))
1021 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
1022 if (at <= strat->Ll)
1036 if (
h->pTotalDeg() >= (
long)strat->
tailRing->bitmask)
1041 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
1058 if (strat->
sl<0)
return 1;
1059 if (
h->IsNull())
return 0;
1069 long reddeg =
h->GetpFDeg();
1072 h->SetShortExpVector();
1091 if (
h->GetLmTailRing() ==
NULL)
1104 if (
h->GetLmTailRing() ==
NULL)
1109 h->SetShortExpVector();
1123 if (strat->
tl<0)
return 1;
1128 int i,
j,at,pass,cnt,ii;
1136 h->SetShortExpVector();
1137 h_p =
h->GetLmTailRing();
1142 if (
j < 0)
return 1;
1144 li = strat->
T[
j].pLength;
1152 if (test_opt_length)
1154 if (li<=0) li=strat->
T[
j].GetpLength();
1157 unsigned long not_sev = ~ h->sev;
1164 if ((strat->
T[
i].pLength < li)
1172 li = strat->
T[
i].pLength;
1173 if (li<=0) li=strat->
T[
i].GetpLength();
1197#if SBA_PRINT_REDUCTION_STEPS
1198 sba_interreduction_steps++;
1200#if SBA_PRINT_OPERATIONS
1201 sba_interreduction_operations +=
pLength(strat->
T[ii].p);
1213 h_p =
h->GetLmTailRing();
1229 else if (
h->t_p!=
NULL)
1248 else if (
h->t_p!=
NULL)
1257 h->SetShortExpVector();
1269 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
1270 if (at <= strat->Ll)
1281 int dummy=strat->
sl;
1288 Print(
" lazy: -> L%d\n",at);
1307 assume(PR->GetLmCurrRing() != PW->GetLmCurrRing());
1309 Red->HeadNormalize();
1343 if (strat->
tl<0)
return 1;
1349 PrintS(
"------- IN REDSIG -------\n");
1356 PrintS(
"---------------------------\n");
1359 int i,
j,at,pass, ii;
1362 unsigned long not_sev;
1369 h->SetShortExpVector();
1370 h_p =
h->GetLmTailRing();
1380 li = strat->
T[
j].pLength;
1381 if (li<=0) li=strat->
T[
j].GetpLength();
1389 if (test_opt_length)
1398 if ((strat->
T[
i].pLength < li)
1406 li = strat->
T[
i].pLength;
1407 if (li<=0) li=strat->
T[
i].GetpLength();
1429 Print(
"BEFORE REDUCTION WITH %d:\n",ii);
1430 PrintS(
"--------------------------------\n");
1437 PrintS(
"--------------------------------\n");
1438 printf(
"INDEX OF REDUCER T: %d\n",ii);
1441#if SBA_PRINT_REDUCTION_STEPS
1443 sba_reduction_steps++;
1445#if SBA_PRINT_OPERATIONS
1447 sba_operations +=
pLength(strat->
T[ii].p);
1454 Print(
"SigSAFE: %d\n",sigSafe);
1469 h_p =
h->GetLmTailRing();
1475 h->SetShortExpVector();
1487 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
1488 if (at <= strat->Ll)
1490 int dummy=strat->
sl;
1498 Print(
" lazy: -> L%d\n",at);
1522 beforeredsig =
pCopy(
h->sig);
1524 if (strat->
tl<0)
return 1;
1530 Print(
"------- IN REDSIG -------\n");
1537 Print(
"---------------------------\n");
1540 int i,
j,at,pass, ii;
1543 unsigned long not_sev;
1550 h->SetShortExpVector();
1551 h_p =
h->GetLmTailRing();
1573 h->i_r1 = strat->
tl;
1576 if (
h->GetLmTailRing() ==
NULL)
1583 if(
pLtCmp(beforeredsig,
h->sig) == 1)
1606 li = strat->
T[
j].pLength;
1607 if (li<=0) li=strat->
T[
j].GetpLength();
1614 if (test_opt_length)
1623 if ((strat->
T[
i].pLength < li)
1631 li = strat->
T[
i].pLength;
1632 if (li<=0) li=strat->
T[
i].GetpLength();
1654 Print(
"BEFORE REDUCTION WITH %d:\n",ii);
1655 Print(
"--------------------------------\n");
1662 Print(
"--------------------------------\n");
1663 printf(
"INDEX OF REDUCER T: %d\n",ii);
1691#if SBA_PRINT_REDUCTION_STEPS
1693 sba_reduction_steps++;
1695#if SBA_PRINT_OPERATIONS
1697 sba_operations +=
pLength(strat->
T[ii].p);
1704 Print(
"SigSAFE: %d\n",sigSafe);
1719 h_p =
h->GetLmTailRing();
1725 h->SetShortExpVector();
1737 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
1738 if (at <= strat->Ll)
1740 int dummy=strat->
sl;
1748 Print(
" lazy: -> L%d\n",at);
1764 p =
h = L->GetLmTailRing();
1766 return L->GetLmCurrRing();
1774 Ln.sevSig = L->sevSig;
1775 Ln.pLength = L->GetpLength() - 1;
1790 Ln.SetShortExpVector();
1796 With = &(strat->
T[
j]);
1801 if (With ==
NULL)
break;
1825#if SBA_PRINT_REDUCTION_STEPS
1827 sba_reduction_steps++;
1829#if SBA_PRINT_OPERATIONS
1831 sba_operations +=
pLength(With->p);
1841 pNext(
h) = Ln.LmExtractAndIter();
1844 }
while (!Ln.IsNull());
1847 if (Ln.IsNull())
goto all_done;
1848 if (! withT) With_s.Init(
currRing);
1855 pNext(
h) = Ln.LmExtractAndIter();
1872 return L->GetLmCurrRing();
1881 if (strat->
tl<0)
return 1;
1887 long reddeg =
h->GetpFDeg();
1891 h->SetShortExpVector();
1892 poly h_p =
h->GetLmTailRing();
1897 if (
j < 0)
return 1;
1899 li = strat->
T[
j].pLength;
1908 if (test_opt_length)
1910 if (li<=0) li=strat->
T[
j].GetpLength();
1913 unsigned long not_sev = ~ h->sev;
1920 if ((strat->
T[
i].pLength < li)
1928 li = strat->
T[
i].pLength;
1929 if (li<=0) li=strat->
T[
i].GetpLength();
1954#if SBA_PRINT_REDUCTION_STEPS
1955 sba_interreduction_steps++;
1957#if SBA_PRINT_OPERATIONS
1958 sba_interreduction_operations +=
pLength(strat->
T[ii].p);
1970 h_p=
h->GetLmTailRing();
1987 else if (
h->t_p!=
NULL)
2006 else if (
h->t_p!=
NULL)
2015 h->SetShortExpVector();
2021 (strat->
Ll >= 0) && ((d > reddeg) || (pass > strat->
LazyPass)))
2024 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
2025 if (at <= strat->Ll)
2037 int dummy=strat->
sl;
2050 else if (d != reddeg)
2054 if (
h->pTotalDeg() >= (
long)strat->
tailRing->bitmask)
2059 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
2086 if (strat->
tl<0)
return 1;
2090 int i,
j,at,pass,ei, ii, h_d;
2096 d = reddeg =
h->GetpFDeg() +
h->ecart;
2097 h->SetShortExpVector();
2098 h_p =
h->GetLmTailRing();
2104 if (
j < 0)
return 1;
2106 ei = strat->
T[
j].ecart;
2107 li = strat->
T[
j].pLength;
2114 if (test_opt_length)
2116 if (li<=0) li=strat->
T[
j].GetpLength();
2119 unsigned long not_sev = ~ h->sev;
2124 if (
i > strat->
tl)
break;
2125 if (ei <= h->ecart)
break;
2129 strat->
T[
i].GetpLength();
2130 if (((strat->
T[
i].ecart < ei) && (ei>
h->ecart))
2131 || ((strat->
T[
i].ecart <=
h->ecart) && (strat->
T[
i].pLength < li)))
2136 ei = strat->
T[
i].ecart;
2137 li = strat->
T[
i].pLength;
2140 if (ei<=h->ecart)
break;
2161 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
2179 Print(
"\nwith T[%d]:",ii);
2186#if SBA_PRINT_REDUCTION_STEPS
2187 sba_interreduction_steps++;
2189#if SBA_PRINT_OPERATIONS
2190 sba_interreduction_operations += strat->
T[ii].pLength;
2216 else if (
h->t_p!=
NULL)
2235 else if (
h->t_p!=
NULL)
2243 h->SetShortExpVector();
2244 h_d =
h->SetpFDeg();
2249 h->ecart = d-h_d+ei-
h->ecart;
2261 && ((d > reddeg) || (pass > strat->
LazyPass))))
2265 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
2266 if (at <= strat->Ll)
2277 int dummy=strat->
sl;
2284 Print(
" degree jumped: -> L%d\n",at);
2290 else if (d > reddeg)
2294 if (
h->pTotalDeg()+
h->ecart >= (
long)strat->
tailRing->bitmask)
2299 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
2331 P.SetShortExpVector();
2335 if(is_ring) nonorm=
TRUE;
2454 P.SetShortExpVector();
2531 P.SetShortExpVector();
2600 P.SetShortExpVector();
2614 P.SetShortExpVector();
2640 int hilbeledeg=1,hilbcount=0,minimcnt=0;
2663 withT = ! strat->
homog;
2668#ifdef HAVE_TAIL_RING
2684 while (strat->
Ll >= 0)
2691 while (strat->
Ll >= 0)
2704 while ((strat->
Ll >= 0)
2705 && (strat->
L[strat->
Ll].p1!=
NULL) && (strat->
L[strat->
Ll].p2!=
NULL)
2710 if (strat->
Ll<0)
break;
2715 strat->
P = strat->
L[strat->
Ll];
2745 else if (strat->
P.p1 ==
NULL)
2747 if (strat->
minim > 0)
2753 if ((strat->
P.p ==
NULL) && (strat->
P.t_p ==
NULL))
2761 &olddeg,&reduc,strat, red_result);
2764 red_result = strat->
red(&strat->
P,strat);
2774 if (red_result == 1)
2777 strat->
P.GetP(strat->
lmBin);
2786 int pos=
posInS(strat,strat->
sl,strat->
P.p,strat->
P.ecart);
2801 strat->
P.pCleardenom();
2805 strat->
P.pCleardenom();
2814 strat->
P.p =
redtailBba(&(strat->
P),pos-1,strat, withT);
2826 if (strat->
minim==1)
2833 strat->
M->m[minimcnt]=strat->
P.p2;
2837 pNext(strat->
M->m[minimcnt])
2847 strat->
P.SetShortExpVector();
2854 strat->
enterS(strat->
P, pos, strat, strat->
tl);
2869 if (hilb!=
NULL)
khCheck(
Q,
w,hilb,hilbeledeg,hilbcount,strat);
2877 if (strat->
s_poly(strat))
2882 int pos=
posInS(strat,strat->
sl,strat->
P.p,strat->
P.ecart);
2888 strat->
enterS(strat->
P, pos, strat, strat->
tl);
2892 else if (strat->
P.p1 ==
NULL && strat->
minim > 0)
2898 memset(&(strat->
P), 0,
sizeof(strat->
P));
2934#ifdef HAVE_TAIL_RING
2956 for(
int i = 0;
i<=strat->
sl;
i++)
2991 return (strat->
Shdl);
3003#if SBA_PRINT_ZERO_REDUCTIONS
3004 long zeroreductions = 0;
3006#if SBA_PRINT_PRODUCT_CRITERION
3007 long product_criterion = 0;
3011 int size_g_non_red = 0;
3013#if SBA_PRINT_SIZE_SYZ
3017#if SBA_PRINT_REDUCTION_STEPS
3018 sba_reduction_steps = 0;
3019 sba_interreduction_steps = 0;
3021#if SBA_PRINT_OPERATIONS
3023 sba_interreduction_operations = 0;
3027 ring sRing, currRingOld;
3032 if (sRing!=currRingOld)
3051 dummy =
pCopy(F->m[0]);
3053 F->m[
i] = F->m[
i+1];
3074 dummy =
pCopy(F->m[0]);
3076 F->m[
i] = F->m[
i+1];
3094 for (
int i=0;
i<
sort->length();++
i)
3095 F->m[
i] = F1->m[(*
sort)[
i]-1];
3109 F->m[
j] = F->m[
j-1];
3123#if SBA_INTERRED_START
3127 printf(
"SBA COMPUTATIONS DONE IN THE FOLLOWING RING:\n");
3129 printf(
"ordSgn = %d\n",
currRing->OrdSgn);
3132 int srmax,lrmax, red_result = 1;
3134 int hilbeledeg=1,hilbcount=0,minimcnt=0;
3148 reduc = olddeg = lrmax = 0;
3161#ifdef HAVE_TAIL_RING
3179 strat->
enterS(strat->
L[strat->
Ll-(
i)], strat->
sl+1, strat, strat->
tl);
3189 while (strat->
Ll >= 0)
3191 if (strat->
Ll > lrmax) lrmax =strat->
Ll;
3221 f5c ( strat, olddeg, minimcnt, hilbeledeg, hilbcount, srmax,
3222 lrmax, reduc,
Q,
w, hilb );
3232 strat->
P = strat->
L[strat->
Ll];
3238 if (!strat->
rewCrit2(strat->
P.sig, ~strat->
P.sevSig, strat->
P.GetLmCurrRing(), strat, strat->
P.checked+1))
3242 PrintS(
"SIG OF NEXT PAIR TO HANDLE IN SIG-BASED ALGORITHM\n");
3243 PrintS(
"-------------------------------------------------\n");
3248 PrintS(
"-------------------------------------------------\n");
3283 else if (strat->
P.p1 ==
NULL)
3285 if (strat->
minim > 0)
3291 if (strat->
P.p ==
NULL && strat->
P.t_p ==
NULL)
3299 PrintS(
"Poly before red: ");
3303#if SBA_PRODUCT_CRITERION
3304 if (strat->
P.prod_crit)
3306#if SBA_PRINT_PRODUCT_CRITERION
3307 product_criterion++;
3309 int pos =
posInSyz(strat, strat->
P.sig);
3316 red_result = strat->
red(&strat->
P,strat);
3319 red_result = strat->
red(&strat->
P,strat);
3335 strat->
P.p =
pNeg(strat->
P.p);
3336 strat->
P.sig =
pNeg(strat->
P.sig);
3339 if(strat->
P.sig !=
NULL)
3341 if(strat->
P.p !=
NULL)
3348 red_result =
redRing(&strat->
P,strat);
3353 strat->
P.sig =
NULL;
3357 strat->
enterS(strat->
P, 0, strat, strat->
tl);
3373 if (red_result != 0)
3375 PrintS(
"Poly after red: ");
3377 pWrite(strat->
P.GetLmCurrRing());
3379 printf(
"%d\n",red_result);
3384 if(strat->
P.p !=
NULL)
3386 &olddeg,&reduc,strat, red_result);
3389 &olddeg,&reduc,strat, red_result);
3397 if (red_result == 1)
3400 strat->
P.GetP(strat->
lmBin);
3404 (strat->
P).FDeg = (strat->
P).pFDeg();
3416 int pos = strat->
sl+1;
3423 beforetailred =
pCopy(strat->
P.sig);
3429 strat->
P.p =
redtailSba(&(strat->
P),pos-1,strat, withT);
3437 strat->
P.pCleardenom();
3440 strat->
P.p =
redtailSba(&(strat->
P),pos-1,strat, withT);
3441 strat->
P.pCleardenom();
3448 strat->
P.p =
redtailSba(&(strat->
P),pos-1,strat, withT);
3457 strat->
enterS(strat->
P, 0, strat, strat->
tl);
3463 if(strat->
P.sig ==
NULL ||
pLtCmp(beforetailred,strat->
P.sig) == 1)
3467 red_result =
redRing(&strat->
P,strat);
3476 strat->
enterS(strat->
P, 0, strat, strat->
tl);
3482 if(strat->
P.p ==
NULL)
3483 goto case_when_red_result_changed;
3489 for (
int jj = 0; jj<strat->
tl+1; jj++)
3493 strat->
T[jj].is_sigsafe =
FALSE;
3499 for (
int jj = 0; jj<strat->
tl+1; jj++)
3501 strat->
T[jj].is_sigsafe =
FALSE;
3511 if (strat->
minim==1)
3518 strat->
M->m[minimcnt]=strat->
P.p2;
3522 pNext(strat->
M->m[minimcnt])
3532 strat->
T[strat->
tl].is_sigsafe =
FALSE;
3546 strat->
enterS(strat->
P, pos, strat, strat->
tl);
3550 for (
int tk=0; tk<strat->
sl+1; tk++)
3571 for(
int ps=0;ps<strat->
sl+1;ps++)
3579 (strat->
syzmax)*
sizeof(
unsigned long),
3581 *
sizeof(
unsigned long));
3613 unsigned max_cmp =
IDELEMS(F);
3623 for (
int i=0;
i<strat->
sl; ++
i)
3640 for (
unsigned i=cmp+1;
i<=max_cmp; ++
i)
3643 for (
int j=0;
j<strat->
sl; ++
j)
3681 printf(
"---------------------------\n");
3682 Print(
" %d. ELEMENT ADDED TO GCURR:\n",strat->
sl+1);
3705 if (hilb!=
NULL)
khCheck(
Q,
w,hilb,hilbeledeg,hilbcount,strat);
3708 if (strat->
sl>srmax) srmax = strat->
sl;
3712 case_when_red_result_changed:
3720#if SBA_PRINT_ZERO_REDUCTIONS
3729 int pos =
posInSyz(strat, strat->
P.sig);
3733 Print(
"ADDING STUFF TO SYZ : ");
3746 memset(&(strat->
P), 0,
sizeof(strat->
P));
3752 printf(
"\nSigDrop!\n");
3754 printf(
"\nEnded with no SigDrop\n");
3760 if(strat->
P.sig !=
NULL)
3764 memset(&(strat->
P), 0,
sizeof(strat->
P));
3799#ifdef HAVE_TAIL_RING
3815#if SBA_PRINT_SIZE_SYZ
3817 size_syz = strat->
syzl;
3845 for(;
k>=0 && (strat->
L[
k].p1 !=
NULL || strat->
L[
k].p2 !=
NULL);
k--)
3855 for(;
k>=0 && strat->
L[
k].p1 ==
NULL && strat->
L[
k].p2 ==
NULL;
k--)
3858 strat->
enterS(strat->
L[
k], strat->
sl+1, strat, strat->
tl);
3866 for(
k=strat->
sl;
k>=0;
k--)
3903 printf(
"SIZE OF SHDL: %d\n",
IDELEMS(strat->
Shdl));
3907 printf(
" %d. ",oo+1);
3912#if SBA_PRINT_ZERO_REDUCTIONS
3913 printf(
"----------------------------------------------------------\n");
3914 printf(
"ZERO REDUCTIONS: %ld\n",zeroreductions);
3917#if SBA_PRINT_REDUCTION_STEPS
3918 printf(
"----------------------------------------------------------\n");
3919 printf(
"S-REDUCTIONS: %ld\n",sba_reduction_steps);
3921#if SBA_PRINT_OPERATIONS
3922 printf(
"OPERATIONS: %ld\n",sba_operations);
3924#if SBA_PRINT_REDUCTION_STEPS
3925 printf(
"- - - - - - - - - - - - - - - - - - - - - - - - - - - - - \n");
3926 printf(
"INTERREDUCTIONS: %ld\n",sba_interreduction_steps);
3928#if SBA_PRINT_OPERATIONS
3929 printf(
"INTERREDUCTION OPERATIONS: %ld\n",sba_interreduction_operations);
3931#if SBA_PRINT_REDUCTION_STEPS
3932 printf(
"- - - - - - - - - - - - - - - - - - - - - - - - - - - - - \n");
3933 printf(
"ALL REDUCTIONS: %ld\n",sba_reduction_steps+sba_interreduction_steps);
3934 sba_interreduction_steps = 0;
3935 sba_reduction_steps = 0;
3937#if SBA_PRINT_OPERATIONS
3938 printf(
"ALL OPERATIONS: %ld\n",sba_operations+sba_interreduction_operations);
3939 sba_interreduction_operations = 0;
3943 printf(
"----------------------------------------------------------\n");
3944 printf(
"SIZE OF G: %d / %d\n",size_g,size_g_non_red);
3948#if SBA_PRINT_SIZE_SYZ
3949 printf(
"SIZE OF SYZ: %ld\n",size_syz);
3950 printf(
"----------------------------------------------------------\n");
3953#if SBA_PRINT_PRODUCT_CRITERION
3954 printf(
"PRODUCT CRITERIA: %ld\n",product_criterion);
3955 product_criterion = 0;
3957 return (strat->
Shdl);
4290 int& hilbcount,
int& srmax,
int& lrmax,
int& reduc, ideal
Q,
4293 int Ll_old, red_result = 1;
4299 reduc = olddeg = lrmax = 0;
4304 while (strat->
tl >= 0)
4306 if(!strat->
T[strat->
tl].is_redundant)
4309 h.p = strat->
T[strat->
tl].p;
4310 h.tailRing = strat->
T[strat->
tl].tailRing;
4311 h.t_p = strat->
T[strat->
tl].t_p;
4350 while (strat->
Ll>Ll_old)
4352 strat->
P = strat->
L[strat->
Ll];
4356 PrintS(
"NEXT PAIR TO HANDLE IN INTERRED ALGORITHM\n");
4357 PrintS(
"-------------------------------------------------\n");
4361 printf(
"%d\n",strat->
tl);
4362 PrintS(
"-------------------------------------------------\n");
4395 else if (strat->
P.p1 ==
NULL)
4397 if (strat->
minim > 0)
4404 if (strat->
P.p ==
NULL && strat->
P.t_p ==
NULL)
4412 &olddeg,&reduc,strat, red_result);
4415 PrintS(
"Poly before red: ");
4419 red_result = strat->
red2(&strat->
P,strat);
4429 if (red_result == 1)
4432 strat->
P.GetP(strat->
lmBin);
4443 pos =
posInS(strat,strat->
sl,strat->
P.p,strat->
P.ecart);
4447 pos =
posInS(strat,strat->
sl,strat->
P.p,strat->
P.ecart);
4455 strat->
P.pCleardenom();
4458 strat->
P.p =
redtailBba(&(strat->
P),pos-1,strat, withT);
4459 strat->
P.pCleardenom();
4466 strat->
P.p =
redtailBba(&(strat->
P),pos-1,strat, withT);
4476 if (strat->
minim==1)
4483 strat->
M->m[minimcnt]=strat->
P.p2;
4487 pNext(strat->
M->m[minimcnt])
4500 strat->
enterS(strat->
P, pos, strat, strat->
tl);
4503 PrintS(
"ELEMENT ADDED TO GCURR DURING INTERRED: ");
4507 if (hilb!=
NULL)
khCheck(
Q,
w,hilb,hilbeledeg,hilbcount,strat);
4511 if (strat->
sl>srmax) srmax = strat->
sl;
4527 memset(&(strat->
P), 0,
sizeof(strat->
P));
4531 while (cc<strat->tl+1)
4533 strat->
T[cc].sig =
pOne();
4536 strat->
sig[cc] = strat->
T[cc].sig;
4537 strat->
sevSig[cc] = strat->
T[cc].sevSig;
4538 strat->
T[cc].is_sigsafe =
TRUE;
4546 for (
int cd=strat->
Ll;
cd>=0;
cd--)
4554 printf(
"\nAfter f5c sorting\n");
4555 for(
int i=0;
i<=strat->
sl;
i++)
4561 PrintS(
"------------------- STRAT S ---------------------\n");
4563 while (cc<strat->tl+1)
4567 printf(
"- - - - - -\n");
4570 PrintS(
"-------------------------------------------------\n");
4571 PrintS(
"------------------- STRAT T ---------------------\n");
4573 while (cc<strat->tl+1)
4577 printf(
"- - - - - -\n");
4580 PrintS(
"-------------------------------------------------\n");
4581 PrintS(
"------------------- STRAT L ---------------------\n");
4583 while (cc<strat->Ll+1)
4589 printf(
"- - - - - -\n");
4592 PrintS(
"-------------------------------------------------\n");
4593 printf(
"F5C DONE\nSTRAT SL: %d -- %d\n",strat->
sl, strat->
currIdx);
4605 int hilbeledeg=1,hilbcount=0,minimcnt=0;
4633#ifdef HAVE_TAIL_RING
4649 while (strat->
Ll >= 0)
4656 while (strat->
Ll >= 0)
4669 while ((strat->
Ll >= 0)
4670 && (strat->
L[strat->
Ll].p1!=
NULL) && (strat->
L[strat->
Ll].p2!=
NULL)
4675 if (strat->
Ll<0)
break;
4680 strat->
P = strat->
L[strat->
Ll];
4710 else if (strat->
P.p1 ==
NULL)
4712 if (strat->
minim > 0)
4718 if ((strat->
P.p ==
NULL) && (strat->
P.t_p ==
NULL))
4726 &olddeg,&reduc,strat, red_result);
4729 red_result = strat->
red(&strat->
P,strat);
4739 if (red_result == 1)
4742 strat->
P.GetP(strat->
lmBin);
4751 int pos=
posInS(strat,strat->
sl,strat->
P.p,strat->
P.ecart);
4766 strat->
P.pCleardenom();
4770 strat->
P.pCleardenom();
4783 strat->
P.p =
redtailBba(&(strat->
P),pos-1,strat, withT);
4799 if (strat->
minim==1)
4806 strat->
M->m[minimcnt]=strat->
P.p2;
4810 pNext(strat->
M->m[minimcnt])
4824 strat->
enterS(strat->
P, pos, strat, strat->
tl);
4829 if (hilb!=
NULL)
khCheck(
Q,
w,hilb,hilbeledeg,hilbcount,strat);
4837 if (strat->
s_poly(strat))
4842 int pos=
posInS(strat,strat->
sl,strat->
P.p,strat->
P.ecart);
4845 strat->
enterS(strat->
P, pos, strat, strat->
tl);
4851 else if (strat->
P.p1 ==
NULL && strat->
minim > 0)
4856 memset(&(strat->
P), 0,
sizeof(strat->
P));
4868 for (
int k = 0;
k <= strat->
sl; ++
k)
4871 for (
int j = 0;
j<=strat->
tl; ++
j)
4901#ifdef HAVE_TAIL_RING
4908 WarnS(
"reduction with S is not yet supported by Letterplace");
4925 for(
int i = 0;
i<=strat->
sl;
i++)
4960 return (strat->
Shdl);
4983 if (
h->IsNull())
return 0;
4991 d =
h->GetpFDeg() +
h->ecart;
4994 h->SetShortExpVector();
5000 h->SetDegStuffReturnLDeg(strat->
LDegLast);
5005 strat->
T[
j].pNorm();
5031 h->SetShortExpVector();
5044 h->SetDegStuffReturnLDeg(strat->
LDegLast);
5054 if (strat->
T[
j].ecart <=
h->ecart)
5055 h->ecart = d -
h->GetpFDeg();
5057 h->ecart = d -
h->GetpFDeg() + strat->
T[
j].ecart -
h->ecart;
5059 d =
h->GetpFDeg() +
h->ecart;
5062 d =
h->SetDegStuffReturnLDeg(strat->
LDegLast);
5071 && ((d >= reddeg) || (pass > strat->
LazyPass)))
5076 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
5077 if (at <= strat->Ll)
static int si_max(const int a, const int b)
CanonicalForm cd(bCommonDen(FF))
static CanonicalForm bound(const CFMatrix &M)
KINLINE poly kNoetherTail()
int(* red2)(LObject *L, kStrategy strat)
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 sort(CFArray &A, int l=0)
quick sort A
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)