30 #if __FLINT_RELEASE >= 20503
31 #include <flint/fmpq_mpoly.h>
38#define OVERFLOW_MAX LONG_MAX
39#define OVERFLOW_MIN LONG_MIN
41#define OVERFLOW_MAX (((int64)LONG_MAX)<<30)
42#define OVERFLOW_MIN (-OVERFLOW_MAX)
384 mpz_set_ui(dummy, 1);
386 mpz_set_si(dummy, -1);
387 mpz_add(ec, ec, dummy);
400 int i,howmanyvarinp = 0;
420 poly notsqrfree =
NULL;
437 if(notsqrfree !=
NULL)
510static void rouneslice(ideal I, ideal S, poly q, poly
x,
int &
prune,
int &moreprune,
int &steps,
int &NNN, mpz_ptr &hilbertcoef,
int* &hilbpower)
612 hilbertcoef = (mpz_ptr)
omAlloc((NNN+1)*
sizeof(mpz_t));
613 hilbpower = (
int*)
omAlloc((NNN+1)*
sizeof(int));
614 mpz_init_set( &hilbertcoef[NNN], ec);
626 mpz_add(&hilbertcoef[
i],&hilbertcoef[
i],ec_ptr);
631 hilbertcoef = (mpz_ptr)
omRealloc(hilbertcoef, (NNN+1)*
sizeof(mpz_t));
632 hilbpower = (
int*)
omRealloc(hilbpower, (NNN+1)*
sizeof(int));
633 mpz_init(&hilbertcoef[NNN]);
634 for(
j = NNN;
j>
i;
j--)
636 mpz_set(&hilbertcoef[
j],&hilbertcoef[
j-1]);
637 hilbpower[
j] = hilbpower[
j-1];
639 mpz_set( &hilbertcoef[
i], ec);
657 rouneslice(Ip, Sp, pq,
x,
prune, moreprune, steps, NNN, hilbertcoef,hilbpower);
670 int steps = 0,
prune = 0, moreprune = 0;
687 rouneslice(I,S,q,X->m[0],
prune, moreprune, steps, NNN, hilbertcoef, hilbpower);
693 printf(
"\n// %8d t^0",1);
694 for(
i = 0;
i<NNN;
i++)
696 if(mpz_sgn(&hilbertcoef[
i])!=0)
698 gmp_printf(
"\n// %8Zd t^%d",&hilbertcoef[
i],hilbpower[
i]);
712 if (hseries1 ==
NULL)
714 work =
new intvec(hseries1);
717 for (
i =
k-1;
i >= 0;
i--)
721 if ((
s != 0) || (
k == 1))
726 for (
i =
k-1;
i >= 0;
i--)
735 for (
i =
k-1;
i >= 0;
i--)
736 (*hseries2)[
i] = (*work)[
i];
737 (*hseries2)[
k] = (*work)[
l];
754 for(
k=
j-2;
k>=0;
k--)
767#if defined(HAVE_FLINT) && (__FLINT_RELEASE >= 20503)
769 fmpq_mpoly_ctx_t ctx;
770 convSingRFlintR(ctx,Qt);
773 di2=Flint_Divide_MP(di1,0,o_t,0,ctx,Qt);
774 if (di2==
NULL)
break;
789 if (dummy!=Di1)
break;
801 if ((modul_weight!=
NULL)&&(modul_weight->
compare(0)!=0))
804 Print(
"module weights:%s\n",
s);
811 if (hseries==
NULL) di=0;
823 Print(
"// dimension (proj.) = %d\n// degree (proj.) = %d\n", di-1,
mu);
825 Print(
"// dimension (affine) = 0\n// degree (affine) = %d\n",
mu);
828 Print(
"// dimension (local) = %d\n// multiplicity = %d\n", di,
mu);
840 Qt->block0 = (
int *)
omAlloc0(3 *
sizeof(
int *));
841 Qt->block1 = (
int *)
omAlloc0(3 *
sizeof(
int *));
857 if ((src->VarOffset[0]== -1)
858 || (src->pCompIndex<0))
889 if ((modulweight!=
NULL)&&(modulweight->
compare(0)!=0))
892 Print(
"module weights:%s\n",
s);
919 while ((
j >= 0) && (I->m[
j] ==
NULL))
948 if(JCount != ObCount)
953 for(
i = 0;
i < JCount;
i++)
1004 if(JCount != ObCount)
1014 for(
i = 0;
i< JCount;
i++)
1038 int orbCount = idorb.size();
1064 for(
i = 1;
i < orbCount;
i++)
1085 dtrp = trInd - degp;
1114 int OrbCount = idorb.size();
1121 for(
i = 1;
i < OrbCount;
i++)
1146 int OrbCount = idorb.size();
1147 int dtr=0;
int IwCount, ObCount;
1152 for(
i = 1;
i < OrbCount;
i++)
1175 for(
i = 1;
i < OrbCount;
i++)
1188 for(
i = 1;
i < OrbCount;
i++)
1243 for(
k = ICount - 1;
k >=1;
k--)
1245 for(
i = 0;
i <
k;
i++)
1267 poly smon =
p_One(r);
1271 int *e=(
int *)
omAlloc((r->N+1)*
sizeof(int));
1272 int *
s=(
int *)
omAlloc0((r->N+1)*
sizeof(int));
1275 for(
j = 1;
j <= cnt;
j++)
1302 int *e = (
int *)
omAlloc((r->N+1)*
sizeof(int));
1303 int *
s=(
int *)
omAlloc0((r->N+1)*
sizeof(int));
1312 for(
j = (cnt+1);
j < (r->N+1);
j++)
1327static void TwordMap(poly
p, poly
w,
int lV,
int d, ideal Jwi,
bool &flag)
1343 for(
i = 0;
i <= d - 1;
i++)
1388static ideal
colonIdeal(ideal S, poly
w,
int lV, ideal Jwi,
int trunDegHs)
1403 if(trunDegHs !=0 && d >= trunDegHs)
1410 for(
i = 0;
i < SCount;
i++)
1446 PrintS(
"Hilbert Series:\n 0\n");
1449 int (*POS)(ideal, poly, std::vector<ideal>, std::vector<poly>, int, int);
1452 Print(
"\nTruncation degree = %d\n",trunDegHs);
1461 WerrorS(
"wrong input: it is not an infinitely gen. case");
1470 std::vector<ideal > idorb;
1471 std::vector< poly > polist;
1473 ideal orb_init =
idInit(1, 1);
1474 idorb.push_back(orb_init);
1478 std::vector< std::vector<int> > posMat;
1479 std::vector<int> posRow(lV,0);
1483 unsigned long lpcnt = 0;
1488 while(lpcnt < idorb.size())
1492 if(lpcnt >= 1 &&
idIs0(idorb[lpcnt]) ==
FALSE)
1509 for(is = 1; is <= lV; is++)
1530 ps = (*POS)(Jwi, wi, idorb, polist, trInd, trunDegHs);
1534 posRow[is-1] = idorb.size();
1536 idorb.push_back(Jwi);
1537 polist.push_back(wi);
1546 posMat.push_back(posRow);
1547 posRow.resize(lV,0);
1552 Print(
"\nlength of the Orbit = %d", lO);
1557 Print(
"words description of the Orbit: \n");
1558 for(is = 0; is < lO; is++)
1564 PrintS(
"\nmaximal degree, #(sum_j R(w,w_j))");
1566 for(is = 0; is < lO; is++)
1568 if(
idIs0(idorb[is]))
1579 for(is = idorb.size()-1; is >= 0; is--)
1583 for(is = polist.size()-1; is >= 0; is--)
1591 int adjMatrix[lO][lO];
1592 memset(adjMatrix, 0, lO*lO*
sizeof(
int));
1593 int rowCount, colCount;
1597 for(rowCount = 0; rowCount < lO; rowCount++)
1599 for(colCount = 0; colCount < lV; colCount++)
1601 tm = posMat[rowCount][colCount];
1602 adjMatrix[rowCount][tm] = adjMatrix[rowCount][tm] + 1;
1613 tt=(
char**)
omAlloc(
sizeof(
char*));
1619 tt=(
char**)
omalloc(lV*
sizeof(
char*));
1620 for(is = 0; is < lV; is++)
1622 tt[is] = (
char*)
omAlloc(7*
sizeof(
char));
1623 sprintf (tt[is],
"t%d", is+1);
1630 char** xx = (
char**)
omAlloc(
sizeof(
char*));
1643 for(rowCount = 0; rowCount < lO; rowCount++)
1645 for(colCount = 0; colCount < lO; colCount++)
1647 if(adjMatrix[rowCount][colCount] != 0)
1649 MATELEM(mR, rowCount + 1, colCount + 1) =
p_ISet(adjMatrix[rowCount][colCount],
R);
1657 for(rowCount = 0; rowCount < lO; rowCount++)
1659 for(colCount = 0; colCount < lV; colCount++)
1664 MATELEM(mR, rowCount +1, posMat[rowCount][colCount]+1)=
p_Add_q(rc,
MATELEM(mR, rowCount +1, posMat[rowCount][colCount]+1),
R);
1669 for(rowCount = 0; rowCount < lO; rowCount++)
1671 if(C[rowCount] != 0)
1685 PrintS(
"\nlinear system:\n");
1688 for(rowCount = 0; rowCount < lO; rowCount++)
1690 Print(
"H(%d) = ", rowCount+1);
1691 for(colCount = 0; colCount < lV; colCount++)
1696 Print(
"H(%d) + ", posMat[rowCount][colCount] + 1);
1698 Print(
" %d\n", C[rowCount] );
1700 PrintS(
"where H(1) represents the series corresp. to input ideal\n");
1701 PrintS(
"and i^th summand in the rhs of an eqn. is according\n");
1702 PrintS(
"to the right colon map corresp. to the i^th variable\n");
1706 for(rowCount = 0; rowCount < lO; rowCount++)
1708 Print(
"H(%d) = ", rowCount+1);
1709 for(colCount = 0; colCount < lV; colCount++)
1714 Print(
"H(%d) + ", posMat[rowCount][colCount] + 1);
1716 Print(
" %d\n", C[rowCount] );
1718 PrintS(
"where H(1) represents the series corresp. to input ideal\n");
1750 Print(
"Hilbert series:");
1759 for(is = lV-1; is >= 0; is--)
1808 for(
int i=src->N;
i>0;
i--)
1825#if defined(__APPLE__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(__CYGWIN__)
1826static int compare_rp(
void *arg,
const void *pp1,
const void *pp2)
1828static int compare_rp(
const void *pp1,
const void *pp2,
void* arg)
1831 poly p1=*(poly*)pp1;
1832 poly p2=*(poly*)pp2;
1834 for(
int i=src->N;
i>0;
i--)
1838 if(e1<e2)
return -1;
1846 poly p1=*(poly*)pp1;
1847 poly p2=*(poly*)pp2;
1852 if(e1<e2)
return -1;
1861 while(id->m[
k]==
NULL)
k--;
1863 long *sev=(
long*)
omAlloc0(kk*
sizeof(
long));
1864 BOOLEAN only_lm=r->cf->has_simple_Alloc;
1867 for (
int i=
k;
i>=0;
i--)
1875 for (
int i=
k;
i>=0;
i--)
1882 for (
int i=
k;
i>=0;
i--)
1889 for (
int i=0;
i<
k;
i++)
1895 for (
int j=
i+1;
j<=
k;
j++)
1915 for (
int i=0;
i<
k;
i++)
1921 for (
int j=
i+1;
j<=
k;
j++)
1954 int*
exp=(
int*)
omAlloc((src->N+1)*
sizeof(int));
1960 for(
int j=src->N;
j>0;
j--)
1962 int w=(*wdegree)[
j-1];
1965 WerrorS(
"weights must be positive");
1982 int *exp_q=(
int*)
omAlloc((src->N+1)*
sizeof(int));
1984 for (
int i=1;
i<r;
i++)
1987 for(
int ii=src->N;ii>0;ii--)
1990 for(
int ii=0;ii<
i;ii++)
1998 for (
int ii=
IDELEMS(J)-1;ii>=0;ii--)
2062 #if defined(__APPLE__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(__CYGWIN__)
2063 qsort_r(AA->m,
IDELEMS(AA),
sizeof(poly),src,compare_rp);
2065 qsort_r(AA->m,
IDELEMS(AA),
sizeof(poly),compare_rp,src);
2084 for(
int i=1;
i<=rk;
i++)
2088 for(
int ii=0;ii<
IDELEMS(AA);ii++)
2090 if (AA->m[ii]!=
NULL)
2118 int sh=(*shifts)[
i-1]-
m;
2145 if((
l==0)||(
l<=-INT_MAX)||(
l>INT_MAX))
2149 else (*ss)[
i]=(int)
l;
2176 while(
prod<(1<<15) && (a>1))
2182 if (a==1)
b=(1<<15);
2220 int w_max=0,w_min=0;
2223 w_max=module_w->
max_in();
2224 w_min=module_w->
min_in();
2226 for(
int c=1;c<=
A->rank;c++)
2234 if ((module_w==
NULL) || ((*module_w)[c-1]==0)) tmp=
ivAdd(
res,res_c);
2243 (*res)[
res->length()-1]=w_min;
2250 if(modulweight==
NULL)
return 0;
2251 return modulweight->
min_in();
2261 x = (*wdegree)[
i-1];
2277 memcpy(pon, pol,
l *
sizeof(
int64));
2280 for (
i =
x;
i <
l;
i++)
2282 #ifndef __SIZEOF_INT128__
2290 __int128 t2=pol[
i -
x];
2292 if ((t>=LONG_MIN)&&(t<=LONG_MAX)) pon[
i]=t;
2296 for (
i =
l;
i < ln;
i++)
2298 #ifndef __SIZEOF_INT128__
2303 __int128 t= -pol[
i -
x];
2304 if ((t>=LONG_MIN)&&(t<=LONG_MAX)) pon[
i]=t;
2311 for (
i =
l;
i <
x;
i++)
2313 for (
i =
x;
i < ln;
i++)
2314 pon[
i] = -pol[
i -
x];
2321 int l = lp,
x,
i,
j;
2325 for (
i = Nv;
i>0;
i--)
2327 x = pure[var[
i + 1]];
2333 for (
i = 0;
i <
l;
i++)
2335 #ifndef __SIZEOF_INT128__
2345 if ((t>=LONG_MIN)&&(t<=LONG_MAX)) pl[
i+
j]=t;
2353 for (
i = 0;
i <
l;
i++)
2355 #ifndef __SIZEOF_INT128__
2365 if ((t>=LONG_MIN)&&(t<=LONG_MAX)) pl[
i+
j]=t;
2380 for (
i = Nvar;
i>0;
i--)
2383 for (
j = 0;
j < Nstc;
j++)
2395 WerrorS(
"internal arrays too big");
2407 for (
x =
Ql[
j];
x < z;
x++)
2417 int Nvar,
int64 *pol,
int Lpol)
2419 int iv = Nvar -1, ln, a, a0, a1,
b,
i;
2432 hStepS(sn, Nstc, var, Nvar, &a, &
x);
2438 x = pure[var[Nvar]];
2456 hStepS(sn, Nstc, var, Nvar, &a, &
x);
2457 hElimS(sn, &
b, a0, a, var, iv);
2459 hPure(sn, a0, &a1, var, iv, pn, &
i);
2470 x = pure[var[Nvar]];
2487 int i,
j,
k,
l, ii, mw;
2526 if (modulweight !=
NULL)
2527 j = (*modulweight)[mc-1]-mw;
2562 while ((
i > 0) && ((*Qpol)[
i - 1] == 0))
2570 for (ii=0; ii<
k; ii++)
2571 (*work)[ii] = (*hseries1)[ii];
2572 if (hseries1 !=
NULL)
2579 (*hseries1)[
i +
j - 1] += (*Qpol)[
i - 1];
2598 while ((*hseries1)[
l-2]==0)
l--;
2602 for (ii=
l-2; ii>=0; ii--)
2603 (*work)[ii] = (*hseries1)[ii];
2607 (*hseries1)[
l-1] = mw;
2662 for(
int d=0;d<
b->rows()-1;d++)
2734 for(
int i=0;
i<h1->cols();
i++)
2743 hseries2 = hseries1;
2748 if ((
l == 1) &&(
mu == 0))
#define BIMATELEM(M, I, J)
const CanonicalForm CFMap CFMap & N
CanonicalForm convSingPFactoryP(poly p, const ring r)
poly convFactoryPSingP(const CanonicalForm &f, const ring r)
int compare(const intvec *o) const
char * ivString(int not_mat=1, int spaces=0, int dim=2) const
Coefficient rings, fields and other domains suitable for Singular polynomials.
static FORCE_INLINE number n_Mult(number a, number b, const coeffs r)
return the product of 'a' and 'b', i.e., a*b
static FORCE_INLINE number n_Param(const int iParameter, const coeffs r)
return the (iParameter^th) parameter as a NEW number NOTE: parameter numbering: 1....
static FORCE_INLINE long n_Int(number &n, const coeffs r)
conversion of n to an int; 0 if not possible in Z/pZ: the representing int lying in (-p/2 ....
@ n_Q
rational (GMP) numbers
@ n_transExt
used for all transcendental extensions, i.e., the top-most extension in an extension tower is transce...
static FORCE_INLINE nMapFunc n_SetMap(const coeffs src, const coeffs dst)
set the mapping function pointers for translating numbers from src to dst
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
const CanonicalForm int s
const CanonicalForm int const CFList const Variable & y
void FACTORY_PUBLIC prune(Variable &alpha)
static int max(int a, int b)
VAR void(* WerrorS_callback)(const char *s)
void WerrorS(const char *s)
This file is work in progress and currently not part of the official Singular.
void scPrintDegree(int co, int mu)
static void idInsertMonomial(ideal I, poly p)
static int comapreMonoIdBases_IG_Case(ideal J, int JCount, ideal Ob, int ObCount)
poly hBIV2Poly(bigintmat *b, const ring Qt, const coeffs biv_cf)
static void rouneslice(ideal I, ideal S, poly q, poly x, int &prune, int &moreprune, int &steps, int &NNN, mpz_ptr &hilbertcoef, int *&hilbpower)
poly hFirstSeries0m(ideal A, ideal Q, intvec *wdegree, intvec *shifts, const ring src, const ring Qt)
static poly hilbert_series(ideal A, const ring src, const intvec *wdegree, const ring Qt)
poly hFirstSeries0p(ideal A, ideal Q, intvec *wdegree, const ring src, const ring Qt)
static poly SqFree(ideal I)
static void idAddMon(ideal I, ideal p)
static int comapreMonoIdBases(ideal J, ideal Ob)
static void TwordMap(poly p, poly w, int lV, int d, ideal Jwi, bool &flag)
static poly ChooseP(ideal I)
static poly deleteInMon(poly w, int i, int lV, const ring r)
intvec * hSecondSeries(intvec *hseries1)
static void hLastHilb(scmon pure, int Nv, varset var, int64 *pol, int lp)
static BOOLEAN isModule(ideal A, const ring src)
static int CountOnIdUptoTruncationIndex(ideal I, int tr)
static poly ChoosePJL(ideal I)
static int monCompare(const void *m, const void *n)
static void hHilbEst(scfmon stc, int Nstc, varset var, int Nvar)
static int positionInOrbitTruncationCase(ideal I, poly w, std::vector< ideal > idorb, std::vector< poly > polist, int, int trunDegHs)
static intvec * hSeries(ideal S, intvec *modulweight, intvec *wdegree, ideal Q)
static poly LCMmon(ideal I)
void HilbertSeries_OrbitData(ideal S, int lV, bool IG_CASE, bool mgrad, bool odp, int trunDegHs)
static ideal colonIdeal(ideal S, poly w, int lV, ideal Jwi, int trunDegHs)
intvec * hFirstSeries(ideal A, intvec *module_w, ideal Q, intvec *wdegree)
static int hMinModulweight(intvec *modulweight)
static poly shiftInMon(poly p, int i, int lV, const ring r)
static ideal getModuleComp(ideal A, int c, const ring src)
poly hFirst2Second(poly h, const ring Qt, int &co)
intvec * hFirstSeries0(ideal A, ideal Q, intvec *wdegree, const ring src, const ring Qt)
static void hPrintHilb(poly hseries, const ring Qt, intvec *modul_weight)
static poly ChoosePVar(ideal I)
static int positionInOrbit_FG_Case(ideal I, poly, std::vector< ideal > idorb, std::vector< poly >, int, int)
static void sortMonoIdeal_pCompare(ideal I)
bigintmat * hPoly2BIV(poly h, const ring Qt, const coeffs biv_cf)
static ideal SortByDeg(ideal I)
static bool IsIn(poly p, ideal I)
static void eulerchar(ideal I, int variables, mpz_ptr ec)
ideal RightColonOperation(ideal S, poly w, int lV)
static void hHilbStep(scmon pure, scfmon stc, int Nstc, varset var, int Nvar, int64 *pol, int Lpol)
bigintmat * hFirstSeries0b(ideal I, ideal Q, intvec *wdegree, intvec *shifts, const ring src, const coeffs biv_cf)
static void hWDegree(intvec *wdegree)
static BOOLEAN p_Div_hi(poly p, const int *exp_q, const ring src)
bigintmat * hSecondSeries0b(ideal I, ideal Q, intvec *wdegree, intvec *shifts, const ring src, const coeffs biv_cf)
static int positionInOrbit_IG_Case(ideal I, poly w, std::vector< ideal > idorb, std::vector< poly > polist, int trInd, int)
void hDegreeSeries(intvec *s1, intvec *s2, int *co, int *mu)
static poly SearchP(ideal I)
searches for a monomial of degree d>=2 and divides it by a variable (result monomial of deg d-1)
static int64 * hAddHilb(int Nv, int x, int64 *pol, int *lp)
static ideal minimalMonomialGenSet(ideal I)
intvec * hFirstSeries1(ideal S, intvec *modulweight, ideal Q, intvec *wdegree)
ideal idQuotMon(ideal Iorig, ideal p)
static void SortByDeg_p(ideal I, poly p)
void scDegree(ideal S, intvec *modulweight, ideal Q)
static bool JustVar(ideal I)
void hLookSeries(ideal S, intvec *modulweight, ideal Q, intvec *wdegree)
static void id_DelDiv_hi(ideal id, BOOLEAN *bad, const ring r)
static int compare_rp_currRing(const void *pp1, const void *pp2)
void hComp(scfmon exist, int Nexist, int ak, scfmon stc, int *Nstc)
void hLex2S(scfmon rad, int e1, int a2, int e2, varset var, int Nvar, scfmon w)
void hKill(monf xmem, int Nvar)
void hElimS(scfmon stc, int *e1, int a2, int e2, varset var, int Nvar)
void hLexS(scfmon stc, int Nstc, varset var, int Nvar)
void hDelete(scfmon ev, int ev_length)
scfmon hGetmem(int lm, scfmon old, monp monmem)
void hPure(scfmon stc, int a, int *Nstc, varset var, int Nvar, scmon pure, int *Npure)
void hSupp(scfmon stc, int Nstc, varset var, int *Nvar)
void hStepS(scfmon stc, int Nstc, varset var, int Nvar, int *a, int *x)
void hStaircase(scfmon stc, int *Nstc, varset var, int Nvar)
void hOrdSupp(scfmon stc, int Nstc, varset var, int Nvar)
scfmon hInit(ideal S, ideal Q, int *Nexist)
#define idDelete(H)
delete an ideal
BOOLEAN idInsertPoly(ideal h1, poly h2)
insert h2 into h1 (if h2 is not the zero polynomial) return TRUE iff h2 was indeed inserted
ideal id_Copy(ideal h1, const ring r)
copy an ideal
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
intvec * ivAddShift(intvec *a, intvec *b, int s)
intvec * ivAdd(intvec *a, intvec *b)
static void WerrorS_dummy(const char *)
bool unitMatrix(const int n, matrix &unitMat, const ring R)
Creates a new matrix which is the (nxn) unit matrix, and returns true in case of success.
void luDecomp(const matrix aMat, matrix &pMat, matrix &lMat, matrix &uMat, const ring R)
LU-decomposition of a given (m x n)-matrix.
bool luSolveViaLUDecomp(const matrix pMat, const matrix lMat, const matrix uMat, const matrix bVec, matrix &xVec, matrix &H)
Solves the linear system A * x = b, where A is an (m x n)-matrix which is given by its LU-decompositi...
void mp_Delete(matrix *a, const ring r)
static matrix mu(matrix A, const ring R)
matrix mp_Sub(matrix a, matrix b, const ring R)
matrix mpNew(int r, int c)
create a r x c zero-matrix
#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
gmp_float exp(const gmp_float &a)
The main handler for Singular numbers which are suitable for Singular polynomials.
#define omFreeSize(addr, size)
#define omRealloc(addr, size)
poly p_ISet(long i, const ring r)
returns the poly representing the integer i
poly p_Power(poly p, int i, const ring r)
unsigned long p_GetShortExpVector0(const poly p, const ring r)
poly p_MDivide(poly a, poly b, const ring r)
int p_Compare(const poly a, const poly b, const ring R)
unsigned long p_GetShortExpVector(const poly p, const ring r)
void pEnlargeSet(poly **p, int l, int increment)
unsigned long p_GetShortExpVector1(const poly p, 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)
#define p_LmEqual(p1, p2, r)
static void p_SetExpV(poly p, int *ev, const ring r)
static poly pp_Mult_mm(poly p, poly m, const 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 unsigned long p_SetComp(poly p, unsigned long c, ring r)
static void p_Setm(poly p, const ring r)
static number p_SetCoeff(poly p, number n, ring r)
static poly p_Head(const poly p, const ring r)
copy the (leading) term of p
static BOOLEAN p_LmShortDivisibleBy(poly a, unsigned long sev_a, poly b, unsigned long not_sev_b, 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 BOOLEAN p_IsOne(const poly p, const ring R)
either poly(1) or gen(k)?!
static poly p_New(const ring, omBin bin)
static BOOLEAN p_LmDivisibleBy(poly a, poly b, const ring r)
static BOOLEAN p_DivisibleBy(poly a, poly b, const ring r)
static void p_Delete(poly *p, const ring r)
static void p_GetExpV(poly p, int *ev, const ring r)
void p_Write0(poly p, ring lmRing, ring tailRing)
static void p_LmFree(poly p, ring)
static poly p_Init(const ring r, omBin bin)
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 ...
#define pLmDivisibleBy(a, b)
like pDivisibleBy, except that it is assumed that a!=NULL, b!=NULL
static void pLmFree(poly p)
frees the space of the monomial m, assumes m != NULL coef is not freed, m is not advanced
#define pCopy(p)
return a copy of the poly
void StringSetS(const char *st)
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 rDefault(const coeffs cf, int N, char **n, int ord_size, rRingOrder_t *ord, int *block0, int *block1, int **wvhdl, unsigned long bitmask)
static short rVar(const ring r)
#define rVar(r) (r->N)
int status int void size_t count
ideal idInit(int idsize, int rank)
initialise an ideal / module
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
int idSkipZeroes0(ideal ide)
void id_Delete0(ideal *h, ring r)
ideal id_Head(ideal h, const ring r)
returns the ideals of initial terms
void id_DelDiv(ideal id, const ring r)
delete id[j], if LT(j) == coeff*mon*LT(i) and vice versa, i.e., delete id[i], if LT(i) == coeff*mon*L...
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...
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 (...
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
struct for passing initialization parameters to naInitChar