/** 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() */
/*
* Return the Z-polyhedron intersection of the Z-polyhedra 'A' and 'B'.
* Note: If Z1 = L1 (intersect) P1 and Z2 = L2 (intersect) P2, then
* Z1 (intersect) Z2 = (L1 (intersect) L2) (intersect) (P1 (intersect) P2)
*/
static ZPolyhedron *ZPolyhedronIntersection(ZPolyhedron *A, ZPolyhedron *B) {
ZPolyhedron *Result = NULL;
Lattice *LInter;
Polyhedron *PInter, *ImageA, *ImageB, *PreImage;
#ifdef DOMDEBUG
FILE *fp;
fp = fopen("_debug","a");
fprintf(fp,"\nEntered ZPOLYHEDRONINTERSECTION\n");
fclose(fp);
#endif
LInter = LatticeIntersection(A->Lat,B->Lat);
if(isEmptyLattice(LInter) == True) {
ZPolyhedron_Free (Result);
Matrix_Free(LInter);
return (EmptyZPolyhedron(A->Lat->NbRows-1));
}
ImageA = DomainImage(A->P,A->Lat,MAXNOOFRAYS);
ImageB = DomainImage(B->P,B->Lat,MAXNOOFRAYS);
PInter = DomainIntersection(ImageA,ImageB,MAXNOOFRAYS);
if (emptyQ(PInter))
Result = EmptyZPolyhedron(LInter->NbRows-1);
else {
PreImage = DomainPreimage(PInter,(Matrix *)LInter,MAXNOOFRAYS);
Result = ZPolyhedron_Alloc(LInter, PreImage);
Domain_Free (PreImage);
}
Matrix_Free(LInter);
Domain_Free(PInter);
Domain_Free(ImageA);
Domain_Free(ImageB);
return Result ;
} /* ZPolyhedronIntersection */
PlutoConstraints *pluto_constraints_intersection(const PlutoConstraints *cst1,
const PlutoConstraints *cst2)
{
Polyhedron *pol1 = pluto_constraints_to_polylib(cst1);
Polyhedron *pol2 = pluto_constraints_to_polylib(cst2);
Polyhedron *pol3 = DomainIntersection(pol1, pol2, 50);
PlutoConstraints *icst = polylib_to_pluto_constraints(pol3);
Domain_Free(pol1);
Domain_Free(pol2);
Domain_Free(pol3);
return icst;
}
/*
* Return the difference of the two Z-polyhedra 'A' and 'B'. Below is the
* procedure to find the difference of 'A' and 'B' :-
* Procedure:
* Let A = L1 (intersect) P1' and B = L2 (intersect) P2' where
* (P1' = DomImage(P1,L1) and P2' = DomImage(P2,L2)). Then
* A-B = L1 (intersect) (P1'-P2') Union
* (L1-L2) (intersect) (P1' (intersect) P2')
*/
static ZPolyhedron *ZPolyhedronDifference(ZPolyhedron *A, ZPolyhedron *B) {
ZPolyhedron *Result = NULL ;
LatticeUnion *LatDiff, *temp;
Polyhedron *DomDiff, *DomInter, *PreImage, *ImageA, *ImageB;
Bool flag = False;
#ifdef DOMDEBUG
FILE *fp;
fp = fopen("_debug", "a");
fprintf(fp,"\nEntered ZPOLYHEDRONDIFFERENCE\n");
fclose(fp);
#endif
if(isEmptyZPolyhedron (A))
return NULL;
if(isEmptyZPolyhedron (B)) {
Result = ZDomain_Copy (A);
return Result;
}
ImageA = DomainImage(A->P,(Matrix *)A->Lat,MAXNOOFRAYS);
ImageB = DomainImage(B->P,(Matrix *)B->Lat,MAXNOOFRAYS);
DomDiff = DomainDifference(ImageA,ImageB,MAXNOOFRAYS);
if (emptyQ (DomDiff))
flag = True;
else {
ZPolyhedron *Z;
PreImage = DomainPreimage(DomDiff,A->Lat,MAXNOOFRAYS);
Z = ZPolyhedron_Alloc(A->Lat,PreImage);
Result = AddZPolytoZDomain(Z,Result);
}
if (flag == True) /* DomDiff = NULL; DomInter = A */
DomInter = Domain_Copy(ImageA);
else {
DomInter = DomainIntersection(ImageA,ImageB,MAXNOOFRAYS);
if (emptyQ(DomInter)) {
if (flag == True)
return (EmptyZPolyhedron(A->Lat->NbRows-1));
else
return Result;
}
}
LatDiff = LatticeDifference(A->Lat, B->Lat);
if(LatDiff == NULL)
if(flag == True )
return(EmptyZPolyhedron (A->Lat->NbRows-1));
while (LatDiff != NULL) {
ZPolyhedron *tempZ = NULL;
PreImage = DomainPreimage(DomInter, LatDiff->M, MAXNOOFRAYS);
tempZ = ZPolyhedron_Alloc(LatDiff->M, PreImage);
Domain_Free(PreImage);
Result = AddZPoly2ZDomain(tempZ,Result);
ZPolyhedron_Free(tempZ);
temp = LatDiff;
LatDiff = LatDiff->next;
Matrix_Free ((Matrix *) temp->M);
free (temp);
}
Domain_Free (DomInter);
Domain_Free (DomDiff);
return Result;
} /* ZPolyhedronDifference */
/** 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() */
int main() {
Matrix *a, *b, *t;
Polyhedron *A, *B, *C, *D;
printf("Polyhedral Library Test\n\n");
/* read in a matrix containing your equations */
/* for example, run this program and type in these five lines:
4 4
1 0 1 -1
1 -1 0 6
1 0 -1 7
1 1 0 -2
This is a matrix for the following inequalities
1 = inequality, 0x + 1y -1 >=0 --> y >= 1
1 = inequality, -1x + 0y +6 >=0 --> x <= 6
1 = inequality, 0x + -1y +7 >=0 --> y <= 7
1 = inequality, 1x + 0y -2 >=0 --> x >= 2
If the first number is a 0 instead of a 1, then that constraint
is an 'equality' instead of an 'inequality'.
*/
a = Matrix_Read();
/* read in a second matrix containing a second set of constraints:
for example :
4 4
1 1 0 -1
1 -1 0 3
1 0 -1 5
1 0 1 -2
*/
b = Matrix_Read();
/* Convert the constraints to a Polyhedron.
This operation 1. Computes the dual ray/vertice form of the
system, and 2. Eliminates redundant constraints and reduces
them to a minimal form.
*/
A = Constraints2Polyhedron(a, 200);
B = Constraints2Polyhedron(b, 200);
/* the 200 is the size of the working space (in terms of number
of rays) that is allocated temporarily
-- you can enlarge or reduce it as needed */
/* There is likewise a rays to polyhedron procedure */
/* Since you are done with the matrices a and b, be a good citizen
and clean up your garbage */
Matrix_Free(a);
Matrix_Free(b);
/* If you want the the reduced set of equations back, you can
either learn to read the polyhedron structure (not hard,
look in "types.h"...
or you can get the matrix back in the same format it started
in... */
a = Polyhedron2Constraints(A);
b = Polyhedron2Constraints(B);
/* Take a look at them if you want */
printf("\na =");
Matrix_Print(stdout,P_VALUE_FMT,a);
printf("\nb =");
Matrix_Print(stdout,P_VALUE_FMT,b);
Matrix_Free(a);
Matrix_Free(b);
/* To intersect the two systems, use the polyhedron formats... */
C = DomainIntersection(A, B, 200);
/* Again, the 200 is the size of the working space */
/* This time, lets look a the polyhedron itself... */
printf("\nC = A and B =");
Polyhedron_Print(stdout,P_VALUE_FMT,C);
/*
* The operations DomainUnion, DomainDifference, and DomainConvex
* are also available
*/
/*
* Read in a third matrix containing a transformation matrix,
* this one swaps the indices (x,y --> y,x):
* 3 3
* 0 1 0
* 1 0 0
* 0 0 1
*/
t = Matrix_Read();
/* Take the preimage (transform the equations) of the domain C to
get D. Are you catching on to this 200 thing yet ??? */
D = Polyhedron_Preimage(C, t, 200);
/* cleanup please */
Matrix_Free(t);
printf("\nD = transformed C =");
Polyhedron_Print(stdout,P_VALUE_FMT,D);
Domain_Free(D);
/* in a similar way, Polyhedron_Image(dom, mat, 200), takes the image
of dom under matrix mat (transforms the vertices/rays) */
/* The function PolyhedronIncludes(Pol1, Pol2) returns 1 if Pol1
includes (covers) Pol2, and a 0 otherwise */
if (PolyhedronIncludes(A,C))
printf("\nWe expected A to cover C since C = A intersect B\n");
if (!PolyhedronIncludes(C,B))
printf("and C does not cover B...\n");
/* Final note: some functions are defined for Domains, others
* for Polyhedrons. A domain is simply a list of polyhedrons.
* Every polyhedron structure has a "next" pointer used to
* make a list of polyhedrons... For instance, the union of
* two disjoint polyhedra is a domain consisting of two polyhedra.
* If you want the convex domain... you have to call
* DomainConvex(Pol1, 200) explicity.
* Note that includes does not work on domains, only on simple
* polyhedrons...
* Thats the end of the demo... write me if you have questions.
* And remember to clean up...
*/
Domain_Free(A);
Domain_Free(B);
Domain_Free(C);
return 0;
}
/* INDEX = 1 .... Dimension */
int PolyhedronLTQ (Polyhedron *Pol1,Polyhedron *Pol2,int INDEX, int PDIM, int NbMaxConstrs) {
int res, dim, i, j, k;
Polyhedron *Q1, *Q2, *Q3, *Q4, *Q;
Matrix *Mat;
if (Pol1->next || Pol2->next) {
errormsg1("PolyhedronLTQ", "compoly", "Can only compare polyhedra");
return 0;
}
if (Pol1->Dimension != Pol2->Dimension) {
errormsg1("PolyhedronLTQ","diffdim","Polyhedra are not same dimension");
return 0;
}
dim = Pol1->Dimension+2;
POL_ENSURE_FACETS(Pol1);
POL_ENSURE_VERTICES(Pol1);
POL_ENSURE_FACETS(Pol2);
POL_ENSURE_VERTICES(Pol2);
#ifdef DEBUG
fprintf(stdout, "P1\n");
Polyhedron_Print(stdout,P_VALUE_FMT,Pol1);
fprintf(stdout, "P2\n");
Polyhedron_Print(stdout,P_VALUE_FMT,Pol2);
#endif
/* Create the Line to add */
k = Pol1->Dimension-INDEX+1-PDIM;
Mat = Matrix_Alloc(k,dim);
Vector_Set(Mat->p_Init,0,dim*k);
for(j=0,i=INDEX;j<k;i++,j++)
value_set_si(Mat->p[j][i],1);
Q1 = AddRays(Mat->p[0],k,Pol1,NbMaxConstrs);
Q2 = AddRays(Mat->p[0],k,Pol2,NbMaxConstrs);
#ifdef DEBUG
fprintf(stdout, "Q1\n");
Polyhedron_Print(stdout,P_VALUE_FMT,Q1);
fprintf(stdout, "Q2\n");
Polyhedron_Print(stdout,P_VALUE_FMT,Q2);
#endif
Matrix_Free(Mat);
Q = DomainIntersection(Q1,Q2,NbMaxConstrs);
#ifdef DEBUG
fprintf(stdout, "Q\n");
Polyhedron_Print(stdout,P_VALUE_FMT,Q);
#endif
Domain_Free(Q1);
Domain_Free(Q2);
if (emptyQ(Q)) res = 0; /* not comparable */
else {
Q1 = DomainIntersection(Pol1,Q,NbMaxConstrs);
Q2 = DomainIntersection(Pol2,Q,NbMaxConstrs);
#ifdef DEBUG
fprintf(stdout, "Q1\n");
Polyhedron_Print(stdout,P_VALUE_FMT,Q1);
fprintf(stdout, "Q2\n");
Polyhedron_Print(stdout,P_VALUE_FMT,Q2);
#endif
k = Q1->NbConstraints + Q2->NbConstraints;
Mat = Matrix_Alloc(k, dim);
Vector_Set(Mat->p_Init,0,k*dim);
/* First compute surrounding polyhedron */
j=0;
for (i=0; i<Q1->NbConstraints; i++) {
if ((value_one_p(Q1->Constraint[i][0])) && (value_pos_p(Q1->Constraint[i][INDEX]))) {
/* keep Q1's lower bounds */
for (k=0; k<dim; k++)
value_assign(Mat->p[j][k],Q1->Constraint[i][k]);
j++;
}
}
for (i=0; i<Q2->NbConstraints; i++) {
if ((value_one_p(Q2->Constraint[i][0])) && (value_neg_p(Q2->Constraint[i][INDEX]))) {
/* and keep Q2's upper bounds */
for (k=0; k<dim; k++)
value_assign(Mat->p[j][k],Q2->Constraint[i][k]);
j++;
}
}
Q4 = AddConstraints(Mat->p[0], j, Q, NbMaxConstrs);
Matrix_Free(Mat);
#ifdef debug
fprintf(stderr, "Q4 surrounding polyhedron\n");
Polyhderon_Print(stderr,P_VALUE_FMT, Q4);
#endif
/* if surrounding polyhedron is empty, D1>D2 */
if (emptyQ(Q4)) {
res = 1;
#ifdef debug
fprintf(stderr, "Surrounding polyhedron is empty\n");
#endif
goto LTQdone2;
}
/* Test if Q1 < Q2 */
/* Build a constraint array for >= Q1 and <= Q2 */
Mat = Matrix_Alloc(2,dim);
Vector_Set(Mat->p_Init,0,2*dim);
/* Choose a contraint from Q1 */
for (i=0; i<Q1->NbConstraints; i++) {
if (value_zero_p(Q1->Constraint[i][0])) {
/* Equality */
if (value_zero_p(Q1->Constraint[i][INDEX])) {
/* Ignore side constraint (they are in Q) */
continue;
}
else if (value_neg_p(Q1->Constraint[i][INDEX])) {
/* copy -constraint to Mat */
value_set_si(Mat->p[0][0],1);
for (k=1; k<dim; k++)
value_oppose(Mat->p[0][k],Q1->Constraint[i][k]);
}
else {
/* Copy constraint to Mat */
value_set_si(Mat->p[0][0],1);
for (k=1; k<dim; k++)
value_assign(Mat->p[0][k],Q1->Constraint[i][k]);
}
}
else if(value_neg_p(Q1->Constraint[i][INDEX])) {
/* Upper bound -- make a lower bound from it */
value_set_si(Mat->p[0][0],1);
for (k=1; k<dim; k++)
value_oppose(Mat->p[0][k],Q1->Constraint[i][k]);
}
else {
/* Lower or side bound -- ignore it */
continue;
}
/* Choose a constraint from Q2 */
for (j=0; j<Q2->NbConstraints; j++) {
if (value_zero_p(Q2->Constraint[j][0])) { /* equality */
if (value_zero_p(Q2->Constraint[j][INDEX])) {
/* Ignore side constraint (they are in Q) */
continue;
}
else if (value_pos_p(Q2->Constraint[j][INDEX])) {
/* Copy -constraint to Mat */
value_set_si(Mat->p[1][0],1);
for (k=1; k<dim; k++)
value_oppose(Mat->p[1][k],Q2->Constraint[j][k]);
}
else {
/* Copy constraint to Mat */
value_set_si(Mat->p[1][0],1);
for (k=1; k<dim; k++)
value_assign(Mat->p[1][k],Q2->Constraint[j][k]);
};
}
else if (value_pos_p(Q2->Constraint[j][INDEX])) {
/* Lower bound -- make an upper bound from it */
value_set_si(Mat->p[1][0],1);
for(k=1;k<dim;k++)
value_oppose(Mat->p[1][k],Q2->Constraint[j][k]);
}
else {
/* Upper or side bound -- ignore it */
continue;
};
#ifdef DEBUG
fprintf(stdout, "i=%d j=%d M=\n", i+1, j+1);
Matrix_Print(stdout,P_VALUE_FMT,Mat);
#endif
/* Add Mat to Q and see if anything is made */
Q3 = AddConstraints(Mat->p[0],2,Q,NbMaxConstrs);
#ifdef DEBUG
fprintf(stdout, "Q3\n");
Polyhedron_Print(stdout,P_VALUE_FMT,Q3);
#endif
if (!emptyQ(Q3)) {
Domain_Free(Q3);
#ifdef DEBUG
fprintf(stdout, "not empty\n");
#endif
res = -1;
goto LTQdone;
}
#ifdef DEBUG
fprintf(stdout,"empty\n");
#endif
Domain_Free(Q3);
} /* end for j */
} /* end for i */
res = 1;
LTQdone:
Matrix_Free(Mat);
LTQdone2:
Domain_Free(Q4);
Domain_Free(Q1);
Domain_Free(Q2);
}
Domain_Free(Q);
#ifdef DEBUG
fprintf(stdout, "res = %d\n", res);
#endif
return res;
} /* PolyhedronLTQ */
int main(int argc,char *argv[]) {
Matrix *C1, *P1;
Polyhedron *C, *P, *S;
Polyhedron *CC, *PP;
Enumeration *en;
Value *p;
int i,j,k;
int m,M;
char str[1024];
Value c;
/******* Read the input *********/
P1 = Matrix_Read();
C1 = Matrix_Read();
if(C1->NbColumns < 2) {
fprintf(stderr,"Not enough parameters !\n");
exit(0);
}
P = Constraints2Polyhedron(P1, MAXRAYS);
C = Constraints2Polyhedron(C1, MAXRAYS);
Matrix_Free(C1);
Matrix_Free(P1);
/******* Compute the true context *******/
CC = align_context(C,P->Dimension,MAXRAYS);
PP = DomainIntersection(P,CC,MAXRAYS);
Domain_Free(CC);
C1 = Matrix_Alloc(C->Dimension+1,P->Dimension+1);
for(i=0;i<C1->NbRows;i++)
for(j=0;j<C1->NbColumns;j++)
if(i==j-P->Dimension+C->Dimension)
value_set_si(C1->p[i][j],1);
else
value_set_si(C1->p[i][j],0);
CC = Polyhedron_Image(PP,C1,MAXRAYS);
Domain_Free(C);
Domain_Free(PP);
Matrix_Free(C1);
C = CC;
/******* Initialize parameters *********/
p = (Value *)malloc(sizeof(Value) * (P->Dimension+2));
for(i=0;i<=P->Dimension;i++) {
value_init(p[i]);
value_set_si(p[i],0);
}
value_init(p[i]);
value_set_si(p[i],1);
/*** S = scanning list of polyhedra ***/
S = Polyhedron_Scan(P,C,MAXRAYS);
value_init(c);
/******* Count now *********/
FOREVER {
fflush(stdin);
printf("Enter %d parameters : ",C->Dimension);
for(k=S->Dimension-C->Dimension+1;k<=S->Dimension;++k) {
scanf(" %s", str);
value_read(p[k],str);
}
printf("EP( ");
value_print(stdout,VALUE_FMT,p[S->Dimension-C->Dimension+1]);
for(k=S->Dimension-C->Dimension+2;k<=S->Dimension;++k) {
printf(", ");
value_print(stdout,VALUE_FMT,p[k]);
}
printf(" ) = ");
count_points(1,S,p,&c);
value_print(stdout,VALUE_FMT,c);
printf("\n");
}
for(i=0;i<=(P->Dimension+1);i++)
value_clear(p[i]);
value_clear(c);
return(0);
} /* main */