def _make_Vertex(self, polyhedron, data):
"""
Create a new vertex object.
INPUT:
- ``polyhedron`` -- the new polyhedron.
- ``data`` -- the V-representation data.
OUTPUT:
A new :class:`~sage.geometry.polyhedron.representation.Vertex` object.
EXAMPLES::
sage: p = Polyhedron([(1,2,3),(2/3,3/4,4/5)], rays=[(5/6,6/7,7/8)]) # indirect doctest
sage: p.vertex_generator().next()
A vertex at (1, 2, 3)
"""
try:
obj = self._Vertex_pool.pop()
except IndexError:
obj = Vertex(self)
obj._set_data(polyhedron, data)
return obj
def _make_Vertex(self, polyhedron, data):
"""
Create a new vertex object.
INPUT:
- ``polyhedron`` -- the new polyhedron.
- ``data`` -- the V-representation data.
OUTPUT:
A new :class:`~sage.geometry.polyhedron.representation.Vertex` object.
EXAMPLES::
sage: p = Polyhedron([(1,2,3),(2/3,3/4,4/5)], rays=[(5/6,6/7,7/8)]) # indirect doctest
sage: next(p.vertex_generator())
A vertex at (1, 2, 3)
"""
try:
obj = self._Vertex_pool.pop()
except IndexError:
obj = Vertex(self)
obj._set_data(polyhedron, data)
return obj
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()
for g in gs:
if g.is_point():
d = g.divisor()
Vertex(self, [x / d for x in g.coefficients()])
elif g.is_ray():
Ray(self, g.coefficients())
elif g.is_line():
Line(self, g.coefficients())
else:
assert False
self._Vrepresentation = tuple(self._Vrepresentation)
def _init_from_cdd_output(self, cdd_output_string):
"""
Initialize ourselves with the output from cdd.
TESTS::
sage: from sage.geometry.polyhedron.cdd_file_format import cdd_Vrepresentation
sage: s = cdd_Vrepresentation('rational',[[0,0],[1,0],[0,1],[1,1]], [], [])
sage: from subprocess import Popen, PIPE
sage: cdd_proc = Popen(['cdd_both_reps_gmp', '--all'], stdin=PIPE, stdout=PIPE, stderr=PIPE)
sage: ans, err = cdd_proc.communicate(input=s)
sage: p = Polyhedron(vertices = [[0,0],[1,0],[0,1],[1,1]], backend='cddr')
sage: p._init_from_cdd_output(ans)
sage: p.vertices()
[[0, 0], [1, 0], [0, 1], [1, 1]]
"""
cddout=cdd_output_string.splitlines()
suppressed_vertex = False # whether cdd suppressed the vertex in output
# nested function
def expect_in_cddout(expected_string):
l = cddout.pop(0).strip()
if l!=expected_string:
raise ValueError, ('Error while parsing cdd output: expected "'
+expected_string+'" but got "'+l+'".\n' )
# nested function
def cdd_linearities():
l = cddout[0].split()
if l[0] != "linearity":
return []
cddout.pop(0)
assert len(l) == int(l[1])+2, "Not enough linearities given"
return [int(i)-1 for i in l[2:]] # make indices pythonic
# nested function
def cdd_convert(string, field=self.field()):
"""
Converts the cdd output string to a numerical value.
"""
return [field(x) for x in string.split()]
# nested function
def find_in_cddout(expected_string):
"""
Find the expected string in a list of strings, and
truncates ``cddout`` to start at that point. Returns
``False`` if search fails.
"""
for pos in range(0,len(cddout)):
l = cddout[pos].strip();
if l==expected_string:
# must not assign to cddout in nested function
for i in range(0,pos+1):
cddout.pop(0)
return True
return False
if find_in_cddout('V-representation'):
self._Vrepresentation = []
lines = cdd_linearities()
expect_in_cddout('begin')
l = cddout.pop(0).split()
assert self._ambient_dim == int(l[1])-1, "Different ambient dimension?"
suppressed_vertex = True
for i in range(int(l[0])):
l = cddout.pop(0).strip()
l_type = l[0]
l = l[1:]
if i in lines:
Line(self, cdd_convert(l));
elif l_type == '0':
Ray(self, cdd_convert(l));
else:
Vertex(self, cdd_convert(l));
suppressed_vertex = False
if suppressed_vertex and self.n_Vrepresentation()>0:
# cdd does not output the vertex if it is only the origin
Vertex(self, [0] * self._ambient_dim)
self._Vrepresentation = tuple(self._Vrepresentation)
expect_in_cddout('end')
if find_in_cddout('H-representation'):
self._Hrepresentation = []
equations = cdd_linearities()
expect_in_cddout('begin')
l = cddout.pop(0).split()
assert self._ambient_dim == int(l[1])-1, "Different ambient dimension?"
for i in range(int(l[0])):
l = cddout.pop(0)
if i in equations:
Equation(self, cdd_convert(l));
else:
Inequality(self, cdd_convert(l));
self._Hrepresentation = tuple(self._Hrepresentation)
expect_in_cddout('end')
# nested function
def cdd_adjacencies():
l = cddout.pop(0).split()
assert l[2] == ':', "Not a line of the adjacency data?"
return [int(i)-1 for i in l[3:]]
if find_in_cddout('Vertex graph'):
n = len(self._Vrepresentation);
if suppressed_vertex:
n_cdd=n-1;
else:
n_cdd=n;
self._V_adjacency_matrix = matrix(ZZ, n, n, 0)
expect_in_cddout('begin')
l = cddout.pop(0).split()
assert int(l[0]) == n_cdd, "Not enough V-adjacencies in cdd output?"
for i in range(n_cdd):
for a in cdd_adjacencies():
self._V_adjacency_matrix[i,a] = 1
# cdd reports that lines are never adjacent to anything.
# I disagree, they are adjacent to everything!
if self._Vrepresentation[i].is_line():
for j in range(n):
self._V_adjacency_matrix[i,j] = 1
self._V_adjacency_matrix[j,i] = 1
self._V_adjacency_matrix[i,i] = 0
if suppressed_vertex: # cdd implied that there is only one vertex
for i in range(n-1):
self._V_adjacency_matrix[i,n-1] = 1
self._V_adjacency_matrix[n-1,i] = 1
self._V_adjacency_matrix.set_immutable()
expect_in_cddout('end')
if find_in_cddout('Facet graph'):
n = len(self._Hrepresentation);
self._H_adjacency_matrix = matrix(ZZ, n, n, 0)
expect_in_cddout('begin')
l = cddout.pop(0).split()
assert int(l[0]) == n, "Not enough H-adjacencies in cdd output?"
for i in range(n):
for a in cdd_adjacencies():
self._H_adjacency_matrix[i,a] = 1
self._H_adjacency_matrix.set_immutable()
expect_in_cddout('end')