X-Git-Url: https://scm.cri.mines-paristech.fr/git/linpy.git/blobdiff_plain/22d69753489bdafa3401e54be79b58d9e94225a3..25ce908cffca380f930182a77c1e5a4491042a1c:/pypol/polyhedra.py?ds=inline diff --git a/pypol/polyhedra.py b/pypol/polyhedra.py index 7202bec..fe143d4 100644 --- a/pypol/polyhedra.py +++ b/pypol/polyhedra.py @@ -5,8 +5,8 @@ import numbers from . import islhelper from .islhelper import mainctx, libisl -from .geometry import GeometricObject, Point, Vector -from .linexprs import Expression, Symbol, Rational +from .geometry import GeometricObject, Point +from .linexprs import Expression, Rational from .domains import Domain @@ -56,14 +56,23 @@ class Polyhedron(Domain): @property def equalities(self): + """ + Return a list of the equalities in a set. + """ return self._equalities @property def inequalities(self): + """ + Return a list of the inequalities in a set. + """ return self._inequalities @property def constraints(self): + """ + Return ta list of the constraints of a set. + """ return self._constraints @property @@ -72,13 +81,13 @@ class Polyhedron(Domain): def disjoint(self): """ - Return this set as disjoint. + Return a set as disjoint. """ return self def isuniverse(self): """ - Return true if this set is the Universe set. + Return true if a set is the Universe set. """ islbset = self._toislbasicset(self.equalities, self.inequalities, self.symbols) @@ -88,7 +97,7 @@ class Polyhedron(Domain): def aspolyhedron(self): """ - Return polyhedral hull of this set. + Return polyhedral hull of a set. """ return self @@ -106,12 +115,40 @@ class Polyhedron(Domain): return True def subs(self, symbol, expression=None): + """ + Subsitute the given value into an expression and return the resulting expression. + """ equalities = [equality.subs(symbol, expression) for equality in self.equalities] inequalities = [inequality.subs(symbol, expression) for inequality in self.inequalities] return Polyhedron(equalities, inequalities) + def _asinequalities(self): + inequalities = list(self.equalities) + inequalities.extend([-expression for expression in self.equalities]) + inequalities.extend(self.inequalities) + return inequalities + + def widen(self, other): + if not isinstance(other, Polyhedron): + raise ValueError('argument must be a Polyhedron instance') + inequalities1 = self._asinequalities() + inequalities2 = other._asinequalities() + inequalities = [] + for inequality1 in inequalities1: + if other <= Polyhedron(inequalities=[inequality1]): + inequalities.append(inequality1) + for inequality2 in inequalities2: + for i in range(len(inequalities1)): + inequalities3 = inequalities1[:i] + inequalities[i + 1:] + inequalities3.append(inequality2) + polyhedron3 = Polyhedron(inequalities=inequalities3) + if self == polyhedron3: + inequalities.append(inequality2) + break + return Polyhedron(inequalities=inequalities) + @classmethod def _fromislbasicset(cls, islbset, symbols): islconstraints = islhelper.isl_basic_set_constraints(islbset) @@ -184,42 +221,39 @@ class Polyhedron(Domain): return domain def __repr__(self): - if self.isempty(): - return 'Empty' - elif self.isuniverse(): - return 'Universe' + strings = [] + for equality in self.equalities: + strings.append('Eq({}, 0)'.format(equality)) + for inequality in self.inequalities: + strings.append('Ge({}, 0)'.format(inequality)) + if len(strings) == 1: + return strings[0] else: - strings = [] - for equality in self.equalities: - strings.append('Eq({}, 0)'.format(equality)) - for inequality in self.inequalities: - strings.append('Ge({}, 0)'.format(inequality)) - if len(strings) == 1: - return strings[0] - else: - return 'And({})'.format(', '.join(strings)) + return 'And({})'.format(', '.join(strings)) + def _repr_latex_(self): - if self.isempty(): - return '$$\\emptyset$$' - elif self.isuniverse(): - return '$$\\Omega$$' - else: - strings = [] - for equality in self.equalities: - strings.append('{} = 0'.format(equality._repr_latex_().strip('$'))) - for inequality in self.inequalities: - strings.append('{} \\ge 0'.format(inequality._repr_latex_().strip('$'))) - return '$${}$$'.format(' \\wedge '.join(strings)) + strings = [] + for equality in self.equalities: + strings.append('{} = 0'.format(equality._repr_latex_().strip('$'))) + for inequality in self.inequalities: + strings.append('{} \\ge 0'.format(inequality._repr_latex_().strip('$'))) + return '$${}$$'.format(' \\wedge '.join(strings)) @classmethod def fromsympy(cls, expr): + """ + Convert a sympy object to an expression. + """ domain = Domain.fromsympy(expr) if not isinstance(domain, Polyhedron): raise ValueError('non-polyhedral expression: {!r}'.format(expr)) return domain def tosympy(self): + """ + Return an expression as a sympy object. + """ import sympy constraints = [] for equality in self.equalities: @@ -228,127 +262,53 @@ class Polyhedron(Domain): constraints.append(sympy.Ge(inequality.tosympy(), 0)) return sympy.And(*constraints) - @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) +class EmptyType(Polyhedron): - @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) + __slots__ = Polyhedron.__slots__ - @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): - vertices = self.vertices() - faces = [] - for constraint in self.constraints: - face = [] - for vertex in vertices: - if constraint.subs(vertex.coordinates()) == 0: - face.append(vertex) - faces.append(face) - return faces - - def _plot_2d(self, plot=None, **kwargs): - import matplotlib.pyplot as plt - from matplotlib.patches import Polygon - vertices = self._sort_polygon_2d(self.vertices()) - xys = [tuple(vertex.values()) for vertex in vertices] - if plot is None: - fig = plt.figure() - plot = fig.add_subplot(1, 1, 1) - xmin, xmax = plot.get_xlim() - ymin, ymax = plot.get_xlim() - 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.set_xlim(xmin, xmax) - plot.set_ylim(ymin, ymax) - plot.add_patch(Polygon(xys, closed=True, **kwargs)) - 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_xlim() - zmin, zmax = axes.get_xlim() - poly_xyzs = [] - for vertices in self.faces(): - if len(vertices) == 0: - continue - vertices = Polyhedron._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 3D plot of set. - """ - if 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 __new__(cls): + self = object().__new__(cls) + self._equalities = (Rational(1),) + self._inequalities = () + self._constraints = self._equalities + self._symbols = () + self._dimension = 0 + return self + + def widen(self, other): + if not isinstance(other, Polyhedron): + raise ValueError('argument must be a Polyhedron instance') + return other + + def __repr__(self): + return 'Empty' + + def _repr_latex_(self): + return '$$\\emptyset$$' + +Empty = EmptyType() + + +class UniverseType(Polyhedron): + + __slots__ = Polyhedron.__slots__ + + def __new__(cls): + self = object().__new__(cls) + self._equalities = () + self._inequalities = () + self._constraints = () + self._symbols = () + self._dimension = () + return self + + def __repr__(self): + return 'Universe' + + def _repr_latex_(self): + return '$$\\Omega$$' + +Universe = UniverseType() def _polymorphic(func): @@ -372,46 +332,42 @@ def _polymorphic(func): @_polymorphic def Lt(left, right): """ - Return true if the first set is less than the second. + Assert first set is less than the second set. """ return Polyhedron([], [right - left - 1]) @_polymorphic def Le(left, right): """ - Return true the first set is less than or equal to the second. + Assert first set is less than or equal to the second set. """ return Polyhedron([], [right - left]) @_polymorphic def Eq(left, right): """ - Return true if the sets are equal. + Assert first set is equal to the second set. """ return Polyhedron([left - right], []) @_polymorphic def Ne(left, right): """ - Return true if the sets are NOT equal. + Assert first set is not equal to the second set. """ return ~Eq(left, right) @_polymorphic def Gt(left, right): """ - Return true if the first set is greater than the second set. + Assert first set is greater than the second set. """ return Polyhedron([], [left - right - 1]) @_polymorphic def Ge(left, right): """ - Return true if the first set is greater than or equal the second set. + Assert first set is greater than or equal to the second set. """ return Polyhedron([], [left - right]) - -Empty = Eq(1, 0) - -Universe = Polyhedron([])