Changeset 32d8cb in git

Timestamp:

Oct 25, 2013, 8:34:39 PM (9 years ago)

Author:

Hans Schoenemann <hannes@…>

Branches:

(u'jengelh-datetime', 'ceac47cbc86fe4a15902392bdbb9bd2ae0ea02c6')(u'spielwiese', 'f875bbaccd0831e36aaed09ff6adeb3eb45aeb94')

Children:

9cf75aab8ce4766fcf49c2135012db6957300a95

Parents:

6a6ae29f7bcf2272aa28c90bb17f8e9a0337de6e62de8de7d677c1aa9a6da3c0e58b04a58a9a884b

Message:

Merge pull request #408 from YueRen/spielwiese

polymake/gfanlib modules

Files:

• doc/polymake.doc (modified) (previous)
• dyn_modules/callgfanlib/bbcone.cc (modified) (14 diffs)
• dyn_modules/callgfanlib/bbfan.cc (modified) (5 diffs)
• dyn_modules/callgfanlib/bbpolytope.cc (modified) (6 diffs)
• dyn_modules/callgfanlib/gfan.h (modified) (1 diff)
• dyn_modules/callgfanlib/gitfan.cc (modified) (4 diffs)
• dyn_modules/callpolymake/Makefile.am (modified) (2 diffs)
• dyn_modules/callpolymake/polymake_conversion.cc (modified) (4 diffs)
• dyn_modules/callpolymake/polymake_conversion.h (modified) (4 diffs)
• dyn_modules/callpolymake/polymake_documentation.cc (modified) (2 diffs)
• dyn_modules/callpolymake/polymake_documentation.h (modified) (2 diffs)
• dyn_modules/callpolymake/polymake_wrapper.cc (modified) (5 diffs)
• gfanlib/gfanlib_matrix.h (modified) (2 diffs)
• gfanlib/gfanlib_polyhedralfan.cpp (modified) (3 diffs)
• gfanlib/gfanlib_polymakefile.cpp (modified) (9 diffs)
• gfanlib/gfanlib_q.h (modified) (1 diff)
• gfanlib/gfanlib_symmetriccomplex.cpp (modified) (16 diffs)
• gfanlib/gfanlib_symmetry.cpp (modified) (12 diffs)
• gfanlib/gfanlib_vector.h (modified) (7 diffs)
• gfanlib/gfanlib_zcone.cpp (modified) (16 diffs)
• gfanlib/gfanlib_zcone.h (modified) (1 diff)
• gfanlib/gfanlib_zfan.cpp (modified) (3 diffs)
• m4/flags.m4 (modified) (2 diffs)

dyn_modules/callgfanlib/bbcone.cc

@@ -170 +170 @@
 }
 
-void* bbcone_Init(blackbox *b)
+void* bbcone_Init(blackbox* /*b*/)
 {
   return (void*)(new gfan::ZCone());
@@ -229 +229 @@
 }
 
-char * bbcone_String(blackbox *b, void *d)
+char* bbcone_String(blackbox* /*b*/, void *d)
 {
   if (d==NULL) return omStrDup("invalid object");
@@ -239 +239 @@
 }
 
-void bbcone_destroy(blackbox *b, void *d)
+void bbcone_destroy(blackbox* /*b*/, void *d)
 {
   if (d!=NULL)
@@ -248 +248 @@
 }
 
-void* bbcone_Copy(blackbox*b, void *d)
+void* bbcone_Copy(blackbox* /*b*/, void *d)
 {
   gfan::ZCone* zc = (gfan::ZCone*)d;
@@ -622 +622 @@
 {
   leftv u = args;
-  if ((u != NULL) && (u->Typ() == coneID))
+  if ((u != NULL) && (u->Typ() == coneID || u->Typ() == polytopeID))
   {
     gfan::ZCone* zc = (gfan::ZCone*)u->Data();
@@ -638 +638 @@
 {
   leftv u = args;
-  if ((u != NULL) && (u->Typ() == coneID))
+  if ((u != NULL) && (u->Typ() == coneID || u->Typ() == polytopeID))
   {
     gfan::ZCone* zc = (gfan::ZCone*)u->Data();
@@ -653 +653 @@
 {
   leftv u = args;
-  if ((u != NULL) && (u->Typ() == coneID))
+  if ((u != NULL) && (u->Typ() == coneID || u->Typ() == polytopeID))
   {
     gfan::ZCone* zc = (gfan::ZCone*)u->Data();
@@ -661 +661 @@
     return FALSE;
   }
-  if ((u != NULL) && (u->Typ() == polytopeID))
-    {
-      gfan::ZCone* zc = (gfan::ZCone*)u->Data();
-      res->rtyp = BIGINTMAT_CMD;
-      res->data = (void*) getFacetNormals(zc);
-      return FALSE;
-    }
   WerrorS("facets: unexpected parameters");
   return TRUE;
@@ -675 +668 @@
 {
   leftv u = args;
-  if ((u != NULL) && (u->Typ() == coneID))
+  if ((u != NULL) && (u->Typ() == coneID || u->Typ() == polytopeID))
   {
     gfan::ZCone* zc = (gfan::ZCone*)u->Data();
@@ -690 +683 @@
 {
   leftv u = args;
-  if ((u != NULL) && (u->Typ() == coneID))
+  if ((u != NULL) && (u->Typ() == coneID || u->Typ() == polytopeID))
   {
     gfan::ZCone* zc = (gfan::ZCone*)u->Data();
@@ -705 +698 @@
 {
   leftv u = args;
-  if ((u != NULL) && (u->Typ() == coneID))
+  if ((u != NULL) && (u->Typ() == coneID || u->Typ() == polytopeID))
   {
     gfan::ZCone* zc = (gfan::ZCone*)u->Data();
@@ -1646 +1639 @@
 
 
+lists listOfFacets(const gfan::ZCone &zc)
+{
+  gfan::ZMatrix inequalities = zc.getFacets();
+  gfan::ZMatrix equations = zc.getImpliedEquations();
+  lists L = (lists)omAllocBin(slists_bin);
+  int r = inequalities.getHeight();
+  int c = inequalities.getWidth();
+  L->Init(r);
+
+  /* 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 */
+  gfan::ZMatrix newInequalities = inequalities.submatrix(1,0,r,c);
+  gfan::ZMatrix newEquations = equations;
+  newEquations.appendRow(inequalities[0]);
+  L->m[0].rtyp = coneID; L->m[0].data=(void*) new gfan::ZCone(newInequalities,newEquations);
+
+  /* these are the cases i=1,...,r-2 */
+  for (int i=1; i<r-1; i++)
+  {
+    newInequalities = inequalities.submatrix(0,0,i-1,c);
+    newInequalities.append(inequalities.submatrix(i+1,0,r,c));
+    newEquations = equations;
+    newEquations.appendRow(inequalities[i]);
+    L->m[i].rtyp = coneID; L->m[i].data=(void*) new gfan::ZCone(newInequalities,newEquations);
+  }
+
+  /* this is the i=r-1 case */
+  newInequalities = inequalities.submatrix(0,0,r-1,c);
+  newEquations = equations;
+  newEquations.appendRow(inequalities[r]);
+  L->m[r-1].rtyp = coneID; L->m[r-1].data=(void*) new gfan::ZCone(newInequalities,newEquations);
+
+  return L;
+}
+
+
+BOOLEAN listOfFacets(leftv res, leftv args)
+{
+  leftv u=args;
+  if ((u != NULL) && (u->Typ() == coneID))
+  {
+    gfan::ZCone* zc = (gfan::ZCone*) u->Data();
+    lists L = listOfFacets(*zc);
+    res->rtyp = LIST_CMD;
+    res->data = (void*) L;
+    return FALSE;
+  }
+  WerrorS("listOfFacets: unexpected parameters");
+  return TRUE;
+}
+
+
 poly initial(poly p)
 {
@@ -1684 +1729 @@
       ideal I = (ideal) u->Data();
       ideal inI = idInit(IDELEMS(I));
-      poly g; poly h; long d;
+      poly g;
       for (int i=0; i<IDELEMS(I); i++)
       {
@@ -1908 +1953 @@
   p->iiAddCproc("","uniquePoint",FALSE,uniquePoint);
   p->iiAddCproc("","listContainsCone",FALSE,containsCone);
+  p->iiAddCproc("","listOfFacets",FALSE,listOfFacets);
   p->iiAddCproc("","maximalGroebnerCone",FALSE,maximalGroebnerCone);
   p->iiAddCproc("","groebnerCone",FALSE,groebnerCone);

dyn_modules/callgfanlib/bbfan.cc

@@ -25 +25 @@
 int fanID;
 
-void* bbfan_Init(blackbox *b)
+void* bbfan_Init(blackbox* /*b*/)
 {
   return (void*) new gfan::ZFan(0);
 }
 
-void bbfan_destroy(blackbox *b, void *d)
+void bbfan_destroy(blackbox* /*b*/, void *d)
 {
   if (d!=NULL)
@@ -39 +39 @@
 }
 
-char* bbfan_String(blackbox *b, void *d)
+char* bbfan_String(blackbox* /*b*/, void *d)
 {
   if (d==NULL) return omStrDup("invalid object");
@@ -50 +50 @@
 }
 
-void* bbfan_Copy(blackbox*b, void *d)
+void* bbfan_Copy(blackbox* /*b*/, void *d)
 {
   gfan::ZFan* zf = (gfan::ZFan*)d;
@@ -502 +502 @@
       leftv w=v->next; int n = 1;
       if ((w != NULL) && (w->Typ() == INT_CMD))
-        int n = (int)(long) w;
+        n = (int)(long) w;
 
       if (n != 0)
@@ -864 +864 @@
 }
 
-lists listOfFacets(const gfan::ZCone &zc)
-{
-  gfan::ZMatrix inequalities = zc.getFacets();
-  gfan::ZMatrix equations = zc.getImpliedEquations();
-  lists L = (lists)omAllocBin(slists_bin);
-  int r = inequalities.getHeight();
-  int c = inequalities.getWidth();
-  L->Init(r);
-
-  /* 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 */
-  gfan::ZMatrix newInequalities = inequalities.submatrix(1,0,r,c);
-  gfan::ZMatrix newEquations = equations;
-  newEquations.appendRow(inequalities[0]);
-  L->m[0].rtyp = coneID; L->m[0].data=(void*) new gfan::ZCone(newInequalities,newEquations);
-
-  /* these are the cases i=1,...,r-2 */
-  for (int i=1; i<r-1; i++)
-  {
-    newInequalities = inequalities.submatrix(0,0,i-1,c);
-    newInequalities.append(inequalities.submatrix(i+1,0,r,c));
-    newEquations = equations;
-    newEquations.appendRow(inequalities[i]);
-    L->m[i].rtyp = coneID; L->m[i].data=(void*) new gfan::ZCone(newInequalities,newEquations);
-  }
-
-  /* this is the i=r-1 case */
-  newInequalities = inequalities.submatrix(0,0,r-1,c);
-  newEquations = equations;
-  newEquations.appendRow(inequalities[r]);
-  L->m[r-1].rtyp = coneID; L->m[r-1].data=(void*) new gfan::ZCone(newInequalities,newEquations);
-
-  return L;
-}
-
-BOOLEAN listOfFacets(leftv res, leftv args)
-{
-  leftv u=args;
-  if ((u != NULL) && (u->Typ() == coneID))
-  {
-    gfan::ZCone* zc = (gfan::ZCone*) u->Data();
-    lists L = listOfFacets(*zc);
-    res->rtyp = LIST_CMD;
-    res->data = (void*) L;
-    return FALSE;
-  }
-  WerrorS("listOfFacets: unexpected parameters");
-  return TRUE;
-}
 
 BOOLEAN tropicalVariety(leftv res, leftv args)

dyn_modules/callgfanlib/bbpolytope.cc

@@ -38 +38 @@
 }
 
-void *bbpolytope_Init(blackbox *b)
+void *bbpolytope_Init(blackbox* /*b*/)
 {
   return (void*)(new gfan::ZCone());
@@ -97 +97 @@
 }
 
-char* bbpolytope_String(blackbox *b, void *d)
+char* bbpolytope_String(blackbox* /*b*/, void *d)
 { if (d==NULL) return omStrDup("invalid object");
    else
@@ -107 +107 @@
 }
 
-void bbpolytope_destroy(blackbox *b, void *d)
+void bbpolytope_destroy(blackbox* /*b*/, void *d)
 {
   if (d!=NULL)
@@ -116 +116 @@
 }
 
-void* bbpolytope_Copy(blackbox*b, void *d)
+void* bbpolytope_Copy(blackbox* /*b*/, void *d)
 {
   gfan::ZCone* zc = (gfan::ZCone*)d;
@@ -358 +358 @@
   WerrorS("vertices: unexpected parameters");
   return TRUE;
-}
-
-bigintmat* getFacetNormals(gfan::ZCone* zc)
-{
-  gfan::ZMatrix zmat = zc->getFacets();
-  return zMatrixToBigintmat(zmat);
 }
 
@@ -482 +476 @@
   // iiAddCproc("","getCodimension",FALSE,getAmbientDimension);
   // iiAddCproc("","getDimension",FALSE,getDimension);
-  // iiAddCproc("","getFacetNormals",FALSE,getFacetNormals);
   /********************************************************/
   /* the following functions are identical to those in bbcone.cc */
+  // iiAddCproc("","facets",FALSE,facets);
   // iiAddCproc("","setLinearForms",FALSE,setLinearForms);
   // iiAddCproc("","getLinearForms",FALSE,getLinearForms);

dyn_modules/callgfanlib/gfan.h

@@ -261 +261 @@
 };
 lists lprepareResult(gcone *gc, const int n);
-static int64 int64gcd(const int64 &a, const int64 &b);
-static int intgcd(const int &a, const int &b);
-static int dotProduct(const int64vec &iva, const int64vec &ivb);
-static bool isParallel(const int64vec &a, const int64vec &b);
-static int64vec *ivNeg(/*const*/ int64vec *iv);
-static void idDebugPrint(const ideal &I);
-static volatile void showSLA(facet &f);
-static bool isMonomial(const ideal &I);
-static bool ivAreEqual(const int64vec &a, const int64vec &b);
-static bool areEqual2(facet *f, facet *g);
-static bool areEqual( facet *f, facet *g);
+/* static int64 int64gcd(const int64 &a, const int64 &b); */
+/* static int intgcd(const int &a, const int &b); */
+/* static int dotProduct(const int64vec &iva, const int64vec &ivb); */
+/* static bool isParallel(const int64vec &a, const int64vec &b); */
+/* static int64vec *ivNeg(/\*const*\/ int64vec *iv); */
+/* static void idDebugPrint(const ideal &I); */
+/* static volatile void showSLA(facet &f); */
+/* static bool isMonomial(const ideal &I); */
+/* static bool ivAreEqual(const int64vec &a, const int64vec &b); */
+/* static bool areEqual2(facet *f, facet *g); */
+/* static bool areEqual( facet *f, facet *g); */
 // bool iv64isStrictlyPositive(int64vec *);
 #endif

dyn_modules/callgfanlib/gitfan.cc

@@ -40 +40 @@
     gfan::ZVector v = f.interiorPoint;
     gfan::ZVector w = f.facetNormal;
-    assume(c.ambientDimension() == v.size());
-    assume(c.ambientDimension() == w.size());
+    assume(c.ambientDimension() == (int)v.size());
+    assume(c.ambientDimension() == (int)w.size());
     assume(c.contains(v));
     assume(!c.contains(w));
@@ -53 +53 @@
   {
 #ifndef NDEBUG
-    assume(c.ambientDimension() == v.size());
-    assume(c.ambientDimension() == w.size());
+    assume(c.ambientDimension() == (int)v.size());
+    assume(c.ambientDimension() == (int)w.size());
     assume(c.contains(v));
     assume(!c.contains(w));
@@ -66 +66 @@
     gfan::ZVector v = this->interiorPoint;
     gfan::ZVector w = this->facetNormal;
-    assume(c.ambientDimension() == v.size());
-    assume(c.ambientDimension() == w.size());
+    assume(c.ambientDimension() == (int)v.size());
+    assume(c.ambientDimension() == (int)w.size());
     assume(c.contains(v));
     assume(!c.contains(w));
@@ -114 +114 @@
     return F;
 
-  int index = 0;
+  // int index = 0;
   /* 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 */

dyn_modules/callpolymake/Makefile.am

@@ -10 +10 @@
 
 # forcefully enable exceptions for polymake
-POLYMAKE_CFLAGS = -fexceptions
+POLYMAKE_CFLAGS = -fexceptions -frtti
 
 AM_LDFLAGS      = -release ${PACKAGE_VERSION} ${PM_LDFLAGS}
@@ -16 +16 @@
 SOURCES = polymake_conversion.cc polymake_documentation.cc polymake_wrapper.cc
 
+CXXFLAGS += $(POLYMAKE_CXXFLAGS)
+
 polymake_la_SOURCES = $(SOURCES)
 
 MYINCLUDES = -I${top_srcdir} -I${top_builddir} -I${srcdir} \
--I${top_srcdir}/libpolys -I${top_builddir}/libpolys \
-$(GMP_CFLAGS) ${PM_INC} ${PM_CFLAGS} ${POLYMAKE_CFLAGS}
+-I${top_srcdir}/libpolys -I${top_builddir}/libpolys  \
+-I${top_builddir}/factory/include $(GMP_CFLAGS) $(PM_INC) $(PM_CFLAGS) \
+$(POLYMAKE_CFLAGS) $(FACTORY_CFLAGS)
 
 P_PROCS_CPPFLAGS_COMMON = -DDYNAMIC_VERSION

dyn_modules/callpolymake/polymake_conversion.cc

@@ -7 +7 @@
 #include <polymake/Set.h>
 #include <polymake/common/lattice_tools.h>
-// #include <polymake/perl/macros.h>
-// #include <polymake/IncidenceMatrix.h>
+#include <polymake/IncidenceMatrix.h>
 
 #include <gfanlib/gfanlib.h>
@@ -14 +13 @@
 
 #include <kernel/mod2.h>
-// #include <kernel/structs.h>
-// #include <kernel/febase.h>
 #include <libpolys/misc/intvec.h>
-
-// #include <callgfanlib/bbcone.h>
-// #include <callgfanlib/bbfan.h>
-// #include <callgfanlib/bbpolytope.h>
-
-// #include <Singular/blackbox.h>
-// #include <Singular/ipshell.h>
-// #include <Singular/subexpr.h>
-// #include <Singular/tok.h>
-
+#include <libpolys/coeffs/numbers.h>
+#include <libpolys/coeffs/bigintmat.h>
+#include <Singular/lists.h>
+#include <Singular/ipid.h> // for bigints,
+// is there really nothing better than this?
 
 /* Functions for converting Integers, Rationals and their Matrices
@@ -136 +128 @@
 }
 
+number PmInteger2Number (const polymake::Integer& pi)
+{
+  mpz_class cache(pi.get_rep());
+  long m = 268435456;
+  if(mpz_cmp_si(cache.get_mpz_t(),m))
+  {
+    int temp = (int) mpz_get_si(cache.get_mpz_t());
+    return n_Init(temp,coeffs_BIGINT);
+  }
+  else
+    return n_InitMPZ(cache.get_mpz_t(),coeffs_BIGINT);
+}
+
 intvec* PmVectorInteger2Intvec (const polymake::Vector<polymake::Integer>* vi, bool &ok)
 {
@@ -161 +166 @@
 }
 
-// intvec* PmIncidenceMatrix2Intvec (polymake::IncidenceMatrix<polymake::NonSymmetric>* icmat)
-// {
-//   int rows = icmat->rows();
-//   int cols = icmat->cols();
-//   intvec* iv = new intvec(rows,cols,0);
-//   for (int r = 1; r <= rows; r++)
-//     for (int c = 1; c <= cols; c++)
-//       IMATELEM(*iv,r,c) = (int) (*icmat).row(r).exists(c);
-//   return iv;
-// }
+bigintmat* PmMatrixInteger2Bigintmat (polymake::Matrix<polymake::Integer>* mi)
+{
+  int rows = mi->rows();
+  int cols = mi->cols();
+  bigintmat* bim= new bigintmat(rows,cols,coeffs_BIGINT);
+  const polymake::Integer* pi = concat_rows(*mi).begin();
+  for (int r = 1; r <= rows; r++)
+    for (int c = 1; c <= cols; c++)
+    {
+      number temp = PmInteger2Number(*pi);
+      bim->set(r,c,temp);
+      n_Delete(&temp,coeffs_BIGINT);
+      pi++;
+    }
+  return bim;
+}
+
+lists PmIncidenceMatrix2ListOfIntvecs (polymake::IncidenceMatrix<polymake::NonSymmetric>* icmat)
+{
+  int rows = icmat->rows();
+  int cols = icmat->cols();
+  lists L = (lists)omAllocBin(slists_bin);
+  L->Init(rows);
+
+  for (int r = 0; r < rows; r++)
+  {
+    intvec* iv = new intvec(cols); int i=0;
+    for (int c = 0; c < cols; c++)
+    {
+      if ((*icmat).row(r).exists(c))
+      { (*iv)[i]=c; i++; }
+    }
+    iv->resize(i);
+    L->m[r].rtyp = INTVEC_CMD;
+    L->m[r].data = (void*) iv;
+  }
+
+  return L;
+}
+
+lists PmAdjacencyMatrix2ListOfEdges (polymake::IncidenceMatrix<polymake::NonSymmetric>* icmat)
+{
+  int rows = icmat->rows();
+  int cols = icmat->cols();
+
+  // counting number of edges
+  int i=0; int r, c;
+  for (r=0; r<rows; r++)
+  {
+    for (c=0; c<cols; c++)
+    {
+      if ((*icmat).row(r).exists(c) && r<c)
+        i++;
+    }
+  }
+
+  lists L = (lists)omAllocBin(slists_bin);
+  L->Init(i);
+
+  i=0;
+  for (r=0; r<rows; r++)
+  {
+    for (c=0; c<cols; c++)
+    {
+      if ((*icmat).row(r).exists(c) && r<c)
+      {
+        intvec* iv = new intvec(2);
+        (*iv)[0]=r; (*iv)[1]=c;
+        L->m[i].rtyp = INTVEC_CMD;
+        L->m[i].data = (void*) iv;
+        i++;
+      }
+    }
+  }
+
+  return L;
+}
 
 intvec* PmSetInteger2Intvec (polymake::Set<polymake::Integer>* si, bool &b)

dyn_modules/callpolymake/polymake_conversion.h

@@ -3 +3 @@
 
 #include <kernel/mod2.h>
-
-#ifdef HAVE_FANS
 
 #include <gmpxx.h>
@@ -14 +12 @@
 #include <polymake/Set.h>
 #include <polymake/common/lattice_tools.h>
+#include <polymake/IncidenceMatrix.h>
 
 #include <gfanlib/gfanlib.h>
 #include <gfanlib/gfanlib_q.h>
 
+#include <libpolys/coeffs/numbers.h>
+#include <libpolys/coeffs/bigintmat.h>
 #include <libpolys/misc/intvec.h>
+#include <Singular/lists.h>
 
 /* Functions for converting Integers, Rationals and their Matrices
@@ -43 +45 @@
 intvec* PmVectorInteger2Intvec (const polymake::Vector<polymake::Integer>* vi, bool &ok);
 intvec* PmMatrixInteger2Intvec (polymake::Matrix<polymake::Integer>* mi, bool &ok);
-// intvec* PmIncidenceMatrix2Intvec (polymake::IncidenceMatrix<polymake::NonSymmetric>* icmat);
+lists PmIncidenceMatrix2ListOfIntvecs (polymake::IncidenceMatrix<polymake::NonSymmetric>* icmat);
+lists PmAdjacencyMatrix2ListOfEdges (polymake::IncidenceMatrix<polymake::NonSymmetric>* icmat);
 intvec* PmSetInteger2Intvec (polymake::Set<polymake::Integer>* si, bool &b);
+number PmInteger2Number (const polymake::Integer& pi);
+bigintmat* PmMatrixInteger2Bigintmat (polymake::Matrix<polymake::Integer>* mi);
 
 /* polymake <- singular */
@@ -62 +67 @@
 
 #endif
-#endif

dyn_modules/callpolymake/polymake_documentation.cc

@@ -1 @@
-#include <polymake_conversion.h>
-
-#include <callgfanlib/bbcone.h>
-#include <callgfanlib/bbfan.h>
-#include <callgfanlib/bbpolytope.h>
-
-#include <Singular/blackbox.h>
-#include <Singular/ipshell.h>
-#include <Singular/subexpr.h>
 #include <Singular/ipid.h>
 
@@ -204 +195 @@
     module_help_proc("polymake.so","normalFan", normalFan_help);
 
+  const char* vertexAdjacencyGraph_help =
+    "USAGE:    vertexAdjacencyGraph(polytope p)\nRETURN:   list,\nKEYWORDS: polytopes; polymake;\nEXAMPLE:  example visual shows an example\n";
+
+    module_help_proc("polymake.so","vertexAdjacencyGraph", normalFan_help);
+
+  const char* vertexEdgeGraph_help =
+    "USAGE:    vertexEdgeGraph(polytope p)\nRETURN:   list,\nKEYWORDS: polytopes; polymake;\nEXAMPLE:  example visual shows an example\n";
+
+    module_help_proc("polymake.so","vertexEdgeGraph", normalFan_help);
+
 }

dyn_modules/callpolymake/polymake_documentation.h

@@ -4 +4 @@
 #include <kernel/mod2.h>
 
-#ifdef HAVE_FANS
-
 #include <polymake_conversion.h>
 
-#include <callgfanlib/bbcone.h>
-#include <callgfanlib/bbfan.h>
-#include <callgfanlib/bbpolytope.h>
+#include <dyn_modules/callgfanlib/bbcone.h>
+#include <dyn_modules/callgfanlib/bbfan.h>
+#include <dyn_modules/callgfanlib/bbpolytope.h>
 
 #include <Singular/blackbox.h>
@@ -22 +20 @@
 
 #endif
-#endif

dyn_modules/callpolymake/polymake_wrapper.cc

@@ -1 +1 @@
 #include <polymake_conversion.h>
 #include <polymake_documentation.h>
+#include <polymake/Graph.h>
 
 #include <dyn_modules/callgfanlib/bbcone.h>
@@ -1680 +1681 @@
 }
 
+
+BOOLEAN PMvertexAdjacencyGraph(leftv res, leftv args)
+{
+  leftv u = args;
+  if ((u != NULL) && (u->Typ() == polytopeID))
+  {
+    gfan::ZCone* zp = (gfan::ZCone*) u->Data();
+    lists output=(lists)omAllocBin(slists_bin); output->Init(2);
+    try
+    {
+      polymake::perl::Object* p = ZPolytope2PmPolytope(zp);
+      polymake::Matrix<polymake::Integer> vert0 = p->give("VERTICES");
+      bigintmat* vert1 = PmMatrixInteger2Bigintmat(&vert0);
+      output->m[0].rtyp = BIGINTMAT_CMD;
+      output->m[0].data = (void*) vert1;
+
+      polymake::Graph<> gr=p->give("GRAPH.ADJACENCY");
+      polymake::IncidenceMatrix<polymake::NonSymmetric> adj = adjacency_matrix(gr);
+      lists listOfEdges = PmIncidenceMatrix2ListOfIntvecs(&adj);
+      output->m[1].rtyp = LIST_CMD;
+      output->m[1].data = (void*) listOfEdges;
+      delete p;
+    }
+    catch (const std::exception& ex)
+    {
+      WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
+      return TRUE;
+    }
+    res->rtyp = LIST_CMD;
+    res->data = (void*) output;
+    return FALSE;
+  }
+  WerrorS("vertexEdgeGraph: unexpected parameters");
+  return TRUE;
+}
+
+
+BOOLEAN PMvertexEdgeGraph(leftv res, leftv args)
+{
+  leftv u = args;
+  if ((u != NULL) && (u->Typ() == polytopeID))
+  {
+    gfan::ZCone* zp = (gfan::ZCone*) u->Data();
+    lists output=(lists)omAllocBin(slists_bin); output->Init(2);
+    try
+    {
+      polymake::perl::Object* p = ZPolytope2PmPolytope(zp);
+      polymake::Matrix<polymake::Integer> vert0 = p->give("VERTICES");
+      bigintmat* vert1 = PmMatrixInteger2Bigintmat(&vert0);
+      output->m[0].rtyp = BIGINTMAT_CMD;
+      output->m[0].data = (void*) vert1;
+
+      polymake::Graph<> gr=p->give("GRAPH.ADJACENCY");
+      polymake::IncidenceMatrix<polymake::NonSymmetric> adj = adjacency_matrix(gr);
+      lists listOfEdges = PmAdjacencyMatrix2ListOfEdges(&adj);
+      output->m[1].rtyp = LIST_CMD;
+      output->m[1].data = (void*) listOfEdges;
+      delete p;
+    }
+    catch (const std::exception& ex)
+    {
+      WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
+      return TRUE;
+    }
+    res->rtyp = LIST_CMD;
+    res->data = (void*) output;
+    return FALSE;
+  }
+  WerrorS("vertexEdgeGraph: unexpected parameters");
+  return TRUE;
+}
+
+
 extern "C" int mod_init(SModulFunctions* p)
 {
@@ -1685 +1759 @@
     {init_polymake = new polymake::Main();}
   init_polymake->set_application("fan");
-  // iiAddCproc("","cube",FALSE,cube);
-  // iiAddCproc("","cross",FALSE,cross);
-  //p->iiAddCproc("polymake.so","coneViaPoints",FALSE,PMconeViaRays);
-  p->iiAddCproc("polymake.so","polytopeViaVertices",FALSE,PMpolytopeViaVertices);
+  // p->iiAddCproc("polymake.so","coneViaPoints",FALSE,PMconeViaRays);
+  // p->iiAddCproc("polymake.so","polytopeViaPoints",FALSE,PMpolytopeViaVertices);
   p->iiAddCproc("polymake.so","isLatticePolytope",FALSE,PMisLatticePolytope);
   p->iiAddCproc("polymake.so","isBounded",FALSE,PMisBounded);
@@ -1702 +1774 @@
   p->iiAddCproc("polymake.so","latticeCodegree",FALSE,PMlatticeCodegree);
   p->iiAddCproc("polymake.so","ehrhartPolynomialCoeff",FALSE,PMehrhartPolynomialCoeff);
-  //p->iiAddCproc("polymake.so","fVector",FALSE,PMfVector);
+  p->iiAddCproc("polymake.so","fVector",FALSE,PMfVector);
   p->iiAddCproc("polymake.so","hVector",FALSE,PMhVector);
   p->iiAddCproc("polymake.so","hStarVector",FALSE,PMhStarVector);
@@ -1727 +1799 @@
   p->iiAddCproc("polymake.so","visual",FALSE,visual);
   p->iiAddCproc("polymake.so","normalFan",FALSE,normalFan);
-  // iiAddCproc("","testingtypes",FALSE,testingtypes);
-  // iiAddCproc("","testingintvec",FALSE,testingintvec);
-  // iiAddCproc("","testingcones",FALSE,testingcones);
-  // iiAddCproc("","testingpolytopes",FALSE,testingpolytopes);
-  // iiAddCproc("","testingfans",FALSE,testingfans);
-  // iiAddCproc("","testingvisuals",FALSE,testingvisuals);
-  // iiAddCproc("","testingstrings",FALSE,testingstrings);
-  // iiAddCproc("","testingmatrices",FALSE,testingmatrices);
-  // iiAddCproc("","loadPolymakeDocumentation",FALSE,loadPolymakeDocumentation);
+  p->iiAddCproc("polymake.so","vertexAdjacencyGraph",FALSE,PMvertexAdjacencyGraph);
+  p->iiAddCproc("polymake.so","vertexEdgeGraph",FALSE,PMvertexEdgeGraph);
 
   blackbox* b=getBlackboxStuff(polytopeID);

gfanlib/gfanlib_matrix.h

@@ -69 +69 @@
   void appendRow(Vector<typ> const &v)
     {
-      assert(v.size()==width);
+      assert((int)v.size()==width);
       rows.push_back(v);
       height++;
@@ -410 +410 @@
   {
     assert(typ::isField());
-    assert(v.size()==getWidth());
+    assert((int)v.size()==getWidth());
 
     int pivotI=-1;

gfanlib/gfanlib_polyhedralfan.cpp

@@ -352 +352 @@
 
       bool notAll=false;
-      for(int j=0;j<theCone.indices.size();j++)
+      for(unsigned j=0;j<theCone.indices.size();j++)
         if(dot(rays[theCone.indices[j]],facetCandidates[i]).sign()==0)
           indices.insert(theCone.indices[j]);
@@ -395 +395 @@
 void addFacesToSymmetricComplex(SymmetricComplex &c, ZCone const &cone, ZMatrix const &facetCandidates, ZMatrix const &generatorsOfLinealitySpace)
 {
-  ZMatrix const &rays=c.getVertices();
+  // ZMatrix const &rays=c.getVertices();
   std::set<int> indices;
 
@@ -502 +502 @@
 }
 
-std::string PolyhedralFan::toString(int flags)const
+std::string PolyhedralFan::toString(int /*flags*/)const
 //void PolyhedralFan::printWithIndices(class Printer *p, bool printMultiplicities, SymmetryGroup *sym, bool group, bool ignoreCones, bool xml, bool tPlaneSort, vector<string> const *comments)const
 {

gfanlib/gfanlib_polymakefile.cpp

@@ -53 +53 @@
   list<int> ret;
   int c=s.peek();
-  while((c>='0') && (c<='9')|| (c==' '))
+  while(((c>='0') && (c<='9')) || (c==' '))
     {
       //      fprintf(Stderr,"?\n");
@@ -66 +66 @@
 namespace gfan{
 PolymakeProperty::PolymakeProperty(const std::string &name_, const std::string &value_):
-  name(name_),
-  value(value_)
+  value(value_),
+  name(name_)
 {
 }
@@ -271 +271 @@
 
 
-bool PolymakeFile::readBooleanProperty(const char *p)
+bool PolymakeFile::readBooleanProperty(const char */*p*/)
 {
   return false;
@@ -277 +277 @@
 
 
-void PolymakeFile::writeBooleanProperty(const char *p, bool n)
+void PolymakeFile::writeBooleanProperty(const char */*p*/, bool /*n*/)
 {
 }
@@ -322 +322 @@
   stringstream t;
 
-  if(comments)assert(comments->size()>=m.getHeight());
+  if(comments)assert((int)comments->size()>=m.getHeight());
   if(isXml)
     {
@@ -389 +389 @@
     {
       t<<"<incidence_matrix>";
-      for(int i=0;i<m.size();i++)
+      for(unsigned i=0;i<m.size();i++)
         {
           t<<"<set>";
@@ -405 +405 @@
   else
     {
-      for(int i=0;i<m.size();i++)
+      for(unsigned i=0;i<m.size();i++)
         {
           t<<'{';
@@ -445 +445 @@
     {
       t<<"<vector>";
-      for(int i=0;i<v.size();i++)
+      for(unsigned i=0;i<v.size();i++)
         {
           if(i!=0)t<<" ";
@@ -454 +454 @@
   else
     {
-      for(int i=0;i<v.size();i++)
+      for(unsigned i=0;i<v.size();i++)
         {
           if(i!=0)t<<" ";

gfanlib/gfanlib_q.h

@@ -156 +156 @@
     return mpq_sgn(value);
   }
-  static Rational gcd(Rational const &a, Rational const &b, Rational &s, Rational &t)
+  static Rational gcd(Rational const &a, Rational const /*&b*/, Rational /*&s*/, Rational /*t*/)
   {
 /*    mpz_t r;

gfanlib/gfanlib_symmetriccomplex.cpp

@@ -15 +15 @@
 
 SymmetricComplex::Cone::Cone(std::set<int> const &indices_, int dimension_, Integer multiplicity_, bool sortWithSymmetry, SymmetricComplex const &complex):
+  isKnownToBeNonMaximalFlag(false),
   dimension(dimension_),
   multiplicity(multiplicity_),
-  isKnownToBeNonMaximalFlag(false),
   sortKeyPermutation(complex.n)
 {
@@ -27 +27 @@
   ZMatrix const &vertices=complex.getVertices();
   ZVector sum(vertices.getWidth());
-  for(int i=0;i<indices.size();i++)
+  for(unsigned i=0;i<indices.size();i++)
     sum+=vertices[indices[i]];
 
@@ -56 +56 @@
   ZMatrix const &vertices=complex.getVertices();
   ZVector sum(vertices.getWidth());
-  for(int i=0;i<indices.size();i++)
+  for(unsigned i=0;i<indices.size();i++)
     sum+=vertices[indices[i]];
 
@@ -62 +62 @@
   Permutation const &bestPermutation=sortKeyPermutation;
 
-  assert(bestPermutation.size()==n);
+  assert((int)bestPermutation.size()==n);
 
   IntVector indicesNew(indices.size());
   int I=0;
-  for(int i=0;i<indices.size();i++,I++)
+  for(unsigned i=0;i<indices.size();i++,I++)
     {
       ZVector ny=bestPermutation.apply(complex.vertices[indices[i]]);
@@ -80 +80 @@
 {
   std::set<int> ret;
-  for(int i=0;i<indices.size();i++)
+  for(unsigned i=0;i<indices.size();i++)
     ret.insert(indices[i]);
 
@@ -89 +89 @@
 {
   int next=0;
-  for(int i=0;i<indices.size();i++)
+  for(unsigned i=0;i<indices.size();i++)
     {
       while(1)
         {
-          if(next>=c.indices.size())return false;
+          if(next>=(int)c.indices.size())return false;
           if(indices[i]==c.indices[next])break;
           next++;
@@ -105 +105 @@
 {
   std::set<int> r;
-  for(int i=0;i<indices.size();i++)
+  for(unsigned i=0;i<indices.size();i++)
     {
       ZVector ny=permutation.apply(complex.vertices[indices[i]]);
@@ -139 +139 @@
 {
   ZMatrix l;
-  for(int i=0;i<indices.size();i++)
+  for(unsigned i=0;i<indices.size();i++)
     l.appendRow(complex.vertices[indices[i]]);
 
@@ -150 +150 @@
 SymmetricComplex::SymmetricComplex(ZMatrix const &rays, ZMatrix const &linealitySpace_, SymmetryGroup const &sym_):
   n(rays.getWidth()),
+  linealitySpace(canonicalizeSubspace(linealitySpace_)),
   sym(sym_),
-  dimension(-1),
-  linealitySpace(canonicalizeSubspace(linealitySpace_))
+  dimension(-1)
 {
   assert(rays.getWidth()==linealitySpace.getWidth());
@@ -222 +222 @@
 }
 
-/*
+#if 0
 IntVector SymmetricComplex::dimensionsAtInfinity()const
 {
@@ -228 +228 @@
      dimension of the intersection of each cone in the complex with
      the plane x_0=0 */
-/*
   IntVector ret(cones.size());
 
@@ -247 +246 @@
   return ret;
 }
-*/
+#endif
 
 void SymmetricComplex::buildConeLists(bool onlyMaximal, bool compressed, std::vector<std::vector<IntVector > >*conelist/*, ZMatrix *multiplicities*/)const
@@ -259 +258 @@
       int numberOfOrbitsOutput=0;
       int numberOfOrbitsOfThisDimension=0;
-      bool newDimension=true;
+      // bool newDimension=true;
         {
           int I=0;
           for(ConeContainer::const_iterator i=cones.begin();i!=cones.end();i++,I++)
-                  if(i->dimension==d)
-                    {
-                  numberOfOrbitsOfThisDimension++;
+            if(i->dimension==d)
+            {
+              numberOfOrbitsOfThisDimension++;
               if(!onlyMaximal || isMaximal(*i))
                 {
                   numberOfOrbitsOutput++;
-                  bool isMax=isMaximal(*i);
-                  bool newOrbit=true;
+                  // bool isMax=isMaximal(*i);
+                  // bool newOrbit=true;
                   std::set<std::set<int> > temp;
-                    for(SymmetryGroup::ElementContainer::const_iterator k=sym.elements.begin();k!=sym.elements.end();k++)
-                      {
+                  for(SymmetryGroup::ElementContainer::const_iterator k=sym.elements.begin();k!=sym.elements.end();k++)
+                    {
                         Cone temp1=i->permuted(*k,*this,false);
                         temp.insert(temp1.indexSet());
@@ -291 +290 @@
                           *multiplicities << std::endl;
                         }*/
-                      newOrbit=false;
-                      newDimension=false;
+                      // newOrbit=false;
+                      // newDimension=false;
                     }
-              }
-                    }
-        }
-    }
-
-}
-
-std::string SymmetricComplex::toStringJustCones(int dimLow, int dimHigh, bool onlyMaximal, bool group, std::ostream *multiplicities, bool compressed, bool tPlaneSort)const
+                }
+            }
+        }
+    }
+
+}
+
+std::string SymmetricComplex::toStringJustCones(int dimLow, int dimHigh, bool onlyMaximal, bool group, std::ostream *multiplicities, bool compressed, bool /*tPlaneSort*/)const
 {
   std::stringstream ret;
@@ -392 +391 @@
         {
           bool isBounded=true;
-          for(int j=0;j<i->indices.size();j++)
+          for(unsigned j=0;j<i->indices.size();j++)
             if(vertices[i->indices[j]][0].sign()==0)isBounded=false;
           doAdd=isBounded;
@@ -692 +691 @@
   {
     ZMatrix generators(indices.size(),getAmbientDimension());
-    for(int i=0;i<indices.size();i++)
+    for(unsigned i=0;i<indices.size();i++)
       generators[i]=vertices[indices[i]];
     return ZCone::givenByRays(generators,linealitySpace);

gfanlib/gfanlib_symmetry.cpp

@@ -25 +25 @@
                 TrieNode(IntVector const &v, int i)
                 {
-                        if(i<v.size())
+                  if(i<(int)v.size())
                         m[v[i]]=TrieNode(v,i+1);
                 }
@@ -31 +31 @@
                 {
                   int ret=0;
-                  if(i==v.size())return 1;
+                  if(i==(int)v.size())return 1;
                   for(Map::const_iterator j=m.begin();j!=m.end();j++)
                     {
@@ -41 +41 @@
                 void search(ZVector const &v, ZVector  &building, Permutation &tempPerm, Permutation &ret, ZVector &optimal, int i, bool &isImproving)const
                 {
-                        if(i==v.size()){ret=tempPerm;optimal=building;isImproving=false;return;}
+                  if(i==(int)v.size()){ret=tempPerm;optimal=building;isImproving=false;return;}
                         if(isImproving)
                                 building[i]=-0x7fffffff;
@@ -61 +61 @@
                 void searchStabalizer(ZVector const &v, ZVector  &building, Permutation &tempPerm, Permutation &ret, ZVector &optimal, int i, bool &isImproving, ZVector const &toBeFixed)const
                 {
-                        if(i==v.size())
+                  if(i==(int)v.size())
                                 if(!(tempPerm.apply(v)<optimal))
                                         {
@@ -102 +102 @@
                 void insert(Permutation const &v, int i)
                 {
-                        if(i==v.size())return;
+                  if(i==(int)v.size())return;
                         if(m.count(v[i]))
                                 m[v[i]].insert(v,i+1);
@@ -132 +132 @@
         int n;
         Trie(int n_):
-                n(n_),
-                theTree(Permutation(n_),0)
+                theTree(Permutation(n_),0),
+                n(n_)
         {
         }
@@ -276 +276 @@
   IntVector ret(size());
   assert(size()==b.size());
-  for(int i=0;i<size();i++)ret[i]=b[(*this)[i]];
+  for(unsigned i=0;i<size();i++)ret[i]=b[(*this)[i]];
   return Permutation(ret);
 }
@@ -284 +284 @@
   IntVector ret(size());
   assert(size()==b.size());
-  for(int i=0;i<size();i++)ret[(*this)[i]]=b[i];
+  for(unsigned i=0;i<size();i++)ret[(*this)[i]]=b[i];
   return Permutation(ret);
 }
@@ -292 +292 @@
   IntVector ret(size());
   assert(size()==v.size());
-  for(int i=0;i<size();i++)ret[i]=v[(*this)[i]];
+  for(unsigned i=0;i<size();i++)ret[i]=v[(*this)[i]];
   return ret;
 }
@@ -300 +300 @@
   ZVector ret(size());
   assert(size()==v.size());
-  for(int i=0;i<size();i++)ret[i]=v[(*this)[i]];
+  for(unsigned i=0;i<size();i++)ret[i]=v[(*this)[i]];
   return ret;
 }
@@ -309 +309 @@
   ZVector ret(size());
   assert(size()==v.size());
-  for(int i=0;i<size();i++)ret[(*this)[i]]=v[i];
+  for(unsigned i=0;i<size();i++)ret[(*this)[i]]=v[i];
   return ret;
 }
@@ -431 +431 @@
 ZVector Permutation::fundamentalDomainInequality()const
 {
-  for(int i=0;i<size();i++)
-    if((*this)[i]!=i)
+  for(unsigned i=0;i<size();i++)
+    if((*this)[i]!=(int)i)
       return ZVector::standardVector(size(),i)-ZVector::standardVector(size(),(*this)[i]);
   return ZVector(size());

gfanlib/gfanlib_vector.h

@@ -101 +101 @@
       if(size()<b.size())return true;
       if(size()>b.size())return false;
-      for(int i=0;i<size();i++)
+      for(unsigned i=0;i<size();i++)
         {
           if(v[i]<b[i])return true;
@@ -156 +156 @@
       return pq*pq==pp*qq;
 */
-          int n=p.size();
+          unsigned n=p.size();
           assert(n==q.size());
-          int i;
+          unsigned i;
           for(i=0;i<n;i++)
           {
@@ -167 +167 @@
           typ a=p.v[i];
           typ b=q.v[i];
-          for(int j=0;j<n;j++)
+          for(unsigned j=0;j<n;j++)
             if(a*q.v[j]!=b*p.v[j])return false;
           return true;
@@ -175 +175 @@
   // Arithmetic slow
   //-----------------
-  inline friend Vector operator*(typ s, const Vector& q){Vector p=q;for(int i=0;i<q.size();i++)p[i]*=s;return p;}
+  inline friend Vector operator*(typ s, const Vector& q){Vector p=q;for(unsigned i=0;i<q.size();i++)p[i]*=s;return p;}
 //  inline friend Vektor operator/(const Vektor& q, typ s){Vektor p=q;for(int i=0;i<q.size();i++)p[i]/=s;return p;}
 /*  inline friend Vector operator*(const Vektor& p, const Vektor& q){assert(p.size()==q.size());Vektor p1=p;for(int i=0;i<p.size();i++)p1.v[i]*=q.v[i];return p1;}
@@ -181 +181 @@
 */
   inline friend Vector operator/(const Vector& p, typ const &s){Vector ret(p.size());for(unsigned i=0;i<p.size();i++)ret[i]=p[i]/s;return ret;}
-  inline friend Vector operator+(const Vector& p, const Vector& q){assert(p.size()==q.size());Vector p1=p;for(int i=0;i<p.size();i++)p1[i]+=q[i];return p1;}
-  inline friend Vector operator-(const Vector& p, const Vector& q){assert(p.size()==q.size());Vector p1=p;for(int i=0;i<p.size();i++)p1[i]-=q[i];return p1;}
-  inline friend Vector max(const Vector& p, const Vector& q){assert(p.size()==q.size());Vector p1=p;for(int i=0;i<p.size();i++)if(p1[i]<q[i])p1[i]=q[i];return p1;}
-  inline friend Vector min(const Vector& p, const Vector& q){assert(p.size()==q.size());Vector p1=p;for(int i=0;i<p.size();i++)if(p1[i]>q[i])p1[i]=q[i];return p1;}
+  inline friend Vector operator+(const Vector& p, const Vector& q){assert(p.size()==q.size());Vector p1=p;for(unsigned i=0;i<p.size();i++)p1[i]+=q[i];return p1;}
+  inline friend Vector operator-(const Vector& p, const Vector& q){assert(p.size()==q.size());Vector p1=p;for(unsigned i=0;i<p.size();i++)p1[i]-=q[i];return p1;}
+  inline friend Vector max(const Vector& p, const Vector& q){assert(p.size()==q.size());Vector p1=p;for(unsigned i=0;i<p.size();i++)if(p1[i]<q[i])p1[i]=q[i];return p1;}
+  inline friend Vector min(const Vector& p, const Vector& q){assert(p.size()==q.size());Vector p1=p;for(unsigned i=0;i<p.size();i++)if(p1[i]>q[i])p1[i]=q[i];return p1;}
 
   friend Vector operator-(const Vector &b)
   {
     Vector ret(b.size());
-    for(int i=0;i<b.size();i++)ret[i]=-b[i];
+    for(unsigned i=0;i<b.size();i++)ret[i]=-b[i];
     return ret;
   }
@@ -226 +226 @@
     {
       assert(begin>=0);
-      assert(end<=size());
+      assert(end<=(int)size());
       assert(end>=begin);
       Vector ret(end-begin);
@@ -293 +293 @@
     typ temp1,temp2;
     typ ret(1);
-    for(int i=0;i<size();i++)
+    for(unsigned i=0;i<size();i++)
       ret=typ::gcd(ret,v[i],temp1,temp2);
     return ret;

gfanlib/gfanlib_zcone.cpp

@@ -44 +44 @@
     dd_colrange d_input,j;
     dd_RepresentationType rep=dd_Inequality;
-    dd_boolean found=dd_FALSE, newformat=dd_FALSE, successful=dd_FALSE;
-    char command[dd_linelenmax], comsave[dd_linelenmax];
+    // dd_boolean found=dd_FALSE, newformat=dd_FALSE, successful=dd_FALSE;
+    // char command[dd_linelenmax], comsave[dd_linelenmax];
     dd_NumberType NT;
 
     (*Error)=dd_NoError;
 
-    rep=dd_Inequality; newformat=dd_TRUE;
+    rep=dd_Inequality; // newformat=dd_TRUE;
 
     m_input=g.getHeight();
@@ -70 +70 @@
     }
 
-    successful=dd_TRUE;
+    // successful=dd_TRUE;
 
     return M;
@@ -108 +108 @@
   {
     bool ret;
-    dd_MatrixPtr M=NULL,M2=NULL,M3=NULL;
-    dd_colrange d;
+    dd_MatrixPtr M=NULL/*,M2=NULL,M3=NULL*/;
+    // dd_colrange d;
     dd_ErrorType err=dd_NoError;
-    dd_rowset redrows,linrows,ignoredrows, basisrows;
-    dd_colset ignoredcols, basiscols;
-    dd_DataFileType inputfile;
-    FILE *reading=NULL;
+    // dd_rowset redrows,linrows,ignoredrows, basisrows;
+    // dd_colset ignoredcols, basiscols;
+    // dd_DataFileType inputfile;
+    // FILE *reading=NULL;
 
     cddinitGmp();
@@ -121 +121 @@
     if (err!=dd_NoError) goto _L99;
 
-    d=M->colsize;
+    // d=M->colsize;
 
     static dd_Arow temp;
@@ -339 +339 @@
     if(numberOfRows==0)return;//the full space, so description is already irredundant
 
-    dd_rowset r=NULL;
+    // dd_rowset r=NULL;
     ZMatrix g=inequalities;
     g.append(equations);
 
-    dd_LPSolverType solver=dd_DualSimplex;
+    // dd_LPSolverType solver=dd_DualSimplex;
     dd_MatrixPtr A=NULL;
     dd_ErrorType err=dd_NoError;
@@ -402 +402 @@
     int numberOfRows=numberOfEqualities+numberOfInequalities;
 
-    dd_rowset r=NULL;
+    // dd_rowset r=NULL;
     ZMatrix g=inequalities;
     g.append(equations);
@@ -448 +448 @@
   void dual(ZMatrix const &inequalities, ZMatrix const &equations, ZMatrix &dualInequalities, ZMatrix &dualEquations)
   {
-    int result;
+    // int result;
 
     dd_MatrixPtr A=NULL;
@@ -472 +472 @@
 
     return;
-   _L99:
-    assert(0);
+   // _L99:
+   //  assert(0);
   }
   // this procedure is take from cddio.c.
@@ -556 +556 @@
     int dim2=inequalities.getHeight();
     if(dim2==0)return std::vector<std::vector<int> >();
-    int dimension=inequalities.getWidth();
+    // int dimension=inequalities.getWidth();
 
     dd_MatrixPtr A=NULL;
@@ -603 +603 @@
 
     return ret;
-   _L99:
-    assert(0);
-    return std::vector<std::vector<int> >();
+   // _L99:
+   //  assert(0);
+   //  return std::vector<std::vector<int> >();
   }
 
@@ -707 +707 @@
           inequalities=LpSolver::fastNormals(inequalities2);
           goto noFallBack;
-        fallBack://alternativ (disabled)
-          lpSolver.removeRedundantRows(inequalities,equations,true);
+        // fallBack://alternativ (disabled)
+        //   lpSolver.removeRedundantRows(inequalities,equations,true);
         noFallBack:;
         }
@@ -730 +730 @@
 }
 
-std::ostream &operator<<(std::ostream &f, ZCone const &c)
+void operator<<(std::ostream &f, ZCone const &c)
 {
   f<<"Ambient dimension:"<<c.n<<std::endl;
@@ -741 +741 @@
 
 ZCone::ZCone(int ambientDimension):
+  preassumptions(PCP_impliedEquationsKnown|PCP_facetsKnown),
+  state(1),
+  n(ambientDimension),
+  multiplicity(1),
+  linearForms(ZMatrix(0,ambientDimension)),
   inequalities(ZMatrix(0,ambientDimension)),
   equations(ZMatrix(0,ambientDimension)),
-  n(ambientDimension),
-  state(1),
-  preassumptions(PCP_impliedEquationsKnown|PCP_facetsKnown),
+  haveExtremeRaysBeenCached(false)
+{
+}
+
+
+ZCone::ZCone(ZMatrix const &inequalities_, ZMatrix const &equations_, int preassumptions_):
+  preassumptions(preassumptions_),
+  state(0),
+  n(inequalities_.getWidth()),
   multiplicity(1),
-  haveExtremeRaysBeenCached(false),
-  linearForms(ZMatrix(0,ambientDimension))
-{
-}
-
-
-ZCone::ZCone(ZMatrix const &inequalities_, ZMatrix const &equations_, int preassumptions_):
+  linearForms(ZMatrix(0,inequalities_.getWidth())),
   inequalities(inequalities_),
   equations(equations_),
-  state(0),
-  preassumptions(preassumptions_),
-  multiplicity(1),
-  haveExtremeRaysBeenCached(false),
-  n(inequalities_.getWidth()),
-  linearForms(ZMatrix(0,inequalities_.getWidth()))
+  haveExtremeRaysBeenCached(false)
   {
   assert(preassumptions_<4);//OTHERWISE WE ARE DOING SOMETHING STUPID LIKE SPECIFYING AMBIENT DIMENSION
@@ -1042 +1042 @@
   std::vector<std::vector<int> > indices=lpSolver.extremeRaysInequalityIndices(inequalities);
 
-  for(int i=0;i<indices.size();i++)
+  for(unsigned i=0;i<indices.size();i++)
     {
       /* At this point we know lineality space, implied equations and
@@ -1082 +1082 @@
 
           std::vector<int> asVector(inequalities.getHeight());
-          for(int j=0;j<indices[i].size();j++){asVector[indices[i][j]]=1;}
+          for(unsigned j=0;j<indices[i].size();j++){asVector[indices[i][j]]=1;}
           ZMatrix equations=this->equations;
           ZVector theInequality;
 
-          for(int j=0;j<asVector.size();j++)
+          for(unsigned j=0;j<asVector.size();j++)
             if(asVector[j])
               equations.appendRow(inequalities[j]);
@@ -1229 +1229 @@
 ZCone ZCone::faceContaining(ZVector const &v)const
 {
-  assert(n==v.size());
+  assert(n==(int)v.size());
   assert(contains(v));
   ZMatrix newEquations=equations;

gfanlib/gfanlib_zcone.h

@@ -352 +352 @@
      */
    // PolyhedralCone projection(int newn)const;
-    friend std::ostream &operator<<(std::ostream &f, ZCone const &c);
+    friend void operator<<(std::ostream &f, ZCone const &c);
 };
 

gfanlib/gfanlib_zfan.cpp

@@ -16 +16 @@
   {
     assert(dimension>=0);
-    if(dimension>=T.size())return 0;
+    if(dimension>=(int)T.size())return 0;
     return T[dimension].size();
   }
@@ -162 +162 @@
 
 //        log2 cerr<< "Number of orbits to expand "<<cones.size()<<endl;
-        for(int i=0;i<cones.size();i++)
+        for(unsigned i=0;i<cones.size();i++)
         //  if(coneIndices==0 || coneIndices->count(i))
             {
@@ -202 +202 @@
   }
   ZFan::ZFan(ZFan const& f):
+    coneCollection(0),
     complex(0),
-    coneCollection(0),
     cones(f.table(0,0)),
     maximalCones(f.table(0,1)),

m4/flags.m4

@@ -87 +87 @@
  AC_LANG_PUSH([C++])
  AX_APPEND_COMPILE_FLAGS(${FLAGS}, [CXXFLAGS])
+ AX_APPEND_COMPILE_FLAGS([-fexceptions -frtti], [POLYMAKE_CXXFLAGS])
  AC_LANG_POP([C++])
 
  AX_APPEND_LINK_FLAGS(${FLAGS}) 
- 
+
+ AC_SUBST(POLYMAKE_CXXFLAGS)
+
  if test "x${ENABLE_DEBUG}" == xyes; then
   DBGFLAGS="-g -ftrapv -fdiagnostics-show-option -Wall -Wextra"
@@ -121 +124 @@
  fi
 
-
 # SING_SHOW_FLAGS([before PROG_C_CC])