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++)
109 for (
int i=0;
i<
k;
i++)
125 const bool completelyHomogeneous,
126 const bool completeSpace):
127 originalRing(
rCopy(r)),
129 expectedDimension(
dim(originalIdeal,originalRing)),
131 startingRing(
rCopy(originalRing)),
132 startingIdeal(
id_Copy(originalIdeal,originalRing)),
133 uniformizingParameter(
NULL),
135 onlyLowerHalfSpace(
false),
141 if (!completelyHomogeneous)
164 char** oldNames = s->names;
165 s->names = (
char**)
omAlloc((n+1)*
sizeof(
char**));
167 for (
int i=1;
i<n;
i++)
168 s->names[
i] = oldNames[
i-1];
171 s->order = (
int*)
omAlloc0(3*
sizeof(
int));
172 s->block0 = (
int*)
omAlloc0(3*
sizeof(
int));
173 s->block1 = (
int*)
omAlloc0(3*
sizeof(
int));
174 s->wvhdl = (
int**)
omAlloc0(3*
sizeof(
int**));
178 s->wvhdl[0] = (
int*)
omAlloc(n*
sizeof(
int));
190 for (
int i=1;
i<n;
i++)
195 for (
int i=1;
i<n;
i++)
200 for (
int i=1;
i<n;
i++)
201 s->wvhdl[0][
i] = r->wvhdl[0][
i-1];
205 for (
int i=1;
i<n;
i++)
206 s->wvhdl[0][
i] = -r->wvhdl[0][
i-1];
219 p_SetCoeff(g,uniformizingParameter,startingRing);
231 int n =
rVar(originalRing);
232 int* shiftByOne = (
int*)
omAlloc((n+1)*
sizeof(int));
233 for (
int i=1;
i<=n;
i++)
235 for (
int i=0;
i<
k;
i++)
236 J->m[
i] =
p_PermPoly(originalIdeal->m[
i],shiftByOne,originalRing,startingRing,nMap,
NULL,0);
245 startingIdeal->m[
k] = pt->m[0];
363 if (shortcutRing)
rTest(shortcutRing);
389 for (
int i=l;
i>0;
i--)
429 ring rShortcut =
rCopy0(r);
432 int* order = rShortcut->order;
433 int* block0 = rShortcut->block0;
434 int* block1 = rShortcut->block1;
435 int** wvhdl = rShortcut->wvhdl;
440 rShortcut->order = (
int*)
omAlloc0((h+1)*
sizeof(int));
441 rShortcut->block0 = (
int*)
omAlloc0((h+1)*
sizeof(int));
442 rShortcut->block1 = (
int*)
omAlloc0((h+1)*
sizeof(int));
443 rShortcut->wvhdl = (
int**)
omAlloc0((h+1)*
sizeof(
int*));
445 rShortcut->block0[0] = 1;
446 rShortcut->block1[0] = n;
449 for (
int i=1;
i<=
h;
i++)
451 rShortcut->order[
i] = order[
i-1];
452 rShortcut->block0[
i] = block0[
i-1];
453 rShortcut->block1[
i] = block1[
i-1];
454 rShortcut->wvhdl[
i] = wvhdl[
i-1];
479 for (
int i=0;
i<
k;
i++)
483 return std::pair<poly,int>(
g,
i);
499 for (
int i=0;
i<
k;
i++)
531 return std::pair<poly,int>(monomial,-1);
536 ring rShortcut =
rCopy0(r);
566 ideal inJShortcut =
idInit(k);
567 ideal inIShortcut =
idInit(l);
569 for (
int i=0;
i<
k;
i++)
571 for (
int j=0;
j<
l;
j++)
573 id_Test(inJShortcut,rShortcut);
574 id_Test(inIShortcut,rShortcut);
583 for (
int ij=k*l-1; ij>=0; ij--)
593 for (
int j=0;
j<
k;
j++)
596 for (
int i=0;
i<
l;
i++)
606 for (
int i=0;
i<
l;
i++)
637 ideal inIShortcut =
idInit(k);
638 for (
int i=0;
i<
k;
i++)
646 inJ->m[0] =
p_One(r);
649 for (
int i=0;
i<
k;
i++)
663 for (
int i=0;
i<
k;
i++)
669 for (
int i=0;
i<
k;
i++)
676 if (r->order !=
NULL)
685 for (
int j=0;
j<
i;
j++)
686 if (r->wvhdl[
j]!=
NULL)
704 s->order = (
int*)
omAlloc0(5*
sizeof(
int));
705 s->block0 = (
int*)
omAlloc0(5*
sizeof(
int));
706 s->block1 = (
int*)
omAlloc0(5*
sizeof(
int));
707 s->wvhdl = (
int**)
omAlloc0(5*
sizeof(
int**));
733 s->order = (
int*)
omAlloc0(5*
sizeof(
int));
734 s->block0 = (
int*)
omAlloc0(5*
sizeof(
int));
735 s->block1 = (
int*)
omAlloc0(5*
sizeof(
int));
736 s->wvhdl = (
int**)
omAlloc0(5*
sizeof(
int**));
756 const gfan::ZVector &interiorPoint,
757 const gfan::ZVector &facetNormal)
const 764 ideal inIr =
initial(Ir,r,interiorPoint);
768 ideal inIsAdjusted =
idInit(k);
769 for (
int i=0;
i<
k;
i++)
777 identity =
n_SetMap(sAdjusted->cf,r->cf);
778 for (
int i=0;
i<
k;
i++)
785 for (
int i=0;
i<
k;
i++)
798 return std::make_pair(Js,s);
938 ideal inJ = (ideal) u->
CopyD();
939 ideal inI = (ideal) v->
CopyD();
940 ideal I = (ideal) w->
CopyD();
941 number
p = (number) x->
CopyD();
949 res->
data = (
char*) J;
975 ideal I = (ideal) u->
CopyD();
976 number
p = (number) v->
CopyD();
992 delete interiorPoint0;
994 delete interiorPoint;
1004 WerrorS(
"computeFlipDebug: unexpected parameters");
#define idPosConstant(I)
index of generator with leading term in ground ring (if any); otherwise -1
implementation of the class tropicalStrategy
ring getOriginalRing() const
returns the polynomial ring over the field with valuation
const CanonicalForm int s
int findPositionOfUniformizingBinomial(const ideal I, const ring r) const
matrix divisionDiscardingRemainder(const poly f, const ideal G, const ring r)
Computes a division discarding remainder of f with respect to G.
ideal getOriginalIdeal() const
returns the input ideal over the field with valuation
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)
bool isValuationNonTrivial() const
gfan::ZVector nonvalued_adjustWeightUnderHomogeneity(const gfan::ZVector &e, const gfan::ZVector &)
#define idDelete(H)
delete an ideal
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 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.
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
poly p_Div_nn(poly p, const number n, const ring r)
void pReduce(ideal I, const ring r) 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 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)
static tropicalStrategy debugStrategy(const ideal startIdeal, number unifParameter, ring startRing)
ring getStartingRing() const
returns the polynomial ring over the valuation ring
BOOLEAN computeWitnessDebug(leftv res, leftv args)
static number p_SetCoeff(poly p, number n, ring r)
static void swapElements(ideal I, ideal J)
int getExpectedDimension() const
returns the expected Dimension of the polyhedral output
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
ideal startingIdeal
preimage of the input ideal under the map that sends t to the uniformizing parameter ...
~tropicalStrategy()
destructor
ring copyAndChangeCoefficientRing(const ring r) const
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 ...
number getUniformizingParameter() const
returns the uniformizing parameter in the valuation ring
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 ...
ring getShortcutRing() const
ideal computeStdOfInitialIdeal(const ideal inI, const ring r) const
given generators of the initial ideal, computes its standard basis
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)
static void deleteOrdering(ring r)
ring rCopy0(const ring r, BOOLEAN copy_qideal, BOOLEAN copy_ordering)
ideal getStartingIdeal() const
returns the input ideal
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 ...
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 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...
#define n_Test(a, r)
BOOLEAN n_Test(number a, const coeffs r)
void putUniformizingBinomialInFront(ideal I, const ring r, const number q) const
poly checkForMonomialViaSuddenSaturation(const ideal I, const ring r)
only used if HAVE_RINGS is defined: ?
ring copyAndChangeOrderingWP(const ring r, const gfan::ZVector &w, const gfan::ZVector &v) const
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
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...
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)
gfan::ZCone getHomogeneitySpace() const
returns the homogeneity space of the preimage ideal
static BOOLEAN rField_is_Zp(const ring r)
bool restrictToLowerHalfSpace() const
returns true, if valuation non-trivial, false otherwise
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
gfan::ZVector adjustWeightForHomogeneity(gfan::ZVector w) const
Given weight w, returns a strictly positive weight u such that an ideal satisfying the valuation-sepc...
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
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.
ring copyAndChangeOrderingLS(const ring r, const gfan::ZVector &w, const gfan::ZVector &v) const
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...
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
bool checkForUniformizingBinomial(const ideal I, const ring r) const
if valuation non-trivial, checks whether the generating system contains p-t otherwise returns true ...
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)
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...
ideal id_Head(ideal h, const ring r)
returns the ideals of initial terms
ideal computeLift(const ideal inJs, const ring s, const ideal inIr, const ideal Ir, const ring r) const
static void p_Setm(poly p, const ring r)
static int idSize(const ideal id)
Count the effective size of an ideal (without the trailing allocated zero-elements) ...
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.
bool checkForUniformizingParameter(const ideal inI, const ring r) const
if valuation non-trivial, checks whether the genearting system contains p otherwise returns true ...
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)
bool isValuationTrivial() const
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL