 |
My Project
debian-1:4.1.1-p2+ds-4
|
Go to the source code of this file.
|
static int | hMinModulweight (intvec *modulweight) |
|
static void | hHilbEst (scfmon stc, int Nstc, varset var, int Nvar) |
|
static int * | hAddHilb (int Nv, int x, int *pol, int *lp) |
|
static void | hLastHilb (scmon pure, int Nv, varset var, int *pol, int lp) |
|
static void | hHilbStep (scmon pure, scfmon stc, int Nstc, varset var, int Nvar, int *pol, int Lpol) |
|
static void | hWDegree (intvec *wdegree) |
|
static void | SortByDeg_p (ideal I, poly p) |
| !!!!!!!!!!!!!!!!!!!! Just for Monomial Ideals !!!!!!!!!!!!!!!!!!!!!!!!!!!! More...
|
|
static ideal | SortByDeg (ideal I) |
|
ideal | idQuotMon (ideal Iorig, ideal p) |
|
static void | idAddMon (ideal I, ideal p) |
|
static poly | ChoosePVar (ideal I) |
|
static poly | ChoosePJL (ideal I) |
|
static poly | ChooseP (ideal I) |
|
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) More...
|
|
static bool | JustVar (ideal I) |
|
static void | eulerchar (ideal I, int variables, mpz_ptr ec) |
|
static poly | SqFree (ideal I) |
|
static bool | IsIn (poly p, ideal I) |
|
static poly | LCMmon (ideal I) |
|
void | rouneslice (ideal I, ideal S, poly q, poly x, int &prune, int &moreprune, int &steps, int &NNN, mpz_ptr &hilbertcoef, int *&hilbpower) |
|
void | slicehilb (ideal I) |
|
static intvec * | hSeries (ideal S, intvec *modulweight, int, intvec *wdegree, ideal Q, ring tailRing) |
|
intvec * | hHstdSeries (ideal S, intvec *modulweight, intvec *wdegree, ideal Q, ring tailRing) |
|
intvec * | hFirstSeries (ideal S, intvec *modulweight, ideal Q, intvec *wdegree, ring tailRing) |
|
intvec * | hSecondSeries (intvec *hseries1) |
|
void | hDegreeSeries (intvec *s1, intvec *s2, int *co, int *mu) |
|
static void | hPrintHilb (intvec *hseries) |
|
void | hLookSeries (ideal S, intvec *modulweight, ideal Q, intvec *wdegree, ring tailRing) |
|
static void | idInsertMonomial (ideal I, poly p) |
|
static int | comapreMonoIdBases (ideal J, ideal Ob) |
|
static int | CountOnIdUptoTruncationIndex (ideal I, int tr) |
|
static int | comapreMonoIdBases_IG_Case (ideal J, int JCount, ideal Ob, int ObCount) |
|
static int | positionInOrbit_IG_Case (ideal I, poly w, std::vector< ideal > idorb, std::vector< poly > polist, int trInd, int trunDegHs) |
|
static int | positionInOrbit_FG_Case (ideal I, poly, std::vector< ideal > idorb, std::vector< poly >, int, int) |
|
static int | positionInOrbitTruncationCase (ideal I, poly w, std::vector< ideal > idorb, std::vector< poly > polist, int, int trunDegHs) |
|
static int | monCompare (const void *m, const void *n) |
|
void | sortMonoIdeal_pCompare (ideal I) |
|
static ideal | minimalMonomialGenSet (ideal I) |
|
static poly | shiftInMon (poly p, int i, int lV, const ring r) |
|
static poly | deleteInMon (poly w, int i, int lV, const ring r) |
|
static void | TwordMap (poly p, poly w, int lV, int d, ideal Jwi, bool &flag) |
|
static ideal | colonIdeal (ideal S, poly w, int lV, ideal Jwi, int trunDegHs) |
|
void | HilbertSeries_OrbitData (ideal S, int lV, bool IG_CASE, bool mgrad, bool odp, int trunDegHs) |
|
ideal | RightColonOperation (ideal S, poly w, int lV) |
|
◆ omsai
◆ ChooseP()
static poly ChooseP |
( |
ideal |
I | ) |
|
|
static |
◆ ChoosePJL()
static poly ChoosePJL |
( |
ideal |
I | ) |
|
|
static |
◆ ChoosePVar()
static poly ChoosePVar |
( |
ideal |
I | ) |
|
|
static |
◆ colonIdeal()
static ideal colonIdeal |
( |
ideal |
S, |
|
|
poly |
w, |
|
|
int |
lV, |
|
|
ideal |
Jwi, |
|
|
int |
trunDegHs |
|
) |
| |
|
static |
Definition at line 1933 of file hilb.cc.
1949 if(trunDegHs !=0 && d >= trunDegHs)
1956 for(
i = 0;
i < SCount;
i++)
◆ comapreMonoIdBases()
static int comapreMonoIdBases |
( |
ideal |
J, |
|
|
ideal |
Ob |
|
) |
| |
|
static |
Definition at line 1477 of file hilb.cc.
1494 if(JCount != ObCount)
1499 for(
i = 0;
i < JCount;
i++)
◆ comapreMonoIdBases_IG_Case()
static int comapreMonoIdBases_IG_Case |
( |
ideal |
J, |
|
|
int |
JCount, |
|
|
ideal |
Ob, |
|
|
int |
ObCount |
|
) |
| |
|
static |
Definition at line 1535 of file hilb.cc.
1550 if(JCount != ObCount)
1560 for(
i = 0;
i< JCount;
i++)
◆ CountOnIdUptoTruncationIndex()
static int CountOnIdUptoTruncationIndex |
( |
ideal |
I, |
|
|
int |
tr |
|
) |
| |
|
static |
◆ deleteInMon()
static poly deleteInMon |
( |
poly |
w, |
|
|
int |
i, |
|
|
int |
lV, |
|
|
const ring |
r |
|
) |
| |
|
static |
Definition at line 1838 of file hilb.cc.
1848 int *e = (
int *)
omAlloc((r->N+1)*
sizeof(int));
1849 int *
s=(
int *)
omAlloc0((r->N+1)*
sizeof(int));
1858 for(
j = (cnt+1);
j < (r->N+1);
j++)
◆ eulerchar()
static void eulerchar |
( |
ideal |
I, |
|
|
int |
variables, |
|
|
mpz_ptr |
ec |
|
) |
| |
|
static |
Definition at line 838 of file hilb.cc.
849 mpz_set_ui(dummy, 1);
851 mpz_set_si(dummy, -1);
852 mpz_add(ec, ec, dummy);
865 int i,howmanyvarinp = 0;
◆ hAddHilb()
static int* hAddHilb |
( |
int |
Nv, |
|
|
int |
x, |
|
|
int * |
pol, |
|
|
int * |
lp |
|
) |
| |
|
static |
Definition at line 105 of file hilb.cc.
111 memcpy(pon, pol,
l *
sizeof(
int));
114 for (
i =
x;
i <
l;
i++)
118 if ((t>=INT_MIN)&&(t<=INT_MAX)) pon[
i]=t;
121 for (
i =
l;
i < ln;
i++)
124 if ((t>=INT_MIN)&&(t<=INT_MAX)) pon[
i]=t;
130 for (
i =
l;
i <
x;
i++)
132 for (
i =
x;
i < ln;
i++)
133 pon[
i] = -pol[
i -
x];
◆ hDegreeSeries()
void hDegreeSeries |
( |
intvec * |
s1, |
|
|
intvec * |
s2, |
|
|
int * |
co, |
|
|
int * |
mu |
|
) |
| |
◆ hFirstSeries()
intvec* hFirstSeries |
( |
ideal |
S, |
|
|
intvec * |
modulweight, |
|
|
ideal |
Q, |
|
|
intvec * |
wdegree, |
|
|
ring |
tailRing |
|
) |
| |
◆ hHilbEst()
static void hHilbEst |
( |
scfmon |
stc, |
|
|
int |
Nstc, |
|
|
varset |
var, |
|
|
int |
Nvar |
|
) |
| |
|
static |
Definition at line 64 of file hilb.cc.
69 for (
i = Nvar;
i>0;
i--)
72 for (
j = 0;
j < Nstc;
j++)
84 WerrorS(
"internal arrays too big");
87 p = (
int *)
omAlloc((
unsigned long)z *
sizeof(int));
96 for (
x =
Ql[
j];
x < z;
x++)
◆ hHilbStep()
static void hHilbStep |
( |
scmon |
pure, |
|
|
scfmon |
stc, |
|
|
int |
Nstc, |
|
|
varset |
var, |
|
|
int |
Nvar, |
|
|
int * |
pol, |
|
|
int |
Lpol |
|
) |
| |
|
static |
Definition at line 178 of file hilb.cc.
181 int iv = Nvar -1, ln, a, a0, a1,
b,
i;
194 hStepS(sn, Nstc, var, Nvar, &a, &
x);
218 hStepS(sn, Nstc, var, Nvar, &a, &
x);
219 hElimS(sn, &
b, a0, a, var, iv);
221 hPure(sn, a0, &a1, var, iv, pn, &
i);
◆ hHstdSeries()
intvec* hHstdSeries |
( |
ideal |
S, |
|
|
intvec * |
modulweight, |
|
|
intvec * |
wdegree, |
|
|
ideal |
Q, |
|
|
ring |
tailRing |
|
) |
| |
Definition at line 1329 of file hilb.cc.
1333 return hSeries(S, modulweight, 0, wdegree,
Q, tailRing);
◆ HilbertSeries_OrbitData()
void HilbertSeries_OrbitData |
( |
ideal |
S, |
|
|
int |
lV, |
|
|
bool |
IG_CASE, |
|
|
bool |
mgrad, |
|
|
bool |
odp, |
|
|
int |
trunDegHs |
|
) |
| |
Definition at line 1968 of file hilb.cc.
1985 PrintS(
"Hilbert Series:\n 0\n");
1988 int (*POS)(ideal, poly, std::vector<ideal>, std::vector<poly>, int, int);
1991 Print(
"\nTruncation degree = %d\n",trunDegHs);
2000 WerrorS(
"wrong input: it is not an infinitely gen. case");
2009 std::vector<ideal > idorb;
2010 std::vector< poly > polist;
2012 ideal orb_init =
idInit(1, 1);
2013 idorb.push_back(orb_init);
2017 std::vector< std::vector<int> > posMat;
2018 std::vector<int> posRow(lV,0);
2027 while(lpcnt < idorb.size())
2031 if(lpcnt >= 1 &&
idIs0(idorb[lpcnt]) ==
FALSE)
2048 for(is = 1; is <= lV; is++)
2069 ps = (*POS)(Jwi, wi, idorb, polist, trInd, trunDegHs);
2073 posRow[is-1] = idorb.size();
2075 idorb.push_back(Jwi);
2076 polist.push_back(wi);
2085 posMat.push_back(posRow);
2086 posRow.resize(lV,0);
2091 Print(
"\nlength of the Orbit = %d", lO);
2096 Print(
"words description of the Orbit: \n");
2097 for(is = 0; is < lO; is++)
2103 PrintS(
"\nmaximal degree, #(sum_j R(w,w_j))");
2105 for(is = 0; is < lO; is++)
2107 if(
idIs0(idorb[is]))
2118 for(is = idorb.size()-1; is >= 0; is--)
2122 for(is = polist.size()-1; is >= 0; is--)
2130 int adjMatrix[lO][lO];
2131 memset(adjMatrix, 0, lO*lO*
sizeof(
int));
2132 int rowCount, colCount;
2136 for(rowCount = 0; rowCount < lO; rowCount++)
2138 for(colCount = 0; colCount < lV; colCount++)
2140 tm = posMat[rowCount][colCount];
2141 adjMatrix[rowCount][tm] = adjMatrix[rowCount][tm] + 1;
2152 tt=(
char**)
omAlloc(
sizeof(
char*));
2158 tt=(
char**)
omalloc(lV*
sizeof(
char*));
2159 for(is = 0; is < lV; is++)
2161 tt[is] = (
char*)
omAlloc(7*
sizeof(
char));
2162 sprintf (tt[is],
"t%d", is+1);
2169 char** xx = (
char**)
omAlloc(
sizeof(
char*));
2182 for(rowCount = 0; rowCount < lO; rowCount++)
2184 for(colCount = 0; colCount < lO; colCount++)
2186 if(adjMatrix[rowCount][colCount] != 0)
2188 MATELEM(mR, rowCount + 1, colCount + 1) =
p_ISet(adjMatrix[rowCount][colCount],
R);
2196 for(rowCount = 0; rowCount < lO; rowCount++)
2198 for(colCount = 0; colCount < lV; colCount++)
2203 MATELEM(mR, rowCount +1, posMat[rowCount][colCount]+1)=
p_Add_q(rc,
MATELEM(mR, rowCount +1, posMat[rowCount][colCount]+1),
R);
2208 for(rowCount = 0; rowCount < lO; rowCount++)
2210 if(C[rowCount] != 0)
2224 PrintS(
"\nlinear system:\n");
2227 for(rowCount = 0; rowCount < lO; rowCount++)
2229 Print(
"H(%d) = ", rowCount+1);
2230 for(colCount = 0; colCount < lV; colCount++)
2235 Print(
"H(%d) + ", posMat[rowCount][colCount] + 1);
2237 Print(
" %d\n", C[rowCount] );
2239 PrintS(
"where H(1) represents the series corresp. to input ideal\n");
2240 PrintS(
"and i^th summand in the rhs of an eqn. is according\n");
2241 PrintS(
"to the right colon map corresp. to the i^th variable\n");
2245 for(rowCount = 0; rowCount < lO; rowCount++)
2247 Print(
"H(%d) = ", rowCount+1);
2248 for(colCount = 0; colCount < lV; colCount++)
2253 Print(
"H(%d) + ", posMat[rowCount][colCount] + 1);
2255 Print(
" %d\n", C[rowCount] );
2257 PrintS(
"where H(1) represents the series corresp. to input ideal\n");
2289 Print(
"Hilbert series:");
2298 for(is = lV-1; is >= 0; is--)
◆ hLastHilb()
static void hLastHilb |
( |
scmon |
pure, |
|
|
int |
Nv, |
|
|
varset |
var, |
|
|
int * |
pol, |
|
|
int |
lp |
|
) |
| |
|
static |
Definition at line 138 of file hilb.cc.
144 for (
i = Nv;
i>0;
i--)
146 x = pure[var[
i + 1]];
152 for (
i = 0;
i <
l;
i++)
157 if ((t>=INT_MIN)&&(t<=INT_MAX)) pl[
i+
j]=t;
164 for (
i = 0;
i <
l;
i++)
169 if ((t>=INT_MIN)&&(t<=INT_MAX)) pl[
i+
j]=t;
◆ hLookSeries()
void hLookSeries |
( |
ideal |
S, |
|
|
intvec * |
modulweight, |
|
|
ideal |
Q, |
|
|
intvec * |
wdegree, |
|
|
ring |
tailRing |
|
) |
| |
Definition at line 1419 of file hilb.cc.
1428 const int l = hseries1->
length()-1;
1437 if ((
l == 1) &&(
mu == 0))
◆ hMinModulweight()
static int hMinModulweight |
( |
intvec * |
modulweight | ) |
|
|
static |
Definition at line 50 of file hilb.cc.
54 if(modulweight==
NULL)
return 0;
56 for(
i=modulweight->
rows()-1;
i!=0;
i--)
◆ hPrintHilb()
static void hPrintHilb |
( |
intvec * |
hseries | ) |
|
|
static |
Definition at line 1399 of file hilb.cc.
1402 if (hseries ==
NULL)
1406 for (
i = 0;
i <
l;
i++)
◆ hSecondSeries()
Definition at line 1346 of file hilb.cc.
1351 if (hseries1 ==
NULL)
1353 work =
new intvec(hseries1);
1356 for (
i =
k-1;
i >= 0;
i--)
1360 if ((
s != 0) || (
k == 1))
1365 for (
i =
k-1;
i >= 0;
i--)
1374 for (
i =
k-1;
i >= 0;
i--)
1375 (*hseries2)[
i] = (*work)[
i];
1376 (*hseries2)[
k] = (*work)[
l];
◆ hSeries()
static intvec* hSeries |
( |
ideal |
S, |
|
|
intvec * |
modulweight, |
|
|
int |
, |
|
|
intvec * |
wdegree, |
|
|
ideal |
Q, |
|
|
ring |
tailRing |
|
) |
| |
|
static |
Definition at line 1173 of file hilb.cc.
1181 int i,
j,
k,
l, ii, mw;
1192 if (wdegree ==
NULL)
1227 if (modulweight !=
NULL)
1228 j = (*modulweight)[mc-1]-mw;
1263 while ((
i > 0) && ((*Qpol)[
i - 1] == 0))
1271 for (ii=0; ii<
k; ii++)
1272 (*work)[ii] = (*hseries1)[ii];
1273 if (hseries1 !=
NULL)
1280 (*hseries1)[
i +
j - 1] += (*Qpol)[
i - 1];
1299 while ((*hseries1)[
l-2]==0)
l--;
1303 for (ii=
l-2; ii>=0; ii--)
1304 (*work)[ii] = (*hseries1)[ii];
1308 (*hseries1)[
l-1] = mw;
◆ hWDegree()
static void hWDegree |
( |
intvec * |
wdegree | ) |
|
|
static |
◆ idAddMon()
static void idAddMon |
( |
ideal |
I, |
|
|
ideal |
p |
|
) |
| |
|
static |
◆ idInsertMonomial()
static void idInsertMonomial |
( |
ideal |
I, |
|
|
poly |
p |
|
) |
| |
|
static |
◆ idQuotMon()
ideal idQuotMon |
( |
ideal |
Iorig, |
|
|
ideal |
p |
|
) |
| |
◆ IsIn()
static bool IsIn |
( |
poly |
p, |
|
|
ideal |
I |
|
) |
| |
|
static |
◆ JustVar()
static bool JustVar |
( |
ideal |
I | ) |
|
|
static |
◆ LCMmon()
static poly LCMmon |
( |
ideal |
I | ) |
|
|
static |
◆ minimalMonomialGenSet()
static ideal minimalMonomialGenSet |
( |
ideal |
I | ) |
|
|
static |
Definition at line 1773 of file hilb.cc.
1789 for(
k = ICount - 1;
k >=1;
k--)
1791 for(
i = 0;
i <
k;
i++)
◆ monCompare()
static int monCompare |
( |
const void * |
m, |
|
|
const void * |
n |
|
) |
| |
|
static |
◆ positionInOrbit_FG_Case()
static int positionInOrbit_FG_Case |
( |
ideal |
I, |
|
|
poly |
, |
|
|
std::vector< ideal > |
idorb, |
|
|
std::vector< poly > |
, |
|
|
int |
, |
|
|
int |
|
|
) |
| |
|
static |
Definition at line 1648 of file hilb.cc.
1660 int OrbCount = idorb.size();
1667 for(
i = 1;
i < OrbCount;
i++)
◆ positionInOrbit_IG_Case()
static int positionInOrbit_IG_Case |
( |
ideal |
I, |
|
|
poly |
w, |
|
|
std::vector< ideal > |
idorb, |
|
|
std::vector< poly > |
polist, |
|
|
int |
trInd, |
|
|
int |
trunDegHs |
|
) |
| |
|
static |
Definition at line 1570 of file hilb.cc.
1584 int orbCount = idorb.size();
1610 for(
i = 1;
i < orbCount;
i++)
1631 dtrp = trInd - degp;
◆ positionInOrbitTruncationCase()
static int positionInOrbitTruncationCase |
( |
ideal |
I, |
|
|
poly |
w, |
|
|
std::vector< ideal > |
idorb, |
|
|
std::vector< poly > |
polist, |
|
|
int |
, |
|
|
int |
trunDegHs |
|
) |
| |
|
static |
Definition at line 1679 of file hilb.cc.
1692 int OrbCount = idorb.size();
1693 int dtr=0;
int IwCount, ObCount;
1698 for(
i = 1;
i < OrbCount;
i++)
1721 for(
i = 1;
i < OrbCount;
i++)
1734 for(
i = 1;
i < OrbCount;
i++)
◆ RightColonOperation()
ideal RightColonOperation |
( |
ideal |
S, |
|
|
poly |
w, |
|
|
int |
lV |
|
) |
| |
◆ rouneslice()
void rouneslice |
( |
ideal |
I, |
|
|
ideal |
S, |
|
|
poly |
q, |
|
|
poly |
x, |
|
|
int & |
prune, |
|
|
int & |
moreprune, |
|
|
int & |
steps, |
|
|
int & |
NNN, |
|
|
mpz_ptr & |
hilbertcoef, |
|
|
int *& |
hilbpower |
|
) |
| |
Definition at line 975 of file hilb.cc.
1072 mpz_ptr ec_ptr = ec;
1077 hilbertcoef = (mpz_ptr)
omAlloc((NNN+1)*
sizeof(mpz_t));
1078 hilbpower = (
int*)
omAlloc((NNN+1)*
sizeof(int));
1079 mpz_init_set( &hilbertcoef[NNN], ec);
1091 mpz_add(&hilbertcoef[
i],&hilbertcoef[
i],ec_ptr);
1096 hilbertcoef = (mpz_ptr)
omRealloc(hilbertcoef, (NNN+1)*
sizeof(mpz_t));
1097 hilbpower = (
int*)
omRealloc(hilbpower, (NNN+1)*
sizeof(int));
1098 mpz_init(&hilbertcoef[NNN]);
1099 for(
j = NNN;
j>
i;
j--)
1101 mpz_set(&hilbertcoef[
j],&hilbertcoef[
j-1]);
1102 hilbpower[
j] = hilbpower[
j-1];
1104 mpz_set( &hilbertcoef[
i], ec);
1122 rouneslice(Ip, Sp, pq,
x,
prune, moreprune, steps, NNN, hilbertcoef,hilbpower);
◆ SearchP()
static poly SearchP |
( |
ideal |
I | ) |
|
|
static |
searches for a monomial of degree d>=2 and divides it by a variable (result monomial of deg d-1)
Definition at line 781 of file hilb.cc.
◆ shiftInMon()
static poly shiftInMon |
( |
poly |
p, |
|
|
int |
i, |
|
|
int |
lV, |
|
|
const ring |
r |
|
) |
| |
|
static |
Definition at line 1805 of file hilb.cc.
1813 poly smon =
p_One(r);
1817 int *e=(
int *)
omAlloc((r->N+1)*
sizeof(int));
1818 int *
s=(
int *)
omAlloc0((r->N+1)*
sizeof(int));
1821 for(
j = 1;
j <= cnt;
j++)
◆ slicehilb()
void slicehilb |
( |
ideal |
I | ) |
|
Definition at line 1131 of file hilb.cc.
1135 int steps = 0,
prune = 0, moreprune = 0;
1136 mpz_ptr hilbertcoef;
1152 rouneslice(I,S,q,X->m[0],
prune, moreprune, steps, NNN, hilbertcoef, hilbpower);
1158 printf(
"\n// %8d t^0",1);
1159 for(
i = 0;
i<NNN;
i++)
1161 if(mpz_sgn(&hilbertcoef[
i])!=0)
1163 gmp_printf(
"\n// %8Zd t^%d",&hilbertcoef[
i],hilbpower[
i]);
1167 omFreeSize(hilbertcoef, (NNN)*
sizeof(mpz_t));
◆ SortByDeg()
static ideal SortByDeg |
( |
ideal |
I | ) |
|
|
static |
◆ SortByDeg_p()
static void SortByDeg_p |
( |
ideal |
I, |
|
|
poly |
p |
|
) |
| |
|
static |
!!!!!!!!!!!!!!!!!!!! Just for Monomial Ideals !!!!!!!!!!!!!!!!!!!!!!!!!!!!
Definition at line 289 of file hilb.cc.
◆ sortMonoIdeal_pCompare()
void sortMonoIdeal_pCompare |
( |
ideal |
I | ) |
|
◆ SqFree()
static poly SqFree |
( |
ideal |
I | ) |
|
|
static |
Definition at line 881 of file hilb.cc.
885 poly notsqrfree =
NULL;
902 if(notsqrfree !=
NULL)
◆ TwordMap()
static void TwordMap |
( |
poly |
p, |
|
|
poly |
w, |
|
|
int |
lV, |
|
|
int |
d, |
|
|
ideal |
Jwi, |
|
|
bool & |
flag |
|
) |
| |
|
static |
Definition at line 1872 of file hilb.cc.
1889 for(
i = 0;
i <= d - 1;
i++)
◆ hLength
◆ Q0
◆ Ql
◆ Qpol
void hStaircase(scfmon stc, int *Nstc, varset var, int Nvar)
static int hMinModulweight(intvec *modulweight)
void hElimS(scfmon stc, int *e1, int a2, int e2, varset var, int Nvar)
static void hPrintHilb(intvec *hseries)
struct for passing initialization parameters to naInitChar
static int monCompare(const void *m, const void *n)
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent @Note: the integer VarOffset encodes:
#define idDelete(H)
delete an ideal
static void pLmFree(poly p)
frees the space of the monomial m, assumes m != NULL coef is not freed, m is not advanced
#define MATELEM(mat, i, j)
const CanonicalForm int const CFList const Variable & y
static ideal minimalMonomialGenSet(ideal I)
void rChangeCurrRing(ring r)
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)
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.
static void idInsertMonomial(ideal I, poly p)
void pEnlargeSet(poly **p, int l, int increment)
static void hWDegree(intvec *wdegree)
static int positionInOrbit_FG_Case(ideal I, poly, std::vector< ideal > idorb, std::vector< poly >, int, int)
static poly p_Head(poly p, const ring r)
static poly shiftInMon(poly p, int i, int lV, const ring r)
BOOLEAN idInsertPoly(ideal h1, poly h2)
insert h2 into h1 (if h2 is not the zero polynomial) return TRUE iff h2 was indeed inserted
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...
static poly ChooseP(ideal I)
static BOOLEAN p_IsOne(const poly p, const ring R)
either poly(1) or gen(k)?!
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
static poly pp_Mult_mm(poly p, poly m, const ring r)
static int comapreMonoIdBases(ideal J, ideal Ob)
scfmon hGetmem(int lm, scfmon old, monp monmem)
const CanonicalForm CFMap CFMap & N
static bool IsIn(poly p, ideal I)
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....
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
static BOOLEAN p_LmDivisibleBy(poly a, poly b, const ring r)
static void hHilbStep(scmon pure, scfmon stc, int Nstc, varset var, int Nvar, int *pol, int Lpol)
#define p_LmEqual(p1, p2, r)
static void idAddMon(ideal I, ideal 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
void mu(int **points, int sizePoints)
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 poly deleteInMon(poly w, int i, int lV, const ring r)
#define omRealloc(addr, size)
static void p_SetExpV(poly p, int *ev, const ring r)
static poly p_Copy(poly p, const ring r)
returns a copy of p
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
static short rVar(const ring r)
#define rVar(r) (r->N)
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
static intvec * hSeries(ideal S, intvec *modulweight, int, intvec *wdegree, ideal Q, ring tailRing)
static int CountOnIdUptoTruncationIndex(ideal I, int tr)
static ideal colonIdeal(ideal S, poly w, int lV, ideal Jwi, int trunDegHs)
void PrintS(const char *s)
#define omFreeSize(addr, size)
poly p_MDivide(poly a, poly b, const ring r)
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size
static void TwordMap(poly p, poly w, int lV, int d, ideal Jwi, bool &flag)
void hComp(scfmon exist, int Nexist, int ak, scfmon stc, int *Nstc)
void hKill(monf xmem, int Nvar)
void prune(Variable &alpha)
static int positionInOrbitTruncationCase(ideal I, poly w, std::vector< ideal > idorb, std::vector< poly > polist, int, int trunDegHs)
static ideal SortByDeg(ideal I)
static FORCE_INLINE number n_Mult(number a, number b, const coeffs r)
return the product of 'a' and 'b', i.e., a*b
int p_Compare(const poly a, const poly b, const ring R)
void hDelete(scfmon ev, int ev_length)
static BOOLEAN p_DivisibleBy(poly a, poly b, const ring r)
static poly ChoosePJL(ideal I)
static void p_GetExpV(poly p, int *ev, const ring r)
void rouneslice(ideal I, ideal S, poly q, poly x, int &prune, int &moreprune, int &steps, int &NNN, mpz_ptr &hilbertcoef, int *&hilbpower)
void mp_Delete(matrix *a, const ring r)
static poly SqFree(ideal I)
void hStepS(scfmon stc, int Nstc, varset var, int Nvar, int *a, int *x)
static void eulerchar(ideal I, int variables, mpz_ptr ec)
static void hLastHilb(scmon pure, int Nv, varset var, int *pol, int lp)
static bool JustVar(ideal I)
matrix mpNew(int r, int c)
create a r x c zero-matrix
used for all transcendental extensions, i.e., the top-most extension in an extension tower is transce...
intvec * hSecondSeries(intvec *hseries1)
gmp_float exp(const gmp_float &a)
void hPure(scfmon stc, int a, int *Nstc, varset var, int Nvar, scmon pure, int *Npure)
void hLex2S(scfmon rad, int e1, int a2, int e2, varset var, int Nvar, scfmon w)
static void p_Delete(poly *p, const ring r)
static poly p_Add_q(poly p, poly q, const ring r)
scfmon hInit(ideal S, ideal Q, int *Nexist, ring tailRing)
intvec * hFirstSeries(ideal S, intvec *modulweight, ideal Q, intvec *wdegree, ring tailRing)
static poly LCMmon(ideal I)
void StringSetS(const char *st)
void hOrdSupp(scfmon stc, int Nstc, varset var, int Nvar)
void sortMonoIdeal_pCompare(ideal I)
void hSupp(scfmon stc, int Nstc, varset var, int *Nvar)
static int comapreMonoIdBases_IG_Case(ideal J, int JCount, ideal Ob, int ObCount)
ideal idInit(int idsize, int rank)
initialise an ideal / module
static void hHilbEst(scfmon stc, int Nstc, varset var, int Nvar)
static number p_SetCoeff(poly p, number n, ring r)
#define id_TestTail(A, lR, tR)
static poly ChoosePVar(ideal I)
static void SortByDeg_p(ideal I, poly p)
!!!!!!!!!!!!!!!!!!!! Just for Monomial Ideals !!!!!!!!!!!!!!!!!!!!!!!!!!!!
void WerrorS(const char *s)
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
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...
static void p_Setm(poly p, const ring r)
static int positionInOrbit_IG_Case(ideal I, poly w, std::vector< ideal > idorb, std::vector< poly > polist, int trInd, int trunDegHs)
#define pLmDivisibleBy(a, b)
like pDivisibleBy, except that it is assumed that a!=NULL, b!=NULL
static long p_Totaldegree(poly p, const ring r)
const CanonicalForm int s
int status int void size_t count
#define pCopy(p)
return a copy of the poly
void hDegreeSeries(intvec *s1, intvec *s2, int *co, int *mu)
poly p_ISet(long i, const ring r)
returns the poly representing the integer i
ideal id_Copy(ideal h1, const ring r)
copy an ideal
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
void scPrintDegree(int co, int mu)
ideal id_Head(ideal h, const ring r)
returns the ideals of initial terms
ideal idQuotMon(ideal Iorig, ideal p)
matrix mp_Sub(matrix a, matrix b, const ring R)
static int * hAddHilb(int Nv, int x, int *pol, int *lp)
void luDecomp(const matrix aMat, matrix &pMat, matrix &lMat, matrix &uMat, const ring R)
LU-decomposition of a given (m x n)-matrix.
void hLexS(scfmon stc, int Nstc, varset var, int Nvar)