def verify(self, inequalities, equations):
"""
Compare result to PPL if the base ring is QQ.
This method is for debugging purposes and compares the
computation with another backend if available.
INPUT:
- ``inequalities``, ``equations`` -- see :class:`Hrep2Vrep`.
EXAMPLES::
sage: from sage.geometry.polyhedron.double_description_inhomogeneous import Hrep2Vrep
sage: H = Hrep2Vrep(QQ, 1, [(1,2)], [])
sage: H.verify([(1,2)], [])
"""
from sage.rings.all import QQ
from sage.geometry.polyhedron.constructor import Polyhedron
if self.base_ring is not QQ:
return
P = Polyhedron(vertices=self.vertices, rays=self.rays, lines=self.lines,
base_ring=QQ, ambient_dim=self.dim, backend='ppl')
Q = Polyhedron(ieqs=inequalities, eqns=equations,
base_ring=QQ, ambient_dim=self.dim, backend='ppl')
if (P != Q) or \
(len(self.vertices) != P.n_vertices()) or \
(len(self.rays) != P.n_rays()) or \
(len(self.lines) != P.n_lines()):
print 'incorrect!',
print Q.Vrepresentation()
print P.Hrepresentation()
def verify(self, vertices, rays, lines):
"""
Compare result to PPL if the base ring is QQ.
This method is for debugging purposes and compares the
computation with another backend if available.
INPUT:
- ``vertices``, ``rays``, ``lines`` -- see :class:`Vrep2Hrep`.
EXAMPLES::
sage: from sage.geometry.polyhedron.double_description_inhomogeneous import Vrep2Hrep
sage: vertices = [(-1/2,0)]
sage: rays = [(-1/2,2/3), (1/2,-1/3)]
sage: lines = []
sage: V2H = Vrep2Hrep(QQ, 2, vertices, rays, lines)
sage: V2H.verify(vertices, rays, lines)
"""
from sage.rings.all import QQ
from sage.geometry.polyhedron.constructor import Polyhedron
if self.base_ring is not QQ:
return
P = Polyhedron(vertices=vertices, rays=rays, lines=lines,
base_ring=QQ, ambient_dim=self.dim)
trivial = [self.base_ring.one()] + [self.base_ring.zero()] * self.dim # always true equation
Q = Polyhedron(ieqs=self.inequalities + [trivial], eqns=self.equations,
base_ring=QQ, ambient_dim=self.dim)
if not P == Q:
print 'incorrect!', P, Q
print Q.Vrepresentation()
print P.Hrepresentation()
def family_two(n, backend=None):
r"""
Return the vector configuration of the simplicial arrangement
`A(n,1)` from the family `\mathcal R(1)` in Grunbaum's list [Gru]_.
The arrangement will have an ``n`` hyperplanes, with ``n`` even, consisting
of the edges of the regular `n/2`-gon and the `n/2` lines of
mirror symmetry.
INPUT:
- ``n`` -- integer. ``n`` `\geq 6`. The number of lines in the arrangement.
- ``backend`` -- string (default = ``None``). The backend to use.
OUTPUT:
A vector configuration.
EXAMPLES::
sage: from cn_hyperarr.infinite_families import *
sage: pf = family_two(8,'normaliz'); pf # optional - pynormaliz
Vector configuration of 8 vectors in dimension 3
The number of lines must be even::
sage: pf3 = family_two(3,'normaliz'); # optional - pynormaliz
Traceback (most recent call last):
...
AssertionError: n must be even
The number of lines must be at least 6::
sage: pf4 = family_two(4,'normaliz') # optional - pynormaliz
Traceback (most recent call last):
...
ValueError: n (=2) must be an integer greater than 2
"""
assert n % 2 == 0, "n must be even"
reg_poly = polytopes.regular_polygon(n / QQ(2), backend='normaliz')
reg_cone = Polyhedron(
rays=[list(v.vector()) + [1] for v in reg_poly.vertices()],
backend=backend)
vecs = [h.A() for h in reg_cone.Hrepresentation()]
z = QQbar.zeta(n)
vecs += [[(z**k).real(), (z**k).imag(), 0] for k in range(n / QQ(2))]
return VectorConfiguration(vecs, backend=backend)
def __init__(self, points):
r"""
See ``VoronoiDiagram`` for full documentation.
EXAMPLES::
sage: V = VoronoiDiagram([[1, 3, 3], [2, -2, 1], [-1 ,2, -1]]); V
The Voronoi diagram of 3 points of dimension 3 in the Rational Field
"""
self._P = {}
self._points = PointConfiguration(points)
self._n = self._points.n_points()
if not self._n or self._points.base_ring().is_subring(QQ):
self._base_ring = QQ
elif self._points.base_ring() in [RDF, AA]:
self._base_ring = self._points.base_ring()
elif isinstance(self._points.base_ring(), RealField_class):
self._base_ring = RDF
self._points = PointConfiguration([[RDF(cor) for cor in poi]
for poi in self._points])
else:
raise NotImplementedError('Base ring of the Voronoi diagram must '
'be one of QQ, RDF, AA.')
if self._n > 0:
self._d = self._points.ambient_dim()
e = [([sum(vector(i)[k] ** 2
for k in range(self._d))] +
[(-2) * vector(i)[l] for l in range(self._d)] + [1])
for i in self._points]
# we attach hyperplane to the paraboloid
e = [[self._base_ring(i) for i in k] for k in e]
p = Polyhedron(ieqs=e, base_ring=self._base_ring)
# To understand the reordering that takes place when
# defining a rational polyhedron, we generate two sorted
# lists, that are used a few lines below
if self.base_ring() == QQ:
enormalized = []
for ineq in e:
if ineq[0] == 0:
enormalized.append(ineq)
else:
enormalized.append([i / ineq[0] for i in ineq[1:]])
# print enormalized
hlist = [list(ineq) for ineq in p.Hrepresentation()]
hlistnormalized = []
for ineq in hlist:
if ineq[0] == 0:
hlistnormalized.append(ineq)
else:
hlistnormalized.append([i / ineq[0] for i in ineq[1:]])
# print hlistnormalized
for i in range(self._n):
# for base ring RDF and AA, Polyhedron keeps the order of the
# points in the input, for QQ we resort
if self.base_ring() == QQ:
equ = p.Hrepresentation(hlistnormalized.index(enormalized[i]))
else:
equ = p.Hrepresentation(i)
pvert = [[u[k] for k in range(self._d)] for u in equ.incident()
if u.is_vertex()]
prays = [[u[k] for k in range(self._d)] for u in equ.incident()
if u.is_ray()]
pline = [[u[k] for k in range(self._d)] for u in equ.incident()
if u.is_line()]
(self._P)[self._points[i]] = Polyhedron(vertices=pvert,
lines=pline, rays=prays,
base_ring=self._base_ring)
