X-Git-Url: https://svn.cri.ensmp.fr/git/linpy.git/blobdiff_plain/663316ddc03c19cf06e95bad67fd5ac2bb5e1dfc..ba567519bac2c8a170defbc2275088f31cf8ccdd:/pypol/domains.py diff --git a/pypol/domains.py b/pypol/domains.py index 255c995..28ce533 100644 --- a/pypol/domains.py +++ b/pypol/domains.py @@ -5,8 +5,8 @@ import re from fractions import Fraction from . import islhelper -from .islhelper import mainctx, libisl, isl_set_basic_sets -from .coordinates import Point +from .islhelper import mainctx, libisl +from .geometry import GeometricObject, Point from .linexprs import Expression, Symbol @@ -17,7 +17,7 @@ __all__ = [ @functools.total_ordering -class Domain: +class Domain(GeometricObject): __slots__ = ( '_polyhedra', @@ -28,14 +28,14 @@ class Domain: def __new__(cls, *polyhedra): from .polyhedra import Polyhedron if len(polyhedra) == 1: - polyhedron = polyhedra[0] - if isinstance(polyhedron, str): - return cls.fromstring(polyhedron) - elif isinstance(polyhedron, Polyhedron): - return polyhedron + argument = polyhedra[0] + if isinstance(argument, str): + return cls.fromstring(argument) + elif isinstance(argument, GeometricObject): + return argument.aspolyhedron() else: raise TypeError('argument must be a string ' - 'or a Polyhedron instance') + 'or a GeometricObject instance') else: for polyhedron in polyhedra: if not isinstance(polyhedron, Polyhedron): @@ -67,11 +67,17 @@ class Domain: return self._dimension def disjoint(self): + """ + Returns this set as disjoint. + """ islset = self._toislset(self.polyhedra, self.symbols) islset = libisl.isl_set_make_disjoint(mainctx, islset) return self._fromislset(islset, self.symbols) def isempty(self): + """ + Returns true if this set is an Empty set. + """ islset = self._toislset(self.polyhedra, self.symbols) empty = bool(libisl.isl_set_is_empty(islset)) libisl.isl_set_free(islset) @@ -81,18 +87,27 @@ class Domain: return not self.isempty() def isuniverse(self): + """ + Returns true if this set is the Universe set. + """ islset = self._toislset(self.polyhedra, self.symbols) universe = bool(libisl.isl_set_plain_is_universe(islset)) libisl.isl_set_free(islset) return universe def isbounded(self): + """ + Returns true if this set is bounded. + """ islset = self._toislset(self.polyhedra, self.symbols) bounded = bool(libisl.isl_set_is_bounded(islset)) libisl.isl_set_free(islset) return bounded def __eq__(self, other): + """ + Returns true if two sets are equal. + """ symbols = self._xsymbols([self, other]) islset1 = self._toislset(self.polyhedra, symbols) islset2 = other._toislset(other.polyhedra, symbols) @@ -102,6 +117,9 @@ class Domain: return equal def isdisjoint(self, other): + """ + Return True if two sets have a null intersection. + """ symbols = self._xsymbols([self, other]) islset1 = self._toislset(self.polyhedra, symbols) islset2 = self._toislset(other.polyhedra, symbols) @@ -111,6 +129,9 @@ class Domain: return equal def issubset(self, other): + """ + Report whether another set contains this set. + """ symbols = self._xsymbols([self, other]) islset1 = self._toislset(self.polyhedra, symbols) islset2 = self._toislset(other.polyhedra, symbols) @@ -120,9 +141,15 @@ class Domain: return equal def __le__(self, other): + """ + Returns true if this set is less than or equal to another set. + """ return self.issubset(other) def __lt__(self, other): + """ + Returns true if this set is less than another set. + """ symbols = self._xsymbols([self, other]) islset1 = self._toislset(self.polyhedra, symbols) islset2 = self._toislset(other.polyhedra, symbols) @@ -132,30 +159,43 @@ class Domain: return equal def complement(self): + """ + Returns the complement of this set. + """ islset = self._toislset(self.polyhedra, self.symbols) islset = libisl.isl_set_complement(islset) return self._fromislset(islset, self.symbols) def __invert__(self): + """ + Returns the complement of this set. + """ return self.complement() def simplify(self): - #does not change anything in any of the examples - #isl seems to do this naturally + """ + Returns a set without redundant constraints. + """ islset = self._toislset(self.polyhedra, self.symbols) islset = libisl.isl_set_remove_redundancies(islset) return self._fromislset(islset, self.symbols) def aspolyhedron(self): - # several types of hull are available - # polyhedral seems to be the more appropriate, to be checked + """ + Returns polyhedral hull of set. + """ from .polyhedra import Polyhedron islset = self._toislset(self.polyhedra, self.symbols) islbset = libisl.isl_set_polyhedral_hull(islset) return Polyhedron._fromislbasicset(islbset, self.symbols) + def asdomain(self): + return self + def project(self, dims): - # use to remove certain variables + """ + Return new set with given dimensions removed. + """ islset = self._toislset(self.polyhedra, self.symbols) n = 0 for index, symbol in reversed(list(enumerate(self.symbols))): @@ -170,6 +210,9 @@ class Domain: return Domain._fromislset(islset, dims) def sample(self): + """ + Returns a single subset of the input. + """ islset = self._toislset(self.polyhedra, self.symbols) islpoint = libisl.isl_set_sample_point(islset) if bool(libisl.isl_point_is_void(islpoint)): @@ -185,6 +228,9 @@ class Domain: return point def intersection(self, *others): + """ + Return the intersection of two sets as a new set. + """ if len(others) == 0: return self symbols = self._xsymbols((self,) + others) @@ -195,9 +241,15 @@ class Domain: return self._fromislset(islset1, symbols) def __and__(self, other): + """ + Return the intersection of two sets as a new set. + """ return self.intersection(other) def union(self, *others): + """ + Return the union of sets as a new set. + """ if len(others) == 0: return self symbols = self._xsymbols((self,) + others) @@ -208,12 +260,21 @@ class Domain: return self._fromislset(islset1, symbols) def __or__(self, other): + """ + Return a new set with elements from both sets. + """ return self.union(other) def __add__(self, other): + """ + Return new set containing all elements in both sets. + """ return self.union(other) def difference(self, other): + """ + Return the difference of two sets as a new set. + """ symbols = self._xsymbols([self, other]) islset1 = self._toislset(self.polyhedra, symbols) islset2 = other._toislset(other.polyhedra, symbols) @@ -221,26 +282,39 @@ class Domain: return self._fromislset(islset, symbols) def __sub__(self, other): + """ + Return the difference of two sets as a new set. + """ return self.difference(other) def lexmin(self): + """ + Return a new set containing the lexicographic minimum of the elements in the set. + """ islset = self._toislset(self.polyhedra, self.symbols) islset = libisl.isl_set_lexmin(islset) return self._fromislset(islset, self.symbols) def lexmax(self): + """ + Return a new set containing the lexicographic maximum of the elements in the set. + """ islset = self._toislset(self.polyhedra, self.symbols) islset = libisl.isl_set_lexmax(islset) return self._fromislset(islset, self.symbols) def num_parameters(self): - #could be useful with large, complicated polyhedrons + """ + Return the total number of parameters, input, output or set dimensions. + """ islbset = self._toislbasicset(self.equalities, self.inequalities, self.symbols) num = libisl.isl_basic_set_dim(islbset, libisl.isl_dim_set) return num def involves_dims(self, dims): - #could be useful with large, complicated polyhedrons + """ + Returns true if set depends on given dimensions. + """ islset = self._toislset(self.polyhedra, self.symbols) dims = sorted(dims) symbols = sorted(list(self.symbols)) @@ -261,8 +335,12 @@ class Domain: _RE_COORDINATE = re.compile(r'\((?P\-?\d+)\)(/(?P\d+))?') def vertices(self): - #returning list of verticies + """ + Return a list of vertices for this Polygon. + """ from .polyhedra import Polyhedron + 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); vertices = islhelper.isl_vertices_vertices(vertices) @@ -283,6 +361,7 @@ class Domain: coordinate = -Fraction(constant, coefficient) coordinates.append((symbol, coordinate)) else: + # horrible hack, find a cleaner solution string = islhelper.isl_multi_aff_to_str(expr) matches = self._RE_COORDINATE.finditer(string) @@ -296,6 +375,9 @@ class Domain: return points def points(self): + """ + Returns the points contained in the set. + """ if not self.isbounded(): raise ValueError('domain must be bounded') from .polyhedra import Universe, Eq @@ -327,7 +409,7 @@ class Domain: def _fromislset(cls, islset, symbols): from .polyhedra import Polyhedron islset = libisl.isl_set_remove_divs(islset) - islbsets = isl_set_basic_sets(islset) + islbsets = islhelper.isl_set_basic_sets(islset) libisl.isl_set_free(islset) polyhedra = [] for islbset in islbsets: @@ -435,6 +517,12 @@ class Domain: strings = [repr(polyhedron) for polyhedron in self.polyhedra] return 'Or({})'.format(', '.join(strings)) + def _repr_latex_(self): + strings = [] + for polyhedron in self.polyhedra: + strings.append('({})'.format(polyhedron._repr_latex_().strip('$'))) + return '${}$'.format(' \\vee '.join(strings)) + @classmethod def fromsympy(cls, expr): import sympy @@ -459,6 +547,9 @@ class Domain: def And(*domains): + """ + Return the intersection of two sets as a new set. + """ if len(domains) == 0: from .polyhedra import Universe return Universe @@ -466,6 +557,9 @@ def And(*domains): return domains[0].intersection(*domains[1:]) def Or(*domains): + """ + Return the union of sets as a new set. + """ if len(domains) == 0: from .polyhedra import Empty return Empty @@ -473,4 +567,7 @@ def Or(*domains): return domains[0].union(*domains[1:]) def Not(domain): + """ + Returns the complement of this set. + """ return ~domain