My Project
Loading...
Searching...
No Matches
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"
17
18#include "kernel/polys.h"
19#include "kernel/ideals.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
37VAR int overflow_error; //global variable
38
39/*
40overflow_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
5010: getinveps64 mult
5111: getinveps64 add
5212: getTaun64 mult
5313: 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
69WalkState 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
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
222WalkState walk64(ideal I,int64vec* currw64,ring destRing,
223int64vec* 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
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);
275 //uppdates nextG if all is OK
276
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 ALWAYS AS DEFAULT SET
310//TO TRUE BUT IS INPUT FROM fractalWalk64
312intvec* currMat, ring destRing,
313BOOLEAN 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 address 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
358WalkState 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
434WalkState fractalRec64(ideal & G,int64vec* currw64, intvec* destMat,
435 int level,int step)
436{
437
438if (TEST_OPT_PROT)
439{ PrintS("fractal walk, weights");currw64->show();PrintLn(); }
440WalkState state=WalkOk;
441BITSET save1,save2;
442SI_SAVE_OPT(save1,save2);
443
444//1
445int64vec* w=(currw64);
446int64vec* old_w=(currw64);
447int64vec* sigma=(currw64);
448
449//lists taunpair64=getTaun64(G,destMat,level);
450//int64vec* w2=getiv64(taunpair64);
451//int64 inveps64=getint64(taunpair64);
452int64vec* w2;
453int64 inveps64;
454getTaun64(G,destMat,level,&w2,inveps64);
455
456//2
457while(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
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 address 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);
560 rSetWeightVec(currRing,w->iv64GetVec());
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
614WalkState fractalWalk64(ideal sourceIdeal,ring destRing,
615ideal & destIdeal,BOOLEAN sourceIsSB,
616BOOLEAN 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
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
654 state=WalkOverFlowError;
655
656 delete currw64;
657 delete destMat;
658 return state;
659}
660
661
662/////////////////////////////////////////////////////////////
long int64
Definition: auxiliary.h:68
int BOOLEAN
Definition: auxiliary.h:87
#define FALSE
Definition: auxiliary.h:96
int level(const CanonicalForm &f)
const CanonicalForm & GG
Definition: cfModGcd.cc:4076
void show(int mat=0, int spaces=0)
Definition: int64vec.cc:104
Definition: intvec.h:23
const CanonicalForm & w
Definition: facAbsFact.cc:51
#define VAR
Definition: globaldefs.h:5
ideal idLiftStd(ideal h1, matrix *T, tHomog hi, ideal *S, GbVariant alg, ideal h11)
Definition: ideals.cc:976
#define idDelete(H)
delete an ideal
Definition: ideals.h:29
#define idTest(id)
Definition: ideals.h:47
ideal idCopy(ideal A)
Definition: ideals.h:60
int64vec * iv64Copy(int64vec *o)
Definition: int64vec.h:84
STATIC_VAR TreeM * G
Definition: janet.cc:31
matrix mpNew(int r, int c)
create a r x c zero-matrix
Definition: matpol.cc:37
matrix mp_Mult(matrix a, matrix b, const ring R)
Definition: matpol.cc:206
ip_smatrix * matrix
Definition: matpol.h:43
#define NULL
Definition: omList.c:12
VAR unsigned si_opt_1
Definition: options.c:5
#define SI_SAVE_OPT(A, B)
Definition: options.h:20
#define OPT_REDTAIL
Definition: options.h:92
#define OPT_REDSB
Definition: options.h:77
#define Sy_bit(x)
Definition: options.h:31
#define TEST_OPT_PROT
Definition: options.h:104
#define SI_RESTORE_OPT(A, B)
Definition: options.h:23
void rChangeCurrRing(ring r)
Definition: polys.cc:15
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
Compatibility layer for legacy polynomial operations (over currRing)
ideal idrMoveR(ideal &id, ring src_r, ring dest_r)
Definition: prCopy.cc:248
void PrintS(const char *s)
Definition: reporter.cc:284
void PrintLn()
Definition: reporter.cc:310
void rSetWeightVec(ring r, int64 *wv)
Definition: ring.cc:5232
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:3450
ring rCopy0AndAddA(const ring r, int64vec *wv64, BOOLEAN copy_qideal, BOOLEAN copy_ordering)
Definition: ring.cc:1564
ring rCopy0(const ring r, BOOLEAN copy_qideal, BOOLEAN copy_ordering)
Definition: ring.cc:1421
void rDelete(ring r)
unconditionally deletes fields in r
Definition: ring.cc:450
#define BITSET
Definition: structs.h:16
VAR int overflow_error
Definition: walkMain.cc:37
WalkState unperturbedFirstStep64(ideal &G, int64vec *currw64, ring destRing)
Definition: walkMain.cc:358
WalkState firstWalkStep64(ideal &G, int64vec *currw64, ring destRing)
Definition: walkMain.cc:69
WalkState firstFractalWalkStep64(ideal &G, int64vec *&currw64, intvec *currMat, ring destRing, BOOLEAN unperturbedStartVectorStrategy)
Definition: walkMain.cc:311
WalkState fractalWalk64(ideal sourceIdeal, ring destRing, ideal &destIdeal, BOOLEAN sourceIsSB, BOOLEAN unperturbedStartVectorStrategy)
Definition: walkMain.cc:614
WalkState fractalRec64(ideal &G, int64vec *currw64, intvec *destMat, int level, int step)
Definition: walkMain.cc:434
WalkState walkStep64(ideal &G, int64vec *currw64)
Definition: walkMain.cc:148
WalkState walk64(ideal I, int64vec *currw64, ring destRing, int64vec *destVec64, ideal &destIdeal, BOOLEAN sourceIsSB)
Definition: walkMain.cc:222
WalkState
Definition: walkMain.h:7
@ WalkOverFlowError
Definition: walkMain.h:11
@ WalkOk
Definition: walkMain.h:30
int64vec * rGetGlobalOrderMatrix(ring r)
void nextt64(ideal G, int64vec *currw64, int64vec *targw64, int64 &tvec0, int64 &tvec1)
Definition: walkSupport.cc:560
matrix matIdLift(ideal Gomega, ideal M)
Definition: walkSupport.cc:978
int invEpsOk64(ideal I, intvec *targm, int pertdeg, int64 inveps64)
Definition: walkSupport.cc:141
void getTaun64(ideal G, intvec *targm, int pertdeg, int64vec **v64, int64 &i64)
Definition: walkSupport.cc:209
BOOLEAN currwOnBorder64(ideal G, int64vec *currw64)
Definition: walkSupport.cc:350
int64vec * nextw64(int64vec *currw, int64vec *targw, int64 nexttvec0, int64 nexttvec1)
Definition: walkSupport.cc:604
ideal sortRedSB(ideal G)
BOOLEAN noPolysWithMoreThanTwoTerms(ideal Gw)
Definition: walkSupport.cc:380
void rCopyAndChangeA(int64vec *w)
intvec * int64VecToIntVec(int64vec *source)
ideal init64(ideal G, int64vec *currw64)
Definition: walkSupport.cc:299
int64vec * getNthRow64(intvec *v, int n)
Definition: walkSupport.cc:181
ideal idInterRed(ideal G)
Definition: walkSupport.cc:958
ideal idStd(ideal G)
Definition: walkSupport.cc:938
int iv64Size(int64vec *v)
Definition: walkSupport.h:37