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) &&
555 if (arg <= 0)
return 0;
557 if (arg%2 == 1) { arg--; }
573 poly zeroPoly =
NULL;
574 unsigned long a = (
unsigned long)
pGetCoeff(
p);
581 for (
int i = 1;
i <= leadRing->N;
i++)
590 poly lead_mult =
p_ISet(1, tailRing);
591 if (
n_GetChar(leadRing->cf) <= k_ind2 + a_ind2)
593 int too_much = k_ind2 + a_ind2 -
n_GetChar(leadRing->cf);
595 zeroPoly =
p_ISet(a, tailRing);
596 for (
int i = 1;
i <= leadRing->N;
i++)
609 for (
int j = 1;
j <= s_exp;
j++)
626 p_Setm(lead_mult, tailRing);
627 zeroPoly =
p_Mult_mm(zeroPoly, lead_mult, tailRing);
629 for (
int i = 1;
i <= leadRing->N;
i++)
679 if (
h->IsNull())
return 0;
680 if (strat->
tl<0)
return 1;
690 long reddeg =
h->GetpFDeg();
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();
795 (strat->
Ll >= 0) && ((d > reddeg) || (pass > strat->
LazyPass)))
800 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
815 if (
h->pTotalDeg() >= (
long)strat->
tailRing->bitmask)
820 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
837 if (
h->IsNull())
return 0;
838 if (strat->
sl<0)
return 1;
846 h->SetShortExpVector();
847 int max_ind=strat->
sl;
856#if STDZ_EXCHANGE_DURING_REDUCTION
880 if (
h->GetLmTailRing() ==
NULL)
906#if STDZ_EXCHANGE_DURING_REDUCTION
920 redtailBbaAlsoLC_Z_S(&h2,
j, strat);
933 if (
h->GetLmCurrRing() ==
NULL)
938 h->SetShortExpVector();
947 if (strat->
tl<0)
return 1;
948 if (
h->IsNull())
return 0;
959 long reddeg =
h->GetpFDeg();
961 h->SetShortExpVector();
983 if (
h->GetLmTailRing() ==
NULL)
996 if (
h->GetLmTailRing() ==
NULL)
1002 h->SetShortExpVector();
1007 (strat->
Ll >= 0) && ((d > reddeg) || (pass > strat->
LazyPass)))
1012 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
1013 if (at <= strat->Ll)
1027 if (
h->pTotalDeg() >= (
long)strat->
tailRing->bitmask)
1032 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
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;
1114 int i,
j,at,pass,cnt,ii;
1121 h->SetShortExpVector();
1122 h_p =
h->GetLmTailRing();
1127 if (
j < 0)
return 1;
1129 li = strat->
T[
j].pLength;
1137 if (test_opt_length)
1139 if (li<=0) li=strat->
T[
j].GetpLength();
1142 unsigned long not_sev = ~ h->sev;
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
1183 sba_interreduction_steps++;
1185#if SBA_PRINT_OPERATIONS
1186 sba_interreduction_operations +=
pLength(strat->
T[ii].p);
1198 h_p =
h->GetLmTailRing();
1214 else if (
h->t_p!=
NULL)
1233 else if (
h->t_p!=
NULL)
1242 h->SetShortExpVector();
1254 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
1255 if (at <= strat->Ll)
1266 int dummy=strat->
sl;
1273 Print(
" lazy: -> L%d\n",at);
1292 assume(PR->GetLmCurrRing() != PW->GetLmCurrRing());
1294 Red->HeadNormalize();
1328 if (strat->
tl<0)
return 1;
1334 PrintS(
"------- IN REDSIG -------\n");
1341 PrintS(
"---------------------------\n");
1344 int i,
j,at,pass, ii;
1347 unsigned long not_sev;
1353 h->SetShortExpVector();
1354 h_p =
h->GetLmTailRing();
1364 li = strat->
T[
j].pLength;
1365 if (li<=0) li=strat->
T[
j].GetpLength();
1373 if (test_opt_length)
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
1427 sba_reduction_steps++;
1429#if SBA_PRINT_OPERATIONS
1431 sba_operations +=
pLength(strat->
T[ii].p);
1438 Print(
"SigSAFE: %d\n",sigSafe);
1453 h_p =
h->GetLmTailRing();
1459 h->SetShortExpVector();
1471 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
1472 if (at <= strat->Ll)
1474 int dummy=strat->
sl;
1482 Print(
" lazy: -> L%d\n",at);
1506 beforeredsig =
pCopy(
h->sig);
1508 if (strat->
tl<0)
return 1;
1514 Print(
"------- IN REDSIG -------\n");
1521 Print(
"---------------------------\n");
1524 int i,
j,at,pass, ii;
1527 unsigned long not_sev;
1533 h->SetShortExpVector();
1534 h_p =
h->GetLmTailRing();
1556 h->i_r1 = strat->
tl;
1559 if (
h->GetLmTailRing() ==
NULL)
1566 if(
pLtCmp(beforeredsig,
h->sig) == 1)
1589 li = strat->
T[
j].pLength;
1590 if (li<=0) li=strat->
T[
j].GetpLength();
1597 if (test_opt_length)
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
1676 sba_reduction_steps++;
1678#if SBA_PRINT_OPERATIONS
1680 sba_operations +=
pLength(strat->
T[ii].p);
1687 Print(
"SigSAFE: %d\n",sigSafe);
1702 h_p =
h->GetLmTailRing();
1708 h->SetShortExpVector();
1720 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
1721 if (at <= strat->Ll)
1723 int dummy=strat->
sl;
1731 Print(
" lazy: -> L%d\n",at);
1747 p =
h = L->GetLmTailRing();
1749 return L->GetLmCurrRing();
1757 Ln.sevSig = L->sevSig;
1758 Ln.pLength = L->GetpLength() - 1;
1773 Ln.SetShortExpVector();
1779 With = &(strat->
T[
j]);
1784 if (With ==
NULL)
break;
1808#if SBA_PRINT_REDUCTION_STEPS
1810 sba_reduction_steps++;
1812#if SBA_PRINT_OPERATIONS
1814 sba_operations +=
pLength(With->p);
1824 pNext(
h) = Ln.LmExtractAndIter();
1827 }
while (!Ln.IsNull());
1830 if (Ln.IsNull())
goto all_done;
1831 if (! withT) With_s.Init(
currRing);
1838 pNext(
h) = Ln.LmExtractAndIter();
1855 return L->GetLmCurrRing();
1864 if (strat->
tl<0)
return 1;
1870 long reddeg =
h->GetpFDeg();
1874 h->SetShortExpVector();
1875 poly h_p =
h->GetLmTailRing();
1880 if (
j < 0)
return 1;
1882 li = strat->
T[
j].pLength;
1891 if (test_opt_length)
1893 if (li<=0) li=strat->
T[
j].GetpLength();
1896 unsigned long not_sev = ~ h->sev;
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
1938 sba_interreduction_steps++;
1940#if SBA_PRINT_OPERATIONS
1941 sba_interreduction_operations +=
pLength(strat->
T[ii].p);
1953 h_p=
h->GetLmTailRing();
1970 else if (
h->t_p!=
NULL)
1989 else if (
h->t_p!=
NULL)
1998 h->SetShortExpVector();
2004 (strat->
Ll >= 0) && ((d > reddeg) || (pass > strat->
LazyPass)))
2007 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
2008 if (at <= strat->Ll)
2020 int dummy=strat->
sl;
2033 else if (d != reddeg)
2037 if (
h->pTotalDeg() >= (
long)strat->
tailRing->bitmask)
2042 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
2069 if (strat->
tl<0)
return 1;
2073 int i,
j,at,pass,ei, ii, h_d;
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;
2097 if (test_opt_length)
2099 if (li<=0) li=strat->
T[
j].GetpLength();
2102 unsigned long not_sev = ~ h->sev;
2107 if (
i > strat->
tl)
break;
2108 if (ei <= h->ecart)
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;
2123 if (ei<=h->ecart)
break;
2144 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
2162 Print(
"\nwith T[%d]:",ii);
2169#if SBA_PRINT_REDUCTION_STEPS
2170 sba_interreduction_steps++;
2172#if SBA_PRINT_OPERATIONS
2173 sba_interreduction_operations += strat->
T[ii].pLength;
2199 else if (
h->t_p!=
NULL)
2218 else if (
h->t_p!=
NULL)
2226 h->SetShortExpVector();
2227 h_d =
h->SetpFDeg();
2232 h->ecart = d-h_d+ei-
h->ecart;
2244 && ((d > reddeg) || (pass > strat->
LazyPass))))
2248 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
2249 if (at <= strat->Ll)
2260 int dummy=strat->
sl;
2267 Print(
" degree jumped: -> L%d\n",at);
2273 else if (d > reddeg)
2277 if (
h->pTotalDeg()+
h->ecart >= (
long)strat->
tailRing->bitmask)
2282 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
2314 P.SetShortExpVector();
2317 if(is_ring) nonorm=
TRUE;
2435 P.SetShortExpVector();
2510 P.SetShortExpVector();
2573 P.SetShortExpVector();
2587 P.SetShortExpVector();
2613 int hilbeledeg=1,hilbcount=0,minimcnt=0;
2636 withT = ! strat->
homog;
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))
2734 &olddeg,&reduc,strat, red_result);
2737 red_result = strat->red(&strat->P,strat);
2747 if (red_result == 1)
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();
2787 strat->
P.p =
redtailBba(&(strat->
P),pos-1,strat, withT);
2799 if (strat->
minim==1)
2806 strat->
M->m[minimcnt]=strat->
P.p2;
2810 pNext(strat->
M->m[minimcnt])
2820 strat->
P.SetShortExpVector();
2827 strat->
enterS(strat->
P, pos, strat, strat->
tl);
2842 if (hilb!=
NULL)
khCheck(
Q,
w,hilb,hilbeledeg,hilbcount,strat);
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
2977 long zeroreductions = 0;
2979#if SBA_PRINT_PRODUCT_CRITERION
2980 long product_criterion = 0;
2984 int size_g_non_red = 0;
2986#if SBA_PRINT_SIZE_SYZ
2990#if SBA_PRINT_REDUCTION_STEPS
2991 sba_reduction_steps = 0;
2992 sba_interreduction_steps = 0;
2994#if SBA_PRINT_OPERATIONS
2996 sba_interreduction_operations = 0;
3000 ring sRing, currRingOld;
3005 if (sRing!=currRingOld)
3024 dummy =
pCopy(F->m[0]);
3026 F->m[
i] = F->m[
i+1];
3047 dummy =
pCopy(F->m[0]);
3049 F->m[
i] = F->m[
i+1];
3067 for (
int i=0;
i<
sort->length();++
i)
3082 F->m[
j] = F->m[
j-1];
3096#if SBA_INTERRED_START
3100 printf(
"SBA COMPUTATIONS DONE IN THE FOLLOWING RING:\n");
3102 printf(
"ordSgn = %d\n",
currRing->OrdSgn);
3105 int srmax,lrmax, red_result = 1;
3107 int hilbeledeg=1,hilbcount=0,minimcnt=0;
3121 reduc = olddeg = lrmax = 0;
3134#ifdef HAVE_TAIL_RING
3152 strat->
enterS(strat->
L[strat->
Ll-(
i)], strat->
sl+1, strat, strat->
tl);
3162 while (strat->
Ll >= 0)
3164 if (strat->
Ll > lrmax) lrmax =strat->
Ll;
3194 f5c ( strat, olddeg, minimcnt, hilbeledeg, hilbcount, srmax,
3195 lrmax, reduc,
Q,
w, hilb );
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
3280 product_criterion++;
3282 int pos =
posInSyz(strat, strat->
P.sig);
3289 red_result = strat->
red(&strat->
P,strat);
3292 red_result = strat->
red(&strat->
P,strat);
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)
3321 red_result =
redRing(&strat->
P,strat);
3326 strat->
P.sig =
NULL;
3330 strat->
enterS(strat->
P, 0, strat, strat->
tl);
3346 if (red_result != 0)
3348 PrintS(
"Poly after red: ");
3350 pWrite(strat->
P.GetLmCurrRing());
3352 printf(
"%d\n",red_result);
3357 if(strat->
P.p !=
NULL)
3359 &olddeg,&reduc,strat, red_result);
3361 message((strat->honey ? strat->P.ecart : 0),
3362 &olddeg,&reduc,strat, red_result);
3370 if (red_result == 1)
3373 strat->
P.GetP(strat->
lmBin);
3377 (strat->
P).FDeg = (strat->
P).pFDeg();
3389 int pos = strat->
sl+1;
3395 beforetailred =
pCopy(strat->
P.sig);
3400 strat->
P.p =
redtailSba(&(strat->
P),pos-1,strat, withT);
3408 strat->
P.pCleardenom();
3411 strat->
P.p =
redtailSba(&(strat->
P),pos-1,strat, withT);
3412 strat->
P.pCleardenom();
3419 strat->
P.p =
redtailSba(&(strat->
P),pos-1,strat, withT);
3428 strat->
enterS(strat->
P, 0, strat, strat->
tl);
3434 if(strat->
P.sig ==
NULL ||
pLtCmp(beforetailred,strat->
P.sig) == 1)
3438 red_result =
redRing(&strat->
P,strat);
3447 strat->
enterS(strat->
P, 0, strat, strat->
tl);
3453 if(strat->
P.p ==
NULL)
3454 goto case_when_red_result_changed;
3460 for (
int jj = 0; jj<strat->
tl+1; jj++)
3464 strat->
T[jj].is_sigsafe =
FALSE;
3470 for (
int jj = 0; jj<strat->
tl+1; jj++)
3472 strat->
T[jj].is_sigsafe =
FALSE;
3482 if (strat->
minim==1)
3489 strat->
M->m[minimcnt]=strat->
P.p2;
3493 pNext(strat->
M->m[minimcnt])
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++)
3542 for(
int ps=0;ps<strat->
sl+1;ps++)
3550 (strat->
syzmax)*
sizeof(
unsigned long),
3552 *
sizeof(
unsigned long));
3584 unsigned max_cmp =
IDELEMS(F);
3594 for (
int i=0;
i<strat->
sl; ++
i)
3611 for (
unsigned i=cmp+1;
i<=max_cmp; ++
i)
3614 for (
int j=0;
j<strat->
sl; ++
j)
3652 printf(
"---------------------------\n");
3653 Print(
" %d. ELEMENT ADDED TO GCURR:\n",strat->
sl+1);
3676 if (hilb!=
NULL)
khCheck(
Q,
w,hilb,hilbeledeg,hilbcount,strat);
3679 if (strat->
sl>srmax) srmax = strat->
sl;
3683 case_when_red_result_changed:
3691#if SBA_PRINT_ZERO_REDUCTIONS
3700 int pos =
posInSyz(strat, strat->
P.sig);
3704 Print(
"ADDING STUFF TO SYZ : ");
3723 printf(
"\nSigDrop!\n");
3725 printf(
"\nEnded with no SigDrop\n");
3731 if(strat->
P.sig !=
NULL)
3770#ifdef HAVE_TAIL_RING
3786#if SBA_PRINT_SIZE_SYZ
3788 size_syz = strat->
syzl;
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--)
3872 printf(
"SIZE OF SHDL: %d\n",
IDELEMS(strat->
Shdl));
3876 printf(
" %d. ",oo+1);
3881#if SBA_PRINT_ZERO_REDUCTIONS
3882 printf(
"----------------------------------------------------------\n");
3883 printf(
"ZERO REDUCTIONS: %ld\n",zeroreductions);
3886#if SBA_PRINT_REDUCTION_STEPS
3887 printf(
"----------------------------------------------------------\n");
3888 printf(
"S-REDUCTIONS: %ld\n",sba_reduction_steps);
3890#if SBA_PRINT_OPERATIONS
3891 printf(
"OPERATIONS: %ld\n",sba_operations);
3893#if SBA_PRINT_REDUCTION_STEPS
3894 printf(
"- - - - - - - - - - - - - - - - - - - - - - - - - - - - - \n");
3895 printf(
"INTERREDUCTIONS: %ld\n",sba_interreduction_steps);
3897#if SBA_PRINT_OPERATIONS
3898 printf(
"INTERREDUCTION OPERATIONS: %ld\n",sba_interreduction_operations);
3900#if SBA_PRINT_REDUCTION_STEPS
3901 printf(
"- - - - - - - - - - - - - - - - - - - - - - - - - - - - - \n");
3902 printf(
"ALL REDUCTIONS: %ld\n",sba_reduction_steps+sba_interreduction_steps);
3903 sba_interreduction_steps = 0;
3904 sba_reduction_steps = 0;
3906#if SBA_PRINT_OPERATIONS
3907 printf(
"ALL OPERATIONS: %ld\n",sba_operations+sba_interreduction_operations);
3908 sba_interreduction_operations = 0;
3912 printf(
"----------------------------------------------------------\n");
3913 printf(
"SIZE OF G: %d / %d\n",size_g,size_g_non_red);
3917#if SBA_PRINT_SIZE_SYZ
3918 printf(
"SIZE OF SYZ: %ld\n",size_syz);
3919 printf(
"----------------------------------------------------------\n");
3922#if SBA_PRINT_PRODUCT_CRITERION
3923 printf(
"PRODUCT CRITERIA: %ld\n",product_criterion);
3924 product_criterion = 0;
3926 return (strat->
Shdl);
4263 int& hilbcount,
int& srmax,
int& lrmax,
int& reduc, ideal
Q,
4266 int Ll_old, red_result = 1;
4272 reduc = olddeg = lrmax = 0;
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;
4323 while (strat->
Ll>Ll_old)
4325 strat->
P = strat->
L[strat->
Ll];
4329 PrintS(
"NEXT PAIR TO HANDLE IN INTERRED ALGORITHM\n");
4330 PrintS(
"-------------------------------------------------\n");
4334 printf(
"%d\n",strat->
tl);
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)
4385 &olddeg,&reduc,strat, red_result);
4388 PrintS(
"Poly before red: ");
4392 red_result = strat->red2(&strat->P,strat);
4402 if (red_result == 1)
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();
4431 strat->
P.p =
redtailBba(&(strat->
P),pos-1,strat, withT);
4432 strat->
P.pCleardenom();
4439 strat->
P.p =
redtailBba(&(strat->
P),pos-1,strat, withT);
4449 if (strat->
minim==1)
4456 strat->
M->m[minimcnt]=strat->
P.p2;
4460 pNext(strat->
M->m[minimcnt])
4473 strat->
enterS(strat->
P, pos, strat, strat->
tl);
4476 PrintS(
"ELEMENT ADDED TO GCURR DURING INTERRED: ");
4480 if (hilb!=
NULL)
khCheck(
Q,
w,hilb,hilbeledeg,hilbcount,strat);
4484 if (strat->
sl>srmax) srmax = strat->
sl;
4504 while (cc<strat->tl+1)
4506 strat->
T[cc].sig =
pOne();
4509 strat->
sig[cc] = strat->
T[cc].sig;
4510 strat->
sevSig[cc] = strat->
T[cc].sevSig;
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");
4536 while (cc<strat->tl+1)
4540 printf(
"- - - - - -\n");
4543 PrintS(
"-------------------------------------------------\n");
4544 PrintS(
"------------------- STRAT T ---------------------\n");
4546 while (cc<strat->tl+1)
4550 printf(
"- - - - - -\n");
4553 PrintS(
"-------------------------------------------------\n");
4554 PrintS(
"------------------- STRAT L ---------------------\n");
4556 while (cc<strat->Ll+1)
4562 printf(
"- - - - - -\n");
4565 PrintS(
"-------------------------------------------------\n");
4566 printf(
"F5C DONE\nSTRAT SL: %d -- %d\n",strat->
sl, strat->
currIdx);
4578 int hilbeledeg=1,hilbcount=0,minimcnt=0;
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))
4699 &olddeg,&reduc,strat, red_result);
4702 red_result = strat->red(&strat->P,strat);
4712 if (red_result == 1)
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();
4756 strat->
P.p =
redtailBba(&(strat->
P),pos-1,strat, withT);
4772 if (strat->
minim==1)
4779 strat->
M->m[minimcnt]=strat->
P.p2;
4783 pNext(strat->
M->m[minimcnt])
4797 strat->
enterS(strat->
P, pos, strat, strat->
tl);
4802 if (hilb!=
NULL)
khCheck(
Q,
w,hilb,hilbeledeg,hilbcount,strat);
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);
5044 && ((d >= reddeg) || (pass > strat->
LazyPass)))
5049 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
5050 if (at <= strat->Ll)
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.