regina::detail::FaceNumberingImpl< 4, 2, 1 > Class Reference

Inheritance diagram for regina::detail::FaceNumberingImpl< 4, 2, 1 >:

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. More...
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. More...
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. More...

Static Public Attributes
static constexpr int	triangleNumber [5][5][5]
	A table that maps vertices of a pentachoron to triangle numbers. More...
static constexpr int	triangleVertex [10][3]
	A table that maps triangles of a pentachoron to vertex numbers. More...
static constexpr int	oppositeDim
	The dimension of the faces opposite these in a top-dimensional simplex of a dim-dimensional triangulation. More...
static constexpr bool	lexNumbering
	true if faces are numbered in lexicographical order according to their vertices, or false if faces are numbered in reverse lexicographical order. More...
static constexpr int	nFaces
	The total number of subdim-dimensional faces in each dim-dimensional simplex. More...

Static Protected Attributes
static constexpr int	lexDim
	Whichever of subdim or oppositeDim uses lexicographical face numbering. More...

Member Function Documentation

containsVertex()

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()

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()

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

constexpr int regina::detail::FaceNumberingAPI< dim, subdim >::lexDim

staticconstexprprotectedinherited

Whichever of subdim or oppositeDim uses lexicographical face numbering.

lexNumbering

constexpr bool regina::detail::FaceNumberingAPI< dim, subdim >::lexNumbering

staticconstexprinherited

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

nFaces

constexpr int regina::detail::FaceNumberingAPI< dim, subdim >::nFaces

staticconstexprinherited

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

oppositeDim

constexpr int regina::detail::FaceNumberingAPI< dim, subdim >::oppositeDim

staticconstexprinherited

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

triangleNumber

constexpr int regina::detail::FaceNumberingImpl< 4, 2, 1 >::triangleNumber[5][5][5]

staticconstexpr

Initial value:

= {
            { { -1,-1,-1,-1,-1 }, { -1,-1, 9, 8, 7 }, { -1, 9,-1, 6, 5 },
              { -1, 8, 6,-1, 4 }, { -1, 7, 5, 4,-1 } },
            { { -1,-1, 9, 8, 7 }, { -1,-1,-1,-1,-1 }, {  9,-1,-1, 3, 2 },
              {  8,-1, 3,-1, 1 }, {  7,-1, 2, 1,-1 } },
            { { -1, 9,-1, 6, 5 }, {  9,-1,-1, 3, 2 }, { -1,-1,-1,-1,-1 },
              {  6, 3,-1,-1, 0 }, {  5, 2,-1, 0,-1 } },
            { { -1, 8, 6,-1, 4 }, {  8,-1, 3,-1, 1 }, {  6, 3,-1,-1, 0 },
              { -1,-1,-1,-1,-1 }, {  4, 1, 0,-1,-1 } },
            { { -1, 7, 5, 4,-1 }, {  7,-1, 2, 1,-1 }, {  5, 2,-1, 0,-1 },
              {  4, 1, 0,-1,-1 }, { -1,-1,-1,-1,-1 } }
        }

A table that maps vertices of a pentachoron to triangle numbers.

Triangles in a pentachoron are numbered 0,...,9. This table converts vertices to triangle numbers; in particular, the triangle spanned by vertices i, j and k of a pentachoron is triangle number triangleNumber[i][j][k]. Here i, j and k must be distinct, must be between 0 and 4 inclusive, and may be given in any order. The resulting triangle number will be between 0 and 9 inclusive.

Note

Accessing triangleNumber[i][j][k] is equivalent to calling faceNumber(p), where p is a permutation that maps 0,1,2 to i,j,k in some order.

triangleVertex

constexpr int regina::detail::FaceNumberingImpl< 4, 2, 1 >::triangleVertex[10][3]

staticconstexpr

Initial value:

= {
            { 2, 3, 4 }, { 1, 3, 4 }, { 1, 2, 4 }, { 1, 2, 3 }, { 0, 3, 4 },
            { 0, 2, 4 }, { 0, 2, 3 }, { 0, 1, 4 }, { 0, 1, 3 }, { 0, 1, 2 }
        }

A table that maps triangles of a pentachoron to vertex numbers.

Triangles in a pentachoron are numbered 0,...,9. This table converts triangle numbers to vertices; in particular, triangle i in a pentachoron is spanned by vertices triangleVertex[i][0], triangleVertex[i][1] and triangleVertex[i][2]. Here i must be between 0 and 9 inclusive; the resulting vertex numbers will be between 0 and 4 inclusive.

It is guaranteed that triangleVertex[i][0] will always be smaller than triangleVertex[i][1], which in turn will always be smaller than triangleVertex[i][2].

Note

Accessing triangleVertex[i][j] is equivalent to calling ordering(i)[j].

---

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

• triangulation/detail/facenumbering.h