pypol/polyhedra.py

   1 """
   2     This file is part of Linpy.
   3
   4     Linpy is free software: you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation, either version 3 of the License, or
   7     (at your option) any later version.
   8
   9     Linpy is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with Linpy.  If not, see <http://www.gnu.org/licenses/>.
  16 """
  17
  18 import functools
  19 import math
  20 import numbers
  21
  22 from . import islhelper
  23
  24 from .islhelper import mainctx, libisl
  25 from .geometry import GeometricObject, Point
  26 from .linexprs import Expression, Rational
  27 from .domains import Domain
  28
  29
  30 __all__ = [
  31     'Polyhedron',
  32     'Lt', 'Le', 'Eq', 'Ne', 'Ge', 'Gt',
  33     'Empty', 'Universe',
  34 ]
  35
  36
  37 class Polyhedron(Domain):
  38
  39     __slots__ = (
  40         '_equalities',
  41         '_inequalities',
  42         '_constraints',
  43         '_symbols',
  44         '_dimension',
  45     )
  46
  47     def __new__(cls, equalities=None, inequalities=None):
  48         if isinstance(equalities, str):
  49             if inequalities is not None:
  50                 raise TypeError('too many arguments')
  51             return cls.fromstring(equalities)
  52         elif isinstance(equalities, GeometricObject):
  53             if inequalities is not None:
  54                 raise TypeError('too many arguments')
  55             return equalities.aspolyhedron()
  56         if equalities is None:
  57             equalities = []
  58         else:
  59             for i, equality in enumerate(equalities):
  60                 if not isinstance(equality, Expression):
  61                     raise TypeError('equalities must be linear expressions')
  62                 equalities[i] = equality.scaleint()
  63         if inequalities is None:
  64             inequalities = []
  65         else:
  66             for i, inequality in enumerate(inequalities):
  67                 if not isinstance(inequality, Expression):
  68                     raise TypeError('inequalities must be linear expressions')
  69                 inequalities[i] = inequality.scaleint()
  70         symbols = cls._xsymbols(equalities + inequalities)
  71         islbset = cls._toislbasicset(equalities, inequalities, symbols)
  72         return cls._fromislbasicset(islbset, symbols)
  73
  74     @property
  75     def equalities(self):
  76         """
  77         Return a list of the equalities in a set.
  78         """
  79         return self._equalities
  80
  81     @property
  82     def inequalities(self):
  83         """
  84         Return a list of the inequalities in a set.
  85         """
  86         return self._inequalities
  87
  88     @property
  89     def constraints(self):
  90         """
  91         Return ta list of the constraints of a set.
  92         """
  93         return self._constraints
  94
  95     @property
  96     def polyhedra(self):
  97         return self,
  98
  99     def disjoint(self):
 100         """
 101         Return a set as disjoint.
 102         """
 103         return self
 104
 105     def isuniverse(self):
 106         """
 107         Return true if a set is the Universe set.
 108         """
 109         islbset = self._toislbasicset(self.equalities, self.inequalities,
 110             self.symbols)
 111         universe = bool(libisl.isl_basic_set_is_universe(islbset))
 112         libisl.isl_basic_set_free(islbset)
 113         return universe
 114
 115     def aspolyhedron(self):
 116         """
 117         Return polyhedral hull of a set.
 118         """
 119         return self
 120
 121     def __contains__(self, point):
 122         if not isinstance(point, Point):
 123             raise TypeError('point must be a Point instance')
 124         if self.symbols != point.symbols:
 125             raise ValueError('arguments must belong to the same space')
 126         for equality in self.equalities:
 127             if equality.subs(point.coordinates()) != 0:
 128                 return False
 129         for inequality in self.inequalities:
 130             if inequality.subs(point.coordinates()) < 0:
 131                 return False
 132         return True
 133
 134     def subs(self, symbol, expression=None):
 135         """
 136         Subsitute the given value into an expression and return the resulting
 137         expression.
 138         """
 139         equalities = [equality.subs(symbol, expression)
 140             for equality in self.equalities]
 141         inequalities = [inequality.subs(symbol, expression)
 142             for inequality in self.inequalities]
 143         return Polyhedron(equalities, inequalities)
 144
 145     def _asinequalities(self):
 146         inequalities = list(self.equalities)
 147         inequalities.extend([-expression for expression in self.equalities])
 148         inequalities.extend(self.inequalities)
 149         return inequalities
 150
 151     def widen(self, other):
 152         if not isinstance(other, Polyhedron):
 153             raise ValueError('argument must be a Polyhedron instance')
 154         inequalities1 = self._asinequalities()
 155         inequalities2 = other._asinequalities()
 156         inequalities = []
 157         for inequality1 in inequalities1:
 158             if other <= Polyhedron(inequalities=[inequality1]):
 159                 inequalities.append(inequality1)
 160         for inequality2 in inequalities2:
 161             for i in range(len(inequalities1)):
 162                 inequalities3 = inequalities1[:i] + inequalities[i + 1:]
 163                 inequalities3.append(inequality2)
 164                 polyhedron3 = Polyhedron(inequalities=inequalities3)
 165                 if self == polyhedron3:
 166                     inequalities.append(inequality2)
 167                     break
 168         return Polyhedron(inequalities=inequalities)
 169
 170     @classmethod
 171     def _fromislbasicset(cls, islbset, symbols):
 172         islconstraints = islhelper.isl_basic_set_constraints(islbset)
 173         equalities = []
 174         inequalities = []
 175         for islconstraint in islconstraints:
 176             constant = libisl.isl_constraint_get_constant_val(islconstraint)
 177             constant = islhelper.isl_val_to_int(constant)
 178             coefficients = {}
 179             for index, symbol in enumerate(symbols):
 180                 coefficient = libisl.isl_constraint_get_coefficient_val(islconstraint,
 181                     libisl.isl_dim_set, index)
 182                 coefficient = islhelper.isl_val_to_int(coefficient)
 183                 if coefficient != 0:
 184                     coefficients[symbol] = coefficient
 185             expression = Expression(coefficients, constant)
 186             if libisl.isl_constraint_is_equality(islconstraint):
 187                 equalities.append(expression)
 188             else:
 189                 inequalities.append(expression)
 190         libisl.isl_basic_set_free(islbset)
 191         self = object().__new__(Polyhedron)
 192         self._equalities = tuple(equalities)
 193         self._inequalities = tuple(inequalities)
 194         self._constraints = tuple(equalities + inequalities)
 195         self._symbols = cls._xsymbols(self._constraints)
 196         self._dimension = len(self._symbols)
 197         return self
 198
 199     @classmethod
 200     def _toislbasicset(cls, equalities, inequalities, symbols):
 201         dimension = len(symbols)
 202         indices = {symbol: index for index, symbol in enumerate(symbols)}
 203         islsp = libisl.isl_space_set_alloc(mainctx, 0, dimension)
 204         islbset = libisl.isl_basic_set_universe(libisl.isl_space_copy(islsp))
 205         islls = libisl.isl_local_space_from_space(islsp)
 206         for equality in equalities:
 207             isleq = libisl.isl_equality_alloc(libisl.isl_local_space_copy(islls))
 208             for symbol, coefficient in equality.coefficients():
 209                 islval = str(coefficient).encode()
 210                 islval = libisl.isl_val_read_from_str(mainctx, islval)
 211                 index = indices[symbol]
 212                 isleq = libisl.isl_constraint_set_coefficient_val(isleq,
 213                     libisl.isl_dim_set, index, islval)
 214             if equality.constant != 0:
 215                 islval = str(equality.constant).encode()
 216                 islval = libisl.isl_val_read_from_str(mainctx, islval)
 217                 isleq = libisl.isl_constraint_set_constant_val(isleq, islval)
 218             islbset = libisl.isl_basic_set_add_constraint(islbset, isleq)
 219         for inequality in inequalities:
 220             islin = libisl.isl_inequality_alloc(libisl.isl_local_space_copy(islls))
 221             for symbol, coefficient in inequality.coefficients():
 222                 islval = str(coefficient).encode()
 223                 islval = libisl.isl_val_read_from_str(mainctx, islval)
 224                 index = indices[symbol]
 225                 islin = libisl.isl_constraint_set_coefficient_val(islin,
 226                     libisl.isl_dim_set, index, islval)
 227             if inequality.constant != 0:
 228                 islval = str(inequality.constant).encode()
 229                 islval = libisl.isl_val_read_from_str(mainctx, islval)
 230                 islin = libisl.isl_constraint_set_constant_val(islin, islval)
 231             islbset = libisl.isl_basic_set_add_constraint(islbset, islin)
 232         return islbset
 233
 234     @classmethod
 235     def fromstring(cls, string):
 236         domain = Domain.fromstring(string)
 237         if not isinstance(domain, Polyhedron):
 238             raise ValueError('non-polyhedral expression: {!r}'.format(string))
 239         return domain
 240
 241     def __repr__(self):
 242         strings = []
 243         for equality in self.equalities:
 244             strings.append('Eq({}, 0)'.format(equality))
 245         for inequality in self.inequalities:
 246             strings.append('Ge({}, 0)'.format(inequality))
 247         if len(strings) == 1:
 248             return strings[0]
 249         else:
 250             return 'And({})'.format(', '.join(strings))
 251
 252
 253     def _repr_latex_(self):
 254         strings = []
 255         for equality in self.equalities:
 256             strings.append('{} = 0'.format(equality._repr_latex_().strip('$')))
 257         for inequality in self.inequalities:
 258             strings.append('{} \\ge 0'.format(inequality._repr_latex_().strip('$')))
 259         return '$${}$$'.format(' \\wedge '.join(strings))
 260
 261     @classmethod
 262     def fromsympy(cls, expr):
 263         """
 264         Convert a sympy object to an expression.
 265         """
 266         domain = Domain.fromsympy(expr)
 267         if not isinstance(domain, Polyhedron):
 268             raise ValueError('non-polyhedral expression: {!r}'.format(expr))
 269         return domain
 270
 271     def tosympy(self):
 272         """
 273         Return an expression as a sympy object.
 274         """
 275         import sympy
 276         constraints = []
 277         for equality in self.equalities:
 278             constraints.append(sympy.Eq(equality.tosympy(), 0))
 279         for inequality in self.inequalities:
 280             constraints.append(sympy.Ge(inequality.tosympy(), 0))
 281         return sympy.And(*constraints)
 282
 283 class EmptyType(Polyhedron):
 284
 285     __slots__ = Polyhedron.__slots__
 286
 287     def __new__(cls):
 288         self = object().__new__(cls)
 289         self._equalities = (Rational(1),)
 290         self._inequalities = ()
 291         self._constraints = self._equalities
 292         self._symbols = ()
 293         self._dimension = 0
 294         return self
 295
 296     def widen(self, other):
 297         if not isinstance(other, Polyhedron):
 298             raise ValueError('argument must be a Polyhedron instance')
 299         return other
 300
 301     def __repr__(self):
 302         return 'Empty'
 303
 304     def _repr_latex_(self):
 305         return '$$\\emptyset$$'
 306
 307 Empty = EmptyType()
 308
 309
 310 class UniverseType(Polyhedron):
 311
 312     __slots__ = Polyhedron.__slots__
 313
 314     def __new__(cls):
 315         self = object().__new__(cls)
 316         self._equalities = ()
 317         self._inequalities = ()
 318         self._constraints = ()
 319         self._symbols = ()
 320         self._dimension = ()
 321         return self
 322
 323     def __repr__(self):
 324         return 'Universe'
 325
 326     def _repr_latex_(self):
 327         return '$$\\Omega$$'
 328
 329 Universe = UniverseType()
 330
 331
 332 def _polymorphic(func):
 333     @functools.wraps(func)
 334     def wrapper(left, right):
 335         if not isinstance(left, Expression):
 336             if isinstance(left, numbers.Rational):
 337                 left = Rational(left)
 338             else:
 339                 raise TypeError('left must be a a rational number '
 340                     'or a linear expression')
 341         if not isinstance(right, Expression):
 342             if isinstance(right, numbers.Rational):
 343                 right = Rational(right)
 344             else:
 345                 raise TypeError('right must be a a rational number '
 346                     'or a linear expression')
 347         return func(left, right)
 348     return wrapper
 349
 350 @_polymorphic
 351 def Lt(left, right):
 352     """
 353     Assert first set is less than the second set.
 354     """
 355     return Polyhedron([], [right - left - 1])
 356
 357 @_polymorphic
 358 def Le(left, right):
 359     """
 360     Assert first set is less than or equal to the second set.
 361     """
 362     return Polyhedron([], [right - left])
 363
 364 @_polymorphic
 365 def Eq(left, right):
 366     """
 367     Assert first set is equal to the second set.
 368     """
 369     return Polyhedron([left - right], [])
 370
 371 @_polymorphic
 372 def Ne(left, right):
 373     """
 374     Assert first set is not equal to the second set.
 375     """
 376     return ~Eq(left, right)
 377
 378 @_polymorphic
 379 def Gt(left, right):
 380     """
 381     Assert first set is greater than the second set.
 382     """
 383     return Polyhedron([], [left - right - 1])
 384
 385 @_polymorphic
 386 def Ge(left, right):
 387     """
 388     Assert first set is greater than or equal to the second set.
 389     """
 390     return Polyhedron([], [left - right])
 391
 392 # Copyright 2014 MINES ParisTech