Base class for polyhedra: Methods for triangulation and volume computation#

class sage.geometry.polyhedron.base7.Polyhedron_base7(parent, Vrep, Hrep, Vrep_minimal=None, Hrep_minimal=None, pref_rep=None, mutable=False, **kwds)[source]#

Bases: Polyhedron_base6

Methods related to triangulation and volume.

centroid(engine='auto', **kwds)[source]#

Return the center of the mass of the polytope.

The mass is taken with respect to the induced Lebesgue measure, see volume().

If the polyhedron is not compact, a NotImplementedError is raised.

INPUT:

engine – either ‘auto’ (default), ‘internal’, ‘TOPCOM’, or ‘normaliz’. The ‘internal’ and ‘TOPCOM’ instruct this package to always use its own triangulation algorithms or TOPCOM’s algorithms, respectively. By default (‘auto’), TOPCOM is used if it is available and internal routines otherwise.
**kwds – keyword arguments that are passed to the triangulation engine (see triangulate()).

OUTPUT: The centroid as vector.

ALGORITHM:

We triangulate the polytope and find the barycenter of the simplices. We add the individual barycenters weighted by the fraction of the total mass.

EXAMPLES:

Sage

sage: P = polytopes.hypercube(2).pyramid()
sage: P.centroid()
(1/4, 0, 0)

sage: P = polytopes.associahedron(['A', 2])                                 # needs sage.combinat
sage: P.centroid()                                                          # needs sage.combinat
(2/21, 2/21)

sage: P = polytopes.permutahedron(4, backend='normaliz')    # optional - pynormaliz
sage: P.centroid()                                          # optional - pynormaliz
(5/2, 5/2, 5/2, 5/2)

Python

>>> from sage.all import *
>>> P = polytopes.hypercube(Integer(2)).pyramid()
>>> P.centroid()
(1/4, 0, 0)

>>> P = polytopes.associahedron(['A', Integer(2)])                                 # needs sage.combinat
>>> P.centroid()                                                          # needs sage.combinat
(2/21, 2/21)

>>> P = polytopes.permutahedron(Integer(4), backend='normaliz')    # optional - pynormaliz
>>> P.centroid()                                          # optional - pynormaliz
(5/2, 5/2, 5/2, 5/2)

The method is not implemented for unbounded polyhedra:

Sage

sage: P = Polyhedron(vertices=[(0, 0)], rays=[(1, 0), (0, 1)])
sage: P.centroid()
Traceback (most recent call last):
...
NotImplementedError: the polyhedron is not compact

Python

>>> from sage.all import *
>>> P = Polyhedron(vertices=[(Integer(0), Integer(0))], rays=[(Integer(1), Integer(0)), (Integer(0), Integer(1))])
>>> P.centroid()
Traceback (most recent call last):
...
NotImplementedError: the polyhedron is not compact

The centroid of an empty polyhedron is not defined:

Sage

sage: Polyhedron().centroid()
Traceback (most recent call last):
...
ZeroDivisionError: rational division by zero

Python

>>> from sage.all import *
>>> Polyhedron().centroid()
Traceback (most recent call last):
...
ZeroDivisionError: rational division by zero

integrate(function, measure='ambient', **kwds)[source]#

Return the integral of function over this polytope.

INPUT:

self – Polyhedron
function – a multivariate polynomial or a valid LattE description string for polynomials
measure – string, the measure to use

Allowed values are:
- ambient (default): Lebesgue measure of ambient space,
- induced: Lebesgue measure of the affine hull,
- induced_nonnormalized: Lebesgue measure of the affine hull without the normalization by \(\sqrt{\det(A^\top A)}\) (with \(A\) being the affine transformation matrix; see affine_hull()).
**kwds – additional keyword arguments that are passed to the engine

OUTPUT:

The integral of the polynomial over the polytope

Note

The polytope triangulation algorithm is used. This function depends on LattE (i.e., the latte_int optional package).

EXAMPLES:

Sage

sage: P = polytopes.cube()
sage: x, y, z = polygens(QQ, 'x, y, z')
sage: P.integrate(x^2*y^2*z^2)                              # optional - latte_int
8/27

Python

>>> from sage.all import *
>>> P = polytopes.cube()
>>> x, y, z = polygens(QQ, 'x, y, z')
>>> P.integrate(x**Integer(2)*y**Integer(2)*z**Integer(2))                              # optional - latte_int
8/27

If the polyhedron has floating point coordinates, an inexact result can be obtained if we transform to rational coordinates:

Sage

sage: P = 1.4142*polytopes.cube()
sage: P_QQ = Polyhedron(vertices=[[QQ(vi) for vi in v] for v in P.vertex_generator()])
sage: RDF(P_QQ.integrate(x^2*y^2*z^2))                      # optional - latte_int
6.703841212195228

Python

>>> from sage.all import *
>>> P = RealNumber('1.4142')*polytopes.cube()
>>> P_QQ = Polyhedron(vertices=[[QQ(vi) for vi in v] for v in P.vertex_generator()])
>>> RDF(P_QQ.integrate(x**Integer(2)*y**Integer(2)*z**Integer(2)))                      # optional - latte_int
6.703841212195228

Integral over a non full-dimensional polytope:

Sage

sage: x, y = polygens(QQ, 'x, y')
sage: P = Polyhedron(vertices=[[0,0], [1,1]])
sage: P.integrate(x*y)
0
sage: ixy = P.integrate(x*y, measure='induced'); ixy        # optional - latte_int
0.4714045207910317?
sage: ixy.parent()                                          # optional - latte_int
Algebraic Real Field

Python

>>> from sage.all import *
>>> x, y = polygens(QQ, 'x, y')
>>> P = Polyhedron(vertices=[[Integer(0),Integer(0)], [Integer(1),Integer(1)]])
>>> P.integrate(x*y)
0
>>> ixy = P.integrate(x*y, measure='induced'); ixy        # optional - latte_int
0.4714045207910317?
>>> ixy.parent()                                          # optional - latte_int
Algebraic Real Field

Convert to a symbolic expression:

Sage

sage: ixy.radical_expression()                              # optional - latte_int
1/3*sqrt(2)

Python

>>> from sage.all import *
>>> ixy.radical_expression()                              # optional - latte_int
1/3*sqrt(2)

Another non full-dimensional polytope integration:

Sage

sage: R.<x, y, z> = QQ[]
sage: P = polytopes.simplex(2)
sage: V = AA(P.volume(measure='induced'))                                   # needs sage.rings.number_field
sage: V.radical_expression()                                                # needs sage.rings.number_field sage.symbolic
1/2*sqrt(3)
sage: P.integrate(R(1), measure='induced') == V             # optional - latte_int, needs sage.rings.number_field sage.symbolic
True

Python

>>> from sage.all import *
>>> R = QQ['x, y, z']; (x, y, z,) = R._first_ngens(3)
>>> P = polytopes.simplex(Integer(2))
>>> V = AA(P.volume(measure='induced'))                                   # needs sage.rings.number_field
>>> V.radical_expression()                                                # needs sage.rings.number_field sage.symbolic
1/2*sqrt(3)
>>> P.integrate(R(Integer(1)), measure='induced') == V             # optional - latte_int, needs sage.rings.number_field sage.symbolic
True

Computing the mass center:

Sage

sage: (P.integrate(x, measure='induced')                    # optional - latte_int, needs sage.rings.number_field sage.symbolic
....:     / V).radical_expression()
1/3
sage: (P.integrate(y, measure='induced')                    # optional - latte_int, needs sage.rings.number_field sage.symbolic
....:     / V).radical_expression()
1/3
sage: (P.integrate(z, measure='induced')                    # optional - latte_int, needs sage.rings.number_field sage.symbolic
....:     / V).radical_expression()
1/3

Python

>>> from sage.all import *
>>> (P.integrate(x, measure='induced')                    # optional - latte_int, needs sage.rings.number_field sage.symbolic
...     / V).radical_expression()
1/3
>>> (P.integrate(y, measure='induced')                    # optional - latte_int, needs sage.rings.number_field sage.symbolic
...     / V).radical_expression()
1/3
>>> (P.integrate(z, measure='induced')                    # optional - latte_int, needs sage.rings.number_field sage.symbolic
...     / V).radical_expression()
1/3

triangulate(engine='auto', connected=True, fine=False, regular=None, star=None)[source]#

Return a triangulation of the polytope.

INPUT:

engine – either ‘auto’ (default), ‘internal’, ‘TOPCOM’, or ‘normaliz’. The ‘internal’ and ‘TOPCOM’ instruct this package to always use its own triangulation algorithms or TOPCOM’s algorithms, respectively. By default (‘auto’), TOPCOM is used if it is available and internal routines otherwise.

The remaining keyword parameters are passed through to the PointConfiguration constructor:

connected – boolean (default: True). Whether the triangulations should be connected to the regular triangulations via bistellar flips. These are much easier to compute than all triangulations.
fine – boolean (default: False). Whether the triangulations must be fine, that is, make use of all points of the configuration.
regular – boolean or None (default: None). Whether the triangulations must be regular. A regular triangulation is one that is induced by a piecewise-linear convex support function. In other words, the shadows of the faces of a polyhedron in one higher dimension.
- True: Only regular triangulations.
- False: Only non-regular triangulations.
- None (default): Both kinds of triangulation.
star – either None (default) or a point. Whether the triangulations must be star. A triangulation is star if all maximal simplices contain a common point. The central point can be specified by its index (an integer) in the given points or by its coordinates (anything iterable.)

OUTPUT:

A triangulation of the convex hull of the vertices as a Triangulation. The indices in the triangulation correspond to the Vrepresentation() objects.

EXAMPLES:

Sage

sage: cube = polytopes.hypercube(3)
sage: triangulation = cube.triangulate(
....:    engine='internal')  # to make doctest independent of TOPCOM
sage: triangulation
(<0,1,2,7>, <0,1,5,7>, <0,2,3,7>, <0,3,4,7>, <0,4,5,7>, <1,5,6,7>)
sage: simplex_indices = triangulation[0]; simplex_indices
(0, 1, 2, 7)
sage: simplex_vertices = [cube.Vrepresentation(i) for i in simplex_indices]
sage: simplex_vertices
[A vertex at (1, -1, -1),
 A vertex at (1, 1, -1),
 A vertex at (1, 1, 1),
 A vertex at (-1, 1, 1)]
sage: Polyhedron(simplex_vertices)
A 3-dimensional polyhedron in ZZ^3 defined as the convex hull of 4 vertices

Python

>>> from sage.all import *
>>> cube = polytopes.hypercube(Integer(3))
>>> triangulation = cube.triangulate(
...    engine='internal')  # to make doctest independent of TOPCOM
>>> triangulation
(<0,1,2,7>, <0,1,5,7>, <0,2,3,7>, <0,3,4,7>, <0,4,5,7>, <1,5,6,7>)
>>> simplex_indices = triangulation[Integer(0)]; simplex_indices
(0, 1, 2, 7)
>>> simplex_vertices = [cube.Vrepresentation(i) for i in simplex_indices]
>>> simplex_vertices
[A vertex at (1, -1, -1),
 A vertex at (1, 1, -1),
 A vertex at (1, 1, 1),
 A vertex at (-1, 1, 1)]
>>> Polyhedron(simplex_vertices)
A 3-dimensional polyhedron in ZZ^3 defined as the convex hull of 4 vertices

It is possible to use 'normaliz' as an engine. For this, the polyhedron should have the backend set to normaliz:

Sage

sage: P = Polyhedron(vertices=[[0,0,1], [1,0,1],            # optional - pynormaliz
....:                          [0,1,1], [1,1,1]],
....:                backend='normaliz')
sage: P.triangulate(engine='normaliz')                      # optional - pynormaliz
(<0,1,2>, <1,2,3>)

sage: P = Polyhedron(vertices=[[0,0,1], [1,0,1],
....:                          [0,1,1], [1,1,1]])
sage: P.triangulate(engine='normaliz')
Traceback (most recent call last):
...
TypeError: the polyhedron's backend should be 'normaliz'

Python

>>> from sage.all import *
>>> P = Polyhedron(vertices=[[Integer(0),Integer(0),Integer(1)], [Integer(1),Integer(0),Integer(1)],            # optional - pynormaliz
...                          [Integer(0),Integer(1),Integer(1)], [Integer(1),Integer(1),Integer(1)]],
...                backend='normaliz')
>>> P.triangulate(engine='normaliz')                      # optional - pynormaliz
(<0,1,2>, <1,2,3>)

>>> P = Polyhedron(vertices=[[Integer(0),Integer(0),Integer(1)], [Integer(1),Integer(0),Integer(1)],
...                          [Integer(0),Integer(1),Integer(1)], [Integer(1),Integer(1),Integer(1)]])
>>> P.triangulate(engine='normaliz')
Traceback (most recent call last):
...
TypeError: the polyhedron's backend should be 'normaliz'

The normaliz engine can triangulate pointed cones:

Sage

sage: # optional - pynormaliz
sage: C1 = Polyhedron(rays=[[0,0,1], [1,0,1],
....:                       [0,1,1], [1,1,1]],
....:                 backend='normaliz')
sage: C1.triangulate(engine='normaliz')
(<0,1,2>, <1,2,3>)
sage: C2 = Polyhedron(rays=[[1,0,1], [0,0,1],
....:                       [0,1,1], [1,1,10/9]],
....:                 backend='normaliz')
sage: C2.triangulate(engine='normaliz')
(<0,1,2>, <1,2,3>)

Python

>>> from sage.all import *
>>> # optional - pynormaliz
>>> C1 = Polyhedron(rays=[[Integer(0),Integer(0),Integer(1)], [Integer(1),Integer(0),Integer(1)],
...                       [Integer(0),Integer(1),Integer(1)], [Integer(1),Integer(1),Integer(1)]],
...                 backend='normaliz')
>>> C1.triangulate(engine='normaliz')
(<0,1,2>, <1,2,3>)
>>> C2 = Polyhedron(rays=[[Integer(1),Integer(0),Integer(1)], [Integer(0),Integer(0),Integer(1)],
...                       [Integer(0),Integer(1),Integer(1)], [Integer(1),Integer(1),Integer(10)/Integer(9)]],
...                 backend='normaliz')
>>> C2.triangulate(engine='normaliz')
(<0,1,2>, <1,2,3>)

They can also be affine cones:

Sage

sage: K = Polyhedron(vertices=[[1,1,1]],                    # optional - pynormaliz
....:                rays=[[1,0,0], [0,1,0], [1,1,-1], [1,1,1]],
....:                backend='normaliz')
sage: K.triangulate(engine='normaliz')                      # optional - pynormaliz
(<0,1,2>, <0,1,3>)

Python

>>> from sage.all import *
>>> K = Polyhedron(vertices=[[Integer(1),Integer(1),Integer(1)]],                    # optional - pynormaliz
...                rays=[[Integer(1),Integer(0),Integer(0)], [Integer(0),Integer(1),Integer(0)], [Integer(1),Integer(1),-Integer(1)], [Integer(1),Integer(1),Integer(1)]],
...                backend='normaliz')
>>> K.triangulate(engine='normaliz')                      # optional - pynormaliz
(<0,1,2>, <0,1,3>)

volume(measure='ambient', engine='auto', **kwds)[source]#

Return the volume of the polytope.

INPUT:

measure – string. The measure to use. Allowed values are:
- ambient (default): Lebesgue measure of ambient space (volume)
- induced: Lebesgue measure of the affine hull (relative volume)
- induced_rational: Scaling of the Lebesgue measure for rational polytopes, such that the unit hypercube has volume 1
- induced_lattice: Scaling of the Lebesgue measure, such that the volume of the hypercube is factorial(n)
engine – string. The backend to use. Allowed values are:
- 'auto' (default): choose engine according to measure
- 'internal': see triangulate()
- 'TOPCOM': see triangulate()
- 'lrs': use David Avis’s lrs program (optional)
- 'latte': use LattE integrale program (optional)
- 'normaliz': use Normaliz program (optional)
**kwds – keyword arguments that are passed to the triangulation engine

OUTPUT:

The volume of the polytope

EXAMPLES:

Sage

sage: polytopes.hypercube(3).volume()
8
sage: (polytopes.hypercube(3)*2).volume()
64
sage: polytopes.twenty_four_cell().volume()
2

Python

>>> from sage.all import *
>>> polytopes.hypercube(Integer(3)).volume()
8
>>> (polytopes.hypercube(Integer(3))*Integer(2)).volume()
64
>>> polytopes.twenty_four_cell().volume()
2

Volume of the same polytopes, using the optional package lrslib (which requires a rational polytope):

Sage

sage: I3 = polytopes.hypercube(3)
sage: I3.volume(engine='lrs')                               # optional - lrslib
8
sage: C24 = polytopes.twenty_four_cell()
sage: C24.volume(engine='lrs')                              # optional - lrslib
2

Python

>>> from sage.all import *
>>> I3 = polytopes.hypercube(Integer(3))
>>> I3.volume(engine='lrs')                               # optional - lrslib
8
>>> C24 = polytopes.twenty_four_cell()
>>> C24.volume(engine='lrs')                              # optional - lrslib
2

If the base ring is exact, the answer is exact:

Sage

sage: P5 = polytopes.regular_polygon(5)                                     # needs sage.rings.number_field
sage: P5.volume()                                                           # needs sage.rings.number_field
2.377641290737884?

sage: polytopes.icosahedron().volume()                                      # needs sage.groups sage.rings.number_field
5/12*sqrt5 + 5/4
sage: numerical_approx(_)  # abs tol 1e9                                    # needs sage.groups sage.rings.number_field
2.18169499062491

Python

>>> from sage.all import *
>>> P5 = polytopes.regular_polygon(Integer(5))                                     # needs sage.rings.number_field
>>> P5.volume()                                                           # needs sage.rings.number_field
2.377641290737884?

>>> polytopes.icosahedron().volume()                                      # needs sage.groups sage.rings.number_field
5/12*sqrt5 + 5/4
>>> numerical_approx(_)  # abs tol 1e9                                    # needs sage.groups sage.rings.number_field
2.18169499062491

When considering lower-dimensional polytopes, we can ask for the ambient (full-dimensional), the induced measure (of the affine hull) or, in the case of lattice polytopes, for the induced rational measure. This is controlled by the parameter measure. Different engines may have different ideas on the definition of volume of a lower-dimensional object:

Sage

sage: P = Polyhedron([[0, 0], [1, 1]])
sage: P.volume()
0
sage: P.volume(measure='induced')                                           # needs sage.rings.number_field
1.414213562373095?
sage: P.volume(measure='induced_rational')                  # optional - latte_int
1

sage: # needs sage.rings.number_field
sage: S = polytopes.regular_polygon(6); S
A 2-dimensional polyhedron in AA^2 defined as the convex hull of 6 vertices
sage: edge = S.faces(1)[4].as_polyhedron()
sage: edge.vertices()
(A vertex at (0.866025403784439?, 1/2), A vertex at (0, 1))
sage: edge.volume()
0
sage: edge.volume(measure='induced')
1

sage: # optional - pynormaliz
sage: P = Polyhedron(backend='normaliz',
....:                vertices=[[1,0,0], [0,0,1],
....:                          [-1,1,1], [-1,2,0]])
sage: P.volume()
0
sage: P.volume(measure='induced')                                           # needs sage.rings.number_field
2.598076211353316?
sage: P.volume(measure='induced', engine='normaliz')
2.598076211353316
sage: P.volume(measure='induced_rational')                  # optional - latte_int
3/2
sage: P.volume(measure='induced_rational',
....:          engine='normaliz')
3/2
sage: P.volume(measure='induced_lattice')
3

Python

>>> from sage.all import *
>>> P = Polyhedron([[Integer(0), Integer(0)], [Integer(1), Integer(1)]])
>>> P.volume()
0
>>> P.volume(measure='induced')                                           # needs sage.rings.number_field
1.414213562373095?
>>> P.volume(measure='induced_rational')                  # optional - latte_int
1

>>> # needs sage.rings.number_field
>>> S = polytopes.regular_polygon(Integer(6)); S
A 2-dimensional polyhedron in AA^2 defined as the convex hull of 6 vertices
>>> edge = S.faces(Integer(1))[Integer(4)].as_polyhedron()
>>> edge.vertices()
(A vertex at (0.866025403784439?, 1/2), A vertex at (0, 1))
>>> edge.volume()
0
>>> edge.volume(measure='induced')
1

>>> # optional - pynormaliz
>>> P = Polyhedron(backend='normaliz',
...                vertices=[[Integer(1),Integer(0),Integer(0)], [Integer(0),Integer(0),Integer(1)],
...                          [-Integer(1),Integer(1),Integer(1)], [-Integer(1),Integer(2),Integer(0)]])
>>> P.volume()
0
>>> P.volume(measure='induced')                                           # needs sage.rings.number_field
2.598076211353316?
>>> P.volume(measure='induced', engine='normaliz')
2.598076211353316
>>> P.volume(measure='induced_rational')                  # optional - latte_int
3/2
>>> P.volume(measure='induced_rational',
...          engine='normaliz')
3/2
>>> P.volume(measure='induced_lattice')
3

The same polytope without normaliz backend:

Sage

sage: P = Polyhedron(vertices=[[1,0,0], [0,0,1], [-1,1,1], [-1,2,0]])
sage: P.volume(measure='induced_lattice', engine='latte')   # optional - latte_int
3

sage: # needs sage.groups sage.rings.number_field
sage: Dexact = polytopes.dodecahedron()
sage: F0 = Dexact.faces(2)[0].as_polyhedron()
sage: v = F0.volume(measure='induced', engine='internal'); v
1.53406271079097?
sage: F4 = Dexact.faces(2)[4].as_polyhedron()
sage: v = F4.volume(measure='induced', engine='internal'); v
1.53406271079097?
sage: RDF(v)    # abs tol 1e-9
1.53406271079044

sage: # needs sage.groups
sage: Dinexact = polytopes.dodecahedron(exact=False)
sage: F2 = Dinexact.faces(2)[2].as_polyhedron()
sage: w = F2.volume(measure='induced', engine='internal')
sage: RDF(w)    # abs tol 1e-9
1.5340627082974878

sage: all(polytopes.simplex(d).volume(measure='induced')                    # needs sage.rings.number_field sage.symbolic
....:        == sqrt(d+1)/factorial(d)
....:     for d in range(1,5))
True

sage: I = Polyhedron([[-3, 0], [0, 9]])
sage: I.volume(measure='induced')                                           # needs sage.rings.number_field
9.48683298050514?
sage: I.volume(measure='induced_rational')                  # optional - latte_int
3

sage: T = Polyhedron([[3, 0, 0], [0, 4, 0], [0, 0, 5]])
sage: T.volume(measure='induced')                                           # needs sage.rings.number_field
13.86542462386205?
sage: T.volume(measure='induced_rational')                  # optional - latte_int
1/2

sage: Q = Polyhedron(vertices=[(0, 0, 1, 1), (0, 1, 1, 0), (1, 1, 0, 0)])
sage: Q.volume(measure='induced')
1
sage: Q.volume(measure='induced_rational')                  # optional - latte_int
1/2

Python

>>> from sage.all import *
>>> P = Polyhedron(vertices=[[Integer(1),Integer(0),Integer(0)], [Integer(0),Integer(0),Integer(1)], [-Integer(1),Integer(1),Integer(1)], [-Integer(1),Integer(2),Integer(0)]])
>>> P.volume(measure='induced_lattice', engine='latte')   # optional - latte_int
3

>>> # needs sage.groups sage.rings.number_field
>>> Dexact = polytopes.dodecahedron()
>>> F0 = Dexact.faces(Integer(2))[Integer(0)].as_polyhedron()
>>> v = F0.volume(measure='induced', engine='internal'); v
1.53406271079097?
>>> F4 = Dexact.faces(Integer(2))[Integer(4)].as_polyhedron()
>>> v = F4.volume(measure='induced', engine='internal'); v
1.53406271079097?
>>> RDF(v)    # abs tol 1e-9
1.53406271079044

>>> # needs sage.groups
>>> Dinexact = polytopes.dodecahedron(exact=False)
>>> F2 = Dinexact.faces(Integer(2))[Integer(2)].as_polyhedron()
>>> w = F2.volume(measure='induced', engine='internal')
>>> RDF(w)    # abs tol 1e-9
1.5340627082974878

>>> all(polytopes.simplex(d).volume(measure='induced')                    # needs sage.rings.number_field sage.symbolic
...        == sqrt(d+Integer(1))/factorial(d)
...     for d in range(Integer(1),Integer(5)))
True

>>> I = Polyhedron([[-Integer(3), Integer(0)], [Integer(0), Integer(9)]])
>>> I.volume(measure='induced')                                           # needs sage.rings.number_field
9.48683298050514?
>>> I.volume(measure='induced_rational')                  # optional - latte_int
3

>>> T = Polyhedron([[Integer(3), Integer(0), Integer(0)], [Integer(0), Integer(4), Integer(0)], [Integer(0), Integer(0), Integer(5)]])
>>> T.volume(measure='induced')                                           # needs sage.rings.number_field
13.86542462386205?
>>> T.volume(measure='induced_rational')                  # optional - latte_int
1/2

>>> Q = Polyhedron(vertices=[(Integer(0), Integer(0), Integer(1), Integer(1)), (Integer(0), Integer(1), Integer(1), Integer(0)), (Integer(1), Integer(1), Integer(0), Integer(0))])
>>> Q.volume(measure='induced')
1
>>> Q.volume(measure='induced_rational')                  # optional - latte_int
1/2

The volume of a full-dimensional unbounded polyhedron is infinity:

Sage

sage: P = Polyhedron(vertices=[[1, 0], [0, 1]], rays=[[1, 1]])
sage: P.volume()
+Infinity

Python

>>> from sage.all import *
>>> P = Polyhedron(vertices=[[Integer(1), Integer(0)], [Integer(0), Integer(1)]], rays=[[Integer(1), Integer(1)]])
>>> P.volume()
+Infinity

The volume of a non full-dimensional unbounded polyhedron depends on the measure used:

Sage

sage: P = Polyhedron(ieqs = [[1,1,1], [-1,-1,-1], [3,1,0]]); P
A 1-dimensional polyhedron in QQ^2 defined as the convex hull of 1 vertex and 1 ray
sage: P.volume()
0
sage: P.volume(measure='induced')
+Infinity
sage: P.volume(measure='ambient')
0
sage: P.volume(measure='induced_rational')                  # optional - pynormaliz
+Infinity
sage: P.volume(measure='induced_rational',engine='latte')
+Infinity

Python

>>> from sage.all import *
>>> P = Polyhedron(ieqs = [[Integer(1),Integer(1),Integer(1)], [-Integer(1),-Integer(1),-Integer(1)], [Integer(3),Integer(1),Integer(0)]]); P
A 1-dimensional polyhedron in QQ^2 defined as the convex hull of 1 vertex and 1 ray
>>> P.volume()
0
>>> P.volume(measure='induced')
+Infinity
>>> P.volume(measure='ambient')
0
>>> P.volume(measure='induced_rational')                  # optional - pynormaliz
+Infinity
>>> P.volume(measure='induced_rational',engine='latte')
+Infinity

The volume in \(0\)-dimensional space is taken by counting measure:

Sage

sage: P = Polyhedron(vertices=[[]]); P
A 0-dimensional polyhedron in ZZ^0 defined as the convex hull of 1 vertex
sage: P.volume()
1
sage: P = Polyhedron(vertices=[]); P
The empty polyhedron in ZZ^0
sage: P.volume()
0

Python

>>> from sage.all import *
>>> P = Polyhedron(vertices=[[]]); P
A 0-dimensional polyhedron in ZZ^0 defined as the convex hull of 1 vertex
>>> P.volume()
1
>>> P = Polyhedron(vertices=[]); P
The empty polyhedron in ZZ^0
>>> P.volume()
0