All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Functions
tropicalCurves.cc File Reference
#include <gfanlib/gfanlib_matrix.h>
#include <gfanlib/gfanlib_zcone.h>
#include <polys/monomials/p_polys.h>
#include <callgfanlib_conversion.h>
#include <std_wrapper.h>
#include <containsMonomial.h>
#include <initial.h>
#include <witness.h>
#include <tropicalStrategy.h>
#include <tropicalVarietyOfPolynomials.h>
#include <tropicalCurves.h>
#include <set>
#include <bbfan.h>

Go to the source code of this file.

Functions

static ZConesSortedByDimension intersect (const ZConesSortedByDimension &setA, const ZConesSortedByDimension &setB, int d=0)
 
static ring genericlyWeightedOrdering (const ring r, const gfan::ZVector &u, const gfan::ZVector &w, const gfan::ZMatrix &W, const tropicalStrategy *currentStrategy)
 
ZConesSortedByDimension tropicalStar (ideal inI, const ring r, const gfan::ZVector &u, const tropicalStrategy *currentStrategy)
 
gfan::ZMatrix raysOfTropicalStar (ideal I, const ring r, const gfan::ZVector &u, const tropicalStrategy *currentStrategy)
 
BOOLEAN tropicalStarDebug (leftv res, leftv args)
 

Function Documentation

static ring genericlyWeightedOrdering ( const ring  r,
const gfan::ZVector &  u,
const gfan::ZVector &  w,
const gfan::ZMatrix &  W,
const tropicalStrategy *  currentStrategy 
)
static

Definition at line 53 of file tropicalCurves.cc.

55 {
56  int n = rVar(r);
57  int h = W.getHeight();
58 
59  /* create a copy s of r and delete its ordering */
60  ring s = rCopy0(r);
61  omFree(s->order);
62  s->order = (int*) omAlloc0((h+4)*sizeof(int));
63  omFree(s->block0);
64  s->block0 = (int*) omAlloc0((h+4)*sizeof(int));
65  omFree(s->block1);
66  s->block1 = (int*) omAlloc0((h+4)*sizeof(int));
67  for (int j=0; s->wvhdl[j]; j++) omFree(s->wvhdl[j]);
68  omFree(s->wvhdl);
69  s->wvhdl = (int**) omAlloc0((h+4)*sizeof(int*));
70 
71  /* construct a new ordering as describe above */
72  bool overflow = false;
73  s->order[0] = ringorder_a;
74  s->block0[0] = 1;
75  s->block1[0] = n;
76  gfan::ZVector uAdjusted = currentStrategy->adjustWeightForHomogeneity(u);
77  s->wvhdl[0] = ZVectorToIntStar(uAdjusted,overflow);
78  s->order[1] = ringorder_a;
79  s->block0[1] = 1;
80  s->block1[1] = n;
81  gfan::ZVector wAdjusted = currentStrategy->adjustWeightUnderHomogeneity(w,uAdjusted);
82  s->wvhdl[1] = ZVectorToIntStar(wAdjusted,overflow);
83  for (int j=0; j<h-1; j++)
84  {
85  s->order[j+2] = ringorder_a;
86  s->block0[j+2] = 1;
87  s->block1[j+2] = n;
88  wAdjusted = currentStrategy->adjustWeightUnderHomogeneity(W[j],uAdjusted);
89  s->wvhdl[j+2] = ZVectorToIntStar(wAdjusted,overflow);
90  }
91  s->order[h+1] = ringorder_wp;
92  s->block0[h+1] = 1;
93  s->block1[h+1] = n;
94  wAdjusted = currentStrategy->adjustWeightUnderHomogeneity(W[h-1],uAdjusted);
95  s->wvhdl[h+1] = ZVectorToIntStar(wAdjusted,overflow);
96  s->order[h+2] = ringorder_C;
97 
98  if (overflow)
99  {
100  WerrorS("genericlyWeightedOrdering: overflow in weight vector");
101  throw 0; // weightOverflow;
102  }
103 
104  /* complete the ring and return it */
105  rComplete(s);
106  rTest(s);
107  return s;
108 }
s
const CanonicalForm int s
Definition: facAbsFact.cc:55
n
const CanonicalForm CFMap CFMap int &both_non_zero int n
Definition: cfEzgcd.cc:52
rVar
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:580
ZVectorToIntStar
int * ZVectorToIntStar(const gfan::ZVector &v, bool &overflow)
Definition: callgfanlib_conversion.cc:114
WerrorS
void WerrorS(const char *s)
Definition: feFopen.cc:24
r
const ring r
Definition: syzextra.cc:208
rComplete
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...
Definition: ring.cc:3435
j
int j
Definition: myNF.cc:70
omFree
#define omFree(addr)
Definition: omAllocDecl.h:261
rCopy0
ring rCopy0(const ring r, BOOLEAN copy_qideal, BOOLEAN copy_ordering)
Definition: ring.cc:1321
rTest
#define rTest(r)
Definition: ring.h:775
tropicalStrategy::adjustWeightUnderHomogeneity
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...
Definition: tropicalStrategy.h:264
tropicalStrategy::adjustWeightForHomogeneity
gfan::ZVector adjustWeightForHomogeneity(gfan::ZVector w) const
Given weight w, returns a strictly positive weight u such that an ideal satisfying the valuation-sepc...
Definition: tropicalStrategy.h:254
w
const CanonicalForm & w
Definition: facAbsFact.cc:55
h
static Poly * h
Definition: janet.cc:978
omAlloc0
#define omAlloc0(size)
Definition: omAllocDecl.h:211
static ZConesSortedByDimension intersect ( const ZConesSortedByDimension &  setA,
const ZConesSortedByDimension &  setB,
int  d = 0 
)
static

Definition at line 22 of file tropicalCurves.cc.

25 {
26  if (setA.empty())
27  return setB;
28  if (setB.empty())
29  return setA;
30  ZConesSortedByDimension setAB;
31  for (ZConesSortedByDimension::iterator coneOfA=setA.begin(); coneOfA!=setA.end(); coneOfA++)
32  {
33  for (ZConesSortedByDimension::iterator coneOfB=setB.begin(); coneOfB!=setB.end(); coneOfB++)
34  {
35  gfan::ZCone coneOfIntersection = gfan::intersection(*coneOfA,*coneOfB);
36  if (coneOfIntersection.dimension()>=d)
37  {
38  coneOfIntersection.canonicalize();
39  setAB.insert(coneOfIntersection);
40  }
41  }
42  }
43  return setAB;
44 }
ZConesSortedByDimension
std::set< gfan::ZCone, ZConeCompareDimensionFirst > ZConesSortedByDimension
Definition: tropicalVarietyOfPolynomials.h:28
gfan::ZMatrix raysOfTropicalStar ( ideal  I,
const ring  r,
const gfan::ZVector &  u,
const tropicalStrategy *  currentStrategy 
)

Definition at line 250 of file tropicalCurves.cc.

251 {
252  ZConesSortedByDimension C = tropicalStar(I,r,u,currentStrategy);
253  // gfan::ZFan* zf = toFanStar(C);
254  // std::cout << zf->toString();
255  // delete zf;
256  gfan::ZMatrix raysOfC(0,u.size());
257  if (!currentStrategy->restrictToLowerHalfSpace())
258  {
259  for (ZConesSortedByDimension::iterator zc=C.begin(); zc!=C.end(); zc++)
260  {
261  assume(zc->dimensionOfLinealitySpace()+1 >= zc->dimension());
262  if (zc->dimensionOfLinealitySpace()+1 >= zc->dimension())
263  raysOfC.appendRow(zc->getRelativeInteriorPoint());
264  else
265  {
266  gfan::ZVector interiorPoint = zc->getRelativeInteriorPoint();
267  if (!currentStrategy->homogeneitySpaceContains(interiorPoint))
268  {
269  raysOfC.appendRow(interiorPoint);
270  raysOfC.appendRow(currentStrategy->negateWeight(interiorPoint));
271  }
272  else
273  {
274  gfan::ZMatrix zm = zc->generatorsOfLinealitySpace();
275  for (int i=0; i<zm.getHeight(); i++)
276  {
277  gfan::ZVector point = zm[i];
278  if (currentStrategy->homogeneitySpaceContains(point))
279  {
280  raysOfC.appendRow(point);
281  raysOfC.appendRow(currentStrategy->negateWeight(point));
282  break;
283  }
284  }
285  }
286  }
287  }
288  }
289  else
290  {
291  for (ZConesSortedByDimension::iterator zc=C.begin(); zc!=C.end(); zc++)
292  {
293  assume(zc->dimensionOfLinealitySpace()+2 >= zc->dimension());
294  if (zc->dimensionOfLinealitySpace()+2 == zc->dimension())
295  raysOfC.appendRow(zc->getRelativeInteriorPoint());
296  else
297  {
298  gfan::ZVector interiorPoint = zc->getRelativeInteriorPoint();
299  if (!currentStrategy->homogeneitySpaceContains(interiorPoint))
300  {
301  raysOfC.appendRow(interiorPoint);
302  raysOfC.appendRow(currentStrategy->negateWeight(interiorPoint));
303  }
304  else
305  {
306  gfan::ZMatrix zm = zc->generatorsOfLinealitySpace();
307  for (int i=0; i<zm.getHeight(); i++)
308  {
309  gfan::ZVector point = zm[i];
310  if (currentStrategy->homogeneitySpaceContains(point))
311  {
312  raysOfC.appendRow(point);
313  raysOfC.appendRow(currentStrategy->negateWeight(point));
314  break;
315  }
316  }
317  }
318  }
319  }
320  }
321  return raysOfC;
322 }
tropicalStrategy::negateWeight
gfan::ZVector negateWeight(const gfan::ZVector &w) const
Definition: tropicalStrategy.h:269
r
const ring r
Definition: syzextra.cc:208
ZConesSortedByDimension
std::set< gfan::ZCone, ZConeCompareDimensionFirst > ZConesSortedByDimension
Definition: tropicalVarietyOfPolynomials.h:28
assume
#define assume(x)
Definition: mod2.h:403
tropicalStrategy::homogeneitySpaceContains
bool homogeneitySpaceContains(const gfan::ZVector &v) const
returns true, if v is contained in the homogeneity space; false otherwise
Definition: tropicalStrategy.h:236
i
int i
Definition: cfEzgcd.cc:123
tropicalStrategy::restrictToLowerHalfSpace
bool restrictToLowerHalfSpace() const
returns true, if valuation non-trivial, false otherwise
Definition: tropicalStrategy.h:244
tropicalStar
ZConesSortedByDimension tropicalStar(ideal inI, const ring r, const gfan::ZVector &u, const tropicalStrategy *currentStrategy)
Definition: tropicalCurves.cc:116
ZConesSortedByDimension tropicalStar ( ideal  inI,
const ring  r,
const gfan::ZVector &  u,
const tropicalStrategy *  currentStrategy 
)

Definition at line 116 of file tropicalCurves.cc.

118 {
119  int k = IDELEMS(inI);
120  int d = currentStrategy->getExpectedDimension();
121 
122  /* Compute the common refinement over all tropical varieties
123  * of the polynomials in the generating set */
124  ZConesSortedByDimension C = tropicalVarietySortedByDimension(inI->m[0],r,currentStrategy);
125  for (int i=1; i<k; i++)
126  {
127  if(inI->m[i]!=NULL)
128  {
129  C = intersect(C,tropicalVarietySortedByDimension(inI->m[i],r,currentStrategy),d);
130  }
131  }
132 
133  /* Cycle through all maximal cones of the refinement.
134  * Pick a monomial ordering corresponding to a generic weight vector in it
135  * and check if the initial ideal is monomial free, generic meaning
136  * that it lies in a maximal Groebner cone in the maximal cone of the refinement.
137  * If the initial ideal is not monomial free, compute a witness for the monomial
138  * and compute the common refinement with its tropical variety.
139  * If all initial ideals are monomial free, then we have our tropical curve */
140  // gfan::ZFan* zf = toFanStar(C);
141  // std::cout << zf->toString(2+4+8+128) << std::endl;
142  // delete zf;
143  for (std::set<gfan::ZCone>::iterator zc=C.begin(); zc!=C.end();)
144  {
145  gfan::ZVector w = zc->getRelativeInteriorPoint();
146  gfan::ZMatrix W = zc->generatorsOfSpan();
147  // std::cout << zc->extremeRays() << std::endl;
148 
149  ring s = genericlyWeightedOrdering(r,u,w,W,currentStrategy);
150  nMapFunc identity = n_SetMap(r->cf,s->cf);
151  ideal inIs = idInit(k);
152  for (int j=0; j<k; j++)
153  inIs->m[j] = p_PermPoly(inI->m[j],NULL,r,s,identity,NULL,0);
154 
155  ideal inIsSTD = gfanlib_kStd_wrapper(inIs,s,isHomog);
156  id_Delete(&inIs,s);
157  ideal ininIs = initial(inIsSTD,s,w,W);
158 
159  std::pair<poly,int> mons = currentStrategy->checkInitialIdealForMonomial(ininIs,s);
160 
161  if (mons.first!=NULL)
162  {
163  poly gs;
164  if (mons.second>=0)
165  // cheap way out, ininIsSTD already contains a monomial in its generators
166  gs = inIsSTD->m[mons.second];
167  else
168  // compute witness
169  gs = witness(mons.first,inIsSTD,ininIs,s);
170 
171  C = intersect(C,tropicalVarietySortedByDimension(gs,s,currentStrategy),d);
172  nMapFunc mMap = n_SetMap(s->cf,r->cf);
173  poly gr = p_PermPoly(gs,NULL,s,r,mMap,NULL,0);
174  idInsertPoly(inI,gr);
175  k++;
176 
177  if (mons.second<0)
178  {
179  // if necessary, cleanup mons and gs
180  p_Delete(&mons.first,s);
181  p_Delete(&gs,s);
182  }
183  // cleanup rest, reset zc
184  id_Delete(&inIsSTD,s);
185  id_Delete(&ininIs,s);
186  rDelete(s);
187  zc = C.begin();
188  }
189  else
190  {
191  // cleanup remaining data of first stage
192  id_Delete(&inIsSTD,s);
193  id_Delete(&ininIs,s);
194  rDelete(s);
195 
196  gfan::ZVector wNeg = currentStrategy->negateWeight(w);
197  if (zc->contains(wNeg))
198  {
199  s = genericlyWeightedOrdering(r,u,wNeg,W,currentStrategy);
200  identity = n_SetMap(r->cf,s->cf);
201  inIs = idInit(k);
202  for (int j=0; j<k; j++)
203  inIs->m[j] = p_PermPoly(inI->m[j],NULL,r,s,identity,NULL,0);
204 
205  inIsSTD = gfanlib_kStd_wrapper(inIs,s,isHomog);
206  id_Delete(&inIs,s);
207  ininIs = initial(inIsSTD,s,wNeg,W);
208 
209  mons = currentStrategy->checkInitialIdealForMonomial(ininIs,s);
210  if (mons.first!=NULL)
211  {
212  poly gs;
213  if (mons.second>=0)
214  // cheap way out, ininIsSTD already contains a monomial in its generators
215  gs = inIsSTD->m[mons.second];
216  else
217  // compute witness
218  gs = witness(mons.first,inIsSTD,ininIs,s);
219 
220  C = intersect(C,tropicalVarietySortedByDimension(gs,s,currentStrategy),d);
221  nMapFunc mMap = n_SetMap(s->cf,r->cf);
222  poly gr = p_PermPoly(gs,NULL,s,r,mMap,NULL,0);
223  idInsertPoly(inI,gr);
224  k++;
225 
226  if (mons.second<0)
227  {
228  // if necessary, cleanup mons and gs
229  p_Delete(&mons.first,s);
230  p_Delete(&gs,s);
231  }
232  // reset zc
233  zc = C.begin();
234  }
235  else
236  zc++;
237  // cleanup remaining data of second stage
238  id_Delete(&inIsSTD,s);
239  id_Delete(&ininIs,s);
240  rDelete(s);
241  }
242  else
243  zc++;
244  }
245  }
246  return C;
247 }
s
const CanonicalForm int s
Definition: facAbsFact.cc:55
genericlyWeightedOrdering
static ring genericlyWeightedOrdering(const ring r, const gfan::ZVector &u, const gfan::ZVector &w, const gfan::ZMatrix &W, const tropicalStrategy *currentStrategy)
Definition: tropicalCurves.cc:53
tropicalVarietySortedByDimension
ZConesSortedByDimension tropicalVarietySortedByDimension(const poly g, const ring r, const tropicalStrategy *currentCase)
Definition: tropicalVarietyOfPolynomials.cc:63
id_Delete
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
Definition: simpleideals.cc:115
k
int k
Definition: cfEzgcd.cc:93
tropicalStrategy::negateWeight
gfan::ZVector negateWeight(const gfan::ZVector &w) const
Definition: tropicalStrategy.h:269
tropicalStrategy::getExpectedDimension
int getExpectedDimension() const
returns the expected Dimension of the polyhedral output
Definition: tropicalStrategy.h:205
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:32
r
const ring r
Definition: syzextra.cc:208
p_PermPoly
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)
Definition: p_polys.cc:3939
ZConesSortedByDimension
std::set< gfan::ZCone, ZConeCompareDimensionFirst > ZConesSortedByDimension
Definition: tropicalVarietyOfPolynomials.h:28
j
int j
Definition: myNF.cc:70
gfanlib_kStd_wrapper
ideal gfanlib_kStd_wrapper(ideal I, ring r, tHomog h=testHomog)
Definition: std_wrapper.cc:5
idInsertPoly
BOOLEAN idInsertPoly(ideal h1, poly h2)
insert h2 into h1 (if h2 is not the zero polynomial) return TRUE iff h2 was indeed inserted ...
Definition: simpleideals.cc:638
intersect
static ZConesSortedByDimension intersect(const ZConesSortedByDimension &setA, const ZConesSortedByDimension &setB, int d=0)
Definition: tropicalCurves.cc:22
i
int i
Definition: cfEzgcd.cc:123
IDELEMS
#define IDELEMS(i)
Definition: simpleideals.h:24
n_SetMap
static FORCE_INLINE nMapFunc n_SetMap(const coeffs src, const coeffs dst)
set the mapping function pointers for translating numbers from src to dst
Definition: coeffs.h:725
p_Delete
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:843
idInit
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:38
NULL
#define NULL
Definition: omList.c:10
witness
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.
Definition: witness.cc:34
rDelete
void rDelete(ring r)
unconditionally deletes fields in r
Definition: ring.cc:448
nMapFunc
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition: coeffs.h:73
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:485
w
const CanonicalForm & w
Definition: facAbsFact.cc:55
poly
polyrec * poly
Definition: hilb.h:10
BOOLEAN tropicalStarDebug ( leftv  res,
leftv  args 
)

Definition at line 330 of file tropicalCurves.cc.

331 {
332  leftv u = args;
333  if ((u!=NULL) && (u->Typ()==IDEAL_CMD))
334  {
335  leftv v = u->next;
336  if ((v!=NULL) && (v->Typ()==BIGINTMAT_CMD))
337  {
338  omUpdateInfo();
339  Print("usedBytesBefore=%ld\n",om_Info.UsedBytes);
340  ideal inI = (ideal) u->CopyD();
341  bigintmat* u = (bigintmat*) v->CopyD();
342  tropicalStrategy currentCase(inI,currRing);
343  gfan::ZVector* v = bigintmatToZVector(u);
344  ZConesSortedByDimension C = tropicalStar(inI,currRing,*v,&currentCase);
345  id_Delete(&inI,currRing);
346  delete u;
347  delete v;
348  res->rtyp = NONE;
349  res->data = NULL;
350  // res->rtyp = fanID;
351  // res->data = (char*) toFanStar(C);
352  return FALSE;
353  }
354  }
355  WerrorS("tropicalStarDebug: unexpected parameters");
356  return TRUE;
357 }
sleftv
Class used for (list of) interpreter objects.
Definition: subexpr.h:84
Print
#define Print
Definition: emacs.cc:83
FALSE
#define FALSE
Definition: auxiliary.h:97
bigintmat
Matrices of numbers.
Definition: bigintmat.h:51
id_Delete
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
Definition: simpleideals.cc:115
TRUE
#define TRUE
Definition: auxiliary.h:101
WerrorS
void WerrorS(const char *s)
Definition: feFopen.cc:24
sleftv::Typ
int Typ()
Definition: subexpr.cc:979
sleftv::data
void * data
Definition: subexpr.h:90
currRing
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:10
ZConesSortedByDimension
std::set< gfan::ZCone, ZConeCompareDimensionFirst > ZConesSortedByDimension
Definition: tropicalVarietyOfPolynomials.h:28
om_Info
omInfo_t om_Info
Definition: omStats.c:13
sleftv::next
leftv next
Definition: subexpr.h:88
tropicalStar
ZConesSortedByDimension tropicalStar(ideal inI, const ring r, const gfan::ZVector &u, const tropicalStrategy *currentStrategy)
Definition: tropicalCurves.cc:116
v
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
NULL
#define NULL
Definition: omList.c:10
omUpdateInfo
void omUpdateInfo()
Definition: omStats.c:24
sleftv::rtyp
int rtyp
Definition: subexpr.h:93
NONE
#define NONE
Definition: tok.h:216
sleftv::CopyD
void * CopyD(int t)
Definition: subexpr.cc:679
bigintmatToZVector
gfan::ZVector * bigintmatToZVector(const bigintmat &bim)
Definition: callgfanlib_conversion.cc:76
Generated on Mon Mar 6 2017 11:17:39 by   doxygen 1.8.8 for Singular debian-1:4.0.3-p3+ds-5~bpo8+1