Changeset 4f80bb in git

Timestamp:

Sep 17, 2010, 2:57:28 PM (13 years ago)

Author:

Frank Seelisch <seelisch@…>

Branches:

(u'spielwiese', '8d54773d6c9e2f1d2593a28bc68b7eeab54ed529')

Children:

dce1e3bbf2389a71a367d500df527054c5d4459f

Parents:

8e7db4cc8c23b1a45ca71f3217a02819e04d9c84

Message:

new types fan and cone, new commands for them;
normally turned off (turn on in Singular/mod2.h and kernel/mod2.h by def HAVE_FANS)

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

Location:

Singular

Files:

• Cone.cc (added)
• Cone.h (added)
• Fan.cc (added)
• Fan.h (added)
• Makefile.in (modified) (1 diff)
• iparith.cc (modified) (18 diffs)
• ipassign.cc (modified) (5 diffs)
• ipid.cc (modified) (2 diffs)
• misc_ip.h (modified) (1 diff)
• subexpr.cc (modified) (4 diffs)
• tok.h (modified) (8 diffs)

Singular/Makefile.in

@@ -184 +184 @@
     Minor.cc \
     MinorProcessor.cc \
-    MinorInterface.cc
+    MinorInterface.cc \
+    Fan.cc \
+    Cone.cc
 
 # stuff for MP

Singular/iparith.cc

@@ -72 +72 @@
 #include <Singular/ipshell.h>
 #include <kernel/mpr_inout.h>
+#include <Singular/Fan.h>
+#include <Singular/Cone.h>
 
 #include <kernel/timer.h>
@@ -214 +216 @@
 {  // name-string alias tokval          toktype
   { "$INVALID$",   0, -1,                 0},
+  #ifdef HAVE_FANS
+  { "addadj",      0, ADDADJ_CMD,         CMD_M},
+  { "addmaxcone",  0, ADDMCONE_CMD,       CMD_2},
+  { "adj",         0, ADJACENCY_CMD,      CMD_13},
+  #endif /* HAVE_FANS */
   { "alias",       0, ALIAS_CMD ,         PARAMETER},
   { "and",         0, '&' ,               LOGIC_OP},
@@ -233 +240 @@
   { "coef",        0, COEF_CMD ,          CMD_M},
   { "coeffs",      0, COEFFS_CMD ,        CMD_23},
+  #ifdef HAVE_FANS
+  { "cone",        0, CONE_CMD,           ROOT_DECL},
+  #endif /* HAVE_FANS */
   { "continue",    0, CONTINUE_CMD ,      CONTINUE_CMD},
   { "contract",    0, CONTRACT_CMD ,      CMD_2},
@@ -242 +252 @@
   { "degree",      0, DEGREE_CMD ,        CMD_1},
   { "delete",      0, DELETE_CMD ,        CMD_2},
+  #ifdef HAVE_FANS
+  { "delmaxcone",  0, DELMCONE_CMD,       CMD_12},
+  #endif /* HAVE_FANS */
   { "det",         0, DET_CMD ,           CMD_1},
   { "diff",        0, DIFF_CMD ,          CMD_2},
@@ -260 +273 @@
   { "export",      0, EXPORT_CMD ,        EXPORT_CMD},
   { "exportto",    0, EXPORTTO_CMD ,      CMD_2},
+  #ifdef HAVE_FANS
+  { "facetnormals",0, FACETNS_CMD,        CMD_1},
+  #endif /* HAVE_FANS */
   { "factorize",   0, FAC_CMD ,           CMD_12},
+  #ifdef HAVE_FANS
+  { "fan",         0, FAN_CMD,            ROOT_DECL},
+  #endif /* HAVE_FANS */
   { "farey",       0, FAREY_CMD ,         CMD_2},
   { "fetch",       0, FETCH_CMD ,         CMD_2},
@@ -273 +292 @@
   { "gen",         0, E_CMD ,             CMD_1},
   { "getdump",     0, GETDUMP_CMD,        CMD_1},
+  #ifdef HAVE_FANS
+  { "getprop",     0, GETPROP_CMD,        CMD_2},
+  #endif /* HAVE_FANS */
   { "gcd",         0, GCD_CMD ,           CMD_2},
   { "GCD",         2, GCD_CMD ,           CMD_2},
@@ -313 +335 @@
   { "liftstd",     0, LIFTSTD_CMD ,       CMD_23},
   { "link",        0, LINK_CMD ,          ROOT_DECL},
+  #ifdef HAVE_FANS
+  { "linspace",    0, LINSPACE_CMD,       CMD_1},
+  #endif /* HAVE_FANS */
   { "listvar",     0, LISTVAR_CMD ,       LISTVAR_CMD},
   { "list",        0, LIST_CMD ,          ROOT_DECL_LIST},
@@ -323 +348 @@
   { "matrix",      0, MATRIX_CMD ,        MATRIX_CMD},
   { "maxideal",    0, MAXID_CMD ,         CMD_1},
+  #ifdef HAVE_FANS
+  { "maxcone",     0, MAXCONE_CMD,        CMD_12},
+  { "maxrays",     0, MAXRAYS_CMD,        CMD_1},
+  #endif /* HAVE_FANS */
   { "memory",      0, MEMORY_CMD ,        CMD_1},
   { "minbase",     0, MINBASE_CMD ,       CMD_1},
@@ -395 +424 @@
   { "ringlist",    0, RINGLIST_CMD ,      CMD_1},
   { "rvar",        0, IS_RINGVAR ,        CMD_1},
+  #ifdef HAVE_FANS
+  { "setprop",     0, SETPROP_CMD,        CMD_3},
+  #endif /* HAVE_FANS */
   { "setring",     0, SETRING_CMD ,       SETRING_CMD},
   { "simplex",     0, SIMPLEX_CMD,        CMD_M},
@@ -3412 +3444 @@
   return FALSE;
 }
+#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),
+     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;
+     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;
+}
+static BOOLEAN jjDELMCONE2(leftv res, leftv u, leftv v)
+{
+  /* method for deleting a maximal cone from the given fan;
+     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 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;
+}
+static BOOLEAN jjDELMCONE3(leftv res, leftv u, leftv v)
+{
+  /* method for deleting numerous maximal cones from the
+     given fan;
+     valid parametrizations: (fan, intvec),
+     Errors will be invoked in the following cases:
+     - one of the given indices is out of range [1..m],
+       where m is the number of maximal cones in the given
+       fan;
+     The method does not check that the given indices are
+     mutually distinct. */
+  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;
+     valid parametrizations: (fan, int),
+     Errors will be invoked in the following cases:
+     - maximal cones not yet set in the fan,
+     - maximal cone index invalid;
+     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));
+  return FALSE;
+}
+static BOOLEAN jjGETPROP1(leftv res, leftv u, leftv v)
+{
+  /* method for retrieving fan properties;
+     valid parametrizations: (fan, string),
+     Errors will be invoked in the following cases:
+     - fan has so far only been instantiated by "fan f;",
+     - string is neither of 'ambientdim', 'dim', 'complete',
+       'simplicial', 'pure' */
+  Fan* f = (Fan*)u->Data();
+  char* prop = (char*)v->Data();
+  int result;
+
+  if (f->getLinSpace() == NULL)
+  {
+    WerrorS("the given fan has no properties yet (freshly instantiated)");
+    return TRUE;
+  }
+
+  if      (strcmp(prop, "ambientdim") == 0)
+    result = f->getAmbientDim();
+  else if (strcmp(prop, "dim")        == 0)
+    result = f->getDim();
+  else if (strcmp(prop, "complete")   == 0)
+    result = f->getComplete();
+  else if (strcmp(prop, "simplicial") == 0)
+    result = f->getSimplicial();
+  else if (strcmp(prop, "pure")       == 0)
+    result = f->getPure();
+  else
+  {
+    Werror("unexpected fan property '%s'", prop);
+    return TRUE;
+  }
+
+  res->data = (void*)result;
+  return FALSE;
+}
+static BOOLEAN jjGETPROP2(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();
+  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();
+  else
+  {
+    Werror("unexpected cone property '%s'", prop);
+    return TRUE;
+  }
+
+  res->data = (void*)result;
+  return FALSE;
+}
+#endif /* HAVE_FANS */
 static BOOLEAN jjVARSTR2(leftv res, leftv u, leftv v)
 {
@@ -3803 +4001 @@
 ,{jjVARSTR2,   VARSTR_CMD,     STRING_CMD,     QRING_CMD,  INT_CMD, ALLOW_PLURAL |ALLOW_RING}
 ,{jjWEDGE,     WEDGE_CMD,      MATRIX_CMD,     MATRIX_CMD, INT_CMD, NO_PLURAL |ALLOW_RING}
+#ifdef HAVE_FANS
+,{jjADDMCONE1, ADDMCONE_CMD,   NONE,           FAN_CMD,    CONE_CMD, ALLOW_PLURAL | ALLOW_RING}
+,{jjADDMCONE2, ADDMCONE_CMD,   NONE,           FAN_CMD,    LIST_CMD, ALLOW_PLURAL | ALLOW_RING}
+,{jjDELMCONE2, DELMCONE_CMD,   NONE,           FAN_CMD,    INT_CMD, ALLOW_PLURAL | ALLOW_RING}
+,{jjDELMCONE3, DELMCONE_CMD,   NONE,           FAN_CMD,    INTVEC_CMD, ALLOW_PLURAL | ALLOW_RING}
+,{jjMAXCONE2,  MAXCONE_CMD,    CONE_CMD,       FAN_CMD,    INT_CMD, ALLOW_PLURAL |ALLOW_RING}
+,{jjGETPROP1,  GETPROP_CMD,    INT_CMD,        FAN_CMD,    STRING_CMD, ALLOW_PLURAL |ALLOW_RING}
+,{jjGETPROP2,  GETPROP_CMD,    INT_CMD,        CONE_CMD,   STRING_CMD, ALLOW_PLURAL |ALLOW_RING}
+#endif /* HAVE_FANS */
 ,{NULL,        0,              0,              0,          0, NO_PLURAL |NO_RING}
 };
@@ -5057 +5264 @@
   switch ((int)(long)v->data)
   {
-    case INT_CMD:     res->data=omStrDup("int"); break;
-    case POLY_CMD:   res->data=omStrDup("poly"); break;
-    case VECTOR_CMD:  res->data=omStrDup("vector"); break;
-    case STRING_CMD:  res->data=omStrDup("string"); break;
-    case INTVEC_CMD:  res->data=omStrDup("intvec"); break;
-    case IDEAL_CMD:   res->data=omStrDup("ideal"); break;
-    case MATRIX_CMD: res->data=omStrDup("matrix"); break;
-    case MODUL_CMD:   res->data=omStrDup("module"); break;
-    case MAP_CMD:     res->data=omStrDup("map"); break;
-    case PROC_CMD:    res->data=omStrDup("proc"); break;
-    case RING_CMD:    res->data=omStrDup("ring"); break;
-    case QRING_CMD:   res->data=omStrDup("qring"); break;
-    case INTMAT_CMD:  res->data=omStrDup("intmat"); break;
-    case NUMBER_CMD:  res->data=omStrDup("number"); break;
-    case BIGINT_CMD:  res->data=omStrDup("bigint"); break;
-    case LIST_CMD:   res->data=omStrDup("list"); break;
-    case PACKAGE_CMD: res->data=omStrDup("package"); break;
-    case LINK_CMD:   res->data=omStrDup("link"); break;
-    case RESOLUTION_CMD:res->data=omStrDup("resolution");break;
+    case INT_CMD:        res->data=omStrDup("int"); break;
+    case POLY_CMD:       res->data=omStrDup("poly"); break;
+    case VECTOR_CMD:     res->data=omStrDup("vector"); break;
+    case STRING_CMD:     res->data=omStrDup("string"); break;
+    case INTVEC_CMD:     res->data=omStrDup("intvec"); break;
+    case IDEAL_CMD:      res->data=omStrDup("ideal"); break;
+    case MATRIX_CMD:     res->data=omStrDup("matrix"); break;
+    case MODUL_CMD:      res->data=omStrDup("module"); break;
+    case MAP_CMD:        res->data=omStrDup("map"); break;
+    case PROC_CMD:       res->data=omStrDup("proc"); break;
+    case RING_CMD:       res->data=omStrDup("ring"); break;
+    case QRING_CMD:      res->data=omStrDup("qring"); break;
+    case INTMAT_CMD:     res->data=omStrDup("intmat"); break;
+    case NUMBER_CMD:     res->data=omStrDup("number"); break;
+    case BIGINT_CMD:     res->data=omStrDup("bigint"); break;
+    case LIST_CMD:       res->data=omStrDup("list"); break;
+    case PACKAGE_CMD:    res->data=omStrDup("package"); break;
+    case LINK_CMD:       res->data=omStrDup("link"); break;
+    case RESOLUTION_CMD: res->data=omStrDup("resolution");break;
+#ifdef HAVE_FANS
+    case FAN_CMD:        res->data=omStrDup("fan");break;
+    case CONE_CMD:       res->data=omStrDup("cone");break;
+#endif /* HAVE_FANS */
     case DEF_CMD:
-    case NONE:    res->data=omStrDup("none"); break;
-    default:       res->data=omStrDup("?unknown type?");
+    case NONE:           res->data=omStrDup("none"); break;
+    default:             res->data=omStrDup("?unknown type?");
   }
   return FALSE;
@@ -5127 +5338 @@
   return FALSE;
 }
-
+#ifdef HAVE_FANS
+static BOOLEAN jjDELMCONE1(leftv res, leftv v)
+{
+  /* method for deleting all maximal cones of the given fan;
+     valid parametrizations: (fan) */
+  Fan* f = (Fan*)v->Data();
+  f->deleteMaxCones(NULL);
+  return FALSE;
+}
+static BOOLEAN jjMAXRAYS1(leftv res, leftv v)
+{
+  /* method for retrieving all maximal rays of the given fan;
+     valid parametrizations: (fan),
+     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. */
+  Fan* f = (Fan*)v->Data();
+  intvec* result = NULL;
+  if (f->getMaxRays() == NULL)
+    /* return a 1x1 matrix with sole entry zero */
+    result = new intvec(1, 1, 0);
+  else
+    result = ivCopy(f->getMaxRays());
+  res->data = (char*)result;
+  return FALSE;
+}
+static BOOLEAN jjMAXRAYS2(leftv res, leftv v)
+{
+  /* method for retrieving all maximal rays of the given cone;
+     valid parametrizations: (cone),
+     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. */
+  Cone* c = (Cone*)v->Data();
+  intvec* result = NULL;
+  if (c->getRays() == 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]);
+      }
+  }
+  res->data = (char*)result;
+  return FALSE;
+}
+static BOOLEAN jjFACETNS1(leftv res, leftv v)
+{
+  /* method for retrieving the facet normals of the given fan;
+     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
+     the facet normals of the given fan. */
+  Fan* f = (Fan*)v->Data();
+  intvec* result = NULL;
+  if (f->getFacetNs() == NULL)
+    /* return a 1x1 matrix with sole entry zero */
+    result = new intvec(1, 1, 0);
+  else
+    result = ivCopy(f->getFacetNs());
+  res->data = (char*)result;
+  return FALSE;
+}
+static BOOLEAN jjFACETNS2(leftv res, leftv v)
+{
+  /* method for retrieving the facet normals of the given cone;
+     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
+     the facet normals of the given cone. */
+  Cone* c = (Cone*)v->Data();
+  intvec* result = NULL;
+  if (c->getFacetNs() == NULL)
+    /* return a 1x1 matrix with sole entry zero */
+    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]);
+      }
+  }
+  res->data = (char*)result;
+  return FALSE;
+}
+static BOOLEAN jjLINSPACE(leftv res, leftv v)
+{
+  /* method for retrieving the lineality space of the given fan;
+     valid parametrizations: (fan) */
+  Fan* f = (Fan*)v->Data();
+  intvec* result = ivCopy(f->getLinSpace());
+  res->data = (char*)result;
+  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;
+  return FALSE;
+}
+static BOOLEAN jjADJACENCY1(leftv res, leftv v)
+{
+  /* method for retrieving the adjacency matrix of 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 */
+  Fan* f = (Fan*)v->Data();
+  if (f->getMaxCones()->nr + 1 < 1)
+  {
+    WerrorS("no maximal cones defined yet");
+    return TRUE;
+  }
+  intvec* adjacencyMatrix = f->getAdjacency();
+  res->data = (char*)adjacencyMatrix;
+  return FALSE;
+}
+#endif /* HAVE_FANS */
 static BOOLEAN jjLOAD1(leftv res, leftv v)
 {
@@ -5671 +6026 @@
 ,{jjLOAD1,      LOAD_CMD,        NONE,           STRING_CMD    , ALLOW_PLURAL |ALLOW_RING}
 ,{loNewtonP,    NEWTONPOLY_CMD,  IDEAL_CMD,      IDEAL_CMD     , ALLOW_PLURAL |ALLOW_RING}
+#ifdef HAVE_FANS
+,{jjDELMCONE1,  DELMCONE_CMD,    NONE,           FAN_CMD       , ALLOW_PLURAL |ALLOW_RING}
+,{jjMAXRAYS1,   MAXRAYS_CMD,     INTMAT_CMD,     FAN_CMD       , ALLOW_PLURAL |ALLOW_RING}
+,{jjMAXRAYS2,   MAXRAYS_CMD,     INTMAT_CMD,     CONE_CMD      , ALLOW_PLURAL |ALLOW_RING}
+,{jjFACETNS1,   FACETNS_CMD,     INTMAT_CMD,     FAN_CMD       , ALLOW_PLURAL |ALLOW_RING}
+,{jjFACETNS2,   FACETNS_CMD,     INTMAT_CMD,     CONE_CMD      , ALLOW_PLURAL |ALLOW_RING}
+,{jjLINSPACE,   LINSPACE_CMD,    INTMAT_CMD,     FAN_CMD       , ALLOW_PLURAL |ALLOW_RING}
+,{jjMAXCONE1,   MAXCONE_CMD,     LIST_CMD,       FAN_CMD       , ALLOW_PLURAL |ALLOW_RING}
+,{jjADJACENCY1, ADJACENCY_CMD,   INTMAT_CMD,     FAN_CMD       , ALLOW_PLURAL |ALLOW_RING}
+#endif /* HAVE_FANS */
 ,{NULL,         0,               0,              0             , NO_PLURAL |NO_RING}
 };
@@ -6683 +7048 @@
   return FALSE;
 }
+#ifdef HAVE_FANS
+static BOOLEAN jjSETPROP1(leftv res, leftv u, leftv v, leftv w)
+{
+  /* method for setting fan properties;
+     valid parametrizations: (fan, string, 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),
+     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;
+     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 */
+  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;
+  return FALSE;
+}
+#endif /* HAVE_FANS */
 static BOOLEAN jjSTD_HILB_W(leftv res, leftv u, leftv v, leftv w)
 {
@@ -6824 +7292 @@
 ,{nuLagSolve,       LAGSOLVE_CMD,LIST_CMD,  POLY_CMD,   INT_CMD,    INT_CMD  , NO_PLURAL |NO_RING}
 ,{nuVanderSys,      VANDER_CMD, POLY_CMD,   IDEAL_CMD,  IDEAL_CMD,  INT_CMD  , NO_PLURAL |NO_RING}
+#ifdef HAVE_FANS
+,{jjSETPROP1,       SETPROP_CMD,NONE,       FAN_CMD,    STRING_CMD, INT_CMD  , NO_PLURAL |NO_RING}
+,{jjSETPROP2,       SETPROP_CMD,NONE,       CONE_CMD,   STRING_CMD, INT_CMD  , NO_PLURAL |NO_RING}
+,{jjADJACENCY2,     ADJACENCY_CMD,CONE_CMD, FAN_CMD,    INT_CMD,    INT_CMD  , NO_PLURAL |NO_RING}
+#endif /* HAVE_FANS */
 ,{NULL,             0,          0,          0,          0,          0        , NO_PLURAL |NO_RING}
 };
@@ -7306 +7779 @@
   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)
 {
@@ -7818 +8413 @@
 ,{jjCALL3ARG,  STD_CMD,         IDEAL_CMD,           3      , NO_PLURAL |ALLOW_RING}
 ,{jjSTD_HILB_WP, STD_CMD,       IDEAL_CMD,           4      , NO_PLURAL |ALLOW_RING}
+#ifdef HAVE_FANS
+,{jjADDADJ,    ADDADJ_CMD,      NONE,               -2      , NO_PLURAL |NO_RING}
+#endif /* HAVE_FANS */
 ,{NULL,        0,               0,                   0      , NO_PLURAL |NO_RING}
 };

Singular/ipassign.cc

@@ -40 +40 @@
 #include <Singular/ipshell.h>
 #include <kernel/sca.h>
+#include <Singular/Fan.h>
+#include <Singular/Cone.h>
 
 /*=================== proc =================*/
@@ -319 +321 @@
   return FALSE;
 }
+#ifdef HAVE_FANS
+static BOOLEAN jiA_FAN(leftv res, leftv a, Subexpr e)
+{
+  if (e != NULL)
+  {
+    WerrorS("unexpectedly encountered subexpression in jiA_FAN");
+    return TRUE;
+  }
+  if (res->data!=NULL)
+  {
+    Fan* fff = (Fan*)res->data;
+    res->data = NULL;
+    delete fff;
+  }
+  Fan* fff = (Fan*)a->CopyD(FAN_CMD);
+  res->data=(void*)fff;
+  return FALSE;
+}
+static BOOLEAN jiA_CONE(leftv res, leftv a, Subexpr e)
+{
+  if (e != NULL)
+  {
+    WerrorS("unexpectedly encountered subexpression in jiA_CONE");
+    return TRUE;
+  }
+  if (res->data!=NULL)
+  {
+    Cone* ccc = (Cone*)res->data;
+    res->data = NULL;
+    delete ccc;
+  }
+  Cone* ccc = (Cone*)a->CopyD(CONE_CMD);
+  res->data=(void*)ccc;
+  return FALSE;
+}
+#endif /* HAVE_FANS */
 static BOOLEAN jiA_POLY(leftv res, leftv a,Subexpr e)
 {
@@ -697 +735 @@
 ,{jiA_LINK,     LINK_CMD,       STRING_CMD }
 ,{jiA_LINK,     LINK_CMD,       LINK_CMD }
+#ifdef HAVE_FANS
+,{jiA_FAN,      FAN_CMD,        FAN_CMD }
+,{jiA_CONE,     CONE_CMD,       CONE_CMD }
+#endif /* HAVE_FANS */
 ,{jiA_PACKAGE,  PACKAGE_CMD,    PACKAGE_CMD }
 ,{NULL,         0,              0 }
@@ -1346 +1388 @@
   return b;
 }
+#ifdef HAVE_FANS
+BOOLEAN jjAssignFan(leftv l, leftv r)
+{
+  /* method for generating a fan;
+     valid parametrizations: (intmat or 0, intmat or 0, intmat or 0),
+     The intmat's capture the maximal rays, facet normals and the
+     lineality space of the new fan.
+     Any of the arguments may be the int 0. But either the 1st or
+     2nd argument must be an intmat, thus not both simultaneously
+     the int 0.
+     Errors will be invoked in the following cases:
+     - 1st and 2nd argument simultaneously the int 0,
+     - numbers of rows in 1st, 2nd, and/or 3rd argument intmat
+       disagree */
+  intvec* maxRays = NULL;    /* maximal rays */
+  intvec* facetNs = NULL;    /* facet normals */
+  intvec* linSpace = NULL;   /* lineality space */
+
+  leftv x = r;
+  if (x->Typ() == INTMAT_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 intmat as 1st argument");
+    return TRUE;
+  }
+  x = x->next;
+  if (x->Typ() == INTMAT_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 intmat as 2nd argument");
+    return TRUE;
+  }
+  if ((maxRays == NULL) && (facetNs == NULL))
+  {
+    WerrorS("expected 1st or 2nd argument to be a valid intmat");
+    return TRUE;
+  }
+  x = x->next;
+  if (x->Typ() == INTMAT_CMD) linSpace = (intvec*)x->Data();
+  else if ((x->Typ() != INT_CMD) ||
+           ((x->Typ() == INT_CMD) && ((int)(long)x->Data() != 0)))
+  {
+    WerrorS("expected '0' or an intmat as 3rd argument");
+    return TRUE;
+  }
+  if ((maxRays != NULL) && (facetNs != NULL) &&
+      (maxRays->rows() != facetNs->rows()))
+  {
+    WerrorS("vector space dims do not agree (1st vs. 2nd argument)");
+    return TRUE;
+  }
+  if ((maxRays != NULL) && (linSpace != NULL) &&
+      (maxRays->rows() != linSpace->rows()))
+  {
+    WerrorS("vector space dims do not agree (1st vs. 3rd argument)");
+    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)
+  {
+    Fan* fff = (Fan*)IDDATA((idhdl)l->data);
+    delete fff;
+  }
+  Fan* fff = new Fan(maxRays, facetNs, linSpace);
+  IDDATA((idhdl)l->data) = (char*)fff;
+  return FALSE;
+}
+BOOLEAN jjAssignCone(leftv l, leftv r)
+{
+  /* 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.
+     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;
+  }
+
+  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;
+  return FALSE;
+}
+#endif /* HAVE_FANS */
 BOOLEAN iiAssign(leftv l, leftv r)
 {
@@ -1466 +1656 @@
       }
     }
+#ifdef HAVE_FANS
+    else if ((lt == FAN_CMD) && (rl == 3))
+    {
+      return jjAssignFan(l, r);
+    }
+    else if ((lt == CONE_CMD) && (rl == 3))
+    {
+      return jjAssignCone(l, r);
+    }
+#endif /* HAVE_FANS */
     if (rt==NONE) rt=r->Typ();
   }

Singular/ipid.cc

@@ -29 +29 @@
 #include <kernel/syz.h>
 #include <Singular/ipid.h>
+#include <Singular/Fan.h>
+#include <Singular/Cone.h>
 
 #ifdef HAVE_DYNAMIC_LOADING
@@ -464 +466 @@
       syKillComputation((syStrategy)IDDATA(h),r);
   }
+#ifdef HAVE_FANS
+  // fan -------------------------------------------------------------
+  else if (IDTYP(h) == FAN_CMD)
+  {
+    Fan* fff = (Fan*)IDDATA(h);
+    delete fff;
+    IDDATA(h) = NULL;
+  }
+  // cone ------------------------------------------------------------
+  else if (IDTYP(h) == CONE_CMD)
+  {
+    Cone* ccc = (Cone*)IDDATA(h);
+    delete ccc;
+    IDDATA(h) = NULL;
+  }
+#endif /* HAVE_FANS */
 #ifdef TEST
   else if ((IDTYP(h)!= INT_CMD)

Singular/misc_ip.h

@@ -25 +25 @@
 #define MISC_H
 
-#include <si_gmp.h>
+#include <kernel/si_gmp.h>
 #include <kernel/structs.h>
 

Singular/subexpr.cc

@@ -38 +38 @@
 #include <Singular/attrib.h>
 #include <Singular/subexpr.h>
+#include <Singular/Fan.h>
+#include <Singular/Cone.h>
 
 omBin sSubexpr_bin = omGetSpecBin(sizeof(_ssubexpr));
@@ -153 +155 @@
           ::Print("%d",(int)(long)d);
           break;
+#ifdef HAVE_FANS
+       case CONE_CMD:
+       case FAN_CMD:
+          PrintNSpaces(spaces);
+          {
+            char *s = String();
+            ::PrintS(s);
+            omFree(s);
+          }
+          break;
+#endif /* HAVE_FANS */
        case PROC_CMD:
          {
@@ -490 +503 @@
         return d;
       }
+#ifdef HAVE_FANS
+    case FAN_CMD:
+      {
+        Fan* fff = (Fan*)d;
+        Fan* ggg = new Fan(*fff);
+        return ggg;
+      }
+    case CONE_CMD:
+      {
+        Cone* ccc = (Cone*)d;
+        Cone* ggg = new Cone(*ccc);
+        return ggg;
+      }
+#endif /* HAVE_FANS */
     case RESOLUTION_CMD:
       return (void*)syCopy((syStrategy)d);
@@ -776 +803 @@
           }
           return s;
-
+#ifdef HAVE_FANS
+        case FAN_CMD:
+        {
+          Fan* fff = (Fan*)d;
+          s = fff->toString();
+          char* ns = (char*) omAlloc(strlen(s) + 10);
+          sprintf(ns, "%s", s);
+          omCheckAddr(ns);
+          omFree(s);
+          return ns;
+        }
+        case CONE_CMD:
+        {
+          Cone* ccc = (Cone*)d;
+          s = ccc->toString();
+          char* ns = (char*) omAlloc(strlen(s) + 10);
+          sprintf(ns, "%s", s);
+          omCheckAddr(ns);
+          omFree(s);
+          return ns;
+        }
+#endif /* HAVE_FANS */
         case RESOLUTION_CMD:
         {

Singular/tok.h

@@ -43 +43 @@
   ALIAS_CMD     = UMINUS + 15,
   ATTRIB_CMD,
+#ifdef HAVE_FANS
+  ADDADJ_CMD,
+  ADDMCONE_CMD,
+  ADJACENCY_CMD,
+#endif /* HAVE_FANS */
   BAREISS_CMD,
   BIGINT_CMD,
@@ -52 +57 @@
   CLOSE_CMD,
   COLS_CMD,
+#ifdef HAVE_FANS
+  CONE_CMD,
+#endif /* HAVE_FANS */
   CONTENT_CMD,
   COUNT_CMD,
@@ -58 +66 @@
   DEFINED_CMD,
   DELETE_CMD,
+#ifdef HAVE_FANS
+  DELMCONE_CMD,
+#endif /* HAVE_FANS */
   DET_CMD,
   DUMP_CMD,
@@ -67 +78 @@
   EXTGCD_CMD,
   FAC_CMD,
+#ifdef HAVE_FANS
+  FACETNS_CMD,
+  FAN_CMD,
+#endif /* HAVE_FANS */
   FIND_CMD,
   FACSTD_CMD,
@@ -75 +90 @@
   GCD_CMD,
   GETDUMP_CMD,
+#ifdef HAVE_FANS
+  GETPROP_CMD,
+#endif /* HAVE_FANS */
   HIGHCORNER_CMD,
   HRES_CMD,
@@ -92 +110 @@
   LAGSOLVE_CMD,
   LINK_CMD,
+#ifdef HAVE_FANS
+  LINSPACE_CMD,
+#endif /* HAVE_FANS */
   LIST_CMD,
   LOAD_CMD,
@@ -98 +119 @@
   LUI_CMD,
   LUS_CMD,
+#ifdef HAVE_FANS
+  MAXCONE_CMD,
+  MAXRAYS_CMD,
+#endif /* HAVE_FANS */
   MEMORY_CMD,
   MONITOR_CMD,
@@ -129 +154 @@
   RINGLIST_CMD,
   ROWS_CMD,
+#ifdef HAVE_FANS
+  SETPROP_CMD,
+#endif /* HAVE_FANS */
   SIMPLEX_CMD,
   SLIM_GB_CMD,