My Project  UNKNOWN_GIT_VERSION
Public Member Functions | Private Attributes | Friends
groebnerCone Class Reference

#include <groebnerCone.h>

Public Member Functions

 groebnerCone ()
 
 groebnerCone (const ideal I, const ring r, const tropicalStrategy &currentCase)
 
 groebnerCone (const ideal I, const ring r, const gfan::ZVector &w, const tropicalStrategy &currentCase)
 
 groebnerCone (const ideal I, const ring r, const gfan::ZVector &u, const gfan::ZVector &w, const tropicalStrategy &currentCase)
 
 groebnerCone (const ideal I, const ideal inI, const ring r, const tropicalStrategy &currentCase)
 
 groebnerCone (const groebnerCone &sigma)
 
 ~groebnerCone ()
 
groebnerConeoperator= (const groebnerCone &sigma)
 
void deletePolynomialData ()
 
ideal getPolynomialIdeal () const
 
ring getPolynomialRing () const
 
gfan::ZCone getPolyhedralCone () const
 
gfan::ZVector getInteriorPoint () const
 
const tropicalStrategygetTropicalStrategy () const
 
bool isTrivial () const
 
bool contains (const gfan::ZVector &w) const
 Returns true if Groebner cone contains w, false otherwise. More...
 
gfan::ZVector tropicalPoint () const
 Returns a point in the tropical variety, if the groebnerCone contains one. More...
 
groebnerCone flipCone (const gfan::ZVector &interiorPoint, const gfan::ZVector &facetNormal) const
 Given an interior point on the facet and the outer normal factor on the facet, returns the adjacent groebnerCone sharing that facet. More...
 
groebnerCones groebnerNeighbours () const
 Returns a complete list of neighboring Groebner cones. More...
 
groebnerCones tropicalNeighbours () const
 Returns a complete list of neighboring Groebner cones in the tropical variety. More...
 
bool checkFlipConeInput (const gfan::ZVector interiorPoint, const gfan::ZVector facetNormal) const
 Debug tools. More...
 
bool pointsOutwards (const gfan::ZVector) const
 

Private Attributes

ideal polynomialIdeal
 ideal to which this Groebner cone belongs to More...
 
ring polynomialRing
 ring in which the ideal exists More...
 
gfan::ZCone polyhedralCone
 
gfan::ZVector interiorPoint
 
const tropicalStrategycurrentStrategy
 

Friends

struct groebnerCone_compare
 

Detailed Description

Definition at line 27 of file groebnerCone.h.

Constructor & Destructor Documentation

◆ groebnerCone() [1/6]

groebnerCone::groebnerCone ( )

Definition at line 69 of file groebnerCone.cc.

69  :
72  polyhedralCone(gfan::ZCone(0)),
73  interiorPoint(gfan::ZVector(0)),
75 {
76 }

◆ groebnerCone() [2/6]

groebnerCone::groebnerCone ( const ideal  I,
const ring  r,
const tropicalStrategy currentCase 
)

Definition at line 78 of file groebnerCone.cc.

78  :
81  currentStrategy(&currentCase)
82 {
84  if (r) polynomialRing = rCopy(r);
85  if (I)
86  {
87  polynomialIdeal = id_Copy(I,r);
90  }
91 
92  int n = rVar(polynomialRing);
93  poly g = NULL;
94  int* leadexpv = (int*) omAlloc((n+1)*sizeof(int));
95  int* tailexpv = (int*) omAlloc((n+1)*sizeof(int));
96  gfan::ZVector leadexpw = gfan::ZVector(n);
97  gfan::ZVector tailexpw = gfan::ZVector(n);
98  gfan::ZMatrix inequalities = gfan::ZMatrix(0,n);
99  for (int i=0; i<IDELEMS(polynomialIdeal); i++)
100  {
101  g = polynomialIdeal->m[i];
102  if (g)
103  {
104  p_GetExpV(g,leadexpv,r);
105  leadexpw = expvToZVector(n, leadexpv);
106  pIter(g);
107  while (g)
108  {
109  p_GetExpV(g,tailexpv,r);
110  tailexpw = expvToZVector(n, tailexpv);
111  inequalities.appendRow(leadexpw-tailexpw);
112  pIter(g);
113  }
114  }
115  }
116  omFreeSize(leadexpv,(n+1)*sizeof(int));
117  omFreeSize(tailexpv,(n+1)*sizeof(int));
118  // if (currentStrategy->restrictToLowerHalfSpace())
119  // {
120  // gfan::ZVector lowerHalfSpaceCondition = gfan::ZVector(n);
121  // lowerHalfSpaceCondition[0] = -1;
122  // inequalities.appendRow(lowerHalfSpaceCondition);
123  // }
124 
125  polyhedralCone = gfan::ZCone(inequalities,gfan::ZMatrix(0, inequalities.getWidth()));
126  polyhedralCone.canonicalize();
127  interiorPoint = polyhedralCone.getRelativeInteriorPoint();
129 }

◆ groebnerCone() [3/6]

groebnerCone::groebnerCone ( const ideal  I,
const ring  r,
const gfan::ZVector &  w,
const tropicalStrategy currentCase 
)

Definition at line 131 of file groebnerCone.cc.

131  :
134  currentStrategy(&currentCase)
135 {
137  if (r) polynomialRing = rCopy(r);
138  if (I)
139  {
140  polynomialIdeal = id_Copy(I,r);
143  }
144 
145  int n = rVar(polynomialRing);
146  gfan::ZMatrix inequalities = gfan::ZMatrix(0,n);
147  gfan::ZMatrix equations = gfan::ZMatrix(0,n);
148  int* expv = (int*) omAlloc((n+1)*sizeof(int));
149  for (int i=0; i<IDELEMS(polynomialIdeal); i++)
150  {
151  poly g = polynomialIdeal->m[i];
152  if (g)
153  {
154  p_GetExpV(g,expv,polynomialRing);
155  gfan::ZVector leadexpv = intStar2ZVector(n,expv);
156  long d = wDeg(g,polynomialRing,w);
157  for (pIter(g); g; pIter(g))
158  {
159  p_GetExpV(g,expv,polynomialRing);
160  gfan::ZVector tailexpv = intStar2ZVector(n,expv);
161  if (wDeg(g,polynomialRing,w)==d)
162  equations.appendRow(leadexpv-tailexpv);
163  else
164  {
166  inequalities.appendRow(leadexpv-tailexpv);
167  }
168  }
169  }
170  }
171  omFreeSize(expv,(n+1)*sizeof(int));
172  // if (currentStrategy->restrictToLowerHalfSpace())
173  // {
174  // gfan::ZVector lowerHalfSpaceCondition = gfan::ZVector(n);
175  // lowerHalfSpaceCondition[0] = -1;
176  // inequalities.appendRow(lowerHalfSpaceCondition);
177  // }
178 
179  polyhedralCone = gfan::ZCone(inequalities,equations);
180  polyhedralCone.canonicalize();
181  interiorPoint = polyhedralCone.getRelativeInteriorPoint();
183 }

◆ groebnerCone() [4/6]

groebnerCone::groebnerCone ( const ideal  I,
const ring  r,
const gfan::ZVector &  u,
const gfan::ZVector &  w,
const tropicalStrategy currentCase 
)

Definition at line 189 of file groebnerCone.cc.

189  :
192  currentStrategy(&currentCase)
193 {
194  assume(checkWeightVector(I,r,u));
196  if (r) polynomialRing = rCopy(r);
197  if (I)
198  {
199  polynomialIdeal = id_Copy(I,r);
202  }
203 
204  int n = rVar(polynomialRing);
205  gfan::ZMatrix inequalities = gfan::ZMatrix(0,n);
206  gfan::ZMatrix equations = gfan::ZMatrix(0,n);
207  int* expv = (int*) omAlloc((n+1)*sizeof(int));
208  for (int i=0; i<IDELEMS(polynomialIdeal); i++)
209  {
210  poly g = polynomialIdeal->m[i];
211  if (g)
212  {
213  p_GetExpV(g,expv,polynomialRing);
214  gfan::ZVector leadexpv = intStar2ZVector(n,expv);
215  long d1 = wDeg(g,polynomialRing,u);
216  long d2 = wDeg(g,polynomialRing,w);
217  for (pIter(g); g; pIter(g))
218  {
219  p_GetExpV(g,expv,polynomialRing);
220  gfan::ZVector tailexpv = intStar2ZVector(n,expv);
221  if (wDeg(g,polynomialRing,u)==d1 && wDeg(g,polynomialRing,w)==d2)
222  equations.appendRow(leadexpv-tailexpv);
223  else
224  {
226  inequalities.appendRow(leadexpv-tailexpv);
227  }
228  }
229  }
230  }
231  omFreeSize(expv,(n+1)*sizeof(int));
232  // if (currentStrategy->restrictToLowerHalfSpace())
233  // {
234  // gfan::ZVector lowerHalfSpaceCondition = gfan::ZVector(n);
235  // lowerHalfSpaceCondition[0] = -1;
236  // inequalities.appendRow(lowerHalfSpaceCondition);
237  // }
238 
239  polyhedralCone = gfan::ZCone(inequalities,equations);
240  polyhedralCone.canonicalize();
241  interiorPoint = polyhedralCone.getRelativeInteriorPoint();
243 }

◆ groebnerCone() [5/6]

groebnerCone::groebnerCone ( const ideal  I,
const ideal  inI,
const ring  r,
const tropicalStrategy currentCase 
)

Definition at line 246 of file groebnerCone.cc.

246  :
247  polynomialIdeal(id_Copy(I,r)),
248  polynomialRing(rCopy(r)),
249  currentStrategy(&currentCase)
250 {
253 
256 
257  int n = rVar(r);
258  gfan::ZMatrix equations = gfan::ZMatrix(0,n);
259  int* expv = (int*) omAlloc((n+1)*sizeof(int));
260  for (int i=0; i<IDELEMS(inI); i++)
261  {
262  poly g = inI->m[i];
263  if (g)
264  {
265  p_GetExpV(g,expv,r);
266  gfan::ZVector leadexpv = intStar2ZVector(n,expv);
267  for (pIter(g); g; pIter(g))
268  {
269  p_GetExpV(g,expv,r);
270  gfan::ZVector tailexpv = intStar2ZVector(n,expv);
271  equations.appendRow(leadexpv-tailexpv);
272  }
273  }
274  }
275  gfan::ZMatrix inequalities = gfan::ZMatrix(0,n);
276  for (int i=0; i<IDELEMS(polynomialIdeal); i++)
277  {
278  poly g = polynomialIdeal->m[i];
279  if (g)
280  {
281  p_GetExpV(g,expv,r);
282  gfan::ZVector leadexpv = intStar2ZVector(n,expv);
283  for (pIter(g); g; pIter(g))
284  {
285  p_GetExpV(g,expv,r);
286  gfan::ZVector tailexpv = intStar2ZVector(n,expv);
287  inequalities.appendRow(leadexpv-tailexpv);
288  }
289  }
290  }
291  omFreeSize(expv,(n+1)*sizeof(int));
293  {
294  gfan::ZVector lowerHalfSpaceCondition = gfan::ZVector(n);
295  lowerHalfSpaceCondition[0] = -1;
296  inequalities.appendRow(lowerHalfSpaceCondition);
297  }
298 
299  polyhedralCone = gfan::ZCone(inequalities,equations);
300  polyhedralCone.canonicalize();
301  interiorPoint = polyhedralCone.getRelativeInteriorPoint();
303 }

◆ groebnerCone() [6/6]

groebnerCone::groebnerCone ( const groebnerCone sigma)

Definition at line 305 of file groebnerCone.cc.

◆ ~groebnerCone()

groebnerCone::~groebnerCone ( )

Member Function Documentation

◆ checkFlipConeInput()

bool groebnerCone::checkFlipConeInput ( const gfan::ZVector  interiorPoint,
const gfan::ZVector  facetNormal 
) const

Debug tools.

Definition at line 23 of file groebnerCone.cc.

24 {
25  /* check first whether interiorPoint lies on the boundary of the cone */
26  if (!polyhedralCone.contains(interiorPoint))
27  {
28  std::cout << "ERROR: interiorPoint is not contained in the Groebner cone!" << std::endl
29  << "cone: " << std::endl
31  << "interiorPoint:" << std::endl
32  << interiorPoint << std::endl;
33  return false;
34  }
35  if (polyhedralCone.containsRelatively(interiorPoint))
36  {
37  std::cout << "ERROR: interiorPoint is contained in the interior of the maximal Groebner cone!" << std::endl
38  << "cone: " << std::endl
40  << "interiorPoint:" << std::endl
41  << interiorPoint << std::endl;
42  return false;
43  }
44  gfan::ZCone hopefullyAFacet = polyhedralCone.faceContaining(interiorPoint);
45  if (hopefullyAFacet.dimension()!=(polyhedralCone.dimension()-1))
46  {
47  std::cout << "ERROR: interiorPoint is not contained in the interior of a facet!" << std::endl
48  << "cone: " << std::endl
50  << "interiorPoint:" << std::endl
51  << interiorPoint << std::endl;
52  return false;
53  }
54  /* check whether facet normal points outwards */
55  gfan::ZCone dual = polyhedralCone.dualCone();
56  if(dual.containsRelatively(facetNormal))
57  {
58  std::cout << "ERROR: facetNormal is not pointing outwards!" << std::endl
59  << "cone: " << std::endl
61  << "facetNormal:" << std::endl
62  << facetNormal << std::endl;
63  return false;
64  }
65  return true;
66 }

◆ contains()

bool groebnerCone::contains ( const gfan::ZVector &  w) const

Returns true if Groebner cone contains w, false otherwise.

Definition at line 344 of file groebnerCone.cc.

345 {
346  return polyhedralCone.contains(w);
347 }

◆ deletePolynomialData()

void groebnerCone::deletePolynomialData ( )
inline

◆ flipCone()

groebnerCone groebnerCone::flipCone ( const gfan::ZVector &  interiorPoint,
const gfan::ZVector &  facetNormal 
) const

Given an interior point on the facet and the outer normal factor on the facet, returns the adjacent groebnerCone sharing that facet.

Definition at line 383 of file groebnerCone.cc.

384 {
385  assume(this->checkFlipConeInput(interiorPoint,facetNormal));
387  /* Note: the polynomial ring created will have a weighted ordering with respect to interiorPoint
388  * and with a weighted ordering with respect to facetNormal as tiebreaker.
389  * Hence it is sufficient to compute the initial form with respect to facetNormal,
390  * to obtain an initial form with respect to interiorPoint+e*facetNormal,
391  * for e>0 sufficiently small */
392  std::pair<ideal,ring> flipped = currentStrategy->computeFlip(polynomialIdeal,polynomialRing,interiorPoint,facetNormal);
393  assume(checkPolynomialInput(flipped.first,flipped.second));
394  groebnerCone flippedCone(flipped.first, flipped.second, interiorPoint, facetNormal, *currentStrategy);
395  id_Delete(&flipped.first,flipped.second);
396  rDelete(flipped.second);
397  return flippedCone;
398 }

◆ getInteriorPoint()

gfan::ZVector groebnerCone::getInteriorPoint ( ) const
inline

Definition at line 65 of file groebnerCone.h.

65 { return interiorPoint; };

◆ getPolyhedralCone()

gfan::ZCone groebnerCone::getPolyhedralCone ( ) const
inline

Definition at line 64 of file groebnerCone.h.

64 { return polyhedralCone; };

◆ getPolynomialIdeal()

ideal groebnerCone::getPolynomialIdeal ( ) const
inline

Definition at line 62 of file groebnerCone.h.

62 { return polynomialIdeal; };

◆ getPolynomialRing()

ring groebnerCone::getPolynomialRing ( ) const
inline

Definition at line 63 of file groebnerCone.h.

63 { return polynomialRing; };

◆ getTropicalStrategy()

const tropicalStrategy* groebnerCone::getTropicalStrategy ( ) const
inline

Definition at line 66 of file groebnerCone.h.

66 { return currentStrategy; };

◆ groebnerNeighbours()

groebnerCones groebnerCone::groebnerNeighbours ( ) const

Returns a complete list of neighboring Groebner cones.

Definition at line 404 of file groebnerCone.cc.

405 {
406  std::pair<gfan::ZMatrix, gfan::ZMatrix> facetsData = interiorPointsAndNormalsOfFacets(polyhedralCone);
407 
408  gfan::ZMatrix interiorPoints = facetsData.first;
409  gfan::ZMatrix facetNormals = facetsData.second;
410 
411  groebnerCones neighbours;
412  for (int i=0; i<interiorPoints.getHeight(); i++)
413  {
414  gfan::ZVector w = interiorPoints[i];
415  gfan::ZVector v = facetNormals[i];
417  {
418  assume(w[0].sign()<=0);
419  if (w[0].sign()==0 && v[0].sign()>0)
420  continue;
421  }
422  neighbours.insert(flipCone(w,v));
423  }
424  return neighbours;
425 }

◆ isTrivial()

bool groebnerCone::isTrivial ( ) const
inline

Definition at line 69 of file groebnerCone.h.

70  {
71  bool b = (polynomialRing==NULL);
72  return b;
73  }

◆ operator=()

groebnerCone & groebnerCone::operator= ( const groebnerCone sigma)

Definition at line 328 of file groebnerCone.cc.

◆ pointsOutwards()

bool groebnerCone::pointsOutwards ( const gfan::ZVector  w) const

Definition at line 428 of file groebnerCone.cc.

429 {
430  gfan::ZCone dual = polyhedralCone.dualCone();
431  return (!dual.contains(w));
432 }

◆ tropicalNeighbours()

groebnerCones groebnerCone::tropicalNeighbours ( ) const

Returns a complete list of neighboring Groebner cones in the tropical variety.

Definition at line 438 of file groebnerCone.cc.

439 {
440  gfan::ZMatrix interiorPoints = interiorPointsOfFacets(polyhedralCone);
441  groebnerCones neighbours;
442  for (int i=0; i<interiorPoints.getHeight(); i++)
443  {
444  if (!(currentStrategy->restrictToLowerHalfSpace() && interiorPoints[i][0].sign()==0))
445  {
446  ideal initialIdeal = initial(polynomialIdeal,polynomialRing,interiorPoints[i]);
447  gfan::ZMatrix ray = raysOfTropicalStar(initialIdeal,polynomialRing,interiorPoints[i],currentStrategy);
448  for (int j=0; j<ray.getHeight(); j++)
449  if (pointsOutwards(ray[j]))
450  {
451  groebnerCone neighbour = flipCone(interiorPoints[i],ray[j]);
452  neighbours.insert(neighbour);
453  }
454  id_Delete(&initialIdeal,polynomialRing);
455  }
456  }
457  return neighbours;
458 }

◆ tropicalPoint()

gfan::ZVector groebnerCone::tropicalPoint ( ) const

Returns a point in the tropical variety, if the groebnerCone contains one.

Returns an empty vector otherwise.

Definition at line 354 of file groebnerCone.cc.

355 {
357  ideal I = polynomialIdeal;
358  ring r = polynomialRing;
359 
360  gfan::ZCone coneToCheck = polyhedralCone;
361  gfan::ZMatrix R = coneToCheck.extremeRays();
362  for (int i=0; i<R.getHeight(); i++)
363  {
364  assume(!currentStrategy->restrictToLowerHalfSpace() || R[i][0].sign()<=0);
365  if (currentStrategy->restrictToLowerHalfSpace() && R[i][0].sign()==0)
366  continue;
367  std::pair<poly,int> s = currentStrategy->checkInitialIdealForMonomial(I,r,R[i]);
368  if (s.first==NULL)
369  {
370  if (s.second<0)
371  // if monomial was initialized, delete it
372  p_Delete(&s.first,r);
373  return R[i];
374  }
375  }
376  return gfan::ZVector();
377 }

Friends And Related Function Documentation

◆ groebnerCone_compare

friend struct groebnerCone_compare
friend

Definition at line 67 of file groebnerCone.h.

Field Documentation

◆ currentStrategy

const tropicalStrategy* groebnerCone::currentStrategy
private

Definition at line 41 of file groebnerCone.h.

◆ interiorPoint

gfan::ZVector groebnerCone::interiorPoint
private

Definition at line 40 of file groebnerCone.h.

◆ polyhedralCone

gfan::ZCone groebnerCone::polyhedralCone
private

Definition at line 39 of file groebnerCone.h.

◆ polynomialIdeal

ideal groebnerCone::polynomialIdeal
private

ideal to which this Groebner cone belongs to

Definition at line 34 of file groebnerCone.h.

◆ polynomialRing

ring groebnerCone::polynomialRing
private

ring in which the ideal exists

Definition at line 38 of file groebnerCone.h.


The documentation for this class was generated from the following files:
tropicalStrategy::pReduce
void pReduce(ideal I, const ring r) const
Definition: tropicalStrategy.cc:430
toString
std::string toString(const gfan::ZCone *const c)
Definition: bbcone.cc:27
groebnerCone::polynomialRing
ring polynomialRing
ring in which the ideal exists
Definition: groebnerCone.h:38
tropicalStrategy::restrictToLowerHalfSpace
bool restrictToLowerHalfSpace() const
returns true, if valuation non-trivial, false otherwise
Definition: tropicalStrategy.h:238
j
int j
Definition: facHensel.cc:105
groebnerCones
std::set< groebnerCone, groebnerCone_compare > groebnerCones
Definition: groebnerCone.h:23
interiorPointsAndNormalsOfFacets
std::pair< gfan::ZMatrix, gfan::ZMatrix > interiorPointsAndNormalsOfFacets(const gfan::ZCone zc, const std::set< gfan::ZVector > &exceptThesePoints, const bool onlyLowerHalfSpace)
Definition: bbcone.cc:1902
tropicalStrategy::reduce
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 ...
Definition: tropicalStrategy.cc:416
groebnerCone::interiorPoint
gfan::ZVector interiorPoint
Definition: groebnerCone.h:40
g
g
Definition: cfModGcd.cc:4031
sign
static int sign(int x)
Definition: ring.cc:3346
groebnerCone::pointsOutwards
bool pointsOutwards(const gfan::ZVector) const
Definition: groebnerCone.cc:428
initial
poly initial(const poly p, const ring r, const gfan::ZVector &w)
Returns the initial form of p with respect to w.
Definition: initial.cc:30
tropicalStrategy::checkInitialIdealForMonomial
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...
Definition: tropicalStrategy.cc:494
checkPolyhedralInput
bool checkPolyhedralInput(const gfan::ZCone zc, const gfan::ZVector p)
Definition: tropicalDebug.cc:117
w
const CanonicalForm & w
Definition: facAbsFact.cc:55
b
CanonicalForm b
Definition: cfModGcd.cc:4044
checkWeightVector
bool checkWeightVector(const ideal I, const ring r, const gfan::ZVector &weightVector, bool checkBorder)
Definition: tropicalDebug.cc:74
intStar2ZVector
gfan::ZVector intStar2ZVector(const int d, const int *i)
Definition: callgfanlib_conversion.cc:86
rVar
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:582
i
int i
Definition: cfEzgcd.cc:125
id_Delete
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
Definition: simpleideals.cc:114
omFreeSize
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
groebnerCone::getPolynomialIdeal
ideal getPolynomialIdeal() const
Definition: groebnerCone.h:62
expvToZVector
gfan::ZVector expvToZVector(const int n, const int *expv)
Definition: callgfanlib_conversion.cc:94
groebnerCone::currentStrategy
const tropicalStrategy * currentStrategy
Definition: groebnerCone.h:41
groebnerCone::getPolynomialRing
ring getPolynomialRing() const
Definition: groebnerCone.h:63
pIter
#define pIter(p)
Definition: monomials.h:38
omAlloc
#define omAlloc(size)
Definition: omAllocDecl.h:210
p_GetExpV
static void p_GetExpV(poly p, int *ev, const ring r)
Definition: p_polys.h:1457
groebnerCone::polyhedralCone
gfan::ZCone polyhedralCone
Definition: groebnerCone.h:39
inequalities
BOOLEAN inequalities(leftv res, leftv args)
Definition: bbcone.cc:560
wDeg
long wDeg(const poly p, const ring r, const gfan::ZVector &w)
various functions to compute the initial form of polynomials and ideals
Definition: initial.cc:6
checkOrderingAndCone
bool checkOrderingAndCone(const ring r, const gfan::ZCone zc)
Definition: tropicalDebug.cc:90
groebnerCone
Definition: groebnerCone.h:28
rDelete
void rDelete(ring r)
unconditionally deletes fields in r
Definition: ring.cc:437
groebnerCone::checkFlipConeInput
bool checkFlipConeInput(const gfan::ZVector interiorPoint, const gfan::ZVector facetNormal) const
Debug tools.
Definition: groebnerCone.cc:23
p_Delete
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:858
checkPolynomialInput
bool checkPolynomialInput(const ideal I, const ring r)
Definition: tropicalDebug.cc:110
assume
#define assume(x)
Definition: mod2.h:390
NULL
#define NULL
Definition: omList.c:10
groebnerCone::getTropicalStrategy
const tropicalStrategy * getTropicalStrategy() const
Definition: groebnerCone.h:66
R
#define R
Definition: sirandom.c:26
equations
BOOLEAN equations(leftv res, leftv args)
Definition: bbcone.cc:577
groebnerCone::flipCone
groebnerCone flipCone(const gfan::ZVector &interiorPoint, const gfan::ZVector &facetNormal) const
Given an interior point on the facet and the outer normal factor on the facet, returns the adjacent g...
Definition: groebnerCone.cc:383
v
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
groebnerCone::getInteriorPoint
gfan::ZVector getInteriorPoint() const
Definition: groebnerCone.h:65
groebnerCone::polynomialIdeal
ideal polynomialIdeal
ideal to which this Groebner cone belongs to
Definition: groebnerCone.h:34
s
const CanonicalForm int s
Definition: facAbsFact.cc:55
IDELEMS
#define IDELEMS(i)
Definition: simpleideals.h:26
id_Copy
ideal id_Copy(ideal h1, const ring r)
copy an ideal
Definition: simpleideals.cc:404
interiorPointsOfFacets
gfan::ZMatrix interiorPointsOfFacets(const gfan::ZCone &zc, const std::set< gfan::ZVector > &exceptThese)
Definition: bbcone.cc:1848
raysOfTropicalStar
gfan::ZMatrix raysOfTropicalStar(ideal I, const ring r, const gfan::ZVector &u, const tropicalStrategy *currentStrategy)
Definition: tropicalCurves.cc:243
rCopy
ring rCopy(ring r)
Definition: ring.cc:1620
tropicalStrategy::computeFlip
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
Definition: tropicalStrategy.cc:760
groebnerCone::getPolyhedralCone
gfan::ZCone getPolyhedralCone() const
Definition: groebnerCone.h:64