X-Git-Url: https://scm.cri.ensmp.fr/git/linpy.git/blobdiff_plain/6ec23dc57252ffe01aa60595fc499f580381e4a9..5eca735504be3b7c301e2a1fa37712eb88b4ec64:/pypol/domains.py diff --git a/pypol/domains.py b/pypol/domains.py index cd118e8..cdf2de4 100644 --- a/pypol/domains.py +++ b/pypol/domains.py @@ -1,14 +1,14 @@ import ast import functools import re +import math from fractions import Fraction from . import islhelper -from .islhelper import mainctx, libisl, isl_set_basic_sets -from .geometry import GeometricObject -from .coordinates import Point -from .linexprs import Expression, Symbol +from .islhelper import mainctx, libisl +from .linexprs import Expression, Symbol, Rational +from .geometry import GeometricObject, Point, Vector __all__ = [ @@ -68,11 +68,17 @@ class Domain(GeometricObject): return self._dimension def disjoint(self): + """ + Returns this set as disjoint. + """ islset = self._toislset(self.polyhedra, self.symbols) islset = libisl.isl_set_make_disjoint(mainctx, islset) return self._fromislset(islset, self.symbols) def isempty(self): + """ + Returns true if this set is an Empty set. + """ islset = self._toislset(self.polyhedra, self.symbols) empty = bool(libisl.isl_set_is_empty(islset)) libisl.isl_set_free(islset) @@ -82,18 +88,27 @@ class Domain(GeometricObject): return not self.isempty() def isuniverse(self): + """ + Returns true if this set is the Universe set. + """ islset = self._toislset(self.polyhedra, self.symbols) universe = bool(libisl.isl_set_plain_is_universe(islset)) libisl.isl_set_free(islset) return universe def isbounded(self): + """ + Returns true if this set is bounded. + """ islset = self._toislset(self.polyhedra, self.symbols) bounded = bool(libisl.isl_set_is_bounded(islset)) libisl.isl_set_free(islset) return bounded def __eq__(self, other): + """ + Returns true if two sets are equal. + """ symbols = self._xsymbols([self, other]) islset1 = self._toislset(self.polyhedra, symbols) islset2 = other._toislset(other.polyhedra, symbols) @@ -103,6 +118,9 @@ class Domain(GeometricObject): return equal def isdisjoint(self, other): + """ + Return True if two sets have a null intersection. + """ symbols = self._xsymbols([self, other]) islset1 = self._toislset(self.polyhedra, symbols) islset2 = self._toislset(other.polyhedra, symbols) @@ -112,6 +130,9 @@ class Domain(GeometricObject): return equal def issubset(self, other): + """ + Report whether another set contains this set. + """ symbols = self._xsymbols([self, other]) islset1 = self._toislset(self.polyhedra, symbols) islset2 = self._toislset(other.polyhedra, symbols) @@ -121,9 +142,15 @@ class Domain(GeometricObject): return equal def __le__(self, other): + """ + Returns true if this set is less than or equal to another set. + """ return self.issubset(other) def __lt__(self, other): + """ + Returns true if this set is less than another set. + """ symbols = self._xsymbols([self, other]) islset1 = self._toislset(self.polyhedra, symbols) islset2 = self._toislset(other.polyhedra, symbols) @@ -133,23 +160,31 @@ class Domain(GeometricObject): return equal def complement(self): + """ + Returns the complement of this set. + """ islset = self._toislset(self.polyhedra, self.symbols) islset = libisl.isl_set_complement(islset) return self._fromislset(islset, self.symbols) def __invert__(self): + """ + Returns the complement of this set. + """ return self.complement() def simplify(self): - #does not change anything in any of the examples - #isl seems to do this naturally + """ + Returns a set without redundant constraints. + """ islset = self._toislset(self.polyhedra, self.symbols) islset = libisl.isl_set_remove_redundancies(islset) return self._fromislset(islset, self.symbols) def aspolyhedron(self): - # several types of hull are available - # polyhedral seems to be the more appropriate, to be checked + """ + Returns polyhedral hull of set. + """ from .polyhedra import Polyhedron islset = self._toislset(self.polyhedra, self.symbols) islbset = libisl.isl_set_polyhedral_hull(islset) @@ -159,7 +194,9 @@ class Domain(GeometricObject): return self def project(self, dims): - # use to remove certain variables + """ + Return new set with given dimensions removed. + """ islset = self._toislset(self.polyhedra, self.symbols) n = 0 for index, symbol in reversed(list(enumerate(self.symbols))): @@ -174,6 +211,9 @@ class Domain(GeometricObject): return Domain._fromislset(islset, dims) def sample(self): + """ + Returns a single subset of the input. + """ islset = self._toislset(self.polyhedra, self.symbols) islpoint = libisl.isl_set_sample_point(islset) if bool(libisl.isl_point_is_void(islpoint)): @@ -189,6 +229,9 @@ class Domain(GeometricObject): return point def intersection(self, *others): + """ + Return the intersection of two sets as a new set. + """ if len(others) == 0: return self symbols = self._xsymbols((self,) + others) @@ -199,9 +242,15 @@ class Domain(GeometricObject): return self._fromislset(islset1, symbols) def __and__(self, other): + """ + Return the intersection of two sets as a new set. + """ return self.intersection(other) def union(self, *others): + """ + Return the union of sets as a new set. + """ if len(others) == 0: return self symbols = self._xsymbols((self,) + others) @@ -212,12 +261,21 @@ class Domain(GeometricObject): return self._fromislset(islset1, symbols) def __or__(self, other): + """ + Return a new set with elements from both sets. + """ return self.union(other) def __add__(self, other): + """ + Return new set containing all elements in both sets. + """ return self.union(other) def difference(self, other): + """ + Return the difference of two sets as a new set. + """ symbols = self._xsymbols([self, other]) islset1 = self._toislset(self.polyhedra, symbols) islset2 = other._toislset(other.polyhedra, symbols) @@ -225,28 +283,34 @@ class Domain(GeometricObject): return self._fromislset(islset, symbols) def __sub__(self, other): + """ + Return the difference of two sets as a new set. + """ return self.difference(other) def lexmin(self): + """ + Return a new set containing the lexicographic minimum of the elements in the set. + """ islset = self._toislset(self.polyhedra, self.symbols) islset = libisl.isl_set_lexmin(islset) return self._fromislset(islset, self.symbols) def lexmax(self): + """ + Return a new set containing the lexicographic maximum of the elements in the set. + """ islset = self._toislset(self.polyhedra, self.symbols) islset = libisl.isl_set_lexmax(islset) return self._fromislset(islset, self.symbols) - def num_parameters(self): - #could be useful with large, complicated polyhedrons - islbset = self._toislbasicset(self.equalities, self.inequalities, self.symbols) - num = libisl.isl_basic_set_dim(islbset, libisl.isl_dim_set) - return num - def involves_dims(self, dims): - #could be useful with large, complicated polyhedrons + def involves_vars(self, vars): + """ + Returns true if a set depends on given dimensions. + """ islset = self._toislset(self.polyhedra, self.symbols) - dims = sorted(dims) + dims = sorted(vars) symbols = sorted(list(self.symbols)) n = 0 if len(dims)>0: @@ -265,8 +329,12 @@ class Domain(GeometricObject): _RE_COORDINATE = re.compile(r'\((?P\-?\d+)\)(/(?P\d+))?') def vertices(self): - #returning list of verticies + """ + Return a list of vertices for this Polygon. + """ from .polyhedra import Polyhedron + if not self.isbounded(): + raise ValueError('domain must be bounded') islbset = self._toislbasicset(self.equalities, self.inequalities, self.symbols) vertices = libisl.isl_basic_set_compute_vertices(islbset); vertices = islhelper.isl_vertices_vertices(vertices) @@ -287,7 +355,6 @@ class Domain(GeometricObject): coordinate = -Fraction(constant, coefficient) coordinates.append((symbol, coordinate)) else: - # horrible hack, find a cleaner solution string = islhelper.isl_multi_aff_to_str(expr) matches = self._RE_COORDINATE.finditer(string) for symbol, match in zip(self.symbols, matches): @@ -300,6 +367,9 @@ class Domain(GeometricObject): return points def points(self): + """ + Returns the points contained in the set. + """ if not self.isbounded(): raise ValueError('domain must be bounded') from .polyhedra import Universe, Eq @@ -316,6 +386,135 @@ class Domain(GeometricObject): points.append(Point(coordinates)) return points + @classmethod + def _polygon_inner_point(cls, points): + symbols = points[0].symbols + coordinates = {symbol: 0 for symbol in symbols} + for point in points: + for symbol, coordinate in point.coordinates(): + coordinates[symbol] += coordinate + for symbol in symbols: + coordinates[symbol] /= len(points) + return Point(coordinates) + + @classmethod + def _sort_polygon_2d(cls, points): + if len(points) <= 3: + return points + o = cls._polygon_inner_point(points) + angles = {} + for m in points: + om = Vector(o, m) + dx, dy = (coordinate for symbol, coordinate in om.coordinates()) + angle = math.atan2(dy, dx) + angles[m] = angle + return sorted(points, key=angles.get) + + @classmethod + def _sort_polygon_3d(cls, points): + if len(points) <= 3: + return points + o = cls._polygon_inner_point(points) + a = points[0] + oa = Vector(o, a) + norm_oa = oa.norm() + for b in points[1:]: + ob = Vector(o, b) + u = oa.cross(ob) + if not u.isnull(): + u = u.asunit() + break + else: + raise ValueError('degenerate polygon') + angles = {a: 0.} + for m in points[1:]: + om = Vector(o, m) + normprod = norm_oa * om.norm() + cosinus = max(oa.dot(om) / normprod, -1.) + sinus = u.dot(oa.cross(om)) / normprod + angle = math.acos(cosinus) + angle = math.copysign(angle, sinus) + angles[m] = angle + return sorted(points, key=angles.get) + + def faces(self): + """ + Returns the vertices of the faces of a polyhedra. + """ + faces = [] + for polyhedron in self.polyhedra: + vertices = polyhedron.vertices() + for constraint in polyhedron.constraints: + face = [] + for vertex in vertices: + if constraint.subs(vertex.coordinates()) == 0: + face.append(vertex) + if len(face) >= 3: + faces.append(face) + return faces + + def _plot_2d(self, plot=None, **kwargs): + import matplotlib.pyplot as plt + from matplotlib.patches import Polygon + if plot is None: + fig = plt.figure() + plot = fig.add_subplot(1, 1, 1) + xmin, xmax = plot.get_xlim() + ymin, ymax = plot.get_ylim() + for polyhedron in self.polyhedra: + vertices = polyhedron._sort_polygon_2d(polyhedron.vertices()) + xys = [tuple(vertex.values()) for vertex in vertices] + xs, ys = zip(*xys) + xmin, xmax = min(xmin, float(min(xs))), max(xmax, float(max(xs))) + ymin, ymax = min(ymin, float(min(ys))), max(ymax, float(max(ys))) + plot.add_patch(Polygon(xys, closed=True, **kwargs)) + plot.set_xlim(xmin, xmax) + plot.set_ylim(ymin, ymax) + return plot + + def _plot_3d(self, plot=None, **kwargs): + import matplotlib.pyplot as plt + from mpl_toolkits.mplot3d import Axes3D + from mpl_toolkits.mplot3d.art3d import Poly3DCollection + if plot is None: + fig = plt.figure() + axes = Axes3D(fig) + else: + axes = plot + xmin, xmax = axes.get_xlim() + ymin, ymax = axes.get_ylim() + zmin, zmax = axes.get_zlim() + poly_xyzs = [] + for vertices in self.faces(): + vertices = self._sort_polygon_3d(vertices) + vertices.append(vertices[0]) + face_xyzs = [tuple(vertex.values()) for vertex in vertices] + xs, ys, zs = zip(*face_xyzs) + xmin, xmax = min(xmin, float(min(xs))), max(xmax, float(max(xs))) + ymin, ymax = min(ymin, float(min(ys))), max(ymax, float(max(ys))) + zmin, zmax = min(zmin, float(min(zs))), max(zmax, float(max(zs))) + poly_xyzs.append(face_xyzs) + collection = Poly3DCollection(poly_xyzs, **kwargs) + axes.add_collection3d(collection) + axes.set_xlim(xmin, xmax) + axes.set_ylim(ymin, ymax) + axes.set_zlim(zmin, zmax) + return axes + + + def plot(self, plot=None, **kwargs): + """ + Display plot of this set. + """ + if not self.isbounded(): + raise ValueError('domain must be bounded') + elif self.dimension == 2: + return self._plot_2d(plot=plot, **kwargs) + elif self.dimension == 3: + return self._plot_3d(plot=plot, **kwargs) + else: + raise ValueError('polyhedron must be 2 or 3-dimensional') + def __contains__(self, point): for polyhedron in self.polyhedra: if point in polyhedron: @@ -323,6 +522,10 @@ class Domain(GeometricObject): return False def subs(self, symbol, expression=None): + """ + Subsitute the given value into an expression and return the resulting + expression. + """ polyhedra = [polyhedron.subs(symbol, expression) for polyhedron in self.polyhedra] return Domain(*polyhedra) @@ -331,7 +534,7 @@ class Domain(GeometricObject): def _fromislset(cls, islset, symbols): from .polyhedra import Polyhedron islset = libisl.isl_set_remove_divs(islset) - islbsets = isl_set_basic_sets(islset) + islbsets = islhelper.isl_set_basic_sets(islset) libisl.isl_set_free(islset) polyhedra = [] for islbset in islbsets: @@ -439,6 +642,12 @@ class Domain(GeometricObject): strings = [repr(polyhedron) for polyhedron in self.polyhedra] return 'Or({})'.format(', '.join(strings)) + def _repr_latex_(self): + strings = [] + for polyhedron in self.polyhedra: + strings.append('({})'.format(polyhedron._repr_latex_().strip('\$'))) + return '\${}\$'.format(' \\vee '.join(strings)) + @classmethod def fromsympy(cls, expr): import sympy @@ -463,6 +672,9 @@ class Domain(GeometricObject): def And(*domains): + """ + Return the intersection of two sets as a new set. + """ if len(domains) == 0: from .polyhedra import Universe return Universe @@ -470,6 +682,9 @@ def And(*domains): return domains[0].intersection(*domains[1:]) def Or(*domains): + """ + Return the union of sets as a new set. + """ if len(domains) == 0: from .polyhedra import Empty return Empty @@ -477,4 +692,7 @@ def Or(*domains): return domains[0].union(*domains[1:]) def Not(domain): + """ + Returns the complement of this set. + """ return ~domain