New example: Menger sponge, to be plotted

[linpy.git] / pypol / polyhedra.py

diff --git a/pypol/polyhedra.py b/pypol/polyhedra.py
index e745d7d..5d1bfa1 100644 (file)
--- a/pypol/polyhedra.py
+++ b/pypol/polyhedra.py
@@ -71,9 +71,15 @@ class Polyhedron(Domain):
         return self,
 
     def disjoint(self):
         return self,
 
     def disjoint(self):

+        """
+        Return this set as disjoint.
+        """

         return self
 
     def isuniverse(self):
         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))
         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 universe
 
     def aspolyhedron(self):

+        """
+        Return polyhedral hull of this set.
+        """

         return self
 
     def __contains__(self, point):
         return self
 
     def __contains__(self, point):


@@ -182,14 +191,27 @@ class Polyhedron(Domain):
         else:
             strings = []
             for equality in self.equalities:
         else:
             strings = []
             for equality in self.equalities:

-                strings.append('0 == {}'.format(equality))
+                strings.append('Eq({}, 0)'.format(equality))

             for inequality in self.inequalities:
             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))
 
             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)
     @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()
         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)
             sinus = u.dot(oa.cross(om)) / normprod
             angle = math.acos(cosinus)
             angle = math.copysign(angle, sinus)


@@ -269,44 +291,78 @@ class Polyhedron(Domain):
         return faces
 
     def plot(self):
         return faces
 
     def plot(self):

+        """
+        Display 3D plot of set. 
+        """

         import matplotlib.pyplot as plt
         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:
         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:
 
         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
         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 _polymorphic(func):
     @functools.wraps(func)


@@ -328,26 +384,44 @@ def _polymorphic(func):
 
 @_polymorphic
 def Lt(left, right):
 
 @_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 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 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 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 ~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 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])
 
 
     return Polyhedron([], [left - right])