51 while(
pure[var[iv]]) iv--;
247 while(
pure[var[iv]]) iv--;
376 for (iv=(
currRing->N); iv!=0 ; iv--)
378 (*Set)[iv-1] = (
pure[iv]==0);
400 for (iv =
Nvar; iv!=0; iv--)
436 while(
pure[var[iv]]) iv--;
475 if (((*Set)[iv-1] == 0) && (
pure[iv] == 0))
502 if ((
pure[iv] == 1) && ((*Set)[iv-1] == 1))
558 (*Set)[iv-1] = (
pure[iv]==0);
580 for (iv =
Nvar; iv; iv--)
595 while(
pure[var[iv]]) iv--;
718 if ((
i0 > 2) && (
i > 10))
742 for (iv =
Nvar; iv; iv--)
778 while(
pure[var[iv]]) iv--;
918 Print(
"// dimension (proj.) = %d\n// degree (proj.) = %d\n",
di-1,
mu);
920 Print(
"// dimension (affine) = 0\n// degree (affine) = %d\n",
mu);
923 Print(
"// dimension (local) = %d\n// multiplicity = %d\n",
di,
mu);
988 if (mc <= 0 ||
hMu < 0)
1101 printf(
"\nThis is HC:\n");
1195 if(
stc[
i][
j] != 0)
break;
1266 }
while (
ideg >= 0);
1288 for (
i=
Nstc-1;
i>=0;
i--)
if(deg >=
stc[
i][1])
return;
1303 if (deg <
x)
ideg = deg;
1320 if (
ideg < 0)
return;
1381 if (
ideg < 0)
return;
1465 if ((deg < 0) || (
deg_ei>=0))
1595 for (
int w = 0;
w <
G->cols();
w++)
1612 for (
int i =
path.size() - 1;
i >= 0;
i--) {
1653 std::vector<int>
path;
1655 std::vector<BOOLEAN>
cyclic;
1656 std::vector<int>
cache;
1659 cache.resize(n, -2);
1663 for (
int v = 0;
v < n;
v++)
1700 for (
int j =
nVars - 1;
j >= 0;
j--)
1702 for (
int i =
last;
i >= 0;
i--)
1784 WerrorS(
"Ufnarovski graph not implemented for l <= 0");
1793 for (
int i = 0;
i < n;
i++)
1795 for (
int j = 0;
j < n;
j++)
1802 for (
int k = 1;
k <= (
l - 1) *
lV;
k++)
1842 WerrorS(
"GK-Dim not implemented for rings");
1852 WerrorS(
"GK-Dim not implemented for modules");
1857 WerrorS(
"GK-Dim not implemented for bi-modules");
1899 WerrorS(
"GK-Dim not defined for 0-ring");
1949 int rows =
M->rows();
1950 int cols =
M->cols();
1952 std::vector<std::vector<int> >
mat(rows, std::vector<int>(cols));
1954 for (
int i = 0;
i < rows;
i++)
1956 for (
int j = 0;
j < cols;
j++)
1967 for (
int i = 0;
i <
mat.size();
i++)
1969 for (
int j = 0;
j <
mat[
i].size();
j++)
1977static void vvTest(
const std::vector<std::vector<int> >&
mat)
1981 int cols =
mat[0].size();
1982 for (
int i = 1;
i <
mat.size();
i++)
1985 WerrorS(
"number of cols in matrix inconsistent");
1992 mat.erase(
mat.begin() + row);
1997 for (
int i = 0;
i <
mat.size();
i++)
1999 mat[
i].erase(
mat[
i].begin() + col);
2005 for (
int i = 0;
i <
mat[row].size();
i++)
2007 if (
mat[row][
i] != 0)
2015 for (
int i = 0;
i <
mat.size();
i++)
2017 if (
mat[
i][col] != 0)
2025 for (
int i = 0;
i <
mat.size();
i++)
2033static std::vector<std::vector<int> >
vvMult(
const std::vector<std::vector<int> >& a,
const std::vector<std::vector<int> >&
b)
2037 int ca = a.size() > 0 ? a[0].size() : 0;
2038 int cb =
b.size() > 0 ?
b[0].size() : 0;
2042 WerrorS(
"matrix dimensions do not match");
2043 return std::vector<std::vector<int> >();
2046 std::vector<std::vector<int> >
res(
ra, std::vector<int>(
cb));
2047 for (
int i = 0;
i <
ra;
i++)
2049 for (
int j = 0;
j <
cb;
j++)
2052 for (
int k = 0;
k <
ca;
k++)
2064 std::vector<int>
path;
2066 std::vector<BOOLEAN>
cyclic;
2067 std::vector<int>
cache;
2070 cache.resize(n, -2);
2072 for (
int v = 0;
v < n;
v++)
2090 WerrorS(
"K-Dim not implemented for rings");
2100 WerrorS(
"K-Dim not implemented for modules");
2105 WerrorS(
"K-Dim not implemented for bi-modules");
2151 WerrorS(
"K-Dim not defined for 0-ring");
2163 PrintS(
"Computing normal words normally...\n");
2192 PrintS(
"Computing Ufnarovski graph...\n");
2209 Print(
"Ufnarovski graph is %dx%d.\n",
UG->rows(),
UG->cols());
2212 PrintS(
"Checking whether Ufnarovski graph is acyclic...\n");
2221 for (
int i = 0;
i <
vvUG.size();
i++)
2231 Print(
"Simplified Ufnarovski graph to %dx%d.\n", (
int)
vvUG.size(), (
int)
vvUG.size());
2236 PrintS(
"Computing normal words via Ufnarovski graph...\n");
2242 PrintS(
"Start count graph entries.\n");
2253 PrintS(
"Done count graph entries.\n");
2258 PrintS(
"Start mat mult.\n");
2261 PrintS(
"Done mat mult.\n");
static int si_max(const int a, const int b)
static int si_min(const int a, const int b)
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_DivBy(number a, number b, const coeffs r)
test whether 'a' is divisible 'b'; for r encoding a field: TRUE iff 'b' does not represent zero in Z:...
const CanonicalForm int s
const CanonicalForm int const CFList const Variable & y
const Variable & v
< [in] a sqrfree bivariate poly
void WerrorS(const char *s)
static long hZeroMult(scmon pure, scfmon stc, int Nstc, varset var, int Nvar)
static ideal lp_computeNormalWords(int length, ideal M)
void scComputeHC(ideal S, ideal Q, int ak, poly &hEdge)
static void hHedgeStep(scmon pure, scfmon stc, int Nstc, varset var, int Nvar, poly hEdge)
static void hDimMult(scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
ideal scKBase(int deg, ideal s, ideal Q, intvec *mv)
int scDimIntRing(ideal vid, ideal Q)
scDimInt for ring-coefficients
static std::vector< int > countCycles(const intvec *_G, int v, std::vector< int > path, std::vector< BOOLEAN > visited, std::vector< BOOLEAN > cyclic, std::vector< int > cache)
long scMult0Int(ideal S, ideal Q)
void hIndMult(scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
static std::vector< std::vector< int > > vvMult(const std::vector< std::vector< int > > &a, const std::vector< std::vector< int > > &b)
static int scMin(int i, scfmon stc, int Nvar)
intvec * scIndIntvec(ideal S, ideal Q)
static void vvDeleteRow(std::vector< std::vector< int > > &mat, int row)
static indset hCheck2(indset sm, scmon pure)
static BOOLEAN hCheck1(indset sm, scmon pure)
static int graphGrowth(const intvec *G)
static BOOLEAN vvIsColumnZero(const std::vector< std::vector< int > > &mat, int col)
static void hDegree(ideal S, ideal Q)
static void vvDeleteColumn(std::vector< std::vector< int > > &mat, int col)
static BOOLEAN hNotZero(scfmon rad, int Nrad, varset var, int Nvar)
int lp_kDim(const ideal _G)
static void hHedge(poly hEdge)
static void hIndSolve(scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
intvec * lp_ufnarovskiGraph(ideal G, ideal &standardWords)
static int scRestrict(int &Nstc, scfmon stc, int Nvar)
int lp_gkDim(const ideal _G)
static std::vector< std::vector< int > > iv2vv(intvec *M)
static void vvPrint(const std::vector< std::vector< int > > &mat)
static void vvTest(const std::vector< std::vector< int > > &mat)
static void scAllKbase(int Nvar, int ideg, int deg)
static void scAll(int Nvar, int deg)
int scMultInt(ideal S, ideal Q)
static void scDegKbase(scfmon stc, int Nstc, int Nvar, int deg)
static void hCheckIndep(scmon pure)
void scPrintDegree(int co, int mu)
static int lp_countNormalWords(int upToLength, ideal M)
static BOOLEAN isAcyclic(const intvec *G)
static int scMax(int i, scfmon stc, int Nvar)
static ideal scIdKbase(poly q, const int rank)
static void hIndep(scmon pure)
static void scInKbase(scfmon stc, int Nstc, int Nvar)
static void hProject(scmon pure, varset sel)
static BOOLEAN vvIsZero(const std::vector< std::vector< int > > &mat)
int scDimInt(ideal S, ideal Q)
ideal dimension
static BOOLEAN vvIsRowZero(const std::vector< std::vector< int > > &mat, int row)
static void _lp_computeNormalWords(ideal words, int &numberOfNormalWords, int length, ideal M, int minDeg, int &last)
void hDimSolve(scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
void hIndAllMult(scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
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 hLexR(scfmon rad, int Nrad, varset var, int Nvar)
void hStepR(scfmon rad, int Nrad, varset var, int Nvar, int *a)
void hLex2R(scfmon rad, int e1, int a2, int e2, varset var, int Nvar, scfmon w)
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 hElimR(scfmon rad, int *e1, int a2, int e2, varset var, int Nvar)
void hOrdSupp(scfmon stc, int Nstc, varset var, int Nvar)
scfmon hInit(ideal S, ideal Q, int *Nexist)
void hRadical(scfmon rad, int *Nrad, int Nvar)
#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
#define idPosConstant(I)
index of generator with leading term in ground ring (if any); otherwise -1
static BOOLEAN length(leftv result, leftv arg)
intvec * ivCopy(const intvec *o)
#define IMATELEM(M, I, J)
static matrix mu(matrix A, const ring R)
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
#define omFreeSize(addr, size)
#define omFreeBin(addr, bin)
#define omGetSpecBin(size)
static int index(p_Length length, p_Ord ord)
int p_IsPurePower(const poly p, const ring r)
return i, if head depends only on var(i)
static int pLength(poly a)
static void p_Delete(poly *p, const 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)
static long pTotaldegree(poly p)
#define pGetComp(p)
Component.
#define pIsConstantComp(p)
return true if p is either NULL, or if all exponents of p are 0, Comp of p might be !...
static void pLmFree(poly p)
frees the space of the monomial m, assumes m != NULL coef is not freed, m is not advanced
#define pGetExp(p, i)
Exponent.
#define pInit()
allocates a new monomial and initializes everything to 0
#define pLmCmp(p, q)
returns 0|1|-1 if p=q|p>q|p<q w.r.t monomial ordering
#define pCopy(p)
return a copy of the poly
void PrintS(const char *s)
static BOOLEAN rField_is_Z(const ring r)
#define rField_is_Ring(R)
BOOLEAN p_LPDivisibleBy(poly a, poly b, const ring r)
poly p_LPVarAt(poly p, int pos, const ring r)
ideal idInit(int idsize, int rank)
initialise an ideal / module
ideal id_Head(ideal h, const ring r)
returns the ideals of initial terms
void id_DelLmEquals(ideal id, const ring r)
Delete id[j], if Lm(j) == Lm(i) and both LC(j), LC(i) are units and j > i.
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size
static int idElem(const ideal F)
number of non-zero polys in F