29 int* Components,
long* ShiftedComponents);
55 (*so).isNotMinimal =
NULL;
74 (*so).isNotMinimal =
NULL;
94 (*argso).isNotMinimal =
NULL;
96 (*argso).reference = -1;
108 while (k+kk<sPlength)
112 if (kk>0)
syCopyPair(&sPairs[k+kk],&sPairs[k]);
136 while (k+kk<*sPlength)
140 if (kk>0)
syCopyPair(&sPairs[k+kk],&sPairs[k]);
165 static int syzcomp2dpc_test(poly p1, poly p2)
167 long c1, c2, cc1, cc2, ccc1, ccc2, ec1, ec2;
174 ec1 = p1->exp[
currRing->typ[1].data.syzcomp.place];
175 ec2 = p2->exp[
currRing->typ[1].data.syzcomp.place];
179 Warn(
"Shifted comp of p1 out of sync. should %d, is %d", ccc1, ec1);
184 Warn(
"Shifted comp of p2 out of sync. should %d, is %d", ccc2, ec2);
202 if (o1 > o2)
return 1;
203 if (o1 < o2)
return -1;
219 if (o1==o2)
return 0;
274 for (i=iv->
length()-1;i>=0;i--)
278 if ((j<0) || ((*iv)[
i]<
j))
306 (resPairs[0])[i].syz = (arg->m[(*iv)[
i]-1]);
307 arg->m[(*iv)[
i]-1] =
NULL;
322 (resPairs[0])[i].syz = arg->m[j];
324 (resPairs[0])[
i].order = (*iv)[
j];
328 if (iv!=
NULL)
delete iv;
338 long new_comps = 0, new_space,
max;
343 if (sc[i-1] + 1 < sc[i]) holes++;
361 assume(new_space < SYZ_SHIFT_BASE && new_space >= 4);
363 long* tc = (
long*)
omAlloc(n*
sizeof(
long));
368 if (sc[i-1] + 1 < sc[i])
370 tc[
i] = tc[i-1] + new_space;
384 assume(tc[i-1] + 1 <= tc[i]);
413 if (syzstr->
res[index] !=
NULL)
438 int till=(*syzstr->
Tl)[index-1];
441 if (Pairs[i].syz!=
NULL)
444 till=(*syzstr->
Tl)[index];
447 if (Pairs1[i].
p!=
NULL)
464 int i=
IDELEMS(syzstr->
res[index-1])+1,
j=0,
k,tc,orc,ie=realcomp-1;
470 int *H1=syzstr->
Howmuch[index-1];
479 if (realcomp==0) realcomp=1;
492 if (trind1[orc]>tc+1)
break;
493 else if (trind1[orc] == tc+1)
506 WerrorS(
"orderedRes to small");
517 if ((LONG_MAX - same_comp) <= shind[ie-1])
520 assume((LONG_MAX - same_comp) > shind[ie-1]);
526 assume(ie == 1 || shind[ie-1] > 0);
527 shind[ie] = shind[ie-1] + same_comp;
539 if ((same_comp && prev + 2 >= next) || (!same_comp && next - prev < 4))
544 assume((same_comp && prev + 2 < next) || (!same_comp && next - prev >= 4));
550 for (
k=ie;
k >
j+1;
k--) shind[
k] = shind[
k-1];
555 shind[j+1] = prev + 1;
556 assume(shind[j+1] + 1 < shind[j+2]);
562 shind[j+1] = prev + ((next - prev) >> 1);
563 assume (shind[j] + 1 < shind[j+1] && shind[j+1] + 1 < shind[j+2]);
591 trind[
k] = trind[
k-1];
592 trind[realcomp] =
j+1;
597 #ifdef OLD_PAIR_ORDER 599 int howmuch,
int index)
601 int i=howmuch-1,i1=0,
l,ll;
614 if (syzstr->
res[index+1]!=
NULL)
620 while ((
l<ll) && (!isDivisible))
624 isDivisible = isDivisible ||
640 spSpolyCreate(tso.p2, tso.p1,
NULL,spSpolyLoop_General);
650 int howmuch,
int index)
652 int i=howmuch-1,i1=0,i2,i3,
l,ll;
665 if (syzstr->
res[index+1]!=
NULL)
671 while ((l<ll) && (!isDivisible))
675 isDivisible = isDivisible ||
701 for (i1=0;i1<howmuch;i1++)
712 if (((*spl)[i1]>=0) && ((*spl)[i1]<(*spl)[i2]))
720 (*result)[i3] = i2+1;
739 (
IDELEMS(syzstr->
res[index])+17)*
sizeof(
int));
743 (
IDELEMS(syzstr->
res[index])+17)*
sizeof(
long));
746 (
IDELEMS(syzstr->
res[index])+17)*
sizeof(
int));
749 (
IDELEMS(syzstr->
res[index])+17)*
sizeof(
int));
752 (
IDELEMS(syzstr->
res[index])+17)*
sizeof(
int));
755 (
IDELEMS(syzstr->
res[index])+17)*
sizeof(
int));
757 (
IDELEMS(syzstr->
res[index])+1)*
sizeof(
unsigned long),
758 (
IDELEMS(syzstr->
res[index])+17)*
sizeof(
unsigned long));
769 int howmuch,
int index)
774 int * Hin=syzstr->
Howmuch[index-1];
787 if ((nextPairs==
NULL) || (howmuch==0))
return;
788 while ((k>0) && (syzstr->
res[index]->m[k-1]==
NULL)) k--;
789 while ((ks>0) && (syzstr->
res[index+1]->m[ks-1]==
NULL)) ks--;
790 spl1 =
syLinStrat(nextPairs,syzstr,howmuch,index);
795 tso = nextPairs[(*spl1)[
i]-1];
796 if ((tso.p1!=
NULL) && (tso.p2!=
NULL))
802 tso.syz =
pHead(tso.lcm);
872 need_reset =
syOrder(syzstr->
res[index]->m[k-1],syzstr,index,k);
877 tso.isNotMinimal =
p;
892 syzstr->
res[index+1]->m[ks] = tso.syz;
899 if (
syOrder(syzstr->
res[index+1]->m[ks],syzstr,index+1,ks+1))
903 nextPairs[(*spl1)[
i]-1] = tso;
921 while ((k>0) && (res->m[k-1]==
NULL)) k--;
922 while ((i<(*syzstr->
Tl)[index-1]) && (((sPairs)[i].syz==
NULL) ||
923 ((sPairs)[i].order<deg)))
925 if ((i>=(*syzstr->
Tl)[index-1]) || ((sPairs)[i].order>deg))
return;
926 while ((i<(*syzstr->
Tl)[index-1]) && (((sPairs)[i].syz==
NULL) ||
927 ((sPairs)[i].order==deg)))
929 if ((sPairs)[i].syz!=
NULL)
932 while ((
j>=0) && (res->m[
j]!=
NULL) &&
933 ((sPairs)[i].syz!=
NULL))
947 if ((sPairs)[
i].syz !=
NULL)
956 if ((sPairs)[i].isNotMinimal==
NULL)
965 res->m[
k] =
syRedtail((sPairs)[i].syz,syzstr,index);
966 (sPairs)[i].syzind = k;
971 if (
syOrder(res->m[k-1],syzstr,index,k))
976 (sPairs)[
i].syzind = -1;
987 int ll,
k,no=(*so).order,sP=*sPlength,
i;
989 if ((sP==0) || (sPairs[sP-1].order<=no))
1000 if ((sPairs[an].order<=no) && (sPairs[an+1].order>no))
1005 else if ((sPairs[en].order<=no) && (sPairs[en+1].order>no))
1010 else if (sPairs[an].order>no)
1017 PrintS(
"Hier ist was faul!\n");
1022 if (sPairs[i].order <= no)
1028 for (k=(*sPlength);k>ll;k--)
1039 if (*sPlength>=(*syzstr->
Tl)[index])
1042 for (ll=0;ll<(*syzstr->
Tl)[index];ll++)
1053 temp[ll].isNotMinimal = (syzstr->
resPairs[
index])[ll].isNotMinimal;
1055 temp[ll].reference = (syzstr->
resPairs[
index])[ll].reference;
1059 (*syzstr->
Tl)[index] += 16;
1074 int first,pos,jj,j1;
1080 while ((k>0) && (rs[k-1]==
NULL)) k--;
1081 if (newEl>=k)
return;
1086 ideal nP=
idInit(k,syzstr->
res[index]->rank);
1089 for (j=newEl;j<
k;j++)
1094 for (i=first;i<pos;i++)
1127 for (i=first;i<pos;i++)
1132 if (
l>=(*syzstr->
Tl)[index])
1134 temp = (
SSet)
omAlloc0(((*syzstr->
Tl)[index]+16)*
sizeof(SObject));
1135 for (ll=0;ll<(*syzstr->
Tl)[index];ll++)
1146 temp[ll].isNotMinimal = (syzstr->
resPairs[
index])[ll].isNotMinimal;
1150 (*syzstr->
Tl)[index] += 16;
1153 tso.lcm = p = nPm[ii];
1164 tso.order += (*syzstr->
cw)[jj-1];
1171 tso.isNotMinimal =
NULL;
1182 int *howmuch,
int * actdeg,
int an,
int en)
1184 int newdeg=*actdeg,newindex=-1,
i,t,sldeg;
1192 if (resPairs[*index]!=
NULL)
1194 sldeg = (*actdeg)+*
index;
1198 while ((
i<(*syzstr->
Tl)[*index]))
1200 if ((resPairs[*index])[
i].
lcm!=
NULL)
1202 if ((resPairs[*index])[
i].order == sldeg)
1204 result = &(resPairs[*
index])[
i];
1208 && ((resPairs[*
index])[
i].order == sldeg))
1223 if ((resPairs[*index])[
i].syz!=
NULL)
1225 if ((resPairs[*index])[
i].order == sldeg)
1227 result = &(resPairs[*
index])[
i];
1230 while ((
i<(*syzstr->
Tl)[*
index]) && ((resPairs[*index])[
i].syz!=
NULL)
1231 && ((resPairs[*index])[
i].order == *actdeg))
1249 if (resPairs[*index]!=
NULL)
1255 if (((resPairs[*index])[
i].lcm!=
NULL) ||
1256 ((resPairs[*index])[
i].syz!=
NULL))
1258 if ((resPairs[*index])[
i].order > t)
1259 t = (resPairs[*index])[
i].order;
1261 if ((t>*actdeg+*index) && ((newdeg==*actdeg) || (t<newdeg+*index)))
1304 int *howmuch,
int * actdeg,
int mindeg)
1434 while ((j<length) && (
res[j]!=
NULL))
1436 Print(
"In module %d: \n",j);
1449 Print(
"%d elements of degree %ld\n",i,deg);
1470 for (
int i=0;
i<init;
i++)
1481 syzstr->
sev[
index] = (
unsigned long*)
omAlloc0(init*
sizeof(
unsigned long));
1487 while ((result>0) && (syzstr->
res[index]->m[result-1]==
NULL)) result--;
1506 for (i=0;i<syzstr->
length;i++)
1517 for (i=0;i<syzstr->
length;i++)
1528 for (i=0;i<syzstr->
length;i++)
1543 for (i=0;i<syzstr->
length;i++)
1545 for (j=0;j<(*syzstr->
Tl)[i];j++)
1591 if (syzstr->
res[i]->m[j]!=
NULL)
1621 delete syzstr->
betti;
1648 ring origR=syzstr->
syRing;
1652 for (i=length-1;i>0;i--)
1659 while ((j>0) && (res[i-1]->
m[j-1]==
NULL)) j--;
1661 ri1 = totake[i-1]->m;
1662 for (j=
IDELEMS(res[i])-1;j>=0;j--)
1707 fullres[i-1]->m[
j] = q;
1715 for (j=
IDELEMS(res[i])-1;j>=0;j--)
1729 fullres[i-1] =
idCopy(res[i]);
1732 fullres[i-1] = res[
i];
1736 for (j=
IDELEMS(fullres[i-1])-1;j>=0;j--)
1765 for(i=weights->
length()-1; i>=0; i--)
1768 if ((*weights)[
i]!=(*(syzstr->
weights[0]))[
i])
1786 if ((fullres==
NULL) && (minres==
NULL))
1802 result =
syBetti(fullres,length,&dummy,weights,minim,row_shift);
1804 result =
syBetti(minres,length,&dummy,weights,minim,row_shift);
1838 WerrorS(
"No resolution found");
1842 while ((i>0) && (r[i-1]==
NULL)) i--;
1857 while ((l>0) && (rP[l-1]==
NULL)) l--;
1858 if (l==0)
return -1;
1863 while ((i<(*syzstr->
Tl)[l]) &&
1864 ((rP[l][i].lcm!=
NULL) || (rP[l][i].syz!=
NULL)) &&
1865 (rP[l][i].isNotMinimal!=
NULL))
1869 if ((i<(*syzstr->
Tl)[l]) &&
1870 ((rP[l][i].lcm!=
NULL) || (rP[l][i].syz!=
NULL)) &&
1871 (rP[l][i].isNotMinimal==
NULL))
1941 PrintS(
"No resolution defined\n");
1947 if (resolution==
NULL)
1954 (*resolution)[0] = syzstr->
res[1]->rank;
1959 while ((j<(*syzstr->
Tl)[k]) &&
1960 ((rP[k][j].lcm!=
NULL) || (rP[k][j].syz!=
NULL)))
1962 if (rP[k][j].isNotMinimal==
NULL)
1963 ((*resolution)[k+1])++;
1983 (*resolution)[k+1] =
idElem(rr[k]);
1994 if ((k>=resolution->
length()) || ((*resolution)[
k]==0))
1996 Print(
"%d",(*resolution)[k]);
2004 if ((k>=resolution->
length()) || ((*resolution)[
k]==0))
2007 if (((k+1)>=resolution->
length()) || ((*resolution)[(k+1)]==0))
2018 if ((k>=resolution->
length()) || ((*resolution)[
k]==0))
2028 PrintS(
"resolution not minimized yet\n");
2040 static poly syStripOut(poly
p,
intvec * toStrip)
2042 if (toStrip==
NULL)
return p;
2077 result = pp =
pHead(p);
2100 poly tempStripped=
NULL;
2104 while ((ii<ordn->
length()) && ((*ordn)[ii]!=-1) &&
2105 (sPairs[(*ordn)[ii]].syzind!=toMin))
2112 if (sPairs[
i].isNotMinimal!=
NULL)
2116 pisN = sPairs[
i].isNotMinimal;
2154 int ii=0,
i,tc,lp,ltS=-1;
2157 poly tempStripped=
NULL;
2161 while ((ii<ordn->
length()) && ((*ordn)[ii]!=-1) &&
2162 (sPairs[(*ordn)[ii]].syzind!=toMin))
2169 if (sPairs[
i].isNotMinimal!=
NULL)
2173 tc =
pGetComp(sPairs[i].isNotMinimal);
2213 changes =
new intvec(rj+1,1,-1);
2214 while ((rj>0) && (ri->m[rj-1]==
NULL)) rj--;
2218 if (ri->m[j+k]!=
NULL)
2220 ri->m[
j] = ri->m[j+
k];
2221 (*changes)[j+k+1] = j+1;
2229 for (jj=j;jj<rj;jj++)
2234 for (j=
IDELEMS(ri)-1;j>=0;j--)
2260 for (
int i=(*syzstr->
Tl)[index-1]-1;
i>=0;
i--)
2264 (*result)[syzstr->
resPairs[index-1][
i].syzind+1] = 1;
2278 int i,
j=0,
k=-1,
l,ii;
2285 if (sPairs[i].syzind>
k)
2289 l = sPairs[
i].syzind;
2294 if (sPairs[i].syzind<
l)
2296 l = sPairs[
i].syzind;
2323 tres[0] = syzstr->
res[1];
2334 for (index=syzstr->
length-1;index>0;index--)
2346 i1 = (*syzstr->
Tl)[index];
2351 if ((sPairs[i].isNotMinimal==
NULL) && (sPairs[i].
lcm!=
NULL))
2353 l = sPairs[
i].syzind;
2355 tres[index+1]->m[
l] =
2370 for (i=(*syzstr->
Tl)[0]-1;i>=0;i--)
2372 if (sPairs[i].syzind>=0)
2374 tres[1]->m[sPairs[
i].syzind] =
pCopy(syzstr->
res[1]->m[sPairs[i].syzind]);
2463 for (i=0;i<=arg->rank;i++)
2475 if (temp->m[i]!=
NULL)
2478 if (j<actdeg) actdeg =
j;
2495 syzstr->
sev = (
unsigned long **)
omAlloc0((*length+1)*
sizeof(
unsigned long *));
2502 while (nextPairs!=
NULL)
2524 if (
index<(*length)-1)
2535 if (origR != syzstr->
syRing)
2587 syzstr->
length = maxlength;
2600 for (i=0;i<=arg->rank;i++)
2607 syzstr->
Tl =
new intvec(maxlength);
2612 if (temp->m[i]!=
NULL)
2615 if (j<actdeg) actdeg =
j;
2635 syzstr->
sev = (
unsigned long **)
omAlloc0((maxlength+1)*
sizeof(
unsigned long *));
2645 while (nextPairs!=
NULL)
2667 if (
index<(maxlength-1))
2677 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)
static BOOLEAN idHomModule(ideal m, ideal Q, intvec **w)
#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 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
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 ...
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
static BOOLEAN length(leftv result, leftv arg)
long * currShiftedComponents
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
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)
void syResetShiftedComponents(syStrategy syzstr, int index, int hilb)
#define pCopy(p)
return a copy of the poly