Macros | Functions
walkSupport.h File Reference
#include "misc/intvec.h"
#include "misc/int64vec.h"

Go to the source code of this file.

Macros

#define idealSize(I)   IDELEMS(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)    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); }
int i
Definition: cfEzgcd.cc:125
static int ABS(int v)
Definition: auxiliary.h:110

◆ 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);
354  BOOLEAN res=FALSE;
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 }
#define idDelete(H)
delete an ideal
Definition: ideals.h:29
#define FALSE
Definition: auxiliary.h:94
#define TRUE
Definition: auxiliary.h:98
static TreeM * G
Definition: janet.cc:32
CanonicalForm res
Definition: facAbsFact.cc:64
ideal init64(ideal G, int64vec *currw64)
Definition: walkSupport.cc:299
int i
Definition: cfEzgcd.cc:125
#define NULL
Definition: omList.c:10
static BOOLEAN length(leftv result, leftv arg)
Definition: interval.cc:267
#define idealSize(I)
Definition: walkSupport.h:35
#define pNext(p)
Definition: monomials.h:43
poly getNthPolyOfId(ideal I, int n)
Definition: walkSupport.cc:686
int p
Definition: cfModGcd.cc:4019
int BOOLEAN
Definition: auxiliary.h:85

◆ 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  {
447  p=getNthPolyOfId(G,j);
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 }
const CanonicalForm int s
Definition: facAbsFact.cc:55
int j
Definition: facHensel.cc:105
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:583
intvec * leadExp(poly p)
Definition: walkSupport.cc:746
intvec * ivSub(intvec *a, intvec *b)
Definition: intvec.cc:279
static TreeM * G
Definition: janet.cc:32
#define pIter(p)
Definition: monomials.h:44
Definition: intvec.h:17
int m
Definition: cfEzgcd.cc:121
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
#define NULL
Definition: omList.c:10
int DIFFspy(ideal G)
Definition: walkSupport.cc:407
const CanonicalForm & w
Definition: facAbsFact.cc:55
#define idealSize(I)
Definition: walkSupport.h:35
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
poly getNthPolyOfId(ideal I, int n)
Definition: walkSupport.cc:686
int p
Definition: cfModGcd.cc:4019
#define IMATELEM(M, I, J)
Definition: intvec.h:83
int l
Definition: cfEzgcd.cc:93

◆ 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  {
416  p=getNthPolyOfId(G,j);
417  if((temp=pLength(p))>0) {sum += (temp-1);}
418  }
419  return(sum);
420 }
const CanonicalForm int s
Definition: facAbsFact.cc:55
int j
Definition: facHensel.cc:105
static TreeM * G
Definition: janet.cc:32
static unsigned pLength(poly a)
Definition: p_polys.h:192
#define idealSize(I)
Definition: walkSupport.h:35
poly getNthPolyOfId(ideal I, int n)
Definition: walkSupport.cc:686
int p
Definition: cfModGcd.cc:4019

◆ 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:4044

◆ 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:66
CanonicalForm b
Definition: cfModGcd.cc:4044

◆ 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)) )
124  overflow_error=11;
125 
126  return(inveps64);
127 }
long int64
Definition: auxiliary.h:66
static TreeM * G
Definition: janet.cc:32
BOOLEAN overflow_error
Definition: walkMain.cc:37
int getMaxTdeg(ideal I)
Definition: walkSupport.cc:54
int getMaxPosOfNthRow(intvec *v, int n)
Definition: walkSupport.cc:80

◆ 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 }
int rows() const
Definition: intvec.h:94
Rational abs(const Rational &a)
Definition: GMPrat.cc:439
CanonicalForm res
Definition: facAbsFact.cc:64
#define assume(x)
Definition: mod2.h:390
int i
Definition: cfEzgcd.cc:125
int cols() const
Definition: intvec.h:93

◆ 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 }
int j
Definition: facHensel.cc:105
CanonicalForm res
Definition: facAbsFact.cc:64
static long pTotaldegree(poly p)
Definition: polys.h:268
#define NULL
Definition: omList.c:10
static BOOLEAN length(leftv result, leftv arg)
Definition: interval.cc:267

◆ 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 }
#define NULL
Definition: omList.c:10

◆ 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 }
int rows() const
Definition: intvec.h:94
Definition: intvec.h:17
CanonicalForm res
Definition: facAbsFact.cc:64
int i
Definition: cfEzgcd.cc:125
int cols() const
Definition: intvec.h:93

◆ 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 }
int rows() const
Definition: intvec.h:94
long int64
Definition: auxiliary.h:66
CanonicalForm res
Definition: facAbsFact.cc:64
int i
Definition: cfEzgcd.cc:125
int cols() const
Definition: intvec.h:93

◆ 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)
227  overflow_error=12;
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]) )
239  overflow_error=13;
240  }
241  if( ( ((*temp64)[i]) < 0 ) && ( ((*add64)[i]) < 0 ) )
242  {
243  if( ((*taun64)[i]) > ((*temp64)[i]) )
244  overflow_error=13;
245  }
246  }
247  delete temp64;
248  }
249 
250  //lists taunlist64=makeTaunList64(taun64,inveps64);
251  //return(taunlist64);
252  *v64=taun64;
253  i64=inveps64;
254 }
int64vec * iv64Copy(int64vec *o)
Definition: int64vec.h:81
int64vec * iv64Add(int64vec *a, int64vec *b)
Definition: int64vec.cc:173
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:583
long int64
Definition: auxiliary.h:66
int64vec * getNthRow64(intvec *v, int n)
Definition: walkSupport.cc:181
static TreeM * G
Definition: janet.cc:32
BOOLEAN overflow_error
Definition: walkMain.cc:37
int i
Definition: cfEzgcd.cc:125
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
int64 getInvEps64(ideal G, intvec *targm, int pertdeg)
Definition: walkSupport.cc:109

◆ 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 }
#define idDelete(H)
delete an ideal
Definition: ideals.h:29
static TreeM * G
Definition: janet.cc:32
const CanonicalForm & GG
Definition: cfModGcd.cc:4017
#define assume(x)
Definition: mod2.h:390
ideal kInterRedOld(ideal F, ideal Q)
Definition: kstd1.cc:3019
#define NULL
Definition: omList.c:10

◆ idStd()

ideal idStd ( ideal  G)

Definition at line 938 of file walkSupport.cc.

939 {
940  ideal GG = kStd(G, NULL, testHomog, NULL);
941  idSkipZeroes(GG);
942  return GG;
943 }
ideal kStd(ideal F, ideal Q, tHomog h, intvec **w, intvec *hilb, int syzComp, int newIdeal, intvec *vw, s_poly_proc_t sp)
Definition: kstd1.cc:2096
static TreeM * G
Definition: janet.cc:32
const CanonicalForm & GG
Definition: cfModGcd.cc:4017
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size
#define NULL
Definition: omList.c:10

◆ 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  {
309  p=getNthPolyOfId(G,j);
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 }
int j
Definition: facHensel.cc:105
#define pAdd(p, q)
Definition: polys.h:190
long int64
Definition: auxiliary.h:66
int64vec * leadExp64(poly p)
Definition: walkSupport.cc:769
static TreeM * G
Definition: janet.cc:32
#define pIter(p)
Definition: monomials.h:44
#define pHead(p)
returns newly allocated copy of Lm(p), coef is copied, next=NULL, p might be NULL ...
Definition: polys.h:67
#define IDELEMS(i)
Definition: simpleideals.h:24
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:37
#define NULL
Definition: omList.c:10
static BOOLEAN length(leftv result, leftv arg)
Definition: interval.cc:267
#define pDelete(p_ptr)
Definition: polys.h:173
static int64 scalarProduct64(int64vec *a, int64vec *b)
Definition: walkSupport.cc:266
poly getNthPolyOfId(ideal I, int n)
Definition: walkSupport.cc:686
int p
Definition: cfModGcd.cc:4019

◆ 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 j
Definition: facHensel.cc:105
int cols() const
Definition: int64vec.h:62
Definition: intvec.h:17
CanonicalForm res
Definition: facAbsFact.cc:64
int rows() const
Definition: int64vec.h:63
int i
Definition: cfEzgcd.cc:125

◆ 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 }
long int64
Definition: auxiliary.h:66
int64 getInvEps64(ideal G, intvec *targm, int pertdeg)
Definition: walkSupport.cc:109

◆ iv64Size()

int iv64Size ( int64vec v)
inline

Definition at line 37 of file walkSupport.h.

37 { return((v->rows())*(v->cols())); }
int cols() const
Definition: int64vec.h:62
int rows() const
Definition: int64vec.h:63

◆ ivSize()

int ivSize ( intvec v)
inline

Definition at line 36 of file walkSupport.h.

36 { return((v->rows())*(v->cols())); }
int rows() const
Definition: intvec.h:94
int cols() const
Definition: intvec.h:93

◆ 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));
750  p_GetExpV(p,e,currRing);
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 }
static void p_GetExpV(poly p, int *ev, const ring r)
Definition: p_polys.h:1466
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:583
#define omAlloc(size)
Definition: omAllocDecl.h:210
Definition: intvec.h:17
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:48
#define omFree(addr)
Definition: omAllocDecl.h:261
int i
Definition: cfEzgcd.cc:125
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
int p
Definition: cfModGcd.cc:4019

◆ 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));
773  p_GetExpV(p,e,currRing);
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 }
static void p_GetExpV(poly p, int *ev, const ring r)
Definition: p_polys.h:1466
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:583
long int64
Definition: auxiliary.h:66
#define omAlloc(size)
Definition: omAllocDecl.h:210
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:48
#define omFree(addr)
Definition: omAllocDecl.h:261
int i
Definition: cfEzgcd.cc:125
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
int p
Definition: cfModGcd.cc:4019

◆ 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 }
#define FALSE
Definition: auxiliary.h:94
#define TRUE
Definition: auxiliary.h:98
#define M
Definition: sirandom.c:24
CanonicalForm res
Definition: facAbsFact.cc:64
#define IDELEMS(i)
Definition: simpleideals.h:24
#define NULL
Definition: omList.c:10
matrix id_Module2formatedMatrix(ideal mod, int rows, int cols, const ring R)
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
ideal idLift(ideal mod, ideal submod, ideal *rest, BOOLEAN goodShape, BOOLEAN isSB, BOOLEAN divide, matrix *unit, GbVariant alg)
Definition: ideals.cc:1113

◆ 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 }
const CanonicalForm int s
Definition: facAbsFact.cc:55
int j
Definition: facHensel.cc:105
int rows() const
Definition: intvec.h:94
long int64
Definition: auxiliary.h:66
static TreeM * G
Definition: janet.cc:32
Definition: intvec.h:17
intvec * DIFF(ideal G)
Definition: walkSupport.cc:435
intvec * getNthRow(intvec *v, int n)
Definition: walkSupport.cc:165
void gett64(intvec *listw, int64vec *currw64, int64vec *targw64, int64 &tvec0, int64 &tvec1)
Definition: walkSupport.cc:481

◆ 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  {
621  overflow_error=7;
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  {
634  overflow_error=8;
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  {
650  overflow_error=9;
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 }
const CanonicalForm int s
Definition: facAbsFact.cc:55
int64vec * iv64Copy(int64vec *o)
Definition: int64vec.h:81
int64vec * iv64Add(int64vec *a, int64vec *b)
Definition: int64vec.cc:173
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:583
long int64
Definition: auxiliary.h:66
g
Definition: cfModGcd.cc:4031
CanonicalForm b
Definition: cfModGcd.cc:4044
int64 abs64(int64 i)
Definition: walkSupport.h:44
BOOLEAN overflow_error
Definition: walkMain.cc:37
int64vec * iv64Sub(int64vec *a, int64vec *b)
Definition: int64vec.cc:203
int i
Definition: cfEzgcd.cc:125
int iv64Size(int64vec *v)
Definition: walkSupport.h:37
int64 gcd64(int64 a, int64 b)
Definition: walkSupport.cc:864
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13

◆ 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 }
#define FALSE
Definition: auxiliary.h:94
#define TRUE
Definition: auxiliary.h:98
int i
Definition: cfEzgcd.cc:125
#define NULL
Definition: omList.c:10
static BOOLEAN length(leftv result, leftv arg)
Definition: interval.cc:267
#define idealSize(I)
Definition: walkSupport.h:35
#define pNext(p)
Definition: monomials.h:43
poly getNthPolyOfId(ideal I, int n)
Definition: walkSupport.cc:686
int p
Definition: cfModGcd.cc:4019

◆ 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 }
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:3351
ring rCopy0(const ring r, BOOLEAN copy_qideal, BOOLEAN copy_ordering)
Definition: ring.cc:1325
void rChangeCurrRing(ring r)
Definition: polys.cc:15
void rSetWeightVec(ring r, int64 *wv)
Definition: ring.cc:5130
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
int64 * iv64GetVec()
Definition: int64vec.h:67

◆ 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 }
BOOLEAN rHasLocalOrMixedOrdering(const ring r)
Definition: ring.h:752
int j
Definition: facHensel.cc:105
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:583
long int64
Definition: auxiliary.h:66
CanonicalForm res
Definition: facAbsFact.cc:64
int i
Definition: cfEzgcd.cc:125

◆ 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 }
BOOLEAN rHasLocalOrMixedOrdering(const ring r)
Definition: ring.h:752
int j
Definition: facHensel.cc:105
for int64 weights
Definition: ring.h:78
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:583
long int64
Definition: auxiliary.h:66
CanonicalForm res
Definition: facAbsFact.cc:64
for(int i=0;i<=n;i++) degsf[i]
Definition: cfEzgcd.cc:65
static BOOLEAN length(leftv result, leftv arg)
Definition: interval.cc:267

◆ 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 }
const CanonicalForm int s
Definition: facAbsFact.cc:55
int j
Definition: facHensel.cc:105
#define pLmCmp(p, q)
returns 0|1|-1 if p=q|p>q|p<q w.r.t monomial ordering
Definition: polys.h:105
static TreeM * G
Definition: janet.cc:32
int m
Definition: cfEzgcd.cc:121
int i
Definition: cfEzgcd.cc:125
#define idealSize(I)
Definition: walkSupport.h:35
int p
Definition: cfModGcd.cc:4019

◆ 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 }
CanonicalForm res
Definition: facAbsFact.cc:64
static long pTotaldegree(poly p)
Definition: polys.h:268
#define NULL
Definition: omList.c:10
int p
Definition: cfModGcd.cc:4019