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)
144 while (
k+kk<*sPlength)
175 long c1, c2, cc1, cc2, ccc1, ccc2, ec1, ec2;
182 ec1 = p1->exp[
currRing->typ[1].data.syzcomp.place];
183 ec2 =
p2->exp[
currRing->typ[1].data.syzcomp.place];
187 Warn(
"Shifted comp of p1 out of sync. should %d, is %d", ccc1, ec1);
192 Warn(
"Shifted comp of p2 out of sync. should %d, is %d", ccc2, ec2);
210 if (o1 > o2)
return 1;
211 if (o1 < o2)
return -1;
227 if (o1==o2)
return 0;
286 if ((
j<0) || ((*iv)[
i]<
j))
314 (resPairs[0])[
i].syz = (arg->m[(*iv)[
i]-1]);
315 arg->m[(*iv)[
i]-1] =
NULL;
330 (resPairs[0])[
i].syz = arg->m[
j];
332 (resPairs[0])[
i].order = (*iv)[
j];
336 if (iv!=
NULL)
delete iv;
346 long new_comps = 0, new_space,
max;
351 if (sc[
i-1] + 1 < sc[
i]) holes++;
369 assume(new_space < SYZ_SHIFT_BASE && new_space >= 4);
371 long* tc = (
long*)
omAlloc(n*
sizeof(
long));
376 if (sc[
i-1] + 1 < sc[
i])
378 tc[
i] = tc[
i-1] + new_space;
446 int till=(*syzstr->
Tl)[
index-1];
449 if (Pairs[
i].syz!=
NULL)
487 if (realcomp==0) realcomp=1;
500 if (trind1[orc]>tc+1)
break;
501 else if (trind1[orc] == tc+1)
514 WerrorS(
"orderedRes to small");
525 if ((LONG_MAX - same_comp) <= shind[ie-1])
528 assume((LONG_MAX - same_comp) > shind[ie-1]);
534 assume(ie == 1 || shind[ie-1] > 0);
535 shind[ie] = shind[ie-1] + same_comp;
547 if ((same_comp && prev + 2 >=
next) || (!same_comp &&
next - prev < 4))
552 assume((same_comp && prev + 2 <
next) || (!same_comp &&
next - prev >= 4));
558 for (
k=ie;
k >
j+1;
k--) shind[
k] = shind[
k-1];
563 shind[
j+1] = prev + 1;
564 assume(shind[
j+1] + 1 < shind[
j+2]);
570 shind[
j+1] = prev + ((
next - prev) >> 1);
571 assume (shind[
j] + 1 < shind[
j+1] && shind[
j+1] + 1 < shind[
j+2]);
599 trind[
k] = trind[
k-1];
600 trind[realcomp] =
j+1;
605 #ifdef OLD_PAIR_ORDER 607 int howmuch,
int index)
609 int i=howmuch-1,i1=0,
l,ll;
628 while ((
l<ll) && (!isDivisible))
632 isDivisible = isDivisible ||
648 spSpolyCreate(tso.p2, tso.p1,
NULL,spSpolyLoop_General);
658 int howmuch,
int index)
660 int i=howmuch-1,i1=0,i2,i3,
l,ll;
679 while ((
l<ll) && (!isDivisible))
683 isDivisible = isDivisible ||
709 for (i1=0;i1<howmuch;i1++)
720 if (((*spl)[i1]>=0) && ((*spl)[i1]<(*spl)[i2]))
728 (*result)[i3] = i2+1;
777 int howmuch,
int index)
795 if ((nextPairs==
NULL) || (howmuch==0))
return;
797 while ((ks>0) && (syzstr->
res[
index+1]->m[ks-1]==
NULL)) ks--;
803 tso = nextPairs[(*spl1)[
i]-1];
804 if ((tso.p1!=
NULL) && (tso.p2!=
NULL))
810 tso.syz =
pHead(tso.lcm);
885 tso.isNotMinimal =
p;
900 syzstr->
res[
index+1]->m[ks] = tso.syz;
911 nextPairs[(*spl1)[
i]-1] = tso;
930 while ((
i<(*syzstr->
Tl)[
index-1]) && (((sPairs)[
i].syz==
NULL) ||
931 ((sPairs)[
i].order<deg)))
933 if ((
i>=(*syzstr->
Tl)[
index-1]) || ((sPairs)[
i].order>deg))
return;
934 while ((
i<(*syzstr->
Tl)[
index-1]) && (((sPairs)[
i].syz==
NULL) ||
935 ((sPairs)[
i].order==deg)))
937 if ((sPairs)[
i].syz!=
NULL)
941 ((sPairs)[
i].syz!=
NULL))
955 if ((sPairs)[
i].syz !=
NULL)
964 if ((sPairs)[
i].isNotMinimal==
NULL)
974 (sPairs)[
i].syzind =
k;
984 (sPairs)[
i].syzind = -1;
995 int ll,
k,no=(*so).order,sP=*sPlength,
i;
997 if ((sP==0) || (sPairs[sP-1].order<=no))
1008 if ((sPairs[an].order<=no) && (sPairs[an+1].order>no))
1013 else if ((sPairs[en].order<=no) && (sPairs[en+1].order>no))
1018 else if (sPairs[an].order>no)
1025 PrintS(
"Hier ist was faul!\n");
1030 if (sPairs[
i].order <= no)
1036 for (
k=(*sPlength);
k>ll;
k--)
1047 if (*sPlength>=(*syzstr->
Tl)[
index])
1050 for (ll=0;ll<(*syzstr->
Tl)[
index];ll++)
1061 temp[ll].isNotMinimal = (syzstr->
resPairs[
index])[ll].isNotMinimal;
1063 temp[ll].reference = (syzstr->
resPairs[
index])[ll].reference;
1082 int first,pos,jj,j1;
1088 while ((
k>0) && (rs[
k-1]==
NULL))
k--;
1089 if (newEl>=
k)
return;
1097 for (
j=newEl;
j<
k;
j++)
1102 for (
i=first;
i<pos;
i++)
1135 for (
i=first;
i<pos;
i++)
1143 for (ll=0;ll<(*syzstr->
Tl)[
index];ll++)
1154 temp[ll].isNotMinimal = (syzstr->
resPairs[
index])[ll].isNotMinimal;
1161 tso.lcm =
p = nPm[ii];
1172 tso.order += (*syzstr->
cw)[jj-1];
1179 tso.isNotMinimal =
NULL;
1190 int *howmuch,
int * actdeg,
int an,
int en)
1192 int newdeg=*actdeg,newindex=-1,
i,t,sldeg;
1202 sldeg = (*actdeg)+*
index;
1210 if ((resPairs[*
index])[
i].order == sldeg)
1216 && ((resPairs[*
index])[
i].order == sldeg))
1233 if ((resPairs[*
index])[
i].order == sldeg)
1239 && ((resPairs[*
index])[
i].order == *actdeg))
1266 if ((resPairs[*
index])[
i].order > t)
1267 t = (resPairs[*
index])[
i].order;
1269 if ((t>*actdeg+*
index) && ((newdeg==*actdeg) || (t<newdeg+*
index)))
1312 int *howmuch,
int * actdeg,
int mindeg)
1444 Print(
"In module %d: \n",
j);
1457 Print(
"%d elements of degree %ld\n",
i,deg);
1478 for (
int i=0;
i<init;
i++)
1489 syzstr->
sev[
index] = (
unsigned long*)
omAlloc0(init*
sizeof(
unsigned long));
1553 for (
j=0;
j<(*syzstr->
Tl)[
i];
j++)
1629 delete syzstr->
betti;
1656 ring origR=syzstr->
syRing;
1660 for (
i=length-1;
i>0;
i--)
1669 ri1 = totake[
i-1]->m;
1715 fullres[
i-1]->m[
j] = q;
1740 fullres[
i-1] =
res[
i];
1776 if ((*weights)[
i]!=(*(syzstr->
weights[0]))[
i])
1792 const int length = syzstr->
length;
1794 if ((fullres==
NULL) && (minres==
NULL))
1810 result =
syBetti(fullres,length,&dummy,weights,minim,row_shift);
1812 result =
syBetti(minres,length,&dummy,weights,minim,row_shift);
1846 WerrorS(
"No resolution found");
1850 while ((
i>0) && (
r[
i-1]==
NULL))
i--;
1865 while ((
l>0) && (rP[
l-1]==
NULL))
l--;
1866 if (
l==0)
return -1;
1871 while ((
i<(*syzstr->
Tl)[
l]) &&
1873 (rP[
l][
i].isNotMinimal!=
NULL))
1877 if ((
i<(*syzstr->
Tl)[
l]) &&
1879 (rP[
l][
i].isNotMinimal==
NULL))
1949 PrintS(
"No resolution defined\n");
1955 if (resolution==
NULL)
1962 (*resolution)[0] = syzstr->
res[1]->rank;
1964 while ((k<syzstr->length) && (rP[
k]!=
NULL))
1967 while ((
j<(*syzstr->
Tl)[
k]) &&
1970 if (rP[
k][
j].isNotMinimal==
NULL)
1971 ((*resolution)[
k+1])++;
1989 while ((k<syzstr->length) && (rr[
k]!=
NULL))
1991 (*resolution)[
k+1] =
idElem(rr[
k]);
2002 if ((
k>=resolution->
length()) || ((*resolution)[
k]==0))
2004 Print(
"%d",(*resolution)[
k]);
2012 if ((
k>=resolution->
length()) || ((*resolution)[
k]==0))
2015 if (((
k+1)>=resolution->
length()) || ((*resolution)[(
k+1)]==0))
2026 if ((
k>=resolution->
length()) || ((*resolution)[
k]==0))
2036 PrintS(
"resolution not minimized yet\n");
2050 if (toStrip==
NULL)
return p;
2112 while ((ii<ordn->length()) && ((*ordn)[ii]!=-1) &&
2113 (sPairs[(*ordn)[ii]].syzind!=toMin))
2120 if (sPairs[
i].isNotMinimal!=
NULL)
2124 pisN = sPairs[
i].isNotMinimal;
2162 int ii=0,
i,tc,lp,ltS=-1;
2169 while ((ii<ordn->length()) && ((*ordn)[ii]!=-1) &&
2170 (sPairs[(*ordn)[ii]].syzind!=toMin))
2177 if (sPairs[
i].isNotMinimal!=
NULL)
2215 for (
i=0;
i<length;
i++)
2221 changes =
new intvec(rj+1,1,-1);
2222 while ((rj>0) && (ri->m[rj-1]==
NULL)) rj--;
2228 ri->m[
j] = ri->m[
j+
k];
2229 (*changes)[
j+
k+1] =
j+1;
2237 for (jj=
j;jj<rj;jj++)
2268 for (
int i=(*syzstr->
Tl)[
index-1]-1;
i>=0;
i--)
2286 int i,
j=0,
k=-1,
l,ii;
2291 for(
i=0;
i<length;
i++)
2293 if (sPairs[
i].syzind>
k)
2297 l = sPairs[
i].syzind;
2302 if (sPairs[
i].syzind<
l)
2304 l = sPairs[
i].syzind;
2331 tres[0] = syzstr->
res[1];
2359 if ((sPairs[
i].isNotMinimal==
NULL) && (sPairs[
i].
lcm!=
NULL))
2361 l = sPairs[
i].syzind;
2378 for (
i=(*syzstr->
Tl)[0]-1;
i>=0;
i--)
2380 if (sPairs[
i].syzind>=0)
2382 tres[1]->m[sPairs[
i].syzind] =
pCopy(syzstr->
res[1]->m[sPairs[
i].syzind]);
2465 for (
i=0;
i<=arg->rank;
i++)
2477 if (temp->m[
i]!=
NULL)
2480 if (
j<actdeg) actdeg =
j;
2497 syzstr->
sev = (
unsigned long **)
omAlloc0((*length+1)*
sizeof(
unsigned long *));
2504 while (nextPairs!=
NULL)
2526 if (
index<(*length)-1)
2537 if (origR != syzstr->
syRing)
2591 syzstr->
length = maxlength;
2604 for (
i=0;
i<=arg->rank;
i++)
2611 syzstr->
Tl =
new intvec(maxlength);
2616 if (temp->m[
i]!=
NULL)
2619 if (
j<actdeg) actdeg =
j;
2639 syzstr->
sev = (
unsigned long **)
omAlloc0((maxlength+1)*
sizeof(
unsigned long *));
2649 while (nextPairs!=
NULL)
2671 if (
index<(maxlength-1))
2681 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)
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) == *...
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
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)
void syResetShiftedComponents(syStrategy syzstr, int index, int hilb)
#define pCopy(p)
return a copy of the poly