My Project
Loading...
Searching...
No Matches
Functions | Variables
syz1.cc File Reference
#include "kernel/mod2.h"
#include "misc/mylimits.h"
#include "misc/options.h"
#include "misc/intvec.h"
#include "coeffs/numbers.h"
#include "polys/monomials/ring.h"
#include "polys/kbuckets.h"
#include "polys/prCopy.h"
#include "kernel/polys.h"
#include "kernel/GBEngine/kstd1.h"
#include "kernel/GBEngine/kutil.h"
#include "kernel/combinatorics/stairc.h"
#include "kernel/ideals.h"
#include "kernel/GBEngine/syz.h"

Go to the source code of this file.

Functions

void p_Setm_Syz (poly p, ring r, int *Components, long *ShiftedComponents)
 
void syDeletePair (SObject *so)
 
void syInitializePair (SObject *so)
 
void syCopyPair (SObject *argso, SObject *imso)
 
void syCompactifyPairSet (SSet sPairs, int sPlength, int first)
 
void syCompactify1 (SSet sPairs, int *sPlength, int first)
 
poly syRedtail (poly p, syStrategy syzstr, int index)
 
static int syChMin (intvec *iv)
 
SRes syInitRes (ideal arg, int *length, intvec *Tl, intvec *cw)
 
long syReorderShiftedComponents (long *sc, int n)
 
static void pResetSetm (poly p)
 
void syResetShiftedComponents (syStrategy syzstr, int index, int hilb)
 
static BOOLEAN syOrder (poly p, syStrategy syzstr, int index, int realcomp)
 
static intvecsyLinStrat (SSet nextPairs, syStrategy syzstr, int howmuch, int index)
 
void syEnlargeFields (syStrategy syzstr, int index)
 
static void syRedNextPairs (SSet nextPairs, syStrategy syzstr, int howmuch, int index)
 
static void syRedGenerOfCurrDeg (syStrategy syzstr, int deg, int index)
 
void syEnterPair (SSet sPairs, SObject *so, int *sPlength, int)
 
void syEnterPair (syStrategy syzstr, SObject *so, int *sPlength, int index)
 
static void syCreateNewPairs (syStrategy syzstr, int index, int newEl)
 
static SSet syChosePairsPutIn (syStrategy syzstr, int *index, int *howmuch, int *actdeg, int an, int en)
 
SSet syChosePairs (syStrategy syzstr, int *index, int *howmuch, int *actdeg)
 
int syInitSyzMod (syStrategy syzstr, int index, int init)
 
void syKillComputation (syStrategy syzstr, ring r)
 
resolvente syReorder (resolvente res, int length, syStrategy syzstr, BOOLEAN toCopy, resolvente totake)
 
intvecsyBettiOfComputation (syStrategy syzstr, BOOLEAN minim, int *row_shift, intvec *weights)
 
int sySize (syStrategy syzstr)
 
int syDim (syStrategy syzstr)
 
syStrategy syCopy (syStrategy syzstr)
 
static void syPrintEmptySpaces (int i)
 
static void syPrintEmptySpaces1 (int i)
 
static int syLengthInt (int i)
 
void syPrint (syStrategy syzstr, const char *sn)
 
static poly syStripOutCopy (poly p, intvec *toStrip)
 
static poly syMinimizeP1 (int toMin, syStrategy syzstr, intvec *ordn, int index, intvec *toStrip)
 
void syKillEmptyEntres (resolvente res, int length)
 
static intvecsyToStrip (syStrategy syzstr, int index)
 
static intvecsyOrdPairs (SSet sPairs, int length)
 
static resolvente syReadOutMinimalRes (syStrategy syzstr, BOOLEAN computeStd=FALSE)
 
syStrategy syMinimize (syStrategy syzstr)
 
syStrategy syLaScala3 (ideal arg, int *length)
 
syStrategy syLaScala (ideal arg, int &maxlength, intvec *weights)
 

Variables

VAR int * currcomponents =NULL
 
VAR long * currShiftedComponents =NULL
 

Function Documentation

◆ p_Setm_Syz()

void p_Setm_Syz ( poly  p,
ring  r,
int *  Components,
long *  ShiftedComponents 
)

Definition at line 531 of file p_polys.cc.

532{
533 _components = Components;
534 _componentsShifted = ShiftedComponents;
536 p_Setm_General(p, r);
538}
int p
Definition: cfModGcd.cc:4078
STATIC_VAR int _componentsExternal
Definition: p_polys.cc:148
STATIC_VAR long * _componentsShifted
Definition: p_polys.cc:147
void p_Setm_General(poly p, const ring r)
Definition: p_polys.cc:158
STATIC_VAR int * _components
Definition: p_polys.cc:146

◆ pResetSetm()

static void pResetSetm ( poly  p)
static

Definition at line 394 of file syz1.cc.

395{
396#ifdef PDEBUG
397 poly q = p;
398#endif
399 while (p!= NULL)
400 {
401 pSetm(p);
402 pIter(p);
403 }
404#ifdef PDEBUG
405 pTest(q);
406#endif
407}
#define pIter(p)
Definition: monomials.h:37
#define NULL
Definition: omList.c:12
#define pTest(p)
Definition: polys.h:414
#define pSetm(p)
Definition: polys.h:271

◆ syBettiOfComputation()

intvec * syBettiOfComputation ( syStrategy  syzstr,
BOOLEAN  minim,
int *  row_shift,
intvec weights 
)

Don't change the syzstr???

Definition at line 1755 of file syz1.cc.

1757{
1758 int dummy;
1759 BOOLEAN std_weights=TRUE;
1760 if ((weights!=NULL)
1761 && (syzstr->betti!=NULL)
1762 && (syzstr->weights!=NULL) && (syzstr->weights[0]!=NULL))
1763 {
1764 int i;
1765 for(i=weights->length()-1; i>=0; i--)
1766 {
1767 //Print("test %d: %d - %d\n",i,(*weights)[i], (*(syzstr->weights[0]))[i]);
1768 if ((*weights)[i]!=(*(syzstr->weights[0]))[i])
1769 {
1770 std_weights=FALSE;
1771 break;
1772 }
1773 }
1774 }
1775 if ((syzstr->betti!=NULL)
1776 && (std_weights))
1777 {
1778 if (minim || (syzstr->resPairs!=NULL))
1779 return ivCopy(syzstr->betti);
1780 }
1781
1782 resolvente fullres = syzstr->fullres;
1783 resolvente minres = syzstr->minres;
1784 const int length = syzstr->length;
1785
1786 if ((fullres==NULL) && (minres==NULL))
1787 {
1788 if (syzstr->hilb_coeffs==NULL)
1789 { // LA SCALA
1790 fullres = syReorder(syzstr->res, length, syzstr);
1791 }
1792 else
1793 { // HRES
1794 minres = syReorder(syzstr->orderedRes, length, syzstr);
1795 syKillEmptyEntres(minres, length);
1796 }
1797 }
1798
1800
1801 if (fullres!=NULL)
1802 result = syBetti(fullres,length,&dummy,weights,minim,row_shift);
1803 else
1804 result = syBetti(minres,length,&dummy,weights,minim,row_shift);
1805
1806
1807 return result; /// Don't change the syzstr???
1808
1809 // TODO: cleanup these!
1810 if( fullres != NULL && syzstr->fullres == NULL )
1811 syzstr->fullres = fullres;
1812 if( minres != NULL && syzstr->minres == NULL )
1813 syzstr->minres = minres;
1814
1815 if ((result!=NULL)
1816 && ((minim) || (syzstr->resPairs!=NULL))
1817 && std_weights
1818 && (syzstr->betti==NULL))
1819 {
1820 syzstr->betti = ivCopy(result); // cache the result...
1821 }
1822
1823 return result;
1824}
int BOOLEAN
Definition: auxiliary.h:87
#define TRUE
Definition: auxiliary.h:100
#define FALSE
Definition: auxiliary.h:96
int i
Definition: cfEzgcd.cc:132
Definition: intvec.h:23
int length() const
Definition: intvec.h:94
return result
Definition: facAbsBiFact.cc:75
ideal * resolvente
Definition: ideals.h:18
static BOOLEAN length(leftv result, leftv arg)
Definition: interval.cc:257
intvec * ivCopy(const intvec *o)
Definition: intvec.h:145
resolvente syReorder(resolvente res, int length, syStrategy syzstr, BOOLEAN toCopy, resolvente totake)
Definition: syz1.cc:1641
void syKillEmptyEntres(resolvente res, int length)
Definition: syz1.cc:2198
intvec * syBetti(resolvente res, int length, int *regularity, intvec *weights, BOOLEAN tomin, int *row_shift)
Definition: syz.cc:770
intvec ** hilb_coeffs
Definition: syz.h:46
resolvente minres
Definition: syz.h:58
intvec * betti
Definition: syz.h:53
resolvente res
Definition: syz.h:47
resolvente fullres
Definition: syz.h:57
intvec ** weights
Definition: syz.h:45
resolvente orderedRes
Definition: syz.h:48
int length
Definition: syz.h:60
SRes resPairs
Definition: syz.h:49

◆ syChMin()

static int syChMin ( intvec iv)
static

Definition at line 270 of file syz1.cc.

271{
272 int i,j=-1,r=-1;
273
274 for (i=iv->length()-1;i>=0;i--)
275 {
276 if ((*iv)[i]>=0)
277 {
278 if ((j<0) || ((*iv)[i]<j))
279 {
280 j = (*iv)[i];
281 r = i;
282 }
283 }
284 }
285 return r;
286}
int j
Definition: facHensel.cc:110

◆ syChosePairs()

SSet syChosePairs ( syStrategy  syzstr,
int *  index,
int *  howmuch,
int *  actdeg 
)

Definition at line 1288 of file syz1.cc.

1289{
1290 return syChosePairsPutIn(syzstr,index,howmuch,actdeg,0,syzstr->length);
1291}
static int index(p_Length length, p_Ord ord)
Definition: p_Procs_Impl.h:592
static SSet syChosePairsPutIn(syStrategy syzstr, int *index, int *howmuch, int *actdeg, int an, int en)
Definition: syz1.cc:1181

◆ syChosePairsPutIn()

static SSet syChosePairsPutIn ( syStrategy  syzstr,
int *  index,
int *  howmuch,
int *  actdeg,
int  an,
int  en 
)
static

Definition at line 1181 of file syz1.cc.

1183{
1184 int newdeg=*actdeg,newindex=-1,i,t,sldeg;
1185 SSet result;
1186 SRes resPairs=syzstr->resPairs;
1187
1188 if (an>syzstr->length) return NULL;
1189 if (en>syzstr->length) en=syzstr->length;
1190 while (*index<en)
1191 {
1192 if (resPairs[*index]!=NULL)
1193 {
1194 sldeg = (*actdeg)+*index;
1195 i = 0;
1196 if (*index!=0)
1197 {
1198 while ((i<(*syzstr->Tl)[*index]))
1199 {
1200 if ((resPairs[*index])[i].lcm!=NULL)
1201 {
1202 if ((resPairs[*index])[i].order == sldeg)
1203 {
1204 result = &(resPairs[*index])[i];
1205 *howmuch =1;
1206 i++;
1207 while ((i<(*syzstr->Tl)[*index]) && ((resPairs[*index])[i].lcm!=NULL)
1208 && ((resPairs[*index])[i].order == sldeg))
1209 {
1210 i++;
1211 (*howmuch)++;
1212 }
1213 return result;
1214 }
1215 }
1216 i++;
1217 }
1218 }
1219 else
1220 {
1221 while ((i<(*syzstr->Tl)[*index]))
1222 {
1223 if ((resPairs[*index])[i].syz!=NULL)
1224 {
1225 if ((resPairs[*index])[i].order == sldeg)
1226 {
1227 result = &(resPairs[*index])[i];
1228 (*howmuch) =1;
1229 i++;
1230 while ((i<(*syzstr->Tl)[*index]) && ((resPairs[*index])[i].syz!=NULL)
1231 && ((resPairs[*index])[i].order == *actdeg))
1232 {
1233 i++;
1234 (*howmuch)++;
1235 }
1236 return result;
1237 }
1238 }
1239 i++;
1240 }
1241 }
1242 }
1243 (*index)++;
1244 }
1245 *index = an;
1246 //if (TEST_OPT_PROT) Print("(Euler:%d)",euler);
1247 while (*index<en)
1248 {
1249 if (resPairs[*index]!=NULL)
1250 {
1251 i = 0;
1252 while ((i<(*syzstr->Tl)[*index]))
1253 {
1254 t = *actdeg+*index;
1255 if (((resPairs[*index])[i].lcm!=NULL) ||
1256 ((resPairs[*index])[i].syz!=NULL))
1257 {
1258 if ((resPairs[*index])[i].order > t)
1259 t = (resPairs[*index])[i].order;
1260 }
1261 if ((t>*actdeg+*index) && ((newdeg==*actdeg) || (t<newdeg+*index)))
1262 {
1263 newdeg = t-*index;
1264 newindex = *index;
1265 break;
1266 }
1267 i++;
1268 }
1269 }
1270 (*index)++;
1271 }
1272 if (newdeg>*actdeg)
1273 {
1274 *actdeg = newdeg;
1275 *index = newindex;
1276 return syChosePairsPutIn(syzstr,index,howmuch,actdeg,an,en);
1277 }
1278 else return NULL;
1279}
int lcm(unsigned long *l, unsigned long *a, unsigned long *b, unsigned long p, int dega, int degb)
Definition: minpoly.cc:709
intvec * Tl
Definition: syz.h:50
SSet * SRes
Definition: syz.h:33
SObject * SSet
Definition: syz.h:32

◆ syCompactify1()

void syCompactify1 ( SSet  sPairs,
int *  sPlength,
int  first 
)

Definition at line 132 of file syz1.cc.

133{
134 int k=first,kk=0;
135
136 while (k+kk<*sPlength)
137 {
138 if (sPairs[k+kk].lcm!=NULL)
139 {
140 if (kk>0) syCopyPair(&sPairs[k+kk],&sPairs[k]);
141 k++;
142 }
143 else
144 {
145 kk++;
146 }
147 }
148 while (k<*sPlength)
149 {
150 syInitializePair(&sPairs[k]);
151 k++;
152 }
153 *sPlength -= kk;
154}
int k
Definition: cfEzgcd.cc:99
void syCopyPair(SObject *argso, SObject *imso)
Definition: syz1.cc:82
void syInitializePair(SObject *so)
Definition: syz1.cc:63

◆ syCompactifyPairSet()

void syCompactifyPairSet ( SSet  sPairs,
int  sPlength,
int  first 
)

Definition at line 104 of file syz1.cc.

105{
106 int k=first,kk=0;
107
108 while (k+kk<sPlength)
109 {
110 if (sPairs[k+kk].lcm!=NULL)
111 {
112 if (kk>0) syCopyPair(&sPairs[k+kk],&sPairs[k]);
113 k++;
114 }
115 else
116 {
117 kk++;
118 }
119 }
120 while (k<sPlength)
121 {
122 syInitializePair(&sPairs[k]);
123 k++;
124 }
125}

◆ syCopy()

syStrategy syCopy ( syStrategy  syzstr)

Definition at line 1884 of file syz1.cc.

1885{
1886 syStrategy result=syzstr;
1887 (result->references)++;
1888 return result;
1889}

◆ syCopyPair()

void syCopyPair ( SObject *  argso,
SObject *  imso 
)

Definition at line 82 of file syz1.cc.

83{
84 *imso=*argso;
85 (*argso).p = NULL;
86 (*argso).p1 = NULL;
87 (*argso).p2 = NULL;
88 (*argso).lcm = NULL;
89 (*argso).syz = NULL;
90 (*argso).ind1 = 0;
91 (*argso).ind2 = 0;
92 (*argso).syzind = -1;
93 (*argso).order = 0;
94 (*argso).isNotMinimal = NULL;
95 (*argso).length = -1;
96 (*argso).reference = -1;
97}

◆ syCreateNewPairs()

static void syCreateNewPairs ( syStrategy  syzstr,
int  index,
int  newEl 
)
static

Definition at line 1069 of file syz1.cc.

1070{
1071 SSet temp;
1072 SObject tso;
1073 int i,ii,j,k=IDELEMS(syzstr->res[index]),l=(*syzstr->Tl)[index],ll;
1074 int first,pos,jj,j1;
1075 int * bci=syzstr->backcomponents[index];
1076 poly p,q;
1077 polyset rs=syzstr->res[index]->m,nPm;
1078
1079
1080 while ((k>0) && (rs[k-1]==NULL)) k--;
1081 if (newEl>=k) return;
1082
1083 long * ShiftedComponents = syzstr->ShiftedComponents[index];
1084 int* Components = syzstr->truecomponents[index];
1085
1086 ideal nP=idInit(k,syzstr->res[index]->rank);
1087 nPm=nP->m;
1088 while ((l>0) && ((syzstr->resPairs[index])[l-1].p1==NULL)) l--;
1089 for (j=newEl;j<k;j++)
1090 {
1091 q = rs[j];
1092 first = syzstr->Firstelem[index-1][pGetComp(q)]-1;
1093 pos = first+syzstr->Howmuch[index-1][pGetComp(q)];
1094 for (i=first;i<pos;i++)
1095 {
1096 jj = bci[i];
1097 if (jj>=j) break;
1098 p = pOne();
1099 pLcm(rs[jj],q,p);
1100 pSetComp(p,j+1);
1101 p_Setm_Syz(p, currRing, Components, ShiftedComponents);
1102 ii = first;
1103 loop
1104 {
1105 j1 = bci[ii];
1106 if (nPm[j1]!=NULL)
1107 {
1108 if (pLmDivisibleByNoComp(nPm[j1],p))
1109 {
1110 pDelete(&p);
1111 break;
1112 }
1113 else if (pLmDivisibleByNoComp(p,nPm[j1]))
1114 {
1115 pDelete(&(nPm[j1]));
1116 //break;
1117 }
1118 }
1119 ii++;
1120 if (ii>=pos) break;
1121 }
1122 if (p!=NULL)
1123 {
1124 nPm[jj] = p;
1125 }
1126 }
1127 for (i=first;i<pos;i++)
1128 {
1129 ii = bci[i];
1130 if (nPm[ii]!=NULL)
1131 {
1132 if (l>=(*syzstr->Tl)[index])
1133 {
1134 temp = (SSet)omAlloc0(((*syzstr->Tl)[index]+16)*sizeof(SObject));
1135 for (ll=0;ll<(*syzstr->Tl)[index];ll++)
1136 {
1137 temp[ll].p = (syzstr->resPairs[index])[ll].p;
1138 temp[ll].p1 = (syzstr->resPairs[index])[ll].p1;
1139 temp[ll].p2 = (syzstr->resPairs[index])[ll].p2;
1140 temp[ll].syz = (syzstr->resPairs[index])[ll].syz;
1141 temp[ll].lcm = (syzstr->resPairs[index])[ll].lcm;
1142 temp[ll].ind1 = (syzstr->resPairs[index])[ll].ind1;
1143 temp[ll].ind2 = (syzstr->resPairs[index])[ll].ind2;
1144 temp[ll].syzind = (syzstr->resPairs[index])[ll].syzind;
1145 temp[ll].order = (syzstr->resPairs[index])[ll].order;
1146 temp[ll].isNotMinimal = (syzstr->resPairs[index])[ll].isNotMinimal;
1147 }
1148 if (syzstr->resPairs[index] != NULL) // OB: ????
1149 omFreeSize((ADDRESS)syzstr->resPairs[index],(*syzstr->Tl)[index]*sizeof(SObject));
1150 (*syzstr->Tl)[index] += 16;
1151 syzstr->resPairs[index] = temp;
1152 }
1153 tso.lcm = p = nPm[ii];
1154 nPm[ii] = NULL;
1155 tso.order = pTotaldegree(p);
1156 if ((syzstr->cw!=NULL) && (index>0) && (pGetComp(q)>0))
1157 {
1158 int ii=index-1,jj=pGetComp(q);
1159 while (ii>0)
1160 {
1161 jj = pGetComp(syzstr->res[ii]->m[jj-1]);
1162 ii--;
1163 }
1164 tso.order += (*syzstr->cw)[jj-1];
1165 }
1166 tso.p1 = rs[ii];
1167 tso.p2 = q;
1168 tso.ind1 = ii;
1169 tso.ind2 = j;
1170 tso.syzind = -1;
1171 tso.isNotMinimal = NULL;
1172 tso.p = NULL;
1173 tso.syz = NULL;
1174 syEnterPair(syzstr->resPairs[index],&tso,&l,index);
1175 }
1176 }
1177 }
1178 idDelete(&nP);
1179}
void * ADDRESS
Definition: auxiliary.h:119
int l
Definition: cfEzgcd.cc:100
#define idDelete(H)
delete an ideal
Definition: ideals.h:29
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
#define omAlloc0(size)
Definition: omAllocDecl.h:211
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
static long pTotaldegree(poly p)
Definition: polys.h:282
#define pDelete(p_ptr)
Definition: polys.h:186
#define pGetComp(p)
Component.
Definition: polys.h:37
#define pSetComp(p, v)
Definition: polys.h:38
#define pOne()
Definition: polys.h:315
poly * polyset
Definition: polys.h:259
#define pLcm(a, b, m)
Definition: polys.h:295
#define pLmDivisibleByNoComp(a, b)
like pLmDivisibleBy, does not check components
Definition: polys.h:142
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:35
#define IDELEMS(i)
Definition: simpleideals.h:23
#define loop
Definition: structs.h:75
void syEnterPair(SSet sPairs, SObject *so, int *sPlength, int)
Definition: syz1.cc:985
void p_Setm_Syz(poly p, ring r, int *Components, long *ShiftedComponents)
Definition: p_polys.cc:531
intvec * cw
Definition: syz.h:52
int ** backcomponents
Definition: syz.h:41
int ** truecomponents
Definition: syz.h:39
int ** Firstelem
Definition: syz.h:43
long ** ShiftedComponents
Definition: syz.h:40
int ** Howmuch
Definition: syz.h:42

◆ syDeletePair()

void syDeletePair ( SObject *  so)

Definition at line 44 of file syz1.cc.

45{
46 pDelete(&(*so).p);
47 pDelete(&(*so).lcm);
48 pDelete(&(*so).syz);
49 (*so).p1 = NULL;
50 (*so).p2 = NULL;
51 (*so).ind1 = 0;
52 (*so).ind2 = 0;
53 (*so).syzind = -1;
54 (*so).order = 0;
55 (*so).isNotMinimal = NULL;
56 (*so).length = -1;
57 (*so).reference = -1;
58}

◆ syDim()

int syDim ( syStrategy  syzstr)

Definition at line 1849 of file syz1.cc.

1850{
1851 int i,l;
1852 if (syzstr->resPairs!=NULL)
1853 {
1854 SRes rP=syzstr->resPairs;
1855
1856 l = syzstr->length;
1857 while ((l>0) && (rP[l-1]==NULL)) l--;
1858 if (l==0) return -1;
1859 l--;
1860 while (l>=0)
1861 {
1862 i = 0;
1863 while ((i<(*syzstr->Tl)[l]) &&
1864 ((rP[l][i].lcm!=NULL) || (rP[l][i].syz!=NULL)) &&
1865 (rP[l][i].isNotMinimal!=NULL))
1866 {
1867 i++;
1868 }
1869 if ((i<(*syzstr->Tl)[l]) &&
1870 ((rP[l][i].lcm!=NULL) || (rP[l][i].syz!=NULL)) &&
1871 (rP[l][i].isNotMinimal==NULL))
1872 return l;
1873 l--;
1874 }
1875 return l;
1876 }
1877 else
1878 return sySize(syzstr);
1879}
int sySize(syStrategy syzstr)
Definition: syz1.cc:1829

◆ syEnlargeFields()

void syEnlargeFields ( syStrategy  syzstr,
int  index 
)

Definition at line 734 of file syz1.cc.

735{
736 pEnlargeSet(&(syzstr->res[index]->m),IDELEMS(syzstr->res[index]),16);
738 (IDELEMS(syzstr->res[index])+1)*sizeof(int),
739 (IDELEMS(syzstr->res[index])+17)*sizeof(int));
740 syzstr->ShiftedComponents[index]
742 (IDELEMS(syzstr->res[index])+1)*sizeof(long),
743 (IDELEMS(syzstr->res[index])+17)*sizeof(long));
745 (IDELEMS(syzstr->res[index])+1)*sizeof(int),
746 (IDELEMS(syzstr->res[index])+17)*sizeof(int));
747 syzstr->Howmuch[index]=(int*)omRealloc0Size((ADDRESS)syzstr->Howmuch[index],
748 (IDELEMS(syzstr->res[index])+1)*sizeof(int),
749 (IDELEMS(syzstr->res[index])+17)*sizeof(int));
750 syzstr->Firstelem[index]=(int*)omRealloc0Size((ADDRESS)syzstr->Firstelem[index],
751 (IDELEMS(syzstr->res[index])+1)*sizeof(int),
752 (IDELEMS(syzstr->res[index])+17)*sizeof(int));
753 syzstr->elemLength[index]=(int*)omRealloc0Size((ADDRESS)syzstr->elemLength[index],
754 (IDELEMS(syzstr->res[index])+1)*sizeof(int),
755 (IDELEMS(syzstr->res[index])+17)*sizeof(int));
756 syzstr->sev[index]=(unsigned long*)omRealloc0Size((ADDRESS)syzstr->sev[index],
757 (IDELEMS(syzstr->res[index])+1)*sizeof(unsigned long),
758 (IDELEMS(syzstr->res[index])+17)*sizeof(unsigned long));
759 IDELEMS(syzstr->res[index]) += 16;
760 pEnlargeSet(&(syzstr->orderedRes[index]->m),IDELEMS(syzstr->orderedRes[index]),16);
761 IDELEMS(syzstr->orderedRes[index]) += 16;
762}
#define omRealloc0Size(addr, o_size, size)
Definition: omAllocDecl.h:221
void pEnlargeSet(poly **p, int l, int increment)
Definition: p_polys.cc:3696
int ** elemLength
Definition: syz.h:44
unsigned long ** sev
Definition: syz.h:59

◆ syEnterPair() [1/2]

void syEnterPair ( SSet  sPairs,
SObject *  so,
int *  sPlength,
int  index 
)

Definition at line 985 of file syz1.cc.

986{
987 int ll,k,no=(*so).order,sP=*sPlength,i;
988
989 if ((sP==0) || (sPairs[sP-1].order<=no))
990 ll = sP;
991 else if (sP==1)
992 ll = 0;
993 else
994 {
995 int an=0,en=sP-1;
996 loop
997 {
998 if (an>=en-1)
999 {
1000 if ((sPairs[an].order<=no) && (sPairs[an+1].order>no))
1001 {
1002 ll = an+1;
1003 break;
1004 }
1005 else if ((sPairs[en].order<=no) && (sPairs[en+1].order>no))
1006 {
1007 ll = en+1;
1008 break;
1009 }
1010 else if (sPairs[an].order>no)
1011 {
1012 ll = an;
1013 break;
1014 }
1015 else
1016 {
1017 PrintS("Hier ist was faul!\n");
1018 break;
1019 }
1020 }
1021 i=(an+en) / 2;
1022 if (sPairs[i].order <= no)
1023 an=i;
1024 else
1025 en=i;
1026 }
1027 }
1028 for (k=(*sPlength);k>ll;k--)
1029 {
1030 syCopyPair(&sPairs[k-1],&sPairs[k]);
1031 }
1032 syCopyPair(so,&sPairs[ll]);
1033 (*sPlength)++;
1034}
void PrintS(const char *s)
Definition: reporter.cc:284

◆ syEnterPair() [2/2]

void syEnterPair ( syStrategy  syzstr,
SObject *  so,
int *  sPlength,
int  index 
)

Definition at line 1035 of file syz1.cc.

1036{
1037 int ll;
1038
1039 if (*sPlength>=(*syzstr->Tl)[index])
1040 {
1041 SSet temp = (SSet)omAlloc0(((*syzstr->Tl)[index]+16)*sizeof(SObject));
1042 for (ll=0;ll<(*syzstr->Tl)[index];ll++)
1043 {
1044 temp[ll].p = (syzstr->resPairs[index])[ll].p;
1045 temp[ll].p1 = (syzstr->resPairs[index])[ll].p1;
1046 temp[ll].p2 = (syzstr->resPairs[index])[ll].p2;
1047 temp[ll].syz = (syzstr->resPairs[index])[ll].syz;
1048 temp[ll].lcm = (syzstr->resPairs[index])[ll].lcm;
1049 temp[ll].ind1 = (syzstr->resPairs[index])[ll].ind1;
1050 temp[ll].ind2 = (syzstr->resPairs[index])[ll].ind2;
1051 temp[ll].syzind = (syzstr->resPairs[index])[ll].syzind;
1052 temp[ll].order = (syzstr->resPairs[index])[ll].order;
1053 temp[ll].isNotMinimal = (syzstr->resPairs[index])[ll].isNotMinimal;
1054 temp[ll].length = (syzstr->resPairs[index])[ll].length;
1055 temp[ll].reference = (syzstr->resPairs[index])[ll].reference;
1056 }
1057 if (syzstr->resPairs[index] != NULL) // OB: ?????
1058 omFreeSize((ADDRESS)syzstr->resPairs[index],(*syzstr->Tl)[index]*sizeof(SObject));
1059 (*syzstr->Tl)[index] += 16;
1060 syzstr->resPairs[index] = temp;
1061 }
1062 syEnterPair(syzstr->resPairs[index],so,sPlength,index);
1063}

◆ syInitializePair()

void syInitializePair ( SObject *  so)

Definition at line 63 of file syz1.cc.

64{
65 (*so).p = NULL;
66 (*so).lcm = NULL;
67 (*so).syz = NULL;
68 (*so).p1 = NULL;
69 (*so).p2 = NULL;
70 (*so).ind1 = 0;
71 (*so).ind2 = 0;
72 (*so).syzind = -1;
73 (*so).order = 0;
74 (*so).isNotMinimal = NULL;
75 (*so).length = -1;
76 (*so).reference = -1;
77}

◆ syInitRes()

SRes syInitRes ( ideal  arg,
int *  length,
intvec Tl,
intvec cw 
)

Definition at line 293 of file syz1.cc.

294{
295 if (idIs0(arg)) return NULL;
296 SRes resPairs = (SRes)omAlloc0(*length*sizeof(SSet));
297 resPairs[0] = (SSet)omAlloc0(IDELEMS(arg)*sizeof(SObject));
298 intvec * iv=NULL;
299 int i,j;
300
301 if (id_RankFreeModule(arg,currRing)==0)
302 {
303 iv = idSort(arg);
304 for (i=0;i<IDELEMS(arg);i++)
305 {
306 (resPairs[0])[i].syz = /*pCopy*/(arg->m[(*iv)[i]-1]);
307 arg->m[(*iv)[i]-1] = NULL;
308 (resPairs[0])[i].order = pTotaldegree((resPairs[0])[i].syz);
309 }
310 }
311 else
312 {
313 iv = new intvec(IDELEMS(arg),1,-1);
314 for (i=0;i<IDELEMS(arg);i++)
315 {
316 (*iv)[i] = pTotaldegree(arg->m[i])+(*cw)[pGetComp(arg->m[i])-1];
317 }
318 for (i=0;i<IDELEMS(arg);i++)
319 {
320 j = syChMin(iv);
321 if (j<0) break;
322 (resPairs[0])[i].syz = arg->m[j];
323 arg->m[j] = NULL;
324 (resPairs[0])[i].order = (*iv)[j];
325 (*iv)[j] = -1;
326 }
327 }
328 if (iv!=NULL) delete iv;
329 (*Tl)[0] = IDELEMS(arg);
330 return resPairs;
331}
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
static intvec * idSort(ideal id, BOOLEAN nolex=TRUE)
Definition: ideals.h:184
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
static int syChMin(intvec *iv)
Definition: syz1.cc:270

◆ syInitSyzMod()

int syInitSyzMod ( syStrategy  syzstr,
int  index,
int  init 
)

Definition at line 1459 of file syz1.cc.

1460{
1461 int result;
1462
1463 if (syzstr->res[index]==NULL)
1464 {
1465 syzstr->res[index] = idInit(init-1,1);
1466 syzstr->truecomponents[index] = (int*)omAlloc0(init*sizeof(int));
1467 syzstr->ShiftedComponents[index] = (long*)omAlloc0(init*sizeof(long));
1468 if (index==0)
1469 {
1470 for (int i=0;i<init;i++)
1471 {
1472 syzstr->truecomponents[0][i] = i;
1473 syzstr->ShiftedComponents[0][i] = (i)*SYZ_SHIFT_BASE;
1474 }
1475 }
1476 syzstr->backcomponents[index] = (int*)omAlloc0(init*sizeof(int));
1477 syzstr->Howmuch[index] = (int*)omAlloc0(init*sizeof(int));
1478 syzstr->Firstelem[index] = (int*)omAlloc0(init*sizeof(int));
1479 syzstr->elemLength[index] = (int*)omAlloc0(init*sizeof(int));
1480 syzstr->orderedRes[index] = idInit(init-1,1);
1481 syzstr->sev[index] = (unsigned long*) omAlloc0(init*sizeof(unsigned long));
1482 result = 0;
1483 }
1484 else
1485 {
1486 result = IDELEMS(syzstr->res[index]);
1487 while ((result>0) && (syzstr->res[index]->m[result-1]==NULL)) result--;
1488 }
1489 return result;
1490}
void init()
Definition: lintree.cc:864
#define SYZ_SHIFT_BASE
Definition: syz.h:18

◆ syKillComputation()

void syKillComputation ( syStrategy  syzstr,
ring  r 
)

Definition at line 1495 of file syz1.cc.

1496{
1497 if (syzstr->references>0)
1498 {
1499 (syzstr->references)--;
1500 }
1501 else
1502 {
1503 int i,j;
1504 if (syzstr->minres!=NULL)
1505 {
1506 for (i=0;i<syzstr->length;i++)
1507 {
1508 if (syzstr->minres[i]!=NULL)
1509 {
1510 id_Delete(&(syzstr->minres[i]),r);
1511 }
1512 }
1513 omFreeSize((ADDRESS)syzstr->minres,(syzstr->length+1)*sizeof(ideal));
1514 }
1515 if (syzstr->fullres!=NULL)
1516 {
1517 for (i=0;i<syzstr->length;i++)
1518 {
1519 if (syzstr->fullres[i]!=NULL)
1520 {
1521 id_Delete(&(syzstr->fullres[i]),r);
1522 }
1523 }
1524 omFreeSize((ADDRESS)syzstr->fullres,(syzstr->length+1)*sizeof(ideal));
1525 }
1526 if (syzstr->weights!=NULL)
1527 {
1528 for (i=0;i<syzstr->length;i++)
1529 {
1530 if (syzstr->weights[i]!=NULL)
1531 {
1532 delete syzstr->weights[i];
1533 }
1534 }
1535 omFreeSize((ADDRESS)syzstr->weights,syzstr->length*sizeof(intvec*));
1536 }
1537
1538 ring sr=syzstr->syRing;
1539 if (sr==NULL) sr=r;
1540
1541 if (syzstr->resPairs!=NULL)
1542 {
1543 for (i=0;i<syzstr->length;i++)
1544 {
1545 for (j=0;j<(*syzstr->Tl)[i];j++)
1546 {
1547 if ((syzstr->resPairs[i])[j].lcm!=NULL)
1548 p_Delete(&((syzstr->resPairs[i])[j].lcm),sr);
1549 if ((i>0) && ((syzstr->resPairs[i])[j].syz!=NULL))
1550 p_Delete(&((syzstr->resPairs[i])[j].syz),sr);
1551 }
1552 if (syzstr->orderedRes[i]!=NULL)
1553 {
1554 for (j=0;j<IDELEMS(syzstr->orderedRes[i]);j++)
1555 {
1556 syzstr->orderedRes[i]->m[j] = NULL;
1557 }
1558 id_Delete(&(syzstr->orderedRes[i]),sr);
1559 }
1560 if (syzstr->truecomponents[i]!=NULL)
1561 {
1562 omFreeSize((ADDRESS)syzstr->truecomponents[i],(IDELEMS(syzstr->res[i])+1)*sizeof(int));
1563 syzstr->truecomponents[i]=NULL;
1564 omFreeSize((ADDRESS)syzstr->ShiftedComponents[i],(IDELEMS(syzstr->res[i])+1)*sizeof(long));
1565 syzstr->ShiftedComponents[i]=NULL;
1566 }
1567 if (syzstr->backcomponents[i]!=NULL)
1568 {
1569 omFreeSize((ADDRESS)syzstr->backcomponents[i],(IDELEMS(syzstr->res[i])+1)*sizeof(int));
1570 syzstr->backcomponents[i]=NULL;
1571 }
1572 if (syzstr->Howmuch[i]!=NULL)
1573 {
1574 omFreeSize((ADDRESS)syzstr->Howmuch[i],(IDELEMS(syzstr->res[i])+1)*sizeof(int));
1575 syzstr->Howmuch[i]=NULL;
1576 }
1577 if (syzstr->Firstelem[i]!=NULL)
1578 {
1579 omFreeSize((ADDRESS)syzstr->Firstelem[i],(IDELEMS(syzstr->res[i])+1)*sizeof(int));
1580 syzstr->Firstelem[i]=NULL;
1581 }
1582 if (syzstr->elemLength[i]!=NULL)
1583 {
1584 omFreeSize((ADDRESS)syzstr->elemLength[i],(IDELEMS(syzstr->res[i])+1)*sizeof(int));
1585 syzstr->elemLength[i]=NULL;
1586 }
1587 if (syzstr->res[i]!=NULL)
1588 {
1589 for (j=0;j<IDELEMS(syzstr->res[i]);j++)
1590 {
1591 if (syzstr->res[i]->m[j]!=NULL)
1592 p_Delete(&(syzstr->res[i]->m[j]),sr);
1593 }
1594 }
1595 if ((syzstr->hilb_coeffs!=NULL)
1596 && (syzstr->hilb_coeffs[i]!=NULL))
1597 delete syzstr->hilb_coeffs[i];
1598 if (syzstr->sev[i] != NULL)
1599 omFreeSize((ADDRESS)syzstr->sev[i], (IDELEMS(syzstr->res[i])+1)*sizeof(unsigned long));
1600 id_Delete(&(syzstr->res[i]),sr);
1601 if (syzstr->resPairs[i] != NULL) // OB: ????
1602 omFreeSize((ADDRESS)syzstr->resPairs[i],(*syzstr->Tl)[i]*sizeof(SObject));
1603 }
1604 omFreeSize((ADDRESS)syzstr->resPairs,syzstr->length*sizeof(SObject*));
1605 omFreeSize((ADDRESS)syzstr->res,(syzstr->length+1)*sizeof(ideal));
1606 omFreeSize((ADDRESS)syzstr->orderedRes,(syzstr->length+1)*sizeof(ideal));
1607 omFreeSize((ADDRESS)syzstr->elemLength,(syzstr->length+1)*sizeof(int*));
1608 omFreeSize((ADDRESS)syzstr->truecomponents,(syzstr->length+1)*sizeof(int*));
1609 omFreeSize((ADDRESS)syzstr->ShiftedComponents,(syzstr->length+1)*sizeof(long*));
1610 if (syzstr->sev != NULL)
1611 omFreeSize(((ADDRESS)syzstr->sev), (syzstr->length+1)*sizeof(unsigned long*));
1612 omFreeSize((ADDRESS)syzstr->backcomponents,(syzstr->length+1)*sizeof(int*));
1613 omFreeSize((ADDRESS)syzstr->Howmuch,(syzstr->length+1)*sizeof(int*));
1614 omFreeSize((ADDRESS)syzstr->Firstelem,(syzstr->length+1)*sizeof(int*));
1615 if (syzstr->hilb_coeffs!=NULL)
1616 omFreeSize((ADDRESS)syzstr->hilb_coeffs,(syzstr->length+1)*sizeof(intvec*));
1617 }
1618 if (syzstr->cw!=NULL)
1619 delete syzstr->cw;
1620 if (syzstr->betti!=NULL)
1621 delete syzstr->betti;
1622 if (syzstr->resolution!=NULL)
1623 delete syzstr->resolution;
1624 if (syzstr->Tl!=NULL)
1625 delete syzstr->Tl;
1626 if ((syzstr->syRing != NULL) && (syzstr->syRing != r))
1627 {
1628 if(syzstr->syRing->typ[1].ord_typ == ro_syzcomp)
1629 rChangeSComps(NULL, NULL, 0, syzstr->syRing);
1630
1631 rDelete(syzstr->syRing);
1632 }
1633 omFreeSize((ADDRESS)syzstr, sizeof(ssyStrategy));
1634 }
1635}
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:899
void rChangeSComps(int *currComponents, long *currShiftedComponents, int length, ring r)
Definition: ring.cc:4405
void rDelete(ring r)
unconditionally deletes fields in r
Definition: ring.cc:450
@ ro_syzcomp
Definition: ring.h:59
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
ring syRing
Definition: syz.h:56
short references
Definition: syz.h:63
intvec * resolution
Definition: syz.h:51

◆ syKillEmptyEntres()

void syKillEmptyEntres ( resolvente  res,
int  length 
)

Definition at line 2198 of file syz1.cc.

2199{
2200 int i,j,jj,k,rj;
2201 intvec * changes;
2202 poly p;
2203 ideal ri;
2204
2205 for (i=0;i<length;i++)
2206 {
2207 ri = res[i];
2208 if (ri!=NULL)
2209 {
2210 rj = IDELEMS(ri);
2211 changes = new intvec(rj+1,1,-1);
2212 while ((rj>0) && (ri->m[rj-1]==NULL)) rj--;
2213 j = k = 0;
2214 while (j+k<rj)
2215 {
2216 if (ri->m[j+k]!=NULL)
2217 {
2218 ri->m[j] = ri->m[j+k];
2219 (*changes)[j+k+1] = j+1;
2220 j++;
2221 }
2222 else
2223 {
2224 k++;
2225 }
2226 }
2227 for (jj=j;jj<rj;jj++)
2228 ri->m[jj] = NULL;
2229 if (res[i+1]!=NULL)
2230 {
2231 ri = res[i+1];
2232 for (j=IDELEMS(ri)-1;j>=0;j--)
2233 {
2234 p = ri->m[j];
2235 while (p!=NULL)
2236 {
2237 pSetComp(p,(*changes)[pGetComp(p)]);
2238 pSetm(p);
2239 pIter(p);
2240 }
2241 }
2242 }
2243 delete changes;
2244 }
2245 }
2246}
CanonicalForm res
Definition: facAbsFact.cc:60
if(!FE_OPT_NO_SHELL_FLAG)(void) system(sys)

◆ syLaScala()

syStrategy syLaScala ( ideal  arg,
int &  maxlength,
intvec weights 
)

Definition at line 2557 of file syz1.cc.

2558{
2559 int i,j,actdeg=32000,index=0;
2560 int howmuch;
2561 ideal temp;
2562 SSet nextPairs;
2563 syStrategy syzstr=(syStrategy)omAlloc0(sizeof(ssyStrategy));
2564 ring origR = currRing;
2565
2566 if(weights!= NULL)
2567 syzstr->cw = new intvec(weights);
2568 else
2569 syzstr->cw = NULL;
2570
2571 if ((idIs0(arg)) ||
2572 ((id_RankFreeModule(arg,currRing)>0) && (!idTestHomModule(arg, NULL, syzstr->cw))))
2573 {
2575 syzstr->length = 1;
2576 syzstr->minres[0] = idInit(1,arg->rank);
2577 return syzstr;
2578 }
2579
2580
2581 //crit = 0;
2582 //euler = -1;
2583
2584 if( maxlength > 0 )
2585 syzstr->length = maxlength; // = (currRing->N)+2;
2586 else
2587 syzstr->length = maxlength = (currRing->N)+2;
2588
2589 // Creare dp,S ring and change to it
2590 syzstr->syRing = rAssure_dp_S(origR);
2591 assume(syzstr->syRing != origR);
2592 assume(syzstr->syRing->typ[1].ord_typ == ro_syzcomp);
2593 rChangeCurrRing(syzstr->syRing);
2594
2595 // set initial ShiftedComps
2596 currcomponents = (int*)omAlloc0((arg->rank+1)*sizeof(int));
2597 currShiftedComponents = (long*)omAlloc0((arg->rank+1)*sizeof(long));
2598 for (i=0;i<=arg->rank;i++)
2599 {
2601 currcomponents[i] = i;
2602 }
2604/*--- initializes the data structures---------------*/
2605 syzstr->Tl = new intvec(maxlength);
2606 temp = idInit(IDELEMS(arg),arg->rank);
2607 for (i=0;i<IDELEMS(arg);i++)
2608 {
2609 temp->m[i] = prCopyR( arg->m[i], origR, currRing);
2610 if (temp->m[i]!=NULL)
2611 {
2612 j = pTotaldegree(temp->m[i]);
2613 if (j<actdeg) actdeg = j;
2614 }
2615 }
2616 idTest(temp);
2617 idSkipZeroes(temp);
2618 idTest(temp);
2619 syzstr->resPairs = syInitRes(temp,&maxlength,syzstr->Tl,syzstr->cw);
2620 omFreeSize((ADDRESS)currcomponents,(arg->rank+1)*sizeof(int));
2621 omFreeSize((ADDRESS)currShiftedComponents,(arg->rank+1)*sizeof(long));
2622
2623 syzstr->res = (resolvente)omAlloc0((maxlength+1)*sizeof(ideal));
2624 syzstr->orderedRes = (resolvente)omAlloc0((maxlength+1)*sizeof(ideal));
2625 syzstr->elemLength = (int**)omAlloc0((maxlength+1)*sizeof(int*));
2626
2627 syzstr->truecomponents = (int**)omAlloc0((maxlength+1)*sizeof(int*));
2628 syzstr->ShiftedComponents = (long**)omAlloc0((maxlength+1)*sizeof(long*));
2629
2630 syzstr->backcomponents = (int**)omAlloc0((maxlength+1)*sizeof(int*));
2631 syzstr->Howmuch = (int**)omAlloc0((maxlength+1)*sizeof(int*));
2632 syzstr->Firstelem = (int**)omAlloc0((maxlength+1)*sizeof(int*));
2633 syzstr->sev = (unsigned long **) omAlloc0((maxlength+1)*sizeof(unsigned long *));
2634
2635 assume( syzstr->length == maxlength );
2636
2637 syzstr->bucket = kBucketCreate(currRing);
2638 int len0=id_RankFreeModule(temp,currRing)+1;
2639
2640 nextPairs = syChosePairs(syzstr,&index,&howmuch,&actdeg);
2641 //if (TEST_OPT_PROT) Print("(%d,%d)",howmuch,index);
2642/*--- computes the resolution ----------------------*/
2643 while (nextPairs!=NULL)
2644 {
2645 if (TEST_OPT_PROT) Print("%d",actdeg);
2646 if (TEST_OPT_PROT) Print("(m%d)",index);
2647 if (index==0)
2648 i = syInitSyzMod(syzstr,index,len0);
2649 else
2650 i = syInitSyzMod(syzstr,index);
2651 currcomponents = syzstr->truecomponents[si_max(index-1,0)];
2654 IDELEMS(syzstr->res[si_max(index-1,0)]), currRing);
2655 j = syInitSyzMod(syzstr,index+1);
2656 if (index>0)
2657 {
2658 syRedNextPairs(nextPairs,syzstr,howmuch,index);
2659 syCompactifyPairSet(syzstr->resPairs[index],(*syzstr->Tl)[index],0);
2660 }
2661 else
2662 syRedGenerOfCurrDeg(syzstr,actdeg,index+1);
2663/*--- creates new pairs -----------------------------*/
2664 syCreateNewPairs(syzstr,index,i);
2665 if (index<(maxlength-1))
2666 {
2667 syCreateNewPairs(syzstr,index+1,j);
2668 }
2669 index++;
2670 nextPairs = syChosePairs(syzstr,&index,&howmuch,&actdeg);
2671 //if (TEST_OPT_PROT) Print("(%d,%d)",howmuch,index);
2672 }
2673 if (temp!=NULL) idDelete(&temp);
2674 kBucketDestroy(&(syzstr->bucket));
2675 if (origR != syzstr->syRing)
2676 rChangeCurrRing(origR);
2677 if (TEST_OPT_PROT) PrintLn();
2678 return syzstr;
2679}
static int si_max(const int a, const int b)
Definition: auxiliary.h:124
#define Print
Definition: emacs.cc:80
BOOLEAN idTestHomModule(ideal m, ideal Q, intvec *w)
Definition: ideals.cc:2069
#define idTest(id)
Definition: ideals.h:47
void kBucketDestroy(kBucket_pt *bucket_pt)
Definition: kbuckets.cc:216
kBucket_pt kBucketCreate(const ring bucket_ring)
Creation/Destruction of buckets.
Definition: kbuckets.cc:209
#define assume(x)
Definition: mod2.h:389
#define omAlloc0Bin(bin)
Definition: omAllocDecl.h:206
#define TEST_OPT_PROT
Definition: options.h:104
void rChangeCurrRing(ring r)
Definition: polys.cc:15
poly prCopyR(poly p, ring src_r, ring dest_r)
Definition: prCopy.cc:34
void PrintLn()
Definition: reporter.cc:310
ring rAssure_dp_S(const ring r)
Definition: ring.cc:4975
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size
EXTERN_VAR omBin char_ptr_bin
Definition: structs.h:77
VAR int * currcomponents
Definition: syz1.cc:33
SRes syInitRes(ideal arg, int *length, intvec *Tl, intvec *cw)
Definition: syz1.cc:293
static void syCreateNewPairs(syStrategy syzstr, int index, int newEl)
Definition: syz1.cc:1069
void syCompactifyPairSet(SSet sPairs, int sPlength, int first)
Definition: syz1.cc:104
static void syRedGenerOfCurrDeg(syStrategy syzstr, int deg, int index)
Definition: syz1.cc:915
int syInitSyzMod(syStrategy syzstr, int index, int init)
Definition: syz1.cc:1459
static void syRedNextPairs(SSet nextPairs, syStrategy syzstr, int howmuch, int index)
Definition: syz1.cc:768
SSet syChosePairs(syStrategy syzstr, int *index, int *howmuch, int *actdeg)
Definition: syz1.cc:1288
VAR long * currShiftedComponents
Definition: syz1.cc:34
ssyStrategy * syStrategy
Definition: syz.h:36
kBucket_pt bucket
Definition: syz.h:54

◆ syLaScala3()

syStrategy syLaScala3 ( ideal  arg,
int *  length 
)

Definition at line 2431 of file syz1.cc.

2432{
2433 int i,j,actdeg=32000,index=0;
2434 int howmuch;
2435 ideal temp;
2436 SSet nextPairs;
2437 syStrategy syzstr=(syStrategy)omAlloc0(sizeof(ssyStrategy));
2438 ring origR = currRing;
2439
2440 if ((idIs0(arg)) ||
2441 ((id_RankFreeModule(arg,currRing)>0) && (!idHomModule(arg,NULL,&(syzstr->cw)))))
2442 {
2444 syzstr->length = 1;
2445 syzstr->minres[0] = idInit(1,arg->rank);
2446 return syzstr;
2447 }
2448
2449 //crit = 0;
2450 //euler = -1;
2451 syzstr->length = *length = (currRing->N)+2;
2452
2453 // Creare dp,S ring and change to it
2454 syzstr->syRing = rAssure_dp_S(origR);
2455 assume(syzstr->syRing != origR); // why?
2456 rChangeCurrRing(syzstr->syRing);
2457
2458 // set initial ShiftedComps
2459 currcomponents = (int*)omAlloc0((arg->rank+1)*sizeof(int));
2460 currShiftedComponents = (long*)omAlloc0((arg->rank+1)*sizeof(long));
2461 for (i=0;i<=arg->rank;i++)
2462 {
2464 currcomponents[i] = i;
2465 }
2467/*--- initializes the data structures---------------*/
2468 syzstr->Tl = new intvec(*length);
2469 temp = idInit(IDELEMS(arg),arg->rank);
2470 for (i=0;i<IDELEMS(arg);i++)
2471 {
2472 temp->m[i] = prCopyR( arg->m[i], origR, syzstr->syRing);
2473 if (temp->m[i]!=NULL)
2474 {
2475 j = pTotaldegree(temp->m[i]);
2476 if (j<actdeg) actdeg = j;
2477 }
2478 }
2479 idTest(temp);
2480 idSkipZeroes(temp);
2481 idTest(temp);
2482 syzstr->resPairs = syInitRes(temp,length,syzstr->Tl,syzstr->cw);
2483 omFreeSize((ADDRESS)currcomponents,(arg->rank+1)*sizeof(int));
2484 omFreeSize((ADDRESS)currShiftedComponents,(arg->rank+1)*sizeof(long));
2485 syzstr->res = (resolvente)omAlloc0((*length+1)*sizeof(ideal));
2486 syzstr->orderedRes = (resolvente)omAlloc0((*length+1)*sizeof(ideal));
2487 syzstr->elemLength = (int**)omAlloc0((*length+1)*sizeof(int*));
2488 syzstr->truecomponents = (int**)omAlloc0((*length+1)*sizeof(int*));
2489 syzstr->ShiftedComponents = (long**)omAlloc0((*length+1)*sizeof(long*));
2490 syzstr->backcomponents = (int**)omAlloc0((*length+1)*sizeof(int*));
2491 syzstr->Howmuch = (int**)omAlloc0((*length+1)*sizeof(int*));
2492 syzstr->Firstelem = (int**)omAlloc0((*length+1)*sizeof(int*));
2493 syzstr->sev = (unsigned long **) omAlloc0((*length+1)*sizeof(unsigned long *));
2494 syzstr->bucket = kBucketCreate(currRing);
2495 int len0=id_RankFreeModule(temp,currRing)+1;
2496
2497 nextPairs = syChosePairs(syzstr,&index,&howmuch,&actdeg);
2498 //if (TEST_OPT_PROT) Print("(%d,%d)",howmuch,index);
2499/*--- computes the resolution ----------------------*/
2500 while (nextPairs!=NULL)
2501 {
2502 if (TEST_OPT_PROT) Print("%d",actdeg);
2503 if (TEST_OPT_PROT) Print("(m%d)",index);
2504 if (index==0)
2505 i = syInitSyzMod(syzstr,index,len0);
2506 else
2507 i = syInitSyzMod(syzstr,index);
2508 currcomponents = syzstr->truecomponents[si_max(index-1,0)];
2511 IDELEMS(syzstr->res[si_max(index-1,0)]), currRing);
2512 j = syInitSyzMod(syzstr,index+1);
2513 if (index>0)
2514 {
2515 syRedNextPairs(nextPairs,syzstr,howmuch,index);
2516 syCompactifyPairSet(syzstr->resPairs[index],(*syzstr->Tl)[index],0);
2517 }
2518 else
2519 syRedGenerOfCurrDeg(syzstr,actdeg,index+1);
2520/*--- creates new pairs -----------------------------*/
2521 syCreateNewPairs(syzstr,index,i);
2522 if (index<(*length)-1)
2523 {
2524 syCreateNewPairs(syzstr,index+1,j);
2525 }
2526 index++;
2527 nextPairs = syChosePairs(syzstr,&index,&howmuch,&actdeg);
2528 //if (TEST_OPT_PROT) Print("(%d,%d)",howmuch,index);
2529 }
2530 if (temp!=NULL) idDelete(&temp);
2531 kBucketDestroy(&(syzstr->bucket));
2532
2533 if (origR != syzstr->syRing)
2534 rChangeCurrRing(origR);
2535
2536 if (TEST_OPT_PROT) PrintLn();
2537
2538 assume(syzstr->minres==NULL); assume(syzstr->fullres ==NULL);
2539 assume(syzstr->resPairs!=NULL); assume(syzstr->hilb_coeffs==NULL);
2540 assume(syzstr->res!=NULL);
2541
2543 syzstr->minres = syReadOutMinimalRes(syzstr);
2544 else
2545 syzstr->fullres = syReorder(syzstr->res, syzstr->length, syzstr); // buggy? (betti...?)
2546
2547 return syzstr;
2548}
static BOOLEAN idHomModule(ideal m, ideal Q, intvec **w)
Definition: ideals.h:96
#define TEST_OPT_NO_SYZ_MINIM
Definition: options.h:125
static resolvente syReadOutMinimalRes(syStrategy syzstr, BOOLEAN computeStd=FALSE)
Definition: syz1.cc:2311

◆ syLengthInt()

static int syLengthInt ( int  i)
static

Definition at line 1918 of file syz1.cc.

1919{
1920 int j=0;
1921
1922 if (i==0) return 1;
1923 while (i!=0)
1924 {
1925 j++;
1926 i = i/10;
1927 }
1928 return j;
1929}

◆ syLinStrat()

static intvec * syLinStrat ( SSet  nextPairs,
syStrategy  syzstr,
int  howmuch,
int  index 
)
static

Definition at line 649 of file syz1.cc.

651{
652 int i=howmuch-1,i1=0,i2,i3,l,ll;
653 int ** Fin=syzstr->Firstelem;
654 int ** Hin=syzstr->Howmuch;
655 ideal o_r=syzstr->orderedRes[index+1];
656 intvec *result=new intvec(howmuch+1);
657 intvec *spl=new intvec(howmuch,1,-1);
658 BOOLEAN isDivisible;
659 SObject tso;
660
661 while (i>=0)
662 {
663 tso = nextPairs[i];
664 isDivisible = FALSE;
665 if (syzstr->res[index+1]!=NULL)
666 {
667 l = Fin[index][pGetComp(tso.lcm)]-1;
668 if (l>=0)
669 {
670 ll = l+Hin[index][pGetComp(tso.lcm)];
671 while ((l<ll) && (!isDivisible))
672 {
673 if (o_r->m[l]!=NULL)
674 {
675 isDivisible = isDivisible ||
676 pLmDivisibleByNoComp(o_r->m[l],tso.lcm);
677 }
678 l++;
679 }
680 }
681 }
682 if (isDivisible)
683 {
684 syDeletePair(&nextPairs[i]);
685 //crit++;
686 }
687 else
688 {
689 pTest(tso.p2);
690 pTest(tso.p1);
691 nextPairs[i].p =
692 ksOldCreateSpoly(tso.p2, tso.p1,NULL);
693 (*spl)[i] = pLength(nextPairs[i].p);
694 }
695 i--;
696 }
697 i3 = 0;
698 loop
699 {
700 i2 = -1;
701 for (i1=0;i1<howmuch;i1++)
702 {
703 if (i2==-1)
704 {
705 if ((*spl)[i1]!=-1)
706 {
707 i2 = i1;
708 }
709 }
710 else
711 {
712 if (((*spl)[i1]>=0) && ((*spl)[i1]<(*spl)[i2]))
713 {
714 i2 = i1;
715 }
716 }
717 }
718 if (i2>=0)
719 {
720 (*result)[i3] = i2+1;
721 (*spl)[i2] = -1;
722 i3++;
723 }
724 else
725 {
726 break;
727 }
728 }
729 delete spl;
730 return result;
731}
KINLINE poly ksOldCreateSpoly(poly p1, poly p2, poly spNoether, ring r)
Definition: kInline.h:1196
static int pLength(poly a)
Definition: p_polys.h:188
void syDeletePair(SObject *so)
Definition: syz1.cc:44

◆ syMinimize()

syStrategy syMinimize ( syStrategy  syzstr)

Definition at line 2392 of file syz1.cc.

2393{
2394 if (syzstr->minres==NULL)
2395 {
2396 if (syzstr->resolution!=NULL)
2397 {
2398 // need to clear syzstr->resolution, as we are
2399 // now displaying the minres instead of fullres
2400 delete syzstr->resolution;
2401 syzstr->resolution=NULL;
2402 }
2403 if (syzstr->resPairs!=NULL)
2404 {
2405 if (syzstr->hilb_coeffs==NULL)
2406 {
2407 // La Scala Resolution
2408 syzstr->minres = syReadOutMinimalRes(syzstr);
2409 }
2410 else
2411 { // HRES
2412 syzstr->minres = syReorder(syzstr->orderedRes,syzstr->length,syzstr);
2413 }
2414 }
2415 else if (syzstr->fullres!=NULL)
2416 {
2417 syMinimizeResolvente(syzstr->fullres,syzstr->length,1);
2418 syzstr->minres = syzstr->fullres;
2419 syzstr->fullres = NULL;
2420 }
2421 }
2422 (syzstr->references)++;
2423 return syzstr;
2424}
void syMinimizeResolvente(resolvente res, int length, int first)
Definition: syz.cc:355

◆ syMinimizeP1()

static poly syMinimizeP1 ( int  toMin,
syStrategy  syzstr,
intvec ordn,
int  index,
intvec toStrip 
)
static

Definition at line 2150 of file syz1.cc.

2152{
2153 int ii=0,i,tc,lp,ltS=-1;
2154 poly p,mp=NULL,pp;
2155 SSet sPairs=syzstr->resPairs[index];
2156 poly tempStripped=NULL;
2157
2158 pp = syStripOutCopy(syzstr->res[index+1]->m[toMin],toStrip);
2159 kBucketInit(syzstr->bucket,pp,-1);
2160 while ((ii<ordn->length()) && ((*ordn)[ii]!=-1) &&
2161 (sPairs[(*ordn)[ii]].syzind!=toMin))
2162 {
2163 ii++;
2164 }
2165 while (ii>=0)
2166 {
2167 i = (*ordn)[ii];
2168 if (sPairs[i].isNotMinimal!=NULL)
2169 {
2170 tempStripped =
2171 syStripOutCopy(syzstr->res[index+1]->m[sPairs[i].syzind],toStrip);
2172 tc = pGetComp(sPairs[i].isNotMinimal);
2173 int lu;
2174 pTakeOutComp(&tempStripped,tc,&p,&lu);
2175 kBucketTakeOutComp(syzstr->bucket,tc,&mp,&lp);
2176 mp = pDivideM(mp,p);
2177 while (mp!=NULL)
2178 {
2179 p = pNext(mp);
2180 pNext(mp) = NULL;
2181 ltS = -1;
2182 kBucket_Minus_m_Mult_p(syzstr->bucket,mp,tempStripped,&ltS);
2183 pDelete(&mp);
2184 mp = p;
2185 }
2186 pDelete(&mp);
2187 pDelete(&tempStripped);
2188 }
2189 ii--;
2190 }
2191 kBucketClear(syzstr->bucket,&pp,&lp);
2192 return pp;
2193}
CanonicalForm FACTORY_PUBLIC pp(const CanonicalForm &)
CanonicalForm pp ( const CanonicalForm & f )
Definition: cf_gcd.cc:676
void kBucketClear(kBucket_pt bucket, poly *p, int *length)
Definition: kbuckets.cc:521
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...
Definition: kbuckets.cc:722
void kBucketTakeOutComp(kBucket_pt bucket, long comp, poly *r_p, int *l)
Definition: kbuckets.cc:1032
void kBucketInit(kBucket_pt bucket, poly lm, int length)
Definition: kbuckets.cc:493
#define pNext(p)
Definition: monomials.h:36
#define pDivideM(a, b)
Definition: polys.h:294
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 ...
Definition: polys.h:338
static poly syStripOutCopy(poly p, intvec *toStrip)
Definition: syz1.cc:2065

◆ syOrder()

static BOOLEAN syOrder ( poly  p,
syStrategy  syzstr,
int  index,
int  realcomp 
)
static

Definition at line 461 of file syz1.cc.

463{
464 int i=IDELEMS(syzstr->res[index-1])+1,j=0,k,tc,orc,ie=realcomp-1;
465 int *trind1=syzstr->truecomponents[index-1];
466 int *trind=syzstr->truecomponents[index];
467 long *shind=syzstr->ShiftedComponents[index];
468 int *bc=syzstr->backcomponents[index];
469 int *F1=syzstr->Firstelem[index-1];
470 int *H1=syzstr->Howmuch[index-1];
471 polyset o_r=syzstr->orderedRes[index]->m;
472 BOOLEAN ret = FALSE;
473
474 // if != 0, then new element can go into same component
475 // i.e., we do not need to leave space in shifted components
476 long same_comp = 0;
477
478 if (p==NULL) return FALSE;
479 if (realcomp==0) realcomp=1;
480
481 if (index>1)
482 tc = trind1[pGetComp(p)]-1;
483 else
484 tc = pGetComp(p)-1;
485 loop //while ((j<ie) && (trind1[orc]<=tc+1))
486 {
487 if (j>=ie)
488 break;
489 else
490 {
491 orc = pGetComp(o_r[j]);
492 if (trind1[orc]>tc+1) break;
493 else if (trind1[orc] == tc+1)
494 {
495 same_comp = 1;
496 }
497 else
498 {
499 assume(same_comp == 0);
500 }
501 j += H1[orc];
502 }
503 }
504 if (j>ie)
505 {
506 WerrorS("orderedRes to small");
507 return FALSE;
508 }
509 ie++;
510 if (j == (ie -1))
511 {
512 // new element is the last in ordered module
513 if (same_comp == 0)
514 same_comp = SYZ_SHIFT_BASE;
515
516 // test whether we have enough space for new shifted component
517 if ((LONG_MAX - same_comp) <= shind[ie-1])
518 {
519 long new_space = syReorderShiftedComponents(shind, ie);
520 assume((LONG_MAX - same_comp) > shind[ie-1]);
521 ret = TRUE;
522 if (TEST_OPT_PROT) Print("(T%ld)", new_space);
523 }
524
525 // yes, then set new shifted component
526 assume(ie == 1 || shind[ie-1] > 0);
527 shind[ie] = shind[ie-1] + same_comp;
528 }
529 else
530 {
531 // new element must come in between
532 // i.e. at place j+1
533 long prev, next;
534
535 // test whether new component can get shifted value
536 prev = shind[j];
537 next = shind[j+1];
538 assume(next > prev);
539 if ((same_comp && prev + 2 >= next) || (!same_comp && next - prev < 4))
540 {
541 long new_space = syReorderShiftedComponents(shind, ie);
542 prev = shind[j];
543 next = shind[j+1];
544 assume((same_comp && prev + 2 < next) || (!same_comp && next - prev >= 4));
545 ret = TRUE;
546 if (TEST_OPT_PROT) Print("(B%ld)", new_space);
547 }
548
549 // make room for insertion of j+1 shifted component
550 for (k=ie; k > j+1; k--) shind[k] = shind[k-1];
551
552 if (same_comp)
553 {
554 // can simply add one
555 shind[j+1] = prev + 1;
556 assume(shind[j+1] + 1 < shind[j+2]);
557 }
558 else
559 {
560 // need to leave more breathing room - i.e. value goes in
561 // between
562 shind[j+1] = prev + ((next - prev) >> 1);
563 assume (shind[j] + 1 < shind[j+1] && shind[j+1] + 1 < shind[j+2]);
564 }
565 }
566
567 if (o_r[j]!=NULL)
568 {
569 for (k=ie-1;k>j;k--)
570 {
571 o_r[k] = o_r[k-1];
572 bc[k] = bc[k-1];
573 }
574 }
575 o_r[j] = p;
576 bc[j] = realcomp-1;
577 (H1[pGetComp(p)])++;
578 for (k=0;k<i;k++)
579 {
580 if (F1[k]>j)
581 (F1[k])++;
582 }
583 if (F1[pGetComp(p)]==0)
584 F1[pGetComp(p)]=j+1;
585 for (k=0;k<IDELEMS((syzstr->res)[index]);k++)
586 {
587 if (trind[k]>j)
588 trind[k] += 1;
589 }
590 for (k=IDELEMS((syzstr->res)[index])-1;k>realcomp;k--)
591 trind[k] = trind[k-1];
592 trind[realcomp] = j+1;
593 return ret;
594}
void WerrorS(const char *s)
Definition: feFopen.cc:24
ListNode * next
Definition: janet.h:31
long syReorderShiftedComponents(long *sc, int n)
Definition: syz1.cc:334
int F1(int a1, int &r1)
F1.

◆ syOrdPairs()

static intvec * syOrdPairs ( SSet  sPairs,
int  length 
)
static

Definition at line 2273 of file syz1.cc.

2274{
2275 intvec * result=new intvec(length,1,-1);
2276 int i,j=0,k=-1,l,ii;
2277
2278 loop
2279 {
2280 l = -1;
2281 for(i=0;i<length;i++)
2282 {
2283 if (sPairs[i].syzind>k)
2284 {
2285 if (l==-1)
2286 {
2287 l = sPairs[i].syzind;
2288 ii = i;
2289 }
2290 else
2291 {
2292 if (sPairs[i].syzind<l)
2293 {
2294 l = sPairs[i].syzind;
2295 ii = i;
2296 }
2297 }
2298 }
2299 }
2300 if (l==-1) break;
2301 (*result)[j] = ii;
2302 j++;
2303 k = l;
2304 }
2305 return result;
2306}

◆ syPrint()

void syPrint ( syStrategy  syzstr,
const char *  sn 
)

Definition at line 1934 of file syz1.cc.

1935{
1936 if ( (syzstr->resPairs==NULL) &&
1937 (syzstr->fullres==NULL) &&
1938 (syzstr->minres==NULL) &&
1939 (syzstr->resolution == NULL) )
1940 {
1941 PrintS("No resolution defined\n");
1942 return;
1943 }
1944
1945 intvec* resolution = syzstr->resolution;
1946
1947 if (resolution==NULL)
1948 {
1949 if (syzstr->resPairs!=NULL)
1950 {
1951 resolution = new intvec(syzstr->length+1);
1952 SRes rP = syzstr->resPairs;
1953// assume(idRankFreeModule(syzstr->res[1], (syzstr->syRing != NULL ? syzstr->syRing : currRing))==syzstr->res[1]->rank);
1954 (*resolution)[0] = syzstr->res[1]->rank;
1955 int k=0;
1956 while ((k<syzstr->length) && (rP[k]!=NULL))
1957 {
1958 int j = 0;
1959 while ((j<(*syzstr->Tl)[k]) &&
1960 ((rP[k][j].lcm!=NULL) || (rP[k][j].syz!=NULL)))
1961 {
1962 if (rP[k][j].isNotMinimal==NULL)
1963 ((*resolution)[k+1])++;
1964 j++;
1965 }
1966 k++;
1967 }
1968 }
1969 else
1970 {
1971 resolution = new intvec(syzstr->length+2);
1972 resolvente rr;
1973 if (syzstr->minres!=NULL)
1974 rr = syzstr->minres;
1975 else
1976 rr = syzstr->fullres;
1977 (*resolution)[0]
1978 = si_max(1,(int)id_RankFreeModule(rr[0],
1979 (syzstr->syRing != NULL ? syzstr->syRing : currRing)));
1980 int k=0;
1981 while ((k<syzstr->length) && (rr[k]!=NULL))
1982 {
1983 (*resolution)[k+1] = idElem(rr[k]);
1984 k++;
1985 }
1986 }
1987 }
1988
1989 int sl=strlen(sn);
1991 int k = 0;
1992 loop
1993 {
1994 if ((k>=resolution->length()) || ((*resolution)[k]==0))
1995 break;
1996 Print("%d",(*resolution)[k]);
1997 syPrintEmptySpaces1(sl+5);
1998 k++;
1999 }
2000 PrintLn();
2001 k = 0;
2002 loop
2003 {
2004 if ((k>=resolution->length()) || ((*resolution)[k]==0))
2005 break;
2006 PrintS(sn);
2007 if (((k+1)>=resolution->length()) || ((*resolution)[(k+1)]==0))
2008 break;
2009 PrintS(" <-- ");
2010 syPrintEmptySpaces((*resolution)[k]);
2011 k++;
2012 }
2013 PrintS("\n\n");
2014 k = 0;
2015 loop
2016 {
2017 if ((k>=resolution->length()) || ((*resolution)[k]==0))
2018 break;
2019 Print("%d",k);
2020 syPrintEmptySpaces1(sl+5+syLengthInt((*resolution)[k])-
2021 syLengthInt(k));
2022 k++;
2023 }
2024 PrintLn();
2025 if (syzstr->minres==NULL)
2026 {
2027 PrintS("resolution not minimized yet\n");
2028 }
2029
2030 if (syzstr->resolution == NULL) syzstr->resolution = resolution;
2031}
static int idElem(const ideal F)
number of non-zero polys in F
Definition: simpleideals.h:67
static int syLengthInt(int i)
Definition: syz1.cc:1918
static void syPrintEmptySpaces1(int i)
Definition: syz1.cc:1906
static void syPrintEmptySpaces(int i)
Definition: syz1.cc:1894

◆ syPrintEmptySpaces()

static void syPrintEmptySpaces ( int  i)
static

Definition at line 1894 of file syz1.cc.

1895{
1896 if (i!=0)
1897 {
1898 PrintS(" ");
1900 }
1901}

◆ syPrintEmptySpaces1()

static void syPrintEmptySpaces1 ( int  i)
static

Definition at line 1906 of file syz1.cc.

1907{
1908 if (i!=0)
1909 {
1910 PrintS(" ");
1912 }
1913}

◆ syReadOutMinimalRes()

static resolvente syReadOutMinimalRes ( syStrategy  syzstr,
BOOLEAN  computeStd = FALSE 
)
static

Definition at line 2311 of file syz1.cc.

2313{
2314 intvec * Strip, * ordn;
2315 resolvente tres=(resolvente)omAlloc0((syzstr->length+1)*sizeof(ideal));
2316 ring origR = currRing;
2317
2318//Print("Hier ");
2319 if (computeStd)
2320 {
2321 tres[0] = syzstr->res[1];
2322 syzstr->res[1] = idInit(IDELEMS(tres[0]),tres[0]->rank);
2323 return tres;
2324 }
2325 int i,l,index,i1;
2326 SSet sPairs;
2327
2328 assume(syzstr->syRing != NULL);
2329 rChangeCurrRing(syzstr->syRing);
2330//Print("laeufts ");
2331 syzstr->bucket = kBucketCreate(syzstr->syRing);
2332 for (index=syzstr->length-1;index>0;index--)
2333 {
2334 if (syzstr->resPairs[index]!=NULL)
2335 {
2336//Print("ideal %d: \n",index);
2340 IDELEMS(syzstr->res[index]), currRing);
2341 sPairs = syzstr->resPairs[index];
2342 Strip = syToStrip(syzstr,index);
2343 tres[index+1] = idInit(IDELEMS(syzstr->res[index+1]),syzstr->res[index+1]->rank);
2344 i1 = (*syzstr->Tl)[index];
2345//Print("i1= %d\n",i1);
2346 ordn = syOrdPairs(sPairs,i1);
2347 for (i=0;i<i1;i++)
2348 {
2349 if ((sPairs[i].isNotMinimal==NULL) && (sPairs[i].lcm!=NULL))
2350 {
2351 l = sPairs[i].syzind;
2352//Print("Minimiere Poly %d: ",l);pWrite(syzstr->res[index+1]->m[l]);
2353 tres[index+1]->m[l] =
2354 syMinimizeP1(l,syzstr,ordn,index,Strip);
2355 }
2356 }
2357 delete Strip;
2358 delete ordn;
2359 Strip = NULL;
2360 }
2361 }
2362 currcomponents = syzstr->truecomponents[0];
2365 IDELEMS(syzstr->res[0]), currRing);
2366 tres[1] = idInit(IDELEMS(syzstr->res[1]),syzstr->res[1]->rank);
2367 sPairs = syzstr->resPairs[0];
2368 for (i=(*syzstr->Tl)[0]-1;i>=0;i--)
2369 {
2370 if (sPairs[i].syzind>=0)
2371 {
2372 tres[1]->m[sPairs[i].syzind] = pCopy(syzstr->res[1]->m[sPairs[i].syzind]);
2373 }
2374 }
2375/*--- changes to the original ring------------------*/
2376 kBucketDestroy(&syzstr->bucket);
2377 if (syzstr->syRing != NULL)
2378 {
2379 rChangeCurrRing(origR);
2380 // Thomas: now make sure that all data which you need is pFetchCopied
2381 // maybe incorporate it into syReorder ??
2382 }
2383 tres = syReorder(tres,syzstr->length,syzstr,FALSE,syzstr->res);
2384 syKillEmptyEntres(tres,syzstr->length);
2385 idSkipZeroes(tres[0]);
2386 return tres;
2387}
#define pCopy(p)
return a copy of the poly
Definition: polys.h:185
static intvec * syOrdPairs(SSet sPairs, int length)
Definition: syz1.cc:2273
static poly syMinimizeP1(int toMin, syStrategy syzstr, intvec *ordn, int index, intvec *toStrip)
Definition: syz1.cc:2150
static intvec * syToStrip(syStrategy syzstr, int index)
Definition: syz1.cc:2251

◆ syRedGenerOfCurrDeg()

static void syRedGenerOfCurrDeg ( syStrategy  syzstr,
int  deg,
int  index 
)
static

Definition at line 915 of file syz1.cc.

916{
917 ideal res=syzstr->res[index];
918 int i=0,j,k=IDELEMS(res);
919 SSet sPairs=syzstr->resPairs[index-1];
920
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)))
924 i++;
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)))
928 {
929 if ((sPairs)[i].syz!=NULL)
930 {
931 j = k-1;
932 while ((j>=0) && (res->m[j]!=NULL) &&
933 ((sPairs)[i].syz!=NULL))
934 {
935 if (pLmDivisibleBy(res->m[j],(sPairs)[i].syz))
936 {
937 (sPairs)[i].syz =
938 ksOldSpolyRed(res->m[j],(sPairs)[i].syz);
939 //sySPolyRed((sPairs)[i].syz,res->m[j]);
940 j = k-1;
941 }
942 else
943 {
944 j--;
945 }
946 }
947 if ((sPairs)[i].syz != NULL)
948 {
949 if (k==IDELEMS(res))
950 {
951 syEnlargeFields(syzstr,index);
952 res=syzstr->res[index];
953 }
954 if (TEST_OPT_DEBUG)
955 {
956 if ((sPairs)[i].isNotMinimal==NULL)
957 {
958 PrintLn();
959 PrintS("minimal generator: ");pWrite((syzstr->resPairs[index-1])[i].syz);
960 PrintS("comes from: ");pWrite((syzstr->resPairs[index-1])[i].p1);
961 PrintS("and: ");pWrite((syzstr->resPairs[index-1])[i].p2);
962 }
963 }
964 //res->m[k] = (sPairs)[i].syz;
965 res->m[k] = syRedtail((sPairs)[i].syz,syzstr,index);
966 (sPairs)[i].syzind = k;
967 syzstr->elemLength[index][k] = pLength((sPairs)[i].syz);
968 pNorm(res->m[k]);
969 // (sPairs)[i].syz = NULL;
970 k++;
971 if (syOrder(res->m[k-1],syzstr,index,k))
973 //euler++;
974 }
975 else
976 (sPairs)[i].syzind = -1;
977 }
978 i++;
979 }
980}
KINLINE poly ksOldSpolyRed(poly p1, poly p2, poly spNoether)
Definition: kInline.h:1176
#define TEST_OPT_DEBUG
Definition: options.h:109
void pNorm(poly p)
Definition: polys.h:362
#define pLmDivisibleBy(a, b)
like pDivisibleBy, except that it is assumed that a!=NULL, b!=NULL
Definition: polys.h:140
void pWrite(poly p)
Definition: polys.h:308
poly syRedtail(poly p, syStrategy syzstr, int index)
Definition: syz1.cc:226
void syEnlargeFields(syStrategy syzstr, int index)
Definition: syz1.cc:734
static BOOLEAN syOrder(poly p, syStrategy syzstr, int index, int realcomp)
Definition: syz1.cc:461
void syResetShiftedComponents(syStrategy syzstr, int index, int hilb)
Definition: syz1.cc:409

◆ syRedNextPairs()

static void syRedNextPairs ( SSet  nextPairs,
syStrategy  syzstr,
int  howmuch,
int  index 
)
static

Definition at line 768 of file syz1.cc.

770{
771 int i,j,k=IDELEMS(syzstr->res[index]);
772 int ks=IDELEMS(syzstr->res[index+1]);
773 int * Fin=syzstr->Firstelem[index-1];
774 int * Hin=syzstr->Howmuch[index-1];
775 int * bin=syzstr->backcomponents[index];
776 int * elL=syzstr->elemLength[index];
777 number coefgcd;
778 polyset redset=syzstr->orderedRes[index]->m;
779 poly p=NULL,q;
780 intvec *spl1;
781 SObject tso;
782 long * ShiftedComponents = syzstr->ShiftedComponents[index];
783 int* Components = syzstr->truecomponents[index];
784 assume(Components != NULL && ShiftedComponents != NULL);
785 BOOLEAN need_reset;
786
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);
791 i=0;
792 while ((*spl1)[i]>0)
793 {
794 need_reset = FALSE;
795 tso = nextPairs[(*spl1)[i]-1];
796 if ((tso.p1!=NULL) && (tso.p2!=NULL))
797 {
798 nNormalize(pGetCoeff(tso.p1));
799 nNormalize(pGetCoeff(tso.p2));
800 coefgcd =
801 n_SubringGcd(pGetCoeff(tso.p1),pGetCoeff(tso.p2),currRing->cf);
802 tso.syz = pHead(tso.lcm);
803 p = tso.syz;
804 pSetCoeff(p,nDiv(pGetCoeff(tso.p1),coefgcd));
806 pSetComp(p,tso.ind2+1);
807 p_Setm_Syz(p, currRing, Components, ShiftedComponents); // actueller index
808 pNext(p) = pHead(tso.lcm);
809 pIter(p);
810 pSetComp(p,tso.ind1+1);
811 p_Setm_Syz(p, currRing, Components, ShiftedComponents); // actueller index
812 pSetCoeff(p,nDiv(pGetCoeff(tso.p2),coefgcd));
813 nDelete(&coefgcd);
814 if (tso.p != NULL)
815 {
816 kBucketInit(syzstr->bucket,tso.p,-1);
817 q = kBucketGetLm(syzstr->bucket);
818 j = Fin[pGetComp(q)]-1;
819 int pos = j+Hin[pGetComp(q)];
820 loop
821 {
822 if (j<0) break;
823 if (pLmDivisibleByNoComp(redset[j],q))
824 {
825 pNext(p) = pHead(q);
826 pIter(p);
827 pSetComp(p,bin[j]+1);
828 p_Setm_Syz(p, currRing, Components, ShiftedComponents); // actueller index
829//if (pLength(redset[j])!=syzstr->elemLength[index][bin[j]])
830//Print("Halt");
831//if (pLength(redset[j])!=syzstr->elemLength[index][bin[j]])
832//Print("Halt");
834 number up = kBucketPolyRed(syzstr->bucket,redset[j],elL[bin[j]],
835 NULL);
836 // Thomas: Check whether you need number here
837 nDelete(&up);
838 q = kBucketGetLm(syzstr->bucket);
839 if (q==NULL) break;
840 j = Fin[pGetComp(q)]-1;
841 pos = j+Hin[pGetComp(q)];
842 }
843 else
844 {
845 j++;
846 if (j==pos) break;
847 }
848 }
849 int lb;
850 kBucketClear(syzstr->bucket,&tso.p,&lb);
851 }
852 if (tso.p != NULL)
853 {
854 if (TEST_OPT_PROT) PrintS("g");
855 if (k==IDELEMS((syzstr->res)[index]))
856 {
857 syEnlargeFields(syzstr,index);
858 bin=syzstr->backcomponents[index];
859 elL=syzstr->elemLength[index];
860 redset=syzstr->orderedRes[index]->m;
861 Components = syzstr->truecomponents[index];
862 ShiftedComponents = syzstr->ShiftedComponents[index];
863 }
864 pNext(p) = pHead(tso.p);
865 pIter(p);
866
867 assume(p!= NULL);
868 k++;
869 syzstr->res[index]->m[k-1] = tso.p;
870 syzstr->elemLength[index][k-1] = pLength(tso.p);
871 pNorm(syzstr->res[index]->m[k-1]);
872 need_reset = syOrder(syzstr->res[index]->m[k-1],syzstr,index,k);
873 pSetComp(p,k); // actueller index
874 p_Setm_Syz(p, currRing, Components, ShiftedComponents);
876
877 tso.isNotMinimal = p;
878 tso.p = NULL;
879 }
880 else
881 {
882 if (TEST_OPT_PROT) PrintS(".");
883 //if (index % 2==0)
884 //euler++;
885 //else
886 //euler--;
887 }
888 if (ks==IDELEMS(syzstr->res[index+1]))
889 {
890 syEnlargeFields(syzstr,index+1);
891 }
892 syzstr->res[index+1]->m[ks] = tso.syz;
893 syzstr->elemLength[index+1][ks] = pLength(tso.syz);
894 pNorm(syzstr->res[index+1]->m[ks]);
895 tso.syz =NULL;
896 tso.syzind = ks;
897 if (need_reset)
899 if (syOrder(syzstr->res[index+1]->m[ks],syzstr,index+1,ks+1))
901 ks++;
902 p = NULL;
903 nextPairs[(*spl1)[i]-1] = tso;
904 }
905 i++;
906 }
907 delete spl1;
908}
static FORCE_INLINE number n_SubringGcd(number a, number b, const coeffs r)
Definition: coeffs.h:663
number kBucketPolyRed(kBucket_pt bucket, poly p1, int l1, poly spNoether)
Definition: kbuckets.cc:1071
const poly kBucketGetLm(kBucket_pt bucket)
Definition: kbuckets.cc:506
poly p
Definition: kbuckets.h:186
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
Definition: monomials.h:44
#define nDiv(a, b)
Definition: numbers.h:32
#define nDelete(n)
Definition: numbers.h:16
#define nInpNeg(n)
Definition: numbers.h:21
#define nNormalize(n)
Definition: numbers.h:30
#define pHead(p)
returns newly allocated copy of Lm(p), coef is copied, next=NULL, p might be NULL
Definition: polys.h:67
#define pSetCoeff(p, n)
deletes old coeff before setting the new one
Definition: polys.h:31
static intvec * syLinStrat(SSet nextPairs, syStrategy syzstr, int howmuch, int index)
Definition: syz1.cc:649

◆ syRedtail()

poly syRedtail ( poly  p,
syStrategy  syzstr,
int  index 
)

Definition at line 226 of file syz1.cc.

227{
228 poly h, hn;
229 int j,pos;
230 ideal redWith=syzstr->orderedRes[index];
231
232 h = p;
233 hn = pNext(h);
234 while(hn != NULL)
235 {
236 j = syzstr->Firstelem[index-1][pGetComp(hn)]-1;
237 if (j>=0)
238 {
239 pos = j+syzstr->Howmuch[index-1][pGetComp(hn)];
240 while (j < pos)
241 {
242 if (pLmDivisibleByNoComp(redWith->m[j], hn))
243 {
244 //hn = sySPolyRed(hn,redWith->m[j]);
245 hn = ksOldSpolyRed(redWith->m[j],hn);
246 if (hn == NULL)
247 {
248 pNext(h) = NULL;
249 return p;
250 }
251 j = syzstr->Firstelem[index-1][pGetComp(hn)]-1;
252 pos = j+syzstr->Howmuch[index-1][pGetComp(hn)];
253 }
254 else
255 {
256 j++;
257 }
258 }
259 }
260 h = pNext(h) = hn;
261 hn = pNext(h);
262 }
263 return p;
264}
STATIC_VAR Poly * h
Definition: janet.cc:971

◆ syReorder()

resolvente syReorder ( resolvente  res,
int  length,
syStrategy  syzstr,
BOOLEAN  toCopy,
resolvente  totake 
)

Definition at line 1641 of file syz1.cc.

1643{
1644 int i,j,l;
1645 poly p,q,tq;
1646 polyset ri1;
1647 resolvente fullres;
1648 ring origR=syzstr->syRing;
1649 fullres = (resolvente)omAlloc0((length+1)*sizeof(ideal));
1650 if (totake==NULL)
1651 totake = res;
1652 for (i=length-1;i>0;i--)
1653 {
1654 if (res[i]!=NULL)
1655 {
1656 if (i>1)
1657 {
1658 j = IDELEMS(res[i-1]);
1659 while ((j>0) && (res[i-1]->m[j-1]==NULL)) j--;
1660 fullres[i-1] = idInit(IDELEMS(res[i]),j);
1661 ri1 = totake[i-1]->m;
1662 for (j=IDELEMS(res[i])-1;j>=0;j--)
1663 {
1664 p = res[i]->m[j];
1665 q = NULL;
1666 while (p!=NULL)
1667 {
1668 if (toCopy)
1669 {
1670 if (origR!=NULL)
1671 tq = prHeadR(p,origR, currRing);
1672 else
1673 tq = pHead(p);
1674 pIter(p);
1675 }
1676 else
1677 {
1678 res[i]->m[j] = NULL;
1679 if (origR!=NULL)
1680 {
1681 poly pp=p;
1682 pIter(p);
1683 pNext(pp)=NULL;
1684 tq = prMoveR(pp, origR, currRing);
1685 }
1686 else
1687 {
1688 tq = p;
1689 pIter(p);
1690 pNext(tq) = NULL;
1691 }
1692 }
1693// pWrite(tq);
1694 pTest(tq);
1695 for (l=(currRing->N);l>0;l--)
1696 {
1697 if (origR!=NULL)
1698 pSubExp(tq,l, p_GetExp(ri1[pGetComp(tq)-1],l,origR));
1699 else
1700 pSubExp(tq,l, pGetExp(ri1[pGetComp(tq)-1],l));
1701 }
1702 pSetm(tq);
1703 pTest(tq);
1704 q = pAdd(q,tq);
1705 pTest(q);
1706 }
1707 fullres[i-1]->m[j] = q;
1708 }
1709 }
1710 else
1711 {
1712 if (origR!=NULL)
1713 {
1714 fullres[i-1] = idInit(IDELEMS(res[i]),res[i]->rank);
1715 for (j=IDELEMS(res[i])-1;j>=0;j--)
1716 {
1717 if (toCopy)
1718 fullres[i-1]->m[j] = prCopyR(res[i]->m[j], origR, currRing);
1719 else
1720 {
1721 fullres[i-1]->m[j] = prMoveR(res[i]->m[j], origR, currRing);
1722 res[i]->m[j] = NULL;
1723 }
1724 }
1725 }
1726 else
1727 {
1728 if (toCopy)
1729 fullres[i-1] = idCopy(res[i]);
1730 else
1731 {
1732 fullres[i-1] = res[i];
1733 res[i] = NULL;
1734 }
1735 }
1736 for (j=IDELEMS(fullres[i-1])-1;j>=0;j--)
1737 fullres[i-1]->m[j] = pSortCompCorrect(fullres[i-1]->m[j]);
1738 }
1739 if (!toCopy)
1740 {
1741 if (res[i]!=NULL) idDelete(&res[i]);
1742 }
1743 }
1744 }
1745 if (!toCopy)
1746 omFreeSize((ADDRESS)res,(length+1)*sizeof(ideal));
1747 //syzstr->length = length;
1748 return fullres;
1749}
int m
Definition: cfEzgcd.cc:128
ideal idCopy(ideal A)
Definition: ideals.h:60
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent @Note: the integer VarOffset encodes:
Definition: p_polys.h:467
#define pAdd(p, q)
Definition: polys.h:203
#define pGetExp(p, i)
Exponent.
Definition: polys.h:41
#define pSubExp(p, i, v)
Definition: polys.h:46
#define pSortCompCorrect(p)
Assume: If considered only as poly in any component of p (say, monomials of other components of p are...
Definition: polys.h:227
poly prMoveR(poly &p, ring src_r, ring dest_r)
Definition: prCopy.cc:90
poly prHeadR(poly p, ring src_r, ring dest_r, prCopyProc_t prproc)
Definition: prCopy.cc:126

◆ syReorderShiftedComponents()

long syReorderShiftedComponents ( long *  sc,
int  n 
)

Definition at line 334 of file syz1.cc.

335{
336 long holes = 0;
337 int i;
338 long new_comps = 0, new_space, max;
339
340 // count number of holes
341 for (i=1; i<n; i++)
342 {
343 if (sc[i-1] + 1 < sc[i]) holes++;
344 }
345
346 if (LONG_MAX - SYZ_SHIFT_BASE <= sc[n-1])
347 {
348 // need new components
349 new_comps = (((long) 1) << SYZ_SHIFT_MAX_NEW_COMP_ESTIMATE) - 1;
350 max = LONG_MAX;
351 }
352 else
353 {
354 max = sc[n-1] + SYZ_SHIFT_BASE;
355 }
356
357 // no we arrange things such that
358 // (n - holes) + holes*new_space + new_comps*SYZ_SHIFT_BASE= LONG_MAX
359 new_space = (max - n + holes - new_comps*SYZ_SHIFT_BASE) / holes;
360
361 assume(new_space < SYZ_SHIFT_BASE && new_space >= 4);
362
363 long* tc = ( long*) omAlloc(n*sizeof(long));
364 tc[0] = sc[0];
365 // rearrange things
366 for (i=1; i<n; i++)
367 {
368 if (sc[i-1] + 1 < sc[i])
369 {
370 tc[i] = tc[i-1] + new_space;
371 }
372 else
373 {
374 tc[i] = tc[i-1] + 1;
375 }
376 assume(tc[i] > tc[i-1]);
377 }
378
379 assume(LONG_MAX - SYZ_SHIFT_BASE > tc[n-1]);
380#ifndef SING_NDEBUG
381 for (i=1; i<n; i++)
382 {
383 assume(tc[i] >= 0);
384 assume(tc[i-1] + 1 <= tc[i]);
385 }
386#endif
387
388 memcpy(sc, tc, n*sizeof(long));
389 omFreeSize(tc, n*sizeof(long));
390 return new_space;
391}
static int max(int a, int b)
Definition: fast_mult.cc:264
#define omAlloc(size)
Definition: omAllocDecl.h:210
#define SYZ_SHIFT_MAX_NEW_COMP_ESTIMATE
Definition: syz.h:15

◆ syResetShiftedComponents()

void syResetShiftedComponents ( syStrategy  syzstr,
int  index,
int  hilb 
)

Definition at line 409 of file syz1.cc.

410{
411 assume(index > 0);
412 int i;
413 if (syzstr->res[index] != NULL)
414 {
415 long * prev_s;
416 int* prev_c;
417 int p_length;
418 rGetSComps(&prev_c, &prev_s, &p_length, currRing);
423 IDELEMS(syzstr->res[index-1]), currRing);
424 if (hilb==0)
425 {
426 ideal id = syzstr->res[index];
427 for (i=0; i<IDELEMS(id); i++)
428 {
429 pResetSetm(id->m[i]);
430 }
431 }
432 else if (hilb==1)
433 {
434 assume (index>1);
435 assume (syzstr->resPairs[index-1]!=NULL);
436 SSet Pairs=syzstr->resPairs[index-1];
437 SSet Pairs1=syzstr->resPairs[index];
438 int till=(*syzstr->Tl)[index-1];
439 for (i=0;i<till;i++)
440 {
441 if (Pairs[i].syz!=NULL)
442 pResetSetm(Pairs[i].syz);
443 }
444 till=(*syzstr->Tl)[index];
445 for (i=0;i<till;i++)
446 {
447 if (Pairs1[i].p!=NULL)
448 pResetSetm(Pairs1[i].p);
449 }
450 }
451 currcomponents = prev_c;
452 currShiftedComponents = prev_s;
453 rChangeSComps(prev_c, prev_s, p_length, currRing);
454 }
455}
void rGetSComps(int **currComponents, long **currShiftedComponents, int *length, ring r)
Definition: ring.cc:4414
static void pResetSetm(poly p)
Definition: syz1.cc:394

◆ sySize()

int sySize ( syStrategy  syzstr)

Definition at line 1829 of file syz1.cc.

1830{
1831 resolvente r=syzstr->res;
1832 if (r==NULL)
1833 r = syzstr->fullres;
1834 if (r==NULL)
1835 r = syzstr->minres;
1836 if (r==NULL)
1837 {
1838 WerrorS("No resolution found");
1839 return 0;
1840 }
1841 int i=syzstr->length;
1842 while ((i>0) && (r[i-1]==NULL)) i--;
1843 return i;
1844}

◆ syStripOutCopy()

static poly syStripOutCopy ( poly  p,
intvec toStrip 
)
static

Definition at line 2065 of file syz1.cc.

2066{
2067 if (toStrip==NULL) return pCopy(p);
2068 poly result=NULL,pp;
2069
2070 while (p!=NULL)
2071 {
2072 if ((*toStrip)[pGetComp(p)]==0)
2073 {
2074 if (result==NULL)
2075 {
2076 result = pp = pHead(p);
2077 }
2078 else
2079 {
2080 pNext(pp) = pHead(p);
2081 pIter(pp);
2082 }
2083 }
2084 pIter(p);
2085 }
2086 return result;
2087}

◆ syToStrip()

static intvec * syToStrip ( syStrategy  syzstr,
int  index 
)
static

Definition at line 2251 of file syz1.cc.

2252{
2253 intvec * result=NULL;
2254
2255 if ((syzstr->resPairs[index-1]!=NULL) && (!idIs0(syzstr->res[index])))
2256 {
2257 result=new intvec(IDELEMS(syzstr->res[index])+1);
2258 for (int i=(*syzstr->Tl)[index-1]-1;i>=0;i--)
2259 {
2260 if (syzstr->resPairs[index-1][i].isNotMinimal!=NULL)
2261 {
2262 (*result)[syzstr->resPairs[index-1][i].syzind+1] = 1;
2263 }
2264 }
2265 }
2266 return result;
2267}

Variable Documentation

◆ currcomponents

VAR int* currcomponents =NULL

Definition at line 33 of file syz1.cc.

◆ currShiftedComponents

VAR long* currShiftedComponents =NULL

Definition at line 34 of file syz1.cc.