X-Git-Url: https://scm.cri.ensmp.fr/git/linpy.git/blobdiff_plain/8332ae24f41a1f2bbba78597cc9e412ef9935ae8..1695c920d030869b3a842736fe5bcf963f2ffc52:/pypol/polyhedra.py diff --git a/pypol/polyhedra.py b/pypol/polyhedra.py index 69ed2b2..5d1bfa1 100644 --- a/pypol/polyhedra.py +++ b/pypol/polyhedra.py @@ -71,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)) @@ -81,6 +87,9 @@ class Polyhedron(Domain): return universe def aspolyhedron(self): + """ + Return polyhedral hull of this set. + """ return self def __contains__(self, point): @@ -182,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) @@ -250,7 +272,7 @@ class Polyhedron(Domain): 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) @@ -269,83 +291,137 @@ class Polyhedron(Domain): return faces def plot(self): + """ + Display 3D plot of set. + """ 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) - 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() + import pylab + points = [] + for verts in self.vertices(): + pairs=() + for coordinate, point in verts.coordinates(): + pairs = pairs + (float(point),) + points.append(pairs) + cent=(sum([p[0] for p in points])/len(points),sum([p[1] for p in points])/len(points)) + points.sort(key=lambda p: math.atan2(p[1]-cent[1],p[0]-cent[0])) + pylab.scatter([p[0] for p in points],[p[1] for p in points]) + pylab.gca().add_patch(patches.Polygon(points,closed=True,fill=True)) + pylab.grid() + pylab.show() elif len(self.symbols)==3: - return 0 - + from mpl_toolkits.mplot3d import Axes3D + from mpl_toolkits.mplot3d.art3d import Poly3DCollection + faces = self.faces() + fig = plt.figure() + ax = Axes3D(fig) + for face in faces: + points = [] + vertices = Polyhedron._sort_polygon_3d(face) + for verts in vertices: + pairs=() + for coordinate, point in verts.coordinates(): + pairs = pairs + (float(point),) + points.append(pairs) + collection = Poly3DCollection([points], alpha=0.7) + face_color = [0.5, 0.5, 1] # alternative: matplotlib.colors.rgb2hex([0.5, 0.5, 1]) + collection.set_facecolor(face_color) + ax.add_collection3d(collection) + ax.set_xlabel('X') + ax.set_xlim(0, 5) + ax.set_ylabel('Y') + ax.set_ylim(0, 5) + ax.set_zlabel('Z') + ax.set_zlim(0, 5) + plt.grid() + plt.show() return points - + + @classmethod + def limit(cls, faces, variable, lim): + sym = [] + if variable is 'x': + n = 0 + elif variable is 'y': + n = 1 + elif variable is 'z': + n = 2 + for face in faces: + for vert in face: + coordinates = vert.coordinates() + for point in enumerate(coordinates): + coordinates.get(n) + sym.append(points) + if lim == 0: + value = min(sym) + else: + value = max(sym) + return value 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])