32 int dn, iv, rad0,
b, c,
x;
45 while(pure[var[iv]]) iv--;
46 hStepR(rad, Nrad, var, iv, &rad0);
54 hDimSolve(pn, Npure + 1, rn, rad0, var, iv);
57 hElimR(rn, &rad0, b, c, var, iv);
58 hPure(rn, b, &c, var, iv, pn, &x);
61 hDimSolve(pn, Npure + x, rn, rad0, var, iv);
65 hDimSolve(pure, Npure, rad, Nrad, var, iv);
136 int dn, iv, rad0,
b, c,
x;
173 while(pure[var[iv]]) iv--;
174 hStepR(rad, Nrad, var, iv, &rad0);
183 hIndSolve(pn, Npure + 1, rn, rad0, var, iv);
187 hElimR(rn, &rad0, b, c, var, iv);
188 hPure(rn, b, &c, var, iv, pn, &x);
191 hIndSolve(pn, Npure + x, rn, rad0, var, iv);
195 hIndSolve(pure, Npure, rad, Nrad, var, iv);
267 (*Set)[
i] = hInd[i+1];
302 for (iv=(
currRing->N); iv!=0 ; iv--)
316 int dn, iv, rad0,
b, c,
x;
329 for (iv = Nvar; iv!=0; iv--)
365 while(pure[var[iv]]) iv--;
366 hStepR(rad, Nrad, var, iv, &rad0);
373 hIndMult(pn, Npure + 1, rn, rad0, var, iv);
377 hElimR(rn, &rad0, b, c, var, iv);
378 hPure(rn, b, &c, var, iv, pn, &x);
381 hIndMult(pn, Npure + x, rn, rad0, var, iv);
385 hIndMult(pure, Npure, rad, Nrad, var, iv);
398 while (sm->nx !=
NULL)
404 if (((*Set)[iv-1] == 0) && (pure[iv] == 0))
425 while (sm->nx !=
NULL)
431 if ((pure[iv] == 1) && ((*Set)[iv-1] == 1))
499 int dn, iv, rad0,
b, c,
x;
512 for (iv = Nvar; iv; iv--)
527 while(pure[var[iv]]) iv--;
528 hStepR(rad, Nrad, var, iv, &rad0);
539 hElimR(rn, &rad0, b, c, var, iv);
540 hPure(rn, b, &c, var, iv, pn, &x);
555 int iv = Nvar -1, sum,
a, a0, a1,
b,
i;
564 for (i = Nvar;
i; i--)
571 hStepS(sn, Nstc, var, Nvar, &a, &x);
573 return pure[var[Nvar]] *
hZeroMult(pn, sn, a, var, iv);
581 hStepS(sn, Nstc, var, Nvar, &a, &x);
582 hElimS(sn, &b, a0, a, var, iv);
584 hPure(sn, a0, &a1, var, iv, pn, &i);
589 sum += (x - x0) *
hZeroMult(pn, sn, b, var, iv);
593 sum += (pure[var[Nvar]] - x0) *
hZeroMult(pn, sn, b, var, iv);
603 for (i = 1; i <= (
currRing->N); i++)
614 if ((i0 > 2) && (i > 10))
625 int dn, iv, rad0,
b, c,
x;
638 for (iv = Nvar; iv; iv--)
674 while(pure[var[iv]]) iv--;
675 hStepR(rad, Nrad, var, iv, &rad0);
682 hDimMult(pn, Npure + 1, rn, rad0, var, iv);
686 hElimR(rn, &rad0, b, c, var, iv);
687 hPure(rn, b, &c, var, iv, pn, &x);
690 hDimMult(pn, Npure + x, rn, rad0, var, iv);
694 hDimMult(pure, Npure, rad, Nrad, var, iv);
814 Print(
"// dimension (proj.) = %d\n// degree (proj.) = %d\n", di-1, mu);
816 Print(
"// dimension (affine) = 0\n// degree (affine) = %d\n", mu);
819 Print(
"// dimension (local) = %d\n// multiplicity = %d\n", di, mu);
836 if ((l == 1) &&(mu == 0))
894 memset(
hpur0, 0, ((r->N) + 1) *
sizeof(
int));
907 if (mc <= 0 ||
hMu < 0)
948 int iv = Nvar -1,
k = var[Nvar],
a, a0, a1,
b,
i;
960 for (i = Nvar; i>0; i--)
961 pSetExp(pWork, var[i], pure[var[i]]);
968 hStepS(sn, Nstc, var, Nvar, &a, &x);
985 hStepS(sn, Nstc, var, Nvar, &a, &x);
986 hElimS(sn, &b, a0, a, var, iv);
988 hPure(sn, a0, &a1, var, iv, pn, &i);
1017 for(i=0;i<=
idElem(S);i++)
1028 printf(
"\nThis is HC:\n");
1029 for(
int ii=0;ii<=
idElem(S);ii++)
1049 for (i = hNvar; i>0; i--)
1052 if ((hNvar > 2) && (
hNstc > 10))
1054 memset(
hpure, 0, (hNvar + 1) *
sizeof(
int));
1084 last =
pNext(last) = q;
1089 int x,
y=stc[0][Nvar];
1101 int x,
y=stc[0][Nvar];
1114 int i,
j, Istc = Nstc;
1117 for (i=Nstc-1; i>=0; i--)
1122 if(stc[i][j] != 0)
break;
1136 for (i=Nstc-1; i>=0; i--)
1138 if (stc[i] && (stc[i][Nvar] >= y))
1168 for (i=Nvar;
i; i--) act[i] = 0;
1181 scAll(Nvar-1, deg-d);
1191 scAll(Nvar-1, deg-ideg);
1193 }
while (ideg >= 0);
1198 int Ivar, Istc,
i,
j;
1204 for (i=Nstc-1; i>=0; i--)
1206 for (j=Nvar;
j;j--){
if(stc[i][j])
break; }
1209 for (i=Nvar;
i; i--) act[i] = 0;
1215 for (i=Nstc-1; i>=0; i--)
if(deg >= stc[i][1])
return;
1230 if (deg < x) ideg = deg;
1240 x =
scMax(Nstc, sn, Nvar);
1247 if (ideg < 0)
return;
1249 for (i=Nstc-1; i>=0; i--)
1251 if (ideg < sn[i][Nvar])
1279 int Ivar, Istc,
i,
j;
1285 ideg =
scMin(Nstc, stc, 1);
1301 x =
scMax(Nstc, sn, Nvar);
1308 if (ideg < 0)
return;
1310 for (i=Nstc-1; i>=0; i--)
1312 if (ideg < sn[i][Nvar])
1365 return idInit(1,s->rank);
1392 if (mv!=
NULL) deg_ei -= (*mv)[i-1];
1393 if ((deg < 0) || (deg_ei>=0))
1412 return idInit(1,s->rank);
1418 #if 0 //-- alternative implementation of scComputeHC
ideal scKBase(int deg, ideal s, ideal Q, intvec *mv)
#define id_TestTail(A, lR, tR)
const CanonicalForm int s
void hLexS(scfmon stc, int Nstc, varset var, int Nvar)
const CanonicalForm int const CFList const Variable & y
void hDimSolve(scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
void hElimR(scfmon rad, int *e1, int a2, int e2, varset var, int Nvar)
void mu(int **points, int sizePoints)
scfmon hGetmem(int lm, scfmon old, monp monmem)
void hIndAllMult(scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
void hElimS(scfmon stc, int *e1, int a2, int e2, varset var, int Nvar)
void scPrintDegree(int co, int mu)
intvec * scIndIntvec(ideal S, ideal Q)
Compatiblity layer for legacy polynomial operations (over currRing)
ideal id_Copy(ideal h1, const ring r)
copy an ideal
#define pLmCmp(p, q)
returns 0|1|-1 if p=q|p>q|p
static void scDegKbase(scfmon stc, int Nstc, int Nvar, int deg)
BEGIN_NAMESPACE_SINGULARXX const ring const ring tailRing
#define omFreeSize(addr, size)
static void hProject(scmon pure, varset sel)
static BOOLEAN hNotZero(scfmon rad, int Nrad, varset var, int Nvar)
static void hDegree(ideal S, ideal Q)
static void hCheckIndep(scmon pure)
static indset hCheck2(indset sm, scmon pure)
void scComputeHC(ideal S, ideal Q, int ak, poly &hEdge, ring tailRing)
#define pLmDelete(p)
assume p != NULL, deletes Lm(p)->coef and Lm(p)
static void scAllKbase(int Nvar, int ideg, int deg)
void hDegreeSeries(intvec *s1, intvec *s2, int *co, int *mu)
void hStepR(scfmon rad, int Nrad, varset var, int Nvar, int *a)
void hRadical(scfmon rad, int *Nrad, int Nvar)
static int pLength(poly a)
void hDelete(scfmon ev, int ev_length)
int scMultInt(ideal S, ideal Q)
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
#define pGetExp(p, i)
Exponent.
void hOrdSupp(scfmon stc, int Nstc, varset var, int Nvar)
void hKill(monf xmem, int Nvar)
static void hIndep(scmon pure)
static void hHedge(poly hEdge)
int scMult0Int(ideal S, ideal Q, const ring tailRing)
void hIndMult(scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
void scDegree(ideal S, intvec *modulweight, ideal Q)
static void hDimMult(scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
int scDimInt(ideal S, ideal Q)
void hPure(scfmon stc, int a, int *Nstc, varset var, int Nvar, scmon pure, int *Npure)
void hStaircase(scfmon stc, int *Nstc, varset var, int Nvar)
static void hHedgeStep(scmon pure, scfmon stc, int Nstc, varset var, int Nvar, poly hEdge)
void hLex2S(scfmon rad, int e1, int a2, int e2, varset var, int Nvar, scfmon w)
static BOOLEAN hCheck1(indset sm, scmon pure)
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size
void hLex2R(scfmon rad, int e1, int a2, int e2, varset var, int Nvar, scfmon w)
static int scRestrict(int &Nstc, scfmon stc, int Nvar)
void hLexR(scfmon rad, int Nrad, varset var, int Nvar)
static void p_Delete(poly *p, const ring r)
#define omGetSpecBin(size)
ideal idInit(int idsize, int rank)
initialise an ideal / module
int p_IsPurePower(const poly p, const ring r)
return i, if head depends only on var(i)
static BOOLEAN rField_is_Ring(const ring r)
void hStepS(scfmon stc, int Nstc, varset var, int Nvar, int *a, int *x)
static ideal scIdKbase(poly q, const int rank)
intvec * hSecondSeries(intvec *hseries1)
#define pInit()
allocates a new monomial and initializes everything to 0
static void scInKbase(scfmon stc, int Nstc, int Nvar)
static void pLmFree(poly p)
frees the space of the monomial m, assumes m != NULL coef is not freed, m is not advanced ...
static int scMax(int i, scfmon stc, int Nvar)
int idElem(const ideal F)
count non-zero elements
static void scAll(int Nvar, int deg)
intvec * hFirstSeries(ideal S, intvec *modulweight, ideal Q, intvec *wdegree, ring tailRing)
static void hIndSolve(scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
static int scMin(int i, scfmon stc, int Nvar)
#define omFreeBin(addr, bin)
void hComp(scfmon exist, int Nexist, int ak, scfmon stc, int *Nstc)
static void hDegree0(ideal S, ideal Q, const ring tailRing)
scfmon hInit(ideal S, ideal Q, int *Nexist, ring tailRing)
static int hZeroMult(scmon pure, scfmon stc, int Nstc, varset var, int Nvar)
void hSupp(scfmon stc, int Nstc, varset var, int *Nvar)