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, bigintmat *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 idMinEmbedding_with_map (ideal arg, intvec **w, ideal &trans)
 
ideal idMinEmbedding_with_map_v (ideal arg, intvec **w, ideal &trans, int *red_comp)
 
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_intern (ideal I, ideal J, int &ki, BOOLEAN isIdeal, BOOLEAN isSB)
 
ideal idSaturate (ideal I, ideal J, int &ki, BOOLEAN isIdeal=TRUE)
 
ideal idSaturateGB (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 1213 of file simpleideals.cc.

1214{
1215 int i;
1216 int64 result;
1217
1218 if (r==0) return 1;
1219 if (n-r<r) return binom(n,n-r);
1220 result = n-r+1;
1221 for (i=2;i<=r;i++)
1222 {
1223 result *= n-r+i;
1224 result /= i;
1225 }
1226 if (result>MAX_INT_VAL)
1227 {
1228 WarnS("overflow in binomials");
1229 result=0;
1230 }
1231 return (int)result;
1232}
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 541 of file simpleideals.cc.

542{
543 id_Test(h1, r);
544
545 ideal h2 = idInit(IDELEMS(h1), h1->rank);
546 for (int i=IDELEMS(h1)-1; i>=0; i--)
547 h2->m[i] = p_Copy(h1->m[i],r);
548 return h2;
549}
static poly p_Copy(poly p, const ring r)
returns a copy of p
Definition p_polys.h:848
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 3066 of file ideals.cc.

3067{
3068 int cnt=IDELEMS(x)*x->nrows;
3069 ideal result=idInit(cnt,x->rank);
3070 result->nrows=x->nrows; // for lifting matrices
3071 result->ncols=x->ncols; // for lifting matrices
3072
3073 int i;
3074 for(i=cnt-1;i>=0;i--)
3075 {
3076 result->m[i]=p_Farey(x->m[i],N,r);
3077 }
3078 return result;
3079}
const CanonicalForm CFMap CFMap & N
Definition cfEzgcd.cc:56
Variable x
Definition cfModGcd.cc:4090
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 2963 of file ideals.cc.

2964{
2965 ideal I=idInit(2,1); I->m[0]=f; I->m[1]=g;
2966 intvec *w = NULL;
2967
2969 rChangeCurrRing(r);
2972
2973 if (w!=NULL) delete w;
2974 poly gg=p_TakeOutComp(&(S->m[0]), 2, r);
2975 id_Delete(&S, r);
2976 poly gcd_p=singclap_pdivide(f,gg, r);
2977 p_Delete(&gg, r);
2978
2979 return gcd_p;
2980}
g
Definition cfModGcd.cc:4098
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:836
void p_TakeOutComp(poly *p, long comp, poly *q, int *lq, const ring r)
Definition p_polys.cc:3575
#define NULL
Definition omList.c:12
static void p_Delete(poly *p, const ring r)
Definition p_polys.h:903
void rChangeCurrRing(ring r)
Definition polys.cc:16
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:34

◆ id_Homogenize()

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

Definition at line 3568 of file ideals.cc.

3569{
3570 ideal II=id_Copy(I,r);
3571 if (var_num==1)
3572 {
3574 if (tmpR!=r)
3575 {
3577 II=idrMoveR(II,r,tmpR);
3578 }
3580 id_Delete(&II,tmpR);
3581 intvec *ww=NULL;
3582 II=kStd(III,currRing->qideal,(tHomog)TRUE,&ww);
3583 if (ww!=NULL) delete ww;
3584 id_Delete(&III,tmpR);
3585 if (tmpR!=r)
3586 {
3587 rChangeCurrRing(r);
3588 II=idrMoveR(II,tmpR,r);
3589 }
3590 return II;
3591 }
3593 int *perm=(int*)omAlloc0((rVar(r)+1)*sizeof(int));
3594 for(int i=rVar(r)-1; i>0; i--) perm[i]=i;
3595 perm[var_num]=1;
3596 perm[1]=var_num;
3597 for(int i=IDELEMS(II)-1; i>=0;i--)
3598 {
3599 III->m[i]=p_PermPoly(II->m[i],perm,r,r,ndCopyMap,NULL,0,FALSE);
3600 }
3601 id_Delete(&II,r);
3602 II=id_Homogenize(III,1,r);
3603 id_Delete(&III,r);
3604 III=idInit(IDELEMS(II),1);
3605 for(int i=IDELEMS(II)-1; i>=0;i--)
3606 {
3607 III->m[i]=p_PermPoly(II->m[i],perm,r,r,ndCopyMap,NULL,0,FALSE);
3608 }
3609 id_Delete(&II,r);
3610 return III;
3611}
#define TRUE
Definition auxiliary.h:101
#define FALSE
Definition auxiliary.h:97
number ndCopyMap(number a, const coeffs src, const coeffs dst)
Definition numbers.cc:287
ideal id_Homogenize(ideal I, int var_num, const ring r)
Definition ideals.cc:3568
ideal id_Copy(ideal h1, const ring r)
copy an ideal
ideal kStd(ideal F, ideal Q, tHomog h, intvec **w, bigintmat *hilb, int syzComp, int newIdeal, intvec *vw, s_poly_proc_t sp)
Definition kstd1.cc:2603
#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:4211
ideal idrMoveR(ideal &id, ring src_r, ring dest_r)
Definition prCopy.cc:248
ring rAssure_Dp_C(const ring r)
Definition ring.cc:5116
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition ring.h:598
ideal id_Homogen(ideal h, int varnum, const ring r)
tHomog
Definition structs.h:31

◆ id_HomogenizeW()

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

Definition at line 3613 of file ideals.cc.

3614{
3615 ideal II=id_Copy(I,r);
3616 if (var_num==1)
3617 {
3619 if (tmpR!=r)
3620 {
3622 II=idrMoveR(II,r,tmpR);
3623 }
3625 id_Delete(&II,tmpR);
3626 intvec *ww=NULL;
3627 II=kStd(III,currRing->qideal,(tHomog)TRUE,&ww);
3628 if (ww!=NULL) delete ww;
3629 id_Delete(&III,tmpR);
3630 if (tmpR!=r)
3631 {
3632 rChangeCurrRing(r);
3633 II=idrMoveR(II,tmpR,r);
3634 }
3635 return II;
3636 }
3638 int *perm=(int*)omAlloc0((rVar(r)+1)*sizeof(int));
3639 for(int i=rVar(r)-1; i>0; i--) perm[i]=i;
3640 perm[var_num]=1;
3641 perm[1]=var_num;
3642 for(int i=IDELEMS(II)-1; i>=0;i--)
3643 {
3644 III->m[i]=p_PermPoly(II->m[i],perm,r,r,ndCopyMap,NULL,0,FALSE);
3645 }
3646 id_Delete(&II,r);
3647 II=id_HomogenizeW(III,1,w,r);
3648 id_Delete(&III,r);
3649 III=idInit(IDELEMS(II),1);
3650 for(int i=IDELEMS(II)-1; i>=0;i--)
3651 {
3652 III->m[i]=p_PermPoly(II->m[i],perm,r,r,ndCopyMap,NULL,0,FALSE);
3653 }
3654 id_Delete(&II,r);
3655 return III;
3656}
ideal id_HomogenizeW(ideal I, int var_num, intvec *w, const ring r)
Definition ideals.cc:3613
ring rAssure_Wp_C(const ring r, intvec *w)
Definition ring.cc:4934

◆ id_Sat_principal()

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

Definition at line 3378 of file ideals.cc.

3379{
3380 rRingOrder_t *ord;
3381 int *block0,*block1;
3382 int **wv;
3383
3384 // construction extension ring
3385 ord=(rRingOrder_t*)omAlloc0(4*sizeof(rRingOrder_t));
3386 block0=(int*)omAlloc0(4*sizeof(int));
3387 block1=(int*)omAlloc0(4*sizeof(int));
3388 wv=(int**) omAlloc0(4*sizeof(int**));
3389 wv[0]=(int*)omAlloc0((rVar(origR) + 2)*sizeof(int));
3390 block0[0] = block0[1] = 1;
3391 block1[0] = block1[1] = rVar(origR)+1;
3392 // use this special ordering: like ringorder_a, except that pFDeg, pWeights
3393 // ignore it
3394 ord[0] = ringorder_aa;
3395 wv[0][rVar(origR)]=1;
3396 BOOLEAN wp=FALSE;
3397 for (int j=0;j<rVar(origR);j++)
3398 if (p_Weight(j+1,origR)!=1) { wp=TRUE;break; }
3399 if (wp)
3400 {
3401 wv[1]=(int*)omAlloc0((rVar(origR) + 1)*sizeof(int));
3402 for (int j=0;j<rVar(origR);j++)
3403 wv[1][j]=p_Weight(j+1,origR);
3404 ord[1] = ringorder_wp;
3405 }
3406 else
3407 ord[1] = ringorder_dp;
3408 ord[2] = ringorder_C;
3409 ord[3] = (rRingOrder_t)0;
3410 char **names=(char**)omAlloc0((origR->N+1) * sizeof(char *));
3411 for (int j=0;j<rVar(origR);j++)
3412 names[j]=origR->names[j];
3413 names[rVar(origR)]=(char*)"@";
3414 ring tmpR=rDefault(nCopyCoeff(origR->cf),rVar(origR)+1,names,4,ord,block0,block1,wv);
3415 omFree(names);
3416 rComplete(tmpR, 1);
3418 // map I
3420 // map J
3422 // J[1]*t-1
3423 poly t=pOne();
3424 p_SetExp(t,rVar(tmpR),1,tmpR);
3425 p_Setm(t,tmpR);
3426 poly p=JJ->m[0];
3427 p_Norm(p,currRing);
3428 p=p_Mult_q(p,t,tmpR);
3429 p=p_Sub(p,pOne(),tmpR);
3430 JJ->m[0]=p;
3432 idTest(T);
3433 id_Delete(&II,tmpR);
3434 id_Delete(&JJ,tmpR);
3435 // elimination
3436 t=pOne();
3437 p_SetExp(t,rVar(tmpR),1,tmpR);
3438 p_Setm(t,tmpR);
3440 p_Delete(&t,tmpR);
3441 for(int j=0;j<IDELEMS(TT);j++)
3442 {
3443 if ((TT->m[j]!=NULL)
3444 && (p_GetExp(TT->m[j],rVar(tmpR),tmpR)>0))
3445 {
3446 p_Delete(&TT->m[j],tmpR);
3447 }
3448 }
3449 // map back
3451 id_Delete(&TT,tmpR);
3453 rDelete(tmpR);
3455 return TTT;
3456}
int BOOLEAN
Definition auxiliary.h:88
int p
Definition cfModGcd.cc:4086
static FORCE_INLINE coeffs nCopyCoeff(const coeffs r)
"copy" coeffs, i.e. increment ref
Definition coeffs.h:437
int j
Definition facHensel.cc:110
static ideal idGroebner(ideal temp, int syzComp, GbVariant alg, bigintmat *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:706
void p_Norm(poly p1, const ring r)
Definition p_polys.cc:3799
poly p_Sub(poly p1, poly p2, const ring r)
Definition p_polys.cc:1994
static poly p_Mult_q(poly p, poly q, const ring r)
Definition p_polys.h:1120
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:490
static void p_Setm(poly p, const ring r)
Definition p_polys.h:235
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:471
#define pOne()
Definition polys.h:316
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:3518
void rDelete(ring r)
unconditionally deletes fields in r
Definition ring.cc:452
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:103
rRingOrder_t
order stuff
Definition ring.h:69
@ ringorder_C
Definition ring.h:74
@ ringorder_dp
Definition ring.h:79
@ ringorder_aa
for idElimination, like a, except pFDeg, pWeigths ignore it
Definition ring.h:93
@ ringorder_wp
Definition ring.h:82
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 3326 of file ideals.cc.

3327{
3329 if (currRing!=r) rChangeCurrRing(r);
3330 idSkipZeroes(J);
3332 int k=IDELEMS(J);
3333 if (k>1)
3334 {
3335 for (int i=0; i<k; i++)
3336 {
3337 poly x = J->m[i];
3338 int li = p_Var(x,r);
3339 if (li>0)
3341 else
3342 {
3344 WerrorS("ideal generators must be variables");
3345 return NULL;
3346 }
3347 }
3348 }
3349 else
3350 {
3351 poly x = J->m[0];
3352 if (pNext(x)!=NULL)
3353 {
3354 Werror("generator must be a monomial");
3356 return NULL;
3357 }
3358 for (int i=1; i<=r->N; i++)
3359 {
3360 int li = p_GetExp(x,i,r);
3361 if (li==1)
3363 else if (li>1)
3364 {
3366 Werror("exponent(x(%d)^%d) must be 0 or 1",i,li);
3367 return NULL;
3368 }
3369 }
3370 }
3375 return res;
3376}
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:3211
static BOOLEAN id_sat_vars_sp(kStrategy strat)
Definition ideals.cc:3213
#define pNext(p)
Definition monomials.h:36
#define omFreeSize(addr, size)
int p_Var(poly m, const ring r)
Definition p_polys.cc:4765
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 2067 of file simpleideals.cc.

2068{
2069// #ifdef DEBU
2070// WarnS("tensorModuleMult!!!!");
2071
2072 assume(m > 0);
2073 assume(M != NULL);
2074
2075 const int n = rRing->N;
2076
2077 assume(M->rank <= m * n);
2078
2079 const int k = IDELEMS(M);
2080
2081 ideal idTemp = idInit(k,m); // = {f_1, ..., f_k }
2082
2083 for( int i = 0; i < k; i++ ) // for every w \in M
2084 {
2085 poly pTempSum = NULL;
2086
2087 poly w = M->m[i];
2088
2089 while(w != NULL) // for each term of w...
2090 {
2091 poly h = p_Head(w, rRing);
2092
2093 const int gen = __p_GetComp(h, rRing); // 1 ...
2094
2095 assume(gen > 0);
2096 assume(gen <= n*m);
2097
2098 // TODO: write a formula with %, / instead of while!
2099 /*
2100 int c = gen;
2101 int v = 1;
2102 while(c > m)
2103 {
2104 c -= m;
2105 v++;
2106 }
2107 */
2108
2109 int cc = gen % m;
2110 if( cc == 0) cc = m;
2111 int vv = 1 + (gen - cc) / m;
2112
2113// assume( cc == c );
2114// assume( vv == v );
2115
2116 // 1<= c <= m
2117 assume( cc > 0 );
2118 assume( cc <= m );
2119
2120 assume( vv > 0 );
2121 assume( vv <= n );
2122
2123 assume( (cc + (vv-1)*m) == gen );
2124
2125 p_IncrExp(h, vv, rRing); // h *= var(j) && // p_AddExp(h, vv, 1, rRing);
2126 p_SetComp(h, cc, rRing);
2127
2128 p_Setm(h, rRing); // adjust degree after the previous steps!
2129
2130 pTempSum = p_Add_q(pTempSum, h, rRing); // it is slow since h will be usually put to the back of pTempSum!!!
2131
2132 pIter(w);
2133 }
2134
2135 idTemp->m[i] = pTempSum;
2136 }
2137
2138 // simplify idTemp???
2139
2141
2143
2144 return(idResult);
2145}
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:938
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
Definition p_polys.h:249
static long p_IncrExp(poly p, int v, ring r)
Definition p_polys.h:593
static poly p_Head(const poly p, const ring r)
copy the (leading) term of p
Definition p_polys.h:862
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 2631 of file ideals.cc.

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

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

3175{
3176 int idsize = IDELEMS(id);
3178 for (int i = 0; i < idsize; i++)
3179 {
3180 id_sort[i].p = id->m[i];
3181 id_sort[i].index = i;
3182 }
3184 int index, index_i, index_j;
3185 int i = 0;
3186 for (int j = 1; j < idsize; j++)
3187 {
3188 if (id_sort[i].p != NULL && pEqualPolys(id_sort[i].p, id_sort[j].p))
3189 {
3190 index_i = id_sort[i].index;
3191 index_j = id_sort[j].index;
3192 if (index_j > index_i)
3193 {
3194 index = index_j;
3195 }
3196 else
3197 {
3198 index = index_i;
3199 i = j;
3200 }
3201 pDelete(&id->m[index]);
3202 }
3203 else
3204 {
3205 i = j;
3206 }
3207 }
3209}
void idSort_qsort(poly_sort *id_sort, int idsize)
Definition ideals.cc:3165
static int index(p_Length length, p_Ord ord)
#define pDelete(p_ptr)
Definition polys.h:187
#define pEqualPolys(p1, p2)
Definition polys.h:400

◆ idDiff()

matrix idDiff ( matrix  i,
int  k 
)

Definition at line 2152 of file ideals.cc.

2153{
2154 int e=MATCOLS(i)*MATROWS(i);
2156 r->rank=i->rank;
2157 int j;
2158 for(j=0; j<e; j++)
2159 {
2160 r->m[j]=pDiff(i->m[j],k);
2161 }
2162 return r;
2163}
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:297

◆ idDiffOp()

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

Definition at line 2165 of file ideals.cc.

2166{
2168 int i,j;
2169 for(i=0; i<IDELEMS(I); i++)
2170 {
2171 for(j=0; j<IDELEMS(J); j++)
2172 {
2173 MATELEM(r,i+1,j+1)=pDiffOp(I->m[i],J->m[j],multiply);
2174 }
2175 }
2176 return r;
2177}
#define pDiffOp(a, b, m)
Definition polys.h:298

◆ idElimination()

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

Definition at line 1611 of file ideals.cc.

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

1156{
1157 int i = r-1,j;
1158 while ((i >= 0) && (choise[i] == end))
1159 {
1160 i--;
1161 end--;
1162 }
1163 if (i == -1)
1164 *endch = TRUE;
1165 else
1166 {
1167 choise[i]++;
1168 for (j=i+1; j<r; j++)
1169 {
1170 choise[j] = choise[i]+j-i;
1171 }
1172 *endch = FALSE;
1173 }
1174}

◆ idGetNumberOfChoise()

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

Definition at line 1181 of file simpleideals.cc.

1182{
1183 int * localchoise,i,result=0;
1184 BOOLEAN b=FALSE;
1185
1186 if (d<=1) return 1;
1187 localchoise=(int*)omAlloc((d-1)*sizeof(int));
1188 idInitChoise(d-1,begin,end,&b,localchoise);
1189 while (!b)
1190 {
1191 result++;
1192 i = 0;
1193 while ((i<t) && (localchoise[i]==choise[i])) i++;
1194 if (i>=t)
1195 {
1196 i = t+1;
1197 while ((i<d) && (localchoise[i-1]==choise[i])) i++;
1198 if (i>=d)
1199 {
1200 omFreeSize((ADDRESS)localchoise,(d-1)*sizeof(int));
1201 return result;
1202 }
1203 }
1204 idGetNextChoise(d-1,end,&b,localchoise);
1205 }
1206 omFreeSize((ADDRESS)localchoise,(d-1)*sizeof(int));
1207 return 0;
1208}
CanonicalForm b
Definition cfModGcd.cc:4111
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 1133 of file simpleideals.cc.

1134{
1135 /*returns the first choise of r numbers between beg and end*/
1136 int i;
1137 for (i=0; i<r; i++)
1138 {
1139 choise[i] = 0;
1140 }
1141 if (r <= end-beg+1)
1142 for (i=0; i<r; i++)
1143 {
1144 choise[i] = beg+i;
1145 }
1146 if (r > end-beg+1)
1147 *endch = TRUE;
1148 else
1149 *endch = FALSE;
1150}

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

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

◆ idInsertPolyOnPos()

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

insert p into I on position pos

Definition at line 850 of file simpleideals.cc.

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

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

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

◆ idIsSubModule()

BOOLEAN idIsSubModule ( ideal  id1,
ideal  id2 
)

Definition at line 2062 of file ideals.cc.

2063{
2064 int i;
2065 poly p;
2066
2067 if (idIs0(id1)) return TRUE;
2068 for (i=0;i<IDELEMS(id1);i++)
2069 {
2070 if (id1->m[i] != NULL)
2071 {
2072 p = kNF(id2,currRing->qideal,id1->m[i]);
2073 if (p != NULL)
2074 {
2076 return FALSE;
2077 }
2078 }
2079 }
2080 return TRUE;
2081}
poly kNF(ideal F, ideal Q, poly p, int syzComp, int lazyReduce)
Definition kstd1.cc:3209

◆ idIsZeroDim()

static BOOLEAN idIsZeroDim ( ideal  i)
inlinestatic

Definition at line 179 of file ideals.h.

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

3143{
3144 for (int i = IDELEMS(id)-1; i >= k; i--)
3145 {
3146 if (id->m[i] != NULL) pDelete(&id->m[i]);
3147 }
3148 int kk=k;
3149 if (k==0) kk=1; /* ideals must have at least one element(0)*/
3150 pEnlargeSet(&(id->m), IDELEMS(id), kk-IDELEMS(id));
3151 IDELEMS(id) = kk;
3152}

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

1113{
1115 int comps_to_add=0;
1116 int idelems_mod=IDELEMS(mod);
1118 poly p;
1119
1120 if (idIs0(submod))
1121 {
1122 if (rest!=NULL)
1123 {
1124 *rest=idInit(1,mod->rank);
1125 }
1127 return idInit(1,idelems_mod);
1128 }
1129 if (idIs0(mod)) /* and not idIs0(submod) */
1130 {
1131 if (rest!=NULL)
1132 {
1133 *rest=idCopy(submod);
1135 return idInit(1,idelems_mod);
1136 }
1137 else
1138 {
1139 WerrorS("2nd module does not lie in the first");
1140 return NULL;
1141 }
1142 }
1143 if (unit!=NULL)
1144 {
1146 while ((comps_to_add>0) && (submod->m[comps_to_add-1]==NULL))
1147 comps_to_add--;
1148 }
1150 if ((k!=0) && (lsmod==0)) lsmod=1;
1151 k=si_max(k,(int)mod->rank);
1152 if (k<submod->rank) { WarnS("rk(submod) > rk(mod) ?");k=submod->rank; }
1153
1158
1160 if (orig_ring != syz_ring)
1161 {
1164 }
1165 else
1166 {
1167 s_mod = mod;
1168 s_temp = idCopy(submod);
1169 }
1170 BITSET save2;
1172
1173 if ((rest==NULL)
1175 && (!rIsNCRing(currRing))
1176 && (!TEST_OPT_RETURN_SB))
1178 else
1179 si_opt_2 &=~Sy_bit(V_IDLIFT);
1180 ideal s_h3;
1181 if (isSB && !TEST_OPT_IDLIFT)
1182 {
1183 s_h3 = idCopy(s_mod);
1185 }
1186 else
1187 {
1189 }
1191
1192 if (!goodShape)
1193 {
1194 for (j=0;j<IDELEMS(s_h3);j++)
1195 {
1196 if ((s_h3->m[j] != NULL) && (pMinComp(s_h3->m[j]) > k))
1197 p_Delete(&(s_h3->m[j]),currRing);
1198 }
1199 }
1201 if (lsmod==0)
1202 {
1204 }
1205 if (unit!=NULL)
1206 {
1207 for(j = 0;j<comps_to_add;j++)
1208 {
1209 p = s_temp->m[j];
1210 if (p!=NULL)
1211 {
1212 while (pNext(p)!=NULL) pIter(p);
1213 pNext(p) = pOne();
1214 pIter(p);
1215 pSetComp(p,1+j+k);
1216 pSetmComp(p);
1217 p = pNeg(p);
1218 }
1219 }
1220 s_temp->rank += (k+comps_to_add);
1221 }
1222 ideal s_result = kNF(s_h3,currRing->qideal,s_temp,k);
1223 s_result->rank = s_h3->rank;
1225 idDelete(&s_h3);
1226 idDelete(&s_temp);
1227
1228 for (j=0;j<IDELEMS(s_result);j++)
1229 {
1230 if (s_result->m[j]!=NULL)
1231 {
1232 if (pGetComp(s_result->m[j])<=k)
1233 {
1234 if (!divide)
1235 {
1236 if (rest==NULL)
1237 {
1238 if (isSB)
1239 {
1240 WarnS("first module not a standardbasis\n"
1241 "// ** or second not a proper submodule");
1242 }
1243 else
1244 WerrorS("2nd module does not lie in the first");
1245 }
1247 idDelete(&s_rest);
1248 if(syz_ring!=orig_ring)
1249 {
1250 idDelete(&s_mod);
1253 }
1254 if (unit!=NULL)
1255 {
1257 }
1258 if (rest!=NULL) *rest=idCopy(submod);
1260 return s_result;
1261 }
1262 else
1263 {
1264 p = s_rest->m[j] = s_result->m[j];
1265 while ((pNext(p)!=NULL) && (pGetComp(pNext(p))<=k)) pIter(p);
1266 s_result->m[j] = pNext(p);
1267 pNext(p) = NULL;
1268 }
1269 }
1270 p_Shift(&(s_result->m[j]),-k,currRing);
1271 pNeg(s_result->m[j]);
1272 }
1273 }
1274 if ((lsmod==0) && (s_rest!=NULL))
1275 {
1276 for (j=IDELEMS(s_rest);j>0;j--)
1277 {
1278 if (s_rest->m[j-1]!=NULL)
1279 {
1280 p_Shift(&(s_rest->m[j-1]),-1,currRing);
1281 }
1282 }
1283 }
1284 if(syz_ring!=orig_ring)
1285 {
1286 idDelete(&s_mod);
1291 }
1292 if (rest!=NULL)
1293 {
1294 s_rest->rank=mod->rank;
1295 *rest = s_rest;
1296 }
1297 else
1298 idDelete(&s_rest);
1299 if (unit!=NULL)
1300 {
1302 int i;
1303 for(i=0;i<IDELEMS(s_result);i++)
1304 {
1305 poly p=s_result->m[i];
1306 poly q=NULL;
1307 while(p!=NULL)
1308 {
1309 if(pGetComp(p)<=comps_to_add)
1310 {
1311 pSetComp(p,0);
1312 if (q!=NULL)
1313 {
1314 pNext(q)=pNext(p);
1315 }
1316 else
1317 {
1318 pIter(s_result->m[i]);
1319 }
1320 pNext(p)=NULL;
1321 MATELEM(*unit,i+1,i+1)=pAdd(MATELEM(*unit,i+1,i+1),p);
1322 if(q!=NULL) p=pNext(q);
1323 else p=s_result->m[i];
1324 }
1325 else
1326 {
1327 q=p;
1328 pIter(p);
1329 }
1330 }
1332 }
1333 }
1334 s_result->rank=idelems_mod;
1335 return s_result;
1336}
#define BITSET
Definition auxiliary.h:85
static int si_max(const int a, const int b)
Definition auxiliary.h:125
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:1047
static void idLift_setUnit(int e_mod, matrix *unit)
Definition ideals.cc:1088
static ideal idPrepare(ideal h1, ideal h11, tHomog hom, int syzcomp, intvec **w, GbVariant alg)
Definition ideals.cc:613
VAR unsigned si_opt_2
Definition options.c:6
#define TEST_OPT_IDLIFT
Definition options.h:131
#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:114
#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:4815
#define pNeg(p)
Definition polys.h:199
#define pGetComp(p)
Component.
Definition polys.h:38
#define pSetComp(p, v)
Definition polys.h:39
#define pSetmComp(p)
TODO:
Definition polys.h:274
#define pMinComp(p)
Definition polys.h:301
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:4514
void rSetSyzComp(int k, const ring r)
Definition ring.cc:5222
static BOOLEAN rIsNCRing(const ring r)
Definition ring.h:427
#define rField_is_Ring(R)
Definition ring.h:491
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 982 of file ideals.cc.

984{
986 long k;
987 intvec *w=NULL;
988
989 idDelete((ideal*)T);
991 if (S!=NULL) { lift3=TRUE; idDelete(S); }
992 if (idIs0(h1))
993 {
994 *T=mpNew(1,IDELEMS(h1));
995 if (lift3)
996 {
998 }
999 return idInit(1,h1->rank);
1000 }
1001
1006
1008
1013
1014 ideal s_h1;
1015
1016 if (orig_ring != syz_ring)
1018 else
1019 s_h1 = h1;
1021 if (h11!=NULL)
1022 {
1024 }
1025
1026
1027 ideal s_h3=idPrepare(s_h1,s_h11,hi,k,&w,alg); // main (syz) GB computation
1028
1029
1030 if (w!=NULL) delete w;
1031 if (syz_ring!=orig_ring)
1032 {
1033 idDelete(&s_h1);
1034 if (s_h11!=NULL) idDelete(&s_h11);
1035 }
1036
1037 if (S!=NULL) (*S)=idInit(IDELEMS(s_h3),IDELEMS(h1));
1038
1040
1042 s_h3->rank=h1->rank;
1044 return s_h3;
1045}
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:715
ideal idFreeModule(int i)
Definition ideals.h:111
#define SI_SAVE_OPT(A, B)
Definition options.h:20
#define V_NOT_TRICKS
Definition options.h:71
#define SI_RESTORE_OPT(A, B)
Definition options.h:23

◆ idLiftW()

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

Definition at line 1342 of file ideals.cc.

1343{
1344 long N=0;
1345 int i;
1346 for(i=IDELEMS(Q)-1;i>=0;i--)
1347 if(w==NULL)
1348 N=si_max(N,p_Deg(Q->m[i],currRing));
1349 else
1350 N=si_max(N,p_DegW(Q->m[i],w,currRing));
1351 N+=n;
1352
1353 T=mpNew(IDELEMS(Q),IDELEMS(P));
1354 R=idInit(IDELEMS(P),P->rank);
1355
1356 for(i=IDELEMS(P)-1;i>=0;i--)
1357 {
1358 poly p;
1359 if(w==NULL)
1360 p=ppJet(P->m[i],N);
1361 else
1362 p=ppJetW(P->m[i],N,w);
1363
1364 int j=IDELEMS(Q)-1;
1365 while(p!=NULL)
1366 {
1367 if(pDivisibleBy(Q->m[j],p))
1368 {
1369 poly p0=p_DivideM(pHead(p),pHead(Q->m[j]),currRing);
1370 if(w==NULL)
1371 p=pJet(pSub(p,ppMult_mm(Q->m[j],p0)),N);
1372 else
1373 p=pJetW(pSub(p,ppMult_mm(Q->m[j],p0)),N,w);
1374 pNormalize(p);
1375 if(((w==NULL)&&(p_Deg(p0,currRing)>n))||((w!=NULL)&&(p_DegW(p0,w,currRing)>n)))
1377 else
1378 MATELEM(T,j+1,i+1)=pAdd(MATELEM(T,j+1,i+1),p0);
1379 j=IDELEMS(Q)-1;
1380 }
1381 else
1382 {
1383 if(j==0)
1384 {
1385 poly p0=p;
1386 pIter(p);
1387 pNext(p0)=NULL;
1388 if(((w==NULL)&&(p_Deg(p0,currRing)>n))
1389 ||((w!=NULL)&&(p_DegW(p0,w,currRing)>n)))
1391 else
1392 R->m[i]=pAdd(R->m[i],p0);
1393 j=IDELEMS(Q)-1;
1394 }
1395 else
1396 j--;
1397 }
1398 }
1399 }
1400}
poly p_DivideM(poly a, poly b, const ring r)
Definition p_polys.cc:1582
long p_DegW(poly p, const int *w, const ring R)
Definition p_polys.cc:691
long p_Deg(poly a, const ring r)
Definition p_polys.cc:586
#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:68
#define ppMult_mm(p, m)
Definition polys.h:202
#define pJet(p, m)
Definition polys.h:368
#define pSub(a, b)
Definition polys.h:288
#define ppJetW(p, m, iv)
Definition polys.h:369
#define pJetW(p, m, iv)
Definition polys.h:370
#define pNormalize(p)
Definition polys.h:318
#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:139
#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, bigintmat *hilb, int syzComp, int reduced)
Definition kstd1.cc:3057
#define pCopy(p)
return a copy of the poly
Definition polys.h:186
static BOOLEAN rHasGlobalOrdering(const ring r)
Definition ring.h:768
@ isNotHomog
Definition structs.h:32

◆ idMinEmbedding()

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

Definition at line 2816 of file ideals.cc.

2817{
2818 int *red_comp=(int*)omAlloc((arg->rank+1)*sizeof(int));
2819 int del=0;
2823 return res;
2824}
static ideal idMinEmbedding1(ideal arg, BOOLEAN inPlace, intvec **w, int *red_comp, int &del)
Definition ideals.cc:2780
static void idDeleteComps(ideal arg, int *red_comp, int del)
Definition ideals.cc:2670

◆ idMinEmbedding_with_map()

ideal idMinEmbedding_with_map ( ideal  arg,
intvec **  w,
ideal trans 
)

Definition at line 2826 of file ideals.cc.

2827{
2828 int *red_comp=(int*)omAlloc((arg->rank+1)*sizeof(int));
2829 int del=0;
2832 //idDeleteComps(res,red_comp,del);
2834 return res;
2835}
ideal idLift(ideal mod, ideal submod, ideal *rest, BOOLEAN goodShape, BOOLEAN isSB, BOOLEAN divide, matrix *unit, GbVariant alg)
represents the generators of submod in terms of the generators of mod (Matrix(SM)*U-Matrix(rest)) = M...
Definition ideals.cc:1111

◆ idMinEmbedding_with_map_v()

ideal idMinEmbedding_with_map_v ( ideal  arg,
intvec **  w,
ideal trans,
int red_comp 
)

Definition at line 2837 of file ideals.cc.

2838{
2839 if (idIs0(arg))
2840 {
2841 trans=idFreeModule(arg->rank);
2842 if (g!=NULL)
2843 {
2844 for(int i=0;i<arg->rank;i++) g[i]=i+1;
2845 }
2846 return arg;
2847 }
2848 int *red_comp=(int*)omAlloc((arg->rank+1)*sizeof(int));
2849 int del=0;
2852 for(int i=1;i<=arg->rank;i++)
2853 {
2854 g[i-1]=red_comp[i];
2855 }
2857 return res;
2858}

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

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

2427{
2428#ifdef HAVE_SHIFTBBA
2429 if (rIsLPRing(currRing))
2430 return idModuloLP(h2,h1,hom,w,T,alg);
2431#endif
2432 intvec *wtmp=NULL;
2433 if (T!=NULL) idDelete((ideal*)T);
2434
2435 int i,flength=0,slength,length;
2436
2437 if (idIs0(h2))
2438 return idFreeModule(si_max(1,h2->ncols));
2439 if (!idIs0(h1))
2444 if (length==0)
2445 {
2446 length = 1;
2448 }
2449 if ((w!=NULL)&&((*w)!=NULL))
2450 {
2451 //Print("input weights:");(*w)->show(1);PrintLn();
2452 int d;
2453 int k;
2454 wtmp=new intvec(length+IDELEMS(h2));
2455 for (i=0;i<length;i++)
2456 ((*wtmp)[i])=(**w)[i];
2457 for (i=0;i<IDELEMS(h2);i++)
2458 {
2459 poly p=h2->m[i];
2460 if (p!=NULL)
2461 {
2462 d = p_Deg(p,currRing);
2463 k= pGetComp(p);
2464 if (slength>0) k--;
2465 d +=((**w)[k]);
2466 ((*wtmp)[i+length]) = d;
2467 }
2468 }
2469 //Print("weights:");wtmp->show(1);PrintLn();
2470 }
2471 ideal s_temp1;
2475 {
2477 ideal s1,s2;
2478
2479 if (syz_ring != orig_ring)
2480 {
2483 }
2484 else
2485 {
2486 s1=idCopy(h1);
2487 s2=idCopy(h2);
2488 }
2489
2492 if (T==NULL) si_opt_1 |= Sy_bit(OPT_REDTAIL);
2496 }
2497
2498 //if (wtmp!=NULL) Print("output weights:");wtmp->show(1);PrintLn();
2499 if ((w!=NULL) && (*w !=NULL) && (wtmp!=NULL))
2500 {
2501 delete *w;
2502 *w=new intvec(IDELEMS(h2));
2503 for (i=0;i<IDELEMS(h2);i++)
2504 ((**w)[i])=(*wtmp)[i+length];
2505 }
2506 if (wtmp!=NULL) delete wtmp;
2507
2510
2511 idDelete(&s_temp1);
2512 if (syz_ring!=orig_ring)
2513 {
2515 }
2516 idTest(h2);
2517 idTest(h1);
2518 idTest(result);
2519 if (T!=NULL) idTest((ideal)*T);
2520 return result;
2521}
ideal idModuloLP(ideal h2, ideal h1, tHomog, intvec **w, matrix *T, GbVariant alg)
Definition ideals.cc:2235
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:88
#define OPT_REDTAIL
Definition options.h:92
static BOOLEAN rIsLPRing(const ring r)
Definition ring.h:417

◆ 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;
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 {
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
510
513 rSetSyzComp(syzComp,syz_ring);
515
516 bigmat = idInit(j,(k+1)*maxrk);
517 /* create unit matrices ------------------------------------------*/
518 for (i=0;i<maxrk;i++)
519 {
520 for (j=0;j<=k;j++)
521 {
522 p = pOne();
523 pSetComp(p,i+1+j*maxrk);
524 pSetmComp(p);
525 bigmat->m[i] = pAdd(bigmat->m[i],p);
526 }
527 }
528 /* enter given ideals ------------------------------------------*/
529 i = maxrk;
530 k = 0;
531 for (j=0;j<length;j++)
532 {
533 if (arg[j]!=NULL)
534 {
535 for (l=0;l<IDELEMS(arg[j]);l++)
536 {
537 if (arg[j]->m[l]!=NULL)
538 {
539 if (syz_ring==orig_ring)
540 bigmat->m[i] = pCopy(arg[j]->m[l]);
541 else
542 bigmat->m[i] = prCopyR(arg[j]->m[l], orig_ring,currRing);
544 i++;
545 }
546 }
547 k++;
548 }
549 }
550 /* std computation --------------------------------------------*/
551 if ((alg!=GbDefault)
552 && (alg!=GbGroebner)
553 && (alg!=GbModstd)
554 && (alg!=GbSlimgb)
555 && (alg!=GbStd))
556 {
557 WarnS("wrong algorithm for GB");
559 }
560 tempstd=idGroebner(bigmat,syzComp,alg);
561
564
565 /* interpret result ----------------------------------------*/
567 k = 0;
568 for (j=0;j<IDELEMS(tempstd);j++)
569 {
570 if ((tempstd->m[j]!=NULL) && (__p_GetComp(tempstd->m[j],syz_ring)>syzComp))
571 {
572 if (syz_ring==orig_ring)
573 p = pCopy(tempstd->m[j]);
574 else
576 p_Shift(&p,-syzComp-isIdeal,currRing);
577 result->m[k] = p;
578 k++;
579 }
580 }
581 /* clean up ----------------------------------------------------*/
586 {
589 }
592 return result;
593}
#define SI_SAVE_OPT1(A)
Definition options.h:21
#define SI_RESTORE_OPT1(A)
Definition options.h:24

◆ idQuot()

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

Definition at line 1512 of file ideals.cc.

1513{
1514 // first check for special case h1:(0)
1515 if (idIs0(h2))
1516 {
1517 ideal res;
1518 if (resultIsIdeal)
1519 {
1520 res = idInit(1,1);
1521 res->m[0] = pOne();
1522 }
1523 else
1524 res = idFreeModule(h1->rank);
1525 return res;
1526 }
1527 int i, kmax;
1530 intvec * weights1;
1531
1533
1535
1540 if (orig_ring!=syz_ring)
1541 // s_h4 = idrMoveR_NoSort(s_h4,orig_ring, syz_ring);
1543 idTest(s_h4);
1544
1545 #if 0
1547 PrintS("start:\n");
1548 ipPrint_MA0(m,"Q");
1549 idDelete((ideal *)&m);
1550 PrintS("last elem:");wrp(s_h4->m[IDELEMS(s_h4)-1]);PrintLn();
1551 #endif
1552
1553 ideal s_h3;
1557 if (addOnlyOne)
1558 {
1560 s_h3 = kStd(s_h4,currRing->qideal,hom,&weights1,NULL,0/*kmax-1*/,IDELEMS(s_h4)-1);
1561 }
1562 else
1563 {
1564 s_h3 = kStd(s_h4,currRing->qideal,hom,&weights1,NULL,kmax-1);
1565 }
1567
1568 #if 0
1569 // only together with the above debug stuff
1572 Print("result, kmax=%d:\n",kmax);
1573 ipPrint_MA0(m,"S");
1574 idDelete((ideal *)&m);
1575 #endif
1576
1577 idTest(s_h3);
1578 if (weights1!=NULL) delete weights1;
1579 idDelete(&s_h4);
1580
1581 for (i=0;i<IDELEMS(s_h3);i++)
1582 {
1583 if ((s_h3->m[i]!=NULL) && (pGetComp(s_h3->m[i])>=kmax))
1584 {
1585 if (resultIsIdeal)
1586 p_Shift(&s_h3->m[i],-kmax,currRing);
1587 else
1588 p_Shift(&s_h3->m[i],-kmax+1,currRing);
1589 }
1590 else
1591 p_Delete(&s_h3->m[i],currRing);
1592 }
1593 if (resultIsIdeal)
1594 s_h3->rank = 1;
1595 else
1596 s_h3->rank = h1->rank;
1597 if(syz_ring!=orig_ring)
1598 {
1602 }
1604 idTest(s_h3);
1605 return s_h3;
1606}
#define Print
Definition emacs.cc:80
void ipPrint_MA0(matrix m, const char *name)
Definition ipprint.cc:57
static ideal idInitializeQuot(ideal h1, ideal h2, BOOLEAN h1IsStb, BOOLEAN *addOnlyOne, int *kkmax)
Definition ideals.cc:1407
#define OPT_SB_1
Definition options.h:96
void wrp(poly p)
Definition polys.h:311
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 3559 of file ideals.cc.

3560{
3562}
ideal idSaturate_intern(ideal I, ideal J, int &k, BOOLEAN isIdeal, BOOLEAN isSB)
Definition ideals.cc:3458

◆ idSaturate_intern()

ideal idSaturate_intern ( ideal  I,
ideal  J,
int ki,
BOOLEAN  isIdeal,
BOOLEAN  isSB 
)

Definition at line 3458 of file ideals.cc.

3459{
3460 if(idIs0(J))
3461 {
3462 ideal res;
3463 if(isIdeal)
3464 {
3465 res=idInit(1,1);
3466 res->m[0]=pOne();
3467 }
3468 else
3469 {
3470 res=idFreeModule(I->rank);
3471 }
3472 k=1;
3473 return(res);
3474 }
3476 //if (idElem(J)==1)
3477 //{
3478 // idSkipZeroes(J);
3479 // return id_Sat_principal(I,J,currRing);
3480 //}
3481 //---------------------------------------------------
3482 BOOLEAN only_vars=TRUE; // enabled for I:x_i
3483 if (idElem(J)==1)
3484 {
3485 for(int j=IDELEMS(J)-1;j>=0;j--)
3486 {
3487 poly p=J->m[j];
3488 if (p!=NULL)
3489 {
3490 if (pVar(p)==0)
3491 {
3493 break;
3494 }
3495 }
3496 }
3497 }
3499 && (idElem(J)==1))
3500 {
3502 intvec *w=NULL;
3505 k=0;
3506 loop
3507 {
3508 k++;
3510 ideal tmp=kNF(Istd,currRing->qideal,Iquot,5);
3511 int elem=idElem(tmp);
3514 Istd=Iquot;
3515 w=NULL;
3516 Istd=kStd(Iquot,currRing->qideal,testHomog,&w);
3517 if (w!=NULL) delete w;
3519 if (elem==0) break;
3520 }
3521 k--;
3523 //PrintS("\nSatstd:\n");
3524 //iiWriteMatrix((matrix)I,"I",1,currRing,0); PrintLn();
3525 //iiWriteMatrix((matrix)J,"J",1,currRing,0); PrintLn();
3526 //iiWriteMatrix((matrix)Istd,"res",1,currRing,0);PrintLn();
3527 //id_Delete(&Istd,currRing);
3529 return Istd;
3530 }
3531 //--------------------------------------------------
3533 intvec *w=NULL;
3534 Istd=idCopy(I);
3535 k=0;
3536 loop
3537 {
3538 k++;
3540 isSB=FALSE;
3541 si_opt_2|=Sy_bit(V_NOT_TRICKS); // used from 2nd loop on
3542 ideal tmp=kNF(Istd,currRing->qideal,Iquot,5);
3543 int elem=idElem(tmp);
3546 Istd=Iquot;
3547 if (elem==0) break;
3548 }
3549 k--;
3550 Istd=kStd(Iquot,currRing->qideal,testHomog,&w);
3553 //if (only_vars)
3554 //{
3555 // iiWriteMatrix((matrix)Istd,"org",1,currRing,0);
3556 //}
3557 return Istd;
3558}
ideal idQuot(ideal h1, ideal h2, BOOLEAN h1IsStb, BOOLEAN resultIsIdeal)
Definition ideals.cc:1512
ideal id_Satstd(const ideal I, ideal J, const ring r)
Definition ideals.cc:3326
#define pVar(m)
Definition polys.h:381
BOOLEAN rOrd_is_Totaldegree_Ordering(const ring r)
Definition ring.cc:2034
static int idElem(const ideal F)
number of non-zero polys in F
#define loop
Definition structs.h:71

◆ idSaturateGB()

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

Definition at line 3563 of file ideals.cc.

3564{
3566}

◆ 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
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");
404 }
406
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)
416 {
418 {
419 p = temp1->m[i];
420 }
421 else
422 {
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 }
441 {
443 idDelete(&temp1);
446 }
447 else
448 {
449 idDelete(&temp1);
450 }
451
455 {
456 w=NULL;
458 if (w!=NULL) delete w;
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:132
#define TEST_V_INTERSECT_ELIM
Definition options.h:146
#define TEST_V_INTERSECT_SYZ
Definition options.h:147
#define TEST_OPT_PROT
Definition options.h:105
#define pMult(p, q)
Definition polys.h:208

◆ idSeries()

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

Definition at line 2135 of file ideals.cc.

2136{
2137 for(int i=IDELEMS(M)-1;i>=0;i--)
2138 {
2139 if(U==NULL)
2140 M->m[i]=pSeries(n,M->m[i],NULL,w);
2141 else
2142 {
2143 M->m[i]=pSeries(n,M->m[i],MATELEM(U,i+1,i+1),w);
2144 MATELEM(U,i+1,i+1)=NULL;
2145 }
2146 }
2147 if(U!=NULL)
2148 idDelete((ideal*)&U);
2149 return M;
2150}
#define pSeries(n, p, u, w)
Definition polys.h:372

◆ idSort()

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

Definition at line 187 of file ideals.h.

188{
189 return id_Sort(id, nolex, currRing);
190}
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 836 of file ideals.cc.

838{
839 ideal s_h1;
840 int j, k, length=0,reg;
842 int ii, idElemens_h1;
843
844 assume(h1 != NULL);
845
847#ifdef PDEBUG
848 for(ii=0;ii<idElemens_h1 /*IDELEMS(h1)*/;ii++) pTest(h1->m[ii]);
849#endif
850 if (idIs0(h1))
851 {
852 ideal result=idFreeModule(idElemens_h1/*IDELEMS(h1)*/);
853 return result;
854 }
856 k=si_max(1,slength /*id_RankFreeModule(h1)*/);
857
858 assume(currRing != NULL);
862
863 if (orig_ring != syz_ring)
864 {
867 }
868 else
869 {
870 s_h1 = h1;
871 }
872
873 idTest(s_h1);
874
878
879 ideal s_h3=idPrepare(s_h1,NULL,h,k,w,alg); // main (syz) GB computation
880
882
883 if (orig_ring != syz_ring)
884 {
885 idDelete(&s_h1);
886 for (j=0; j<IDELEMS(s_h3); j++)
887 {
888 if (s_h3->m[j] != NULL)
889 {
890 if (p_MinComp(s_h3->m[j],syz_ring) > k)
891 p_Shift(&s_h3->m[j], -k,syz_ring);
892 else
893 p_Delete(&s_h3->m[j],syz_ring);
894 }
895 }
897 s_h3->rank -= k;
901 #ifdef HAVE_PLURAL
903 {
906 }
907 #endif
908 idTest(s_h3);
909 return s_h3;
910 }
911
912 ideal e = idInit(IDELEMS(s_h3), s_h3->rank);
913
914 for (j=IDELEMS(s_h3)-1; j>=0; j--)
915 {
916 if (s_h3->m[j] != NULL)
917 {
918 if (p_MinComp(s_h3->m[j],syz_ring) <= k)
919 {
920 e->m[j] = s_h3->m[j];
923 s_h3->m[j] = NULL;
924 }
925 }
926 }
927
929 idSkipZeroes(e);
930
931 if ((deg != NULL)
932 && (!isMonomial)
934 && (setRegularity)
935 && (h==isHomog)
938 )
939 {
941 ring dp_C_ring = rAssure_dp_C(syz_ring); // will do rChangeCurrRing later
942 if (dp_C_ring != syz_ring)
943 {
946 }
949 *deg = reg+2;
950 delete dummy;
951 for (j=0;j<length;j++)
952 {
953 if (res[j]!=NULL) idDelete(&(res[j]));
954 }
956 idDelete(&e);
957 if (dp_C_ring != orig_ring)
958 {
961 }
962 }
963 else
964 {
965 idDelete(&e);
966 }
968 idTest(s_h3);
969 if (currRing->qideal != NULL)
970 {
971 ideal ts_h3=kStd(s_h3,currRing->qideal,h,w);
972 idDelete(&s_h3);
973 s_h3 = ts_h3;
974 }
975 return s_h3;
976}
ideal * resolvente
Definition ideals.h:18
#define TEST_OPT_NOTREGULARITY
Definition options.h:122
static long p_MinComp(poly p, ring lmRing, ring tailRing)
Definition p_polys.h:315
#define pTest(p)
Definition polys.h:415
ring rAssure_SyzComp(const ring r, BOOLEAN complete)
Definition ring.cc:4519
ring rAssure_dp_C(const ring r)
Definition ring.cc:5111
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:33
intvec * syBetti(resolvente res, int length, int *regularity, intvec *weights, BOOLEAN tomin, int *row_shift)
Definition syz.cc:783
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 2083 of file ideals.cc.

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

◆ idVec2Ideal()

static ideal idVec2Ideal ( poly  vec)
inlinestatic

Definition at line 172 of file ideals.h.

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

3659{
3661 if (strcmp(n,"default")==0) alg=GbDefault;
3662 else if (strcmp(n,"slimgb")==0) alg=GbSlimgb;
3663 else if (strcmp(n,"std")==0) alg=GbStd;
3664 else if (strcmp(n,"sba")==0) alg=GbSba;
3665 else if (strcmp(n,"singmatic")==0) alg=GbSingmatic;
3666 else if (strcmp(n,"groebner")==0) alg=GbGroebner;
3667 else if (strcmp(n,"modstd")==0) alg=GbModstd;
3668 else if (strcmp(n,"ffmod")==0) alg=GbFfmod;
3669 else if (strcmp(n,"nfmod")==0) alg=GbNfmod;
3670 else if (strcmp(n,"std:sat")==0) alg=GbStdSat;
3671 else Warn(">>%s<< is an unknown algorithm",n);
3672
3673 if (alg==GbSlimgb) // test conditions for slimgb
3674 {
3675 if(rHasGlobalOrdering(r)
3676 &&(!rIsNCRing(r))
3677 &&(r->qideal==NULL)
3678 &&(!rField_is_Ring(r)))
3679 {
3680 return GbSlimgb;
3681 }
3682 if (TEST_OPT_PROT)
3683 WarnS("requires: coef:field, commutative, global ordering, not qring");
3684 }
3685 else if (alg==GbSba) // cond. for sba
3686 {
3687 if(rField_is_Domain(r)
3688 &&(!rIsNCRing(r))
3689 &&(rHasGlobalOrdering(r)))
3690 {
3691 return GbSba;
3692 }
3693 if (TEST_OPT_PROT)
3694 WarnS("requires: coef:domain, commutative, global ordering");
3695 }
3696 else if (alg==GbGroebner) // cond. for groebner
3697 {
3698 return GbGroebner;
3699 }
3700 else if(alg==GbModstd) // cond for modstd: Q or Q(a)
3701 {
3702 if(ggetid("modStd")==NULL)
3703 {
3704 WarnS(">>modStd<< not found");
3705 }
3706 else if(rField_is_Q(r)
3707 &&(!rIsNCRing(r))
3708 &&(rHasGlobalOrdering(r)))
3709 {
3710 return GbModstd;
3711 }
3712 if (TEST_OPT_PROT)
3713 WarnS("requires: coef:QQ, commutative, global ordering");
3714 }
3715 else if(alg==GbStdSat) // cond for std:sat: 2 blocks of variables
3716 {
3717 if(ggetid("satstd")==NULL)
3718 {
3719 WarnS(">>satstd<< not found");
3720 }
3721 else
3722 {
3723 return GbStdSat;
3724 }
3725 }
3726
3727 return GbStd; // no conditions for std
3728}
#define Warn
Definition emacs.cc:77
GbVariant
Definition ideals.h:119
idhdl ggetid(const char *n)
Definition ipid.cc:581
static BOOLEAN rField_is_Domain(const ring r)
Definition ring.h:493
static BOOLEAN rField_is_Q(const ring r)
Definition ring.h:512