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

§ bbcone_setup()

void bbcone_setup ( SModulFunctions p)

Definition at line 1799 of file bbcone.cc.

1800 {
1801  blackbox *b=(blackbox*)omAlloc0(sizeof(blackbox));
1802  // all undefined entries will be set to default in setBlackboxStuff
1803  // the default Print is quite usefull,
1804  // all other are simply error messages
1805  b->blackbox_destroy=bbcone_destroy;
1806  b->blackbox_String=bbcone_String;
1807  // b->blackbox_Print=blackbox_default_Print;
1808  b->blackbox_Init=bbcone_Init;
1809  b->blackbox_Copy=bbcone_Copy;
1810  b->blackbox_Assign=bbcone_Assign;
1811  b->blackbox_Op2=bbcone_Op2;
1812  b->blackbox_serialize=bbcone_serialize;
1813  b->blackbox_deserialize=bbcone_deserialize;
1814  p->iiAddCproc("gfan.lib","coneViaInequalities",FALSE,coneViaNormals);
1815  p->iiAddCproc("gfan.lib","coneViaPoints",FALSE,coneViaRays);
1816  p->iiAddCproc("","listContainsCone",FALSE,containsCone);
1817  // iiAddCproc("gfan.lib","makePolytope",FALSE,coneToPolytope);
1818  p->iiAddCproc("gfan.lib","ambientDimension",FALSE,ambientDimension);
1819  p->iiAddCproc("gfan.lib","canonicalizeCone",FALSE,canonicalizeCone);
1820  p->iiAddCproc("gfan.lib","codimension",FALSE,codimension);
1821  p->iiAddCproc("gfan.lib","coneLink",FALSE,coneLink);
1822  p->iiAddCproc("gfan.lib","containsAsFace",FALSE,hasFace);
1823  p->iiAddCproc("gfan.lib","containsInSupport",FALSE,containsInSupport);
1824  p->iiAddCproc("gfan.lib","containsPositiveVector",FALSE,containsPositiveVector);
1825  p->iiAddCproc("gfan.lib","containsRelatively",FALSE,containsRelatively);
1826  p->iiAddCproc("gfan.lib","convexHull",FALSE,convexHull);
1827  p->iiAddCproc("gfan.lib","convexIntersection",FALSE,intersectCones);
1828  p->iiAddCproc("gfan.lib","dimension",FALSE,dimension);
1829  p->iiAddCproc("gfan.lib","dualCone",FALSE,dualCone);
1830  p->iiAddCproc("gfan.lib","equations",FALSE,equations);
1831  p->iiAddCproc("gfan.lib","facets",FALSE,facets);
1832  p->iiAddCproc("gfan.lib","generatorsOfLinealitySpace",FALSE,generatorsOfLinealitySpace);
1833  p->iiAddCproc("gfan.lib","generatorsOfSpan",FALSE,generatorsOfSpan);
1834  p->iiAddCproc("gfan.lib","getLinearForms",FALSE,getLinearForms);
1835  p->iiAddCproc("gfan.lib","getMultiplicity",FALSE,getMultiplicity);
1836  p->iiAddCproc("gfan.lib","inequalities",FALSE,inequalities);
1837  p->iiAddCproc("gfan.lib","isFullSpace",FALSE,isFullSpace);
1838  p->iiAddCproc("gfan.lib","isOrigin",FALSE,isOrigin);
1839  p->iiAddCproc("gfan.lib","isSimplicial",FALSE,isSimplicial);
1840  p->iiAddCproc("gfan.lib","linealityDimension",FALSE,linealityDimension);
1841  p->iiAddCproc("gfan.lib","linealitySpace",FALSE,linealitySpace);
1842  p->iiAddCproc("gfan.lib","negatedCone",FALSE,negatedCone);
1843  p->iiAddCproc("gfan.lib","quotientLatticeBasis",FALSE,quotientLatticeBasis);
1844  p->iiAddCproc("gfan.lib","randomPoint",FALSE,randomPoint);
1845  p->iiAddCproc("gfan.lib","rays",FALSE,rays);
1846  p->iiAddCproc("gfan.lib","relativeInteriorPoint",FALSE,relativeInteriorPoint);
1847  p->iiAddCproc("gfan.lib","semigroupGenerator",FALSE,semigroupGenerator);
1848  p->iiAddCproc("gfan.lib","setLinearForms",FALSE,setLinearForms);
1849  p->iiAddCproc("gfan.lib","setMultiplicity",FALSE,setMultiplicity);
1850  p->iiAddCproc("gfan.lib","span",FALSE,impliedEquations);
1851  p->iiAddCproc("gfan.lib","uniquePoint",FALSE,uniquePoint);
1852  p->iiAddCproc("gfan.lib","faceContaining",FALSE,faceContaining);
1853  coneID=setBlackboxStuff(b,"cone");
1854 }
BOOLEAN isFullSpace(leftv res, leftv args)
Definition: bbcone.cc:825
BOOLEAN coneViaNormals(leftv res, leftv args)
Definition: bbcone.cc:353
BOOLEAN getMultiplicity(leftv res, leftv args)
Definition: bbcone.cc:793
BOOLEAN dualCone(leftv res, leftv args)
Definition: bbcone.cc:897
BOOLEAN containsPositiveVector(leftv res, leftv args)
Definition: bbcone.cc:865
BOOLEAN containsRelatively(leftv res, leftv args)
Definition: bbcone.cc:1415
BOOLEAN canonicalizeCone(leftv res, leftv args)
Definition: bbcone.cc:1491
BOOLEAN bbcone_deserialize(blackbox **b, void **d, si_link f)
Definition: bbcone.cc:1782
#define FALSE
Definition: auxiliary.h:94
BOOLEAN quotientLatticeBasis(leftv res, leftv args)
Definition: bbcone.cc:652
BOOLEAN generatorsOfSpan(leftv res, leftv args)
Definition: bbcone.cc:596
BOOLEAN coneViaRays(leftv res, leftv args)
Definition: bbcone.cc:509
BOOLEAN containsInSupport(leftv res, leftv args)
Definition: bbcone.cc:1356
static BOOLEAN bbcone_Op2(int op, leftv res, leftv i1, leftv i2)
Definition: bbcone.cc:165
gfan::ZVector randomPoint(const gfan::ZCone *zc)
Definition: bbcone.cc:984
BOOLEAN bbcone_serialize(blackbox *b, void *d, si_link f)
Definition: bbcone.cc:1733
BOOLEAN inequalities(leftv res, leftv args)
Definition: bbcone.cc:531
BOOLEAN linealitySpace(leftv res, leftv args)
Definition: bbcone.cc:881
BOOLEAN relativeInteriorPoint(leftv res, leftv args)
Definition: bbcone.cc:952
BOOLEAN semigroupGenerator(leftv res, leftv args)
Definition: bbcone.cc:929
BOOLEAN isSimplicial(leftv res, leftv args)
Definition: bbcone.cc:841
BOOLEAN codimension(leftv res, leftv args)
Definition: bbcone.cc:742
BOOLEAN coneLink(leftv res, leftv args)
Definition: bbcone.cc:1310
BOOLEAN negatedCone(leftv res, leftv args)
Definition: bbcone.cc:913
BOOLEAN getLinearForms(leftv res, leftv args)
Definition: bbcone.cc:668
int coneID
Definition: bbcone.cc:26
BOOLEAN rays(leftv res, leftv args)
Definition: bbcone.cc:628
void bbcone_destroy(blackbox *, void *d)
Definition: bbcone.cc:149
BOOLEAN dimension(leftv res, leftv args)
Definition: bbcone.cc:713
void * bbcone_Init(blackbox *)
Definition: bbcone.cc:81
BOOLEAN containsCone(leftv res, leftv args)
Definition: bbcone.cc:1508
BOOLEAN uniquePoint(leftv res, leftv args)
Definition: bbcone.cc:968
BOOLEAN equations(leftv res, leftv args)
Definition: bbcone.cc:548
BOOLEAN facets(leftv res, leftv args)
Definition: bbcone.cc:564
BOOLEAN setLinearForms(leftv res, leftv args)
Definition: bbcone.cc:1042
BOOLEAN ambientDimension(leftv res, leftv args)
Definition: bbcone.cc:684
char * bbcone_String(blackbox *, void *d)
Definition: bbcone.cc:139
BOOLEAN isOrigin(leftv res, leftv args)
Definition: bbcone.cc:809
BOOLEAN bbcone_Assign(leftv l, leftv r)
Definition: bbcone.cc:86
BOOLEAN faceContaining(leftv res, leftv args)
Definition: bbcone.cc:1545
BOOLEAN linealityDimension(leftv res, leftv args)
Definition: bbcone.cc:771
int(* iiAddCproc)(const char *libname, const char *procname, BOOLEAN pstatic, BOOLEAN(*func)(leftv res, leftv v))
Definition: ipid.h:71
BOOLEAN generatorsOfLinealitySpace(leftv res, leftv args)
Definition: bbcone.cc:612
BOOLEAN impliedEquations(leftv res, leftv args)
Definition: bbcone.cc:580
BOOLEAN hasFace(leftv res, leftv args)
Definition: bbcone.cc:1457
BOOLEAN intersectCones(leftv res, leftv args)
Definition: bbcone.cc:1113
int setBlackboxStuff(blackbox *bb, const char *n)
define a new type
Definition: blackbox.cc:126
const poly b
Definition: syzextra.cc:213
void * bbcone_Copy(blackbox *, void *d)
Definition: bbcone.cc:158
#define omAlloc0(size)
Definition: omAllocDecl.h:211
BOOLEAN setMultiplicity(leftv res, leftv args)
Definition: bbcone.cc:1021

§ interiorPointsAndNormalsOfFacets()

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 1642 of file bbcone.cc.

1643 {
1644  gfan::ZMatrix inequalities = zc.getFacets();
1645  gfan::ZMatrix equations = zc.getImpliedEquations();
1646  int r = inequalities.getHeight();
1647  int c = inequalities.getWidth();
1648 
1649  /* our cone has r facets, if r==0 return empty matrices */
1650  gfan::ZMatrix relativeInteriorPoints = gfan::ZMatrix(0,c);
1651  gfan::ZMatrix outerFacetNormals = gfan::ZMatrix(0,c);
1652  if (r==0)
1653  return std::make_pair(relativeInteriorPoints,outerFacetNormals);
1654 
1655  /* next we iterate over each of the r facets,
1656  * build the respective cone and add it to the list
1657  * this is the i=0 case */
1658  gfan::ZMatrix newInequalities = inequalities.submatrix(1,0,r,c);
1659  gfan::ZMatrix newEquations = equations;
1660  newEquations.appendRow(inequalities[0]);
1661  gfan::ZCone facet = gfan::ZCone(newInequalities,newEquations);
1662  gfan::ZVector interiorPoint = facet.getRelativeInteriorPoint();
1663  if (onlyLowerHalfSpace==false || interiorPoint[0].sign()<0)
1664  {
1665  if (exceptThesePoints.count(interiorPoint)==0)
1666  {
1667  relativeInteriorPoints.appendRow(interiorPoint);
1668  outerFacetNormals.appendRow(-inequalities[0].toVector());
1669  }
1670  }
1671 
1672  /* these are the cases i=1,...,r-2 */
1673  for (int i=1; i<r-1; i++)
1674  {
1675  newInequalities = inequalities.submatrix(0,0,i,c);
1676  newInequalities.append(inequalities.submatrix(i+1,0,r,c));
1677  newEquations = equations;
1678  newEquations.appendRow(inequalities[i]);
1679  facet = gfan::ZCone(newInequalities,newEquations);
1680  interiorPoint = facet.getRelativeInteriorPoint();
1681  if (onlyLowerHalfSpace==false || interiorPoint[0].sign()<0)
1682  {
1683  if (exceptThesePoints.count(interiorPoint)==0)
1684  {
1685  relativeInteriorPoints.appendRow(interiorPoint);
1686  outerFacetNormals.appendRow(-inequalities[i].toVector());
1687  }
1688  }
1689  }
1690 
1691  /* this is the i=r-1 case */
1692  newInequalities = inequalities.submatrix(0,0,r-1,c);
1693  newEquations = equations;
1694  newEquations.appendRow(inequalities[r-1]);
1695  facet = gfan::ZCone(newInequalities,newEquations);
1696  interiorPoint = facet.getRelativeInteriorPoint();
1697  if (onlyLowerHalfSpace==false || interiorPoint[0].sign()<0)
1698  {
1699  if (exceptThesePoints.count(interiorPoint)==0)
1700  {
1701  relativeInteriorPoints.appendRow(interiorPoint);
1702  outerFacetNormals.appendRow(-inequalities[r-1].toVector());
1703  }
1704  }
1705 
1706  return std::make_pair(relativeInteriorPoints,outerFacetNormals);
1707 }
Definition: gfan.h:44
BOOLEAN inequalities(leftv res, leftv args)
Definition: bbcone.cc:531
const ring r
Definition: syzextra.cc:208
int i
Definition: cfEzgcd.cc:123
BOOLEAN equations(leftv res, leftv args)
Definition: bbcone.cc:548
static int sign(int x)
Definition: ring.cc:3328

§ interiorPointsOfFacets()

gfan::ZMatrix interiorPointsOfFacets ( const gfan::ZCone &  zc,
const std::set< gfan::ZVector > &  exceptThese = std::set< gfan::ZVector >() 
)

Definition at line 1588 of file bbcone.cc.

1589 {
1590  gfan::ZMatrix inequalities = zc.getFacets();
1591  gfan::ZMatrix equations = zc.getImpliedEquations();
1592  int r = inequalities.getHeight();
1593  int c = inequalities.getWidth();
1594 
1595  /* our cone has r facets, if r==0 return empty matrices */
1596  gfan::ZMatrix relativeInteriorPoints = gfan::ZMatrix(0,c);
1597  if (r==0) return relativeInteriorPoints;
1598 
1599  /* next we iterate over each of the r facets,
1600  * build the respective cone and add it to the list
1601  * this is the i=0 case */
1602  gfan::ZMatrix newInequalities = inequalities.submatrix(1,0,r,c);
1603  gfan::ZMatrix newEquations = equations;
1604  newEquations.appendRow(inequalities[0]);
1605  gfan::ZCone facet = gfan::ZCone(newInequalities,newEquations);
1606  facet.canonicalize();
1607  gfan::ZVector interiorPoint = facet.getRelativeInteriorPoint();
1608  if (exceptThese.count(interiorPoint)==0)
1609  relativeInteriorPoints.appendRow(interiorPoint);
1610 
1611  /* these are the cases i=1,...,r-2 */
1612  for (int i=1; i<r-1; i++)
1613  {
1614  newInequalities = inequalities.submatrix(0,0,i,c);
1615  newInequalities.append(inequalities.submatrix(i+1,0,r,c));
1616  newEquations = equations;
1617  newEquations.appendRow(inequalities[i]);
1618  facet = gfan::ZCone(newInequalities,newEquations);
1619  facet.canonicalize();
1620  interiorPoint = facet.getRelativeInteriorPoint();
1621  if (exceptThese.count(interiorPoint)==0)
1622  relativeInteriorPoints.appendRow(interiorPoint);
1623  }
1624 
1625  /* this is the i=r-1 case */
1626  newInequalities = inequalities.submatrix(0,0,r-1,c);
1627  newEquations = equations;
1628  newEquations.appendRow(inequalities[r-1]);
1629  facet = gfan::ZCone(newInequalities,newEquations);
1630  facet.canonicalize();
1631  interiorPoint = facet.getRelativeInteriorPoint();
1632  if (exceptThese.count(interiorPoint)==0)
1633  relativeInteriorPoints.appendRow(interiorPoint);
1634 
1635  return relativeInteriorPoints;
1636 }
Definition: gfan.h:44
BOOLEAN inequalities(leftv res, leftv args)
Definition: bbcone.cc:531
const ring r
Definition: syzextra.cc:208
int i
Definition: cfEzgcd.cc:123
BOOLEAN equations(leftv res, leftv args)
Definition: bbcone.cc:548

§ liftUp()

gfan::ZCone liftUp ( const gfan::ZCone &  zc)

Definition at line 1087 of file bbcone.cc.

1088 {
1089  gfan::ZMatrix ineq=zc.getInequalities();
1090  gfan::ZMatrix eq=zc.getEquations();
1091  gfan::ZCone zd(liftUp(ineq),liftUp(eq));
1092  return zd;
1093 }
gfan::ZMatrix liftUp(const gfan::ZMatrix &zm)
Definition: bbcone.cc:1075

§ randomPoint()

gfan::ZVector randomPoint ( const gfan::ZCone *  zc)

Definition at line 984 of file bbcone.cc.

985 {
986  gfan::ZVector rp = gfan::ZVector(zc->ambientDimension());
987 
988  gfan::ZMatrix rays = zc->extremeRays();
989  for (int i=0; i<rays.getHeight(); i++)
990  {
991  int n = siRand();
992  rp = rp + n * rays[i].toVector();
993  }
994 
995  gfan::ZMatrix lins = zc->generatorsOfLinealitySpace();
996  for (int i=0; i<lins.getHeight(); i++)
997  {
998  int n = siRand();
999  rp = rp + n * lins[i].toVector();
1000  }
1001 
1002  return rp;
1003 }
int i
Definition: cfEzgcd.cc:123
BOOLEAN rays(leftv res, leftv args)
Definition: bbcone.cc:628
int siRand()
Definition: sirandom.c:41

§ toString()

std::string toString ( const gfan::ZCone *const  c)

Definition at line 28 of file bbcone.cc.

29 {
30  std::stringstream s;
31  s<<"AMBIENT_DIM"<<std::endl;
32  s<<c->ambientDimension()<<std::endl;
33 
34  gfan::ZMatrix i=c->getInequalities();
35  char* ineqs = toString(i);
36  if (c->areFacetsKnown())
37  s<<"FACETS"<<std::endl;
38  else
39  s<<"INEQUALITIES"<<std::endl;
40  if (ineqs!=NULL)
41  {
42  s<<ineqs<<std::endl;
43  omFree(ineqs);
44  }
45 
46  gfan::ZMatrix e=c->getEquations();
47  char* eqs = toString(e);
48  if (c->areImpliedEquationsKnown())
49  s<<"LINEAR_SPAN"<<std::endl;
50  else
51  s<<"EQUATIONS"<<std::endl;
52  if (eqs!=NULL)
53  {
54  s<<eqs<<std::endl;
55  omFree(eqs);
56  }
57 
58  if (c->areExtremeRaysKnown())
59  {
60  gfan::ZMatrix r=c->extremeRays();
61  char* rs = toString(r);
62  s<<"RAYS"<<std::endl;
63  if (rs!=NULL)
64  {
65  s<<rs<<std::endl;
66  omFree(rs);
67  }
68  gfan::ZMatrix l=c->generatorsOfLinealitySpace();
69  char* ls = toString(l);
70  s<<"LINEALITY_SPACE"<<std::endl;
71  if (ls!=NULL)
72  {
73  s<<ls<<std::endl;
74  omFree(ls);
75  }
76  }
77 
78  return s.str();
79 }
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:28
int l
Definition: cfEzgcd.cc:94

Variable Documentation

§ coneID

int coneID

Definition at line 26 of file bbcone.cc.