35 if (i != -1)
pDelete(&vv->m[i]);
63 gfan::ZVector allOnes(n);
64 for (
int i=0;
i<n;
i++)
66 ring rShortcut =
rCopy0(r);
68 int* order = rShortcut->order;
69 int* block0 = rShortcut->block0;
70 int* block1 = rShortcut->block1;
71 int** wvhdl = rShortcut->wvhdl;
74 rShortcut->order = (
int*)
omAlloc0((h+1)*
sizeof(int));
75 rShortcut->block0 = (
int*)
omAlloc0((h+1)*
sizeof(int));
76 rShortcut->block1 = (
int*)
omAlloc0((h+1)*
sizeof(int));
77 rShortcut->wvhdl = (
int**)
omAlloc0((h+1)*
sizeof(
int*));
79 rShortcut->block0[0] = 1;
80 rShortcut->block1[0] = n;
83 for (
int i=1;
i<=
h;
i++)
85 rShortcut->order[
i] = order[
i-1];
86 rShortcut->block0[
i] = block0[
i-1];
87 rShortcut->block1[
i] = block1[
i-1];
88 rShortcut->wvhdl[
i] = wvhdl[
i-1];
100 ideal IShortcut =
idInit(k);
102 for (
int i=0;
i<
k;
i++)
114 for (
int i=0;
i<
k;
i++)
130 const bool completelyHomogeneous,
131 const bool completeSpace):
132 originalRing(
rCopy(r)),
134 expectedDimension(
dim(originalIdeal,originalRing)),
136 startingRing(
rCopy(originalRing)),
137 startingIdeal(
id_Copy(originalIdeal,originalRing)),
138 uniformizingParameter(
NULL),
140 onlyLowerHalfSpace(
false),
146 if (!completelyHomogeneous)
169 char** oldNames = s->names;
170 s->names = (
char**)
omAlloc((n+1)*
sizeof(
char**));
172 for (
int i=1;
i<n;
i++)
173 s->names[
i] = oldNames[
i-1];
176 s->order = (
int*)
omAlloc0(3*
sizeof(
int));
177 s->block0 = (
int*)
omAlloc0(3*
sizeof(
int));
178 s->block1 = (
int*)
omAlloc0(3*
sizeof(
int));
179 s->wvhdl = (
int**)
omAlloc0(3*
sizeof(
int**));
183 s->wvhdl[0] = (
int*)
omAlloc(n*
sizeof(
int));
195 for (
int i=1;
i<n;
i++)
200 for (
int i=1;
i<n;
i++)
205 for (
int i=1;
i<n;
i++)
206 s->wvhdl[0][
i] = r->wvhdl[0][
i-1];
210 for (
int i=1;
i<n;
i++)
211 s->wvhdl[0][
i] = -r->wvhdl[0][
i-1];
224 p_SetCoeff(g,uniformizingParameter,startingRing);
236 int n =
rVar(originalRing);
237 int* shiftByOne = (
int*)
omAlloc((n+1)*
sizeof(int));
238 for (
int i=1;
i<=n;
i++)
240 for (
int i=0;
i<
k;
i++)
242 if(originalIdeal->m[
i]!=
NULL)
244 J->m[
i] =
p_PermPoly(originalIdeal->m[
i],shiftByOne,originalRing,startingRing,nMap,
NULL,0);
255 startingIdeal->m[
k] = pt->m[0];
373 if (shortcutRing)
rTest(shortcutRing);
399 for (
int i=l;
i>0;
i--)
439 ring rShortcut =
rCopy0(r);
442 int* order = rShortcut->order;
443 int* block0 = rShortcut->block0;
444 int* block1 = rShortcut->block1;
445 int** wvhdl = rShortcut->wvhdl;
450 rShortcut->order = (
int*)
omAlloc0((h+1)*
sizeof(int));
451 rShortcut->block0 = (
int*)
omAlloc0((h+1)*
sizeof(int));
452 rShortcut->block1 = (
int*)
omAlloc0((h+1)*
sizeof(int));
453 rShortcut->wvhdl = (
int**)
omAlloc0((h+1)*
sizeof(
int*));
455 rShortcut->block0[0] = 1;
456 rShortcut->block1[0] = n;
459 for (
int i=1;
i<=
h;
i++)
461 rShortcut->order[
i] = order[
i-1];
462 rShortcut->block0[
i] = block0[
i-1];
463 rShortcut->block1[
i] = block1[
i-1];
464 rShortcut->wvhdl[
i] = wvhdl[
i-1];
489 for (
int i=0;
i<
k;
i++)
495 return std::pair<poly,int>(
g,
i);
511 for (
int i=0;
i<
k;
i++)
543 return std::pair<poly,int>(monomial,-1);
548 ring rShortcut =
rCopy0(r);
578 ideal inJShortcut =
idInit(k);
579 ideal inIShortcut =
idInit(l);
581 for (
int i=0;
i<
k;
i++)
583 for (
int j=0;
j<
l;
j++)
585 id_Test(inJShortcut,rShortcut);
586 id_Test(inIShortcut,rShortcut);
595 for (
int ij=k*l-1; ij>=0; ij--)
605 for (
int j=0;
j<
k;
j++)
608 for (
int i=0;
i<
l;
i++)
618 for (
int i=0;
i<
l;
i++)
649 ideal inIShortcut =
idInit(k);
650 for (
int i=0;
i<
k;
i++)
658 inJ->m[0] =
p_One(r);
661 for (
int i=0;
i<
k;
i++)
675 for (
int i=0;
i<
k;
i++)
681 for (
int i=0;
i<
k;
i++)
688 if (r->order !=
NULL)
697 for (
int j=0;
j<
i;
j++)
698 if (r->wvhdl[
j]!=
NULL)
716 s->order = (
int*)
omAlloc0(5*
sizeof(
int));
717 s->block0 = (
int*)
omAlloc0(5*
sizeof(
int));
718 s->block1 = (
int*)
omAlloc0(5*
sizeof(
int));
719 s->wvhdl = (
int**)
omAlloc0(5*
sizeof(
int**));
745 s->order = (
int*)
omAlloc0(5*
sizeof(
int));
746 s->block0 = (
int*)
omAlloc0(5*
sizeof(
int));
747 s->block1 = (
int*)
omAlloc0(5*
sizeof(
int));
748 s->wvhdl = (
int**)
omAlloc0(5*
sizeof(
int**));
768 const gfan::ZVector &interiorPoint,
769 const gfan::ZVector &facetNormal)
const 776 ideal inIr =
initial(Ir,r,interiorPoint);
780 ideal inIsAdjusted =
idInit(k);
781 for (
int i=0;
i<
k;
i++)
789 identity =
n_SetMap(sAdjusted->cf,r->cf);
790 for (
int i=0;
i<
k;
i++)
797 for (
int i=0;
i<
k;
i++)
810 return std::make_pair(Js,s);
950 ideal inJ = (ideal) u->
CopyD();
951 ideal inI = (ideal) v->
CopyD();
952 ideal I = (ideal) w->
CopyD();
953 number
p = (number) x->
CopyD();
961 res->
data = (
char*) J;
987 ideal I = (ideal) u->
CopyD();
988 number
p = (number) v->
CopyD();
1004 delete interiorPoint0;
1005 delete facetNormal0;
1006 delete interiorPoint;
1016 WerrorS(
"computeFlipDebug: unexpected parameters");
#define idPosConstant(I)
index of generator with leading term in ground ring (if any); otherwise -1
void putUniformizingBinomialInFront(ideal I, const ring r, const number q) const
implementation of the class tropicalStrategy
ring getShortcutRing() const
const CanonicalForm int s
ring getShortcutRingPrependingWeight(const ring r, const gfan::ZVector &w) const
If valuation trivial, returns a copy of r with a positive weight prepended, such that any ideal homog...
matrix divisionDiscardingRemainder(const poly f, const ideal G, const ring r)
Computes a division discarding remainder of f with respect to G.
Class used for (list of) interpreter objects.
poly kNF(ideal F, ideal Q, poly p, int syzComp, int lazyReduce)
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.
gfan::ZCone homogeneitySpace(ideal I, ring r)
gfan::ZVector nonvalued_adjustWeightUnderHomogeneity(const gfan::ZVector &e, const gfan::ZVector &)
int findPositionOfUniformizingBinomial(const ideal I, const ring r) const
ring copyAndChangeCoefficientRing(const ring r) const
#define idDelete(H)
delete an ideal
ring getOriginalRing() const
returns the polynomial ring over the field with valuation
bool isOrderingLocalInT(const ring r)
ideal id_Copy(ideal h1, const ring r)
copy an ideal
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
ideal computeWitness(const ideal inJ, const ideal inI, const ideal I, const ring r) const
suppose w a weight in maximal groebner cone of > suppose I (initially) reduced standard basis w...
bool ppreduceInitially(poly *hStar, const poly g, const ring r)
reduces h initially with respect to g, returns false if h was initially reduced in the first place...
BOOLEAN computeFlipDebug(leftv res, leftv args)
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
#define omFreeSize(addr, size)
static short rVar(const ring r)
#define rVar(r) (r->N)
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
ring getStartingRing() const
returns the polynomial ring over the valuation ring
poly p_Div_nn(poly p, const number n, const ring r)
static ideal constructStartingIdeal(ideal originalIdeal, ring originalRing, number uniformizingParameter, ring startingRing)
bool onlyLowerHalfSpace
true if valuation non-trivial, false otherwise
int * ZVectorToIntStar(const gfan::ZVector &v, bool &overflow)
void WerrorS(const char *s)
number getUniformizingParameter() const
returns the uniformizing parameter in the valuation ring
static tropicalStrategy debugStrategy(const ideal startIdeal, number unifParameter, ring startRing)
BOOLEAN computeWitnessDebug(leftv res, leftv args)
static number p_SetCoeff(poly p, number n, ring r)
static void swapElements(ideal I, ideal J)
static ring constructStartingRing(ring r)
Given a polynomial ring r over the rational numbers and a weighted ordering, returns a polynomial rin...
static poly p_Copy(poly p, const ring r)
returns a copy of p
std::pair< ideal, ring > computeFlip(const ideal Ir, const ring r, const gfan::ZVector &interiorPoint, const gfan::ZVector &facetNormal) const
given an interior point of a groebner cone computes the groebner cone adjacent to it ...
ideal startingIdeal
preimage of the input ideal under the map that sends t to the uniformizing parameter ...
~tropicalStrategy()
destructor
poly initial(const poly p, const ring r, const gfan::ZVector w)
Returns the initial form of p with respect to w.
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
static int rBlocks(ring r)
poly p_PermPoly(poly p, const int *perm, const ring oldRing, const ring dst, nMapFunc nMap, const int *par_perm, int OldPar, BOOLEAN use_mult)
BOOLEAN linealitySpace(leftv res, leftv args)
ideal originalIdeal
input ideal, assumed to be a homogeneous prime ideal
static bool noExtraReduction(ideal I, ring r, number)
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 ...
bool isValuationTrivial() const
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 shortcutRing
polynomial ring over the residue field
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
ideal gfanlib_kStd_wrapper(ideal I, ring r, tHomog h=testHomog)
gfan::ZCone getHomogeneitySpace() const
returns the homogeneity space of the preimage ideal
static void deleteOrdering(ring r)
ring rCopy0(const ring r, BOOLEAN copy_qideal, BOOLEAN copy_ordering)
ideal getStartingIdeal() const
returns the input ideal
int scDimInt(ideal S, ideal Q)
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
ring copyAndChangeOrderingLS(const ring r, const gfan::ZVector &w, const gfan::ZVector &v) const
#define n_Test(a, r)
BOOLEAN n_Test(number a, const coeffs r)
void pReduce(ideal I, const ring r) const
bool checkForUniformizingParameter(const ideal inI, const ring r) const
if valuation non-trivial, checks whether the genearting system contains p otherwise returns true ...
poly checkForMonomialViaSuddenSaturation(const ideal I, const ring r)
only used if HAVE_RINGS is defined
gfan::ZVector adjustWeightForHomogeneity(gfan::ZVector w) const
Given weight w, returns a strictly positive weight u such that an ideal satisfying the valuation-sepc...
bool restrictToLowerHalfSpace() const
returns true, if valuation non-trivial, false otherwise
static BOOLEAN rField_is_Q(const ring r)
gfan::ZVector(* weightAdjustingAlgorithm2)(const gfan::ZVector &v, const gfan::ZVector &w)
A function such that: Given strictly positive weight w and weight v, returns a strictly positive weig...
void mp_Delete(matrix *a, const ring r)
static FORCE_INLINE nMapFunc n_SetMap(const coeffs src, const coeffs dst)
set the mapping function pointers for translating numbers from src to dst
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size
ideal computeLift(const ideal inJs, const ring s, const ideal inIr, const ideal Ir, const ring r) const
BOOLEAN p_EqualPolys(poly p1, poly p2, const ring r)
gfan::ZVector valued_adjustWeightUnderHomogeneity(const gfan::ZVector &e, const gfan::ZVector &w)
void rChangeCurrRing(ring r)
static BOOLEAN rField_is_Zp(const ring r)
ring copyAndChangeOrderingWP(const ring r, const gfan::ZVector &w, const gfan::ZVector &v) const
bool checkForUniformizingBinomial(const ideal I, const ring r) const
if valuation non-trivial, checks whether the generating system contains p-t otherwise returns true ...
matrix mpNew(int r, int c)
create a r x c zero-matrix
static FORCE_INLINE coeffs nCopyCoeff(const coeffs r)
"copy" coeffs, i.e. increment ref
static void p_Delete(poly *p, const ring r)
ideal idInit(int idsize, int rank)
initialise an ideal / module
const Variable & v
< [in] a sqrfree bivariate poly
number uniformizingParameter
uniformizing parameter in the valuation ring
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent : VarOffset encodes the position in p->exp
ring startingRing
polynomial ring over the valuation ring extended by one extra variable t
bool isValuationNonTrivial() const
bool reduce(ideal I, const ring r) const
reduces the generators of an ideal I so that the inequalities and equations of the Groebner cone can ...
static BOOLEAN rField_is_Ring(const ring r)
poly witness(const poly m, const ideal I, const ideal inI, const ring r)
Let w be the uppermost weight vector in the matrix defining the ordering on r.
bool(* extraReductionAlgorithm)(ideal I, ring r, number p)
A function that reduces the generators of an ideal I so that the inequalities and equations of the Gr...
ideal getOriginalIdeal() const
returns the input ideal over the field with valuation
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of 'n'
void rDelete(ring r)
unconditionally deletes fields in r
static BOOLEAN rField_is_Ring_Z(const ring r)
gfan::ZVector nonvalued_adjustWeightForHomogeneity(const gfan::ZVector &w)
gfan::ZVector valued_adjustWeightForHomogeneity(const gfan::ZVector &w)
ideal id_Head(ideal h, const ring r)
returns the ideals of initial terms
int getExpectedDimension() const
returns the expected Dimension of the polyhedral output
std::pair< poly, int > checkInitialIdealForMonomial(const ideal I, const ring r, const gfan::ZVector &w=0) const
If given w, assuming w is in the Groebner cone of the ordering on r and I is a standard basis with re...
static void p_Setm(poly p, const ring r)
gfan::ZVector adjustWeightUnderHomogeneity(gfan::ZVector v, gfan::ZVector w) const
Given strictly positive weight w and weight v, returns a strictly positive weight u such that on an i...
static poly p_Neg(poly p, const ring r)
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
ring originalRing
polynomial ring over a field with valuation
static poly p_Add_q(poly p, poly q, const ring r)
tropicalStrategy & operator=(const tropicalStrategy ¤tStrategy)
assignment operator
gfan::ZCone linealitySpace
the homogeneity space of the Grobner fan
void nKillChar(coeffs r)
undo all initialisations
static poly p_Mult_q(poly p, poly q, const ring r)
gfan::ZVector * bigintmatToZVector(const bigintmat &bim)
int expectedDimension
the expected Dimension of the polyhedral output, i.e.
gfan::ZVector(* weightAdjustingAlgorithm1)(const gfan::ZVector &w)
A function such that: Given weight w, returns a strictly positive weight u such that an ideal satisfy...
#define MATELEM(mat, i, j)
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
ideal computeStdOfInitialIdeal(const ideal inI, const ring r) const
given generators of the initial ideal, computes its standard basis