/** Removes equalities involving only parameters, but starting from a
* Polyhedron and its context.
* @param P the polyhedron
* @param C P's context
* @param renderSpace: 0 for the parameter space, =1 for the combined space.
* @maxRays Polylib's usual <i>workspace</i>.
*/
Polyhedron * Polyhedron_Remove_parm_eqs(Polyhedron ** P, Polyhedron ** C,
int renderSpace,
unsigned int ** elimParms,
int maxRays) {
Matrix * Eqs;
Polyhedron * Peqs;
Matrix * M = Polyhedron2Constraints((*P));
Matrix * Ct = Polyhedron2Constraints((*C));
/* if the Minkowski representation is not computed yet, do not compute it in
Constraints2Polyhedron */
if (F_ISSET((*P), POL_VALID | POL_INEQUALITIES) &&
(F_ISSET((*C), POL_VALID | POL_INEQUALITIES))) {
FL_INIT(maxRays, POL_NO_DUAL);
}
Eqs = Constraints_Remove_parm_eqs(&M, &Ct, renderSpace, elimParms);
Peqs = Constraints2Polyhedron(Eqs, maxRays);
Matrix_Free(Eqs);
/* particular case: no equality involving only parms is found */
if (Eqs->NbRows==0) {
Matrix_Free(M);
Matrix_Free(Ct);
return Peqs;
}
Polyhedron_Free(*P);
Polyhedron_Free(*C);
(*P) = Constraints2Polyhedron(M, maxRays);
(*C) = Constraints2Polyhedron(Ct, maxRays);
Matrix_Free(M);
Matrix_Free(Ct);
return Peqs;
} /* Polyhedron_Remove_parm_eqs */
/** extracts the equalities holding on the parameters only, try to introduce
them back and compare the two polyhedra.
Reads a polyhedron and a context.
*/
int test_Polyhedron_Remove_parm_eqs(Matrix * A, Matrix * B) {
int isOk = 1;
Matrix * M, *C;
Polyhedron *Pm, *Pc, *Pcp, *Peqs, *Pint, *Pint1;
unsigned int * elimParms;
printf("----- test_Polyhedron_Remove_parm_eqs() -----\n");
M = Matrix_Copy(A);
C = Matrix_Copy(B);
/* compute the combined polyhedron */
Pm = Constraints2Polyhedron(M, maxRays);
Pc = Constraints2Polyhedron(C, maxRays);
Pcp = align_context(Pc, Pm->Dimension, maxRays);
Polyhedron_Free(Pc);
Pint1 = DomainIntersection(Pm, Pcp, maxRays);
Polyhedron_Free(Pm);
Polyhedron_Free(Pcp);
Matrix_Free(M);
Matrix_Free(C);
M = Matrix_Copy(A);
C = Matrix_Copy(B);
/* extract the parm-equalities, expressed in the combined space */
Pm = Constraints2Polyhedron(M, maxRays);
Pc = Constraints2Polyhedron(C, maxRays);
Matrix_Free(M);
Matrix_Free(C);
Peqs = Polyhedron_Remove_parm_eqs(&Pm, &Pc, 1, &elimParms, 200);
/* compute the supposedly-same polyhedron, using the extracted equalities */
Pcp = align_context(Pc, Pm->Dimension, maxRays);
Polyhedron_Free(Pc);
Pc = DomainIntersection(Pm, Pcp, maxRays);
Polyhedron_Free(Pm);
Polyhedron_Free(Pcp);
Pint = DomainIntersection(Pc, Peqs, maxRays);
Polyhedron_Free(Pc);
Polyhedron_Free(Peqs);
/* test their equality */
if (!PolyhedronIncludes(Pint, Pint1)) {
isOk = 0;
}
else {
if (!PolyhedronIncludes(Pint1, Pint)) {
isOk = 0;
}
}
Polyhedron_Free(Pint1);
Polyhedron_Free(Pint);
return isOk;
} /* test_Polyhedron_remove_parm_eqs() */
/* Returns the sign of the affine function specified by T on the polyhedron D */
enum order_sign PL_polyhedron_affine_sign(Polyhedron *D, Matrix *T,
struct barvinok_options *options)
{
enum order_sign sign;
Polyhedron *I = Polyhedron_Image(D, T, options->MaxRays);
if (POL_ISSET(options->MaxRays, POL_INTEGER))
I = DomainConstraintSimplify(I, options->MaxRays);
if (emptyQ2(I)) {
Polyhedron_Free(I);
I = Polyhedron_Image(D, T, options->MaxRays);
}
sign = interval_minmax(I);
Polyhedron_Free(I);
return sign;
}
int main(int argc, char **argv)
{
Matrix *M;
Polyhedron *C;
struct barvinok_options *options = barvinok_options_new_with_defaults();
argc = barvinok_options_parse(options, argc, argv, ISL_ARG_ALL);
M = Matrix_Read();
C = Constraints2Polyhedron(M, options->MaxRays);
Matrix_Free(M);
M = Cone_Integer_Hull(C, NULL, 0, options);
Polyhedron_Free(C);
Matrix_Print(stdout, P_VALUE_FMT, M);
Matrix_Free(M);
if (options->print_stats)
barvinok_stats_print(options->stats, stdout);
barvinok_options_free(options);
return 0;
}
/*
* Image: if cst is a list of constraints, just its first element's image
* is taken.
*/
PlutoConstraints *pluto_constraints_image(const PlutoConstraints *cst, const PlutoMatrix *func)
{
// IF_DEBUG(printf("pluto const image: domain\n"););
// IF_DEBUG(pluto_constraints_print(stdout, cst););
// IF_DEBUG(printf("pluto const image: func\n"););
// IF_DEBUG(pluto_matrix_print(stdout, func););
assert(func->ncols == cst->ncols);
PlutoConstraints *imagecst;
Polyhedron *pol = pluto_constraints_to_polylib(cst);
Matrix *polymat = pluto_matrix_to_polylib(func);
// Polyhedron_Print(stdout, "%4d", pol);
Polyhedron *image = Polyhedron_Image(pol, polymat, 2*cst->nrows);
// Polyhedron_Print(stdout, "%4d ", image);
imagecst = polylib_to_pluto_constraints(image);
Matrix_Free(polymat);
Domain_Free(pol);
Polyhedron_Free(image);
// IF_DEBUG(printf("pluto const image is\n"););
// IF_DEBUG(pluto_constraints_print(stdout, imagecst););
return imagecst;
}
static isl_stat add_vertex(__isl_take isl_vertex *vertex, void *user)
{
Param_Vertices ***next_V = (Param_Vertices ***) user;
Param_Vertices *V;
Polyhedron *D;
isl_basic_set *dom;
isl_multi_aff *expr;
isl_ctx *ctx;
ctx = isl_vertex_get_ctx(vertex);
dom = isl_vertex_get_domain(vertex);
D = isl_basic_set_to_polylib(dom);
isl_basic_set_free(dom);
expr = isl_vertex_get_expr(vertex);
V = isl_alloc_type(ctx, Param_Vertices);
V->Vertex = isl_multi_aff_to_polylib(expr);
V->Domain = Polyhedron2Constraints(D);
V->Facets = NULL;
V->next = NULL;
Polyhedron_Free(D);
isl_multi_aff_free(expr);
**next_V = V;
*next_V = &V->next;
isl_vertex_free(vertex);
return isl_stat_ok;
}
enum lp_result PL_constraints_opt(Matrix *C, Value *obj, Value denom,
enum lp_dir dir, Value *opt,
unsigned MaxRays)
{
enum lp_result res;
Polyhedron *P = Constraints2Polyhedron(C, MaxRays);
res = PL_polyhedron_opt(P, obj, denom, dir, opt);
Polyhedron_Free(P);
return res;
}
int main(int argc, char **argv)
{
int nchamber;
unsigned nparam;
Matrix *A;
Polyhedron *P, *C;
Param_Polyhedron *PP;
Param_Domain *PD;
struct barvinok_options *options = barvinok_options_new_with_defaults();
argc = barvinok_options_parse(options, argc, argv, ISL_ARG_ALL);
A = Matrix_Read();
assert(A);
nparam = A->NbRows;
C = Universe_Polyhedron(nparam);
P = partition2polyhedron(A, options);
Matrix_Free(A);
PP = Polyhedron2Param_Polyhedron(P, C, options);
Polyhedron_Free(P);
Polyhedron_Free(C);
nchamber = 0;
for (PD = PP->D; PD; PD = PD->next)
nchamber++;
printf("%d\n", nchamber);
for (PD = PP->D; PD; PD = PD->next) {
printf("\n");
Polyhedron_PrintConstraints(stdout, P_VALUE_FMT, PD->Domain);
}
Param_Polyhedron_Free(PP);
barvinok_options_free(options);
return 0;
}
void count_new(Value* cb, int lanes[NLANES][L],int filaments,int noconsts){
//clock_t t1 = clock();
Polyhedron *A;
int i,j;
Matrix *M;
//printf("inside count we have the following lanes for %d filaments and %d noconsts:\n",filaments,noconsts);
//dump_lanes(lanes);
M=Matrix_Alloc(noconsts,filaments+2);
//lock_t t2 = clock();
int** constraints;
constraints= malloc(noconsts*sizeof(int *));
//clock_t t3 = clock();
//printf("%lu\n",(filaments+2)*(noconsts));
for (i=0;i<noconsts;i++){
constraints[i]=(int*)malloc(sizeof(int)*(filaments+2));
for(j=0;j<filaments+2;j++){
constraints[i][j]=0;
//printf("%d %d %d\n",i,j,constraints[i][j]);
}
}
//clock_t t4 = clock();
//printf("from count: fils %d noconsts %d\n",filaments,noconsts);
gen_constraints(constraints,lanes,filaments,noconsts);
//clock_t t5 = clock();
struct barvinok_options *options = barvinok_options_new_with_defaults();
Matrix_Init(M,constraints);
//clock_t t6 = clock();
A=Constraints2Polyhedron(M,options->MaxRays);
//clock_t t7 = clock();
barvinok_count_with_options(A, cb, options);
//clock_t t8 = clock();
//printf("timings at count: t2=%f, t3=%f, t4=%f, t5=%f, t6=%f, t7=%f, t8=%f\n",(double)(t2-t1)/CLOCKS_PER_SEC,(double)(t3-t1)/CLOCKS_PER_SEC,(double)(t4-t1)/CLOCKS_PER_SEC,(double)(t5-t1)/CLOCKS_PER_SEC,(double)(t6-t1)/CLOCKS_PER_SEC,(double)(t7-t1)/CLOCKS_PER_SEC,(double)(t8-t1)/CLOCKS_PER_SEC);
Polyhedron_Free(A);
barvinok_options_free(options);
Matrix_Free(M);
for (i=0;i<noconsts;i++){
free(constraints[i]);
}
free(constraints);
}
/* Assumes C is a linear cone (i.e. with apex zero).
* All equalities are removed first to speed up the computation
* in zsolve.
*/
Matrix *Cone_Hilbert_Basis(Polyhedron *C, unsigned MaxRays)
{
unsigned dim;
int i;
Matrix *M2, *M3, *T;
Matrix *CV = NULL;
LinearSystem initialsystem;
ZSolveMatrix matrix;
ZSolveVector rhs;
ZSolveContext ctx;
remove_all_equalities(&C, NULL, NULL, &CV, 0, MaxRays);
dim = C->Dimension;
for (i = 0; i < C->NbConstraints; ++i)
assert(value_zero_p(C->Constraint[i][1+dim]) ||
First_Non_Zero(C->Constraint[i]+1, dim) == -1);
M2 = Polyhedron2standard_form(C, &T);
matrix = Matrix2zsolve(M2);
Matrix_Free(M2);
rhs = createVector(matrix->Height);
for (i = 0; i < matrix->Height; i++)
rhs[i] = 0;
initialsystem = createLinearSystem();
setLinearSystemMatrix(initialsystem, matrix);
deleteMatrix(matrix);
setLinearSystemRHS(initialsystem, rhs);
deleteVector(rhs);
setLinearSystemLimit(initialsystem, -1, 0, MAXINT, 0);
setLinearSystemEquationType(initialsystem, -1, EQUATION_EQUAL, 0);
ctx = createZSolveContextFromSystem(initialsystem, NULL, 0, 0, NULL, NULL);
zsolveSystem(ctx, 0);
M2 = VectorArray2Matrix(ctx->Homs, C->Dimension);
deleteZSolveContext(ctx, 1);
Matrix_Transposition(T);
M3 = Matrix_Alloc(M2->NbRows, M2->NbColumns);
Matrix_Product(M2, T, M3);
Matrix_Free(M2);
Matrix_Free(T);
if (CV) {
Matrix *T, *M;
T = Transpose(CV);
M = Matrix_Alloc(M3->NbRows, T->NbColumns);
Matrix_Product(M3, T, M);
Matrix_Free(M3);
Matrix_Free(CV);
Matrix_Free(T);
Polyhedron_Free(C);
M3 = M;
}
return M3;
}
/*
* Return the Z-polyhderon 'Zpol' in canonical form: 'Result' (for the Z-poly-
* hedron in canonical form) and Basis 'Basis' (for the basis with respect to
* which 'Result' is in canonical form.
*/
void CanonicalForm(ZPolyhedron *Zpol,ZPolyhedron **Result,Matrix **Basis) {
Matrix *B1 = NULL, *B2=NULL, *T1 , *B2inv;
int i, l1, l2;
Value tmp;
Polyhedron *Image, *ImageP;
Matrix *H, *U, *temp, *Hprime, *Uprime, *T2;
#ifdef DOMDEBUG
FILE *fp;
fp = fopen("_debug", "a");
fprintf(fp,"\nEntered CANONICALFORM\n");
fclose(fp);
#endif
if(isEmptyZPolyhedron (Zpol)) {
Basis[0] = Identity(Zpol->Lat->NbRows);
Result[0] = ZDomain_Copy (Zpol);
return ;
}
value_init(tmp);
l1 = FindHermiteBasisofDomain(Zpol->P,&B1);
Image = DomainImage (Zpol->P,(Matrix *)Zpol->Lat,MAXNOOFRAYS);
l2 = FindHermiteBasisofDomain(Image,&B2);
if (l1 != l2)
fprintf(stderr,"In CNF : Something wrong with the Input Zpolyhedra \n");
B2inv = Matrix_Alloc(B2->NbRows, B2->NbColumns);
temp = Matrix_Copy(B2);
Matrix_Inverse(temp,B2inv);
Matrix_Free(temp);
temp = Matrix_Alloc(B2inv->NbRows,Zpol->Lat->NbColumns);
T1 = Matrix_Alloc(temp->NbRows,B1->NbColumns);
Matrix_Product(B2inv,(Matrix *)Zpol->Lat,temp);
Matrix_Product(temp,B1,T1);
Matrix_Free(temp);
T2 = ChangeLatticeDimension(T1,l1);
temp = ChangeLatticeDimension(T2,T2->NbRows+1);
/* Adding the affine part */
for(i = 0; i < l1; i ++)
value_assign(temp->p[i][temp->NbColumns-1],T1->p[i][T1->NbColumns-1]);
AffineHermite(temp,&H,&U);
Hprime = ChangeLatticeDimension(H,Zpol->Lat->NbRows);
/* Exchanging the Affine part */
for(i = 0; i < l1; i ++) {
value_assign(tmp,Hprime->p[i][Hprime->NbColumns-1]);
value_assign(Hprime->p[i][Hprime->NbColumns-1],Hprime->p[i][H->NbColumns-1]);
value_assign(Hprime->p[i][H->NbColumns-1],tmp);
}
Uprime = ChangeLatticeDimension(U,Zpol->Lat->NbRows);
/* Exchanging the Affine part */
for (i = 0;i < l1; i++) {
value_assign(tmp,Uprime->p[i][Uprime->NbColumns-1]);
value_assign(Uprime->p[i][Uprime->NbColumns-1],Uprime->p[i][U->NbColumns-1]);
value_assign(Uprime->p[i][U->NbColumns-1],tmp);
}
Polyhedron_Free (Image);
Matrix_Free (B2inv);
B2inv = Matrix_Alloc(B1->NbRows, B1->NbColumns);
Matrix_Inverse(B1,B2inv);
ImageP = DomainImage(Zpol->P, B2inv, MAXNOOFRAYS);
Matrix_Free(B2inv);
Image = DomainImage(ImageP, Uprime, MAXNOOFRAYS);
Domain_Free(ImageP);
Result[0] = ZPolyhedron_Alloc(Hprime, Image);
Basis[0] = Matrix_Copy(B2);
/* Free the variables */
Polyhedron_Free (Image);
Matrix_Free (B1);
Matrix_Free (B2);
Matrix_Free (temp);
Matrix_Free (T1);
Matrix_Free (T2);
Matrix_Free (H);
Matrix_Free (U);
Matrix_Free (Hprime);
Matrix_Free (Uprime);
value_clear(tmp);
return;
} /* CanonicalForm */
/** extracts the equalities involving the parameters only, try to introduce
them back and compare the two polyhedra.
Reads a polyhedron and a context.
*/
int test_Constraints_Remove_parm_eqs(Matrix * A, Matrix * B) {
int isOk = 1;
Matrix * M, *C, *Cp, * Eqs, *M1, *C1;
Polyhedron *Pm, *Pc, *Pcp, *Peqs, *Pint;
unsigned int * elimParms;
printf("----- test_Constraints_Remove_parm_eqs() -----\n");
M1 = Matrix_Copy(A);
C1 = Matrix_Copy(B);
M = Matrix_Copy(M1);
C = Matrix_Copy(C1);
/* compute the combined polyhedron */
Pm = Constraints2Polyhedron(M, maxRays);
Pc = Constraints2Polyhedron(C, maxRays);
Pcp = align_context(Pc, Pm->Dimension, maxRays);
Polyhedron_Free(Pc);
Pc = DomainIntersection(Pm, Pcp, maxRays);
Polyhedron_Free(Pm);
Polyhedron_Free(Pcp);
Matrix_Free(M);
Matrix_Free(C);
/* extract the parm-equalities, expressed in the combined space */
Eqs = Constraints_Remove_parm_eqs(&M1, &C1, 1, &elimParms);
printf("Removed equalities: \n");
show_matrix(Eqs);
printf("Polyhedron without equalities involving only parameters: \n");
show_matrix(M1);
printf("Context without equalities: \n");
show_matrix(C1);
/* compute the supposedly-same polyhedron, using the extracted equalities */
Pm = Constraints2Polyhedron(M1, maxRays);
Pcp = Constraints2Polyhedron(C1, maxRays);
Peqs = align_context(Pcp, Pm->Dimension, maxRays);
Polyhedron_Free(Pcp);
Pcp = DomainIntersection(Pm, Peqs, maxRays);
Polyhedron_Free(Peqs);
Polyhedron_Free(Pm);
Peqs = Constraints2Polyhedron(Eqs, maxRays);
Matrix_Free(Eqs);
Matrix_Free(M1);
Matrix_Free(C1);
Pint = DomainIntersection(Pcp, Peqs, maxRays);
Polyhedron_Free(Pcp);
Polyhedron_Free(Peqs);
/* test their equality */
if (!PolyhedronIncludes(Pint, Pc)) {
isOk = 0;
}
else {
if (!PolyhedronIncludes(Pc, Pint)) {
isOk = 0;
}
}
Polyhedron_Free(Pc);
Polyhedron_Free(Pint);
return isOk;
} /* test_Constraints_Remove_parm_eqs() */
/**
* Tests Constraints_fullDimensionize by comparing the Ehrhart polynomials
* @param A the input set of constraints
* @param B the corresponding context
* @param the number of samples to generate for the test
* @return 1 if the Ehrhart polynomial had the same value for the
* full-dimensional and non-full-dimensional sets of constraints, for their
* corresponding sample parameters values.
*/
int test_Constraints_fullDimensionize(Matrix * A, Matrix * B,
unsigned int nbSamples) {
Matrix * Eqs= NULL, *ParmEqs=NULL, *VL=NULL;
unsigned int * elimVars=NULL, * elimParms=NULL;
Matrix * sample, * smallerSample=NULL;
Matrix * transfSample=NULL;
Matrix * parmVL=NULL;
unsigned int i, j, r, nbOrigParms, nbParms;
Value div, mod, *origVal=NULL, *fullVal=NULL;
Matrix * VLInv;
Polyhedron * P, *PC;
Matrix * M, *C;
Enumeration * origEP, * fullEP=NULL;
const char **fullNames = NULL;
int isOk = 1; /* holds the result */
/* compute the origial Ehrhart polynomial */
M = Matrix_Copy(A);
C = Matrix_Copy(B);
P = Constraints2Polyhedron(M, maxRays);
PC = Constraints2Polyhedron(C, maxRays);
origEP = Polyhedron_Enumerate(P, PC, maxRays, origNames);
Matrix_Free(M);
Matrix_Free(C);
Polyhedron_Free(P);
Polyhedron_Free(PC);
/* compute the full-dimensional polyhedron corresponding to A and its Ehrhart
polynomial */
M = Matrix_Copy(A);
C = Matrix_Copy(B);
nbOrigParms = B->NbColumns-2;
Constraints_fullDimensionize(&M, &C, &VL, &Eqs, &ParmEqs,
&elimVars, &elimParms, maxRays);
if ((Eqs->NbRows==0) && (ParmEqs->NbRows==0)) {
Matrix_Free(M);
Matrix_Free(C);
Matrix_Free(Eqs);
Matrix_Free(ParmEqs);
free(elimVars);
free(elimParms);
return 1;
}
nbParms = C->NbColumns-2;
P = Constraints2Polyhedron(M, maxRays);
PC = Constraints2Polyhedron(C, maxRays);
namesWithoutElim(origNames, nbOrigParms, elimParms, &fullNames);
fullEP = Polyhedron_Enumerate(P, PC, maxRays, fullNames);
Matrix_Free(M);
Matrix_Free(C);
Polyhedron_Free(P);
Polyhedron_Free(PC);
/* make a set of sample parameter values and compare the corresponding
Ehrhart polnomials */
sample = Matrix_Alloc(1,nbOrigParms);
transfSample = Matrix_Alloc(1, nbParms);
Lattice_extractSubLattice(VL, nbParms, &parmVL);
VLInv = Matrix_Alloc(parmVL->NbRows, parmVL->NbRows+1);
MatInverse(parmVL, VLInv);
if (dbg) {
show_matrix(parmVL);
show_matrix(VLInv);
}
srand(nbSamples);
value_init(mod);
value_init(div);
for (i = 0; i< nbSamples; i++) {
/* create a random sample */
for (j=0; j< nbOrigParms; j++) {
value_set_si(sample->p[0][j], rand()%100);
}
/* compute the corresponding value for the full-dimensional
constraints */
valuesWithoutElim(sample, elimParms, &smallerSample);
/* (N' i' 1)^T = VLinv.(N i 1)^T*/
for (r = 0; r < nbParms; r++) {
Inner_Product(&(VLInv->p[r][0]), smallerSample->p[0], nbParms,
&(transfSample->p[0][r]));
/* add the constant part */
value_addto(transfSample->p[0][r], transfSample->p[0][r],
VLInv->p[r][VLInv->NbColumns-2]);
value_pdivision(div, transfSample->p[0][r],
VLInv->p[r][VLInv->NbColumns-1]);
value_subtract(mod, transfSample->p[0][r], div);
/* if the parameters value does not belong to the validity lattice, the
Ehrhart polynomial is zero. */
if (!value_zero_p(mod)) {
fullEP = Enumeration_zero(nbParms, maxRays);
break;
}
}
/* compare the two forms of the Ehrhart polynomial.*/
if (origEP ==NULL) break; /* NULL has loose semantics for EPs */
origVal = compute_poly(origEP, sample->p[0]);
fullVal = compute_poly(fullEP, transfSample->p[0]);
if (!value_eq(*origVal, *fullVal)) {
isOk = 0;
printf("EPs don't match. \n Original value = ");
value_print(stdout, VALUE_FMT, *origVal);
printf("\n Original sample = [");
for (j=0; j<sample->NbColumns; j++) {
value_print(stdout, VALUE_FMT, sample->p[0][j]);
printf(" ");
}
printf("] \n EP = ");
if(origEP!=NULL) {
print_evalue(stdout, &(origEP->EP), origNames);
}
else {
printf("NULL");
}
printf(" \n Full-dimensional value = ");
value_print(stdout, P_VALUE_FMT, *fullVal);
printf("\n full-dimensional sample = [");
for (j=0; j<sample->NbColumns; j++) {
value_print(stdout, VALUE_FMT, transfSample->p[0][j]);
printf(" ");
}
printf("] \n EP = ");
if(origEP!=NULL) {
print_evalue(stdout, &(origEP->EP), fullNames);
}
else {
printf("NULL");
}
}
if (dbg) {
printf("\nOriginal value = ");
value_print(stdout, VALUE_FMT, *origVal);
printf("\nFull-dimensional value = ");
value_print(stdout, P_VALUE_FMT, *fullVal);
printf("\n");
}
value_clear(*origVal);
value_clear(*fullVal);
}
value_clear(mod);
value_clear(div);
Matrix_Free(sample);
Matrix_Free(smallerSample);
Matrix_Free(transfSample);
Enumeration_Free(origEP);
Enumeration_Free(fullEP);
return isOk;
} /* test_Constraints_fullDimensionize */
int main(int argc, char **argv)
{
isl_ctx *ctx;
int i, nbPol, nbVec, nbMat, func, j, n;
Polyhedron *A, *B, *C, *D, *E, *F, *G;
char s[128];
struct barvinok_options *options = barvinok_options_new_with_defaults();
argc = barvinok_options_parse(options, argc, argv, ISL_ARG_ALL);
ctx = isl_ctx_alloc_with_options(&barvinok_options_args, options);
nbPol = nbVec = nbMat = 0;
fgets(s, 128, stdin);
while ((*s=='#') ||
((sscanf(s, "D %d", &nbPol) < 1) &&
(sscanf(s, "V %d", &nbVec) < 1) &&
(sscanf(s, "M %d", &nbMat) < 1)))
fgets(s, 128, stdin);
for (i = 0; i < nbPol; ++i) {
Matrix *M = Matrix_Read();
A = Constraints2Polyhedron(M, options->MaxRays);
Matrix_Free(M);
fgets(s, 128, stdin);
while ((*s=='#') || (sscanf(s, "F %d", &func)<1))
fgets(s, 128, stdin);
switch(func) {
case 0: {
Value cb, ck;
value_init(cb);
value_init(ck);
fgets(s, 128, stdin);
/* workaround for apparent bug in older gmps */
*strchr(s, '\n') = '\0';
while ((*s=='#') || (value_read(ck, s) != 0)) {
fgets(s, 128, stdin);
/* workaround for apparent bug in older gmps */
*strchr(s, '\n') = '\0';
}
barvinok_count_with_options(A, &cb, options);
if (value_ne(cb, ck))
return -1;
value_clear(cb);
value_clear(ck);
break;
}
case 1:
Polyhedron_Print(stdout, P_VALUE_FMT, A);
B = Polyhedron_Polar(A, options->MaxRays);
Polyhedron_Print(stdout, P_VALUE_FMT, B);
C = Polyhedron_Polar(B, options->MaxRays);
Polyhedron_Print(stdout, P_VALUE_FMT, C);
Polyhedron_Free(C);
Polyhedron_Free(B);
break;
case 2:
Polyhedron_Print(stdout, P_VALUE_FMT, A);
for (j = 0; j < A->NbRays; ++j) {
B = supporting_cone(A, j);
Polyhedron_Print(stdout, P_VALUE_FMT, B);
Polyhedron_Free(B);
}
break;
case 3:
Polyhedron_Print(stdout, P_VALUE_FMT, A);
C = B = NULL;
barvinok_decompose(A,&B,&C);
puts("Pos:");
Polyhedron_Print(stdout, P_VALUE_FMT, B);
puts("Neg:");
Polyhedron_Print(stdout, P_VALUE_FMT, C);
Domain_Free(B);
Domain_Free(C);
break;
case 4: {
Value cm, cb;
struct tms tms_before, tms_between, tms_after;
value_init(cm);
value_init(cb);
Polyhedron_Print(stdout, P_VALUE_FMT, A);
times(&tms_before);
manual_count(A, &cm);
times(&tms_between);
barvinok_count(A, &cb, 100);
times(&tms_after);
printf("manual: ");
value_print(stdout, P_VALUE_FMT, cm);
puts("");
time_diff(&tms_before, &tms_between);
printf("Barvinok: ");
value_print(stdout, P_VALUE_FMT, cb);
puts("");
time_diff(&tms_between, &tms_after);
value_clear(cm);
value_clear(cb);
break;
}
case 5:
Polyhedron_Print(stdout, P_VALUE_FMT, A);
B = triangulate_cone(A, 100);
Polyhedron_Print(stdout, P_VALUE_FMT, B);
check_triangulization(A, B);
Domain_Free(B);
break;
case 6:
Polyhedron_Print(stdout, P_VALUE_FMT, A);
B = remove_equalities(A, options->MaxRays);
Polyhedron_Print(stdout, P_VALUE_FMT, B);
Polyhedron_Free(B);
break;
case 8: {
evalue *EP;
Matrix *M = Matrix_Read();
const char **param_name;
C = Constraints2Polyhedron(M, options->MaxRays);
Matrix_Free(M);
Polyhedron_Print(stdout, P_VALUE_FMT, A);
Polyhedron_Print(stdout, P_VALUE_FMT, C);
EP = barvinok_enumerate_with_options(A, C, options);
param_name = Read_ParamNames(stdin, C->Dimension);
print_evalue(stdout, EP, (const char**)param_name);
evalue_free(EP);
Polyhedron_Free(C);
}
case 9:
Polyhedron_Print(stdout, P_VALUE_FMT, A);
Polyhedron_Polarize(A);
C = B = NULL;
barvinok_decompose(A,&B,&C);
for (D = B; D; D = D->next)
Polyhedron_Polarize(D);
for (D = C; D; D = D->next)
Polyhedron_Polarize(D);
puts("Pos:");
Polyhedron_Print(stdout, P_VALUE_FMT, B);
puts("Neg:");
Polyhedron_Print(stdout, P_VALUE_FMT, C);
Domain_Free(B);
Domain_Free(C);
break;
case 10: {
evalue *EP;
Value cb, ck;
value_init(cb);
value_init(ck);
fgets(s, 128, stdin);
sscanf(s, "%d", &n);
for (j = 0; j < n; ++j) {
Polyhedron *P;
M = Matrix_Read();
P = Constraints2Polyhedron(M, options->MaxRays);
Matrix_Free(M);
A = DomainConcat(P, A);
}
fgets(s, 128, stdin);
/* workaround for apparent bug in older gmps */
*strchr(s, '\n') = '\0';
while ((*s=='#') || (value_read(ck, s) != 0)) {
fgets(s, 128, stdin);
/* workaround for apparent bug in older gmps */
*strchr(s, '\n') = '\0';
}
C = Universe_Polyhedron(0);
EP = barvinok_enumerate_union(A, C, options->MaxRays);
value_set_double(cb, compute_evalue(EP, &ck)+.25);
if (value_ne(cb, ck))
return -1;
Domain_Free(C);
value_clear(cb);
value_clear(ck);
evalue_free(EP);
break;
}
case 11: {
isl_space *dim;
isl_basic_set *bset;
isl_pw_qpolynomial *expected, *computed;
unsigned nparam;
expected = isl_pw_qpolynomial_read_from_file(ctx, stdin);
nparam = isl_pw_qpolynomial_dim(expected, isl_dim_param);
dim = isl_space_set_alloc(ctx, nparam, A->Dimension - nparam);
bset = isl_basic_set_new_from_polylib(A, dim);
computed = isl_basic_set_lattice_width(bset);
computed = isl_pw_qpolynomial_sub(computed, expected);
if (!isl_pw_qpolynomial_is_zero(computed))
return -1;
isl_pw_qpolynomial_free(computed);
break;
}
case 12: {
Vector *sample;
int has_sample;
fgets(s, 128, stdin);
sscanf(s, "%d", &has_sample);
sample = Polyhedron_Sample(A, options);
if (!sample && has_sample)
return -1;
if (sample && !has_sample)
return -1;
if (sample && !in_domain(A, sample->p))
return -1;
Vector_Free(sample);
}
}
Domain_Free(A);
}
for (i = 0; i < nbVec; ++i) {
int ok;
Vector *V = Vector_Read();
Matrix *M = Matrix_Alloc(V->Size, V->Size);
Vector_Copy(V->p, M->p[0], V->Size);
ok = unimodular_complete(M, 1);
assert(ok);
Matrix_Print(stdout, P_VALUE_FMT, M);
Matrix_Free(M);
Vector_Free(V);
}
for (i = 0; i < nbMat; ++i) {
Matrix *U, *V, *S;
Matrix *M = Matrix_Read();
Smith(M, &U, &V, &S);
Matrix_Print(stdout, P_VALUE_FMT, U);
Matrix_Print(stdout, P_VALUE_FMT, V);
Matrix_Print(stdout, P_VALUE_FMT, S);
Matrix_Free(M);
Matrix_Free(U);
Matrix_Free(V);
Matrix_Free(S);
}
isl_ctx_free(ctx);
return 0;
}