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

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:98
#define FALSE
Definition: auxiliary.h:140
#define TRUE
Definition: auxiliary.h:144
int Typ()
Definition: subexpr.cc:976
Definition: idrec.h:34
#define IDHDL
Definition: tok.h:35
void * data
Definition: subexpr.h:89
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1118
#define IDDATA(a)
Definition: ipid.h:125
void Werror(const char *fmt,...)
Definition: reporter.cc:199
void * CopyD(int t)
Definition: subexpr.cc:676
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 }
BOOLEAN bbfan_deserialize ( blackbox **  b,
void **  d,
si_link  f 
)

Definition at line 1040 of file bbfan.cc.

1041 {
1042  ssiInfo *dd = (ssiInfo *)f->data;
1043 
1044  int l = s_readint(dd->f_read);
1045  char* buf = (char*) omAlloc0(l+1);
1046  (void) s_getc(dd->f_read); // skip whitespace
1047  (void) s_readbytes(buf,l,dd->f_read);
1048  buf[l]='\0';
1049 
1050  std::istringstream fanInString(std::string(buf,l));
1051  gfan::ZFan* zf = new gfan::ZFan(fanInString);
1052  *d=zf;
1053 
1054  omFree(buf);
1055  return FALSE;
1056 }
int s_readbytes(char *buff, int len, s_buff F)
Definition: s_buff.cc:176
#define FALSE
Definition: auxiliary.h:140
#define string
Definition: libparse.cc:1250
int s_getc(s_buff F)
Definition: s_buff.cc:66
int s_readint(s_buff F)
Definition: s_buff.cc:120
#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
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
void* bbfan_Init ( blackbox *  )

Definition at line 22 of file bbfan.cc.

23 {
24  return (void*) new gfan::ZFan(0);
25 }
BOOLEAN bbfan_serialize ( blackbox *  b,
void *  d,
si_link  f 
)

Definition at line 1021 of file bbfan.cc.

1022 {
1023  ssiInfo *dd = (ssiInfo *)f->data;
1024 
1025  sleftv l;
1026  memset(&l,0,sizeof(l));
1027  l.rtyp=STRING_CMD;
1028  l.data=(void*)"fan";
1029  f->m->Write(f, &l);
1030 
1031  gfan::ZFan* zf = (gfan::ZFan*) d;
1032  std::string s = zf->toString(2+4+8+128);
1033 
1034  fprintf(dd->f_write,"%d %s ",(int)s.size(),s.c_str());
1035 
1036  return FALSE;
1037 }
const CanonicalForm int s
Definition: facAbsFact.cc:55
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
#define FALSE
Definition: auxiliary.h:140
#define string
Definition: libparse.cc:1250
FILE * f
Definition: checklibs.c:7
int l
Definition: cfEzgcd.cc:94
void bbfan_setup ( SModulFunctions p)

Definition at line 1059 of file bbfan.cc.

1060 {
1061  blackbox *b=(blackbox*)omAlloc0(sizeof(blackbox));
1062  // all undefined entries will be set to default in setBlackboxStuff
1063  // the default Print is quite usefule,
1064  // all other are simply error messages
1065  b->blackbox_destroy=bbfan_destroy;
1066  b->blackbox_String=bbfan_String;
1067  //b->blackbox_Print=blackbox_default_Print;
1068  b->blackbox_Init=bbfan_Init;
1069  b->blackbox_Copy=bbfan_Copy;
1070  b->blackbox_Assign=bbfan_Assign;
1071  b->blackbox_serialize=bbfan_serialize;
1072  b->blackbox_deserialize=bbfan_deserialize;
1073  p->iiAddCproc("","emptyFan",FALSE,emptyFan);
1074  p->iiAddCproc("","fullFan",FALSE,fullFan);
1075  /* the following functions are implemented in bbcone.cc */
1076  // iiAddCproc("","containsInSupport",FALSE,containsInSupport);
1077  // iiAddCproc("","getAmbientDimension",FALSE,getAmbientDimension);
1078  // iiAddCproc("","getCodimension",FALSE,getDimension);
1079  // iiAddCproc("","getDimension",FALSE,getDimension);
1080  // iiAddCproc("","getLinealityDimension",FALSE,getLinealityDimension);
1081  // iiAddCproc("","isSimplicial",FALSE,isSimplicial);
1082  /********************************************************/
1083  p->iiAddCproc("","isCompatible",FALSE,isCompatible);
1084  p->iiAddCproc("","numberOfConesOfDimension",FALSE,numberOfConesOfDimension);
1085  p->iiAddCproc("","ncones",FALSE,ncones);
1086  p->iiAddCproc("","nmaxcones",FALSE,nmaxcones);
1087  p->iiAddCproc("","insertCone",FALSE,insertCone);
1088  p->iiAddCproc("","removeCone",FALSE,removeCone);
1089  p->iiAddCproc("","getCone",FALSE,getCone);
1090  p->iiAddCproc("","getCones",FALSE,getCones);
1091  p->iiAddCproc("","isPure",FALSE,isPure);
1092  p->iiAddCproc("","fanFromString",FALSE,fanFromString);
1093  p->iiAddCproc("","fanViaCones",FALSE,fanViaCones);
1094  p->iiAddCproc("","numberOfConesWithVector",FALSE,numberOfConesWithVector);
1095  // iiAddCproc("","isComplete",FALSE,isComplete); not working as expected, should leave this to polymake
1096  p->iiAddCproc("","fVector",FALSE,fVector);
1097  p->iiAddCproc("","containsInCollection",FALSE,containsInCollection);
1098  // p->iiAddCproc("","tropicalVariety",FALSE,tropicalVariety);
1099  p->iiAddCproc("","commonRefinement",FALSE,commonRefinement);
1100  // iiAddCproc("","grFan",FALSE,grFan);
1101  fanID=setBlackboxStuff(b,"fan");
1102  //Print("created type %d (fan)\n",fanID);
1103 }
char * bbfan_String(blackbox *, void *d)
Definition: bbfan.cc:36
#define FALSE
Definition: auxiliary.h:140
BOOLEAN numberOfConesOfDimension(leftv res, leftv args)
Definition: bbfan.cc:264
BOOLEAN nmaxcones(leftv res, leftv args)
Definition: bbfan.cc:328
bool isCompatible(const gfan::ZFan *zf, const gfan::ZCone *zc)
Definition: bbfan.cc:347
void * bbfan_Init(blackbox *)
Definition: bbfan.cc:22
BOOLEAN fullFan(leftv res, leftv args)
Definition: bbfan.cc:227
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:803
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:1040
BOOLEAN getCone(leftv res, leftv args)
Definition: bbfan.cc:537
BOOLEAN fanFromString(leftv res, leftv args)
Definition: bbfan.cc:787
BOOLEAN ncones(leftv res, leftv args)
Definition: bbfan.cc:308
int numberOfConesWithVector(gfan::ZFan *zf, gfan::ZVector *v)
Definition: bbfan.cc:742
BOOLEAN insertCone(leftv res, leftv args)
Definition: bbfan.cc:386
BOOLEAN fVector(leftv res, leftv args)
Definition: bbfan.cc:716
bool containsInCollection(gfan::ZFan *zf, gfan::ZCone *zc)
Definition: bbfan.cc:423
BOOLEAN getCones(leftv res, leftv args)
Definition: bbfan.cc:612
BOOLEAN isPure(leftv res, leftv args)
Definition: bbfan.cc:686
gfan::ZFan commonRefinement(gfan::ZFan zf, gfan::ZFan zg)
Definition: bbfan.cc:927
BOOLEAN removeCone(leftv res, leftv args)
Definition: bbfan.cc:501
BOOLEAN bbfan_serialize(blackbox *b, void *d, si_link f)
Definition: bbfan.cc:1021
int(* iiAddCproc)(const char *libname, const char *procname, BOOLEAN pstatic, BOOLEAN(*func)(leftv res, leftv v))
Definition: ipid.h:73
int setBlackboxStuff(blackbox *bb, const char *n)
define a new type
Definition: blackbox.cc:128
const poly b
Definition: syzextra.cc:213
void bbfan_destroy(blackbox *, void *d)
Definition: bbfan.cc:27
#define omAlloc0(size)
Definition: omAllocDecl.h:211
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
gfan::ZFan commonRefinement ( gfan::ZFan  zf,
gfan::ZFan  zg 
)

Definition at line 927 of file bbfan.cc.

928 {
929  assume(zf.getAmbientDimension() == zg.getAmbientDimension());
930 
931  // gather all maximal cones of f and g
932  std::list<gfan::ZCone> maximalConesOfF;
933  for (int d=0; d<=zf.getAmbientDimension(); d++)
934  for (int i=0; i<zf.numberOfConesOfDimension(d,0,1); i++)
935  maximalConesOfF.push_back(zf.getCone(d,i,0,1));
936 
937  std::list<gfan::ZCone> maximalConesOfG;
938  for (int d=0; d<=zg.getAmbientDimension(); d++)
939  for (int i=0; i<zg.numberOfConesOfDimension(d,0,1); i++)
940  maximalConesOfG.push_back(zg.getCone(d,i,0,1));
941 
942  // construct a new fan out of their intersections
943  gfan::ZFan zr = gfan::ZFan(zf.getAmbientDimension());
944  for (std::list<gfan::ZCone>::iterator itf=maximalConesOfF.begin();
945  itf != maximalConesOfF.end(); itf++)
946  for (std::list<gfan::ZCone>::iterator itg=maximalConesOfG.begin();
947  itg != maximalConesOfG.end(); itg++)
948  zr.insert(intersection(*itf,*itg));
949 
950  return zr;
951 }
#define assume(x)
Definition: mod2.h:405
int i
Definition: cfEzgcd.cc:123
BOOLEAN commonRefinement ( leftv  res,
leftv  args 
)

Definition at line 953 of file bbfan.cc.

954 {
955  leftv u=args;
956  if ((u != NULL) && (u->Typ() == fanID))
957  {
958  leftv v=u->next;
959  if ((v != NULL) && (v->Typ() == fanID))
960  {
961  gfan::ZFan* zf = (gfan::ZFan*) u->Data();
962  gfan::ZFan* zg = (gfan::ZFan*) v->Data();
963  gfan::ZFan* zr = new gfan::ZFan(commonRefinement(*zf,*zg));
964  res->rtyp = fanID;
965  res->data = (void*) zr;
966  return FALSE;
967  }
968  }
969  WerrorS("commonRefinement: unexpected parameters");
970  return TRUE;
971 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
#define FALSE
Definition: auxiliary.h:140
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:24
int fanID
Definition: bbfan.cc:20
int Typ()
Definition: subexpr.cc:976
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:927
void * Data()
Definition: subexpr.cc:1118
bool containsInCollection ( gfan::ZFan *  zf,
gfan::ZCone *  zc 
)

Definition at line 423 of file bbfan.cc.

424 {
425  gfan::ZVector zv=zc->getRelativeInteriorPoint();
426  for (int d=0; d<=zf->getAmbientDimension(); d++)
427  {
428  for (int i=0; i<zf->numberOfConesOfDimension(d,0,1); i++)
429  {
430  gfan::ZCone zd = zf->getCone(d,i,0,1);
431  zd.canonicalize();
432  if (zd.containsRelatively(zv))
433  {
434  gfan::ZCone temp = *zc;
435  temp.canonicalize();
436  return (!(zd != temp));
437  }
438  }
439  }
440  return 0;
441 }
int i
Definition: cfEzgcd.cc:123
BOOLEAN containsInCollection ( leftv  res,
leftv  args 
)

Definition at line 443 of file bbfan.cc.

444 {
445  leftv u=args;
446  if ((u != NULL) && (u->Typ() == fanID))
447  {
448  leftv v=u->next;
449  if ((v != NULL) && (v->Typ() == coneID))
450  {
451  gfan::ZFan* zf = (gfan::ZFan*)u->Data();
452  gfan::ZCone* zc = (gfan::ZCone*)v->Data();
453  if((zf->getAmbientDimension() == zc->ambientDimension()))
454  {
455  res->rtyp = INT_CMD;
456  res->data = (void*) (long) (int) containsInCollection(zf,zc);
457  return FALSE;
458  }
459  WerrorS("containsInCollection: mismatching ambient dimensions");
460  return TRUE;
461  }
462  }
463  WerrorS("containsInCollection: unexpected parameters");
464  return TRUE;
465 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: tok.h:98
#define FALSE
Definition: auxiliary.h:140
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:24
int fanID
Definition: bbfan.cc:20
int Typ()
Definition: subexpr.cc:976
void * data
Definition: subexpr.h:89
bool containsInCollection(gfan::ZFan *zf, gfan::ZCone *zc)
Definition: bbfan.cc:423
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:1118
BOOLEAN emptyFan ( leftv  res,
leftv  args 
)

Definition at line 175 of file bbfan.cc.

176 {
177  leftv u = args;
178  if (u == NULL)
179  {
180  res->rtyp = fanID;
181  res->data = (void*) new gfan::ZFan(0);
182  return FALSE;
183  }
184  if ((u != NULL) && (u->Typ() == INT_CMD))
185  {
186  if (u->next == NULL) return jjFANEMPTY_I(res, u);
187  }
188  if ((u != NULL) && (u->Typ() == BIGINTMAT_CMD))
189  {
190  if (u->next == NULL) return jjFANEMPTY_IM(res, u);
191  }
192  WerrorS("emptyFan: unexpected parameters");
193  return TRUE;
194 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: tok.h:98
#define FALSE
Definition: auxiliary.h:140
#define TRUE
Definition: auxiliary.h:144
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:976
void * data
Definition: subexpr.h:89
static BOOLEAN jjFANEMPTY_I(leftv res, leftv v)
Definition: bbfan.cc:145
leftv next
Definition: subexpr.h:87
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
BOOLEAN fanFromString ( leftv  res,
leftv  args 
)

Definition at line 787 of file bbfan.cc.

788 {
789  leftv u=args;
790  if ((u != NULL) && (u->Typ() == STRING_CMD))
791  {
792  std::string fanInString = (char*) u->Data();
793  std::istringstream s(fanInString);
794  gfan::ZFan* zf = new gfan::ZFan(s);
795  res->rtyp = fanID;
796  res->data = (void*) zf;
797  return FALSE;
798  }
799  WerrorS("fanFromString: unexpected parameters");
800  return TRUE;
801 }
const CanonicalForm int s
Definition: facAbsFact.cc:55
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
#define FALSE
Definition: auxiliary.h:140
#define string
Definition: libparse.cc:1250
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:24
int fanID
Definition: bbfan.cc:20
int Typ()
Definition: subexpr.cc:976
void * data
Definition: subexpr.h:89
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1118
BOOLEAN fanViaCones ( leftv  res,
leftv  args 
)

Definition at line 803 of file bbfan.cc.

804 {
805  leftv u=args;
806  if ((u != NULL) && (u->Typ() == LIST_CMD))
807  {
808  lists L = (lists) u->Data();
809  if (lSize(L)>-1)
810  {
811  if (L->m[0].Typ() != coneID)
812  {
813  WerrorS("fanViaCones: list contains entries of wrong type");
814  return TRUE;
815  }
816  gfan::ZCone* zc = (gfan::ZCone*) L->m[0].Data();
817  gfan::ZFan* zf = new gfan::ZFan(zc->ambientDimension());
818  zf->insert(*zc);
819  for (int i=1; i<=lSize(L); i++)
820  {
821  if (L->m[i].Typ() != coneID)
822  {
823  WerrorS("fanViaCones: entries of wrong type in list");
824  return TRUE;
825  }
826  gfan::ZCone* zc = (gfan::ZCone*) L->m[i].Data();
827  if (zc->ambientDimension() != zf->getAmbientDimension())
828  {
829  WerrorS("fanViaCones: inconsistent ambient dimensions amongst cones in list");
830  return TRUE;
831  }
832  zf->insert(*zc);
833  }
834  res->rtyp = fanID;
835  res->data = (void*) zf;
836  return FALSE;
837  }
838  res->rtyp = fanID;
839  res->data = (void*) new gfan::ZFan(0);
840  return FALSE;
841  }
842  if ((u != NULL) && (u->Typ() == coneID))
843  {
844  gfan::ZCone* zc = (gfan::ZCone*) u->Data();
845  gfan::ZFan* zf = new gfan::ZFan(zc->ambientDimension());
846  zf->insert(*zc);
847  while (u->next != NULL)
848  {
849  u = u->next;
850  if (u->Typ() != coneID)
851  {
852  WerrorS("fanViaCones: arguments of wrong type");
853  return TRUE;
854  }
855  gfan::ZCone* zc = (gfan::ZCone*) u->Data();
856  if (zc->ambientDimension() != zf->getAmbientDimension())
857  {
858  WerrorS("fanViaCones: inconsistent ambient dimensions amongst input cones");
859  return TRUE;
860  }
861  zf->insert(*zc);
862  }
863  res->rtyp = fanID;
864  res->data = (void*) zf;
865  return FALSE;
866  }
867  if (u == NULL)
868  {
869  res->rtyp = fanID;
870  res->data = (void*) new gfan::ZFan(0);
871  return FALSE;
872  }
873  WerrorS("fanViaCones: unexpected parameters");
874  return TRUE;
875 }
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:140
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:24
int fanID
Definition: bbfan.cc:20
int Typ()
Definition: subexpr.cc:976
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:1118
Definition: tok.h:120
BOOLEAN fullFan ( leftv  res,
leftv  args 
)

Definition at line 227 of file bbfan.cc.

228 {
229  leftv u = args;
230  if (u == NULL)
231  {
232  res->rtyp = fanID;
233  res->data = (void*) new gfan::ZFan(0);
234  return FALSE;
235  }
236  if ((u != NULL) && (u->Typ() == INT_CMD))
237  if (u->next == NULL) return jjFANFULL_I(res, u);
238  if ((u != NULL) && (u->Typ() == BIGINTMAT_CMD))
239  if (u->next == NULL) return jjFANFULL_IM(res, u);
240  WerrorS("fullFan: unexpected parameters");
241  return TRUE;
242 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: tok.h:98
#define FALSE
Definition: auxiliary.h:140
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:24
int fanID
Definition: bbfan.cc:20
int Typ()
Definition: subexpr.cc:976
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:209
static BOOLEAN jjFANFULL_I(leftv res, leftv v)
Definition: bbfan.cc:196
BOOLEAN fVector ( leftv  res,
leftv  args 
)

Definition at line 716 of file bbfan.cc.

717 {
718  leftv u=args;
719  if ((u != NULL) && (u->Typ() == fanID))
720  {
721  gfan::ZFan* zf = (gfan::ZFan*) u->Data();
722  gfan::ZVector zv=zf->getFVector();
723  res->rtyp = BIGINTMAT_CMD;
724  res->data = (void*) zVectorToBigintmat(zv);
725  return FALSE;
726  }
727  WerrorS("fVector: unexpected parameters");
728  return TRUE;
729 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
#define FALSE
Definition: auxiliary.h:140
#define TRUE
Definition: auxiliary.h:144
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:976
void * data
Definition: subexpr.h:89
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1118
int getAmbientDimension ( gfan::ZFan *  zf)

Definition at line 244 of file bbfan.cc.

245 {
246  return zf->getAmbientDimension();
247 }
int getCodimension ( gfan::ZFan *  zf)

Definition at line 249 of file bbfan.cc.

250 {
251  return zf->getCodimension();
252 }
BOOLEAN getCone ( leftv  res,
leftv  args 
)

Definition at line 537 of file bbfan.cc.

538 {
539  leftv u=args;
540  if ((u != NULL) && (u->Typ() == fanID))
541  {
542  leftv v=u->next;
543  if ((v != NULL) && (v->Typ() == INT_CMD))
544  {
545  leftv w=v->next;
546  if ((w != NULL) && (w->Typ() == INT_CMD))
547  {
548  gfan::ZFan* zf = (gfan::ZFan*) u->Data();
549  int d = (int)(long)v->Data();
550  int i = (int)(long)w->Data();
551  int o = -1;
552  int m = -1;
553  leftv x=w->next;
554  if ((x != NULL) && (x->Typ() == INT_CMD))
555  {
556  o = (int)(long)x->Data();
557  leftv y=x->next;
558  if ((y != NULL) && (y->Typ() == INT_CMD))
559  {
560  m = (int)(long)y->Data();
561  }
562  }
563  if (o == -1) o = 0;
564  if (m == -1) m = 0;
565  if (((o == 0) || (o == 1)) && ((m == 0) || (m == 1)))
566  {
567  bool oo = (bool) o;
568  bool mm = (bool) m;
569  if (0<=d && d<=zf->getAmbientDimension())
570  {
571  int ld = zf->getLinealityDimension();
572  if (0<i && i<=zf->numberOfConesOfDimension(d-ld,oo,mm))
573  {
574  i=i-1;
575  if (d-ld>=0)
576  {
577  gfan::ZCone zc = zf->getCone(d-ld,i,oo,mm);
578  res->rtyp = coneID;
579  res->data = (void*)new gfan::ZCone(zc);
580  return FALSE;
581  }
582  else
583  {
584  WerrorS("getCone: invalid dimension; no cones in this dimension");
585  return TRUE;
586  }
587  }
588  else
589  {
590  WerrorS("getCone: invalid index");
591  return TRUE;
592  }
593  }
594  else
595  {
596  WerrorS("getCone: invalid dimension");
597  return TRUE;
598  }
599  }
600  else
601  {
602  WerrorS("getCone: invalid specifier for orbit or maximal");
603  return TRUE;
604  }
605  }
606  }
607  }
608  WerrorS("getCone: unexpected parameters");
609  return TRUE;
610 }
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:98
#define FALSE
Definition: auxiliary.h:140
BOOLEAN numberOfConesOfDimension(leftv res, leftv args)
Definition: bbfan.cc:264
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:24
int fanID
Definition: bbfan.cc:20
int Typ()
Definition: subexpr.cc:976
int getAmbientDimension(gfan::ZFan *zf)
Definition: bbfan.cc:244
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:1118
BOOLEAN getCones ( leftv  res,
leftv  args 
)

Definition at line 612 of file bbfan.cc.

613 {
614  leftv u=args;
615  if ((u != NULL) && (u->Typ() == fanID))
616  {
617  leftv v=u->next;
618  if ((v != NULL) && (v->Typ() == INT_CMD))
619  {
620  gfan::ZFan* zf = (gfan::ZFan*) u->Data();
621  int d = (int)(long)v->Data();
622  int o = -1;
623  int m = -1;
624  leftv w=v->next;
625  if ((w != NULL) && (w->Typ() == INT_CMD))
626  {
627  o = (int)(long)w->Data();
628  leftv x=w->next;
629  if ((x != NULL) && (x->Typ() == INT_CMD))
630  {
631  m = (int)(long)x->Data();
632  }
633  }
634  if (o == -1) o = 0;
635  if (m == -1) m = 0;
636  if (((o == 0) || (o == 1)) && ((m == 0) || (m == 1)))
637  {
638  bool oo = (bool) o;
639  bool mm = (bool) m;
640  if (0<=d && d<=zf->getAmbientDimension())
641  {
642  int ld = zf->getLinealityDimension();
643  if (d-ld>=0)
644  {
646  int n = zf->numberOfConesOfDimension(d-ld,oo,mm);
647  L->Init(n);
648  for (int i=0; i<n; i++)
649  {
650  gfan::ZCone zc = zf->getCone(d-ld,i,oo,mm);
651  L->m[i].rtyp = coneID; L->m[i].data=(void*) new gfan::ZCone(zc);
652  }
653  res->rtyp = LIST_CMD;
654  res->data = (void*) L;
655  return FALSE;
656  }
657  else
658  {
659  WerrorS("getCones: invalid dimension; no cones in this dimension");
660  return TRUE;
661  }
662  }
663  else
664  {
665  WerrorS("getCones: invalid dimension");
666  return TRUE;
667  }
668  }
669  else
670  {
671  WerrorS("getCones: invalid specifier for orbit or maximal");
672  return TRUE;
673  }
674  }
675  }
676  WerrorS("getCones: unexpected parameters");
677  return TRUE;
678 }
#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:98
Definition: lists.h:22
#define FALSE
Definition: auxiliary.h:140
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:24
int fanID
Definition: bbfan.cc:20
int Typ()
Definition: subexpr.cc:976
int getAmbientDimension(gfan::ZFan *zf)
Definition: bbfan.cc:244
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)
Definition: lists.h:66
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:1118
Definition: tok.h:120
omBin slists_bin
Definition: lists.cc:23
int getDimension ( gfan::ZFan *  zf)

Definition at line 254 of file bbfan.cc.

255 {
256  return zf->getDimension();
257 }
int getLinealityDimension ( gfan::ZFan *  zf)

Definition at line 259 of file bbfan.cc.

260 {
261  return zf->getLinealityDimension();
262 }
BOOLEAN insertCone ( leftv  res,
leftv  args 
)

Definition at line 386 of file bbfan.cc.

387 {
388  leftv u=args;
389  if ((u != NULL) && (u->rtyp==IDHDL) && (u->e==NULL) && (u->Typ() == fanID))
390  {
391  leftv v=u->next;
392  if ((v != NULL) && (v->Typ() == coneID))
393  {
394  gfan::ZFan* zf = (gfan::ZFan*)u->Data();
395  gfan::ZCone* zc = (gfan::ZCone*)v->Data();
396  zc->canonicalize();
397 
398  leftv w=v->next;
399  int n;
400  if ((w != NULL) && (w->Typ() == INT_CMD))
401  n = (int)(long) w;
402 
403  if (n != 0)
404  {
405  if (!isCompatible(zf,zc))
406  {
407  WerrorS("insertCone: cone and fan not compatible");
408  return TRUE;
409  }
410  }
411 
412  zf->insert(*zc);
413  res->rtyp = NONE;
414  res->data = NULL;
415  IDDATA((idhdl)u->data) = (char*) zf;
416  return FALSE;
417  }
418  }
419  WerrorS("insertCone: unexpected parameters");
420  return TRUE;
421 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: tok.h:98
Subexpr e
Definition: subexpr.h:106
#define FALSE
Definition: auxiliary.h:140
bool isCompatible(const gfan::ZFan *zf, const gfan::ZCone *zc)
Definition: bbfan.cc:347
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:24
int fanID
Definition: bbfan.cc:20
int Typ()
Definition: subexpr.cc:976
Definition: idrec.h:34
#define IDHDL
Definition: tok.h:35
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:1118
#define IDDATA(a)
Definition: ipid.h:125
#define NONE
Definition: tok.h:220
bool isCompatible ( const gfan::ZFan *  zf,
const gfan::ZCone *  zc 
)

Definition at line 347 of file bbfan.cc.

348 {
349  bool b = (zf->getAmbientDimension() == zc->ambientDimension());
350  if(b)
351  {
352  for (int d=0; d<=zf->getAmbientDimension(); d++)
353  {
354  for (int i=0; i<zf->numberOfConesOfDimension(d,0,1); i++)
355  {
356  gfan::ZCone zd = zf->getCone(d,i,0,1);
357  gfan::ZCone zt = gfan::intersection(*zc,zd);
358  zt.canonicalize();
359  b = b && zd.hasFace(zt);
360  }
361  }
362  }
363  return b;
364 }
int i
Definition: cfEzgcd.cc:123
const poly b
Definition: syzextra.cc:213
BOOLEAN isCompatible ( leftv  res,
leftv  args 
)

Definition at line 366 of file bbfan.cc.

367 {
368  leftv u=args;
369  if ((u != NULL) && (u->Typ() == fanID))
370  {
371  leftv v=u->next;
372  if ((v != NULL) && (v->Typ() == coneID))
373  {
374  gfan::ZFan* zf = (gfan::ZFan*)u->Data();
375  gfan::ZCone* zc = (gfan::ZCone*)v->Data();
376  int b = isCompatible(zf,zc);
377  res->rtyp = INT_CMD;
378  res->data = (void*) (long) b;
379  return FALSE;
380  }
381  }
382  WerrorS("isCompatible: unexpected parameters");
383  return TRUE;
384 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: tok.h:98
#define FALSE
Definition: auxiliary.h:140
bool isCompatible(const gfan::ZFan *zf, const gfan::ZCone *zc)
Definition: bbfan.cc:347
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:24
int fanID
Definition: bbfan.cc:20
int Typ()
Definition: subexpr.cc:976
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:1118
const poly b
Definition: syzextra.cc:213
BOOLEAN isPure ( leftv  res,
leftv  args 
)

Definition at line 686 of file bbfan.cc.

687 {
688  leftv u=args;
689  if ((u != NULL) && (u->Typ() == fanID))
690  {
691  gfan::ZFan* zf = (gfan::ZFan*) u->Data();
692  int b = zf->isPure();
693  res->rtyp = INT_CMD;
694  res->data = (void*) (long) b;
695  return FALSE;
696  }
697  WerrorS("isPure: unexpected parameters");
698  return TRUE;
699 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: tok.h:98
#define FALSE
Definition: auxiliary.h:140
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:24
int fanID
Definition: bbfan.cc:20
int Typ()
Definition: subexpr.cc:976
void * data
Definition: subexpr.h:89
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1118
const poly b
Definition: syzextra.cc:213
int isSimplicial ( gfan::ZFan *  zf)

Definition at line 680 of file bbfan.cc.

681 {
682  int i = zf->isSimplicial() ? 1 : 0;
683  return i;
684 }
int i
Definition: cfEzgcd.cc:123
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:140
#define TRUE
Definition: auxiliary.h:144
int fanID
Definition: bbfan.cc:20
void * data
Definition: subexpr.h:89
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1118
void Werror(const char *fmt,...)
Definition: reporter.cc:199
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:140
Matrices of numbers.
Definition: bigintmat.h:51
#define TRUE
Definition: auxiliary.h:144
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:126
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1118
void Werror(const char *fmt,...)
Definition: reporter.cc:199
static BOOLEAN jjFANFULL_I ( leftv  res,
leftv  v 
)
static

Definition at line 196 of file bbfan.cc.

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

Definition at line 209 of file bbfan.cc.

210 {
211  bigintmat* permutations = (bigintmat*)v->Data();
212  int ambientDim = permutations->cols();
213  gfan::IntMatrix im = permutationIntMatrix(permutations);
214  if (!gfan::Permutation::arePermutations(im))
215  {
216  Werror("provided bigintmat contains invalid permutations of {1, ..., %d}", ambientDim);
217  return TRUE;
218  }
219  gfan::SymmetryGroup sg = gfan::SymmetryGroup(ambientDim);
220  sg.computeClosure(im);
221  gfan::ZFan* zf = new gfan::ZFan(gfan::ZFan::fullFan(sg));
222  res->rtyp = fanID;
223  res->data = (void*) zf;
224  return FALSE;
225 }
#define FALSE
Definition: auxiliary.h:140
Matrices of numbers.
Definition: bigintmat.h:51
BOOLEAN fullFan(leftv res, leftv args)
Definition: bbfan.cc:227
#define TRUE
Definition: auxiliary.h:144
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:126
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1118
void Werror(const char *fmt,...)
Definition: reporter.cc:199
BOOLEAN ncones ( leftv  res,
leftv  args 
)

Definition at line 308 of file bbfan.cc.

309 {
310  leftv u=args;
311  if ((u != NULL) && (u->Typ() == fanID))
312  {
313  gfan::ZFan* zf = (gfan::ZFan*)u->Data();
314  int d = zf->getAmbientDimension();
315  int n = 0;
316 
317  for (int i=0; i<=d; i++)
318  n = n + zf->numberOfConesOfDimension(i,0,0);
319 
320  res->rtyp = INT_CMD;
321  res->data = (void*) (long) n;
322  return FALSE;
323  }
324  WerrorS("ncones: unexpected parameters");
325  return TRUE;
326 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: tok.h:98
#define FALSE
Definition: auxiliary.h:140
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:24
int fanID
Definition: bbfan.cc:20
int Typ()
Definition: subexpr.cc:976
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:1118
BOOLEAN nmaxcones ( leftv  res,
leftv  args 
)

Definition at line 328 of file bbfan.cc.

329 {
330  leftv u=args;
331  if ((u != NULL) && (u->Typ() == fanID))
332  {
333  gfan::ZFan* zf = (gfan::ZFan*)u->Data();
334 
335  int n = 0;
336  for (int d=0; d<=zf->getAmbientDimension(); d++)
337  n = n + zf->numberOfConesOfDimension(d,0,1);
338 
339  res->rtyp = INT_CMD;
340  res->data = (void*) (long) n;
341  return FALSE;
342  }
343  WerrorS("nmaxcones: unexpected parameters");
344  return TRUE;
345 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: tok.h:98
#define FALSE
Definition: auxiliary.h:140
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:24
int fanID
Definition: bbfan.cc:20
int Typ()
Definition: subexpr.cc:976
void * data
Definition: subexpr.h:89
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1118
BOOLEAN numberOfConesOfDimension ( leftv  res,
leftv  args 
)

Definition at line 264 of file bbfan.cc.

265 {
266  leftv u=args;
267  if ((u != NULL) && (u->Typ() == fanID))
268  {
269  leftv v=u->next;
270  if ((v != NULL) && (v->Typ() == INT_CMD))
271  {
272  leftv w=v->next;
273  if ((w != NULL) && (w->Typ() == INT_CMD))
274  {
275  leftv x=w->next;
276  if ((x != NULL) && (x->Typ() == INT_CMD))
277  {
278  gfan::ZFan* zf = (gfan::ZFan*) u->Data();
279  int d = (int)(long)v->Data();
280  int o = (int)(long)w->Data();
281  int m = (int)(long)x->Data();
282  if ( (0<=d) && (d <= zf->getAmbientDimension())
283  && ((o == 0) || (o == 1))
284  && ((m == 0) || (m == 1)))
285  {
286  bool oo = (bool) o;
287  bool mm = (bool) m;
288  int ld = zf->getLinealityDimension();
289  if (d-ld>=0)
290  {
291  int n = zf->numberOfConesOfDimension(d-ld,oo,mm);
292  res->rtyp = INT_CMD;
293  res->data = (void*) (long) n;
294  return FALSE;
295  }
296  res->rtyp = INT_CMD;
297  res->data = (void*) (long) 0;
298  return FALSE;
299  }
300  }
301  }
302  }
303  }
304  WerrorS("numberOfConesOfDimension: unexpected parameters");
305  return TRUE;
306 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: tok.h:98
#define FALSE
Definition: auxiliary.h:140
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:24
int fanID
Definition: bbfan.cc:20
int Typ()
Definition: subexpr.cc:976
int getAmbientDimension(gfan::ZFan *zf)
Definition: bbfan.cc:244
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:1118
int numberOfConesWithVector ( gfan::ZFan *  zf,
gfan::ZVector *  v 
)

Definition at line 742 of file bbfan.cc.

743 {
744  int count = 0;
745  int ambientDim = zf->getAmbientDimension();
746  for (int i=0; i<zf->numberOfConesOfDimension(ambientDim, 0, 0); i++)
747  {
748  gfan::ZCone zc = zf->getCone(ambientDim, i, 0, 0);
749  if (zc.contains(*v))
750  {
751  count = count +1;
752  if (count > 1)
753  return count;
754  }
755  }
756  return count;
757 }
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
BOOLEAN numberOfConesWithVector ( leftv  res,
leftv  args 
)

Definition at line 759 of file bbfan.cc.

760 {
761  leftv u=args;
762  if ((u != NULL) && (u->Typ() == fanID))
763  {
764  leftv v=u->next;
765  if ((v != NULL) && (v->Typ() == BIGINTMAT_CMD))
766  {
767  gfan::ZFan* zf = (gfan::ZFan*) u->Data();
768  bigintmat* v0 = (bigintmat*) v->Data();
769  int ambientDim = zf->getAmbientDimension();
770  if (ambientDim != v0->cols())
771  {
772  WerrorS("numberOfConesWithVector: mismatching dimensions");
773  return TRUE;
774  }
775  gfan::ZVector* v1 = bigintmatToZVector(*v0);
776  int count = numberOfConesWithVector(zf, v1);
777  delete v1;
778  res->rtyp = INT_CMD;
779  res->data = (void*) (long) count;
780  return FALSE;
781  }
782  }
783  WerrorS("numberOfConesWithVector: unexpected parameters");
784  return TRUE;
785 }
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:98
#define FALSE
Definition: auxiliary.h:140
Matrices of numbers.
Definition: bigintmat.h:51
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:24
int fanID
Definition: bbfan.cc:20
int Typ()
Definition: subexpr.cc:976
void * data
Definition: subexpr.h:89
int numberOfConesWithVector(gfan::ZFan *zf, gfan::ZVector *v)
Definition: bbfan.cc:742
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:1118
gfan::ZVector * bigintmatToZVector(const bigintmat &bim)
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:670
Matrices of numbers.
Definition: bigintmat.h:51
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:539
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
int rows() const
Definition: bigintmat.h:146
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:456
#define IMATELEM(M, I, J)
Definition: intvec.h:77
gfan::ZMatrix rays ( const gfan::ZFan *const  zf)

Definition at line 731 of file bbfan.cc.

732 {
733  gfan::ZMatrix rays(0,zf->getAmbientDimension());
734  for (int i=0; i<zf->numberOfConesOfDimension(1,0,0); i++)
735  {
736  gfan::ZCone zc = zf->getCone(1, i, 0, 0);
737  rays.append(zc.extremeRays());
738  }
739  return rays;
740 }
gfan::ZMatrix rays(const gfan::ZFan *const zf)
Definition: bbfan.cc:731
int i
Definition: cfEzgcd.cc:123
BOOLEAN removeCone ( leftv  res,
leftv  args 
)

Definition at line 501 of file bbfan.cc.

502 {
503  leftv u=args;
504  if ((u != NULL) && (u->Typ() == fanID))
505  {
506  leftv v=u->next;
507  if ((v != NULL) && (v->Typ() == coneID))
508  {
509  gfan::ZFan* zf = (gfan::ZFan*)u->Data();
510  gfan::ZCone* zc = (gfan::ZCone*)v->Data();
511  zc->canonicalize();
512 
513  leftv w=v->next; int n = 1;
514  if ((w != NULL) && (w->Typ() == INT_CMD))
515  n = (int)(long) w;
516 
517  if (n != 0)
518  {
519  if (!containsInCollection(zf,zc))
520  {
521  WerrorS("removeCone: cone not contained in fan");
522  return TRUE;
523  }
524  }
525 
526  zf->remove(*zc);
527  res->rtyp = NONE;
528  res->data = NULL;
529  IDDATA((idhdl)u->data) = (char*) zf;
530  return FALSE;
531  }
532  }
533  WerrorS("removeCone: unexpected parameters");
534  return TRUE;
535 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: tok.h:98
#define FALSE
Definition: auxiliary.h:140
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:24
int fanID
Definition: bbfan.cc:20
int Typ()
Definition: subexpr.cc:976
Definition: idrec.h:34
void * data
Definition: subexpr.h:89
bool containsInCollection(gfan::ZFan *zf, gfan::ZCone *zc)
Definition: bbfan.cc:423
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:1118
#define IDDATA(a)
Definition: ipid.h:125
#define NONE
Definition: tok.h:220

Variable Documentation

int fanID

Definition at line 20 of file bbfan.cc.