/*
* Given Z-polyhedra 'A' and 'B', return True if 'A' is included in 'B',
* otherwise return False
*/
Bool ZPolyhedronIncludes(ZPolyhedron *A, ZPolyhedron *B) {
Polyhedron *Diff = NULL ;
Bool retval = False;
#ifdef DOMDEBUG
FILE *fp;
fp = fopen("_debug","a");
fprintf(fp,"\nEntered ZPOLYHEDRONINCLUDES\n");
fclose(fp);
#endif
if (LatticeIncludes(A->Lat, B->Lat) == True) {
Polyhedron *ImageA, *ImageB ;
ImageA = DomainImage(A->P,A->Lat,MAXNOOFRAYS);
ImageB = DomainImage(B->P,B->Lat,MAXNOOFRAYS);
Diff = DomainDifference(ImageA, ImageB, MAXNOOFRAYS);
if(emptyQ (Diff))
retval = True ;
Domain_Free (ImageA);
Domain_Free (ImageB);
Domain_Free (Diff);
}
return retval;
} /* ZPolyhedronIncludes */
PlutoConstraints *pluto_constraints_difference(const PlutoConstraints *cst1,
const PlutoConstraints *cst2)
{
assert(cst1->ncols == cst2->ncols);
Polyhedron *pol1 = pluto_constraints_to_polylib(cst1);
Polyhedron *pol2 = pluto_constraints_to_polylib(cst2);
Polyhedron *pol3 = DomainDifference(pol1, pol2, 50);
PlutoConstraints *diffcst = polylib_to_pluto_constraints(pol3);
Domain_Free(pol1);
Domain_Free(pol2);
Domain_Free(pol3);
return diffcst;
}
/*
* Return the simplified representation of the Z-domain 'ZDom'. It attempts to
* convexize unions of polyhedra when they correspond to the same lattices and
* to simplify union of lattices when they correspond to the same polyhdera.
*/
ZPolyhedron *ZDomainSimplify(ZPolyhedron *ZDom) {
ZPolyhedron *Ztmp, *Result;
ForSimplify *Head, *Prev, *Curr;
ZPolyhedron *ZDomHead, *Emp;
if (ZDom == NULL) {
fprintf(stderr,"\nError in ZDomainSimplify - ZDomHead = NULL\n");
return NULL;
}
if (ZDom->next == NULL)
return (ZPolyhedron_Copy (ZDom));
Emp = EmptyZPolyhedron(ZDom->Lat->NbRows-1);
ZDomHead = ZDomainUnion(ZDom, Emp);
ZPolyhedron_Free(Emp);
Head = NULL;
Ztmp = ZDomHead;
do {
Polyhedron *Img;
Img = DomainImage(Ztmp->P,Ztmp->Lat,MAXNOOFRAYS);
for(Curr = Head; Curr != NULL; Curr = Curr->next) {
Polyhedron *Diff1;
Bool flag = False;
Diff1 = DomainDifference(Img,Curr->Pol,MAXNOOFRAYS);
if (emptyQ(Diff1)) {
Polyhedron *Diff2;
Diff2 = DomainDifference(Curr->Pol,Img,MAXNOOFRAYS);
if (emptyQ(Diff2))
flag = True;
Domain_Free(Diff2);
}
Domain_Free (Diff1);
if (flag == True) {
LatticeUnion *temp;
temp = (LatticeUnion *)malloc(sizeof(LatticeUnion));
temp->M = (Lattice *)Matrix_Copy((Matrix *)Ztmp->Lat);
temp->next = Curr->LatUni;
Curr->LatUni = temp;
break;
}
}
if(Curr == NULL) {
Curr = (ForSimplify *)malloc(sizeof(ForSimplify));
Curr->Pol = Domain_Copy(Img);
Curr->LatUni = (LatticeUnion *)malloc(sizeof(LatticeUnion));
Curr->LatUni->M = (Lattice *)Matrix_Copy((Matrix *)Ztmp->Lat);
Curr->LatUni->next = NULL;
Curr->next = Head;
Head = Curr;
}
Domain_Free (Img);
Ztmp = Ztmp->next;
} while(Ztmp != NULL);
for (Curr = Head; Curr != NULL; Curr = Curr->next)
Curr->LatUni = LatticeSimplify(Curr->LatUni);
Result = NULL;
for(Curr = Head; Curr != NULL; Curr = Curr->next) {
LatticeUnion *L;
for(L = Curr->LatUni; L != NULL; L = L->next) {
Polyhedron *Preim;
ZPolyhedron *Zpol;
Preim = DomainPreimage(Curr->Pol,L->M,MAXNOOFRAYS);
Zpol = ZPolyhedron_Alloc(L->M, Preim);
Zpol->next = Result;
Result = Zpol;
Domain_Free(Preim);
}
}
Curr = Head;
while (Curr != NULL) {
Prev = Curr;
Curr = Curr->next;
LatticeUnion_Free(Prev->LatUni);
Domain_Free(Prev->Pol);
free(Prev);
}
return Result;
} /* ZDomainSimplify */
/*
* 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 */
