31 int dn, iv, rad0,
b, c,
x;
44 while(pure[var[iv]]) iv--;
45 hStepR(rad, Nrad, var, iv, &rad0);
53 hDimSolve(pn, Npure + 1, rn, rad0, var, iv);
56 hElimR(rn, &rad0, b, c, var, iv);
57 hPure(rn, b, &c, var, iv, pn, &x);
60 hDimSolve(pn, Npure + x, rn, rad0, var, iv);
64 hDimSolve(pure, Npure, rad, Nrad, var, iv);
135 int dn, iv, rad0,
b, c,
x;
172 while(pure[var[iv]]) iv--;
173 hStepR(rad, Nrad, var, iv, &rad0);
182 hIndSolve(pn, Npure + 1, rn, rad0, var, iv);
186 hElimR(rn, &rad0, b, c, var, iv);
187 hPure(rn, b, &c, var, iv, pn, &x);
190 hIndSolve(pn, Npure + x, rn, rad0, var, iv);
194 hIndSolve(pure, Npure, rad, Nrad, var, iv);
266 (*Set)[
i] = hInd[i+1];
301 for (iv=(
currRing->N); iv!=0 ; iv--)
315 int dn, iv, rad0,
b, c,
x;
328 for (iv = Nvar; iv!=0; iv--)
364 while(pure[var[iv]]) iv--;
365 hStepR(rad, Nrad, var, iv, &rad0);
372 hIndMult(pn, Npure + 1, rn, rad0, var, iv);
376 hElimR(rn, &rad0, b, c, var, iv);
377 hPure(rn, b, &c, var, iv, pn, &x);
380 hIndMult(pn, Npure + x, rn, rad0, var, iv);
384 hIndMult(pure, Npure, rad, Nrad, var, iv);
397 while (sm->nx !=
NULL)
403 if (((*Set)[iv-1] == 0) && (pure[iv] == 0))
424 while (sm->nx !=
NULL)
430 if ((pure[iv] == 1) && ((*Set)[iv-1] == 1))
498 int dn, iv, rad0,
b, c,
x;
511 for (iv = Nvar; iv; iv--)
526 while(pure[var[iv]]) iv--;
527 hStepR(rad, Nrad, var, iv, &rad0);
538 hElimR(rn, &rad0, b, c, var, iv);
539 hPure(rn, b, &c, var, iv, pn, &x);
554 int iv = Nvar -1, sum, a, a0, a1,
b,
i;
563 for (i = Nvar;
i; i--)
570 hStepS(sn, Nstc, var, Nvar, &a, &x);
572 return pure[var[Nvar]] *
hZeroMult(pn, sn, a, var, iv);
580 hStepS(sn, Nstc, var, Nvar, &a, &x);
581 hElimS(sn, &b, a0, a, var, iv);
583 hPure(sn, a0, &a1, var, iv, pn, &i);
588 sum += (x - x0) *
hZeroMult(pn, sn, b, var, iv);
592 sum += (pure[var[Nvar]] - x0) *
hZeroMult(pn, sn, b, var, iv);
602 for (i = 1; i <= (
currRing->N); i++)
613 if ((i0 > 2) && (i > 10))
624 int dn, iv, rad0,
b, c,
x;
637 for (iv = Nvar; iv; iv--)
673 while(pure[var[iv]]) iv--;
674 hStepR(rad, Nrad, var, iv, &rad0);
681 hDimMult(pn, Npure + 1, rn, rad0, var, iv);
685 hElimR(rn, &rad0, b, c, var, iv);
686 hPure(rn, b, &c, var, iv, pn, &x);
689 hDimMult(pn, Npure + x, rn, rad0, var, iv);
693 hDimMult(pure, Npure, rad, Nrad, var, iv);
813 Print(
"// dimension (proj.) = %d\n// degree (proj.) = %d\n", di-1, mu);
815 Print(
"// dimension (affine) = 0\n// degree (affine) = %d\n", mu);
818 Print(
"// dimension (local) = %d\n// multiplicity = %d\n", di, mu);
835 if ((l == 1) &&(mu == 0))
844 static void hDegree0(ideal S, ideal
Q,
const ring tailRing)
893 memset(
hpur0, 0, ((r->N) + 1) *
sizeof(
int));
906 if (mc <= 0 ||
hMu < 0)
945 int Nstc,
varset var,
int Nvar,poly hEdge)
947 int iv = Nvar -1,
k = var[Nvar], a, a0, a1,
b,
i;
959 for (i = Nvar; i>0; i--)
960 pSetExp(pWork, var[i], pure[var[i]]);
967 hStepS(sn, Nstc, var, Nvar, &a, &x);
984 hStepS(sn, Nstc, var, Nvar, &a, &x);
985 hElimS(sn, &b, a0, a, var, iv);
987 hPure(sn, a0, &a1, var, iv, pn, &i);
1016 for(i=0;i<=
idElem(S);i++)
1029 printf(
"\nThis is HC:\n");
1030 for(
int ii=0;ii<=
idElem(S);ii++)
1050 for (i = hNvar; i>0; i--)
1053 if ((hNvar > 2) && (
hNstc > 10))
1055 memset(
hpure, 0, (hNvar + 1) *
sizeof(
int));
1085 last =
pNext(last) = q;
1090 int x,
y=stc[0][Nvar];
1102 int x,
y=stc[0][Nvar];
1115 int i,
j, Istc = Nstc;
1118 for (i=Nstc-1; i>=0; i--)
1123 if(stc[i][j] != 0)
break;
1137 for (i=Nstc-1; i>=0; i--)
1139 if (stc[i] && (stc[i][Nvar] >= y))
1169 for (i=Nvar;
i; i--) act[i] = 0;
1182 scAll(Nvar-1, deg-d);
1192 scAll(Nvar-1, deg-ideg);
1194 }
while (ideg >= 0);
1199 int Ivar, Istc,
i,
j;
1205 for (i=Nstc-1; i>=0; i--)
1207 for (j=Nvar;
j;j--){
if(stc[i][j])
break; }
1210 for (i=Nvar;
i; i--) act[i] = 0;
1216 for (i=Nstc-1; i>=0; i--)
if(deg >= stc[i][1])
return;
1231 if (deg < x) ideg = deg;
1241 x =
scMax(Nstc, sn, Nvar);
1248 if (ideg < 0)
return;
1250 for (i=Nstc-1; i>=0; i--)
1252 if (ideg < sn[i][Nvar])
1280 int Ivar, Istc,
i,
j;
1286 ideg =
scMin(Nstc, stc, 1);
1302 x =
scMax(Nstc, sn, Nvar);
1309 if (ideg < 0)
return;
1311 for (i=Nstc-1; i>=0; i--)
1313 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)
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.
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<q w.r.t monomial ordering
static void scDegKbase(scfmon stc, int Nstc, int Nvar, int deg)
#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)
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)
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
void hRadical(scfmon rad, int *Nrad, int Nvar)
void hDelete(scfmon ev, int ev_length)
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
int scMultInt(ideal S, ideal Q)
#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)
static unsigned pLength(poly a)
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)