class Polyhedron_ppl(Polyhedron_base):
"""
Polyhedra with ppl
INPUT:
- ``Vrep`` -- a list ``[vertices, rays, lines]`` or ``None``.
- ``Hrep`` -- a list ``[ieqs, eqns]`` or ``None``.
EXAMPLES::
sage: p = Polyhedron(vertices=[(0,0),(1,0),(0,1)], rays=[(1,1)], lines=[], backend='ppl')
sage: TestSuite(p).run()
"""
def _init_from_Vrepresentation(self, vertices, rays, lines, minimize=True, verbose=False):
"""
Construct polyhedron from V-representation data.
INPUT:
- ``vertices`` -- list of point. Each point can be specified
as any iterable container of
:meth:`~sage.geometry.polyhedron.base.base_ring` elements.
- ``rays`` -- list of rays. Each ray can be specified as any
iterable container of
:meth:`~sage.geometry.polyhedron.base.base_ring` elements.
- ``lines`` -- list of lines. Each line can be specified as
any iterable container of
:meth:`~sage.geometry.polyhedron.base.base_ring` elements.
- ``verbose`` -- boolean (default: ``False``). Whether to print
verbose output for debugging purposes.
EXAMPLES::
sage: p = Polyhedron(backend='ppl')
sage: from sage.geometry.polyhedron.backend_ppl import Polyhedron_ppl
sage: Polyhedron_ppl._init_from_Vrepresentation(p, [], [], [])
"""
gs = Generator_System()
if vertices is None: vertices = []
for v in vertices:
d = LCM_list([denominator(v_i) for v_i in v])
if d.is_one():
gs.insert(point(Linear_Expression(v, 0)))
else:
dv = [ d*v_i for v_i in v ]
gs.insert(point(Linear_Expression(dv, 0), d))
if rays is None: rays = []
for r in rays:
d = LCM_list([denominator(r_i) for r_i in r])
if d.is_one():
gs.insert(ray(Linear_Expression(r, 0)))
else:
dr = [ d*r_i for r_i in r ]
gs.insert(ray(Linear_Expression(dr, 0)))
if lines is None: lines = []
for l in lines:
d = LCM_list([denominator(l_i) for l_i in l])
if d.is_one():
gs.insert(line(Linear_Expression(l, 0)))
else:
dl = [ d*l_i for l_i in l ]
gs.insert(line(Linear_Expression(dl, 0)))
if gs.empty():
self._ppl_polyhedron = C_Polyhedron(self.ambient_dim(), 'empty')
else:
self._ppl_polyhedron = C_Polyhedron(gs)
self._init_Vrepresentation_from_ppl(minimize)
self._init_Hrepresentation_from_ppl(minimize)
def _init_from_Hrepresentation(self, ieqs, eqns, minimize=True, verbose=False):
"""
Construct polyhedron from H-representation data.
INPUT:
- ``ieqs`` -- list of inequalities. Each line can be specified
as any iterable container of
:meth:`~sage.geometry.polyhedron.base.base_ring` elements.
- ``eqns`` -- list of equalities. Each line can be specified
as any iterable container of
:meth:`~sage.geometry.polyhedron.base.base_ring` elements.
- ``verbose`` -- boolean (default: ``False``). Whether to print
verbose output for debugging purposes.
EXAMPLES::
sage: p = Polyhedron(backend='ppl')
sage: from sage.geometry.polyhedron.backend_ppl import Polyhedron_ppl
sage: Polyhedron_ppl._init_from_Hrepresentation(p, [], [])
"""
cs = Constraint_System()
if ieqs is None: ieqs = []
for ieq in ieqs:
d = LCM_list([denominator(ieq_i) for ieq_i in ieq])
dieq = [ ZZ(d*ieq_i) for ieq_i in ieq ]
b = dieq[0]
A = dieq[1:]
cs.insert(Linear_Expression(A, b) >= 0)
if eqns is None: eqns = []
for eqn in eqns:
d = LCM_list([denominator(eqn_i) for eqn_i in eqn])
deqn = [ ZZ(d*eqn_i) for eqn_i in eqn ]
b = deqn[0]
A = deqn[1:]
cs.insert(Linear_Expression(A, b) == 0)
if cs.empty():
self._ppl_polyhedron = C_Polyhedron(self.ambient_dim(), 'universe')
else:
self._ppl_polyhedron = C_Polyhedron(cs)
self._init_Vrepresentation_from_ppl(minimize)
self._init_Hrepresentation_from_ppl(minimize)
def _init_Vrepresentation_from_ppl(self, minimize):
"""
Create the Vrepresentation objects from the ppl polyhedron.
EXAMPLES::
sage: p = Polyhedron(vertices=[(0,1/2),(2,0),(4,5/6)],
....: backend='ppl') # indirect doctest
sage: p.Hrepresentation()
(An inequality (1, 4) x - 2 >= 0,
An inequality (1, -12) x + 6 >= 0,
An inequality (-5, 12) x + 10 >= 0)
sage: p._ppl_polyhedron.minimized_constraints()
Constraint_System {x0+4*x1-2>=0, x0-12*x1+6>=0, -5*x0+12*x1+10>=0}
sage: p.Vrepresentation()
(A vertex at (0, 1/2), A vertex at (2, 0), A vertex at (4, 5/6))
sage: p._ppl_polyhedron.minimized_generators()
Generator_System {point(0/2, 1/2), point(2/1, 0/1), point(24/6, 5/6)}
"""
self._Vrepresentation = []
gs = self._ppl_polyhedron.minimized_generators()
parent = self.parent()
for g in gs:
coefficients = [Integer(mpz) for mpz in g.coefficients()]
if g.is_point():
d = Integer(g.divisor())
if d.is_one():
parent._make_Vertex(self, coefficients)
else:
parent._make_Vertex(self, [x/d for x in coefficients])
elif g.is_ray():
parent._make_Ray(self, coefficients)
elif g.is_line():
parent._make_Line(self, coefficients)
else:
assert False
self._Vrepresentation = tuple(self._Vrepresentation)
def _init_Hrepresentation_from_ppl(self, minimize):
"""
Create the Hrepresentation objects from the ppl polyhedron.
EXAMPLES::
sage: p = Polyhedron(vertices=[(0,1/2),(2,0),(4,5/6)],
....: backend='ppl') # indirect doctest
sage: p.Hrepresentation()
(An inequality (1, 4) x - 2 >= 0,
An inequality (1, -12) x + 6 >= 0,
An inequality (-5, 12) x + 10 >= 0)
sage: p._ppl_polyhedron.minimized_constraints()
Constraint_System {x0+4*x1-2>=0, x0-12*x1+6>=0, -5*x0+12*x1+10>=0}
sage: p.Vrepresentation()
(A vertex at (0, 1/2), A vertex at (2, 0), A vertex at (4, 5/6))
sage: p._ppl_polyhedron.minimized_generators()
Generator_System {point(0/2, 1/2), point(2/1, 0/1), point(24/6, 5/6)}
"""
self._Hrepresentation = []
cs = self._ppl_polyhedron.minimized_constraints()
parent = self.parent()
for c in cs:
if c.is_inequality():
parent._make_Inequality(self, (c.inhomogeneous_term(),) + c.coefficients())
elif c.is_equality():
parent._make_Equation(self, (c.inhomogeneous_term(),) + c.coefficients())
self._Hrepresentation = tuple(self._Hrepresentation)
def _init_empty_polyhedron(self):
"""
Initializes an empty polyhedron.
TESTS::
sage: empty = Polyhedron(backend='ppl'); empty
The empty polyhedron in ZZ^0
sage: empty.Vrepresentation()
()
sage: empty.Hrepresentation()
(An equation -1 == 0,)
sage: Polyhedron(vertices = [], backend='ppl')
The empty polyhedron in ZZ^0
sage: Polyhedron(backend='ppl')._init_empty_polyhedron()
"""
super(Polyhedron_ppl, self)._init_empty_polyhedron()
self._ppl_polyhedron = C_Polyhedron(self.ambient_dim(), 'empty')
class Polytope(object):
def __init__(self, halfspaces=None, vertices=None):
if halfspaces is not None:
self.halfspaces = halfspaces
self.dim = halfspaces[0][0].dim
self.poly = self.poly_from_constraints(halfspaces)
self.vertices = self.vertices_from_poly()
elif vertices is not None:
v = vertices.pop()
self.dim = v.dim
vertices.add(v)
self.poly = self.poly_from_vertices(vertices)
self.vertices = self.vertices_from_poly()
self.hyperplanes = self.hyperplanes_from_poly()
self.halfspaces = zip(self.hyperplanes, [1] * len(self.hyperplanes))
else:
self.hyperplanes = []
self.halfspaces = []
self.vertices = []
self.poly = C_Polyhedron(0)
def as_convex_hull(self):
vertices = np.array([vertex.coordinates for vertex in self.vertices])
convex_hull = ConvexHull(vertices, qhull_options='Pp')
return convex_hull
def get_vertex_coordinates(self):
return np.array([v.coordinates for v in self.vertices])
def vertices_from_poly(self):
# Get vertices of polytope resulting from intersection. only points not rays
return np.array([Vertex(pt) for pt in self.poly.minimized_generators() if pt.is_point()])
def poly_from_constraints(self, halfspaces):
# Create PPL variables.
x = [Variable(i) for i in range(self.dim)]
# Init constraint system.
constraints = Constraint_System()
# Add polytope facets to constraint systems.
# Format of ConvexHull.equations: [a1 a2 .. b] => a1*x1 + a2*x2 + .. + b <= 0.
for hyp, orient in halfspaces:
if orient == -1:
constraints.insert(sum(hyp.a[i] * x[i] for i in range(self.dim)) + hyp.b <= 0)
elif orient == 1:
constraints.insert(sum(hyp.a[i] * x[i] for i in range(self.dim)) + hyp.b >= 0)
elif orient == 0:
constraints.insert(sum(hyp.a[i] * x[i] for i in range(self.dim)) + hyp.b == 0)
# Build PPL polyhedra.
return C_Polyhedron(constraints)
def poly_from_vertices(self, vertices):
# Create PPL variables.
x = [Variable(i) for i in range(self.dim)]
# Init constraint system.
generators = Generator_System()
# ppl needs coordinates in form of point(sum(a_i *x_i), denom) with a_i integers
for vertex in vertices:
generators.insert(vertex.ppl)
# Build PPL polyhedra.
return C_Polyhedron(generators)
def hyperplanes_from_poly(self):
logging.debug('<nr generators: {}>, <nr constraints: {}>'
.format(len(self.poly.generators()), len(self.poly.constraints())))
hyperplanes = []
# constraints in ppl are saved as of the form ax + b >= 0
for constraint in self.poly.minimized_constraints():
a = np.array(constraint.coefficients())
b = constraint.inhomogeneous_term()
hyperplane = Hyperplane(a, b)
hyperplanes.append(hyperplane)
return hyperplanes
def add_constraint(self, halfspace):
# Create PPL variables.
x = [Variable(i) for i in range(self.dim)]
if halfspace[1] == -1:
self.poly.add_constraint(
sum(halfspace[0].a[i] * x[i] for i in range(self.dim)) + halfspace[0].b <= 0)
elif halfspace[1] == 1:
self.poly.add_constraint(
sum(halfspace[0].a[i] * x[i] for i in range(self.dim)) + halfspace[0].b >= 0)
elif halfspace[1] == 0:
self.poly.add_constraint(
sum(halfspace[0].a[i] * x[i] for i in range(self.dim)) + halfspace[0].b == 0)
self.hyperplanes = self.hyperplanes_from_poly()
self.halfspaces.append(halfspace)
self.vertices = self.vertices_from_poly()
def point_in_poly(self, point):
return self.poly.relation_with(point.ppl).implies(Poly_Gen_Relation.subsumes())
class Polyhedron_ppl(Polyhedron_base):
"""
Polyhedra with ppl
INPUT:
- ``Vrep`` -- a list ``[vertices, rays, lines]`` or ``None``.
- ``Hrep`` -- a list ``[ieqs, eqns]`` or ``None``.
EXAMPLES::
sage: p = Polyhedron(vertices=[(0,0),(1,0),(0,1)], rays=[(1,1)], lines=[], backend='ppl')
sage: TestSuite(p).run()
"""
def _init_from_Vrepresentation(self,
vertices,
rays,
lines,
minimize=True,
verbose=False):
"""
Construct polyhedron from V-representation data.
INPUT:
- ``vertices`` -- list of point. Each point can be specified
as any iterable container of
:meth:`~sage.geometry.polyhedron.base.base_ring` elements.
- ``rays`` -- list of rays. Each ray can be specified as any
iterable container of
:meth:`~sage.geometry.polyhedron.base.base_ring` elements.
- ``lines`` -- list of lines. Each line can be specified as
any iterable container of
:meth:`~sage.geometry.polyhedron.base.base_ring` elements.
- ``verbose`` -- boolean (default: ``False``). Whether to print
verbose output for debugging purposes.
EXAMPLES::
sage: p = Polyhedron(backend='ppl')
sage: from sage.geometry.polyhedron.backend_ppl import Polyhedron_ppl
sage: Polyhedron_ppl._init_from_Vrepresentation(p, [], [], [])
"""
gs = Generator_System()
if vertices is None: vertices = []
for v in vertices:
d = LCM_list([denominator(v_i) for v_i in v])
if d.is_one():
gs.insert(point(Linear_Expression(v, 0)))
else:
dv = [d * v_i for v_i in v]
gs.insert(point(Linear_Expression(dv, 0), d))
if rays is None: rays = []
for r in rays:
d = LCM_list([denominator(r_i) for r_i in r])
if d.is_one():
gs.insert(ray(Linear_Expression(r, 0)))
else:
dr = [d * r_i for r_i in r]
gs.insert(ray(Linear_Expression(dr, 0)))
if lines is None: lines = []
for l in lines:
d = LCM_list([denominator(l_i) for l_i in l])
if d.is_one():
gs.insert(line(Linear_Expression(l, 0)))
else:
dl = [d * l_i for l_i in l]
gs.insert(line(Linear_Expression(dl, 0)))
if gs.empty():
self._ppl_polyhedron = C_Polyhedron(self.ambient_dim(), 'empty')
else:
self._ppl_polyhedron = C_Polyhedron(gs)
self._init_Vrepresentation_from_ppl(minimize)
self._init_Hrepresentation_from_ppl(minimize)
def _init_from_Hrepresentation(self,
ieqs,
eqns,
minimize=True,
verbose=False):
"""
Construct polyhedron from H-representation data.
INPUT:
- ``ieqs`` -- list of inequalities. Each line can be specified
as any iterable container of
:meth:`~sage.geometry.polyhedron.base.base_ring` elements.
- ``eqns`` -- list of equalities. Each line can be specified
as any iterable container of
:meth:`~sage.geometry.polyhedron.base.base_ring` elements.
- ``verbose`` -- boolean (default: ``False``). Whether to print
verbose output for debugging purposes.
EXAMPLES::
sage: p = Polyhedron(backend='ppl')
sage: from sage.geometry.polyhedron.backend_ppl import Polyhedron_ppl
sage: Polyhedron_ppl._init_from_Hrepresentation(p, [], [])
"""
cs = Constraint_System()
if ieqs is None: ieqs = []
for ieq in ieqs:
d = LCM_list([denominator(ieq_i) for ieq_i in ieq])
dieq = [ZZ(d * ieq_i) for ieq_i in ieq]
b = dieq[0]
A = dieq[1:]
cs.insert(Linear_Expression(A, b) >= 0)
if eqns is None: eqns = []
for eqn in eqns:
d = LCM_list([denominator(eqn_i) for eqn_i in eqn])
deqn = [ZZ(d * eqn_i) for eqn_i in eqn]
b = deqn[0]
A = deqn[1:]
cs.insert(Linear_Expression(A, b) == 0)
if cs.empty():
self._ppl_polyhedron = C_Polyhedron(self.ambient_dim(), 'universe')
else:
self._ppl_polyhedron = C_Polyhedron(cs)
self._init_Vrepresentation_from_ppl(minimize)
self._init_Hrepresentation_from_ppl(minimize)
def _init_Vrepresentation_from_ppl(self, minimize):
"""
Create the Vrepresentation objects from the ppl polyhedron.
EXAMPLES::
sage: p = Polyhedron(vertices=[(0,1/2),(2,0),(4,5/6)],
....: backend='ppl') # indirect doctest
sage: p.Hrepresentation()
(An inequality (1, 4) x - 2 >= 0,
An inequality (1, -12) x + 6 >= 0,
An inequality (-5, 12) x + 10 >= 0)
sage: p._ppl_polyhedron.minimized_constraints()
Constraint_System {x0+4*x1-2>=0, x0-12*x1+6>=0, -5*x0+12*x1+10>=0}
sage: p.Vrepresentation()
(A vertex at (0, 1/2), A vertex at (2, 0), A vertex at (4, 5/6))
sage: p._ppl_polyhedron.minimized_generators()
Generator_System {point(0/2, 1/2), point(2/1, 0/1), point(24/6, 5/6)}
"""
self._Vrepresentation = []
gs = self._ppl_polyhedron.minimized_generators()
parent = self.parent()
for g in gs:
coefficients = [Integer(mpz) for mpz in g.coefficients()]
if g.is_point():
d = Integer(g.divisor())
if d.is_one():
parent._make_Vertex(self, coefficients)
else:
parent._make_Vertex(self, [x / d for x in coefficients])
elif g.is_ray():
parent._make_Ray(self, coefficients)
elif g.is_line():
parent._make_Line(self, coefficients)
else:
assert False
self._Vrepresentation = tuple(self._Vrepresentation)
def _init_Hrepresentation_from_ppl(self, minimize):
"""
Create the Hrepresentation objects from the ppl polyhedron.
EXAMPLES::
sage: p = Polyhedron(vertices=[(0,1/2),(2,0),(4,5/6)],
....: backend='ppl') # indirect doctest
sage: p.Hrepresentation()
(An inequality (1, 4) x - 2 >= 0,
An inequality (1, -12) x + 6 >= 0,
An inequality (-5, 12) x + 10 >= 0)
sage: p._ppl_polyhedron.minimized_constraints()
Constraint_System {x0+4*x1-2>=0, x0-12*x1+6>=0, -5*x0+12*x1+10>=0}
sage: p.Vrepresentation()
(A vertex at (0, 1/2), A vertex at (2, 0), A vertex at (4, 5/6))
sage: p._ppl_polyhedron.minimized_generators()
Generator_System {point(0/2, 1/2), point(2/1, 0/1), point(24/6, 5/6)}
"""
self._Hrepresentation = []
cs = self._ppl_polyhedron.minimized_constraints()
parent = self.parent()
for c in cs:
if c.is_inequality():
parent._make_Inequality(self, (c.inhomogeneous_term(), ) +
c.coefficients())
elif c.is_equality():
parent._make_Equation(self, (c.inhomogeneous_term(), ) +
c.coefficients())
self._Hrepresentation = tuple(self._Hrepresentation)
def _init_empty_polyhedron(self):
"""
Initializes an empty polyhedron.
TESTS::
sage: empty = Polyhedron(backend='ppl'); empty
The empty polyhedron in ZZ^0
sage: empty.Vrepresentation()
()
sage: empty.Hrepresentation()
(An equation -1 == 0,)
sage: Polyhedron(vertices = [], backend='ppl')
The empty polyhedron in ZZ^0
sage: Polyhedron(backend='ppl')._init_empty_polyhedron()
"""
super(Polyhedron_ppl, self)._init_empty_polyhedron()
self._ppl_polyhedron = C_Polyhedron(self.ambient_dim(), 'empty')
