60 WarnS(
"minbase applies only to the local or homogeneous case over coefficient fields");
69 WarnS(
"minbase applies only to the local or homogeneous case over coefficient fields");
92 while ((
k > 0) && (h3->m[
k-1] ==
NULL))
k--;
95 while ((
l > 0) && (h2->m[
l-1] ==
NULL))
l--;
96 for (
i=
l-1;
i>=0;
i--)
101 while ((ll <
k) && ((h3->m[ll] ==
NULL)
153 for (
j=0;
j<r->N-1;
j++) names[
j]=r->names[
j];
238 Werror(
"error %d in >>groebner<<",err);
246 void *args[]={temp,(
void*)1,
NULL};
253 Werror(
"error %d in >>modStd<<",err);
296 void *args[]={temp,
v,
NULL};
304 Werror(
"error %d in >>satstd<<",err);
321 int rank=
si_max(h1->rank,h2->rank);
328 ideal first,second,temp,temp1,
result;
340 int t=flength; flength=slength; slength=t;
361 while ((
j>0) && (first->m[
j-1]==
NULL))
j--;
366 if (first->m[
i]!=
NULL)
368 if (syz_ring==orig_ring)
369 temp->m[
k] =
pCopy(first->m[
i]);
371 temp->m[
k] =
prCopyR(first->m[
i], orig_ring, syz_ring);
384 if (second->m[
i]!=
NULL)
386 if (syz_ring==orig_ring)
387 temp->m[
k] =
pCopy(second->m[
i]);
402 WarnS(
"wrong algorithm for GB");
407 if(syz_ring!=orig_ring)
414 if ((temp1->m[
i]!=
NULL)
417 if(syz_ring==orig_ring)
423 p =
prMoveR(temp1->m[
i], syz_ring,orig_ring);
440 if(syz_ring!=orig_ring)
474 int i,
j=0,
k=0,
l,maxrk=-1,realrki;
476 ideal bigmat,tempstd,
result;
488 if (realrki>maxrk) maxrk = realrki;
518 for (
i=0;
i<maxrk;
i++)
525 bigmat->m[
i] =
pAdd(bigmat->m[
i],
p);
539 if (syz_ring==orig_ring)
557 WarnS(
"wrong algorithm for GB");
562 if(syz_ring!=orig_ring)
572 if (syz_ring==orig_ring)
582 if(syz_ring!=orig_ring)
585 if(syz_ring!=orig_ring)
637 Warn(
"syzcomp too low, should be %d instead of %d",
k,syzcomp);
641 h2->rank = syzcomp+
i;
693 PrintS(
" --------------before std------------------------\n");
705 WarnS(
"wrong algorithm for GB");
716 int h1_size,
BOOLEAN inputIsIdeal,
const ring oring,
const ring sring)
726 Print(
"after std: --------------syzComp=%d------------------------\n",syzComp);
735 if (s_h3->m[
j] !=
NULL)
761 (*S)->m[
j]=s_h3->m[
j];
773 PrintS(
"T: ----------------------------------------\n");
792 if (s_h2->m[
j] !=
NULL)
794 poly q =
prMoveR( s_h2->m[
j], sring,oring);
842 int ii, idElemens_h1;
848 for(ii=0;ii<idElemens_h1 ;ii++)
pTest(h1->m[ii]);
863 if (orig_ring != syz_ring)
883 if (orig_ring != syz_ring)
888 if (s_h3->m[
j] !=
NULL)
916 if (s_h3->m[
j] !=
NULL)
920 e->m[
j] = s_h3->m[
j];
921 isMonomial=isMonomial && (
pNext(s_h3->m[
j])==
NULL);
940 assume(orig_ring==syz_ring);
942 if (dp_C_ring != syz_ring)
957 if (dp_C_ring != orig_ring)
999 return idInit(1,h1->rank);
1002 BITSET saveOpt1,saveOpt2;
1016 if (orig_ring != syz_ring)
1031 if (syz_ring!=orig_ring)
1041 if (syz_ring!=orig_ring)
rDelete(syz_ring);
1042 s_h3->rank=h1->rank;
1062 if (s_temp->m[
j]!=
NULL)
1075 s_temp->m[
j] =
pAdd(
p, q);
1092 *unit=
mpNew(e_mod,e_mod);
1094 for(
int i=e_mod;
i>0;
i--)
1117 int idelems_submod=
IDELEMS(submod);
1127 return idInit(1,idelems_mod);
1135 return idInit(1,idelems_mod);
1139 WerrorS(
"2nd module does not lie in the first");
1145 comps_to_add = idelems_submod;
1146 while ((comps_to_add>0) && (submod->m[comps_to_add-1]==
NULL))
1150 if ((
k!=0) && (lsmod==0)) lsmod=1;
1159 ideal s_mod, s_temp;
1160 if (orig_ring != syz_ring)
1207 for(
j = 0;
j<comps_to_add;
j++)
1220 s_temp->rank += (
k+comps_to_add);
1223 s_result->rank = s_h3->rank;
1230 if (s_result->m[
j]!=
NULL)
1240 WarnS(
"first module not a standardbasis\n"
1241 "// ** or second not a proper submodule");
1244 WerrorS(
"2nd module does not lie in the first");
1248 if(syz_ring!=orig_ring)
1259 s_result=
idInit(idelems_submod,idelems_mod);
1264 p = s_rest->m[
j] = s_result->m[
j];
1271 pNeg(s_result->m[
j]);
1274 if ((lsmod==0) && (s_rest!=
NULL))
1278 if (s_rest->m[
j-1]!=
NULL)
1284 if(syz_ring!=orig_ring)
1294 s_rest->rank=
mod->rank;
1301 *unit=
mpNew(idelems_submod,idelems_submod);
1305 poly
p=s_result->m[
i];
1323 else p=s_result->m[
i];
1334 s_result->rank=idelems_mod;
1414 int i,
l,ll,
k,kkk,kmax;
1422 if ((k2==0) && (
k>1)) *addOnlyOne =
FALSE;
1429 if (weights!=
NULL)
delete weights;
1434 if (h2->m[
i] !=
NULL)
1445 *kkmax = kmax =
j*
k+1;
1460 if (h4->m[
i-1]!=
NULL)
1474 if(temph1->m[
l]!=
NULL)
1476 for (ll=0; ll<
j; ll++)
1500 h4->m[
i] = h4->m[
i+1];
1540 if (orig_ring!=syz_ring)
1542 s_h4 =
idrMoveR(s_h4,orig_ring, syz_ring);
1571 m=idModule2Matrix(
idCopy(s_h3));
1572 Print(
"result, kmax=%d:\n",kmax);
1578 if (weights1!=
NULL)
delete weights1;
1596 s_h3->rank = h1->rank;
1597 if(syz_ring!=orig_ring)
1616 int *block0,*block1;
1630 WerrorS(
"cannot eliminate in a qring");
1643 WerrorS(
"no elimination is possible: subalgebra is not admissible");
1656 for (
k=0;
k<ordersize-1;
k++)
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]);
1671 double wNsqr = (double)2.0 / (
double)(
currRing->N);
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];
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);
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);
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++)
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)
1755 int l=(origR->block1[
k]-origR->block0[
k]+1)*
sizeof(
int);
1758 memcpy(wv[
k+1],origR->wvhdl[
k],
l);
1763 block1[0] =
rVar(origR);
1776 tmpR->block0 = block0;
1777 tmpR->block1 = block1;
1787 WerrorS(
"no elimination is possible: ordering condition is violated");
1804 if (origR->qideal!=
NULL)
1806 WarnS(
"eliminate in q-ring: experimental");
1821 WarnS(
"wrong algorithm for GB");
1828 while ((
i >= 0) && (hh->m[
i] ==
NULL))
i--;
1831 for (
k=0;
k<=
i;
k++)
1843 h3->m[
j] =
prMoveR( hh->m[
k], tmpR,origR);
1859 if (hh!=
NULL)
delete hh;
1863#ifdef WITH_OLD_MINOR
1867poly idMinor(
matrix a,
int ar,
unsigned long which, ideal
R)
1871 int *rowchoise,*colchoise;
1877 rowchoise=(
int *)
omAlloc(ar*
sizeof(
int));
1878 colchoise=(
int *)
omAlloc(ar*
sizeof(
int));
1889 for (
i=1;
i<=ar;
i++)
1891 for (
j=1;
j<=ar;
j++)
1907 for (
i=1;
i<=ar;
i++)
1930 int *rowchoise,*colchoise;
1940 rowchoise=(
int *)
omAlloc(ar*
sizeof(
int));
1941 colchoise=(
int *)
omAlloc(ar*
sizeof(
int));
1951 for (
i=1;
i<=ar;
i++)
1953 for (
j=1;
j<=ar;
j++)
1980 for (
i=1;
i<=ar;
i++)
2008 const int r = a->
nrows;
2009 const int c = a->
ncols;
2011 if((ar<=0) || (ar>r) || (ar>c))
2013 Werror(
"%d-th minor, matrix is %dx%d",ar,r,c);
2025 for (
int i=r*c-1;
i>=0;
i--)
2078 if (id1->m[
i] !=
NULL)
2107 if (
w->length()+1 < cmax)
2248 int i,
k,rk,flength=0,slength,
length;
2269 ((*wtmp)[
i])=(**w)[
i];
2293 if(temp->m[
i]!=
NULL)
2331 if (syz_ring != orig_ring)
2341 BITSET save_opt,save_opt2;
2356 if (wtmp!=
NULL)
delete wtmp;
2362 if (s_temp1->m[
i]!=
NULL)
2380 if (s_temp1->m[
i]!=
NULL)
2388 poly q =
prMoveR( s_temp1->m[
i], syz_ring,orig_ring);
2389 s_temp1->m[
i] =
NULL;
2403 }
while (q !=
NULL);
2416 if (syz_ring!=orig_ring)
2443 int i,flength=0,slength,
length;
2464 ((*wtmp)[
i])=(**w)[
i];
2487 if (syz_ring != orig_ring)
2498 BITSET save_opt,save_opt2;
2514 if (wtmp!=
NULL)
delete wtmp;
2520 if (syz_ring!=orig_ring)
2561 for (
i=0;
i<(*convert)->length();
i++)
2575 while ((
j>0) && (kbase->m[
j-1]==
NULL))
j--;
2576 if (
j==0)
return -1;
2585 if (
j==0)
return -1;
2647 while ((
i>0) && (kbase->m[
i-1]==
NULL))
i--;
2650 while ((
j>0) && (arg->m[
j-1]==
NULL))
j--;
2654 while ((
j>0) && (arg->m[
j-1]==
NULL))
j--;
2707 int i=0,
j, generator=-1;
2708 int rk_arg=arg->rank;
2709 int * componentIsUsed =(
int *)
omAlloc((rk_arg+1)*
sizeof(
int));
2712 while ((generator<0) && (
i<
IDELEMS(arg)))
2714 memset(componentIsUsed,0,(rk_arg+1)*
sizeof(
int));
2721 if (componentIsUsed[
j]==0)
2727 componentIsUsed[
j] = 1;
2731 componentIsUsed[
j] = -1;
2734 else if (componentIsUsed[
j]>0)
2736 (componentIsUsed[
j])++;
2746 if (componentIsUsed[
j]==0)
2751 componentIsUsed[
j] = 1;
2755 componentIsUsed[
j] = -1;
2758 else if (componentIsUsed[
j]>0)
2760 (componentIsUsed[
j])++;
2769 for (
j=0;
j<=rk_arg;
j++)
2771 if (componentIsUsed[
j]>0)
2773 if ((*
comp==-1) || (componentIsUsed[
j]<
i))
2776 i= componentIsUsed[
j];
2789 int* red_comp,
int &del)
2792 int i,next_gen,next_comp;
2796 for (
i=
res->rank;
i>=0;
i--) red_comp[
i]=
i;
2801 if (next_gen<0)
break;
2804 for(
i=next_comp+1;
i<=arg->rank;
i++) red_comp[
i]--;
2807 for(
i=next_comp;
i<(*w)->length();
i++) (**
w)[
i-1]=(**w)[
i];
2815 int nl=
si_max((*w)->length()-del,1);
2817 for(
i=0;
i<nl;
i++) (*wtmp)[
i]=(**w)[
i];
2826 int *red_comp=(
int*)
omAlloc((arg->rank+1)*
sizeof(
int));
2836 int *red_comp=(
int*)
omAlloc((arg->rank+1)*
sizeof(
int));
2852 for(
int i=0;
i<arg->rank;
i++)
g[
i]=
i+1;
2856 int *red_comp=(
int*)
omAlloc((arg->rank+1)*
sizeof(
int));
2860 for(
int i=1;
i<=arg->rank;
i++)
2870ideal idMinEmbedding_with_map0(ideal arg,
intvec **
w, ideal &trans)
2875 const int rk=a->rank;
2919 if(changed)
continue;
2928 while(a->m[
i]!=
NULL)
2955poly
id_GCD(poly
f, poly
g,
const ring r)
2959 ideal I=
idInit(2,1); I->m[0]=
f; I->m[1]=
g;
2973 ideal I=
idInit(2,1); I->m[0]=
f; I->m[1]=
g;
3001 int cnt=
IDELEMS(xx[0])*xx[0]->nrows;
3003 result->nrows=xx[0]->nrows;
3004 result->ncols=xx[0]->ncols;
3007 number *
x=(number *)
omAlloc(rl*
sizeof(number));
3008 for(
i=cnt-1;
i>=0;
i--)
3014 for(
j=rl-1;
j>=0;
j--)
3023 for(
j=rl-1;
j>=0;
j--)
3036 number n=n_ChineseRemainder(
x,q,rl,
R->cf);
3038 for(
j=rl-1;
j>=0;
j--)
3082 for(
i=cnt-1;
i>=0;
i--)
3186 for (
int i = 0;
i < idsize;
i++)
3188 id_sort[
i].
p =
id->m[
i];
3192 int index, index_i, index_j;
3194 for (
int j = 1;
j < idsize;
j++)
3198 index_i = id_sort[
i].
index;
3199 index_j = id_sort[
j].
index;
3200 if (index_j > index_i)
3225 if (strat->
P.t_p==
NULL)
3234 bool nonTrivialSaturationToBeDone=
true;
3237 nonTrivialSaturationToBeDone=
false;
3244 if (mm[
i]>0) nonTrivialSaturationToBeDone=
true;
3249 if (!nonTrivialSaturationToBeDone)
break;
3251 if (nonTrivialSaturationToBeDone)
3280 poly
p=strat->
P.t_p;
3287 bool nonTrivialSaturationToBeDone=
true;
3290 nonTrivialSaturationToBeDone=
false;
3297 if (mm[
i]>0) nonTrivialSaturationToBeDone =
true;
3302 if (!nonTrivialSaturationToBeDone)
break;
3304 if (nonTrivialSaturationToBeDone)
3343 for (
int i=0;
i<
k;
i++)
3352 WerrorS(
"ideal generators must be variables");
3362 Werror(
"generator must be a monomial");
3366 for (
int i=1;
i<=r->N;
i++)
3374 Werror(
"exponent(x(%d)^%d) must be 0 or 1",
i,li);
3389 int *block0,*block1;
3394 block0=(
int*)
omAlloc0(4*
sizeof(
int));
3395 block1=(
int*)
omAlloc0(4*
sizeof(
int));
3396 wv=(
int**)
omAlloc0(4*
sizeof(
int**));
3398 block0[0] = block0[1] = 1;
3399 block1[0] = block1[1] =
rVar(origR)+1;
3403 wv[0][
rVar(origR)]=1;
3405 for (
int j=0;
j<
rVar(origR);
j++)
3410 for (
int j=0;
j<
rVar(origR);
j++)
3418 char **names=(
char**)
omAlloc0((origR->N+1) *
sizeof(
char *));
3419 for (
int j=0;
j<
rVar(origR);
j++)
3420 names[
j]=origR->names[
j];
3421 names[
rVar(origR)]=(
char*)
"@";
3451 if ((TT->m[
j]!=
NULL)
3547 Iquot=
idQuot(Istd,J,isSB,isIdeal);
3591 if (ww!=
NULL)
delete ww;
3602 for(
int i=
rVar(r)-1;
i>0;
i--) perm[
i]=
i;
3636 if (ww!=
NULL)
delete ww;
3647 for(
int i=
rVar(r)-1;
i>0;
i--) perm[
i]=
i;
3669 if (strcmp(n,
"default")==0) alg=
GbDefault;
3670 else if (strcmp(n,
"slimgb")==0) alg=
GbSlimgb;
3671 else if (strcmp(n,
"std")==0) alg=
GbStd;
3672 else if (strcmp(n,
"sba")==0) alg=
GbSba;
3673 else if (strcmp(n,
"singmatic")==0) alg=
GbSingmatic;
3674 else if (strcmp(n,
"groebner")==0) alg=
GbGroebner;
3675 else if (strcmp(n,
"modstd")==0) alg=
GbModstd;
3676 else if (strcmp(n,
"ffmod")==0) alg=
GbFfmod;
3677 else if (strcmp(n,
"nfmod")==0) alg=
GbNfmod;
3678 else if (strcmp(n,
"std:sat")==0) alg=
GbStdSat;
3679 else Warn(
">>%s<< is an unknown algorithm",n);
3691 WarnS(
"requires: coef:field, commutative, global ordering, not qring");
3693 else if (alg==
GbSba)
3702 WarnS(
"requires: coef:domain, commutative, global ordering");
3712 WarnS(
">>modStd<< not found");
3721 WarnS(
"requires: coef:QQ, commutative, global ordering");
3727 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.
number ndCopyMap(number a, const coeffs src, const coeffs dst)
static FORCE_INLINE BOOLEAN n_IsUnit(number n, const coeffs r)
TRUE iff n has a multiplicative inverse in the given coeff field/ring r.
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff 'n' represents the zero element.
static FORCE_INLINE coeffs nCopyCoeff(const coeffs r)
"copy" coeffs, i.e. increment ref
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
int comp(const CanonicalForm &A, const CanonicalForm &B)
compare polynomials
void WerrorS(const char *s)
GbVariant syGetAlgorithm(char *n, const ring r, const ideal)
static ideal idMinEmbedding1(ideal arg, BOOLEAN inPlace, intvec **w, int *red_comp, int &del)
static void idPrepareStd(ideal s_temp, int k)
matrix idCoeffOfKBase(ideal arg, ideal kbase, poly how)
void idLiftW(ideal P, ideal Q, int n, matrix &T, ideal &R, int *w)
static void idLift_setUnit(int e_mod, matrix *unit)
ideal idSyzygies(ideal h1, tHomog h, intvec **w, BOOLEAN setSyzComp, BOOLEAN setRegularity, int *deg, GbVariant alg)
matrix idDiff(matrix i, int k)
ideal id_Sat_principal(ideal I, ideal J, const ring origR)
ideal idSaturateGB(ideal I, ideal J, int &k, BOOLEAN isIdeal)
static ideal idGroebner(ideal temp, int syzComp, GbVariant alg, bigintmat *hilb=NULL, intvec *w=NULL, tHomog hom=testHomog)
BOOLEAN idTestHomModule(ideal m, ideal Q, intvec *w)
ideal id_Homogenize(ideal I, int var_num, const ring r)
ideal idLiftStd(ideal h1, matrix *T, tHomog hi, ideal *S, GbVariant alg, ideal h11)
void idDelEquals(ideal id)
int pCompare_qsort(const void *a, const void *b)
ideal idQuot(ideal h1, ideal h2, BOOLEAN h1IsStb, BOOLEAN resultIsIdeal)
ideal id_HomogenizeW(ideal I, int var_num, intvec *w, const ring r)
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 idSaturate(ideal I, ideal J, int &k, BOOLEAN isIdeal)
void ipPrint_MA0(matrix m, const char *name)
BOOLEAN idIsSubModule(ideal id1, ideal id2)
ideal idSeries(int n, ideal M, matrix U, intvec *w)
ideal idMinEmbedding_with_map_v(ideal arg, intvec **w, ideal &trans, int *g)
ideal idCreateSpecialKbase(ideal kBase, intvec **convert)
static ideal idPrepare(ideal h1, ideal h11, tHomog hom, int syzcomp, intvec **w, GbVariant alg)
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)
ideal idSaturate_intern(ideal I, ideal J, int &k, BOOLEAN isIdeal, BOOLEAN isSB)
ideal idElimination2(ideal h1, poly delVar, bigintmat *hilb, GbVariant alg)
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)
static ideal idSectWithElim(ideal h1, ideal h2, GbVariant alg)
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)
represents the generators of submod in terms of the generators of mod (Matrix(SM)*U-Matrix(rest)) = M...
STATIC_VAR int * id_satstdSaturatingVariables
ideal idExtractG_T_S(ideal s_h3, matrix *T, ideal *S, long syzComp, int h1_size, BOOLEAN inputIsIdeal, const ring oring, const ring sring)
static void idDeleteComps(ideal arg, int *red_comp, int del)
ideal idModulo(ideal h2, ideal h1, tHomog hom, intvec **w, matrix *T, GbVariant alg)
ideal idMinEmbedding_with_map(ideal arg, intvec **w, ideal &trans)
ideal idMinBase(ideal h1, ideal *SB)
ideal id_Farey(ideal x, number N, const ring r)
ideal id_Satstd(const ideal I, ideal J, const ring r)
static int id_ReadOutPivot(ideal arg, int *comp, const ring r)
ideal idModuloLP(ideal h2, ideal h1, tHomog, intvec **w, matrix *T, GbVariant alg)
static BOOLEAN id_sat_vars_sp(kStrategy strat)
ideal idMinEmbedding(ideal arg, BOOLEAN inPlace, intvec **w)
#define idDelete(H)
delete an ideal
#define idSimpleAdd(A, B)
void idGetNextChoise(int r, int end, BOOLEAN *endch, int *choise)
ideal id_Copy(ideal h1, const ring r)
copy an ideal
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
static BOOLEAN idHomModule(ideal m, ideal Q, intvec **w)
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)
static intvec * idSort(ideal id, BOOLEAN nolex=TRUE)
ideal idFreeModule(int i)
static BOOLEAN length(leftv result, leftv arg)
bigintmat * iv2biv(intvec *hilb, const coeffs cf)
intvec * ivCopy(const intvec *o)
idhdl ggetid(const char *n)
EXTERN_VAR omBin sleftv_bin
leftv ii_CallLibProcM(const char *n, void **args, int *arg_types, const ring R, BOOLEAN &err)
args: NULL terminated array of arguments arg_types: 0 terminated array of corresponding types
void * iiCallLibProc1(const char *n, void *arg, int arg_type, BOOLEAN &err)
void p_TakeOutComp(poly *p, long comp, poly *q, int *lq, const ring r)
ideal kMin_std2(ideal F, ideal Q, tHomog h, intvec **w, ideal &M, bigintmat *hilb, int syzComp, int reduced)
ideal kStd2(ideal F, ideal Q, tHomog h, intvec **w, bigintmat *hilb, int syzComp, int newIdeal, intvec *vw, s_poly_proc_t sp)
generic interface to GB/SB computations, large hilbert vectors
ideal kSba(ideal F, ideal Q, tHomog h, intvec **w, int sbaOrder, int arri, bigintmat *hilb, int syzComp, int newIdeal, intvec *vw)
poly kNF(ideal F, ideal Q, poly p, int syzComp, int lazyReduce)
static nc_type & ncRingType(nc_struct *p)
BOOLEAN nc_CheckSubalgebra(poly PolyVar, ring r)
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 omFreeBin(addr, bin)
#define SI_SAVE_OPT(A, B)
#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
#define SI_RESTORE_OPT(A, B)
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
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)
poly p_Div_nn(poly p, const number n, const ring r)
void p_Norm(poly p1, const ring r)
int p_Compare(const poly a, const poly b, const ring R)
long p_DegW(poly p, const int *w, const ring R)
poly p_Vec2Poly(poly v, int k, const ring r)
void p_SetModDeg(intvec *w, ring r)
int p_Var(poly m, const ring r)
poly p_Sub(poly p1, poly p2, 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 void p_LmDelete(poly p, const ring r)
static poly p_Mult_q(poly p, poly q, const ring r)
static long p_SubExp(poly p, int v, long ee, ring r)
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 BOOLEAN p_LmIsConstantComp(const poly p, const ring r)
static poly p_Head(const poly p, const ring r)
copy the (leading) term of 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
static long p_Totaldegree(poly p, const ring r)
void rChangeCurrRing(ring r)
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Compatibility 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_Wp_C(const ring r, intvec *w)
ring rAssure_Dp_C(const ring r)
BOOLEAN rOrd_is_Totaldegree_Ordering(const ring r)
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
ring rDefault(const coeffs cf, int N, char **n, int ord_size, rRingOrder_t *ord, int *block0, int *block1, int **wvhdl, unsigned long bitmask)
void rSetSyzComp(int k, const ring r)
ring rAssure_dp_C(const ring r)
static BOOLEAN rHasGlobalOrdering(const ring r)
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
static int rBlocks(const ring r)
static BOOLEAN rField_is_Domain(const ring r)
static BOOLEAN rIsLPRing(const ring r)
@ ringorder_a64
for int64 weights
@ ringorder_aa
for idElimination, like a, except pFDeg, pWeigths ignore it
static BOOLEAN rField_is_Q(const ring r)
static BOOLEAN rIsNCRing(const ring r)
static short rVar(const ring r)
#define rVar(r) (r->N)
#define rField_is_Ring(R)
ideal idInit(int idsize, int rank)
initialise an ideal / module
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
ideal id_Homogen(ideal h, int varnum, const ring r)
matrix id_Module2Matrix(ideal mod, const ring R)
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
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
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
void id_Shift(ideal M, int s, const ring r)
ideal id_ChineseRemainder(ideal *xx, number *q, int rl, const ring r)
static int idElem(const ideal F)
number of non-zero polys in F
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)
void syGaussForOne(ideal syz, int elnum, int ModComp, int from, int till)
intvec * syBetti(resolvente res, int length, int *regularity, intvec *weights, BOOLEAN tomin, int *row_shift)
resolvente sySchreyerResolvente(ideal arg, int maxlength, int *length, BOOLEAN isMonomial=FALSE, BOOLEAN notReplace=FALSE)
int name
New type name for int.
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)