Regina Calculation Engine
Classes | Functions | Variables
Implementation details

Implementation details that end users should not need to reference directly. More...

Classes

class  regina::detail::ComponentBase< dim >
 Helper class that provides core functionality for a connected component of a dim-manifold triangulation. More...
 
class  regina::detail::FaceEmbeddingBase< dim, subdim >
 Helper class that provides core functionality for describing how a subdim-face of a dim-dimensional triangulation appears within each top-dimensional simplex. More...
 
class  regina::detail::FaceStorage< dim, codim >
 Helper class for storing all the ways in which a given face of codimension codim in a dim-dimensional triangulation appears within the various top-dimensional simplices. More...
 
class  regina::detail::FaceValidity< allowsInvalid, testLinks >
 Helper class that stores whether a face is valid. More...
 
class  regina::detail::FaceValidity< false, testLinks >
 Helper class that stores whether a face is valid. More...
 
class  regina::detail::FaceValidity< true, false >
 Helper class that stores whether a face is valid. More...
 
class  regina::detail::FaceOrientability< allowsNonorientable >
 Helper class that stores whether the link of a face is orientable. More...
 
class  regina::detail::FaceOrientability< false >
 Helper class that stores whether the link of a face is orientable. More...
 
struct  regina::detail::FaceListHolder< class, int >
 Helper class that indicates what data type Base uses to store its list of subdim-faces. More...
 
class  regina::detail::FaceBase< dim, subdim >
 Helper class that provides core functionality for a subdim-face in the skeleton of a dim-dimensional triangulation. More...
 
class  regina::detail::FaceNumberingAPI< dim, subdim >
 Placeholder class that outlines the functions provided by FaceNumbering<dim, subdim>. More...
 
class  regina::detail::FaceNumberingImpl< dim, subdim, lex >
 Implementation details for numbering subdim-faces of a dim-dimensional simplex. More...
 
class  regina::detail::FaceNumberingImpl< dim, subdim, false >
 
class  regina::detail::FaceNumberingImpl< dim, 0, true >
 
class  regina::detail::FaceNumberingImpl< 1, 0, true >
 
class  regina::detail::FaceNumberingImpl< 2, 0, true >
 
class  regina::detail::FaceNumberingImpl< 2, 1, false >
 
class  regina::detail::FaceNumberingImpl< 3, 0, true >
 
class  regina::detail::FaceNumberingImpl< 3, 1, true >
 
class  regina::detail::FaceNumberingImpl< 3, 2, false >
 
class  regina::detail::FaceNumberingImpl< 4, 0, true >
 
class  regina::detail::FaceNumberingImpl< 4, 1, true >
 
class  regina::detail::FaceNumberingImpl< 4, 2, false >
 
class  regina::detail::FaceNumberingImpl< 4, 3, false >
 
class  regina::detail::FacetPairingBase< dim >
 Provides core functionality for facet pairings (that is, dual graphs) of dim-dimensional triangulations. More...
 
class  regina::detail::IsomorphismBase< dim >
 Provides core functionality for combinatorial isomorphisms between dim-manifold triangulations. More...
 
class  regina::detail::SimplexFaces< dim, subdim >
 Helper class for storing which subdim-faces of a dim-dimensional triangulation appear within each top-dimensional simplex. More...
 
class  regina::detail::SimplexFacesSuite< dim, subdim >
 Internal class that helps a simplex store the details of its lower-dimensional faces. More...
 
class  regina::detail::SimplexBase< dim >
 Helper class that provides core functionality for a top-dimensional simplex in a dim-manifold triangulation. More...
 
class  regina::detail::FaceListSuite< dim, subdim >
 Internal class that helps a triangulation store its lists of faces. More...
 
struct  regina::detail::FaceListHolder< detail::TriangulationBase< dim >, subdim >
 Helper class that indicates what data type is used by a triangulation class to store a list of subdim-faces. More...
 
struct  regina::detail::FaceCalculator< dim, subdim, codim >
 Internal class used to calculate lower-dimensional faces in a triangulation. More...
 
class  regina::detail::TriangulationBase< dim >
 Provides core functionality for dim-dimensional triangulations. More...
 
struct  regina::detail::XMLTriangulationTags< dim >
 Internal class that indicates the XML tags and attributes used to describe top-dimensional simplices in a dim-dimensional triangulation. More...
 
class  regina::detail::XMLSimplexReader< dim >
 Helper class that reads the XML element for a single top-dimensional simplex in a dim-dimensional triangulation. More...
 
class  regina::detail::XMLSimplicesReader< dim >
 Helper class that reads the XML element for the set of all top-dimensional simplices in a dim-dimensional triangulation. More...
 
class  regina::detail::XMLTriangulationReaderBase< dim >
 Helper class that provides core functionality for the XML packet reader that reads a single dim-dimensional triangulation. More...
 

Functions

constexpr bool regina::detail::allowsInvalidFaces (int dim, int subdim)
 Indicates whether it is possible for a subdim-face of a dim-dimensional triangulation to be invalid. More...
 
constexpr bool regina::detail::allowsNonOrientableLinks (int dim, int subdim)
 Indicates whether it is possible for a subdim-face of a dim-dimensional triangulation to have a non-orientable link. More...
 
static NPerm< dim+1 > regina::detail::FaceNumberingAPI< dim, subdim >::ordering (unsigned face)
 Given a subdim-face number within a dim-dimensional simplex, returns the corresponding canonical ordering of the simplex vertices. More...
 
static unsigned regina::detail::FaceNumberingAPI< dim, subdim >::faceNumber (NPerm< 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 bool regina::detail::FaceNumberingAPI< dim, subdim >::containsVertex (unsigned face, unsigned vertex)
 Tests whether the given subdim-face of a dim-dimensional simplex contains the given vertex of the simplex. More...
 

Variables

REGINA_API const int *const regina::detail::binomSmall_ [17]
 A lookup table that stores (n choose k) for all n16. More...
 
static constexpr int regina::detail::FaceNumberingImpl< dim, subdim, lex >::nFaces
 The total number of subdim-dimensional faces in each dim-dimensional simplex. More...
 
static constexpr int regina::detail::FaceNumberingImpl< dim, subdim, false >::nFaces
 The total number of subdim-dimensional faces in each dim-dimensional simplex. More...
 
static constexpr int regina::detail::FaceNumberingImpl< dim, 0, true >::nFaces = dim + 1
 The total number of vertices in each dim-dimensional simplex. More...
 
static constexpr int regina::detail::FaceNumberingImpl< 1, 0, true >::nFaces = 2
 The total number of vertices in each edge. More...
 
static constexpr int regina::detail::FaceNumberingImpl< 2, 0, true >::nFaces = 3
 The total number of vertices in each triangle. More...
 
static constexpr int regina::detail::FaceNumberingImpl< 2, 1, false >::nFaces = 3
 The total number of edges in each triangle. More...
 
static constexpr int regina::detail::FaceNumberingImpl< 3, 0, true >::nFaces = 4
 The total number of vertices in each tetrahedron. More...
 
static const int regina::detail::FaceNumberingImpl< 3, 1, true >::edgeNumber [4][4]
 A table that maps vertices of a tetrahedron to edge numbers. More...
 
static const int regina::detail::FaceNumberingImpl< 3, 1, true >::edgeVertex [6][2]
 A table that maps edges of a tetrahedron to vertex numbers. More...
 
static constexpr int regina::detail::FaceNumberingImpl< 3, 1, true >::nFaces = 6
 The total number of edges in each tetrahedron. More...
 
static constexpr int regina::detail::FaceNumberingImpl< 3, 2, false >::nFaces = 4
 The total number of triangles in each tetrahedron. More...
 
static constexpr int regina::detail::FaceNumberingImpl< 4, 0, true >::nFaces = 5
 The total number of vertices in each pentachoron. More...
 
static const int regina::detail::FaceNumberingImpl< 4, 1, true >::edgeNumber [5][5]
 A table that maps vertices of a pentachoron to edge numbers. More...
 
static const int regina::detail::FaceNumberingImpl< 4, 1, true >::edgeVertex [10][2]
 A table that maps edges of a pentachoron to vertex numbers. More...
 
static constexpr int regina::detail::FaceNumberingImpl< 4, 1, true >::nFaces = 10
 The total number of edges in each pentachoron. More...
 
static const int regina::detail::FaceNumberingImpl< 4, 2, false >::triangleNumber [5][5][5]
 A table that maps vertices of a pentachoron to triangle numbers. More...
 
static const int regina::detail::FaceNumberingImpl< 4, 2, false >::triangleVertex [10][3]
 A table that maps triangles of a pentachoron to vertex numbers. More...
 
static constexpr int regina::detail::FaceNumberingImpl< 4, 2, false >::nFaces = 10
 The total number of triangles in each pentachoron. More...
 
static constexpr int regina::detail::FaceNumberingImpl< 4, 3, false >::nFaces = 5
 The total number of tetrahedra in each pentachoron. More...
 

Detailed Description

Implementation details that end users should not need to reference directly.

Function Documentation

§ allowsInvalidFaces()

constexpr bool regina::detail::allowsInvalidFaces ( int  dim,
int  subdim 
)

Indicates whether it is possible for a subdim-face of a dim-dimensional triangulation to be invalid.

This compile-time constant function is used to determine the first template argument that should be passed to FaceValidity.

Python:
Not present.
Parameters
dimthe dimension of the underlying triangulations.
subdimthe dimension of the faces in question.
Returns
true if such faces may be invalid, or false if subdim-faces of dim-dimensional triangluations are always valid.

§ allowsNonOrientableLinks()

constexpr bool regina::detail::allowsNonOrientableLinks ( int  dim,
int  subdim 
)

Indicates whether it is possible for a subdim-face of a dim-dimensional triangulation to have a non-orientable link.

This compile-time constant function is used to determine the template argument that should be passed to FaceOrientability.

Python:
Not present.
Parameters
dimthe dimension of the underlying triangulations.
subdimthe dimension of the faces in question.
Returns
true if such faces may have non-orientable links, or false if the links of subdim-faces of dim-dimensional triangluations are always orientable.

§ containsVertex()

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

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

Parameters
facea subdim-face number in a dim-simplex; this must be between 0 and (dim+1 choose subdim+1)-1 inclusive.
vertexa 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 unsigned regina::detail::FaceNumberingAPI< dim, subdim >::faceNumber ( NPerm< dim+1 >  vertices)
static

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
verticesa 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 NPerm<dim + 1> regina::detail::FaceNumberingAPI< dim, subdim >::ordering ( unsigned  face)
static

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

Variable Documentation

§ binomSmall_

REGINA_API const int* const regina::detail::binomSmall_[17]

A lookup table that stores (n choose k) for all n16.

For all values 0 ≤ kn ≤ 16, the value binomSmall_[n][k] is the binomial coefficient (n choose k).

This array is used in the implementation of the function binomSmall(). End users should call binomSmall() instead of referring to this array directly.

§ edgeNumber [1/2]

const int regina::detail::FaceNumberingImpl< 3, 1, true >::edgeNumber[4][4]
static

A table that maps vertices of a tetrahedron to edge numbers.

Edges in a tetrahedron are numbered 0,...,5. This table converts vertices to edge numbers; in particular, the edge joining vertices i and j of a tetrahedron is edge number edgeNumber[i][j]. Here i and j must be distinct, must be between 0 and 3 inclusive, and may be given in any order. The resulting edge number will be between 0 and 5 inclusive.

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

§ edgeNumber [2/2]

const int regina::detail::FaceNumberingImpl< 4, 1, true >::edgeNumber[5][5]
static

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

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

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

§ edgeVertex [1/2]

const int regina::detail::FaceNumberingImpl< 3, 1, true >::edgeVertex[6][2]
static

A table that maps edges of a tetrahedron to vertex numbers.

Edges in a tetrahedron are numbered 0,...,5. This table converts edge numbers to vertices; in particular, edge i in a tetrahedron joins vertices edgeVertex[i][0] and edgeVertex[i][1]. Here i must be bewteen 0 and 5 inclusive; the resulting vertex numbers will be between 0 and 3 inclusive.

It is guaranteed that edgeVertex[i][0] will always be smaller than edgeVertex[i][1].

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

§ edgeVertex [2/2]

const int regina::detail::FaceNumberingImpl< 4, 1, true >::edgeVertex[10][2]
static

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

Edges in a pentachoron are numbered 0,...,9. This table converts edge numbers to vertices; in particular, edge i in a pentachoron joins vertices edgeVertex[i][0] and edgeVertex[i][1]. Here i must be between 0 and 9 inclusive; the resulting vertex numbers will be between 0 and 4 inclusive.

It is guaranteed that edgeVertex[i][0] will always be smaller than edgeVertex[i][1].

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

§ nFaces [1/13]

template<int dim, int subdim, bool lex>
constexpr int regina::detail::FaceNumberingImpl< dim, subdim, lex >::nFaces
static
Initial value:
=
FaceNumberingImpl<dim - 1, subdim - 1, lex>::nFaces +
FaceNumberingImpl<dim - 1, subdim,
(dim >= 2 * (subdim + 1))>::nFaces

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

§ nFaces [2/13]

template<int dim, int subdim>
constexpr int regina::detail::FaceNumberingImpl< dim, subdim, false >::nFaces
static
Initial value:
=
FaceNumberingImpl<dim, dim - subdim - 1, true>::nFaces

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

§ nFaces [3/13]

template<int dim>
constexpr int regina::detail::FaceNumberingImpl< dim, 0, true >::nFaces = dim + 1
static

The total number of vertices in each dim-dimensional simplex.

§ nFaces [4/13]

constexpr int regina::detail::FaceNumberingImpl< 1, 0, true >::nFaces = 2
static

The total number of vertices in each edge.

§ nFaces [5/13]

constexpr int regina::detail::FaceNumberingImpl< 2, 0, true >::nFaces = 3
static

The total number of vertices in each triangle.

§ nFaces [6/13]

constexpr int regina::detail::FaceNumberingImpl< 2, 1, false >::nFaces = 3
static

The total number of edges in each triangle.

§ nFaces [7/13]

constexpr int regina::detail::FaceNumberingImpl< 3, 0, true >::nFaces = 4
static

The total number of vertices in each tetrahedron.

§ nFaces [8/13]

constexpr int regina::detail::FaceNumberingImpl< 3, 1, true >::nFaces = 6
static

The total number of edges in each tetrahedron.

§ nFaces [9/13]

constexpr int regina::detail::FaceNumberingImpl< 3, 2, false >::nFaces = 4
static

The total number of triangles in each tetrahedron.

§ nFaces [10/13]

constexpr int regina::detail::FaceNumberingImpl< 4, 0, true >::nFaces = 5
static

The total number of vertices in each pentachoron.

§ nFaces [11/13]

constexpr int regina::detail::FaceNumberingImpl< 4, 1, true >::nFaces = 10
static

The total number of edges in each pentachoron.

§ nFaces [12/13]

constexpr int regina::detail::FaceNumberingImpl< 4, 2, false >::nFaces = 10
static

The total number of triangles in each pentachoron.

§ nFaces [13/13]

constexpr int regina::detail::FaceNumberingImpl< 4, 3, false >::nFaces = 5
static

The total number of tetrahedra in each pentachoron.

§ triangleNumber

const int regina::detail::FaceNumberingImpl< 4, 2, false >::triangleNumber[5][5][5]
static

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

const int regina::detail::FaceNumberingImpl< 4, 2, false >::triangleVertex[10][3]
static

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

Copyright © 1999-2016, The Regina development team
This software is released under the GNU General Public License, with some additional permissions; see the source code for details.
For further information, or to submit a bug or other problem, please contact Ben Burton (bab@maths.uq.edu.au).