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

1874 {
1875  blackbox *b=(blackbox*)omAlloc0(sizeof(blackbox));
1876  // all undefined entries will be set to default in setBlackboxStuff
1877  // the default Print is quite usefull,
1878  // all other are simply error messages
1879  b->blackbox_destroy=bbcone_destroy;
1880  b->blackbox_String=bbcone_String;
1881  // b->blackbox_Print=blackbox_default_Print;
1882  b->blackbox_Init=bbcone_Init;
1883  b->blackbox_Copy=bbcone_Copy;
1884  b->blackbox_Assign=bbcone_Assign;
1885  b->blackbox_Op2=bbcone_Op2;
1886  b->blackbox_serialize=bbcone_serialize;
1887  b->blackbox_deserialize=bbcone_deserialize;
1888  p->iiAddCproc("","coneViaInequalities",FALSE,coneViaNormals);
1889  p->iiAddCproc("","coneViaPoints",FALSE,coneViaRays);
1890 
1891  // iiAddCproc("","makePolytope",FALSE,coneToPolytope);
1892  p->iiAddCproc("","ambientDimension",FALSE,ambientDimension);
1893  p->iiAddCproc("","canonicalizeCone",FALSE,canonicalizeCone);
1894  p->iiAddCproc("","codimension",FALSE,codimension);
1895  p->iiAddCproc("","coneLink",FALSE,coneLink);
1896  p->iiAddCproc("","containsAsFace",FALSE,hasFace);
1897  p->iiAddCproc("","containsInSupport",FALSE,containsInSupport);
1898  p->iiAddCproc("","containsPositiveVector",FALSE,containsPositiveVector);
1899  p->iiAddCproc("","containsRelatively",FALSE,containsRelatively);
1900  p->iiAddCproc("","convexHull",FALSE,convexHull);
1901  p->iiAddCproc("","convexIntersection",FALSE,intersectCones);
1902  p->iiAddCproc("","dimension",FALSE,dimension);
1903  p->iiAddCproc("","dualCone",FALSE,dualCone);
1904  p->iiAddCproc("","equations",FALSE,equations);
1905  p->iiAddCproc("","facets",FALSE,facets);
1906  p->iiAddCproc("","generatorsOfLinealitySpace",FALSE,generatorsOfLinealitySpace);
1907  p->iiAddCproc("","generatorsOfSpan",FALSE,generatorsOfSpan);
1908  p->iiAddCproc("","getLinearForms",FALSE,getLinearForms);
1909  p->iiAddCproc("","getMultiplicity",FALSE,getMultiplicity);
1910  p->iiAddCproc("","inequalities",FALSE,inequalities);
1911  p->iiAddCproc("","isFullSpace",FALSE,isFullSpace);
1912  p->iiAddCproc("","isOrigin",FALSE,isOrigin);
1913  p->iiAddCproc("","isSimplicial",FALSE,isSimplicial);
1914  p->iiAddCproc("","linealityDimension",FALSE,linealityDimension);
1915  p->iiAddCproc("","linealitySpace",FALSE,linealitySpace);
1916  p->iiAddCproc("","negatedCone",FALSE,negatedCone);
1917  p->iiAddCproc("","quotientLatticeBasis",FALSE,quotientLatticeBasis);
1918  p->iiAddCproc("","randomPoint",FALSE,randomPoint);
1919  p->iiAddCproc("","rays",FALSE,rays);
1920  p->iiAddCproc("","relativeInteriorPoint",FALSE,relativeInteriorPoint);
1921  p->iiAddCproc("","semigroupGenerator",FALSE,semigroupGenerator);
1922  p->iiAddCproc("","setLinearForms",FALSE,setLinearForms);
1923  p->iiAddCproc("","setMultiplicity",FALSE,setMultiplicity);
1924  p->iiAddCproc("","span",FALSE,impliedEquations);
1925  p->iiAddCproc("","uniquePoint",FALSE,uniquePoint);
1926  p->iiAddCproc("","listContainsCone",FALSE,containsCone);
1927  p->iiAddCproc("","listOfFacets",FALSE,listOfFacets);
1928  p->iiAddCproc("","facetContaining",FALSE,facetContaining);
1929  coneID=setBlackboxStuff(b,"cone");
1930 }
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:1856
#define FALSE
Definition: auxiliary.h:97
BOOLEAN quotientLatticeBasis(leftv res, leftv args)
Definition: bbcone.cc:652
BOOLEAN generatorsOfSpan(leftv res, leftv args)
Definition: bbcone.cc:596
gfan::ZVector * facetContaining(gfan::ZCone *zc, gfan::ZVector *zv)
Definition: bbcone.cc:1608
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:1807
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
lists listOfFacets(const gfan::ZCone &zc)
Definition: bbcone.cc:1546
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 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:124
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 1716 of file bbcone.cc.

1717 {
1718  gfan::ZMatrix inequalities = zc.getFacets();
1719  gfan::ZMatrix equations = zc.getImpliedEquations();
1720  int r = inequalities.getHeight();
1721  int c = inequalities.getWidth();
1722 
1723  /* our cone has r facets, if r==0 return empty matrices */
1724  gfan::ZMatrix relativeInteriorPoints = gfan::ZMatrix(0,c);
1725  gfan::ZMatrix outerFacetNormals = gfan::ZMatrix(0,c);
1726  if (r==0)
1727  return std::make_pair(relativeInteriorPoints,outerFacetNormals);
1728 
1729  /* next we iterate over each of the r facets,
1730  * build the respective cone and add it to the list
1731  * this is the i=0 case */
1732  gfan::ZMatrix newInequalities = inequalities.submatrix(1,0,r,c);
1733  gfan::ZMatrix newEquations = equations;
1734  newEquations.appendRow(inequalities[0]);
1735  gfan::ZCone facet = gfan::ZCone(newInequalities,newEquations);
1736  gfan::ZVector interiorPoint = facet.getRelativeInteriorPoint();
1737  if (onlyLowerHalfSpace==false || interiorPoint[0].sign()<0)
1738  {
1739  if (exceptThesePoints.count(interiorPoint)==0)
1740  {
1741  relativeInteriorPoints.appendRow(interiorPoint);
1742  outerFacetNormals.appendRow(-inequalities[0].toVector());
1743  }
1744  }
1745 
1746  /* these are the cases i=1,...,r-2 */
1747  for (int i=1; i<r-1; i++)
1748  {
1749  newInequalities = inequalities.submatrix(0,0,i,c);
1750  newInequalities.append(inequalities.submatrix(i+1,0,r,c));
1751  newEquations = equations;
1752  newEquations.appendRow(inequalities[i]);
1753  facet = gfan::ZCone(newInequalities,newEquations);
1754  interiorPoint = facet.getRelativeInteriorPoint();
1755  if (onlyLowerHalfSpace==false || interiorPoint[0].sign()<0)
1756  {
1757  if (exceptThesePoints.count(interiorPoint)==0)
1758  {
1759  relativeInteriorPoints.appendRow(interiorPoint);
1760  outerFacetNormals.appendRow(-inequalities[i].toVector());
1761  }
1762  }
1763  }
1764 
1765  /* this is the i=r-1 case */
1766  newInequalities = inequalities.submatrix(0,0,r-1,c);
1767  newEquations = equations;
1768  newEquations.appendRow(inequalities[r-1]);
1769  facet = gfan::ZCone(newInequalities,newEquations);
1770  interiorPoint = facet.getRelativeInteriorPoint();
1771  if (onlyLowerHalfSpace==false || interiorPoint[0].sign()<0)
1772  {
1773  if (exceptThesePoints.count(interiorPoint)==0)
1774  {
1775  relativeInteriorPoints.appendRow(interiorPoint);
1776  outerFacetNormals.appendRow(-inequalities[r-1].toVector());
1777  }
1778  }
1779 
1780  return std::make_pair(relativeInteriorPoints,outerFacetNormals);
1781 }
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:3412

§ interiorPointsOfFacets()

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

Definition at line 1662 of file bbcone.cc.

1663 {
1664  gfan::ZMatrix inequalities = zc.getFacets();
1665  gfan::ZMatrix equations = zc.getImpliedEquations();
1666  int r = inequalities.getHeight();
1667  int c = inequalities.getWidth();
1668 
1669  /* our cone has r facets, if r==0 return empty matrices */
1670  gfan::ZMatrix relativeInteriorPoints = gfan::ZMatrix(0,c);
1671  if (r==0) return relativeInteriorPoints;
1672 
1673  /* next we iterate over each of the r facets,
1674  * build the respective cone and add it to the list
1675  * this is the i=0 case */
1676  gfan::ZMatrix newInequalities = inequalities.submatrix(1,0,r,c);
1677  gfan::ZMatrix newEquations = equations;
1678  newEquations.appendRow(inequalities[0]);
1679  gfan::ZCone facet = gfan::ZCone(newInequalities,newEquations);
1680  facet.canonicalize();
1681  gfan::ZVector interiorPoint = facet.getRelativeInteriorPoint();
1682  if (exceptThese.count(interiorPoint)==0)
1683  relativeInteriorPoints.appendRow(interiorPoint);
1684 
1685  /* these are the cases i=1,...,r-2 */
1686  for (int i=1; i<r-1; i++)
1687  {
1688  newInequalities = inequalities.submatrix(0,0,i,c);
1689  newInequalities.append(inequalities.submatrix(i+1,0,r,c));
1690  newEquations = equations;
1691  newEquations.appendRow(inequalities[i]);
1692  facet = gfan::ZCone(newInequalities,newEquations);
1693  facet.canonicalize();
1694  interiorPoint = facet.getRelativeInteriorPoint();
1695  if (exceptThese.count(interiorPoint)==0)
1696  relativeInteriorPoints.appendRow(interiorPoint);
1697  }
1698 
1699  /* this is the i=r-1 case */
1700  newInequalities = inequalities.submatrix(0,0,r-1,c);
1701  newEquations = equations;
1702  newEquations.appendRow(inequalities[r-1]);
1703  facet = gfan::ZCone(newInequalities,newEquations);
1704  facet.canonicalize();
1705  interiorPoint = facet.getRelativeInteriorPoint();
1706  if (exceptThese.count(interiorPoint)==0)
1707  relativeInteriorPoints.appendRow(interiorPoint);
1708 
1709  return relativeInteriorPoints;
1710 }
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.