X-Git-Url: https://scm.cri.mines-paristech.fr/git/linpy.git/blobdiff_plain/cd2197879049a836b02a331adf0a00c0b87fe043..5b661514c1bbabd8205fdbd22a0ba0f6b1ac6305:/pypol/polyhedra.py?ds=sidebyside diff --git a/pypol/polyhedra.py b/pypol/polyhedra.py index a6adeda..6b5f9ab 100644 --- a/pypol/polyhedra.py +++ b/pypol/polyhedra.py @@ -1,10 +1,12 @@ import functools +import math import numbers from . import islhelper from .islhelper import mainctx, libisl -from .linexprs import Expression, Rational +from .geometry import GeometricObject, Point, Vector +from .linexprs import Expression, Symbol, Rational from .domains import Domain @@ -30,11 +32,7 @@ class Polyhedron(Domain): if inequalities is not None: raise TypeError('too many arguments') return cls.fromstring(equalities) - elif isinstance(equalities, Polyhedron): - if inequalities is not None: - raise TypeError('too many arguments') - return equalities - elif isinstance(equalities, Domain): + elif isinstance(equalities, GeometricObject): if inequalities is not None: raise TypeError('too many arguments') return equalities.aspolyhedron() @@ -85,6 +83,26 @@ class Polyhedron(Domain): def aspolyhedron(self): return self + def __contains__(self, point): + if not isinstance(point, Point): + raise TypeError('point must be a Point instance') + if self.symbols != point.symbols: + raise ValueError('arguments must belong to the same space') + for equality in self.equalities: + if equality.subs(point.coordinates()) != 0: + return False + for inequality in self.inequalities: + if inequality.subs(point.coordinates()) < 0: + return False + return True + + def subs(self, symbol, expression=None): + equalities = [equality.subs(symbol, expression) + for equality in self.equalities] + inequalities = [inequality.subs(symbol, expression) + for inequality in self.inequalities] + return Polyhedron(equalities, inequalities) + @classmethod def _fromislbasicset(cls, islbset, symbols): islconstraints = islhelper.isl_basic_set_constraints(islbset) @@ -164,14 +182,27 @@ class Polyhedron(Domain): else: strings = [] for equality in self.equalities: - strings.append('0 == {}'.format(equality)) + strings.append('Eq({}, 0)'.format(equality)) for inequality in self.inequalities: - strings.append('0 <= {}'.format(inequality)) + strings.append('Ge({}, 0)'.format(inequality)) if len(strings) == 1: return strings[0] else: return 'And({})'.format(', '.join(strings)) + def _repr_latex_(self): + if self.isempty(): + return '$\\emptyset$' + elif self.isuniverse(): + return '$\\Omega$' + else: + strings = [] + for equality in self.equalities: + strings.append('{} = 0'.format(equality._repr_latex_().strip('$'))) + for inequality in self.inequalities: + strings.append('{} \\ge 0'.format(inequality._repr_latex_().strip('$'))) + return '${}$'.format(' \\wedge '.join(strings)) + @classmethod def fromsympy(cls, expr): domain = Domain.fromsympy(expr) @@ -188,20 +219,123 @@ class Polyhedron(Domain): constraints.append(sympy.Ge(inequality.tosympy(), 0)) return sympy.And(*constraints) + @classmethod + def _polygon_inner_point(cls, points): + symbols = points[0].symbols + coordinates = {symbol: 0 for symbol in symbols} + for point in points: + for symbol, coordinate in point.coordinates(): + coordinates[symbol] += coordinate + for symbol in symbols: + coordinates[symbol] /= len(points) + return Point(coordinates) + + @classmethod + def _sort_polygon_2d(cls, points): + if len(points) <= 3: + return points + o = cls._polygon_inner_point(points) + angles = {} + for m in points: + om = Vector(o, m) + dx, dy = (coordinate for symbol, coordinate in om.coordinates()) + angle = math.atan2(dy, dx) + angles[m] = angle + return sorted(points, key=angles.get) + + @classmethod + def _sort_polygon_3d(cls, points): + if len(points) <= 3: + return points + o = cls._polygon_inner_point(points) + a = points[0] + oa = Vector(o, a) + norm_oa = oa.norm() + for b in points[1:]: + ob = Vector(o, b) + u = oa.cross(ob) + if not u.isnull(): + u = u.asunit() + break + else: + raise ValueError('degenerate polygon') + angles = {a: 0.} + for m in points[1:]: + om = Vector(o, m) + normprod = norm_oa * om.norm() + cosinus = oa.dot(om) / normprod + sinus = u.dot(oa.cross(om)) / normprod + angle = math.acos(cosinus) + angle = math.copysign(angle, sinus) + angles[m] = angle + return sorted(points, key=angles.get) + + def faces(self): + vertices = self.vertices() + faces = [] + for constraint in self.constraints: + face = [] + for vertex in vertices: + if constraint.subs(vertex.coordinates()) == 0: + face.append(vertex) + faces.append(face) + return faces + + def plot(self): + import matplotlib.pyplot as plt + from matplotlib.path import Path + import matplotlib.patches as patches + + if len(self.symbols)> 3: + raise TypeError + + elif len(self.symbols) == 2: + verts = self.vertices() + points = [] + codes = [Path.MOVETO] + for vert in verts: + pairs = () + for sym in sorted(vert, key=Symbol.sortkey): + num = vert.get(sym) + pairs = pairs + (num,) + points.append(pairs) + points.append((0.0, 0.0)) + num = len(points) + while num > 2: + codes.append(Path.LINETO) + num = num - 1 + else: + codes.append(Path.CLOSEPOLY) + path = Path(points, codes) + fig = plt.figure() + ax = fig.add_subplot(111) + patch = patches.PathPatch(path, facecolor='blue', lw=2) + ax.add_patch(patch) + ax.set_xlim(-5,5) + ax.set_ylim(-5,5) + plt.show() + + elif len(self.symbols)==3: + return 0 + + return points + def _polymorphic(func): @functools.wraps(func) def wrapper(left, right): - if isinstance(left, numbers.Rational): - left = Rational(left) - elif not isinstance(left, Expression): - raise TypeError('left must be a a rational number ' - 'or a linear expression') - if isinstance(right, numbers.Rational): - right = Rational(right) - elif not isinstance(right, Expression): - raise TypeError('right must be a a rational number ' - 'or a linear expression') + if not isinstance(left, Expression): + if isinstance(left, numbers.Rational): + left = Rational(left) + else: + raise TypeError('left must be a a rational number ' + 'or a linear expression') + if not isinstance(right, Expression): + if isinstance(right, numbers.Rational): + right = Rational(right) + else: + raise TypeError('right must be a a rational number ' + 'or a linear expression') return func(left, right) return wrapper