Loading...
Searching...
No Matches
gitfan.cc
Go to the documentation of this file.
/***************************************************************
*
* File: gitfan.cc
* Purpose: Computationally intensive procedures for gitfan.lib,
* outsourced to improve the performance.
* Authors: Janko Boehm boehm@mathematik.uni-kl.de
* Simon Keicher keicher@mail.mathematik.uni-tuebingen.de
* Yue Ren ren@mathematik.uni-kl.de
*
***************************************************************/
#include "kernel/mod2.h"
#if HAVE_GFANLIB
#include "Singular/dyn_modules/gfanlib/callgfanlib_conversion.h"
#include "Singular/dyn_modules/gfanlib/bbcone.h"
#include "Singular/dyn_modules/gfanlib/bbfan.h"
#include "Singular/mod_lib.h"
#include "gitfan.h"
namespace gitfan
{
facet::facet():
eta(gfan::ZCone()),
interiorPoint(gfan::ZVector()),
facetNormal(gfan::ZVector())
{
}
facet::facet(const gitfan::facet &f):
eta(f.eta),
interiorPoint(f.interiorPoint),
facetNormal(f.facetNormal)
{
#ifndef SING_NDEBUG
gfan::ZCone c = f.eta;
gfan::ZVector v = f.interiorPoint;
gfan::ZVector w = f.facetNormal;
assume(c.ambientDimension() == (int)v.size());
assume(c.ambientDimension() == (int)w.size());
assume(c.contains(v));
assume(!c.contains(w));
#endif
}
facet::facet(const gfan::ZCone &c, const gfan::ZVector &v, const gfan::ZVector &w):
eta(c),
interiorPoint(v),
facetNormal(w)
{
#ifndef SING_NDEBUG
assume(c.ambientDimension() == (int)v.size());
assume(c.ambientDimension() == (int)w.size());
assume(c.contains(v));
assume(!c.contains(w));
#endif
}
facet::~facet()
{
#ifndef SING_NDEBUG
gfan::ZCone c = this->eta;
gfan::ZVector v = this->interiorPoint;
gfan::ZVector w = this->facetNormal;
assume(c.ambientDimension() == (int)v.size());
assume(c.ambientDimension() == (int)w.size());
assume(c.contains(v));
assume(!c.contains(w));
#endif
}
void mergeFacets(facets &F, const facets &newFacets)
{
std::pair<facets::iterator,bool> check(newFacets.begin(),false);
for(facets::iterator p=newFacets.begin(); p!=newFacets.end(); p++)
{
check = F.insert(*p);
if(!check.second)
F.erase(check.first);
}
}
}
static gfan::ZCone subcone(const lists &cones, const gfan::ZVector &point)
{
gfan::ZCone sigma = gfan::ZCone(gfan::ZMatrix(1,point.size()), gfan::ZMatrix(1,point.size()));
gfan::ZCone* zc;
for (int i=0; i<=cones->nr; i++)
{
zc = (gfan::ZCone*) cones->m[i].Data();
if (zc->contains(point))
sigma = gfan::intersection(sigma,*zc);
}
return(sigma);
}
static gitfan::facets interiorFacets(const gfan::ZCone &zc, const gfan::ZCone &bound)
{
gfan::ZMatrix inequalities = zc.getFacets();
gfan::ZMatrix equations = zc.getImpliedEquations();
int r = inequalities.getHeight();
int c = inequalities.getWidth();
gitfan::facets F;
if (r*c == 0)
/***
* this is the trivial case where either we are in a zerodimensional ambient space,
* or the cone has no facets.
**/
return F;
// int index = 0;
/* next we iterate over each of the r facets, build the respective cone and add it to the list */
/* this is the i=0 case */
gfan::ZMatrix newInequalities = inequalities.submatrix(1,0,r,c);
gfan::ZMatrix newEquations = equations;
newEquations.appendRow(inequalities[0]);
gfan::ZCone eta = gfan::ZCone(newInequalities,newEquations);
eta.canonicalize();
gfan::ZVector v = eta.getRelativeInteriorPoint();
gfan::ZVector w = inequalities[0];
if (bound.containsRelatively(v))
F.insert(gitfan::facet(eta,v,w));
/* these are the cases i=1,...,r-2 */
for (int i=1; i<r-1; i++)
{
newInequalities = inequalities.submatrix(0,0,i,c);
newInequalities.append(inequalities.submatrix(i+1,0,r,c));
newEquations = equations;
newEquations.appendRow(inequalities[i]);
eta = gfan::ZCone(newInequalities,newEquations);
eta.canonicalize();
v = eta.getRelativeInteriorPoint();
w = inequalities[i];
if (bound.containsRelatively(v))
F.insert(gitfan::facet(eta,v,w));
}
/* this is the i=r-1 case */
newInequalities = inequalities.submatrix(0,0,r-1,c);
newEquations = equations;
newEquations.appendRow(inequalities[r-1]);
eta = gfan::ZCone(newInequalities,newEquations);
eta.canonicalize();
v = eta.getRelativeInteriorPoint();
w = inequalities[r-1];
if (bound.containsRelatively(v))
F.insert(gitfan::facet(eta,v,w));
return F;
}
BOOLEAN refineCones(leftv res, leftv args)
{
leftv u=args;
if ((u != NULL) && (u->Typ() == LIST_CMD))
{
leftv v=u->next;
if ((v != NULL) && (v->Typ() == BIGINTMAT_CMD))
{
lists cones = (lists) u->Data();
bigintmat* bim = (bigintmat*) v->Data();
gfan::ZMatrix* zm = bigintmatToZMatrix(bim->transpose());
gfan::ZCone support = gfan::ZCone::givenByRays(*zm, gfan::ZMatrix(0, zm->getWidth()));
delete zm;
/***
* Randomly compute a first full-dimensional cone and insert it into the fan.
* Compute a list of facets and relative interior points.
* The relative interior points are unique, assuming the cone is stored in canonical form,
* which is the case in our algorithm, as we supply no redundant inequalities.
* Hence we can decide whether a facet need to be traversed by crosschecking
* its relative interior point with this list.
**/
gfan::ZCone lambda; gfan::ZVector point;
do
{
point = randomPoint(&support);
lambda = subcone(cones, point);
}
while (lambda.dimension() < lambda.ambientDimension());
int iterationNumber = 1;
std::cout << "cones found: " << iterationNumber++ << std::endl;
lambda.canonicalize();
gfan::ZFan* Sigma = new gfan::ZFan(lambda.ambientDimension());
Sigma->insert(lambda);
gitfan::facets F = interiorFacets(lambda, support);
if (F.empty())
{
res->rtyp = fanID;
res->data = (void*) Sigma;
return FALSE;
}
int mu = 1024;
gitfan::facet f;
gfan::ZCone eta;
gfan::ZVector interiorPoint;
gfan::ZVector facetNormal;
gitfan::facets newFacets;
while (!F.empty())
{
/***
* Extract a facet to traverse and its relative interior point.
**/
f = *(F.begin());
eta = f.getEta();
interiorPoint = f.getInteriorPoint();
facetNormal = f.getFacetNormal();
/***
* construct a point, which lies on the other side of the facet.
* make sure it lies in the known support of our fan
* and that the cone around the point is maximal, containing eta.
**/
point = mu * interiorPoint - facetNormal;
while (!support.containsRelatively(point))
{
mu = mu * 16;
point = mu * interiorPoint - facetNormal;
}
lambda = subcone(cones,point);
while ((lambda.dimension() < lambda.ambientDimension()) && !(lambda.contains(interiorPoint)))
{
mu = mu * 16;
point = mu * interiorPoint - facetNormal;
lambda = subcone(cones,point);
}
std::cout << "cones found: " << iterationNumber++ << std::endl;
/***
* insert lambda into Sigma, and create a list of facets of lambda.
* merge the two lists of facets
**/
lambda.canonicalize();
Sigma->insert(lambda);
newFacets = interiorFacets(lambda, support);
mergeFacets(F,newFacets);
newFacets.clear();
}
res->rtyp = fanID;
res->data = (void*) Sigma;
return FALSE;
}
}
WerrorS("refineCones: unexpected parameters");
return TRUE;
}
static int binomial(int n, int k)
{
if (n<k)
return(0);
gfan::Integer num = 1;
gfan::Integer den = 1;
for (int i=1; i<=k; i++)
den = den*i;
for (int j=n-k+1; j<=n; j++)
num = num*j;
gfan::Integer bin = num/den;
return(bin.toInt());
}
intvec* intToAface(unsigned int v0, int n, int k)
{
intvec* v = new intvec(k);
int j = 0;
for (int i=0; i<n; i++)
{
if (v0 & (1<<i))
(*v)[j++] = i+1;
}
return v;
}
BOOLEAN listOfAfacesToCheck(leftv res, leftv args)
{
leftv u = args;
if ((u != NULL) && (u->Typ() == INT_CMD))
{
leftv v = u->next;
if ((v != NULL) && (v->Typ() == INT_CMD))
{
int n = (int)(long) u->Data();
int k = (int)(long) v->Data();
unsigned int v = 0;
for (int i=0; i<k; i++)
v |= 1<<i; // sets the first k bits of v as 1
lists L = (lists)omAllocBin(slists_bin);
int count = (int) binomial(n,k); L->Init(count);
unsigned int t;
while (!(v & (1<<n)))
{
L->m[--count].rtyp = INTVEC_CMD;
L->m[count].data = (void*) intToAface(v,n,k);
// t gets v's least significant 0 bits set to 1
t = v | (v - 1);
// Next set to 1 the most significant bit to change,
// set to 0 the least significant ones, and add the necessary 1 bits.
v = (t + 1) | (((~t & -~t) - 1) >> (__builtin_ctz(v) + 1));
}
res->rtyp = LIST_CMD;
res->data = (void*) L;
return FALSE;
}
}
WerrorS("listOfAfacesToCheck: unexpected parameter");
return TRUE;
}
BOOLEAN nextAfaceToCheck(leftv res, leftv args)
{
leftv u = args;
if ((u != NULL) && (u->Typ() == INTVEC_CMD))
{
leftv v = u->next;
if ((v != NULL) && (v->Typ() == INT_CMD))
{
leftv w = v->next;
if ((w != NULL) && (w->Typ() == INT_CMD))
{
intvec* aface = (intvec*) u->Data();
int ambientDimension = (int)(long) v->Data();
int dimension = (int)(long) w->Data();
unsigned int af = 0;
for (int i=0; i<aface->length(); i++)
af |= 1<<((*aface)[i]-1);
unsigned int t = af | (af - 1);
af = (t + 1) | (((~t & -~t) - 1) >> (__builtin_ctz(af) + 1));
if (af & (1<<ambientDimension))
{
res->rtyp = INTVEC_CMD;
res->data = (void*) new intvec(1);
return FALSE;
}
res->rtyp = INTVEC_CMD;
res->data = (void*) intToAface(af,ambientDimension,dimension);
return FALSE;
}
}
}
WerrorS("nextAfaceToCheck: unexpected parameter");
return TRUE;
}
BOOLEAN checkSigns(leftv res, leftv args)
{
leftv u = args;
if ((u != NULL) && (u->Typ()==BIGINTMAT_CMD || u->Typ()==INTMAT_CMD))
{
leftv v = u->next;
if ((v != NULL) && (v->Typ() == INTVEC_CMD) && (v->next == NULL))
{
bigintmat* interiorPoint = NULL;
if (u->Typ() == INTMAT_CMD)
{
intvec* p0 = (intvec*) u->Data();
interiorPoint = iv2bim(p0,coeffs_BIGINT);
}
else
interiorPoint = (bigintmat*) u->Data();
intvec* hash = (intvec*) v->Data();
res->rtyp = INT_CMD;
for (int i=0; i<hash->length(); i++)
{
if ( (*hash)[i]<0 && n_GreaterZero((*interiorPoint)[i],interiorPoint->basecoeffs()) )
{
res->data = (void*) (long) 0;
return FALSE;
}
if ( (*hash)[i]>0 && !n_IsZero((*interiorPoint)[i],interiorPoint->basecoeffs()) )
{
number neg = n_Copy((*interiorPoint)[i],interiorPoint->basecoeffs());
neg = n_InpNeg(neg,interiorPoint->basecoeffs());
if (n_GreaterZero(neg,interiorPoint->basecoeffs()))
{
n_Delete(&neg,interiorPoint->basecoeffs());
res->data = (void*) (long) 0;
return FALSE;
}
n_Delete(&neg,interiorPoint->basecoeffs());
}
}
res->data = (void*) (long) 1;
if (v->Typ() == INTMAT_CMD)
delete interiorPoint;
return FALSE;
}
}
WerrorS("checkSigns: unexpected parameter");
return TRUE;
}
BOOLEAN binaryToBigint(leftv res, leftv args)
{
leftv u = args;
if ((u != NULL) && (u->Typ() == INTVEC_CMD) && (u->next == NULL))
{
intvec* iv = (intvec*) u->Data();
const int l = (iv->rows())*(iv->cols());
number base = n_Init(2,coeffs_BIGINT);
number endResult;
n_Power(base,(*iv)[0]-1,&endResult,coeffs_BIGINT);
for (int i=1; i<l; i++)
{
number endResultCache;
number currentBit;
n_Power(base,(*iv)[i]-1,&currentBit,coeffs_BIGINT);
endResultCache = n_Add(endResult,currentBit,coeffs_BIGINT);
n_Delete(&endResult,coeffs_BIGINT);
n_Delete(&currentBit,coeffs_BIGINT);
endResult = endResultCache;
endResultCache = NULL;
}
n_Delete(&base,coeffs_BIGINT);
res->rtyp = BIGINT_CMD;
res->data = (void*) endResult;
return FALSE;
}
WerrorS("binaryToBigint: unexpected parameter");
return TRUE;
}
BOOLEAN composeIntvecs(leftv res, leftv args)
{
leftv u = args;
if ((u!=NULL) && (u->Typ()==INTVEC_CMD))
{
leftv v = u->next;
if ((v!=NULL) && (v->Typ()==INTVEC_CMD) && (v->next==NULL))
{
intvec* iv1 = (intvec*) u->Data();
intvec* iv2 = (intvec*) v->Data();
int k = iv2->length();
intvec* composedIntvec = new intvec(k);
for (int i=0; i<k; i++)
(*composedIntvec)[i] = (*iv1)[(*iv2)[i]-1];
res->rtyp = INTVEC_CMD;
res->data = (void*) composedIntvec;
return FALSE;
}
}
WerrorS("composeIntvecs: unexpected parameter");
return TRUE;
}
BOOLEAN findPlaceToInsert(leftv res, leftv args)
{
leftv u = args;
if ((u!=NULL) && (u->Typ()==LIST_CMD))
{
leftv v = u->next;
if ((v!=NULL) && (v->Typ()==BIGINT_CMD) && (v->next==NULL))
{
lists listOfNumbers = (lists) u->Data();
number numberToInsert = (number) v->Data();
int lowerBound = 0;
int upperBound = lSize(listOfNumbers);
if (upperBound<0)
{
res->rtyp = INT_CMD;
res->data = (void*) (long) (lowerBound+1);
return FALSE;
}
number lowerNumber = (number) listOfNumbers->m[lowerBound].Data();
if (n_Equal(lowerNumber,numberToInsert,coeffs_BIGINT))
{
res->rtyp = INT_CMD;
res->data = (void*) (long) (-1);
return FALSE;
}
if (n_Greater(lowerNumber,numberToInsert,coeffs_BIGINT))
{
res->rtyp = INT_CMD;
res->data = (void*) (long) (lowerBound+1);
return FALSE;
}
number upperNumber = (number) listOfNumbers->m[upperBound].Data();
if (n_Equal(numberToInsert,upperNumber,coeffs_BIGINT))
{
res->rtyp = INT_CMD;
res->data = (void*) (long) (-1);
return FALSE;
}
if (n_Greater(numberToInsert,upperNumber,coeffs_BIGINT))
{
res->rtyp = INT_CMD;
res->data = (void*) (long) (upperBound+2);
return FALSE;
}
while (lowerBound+1<upperBound)
{
int middle = lowerBound + (upperBound-lowerBound) / 2;
number lowerNumber = (number) listOfNumbers->m[lowerBound].Data();
number upperNumber = (number) listOfNumbers->m[upperBound].Data();
number middleNumber = (number) listOfNumbers->m[middle].Data();
if ((n_Equal(lowerNumber,numberToInsert,coeffs_BIGINT)) ||
(n_Equal(middleNumber,numberToInsert,coeffs_BIGINT)) ||
(n_Equal(upperNumber,numberToInsert,coeffs_BIGINT)))
{
res->rtyp = INT_CMD;
res->data = (void*) (long) -1;
return FALSE;
}
if (n_Greater(numberToInsert,middleNumber,coeffs_BIGINT))
lowerBound = middle;
if (n_Greater(middleNumber,numberToInsert,coeffs_BIGINT))
upperBound = middle;
}
res->rtyp = INT_CMD;
res->data = (void*) (long) (upperBound+1);
return FALSE;
}
}
WerrorS("findPlaceToInsert: unexpected parameter");
return TRUE;
}
extern "C" int SI_MOD_INIT(gitfan) (SModulFunctions* p)
{
gfan::initializeCddlibIfRequired();
p->iiAddCproc("gitfan.lib","refineCones",FALSE,refineCones);
p->iiAddCproc("gitfan.lib","listOfAfacesToCheck",FALSE,listOfAfacesToCheck);
p->iiAddCproc("gitfan.lib","nextAfaceToCheck",FALSE,nextAfaceToCheck);
p->iiAddCproc("gitfan.lib","checkSigns",FALSE,checkSigns);
p->iiAddCproc("gitfan.lib","binaryToBigint",FALSE,binaryToBigint);
p->iiAddCproc("gitfan.lib","composeIntvecs",FALSE,composeIntvecs);
p->iiAddCproc("gitfan.lib","findPlaceToInsert",FALSE,findPlaceToInsert);
return (MAX_TOK);
}
#endif
BOOLEAN
int BOOLEAN
Definition auxiliary.h:88
TRUE
#define TRUE
Definition auxiliary.h:101
FALSE
#define FALSE
Definition auxiliary.h:97
ambientDimension
BOOLEAN ambientDimension(leftv res, leftv args)
Definition bbcone.cc:723
equations
BOOLEAN equations(leftv res, leftv args)
Definition bbcone.cc:577
dimension
BOOLEAN dimension(leftv res, leftv args)
Definition bbcone.cc:757
randomPoint
gfan::ZVector randomPoint(const gfan::ZCone *zc, const int b)
Definition bbcone.cc:1069
inequalities
BOOLEAN inequalities(leftv res, leftv args)
Definition bbcone.cc:560
bbcone.h
fanID
VAR int fanID
Definition bbfan.cc:19
bbfan.h
iv2bim
bigintmat * iv2bim(intvec *b, const coeffs C)
Definition bigintmat.cc:347
bigintmatToZMatrix
gfan::ZMatrix * bigintmatToZMatrix(const bigintmat &bim)
Definition callgfanlib_conversion.cc:57
callgfanlib_conversion.h
num
CanonicalForm num(const CanonicalForm &f)
Definition canonicalform.h:337
den
CanonicalForm den(const CanonicalForm &f)
Definition canonicalform.h:340
l
int l
Definition cfEzgcd.cc:100
i
int i
Definition cfEzgcd.cc:132
k
int k
Definition cfEzgcd.cc:99
p
int p
Definition cfModGcd.cc:4086
lambda
void lambda(int **points, int sizePoints)
Definition cfNewtonPolygon.cc:449
bound
static CanonicalForm bound(const CFMatrix &M)
Definition cf_linsys.cc:460
f
FILE * f
Definition checklibs.c:9
bigintmat
Matrices of numbers.
Definition bigintmat.h:51
bigintmat::transpose
bigintmat * transpose()
Definition bigintmat.cc:35
bigintmat::basecoeffs
coeffs basecoeffs() const
Definition bigintmat.h:146
gitfan::facet
Definition gitfan.h:18
gitfan::facet::facet
facet()
Definition gitfan.cc:28
gitfan::facet::eta
gfan::ZCone eta
Definition gitfan.h:19
gitfan::facet::facetNormal
gfan::ZVector facetNormal
Definition gitfan.h:21
gitfan::facet::~facet
~facet()
Definition gitfan.cc:64
gitfan::facet::interiorPoint
gfan::ZVector interiorPoint
Definition gitfan.h:20
intvec
Definition intvec.h:24
intvec::length
int length() const
Definition intvec.h:95
intvec::cols
int cols() const
Definition intvec.h:96
intvec::rows
int rows() const
Definition intvec.h:97
sleftv::Typ
int Typ()
Definition subexpr.cc:1048
sleftv::rtyp
int rtyp
Definition subexpr.h:91
sleftv::Data
void * Data()
Definition subexpr.cc:1192
sleftv::next
leftv next
Definition subexpr.h:86
sleftv::data
void * data
Definition subexpr.h:88
slists::m
sleftv * m
Definition lists.h:46
slists::Init
INLINE_THIS void Init(int l=0)
slists::nr
int nr
Definition lists.h:44
n_Copy
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of 'n'
Definition coeffs.h:457
n_Add
static FORCE_INLINE number n_Add(number a, number b, const coeffs r)
return the sum of 'a' and 'b', i.e., a+b
Definition coeffs.h:653
n_GreaterZero
static FORCE_INLINE BOOLEAN n_GreaterZero(number n, const coeffs r)
ordered fields: TRUE iff 'n' is positive; in Z/pZ: TRUE iff 0 < m <= roundedBelow(p/2),...
Definition coeffs.h:500
n_InpNeg
static FORCE_INLINE number n_InpNeg(number n, const coeffs r)
in-place negation of n MUST BE USED: n = n_InpNeg(n) (no copy is returned)
Definition coeffs.h:560
n_Power
static FORCE_INLINE void n_Power(number a, int b, number *res, const coeffs r)
fill res with the power a^b
Definition coeffs.h:635
n_Greater
static FORCE_INLINE BOOLEAN n_Greater(number a, number b, const coeffs r)
ordered fields: TRUE iff 'a' is larger than 'b'; in Z/pZ: TRUE iff la > lb, where la and lb are the l...
Definition coeffs.h:517
n_IsZero
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff 'n' represents the zero element.
Definition coeffs.h:470
n_Delete
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
Definition coeffs.h:461
n_Init
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:541
n_Equal
static FORCE_INLINE BOOLEAN n_Equal(number a, number b, const coeffs r)
TRUE iff 'a' and 'b' represent the same number; they may have different representations.
Definition coeffs.h:466
support
static BOOLEAN support(leftv res, leftv args)
Definition cohomo.cc:4381
res
CanonicalForm res
Definition facAbsFact.cc:60
w
const CanonicalForm & w
Definition facAbsFact.cc:51
v
const Variable & v
< [in] a sqrfree bivariate poly
Definition facBivar.h:39
j
int j
Definition facHensel.cc:110
WerrorS
void WerrorS(const char *s)
Definition feFopen.cc:24
binomial
static int binomial(int n, int k)
Definition gitfan.cc:262
interiorFacets
static gitfan::facets interiorFacets(const gfan::ZCone &zc, const gfan::ZCone &bound)
Definition gitfan.cc:104
intToAface
intvec * intToAface(unsigned int v0, int n, int k)
Definition gitfan.cc:277
listOfAfacesToCheck
BOOLEAN listOfAfacesToCheck(leftv res, leftv args)
Definition gitfan.cc:290
findPlaceToInsert
BOOLEAN findPlaceToInsert(leftv res, leftv args)
Definition gitfan.cc:472
checkSigns
BOOLEAN checkSigns(leftv res, leftv args)
Definition gitfan.cc:368
refineCones
BOOLEAN refineCones(leftv res, leftv args)
Definition gitfan.cc:162
binaryToBigint
BOOLEAN binaryToBigint(leftv res, leftv args)
Definition gitfan.cc:417
subcone
static gfan::ZCone subcone(const lists &cones, const gfan::ZVector &point)
Definition gitfan.cc:91
nextAfaceToCheck
BOOLEAN nextAfaceToCheck(leftv res, leftv args)
Definition gitfan.cc:328
composeIntvecs
BOOLEAN composeIntvecs(leftv res, leftv args)
Definition gitfan.cc:448
gitfan.h
BIGINTMAT_CMD
@ BIGINTMAT_CMD
Definition grammar.cc:278
INTMAT_CMD
@ INTMAT_CMD
Definition grammar.cc:280
SModulFunctions
Definition ipid.h:69
check
VAR int check
Definition libparse.cc:1106
slists_bin
VAR omBin slists_bin
Definition lists.cc:23
lSize
int lSize(lists L)
Definition lists.cc:25
mu
static matrix mu(matrix A, const ring R)
Definition matpol.cc:2028
mod2.h
assume
#define assume(x)
Definition mod2.h:389
mod_lib.h
lists
slists * lists
Definition mpr_numeric.h:146
gitfan
Definition gitfan.cc:26
gitfan::mergeFacets
void mergeFacets(facets &F, const facets &newFacets)
Definition gitfan.cc:77
gitfan::facets
std::set< facet, facet_compare > facets
Definition gitfan.h:50
omAllocBin
#define omAllocBin(bin)
Definition omAllocDecl.h:205
NULL
#define NULL
Definition omList.c:12
coeffs_BIGINT
VAR coeffs coeffs_BIGINT
Definition polys.cc:14
count
int status int void size_t count
Definition si_signals.h:69
leftv
sleftv * leftv
Definition structs.h:53
BIGINT_CMD
@ BIGINT_CMD
Definition tok.h:38
LIST_CMD
@ LIST_CMD
Definition tok.h:118
INTVEC_CMD
@ INTVEC_CMD
Definition tok.h:101
INT_CMD
@ INT_CMD
Definition tok.h:96
MAX_TOK
@ MAX_TOK
Definition tok.h:220