18 #define PLURAL_INTERNAL_DECLARATIONS 1 37 #define SBA_INTERRED_START 0 38 #define SBA_TAIL_RED 1 39 #define SBA_PRODUCT_CRITERION 0 40 #define SBA_PRINT_ZERO_REDUCTIONS 0 41 #define SBA_PRINT_REDUCTION_STEPS 0 42 #define SBA_PRINT_OPERATIONS 0 43 #define SBA_PRINT_SIZE_G 0 44 #define SBA_PRINT_SIZE_SYZ 0 45 #define SBA_PRINT_PRODUCT_CRITERION 0 48 #if SBA_PRINT_REDUCTION_STEPS 49 VAR long sba_reduction_steps;
50 VAR long sba_interreduction_steps;
52 #if SBA_PRINT_OPERATIONS 53 VAR long sba_operations;
54 VAR long sba_interreduction_operations;
86 unsigned long not_sev = ~L->sev;
91 const unsigned long* sevT=strat->
sevT;
103 if (j > strat->
tl)
return o;
123 if (j > strat->
tl)
return o;
141 unsigned long not_sev = ~L->sev;
146 const unsigned long* sevT=strat->
sevT;
147 number rest, orest,
mult;
158 if (j > strat->
tl)
return o;
159 #if defined(PDEBUG) || defined(PDIV_DEBUG) 188 if (j > strat->
tl)
return o;
189 #if defined(PDEBUG) || defined(PDIV_DEBUG) 218 unsigned long not_sev = ~L->sev;
222 const unsigned long* sevT=strat->
sevT;
235 if (j > strat->
tl)
return -1;
236 #if defined(PDEBUG) || defined(PDIV_DEBUG) 243 if (!(sevT[j] & not_sev) &&
257 if (j > strat->
tl)
return -1;
258 #if defined(PDEBUG) || defined(PDIV_DEBUG) 264 if (!(sevT[j] & not_sev) &&
282 if (j > strat->
tl)
return -1;
283 #if defined(PDEBUG) || defined(PDIV_DEBUG) 291 if (!(sevT[j] & not_sev) &&
305 if (j > strat->
tl)
return -1;
306 #if defined(PDEBUG) || defined(PDIV_DEBUG) 313 if (!(sevT[j] & not_sev) &&
328 unsigned long not_sev = ~L->sev;
329 poly
p = L->GetLmCurrRing();
343 ende=
posInS(strat,*max_ind,p,0)+1;
344 if (ende>(*max_ind)) ende=(*max_ind);
353 if (j > ende)
return -1;
354 #if defined(PDEBUG) || defined(PDIV_DEBUG) 362 if ( !(strat->
sevS[j] & not_sev) &&
376 if (j > ende)
return -1;
377 #if defined(PDEBUG) || defined(PDIV_DEBUG) 384 if ( !(strat->
sevS[j] & not_sev) &&
397 unsigned long not_sev = ~L->sev;
398 poly
p = L->GetLmCurrRing();
411 if (j > ende)
return -1;
412 #if defined(PDEBUG) || defined(PDIV_DEBUG) 420 if ( !(strat->
sevS[j] & not_sev) &&
434 if (j > ende)
return -1;
435 #if defined(PDEBUG) || defined(PDIV_DEBUG) 442 if ( !(strat->
sevS[j] & not_sev) &&
461 poly zeroPoly =
NULL;
462 unsigned long a = (
unsigned long)
pGetCoeff(p);
465 int a_ind2 =
ind2(a);
469 for (
int i = 1;
i <= leadRing->N;
i++)
478 poly lead_mult =
p_ISet(1, tailRing);
479 if (
n_GetChar(leadRing->cf) <= k_ind2 + a_ind2)
481 int too_much = k_ind2 + a_ind2 -
n_GetChar(leadRing->cf);
483 zeroPoly =
p_ISet(a, tailRing);
484 for (
int i = 1;
i <= leadRing->N;
i++)
491 while ( (0 <
ind2(s_exp)) && (
ind2(s_exp) <= too_much) )
493 too_much = too_much -
ind2(s_exp);
497 for (
int j = 1;
j <= s_exp;
j++)
500 tmp2 =
p_ISet(1, tailRing);
505 zeroPoly =
p_Mult_q(zeroPoly, tmp2, tailRing);
510 zeroPoly =
p_Mult_q(zeroPoly,
p_Add_q(tmp3, tmp2, tailRing), tailRing);
514 p_Setm(lead_mult, tailRing);
515 zeroPoly =
p_Mult_mm(zeroPoly, lead_mult, tailRing);
517 for (
int i = 1;
i <= leadRing->N;
i++)
523 pNext(tmp2) = zeroPoly;
570 if (h->IsNull())
return 0;
571 if (strat->
tl<0)
return 1;
581 assume(h->pFDeg() == h->FDeg);
582 long reddeg = h->GetpFDeg();
584 h->SetShortExpVector();
615 if (h->GetLmTailRing() ==
NULL)
661 if (h->GetLmTailRing() ==
NULL)
670 h->SetShortExpVector();
675 (strat->
Ll >= 0) && ((d > reddeg) || (pass > strat->
LazyPass)))
680 at = strat->
posInL(strat->
L,strat->
Ll,h,strat);
693 if (d >= (
long)strat->
tailRing->bitmask)
695 if (h->pTotalDeg() >= (long)strat->
tailRing->bitmask)
700 at = strat->
posInL(strat->
L,strat->
Ll,h,strat);
717 if (h->IsNull())
return 0;
718 if (strat->
tl<0)
return 1;
728 assume(h->pFDeg() == h->FDeg);
729 long reddeg = h->GetpFDeg();
731 h->SetShortExpVector();
753 if (h->GetLmTailRing() ==
NULL)
766 if (h->GetLmTailRing() ==
NULL)
772 h->SetShortExpVector();
777 (strat->
Ll >= 0) && ((d > reddeg) || (pass > strat->
LazyPass)))
782 at = strat->
posInL(strat->
L,strat->
Ll,h,strat);
795 if (d >= (
long)strat->
tailRing->bitmask)
797 if (h->pTotalDeg() >= (long)strat->
tailRing->bitmask)
802 at = strat->
posInL(strat->
L,strat->
Ll,h,strat);
824 if (strat->
tl<0)
return 1;
826 assume(h->FDeg == h->pFDeg());
830 unsigned long not_sev;
835 h->SetShortExpVector();
837 h_p = h->GetLmTailRing();
844 li = strat->
T[
j].pLength;
845 if (li<=0) li=strat->
T[
j].GetpLength();
862 if ((strat->
T[i].pLength < li)
870 li = strat->
T[
i].pLength;
871 if (li<=0) li=strat->
T[
i].GetpLength();
892 #if SBA_PRINT_REDUCTION_STEPS 893 sba_interreduction_steps++;
895 #if SBA_PRINT_OPERATIONS 896 sba_interreduction_operations +=
pLength(strat->
T[ii].p);
908 h_p = h->GetLmTailRing();
914 h->SetShortExpVector();
926 at = strat->
posInL(strat->
L,strat->
Ll,h,strat);
935 Print(
" lazy: -> L%d\n",at);
948 assume(PR->GetLmCurrRing() != PW->GetLmCurrRing());
950 Red->HeadNormalize();
984 if (strat->
tl<0)
return 1;
987 assume(h->FDeg == h->pFDeg());
990 PrintS(
"------- IN REDSIG -------\n");
997 PrintS(
"---------------------------\n");
1000 int i,
j,at,pass, ii;
1003 unsigned long not_sev;
1008 h->SetShortExpVector();
1010 h_p = h->GetLmTailRing();
1020 li = strat->
T[
j].pLength;
1021 if (li<=0) li=strat->
T[
j].GetpLength();
1038 if ((strat->
T[i].pLength < li)
1046 li = strat->
T[
i].pLength;
1047 if (li<=0) li=strat->
T[
i].GetpLength();
1069 Print(
"BEFORE REDUCTION WITH %d:\n",ii);
1070 PrintS(
"--------------------------------\n");
1073 pWrite(h->GetLmCurrRing());
1077 PrintS(
"--------------------------------\n");
1078 printf(
"INDEX OF REDUCER T: %d\n",ii);
1081 #if SBA_PRINT_REDUCTION_STEPS 1083 sba_reduction_steps++;
1085 #if SBA_PRINT_OPERATIONS 1087 sba_operations +=
pLength(strat->
T[ii].p);
1094 Print(
"SigSAFE: %d\n",sigSafe);
1109 h_p = h->GetLmTailRing();
1115 h->SetShortExpVector();
1127 at = strat->
posInL(strat->
L,strat->
Ll,h,strat);
1128 if (at <= strat->Ll)
1130 int dummy=strat->
sl;
1138 Print(
" lazy: -> L%d\n",at);
1162 beforeredsig =
pCopy(h->sig);
1164 if (strat->
tl<0)
return 1;
1167 assume(h->FDeg == h->pFDeg());
1170 Print(
"------- IN REDSIG -------\n");
1177 Print(
"---------------------------\n");
1180 int i,
j,at,pass, ii;
1183 unsigned long not_sev;
1188 h->SetShortExpVector();
1190 h_p = h->GetLmTailRing();
1201 h->is_redundant =
FALSE;
1212 h->i_r1 = strat->
tl;
1215 if (h->GetLmTailRing() ==
NULL)
1222 if(
pLtCmp(beforeredsig,h->sig) == 1)
1226 int red_result =
redRing(h,strat);
1245 li = strat->
T[
j].pLength;
1246 if (li<=0) li=strat->
T[
j].GetpLength();
1262 if ((strat->
T[i].pLength < li)
1270 li = strat->
T[
i].pLength;
1271 if (li<=0) li=strat->
T[
i].GetpLength();
1293 Print(
"BEFORE REDUCTION WITH %d:\n",ii);
1294 Print(
"--------------------------------\n");
1297 pWrite(h->GetLmCurrRing());
1301 Print(
"--------------------------------\n");
1302 printf(
"INDEX OF REDUCER T: %d\n",ii);
1315 int red_result =
redRing(h,strat);
1330 #if SBA_PRINT_REDUCTION_STEPS 1332 sba_reduction_steps++;
1334 #if SBA_PRINT_OPERATIONS 1336 sba_operations +=
pLength(strat->
T[ii].p);
1343 Print(
"SigSAFE: %d\n",sigSafe);
1358 h_p = h->GetLmTailRing();
1364 h->SetShortExpVector();
1376 at = strat->
posInL(strat->
L,strat->
Ll,h,strat);
1377 if (at <= strat->Ll)
1379 int dummy=strat->
sl;
1387 Print(
" lazy: -> L%d\n",at);
1400 #define REDTAIL_CANONICALIZE 100 1404 p = h = L->GetLmTailRing();
1406 return L->GetLmCurrRing();
1414 Ln.sevSig = L->sevSig;
1415 Ln.pLength = L->GetpLength() - 1;
1430 Ln.SetShortExpVector();
1436 With = &(strat->
T[
j]);
1441 if (With ==
NULL)
break;
1465 #if SBA_PRINT_REDUCTION_STEPS 1467 sba_reduction_steps++;
1469 #if SBA_PRINT_OPERATIONS 1471 sba_operations +=
pLength(With->p);
1481 pNext(h) = Ln.LmExtractAndIter();
1484 }
while (!Ln.IsNull());
1487 if (Ln.IsNull())
goto all_done;
1488 if (! withT) With_s.Init(
currRing);
1495 pNext(h) = Ln.LmExtractAndIter();
1512 return L->GetLmCurrRing();
1521 if (strat->
tl<0)
return 1;
1525 assume(h->pFDeg() == h->FDeg);
1526 long reddeg = h->GetpFDeg();
1528 unsigned long not_sev;
1530 h->SetShortExpVector();
1531 poly h_p = h->GetLmTailRing();
1536 if (j < 0)
return 1;
1538 li = strat->
T[
j].pLength;
1539 if (li<=0) li=strat->
T[
j].GetpLength();
1557 if ((strat->
T[i].pLength < li)
1565 li = strat->
T[
i].pLength;
1566 if (li<=0) li=strat->
T[
i].GetpLength();
1588 #if SBA_PRINT_REDUCTION_STEPS 1589 sba_interreduction_steps++;
1591 #if SBA_PRINT_OPERATIONS 1592 sba_interreduction_operations +=
pLength(strat->
T[ii].p);
1604 h_p=h->GetLmTailRing();
1611 h->SetShortExpVector();
1617 (strat->
Ll >= 0) && ((d > reddeg) || (pass > strat->
LazyPass)))
1620 at = strat->
posInL(strat->
L,strat->
Ll,h,strat);
1621 if (at <= strat->Ll)
1624 int dummy=strat->
sl;
1636 else if (d != reddeg)
1638 if (d>=(
long)strat->
tailRing->bitmask)
1640 if (h->pTotalDeg() >= (long)strat->
tailRing->bitmask)
1645 at = strat->
posInL(strat->
L,strat->
Ll,h,strat);
1666 if (strat->
tl<0)
return 1;
1668 assume(h->FDeg == h->pFDeg());
1670 int i,
j,at,pass,ei, ii, h_d;
1671 unsigned long not_sev;
1675 d = reddeg = h->GetpFDeg() + h->ecart;
1676 h->SetShortExpVector();
1678 h_p = h->GetLmTailRing();
1685 if (j < 0)
return 1;
1687 ei = strat->
T[
j].ecart;
1688 li = strat->
T[
j].pLength;
1689 if (li<=0) li=strat->
T[
j].GetpLength();
1707 if ((((strat->
T[i].ecart < ei) && (ei> h->ecart))
1708 || ((strat->
T[i].ecart <= h->ecart) && (strat->
T[i].pLength < li)))
1716 ei = strat->
T[
i].ecart;
1717 li = strat->
T[
i].pLength;
1718 if (li<=0) li=strat->
T[
i].GetpLength();
1737 at = strat->
posInL(strat->
L,strat->
Ll,h,strat);
1755 Print(
"\nwith T[%d]:",ii);
1762 #if SBA_PRINT_REDUCTION_STEPS 1763 sba_interreduction_steps++;
1765 #if SBA_PRINT_OPERATIONS 1766 sba_interreduction_operations +=
pLength(strat->
T[ii].p);
1792 else if (h->t_p!=
NULL)
1801 h->SetShortExpVector();
1803 h_d = h->SetpFDeg();
1808 h->ecart = d-h_d+ei-h->ecart;
1822 at = strat->
posInL(strat->
L,strat->
Ll,h,strat);
1823 if (at <= strat->Ll)
1825 int dummy=strat->
sl;
1831 Print(
" degree jumped: -> L%d\n",at);
1837 else if (d > reddeg)
1839 if (d>=(
long)strat->
tailRing->bitmask)
1841 if (h->pTotalDeg()+h->ecart >= (long)strat->
tailRing->bitmask)
1846 at = strat->
posInL(strat->
L,strat->
Ll,h,strat);
1868 #define REDNF_CANONICALIZE 60 1879 P.SetShortExpVector();
1907 int sl=
pSize(strat->
S[j]);
1985 P.SetShortExpVector();
2034 P.SetShortExpVector();
2062 int sl=
pSize(strat->
S[j]);
2111 P.p =
pJet(P.p,bound);
2115 P.SetShortExpVector();
2143 P.SetShortExpVector();
2182 int hilbeledeg=1,hilbcount=0,minimcnt=0;
2205 withT = ! strat->
homog;
2210 #ifdef HAVE_TAIL_RING 2226 while (strat->
Ll >= 0)
2233 while (strat->
Ll >= 0)
2246 while ((strat->
Ll >= 0)
2247 && (strat->
L[strat->
Ll].p1!=
NULL) && (strat->
L[strat->
Ll].p2!=
NULL)
2252 if (strat->
Ll<0)
break;
2257 strat->
P = strat->
L[strat->
Ll];
2287 else if (strat->
P.p1 ==
NULL)
2289 if (strat->
minim > 0)
2295 if ((strat->
P.p ==
NULL) && (strat->
P.t_p ==
NULL))
2303 &olddeg,&reduc,strat, red_result);
2306 red_result = strat->red(&strat->P,strat);
2316 if (red_result == 1)
2319 strat->
P.GetP(strat->
lmBin);
2328 int pos=
posInS(strat,strat->
sl,strat->
P.p,strat->
P.ecart);
2339 strat->
P.pCleardenom();
2344 strat->
P.pCleardenom();
2348 strat->
P.pCleardenom();
2357 strat->
P.p =
redtailBba(&(strat->
P),pos-1,strat, withT);
2369 if (strat->
minim==1)
2376 strat->
M->m[minimcnt]=strat->
P.p2;
2380 pNext(strat->
M->m[minimcnt])
2396 strat->
enterS(strat->
P, pos, strat, strat->
tl);
2411 if (hilb!=
NULL)
khCheck(Q,w,hilb,hilbeledeg,hilbcount,strat);
2419 if (strat->
s_poly(strat))
2424 int pos=
posInS(strat,strat->
sl,strat->
P.p,strat->
P.ecart);
2430 strat->
enterS(strat->
P, pos, strat, strat->
tl);
2434 else if (strat->
P.p1 ==
NULL && strat->
minim > 0)
2440 memset(&(strat->
P), 0,
sizeof(strat->
P));
2476 #ifdef HAVE_TAIL_RING 2482 for(i=strat->
sl;i>=0;i--) strat->
S_2_R[
i]=-1;
2498 for(
int i = 0;
i<=strat->
sl;
i++)
2533 return (strat->
Shdl);
2545 #if SBA_PRINT_ZERO_REDUCTIONS 2546 long zeroreductions = 0;
2548 #if SBA_PRINT_PRODUCT_CRITERION 2549 long product_criterion = 0;
2551 #if SBA_PRINT_SIZE_G 2553 int size_g_non_red = 0;
2555 #if SBA_PRINT_SIZE_SYZ 2559 #if SBA_PRINT_REDUCTION_STEPS 2560 sba_reduction_steps = 0;
2561 sba_interreduction_steps = 0;
2563 #if SBA_PRINT_OPERATIONS 2565 sba_interreduction_operations = 0;
2569 ring sRing, currRingOld;
2574 if (sRing!=currRingOld)
2593 dummy =
pCopy(F->m[0]);
2595 F->m[
i] = F->m[
i+1];
2616 dummy =
pCopy(F->m[0]);
2618 F->m[
i] = F->m[
i+1];
2637 F->m[
i] = F1->m[(*sort)[
i]-1];
2651 F->m[
j] = F->m[
j-1];
2669 printf(
"SBA COMPUTATIONS DONE IN THE FOLLOWING RING:\n");
2671 printf(
"ordSgn = %d\n",
currRing->OrdSgn);
2674 int srmax,lrmax, red_result = 1;
2676 int hilbeledeg=1,hilbcount=0,minimcnt=0;
2690 reduc = olddeg = lrmax = 0;
2703 #ifdef HAVE_TAIL_RING 2721 strat->
enterS(strat->
L[strat->
Ll-(
i)], strat->
sl+1, strat, strat->
tl);
2731 while (strat->
Ll >= 0)
2733 if (strat->
Ll > lrmax) lrmax =strat->
Ll;
2763 f5c ( strat, olddeg, minimcnt, hilbeledeg, hilbcount, srmax,
2764 lrmax, reduc, Q, w, hilb );
2774 strat->
P = strat->
L[strat->
Ll];
2780 if (!strat->
rewCrit2(strat->
P.sig, ~strat->
P.sevSig, strat->
P.GetLmCurrRing(), strat, strat->
P.checked+1))
2784 PrintS(
"SIG OF NEXT PAIR TO HANDLE IN SIG-BASED ALGORITHM\n");
2785 PrintS(
"-------------------------------------------------\n");
2790 PrintS(
"-------------------------------------------------\n");
2825 else if (strat->
P.p1 ==
NULL)
2827 if (strat->
minim > 0)
2833 if (strat->
P.p ==
NULL && strat->
P.t_p ==
NULL)
2841 PrintS(
"Poly before red: ");
2845 #if SBA_PRODUCT_CRITERION 2846 if (strat->
P.prod_crit)
2848 #if SBA_PRINT_PRODUCT_CRITERION 2849 product_criterion++;
2851 int pos =
posInSyz(strat, strat->
P.sig);
2858 red_result = strat->
red(&strat->
P,strat);
2861 red_result = strat->
red(&strat->
P,strat);
2877 strat->
P.p =
pNeg(strat->
P.p);
2878 strat->
P.sig =
pNeg(strat->
P.sig);
2881 if(strat->
P.sig !=
NULL)
2883 if(strat->
P.p !=
NULL)
2890 red_result =
redRing(&strat->
P,strat);
2895 strat->
P.sig =
NULL;
2899 strat->
enterS(strat->
P, 0, strat, strat->
tl);
2915 if (red_result != 0)
2917 PrintS(
"Poly after red: ");
2919 pWrite(strat->
P.GetLmCurrRing());
2921 printf(
"%d\n",red_result);
2926 if(strat->
P.p !=
NULL)
2928 &olddeg,&reduc,strat, red_result);
2930 message((strat->honey ? strat->P.ecart : 0),
2931 &olddeg,&reduc,strat, red_result);
2939 if (red_result == 1)
2942 strat->
P.GetP(strat->
lmBin);
2946 (strat->
P).FDeg = (strat->
P).pFDeg();
2958 int pos = strat->
sl+1;
2966 beforetailred =
pCopy(strat->
P.sig);
2972 strat->
P.p =
redtailSba(&(strat->
P),pos-1,strat, withT);
2980 strat->
P.pCleardenom();
2983 strat->
P.p =
redtailSba(&(strat->
P),pos-1,strat, withT);
2984 strat->
P.pCleardenom();
2991 strat->
P.p =
redtailSba(&(strat->
P),pos-1,strat, withT);
3000 strat->
enterS(strat->
P, 0, strat, strat->
tl);
3006 if(strat->
P.sig ==
NULL ||
pLtCmp(beforetailred,strat->
P.sig) == 1)
3010 red_result =
redRing(&strat->
P,strat);
3019 strat->
enterS(strat->
P, 0, strat, strat->
tl);
3025 if(strat->
P.p ==
NULL)
3026 goto case_when_red_result_changed;
3032 for (
int jj = 0; jj<strat->
tl+1; jj++)
3036 strat->
T[jj].is_sigsafe =
FALSE;
3042 for (
int jj = 0; jj<strat->
tl+1; jj++)
3044 strat->
T[jj].is_sigsafe =
FALSE;
3054 if (strat->
minim==1)
3061 strat->
M->m[minimcnt]=strat->
P.p2;
3065 pNext(strat->
M->m[minimcnt])
3075 strat->
T[strat->
tl].is_sigsafe =
FALSE;
3089 strat->
enterS(strat->
P, pos, strat, strat->
tl);
3093 for (
int tk=0; tk<strat->
sl+1; tk++)
3114 for(
int ps=0;ps<strat->
sl+1;ps++)
3122 (strat->
syzmax)*
sizeof(
unsigned long),
3124 *
sizeof(
unsigned long));
3127 Q.sig =
pCopy(strat->
P.sig);
3156 unsigned max_cmp =
IDELEMS(F);
3166 for (
int i=0;
i<strat->
sl; ++
i)
3183 for (
unsigned i=cmp+1;
i<=max_cmp; ++
i)
3186 for (
int j=0;
j<strat->
sl; ++
j)
3224 printf(
"---------------------------\n");
3225 Print(
" %d. ELEMENT ADDED TO GCURR:\n",strat->
sl+1);
3248 if (hilb!=
NULL)
khCheck(Q,w,hilb,hilbeledeg,hilbcount,strat);
3251 if (strat->
sl>srmax) srmax = strat->
sl;
3255 case_when_red_result_changed:
3263 #if SBA_PRINT_ZERO_REDUCTIONS 3272 int pos =
posInSyz(strat, strat->
P.sig);
3276 Print(
"ADDING STUFF TO SYZ : ");
3289 memset(&(strat->
P), 0,
sizeof(strat->
P));
3295 printf(
"\nSigDrop!\n");
3297 printf(
"\nEnded with no SigDrop\n");
3303 if(strat->
P.sig !=
NULL)
3307 memset(&(strat->
P), 0,
sizeof(strat->
P));
3342 #ifdef HAVE_TAIL_RING 3348 for(i=strat->
sl;i>=0;i--) strat->
S_2_R[
i]=-1;
3358 #if SBA_PRINT_SIZE_SYZ 3360 size_syz = strat->
syzl;
3373 #if SBA_PRINT_SIZE_G 3388 for(;k>=0 && (strat->
L[
k].p1 !=
NULL || strat->
L[
k].p2 !=
NULL);k--)
3398 for(;k>=0 && strat->
L[
k].p1 ==
NULL && strat->
L[
k].p2 ==
NULL;k--)
3401 strat->
enterS(strat->
L[k], strat->
sl+1, strat, strat->
tl);
3409 for(k=strat->
sl;k>=0;k--)
3411 printf(
"\nsig[%i] = ",
i);
pWrite(strat->
sig[k]);
3442 #if SBA_PRINT_SIZE_G 3446 printf(
"SIZE OF SHDL: %d\n",
IDELEMS(strat->
Shdl));
3450 printf(
" %d. ",oo+1);
3455 #if SBA_PRINT_ZERO_REDUCTIONS 3456 printf(
"----------------------------------------------------------\n");
3457 printf(
"ZERO REDUCTIONS: %ld\n",zeroreductions);
3460 #if SBA_PRINT_REDUCTION_STEPS 3461 printf(
"----------------------------------------------------------\n");
3462 printf(
"S-REDUCTIONS: %ld\n",sba_reduction_steps);
3464 #if SBA_PRINT_OPERATIONS 3465 printf(
"OPERATIONS: %ld\n",sba_operations);
3467 #if SBA_PRINT_REDUCTION_STEPS 3468 printf(
"- - - - - - - - - - - - - - - - - - - - - - - - - - - - - \n");
3469 printf(
"INTERREDUCTIONS: %ld\n",sba_interreduction_steps);
3471 #if SBA_PRINT_OPERATIONS 3472 printf(
"INTERREDUCTION OPERATIONS: %ld\n",sba_interreduction_operations);
3474 #if SBA_PRINT_REDUCTION_STEPS 3475 printf(
"- - - - - - - - - - - - - - - - - - - - - - - - - - - - - \n");
3476 printf(
"ALL REDUCTIONS: %ld\n",sba_reduction_steps+sba_interreduction_steps);
3477 sba_interreduction_steps = 0;
3478 sba_reduction_steps = 0;
3480 #if SBA_PRINT_OPERATIONS 3481 printf(
"ALL OPERATIONS: %ld\n",sba_operations+sba_interreduction_operations);
3482 sba_interreduction_operations = 0;
3485 #if SBA_PRINT_SIZE_G 3486 printf(
"----------------------------------------------------------\n");
3487 printf(
"SIZE OF G: %d / %d\n",size_g,size_g_non_red);
3491 #if SBA_PRINT_SIZE_SYZ 3492 printf(
"SIZE OF SYZ: %ld\n",size_syz);
3493 printf(
"----------------------------------------------------------\n");
3496 #if SBA_PRINT_PRODUCT_CRITERION 3497 printf(
"PRODUCT CRITERIA: %ld\n",product_criterion);
3498 product_criterion = 0;
3500 return (strat->
Shdl);
3524 #ifdef HAVE_SHIFTBBA 3562 p =
redtailBba(p,max_ind,strat,(lazyReduce & KSTD_NF_NONORM)==0);
3575 #ifdef HAVE_SHIFTBBA 3646 p =
redtailBbaBound(p,max_ind,strat,bound,(lazyReduce & KSTD_NF_NONORM)==0);
3691 #ifdef HAVE_SHIFTBBA 3711 for (i=
IDELEMS(q)-1; i>=0; i--)
3726 p =
redtailBba(p,max_ind,strat,(lazyReduce & KSTD_NF_NONORM)==0);
3744 #ifdef HAVE_SHIFTBBA 3801 for (i=
IDELEMS(q)-1; i>=0; i--)
3816 p =
redtailBbaBound(p,max_ind,strat,bound,(lazyReduce & KSTD_NF_NONORM)==0);
3849 int& hilbcount,
int& srmax,
int& lrmax,
int& reduc, ideal
Q,
3852 int Ll_old, red_result = 1;
3858 reduc = olddeg = lrmax = 0;
3863 while (strat->
tl >= 0)
3865 if(!strat->
T[strat->
tl].is_redundant)
3868 h.p = strat->
T[strat->
tl].p;
3869 h.tailRing = strat->
T[strat->
tl].tailRing;
3870 h.t_p = strat->
T[strat->
tl].t_p;
3909 while (strat->
Ll>Ll_old)
3911 strat->
P = strat->
L[strat->
Ll];
3915 PrintS(
"NEXT PAIR TO HANDLE IN INTERRED ALGORITHM\n");
3916 PrintS(
"-------------------------------------------------\n");
3920 printf(
"%d\n",strat->
tl);
3921 PrintS(
"-------------------------------------------------\n");
3954 else if (strat->
P.p1 ==
NULL)
3956 if (strat->
minim > 0)
3963 if (strat->
P.p ==
NULL && strat->
P.t_p ==
NULL)
3971 &olddeg,&reduc,strat, red_result);
3974 PrintS(
"Poly before red: ");
3978 red_result = strat->red2(&strat->P,strat);
3988 if (red_result == 1)
3991 strat->
P.GetP(strat->
lmBin);
4002 pos =
posInS(strat,strat->
sl,strat->
P.p,strat->
P.ecart);
4006 pos =
posInS(strat,strat->
sl,strat->
P.p,strat->
P.ecart);
4015 strat->
P.pCleardenom();
4018 strat->
P.p =
redtailBba(&(strat->
P),pos-1,strat, withT);
4019 strat->
P.pCleardenom();
4026 strat->
P.p =
redtailBba(&(strat->
P),pos-1,strat, withT);
4036 if (strat->
minim==1)
4043 strat->
M->m[minimcnt]=strat->
P.p2;
4047 pNext(strat->
M->m[minimcnt])
4060 strat->
enterS(strat->
P, pos, strat, strat->
tl);
4063 PrintS(
"ELEMENT ADDED TO GCURR DURING INTERRED: ");
4067 if (hilb!=
NULL)
khCheck(Q,w,hilb,hilbeledeg,hilbcount,strat);
4071 if (strat->
sl>srmax) srmax = strat->
sl;
4087 memset(&(strat->
P), 0,
sizeof(strat->
P));
4091 while (cc<strat->tl+1)
4093 strat->
T[cc].sig =
pOne();
4096 strat->
sig[cc] = strat->
T[cc].sig;
4097 strat->
sevSig[cc] = strat->
T[cc].sevSig;
4098 strat->
T[cc].is_sigsafe =
TRUE;
4106 for (
int cd=strat->
Ll;
cd>=0;
cd--)
4114 printf(
"\nAfter f5c sorting\n");
4115 for(
int i=0;
i<=strat->
sl;
i++)
4121 PrintS(
"------------------- STRAT S ---------------------\n");
4123 while (cc<strat->tl+1)
4127 printf(
"- - - - - -\n");
4130 PrintS(
"-------------------------------------------------\n");
4131 PrintS(
"------------------- STRAT T ---------------------\n");
4133 while (cc<strat->tl+1)
4137 printf(
"- - - - - -\n");
4140 PrintS(
"-------------------------------------------------\n");
4141 PrintS(
"------------------- STRAT L ---------------------\n");
4143 while (cc<strat->Ll+1)
4149 printf(
"- - - - - -\n");
4152 PrintS(
"-------------------------------------------------\n");
4153 printf(
"F5C DONE\nSTRAT SL: %d -- %d\n",strat->
sl, strat->
currIdx);
4160 #ifdef HAVE_SHIFTBBA 4167 int hilbeledeg=1,hilbcount=0,minimcnt=0;
4195 #ifdef HAVE_TAIL_RING 4205 while (strat->
Ll >= 0)
4220 while ((strat->
Ll >= 0)
4221 && (strat->
L[strat->
Ll].p1!=
NULL) && (strat->
L[strat->
Ll].p2!=
NULL)
4226 if (strat->
Ll<0)
break;
4230 strat->
P = strat->
L[strat->
Ll];
4253 else if (strat->
P.p1 ==
NULL)
4255 if (strat->
minim > 0)
4261 if (strat->
P.p ==
NULL && strat->
P.t_p ==
NULL)
4269 &olddeg,&reduc,strat, red_result);
4272 red_result = strat->red(&strat->P,strat);
4277 if (red_result == 1)
4280 strat->
P.GetP(strat->
lmBin);
4289 int pos=
posInS(strat,strat->
sl,strat->
P.p,strat->
P.ecart);
4297 strat->
P.pCleardenom();
4300 strat->
P.p =
redtailBba(&(strat->
P),pos-1,strat, withT);
4301 strat->
P.pCleardenom();
4312 strat->
P.p =
redtailBba(&(strat->
P),pos-1,strat, withT);
4327 if (strat->
minim==1)
4334 strat->
M->m[minimcnt]=strat->
P.p2;
4338 pNext(strat->
M->m[minimcnt])
4352 strat->
enterS(strat->
P, pos, strat, strat->
tl);
4357 if (hilb!=
NULL)
khCheck(Q,w,hilb,hilbeledeg,hilbcount,strat);
4365 if (strat->
s_poly(strat))
4370 int pos=
posInS(strat,strat->
sl,strat->
P.p,strat->
P.ecart);
4373 strat->
enterS(strat->
P, pos, strat, strat->
tl);
4379 else if (strat->
P.p1 ==
NULL && strat->
minim > 0)
4384 memset(&(strat->
P), 0,
sizeof(strat->
P));
4394 for (
int k = 0;
k <= strat->
sl; ++
k)
4397 for (
int j = 0;
j<=strat->
tl; ++
j)
4404 if (
pLmCmp(strat->
T[
j].p, strat->
S[
k]) != 0) {
4422 #ifdef HAVE_TAIL_RING 4428 for(i=strat->
sl;i>=0;i--) strat->
S_2_R[
i]=-1;
4429 WarnS(
"reduction with S is not yet supported by Letterplace");
4457 return (strat->
Shdl);
4487 if (h->IsNull())
return 0;
4495 d = h->GetpFDeg() + h->ecart;
4498 h->SetShortExpVector();
4504 h->SetDegStuffReturnLDeg(strat->
LDegLast);
4509 strat->
T[
j].pNorm();
4535 h->SetShortExpVector();
4548 h->SetDegStuffReturnLDeg(strat->
LDegLast);
4558 if (strat->
T[j].ecart <= h->ecart)
4559 h->ecart = d - h->GetpFDeg();
4561 h->ecart = d - h->GetpFDeg() + strat->
T[
j].ecart - h->ecart;
4563 d = h->GetpFDeg() + h->ecart;
4566 d = h->SetDegStuffReturnLDeg(strat->
LDegLast);
4575 && ((d >= reddeg) || (pass > strat->
LazyPass)))
4580 at = strat->
posInL(strat->
L,strat->
Ll,h,strat);
4581 if (at <= strat->Ll)
BOOLEAN rHasLocalOrMixedOrdering(const ring r)
#define __p_GetComp(p, r)
void initEcartPairBba(LObject *Lp, poly, poly, int, int)
void kBucketClear(kBucket_pt bucket, poly *p, int *length)
int kFindNextDivisibleByInS(const kStrategy strat, int start, int max_ind, LObject *L)
BOOLEAN kbTest(kBucket_pt bucket)
Tests.
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...
void replaceInLAndSAndT(LObject &p, int tj, kStrategy strat)
#define omRealloc0Size(addr, o_size, size)
int(* posInL)(const LSet set, const int length, LObject *L, const kStrategy strat)
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...
int posInSMonFirst(const kStrategy strat, const int length, const poly p)
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 initSbaPos(kStrategy strat)
static FORCE_INLINE number n_EucNorm(number a, const coeffs r)
int ksReducePolyLC(LObject *PR, TObject *PW, poly spNoether, number *coef, kStrategy strat)
static void nc_kBucketPolyRed_NF(kBucket_pt b, poly p, number *c)
poly kNF2Bound(ideal F, ideal Q, poly q, int bound, kStrategy strat, int lazyReduce)
int redRing(LObject *h, kStrategy strat)
int kFindDivisibleByInT_Z(const kStrategy strat, const LObject *L, const int start)
static poly normalize(poly next_p, ideal add_generators, syStrategy syzstr, int *g_l, int *p_l, int crit_comp)
void kBucketInit(kBucket_pt bucket, poly lm, int length)
ideal rightgb(ideal F, ideal Q)
int redRing_Z(LObject *h, kStrategy strat)
static CanonicalForm bound(const CFMatrix &M)
static poly p_LmDeleteAndNext(poly p, const ring r)
#define TEST_OPT_DEGBOUND
void enterTShift(LObject p, kStrategy strat, int atT)
KINLINE poly redtailBba_Z(poly p, int pos, kStrategy strat)
void initBuchMoraPos(kStrategy strat)
void message(int i, int *reduc, int *olddeg, kStrategy strat, int red_result)
CanonicalForm cd(bCommonDen(FF))
BOOLEAN idInsertPolyOnPos(ideal I, poly p, int pos)
insert p into I on position pos
#define idDelete(H)
delete an ideal
int posInLF5CRing(const LSet set, int start, const int length, LObject *p, const kStrategy)
int kFindSameLMInT_Z(const kStrategy strat, const LObject *L, const int start)
void messageStat(int hilbcount, kStrategy strat)
void postReduceByMonSig(LObject *h, kStrategy strat)
int posInIdealMonFirst(const ideal F, const poly p, int start, int end)
Compatiblity layer for legacy polynomial operations (over currRing)
void enterSBbaShift(LObject &p, int atS, kStrategy strat, int atR)
number kBucketPolyRed(kBucket_pt bucket, poly p1, int l1, poly spNoether)
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
void initBuchMora(ideal F, ideal Q, kStrategy strat)
static poly p_Mult_mm(poly p, poly m, const ring r)
poly p_NSet(number n, const ring r)
returns the poly representing the number n, destroys n
#define pLmCmp(p, q)
returns 0|1|-1 if p=q|p>q|p<q w.r.t monomial ordering
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
void redtailBbaAlsoLC_Z(LObject *L, int end_pos, kStrategy strat)
#define TEST_OPT_CONTENTSB
static void p_GetExpV(poly p, int *ev, const ring r)
#define REDNF_CANONICALIZE
VAR int(* test_PosInT)(const TSet T, const int tl, LObject &h)
BOOLEAN(* rewCrit2)(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
const poly kBucketGetLm(kBucket_pt bucket)
void initSba(ideal F, kStrategy strat)
BOOLEAN sbaCheckGcdPair(LObject *h, kStrategy strat)
void initSyzRules(kStrategy strat)
void enterpairs(poly h, int k, int ecart, int pos, kStrategy strat, int atR)
poly redNFBound(poly h, int &max_ind, int nonorm, kStrategy strat, int bound)
#define pLmDelete(p)
assume p != NULL, deletes Lm(p)->coef and Lm(p)
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
static void kDeleteLcm(LObject *P)
int ksReducePoly(LObject *PR, TObject *PW, poly spNoether, number *coef, kStrategy strat)
void deleteInS(int i, kStrategy strat)
pShallowCopyDeleteProc p_shallow_copy_delete
int ksReducePolyZ(LObject *PR, TObject *PW, poly spNoether, number *coef, kStrategy strat)
void(* initEcartPair)(LObject *h, poly f, poly g, int ecartF, int ecartG)
ring sbaRing(kStrategy strat, const ring r, BOOLEAN, int)
void cancelunit(LObject *L, BOOLEAN inNF)
void WerrorS(const char *s)
void initSbaBuchMora(ideal F, ideal Q, kStrategy strat)
static intvec * idSort(ideal id, BOOLEAN nolex=TRUE)
void initBba(kStrategy strat)
void enterL(LSet *set, int *length, int *LSetmax, LObject p, int at)
static BOOLEAN rField_is_Z(const ring r)
int redSig(LObject *h, kStrategy strat)
ideal bba(ideal F, ideal Q, intvec *w, intvec *hilb, kStrategy strat)
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
ideal sba(ideal F0, ideal Q, intvec *w, intvec *hilb, kStrategy strat)
static BOOLEAN rIsLPRing(const ring r)
int(* red)(LObject *L, kStrategy strat)
void initBuchMoraPosRing(kStrategy strat)
int redHomog(LObject *h, kStrategy strat)
KINLINE poly redtailBba(poly p, int pos, kStrategy strat, BOOLEAN normalize)
int(* posInT)(const TSet T, const int tl, LObject &h)
void enterpairsSig(poly h, poly hSig, int hFrom, int k, int ecart, int pos, kStrategy strat, int atR)
#define pGetComp(p)
Component.
static void p_SetExpV(poly p, int *ev, const ring r)
int ksReducePolySig(LObject *PR, TObject *PW, long, poly spNoether, number *coef, kStrategy strat)
int redFirstShift(LObject *h, kStrategy strat)
static poly p_Copy(poly p, const ring r)
returns a copy of p
poly redNF(poly h, int &max_ind, int nonorm, kStrategy strat)
char completeReduce_retry
void kStratInitChangeTailRing(kStrategy strat)
#define TEST_OPT_NOT_BUCKETS
void enterT(LObject &p, kStrategy strat, int atT)
int redHoney(LObject *h, kStrategy strat)
void deleteInL(LSet set, int *length, int j, kStrategy strat)
KINLINE poly redtailBbaBound(poly p, int pos, kStrategy strat, int bound, BOOLEAN normalize)
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
void(* initEcart)(TObject *L)
int redLazy(LObject *h, kStrategy strat)
void initS(ideal F, ideal Q, kStrategy strat)
poly kNF2(ideal F, ideal Q, poly q, kStrategy strat, int lazyReduce)
ideal freegb(ideal F, ideal Q)
void kBucketDestroy(kBucket_pt *bucket_pt)
void initEcartPairMora(LObject *Lp, poly, poly, int ecartF, int ecartG)
#define TEST_OPT_INTSTRATEGY
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
void initHilbCrit(ideal, ideal, intvec **hilb, kStrategy strat)
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
void initEcartBBA(TObject *h)
void messageStatSBA(int hilbcount, kStrategy strat)
#define pGetShortExpVector(a)
returns the "Short Exponent Vector" – used to speed up divisibility tests (see polys-impl.cc )
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:...
#define pLmShortDivisibleBy(a, sev_a, b, not_sev_b)
Divisibility tests based on Short Exponent vectors sev_a == pGetShortExpVector(a) not_sev_b == ~ pGet...
void(* enterS)(LObject &h, int pos, kStrategy strat, int atR)
static BOOLEAN p_LmShortDivisibleBy(poly a, unsigned long sev_a, poly b, unsigned long not_sev_b, const ring r)
ideal kInterRed(ideal F, ideal Q)
void ksCreateSpoly(LObject *Pair, poly spNoether, int use_buckets, ring tailRing, poly m1, poly m2, TObject **R)
int kFindDivisibleByInS(const kStrategy strat, int *max_ind, LObject *L)
return -1 if no divisor is found number of first divisor in S, otherwise
ideal bbaShift(ideal F, ideal Q, intvec *w, intvec *hilb, kStrategy strat)
int ksReducePolyGCD(LObject *PR, TObject *PW, poly spNoether, number *coef, kStrategy strat)
ideal idrMoveR(ideal &id, ring src_r, ring dest_r)
static int p_LmCmp(poly p, poly q, const ring r)
BOOLEAN kStratChangeTailRing(kStrategy strat, LObject *L, TObject *T, unsigned long expbound)
static FORCE_INLINE number n_QuotRem(number a, number b, number *q, const coeffs r)
void initBuchMoraCrit(kStrategy strat)
static int si_max(const int a, const int b)
void exitSba(kStrategy strat)
void PrintS(const char *s)
void deleteHC(LObject *L, kStrategy strat, BOOLEAN fromNext)
void superenterpairsSig(poly h, poly hSig, int hFrom, int k, int ecart, int pos, kStrategy strat, int atR)
int redSigRing(LObject *h, kStrategy strat)
static void p_ExpVectorAdd(poly p1, poly p2, const ring r)
void f5c(kStrategy strat, int &olddeg, int &minimcnt, int &hilbeledeg, int &hilbcount, int &srmax, int &lrmax, int &reduc, ideal Q, intvec *w, intvec *hilb)
void rWrite(ring r, BOOLEAN details)
static unsigned pLength(poly a)
#define pHead(p)
returns newly allocated copy of Lm(p), coef is copied, next=NULL, p might be NULL ...
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff 'n' represents the zero element.
static BOOLEAN p_LmDivisibleBy(poly a, poly b, const ring r)
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size
poly kFindZeroPoly(poly input_p, ring leadRing, ring tailRing)
void rChangeCurrRing(ring r)
BOOLEAN kCheckSpolyCreation(LObject *L, kStrategy strat, poly &m1, poly &m2)
#define REDTAIL_CANONICALIZE
static void p_Delete(poly *p, const ring r)
void initBbaShift(kStrategy strat)
void khCheck(ideal Q, intvec *w, intvec *hilb, int &eledeg, int &count, kStrategy strat)
unsigned long p_GetShortExpVector(const poly p, const ring r)
ideal idInit(int idsize, int rank)
initialise an ideal / module
#define p_LmEqual(p1, p2, r)
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent : VarOffset encodes the position in p->exp
void mult(unsigned long *result, unsigned long *a, unsigned long *b, unsigned long p, int dega, int degb)
void postReduceByMon(LObject *h, kStrategy strat)
used for GB over ZZ: intermediate reduction by monomial elements background: any known constant eleme...
static BOOLEAN rField_is_Ring(const ring r)
void cleanT(kStrategy strat)
#define SBA_INTERRED_START
void pEnlargeSet(poly **p, int l, int increment)
void superenterpairs(poly h, int k, int ecart, int pos, kStrategy strat, int atR)
void rDelete(ring r)
unconditionally deletes fields in r
long ind_fact_2(long arg)
int posInSyz(const kStrategy strat, poly sig)
void pNorm(poly p, const ring R=currRing)
static BOOLEAN length(leftv result, leftv arg)
void initSbaCrit(kStrategy strat)
int posInS(const kStrategy strat, const int length, const poly p, const int ecart_p)
void completeReduce(kStrategy strat, BOOLEAN withT)
static void p_Setm(poly p, const ring r)
void updateResult(ideal r, ideal Q, kStrategy strat)
static void pLmFree(poly p)
frees the space of the monomial m, assumes m != NULL coef is not freed, m is not advanced ...
ideal kStdShift(ideal F, ideal Q, tHomog h, intvec **w, intvec *hilb, int syzComp, int newIdeal, intvec *vw, BOOLEAN rightGB)
KINLINE void clearS(poly p, unsigned long p_sev, int *at, int *k, kStrategy strat)
void sort(CFArray &A, int l=0)
quick sort A
char posInLDependsOnLength
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
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
KINLINE int ksReducePolyTailSig(LObject *PR, TObject *PW, LObject *Red, kStrategy strat)
void initEcartNormal(TObject *h)
static poly p_Add_q(poly p, poly q, const ring r)
#define TEST_OPT_REDTHROUGH
void finalReduceByMon(kStrategy strat)
used for GB over ZZ: final reduction by constant elements background: any known constant element of i...
kBucket_pt kBucketCreate(const ring bucket_ring)
Creation/Destruction of buckets.
poly redtailSba(LObject *L, int pos, kStrategy strat, BOOLEAN withT, BOOLEAN normalize)
int kBucketCanonicalize(kBucket_pt bucket)
Canonicalizes Bpoly, i.e. converts polys of buckets into one poly in one bucket: Returns number of bu...
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
KINLINE poly kNoetherTail()
void enterpairsShift(poly h, int k, int ecart, int pos, kStrategy strat, int atR)
#define SI_RESTORE_OPT1(A)
poly p_ISet(long i, const ring r)
returns the poly representing the integer i
static poly p_Mult_q(poly p, poly q, const ring r)
void exitBuchMora(kStrategy strat)
void Werror(const char *fmt,...)
TObject * kFindDivisibleByInS_T(kStrategy strat, int end_pos, LObject *L, TObject *T, long ecart)
void kDebugPrint(kStrategy strat)
void enterSyz(LObject &p, kStrategy strat, int atT)
ideal idrMoveR_NoSort(ideal &id, ring src_r, ring dest_r)
void enterSBba(LObject &p, int atS, kStrategy strat, int atR)
#define pCopy(p)
return a copy of the poly
int ksReducePolySigRing(LObject *PR, TObject *PW, long, poly spNoether, number *coef, kStrategy strat)
VAR int(* test_PosInL)(const LSet set, const int length, LObject *L, const kStrategy strat)