index 4cd46a4..581a065 100644 (file)
@@ -24,7 +24,7 @@ from fractions import Fraction

from . import islhelper
from .islhelper import mainctx, libisl
-from .linexprs import LinExpr, Symbol, Rational
+from .linexprs import LinExpr, Symbol
from .geometry import GeometricObject, Point, Vector

@@ -38,7 +38,7 @@ __all__ = [
class Domain(GeometricObject):
"""
A domain is a union of polyhedra. Unlike polyhedra, domains allow exact
-    computation of union and complementary operations.
+    computation of union, subtraction and complementary operations.

A domain with a unique polyhedron is automatically subclassed as a
Polyhedron instance.
@@ -161,18 +161,22 @@ class Domain(GeometricObject):
"""
Return True if two domains are equal.
"""
-        symbols = self._xsymbols([self, other])
-        islset1 = self._toislset(self.polyhedra, symbols)
-        islset2 = other._toislset(other.polyhedra, symbols)
-        equal = bool(libisl.isl_set_is_equal(islset1, islset2))
-        libisl.isl_set_free(islset1)
-        libisl.isl_set_free(islset2)
-        return equal
+        if isinstance(other, Domain):
+            symbols = self._xsymbols([self, other])
+            islset1 = self._toislset(self.polyhedra, symbols)
+            islset2 = other._toislset(other.polyhedra, symbols)
+            equal = bool(libisl.isl_set_is_equal(islset1, islset2))
+            libisl.isl_set_free(islset1)
+            libisl.isl_set_free(islset2)
+            return equal
+        return NotImplemented

def isdisjoint(self, other):
"""
Return True if two domains have a null intersection.
"""
+        if not isinstance(other, Domain):
+            raise TypeError('other must be a Domain instance')
symbols = self._xsymbols([self, other])
islset1 = self._toislset(self.polyhedra, symbols)
islset2 = self._toislset(other.polyhedra, symbols)
@@ -185,29 +189,33 @@ class Domain(GeometricObject):
"""
Report whether another domain contains the domain.
"""
-        symbols = self._xsymbols([self, other])
-        islset1 = self._toislset(self.polyhedra, symbols)
-        islset2 = self._toislset(other.polyhedra, symbols)
-        equal = bool(libisl.isl_set_is_subset(islset1, islset2))
-        libisl.isl_set_free(islset1)
-        libisl.isl_set_free(islset2)
-        return equal
+        return self < other

def __le__(self, other):
-        return self.issubset(other)
+        if isinstance(other, Domain):
+            symbols = self._xsymbols([self, other])
+            islset1 = self._toislset(self.polyhedra, symbols)
+            islset2 = self._toislset(other.polyhedra, symbols)
+            equal = bool(libisl.isl_set_is_subset(islset1, islset2))
+            libisl.isl_set_free(islset1)
+            libisl.isl_set_free(islset2)
+            return equal
+        return NotImplemented
__le__.__doc__ = issubset.__doc__

def __lt__(self, other):
"""
Report whether another domain is contained within the domain.
"""
-        symbols = self._xsymbols([self, other])
-        islset1 = self._toislset(self.polyhedra, symbols)
-        islset2 = self._toislset(other.polyhedra, symbols)
-        equal = bool(libisl.isl_set_is_strict_subset(islset1, islset2))
-        libisl.isl_set_free(islset1)
-        libisl.isl_set_free(islset2)
-        return equal
+        if isinstance(other, Domain):
+            symbols = self._xsymbols([self, other])
+            islset1 = self._toislset(self.polyhedra, symbols)
+            islset2 = self._toislset(other.polyhedra, symbols)
+            equal = bool(libisl.isl_set_is_strict_subset(islset1, islset2))
+            libisl.isl_set_free(islset1)
+            libisl.isl_set_free(islset2)
+            return equal
+        return NotImplemented

def complement(self):
"""
@@ -270,6 +278,10 @@ class Domain(GeometricObject):
Project out the sequence of symbols given in arguments, and return the
resulting domain.
"""
+        symbols = list(symbols)
+        for symbol in symbols:
+            if not isinstance(symbol, Symbol):
+                raise TypeError('symbols must be Symbol instances')
islset = self._toislset(self.polyhedra, self.symbols)
n = 0
for index, symbol in reversed(list(enumerate(self.symbols))):
@@ -308,17 +320,19 @@ class Domain(GeometricObject):
Return the intersection of two or more domains as a new domain. As an
alternative, function And() can be used.
"""
-        if len(others) == 0:
-            return self
-        symbols = self._xsymbols((self,) + others)
-        islset1 = self._toislset(self.polyhedra, symbols)
+        result = self
for other in others:
-            islset2 = other._toislset(other.polyhedra, symbols)
-            islset1 = libisl.isl_set_intersect(islset1, islset2)
-        return self._fromislset(islset1, symbols)
+            result &= other
+        return result

def __and__(self, other):
-        return self.intersection(other)
+        if isinstance(other, Domain):
+            symbols = self._xsymbols([self, other])
+            islset1 = self._toislset(self.polyhedra, symbols)
+            islset2 = other._toislset(other.polyhedra, symbols)
+            islset = libisl.isl_set_intersect(islset1, islset2)
+            return self._fromislset(islset, symbols)
+        return NotImplemented
__and__.__doc__ = intersection.__doc__

def union(self, *others):
@@ -326,35 +340,39 @@ class Domain(GeometricObject):
Return the union of two or more domains as a new domain. As an
alternative, function Or() can be used.
"""
-        if len(others) == 0:
-            return self
-        symbols = self._xsymbols((self,) + others)
-        islset1 = self._toislset(self.polyhedra, symbols)
+        result = self
for other in others:
-            islset2 = other._toislset(other.polyhedra, symbols)
-            islset1 = libisl.isl_set_union(islset1, islset2)
-        return self._fromislset(islset1, symbols)
+            result |= other
+        return result

def __or__(self, other):
-        return self.union(other)
+        if isinstance(other, Domain):
+            symbols = self._xsymbols([self, other])
+            islset1 = self._toislset(self.polyhedra, symbols)
+            islset2 = other._toislset(other.polyhedra, symbols)
+            islset = libisl.isl_set_union(islset1, islset2)
+            return self._fromislset(islset, symbols)
+        return NotImplemented
__or__.__doc__ = union.__doc__

-        return self.union(other)
+        return self | other

def difference(self, other):
"""
Return the difference of two domains as a new domain.
"""
-        symbols = self._xsymbols([self, other])
-        islset1 = self._toislset(self.polyhedra, symbols)
-        islset2 = other._toislset(other.polyhedra, symbols)
-        islset = libisl.isl_set_subtract(islset1, islset2)
-        return self._fromislset(islset, symbols)
+        return self - other

def __sub__(self, other):
-        return self.difference(other)
+        if isinstance(other, Domain):
+            symbols = self._xsymbols([self, other])
+            islset1 = self._toislset(self.polyhedra, symbols)
+            islset2 = other._toislset(other.polyhedra, symbols)
+            islset = libisl.isl_set_subtract(islset1, islset2)
+            return self._fromislset(islset, symbols)
+        return NotImplemented
__sub__.__doc__ = difference.__doc__

def lexmin(self):
@@ -373,7 +391,10 @@ class Domain(GeometricObject):
islset = libisl.isl_set_lexmax(islset)
return self._fromislset(islset, self.symbols)

-    _RE_COORDINATE = re.compile(r'\((?P<num>\-?\d+)\)(/(?P<den>\d+))?')
+    if islhelper.isl_version >= '0.13':
+        _RE_COORDINATE = re.compile(r'\((?P<num>\-?\d+)\)(/(?P<den>\d+))?')
+    else:
+        _RE_COORDINATE = None

def vertices(self):
"""
@@ -391,7 +412,7 @@ class Domain(GeometricObject):
for vertex in vertices:
expr = libisl.isl_vertex_get_expr(vertex)
coordinates = []
-            if islhelper.isl_version < '0.13':
+            if self._RE_COORDINATE is None:
constraints = islhelper.isl_basic_set_constraints(expr)
for constraint in constraints:
constant = libisl.isl_constraint_get_constant_val(constraint)
@@ -578,7 +599,7 @@ class Domain(GeometricObject):
elif self.dimension == 3:
return self._plot_3d(plot=plot, **kwargs)
else:
-            raise ValueError('polyhedron must be 2 or 3-dimensional')
+            raise ValueError('domain must be 2 or 3-dimensional')

def subs(self, symbol, expression=None):
"""
@@ -682,17 +703,17 @@ class Domain(GeometricObject):
Create a domain from a string. Raise SyntaxError if the string is not
properly formatted.
"""
-        # remove curly brackets
+        # Remove curly brackets.
string = cls._RE_BRACES.sub(r'', string)
-        # replace '=' by '=='
+        # Replace '=' by '=='.
string = cls._RE_EQ.sub(r'\1==\2', string)
-        # replace 'and', 'or', 'not'
+        # Replace 'and', 'or', 'not'.
string = cls._RE_AND.sub(r' & ', string)
string = cls._RE_OR.sub(r' | ', string)
string = cls._RE_NOT.sub(r' ~', string)
-        # add implicit multiplication operators, e.g. '5x' -> '5*x'
+        # Add implicit multiplication operators, e.g. '5x' -> '5*x'.
string = cls._RE_NUM_VAR.sub(r'\1*\2', string)
-        # add parentheses to force precedence
+        # Add parentheses to force precedence.
tokens = cls._RE_OPERATORS.split(string)
for i, token in enumerate(tokens):
if i % 2 == 0:
@@ -716,7 +737,7 @@ class Domain(GeometricObject):
@classmethod
def fromsympy(cls, expr):
"""
-        Create a domain from a sympy expression.
+        Create a domain from a SymPy expression.
"""
import sympy
from .polyhedra import Lt, Le, Eq, Ne, Ge, Gt
@@ -735,7 +756,7 @@ class Domain(GeometricObject):

def tosympy(self):
"""
-        Convert the domain to a sympy expression.
+        Convert the domain to a SymPy expression.
"""
import sympy
polyhedra = [polyhedron.tosympy() for polyhedron in polyhedra]
@@ -751,7 +772,6 @@ def And(*domains):
return Universe
else:
return domains[0].intersection(*domains[1:])
-And.__doc__ = Domain.intersection.__doc__

def Or(*domains):
"""
@@ -762,11 +782,9 @@ def Or(*domains):
return Empty
else:
return domains[0].union(*domains[1:])
-Or.__doc__ = Domain.union.__doc__

def Not(domain):
"""
Create the complementary domain of the domain given in argument.
"""
return ~domain
-Not.__doc__ = Domain.complement.__doc__