35 int* Components,
long* ShiftedComponents);
63 (*so).isNotMinimal =
NULL;
82 (*so).isNotMinimal =
NULL;
100 (*argso).syzind = -1;
102 (*argso).isNotMinimal =
NULL;
103 (*argso).length = -1;
104 (*argso).reference = -1;
116 while (k+kk<sPlength)
120 if (kk>0)
syCopyPair(&sPairs[k+kk],&sPairs[k]);
144 while (k+kk<*sPlength)
148 if (kk>0)
syCopyPair(&sPairs[k+kk],&sPairs[k]);
173 long c1, c2, cc1, cc2, ccc1, ccc2, ec1, ec2;
180 ec1 = p1->exp[
currRing->typ[1].data.syzcomp.place];
181 ec2 = p2->exp[
currRing->typ[1].data.syzcomp.place];
185 Warn(
"Shifted comp of p1 out of sync. should %d, is %d", ccc1, ec1);
190 Warn(
"Shifted comp of p2 out of sync. should %d, is %d", ccc2, ec2);
208 if (o1 > o2)
return 1;
209 if (o1 < o2)
return -1;
225 if (o1==o2)
return 0;
279 for (i=iv->
length()-1;i>=0;i--)
283 if ((j<0) || ((*iv)[
i]<
j))
311 (resPairs[0])[i].syz = (arg->m[(*iv)[
i]-1]);
312 arg->m[(*iv)[
i]-1] =
NULL;
327 (resPairs[0])[i].syz = arg->m[j];
329 (resPairs[0])[
i].order = (*iv)[
j];
333 if (iv!=
NULL)
delete iv;
343 long new_comps = 0, new_space,
max;
348 if (sc[i-1] + 1 < sc[i]) holes++;
366 assume(new_space < SYZ_SHIFT_BASE && new_space >= 4);
368 long* tc = (
long*)
omAlloc(n*
sizeof(
long));
373 if (sc[i-1] + 1 < sc[i])
375 tc[
i] = tc[i-1] + new_space;
389 assume(tc[i-1] + 1 <= tc[i]);
418 if (syzstr->
res[index] !=
NULL)
443 int till=(*syzstr->
Tl)[index-1];
446 if (Pairs[i].syz!=
NULL)
449 till=(*syzstr->
Tl)[index];
452 if (Pairs1[i].
p!=
NULL)
469 int i=
IDELEMS(syzstr->
res[index-1])+1,
j=0,
k,tc,orc,ie=realcomp-1;
475 int *H1=syzstr->
Howmuch[index-1];
484 if (realcomp==0) realcomp=1;
497 if (trind1[orc]>tc+1)
break;
498 else if (trind1[orc] == tc+1)
511 WerrorS(
"orderedRes to small");
522 if ((LONG_MAX - same_comp) <= shind[ie-1])
525 assume((LONG_MAX - same_comp) > shind[ie-1]);
531 assume(ie == 1 || shind[ie-1] > 0);
532 shind[ie] = shind[ie-1] + same_comp;
544 if ((same_comp && prev + 2 >= next) || (!same_comp && next - prev < 4))
549 assume((same_comp && prev + 2 < next) || (!same_comp && next - prev >= 4));
555 for (
k=ie;
k >
j+1;
k--) shind[
k] = shind[
k-1];
560 shind[j+1] = prev + 1;
561 assume(shind[j+1] + 1 < shind[j+2]);
567 shind[j+1] = prev + ((next - prev) >> 1);
568 assume (shind[j] + 1 < shind[j+1] && shind[j+1] + 1 < shind[j+2]);
596 trind[
k] = trind[
k-1];
597 trind[realcomp] =
j+1;
602 #ifdef OLD_PAIR_ORDER 604 int howmuch,
int index)
606 int i=howmuch-1,i1=0,
l,ll;
619 if (syzstr->
res[index+1]!=
NULL)
625 while ((
l<ll) && (!isDivisible))
629 isDivisible = isDivisible ||
645 spSpolyCreate(tso.p2, tso.p1,
NULL,spSpolyLoop_General);
655 int howmuch,
int index)
657 int i=howmuch-1,i1=0,i2,i3,
l,ll;
670 if (syzstr->
res[index+1]!=
NULL)
676 while ((l<ll) && (!isDivisible))
680 isDivisible = isDivisible ||
706 for (i1=0;i1<howmuch;i1++)
717 if (((*spl)[i1]>=0) && ((*spl)[i1]<(*spl)[i2]))
725 (*result)[i3] = i2+1;
744 (
IDELEMS(syzstr->
res[index])+17)*
sizeof(
int));
748 (
IDELEMS(syzstr->
res[index])+17)*
sizeof(
long));
751 (
IDELEMS(syzstr->
res[index])+17)*
sizeof(
int));
754 (
IDELEMS(syzstr->
res[index])+17)*
sizeof(
int));
757 (
IDELEMS(syzstr->
res[index])+17)*
sizeof(
int));
760 (
IDELEMS(syzstr->
res[index])+17)*
sizeof(
int));
762 (
IDELEMS(syzstr->
res[index])+1)*
sizeof(
unsigned long),
763 (
IDELEMS(syzstr->
res[index])+17)*
sizeof(
unsigned long));
774 int howmuch,
int index)
779 int * Hin=syzstr->
Howmuch[index-1];
792 if ((nextPairs==
NULL) || (howmuch==0))
return;
793 while ((k>0) && (syzstr->
res[index]->m[k-1]==
NULL)) k--;
794 while ((ks>0) && (syzstr->
res[index+1]->m[ks-1]==
NULL)) ks--;
795 spl1 =
syLinStrat(nextPairs,syzstr,howmuch,index);
800 tso = nextPairs[(*spl1)[
i]-1];
801 if ((tso.p1!=
NULL) && (tso.p2!=
NULL))
807 tso.syz =
pHead(tso.lcm);
877 need_reset =
syOrder(syzstr->
res[index]->m[k-1],syzstr,index,k);
882 tso.isNotMinimal =
p;
897 syzstr->
res[index+1]->m[ks] = tso.syz;
904 if (
syOrder(syzstr->
res[index+1]->m[ks],syzstr,index+1,ks+1))
908 nextPairs[(*spl1)[
i]-1] = tso;
926 while ((k>0) && (res->m[k-1]==
NULL)) k--;
927 while ((i<(*syzstr->
Tl)[index-1]) && (((sPairs)[i].syz==
NULL) ||
928 ((sPairs)[i].order<deg)))
930 if ((i>=(*syzstr->
Tl)[index-1]) || ((sPairs)[i].order>deg))
return;
931 while ((i<(*syzstr->
Tl)[index-1]) && (((sPairs)[i].syz==
NULL) ||
932 ((sPairs)[i].order==deg)))
934 if ((sPairs)[i].syz!=
NULL)
937 while ((
j>=0) && (res->m[
j]!=
NULL) &&
938 ((sPairs)[i].syz!=
NULL))
952 if ((sPairs)[
i].syz !=
NULL)
961 if ((sPairs)[i].isNotMinimal==
NULL)
970 res->m[
k] =
syRedtail((sPairs)[i].syz,syzstr,index);
971 (sPairs)[i].syzind = k;
976 if (
syOrder(res->m[k-1],syzstr,index,k))
981 (sPairs)[
i].syzind = -1;
992 int ll,
k,no=(*so).order,sP=*sPlength,
i;
994 if ((sP==0) || (sPairs[sP-1].order<=no))
1005 if ((sPairs[an].order<=no) && (sPairs[an+1].order>no))
1010 else if ((sPairs[en].order<=no) && (sPairs[en+1].order>no))
1015 else if (sPairs[an].order>no)
1022 PrintS(
"Hier ist was faul!\n");
1027 if (sPairs[i].order <= no)
1033 for (k=(*sPlength);k>ll;k--)
1044 if (*sPlength>=(*syzstr->
Tl)[index])
1047 for (ll=0;ll<(*syzstr->
Tl)[index];ll++)
1058 temp[ll].isNotMinimal = (syzstr->
resPairs[
index])[ll].isNotMinimal;
1060 temp[ll].reference = (syzstr->
resPairs[
index])[ll].reference;
1064 (*syzstr->
Tl)[index] += 16;
1079 int first,pos,jj,j1;
1085 while ((k>0) && (rs[k-1]==
NULL)) k--;
1086 if (newEl>=k)
return;
1091 ideal nP=
idInit(k,syzstr->
res[index]->rank);
1094 for (j=newEl;j<
k;j++)
1099 for (i=first;i<pos;i++)
1132 for (i=first;i<pos;i++)
1137 if (
l>=(*syzstr->
Tl)[index])
1139 temp = (
SSet)
omAlloc0(((*syzstr->
Tl)[index]+16)*
sizeof(SObject));
1140 for (ll=0;ll<(*syzstr->
Tl)[index];ll++)
1151 temp[ll].isNotMinimal = (syzstr->
resPairs[
index])[ll].isNotMinimal;
1155 (*syzstr->
Tl)[index] += 16;
1158 tso.lcm = p = nPm[ii];
1169 tso.order += (*syzstr->
cw)[jj-1];
1176 tso.isNotMinimal =
NULL;
1187 int *howmuch,
int * actdeg,
int an,
int en)
1189 int newdeg=*actdeg,newindex=-1,
i,t,sldeg;
1197 if (resPairs[*index]!=
NULL)
1199 sldeg = (*actdeg)+*
index;
1203 while ((
i<(*syzstr->
Tl)[*index]))
1205 if ((resPairs[*index])[
i].
lcm!=
NULL)
1207 if ((resPairs[*index])[
i].order == sldeg)
1209 result = &(resPairs[*
index])[
i];
1213 && ((resPairs[*
index])[
i].order == sldeg))
1228 if ((resPairs[*index])[
i].syz!=
NULL)
1230 if ((resPairs[*index])[
i].order == sldeg)
1232 result = &(resPairs[*
index])[
i];
1235 while ((
i<(*syzstr->
Tl)[*
index]) && ((resPairs[*index])[
i].syz!=
NULL)
1236 && ((resPairs[*index])[
i].order == *actdeg))
1254 if (resPairs[*index]!=
NULL)
1260 if (((resPairs[*index])[
i].lcm!=
NULL) ||
1261 ((resPairs[*index])[
i].syz!=
NULL))
1263 if ((resPairs[*index])[
i].order > t)
1264 t = (resPairs[*index])[
i].order;
1266 if ((t>*actdeg+*index) && ((newdeg==*actdeg) || (t<newdeg+*index)))
1307 int *howmuch,
int * actdeg,
int mindeg)
1436 while ((j<length) && (
res[j]!=
NULL))
1438 Print(
"In module %d: \n",j);
1451 Print(
"%d elements of degree %ld\n",i,deg);
1472 for (
int i=0;
i<init;
i++)
1483 syzstr->
sev[
index] = (
unsigned long*)
omAlloc0(init*
sizeof(
unsigned long));
1489 while ((result>0) && (syzstr->
res[index]->m[result-1]==
NULL)) result--;
1508 for (i=0;i<syzstr->
length;i++)
1519 for (i=0;i<syzstr->
length;i++)
1530 for (i=0;i<syzstr->
length;i++)
1545 for (i=0;i<syzstr->
length;i++)
1547 for (j=0;j<(*syzstr->
Tl)[i];j++)
1593 if (syzstr->
res[i]->m[j]!=
NULL)
1623 delete syzstr->
betti;
1650 ring origR=syzstr->
syRing;
1654 for (i=length-1;i>0;i--)
1661 while ((j>0) && (res[i-1]->
m[j-1]==
NULL)) j--;
1663 ri1 = totake[i-1]->m;
1664 for (j=
IDELEMS(res[i])-1;j>=0;j--)
1709 fullres[i-1]->m[
j] = q;
1717 for (j=
IDELEMS(res[i])-1;j>=0;j--)
1731 fullres[i-1] =
idCopy(res[i]);
1734 fullres[i-1] = res[
i];
1738 for (j=
IDELEMS(fullres[i-1])-1;j>=0;j--)
1767 for(i=weights->
length()-1; i>=0; i--)
1770 if ((*weights)[
i]!=(*(syzstr->
weights[0]))[
i])
1786 const int length = syzstr->
length;
1788 if ((fullres==
NULL) && (minres==
NULL))
1804 result =
syBetti(fullres,length,&dummy,weights,minim,row_shift);
1806 result =
syBetti(minres,length,&dummy,weights,minim,row_shift);
1840 WerrorS(
"No resolution found");
1844 while ((i>0) && (r[i-1]==
NULL)) i--;
1859 while ((l>0) && (rP[l-1]==
NULL)) l--;
1860 if (l==0)
return -1;
1865 while ((i<(*syzstr->
Tl)[l]) &&
1866 ((rP[l][i].lcm!=
NULL) || (rP[l][i].syz!=
NULL)) &&
1867 (rP[l][i].isNotMinimal!=
NULL))
1871 if ((i<(*syzstr->
Tl)[l]) &&
1872 ((rP[l][i].lcm!=
NULL) || (rP[l][i].syz!=
NULL)) &&
1873 (rP[l][i].isNotMinimal==
NULL))
1943 PrintS(
"No resolution defined\n");
1949 if (resolution==
NULL)
1956 (*resolution)[0] = syzstr->
res[1]->rank;
1958 while ((k<syzstr->length) && (rP[k]!=
NULL))
1961 while ((j<(*syzstr->
Tl)[k]) &&
1962 ((rP[k][j].lcm!=
NULL) || (rP[k][j].syz!=
NULL)))
1964 if (rP[k][j].isNotMinimal==
NULL)
1965 ((*resolution)[k+1])++;
1983 while ((k<syzstr->length) && (rr[k]!=
NULL))
1985 (*resolution)[k+1] =
idElem(rr[k]);
1996 if ((k>=resolution->
length()) || ((*resolution)[
k]==0))
1998 Print(
"%d",(*resolution)[k]);
2006 if ((k>=resolution->
length()) || ((*resolution)[
k]==0))
2009 if (((k+1)>=resolution->
length()) || ((*resolution)[(k+1)]==0))
2020 if ((k>=resolution->
length()) || ((*resolution)[
k]==0))
2030 PrintS(
"resolution not minimized yet\n");
2042 if (toStrip==
NULL)
return p;
2076 result = pp =
pHead(p);
2103 while ((ii<ordn->length()) && ((*ordn)[ii]!=-1) &&
2104 (sPairs[(*ordn)[ii]].syzind!=toMin))
2111 if (sPairs[
i].isNotMinimal!=
NULL)
2115 pisN = sPairs[
i].isNotMinimal;
2153 int ii=0,
i,tc,lp,ltS=-1;
2160 while ((ii<ordn->length()) && ((*ordn)[ii]!=-1) &&
2161 (sPairs[(*ordn)[ii]].syzind!=toMin))
2168 if (sPairs[
i].isNotMinimal!=
NULL)
2172 tc =
pGetComp(sPairs[i].isNotMinimal);
2206 for (i=0;i<length;i++)
2212 changes =
new intvec(rj+1,1,-1);
2213 while ((rj>0) && (ri->m[rj-1]==
NULL)) rj--;
2217 if (ri->m[j+k]!=
NULL)
2219 ri->m[
j] = ri->m[j+
k];
2220 (*changes)[j+k+1] = j+1;
2228 for (jj=j;jj<rj;jj++)
2233 for (j=
IDELEMS(ri)-1;j>=0;j--)
2259 for (
int i=(*syzstr->
Tl)[index-1]-1;
i>=0;
i--)
2263 (*result)[syzstr->
resPairs[index-1][
i].syzind+1] = 1;
2277 int i,
j=0,
k=-1,
l,ii;
2282 for(i=0;i<length;i++)
2284 if (sPairs[i].syzind>
k)
2288 l = sPairs[
i].syzind;
2293 if (sPairs[i].syzind<
l)
2295 l = sPairs[
i].syzind;
2322 tres[0] = syzstr->
res[1];
2333 for (index=syzstr->
length-1;index>0;index--)
2345 i1 = (*syzstr->
Tl)[index];
2350 if ((sPairs[i].isNotMinimal==
NULL) && (sPairs[i].
lcm!=
NULL))
2352 l = sPairs[
i].syzind;
2354 tres[index+1]->m[
l] =
2369 for (i=(*syzstr->
Tl)[0]-1;i>=0;i--)
2371 if (sPairs[i].syzind>=0)
2373 tres[1]->m[sPairs[
i].syzind] =
pCopy(syzstr->
res[1]->m[sPairs[i].syzind]);
2456 for (i=0;i<=arg->rank;i++)
2468 if (temp->m[i]!=
NULL)
2471 if (j<actdeg) actdeg =
j;
2488 syzstr->
sev = (
unsigned long **)
omAlloc0((*length+1)*
sizeof(
unsigned long *));
2495 while (nextPairs!=
NULL)
2517 if (
index<(*length)-1)
2528 if (origR != syzstr->
syRing)
2582 syzstr->
length = maxlength;
2595 for (i=0;i<=arg->rank;i++)
2602 syzstr->
Tl =
new intvec(maxlength);
2607 if (temp->m[i]!=
NULL)
2610 if (j<actdeg) actdeg =
j;
2630 syzstr->
sev = (
unsigned long **)
omAlloc0((maxlength+1)*
sizeof(
unsigned long *));
2640 while (nextPairs!=
NULL)
2662 if (
index<(maxlength-1))
2672 if (origR != syzstr->
syRing)
void kBucketClear(kBucket_pt bucket, poly *p, int *length)
poly prHeadR(poly p, ring src_r, ring dest_r, prCopyProc_t prproc)
#define omRealloc0Size(addr, o_size, size)
static intvec * syLinStrat(SSet nextPairs, syStrategy syzstr, int howmuch, int index)
void syKillEmptyEntres(resolvente res, int length)
static void syCreateNewPairs(syStrategy syzstr, int index, int newEl)
intvec * syBettiOfComputation(syStrategy syzstr, BOOLEAN minim, int *row_shift, intvec *weights)
int lcm(unsigned long *l, unsigned long *a, unsigned long *b, unsigned long p, int dega, int degb)
void kBucketInit(kBucket_pt bucket, poly lm, int length)
void syEnlargeFields(syStrategy syzstr, int index)
static SSet syChosePairsPutIn(syStrategy syzstr, int *index, int *howmuch, int *actdeg, int an, int en)
poly prCopyR(poly p, ring src_r, ring dest_r)
#define idDelete(H)
delete an ideal
syStrategy syCopy(syStrategy syzstr)
int syDim(syStrategy syzstr)
Compatiblity layer for legacy polynomial operations (over currRing)
#define omMemcpyW(p1, p2, l)
number kBucketPolyRed(kBucket_pt bucket, poly p1, int l1, poly spNoether)
void syInitializePair(SObject *so)
void syMinimizeResolvente(resolvente res, int length, int first)
BOOLEAN idTestHomModule(ideal m, ideal Q, intvec *w)
poly prMoveR(poly &p, ring src_r, ring dest_r)
poly syRedtail(poly p, syStrategy syzstr, int index)
#define omFreeSize(addr, size)
const poly kBucketGetLm(kBucket_pt bucket)
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
intvec * ivCopy(const intvec *o)
static void syRedNextPairs(SSet nextPairs, syStrategy syzstr, int howmuch, int index)
KINLINE poly ksOldCreateSpoly(poly p1, poly p2, poly spNoether, ring r)
resolvente syReorder(resolvente res, int length, syStrategy syzstr, BOOLEAN toCopy, resolvente totake)
#define pLmDelete(p)
assume p != NULL, deletes Lm(p)->coef and Lm(p)
static resolvente syReadOutMinimalRes(syStrategy syzstr, BOOLEAN computeStd=FALSE)
void WerrorS(const char *s)
static intvec * idSort(ideal id, BOOLEAN nolex=TRUE)
#define pLmDivisibleBy(a, b)
like pDivisibleBy, except that it is assumed that a!=NULL, b!=NULL
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
#define SYZ_SHIFT_MAX_NEW_COMP_ESTIMATE
void syCopyPair(SObject *argso, SObject *imso)
#define pGetComp(p)
Component.
long syReorderShiftedComponents(long *sc, int n)
void syPrint(syStrategy syzstr, const char *sn)
void syCompactifyPairSet(SSet sPairs, int sPlength, int first)
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
#define pGetExp(p, i)
Exponent.
void rGetSComps(int **currComponents, long **currShiftedComponents, int *length, ring r)
static BOOLEAN syOrder(poly p, syStrategy syzstr, int index, int realcomp)
syStrategy syLaScala3(ideal arg, int *length)
#define pGetOrder(p)
Order.
void kBucketDestroy(kBucket_pt *bucket_pt)
#define pSortCompCorrect(p)
Assume: If considerd only as poly in any component of p (say, monomials of other components of p are ...
static int syChMin(intvec *iv)
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
#define TEST_OPT_NO_SYZ_MINIM
static int max(int a, int b)
#define pLmDivisibleByNoComp(a, b)
like pLmDivisibleBy, does not check components
static long pTotaldegree(poly p)
void syKillComputation(syStrategy syzstr, ring r)
static poly syMinimizeP1(int toMin, syStrategy syzstr, intvec *ordn, int index, intvec *toStrip)
int syInitSyzMod(syStrategy syzstr, int index, int init)
int sySize(syStrategy syzstr)
static int si_max(const int a, const int b)
void PrintS(const char *s)
static void syPrintEmptySpaces(int i)
static unsigned pLength(poly a)
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...
SSet syChosePairs(syStrategy syzstr, int *index, int *howmuch, int *actdeg)
#define pHead(p)
returns newly allocated copy of Lm(p), coef is copied, next=NULL, p might be NULL ...
static int syLengthInt(int i)
static void syRedGenerOfCurrDeg(syStrategy syzstr, int deg, int index)
static void syPrintEmptySpaces1(int i)
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size
static int syzcomp2dpc_test(poly p1, poly p2)
static int index(p_Length length, p_Ord ord)
void rChangeCurrRing(ring r)
void p_Setm_Syz(poly p, ring r, int *Components, long *ShiftedComponents)
static void p_Delete(poly *p, const ring r)
ideal idInit(int idsize, int rank)
initialise an ideal / module
static poly syStripOut(poly p, intvec *toStrip)
syStrategy syLaScala(ideal arg, int &maxlength, intvec *weights)
static poly syStripOutCopy(poly p, intvec *toStrip)
long ** ShiftedComponents
ring rAssure_dp_S(const ring r)
void pEnlargeSet(poly **p, int l, int increment)
void rDelete(ring r)
unconditionally deletes fields in r
void pTakeOutComp(poly *p, long comp, poly *q, int *lq, const ring R=currRing)
Splits *p into two polys: *q which consists of all monoms with component == comp and *p of all other ...
static SSet syChosePairsIH(syStrategy syzstr, int *index, int *howmuch, int *actdeg, int mindeg)
syStrategy syMinimize(syStrategy syzstr)
static void pResetSetm(poly p)
void syEnterPair(SSet sPairs, SObject *so, int *sPlength, int)
void pNorm(poly p, const ring R=currRing)
#define pInit()
allocates a new monomial and initializes everything to 0
long * currShiftedComponents
void syDeletePair(SObject *so)
SRes syInitRes(ideal arg, int *length, intvec *Tl, intvec *cw)
KINLINE poly ksOldSpolyRed(poly p1, poly p2, poly spNoether)
static FORCE_INLINE number n_SubringGcd(number a, number b, const coeffs r)
int idElem(const ideal F)
count non-zero elements
intvec * syBetti(resolvente res, int length, int *regularity, intvec *weights, BOOLEAN tomin, int *row_shift)
static intvec * syToStrip(syStrategy syzstr, int index)
static intvec * syOrdPairs(SSet sPairs, int length)
kBucket_pt kBucketCreate(const ring bucket_ring)
Creation/Destruction of buckets.
void syCompactify1(SSet sPairs, int *sPlength, int first)
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
#define pSetCoeff(p, n)
deletes old coeff before setting the new one
void rChangeSComps(int *currComponents, long *currShiftedComponents, int length, ring r)
void kBucketTakeOutComp(kBucket_pt bucket, long comp, poly *r_p, int *l)
BOOLEAN idHomModule(ideal m, ideal Q, intvec **w)
void syResetShiftedComponents(syStrategy syzstr, int index, int hilb)
#define pCopy(p)
return a copy of the poly