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

2060 {
2061  blackbox *b=(blackbox*)omAlloc0(sizeof(blackbox));
2062  // all undefined entries will be set to default in setBlackboxStuff
2063  // the default Print is quite usefull,
2064  // all other are simply error messages
2065  b->blackbox_destroy=bbcone_destroy;
2066  b->blackbox_String=bbcone_String;
2067  // b->blackbox_Print=blackbox_default_Print;
2068  b->blackbox_Init=bbcone_Init;
2069  b->blackbox_Copy=bbcone_Copy;
2070  b->blackbox_Assign=bbcone_Assign;
2071  b->blackbox_Op2=bbcone_Op2;
2072  b->blackbox_serialize=bbcone_serialize;
2073  b->blackbox_deserialize=bbcone_deserialize;
2074  p->iiAddCproc("gfan.lib","coneViaInequalities",FALSE,coneViaNormals);
2075  p->iiAddCproc("gfan.lib","coneViaPoints",FALSE,coneViaRays);
2076  p->iiAddCproc("","listContainsCone",FALSE,containsCone);
2077  // iiAddCproc("gfan.lib","makePolytope",FALSE,coneToPolytope);
2078  p->iiAddCproc("gfan.lib","ambientDimension",FALSE,ambientDimension);
2079  p->iiAddCproc("gfan.lib","canonicalizeCone",FALSE,canonicalizeCone);
2080  p->iiAddCproc("gfan.lib","codimension",FALSE,codimension);
2081  p->iiAddCproc("gfan.lib","coneLink",FALSE,coneLink);
2082  p->iiAddCproc("gfan.lib","containsAsFace",FALSE,hasFace);
2083  p->iiAddCproc("gfan.lib","containsInSupport",FALSE,containsInSupport);
2084  p->iiAddCproc("gfan.lib","containsPositiveVector",FALSE,containsPositiveVector);
2085  p->iiAddCproc("gfan.lib","containsRelatively",FALSE,containsRelatively);
2086  p->iiAddCproc("gfan.lib","convexHull",FALSE,convexHull);
2087  p->iiAddCproc("gfan.lib","convexIntersection",FALSE,intersectCones);
2088  p->iiAddCproc("gfan.lib","convexIntersectionOld",FALSE,convexIntersectionOld);
2089  p->iiAddCproc("gfan.lib","dimension",FALSE,dimension);
2090  p->iiAddCproc("gfan.lib","dualCone",FALSE,dualCone);
2091  p->iiAddCproc("gfan.lib","equations",FALSE,equations);
2092  p->iiAddCproc("gfan.lib","facets",FALSE,facets);
2093  p->iiAddCproc("gfan.lib","generatorsOfLinealitySpace",FALSE,generatorsOfLinealitySpace);
2094  p->iiAddCproc("gfan.lib","generatorsOfSpan",FALSE,generatorsOfSpan);
2095  p->iiAddCproc("gfan.lib","getLinearForms",FALSE,getLinearForms);
2096  p->iiAddCproc("gfan.lib","getMultiplicity",FALSE,getMultiplicity);
2097  p->iiAddCproc("gfan.lib","inequalities",FALSE,inequalities);
2098  p->iiAddCproc("gfan.lib","isFullSpace",FALSE,isFullSpace);
2099  p->iiAddCproc("gfan.lib","isOrigin",FALSE,isOrigin);
2100  p->iiAddCproc("gfan.lib","isSimplicial",FALSE,isSimplicial);
2101  p->iiAddCproc("gfan.lib","linealityDimension",FALSE,linealityDimension);
2102  p->iiAddCproc("gfan.lib","linealitySpace",FALSE,linealitySpace);
2103  p->iiAddCproc("gfan.lib","negatedCone",FALSE,negatedCone);
2104  p->iiAddCproc("gfan.lib","quotientLatticeBasis",FALSE,quotientLatticeBasis);
2105  p->iiAddCproc("gfan.lib","randomPoint",FALSE,randomPoint);
2106  p->iiAddCproc("gfan.lib","rays",FALSE,rays);
2107  p->iiAddCproc("gfan.lib","relativeInteriorPoint",FALSE,relativeInteriorPoint);
2108  p->iiAddCproc("gfan.lib","semigroupGenerator",FALSE,semigroupGenerator);
2109  p->iiAddCproc("gfan.lib","setLinearForms",FALSE,setLinearForms);
2110  p->iiAddCproc("gfan.lib","setMultiplicity",FALSE,setMultiplicity);
2111  p->iiAddCproc("gfan.lib","span",FALSE,impliedEquations);
2112  p->iiAddCproc("gfan.lib","uniquePoint",FALSE,uniquePoint);
2113  p->iiAddCproc("gfan.lib","faceContaining",FALSE,faceContaining);
2114  coneID=setBlackboxStuff(b,"cone");
2115 }
BOOLEAN isFullSpace(leftv res, leftv args)
Definition: bbcone.cc:884
BOOLEAN coneViaNormals(leftv res, leftv args)
Definition: bbcone.cc:352
BOOLEAN getMultiplicity(leftv res, leftv args)
Definition: bbcone.cc:850
BOOLEAN dualCone(leftv res, leftv args)
Definition: bbcone.cc:962
BOOLEAN containsPositiveVector(leftv res, leftv args)
Definition: bbcone.cc:928
BOOLEAN containsRelatively(leftv res, leftv args)
Definition: bbcone.cc:1666
BOOLEAN canonicalizeCone(leftv res, leftv args)
Definition: bbcone.cc:1747
BOOLEAN bbcone_deserialize(blackbox **b, void **d, si_link f)
Definition: bbcone.cc:2042
#define FALSE
Definition: auxiliary.h:94
BOOLEAN quotientLatticeBasis(leftv res, leftv args)
Definition: bbcone.cc:689
BOOLEAN generatorsOfSpan(leftv res, leftv args)
Definition: bbcone.cc:628
BOOLEAN coneViaRays(leftv res, leftv args)
Definition: bbcone.cc:523
BOOLEAN containsInSupport(leftv res, leftv args)
Definition: bbcone.cc:1512
BOOLEAN convexIntersectionOld(leftv res, leftv args)
Definition: bbcone.cc:1576
static BOOLEAN bbcone_Op2(int op, leftv res, leftv i1, leftv i2)
Definition: bbcone.cc:164
gfan::ZVector randomPoint(const gfan::ZCone *zc)
Definition: bbcone.cc:1055
BOOLEAN bbcone_serialize(blackbox *b, void *d, si_link f)
Definition: bbcone.cc:1993
CanonicalForm b
Definition: cfModGcd.cc:4044
BOOLEAN inequalities(leftv res, leftv args)
Definition: bbcone.cc:560
BOOLEAN linealitySpace(leftv res, leftv args)
Definition: bbcone.cc:945
BOOLEAN relativeInteriorPoint(leftv res, leftv args)
Definition: bbcone.cc:1021
BOOLEAN semigroupGenerator(leftv res, leftv args)
Definition: bbcone.cc:996
BOOLEAN isSimplicial(leftv res, leftv args)
Definition: bbcone.cc:901
BOOLEAN codimension(leftv res, leftv args)
Definition: bbcone.cc:791
BOOLEAN coneLink(leftv res, leftv args)
Definition: bbcone.cc:1463
BOOLEAN negatedCone(leftv res, leftv args)
Definition: bbcone.cc:979
BOOLEAN getLinearForms(leftv res, leftv args)
Definition: bbcone.cc:706
int coneID
Definition: bbcone.cc:25
BOOLEAN rays(leftv res, leftv args)
Definition: bbcone.cc:662
void bbcone_destroy(blackbox *, void *d)
Definition: bbcone.cc:148
BOOLEAN dimension(leftv res, leftv args)
Definition: bbcone.cc:757
void * bbcone_Init(blackbox *)
Definition: bbcone.cc:80
BOOLEAN containsCone(leftv res, leftv args)
Definition: bbcone.cc:1765
BOOLEAN uniquePoint(leftv res, leftv args)
Definition: bbcone.cc:1038
BOOLEAN equations(leftv res, leftv args)
Definition: bbcone.cc:577
BOOLEAN facets(leftv res, leftv args)
Definition: bbcone.cc:594
BOOLEAN setLinearForms(leftv res, leftv args)
Definition: bbcone.cc:1115
BOOLEAN ambientDimension(leftv res, leftv args)
Definition: bbcone.cc:723
char * bbcone_String(blackbox *, void *d)
Definition: bbcone.cc:138
BOOLEAN isOrigin(leftv res, leftv args)
Definition: bbcone.cc:867
BOOLEAN bbcone_Assign(leftv l, leftv r)
Definition: bbcone.cc:85
BOOLEAN faceContaining(leftv res, leftv args)
Definition: bbcone.cc:1804
BOOLEAN linealityDimension(leftv res, leftv args)
Definition: bbcone.cc:825
int(* iiAddCproc)(const char *libname, const char *procname, BOOLEAN pstatic, BOOLEAN(*func)(leftv res, leftv v))
Definition: ipid.h:69
BOOLEAN generatorsOfLinealitySpace(leftv res, leftv args)
Definition: bbcone.cc:645
BOOLEAN impliedEquations(leftv res, leftv args)
Definition: bbcone.cc:611
BOOLEAN hasFace(leftv res, leftv args)
Definition: bbcone.cc:1710
BOOLEAN intersectCones(leftv res, leftv args)
Definition: bbcone.cc:1188
int setBlackboxStuff(blackbox *bb, const char *n)
define a new type
Definition: blackbox.cc:126
void * bbcone_Copy(blackbox *, void *d)
Definition: bbcone.cc:157
#define omAlloc0(size)
Definition: omAllocDecl.h:211
BOOLEAN setMultiplicity(leftv res, leftv args)
Definition: bbcone.cc:1093

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

1903 {
1904  gfan::ZMatrix inequalities = zc.getFacets();
1905  gfan::ZMatrix equations = zc.getImpliedEquations();
1906  int r = inequalities.getHeight();
1907  int c = inequalities.getWidth();
1908 
1909  /* our cone has r facets, if r==0 return empty matrices */
1910  gfan::ZMatrix relativeInteriorPoints = gfan::ZMatrix(0,c);
1911  gfan::ZMatrix outerFacetNormals = gfan::ZMatrix(0,c);
1912  if (r==0)
1913  return std::make_pair(relativeInteriorPoints,outerFacetNormals);
1914 
1915  /* next we iterate over each of the r facets,
1916  * build the respective cone and add it to the list
1917  * this is the i=0 case */
1918  gfan::ZMatrix newInequalities = inequalities.submatrix(1,0,r,c);
1919  gfan::ZMatrix newEquations = equations;
1920  newEquations.appendRow(inequalities[0]);
1921  gfan::ZCone facet = gfan::ZCone(newInequalities,newEquations);
1922  gfan::ZVector interiorPoint = facet.getRelativeInteriorPoint();
1923  if (onlyLowerHalfSpace==false || interiorPoint[0].sign()<0)
1924  {
1925  if (exceptThesePoints.count(interiorPoint)==0)
1926  {
1927  relativeInteriorPoints.appendRow(interiorPoint);
1928  outerFacetNormals.appendRow(-inequalities[0].toVector());
1929  }
1930  }
1931 
1932  /* these are the cases i=1,...,r-2 */
1933  for (int i=1; i<r-1; i++)
1934  {
1935  newInequalities = inequalities.submatrix(0,0,i,c);
1936  newInequalities.append(inequalities.submatrix(i+1,0,r,c));
1937  newEquations = equations;
1938  newEquations.appendRow(inequalities[i]);
1939  facet = gfan::ZCone(newInequalities,newEquations);
1940  interiorPoint = facet.getRelativeInteriorPoint();
1941  if (onlyLowerHalfSpace==false || interiorPoint[0].sign()<0)
1942  {
1943  if (exceptThesePoints.count(interiorPoint)==0)
1944  {
1945  relativeInteriorPoints.appendRow(interiorPoint);
1946  outerFacetNormals.appendRow(-inequalities[i].toVector());
1947  }
1948  }
1949  }
1950 
1951  /* this is the i=r-1 case */
1952  newInequalities = inequalities.submatrix(0,0,r-1,c);
1953  newEquations = equations;
1954  newEquations.appendRow(inequalities[r-1]);
1955  facet = gfan::ZCone(newInequalities,newEquations);
1956  interiorPoint = facet.getRelativeInteriorPoint();
1957  if (onlyLowerHalfSpace==false || interiorPoint[0].sign()<0)
1958  {
1959  if (exceptThesePoints.count(interiorPoint)==0)
1960  {
1961  relativeInteriorPoints.appendRow(interiorPoint);
1962  outerFacetNormals.appendRow(-inequalities[r-1].toVector());
1963  }
1964  }
1965 
1966  return std::make_pair(relativeInteriorPoints,outerFacetNormals);
1967 }
Definition: gfan.h:44
BOOLEAN inequalities(leftv res, leftv args)
Definition: bbcone.cc:560
int i
Definition: cfEzgcd.cc:125
BOOLEAN equations(leftv res, leftv args)
Definition: bbcone.cc:577
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 1848 of file bbcone.cc.

1849 {
1850  gfan::ZMatrix inequalities = zc.getFacets();
1851  gfan::ZMatrix equations = zc.getImpliedEquations();
1852  int r = inequalities.getHeight();
1853  int c = inequalities.getWidth();
1854 
1855  /* our cone has r facets, if r==0 return empty matrices */
1856  gfan::ZMatrix relativeInteriorPoints = gfan::ZMatrix(0,c);
1857  if (r==0) return relativeInteriorPoints;
1858 
1859  /* next we iterate over each of the r facets,
1860  * build the respective cone and add it to the list
1861  * this is the i=0 case */
1862  gfan::ZMatrix newInequalities = inequalities.submatrix(1,0,r,c);
1863  gfan::ZMatrix newEquations = equations;
1864  newEquations.appendRow(inequalities[0]);
1865  gfan::ZCone facet = gfan::ZCone(newInequalities,newEquations);
1866  facet.canonicalize();
1867  gfan::ZVector interiorPoint = facet.getRelativeInteriorPoint();
1868  if (exceptThese.count(interiorPoint)==0)
1869  relativeInteriorPoints.appendRow(interiorPoint);
1870 
1871  /* these are the cases i=1,...,r-2 */
1872  for (int i=1; i<r-1; i++)
1873  {
1874  newInequalities = inequalities.submatrix(0,0,i,c);
1875  newInequalities.append(inequalities.submatrix(i+1,0,r,c));
1876  newEquations = equations;
1877  newEquations.appendRow(inequalities[i]);
1878  facet = gfan::ZCone(newInequalities,newEquations);
1879  facet.canonicalize();
1880  interiorPoint = facet.getRelativeInteriorPoint();
1881  if (exceptThese.count(interiorPoint)==0)
1882  relativeInteriorPoints.appendRow(interiorPoint);
1883  }
1884 
1885  /* this is the i=r-1 case */
1886  newInequalities = inequalities.submatrix(0,0,r-1,c);
1887  newEquations = equations;
1888  newEquations.appendRow(inequalities[r-1]);
1889  facet = gfan::ZCone(newInequalities,newEquations);
1890  facet.canonicalize();
1891  interiorPoint = facet.getRelativeInteriorPoint();
1892  if (exceptThese.count(interiorPoint)==0)
1893  relativeInteriorPoints.appendRow(interiorPoint);
1894 
1895  return relativeInteriorPoints;
1896 }
Definition: gfan.h:44
BOOLEAN inequalities(leftv res, leftv args)
Definition: bbcone.cc:560
int i
Definition: cfEzgcd.cc:125
BOOLEAN equations(leftv res, leftv args)
Definition: bbcone.cc:577

◆ liftUp()

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

Definition at line 1161 of file bbcone.cc.

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

◆ randomPoint()

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

Definition at line 1055 of file bbcone.cc.

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

◆ toString()

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

Definition at line 27 of file bbcone.cc.

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

Variable Documentation

◆ coneID

int coneID

Definition at line 25 of file bbcone.cc.