regina::FaceNumbering< int, int > Class Template Reference

Specifies how subdim-faces are numbered within a dim-dimensional simplex. More...

#include <triangulation/facenumbering.h>

Inheritance diagram for regina::FaceNumbering< int, int >:

Static Public Member Functions
static constexpr Perm< dim+1 >	ordering (int face)
	Given a subdim-face number within a dim-dimensional simplex, returns the corresponding canonical ordering of the simplex vertices.
static constexpr int	faceNumber (Perm< dim+1 > vertices)
	Identifies which subdim-face in a dim-dimensional simplex is represented by the first (subdim + 1) elements of the given permutation.
static constexpr bool	containsVertex (int face, int vertex)
	Tests whether the given subdim-face of a dim-dimensional simplex contains the given vertex of the simplex.

Static Public Attributes
static constexpr int	oppositeDim = (dim - 1 - subdim)
	The dimension of the faces opposite these in a top-dimensional simplex of a dim-dimensional triangulation.
static constexpr bool	lexNumbering = (subdim <= oppositeDim)
	true if faces are numbered in lexicographical order according to their vertices, or false if faces are numbered in reverse lexicographical order.
static constexpr int	nFaces = binomSmall(dim + 1, lexDim + 1)
	The total number of subdim-dimensional faces in each dim-dimensional simplex.

Static Protected Attributes
static constexpr int	lexDim = (lexNumbering ? subdim : oppositeDim)
	Whichever of subdim or oppositeDim uses lexicographical face numbering.

Detailed Description

template<int, int>
class regina::FaceNumbering< int, int >

Specifies how subdim-faces are numbered within a dim-dimensional simplex.

Regina uses the following general scheme for numbering faces:

• For low-dimensional faces (subdim < dim / 2), faces are numbered in lexicographical order according to their vertices. For example, in a 3-dimensional triangulation, edges 0,...,5 contain vertices 01, 02, 03, 12, 13, 23 respectively.
• For high-dimensional faces (subdim ≥ dim / 2), faces are numbered in reverse lexicographical order according to their vertices. For example, in a 3-dimensional triangulation, triangles 0,...,3 contain vertices 123, 023, 013, 012 respectively.
• As a consequence, unless subdim = (dim-1)/2, we always have subdim-face number i opposite (dim-1-subdim)-face number i. For the special "halfway case" subdim = (dim-1)/2, where each subdim-face is opposite another subdim-face, we always have subdim-face number i opposite subdim-face number (nFaces-1-i).

Every class Face<dim, subdim> inherits from this class, which means you can access these routines as Face<dim, subdim>::ordering(), Face<dim, subdim>::faceNumber(), and so on.

An advantage of referring to FaceNumbering<dim, subdim> directly (as opposed to Face<dim, subdim>) is that its header is lightweight: it does not pull in the large and complex headers required by Face<dim, subdim>.

This class is specialised (and optimised) in Regina's standard dimensions.

Python

This class is not available in Python. However, all of its routines can be accessed through Face<dim, subdim> (which in Python becomes Facedim_subdim, or one of the type aliases such as Vertex3, Edge2 and so on).

Template Parameters

dim	the dimension of the simplex whose faces we are numbering. This must be between 1 and 15 inclusive.
subdim	the dimension of the faces that we are numbering. This must be between 0 and dim-1 inclusive.

Member Function Documentation

containsVertex()

template<int dim, int subdim>

static constexpr bool regina::detail::FaceNumberingAPI< dim, subdim >::containsVertex ( int face, int vertex )

staticconstexprinherited

Tests whether the given subdim-face of a dim-dimensional simplex contains the given vertex of the simplex.

Parameters

face	a subdim-face number in a dim-simplex; this must be between 0 and (dim+1 choose subdim+1)-1 inclusive.
vertex	a vertex number in a dim-simplex; this must be between 0 and dim inclusive.

Returns

true if and only if the given subdim-face contains the given vertex.

faceNumber()

template<int dim, int subdim>

static constexpr int regina::detail::FaceNumberingAPI< dim, subdim >::faceNumber ( Perm< dim+1 > vertices )

staticconstexprinherited

Identifies which subdim-face in a dim-dimensional simplex is represented by the first (subdim + 1) elements of the given permutation.

In other words, this routine identifies which subdim-face number within a dim-dimensional simplex spans vertices vertices[0, ..., subdim].

Parameters

vertices

a permutation whose first (subdim + 1) elements represent some vertex numbers in a dim-simplex.

Returns

the corresponding subdim-face number in the dim-simplex. This will be between 0 and (dim+1 choose subdim+1)-1 inclusive.

ordering()

template<int dim, int subdim>

static constexpr Perm< dim+1 > regina::detail::FaceNumberingAPI< dim, subdim >::ordering ( int face )

staticconstexprinherited

Given a subdim-face number within a dim-dimensional simplex, returns the corresponding canonical ordering of the simplex vertices.

If this canonical ordering is c, then c[0,...,subdim] will be the vertices of the given face in increasing numerical order. That is, c[0] < ... < c[subdim]. The remaining images c[(subdim + 1),...,dim] will be ordered arbitrarily.

Note that this is not the same permutation as returned by Simplex<dim>::faceMapping<subdim>():

• ordering() is a static function, which returns the same permutation for the same face number, regardless of which dim-simplex we are looking at. The images of 0,...,subdim will always appear in increasing order, and the images of (subdim + 1),...,dim will be arbitrary.
• faceMapping() examines the underlying face F of the triangulation and, across all appearances of F in different dim-simplices: (i) chooses the images of 0,...,subdim to map to the same respective vertices of F; and (ii) chooses the images of (subdim + 1),...,dim to maintain a "consistent orientation" constraint.

Parameters

face	identifies which subdim-face of a dim-dimensional simplex to query. This must be between 0 and (dim+1 choose subdim+1)-1 inclusive.

Returns

the corresponding canonical ordering of the simplex vertices.

Member Data Documentation

lexDim

template<int dim, int subdim>

int regina::detail::FaceNumberingAPI< dim, subdim >::lexDim = (lexNumbering ? subdim : oppositeDim)

staticconstexprprotectedinherited

Whichever of subdim or oppositeDim uses lexicographical face numbering.

lexNumbering

template<int dim, int subdim>

bool regina::detail::FaceNumberingAPI< dim, subdim >::lexNumbering = (subdim <= oppositeDim)

staticconstexprinherited

true if faces are numbered in lexicographical order according to their vertices, or false if faces are numbered in reverse lexicographical order.

nFaces

template<int dim, int subdim>

int regina::detail::FaceNumberingAPI< dim, subdim >::nFaces = binomSmall(dim + 1, lexDim + 1)

staticconstexprinherited

The total number of subdim-dimensional faces in each dim-dimensional simplex.

oppositeDim

template<int dim, int subdim>

int regina::detail::FaceNumberingAPI< dim, subdim >::oppositeDim = (dim - 1 - subdim)

staticconstexprinherited

The dimension of the faces opposite these in a top-dimensional simplex of a dim-dimensional triangulation.

---

The documentation for this class was generated from the following files:

• triangulation/facenumbering.h
• triangulation/isosigtype.h