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 70 of file bbfan.cc.

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

§ bbfan_Copy()

void* bbfan_Copy ( blackbox *  ,
void *  d 
)

Definition at line 63 of file bbfan.cc.

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

§ bbfan_deserialize()

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

Definition at line 1059 of file bbfan.cc.

1060 {
1061  ssiInfo *dd = (ssiInfo *)f->data;
1062 
1063  int l = s_readint(dd->f_read);
1064  char* buf = (char*) omAlloc0(l+1);
1065  (void) s_getc(dd->f_read); // skip whitespace
1066  (void) s_readbytes(buf,l,dd->f_read);
1067  buf[l]='\0';
1068 
1069  std::istringstream fanInString(std::string(buf,l));
1070  gfan::ZFan* zf = new gfan::ZFan(fanInString);
1071  *d=zf;
1072 
1073  omFree(buf);
1074  return FALSE;
1075 }
int s_readbytes(char *buff, int len, s_buff F)
Definition: s_buff.cc:175
#define FALSE
Definition: auxiliary.h:97
#define string
Definition: libparse.cc:1250
int s_getc(s_buff F)
Definition: s_buff.cc:65
int s_readint(s_buff F)
Definition: s_buff.cc:119
#define omFree(addr)
Definition: omAllocDecl.h:261
int status int void * buf
Definition: si_signals.h:59
FILE * f
Definition: checklibs.c:7
#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 1040 of file bbfan.cc.

1041 {
1042  ssiInfo *dd = (ssiInfo *)f->data;
1043 
1044  sleftv l;
1045  memset(&l,0,sizeof(l));
1046  l.rtyp=STRING_CMD;
1047  l.data=(void*)"fan";
1048  f->m->Write(f, &l);
1049 
1050  gfan::ZFan* zf = (gfan::ZFan*) d;
1051  std::string s = zf->toString(2+4+8+128);
1052 
1053  fprintf(dd->f_write,"%d %s ",(int)s.size(),s.c_str());
1054 
1055  return FALSE;
1056 }
const CanonicalForm int s
Definition: facAbsFact.cc:55
Class used for (list of) interpreter objects.
Definition: subexpr.h:84
#define FALSE
Definition: auxiliary.h:97
#define string
Definition: libparse.cc:1250
FILE * f
Definition: checklibs.c:7
int l
Definition: cfEzgcd.cc:94

§ bbfan_setup()

void bbfan_setup ( SModulFunctions p)

Definition at line 1078 of file bbfan.cc.

1079 {
1080  blackbox *b=(blackbox*)omAlloc0(sizeof(blackbox));
1081  // all undefined entries will be set to default in setBlackboxStuff
1082  // the default Print is quite usefule,
1083  // all other are simply error messages
1084  b->blackbox_destroy=bbfan_destroy;
1085  b->blackbox_String=bbfan_String;
1086  //b->blackbox_Print=blackbox_default_Print;
1087  b->blackbox_Init=bbfan_Init;
1088  b->blackbox_Copy=bbfan_Copy;
1089  b->blackbox_Assign=bbfan_Assign;
1090  b->blackbox_serialize=bbfan_serialize;
1091  b->blackbox_deserialize=bbfan_deserialize;
1092  p->iiAddCproc("","emptyFan",FALSE,emptyFan);
1093  p->iiAddCproc("","fullFan",FALSE,fullFan);
1094  /* the following functions are implemented in bbcone.cc */
1095  // iiAddCproc("","containsInSupport",FALSE,containsInSupport);
1096  // iiAddCproc("","getAmbientDimension",FALSE,getAmbientDimension);
1097  // iiAddCproc("","getCodimension",FALSE,getDimension);
1098  // iiAddCproc("","getDimension",FALSE,getDimension);
1099  // iiAddCproc("","getLinealityDimension",FALSE,getLinealityDimension);
1100  // iiAddCproc("","isSimplicial",FALSE,isSimplicial);
1101  /********************************************************/
1102  p->iiAddCproc("","isCompatible",FALSE,isCompatible);
1103  p->iiAddCproc("","numberOfConesOfDimension",FALSE,numberOfConesOfDimension);
1104  p->iiAddCproc("","ncones",FALSE,ncones);
1105  p->iiAddCproc("","nmaxcones",FALSE,nmaxcones);
1106  p->iiAddCproc("","insertCone",FALSE,insertCone);
1107  p->iiAddCproc("","removeCone",FALSE,removeCone);
1108  p->iiAddCproc("","getCone",FALSE,getCone);
1109  p->iiAddCproc("","getCones",FALSE,getCones);
1110  p->iiAddCproc("","isPure",FALSE,isPure);
1111  p->iiAddCproc("","fanFromString",FALSE,fanFromString);
1112  p->iiAddCproc("","fanViaCones",FALSE,fanViaCones);
1113  p->iiAddCproc("","numberOfConesWithVector",FALSE,numberOfConesWithVector);
1114  // iiAddCproc("","isComplete",FALSE,isComplete); not working as expected, should leave this to polymake
1115  p->iiAddCproc("","fVector",FALSE,fVector);
1116  p->iiAddCproc("","containsInCollection",FALSE,containsInCollection);
1117  // p->iiAddCproc("","tropicalVariety",FALSE,tropicalVariety);
1118  p->iiAddCproc("","commonRefinement",FALSE,commonRefinement);
1119  // iiAddCproc("","grFan",FALSE,grFan);
1120  fanID=setBlackboxStuff(b,"fan");
1121  //Print("created type %d (fan)\n",fanID);
1122 }
char * bbfan_String(blackbox *, void *d)
Definition: bbfan.cc:36
#define FALSE
Definition: auxiliary.h:97
BOOLEAN numberOfConesOfDimension(leftv res, leftv args)
Definition: bbfan.cc:266
BOOLEAN nmaxcones(leftv res, leftv args)
Definition: bbfan.cc:332
bool isCompatible(const gfan::ZFan *zf, const gfan::ZCone *zc)
Definition: bbfan.cc:352
void * bbfan_Init(blackbox *)
Definition: bbfan.cc:22
BOOLEAN fullFan(leftv res, leftv args)
Definition: bbfan.cc:228
BOOLEAN bbfan_Assign(leftv l, leftv r)
Definition: bbfan.cc:70
BOOLEAN emptyFan(leftv res, leftv args)
Definition: bbfan.cc:175
BOOLEAN fanViaCones(leftv res, leftv args)
Definition: bbfan.cc:820
int fanID
Definition: bbfan.cc:20
void * bbfan_Copy(blackbox *, void *d)
Definition: bbfan.cc:63
BOOLEAN bbfan_deserialize(blackbox **b, void **d, si_link f)
Definition: bbfan.cc:1059
BOOLEAN getCone(leftv res, leftv args)
Definition: bbfan.cc:546
BOOLEAN fanFromString(leftv res, leftv args)
Definition: bbfan.cc:803
BOOLEAN ncones(leftv res, leftv args)
Definition: bbfan.cc:311
int numberOfConesWithVector(gfan::ZFan *zf, gfan::ZVector *v)
Definition: bbfan.cc:756
BOOLEAN insertCone(leftv res, leftv args)
Definition: bbfan.cc:392
BOOLEAN fVector(leftv res, leftv args)
Definition: bbfan.cc:728
bool containsInCollection(gfan::ZFan *zf, gfan::ZCone *zc)
Definition: bbfan.cc:430
BOOLEAN getCones(leftv res, leftv args)
Definition: bbfan.cc:622
BOOLEAN isPure(leftv res, leftv args)
Definition: bbfan.cc:697
gfan::ZFan commonRefinement(gfan::ZFan zf, gfan::ZFan zg)
Definition: bbfan.cc:945
BOOLEAN removeCone(leftv res, leftv args)
Definition: bbfan.cc:509
BOOLEAN bbfan_serialize(blackbox *b, void *d, si_link f)
Definition: bbfan.cc:1040
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

§ 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::ZFan* zf = (gfan::ZFan*)d;
42  std::string s = zf->toString(2+4+8+128);
43  return omStrDup(s.c_str());
44 // =======
45 // std::stringstream s;
46 // std::string raysAndCones = zf->toStringJustRaysAndMaximalCones();
47 // s << raysAndCones;
48 // if (zf->getDimension() >= 0) // <=> zf is not empty
49 // {
50 // assert(zf->numberOfConesOfDimension(zf->getDimension()-zf->getLinealityDimension(),0,0));
51 // gfan::ZCone zc = zf->getCone(zf->getDimension()-zf->getLinealityDimension(),0,0,0);
52 // gfan::ZMatrix genLinSpace = zc.generatorsOfLinealitySpace();
53 // char* gens = toString(genLinSpace);
54 // s << std::endl << "GENERATORS_LINEALITY_SPACE:" << std::endl;
55 // s << gens;
56 // }
57 // std::string sstring = s.str();
58 // return omStrDup(sstring.c_str());
59 // >>>>>>> status updated 11.03.
60  }
61 }
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 945 of file bbfan.cc.

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

§ commonRefinement() [2/2]

BOOLEAN commonRefinement ( leftv  res,
leftv  args 
)

Definition at line 971 of file bbfan.cc.

972 {
973  gfan::initializeCddlibIfRequired();
974  leftv u=args;
975  if ((u != NULL) && (u->Typ() == fanID))
976  {
977  leftv v=u->next;
978  if ((v != NULL) && (v->Typ() == fanID))
979  {
980  gfan::ZFan* zf = (gfan::ZFan*) u->Data();
981  gfan::ZFan* zg = (gfan::ZFan*) v->Data();
982  gfan::ZFan* zr = new gfan::ZFan(commonRefinement(*zf,*zg));
983  res->rtyp = fanID;
984  res->data = (void*) zr;
985  return FALSE;
986  }
987  }
988  WerrorS("commonRefinement: unexpected parameters");
989  return TRUE;
990 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:84
#define FALSE
Definition: auxiliary.h:97
#define TRUE
Definition: auxiliary.h:101
void WerrorS(const char *s)
Definition: feFopen.cc:24
int fanID
Definition: bbfan.cc:20
int Typ()
Definition: subexpr.cc:979
void * data
Definition: subexpr.h:90
leftv next
Definition: subexpr.h:88
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:93
gfan::ZFan commonRefinement(gfan::ZFan zf, gfan::ZFan zg)
Definition: bbfan.cc:945
void * Data()
Definition: subexpr.cc:1121

§ containsInCollection() [1/2]

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

Definition at line 430 of file bbfan.cc.

431 {
432  gfan::ZVector zv=zc->getRelativeInteriorPoint();
433  for (int d=0; d<=zf->getAmbientDimension(); d++)
434  {
435  for (int i=0; i<zf->numberOfConesOfDimension(d,0,1); i++)
436  {
437  gfan::ZCone zd = zf->getCone(d,i,0,1);
438  zd.canonicalize();
439  if (zd.containsRelatively(zv))
440  {
441  gfan::ZCone temp = *zc;
442  temp.canonicalize();
443  return (!(zd != temp));
444  }
445  }
446  }
447  return 0;
448 }
int i
Definition: cfEzgcd.cc:123

§ containsInCollection() [2/2]

BOOLEAN containsInCollection ( leftv  res,
leftv  args 
)

Definition at line 450 of file bbfan.cc.

451 {
452  gfan::initializeCddlibIfRequired();
453  leftv u=args;
454  if ((u != NULL) && (u->Typ() == fanID))
455  {
456  leftv v=u->next;
457  if ((v != NULL) && (v->Typ() == coneID))
458  {
459  gfan::ZFan* zf = (gfan::ZFan*)u->Data();
460  gfan::ZCone* zc = (gfan::ZCone*)v->Data();
461  if((zf->getAmbientDimension() == zc->ambientDimension()))
462  {
463  res->rtyp = INT_CMD;
464  res->data = (void*) (long) (int) containsInCollection(zf,zc);
465  return FALSE;
466  }
467  WerrorS("containsInCollection: mismatching ambient dimensions");
468  return TRUE;
469  }
470  }
471  WerrorS("containsInCollection: unexpected parameters");
472  return TRUE;
473 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:84
Definition: tok.h:94
#define FALSE
Definition: auxiliary.h:97
#define TRUE
Definition: auxiliary.h:101
void WerrorS(const char *s)
Definition: feFopen.cc:24
int fanID
Definition: bbfan.cc:20
int Typ()
Definition: subexpr.cc:979
void * data
Definition: subexpr.h:90
bool containsInCollection(gfan::ZFan *zf, gfan::ZCone *zc)
Definition: bbfan.cc:430
int coneID
Definition: bbcone.cc:26
leftv next
Definition: subexpr.h:88
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:93
void * Data()
Definition: subexpr.cc:1121

§ emptyFan()

BOOLEAN emptyFan ( leftv  res,
leftv  args 
)

Definition at line 175 of file bbfan.cc.

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

§ fanFromString()

BOOLEAN fanFromString ( leftv  res,
leftv  args 
)

Definition at line 803 of file bbfan.cc.

804 {
805  gfan::initializeCddlibIfRequired();
806  leftv u=args;
807  if ((u != NULL) && (u->Typ() == STRING_CMD))
808  {
809  std::string fanInString = (char*) u->Data();
810  std::istringstream s(fanInString);
811  gfan::ZFan* zf = new gfan::ZFan(s);
812  res->rtyp = fanID;
813  res->data = (void*) zf;
814  return FALSE;
815  }
816  WerrorS("fanFromString: unexpected parameters");
817  return TRUE;
818 }
const CanonicalForm int s
Definition: facAbsFact.cc:55
Class used for (list of) interpreter objects.
Definition: subexpr.h:84
#define FALSE
Definition: auxiliary.h:97
#define string
Definition: libparse.cc:1250
#define TRUE
Definition: auxiliary.h:101
void WerrorS(const char *s)
Definition: feFopen.cc:24
int fanID
Definition: bbfan.cc:20
int Typ()
Definition: subexpr.cc:979
void * data
Definition: subexpr.h:90
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:93
void * Data()
Definition: subexpr.cc:1121

§ fanViaCones()

BOOLEAN fanViaCones ( leftv  res,
leftv  args 
)

Definition at line 820 of file bbfan.cc.

821 {
822  gfan::initializeCddlibIfRequired();
823  leftv u=args;
824  if ((u != NULL) && (u->Typ() == LIST_CMD))
825  {
826  lists L = (lists) u->Data();
827  if (lSize(L)>-1)
828  {
829  if (L->m[0].Typ() != coneID)
830  {
831  WerrorS("fanViaCones: list contains entries of wrong type");
832  return TRUE;
833  }
834  gfan::ZCone* zc = (gfan::ZCone*) L->m[0].Data();
835  gfan::ZFan* zf = new gfan::ZFan(zc->ambientDimension());
836  zf->insert(*zc);
837  for (int i=1; i<=lSize(L); i++)
838  {
839  if (L->m[i].Typ() != coneID)
840  {
841  WerrorS("fanViaCones: entries of wrong type in list");
842  return TRUE;
843  }
844  gfan::ZCone* zc = (gfan::ZCone*) L->m[i].Data();
845  if (zc->ambientDimension() != zf->getAmbientDimension())
846  {
847  WerrorS("fanViaCones: inconsistent ambient dimensions amongst cones in list");
848  return TRUE;
849  }
850  zf->insert(*zc);
851  }
852  res->rtyp = fanID;
853  res->data = (void*) zf;
854  return FALSE;
855  }
856  res->rtyp = fanID;
857  res->data = (void*) new gfan::ZFan(0);
858  return FALSE;
859  }
860  if ((u != NULL) && (u->Typ() == coneID))
861  {
862  gfan::ZCone* zc = (gfan::ZCone*) u->Data();
863  gfan::ZFan* zf = new gfan::ZFan(zc->ambientDimension());
864  zf->insert(*zc);
865  while (u->next != NULL)
866  {
867  u = u->next;
868  if (u->Typ() != coneID)
869  {
870  WerrorS("fanViaCones: arguments of wrong type");
871  return TRUE;
872  }
873  gfan::ZCone* zc = (gfan::ZCone*) u->Data();
874  if (zc->ambientDimension() != zf->getAmbientDimension())
875  {
876  WerrorS("fanViaCones: inconsistent ambient dimensions amongst input cones");
877  return TRUE;
878  }
879  zf->insert(*zc);
880  }
881  res->rtyp = fanID;
882  res->data = (void*) zf;
883  return FALSE;
884  }
885  if (u == NULL)
886  {
887  res->rtyp = fanID;
888  res->data = (void*) new gfan::ZFan(0);
889  return FALSE;
890  }
891  WerrorS("fanViaCones: unexpected parameters");
892  return TRUE;
893 }
sleftv * m
Definition: lists.h:45
Class used for (list of) interpreter objects.
Definition: subexpr.h:84
Definition: lists.h:22
#define FALSE
Definition: auxiliary.h:97
#define TRUE
Definition: auxiliary.h:101
void WerrorS(const char *s)
Definition: feFopen.cc:24
int fanID
Definition: bbfan.cc:20
int Typ()
Definition: subexpr.cc:979
void * data
Definition: subexpr.h:90
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:88
#define NULL
Definition: omList.c:10
slists * lists
Definition: mpr_numeric.h:146
int rtyp
Definition: subexpr.h:93
void * Data()
Definition: subexpr.cc:1121
Definition: tok.h:116

§ fullFan()

BOOLEAN fullFan ( leftv  res,
leftv  args 
)

Definition at line 228 of file bbfan.cc.

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

§ fVector()

BOOLEAN fVector ( leftv  res,
leftv  args 
)

Definition at line 728 of file bbfan.cc.

729 {
730  gfan::initializeCddlibIfRequired();
731  leftv u=args;
732  if ((u != NULL) && (u->Typ() == fanID))
733  {
734  gfan::ZFan* zf = (gfan::ZFan*) u->Data();
735  gfan::ZVector zv=zf->getFVector();
736  res->rtyp = BIGINTMAT_CMD;
737  res->data = (void*) zVectorToBigintmat(zv);
738  return FALSE;
739  }
740  WerrorS("fVector: unexpected parameters");
741  return TRUE;
742 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:84
#define FALSE
Definition: auxiliary.h:97
#define TRUE
Definition: auxiliary.h:101
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:979
void * data
Definition: subexpr.h:90
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:93
void * Data()
Definition: subexpr.cc:1121

§ getAmbientDimension()

int getAmbientDimension ( gfan::ZFan *  zf)

Definition at line 246 of file bbfan.cc.

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

§ getCodimension()

int getCodimension ( gfan::ZFan *  zf)

Definition at line 251 of file bbfan.cc.

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

§ getCone()

BOOLEAN getCone ( leftv  res,
leftv  args 
)

Definition at line 546 of file bbfan.cc.

547 {
548  gfan::initializeCddlibIfRequired();
549  leftv u=args;
550  if ((u != NULL) && (u->Typ() == fanID))
551  {
552  leftv v=u->next;
553  if ((v != NULL) && (v->Typ() == INT_CMD))
554  {
555  leftv w=v->next;
556  if ((w != NULL) && (w->Typ() == INT_CMD))
557  {
558  gfan::ZFan* zf = (gfan::ZFan*) u->Data();
559  int d = (int)(long)v->Data();
560  int i = (int)(long)w->Data();
561  int o = -1;
562  int m = -1;
563  leftv x=w->next;
564  if ((x != NULL) && (x->Typ() == INT_CMD))
565  {
566  o = (int)(long)x->Data();
567  leftv y=x->next;
568  if ((y != NULL) && (y->Typ() == INT_CMD))
569  {
570  m = (int)(long)y->Data();
571  }
572  }
573  if (o == -1) o = 0;
574  if (m == -1) m = 0;
575  if (((o == 0) || (o == 1)) && ((m == 0) || (m == 1)))
576  {
577  bool oo = (bool) o;
578  bool mm = (bool) m;
579  if (0<=d && d<=zf->getAmbientDimension())
580  {
581  int ld = zf->getLinealityDimension();
582  if (0<i && i<=zf->numberOfConesOfDimension(d-ld,oo,mm))
583  {
584  i=i-1;
585  if (d-ld>=0)
586  {
587  gfan::ZCone zc = zf->getCone(d-ld,i,oo,mm);
588  res->rtyp = coneID;
589  res->data = (void*)new gfan::ZCone(zc);
590  return FALSE;
591  }
592  else
593  {
594  WerrorS("getCone: invalid dimension; no cones in this dimension");
595  return TRUE;
596  }
597  }
598  else
599  {
600  WerrorS("getCone: invalid index");
601  return TRUE;
602  }
603  }
604  else
605  {
606  WerrorS("getCone: invalid dimension");
607  return TRUE;
608  }
609  }
610  else
611  {
612  WerrorS("getCone: invalid specifier for orbit or maximal");
613  return TRUE;
614  }
615  }
616  }
617  }
618  WerrorS("getCone: unexpected parameters");
619  return TRUE;
620 }
const CanonicalForm int const CFList const Variable & y
Definition: facAbsFact.cc:57
Class used for (list of) interpreter objects.
Definition: subexpr.h:84
Definition: tok.h:94
#define FALSE
Definition: auxiliary.h:97
BOOLEAN numberOfConesOfDimension(leftv res, leftv args)
Definition: bbfan.cc:266
#define TRUE
Definition: auxiliary.h:101
void WerrorS(const char *s)
Definition: feFopen.cc:24
int fanID
Definition: bbfan.cc:20
int Typ()
Definition: subexpr.cc:979
int getAmbientDimension(gfan::ZFan *zf)
Definition: bbfan.cc:246
void * data
Definition: subexpr.h:90
int m
Definition: cfEzgcd.cc:119
int coneID
Definition: bbcone.cc:26
int i
Definition: cfEzgcd.cc:123
leftv next
Definition: subexpr.h:88
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:93
Variable x
Definition: cfModGcd.cc:4023
void * Data()
Definition: subexpr.cc:1121

§ getCones()

BOOLEAN getCones ( leftv  res,
leftv  args 
)

Definition at line 622 of file bbfan.cc.

623 {
624  gfan::initializeCddlibIfRequired();
625  leftv u=args;
626  if ((u != NULL) && (u->Typ() == fanID))
627  {
628  leftv v=u->next;
629  if ((v != NULL) && (v->Typ() == INT_CMD))
630  {
631  gfan::ZFan* zf = (gfan::ZFan*) u->Data();
632  int d = (int)(long)v->Data();
633  int o = -1;
634  int m = -1;
635  leftv w=v->next;
636  if ((w != NULL) && (w->Typ() == INT_CMD))
637  {
638  o = (int)(long)w->Data();
639  leftv x=w->next;
640  if ((x != NULL) && (x->Typ() == INT_CMD))
641  {
642  m = (int)(long)x->Data();
643  }
644  }
645  if (o == -1) o = 0;
646  if (m == -1) m = 0;
647  if (((o == 0) || (o == 1)) && ((m == 0) || (m == 1)))
648  {
649  bool oo = (bool) o;
650  bool mm = (bool) m;
651  if (0<=d && d<=zf->getAmbientDimension())
652  {
653  int ld = zf->getLinealityDimension();
654  if (d-ld>=0)
655  {
657  int n = zf->numberOfConesOfDimension(d-ld,oo,mm);
658  L->Init(n);
659  for (int i=0; i<n; i++)
660  {
661  gfan::ZCone zc = zf->getCone(d-ld,i,oo,mm);
662  L->m[i].rtyp = coneID; L->m[i].data=(void*) new gfan::ZCone(zc);
663  }
664  res->rtyp = LIST_CMD;
665  res->data = (void*) L;
666  return FALSE;
667  }
668  else
669  {
670  WerrorS("getCones: invalid dimension; no cones in this dimension");
671  return TRUE;
672  }
673  }
674  else
675  {
676  WerrorS("getCones: invalid dimension");
677  return TRUE;
678  }
679  }
680  else
681  {
682  WerrorS("getCones: invalid specifier for orbit or maximal");
683  return TRUE;
684  }
685  }
686  }
687  WerrorS("getCones: unexpected parameters");
688  return TRUE;
689 }
#define omAllocBin(bin)
Definition: omAllocDecl.h:205
sleftv * m
Definition: lists.h:45
Class used for (list of) interpreter objects.
Definition: subexpr.h:84
Definition: tok.h:94
Definition: lists.h:22
#define FALSE
Definition: auxiliary.h:97
#define TRUE
Definition: auxiliary.h:101
void WerrorS(const char *s)
Definition: feFopen.cc:24
int fanID
Definition: bbfan.cc:20
int Typ()
Definition: subexpr.cc:979
int getAmbientDimension(gfan::ZFan *zf)
Definition: bbfan.cc:246
void * data
Definition: subexpr.h:90
int m
Definition: cfEzgcd.cc:119
int coneID
Definition: bbcone.cc:26
int i
Definition: cfEzgcd.cc:123
leftv next
Definition: subexpr.h:88
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:93
Variable x
Definition: cfModGcd.cc:4023
void * Data()
Definition: subexpr.cc:1121
Definition: tok.h:116
omBin slists_bin
Definition: lists.cc:23

§ getDimension()

int getDimension ( gfan::ZFan *  zf)

Definition at line 256 of file bbfan.cc.

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

§ getLinealityDimension()

int getLinealityDimension ( gfan::ZFan *  zf)

Definition at line 261 of file bbfan.cc.

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

§ insertCone()

BOOLEAN insertCone ( leftv  res,
leftv  args 
)

Definition at line 392 of file bbfan.cc.

393 {
394  gfan::initializeCddlibIfRequired();
395  leftv u=args;
396  if ((u != NULL) && (u->rtyp==IDHDL) && (u->e==NULL) && (u->Typ() == fanID))
397  {
398  leftv v=u->next;
399  if ((v != NULL) && (v->Typ() == coneID))
400  {
401  gfan::ZFan* zf = (gfan::ZFan*)u->Data();
402  gfan::ZCone* zc = (gfan::ZCone*)v->Data();
403  zc->canonicalize();
404 
405  leftv w=v->next;
406  int n;
407  if ((w != NULL) && (w->Typ() == INT_CMD))
408  n = (int)(long) w;
409 
410  if (n != 0)
411  {
412  if (!isCompatible(zf,zc))
413  {
414  WerrorS("insertCone: cone and fan not compatible");
415  return TRUE;
416  }
417  }
418 
419  zf->insert(*zc);
420  res->rtyp = NONE;
421  res->data = NULL;
422  IDDATA((idhdl)u->data) = (char*) zf;
423  return FALSE;
424  }
425  }
426  WerrorS("insertCone: unexpected parameters");
427  return TRUE;
428 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:84
Definition: tok.h:94
Subexpr e
Definition: subexpr.h:107
#define FALSE
Definition: auxiliary.h:97
bool isCompatible(const gfan::ZFan *zf, const gfan::ZCone *zc)
Definition: bbfan.cc:352
#define TRUE
Definition: auxiliary.h:101
void WerrorS(const char *s)
Definition: feFopen.cc:24
int fanID
Definition: bbfan.cc:20
int Typ()
Definition: subexpr.cc:979
Definition: idrec.h:34
#define IDHDL
Definition: tok.h:31
void * data
Definition: subexpr.h:90
int coneID
Definition: bbcone.cc:26
leftv next
Definition: subexpr.h:88
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:93
void * Data()
Definition: subexpr.cc:1121
#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 352 of file bbfan.cc.

353 {
354  bool b = (zf->getAmbientDimension() == zc->ambientDimension());
355  if(b)
356  {
357  for (int d=0; d<=zf->getAmbientDimension(); d++)
358  {
359  for (int i=0; i<zf->numberOfConesOfDimension(d,0,1); i++)
360  {
361  gfan::ZCone zd = zf->getCone(d,i,0,1);
362  gfan::ZCone zt = gfan::intersection(*zc,zd);
363  zt.canonicalize();
364  b = b && zd.hasFace(zt);
365  }
366  }
367  }
368  return b;
369 }
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 371 of file bbfan.cc.

372 {
373  gfan::initializeCddlibIfRequired();
374  leftv u=args;
375  if ((u != NULL) && (u->Typ() == fanID))
376  {
377  leftv v=u->next;
378  if ((v != NULL) && (v->Typ() == coneID))
379  {
380  gfan::ZFan* zf = (gfan::ZFan*)u->Data();
381  gfan::ZCone* zc = (gfan::ZCone*)v->Data();
382  int b = isCompatible(zf,zc);
383  res->rtyp = INT_CMD;
384  res->data = (void*) (long) b;
385  return FALSE;
386  }
387  }
388  WerrorS("isCompatible: unexpected parameters");
389  return TRUE;
390 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:84
Definition: tok.h:94
#define FALSE
Definition: auxiliary.h:97
bool isCompatible(const gfan::ZFan *zf, const gfan::ZCone *zc)
Definition: bbfan.cc:352
#define TRUE
Definition: auxiliary.h:101
void WerrorS(const char *s)
Definition: feFopen.cc:24
int fanID
Definition: bbfan.cc:20
int Typ()
Definition: subexpr.cc:979
void * data
Definition: subexpr.h:90
int coneID
Definition: bbcone.cc:26
leftv next
Definition: subexpr.h:88
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:93
void * Data()
Definition: subexpr.cc:1121
const poly b
Definition: syzextra.cc:213

§ isPure()

BOOLEAN isPure ( leftv  res,
leftv  args 
)

Definition at line 697 of file bbfan.cc.

698 {
699  gfan::initializeCddlibIfRequired();
700  leftv u=args;
701  if ((u != NULL) && (u->Typ() == fanID))
702  {
703  gfan::ZFan* zf = (gfan::ZFan*) u->Data();
704  int b = zf->isPure();
705  res->rtyp = INT_CMD;
706  res->data = (void*) (long) b;
707  return FALSE;
708  }
709  WerrorS("isPure: unexpected parameters");
710  return TRUE;
711 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:84
Definition: tok.h:94
#define FALSE
Definition: auxiliary.h:97
#define TRUE
Definition: auxiliary.h:101
void WerrorS(const char *s)
Definition: feFopen.cc:24
int fanID
Definition: bbfan.cc:20
int Typ()
Definition: subexpr.cc:979
void * data
Definition: subexpr.h:90
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:93
void * Data()
Definition: subexpr.cc:1121
const poly b
Definition: syzextra.cc:213

§ isSimplicial()

int isSimplicial ( gfan::ZFan *  zf)

Definition at line 691 of file bbfan.cc.

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

§ jjFANEMPTY_I()

static BOOLEAN jjFANEMPTY_I ( leftv  res,
leftv  v 
)
static

Definition at line 145 of file bbfan.cc.

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

§ jjFANEMPTY_IM()

static BOOLEAN jjFANEMPTY_IM ( leftv  res,
leftv  v 
)
static

Definition at line 158 of file bbfan.cc.

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

§ jjFANFULL_I()

static BOOLEAN jjFANFULL_I ( leftv  res,
leftv  v 
)
static

Definition at line 197 of file bbfan.cc.

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

§ jjFANFULL_IM()

static BOOLEAN jjFANFULL_IM ( leftv  res,
leftv  v 
)
static

Definition at line 210 of file bbfan.cc.

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

§ ncones()

BOOLEAN ncones ( leftv  res,
leftv  args 
)

Definition at line 311 of file bbfan.cc.

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

§ nmaxcones()

BOOLEAN nmaxcones ( leftv  res,
leftv  args 
)

Definition at line 332 of file bbfan.cc.

333 {
334  gfan::initializeCddlibIfRequired();
335  leftv u=args;
336  if ((u != NULL) && (u->Typ() == fanID))
337  {
338  gfan::ZFan* zf = (gfan::ZFan*)u->Data();
339 
340  int n = 0;
341  for (int d=0; d<=zf->getAmbientDimension(); d++)
342  n = n + zf->numberOfConesOfDimension(d,0,1);
343 
344  res->rtyp = INT_CMD;
345  res->data = (void*) (long) n;
346  return FALSE;
347  }
348  WerrorS("nmaxcones: unexpected parameters");
349  return TRUE;
350 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:84
Definition: tok.h:94
#define FALSE
Definition: auxiliary.h:97
#define TRUE
Definition: auxiliary.h:101
void WerrorS(const char *s)
Definition: feFopen.cc:24
int fanID
Definition: bbfan.cc:20
int Typ()
Definition: subexpr.cc:979
void * data
Definition: subexpr.h:90
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:93
void * Data()
Definition: subexpr.cc:1121

§ numberOfConesOfDimension()

BOOLEAN numberOfConesOfDimension ( leftv  res,
leftv  args 
)

Definition at line 266 of file bbfan.cc.

267 {
268  gfan::initializeCddlibIfRequired();
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::ZFan* zf = (gfan::ZFan*) u->Data();
282  int d = (int)(long)v->Data();
283  int o = (int)(long)w->Data();
284  int m = (int)(long)x->Data();
285  if ( (0<=d) && (d <= zf->getAmbientDimension())
286  && ((o == 0) || (o == 1))
287  && ((m == 0) || (m == 1)))
288  {
289  bool oo = (bool) o;
290  bool mm = (bool) m;
291  int ld = zf->getLinealityDimension();
292  if (d-ld>=0)
293  {
294  int n = zf->numberOfConesOfDimension(d-ld,oo,mm);
295  res->rtyp = INT_CMD;
296  res->data = (void*) (long) n;
297  return FALSE;
298  }
299  res->rtyp = INT_CMD;
300  res->data = (void*) (long) 0;
301  return FALSE;
302  }
303  }
304  }
305  }
306  }
307  WerrorS("numberOfConesOfDimension: unexpected parameters");
308  return TRUE;
309 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:84
Definition: tok.h:94
#define FALSE
Definition: auxiliary.h:97
#define TRUE
Definition: auxiliary.h:101
void WerrorS(const char *s)
Definition: feFopen.cc:24
int fanID
Definition: bbfan.cc:20
int Typ()
Definition: subexpr.cc:979
int getAmbientDimension(gfan::ZFan *zf)
Definition: bbfan.cc:246
void * data
Definition: subexpr.h:90
int m
Definition: cfEzgcd.cc:119
leftv next
Definition: subexpr.h:88
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:93
Variable x
Definition: cfModGcd.cc:4023
void * Data()
Definition: subexpr.cc:1121

§ numberOfConesWithVector() [1/2]

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

Definition at line 756 of file bbfan.cc.

757 {
758  gfan::initializeCddlibIfRequired();
759  int count = 0;
760  int ambientDim = zf->getAmbientDimension();
761  for (int i=0; i<zf->numberOfConesOfDimension(ambientDim, 0, 0); i++)
762  {
763  gfan::ZCone zc = zf->getCone(ambientDim, i, 0, 0);
764  if (zc.contains(*v))
765  {
766  count = count +1;
767  if (count > 1)
768  return count;
769  }
770  }
771  return count;
772 }
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 774 of file bbfan.cc.

775 {
776  gfan::initializeCddlibIfRequired();
777  leftv u=args;
778  if ((u != NULL) && (u->Typ() == fanID))
779  {
780  leftv v=u->next;
781  if ((v != NULL) && (v->Typ() == BIGINTMAT_CMD))
782  {
783  gfan::ZFan* zf = (gfan::ZFan*) u->Data();
784  bigintmat* v0 = (bigintmat*) v->Data();
785  int ambientDim = zf->getAmbientDimension();
786  if (ambientDim != v0->cols())
787  {
788  WerrorS("numberOfConesWithVector: mismatching dimensions");
789  return TRUE;
790  }
791  gfan::ZVector* v1 = bigintmatToZVector(*v0);
792  int count = numberOfConesWithVector(zf, v1);
793  delete v1;
794  res->rtyp = INT_CMD;
795  res->data = (void*) (long) count;
796  return FALSE;
797  }
798  }
799  WerrorS("numberOfConesWithVector: unexpected parameters");
800  return TRUE;
801 }
int status int void size_t count
Definition: si_signals.h:59
Class used for (list of) interpreter objects.
Definition: subexpr.h:84
Definition: tok.h:94
#define FALSE
Definition: auxiliary.h:97
Matrices of numbers.
Definition: bigintmat.h:51
#define TRUE
Definition: auxiliary.h:101
void WerrorS(const char *s)
Definition: feFopen.cc:24
int fanID
Definition: bbfan.cc:20
int Typ()
Definition: subexpr.cc:979
void * data
Definition: subexpr.h:90
int numberOfConesWithVector(gfan::ZFan *zf, gfan::ZVector *v)
Definition: bbfan.cc:756
int cols() const
Definition: bigintmat.h:145
leftv next
Definition: subexpr.h:88
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:93
void * Data()
Definition: subexpr.cc:1121
gfan::ZVector * bigintmatToZVector(const bigintmat &bim)

§ permutationIntMatrix()

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

Definition at line 126 of file bbfan.cc.

127 {
128  int cc = iv->cols();
129  int rr = iv->rows();
130  bigintmat* ivCopy = new bigintmat(rr, cc, coeffs_BIGINT);
131  number temp1 = n_Init(1,coeffs_BIGINT);
132  for (int r = 1; r <= rr; r++)
133  for (int c = 1; c <= cc; c++)
134  {
135  number temp2 = n_Sub(IMATELEM(*iv, r, c),temp1,coeffs_BIGINT);
136  ivCopy->set(r,c,temp2);
137  n_Delete(&temp2,coeffs_BIGINT);
138  }
139  n_Delete(&temp1,coeffs_BIGINT);
140  gfan::ZMatrix* zm = bigintmatToZMatrix(ivCopy);
141  gfan::IntMatrix im = gfan::IntMatrix(gfan::ZToIntMatrix(*zm));
142  delete zm;
143  return im;
144 }
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 744 of file bbfan.cc.

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

§ removeCone()

BOOLEAN removeCone ( leftv  res,
leftv  args 
)

Definition at line 509 of file bbfan.cc.

510 {
511  gfan::initializeCddlibIfRequired();
512  leftv u=args;
513  if ((u != NULL) && (u->Typ() == fanID))
514  {
515  leftv v=u->next;
516  if ((v != NULL) && (v->Typ() == coneID))
517  {
518  gfan::ZFan* zf = (gfan::ZFan*)u->Data();
519  gfan::ZCone* zc = (gfan::ZCone*)v->Data();
520  zc->canonicalize();
521 
522  leftv w=v->next; int n = 1;
523  if ((w != NULL) && (w->Typ() == INT_CMD))
524  n = (int)(long) w;
525 
526  if (n != 0)
527  {
528  if (!containsInCollection(zf,zc))
529  {
530  WerrorS("removeCone: cone not contained in fan");
531  return TRUE;
532  }
533  }
534 
535  zf->remove(*zc);
536  res->rtyp = NONE;
537  res->data = NULL;
538  IDDATA((idhdl)u->data) = (char*) zf;
539  return FALSE;
540  }
541  }
542  WerrorS("removeCone: unexpected parameters");
543  return TRUE;
544 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:84
Definition: tok.h:94
#define FALSE
Definition: auxiliary.h:97
#define TRUE
Definition: auxiliary.h:101
void WerrorS(const char *s)
Definition: feFopen.cc:24
int fanID
Definition: bbfan.cc:20
int Typ()
Definition: subexpr.cc:979
Definition: idrec.h:34
void * data
Definition: subexpr.h:90
bool containsInCollection(gfan::ZFan *zf, gfan::ZCone *zc)
Definition: bbfan.cc:430
int coneID
Definition: bbcone.cc:26
leftv next
Definition: subexpr.h:88
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:93
void * Data()
Definition: subexpr.cc:1121
#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.