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:
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;
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 }
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}
#define NULL
Definition: auxiliary.h:104
f
Definition: cfModGcd.cc:4083
g
Definition: cfModGcd.cc:4092
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
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);
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
static nc_type & ncRingType(nc_struct *p)
Definition: nc.h:159
BOOLEAN nc_CheckSubalgebra(poly PolyVar, ring r)
Definition: old.gring.cc:2568
#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;
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 {
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 &)
Definition: cf_inline.cc:571
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);
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);
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)
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);
455 {
456 w=NULL;
457 temp1=kStd(result,currRing->qideal,testHomog,&w);
458 if (w!=NULL) delete w;
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)
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