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].toVector().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].toVector().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].toVector();
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].toVector();
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++)
361 gfan::ZVector startingPoint;
groebnerCone ambientMaximalCone;
382 startingPoint = startingData.first;
390 inI =
initial(inI,s,startingPoint);
401 ideal J =
lift(I,r,inI,s);
417 for (
int i=0;
i<
k;
i++)
447 gfan::ZVector startingPoint = startingData.first;
452 inJ =
initial(inJ,s,startingPoint);
453 ideal inI =
initial(I,r,startingPoint);
461 ideal J =
lift(I,r,inJ,s);
471 ring rShortcut =
rCopy0(r);
477 ideal inJShortcut =
idInit(k);
479 for (
int i=0;
i<
k;
i++)
504 inJShortcut =
initial(inJShortcut,sShortcut,interiorPoint);
505 inI =
initial(inI,r,interiorPoint);
515 inJ->m[0] =
p_One(s);
516 identityMap =
n_SetMap(r->cf,s->cf);
519 for (
int i=0;
i<
k;
i++)
521 if(inJShortcut->m[
i]!=
NULL)
527 ideal J = currentStrategy.
computeLift(inJ,s,inI,I,r);
545 ideal I = (ideal) u->
CopyD();
549 number
p = (number) v->
Data();
557 res->
data = (
char*) startingCone;
573 WerrorS(
"tropicalStartingCone: unexpected parameters");
BOOLEAN negativeTropicalStartingPoint(leftv res, leftv args)
implementation of the class tropicalStrategy
ring getShortcutRing() const
const CanonicalForm int s
gfan::ZCone getPolyhedralCone() const
Class used for (list of) interpreter objects.
gfan::ZCone groebnerCone(const ideal I, const ring r, const gfan::ZVector &w)
ring getPolynomialRing() const
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
ring getStartingRing() const
returns the polynomial ring over the valuation ring
groebnerCone tropicalStartingCone(const tropicalStrategy ¤tStrategy)
void WerrorS(const char *s)
static gfan::ZCone linealitySpaceOfGroebnerFan(const ideal I, const ring r)
number getUniformizingParameter() const
returns the uniformizing parameter in the valuation ring
bigintmat * zVectorToBigintmat(const gfan::ZVector &zv)
static number p_SetCoeff(poly p, number n, ring r)
gfan::ZVector tropicalPoint() const
Returns a point in the tropical variety, if the groebnerCone contains one.
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 ...
groebnerCones groebnerNeighbours() const
Returns a complete list of neighboring Groebner cones.
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)
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...
gfan::ZVector intStar2ZVector(const int d, const int *i)
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
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
BOOLEAN tropicalVariety(leftv res, leftv args)
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
ideal computeLift(const ideal inJs, const ring s, const ideal inIr, const ideal Ir, const ring r) const
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)
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 ...
implementation of the class groebnerCone
void rDelete(ring r)
unconditionally deletes fields in r
gfan::ZVector getInteriorPoint() const
BOOLEAN equations(leftv res, leftv args)
int getExpectedDimension() const
returns the expected Dimension of the polyhedral output
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.
int idElem(const ideal F)
count non-zero elements
groebnerCone groebnerStartingCone(const tropicalStrategy ¤tStrategy)
BOOLEAN nonNegativeTropicalStartingPoint(leftv res, leftv args)
void nKillChar(coeffs r)
undo all initialisations
ideal getPolynomialIdeal() const