My Project
Loading...
Searching...
No Matches
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
 
#define idMaxIdeal(D)   id_MaxIdeal(D,currRing)
 initialise the maximal ideal (at 0)
 
#define idPosConstant(I)   id_PosConstant(I,currRing)
 index of generator with leading term in ground ring (if any); otherwise -1
 
#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 idealresolvente
 

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.)
 
void idDelEquals (ideal id)
 
ideal id_Copy (ideal h1, const ring r)
 copy an ideal
 
ideal idCopy (ideal A)
 
ideal idAdd (ideal h1, ideal h2)
 h1 + h2
 
BOOLEAN idInsertPoly (ideal h1, poly h2)
 insert h2 into h1 (if h2 is not the zero polynomial) return TRUE iff h2 was indeed inserted
 
BOOLEAN idInsertPolyOnPos (ideal I, poly p, int pos)
 insert p into I on position pos
 
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
 
BOOLEAN idIs0 (ideal h)
 returns true if h is the zero ideal
 
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, ideal *SB=NULL)
 
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)
 represents the generators of submod in terms of the generators of mod (Matrix(SM)*U-Matrix(rest)) = Matrix(M)*Matrix(result) goodShape: maximal non-zero index in generators of SM <= that of M isSB: generators of M form a Groebner basis divide: allow SM not to be a submodule of M U is an diagonal matrix of units (non-constant only in local rings) rest is: 0 if SM in M, SM if not divide, NF(SM,std(M)) if divide
 
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)
 
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)
 
ideal id_Sat_principal (const ideal I, ideal J, const ring r)
 
ideal idSaturate (ideal I, ideal J, int &ki, BOOLEAN isIdeal=TRUE)
 
ideal id_Homogenize (ideal I, int var_num, const ring r)
 
ideal id_HomogenizeW (ideal I, int var_num, intvec *w, 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

Definition at line 18 of file ideals.h.

Enumeration Type Documentation

◆ 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 // and test variants
133};
@ 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 1152 of file simpleideals.cc.

1153{
1154 int i;
1155 int64 result;
1156
1157 if (r==0) return 1;
1158 if (n-r<r) return binom(n,n-r);
1159 result = n-r+1;
1160 for (i=2;i<=r;i++)
1161 {
1162 result *= n-r+i;
1163 result /= i;
1164 }
1165 if (result>MAX_INT_VAL)
1166 {
1167 WarnS("overflow in binomials");
1168 result=0;
1169 }
1170 return (int)result;
1171}
long int64
Definition auxiliary.h:68
int i
Definition cfEzgcd.cc:132
#define WarnS
Definition emacs.cc:78
return result
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 545 of file simpleideals.cc.

546{
547 id_Test(h1, r);
548
549 ideal h2 = idInit(IDELEMS(h1), h1->rank);
550 for (int i=IDELEMS(h1)-1; i>=0; i--)
551 h2->m[i] = p_Copy(h1->m[i],r);
552 return h2;
553}
static poly p_Copy(poly p, const ring r)
returns a copy of p
Definition p_polys.h:846
ideal idInit(int idsize, int rank)
initialise an ideal / module
#define IDELEMS(i)
#define id_Test(A, lR)

◆ id_Farey()

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

Definition at line 2856 of file ideals.cc.

2857{
2858 int cnt=IDELEMS(x)*x->nrows;
2859 ideal result=idInit(cnt,x->rank);
2860 result->nrows=x->nrows; // for lifting matrices
2861 result->ncols=x->ncols; // for lifting matrices
2862
2863 int i;
2864 for(i=cnt-1;i>=0;i--)
2865 {
2866 result->m[i]=p_Farey(x->m[i],N,r);
2867 }
2868 return result;
2869}
const CanonicalForm CFMap CFMap & N
Definition cfEzgcd.cc:56
Variable x
Definition cfModGcd.cc:4081
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 2753 of file ideals.cc.

2754{
2755 ideal I=idInit(2,1); I->m[0]=f; I->m[1]=g;
2756 intvec *w = NULL;
2757
2759 rChangeCurrRing(r);
2762
2763 if (w!=NULL) delete w;
2764 poly gg=p_TakeOutComp(&(S->m[0]), 2, r);
2765 id_Delete(&S, r);
2766 poly gcd_p=singclap_pdivide(f,gg, r);
2767 p_Delete(&gg, r);
2768
2769 return gcd_p;
2770}
g
Definition cfModGcd.cc:4089
FILE * f
Definition checklibs.c:9
poly singclap_pdivide(poly f, poly g, const ring r)
Definition clapsing.cc:624
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:3496
#define NULL
Definition omList.c:12
static void p_Delete(poly *p, const ring r)
Definition p_polys.h:901
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:38

◆ id_Homogenize()

ideal id_Homogenize ( ideal I,
int var_num,
const ring r )

Definition at line 3335 of file ideals.cc.

3336{
3337 ideal II=id_Copy(I,r);
3338 if (var_num==1)
3339 {
3341 if (tmpR!=r)
3342 {
3344 II=idrMoveR(II,r,tmpR);
3345 }
3347 id_Delete(&II,tmpR);
3348 intvec *ww=NULL;
3349 II=kStd(III,currRing->qideal,(tHomog)TRUE,&ww);
3350 if (ww!=NULL) delete ww;
3351 id_Delete(&III,tmpR);
3352 if (tmpR!=r)
3353 {
3354 rChangeCurrRing(r);
3355 II=idrMoveR(II,tmpR,r);
3356 }
3357 return II;
3358 }
3360 int *perm=(int*)omAlloc0((rVar(r)+1)*sizeof(int));
3361 for(int i=rVar(r)-1; i>0; i--) perm[i]=i;
3362 perm[var_num]=1;
3363 perm[1]=var_num;
3364 for(int i=IDELEMS(II)-1; i>=0;i--)
3365 {
3366 III->m[i]=p_PermPoly(II->m[i],perm,r,r,ndCopyMap,NULL,0,FALSE);
3367 }
3368 id_Delete(&II,r);
3369 II=id_Homogenize(III,1,r);
3370 id_Delete(&III,r);
3371 III=idInit(IDELEMS(II),1);
3372 for(int i=IDELEMS(II)-1; i>=0;i--)
3373 {
3374 III->m[i]=p_PermPoly(II->m[i],perm,r,r,ndCopyMap,NULL,0,FALSE);
3375 }
3376 id_Delete(&II,r);
3377 return III;
3378}
#define TRUE
Definition auxiliary.h:100
#define FALSE
Definition auxiliary.h:96
number ndCopyMap(number a, const coeffs src, const coeffs dst)
Definition numbers.cc:291
ideal id_Homogenize(ideal I, int var_num, const ring r)
Definition ideals.cc:3335
ideal id_Copy(ideal h1, const ring r)
copy an ideal
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:2449
#define omAlloc0(size)
poly p_PermPoly(poly p, const int *perm, const ring oldRing, const ring dst, nMapFunc nMap, const int *par_perm, int OldPar, BOOLEAN use_mult)
Definition p_polys.cc:4130
ideal idrMoveR(ideal &id, ring src_r, ring dest_r)
Definition prCopy.cc:248
ring rAssure_Dp_C(const ring r)
Definition ring.cc:5041
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition ring.h:592
ideal id_Homogen(ideal h, int varnum, const ring r)
tHomog
Definition structs.h:35

◆ id_HomogenizeW()

ideal id_HomogenizeW ( ideal I,
int var_num,
intvec * w,
const ring r )

Definition at line 3380 of file ideals.cc.

3381{
3382 ideal II=id_Copy(I,r);
3383 if (var_num==1)
3384 {
3386 if (tmpR!=r)
3387 {
3389 II=idrMoveR(II,r,tmpR);
3390 }
3392 id_Delete(&II,tmpR);
3393 intvec *ww=NULL;
3394 II=kStd(III,currRing->qideal,(tHomog)TRUE,&ww);
3395 if (ww!=NULL) delete ww;
3396 id_Delete(&III,tmpR);
3397 if (tmpR!=r)
3398 {
3399 rChangeCurrRing(r);
3400 II=idrMoveR(II,tmpR,r);
3401 }
3402 return II;
3403 }
3405 int *perm=(int*)omAlloc0((rVar(r)+1)*sizeof(int));
3406 for(int i=rVar(r)-1; i>0; i--) perm[i]=i;
3407 perm[var_num]=1;
3408 perm[1]=var_num;
3409 for(int i=IDELEMS(II)-1; i>=0;i--)
3410 {
3411 III->m[i]=p_PermPoly(II->m[i],perm,r,r,ndCopyMap,NULL,0,FALSE);
3412 }
3413 id_Delete(&II,r);
3414 II=id_HomogenizeW(III,1,w,r);
3415 id_Delete(&III,r);
3416 III=idInit(IDELEMS(II),1);
3417 for(int i=IDELEMS(II)-1; i>=0;i--)
3418 {
3419 III->m[i]=p_PermPoly(II->m[i],perm,r,r,ndCopyMap,NULL,0,FALSE);
3420 }
3421 id_Delete(&II,r);
3422 return III;
3423}
ideal id_HomogenizeW(ideal I, int var_num, intvec *w, const ring r)
Definition ideals.cc:3380
ring rAssure_Wp_C(const ring r, intvec *w)
Definition ring.cc:4859

◆ id_Sat_principal()

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

Definition at line 3168 of file ideals.cc.

3169{
3170 rRingOrder_t *ord;
3171 int *block0,*block1;
3172 int **wv;
3173
3174 // construction extension ring
3175 ord=(rRingOrder_t*)omAlloc0(4*sizeof(rRingOrder_t));
3176 block0=(int*)omAlloc0(4*sizeof(int));
3177 block1=(int*)omAlloc0(4*sizeof(int));
3178 wv=(int**) omAlloc0(4*sizeof(int**));
3179 wv[0]=(int*)omAlloc0((rVar(origR) + 2)*sizeof(int));
3180 block0[0] = block0[1] = 1;
3181 block1[0] = block1[1] = rVar(origR)+1;
3182 // use this special ordering: like ringorder_a, except that pFDeg, pWeights
3183 // ignore it
3184 ord[0] = ringorder_aa;
3185 wv[0][rVar(origR)]=1;
3186 BOOLEAN wp=FALSE;
3187 for (int j=0;j<rVar(origR);j++)
3188 if (p_Weight(j+1,origR)!=1) { wp=TRUE;break; }
3189 if (wp)
3190 {
3191 wv[1]=(int*)omAlloc0((rVar(origR) + 1)*sizeof(int));
3192 for (int j=0;j<rVar(origR);j++)
3193 wv[1][j]=p_Weight(j+1,origR);
3194 ord[1] = ringorder_wp;
3195 }
3196 else
3197 ord[1] = ringorder_dp;
3198 ord[2] = ringorder_C;
3199 ord[3] = (rRingOrder_t)0;
3200 char **names=(char**)omAlloc0((origR->N+1) * sizeof(char *));
3201 for (int j=0;j<rVar(origR);j++)
3202 names[j]=origR->names[j];
3203 names[rVar(origR)]=(char*)"@";
3204 ring tmpR=rDefault(nCopyCoeff(origR->cf),rVar(origR)+1,names,4,ord,block0,block1,wv);
3205 omFree(names);
3206 rComplete(tmpR, 1);
3208 // map I
3210 // map J
3212 // J[1]*t-1
3213 poly t=pOne();
3214 p_SetExp(t,rVar(tmpR),1,tmpR);
3215 p_Setm(t,tmpR);
3216 poly p=JJ->m[0];
3217 p_Norm(p,currRing);
3218 p=p_Mult_q(p,t,tmpR);
3219 p=p_Sub(p,pOne(),tmpR);
3220 JJ->m[0]=p;
3222 idTest(T);
3223 id_Delete(&II,tmpR);
3224 id_Delete(&JJ,tmpR);
3225 // elimination
3226 t=pOne();
3227 p_SetExp(t,rVar(tmpR),1,tmpR);
3228 p_Setm(t,tmpR);
3230 p_Delete(&t,tmpR);
3231 for(int j=0;j<IDELEMS(TT);j++)
3232 {
3233 if ((TT->m[j]!=NULL)
3234 && (p_GetExp(TT->m[j],rVar(tmpR),tmpR)>0))
3235 {
3236 p_Delete(&TT->m[j],tmpR);
3237 }
3238 }
3239 // map back
3241 id_Delete(&TT,tmpR);
3243 rDelete(tmpR);
3245 return TTT;
3246}
int BOOLEAN
Definition auxiliary.h:87
int p
Definition cfModGcd.cc:4077
static FORCE_INLINE coeffs nCopyCoeff(const coeffs r)
"copy" coeffs, i.e. increment ref
Definition coeffs.h:430
int j
Definition facHensel.cc:110
static ideal idGroebner(ideal temp, int syzComp, GbVariant alg, intvec *hilb=NULL, intvec *w=NULL, tHomog hom=testHomog)
Definition ideals.cc:200
#define idTest(id)
Definition ideals.h:47
STATIC_VAR jList * T
Definition janet.cc:30
#define omFree(addr)
int p_Weight(int i, const ring r)
Definition p_polys.cc:705
void p_Norm(poly p1, const ring r)
Definition p_polys.cc:3719
poly p_Sub(poly p1, poly p2, const ring r)
Definition p_polys.cc:1990
static poly p_Mult_q(poly p, poly q, const ring r)
Definition p_polys.h:1114
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent @Note: VarOffset encodes the position in p->exp
Definition p_polys.h:488
static void p_Setm(poly p, const ring r)
Definition p_polys.h:233
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
#define pOne()
Definition polys.h:315
ideal idrCopyR(ideal id, ring src_r, ring dest_r)
Definition prCopy.cc:192
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:3459
void rDelete(ring r)
unconditionally deletes fields in r
Definition ring.cc:450
ring rDefault(const coeffs cf, int N, char **n, int ord_size, rRingOrder_t *ord, int *block0, int *block1, int **wvhdl, unsigned long bitmask)
Definition ring.cc:102
rRingOrder_t
order stuff
Definition ring.h:68
@ 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_wp
Definition ring.h:81
ideal id_SimpleAdd(ideal h1, ideal h2, const ring R)
concat the lists h1 and h2 without zeros
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size

◆ id_Satstd()

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

Definition at line 3116 of file ideals.cc.

3117{
3119 if (currRing!=r) rChangeCurrRing(r);
3120 idSkipZeroes(J);
3122 int k=IDELEMS(J);
3123 if (k>1)
3124 {
3125 for (int i=0; i<k; i++)
3126 {
3127 poly x = J->m[i];
3128 int li = p_Var(x,r);
3129 if (li>0)
3131 else
3132 {
3134 WerrorS("ideal generators must be variables");
3135 return NULL;
3136 }
3137 }
3138 }
3139 else
3140 {
3141 poly x = J->m[0];
3142 if (pNext(x)!=NULL)
3143 {
3144 Werror("generator must be a monomial");
3146 return NULL;
3147 }
3148 for (int i=1; i<=r->N; i++)
3149 {
3150 int li = p_GetExp(x,i,r);
3151 if (li==1)
3153 else if (li>1)
3154 {
3156 Werror("exponent(x(%d)^%d) must be 0 or 1",i,li);
3157 return NULL;
3158 }
3159 }
3160 }
3165 return res;
3166}
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:3001
static BOOLEAN id_sat_vars_sp(kStrategy strat)
Definition ideals.cc:3003
#define pNext(p)
Definition monomials.h:36
#define omFreeSize(addr, size)
int p_Var(poly m, const ring r)
Definition p_polys.cc:4656
void Werror(const char *fmt,...)
Definition reporter.cc:189

◆ id_TensorModuleMult()

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

Definition at line 2038 of file simpleideals.cc.

2039{
2040// #ifdef DEBU
2041// WarnS("tensorModuleMult!!!!");
2042
2043 assume(m > 0);
2044 assume(M != NULL);
2045
2046 const int n = rRing->N;
2047
2048 assume(M->rank <= m * n);
2049
2050 const int k = IDELEMS(M);
2051
2052 ideal idTemp = idInit(k,m); // = {f_1, ..., f_k }
2053
2054 for( int i = 0; i < k; i++ ) // for every w \in M
2055 {
2056 poly pTempSum = NULL;
2057
2058 poly w = M->m[i];
2059
2060 while(w != NULL) // for each term of w...
2061 {
2062 poly h = p_Head(w, rRing);
2063
2064 const int gen = __p_GetComp(h, rRing); // 1 ...
2065
2066 assume(gen > 0);
2067 assume(gen <= n*m);
2068
2069 // TODO: write a formula with %, / instead of while!
2070 /*
2071 int c = gen;
2072 int v = 1;
2073 while(c > m)
2074 {
2075 c -= m;
2076 v++;
2077 }
2078 */
2079
2080 int cc = gen % m;
2081 if( cc == 0) cc = m;
2082 int vv = 1 + (gen - cc) / m;
2083
2084// assume( cc == c );
2085// assume( vv == v );
2086
2087 // 1<= c <= m
2088 assume( cc > 0 );
2089 assume( cc <= m );
2090
2091 assume( vv > 0 );
2092 assume( vv <= n );
2093
2094 assume( (cc + (vv-1)*m) == gen );
2095
2096 p_IncrExp(h, vv, rRing); // h *= var(j) && // p_AddExp(h, vv, 1, rRing);
2097 p_SetComp(h, cc, rRing);
2098
2099 p_Setm(h, rRing); // addjust degree after the previous steps!
2100
2101 pTempSum = p_Add_q(pTempSum, h, rRing); // it is slow since h will be usually put to the back of pTempSum!!!
2102
2103 pIter(w);
2104 }
2105
2106 idTemp->m[i] = pTempSum;
2107 }
2108
2109 // simplify idTemp???
2110
2112
2114
2115 return(idResult);
2116}
int m
Definition cfEzgcd.cc:128
STATIC_VAR Poly * h
Definition janet.cc:971
#define assume(x)
Definition mod2.h:389
#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:936
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 poly p_Head(const poly p, const ring r)
copy the (leading) term of p
Definition p_polys.h:860
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 2629 of file ideals.cc.

2630{
2631 matrix result;
2633 poly p,q;
2634 intvec * convert;
2635 int i=IDELEMS(kbase),j=IDELEMS(arg),k,pos;
2636#if 0
2637 while ((i>0) && (kbase->m[i-1]==NULL)) i--;
2638 if (idIs0(arg))
2639 return mpNew(i,1);
2640 while ((j>0) && (arg->m[j-1]==NULL)) j--;
2641 result = mpNew(i,j);
2642#else
2643 result = mpNew(i, j);
2644 while ((j>0) && (arg->m[j-1]==NULL)) j--;
2645#endif
2646
2648 for (k=0;k<j;k++)
2649 {
2650 p = arg->m[k];
2651 while (p!=NULL)
2652 {
2653 q = idDecompose(p,how,tempKbase,&pos);
2654 if (pos>=0)
2655 {
2656 MATELEM(result,(*convert)[pos],k+1) =
2657 pAdd(MATELEM(result,(*convert)[pos],k+1),q);
2658 }
2659 else
2660 p_Delete(&q,currRing);
2661 pIter(p);
2662 }
2663 }
2665 return result;
2666}
ideal idCreateSpecialKbase(ideal kBase, intvec **convert)
Definition ideals.cc:2543
poly idDecompose(poly monom, poly how, ideal kbase, int *pos)
Definition ideals.cc:2597
#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}
#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 2964 of file ideals.cc.

2965{
2966 int idsize = IDELEMS(id);
2968 for (int i = 0; i < idsize; i++)
2969 {
2970 id_sort[i].p = id->m[i];
2971 id_sort[i].index = i;
2972 }
2974 int index, index_i, index_j;
2975 int i = 0;
2976 for (int j = 1; j < idsize; j++)
2977 {
2978 if (id_sort[i].p != NULL && pEqualPolys(id_sort[i].p, id_sort[j].p))
2979 {
2980 index_i = id_sort[i].index;
2981 index_j = id_sort[j].index;
2982 if (index_j > index_i)
2983 {
2984 index = index_j;
2985 }
2986 else
2987 {
2988 index = index_i;
2989 i = j;
2990 }
2991 pDelete(&id->m[index]);
2992 }
2993 else
2994 {
2995 i = j;
2996 }
2997 }
2999}
void idSort_qsort(poly_sort *id_sort, int idsize)
Definition ideals.cc:2955
static int index(p_Length length, p_Ord ord)
#define pDelete(p_ptr)
Definition polys.h:186
#define pEqualPolys(p1, p2)
Definition polys.h:399

◆ idDiff()

matrix idDiff ( matrix i,
int k )

Definition at line 2146 of file ideals.cc.

2147{
2148 int e=MATCOLS(i)*MATROWS(i);
2150 r->rank=i->rank;
2151 int j;
2152 for(j=0; j<e; j++)
2153 {
2154 r->m[j]=pDiff(i->m[j],k);
2155 }
2156 return r;
2157}
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 2159 of file ideals.cc.

2160{
2162 int i,j;
2163 for(i=0; i<IDELEMS(I); i++)
2164 {
2165 for(j=0; j<IDELEMS(J); j++)
2166 {
2167 MATELEM(r,i+1,j+1)=pDiffOp(I->m[i],J->m[j],multiply);
2168 }
2169 }
2170 return r;
2171}
#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 1605 of file ideals.cc.

1606{
1607 int i,j=0,k,l;
1608 ideal h,hh, h3;
1609 rRingOrder_t *ord;
1610 int *block0,*block1;
1611 int ordersize=2;
1612 int **wv;
1613 tHomog hom;
1614 intvec * w;
1615 ring tmpR;
1617
1618 if (delVar==NULL)
1619 {
1620 return idCopy(h1);
1621 }
1622 if ((currRing->qideal!=NULL) && rIsPluralRing(origR))
1623 {
1624 WerrorS("cannot eliminate in a qring");
1625 return NULL;
1626 }
1627 if (idIs0(h1)) return idInit(1,h1->rank);
1628#ifdef HAVE_PLURAL
1629 if (rIsPluralRing(origR))
1630 /* in the NC case, we have to check the admissibility of */
1631 /* the subalgebra to be intersected with */
1632 {
1633 if ((ncRingType(origR) != nc_skew) && (ncRingType(origR) != nc_exterior)) /* in (quasi)-commutative algebras every subalgebra is admissible */
1634 {
1636 {
1637 WerrorS("no elimination is possible: subalgebra is not admissible");
1638 return NULL;
1639 }
1640 }
1641 }
1642#endif
1643 hom=(tHomog)idHomModule(h1,NULL,&w); //sets w to weight vector or NULL
1644 h3=idInit(16,h1->rank);
1646#if 0
1647 if (rIsPluralRing(origR)) // we have too keep the odering: it may be needed
1648 // for G-algebra
1649 {
1650 for (k=0;k<ordersize-1; k++)
1651 {
1652 block0[k+1] = origR->block0[k];
1653 block1[k+1] = origR->block1[k];
1654 ord[k+1] = origR->order[k];
1655 if (origR->wvhdl[k]!=NULL) wv[k+1] = (int*) omMemDup(origR->wvhdl[k]);
1656 }
1657 }
1658 else
1659 {
1660 block0[1] = 1;
1661 block1[1] = (currRing->N);
1662 if (origR->OrdSgn==1) ord[1] = ringorder_wp;
1663 else ord[1] = ringorder_ws;
1664 wv[1]=(int*)omAlloc0((currRing->N)*sizeof(int));
1665 double wNsqr = (double)2.0 / (double)(currRing->N);
1667 int *x= (int * )omAlloc(2 * ((currRing->N) + 1) * sizeof(int));
1668 int sl=IDELEMS(h1) - 1;
1669 wCall(h1->m, sl, x, wNsqr);
1670 for (sl = (currRing->N); sl!=0; sl--)
1671 wv[1][sl-1] = x[sl + (currRing->N) + 1];
1672 omFreeSize((ADDRESS)x, 2 * ((currRing->N) + 1) * sizeof(int));
1673
1674 ord[2]=ringorder_C;
1675 ord[3]=0;
1676 }
1677#else
1678#endif
1679 if ((hom==TRUE) && (origR->OrdSgn==1) && (!rIsPluralRing(origR)))
1680 {
1681 #if 1
1682 // we change to an ordering:
1683 // aa(1,1,1,...,0,0,0),wp(...),C
1684 // this seems to be better than version 2 below,
1685 // according to Tst/../elimiate_[3568].tat (- 17 %)
1686 ord=(rRingOrder_t*)omAlloc0(4*sizeof(rRingOrder_t));
1687 block0=(int*)omAlloc0(4*sizeof(int));
1688 block1=(int*)omAlloc0(4*sizeof(int));
1689 wv=(int**) omAlloc0(4*sizeof(int**));
1690 block0[0] = block0[1] = 1;
1691 block1[0] = block1[1] = rVar(origR);
1692 wv[0]=(int*)omAlloc0((rVar(origR) + 1)*sizeof(int));
1693 // use this special ordering: like ringorder_a, except that pFDeg, pWeights
1694 // ignore it
1695 ord[0] = ringorder_aa;
1696 for (j=0;j<rVar(origR);j++)
1697 if (pGetExp(delVar,j+1)!=0) wv[0][j]=1;
1698 BOOLEAN wp=FALSE;
1699 for (j=0;j<rVar(origR);j++)
1700 if (p_Weight(j+1,origR)!=1) { wp=TRUE;break; }
1701 if (wp)
1702 {
1703 wv[1]=(int*)omAlloc0((rVar(origR) + 1)*sizeof(int));
1704 for (j=0;j<rVar(origR);j++)
1705 wv[1][j]=p_Weight(j+1,origR);
1706 ord[1] = ringorder_wp;
1707 }
1708 else
1709 ord[1] = ringorder_dp;
1710 #else
1711 // we change to an ordering:
1712 // a(w1,...wn),wp(1,...0.....),C
1713 ord=(int*)omAlloc0(4*sizeof(int));
1714 block0=(int*)omAlloc0(4*sizeof(int));
1715 block1=(int*)omAlloc0(4*sizeof(int));
1716 wv=(int**) omAlloc0(4*sizeof(int**));
1717 block0[0] = block0[1] = 1;
1718 block1[0] = block1[1] = rVar(origR);
1719 wv[0]=(int*)omAlloc0((rVar(origR) + 1)*sizeof(int));
1720 wv[1]=(int*)omAlloc0((rVar(origR) + 1)*sizeof(int));
1721 ord[0] = ringorder_a;
1722 for (j=0;j<rVar(origR);j++)
1723 wv[0][j]=pWeight(j+1,origR);
1724 ord[1] = ringorder_wp;
1725 for (j=0;j<rVar(origR);j++)
1726 if (pGetExp(delVar,j+1)!=0) wv[1][j]=1;
1727 #endif
1728 ord[2] = ringorder_C;
1729 ord[3] = (rRingOrder_t)0;
1730 }
1731 else
1732 {
1733 // we change to an ordering:
1734 // aa(....),orig_ordering
1736 block0=(int*)omAlloc0(ordersize*sizeof(int));
1737 block1=(int*)omAlloc0(ordersize*sizeof(int));
1738 wv=(int**) omAlloc0(ordersize*sizeof(int**));
1739 for (k=0;k<ordersize-1; k++)
1740 {
1741 block0[k+1] = origR->block0[k];
1742 block1[k+1] = origR->block1[k];
1743 ord[k+1] = origR->order[k];
1744 if (origR->wvhdl[k]!=NULL)
1745 #ifdef HAVE_OMALLOC
1746 wv[k+1] = (int*) omMemDup(origR->wvhdl[k]);
1747 #else
1748 {
1749 int l=(origR->block1[k]-origR->block0[k]+1)*sizeof(int);
1750 if (origR->order[k]==ringorder_a64) l*=2;
1751 wv[k+1]=(int*)omalloc(l);
1752 memcpy(wv[k+1],origR->wvhdl[k],l);
1753 }
1754 #endif
1755 }
1756 block0[0] = 1;
1757 block1[0] = rVar(origR);
1758 wv[0]=(int*)omAlloc0((rVar(origR) + 1)*sizeof(int));
1759 for (j=0;j<rVar(origR);j++)
1760 if (pGetExp(delVar,j+1)!=0) wv[0][j]=1;
1761 // use this special ordering: like ringorder_a, except that pFDeg, pWeights
1762 // ignore it
1763 ord[0] = ringorder_aa;
1764 }
1765 // fill in tmp ring to get back the data later on
1766 tmpR = rCopy0(origR,FALSE,FALSE); // qring==NULL
1767 //rUnComplete(tmpR);
1768 tmpR->p_Procs=NULL;
1769 tmpR->order = ord;
1770 tmpR->block0 = block0;
1771 tmpR->block1 = block1;
1772 tmpR->wvhdl = wv;
1773 rComplete(tmpR, 1);
1774
1775#ifdef HAVE_PLURAL
1776 /* update nc structure on tmpR */
1777 if (rIsPluralRing(origR))
1778 {
1779 if ( nc_rComplete(origR, tmpR, false) ) // no quotient ideal!
1780 {
1781 WerrorS("no elimination is possible: ordering condition is violated");
1782 // cleanup
1783 rDelete(tmpR);
1784 if (w!=NULL)
1785 delete w;
1786 return NULL;
1787 }
1788 }
1789#endif
1790 // change into the new ring
1791 //pChangeRing((currRing->N),currRing->OrdSgn,ord,block0,block1,wv);
1793
1794 //h = idInit(IDELEMS(h1),h1->rank);
1795 // fetch data from the old ring
1796 //for (k=0;k<IDELEMS(h1);k++) h->m[k] = prCopyR( h1->m[k], origR);
1798 if (origR->qideal!=NULL)
1799 {
1800 WarnS("eliminate in q-ring: experimental");
1801 ideal q=idrCopyR(origR->qideal,origR,currRing);
1802 ideal s=idSimpleAdd(h,q);
1803 idDelete(&h);
1804 idDelete(&q);
1805 h=s;
1806 }
1807 // compute GB
1808 if ((alg!=GbDefault)
1809 && (alg!=GbGroebner)
1810 && (alg!=GbModstd)
1811 && (alg!=GbSlimgb)
1812 && (alg!=GbSba)
1813 && (alg!=GbStd))
1814 {
1815 WarnS("wrong algorithm for GB");
1816 alg=GbDefault;
1817 }
1818 hh=idGroebner(h,0,alg,hilb);
1819 // go back to the original ring
1821 i = IDELEMS(hh)-1;
1822 while ((i >= 0) && (hh->m[i] == NULL)) i--;
1823 j = -1;
1824 // fetch data from temp ring
1825 for (k=0; k<=i; k++)
1826 {
1827 l=(currRing->N);
1828 while ((l>0) && (p_GetExp( hh->m[k],l,tmpR)*pGetExp(delVar,l)==0)) l--;
1829 if (l==0)
1830 {
1831 j++;
1832 if (j >= IDELEMS(h3))
1833 {
1834 pEnlargeSet(&(h3->m),IDELEMS(h3),16);
1835 IDELEMS(h3) += 16;
1836 }
1837 h3->m[j] = prMoveR( hh->m[k], tmpR,origR);
1838 hh->m[k] = NULL;
1839 }
1840 }
1841 id_Delete(&hh, tmpR);
1843 rDelete(tmpR);
1844 if (w!=NULL)
1845 delete w;
1846 return h3;
1847}
int l
Definition cfEzgcd.cc:100
const CanonicalForm int s
Definition facAbsFact.cc:51
#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)
#define omAlloc(size)
#define omalloc(size)
#define omMemDup(s)
void pEnlargeSet(poly **p, int l, int increment)
Definition p_polys.cc:3696
#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:90
BOOLEAN nc_rComplete(const ring src, ring dest, bool bSetupQuotient)
Definition ring.cc:5746
ring rCopy0(const ring r, BOOLEAN copy_qideal, BOOLEAN copy_ordering)
Definition ring.cc:1421
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
Definition ring.h:400
static int rBlocks(const ring r)
Definition ring.h:568
@ ringorder_a
Definition ring.h:70
@ ringorder_a64
for int64 weights
Definition ring.h:71
@ ringorder_ws
Definition ring.h:86
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.cc: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 1094 of file simpleideals.cc.

1095{
1096 int i = r-1,j;
1097 while ((i >= 0) && (choise[i] == end))
1098 {
1099 i--;
1100 end--;
1101 }
1102 if (i == -1)
1103 *endch = TRUE;
1104 else
1105 {
1106 choise[i]++;
1107 for (j=i+1; j<r; j++)
1108 {
1109 choise[j] = choise[i]+j-i;
1110 }
1111 *endch = FALSE;
1112 }
1113}

◆ idGetNumberOfChoise()

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

Definition at line 1120 of file simpleideals.cc.

1121{
1122 int * localchoise,i,result=0;
1123 BOOLEAN b=FALSE;
1124
1125 if (d<=1) return 1;
1126 localchoise=(int*)omAlloc((d-1)*sizeof(int));
1127 idInitChoise(d-1,begin,end,&b,localchoise);
1128 while (!b)
1129 {
1130 result++;
1131 i = 0;
1132 while ((i<t) && (localchoise[i]==choise[i])) i++;
1133 if (i>=t)
1134 {
1135 i = t+1;
1136 while ((i<d) && (localchoise[i-1]==choise[i])) i++;
1137 if (i>=d)
1138 {
1139 omFreeSize((ADDRESS)localchoise,(d-1)*sizeof(int));
1140 return result;
1141 }
1142 }
1143 idGetNextChoise(d-1,end,&b,localchoise);
1144 }
1145 omFreeSize((ADDRESS)localchoise,(d-1)*sizeof(int));
1146 return 0;
1147}
CanonicalForm b
Definition cfModGcd.cc:4102
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}
BOOLEAN id_HomIdeal(ideal id, ideal Q, const ring r)
#define Q
Definition sirandom.c:26

◆ 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 1072 of file simpleideals.cc.

1073{
1074 /*returns the first choise of r numbers between beg and end*/
1075 int i;
1076 for (i=0; i<r; i++)
1077 {
1078 choise[i] = 0;
1079 }
1080 if (r <= end-beg+1)
1081 for (i=0; i<r; i++)
1082 {
1083 choise[i] = beg+i;
1084 }
1085 if (r > end-beg+1)
1086 *endch = TRUE;
1087 else
1088 *endch = FALSE;
1089}

◆ 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 835 of file simpleideals.cc.

836{
837 if (h2==NULL) return FALSE;
838 assume (h1 != NULL);
839
840 int j = IDELEMS(h1) - 1;
841
842 while ((j >= 0) && (h1->m[j] == NULL)) j--;
843 j++;
844 if (j==IDELEMS(h1))
845 {
846 pEnlargeSet(&(h1->m),IDELEMS(h1),16);
847 IDELEMS(h1)+=16;
848 }
849 h1->m[j]=h2;
850 return TRUE;
851}

◆ idInsertPolyOnPos()

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

insert p into I on position pos

Definition at line 854 of file simpleideals.cc.

855{
856 if (p==NULL) return FALSE;
857 assume (I != NULL);
858
859 int j = IDELEMS(I) - 1;
860
861 while ((j >= 0) && (I->m[j] == NULL)) j--;
862 j++;
863 if (j==IDELEMS(I))
864 {
865 pEnlargeSet(&(I->m),IDELEMS(I),IDELEMS(I)+1);
866 IDELEMS(I)+=1;
867 }
868 for(j = IDELEMS(I)-1;j>pos;j--)
869 I->m[j] = I->m[j-1];
870 I->m[pos]=p;
871 return TRUE;
872}

◆ 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{
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 963 of file simpleideals.cc.

964{
965 assume (h != NULL); // will fail :(
966// if (h == NULL) return TRUE;
967
968 for( int i = IDELEMS(h)-1; i >= 0; i-- )
969 if(h->m[i] != NULL)
970 return FALSE;
971
972 return TRUE;
973
974}

◆ idIsSubModule()

BOOLEAN idIsSubModule ( ideal id1,
ideal id2 )

Definition at line 2056 of file ideals.cc.

2057{
2058 int i;
2059 poly p;
2060
2061 if (idIs0(id1)) return TRUE;
2062 for (i=0;i<IDELEMS(id1);i++)
2063 {
2064 if (id1->m[i] != NULL)
2065 {
2066 p = kNF(id2,currRing->qideal,id1->m[i]);
2067 if (p != NULL)
2068 {
2070 return FALSE;
2071 }
2072 }
2073 }
2074 return TRUE;
2075}
poly kNF(ideal F, ideal Q, poly p, int syzComp, int lazyReduce)
Definition kstd1.cc:3185

◆ idIsZeroDim()

static BOOLEAN idIsZeroDim ( ideal i)
inlinestatic

Definition at line 177 of file ideals.h.

178{
179 return id_IsZeroDim(i, currRing);
180}
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 2932 of file ideals.cc.

2933{
2934 for (int i = IDELEMS(id)-1; i >= k; i--)
2935 {
2936 if (id->m[i] != NULL) pDelete(&id->m[i]);
2937 }
2938 int kk=k;
2939 if (k==0) kk=1; /* ideals must have at least one element(0)*/
2940 pEnlargeSet(&(id->m), IDELEMS(id), kk-IDELEMS(id));
2941 IDELEMS(id) = kk;
2942}

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

represents the generators of submod in terms of the generators of mod (Matrix(SM)*U-Matrix(rest)) = Matrix(M)*Matrix(result) goodShape: maximal non-zero index in generators of SM <= that of M isSB: generators of M form a Groebner basis divide: allow SM not to be a submodule of M U is an diagonal matrix of units (non-constant only in local rings) rest is: 0 if SM in M, SM if not divide, NF(SM,std(M)) if divide

Definition at line 1105 of file ideals.cc.

1107{
1109 int comps_to_add=0;
1110 int idelems_mod=IDELEMS(mod);
1112 poly p;
1113
1114 if (idIs0(submod))
1115 {
1116 if (rest!=NULL)
1117 {
1118 *rest=idInit(1,mod->rank);
1119 }
1121 return idInit(1,idelems_mod);
1122 }
1123 if (idIs0(mod)) /* and not idIs0(submod) */
1124 {
1125 if (rest!=NULL)
1126 {
1127 *rest=idCopy(submod);
1129 return idInit(1,idelems_mod);
1130 }
1131 else
1132 {
1133 WerrorS("2nd module does not lie in the first");
1134 return NULL;
1135 }
1136 }
1137 if (unit!=NULL)
1138 {
1140 while ((comps_to_add>0) && (submod->m[comps_to_add-1]==NULL))
1141 comps_to_add--;
1142 }
1144 if ((k!=0) && (lsmod==0)) lsmod=1;
1145 k=si_max(k,(int)mod->rank);
1146 if (k<submod->rank) { WarnS("rk(submod) > rk(mod) ?");k=submod->rank; }
1147
1152
1154 if (orig_ring != syz_ring)
1155 {
1158 }
1159 else
1160 {
1161 s_mod = mod;
1162 s_temp = idCopy(submod);
1163 }
1164 BITSET save2;
1166
1167 if ((rest==NULL)
1169 && (!rIsNCRing(currRing))
1170 && (!TEST_OPT_RETURN_SB))
1172 else
1173 si_opt_2 &=~Sy_bit(V_IDLIFT);
1174 ideal s_h3;
1175 if (isSB && !TEST_OPT_IDLIFT)
1176 {
1177 s_h3 = idCopy(s_mod);
1179 }
1180 else
1181 {
1183 }
1185
1186 if (!goodShape)
1187 {
1188 for (j=0;j<IDELEMS(s_h3);j++)
1189 {
1190 if ((s_h3->m[j] != NULL) && (pMinComp(s_h3->m[j]) > k))
1191 p_Delete(&(s_h3->m[j]),currRing);
1192 }
1193 }
1195 if (lsmod==0)
1196 {
1198 }
1199 if (unit!=NULL)
1200 {
1201 for(j = 0;j<comps_to_add;j++)
1202 {
1203 p = s_temp->m[j];
1204 if (p!=NULL)
1205 {
1206 while (pNext(p)!=NULL) pIter(p);
1207 pNext(p) = pOne();
1208 pIter(p);
1209 pSetComp(p,1+j+k);
1210 pSetmComp(p);
1211 p = pNeg(p);
1212 }
1213 }
1214 s_temp->rank += (k+comps_to_add);
1215 }
1216 ideal s_result = kNF(s_h3,currRing->qideal,s_temp,k);
1217 s_result->rank = s_h3->rank;
1219 idDelete(&s_h3);
1220 idDelete(&s_temp);
1221
1222 for (j=0;j<IDELEMS(s_result);j++)
1223 {
1224 if (s_result->m[j]!=NULL)
1225 {
1226 if (pGetComp(s_result->m[j])<=k)
1227 {
1228 if (!divide)
1229 {
1230 if (rest==NULL)
1231 {
1232 if (isSB)
1233 {
1234 WarnS("first module not a standardbasis\n"
1235 "// ** or second not a proper submodule");
1236 }
1237 else
1238 WerrorS("2nd module does not lie in the first");
1239 }
1241 idDelete(&s_rest);
1242 if(syz_ring!=orig_ring)
1243 {
1244 idDelete(&s_mod);
1247 }
1248 if (unit!=NULL)
1249 {
1251 }
1252 if (rest!=NULL) *rest=idCopy(submod);
1254 return s_result;
1255 }
1256 else
1257 {
1258 p = s_rest->m[j] = s_result->m[j];
1259 while ((pNext(p)!=NULL) && (pGetComp(pNext(p))<=k)) pIter(p);
1260 s_result->m[j] = pNext(p);
1261 pNext(p) = NULL;
1262 }
1263 }
1264 p_Shift(&(s_result->m[j]),-k,currRing);
1265 pNeg(s_result->m[j]);
1266 }
1267 }
1268 if ((lsmod==0) && (s_rest!=NULL))
1269 {
1270 for (j=IDELEMS(s_rest);j>0;j--)
1271 {
1272 if (s_rest->m[j-1]!=NULL)
1273 {
1274 p_Shift(&(s_rest->m[j-1]),-1,currRing);
1275 }
1276 }
1277 }
1278 if(syz_ring!=orig_ring)
1279 {
1280 idDelete(&s_mod);
1285 }
1286 if (rest!=NULL)
1287 {
1288 s_rest->rank=mod->rank;
1289 *rest = s_rest;
1290 }
1291 else
1292 idDelete(&s_rest);
1293 if (unit!=NULL)
1294 {
1296 int i;
1297 for(i=0;i<IDELEMS(s_result);i++)
1298 {
1299 poly p=s_result->m[i];
1300 poly q=NULL;
1301 while(p!=NULL)
1302 {
1303 if(pGetComp(p)<=comps_to_add)
1304 {
1305 pSetComp(p,0);
1306 if (q!=NULL)
1307 {
1308 pNext(q)=pNext(p);
1309 }
1310 else
1311 {
1312 pIter(s_result->m[i]);
1313 }
1314 pNext(p)=NULL;
1315 MATELEM(*unit,i+1,i+1)=pAdd(MATELEM(*unit,i+1,i+1),p);
1316 if(q!=NULL) p=pNext(q);
1317 else p=s_result->m[i];
1318 }
1319 else
1320 {
1321 q=p;
1322 pIter(p);
1323 }
1324 }
1326 }
1327 }
1328 s_result->rank=idelems_mod;
1329 return s_result;
1330}
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
VAR unsigned si_opt_2
Definition options.c:6
#define TEST_OPT_IDLIFT
Definition options.h:129
#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:112
#define V_IDLIFT
Definition options.h:63
void p_Shift(poly *p, int i, const ring r)
shifts components of the vector p by i
Definition p_polys.cc:4706
#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 pMinComp(p)
Definition polys.h:300
ideal idrMoveR_NoSort(ideal &id, ring src_r, ring dest_r)
Definition prCopy.cc:261
ideal idrCopyR_NoSort(ideal id, ring src_r, ring dest_r)
Definition prCopy.cc:205
ring rAssure_SyzOrder(const ring r, BOOLEAN complete)
Definition ring.cc:4439
void rSetSyzComp(int k, const ring r)
Definition ring.cc:5147
static BOOLEAN rIsNCRing(const ring r)
Definition ring.h:421
#define rField_is_Ring(R)
Definition ring.h:485
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)
#define BITSET
Definition structs.h:16

◆ 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{
980 long k;
981 intvec *w=NULL;
982
983 idDelete((ideal*)T);
985 if (S!=NULL) { lift3=TRUE; idDelete(S); }
986 if (idIs0(h1))
987 {
988 *T=mpNew(1,IDELEMS(h1));
989 if (lift3)
990 {
992 }
993 return idInit(1,h1->rank);
994 }
995
998
1000
1002
1007
1008 ideal s_h1;
1009
1010 if (orig_ring != syz_ring)
1012 else
1013 s_h1 = h1;
1015 if (h11!=NULL)
1016 {
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
1034
1036 s_h3->rank=h1->rank;
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

◆ idLiftW()

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

Definition at line 1336 of file ideals.cc.

1337{
1338 long N=0;
1339 int i;
1340 for(i=IDELEMS(Q)-1;i>=0;i--)
1341 if(w==NULL)
1342 N=si_max(N,p_Deg(Q->m[i],currRing));
1343 else
1344 N=si_max(N,p_DegW(Q->m[i],w,currRing));
1345 N+=n;
1346
1347 T=mpNew(IDELEMS(Q),IDELEMS(P));
1348 R=idInit(IDELEMS(P),P->rank);
1349
1350 for(i=IDELEMS(P)-1;i>=0;i--)
1351 {
1352 poly p;
1353 if(w==NULL)
1354 p=ppJet(P->m[i],N);
1355 else
1356 p=ppJetW(P->m[i],N,w);
1357
1358 int j=IDELEMS(Q)-1;
1359 while(p!=NULL)
1360 {
1361 if(pDivisibleBy(Q->m[j],p))
1362 {
1363 poly p0=p_DivideM(pHead(p),pHead(Q->m[j]),currRing);
1364 if(w==NULL)
1365 p=pJet(pSub(p,ppMult_mm(Q->m[j],p0)),N);
1366 else
1367 p=pJetW(pSub(p,ppMult_mm(Q->m[j],p0)),N,w);
1368 pNormalize(p);
1369 if(((w==NULL)&&(p_Deg(p0,currRing)>n))||((w!=NULL)&&(p_DegW(p0,w,currRing)>n)))
1371 else
1372 MATELEM(T,j+1,i+1)=pAdd(MATELEM(T,j+1,i+1),p0);
1373 j=IDELEMS(Q)-1;
1374 }
1375 else
1376 {
1377 if(j==0)
1378 {
1379 poly p0=p;
1380 pIter(p);
1381 pNext(p0)=NULL;
1382 if(((w==NULL)&&(p_Deg(p0,currRing)>n))
1383 ||((w!=NULL)&&(p_DegW(p0,w,currRing)>n)))
1385 else
1386 R->m[i]=pAdd(R->m[i],p0);
1387 j=IDELEMS(Q)-1;
1388 }
1389 else
1390 j--;
1391 }
1392 }
1393 }
1394}
poly p_DivideM(poly a, poly b, const ring r)
Definition p_polys.cc:1578
long p_DegW(poly p, const int *w, const ring R)
Definition p_polys.cc:690
long p_Deg(poly a, const ring r)
Definition p_polys.cc:587
#define ppJet(p, m)
Definition polys.h:366
#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:367
#define pSub(a, b)
Definition polys.h:287
#define ppJetW(p, m, iv)
Definition polys.h:368
#define pJetW(p, m, iv)
Definition polys.h:369
#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,
ideal * SB = NULL )

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 h2 = kStd(h1,currRing->qideal,isNotHomog,NULL);
86 if (SB!=NULL) *SB=h2;
87 h3 = idMaxIdeal(1);
88 h4=idMult(h2,h3);
89 idDelete(&h3);
91 k = IDELEMS(h3);
92 while ((k > 0) && (h3->m[k-1] == NULL)) k--;
93 j = -1;
94 l = IDELEMS(h2);
95 while ((l > 0) && (h2->m[l-1] == NULL)) l--;
96 for (i=l-1; i>=0; i--)
97 {
98 if (h2->m[i] != NULL)
99 {
100 ll = 0;
101 while ((ll < k) && ((h3->m[ll] == NULL)
102 || !pDivisibleBy(h3->m[ll],h2->m[i])))
103 ll++;
104 if (ll >= k)
105 {
106 j++;
107 if (j > IDELEMS(e)-1)
108 {
109 pEnlargeSet(&(e->m),IDELEMS(e),16);
110 IDELEMS(e) += 16;
111 }
112 e->m[j] = pCopy(h2->m[i]);
113 }
114 }
115 }
116 if (SB==NULL) idDelete(&h2);
117 idDelete(&h3);
118 idDelete(&h4);
119 if (currRing->qideal!=NULL)
120 {
121 h3=idInit(1,e->rank);
122 h2=kNF(h3,currRing->qideal,e);
123 idDelete(&h3);
124 idDelete(&e);
125 e=h2;
126 }
127 idSkipZeroes(e);
128 return e;
129}
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:3035
#define pCopy(p)
return a copy of the poly
Definition polys.h:185
BOOLEAN rHasGlobalOrdering(const ring r)
Definition ring.h:761
@ isNotHomog
Definition structs.h:36

◆ idMinEmbedding()

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

Definition at line 2695 of file ideals.cc.

2696{
2697 if (idIs0(arg)) return idInit(1,arg->rank);
2698 int i,next_gen,next_comp;
2699 ideal res=arg;
2700 if (!inPlace) res = idCopy(arg);
2702 int *red_comp=(int*)omAlloc((res->rank+1)*sizeof(int));
2703 for (i=res->rank;i>=0;i--) red_comp[i]=i;
2704
2705 int del=0;
2706 loop
2707 {
2709 if (next_gen<0) break;
2710 del++;
2712 for(i=next_comp+1;i<=arg->rank;i++) red_comp[i]--;
2713 if ((w !=NULL)&&(*w!=NULL))
2714 {
2715 for(i=next_comp;i<(*w)->length();i++) (**w)[i-1]=(**w)[i];
2716 }
2717 }
2718
2722
2723 if ((w !=NULL)&&(*w!=NULL) &&(del>0))
2724 {
2725 int nl=si_max((*w)->length()-del,1);
2726 intvec *wtmp=new intvec(nl);
2727 for(i=0;i<res->rank;i++) (*wtmp)[i]=(**w)[i];
2728 delete *w;
2729 *w=wtmp;
2730 }
2731 return res;
2732}
int length() const
static void idDeleteComps(ideal arg, int *red_comp, int del)
Definition ideals.cc:2668
int id_ReadOutPivot(ideal arg, int *comp, const ring r)
#define loop
Definition structs.h:75
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 1988 of file ideals.cc.

1989{
1990
1991 const ring origR=currRing;
1992 id_Test((ideal)a, origR);
1993
1994 const int r = a->nrows;
1995 const int c = a->ncols;
1996
1997 if((ar<=0) || (ar>r) || (ar>c))
1998 {
1999 Werror("%d-th minor, matrix is %dx%d",ar,r,c);
2000 return NULL;
2001 }
2002
2004 long bound = sm_ExpBound(h,c,r,ar,origR);
2005 id_Delete(&h, origR);
2006
2008
2009 matrix b = mpNew(r,c);
2010
2011 for (int i=r*c-1;i>=0;i--)
2012 if (a->m[i] != NULL)
2013 b->m[i] = prCopyR(a->m[i],origR,tmpR);
2014
2015 id_Test( (ideal)b, tmpR);
2016
2017 if (R!=NULL)
2018 {
2019 R = idrCopyR(R,origR,tmpR); // TODO: overwrites R? memory leak?
2020 //if (ar>1) // otherwise done in mpMinorToResult
2021 //{
2022 // matrix bb=(matrix)kNF(R,currRing->qideal,(ideal)b);
2023 // bb->rank=b->rank; bb->nrows=b->nrows; bb->ncols=b->ncols;
2024 // idDelete((ideal*)&b); b=bb;
2025 //}
2026 id_Test( R, tmpR);
2027 }
2028
2029 int size=binom(r,ar)*binom(c,ar);
2030 ideal result = idInit(size,1);
2031
2032 int elems = 0;
2033
2034 if(ar>1)
2035 mp_RecMin(ar-1,result,elems,b,r,c,NULL,R,tmpR);
2036 else
2037 mp_MinorToResult(result,elems,b,r,c,R,tmpR);
2038
2039 id_Test( (ideal)b, tmpR);
2040
2041 id_Delete((ideal *)&b, tmpR);
2042
2043 if (R!=NULL) id_Delete(&R,tmpR);
2044
2048 idTest(result);
2049 return result;
2050}
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)
matrix mp_Copy(matrix a, const ring r)
copies matrix a (from ring r to r)
Definition matpol.cc:57
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:1500
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:1596
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 2422 of file ideals.cc.

2423{
2424#ifdef HAVE_SHIFTBBA
2425 if (rIsLPRing(currRing))
2426 return idModuloLP(h2,h1,hom,w,T,alg);
2427#endif
2428 intvec *wtmp=NULL;
2429 if (T!=NULL) idDelete((ideal*)T);
2430
2431 int i,flength=0,slength,length;
2432
2433 if (idIs0(h2))
2434 return idFreeModule(si_max(1,h2->ncols));
2435 if (!idIs0(h1))
2440 if (length==0)
2441 {
2442 length = 1;
2444 }
2445 if ((w!=NULL)&&((*w)!=NULL))
2446 {
2447 //Print("input weights:");(*w)->show(1);PrintLn();
2448 int d;
2449 int k;
2450 wtmp=new intvec(length+IDELEMS(h2));
2451 for (i=0;i<length;i++)
2452 ((*wtmp)[i])=(**w)[i];
2453 for (i=0;i<IDELEMS(h2);i++)
2454 {
2455 poly p=h2->m[i];
2456 if (p!=NULL)
2457 {
2458 d = p_Deg(p,currRing);
2459 k= pGetComp(p);
2460 if (slength>0) k--;
2461 d +=((**w)[k]);
2462 ((*wtmp)[i+length]) = d;
2463 }
2464 }
2465 //Print("weights:");wtmp->show(1);PrintLn();
2466 }
2467 ideal s_temp1;
2471 {
2473 ideal s1,s2;
2474
2475 if (syz_ring != orig_ring)
2476 {
2479 }
2480 else
2481 {
2482 s1=idCopy(h1);
2483 s2=idCopy(h2);
2484 }
2485
2486 unsigned save_opt,save_opt2;
2489 if (T==NULL) si_opt_1 |= Sy_bit(OPT_REDTAIL);
2494 }
2495
2496 //if (wtmp!=NULL) Print("output weights:");wtmp->show(1);PrintLn();
2497 if ((w!=NULL) && (*w !=NULL) && (wtmp!=NULL))
2498 {
2499 delete *w;
2500 *w=new intvec(IDELEMS(h2));
2501 for (i=0;i<IDELEMS(h2);i++)
2502 ((**w)[i])=(*wtmp)[i+length];
2503 }
2504 if (wtmp!=NULL) delete wtmp;
2505
2508
2509 idDelete(&s_temp1);
2510 if (syz_ring!=orig_ring)
2511 {
2513 }
2514 idTest(h2);
2515 idTest(h1);
2516 idTest(result);
2517 if (T!=NULL) idTest((ideal)*T);
2518 return result;
2519}
ideal idModuloLP(ideal h2, ideal h1, tHomog, intvec **w, matrix *T, GbVariant alg)
Definition ideals.cc:2229
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 471 of file ideals.cc.

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

◆ idQuot()

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

Definition at line 1506 of file ideals.cc.

1507{
1508 // first check for special case h1:(0)
1509 if (idIs0(h2))
1510 {
1511 ideal res;
1512 if (resultIsIdeal)
1513 {
1514 res = idInit(1,1);
1515 res->m[0] = pOne();
1516 }
1517 else
1518 res = idFreeModule(h1->rank);
1519 return res;
1520 }
1521 int i, kmax;
1524 intvec * weights1;
1525
1527
1529
1534 if (orig_ring!=syz_ring)
1535 // s_h4 = idrMoveR_NoSort(s_h4,orig_ring, syz_ring);
1537 idTest(s_h4);
1538
1539 #if 0
1541 PrintS("start:\n");
1542 ipPrint_MA0(m,"Q");
1543 idDelete((ideal *)&m);
1544 PrintS("last elem:");wrp(s_h4->m[IDELEMS(s_h4)-1]);PrintLn();
1545 #endif
1546
1547 ideal s_h3;
1551 if (addOnlyOne)
1552 {
1554 s_h3 = kStd(s_h4,currRing->qideal,hom,&weights1,NULL,0/*kmax-1*/,IDELEMS(s_h4)-1);
1555 }
1556 else
1557 {
1558 s_h3 = kStd(s_h4,currRing->qideal,hom,&weights1,NULL,kmax-1);
1559 }
1561
1562 #if 0
1563 // only together with the above debug stuff
1566 Print("result, kmax=%d:\n",kmax);
1567 ipPrint_MA0(m,"S");
1568 idDelete((ideal *)&m);
1569 #endif
1570
1571 idTest(s_h3);
1572 if (weights1!=NULL) delete weights1;
1573 idDelete(&s_h4);
1574
1575 for (i=0;i<IDELEMS(s_h3);i++)
1576 {
1577 if ((s_h3->m[i]!=NULL) && (pGetComp(s_h3->m[i])>=kmax))
1578 {
1579 if (resultIsIdeal)
1580 p_Shift(&s_h3->m[i],-kmax,currRing);
1581 else
1582 p_Shift(&s_h3->m[i],-kmax+1,currRing);
1583 }
1584 else
1585 p_Delete(&s_h3->m[i],currRing);
1586 }
1587 if (resultIsIdeal)
1588 s_h3->rank = 1;
1589 else
1590 s_h3->rank = h1->rank;
1591 if(syz_ring!=orig_ring)
1592 {
1596 }
1598 idTest(s_h3);
1599 return s_h3;
1600}
#define Print
Definition emacs.cc:80
static ideal idInitializeQuot(ideal h1, ideal h2, BOOLEAN h1IsStb, BOOLEAN *addOnlyOne, int *kkmax)
Definition ideals.cc:1401
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

◆ idSaturate()

ideal idSaturate ( ideal I,
ideal J,
int & ki,
BOOLEAN isIdeal = TRUE )

Definition at line 3248 of file ideals.cc.

3249{
3250 if(idIs0(I))
3251 {
3252 I=idCopy(I);
3253 idSkipZeroes(I);
3254 return(I);
3255 }
3256 //if (idElem(J)==1)
3257 //{
3258 // idSkipZeroes(J);
3259 // return id_Sat_principal(I,J,currRing);
3260 //}
3261 //---------------------------------------------------
3262 BOOLEAN only_vars=TRUE; // enabled for I:x_i
3263 if (idElem(J)==1)
3264 {
3265 for(int j=IDELEMS(J)-1;j>=0;j--)
3266 {
3267 poly p=J->m[j];
3268 if (p!=NULL)
3269 {
3270 if (pVar(p)==0)
3271 {
3273 break;
3274 }
3275 }
3276 }
3277 }
3279 && (idElem(J)==1))
3280 {
3282 intvec *w=NULL;
3284 k=0;
3285 loop
3286 {
3287 k++;
3289 ideal tmp=kNF(Istd,currRing->qideal,Iquot,5);
3290 int elem=idElem(tmp);
3293 Istd=Iquot;
3294 w=NULL;
3295 Istd=kStd(Iquot,currRing->qideal,testHomog,&w);
3296 if (w!=NULL) delete w;
3298 if (elem==0) break;
3299 }
3300 k--;
3302 //PrintS("\nSatstd:\n");
3303 //iiWriteMatrix((matrix)I,"I",1,currRing,0); PrintLn();
3304 //iiWriteMatrix((matrix)J,"J",1,currRing,0); PrintLn();
3305 //iiWriteMatrix((matrix)Istd,"res",1,currRing,0);PrintLn();
3306 //id_Delete(&Istd,currRing);
3307 return Istd;
3308 }
3309 //--------------------------------------------------
3311 intvec *w=NULL;
3312 Istd=idCopy(I);
3313 k=0;
3314 loop
3315 {
3316 k++;
3318 ideal tmp=kNF(Istd,currRing->qideal,Iquot,5);
3319 int elem=idElem(tmp);
3322 Istd=Iquot;
3323 if (elem==0) break;
3324 }
3325 k--;
3326 Istd=kStd(Iquot,currRing->qideal,testHomog,&w);
3328 //if (only_vars)
3329 //{
3330 // iiWriteMatrix((matrix)Istd,"org",1,currRing,0);
3331 //}
3332 return Istd;
3333}
ideal idQuot(ideal h1, ideal h2, BOOLEAN h1IsStb, BOOLEAN resultIsIdeal)
Definition ideals.cc:1506
ideal id_Satstd(const ideal I, ideal J, const ring r)
Definition ideals.cc:3116
#define pVar(m)
Definition polys.h:380
BOOLEAN rOrd_is_Totaldegree_Ordering(const ring r)
Definition ring.cc:2013
static int idElem(const ideal F)
number of non-zero polys in F

◆ idSect()

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

Definition at line 315 of file ideals.cc.

316{
317 int i,j,k;
318 unsigned length;
321 int rank=si_max(h1->rank,h2->rank);
322 if ((idIs0(h1)) || (idIs0(h2))) return idInit(1,rank);
323
327
329 poly p,q;
330
331 if (IDELEMS(h1)<IDELEMS(h2))
332 {
333 first = h1;
334 second = h2;
335 }
336 else
337 {
338 first = h2;
339 second = h1;
340 int t=flength; flength=slength; slength=t;
341 }
343 if (length==0)
344 {
345 if ((currRing->qideal==NULL)
346 && (currRing->OrdSgn==1)
349 return idSectWithElim(first,second,alg);
350 else length = 1;
351 }
352 if (TEST_OPT_PROT) PrintS("intersect by syzygy methods\n");
353 j = IDELEMS(first);
354
359
360 while ((j>0) && (first->m[j-1]==NULL)) j--;
361 temp = idInit(j /*IDELEMS(first)*/+IDELEMS(second),length+j);
362 k = 0;
363 for (i=0;i<j;i++)
364 {
365 if (first->m[i]!=NULL)
366 {
367 if (syz_ring==orig_ring)
368 temp->m[k] = pCopy(first->m[i]);
369 else
370 temp->m[k] = prCopyR(first->m[i], orig_ring, syz_ring);
371 q = pOne();
372 pSetComp(q,i+1+length);
373 pSetmComp(q);
374 if (flength==0) p_Shift(&(temp->m[k]),1,currRing);
375 p = temp->m[k];
376 while (pNext(p)!=NULL) pIter(p);
377 pNext(p) = q;
378 k++;
379 }
380 }
381 for (i=0;i<IDELEMS(second);i++)
382 {
383 if (second->m[i]!=NULL)
384 {
385 if (syz_ring==orig_ring)
386 temp->m[k] = pCopy(second->m[i]);
387 else
388 temp->m[k] = prCopyR(second->m[i], orig_ring,currRing);
389 if (slength==0) p_Shift(&(temp->m[k]),1,currRing);
390 k++;
391 }
392 }
393 intvec *w=NULL;
394
395 if ((alg!=GbDefault)
396 && (alg!=GbGroebner)
397 && (alg!=GbModstd)
398 && (alg!=GbSlimgb)
399 && (alg!=GbStd))
400 {
401 WarnS("wrong algorithm for GB");
403 }
405
408
409 result = idInit(IDELEMS(temp1),rank);
410 j = 0;
411 for (i=0;i<IDELEMS(temp1);i++)
412 {
413 if ((temp1->m[i]!=NULL)
415 {
417 {
418 p = temp1->m[i];
419 }
420 else
421 {
423 }
424 temp1->m[i]=NULL;
425 while (p!=NULL)
426 {
427 q = pNext(p);
428 pNext(p) = NULL;
429 k = pGetComp(p)-1-length;
430 pSetComp(p,0);
431 pSetmComp(p);
432 /* Warning! multiply only from the left! it's very important for Plural */
433 result->m[j] = pAdd(result->m[j],pMult(p,pCopy(first->m[k])));
434 p = q;
435 }
436 j++;
437 }
438 }
440 {
442 idDelete(&temp1);
445 }
446 else
447 {
448 idDelete(&temp1);
449 }
450
454 {
455 w=NULL;
457 if (w!=NULL) delete w;
460 return temp1;
461 }
462 //else
463 // temp1=kInterRed(result,currRing->qideal);
464 return result;
465}
static ideal idSectWithElim(ideal h1, ideal h2, GbVariant alg)
Definition ideals.cc:132
#define TEST_V_INTERSECT_ELIM
Definition options.h:143
#define TEST_V_INTERSECT_SYZ
Definition options.h:144
#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 2129 of file ideals.cc.

2130{
2131 for(int i=IDELEMS(M)-1;i>=0;i--)
2132 {
2133 if(U==NULL)
2134 M->m[i]=pSeries(n,M->m[i],NULL,w);
2135 else
2136 {
2137 M->m[i]=pSeries(n,M->m[i],MATELEM(U,i+1,i+1),w);
2138 MATELEM(U,i+1,i+1)=NULL;
2139 }
2140 }
2141 if(U!=NULL)
2142 idDelete((ideal*)&U);
2143 return M;
2144}
#define pSeries(n, p, u, w)
Definition polys.h:371

◆ idSort()

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

Definition at line 185 of file ideals.h.

186{
187 return id_Sort(id, nolex, currRing);
188}
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;
836 int ii, idElemens_h1;
837
838 assume(h1 != NULL);
839
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 }
850 k=si_max(1,slength /*id_RankFreeModule(h1)*/);
851
852 assume(currRing != NULL);
856
857 if (orig_ring != syz_ring)
858 {
861 }
862 else
863 {
864 s_h1 = h1;
865 }
866
867 idTest(s_h1);
868
872
873 ideal s_h3=idPrepare(s_h1,NULL,h,k,w,alg); // main (syz) GB computation
874
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 }
891 s_h3->rank -= k;
895 #ifdef HAVE_PLURAL
897 {
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];
917 s_h3->m[j] = NULL;
918 }
919 }
920 }
921
923 idSkipZeroes(e);
924
925 if ((deg != NULL)
926 && (!isMonomial)
928 && (setRegularity)
929 && (h==isHomog)
932 )
933 {
935 ring dp_C_ring = rAssure_dp_C(syz_ring); // will do rChangeCurrRing later
936 if (dp_C_ring != syz_ring)
937 {
940 }
943 *deg = reg+2;
944 delete dummy;
945 for (j=0;j<length;j++)
946 {
947 if (res[j]!=NULL) idDelete(&(res[j]));
948 }
950 idDelete(&e);
951 if (dp_C_ring != orig_ring)
952 {
955 }
956 }
957 else
958 {
959 idDelete(&e);
960 }
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:414
ring rAssure_SyzComp(const ring r, BOOLEAN complete)
Definition ring.cc:4444
ring rAssure_dp_C(const ring r)
Definition ring.cc:5036
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:37
intvec * syBetti(resolvente res, int length, int *regularity, intvec *weights, BOOLEAN tomin, int *row_shift)
Definition syz.cc:771
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 2077 of file ideals.cc.

2078{
2079 if ((Q!=NULL) && (!idHomIdeal(Q,NULL))) { PrintS(" Q not hom\n"); return FALSE;}
2080 if (idIs0(m)) return TRUE;
2081
2082 int cmax=-1;
2083 int i;
2084 poly p=NULL;
2085 int length=IDELEMS(m);
2086 polyset P=m->m;
2087 for (i=length-1;i>=0;i--)
2088 {
2089 p=P[i];
2090 if (p!=NULL) cmax=si_max(cmax,(int)pMaxComp(p)+1);
2091 }
2092 if (w != NULL)
2093 if (w->length()+1 < cmax)
2094 {
2095 // Print("length: %d - %d \n", w->length(),cmax);
2096 return FALSE;
2097 }
2098
2099 if(w!=NULL)
2101
2102 for (i=length-1;i>=0;i--)
2103 {
2104 p=P[i];
2105 if (p!=NULL)
2106 {
2107 int d=currRing->pFDeg(p,currRing);
2108 loop
2109 {
2110 pIter(p);
2111 if (p==NULL) break;
2112 if (d!=currRing->pFDeg(p,currRing))
2113 {
2114 //pWrite(q); wrp(p); Print(" -> %d - %d\n",d,pFDeg(p,currRing));
2115 if(w!=NULL)
2117 return FALSE;
2118 }
2119 }
2120 }
2121 }
2122
2123 if(w!=NULL)
2125
2126 return TRUE;
2127}
static BOOLEAN idHomIdeal(ideal id, ideal Q=NULL)
Definition ideals.h:91
void p_SetModDeg(intvec *w, ring r)
Definition p_polys.cc:3673
#define pMaxComp(p)
Definition polys.h:299
poly * polyset
Definition polys.h:259

◆ idVec2Ideal()

static ideal idVec2Ideal ( poly vec)
inlinestatic

Definition at line 170 of file ideals.h.

171{
172 return id_Vec2Ideal(vec, currRing);
173}
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 3425 of file ideals.cc.

3426{
3428 if (strcmp(n,"default")==0) alg=GbDefault;
3429 else if (strcmp(n,"slimgb")==0) alg=GbSlimgb;
3430 else if (strcmp(n,"std")==0) alg=GbStd;
3431 else if (strcmp(n,"sba")==0) alg=GbSba;
3432 else if (strcmp(n,"singmatic")==0) alg=GbSingmatic;
3433 else if (strcmp(n,"groebner")==0) alg=GbGroebner;
3434 else if (strcmp(n,"modstd")==0) alg=GbModstd;
3435 else if (strcmp(n,"ffmod")==0) alg=GbFfmod;
3436 else if (strcmp(n,"nfmod")==0) alg=GbNfmod;
3437 else if (strcmp(n,"std:sat")==0) alg=GbStdSat;
3438 else Warn(">>%s<< is an unknown algorithm",n);
3439
3440 if (alg==GbSlimgb) // test conditions for slimgb
3441 {
3442 if(rHasGlobalOrdering(r)
3443 &&(!rIsNCRing(r))
3444 &&(r->qideal==NULL)
3445 &&(!rField_is_Ring(r)))
3446 {
3447 return GbSlimgb;
3448 }
3449 if (TEST_OPT_PROT)
3450 WarnS("requires: coef:field, commutative, global ordering, not qring");
3451 }
3452 else if (alg==GbSba) // cond. for sba
3453 {
3454 if(rField_is_Domain(r)
3455 &&(!rIsNCRing(r))
3456 &&(rHasGlobalOrdering(r)))
3457 {
3458 return GbSba;
3459 }
3460 if (TEST_OPT_PROT)
3461 WarnS("requires: coef:domain, commutative, global ordering");
3462 }
3463 else if (alg==GbGroebner) // cond. for groebner
3464 {
3465 return GbGroebner;
3466 }
3467 else if(alg==GbModstd) // cond for modstd: Q or Q(a)
3468 {
3469 if(ggetid("modStd")==NULL)
3470 {
3471 WarnS(">>modStd<< not found");
3472 }
3473 else if(rField_is_Q(r)
3474 &&(!rIsNCRing(r))
3475 &&(rHasGlobalOrdering(r)))
3476 {
3477 return GbModstd;
3478 }
3479 if (TEST_OPT_PROT)
3480 WarnS("requires: coef:QQ, commutative, global ordering");
3481 }
3482 else if(alg==GbStdSat) // cond for std:sat: 2 blocks of variables
3483 {
3484 if(ggetid("satstd")==NULL)
3485 {
3486 WarnS(">>satstd<< not found");
3487 }
3488 else
3489 {
3490 return GbStdSat;
3491 }
3492 }
3493
3494 return GbStd; // no conditions for std
3495}
#define Warn
Definition emacs.cc:77
GbVariant
Definition ideals.h:119
idhdl ggetid(const char *n)
Definition ipid.cc:558
static BOOLEAN rField_is_Domain(const ring r)
Definition ring.h:487
static BOOLEAN rField_is_Q(const ring r)
Definition ring.h:506