39 if (i != -1)
pDelete(&vv->m[i]);
67 gfan::ZVector allOnes(n);
68 for (
int i=0;
i<n;
i++)
70 ring rShortcut =
rCopy0(r);
72 int* order = rShortcut->order;
73 int* block0 = rShortcut->block0;
74 int* block1 = rShortcut->block1;
75 int** wvhdl = rShortcut->wvhdl;
78 rShortcut->order = (
int*)
omAlloc0((h+1)*
sizeof(int));
79 rShortcut->block0 = (
int*)
omAlloc0((h+1)*
sizeof(int));
80 rShortcut->block1 = (
int*)
omAlloc0((h+1)*
sizeof(int));
81 rShortcut->wvhdl = (
int**)
omAlloc0((h+1)*
sizeof(
int*));
83 rShortcut->block0[0] = 1;
84 rShortcut->block1[0] = n;
87 for (
int i=1;
i<=
h;
i++)
89 rShortcut->order[
i] = order[
i-1];
90 rShortcut->block0[
i] = block0[
i-1];
91 rShortcut->block1[
i] = block1[
i-1];
92 rShortcut->wvhdl[
i] = wvhdl[
i-1];
104 ideal IShortcut =
idInit(k);
106 for (
int i=0;
i<
k;
i++)
118 for (
int i=0;
i<
k;
i++)
135 const bool completelyHomogeneous,
136 const bool completeSpace):
137 originalRing(
rCopy(r)),
139 expectedDimension(
dim(originalIdeal,originalRing)),
141 startingRing(
rCopy(originalRing)),
142 startingIdeal(
id_Copy(originalIdeal,originalRing)),
143 uniformizingParameter(
NULL),
145 onlyLowerHalfSpace(
false),
151 if (!completelyHomogeneous)
174 char** oldNames = s->names;
175 s->names = (
char**)
omAlloc((n+1)*
sizeof(
char**));
177 for (
int i=1;
i<n;
i++)
178 s->names[
i] = oldNames[
i-1];
181 s->order = (
int*)
omAlloc0(3*
sizeof(
int));
182 s->block0 = (
int*)
omAlloc0(3*
sizeof(
int));
183 s->block1 = (
int*)
omAlloc0(3*
sizeof(
int));
184 s->wvhdl = (
int**)
omAlloc0(3*
sizeof(
int**));
188 s->wvhdl[0] = (
int*)
omAlloc(n*
sizeof(
int));
200 for (
int i=1;
i<n;
i++)
205 for (
int i=1;
i<n;
i++)
210 for (
int i=1;
i<n;
i++)
211 s->wvhdl[0][
i] = r->wvhdl[0][
i-1];
215 for (
int i=1;
i<n;
i++)
216 s->wvhdl[0][
i] = -r->wvhdl[0][
i-1];
229 p_SetCoeff(g,uniformizingParameter,startingRing);
241 int n =
rVar(originalRing);
242 int* shiftByOne = (
int*)
omAlloc((n+1)*
sizeof(int));
243 for (
int i=1;
i<=n;
i++)
245 for (
int i=0;
i<
k;
i++)
247 if(originalIdeal->m[
i]!=
NULL)
249 J->m[
i] =
p_PermPoly(originalIdeal->m[
i],shiftByOne,originalRing,startingRing,nMap,
NULL,0);
260 startingIdeal->m[
k] = pt->m[0];
378 if (shortcutRing)
rTest(shortcutRing);
404 for (
int i=l;
i>0;
i--)
444 ring rShortcut =
rCopy0(r);
447 int* order = rShortcut->order;
448 int* block0 = rShortcut->block0;
449 int* block1 = rShortcut->block1;
450 int** wvhdl = rShortcut->wvhdl;
455 rShortcut->order = (
int*)
omAlloc0((h+1)*
sizeof(int));
456 rShortcut->block0 = (
int*)
omAlloc0((h+1)*
sizeof(int));
457 rShortcut->block1 = (
int*)
omAlloc0((h+1)*
sizeof(int));
458 rShortcut->wvhdl = (
int**)
omAlloc0((h+1)*
sizeof(
int*));
460 rShortcut->block0[0] = 1;
461 rShortcut->block1[0] = n;
464 for (
int i=1;
i<=
h;
i++)
466 rShortcut->order[
i] = order[
i-1];
467 rShortcut->block0[
i] = block0[
i-1];
468 rShortcut->block1[
i] = block1[
i-1];
469 rShortcut->wvhdl[
i] = wvhdl[
i-1];
494 for (
int i=0;
i<
k;
i++)
500 return std::pair<poly,int>(
g,
i);
516 for (
int i=0;
i<
k;
i++)
529 gfan::ZCone pos = gfan::ZCone::positiveOrthant(C0.ambientDimension());
530 gfan::ZCone C0pos = intersection(C0,pos);
531 C0pos.canonicalize();
532 gfan::ZVector wpos = C0pos.getRelativeInteriorPoint();
555 return std::pair<poly,int>(monomial,-1);
560 ring rShortcut =
rCopy0(r);
590 ideal inJShortcut =
idInit(k);
591 ideal inIShortcut =
idInit(l);
593 for (
int i=0;
i<
k;
i++)
595 for (
int j=0;
j<
l;
j++)
597 id_Test(inJShortcut,rShortcut);
598 id_Test(inIShortcut,rShortcut);
607 for (
int ij=k*l-1; ij>=0; ij--)
617 for (
int j=0;
j<
k;
j++)
620 for (
int i=0;
i<
l;
i++)
630 for (
int i=0;
i<
l;
i++)
661 ideal inIShortcut =
idInit(k);
662 for (
int i=0;
i<
k;
i++)
670 inJ->m[0] =
p_One(r);
673 for (
int i=0;
i<
k;
i++)
687 for (
int i=0;
i<
k;
i++)
693 for (
int i=0;
i<
k;
i++)
707 s->order = (
int*)
omAlloc0(5*
sizeof(
int));
708 s->block0 = (
int*)
omAlloc0(5*
sizeof(
int));
709 s->block1 = (
int*)
omAlloc0(5*
sizeof(
int));
710 s->wvhdl = (
int**)
omAlloc0(5*
sizeof(
int**));
736 s->order = (
int*)
omAlloc0(5*
sizeof(
int));
737 s->block0 = (
int*)
omAlloc0(5*
sizeof(
int));
738 s->block1 = (
int*)
omAlloc0(5*
sizeof(
int));
739 s->wvhdl = (
int**)
omAlloc0(5*
sizeof(
int**));
759 const gfan::ZVector &interiorPoint,
760 const gfan::ZVector &facetNormal)
const 768 ideal inIr =
initial(Ir,r,interiorPoint);
772 ideal inIsAdjusted =
idInit(k);
773 for (
int i=0;
i<
k;
i++)
781 identity =
n_SetMap(sAdjusted->cf,r->cf);
782 for (
int i=0;
i<
k;
i++)
789 for (
int i=0;
i<
k;
i++)
806 return std::make_pair(Js,s);
#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
bool checkForNonPositiveEntries(const gfan::ZVector &w)
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.
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...
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)
number getUniformizingParameter() const
returns the uniformizing parameter in the valuation ring
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
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
poly initial(const poly p, const ring r, const gfan::ZVector &w)
Returns the initial form of p with respect to w.
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:
void deleteOrdering(ring r)
ideal gfanlib_kStd_wrapper(ideal I, ring r, tHomog h=testHomog)
gfan::ZCone getHomogeneitySpace() const
returns the homogeneity space of the preimage ideal
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
bool areIdealsEqual(ideal I, ring r, ideal J, ring s)
#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 ...
only used if HAVE_RINGS is defined
poly searchForMonomialViaStepwiseSaturation(const ideal I, const ring r, const gfan::ZVector w0)
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...
bool checkWeightVector(const ideal I, const ring r, const gfan::ZVector &weightVector, bool checkBorder)
tropicalStrategy(const ideal I, const ring r, const bool completelyHomogeneous=true, const bool completeSpace=true)
Constructor for the trivial valuation case.
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)
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