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 2832 of file ideals.cc.

2833 {
2834  int cnt=IDELEMS(x)*x->nrows;
2835  ideal result=idInit(cnt,x->rank);
2836  result->nrows=x->nrows; // for lifting matrices
2837  result->ncols=x->ncols; // for lifting matrices
2838 
2839  int i;
2840  for(i=cnt-1;i>=0;i--)
2841  {
2842  result->m[i]=p_Farey(x->m[i],N,r);
2843  }
2844  return result;
2845 }
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 2729 of file ideals.cc.

2730 {
2731  ideal I=idInit(2,1); I->m[0]=f; I->m[1]=g;
2732  intvec *w = NULL;
2733 
2734  ring save_r = currRing;
2735  rChangeCurrRing(r);
2736  ideal S=idSyzygies(I,testHomog,&w);
2737  rChangeCurrRing(save_r);
2738 
2739  if (w!=NULL) delete w;
2740  poly gg=p_TakeOutComp(&(S->m[0]), 2, r);
2741  id_Delete(&S, r);
2742  poly gcd_p=singclap_pdivide(f,gg, r);
2743  p_Delete(&gg, r);
2744 
2745  return gcd_p;
2746 }
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 3092 of file ideals.cc.

3093 {
3094  ring save=currRing;
3095  if (currRing!=r) rChangeCurrRing(r);
3096  idSkipZeroes(J);
3097  id_satstdSaturatingVariables=(int*)omAlloc0((1+rVar(currRing))*sizeof(int));
3098  int k=IDELEMS(J);
3099  if (k>1)
3100  {
3101  for (int i=0; i<k; i++)
3102  {
3103  poly x = J->m[i];
3104  int li = p_Var(x,r);
3105  if (li>0)
3107  else
3108  {
3109  if (currRing!=save) rChangeCurrRing(save);
3110  WerrorS("ideal generators must be variables");
3111  return NULL;
3112  }
3113  }
3114  }
3115  else
3116  {
3117  poly x = J->m[0];
3118  for (int i=1; i<=r->N; i++)
3119  {
3120  int li = p_GetExp(x,i,r);
3121  if (li==1)
3123  else if (li>1)
3124  {
3125  if (currRing!=save) rChangeCurrRing(save);
3126  Werror("exponent(x(%d)^%d) must be 0 or 1",i,li);
3127  return NULL;
3128  }
3129  }
3130  }
3131  ideal res=kStd(I,r->qideal,testHomog,NULL,NULL,0,0,NULL,id_sat_vars_sp);
3134  if (currRing!=save) rChangeCurrRing(save);
3135  return res;
3136 }
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:2977
static BOOLEAN id_sat_vars_sp(kStrategy strat)
Definition: ideals.cc:2979
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:2419
#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:4682
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:597
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 2605 of file ideals.cc.

2606 {
2607  matrix result;
2608  ideal tempKbase;
2609  poly p,q;
2610  intvec * convert;
2611  int i=IDELEMS(kbase),j=IDELEMS(arg),k,pos;
2612 #if 0
2613  while ((i>0) && (kbase->m[i-1]==NULL)) i--;
2614  if (idIs0(arg))
2615  return mpNew(i,1);
2616  while ((j>0) && (arg->m[j-1]==NULL)) j--;
2617  result = mpNew(i,j);
2618 #else
2619  result = mpNew(i, j);
2620  while ((j>0) && (arg->m[j-1]==NULL)) j--;
2621 #endif
2622 
2623  tempKbase = idCreateSpecialKbase(kbase,&convert);
2624  for (k=0;k<j;k++)
2625  {
2626  p = arg->m[k];
2627  while (p!=NULL)
2628  {
2629  q = idDecompose(p,how,tempKbase,&pos);
2630  if (pos>=0)
2631  {
2632  MATELEM(result,(*convert)[pos],k+1) =
2633  pAdd(MATELEM(result,(*convert)[pos],k+1),q);
2634  }
2635  else
2636  p_Delete(&q,currRing);
2637  pIter(p);
2638  }
2639  }
2640  idDelete(&tempKbase);
2641  return result;
2642 }
int p
Definition: cfModGcd.cc:4080
int j
Definition: facHensel.cc:110
ideal idCreateSpecialKbase(ideal kBase, intvec **convert)
Definition: ideals.cc:2519
poly idDecompose(poly monom, poly how, ideal kbase, int *pos)
Definition: ideals.cc:2573
#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 2940 of file ideals.cc.

2941 {
2942  int idsize = IDELEMS(id);
2943  poly_sort *id_sort = (poly_sort *)omAlloc0(idsize*sizeof(poly_sort));
2944  for (int i = 0; i < idsize; i++)
2945  {
2946  id_sort[i].p = id->m[i];
2947  id_sort[i].index = i;
2948  }
2949  idSort_qsort(id_sort, idsize);
2950  int index, index_i, index_j;
2951  int i = 0;
2952  for (int j = 1; j < idsize; j++)
2953  {
2954  if (id_sort[i].p != NULL && pEqualPolys(id_sort[i].p, id_sort[j].p))
2955  {
2956  index_i = id_sort[i].index;
2957  index_j = id_sort[j].index;
2958  if (index_j > index_i)
2959  {
2960  index = index_j;
2961  }
2962  else
2963  {
2964  index = index_i;
2965  i = j;
2966  }
2967  pDelete(&id->m[index]);
2968  }
2969  else
2970  {
2971  i = j;
2972  }
2973  }
2974  omFreeSize((ADDRESS)(id_sort), idsize*sizeof(poly_sort));
2975 }
void * ADDRESS
Definition: auxiliary.h:119
int index
Definition: ideals.cc:2923
poly p
Definition: ideals.cc:2922
void idSort_qsort(poly_sort *id_sort, int idsize)
Definition: ideals.cc:2931
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 2122 of file ideals.cc.

2123 {
2124  int e=MATCOLS(i)*MATROWS(i);
2125  matrix r=mpNew(MATROWS(i),MATCOLS(i));
2126  r->rank=i->rank;
2127  int j;
2128  for(j=0; j<e; j++)
2129  {
2130  r->m[j]=pDiff(i->m[j],k);
2131  }
2132  return r;
2133 }
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 2135 of file ideals.cc.

2136 {
2137  matrix r=mpNew(IDELEMS(I),IDELEMS(J));
2138  int i,j;
2139  for(i=0; i<IDELEMS(I); i++)
2140  {
2141  for(j=0; j<IDELEMS(J); j++)
2142  {
2143  MATELEM(r,i+1,j+1)=pDiffOp(I->m[i],J->m[j],multiply);
2144  }
2145  }
2146  return r;
2147 }
#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  hh=idGroebner(h,0,alg,hilb);
1795  // go back to the original ring
1796  rChangeCurrRing(origR);
1797  i = IDELEMS(hh)-1;
1798  while ((i >= 0) && (hh->m[i] == NULL)) i--;
1799  j = -1;
1800  // fetch data from temp ring
1801  for (k=0; k<=i; k++)
1802  {
1803  l=(currRing->N);
1804  while ((l>0) && (p_GetExp( hh->m[k],l,tmpR)*pGetExp(delVar,l)==0)) l--;
1805  if (l==0)
1806  {
1807  j++;
1808  if (j >= IDELEMS(h3))
1809  {
1810  pEnlargeSet(&(h3->m),IDELEMS(h3),16);
1811  IDELEMS(h3) += 16;
1812  }
1813  h3->m[j] = prMoveR( hh->m[k], tmpR,origR);
1814  hh->m[k] = NULL;
1815  }
1816  }
1817  id_Delete(&hh, tmpR);
1818  idSkipZeroes(h3);
1819  rDelete(tmpR);
1820  if (w!=NULL)
1821  delete w;
1822  return h3;
1823 }
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
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:3403
BOOLEAN nc_rComplete(const ring src, ring dest, bool bSetupQuotient)
Definition: ring.cc:5657
ring rCopy0(const ring r, BOOLEAN copy_qideal, BOOLEAN copy_ordering)
Definition: ring.cc:1366
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
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 2032 of file ideals.cc.

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

◆ 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 2908 of file ideals.cc.

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

◆ 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:4732
#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:4421
void rSetSyzComp(int k, const ring r)
Definition: ring.cc:5036
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
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 Sy_bit(x)
Definition: options.h:31
#define TEST_OPT_RETURN_SB
Definition: options.h:111
#define V_IDLIFT
Definition: options.h:62
#define BITSET
Definition: structs.h:20

◆ 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:3009
#define pCopy(p)
return a copy of the poly
Definition: polys.h:185
static BOOLEAN rField_is_Ring(const ring r)
Definition: ring.h:489
BOOLEAN rHasGlobalOrdering(const ring r)
Definition: ring.h:764
@ isNotHomog
Definition: structs.h:41

◆ idMinEmbedding()

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

Definition at line 2671 of file ideals.cc.

2672 {
2673  if (idIs0(arg)) return idInit(1,arg->rank);
2674  int i,next_gen,next_comp;
2675  ideal res=arg;
2676  if (!inPlace) res = idCopy(arg);
2677  res->rank=si_max(res->rank,id_RankFreeModule(res,currRing));
2678  int *red_comp=(int*)omAlloc((res->rank+1)*sizeof(int));
2679  for (i=res->rank;i>=0;i--) red_comp[i]=i;
2680 
2681  int del=0;
2682  loop
2683  {
2684  next_gen = id_ReadOutPivot(res, &next_comp, currRing);
2685  if (next_gen<0) break;
2686  del++;
2687  syGaussForOne(res,next_gen,next_comp,0,IDELEMS(res));
2688  for(i=next_comp+1;i<=arg->rank;i++) red_comp[i]--;
2689  if ((w !=NULL)&&(*w!=NULL))
2690  {
2691  for(i=next_comp;i<(*w)->length();i++) (**w)[i-1]=(**w)[i];
2692  }
2693  }
2694 
2695  idDeleteComps(res,red_comp,del);
2696  idSkipZeroes(res);
2697  omFree(red_comp);
2698 
2699  if ((w !=NULL)&&(*w!=NULL) &&(del>0))
2700  {
2701  int nl=si_max((*w)->length()-del,1);
2702  intvec *wtmp=new intvec(nl);
2703  for(i=0;i<res->rank;i++) (*wtmp)[i]=(**w)[i];
2704  delete *w;
2705  *w=wtmp;
2706  }
2707  return res;
2708 }
static void idDeleteComps(ideal arg, int *red_comp, int del)
Definition: ideals.cc:2644
#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 1964 of file ideals.cc.

1965 {
1966 
1967  const ring origR=currRing;
1968  id_Test((ideal)a, origR);
1969 
1970  const int r = a->nrows;
1971  const int c = a->ncols;
1972 
1973  if((ar<=0) || (ar>r) || (ar>c))
1974  {
1975  Werror("%d-th minor, matrix is %dx%d",ar,r,c);
1976  return NULL;
1977  }
1978 
1979  ideal h = id_Matrix2Module(mp_Copy(a,origR),origR);
1980  long bound = sm_ExpBound(h,c,r,ar,origR);
1981  id_Delete(&h, origR);
1982 
1983  ring tmpR = sm_RingChange(origR,bound);
1984 
1985  matrix b = mpNew(r,c);
1986 
1987  for (int i=r*c-1;i>=0;i--)
1988  if (a->m[i] != NULL)
1989  b->m[i] = prCopyR(a->m[i],origR,tmpR);
1990 
1991  id_Test( (ideal)b, tmpR);
1992 
1993  if (R!=NULL)
1994  {
1995  R = idrCopyR(R,origR,tmpR); // TODO: overwrites R? memory leak?
1996  //if (ar>1) // otherwise done in mpMinorToResult
1997  //{
1998  // matrix bb=(matrix)kNF(R,currRing->qideal,(ideal)b);
1999  // bb->rank=b->rank; bb->nrows=b->nrows; bb->ncols=b->ncols;
2000  // idDelete((ideal*)&b); b=bb;
2001  //}
2002  id_Test( R, tmpR);
2003  }
2004 
2005  int size=binom(r,ar)*binom(c,ar);
2006  ideal result = idInit(size,1);
2007 
2008  int elems = 0;
2009 
2010  if(ar>1)
2011  mp_RecMin(ar-1,result,elems,b,r,c,NULL,R,tmpR);
2012  else
2013  mp_MinorToResult(result,elems,b,r,c,R,tmpR);
2014 
2015  id_Test( (ideal)b, tmpR);
2016 
2017  id_Delete((ideal *)&b, tmpR);
2018 
2019  if (R!=NULL) id_Delete(&R,tmpR);
2020 
2021  rChangeCurrRing(origR);
2022  result = idrMoveR(result,tmpR,origR);
2023  sm_KillModifiedRing(tmpR);
2024  idTest(result);
2025  return result;
2026 }
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 2398 of file ideals.cc.

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

◆ idSeries()

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

Definition at line 2105 of file ideals.cc.

2106 {
2107  for(int i=IDELEMS(M)-1;i>=0;i--)
2108  {
2109  if(U==NULL)
2110  M->m[i]=pSeries(n,M->m[i],NULL,w);
2111  else
2112  {
2113  M->m[i]=pSeries(n,M->m[i],MATELEM(U,i+1,i+1),w);
2114  MATELEM(U,i+1,i+1)=NULL;
2115  }
2116  }
2117  if(U!=NULL)
2118  idDelete((ideal*)&U);
2119  return M;
2120 }
#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:119
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:4426
ring rAssure_dp_C(const ring r)
Definition: ring.cc:4930
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 2053 of file ideals.cc.

2054 {
2055  if ((Q!=NULL) && (!idHomIdeal(Q,NULL))) { PrintS(" Q not hom\n"); return FALSE;}
2056  if (idIs0(m)) return TRUE;
2057 
2058  int cmax=-1;
2059  int i;
2060  poly p=NULL;
2061  int length=IDELEMS(m);
2062  polyset P=m->m;
2063  for (i=length-1;i>=0;i--)
2064  {
2065  p=P[i];
2066  if (p!=NULL) cmax=si_max(cmax,(int)pMaxComp(p)+1);
2067  }
2068  if (w != NULL)
2069  if (w->length()+1 < cmax)
2070  {
2071  // Print("length: %d - %d \n", w->length(),cmax);
2072  return FALSE;
2073  }
2074 
2075  if(w!=NULL)
2077 
2078  for (i=length-1;i>=0;i--)
2079  {
2080  p=P[i];
2081  if (p!=NULL)
2082  {
2083  int d=currRing->pFDeg(p,currRing);
2084  loop
2085  {
2086  pIter(p);
2087  if (p==NULL) break;
2088  if (d!=currRing->pFDeg(p,currRing))
2089  {
2090  //pWrite(q); wrp(p); Print(" -> %d - %d\n",d,pFDeg(p,currRing));
2091  if(w!=NULL)
2093  return FALSE;
2094  }
2095  }
2096  }
2097  }
2098 
2099  if(w!=NULL)
2101 
2102  return TRUE;
2103 }
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 3138 of file ideals.cc.

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