My Project
Macros | Typedefs | Enumerations | Functions
ideals.h File Reference
#include "polys/monomials/ring.h"
#include "polys/monomials/p_polys.h"
#include "polys/simpleideals.h"
#include "kernel/structs.h"

Go to the source code of this file.

Macros

#define idDelete(H)   id_Delete((H),currRing)
 delete an ideal More...
 
#define idMaxIdeal(D)   id_MaxIdeal(D,currRing)
 initialise the maximal ideal (at 0) More...
 
#define idPosConstant(I)   id_PosConstant(I,currRing)
 index of generator with leading term in ground ring (if any); otherwise -1 More...
 
#define idIsConstant(I)   id_IsConstant(I,currRing)
 
#define idSimpleAdd(A, B)   id_SimpleAdd(A,B,currRing)
 
#define idPrint(id)   id_Print(id, currRing, currRing)
 
#define idTest(id)   id_Test(id, currRing)
 

Typedefs

typedef ideal * resolvente
 

Enumerations

enum  GbVariant {
  GbDefault =0 , GbStd , GbSlimgb , GbSba ,
  GbGroebner , GbModstd , GbFfmod , GbNfmod ,
  GbStdSat , GbSingmatic
}
 

Functions

static ideal idCopyFirstK (const ideal ide, const int k)
 
void idKeepFirstK (ideal ide, const int k)
 keeps the first k (>= 1) entries of the given ideal (Note that the kept polynomials may be zero.) More...
 
void idDelEquals (ideal id)
 
ideal id_Copy (ideal h1, const ring r)
 copy an ideal More...
 
ideal idCopy (ideal A)
 
ideal idAdd (ideal h1, ideal h2)
 h1 + h2 More...
 
BOOLEAN idInsertPoly (ideal h1, poly h2)
 insert h2 into h1 (if h2 is not the zero polynomial) return TRUE iff h2 was indeed inserted More...
 
BOOLEAN idInsertPolyOnPos (ideal I, poly p, int pos)
 insert p into I on position pos More...
 
BOOLEAN idInsertPolyWithTests (ideal h1, const int validEntries, const poly h2, const bool zeroOk, const bool duplicateOk)
 
static ideal idMult (ideal h1, ideal h2)
 hh := h1 * h2 More...
 
BOOLEAN idIs0 (ideal h)
 returns true if h is the zero ideal More...
 
static BOOLEAN idHomIdeal (ideal id, ideal Q=NULL)
 
static BOOLEAN idHomModule (ideal m, ideal Q, intvec **w)
 
BOOLEAN idTestHomModule (ideal m, ideal Q, intvec *w)
 
ideal idMinBase (ideal h1)
 
void idInitChoise (int r, int beg, int end, BOOLEAN *endch, int *choise)
 
void idGetNextChoise (int r, int end, BOOLEAN *endch, int *choise)
 
int idGetNumberOfChoise (int t, int d, int begin, int end, int *choise)
 
int binom (int n, int r)
 
ideal idFreeModule (int i)
 
ideal idSect (ideal h1, ideal h2, GbVariant a=GbDefault)
 
ideal idMultSect (resolvente arg, int length, GbVariant a=GbDefault)
 
ideal idSyzygies (ideal h1, tHomog h, intvec **w, BOOLEAN setSyzComp=TRUE, BOOLEAN setRegularity=FALSE, int *deg=NULL, GbVariant a=GbDefault)
 
ideal idLiftStd (ideal h1, matrix *m, tHomog h=testHomog, ideal *syz=NULL, GbVariant a=GbDefault, ideal h11=NULL)
 
ideal idLift (ideal mod, ideal submod, ideal *rest=NULL, BOOLEAN goodShape=FALSE, BOOLEAN isSB=TRUE, BOOLEAN divide=FALSE, matrix *unit=NULL, GbVariant a=GbDefault)
 
void idLiftW (ideal P, ideal Q, int n, matrix &T, ideal &R, int *w=NULL)
 
ideal idQuot (ideal h1, ideal h2, BOOLEAN h1IsStb=FALSE, BOOLEAN resultIsIdeal=FALSE)
 
ideal idElimination (ideal h1, poly delVar, intvec *hilb=NULL, GbVariant a=GbDefault)
 
ideal idMinors (matrix a, int ar, ideal R=NULL)
 compute all ar-minors of the matrix a the caller of mpRecMin the elements of the result are not in R (if R!=NULL) More...
 
ideal idMinEmbedding (ideal arg, BOOLEAN inPlace=FALSE, intvec **w=NULL)
 
ideal idHead (ideal h)
 
BOOLEAN idIsSubModule (ideal id1, ideal id2)
 
static ideal idVec2Ideal (poly vec)
 
ideal idSeries (int n, ideal M, matrix U=NULL, intvec *w=NULL)
 
static BOOLEAN idIsZeroDim (ideal i)
 
matrix idDiff (matrix i, int k)
 
matrix idDiffOp (ideal I, ideal J, BOOLEAN multiply=TRUE)
 
static intvecidSort (ideal id, BOOLEAN nolex=TRUE)
 
ideal idModulo (ideal h1, ideal h2, tHomog h=testHomog, intvec **w=NULL, matrix *T=NULL, GbVariant a=GbDefault)
 
matrix idCoeffOfKBase (ideal arg, ideal kbase, poly how)
 
poly id_GCD (poly f, poly g, const ring r)
 
ideal id_Farey (ideal x, number N, const ring r)
 
ideal id_TensorModuleMult (const int m, const ideal M, const ring rRing)
 
ideal id_Satstd (const ideal I, ideal J, const ring r)
 
GbVariant syGetAlgorithm (char *n, const ring r, const ideal M)
 

Macro Definition Documentation

◆ idDelete

#define idDelete (   H)    id_Delete((H),currRing)

delete an ideal

Definition at line 29 of file ideals.h.

◆ idIsConstant

#define idIsConstant (   I)    id_IsConstant(I,currRing)

Definition at line 40 of file ideals.h.

◆ idMaxIdeal

#define idMaxIdeal (   D)    id_MaxIdeal(D,currRing)

initialise the maximal ideal (at 0)

Definition at line 33 of file ideals.h.

◆ idPosConstant

#define idPosConstant (   I)    id_PosConstant(I,currRing)

index of generator with leading term in ground ring (if any); otherwise -1

Definition at line 37 of file ideals.h.

◆ idPrint

#define idPrint (   id)    id_Print(id, currRing, currRing)

Definition at line 46 of file ideals.h.

◆ idSimpleAdd

#define idSimpleAdd (   A,
  B 
)    id_SimpleAdd(A,B,currRing)

Definition at line 42 of file ideals.h.

◆ idTest

#define idTest (   id)    id_Test(id, currRing)

Definition at line 47 of file ideals.h.

Typedef Documentation

◆ resolvente

typedef ideal* resolvente

Definition at line 18 of file ideals.h.

Enumeration Type Documentation

◆ GbVariant

enum GbVariant
Enumerator
GbDefault 
GbStd 
GbSlimgb 
GbSba 
GbGroebner 
GbModstd 
GbFfmod 
GbNfmod 
GbStdSat 
GbSingmatic 

Definition at line 118 of file ideals.h.

119 {
120  GbDefault=0,
121  // internal variants:
122  GbStd,
123  GbSlimgb,
124  GbSba,
125  // and the library functions:
126  GbGroebner,
127  GbModstd,
128  GbFfmod,
129  GbNfmod,
130  GbStdSat,
132 };
@ GbGroebner
Definition: ideals.h:126
@ GbModstd
Definition: ideals.h:127
@ GbStdSat
Definition: ideals.h:130
@ GbSlimgb
Definition: ideals.h:123
@ GbFfmod
Definition: ideals.h:128
@ GbNfmod
Definition: ideals.h:129
@ GbDefault
Definition: ideals.h:120
@ GbStd
Definition: ideals.h:122
@ GbSingmatic
Definition: ideals.h:131
@ GbSba
Definition: ideals.h:124

Function Documentation

◆ binom()

int binom ( int  n,
int  r 
)

Definition at line 922 of file simpleideals.cc.

923 {
924  int i;
925  int64 result;
926 
927  if (r==0) return 1;
928  if (n-r<r) return binom(n,n-r);
929  result = n-r+1;
930  for (i=2;i<=r;i++)
931  {
932  result *= n-r+i;
933  result /= i;
934  }
935  if (result>MAX_INT_VAL)
936  {
937  WarnS("overflow in binomials");
938  result=0;
939  }
940  return (int)result;
941 }
long int64
Definition: auxiliary.h:68
int i
Definition: cfEzgcd.cc:132
#define WarnS
Definition: emacs.cc:78
return result
Definition: facAbsBiFact.cc:75
const int MAX_INT_VAL
Definition: mylimits.h:12
int binom(int n, int r)

◆ id_Copy()

ideal id_Copy ( ideal  h1,
const ring  r 
)

copy an ideal

Definition at line 413 of file simpleideals.cc.

414 {
415  id_Test(h1, r);
416 
417  ideal h2 = idInit(IDELEMS(h1), h1->rank);
418  for (int i=IDELEMS(h1)-1; i>=0; i--)
419  h2->m[i] = p_Copy(h1->m[i],r);
420  return h2;
421 }
static poly p_Copy(poly p, const ring r)
returns a copy of p
Definition: p_polys.h:812
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:35
#define IDELEMS(i)
Definition: simpleideals.h:23
#define id_Test(A, lR)
Definition: simpleideals.h:78

◆ id_Farey()

ideal id_Farey ( ideal  x,
number  N,
const ring  r 
)

Definition at line 2836 of file ideals.cc.

2837 {
2838  int cnt=IDELEMS(x)*x->nrows;
2839  ideal result=idInit(cnt,x->rank);
2840  result->nrows=x->nrows; // for lifting matrices
2841  result->ncols=x->ncols; // for lifting matrices
2842 
2843  int i;
2844  for(i=cnt-1;i>=0;i--)
2845  {
2846  result->m[i]=p_Farey(x->m[i],N,r);
2847  }
2848  return result;
2849 }
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:56
Variable x
Definition: cfModGcd.cc:4084
poly p_Farey(poly p, number N, const ring r)
Definition: p_polys.cc:54

◆ id_GCD()

poly id_GCD ( poly  f,
poly  g,
const ring  r 
)

Definition at line 2733 of file ideals.cc.

2734 {
2735  ideal I=idInit(2,1); I->m[0]=f; I->m[1]=g;
2736  intvec *w = NULL;
2737 
2738  ring save_r = currRing;
2739  rChangeCurrRing(r);
2740  ideal S=idSyzygies(I,testHomog,&w);
2741  rChangeCurrRing(save_r);
2742 
2743  if (w!=NULL) delete w;
2744  poly gg=p_TakeOutComp(&(S->m[0]), 2, r);
2745  id_Delete(&S, r);
2746  poly gcd_p=singclap_pdivide(f,gg, r);
2747  p_Delete(&gg, r);
2748 
2749  return gcd_p;
2750 }
g
Definition: cfModGcd.cc:4092
FILE * f
Definition: checklibs.c:9
poly singclap_pdivide(poly f, poly g, const ring r)
Definition: clapsing.cc:590
Definition: intvec.h:23
const CanonicalForm & w
Definition: facAbsFact.cc:51
ideal idSyzygies(ideal h1, tHomog h, intvec **w, BOOLEAN setSyzComp, BOOLEAN setRegularity, int *deg, GbVariant alg)
Definition: ideals.cc:830
void p_TakeOutComp(poly *p, long comp, poly *q, int *lq, const ring r)
Definition: p_polys.cc:3565
#define NULL
Definition: omList.c:12
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:861
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
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
@ testHomog
Definition: structs.h:43

◆ id_Satstd()

ideal id_Satstd ( const ideal  I,
ideal  J,
const ring  r 
)

Definition at line 3096 of file ideals.cc.

3097 {
3098  ring save=currRing;
3099  if (currRing!=r) rChangeCurrRing(r);
3100  idSkipZeroes(J);
3101  id_satstdSaturatingVariables=(int*)omAlloc0((1+rVar(currRing))*sizeof(int));
3102  int k=IDELEMS(J);
3103  if (k>1)
3104  {
3105  for (int i=0; i<k; i++)
3106  {
3107  poly x = J->m[i];
3108  int li = p_Var(x,r);
3109  if (li>0)
3111  else
3112  {
3113  if (currRing!=save) rChangeCurrRing(save);
3114  WerrorS("ideal generators must be variables");
3115  return NULL;
3116  }
3117  }
3118  }
3119  else
3120  {
3121  poly x = J->m[0];
3122  for (int i=1; i<=r->N; i++)
3123  {
3124  int li = p_GetExp(x,i,r);
3125  if (li==1)
3127  else if (li>1)
3128  {
3129  if (currRing!=save) rChangeCurrRing(save);
3130  Werror("exponent(x(%d)^%d) must be 0 or 1",i,li);
3131  return NULL;
3132  }
3133  }
3134  }
3135  ideal res=kStd(I,r->qideal,testHomog,NULL,NULL,0,0,NULL,id_sat_vars_sp);
3138  if (currRing!=save) rChangeCurrRing(save);
3139  return res;
3140 }
int k
Definition: cfEzgcd.cc:99
CanonicalForm res
Definition: facAbsFact.cc:60
void WerrorS(const char *s)
Definition: feFopen.cc:24
STATIC_VAR int * id_satstdSaturatingVariables
Definition: ideals.cc:2981
static BOOLEAN id_sat_vars_sp(kStrategy strat)
Definition: ideals.cc:2983
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:2430
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
#define omAlloc0(size)
Definition: omAllocDecl.h:211
int p_Var(poly m, const ring r)
Definition: p_polys.cc:4684
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent @Note: the integer VarOffset encodes:
Definition: p_polys.h:469
void Werror(const char *fmt,...)
Definition: reporter.cc:189
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:594
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size

◆ id_TensorModuleMult()

ideal id_TensorModuleMult ( const int  m,
const ideal  M,
const ring  rRing 
)

Definition at line 1799 of file simpleideals.cc.

1800 {
1801 // #ifdef DEBU
1802 // WarnS("tensorModuleMult!!!!");
1803 
1804  assume(m > 0);
1805  assume(M != NULL);
1806 
1807  const int n = rRing->N;
1808 
1809  assume(M->rank <= m * n);
1810 
1811  const int k = IDELEMS(M);
1812 
1813  ideal idTemp = idInit(k,m); // = {f_1, ..., f_k }
1814 
1815  for( int i = 0; i < k; i++ ) // for every w \in M
1816  {
1817  poly pTempSum = NULL;
1818 
1819  poly w = M->m[i];
1820 
1821  while(w != NULL) // for each term of w...
1822  {
1823  poly h = p_Head(w, rRing);
1824 
1825  const int gen = __p_GetComp(h, rRing); // 1 ...
1826 
1827  assume(gen > 0);
1828  assume(gen <= n*m);
1829 
1830  // TODO: write a formula with %, / instead of while!
1831  /*
1832  int c = gen;
1833  int v = 1;
1834  while(c > m)
1835  {
1836  c -= m;
1837  v++;
1838  }
1839  */
1840 
1841  int cc = gen % m;
1842  if( cc == 0) cc = m;
1843  int vv = 1 + (gen - cc) / m;
1844 
1845 // assume( cc == c );
1846 // assume( vv == v );
1847 
1848  // 1<= c <= m
1849  assume( cc > 0 );
1850  assume( cc <= m );
1851 
1852  assume( vv > 0 );
1853  assume( vv <= n );
1854 
1855  assume( (cc + (vv-1)*m) == gen );
1856 
1857  p_IncrExp(h, vv, rRing); // h *= var(j) && // p_AddExp(h, vv, 1, rRing);
1858  p_SetComp(h, cc, rRing);
1859 
1860  p_Setm(h, rRing); // addjust degree after the previous steps!
1861 
1862  pTempSum = p_Add_q(pTempSum, h, rRing); // it is slow since h will be usually put to the back of pTempSum!!!
1863 
1864  pIter(w);
1865  }
1866 
1867  idTemp->m[i] = pTempSum;
1868  }
1869 
1870  // simplify idTemp???
1871 
1872  ideal idResult = id_Transp(idTemp, rRing);
1873 
1874  id_Delete(&idTemp, rRing);
1875 
1876  return(idResult);
1877 }
int m
Definition: cfEzgcd.cc:128
STATIC_VAR Poly * h
Definition: janet.cc:971
#define assume(x)
Definition: mod2.h:387
#define pIter(p)
Definition: monomials.h:37
#define __p_GetComp(p, r)
Definition: monomials.h:63
static poly p_Add_q(poly p, poly q, const ring r)
Definition: p_polys.h:896
static poly p_Head(poly p, const ring r)
copy the i(leading) term of p
Definition: p_polys.h:826
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
Definition: p_polys.h:247
static long p_IncrExp(poly p, int v, ring r)
Definition: p_polys.h:591
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:233
ideal id_Transp(ideal a, const ring rRing)
transpose a module
#define M
Definition: sirandom.c:25

◆ idAdd()

ideal idAdd ( ideal  h1,
ideal  h2 
)
inline

h1 + h2

Definition at line 68 of file ideals.h.

69 {
70  return id_Add(h1, h2, currRing);
71 }
ideal id_Add(ideal h1, ideal h2, const ring r)
h1 + h2

◆ idCoeffOfKBase()

matrix idCoeffOfKBase ( ideal  arg,
ideal  kbase,
poly  how 
)

Definition at line 2609 of file ideals.cc.

2610 {
2611  matrix result;
2612  ideal tempKbase;
2613  poly p,q;
2614  intvec * convert;
2615  int i=IDELEMS(kbase),j=IDELEMS(arg),k,pos;
2616 #if 0
2617  while ((i>0) && (kbase->m[i-1]==NULL)) i--;
2618  if (idIs0(arg))
2619  return mpNew(i,1);
2620  while ((j>0) && (arg->m[j-1]==NULL)) j--;
2621  result = mpNew(i,j);
2622 #else
2623  result = mpNew(i, j);
2624  while ((j>0) && (arg->m[j-1]==NULL)) j--;
2625 #endif
2626 
2627  tempKbase = idCreateSpecialKbase(kbase,&convert);
2628  for (k=0;k<j;k++)
2629  {
2630  p = arg->m[k];
2631  while (p!=NULL)
2632  {
2633  q = idDecompose(p,how,tempKbase,&pos);
2634  if (pos>=0)
2635  {
2636  MATELEM(result,(*convert)[pos],k+1) =
2637  pAdd(MATELEM(result,(*convert)[pos],k+1),q);
2638  }
2639  else
2640  p_Delete(&q,currRing);
2641  pIter(p);
2642  }
2643  }
2644  idDelete(&tempKbase);
2645  return result;
2646 }
int p
Definition: cfModGcd.cc:4080
int j
Definition: facHensel.cc:110
ideal idCreateSpecialKbase(ideal kBase, intvec **convert)
Definition: ideals.cc:2523
poly idDecompose(poly monom, poly how, ideal kbase, int *pos)
Definition: ideals.cc:2577
#define idDelete(H)
delete an ideal
Definition: ideals.h:29
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
matrix mpNew(int r, int c)
create a r x c zero-matrix
Definition: matpol.cc:37
#define MATELEM(mat, i, j)
1-based access to matrix
Definition: matpol.h:29
#define pAdd(p, q)
Definition: polys.h:203

◆ idCopy()

ideal idCopy ( ideal  A)
inline

Definition at line 60 of file ideals.h.

61 {
62  return id_Copy(A, currRing);
63 }
ideal id_Copy(ideal h1, const ring r)
copy an ideal
#define A
Definition: sirandom.c:24

◆ idCopyFirstK()

static ideal idCopyFirstK ( const ideal  ide,
const int  k 
)
inlinestatic

Definition at line 20 of file ideals.h.

21 {
22  return id_CopyFirstK(ide, k, currRing);
23 }
ideal id_CopyFirstK(const ideal ide, const int k, const ring r)
copies the first k (>= 1) entries of the given ideal/module and returns these as a new ideal/module (...

◆ idDelEquals()

void idDelEquals ( ideal  id)

Definition at line 2944 of file ideals.cc.

2945 {
2946  int idsize = IDELEMS(id);
2947  poly_sort *id_sort = (poly_sort *)omAlloc0(idsize*sizeof(poly_sort));
2948  for (int i = 0; i < idsize; i++)
2949  {
2950  id_sort[i].p = id->m[i];
2951  id_sort[i].index = i;
2952  }
2953  idSort_qsort(id_sort, idsize);
2954  int index, index_i, index_j;
2955  int i = 0;
2956  for (int j = 1; j < idsize; j++)
2957  {
2958  if (id_sort[i].p != NULL && pEqualPolys(id_sort[i].p, id_sort[j].p))
2959  {
2960  index_i = id_sort[i].index;
2961  index_j = id_sort[j].index;
2962  if (index_j > index_i)
2963  {
2964  index = index_j;
2965  }
2966  else
2967  {
2968  index = index_i;
2969  i = j;
2970  }
2971  pDelete(&id->m[index]);
2972  }
2973  else
2974  {
2975  i = j;
2976  }
2977  }
2978  omFreeSize((ADDRESS)(id_sort), idsize*sizeof(poly_sort));
2979 }
void * ADDRESS
Definition: auxiliary.h:119
int index
Definition: ideals.cc:2927
poly p
Definition: ideals.cc:2926
void idSort_qsort(poly_sort *id_sort, int idsize)
Definition: ideals.cc:2935
static int index(p_Length length, p_Ord ord)
Definition: p_Procs_Impl.h:592
#define pDelete(p_ptr)
Definition: polys.h:186
#define pEqualPolys(p1, p2)
Definition: polys.h:400

◆ idDiff()

matrix idDiff ( matrix  i,
int  k 
)

Definition at line 2126 of file ideals.cc.

2127 {
2128  int e=MATCOLS(i)*MATROWS(i);
2129  matrix r=mpNew(MATROWS(i),MATCOLS(i));
2130  r->rank=i->rank;
2131  int j;
2132  for(j=0; j<e; j++)
2133  {
2134  r->m[j]=pDiff(i->m[j],k);
2135  }
2136  return r;
2137 }
long rank
Definition: matpol.h:19
poly * m
Definition: matpol.h:18
#define MATROWS(i)
Definition: matpol.h:26
#define MATCOLS(i)
Definition: matpol.h:27
#define pDiff(a, b)
Definition: polys.h:296

◆ idDiffOp()

matrix idDiffOp ( ideal  I,
ideal  J,
BOOLEAN  multiply = TRUE 
)

Definition at line 2139 of file ideals.cc.

2140 {
2141  matrix r=mpNew(IDELEMS(I),IDELEMS(J));
2142  int i,j;
2143  for(i=0; i<IDELEMS(I); i++)
2144  {
2145  for(j=0; j<IDELEMS(J); j++)
2146  {
2147  MATELEM(r,i+1,j+1)=pDiffOp(I->m[i],J->m[j],multiply);
2148  }
2149  }
2150  return r;
2151 }
#define pDiffOp(a, b, m)
Definition: polys.h:297

◆ idElimination()

ideal idElimination ( ideal  h1,
poly  delVar,
intvec hilb = NULL,
GbVariant  a = GbDefault 
)

Definition at line 1587 of file ideals.cc.

1588 {
1589  int i,j=0,k,l;
1590  ideal h,hh, h3;
1591  rRingOrder_t *ord;
1592  int *block0,*block1;
1593  int ordersize=2;
1594  int **wv;
1595  tHomog hom;
1596  intvec * w;
1597  ring tmpR;
1598  ring origR = currRing;
1599 
1600  if (delVar==NULL)
1601  {
1602  return idCopy(h1);
1603  }
1604  if ((currRing->qideal!=NULL) && rIsPluralRing(origR))
1605  {
1606  WerrorS("cannot eliminate in a qring");
1607  return NULL;
1608  }
1609  if (idIs0(h1)) return idInit(1,h1->rank);
1610 #ifdef HAVE_PLURAL
1611  if (rIsPluralRing(origR))
1612  /* in the NC case, we have to check the admissibility of */
1613  /* the subalgebra to be intersected with */
1614  {
1615  if ((ncRingType(origR) != nc_skew) && (ncRingType(origR) != nc_exterior)) /* in (quasi)-commutative algebras every subalgebra is admissible */
1616  {
1617  if (nc_CheckSubalgebra(delVar,origR))
1618  {
1619  WerrorS("no elimination is possible: subalgebra is not admissible");
1620  return NULL;
1621  }
1622  }
1623  }
1624 #endif
1625  hom=(tHomog)idHomModule(h1,NULL,&w); //sets w to weight vector or NULL
1626  h3=idInit(16,h1->rank);
1627  for (k=0;; k++)
1628  {
1629  if (origR->order[k]!=0) ordersize++;
1630  else break;
1631  }
1632 #if 0
1633  if (rIsPluralRing(origR)) // we have too keep the odering: it may be needed
1634  // for G-algebra
1635  {
1636  for (k=0;k<ordersize-1; k++)
1637  {
1638  block0[k+1] = origR->block0[k];
1639  block1[k+1] = origR->block1[k];
1640  ord[k+1] = origR->order[k];
1641  if (origR->wvhdl[k]!=NULL) wv[k+1] = (int*) omMemDup(origR->wvhdl[k]);
1642  }
1643  }
1644  else
1645  {
1646  block0[1] = 1;
1647  block1[1] = (currRing->N);
1648  if (origR->OrdSgn==1) ord[1] = ringorder_wp;
1649  else ord[1] = ringorder_ws;
1650  wv[1]=(int*)omAlloc0((currRing->N)*sizeof(int));
1651  double wNsqr = (double)2.0 / (double)(currRing->N);
1653  int *x= (int * )omAlloc(2 * ((currRing->N) + 1) * sizeof(int));
1654  int sl=IDELEMS(h1) - 1;
1655  wCall(h1->m, sl, x, wNsqr);
1656  for (sl = (currRing->N); sl!=0; sl--)
1657  wv[1][sl-1] = x[sl + (currRing->N) + 1];
1658  omFreeSize((ADDRESS)x, 2 * ((currRing->N) + 1) * sizeof(int));
1659 
1660  ord[2]=ringorder_C;
1661  ord[3]=0;
1662  }
1663 #else
1664 #endif
1665  if ((hom==TRUE) && (origR->OrdSgn==1) && (!rIsPluralRing(origR)))
1666  {
1667  #if 1
1668  // we change to an ordering:
1669  // aa(1,1,1,...,0,0,0),wp(...),C
1670  // this seems to be better than version 2 below,
1671  // according to Tst/../elimiate_[3568].tat (- 17 %)
1672  ord=(rRingOrder_t*)omAlloc0(4*sizeof(rRingOrder_t));
1673  block0=(int*)omAlloc0(4*sizeof(int));
1674  block1=(int*)omAlloc0(4*sizeof(int));
1675  wv=(int**) omAlloc0(4*sizeof(int**));
1676  block0[0] = block0[1] = 1;
1677  block1[0] = block1[1] = rVar(origR);
1678  wv[0]=(int*)omAlloc0((rVar(origR) + 1)*sizeof(int));
1679  // use this special ordering: like ringorder_a, except that pFDeg, pWeights
1680  // ignore it
1681  ord[0] = ringorder_aa;
1682  for (j=0;j<rVar(origR);j++)
1683  if (pGetExp(delVar,j+1)!=0) wv[0][j]=1;
1684  BOOLEAN wp=FALSE;
1685  for (j=0;j<rVar(origR);j++)
1686  if (p_Weight(j+1,origR)!=1) { wp=TRUE;break; }
1687  if (wp)
1688  {
1689  wv[1]=(int*)omAlloc0((rVar(origR) + 1)*sizeof(int));
1690  for (j=0;j<rVar(origR);j++)
1691  wv[1][j]=p_Weight(j+1,origR);
1692  ord[1] = ringorder_wp;
1693  }
1694  else
1695  ord[1] = ringorder_dp;
1696  #else
1697  // we change to an ordering:
1698  // a(w1,...wn),wp(1,...0.....),C
1699  ord=(int*)omAlloc0(4*sizeof(int));
1700  block0=(int*)omAlloc0(4*sizeof(int));
1701  block1=(int*)omAlloc0(4*sizeof(int));
1702  wv=(int**) omAlloc0(4*sizeof(int**));
1703  block0[0] = block0[1] = 1;
1704  block1[0] = block1[1] = rVar(origR);
1705  wv[0]=(int*)omAlloc0((rVar(origR) + 1)*sizeof(int));
1706  wv[1]=(int*)omAlloc0((rVar(origR) + 1)*sizeof(int));
1707  ord[0] = ringorder_a;
1708  for (j=0;j<rVar(origR);j++)
1709  wv[0][j]=pWeight(j+1,origR);
1710  ord[1] = ringorder_wp;
1711  for (j=0;j<rVar(origR);j++)
1712  if (pGetExp(delVar,j+1)!=0) wv[1][j]=1;
1713  #endif
1714  ord[2] = ringorder_C;
1715  ord[3] = (rRingOrder_t)0;
1716  }
1717  else
1718  {
1719  // we change to an ordering:
1720  // aa(....),orig_ordering
1721  ord=(rRingOrder_t*)omAlloc0(ordersize*sizeof(rRingOrder_t));
1722  block0=(int*)omAlloc0(ordersize*sizeof(int));
1723  block1=(int*)omAlloc0(ordersize*sizeof(int));
1724  wv=(int**) omAlloc0(ordersize*sizeof(int**));
1725  for (k=0;k<ordersize-1; k++)
1726  {
1727  block0[k+1] = origR->block0[k];
1728  block1[k+1] = origR->block1[k];
1729  ord[k+1] = origR->order[k];
1730  if (origR->wvhdl[k]!=NULL) wv[k+1] = (int*) omMemDup(origR->wvhdl[k]);
1731  }
1732  block0[0] = 1;
1733  block1[0] = rVar(origR);
1734  wv[0]=(int*)omAlloc0((rVar(origR) + 1)*sizeof(int));
1735  for (j=0;j<rVar(origR);j++)
1736  if (pGetExp(delVar,j+1)!=0) wv[0][j]=1;
1737  // use this special ordering: like ringorder_a, except that pFDeg, pWeights
1738  // ignore it
1739  ord[0] = ringorder_aa;
1740  }
1741  // fill in tmp ring to get back the data later on
1742  tmpR = rCopy0(origR,FALSE,FALSE); // qring==NULL
1743  //rUnComplete(tmpR);
1744  tmpR->p_Procs=NULL;
1745  tmpR->order = ord;
1746  tmpR->block0 = block0;
1747  tmpR->block1 = block1;
1748  tmpR->wvhdl = wv;
1749  rComplete(tmpR, 1);
1750 
1751 #ifdef HAVE_PLURAL
1752  /* update nc structure on tmpR */
1753  if (rIsPluralRing(origR))
1754  {
1755  if ( nc_rComplete(origR, tmpR, false) ) // no quotient ideal!
1756  {
1757  WerrorS("no elimination is possible: ordering condition is violated");
1758  // cleanup
1759  rDelete(tmpR);
1760  if (w!=NULL)
1761  delete w;
1762  return NULL;
1763  }
1764  }
1765 #endif
1766  // change into the new ring
1767  //pChangeRing((currRing->N),currRing->OrdSgn,ord,block0,block1,wv);
1768  rChangeCurrRing(tmpR);
1769 
1770  //h = idInit(IDELEMS(h1),h1->rank);
1771  // fetch data from the old ring
1772  //for (k=0;k<IDELEMS(h1);k++) h->m[k] = prCopyR( h1->m[k], origR);
1773  h=idrCopyR(h1,origR,currRing);
1774  if (origR->qideal!=NULL)
1775  {
1776  WarnS("eliminate in q-ring: experimental");
1777  ideal q=idrCopyR(origR->qideal,origR,currRing);
1778  ideal s=idSimpleAdd(h,q);
1779  idDelete(&h);
1780  idDelete(&q);
1781  h=s;
1782  }
1783  // compute GB
1784  if ((alg!=GbDefault)
1785  && (alg!=GbGroebner)
1786  && (alg!=GbModstd)
1787  && (alg!=GbSlimgb)
1788  && (alg!=GbSba)
1789  && (alg!=GbStd))
1790  {
1791  WarnS("wrong algorithm for GB");
1792  alg=GbDefault;
1793  }
1794  BITSET save2;
1795  SI_SAVE_OPT2(save2);
1797  hh=idGroebner(h,0,alg,hilb);
1798  SI_RESTORE_OPT2(save2);
1799  // go back to the original ring
1800  rChangeCurrRing(origR);
1801  i = IDELEMS(hh)-1;
1802  while ((i >= 0) && (hh->m[i] == NULL)) i--;
1803  j = -1;
1804  // fetch data from temp ring
1805  for (k=0; k<=i; k++)
1806  {
1807  l=(currRing->N);
1808  while ((l>0) && (p_GetExp( hh->m[k],l,tmpR)*pGetExp(delVar,l)==0)) l--;
1809  if (l==0)
1810  {
1811  j++;
1812  if (j >= IDELEMS(h3))
1813  {
1814  pEnlargeSet(&(h3->m),IDELEMS(h3),16);
1815  IDELEMS(h3) += 16;
1816  }
1817  h3->m[j] = prMoveR( hh->m[k], tmpR,origR);
1818  hh->m[k] = NULL;
1819  }
1820  }
1821  id_Delete(&hh, tmpR);
1822  idSkipZeroes(h3);
1823  rDelete(tmpR);
1824  if (w!=NULL)
1825  delete w;
1826  return h3;
1827 }
int BOOLEAN
Definition: auxiliary.h:87
#define TRUE
Definition: auxiliary.h:100
#define FALSE
Definition: auxiliary.h:96
int l
Definition: cfEzgcd.cc:100
const CanonicalForm int s
Definition: facAbsFact.cc:51
static ideal idGroebner(ideal temp, int syzComp, GbVariant alg, intvec *hilb=NULL, intvec *w=NULL, tHomog hom=testHomog)
Definition: ideals.cc:201
#define idSimpleAdd(A, B)
Definition: ideals.h:42
static BOOLEAN idHomModule(ideal m, ideal Q, intvec **w)
Definition: ideals.h:96
ideal idCopy(ideal A)
Definition: ideals.h:60
@ nc_skew
Definition: nc.h:16
@ nc_exterior
Definition: nc.h:21
BOOLEAN nc_CheckSubalgebra(poly PolyVar, ring r)
Definition: old.gring.cc:2568
static nc_type & ncRingType(nc_struct *p)
Definition: nc.h:159
#define omAlloc(size)
Definition: omAllocDecl.h:210
#define omMemDup(s)
Definition: omAllocDecl.h:264
VAR unsigned si_opt_2
Definition: options.c:6
#define SI_SAVE_OPT2(A)
Definition: options.h:22
#define SI_RESTORE_OPT2(A)
Definition: options.h:25
#define TEST_OPT_RETURN_SB
Definition: options.h:112
#define V_IDELIM
Definition: options.h:70
int p_Weight(int i, const ring r)
Definition: p_polys.cc:700
void pEnlargeSet(poly **p, int l, int increment)
Definition: p_polys.cc:3766
#define pWeight(i)
Definition: polys.h:280
#define pGetExp(p, i)
Exponent.
Definition: polys.h:41
poly prMoveR(poly &p, ring src_r, ring dest_r)
Definition: prCopy.cc:89
ideal idrCopyR(ideal id, ring src_r, ring dest_r)
Definition: prCopy.cc:191
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:3400
BOOLEAN nc_rComplete(const ring src, ring dest, bool bSetupQuotient)
Definition: ring.cc:5654
ring rCopy0(const ring r, BOOLEAN copy_qideal, BOOLEAN copy_ordering)
Definition: ring.cc:1363
void rDelete(ring r)
unconditionally deletes fields in r
Definition: ring.cc:449
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
Definition: ring.h:400
rRingOrder_t
order stuff
Definition: ring.h:68
@ ringorder_a
Definition: ring.h:70
@ ringorder_C
Definition: ring.h:73
@ ringorder_dp
Definition: ring.h:78
@ ringorder_aa
for idElimination, like a, except pFDeg, pWeigths ignore it
Definition: ring.h:91
@ ringorder_ws
Definition: ring.h:86
@ ringorder_wp
Definition: ring.h:81
tHomog
Definition: structs.h:40
#define BITSET
Definition: structs.h:20
THREAD_VAR double(* wFunctional)(int *degw, int *lpol, int npol, double *rel, double wx, double wNsqr)
Definition: weight.cc:20
void wCall(poly *s, int sl, int *x, double wNsqr, const ring R)
Definition: weight.cc:108
double wFunctionalBuch(int *degw, int *lpol, int npol, double *rel, double wx, double wNsqr)
Definition: weight0.c:78

◆ idFreeModule()

ideal idFreeModule ( int  i)
inline

Definition at line 111 of file ideals.h.

112 {
113  return id_FreeModule (i, currRing);
114 }
ideal id_FreeModule(int i, const ring r)
the free module of rank i

◆ idGetNextChoise()

void idGetNextChoise ( int  r,
int  end,
BOOLEAN endch,
int *  choise 
)

Definition at line 864 of file simpleideals.cc.

865 {
866  int i = r-1,j;
867  while ((i >= 0) && (choise[i] == end))
868  {
869  i--;
870  end--;
871  }
872  if (i == -1)
873  *endch = TRUE;
874  else
875  {
876  choise[i]++;
877  for (j=i+1; j<r; j++)
878  {
879  choise[j] = choise[i]+j-i;
880  }
881  *endch = FALSE;
882  }
883 }

◆ idGetNumberOfChoise()

int idGetNumberOfChoise ( int  t,
int  d,
int  begin,
int  end,
int *  choise 
)

Definition at line 890 of file simpleideals.cc.

891 {
892  int * localchoise,i,result=0;
893  BOOLEAN b=FALSE;
894 
895  if (d<=1) return 1;
896  localchoise=(int*)omAlloc((d-1)*sizeof(int));
897  idInitChoise(d-1,begin,end,&b,localchoise);
898  while (!b)
899  {
900  result++;
901  i = 0;
902  while ((i<t) && (localchoise[i]==choise[i])) i++;
903  if (i>=t)
904  {
905  i = t+1;
906  while ((i<d) && (localchoise[i-1]==choise[i])) i++;
907  if (i>=d)
908  {
909  omFreeSize((ADDRESS)localchoise,(d-1)*sizeof(int));
910  return result;
911  }
912  }
913  idGetNextChoise(d-1,end,&b,localchoise);
914  }
915  omFreeSize((ADDRESS)localchoise,(d-1)*sizeof(int));
916  return 0;
917 }
CanonicalForm b
Definition: cfModGcd.cc:4105
void idGetNextChoise(int r, int end, BOOLEAN *endch, int *choise)
void idInitChoise(int r, int beg, int end, BOOLEAN *endch, int *choise)

◆ idHead()

ideal idHead ( ideal  h)

◆ idHomIdeal()

static BOOLEAN idHomIdeal ( ideal  id,
ideal  Q = NULL 
)
inlinestatic

Definition at line 91 of file ideals.h.

92 {
93  return id_HomIdeal(id, Q, currRing);
94 }
STATIC_VAR jList * Q
Definition: janet.cc:30
BOOLEAN id_HomIdeal(ideal id, ideal Q, const ring r)

◆ idHomModule()

static BOOLEAN idHomModule ( ideal  m,
ideal  Q,
intvec **  w 
)
inlinestatic

Definition at line 96 of file ideals.h.

97 {
98  return id_HomModule(m, Q, w, currRing);
99 }
BOOLEAN id_HomModule(ideal m, ideal Q, intvec **w, const ring R)

◆ idInitChoise()

void idInitChoise ( int  r,
int  beg,
int  end,
BOOLEAN endch,
int *  choise 
)

Definition at line 842 of file simpleideals.cc.

843 {
844  /*returns the first choise of r numbers between beg and end*/
845  int i;
846  for (i=0; i<r; i++)
847  {
848  choise[i] = 0;
849  }
850  if (r <= end-beg+1)
851  for (i=0; i<r; i++)
852  {
853  choise[i] = beg+i;
854  }
855  if (r > end-beg+1)
856  *endch = TRUE;
857  else
858  *endch = FALSE;
859 }

◆ idInsertPoly()

BOOLEAN idInsertPoly ( ideal  h1,
poly  h2 
)

insert h2 into h1 (if h2 is not the zero polynomial) return TRUE iff h2 was indeed inserted

Definition at line 649 of file simpleideals.cc.

650 {
651  if (h2==NULL) return FALSE;
652  assume (h1 != NULL);
653 
654  int j = IDELEMS(h1) - 1;
655 
656  while ((j >= 0) && (h1->m[j] == NULL)) j--;
657  j++;
658  if (j==IDELEMS(h1))
659  {
660  pEnlargeSet(&(h1->m),IDELEMS(h1),16);
661  IDELEMS(h1)+=16;
662  }
663  h1->m[j]=h2;
664  return TRUE;
665 }

◆ idInsertPolyOnPos()

BOOLEAN idInsertPolyOnPos ( ideal  I,
poly  p,
int  pos 
)

insert p into I on position pos

Definition at line 668 of file simpleideals.cc.

669 {
670  if (p==NULL) return FALSE;
671  assume (I != NULL);
672 
673  int j = IDELEMS(I) - 1;
674 
675  while ((j >= 0) && (I->m[j] == NULL)) j--;
676  j++;
677  if (j==IDELEMS(I))
678  {
679  pEnlargeSet(&(I->m),IDELEMS(I),IDELEMS(I)+1);
680  IDELEMS(I)+=1;
681  }
682  for(j = IDELEMS(I)-1;j>pos;j--)
683  I->m[j] = I->m[j-1];
684  I->m[pos]=p;
685  return TRUE;
686 }

◆ idInsertPolyWithTests()

BOOLEAN idInsertPolyWithTests ( ideal  h1,
const int  validEntries,
const poly  h2,
const bool  zeroOk,
const bool  duplicateOk 
)
inline

Definition at line 75 of file ideals.h.

76 {
77  return id_InsertPolyWithTests (h1, validEntries, h2, zeroOk, duplicateOk, currRing);
78 }
BOOLEAN id_InsertPolyWithTests(ideal h1, const int validEntries, const poly h2, const bool zeroOk, const bool duplicateOk, const ring r)
insert h2 into h1 depending on the two boolean parameters:

◆ idIs0()

BOOLEAN idIs0 ( ideal  h)

returns true if h is the zero ideal

Definition at line 777 of file simpleideals.cc.

778 {
779  assume (h != NULL); // will fail :(
780 // if (h == NULL) return TRUE;
781 
782  for( int i = IDELEMS(h)-1; i >= 0; i-- )
783  if(h->m[i] != NULL)
784  return FALSE;
785 
786  return TRUE;
787 
788 }

◆ idIsSubModule()

BOOLEAN idIsSubModule ( ideal  id1,
ideal  id2 
)

Definition at line 2036 of file ideals.cc.

2037 {
2038  int i;
2039  poly p;
2040 
2041  if (idIs0(id1)) return TRUE;
2042  for (i=0;i<IDELEMS(id1);i++)
2043  {
2044  if (id1->m[i] != NULL)
2045  {
2046  p = kNF(id2,currRing->qideal,id1->m[i]);
2047  if (p != NULL)
2048  {
2049  p_Delete(&p,currRing);
2050  return FALSE;
2051  }
2052  }
2053  }
2054  return TRUE;
2055 }
poly kNF(ideal F, ideal Q, poly p, int syzComp, int lazyReduce)
Definition: kstd1.cc:3169

◆ idIsZeroDim()

static BOOLEAN idIsZeroDim ( ideal  i)
inlinestatic

Definition at line 176 of file ideals.h.

177 {
178  return id_IsZeroDim(i, currRing);
179 }
BOOLEAN id_IsZeroDim(ideal I, const ring r)

◆ idKeepFirstK()

void idKeepFirstK ( ideal  ide,
const int  k 
)

keeps the first k (>= 1) entries of the given ideal (Note that the kept polynomials may be zero.)

Definition at line 2912 of file ideals.cc.

2913 {
2914  for (int i = IDELEMS(id)-1; i >= k; i--)
2915  {
2916  if (id->m[i] != NULL) pDelete(&id->m[i]);
2917  }
2918  int kk=k;
2919  if (k==0) kk=1; /* ideals must have at least one element(0)*/
2920  pEnlargeSet(&(id->m), IDELEMS(id), kk-IDELEMS(id));
2921  IDELEMS(id) = kk;
2922 }

◆ idLift()

ideal idLift ( ideal  mod,
ideal  submod,
ideal *  rest = NULL,
BOOLEAN  goodShape = FALSE,
BOOLEAN  isSB = TRUE,
BOOLEAN  divide = FALSE,
matrix unit = NULL,
GbVariant  a = GbDefault 
)

Definition at line 1099 of file ideals.cc.

1101 {
1102  int lsmod =id_RankFreeModule(submod,currRing), j, k;
1103  int comps_to_add=0;
1104  int idelems_mod=IDELEMS(mod);
1105  int idelems_submod=IDELEMS(submod);
1106  poly p;
1107 
1108  if (idIs0(submod))
1109  {
1110  if (rest!=NULL)
1111  {
1112  *rest=idInit(1,mod->rank);
1113  }
1114  idLift_setUnit(idelems_submod,unit);
1115  return idInit(1,idelems_mod);
1116  }
1117  if (idIs0(mod)) /* and not idIs0(submod) */
1118  {
1119  if (rest!=NULL)
1120  {
1121  *rest=idCopy(submod);
1122  idLift_setUnit(idelems_submod,unit);
1123  return idInit(1,idelems_mod);
1124  }
1125  else
1126  {
1127  WerrorS("2nd module does not lie in the first");
1128  return NULL;
1129  }
1130  }
1131  if (unit!=NULL)
1132  {
1133  comps_to_add = idelems_submod;
1134  while ((comps_to_add>0) && (submod->m[comps_to_add-1]==NULL))
1135  comps_to_add--;
1136  }
1138  if ((k!=0) && (lsmod==0)) lsmod=1;
1139  k=si_max(k,(int)mod->rank);
1140  if (k<submod->rank) { WarnS("rk(submod) > rk(mod) ?");k=submod->rank; }
1141 
1142  ring orig_ring=currRing;
1143  ring syz_ring=rAssure_SyzOrder(orig_ring,TRUE);
1144  rSetSyzComp(k,syz_ring);
1145  rChangeCurrRing(syz_ring);
1146 
1147  ideal s_mod, s_temp;
1148  if (orig_ring != syz_ring)
1149  {
1150  s_mod = idrCopyR_NoSort(mod,orig_ring,syz_ring);
1151  s_temp = idrCopyR_NoSort(submod,orig_ring,syz_ring);
1152  }
1153  else
1154  {
1155  s_mod = mod;
1156  s_temp = idCopy(submod);
1157  }
1158  ideal s_h3;
1159  if (isSB)
1160  {
1161  s_h3 = idCopy(s_mod);
1162  idPrepareStd(s_h3, k+comps_to_add);
1163  }
1164  else
1165  {
1166  s_h3 = idPrepare(s_mod,NULL,(tHomog)FALSE,k+comps_to_add,NULL,alg);
1167  }
1168  if (!goodShape)
1169  {
1170  for (j=0;j<IDELEMS(s_h3);j++)
1171  {
1172  if ((s_h3->m[j] != NULL) && (pMinComp(s_h3->m[j]) > k))
1173  p_Delete(&(s_h3->m[j]),currRing);
1174  }
1175  }
1176  idSkipZeroes(s_h3);
1177  if (lsmod==0)
1178  {
1179  id_Shift(s_temp,1,currRing);
1180  }
1181  if (unit!=NULL)
1182  {
1183  for(j = 0;j<comps_to_add;j++)
1184  {
1185  p = s_temp->m[j];
1186  if (p!=NULL)
1187  {
1188  while (pNext(p)!=NULL) pIter(p);
1189  pNext(p) = pOne();
1190  pIter(p);
1191  pSetComp(p,1+j+k);
1192  pSetmComp(p);
1193  p = pNeg(p);
1194  }
1195  }
1196  s_temp->rank += (k+comps_to_add);
1197  }
1198  ideal s_result = kNF(s_h3,currRing->qideal,s_temp,k);
1199  s_result->rank = s_h3->rank;
1200  ideal s_rest = idInit(IDELEMS(s_result),k);
1201  idDelete(&s_h3);
1202  idDelete(&s_temp);
1203 
1204  for (j=0;j<IDELEMS(s_result);j++)
1205  {
1206  if (s_result->m[j]!=NULL)
1207  {
1208  if (pGetComp(s_result->m[j])<=k)
1209  {
1210  if (!divide)
1211  {
1212  if (rest==NULL)
1213  {
1214  if (isSB)
1215  {
1216  WarnS("first module not a standardbasis\n"
1217  "// ** or second not a proper submodule");
1218  }
1219  else
1220  WerrorS("2nd module does not lie in the first");
1221  }
1222  idDelete(&s_result);
1223  idDelete(&s_rest);
1224  if(syz_ring!=orig_ring)
1225  {
1226  idDelete(&s_mod);
1227  rChangeCurrRing(orig_ring);
1228  rDelete(syz_ring);
1229  }
1230  if (unit!=NULL)
1231  {
1232  idLift_setUnit(idelems_submod,unit);
1233  }
1234  if (rest!=NULL) *rest=idCopy(submod);
1235  s_result=idInit(idelems_submod,idelems_mod);
1236  return s_result;
1237  }
1238  else
1239  {
1240  p = s_rest->m[j] = s_result->m[j];
1241  while ((pNext(p)!=NULL) && (pGetComp(pNext(p))<=k)) pIter(p);
1242  s_result->m[j] = pNext(p);
1243  pNext(p) = NULL;
1244  }
1245  }
1246  p_Shift(&(s_result->m[j]),-k,currRing);
1247  pNeg(s_result->m[j]);
1248  }
1249  }
1250  if ((lsmod==0) && (s_rest!=NULL))
1251  {
1252  for (j=IDELEMS(s_rest);j>0;j--)
1253  {
1254  if (s_rest->m[j-1]!=NULL)
1255  {
1256  p_Shift(&(s_rest->m[j-1]),-1,currRing);
1257  }
1258  }
1259  }
1260  if(syz_ring!=orig_ring)
1261  {
1262  idDelete(&s_mod);
1263  rChangeCurrRing(orig_ring);
1264  s_result = idrMoveR_NoSort(s_result, syz_ring, orig_ring);
1265  s_rest = idrMoveR_NoSort(s_rest, syz_ring, orig_ring);
1266  rDelete(syz_ring);
1267  }
1268  if (rest!=NULL)
1269  {
1270  s_rest->rank=mod->rank;
1271  *rest = s_rest;
1272  }
1273  else
1274  idDelete(&s_rest);
1275  if (unit!=NULL)
1276  {
1277  *unit=mpNew(idelems_submod,idelems_submod);
1278  int i;
1279  for(i=0;i<IDELEMS(s_result);i++)
1280  {
1281  poly p=s_result->m[i];
1282  poly q=NULL;
1283  while(p!=NULL)
1284  {
1285  if(pGetComp(p)<=comps_to_add)
1286  {
1287  pSetComp(p,0);
1288  if (q!=NULL)
1289  {
1290  pNext(q)=pNext(p);
1291  }
1292  else
1293  {
1294  pIter(s_result->m[i]);
1295  }
1296  pNext(p)=NULL;
1297  MATELEM(*unit,i+1,i+1)=pAdd(MATELEM(*unit,i+1,i+1),p);
1298  if(q!=NULL) p=pNext(q);
1299  else p=s_result->m[i];
1300  }
1301  else
1302  {
1303  q=p;
1304  pIter(p);
1305  }
1306  }
1307  p_Shift(&s_result->m[i],-comps_to_add,currRing);
1308  }
1309  }
1310  s_result->rank=idelems_mod;
1311  return s_result;
1312 }
static int si_max(const int a, const int b)
Definition: auxiliary.h:124
CF_NO_INLINE FACTORY_PUBLIC CanonicalForm mod(const CanonicalForm &, const CanonicalForm &)
CanonicalForm divide(const CanonicalForm &ff, const CanonicalForm &f, const CFList &as)
static void idPrepareStd(ideal s_temp, int k)
Definition: ideals.cc:1041
static void idLift_setUnit(int e_mod, matrix *unit)
Definition: ideals.cc:1082
static ideal idPrepare(ideal h1, ideal h11, tHomog hom, int syzcomp, intvec **w, GbVariant alg)
Definition: ideals.cc:607
#define pNext(p)
Definition: monomials.h:36
void p_Shift(poly *p, int i, const ring r)
shifts components of the vector p by i
Definition: p_polys.cc:4734
#define pNeg(p)
Definition: polys.h:198
#define pGetComp(p)
Component.
Definition: polys.h:37
#define pSetComp(p, v)
Definition: polys.h:38
#define pSetmComp(p)
TODO:
Definition: polys.h:273
#define pOne()
Definition: polys.h:315
#define pMinComp(p)
Definition: polys.h:300
ideal idrMoveR_NoSort(ideal &id, ring src_r, ring dest_r)
Definition: prCopy.cc:260
ideal idrCopyR_NoSort(ideal id, ring src_r, ring dest_r)
Definition: prCopy.cc:204
ring rAssure_SyzOrder(const ring r, BOOLEAN complete)
Definition: ring.cc:4418
void rSetSyzComp(int k, const ring r)
Definition: ring.cc:5033
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
void id_Shift(ideal M, int s, const ring r)

◆ idLiftStd()

ideal idLiftStd ( ideal  h1,
matrix m,
tHomog  h = testHomog,
ideal *  syz = NULL,
GbVariant  a = GbDefault,
ideal  h11 = NULL 
)

Definition at line 976 of file ideals.cc.

978 {
979  int inputIsIdeal=id_RankFreeModule(h1,currRing);
980  long k;
981  intvec *w=NULL;
982 
983  idDelete((ideal*)T);
984  BOOLEAN lift3=FALSE;
985  if (S!=NULL) { lift3=TRUE; idDelete(S); }
986  if (idIs0(h1))
987  {
988  *T=mpNew(1,0);
989  if (lift3)
990  {
991  *S=idFreeModule(IDELEMS(h1));
992  }
993  return idInit(1,h1->rank);
994  }
995 
996  BITSET save2;
997  SI_SAVE_OPT2(save2);
998 
999  k=si_max(1,inputIsIdeal);
1000 
1001  if ((!lift3)&&(!TEST_OPT_RETURN_SB)) si_opt_2 |=Sy_bit(V_IDLIFT);
1002 
1003  ring orig_ring = currRing;
1004  ring syz_ring = rAssure_SyzOrder(orig_ring,TRUE);
1005  rSetSyzComp(k,syz_ring);
1006  rChangeCurrRing(syz_ring);
1007 
1008  ideal s_h1;
1009 
1010  if (orig_ring != syz_ring)
1011  s_h1 = idrCopyR_NoSort(h1,orig_ring,syz_ring);
1012  else
1013  s_h1 = h1;
1014  ideal s_h11=NULL;
1015  if (h11!=NULL)
1016  {
1017  s_h11=idrCopyR_NoSort(h11,orig_ring,syz_ring);
1018  }
1019 
1020 
1021  ideal s_h3=idPrepare(s_h1,s_h11,hi,k,&w,alg); // main (syz) GB computation
1022 
1023 
1024  if (w!=NULL) delete w;
1025  if (syz_ring!=orig_ring)
1026  {
1027  idDelete(&s_h1);
1028  if (s_h11!=NULL) idDelete(&s_h11);
1029  }
1030 
1031  if (S!=NULL) (*S)=idInit(IDELEMS(s_h3),IDELEMS(h1));
1032 
1033  s_h3=idExtractG_T_S(s_h3,T,S,k,IDELEMS(h1),inputIsIdeal,orig_ring,syz_ring);
1034 
1035  if (syz_ring!=orig_ring) rDelete(syz_ring);
1036  s_h3->rank=h1->rank;
1037  SI_RESTORE_OPT2(save2);
1038  return s_h3;
1039 }
ideal idExtractG_T_S(ideal s_h3, matrix *T, ideal *S, long syzComp, int h1_size, BOOLEAN inputIsIdeal, const ring oring, const ring sring)
Definition: ideals.cc:709
ideal idFreeModule(int i)
Definition: ideals.h:111
STATIC_VAR jList * T
Definition: janet.cc:30
#define Sy_bit(x)
Definition: options.h:31
#define V_IDLIFT
Definition: options.h:62

◆ idLiftW()

void idLiftW ( ideal  P,
ideal  Q,
int  n,
matrix T,
ideal &  R,
int *  w = NULL 
)

Definition at line 1318 of file ideals.cc.

1319 {
1320  long N=0;
1321  int i;
1322  for(i=IDELEMS(Q)-1;i>=0;i--)
1323  if(w==NULL)
1324  N=si_max(N,p_Deg(Q->m[i],currRing));
1325  else
1326  N=si_max(N,p_DegW(Q->m[i],w,currRing));
1327  N+=n;
1328 
1329  T=mpNew(IDELEMS(Q),IDELEMS(P));
1330  R=idInit(IDELEMS(P),P->rank);
1331 
1332  for(i=IDELEMS(P)-1;i>=0;i--)
1333  {
1334  poly p;
1335  if(w==NULL)
1336  p=ppJet(P->m[i],N);
1337  else
1338  p=ppJetW(P->m[i],N,w);
1339 
1340  int j=IDELEMS(Q)-1;
1341  while(p!=NULL)
1342  {
1343  if(pDivisibleBy(Q->m[j],p))
1344  {
1345  poly p0=p_DivideM(pHead(p),pHead(Q->m[j]),currRing);
1346  if(w==NULL)
1347  p=pJet(pSub(p,ppMult_mm(Q->m[j],p0)),N);
1348  else
1349  p=pJetW(pSub(p,ppMult_mm(Q->m[j],p0)),N,w);
1350  pNormalize(p);
1351  if(((w==NULL)&&(p_Deg(p0,currRing)>n))||((w!=NULL)&&(p_DegW(p0,w,currRing)>n)))
1352  p_Delete(&p0,currRing);
1353  else
1354  MATELEM(T,j+1,i+1)=pAdd(MATELEM(T,j+1,i+1),p0);
1355  j=IDELEMS(Q)-1;
1356  }
1357  else
1358  {
1359  if(j==0)
1360  {
1361  poly p0=p;
1362  pIter(p);
1363  pNext(p0)=NULL;
1364  if(((w==NULL)&&(p_Deg(p0,currRing)>n))
1365  ||((w!=NULL)&&(p_DegW(p0,w,currRing)>n)))
1366  p_Delete(&p0,currRing);
1367  else
1368  R->m[i]=pAdd(R->m[i],p0);
1369  j=IDELEMS(Q)-1;
1370  }
1371  else
1372  j--;
1373  }
1374  }
1375  }
1376 }
poly p_DivideM(poly a, poly b, const ring r)
Definition: p_polys.cc:1565
long p_DegW(poly p, const int *w, const ring R)
Definition: p_polys.cc:685
long p_Deg(poly a, const ring r)
Definition: p_polys.cc:582
#define ppJet(p, m)
Definition: polys.h:367
#define pHead(p)
returns newly allocated copy of Lm(p), coef is copied, next=NULL, p might be NULL
Definition: polys.h:67
#define ppMult_mm(p, m)
Definition: polys.h:201
#define pJet(p, m)
Definition: polys.h:368
#define pSub(a, b)
Definition: polys.h:287
#define ppJetW(p, m, iv)
Definition: polys.h:369
#define pJetW(p, m, iv)
Definition: polys.h:370
#define pNormalize(p)
Definition: polys.h:317
#define pDivisibleBy(a, b)
returns TRUE, if leading monom of a divides leading monom of b i.e., if there exists a expvector c > ...
Definition: polys.h:138
#define R
Definition: sirandom.c:27

◆ idMinBase()

ideal idMinBase ( ideal  h1)

Definition at line 51 of file ideals.cc.

52 {
53  ideal h2, h3,h4,e;
54  int j,k;
55  int i,l,ll;
56  intvec * wth;
57  BOOLEAN homog;
59  {
60  WarnS("minbase applies only to the local or homogeneous case over coefficient fields");
61  e=idCopy(h1);
62  return e;
63  }
64  homog = idHomModule(h1,currRing->qideal,&wth);
66  {
67  if(!homog)
68  {
69  WarnS("minbase applies only to the local or homogeneous case over coefficient fields");
70  e=idCopy(h1);
71  return e;
72  }
73  else
74  {
75  ideal re=kMin_std(h1,currRing->qideal,(tHomog)homog,&wth,h2,NULL,0,3);
76  idDelete(&re);
77  return h2;
78  }
79  }
80  e=idInit(1,h1->rank);
81  if (idIs0(h1))
82  {
83  return e;
84  }
85  pEnlargeSet(&(e->m),IDELEMS(e),15);
86  IDELEMS(e) = 16;
87  h2 = kStd(h1,currRing->qideal,isNotHomog,NULL);
88  h3 = idMaxIdeal(1);
89  h4=idMult(h2,h3);
90  idDelete(&h3);
91  h3=kStd(h4,currRing->qideal,isNotHomog,NULL);
92  k = IDELEMS(h3);
93  while ((k > 0) && (h3->m[k-1] == NULL)) k--;
94  j = -1;
95  l = IDELEMS(h2);
96  while ((l > 0) && (h2->m[l-1] == NULL)) l--;
97  for (i=l-1; i>=0; i--)
98  {
99  if (h2->m[i] != NULL)
100  {
101  ll = 0;
102  while ((ll < k) && ((h3->m[ll] == NULL)
103  || !pDivisibleBy(h3->m[ll],h2->m[i])))
104  ll++;
105  if (ll >= k)
106  {
107  j++;
108  if (j > IDELEMS(e)-1)
109  {
110  pEnlargeSet(&(e->m),IDELEMS(e),16);
111  IDELEMS(e) += 16;
112  }
113  e->m[j] = pCopy(h2->m[i]);
114  }
115  }
116  }
117  idDelete(&h2);
118  idDelete(&h3);
119  idDelete(&h4);
120  if (currRing->qideal!=NULL)
121  {
122  h3=idInit(1,e->rank);
123  h2=kNF(h3,currRing->qideal,e);
124  idDelete(&h3);
125  idDelete(&e);
126  e=h2;
127  }
128  idSkipZeroes(e);
129  return e;
130 }
static ideal idMult(ideal h1, ideal h2)
hh := h1 * h2
Definition: ideals.h:84
#define idMaxIdeal(D)
initialise the maximal ideal (at 0)
Definition: ideals.h:33
ideal kMin_std(ideal F, ideal Q, tHomog h, intvec **w, ideal &M, intvec *hilb, int syzComp, int reduced)
Definition: kstd1.cc:3020
#define pCopy(p)
return a copy of the poly
Definition: polys.h:185
static BOOLEAN rField_is_Ring(const ring r)
Definition: ring.h:486
BOOLEAN rHasGlobalOrdering(const ring r)
Definition: ring.h:761
@ isNotHomog
Definition: structs.h:41

◆ idMinEmbedding()

ideal idMinEmbedding ( ideal  arg,
BOOLEAN  inPlace = FALSE,
intvec **  w = NULL 
)

Definition at line 2675 of file ideals.cc.

2676 {
2677  if (idIs0(arg)) return idInit(1,arg->rank);
2678  int i,next_gen,next_comp;
2679  ideal res=arg;
2680  if (!inPlace) res = idCopy(arg);
2681  res->rank=si_max(res->rank,id_RankFreeModule(res,currRing));
2682  int *red_comp=(int*)omAlloc((res->rank+1)*sizeof(int));
2683  for (i=res->rank;i>=0;i--) red_comp[i]=i;
2684 
2685  int del=0;
2686  loop
2687  {
2688  next_gen = id_ReadOutPivot(res, &next_comp, currRing);
2689  if (next_gen<0) break;
2690  del++;
2691  syGaussForOne(res,next_gen,next_comp,0,IDELEMS(res));
2692  for(i=next_comp+1;i<=arg->rank;i++) red_comp[i]--;
2693  if ((w !=NULL)&&(*w!=NULL))
2694  {
2695  for(i=next_comp;i<(*w)->length();i++) (**w)[i-1]=(**w)[i];
2696  }
2697  }
2698 
2699  idDeleteComps(res,red_comp,del);
2700  idSkipZeroes(res);
2701  omFree(red_comp);
2702 
2703  if ((w !=NULL)&&(*w!=NULL) &&(del>0))
2704  {
2705  int nl=si_max((*w)->length()-del,1);
2706  intvec *wtmp=new intvec(nl);
2707  for(i=0;i<res->rank;i++) (*wtmp)[i]=(**w)[i];
2708  delete *w;
2709  *w=wtmp;
2710  }
2711  return res;
2712 }
static void idDeleteComps(ideal arg, int *red_comp, int del)
Definition: ideals.cc:2648
#define omFree(addr)
Definition: omAllocDecl.h:261
int id_ReadOutPivot(ideal arg, int *comp, const ring r)
#define loop
Definition: structs.h:80
void syGaussForOne(ideal syz, int elnum, int ModComp, int from, int till)
Definition: syz.cc:218

◆ idMinors()

ideal idMinors ( matrix  a,
int  ar,
ideal  R = NULL 
)

compute all ar-minors of the matrix a the caller of mpRecMin the elements of the result are not in R (if R!=NULL)

Definition at line 1968 of file ideals.cc.

1969 {
1970 
1971  const ring origR=currRing;
1972  id_Test((ideal)a, origR);
1973 
1974  const int r = a->nrows;
1975  const int c = a->ncols;
1976 
1977  if((ar<=0) || (ar>r) || (ar>c))
1978  {
1979  Werror("%d-th minor, matrix is %dx%d",ar,r,c);
1980  return NULL;
1981  }
1982 
1983  ideal h = id_Matrix2Module(mp_Copy(a,origR),origR);
1984  long bound = sm_ExpBound(h,c,r,ar,origR);
1985  id_Delete(&h, origR);
1986 
1987  ring tmpR = sm_RingChange(origR,bound);
1988 
1989  matrix b = mpNew(r,c);
1990 
1991  for (int i=r*c-1;i>=0;i--)
1992  if (a->m[i] != NULL)
1993  b->m[i] = prCopyR(a->m[i],origR,tmpR);
1994 
1995  id_Test( (ideal)b, tmpR);
1996 
1997  if (R!=NULL)
1998  {
1999  R = idrCopyR(R,origR,tmpR); // TODO: overwrites R? memory leak?
2000  //if (ar>1) // otherwise done in mpMinorToResult
2001  //{
2002  // matrix bb=(matrix)kNF(R,currRing->qideal,(ideal)b);
2003  // bb->rank=b->rank; bb->nrows=b->nrows; bb->ncols=b->ncols;
2004  // idDelete((ideal*)&b); b=bb;
2005  //}
2006  id_Test( R, tmpR);
2007  }
2008 
2009  int size=binom(r,ar)*binom(c,ar);
2010  ideal result = idInit(size,1);
2011 
2012  int elems = 0;
2013 
2014  if(ar>1)
2015  mp_RecMin(ar-1,result,elems,b,r,c,NULL,R,tmpR);
2016  else
2017  mp_MinorToResult(result,elems,b,r,c,R,tmpR);
2018 
2019  id_Test( (ideal)b, tmpR);
2020 
2021  id_Delete((ideal *)&b, tmpR);
2022 
2023  if (R!=NULL) id_Delete(&R,tmpR);
2024 
2025  rChangeCurrRing(origR);
2026  result = idrMoveR(result,tmpR,origR);
2027  sm_KillModifiedRing(tmpR);
2028  idTest(result);
2029  return result;
2030 }
int size(const CanonicalForm &f, const Variable &v)
int size ( const CanonicalForm & f, const Variable & v )
Definition: cf_ops.cc:600
static CanonicalForm bound(const CFMatrix &M)
Definition: cf_linsys.cc:460
int nrows
Definition: matpol.h:20
int ncols
Definition: matpol.h:21
int binom(int n, int r)
#define idTest(id)
Definition: ideals.h:47
matrix mp_Copy(matrix a, const ring r)
copies matrix a (from ring r to r)
Definition: matpol.cc:64
void mp_MinorToResult(ideal result, int &elems, matrix a, int r, int c, ideal R, const ring)
entries of a are minors and go to result (only if not in R)
Definition: matpol.cc:1507
void mp_RecMin(int ar, ideal result, int &elems, matrix a, int lr, int lc, poly barDiv, ideal R, const ring r)
produces recursively the ideal of all arxar-minors of a
Definition: matpol.cc:1603
ideal idrMoveR(ideal &id, ring src_r, ring dest_r)
Definition: prCopy.cc:247
poly prCopyR(poly p, ring src_r, ring dest_r)
Definition: prCopy.cc:34
ideal id_Matrix2Module(matrix mat, const ring R)
converts mat to module, destroys mat
long sm_ExpBound(ideal m, int di, int ra, int t, const ring currRing)
Definition: sparsmat.cc:188
ring sm_RingChange(const ring origR, long bound)
Definition: sparsmat.cc:258
void sm_KillModifiedRing(ring r)
Definition: sparsmat.cc:289

◆ idModulo()

ideal idModulo ( ideal  h1,
ideal  h2,
tHomog  h = testHomog,
intvec **  w = NULL,
matrix T = NULL,
GbVariant  a = GbDefault 
)

Definition at line 2402 of file ideals.cc.

2403 {
2404 #ifdef HAVE_SHIFTBBA
2405  if (rIsLPRing(currRing))
2406  return idModuloLP(h2,h1,hom,w,T,alg);
2407 #endif
2408  intvec *wtmp=NULL;
2409  if (T!=NULL) idDelete((ideal*)T);
2410 
2411  int i,flength=0,slength,length;
2412 
2413  if (idIs0(h2))
2414  return idFreeModule(si_max(1,h2->ncols));
2415  if (!idIs0(h1))
2416  flength = id_RankFreeModule(h1,currRing);
2417  slength = id_RankFreeModule(h2,currRing);
2418  length = si_max(flength,slength);
2419  BOOLEAN inputIsIdeal=FALSE;
2420  if (length==0)
2421  {
2422  length = 1;
2423  inputIsIdeal=TRUE;
2424  }
2425  if ((w!=NULL)&&((*w)!=NULL))
2426  {
2427  //Print("input weights:");(*w)->show(1);PrintLn();
2428  int d;
2429  int k;
2430  wtmp=new intvec(length+IDELEMS(h2));
2431  for (i=0;i<length;i++)
2432  ((*wtmp)[i])=(**w)[i];
2433  for (i=0;i<IDELEMS(h2);i++)
2434  {
2435  poly p=h2->m[i];
2436  if (p!=NULL)
2437  {
2438  d = p_Deg(p,currRing);
2439  k= pGetComp(p);
2440  if (slength>0) k--;
2441  d +=((**w)[k]);
2442  ((*wtmp)[i+length]) = d;
2443  }
2444  }
2445  //Print("weights:");wtmp->show(1);PrintLn();
2446  }
2447  ideal s_temp1;
2448  ring orig_ring=currRing;
2449  ring syz_ring=rAssure_SyzOrder(orig_ring, TRUE);
2450  rSetSyzComp(length,syz_ring);
2451  {
2452  rChangeCurrRing(syz_ring);
2453  ideal s1,s2;
2454 
2455  if (syz_ring != orig_ring)
2456  {
2457  s1 = idrCopyR_NoSort(h1, orig_ring, syz_ring);
2458  s2 = idrCopyR_NoSort(h2, orig_ring, syz_ring);
2459  }
2460  else
2461  {
2462  s1=idCopy(h1);
2463  s2=idCopy(h2);
2464  }
2465 
2466  unsigned save_opt,save_opt2;
2467  SI_SAVE_OPT1(save_opt);
2468  SI_SAVE_OPT2(save_opt2);
2469  if (T==NULL) si_opt_1 |= Sy_bit(OPT_REDTAIL);
2471  s_temp1 = idPrepare(s2,s1,testHomog,length,w,alg);
2472  SI_RESTORE_OPT1(save_opt);
2473  SI_RESTORE_OPT2(save_opt2);
2474  }
2475 
2476  //if (wtmp!=NULL) Print("output weights:");wtmp->show(1);PrintLn();
2477  if ((w!=NULL) && (*w !=NULL) && (wtmp!=NULL))
2478  {
2479  delete *w;
2480  *w=new intvec(IDELEMS(h2));
2481  for (i=0;i<IDELEMS(h2);i++)
2482  ((**w)[i])=(*wtmp)[i+length];
2483  }
2484  if (wtmp!=NULL) delete wtmp;
2485 
2486  ideal result=idInit(IDELEMS(s_temp1),IDELEMS(h2));
2487  s_temp1=idExtractG_T_S(s_temp1,T,&result,length,IDELEMS(h2),inputIsIdeal,orig_ring,syz_ring);
2488 
2489  idDelete(&s_temp1);
2490  if (syz_ring!=orig_ring)
2491  {
2492  rDelete(syz_ring);
2493  }
2494  idTest(h2);
2495  idTest(h1);
2496  idTest(result);
2497  if (T!=NULL) idTest((ideal)*T);
2498  return result;
2499 }
ideal idModuloLP(ideal h2, ideal h1, tHomog, intvec **w, matrix *T, GbVariant alg)
Definition: ideals.cc:2209
static BOOLEAN length(leftv result, leftv arg)
Definition: interval.cc:257
VAR unsigned si_opt_1
Definition: options.c:5
#define OPT_REDTAIL_SYZ
Definition: options.h:87
#define OPT_REDTAIL
Definition: options.h:91
#define SI_SAVE_OPT1(A)
Definition: options.h:21
#define SI_RESTORE_OPT1(A)
Definition: options.h:24
static BOOLEAN rIsLPRing(const ring r)
Definition: ring.h:411

◆ idMult()

static ideal idMult ( ideal  h1,
ideal  h2 
)
inlinestatic

hh := h1 * h2

Definition at line 84 of file ideals.h.

85 {
86  return id_Mult(h1, h2, currRing);
87 }
ideal id_Mult(ideal h1, ideal h2, const ring R)
h1 * h2 one h_i must be an ideal (with at least one column) the other h_i may be a module (with no co...

◆ idMultSect()

ideal idMultSect ( resolvente  arg,
int  length,
GbVariant  a = GbDefault 
)

Definition at line 472 of file ideals.cc.

473 {
474  int i,j=0,k=0,l,maxrk=-1,realrki;
475  unsigned syzComp;
476  ideal bigmat,tempstd,result;
477  poly p;
478  int isIdeal=0;
479 
480  /* find 0-ideals and max rank -----------------------------------*/
481  for (i=0;i<length;i++)
482  {
483  if (!idIs0(arg[i]))
484  {
485  realrki=id_RankFreeModule(arg[i],currRing);
486  k++;
487  j += IDELEMS(arg[i]);
488  if (realrki>maxrk) maxrk = realrki;
489  }
490  else
491  {
492  if (arg[i]!=NULL)
493  {
494  return idInit(1,arg[i]->rank);
495  }
496  }
497  }
498  if (maxrk == 0)
499  {
500  isIdeal = 1;
501  maxrk = 1;
502  }
503  /* init -----------------------------------------------------------*/
504  j += maxrk;
505  syzComp = k*maxrk;
506 
507  ring orig_ring=currRing;
508  ring syz_ring=rAssure_SyzOrder(orig_ring,TRUE);
509  rSetSyzComp(syzComp,syz_ring);
510  rChangeCurrRing(syz_ring);
511 
512  bigmat = idInit(j,(k+1)*maxrk);
513  /* create unit matrices ------------------------------------------*/
514  for (i=0;i<maxrk;i++)
515  {
516  for (j=0;j<=k;j++)
517  {
518  p = pOne();
519  pSetComp(p,i+1+j*maxrk);
520  pSetmComp(p);
521  bigmat->m[i] = pAdd(bigmat->m[i],p);
522  }
523  }
524  /* enter given ideals ------------------------------------------*/
525  i = maxrk;
526  k = 0;
527  for (j=0;j<length;j++)
528  {
529  if (arg[j]!=NULL)
530  {
531  for (l=0;l<IDELEMS(arg[j]);l++)
532  {
533  if (arg[j]->m[l]!=NULL)
534  {
535  if (syz_ring==orig_ring)
536  bigmat->m[i] = pCopy(arg[j]->m[l]);
537  else
538  bigmat->m[i] = prCopyR(arg[j]->m[l], orig_ring,currRing);
539  p_Shift(&(bigmat->m[i]),k*maxrk+isIdeal,currRing);
540  i++;
541  }
542  }
543  k++;
544  }
545  }
546  /* std computation --------------------------------------------*/
547  if ((alg!=GbDefault)
548  && (alg!=GbGroebner)
549  && (alg!=GbModstd)
550  && (alg!=GbSlimgb)
551  && (alg!=GbStd))
552  {
553  WarnS("wrong algorithm for GB");
554  alg=GbDefault;
555  }
556  tempstd=idGroebner(bigmat,syzComp,alg);
557 
558  if(syz_ring!=orig_ring)
559  rChangeCurrRing(orig_ring);
560 
561  /* interprete result ----------------------------------------*/
562  result = idInit(IDELEMS(tempstd),maxrk);
563  k = 0;
564  for (j=0;j<IDELEMS(tempstd);j++)
565  {
566  if ((tempstd->m[j]!=NULL) && (__p_GetComp(tempstd->m[j],syz_ring)>syzComp))
567  {
568  if (syz_ring==orig_ring)
569  p = pCopy(tempstd->m[j]);
570  else
571  p = prCopyR(tempstd->m[j], syz_ring,currRing);
572  p_Shift(&p,-syzComp-isIdeal,currRing);
573  result->m[k] = p;
574  k++;
575  }
576  }
577  /* clean up ----------------------------------------------------*/
578  if(syz_ring!=orig_ring)
579  rChangeCurrRing(syz_ring);
580  idDelete(&tempstd);
581  if(syz_ring!=orig_ring)
582  {
583  rChangeCurrRing(orig_ring);
584  rDelete(syz_ring);
585  }
587  return result;
588 }

◆ idQuot()

ideal idQuot ( ideal  h1,
ideal  h2,
BOOLEAN  h1IsStb = FALSE,
BOOLEAN  resultIsIdeal = FALSE 
)

Definition at line 1488 of file ideals.cc.

1489 {
1490  // first check for special case h1:(0)
1491  if (idIs0(h2))
1492  {
1493  ideal res;
1494  if (resultIsIdeal)
1495  {
1496  res = idInit(1,1);
1497  res->m[0] = pOne();
1498  }
1499  else
1500  res = idFreeModule(h1->rank);
1501  return res;
1502  }
1503  int i, kmax;
1504  BOOLEAN addOnlyOne=TRUE;
1505  tHomog hom=isNotHomog;
1506  intvec * weights1;
1507 
1508  ideal s_h4 = idInitializeQuot (h1,h2,h1IsStb,&addOnlyOne,&kmax);
1509 
1510  hom = (tHomog)idHomModule(s_h4,currRing->qideal,&weights1);
1511 
1512  ring orig_ring=currRing;
1513  ring syz_ring=rAssure_SyzOrder(orig_ring,TRUE);
1514  rSetSyzComp(kmax-1,syz_ring);
1515  rChangeCurrRing(syz_ring);
1516  if (orig_ring!=syz_ring)
1517  // s_h4 = idrMoveR_NoSort(s_h4,orig_ring, syz_ring);
1518  s_h4 = idrMoveR(s_h4,orig_ring, syz_ring);
1519  idTest(s_h4);
1520 
1521  #if 0
1522  matrix m=idModule2Matrix(idCopy(s_h4));
1523  PrintS("start:\n");
1524  ipPrint_MA0(m,"Q");
1525  idDelete((ideal *)&m);
1526  PrintS("last elem:");wrp(s_h4->m[IDELEMS(s_h4)-1]);PrintLn();
1527  #endif
1528 
1529  ideal s_h3;
1530  BITSET old_test1;
1531  SI_SAVE_OPT1(old_test1);
1533  if (addOnlyOne)
1534  {
1536  s_h3 = kStd(s_h4,currRing->qideal,hom,&weights1,NULL,0/*kmax-1*/,IDELEMS(s_h4)-1);
1537  }
1538  else
1539  {
1540  s_h3 = kStd(s_h4,currRing->qideal,hom,&weights1,NULL,kmax-1);
1541  }
1542  SI_RESTORE_OPT1(old_test1);
1543 
1544  #if 0
1545  // only together with the above debug stuff
1546  idSkipZeroes(s_h3);
1547  m=idModule2Matrix(idCopy(s_h3));
1548  Print("result, kmax=%d:\n",kmax);
1549  ipPrint_MA0(m,"S");
1550  idDelete((ideal *)&m);
1551  #endif
1552 
1553  idTest(s_h3);
1554  if (weights1!=NULL) delete weights1;
1555  idDelete(&s_h4);
1556 
1557  for (i=0;i<IDELEMS(s_h3);i++)
1558  {
1559  if ((s_h3->m[i]!=NULL) && (pGetComp(s_h3->m[i])>=kmax))
1560  {
1561  if (resultIsIdeal)
1562  p_Shift(&s_h3->m[i],-kmax,currRing);
1563  else
1564  p_Shift(&s_h3->m[i],-kmax+1,currRing);
1565  }
1566  else
1567  p_Delete(&s_h3->m[i],currRing);
1568  }
1569  if (resultIsIdeal)
1570  s_h3->rank = 1;
1571  else
1572  s_h3->rank = h1->rank;
1573  if(syz_ring!=orig_ring)
1574  {
1575  rChangeCurrRing(orig_ring);
1576  s_h3 = idrMoveR_NoSort(s_h3, syz_ring, orig_ring);
1577  rDelete(syz_ring);
1578  }
1579  idSkipZeroes(s_h3);
1580  idTest(s_h3);
1581  return s_h3;
1582 }
#define Print
Definition: emacs.cc:80
static ideal idInitializeQuot(ideal h1, ideal h2, BOOLEAN h1IsStb, BOOLEAN *addOnlyOne, int *kkmax)
Definition: ideals.cc:1383
void ipPrint_MA0(matrix m, const char *name)
Definition: ipprint.cc:57
#define OPT_SB_1
Definition: options.h:95
void wrp(poly p)
Definition: polys.h:310
void PrintS(const char *s)
Definition: reporter.cc:284
void PrintLn()
Definition: reporter.cc:310

◆ idSect()

ideal idSect ( ideal  h1,
ideal  h2,
GbVariant  a = GbDefault 
)

Definition at line 316 of file ideals.cc.

317 {
318  int i,j,k;
319  unsigned length;
320  int flength = id_RankFreeModule(h1,currRing);
321  int slength = id_RankFreeModule(h2,currRing);
322  int rank=si_max(h1->rank,h2->rank);
323  if ((idIs0(h1)) || (idIs0(h2))) return idInit(1,rank);
324 
325  BITSET save_opt;
326  SI_SAVE_OPT1(save_opt);
328 
329  ideal first,second,temp,temp1,result;
330  poly p,q;
331 
332  if (IDELEMS(h1)<IDELEMS(h2))
333  {
334  first = h1;
335  second = h2;
336  }
337  else
338  {
339  first = h2;
340  second = h1;
341  int t=flength; flength=slength; slength=t;
342  }
343  length = si_max(flength,slength);
344  if (length==0)
345  {
346  if ((currRing->qideal==NULL)
347  && (currRing->OrdSgn==1)
348  && (!rIsPluralRing(currRing))
350  return idSectWithElim(first,second,alg);
351  else length = 1;
352  }
353  if (TEST_OPT_PROT) PrintS("intersect by syzygy methods\n");
354  j = IDELEMS(first);
355 
356  ring orig_ring=currRing;
357  ring syz_ring=rAssure_SyzOrder(orig_ring,TRUE);
358  rSetSyzComp(length,syz_ring);
359  rChangeCurrRing(syz_ring);
360 
361  while ((j>0) && (first->m[j-1]==NULL)) j--;
362  temp = idInit(j /*IDELEMS(first)*/+IDELEMS(second),length+j);
363  k = 0;
364  for (i=0;i<j;i++)
365  {
366  if (first->m[i]!=NULL)
367  {
368  if (syz_ring==orig_ring)
369  temp->m[k] = pCopy(first->m[i]);
370  else
371  temp->m[k] = prCopyR(first->m[i], orig_ring, syz_ring);
372  q = pOne();
373  pSetComp(q,i+1+length);
374  pSetmComp(q);
375  if (flength==0) p_Shift(&(temp->m[k]),1,currRing);
376  p = temp->m[k];
377  while (pNext(p)!=NULL) pIter(p);
378  pNext(p) = q;
379  k++;
380  }
381  }
382  for (i=0;i<IDELEMS(second);i++)
383  {
384  if (second->m[i]!=NULL)
385  {
386  if (syz_ring==orig_ring)
387  temp->m[k] = pCopy(second->m[i]);
388  else
389  temp->m[k] = prCopyR(second->m[i], orig_ring,currRing);
390  if (slength==0) p_Shift(&(temp->m[k]),1,currRing);
391  k++;
392  }
393  }
394  intvec *w=NULL;
395 
396  if ((alg!=GbDefault)
397  && (alg!=GbGroebner)
398  && (alg!=GbModstd)
399  && (alg!=GbSlimgb)
400  && (alg!=GbStd))
401  {
402  WarnS("wrong algorithm for GB");
403  alg=GbDefault;
404  }
405  temp1=idGroebner(temp,length,alg);
406 
407  if(syz_ring!=orig_ring)
408  rChangeCurrRing(orig_ring);
409 
410  result = idInit(IDELEMS(temp1),rank);
411  j = 0;
412  for (i=0;i<IDELEMS(temp1);i++)
413  {
414  if ((temp1->m[i]!=NULL)
415  && (__p_GetComp(temp1->m[i],syz_ring)>length))
416  {
417  if(syz_ring==orig_ring)
418  {
419  p = temp1->m[i];
420  }
421  else
422  {
423  p = prMoveR(temp1->m[i], syz_ring,orig_ring);
424  }
425  temp1->m[i]=NULL;
426  while (p!=NULL)
427  {
428  q = pNext(p);
429  pNext(p) = NULL;
430  k = pGetComp(p)-1-length;
431  pSetComp(p,0);
432  pSetmComp(p);
433  /* Warning! multiply only from the left! it's very important for Plural */
434  result->m[j] = pAdd(result->m[j],pMult(p,pCopy(first->m[k])));
435  p = q;
436  }
437  j++;
438  }
439  }
440  if(syz_ring!=orig_ring)
441  {
442  rChangeCurrRing(syz_ring);
443  idDelete(&temp1);
444  rChangeCurrRing(orig_ring);
445  rDelete(syz_ring);
446  }
447  else
448  {
449  idDelete(&temp1);
450  }
451 
453  SI_RESTORE_OPT1(save_opt);
454  if (TEST_OPT_RETURN_SB)
455  {
456  w=NULL;
457  temp1=kStd(result,currRing->qideal,testHomog,&w);
458  if (w!=NULL) delete w;
459  idDelete(&result);
460  idSkipZeroes(temp1);
461  return temp1;
462  }
463  //else
464  // temp1=kInterRed(result,currRing->qideal);
465  return result;
466 }
static ideal idSectWithElim(ideal h1, ideal h2, GbVariant alg)
Definition: ideals.cc:133
#define TEST_V_INTERSECT_ELIM
Definition: options.h:144
#define TEST_V_INTERSECT_SYZ
Definition: options.h:145
#define TEST_OPT_PROT
Definition: options.h:103
#define pMult(p, q)
Definition: polys.h:207

◆ idSeries()

ideal idSeries ( int  n,
ideal  M,
matrix  U = NULL,
intvec w = NULL 
)

Definition at line 2109 of file ideals.cc.

2110 {
2111  for(int i=IDELEMS(M)-1;i>=0;i--)
2112  {
2113  if(U==NULL)
2114  M->m[i]=pSeries(n,M->m[i],NULL,w);
2115  else
2116  {
2117  M->m[i]=pSeries(n,M->m[i],MATELEM(U,i+1,i+1),w);
2118  MATELEM(U,i+1,i+1)=NULL;
2119  }
2120  }
2121  if(U!=NULL)
2122  idDelete((ideal*)&U);
2123  return M;
2124 }
#define pSeries(n, p, u, w)
Definition: polys.h:372

◆ idSort()

static intvec* idSort ( ideal  id,
BOOLEAN  nolex = TRUE 
)
inlinestatic

Definition at line 184 of file ideals.h.

185 {
186  return id_Sort(id, nolex, currRing);
187 }
intvec * id_Sort(const ideal id, const BOOLEAN nolex, const ring r)
sorts the ideal w.r.t. the actual ringordering uses lex-ordering when nolex = FALSE

◆ idSyzygies()

ideal idSyzygies ( ideal  h1,
tHomog  h,
intvec **  w,
BOOLEAN  setSyzComp = TRUE,
BOOLEAN  setRegularity = FALSE,
int *  deg = NULL,
GbVariant  a = GbDefault 
)

Definition at line 830 of file ideals.cc.

832 {
833  ideal s_h1;
834  int j, k, length=0,reg;
835  BOOLEAN isMonomial=TRUE;
836  int ii, idElemens_h1;
837 
838  assume(h1 != NULL);
839 
840  idElemens_h1=IDELEMS(h1);
841 #ifdef PDEBUG
842  for(ii=0;ii<idElemens_h1 /*IDELEMS(h1)*/;ii++) pTest(h1->m[ii]);
843 #endif
844  if (idIs0(h1))
845  {
846  ideal result=idFreeModule(idElemens_h1/*IDELEMS(h1)*/);
847  return result;
848  }
849  int slength=(int)id_RankFreeModule(h1,currRing);
850  k=si_max(1,slength /*id_RankFreeModule(h1)*/);
851 
852  assume(currRing != NULL);
853  ring orig_ring=currRing;
854  ring syz_ring=rAssure_SyzComp(orig_ring,TRUE);
855  if (setSyzComp) rSetSyzComp(k,syz_ring);
856 
857  if (orig_ring != syz_ring)
858  {
859  rChangeCurrRing(syz_ring);
860  s_h1=idrCopyR_NoSort(h1,orig_ring,syz_ring);
861  }
862  else
863  {
864  s_h1 = h1;
865  }
866 
867  idTest(s_h1);
868 
869  BITSET save_opt;
870  SI_SAVE_OPT1(save_opt);
872 
873  ideal s_h3=idPrepare(s_h1,NULL,h,k,w,alg); // main (syz) GB computation
874 
875  SI_RESTORE_OPT1(save_opt);
876 
877  if (orig_ring != syz_ring)
878  {
879  idDelete(&s_h1);
880  for (j=0; j<IDELEMS(s_h3); j++)
881  {
882  if (s_h3->m[j] != NULL)
883  {
884  if (p_MinComp(s_h3->m[j],syz_ring) > k)
885  p_Shift(&s_h3->m[j], -k,syz_ring);
886  else
887  p_Delete(&s_h3->m[j],syz_ring);
888  }
889  }
890  idSkipZeroes(s_h3);
891  s_h3->rank -= k;
892  rChangeCurrRing(orig_ring);
893  s_h3 = idrMoveR_NoSort(s_h3, syz_ring, orig_ring);
894  rDelete(syz_ring);
895  #ifdef HAVE_PLURAL
896  if (rIsPluralRing(orig_ring))
897  {
898  id_DelMultiples(s_h3,orig_ring);
899  idSkipZeroes(s_h3);
900  }
901  #endif
902  idTest(s_h3);
903  return s_h3;
904  }
905 
906  ideal e = idInit(IDELEMS(s_h3), s_h3->rank);
907 
908  for (j=IDELEMS(s_h3)-1; j>=0; j--)
909  {
910  if (s_h3->m[j] != NULL)
911  {
912  if (p_MinComp(s_h3->m[j],syz_ring) <= k)
913  {
914  e->m[j] = s_h3->m[j];
915  isMonomial=isMonomial && (pNext(s_h3->m[j])==NULL);
916  p_Delete(&pNext(s_h3->m[j]),syz_ring);
917  s_h3->m[j] = NULL;
918  }
919  }
920  }
921 
922  idSkipZeroes(s_h3);
923  idSkipZeroes(e);
924 
925  if ((deg != NULL)
926  && (!isMonomial)
928  && (setRegularity)
929  && (h==isHomog)
930  && (!rIsPluralRing(currRing))
931  && (!rField_is_Ring(currRing))
932  )
933  {
934  assume(orig_ring==syz_ring);
935  ring dp_C_ring = rAssure_dp_C(syz_ring); // will do rChangeCurrRing later
936  if (dp_C_ring != syz_ring)
937  {
938  rChangeCurrRing(dp_C_ring);
939  e = idrMoveR_NoSort(e, syz_ring, dp_C_ring);
940  }
942  intvec * dummy = syBetti(res,length,&reg, *w);
943  *deg = reg+2;
944  delete dummy;
945  for (j=0;j<length;j++)
946  {
947  if (res[j]!=NULL) idDelete(&(res[j]));
948  }
949  omFreeSize((ADDRESS)res,length*sizeof(ideal));
950  idDelete(&e);
951  if (dp_C_ring != orig_ring)
952  {
953  rChangeCurrRing(orig_ring);
954  rDelete(dp_C_ring);
955  }
956  }
957  else
958  {
959  idDelete(&e);
960  }
961  assume(orig_ring==currRing);
962  idTest(s_h3);
963  if (currRing->qideal != NULL)
964  {
965  ideal ts_h3=kStd(s_h3,currRing->qideal,h,w);
966  idDelete(&s_h3);
967  s_h3 = ts_h3;
968  }
969  return s_h3;
970 }
ideal * resolvente
Definition: ideals.h:18
#define TEST_OPT_NOTREGULARITY
Definition: options.h:120
static long p_MinComp(poly p, ring lmRing, ring tailRing)
Definition: p_polys.h:313
#define pTest(p)
Definition: polys.h:415
ring rAssure_SyzComp(const ring r, BOOLEAN complete)
Definition: ring.cc:4423
ring rAssure_dp_C(const ring r)
Definition: ring.cc:4927
void id_DelMultiples(ideal id, const ring r)
ideal id = (id[i]), c any unit if id[i] = c*id[j] then id[j] is deleted for j > i
@ isHomog
Definition: structs.h:42
intvec * syBetti(resolvente res, int length, int *regularity, intvec *weights, BOOLEAN tomin, int *row_shift)
Definition: syz.cc:770
resolvente sySchreyerResolvente(ideal arg, int maxlength, int *length, BOOLEAN isMonomial=FALSE, BOOLEAN notReplace=FALSE)
Definition: syz0.cc:855

◆ idTestHomModule()

BOOLEAN idTestHomModule ( ideal  m,
ideal  Q,
intvec w 
)

Definition at line 2057 of file ideals.cc.

2058 {
2059  if ((Q!=NULL) && (!idHomIdeal(Q,NULL))) { PrintS(" Q not hom\n"); return FALSE;}
2060  if (idIs0(m)) return TRUE;
2061 
2062  int cmax=-1;
2063  int i;
2064  poly p=NULL;
2065  int length=IDELEMS(m);
2066  polyset P=m->m;
2067  for (i=length-1;i>=0;i--)
2068  {
2069  p=P[i];
2070  if (p!=NULL) cmax=si_max(cmax,(int)pMaxComp(p)+1);
2071  }
2072  if (w != NULL)
2073  if (w->length()+1 < cmax)
2074  {
2075  // Print("length: %d - %d \n", w->length(),cmax);
2076  return FALSE;
2077  }
2078 
2079  if(w!=NULL)
2081 
2082  for (i=length-1;i>=0;i--)
2083  {
2084  p=P[i];
2085  if (p!=NULL)
2086  {
2087  int d=currRing->pFDeg(p,currRing);
2088  loop
2089  {
2090  pIter(p);
2091  if (p==NULL) break;
2092  if (d!=currRing->pFDeg(p,currRing))
2093  {
2094  //pWrite(q); wrp(p); Print(" -> %d - %d\n",d,pFDeg(p,currRing));
2095  if(w!=NULL)
2097  return FALSE;
2098  }
2099  }
2100  }
2101  }
2102 
2103  if(w!=NULL)
2105 
2106  return TRUE;
2107 }
static BOOLEAN idHomIdeal(ideal id, ideal Q=NULL)
Definition: ideals.h:91
void p_SetModDeg(intvec *w, ring r)
Definition: p_polys.cc:3743
#define pMaxComp(p)
Definition: polys.h:299
poly * polyset
Definition: polys.h:259

◆ idVec2Ideal()

static ideal idVec2Ideal ( poly  vec)
inlinestatic

Definition at line 169 of file ideals.h.

170 {
171  return id_Vec2Ideal(vec, currRing);
172 }
fq_nmod_poly_t * vec
Definition: facHensel.cc:108
ideal id_Vec2Ideal(poly vec, const ring R)

◆ syGetAlgorithm()

GbVariant syGetAlgorithm ( char *  n,
const ring  r,
const ideal  M 
)

Definition at line 3142 of file ideals.cc.

3143 {
3144  GbVariant alg=GbDefault;
3145  if (strcmp(n,"default")==0) alg=GbDefault;
3146  else if (strcmp(n,"slimgb")==0) alg=GbSlimgb;
3147  else if (strcmp(n,"std")==0) alg=GbStd;
3148  else if (strcmp(n,"sba")==0) alg=GbSba;
3149  else if (strcmp(n,"singmatic")==0) alg=GbSingmatic;
3150  else if (strcmp(n,"groebner")==0) alg=GbGroebner;
3151  else if (strcmp(n,"modstd")==0) alg=GbModstd;
3152  else if (strcmp(n,"ffmod")==0) alg=GbFfmod;
3153  else if (strcmp(n,"nfmod")==0) alg=GbNfmod;
3154  else if (strcmp(n,"std:sat")==0) alg=GbStdSat;
3155  else Warn(">>%s<< is an unknown algorithm",n);
3156 
3157  if (alg==GbSlimgb) // test conditions for slimgb
3158  {
3159  if(rHasGlobalOrdering(r)
3160  &&(!rIsNCRing(r))
3161  &&(r->qideal==NULL)
3162  &&(!rField_is_Ring(r)))
3163  {
3164  return GbSlimgb;
3165  }
3166  if (TEST_OPT_PROT)
3167  WarnS("requires: coef:field, commutative, global ordering, not qring");
3168  }
3169  else if (alg==GbSba) // cond. for sba
3170  {
3171  if(rField_is_Domain(r)
3172  &&(!rIsNCRing(r))
3173  &&(rHasGlobalOrdering(r)))
3174  {
3175  return GbSba;
3176  }
3177  if (TEST_OPT_PROT)
3178  WarnS("requires: coef:domain, commutative, global ordering");
3179  }
3180  else if (alg==GbGroebner) // cond. for groebner
3181  {
3182  return GbGroebner;
3183  }
3184  else if(alg==GbModstd) // cond for modstd: Q or Q(a)
3185  {
3186  if(ggetid("modStd")==NULL)
3187  {
3188  WarnS(">>modStd<< not found");
3189  }
3190  else if(rField_is_Q(r)
3191  &&(!rIsNCRing(r))
3192  &&(rHasGlobalOrdering(r)))
3193  {
3194  return GbModstd;
3195  }
3196  if (TEST_OPT_PROT)
3197  WarnS("requires: coef:QQ, commutative, global ordering");
3198  }
3199  else if(alg==GbStdSat) // cond for std:sat: 2 blocks of variables
3200  {
3201  if(ggetid("satstd")==NULL)
3202  {
3203  WarnS(">>satstd<< not found");
3204  }
3205  else
3206  {
3207  return GbStdSat;
3208  }
3209  }
3210 
3211  return GbStd; // no conditions for std
3212 }
#define Warn
Definition: emacs.cc:77
GbVariant
Definition: ideals.h:119
idhdl ggetid(const char *n)
Definition: ipid.cc:571
static BOOLEAN rField_is_Domain(const ring r)
Definition: ring.h:489
static BOOLEAN rField_is_Q(const ring r)
Definition: ring.h:508
static BOOLEAN rIsNCRing(const ring r)
Definition: ring.h:421