X-Git-Url: https://svn.cri.ensmp.fr/git/linpy.git/blobdiff_plain/1c48ba9f3483505f53962731dc58c6c02d785fc4..2964ba35929f34ab12a6ee61ad7cc3fb543da875:/pypol/polyhedra.py?ds=sidebyside diff --git a/pypol/polyhedra.py b/pypol/polyhedra.py index d181646..3db8f40 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, Constant +from .linexprs import Expression, Symbol, Rational from .domains import Domain @@ -37,21 +39,21 @@ class Polyhedron(Domain): elif isinstance(equalities, Domain): if inequalities is not None: raise TypeError('too many arguments') - return equalities.polyhedral_hull() + return equalities.aspolyhedron() if equalities is None: equalities = [] else: for i, equality in enumerate(equalities): if not isinstance(equality, Expression): raise TypeError('equalities must be linear expressions') - equalities[i] = equality._toint() + equalities[i] = equality.scaleint() if inequalities is None: inequalities = [] else: for i, inequality in enumerate(inequalities): if not isinstance(inequality, Expression): raise TypeError('inequalities must be linear expressions') - inequalities[i] = inequality._toint() + inequalities[i] = inequality.scaleint() symbols = cls._xsymbols(equalities + inequalities) islbset = cls._toislbasicset(equalities, inequalities, symbols) return cls._fromislbasicset(islbset, symbols) @@ -82,21 +84,28 @@ class Polyhedron(Domain): libisl.isl_basic_set_free(islbset) return universe - def polyhedral_hull(self): + def aspolyhedron(self): return self + 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) equalities = [] inequalities = [] for islconstraint in islconstraints: - islpr = libisl.isl_printer_to_str(mainctx) constant = libisl.isl_constraint_get_constant_val(islconstraint) constant = islhelper.isl_val_to_int(constant) coefficients = {} - for dim, symbol in enumerate(symbols): - coefficient = libisl.isl_constraint_get_coefficient_val(islconstraint, libisl.isl_dim_set, dim) + for index, symbol in enumerate(symbols): + coefficient = libisl.isl_constraint_get_coefficient_val(islconstraint, + libisl.isl_dim_set, index) coefficient = islhelper.isl_val_to_int(coefficient) if coefficient != 0: coefficients[symbol] = coefficient @@ -117,34 +126,35 @@ class Polyhedron(Domain): @classmethod def _toislbasicset(cls, equalities, inequalities, symbols): dimension = len(symbols) + indices = {symbol: index for index, symbol in enumerate(symbols)} islsp = libisl.isl_space_set_alloc(mainctx, 0, dimension) islbset = libisl.isl_basic_set_universe(libisl.isl_space_copy(islsp)) islls = libisl.isl_local_space_from_space(islsp) for equality in equalities: isleq = libisl.isl_equality_alloc(libisl.isl_local_space_copy(islls)) for symbol, coefficient in equality.coefficients(): - val = str(coefficient).encode() - val = libisl.isl_val_read_from_str(mainctx, val) - sid = symbols.index(symbol) + islval = str(coefficient).encode() + islval = libisl.isl_val_read_from_str(mainctx, islval) + index = indices[symbol] isleq = libisl.isl_constraint_set_coefficient_val(isleq, - libisl.isl_dim_set, sid, val) + libisl.isl_dim_set, index, islval) if equality.constant != 0: - val = str(equality.constant).encode() - val = libisl.isl_val_read_from_str(mainctx, val) - isleq = libisl.isl_constraint_set_constant_val(isleq, val) + islval = str(equality.constant).encode() + islval = libisl.isl_val_read_from_str(mainctx, islval) + isleq = libisl.isl_constraint_set_constant_val(isleq, islval) islbset = libisl.isl_basic_set_add_constraint(islbset, isleq) for inequality in inequalities: islin = libisl.isl_inequality_alloc(libisl.isl_local_space_copy(islls)) for symbol, coefficient in inequality.coefficients(): - val = str(coefficient).encode() - val = libisl.isl_val_read_from_str(mainctx, val) - sid = symbols.index(symbol) + islval = str(coefficient).encode() + islval = libisl.isl_val_read_from_str(mainctx, islval) + index = indices[symbol] islin = libisl.isl_constraint_set_coefficient_val(islin, - libisl.isl_dim_set, sid, val) + libisl.isl_dim_set, index, islval) if inequality.constant != 0: - val = str(inequality.constant).encode() - val = libisl.isl_val_read_from_str(mainctx, val) - islin = libisl.isl_constraint_set_constant_val(islin, val) + islval = str(inequality.constant).encode() + islval = libisl.isl_val_read_from_str(mainctx, islval) + islin = libisl.isl_constraint_set_constant_val(islin, islval) islbset = libisl.isl_basic_set_add_constraint(islbset, islin) return islbset @@ -163,46 +173,20 @@ class Polyhedron(Domain): else: strings = [] for equality in self.equalities: - strings.append('Eq({}, 0)'.format(equality)) + strings.append('0 == {}'.format(equality)) for inequality in self.inequalities: - strings.append('Ge({}, 0)'.format(inequality)) + strings.append('0 <= {}'.format(inequality)) if len(strings) == 1: return strings[0] else: return 'And({})'.format(', '.join(strings)) - @classmethod - def _fromsympy(cls, expr): - import sympy - equalities = [] - inequalities = [] - if expr.func == sympy.And: - for arg in expr.args: - arg_eqs, arg_ins = cls._fromsympy(arg) - equalities.extend(arg_eqs) - inequalities.extend(arg_ins) - elif expr.func == sympy.Eq: - expr = Expression.fromsympy(expr.args[0] - expr.args[1]) - equalities.append(expr) - else: - if expr.func == sympy.Lt: - expr = Expression.fromsympy(expr.args[1] - expr.args[0] - 1) - elif expr.func == sympy.Le: - expr = Expression.fromsympy(expr.args[1] - expr.args[0]) - elif expr.func == sympy.Ge: - expr = Expression.fromsympy(expr.args[0] - expr.args[1]) - elif expr.func == sympy.Gt: - expr = Expression.fromsympy(expr.args[0] - expr.args[1] - 1) - else: - raise ValueError('non-polyhedral expression: {!r}'.format(expr)) - inequalities.append(expr) - return equalities, inequalities - @classmethod def fromsympy(cls, expr): - import sympy - equalities, inequalities = cls._fromsympy(expr) - return cls(equalities, inequalities) + domain = Domain.fromsympy(expr) + if not isinstance(domain, Polyhedron): + raise ValueError('non-polyhedral expression: {!r}'.format(expr)) + return domain def tosympy(self): import sympy @@ -213,17 +197,92 @@ class Polyhedron(Domain): constraints.append(sympy.Ge(inequality.tosympy(), 0)) return sympy.And(*constraints) + @classmethod + def _sort_polygon_2d(cls, points): + if len(points) <= 3: + return points + o = sum((Vector(point) for point in points)) / len(points) + o = Point(o.coordinates()) + angles = {} + for m in points: + om = Vector(o, m) + dx, dy = (coordinate for symbol, coordinates 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 = sum((Vector(point) for point in points)) / len(points) + o = Point(o.coordinates()) + a, b = points[:2] + oa = Vector(o, a) + ob = Vector(o, b) + norm_oa = oa.norm() + u = (oa.cross(ob)).asunit() + 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 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 = Constant(left) + 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 = Constant(right) + right = Rational(right) elif not isinstance(right, Expression): raise TypeError('right must be a a rational number ' 'or a linear expression')