Fix error message

[linpy.git] / linpy / domains.py

diff --git a/linpy/domains.py b/linpy/domains.py
index 45f55a5..a431a02 100644 (file)
--- a/linpy/domains.py
+++ b/linpy/domains.py
@@ -23,14 +23,16 @@ import math
 from fractions import Fraction
 
 from . import islhelper
 from fractions import Fraction
 
 from . import islhelper

-from .islhelper import mainctx, libisl
-from .linexprs import LinExpr, Symbol

 from .geometry import GeometricObject, Point, Vector
 from .geometry import GeometricObject, Point, Vector

+from .islhelper import libisl
+from .linexprs import LinExpr, Symbol

 
 
 __all__ = [
 
 
 __all__ = [

+    'And',

     'Domain',
     'Domain',

-    'And', 'Or', 'Not',
+    'Not',
+    'Or',

 ]
 
 
 ]
 
 


@@ -84,7 +86,7 @@ class Domain(GeometricObject):
                 return argument.aspolyhedron()
             else:
                 raise TypeError('argument must be a string '
                 return argument.aspolyhedron()
             else:
                 raise TypeError('argument must be a string '

-                    'or a GeometricObject instance')
+                                'or a GeometricObject instance')

         else:
             for polyhedron in polyhedra:
                 if not isinstance(polyhedron, Polyhedron):
         else:
             for polyhedron in polyhedra:
                 if not isinstance(polyhedron, Polyhedron):


@@ -235,7 +237,7 @@ class Domain(GeometricObject):
         Return an equivalent domain, whose polyhedra are disjoint.
         """
         islset = self._toislset(self.polyhedra, self.symbols)
         Return an equivalent domain, whose polyhedra are disjoint.
         """
         islset = self._toislset(self.polyhedra, self.symbols)

-        islset = libisl.isl_set_make_disjoint(mainctx, islset)
+        islset = libisl.isl_set_make_disjoint(islset)

         return self._fromislset(islset, self.symbols)
 
     def coalesce(self):
         return self._fromislset(islset, self.symbols)
 
     def coalesce(self):


@@ -289,11 +291,12 @@ class Domain(GeometricObject):
             if symbol in symbols:
                 n += 1
             elif n > 0:
             if symbol in symbols:
                 n += 1
             elif n > 0:

-                islset = libisl.isl_set_project_out(islset,
-                    libisl.isl_dim_set, index + 1, n)
+                islset = libisl.isl_set_project_out(
+                    islset, libisl.isl_dim_set, index + 1, n)

                 n = 0
         if n > 0:
                 n = 0
         if n > 0:

-            islset = libisl.isl_set_project_out(islset, libisl.isl_dim_set, 0, n)
+            islset = libisl.isl_set_project_out(
+                islset, libisl.isl_dim_set, 0, n)

         symbols = [symbol for symbol in self.symbols if symbol not in symbols]
         return Domain._fromislset(islset, symbols)
 
         symbols = [symbol for symbol in self.symbols if symbol not in symbols]
         return Domain._fromislset(islset, symbols)
 


@@ -309,8 +312,8 @@ class Domain(GeometricObject):
             raise ValueError('domain must be non-empty')
         point = {}
         for index, symbol in enumerate(self.symbols):
             raise ValueError('domain must be non-empty')
         point = {}
         for index, symbol in enumerate(self.symbols):

-            coordinate = libisl.isl_point_get_coordinate_val(islpoint,
-                libisl.isl_dim_set, index)
+            coordinate = libisl.isl_point_get_coordinate_val(
+                islpoint, libisl.isl_dim_set, index)

             coordinate = islhelper.isl_val_to_int(coordinate)
             point[symbol] = coordinate
         libisl.isl_point_free(islpoint)
             coordinate = islhelper.isl_val_to_int(coordinate)
             point[symbol] = coordinate
         libisl.isl_point_free(islpoint)


@@ -402,12 +405,11 @@ class Domain(GeometricObject):
         Return the vertices of the domain, as a list of rational instances of
         Point.
         """
         Return the vertices of the domain, as a list of rational instances of
         Point.
         """

-        from .polyhedra import Polyhedron

         if not self.isbounded():
             raise ValueError('domain must be bounded')
         islbset = self._toislbasicset(self.equalities, self.inequalities,
         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);
+                                      self.symbols)
+        vertices = libisl.isl_basic_set_compute_vertices(islbset)

         vertices = islhelper.isl_vertices_vertices(vertices)
         points = []
         for vertex in vertices:
         vertices = islhelper.isl_vertices_vertices(vertices)
         points = []
         for vertex in vertices:


@@ -416,11 +418,13 @@ class Domain(GeometricObject):
             if self._RE_COORDINATE is None:
                 constraints = islhelper.isl_basic_set_constraints(expression)
                 for constraint in constraints:
             if self._RE_COORDINATE is None:
                 constraints = islhelper.isl_basic_set_constraints(expression)
                 for constraint in constraints:

-                    constant = libisl.isl_constraint_get_constant_val(constraint)
+                    constant = libisl.isl_constraint_get_constant_val(
+                        constraint)

                     constant = islhelper.isl_val_to_int(constant)
                     for index, symbol in enumerate(self.symbols):
                     constant = islhelper.isl_val_to_int(constant)
                     for index, symbol in enumerate(self.symbols):

-                        coefficient = libisl.isl_constraint_get_coefficient_val(constraint,
-                            libisl.isl_dim_set, index)
+                        coefficient = \
+                            libisl.isl_constraint_get_coefficient_val(
+                                constraint, libisl.isl_dim_set, index)

                         coefficient = islhelper.isl_val_to_int(coefficient)
                         if coefficient != 0:
                             coordinate = -Fraction(constant, coefficient)
                         coefficient = islhelper.isl_val_to_int(coefficient)
                         if coefficient != 0:
                             coordinate = -Fraction(constant, coefficient)


@@ -431,7 +435,8 @@ class Domain(GeometricObject):
                 for symbol, match in zip(self.symbols, matches):
                     numerator = int(match.group('num'))
                     denominator = match.group('den')
                 for symbol, match in zip(self.symbols, matches):
                     numerator = int(match.group('num'))
                     denominator = match.group('den')

-                    denominator = 1 if denominator is None else int(denominator)
+                    denominator = \
+                        1 if denominator is None else int(denominator)

                     coordinate = Fraction(numerator, denominator)
                     coordinates.append((symbol, coordinate))
             points.append(Point(coordinates))
                     coordinate = Fraction(numerator, denominator)
                     coordinates.append((symbol, coordinate))
             points.append(Point(coordinates))


@@ -440,20 +445,19 @@ class Domain(GeometricObject):
     def points(self):
         """
         Return the integer points of a bounded domain, as a list of integer
     def points(self):
         """
         Return the integer points of a bounded domain, as a list of integer

-        instances of Point. If the domain is not bounded, a ValueError exception
-        is raised.
+        instances of Point. If the domain is not bounded, a ValueError
+        exception is raised.

         """
         if not self.isbounded():
             raise ValueError('domain must be bounded')
         """
         if not self.isbounded():
             raise ValueError('domain must be bounded')

-        from .polyhedra import Universe, Eq

         islset = self._toislset(self.polyhedra, self.symbols)
         islpoints = islhelper.isl_set_points(islset)
         points = []
         for islpoint in islpoints:
             coordinates = {}
             for index, symbol in enumerate(self.symbols):
         islset = self._toislset(self.polyhedra, self.symbols)
         islpoints = islhelper.isl_set_points(islset)
         points = []
         for islpoint in islpoints:
             coordinates = {}
             for index, symbol in enumerate(self.symbols):

-                coordinate = libisl.isl_point_get_coordinate_val(islpoint,
-                    libisl.isl_dim_set, index)
+                coordinate = libisl.isl_point_get_coordinate_val(
+                    islpoint, libisl.isl_dim_set, index)

                 coordinate = islhelper.isl_val_to_int(coordinate)
                 coordinates[symbol] = coordinate
             points.append(Point(coordinates))
                 coordinate = islhelper.isl_val_to_int(coordinate)
                 coordinates[symbol] = coordinate
             points.append(Point(coordinates))


@@ -600,7 +604,7 @@ class Domain(GeometricObject):
         elif self.dimension == 3:
             return self._plot_3d(plot=plot, **kwargs)
         else:
         elif self.dimension == 3:
             return self._plot_3d(plot=plot, **kwargs)
         else:

-            raise ValueError('domain must be 2 or 3-dimensional')
+            raise ValueError('domain must be two or three-dimensional')

 
     def subs(self, symbol, expression=None):
         """
 
     def subs(self, symbol, expression=None):
         """


@@ -610,7 +614,7 @@ class Domain(GeometricObject):
         similar to LinExpr.subs().
         """
         polyhedra = [polyhedron.subs(symbol, expression)
         similar to LinExpr.subs().
         """
         polyhedra = [polyhedron.subs(symbol, expression)

-            for polyhedron in self.polyhedra]
+                     for polyhedron in self.polyhedra]

         return Domain(*polyhedra)
 
     @classmethod
         return Domain(*polyhedra)
 
     @classmethod


@@ -638,12 +642,12 @@ class Domain(GeometricObject):
     @classmethod
     def _toislset(cls, polyhedra, symbols):
         polyhedron = polyhedra[0]
     @classmethod
     def _toislset(cls, polyhedra, symbols):
         polyhedron = polyhedra[0]

-        islbset = polyhedron._toislbasicset(polyhedron.equalities,
-            polyhedron.inequalities, symbols)
+        islbset = polyhedron._toislbasicset(
+            polyhedron.equalities, polyhedron.inequalities, symbols)

         islset1 = libisl.isl_set_from_basic_set(islbset)
         for polyhedron in polyhedra[1:]:
         islset1 = libisl.isl_set_from_basic_set(islbset)
         for polyhedron in polyhedra[1:]:

-            islbset = polyhedron._toislbasicset(polyhedron.equalities,
-                polyhedron.inequalities, symbols)
+            islbset = polyhedron._toislbasicset(
+                polyhedron.equalities, polyhedron.inequalities, symbols)

             islset2 = libisl.isl_set_from_basic_set(islbset)
             islset1 = libisl.isl_set_union(islset1, islset2)
         return islset1
             islset2 = libisl.isl_set_from_basic_set(islbset)
             islset1 = libisl.isl_set_union(islset1, islset2)
         return islset1


@@ -754,7 +758,7 @@ class Domain(GeometricObject):
         Convert the domain to a SymPy expression.
         """
         import sympy
         Convert the domain to a SymPy expression.
         """
         import sympy

-        polyhedra = [polyhedron.tosympy() for polyhedron in polyhedra]
+        polyhedra = [polyhedron.tosympy() for polyhedron in self.polyhedra]

         return sympy.Or(*polyhedra)
 
 
         return sympy.Or(*polyhedra)
 
 


@@ -768,6 +772,7 @@ def And(*domains):
     else:
         return domains[0].intersection(*domains[1:])
 
     else:
         return domains[0].intersection(*domains[1:])
 

+

 def Or(*domains):
     """
     Create the union domain of the domains given in arguments.
 def Or(*domains):
     """
     Create the union domain of the domains given in arguments.


@@ -778,6 +783,7 @@ def Or(*domains):
     else:
         return domains[0].union(*domains[1:])
 
     else:
         return domains[0].union(*domains[1:])
 

+

 def Not(domain):
     """
     Create the complementary domain of the domain given in argument.
 def Not(domain):
     """
     Create the complementary domain of the domain given in argument.