Functions | Variables
bbfan.h File Reference
#include <kernel/mod2.h>
#include <Singular/ipid.h>
#include <gfanlib/gfanlib.h>

Go to the source code of this file.

Functions

void bbfan_setup (SModulFunctions *p)
 
bool isCompatible (const gfan::ZFan *zf, const gfan::ZCone *zc)
 
int getAmbientDimension (gfan::ZFan *zf)
 
int getCodimension (gfan::ZFan *zf)
 
int getDimension (gfan::ZFan *zf)
 
int getLinealityDimension (gfan::ZFan *zf)
 
int isSimplicial (gfan::ZFan *zf)
 
gfan::Matrix< gfan::Integer > rays (const gfan::ZFan *const zf)
 
gfan::ZFan commonRefinement (gfan::ZFan zf, gfan::ZFan zg)
 

Variables

int fanID
 

Function Documentation

§ bbfan_setup()

void bbfan_setup ( SModulFunctions p)

Definition at line 1079 of file bbfan.cc.

1080 {
1081  blackbox *b=(blackbox*)omAlloc0(sizeof(blackbox));
1082  // all undefined entries will be set to default in setBlackboxStuff
1083  // the default Print is quite usefule,
1084  // all other are simply error messages
1085  b->blackbox_destroy=bbfan_destroy;
1086  b->blackbox_String=bbfan_String;
1087  //b->blackbox_Print=blackbox_default_Print;
1088  b->blackbox_Init=bbfan_Init;
1089  b->blackbox_Copy=bbfan_Copy;
1090  b->blackbox_Assign=bbfan_Assign;
1091  b->blackbox_serialize=bbfan_serialize;
1092  b->blackbox_deserialize=bbfan_deserialize;
1093  p->iiAddCproc("gfan.lib","emptyFan",FALSE,emptyFan);
1094  p->iiAddCproc("gfan.lib","fullFan",FALSE,fullFan);
1095  /* the following functions are implemented in bbcone.cc */
1096  // iiAddCproc("gfan.lib","containsInSupport",FALSE,containsInSupport);
1097  // iiAddCproc("gfan.lib","getAmbientDimension",FALSE,getAmbientDimension);
1098  // iiAddCproc("gfan.lib","getCodimension",FALSE,getDimension);
1099  // iiAddCproc("gfan.lib","getDimension",FALSE,getDimension);
1100  // iiAddCproc("gfan.lib","getLinealityDimension",FALSE,getLinealityDimension);
1101  // iiAddCproc("gfan.lib","isSimplicial",FALSE,isSimplicial);
1102  /********************************************************/
1103  p->iiAddCproc("gfan.lib","isCompatible",FALSE,isCompatible);
1104  p->iiAddCproc("gfan.lib","numberOfConesOfDimension",FALSE,numberOfConesOfDimension);
1105  p->iiAddCproc("gfan.lib","ncones",FALSE,ncones);
1106  p->iiAddCproc("gfan.lib","nmaxcones",FALSE,nmaxcones);
1107  p->iiAddCproc("gfan.lib","insertCone",FALSE,insertCone);
1108  p->iiAddCproc("gfan.lib","removeCone",FALSE,removeCone);
1109  p->iiAddCproc("gfan.lib","getCone",FALSE,getCone);
1110  p->iiAddCproc("gfan.lib","getCones",FALSE,getCones);
1111  p->iiAddCproc("gfan.lib","isPure",FALSE,isPure);
1112  p->iiAddCproc("gfan.lib","fanFromString",FALSE,fanFromString);
1113  p->iiAddCproc("gfan.lib","fanViaCones",FALSE,fanViaCones);
1114  p->iiAddCproc("gfan.lib","numberOfConesWithVector",FALSE,numberOfConesWithVector);
1115  // iiAddCproc("gfan.lib","isComplete",FALSE,isComplete); not working as expected, should leave this to polymake
1116  p->iiAddCproc("gfan.lib","fVector",FALSE,fVector);
1117  p->iiAddCproc("gfan.lib","containsInCollection",FALSE,containsInCollection);
1118  // p->iiAddCproc("gfan.lib","tropicalVariety",FALSE,tropicalVariety);
1119  p->iiAddCproc("gfan.lib","commonRefinement",FALSE,commonRefinement);
1120  // iiAddCproc("gfan.lib","grFan",FALSE,grFan);
1121  fanID=setBlackboxStuff(b,"fan");
1122  //Print("created type %d (fan)\n",fanID);
1123 }
char * bbfan_String(blackbox *, void *d)
Definition: bbfan.cc:36
#define FALSE
Definition: auxiliary.h:95
BOOLEAN numberOfConesOfDimension(leftv res, leftv args)
Definition: bbfan.cc:267
BOOLEAN nmaxcones(leftv res, leftv args)
Definition: bbfan.cc:333
bool isCompatible(const gfan::ZFan *zf, const gfan::ZCone *zc)
Definition: bbfan.cc:353
void * bbfan_Init(blackbox *)
Definition: bbfan.cc:22
BOOLEAN fullFan(leftv res, leftv args)
Definition: bbfan.cc:229
BOOLEAN bbfan_Assign(leftv l, leftv r)
Definition: bbfan.cc:71
BOOLEAN emptyFan(leftv res, leftv args)
Definition: bbfan.cc:176
BOOLEAN fanViaCones(leftv res, leftv args)
Definition: bbfan.cc:821
int fanID
Definition: bbfan.cc:20
void * bbfan_Copy(blackbox *, void *d)
Definition: bbfan.cc:64
BOOLEAN bbfan_deserialize(blackbox **b, void **d, si_link f)
Definition: bbfan.cc:1060
BOOLEAN getCone(leftv res, leftv args)
Definition: bbfan.cc:547
BOOLEAN fanFromString(leftv res, leftv args)
Definition: bbfan.cc:804
BOOLEAN ncones(leftv res, leftv args)
Definition: bbfan.cc:312
int numberOfConesWithVector(gfan::ZFan *zf, gfan::ZVector *v)
Definition: bbfan.cc:757
BOOLEAN insertCone(leftv res, leftv args)
Definition: bbfan.cc:393
BOOLEAN fVector(leftv res, leftv args)
Definition: bbfan.cc:729
bool containsInCollection(gfan::ZFan *zf, gfan::ZCone *zc)
Definition: bbfan.cc:431
BOOLEAN getCones(leftv res, leftv args)
Definition: bbfan.cc:623
BOOLEAN isPure(leftv res, leftv args)
Definition: bbfan.cc:698
gfan::ZFan commonRefinement(gfan::ZFan zf, gfan::ZFan zg)
Definition: bbfan.cc:946
BOOLEAN removeCone(leftv res, leftv args)
Definition: bbfan.cc:510
BOOLEAN bbfan_serialize(blackbox *b, void *d, si_link f)
Definition: bbfan.cc:1041
int(* iiAddCproc)(const char *libname, const char *procname, BOOLEAN pstatic, BOOLEAN(*func)(leftv res, leftv v))
Definition: ipid.h:71
int setBlackboxStuff(blackbox *bb, const char *n)
define a new type
Definition: blackbox.cc:124
const poly b
Definition: syzextra.cc:213
void bbfan_destroy(blackbox *, void *d)
Definition: bbfan.cc:27
#define omAlloc0(size)
Definition: omAllocDecl.h:211

§ commonRefinement()

gfan::ZFan commonRefinement ( gfan::ZFan  zf,
gfan::ZFan  zg 
)

Definition at line 946 of file bbfan.cc.

947 {
948  assume(zf.getAmbientDimension() == zg.getAmbientDimension());
949 
950  // gather all maximal cones of f and g
951  std::list<gfan::ZCone> maximalConesOfF;
952  for (int d=0; d<=zf.getAmbientDimension(); d++)
953  for (int i=0; i<zf.numberOfConesOfDimension(d,0,1); i++)
954  maximalConesOfF.push_back(zf.getCone(d,i,0,1));
955 
956  std::list<gfan::ZCone> maximalConesOfG;
957  for (int d=0; d<=zg.getAmbientDimension(); d++)
958  for (int i=0; i<zg.numberOfConesOfDimension(d,0,1); i++)
959  maximalConesOfG.push_back(zg.getCone(d,i,0,1));
960 
961  // construct a new fan out of their intersections
962  gfan::ZFan zr = gfan::ZFan(zf.getAmbientDimension());
963  for (std::list<gfan::ZCone>::iterator itf=maximalConesOfF.begin();
964  itf != maximalConesOfF.end(); itf++)
965  for (std::list<gfan::ZCone>::iterator itg=maximalConesOfG.begin();
966  itg != maximalConesOfG.end(); itg++)
967  zr.insert(intersection(*itf,*itg));
968 
969  return zr;
970 }
#define assume(x)
Definition: mod2.h:403
int i
Definition: cfEzgcd.cc:123

§ getAmbientDimension()

int getAmbientDimension ( gfan::ZFan *  zf)

Definition at line 247 of file bbfan.cc.

248 {
249  return zf->getAmbientDimension();
250 }

§ getCodimension()

int getCodimension ( gfan::ZFan *  zf)

Definition at line 252 of file bbfan.cc.

253 {
254  return zf->getCodimension();
255 }

§ getDimension()

int getDimension ( gfan::ZFan *  zf)

Definition at line 257 of file bbfan.cc.

258 {
259  return zf->getDimension();
260 }

§ getLinealityDimension()

int getLinealityDimension ( gfan::ZFan *  zf)

Definition at line 262 of file bbfan.cc.

263 {
264  return zf->getLinealityDimension();
265 }

§ isCompatible()

bool isCompatible ( const gfan::ZFan *  zf,
const gfan::ZCone *  zc 
)

Definition at line 353 of file bbfan.cc.

354 {
355  bool b = (zf->getAmbientDimension() == zc->ambientDimension());
356  if(b)
357  {
358  for (int d=0; d<=zf->getAmbientDimension(); d++)
359  {
360  for (int i=0; i<zf->numberOfConesOfDimension(d,0,1); i++)
361  {
362  gfan::ZCone zd = zf->getCone(d,i,0,1);
363  gfan::ZCone zt = gfan::intersection(*zc,zd);
364  zt.canonicalize();
365  b = b && zd.hasFace(zt);
366  }
367  }
368  }
369  return b;
370 }
int i
Definition: cfEzgcd.cc:123
const poly b
Definition: syzextra.cc:213

§ isSimplicial()

int isSimplicial ( gfan::ZFan *  zf)

Definition at line 692 of file bbfan.cc.

693 {
694  int i = zf->isSimplicial() ? 1 : 0;
695  return i;
696 }
int i
Definition: cfEzgcd.cc:123

§ rays()

gfan::Matrix<gfan::Integer> rays ( const gfan::ZFan *const  zf)

Definition at line 745 of file bbfan.cc.

746 {
747  gfan::initializeCddlibIfRequired();
748  gfan::ZMatrix rays(0,zf->getAmbientDimension());
749  for (int i=0; i<zf->numberOfConesOfDimension(1,0,0); i++)
750  {
751  gfan::ZCone zc = zf->getCone(1, i, 0, 0);
752  rays.append(zc.extremeRays());
753  }
754  return rays;
755 }
gfan::ZMatrix rays(const gfan::ZFan *const zf)
Definition: bbfan.cc:745
int i
Definition: cfEzgcd.cc:123

Variable Documentation

§ fanID

int fanID

Definition at line 20 of file bbfan.cc.