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

1834 {
1835  blackbox *b=(blackbox*)omAlloc0(sizeof(blackbox));
1836  // all undefined entries will be set to default in setBlackboxStuff
1837  // the default Print is quite usefull,
1838  // all other are simply error messages
1839  b->blackbox_destroy=bbcone_destroy;
1840  b->blackbox_String=bbcone_String;
1841  // b->blackbox_Print=blackbox_default_Print;
1842  b->blackbox_Init=bbcone_Init;
1843  b->blackbox_Copy=bbcone_Copy;
1844  b->blackbox_Assign=bbcone_Assign;
1845  b->blackbox_Op2=bbcone_Op2;
1846  b->blackbox_serialize=bbcone_serialize;
1847  b->blackbox_deserialize=bbcone_deserialize;
1848  p->iiAddCproc("","coneViaInequalities",FALSE,coneViaNormals);
1849  p->iiAddCproc("","coneViaPoints",FALSE,coneViaRays);
1850 
1851  // iiAddCproc("","makePolytope",FALSE,coneToPolytope);
1852  p->iiAddCproc("","ambientDimension",FALSE,ambientDimension);
1853  p->iiAddCproc("","canonicalizeCone",FALSE,canonicalizeCone);
1854  p->iiAddCproc("","codimension",FALSE,codimension);
1855  p->iiAddCproc("","coneLink",FALSE,coneLink);
1856  p->iiAddCproc("","containsAsFace",FALSE,hasFace);
1857  p->iiAddCproc("","containsInSupport",FALSE,containsInSupport);
1858  p->iiAddCproc("","containsPositiveVector",FALSE,containsPositiveVector);
1859  p->iiAddCproc("","containsRelatively",FALSE,containsRelatively);
1860  p->iiAddCproc("","convexHull",FALSE,convexHull);
1861  p->iiAddCproc("","convexIntersection",FALSE,intersectCones);
1862  p->iiAddCproc("","dimension",FALSE,dimension);
1863  p->iiAddCproc("","dualCone",FALSE,dualCone);
1864  p->iiAddCproc("","equations",FALSE,equations);
1865  p->iiAddCproc("","facets",FALSE,facets);
1866  p->iiAddCproc("","generatorsOfLinealitySpace",FALSE,generatorsOfLinealitySpace);
1867  p->iiAddCproc("","generatorsOfSpan",FALSE,generatorsOfSpan);
1868  p->iiAddCproc("","getLinearForms",FALSE,getLinearForms);
1869  p->iiAddCproc("","getMultiplicity",FALSE,getMultiplicity);
1870  p->iiAddCproc("","inequalities",FALSE,inequalities);
1871  p->iiAddCproc("","isFullSpace",FALSE,isFullSpace);
1872  p->iiAddCproc("","isOrigin",FALSE,isOrigin);
1873  p->iiAddCproc("","isSimplicial",FALSE,isSimplicial);
1874  p->iiAddCproc("","linealityDimension",FALSE,linealityDimension);
1875  p->iiAddCproc("","linealitySpace",FALSE,linealitySpace);
1876  p->iiAddCproc("","negatedCone",FALSE,negatedCone);
1877  p->iiAddCproc("","quotientLatticeBasis",FALSE,quotientLatticeBasis);
1878  p->iiAddCproc("","randomPoint",FALSE,randomPoint);
1879  p->iiAddCproc("","rays",FALSE,rays);
1880  p->iiAddCproc("","relativeInteriorPoint",FALSE,relativeInteriorPoint);
1881  p->iiAddCproc("","semigroupGenerator",FALSE,semigroupGenerator);
1882  p->iiAddCproc("","setLinearForms",FALSE,setLinearForms);
1883  p->iiAddCproc("","setMultiplicity",FALSE,setMultiplicity);
1884  p->iiAddCproc("","span",FALSE,impliedEquations);
1885  p->iiAddCproc("","uniquePoint",FALSE,uniquePoint);
1886  p->iiAddCproc("","listContainsCone",FALSE,containsCone);
1887  p->iiAddCproc("","listOfFacets",FALSE,listOfFacets);
1888  p->iiAddCproc("","facetContaining",FALSE,facetContaining);
1889  coneID=setBlackboxStuff(b,"cone");
1890 }
BOOLEAN isFullSpace(leftv res, leftv args)
Definition: bbcone.cc:808
BOOLEAN coneViaNormals(leftv res, leftv args)
Definition: bbcone.cc:353
BOOLEAN getMultiplicity(leftv res, leftv args)
Definition: bbcone.cc:778
BOOLEAN dualCone(leftv res, leftv args)
Definition: bbcone.cc:876
BOOLEAN containsPositiveVector(leftv res, leftv args)
Definition: bbcone.cc:846
BOOLEAN containsRelatively(leftv res, leftv args)
Definition: bbcone.cc:1381
BOOLEAN canonicalizeCone(leftv res, leftv args)
Definition: bbcone.cc:1455
BOOLEAN bbcone_deserialize(blackbox **b, void **d, si_link f)
Definition: bbcone.cc:1816
#define FALSE
Definition: auxiliary.h:140
BOOLEAN quotientLatticeBasis(leftv res, leftv args)
Definition: bbcone.cc:643
BOOLEAN generatorsOfSpan(leftv res, leftv args)
Definition: bbcone.cc:590
gfan::ZVector * facetContaining(gfan::ZCone *zc, gfan::ZVector *zv)
Definition: bbcone.cc:1569
BOOLEAN coneViaRays(leftv res, leftv args)
Definition: bbcone.cc:508
BOOLEAN containsInSupport(leftv res, leftv args)
Definition: bbcone.cc:1323
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:958
BOOLEAN bbcone_serialize(blackbox *b, void *d, si_link f)
Definition: bbcone.cc:1767
BOOLEAN inequalities(leftv res, leftv args)
Definition: bbcone.cc:529
BOOLEAN linealitySpace(leftv res, leftv args)
Definition: bbcone.cc:861
BOOLEAN relativeInteriorPoint(leftv res, leftv args)
Definition: bbcone.cc:928
BOOLEAN semigroupGenerator(leftv res, leftv args)
Definition: bbcone.cc:906
BOOLEAN isSimplicial(leftv res, leftv args)
Definition: bbcone.cc:823
BOOLEAN codimension(leftv res, leftv args)
Definition: bbcone.cc:729
BOOLEAN coneLink(leftv res, leftv args)
Definition: bbcone.cc:1278
BOOLEAN negatedCone(leftv res, leftv args)
Definition: bbcone.cc:891
BOOLEAN getLinearForms(leftv res, leftv args)
Definition: bbcone.cc:658
int coneID
Definition: bbcone.cc:26
lists listOfFacets(const gfan::ZCone &zc)
Definition: bbcone.cc:1508
BOOLEAN rays(leftv res, leftv args)
Definition: bbcone.cc:620
void bbcone_destroy(blackbox *, void *d)
Definition: bbcone.cc:149
BOOLEAN dimension(leftv res, leftv args)
Definition: bbcone.cc:701
void * bbcone_Init(blackbox *)
Definition: bbcone.cc:81
BOOLEAN containsCone(leftv res, leftv args)
Definition: bbcone.cc:1471
BOOLEAN uniquePoint(leftv res, leftv args)
Definition: bbcone.cc:943
BOOLEAN equations(leftv res, leftv args)
Definition: bbcone.cc:545
BOOLEAN facets(leftv res, leftv args)
Definition: bbcone.cc:560
BOOLEAN setLinearForms(leftv res, leftv args)
Definition: bbcone.cc:1014
BOOLEAN ambientDimension(leftv res, leftv args)
Definition: bbcone.cc:673
char * bbcone_String(blackbox *, void *d)
Definition: bbcone.cc:139
BOOLEAN isOrigin(leftv res, leftv args)
Definition: bbcone.cc:793
BOOLEAN bbcone_Assign(leftv l, leftv r)
Definition: bbcone.cc:86
BOOLEAN linealityDimension(leftv res, leftv args)
Definition: bbcone.cc:757
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:605
BOOLEAN impliedEquations(leftv res, leftv args)
Definition: bbcone.cc:575
BOOLEAN hasFace(leftv res, leftv args)
Definition: bbcone.cc:1422
BOOLEAN intersectCones(leftv res, leftv args)
Definition: bbcone.cc:1083
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:158
#define omAlloc0(size)
Definition: omAllocDecl.h:211
BOOLEAN setMultiplicity(leftv res, leftv args)
Definition: bbcone.cc:994
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 1676 of file bbcone.cc.

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

Definition at line 1622 of file bbcone.cc.

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

Definition at line 1058 of file bbcone.cc.

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

Definition at line 958 of file bbcone.cc.

959 {
960  gfan::ZVector rp = gfan::ZVector(zc->ambientDimension());
961 
962  gfan::ZMatrix rays = zc->extremeRays();
963  for (int i=0; i<rays.getHeight(); i++)
964  {
965  int n = siRand();
966  rp = rp + n * rays[i];
967  }
968 
969  gfan::ZMatrix lins = zc->generatorsOfLinealitySpace();
970  for (int i=0; i<lins.getHeight(); i++)
971  {
972  int n = siRand();
973  rp = rp + n * lins[i];
974  }
975 
976  return rp;
977 }
int i
Definition: cfEzgcd.cc:123
BOOLEAN rays(leftv res, leftv args)
Definition: bbcone.cc:620
int siRand()
Definition: sirandom.c:41
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

int coneID

Definition at line 26 of file bbcone.cc.