walkMain.cc
Go to the documentation of this file.
1 /****************************************
2 * Computer Algebra System SINGULAR *
3 ****************************************/
4 /*
5  * ABSTRACT: fractal walk stuff
6  *
7 */
8 #include <kernel/mod2.h>
9 
10 #include <misc/options.h>
11 #include <misc/intvec.h>
12 #include <misc/int64vec.h>
13 
14 #include <polys/prCopy.h>
15 #include <polys/matpol.h>
16 #include <polys/monomials/ring.h>
17 
18 #include <kernel/polys.h>
19 #include <kernel/ideals.h>
22 #include <kernel/GBEngine/kstd1.h>
23 
24 #include <string.h>
25 
26 ///////////////////////////////////////////////////////////////////
27 //Groebner Walk and Fractal Walk
28 ///////////////////////////////////////////////////////////////////
29 //v1.3 2004-11-15
30 ///////////////////////////////////////////////////////////////////
31 //implemented by Henrik Strohmayer
32 ///////////////////////////////////////////////////////////////////
33 //in C++:
34 ///////////////////////////////////////////////////////////////////
35 
36 
37 int overflow_error; //global variable
38 
39 /*
40 overflow_error table
41  1: Miv64DotProduct mult
42  2: Miv64DotProduct add
43  3: gett64 zaehler mult
44  4: gett64 zaehler add
45  5: gett64 nenner mult
46  6: gett64 nenner add
47  7: nextw64 mult a
48  8: nextw64 mult b
49  9: nextw64 add
50 10: getinveps64 mult
51 11: getinveps64 add
52 12: getTaun64 mult
53 13: getTaun64 add
54 */
55 
56 ///////////////////////////////////////////////////////////////////
57 //fistWalkStep64
58 ///////////////////////////////////////////////////////////////////
59 //Description: adapts currRing for the algorithm and moves G into
60 //it, calculating the appropriate GB if currw not is inside of
61 //the current groebner cone
62 ///////////////////////////////////////////////////////////////////
63 //Assumes: that the option redSB is turned off
64 ///////////////////////////////////////////////////////////////////
65 //Uses: init64, rCopy0AndAddA, rComplete, rChangeCurrRing, matIdLift,
66 //mpMult, idInterRed, idStd, idCopy, idrMoveR,currwOnBorder64
67 ///////////////////////////////////////////////////////////////////
68 
69 WalkState firstWalkStep64(ideal & G,int64vec* currw64, ring destRing){
70  WalkState state=WalkOk;
71  /* OLDRING **************************************************** */
72  ideal nextG;
73 
74  if (currwOnBorder64(G,currw64))
75  {
76  ideal Gw=init64(G,currw64);
77  ring oldRing=currRing;
78  /* NEWRING **************************************************** */
79  ring rnew=rCopy0AndAddA(destRing,currw64);
80  rComplete(rnew);
81  rChangeCurrRing(rnew);
82 
83  ideal newGw=idrMoveR(Gw, oldRing, rnew);
84 
85 
86  //HIER GEANDERT
87  matrix L=mpNew(1,1);
88  idLiftStd(newGw,&L);
89 
90 // //turn off bucket representation of polynomials and on redSB
91 // optionState=test;
92 // //test|=Sy_bit(OPT_NOT_BUCKETS);
93 // test|=Sy_bit(OPT_REDSB);
94 
95 // ideal newStdGw=idStd(newGw);
96 
97 // //turn on bucket representation of polynomials and off redSB
98 // test=optionState;
99 
100 // matrix L=matIdLift(newGw,newStdGw);
101 // idDelete(&newStdGw);
102 
103  idDelete(&newGw);
104 
105  nextG=idrMoveR(G,oldRing, rnew); idTest(nextG);
106 
107  matrix nextGmat=(matrix)nextG;
108 
109  matrix resMat=mp_Mult(nextGmat,L,rnew);
110  idDelete((ideal *)&nextGmat);
111  idDelete((ideal *)&L);
112 
113  nextG=(ideal)resMat;
114 
115  BITSET save1,save2;
116  SI_SAVE_OPT(save1,save2);
118  nextG = idInterRed(nextG);
119  SI_RESTORE_OPT(save1,save2);
120  }
121  else
122  {
123  ring oldRing=currRing;
124  ring rnew=rCopy0AndAddA(destRing,currw64);
125  rComplete(rnew);
126  rChangeCurrRing(rnew);
127  nextG=idrMoveR(G,oldRing, rnew);
128  }
129 
130  G=nextG;
131  return(state);
132 }
133 
134 ///////////////////////////////////////////////////////////////////
135 
136 
137 ///////////////////////////////////////////////////////////////////
138 //walkStep64
139 ///////////////////////////////////////////////////////////////////
140 //Description: one step in the groebner walk
141 ///////////////////////////////////////////////////////////////////
142 //Assumes: that the option redSB is turned off
143 ///////////////////////////////////////////////////////////////////
144 //Uses: init, rCopyAndChangeA, matIdLift, mpMult,
145 //idInterRed, mStd, idCopy, idrMoveR
146 ///////////////////////////////////////////////////////////////////
147 
148 WalkState walkStep64(ideal & G,int64vec* currw64, int step)
149 {
150  WalkState state=WalkOk;
151 
152 /* OLDRING ****************************************************** */
153  ideal Gw=init64(G,currw64);
154 
155  ring oldRing=currRing;
156 
157 /* NEWRING ****************************************************** */
158  rCopyAndChangeA(currw64);
159 
160  ideal newGw=idrMoveR(Gw, oldRing,currRing);
161 
162  //HIER GEANDERT
163  matrix L=mpNew(1,1);
164  ideal newStdGw=idLiftStd(newGw,&L);
165 
166 //what it looked like before idStd and idLift were replaced
167 //by idLiftStd
168 // optionState=test;
169 // test|=Sy_bit(OPT_REDSB);
170 // test|=Sy_bit(OPT_NOT_BUCKETS);
171 
172 // //PrintS(" new initial forms:\n");
173 // for (int ii=0; ii <IDELEMS(newGw); ii++) pCleardenom(newGw->m[ii]);
174 // //idShow(newGw);
175 // ideal newStdGw=idStd(newGw);
176 // PrintS(" std for initial forms done\n");
177 
178 // test=optionState;
179 
180 // matrix L=matIdLift(newGw,newStdGw);
181 
182 // idDelete(&newStdGw);
183 
184  idDelete(&newGw);
185  //PrintS(" lift for initial forms done\n");
186 
187  ideal nextG=idrMoveR(G,oldRing,currRing);
188  rDelete(oldRing);
189 
190  matrix nextGmat=(matrix)nextG;
191 
192  matrix resMat=mp_Mult(nextGmat,L,currRing);
193  idDelete((ideal *)&nextGmat);
194  idDelete((ideal *)&L);
195  //PrintS(" lift done\n");
196 
197  nextG=(ideal)resMat;
198 
199  BITSET save1,save2;
200  SI_SAVE_OPT(save1,save2);
202  nextG = idInterRed(nextG);
203  SI_RESTORE_OPT(save1,save2);
204 
205  G=nextG;
206  return(state);
207 }
208 
209 ///////////////////////////////////////////////////////////////////
210 
211 
212 ///////////////////////////////////////////////////////////////////
213 //walk64
214 ///////////////////////////////////////////////////////////////////
215 //Description: the main function of groebner walk, keeping
216 //everything together
217 ///////////////////////////////////////////////////////////////////
218 //Uses: mStd, getnthrow, firstwalkStep64, nextt64,
219 //nextw64, walkStep64, changecurrRing
220 ///////////////////////////////////////////////////////////////////
221 
222 WalkState walk64(ideal I,int64vec* currw64,ring destRing,
223 int64vec* destVec64,ideal & destIdeal,BOOLEAN sourceIsSB)
224 {
225  //some initializations
226  WalkState state=WalkOk;
227  BITSET save1,save2;
228  SI_SAVE_OPT(save1,save2);
229 
232  int step=0;
233  ideal G=I;
234 
236  if(!sourceIsSB)
237  {
238  ideal GG=idStd(G);
239  idDelete(&G); G=GG;
240  }
241  else
242  G=idInterRed(G);
243  SI_RESTORE_OPT(save1,save2);
244 
245  ideal nextG;
246  state=firstWalkStep64(G,currw64,destRing);
247  nextG=G;
248 
249  if(overflow_error)
250  {
251  state=WalkOverFlowError;
252  return(state);
253  }
254 
255  int64 nexttvec0,nexttvec1;
256  //int64vec* nexttvec64=nextt64(nextG,currw64,destVec64);
257  nextt64(nextG,currw64,destVec64,nexttvec0,nexttvec1);
258 
259  //while(0<t<=1) ( t=((*nexttvec64)[0])/((*nexttvec64)[1]) )
260  //while( (*nexttvec64)[0]<=(*nexttvec64)[1] ) {
261  while (nexttvec0<=nexttvec1 )
262  {
263  step=step+1;
264 
265  //int64vec *tt=nextw64(currw64,destVec64,nexttvec64);
266  int64vec *tt=nextw64(currw64,destVec64,nexttvec0,nexttvec1);
267  delete currw64; currw64=tt; tt=NULL;
268 
269  if (TEST_OPT_PROT)
270  {
271  PrintS("walk step:"); currw64->show(); PrintLn();
272  }
273 
274  state=walkStep64(nextG,currw64,step);
275  //uppdates nextG if all is OK
276 
277  if(overflow_error)
278  return(WalkOverFlowError);
279 
280  //delete nexttvec64;
281  //nexttvec64=nextt64(nextG,currw64,destVec64);
282  nextt64(nextG,currw64,destVec64,nexttvec0,nexttvec1);
283 
284  }
285 
286  destIdeal=sortRedSB(nextG);
287  return(state);
288 }
289 
290 ///////////////////////////////////////////////////////////////////
291 
292 
293 
294 ///////////////////////////////////////////////////////////////////
295 //FRACTAL WALK PART BEGINS HERE
296 ///////////////////////////////////////////////////////////////////
297 
298 ///////////////////////////////////////////////////////////////////
299 //firstFractalWalkStep64
300 ///////////////////////////////////////////////////////////////////
301 //Description: called once before fractalRec64 is called, to set up
302 //the ring and move G into it, has two different strategies
303 ///////////////////////////////////////////////////////////////////
304 //Uses: firstWalkStep64,currwOnBorder64,getTaun64,rCopy0AndAddA,
305 //getiv64,iv64Size,rComplete,rChangeCurrRing,idrMoveR,idStd,matIdLift
306 ///////////////////////////////////////////////////////////////////
307 
308 
309 //unperturbedStartVectorStrategy IS NOW NOT ALLWAYS AS DEFAULT SET
310 //TO TRUE BUT IS INPUT FROM fractalWalk64
312 intvec* currMat, ring destRing,
313 BOOLEAN unperturbedStartVectorStrategy){
314 
315  //This strategy Uses the ordinary walk for the first step
316  if(unperturbedStartVectorStrategy){
317  return(unperturbedFirstStep64(G,currw64,destRing));
318  //here G is updated since its adress is given as argument
319  }
320 
321  //This strategy makes sure that the start vector lies inside the start cone
322  //thus no step is needed within the start cone.
323  else{
324  if(currwOnBorder64(G,currw64))
325  {
326  int64 dummy64;
327  getTaun64(G,currMat,iv64Size(currw64),&currw64,dummy64);
328  //currw64=getiv64(getTaun64(G,currMat,iv64Size(currw64)));
329  }
330  ring oldRing=currRing;
331  ring newRing=rCopy0AndAddA(destRing,currw64);
332  rComplete(newRing);
333  rChangeCurrRing(newRing);
334  G=idrMoveR(G,oldRing,newRing);
335  }
336 
337  return(WalkOk);
338 }
339 
340 ///////////////////////////////////////////////////////////////////
341 
342 
343 
344 //DIESE FUNKTION ERSETZT firstWalkStep FUR fractalWalk
345 ///////////////////////////////////////////////////////////////////
346 //unperturbedFirstStep64
347 ///////////////////////////////////////////////////////////////////
348 //Description: adapts currRing for the algorithm and moves G into
349 //it, calculating the appropriate GB if currw not is inside of
350 //the current groebner cone
351 ///////////////////////////////////////////////////////////////////
352 //Assumes: that the option redSB is turned off
353 ///////////////////////////////////////////////////////////////////
354 //Uses: init64, rCopy0AndAddA, rComplete, rChangeCurrRing, matIdLift,
355 //mpMult, idInterRed, idStd, idCopy, idrMoveR,currwOnBorder64
356 ///////////////////////////////////////////////////////////////////
357 
358 WalkState unperturbedFirstStep64(ideal & G,int64vec* currw64, ring destRing)
359 {
360  WalkState state=WalkOk;
361  /* OLDRING **************************************************** */
362  ideal nextG;
363  BITSET save1,save2;
364  SI_SAVE_OPT(save1,save2);
365 
366  if (currwOnBorder64(G,currw64))
367  {
368  ideal Gw=init64(G,currw64);
369  ring oldRing=currRing;
370  /* NEWRING **************************************************** */
371  ring rnew=rCopy0AndAddA(destRing,currw64);
372  rComplete(rnew);
373  rChangeCurrRing(rnew);
374 
375  ideal newGw=idrMoveR(Gw, oldRing,rnew);
376 
377  //turn off bucket representation of polynomials and on redSB
378  //si_opt_1|=Sy_bit(OPT_NOT_BUCKETS);
380 
381  ideal newStdGw=idStd(newGw);
382 
383  //turn on bucket representation of polynomials and off redSB
384  SI_RESTORE_OPT(save1,save2);
385 
386  matrix L=matIdLift(newGw,newStdGw);
387  idDelete(&newStdGw);
388  idDelete(&newGw);
389 
390  nextG=idrMoveR(G,oldRing,rnew); idTest(nextG);
391 
392  matrix nextGmat=(matrix)nextG;
393 
394  matrix resMat=mp_Mult(nextGmat,L,rnew);
395  idDelete((ideal *)&nextGmat);
396  idDelete((ideal *)&L);
397 
398  nextG=(ideal)resMat;
399 
401  nextG = idInterRed(nextG);
402  SI_RESTORE_OPT(save1,save2);
403  }
404  else
405  {
406  ring oldRing=currRing;
407  ring rnew=rCopy0AndAddA(destRing,currw64);
408  rComplete(rnew);
409  rChangeCurrRing(rnew);
410  nextG=idrMoveR(G,oldRing,rnew);
411  }
412 
413  G=nextG;
414  return(state);
415 }
416 
417 ///////////////////////////////////////////////////////////////////
418 
419 
420 
421 ///////////////////////////////////////////////////////////////////
422 //fractalRec64
423 ///////////////////////////////////////////////////////////////////
424 //Description: the recursion function used in fractalWalk64
425 //(see appropriate par of thesis for more details)
426 ///////////////////////////////////////////////////////////////////
427 //Assumes: that the option redSB is turned off
428 ///////////////////////////////////////////////////////////////////
429 //Uses: getTaun64,getint64,getiv64,invEpsOk64,nextt64,nextw64,
430 //init64,idCopy,noPolysOfMoreThanTwoTerms,rCopy0,rComplete,
431 //rChangeCurrRing,rSetWeightVec,idrMoveR,mpMult,idInterRed
432 ///////////////////////////////////////////////////////////////////
433 
434 WalkState fractalRec64(ideal & G,int64vec* currw64, intvec* destMat,
435  int level,int step)
436 {
437 
438 if (TEST_OPT_PROT)
439 { PrintS("fractal walk, weights");currw64->show();PrintLn(); }
440 WalkState state=WalkOk;
441 BITSET save1,save2;
442 SI_SAVE_OPT(save1,save2);
443 
444 //1
445 int64vec* w=(currw64);
446 int64vec* old_w=(currw64);
447 int64vec* sigma=(currw64);
448 
449 //lists taunpair64=getTaun64(G,destMat,level);
450 //int64vec* w2=getiv64(taunpair64);
451 //int64 inveps64=getint64(taunpair64);
452 int64vec* w2;
453 int64 inveps64;
454 getTaun64(G,destMat,level,&w2,inveps64);
455 
456 //2
457 while(1){
458 
459  //int64vec* tvec64=nextt64(G,w,w2);
460  int64 tvec0,tvec1;
461  nextt64(G,w,w2,tvec0,tvec1);
462 
463  if(overflow_error){
464  return WalkOverFlowError;
465  }
466 
467  //tvec[1]>tvec[2] iff t>1 or t ist undefined i.e.is (2,0)
468  //if ((*tvec64)[0]>(*tvec64)[1])
469  if (tvec0>tvec1)
470  {
471  if(invEpsOk64(G,destMat,level,inveps64)) {
472  return(state);
473  }
474  else
475  {
476  //taunpair64=getTaun64(G,destMat,level);
477  //w2=getiv64(taunpair64);
478  //inveps64=getint64(taunpair64);
479  delete w2;
480  getTaun64(G,destMat,level,&w2,inveps64);
481 
482  //tvec64=nextt64(G,w,w2);
483  nextt64(G,w,w2,tvec0,tvec1);
484 
485  if(overflow_error){
486  return WalkOverFlowError;
487  }
488 
489  //if((*tvec64)[0]>(*tvec64)[1])
490  if(tvec0>tvec1)
491  {
492  return(state);
493  }
494  }
495  }
496 
497  //i.e. t=1 and we have reached the target vector
498  //if( ((*tvec64)[0]==(*tvec64)[1]) && (level!=iv64Size(w)) )
499  if( (tvec0==tvec1) && (level!=iv64Size(w)) )
500  {
501  state=fractalRec64(G,old_w,destMat,level+1,step);
502  return(state);
503  }
504  else
505  {
506  w=nextw64(w,w2,tvec0,tvec1);
507 
508 //3
509  ideal Gw=init64(G,w); //finding initial ideal for new w
510 
511  ring oldRing=currRing;
512 
513  ideal GwCp=idCopy(Gw);
514  ideal GCp=idCopy(G);
515 
516  ideal newGw;
517  ideal newStdGw;
518  ideal newG;
519 
520 //4
521  if ( level==iv64Size(w) || noPolysWithMoreThanTwoTerms(Gw) ){
522 
523 //5
524 /*NEWRING**********************************************************/
525 
526  //this assumes order has A-vector as first vector
527  ring newring=rCopy0(currRing);
528  rComplete(newring);
529  rSetWeightVec(newring,w->iv64GetVec());
530  rChangeCurrRing(newring);
531  //rSetWeightVec(newring,w->iv64GetVec());
532  //rComplete(newring,1);
533 
534  newGw=idrMoveR(GwCp,oldRing,newring);
535 
537  newStdGw=idStd(newGw); //computes new reduced GB of Gw
538  SI_RESTORE_OPT(save1,save2);
539  }
540  else
541  {
542 //7
543 /*THE RING FROM THE RECURSION STEP BELOW***************************/
544  //Here we can choose whether to call fractalrec with old_w,
545  //which is the last w from the top level, or with sigma,
546  //the original start vector. The impact on the algorithm is not obvious.
547 
548  state=fractalRec64(Gw,sigma,destMat,level+1,step);
549 
550  //The resulting GB is Gw since its adress is given as argument.
551  ideal recG=Gw;
552  ring temp=currRing;
553 
554 /*NEWRING**********************************************************/
555 
556  //this assumes order has A-vector as first vector
557  ring newring=rCopy0(currRing);
558  rComplete(newring);
559  rChangeCurrRing(newring);
561  rComplete(newring,1);
562 
563  newGw=idrMoveR(GwCp,oldRing,newring);
564 
565  newStdGw=idrMoveR(recG,temp,newring);
566  }
567 
568 //8
569  //lifting comes either after level=nvars(ring), after Gw has
570  //no poly with more than two terms or after
571  //fractalRec64(Gw,level+1) has returned
572 
573  //si_opt_1|=Sy_bit(OPT_NOT_BUCKETS);
574  matrix L=matIdLift(newGw,newStdGw);
575  SI_RESTORE_OPT(save1,save2);
576 
577  newG=idrMoveR(GCp,oldRing,currRing);
578  matrix MG=(matrix)newG;
579 
580  matrix resMat=mp_Mult(MG,L,currRing);
581  idDelete((ideal *)&MG);
582  idDelete((ideal *)&L);
583  G=(ideal)resMat;
584 
585 //9
586 
588  G=idInterRed(G);
589  SI_RESTORE_OPT(save1,save2);
590 
591  old_w=iv64Copy(w);
592  if(level==1) step=step+1;
593 
594  }
595 
596 }
597 }
598 
599 
600 ///////////////////////////////////////////////////////////////////
601 
602 
603 //ANOTHER INPUT-VARIABLE ADDED: unperturbedStartVectorStrategy
604 //THIS SHOULD BE SET IN walkProc.cc BY THE USER
605 ///////////////////////////////////////////////////////////////////
606 //fractalWalk64
607 ///////////////////////////////////////////////////////////////////
608 //Description:
609 ///////////////////////////////////////////////////////////////////
610 //Uses:fractalRec64,firstFractalWalkStep64,idStd,idInterRed,
611 //int64VecToIntVec,getNthRow,sortRedSB
612 ///////////////////////////////////////////////////////////////////
613 
614 WalkState fractalWalk64(ideal sourceIdeal,ring destRing,
615 ideal & destIdeal,BOOLEAN sourceIsSB,
616 BOOLEAN unperturbedStartVectorStrategy)
617 {
618 
619  overflow_error=FALSE; //global
620  WalkState state=WalkOk;
621  BITSET save1,save2;
622  SI_SAVE_OPT(save1,save2);
623 
625  ideal G;
626 
627  if(!sourceIsSB)
628  {
629  G=idStd(sourceIdeal);
630  }
631 
632  else
633  {
634  G=idInterRed(idCopy(sourceIdeal));
635  }
636 
637  SI_RESTORE_OPT(save1,save2); //switches REDSB off
638 
639  //matrices for the orders of the rings
640  intvec *destMat=int64VecToIntVec(rGetGlobalOrderMatrix(destRing));
642 
643  int64vec* currw64=getNthRow64(currMat,1); //start vector
644 
645  state=firstFractalWalkStep64(G,currw64,currMat,destRing,
646  unperturbedStartVectorStrategy);
647  delete currMat;
648 
649  state=fractalRec64(G,currw64,destMat,1,1);
650  if(state==WalkOk)
651  destIdeal=G;
652 
653  if(overflow_error)
654  state=WalkOverFlowError;
655 
656  delete currw64;
657  delete destMat;
658  return state;
659 }
660 
661 
662 /////////////////////////////////////////////////////////////
void nextt64(ideal G, int64vec *currw64, int64vec *targw64, int64 &tvec0, int64 &tvec1)
Definition: walkSupport.cc:563
#define OPT_REDSB
Definition: options.h:71
ideal sortRedSB(ideal G)
int overflow_error
Definition: walkMain.cc:37
void rCopyAndChangeA(int64vec *w)
unsigned si_opt_1
Definition: options.c:5
int level(const CanonicalForm &f)
void PrintLn()
Definition: reporter.cc:327
#define idDelete(H)
delete an ideal
Definition: ideals.h:31
#define TEST_OPT_PROT
Definition: options.h:98
WalkState
Definition: walkMain.h:7
#define FALSE
Definition: auxiliary.h:140
Compatiblity layer for legacy polynomial operations (over currRing)
int64vec * iv64Copy(int64vec *o)
Definition: int64vec.h:75
WalkState walk64(ideal I, int64vec *currw64, ring destRing, int64vec *destVec64, ideal &destIdeal, BOOLEAN sourceIsSB)
Definition: walkMain.cc:222
ring rCopy0AndAddA(const ring r, int64vec *wv64, BOOLEAN copy_qideal, BOOLEAN copy_ordering)
Definition: ring.cc:1461
long int64
Definition: auxiliary.h:112
int64vec * nextw64(int64vec *currw, int64vec *targw, int64 nexttvec0, int64 nexttvec1)
Definition: walkSupport.cc:607
int64vec * getNthRow64(intvec *v, int n)
Definition: walkSupport.cc:184
static TreeM * G
Definition: janet.cc:38
#define BITSET
Definition: structs.h:17
void show(int mat=0, int spaces=0)
Definition: int64vec.cc:105
#define Sy_bit(x)
Definition: options.h:30
WalkState walkStep64(ideal &G, int64vec *currw64, int step)
Definition: walkMain.cc:148
const CanonicalForm & GG
Definition: cfModGcd.cc:4017
int invEpsOk64(ideal I, intvec *targm, int pertdeg, int64 inveps64)
Definition: walkSupport.cc:144
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
#define SI_RESTORE_OPT(A, B)
Definition: options.h:22
WalkState fractalWalk64(ideal sourceIdeal, ring destRing, ideal &destIdeal, BOOLEAN sourceIsSB, BOOLEAN unperturbedStartVectorStrategy)
Definition: walkMain.cc:614
ideal idStd(ideal G)
Definition: walkSupport.cc:941
Definition: intvec.h:14
BOOLEAN rComplete(ring r, int force)
this needs to be called whenever a new ring is created: new fields in ring are created (like VarOffse...
Definition: ring.cc:3436
#define OPT_REDTAIL
Definition: options.h:86
ideal init64(ideal G, int64vec *currw64)
Definition: walkSupport.cc:302
ring rCopy0(const ring r, BOOLEAN copy_qideal, BOOLEAN copy_ordering)
Definition: ring.cc:1318
ideal idInterRed(ideal G)
Definition: walkSupport.cc:961
ip_smatrix * matrix
void getTaun64(ideal G, intvec *targm, int pertdeg, int64vec **v64, int64 &i64)
Definition: walkSupport.cc:212
ideal idrMoveR(ideal &id, ring src_r, ring dest_r)
Definition: prCopy.cc:249
WalkState firstFractalWalkStep64(ideal &G, int64vec *&currw64, intvec *currMat, ring destRing, BOOLEAN unperturbedStartVectorStrategy)
Definition: walkMain.cc:311
void PrintS(const char *s)
Definition: reporter.cc:294
WalkState unperturbedFirstStep64(ideal &G, int64vec *currw64, ring destRing)
Definition: walkMain.cc:358
int iv64Size(int64vec *v)
Definition: walkSupport.h:37
matrix matIdLift(ideal Gomega, ideal M)
Definition: walkSupport.cc:981
WalkState fractalRec64(ideal &G, int64vec *currw64, intvec *destMat, int level, int step)
Definition: walkMain.cc:434
ideal idCopy(ideal A)
Definition: ideals.h:73
void rChangeCurrRing(ring r)
Definition: polys.cc:14
matrix mpNew(int r, int c)
create a r x c zero-matrix
Definition: matpol.cc:48
void rSetWeightVec(ring r, int64 *wv)
Definition: ring.cc:5143
BOOLEAN noPolysWithMoreThanTwoTerms(ideal Gw)
Definition: walkSupport.cc:383
matrix mp_Mult(matrix a, matrix b, const ring R)
Definition: matpol.cc:224
#define NULL
Definition: omList.c:10
void rDelete(ring r)
unconditionally deletes fields in r
Definition: ring.cc:448
BOOLEAN currwOnBorder64(ideal G, int64vec *currw64)
Definition: walkSupport.cc:353
ideal idLiftStd(ideal h1, matrix *ma, tHomog hi, ideal *syz)
Definition: ideals.cc:748
const CanonicalForm & w
Definition: facAbsFact.cc:55
#define SI_SAVE_OPT(A, B)
Definition: options.h:19
int64vec * rGetGlobalOrderMatrix(ring r)
intvec * int64VecToIntVec(int64vec *source)
int BOOLEAN
Definition: auxiliary.h:131
WalkState firstWalkStep64(ideal &G, int64vec *currw64, ring destRing)
Definition: walkMain.cc:69
int64 * iv64GetVec()
Definition: int64vec.h:61
#define idTest(id)
Definition: ideals.h:60