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, const int b=0)
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
EXTERN_VAR int	coneID

Function Documentation

bbcone_setup()

void bbcone_setup

(

SModulFunctions *

p

)

Definition at line 2101 of file bbcone.cc.

{
  blackbox *b=(blackbox*)omAlloc0(sizeof(blackbox));
  // all undefined entries will be set to default in setBlackboxStuff
  // the default Print is quite usefull,
  // all other are simply error messages
  b->blackbox_destroy=bbcone_destroy;
  b->blackbox_String=bbcone_String;
  // b->blackbox_Print=blackbox_default_Print;
  b->blackbox_Init=bbcone_Init;
  b->blackbox_Copy=bbcone_Copy;
  b->blackbox_Assign=bbcone_Assign;
  b->blackbox_Op2=bbcone_Op2;
  b->blackbox_serialize=bbcone_serialize;
  b->blackbox_deserialize=bbcone_deserialize;
  p->iiAddCproc("gfan.lib","coneViaInequalities",FALSE,coneViaNormals);
  p->iiAddCproc("gfan.lib","coneViaPoints",FALSE,coneViaRays);
  p->iiAddCproc("","listContainsCone",FALSE,containsCone);
  // iiAddCproc("gfan.lib","makePolytope",FALSE,coneToPolytope);
  p->iiAddCproc("gfan.lib","ambientDimension",FALSE,ambientDimension);
  p->iiAddCproc("gfan.lib","canonicalizeCone",FALSE,canonicalizeCone);
  p->iiAddCproc("gfan.lib","codimension",FALSE,codimension);
  p->iiAddCproc("gfan.lib","coneLink",FALSE,coneLink);
  p->iiAddCproc("gfan.lib","containsAsFace",FALSE,hasFace);
  p->iiAddCproc("gfan.lib","containsInSupport",FALSE,containsInSupport);
  p->iiAddCproc("gfan.lib","containsPositiveVector",FALSE,containsPositiveVector);
  p->iiAddCproc("gfan.lib","containsRelatively",FALSE,containsRelatively);
  p->iiAddCproc("gfan.lib","convexHull",FALSE,convexHull);
  p->iiAddCproc("gfan.lib","convexIntersection",FALSE,intersectCones);
  p->iiAddCproc("gfan.lib","dimension",FALSE,dimension);
  p->iiAddCproc("gfan.lib","dualCone",FALSE,dualCone);
  p->iiAddCproc("gfan.lib","equations",FALSE,equations);
  p->iiAddCproc("gfan.lib","facets",FALSE,facets);
  p->iiAddCproc("gfan.lib","generatorsOfLinealitySpace",FALSE,generatorsOfLinealitySpace);
  p->iiAddCproc("gfan.lib","generatorsOfSpan",FALSE,generatorsOfSpan);
  p->iiAddCproc("gfan.lib","getLinearForms",FALSE,getLinearForms);
  p->iiAddCproc("gfan.lib","getMultiplicity",FALSE,getMultiplicity);
  p->iiAddCproc("gfan.lib","inequalities",FALSE,inequalities);
  p->iiAddCproc("gfan.lib","isFullSpace",FALSE,isFullSpace);
  p->iiAddCproc("gfan.lib","isOrigin",FALSE,isOrigin);
  p->iiAddCproc("gfan.lib","isSimplicial",FALSE,isSimplicial);
  p->iiAddCproc("gfan.lib","linealityDimension",FALSE,linealityDimension);
  p->iiAddCproc("gfan.lib","linealitySpace",FALSE,linealitySpace);
  p->iiAddCproc("gfan.lib","negatedCone",FALSE,negatedCone);
  p->iiAddCproc("gfan.lib","quotientLatticeBasis",FALSE,quotientLatticeBasis);
  p->iiAddCproc("gfan.lib","randomPoint",FALSE,randomPoint);
  p->iiAddCproc("gfan.lib","rays",FALSE,rays);
  p->iiAddCproc("gfan.lib","relativeInteriorPoint",FALSE,relativeInteriorPoint);
  p->iiAddCproc("gfan.lib","semigroupGenerator",FALSE,semigroupGenerator);
  p->iiAddCproc("gfan.lib","setLinearForms",FALSE,setLinearForms);
  p->iiAddCproc("gfan.lib","setMultiplicity",FALSE,setMultiplicity);
  p->iiAddCproc("gfan.lib","span",FALSE,impliedEquations);
  p->iiAddCproc("gfan.lib","uniquePoint",FALSE,uniquePoint);
  p->iiAddCproc("gfan.lib","faceContaining",FALSE,faceContaining);
  p->iiAddCproc("gfan.lib","onesVector",FALSE,onesVector);
  p->iiAddCproc("gfan.lib","convexIntersectionOld",FALSE,convexIntersectionOld);
  coneID=setBlackboxStuff(b,"cone");
}

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

{
  gfan::ZMatrix inequalities = zc.getFacets();
  gfan::ZMatrix equations = zc.getImpliedEquations();
  int r = inequalities.getHeight();
  int c = inequalities.getWidth();
 
  /* our cone has r facets, if r==0 return empty matrices */
  gfan::ZMatrix relativeInteriorPoints = gfan::ZMatrix(0,c);
  gfan::ZMatrix outerFacetNormals = gfan::ZMatrix(0,c);
  if (r==0)
    return std::make_pair(relativeInteriorPoints,outerFacetNormals);
 
  /* next we iterate over each of the r facets,
   * build the respective cone and add it to the list
   * this is the i=0 case */
  gfan::ZMatrix newInequalities = inequalities.submatrix(1,0,r,c);
  gfan::ZMatrix newEquations = equations;
  newEquations.appendRow(inequalities[0]);
  gfan::ZCone facet = gfan::ZCone(newInequalities,newEquations);
  gfan::ZVector interiorPoint = facet.getRelativeInteriorPoint();
  if (onlyLowerHalfSpace==false || interiorPoint[0].sign()<0)
  {
    if (exceptThesePoints.count(interiorPoint)==0)
    {
      relativeInteriorPoints.appendRow(interiorPoint);
      outerFacetNormals.appendRow(-inequalities[0].toVector());
    }
  }
 
  /* these are the cases i=1,...,r-2 */
  for (int i=1; i<r-1; i++)
  {
    newInequalities = inequalities.submatrix(0,0,i,c);
    newInequalities.append(inequalities.submatrix(i+1,0,r,c));
    newEquations = equations;
    newEquations.appendRow(inequalities[i]);
    facet = gfan::ZCone(newInequalities,newEquations);
    interiorPoint = facet.getRelativeInteriorPoint();
    if (onlyLowerHalfSpace==false || interiorPoint[0].sign()<0)
    {
      if (exceptThesePoints.count(interiorPoint)==0)
      {
        relativeInteriorPoints.appendRow(interiorPoint);
        outerFacetNormals.appendRow(-inequalities[i].toVector());
      }
    }
  }
 
  /* this is the i=r-1 case */
  newInequalities = inequalities.submatrix(0,0,r-1,c);
  newEquations = equations;
  newEquations.appendRow(inequalities[r-1]);
  facet = gfan::ZCone(newInequalities,newEquations);
  interiorPoint = facet.getRelativeInteriorPoint();
  if (onlyLowerHalfSpace==false || interiorPoint[0].sign()<0)
  {
    if (exceptThesePoints.count(interiorPoint)==0)
    {
      relativeInteriorPoints.appendRow(interiorPoint);
      outerFacetNormals.appendRow(-inequalities[r-1].toVector());
    }
  }
 
  return std::make_pair(relativeInteriorPoints,outerFacetNormals);
}

interiorPointsOfFacets()

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

Definition at line 1799 of file bbcone.cc.

{
  gfan::ZMatrix inequalities = zc.getFacets();
  gfan::ZMatrix equations = zc.getImpliedEquations();
  int r = inequalities.getHeight();
  int c = inequalities.getWidth();
 
  /* our cone has r facets, if r==0 return empty matrices */
  gfan::ZMatrix relativeInteriorPoints = gfan::ZMatrix(0,c);
  if (r==0) return relativeInteriorPoints;
 
  /* next we iterate over each of the r facets,
   * build the respective cone and add it to the list
   * this is the i=0 case */
  gfan::ZMatrix newInequalities = inequalities.submatrix(1,0,r,c);
  gfan::ZMatrix newEquations = equations;
  newEquations.appendRow(inequalities[0]);
  gfan::ZCone facet = gfan::ZCone(newInequalities,newEquations);
  facet.canonicalize();
  gfan::ZVector interiorPoint = facet.getRelativeInteriorPoint();
  if (exceptThese.count(interiorPoint)==0)
    relativeInteriorPoints.appendRow(interiorPoint);
 
  /* these are the cases i=1,...,r-2 */
  for (int i=1; i<r-1; i++)
  {
    newInequalities = inequalities.submatrix(0,0,i,c);
    newInequalities.append(inequalities.submatrix(i+1,0,r,c));
    newEquations = equations;
    newEquations.appendRow(inequalities[i]);
    facet = gfan::ZCone(newInequalities,newEquations);
    facet.canonicalize();
    interiorPoint = facet.getRelativeInteriorPoint();
    if (exceptThese.count(interiorPoint)==0)
      relativeInteriorPoints.appendRow(interiorPoint);
  }
 
  /* this is the i=r-1 case */
  newInequalities = inequalities.submatrix(0,0,r-1,c);
  newEquations = equations;
  newEquations.appendRow(inequalities[r-1]);
  facet = gfan::ZCone(newInequalities,newEquations);
  facet.canonicalize();
  interiorPoint = facet.getRelativeInteriorPoint();
  if (exceptThese.count(interiorPoint)==0)
    relativeInteriorPoints.appendRow(interiorPoint);
 
  return relativeInteriorPoints;
}

liftUp()

gfan::ZCone liftUp

(

const gfan::ZCone &

zc

)

Definition at line 1182 of file bbcone.cc.

{
  gfan::ZMatrix ineq=zc.getInequalities();
  gfan::ZMatrix eq=zc.getEquations();
  gfan::ZCone zd(liftUp(ineq),liftUp(eq));
  return zd;
}

randomPoint()

gfan::ZVector randomPoint	(	const gfan::ZCone *	zc,
		const int	b = 0
	)

Definition at line 1069 of file bbcone.cc.

{
  gfan::ZVector rp = gfan::ZVector(zc->ambientDimension());
 
  gfan::ZMatrix rays = zc->extremeRays();
  for (int i=0; i<rays.getHeight(); i++)
    rp += siRandBound(b) * rays[i].toVector();
 
  // gfan::ZMatrix lins = zc->generatorsOfLinealitySpace();
  // for (int i=0; i<lins.getHeight(); i++)
  // {
  //   int n = siRandBound(b);
  //   rp = rp + n * lins[i].toVector();
  // }
 
  return rp;
}

toString()

std::string toString

(

const gfan::ZCone *const

c

)

Definition at line 27 of file bbcone.cc.

{
  std::stringstream s;
  s<<"AMBIENT_DIM"<<std::endl;
  s<<c->ambientDimension()<<std::endl;
 
  gfan::ZMatrix i=c->getInequalities();
  char* ineqs = toString(i);
  if (c->areFacetsKnown())
    s<<"FACETS"<<std::endl;
  else
    s<<"INEQUALITIES"<<std::endl;
  if (ineqs!=NULL)
  {
    s<<ineqs<<std::endl;
    omFree(ineqs);
  }
 
  gfan::ZMatrix e=c->getEquations();
  char* eqs = toString(e);
  if (c->areImpliedEquationsKnown())
    s<<"LINEAR_SPAN"<<std::endl;
  else
    s<<"EQUATIONS"<<std::endl;
  if (eqs!=NULL)
  {
    s<<eqs<<std::endl;
    omFree(eqs);
  }
 
  if (c->areExtremeRaysKnown())
  {
    gfan::ZMatrix r=c->extremeRays();
    char* rs = toString(r);
    s<<"RAYS"<<std::endl;
    if (rs!=NULL)
    {
      s<<rs<<std::endl;
      omFree(rs);
    }
    gfan::ZMatrix l=c->generatorsOfLinealitySpace();
    char* ls = toString(l);
    s<<"LINEALITY_SPACE"<<std::endl;
    if (ls!=NULL)
    {
      s<<ls<<std::endl;
      omFree(ls);
    }
  }
 
  return s.str();
}

Variable Documentation

coneID

EXTERN_VAR int coneID

Definition at line 14 of file bbcone.h.