Functions | Variables
bbfan.cc File Reference
#include <kernel/mod2.h>
#include <misc/intvec.h>
#include <coeffs/coeffs.h>
#include <coeffs/bigintmat.h>
#include <Singular/ipid.h>
#include <Singular/ipshell.h>
#include <Singular/blackbox.h>
#include <Singular/links/ssiLink.h>
#include <callgfanlib_conversion.h>
#include <bbfan.h>
#include <gfan.h>
#include <sstream>

Go to the source code of this file.

Functions

void * bbfan_Init (blackbox *)
 
void bbfan_destroy (blackbox *, void *d)
 
char * bbfan_String (blackbox *, void *d)
 
void * bbfan_Copy (blackbox *, void *d)
 
BOOLEAN bbfan_Assign (leftv l, leftv r)
 
static gfan::IntMatrix permutationIntMatrix (const bigintmat *iv)
 
static BOOLEAN jjFANEMPTY_I (leftv res, leftv v)
 
static BOOLEAN jjFANEMPTY_IM (leftv res, leftv v)
 
BOOLEAN emptyFan (leftv res, leftv args)
 
static BOOLEAN jjFANFULL_I (leftv res, leftv v)
 
static BOOLEAN jjFANFULL_IM (leftv res, leftv v)
 
BOOLEAN fullFan (leftv res, leftv args)
 
int getAmbientDimension (gfan::ZFan *zf)
 
int getCodimension (gfan::ZFan *zf)
 
int getDimension (gfan::ZFan *zf)
 
int getLinealityDimension (gfan::ZFan *zf)
 
BOOLEAN numberOfConesOfDimension (leftv res, leftv args)
 
BOOLEAN ncones (leftv res, leftv args)
 
BOOLEAN nmaxcones (leftv res, leftv args)
 
bool isCompatible (const gfan::ZFan *zf, const gfan::ZCone *zc)
 
BOOLEAN isCompatible (leftv res, leftv args)
 
BOOLEAN insertCone (leftv res, leftv args)
 
bool containsInCollection (gfan::ZFan *zf, gfan::ZCone *zc)
 
BOOLEAN containsInCollection (leftv res, leftv args)
 
BOOLEAN removeCone (leftv res, leftv args)
 
BOOLEAN getCone (leftv res, leftv args)
 
BOOLEAN getCones (leftv res, leftv args)
 
int isSimplicial (gfan::ZFan *zf)
 
BOOLEAN isPure (leftv res, leftv args)
 
BOOLEAN fVector (leftv res, leftv args)
 
gfan::ZMatrix rays (const gfan::ZFan *const zf)
 
int numberOfConesWithVector (gfan::ZFan *zf, gfan::ZVector *v)
 
BOOLEAN numberOfConesWithVector (leftv res, leftv args)
 
BOOLEAN fanFromString (leftv res, leftv args)
 
BOOLEAN fanViaCones (leftv res, leftv args)
 
gfan::ZFan commonRefinement (gfan::ZFan zf, gfan::ZFan zg)
 
BOOLEAN commonRefinement (leftv res, leftv args)
 
BOOLEAN bbfan_serialize (blackbox *b, void *d, si_link f)
 
BOOLEAN bbfan_deserialize (blackbox **b, void **d, si_link f)
 
void bbfan_setup (SModulFunctions *p)
 

Variables

int fanID
 

Function Documentation

◆ bbfan_Assign()

BOOLEAN bbfan_Assign ( leftv  l,
leftv  r 
)

Definition at line 72 of file bbfan.cc.

73 {
74  gfan::ZFan* newZf;
75  if (r==NULL)
76  {
77  if (l->Data()!=NULL)
78  {
79  gfan::ZFan* zd = (gfan::ZFan*) l->Data();
80  delete zd;
81  }
82  newZf = new gfan::ZFan(0);
83  }
84  else if (r->Typ()==l->Typ())
85  {
86  if (l->Data()!=NULL)
87  {
88  gfan::ZFan* zd = (gfan::ZFan*) l->Data();
89  delete zd;
90  }
91  newZf = (gfan::ZFan*) r->CopyD();
92  }
93  else if (r->Typ()==INT_CMD)
94  {
95  int ambientDim = (int) (long) r->Data();
96  if (ambientDim < 0)
97  {
98  Werror("expected an int >= 0, but got %d", ambientDim);
99  return TRUE;
100  }
101  if (l->Data()!=NULL)
102  {
103  gfan::ZFan* zd = (gfan::ZFan*) l->Data();
104  delete zd;
105  }
106  newZf = new gfan::ZFan(ambientDim);
107  }
108  else
109  {
110  Werror("assign Type(%d) = Type(%d) not implemented",l->Typ(),r->Typ());
111  return TRUE;
112  }
113 
114  if (l->rtyp==IDHDL)
115  {
116  IDDATA((idhdl)l->data) = (char*) newZf;
117  }
118  else
119  {
120  l->data = (void*) newZf;
121  }
122  return FALSE;
123 }
Definition: tok.h:95
#define FALSE
Definition: auxiliary.h:94
#define TRUE
Definition: auxiliary.h:98
int Typ()
Definition: subexpr.cc:995
Definition: idrec.h:34
#define IDHDL
Definition: tok.h:31
void * data
Definition: subexpr.h:89
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1137
#define IDDATA(a)
Definition: ipid.h:123
void Werror(const char *fmt,...)
Definition: reporter.cc:189
void * CopyD(int t)
Definition: subexpr.cc:707

◆ bbfan_Copy()

void* bbfan_Copy ( blackbox *  ,
void *  d 
)

Definition at line 65 of file bbfan.cc.

66 {
67  gfan::ZFan* zf = (gfan::ZFan*)d;
68  gfan::ZFan* newZf = new gfan::ZFan(*zf);
69  return newZf;
70 }

◆ bbfan_deserialize()

BOOLEAN bbfan_deserialize ( blackbox **  b,
void **  d,
si_link  f 
)

Definition at line 1093 of file bbfan.cc.

1094 {
1095  ssiInfo *dd = (ssiInfo *)f->data;
1096 
1097  int l = s_readint(dd->f_read);
1098  char* buf = (char*) omAlloc0(l+1);
1099  (void) s_getc(dd->f_read); // skip whitespace
1100  (void) s_readbytes(buf,l,dd->f_read);
1101  buf[l]='\0';
1102 
1103  std::istringstream fanInString(std::string(buf,l));
1104  gfan::ZFan* zf = new gfan::ZFan(fanInString);
1105  *d=zf;
1106 
1107  omFree(buf);
1108  return FALSE;
1109 }
int s_readbytes(char *buff, int len, s_buff F)
Definition: s_buff.cc:166
#define FALSE
Definition: auxiliary.h:94
#define string
Definition: libparse.cc:1250
int s_getc(s_buff F)
Definition: s_buff.cc:56
int s_readint(s_buff F)
Definition: s_buff.cc:110
#define omFree(addr)
Definition: omAllocDecl.h:261
int status int void * buf
Definition: si_signals.h:59
FILE * f
Definition: checklibs.c:9
#define omAlloc0(size)
Definition: omAllocDecl.h:211
int l
Definition: cfEzgcd.cc:94

◆ bbfan_destroy()

void bbfan_destroy ( blackbox *  ,
void *  d 
)

Definition at line 27 of file bbfan.cc.

28 {
29  if (d!=NULL)
30  {
31  gfan::ZFan* zf = (gfan::ZFan*) d;
32  delete zf;
33  }
34 }
#define NULL
Definition: omList.c:10

◆ bbfan_Init()

void* bbfan_Init ( blackbox *  )

Definition at line 22 of file bbfan.cc.

23 {
24  return (void*) new gfan::ZFan(0);
25 }

◆ bbfan_serialize()

BOOLEAN bbfan_serialize ( blackbox *  b,
void *  d,
si_link  f 
)

Definition at line 1074 of file bbfan.cc.

1075 {
1076  ssiInfo *dd = (ssiInfo *)f->data;
1077 
1078  sleftv l;
1079  memset(&l,0,sizeof(l));
1080  l.rtyp=STRING_CMD;
1081  l.data=(void*)"fan";
1082  f->m->Write(f, &l);
1083 
1084  gfan::ZFan* zf = (gfan::ZFan*) d;
1085  std::string s = zf->toString(2+4+8+128);
1086 
1087  fprintf(dd->f_write,"%d %s ",(int)s.size(),s.c_str());
1088 
1089  return FALSE;
1090 }
const CanonicalForm int s
Definition: facAbsFact.cc:55
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
#define FALSE
Definition: auxiliary.h:94
#define string
Definition: libparse.cc:1250
FILE * f
Definition: checklibs.c:9
int l
Definition: cfEzgcd.cc:94

◆ bbfan_setup()

void bbfan_setup ( SModulFunctions p)

Definition at line 1112 of file bbfan.cc.

1113 {
1114  blackbox *b=(blackbox*)omAlloc0(sizeof(blackbox));
1115  // all undefined entries will be set to default in setBlackboxStuff
1116  // the default Print is quite usefule,
1117  // all other are simply error messages
1118  b->blackbox_destroy=bbfan_destroy;
1119  b->blackbox_String=bbfan_String;
1120  //b->blackbox_Print=blackbox_default_Print;
1121  b->blackbox_Init=bbfan_Init;
1122  b->blackbox_Copy=bbfan_Copy;
1123  b->blackbox_Assign=bbfan_Assign;
1124  b->blackbox_serialize=bbfan_serialize;
1125  b->blackbox_deserialize=bbfan_deserialize;
1126  p->iiAddCproc("gfan.lib","emptyFan",FALSE,emptyFan);
1127  p->iiAddCproc("gfan.lib","fullFan",FALSE,fullFan);
1128  /* the following functions are implemented in bbcone.cc */
1129  // iiAddCproc("gfan.lib","containsInSupport",FALSE,containsInSupport);
1130  // iiAddCproc("gfan.lib","getAmbientDimension",FALSE,getAmbientDimension);
1131  // iiAddCproc("gfan.lib","getCodimension",FALSE,getDimension);
1132  // iiAddCproc("gfan.lib","getDimension",FALSE,getDimension);
1133  // iiAddCproc("gfan.lib","getLinealityDimension",FALSE,getLinealityDimension);
1134  // iiAddCproc("gfan.lib","isSimplicial",FALSE,isSimplicial);
1135  /********************************************************/
1136  p->iiAddCproc("gfan.lib","isCompatible",FALSE,isCompatible);
1137  p->iiAddCproc("gfan.lib","numberOfConesOfDimension",FALSE,numberOfConesOfDimension);
1138  p->iiAddCproc("gfan.lib","ncones",FALSE,ncones);
1139  p->iiAddCproc("gfan.lib","nmaxcones",FALSE,nmaxcones);
1140  p->iiAddCproc("gfan.lib","insertCone",FALSE,insertCone);
1141  p->iiAddCproc("gfan.lib","removeCone",FALSE,removeCone);
1142  p->iiAddCproc("gfan.lib","getCone",FALSE,getCone);
1143  p->iiAddCproc("gfan.lib","getCones",FALSE,getCones);
1144  p->iiAddCproc("gfan.lib","isPure",FALSE,isPure);
1145  p->iiAddCproc("gfan.lib","fanFromString",FALSE,fanFromString);
1146  p->iiAddCproc("gfan.lib","fanViaCones",FALSE,fanViaCones);
1147  p->iiAddCproc("gfan.lib","numberOfConesWithVector",FALSE,numberOfConesWithVector);
1148  // iiAddCproc("gfan.lib","isComplete",FALSE,isComplete); not working as expected, should leave this to polymake
1149  p->iiAddCproc("gfan.lib","fVector",FALSE,fVector);
1150  p->iiAddCproc("gfan.lib","containsInCollection",FALSE,containsInCollection);
1151  // p->iiAddCproc("gfan.lib","tropicalVariety",FALSE,tropicalVariety);
1152  p->iiAddCproc("gfan.lib","commonRefinement",FALSE,commonRefinement);
1153  // iiAddCproc("gfan.lib","grFan",FALSE,grFan);
1154  fanID=setBlackboxStuff(b,"fan");
1155  //Print("created type %d (fan)\n",fanID);
1156 }
char * bbfan_String(blackbox *, void *d)
Definition: bbfan.cc:36
#define FALSE
Definition: auxiliary.h:94
BOOLEAN numberOfConesOfDimension(leftv res, leftv args)
Definition: bbfan.cc:267
BOOLEAN nmaxcones(leftv res, leftv args)
Definition: bbfan.cc:336
bool isCompatible(const gfan::ZFan *zf, const gfan::ZCone *zc)
Definition: bbfan.cc:357
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:72
BOOLEAN emptyFan(leftv res, leftv args)
Definition: bbfan.cc:177
BOOLEAN fanViaCones(leftv res, leftv args)
Definition: bbfan.cc:844
int fanID
Definition: bbfan.cc:20
void * bbfan_Copy(blackbox *, void *d)
Definition: bbfan.cc:65
BOOLEAN bbfan_deserialize(blackbox **b, void **d, si_link f)
Definition: bbfan.cc:1093
BOOLEAN getCone(leftv res, leftv args)
Definition: bbfan.cc:558
BOOLEAN fanFromString(leftv res, leftv args)
Definition: bbfan.cc:826
BOOLEAN ncones(leftv res, leftv args)
Definition: bbfan.cc:314
int numberOfConesWithVector(gfan::ZFan *zf, gfan::ZVector *v)
Definition: bbfan.cc:778
BOOLEAN insertCone(leftv res, leftv args)
Definition: bbfan.cc:398
BOOLEAN fVector(leftv res, leftv args)
Definition: bbfan.cc:750
bool containsInCollection(gfan::ZFan *zf, gfan::ZCone *zc)
Definition: bbfan.cc:438
BOOLEAN getCones(leftv res, leftv args)
Definition: bbfan.cc:639
BOOLEAN isPure(leftv res, leftv args)
Definition: bbfan.cc:718
gfan::ZFan commonRefinement(gfan::ZFan zf, gfan::ZFan zg)
Definition: bbfan.cc:978
BOOLEAN removeCone(leftv res, leftv args)
Definition: bbfan.cc:519
BOOLEAN bbfan_serialize(blackbox *b, void *d, si_link f)
Definition: bbfan.cc:1074
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:126
const poly b
Definition: syzextra.cc:213
void bbfan_destroy(blackbox *, void *d)
Definition: bbfan.cc:27
#define omAlloc0(size)
Definition: omAllocDecl.h:211

◆ bbfan_String()

char* bbfan_String ( blackbox *  ,
void *  d 
)

Definition at line 36 of file bbfan.cc.

37 {
38  if (d==NULL) return omStrDup("invalid object");
39  else
40  {
41  gfan::initializeCddlibIfRequired();
42  gfan::ZFan* zf = (gfan::ZFan*)d;
43  std::string s = zf->toString(2+4+8+128);
44  gfan::deinitializeCddlibIfRequired();
45  return omStrDup(s.c_str());
46 // =======
47 // std::stringstream s;
48 // std::string raysAndCones = zf->toStringJustRaysAndMaximalCones();
49 // s << raysAndCones;
50 // if (zf->getDimension() >= 0) // <=> zf is not empty
51 // {
52 // assert(zf->numberOfConesOfDimension(zf->getDimension()-zf->getLinealityDimension(),0,0));
53 // gfan::ZCone zc = zf->getCone(zf->getDimension()-zf->getLinealityDimension(),0,0,0);
54 // gfan::ZMatrix genLinSpace = zc.generatorsOfLinealitySpace();
55 // char* gens = toString(genLinSpace);
56 // s << std::endl << "GENERATORS_LINEALITY_SPACE:" << std::endl;
57 // s << gens;
58 // }
59 // std::string sstring = s.str();
60 // return omStrDup(sstring.c_str());
61 // >>>>>>> status updated 11.03.
62  }
63 }
const CanonicalForm int s
Definition: facAbsFact.cc:55
#define string
Definition: libparse.cc:1250
#define NULL
Definition: omList.c:10
#define omStrDup(s)
Definition: omAllocDecl.h:263

◆ commonRefinement() [1/2]

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

Definition at line 978 of file bbfan.cc.

979 {
980  assume(zf.getAmbientDimension() == zg.getAmbientDimension());
981 
982  // gather all maximal cones of f and g
983  std::list<gfan::ZCone> maximalConesOfF;
984  for (int d=0; d<=zf.getAmbientDimension(); d++)
985  for (int i=0; i<zf.numberOfConesOfDimension(d,0,1); i++)
986  maximalConesOfF.push_back(zf.getCone(d,i,0,1));
987 
988  std::list<gfan::ZCone> maximalConesOfG;
989  for (int d=0; d<=zg.getAmbientDimension(); d++)
990  for (int i=0; i<zg.numberOfConesOfDimension(d,0,1); i++)
991  maximalConesOfG.push_back(zg.getCone(d,i,0,1));
992 
993  // construct a new fan out of their intersections
994  gfan::ZFan zr = gfan::ZFan(zf.getAmbientDimension());
995  for (std::list<gfan::ZCone>::iterator itf=maximalConesOfF.begin();
996  itf != maximalConesOfF.end(); itf++)
997  for (std::list<gfan::ZCone>::iterator itg=maximalConesOfG.begin();
998  itg != maximalConesOfG.end(); itg++)
999  zr.insert(intersection(*itf,*itg));
1000 
1001  return zr;
1002 }
#define assume(x)
Definition: mod2.h:394
int i
Definition: cfEzgcd.cc:123

◆ commonRefinement() [2/2]

BOOLEAN commonRefinement ( leftv  res,
leftv  args 
)

Definition at line 1004 of file bbfan.cc.

1005 {
1006  leftv u=args;
1007  if ((u != NULL) && (u->Typ() == fanID))
1008  {
1009  leftv v=u->next;
1010  if ((v != NULL) && (v->Typ() == fanID))
1011  {
1012  gfan::initializeCddlibIfRequired();
1013  gfan::ZFan* zf = (gfan::ZFan*) u->Data();
1014  gfan::ZFan* zg = (gfan::ZFan*) v->Data();
1015  gfan::ZFan* zr = new gfan::ZFan(commonRefinement(*zf,*zg));
1016  res->rtyp = fanID;
1017  res->data = (void*) zr;
1018  gfan::deinitializeCddlibIfRequired();
1019  return FALSE;
1020  }
1021  }
1022  WerrorS("commonRefinement: unexpected parameters");
1023  return TRUE;
1024 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
#define FALSE
Definition: auxiliary.h:94
#define TRUE
Definition: auxiliary.h:98
void WerrorS(const char *s)
Definition: feFopen.cc:24
int fanID
Definition: bbfan.cc:20
int Typ()
Definition: subexpr.cc:995
void * data
Definition: subexpr.h:89
leftv next
Definition: subexpr.h:87
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
gfan::ZFan commonRefinement(gfan::ZFan zf, gfan::ZFan zg)
Definition: bbfan.cc:978
void * Data()
Definition: subexpr.cc:1137

◆ containsInCollection() [1/2]

bool containsInCollection ( gfan::ZFan *  zf,
gfan::ZCone *  zc 
)

Definition at line 438 of file bbfan.cc.

439 {
440  gfan::ZVector zv=zc->getRelativeInteriorPoint();
441  for (int d=0; d<=zf->getAmbientDimension(); d++)
442  {
443  for (int i=0; i<zf->numberOfConesOfDimension(d,0,1); i++)
444  {
445  gfan::ZCone zd = zf->getCone(d,i,0,1);
446  zd.canonicalize();
447  if (zd.containsRelatively(zv))
448  {
449  gfan::ZCone temp = *zc;
450  temp.canonicalize();
451  return (!(zd != temp));
452  }
453  }
454  }
455  return 0;
456 }
int i
Definition: cfEzgcd.cc:123

◆ containsInCollection() [2/2]

BOOLEAN containsInCollection ( leftv  res,
leftv  args 
)

Definition at line 458 of file bbfan.cc.

459 {
460  leftv u=args;
461  if ((u != NULL) && (u->Typ() == fanID))
462  {
463  leftv v=u->next;
464  if ((v != NULL) && (v->Typ() == coneID))
465  {
466  gfan::initializeCddlibIfRequired();
467  gfan::ZFan* zf = (gfan::ZFan*)u->Data();
468  gfan::ZCone* zc = (gfan::ZCone*)v->Data();
469  if((zf->getAmbientDimension() == zc->ambientDimension()))
470  {
471  res->rtyp = INT_CMD;
472  res->data = (void*) (long) (int) containsInCollection(zf,zc);
473  gfan::deinitializeCddlibIfRequired();
474  return FALSE;
475  }
476  gfan::deinitializeCddlibIfRequired();
477  WerrorS("containsInCollection: mismatching ambient dimensions");
478  return TRUE;
479  }
480  }
481  WerrorS("containsInCollection: unexpected parameters");
482  return TRUE;
483 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: tok.h:95
#define FALSE
Definition: auxiliary.h:94
#define TRUE
Definition: auxiliary.h:98
void WerrorS(const char *s)
Definition: feFopen.cc:24
int fanID
Definition: bbfan.cc:20
int Typ()
Definition: subexpr.cc:995
void * data
Definition: subexpr.h:89
bool containsInCollection(gfan::ZFan *zf, gfan::ZCone *zc)
Definition: bbfan.cc:438
int coneID
Definition: bbcone.cc:26
leftv next
Definition: subexpr.h:87
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1137

◆ emptyFan()

BOOLEAN emptyFan ( leftv  res,
leftv  args 
)

Definition at line 177 of file bbfan.cc.

178 {
179  leftv u = args;
180  if (u == NULL)
181  {
182  res->rtyp = fanID;
183  res->data = (void*) new gfan::ZFan(0);
184  return FALSE;
185  }
186  if ((u != NULL) && (u->Typ() == INT_CMD))
187  {
188  if (u->next == NULL) return jjFANEMPTY_I(res, u);
189  }
190  if ((u != NULL) && (u->Typ() == BIGINTMAT_CMD))
191  {
192  if (u->next == NULL) return jjFANEMPTY_IM(res, u);
193  }
194  WerrorS("emptyFan: unexpected parameters");
195  return TRUE;
196 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: tok.h:95
#define FALSE
Definition: auxiliary.h:94
#define TRUE
Definition: auxiliary.h:98
void WerrorS(const char *s)
Definition: feFopen.cc:24
static BOOLEAN jjFANEMPTY_IM(leftv res, leftv v)
Definition: bbfan.cc:160
int fanID
Definition: bbfan.cc:20
int Typ()
Definition: subexpr.cc:995
void * data
Definition: subexpr.h:89
static BOOLEAN jjFANEMPTY_I(leftv res, leftv v)
Definition: bbfan.cc:147
leftv next
Definition: subexpr.h:87
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92

◆ fanFromString()

BOOLEAN fanFromString ( leftv  res,
leftv  args 
)

Definition at line 826 of file bbfan.cc.

827 {
828  leftv u=args;
829  if ((u != NULL) && (u->Typ() == STRING_CMD))
830  {
831  gfan::initializeCddlibIfRequired();
832  std::string fanInString = (char*) u->Data();
833  std::istringstream s(fanInString);
834  gfan::ZFan* zf = new gfan::ZFan(s);
835  res->rtyp = fanID;
836  res->data = (void*) zf;
837  gfan::deinitializeCddlibIfRequired();
838  return FALSE;
839  }
840  WerrorS("fanFromString: unexpected parameters");
841  return TRUE;
842 }
const CanonicalForm int s
Definition: facAbsFact.cc:55
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
#define FALSE
Definition: auxiliary.h:94
#define string
Definition: libparse.cc:1250
#define TRUE
Definition: auxiliary.h:98
void WerrorS(const char *s)
Definition: feFopen.cc:24
int fanID
Definition: bbfan.cc:20
int Typ()
Definition: subexpr.cc:995
void * data
Definition: subexpr.h:89
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1137

◆ fanViaCones()

BOOLEAN fanViaCones ( leftv  res,
leftv  args 
)

Definition at line 844 of file bbfan.cc.

845 {
846  leftv u=args;
847  if ((u != NULL) && (u->Typ() == LIST_CMD))
848  {
849  lists L = (lists) u->Data();
850  if (lSize(L)>-1)
851  {
852  gfan::initializeCddlibIfRequired();
853  if (L->m[0].Typ() != coneID)
854  {
855  WerrorS("fanViaCones: list contains entries of wrong type");
856  return TRUE;
857  }
858  gfan::ZCone* zc = (gfan::ZCone*) L->m[0].Data();
859  gfan::ZFan* zf = new gfan::ZFan(zc->ambientDimension());
860  zf->insert(*zc);
861  for (int i=1; i<=lSize(L); i++)
862  {
863  if (L->m[i].Typ() != coneID)
864  {
865  WerrorS("fanViaCones: entries of wrong type in list");
866  gfan::deinitializeCddlibIfRequired();
867  return TRUE;
868  }
869  gfan::ZCone* zc = (gfan::ZCone*) L->m[i].Data();
870  if (zc->ambientDimension() != zf->getAmbientDimension())
871  {
872  WerrorS("fanViaCones: inconsistent ambient dimensions amongst cones in list");
873  gfan::deinitializeCddlibIfRequired();
874  return TRUE;
875  }
876  zf->insert(*zc);
877  }
878  res->rtyp = fanID;
879  res->data = (void*) zf;
880  gfan::deinitializeCddlibIfRequired();
881  return FALSE;
882  }
883  res->rtyp = fanID;
884  res->data = (void*) new gfan::ZFan(0);
885  return FALSE;
886  }
887  if ((u != NULL) && (u->Typ() == coneID))
888  {
889  gfan::initializeCddlibIfRequired();
890  gfan::ZCone* zc = (gfan::ZCone*) u->Data();
891  gfan::ZFan* zf = new gfan::ZFan(zc->ambientDimension());
892  zf->insert(*zc);
893  while (u->next != NULL)
894  {
895  u = u->next;
896  if (u->Typ() != coneID)
897  {
898  WerrorS("fanViaCones: arguments of wrong type");
899  gfan::deinitializeCddlibIfRequired();
900  delete zf;
901  return TRUE;
902  }
903  gfan::ZCone* zc = (gfan::ZCone*) u->Data();
904  if (zc->ambientDimension() != zf->getAmbientDimension())
905  {
906  WerrorS("fanViaCones: inconsistent ambient dimensions amongst input cones");
907  gfan::deinitializeCddlibIfRequired();
908  delete zf;
909  return TRUE;
910  }
911  zf->insert(*zc);
912  }
913  res->rtyp = fanID;
914  res->data = (void*) zf;
915  gfan::deinitializeCddlibIfRequired();
916  return FALSE;
917  }
918  if (u == NULL)
919  {
920  res->rtyp = fanID;
921  res->data = (void*) new gfan::ZFan(0);
922  return FALSE;
923  }
924  WerrorS("fanViaCones: unexpected parameters");
925  return TRUE;
926 }
sleftv * m
Definition: lists.h:45
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: lists.h:22
#define FALSE
Definition: auxiliary.h:94
#define TRUE
Definition: auxiliary.h:98
void WerrorS(const char *s)
Definition: feFopen.cc:24
int fanID
Definition: bbfan.cc:20
int Typ()
Definition: subexpr.cc:995
void * data
Definition: subexpr.h:89
int coneID
Definition: bbcone.cc:26
int i
Definition: cfEzgcd.cc:123
int lSize(lists L)
Definition: lists.cc:25
leftv next
Definition: subexpr.h:87
#define NULL
Definition: omList.c:10
slists * lists
Definition: mpr_numeric.h:146
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1137
Definition: tok.h:117

◆ fullFan()

BOOLEAN fullFan ( leftv  res,
leftv  args 
)

Definition at line 229 of file bbfan.cc.

230 {
231  gfan::initializeCddlibIfRequired();
232  leftv u = args;
233  if (u == NULL)
234  {
235  res->rtyp = fanID;
236  res->data = (void*) new gfan::ZFan(0);
237  return FALSE;
238  }
239  if ((u != NULL) && (u->Typ() == INT_CMD))
240  if (u->next == NULL) return jjFANFULL_I(res, u);
241  if ((u != NULL) && (u->Typ() == BIGINTMAT_CMD))
242  if (u->next == NULL) return jjFANFULL_IM(res, u);
243  WerrorS("fullFan: unexpected parameters");
244  return TRUE;
245 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: tok.h:95
#define FALSE
Definition: auxiliary.h:94
#define TRUE
Definition: auxiliary.h:98
void WerrorS(const char *s)
Definition: feFopen.cc:24
int fanID
Definition: bbfan.cc:20
int Typ()
Definition: subexpr.cc:995
void * data
Definition: subexpr.h:89
leftv next
Definition: subexpr.h:87
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
static BOOLEAN jjFANFULL_IM(leftv res, leftv v)
Definition: bbfan.cc:211
static BOOLEAN jjFANFULL_I(leftv res, leftv v)
Definition: bbfan.cc:198

◆ fVector()

BOOLEAN fVector ( leftv  res,
leftv  args 
)

Definition at line 750 of file bbfan.cc.

751 {
752  leftv u=args;
753  if ((u != NULL) && (u->Typ() == fanID))
754  {
755  gfan::initializeCddlibIfRequired();
756  gfan::ZFan* zf = (gfan::ZFan*) u->Data();
757  gfan::ZVector zv=zf->getFVector();
758  res->rtyp = BIGINTMAT_CMD;
759  res->data = (void*) zVectorToBigintmat(zv);
760  gfan::deinitializeCddlibIfRequired();
761  return FALSE;
762  }
763  WerrorS("fVector: unexpected parameters");
764  return TRUE;
765 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
#define FALSE
Definition: auxiliary.h:94
#define TRUE
Definition: auxiliary.h:98
void WerrorS(const char *s)
Definition: feFopen.cc:24
bigintmat * zVectorToBigintmat(const gfan::ZVector &zv)
int fanID
Definition: bbfan.cc:20
int Typ()
Definition: subexpr.cc:995
void * data
Definition: subexpr.h:89
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1137

◆ 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 }

◆ getCone()

BOOLEAN getCone ( leftv  res,
leftv  args 
)

Definition at line 558 of file bbfan.cc.

559 {
560  leftv u=args;
561  if ((u != NULL) && (u->Typ() == fanID))
562  {
563  leftv v=u->next;
564  if ((v != NULL) && (v->Typ() == INT_CMD))
565  {
566  leftv w=v->next;
567  if ((w != NULL) && (w->Typ() == INT_CMD))
568  {
569  gfan::initializeCddlibIfRequired();
570  gfan::ZFan* zf = (gfan::ZFan*) u->Data();
571  int d = (int)(long)v->Data();
572  int i = (int)(long)w->Data();
573  int o = -1;
574  int m = -1;
575  leftv x=w->next;
576  if ((x != NULL) && (x->Typ() == INT_CMD))
577  {
578  o = (int)(long)x->Data();
579  leftv y=x->next;
580  if ((y != NULL) && (y->Typ() == INT_CMD))
581  {
582  m = (int)(long)y->Data();
583  }
584  }
585  if (o == -1) o = 0;
586  if (m == -1) m = 0;
587  if (((o == 0) || (o == 1)) && ((m == 0) || (m == 1)))
588  {
589  bool oo = (bool) o;
590  bool mm = (bool) m;
591  if (0<=d && d<=zf->getAmbientDimension())
592  {
593  int ld = zf->getLinealityDimension();
594  if (0<i && i<=zf->numberOfConesOfDimension(d-ld,oo,mm))
595  {
596  i=i-1;
597  if (d-ld>=0)
598  {
599  gfan::ZCone zc = zf->getCone(d-ld,i,oo,mm);
600  res->rtyp = coneID;
601  res->data = (void*)new gfan::ZCone(zc);
602  gfan::deinitializeCddlibIfRequired();
603  return FALSE;
604  }
605  else
606  {
607  WerrorS("getCone: invalid dimension; no cones in this dimension");
608  gfan::deinitializeCddlibIfRequired();
609  return TRUE;
610  }
611  }
612  else
613  {
614  WerrorS("getCone: invalid index");
615  gfan::deinitializeCddlibIfRequired();
616  return TRUE;
617  }
618  }
619  else
620  {
621  WerrorS("getCone: invalid dimension");
622  gfan::deinitializeCddlibIfRequired();
623  return TRUE;
624  }
625  }
626  else
627  {
628  WerrorS("getCone: invalid specifier for orbit or maximal");
629  gfan::deinitializeCddlibIfRequired();
630  return TRUE;
631  }
632  }
633  }
634  }
635  WerrorS("getCone: unexpected parameters");
636  return TRUE;
637 }
const CanonicalForm int const CFList const Variable & y
Definition: facAbsFact.cc:57
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: tok.h:95
#define FALSE
Definition: auxiliary.h:94
BOOLEAN numberOfConesOfDimension(leftv res, leftv args)
Definition: bbfan.cc:267
#define TRUE
Definition: auxiliary.h:98
void WerrorS(const char *s)
Definition: feFopen.cc:24
int fanID
Definition: bbfan.cc:20
int Typ()
Definition: subexpr.cc:995
int getAmbientDimension(gfan::ZFan *zf)
Definition: bbfan.cc:247
void * data
Definition: subexpr.h:89
int m
Definition: cfEzgcd.cc:119
int coneID
Definition: bbcone.cc:26
int i
Definition: cfEzgcd.cc:123
leftv next
Definition: subexpr.h:87
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
#define NULL
Definition: omList.c:10
const CanonicalForm & w
Definition: facAbsFact.cc:55
int rtyp
Definition: subexpr.h:92
Variable x
Definition: cfModGcd.cc:4023
void * Data()
Definition: subexpr.cc:1137

◆ getCones()

BOOLEAN getCones ( leftv  res,
leftv  args 
)

Definition at line 639 of file bbfan.cc.

640 {
641  leftv u=args;
642  if ((u != NULL) && (u->Typ() == fanID))
643  {
644  leftv v=u->next;
645  if ((v != NULL) && (v->Typ() == INT_CMD))
646  {
647  gfan::initializeCddlibIfRequired();
648  gfan::ZFan* zf = (gfan::ZFan*) u->Data();
649  int d = (int)(long)v->Data();
650  int o = -1;
651  int m = -1;
652  leftv w=v->next;
653  if ((w != NULL) && (w->Typ() == INT_CMD))
654  {
655  o = (int)(long)w->Data();
656  leftv x=w->next;
657  if ((x != NULL) && (x->Typ() == INT_CMD))
658  {
659  m = (int)(long)x->Data();
660  }
661  }
662  if (o == -1) o = 0;
663  if (m == -1) m = 0;
664  if (((o == 0) || (o == 1)) && ((m == 0) || (m == 1)))
665  {
666  bool oo = (bool) o;
667  bool mm = (bool) m;
668  if (0<=d && d<=zf->getAmbientDimension())
669  {
670  int ld = zf->getLinealityDimension();
671  if (d-ld>=0)
672  {
674  int n = zf->numberOfConesOfDimension(d-ld,oo,mm);
675  L->Init(n);
676  for (int i=0; i<n; i++)
677  {
678  gfan::ZCone zc = zf->getCone(d-ld,i,oo,mm);
679  L->m[i].rtyp = coneID; L->m[i].data=(void*) new gfan::ZCone(zc);
680  }
681  res->rtyp = LIST_CMD;
682  res->data = (void*) L;
683  gfan::deinitializeCddlibIfRequired();
684  return FALSE;
685  }
686  else
687  {
688  WerrorS("getCones: invalid dimension; no cones in this dimension");
689  gfan::deinitializeCddlibIfRequired();
690  return TRUE;
691  }
692  }
693  else
694  {
695  WerrorS("getCones: invalid dimension");
696  gfan::deinitializeCddlibIfRequired();
697  return TRUE;
698  }
699  }
700  else
701  {
702  WerrorS("getCones: invalid specifier for orbit or maximal");
703  gfan::deinitializeCddlibIfRequired();
704  return TRUE;
705  }
706  }
707  }
708  WerrorS("getCones: unexpected parameters");
709  return TRUE;
710 }
#define omAllocBin(bin)
Definition: omAllocDecl.h:205
sleftv * m
Definition: lists.h:45
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: tok.h:95
Definition: lists.h:22
#define FALSE
Definition: auxiliary.h:94
#define TRUE
Definition: auxiliary.h:98
void WerrorS(const char *s)
Definition: feFopen.cc:24
int fanID
Definition: bbfan.cc:20
int Typ()
Definition: subexpr.cc:995
int getAmbientDimension(gfan::ZFan *zf)
Definition: bbfan.cc:247
void * data
Definition: subexpr.h:89
int m
Definition: cfEzgcd.cc:119
int coneID
Definition: bbcone.cc:26
int i
Definition: cfEzgcd.cc:123
leftv next
Definition: subexpr.h:87
INLINE_THIS void Init(int l=0)
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
#define NULL
Definition: omList.c:10
slists * lists
Definition: mpr_numeric.h:146
const CanonicalForm & w
Definition: facAbsFact.cc:55
int rtyp
Definition: subexpr.h:92
Variable x
Definition: cfModGcd.cc:4023
void * Data()
Definition: subexpr.cc:1137
Definition: tok.h:117
omBin slists_bin
Definition: lists.cc:23

◆ 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 }

◆ insertCone()

BOOLEAN insertCone ( leftv  res,
leftv  args 
)

Definition at line 398 of file bbfan.cc.

399 {
400  leftv u=args;
401  if ((u != NULL) && (u->rtyp==IDHDL) && (u->e==NULL) && (u->Typ() == fanID))
402  {
403  leftv v=u->next;
404  if ((v != NULL) && (v->Typ() == coneID))
405  {
406  gfan::initializeCddlibIfRequired();
407  gfan::ZFan* zf = (gfan::ZFan*)u->Data();
408  gfan::ZCone* zc = (gfan::ZCone*)v->Data();
409  zc->canonicalize();
410 
411  leftv w=v->next;
412  int n;
413  if ((w != NULL) && (w->Typ() == INT_CMD))
414  n = (int)(long) w;
415 
416  if (n != 0)
417  {
418  if (!isCompatible(zf,zc))
419  {
420  WerrorS("insertCone: cone and fan not compatible");
421  gfan::deinitializeCddlibIfRequired();
422  return TRUE;
423  }
424  }
425 
426  zf->insert(*zc);
427  res->rtyp = NONE;
428  res->data = NULL;
429  IDDATA((idhdl)u->data) = (char*) zf;
430  gfan::deinitializeCddlibIfRequired();
431  return FALSE;
432  }
433  }
434  WerrorS("insertCone: unexpected parameters");
435  return TRUE;
436 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: tok.h:95
Subexpr e
Definition: subexpr.h:106
#define FALSE
Definition: auxiliary.h:94
bool isCompatible(const gfan::ZFan *zf, const gfan::ZCone *zc)
Definition: bbfan.cc:357
#define TRUE
Definition: auxiliary.h:98
void WerrorS(const char *s)
Definition: feFopen.cc:24
int fanID
Definition: bbfan.cc:20
int Typ()
Definition: subexpr.cc:995
Definition: idrec.h:34
#define IDHDL
Definition: tok.h:31
void * data
Definition: subexpr.h:89
int coneID
Definition: bbcone.cc:26
leftv next
Definition: subexpr.h:87
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
#define NULL
Definition: omList.c:10
const CanonicalForm & w
Definition: facAbsFact.cc:55
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1137
#define IDDATA(a)
Definition: ipid.h:123
#define NONE
Definition: tok.h:216

◆ isCompatible() [1/2]

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

Definition at line 357 of file bbfan.cc.

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

◆ isCompatible() [2/2]

BOOLEAN isCompatible ( leftv  res,
leftv  args 
)

Definition at line 376 of file bbfan.cc.

377 {
378  leftv u=args;
379  if ((u != NULL) && (u->Typ() == fanID))
380  {
381  leftv v=u->next;
382  if ((v != NULL) && (v->Typ() == coneID))
383  {
384  gfan::initializeCddlibIfRequired();
385  gfan::ZFan* zf = (gfan::ZFan*)u->Data();
386  gfan::ZCone* zc = (gfan::ZCone*)v->Data();
387  int b = isCompatible(zf,zc);
388  res->rtyp = INT_CMD;
389  res->data = (void*) (long) b;
390  gfan::deinitializeCddlibIfRequired();
391  return FALSE;
392  }
393  }
394  WerrorS("isCompatible: unexpected parameters");
395  return TRUE;
396 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: tok.h:95
#define FALSE
Definition: auxiliary.h:94
bool isCompatible(const gfan::ZFan *zf, const gfan::ZCone *zc)
Definition: bbfan.cc:357
#define TRUE
Definition: auxiliary.h:98
void WerrorS(const char *s)
Definition: feFopen.cc:24
int fanID
Definition: bbfan.cc:20
int Typ()
Definition: subexpr.cc:995
void * data
Definition: subexpr.h:89
int coneID
Definition: bbcone.cc:26
leftv next
Definition: subexpr.h:87
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1137
const poly b
Definition: syzextra.cc:213

◆ isPure()

BOOLEAN isPure ( leftv  res,
leftv  args 
)

Definition at line 718 of file bbfan.cc.

719 {
720  leftv u=args;
721  if ((u != NULL) && (u->Typ() == fanID))
722  {
723  gfan::initializeCddlibIfRequired();
724  gfan::ZFan* zf = (gfan::ZFan*) u->Data();
725  int b = zf->isPure();
726  res->rtyp = INT_CMD;
727  res->data = (void*) (long) b;
728  gfan::deinitializeCddlibIfRequired();
729  return FALSE;
730  }
731  WerrorS("isPure: unexpected parameters");
732  return TRUE;
733 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: tok.h:95
#define FALSE
Definition: auxiliary.h:94
#define TRUE
Definition: auxiliary.h:98
void WerrorS(const char *s)
Definition: feFopen.cc:24
int fanID
Definition: bbfan.cc:20
int Typ()
Definition: subexpr.cc:995
void * data
Definition: subexpr.h:89
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1137
const poly b
Definition: syzextra.cc:213

◆ isSimplicial()

int isSimplicial ( gfan::ZFan *  zf)

Definition at line 712 of file bbfan.cc.

713 {
714  int i = zf->isSimplicial() ? 1 : 0;
715  return i;
716 }
int i
Definition: cfEzgcd.cc:123

◆ jjFANEMPTY_I()

static BOOLEAN jjFANEMPTY_I ( leftv  res,
leftv  v 
)
static

Definition at line 147 of file bbfan.cc.

148 {
149  int ambientDim = (int)(long)v->Data();
150  if (ambientDim < 0)
151  {
152  Werror("expected non-negative ambient dim but got %d", ambientDim);
153  return TRUE;
154  }
155  res->rtyp = fanID;
156  res->data = (void*)(new gfan::ZFan(ambientDim));
157  return FALSE;
158 }
#define FALSE
Definition: auxiliary.h:94
#define TRUE
Definition: auxiliary.h:98
int fanID
Definition: bbfan.cc:20
void * data
Definition: subexpr.h:89
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1137
void Werror(const char *fmt,...)
Definition: reporter.cc:189

◆ jjFANEMPTY_IM()

static BOOLEAN jjFANEMPTY_IM ( leftv  res,
leftv  v 
)
static

Definition at line 160 of file bbfan.cc.

161 {
162  bigintmat* permutations = (bigintmat*)v->Data();
163  int ambientDim = permutations->cols();
164  gfan::IntMatrix im = permutationIntMatrix(permutations);
165  if (!gfan::Permutation::arePermutations(im))
166  {
167  Werror("provided bigintmat contains invalid permutations of {1, ..., %d}", ambientDim);
168  return TRUE;
169  }
170  gfan::SymmetryGroup sg = gfan::SymmetryGroup(ambientDim);
171  sg.computeClosure(im);
172  res->rtyp = fanID;
173  res->data = (void*)(new gfan::ZFan(sg));
174  return FALSE;
175 }
#define FALSE
Definition: auxiliary.h:94
Matrices of numbers.
Definition: bigintmat.h:51
#define TRUE
Definition: auxiliary.h:98
int fanID
Definition: bbfan.cc:20
void * data
Definition: subexpr.h:89
int cols() const
Definition: bigintmat.h:145
static gfan::IntMatrix permutationIntMatrix(const bigintmat *iv)
Definition: bbfan.cc:128
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1137
void Werror(const char *fmt,...)
Definition: reporter.cc:189

◆ jjFANFULL_I()

static BOOLEAN jjFANFULL_I ( leftv  res,
leftv  v 
)
static

Definition at line 198 of file bbfan.cc.

199 {
200  int ambientDim = (int)(long)v->Data();
201  if (ambientDim < 0)
202  {
203  Werror("expected non-negative ambient dim but got %d", ambientDim);
204  return TRUE;
205  }
206  gfan::ZFan* zf = new gfan::ZFan(gfan::ZFan::fullFan(ambientDim));
207  res->rtyp = fanID;
208  res->data = (void*) zf;
209  return FALSE;
210 }
#define FALSE
Definition: auxiliary.h:94
BOOLEAN fullFan(leftv res, leftv args)
Definition: bbfan.cc:229
#define TRUE
Definition: auxiliary.h:98
int fanID
Definition: bbfan.cc:20
void * data
Definition: subexpr.h:89
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1137
void Werror(const char *fmt,...)
Definition: reporter.cc:189

◆ jjFANFULL_IM()

static BOOLEAN jjFANFULL_IM ( leftv  res,
leftv  v 
)
static

Definition at line 211 of file bbfan.cc.

212 {
213  bigintmat* permutations = (bigintmat*)v->Data();
214  int ambientDim = permutations->cols();
215  gfan::IntMatrix im = permutationIntMatrix(permutations);
216  if (!gfan::Permutation::arePermutations(im))
217  {
218  Werror("provided bigintmat contains invalid permutations of {1, ..., %d}", ambientDim);
219  return TRUE;
220  }
221  gfan::SymmetryGroup sg = gfan::SymmetryGroup(ambientDim);
222  sg.computeClosure(im);
223  gfan::ZFan* zf = new gfan::ZFan(gfan::ZFan::fullFan(sg));
224  res->rtyp = fanID;
225  res->data = (void*) zf;
226  return FALSE;
227 }
#define FALSE
Definition: auxiliary.h:94
Matrices of numbers.
Definition: bigintmat.h:51
BOOLEAN fullFan(leftv res, leftv args)
Definition: bbfan.cc:229
#define TRUE
Definition: auxiliary.h:98
int fanID
Definition: bbfan.cc:20
void * data
Definition: subexpr.h:89
int cols() const
Definition: bigintmat.h:145
static gfan::IntMatrix permutationIntMatrix(const bigintmat *iv)
Definition: bbfan.cc:128
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1137
void Werror(const char *fmt,...)
Definition: reporter.cc:189

◆ ncones()

BOOLEAN ncones ( leftv  res,
leftv  args 
)

Definition at line 314 of file bbfan.cc.

315 {
316  leftv u=args;
317  if ((u != NULL) && (u->Typ() == fanID))
318  {
319  gfan::initializeCddlibIfRequired();
320  gfan::ZFan* zf = (gfan::ZFan*)u->Data();
321  int d = zf->getAmbientDimension();
322  int n = 0;
323 
324  for (int i=0; i<=d; i++)
325  n = n + zf->numberOfConesOfDimension(i,0,0);
326 
327  res->rtyp = INT_CMD;
328  res->data = (void*) (long) n;
329  gfan::deinitializeCddlibIfRequired();
330  return FALSE;
331  }
332  WerrorS("ncones: unexpected parameters");
333  return TRUE;
334 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: tok.h:95
#define FALSE
Definition: auxiliary.h:94
#define TRUE
Definition: auxiliary.h:98
void WerrorS(const char *s)
Definition: feFopen.cc:24
int fanID
Definition: bbfan.cc:20
int Typ()
Definition: subexpr.cc:995
void * data
Definition: subexpr.h:89
int i
Definition: cfEzgcd.cc:123
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1137

◆ nmaxcones()

BOOLEAN nmaxcones ( leftv  res,
leftv  args 
)

Definition at line 336 of file bbfan.cc.

337 {
338  leftv u=args;
339  if ((u != NULL) && (u->Typ() == fanID))
340  {
341  gfan::initializeCddlibIfRequired();
342  gfan::ZFan* zf = (gfan::ZFan*)u->Data();
343 
344  int n = 0;
345  for (int d=0; d<=zf->getAmbientDimension(); d++)
346  n = n + zf->numberOfConesOfDimension(d,0,1);
347 
348  res->rtyp = INT_CMD;
349  res->data = (void*) (long) n;
350  gfan::deinitializeCddlibIfRequired();
351  return FALSE;
352  }
353  WerrorS("nmaxcones: unexpected parameters");
354  return TRUE;
355 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: tok.h:95
#define FALSE
Definition: auxiliary.h:94
#define TRUE
Definition: auxiliary.h:98
void WerrorS(const char *s)
Definition: feFopen.cc:24
int fanID
Definition: bbfan.cc:20
int Typ()
Definition: subexpr.cc:995
void * data
Definition: subexpr.h:89
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1137

◆ numberOfConesOfDimension()

BOOLEAN numberOfConesOfDimension ( leftv  res,
leftv  args 
)

Definition at line 267 of file bbfan.cc.

268 {
269  leftv u=args;
270  if ((u != NULL) && (u->Typ() == fanID))
271  {
272  leftv v=u->next;
273  if ((v != NULL) && (v->Typ() == INT_CMD))
274  {
275  leftv w=v->next;
276  if ((w != NULL) && (w->Typ() == INT_CMD))
277  {
278  leftv x=w->next;
279  if ((x != NULL) && (x->Typ() == INT_CMD))
280  {
281  gfan::initializeCddlibIfRequired();
282  gfan::ZFan* zf = (gfan::ZFan*) u->Data();
283  int d = (int)(long)v->Data();
284  int o = (int)(long)w->Data();
285  int m = (int)(long)x->Data();
286  if ( (0<=d) && (d <= zf->getAmbientDimension())
287  && ((o == 0) || (o == 1))
288  && ((m == 0) || (m == 1)))
289  {
290  bool oo = (bool) o;
291  bool mm = (bool) m;
292  int ld = zf->getLinealityDimension();
293  if (d-ld>=0)
294  {
295  int n = zf->numberOfConesOfDimension(d-ld,oo,mm);
296  res->rtyp = INT_CMD;
297  res->data = (void*) (long) n;
298  gfan::deinitializeCddlibIfRequired();
299  return FALSE;
300  }
301  res->rtyp = INT_CMD;
302  res->data = (void*) (long) 0;
303  gfan::deinitializeCddlibIfRequired();
304  return FALSE;
305  }
306  }
307  }
308  }
309  }
310  WerrorS("numberOfConesOfDimension: unexpected parameters");
311  return TRUE;
312 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: tok.h:95
#define FALSE
Definition: auxiliary.h:94
#define TRUE
Definition: auxiliary.h:98
void WerrorS(const char *s)
Definition: feFopen.cc:24
int fanID
Definition: bbfan.cc:20
int Typ()
Definition: subexpr.cc:995
int getAmbientDimension(gfan::ZFan *zf)
Definition: bbfan.cc:247
void * data
Definition: subexpr.h:89
int m
Definition: cfEzgcd.cc:119
leftv next
Definition: subexpr.h:87
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
#define NULL
Definition: omList.c:10
const CanonicalForm & w
Definition: facAbsFact.cc:55
int rtyp
Definition: subexpr.h:92
Variable x
Definition: cfModGcd.cc:4023
void * Data()
Definition: subexpr.cc:1137

◆ numberOfConesWithVector() [1/2]

int numberOfConesWithVector ( gfan::ZFan *  zf,
gfan::ZVector *  v 
)

Definition at line 778 of file bbfan.cc.

779 {
780  int count = 0;
781  int ambientDim = zf->getAmbientDimension();
782  for (int i=0; i<zf->numberOfConesOfDimension(ambientDim, 0, 0); i++)
783  {
784  gfan::ZCone zc = zf->getCone(ambientDim, i, 0, 0);
785  if (zc.contains(*v))
786  {
787  count = count +1;
788  if (count > 1)
789  return count;
790  }
791  }
792  return count;
793 }
int status int void size_t count
Definition: si_signals.h:59
int i
Definition: cfEzgcd.cc:123
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37

◆ numberOfConesWithVector() [2/2]

BOOLEAN numberOfConesWithVector ( leftv  res,
leftv  args 
)

Definition at line 795 of file bbfan.cc.

796 {
797  leftv u=args;
798  if ((u != NULL) && (u->Typ() == fanID))
799  {
800  leftv v=u->next;
801  if ((v != NULL) && (v->Typ() == BIGINTMAT_CMD))
802  {
803  gfan::initializeCddlibIfRequired();
804  gfan::ZFan* zf = (gfan::ZFan*) u->Data();
805  bigintmat* v0 = (bigintmat*) v->Data();
806  int ambientDim = zf->getAmbientDimension();
807  if (ambientDim != v0->cols())
808  {
809  WerrorS("numberOfConesWithVector: mismatching dimensions");
810  gfan::deinitializeCddlibIfRequired();
811  return TRUE;
812  }
813  gfan::ZVector* v1 = bigintmatToZVector(*v0);
814  int count = numberOfConesWithVector(zf, v1);
815  delete v1;
816  res->rtyp = INT_CMD;
817  res->data = (void*) (long) count;
818  gfan::deinitializeCddlibIfRequired();
819  return FALSE;
820  }
821  }
822  WerrorS("numberOfConesWithVector: unexpected parameters");
823  return TRUE;
824 }
int status int void size_t count
Definition: si_signals.h:59
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: tok.h:95
#define FALSE
Definition: auxiliary.h:94
Matrices of numbers.
Definition: bigintmat.h:51
#define TRUE
Definition: auxiliary.h:98
void WerrorS(const char *s)
Definition: feFopen.cc:24
int fanID
Definition: bbfan.cc:20
int Typ()
Definition: subexpr.cc:995
void * data
Definition: subexpr.h:89
int numberOfConesWithVector(gfan::ZFan *zf, gfan::ZVector *v)
Definition: bbfan.cc:778
int cols() const
Definition: bigintmat.h:145
leftv next
Definition: subexpr.h:87
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1137
gfan::ZVector * bigintmatToZVector(const bigintmat &bim)

◆ permutationIntMatrix()

static gfan::IntMatrix permutationIntMatrix ( const bigintmat iv)
static

Definition at line 128 of file bbfan.cc.

129 {
130  int cc = iv->cols();
131  int rr = iv->rows();
132  bigintmat* ivCopy = new bigintmat(rr, cc, coeffs_BIGINT);
133  number temp1 = n_Init(1,coeffs_BIGINT);
134  for (int r = 1; r <= rr; r++)
135  for (int c = 1; c <= cc; c++)
136  {
137  number temp2 = n_Sub(IMATELEM(*iv, r, c),temp1,coeffs_BIGINT);
138  ivCopy->set(r,c,temp2);
139  n_Delete(&temp2,coeffs_BIGINT);
140  }
141  n_Delete(&temp1,coeffs_BIGINT);
142  gfan::ZMatrix* zm = bigintmatToZMatrix(ivCopy);
143  gfan::IntMatrix im = gfan::IntMatrix(gfan::ZToIntMatrix(*zm));
144  delete zm;
145  return im;
146 }
static FORCE_INLINE number n_Sub(number a, number b, const coeffs r)
return the difference of &#39;a&#39; and &#39;b&#39;, i.e., a-b
Definition: coeffs.h:673
Matrices of numbers.
Definition: bigintmat.h:51
int rows() const
Definition: bigintmat.h:146
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
Definition: coeffs.h:542
intvec * ivCopy(const intvec *o)
Definition: intvec.h:126
coeffs coeffs_BIGINT
Definition: ipid.cc:54
void set(int i, int j, number n, const coeffs C=NULL)
replace an entry with a copy (delete old + copy new!). NOTE: starts at [1,1]
Definition: bigintmat.cc:96
const ring r
Definition: syzextra.cc:208
gfan::ZMatrix * bigintmatToZMatrix(const bigintmat &bim)
int cols() const
Definition: bigintmat.h:145
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:459
#define IMATELEM(M, I, J)
Definition: intvec.h:77

◆ rays()

gfan::ZMatrix rays ( const gfan::ZFan *const  zf)

Definition at line 767 of file bbfan.cc.

768 {
769  gfan::ZMatrix rays(0,zf->getAmbientDimension());
770  for (int i=0; i<zf->numberOfConesOfDimension(1,0,0); i++)
771  {
772  gfan::ZCone zc = zf->getCone(1, i, 0, 0);
773  rays.append(zc.extremeRays());
774  }
775  return rays;
776 }
gfan::ZMatrix rays(const gfan::ZFan *const zf)
Definition: bbfan.cc:767
int i
Definition: cfEzgcd.cc:123

◆ removeCone()

BOOLEAN removeCone ( leftv  res,
leftv  args 
)

Definition at line 519 of file bbfan.cc.

520 {
521  leftv u=args;
522  if ((u != NULL) && (u->Typ() == fanID))
523  {
524  leftv v=u->next;
525  if ((v != NULL) && (v->Typ() == coneID))
526  {
527  gfan::initializeCddlibIfRequired();
528  gfan::ZFan* zf = (gfan::ZFan*)u->Data();
529  gfan::ZCone* zc = (gfan::ZCone*)v->Data();
530  zc->canonicalize();
531 
532  leftv w=v->next; int n = 1;
533  if ((w != NULL) && (w->Typ() == INT_CMD))
534  n = (int)(long) w;
535 
536  if (n != 0)
537  {
538  if (!containsInCollection(zf,zc))
539  {
540  WerrorS("removeCone: cone not contained in fan");
541  gfan::deinitializeCddlibIfRequired();
542  return TRUE;
543  }
544  }
545 
546  zf->remove(*zc);
547  res->rtyp = NONE;
548  res->data = NULL;
549  IDDATA((idhdl)u->data) = (char*) zf;
550  gfan::deinitializeCddlibIfRequired();
551  return FALSE;
552  }
553  }
554  WerrorS("removeCone: unexpected parameters");
555  return TRUE;
556 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: tok.h:95
#define FALSE
Definition: auxiliary.h:94
#define TRUE
Definition: auxiliary.h:98
void WerrorS(const char *s)
Definition: feFopen.cc:24
int fanID
Definition: bbfan.cc:20
int Typ()
Definition: subexpr.cc:995
Definition: idrec.h:34
void * data
Definition: subexpr.h:89
bool containsInCollection(gfan::ZFan *zf, gfan::ZCone *zc)
Definition: bbfan.cc:438
int coneID
Definition: bbcone.cc:26
leftv next
Definition: subexpr.h:87
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
#define NULL
Definition: omList.c:10
const CanonicalForm & w
Definition: facAbsFact.cc:55
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1137
#define IDDATA(a)
Definition: ipid.h:123
#define NONE
Definition: tok.h:216

Variable Documentation

◆ fanID

int fanID

Definition at line 20 of file bbfan.cc.