My Project  UNKNOWN_GIT_VERSION
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); }

◆ 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 }

◆ 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 }

◆ 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 }

◆ 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 }

◆ 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 }

◆ 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 }

◆ 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 }

◆ 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 }

◆ 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)
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 }

◆ 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 }

◆ 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 }

◆ 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 }

◆ 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 }

◆ 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));
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 }

◆ 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 }

◆ 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 }

◆ 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 }

◆ 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 }

◆ 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 }

◆ 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 }

◆ 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 }

◆ 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 }

◆ 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 }
FALSE
#define FALSE
Definition: auxiliary.h:94
idLift
ideal idLift(ideal mod, ideal submod, ideal *rest, BOOLEAN goodShape, BOOLEAN isSB, BOOLEAN divide, matrix *unit, GbVariant alg)
Definition: ideals.cc:1113
rSetWeightVec
void rSetWeightVec(ring r, int64 *wv)
Definition: ring.cc:5148
ip_smatrix
Definition: matpol.h:15
j
int j
Definition: facHensel.cc:105
omFree
#define omFree(addr)
Definition: omAllocDecl.h:261
iv64Size
int iv64Size(int64vec *v)
Definition: walkSupport.h:37
idDelete
#define idDelete(H)
delete an ideal
Definition: ideals.h:29
rChangeCurrRing
void rChangeCurrRing(ring r)
Definition: polys.cc:15
getNthRow64
int64vec * getNthRow64(intvec *v, int n)
Definition: walkSupport.cc:181
abs64
int64 abs64(int64 i)
Definition: walkSupport.h:44
length
static BOOLEAN length(leftv result, leftv arg)
Definition: interval.cc:263
g
g
Definition: cfModGcd.cc:4031
ivSub
intvec * ivSub(intvec *a, intvec *b)
Definition: intvec.cc:279
kInterRedOld
ideal kInterRedOld(ideal F, ideal Q)
Definition: kstd1.cc:3028
pDelete
#define pDelete(p_ptr)
Definition: polys.h:181
N
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:49
testHomog
@ testHomog
Definition: structs.h:41
ABS
static int ABS(int v)
Definition: auxiliary.h:110
w
const CanonicalForm & w
Definition: facAbsFact.cc:55
b
CanonicalForm b
Definition: cfModGcd.cc:4044
pTotaldegree
static long pTotaldegree(poly p)
Definition: polys.h:276
int64vec::rows
int rows() const
Definition: int64vec.h:63
rCopy0
ring rCopy0(const ring r, BOOLEAN copy_qideal, BOOLEAN copy_ordering)
Definition: ring.cc:1340
pLength
static unsigned pLength(poly a)
Definition: p_polys.h:193
ringorder_Wp
@ ringorder_Wp
Definition: ring.h:83
for
for(int i=0;i<=n;i++) degsf[i]
Definition: cfEzgcd.cc:65
leadExp64
int64vec * leadExp64(poly p)
Definition: walkSupport.cc:769
currRing
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
rVar
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:582
TRUE
#define TRUE
Definition: auxiliary.h:98
i
int i
Definition: cfEzgcd.cc:125
rHasLocalOrMixedOrdering
BOOLEAN rHasLocalOrMixedOrdering(const ring r)
Definition: ring.h:751
res
CanonicalForm res
Definition: facAbsFact.cc:64
int64vec
Definition: int64vec.h:21
ringorder_Dp
@ ringorder_Dp
Definition: ring.h:81
abs
Rational abs(const Rational &a)
Definition: GMPrat.cc:439
M
#define M
Definition: sirandom.c:24
leadExp
intvec * leadExp(poly p)
Definition: walkSupport.cc:746
BOOLEAN
int BOOLEAN
Definition: auxiliary.h:85
init64
ideal init64(ideal G, int64vec *currw64)
Definition: walkSupport.cc:299
idSkipZeroes
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size
Definition: simpleideals.cc:172
ringorder_M
@ ringorder_M
Definition: ring.h:75
intvec
Definition: intvec.h:21
pIter
#define pIter(p)
Definition: monomials.h:38
omAlloc
#define omAlloc(size)
Definition: omAllocDecl.h:210
GG
const CanonicalForm & GG
Definition: cfModGcd.cc:4017
gcd64
int64 gcd64(int64 a, int64 b)
Definition: walkSupport.cc:864
DIFF
intvec * DIFF(ideal G)
Definition: walkSupport.cc:435
p_GetExpV
static void p_GetExpV(poly p, int *ev, const ring r)
Definition: p_polys.h:1457
overflow_error
BOOLEAN overflow_error
Definition: walkMain.cc:37
pAdd
#define pAdd(p, q)
Definition: polys.h:198
ringorder_lp
@ ringorder_lp
Definition: ring.h:78
iv64Add
int64vec * iv64Add(int64vec *a, int64vec *b)
Definition: int64vec.cc:173
ringorder_dp
@ ringorder_dp
Definition: ring.h:79
idealSize
#define idealSize(I)
Definition: walkSupport.h:35
getMaxTdeg
int getMaxTdeg(ideal I)
Definition: walkSupport.cc:54
IMATELEM
#define IMATELEM(M, I, J)
Definition: intvec.h:83
gett64
void gett64(intvec *listw, int64vec *currw64, int64vec *targw64, int64 &tvec0, int64 &tvec1)
Definition: walkSupport.cc:481
getNthPolyOfId
poly getNthPolyOfId(ideal I, int n)
Definition: walkSupport.cc:686
ringorder_a
@ ringorder_a
Definition: ring.h:71
int64
long int64
Definition: auxiliary.h:66
idInit
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:37
getNthRow
intvec * getNthRow(intvec *v, int n)
Definition: walkSupport.cc:165
int64vec::cols
int cols() const
Definition: int64vec.h:62
iv64Sub
int64vec * iv64Sub(int64vec *a, int64vec *b)
Definition: int64vec.cc:203
getMaxPosOfNthRow
int getMaxPosOfNthRow(intvec *v, int n)
Definition: walkSupport.cc:80
m
int m
Definition: cfEzgcd.cc:121
assume
#define assume(x)
Definition: mod2.h:390
NULL
#define NULL
Definition: omList.c:10
scalarProduct64
static int64 scalarProduct64(int64vec *a, int64vec *b)
Definition: walkSupport.cc:266
l
int l
Definition: cfEzgcd.cc:93
intvec::rows
int rows() const
Definition: intvec.h:94
v
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
ringorder_wp
@ ringorder_wp
Definition: ring.h:82
iv64Copy
int64vec * iv64Copy(int64vec *o)
Definition: int64vec.h:81
DIFFspy
int DIFFspy(ideal G)
Definition: walkSupport.cc:407
p
int p
Definition: cfModGcd.cc:4019
s
const CanonicalForm int s
Definition: facAbsFact.cc:55
pLmCmp
#define pLmCmp(p, q)
returns 0|1|-1 if p=q|p>q|p<q w.r.t monomial ordering
Definition: polys.h:105
IDELEMS
#define IDELEMS(i)
Definition: simpleideals.h:24
kStd
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:2087
id_Module2formatedMatrix
matrix id_Module2formatedMatrix(ideal mod, int rows, int cols, const ring R)
Definition: simpleideals.cc:1247
ringorder_a64
@ ringorder_a64
for int64 weights
Definition: ring.h:72
pHead
#define pHead(p)
returns newly allocated copy of Lm(p), coef is copied, next=NULL, p might be NULL
Definition: polys.h:67
getInvEps64
int64 getInvEps64(ideal G, intvec *targm, int pertdeg)
Definition: walkSupport.cc:109
G
static TreeM * G
Definition: janet.cc:32
pNext
#define pNext(p)
Definition: monomials.h:37
rComplete
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:3369