Changeset 4f80bb in git for Singular


Ignore:
Timestamp:
Sep 17, 2010, 2:57:28 PM (14 years ago)
Author:
Frank Seelisch <seelisch@…>
Branches:
(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', '38dfc5131670d387a89455159ed1e071997eec94')
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:
4 added
7 edited

Legend:

Unmodified
Added
Removed

  • Singular/Makefile.in

    r8e7db4 r4f80bb  
    184184    Minor.cc \
    185185    MinorProcessor.cc \
    186     MinorInterface.cc
     186    MinorInterface.cc \
     187    Fan.cc \
     188    Cone.cc
    187189
    188190# stuff for MP

  • Singular/iparith.cc

    r8e7db4 r4f80bb  
    7272#include <Singular/ipshell.h>
    7373#include <kernel/mpr_inout.h>
     74#include <Singular/Fan.h>
     75#include <Singular/Cone.h>
    7476
    7577#include <kernel/timer.h>
    … …  
    214216{  // name-string alias tokval          toktype
    215217  { "$INVALID$",   0, -1,                 0},
     218  #ifdef HAVE_FANS
     219  { "addadj",      0, ADDADJ_CMD,         CMD_M},
     220  { "addmaxcone",  0, ADDMCONE_CMD,       CMD_2},
     221  { "adj",         0, ADJACENCY_CMD,      CMD_13},
     222  #endif /* HAVE_FANS */
    216223  { "alias",       0, ALIAS_CMD ,         PARAMETER},
    217224  { "and",         0, '&' ,               LOGIC_OP},
    … …  
    233240  { "coef",        0, COEF_CMD ,          CMD_M},
    234241  { "coeffs",      0, COEFFS_CMD ,        CMD_23},
     242  #ifdef HAVE_FANS
     243  { "cone",        0, CONE_CMD,           ROOT_DECL},
     244  #endif /* HAVE_FANS */
    235245  { "continue",    0, CONTINUE_CMD ,      CONTINUE_CMD},
    236246  { "contract",    0, CONTRACT_CMD ,      CMD_2},
    … …  
    242252  { "degree",      0, DEGREE_CMD ,        CMD_1},
    243253  { "delete",      0, DELETE_CMD ,        CMD_2},
     254  #ifdef HAVE_FANS
     255  { "delmaxcone",  0, DELMCONE_CMD,       CMD_12},
     256  #endif /* HAVE_FANS */
    244257  { "det",         0, DET_CMD ,           CMD_1},
    245258  { "diff",        0, DIFF_CMD ,          CMD_2},
    … …  
    260273  { "export",      0, EXPORT_CMD ,        EXPORT_CMD},
    261274  { "exportto",    0, EXPORTTO_CMD ,      CMD_2},
     275  #ifdef HAVE_FANS
     276  { "facetnormals",0, FACETNS_CMD,        CMD_1},
     277  #endif /* HAVE_FANS */
    262278  { "factorize",   0, FAC_CMD ,           CMD_12},
     279  #ifdef HAVE_FANS
     280  { "fan",         0, FAN_CMD,            ROOT_DECL},
     281  #endif /* HAVE_FANS */
    263282  { "farey",       0, FAREY_CMD ,         CMD_2},
    264283  { "fetch",       0, FETCH_CMD ,         CMD_2},
    … …  
    273292  { "gen",         0, E_CMD ,             CMD_1},
    274293  { "getdump",     0, GETDUMP_CMD,        CMD_1},
     294  #ifdef HAVE_FANS
     295  { "getprop",     0, GETPROP_CMD,        CMD_2},
     296  #endif /* HAVE_FANS */
    275297  { "gcd",         0, GCD_CMD ,           CMD_2},
    276298  { "GCD",         2, GCD_CMD ,           CMD_2},
    … …  
    313335  { "liftstd",     0, LIFTSTD_CMD ,       CMD_23},
    314336  { "link",        0, LINK_CMD ,          ROOT_DECL},
     337  #ifdef HAVE_FANS
     338  { "linspace",    0, LINSPACE_CMD,       CMD_1},
     339  #endif /* HAVE_FANS */
    315340  { "listvar",     0, LISTVAR_CMD ,       LISTVAR_CMD},
    316341  { "list",        0, LIST_CMD ,          ROOT_DECL_LIST},
    … …  
    323348  { "matrix",      0, MATRIX_CMD ,        MATRIX_CMD},
    324349  { "maxideal",    0, MAXID_CMD ,         CMD_1},
     350  #ifdef HAVE_FANS
     351  { "maxcone",     0, MAXCONE_CMD,        CMD_12},
     352  { "maxrays",     0, MAXRAYS_CMD,        CMD_1},
     353  #endif /* HAVE_FANS */
    325354  { "memory",      0, MEMORY_CMD ,        CMD_1},
    326355  { "minbase",     0, MINBASE_CMD ,       CMD_1},
    … …  
    395424  { "ringlist",    0, RINGLIST_CMD ,      CMD_1},
    396425  { "rvar",        0, IS_RINGVAR ,        CMD_1},
     426  #ifdef HAVE_FANS
     427  { "setprop",     0, SETPROP_CMD,        CMD_3},
     428  #endif /* HAVE_FANS */
    397429  { "setring",     0, SETRING_CMD ,       SETRING_CMD},
    398430  { "simplex",     0, SIMPLEX_CMD,        CMD_M},
    … …  
    34123444  return FALSE;
    34133445}
     3446#ifdef HAVE_FANS
     3447static BOOLEAN jjADDMCONE1(leftv res, leftv u, leftv v)
     3448{
     3449  /* method for adding a maximal cone in the given fan;
     3450     valid parametrizations: (fan, cone),
     3451     Errors will be invoked in the following cases:
     3452     - the cone has been generated in the context of a
     3453       fan which is different from the given one */
     3454  Fan* f = (Fan*)u->Data();
     3455  Cone* c = (Cone*)v->Data();
     3456  if (! f->addMaxCone(c))
     3457  {
     3458    WerrorS("cone references a fan which is different from the 1st argument");
     3459    return TRUE;
     3460  }
     3461  else return FALSE;
     3462}
     3463static BOOLEAN jjADDMCONE2(leftv res, leftv u, leftv v)
     3464{
     3465  /* method for adding numerous maximal cones in the given fan;
     3466     valid parametrizations: (fan, list),
     3467     where the list entries are expected to be cones;
     3468     Errors will be invoked in the following cases:
     3469     - one of the cones has been generated in the context
     3470       of a fan which is different from the given one */
     3471  Fan* f = (Fan*)u->Data();
     3472  lists L = (lists)v->Data();
     3473  int index = f->addMaxCones(L);
     3474  if (index != 0)
     3475  {
     3476    Werror("cone at position %d references a fan which %s",
     3477           index, "is different from the 1st argument");
     3478    return TRUE;
     3479  }
     3480  else return FALSE;
     3481}
     3482static BOOLEAN jjDELMCONE2(leftv res, leftv u, leftv v)
     3483{
     3484  /* method for deleting a maximal cone from the given fan;
     3485     valid parametrizations: (fan, int),
     3486     Errors will be invoked in the following cases:
     3487     - the given index is out of range [1..m], where m is
     3488       the number of maximal cones in the given fan */
     3489  Fan* f = (Fan*)u->Data();
     3490  int index = (int)(long)v->Data();
     3491  if (! f->deleteMaxCone(index))
     3492  {
     3493    Werror("cone index %d out of range [1..%d]; no cone deleted",
     3494           index, f->getMaxCones()->nr + 1);
     3495    return TRUE;
     3496  }
     3497  else return FALSE;
     3498}
     3499static BOOLEAN jjDELMCONE3(leftv res, leftv u, leftv v)
     3500{
     3501  /* method for deleting numerous maximal cones from the
     3502     given fan;
     3503     valid parametrizations: (fan, intvec),
     3504     Errors will be invoked in the following cases:
     3505     - one of the given indices is out of range [1..m],
     3506       where m is the number of maximal cones in the given
     3507       fan;
     3508     The method does not check that the given indices are
     3509     mutually distinct. */
     3510  Fan* f = (Fan*)u->Data();
     3511  intvec* indices = (intvec*)v->Data();
     3512  int result = f->deleteMaxCones(indices);
     3513  if (result != 0)
     3514  {
     3515    Werror("cone index %d at position %d out of range [1..%d]; %s",
     3516           (*indices)[result - 1], result, f->getMaxCones()->nr + 1,
     3517           "no cone deleted");
     3518    return TRUE;
     3519  }
     3520  else return FALSE;
     3521}
     3522static BOOLEAN jjMAXCONE2(leftv res, leftv u, leftv v)
     3523{
     3524  /* method for retrieving a maximal cone of the given fan;
     3525     valid parametrizations: (fan, int),
     3526     Errors will be invoked in the following cases:
     3527     - maximal cones not yet set in the fan,
     3528     - maximal cone index invalid;
     3529     The method returns an object of type cone. */
     3530  Fan* f = (Fan*)u->Data();
     3531  int index = (int)(long)v->Data();
     3532  lists maxCones = f->getMaxCones();
     3533  if (maxCones == NULL)
     3534  {
     3535    WerrorS("no maximal cones set in the given fan");
     3536    return TRUE;
     3537  }
     3538  else if ((index < 1) || (maxCones->nr + 1 < index))
     3539  {
     3540    Werror("invalid cone index %d", index);
     3541    return TRUE;
     3542  }
     3543  res->data = (char*)new Cone(*(Cone*)(maxCones->m[index - 1].data));
     3544  return FALSE;
     3545}
     3546static BOOLEAN jjGETPROP1(leftv res, leftv u, leftv v)
     3547{
     3548  /* method for retrieving fan properties;
     3549     valid parametrizations: (fan, string),
     3550     Errors will be invoked in the following cases:
     3551     - fan has so far only been instantiated by "fan f;",
     3552     - string is neither of 'ambientdim', 'dim', 'complete',
     3553       'simplicial', 'pure' */
     3554  Fan* f = (Fan*)u->Data();
     3555  char* prop = (char*)v->Data();
     3556  int result;
     3557
     3558  if (f->getLinSpace() == NULL)
     3559  {
     3560    WerrorS("the given fan has no properties yet (freshly instantiated)");
     3561    return TRUE;
     3562  }
     3563
     3564  if      (strcmp(prop, "ambientdim") == 0)
     3565    result = f->getAmbientDim();
     3566  else if (strcmp(prop, "dim")        == 0)
     3567    result = f->getDim();
     3568  else if (strcmp(prop, "complete")   == 0)
     3569    result = f->getComplete();
     3570  else if (strcmp(prop, "simplicial") == 0)
     3571    result = f->getSimplicial();
     3572  else if (strcmp(prop, "pure")       == 0)
     3573    result = f->getPure();
     3574  else
     3575  {
     3576    Werror("unexpected fan property '%s'", prop);
     3577    return TRUE;
     3578  }
     3579
     3580  res->data = (void*)result;
     3581  return FALSE;
     3582}
     3583static BOOLEAN jjGETPROP2(leftv res, leftv u, leftv v)
     3584{
     3585  /* method for retrieving cone properties;
     3586     valid parametrizations: (cone, string),
     3587     Errors will be invoked in the following cases:
     3588     - cone has so far only been instantiated by "cone c;",
     3589     - string is not 'dim' */
     3590  Cone* c = (Cone*)u->Data();
     3591  char* prop = (char*)v->Data();
     3592  int result;
     3593
     3594  if (c->getFan() == NULL)
     3595  {
     3596    WerrorS("the given cone has no properties yet (freshly instantiated)");
     3597    return TRUE;
     3598  }
     3599
     3600  if (strcmp(prop, "dim") == 0)
     3601    result = c->getDim();
     3602  else
     3603  {
     3604    Werror("unexpected cone property '%s'", prop);
     3605    return TRUE;
     3606  }
     3607
     3608  res->data = (void*)result;
     3609  return FALSE;
     3610}
     3611#endif /* HAVE_FANS */
    34143612static BOOLEAN jjVARSTR2(leftv res, leftv u, leftv v)
    34153613{
    … …  
    38034001,{jjVARSTR2,   VARSTR_CMD,     STRING_CMD,     QRING_CMD,  INT_CMD, ALLOW_PLURAL |ALLOW_RING}
    38044002,{jjWEDGE,     WEDGE_CMD,      MATRIX_CMD,     MATRIX_CMD, INT_CMD, NO_PLURAL |ALLOW_RING}
     4003#ifdef HAVE_FANS
     4004,{jjADDMCONE1, ADDMCONE_CMD,   NONE,           FAN_CMD,    CONE_CMD, ALLOW_PLURAL | ALLOW_RING}
     4005,{jjADDMCONE2, ADDMCONE_CMD,   NONE,           FAN_CMD,    LIST_CMD, ALLOW_PLURAL | ALLOW_RING}
     4006,{jjDELMCONE2, DELMCONE_CMD,   NONE,           FAN_CMD,    INT_CMD, ALLOW_PLURAL | ALLOW_RING}
     4007,{jjDELMCONE3, DELMCONE_CMD,   NONE,           FAN_CMD,    INTVEC_CMD, ALLOW_PLURAL | ALLOW_RING}
     4008,{jjMAXCONE2,  MAXCONE_CMD,    CONE_CMD,       FAN_CMD,    INT_CMD, ALLOW_PLURAL |ALLOW_RING}
     4009,{jjGETPROP1,  GETPROP_CMD,    INT_CMD,        FAN_CMD,    STRING_CMD, ALLOW_PLURAL |ALLOW_RING}
     4010,{jjGETPROP2,  GETPROP_CMD,    INT_CMD,        CONE_CMD,   STRING_CMD, ALLOW_PLURAL |ALLOW_RING}
     4011#endif /* HAVE_FANS */
    38054012,{NULL,        0,              0,              0,          0, NO_PLURAL |NO_RING}
    38064013};
    … …  
    50575264  switch ((int)(long)v->data)
    50585265  {
    5059     case INT_CMD:     res->data=omStrDup("int"); break;
    5060     case POLY_CMD:   res->data=omStrDup("poly"); break;
    5061     case VECTOR_CMD:  res->data=omStrDup("vector"); break;
    5062     case STRING_CMD:  res->data=omStrDup("string"); break;
    5063     case INTVEC_CMD:  res->data=omStrDup("intvec"); break;
    5064     case IDEAL_CMD:   res->data=omStrDup("ideal"); break;
    5065     case MATRIX_CMD: res->data=omStrDup("matrix"); break;
    5066     case MODUL_CMD:   res->data=omStrDup("module"); break;
    5067     case MAP_CMD:     res->data=omStrDup("map"); break;
    5068     case PROC_CMD:    res->data=omStrDup("proc"); break;
    5069     case RING_CMD:    res->data=omStrDup("ring"); break;
    5070     case QRING_CMD:   res->data=omStrDup("qring"); break;
    5071     case INTMAT_CMD:  res->data=omStrDup("intmat"); break;
    5072     case NUMBER_CMD:  res->data=omStrDup("number"); break;
    5073     case BIGINT_CMD:  res->data=omStrDup("bigint"); break;
    5074     case LIST_CMD:   res->data=omStrDup("list"); break;
    5075     case PACKAGE_CMD: res->data=omStrDup("package"); break;
    5076     case LINK_CMD:   res->data=omStrDup("link"); break;
    5077     case RESOLUTION_CMD:res->data=omStrDup("resolution");break;
     5266    case INT_CMD:        res->data=omStrDup("int"); break;
     5267    case POLY_CMD:       res->data=omStrDup("poly"); break;
     5268    case VECTOR_CMD:     res->data=omStrDup("vector"); break;
     5269    case STRING_CMD:     res->data=omStrDup("string"); break;
     5270    case INTVEC_CMD:     res->data=omStrDup("intvec"); break;
     5271    case IDEAL_CMD:      res->data=omStrDup("ideal"); break;
     5272    case MATRIX_CMD:     res->data=omStrDup("matrix"); break;
     5273    case MODUL_CMD:      res->data=omStrDup("module"); break;
     5274    case MAP_CMD:        res->data=omStrDup("map"); break;
     5275    case PROC_CMD:       res->data=omStrDup("proc"); break;
     5276    case RING_CMD:       res->data=omStrDup("ring"); break;
     5277    case QRING_CMD:      res->data=omStrDup("qring"); break;
     5278    case INTMAT_CMD:     res->data=omStrDup("intmat"); break;
     5279    case NUMBER_CMD:     res->data=omStrDup("number"); break;
     5280    case BIGINT_CMD:     res->data=omStrDup("bigint"); break;
     5281    case LIST_CMD:       res->data=omStrDup("list"); break;
     5282    case PACKAGE_CMD:    res->data=omStrDup("package"); break;
     5283    case LINK_CMD:       res->data=omStrDup("link"); break;
     5284    case RESOLUTION_CMD: res->data=omStrDup("resolution");break;
     5285#ifdef HAVE_FANS
     5286    case FAN_CMD:        res->data=omStrDup("fan");break;
     5287    case CONE_CMD:       res->data=omStrDup("cone");break;
     5288#endif /* HAVE_FANS */
    50785289    case DEF_CMD:
    5079     case NONE:    res->data=omStrDup("none"); break;
    5080     default:       res->data=omStrDup("?unknown type?");
     5290    case NONE:           res->data=omStrDup("none"); break;
     5291    default:             res->data=omStrDup("?unknown type?");
    50815292  }
    50825293  return FALSE;
    … …  
    51275338  return FALSE;
    51285339}
    5129 
     5340#ifdef HAVE_FANS
     5341static BOOLEAN jjDELMCONE1(leftv res, leftv v)
     5342{
     5343  /* method for deleting all maximal cones of the given fan;
     5344     valid parametrizations: (fan) */
     5345  Fan* f = (Fan*)v->Data();
     5346  f->deleteMaxCones(NULL);
     5347  return FALSE;
     5348}
     5349static BOOLEAN jjMAXRAYS1(leftv res, leftv v)
     5350{
     5351  /* method for retrieving all maximal rays of the given fan;
     5352     valid parametrizations: (fan),
     5353     If there are no maximal rays, the method returns a 1x1
     5354     matrix with entry 0. Otherwise the returned matrix contains
     5355     the maximal rays as column vectors. */
     5356  Fan* f = (Fan*)v->Data();
     5357  intvec* result = NULL;
     5358  if (f->getMaxRays() == NULL)
     5359    /* return a 1x1 matrix with sole entry zero */
     5360    result = new intvec(1, 1, 0);
     5361  else
     5362    result = ivCopy(f->getMaxRays());
     5363  res->data = (char*)result;
     5364  return FALSE;
     5365}
     5366static BOOLEAN jjMAXRAYS2(leftv res, leftv v)
     5367{
     5368  /* method for retrieving all maximal rays of the given cone;
     5369     valid parametrizations: (cone),
     5370     If there are no maximal rays, the method returns a 1x1
     5371     matrix with entry 0. Otherwise the returned matrix contains
     5372     the maximal rays as column vectors. */
     5373  Cone* c = (Cone*)v->Data();
     5374  intvec* result = NULL;
     5375  if (c->getRays() == NULL)
     5376    /* return a 1x1 matrix with sole entry zero */
     5377    result = new intvec(1, 1, 0);
     5378  else
     5379  {
     5380    intvec* indices = c->getRays();
     5381    intvec* maxRays = c->getFan()->getMaxRays();
     5382    result = new intvec(maxRays->rows(), indices->length(), 0);
     5383    for (int c = 1; c <= indices->length(); c++)
     5384      for (int r = 1; r <= maxRays->rows(); r++)
     5385      {
     5386        IMATELEM(*result, r, c) = IMATELEM(*maxRays, r, (*indices)[c - 1]);
     5387      }
     5388  }
     5389  res->data = (char*)result;
     5390  return FALSE;
     5391}
     5392static BOOLEAN jjFACETNS1(leftv res, leftv v)
     5393{
     5394  /* method for retrieving the facet normals of the given fan;
     5395     valid parametrizations: (fan),
     5396     If there are no facet normals, a 1x1 matrix with entry 0
     5397     is returned; otherwise a matrix the columns of which are
     5398     the facet normals of the given fan. */
     5399  Fan* f = (Fan*)v->Data();
     5400  intvec* result = NULL;
     5401  if (f->getFacetNs() == NULL)
     5402    /* return a 1x1 matrix with sole entry zero */
     5403    result = new intvec(1, 1, 0);
     5404  else
     5405    result = ivCopy(f->getFacetNs());
     5406  res->data = (char*)result;
     5407  return FALSE;
     5408}
     5409static BOOLEAN jjFACETNS2(leftv res, leftv v)
     5410{
     5411  /* method for retrieving the facet normals of the given cone;
     5412     valid parametrizations: (fan),
     5413     If there are no facet normals, a 1x1 matrix with entry 0
     5414     is returned; otherwise a matrix the columns of which are
     5415     the facet normals of the given cone. */
     5416  Cone* c = (Cone*)v->Data();
     5417  intvec* result = NULL;
     5418  if (c->getFacetNs() == NULL)
     5419    /* return a 1x1 matrix with sole entry zero */
     5420    result = new intvec(1, 1, 0);
     5421  else
     5422  {
     5423    intvec* indices = c->getFacetNs();
     5424    intvec* facetNs = c->getFan()->getFacetNs();
     5425    result = new intvec(facetNs->rows(), indices->length(), 0);
     5426    for (int c = 1; c <= indices->length(); c++)
     5427      for (int r = 1; r <= facetNs->rows(); r++)
     5428      {
     5429        IMATELEM(*result, r, c) = IMATELEM(*facetNs, r, (*indices)[c - 1]);
     5430      }
     5431  }
     5432  res->data = (char*)result;
     5433  return FALSE;
     5434}
     5435static BOOLEAN jjLINSPACE(leftv res, leftv v)
     5436{
     5437  /* method for retrieving the lineality space of the given fan;
     5438     valid parametrizations: (fan) */
     5439  Fan* f = (Fan*)v->Data();
     5440  intvec* result = ivCopy(f->getLinSpace());
     5441  res->data = (char*)result;
     5442  return FALSE;
     5443}
     5444static BOOLEAN jjMAXCONE1(leftv res, leftv v)
     5445{
     5446  /* method for retrieving all maximal cones of the given fan;
     5447     valid parametrizations: (fan),
     5448     Errors will be invoked in the following cases:
     5449     - maximal cones not yet set in the fan;
     5450     The method returns a list of cone objects. */
     5451  Fan* f = (Fan*)v->Data();
     5452  lists maxCones = lCopy(f->getMaxCones());
     5453  if (maxCones == NULL)
     5454  {
     5455    WerrorS("no maximal cones set in the given fan");
     5456    return TRUE;
     5457  }
     5458  res->data = (char*)maxCones;
     5459  return FALSE;
     5460}
     5461static BOOLEAN jjADJACENCY1(leftv res, leftv v)
     5462{
     5463  /* method for retrieving the adjacency matrix of the given fan;
     5464     valid parametrizations: (fan),
     5465     Errors will be invoked in the following cases:
     5466     - no maximal cone has been defined yet in the given fan;
     5467     The matrix entries have the following meaning:
     5468     _[i, j] =  0: the maximal cones with indices i and j are
     5469                   not adjacent,
     5470             =  1: they are adjacent, and the intersection facet
     5471                   has been stored in the given fan,
     5472             = -1: they are adjacent but there is no intersection
     5473                   facet available */
     5474  Fan* f = (Fan*)v->Data();
     5475  if (f->getMaxCones()->nr + 1 < 1)
     5476  {
     5477    WerrorS("no maximal cones defined yet");
     5478    return TRUE;
     5479  }
     5480  intvec* adjacencyMatrix = f->getAdjacency();
     5481  res->data = (char*)adjacencyMatrix;
     5482  return FALSE;
     5483}
     5484#endif /* HAVE_FANS */
    51305485static BOOLEAN jjLOAD1(leftv res, leftv v)
    51315486{
    … …  
    56716026,{jjLOAD1,      LOAD_CMD,        NONE,           STRING_CMD    , ALLOW_PLURAL |ALLOW_RING}
    56726027,{loNewtonP,    NEWTONPOLY_CMD,  IDEAL_CMD,      IDEAL_CMD     , ALLOW_PLURAL |ALLOW_RING}
     6028#ifdef HAVE_FANS
     6029,{jjDELMCONE1,  DELMCONE_CMD,    NONE,           FAN_CMD       , ALLOW_PLURAL |ALLOW_RING}
     6030,{jjMAXRAYS1,   MAXRAYS_CMD,     INTMAT_CMD,     FAN_CMD       , ALLOW_PLURAL |ALLOW_RING}
     6031,{jjMAXRAYS2,   MAXRAYS_CMD,     INTMAT_CMD,     CONE_CMD      , ALLOW_PLURAL |ALLOW_RING}
     6032,{jjFACETNS1,   FACETNS_CMD,     INTMAT_CMD,     FAN_CMD       , ALLOW_PLURAL |ALLOW_RING}
     6033,{jjFACETNS2,   FACETNS_CMD,     INTMAT_CMD,     CONE_CMD      , ALLOW_PLURAL |ALLOW_RING}
     6034,{jjLINSPACE,   LINSPACE_CMD,    INTMAT_CMD,     FAN_CMD       , ALLOW_PLURAL |ALLOW_RING}
     6035,{jjMAXCONE1,   MAXCONE_CMD,     LIST_CMD,       FAN_CMD       , ALLOW_PLURAL |ALLOW_RING}
     6036,{jjADJACENCY1, ADJACENCY_CMD,   INTMAT_CMD,     FAN_CMD       , ALLOW_PLURAL |ALLOW_RING}
     6037#endif /* HAVE_FANS */
    56736038,{NULL,         0,               0,              0             , NO_PLURAL |NO_RING}
    56746039};
    … …  
    66837048  return FALSE;
    66847049}
     7050#ifdef HAVE_FANS
     7051static BOOLEAN jjSETPROP1(leftv res, leftv u, leftv v, leftv w)
     7052{
     7053  /* method for setting fan properties;
     7054     valid parametrizations: (fan, string, int),
     7055     Errors will be invoked in the following cases:
     7056     - string is neither of 'dim', 'complete', 'simplicial',
     7057       and 'pure';
     7058     A value 0 means that the property is not fulfilled.
     7059     1 means it is. -1 means that the answer is unknown.
     7060     Any value other than 0 and 1 will be converted to -1;
     7061     except for dim: Here, only negative values will be converted
     7062     to -1. */
     7063  Fan* f = (Fan*)u->Data();
     7064  char* prop = (char*)v->Data();
     7065  int value = (int)(long)w->Data();
     7066
     7067  if      (strcmp(prop, "ambientdim") == 0)
     7068  {
     7069    Werror("ambient dimension of a fan cannot be set (implicitely given)");
     7070    return TRUE;
     7071  }
     7072  else if (strcmp(prop, "dim")        == 0)
     7073    f->setDim(value);
     7074  else if (strcmp(prop, "complete")   == 0)
     7075    f->setComplete(value);
     7076  else if (strcmp(prop, "simplicial") == 0)
     7077    f->setSimplicial(value);
     7078  else if (strcmp(prop, "pure")       == 0)
     7079    f->setPure(value);
     7080  else
     7081  {
     7082    Werror("unexpected fan property '%s'", prop);
     7083    return TRUE;
     7084  }
     7085
     7086  return FALSE;
     7087}
     7088static BOOLEAN jjSETPROP2(leftv res, leftv u, leftv v, leftv w)
     7089{
     7090  /* method for setting cone properties;
     7091     valid parametrizations: (fan, string, int),
     7092     Errors will be invoked in the following cases:
     7093     - string is not 'dim';
     7094     Any negative value will be converted to -1 signaling
     7095     that the dim is unknown. */
     7096  Cone* c = (Cone*)u->Data();
     7097  char* prop = (char*)v->Data();
     7098  int value = (int)(long)w->Data();
     7099
     7100  if (strcmp(prop, "dim") == 0)
     7101    c->setDim(value);
     7102  else
     7103  {
     7104    Werror("unexpected cone property '%s'", prop);
     7105    return TRUE;
     7106  }
     7107
     7108  return FALSE;
     7109}
     7110static BOOLEAN jjADJACENCY2(leftv res, leftv u, leftv v, leftv w)
     7111{
     7112  /* method for retrieving the adjacency information concerning
     7113     two maximal cones of the given fan;
     7114     valid parametrizations: (fan, int, int),
     7115     Errors will be invoked in the following cases:
     7116     - a maximal cone index is out of range [1..m],
     7117       where m is the number of maximal cones in the given fan,
     7118     - the two specified maximal cones are not adjacent,
     7119     - the two specified maximal cones are adjacent but the
     7120       intersection facet has not been stored in the fan */
     7121  Fan* f = (Fan*)u->Data();
     7122  int maxCone1 = (int)(long)v->Data();
     7123  int maxCone2 = (int)(long)w->Data();
     7124  int nMaxCones = f->getMaxCones()->nr + 1;
     7125  if ((maxCone1 < 1) || (nMaxCones < maxCone1))
     7126  {
     7127    Werror("1st index %d out of range [1..%d]",
     7128           maxCone1, nMaxCones);
     7129    return TRUE;
     7130  }
     7131  if ((maxCone2 < 1) || (nMaxCones < maxCone2))
     7132  {
     7133    Werror("2nd index %d out of range [1..%d]",
     7134           maxCone2, nMaxCones);
     7135    return TRUE;
     7136  }
     7137  Cone* result = (Cone*)f->getAdjacencyFacet(maxCone1, maxCone2);
     7138  if (result->isNoAdj())
     7139  {
     7140    WerrorS("specified cones are not adjacent");
     7141    return TRUE;
     7142  }
     7143  if (result->isNoFacet())
     7144  {
     7145    Werror("specified cones are adjacent, %s",
     7146           "but there is no facet information available");
     7147    return TRUE;
     7148  }
     7149  res->data = (char*)result;
     7150  return FALSE;
     7151}
     7152#endif /* HAVE_FANS */
    66857153static BOOLEAN jjSTD_HILB_W(leftv res, leftv u, leftv v, leftv w)
    66867154{
    … …  
    68247292,{nuLagSolve,       LAGSOLVE_CMD,LIST_CMD,  POLY_CMD,   INT_CMD,    INT_CMD  , NO_PLURAL |NO_RING}
    68257293,{nuVanderSys,      VANDER_CMD, POLY_CMD,   IDEAL_CMD,  IDEAL_CMD,  INT_CMD  , NO_PLURAL |NO_RING}
     7294#ifdef HAVE_FANS
     7295,{jjSETPROP1,       SETPROP_CMD,NONE,       FAN_CMD,    STRING_CMD, INT_CMD  , NO_PLURAL |NO_RING}
     7296,{jjSETPROP2,       SETPROP_CMD,NONE,       CONE_CMD,   STRING_CMD, INT_CMD  , NO_PLURAL |NO_RING}
     7297,{jjADJACENCY2,     ADJACENCY_CMD,CONE_CMD, FAN_CMD,    INT_CMD,    INT_CMD  , NO_PLURAL |NO_RING}
     7298#endif /* HAVE_FANS */
    68267299,{NULL,             0,          0,          0,          0,          0        , NO_PLURAL |NO_RING}
    68277300};
    … …  
    73067779  return FALSE;
    73077780}
     7781#ifdef HAVE_FANS
     7782static BOOLEAN jjADDADJ(leftv res, leftv v)
     7783{
     7784  /* method for adding one or more adjacencies between pairs of
     7785     maximal cones of the given fan;
     7786     valid parametrizations: (fan, int, int, cone),
     7787                             (fan, int, int, 0), or
     7788                             (fan, intvec, intvec, list),
     7789     where in the latter case, the list entries must either be
     7790     of type Cone* or the integer zero;
     7791     Errors will be invoked in the following cases:
     7792     - we have none of the above parametrizations,
     7793     - intvecs and list have different lengths,
     7794     - int's resp. intvec entries are out of range [1..m], where
     7795       m is the number of maximal cones in the given fan,
     7796     - int's are equal resp. intvec entries at same positions
     7797       are equal */
     7798  if ((v == NULL) || (v->next == NULL) ||
     7799      (v->next->next == NULL) || (v->next->next->next == NULL) ||
     7800      (v->next->next->next->next != NULL))
     7801  {
     7802    WerrorS("expected exactly four arguments as input");
     7803    return TRUE;
     7804  }
     7805  Fan* f = NULL;
     7806  int i; intvec* iv;
     7807  int j; intvec* jv;
     7808  Cone* c = NULL; lists L;
     7809  leftv x = v; bool listCase = false;
     7810  if (x->Typ() == FAN_CMD)
     7811    f = (Fan*)x->Data();
     7812  else
     7813  {
     7814    WerrorS("expected fan as 1st argument");
     7815    return TRUE;
     7816  }
     7817  x = x->next;
     7818  if      (x->Typ() == INT_CMD)
     7819    i = (int)(long)x->Data();
     7820  else if (x->Typ() == INTVEC_CMD)
     7821  {
     7822    iv = (intvec*)x->Data(); listCase = true;
     7823  }
     7824  else
     7825  {
     7826    WerrorS("expected int or intvec as 2nd argument");
     7827    return TRUE;
     7828  }
     7829  x = x->next;
     7830  if (listCase)
     7831  {
     7832    if ((x->Typ() != INTVEC_CMD) || ((x->next->Typ() != LIST_CMD)))
     7833    {
     7834      Werror("expected (fan, int, int, cone/0) %s",
     7835             "or (fan, intvec, intvec, list)");
     7836      return TRUE;
     7837    }
     7838    else jv = (intvec*)x->Data();
     7839    x = x->next;
     7840    L = (lists)x->Data();
     7841  }
     7842  else
     7843  {
     7844    if ((x->Typ() != INT_CMD) ||
     7845        ((x->next->Typ() != CONE_CMD) && (x->next->Typ() != INT_CMD)))
     7846    {
     7847      Werror("expected (fan, int, int, cone/0) %s",
     7848             "or (fan, intvec, intvec, list)");
     7849      return TRUE;
     7850    }
     7851    else j = (int)(long)x->Data();
     7852    x = x->next;
     7853    if ((x->Typ() == INT_CMD) && ((int)(long)x->Data() != 0))
     7854    {
     7855      WerrorS("expected (fan, int, int, cone/0)");
     7856      return TRUE;
     7857    }
     7858    if (x->Typ() != INT_CMD) c = (Cone*)x->Data();
     7859  }
     7860  int n = f->getMaxCones()->nr + 1;
     7861  if (!listCase)
     7862  {
     7863    if ((i < 1) || (n < i))
     7864    { Werror("2nd argument %d out of range [1..%d]", i, n); }
     7865    if ((j < 1) || (n < j))
     7866    { Werror("3rd argument %d out of range [1..%d]", j, n); }
     7867    if (i == j)
     7868    { WerrorS("2nd and 3rd argument are equal"); }
     7869    f->addAdjacency(i, j, c);
     7870  }
     7871  else
     7872  {
     7873    if (iv->length() != jv->length())
     7874      WerrorS("2nd and 3rd argument have different lengths");
     7875    if (iv->length() != L->nr + 1)
     7876      WerrorS("2nd and 4th argument have different lengths");
     7877    for (i = 0; i < iv->length(); i++)
     7878    {
     7879      if (((*iv)[i] < 1) || (n < (*iv)[i]))
     7880        Werror("index %d at position %d in 2nd argument out of range [1..%d]",
     7881               (*iv)[i], i + 1, n);
     7882    }
     7883    for (j = 0; j < jv->length(); j++)
     7884    {
     7885      if (((*jv)[j] < 1) || (n < (*jv)[j]))
     7886        Werror("index %d at position %d in 3rd argument out of range [1..%d]",
     7887               (*jv)[j], j + 1, n);
     7888      if ((*iv)[j] == (*jv)[j])
     7889        Werror("indices in 2nd and 3rd argument at position %d equal", j + 1);
     7890    }
     7891    for (i = 0; i < L->nr + 1; i++)
     7892    {
     7893      if ((L->m[i].Typ() != CONE_CMD) &&
     7894          ((L->m[i].Typ() != INT_CMD) || ((int)(long)L->m[i].Data() != 0)))
     7895        Werror("entry at position %d in 4th argument neither cone nor int 0",
     7896               i + 1);
     7897    }
     7898    f->addAdjacencies(iv, jv, L);
     7899  }
     7900  return FALSE;
     7901}
     7902#endif /* HAVE_FANS */
    73087903static BOOLEAN jjINTVEC_PL(leftv res, leftv v)
    73097904{
    … …  
    78188413,{jjCALL3ARG,  STD_CMD,         IDEAL_CMD,           3      , NO_PLURAL |ALLOW_RING}
    78198414,{jjSTD_HILB_WP, STD_CMD,       IDEAL_CMD,           4      , NO_PLURAL |ALLOW_RING}
     8415#ifdef HAVE_FANS
     8416,{jjADDADJ,    ADDADJ_CMD,      NONE,               -2      , NO_PLURAL |NO_RING}
     8417#endif /* HAVE_FANS */
    78208418,{NULL,        0,               0,                   0      , NO_PLURAL |NO_RING}
    78218419};

  • Singular/ipassign.cc

    r8e7db4 r4f80bb  
    4040#include <Singular/ipshell.h>
    4141#include <kernel/sca.h>
     42#include <Singular/Fan.h>
     43#include <Singular/Cone.h>
    4244
    4345/*=================== proc =================*/
    … …  
    319321  return FALSE;
    320322}
     323#ifdef HAVE_FANS
     324static BOOLEAN jiA_FAN(leftv res, leftv a, Subexpr e)
     325{
     326  if (e != NULL)
     327  {
     328    WerrorS("unexpectedly encountered subexpression in jiA_FAN");
     329    return TRUE;
     330  }
     331  if (res->data!=NULL)
     332  {
     333    Fan* fff = (Fan*)res->data;
     334    res->data = NULL;
     335    delete fff;
     336  }
     337  Fan* fff = (Fan*)a->CopyD(FAN_CMD);
     338  res->data=(void*)fff;
     339  return FALSE;
     340}
     341static BOOLEAN jiA_CONE(leftv res, leftv a, Subexpr e)
     342{
     343  if (e != NULL)
     344  {
     345    WerrorS("unexpectedly encountered subexpression in jiA_CONE");
     346    return TRUE;
     347  }
     348  if (res->data!=NULL)
     349  {
     350    Cone* ccc = (Cone*)res->data;
     351    res->data = NULL;
     352    delete ccc;
     353  }
     354  Cone* ccc = (Cone*)a->CopyD(CONE_CMD);
     355  res->data=(void*)ccc;
     356  return FALSE;
     357}
     358#endif /* HAVE_FANS */
    321359static BOOLEAN jiA_POLY(leftv res, leftv a,Subexpr e)
    322360{
    … …  
    697735,{jiA_LINK,     LINK_CMD,       STRING_CMD }
    698736,{jiA_LINK,     LINK_CMD,       LINK_CMD }
     737#ifdef HAVE_FANS
     738,{jiA_FAN,      FAN_CMD,        FAN_CMD }
     739,{jiA_CONE,     CONE_CMD,       CONE_CMD }
     740#endif /* HAVE_FANS */
    699741,{jiA_PACKAGE,  PACKAGE_CMD,    PACKAGE_CMD }
    700742,{NULL,         0,              0 }
    … …  
    13461388  return b;
    13471389}
     1390#ifdef HAVE_FANS
     1391BOOLEAN jjAssignFan(leftv l, leftv r)
     1392{
     1393  /* method for generating a fan;
     1394     valid parametrizations: (intmat or 0, intmat or 0, intmat or 0),
     1395     The intmat's capture the maximal rays, facet normals and the
     1396     lineality space of the new fan.
     1397     Any of the arguments may be the int 0. But either the 1st or
     1398     2nd argument must be an intmat, thus not both simultaneously
     1399     the int 0.
     1400     Errors will be invoked in the following cases:
     1401     - 1st and 2nd argument simultaneously the int 0,
     1402     - numbers of rows in 1st, 2nd, and/or 3rd argument intmat
     1403       disagree */
     1404  intvec* maxRays = NULL;    /* maximal rays */
     1405  intvec* facetNs = NULL;    /* facet normals */
     1406  intvec* linSpace = NULL;   /* lineality space */
     1407
     1408  leftv x = r;
     1409  if (x->Typ() == INTMAT_CMD) maxRays = (intvec*)x->Data();
     1410  else if ((x->Typ() != INT_CMD) ||
     1411           ((x->Typ() == INT_CMD) && ((int)(long)x->Data() != 0)))
     1412  {
     1413    WerrorS("expected '0' or an intmat as 1st argument");
     1414    return TRUE;
     1415  }
     1416  x = x->next;
     1417  if (x->Typ() == INTMAT_CMD) facetNs = (intvec*)x->Data();
     1418  else if ((x->Typ() != INT_CMD) ||
     1419           ((x->Typ() == INT_CMD) && ((int)(long)x->Data() != 0)))
     1420  {
     1421    WerrorS("expected '0' or an intmat as 2nd argument");
     1422    return TRUE;
     1423  }
     1424  if ((maxRays == NULL) && (facetNs == NULL))
     1425  {
     1426    WerrorS("expected 1st or 2nd argument to be a valid intmat");
     1427    return TRUE;
     1428  }
     1429  x = x->next;
     1430  if (x->Typ() == INTMAT_CMD) linSpace = (intvec*)x->Data();
     1431  else if ((x->Typ() != INT_CMD) ||
     1432           ((x->Typ() == INT_CMD) && ((int)(long)x->Data() != 0)))
     1433  {
     1434    WerrorS("expected '0' or an intmat as 3rd argument");
     1435    return TRUE;
     1436  }
     1437  if ((maxRays != NULL) && (facetNs != NULL) &&
     1438      (maxRays->rows() != facetNs->rows()))
     1439  {
     1440    WerrorS("vector space dims do not agree (1st vs. 2nd argument)");
     1441    return TRUE;
     1442  }
     1443  if ((maxRays != NULL) && (linSpace != NULL) &&
     1444      (maxRays->rows() != linSpace->rows()))
     1445  {
     1446    WerrorS("vector space dims do not agree (1st vs. 3rd argument)");
     1447    return TRUE;
     1448  }
     1449  if ((facetNs != NULL) && (linSpace != NULL) &&
     1450      (facetNs->rows() != linSpace->rows()))
     1451  {
     1452    WerrorS("vector space dims do not agree (2nd vs. 3rd argument)");
     1453    return TRUE;
     1454  }
     1455
     1456  if (IDDATA((idhdl)l->data) != NULL)
     1457  {
     1458    Fan* fff = (Fan*)IDDATA((idhdl)l->data);
     1459    delete fff;
     1460  }
     1461  Fan* fff = new Fan(maxRays, facetNs, linSpace);
     1462  IDDATA((idhdl)l->data) = (char*)fff;
     1463  return FALSE;
     1464}
     1465BOOLEAN jjAssignCone(leftv l, leftv r)
     1466{
     1467  /* method for generating a cone;
     1468     valid parametrizations: (fan, intvec or 0, intvec or 0),
     1469     The intvec's capture indices of the maximal rays resp.
     1470     facet normals of the given fan.
     1471     2nd and 3rd argument may be the int 0, but not simultaneously.
     1472     Errors will be invoked in the following cases:
     1473     - 2nd and 3rd argument simultaneously the int 0,
     1474     - invalid index for maximal row or facet normal */
     1475  Fan* fff = NULL;           /* the Fan where maximal rays and/or
     1476                                facet normals are stored */
     1477  intvec* maxRays = NULL;    /* indices of maximal rays */
     1478  intvec* facetNs = NULL;    /* indices of facet normals */
     1479
     1480  leftv x = r;
     1481  if (x->Typ() != FAN_CMD)
     1482  {
     1483    WerrorS("expected a fan as 1st argument");
     1484    return TRUE;
     1485  }
     1486  else
     1487  {
     1488    fff = (Fan*)x->Data();
     1489  }
     1490  x = x->next;
     1491  if (x->Typ() == INTVEC_CMD) maxRays = (intvec*)x->Data();
     1492  else if ((x->Typ() != INT_CMD) ||
     1493           ((x->Typ() == INT_CMD) && ((int)(long)x->Data() != 0)))
     1494  {
     1495    WerrorS("expected '0' or an intvec as 2nd argument");
     1496    return TRUE;
     1497  }
     1498  x = x->next;
     1499  if (x->Typ() == INTVEC_CMD) facetNs = (intvec*)x->Data();
     1500  else if ((x->Typ() != INT_CMD) ||
     1501           ((x->Typ() == INT_CMD) && ((int)(long)x->Data() != 0)))
     1502  {
     1503    WerrorS("expected '0' or an intvec as 3rd argument");
     1504    return TRUE;
     1505  }
     1506  if ((maxRays == NULL) && (facetNs == NULL))
     1507  {
     1508    WerrorS("expected 2nd or 3rd argument to be a valid intvec");
     1509    return TRUE;
     1510  }
     1511 
     1512  int check = Cone::checkConeData(fff, maxRays, facetNs);
     1513  if (check > 0)
     1514  {
     1515    Werror("invalid index %d for maximal ray at position %d",
     1516           (int)(long)((*maxRays)[check - 1]), check);
     1517    return TRUE;
     1518  }
     1519  else if (check < 0)
     1520  {
     1521    char h[150];
     1522    sprintf(h, "invalid index %d for facet normal at position %d",
     1523               (int)(long)((*facetNs)[-check - 1]), -check);
     1524    WerrorS(h);
     1525    return TRUE;
     1526  }
     1527
     1528  if (IDDATA((idhdl)l->data) != NULL)
     1529  {
     1530    Cone* ccc = (Cone*)IDDATA((idhdl)l->data);
     1531    delete ccc;
     1532  }
     1533  Cone* ccc = new Cone(fff, maxRays, facetNs);
     1534  IDDATA((idhdl)l->data) = (char*)ccc;
     1535  return FALSE;
     1536}
     1537#endif /* HAVE_FANS */
    13481538BOOLEAN iiAssign(leftv l, leftv r)
    13491539{
    … …  
    14661656      }
    14671657    }
     1658#ifdef HAVE_FANS
     1659    else if ((lt == FAN_CMD) && (rl == 3))
     1660    {
     1661      return jjAssignFan(l, r);
     1662    }
     1663    else if ((lt == CONE_CMD) && (rl == 3))
     1664    {
     1665      return jjAssignCone(l, r);
     1666    }
     1667#endif /* HAVE_FANS */
    14681668    if (rt==NONE) rt=r->Typ();
    14691669  }

  • Singular/ipid.cc

    r8e7db4 r4f80bb  
    2929#include <kernel/syz.h>
    3030#include <Singular/ipid.h>
     31#include <Singular/Fan.h>
     32#include <Singular/Cone.h>
    3133
    3234#ifdef HAVE_DYNAMIC_LOADING
    … …  
    464466      syKillComputation((syStrategy)IDDATA(h),r);
    465467  }
     468#ifdef HAVE_FANS
     469  // fan -------------------------------------------------------------
     470  else if (IDTYP(h) == FAN_CMD)
     471  {
     472    Fan* fff = (Fan*)IDDATA(h);
     473    delete fff;
     474    IDDATA(h) = NULL;
     475  }
     476  // cone ------------------------------------------------------------
     477  else if (IDTYP(h) == CONE_CMD)
     478  {
     479    Cone* ccc = (Cone*)IDDATA(h);
     480    delete ccc;
     481    IDDATA(h) = NULL;
     482  }
     483#endif /* HAVE_FANS */
    466484#ifdef TEST
    467485  else if ((IDTYP(h)!= INT_CMD)

  • Singular/misc_ip.h

    r8e7db4 r4f80bb  
    2525#define MISC_H
    2626
    27 #include <si_gmp.h>
     27#include <kernel/si_gmp.h>
    2828#include <kernel/structs.h>
    2929

  • Singular/subexpr.cc

    r8e7db4 r4f80bb  
    3838#include <Singular/attrib.h>
    3939#include <Singular/subexpr.h>
     40#include <Singular/Fan.h>
     41#include <Singular/Cone.h>
    4042
    4143omBin sSubexpr_bin = omGetSpecBin(sizeof(_ssubexpr));
    … …  
    153155          ::Print("%d",(int)(long)d);
    154156          break;
     157#ifdef HAVE_FANS
     158       case CONE_CMD:
     159       case FAN_CMD:
     160          PrintNSpaces(spaces);
     161          {
     162            char *s = String();
     163            ::PrintS(s);
     164            omFree(s);
     165          }
     166          break;
     167#endif /* HAVE_FANS */
    155168       case PROC_CMD:
    156169         {
    … …  
    490503        return d;
    491504      }
     505#ifdef HAVE_FANS
     506    case FAN_CMD:
     507      {
     508        Fan* fff = (Fan*)d;
     509        Fan* ggg = new Fan(*fff);
     510        return ggg;
     511      }
     512    case CONE_CMD:
     513      {
     514        Cone* ccc = (Cone*)d;
     515        Cone* ggg = new Cone(*ccc);
     516        return ggg;
     517      }
     518#endif /* HAVE_FANS */
    492519    case RESOLUTION_CMD:
    493520      return (void*)syCopy((syStrategy)d);
    … …  
    776803          }
    777804          return s;
    778 
     805#ifdef HAVE_FANS
     806        case FAN_CMD:
     807        {
     808          Fan* fff = (Fan*)d;
     809          s = fff->toString();
     810          char* ns = (char*) omAlloc(strlen(s) + 10);
     811          sprintf(ns, "%s", s);
     812          omCheckAddr(ns);
     813          omFree(s);
     814          return ns;
     815        }
     816        case CONE_CMD:
     817        {
     818          Cone* ccc = (Cone*)d;
     819          s = ccc->toString();
     820          char* ns = (char*) omAlloc(strlen(s) + 10);
     821          sprintf(ns, "%s", s);
     822          omCheckAddr(ns);
     823          omFree(s);
     824          return ns;
     825        }
     826#endif /* HAVE_FANS */
    779827        case RESOLUTION_CMD:
    780828        {

  • Singular/tok.h

    r8e7db4 r4f80bb  
    4343  ALIAS_CMD     = UMINUS + 15,
    4444  ATTRIB_CMD,
     45#ifdef HAVE_FANS
     46  ADDADJ_CMD,
     47  ADDMCONE_CMD,
     48  ADJACENCY_CMD,
     49#endif /* HAVE_FANS */
    4550  BAREISS_CMD,
    4651  BIGINT_CMD,
    … …  
    5257  CLOSE_CMD,
    5358  COLS_CMD,
     59#ifdef HAVE_FANS
     60  CONE_CMD,
     61#endif /* HAVE_FANS */
    5462  CONTENT_CMD,
    5563  COUNT_CMD,
    … …  
    5866  DEFINED_CMD,
    5967  DELETE_CMD,
     68#ifdef HAVE_FANS
     69  DELMCONE_CMD,
     70#endif /* HAVE_FANS */
    6071  DET_CMD,
    6172  DUMP_CMD,
    … …  
    6778  EXTGCD_CMD,
    6879  FAC_CMD,
     80#ifdef HAVE_FANS
     81  FACETNS_CMD,
     82  FAN_CMD,
     83#endif /* HAVE_FANS */
    6984  FIND_CMD,
    7085  FACSTD_CMD,
    … …  
    7590  GCD_CMD,
    7691  GETDUMP_CMD,
     92#ifdef HAVE_FANS
     93  GETPROP_CMD,
     94#endif /* HAVE_FANS */
    7795  HIGHCORNER_CMD,
    7896  HRES_CMD,
    … …  
    92110  LAGSOLVE_CMD,
    93111  LINK_CMD,
     112#ifdef HAVE_FANS
     113  LINSPACE_CMD,
     114#endif /* HAVE_FANS */
    94115  LIST_CMD,
    95116  LOAD_CMD,
    … …  
    98119  LUI_CMD,
    99120  LUS_CMD,
     121#ifdef HAVE_FANS
     122  MAXCONE_CMD,
     123  MAXRAYS_CMD,
     124#endif /* HAVE_FANS */
    100125  MEMORY_CMD,
    101126  MONITOR_CMD,
    … …  
    129154  RINGLIST_CMD,
    130155  ROWS_CMD,
     156#ifdef HAVE_FANS
     157  SETPROP_CMD,
     158#endif /* HAVE_FANS */
    131159  SIMPLEX_CMD,
    132160  SLIM_GB_CMD,
Note: See TracChangeset for help on using the changeset viewer.