Functions | Variables
bbcone.h File Reference
#include <kernel/mod2.h>
#include <misc/intvec.h>
#include <coeffs/bigintmat.h>
#include <Singular/ipid.h>
#include <gfanlib/gfanlib.h>

Go to the source code of this file.

Functions

void bbcone_setup (SModulFunctions *p)
 
std::string toString (const gfan::ZCone *const c)
 
gfan::ZVector randomPoint (const gfan::ZCone *zc)
 
gfan::ZCone liftUp (const gfan::ZCone &zc)
 
gfan::ZMatrix interiorPointsOfFacets (const gfan::ZCone &zc, const std::set< gfan::ZVector > &exceptThese=std::set< gfan::ZVector >())
 
std::pair< gfan::ZMatrix, gfan::ZMatrix > interiorPointsAndNormalsOfFacets (const gfan::ZCone zc, const std::set< gfan::ZVector > &exceptThesePoints=std::set< gfan::ZVector >(), const bool onlyLowerHalfSpace=false)
 

Variables

int coneID
 

Function Documentation

void bbcone_setup ( SModulFunctions p)

Definition at line 1787 of file bbcone.cc.

1788 {
1789  blackbox *b=(blackbox*)omAlloc0(sizeof(blackbox));
1790  // all undefined entries will be set to default in setBlackboxStuff
1791  // the default Print is quite usefull,
1792  // all other are simply error messages
1793  b->blackbox_destroy=bbcone_destroy;
1794  b->blackbox_String=bbcone_String;
1795  // b->blackbox_Print=blackbox_default_Print;
1796  b->blackbox_Init=bbcone_Init;
1797  b->blackbox_Copy=bbcone_Copy;
1798  b->blackbox_Assign=bbcone_Assign;
1799  b->blackbox_Op2=bbcone_Op2;
1800  //b->blackbox_serialize=bbcone_serialize;
1801  //b->blackbox_deserialize=bbcone_deserialize;
1802  p->iiAddCproc("","coneViaInequalities",FALSE,coneViaNormals);
1803  p->iiAddCproc("","coneViaPoints",FALSE,coneViaRays);
1804 
1805  // iiAddCproc("","makePolytope",FALSE,coneToPolytope);
1806  p->iiAddCproc("","ambientDimension",FALSE,ambientDimension);
1807  p->iiAddCproc("","canonicalizeCone",FALSE,canonicalizeCone);
1808  p->iiAddCproc("","codimension",FALSE,codimension);
1809  p->iiAddCproc("","coneLink",FALSE,coneLink);
1810  p->iiAddCproc("","containsAsFace",FALSE,hasFace);
1811  p->iiAddCproc("","containsInSupport",FALSE,containsInSupport);
1812  p->iiAddCproc("","containsPositiveVector",FALSE,containsPositiveVector);
1813  p->iiAddCproc("","containsRelatively",FALSE,containsRelatively);
1814  p->iiAddCproc("","convexHull",FALSE,convexHull);
1815  p->iiAddCproc("","convexIntersection",FALSE,intersectCones);
1816  p->iiAddCproc("","dimension",FALSE,dimension);
1817  p->iiAddCproc("","dualCone",FALSE,dualCone);
1818  p->iiAddCproc("","equations",FALSE,equations);
1819  p->iiAddCproc("","facets",FALSE,facets);
1820  p->iiAddCproc("","generatorsOfLinealitySpace",FALSE,generatorsOfLinealitySpace);
1821  p->iiAddCproc("","generatorsOfSpan",FALSE,generatorsOfSpan);
1822  p->iiAddCproc("","getLinearForms",FALSE,getLinearForms);
1823  p->iiAddCproc("","getMultiplicity",FALSE,getMultiplicity);
1824  p->iiAddCproc("","inequalities",FALSE,inequalities);
1825  p->iiAddCproc("","isFullSpace",FALSE,isFullSpace);
1826  p->iiAddCproc("","isOrigin",FALSE,isOrigin);
1827  p->iiAddCproc("","isSimplicial",FALSE,isSimplicial);
1828  p->iiAddCproc("","linealityDimension",FALSE,linealityDimension);
1829  p->iiAddCproc("","linealitySpace",FALSE,linealitySpace);
1830  p->iiAddCproc("","negatedCone",FALSE,negatedCone);
1831  p->iiAddCproc("","quotientLatticeBasis",FALSE,quotientLatticeBasis);
1832  p->iiAddCproc("","randomPoint",FALSE,randomPoint);
1833  p->iiAddCproc("","rays",FALSE,rays);
1834  p->iiAddCproc("","relativeInteriorPoint",FALSE,relativeInteriorPoint);
1835  p->iiAddCproc("","semigroupGenerator",FALSE,semigroupGenerator);
1836  p->iiAddCproc("","setLinearForms",FALSE,setLinearForms);
1837  p->iiAddCproc("","setMultiplicity",FALSE,setMultiplicity);
1838  p->iiAddCproc("","span",FALSE,impliedEquations);
1839  p->iiAddCproc("","uniquePoint",FALSE,uniquePoint);
1840  p->iiAddCproc("","listContainsCone",FALSE,containsCone);
1841  p->iiAddCproc("","listOfFacets",FALSE,listOfFacets);
1842  p->iiAddCproc("","facetContaining",FALSE,facetContaining);
1843  coneID=setBlackboxStuff(b,"cone");
1844 }
BOOLEAN isFullSpace(leftv res, leftv args)
Definition: bbcone.cc:806
BOOLEAN coneViaNormals(leftv res, leftv args)
Definition: bbcone.cc:351
BOOLEAN getMultiplicity(leftv res, leftv args)
Definition: bbcone.cc:776
BOOLEAN dualCone(leftv res, leftv args)
Definition: bbcone.cc:874
BOOLEAN containsPositiveVector(leftv res, leftv args)
Definition: bbcone.cc:844
BOOLEAN containsRelatively(leftv res, leftv args)
Definition: bbcone.cc:1379
BOOLEAN canonicalizeCone(leftv res, leftv args)
Definition: bbcone.cc:1453
#define FALSE
Definition: auxiliary.h:140
BOOLEAN quotientLatticeBasis(leftv res, leftv args)
Definition: bbcone.cc:641
BOOLEAN generatorsOfSpan(leftv res, leftv args)
Definition: bbcone.cc:588
gfan::ZVector * facetContaining(gfan::ZCone *zc, gfan::ZVector *zv)
Definition: bbcone.cc:1567
BOOLEAN coneViaRays(leftv res, leftv args)
Definition: bbcone.cc:506
BOOLEAN containsInSupport(leftv res, leftv args)
Definition: bbcone.cc:1321
static BOOLEAN bbcone_Op2(int op, leftv res, leftv i1, leftv i2)
Definition: bbcone.cc:163
gfan::ZVector randomPoint(const gfan::ZCone *zc)
Definition: bbcone.cc:956
BOOLEAN inequalities(leftv res, leftv args)
Definition: bbcone.cc:527
BOOLEAN linealitySpace(leftv res, leftv args)
Definition: bbcone.cc:859
BOOLEAN relativeInteriorPoint(leftv res, leftv args)
Definition: bbcone.cc:926
BOOLEAN semigroupGenerator(leftv res, leftv args)
Definition: bbcone.cc:904
BOOLEAN isSimplicial(leftv res, leftv args)
Definition: bbcone.cc:821
BOOLEAN codimension(leftv res, leftv args)
Definition: bbcone.cc:727
BOOLEAN coneLink(leftv res, leftv args)
Definition: bbcone.cc:1276
BOOLEAN negatedCone(leftv res, leftv args)
Definition: bbcone.cc:889
BOOLEAN getLinearForms(leftv res, leftv args)
Definition: bbcone.cc:656
int coneID
Definition: bbcone.cc:24
lists listOfFacets(const gfan::ZCone &zc)
Definition: bbcone.cc:1506
BOOLEAN rays(leftv res, leftv args)
Definition: bbcone.cc:618
void bbcone_destroy(blackbox *, void *d)
Definition: bbcone.cc:147
BOOLEAN dimension(leftv res, leftv args)
Definition: bbcone.cc:699
void * bbcone_Init(blackbox *)
Definition: bbcone.cc:79
BOOLEAN containsCone(leftv res, leftv args)
Definition: bbcone.cc:1469
BOOLEAN uniquePoint(leftv res, leftv args)
Definition: bbcone.cc:941
BOOLEAN equations(leftv res, leftv args)
Definition: bbcone.cc:543
BOOLEAN facets(leftv res, leftv args)
Definition: bbcone.cc:558
BOOLEAN setLinearForms(leftv res, leftv args)
Definition: bbcone.cc:1012
BOOLEAN ambientDimension(leftv res, leftv args)
Definition: bbcone.cc:671
char * bbcone_String(blackbox *, void *d)
Definition: bbcone.cc:137
BOOLEAN isOrigin(leftv res, leftv args)
Definition: bbcone.cc:791
BOOLEAN bbcone_Assign(leftv l, leftv r)
Definition: bbcone.cc:84
BOOLEAN linealityDimension(leftv res, leftv args)
Definition: bbcone.cc:755
int(* iiAddCproc)(const char *libname, const char *procname, BOOLEAN pstatic, BOOLEAN(*func)(leftv res, leftv v))
Definition: ipid.h:73
BOOLEAN generatorsOfLinealitySpace(leftv res, leftv args)
Definition: bbcone.cc:603
BOOLEAN impliedEquations(leftv res, leftv args)
Definition: bbcone.cc:573
BOOLEAN hasFace(leftv res, leftv args)
Definition: bbcone.cc:1420
BOOLEAN intersectCones(leftv res, leftv args)
Definition: bbcone.cc:1081
int setBlackboxStuff(blackbox *bb, const char *n)
define a new type
Definition: blackbox.cc:128
const poly b
Definition: syzextra.cc:213
void * bbcone_Copy(blackbox *, void *d)
Definition: bbcone.cc:156
#define omAlloc0(size)
Definition: omAllocDecl.h:211
BOOLEAN setMultiplicity(leftv res, leftv args)
Definition: bbcone.cc:992
std::pair<gfan::ZMatrix,gfan::ZMatrix> interiorPointsAndNormalsOfFacets ( const gfan::ZCone  zc,
const std::set< gfan::ZVector > &  exceptThesePoints = std::set< gfan::ZVector >(),
const bool  onlyLowerHalfSpace = false 
)

Definition at line 1674 of file bbcone.cc.

1675 {
1676  gfan::ZMatrix inequalities = zc.getFacets();
1677  gfan::ZMatrix equations = zc.getImpliedEquations();
1678  int r = inequalities.getHeight();
1679  int c = inequalities.getWidth();
1680 
1681  /* our cone has r facets, if r==0 return empty matrices */
1682  gfan::ZMatrix relativeInteriorPoints = gfan::ZMatrix(0,c);
1683  gfan::ZMatrix outerFacetNormals = gfan::ZMatrix(0,c);
1684  if (r==0)
1685  return std::make_pair(relativeInteriorPoints,outerFacetNormals);
1686 
1687  /* next we iterate over each of the r facets,
1688  * build the respective cone and add it to the list
1689  * this is the i=0 case */
1690  gfan::ZMatrix newInequalities = inequalities.submatrix(1,0,r,c);
1691  gfan::ZMatrix newEquations = equations;
1692  newEquations.appendRow(inequalities[0]);
1693  gfan::ZCone facet = gfan::ZCone(newInequalities,newEquations);
1694  gfan::ZVector interiorPoint = facet.getRelativeInteriorPoint();
1695  if (onlyLowerHalfSpace==false || interiorPoint[0].sign()<0)
1696  {
1697  if (exceptThesePoints.count(interiorPoint)==0)
1698  {
1699  relativeInteriorPoints.appendRow(interiorPoint);
1700  outerFacetNormals.appendRow(-inequalities[0]);
1701  }
1702  }
1703 
1704  /* these are the cases i=1,...,r-2 */
1705  for (int i=1; i<r-1; i++)
1706  {
1707  newInequalities = inequalities.submatrix(0,0,i,c);
1708  newInequalities.append(inequalities.submatrix(i+1,0,r,c));
1709  newEquations = equations;
1710  newEquations.appendRow(inequalities[i]);
1711  facet = gfan::ZCone(newInequalities,newEquations);
1712  interiorPoint = facet.getRelativeInteriorPoint();
1713  if (onlyLowerHalfSpace==false || interiorPoint[0].sign()<0)
1714  {
1715  if (exceptThesePoints.count(interiorPoint)==0)
1716  {
1717  relativeInteriorPoints.appendRow(interiorPoint);
1718  outerFacetNormals.appendRow(-inequalities[i]);
1719  }
1720  }
1721  }
1722 
1723  /* this is the i=r-1 case */
1724  newInequalities = inequalities.submatrix(0,0,r-1,c);
1725  newEquations = equations;
1726  newEquations.appendRow(inequalities[r-1]);
1727  facet = gfan::ZCone(newInequalities,newEquations);
1728  interiorPoint = facet.getRelativeInteriorPoint();
1729  if (onlyLowerHalfSpace==false || interiorPoint[0].sign()<0)
1730  {
1731  if (exceptThesePoints.count(interiorPoint)==0)
1732  {
1733  relativeInteriorPoints.appendRow(interiorPoint);
1734  outerFacetNormals.appendRow(-inequalities[r-1]);
1735  }
1736  }
1737 
1738  return std::make_pair(relativeInteriorPoints,outerFacetNormals);
1739 }
Definition: gfan.h:44
BOOLEAN inequalities(leftv res, leftv args)
Definition: bbcone.cc:527
const ring r
Definition: syzextra.cc:208
int i
Definition: cfEzgcd.cc:123
BOOLEAN equations(leftv res, leftv args)
Definition: bbcone.cc:543
int sign(const CanonicalForm &a)
gfan::ZMatrix interiorPointsOfFacets ( const gfan::ZCone &  zc,
const std::set< gfan::ZVector > &  exceptThese = std::set< gfan::ZVector >() 
)

Definition at line 1620 of file bbcone.cc.

1621 {
1622  gfan::ZMatrix inequalities = zc.getFacets();
1623  gfan::ZMatrix equations = zc.getImpliedEquations();
1624  int r = inequalities.getHeight();
1625  int c = inequalities.getWidth();
1626 
1627  /* our cone has r facets, if r==0 return empty matrices */
1628  gfan::ZMatrix relativeInteriorPoints = gfan::ZMatrix(0,c);
1629  if (r==0) return relativeInteriorPoints;
1630 
1631  /* next we iterate over each of the r facets,
1632  * build the respective cone and add it to the list
1633  * this is the i=0 case */
1634  gfan::ZMatrix newInequalities = inequalities.submatrix(1,0,r,c);
1635  gfan::ZMatrix newEquations = equations;
1636  newEquations.appendRow(inequalities[0]);
1637  gfan::ZCone facet = gfan::ZCone(newInequalities,newEquations);
1638  facet.canonicalize();
1639  gfan::ZVector interiorPoint = facet.getRelativeInteriorPoint();
1640  if (exceptThese.count(interiorPoint)==0)
1641  relativeInteriorPoints.appendRow(interiorPoint);
1642 
1643  /* these are the cases i=1,...,r-2 */
1644  for (int i=1; i<r-1; i++)
1645  {
1646  newInequalities = inequalities.submatrix(0,0,i,c);
1647  newInequalities.append(inequalities.submatrix(i+1,0,r,c));
1648  newEquations = equations;
1649  newEquations.appendRow(inequalities[i]);
1650  facet = gfan::ZCone(newInequalities,newEquations);
1651  facet.canonicalize();
1652  interiorPoint = facet.getRelativeInteriorPoint();
1653  if (exceptThese.count(interiorPoint)==0)
1654  relativeInteriorPoints.appendRow(interiorPoint);
1655  }
1656 
1657  /* this is the i=r-1 case */
1658  newInequalities = inequalities.submatrix(0,0,r-1,c);
1659  newEquations = equations;
1660  newEquations.appendRow(inequalities[r-1]);
1661  facet = gfan::ZCone(newInequalities,newEquations);
1662  facet.canonicalize();
1663  interiorPoint = facet.getRelativeInteriorPoint();
1664  if (exceptThese.count(interiorPoint)==0)
1665  relativeInteriorPoints.appendRow(interiorPoint);
1666 
1667  return relativeInteriorPoints;
1668 }
Definition: gfan.h:44
BOOLEAN inequalities(leftv res, leftv args)
Definition: bbcone.cc:527
const ring r
Definition: syzextra.cc:208
int i
Definition: cfEzgcd.cc:123
BOOLEAN equations(leftv res, leftv args)
Definition: bbcone.cc:543
gfan::ZCone liftUp ( const gfan::ZCone &  zc)

Definition at line 1056 of file bbcone.cc.

1057 {
1058  gfan::ZMatrix ineq=zc.getInequalities();
1059  gfan::ZMatrix eq=zc.getEquations();
1060  gfan::ZCone zd(liftUp(ineq),liftUp(eq));
1061  return zd;
1062 }
gfan::ZMatrix liftUp(const gfan::ZMatrix &zm)
Definition: bbcone.cc:1044
gfan::ZVector randomPoint ( const gfan::ZCone *  zc)

Definition at line 956 of file bbcone.cc.

957 {
958  gfan::ZVector rp = gfan::ZVector(zc->ambientDimension());
959 
960  gfan::ZMatrix rays = zc->extremeRays();
961  for (int i=0; i<rays.getHeight(); i++)
962  {
963  int n = siRand();
964  rp = rp + n * rays[i];
965  }
966 
967  gfan::ZMatrix lins = zc->generatorsOfLinealitySpace();
968  for (int i=0; i<lins.getHeight(); i++)
969  {
970  int n = siRand();
971  rp = rp + n * lins[i];
972  }
973 
974  return rp;
975 }
int i
Definition: cfEzgcd.cc:123
BOOLEAN rays(leftv res, leftv args)
Definition: bbcone.cc:618
int siRand()
Definition: sirandom.c:41
std::string toString ( const gfan::ZCone *const  c)

Definition at line 26 of file bbcone.cc.

27 {
28  std::stringstream s;
29  s<<"AMBIENT_DIM"<<std::endl;
30  s<<c->ambientDimension()<<std::endl;
31 
32  gfan::ZMatrix i=c->getInequalities();
33  char* ineqs = toString(i);
34  if (c->areFacetsKnown())
35  s<<"FACETS"<<std::endl;
36  else
37  s<<"INEQUALITIES"<<std::endl;
38  if (ineqs!=NULL)
39  {
40  s<<ineqs<<std::endl;
41  omFree(ineqs);
42  }
43 
44  gfan::ZMatrix e=c->getEquations();
45  char* eqs = toString(e);
46  if (c->areImpliedEquationsKnown())
47  s<<"LINEAR_SPAN"<<std::endl;
48  else
49  s<<"EQUATIONS"<<std::endl;
50  if (eqs!=NULL)
51  {
52  s<<eqs<<std::endl;
53  omFree(eqs);
54  }
55 
56  if (c->areExtremeRaysKnown())
57  {
58  gfan::ZMatrix r=c->extremeRays();
59  char* rs = toString(r);
60  s<<"RAYS"<<std::endl;
61  if (rs!=NULL)
62  {
63  s<<rs<<std::endl;
64  omFree(rs);
65  }
66  gfan::ZMatrix l=c->generatorsOfLinealitySpace();
67  char* ls = toString(l);
68  s<<"LINEALITY_SPACE"<<std::endl;
69  if (ls!=NULL)
70  {
71  s<<ls<<std::endl;
72  omFree(ls);
73  }
74  }
75 
76  return s.str();
77 }
const CanonicalForm int s
Definition: facAbsFact.cc:55
const ring r
Definition: syzextra.cc:208
#define omFree(addr)
Definition: omAllocDecl.h:261
int i
Definition: cfEzgcd.cc:123
#define NULL
Definition: omList.c:10
std::string toString(const gfan::ZCone *const c)
Definition: bbcone.cc:26
int l
Definition: cfEzgcd.cc:94

Variable Documentation

int coneID

Definition at line 24 of file bbcone.cc.