X-Git-Url: https://svn.cri.ensmp.fr/git/linpy.git/blobdiff_plain/663316ddc03c19cf06e95bad67fd5ac2bb5e1dfc..c5ec50e02bb591e2ce3b28131424d21c02255f3b:/pypol/polyhedra.py?ds=inline diff --git a/pypol/polyhedra.py b/pypol/polyhedra.py index a08213d..a5048d1 100644 --- a/pypol/polyhedra.py +++ b/pypol/polyhedra.py @@ -1,4 +1,3 @@ - import functools import math import numbers @@ -6,7 +5,7 @@ import numbers from . import islhelper from .islhelper import mainctx, libisl -from .coordinates import Point +from .geometry import GeometricObject, Point, Vector from .linexprs import Expression, Symbol, Rational from .domains import Domain @@ -33,11 +32,7 @@ class Polyhedron(Domain): if inequalities is not None: raise TypeError('too many arguments') return cls.fromstring(equalities) - elif isinstance(equalities, Polyhedron): - if inequalities is not None: - raise TypeError('too many arguments') - return equalities - elif isinstance(equalities, Domain): + elif isinstance(equalities, GeometricObject): if inequalities is not None: raise TypeError('too many arguments') return equalities.aspolyhedron() @@ -76,9 +71,15 @@ class Polyhedron(Domain): return self, def disjoint(self): + """ + Return this set as disjoint. + """ return self def isuniverse(self): + """ + Return true if this set is the Universe set. + """ islbset = self._toislbasicset(self.equalities, self.inequalities, self.symbols) universe = bool(libisl.isl_basic_set_is_universe(islbset)) @@ -86,6 +87,9 @@ class Polyhedron(Domain): return universe def aspolyhedron(self): + """ + Return polyhedral hull of this set. + """ return self def __contains__(self, point): @@ -187,14 +191,27 @@ class Polyhedron(Domain): else: strings = [] for equality in self.equalities: - strings.append('0 == {}'.format(equality)) + strings.append('Eq({}, 0)'.format(equality)) for inequality in self.inequalities: - strings.append('0 <= {}'.format(inequality)) + strings.append('Ge({}, 0)'.format(inequality)) if len(strings) == 1: return strings[0] else: 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)) + @classmethod def fromsympy(cls, expr): domain = Domain.fromsympy(expr) @@ -211,16 +228,26 @@ 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) + @classmethod def _sort_polygon_2d(cls, points): if len(points) <= 3: return points - o = sum((Vector(point) for point in points)) / len(points) - o = Point(o.coordinates()) + o = cls._polygon_inner_point(points) angles = {} for m in points: om = Vector(o, m) - dx, dy = (coordinate for symbol, coordinates in om.coordinates()) + dx, dy = (coordinate for symbol, coordinate in om.coordinates()) angle = math.atan2(dy, dx) angles[m] = angle return sorted(points, key=angles.get) @@ -229,102 +256,159 @@ class Polyhedron(Domain): def _sort_polygon_3d(cls, points): if len(points) <= 3: return points - o = sum((Vector(point) for point in points)) / len(points) - o = Point(o.coordinates()) - a, b = points[:2] + o = cls._polygon_inner_point(points) + a = points[0] oa = Vector(o, a) - ob = Vector(o, b) norm_oa = oa.norm() - u = (oa.cross(ob)).asunit() + 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 = oa.dot(om) / normprod + 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 plot(self): + 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): + from matplotlib import pylab import matplotlib.pyplot as plt - from matplotlib.path import Path - import matplotlib.patches as patches - - if len(self.symbols)> 3: - raise TypeError - - elif len(self.symbols) == 2: - verts = self.vertices() - points = [] - codes = [Path.MOVETO] - for vert in verts: - pairs = () - for sym in sorted(vert, key=Symbol.sortkey): - num = vert.get(sym) - pairs = pairs + (num,) - points.append(pairs) - points.append((0.0, 0.0)) - num = len(points) - while num > 2: - codes.append(Path.LINETO) - num = num - 1 - else: - codes.append(Path.CLOSEPOLY) - path = Path(points, codes) + from matplotlib.axes import Axes + 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() - ax = fig.add_subplot(111) - patch = patches.PathPatch(path, facecolor='blue', lw=2) - ax.add_patch(patch) - ax.set_xlim(-5,5) - ax.set_ylim(-5,5) - plt.show() - - elif len(self.symbols)==3: - return 0 - - return points + plot = fig.add_subplot(1, 1, 1) + xs, ys = zip(*xys) + plot.set_xlim(float(min(xs)), float(max(xs))) + plot.set_ylim(float(min(ys)), float(max(ys))) + 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) + xmin, xmax = float('inf'), float('-inf') + ymin, ymax = float('inf'), float('-inf') + zmin, zmax = float('inf'), float('-inf') + else: + axes = plot + 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] + if plot is None: + 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) + if plot is None: + 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 _polymorphic(func): @functools.wraps(func) def wrapper(left, right): - if isinstance(left, numbers.Rational): - left = Rational(left) - elif not isinstance(left, Expression): - raise TypeError('left must be a a rational number ' - 'or a linear expression') - if isinstance(right, numbers.Rational): - right = Rational(right) - elif not isinstance(right, Expression): - raise TypeError('right must be a a rational number ' - 'or a linear expression') + if not isinstance(left, Expression): + if isinstance(left, numbers.Rational): + left = Rational(left) + else: + raise TypeError('left must be a a rational number ' + 'or a linear expression') + if not isinstance(right, Expression): + if isinstance(right, numbers.Rational): + right = Rational(right) + else: + raise TypeError('right must be a a rational number ' + 'or a linear expression') return func(left, right) return wrapper @_polymorphic def Lt(left, right): + """ + Return true if the first set is less than the second. + """ return Polyhedron([], [right - left - 1]) @_polymorphic def Le(left, right): + """ + Return true the first set is less than or equal to the second. + """ return Polyhedron([], [right - left]) @_polymorphic def Eq(left, right): + """ + Return true if the sets are equal. + """ return Polyhedron([left - right], []) @_polymorphic def Ne(left, right): + """ + Return true if the sets are NOT equal. + """ return ~Eq(left, right) @_polymorphic def Gt(left, right): + """ + Return true if the 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. + """ return Polyhedron([], [left - right])