My Project
Loading...
Searching...
No Matches
walkSupport.h File Reference
#include "misc/intvec.h"
#include "misc/int64vec.h"

Go to the source code of this file.

Macros

#define idealSize(I)
 

Functions

int tdeg (poly p)
 
int getMaxTdeg (ideal I)
 
int getMaxPosOfNthRow (intvec *v, int n)
 
int64 getInvEps64 (ideal G, intvec *targm, int pertdeg)
 
int invEpsOk64 (ideal I, intvec *targm, int pertdeg, int64 inveps64)
 
intvecgetNthRow (intvec *v, int n)
 
int64vecgetNthRow64 (intvec *v, int n)
 
void gett64 (int64vec *listw, int64vec *currw, int64vec *targw, int64 &t1, int64 &t2)
 
void nextt64 (ideal G, int64vec *currw, int64vec *targw, int64 &t1, int64 &t2)
 
int64vecnextw64 (int64vec *currw, int64vec *targw, int64 nexttvec0, int64 nexttvec1)
 
int DIFFspy (ideal G)
 
intvecDIFF (ideal G)
 
ideal init64 (ideal G, int64vec *currw)
 
BOOLEAN currwOnBorder64 (ideal I, int64vec *currw64)
 
void getTaun64 (ideal G, intvec *targm, int pertdeg, int64vec **v64, int64 &i64)
 
ideal idStd (ideal G)
 
ideal idInterRed (ideal G)
 
matrix matIdLift (ideal Gomega, ideal M)
 
void rCopyAndChangeA (int64vec *w)
 
int64vecrGetGlobalOrderMatrix (ring r)
 
int64vecrGetGlobalOrderWeightVec (ring r)
 
BOOLEAN noPolysWithMoreThanTwoTerms (ideal Gw)
 
int ivSize (intvec *v)
 
int iv64Size (int64vec *v)
 
intvecleadExp (poly p)
 
int64vecleadExp64 (poly p)
 
void setPosOfIM (intvec *im, int i, int j, int val)
 
poly getNthPolyOfId (ideal I, int n)
 
int gcd (int a, int b)
 
int64 gcd64 (int64 a, int64 b)
 
int64 abs64 (int64 i)
 
ideal sortRedSB (ideal G)
 
intvecint64VecToIntVec (int64vec *source)
 

Macro Definition Documentation

◆ idealSize

#define idealSize ( I)
Value:
#define IDELEMS(i)

Definition at line 35 of file walkSupport.h.

Function Documentation

◆ abs64()

int64 abs64 ( int64 i)
inline

Definition at line 44 of file walkSupport.h.

44{ return ABS(i); }
static int ABS(int v)
Definition auxiliary.h:113
int i
Definition cfEzgcd.cc:132

◆ currwOnBorder64()

BOOLEAN currwOnBorder64 ( ideal I,
int64vec * currw64 )

Definition at line 350 of file walkSupport.cc.

351{
352 ideal J=init64(G,currw64);
353 int length=idealSize(J);
355 for(int i=length; i>0; i--)
356 {
357 //if(pLength(getNthPolyOfId(J,i))>1)
358 poly p=getNthPolyOfId(J,i);
359 if ((p!=NULL) && (pNext(p)!=NULL))
360 {
361 res=TRUE;break;
362 }
363 }
364 idDelete(&J);
365 return res;
366}
int BOOLEAN
Definition auxiliary.h:88
#define TRUE
Definition auxiliary.h:101
#define FALSE
Definition auxiliary.h:97
int p
Definition cfModGcd.cc:4086
CanonicalForm res
Definition facAbsFact.cc:60
#define idDelete(H)
delete an ideal
Definition ideals.h:29
static BOOLEAN length(leftv result, leftv arg)
Definition interval.cc:257
STATIC_VAR TreeM * G
Definition janet.cc:31
#define pNext(p)
Definition monomials.h:36
#define NULL
Definition omList.c:12
poly getNthPolyOfId(ideal I, int n)
ideal init64(ideal G, int64vec *currw64)
#define idealSize(I)
Definition walkSupport.h:35

◆ DIFF()

intvec * DIFF ( ideal G)

Definition at line 435 of file walkSupport.cc.

436{
437 intvec *v,*w;
438 poly p;
439 int s=idealSize(G);
440 int n=rVar(currRing);
441 int m=DIFFspy(G);
442 intvec* diffm=new intvec(m,n,0);
443 int j,l;
444 int inc=0;
445 for (j=1; j<=s; j++)
446 {
448 v=leadExp(p);
449 pIter(p);
450 while(p!=NULL)
451 {
452 inc++;
453 intvec *lep=leadExp(p);
454 w=ivSub(v,lep /*leadExp(p)*/);
455 delete lep;
456 pIter(p);
457 for (l=1; l<=n; l++)
458 {
459 // setPosOfIM(diffm,inc,l,(*w)[l-1]);
460 IMATELEM(*diffm,inc,l) =(*w)[l-1] ;
461 }
462 delete w;
463 }
464 delete v;
465 }
466 return(diffm);
467}
int l
Definition cfEzgcd.cc:100
int m
Definition cfEzgcd.cc:128
const CanonicalForm int s
Definition facAbsFact.cc:51
const CanonicalForm & w
Definition facAbsFact.cc:51
const Variable & v
< [in] a sqrfree bivariate poly
Definition facBivar.h:39
int j
Definition facHensel.cc:110
intvec * ivSub(intvec *a, intvec *b)
Definition intvec.cc:297
#define IMATELEM(M, I, J)
Definition intvec.h:86
#define pIter(p)
Definition monomials.h:37
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition polys.cc:13
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition ring.h:598
intvec * leadExp(poly p)
int DIFFspy(ideal G)

◆ DIFFspy()

int DIFFspy ( ideal G)

Definition at line 407 of file walkSupport.cc.

408{
409 int s=idealSize(G);
410 int j;
411 int temp;
412 int sum=0;
413 poly p;
414 for (j=1; j<=s; j++)
415 {
417 if((temp=pLength(p))>0) {sum += (temp-1);}
418 }
419 return(sum);
420}
static int pLength(poly a)
Definition p_polys.h:190

◆ gcd()

int gcd ( int a,
int b )

Definition at line 836 of file walkSupport.cc.

837{
838 int r, p0 = a, p1 = b;
839 if(p0 < 0)
840 p0 = -p0;
841
842 if(p1 < 0)
843 p1 = -p1;
844 while(p1 != 0)
845 {
846 r = p0 % p1;
847 p0 = p1;
848 p1 = r;
849 }
850 return p0;
851}
CanonicalForm b
Definition cfModGcd.cc:4111

◆ gcd64()

int64 gcd64 ( int64 a,
int64 b )

Definition at line 864 of file walkSupport.cc.

865{
866 int64 r, p0 = a, p1 = b;
867 if(p0 < 0)
868 p0 = -p0;
869
870 if(p1 < 0)
871 p1 = -p1;
872
873 while(p1 != ((int64)0) )
874 {
875 r = p0 % p1;
876 p0 = p1;
877 p1 = r;
878 }
879
880 return p0;
881}
long int64
Definition auxiliary.h:68

◆ getInvEps64()

int64 getInvEps64 ( ideal G,
intvec * targm,
int pertdeg )

Definition at line 109 of file walkSupport.cc.

110{
111 int n;
112 int64 temp64;
113 int64 sum64=0;
114//think n=2 is enough (instead of n=1)
115 for (n=pertdeg; n>1; n--)
116 {
117 temp64=getMaxPosOfNthRow(targm,n);
118 sum64 += temp64;
119 }
120 int64 inveps64=getMaxTdeg(G)*sum64+1;
121
122 //overflow test
123 if( sum64!=0 && (((inveps64-1)/sum64)!=getMaxTdeg(G)) )
125
126 return(inveps64);
127}
VAR int overflow_error
Definition walkMain.cc:37
int getMaxTdeg(ideal I)
int getMaxPosOfNthRow(intvec *v, int n)

◆ getMaxPosOfNthRow()

int getMaxPosOfNthRow ( intvec * v,
int n )

Definition at line 80 of file walkSupport.cc.

81{
82 int res=0;
83 assume( (0<n) && (n<=(v->rows())) );
84 {
85 int c=v->cols();
86 int cc=(n-1)*c;
87 res=abs((*v)[0+cc /*(n-1)*c*/]);
88 for (int i=c-1;i>=0;i--)
89 {
90 int temp=abs((*v)[i+cc /*(n-1)*c*/]);
91 if(temp>res){res=temp;}
92 }
93 }
94 return(res);
95}
Rational abs(const Rational &a)
Definition GMPrat.cc:436
#define assume(x)
Definition mod2.h:389

◆ getMaxTdeg()

int getMaxTdeg ( ideal I)

Definition at line 54 of file walkSupport.cc.

55{
56 int res=-1;
57 int length=(int)I->ncols;
58 for(int j=length-1;j>=0;j--)
59 {
60 if ((I->m)[j]!=NULL)
61 {
62 int temp=pTotaldegree((I->m)[j]);
63 if(temp>res) {res=temp;}
64 }
65 }
66 return(res);
67}
static long pTotaldegree(poly p)
Definition polys.h:283

◆ getNthPolyOfId()

poly getNthPolyOfId ( ideal I,
int n )

Definition at line 686 of file walkSupport.cc.

687{
688 if(0<n && n<=((int)I->ncols))
689 {
690 return (I->m)[n-1];
691 }
692 else
693 {
694 return(NULL);
695 }
696}

◆ getNthRow()

intvec * getNthRow ( intvec * v,
int n )

Definition at line 165 of file walkSupport.cc.

166{
167 int r=v->rows();
168 int c=v->cols();
169 intvec *res=new intvec(c);
170 if((0<n) && (n<=r))
171 {
172 int cc=(n-1)*c;
173 for (int i=0; i<c; i++)
174 {
175 (*res)[i]=(*v)[i+cc /*(n-1)*c*/ ];
176 }
177 }
178 return(res);
179}

◆ getNthRow64()

int64vec * getNthRow64 ( intvec * v,
int n )

Definition at line 181 of file walkSupport.cc.

182{
183 int r=v->rows();
184 int c=v->cols();
185 int64vec *res=new int64vec(c);
186 if((0<n) && (n<=r))
187 {
188 int cc=(n-1)*c;
189 for (int i=0; i<c; i++)
190 {
191 (*res)[i]=(int64)(*v)[i+cc /*(n-1)*c*/ ];
192 }
193 }
194 return(res);
195}

◆ gett64()

void gett64 ( int64vec * listw,
int64vec * currw,
int64vec * targw,
int64 & t1,
int64 & t2 )

◆ getTaun64()

void getTaun64 ( ideal G,
intvec * targm,
int pertdeg,
int64vec ** v64,
int64 & i64 )

Definition at line 209 of file walkSupport.cc.

210{
211 int64vec* taun64=getNthRow64(targm,1);
212 int64vec *temp64,*add64;
213 int64 inveps64=1;
214 if (pertdeg>1) inveps64=getInvEps64(G,targm,pertdeg);
215
216 int n;
217 //temp64 is used to check for overflow:
218 for (n=2; n<=pertdeg; n++)
219 {
220 if (inveps64!=1)
221 {
222 temp64=iv64Copy(taun64);
223 (*taun64)*=inveps64;
224 for(int i=0; i<rVar(currRing);i++)
225 {
226 if((*temp64)[i]!=0 && (((*taun64)[i])/((*temp64)[i]))!=inveps64)
228 }
229 delete temp64;
230 }
231 temp64=iv64Copy(taun64);
232 add64=getNthRow64(targm,n);
233 taun64=iv64Add(add64,taun64);
234 for(int i=0; i<rVar(currRing);i++)
235 {
236 if( ( ((*temp64)[i]) > 0 ) && ( ((*add64)[i]) > 0 ) )
237 {
238 if( ((*taun64)[i]) < ((*temp64)[i]) )
240 }
241 if( ( ((*temp64)[i]) < 0 ) && ( ((*add64)[i]) < 0 ) )
242 {
243 if( ((*taun64)[i]) > ((*temp64)[i]) )
245 }
246 }
247 delete temp64;
248 }
249
250 //lists taunlist64=makeTaunList64(taun64,inveps64);
251 //return(taunlist64);
252 *v64=taun64;
253 i64=inveps64;
254}
int64vec * iv64Add(int64vec *a, int64vec *b)
Definition int64vec.cc:172
int64vec * iv64Copy(int64vec *o)
Definition int64vec.h:84
int64vec * getNthRow64(intvec *v, int n)
int64 getInvEps64(ideal G, intvec *targm, int pertdeg)

◆ idInterRed()

ideal idInterRed ( ideal G)

Definition at line 958 of file walkSupport.cc.

959{
960 assume(G != NULL);
961
962 ideal GG = kInterRedOld(G, NULL);
963 idDelete(&G);
964 return GG;
965}
const CanonicalForm & GG
Definition cfModGcd.cc:4084
ideal kInterRedOld(ideal F, const ideal Q)
Definition kstd1.cc:3451

◆ idStd()

ideal idStd ( ideal G)

Definition at line 938 of file walkSupport.cc.

939{
940 ideal GG = kStd2(G, NULL, testHomog, NULL,(bigintmat*)NULL);
942 return GG;
943}
Matrices of numbers.
Definition bigintmat.h:51
ideal kStd2(ideal F, ideal Q, tHomog h, intvec **w, bigintmat *hilb, int syzComp, int newIdeal, intvec *vw, s_poly_proc_t sp)
generic interface to GB/SB computations, large hilbert vectors
Definition kstd1.cc:2602
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size
@ testHomog
Definition structs.h:34

◆ init64()

ideal init64 ( ideal G,
int64vec * currw )

Definition at line 299 of file walkSupport.cc.

300{
301 int length=IDELEMS(G);
302 ideal I=idInit(length,G->rank);
303 int j;
304 int64 leadingweight,templeadingweight;
305 poly p=NULL;
306 poly leadp=NULL;
307 for (j=1; j<=length; j++)
308 {
310 int64vec *tt=leadExp64(p);
311 leadingweight=scalarProduct64(currw64,tt /*leadExp64(p)*/);
312 delete tt;
313 while (p!=NULL)
314 {
315 tt=leadExp64(p);
316 templeadingweight=scalarProduct64(currw64,tt /*leadExp64(p)*/);
317 delete tt;
318 if(templeadingweight==leadingweight)
319 {
320 leadp=pAdd(leadp,pHead(p));
321 }
322 if(templeadingweight>leadingweight)
323 {
324 pDelete(&leadp);
325 leadp=pHead(p);
326 leadingweight=templeadingweight;
327 }
328 pIter(p);
329 }
330 (I->m)[j-1]=leadp;
331 p=NULL;
332 leadp=NULL;
333 }
334 return(I);
335}
#define pAdd(p, q)
Definition polys.h:204
#define pDelete(p_ptr)
Definition polys.h:187
#define pHead(p)
returns newly allocated copy of Lm(p), coef is copied, next=NULL, p might be NULL
Definition polys.h:68
ideal idInit(int idsize, int rank)
initialise an ideal / module
int64vec * leadExp64(poly p)
static int64 scalarProduct64(int64vec *a, int64vec *b)

◆ int64VecToIntVec()

intvec * int64VecToIntVec ( int64vec * source)

Definition at line 1181 of file walkSupport.cc.

1182{
1183 int r=source->rows();
1184 int c=source->cols();
1185 intvec* res=new intvec(r,c,0);
1186 for(int i=0;i<r;i++){
1187 for(int j=0;j<c;j++){
1188 (*res)[i*c+j]=(int)(*source)[i*c+j];
1189 }
1190 }
1191 delete source;
1192 return(res);
1193}
int rows() const
Definition int64vec.h:66
int cols() const
Definition int64vec.h:65

◆ invEpsOk64()

int invEpsOk64 ( ideal I,
intvec * targm,
int pertdeg,
int64 inveps64 )

Definition at line 141 of file walkSupport.cc.

142{
143 int64 temp64=getInvEps64(I,targm,pertdeg);
144 if (inveps64>=temp64)
145 {
146 return(1);
147 }
148 else
149 {
150 return(0);
151 }
152}

◆ iv64Size()

int iv64Size ( int64vec * v)
inline

Definition at line 37 of file walkSupport.h.

37{ return((v->rows())*(v->cols())); }

◆ ivSize()

int ivSize ( intvec * v)
inline

Definition at line 36 of file walkSupport.h.

36{ return((v->rows())*(v->cols())); }

◆ leadExp()

intvec * leadExp ( poly p)

Definition at line 746 of file walkSupport.cc.

747{
748 int N=rVar(currRing);
749 int *e=(int*)omAlloc((N+1)*sizeof(int));
751 intvec* iv=new intvec(N);
752 for(int i=N;i>0;i--) { (*iv)[i-1]=e[i];}
753 omFree(e);
754 return(iv);
755}
const CanonicalForm CFMap CFMap & N
Definition cfEzgcd.cc:56
#define omAlloc(size)
#define omFree(addr)
static void p_GetExpV(poly p, int *ev, const ring r)
Definition p_polys.h:1536

◆ leadExp64()

int64vec * leadExp64 ( poly p)

Definition at line 769 of file walkSupport.cc.

770{
771 int N=rVar(currRing);
772 int *e=(int*)omAlloc((N+1)*sizeof(int));
774 int64vec* iv64=new int64vec(N);
775 for(int i=N;i>0;i--) { (*iv64)[i-1]=(int64)e[i];}
776 omFree(e);
777 return(iv64);
778}

◆ matIdLift()

matrix matIdLift ( ideal Gomega,
ideal M )

Definition at line 978 of file walkSupport.cc.

979{
980 ideal Mtmp = idLift(Gomega, M, NULL, FALSE, FALSE, TRUE, NULL);
981 int rows=IDELEMS(Gomega);
982 int cols=IDELEMS(Mtmp);
984 return res;
985}
ideal idLift(ideal mod, ideal submod, ideal *rest, BOOLEAN goodShape, BOOLEAN isSB, BOOLEAN divide, matrix *unit, GbVariant alg)
represents the generators of submod in terms of the generators of mod (Matrix(SM)*U-Matrix(rest)) = M...
Definition ideals.cc:1111
ip_smatrix * matrix
Definition matpol.h:43
matrix id_Module2formatedMatrix(ideal mod, int rows, int cols, const ring R)
#define M
Definition sirandom.c:25

◆ nextt64()

void nextt64 ( ideal G,
int64vec * currw,
int64vec * targw,
int64 & t1,
int64 & t2 )

Definition at line 560 of file walkSupport.cc.

561{
562 intvec* diffm=DIFF(G);
563 int s=diffm->rows();
564 tvec0=(int64)2;
565 tvec1=(int64)0;
566 intvec *tt;
567 for(int j=1; j<=s; j++)
568 {
569 tt=getNthRow(diffm,j);
570 int64 temptvec0, temptvec1;
571 gett64(tt,currw64,targw64,temptvec0, temptvec1);
572 delete tt;
573
574 //if tempt>0 both parts will be>0
575 if ( (temptvec1!=0) //that tempt is defined
576 &&
577 (temptvec0>0) && (temptvec1>0) //that tempt>0
578 )
579 {
580 if( ( (temptvec0) <= (temptvec1) ) //that tempt<=1
581 &&
582 ( ( (temptvec0) * (tvec1) ) <
583 ( (temptvec1) * (tvec0) ) )
584 )
585 { //that tempt<t
586 tvec0=temptvec0;
587 tvec1=temptvec1;
588 }
589 }
590 }
591 delete diffm;
592 return;
593}
int rows() const
Definition intvec.h:97
intvec * DIFF(ideal G)
intvec * getNthRow(intvec *v, int n)
void gett64(intvec *listw, int64vec *currw64, int64vec *targw64, int64 &tvec0, int64 &tvec1)

◆ nextw64()

int64vec * nextw64 ( int64vec * currw,
int64vec * targw,
int64 nexttvec0,
int64 nexttvec1 )

Definition at line 604 of file walkSupport.cc.

606{
607 //to do (targw-currw)*tvec[0]+currw*tvec[1]
608 int64vec* tempv;
609 int64vec* nextweight;
610 int64vec* a=iv64Sub(targw,currw);
611 //no overflow can occur since both are>=0
612
613 //to test overflow
614 tempv=iv64Copy(a);
615 *a *= (nexttvec0);
616 for(int i=0; i<rVar(currRing); i++)
617 {
618 if( (nexttvec0) !=0 &&
619 (((*a)[i])/(nexttvec0))!=((*tempv)[i]) )
620 {
622 break;
623 }
624 }
625 delete tempv;
626 int64vec* b=currw;
627 tempv=iv64Copy(b);
628 *b *= (nexttvec1);
629 for(int i=0; i<rVar(currRing); i++)
630 {
631 if( (nexttvec1) !=0 &&
632 (((*b)[i])/(nexttvec1))!=((*tempv)[i]) )
633 {
635 break;
636 }
637 }
638 delete tempv;
639 nextweight=iv64Add(a,b);
640
641 for(int i=0; i<rVar(currRing); i++)
642 {
643 if( (((*a)[i])>=0 && ((*b)[i])>=0) ||
644 (((*a)[i])<0 && ((*b)[i])<0) )
645 {
646 if( (abs64((*a)[i]))>abs64((*nextweight)[i]) ||
647 (abs64((*b)[i]))>abs64((*nextweight)[i])
648 )
649 {
651 break;
652 }
653 }
654 }
655
656 //to reduce common factors of nextweight
657 int s=iv64Size(nextweight);
658 int64 g,temp;
659 g=(*nextweight)[0];
660 for (int i=1; i<s; i++)
661 {
662 temp=(*nextweight)[i];
663 g=gcd64(g,temp);
664 if (g==1) break;
665 }
666
667 if (g!=1) *nextweight /= g;
668
669 return(nextweight);
670}
g
Definition cfModGcd.cc:4098
int64vec * iv64Sub(int64vec *a, int64vec *b)
Definition int64vec.cc:202
int64 gcd64(int64 a, int64 b)
int iv64Size(int64vec *v)
Definition walkSupport.h:37
int64 abs64(int64 i)
Definition walkSupport.h:44

◆ noPolysWithMoreThanTwoTerms()

BOOLEAN noPolysWithMoreThanTwoTerms ( ideal Gw)

Definition at line 380 of file walkSupport.cc.

381{
382 int length=idealSize(Gw);
383 for(int i=length; i>0; i--)
384 {
385 //if(pLength(getNthPolyOfId(Gw,i))>2)
386 poly p=getNthPolyOfId(Gw,i);
387 if ((p!=NULL) && (pNext(p)!=NULL) && (pNext(pNext(p))!=NULL))
388 {
389 return FALSE;
390 }
391 }
392 return TRUE;
393}

◆ rCopyAndChangeA()

void rCopyAndChangeA ( int64vec * w)

Definition at line 1000 of file walkSupport.cc.

1001{
1002 ring rnew=rCopy0(currRing);
1003 rComplete(rnew);
1004 rSetWeightVec(rnew,w->iv64GetVec());
1005 rChangeCurrRing(rnew);
1006}
void rChangeCurrRing(ring r)
Definition polys.cc:16
void rSetWeightVec(ring r, int64 *wv)
Definition ring.cc:5376
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:3526
ring rCopy0(const ring r, BOOLEAN copy_qideal, BOOLEAN copy_ordering)
Definition ring.cc:1426

◆ rGetGlobalOrderMatrix()

int64vec * rGetGlobalOrderMatrix ( ring r)

Definition at line 1019 of file walkSupport.cc.

1020{
1021 int n=rVar(r);
1022 int64vec* res=new int64vec(n,n,(int64)0);
1023 if (rHasLocalOrMixedOrdering(r)) return res;
1024 int pos1=0;
1025 int pos2=0;
1026 int i=0;
1027 while(r->order[i]!=0 && pos2<n)
1028 {
1029 pos2=pos2+r->block1[i] - r->block0[i];
1030
1031 if(r->order[i]==ringorder_lp)
1032 {
1033 for(int j=pos1; j<=pos2; j++)
1034 (*res)[j*n+j]=(int64)1;
1035 }
1036 else if(r->order[i]==ringorder_dp)
1037 {
1038 for(int j=pos1;j<=pos2;j++)
1039 (*res)[pos1*n+j]=(int64)1;
1040 for(int j=1;j<=(pos2-pos1);j++)
1041 (*res)[(pos1+j)*n+(pos2+1-j)]=(int64)-1;
1042 }
1043 else if(r->order[i]==ringorder_Dp)
1044 {
1045 for(int j=pos1;j<=pos2;j++)
1046 (*res)[pos1*n+j]=(int64)1;
1047 for(int j=1;j<=(pos2-pos1);j++)
1048 (*res)[(pos1+j)*n+(pos1+j-1)]=(int64)1;
1049 }
1050 else if(r->order[i]==ringorder_wp)
1051 {
1052 int* weights=r->wvhdl[i];
1053 for(int j=pos1;j<=pos2;j++)
1054 (*res)[pos1*n+j]=(int64)weights[j-pos1];
1055 for(int j=1;j<=(pos2-pos1);j++)
1056 (*res)[(pos1+j)*n+(pos2+1-j)]=(int64)-1;
1057 }
1058 else if(r->order[i]==ringorder_Wp)
1059 {
1060 int* weights=r->wvhdl[i];
1061 for(int j=pos1;j<=pos2;j++)
1062 (*res)[pos1*n+j]=(int64)weights[j-pos1];
1063 for(int j=1;j<=(pos2-pos1);j++)
1064 (*res)[(pos1+j)*n+(pos1+j-1)]=(int64)1;
1065 }
1066
1067 else if(r->order[0]==ringorder_M)
1068 {
1069 int* weights=r->wvhdl[0];
1070 for(int j=pos1;j<((pos2+1)*(pos2+1));j++)
1071 (*res)[j]=(int64)weights[j];
1072 }
1073
1074 pos1=pos2+1;
1075 pos2=pos2+1;
1076 i++;
1077 }
1078
1079 return(res);
1080}
static BOOLEAN rHasLocalOrMixedOrdering(const ring r)
Definition ring.h:769
@ ringorder_lp
Definition ring.h:78
@ ringorder_Dp
Definition ring.h:81
@ ringorder_dp
Definition ring.h:79
@ ringorder_Wp
Definition ring.h:83
@ ringorder_wp
Definition ring.h:82
@ ringorder_M
Definition ring.h:75

◆ rGetGlobalOrderWeightVec()

int64vec * rGetGlobalOrderWeightVec ( ring r)

Definition at line 1094 of file walkSupport.cc.

1095{
1096 int n=rVar(r);
1097 int64vec* res=new int64vec(n);
1098
1099 if (rHasLocalOrMixedOrdering(r)) return res;
1100
1101 int length;
1102
1103 if(r->order[0]==ringorder_lp)
1104 {
1105 (*res)[0]=(int64)1;
1106 }
1107 else if( (r->order[0]==ringorder_dp) || (r->order[0]==ringorder_Dp) )
1108 {
1109 length=r->block1[0] - r->block0[0];
1110 for (int j=0;j<=length;j++)
1111 (*res)[j]=(int64)1;
1112 }
1113 else if( (r->order[0]==ringorder_wp) || (r->order[0]==ringorder_Wp) ||
1114 (r->order[0]==ringorder_a) || (r->order[0]==ringorder_M) )
1115 {
1116 int* weights=r->wvhdl[0];
1117 length=r->block1[0] - r->block0[0];
1118 for (int j=0;j<=length;j++)
1119 (*res)[j]=(int64)weights[j];
1120 }
1121 else if( /*(*/ r->order[0]==ringorder_a64 /*)*/ )
1122 {
1123 int64* weights=(int64*)r->wvhdl[0];
1124 length=r->block1[0] - r->block0[0];
1125 for (int j=0;j<=length;j++)
1126 (*res)[j]=weights[j];
1127 }
1128
1129 return(res);
1130}
@ ringorder_a
Definition ring.h:71
@ ringorder_a64
for int64 weights
Definition ring.h:72

◆ setPosOfIM()

void setPosOfIM ( intvec * im,
int i,
int j,
int val )

◆ sortRedSB()

ideal sortRedSB ( ideal G)

Definition at line 1146 of file walkSupport.cc.

1147{
1148 int s=idealSize(G);
1149 poly* m=G->m;
1150 poly p,q;
1151 for (int i=0; i<(s-1); i++)
1152 {
1153 for (int j=0; j<((s-1)-i); j++)
1154 {
1155 p=m[j];
1156 q=m[j+1];
1157 if (pLmCmp(p,q)==1)
1158 {
1159 m[j+1]=p;
1160 m[j]=q;
1161 }
1162 }
1163 }
1164 return(G);
1165}
#define pLmCmp(p, q)
returns 0|1|-1 if p=q|p>q|p<q w.r.t monomial ordering
Definition polys.h:106

◆ tdeg()

int tdeg ( poly p)

Definition at line 35 of file walkSupport.cc.

36{
37 int res=0;
38 if(p!=NULL) res=pTotaldegree(p);
39 return(res);
40}