1 import functools
2 import math
3 import numbers
5 from . import islhelper
7 from .islhelper import mainctx, libisl
8 from .geometry import GeometricObject, Point, Vector
9 from .linexprs import Expression, Symbol, Rational
10 from .domains import Domain
13 __all__ = [
14 'Polyhedron',
15 'Lt', 'Le', 'Eq', 'Ne', 'Ge', 'Gt',
16 'Empty', 'Universe',
17 ]
20 class Polyhedron(Domain):
22 __slots__ = (
23 '_equalities',
24 '_inequalities',
25 '_constraints',
26 '_symbols',
27 '_dimension',
28 )
30 def __new__(cls, equalities=None, inequalities=None):
31 if isinstance(equalities, str):
32 if inequalities is not None:
33 raise TypeError('too many arguments')
34 return cls.fromstring(equalities)
35 elif isinstance(equalities, GeometricObject):
36 if inequalities is not None:
37 raise TypeError('too many arguments')
38 return equalities.aspolyhedron()
39 if equalities is None:
40 equalities = []
41 else:
42 for i, equality in enumerate(equalities):
43 if not isinstance(equality, Expression):
44 raise TypeError('equalities must be linear expressions')
45 equalities[i] = equality.scaleint()
46 if inequalities is None:
47 inequalities = []
48 else:
49 for i, inequality in enumerate(inequalities):
50 if not isinstance(inequality, Expression):
51 raise TypeError('inequalities must be linear expressions')
52 inequalities[i] = inequality.scaleint()
53 symbols = cls._xsymbols(equalities + inequalities)
54 islbset = cls._toislbasicset(equalities, inequalities, symbols)
55 return cls._fromislbasicset(islbset, symbols)
57 @property
58 def equalities(self):
59 return self._equalities
61 @property
62 def inequalities(self):
63 return self._inequalities
65 @property
66 def constraints(self):
67 return self._constraints
69 @property
70 def polyhedra(self):
71 return self,
73 def disjoint(self):
74 """
75 Return this set as disjoint.
76 """
77 return self
79 def isuniverse(self):
80 """
81 Return true if this set is the Universe set.
82 """
83 islbset = self._toislbasicset(self.equalities, self.inequalities,
84 self.symbols)
85 universe = bool(libisl.isl_basic_set_is_universe(islbset))
86 libisl.isl_basic_set_free(islbset)
87 return universe
89 def aspolyhedron(self):
90 """
91 Return polyhedral hull of this set.
92 """
93 return self
95 def __contains__(self, point):
96 if not isinstance(point, Point):
97 raise TypeError('point must be a Point instance')
98 if self.symbols != point.symbols:
99 raise ValueError('arguments must belong to the same space')
100 for equality in self.equalities:
101 if equality.subs(point.coordinates()) != 0:
102 return False
103 for inequality in self.inequalities:
104 if inequality.subs(point.coordinates()) < 0:
105 return False
106 return True
108 def subs(self, symbol, expression=None):
109 equalities = [equality.subs(symbol, expression)
110 for equality in self.equalities]
111 inequalities = [inequality.subs(symbol, expression)
112 for inequality in self.inequalities]
113 return Polyhedron(equalities, inequalities)
115 @classmethod
116 def _fromislbasicset(cls, islbset, symbols):
117 islconstraints = islhelper.isl_basic_set_constraints(islbset)
118 equalities = []
119 inequalities = []
120 for islconstraint in islconstraints:
121 constant = libisl.isl_constraint_get_constant_val(islconstraint)
122 constant = islhelper.isl_val_to_int(constant)
123 coefficients = {}
124 for index, symbol in enumerate(symbols):
125 coefficient = libisl.isl_constraint_get_coefficient_val(islconstraint,
126 libisl.isl_dim_set, index)
127 coefficient = islhelper.isl_val_to_int(coefficient)
128 if coefficient != 0:
129 coefficients[symbol] = coefficient
130 expression = Expression(coefficients, constant)
131 if libisl.isl_constraint_is_equality(islconstraint):
132 equalities.append(expression)
133 else:
134 inequalities.append(expression)
135 libisl.isl_basic_set_free(islbset)
136 self = object().__new__(Polyhedron)
137 self._equalities = tuple(equalities)
138 self._inequalities = tuple(inequalities)
139 self._constraints = tuple(equalities + inequalities)
140 self._symbols = cls._xsymbols(self._constraints)
141 self._dimension = len(self._symbols)
142 return self
144 @classmethod
145 def _toislbasicset(cls, equalities, inequalities, symbols):
146 dimension = len(symbols)
147 indices = {symbol: index for index, symbol in enumerate(symbols)}
148 islsp = libisl.isl_space_set_alloc(mainctx, 0, dimension)
149 islbset = libisl.isl_basic_set_universe(libisl.isl_space_copy(islsp))
150 islls = libisl.isl_local_space_from_space(islsp)
151 for equality in equalities:
152 isleq = libisl.isl_equality_alloc(libisl.isl_local_space_copy(islls))
153 for symbol, coefficient in equality.coefficients():
154 islval = str(coefficient).encode()
156 index = indices[symbol]
157 isleq = libisl.isl_constraint_set_coefficient_val(isleq,
158 libisl.isl_dim_set, index, islval)
159 if equality.constant != 0:
160 islval = str(equality.constant).encode()
162 isleq = libisl.isl_constraint_set_constant_val(isleq, islval)
164 for inequality in inequalities:
165 islin = libisl.isl_inequality_alloc(libisl.isl_local_space_copy(islls))
166 for symbol, coefficient in inequality.coefficients():
167 islval = str(coefficient).encode()
169 index = indices[symbol]
170 islin = libisl.isl_constraint_set_coefficient_val(islin,
171 libisl.isl_dim_set, index, islval)
172 if inequality.constant != 0:
173 islval = str(inequality.constant).encode()
175 islin = libisl.isl_constraint_set_constant_val(islin, islval)
177 return islbset
179 @classmethod
180 def fromstring(cls, string):
181 domain = Domain.fromstring(string)
182 if not isinstance(domain, Polyhedron):
183 raise ValueError('non-polyhedral expression: {!r}'.format(string))
184 return domain
186 def __repr__(self):
187 if self.isempty():
188 return 'Empty'
189 elif self.isuniverse():
190 return 'Universe'
191 else:
192 strings = []
193 for equality in self.equalities:
194 strings.append('Eq({}, 0)'.format(equality))
195 for inequality in self.inequalities:
196 strings.append('Ge({}, 0)'.format(inequality))
197 if len(strings) == 1:
198 return strings[0]
199 else:
200 return 'And({})'.format(', '.join(strings))
202 def _repr_latex_(self):
203 if self.isempty():
204 return '\$\\emptyset\$'
205 elif self.isuniverse():
206 return '\$\\Omega\$'
207 else:
208 strings = []
209 for equality in self.equalities:
210 strings.append('{} = 0'.format(equality._repr_latex_().strip('\$')))
211 for inequality in self.inequalities:
212 strings.append('{} \\ge 0'.format(inequality._repr_latex_().strip('\$')))
213 return '\${}\$'.format(' \\wedge '.join(strings))
215 @classmethod
216 def fromsympy(cls, expr):
217 domain = Domain.fromsympy(expr)
218 if not isinstance(domain, Polyhedron):
219 raise ValueError('non-polyhedral expression: {!r}'.format(expr))
220 return domain
222 def tosympy(self):
223 import sympy
224 constraints = []
225 for equality in self.equalities:
226 constraints.append(sympy.Eq(equality.tosympy(), 0))
227 for inequality in self.inequalities:
228 constraints.append(sympy.Ge(inequality.tosympy(), 0))
229 return sympy.And(*constraints)
231 @classmethod
232 def _polygon_inner_point(cls, points):
233 symbols = points[0].symbols
234 coordinates = {symbol: 0 for symbol in symbols}
235 for point in points:
236 for symbol, coordinate in point.coordinates():
237 coordinates[symbol] += coordinate
238 for symbol in symbols:
239 coordinates[symbol] /= len(points)
240 return Point(coordinates)
242 @classmethod
243 def _sort_polygon_2d(cls, points):
244 if len(points) <= 3:
245 return points
246 o = cls._polygon_inner_point(points)
247 angles = {}
248 for m in points:
249 om = Vector(o, m)
250 dx, dy = (coordinate for symbol, coordinate in om.coordinates())
251 angle = math.atan2(dy, dx)
252 angles[m] = angle
253 return sorted(points, key=angles.get)
255 @classmethod
256 def _sort_polygon_3d(cls, points):
257 if len(points) <= 3:
258 return points
259 o = cls._polygon_inner_point(points)
260 a = points[0]
261 oa = Vector(o, a)
262 norm_oa = oa.norm()
263 for b in points[1:]:
264 ob = Vector(o, b)
265 u = oa.cross(ob)
266 if not u.isnull():
267 u = u.asunit()
268 break
269 else:
270 raise ValueError('degenerate polygon')
271 angles = {a: 0.}
272 for m in points[1:]:
273 om = Vector(o, m)
274 normprod = norm_oa * om.norm()
275 cosinus = max(oa.dot(om) / normprod, -1.)
276 sinus = u.dot(oa.cross(om)) / normprod
277 angle = math.acos(cosinus)
278 angle = math.copysign(angle, sinus)
279 angles[m] = angle
280 return sorted(points, key=angles.get)
282 def faces(self):
283 vertices = self.vertices()
284 faces = []
285 for constraint in self.constraints:
286 face = []
287 for vertex in vertices:
288 if constraint.subs(vertex.coordinates()) == 0:
289 face.append(vertex)
290 faces.append(face)
291 return faces
293 def _plot_2d(self, plot=None, **kwargs):
294 from matplotlib import pylab
295 import matplotlib.pyplot as plt
296 from matplotlib.axes import Axes
297 from matplotlib.patches import Polygon
298 vertices = self._sort_polygon_2d(self.vertices())
299 xys = [tuple(vertex.values()) for vertex in vertices]
300 if plot is None:
301 fig = plt.figure()
302 plot = fig.add_subplot(1, 1, 1)
303 xs, ys = zip(*xys)
304 plot.set_xlim(float(min(xs)), float(max(xs)))
305 plot.set_ylim(float(min(ys)), float(max(ys)))
307 return plot
309 def _plot_3d(self, plot=None, **kwargs):
310 import matplotlib.pyplot as plt
311 from mpl_toolkits.mplot3d import Axes3D
312 from mpl_toolkits.mplot3d.art3d import Poly3DCollection
313 if plot is None:
314 fig = plt.figure()
315 axes = Axes3D(fig)
316 xmin, xmax = float('inf'), float('-inf')
317 ymin, ymax = float('inf'), float('-inf')
318 zmin, zmax = float('inf'), float('-inf')
319 else:
320 axes = plot
321 poly_xyzs = []
322 for vertices in self.faces():
323 if len(vertices) == 0:
324 continue
325 vertices = Polyhedron._sort_polygon_3d(vertices)
326 vertices.append(vertices[0])
327 face_xyzs = [tuple(vertex.values()) for vertex in vertices]
328 if plot is None:
329 xs, ys, zs = zip(*face_xyzs)
330 xmin, xmax = min(xmin, float(min(xs))), max(xmax, float(max(xs)))
331 ymin, ymax = min(ymin, float(min(ys))), max(ymax, float(max(ys)))
332 zmin, zmax = min(zmin, float(min(zs))), max(zmax, float(max(zs)))
333 poly_xyzs.append(face_xyzs)
334 collection = Poly3DCollection(poly_xyzs, **kwargs)
336 if plot is None:
337 axes.set_xlim(xmin, xmax)
338 axes.set_ylim(ymin, ymax)
339 axes.set_zlim(zmin, zmax)
340 return axes
342 def plot(self, plot=None, **kwargs):
343 """
344 Display 3D plot of set.
345 """
346 if self.dimension == 2:
347 return self._plot_2d(plot=plot, **kwargs)
348 elif self.dimension == 3:
349 return self._plot_3d(plot=plot, **kwargs)
350 else:
351 raise ValueError('polyhedron must be 2 or 3-dimensional')
354 def _polymorphic(func):
355 @functools.wraps(func)
356 def wrapper(left, right):
357 if not isinstance(left, Expression):
358 if isinstance(left, numbers.Rational):
359 left = Rational(left)
360 else:
361 raise TypeError('left must be a a rational number '
362 'or a linear expression')
363 if not isinstance(right, Expression):
364 if isinstance(right, numbers.Rational):
365 right = Rational(right)
366 else:
367 raise TypeError('right must be a a rational number '
368 'or a linear expression')
369 return func(left, right)
370 return wrapper
372 @_polymorphic
373 def Lt(left, right):
374 """
375 Return true if the first set is less than the second.
376 """
377 return Polyhedron([], [right - left - 1])
379 @_polymorphic
380 def Le(left, right):
381 """
382 Return true the first set is less than or equal to the second.
383 """
384 return Polyhedron([], [right - left])
386 @_polymorphic
387 def Eq(left, right):
388 """
389 Return true if the sets are equal.
390 """
391 return Polyhedron([left - right], [])
393 @_polymorphic
394 def Ne(left, right):
395 """
396 Return true if the sets are NOT equal.
397 """
398 return ~Eq(left, right)
400 @_polymorphic
401 def Gt(left, right):
402 """
403 Return true if the first set is greater than the second set.
404 """
405 return Polyhedron([], [left - right - 1])
407 @_polymorphic
408 def Ge(left, right):
409 """
410 Return true if the first set is greater than or equal the second set.
411 """
412 return Polyhedron([], [left - right])
415 Empty = Eq(1, 0)
417 Universe = Polyhedron([])