Changeset d4df72 in git

Timestamp:

Oct 25, 2010, 3:34:57 PM (14 years ago)

Author:

Frank Seelisch <seelisch@…>

Branches:

(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', 'b4f17ed1d25f93d46dbe29e4b499baecc2fd51bb')

Children:

386a8636dfd438b85470e212f44acfc042909ef7

Parents:

def863c5f805648a6621b7829a098d93a4674d70

Message:

including ZCone code to link with gfan lib

git-svn-id: file:///usr/local/Singular/svn/trunk@13559 2c84dea3-7e68-4137-9b89-c4e89433aadc

Location:

Singular

Files:

• Makefile.in (modified) (2 diffs)
• claptmpl.cc (modified) (2 diffs)
• configure (modified) (1 diff)
• configure.in (modified) (1 diff)
• iparith.cc (modified) (16 diffs)
• ipassign.cc (modified) (6 diffs)
• ipid.cc (modified) (2 diffs)
• subexpr.cc (modified) (5 diffs)
• tok.h (modified) (1 diff)

Singular/Makefile.in

@@ -96 +96 @@
 LIBSP           = -lm @NEED_LIBSG@
 else
-LIBS            = -lsingfac -lsingcf -lntl  -static -lreadline -lhtmlhelp -Xlinker -Bdynamic -lgmp -lomalloc_ndebug -lncurses
+LIBS            = -lsingfac -lsingcf -lntl  -static -lreadline -lhtmlhelp -lgfan -lcddgmp -Xlinker -Bdynamic -lgmp -lomalloc_ndebug -lncurses
 ## -lpython_module -lpython2.4 /usr/local/lib/libboost_python-gcc-d-1_32.dll
-LIBSG           = -lsingfac -lsingcf -lntl  -static -lreadline -lhtmlhelp -Xlinker -Bdynamic -lgmp -lncurses
+LIBSG           = -lsingfac -lsingcf -lntl  -static -lreadline -lhtmlhelp -lgfan -lcddgmp -Xlinker -Bdynamic -lgmp -lncurses
 endif
 MP_LIBS         = @MP_LIBS@
@@ -381 +381 @@
         ${CXX} ${CXXFLAGS}  ${CPPFLAGS} ${DEFS} -c $<
 
-iparith.inc: gentable.cc grammar.h tok.h table.h mod2.h
-        ${CXX} ${CXXFLAGS} ${CPPFLAGS} ${CXXTEMPLFLAGS} ${DEFS} gentable.cc \
-             -o gentable1
+iparith.inc: ${OBJS} claptmpl.o iparith.cc \
+                          ipconv.cc tok.h mpsr_Tok.cc grammar.h mod2.h
+        ${CXX} ${CXXFLAGS} ${CPPFLAGS} ${CXXTEMPLFLAGS} ${DEFS} -DGENTABLE \
+             -o gentable1 claptmpl.o iparith.cc tesths.cc mpsr_Tok.cc \
+             ${OBJS} ${LDFLAGS} ${LIBS} ../kernel/mmalloc.o
         ./gentable1
         /bin/rm -f gentable1 gentable1.exe
 
-mpsr_Tok.inc: gentable2.cc grammar.h tok.h table.h mod2.h
-        ${CXX} ${CXXFLAGS} ${CPPFLAGS} ${CXXTEMPLFLAGS} ${DEFS} gentable2.cc \
-             -o gentable2
+mpsr_Tok.inc: ${OBJS} claptmpl.o iparith.cc \
+                          ipconv.cc tok.h mpsr_Tok.cc grammar.h mod2.h
+        ${CXX} ${CXXFLAGS} ${CPPFLAGS} ${CXXTEMPLFLAGS} ${DEFS} -DGENTABLE \
+             -o gentable2 claptmpl.o iparith.cc tesths.cc mpsr_Tok.cc \
+             ${OBJS} ${LDFLAGS} ${LIBS} ../kernel/mmalloc.o
         ./gentable2
         /bin/rm -f gentable2 gentable2.exe
+
 
 svnver: 

Singular/claptmpl.cc

@@ -161 +161 @@
   template class List<fglmDelem>;
   template class ListIterator<fglmDelem>;
+#endif
+
+#ifdef HAVE_FANS
+#include <gfanlib/gfanlib.h>
 #endif
 
@@ -261 +265 @@
 template class Cache<MinorKey, PolyMinorValue>;
 #endif
+
+#ifdef HAVE_FANS
+template class gfan::Vector<gfan::Integer>;
+template class gfan::Vector<gfan::Rational>;
+template class gfan::Matrix<gfan::Integer>;
+template class gfan::Matrix<gfan::Rational>;
+#endif
 //template int pos_helper(kStrategy strat, poly p, int len, intset setL, polyset set);

Singular/configure

@@ -5266 +5266 @@
     { echo "configure: error: can not build with gmp" 1>&2; exit 1; }
   fi
+fi
+
+echo $ac_n "checking gfan lib""... $ac_c" 1>&6
+if test "$enable_gfanlib" = yes; then
+  echo "yes"
+  NEED_LIBS="${NEED_LIBS} -lcddgmp -lgfan"
+else
+  echo "no"
 fi
 

Singular/configure.in

@@ -884 +884 @@
 fi
 
+AC_MSG_CHECKING(gfanlib)
+if test "$enable_gfanlib" = yes; then
+  AC_MSG_RESULT(yes)
+  NEED_LIBS="${NEED_LIBS} -lgfan -lcddgmp"
+else
+  AC_MSG_RESULT(can not build with gfan lib)
+fi
+
 AC_MSG_CHECKING(whether to use libsvd)
 if test "$with_svd" = yes; then

Singular/iparith.cc

@@ -71 +71 @@
 #include <Singular/Fan.h>
 #include <Singular/Cone.h>
+#include <gfanlib/gfanlib.h>
 
 #include <kernel/timer.h>
@@ -3161 +3162 @@
 }
 #ifdef HAVE_FANS
-static BOOLEAN jjADDMCONE1(leftv res, leftv u, leftv v)
-{
-  /* method for adding a maximal cone in the given fan;
-     valid parametrizations: (fan, cone),
+int integerToInt(gfan::Integer const &V, bool &ok)
+{
+  mpz_t v;
+  mpz_init(v);
+  V.setGmp(v);
+  int ret=0;
+  if(mpz_fits_sint_p(v))
+    ret=mpz_get_si(v);
+  else
+    ok=false;
+  mpz_clear(v);
+  return ret;
+}
+intvec* zVector2Intvec(const gfan::ZVector zv)
+{
+  int d=zv.size();
+  intvec* iv = new intvec(1, d, 0);
+  bool ok = true;
+  for(int i=1;i<=d;i++)
+    IMATELEM(*iv, 1, i) = integerToInt(zv[i-1], ok);
+  if (!ok) WerrorS("overflow while converting a gfan::ZVector to an intvec");
+  return iv;
+}
+intvec* zMatrix2Intvec(const gfan::ZMatrix zm)
+{
+  int d=zm.getHeight();
+  int n=zm.getWidth();
+  intvec* iv = new intvec(d, n, 0);
+  bool ok = true;
+  for(int i=1;i<=d;i++)
+    for(int j=1;j<=n;j++)
+      IMATELEM(*iv, i, j) = integerToInt(zm[i-1][j-1], ok);
+  if (!ok) WerrorS("overflow while converting a gfan::ZMatrix to an intmat");
+  return iv;
+}
+gfan::ZMatrix intmat2ZMatrix(const intvec* iMat)
+{
+  int d=iMat->rows();
+  int n=iMat->cols();
+  gfan::ZMatrix ret(d,n);
+  for(int i=0;i<d;i++)
+    for(int j=0;j<n;j++)
+      ret[i][j]=IMATELEM(*iMat, i+1, j+1);
+  return ret;
+}
+/* expects iMat to have just one row */
+gfan::ZVector intvec2ZVector(const intvec* iVec)
+{
+  int n =iVec->rows();
+  gfan::ZVector ret(n);
+  for(int j=0;j<n;j++)
+    ret[j]=IMATELEM(*iVec, j+1, 1);
+  return ret;
+}
+static BOOLEAN jjCONERAYS2(leftv res, leftv u, leftv v)
+{
+  /* method for generating a cone object from half-lines,
+     and lines (any point in the cone being the sum of a point
+     in the convex hull of the half-lines and a point in the span
+     of the lines; the second argument may contain or entirely consist
+     of zero rows);
+     valid parametrizations: (intmat, intmat)
      Errors will be invoked in the following cases:
-     - the cone has been generated in the context of a
-       fan which is different from the given one */
-  Fan* f = (Fan*)u->Data();
-  Cone* c = (Cone*)v->Data();
-  if (! f->addMaxCone(c))
-  {
-    WerrorS("cone references a fan which is different from the 1st argument");
-    return TRUE;
-  }
-  else return FALSE;
-}
-static BOOLEAN jjADDMCONE2(leftv res, leftv u, leftv v)
-{
-  /* method for adding numerous maximal cones in the given fan;
-     valid parametrizations: (fan, list),
-     where the list entries are expected to be cones;
+     - u and v have different numbers of columns */
+  intvec* rays = (intvec *)u->CopyD(INTVEC_CMD);
+  intvec* linSpace = (intvec *)v->CopyD(INTVEC_CMD);
+  if (rays->cols() != linSpace->cols())
+  {
+    Werror("expected same number of columns but got %d vs. %d",
+           rays->cols(), linSpace->cols());
+    return TRUE;
+  }
+  gfan::ZMatrix zm1 = intmat2ZMatrix(rays);
+  gfan::ZMatrix zm2 = intmat2ZMatrix(linSpace);
+  gfan::ZCone* zc = new gfan::ZCone();
+  *zc = gfan::ZCone::givenByRays(zm1, zm2);
+  res->data = (char *)zc;
+  return FALSE;
+}
+static BOOLEAN jjFACECONT(leftv res, leftv u, leftv v)
+{
+  gfan::ZCone* zc = (gfan::ZCone*)u->Data();
+  intvec* iv = (intvec*)v->Data();
+  gfan::ZVector zv = intvec2ZVector(iv);
+  int d1 = zc->ambientDimension();
+  int d2 = zv.size();
+  if (d1 != d2)
+    Werror("expected ambient dim of cone and size of vector\n"
+           "to be equal but got %d and %d", d1, d2);
+  if(!zc->contains(zv))
+  {
+    WerrorS("provided intvec does not lie in the cone");
+  }
+  res->data = (void *)new gfan::ZCone(zc->faceContaining(zv));
+  return FALSE;
+}
+static BOOLEAN jjINTERSC(leftv res, leftv u, leftv v)
+{ 
+  gfan::ZCone* zc1 = (gfan::ZCone*)u->Data();
+  gfan::ZCone* zc2 = (gfan::ZCone*)v->Data();
+  int d1 = zc1->ambientDimension();
+  int d2 = zc2->ambientDimension();
+  if (d1 != d2)
+    Werror("expected ambient dims of both cones to coincide\n"
+           "but got %d and %d", d1, d2);
+  gfan::ZCone zc3 = gfan::intersection(*zc1, *zc2);
+  res->data = (void *)new gfan::ZCone(zc3);
+  return FALSE;
+}
+static BOOLEAN jjCONELINK(leftv res, leftv u, leftv v)
+{
+  gfan::ZCone* zc = (gfan::ZCone*)u->Data();
+  intvec* iv = (intvec*)v->Data();
+  gfan::ZVector zv= intvec2ZVector(iv);
+  int d1 = zc->ambientDimension();
+  int d2 = zv.size();
+  if (d1 != d2)
+    Werror("expected ambient dim of cone and size of vector\n"
+           "to be equal but got %d and %d", d1, d2);
+  if(!zc->contains(zv))
+  {
+    WerrorS("the provided intvec does not lie in the cone");
+  }
+  res->data = (void *)new gfan::ZCone(zc->link(zv));
+  return FALSE;
+}
+static BOOLEAN jjCONTAINS2(leftv res, leftv u, leftv v)
+{
+  gfan::ZCone* zc1 = (gfan::ZCone*)u->Data();
+  gfan::ZCone* zc2 = (gfan::ZCone*)v->Data();
+  int d1 = zc1->ambientDimension();
+  int d2 = zc2->ambientDimension();
+  if (d1 != d2)
+    Werror("expected cones with same ambient dimensions\n but got"
+           " dimensions %d and %d", d1, d2);
+  res->data = (void *)(zc1->contains(*zc2) ? 1 : 0);
+  return FALSE;
+}
+static BOOLEAN jjCONENORMALS2(leftv res, leftv u, leftv v)
+{
+  /* method for generating a cone object from iequalities,
+     and equations (...)
+     valid parametrizations: (intmat, intmat)
      Errors will be invoked in the following cases:
-     - one of the cones has been generated in the context
-       of a fan which is different from the given one */
-  Fan* f = (Fan*)u->Data();
-  lists L = (lists)v->Data();
-  int index = f->addMaxCones(L);
-  if (index != 0)
-  {
-    Werror("cone at position %d references a fan which %s",
-           index, "is different from the 1st argument");
-    return TRUE;
-  }
-  else return FALSE;
+     - u and v have different numbers of columns */
+  intvec* inequs = (intvec *)u->CopyD(INTVEC_CMD);
+  intvec* equs = (intvec *)v->CopyD(INTVEC_CMD);
+  if (inequs->cols() != equs->cols())
+  {
+    Werror("expected same number of columns but got %d vs. %d",
+           inequs->cols(), equs->cols());
+    return TRUE;
+  }
+  gfan::ZMatrix zm1 = intmat2ZMatrix(inequs);
+  gfan::ZMatrix zm2 = intmat2ZMatrix(equs);
+  gfan::ZCone* zc = new gfan::ZCone(zm1, zm2);
+  res->data = (char *)zc;
+  return FALSE;
 }
 static BOOLEAN jjDELMCONE2(leftv res, leftv u, leftv v)
@@ -3201 +3326 @@
      valid parametrizations: (fan, int),
      Errors will be invoked in the following cases:
-     - the given index is out of range [1..m], where m is
+     - the given index is out of range [0..m-1], where m is
        the number of maximal cones in the given fan */
   Fan* f = (Fan*)u->Data();
   int index = (int)(long)v->Data();
-  if (! f->deleteMaxCone(index))
-  {
-    Werror("cone index %d out of range [1..%d]; no cone deleted",
-           index, f->getMaxCones()->nr + 1);
-    return TRUE;
-  }
-  else return FALSE;
+  int n = f->getNumberOfMaxCones();
+  if (n == 0)
+  {
+    WerrorS("no maximal cones defined in the given fan");
+    return TRUE;
+  }
+  if ((index < 0) || (n <= index))
+  {
+    Werror("cone index %d out of range [0..%d]; no cone deleted",
+           index, f->getNumberOfMaxCones() - 1);
+    return TRUE;
+  }
+  f->deleteMaxCone(index);
+  return FALSE;
 }
 static BOOLEAN jjDELMCONE3(leftv res, leftv u, leftv v)
@@ -3219 +3351 @@
      valid parametrizations: (fan, intvec),
      Errors will be invoked in the following cases:
-     - one of the given indices is out of range [1..m],
+     - one of the given indices is out of range [0..m-1],
        where m is the number of maximal cones in the given
        fan;
-     The method does not check that the given indices are
-     mutually distinct. */
+     The method does not check whether the given indices are
+     mutually distinct. This is however assumed by this method. */
   Fan* f = (Fan*)u->Data();
-  intvec* indices = (intvec*)v->Data();
-  int result = f->deleteMaxCones(indices);
-  if (result != 0)
-  {
-    Werror("cone index %d at position %d out of range [1..%d]; %s",
-           (*indices)[result - 1], result, f->getMaxCones()->nr + 1,
-           "no cone deleted");
-    return TRUE;
-  }
-  else return FALSE;
-}
-static BOOLEAN jjMAXCONE2(leftv res, leftv u, leftv v)
-{
-  /* method for retrieving a maximal cone of the given fan;
+  intvec* iv = (intvec*)v->Data();
+  int n = f->getNumberOfMaxCones();
+  if (n == 0)
+  {
+    WerrorS("no maximal cones defined in the given fan");
+    return TRUE;
+  }
+  for (int i = 0; i < iv->length(); i++)
+    if (((*iv)[i] < 0) || (n <= (*iv)[i]))
+    {
+      Werror("cone index %d out of range [0..%d]", (*iv)[i], n - 1);
+      return TRUE;
+    }
+  f->deleteMaxCones(iv);
+  return FALSE;
+}
+static BOOLEAN jjMAXCONE1(leftv res, leftv u, leftv v)
+{
+  /* method for retrieving a maximal cone from the given fan;
      valid parametrizations: (fan, int),
      Errors will be invoked in the following cases:
      - maximal cones not yet set in the fan,
-     - maximal cone index invalid;
+     - maximal cone index out of range;
      The method returns an object of type cone. */
   Fan* f = (Fan*)u->Data();
   int index = (int)(long)v->Data();
-  lists maxCones = f->getMaxCones();
-  if (maxCones == NULL)
-  {
-    WerrorS("no maximal cones set in the given fan");
-    return TRUE;
-  }
-  else if ((index < 1) || (maxCones->nr + 1 < index))
-  {
-    Werror("invalid cone index %d", index);
-    return TRUE;
-  }
-  res->data = (char*)new Cone(*(Cone*)(maxCones->m[index - 1].data));
+  int n = f->getNumberOfMaxCones();
+  if (n == 0)
+  {
+    WerrorS("no maximal cones defined in the given fan");
+    return TRUE;
+  }
+  if ((index < 0) || (n <= index))
+  {
+    Werror("cone index %d out of range [0..%d]", index, n - 1);
+    return TRUE;
+  }
+  Cone* c = f->getMaxCone(index);
+  res->data = (char*)c;
+  return FALSE;
+}
+static BOOLEAN jjMAXCONE2(leftv res, leftv u, leftv v)
+{
+  /* method for retrieving numerous maximal cones of the given fan
+     in a list;
+     valid parametrizations: (fan, intvec),
+     Errors will be invoked in the following cases:
+     - maximal cones not yet set in the fan,
+     - cone index out of range;
+     The method returns a list of cone objects. */
+  Fan* f = (Fan*)u->Data();
+  intvec* iv = (intvec*)v->Data();
+  int n = f->getNumberOfMaxCones();
+  if (n == 0)
+  {
+    WerrorS("no maximal cones defined in the given fan");
+    return TRUE;
+  }
+  for (int i = 0; i < iv->length(); i++)
+    if (((*iv)[i] < 0) || (n <= (*iv)[i]))
+    {
+      Werror("cone index %d out of range [0..%d]", (*iv)[i], n - 1);
+      return TRUE;
+    }
+  lists maxCones = f->getMaxCones(iv);
+  res->data = (char*)maxCones;
   return FALSE;
 }
@@ -3297 +3462 @@
   return FALSE;
 }
-static BOOLEAN jjGETPROP2(leftv res, leftv u, leftv v)
+static BOOLEAN jjGETPROPC(leftv res, leftv u, leftv v)
 {
   /* method for retrieving cone properties;
      valid parametrizations: (cone, string),
      Errors will be invoked in the following cases:
-     - cone has so far only been instantiated by "cone c;",
-     - string is not 'dim' */
-  Cone* c = (Cone*)u->Data();
+     - invalid property string (see below for valid ones) */
+  gfan::ZCone* zc = (gfan::ZCone*)u->Data();
   char* prop = (char*)v->Data();
-  int result;
-
-  if (c->getFan() == NULL)
-  {
-    WerrorS("the given cone has no properties yet (freshly instantiated)");
-    return TRUE;
-  }
-
-  if (strcmp(prop, "dim") == 0)
-    result = c->getDim();
+  gfan::ZMatrix retMat;
+  gfan::ZCone retCone;
+  int retInt;
+  gfan::ZVector retVec;
+  int typeInfo;
+
+  /* ################ properties with return type intmat: ################## */
+  if      (strcmp(prop, "INEQUALITIES") == 0)
+  {
+    retMat = zc->getInequalities();
+    typeInfo = INTMAT_CMD;
+  }
+  else if (strcmp(prop, "EQUATIONS") == 0)
+  {
+    retMat = zc->getEquations();
+    typeInfo = INTMAT_CMD;
+  }
+  else if (strcmp(prop, "FACETS") == 0)
+  {
+    retMat = zc->getFacets();
+    typeInfo = INTMAT_CMD;
+  }
+  else if (strcmp(prop, "IMPLIED_EQUATIONS") == 0)
+  {
+    retMat = zc->getImpliedEquations();
+    typeInfo = INTMAT_CMD;
+  }
+  else if (strcmp(prop, "GENERATORS_OF_SPAN") == 0)
+  {
+    retMat = zc->generatorsOfSpan();
+    typeInfo = INTMAT_CMD;
+  }
+  else if (strcmp(prop, "GENERATORS_OF_LINEALITY_SPACE") == 0)
+  {
+    retMat = zc->generatorsOfLinealitySpace();
+    typeInfo = INTMAT_CMD;
+  }
+  else if (strcmp(prop, "RAYS") == 0)
+  {
+    retMat = zc->extremeRays();
+    typeInfo = INTMAT_CMD;
+  }
+  else if (strcmp(prop, "QUOTIENT_LATTICE_BASIS") == 0)
+  {
+    retMat = zc->quotientLatticeBasis();
+    typeInfo = INTMAT_CMD;
+  }
+  else if (strcmp(prop, "LINEAR_FORMS") == 0)
+  {
+    retMat = zc->getLinearForms();
+    typeInfo = INTMAT_CMD;
+  }
+  /* ################ properties with return type int: ################## */
+  else if (strcmp(prop, "AMBIENT_DIM") == 0)
+  {
+    retInt = zc->ambientDimension();
+    typeInfo = INT_CMD;
+  }
+  else if (strcmp(prop, "DIM") == 0)
+  {
+    retInt = zc->dimension();
+    typeInfo = INT_CMD;
+  }
+  else if (strcmp(prop, "LINEALITY_DIM") == 0)
+  {
+    retInt = zc->dimensionOfLinealitySpace();
+    typeInfo = INT_CMD;
+  }
+  else if (strcmp(prop, "MULTIPLICITY") == 0)
+  {
+    bool ok = true;
+    retInt = integerToInt(zc->getMultiplicity(), ok);
+    if (!ok)
+      WerrorS("overflow while converting a gfan::Integer to an int");
+    typeInfo = INT_CMD;
+  }
+  else if (strcmp(prop, "IS_ORIGIN") == 0)
+  {
+    retInt = zc->isOrigin() ? 1 : 0;
+    typeInfo = INT_CMD;
+  }
+  else if (strcmp(prop, "IS_FULL_SPACE") == 0)
+  {
+    retInt = zc->isFullSpace() ? 1 : 0;
+    typeInfo = INT_CMD;
+  }
+  else if (strcmp(prop, "SIMPLICIAL") == 0)
+  {
+    retInt = zc->isSimplicial() ? 1 : 0;
+    typeInfo = INT_CMD;
+  }
+  else if (strcmp(prop, "CONTAINS_POSITIVE_VECTOR") == 0)
+  {
+    retInt = zc->containsPositiveVector() ? 1 : 0;
+    typeInfo = INT_CMD;
+  }
+  /* ################ properties with return type ZCone: ################## */
+  else if (strcmp(prop, "LINEALITY_SPACE") == 0)
+  {
+    retCone = zc->linealitySpace();
+    typeInfo = CONE_CMD;
+  }
+  else if (strcmp(prop, "DUAL_CONE") == 0)
+  {
+    retCone = zc->dualCone();
+    typeInfo = CONE_CMD;
+  }
+  else if (strcmp(prop, "NEGATED") == 0)
+  {
+    retCone = zc->negated();
+    typeInfo = CONE_CMD;
+  }
+  /* ################ properties with return type intvec: ################## */
+  else if (strcmp(prop, "SEMI_GROUP_GENERATOR") == 0)
+  {
+    /* test whether the cone's dim = dim of lin space + 1: */
+    int d = zc->dimension();
+    int dLS = zc->dimensionOfLinealitySpace();
+    if (d == dLS + 1)
+      retVec = zc->semiGroupGeneratorOfRay();
+    else
+    {
+      Werror("expected dim of cone one larger than dim of lin space\n"
+             "but got dimensions %d and %d", d, dLS);
+    }
+    typeInfo = INTVEC_CMD;
+  }
+  else if (strcmp(prop, "RELATIVE_INTERIOR_POINT") == 0)
+  {
+    retVec = zc->getRelativeInteriorPoint();
+    typeInfo = INTVEC_CMD;
+  }
+  else if (strcmp(prop, "UNIQUE_POINT") == 0)
+  {
+    retVec = zc->getUniquePoint();
+    typeInfo = INTVEC_CMD;
+  }
   else
   {
@@ -3322 +3613 @@
   }
 
-  res->data = (void*)result;
+  res->rtyp = typeInfo;
+  switch(typeInfo)
+  {
+    case INTMAT_CMD:
+      res->data = (void*)zMatrix2Intvec(retMat);
+      break;
+    case INT_CMD:
+      res->data = (void*)retInt;
+      break;
+    case CONE_CMD:
+      res->data = (void*)new gfan::ZCone(retCone);
+      break;
+    case INTVEC_CMD:
+      res->data = (void*)zVector2Intvec(retVec);
+      break;
+    default: ; /* should never be reached */
+  }
+  return FALSE;
+}
+static BOOLEAN jjADJACENCY2(leftv res, leftv u, leftv v)
+{
+  /* method for retrieving all maximal cones in the given fan that
+     are adjacent to a given maximal cone;
+     valid parametrizations: (fan, int),
+     Errors will be invoked in the following cases:
+     - the maximal cone index is out of range [0..m-1],
+       where m is the number of maximal cones in the given fan;
+     In case there are no neighbours (yet) of the specified maximal
+     cone, the method returns an intvec of length one with entry zero. */
+  Fan* f = (Fan*)u->Data();
+  int maxCone = (int)(long)v->Data();
+  int nMaxCones = f->getNumberOfMaxCones();
+  if ((maxCone < 0) || (nMaxCones <= maxCone))
+  {
+    Werror("index %d out of range [0..%d]",
+           maxCone, nMaxCones - 1);
+    return TRUE;
+  }
+  intvec* result = f->getAdjacency(maxCone);
+  result = ivCopy(result);
+  res->data = (char*)result;
   return FALSE;
 }
@@ -4693 +5024 @@
 }
 #ifdef HAVE_FANS
+static BOOLEAN jjCONERAYS1(leftv res, leftv v)
+{
+  /* method for generating a cone object from half-lines
+     (cone = convex hull of the half-lines; note: there may be
+     entire lines in the cone);
+     valid parametrizations: (intmat) */
+  intvec* rays = (intvec *)v->CopyD(INTVEC_CMD);
+  gfan::ZMatrix zm = intmat2ZMatrix(rays);
+  gfan::ZCone* zc = new gfan::ZCone();
+  *zc = gfan::ZCone::givenByRays(zm, gfan::ZMatrix(0, zm.getWidth()));
+  res->data = (char *)zc;
+  return FALSE;
+}
+static BOOLEAN jjCONENORMALS1(leftv res, leftv v)
+{
+  /* method for generating a cone object from inequalities;
+     valid parametrizations: (intmat) */
+  intvec* inequs = (intvec *)v->CopyD(INTVEC_CMD);
+  gfan::ZMatrix zm = intmat2ZMatrix(inequs);
+  gfan::ZCone* zc = new gfan::ZCone(zm, gfan::ZMatrix(0, zm.getWidth()));
+  res->data = (char *)zc;
+  return FALSE;
+}
 static BOOLEAN jjDELMCONE1(leftv res, leftv v)
 {
-  /* method for deleting all maximal cones of the given fan;
+  /* method for deleting all maximal cones from a given fan;
      valid parametrizations: (fan) */
   Fan* f = (Fan*)v->Data();
-  f->deleteMaxCones(NULL);
+  int n = f->getNumberOfMaxCones();
+  intvec* iv = new intvec(1, n, 0);
+  for (int i = 1; i <= n; i++)
+    IMATELEM(*iv, 1, i) = i - 1;
+  f->deleteMaxCones(iv);
+  delete iv;
   return FALSE;
 }
@@ -4707 +5066 @@
      If there are no maximal rays, the method returns a 1x1
      matrix with entry 0. Otherwise the returned matrix contains
-     the maximal rays as column vectors. */
+     the maximal rays as row vectors. */
   Fan* f = (Fan*)v->Data();
   intvec* result = NULL;
@@ -4724 +5083 @@
      If there are no maximal rays, the method returns a 1x1
      matrix with entry 0. Otherwise the returned matrix contains
-     the maximal rays as column vectors. */
+     the maximal rays as row vectors. */
   Cone* c = (Cone*)v->Data();
   intvec* result = NULL;
-  if (c->getRays() == NULL)
+  if (c->getMaxRays() == NULL)
     /* return a 1x1 matrix with sole entry zero */
     result = new intvec(1, 1, 0);
   else
-  {
-    intvec* indices = c->getRays();
-    intvec* maxRays = c->getFan()->getMaxRays();
-    result = new intvec(maxRays->rows(), indices->length(), 0);
-    for (int c = 1; c <= indices->length(); c++)
-      for (int r = 1; r <= maxRays->rows(); r++)
-      {
-        IMATELEM(*result, r, c) = IMATELEM(*maxRays, r, (*indices)[c - 1]);
-      }
-  }
+    result = ivCopy(c->getMaxRays());
   res->data = (char*)result;
   return FALSE;
@@ -4749 +5099 @@
      valid parametrizations: (fan),
      If there are no facet normals, a 1x1 matrix with entry 0
-     is returned; otherwise a matrix the columns of which are
+     is returned; otherwise a matrix the rows of which are
      the facet normals of the given fan. */
   Fan* f = (Fan*)v->Data();
@@ -4764 +5114 @@
 {
   /* method for retrieving the facet normals of the given cone;
-     valid parametrizations: (fan),
+     valid parametrizations: (cone),
      If there are no facet normals, a 1x1 matrix with entry 0
-     is returned; otherwise a matrix the columns of which are
+     is returned; otherwise a matrix the rows of which are
      the facet normals of the given cone. */
   Cone* c = (Cone*)v->Data();
@@ -4774 +5124 @@
     result = new intvec(1, 1, 0);
   else
-  {
-    intvec* indices = c->getFacetNs();
-    intvec* facetNs = c->getFan()->getFacetNs();
-    result = new intvec(facetNs->rows(), indices->length(), 0);
-    for (int c = 1; c <= indices->length(); c++)
-      for (int r = 1; r <= facetNs->rows(); r++)
-      {
-        IMATELEM(*result, r, c) = IMATELEM(*facetNs, r, (*indices)[c - 1]);
-      }
-  }
+    result = ivCopy(c->getFacetNs());
   res->data = (char*)result;
   return FALSE;
 }
-static BOOLEAN jjLINSPACE(leftv res, leftv v)
+static BOOLEAN jjLINSPACE1(leftv res, leftv v)
 {
   /* method for retrieving the lineality space of the given fan;
@@ -4796 +5137 @@
   return FALSE;
 }
-static BOOLEAN jjMAXCONE1(leftv res, leftv v)
-{
-  /* method for retrieving all maximal cones of the given fan;
-     valid parametrizations: (fan),
-     Errors will be invoked in the following cases:
-     - maximal cones not yet set in the fan;
-     The method returns a list of cone objects. */
-  Fan* f = (Fan*)v->Data();
-  lists maxCones = lCopy(f->getMaxCones());
-  if (maxCones == NULL)
-  {
-    WerrorS("no maximal cones set in the given fan");
-    return TRUE;
-  }
-  res->data = (char*)maxCones;
+static BOOLEAN jjLINSPACE2(leftv res, leftv v)
+{
+  /* method for retrieving the lineality space of the given cone;
+     valid parametrizations: (cone) */
+  Cone* c = (Cone*)v->Data();
+  intvec* result = ivCopy(c->getLinSpace());
+  res->data = (char*)result;
   return FALSE;
 }
 static BOOLEAN jjADJACENCY1(leftv res, leftv v)
 {
-  /* method for retrieving the adjacency matrix of the given fan;
+  /* method for retrieving adjacency information for the given fan;
      valid parametrizations: (fan),
      Errors will be invoked in the following cases:
      - no maximal cone has been defined yet in the given fan;
-     The matrix entries have the following meaning:
-     _[i, j] =  0: the maximal cones with indices i and j are
-                   not adjacent,
-             =  1: they are adjacent, and the intersection facet
-                   has been stored in the given fan,
-             = -1: they are adjacent but there is no intersection
-                   facet available */
+     The method returns a list with an entry for each maximal cone
+     in the given fan. Each such entry is an intvec with the indices
+     of all neighbouring maximal cones. */
   Fan* f = (Fan*)v->Data();
-  if (f->getMaxCones()->nr + 1 < 1)
+  if (f->getNumberOfMaxCones() == 0)
   {
     WerrorS("no maximal cones defined yet");
     return TRUE;
   }
-  intvec* adjacencyMatrix = f->getAdjacency();
-  res->data = (char*)adjacencyMatrix;
+  lists adjacencyList = f->getAdjacencyList();
+  adjacencyList = lCopy(adjacencyList);
+  res->data = (char*)adjacencyList;
   return FALSE;
 }
@@ -6122 +6452 @@
 }
 #ifdef HAVE_FANS
-static BOOLEAN jjSETPROP1(leftv res, leftv u, leftv v, leftv w)
-{
-  /* method for setting fan properties;
-     valid parametrizations: (fan, string, int),
+static BOOLEAN jjSETPROPC1(leftv res, leftv u, leftv v, leftv w)
+{
+  gfan::ZCone* zc = (gfan::ZCone*)u->Data();
+  char* prop = (char*)v->Data();
+  int val = (int)(long)w->Data();
+
+  if (strcmp(prop, "MULTIPLICITY") == 0)
+  {
+    zc->setMultiplicity(gfan::Integer(val));
+  }
+  else
+  {
+    Werror("unexpected cone property '%s'", prop);
+    return TRUE;
+  }
+  return FALSE;
+}
+static BOOLEAN jjSETPROPC2(leftv res, leftv u, leftv v, leftv w)
+{
+  gfan::ZCone* zc = (gfan::ZCone*)u->Data();
+  char* prop = (char*)v->Data();
+  intvec* mat = (intvec*)w->Data();
+  gfan::ZMatrix zm = intmat2ZMatrix(mat);
+  int val = (int)(long)w->Data();
+
+  if (strcmp(prop, "LINEAR_FORMS") == 0)
+  {
+    zc->setLinearForms(zm);
+  }
+  else
+  {
+    Werror("unexpected cone property '%s'", prop);
+    return TRUE;
+  }
+  return FALSE;
+}
+static BOOLEAN jjCONTAINS3(leftv res, leftv u, leftv v, leftv w)
+{
+  gfan::ZCone* zc = (gfan::ZCone*)u->Data();
+  intvec* vec = (intvec*)v->Data();
+  int flag = (int)(long)w->Data();
+  gfan::ZVector zv = intvec2ZVector(vec);
+  int d1 = zc->ambientDimension();
+  int d2 = zv.size();
+  if (d1 != d2)
+    Werror("expected ambient dim of cone and size of vector\n"
+           "to be equal but got %d and %d", d1, d2);
+  if (flag)
+    res->data = (void *)(zc->containsRelatively(zv) ? 1 : 0);
+  else
+    res->data = (void *)(zc->contains(zv) ? 1 : 0);;
+  return FALSE;
+}
+static BOOLEAN jjCONERAYS3(leftv res, leftv u, leftv v, leftv w)
+{
+  /* method for generating a cone object from half-lines,
+     and lines (any point in the cone being the sum of a point
+     in the convex hull of the half-lines and a point in the span
+     of the lines), and an integer k;
+     valid parametrizations: (intmat, intmat, int);
      Errors will be invoked in the following cases:
-     - string is neither of 'dim', 'complete', 'simplicial',
-       and 'pure';
-     A value 0 means that the property is not fulfilled.
-     1 means it is. -1 means that the answer is unknown.
-     Any value other than 0 and 1 will be converted to -1;
-     except for dim: Here, only negative values will be converted
-     to -1. */
-  Fan* f = (Fan*)u->Data();
-  char* prop = (char*)v->Data();
-  int value = (int)(long)w->Data();
-
-  if      (strcmp(prop, "ambientdim") == 0)
-  {
-    Werror("ambient dimension of a fan cannot be set (implicitely given)");
-    return TRUE;
-  }
-  else if (strcmp(prop, "dim")        == 0)
-    f->setDim(value);
-  else if (strcmp(prop, "complete")   == 0)
-    f->setComplete(value);
-  else if (strcmp(prop, "simplicial") == 0)
-    f->setSimplicial(value);
-  else if (strcmp(prop, "pure")       == 0)
-    f->setPure(value);
-  else
-  {
-    Werror("unexpected fan property '%s'", prop);
-    return TRUE;
-  }
-
-  return FALSE;
-}
-static BOOLEAN jjSETPROP2(leftv res, leftv u, leftv v, leftv w)
-{
-  /* method for setting cone properties;
-     valid parametrizations: (fan, string, int),
+     - u and v have different numbers of columns,
+     - k not in [0..3];
+     if the 2^0-bit of k is set, then the lineality space is known
+     to be the span of the provided lines;
+     if the 2^1-bit of k is set, then the extreme rays are known:
+     each half-line spans a (different) extreme ray */
+  intvec* rays = (intvec *)u->CopyD(INTVEC_CMD);
+  intvec* linSpace = (intvec *)v->CopyD(INTVEC_CMD);
+  if (rays->cols() != linSpace->cols())
+  {
+    Werror("expected same number of columns but got %d vs. %d",
+           rays->cols(), linSpace->cols());
+    return TRUE;
+  }
+  int k = (int)(long)w->Data();
+  if ((k < 0) || (k > 3))
+  {
+    WerrorS("expected int argument in [0..3]");
+    return TRUE;
+  }
+  gfan::ZMatrix zm1 = intmat2ZMatrix(rays);
+  gfan::ZMatrix zm2 = intmat2ZMatrix(linSpace);
+  gfan::ZCone* zc = new gfan::ZCone();
+  *zc = gfan::ZCone::givenByRays(zm1, zm2);
+  //k should be passed on to zc; not available yet
+  res->data = (char *)zc;
+  return FALSE;
+}
+static BOOLEAN jjCONENORMALS3(leftv res, leftv u, leftv v, leftv w)
+{
+  /* method for generating a cone object from inequalities, equations,
+     and an integer k;
+     valid parametrizations: (intmat, intmat, int);
      Errors will be invoked in the following cases:
-     - string is not 'dim';
-     Any negative value will be converted to -1 signaling
-     that the dim is unknown. */
-  Cone* c = (Cone*)u->Data();
-  char* prop = (char*)v->Data();
-  int value = (int)(long)w->Data();
-
-  if (strcmp(prop, "dim") == 0)
-    c->setDim(value);
-  else
-  {
-    Werror("unexpected cone property '%s'", prop);
-    return TRUE;
-  }
-
-  return FALSE;
-}
-static BOOLEAN jjADJACENCY2(leftv res, leftv u, leftv v, leftv w)
-{
-  /* method for retrieving the adjacency information concerning
-     two maximal cones of the given fan;
+     - u and v have different numbers of columns,
+     - k not in [0..3];
+     if the 2^0-bit of k is set, then ... */
+  intvec* inequs = (intvec *)u->CopyD(INTVEC_CMD);
+  intvec* equs = (intvec *)v->CopyD(INTVEC_CMD);
+  if (inequs->cols() != equs->cols())
+  {
+    Werror("expected same number of columns but got %d vs. %d",
+           inequs->cols(), equs->cols());
+    return TRUE;
+  }
+  int k = (int)(long)w->Data();
+  if ((k < 0) || (k > 3))
+  {
+    WerrorS("expected int argument in [0..3]");
+    return TRUE;
+  }
+  gfan::ZMatrix zm1 = intmat2ZMatrix(inequs);
+  gfan::ZMatrix zm2 = intmat2ZMatrix(equs);
+  gfan::ZCone* zc = new gfan::ZCone(zm1, zm2, k);
+  res->data = (char *)zc;
+  return FALSE;
+}
+static BOOLEAN jjADDADJ1(leftv res, leftv u, leftv v, leftv w)
+{
+  /* method for feeding adjacency information into the given fan;
      valid parametrizations: (fan, int, int),
      Errors will be invoked in the following cases:
-     - a maximal cone index is out of range [1..m],
-       where m is the number of maximal cones in the given fan,
-     - the two specified maximal cones are not adjacent,
-     - the two specified maximal cones are adjacent but the
-       intersection facet has not been stored in the fan */
+     - a maximal cone index is out of range [0..m-1],
+       where m is the number of maximal cones in the given fan;
+     - the two indices coincide */
   Fan* f = (Fan*)u->Data();
-  int maxCone1 = (int)(long)v->Data();
-  int maxCone2 = (int)(long)w->Data();
-  int nMaxCones = f->getMaxCones()->nr + 1;
-  if ((maxCone1 < 1) || (nMaxCones < maxCone1))
-  {
-    Werror("1st index %d out of range [1..%d]",
-           maxCone1, nMaxCones);
-    return TRUE;
-  }
-  if ((maxCone2 < 1) || (nMaxCones < maxCone2))
-  {
-    Werror("2nd index %d out of range [1..%d]",
-           maxCone2, nMaxCones);
-    return TRUE;
-  }
-  Cone* result = (Cone*)f->getAdjacencyFacet(maxCone1, maxCone2);
-  if (result->isNoAdj())
-  {
-    WerrorS("specified cones are not adjacent");
-    return TRUE;
-  }
-  if (result->isNoFacet())
-  {
-    Werror("specified cones are adjacent, %s",
-           "but there is no facet information available");
-    return TRUE;
-  }
-  res->data = (char*)result;
+  int i = (int)(long)v->Data();
+  int j = (int)(long)w->Data();
+  int n = f->getNumberOfMaxCones();
+  if (n == 0)
+  {
+    WerrorS("no maximal cones defined in the given fan");
+    return TRUE;
+  }
+  if ((i < 0) || (n <= i))
+  {
+    Werror("1st cone index %d out of range [0..%d]", i, n - 1);
+    return TRUE;
+  }
+  if ((j < 0) || (n <= j))
+  {
+    Werror("2nd cone index %d out of range [0..%d]", j, n - 1);
+    return TRUE;
+  }
+  if (i == j)
+  {
+    WerrorS("expected two distinct maximal cone indices");
+    return TRUE;
+  }
+  f->addAdjacency(i, j);
+  return FALSE;
+}
+static BOOLEAN jjADDADJ2(leftv res, leftv u, leftv v, leftv w)
+{
+  /* method for feeding adjacency information into the given fan;
+     valid parametrizations: (fan, int, intvec);
+     This method sets all adjacencies regarding the maximal cone
+     with index = second argument simultaneously.
+     Errors will be invoked in the following cases:
+     - a maximal cone index is out of range [0..m-1],
+       where m is the number of maximal cones in the given fan;
+     - the index (1st argument) appears in the intvec (2nd arg.) */
+  Fan* f = (Fan*)u->Data();
+  int i = (int)(long)v->Data();
+  intvec* jj = (intvec*)w->Data();
+  int n = f->getNumberOfMaxCones();
+  if (n == 0)
+  {
+    WerrorS("no maximal cones defined in the given fan");
+    return TRUE;
+  }
+  if ((i < 0) || (n <= i))
+  {
+    Werror("1st cone index %d out of range [0..%d]", i, n - 1);
+    return TRUE;
+  }
+  for (int j = 0; j < jj->length(); j++)
+  {
+    if (((*jj)[j] < 0) || (n <= (*jj)[j]))
+    {
+      Werror("cone index %d out of range [0..%d]", (*jj)[j], n - 1);
+      return TRUE;
+    }
+    if ((*jj)[j] == i)
+    {
+      Werror("unexpectedly found int argument %d in intvec argument", i);
+      return TRUE;
+    }
+  }
+  f->addAdjacencies(i, jj);
   return FALSE;
 }
@@ -6300 +6722 @@
   return b;
 }
+#ifdef HAVE_FANS
+static BOOLEAN jjSETPROP1(leftv res, leftv INPUT)
+{
+  /* method for setting fan properties;
+     valid parametrizations: (fan, string, int),
+     Errors will be invoked in the following cases:
+     - types are not correct,
+     - string is neither of 'dim', 'complete', 'simplicial',
+       and 'pure';
+     A value 0 means that the property is not fulfilled.
+     1 means it is. -1 means that the answer is unknown.
+     Any value other than 0 and 1 will be converted to -1;
+     except for dim: Here, only negative values will be converted
+     to -1. */
+  leftv u = INPUT;
+  leftv v = u->next;
+  leftv w = v->next;
+  if (u->Typ() != FAN_CMD)
+  {
+    Werror("expected a fan as 1st argument");
+    return TRUE;
+  }
+  if (v->Typ() != STRING_CMD)
+  {
+    Werror("expected a string as 2nd argument");
+    return TRUE;
+  }
+  if (w->Typ() != INT_CMD)
+  {
+    Werror("expected an int as 3rd argument");
+    return TRUE;
+  }
+
+  Fan* f = (Fan*)u->Data();
+  char* prop = (char*)v->Data();
+  int value = (int)(long)w->Data();
+
+  if      (strcmp(prop, "ambientdim") == 0)
+  {
+    Werror("ambient dimension of a fan cannot be set (implicitely given)");
+    return TRUE;
+  }
+  else if (strcmp(prop, "dim")        == 0)
+    f->setDim(value);
+  else if (strcmp(prop, "complete")   == 0)
+    f->setComplete(value);
+  else if (strcmp(prop, "simplicial") == 0)
+    f->setSimplicial(value);
+  else if (strcmp(prop, "pure")       == 0)
+    f->setPure(value);
+  else
+  {
+    Werror("unexpected fan property '%s'", prop);
+    return TRUE;
+  }
+
+  return FALSE;
+}
+static BOOLEAN jjSETPROP2(leftv res, leftv INPUT)
+{
+  /* method for setting cone properties;
+     valid parametrizations: (fan, int, string, int),
+     Errors will be invoked in the following cases:
+     - types are not correct,
+     - string is neither of 'dim', 'multiplicity', and 'weight',
+     - no maximal cones defined in the given fan,
+     - maximal cone index is out of range;
+     Any negative value will be converted to -1. */
+  leftv u = INPUT;    /* a fan */
+  leftv v = u->next;  /* a maximal cone index */
+  leftv w = v->next;  /* a string */
+  leftv x = w->next;  /* an int value */
+  if (u->Typ() != FAN_CMD)
+  {
+    Werror("expected a fan as 1st argument");
+    return TRUE;
+  }
+  if (v->Typ() != INT_CMD)
+  {
+    Werror("expected an int as 2nd argument");
+    return TRUE;
+  }
+  if (w->Typ() != STRING_CMD)
+  {
+    Werror("expected a string as 3rd argument");
+    return TRUE;
+  }
+  if (x->Typ() != INT_CMD)
+  {
+    Werror("expected an int as 4th argument");
+    return TRUE;
+  }
+
+  Fan* f = (Fan*)u->Data();
+  int index = (int)(long)v->Data();
+  char* prop = (char*)w->Data();
+  int value = (int)(long)x->Data();
+
+  int n = f->getNumberOfMaxCones();
+  if (n == 0)
+  {
+    WerrorS("no maximal cones defined in the given fan");
+    return TRUE;
+  }
+  if ((index < 0) || (n <= index))
+  {
+    Werror("cone index %d out of range [0..%d]", index, n - 1);
+    return TRUE;
+  }
+
+  if      (strcmp(prop, "dim")        == 0)
+    f->setConeDim(index, value);
+  else if (strcmp(prop, "multiplicity")   == 0)
+    f->setConeMultiplicity(index, value);
+  else if (strcmp(prop, "weight") == 0)
+    f->setConeWeight(index, value);
+  else
+  {
+    Werror("unexpected cone property '%s'", prop);
+    return TRUE;
+  }
+
+  return FALSE;
+}
+static BOOLEAN jjADDMCONE(leftv res, leftv INPUT)
+{
+  /* method for adding a maximal cones to the given fan;
+     valid parametrizations: (fan, intvec/0, intvec/0),
+     where not both intvec arguments may be the int zero.
+     Errors will be invoked in the following cases:
+     - 2nd and 3rd argument are int's,
+     - an index in one of the intvec's is out of range;
+     In case of an error addition of the cone fails. */
+  leftv u = INPUT;
+  leftv v = u->next;
+  leftv w = v->next;
+  Fan* f;
+  intvec* ii = NULL;
+  intvec* jj = NULL;
+  int n;
+  if (u->Typ() != FAN_CMD)
+  {
+    Werror("expected a fan as 1st argument");
+    return TRUE;
+  }
+  else { f = (Fan*)u->Data(); }
+  if (v->Typ() == INTVEC_CMD)
+  {
+    ii = (intvec*)v->Data();
+    n = f->getNumberOfMaxRays();
+    for (int i = 0; i < ii->length(); i++)
+    if (((*ii)[i] < 1) || (n < (*ii)[i]))
+    {
+      Werror("max. ray index %d out of range [1..%d]", (*ii)[i], n);
+      return TRUE;
+    }
+  }
+  else if ((v->Typ() != INT_CMD) || ((int)(long)v->Data() != 0))
+  {
+    Werror("expected an intvec or the int 0 as 2nd argument");
+    return TRUE;
+  }
+  if (w->Typ() == INTVEC_CMD)
+  {
+    jj = (intvec*)w->Data();
+    n = f->getNumberOfFacetNormals();
+    for (int j = 0; j < jj->length(); j++)
+    if (((*jj)[j] < 1) || (n < (*jj)[j]))
+    {
+      Werror("facet normal index %d out of range [1..%d]", (*jj)[j], n);
+      return TRUE;
+    }
+  }
+  else if ((w->Typ() != INT_CMD) || ((int)(long)w->Data() != 0))
+  {
+    Werror("expected an intvec or the int 0 as 3rd argument");
+    return TRUE;
+  }
+  f->addMaxCone(ii, jj);
+  return FALSE;
+}
+#endif /* HAVE_FANS */
 static BOOLEAN jjCALL3ARG(leftv res, leftv u)
 {
@@ -6744 +7348 @@
   return FALSE;
 }
-#ifdef HAVE_FANS
-static BOOLEAN jjADDADJ(leftv res, leftv v)
-{
-  /* method for adding one or more adjacencies between pairs of
-     maximal cones of the given fan;
-     valid parametrizations: (fan, int, int, cone),
-                             (fan, int, int, 0), or
-                             (fan, intvec, intvec, list),
-     where in the latter case, the list entries must either be
-     of type Cone* or the integer zero;
-     Errors will be invoked in the following cases:
-     - we have none of the above parametrizations,
-     - intvecs and list have different lengths,
-     - int's resp. intvec entries are out of range [1..m], where
-       m is the number of maximal cones in the given fan,
-     - int's are equal resp. intvec entries at same positions
-       are equal */
-  if ((v == NULL) || (v->next == NULL) ||
-      (v->next->next == NULL) || (v->next->next->next == NULL) ||
-      (v->next->next->next->next != NULL))
-  {
-    WerrorS("expected exactly four arguments as input");
-    return TRUE;
-  }
-  Fan* f = NULL;
-  int i; intvec* iv;
-  int j; intvec* jv;
-  Cone* c = NULL; lists L;
-  leftv x = v; bool listCase = false;
-  if (x->Typ() == FAN_CMD)
-    f = (Fan*)x->Data();
-  else
-  {
-    WerrorS("expected fan as 1st argument");
-    return TRUE;
-  }
-  x = x->next;
-  if      (x->Typ() == INT_CMD)
-    i = (int)(long)x->Data();
-  else if (x->Typ() == INTVEC_CMD)
-  {
-    iv = (intvec*)x->Data(); listCase = true;
-  }
-  else
-  {
-    WerrorS("expected int or intvec as 2nd argument");
-    return TRUE;
-  }
-  x = x->next;
-  if (listCase)
-  {
-    if ((x->Typ() != INTVEC_CMD) || ((x->next->Typ() != LIST_CMD)))
-    {
-      Werror("expected (fan, int, int, cone/0) %s",
-             "or (fan, intvec, intvec, list)");
-      return TRUE;
-    }
-    else jv = (intvec*)x->Data();
-    x = x->next;
-    L = (lists)x->Data();
-  }
-  else
-  {
-    if ((x->Typ() != INT_CMD) ||
-        ((x->next->Typ() != CONE_CMD) && (x->next->Typ() != INT_CMD)))
-    {
-      Werror("expected (fan, int, int, cone/0) %s",
-             "or (fan, intvec, intvec, list)");
-      return TRUE;
-    }
-    else j = (int)(long)x->Data();
-    x = x->next;
-    if ((x->Typ() == INT_CMD) && ((int)(long)x->Data() != 0))
-    {
-      WerrorS("expected (fan, int, int, cone/0)");
-      return TRUE;
-    }
-    if (x->Typ() != INT_CMD) c = (Cone*)x->Data();
-  }
-  int n = f->getMaxCones()->nr + 1;
-  if (!listCase)
-  {
-    if ((i < 1) || (n < i))
-    { Werror("2nd argument %d out of range [1..%d]", i, n); }
-    if ((j < 1) || (n < j))
-    { Werror("3rd argument %d out of range [1..%d]", j, n); }
-    if (i == j)
-    { WerrorS("2nd and 3rd argument are equal"); }
-    f->addAdjacency(i, j, c);
-  }
-  else
-  {
-    if (iv->length() != jv->length())
-      WerrorS("2nd and 3rd argument have different lengths");
-    if (iv->length() != L->nr + 1)
-      WerrorS("2nd and 4th argument have different lengths");
-    for (i = 0; i < iv->length(); i++)
-    {
-      if (((*iv)[i] < 1) || (n < (*iv)[i]))
-        Werror("index %d at position %d in 2nd argument out of range [1..%d]",
-               (*iv)[i], i + 1, n);
-    }
-    for (j = 0; j < jv->length(); j++)
-    {
-      if (((*jv)[j] < 1) || (n < (*jv)[j]))
-        Werror("index %d at position %d in 3rd argument out of range [1..%d]",
-               (*jv)[j], j + 1, n);
-      if ((*iv)[j] == (*jv)[j])
-        Werror("indices in 2nd and 3rd argument at position %d equal", j + 1);
-    }
-    for (i = 0; i < L->nr + 1; i++)
-    {
-      if ((L->m[i].Typ() != CONE_CMD) &&
-          ((L->m[i].Typ() != INT_CMD) || ((int)(long)L->m[i].Data() != 0)))
-        Werror("entry at position %d in 4th argument neither cone nor int 0",
-               i + 1);
-    }
-    f->addAdjacencies(iv, jv, L);
-  }
-  return FALSE;
-}
-#endif /* HAVE_FANS */
 static BOOLEAN jjINTVEC_PL(leftv res, leftv v)
 {

Singular/ipassign.cc

@@ -41 +41 @@
 #include <kernel/sca.h>
 #include <Singular/Fan.h>
-#include <Singular/Cone.h>
+#include <gfanlib/gfanlib.h>
 
 /*=================== proc =================*/
@@ -348 +348 @@
   if (res->data!=NULL)
   {
-    Cone* ccc = (Cone*)res->data;
+    gfan::ZCone* zc = (gfan::ZCone*)res->data;
     res->data = NULL;
-    delete ccc;
-  }
-  Cone* ccc = (Cone*)a->CopyD(CONE_CMD);
-  res->data=(void*)ccc;
+    delete zc;
+  }
+  gfan::ZCone* zc = (gfan::ZCone*)a->CopyD(CONE_CMD);
+  res->data=(void*)zc;
   return FALSE;
 }
@@ -1394 +1394 @@
     return TRUE;
   }
-  if ((facetNs != NULL) && (linSpace != NULL) &&
-      (facetNs->rows() != linSpace->rows()))
-  {
-    WerrorS("vector space dims do not agree (2nd vs. 3rd argument)");
-    return TRUE;
-  }
 
   if (IDDATA((idhdl)l->data) != NULL)
@@ -1413 +1407 @@
 {
   /* method for generating a cone;
-     valid parametrizations: (fan, intvec or 0, intvec or 0),
-     The intvec's capture indices of the maximal rays resp.
-     facet normals of the given fan.
-     2nd and 3rd argument may be the int 0, but not simultaneously.
+     valid parametrizations: int (ambient dimension),
      Errors will be invoked in the following cases:
-     - 2nd and 3rd argument simultaneously the int 0,
-     - invalid index for maximal row or facet normal */
-  Fan* fff = NULL;           /* the Fan where maximal rays and/or
-                                facet normals are stored */
-  intvec* maxRays = NULL;    /* indices of maximal rays */
-  intvec* facetNs = NULL;    /* indices of facet normals */
-
-  leftv x = r;
-  if (x->Typ() != FAN_CMD)
-  {
-    WerrorS("expected a fan as 1st argument");
-    return TRUE;
-  }
-  else
-  {
-    fff = (Fan*)x->Data();
-  }
-  x = x->next;
-  if (x->Typ() == INTVEC_CMD) maxRays = (intvec*)x->Data();
-  else if ((x->Typ() != INT_CMD) ||
-           ((x->Typ() == INT_CMD) && ((int)(long)x->Data() != 0)))
-  {
-    WerrorS("expected '0' or an intvec as 2nd argument");
-    return TRUE;
-  }
-  x = x->next;
-  if (x->Typ() == INTVEC_CMD) facetNs = (intvec*)x->Data();
-  else if ((x->Typ() != INT_CMD) ||
-           ((x->Typ() == INT_CMD) && ((int)(long)x->Data() != 0)))
-  {
-    WerrorS("expected '0' or an intvec as 3rd argument");
-    return TRUE;
-  }
-  if ((maxRays == NULL) && (facetNs == NULL))
-  {
-    WerrorS("expected 2nd or 3rd argument to be a valid intvec");
-    return TRUE;
-  }
-  
-  int check = Cone::checkConeData(fff, maxRays, facetNs);
-  if (check > 0)
-  {
-    Werror("invalid index %d for maximal ray at position %d",
-           (int)(long)((*maxRays)[check - 1]), check);
-    return TRUE;
-  }
-  else if (check < 0)
-  {
-    char h[150];
-    sprintf(h, "invalid index %d for facet normal at position %d",
-               (int)(long)((*facetNs)[-check - 1]), -check);
-    WerrorS(h);
-    return TRUE;
-  }
-
+     - argument < 0 */
+  if (r->Typ() != INT_CMD)
+  {
+    WerrorS("expected an int as argument");
+    return TRUE;
+  }
+  int ambientDim = (int)(long)r->Data();
+  if (ambientDim < 0)
+  {
+    Werror("expected an int >= 0, but got %d", ambientDim);
+    return TRUE;
+  }
   if (IDDATA((idhdl)l->data) != NULL)
   {
-    Cone* ccc = (Cone*)IDDATA((idhdl)l->data);
-    delete ccc;
-  }
-  Cone* ccc = new Cone(fff, maxRays, facetNs);
-  IDDATA((idhdl)l->data) = (char*)ccc;
+    gfan::ZCone* zc = (gfan::ZCone*)IDDATA((idhdl)l->data);
+    delete zc;
+  }
+  gfan::ZCone* zc = new gfan::ZCone(ambientDim);
+  IDDATA((idhdl)l->data) = (char*)zc;
   return FALSE;
 }
@@ -1542 +1490 @@
     rl=r->listLength();
     if (rl==1)
-    {
+    {               
+#ifdef HAVE_FANS
+      if ((l->Typ() == CONE_CMD) && (r->Typ() == INT_CMD))
+        return jjAssignCone(l, r);
+#endif
       /* system variables = ... */
       if(((l->rtyp>=VECHO)&&(l->rtyp<=VPRINTLEVEL))
@@ -1607 +1559 @@
     {
       return jjAssignFan(l, r);
-    }
-    else if ((lt == CONE_CMD) && (rl == 3))
-    {
-      return jjAssignCone(l, r);
     }
 #endif /* HAVE_FANS */

Singular/ipid.cc

@@ -30 +30 @@
 #include <Singular/ipid.h>
 #include <Singular/Fan.h>
-#include <Singular/Cone.h>
+#include <gfanlib/gfanlib.h>
 
 #ifdef HAVE_DYNAMIC_LOADING
@@ -201 +201 @@
       IDPACKAGE(h)->loaded = FALSE;
     }
+#ifdef HAVE_FANS
+    else if (t == FAN_CMD)
+    {
+      IDSTRING(h) = (char*)(new Fan());
+    }
+    else if (t == CONE_CMD)
+    {
+      IDSTRING(h) = (char*)(new gfan::ZCone());
+    }
+#endif /* HAVE_FANS */
   }
   // --------------------------------------------------------

Singular/subexpr.cc

@@ -12 +12 @@
 #include <ctype.h>
 #include <unistd.h>
+#include <sstream>
 
 #include <kernel/mod2.h>
@@ -39 +40 @@
 #include <Singular/subexpr.h>
 #include <Singular/Fan.h>
-#include <Singular/Cone.h>
+#include <gfanlib/gfanlib.h>
 
 omBin sSubexpr_bin = omGetSpecBin(sizeof(_ssubexpr));
@@ -63 +64 @@
   }
   return n;
+}
+
+std::string toString(gfan::ZMatrix const &m, char *tab=0)
+{
+  std::stringstream s;
+
+  for(int i=0;i<m.getHeight();i++)
+    {
+      if(tab)s<<tab;
+      for(int j=0;j<m.getWidth();j++)
+        {
+          s<<m[i][j];
+          if(i+1!=m.getHeight() || j+1!=m.getWidth())
+            {
+              s<<",";
+            }
+        }
+      s<<std::endl;
+    }
+  return s.str();
+}
+
+std::string toPrintString(gfan::ZMatrix const &m, int fieldWidth, char *tab=0)
+{
+  std::stringstream s;
+
+  for(int i=0;i<m.getHeight();i++)
+    {
+      if(tab)s<<tab;
+      for(int j=0;j<m.getWidth();j++)
+        {
+          std::stringstream temp;
+          temp<<m[i][j];
+          std::string temp2=temp.str();
+          for(int k=temp2.size();k<fieldWidth;k++)s<<" ";
+          s<<temp2;  
+          if(i+1!=m.getHeight() || j+1!=m.getWidth())
+            {
+              s<<" ";
+            }
+        }
+      s<<std::endl;
+    }
+  return s.str();
+}
+
+std::string toString(gfan::ZCone const &c)
+{
+  std::stringstream s;
+  gfan::ZMatrix i=c.getInequalities();
+  gfan::ZMatrix e=c.getEquations();
+  s<<"AMBIENT_DIM"<<std::endl;
+  s<<c.ambientDimension()<<std::endl;
+  s<<"INEQUALITIES"<<std::endl;
+  s<<toString(i);
+  s<<"EQUATIONS"<<std::endl;
+  s<<toString(e);
+  return s.str();
+}
+
+std::string toPrintString(gfan::ZCone const &c, char *nameOfCone)
+{
+  std::stringstream s;
+  gfan::ZMatrix i=c.getInequalities();
+  gfan::ZMatrix e=c.getEquations();
+  s<<nameOfCone<<"[1]:"<<std::endl;
+  s<<c.ambientDimension()<<std::endl;
+  s<<nameOfCone<<"[2]:"<<std::endl;
+  s<<toPrintString(i,6,"   ");
+  s<<nameOfCone<<"[3]:"<<std::endl;
+  s<<toPrintString(e,6,"   ");
+  return s.str();
 }
 
@@ -508 +581 @@
     case CONE_CMD:
       {
-        Cone* ccc = (Cone*)d;
-        Cone* ggg = new Cone(*ccc);
-        return ggg;
+        gfan::ZCone* zc = (gfan::ZCone*)d;
+        gfan::ZCone* newZc = new gfan::ZCone(*zc);
+        return newZc;
       }
 #endif /* HAVE_FANS */
@@ -812 +885 @@
         case CONE_CMD:
         {
-          Cone* ccc = (Cone*)d;
-          s = ccc->toString();
-          char* ns = (char*) omAlloc(strlen(s) + 10);
-          sprintf(ns, "%s", s);
+          gfan::ZCone* zc = (gfan::ZCone*)d;
+          std::string s = toString(*zc);
+          char* ns = (char*) omAlloc(strlen(s.c_str()) + 10);
+          sprintf(ns, "%s", s.c_str());
           omCheckAddr(ns);
           omFree(s);

Singular/tok.h

@@ -59 +59 @@
 //#ifdef HAVE_FANS
   CONE_CMD,
+  CONELINK_CMD,
+  CONERAYS_CMD,
+  CONENORMALS_CMD,
+  CONTAINS_CMD,
+  FACECONT_CMD,
+  INTERSC_CMD,
 //#endif /* HAVE_FANS */
   CONTENT_CMD,