33 if (startingPoint.size() > 0)
34 return std::make_pair(startingPoint,sigma);
40 workingList.insert(sigma);
41 while (!workingList.empty())
45 for (groebnerCones::iterator
tau = neighbours.begin();
tau!=neighbours.end();
tau++)
47 if (groebnerFan.count(*
tau) == 0)
49 if (workingList.count(*
tau) == 0)
51 startingPoint =
tau->tropicalPoint();
52 if (startingPoint.size() > 0)
53 return std::make_pair(startingPoint,*
tau);
55 workingList.insert(*
tau);
58 groebnerFan.insert(sigma);
59 workingList.erase(sigma);
63 gfan::ZVector emptyVector = gfan::ZVector(0);
65 return std::pair<gfan::ZVector,groebnerCone>(emptyVector,emptyCone);
80 if (startingPoint.size() > 0)
81 return std::make_pair(startingPoint,sigma);
87 workingList.insert(sigma);
88 while (!workingList.empty())
92 for (groebnerCones::iterator
tau = neighbours.begin();
tau!=neighbours.end();
tau++)
94 if (groebnerFan.count(*
tau) == 0)
96 if (workingList.count(*
tau) == 0)
98 startingPoint =
tau->tropicalPoint();
99 if (startingPoint.size() > 0)
100 return std::make_pair(startingPoint,*
tau);
102 workingList.insert(*
tau);
105 groebnerFan.insert(sigma);
106 workingList.erase(sigma);
110 gfan::ZVector emptyVector = gfan::ZVector(0);
112 return std::pair<gfan::ZVector,groebnerCone>(emptyVector,emptyCone);
120 ideal I = (ideal) u->
Data();
126 for (std::set<gfan::ZCone>::iterator zc=Tg.begin(); zc!=Tg.end(); zc++)
128 gfan::ZMatrix ray = zc->extremeRays();
129 for (
int i=0;
i<ray.getHeight();
i++)
131 if (ray[
i].isPositive())
143 WerrorS(
"positiveTropicalStartingPoint: ideal not principal");
146 WerrorS(
"positiveTropicalStartingPoint: unexpected parameters");
155 ideal I = (ideal) u->
Data();
161 for (std::set<gfan::ZCone>::iterator zc=Tg.begin(); zc!=Tg.end(); zc++)
163 gfan::ZMatrix ray = zc->extremeRays();
164 for (
int i=0;
i<ray.getHeight();
i++)
166 if (ray[
i].isNonNegative())
178 WerrorS(
"nonNegativeTropicalStartingPoint: ideal not principal");
181 WerrorS(
"nonNegativeTropicalStartingPoint: unexpected parameters");
190 ideal I = (ideal) u->
Data();
196 for (std::set<gfan::ZCone>::iterator zc=Tg.begin(); zc!=Tg.end(); zc++)
198 gfan::ZMatrix ray = zc->extremeRays();
199 for (
int i=0;
i<ray.getHeight();
i++)
201 gfan::ZVector negatedRay = gfan::Integer(-1)*ray[
i];
202 if (negatedRay.isPositive())
214 WerrorS(
"negativeTropicalStartingPoint: ideal not principal");
217 WerrorS(
"negativeTropicalStartingPoint: unexpected parameters");
226 ideal I = (ideal) u->
Data();
232 for (std::set<gfan::ZCone>::iterator zc=Tg.begin(); zc!=Tg.end(); zc++)
234 gfan::ZMatrix ray = zc->extremeRays();
235 for (
int i=0;
i<ray.getHeight();
i++)
237 gfan::ZVector negatedRay = gfan::Integer(-1)*ray[
i];
238 if (negatedRay.isNonNegative())
250 WerrorS(
"nonPositiveTropicalStartingPoint: ideal not principal");
253 WerrorS(
"nonPositiveTropicalStartingPoint: unexpected parameters");
262 ideal I = (ideal) u->
Data();
274 gfan::ZCone C = *(Tg.begin());
275 gfan::ZMatrix
rays = C.extremeRays();
276 if (rays.getHeight()==0)
278 gfan::ZMatrix lin = C.generatorsOfLinealitySpace();
290 gfan::ZMatrix lin = C0.generatorsOfLinealitySpace();
296 gfan::ZVector startingPoint = startingData.first;
301 WerrorS(
"tropicalStartingPoint: unexpected parameters");
311 gfan::ZMatrix
equations = gfan::ZMatrix(0,n);
312 int* expv = (
int*)
omAlloc((n+1)*
sizeof(int));
314 for (
int i=0;
i<
k;
i++)
329 return gfan::ZCone(gfan::ZMatrix(0,n),equations);
339 currentStrategy.
reduce(I,r);
348 for (
int i=0;
i<
k;
i++)
356 gfan::ZVector startingPoint;
groebnerCone ambientMaximalCone;
377 startingPoint = startingData.first;
385 inI =
initial(inI,s,startingPoint);
396 ideal J =
lift(I,r,inI,s);
412 for (
int i=0;
i<
k;
i++)
437 gfan::ZVector startingPoint = startingData.first;
442 inJ =
initial(inJ,s,startingPoint);
443 ideal inI =
initial(I,r,startingPoint);
451 ideal J =
lift(I,r,inJ,s);
461 ring rShortcut =
rCopy0(r);
467 ideal inJShortcut =
idInit(k);
469 for (
int i=0;
i<
k;
i++)
489 inJShortcut =
initial(inJShortcut,sShortcut,interiorPoint);
490 inI =
initial(inI,r,interiorPoint);
500 inJ->m[0] =
p_One(s);
501 identityMap =
n_SetMap(r->cf,s->cf);
504 for (
int i=0;
i<
k;
i++)
507 ideal J = currentStrategy.
computeLift(inJ,s,inI,I,r);
525 ideal I = (ideal) u->
CopyD();
529 number
p = (number) v->
Data();
537 res->
data = (
char*) startingCone;
553 WerrorS(
"tropicalStartingCone: unexpected parameters");
BOOLEAN negativeTropicalStartingPoint(leftv res, leftv args)
implementation of the class tropicalStrategy
const CanonicalForm int s
gfan::ZVector getInteriorPoint() const
Class used for (list of) interpreter objects.
gfan::ZCone groebnerCone(const ideal I, const ring r, const gfan::ZVector &w)
gfan::ZFan * groebnerFan(const tropicalStrategy currentStrategy)
BOOLEAN positiveTropicalStartingPoint(leftv res, leftv args)
BOOLEAN nonPositiveTropicalStartingPoint(leftv res, leftv args)
static void p_GetExpV(poly p, int *ev, const 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
gfan::ZCone getPolyhedralCone() 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 ...
groebnerCone tropicalStartingCone(const tropicalStrategy ¤tStrategy)
void WerrorS(const char *s)
static gfan::ZCone linealitySpaceOfGroebnerFan(const ideal I, const ring r)
bigintmat * zVectorToBigintmat(const gfan::ZVector &zv)
ring getStartingRing() const
returns the polynomial ring over the valuation ring
static number p_SetCoeff(poly p, number n, ring r)
int getExpectedDimension() const
returns the expected Dimension of the polyhedral output
std::set< groebnerCone, groebnerCone_compare > groebnerCones
ideal lift(const ideal J, const ring r, const ideal inI, const ring s)
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
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)
ring getShortcutRing() 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...
groebnerCones groebnerNeighbours() const
Returns a complete list of neighboring Groebner cones.
gfan::ZVector intStar2ZVector(const int d, const int *i)
ring rCopy0(const ring r, BOOLEAN copy_qideal, BOOLEAN copy_ordering)
ideal getStartingIdeal() const
returns the input ideal
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
BOOLEAN tropicalVariety(leftv res, leftv args)
ideal getPolynomialIdeal() const
std::pair< gfan::ZVector, groebnerCone > tropicalStartingPoint(const ideal I, const ring r, const tropicalStrategy ¤tStrategy)
Computes a starting point outside the lineatliy space by traversing the Groebner fan, checking each cone whether it contains a ray in the tropical variety.
poly checkForMonomialViaSuddenSaturation(const ideal I, const ring r)
void tau(int **points, int sizePoints, int k)
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::ZCone getHomogeneitySpace() const
returns the homogeneity space of the preimage ideal
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
BOOLEAN rays(leftv res, leftv args)
implementation of the class groebnerCone
void rDelete(ring r)
unconditionally deletes fields in r
ring getPolynomialRing() const
BOOLEAN equations(leftv res, leftv args)
std::pair< gfan::ZVector, groebnerCone > tropicalStartingDataViaGroebnerFan(const ideal I, const ring r, const tropicalStrategy ¤tStrategy)
Computes a starting point outside the lineatliy space by traversing the Groebner fan, checking each cone whether it contains a ray in the tropical variety.
ideal computeLift(const ideal inJs, const ring s, const ideal inIr, const ideal Ir, const ring r) const
static int idSize(const ideal id)
Count the effective size of an ideal (without the trailing allocated zero-elements) ...
groebnerCone groebnerStartingCone(const tropicalStrategy ¤tStrategy)
BOOLEAN nonNegativeTropicalStartingPoint(leftv res, leftv args)
void nKillChar(coeffs r)
undo all initialisations
gfan::ZVector tropicalPoint() const
Returns a point in the tropical variety, if the groebnerCone contains one.
bool isValuationTrivial() const