Functions | Variables
polymake_wrapper.cc File Reference
#include <kernel/mod2.h>
#include <Singular/dyn_modules/gfanlib/bbcone.h>
#include <Singular/dyn_modules/gfanlib/bbfan.h>
#include <Singular/dyn_modules/gfanlib/bbpolytope.h>
#include <Singular/blackbox.h>
#include <Singular/ipshell.h>
#include <Singular/subexpr.h>
#include <Singular/mod_lib.h>
#include <polymake_conversion.h>
#include <polymake_documentation.h>
#include <polymake/Graph.h>
#include <omp.h>

Go to the source code of this file.

Functions

static BOOLEAN bbpolytope_Op2 (int op, leftv res, leftv i1, leftv i2)
 
BOOLEAN PMisLatticePolytope (leftv res, leftv args)
 
BOOLEAN PMisBounded (leftv res, leftv args)
 
BOOLEAN PMisReflexive (leftv res, leftv args)
 
BOOLEAN PMisGorenstein (leftv res, leftv args)
 
BOOLEAN PMgorensteinIndex (leftv res, leftv args)
 
BOOLEAN PMgorensteinVector (leftv res, leftv args)
 
BOOLEAN PMisCanonical (leftv res, leftv args)
 
BOOLEAN PMisTerminal (leftv res, leftv args)
 
BOOLEAN PMisLatticeEmpty (leftv res, leftv args)
 
BOOLEAN PMlatticeVolume (leftv res, leftv args)
 
BOOLEAN PMlatticeDegree (leftv res, leftv args)
 
BOOLEAN PMlatticeCodegree (leftv res, leftv args)
 
BOOLEAN PMehrhartPolynomialCoeff (leftv res, leftv args)
 
BOOLEAN PMfVector (leftv res, leftv args)
 
BOOLEAN PMhVector (leftv res, leftv args)
 
BOOLEAN PMhStarVector (leftv res, leftv args)
 
BOOLEAN PMisNormal (leftv res, leftv args)
 
BOOLEAN PMfacetWidths (leftv res, leftv args)
 
BOOLEAN PMfacetWidth (leftv res, leftv args)
 
BOOLEAN PMfacetVertexLatticeDistances (leftv res, leftv args)
 
BOOLEAN PMisCompressed (leftv res, leftv args)
 
BOOLEAN PMisSmooth (leftv res, leftv args)
 
BOOLEAN PMisVeryAmple (leftv res, leftv args)
 
BOOLEAN PMlatticePoints (leftv res, leftv args)
 
BOOLEAN PMnLatticePoints (leftv res, leftv args)
 
BOOLEAN PMinteriorLatticePoints (leftv res, leftv args)
 
BOOLEAN PMnInteriorLatticePoints (leftv res, leftv args)
 
BOOLEAN PMboundaryLatticePoints (leftv res, leftv args)
 
BOOLEAN PMnBoundaryLatticePoints (leftv res, leftv args)
 
BOOLEAN PMhilbertBasis (leftv res, leftv args)
 
BOOLEAN PMnHilbertBasis (leftv res, leftv args)
 
BOOLEAN PMminkowskiSum (leftv res, leftv args)
 
polymake::Matrix< polymake::Integer > verticesOf (const polymake::perl::Object *p, const polymake::Set< polymake::Integer > *s)
 
BOOLEAN PMmaximalFace (leftv res, leftv args)
 
BOOLEAN PMminimalFace (leftv res, leftv args)
 
BOOLEAN PMmaximalValue (leftv res, leftv args)
 
BOOLEAN PMminimalValue (leftv res, leftv args)
 
BOOLEAN visual (leftv res, leftv args)
 
BOOLEAN normalFan (leftv res, leftv args)
 
BOOLEAN PMconeViaRays (leftv res, leftv args)
 
BOOLEAN PMpolytopeViaVertices (leftv res, leftv args)
 
BOOLEAN PMvertexAdjacencyGraph (leftv res, leftv args)
 
BOOLEAN PMvertexEdgeGraph (leftv res, leftv args)
 
int SI_MOD_INIT() polymake (SModulFunctions *p)
 

Variables

polymake::Main * init_polymake =NULL
 

Function Documentation

static BOOLEAN bbpolytope_Op2 ( int  op,
leftv  res,
leftv  i1,
leftv  i2 
)
static

Definition at line 20 of file polymake_wrapper.cc.

21 {
22  gfan::ZCone* zp = (gfan::ZCone*) i1->Data();
23  switch(op)
24  {
25  case '+':
26  {
27  if (i2->Typ()==polytopeID || i2->Typ()==coneID)
28  {
29  gfan::ZCone* zq = (gfan::ZCone*) i2->Data();
30  gfan::ZCone* ms;
31  try
32  {
33  polymake::perl::Object* pp = ZPolytope2PmPolytope(zp);
34  polymake::perl::Object* pq = ZPolytope2PmPolytope(zq);
35  polymake::perl::Object pms;
36  CallPolymakeFunction("minkowski_sum", *pp, *pq) >> pms;
37  ms = PmPolytope2ZPolytope(&pms);
38  delete pp;
39  delete pq;
40  }
41  catch (const std::exception& ex)
42  {
43  WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
44  return TRUE;
45  }
46  res->rtyp = polytopeID;
47  res->data = (void*) ms;
48  return FALSE;
49  }
50  return blackboxDefaultOp2(op,res,i1,i2);
51  }
52  case '*':
53  {
54  if (i2->Typ()==INT_CMD)
55  {
56  int s = (int)(long) i2->Data();
57  gfan::ZMatrix zm = zp->extremeRays();
58  for (int i=0; i<zm.getHeight(); i++)
59  for (int j=1; j<zm.getWidth(); j++)
60  zm[i][j] *= s;
61  gfan::ZCone* zs = new gfan::ZCone();
62  *zs = gfan::ZCone::givenByRays(zm,gfan::ZMatrix(0, zm.getWidth()));
63  res->rtyp = polytopeID;
64  res->data = (void*) zs;
65  return FALSE;
66  }
67  return blackboxDefaultOp2(op,res,i1,i2);
68  }
69  case '&':
70  {
71  if (i2->Typ()==polytopeID)
72  {
73  gfan::ZCone* zq = (gfan::ZCone*) i2->Data();
74  int d1 = zp->ambientDimension();
75  int d2 = zq->ambientDimension();
76  if (d1 != d2)
77  {
78  Werror("mismatching ambient dimensions");
79  return TRUE;
80  }
81  gfan::ZCone* zs = new gfan::ZCone();
82  *zs = gfan::intersection(*zp, *zq);
83  zs->canonicalize();
84  res->rtyp = polytopeID;
85  res->data = (void*) zs;
86  return FALSE;
87  }
88  return blackboxDefaultOp2(op,res,i1,i2);
89  }
90  case '|':
91  {
92  if(i2->Typ()==polytopeID)
93  {
94  gfan::ZCone* zq = (gfan::ZCone*) i2->Data();
95  int d1 = zp->ambientDimension();
96  int d2 = zq->ambientDimension();
97  if (d1 != d2)
98  {
99  Werror("mismatching ambient dimensions");
100  return TRUE;
101  }
102  gfan::ZMatrix rays = zp->extremeRays();
103  rays.append(zq->extremeRays());
104  gfan::ZMatrix lineality = zp->generatorsOfLinealitySpace();
105  lineality.append(zq->generatorsOfLinealitySpace());
106  gfan::ZCone* zs = new gfan::ZCone();
107  *zs = gfan::ZCone::givenByRays(rays,lineality);
108  zs->canonicalize();
109  res->rtyp = polytopeID;
110  res->data = (void*) zs;
111  return FALSE;
112  }
113  return blackboxDefaultOp2(op,res,i1,i2);
114  }
115  case EQUAL_EQUAL:
116  {
117  if(i2->Typ()==polytopeID)
118  {
119  gfan::ZCone* zq = (gfan::ZCone*) i2->Data();
120  zp->canonicalize();
121  zq->canonicalize();
122  bool b = !((*zp)!=(*zq));
123  res->rtyp = INT_CMD;
124  res->data = (char*) (long) b;
125  return FALSE;
126  }
127  return blackboxDefaultOp2(op,res,i1,i2);
128  }
129  default:
130  return blackboxDefaultOp2(op,res,i1,i2);
131  }
132  return blackboxDefaultOp2(op,res,i1,i2);
133 }
const CanonicalForm int s
Definition: facAbsFact.cc:55
Definition: tok.h:85
#define FALSE
Definition: auxiliary.h:140
polymake::perl::Object * ZPolytope2PmPolytope(gfan::ZCone *zc)
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
int Typ()
Definition: subexpr.cc:955
poly pp
Definition: myNF.cc:296
void * data
Definition: subexpr.h:89
int polytopeID
Definition: bbpolytope.cc:17
int j
Definition: myNF.cc:70
BOOLEAN blackboxDefaultOp2(int op, leftv, leftv r1, leftv)
default procedure blackboxDefaultOp2, to be called as "default:" branch
Definition: blackbox.cc:85
int coneID
Definition: bbcone.cc:24
int i
Definition: cfEzgcd.cc:123
gfan::ZCone * PmPolytope2ZPolytope(polymake::perl::Object *pp)
BOOLEAN rays(leftv res, leftv args)
Definition: bbcone.cc:618
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
const poly b
Definition: syzextra.cc:213
void Werror(const char *fmt,...)
Definition: reporter.cc:199
BOOLEAN normalFan ( leftv  res,
leftv  args 
)

Definition at line 1594 of file polymake_wrapper.cc.

1595 {
1596  leftv u = args;
1597  if ((u != NULL) && (u->Typ() == polytopeID))
1598  {
1599  gfan::ZCone* zp = (gfan::ZCone*)u->Data();
1600  gfan::ZFan* zf = new gfan::ZFan(0);
1601  try
1602  {
1603  polymake::perl::Object* p=ZPolytope2PmPolytope(zp);
1604  polymake::perl::Object pf;
1605  CallPolymakeFunction("normal_fan", *p) >> pf;
1606  delete p;
1607  zf = PmFan2ZFan(&pf);
1608  }
1609  catch (const std::exception& ex)
1610  {
1611  WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
1612  return TRUE;
1613  }
1614  res->rtyp = fanID;
1615  res->data = (char*) zf;
1616  return FALSE;
1617  }
1618  WerrorS("normalFan: unexpected parameters");
1619  return TRUE;
1620 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
polymake::perl::Object * ZPolytope2PmPolytope(gfan::ZCone *zc)
#define TRUE
Definition: auxiliary.h:144
gfan::ZFan * PmFan2ZFan(polymake::perl::Object *pf)
void WerrorS(const char *s)
Definition: feFopen.cc:23
int fanID
Definition: bbfan.cc:18
int Typ()
Definition: subexpr.cc:955
void * data
Definition: subexpr.h:89
int polytopeID
Definition: bbpolytope.cc:17
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
BOOLEAN PMboundaryLatticePoints ( leftv  res,
leftv  args 
)

Definition at line 1099 of file polymake_wrapper.cc.

1100 {
1101  leftv u = args;
1102  if ((u != NULL) && (u->Typ() == polytopeID))
1103  {
1104  gfan::ZCone* zp = (gfan::ZCone*)u->Data();
1105  intvec* iv;
1106  bool ok = true;
1107  try
1108  {
1109  polymake::perl::Object* p = ZPolytope2PmPolytope(zp);
1110  polymake::Matrix<polymake::Integer> lp = p->give("BOUNDARY_LATTICE_POINTS");
1111  delete p;
1112  iv = PmMatrixInteger2Intvec(&lp,ok);
1113  }
1114  catch (const std::exception& ex)
1115  {
1116  WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
1117  return TRUE;
1118  }
1119  if (!ok)
1120  {
1121  WerrorS("overflow while converting polymake::Integer to int");
1122  return TRUE;
1123  }
1124  res->rtyp = INTMAT_CMD;
1125  res->data = (char*) iv;
1126  return FALSE;
1127  }
1128  WerrorS("boundaryLatticePoints: unexpected parameters");
1129  return TRUE;
1130 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
polymake::perl::Object * ZPolytope2PmPolytope(gfan::ZCone *zc)
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
int Typ()
Definition: subexpr.cc:955
void * data
Definition: subexpr.h:89
int polytopeID
Definition: bbpolytope.cc:17
Definition: intvec.h:16
intvec * PmMatrixInteger2Intvec(polymake::Matrix< polymake::Integer > *mi, bool &ok)
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
BOOLEAN PMconeViaRays ( leftv  res,
leftv  args 
)

Definition at line 1622 of file polymake_wrapper.cc.

1623 {
1624  leftv u = args;
1625  if ((u != NULL) && (u->Typ() == INTMAT_CMD))
1626  {
1627  polymake::perl::Object pc("Cone<Rational>");
1628  intvec* hlines = (intvec*) u->Data(); // these will are half lines in the cone
1629  polymake::Matrix<polymake::Integer> pmhlines = Intvec2PmMatrixInteger(hlines);
1630  pc.take("INPUT_RAYS") << pmhlines;
1631 
1632  leftv v = u->next;
1633  if ((v != NULL) && (v->Typ() == INTMAT_CMD))
1634  {
1635  intvec* lines = (intvec*) v->Data(); // these will be lines in the cone
1636  polymake::Matrix<polymake::Integer> pmlines = Intvec2PmMatrixInteger(lines);
1637  pc.take("INPUT_LINEALITY") << pmlines;
1638 
1639  // leftv w = v->next;
1640  // if ((w != NULL) && (w->Typ() == INT_CMD))
1641  // {
1642  // int flag = (int) (long) w->Data(); // TODO: this will indicate whether the
1643  // // information provided are exact
1644  // }
1645  }
1646  gfan::ZCone* zc = PmCone2ZCone(&pc);
1647  res->rtyp = coneID;
1648  res->data = (char*) zc;
1649  return FALSE;
1650  }
1651  WerrorS("coneViaRays: unexpected parameters");
1652  return TRUE;
1653 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
#define FALSE
Definition: auxiliary.h:140
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
polymake::Matrix< polymake::Integer > Intvec2PmMatrixInteger(const intvec *im)
int Typ()
Definition: subexpr.cc:955
void * data
Definition: subexpr.h:89
Definition: intvec.h:16
gfan::ZCone * PmCone2ZCone(polymake::perl::Object *pc)
int coneID
Definition: bbcone.cc:24
int lines
Definition: checklibs.c:11
leftv next
Definition: subexpr.h:87
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
BOOLEAN PMehrhartPolynomialCoeff ( leftv  res,
leftv  args 
)

Definition at line 579 of file polymake_wrapper.cc.

580 {
581  leftv u = args;
582  if ((u != NULL) && (u->Typ() == polytopeID))
583  {
584  gfan::ZCone* zp = (gfan::ZCone*)u->Data();
585  intvec* ec;
586  bool ok = true;
587  try
588  {
589  polymake::perl::Object* p = ZPolytope2PmPolytope(zp);
590  polymake::Vector<polymake::Integer> pec = p->give("EHRHART_POLYNOMIAL_COEFF");
591  delete p;
592  ec = PmVectorInteger2Intvec(&pec,ok);
593  }
594  catch (const std::exception& ex)
595  {
596  WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
597  return TRUE;
598  }
599  if (!ok)
600  {
601  WerrorS("ehrhartPolynomialCoeff: overflow in PmVectorInteger2Intvec");
602  return TRUE;
603  }
604  res->rtyp = INTVEC_CMD;
605  res->data = (char*) ec;
606  return FALSE;
607  }
608  WerrorS("ehrhartPolynomialCoeff: unexpected parameters");
609  return TRUE;
610 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
polymake::perl::Object * ZPolytope2PmPolytope(gfan::ZCone *zc)
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
int Typ()
Definition: subexpr.cc:955
void * data
Definition: subexpr.h:89
int polytopeID
Definition: bbpolytope.cc:17
Definition: intvec.h:16
intvec * PmVectorInteger2Intvec(const polymake::Vector< polymake::Integer > *vi, bool &ok)
Definition: tok.h:88
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
BOOLEAN PMfacetVertexLatticeDistances ( leftv  res,
leftv  args 
)

Definition at line 810 of file polymake_wrapper.cc.

811 {
812  leftv u = args;
813  if ((u != NULL) && (u->Typ() == polytopeID))
814  {
815  gfan::ZCone* zp = (gfan::ZCone*)u->Data();
816  intvec* ld;
817  bool ok=true;
818  try
819  {
820  polymake::perl::Object* p = ZPolytope2PmPolytope(zp);
821  polymake::Matrix<polymake::Integer> pld = p->give("FACET_VERTEX_LATTICE_DISTANCES");
822  delete p;
823  ld = PmMatrixInteger2Intvec(&pld,ok);
824  }
825  catch (const std::exception& ex)
826  {
827  WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
828  return TRUE;
829  }
830  if (!ok)
831  {
832  WerrorS("overflow while converting polymake::Integer to int");
833  return TRUE;
834  }
835  res->rtyp = INTMAT_CMD;
836  res->data = (char*) ld;
837  return FALSE;
838  }
839  WerrorS("facetVertexLatticeDistances: unexpected parameters");
840  return TRUE;
841 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
polymake::perl::Object * ZPolytope2PmPolytope(gfan::ZCone *zc)
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
int Typ()
Definition: subexpr.cc:955
void * data
Definition: subexpr.h:89
int polytopeID
Definition: bbpolytope.cc:17
Definition: intvec.h:16
intvec * PmMatrixInteger2Intvec(polymake::Matrix< polymake::Integer > *mi, bool &ok)
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
BOOLEAN PMfacetWidth ( leftv  res,
leftv  args 
)

Definition at line 776 of file polymake_wrapper.cc.

777 {
778  leftv u = args;
779  if ((u != NULL) && (u->Typ() == polytopeID))
780  {
781  gfan::ZCone* zp = (gfan::ZCone*)u->Data();
782  int fw;
783  bool ok = true;
784  try
785  {
786  polymake::perl::Object* p = ZPolytope2PmPolytope(zp);
787  polymake::Integer pfw = p->give("FACET_WIDTH");
788  delete p;
789  fw = PmInteger2Int(pfw,ok);
790  }
791  catch (const std::exception& ex)
792  {
793  WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
794  return TRUE;
795  }
796  if (!ok)
797  {
798  WerrorS("overflow while converting polymake::Integer to int");
799  return TRUE;
800  }
801  res->rtyp = INT_CMD;
802  res->data = (char*) (long) fw;
803  return FALSE;
804  }
805  WerrorS("facetWidth: unexpected parameters");
806  return TRUE;
807 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: tok.h:85
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
polymake::perl::Object * ZPolytope2PmPolytope(gfan::ZCone *zc)
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
int Typ()
Definition: subexpr.cc:955
void * data
Definition: subexpr.h:89
int polytopeID
Definition: bbpolytope.cc:17
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
int PmInteger2Int(const polymake::Integer &pi, bool &ok)
BOOLEAN PMfacetWidths ( leftv  res,
leftv  args 
)

Definition at line 742 of file polymake_wrapper.cc.

743 {
744  leftv u = args;
745  if ((u != NULL) && (u->Typ() == polytopeID))
746  {
747  gfan::ZCone* zp = (gfan::ZCone*)u->Data();
748  intvec* fw;
749  bool ok = true;
750  try
751  {
752  polymake::perl::Object* p = ZPolytope2PmPolytope(zp);
753  polymake::Vector<polymake::Integer> pfw = p->give("FACET_WIDTHS");
754  delete p;
755  fw = PmVectorInteger2Intvec(&pfw,ok);
756  }
757  catch (const std::exception& ex)
758  {
759  WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
760  return TRUE;
761  }
762  if (!ok)
763  {
764  WerrorS("facetWidths: overflow in PmVectorInteger2Intvec");
765  return TRUE;
766  }
767  res->rtyp = INTVEC_CMD;
768  res->data = (char*) fw;
769  return FALSE;
770  }
771  WerrorS("facetWidths: unexpected parameters");
772  return TRUE;
773 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
polymake::perl::Object * ZPolytope2PmPolytope(gfan::ZCone *zc)
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
int Typ()
Definition: subexpr.cc:955
void * data
Definition: subexpr.h:89
int polytopeID
Definition: bbpolytope.cc:17
Definition: intvec.h:16
intvec * PmVectorInteger2Intvec(const polymake::Vector< polymake::Integer > *vi, bool &ok)
Definition: tok.h:88
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
BOOLEAN PMfVector ( leftv  res,
leftv  args 
)

Definition at line 613 of file polymake_wrapper.cc.

614 {
615  leftv u = args;
616  if ((u != NULL) && (u->Typ() == polytopeID))
617  {
618  gfan::ZCone* zp = (gfan::ZCone*)u->Data();
619  intvec* hv;
620  bool ok = true;
621  try
622  {
623  polymake::perl::Object* p = ZPolytope2PmPolytope(zp);
624  polymake::Vector<polymake::Integer> phv = p->give("F_VECTOR");
625  delete p;
626  hv = PmVectorInteger2Intvec(&phv,ok);
627  }
628  catch (const std::exception& ex)
629  {
630  WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
631  return TRUE;
632  }
633  if (!ok)
634  {
635  WerrorS("fVectorP: overflow in PmVectorInteger2Intvec");
636  return TRUE;
637  }
638  res->rtyp = INTVEC_CMD;
639  res->data = (char*) hv;
640  return FALSE;
641  }
642  WerrorS("fVectorP: unexpected parameters");
643  return TRUE;
644 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
polymake::perl::Object * ZPolytope2PmPolytope(gfan::ZCone *zc)
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
int Typ()
Definition: subexpr.cc:955
void * data
Definition: subexpr.h:89
int polytopeID
Definition: bbpolytope.cc:17
Definition: intvec.h:16
intvec * PmVectorInteger2Intvec(const polymake::Vector< polymake::Integer > *vi, bool &ok)
Definition: tok.h:88
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
BOOLEAN PMgorensteinIndex ( leftv  res,
leftv  args 
)

Definition at line 308 of file polymake_wrapper.cc.

309 {
310  leftv u = args;
311  if ((u != NULL) && (u->Typ() == polytopeID))
312  {
313  gfan::ZCone* zp = (gfan::ZCone*)u->Data();
314  int gi;
315  bool ok = true;
316  try
317  {
318  polymake::perl::Object* p = ZPolytope2PmPolytope(zp);
319  bool b = p->give("GORENSTEIN");
320  if (b)
321  {
322  polymake::Integer pgi = p->give("GORENSTEIN_INDEX");
323  gi = PmInteger2Int(pgi,ok);
324  delete p;
325  }
326  else
327  {
328  delete p;
329  WerrorS("gorensteinIndex: input polytope not gorenstein");
330  return TRUE;
331  }
332  }
333  catch (const std::exception& ex)
334  {
335  WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
336  return TRUE;
337  }
338  if (!ok)
339  {
340  WerrorS("overflow while converting polymake::Integer to int");
341  return TRUE;
342  }
343  res->rtyp = INT_CMD;
344  res->data = (char*) (long) gi;
345  return FALSE;
346  }
347  WerrorS("gorensteinIndex: unexpected parameters");
348  return TRUE;
349 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: tok.h:85
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
polymake::perl::Object * ZPolytope2PmPolytope(gfan::ZCone *zc)
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
int Typ()
Definition: subexpr.cc:955
void * data
Definition: subexpr.h:89
int polytopeID
Definition: bbpolytope.cc:17
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
int PmInteger2Int(const polymake::Integer &pi, bool &ok)
const poly b
Definition: syzextra.cc:213
BOOLEAN PMgorensteinVector ( leftv  res,
leftv  args 
)

Definition at line 352 of file polymake_wrapper.cc.

353 {
354  leftv u = args;
355  if ((u != NULL) && (u->Typ() == polytopeID))
356  {
357  gfan::ZCone* zp = (gfan::ZCone*)u->Data();
358  intvec* gv;
359  bool ok = true;
360  try
361  {
362  polymake::perl::Object* p = ZPolytope2PmPolytope(zp);
363  bool b = p->give("GORENSTEIN");
364  if (b)
365  {
366  polymake::Vector<polymake::Integer> pgv = p->give("GORENSTEIN_VECTOR");
367  gv = PmVectorInteger2Intvec(&pgv,ok);
368  delete p;
369  }
370  else
371  {
372  delete p;
373  WerrorS("gorensteinVector: input polytope not gorenstein");
374  return TRUE;
375  }
376  }
377  catch (const std::exception& ex)
378  {
379  WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
380  return TRUE;
381  }
382  if (!ok)
383  {
384  WerrorS("gorensteinVector: overflow in PmVectorInteger2Intvec");
385  return TRUE;
386  }
387  res->rtyp = INTVEC_CMD;
388  res->data = (char*) gv;
389  return FALSE;
390  }
391  WerrorS("gorensteinVector: unexpected parameters");
392  return TRUE;
393 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
polymake::perl::Object * ZPolytope2PmPolytope(gfan::ZCone *zc)
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
int Typ()
Definition: subexpr.cc:955
void * data
Definition: subexpr.h:89
int polytopeID
Definition: bbpolytope.cc:17
Definition: intvec.h:16
intvec * PmVectorInteger2Intvec(const polymake::Vector< polymake::Integer > *vi, bool &ok)
Definition: tok.h:88
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
const poly b
Definition: syzextra.cc:213
BOOLEAN PMhilbertBasis ( leftv  res,
leftv  args 
)

Definition at line 1167 of file polymake_wrapper.cc.

1168 {
1169  leftv u = args;
1170  if ((u != NULL) && (u->Typ() == coneID))
1171  {
1172  gfan::ZCone* zp = (gfan::ZCone*)u->Data();
1173  intvec* iv;
1174  bool ok = true;
1175  try
1176  {
1177  polymake::perl::Object* p = ZPolytope2PmPolytope(zp);
1178  polymake::Matrix<polymake::Integer> lp = p->give("HILBERT_BASIS");
1179  delete p;
1180  iv = PmMatrixInteger2Intvec(&lp,ok);
1181  }
1182  catch (const std::exception& ex)
1183  {
1184  WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
1185  return TRUE;
1186  }
1187  if (!ok)
1188  {
1189  WerrorS("overflow while converting polymake::Integer to int");
1190  return TRUE;
1191  }
1192  res->rtyp = INTMAT_CMD;
1193  res->data = (char*) iv;
1194  return FALSE;
1195  }
1196  WerrorS("hilbertBasis: unexpected parameters");
1197  return TRUE;
1198 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
polymake::perl::Object * ZPolytope2PmPolytope(gfan::ZCone *zc)
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
int Typ()
Definition: subexpr.cc:955
void * data
Definition: subexpr.h:89
Definition: intvec.h:16
intvec * PmMatrixInteger2Intvec(polymake::Matrix< polymake::Integer > *mi, bool &ok)
int coneID
Definition: bbcone.cc:24
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
BOOLEAN PMhStarVector ( leftv  res,
leftv  args 
)

Definition at line 681 of file polymake_wrapper.cc.

682 {
683  leftv u = args;
684  if ((u != NULL) && (u->Typ() == polytopeID))
685  {
686  gfan::ZCone* zp = (gfan::ZCone*)u->Data();
687  intvec* hv;
688  bool ok = true;
689  try
690  {
691  polymake::perl::Object* p = ZPolytope2PmPolytope(zp);
692  polymake::Vector<polymake::Integer> phv = p->give("H_STAR_VECTOR");
693  delete p;
694  hv = PmVectorInteger2Intvec(&phv,ok);
695  }
696  catch (const std::exception& ex)
697  {
698  WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
699  return TRUE;
700  }
701  if (!ok)
702  {
703  WerrorS("hStarVector: overflow in PmVectorInteger2Intvec");
704  return TRUE;
705  }
706  res->rtyp = INTVEC_CMD;
707  res->data = (char*) hv;
708  return FALSE;
709  }
710  WerrorS("hStarVector: unexpected parameters");
711  return TRUE;
712 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
polymake::perl::Object * ZPolytope2PmPolytope(gfan::ZCone *zc)
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
int Typ()
Definition: subexpr.cc:955
void * data
Definition: subexpr.h:89
int polytopeID
Definition: bbpolytope.cc:17
Definition: intvec.h:16
intvec * PmVectorInteger2Intvec(const polymake::Vector< polymake::Integer > *vi, bool &ok)
Definition: tok.h:88
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
BOOLEAN PMhVector ( leftv  res,
leftv  args 
)

Definition at line 647 of file polymake_wrapper.cc.

648 {
649  leftv u = args;
650  if ((u != NULL) && (u->Typ() == polytopeID))
651  {
652  gfan::ZCone* zp = (gfan::ZCone*)u->Data();
653  intvec* hv;
654  bool ok = true;
655  try
656  {
657  polymake::perl::Object* p = ZPolytope2PmPolytope(zp);
658  polymake::Vector<polymake::Integer> phv = p->give("H_VECTOR");
659  delete p;
660  hv = PmVectorInteger2Intvec(&phv,ok);
661  }
662  catch (const std::exception& ex)
663  {
664  WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
665  return TRUE;
666  }
667  if (!ok)
668  {
669  WerrorS("hVector: overflow in PmVectorInteger2Intvec");
670  return TRUE;
671  }
672  res->rtyp = INTVEC_CMD;
673  res->data = (char*) hv;
674  return FALSE;
675  }
676  WerrorS("hVector: unexpected parameters");
677  return TRUE;
678 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
polymake::perl::Object * ZPolytope2PmPolytope(gfan::ZCone *zc)
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
int Typ()
Definition: subexpr.cc:955
void * data
Definition: subexpr.h:89
int polytopeID
Definition: bbpolytope.cc:17
Definition: intvec.h:16
intvec * PmVectorInteger2Intvec(const polymake::Vector< polymake::Integer > *vi, bool &ok)
Definition: tok.h:88
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
BOOLEAN PMinteriorLatticePoints ( leftv  res,
leftv  args 
)

Definition at line 1031 of file polymake_wrapper.cc.

1032 {
1033  leftv u = args;
1034  if ((u != NULL) && (u->Typ() == polytopeID))
1035  {
1036  gfan::ZCone* zp = (gfan::ZCone*)u->Data();
1037  intvec* iv;
1038  bool ok = true;
1039  try
1040  {
1041  polymake::perl::Object* p = ZPolytope2PmPolytope(zp);
1042  polymake::Matrix<polymake::Integer> lp = p->give("INTERIOR_LATTICE_POINTS");
1043  delete p;
1044  iv = PmMatrixInteger2Intvec(&lp,ok);
1045  }
1046  catch (const std::exception& ex)
1047  {
1048  WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
1049  return TRUE;
1050  }
1051  if (!ok)
1052  {
1053  WerrorS("overflow while converting polymake::Integer to int");
1054  return TRUE;
1055  }
1056  res->rtyp = INTMAT_CMD;
1057  res->data = (char*) iv;
1058  return FALSE;
1059  }
1060  WerrorS("interiorLatticePoints: unexpected parameters");
1061  return TRUE;
1062 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
polymake::perl::Object * ZPolytope2PmPolytope(gfan::ZCone *zc)
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
int Typ()
Definition: subexpr.cc:955
void * data
Definition: subexpr.h:89
int polytopeID
Definition: bbpolytope.cc:17
Definition: intvec.h:16
intvec * PmMatrixInteger2Intvec(polymake::Matrix< polymake::Integer > *mi, bool &ok)
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
BOOLEAN PMisBounded ( leftv  res,
leftv  args 
)

Definition at line 227 of file polymake_wrapper.cc.

228 {
229  leftv u = args;
230  if ((u != NULL) && (u->Typ() == polytopeID))
231  {
232  gfan::ZCone* zp = (gfan::ZCone*)u->Data();
233  bool b;
234  try
235  {
236  polymake::perl::Object* p = ZPolytope2PmPolytope(zp);
237  b = p->give("BOUNDED");
238  delete p;
239  }
240  catch (const std::exception& ex)
241  {
242  WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
243  return TRUE;
244  }
245  res->rtyp = INT_CMD;
246  res->data = (char*) (long) b;
247  return FALSE;
248  }
249  WerrorS("isBounded: unexpected parameters");
250  return TRUE;
251 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: tok.h:85
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
polymake::perl::Object * ZPolytope2PmPolytope(gfan::ZCone *zc)
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
int Typ()
Definition: subexpr.cc:955
void * data
Definition: subexpr.h:89
int polytopeID
Definition: bbpolytope.cc:17
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
const poly b
Definition: syzextra.cc:213
BOOLEAN PMisCanonical ( leftv  res,
leftv  args 
)

Definition at line 396 of file polymake_wrapper.cc.

397 {
398  leftv u = args;
399  if ((u != NULL) && (u->Typ() == polytopeID))
400  {
401  gfan::ZCone* zp = (gfan::ZCone*)u->Data();
402  bool b;
403  try
404  {
405  polymake::perl::Object* p = ZPolytope2PmPolytope(zp);
406  b = p->give("CANONICAL");
407  delete p;
408  }
409  catch (const std::exception& ex)
410  {
411  WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
412  return TRUE;
413  }
414  res->rtyp = INT_CMD;
415  res->data = (char*) (long) b;
416  return FALSE;
417  }
418  WerrorS("isCanonical: unexpected parameters");
419  return TRUE;
420 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: tok.h:85
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
polymake::perl::Object * ZPolytope2PmPolytope(gfan::ZCone *zc)
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
int Typ()
Definition: subexpr.cc:955
void * data
Definition: subexpr.h:89
int polytopeID
Definition: bbpolytope.cc:17
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
const poly b
Definition: syzextra.cc:213
BOOLEAN PMisCompressed ( leftv  res,
leftv  args 
)

Definition at line 844 of file polymake_wrapper.cc.

845 {
846  leftv u = args;
847  if ((u != NULL) && (u->Typ() == polytopeID))
848  {
849  gfan::ZCone* zp = (gfan::ZCone*)u->Data();
850  bool b;
851  try
852  {
853  polymake::perl::Object* p = ZPolytope2PmPolytope(zp);
854  b = p->give("COMPRESSED");
855  delete p;
856  }
857  catch (const std::exception& ex)
858  {
859  WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
860  return TRUE;
861  }
862  res->rtyp = INT_CMD;
863  res->data = (char*) (long) b;
864  return FALSE;
865  }
866  WerrorS("isCompressed: unexpected parameters");
867  return TRUE;
868 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: tok.h:85
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
polymake::perl::Object * ZPolytope2PmPolytope(gfan::ZCone *zc)
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
int Typ()
Definition: subexpr.cc:955
void * data
Definition: subexpr.h:89
int polytopeID
Definition: bbpolytope.cc:17
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
const poly b
Definition: syzextra.cc:213
BOOLEAN PMisGorenstein ( leftv  res,
leftv  args 
)

Definition at line 281 of file polymake_wrapper.cc.

282 {
283  leftv u = args;
284  if ((u != NULL) && (u->Typ() == polytopeID))
285  {
286  gfan::ZCone* zp = (gfan::ZCone*)u->Data();
287  bool b;
288  try
289  {
290  polymake::perl::Object* p = ZPolytope2PmPolytope(zp);
291  b = p->give("GORENSTEIN");
292  delete p;
293  }
294  catch (const std::exception& ex)
295  {
296  WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
297  return TRUE;
298  }
299  res->rtyp = INT_CMD;
300  res->data = (char*) (long) b;
301  return FALSE;
302  }
303  WerrorS("isGorenstein: unexpected parameters");
304  return TRUE;
305 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: tok.h:85
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
polymake::perl::Object * ZPolytope2PmPolytope(gfan::ZCone *zc)
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
int Typ()
Definition: subexpr.cc:955
void * data
Definition: subexpr.h:89
int polytopeID
Definition: bbpolytope.cc:17
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
const poly b
Definition: syzextra.cc:213
BOOLEAN PMisLatticeEmpty ( leftv  res,
leftv  args 
)

Definition at line 450 of file polymake_wrapper.cc.

451 {
452  leftv u = args;
453  if ((u != NULL) && (u->Typ() == polytopeID))
454  {
455  gfan::ZCone* zp = (gfan::ZCone*)u->Data();
456  bool b;
457  try
458  {
459  polymake::perl::Object* p = ZPolytope2PmPolytope(zp);
460  b = p->give("LATTICE_EMPTY");
461  delete p;
462  }
463  catch (const std::exception& ex)
464  {
465  WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
466  return TRUE;
467  }
468  res->rtyp = INT_CMD;
469  res->data = (char*) (long) b;
470  return FALSE;
471  }
472  WerrorS("isLatticeEmpty: unexpected parameters");
473  return TRUE;
474 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: tok.h:85
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
polymake::perl::Object * ZPolytope2PmPolytope(gfan::ZCone *zc)
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
int Typ()
Definition: subexpr.cc:955
void * data
Definition: subexpr.h:89
int polytopeID
Definition: bbpolytope.cc:17
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
const poly b
Definition: syzextra.cc:213
BOOLEAN PMisLatticePolytope ( leftv  res,
leftv  args 
)

Definition at line 200 of file polymake_wrapper.cc.

201 {
202  leftv u = args;
203  if ((u != NULL) && (u->Typ() == polytopeID))
204  {
205  gfan::ZCone* zp = (gfan::ZCone*)u->Data();
206  bool b;
207  try
208  {
209  polymake::perl::Object* p = ZPolytope2PmPolytope(zp);
210  b = p->give("Lattice");
211  delete p;
212  }
213  catch (const std::exception& ex)
214  {
215  WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
216  return TRUE;
217  }
218  res->rtyp = INT_CMD;
219  res->data = (char*) (long) b;
220  return FALSE;
221  }
222  WerrorS("isLatticePolytope: unexpected parameters");
223  return TRUE;
224 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: tok.h:85
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
polymake::perl::Object * ZPolytope2PmPolytope(gfan::ZCone *zc)
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
int Typ()
Definition: subexpr.cc:955
void * data
Definition: subexpr.h:89
int polytopeID
Definition: bbpolytope.cc:17
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
const poly b
Definition: syzextra.cc:213
BOOLEAN PMisNormal ( leftv  res,
leftv  args 
)

Definition at line 715 of file polymake_wrapper.cc.

716 {
717  leftv u = args;
718  if ((u != NULL) && (u->Typ() == polytopeID))
719  {
720  gfan::ZCone* zp = (gfan::ZCone*)u->Data();
721  bool b;
722  try
723  {
724  polymake::perl::Object* p = ZPolytope2PmPolytope(zp);
725  b = p->give("NORMAL");
726  delete p;
727  }
728  catch (const std::exception& ex)
729  {
730  WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
731  return TRUE;
732  }
733  res->rtyp = INT_CMD;
734  res->data = (char*) (long) b;
735  return FALSE;
736  }
737  WerrorS("isNormal: unexpected parameters");
738  return TRUE;
739 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: tok.h:85
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
polymake::perl::Object * ZPolytope2PmPolytope(gfan::ZCone *zc)
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
int Typ()
Definition: subexpr.cc:955
void * data
Definition: subexpr.h:89
int polytopeID
Definition: bbpolytope.cc:17
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
const poly b
Definition: syzextra.cc:213
BOOLEAN PMisReflexive ( leftv  res,
leftv  args 
)

Definition at line 254 of file polymake_wrapper.cc.

255 {
256  leftv u = args;
257  if ((u != NULL) && (u->Typ() == polytopeID))
258  {
259  gfan::ZCone* zp = (gfan::ZCone*)u->Data();
260  bool b;
261  try
262  {
263  polymake::perl::Object* p = ZPolytope2PmPolytope(zp);
264  b = p->give("REFLEXIVE");
265  delete p;
266  }
267  catch (const std::exception& ex)
268  {
269  WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
270  return TRUE;
271  }
272  res->rtyp = INT_CMD;
273  res->data = (char*) (long) b;
274  return FALSE;
275  }
276  WerrorS("isReflexive: unexpected parameters");
277  return TRUE;
278 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: tok.h:85
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
polymake::perl::Object * ZPolytope2PmPolytope(gfan::ZCone *zc)
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
int Typ()
Definition: subexpr.cc:955
void * data
Definition: subexpr.h:89
int polytopeID
Definition: bbpolytope.cc:17
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
const poly b
Definition: syzextra.cc:213
BOOLEAN PMisSmooth ( leftv  res,
leftv  args 
)

Definition at line 871 of file polymake_wrapper.cc.

872 {
873  leftv u = args;
874  if ((u != NULL) && (u->Typ() == coneID))
875  {
876  gfan::ZCone* zc = (gfan::ZCone*)u->Data();
877  bool b;
878  try
879  {
880  polymake::perl::Object* p = ZCone2PmCone(zc);
881  b = p->give("SMOOTH_CONE");
882  delete p;
883  }
884  catch (const std::exception& ex)
885  {
886  WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
887  return TRUE;
888  }
889  res->rtyp = INT_CMD;
890  res->data = (char*) (long) b;
891  return FALSE;
892  }
893  if ((u != NULL) && (u->Typ() == polytopeID))
894  {
895  gfan::ZCone* zp = (gfan::ZCone*)u->Data();
896  bool b;
897  try
898  {
899  polymake::perl::Object* p = ZPolytope2PmPolytope(zp);
900  b = p->give("SMOOTH");
901  delete p;
902  }
903  catch (const std::exception& ex)
904  {
905  WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
906  return TRUE;
907  }
908  res->rtyp = INT_CMD;
909  res->data = (char*) (long) b;
910  return FALSE;
911  }
912  if ((u != NULL) && (u->Typ() == fanID))
913  {
914  gfan::ZFan* zf = (gfan::ZFan*)u->Data();
915  bool b;
916  try
917  {
918  polymake::perl::Object* p = ZFan2PmFan(zf);
919  b = p->give("SMOOTH_FAN");
920  delete p;
921  }
922  catch (const std::exception& ex)
923  {
924  WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
925  return TRUE;
926  }
927  res->rtyp = INT_CMD;
928  res->data = (char*) (long) b;
929  return FALSE;
930  }
931  WerrorS("isSmooth: unexpected parameters");
932  return TRUE;
933 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: tok.h:85
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
polymake::perl::Object * ZCone2PmCone(gfan::ZCone *zc)
polymake::perl::Object * ZPolytope2PmPolytope(gfan::ZCone *zc)
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
int fanID
Definition: bbfan.cc:18
int Typ()
Definition: subexpr.cc:955
void * data
Definition: subexpr.h:89
int polytopeID
Definition: bbpolytope.cc:17
int coneID
Definition: bbcone.cc:24
polymake::perl::Object * ZFan2PmFan(gfan::ZFan *zf)
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
const poly b
Definition: syzextra.cc:213
BOOLEAN PMisTerminal ( leftv  res,
leftv  args 
)

Definition at line 423 of file polymake_wrapper.cc.

424 {
425  leftv u = args;
426  if ((u != NULL) && (u->Typ() == polytopeID))
427  {
428  gfan::ZCone* zp = (gfan::ZCone*)u->Data();
429  bool b;
430  try
431  {
432  polymake::perl::Object* p = ZPolytope2PmPolytope(zp);
433  b = p->give("TERMINAL");
434  delete p;
435  }
436  catch (const std::exception& ex)
437  {
438  WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
439  return TRUE;
440  }
441  res->rtyp = INT_CMD;
442  res->data = (char*) (long) b;
443  return FALSE;
444  }
445  WerrorS("isTerminal: unexpected parameters");
446  return TRUE;
447 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: tok.h:85
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
polymake::perl::Object * ZPolytope2PmPolytope(gfan::ZCone *zc)
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
int Typ()
Definition: subexpr.cc:955
void * data
Definition: subexpr.h:89
int polytopeID
Definition: bbpolytope.cc:17
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
const poly b
Definition: syzextra.cc:213
BOOLEAN PMisVeryAmple ( leftv  res,
leftv  args 
)

Definition at line 936 of file polymake_wrapper.cc.

937 {
938  leftv u = args;
939  if ((u != NULL) && (u->Typ() == polytopeID))
940  {
941  gfan::ZCone* zp = (gfan::ZCone*)u->Data();
942  bool b;
943  try
944  {
945  polymake::perl::Object* p = ZPolytope2PmPolytope(zp);
946  b = p->give("VERY_AMPLE");
947  delete p;
948  }
949  catch (const std::exception& ex)
950  {
951  WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
952  return TRUE;
953  }
954  res->rtyp = INT_CMD;
955  res->data = (char*) (long) b;
956  return FALSE;
957  }
958  WerrorS("isVeryAmple: unexpected parameters");
959  return TRUE;
960 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: tok.h:85
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
polymake::perl::Object * ZPolytope2PmPolytope(gfan::ZCone *zc)
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
int Typ()
Definition: subexpr.cc:955
void * data
Definition: subexpr.h:89
int polytopeID
Definition: bbpolytope.cc:17
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
const poly b
Definition: syzextra.cc:213
BOOLEAN PMlatticeCodegree ( leftv  res,
leftv  args 
)

Definition at line 545 of file polymake_wrapper.cc.

546 {
547  leftv u = args;
548  if ((u != NULL) && (u->Typ() == polytopeID))
549  {
550  gfan::ZCone* zp = (gfan::ZCone*)u->Data();
551  int lc;
552  bool ok = true;
553  try
554  {
555  polymake::perl::Object* p = ZPolytope2PmPolytope(zp);
556  polymake::Integer plc = p->give("LATTICE_CODEGREE");
557  delete p;
558  lc = PmInteger2Int(plc,ok);
559  }
560  catch (const std::exception& ex)
561  {
562  WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
563  return TRUE;
564  }
565  if (!ok)
566  {
567  WerrorS("overflow while converting polymake::Integer to int");
568  return TRUE;
569  }
570  res->rtyp = INT_CMD;
571  res->data = (char*) (long) lc;
572  return FALSE;
573  }
574  WerrorS("latticeCodegree: unexpected parameters");
575  return TRUE;
576 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: tok.h:85
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
polymake::perl::Object * ZPolytope2PmPolytope(gfan::ZCone *zc)
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
int Typ()
Definition: subexpr.cc:955
CanonicalForm lc(const CanonicalForm &f)
void * data
Definition: subexpr.h:89
int polytopeID
Definition: bbpolytope.cc:17
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
int PmInteger2Int(const polymake::Integer &pi, bool &ok)
BOOLEAN PMlatticeDegree ( leftv  res,
leftv  args 
)

Definition at line 511 of file polymake_wrapper.cc.

512 {
513  leftv u = args;
514  if ((u != NULL) && (u->Typ() == polytopeID))
515  {
516  gfan::ZCone* zp = (gfan::ZCone*)u->Data();
517  int ld;
518  bool ok = true;
519  try
520  {
521  polymake::perl::Object* p = ZPolytope2PmPolytope(zp);
522  polymake::Integer pld = p->give("LATTICE_DEGREE");
523  delete p;
524  ld = PmInteger2Int(pld,ok);
525  }
526  catch (const std::exception& ex)
527  {
528  WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
529  return TRUE;
530  }
531  if (!ok)
532  {
533  WerrorS("overflow while converting polymake::Integer to int");
534  return TRUE;
535  }
536  res->rtyp = INT_CMD;
537  res->data = (char*) (long) ld;
538  return FALSE;
539  }
540  WerrorS("latticeDegree: unexpected parameters");
541  return TRUE;
542 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: tok.h:85
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
polymake::perl::Object * ZPolytope2PmPolytope(gfan::ZCone *zc)
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
int Typ()
Definition: subexpr.cc:955
void * data
Definition: subexpr.h:89
int polytopeID
Definition: bbpolytope.cc:17
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
int PmInteger2Int(const polymake::Integer &pi, bool &ok)
BOOLEAN PMlatticePoints ( leftv  res,
leftv  args 
)

Definition at line 963 of file polymake_wrapper.cc.

964 {
965  leftv u = args;
966  if ((u != NULL) && (u->Typ() == polytopeID))
967  {
968  gfan::ZCone* zp = (gfan::ZCone*)u->Data();
969  intvec* iv;
970  bool ok = true;
971  try
972  {
973  polymake::perl::Object* p = ZPolytope2PmPolytope(zp);
974  polymake::Matrix<polymake::Integer> lp = p->give("LATTICE_POINTS");
975  delete p;
976  iv = PmMatrixInteger2Intvec(&lp,ok);
977  }
978  catch (const std::exception& ex)
979  {
980  WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
981  return TRUE;
982  }
983  if (!ok)
984  {
985  WerrorS("overflow while converting polymake::Integer to int");
986  return TRUE;
987  }
988  res->rtyp = INTMAT_CMD;
989  res->data = (char*) iv;
990  return FALSE;
991  }
992  WerrorS("LatticePoints: unexpected parameters");
993  return TRUE;
994 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
polymake::perl::Object * ZPolytope2PmPolytope(gfan::ZCone *zc)
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
int Typ()
Definition: subexpr.cc:955
void * data
Definition: subexpr.h:89
int polytopeID
Definition: bbpolytope.cc:17
Definition: intvec.h:16
intvec * PmMatrixInteger2Intvec(polymake::Matrix< polymake::Integer > *mi, bool &ok)
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
BOOLEAN PMlatticeVolume ( leftv  res,
leftv  args 
)

Definition at line 477 of file polymake_wrapper.cc.

478 {
479  leftv u = args;
480  if ((u != NULL) && (u->Typ() == polytopeID))
481  {
482  gfan::ZCone* zp = (gfan::ZCone*)u->Data();
483  int lv;
484  bool ok = true;
485  try
486  {
487  polymake::perl::Object* p = ZPolytope2PmPolytope(zp);
488  polymake::Integer plv = p->give("LATTICE_VOLUME");
489  delete p;
490  lv = PmInteger2Int(plv,ok);
491  }
492  catch (const std::exception& ex)
493  {
494  WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
495  return TRUE;
496  }
497  if (!ok)
498  {
499  WerrorS("overflow while converting polymake::Integer to int");
500  return TRUE;
501  }
502  res->rtyp = INT_CMD;
503  res->data = (char*) (long) lv;
504  return FALSE;
505  }
506  WerrorS("latticeVolume: unexpected parameters");
507  return TRUE;
508 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: tok.h:85
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
polymake::perl::Object * ZPolytope2PmPolytope(gfan::ZCone *zc)
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
int Typ()
Definition: subexpr.cc:955
void * data
Definition: subexpr.h:89
int polytopeID
Definition: bbpolytope.cc:17
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
int PmInteger2Int(const polymake::Integer &pi, bool &ok)
BOOLEAN PMmaximalFace ( leftv  res,
leftv  args 
)

Definition at line 1371 of file polymake_wrapper.cc.

1372 {
1373  leftv u = args;
1374  if ((u != NULL) && (u->Typ() == polytopeID))
1375  {
1376  leftv v = u->next;
1377  if ((v != NULL) && (v->Typ() == INTVEC_CMD))
1378  {
1379  gfan::ZCone* zp = (gfan::ZCone*)u->Data();
1380  intvec* iv = (intvec*) v->Data();
1381  intvec* maxface;
1382  bool ok = true;
1383  try
1384  {
1385  polymake::perl::Object* p = ZPolytope2PmPolytope(zp);
1386  polymake::perl::Object o("LinearProgram<Rational>");
1387  o.take("LINEAR_OBJECTIVE") << Intvec2PmVectorInteger(iv);
1388  p->take("LP") << o;
1389  polymake::Set<polymake::Integer> mf = p->give("LP.MAXIMAL_FACE");
1390  polymake::Matrix<polymake::Integer> vertices = verticesOf(p,&mf);
1391  delete p;
1392  maxface = new intvec(PmMatrixInteger2Intvec(&vertices,ok));
1393  }
1394  catch (const std::exception& ex)
1395  {
1396  WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
1397  return TRUE;
1398  }
1399  if (!ok)
1400  {
1401  WerrorS("overflow while converting polymake::Integer to int");
1402  return TRUE;
1403  }
1404  res->rtyp = INTVEC_CMD;
1405  res->data = (char*) maxface;
1406  return FALSE;
1407  }
1408  }
1409  WerrorS("maximalFace: unexpected parameters");
1410  return TRUE;
1411 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
polymake::Vector< polymake::Integer > Intvec2PmVectorInteger(const intvec *iv)
polymake::perl::Object * ZPolytope2PmPolytope(gfan::ZCone *zc)
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
int Typ()
Definition: subexpr.cc:955
void * data
Definition: subexpr.h:89
polymake::Matrix< polymake::Integer > verticesOf(const polymake::perl::Object *p, const polymake::Set< polymake::Integer > *s)
int polytopeID
Definition: bbpolytope.cc:17
Definition: intvec.h:16
intvec * PmMatrixInteger2Intvec(polymake::Matrix< polymake::Integer > *mi, bool &ok)
BOOLEAN vertices(leftv res, leftv args)
Definition: bbpolytope.cc:340
Definition: tok.h:88
leftv next
Definition: subexpr.h:87
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
BOOLEAN PMmaximalValue ( leftv  res,
leftv  args 
)

Definition at line 1457 of file polymake_wrapper.cc.

1458 {
1459  leftv u = args;
1460  if ((u != NULL) && (u->Typ() == polytopeID))
1461  {
1462  leftv v = u->next;
1463  if ((v != NULL) && (v->Typ() == INTVEC_CMD))
1464  {
1465  gfan::ZCone* zp = (gfan::ZCone*)u->Data();
1466  intvec* iv = (intvec*) v->Data();
1467  if (iv->rows()==zp->ambientDimension())
1468  {
1469  int m;
1470  bool ok = true;
1471  try
1472  {
1473  polymake::perl::Object* p = ZPolytope2PmPolytope(zp);
1474  polymake::Vector<polymake::Integer> lo = Intvec2PmVectorInteger(iv);
1475  polymake::perl::Object o("LinearProgram<Rational>");
1476  o.take("LINEAR_OBJECTIVE") << lo;
1477  p->take("LP") << o;
1478  polymake::Integer mv = p->give("LP.MAXIMAL_VALUE");
1479  delete p;
1480  m = PmInteger2Int(mv,ok);
1481  }
1482  catch (const std::exception& ex)
1483  {
1484  WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
1485  return TRUE;
1486  }
1487  if (!ok)
1488  {
1489  WerrorS("overflow while converting polymake::Integer to int");
1490  return TRUE;
1491  }
1492  res->rtyp = INT_CMD;
1493  res->data = (char*) (long) m;
1494  return FALSE;
1495  }
1496  }
1497  WerrorS("maximalValue: vector is of wrong size");
1498  return TRUE;
1499  }
1500  WerrorS("maximalValue: unexpected parameters");
1501  return TRUE;
1502 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: tok.h:85
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
polymake::Vector< polymake::Integer > Intvec2PmVectorInteger(const intvec *iv)
polymake::perl::Object * ZPolytope2PmPolytope(gfan::ZCone *zc)
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
int Typ()
Definition: subexpr.cc:955
void * data
Definition: subexpr.h:89
int polytopeID
Definition: bbpolytope.cc:17
Definition: intvec.h:16
int m
Definition: cfEzgcd.cc:119
Definition: tok.h:88
leftv next
Definition: subexpr.h:87
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
#define NULL
Definition: omList.c:10
int rows() const
Definition: intvec.h:88
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
int PmInteger2Int(const polymake::Integer &pi, bool &ok)
BOOLEAN PMminimalFace ( leftv  res,
leftv  args 
)

Definition at line 1414 of file polymake_wrapper.cc.

1415 {
1416  leftv u = args;
1417  if ((u != NULL) && (u->Typ() == polytopeID))
1418  {
1419  leftv v = u->next;
1420  if ((v != NULL) && (v->Typ() == INTVEC_CMD))
1421  {
1422  gfan::ZCone* zp = (gfan::ZCone*)u->Data();
1423  intvec* iv = (intvec*) v->Data();
1424  intvec* minface;
1425  bool ok = true;
1426  try
1427  {
1428  polymake::perl::Object* p = ZPolytope2PmPolytope(zp);
1429  polymake::perl::Object o("LinearProgram<Rational>");
1430  o.take("LINEAR_OBJECTIVE") << Intvec2PmVectorInteger(iv);
1431  p->take("LP") << o;
1432  polymake::Set<polymake::Integer> mf = p->give("LP.MINIMAL_FACE");
1433  polymake::Matrix<polymake::Integer> vertices = verticesOf(p,&mf);
1434  delete p;
1435  minface = new intvec(PmMatrixInteger2Intvec(&vertices,ok));
1436  }
1437  catch (const std::exception& ex)
1438  {
1439  WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
1440  return TRUE;
1441  }
1442  if (!ok)
1443  {
1444  WerrorS("overflow while converting polymake::Integer to int");
1445  return TRUE;
1446  }
1447  res->rtyp = INTVEC_CMD;
1448  res->data = (char*) minface;
1449  return FALSE;
1450  }
1451  }
1452  WerrorS("minimalFace: unexpected parameters");
1453  return TRUE;
1454 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
polymake::Vector< polymake::Integer > Intvec2PmVectorInteger(const intvec *iv)
polymake::perl::Object * ZPolytope2PmPolytope(gfan::ZCone *zc)
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
int Typ()
Definition: subexpr.cc:955
void * data
Definition: subexpr.h:89
polymake::Matrix< polymake::Integer > verticesOf(const polymake::perl::Object *p, const polymake::Set< polymake::Integer > *s)
int polytopeID
Definition: bbpolytope.cc:17
Definition: intvec.h:16
intvec * PmMatrixInteger2Intvec(polymake::Matrix< polymake::Integer > *mi, bool &ok)
BOOLEAN vertices(leftv res, leftv args)
Definition: bbpolytope.cc:340
Definition: tok.h:88
leftv next
Definition: subexpr.h:87
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
BOOLEAN PMminimalValue ( leftv  res,
leftv  args 
)

Definition at line 1504 of file polymake_wrapper.cc.

1505 {
1506  leftv u = args;
1507  if ((u != NULL) && (u->Typ() == polytopeID))
1508  {
1509  leftv v = u->next;
1510  if ((v != NULL) && (v->Typ() == INTVEC_CMD))
1511  {
1512  gfan::ZCone* zp = (gfan::ZCone*)u->Data();
1513  intvec* iv = (intvec*) v->Data();
1514  if (iv->rows()==zp->ambientDimension())
1515  {
1516  int m;
1517  bool ok = true;
1518  try
1519  {
1520  polymake::perl::Object* p = ZPolytope2PmPolytope(zp);
1521  polymake::Vector<polymake::Integer> lo = Intvec2PmVectorInteger(iv);
1522  polymake::perl::Object o("LinearProgram<Rational>");
1523  o.take("LINEAR_OBJECTIVE") << lo;
1524  p->take("LP") << o;
1525  polymake::Integer mv = p->give("LP.MINIMAL_VALUE");
1526  delete p;
1527  m = PmInteger2Int(mv,ok);
1528  }
1529  catch (const std::exception& ex)
1530  {
1531  WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
1532  return TRUE;
1533  }
1534  if (!ok)
1535  {
1536  WerrorS("overflow while converting polymake::Integer to int");
1537  return TRUE;
1538  }
1539  res->rtyp = INT_CMD;
1540  res->data = (char*) (long) m;
1541  return FALSE;
1542  }
1543  }
1544  WerrorS("minimalValue: vector is of wrong size");
1545  return TRUE;
1546  }
1547  WerrorS("minimalValue: unexpected parameters");
1548  return TRUE;
1549 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: tok.h:85
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
polymake::Vector< polymake::Integer > Intvec2PmVectorInteger(const intvec *iv)
polymake::perl::Object * ZPolytope2PmPolytope(gfan::ZCone *zc)
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
int Typ()
Definition: subexpr.cc:955
void * data
Definition: subexpr.h:89
int polytopeID
Definition: bbpolytope.cc:17
Definition: intvec.h:16
int m
Definition: cfEzgcd.cc:119
Definition: tok.h:88
leftv next
Definition: subexpr.h:87
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
#define NULL
Definition: omList.c:10
int rows() const
Definition: intvec.h:88
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
int PmInteger2Int(const polymake::Integer &pi, bool &ok)
BOOLEAN PMminkowskiSum ( leftv  res,
leftv  args 
)

Definition at line 1235 of file polymake_wrapper.cc.

1236 {
1237  leftv u = args;
1238  if ((u != NULL) && (u->Typ() == polytopeID))
1239  {
1240  leftv v = u->next;
1241  if ((v != NULL) && (v->Typ() == polytopeID))
1242  {
1243  gfan::ZCone* zp = (gfan::ZCone*)u->Data();
1244  gfan::ZCone* zq = (gfan::ZCone*)v->Data();
1245  gfan::ZCone* ms;
1246  try
1247  {
1248  polymake::perl::Object* pp = ZPolytope2PmPolytope(zp);
1249  polymake::perl::Object* pq = ZPolytope2PmPolytope(zq);
1250  polymake::perl::Object pms;
1251  CallPolymakeFunction("minkowski_sum", *pp, *pq) >> pms;
1252  delete pp;
1253  delete pq;
1254  ms = PmPolytope2ZPolytope(&pms);
1255  }
1256  catch (const std::exception& ex)
1257  {
1258  WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
1259  return TRUE;
1260  }
1261  res->rtyp = polytopeID;
1262  res->data = (char*) ms;
1263  return FALSE;
1264  }
1265  if ((v != NULL) && (v->Typ() == coneID))
1266  {
1267  gfan::ZCone* zp = (gfan::ZCone*)u->Data();
1268  gfan::ZCone* zc = (gfan::ZCone*)v->Data();
1269  gfan::ZCone* zq = new gfan::ZCone(liftUp(*zc));
1270  gfan::ZCone* ms;
1271  try
1272  {
1273  polymake::perl::Object* pp = ZPolytope2PmPolytope(zp);
1274  polymake::perl::Object* pq = ZPolytope2PmPolytope(zq);
1275  polymake::perl::Object pms;
1276  CallPolymakeFunction("minkowski_sum", *pp, *pq) >> pms;
1277  delete pp;
1278  delete pq;
1279  ms = PmPolytope2ZPolytope(&pms);
1280  }
1281  catch (const std::exception& ex)
1282  {
1283  WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
1284  delete zq;
1285  return TRUE;
1286  }
1287  res->rtyp = polytopeID;
1288  res->data = (char*) ms;
1289  delete zq;
1290  return FALSE;
1291  }
1292  }
1293  if ((u != NULL) && (u->Typ() == coneID))
1294  {
1295  leftv v = u->next;
1296  if ((v != NULL) && (v->Typ() == polytopeID))
1297  {
1298  gfan::ZCone* zc = (gfan::ZCone*)u->Data();
1299  gfan::ZCone* zp = new gfan::ZCone(liftUp(*zc));
1300  gfan::ZCone* zq = (gfan::ZCone*)v->Data();
1301  gfan::ZCone* ms;
1302  try
1303  {
1304  polymake::perl::Object* pp = ZPolytope2PmPolytope(zp);
1305  polymake::perl::Object* pq = ZPolytope2PmPolytope(zq);
1306  polymake::perl::Object pms;
1307  CallPolymakeFunction("minkowski_sum", *pp, *pq) >> pms;
1308  delete pp;
1309  delete pq;
1310  ms = PmPolytope2ZPolytope(&pms);
1311  }
1312  catch (const std::exception& ex)
1313  {
1314  WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
1315  delete zp;
1316  return TRUE;
1317  }
1318  res->rtyp = polytopeID;
1319  res->data = (char*) ms;
1320  delete zp;
1321  return FALSE;
1322  }
1323  if ((v != NULL) && (v->Typ() == coneID))
1324  {
1325  gfan::ZCone* zp = (gfan::ZCone*)u->Data();
1326  gfan::ZCone* zq = (gfan::ZCone*)v->Data();
1327  gfan::ZCone* ms;
1328  try
1329  {
1330  polymake::perl::Object* pp = ZPolytope2PmPolytope(zp);
1331  polymake::perl::Object* pq = ZPolytope2PmPolytope(zq);
1332  polymake::perl::Object pms;
1333  CallPolymakeFunction("minkowski_sum", *pp, *pq) >> pms;
1334  delete pp;
1335  delete pq;
1336  ms = PmPolytope2ZPolytope(&pms);
1337  }
1338  catch (const std::exception& ex)
1339  {
1340  WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
1341  return TRUE;
1342  }
1343  res->rtyp = coneID;
1344  res->data = (char*) ms;
1345  return FALSE;
1346  }
1347  }
1348  WerrorS("minkowskiSum: unexpected parameters");
1349  return TRUE;
1350 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
gfan::ZMatrix liftUp(const gfan::ZMatrix &zm)
Definition: bbcone.cc:1044
#define FALSE
Definition: auxiliary.h:140
polymake::perl::Object * ZPolytope2PmPolytope(gfan::ZCone *zc)
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
int Typ()
Definition: subexpr.cc:955
poly pp
Definition: myNF.cc:296
void * data
Definition: subexpr.h:89
int polytopeID
Definition: bbpolytope.cc:17
int coneID
Definition: bbcone.cc:24
leftv next
Definition: subexpr.h:87
gfan::ZCone * PmPolytope2ZPolytope(polymake::perl::Object *pp)
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
BOOLEAN PMnBoundaryLatticePoints ( leftv  res,
leftv  args 
)

Definition at line 1133 of file polymake_wrapper.cc.

1134 {
1135  leftv u = args;
1136  if ((u != NULL) && (u->Typ() == polytopeID))
1137  {
1138  gfan::ZCone* zp = (gfan::ZCone*)u->Data();
1139  int n;
1140  bool ok = true;
1141  try
1142  {
1143  polymake::perl::Object* p = ZPolytope2PmPolytope(zp);
1144  polymake::Integer nlp = p->give("N_BOUNDARY_LATTICE_POINTS");
1145  delete p;
1146  n = PmInteger2Int(nlp,ok);
1147  }
1148  catch (const std::exception& ex)
1149  {
1150  WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
1151  return TRUE;
1152  }
1153  if (!ok)
1154  {
1155  WerrorS("overflow while converting polymake::Integer to int");
1156  return TRUE;
1157  }
1158  res->rtyp = INT_CMD;
1159  res->data = (char*) (long) n;
1160  return FALSE;
1161  }
1162  WerrorS("nBoundaryLatticePoints: unexpected parameters");
1163  return TRUE;
1164 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: tok.h:85
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
const CanonicalForm CFMap CFMap int &both_non_zero int n
Definition: cfEzgcd.cc:52
polymake::perl::Object * ZPolytope2PmPolytope(gfan::ZCone *zc)
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
int Typ()
Definition: subexpr.cc:955
void * data
Definition: subexpr.h:89
int polytopeID
Definition: bbpolytope.cc:17
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
int PmInteger2Int(const polymake::Integer &pi, bool &ok)
BOOLEAN PMnHilbertBasis ( leftv  res,
leftv  args 
)

Definition at line 1201 of file polymake_wrapper.cc.

1202 {
1203  leftv u = args;
1204  if ((u != NULL) && (u->Typ() == coneID))
1205  {
1206  gfan::ZCone* zp = (gfan::ZCone*)u->Data();
1207  int n;
1208  bool ok = true;
1209  try
1210  {
1211  polymake::perl::Object* p = ZPolytope2PmPolytope(zp);
1212  polymake::Integer nlp = p->give("N_HILBERT_BASIS");
1213  delete p;
1214  n = PmInteger2Int(nlp,ok);
1215  }
1216  catch (const std::exception& ex)
1217  {
1218  WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
1219  return TRUE;
1220  }
1221  if (!ok)
1222  {
1223  WerrorS("overflow while converting polymake::Integer to int");
1224  return TRUE;
1225  }
1226  res->rtyp = INT_CMD;
1227  res->data = (char*) (long) n;
1228  return FALSE;
1229  }
1230  WerrorS("nHilbertBasis: unexpected parameters");
1231  return TRUE;
1232 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: tok.h:85
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
const CanonicalForm CFMap CFMap int &both_non_zero int n
Definition: cfEzgcd.cc:52
polymake::perl::Object * ZPolytope2PmPolytope(gfan::ZCone *zc)
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
int Typ()
Definition: subexpr.cc:955
void * data
Definition: subexpr.h:89
int coneID
Definition: bbcone.cc:24
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
int PmInteger2Int(const polymake::Integer &pi, bool &ok)
BOOLEAN PMnInteriorLatticePoints ( leftv  res,
leftv  args 
)

Definition at line 1065 of file polymake_wrapper.cc.

1066 {
1067  leftv u = args;
1068  if ((u != NULL) && (u->Typ() == polytopeID))
1069  {
1070  gfan::ZCone* zp = (gfan::ZCone*)u->Data();
1071  int n;
1072  bool ok = true;
1073  try
1074  {
1075  polymake::perl::Object* p = ZPolytope2PmPolytope(zp);
1076  polymake::Integer nlp = p->give("N_INTERIOR_LATTICE_POINTS");
1077  delete p;
1078  n = PmInteger2Int(nlp,ok);
1079  }
1080  catch (const std::exception& ex)
1081  {
1082  WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
1083  return TRUE;
1084  }
1085  if (!ok)
1086  {
1087  WerrorS("overflow while converting polymake::Integer to int");
1088  return TRUE;
1089  }
1090  res->rtyp = INT_CMD;
1091  res->data = (char*) (long) n;
1092  return FALSE;
1093  }
1094  WerrorS("nInteriorLatticePoints: unexpected parameters");
1095  return TRUE;
1096 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: tok.h:85
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
const CanonicalForm CFMap CFMap int &both_non_zero int n
Definition: cfEzgcd.cc:52
polymake::perl::Object * ZPolytope2PmPolytope(gfan::ZCone *zc)
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
int Typ()
Definition: subexpr.cc:955
void * data
Definition: subexpr.h:89
int polytopeID
Definition: bbpolytope.cc:17
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
int PmInteger2Int(const polymake::Integer &pi, bool &ok)
BOOLEAN PMnLatticePoints ( leftv  res,
leftv  args 
)

Definition at line 997 of file polymake_wrapper.cc.

998 {
999  leftv u = args;
1000  if ((u != NULL) && (u->Typ() == polytopeID))
1001  {
1002  gfan::ZCone* zp = (gfan::ZCone*)u->Data();
1003  int n;
1004  bool ok = true;
1005  try
1006  {
1007  polymake::perl::Object* p = ZPolytope2PmPolytope(zp);
1008  polymake::Integer nlp = p->give("N_LATTICE_POINTS");
1009  delete p;
1010  n = PmInteger2Int(nlp,ok);
1011  }
1012  catch (const std::exception& ex)
1013  {
1014  WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
1015  return TRUE;
1016  }
1017  if (!ok)
1018  {
1019  WerrorS("overflow while converting polymake::Integer to int");
1020  return TRUE;
1021  }
1022  res->rtyp = INT_CMD;
1023  res->data = (char*) (long) n;
1024  return FALSE;
1025  }
1026  WerrorS("nLatticePoints: unexpected parameters");
1027  return TRUE;
1028 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: tok.h:85
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
const CanonicalForm CFMap CFMap int &both_non_zero int n
Definition: cfEzgcd.cc:52
polymake::perl::Object * ZPolytope2PmPolytope(gfan::ZCone *zc)
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
int Typ()
Definition: subexpr.cc:955
void * data
Definition: subexpr.h:89
int polytopeID
Definition: bbpolytope.cc:17
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
int PmInteger2Int(const polymake::Integer &pi, bool &ok)
BOOLEAN PMpolytopeViaVertices ( leftv  res,
leftv  args 
)

Definition at line 1656 of file polymake_wrapper.cc.

1657 {
1658  leftv u = args;
1659  if ((u != NULL) && (u->Typ() == INTMAT_CMD))
1660  {
1661  polymake::perl::Object pp("Polytope<Rational>");
1662  intvec* points = (intvec*) u->Data(); // these will be vertices of or points in the polytope
1663  polymake::Matrix<polymake::Integer> pmpoints = Intvec2PmMatrixInteger(points);
1664 
1665  leftv v = u->next;
1666  if ((v != NULL) && (v->Typ() == INT_CMD))
1667  {
1668  int flag = (int) (long) v->Data();
1669  switch(flag)
1670  {
1671  case 0: pp.take("POINTS") << pmpoints; // case means the matrix may contain points inside the polytope
1672  case 1: pp.take("VERTICES") << pmpoints; // case means the matrix only contains vertices of the polytope
1673  default: WerrorS("polytopeViaVertices: invalid flag");
1674  }
1675  }
1676  else
1677  pp.take("POINTS") << pmpoints; // by default, we assume that matrix may contain non-vertices
1678 
1679  gfan::ZCone* zp = PmPolytope2ZPolytope(&pp);
1680  res->rtyp = polytopeID;
1681  res->data = (char*) zp;
1682  return FALSE;
1683  }
1684  WerrorS("polytopeViaVertices: unexpected parameters");
1685  return TRUE;
1686 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: tok.h:85
#define FALSE
Definition: auxiliary.h:140
#define TRUE
Definition: auxiliary.h:144
static coordinates * points
void WerrorS(const char *s)
Definition: feFopen.cc:23
polymake::Matrix< polymake::Integer > Intvec2PmMatrixInteger(const intvec *im)
int Typ()
Definition: subexpr.cc:955
poly pp
Definition: myNF.cc:296
void * data
Definition: subexpr.h:89
int polytopeID
Definition: bbpolytope.cc:17
Definition: intvec.h:16
leftv next
Definition: subexpr.h:87
gfan::ZCone * PmPolytope2ZPolytope(polymake::perl::Object *pp)
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
BOOLEAN PMvertexAdjacencyGraph ( leftv  res,
leftv  args 
)

Definition at line 1689 of file polymake_wrapper.cc.

1690 {
1691  leftv u = args;
1692  if ((u != NULL) && (u->Typ() == polytopeID))
1693  {
1694  gfan::ZCone* zp = (gfan::ZCone*) u->Data();
1695  lists output=(lists)omAllocBin(slists_bin); output->Init(2);
1696  try
1697  {
1698  polymake::perl::Object* p = ZPolytope2PmPolytope(zp);
1699  polymake::Matrix<polymake::Integer> vert0 = p->give("VERTICES");
1700  bigintmat* vert1 = PmMatrixInteger2Bigintmat(&vert0);
1701  output->m[0].rtyp = BIGINTMAT_CMD;
1702  output->m[0].data = (void*) vert1;
1703 
1704  polymake::Graph<> gr=p->give("GRAPH.ADJACENCY");
1705  polymake::IncidenceMatrix<polymake::NonSymmetric> adj = adjacency_matrix(gr);
1706  lists listOfEdges = PmIncidenceMatrix2ListOfIntvecs(&adj);
1707  output->m[1].rtyp = LIST_CMD;
1708  output->m[1].data = (void*) listOfEdges;
1709  delete p;
1710  }
1711  catch (const std::exception& ex)
1712  {
1713  WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
1714  return TRUE;
1715  }
1716  res->rtyp = LIST_CMD;
1717  res->data = (void*) output;
1718  return FALSE;
1719  }
1720  WerrorS("vertexEdgeGraph: unexpected parameters");
1721  return TRUE;
1722 }
#define omAllocBin(bin)
Definition: omAllocDecl.h:205
sleftv * m
Definition: lists.h:45
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
lists PmIncidenceMatrix2ListOfIntvecs(polymake::IncidenceMatrix< polymake::NonSymmetric > *icmat)
Definition: lists.h:22
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
Matrices of numbers.
Definition: bigintmat.h:32
polymake::perl::Object * ZPolytope2PmPolytope(gfan::ZCone *zc)
bigintmat * PmMatrixInteger2Bigintmat(polymake::Matrix< polymake::Integer > *mi)
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
int Typ()
Definition: subexpr.cc:955
void * data
Definition: subexpr.h:89
int polytopeID
Definition: bbpolytope.cc:17
INLINE_THIS void Init(int l=0)
Definition: lists.h:66
#define NULL
Definition: omList.c:10
slists * lists
Definition: mpr_numeric.h:146
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
Definition: tok.h:96
omBin slists_bin
Definition: lists.cc:23
BOOLEAN PMvertexEdgeGraph ( leftv  res,
leftv  args 
)

Definition at line 1725 of file polymake_wrapper.cc.

1726 {
1727  leftv u = args;
1728  if ((u != NULL) && (u->Typ() == polytopeID))
1729  {
1730  gfan::ZCone* zp = (gfan::ZCone*) u->Data();
1731  lists output=(lists)omAllocBin(slists_bin); output->Init(2);
1732  try
1733  {
1734  polymake::perl::Object* p = ZPolytope2PmPolytope(zp);
1735  polymake::Matrix<polymake::Integer> vert0 = p->give("VERTICES");
1736  bigintmat* vert1 = PmMatrixInteger2Bigintmat(&vert0);
1737  output->m[0].rtyp = BIGINTMAT_CMD;
1738  output->m[0].data = (void*) vert1;
1739 
1740  polymake::Graph<> gr=p->give("GRAPH.ADJACENCY");
1741  polymake::IncidenceMatrix<polymake::NonSymmetric> adj = adjacency_matrix(gr);
1742  lists listOfEdges = PmAdjacencyMatrix2ListOfEdges(&adj);
1743  output->m[1].rtyp = LIST_CMD;
1744  output->m[1].data = (void*) listOfEdges;
1745  delete p;
1746  }
1747  catch (const std::exception& ex)
1748  {
1749  WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
1750  return TRUE;
1751  }
1752  res->rtyp = LIST_CMD;
1753  res->data = (void*) output;
1754  return FALSE;
1755  }
1756  WerrorS("vertexEdgeGraph: unexpected parameters");
1757  return TRUE;
1758 }
#define omAllocBin(bin)
Definition: omAllocDecl.h:205
sleftv * m
Definition: lists.h:45
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: lists.h:22
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
Matrices of numbers.
Definition: bigintmat.h:32
lists PmAdjacencyMatrix2ListOfEdges(polymake::IncidenceMatrix< polymake::NonSymmetric > *icmat)
polymake::perl::Object * ZPolytope2PmPolytope(gfan::ZCone *zc)
bigintmat * PmMatrixInteger2Bigintmat(polymake::Matrix< polymake::Integer > *mi)
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
int Typ()
Definition: subexpr.cc:955
void * data
Definition: subexpr.h:89
int polytopeID
Definition: bbpolytope.cc:17
INLINE_THIS void Init(int l=0)
Definition: lists.h:66
#define NULL
Definition: omList.c:10
slists * lists
Definition: mpr_numeric.h:146
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
Definition: tok.h:96
omBin slists_bin
Definition: lists.cc:23
int SI_MOD_INIT() polymake ( SModulFunctions p)

Definition at line 1763 of file polymake_wrapper.cc.

1764 {
1765  omp_set_num_threads(1); // avoid multiple threads within polymake/libnormaliz
1766  if (init_polymake==NULL)
1767  {init_polymake = new polymake::Main();}
1768  init_polymake->set_application("fan");
1769  // p->iiAddCproc("polymake.so","coneViaPoints",FALSE,PMconeViaRays);
1770  // p->iiAddCproc("polymake.so","polytopeViaPoints",FALSE,PMpolytopeViaVertices);
1771  p->iiAddCproc("polymake.so","isLatticePolytope",FALSE,PMisLatticePolytope);
1772  p->iiAddCproc("polymake.so","isBounded",FALSE,PMisBounded);
1773  p->iiAddCproc("polymake.so","isReflexive",FALSE,PMisReflexive);
1774  p->iiAddCproc("polymake.so","isGorenstein",FALSE,PMisGorenstein);
1775  p->iiAddCproc("polymake.so","gorensteinIndex",FALSE,PMgorensteinIndex);
1776  p->iiAddCproc("polymake.so","gorensteinVector",FALSE,PMgorensteinVector);
1777  p->iiAddCproc("polymake.so","isCanonical",FALSE,PMisCanonical);
1778  p->iiAddCproc("polymake.so","isTerminal",FALSE,PMisTerminal);
1779  p->iiAddCproc("polymake.so","isLatticeEmpty",FALSE,PMisLatticeEmpty);
1780  p->iiAddCproc("polymake.so","latticeVolume",FALSE,PMlatticeVolume);
1781  p->iiAddCproc("polymake.so","latticeDegree",FALSE,PMlatticeDegree);
1782  p->iiAddCproc("polymake.so","latticeCodegree",FALSE,PMlatticeCodegree);
1783  p->iiAddCproc("polymake.so","ehrhartPolynomialCoeff",FALSE,PMehrhartPolynomialCoeff);
1784  p->iiAddCproc("polymake.so","fVectorP",FALSE,PMfVector);
1785  p->iiAddCproc("polymake.so","hVector",FALSE,PMhVector);
1786  p->iiAddCproc("polymake.so","hStarVector",FALSE,PMhStarVector);
1787  p->iiAddCproc("polymake.so","isNormal",FALSE,PMisNormal);
1788  p->iiAddCproc("polymake.so","facetWidths",FALSE,PMfacetWidths);
1789  p->iiAddCproc("polymake.so","facetWidth",FALSE,PMfacetWidth);
1790  p->iiAddCproc("polymake.so","facetVertexLatticeDistances",FALSE,PMfacetVertexLatticeDistances);
1791  p->iiAddCproc("polymake.so","isCompressed",FALSE,PMisCompressed);
1792  p->iiAddCproc("polymake.so","isSmooth",FALSE,PMisSmooth);
1793  p->iiAddCproc("polymake.so","isVeryAmple",FALSE,PMisVeryAmple);
1794  p->iiAddCproc("polymake.so","latticePoints",FALSE,PMlatticePoints);
1795  p->iiAddCproc("polymake.so","nLatticePoints",FALSE,PMnLatticePoints);
1796  p->iiAddCproc("polymake.so","interiorLatticePoints",FALSE,PMinteriorLatticePoints);
1797  p->iiAddCproc("polymake.so","nInteriorLatticePoints",FALSE,PMnInteriorLatticePoints);
1798  p->iiAddCproc("polymake.so","boundaryLatticePoints",FALSE,PMboundaryLatticePoints);
1799  p->iiAddCproc("polymake.so","nBoundaryLatticePoints",FALSE,PMnBoundaryLatticePoints);
1800  p->iiAddCproc("polymake.so","hilbertBasis",FALSE,PMhilbertBasis);
1801  p->iiAddCproc("polymake.so","nHilbertBasis",FALSE,PMnHilbertBasis);
1802  p->iiAddCproc("polymake.so","minkowskiSum",FALSE,PMminkowskiSum);
1803  p->iiAddCproc("polymake.so","maximalFace",FALSE,PMmaximalFace);
1804  p->iiAddCproc("polymake.so","minimalFace",FALSE,PMminimalFace);
1805  p->iiAddCproc("polymake.so","maximalValue",FALSE,PMmaximalValue);
1806  p->iiAddCproc("polymake.so","minimalValue",FALSE,PMminimalValue);
1807  p->iiAddCproc("polymake.so","visual",FALSE,visual);
1808  p->iiAddCproc("polymake.so","normalFan",FALSE,normalFan);
1809  p->iiAddCproc("polymake.so","vertexAdjacencyGraph",FALSE,PMvertexAdjacencyGraph);
1810  p->iiAddCproc("polymake.so","vertexEdgeGraph",FALSE,PMvertexEdgeGraph);
1811 
1812  blackbox* b=getBlackboxStuff(polytopeID);
1813  b->blackbox_Op2=bbpolytope_Op2;
1814 
1816  return MAX_TOK;
1817 }
void init_polymake_help()
BOOLEAN PMisSmooth(leftv res, leftv args)
BOOLEAN PMmaximalFace(leftv res, leftv args)
BOOLEAN PMnInteriorLatticePoints(leftv res, leftv args)
#define FALSE
Definition: auxiliary.h:140
Definition: tok.h:167
BOOLEAN normalFan(leftv res, leftv args)
BOOLEAN PMisCompressed(leftv res, leftv args)
BOOLEAN PMisBounded(leftv res, leftv args)
BOOLEAN PMgorensteinVector(leftv res, leftv args)
BOOLEAN visual(leftv res, leftv args)
static BOOLEAN bbpolytope_Op2(int op, leftv res, leftv i1, leftv i2)
BOOLEAN PMnHilbertBasis(leftv res, leftv args)
BOOLEAN PMfacetVertexLatticeDistances(leftv res, leftv args)
int polytopeID
Definition: bbpolytope.cc:17
polymake::Main * init_polymake
BOOLEAN PMboundaryLatticePoints(leftv res, leftv args)
BOOLEAN PMinteriorLatticePoints(leftv res, leftv args)
BOOLEAN PMisGorenstein(leftv res, leftv args)
BOOLEAN PMhVector(leftv res, leftv args)
BOOLEAN PMlatticeCodegree(leftv res, leftv args)
BOOLEAN PMhilbertBasis(leftv res, leftv args)
BOOLEAN PMisVeryAmple(leftv res, leftv args)
BOOLEAN PMnBoundaryLatticePoints(leftv res, leftv args)
BOOLEAN PMlatticePoints(leftv res, leftv args)
BOOLEAN PMlatticeVolume(leftv res, leftv args)
BOOLEAN PMisTerminal(leftv res, leftv args)
BOOLEAN PMgorensteinIndex(leftv res, leftv args)
BOOLEAN PMvertexEdgeGraph(leftv res, leftv args)
BOOLEAN PMfacetWidth(leftv res, leftv args)
BOOLEAN PMvertexAdjacencyGraph(leftv res, leftv args)
BOOLEAN PMisReflexive(leftv res, leftv args)
BOOLEAN PMminimalValue(leftv res, leftv args)
BOOLEAN PMfacetWidths(leftv res, leftv args)
BOOLEAN PMehrhartPolynomialCoeff(leftv res, leftv args)
BOOLEAN PMnLatticePoints(leftv res, leftv args)
#define NULL
Definition: omList.c:10
BOOLEAN PMminimalFace(leftv res, leftv args)
BOOLEAN PMisNormal(leftv res, leftv args)
BOOLEAN PMisLatticeEmpty(leftv res, leftv args)
BOOLEAN PMlatticeDegree(leftv res, leftv args)
BOOLEAN PMisCanonical(leftv res, leftv args)
BOOLEAN PMhStarVector(leftv res, leftv args)
int(* iiAddCproc)(const char *libname, const char *procname, BOOLEAN pstatic, BOOLEAN(*func)(leftv res, leftv v))
Definition: ipid.h:73
BOOLEAN PMmaximalValue(leftv res, leftv args)
BOOLEAN PMisLatticePolytope(leftv res, leftv args)
BOOLEAN PMfVector(leftv res, leftv args)
const poly b
Definition: syzextra.cc:213
BOOLEAN PMminkowskiSum(leftv res, leftv args)
blackbox * getBlackboxStuff(const int t)
return the structure to the type given by t
Definition: blackbox.cc:20
polymake::Matrix<polymake::Integer> verticesOf ( const polymake::perl::Object *  p,
const polymake::Set< polymake::Integer > *  s 
)

Definition at line 1353 of file polymake_wrapper.cc.

1355 {
1356  polymake::Matrix<polymake::Integer> allrays = p->give("VERTICES");
1357  polymake::Matrix<polymake::Integer> wantedrays;
1358  bool ok = true;
1359  for(polymake::Entire<polymake::Set<polymake::Integer> >::const_iterator i=polymake::entire(*s); !i.at_end(); i++)
1360  {
1361  wantedrays = wantedrays / allrays.row(PmInteger2Int(*i,ok));
1362  }
1363  if (!ok)
1364  {
1365  WerrorS("overflow while converting polymake::Integer to int in raysOf");
1366  }
1367  return wantedrays;
1368 }
const CanonicalForm int s
Definition: facAbsFact.cc:55
return P p
Definition: myNF.cc:203
void WerrorS(const char *s)
Definition: feFopen.cc:23
int i
Definition: cfEzgcd.cc:123
int PmInteger2Int(const polymake::Integer &pi, bool &ok)
BOOLEAN visual ( leftv  res,
leftv  args 
)

Definition at line 1552 of file polymake_wrapper.cc.

1553 {
1554  leftv u = args;
1555  if ((u != NULL) && (u->Typ() == polytopeID))
1556  {
1557  gfan::ZCone* zp = (gfan::ZCone*)u->Data();
1558  try
1559  {
1560  polymake::perl::Object* pp = ZPolytope2PmPolytope(zp);
1561  VoidCallPolymakeFunction("jreality",pp->CallPolymakeMethod("VISUAL"));
1562  delete pp;
1563  }
1564  catch (const std::exception& ex)
1565  {
1566  WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
1567  return TRUE;
1568  }
1569  res->rtyp = NONE;
1570  res->data = NULL;
1571  return FALSE;
1572  }
1573  if ((u != NULL) && (u->Typ() == fanID))
1574  {
1575  gfan::ZFan* zf = (gfan::ZFan*)u->Data();
1576  try
1577  {
1578  polymake::perl::Object* pf=ZFan2PmFan(zf);
1579  VoidCallPolymakeFunction("jreality",pf->CallPolymakeMethod("VISUAL"));
1580  }
1581  catch (const std::exception& ex)
1582  {
1583  WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
1584  return TRUE;
1585  }
1586  res->rtyp = NONE;
1587  res->data = NULL;
1588  return FALSE;
1589  }
1590  WerrorS("visual: unexpected parameters");
1591  return TRUE;
1592 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
#define FALSE
Definition: auxiliary.h:140
polymake::perl::Object * ZPolytope2PmPolytope(gfan::ZCone *zc)
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
int fanID
Definition: bbfan.cc:18
int Typ()
Definition: subexpr.cc:955
poly pp
Definition: myNF.cc:296
void * data
Definition: subexpr.h:89
int polytopeID
Definition: bbpolytope.cc:17
polymake::perl::Object * ZFan2PmFan(gfan::ZFan *zf)
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
#define NONE
Definition: tok.h:170

Variable Documentation

polymake::Main* init_polymake =NULL

Definition at line 18 of file polymake_wrapper.cc.