Changeset 9abcc6 in git

Timestamp:

Mar 12, 2014, 9:08:50 AM (10 years ago)

Author:

Yue Ren <ren@…>

Branches:

(u'spielwiese', '8e0ad00ce244dfd0756200662572aef8402f13d5')

Children:

7aa26b206f76709abff0bab4adaac2dfc4ddb4ef

Parents:

c890142d6921b9d30b396af149a3df2fbc57981a

git-author:

Yue Ren <ren@mathematik.uni-kl.de>2014-03-12 10:08:50+02:00

git-committer:

Yue Ren <ren@mathematik.uni-kl.de>2015-02-06 13:47:03+01:00

Message:

status updated 11.03.

Files:

• Singular/dyn_modules/gfanlib/Makefile.am (modified) (1 diff)
• Singular/dyn_modules/gfanlib/bbfan.cc (modified) (3 diffs)
• Singular/dyn_modules/gfanlib/groebnerCone.cc (modified) (3 diffs)
• Singular/dyn_modules/gfanlib/groebnerCone.h (modified) (3 diffs)
• Singular/dyn_modules/gfanlib/neighbours.cc (modified) (7 diffs)
• Singular/dyn_modules/gfanlib/neighbours.h (modified) (1 diff)
• Singular/dyn_modules/gfanlib/startingCone.cc (modified) (4 diffs)
• Singular/dyn_modules/gfanlib/startingCone.h (modified) (1 diff)
• Singular/dyn_modules/gfanlib/tropical.cc (modified) (2 diffs)
• Singular/dyn_modules/gfanlib/tropicalCurves.cc (modified) (1 diff)
• Singular/dyn_modules/gfanlib/witness.cc (modified) (4 diffs)
• Singular/dyn_modules/gfanlib/witness.h (modified) (1 diff)
• dyn_modules/callgfanlib/adjustPolysAndIdeals.cc (added)
• dyn_modules/callgfanlib/tropicalVariety.cc (added)
• dyn_modules/callgfanlib/tropicalVariety.h (added)
• dyn_modules/callgfanlib/tropicalVarietyOfIdeals.cc (added)
• dyn_modules/callgfanlib/tropicalVarietyOfIdeals.h (added)

Singular/dyn_modules/gfanlib/Makefile.am

@@ -1 +1 @@
 ACLOCAL_AMFLAGS = -I ../../m4
 
-SOURCES = gfanlib_exceptions.h callgfanlib_conversion.cc callgfanlib_conversion.h bbcone.cc bbcone.h bbfan.cc bbfan.h bbpolytope.cc bbpolytope.h gfan.h gitfan.cc gitfan.h tropicalVarietyOfPolynomials.h tropicalVarietyOfPolynomials.cc ppinitialReduction.cc ppinitialReduction.h ttinitialReduction.cc ttinitialReduction.h containsMonomial.cc containsMonomial.h adjustWeights.cc adjustWeights.h tropicalStrategy.cc tropicalStrategy.h initial.cc initial.h witness.cc witness.h tropicalCurves.cc tropicalCurves.h groebnerCone.cc groebnerCone.h neighbours.cc neighbours.h startingCone.cc startingCone.h tropical.cc tropical.h gfanlib.cc
+SOURCES = gfanlib_exceptions.h callgfanlib_conversion.cc callgfanlib_conversion.h bbcone.cc bbcone.h bbfan.cc bbfan.h bbpolytope.cc bbpolytope.h gfan.h gitfan.cc gitfan.h tropicalVarietyOfPolynomials.h tropicalVarietyOfPolynomials.cc ppinitialReduction.cc ppinitialReduction.h ttinitialReduction.cc ttinitialReduction.h containsMonomial.cc containsMonomial.h adjustWeights.cc adjustWeights.h tropicalStrategy.cc tropicalStrategy.h initial.cc initial.h witness.cc witness.h tropicalCurves.cc tropicalCurves.h groebnerCone.cc groebnerCone.h neighbours.cc neighbours.h startingCone.cc startingCone.h tropicalVarietyOfIdeals.cc tropicalVarietyOfIdeals.h tropicalVariety.cc tropicalVariety.h tropical.cc tropical.h gfanlib.cc
+
 
 MY_CPPFLAGS =  -I${top_srcdir} -I${top_builddir} \

Singular/dyn_modules/gfanlib/bbfan.cc

@@ -40 +40 @@
     std::string s = zf->toString(2+4+8+128);
     return omStrDup(s.c_str());
+// =======
+//     std::stringstream s;
+//     std::string raysAndCones = zf->toStringJustRaysAndMaximalCones();
+//     s << raysAndCones;
+//     if (zf->getDimension() >= 0) // <=> zf is not empty
+//     {
+//       assert(zf->numberOfConesOfDimension(zf->getDimension()-zf->getLinealityDimension(),0,0));
+//       gfan::ZCone zc = zf->getCone(zf->getDimension()-zf->getLinealityDimension(),0,0,0);
+//       gfan::ZMatrix genLinSpace = zc.generatorsOfLinealitySpace();
+//       char* gens = toString(genLinSpace);
+//       s << std::endl << "GENERATORS_LINEALITY_SPACE:" << std::endl;
+//       s << gens;
+//     }
+//     std::string sstring = s.str();
+//     return omStrDup(sstring.c_str());
+// >>>>>>> status updated 11.03.
   }
 }
@@ -858 +874 @@
 
 
-BOOLEAN tropicalVariety(leftv res, leftv args)
-{
-  leftv u=args;
-  if ((u != NULL) && (u->Typ() == POLY_CMD))
-  {
-    int n = rVar(currRing);
-    gfan::ZFan* zf = new gfan::ZFan(n);
-    int* expv1 = (int*)omAlloc((n+1)*sizeof(int));
-    int* expv2 = (int*)omAlloc((n+1)*sizeof(int));
-    int* expvr = (int*)omAlloc((n+1)*sizeof(int));
-    gfan::ZVector expw1 = gfan::ZVector(n);
-    gfan::ZVector expw2 = gfan::ZVector(n);
-    gfan::ZVector expwr = gfan::ZVector(n);
-    gfan::ZMatrix eq, ineq;
-    for (poly s1=(poly)u->Data(); s1!=NULL; pIter(s1))
-    {
-      pGetExpV(s1,expv1);
-      expw1 = intStar2ZVector(n,expv1);
-      for (poly s2=pNext(s1); s2!=NULL; pIter(s2))
-      {
-        pGetExpV(s2,expv2);
-        expw2 = intStar2ZVector(n,expv2);
-        eq = gfan::ZMatrix(0,n);
-        eq.appendRow(expw1-expw2);
-        ineq = gfan::ZMatrix(0,n);
-        for (poly r=(poly)u->Data(); r!=NULL; pIter(r))
-        {
-          pGetExpV(r,expvr);
-          expwr = intStar2ZVector(n,expvr);
-          if ((r!=s1) && (r!=s2))
-          {
-            ineq.appendRow(expw1-expwr);
-          }
-        }
-        gfan::ZCone zc = gfan::ZCone(ineq,eq);
-        zf->insert(zc);
-      }
-    }
-    omFreeSize(expv1,(n+1)*sizeof(int));
-    omFreeSize(expv2,(n+1)*sizeof(int));
-    omFreeSize(expvr,(n+1)*sizeof(int));
-    res->rtyp = fanID;
-    res->data = (void*) zf;
-    return FALSE;
-  }
-  WerrorS("tropicalVariety: unexpected parameters");
-  return TRUE;
-}
+// BOOLEAN tropicalVariety(leftv res, leftv args)
+// {
+//   leftv u=args;
+//   if ((u != NULL) && (u->Typ() == POLY_CMD))
+//   {
+//     int n = rVar(currRing);
+//     gfan::ZFan* zf = new gfan::ZFan(n);
+//     int* expv1 = (int*)omAlloc((n+1)*sizeof(int));
+//     int* expv2 = (int*)omAlloc((n+1)*sizeof(int));
+//     int* expvr = (int*)omAlloc((n+1)*sizeof(int));
+//     gfan::ZVector expw1 = gfan::ZVector(n);
+//     gfan::ZVector expw2 = gfan::ZVector(n);
+//     gfan::ZVector expwr = gfan::ZVector(n);
+//     gfan::ZMatrix eq, ineq;
+//     for (poly s1=(poly)u->Data(); s1!=NULL; pIter(s1))
+//     {
+//       pGetExpV(s1,expv1);
+//       expw1 = intStar2ZVector(n,expv1);
+//       for (poly s2=pNext(s1); s2!=NULL; pIter(s2))
+//       {
+//         pGetExpV(s2,expv2);
+//         expw2 = intStar2ZVector(n,expv2);
+//         eq = gfan::ZMatrix(0,n);
+//         eq.appendRow(expw1-expw2);
+//         ineq = gfan::ZMatrix(0,n);
+//         for (poly r=(poly)u->Data(); r!=NULL; pIter(r))
+//         {
+//           pGetExpV(r,expvr);
+//           expwr = intStar2ZVector(n,expvr);
+//           if ((r!=s1) && (r!=s2))
+//           {
+//             ineq.appendRow(expw1-expwr);
+//           }
+//         }
+//         gfan::ZCone zc = gfan::ZCone(ineq,eq);
+//         zf->insert(zc);
+//       }
+//     }
+//     omFreeSize(expv1,(n+1)*sizeof(int));
+//     omFreeSize(expv2,(n+1)*sizeof(int));
+//     omFreeSize(expvr,(n+1)*sizeof(int));
+//     res->rtyp = fanID;
+//     res->data = (void*) zf;
+//     return FALSE;
+//   }
+//   WerrorS("tropicalVariety: unexpected parameters");
+//   return TRUE;
+// }
 
 gfan::ZFan commonRefinement(gfan::ZFan zf, gfan::ZFan zg)
@@ -1038 +1054 @@
   p->iiAddCproc("","fVector",FALSE,fVector);
   p->iiAddCproc("","containsInCollection",FALSE,containsInCollection);
-  p->iiAddCproc("","tropicalVariety",FALSE,tropicalVariety);
+  // p->iiAddCproc("","tropicalVariety",FALSE,tropicalVariety);
   p->iiAddCproc("","commonRefinement",FALSE,commonRefinement);
   // iiAddCproc("","grFan",FALSE,grFan);

Singular/dyn_modules/gfanlib/groebnerCone.cc

@@ -1 @@
-#include <kernel/polys.h>
+#include <kernel/kstd1.h>
+#include <kernel/ideals.h>
 #include <Singular/ipid.h>
 
+#include <libpolys/polys/monomials/p_polys.h>
 #include <libpolys/polys/monomials/ring.h>
-#include <kernel/ideals.h>
+#include <libpolys/polys/prCopy.h>
+
 #include <gfanlib/gfanlib.h>
 
@@ -95 +98 @@
 }
 
-groebnerConeData::groebnerConeData():
-  I(NULL),
-  r(NULL),
-  c(gfan::ZCone(0)),
-  p(gfan::ZVector(0))
-{
-}
-
-groebnerConeData::groebnerConeData(const groebnerConeData &sigma):
-  I(id_Copy(sigma.getIdeal(),sigma.getRing())),
-  r(rCopy(sigma.getRing())),
-  c(gfan::ZCone(sigma.getCone())),
-  p(gfan::ZVector(sigma.getInteriorPoint()))
-{
-}
-
-groebnerConeData::groebnerConeData(const ideal &J, const ring &s, const gfan::ZCone &d, const gfan::ZVector &q):
-  I(J),
-  r(s),
-  c(d),
-  p(q)
-{
-}
-
-groebnerConeData::groebnerConeData(const ideal &J, const ring &s):
-  I(J),
-  r(s)
-{
-}
-
-groebnerConeData::~groebnerConeData()
-{
-  id_Delete(&I,r);
-  rDelete(r);
-}
-
-
-groebnerConeData maximalGroebnerConeData(ideal I, const ring r)
+gfan::ZCone fullGroebnerCone(const ideal &I, const ring &r)
 {
   int n = rVar(r);
@@ -156 +122 @@
   omFreeSize(leadexpv,(n+1)*sizeof(int));
   omFreeSize(tailexpv,(n+1)*sizeof(int));
+  return gfan::ZCone(inequalities,gfan::ZMatrix(0, inequalities.getWidth()));
+}
+
+groebnerConeData::groebnerConeData():
+  I(NULL),
+  r(NULL),
+  c(gfan::ZCone(0)),
+  p(gfan::ZVector(0))
+{
+}
+
+groebnerConeData::groebnerConeData(const groebnerConeData &sigma):
+  I(id_Copy(sigma.getIdeal(),sigma.getRing())),
+  r(rCopy(sigma.getRing())),
+  c(gfan::ZCone(sigma.getCone())),
+  p(gfan::ZVector(sigma.getInteriorPoint()))
+{
+}
+
+groebnerConeData::groebnerConeData(const ideal &J, const ring &s, const gfan::ZCone &d, const gfan::ZVector &q):
+  I(J),
+  r(s),
+  c(d),
+  p(q)
+{
+}
+
+groebnerConeData::~groebnerConeData()
+{
+  // if (I!=NULL) id_Delete(&I,r);
+  // if (r!=NULL) rDelete(r);
+}
+
+
+groebnerConeData maximalGroebnerConeData(ideal I, const ring r)
+{
+  int n = rVar(r);
+  poly g = NULL;
+  int* leadexpv = (int*) omAlloc((n+1)*sizeof(int));
+  int* tailexpv = (int*) omAlloc((n+1)*sizeof(int));
+  gfan::ZVector leadexpw = gfan::ZVector(n);
+  gfan::ZVector tailexpw = gfan::ZVector(n);
+  gfan::ZMatrix inequalities = gfan::ZMatrix(0,n);
+  for (int i=0; i<IDELEMS(I); i++)
+  {
+    g = (poly) I->m[i]; pGetExpV(g,leadexpv);
+    leadexpw = intStar2ZVector(n, leadexpv);
+    pIter(g);
+    while (g != NULL)
+    {
+      pGetExpV(g,tailexpv);
+      tailexpw = intStar2ZVector(n, tailexpv);
+      inequalities.appendRow(leadexpw-tailexpw);
+      pIter(g);
+    }
+  }
+  omFreeSize(leadexpv,(n+1)*sizeof(int));
+  omFreeSize(tailexpv,(n+1)*sizeof(int));
   gfan::ZCone zc = gfan::ZCone(inequalities,gfan::ZMatrix(0, inequalities.getWidth()));
   gfan::ZVector p = zc.getRelativeInteriorPoint();
   return groebnerConeData(I,r,zc,p);
 }
+
+/***
+ * Given a general ring r with any ordering, changes the ordering to wp(-w)
+ **/
+void changeOrderingTo_wp(ring r, const gfan::ZVector w)
+{
+  omFree(r->order);
+  r->order  = (int*) omAlloc0(3*sizeof(int));
+  omFree(r->block0);
+  r->block0 = (int*) omAlloc0(3*sizeof(int));
+  omFree(r->block1);
+  r->block1 = (int*) omAlloc0(3*sizeof(int));
+  for (int i=0; r->wvhdl[i]; i++) omFree(r->wvhdl[i]);
+  omFree(r->wvhdl);
+  r->wvhdl  = (int**) omAlloc0(3*sizeof(int*));
+
+  bool ok = false;
+  r->order[0]  = ringorder_wp;
+  r->block0[0] = 1;
+  r->block1[0] = r->N;
+  r->wvhdl[0]  = ZVectorToIntStar(w,ok);
+  r->order[1]  = ringorder_C;
+  rComplete(r,1);
+}
+
+groebnerConeData::groebnerConeData(const ideal J, const ring s, const gfan::ZVector w)
+{
+  r = rCopy(s);
+  changeOrderingTo_wp(r,w);
+  rChangeCurrRing(r);
+
+  int k = idSize(J); I = idInit(k);
+  nMapFunc identityMap = n_SetMap(s->cf,r->cf);
+  for (int i=0; i<k; i++)
+    I->m[i] = p_PermPoly(J->m[i],NULL,s,r,identityMap,NULL,0);
+  intvec* nullVector = NULL;
+  I = kStd(I,currQuotient,testHomog,&nullVector);
+
+  c = sloppyGroebnerCone(I,r,w);
+  p = c.getRelativeInteriorPoint();
+}
+
+groebnerConeData::groebnerConeData(const ideal J, const ring s, const gfan::ZCone d)
+{
+  c = d;
+  p = d.getRelativeInteriorPoint();
+
+  r = rCopy(s);
+  changeOrderingTo_wp(r,p);
+  rChangeCurrRing(r);
+
+  int k = idSize(J); I = idInit(k);
+  nMapFunc identityMap = n_SetMap(s->cf,r->cf);
+  for (int i=0; i<k; i++)
+    I->m[i] = p_PermPoly(J->m[i],NULL,s,r,identityMap,NULL,0);
+  intvec* nullVector = NULL;
+  I = kStd(I,currQuotient,testHomog,&nullVector);
+}
+
+// /***
+//  * Given a general ring r with any ordering, changes the ordering to a(v),ws(-w)
+//  **/
+// bool changetoAWSRing(ring r, const gfan::ZVector v, const gfan::ZVector w)
+// {
+//   omFree(r->order);
+//   r->order  = (int*) omAlloc0(4*sizeof(int));
+//   omFree(r->block0);
+//   r->block0 = (int*) omAlloc0(4*sizeof(int));
+//   omFree(r->block1);
+//   r->block1 = (int*) omAlloc0(4*sizeof(int));
+//   for (int i=0; r->wvhdl[i]; i++)
+//   { omFree(r->wvhdl[i]); }
+//   omFree(r->wvhdl);
+//   r->wvhdl  = (int**) omAlloc0(4*sizeof(int*));
+
+//   bool ok = false;
+//   r->order[0]  = ringorder_a;
+//   r->block0[0] = 1;
+//   r->block1[0] = r->N;
+//   r->wvhdl[0]  = ZVectorToIntStar(v,ok);
+//   r->order[1]  = ringorder_ws;
+//   r->block0[1] = 1;
+//   r->block1[1] = r->N;
+//   r->wvhdl[1]  = ZVectorToIntStar(w,ok);
+//   r->order[2]  = ringorder_C;
+//   return ok;
+// }
+
+// groebnerConeData::groebnerConeData(const ideal J, const ring s, const gfan::ZVector w)
+// {
+//   r = rCopy(s);
+//   changeOrderingTo_wp(r,w);
+//   rChangeCurrRing(r);
+
+//   int k = idSize(J); I = idInit(k);
+//   nMapFunc identityMap = n_SetMap(s->cf,r->cf);
+//   for (int i=0; i<k; i++)
+//     I->m[i] = p_PermPoly(J->m[i],NULL,s,r,nMap,NULL,0);
+//   intvec* nullVector = NULL;
+//   I = kStd(I,currQuotient,testHomog,&nullVector);
+
+//   c = sloppyGroebnerCone(I,r,w);
+//   p = c.getRelativeInteriorPoint();
+// }
+
+gfan::ZFan* toFanStar(setOfGroebnerConeData setOfCones)
+{
+  if (setOfCones.size() > 0)
+  {
+    setOfGroebnerConeData::iterator cone = setOfCones.begin();
+    gfan::ZFan* zf = new gfan::ZFan(cone->getCone().ambientDimension());
+    for (; cone!=setOfCones.end(); cone++)
+      zf->insert(cone->getCone());
+    return zf;
+  }
+  else
+    return new gfan::ZFan(gfan::ZFan::fullFan(currRing->N));
+}

Singular/dyn_modules/gfanlib/groebnerCone.h

@@ -8 +8 @@
 #include <libpolys/polys/simpleideals.h>
 #include <kernel/ideals.h>
-#include <gfanlib/gfanlib_vector.h>
-#include <gfanlib/gfanlib_zcone.h>
+#include <gfanlib/gfanlib.h>
 #include <set>
 
+gfan::ZCone sloppyGroebnerCone(const poly g, const ring r, const gfan::ZVector w);
+gfan::ZCone sloppyGroebnerCone(const ideal I, const ring r, const gfan::ZVector w);
 gfan::ZCone groebnerCone(const poly g, const ring r, const gfan::ZVector w);
 gfan::ZCone groebnerCone(const ideal I, const ring r, const gfan::ZVector w);
-
+gfan::ZCone fullGroebnerCone(const ideal &I, const ring &r);
 
 class groebnerConeData
@@ -31 +32 @@
   groebnerConeData(const groebnerConeData &sigma);
   groebnerConeData(const ideal &J, const ring &s, const gfan::ZCone &d, const gfan::ZVector &q);
-  groebnerConeData(const ideal &J, const ring &s);
+  groebnerConeData(const ideal J, const ring s, const gfan::ZVector w);
+  groebnerConeData(const ideal J, const ring s, const gfan::ZCone d);
   ~groebnerConeData();
 
@@ -58 +60 @@
 typedef std::set<groebnerConeData,groebnerConeData_compare> setOfGroebnerConeData;
 
+gfan::ZFan* toFanStar(setOfGroebnerConeData setOfCones);
+
 #endif

Singular/dyn_modules/gfanlib/neighbours.cc

@@ -20 +20 @@
   int r = inequalities.getHeight();
   int c = inequalities.getWidth();
+  if (r==0) return gfan::ZMatrix(0,c);
 
   gfan::ZMatrix relativeInteriorPoints = gfan::ZMatrix(0,c);
@@ -44 +45 @@
   newInequalities = inequalities.submatrix(0,0,r-1,c);
   newEquations = equations;
-  newEquations.appendRow(inequalities[r]);
+  newEquations.appendRow(inequalities[r-1]);
   facet = gfan::ZCone(newInequalities,newEquations);
   relativeInteriorPoints.appendRow(facet.getRelativeInteriorPoint());
@@ -63 +64 @@
   gfan::ZMatrix relativeInteriorPoints = gfan::ZMatrix(0,c);
   gfan::ZMatrix outerFacetNormals = gfan::ZMatrix(0,c);
+  if (r<=1)
+    return std::make_pair(relativeInteriorPoints,outerFacetNormals);
   // next we iterate over each of the r facets, build the respective cone and add it to the list
   // this is the i=0 case
@@ -97 +100 @@
 setOfGroebnerConeData groebnerNeighbours(const groebnerConeData sigma, const tropicalStrategy currentCase)
 {
-  bool (*red)(ideal I, ring r);
-  red = currentCase.reduce;
+  bool (*reduce)(ideal I, ring r);
+  reduce = currentCase.reduce;
 
   gfan::ZCone zc = sigma.getCone();
@@ -108 +111 @@
   for (int i=0; i<interiorPoints.getHeight(); i++)
   {
-    std::pair<ideal,ring> flipped = flip(sigma.getIdeal(),sigma.getRing(),interiorPoints[i],facetNormals[i]);
+    std::pair<ideal,ring> flipped = flip(sigma.getIdeal(),sigma.getRing(),interiorPoints[i],facetNormals[i],currentCase);
     ideal I = flipped.first;
     ring r = flipped.second;
-    red(I,r);
-    neighbours.insert(groebnerConeData(I,r));
+    reduce(I,r);
+    gfan::ZCone c = sloppyGroebnerCone(I,r,facetNormals[i]);
+    gfan::ZVector p = c.getRelativeInteriorPoint();
+    neighbours.insert(groebnerConeData(I,r,c,p));
   }
 
@@ -118 +123 @@
 }
 
-setOfGroebnerConeData tropicalNeighbors(const groebnerConeData sigma, const tropicalStrategy currentCase)
+setOfGroebnerConeData tropicalNeighbours(const groebnerConeData sigma, const tropicalStrategy currentCase)
 {
   gfan::ZCone zc = sigma.getCone();
@@ -138 +143 @@
     for (std::set<gfan::ZVector>::iterator ray = setOfRays.begin(); ray!=setOfRays.end(); ray++)
     {
-      std::pair<ideal,ring> flipped = flip(I,r,w,*ray);
+      std::pair<ideal,ring> flipped = flip(I,r,w,*ray,currentCase);
       ideal I = flipped.first;
       ring r = flipped.second;
       red(I,r);
-      neighbours.insert(groebnerConeData(I,r));
+      gfan::ZCone c = sloppyGroebnerCone(I,r,*ray);
+      gfan::ZVector p = c.getRelativeInteriorPoint();
+      neighbours.insert(groebnerConeData(I,r,c,p));
     }
   }

Singular/dyn_modules/gfanlib/neighbours.h

@@ -6 +6 @@
 
 setOfGroebnerConeData groebnerNeighbours(const groebnerConeData sigma, const tropicalStrategy currentCase);
+setOfGroebnerConeData tropicalNeighbours(const groebnerConeData sigma, const tropicalStrategy currentCase);
 BOOLEAN tropicalNeighbours(leftv res, leftv args);
 

Singular/dyn_modules/gfanlib/startingCone.cc

@@ -6 +6 @@
 #include <neighbours.h>
 #include <tropicalStrategy.h>
-
-/***
- * Given a general ring r with any ordering,
- * changes the ordering to a(v),ws(-w)
- **/
-bool changetoAWSRing(ring r, gfan::ZVector v, gfan::ZVector w)
-{
-  omFree(r->order);
-  r->order  = (int*) omAlloc0(4*sizeof(int));
-  omFree(r->block0);
-  r->block0 = (int*) omAlloc0(4*sizeof(int));
-  omFree(r->block1);
-  r->block1 = (int*) omAlloc0(4*sizeof(int));
-  for (int i=0; r->wvhdl[i]; i++)
-  { omFree(r->wvhdl[i]); }
-  omFree(r->wvhdl);
-  r->wvhdl  = (int**) omAlloc0(4*sizeof(int*));
-
-  bool ok = false;
-  r->order[0]  = ringorder_a;
-  r->block0[0] = 1;
-  r->block1[0] = r->N;
-  r->wvhdl[0]  = ZVectorToIntStar(v,ok);
-  r->order[1]  = ringorder_ws;
-  r->block0[1] = 1;
-  r->block1[1] = r->N;
-  r->wvhdl[1]  = ZVectorToIntStar(w,ok);
-  r->order[2]  = ringorder_C;
-  return ok;
-}
+#include <tropicalCurves.h>
+#include <bbcone.h>
+#include <tropicalVariety.h>
 
 
-/***
- * Given a ring with ordering a(v'),ws(w'),
- * changes the weights to v,w
- **/
-bool changeAWSWeights(ring r, gfan::ZVector v, gfan::ZVector w)
-{
-  omFree(r->wvhdl[0]);
-  omFree(r->wvhdl[1]);
-  bool ok = false;
-  r->wvhdl[0]  = ZVectorToIntStar(v,ok);
-  r->wvhdl[1]  = ZVectorToIntStar(w,ok);
-  return ok;
-}
+// /***
+//  * Given a ring with ordering a(v'),ws(w'),
+//  * changes the weights to v,w
+//  **/
+// bool changeAWSWeights(ring r, gfan::ZVector v, gfan::ZVector w)
+// {
+//   omFree(r->wvhdl[0]);
+//   omFree(r->wvhdl[1]);
+//   bool ok = false;
+//   r->wvhdl[0]  = ZVectorToIntStar(v,ok);
+//   r->wvhdl[1]  = ZVectorToIntStar(w,ok);
+//   return ok;
+// }
 
 
@@ -67 +40 @@
     if (s == NULL)
     {
-      // std::cout << "found no monomial in initial ideal!" << std::endl;
       p_Delete(&s,r);
       return R[i];
-    }
-    p_Delete(&s,r);
-  }
-  gfan::ZMatrix L = zc.generatorsOfLinealitySpace();
-  for (int i=0; i<L.getHeight(); i++)
-  {
-    ideal inI = initial(I,r,L[i]);
-    poly s = checkForMonomialViaSuddenSaturation(inI,r);
-    id_Delete(&inI,r);
-    if (s == NULL)
-    {
-      // std::cout << "found no monomial in initial ideal!" << std::endl;
-      p_Delete(&s,r);
-      return L[i];
     }
     p_Delete(&s,r);
@@ -93 +51 @@
 gfan::ZVector tropicalStartingPoint(const ideal I, const ring r, const tropicalStrategy currentCase)
 {
+  bool (*red)(ideal I, ring r);
+  red = currentCase.reduce; red(I,r);
+
   groebnerConeData sigma = maximalGroebnerConeData(id_Copy(I,r),rCopy(r));
   gfan::ZVector startingPoint = findTropicalPoint(sigma);
-  while (startingPoint.size()==0)
+  if (startingPoint.size() > 0)
+    return startingPoint;
+  setOfGroebnerConeData groebnerFan;
+  setOfGroebnerConeData workingList;
+  workingList.insert(sigma);
+
+  while (!workingList.empty())
   {
+    sigma = *(workingList.begin());
     setOfGroebnerConeData neighbours = groebnerNeighbours(sigma,currentCase);
-    setOfGroebnerConeData::iterator tau = neighbours.begin();
-    for (; tau!=neighbours.end(); tau++)
+    for (setOfGroebnerConeData::iterator tau = neighbours.begin(); tau!=neighbours.end(); tau++)
     {
-      startingPoint = findTropicalPoint(*tau);
-      if (startingPoint.size() > 0) break;
+      if (groebnerFan.count(*tau) == 0)
+      {
+        if (workingList.count(*tau) == 0)
+        {
+          startingPoint = findTropicalPoint(*tau);
+          if (startingPoint.size() > 0)
+            return startingPoint;
+        }
+        workingList.insert(*tau);
+      }
     }
-    tau = neighbours.begin();
-    sigma = *tau;
+    groebnerFan.insert(groebnerConeData(sigma));
+    workingList.erase(sigma);
   }
   return startingPoint;
 }
-
 
 BOOLEAN tropicalStartingPoint0(leftv res, leftv args)
@@ -133 +107 @@
 }
 
+gfan::ZCone tropicalStartingCone(const ideal I, const ring r, const tropicalStrategy currentCase)
+{
+  // groebnerConeData sigma = maximalGroebnerConeData(I,r);
+  // gfan::ZCone zc = sigma.getCone();
+  // if (zc.dimensionOfLinealitySpace == d)
+  //   return zc.linealitySpace();
+  // gfan::ZVector w = tropicalStartingPoint(I,r,currentCase);
+  // ideal inI = initial(I,w,r);
+  // gfan::ZCone zd =
 
-// gfan::ZCone* tropicalStartingCone(const ideal &I, ring r)
-// {
-//   gfan::ZVector* w = tropicalStartingPoint(I,r);
-//   return groebnerCone(I,r,w);
-// }
+  gfan::ZVector w = tropicalStartingPoint(I,r,currentCase);
+  if (w.size() == 0)
+  {
+    gfan::ZCone zc = fullGroebnerCone(I,r);
+    return zc.linealitySpace();
+  }
+  ideal inI = initial(I,r,w);
+  std::set<gfan::ZCone> T = tropicalCurve(inI,r,0,currentCase);
+  return *T.begin();
+}
+
+BOOLEAN tropicalStartingCone0(leftv res, leftv args)
+{
+  leftv u = args;
+  ideal I = (ideal) u->CopyD();
+  gfan::ZCone startingCone = tropicalStartingCone(I,currRing,nonValuedCase);
+  id_Delete(&I, currRing);
+  res->rtyp = coneID;
+  res->data = (char*) new gfan::ZCone(startingCone);
+  return FALSE;
+}
+
+BOOLEAN tropicalStartingCone1(leftv res, leftv args)
+{
+  leftv u = args;
+  ideal I = (ideal) u->CopyD();
+  gfan::ZCone startingCone = tropicalStartingCone(I,currRing,valuedCase);
+  id_Delete(&I, currRing);
+  res->rtyp = coneID;
+  res->data = (char*) new gfan::ZCone(startingCone);
+  return FALSE;
+}

Singular/dyn_modules/gfanlib/startingCone.h

@@ -3 +3 @@
 
 #include <groebnerCone.h>
-/* namespace tropical */
-/* { */
-
-/*   class facet */
-/*   { */
-/*     gfan::ZVector interiorPoint; */
-/*     gfan::ZVector facetNormal; */
-
-/*   public: */
-
-/*     facet(); */
-/*     facet(const facet &f); */
-/*     facet(const gfan::ZCone &c, const gfan::ZVector &v, const gfan::ZVector &w); */
-/*     ~facet(); */
-
-/*     gfan::ZCone getEta() { return this->eta; }; */
-/*     gfan::ZVector getInteriorPoint() { return this->interiorPoint; }; */
-/*     gfan::ZVector getFacetNormal() { return this->facetNormal; }; */
-
-/*     friend struct facet_compare; */
-/*   }; */
-
-/*   struct facet_compare */
-/*   { */
-/*     bool operator()(const facet &f, const facet &g) const */
-/*     { */
-/*       const gfan::ZVector v1 = f.interiorPoint; */
-/*       const gfan::ZVector v2 = g.interiorPoint; */
-/* #ifndef NDEBUG */
-/*       assume(v1.size() == v2.size()); */
-/* #endif */
-/*       return v1 < v2; */
-/*     } */
-/*   }; */
-
-/*   typedef std::set<facet,facet_compare> facets; */
-
-/*   void mergeFacets(facets &F, const facets &newFacets); */
-
-/* } */
+#include <tropicalStrategy.h>
 
 gfan::ZVector containsTropicalPoint(const groebnerConeData sigma);
 gfan::ZVector tropicalStartingPoint(ideal I, ring r);
+gfan::ZCone tropicalStartingCone(const ideal I, const ring r, const tropicalStrategy currentCase);
 
 BOOLEAN tropicalStartingPoint0(leftv res, leftv args);
 BOOLEAN tropicalStartingPoint1(leftv res, leftv args);
 
+BOOLEAN tropicalStartingCone0(leftv res, leftv args);
+BOOLEAN tropicalStartingCone1(leftv res, leftv args);
+
 #endif

Singular/dyn_modules/gfanlib/tropical.cc

@@ -14 +14 @@
 #include <tropicalStrategy.h>
 #include <startingCone.h>
+#include <tropicalVariety.h>
 
 BOOLEAN homogeneitySpace(leftv res, leftv args)
@@ -207 +208 @@
   p->iiAddCproc("","tropicalStartingPoint0",FALSE,tropicalStartingPoint0);
   p->iiAddCproc("","tropicalStartingPoint1",FALSE,tropicalStartingPoint1);
+  p->iiAddCproc("","tropicalStartingCone0",FALSE,tropicalStartingCone0);
+  p->iiAddCproc("","tropicalStartingCone1",FALSE,tropicalStartingCone1);
+  p->iiAddCproc("","tropicalVariety",FALSE,tropicalVariety);
 #endif //NDEBUG
   p->iiAddCproc("","ppreduceInitially",FALSE,ppreduceInitially);

Singular/dyn_modules/gfanlib/tropicalCurves.cc

@@ -89 +89 @@
 
 /***
- * Computes the tropical curve of an x-homogeneous ideal I
- * which is weighted homogeneous with respect to weight w in ring r
+ * Computes the tropical curve of an x-homogeneous ideal I in ring r
  **/
 std::set<gfan::ZCone> tropicalCurve(const ideal I, const ring r, const int d,

Singular/dyn_modules/gfanlib/witness.cc

@@ -4 +4 @@
 #include <callgfanlib_conversion.h>
 #include <initial.h>
+#include <tropicalStrategy.h>
 #include <utility>
 
@@ -134 +135 @@
 }
 
-std::pair<ideal,ring> flip(const ideal I, const ring r, const gfan::ZVector interiorPoint, const gfan::ZVector facetNormal)
+std::pair<ideal,ring> flip(const ideal I, const ring r, const gfan::ZVector interiorPoint, const gfan::ZVector facetNormal, const tropicalStrategy currentCase)
 {
+  gfan::ZVector (*adjustWeight0)(gfan::ZVector w);
+  adjustWeight0 = currentCase.adjustWeightForHomogeneity;
+  gfan::ZVector (*adjustWeight1)(gfan::ZVector v, gfan::ZVector w);
+  adjustWeight1 = currentCase.adjustWeightUnderHomogeneity;
+
+  gfan::ZVector adjustedInteriorPoint = adjustWeight0(interiorPoint);
+  gfan::ZVector adjustedFacetNormal = adjustWeight1(facetNormal,adjustedInteriorPoint);
+
   ring origin = currRing;
   ideal inIr = initial(I,r,interiorPoint);
@@ -143 +152 @@
   int n = rVar(s);
   deleteOrdering(s);
-  // for (i=0; s->order[i]; i++)
-  //   omFree(s->wvhdl[i]);
-  // i++; omFreeSize(s->order, i*sizeof(int));
-  // omFreeSize(s->block0, i*sizeof(int));
-  // omFreeSize(s->block1, i*sizeof(int));
-  // omFreeSize(s->wvhdl, i*sizeof(int));
   s->order = (int*) omAlloc0(4*sizeof(int));
   s->block0 = (int*) omAlloc0(4*sizeof(int));
@@ -156 +159 @@
   s->block0[0] = 1;
   s->block1[0] = n;
-  s->wvhdl[0] = ZVectorToIntStar(interiorPoint,ok);
+  s->wvhdl[0] = ZVectorToIntStar(adjustedInteriorPoint,ok);
   s->order[1] = ringorder_wp;
   s->block0[1] = 1;
   s->block1[1] = n;
-  s->wvhdl[1] = ZVectorToIntStar(facetNormal,ok);
+  s->wvhdl[1] = ZVectorToIntStar(adjustedFacetNormal,ok);
   s->order[2] = ringorder_C;
   rComplete(s,1);

Singular/dyn_modules/gfanlib/witness.h

@@ -6 +6 @@
 #include <Singular/ipid.h>
 #include <gfanlib/gfanlib_vector.h>
+#include <tropicalStrategy.h>
 
 poly witness(const poly m, const ideal I, const ideal inI, const ring r);
-std::pair<ideal,ring> flip(const ideal I, const ring r, const gfan::ZVector interiorPoint, const gfan::ZVector facetNormal);
+std::pair<ideal,ring> flip(const ideal I, const ring r, const gfan::ZVector interiorPoint, const gfan::ZVector facetNormal, const tropicalStrategy currentCase);
 
 #ifndef NDEBUG