56 WarnS(
"minbase applies only to the local or homogeneous case over coefficient fields");
65 WarnS(
"minbase applies only to the local or homogeneous case over coefficient fields");
89 while ((
k > 0) && (h3->m[
k-1] ==
NULL))
k--;
92 while ((
l > 0) && (h2->m[
l-1] ==
NULL))
l--;
93 for (
i=
l-1;
i>=0;
i--)
98 while ((ll <
k) && ((h3->m[ll] ==
NULL)
150 for (
j=0;
j<r->N-1;
j++) names[
j]=r->names[
j];
205 int rank=
si_max(h1->rank,h2->rank);
208 ideal first,second,temp,temp1,
result;
220 int t=flength; flength=slength; slength=t;
240 while ((
j>0) && (first->m[
j-1]==
NULL))
j--;
245 if (first->m[
i]!=
NULL)
247 if (syz_ring==orig_ring)
248 temp->m[
k] =
pCopy(first->m[
i]);
250 temp->m[
k] =
prCopyR(first->m[
i], orig_ring, syz_ring);
263 if (second->m[
i]!=
NULL)
265 if (syz_ring==orig_ring)
266 temp->m[
k] =
pCopy(second->m[
i]);
295 Werror(
"error %d in >>groebner<<",err);
303 void *args[]={temp,(
void*)1,
NULL};
308 Werror(
"error %d in >>modStd<<",err);
345 void *args[]={temp,
v,
NULL};
351 Werror(
"error %d in >>satstd<<",err);
356 if(syz_ring!=orig_ring)
363 if ((temp1->m[
i]!=
NULL)
366 if(syz_ring==orig_ring)
372 p =
prMoveR(temp1->m[
i], syz_ring,orig_ring);
389 if(syz_ring!=orig_ring)
421 int i,
j=0,
k=0,
l,maxrk=-1,realrki;
423 ideal bigmat,tempstd,
result;
436 if (realrki>maxrk) maxrk = realrki;
462 for (
i=0;
i<maxrk;
i++)
469 bigmat->m[
i] =
pAdd(bigmat->m[
i],
p);
483 if (syz_ring==orig_ring)
516 Werror(
"error %d in >>groebner<<",err);
540 Werror(
"wrong algorithm %d for SB",(
int)alg);
543 if(syz_ring!=orig_ring)
553 if (syz_ring==orig_ring)
563 if(syz_ring!=orig_ring)
566 if(syz_ring!=orig_ring)
597 Warn(
"syzcomp too low, should be %d instead of %d",
k,syzcomp);
601 h2->rank = syzcomp+
i;
647 Werror(
"error %d in >>groebner<<",err);
660 Werror(
"error %d in >>modStd<<",err);
703 Werror(
"error %d in >>satstd<<",err);
715 Werror(
"wrong algorithm %d for SB",(
int)alg);
734 int ii, idElemens_h1;
740 for(ii=0;ii<idElemens_h1 ;ii++)
pTest(h1->m[ii]);
755 if (orig_ring != syz_ring)
771 if (orig_ring != syz_ring)
779 if (orig_ring != syz_ring)
784 if (s_h3->m[
j] !=
NULL)
812 if (s_h3->m[
j] !=
NULL)
816 e->m[
j] = s_h3->m[
j];
817 isMonomial=isMonomial && (
pNext(s_h3->m[
j])==
NULL);
836 assume(orig_ring==syz_ring);
838 if (dp_C_ring != syz_ring)
853 if (dp_C_ring != orig_ring)
887 if (orig_ring != syz_ring)
903 if (orig_ring != syz_ring)
940 return idInit(1,h1->rank);
957 if (orig_ring != syz_ring)
976 if (s_h3->m[
j] !=
NULL)
1003 (*syz)->m[
j]=s_h3->m[
j];
1025 if (syz_ring!=orig_ring)
1036 if (s_h2->m[
j] !=
NULL)
1038 q =
prMoveR( s_h2->m[
j], syz_ring,orig_ring);
1072 if (syz_ring!=orig_ring)
rDelete(syz_ring);
1092 if (s_temp->m[
j]!=
NULL)
1133 WerrorS(
"2nd module does not lie in the first");
1138 comps_to_add =
IDELEMS(submod);
1139 while ((comps_to_add>0) && (submod->m[comps_to_add-1]==
NULL))
1143 if ((
k!=0) && (lsmod==0)) lsmod=1;
1145 if (k<submod->rank) {
WarnS(
"rk(submod) > rk(mod) ?");
k=submod->rank; }
1152 ideal s_mod, s_temp;
1153 if (orig_ring != syz_ring)
1188 for(
j = 0;
j<comps_to_add;
j++)
1201 s_temp->rank += (
k+comps_to_add);
1204 s_result->rank = s_h3->rank;
1211 if (s_result->m[
j]!=
NULL)
1219 WarnS(
"first module not a standardbasis\n"
1220 "// ** or second not a proper submodule");
1223 WerrorS(
"2nd module does not lie in the first");
1231 p = s_rest->m[
j] = s_result->m[
j];
1238 pNeg(s_result->m[
j]);
1241 if ((lsmod==0) && (s_rest!=
NULL))
1245 if (s_rest->m[
j-1]!=
NULL)
1251 if(syz_ring!=orig_ring)
1266 *unit=
mpNew(comps_to_add,comps_to_add);
1270 poly
p=s_result->m[
i];
1288 else p=s_result->m[
i];
1378 int i,
l,ll,
k,kkk,kmax;
1386 if ((k2==0) && (
k>1)) *addOnlyOne =
FALSE;
1393 if (weights!=
NULL)
delete weights;
1398 if (h2->m[
i] !=
NULL)
1409 *kkmax = kmax =
j*
k+1;
1424 if (h4->m[
i-1]!=
NULL)
1438 if(temph1->m[
l]!=
NULL)
1440 for (ll=0; ll<
j; ll++)
1464 h4->m[
i] = h4->m[
i+1];
1504 if (orig_ring!=syz_ring)
1506 s_h4 =
idrMoveR(s_h4,orig_ring, syz_ring);
1532 m=idModule2Matrix(
idCopy(s_h3));
1533 Print(
"result, kmax=%d:\n",kmax);
1538 if (weights1!=
NULL)
delete weights1;
1556 s_h3->rank = h1->rank;
1557 if(syz_ring!=orig_ring)
1576 int *block0,*block1;
1590 WerrorS(
"cannot eliminate in a qring");
1603 WerrorS(
"no elimination is possible: subalgebra is not admissible");
1613 if (origR->order[
k]!=0) ordersize++;
1620 for (
k=0;
k<ordersize-1;
k++)
1622 block0[
k+1] = origR->block0[
k];
1623 block1[
k+1] = origR->block1[
k];
1624 ord[
k+1] = origR->order[
k];
1625 if (origR->wvhdl[
k]!=
NULL) wv[
k+1] = (
int*)
omMemDup(origR->wvhdl[
k]);
1635 double wNsqr = (double)2.0 / (
double)(
currRing->N);
1639 wCall(h1->m, sl,
x, wNsqr);
1640 for (sl = (
currRing->N); sl!=0; sl--)
1641 wv[1][sl-1] =
x[sl + (
currRing->N) + 1];
1657 block0=(
int*)
omAlloc0(4*
sizeof(
int));
1658 block1=(
int*)
omAlloc0(4*
sizeof(
int));
1659 wv=(
int**)
omAlloc0(4*
sizeof(
int**));
1660 block0[0] = block0[1] = 1;
1661 block1[0] = block1[1] =
rVar(origR);
1684 block0=(
int*)
omAlloc0(4*
sizeof(
int));
1685 block1=(
int*)
omAlloc0(4*
sizeof(
int));
1686 wv=(
int**)
omAlloc0(4*
sizeof(
int**));
1687 block0[0] = block0[1] = 1;
1688 block1[0] = block1[1] =
rVar(origR);
1706 block0=(
int*)
omAlloc0(ordersize*
sizeof(
int));
1707 block1=(
int*)
omAlloc0(ordersize*
sizeof(
int));
1708 wv=(
int**)
omAlloc0(ordersize*
sizeof(
int**));
1709 for (
k=0;
k<ordersize-1;
k++)
1711 block0[
k+1] = origR->block0[
k];
1712 block1[
k+1] = origR->block1[
k];
1713 ord[
k+1] = origR->order[
k];
1714 if (origR->wvhdl[
k]!=
NULL) wv[
k+1] = (
int*)
omMemDup(origR->wvhdl[
k]);
1717 block1[0] =
rVar(origR);
1730 tmpR->block0 = block0;
1731 tmpR->block1 = block1;
1741 WerrorS(
"no elimination is possible: ordering condition is violated");
1758 if (origR->qideal!=
NULL)
1760 WarnS(
"eliminate in q-ring: experimental");
1794 Werror(
"error %d in >>groebner<<",err);
1807 Werror(
"error %d in >>modStd<<",err);
1811 else if (alg==
GbSba)
1819 Werror(
"wrong algorithm %d for SB",(
int)alg);
1830 while ((
i >= 0) && (hh->m[
i] ==
NULL))
i--;
1833 for (
k=0;
k<=
i;
k++)
1845 h3->m[
j] =
prMoveR( hh->m[
k], tmpR,origR);
1857 #ifdef WITH_OLD_MINOR
1861 poly idMinor(
matrix a,
int ar,
unsigned long which, ideal
R)
1865 int *rowchoise,*colchoise;
1874 rowchoise=(
int *)
omAlloc(ar*
sizeof(
int));
1875 colchoise=(
int *)
omAlloc(ar*
sizeof(
int));
1890 for (
i=1;
i<=ar;
i++)
1892 for (
j=1;
j<=ar;
j++)
1907 for (
i=1;
i<=ar;
i++)
1931 int *rowchoise,*colchoise;
1940 rowchoise=(
int *)
omAlloc(ar*
sizeof(
int));
1941 colchoise=(
int *)
omAlloc(ar*
sizeof(
int));
1942 if ((
i>512) || (
j>512) || (
i*
j >512))
size=512;
1953 for (
i=1;
i<=ar;
i++)
1955 for (
j=1;
j<=ar;
j++)
1985 for (
i=1;
i<=ar;
i++)
2013 const int r = a->
nrows;
2014 const int c = a->
ncols;
2016 if((ar<=0) || (ar>r) || (ar>c))
2018 Werror(
"%d-th minor, matrix is %dx%d",ar,r,c);
2030 for (
int i=r*c-1;
i>=0;
i--)
2084 if (id1->m[
i] !=
NULL)
2113 if (
w->length()+1 < cmax)
2255 int i,
k,rk,flength=0,slength,
length;
2276 ((*wtmp)[
i])=(**w)[
i];
2297 if(temp->m[
i]!=
NULL)
2336 if (syz_ring != orig_ring)
2356 if (wtmp!=
NULL)
delete wtmp;
2360 if ((s_temp1->m[
i]!=
NULL)
2373 if (syz_ring!=orig_ring)
2418 for (
i=0;
i<(*convert)->length();
i++)
2432 while ((
j>0) && (kbase->m[
j-1]==
NULL))
j--;
2433 if (
j==0)
return -1;
2442 if (
j==0)
return -1;
2504 while ((
i>0) && (kbase->m[
i-1]==
NULL))
i--;
2507 while ((
j>0) && (arg->m[
j-1]==
NULL))
j--;
2511 while ((
j>0) && (arg->m[
j-1]==
NULL))
j--;
2565 int i,next_gen,next_comp;
2569 int *red_comp=(
int*)
omAlloc((
res->rank+1)*
sizeof(int));
2570 for (
i=
res->rank;
i>=0;
i--) red_comp[
i]=
i;
2576 if (next_gen<0)
break;
2579 for(
i=next_comp+1;
i<=arg->rank;
i++) red_comp[
i]--;
2582 for(
i=next_comp;
i<(*w)->length();
i++) (**
w)[
i-1]=(**w)[
i];
2592 int nl=
si_max((*w)->length()-del,1);
2594 for(
i=0;
i<
res->rank;
i++) (*wtmp)[
i]=(**w)[
i];
2604 poly
id_GCD(poly
f, poly
g,
const ring r)
2608 ideal I=
idInit(2,1); I->m[0]=
f; I->m[1]=
g;
2622 ideal I=
idInit(2,1); I->m[0]=
f; I->m[1]=
g;
2650 int cnt=
IDELEMS(xx[0])*xx[0]->nrows;
2652 result->nrows=xx[0]->nrows;
2653 result->ncols=xx[0]->ncols;
2656 number *
x=(number *)
omAlloc(rl*
sizeof(number));
2657 for(
i=cnt-1;
i>=0;
i--)
2663 for(
j=rl-1;
j>=0;
j--)
2672 for(
j=rl-1;
j>=0;
j--)
2685 number n=n_ChineseRemainder(
x,q,rl,
R->cf);
2687 for(
j=rl-1;
j>=0;
j--)
2731 for(
i=cnt-1;
i>=0;
i--)
2835 for (
int i = 0;
i < idsize;
i++)
2837 id_sort[
i].
p =
id->m[
i];
2841 int index, index_i, index_j;
2843 for (
int j = 1;
j < idsize;
j++)
2847 index_i = id_sort[
i].
index;
2848 index_j = id_sort[
j].
index;
2849 if (index_j > index_i)
2874 if (strat->
P.t_p==
NULL)
2883 bool nonTrivialSaturationToBeDone=
true;
2886 nonTrivialSaturationToBeDone=
false;
2893 if (mm[
i]>0) nonTrivialSaturationToBeDone=
true;
2898 if (!nonTrivialSaturationToBeDone)
break;
2900 if (nonTrivialSaturationToBeDone)
2909 memset(&strat->
P,0,
sizeof(strat->
P));
2928 poly
p=strat->
P.t_p;
2935 bool nonTrivialSaturationToBeDone=
true;
2938 nonTrivialSaturationToBeDone=
false;
2945 if (mm[
i]>0) nonTrivialSaturationToBeDone =
true;
2950 if (!nonTrivialSaturationToBeDone)
break;
2952 if (nonTrivialSaturationToBeDone)
2960 memset(&strat->
P,0,
sizeof(strat->
P));
2990 for (
int i=0;
i<
k;
i++)
2999 WerrorS(
"ideal generators must be variables");
3007 for (
int i=1;
i<=r->N;
i++)
3015 Werror(
"exponent(x(%d)^%d) must be 0 or 1",
i,li);
3030 if (strcmp(n,
"slimgb")==0) alg=
GbSlimgb;
3031 else if (strcmp(n,
"std")==0) alg=
GbStd;
3032 else if (strcmp(n,
"sba")==0) alg=
GbSba;
3033 else if (strcmp(n,
"singmatic")==0) alg=
GbSingmatic;
3034 else if (strcmp(n,
"groebner")==0) alg=
GbGroebner;
3035 else if (strcmp(n,
"modstd")==0) alg=
GbModstd;
3036 else if (strcmp(n,
"ffmod")==0) alg=
GbFfmod;
3037 else if (strcmp(n,
"nfmod")==0) alg=
GbNfmod;
3038 else if (strcmp(n,
"std:sat")==0) alg=
GbStdSat;
3039 else Warn(
">>%s<< is an unknown algorithm",n);
3051 WarnS(
"requires: coef:field, commutative, global ordering, not qring");
3053 else if (alg==
GbSba)
3062 WarnS(
"requires: coef:domain, commutative, global ordering");
3072 WarnS(
">>modStd<< not found");
3081 WarnS(
"requires: coef:QQ, commutative, global ordering");
3087 WarnS(
">>satstd<< not found");
static int si_max(const int a, const int b)
static int si_min(const int a, const int b)
const CanonicalForm CFMap CFMap & N
static CanonicalForm bound(const CFMatrix &M)
poly singclap_pdivide(poly f, poly g, const ring r)
Coefficient rings, fields and other domains suitable for Singular polynomials.
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff 'n' represents the zero element.
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
const CanonicalForm int s
CanonicalForm divide(const CanonicalForm &ff, const CanonicalForm &f, const CFList &as)
const Variable & v
< [in] a sqrfree bivariate poly
char name(const Variable &v)
void WerrorS(const char *s)
intvec * idMWLift(ideal mod, intvec *weights)
ideal idSectWithElim(ideal h1, ideal h2)
GbVariant syGetAlgorithm(char *n, const ring r, const ideal)
static void idPrepareStd(ideal s_temp, int k)
matrix idCoeffOfKBase(ideal arg, ideal kbase, poly how)
ideal idSyzygies(ideal h1, tHomog h, intvec **w, BOOLEAN setSyzComp, BOOLEAN setRegularity, int *deg, GbVariant alg)
matrix idDiff(matrix i, int k)
ideal idLiftStd(ideal h1, matrix *ma, tHomog hi, ideal *syz, GbVariant alg)
BOOLEAN idTestHomModule(ideal m, ideal Q, intvec *w)
void idDelEquals(ideal id)
int pCompare_qsort(const void *a, const void *b)
ideal idQuot(ideal h1, ideal h2, BOOLEAN h1IsStb, BOOLEAN resultIsIdeal)
ideal idMinors(matrix a, int ar, ideal R)
compute all ar-minors of the matrix a the caller of mpRecMin the elements of the result are not in R ...
ideal idXXX(ideal h1, int k)
BOOLEAN idIsSubModule(ideal id1, ideal id2)
ideal idSeries(int n, ideal M, matrix U, intvec *w)
ideal idCreateSpecialKbase(ideal kBase, intvec **convert)
poly id_GCD(poly f, poly g, const ring r)
int idIndexOfKBase(poly monom, ideal kbase)
poly idDecompose(poly monom, poly how, ideal kbase, int *pos)
matrix idDiffOp(ideal I, ideal J, BOOLEAN multiply)
void idSort_qsort(poly_sort *id_sort, int idsize)
static ideal idInitializeQuot(ideal h1, ideal h2, BOOLEAN h1IsStb, BOOLEAN *addOnlyOne, int *kkmax)
ideal idElimination(ideal h1, poly delVar, intvec *hilb, GbVariant alg)
ideal idMinBase(ideal h1)
ideal idSect(ideal h1, ideal h2, GbVariant alg)
ideal idMultSect(resolvente arg, int length, GbVariant alg)
void idKeepFirstK(ideal id, const int k)
keeps the first k (>= 1) entries of the given ideal (Note that the kept polynomials may be zero....
ideal idLift(ideal mod, ideal submod, ideal *rest, BOOLEAN goodShape, BOOLEAN isSB, BOOLEAN divide, matrix *unit, GbVariant alg)
STATIC_VAR int * id_satstdSaturatingVariables
static void idDeleteComps(ideal arg, int *red_comp, int del)
ideal id_Farey(ideal x, number N, const ring r)
ideal id_Satstd(const ideal I, ideal J, const ring r)
void idLiftW(ideal P, ideal Q, int n, matrix &T, ideal &R, short *w)
static BOOLEAN id_sat_vars_sp(kStrategy strat)
ideal idMinEmbedding(ideal arg, BOOLEAN inPlace, intvec **w)
ideal idModulo(ideal h2, ideal h1, tHomog hom, intvec **w)
static ideal idPrepare(ideal h1, tHomog hom, int syzcomp, intvec **w, GbVariant alg)
#define idDelete(H)
delete an ideal
#define idSimpleAdd(A, B)
void idGetNextChoise(int r, int end, BOOLEAN *endch, int *choise)
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
static BOOLEAN idHomModule(ideal m, ideal Q, intvec **w)
static intvec * idSort(ideal id, BOOLEAN nolex=TRUE)
static BOOLEAN idHomIdeal(ideal id, ideal Q=NULL)
static ideal idMult(ideal h1, ideal h2)
hh := h1 * h2
#define idMaxIdeal(D)
initialise the maximal ideal (at 0)
void idInitChoise(int r, int beg, int end, BOOLEAN *endch, int *choise)
ideal idFreeModule(int i)
static BOOLEAN length(leftv result, leftv arg)
idhdl ggetid(const char *n)
void * iiCallLibProc1(const char *n, void *arg, int arg_type, BOOLEAN &err)
void * iiCallLibProcM(const char *n, void **args, int *arg_types, BOOLEAN &err)
args: NULL terminated arry of arguments arg_types: 0 terminated array of corresponding types
void ipPrint_MA0(matrix m, const char *name)
ideal kGroebner(ideal F, ideal Q)
void p_TakeOutComp(poly *p, long comp, poly *q, int *lq, const ring r)
ideal kMin_std(ideal F, ideal Q, tHomog h, intvec **w, ideal &M, intvec *hilb, int syzComp, int reduced)
poly kNF(ideal F, ideal Q, poly p, int syzComp, int lazyReduce)
ideal kSba(ideal F, ideal Q, tHomog h, intvec **w, int sbaOrder, int arri, intvec *hilb, int syzComp, int newIdeal, intvec *vw)
ideal kStd(ideal F, ideal Q, tHomog h, intvec **w, intvec *hilb, int syzComp, int newIdeal, intvec *vw, s_poly_proc_t sp)
BOOLEAN nc_CheckSubalgebra(poly PolyVar, ring r)
static nc_type & ncRingType(nc_struct *p)
matrix mpNew(int r, int c)
create a r x c zero-matrix
matrix mp_MultP(matrix a, poly p, const ring R)
multiply a matrix 'a' by a poly 'p', destroy the args
matrix mp_Copy(matrix a, const ring r)
copies matrix a (from ring r to r)
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)
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
poly mp_DetBareiss(matrix a, const ring r)
returns the determinant of the matrix m; uses Bareiss algorithm
#define MATELEM(mat, i, j)
1-based access to matrix
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
#define __p_GetComp(p, r)
#define omFreeSize(addr, size)
#define SI_RESTORE_OPT1(A)
#define SI_RESTORE_OPT2(A)
#define TEST_OPT_RETURN_SB
#define TEST_V_INTERSECT_ELIM
#define TEST_V_INTERSECT_SYZ
#define TEST_OPT_NOTREGULARITY
static int index(p_Length length, p_Ord ord)
poly p_DivideM(poly a, poly b, const ring r)
poly p_Farey(poly p, number N, const ring r)
int p_Weight(int i, const ring r)
void p_Shift(poly *p, int i, const ring r)
shifts components of the vector p by i
int p_Compare(const poly a, const poly b, const ring R)
long p_DegW(poly p, const short *w, const ring R)
void p_SetModDeg(intvec *w, ring r)
int p_Var(poly m, const ring r)
void pEnlargeSet(poly **p, int l, int increment)
long p_Deg(poly a, const ring r)
static poly p_Neg(poly p, const ring r)
static poly p_Add_q(poly p, poly q, const ring r)
static long p_SubExp(poly p, int v, long ee, ring r)
static poly p_Head(poly p, const ring r)
copy the i(leading) term of p
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
static long p_MinComp(poly p, ring lmRing, ring tailRing)
static void p_Setm(poly p, const ring r)
static poly p_Copy_noCheck(poly p, const ring r)
returns a copy of p (without any additional testing)
static number p_SetCoeff(poly p, number n, ring r)
static poly pReverse(poly p)
static int p_LmCmp(poly p, poly q, const ring r)
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent @Note: the integer VarOffset encodes:
static void p_Delete(poly *p, const ring r)
static void p_GetExpV(poly p, int *ev, const ring r)
static poly p_LmFreeAndNext(poly p, ring)
static poly p_Copy(poly p, const ring r)
returns a copy of p
void rChangeCurrRing(ring r)
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Compatiblity layer for legacy polynomial operations (over currRing)
#define pHead(p)
returns newly allocated copy of Lm(p), coef is copied, next=NULL, p might be NULL
#define pGetComp(p)
Component.
#define pSetCoeff(p, n)
deletes old coeff before setting the new one
#define pSeries(n, p, u, w)
#define pGetExp(p, i)
Exponent.
#define pSetmComp(p)
TODO:
#define pEqualPolys(p1, p2)
#define pDivisibleBy(a, b)
returns TRUE, if leading monom of a divides leading monom of b i.e., if there exists a expvector c > ...
void pTakeOutComp(poly *p, long comp, poly *q, int *lq, const ring R=currRing)
Splits *p into two polys: *q which consists of all monoms with component == comp and *p of all other ...
#define pCopy(p)
return a copy of the poly
poly prMoveR(poly &p, ring src_r, ring dest_r)
ideal idrMoveR(ideal &id, ring src_r, ring dest_r)
poly prCopyR(poly p, ring src_r, ring dest_r)
ideal idrCopyR(ideal id, ring src_r, ring dest_r)
ideal idrMoveR_NoSort(ideal &id, ring src_r, ring dest_r)
poly prMoveR_NoSort(poly &p, ring src_r, ring dest_r)
ideal idrCopyR_NoSort(ideal id, ring src_r, ring dest_r)
void PrintS(const char *s)
void Werror(const char *fmt,...)
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...
ring rAssure_SyzComp(const ring r, BOOLEAN complete)
BOOLEAN nc_rComplete(const ring src, ring dest, bool bSetupQuotient)
ring rAssure_SyzOrder(const ring r, BOOLEAN complete)
ring rCopy0(const ring r, BOOLEAN copy_qideal, BOOLEAN copy_ordering)
void rDelete(ring r)
unconditionally deletes fields in r
void rSetSyzComp(int k, const ring r)
ring rAssure_dp_C(const ring r)
static BOOLEAN rField_is_Ring(const ring r)
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
static BOOLEAN rField_is_Domain(const ring r)
@ ringorder_aa
for idElimination, like a, except pFDeg, pWeigths ignore it
static BOOLEAN rField_is_Q(const ring r)
static short rVar(const ring r)
#define rVar(r) (r->N)
BOOLEAN rHasGlobalOrdering(const ring r)
ideal idInit(int idsize, int rank)
initialise an ideal / module
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
int id_ReadOutPivot(ideal arg, int *comp, const ring r)
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
ideal id_Matrix2Module(matrix mat, const ring R)
converts mat to module, destroys mat
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size
void id_Shift(ideal M, int s, const ring r)
ideal id_ChineseRemainder(ideal *xx, number *q, int rl, const ring r)
long sm_ExpBound(ideal m, int di, int ra, int t, const ring currRing)
ring sm_RingChange(const ring origR, long bound)
void sm_KillModifiedRing(ring r)
intvec * syBetti(resolvente res, int length, int *regularity, intvec *weights, BOOLEAN tomin, int *row_shift)
void syGaussForOne(ideal syz, int elnum, int ModComp, int from, int till)
resolvente sySchreyerResolvente(ideal arg, int maxlength, int *length, BOOLEAN isMonomial=FALSE, BOOLEAN notReplace=FALSE)
ideal t_rep_gb(const ring r, ideal arg_I, int syz_comp, BOOLEAN F4_mode)
THREAD_VAR double(* wFunctional)(int *degw, int *lpol, int npol, double *rel, double wx, double wNsqr)
void wCall(poly *s, int sl, int *x, double wNsqr, const ring R)
double wFunctionalBuch(int *degw, int *lpol, int npol, double *rel, double wx, double wNsqr)