24 return (
void*)
new gfan::ZFan(0);
31 gfan::ZFan* zf = (gfan::ZFan*) d;
41 gfan::initializeCddlibIfRequired();
42 gfan::ZFan* zf = (gfan::ZFan*)d;
44 gfan::deinitializeCddlibIfRequired();
67 gfan::ZFan* zf = (gfan::ZFan*)d;
68 gfan::ZFan* newZf =
new gfan::ZFan(*zf);
79 gfan::ZFan* zd = (gfan::ZFan*)
l->Data();
82 newZf =
new gfan::ZFan(0);
84 else if (
r->Typ()==
l->Typ())
88 gfan::ZFan* zd = (gfan::ZFan*)
l->Data();
91 newZf = (gfan::ZFan*)
r->CopyD();
95 int ambientDim = (int) (
long)
r->Data();
98 Werror(
"expected an int >= 0, but got %d", ambientDim);
103 gfan::ZFan* zd = (gfan::ZFan*)
l->Data();
106 newZf =
new gfan::ZFan(ambientDim);
110 Werror(
"assign Type(%d) = Type(%d) not implemented",
l->Typ(),
r->Typ());
120 l->data = (
void*) newZf;
134 for (
int r = 1;
r <= rr;
r++)
135 for (
int c = 1; c <= cc; c++)
143 gfan::IntMatrix im = gfan::IntMatrix(gfan::ZToIntMatrix(*zm));
149 int ambientDim = (int)(
long)
v->Data();
152 Werror(
"expected non-negative ambient dim but got %d", ambientDim);
156 res->data = (
void*)(
new gfan::ZFan(ambientDim));
163 int ambientDim = permutations->
cols();
165 if (!gfan::Permutation::arePermutations(im))
167 Werror(
"provided bigintmat contains invalid permutations of {1, ..., %d}", ambientDim);
170 gfan::SymmetryGroup sg = gfan::SymmetryGroup(ambientDim);
171 sg.computeClosure(im);
173 res->data = (
void*)(
new gfan::ZFan(sg));
183 res->data = (
void*)
new gfan::ZFan(0);
194 WerrorS(
"emptyFan: unexpected parameters");
200 int ambientDim = (int)(
long)
v->Data();
203 Werror(
"expected non-negative ambient dim but got %d", ambientDim);
208 res->data = (
void*) zf;
214 int ambientDim = permutations->
cols();
216 if (!gfan::Permutation::arePermutations(im))
218 Werror(
"provided bigintmat contains invalid permutations of {1, ..., %d}", ambientDim);
221 gfan::SymmetryGroup sg = gfan::SymmetryGroup(ambientDim);
222 sg.computeClosure(im);
225 res->data = (
void*) zf;
231 gfan::initializeCddlibIfRequired();
236 res->data = (
void*)
new gfan::ZFan(0);
243 WerrorS(
"fullFan: unexpected parameters");
249 return zf->getAmbientDimension();
254 return zf->getCodimension();
259 return zf->getDimension();
264 return zf->getLinealityDimension();
281 gfan::initializeCddlibIfRequired();
282 gfan::ZFan* zf = (gfan::ZFan*) u->
Data();
283 int d = (int)(
long)
v->Data();
284 int o = (int)(
long)
w->Data();
285 int m = (int)(
long)
x->Data();
287 && ((o == 0) || (o == 1))
288 && ((
m == 0) || (
m == 1)))
292 int ld = zf->getLinealityDimension();
295 int n = zf->numberOfConesOfDimension(d-ld,oo,mm);
297 res->data = (
void*) (
long) n;
298 gfan::deinitializeCddlibIfRequired();
302 res->data = (
void*) (
long) 0;
303 gfan::deinitializeCddlibIfRequired();
310 WerrorS(
"numberOfConesOfDimension: unexpected parameters");
319 gfan::initializeCddlibIfRequired();
320 gfan::ZFan* zf = (gfan::ZFan*)u->
Data();
321 int d = zf->getAmbientDimension();
324 for (
int i=0;
i<=d;
i++)
325 n = n + zf->numberOfConesOfDimension(
i,0,0);
328 res->data = (
void*) (
long) n;
329 gfan::deinitializeCddlibIfRequired();
332 WerrorS(
"ncones: unexpected parameters");
341 gfan::initializeCddlibIfRequired();
342 gfan::ZFan* zf = (gfan::ZFan*)u->
Data();
345 for (
int d=0; d<=zf->getAmbientDimension(); d++)
346 n = n + zf->numberOfConesOfDimension(d,0,1);
349 res->data = (
void*) (
long) n;
350 gfan::deinitializeCddlibIfRequired();
353 WerrorS(
"nmaxcones: unexpected parameters");
359 bool b = (zf->getAmbientDimension() == zc->ambientDimension());
362 for (
int d=0; d<=zf->getAmbientDimension(); d++)
364 for (
int i=0;
i<zf->numberOfConesOfDimension(d,0,1);
i++)
366 gfan::ZCone zd = zf->getCone(d,
i,0,1);
367 gfan::ZCone zt = gfan::intersection(*zc,zd);
369 b =
b && zd.hasFace(zt);
384 gfan::initializeCddlibIfRequired();
385 gfan::ZFan* zf = (gfan::ZFan*)u->
Data();
386 gfan::ZCone* zc = (gfan::ZCone*)
v->Data();
389 res->data = (
void*) (
long)
b;
390 gfan::deinitializeCddlibIfRequired();
394 WerrorS(
"isCompatible: unexpected parameters");
406 gfan::initializeCddlibIfRequired();
407 gfan::ZFan* zf = (gfan::ZFan*)u->
Data();
408 gfan::ZCone* zc = (gfan::ZCone*)
v->Data();
420 WerrorS(
"insertCone: cone and fan not compatible");
421 gfan::deinitializeCddlibIfRequired();
430 gfan::deinitializeCddlibIfRequired();
434 WerrorS(
"insertCone: unexpected parameters");
440 gfan::ZVector zv=zc->getRelativeInteriorPoint();
441 for (
int d=0; d<=zf->getAmbientDimension(); d++)
443 for (
int i=0;
i<zf->numberOfConesOfDimension(d,0,1);
i++)
445 gfan::ZCone zd = zf->getCone(d,
i,0,1);
447 if (zd.containsRelatively(zv))
449 gfan::ZCone temp = *zc;
451 return (!(zd != temp));
466 gfan::initializeCddlibIfRequired();
467 gfan::ZFan* zf = (gfan::ZFan*)u->
Data();
468 gfan::ZCone* zc = (gfan::ZCone*)
v->Data();
469 if((zf->getAmbientDimension() == zc->ambientDimension()))
473 gfan::deinitializeCddlibIfRequired();
476 gfan::deinitializeCddlibIfRequired();
477 WerrorS(
"containsInCollection: mismatching ambient dimensions");
481 WerrorS(
"containsInCollection: unexpected parameters");
527 gfan::initializeCddlibIfRequired();
528 gfan::ZFan* zf = (gfan::ZFan*)u->
Data();
529 gfan::ZCone* zc = (gfan::ZCone*)
v->Data();
540 WerrorS(
"removeCone: cone not contained in fan");
541 gfan::deinitializeCddlibIfRequired();
550 gfan::deinitializeCddlibIfRequired();
554 WerrorS(
"removeCone: unexpected parameters");
569 gfan::initializeCddlibIfRequired();
570 gfan::ZFan* zf = (gfan::ZFan*) u->
Data();
571 int d = (int)(
long)
v->Data();
572 int i = (int)(
long)
w->Data();
578 o = (int)(
long)
x->Data();
582 m = (int)(
long)
y->Data();
587 if (((o == 0) || (o == 1)) && ((
m == 0) || (
m == 1)))
593 int ld = zf->getLinealityDimension();
599 gfan::ZCone zc = zf->getCone(d-ld,
i,oo,mm);
601 res->data = (
void*)
new gfan::ZCone(zc);
602 gfan::deinitializeCddlibIfRequired();
607 WerrorS(
"getCone: invalid dimension; no cones in this dimension");
608 gfan::deinitializeCddlibIfRequired();
614 WerrorS(
"getCone: invalid index");
615 gfan::deinitializeCddlibIfRequired();
621 WerrorS(
"getCone: invalid dimension");
622 gfan::deinitializeCddlibIfRequired();
628 WerrorS(
"getCone: invalid specifier for orbit or maximal");
629 gfan::deinitializeCddlibIfRequired();
635 WerrorS(
"getCone: unexpected parameters");
647 gfan::initializeCddlibIfRequired();
648 gfan::ZFan* zf = (gfan::ZFan*) u->
Data();
649 int d = (int)(
long)
v->Data();
655 o = (int)(
long)
w->Data();
659 m = (int)(
long)
x->Data();
664 if (((o == 0) || (o == 1)) && ((
m == 0) || (
m == 1)))
670 int ld = zf->getLinealityDimension();
674 int n = zf->numberOfConesOfDimension(d-ld,oo,mm);
676 for (
int i=0;
i<n;
i++)
678 gfan::ZCone zc = zf->getCone(d-ld,
i,oo,mm);
682 res->data = (
void*) L;
683 gfan::deinitializeCddlibIfRequired();
688 WerrorS(
"getCones: invalid dimension; no cones in this dimension");
689 gfan::deinitializeCddlibIfRequired();
695 WerrorS(
"getCones: invalid dimension");
696 gfan::deinitializeCddlibIfRequired();
702 WerrorS(
"getCones: invalid specifier for orbit or maximal");
703 gfan::deinitializeCddlibIfRequired();
708 WerrorS(
"getCones: unexpected parameters");
714 int i = zf->isSimplicial() ? 1 : 0;
723 gfan::initializeCddlibIfRequired();
724 gfan::ZFan* zf = (gfan::ZFan*) u->
Data();
725 int b = zf->isPure();
727 res->data = (
void*) (
long)
b;
728 gfan::deinitializeCddlibIfRequired();
731 WerrorS(
"isPure: unexpected parameters");
755 gfan::initializeCddlibIfRequired();
756 gfan::ZFan* zf = (gfan::ZFan*) u->
Data();
757 gfan::ZVector zv=zf->getFVector();
760 gfan::deinitializeCddlibIfRequired();
763 WerrorS(
"fVector: unexpected parameters");
767 gfan::ZMatrix
rays(
const gfan::ZFan*
const zf)
769 gfan::ZMatrix
rays(0,zf->getAmbientDimension());
770 for (
int i=0;
i<zf->numberOfConesOfDimension(1,0,0);
i++)
772 gfan::ZCone zc = zf->getCone(1,
i, 0, 0);
773 rays.append(zc.extremeRays());
781 int ambientDim = zf->getAmbientDimension();
782 for (
int i=0;
i<zf->numberOfConesOfDimension(ambientDim, 0, 0);
i++)
784 gfan::ZCone zc = zf->getCone(ambientDim,
i, 0, 0);
803 gfan::initializeCddlibIfRequired();
804 gfan::ZFan* zf = (gfan::ZFan*) u->
Data();
806 int ambientDim = zf->getAmbientDimension();
807 if (ambientDim != v0->
cols())
809 WerrorS(
"numberOfConesWithVector: mismatching dimensions");
810 gfan::deinitializeCddlibIfRequired();
818 gfan::deinitializeCddlibIfRequired();
822 WerrorS(
"numberOfConesWithVector: unexpected parameters");
831 gfan::initializeCddlibIfRequired();
833 std::istringstream
s(fanInString);
834 gfan::ZFan* zf =
new gfan::ZFan(
s);
836 res->data = (
void*) zf;
837 gfan::deinitializeCddlibIfRequired();
840 WerrorS(
"fanFromString: unexpected parameters");
852 gfan::initializeCddlibIfRequired();
855 WerrorS(
"fanViaCones: list contains entries of wrong type");
858 gfan::ZCone* zc = (gfan::ZCone*) L->
m[0].
Data();
859 gfan::ZFan* zf =
new gfan::ZFan(zc->ambientDimension());
865 WerrorS(
"fanViaCones: entries of wrong type in list");
866 gfan::deinitializeCddlibIfRequired();
869 gfan::ZCone* zc = (gfan::ZCone*) L->
m[
i].
Data();
870 if (zc->ambientDimension() != zf->getAmbientDimension())
872 WerrorS(
"fanViaCones: inconsistent ambient dimensions amongst cones in list");
873 gfan::deinitializeCddlibIfRequired();
879 res->data = (
void*) zf;
880 gfan::deinitializeCddlibIfRequired();
884 res->data = (
void*)
new gfan::ZFan(0);
889 gfan::initializeCddlibIfRequired();
890 gfan::ZCone* zc = (gfan::ZCone*) u->
Data();
891 gfan::ZFan* zf =
new gfan::ZFan(zc->ambientDimension());
898 WerrorS(
"fanViaCones: arguments of wrong type");
899 gfan::deinitializeCddlibIfRequired();
903 gfan::ZCone* zc = (gfan::ZCone*) u->
Data();
904 if (zc->ambientDimension() != zf->getAmbientDimension())
906 WerrorS(
"fanViaCones: inconsistent ambient dimensions amongst input cones");
907 gfan::deinitializeCddlibIfRequired();
914 res->data = (
void*) zf;
915 gfan::deinitializeCddlibIfRequired();
921 res->data = (
void*)
new gfan::ZFan(0);
924 WerrorS(
"fanViaCones: unexpected parameters");
980 assume(zf.getAmbientDimension() == zg.getAmbientDimension());
983 std::list<gfan::ZCone> maximalConesOfF;
984 for (
int d=0; d<=zf.getAmbientDimension(); d++)
985 for (
int i=0;
i<zf.numberOfConesOfDimension(d,0,1);
i++)
986 maximalConesOfF.push_back(zf.getCone(d,
i,0,1));
988 std::list<gfan::ZCone> maximalConesOfG;
989 for (
int d=0; d<=zg.getAmbientDimension(); d++)
990 for (
int i=0;
i<zg.numberOfConesOfDimension(d,0,1);
i++)
991 maximalConesOfG.push_back(zg.getCone(d,
i,0,1));
994 gfan::ZFan zr = gfan::ZFan(zf.getAmbientDimension());
995 for (std::list<gfan::ZCone>::iterator itf=maximalConesOfF.begin();
996 itf != maximalConesOfF.end(); itf++)
997 for (std::list<gfan::ZCone>::iterator itg=maximalConesOfG.begin();
998 itg != maximalConesOfG.end(); itg++)
999 zr.insert(intersection(*itf,*itg));
1012 gfan::initializeCddlibIfRequired();
1013 gfan::ZFan* zf = (gfan::ZFan*) u->
Data();
1014 gfan::ZFan* zg = (gfan::ZFan*)
v->Data();
1017 res->data = (
void*) zr;
1018 gfan::deinitializeCddlibIfRequired();
1022 WerrorS(
"commonRefinement: unexpected parameters");
1079 memset(&
l,0,
sizeof(
l));
1081 l.data=(
void*)
"fan";
1084 gfan::ZFan* zf = (gfan::ZFan*) d;
1087 fprintf(dd->
f_write,
"%d %s ",(
int)
s.size(),
s.c_str());
1104 gfan::ZFan* zf =
new gfan::ZFan(fanInString);
1114 blackbox *
b=(blackbox*)
omAlloc0(
sizeof(blackbox));
int status int void size_t count
static FORCE_INLINE number n_Sub(number a, number b, const coeffs r)
return the difference of 'a' and 'b', i.e., a-b
char * bbfan_String(blackbox *, void *d)
int s_readbytes(char *buff, int len, s_buff F)
const CanonicalForm int s
const CanonicalForm int const CFList const Variable & y
Class used for (list of) interpreter objects.
BOOLEAN numberOfConesOfDimension(leftv res, leftv args)
BOOLEAN nmaxcones(leftv res, leftv args)
bool isCompatible(const gfan::ZFan *zf, const gfan::ZCone *zc)
void * bbfan_Init(blackbox *)
BOOLEAN fullFan(leftv res, leftv args)
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
void bbfan_setup(SModulFunctions *p)
intvec * ivCopy(const intvec *o)
BOOLEAN bbfan_Assign(leftv l, leftv r)
BOOLEAN emptyFan(leftv res, leftv args)
void WerrorS(const char *s)
static BOOLEAN jjFANEMPTY_IM(leftv res, leftv v)
BOOLEAN fanViaCones(leftv res, leftv args)
bigintmat * zVectorToBigintmat(const gfan::ZVector &zv)
int getAmbientDimension(gfan::ZFan *zf)
void * bbfan_Copy(blackbox *, void *d)
BOOLEAN bbfan_deserialize(blackbox **b, void **d, si_link f)
Coefficient rings, fields and other domains suitable for Singular polynomials.
int isSimplicial(gfan::ZFan *zf)
BOOLEAN getCone(leftv res, leftv args)
BOOLEAN fanFromString(leftv res, leftv args)
gfan::ZMatrix rays(const gfan::ZFan *const zf)
BOOLEAN ncones(leftv res, leftv args)
gfan::ZMatrix * bigintmatToZMatrix(const bigintmat &bim)
int status int void * buf
int numberOfConesWithVector(gfan::ZFan *zf, gfan::ZVector *v)
BOOLEAN insertCone(leftv res, leftv args)
BOOLEAN fVector(leftv res, leftv args)
static BOOLEAN jjFANEMPTY_I(leftv res, leftv v)
bool containsInCollection(gfan::ZFan *zf, gfan::ZCone *zc)
int getCodimension(gfan::ZFan *zf)
BOOLEAN getCones(leftv res, leftv args)
INLINE_THIS void Init(int l=0)
const Variable & v
< [in] a sqrfree bivariate poly
BOOLEAN isPure(leftv res, leftv args)
static gfan::IntMatrix permutationIntMatrix(const bigintmat *iv)
gfan::ZFan commonRefinement(gfan::ZFan zf, gfan::ZFan zg)
int getLinealityDimension(gfan::ZFan *zf)
int getDimension(gfan::ZFan *zf)
BOOLEAN removeCone(leftv res, leftv args)
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
BOOLEAN bbfan_serialize(blackbox *b, void *d, si_link f)
static BOOLEAN jjFANFULL_IM(leftv res, leftv v)
int setBlackboxStuff(blackbox *bb, const char *n)
define a new type
#define IMATELEM(M, I, J)
void bbfan_destroy(blackbox *, void *d)
static BOOLEAN jjFANFULL_I(leftv res, leftv v)
void Werror(const char *fmt,...)
gfan::ZVector * bigintmatToZVector(const bigintmat &bim)