Loading...
Searching...
No Matches
kLiftstd.cc
Go to the documentation of this file.
/****************************************
* Computer Algebra System SINGULAR *
****************************************/
/*
* ABSTRACT - Kernel: alg. of Buchberger
*/
#include "kernel/mod2.h"
// define if no buckets should be used
// #define NO_BUCKETS
#include "omalloc/omalloc.h"
#include "kernel/GBEngine/kutil.h"
#include "misc/options.h"
#include "kernel/polys.h"
#include "kernel/ideals.h"
#include "kernel/GBEngine/kstd1.h"
#include "kernel/GBEngine/khstd.h"
#include "polys/kbuckets.h"
#include "polys/prCopy.h"
#include "polys/weight.h"
#include "misc/intvec.h"
#ifdef HAVE_PLURAL
#include "polys/nc/nc.h"
#endif
static poly kSplitAt(int k,TObject* h,kStrategy strat)
{
poly p;
if (h->t_p==NULL)
{
if (currRing!=strat->tailRing)
{
h->t_p=k_LmInit_currRing_2_tailRing(h->p, strat->tailRing);
p=h->t_p;
}
else
p=h->p;
}
else
p=h->t_p;
if (p->next==NULL) return NULL;
const ring tailRing=strat->tailRing;
while(p_GetComp(p->next,tailRing)<=k)
{
pIter(p);
if ((p==NULL)||(p->next==NULL))
{
h->pLength=0; // force re-computation
return NULL;
}
}
poly t=p->next;
p->next=NULL;
h->pLength=0; // force re-computation
if ((h->p!=NULL) && (h->t_p!=NULL)
&& (pNext(h->p)!=pNext(h->t_p)))
{
pNext(h->p)=pNext(h->t_p);
}
return t;
}
static poly kSplitAt(int k,LObject* h,kStrategy strat)
{
poly p,pr,t=NULL;
int l;
if (h->bucket!=NULL)
{
kBucketClear(h->bucket,&p,&l);
pr=p;
}
else
{
if (h->t_p==NULL)
{
if (currRing!=strat->tailRing)
{
h->t_p=k_LmInit_currRing_2_tailRing(h->p, strat->tailRing);
p=h->t_p;
}
else
p=h->p;
}
else
p=h->t_p;
}
const ring tailRing=strat->tailRing;
if(p==NULL) return NULL;
if (p_GetComp(p,tailRing)>k)
{
return p;
}
if (p->next==NULL)
{
goto finish;
}
while(p_GetComp(p->next,tailRing)<=k)
{
pIter(p);
if (p->next==NULL) break;
}
t=p->next;
p->next=NULL;
finish:
if (h->bucket!=NULL)
{
l=pLength(pr);
kBucketInit(h->bucket,pr,l);
}
else
{
if ((h->p!=NULL) && (h->t_p!=NULL))
{
pNext(h->p)=pNext(h->t_p);
}
}
return t;
}
static void kAppend(poly t,TObject* h)
{
poly p;
if (h->t_p!=NULL)
p=h->t_p;
else
p=h->p;
while(p->next!=NULL) pIter(p);
p->next=t;
if ((h->p!=NULL)&&(h->t_p!=NULL)) pNext(h->p)=pNext(h->t_p);
}
static poly lazyComp(number* A, poly* M,poly* T,int index,poly s,int *l,const ring tailR)
{
if ((TEST_OPT_PROT) && (index>0)) { Print("<%d>",index+1); mflush(); }
kBucket_pt b=kBucketCreate(tailR);
kBucketInit(b,s,pLength(s));
int cnt=RED_CANONICALIZE;
for(int i=0;i<index;i++)
{
kBucket_Mult_n(b,A[i]);
n_Delete(&A[i],tailR->cf);
poly tt=T[i];
if (tt!=NULL)
{
cnt--;
int dummy=pLength(tt);
kBucket_Minus_m_Mult_p(b,M[i],tt,&dummy);
}
p_Delete(&M[i],tailR);
if (UNLIKELY(cnt==0))
{
cnt=RED_CANONICALIZE;
kBucketCanonicalize(b);
}
}
poly p;
kBucketClear(b,&p,l);
kBucketDestroy(&b);
return p;
}
/*2
* reduction procedure for the sugar-strategy (honey)
* reduces h with elements from T choosing first possible
* element in T with respect to the given ecart
*/
int redLiftstd (LObject* h, kStrategy strat)
{
if (strat->tl<0) return 1;
assume(h->FDeg == h->pFDeg());
assume(TEST_OPT_IDLIFT);
poly h_p;
int i,j,pass,ei, ii, h_d,ci;
unsigned long not_sev;
long reddeg,d;
#define START_REDUCE 512
int red_size=START_REDUCE;
number *A=(number*)omAlloc0(red_size*sizeof(number));
poly *C=(poly*)omAlloc0(red_size*sizeof(poly));
poly *T=(poly*)omAlloc0(red_size*sizeof(poly));
const ring tailRing=strat->tailRing;
pass = j = 0;
d = reddeg = h->GetpFDeg() + h->ecart;
h->SetShortExpVector();
int li;
h_p = h->GetLmTailRing();
not_sev = ~ h->sev;
// split h into main part (h) and tail (h_tail)
poly h_tail=kSplitAt(strat->syzComp,h,strat);
// fix h-pLength
h->pLength=0;
h->PrepareRed(strat->use_buckets);
loop
{
j=kFindDivisibleByInT(strat, h);
if (j < 0)
{
// lazy computation:
int l;
poly p=lazyComp(A,C,T,pass,h_tail,&l,strat->tailRing);
kBucket_Add_q(h->bucket,p,&l);
omFreeSize(A,red_size*sizeof(number));
omFreeSize(T,red_size*sizeof(poly));
omFreeSize(C,red_size*sizeof(poly));
return 1;
}
ei = strat->T[j].ecart;
li = strat->T[j].pLength;
ci = nSize(pGetCoeff(strat->T[j].p));
ii = j;
/*
* the polynomial to reduce with (up to the moment) is;
* pi with ecart ei (T[ii])
*/
i = j;
if (TEST_OPT_LENGTH)
{
if (li<=0) li=strat->T[j].GetpLength();
if (li>1)
loop
{
/*- possible with respect to ecart, minimal nSize -*/
i++;
if (i > strat->tl)
break;
//if (ei < h->ecart)
// break;
if ((((strat->T[i].ecart < ei) && (ei> h->ecart))
|| ((strat->T[i].ecart <= h->ecart)
&& (strat->T[i].pLength <= li)
&& (nSize(pGetCoeff(strat->T[i].p)) <ci)))
&&
p_LmShortDivisibleBy(strat->T[i].GetLmTailRing(), strat->sevT[i],
h_p, not_sev, tailRing))
{
/*
* the polynomial to reduce with is now;
*/
ei = strat->T[i].ecart;
li = strat->T[i].pLength;
if (li<=0) li=strat->T[i].GetpLength();
ii = i;
if (li==1) break;
}
}
}
/*
* end of search: have to reduce with pi
*/
#ifdef KDEBUG
if (TEST_OPT_DEBUG)
{
PrintS("red:");
h->wrp();
Print("\nwith T[%d]:",ii);
strat->T[ii].wrp();
}
#endif
assume(strat->fromT == FALSE);
//strat->T[ii].pCleardenom();
// split T[ii]:
// remember pLength of strat->T[ii]
int l_orig=strat->T[ii].pLength;
// split strat->T[ii]
poly T_tail=kSplitAt(strat->syzComp,&strat->T[ii],strat);
h->pLength=0; // force re-computation of length
ksReducePoly(h,&(strat->T[ii]),NULL,&A[pass],&C[pass], strat);
// restore T[ii]:
kAppend(T_tail,&strat->T[ii]);
strat->T[ii].pLength=l_orig;
// store T_tail
T[pass]=T_tail;
// delayed computation: A[pass]*tail-M[pass]*T[pass]
#ifdef KDEBUG
if (TEST_OPT_DEBUG)
{
PrintS("\nto:");
h->wrp();
PrintLn();
}
#endif
if(h->IsNull())
{
// clean up A,C,h_tail:
for(int i=0;i<=pass;i++)
{
n_Delete(&A[i],tailRing->cf);
p_Delete(&C[i],tailRing);
}
p_Delete(&h_tail,tailRing);
kDeleteLcm(h);
h->Clear();
omFreeSize(A,red_size*sizeof(number));
omFreeSize(T,red_size*sizeof(poly));
omFreeSize(C,red_size*sizeof(poly));
return 0;
}
h->SetShortExpVector();
not_sev = ~ h->sev;
h_d = h->SetpFDeg();
/* compute the ecart */
if (ei <= h->ecart)
h->ecart = d-h_d;
else
h->ecart = d-h_d+ei-h->ecart;
/*
* try to reduce the s-polynomial h
*test first whether h should go to the lazyset L
*-if the degree jumps
*-if the number of pre-defined reductions jumps
*/
pass++;
d = h_d + h->ecart;
if (pass%RED_CANONICALIZE==0) kBucketCanonicalize(h->bucket);
// if cache is to small, double its size:
if (pass>=red_size-1)
{
A=(number*)omRealloc0Size(A,red_size*sizeof(number),2*red_size*sizeof(number));
C=(poly*)omRealloc0Size(C,red_size*sizeof(poly),2*red_size*sizeof(poly));
T=(poly*)omRealloc0Size(T,red_size*sizeof(poly),2*red_size*sizeof(poly));
if(TEST_OPT_PROT) {Print("+%d+",red_size);mflush();}
red_size*=2;
}
}
}
//---------------------------------------------------------------------------
static void setUnit(int e, ideal *unit)
{
if (unit!=NULL)
{
*unit=idInit(e,e);
for(int i=e-1;i>=0;i--)
{
poly p=pOne();
p_Shift(&p,i+1,currRing);
(*unit)->m[i]=p;
}
}
}
ideal idDivRem(ideal A,const ideal quot, ideal &factor,ideal *unit,int lazyReduce)
{
/* special cases */
if (idIs0(A) || idIs0(quot))
{
factor=idInit(1,IDELEMS(quot));
setUnit(A->rank,unit);
return idCopy(A);
}
/* ideal or module? */
ring orig_ring=currRing;
int k=id_RankFreeModule(quot,orig_ring);
int lsmod=0;
if (k==0) { lsmod=1;k=1;} /*ideal*/
/* NF(A 0 E,quot E 0)
* A,quot: 1..k, 0,E: k+1..k+IDELEMS(quot),
* E,0: k+IDELEMS(quot)..k+IDELEMS(quot)+IDELEMS(A) */
/* new ring */
ring syz_ring=rAssure_SyzOrder(orig_ring,TRUE);
rSetSyzComp(1,syz_ring);
rChangeCurrRing(syz_ring);
/* move ideals to new ring */
ideal s_quot;
ideal s_A;
if (orig_ring != syz_ring)
{
s_quot=idrCopyR_NoSort(quot,orig_ring,syz_ring);
s_A=idrCopyR_NoSort(A,orig_ring,syz_ring);
}
else
{
s_quot=id_Copy(quot,syz_ring);
s_A=id_Copy(A,syz_ring);
}
/* quot[i] -> quot[i]+e(k+i+1) */
for(int i=0;i<IDELEMS(s_quot);i++)
{
p_Shift(&s_quot->m[i],lsmod,syz_ring);
poly p=p_One(syz_ring);
p_SetComp(p,k+i+2,syz_ring);
p_Setm(p,syz_ring);
s_quot->m[i]=p_Add_q(s_quot->m[i],p,syz_ring);
}
s_quot->rank=k+IDELEMS(quot)+1;
/* A[i] -> A[i]*e(1) */
if (lsmod==1)
{
for(int i=0;i<IDELEMS(s_A);i++)
{
p_Shift(&s_A->m[i],1,syz_ring);
}
}
if (unit!=NULL)
{
int u_k=k+IDELEMS(quot)+2;
for(int i=0;i<IDELEMS(s_A);i++)
{
poly p=p_One(syz_ring);
p_SetComp(p,u_k+i,syz_ring);
p_Setm(p,syz_ring);
s_A->m[i]=p_Add_q(s_A->m[i],p,syz_ring);
}
s_A->rank=k+IDELEMS(quot)+IDELEMS(A)+1;
}
/* normalform */
#if 0
PrintS("to reduce:\n");
{
void ipPrint_MA0(matrix m, const char *name);
matrix m = id_Module2Matrix(id_Copy(s_A,currRing),currRing);
ipPrint_MA0(m, "A");
id_Delete((ideal *) &m,currRing);
}
PrintS("with:\n");
{
void ipPrint_MA0(matrix m, const char *name);
matrix m = id_Module2Matrix(id_Copy(s_quot,currRing),currRing);
ipPrint_MA0(m, "B");
id_Delete((ideal *) &m,currRing);
}
#endif
ideal rest=kNF(s_quot,syz_ring->qideal,s_A,0,lazyReduce);
#if 0
PrintS("result NF:\n");
{
void ipPrint_MA0(matrix m, const char *name);
matrix m = id_Module2Matrix(id_Copy(rest,currRing),currRing);
ipPrint_MA0(m, "A");
id_Delete((ideal *) &m,currRing);
}
#endif
/* clean s_quot,s_A */
id_Delete(&s_quot,syz_ring);
id_Delete(&s_A,syz_ring);
/* interpret rest: remainder */
ideal result=idInit(IDELEMS(rest),A->rank);
for(int i=0;i<IDELEMS(rest);i++)
{
poly p=rest->m[i];
poly d=NULL;
while(p!=NULL)
{
poly q=p; pIter(p);
pNext(q)=NULL;
if (p_GetComp(q,syz_ring)<=k)
{
result->m[i]=p_Add_q(result->m[i],q,syz_ring);
}
else
{
d=p_Add_q(d,q,syz_ring);
}
}
rest->m[i]=d;
p_Shift(&result->m[i],-lsmod,syz_ring);
}
#if 0
PrintS("rest:\n");
{
void ipPrint_MA0(matrix m, const char *name);
matrix m = id_Module2Matrix(id_Copy(result,currRing),currRing);
ipPrint_MA0(m, "_");
id_Delete((ideal *) &m,currRing);
}
#endif
#if 0
PrintS("factor+unit:\n");
{
void ipPrint_MA0(matrix m, const char *name);
matrix m = id_Module2Matrix(id_Copy(rest,currRing),currRing);
ipPrint_MA0(m, "_");
id_Delete((ideal *) &m,currRing);
}
#endif
/* interpret rest: factors */
factor=idInit(IDELEMS(rest),IDELEMS(quot));
if (unit==NULL)
{
for(int i=0;i<IDELEMS(rest);i++)
{
poly p=rest->m[i];
p_Shift(&p,-k-lsmod,syz_ring);
factor->m[i]=p;
factor->m[i]=p_Neg(factor->m[i],syz_ring);
rest->m[i]=NULL;
}
}
else
{
*unit=idInit(IDELEMS(A),IDELEMS(A));
/* comp k+1..u_k-1 -> rest, u_k.. -> unit*/
int u_k=k+IDELEMS(quot)+2;
for(int i=0;i<IDELEMS(rest);i++)
{
poly p=rest->m[i];
rest->m[i]=NULL;
poly d=NULL;
while(p!=NULL)
{
poly q=p; pIter(p);
pNext(q)=NULL;
if(p_GetComp(q,syz_ring)<u_k)
{
p_Shift(&q,-k-1,syz_ring);
factor->m[i]=p_Add_q(factor->m[i],q,syz_ring);
}
else
{
d=p_Add_q(d,q,syz_ring);
}
}
(*unit)->m[i]=d;
/*fix sign:*/
factor->m[i]=p_Neg(factor->m[i],syz_ring);
p_Shift(&(*unit)->m[i],-(IDELEMS(quot)+k+1),syz_ring);
}
}
id_Delete(&rest,syz_ring);
if (orig_ring != syz_ring)
{
rChangeCurrRing(orig_ring);
result=idrMoveR_NoSort(result, syz_ring, orig_ring);
factor=idrMoveR(factor, syz_ring, orig_ring);
if (unit!=NULL)
{
*unit=idrMoveR(*unit, syz_ring, orig_ring);
}
rDelete(syz_ring);
}
return result;
}
UNLIKELY
#define UNLIKELY(X)
Definition auxiliary.h:405
TRUE
#define TRUE
Definition auxiliary.h:101
FALSE
#define FALSE
Definition auxiliary.h:97
l
int l
Definition cfEzgcd.cc:100
m
int m
Definition cfEzgcd.cc:128
i
int i
Definition cfEzgcd.cc:132
k
int k
Definition cfEzgcd.cc:99
p
int p
Definition cfModGcd.cc:4086
b
CanonicalForm b
Definition cfModGcd.cc:4111
skStrategy::syzComp
int syzComp
Definition kutil.h:353
skStrategy::tailRing
ring tailRing
Definition kutil.h:342
skStrategy::T
TSet T
Definition kutil.h:325
skStrategy::tl
int tl
Definition kutil.h:349
skStrategy::sevT
unsigned long * sevT
Definition kutil.h:324
skStrategy::use_buckets
char use_buckets
Definition kutil.h:380
skStrategy::fromT
char fromT
Definition kutil.h:376
n_Delete
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
Definition coeffs.h:461
Print
#define Print
Definition emacs.cc:80
result
return result
Definition facAbsBiFact.cc:76
s
const CanonicalForm int s
Definition facAbsFact.cc:51
factor
CanonicalForm factor
Definition facAbsFact.cc:97
j
int j
Definition facHensel.cc:110
name
char name(const Variable &v)
Definition factory.h:189
ipPrint_MA0
void ipPrint_MA0(matrix m, const char *name)
Definition ipprint.cc:57
ideals.h
id_Copy
ideal id_Copy(ideal h1, const ring r)
copy an ideal
Definition simpleideals.cc:542
idIs0
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
Definition simpleideals.cc:960
idCopy
ideal idCopy(ideal A)
Definition ideals.h:60
intvec.h
T
STATIC_VAR jList * T
Definition janet.cc:30
h
STATIC_VAR Poly * h
Definition janet.cc:971
k_LmInit_currRing_2_tailRing
KINLINE poly k_LmInit_currRing_2_tailRing(poly p, ring tailRing, omBin tailBin)
Definition kInline.h:959
redLiftstd
int redLiftstd(LObject *h, kStrategy strat)
Definition kLiftstd.cc:167
lazyComp
static poly lazyComp(number *A, poly *M, poly *T, int index, poly s, int *l, const ring tailR)
Definition kLiftstd.cc:132
kAppend
static void kAppend(poly t, TObject *h)
Definition kLiftstd.cc:121
START_REDUCE
#define START_REDUCE
idDivRem
ideal idDivRem(ideal A, const ideal quot, ideal &factor, ideal *unit, int lazyReduce)
Definition kLiftstd.cc:347
setUnit
static void setUnit(int e, ideal *unit)
Definition kLiftstd.cc:334
kSplitAt
static poly kSplitAt(int k, TObject *h, kStrategy strat)
Definition kLiftstd.cc:28
kBucketClear
void kBucketClear(kBucket_pt bucket, poly *p, int *length)
Definition kbuckets.cc:521
kBucket_Minus_m_Mult_p
void kBucket_Minus_m_Mult_p(kBucket_pt bucket, poly m, poly p, int *l, poly spNoether)
Bpoly == Bpoly - m*p; where m is a monom Does not destroy p and m assume (*l <= 0 || pLength(p) == *l...
Definition kbuckets.cc:722
kBucket_Mult_n
void kBucket_Mult_n(kBucket_pt bucket, number n)
Multiply Bucket by number ,i.e. Bpoly == n*Bpoly.
Definition kbuckets.cc:598
kBucketDestroy
void kBucketDestroy(kBucket_pt *bucket_pt)
Definition kbuckets.cc:216
kBucketInit
void kBucketInit(kBucket_pt bucket, poly lm, int length)
Definition kbuckets.cc:493
kBucketCreate
kBucket_pt kBucketCreate(const ring bucket_ring)
Creation/Destruction of buckets.
Definition kbuckets.cc:209
kBucket_Add_q
void kBucket_Add_q(kBucket_pt bucket, poly q, int *l)
Add to Bucket a poly ,i.e. Bpoly == q+Bpoly.
Definition kbuckets.cc:660
kbuckets.h
kBucketCanonicalize
int kBucketCanonicalize(kBucket_pt bucket)
Canonicalizes Bpoly, i.e. converts polys of buckets into one poly in one bucket: Returns number of bu...
khstd.h
ksReducePoly
int ksReducePoly(LObject *PR, TObject *PW, poly spNoether, number *coef, poly *mon, kStrategy strat, BOOLEAN reduce)
Definition kspoly.cc:187
kNF
poly kNF(ideal F, ideal Q, poly p, int syzComp, int lazyReduce)
Definition kstd1.cc:3229
kstd1.h
kFindDivisibleByInT
int kFindDivisibleByInT(const kStrategy strat, const LObject *L, const int start)
return -1 if no divisor is found number of first divisor in T, otherwise
Definition kstd2.cc:317
kutil.h
kDeleteLcm
static void kDeleteLcm(LObject *P)
Definition kutil.h:876
RED_CANONICALIZE
#define RED_CANONICALIZE
Definition kutil.h:37
TObject
class sTObject TObject
Definition kutil.h:58
LObject
class sLObject LObject
Definition kutil.h:59
nc.h
matrix
ip_smatrix * matrix
Definition matpol.h:43
mod2.h
assume
#define assume(x)
Definition mod2.h:389
p_GetComp
#define p_GetComp(p, r)
Definition monomials.h:64
pIter
#define pIter(p)
Definition monomials.h:37
pNext
#define pNext(p)
Definition monomials.h:36
pGetCoeff
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
Definition monomials.h:44
nSize
#define nSize(n)
Definition numbers.h:39
omFreeSize
#define omFreeSize(addr, size)
Definition omAllocDecl.h:260
omAlloc0
#define omAlloc0(size)
Definition omAllocDecl.h:211
omRealloc0Size
#define omRealloc0Size(addr, o_size, size)
Definition omAllocDecl.h:221
NULL
#define NULL
Definition omList.c:12
omalloc.h
options.h
TEST_OPT_IDLIFT
#define TEST_OPT_IDLIFT
Definition options.h:131
TEST_OPT_LENGTH
#define TEST_OPT_LENGTH
Definition options.h:132
TEST_OPT_PROT
#define TEST_OPT_PROT
Definition options.h:105
TEST_OPT_DEBUG
#define TEST_OPT_DEBUG
Definition options.h:110
index
static int index(p_Length length, p_Ord ord)
Definition p_Procs_Impl.h:592
p_Shift
void p_Shift(poly *p, int i, const ring r)
shifts components of the vector p by i
Definition p_polys.cc:4860
p_One
poly p_One(const ring r)
Definition p_polys.cc:1314
p_Neg
static poly p_Neg(poly p, const ring r)
Definition p_polys.h:1114
pLength
static int pLength(poly a)
Definition p_polys.h:190
p_Add_q
static poly p_Add_q(poly p, poly q, const ring r)
Definition p_polys.h:938
p_SetComp
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
Definition p_polys.h:249
p_Setm
static void p_Setm(poly p, const ring r)
Definition p_polys.h:235
p_LmShortDivisibleBy
static BOOLEAN p_LmShortDivisibleBy(poly a, unsigned long sev_a, poly b, unsigned long not_sev_b, const ring r)
Definition p_polys.h:1931
p_Delete
static void p_Delete(poly *p, const ring r)
Definition p_polys.h:903
rChangeCurrRing
void rChangeCurrRing(ring r)
Definition polys.cc:16
currRing
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition polys.cc:13
polys.h
Compatibility layer for legacy polynomial operations (over currRing).
pOne
#define pOne()
Definition polys.h:316
idrMoveR
ideal idrMoveR(ideal &id, ring src_r, ring dest_r)
Definition prCopy.cc:248
idrMoveR_NoSort
ideal idrMoveR_NoSort(ideal &id, ring src_r, ring dest_r)
Definition prCopy.cc:261
idrCopyR_NoSort
ideal idrCopyR_NoSort(ideal id, ring src_r, ring dest_r)
Definition prCopy.cc:205
prCopy.h
PrintS
void PrintS(const char *s)
Definition reporter.cc:288
PrintLn
void PrintLn()
Definition reporter.cc:314
mflush
#define mflush()
Definition reporter.h:58
rAssure_SyzOrder
ring rAssure_SyzOrder(const ring r, BOOLEAN complete)
Definition ring.cc:4522
rDelete
void rDelete(ring r)
unconditionally deletes fields in r
Definition ring.cc:454
rSetSyzComp
void rSetSyzComp(int k, const ring r)
Definition ring.cc:5230
kBucket_pt
kBucket * kBucket_pt
Definition ring.h:26
idInit
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition simpleideals.cc:35
id_Delete
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
Definition simpleideals.cc:123
id_Module2Matrix
matrix id_Module2Matrix(ideal mod, const ring R)
Definition simpleideals.cc:1594
id_RankFreeModule
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
Definition simpleideals.cc:992
IDELEMS
#define IDELEMS(i)
Definition simpleideals.h:23
A
#define A
Definition sirandom.c:24
M
#define M
Definition sirandom.c:25
kStrategy
skStrategy * kStrategy
Definition structs.h:54
loop
#define loop
Definition structs.h:71
weight.h