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

1915 {
1916  blackbox *b=(blackbox*)omAlloc0(sizeof(blackbox));
1917  // all undefined entries will be set to default in setBlackboxStuff
1918  // the default Print is quite usefull,
1919  // all other are simply error messages
1920  b->blackbox_destroy=bbcone_destroy;
1921  b->blackbox_String=bbcone_String;
1922  // b->blackbox_Print=blackbox_default_Print;
1923  b->blackbox_Init=bbcone_Init;
1924  b->blackbox_Copy=bbcone_Copy;
1925  b->blackbox_Assign=bbcone_Assign;
1926  b->blackbox_Op2=bbcone_Op2;
1927  b->blackbox_serialize=bbcone_serialize;
1928  b->blackbox_deserialize=bbcone_deserialize;
1929  p->iiAddCproc("gfan.lib","coneViaInequalities",FALSE,coneViaNormals);
1930  p->iiAddCproc("gfan.lib","coneViaPoints",FALSE,coneViaRays);
1931  p->iiAddCproc("","listContainsCone",FALSE,containsCone);
1932  // iiAddCproc("gfan.lib","makePolytope",FALSE,coneToPolytope);
1933  p->iiAddCproc("gfan.lib","ambientDimension",FALSE,ambientDimension);
1934  p->iiAddCproc("gfan.lib","canonicalizeCone",FALSE,canonicalizeCone);
1935  p->iiAddCproc("gfan.lib","codimension",FALSE,codimension);
1936  p->iiAddCproc("gfan.lib","coneLink",FALSE,coneLink);
1937  p->iiAddCproc("gfan.lib","containsAsFace",FALSE,hasFace);
1938  p->iiAddCproc("gfan.lib","containsInSupport",FALSE,containsInSupport);
1939  p->iiAddCproc("gfan.lib","containsPositiveVector",FALSE,containsPositiveVector);
1940  p->iiAddCproc("gfan.lib","containsRelatively",FALSE,containsRelatively);
1941  p->iiAddCproc("gfan.lib","convexHull",FALSE,convexHull);
1942  p->iiAddCproc("gfan.lib","convexIntersection",FALSE,intersectCones);
1943  p->iiAddCproc("gfan.lib","dimension",FALSE,dimension);
1944  p->iiAddCproc("gfan.lib","dualCone",FALSE,dualCone);
1945  p->iiAddCproc("gfan.lib","equations",FALSE,equations);
1946  p->iiAddCproc("gfan.lib","facets",FALSE,facets);
1947  p->iiAddCproc("gfan.lib","generatorsOfLinealitySpace",FALSE,generatorsOfLinealitySpace);
1948  p->iiAddCproc("gfan.lib","generatorsOfSpan",FALSE,generatorsOfSpan);
1949  p->iiAddCproc("gfan.lib","getLinearForms",FALSE,getLinearForms);
1950  p->iiAddCproc("gfan.lib","getMultiplicity",FALSE,getMultiplicity);
1951  p->iiAddCproc("gfan.lib","inequalities",FALSE,inequalities);
1952  p->iiAddCproc("gfan.lib","isFullSpace",FALSE,isFullSpace);
1953  p->iiAddCproc("gfan.lib","isOrigin",FALSE,isOrigin);
1954  p->iiAddCproc("gfan.lib","isSimplicial",FALSE,isSimplicial);
1955  p->iiAddCproc("gfan.lib","linealityDimension",FALSE,linealityDimension);
1956  p->iiAddCproc("gfan.lib","linealitySpace",FALSE,linealitySpace);
1957  p->iiAddCproc("gfan.lib","negatedCone",FALSE,negatedCone);
1958  p->iiAddCproc("gfan.lib","quotientLatticeBasis",FALSE,quotientLatticeBasis);
1959  p->iiAddCproc("gfan.lib","randomPoint",FALSE,randomPoint);
1960  p->iiAddCproc("gfan.lib","rays",FALSE,rays);
1961  p->iiAddCproc("gfan.lib","relativeInteriorPoint",FALSE,relativeInteriorPoint);
1962  p->iiAddCproc("gfan.lib","semigroupGenerator",FALSE,semigroupGenerator);
1963  p->iiAddCproc("gfan.lib","setLinearForms",FALSE,setLinearForms);
1964  p->iiAddCproc("gfan.lib","setMultiplicity",FALSE,setMultiplicity);
1965  p->iiAddCproc("gfan.lib","span",FALSE,impliedEquations);
1966  p->iiAddCproc("gfan.lib","uniquePoint",FALSE,uniquePoint);
1967  p->iiAddCproc("gfan.lib","faceContaining",FALSE,faceContaining);
1968  coneID=setBlackboxStuff(b,"cone");
1969 }
BOOLEAN isFullSpace(leftv res, leftv args)
Definition: bbcone.cc:885
BOOLEAN coneViaNormals(leftv res, leftv args)
Definition: bbcone.cc:353
BOOLEAN getMultiplicity(leftv res, leftv args)
Definition: bbcone.cc:851
BOOLEAN dualCone(leftv res, leftv args)
Definition: bbcone.cc:963
BOOLEAN containsPositiveVector(leftv res, leftv args)
Definition: bbcone.cc:929
BOOLEAN containsRelatively(leftv res, leftv args)
Definition: bbcone.cc:1521
BOOLEAN canonicalizeCone(leftv res, leftv args)
Definition: bbcone.cc:1602
BOOLEAN bbcone_deserialize(blackbox **b, void **d, si_link f)
Definition: bbcone.cc:1897
#define FALSE
Definition: auxiliary.h:94
BOOLEAN quotientLatticeBasis(leftv res, leftv args)
Definition: bbcone.cc:690
return P p
Definition: myNF.cc:203
BOOLEAN generatorsOfSpan(leftv res, leftv args)
Definition: bbcone.cc:629
BOOLEAN coneViaRays(leftv res, leftv args)
Definition: bbcone.cc:524
BOOLEAN containsInSupport(leftv res, leftv args)
Definition: bbcone.cc:1457
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:1056
BOOLEAN bbcone_serialize(blackbox *b, void *d, si_link f)
Definition: bbcone.cc:1848
BOOLEAN inequalities(leftv res, leftv args)
Definition: bbcone.cc:561
BOOLEAN linealitySpace(leftv res, leftv args)
Definition: bbcone.cc:946
BOOLEAN relativeInteriorPoint(leftv res, leftv args)
Definition: bbcone.cc:1022
BOOLEAN semigroupGenerator(leftv res, leftv args)
Definition: bbcone.cc:997
BOOLEAN isSimplicial(leftv res, leftv args)
Definition: bbcone.cc:902
BOOLEAN codimension(leftv res, leftv args)
Definition: bbcone.cc:792
BOOLEAN coneLink(leftv res, leftv args)
Definition: bbcone.cc:1408
BOOLEAN negatedCone(leftv res, leftv args)
Definition: bbcone.cc:980
BOOLEAN getLinearForms(leftv res, leftv args)
Definition: bbcone.cc:707
int coneID
Definition: bbcone.cc:26
BOOLEAN rays(leftv res, leftv args)
Definition: bbcone.cc:663
void bbcone_destroy(blackbox *, void *d)
Definition: bbcone.cc:149
BOOLEAN dimension(leftv res, leftv args)
Definition: bbcone.cc:758
void * bbcone_Init(blackbox *)
Definition: bbcone.cc:81
BOOLEAN containsCone(leftv res, leftv args)
Definition: bbcone.cc:1620
BOOLEAN uniquePoint(leftv res, leftv args)
Definition: bbcone.cc:1039
BOOLEAN equations(leftv res, leftv args)
Definition: bbcone.cc:578
BOOLEAN facets(leftv res, leftv args)
Definition: bbcone.cc:595
BOOLEAN setLinearForms(leftv res, leftv args)
Definition: bbcone.cc:1116
BOOLEAN ambientDimension(leftv res, leftv args)
Definition: bbcone.cc:724
char * bbcone_String(blackbox *, void *d)
Definition: bbcone.cc:139
BOOLEAN isOrigin(leftv res, leftv args)
Definition: bbcone.cc:868
BOOLEAN bbcone_Assign(leftv l, leftv r)
Definition: bbcone.cc:86
BOOLEAN faceContaining(leftv res, leftv args)
Definition: bbcone.cc:1659
BOOLEAN linealityDimension(leftv res, leftv args)
Definition: bbcone.cc:826
BOOLEAN generatorsOfLinealitySpace(leftv res, leftv args)
Definition: bbcone.cc:646
BOOLEAN impliedEquations(leftv res, leftv args)
Definition: bbcone.cc:612
BOOLEAN hasFace(leftv res, leftv args)
Definition: bbcone.cc:1565
BOOLEAN intersectCones(leftv res, leftv args)
Definition: bbcone.cc:1189
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:1094

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

1758 {
1759  gfan::ZMatrix inequalities = zc.getFacets();
1760  gfan::ZMatrix equations = zc.getImpliedEquations();
1761  int r = inequalities.getHeight();
1762  int c = inequalities.getWidth();
1763 
1764  /* our cone has r facets, if r==0 return empty matrices */
1765  gfan::ZMatrix relativeInteriorPoints = gfan::ZMatrix(0,c);
1766  gfan::ZMatrix outerFacetNormals = gfan::ZMatrix(0,c);
1767  if (r==0)
1768  return std::make_pair(relativeInteriorPoints,outerFacetNormals);
1769 
1770  /* next we iterate over each of the r facets,
1771  * build the respective cone and add it to the list
1772  * this is the i=0 case */
1773  gfan::ZMatrix newInequalities = inequalities.submatrix(1,0,r,c);
1774  gfan::ZMatrix newEquations = equations;
1775  newEquations.appendRow(inequalities[0]);
1776  gfan::ZCone facet = gfan::ZCone(newInequalities,newEquations);
1777  gfan::ZVector interiorPoint = facet.getRelativeInteriorPoint();
1778  if (onlyLowerHalfSpace==false || interiorPoint[0].sign()<0)
1779  {
1780  if (exceptThesePoints.count(interiorPoint)==0)
1781  {
1782  relativeInteriorPoints.appendRow(interiorPoint);
1783  outerFacetNormals.appendRow(-inequalities[0].toVector());
1784  }
1785  }
1786 
1787  /* these are the cases i=1,...,r-2 */
1788  for (int i=1; i<r-1; i++)
1789  {
1790  newInequalities = inequalities.submatrix(0,0,i,c);
1791  newInequalities.append(inequalities.submatrix(i+1,0,r,c));
1792  newEquations = equations;
1793  newEquations.appendRow(inequalities[i]);
1794  facet = gfan::ZCone(newInequalities,newEquations);
1795  interiorPoint = facet.getRelativeInteriorPoint();
1796  if (onlyLowerHalfSpace==false || interiorPoint[0].sign()<0)
1797  {
1798  if (exceptThesePoints.count(interiorPoint)==0)
1799  {
1800  relativeInteriorPoints.appendRow(interiorPoint);
1801  outerFacetNormals.appendRow(-inequalities[i].toVector());
1802  }
1803  }
1804  }
1805 
1806  /* this is the i=r-1 case */
1807  newInequalities = inequalities.submatrix(0,0,r-1,c);
1808  newEquations = equations;
1809  newEquations.appendRow(inequalities[r-1]);
1810  facet = gfan::ZCone(newInequalities,newEquations);
1811  interiorPoint = facet.getRelativeInteriorPoint();
1812  if (onlyLowerHalfSpace==false || interiorPoint[0].sign()<0)
1813  {
1814  if (exceptThesePoints.count(interiorPoint)==0)
1815  {
1816  relativeInteriorPoints.appendRow(interiorPoint);
1817  outerFacetNormals.appendRow(-inequalities[r-1].toVector());
1818  }
1819  }
1820 
1821  return std::make_pair(relativeInteriorPoints,outerFacetNormals);
1822 }
Definition: gfan.h:44
BOOLEAN inequalities(leftv res, leftv args)
Definition: bbcone.cc:561
const ring r
Definition: syzextra.cc:208
int i
Definition: cfEzgcd.cc:123
BOOLEAN equations(leftv res, leftv args)
Definition: bbcone.cc:578
static int sign(int x)
Definition: ring.cc:3342

◆ interiorPointsOfFacets()

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

Definition at line 1703 of file bbcone.cc.

1704 {
1705  gfan::ZMatrix inequalities = zc.getFacets();
1706  gfan::ZMatrix equations = zc.getImpliedEquations();
1707  int r = inequalities.getHeight();
1708  int c = inequalities.getWidth();
1709 
1710  /* our cone has r facets, if r==0 return empty matrices */
1711  gfan::ZMatrix relativeInteriorPoints = gfan::ZMatrix(0,c);
1712  if (r==0) return relativeInteriorPoints;
1713 
1714  /* next we iterate over each of the r facets,
1715  * build the respective cone and add it to the list
1716  * this is the i=0 case */
1717  gfan::ZMatrix newInequalities = inequalities.submatrix(1,0,r,c);
1718  gfan::ZMatrix newEquations = equations;
1719  newEquations.appendRow(inequalities[0]);
1720  gfan::ZCone facet = gfan::ZCone(newInequalities,newEquations);
1721  facet.canonicalize();
1722  gfan::ZVector interiorPoint = facet.getRelativeInteriorPoint();
1723  if (exceptThese.count(interiorPoint)==0)
1724  relativeInteriorPoints.appendRow(interiorPoint);
1725 
1726  /* these are the cases i=1,...,r-2 */
1727  for (int i=1; i<r-1; i++)
1728  {
1729  newInequalities = inequalities.submatrix(0,0,i,c);
1730  newInequalities.append(inequalities.submatrix(i+1,0,r,c));
1731  newEquations = equations;
1732  newEquations.appendRow(inequalities[i]);
1733  facet = gfan::ZCone(newInequalities,newEquations);
1734  facet.canonicalize();
1735  interiorPoint = facet.getRelativeInteriorPoint();
1736  if (exceptThese.count(interiorPoint)==0)
1737  relativeInteriorPoints.appendRow(interiorPoint);
1738  }
1739 
1740  /* this is the i=r-1 case */
1741  newInequalities = inequalities.submatrix(0,0,r-1,c);
1742  newEquations = equations;
1743  newEquations.appendRow(inequalities[r-1]);
1744  facet = gfan::ZCone(newInequalities,newEquations);
1745  facet.canonicalize();
1746  interiorPoint = facet.getRelativeInteriorPoint();
1747  if (exceptThese.count(interiorPoint)==0)
1748  relativeInteriorPoints.appendRow(interiorPoint);
1749 
1750  return relativeInteriorPoints;
1751 }
Definition: gfan.h:44
BOOLEAN inequalities(leftv res, leftv args)
Definition: bbcone.cc:561
const ring r
Definition: syzextra.cc:208
int i
Definition: cfEzgcd.cc:123
BOOLEAN equations(leftv res, leftv args)
Definition: bbcone.cc:578

◆ liftUp()

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

Definition at line 1162 of file bbcone.cc.

1163 {
1164  gfan::ZMatrix ineq=zc.getInequalities();
1165  gfan::ZMatrix eq=zc.getEquations();
1166  gfan::ZCone zd(liftUp(ineq),liftUp(eq));
1167  return zd;
1168 }
gfan::ZMatrix liftUp(const gfan::ZMatrix &zm)
Definition: bbcone.cc:1150

◆ randomPoint()

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

Definition at line 1056 of file bbcone.cc.

1057 {
1058  gfan::ZVector rp = gfan::ZVector(zc->ambientDimension());
1059 
1060  gfan::ZMatrix rays = zc->extremeRays();
1061  for (int i=0; i<rays.getHeight(); i++)
1062  {
1063  int n = siRand();
1064  rp = rp + n * rays[i].toVector();
1065  }
1066 
1067  gfan::ZMatrix lins = zc->generatorsOfLinealitySpace();
1068  for (int i=0; i<lins.getHeight(); i++)
1069  {
1070  int n = siRand();
1071  rp = rp + n * lins[i].toVector();
1072  }
1073 
1074  return rp;
1075 }
int i
Definition: cfEzgcd.cc:123
BOOLEAN rays(leftv res, leftv args)
Definition: bbcone.cc:663
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.