Implementation details

## Classes

struct | regina::detail::FaceListHolder< BoundaryComponentFaceStorage< dim, true >, subdim >
| Helper class that indicates what data type is used by a boundary component class to store a list of subdim-faces. More...
class | regina::detail::WeakFaceList< dim, subdim >
| Internal class that stores all subdim-faces in a component or boundary component of a dim-dimensional triangulation. More...
class | regina::detail::WeakFaceListSuite< dim, subdim >
| Internal class that helps a component or boundary component store its lists of faces. More...
class | regina::detail::BoundaryComponentFaceStorage< dim, allFaces_ >
| Helper class for storing the necessary faces of a boundary component of a dim-dimensional triangulation. More...
class | regina::detail::BoundaryComponentFaceStorage< dim, false >
| Helper class for storing the necessary faces of a boundary component of a dim-dimensional triangulation. More...
class | regina::detail::BoundaryComponentFaceInterface< dim, allFaces, allowVertex_ >
| Helper class for querying the faces of a boundary component of a dim-dimensional triangulation. More...
class | regina::detail::BoundaryComponentFaceInterface< dim, allFaces, false >
| Helper class for querying the faces of a boundary component of a dim-dimensional triangulation. More...
class | regina::detail::BoundaryComponentStorage< dim, allFaces, allowVertex, canBuild_ >
| Helper class that manages all data storage for a boundary component of a dim-dimensional triangulation. More...
class | regina::detail::BoundaryComponentStorage< dim, allFaces, allowVertex, false >
| Helper class that manages all data storage for a boundary component of a dim-dimensional triangulation. More...
class | regina::detail::BoundaryComponentBase< dim >
| Helper class that provides core functionality for a boundary component of a dim-dimensional triangulation. More...
struct | regina::detail::FaceListHolder< Component< dim >, subdim >
| Helper class that indicates what data type is used by a connected component of a triangulation to store a list of subdim-faces. More...
class | regina::detail::ComponentBase< dim >
| Helper class that provides core functionality for a connected component of a dim-manifold triangulation. More...
class | regina::detail::ExampleFromLowDim< dim, available >
| Helper class that builds various dim-dimensional triangulations from (dim-1)-dimensional triangulations. More...
class | regina::detail::ExampleFromLowDim< dim, false >
| Helper class that builds various dim-dimensional triangulations from (dim-1)-dimensional triangulations. More...
class | regina::detail::ExampleBase< dim >
| Provides core functionality for constructing example dim-dimensional triangulations. 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...
struct | regina::detail::Strings< dim_ >
| Contains a collection of compile-time constant strings that describe features of the dimension dim. 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...
struct | regina::detail::BoundaryComponentCalculator< dim, subdim >
| Internal class used to identify lower-dimensional faces in a boundary component of a triangulation. More...
struct | regina::detail::EulerCalculator< dim, subdim >
| Internal class used to calculate the Euler characteristic of 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 >::AbelianGroupPropertyReader
| Internal class that reads an abelian group property. More...
class | regina::detail::XMLTriangulationReaderBase< dim >::GroupPresentationPropertyReader
| Internal class that reads a group presentation property. 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...

## Typedefs

typedef std::vector< Face< dim, subdim > * > | regina::detail::FaceListHolder< BoundaryComponentFaceStorage< dim, true >, subdim >::Holder
| The data type used by BoundaryComponent<dim> to store the list of all subdim-faces of the boundary component. More...
typedef std::vector< Face< dim, subdim > * > | regina::detail::FaceListHolder< Component< dim >, subdim >::Holder
| The data type used by Component<dim> to store the list of all subdim-faces of the connected component. More...
typedef std::list< Isomorphism< dim > * > | regina::detail::FacetPairingBase< dim >::IsoList
| A list of isomorphisms on facet pairings. More...
typedef void(* | regina::detail::FacetPairingBase< dim >::Use) (const FacetPairing< dim > *, const IsoList *, void *)
| A routine that can do arbitrary processing upon a facet pairing and its automorphisms. More...
typedef IntOfMinSize<(dim/8)+1 >::utype | regina::detail::SimplexBase< dim >::FacetMask
| An unsigned integer type with at least dim+1 bits. More...
typedef FaceList< dim, subdim > | regina::detail::FaceListHolder< detail::TriangulationBase< dim >, subdim >::Holder
| The data type used by Triangulation<dim> to store the list of all subdim-faces of the triangulation. More...
typedef std::vector< Simplex< dim > * >::const_iterator | regina::detail::TriangulationBase< dim >::SimplexIterator
| Used to iterate through top-dimensional simplices. More...
typedef std::vector< Component< dim > * >::const_iterator | regina::detail::TriangulationBase< dim >::ComponentIterator
| Used to iterate through connected components. More...
typedef std::vector< BoundaryComponent< dim > * >::const_iterator | regina::detail::TriangulationBase< dim >::BoundaryComponentIterator
| Used to iterate through boundary components. More...
typedef Property< AbelianGroup, StoreManagedPtr > | regina::detail::XMLTriangulationReaderBase< dim >::AbelianGroupPropertyReader::PropType
| The type of the property currently being read. More...
typedef Property< GroupPresentation, StoreManagedPtr > | regina::detail::XMLTriangulationReaderBase< dim >::GroupPresentationPropertyReader::PropType
| The type of the property currently being read. More...

## Functions

| regina::detail::WeakFaceList< dim, subdim >::ReorderIterator< tridim >::ReorderIterator ()
| Creates an uninitialised iterator. More...
| regina::detail::WeakFaceList< dim, subdim >::ReorderIterator< tridim >::ReorderIterator (typename std::vector< Face< dim, subdim > * >::const_iterator it, Face< tridim, subdim > **map)
| Creates an iterator that points to the given face of this list, using the given map to convert faces of this list to faces of the other triangulation tri. More...
| regina::detail::WeakFaceList< dim, subdim >::ReorderIterator< tridim >::ReorderIterator (const ReorderIterator &)=default
| Copy constructor. More...
bool | regina::detail::WeakFaceList< dim, subdim >::ReorderIterator< tridim >::operator== (const ReorderIterator &rhs) const
| Tests whether this and the given iterator point to the same face. More...
bool | regina::detail::WeakFaceList< dim, subdim >::ReorderIterator< tridim >::operator!= (const ReorderIterator &rhs) const
| Tests whether this and the given iterator point to different faces. More...
ReorderIterator & | regina::detail::WeakFaceList< dim, subdim >::ReorderIterator< tridim >::operator++ ()
| Preincrement operator that steps to the next face in this list. More...
ReorderIterator | regina::detail::WeakFaceList< dim, subdim >::ReorderIterator< tridim >::operator++ (int)
| Postincrement operator that steps to the next face in this list. More...
Face< tridim, subdim > * | regina::detail::WeakFaceList< dim, subdim >::ReorderIterator< tridim >::operator* () const
| Returns the face of the other triangulation tri that corresponds to the current face in this list. More...
template<int tridim>
void | regina::detail::WeakFaceList< dim, subdim >::reorderAndRelabelFaces (Triangulation< tridim > *tri, const std::vector< Face< dim, tridim > * > &tridimFaces) const
| Reorders and relabels all subdim-faces of the given triangulation so that they appear in the same order as the corresponding faces in this list, and so that their vertices are numbered in a corresponding way. More...
template<int tridim>
void | regina::detail::WeakFaceListSuite< dim, subdim >::reorderAndRelabelFaces (Triangulation< tridim > *tri, const std::vector< Face< dim, tridim > * > &tridimFaces) const
| Reorders and relabels all faces of all dimensions 0,...,subdim of the given triangulation, so that for each k, the k-faces of the given triangulation appear in the same order as the corresponding k-faces in this suite, and have their vertices numbered in a corresponding way. More...
size_t | regina::detail::BoundaryComponentFaceStorage< dim, allFaces_ >::size () const
| Returns the number of (dim-1)-faces in this boundary component. More...
size_t | regina::detail::BoundaryComponentFaceStorage< dim, allFaces_ >::countRidges () const
| Returns the number of (dim-2)-faces in this boundary component. More...
template<int subdim>
size_t | regina::detail::BoundaryComponentFaceStorage< dim, allFaces_ >::countFaces () const
| Returns the number of subdim-faces in this boundary component. More...
const std::vector< Face< dim, dim-1 > * > & | regina::detail::BoundaryComponentFaceStorage< dim, allFaces_ >::facets () const
| Returns all (dim-1)-faces in this boundary component. More...
template<int subdim>
const std::vector< Face< dim, subdim > * > & | regina::detail::BoundaryComponentFaceStorage< dim, allFaces_ >::faces () const
| Returns all subdim-faces in this boundary component. More...
Face< dim, dim-1 > * | regina::detail::BoundaryComponentFaceStorage< dim, allFaces_ >::facet (size_t index) const
| Returns the requested (dim-1)-face in this boundary component. More...
template<int subdim>
Face< dim, subdim > * | regina::detail::BoundaryComponentFaceStorage< dim, allFaces_ >::face (size_t index) const
| Returns the requested subdim-face in this boundary component. More...
Triangulation< dim > * | regina::detail::BoundaryComponentFaceStorage< dim, allFaces_ >::triangulation () const
| Returns the triangulation to which this boundary component belongs. More...
Component< dim > * | regina::detail::BoundaryComponentFaceStorage< dim, allFaces_ >::component () const
| Returns the connected component of the triangulation to which this boundary component belongs. More...
template<int subdim>
void | regina::detail::BoundaryComponentFaceStorage< dim, allFaces_ >::push_back (Face< dim, subdim > *face)
| Pushes the given face onto the end of the list of subdim-faces of this boundary component. More...
void | regina::detail::BoundaryComponentFaceStorage< dim, allFaces_ >::reorderAndRelabelFaces (Triangulation< dim-1 > *tri) const
| Reorders all lower-dimensional faces of the given triangulation so that they appear in the same order as the corresponding faces of this boundary component, and relabels these faces so that their vertices are numbered in a corresponding way. More...
size_t | regina::detail::BoundaryComponentFaceStorage< dim, false >::size () const
| Returns the number of (dim-1)-faces in this boundary component. More...
size_t | regina::detail::BoundaryComponentFaceStorage< dim, false >::countRidges () const
| Returns the number of (dim-2)-faces in this boundary component. More...
const std::vector< Face< dim, dim-1 > * > & | regina::detail::BoundaryComponentFaceStorage< dim, false >::facets () const
| Returns all (dim-1)-faces in this boundary component. More...
Face< dim, dim-1 > * | regina::detail::BoundaryComponentFaceStorage< dim, false >::facet (size_t index) const
| Returns the requested (dim-1)-face in this boundary component. More...
Triangulation< dim > * | regina::detail::BoundaryComponentFaceStorage< dim, false >::triangulation () const
| Returns the triangulation to which this boundary component belongs. More...
Component< dim > * | regina::detail::BoundaryComponentFaceStorage< dim, false >::component () const
| Returns the connected component of the triangulation to which this boundary component belongs. More...
| regina::detail::BoundaryComponentFaceStorage< dim, false >::BoundaryComponentFaceStorage ()
| Default constructor that initialises the number of ridges to zero. More...
void | regina::detail::BoundaryComponentFaceStorage< dim, false >::push_back (Face< dim, dim-1 > *face)
| Pushes the given face onto the end of the list of (dim-1)-faces of this boundary component. More...
void | regina::detail::BoundaryComponentFaceStorage< dim, false >::push_back (Face< dim, dim-2 > *)
| Increments the number of (dim-2)-faces in this boundary component. More...
template<int subdim>
void | regina::detail::BoundaryComponentFaceStorage< dim, false >::push_back (Face< dim, subdim > *)
| Does nothing, since this boundary component does not store lower-dimensional faces. More...
void | regina::detail::BoundaryComponentFaceStorage< dim, false >::reorderAndRelabelFaces (Triangulation< dim-1 > *) const
| Reorders all lower-dimensional faces of the given triangulation so that they appear in the same order as the corresponding faces of this boundary component, and relabels these faces so that their vertices are numbered in a corresponding way. More...
bool | regina::detail::BoundaryComponentFaceInterface< dim, allFaces, allowVertex_ >::isReal () const
| Determines if this boundary component is real. More...
bool | regina::detail::BoundaryComponentFaceInterface< dim, allFaces, allowVertex_ >::isIdeal () const
| Determines if this boundary component is ideal. More...
bool | regina::detail::BoundaryComponentFaceInterface< dim, allFaces, allowVertex_ >::isInvalidVertex () const
| Determines if this boundary component consists of a single invalid vertex and nothing else. More...
void | regina::detail::BoundaryComponentFaceInterface< dim, allFaces, allowVertex_ >::writeTextShort (std::ostream &out) const
| Writes a short text representation of this object to the given output stream. More...
void | regina::detail::BoundaryComponentFaceInterface< dim, allFaces, allowVertex_ >::writeTextLong (std::ostream &out) const
| Writes a detailed text representation of this object to the given output stream. More...
const Triangulation< dim-1 > * | regina::detail::BoundaryComponentFaceInterface< dim, allFaces, allowVertex_ >::buildVertexLink () const
| Triangulates the vertex link for an ideal or invalid vertex boundary component. More...
void | regina::detail::BoundaryComponentFaceInterface< dim, allFaces, false >::writeTextShort (std::ostream &out) const
| Writes a short text representation of this object to the given output stream. More...
void | regina::detail::BoundaryComponentFaceInterface< dim, allFaces, false >::writeTextLong (std::ostream &out) const
| Writes a detailed text representation of this object to the given output stream. More...
constexpr const Triangulation< dim-1 > * | regina::detail::BoundaryComponentFaceInterface< dim, allFaces, false >::buildVertexLink () const
| Always returns `null`. More...
| regina::detail::BoundaryComponentStorage< dim, allFaces, allowVertex, canBuild_ >::~BoundaryComponentStorage ()
| Destroys this object. More...
const Triangulation< dim-1 > * | regina::detail::BoundaryComponentStorage< dim, allFaces, allowVertex, canBuild_ >::build () const
| Returns the full (dim-1)-dimensional triangulation of this boundary component. More...
| regina::detail::BoundaryComponentStorage< dim, allFaces, allowVertex, canBuild_ >::BoundaryComponentStorage ()
| Initialises the cached boundary triangulation to `null`. More...
size_t | regina::detail::BoundaryComponentBase< dim >::index () const
| Returns the index of this boundary component in the underlying triangulation. More...
bool | regina::detail::BoundaryComponentBase< dim >::isOrientable () const
| Determines if this boundary component is orientable. More...
| regina::detail::BoundaryComponentBase< dim >::BoundaryComponentBase ()=default
| Default constructor that leaves orientability uninitialised. More...
size_t | regina::detail::ComponentBase< dim >::index () const
| Returns the index of this component within the underlying triangulation. More...
size_t | regina::detail::ComponentBase< dim >::size () const
| Returns the number of top-dimensional simplices in this component. More...
const std::vector< Simplex< dim > * > & | regina::detail::ComponentBase< dim >::simplices () const
| Returns all top-dimensional simplices in this component. More...
Simplex< dim > * | regina::detail::ComponentBase< dim >::simplex (size_t index) const
| Returns the top-dimensional simplex at the given index in this component. More...
size_t | regina::detail::ComponentBase< dim >::countBoundaryComponents () const
| Returns the number of boundary components in this component. More...
const std::vector< BoundaryComponent< dim > * > & | regina::detail::ComponentBase< dim >::boundaryComponents () const
| Returns all boundary components in this component. More...
BoundaryComponent< dim > * | regina::detail::ComponentBase< dim >::boundaryComponent (size_t index) const
| Returns the boundary component at the given index in this component. More...
bool | regina::detail::ComponentBase< dim >::isValid () const
| Determines if this component is valid. More...
bool | regina::detail::ComponentBase< dim >::isOrientable () const
| Determines if this component is orientable. More...
bool | regina::detail::ComponentBase< dim >::hasBoundaryFacets () const
| Determines if this component has any boundary facets. More...
size_t | regina::detail::ComponentBase< dim >::countBoundaryFacets () const
| Returns the number of boundary facets in this component. More...
void | regina::detail::ComponentBase< dim >::writeTextShort (std::ostream &out) const
| Writes a short text representation of this object to the given output stream. More...
void | regina::detail::ComponentBase< dim >::writeTextLong (std::ostream &out) const
| Writes a detailed text representation of this object to the given output stream. More...
| regina::detail::ComponentBase< dim >::ComponentBase ()
| Default constructor. More...
static Triangulation< dim > * | regina::detail::ExampleFromLowDim< dim, available >::doubleCone (const Triangulation< dim-1 > &base)
| Returns a double cone over the given (dim-1)-dimensional triangulation. More...
static Triangulation< dim > * | regina::detail::ExampleFromLowDim< dim, available >::singleCone (const Triangulation< dim-1 > &base)
| Returns a single cone over the given (dim-1)-dimensional triangulation. More...
| regina::detail::ExampleBase< dim >::ExampleBase ()=delete
| Closed Triangulations. More...
static Triangulation< dim > * | regina::detail::ExampleBase< dim >::sphere ()
| Returns a two-simplex triangulation of the dim-sphere. More...
static Triangulation< dim > * | regina::detail::ExampleBase< dim >::simplicialSphere ()
| Returns the standard (dim+2)-simplex triangulation of the dim-sphere as the boundary of a (dim+1)-simplex. More...
static Triangulation< dim > * | regina::detail::ExampleBase< dim >::sphereBundle ()
| Returns a two-simplex triangulation of the product space `S^(dim-1) x S^1`. More...
static Triangulation< dim > * | regina::detail::ExampleBase< dim >::twistedSphereBundle ()
| Returns a two-simplex triangulation of the twisted product space `S^(dim-1) x~ S^1`. More...
static Triangulation< dim > * | regina::detail::ExampleBase< dim >::ball ()
| Bounded Triangulations. More...
static Triangulation< dim > * | regina::detail::ExampleBase< dim >::ballBundle ()
| Returns a triangulation of the product space `B^(dim-1) x S^1`. More...
static Triangulation< dim > * | regina::detail::ExampleBase< dim >::twistedBallBundle ()
| Returns a triangulation of the twisted product space `B^(dim-1) x~ S^1`. More...
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...
| regina::detail::FaceEmbeddingBase< dim, subdim >::FaceEmbeddingBase ()
| Default constructor. More...
| regina::detail::FaceEmbeddingBase< dim, subdim >::FaceEmbeddingBase (Simplex< dim > *simplex, int face)
| Creates a new object containing the given data. More...
| regina::detail::FaceEmbeddingBase< dim, subdim >::FaceEmbeddingBase (const FaceEmbeddingBase &cloneMe)
| Creates a new copy of the given object. More...
FaceEmbeddingBase & | regina::detail::FaceEmbeddingBase< dim, subdim >::operator= (const FaceEmbeddingBase &cloneMe)
| Makes this a copy of the given object. More...
Simplex< dim > * | regina::detail::FaceEmbeddingBase< dim, subdim >::simplex () const
| Returns the top-dimensional simplex in which the underlying subdim-face of the triangulation is contained. More...
int | regina::detail::FaceEmbeddingBase< dim, subdim >::face () const
| Returns the corresponding face number of simplex(). More...
Perm< dim+1 > | regina::detail::FaceEmbeddingBase< dim, subdim >::vertices () const
| Maps vertices (0,...,subdim) of the underlying subdim-face of the triangulation to the corresponding vertex numbers of simplex(). More...
bool | regina::detail::FaceEmbeddingBase< dim, subdim >::operator== (const FaceEmbeddingBase &rhs) const
| Tests whether this and the given object are identical. More...
bool | regina::detail::FaceEmbeddingBase< dim, subdim >::operator!= (const FaceEmbeddingBase &rhs) const
| Tests whether this and the given object are different. More...
void | regina::detail::FaceEmbeddingBase< dim, subdim >::writeTextShort (std::ostream &out) const
| Writes a short text representation of this object to the given output stream. More...
size_t | regina::detail::FaceStorage< dim, codim >::degree () const
| Returns the degree of this face. More...
const FaceEmbedding< dim, dim - codim > & | regina::detail::FaceStorage< dim, codim >::embedding (size_t index) const
| Returns one of the ways in which this face appears within a top-dimensional simplex of the underlying triangluation. More...
std::vector< FaceEmbedding< dim, dim - codim > >::const_iterator | regina::detail::FaceStorage< dim, codim >::begin () const
| A begin function for iterating through all appearances of this face within the various top-dimensional simplices of the underlying triangulation. More...
std::vector< FaceEmbedding< dim, dim - codim > >::const_iterator | regina::detail::FaceStorage< dim, codim >::end () const
| An end function for iterating through all appearances of this face within the various top-dimensional simplices of the underlying triangulation. More...
const FaceEmbedding< dim, dim - codim > & | regina::detail::FaceStorage< dim, codim >::front () const
| Returns the first appearance of this face within a top-dimensional simplex of the underlying triangluation. More...
const FaceEmbedding< dim, dim - codim > & | regina::detail::FaceStorage< dim, codim >::back () const
| Returns the last appearance of this face within a top-dimensional simplex of the underlying triangluation. More...
bool | regina::detail::FaceStorage< dim, codim >::inMaximalForest () const
| Determines whether a codimension-1-face represents a dual edge in the maximal forest that has been chosen for the dual 1-skeleton of the triangulation. More...
void | regina::detail::FaceStorage< dim, codim >::push_back (const FaceEmbedding< dim, dim - codim > &emb)
| Internal routine to help build the skeleton of a triangulation. More...
bool | regina::detail::FaceValidity< allowsInvalid, testLinks >::isValid () const
| Determines if this face is valid. More...
bool | regina::detail::FaceValidity< allowsInvalid, testLinks >::hasBadIdentification () const
| Determines if this face is identified with itself under a non-identity permutation. More...
bool | regina::detail::FaceValidity< allowsInvalid, testLinks >::hasBadLink () const
| Determines if this face does not have an appropriate link. More...
| regina::detail::FaceValidity< allowsInvalid, testLinks >::FaceValidity ()
| Initialises this face as valid. More...
void | regina::detail::FaceValidity< allowsInvalid, testLinks >::markBadIdentification ()
| Marks this face as having a non-identity self-identification. More...
void | regina::detail::FaceValidity< allowsInvalid, testLinks >::markBadLink ()
| Marks this face as having a bad link. More...
bool | regina::detail::FaceValidity< false, testLinks >::isValid () const
| Always returns `true`. More...
void | regina::detail::FaceValidity< false, testLinks >::markBadIdentification ()
| Marks this face as having a non-identity self-identification. More...
void | regina::detail::FaceValidity< false, testLinks >::markBadLink ()
| Marks this face as having a bad link. More...
bool | regina::detail::FaceValidity< true, false >::isValid () const
| Determines if this face is valid. More...
bool | regina::detail::FaceValidity< true, false >::hasBadIdentification () const
| Determines if this face is identified with itself under a non-identity permutation. More...
| regina::detail::FaceValidity< true, false >::FaceValidity ()
| Initialises this face as valid. More...
void | regina::detail::FaceValidity< true, false >::markBadIdentification ()
| Marks this face as having a non-identity self-identification. More...
bool | regina::detail::FaceOrientability< allowsNonorientable >::isLinkOrientable () const
| Determines if the link of this face is orientable. More...
| regina::detail::FaceOrientability< allowsNonorientable >::FaceOrientability ()
| Initialises the link of this face as orientable. More...
void | regina::detail::FaceOrientability< allowsNonorientable >::markLinkNonorientable ()
| Marks the link of this face as non-orientable. More...
bool | regina::detail::FaceOrientability< false >::isLinkOrientable () const
| Determines if the link of this face is orientable. More...
void | regina::detail::FaceOrientability< false >::markLinkNonorientable ()
| Marks the link of this face as non-orientable. More...
size_t | regina::detail::FaceBase< dim, subdim >::index () const
| Returns the index of this face within the underlying triangulation. More...
Triangulation< dim > * | regina::detail::FaceBase< dim, subdim >::triangulation () const
| Returns the triangulation to which this face belongs. More...
Component< dim > * | regina::detail::FaceBase< dim, subdim >::component () const
| Returns the component of the triangulation to which this face belongs. More...
BoundaryComponent< dim > * | regina::detail::FaceBase< dim, subdim >::boundaryComponent () const
| Returns the boundary component of the triangulation to which this face belongs. More...
bool | regina::detail::FaceBase< dim, subdim >::isBoundary () const
| Determines if this face lies entirely on the boundary of the triangulation. More...
template<int lowerdim>
Face< dim, lowerdim > * | regina::detail::FaceBase< dim, subdim >::face (int face) const
| Returns the lowerdim-face of the underlying triangulation that appears as the given lowerdim-dimensional subface of this face. More...
template<int lowerdim>
Perm< dim+1 > | regina::detail::FaceBase< dim, subdim >::faceMapping (int face) const
| Examines the given lowerdim-dimensional subface of this face, and returns the mapping between the underlying lowerdim-face of the triangulation and the individual vertices of this face. More...
void | regina::detail::FaceBase< dim, subdim >::writeTextShort (std::ostream &out) const
| Writes a short text representation of this object to the given output stream. More...
void | regina::detail::FaceBase< dim, subdim >::writeTextLong (std::ostream &out) const
| Writes a detailed text representation of this object to the given output stream. More...
| regina::detail::FaceBase< dim, subdim >::FaceBase (Component< dim > *component)
| Creates a new face. More...
static Perm< 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 (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 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...
| regina::detail::IsomorphismBase< dim >::IsomorphismBase (unsigned nSimplices)
| Creates a new isomorphism with no initialisation. More...
| regina::detail::IsomorphismBase< dim >::IsomorphismBase (const IsomorphismBase< dim > &copy)
| Creates a new copy of the given isomorphism. More...
| regina::detail::IsomorphismBase< dim >::~IsomorphismBase ()
| Destroys this isomorphism. More...
unsigned | regina::detail::IsomorphismBase< dim >::size () const
| Returns the number of simplices in the source triangulation associated with this isomorphism. More...
int & | regina::detail::IsomorphismBase< dim >::simpImage (unsigned sourceSimp)
| Determines the image of the given source simplex under this isomorphism. More...
int | regina::detail::IsomorphismBase< dim >::simpImage (unsigned sourceSimp) const
| Determines the image of the given source simplex under this isomorphism. More...
Perm< dim+1 > & | regina::detail::IsomorphismBase< dim >::facetPerm (unsigned sourceSimp)
| Returns a read-write reference to the permutation that is applied to the (dim + 1) facets of the given source simplex under this isomorphism. More...
Perm< dim+1 > | regina::detail::IsomorphismBase< dim >::facetPerm (unsigned sourceSimp) const
| Determines the permutation that is applied to the (dim + 1) facets of the given source simplex under this isomorphism. More...
FacetSpec< dim > | regina::detail::IsomorphismBase< dim >::operator[] (const FacetSpec< dim > &source) const
| Determines the image of the given source simplex facet under this isomorphism. More...
bool | regina::detail::IsomorphismBase< dim >::isIdentity () const
| Determines whether or not this is an identity isomorphism. More...
Triangulation< dim > * | regina::detail::IsomorphismBase< dim >::apply (const Triangulation< dim > *original) const
| Applies this isomorphism to the given triangulation, and returns the result as a new triangulation. More...
void | regina::detail::IsomorphismBase< dim >::applyInPlace (Triangulation< dim > *tri) const
| Applies this isomorphism to the given triangulation, modifying the given triangulation directly. More...
void | regina::detail::IsomorphismBase< dim >::writeTextShort (std::ostream &out) const
| Writes a short text representation of this object to the given output stream. More...
void | regina::detail::IsomorphismBase< dim >::writeTextLong (std::ostream &out) const
| Writes a detailed text representation of this object to the given output stream. More...
static Isomorphism< dim > * | regina::detail::IsomorphismBase< dim >::identity (unsigned nSimplices)
| Returns the identity isomorphism for the given number of simplices. More...
static Isomorphism< dim > * | regina::detail::IsomorphismBase< dim >::random (unsigned nSimplices)
| Returns a random isomorphism for the given number of simplices. More...
| regina::detail::SimplexFaces< dim, subdim >::SimplexFaces (const SimplexFaces &)=delete
| Explicitly disable the copy constructor. More...
SimplexFaces & | regina::detail::SimplexFaces< dim, subdim >::operator= (const SimplexFaces &)=delete
| Explicitly disable the assignment operator. More...
void | regina::detail::SimplexFaces< dim, subdim >::clear ()
| Resets all face pointers to null. More...
bool | regina::detail::SimplexFaces< dim, subdim >::sameDegrees (const SimplexFaces< dim, subdim > &other, Perm< dim+1 > p) const
| Tests whether the subdim-face degrees of this and the given simplex are identical, under the given relabelling. More...
bool | regina::detail::SimplexFacesSuite< dim, subdim >::sameDegrees (const SimplexFacesSuite< dim, subdim > &other, Perm< dim+1 > p) const
| Tests whether the k-face degrees of this and the given simplex are identical, under the given relabelling, for all faces of all dimensions k ≤ subdim. More...
const std::string & | regina::detail::SimplexBase< dim >::description () const
| Returns the description associated with this simplex. More...
void | regina::detail::SimplexBase< dim >::setDescription (const std::string &desc)
| Sets the description associated with this simplex. More...
size_t | regina::detail::SimplexBase< dim >::index () const
| Returns the index of this simplex in the underlying triangulation. More...
Simplex< dim > * | regina::detail::SimplexBase< dim >::adjacentSimplex (int facet) const
| Returns the adjacent simplex that is glued to the given facet of this simplex. More...
Perm< dim+1 > | regina::detail::SimplexBase< dim >::adjacentGluing (int facet) const
| Returns a permutation that indicates precisely how this simplex is glued to the adjacent simplex across the given facet. More...
int | regina::detail::SimplexBase< dim >::adjacentFacet (int facet) const
| If the given facet of this simplex is glued to facet f of some adjacent simplex, then this routine returns the adjacent facet number f. More...
bool | regina::detail::SimplexBase< dim >::hasBoundary () const
| Determines if this simplex has any facets that lie on the triangulation boundary. More...
void | regina::detail::SimplexBase< dim >::join (int myFacet, Simplex< dim > *you, Perm< dim+1 > gluing)
| Joins the given facet of this simplex to some facet of another simplex. More...
Simplex< dim > * | regina::detail::SimplexBase< dim >::unjoin (int myFacet)
| Unglues the given facet of this simplex from whatever it is joined to. More...
void | regina::detail::SimplexBase< dim >::isolate ()
| Unglues this simplex from any adjacent simplices. More...
Triangulation< dim > * | regina::detail::SimplexBase< dim >::triangulation () const
| Returns the triangulation to which this simplex belongs. More...
Component< dim > * | regina::detail::SimplexBase< dim >::component () const
| Returns the connected component of the triangulation to which this simplex belongs. More...
template<int subdim>
Face< dim, subdim > * | regina::detail::SimplexBase< dim >::face (int face) const
| Returns the subdim-face of the underlying triangulation that appears as the given subdim-face of this simplex. More...
template<int subdim>
Perm< dim+1 > | regina::detail::SimplexBase< dim >::faceMapping (int face) const
| Examines the given subdim-face of this simplex, and returns the mapping between the underlying subdim-face of the triangulation and the individual vertices of this simplex. More...
int | regina::detail::SimplexBase< dim >::orientation () const
| Returns the orientation of this simplex in the dim-dimensional triangulation. More...
bool | regina::detail::SimplexBase< dim >::facetInMaximalForest (int facet) const
| Determines whether the given facet of this simplex belongs to the maximal forest that has been chosen for the dual 1-skeleton of the underlying triangulation. More...
void | regina::detail::SimplexBase< dim >::writeTextShort (std::ostream &out) const
| Writes a short text representation of this object to the given output stream. More...
void | regina::detail::SimplexBase< dim >::writeTextLong (std::ostream &out) const
| Writes a detailed text representation of this object to the given output stream. More...
| regina::detail::SimplexBase< dim >::SimplexBase (Triangulation< dim > *tri)
| Creates a new simplex with no description and no facets joined to anything. More...
| regina::detail::SimplexBase< dim >::SimplexBase (const std::string &desc, Triangulation< dim > *tri)
| Creates a new simplex with the given description and no facets joined to anything. More...
void | regina::detail::FaceListSuite< dim, subdim >::deleteFaces ()
| Deletes all faces of dimension subdim and below. More...
void | regina::detail::FaceListSuite< dim, subdim >::swapFaces (FaceListSuite< dim, subdim > &other)
| Swaps all faces of dimension subdim and below with those of the given triangulation. More...
void | regina::detail::FaceListSuite< dim, subdim >::fillFVector (std::vector< size_t > &result) const
| Fills the given vector with the first (subdim + 1) elements of the f-vector. More...
bool | regina::detail::FaceListSuite< dim, subdim >::sameFVector (const FaceListSuite< dim, subdim > &other) const
| Tests whether this and the given triangulation have the same number of k-faces, for each facial dimension k ≤ subdim. More...
bool | regina::detail::FaceListSuite< dim, subdim >::sameDegrees (const FaceListSuite< dim, subdim > &other) const
| Tests whether this and the given triangulation have the same k-face degree sequences, for each facial dimension k ≤ subdim. More...
static void | regina::detail::FaceCalculator< dim, subdim, codim >::calculate (TriangulationBase< dim > &t)
| Calculates all faces of dimension ≤ subdim in the given triangulation. More...
static void | regina::detail::BoundaryComponentCalculator< dim, subdim >::identify (TriangulationBase< dim > &t, BoundaryComponent< dim > *bc, Face< dim, dim-1 > *facet)
| Identifies and marks all faces of dimension ≤ subdim within the given boundary facet of the given dim-dimensional triangulation. More...
static long | regina::detail::EulerCalculator< dim, subdim >::compute (const TriangulationBase< dim > &tri)
| Computes the alternating sum of the number of faces of tri of dimensions subdim, ..., dim. More...
constexpr static const char * | regina::detail::XMLTriangulationTags< dim >::simplices ()
| The XML tag that stores the set of all top-dimensional simplices for a dim-dimensional triangulation. More...
constexpr static const char * | regina::detail::XMLTriangulationTags< dim >::simplex ()
| The XML tag that stores a single top-dimensional simplex in a dim-dimensional triangulation. More...
constexpr static const char * | regina::detail::XMLTriangulationTags< dim >::size ()
| The XML attribute that stores the number of top-dimensional simplices in a dim-dimensional triangulation. More...
| regina::detail::XMLSimplexReader< dim >::XMLSimplexReader (Triangulation< dim > *tri, size_t whichSimplex)
| Creates a new simplex element reader. More...
virtual void | regina::detail::XMLSimplexReader< dim >::startElement (const std::string &, const regina::xml::XMLPropertyDict &props, XMLElementReader *)
| Signifies that parsing of this XML element is beginning. More...
virtual void | regina::detail::XMLSimplexReader< dim >::initialChars (const std::string &chars)
| Signifies that the initial text belonging to this XML element has been read. More...
| regina::detail::XMLSimplicesReader< dim >::XMLSimplicesReader (Triangulation< dim > *tri)
| Creates a new simplices element reader. More...
virtual void | regina::detail::XMLSimplicesReader< dim >::startElement (const std::string &, const regina::xml::XMLPropertyDict &props, XMLElementReader *)
| Signifies that parsing of this XML element is beginning. More...
virtual XMLElementReader * | regina::detail::XMLSimplicesReader< dim >::startSubElement (const std::string &subTagName, const regina::xml::XMLPropertyDict &)
| Signifies that a subelement of this XML element is about to be parsed. More...
| regina::detail::XMLTriangulationReaderBase< dim >::XMLTriangulationReaderBase (XMLTreeResolver &resolver)
| Creates a new triangulation reader. More...
virtual Packet * | regina::detail::XMLTriangulationReaderBase< dim >::packet () override
| Returns the newly allocated packet that has been read by this element reader. More...
virtual XMLElementReader * | regina::detail::XMLTriangulationReaderBase< dim >::startContentSubElement (const std::string &subTagName, const regina::xml::XMLPropertyDict &subTagProps) override
| Used instead of startSubElement() for XML subelements that are not child packets or packet tags. More...
virtual void | regina::detail::XMLTriangulationReaderBase< dim >::endContentSubElement (const std::string &subTagName, XMLElementReader *subReader) override
| Used instead of endSubElement() for XML subelements that are not child packets or packet tags. More...
| regina::detail::XMLTriangulationReaderBase< dim >::AbelianGroupPropertyReader::AbelianGroupPropertyReader (PropType &prop)
| Creates a new reader that stores its results in the given triangulation property. More...
virtual XMLElementReader * | regina::detail::XMLTriangulationReaderBase< dim >::AbelianGroupPropertyReader::startSubElement (const std::string &subTagName, const regina::xml::XMLPropertyDict &)
| Signifies that a subelement of this XML element is about to be parsed. More...
virtual void | regina::detail::XMLTriangulationReaderBase< dim >::AbelianGroupPropertyReader::endSubElement (const std::string &subTagName, XMLElementReader *subReader)
| Signifies that parsing has finished for a subelement of this XML element. More...
| regina::detail::XMLTriangulationReaderBase< dim >::GroupPresentationPropertyReader::GroupPresentationPropertyReader (PropType &prop)
| Creates a new reader that stores its results in the given triangulation property. More...
virtual XMLElementReader * | regina::detail::XMLTriangulationReaderBase< dim >::GroupPresentationPropertyReader::startSubElement (const std::string &subTagName, const regina::xml::XMLPropertyDict &)
| Signifies that a subelement of this XML element is about to be parsed. More...
virtual void | regina::detail::XMLTriangulationReaderBase< dim >::GroupPresentationPropertyReader::endSubElement (const std::string &subTagName, XMLElementReader *subReader)
| Signifies that parsing has finished for a subelement of this XML element. More...
XMLElementReader * | regina::detail::XMLTriangulationReaderBase< dim >::propertyReader (const std::string &subTagName, const regina::xml::XMLPropertyDict &subTagProps)
| Returns a reader for the generic triangulation property with the given subtag name. More...

## Variables

std::vector< Face< dim, subdim > * > | regina::detail::WeakFaceList< dim, subdim >::faces_
| The list of faces. More...
static constexpr bool | regina::detail::BoundaryComponentFaceStorage< dim, allFaces_ >::allFaces = true
| A compile-time constant indicating whether this boundary component class stores all lower-dimensional faces (`true`), or only faces of dimension dim-1 (`false`). More...
static constexpr bool | regina::detail::BoundaryComponentFaceStorage< dim, false >::allFaces = false
| A compile-time constant indicating whether this boundary component class stores all lower-dimensional faces (`true`), or only faces of dimension dim-1 (`false`). More...
std::vector< Face< dim, dim-1 > * > | regina::detail::BoundaryComponentFaceStorage< dim, false >::facets_
| List of all (dim-1)-simplices in the boundary component. More...
size_t | regina::detail::BoundaryComponentFaceStorage< dim, false >::nRidges_
| The number of (dim-2)-faces in the boundary component. More...
static constexpr bool | regina::detail::BoundaryComponentFaceInterface< dim, allFaces, allowVertex_ >::allowVertex = true
| A compile-time constant indicating whether ideal and/or invalid vertex boundary components are both possible and recognised by this boundary component class. More...
static constexpr bool | regina::detail::BoundaryComponentFaceInterface< dim, allFaces, false >::allowVertex = false
| A compile-time constant indicating whether ideal and/or invalid vertex boundary components are both possible and recognised by this boundary component class. More...
static constexpr bool | regina::detail::BoundaryComponentStorage< dim, allFaces, allowVertex, canBuild_ >::canBuild = true
| A compile-time constant indicating whether this boundary component class supports triangulating boundary components. More...
Triangulation< dim-1 > * | regina::detail::BoundaryComponentStorage< dim, allFaces, allowVertex, canBuild_ >::boundary_
| A full triangulation of the boundary component. More...
static constexpr bool | regina::detail::BoundaryComponentStorage< dim, allFaces, allowVertex, false >::canBuild = false
| A compile-time constant indicating whether this boundary component class supports triangulating boundary components. More...
bool | regina::detail::BoundaryComponentBase< dim >::orientable_
| Is this boundary component orientable? More...
bool | regina::detail::ComponentBase< dim >::valid_
| Is this component valid? See Triangulation<dim>::isValid() for details on what this means. More...
const int *const | regina::detail::binomSmall_ [17]
| A lookup table that stores (n choose k) for all n ≤ 16. 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...
size_t | regina::detail::FacetPairingBase< dim >::size_
| The number of simplices under consideration. More...
FacetSpec< dim > * | regina::detail::FacetPairingBase< dim >::pairs_
| The other facet to which each simplex facet is paired. More...
unsigned | regina::detail::IsomorphismBase< dim >::nSimplices_
| The number of simplices in the source triangulation. More...
int * | regina::detail::IsomorphismBase< dim >::simpImage_
| Stores the simplex of the destination triangulation that each simplex of the source triangulation maps to. More...
Perm< dim+1 > * | regina::detail::IsomorphismBase< dim >::facetPerm_
| The permutation applied to the facets of each source simplex. More...
Face< dim, subdim > * | regina::detail::SimplexFaces< dim, subdim >::face_ [FaceNumbering< dim, subdim >::nFaces]
| The faces of the underlying triangulation that form the individual subdim-faces of this simplex. More...
Perm< dim+1 > | regina::detail::SimplexFaces< dim, subdim >::mapping_ [FaceNumbering< dim, subdim >::nFaces]
| For each subdim-face of this simplex, maps vertices (0,1,...,subdim) of the underlying subdim-face of the triangulation to the corresponding vertices of this simplex, as described by faceMapping(). More...
static constexpr const char * | regina::detail::Strings< dim_ >::dim
| A string that gives the dimension dim as a number. More...
static constexpr const char * | regina::detail::Strings< dim_ >::face
| A string that gives the name of a dim-face, all in lower case. More...
static constexpr const char * | regina::detail::Strings< dim_ >::Face
| A string that gives the name of a dim-face, with the first word capitalised. More...
static constexpr const char * | regina::detail::Strings< dim_ >::faces
| A string that gives the plural name of a dim-face, all in lower case. More...
static constexpr const char * | regina::detail::Strings< dim_ >::Faces
| A string that gives the plural name of a dim-face, with the first word capitalised. More...
static constexpr const char * | regina::detail::Strings< dim_ >::simplex
| A string that gives the name of a dim-simplex, all in lower case. More...
static constexpr const char * | regina::detail::Strings< dim_ >::Simplex
| A string that gives the name of a dim-simplex, with the first word capitalised. More...
static constexpr int | regina::detail::TriangulationBase< dim >::dimension = dim
| A compile-time constant that gives the dimension of the triangulation. More...
MarkedVector< Simplex< dim > > | regina::detail::TriangulationBase< dim >::simplices_
| The top-dimensional simplices that form the triangulation. More...
MarkedVector< BoundaryComponent< dim > > | regina::detail::TriangulationBase< dim >::boundaryComponents_
| The components that form the boundary of the triangulation. More...
bool | regina::detail::TriangulationBase< dim >::valid_
| Is this triangulation valid? See isValid() for details on what this means. More...
Triangulation< dim > * | regina::detail::XMLTriangulationReaderBase< dim >::tri_
| The triangulation currently being read. More...

## Friends

class | regina::detail::BoundaryComponentBase< dim >::Triangulation< dim >
| Allow access to private members. More...
class | regina::detail::ComponentBase< dim >::Triangulation< dim >
class | regina::detail::ComponentBase< dim >::TriangulationBase< dim >
class | regina::detail::FaceBase< dim, subdim >::Triangulation< dim >
class | regina::detail::FaceBase< dim, subdim >::TriangulationBase< dim >
class | regina::detail::SimplexBase< dim >::TriangulationBase< dim >
class | regina::detail::SimplexBase< dim >::Triangulation< dim >

## Constructors and Destructors

| regina::detail::FacetPairingBase< dim >::FacetPairingBase (const FacetPairingBase &cloneMe)
| Creates a new facet pairing that is a clone of the given facet pairing. More...
| regina::detail::FacetPairingBase< dim >::FacetPairingBase (const Triangulation< dim > &tri)
| Creates the facet pairing of given triangulation. More...
| regina::detail::FacetPairingBase< dim >::~FacetPairingBase ()
| Deallocates any memory used by this structure. More...

## Basic Queries

size_t | regina::detail::FacetPairingBase< dim >::size () const
| Returns the number of simplices whose facets are described by this facet pairing. More...
const FacetSpec< dim > & | regina::detail::FacetPairingBase< dim >::dest (const FacetSpec< dim > &source) const
| Returns the other facet to which the given simplex facet is paired. More...
const FacetSpec< dim > & | regina::detail::FacetPairingBase< dim >::dest (size_t simp, unsigned facet) const
| Returns the other facet to which the given simplex facet is paired. More...
const FacetSpec< dim > & | regina::detail::FacetPairingBase< dim >::operator[] (const FacetSpec< dim > &source) const
| Returns the other facet to which the given simplex facet is paired. More...
bool | regina::detail::FacetPairingBase< dim >::isUnmatched (const FacetSpec< dim > &source) const
| Determines whether the given simplex facet has been left deliberately unmatched. More...
bool | regina::detail::FacetPairingBase< dim >::isUnmatched (size_t simp, unsigned facet) const
| Determines whether the given simplex facet has been left deliberately unmatched. More...
bool | regina::detail::FacetPairingBase< dim >::isClosed () const
| Determines whether this facet pairing is closed. More...

## Isomorphic Representations

bool | regina::detail::FacetPairingBase< dim >::isCanonical () const
| Determines whether this facet pairing is in canonical form, i.e., is a lexicographically minimal representative of its isomorphism class. More...
void | regina::detail::FacetPairingBase< dim >::findAutomorphisms (IsoList &list) const
| Fills the given list with the set of all combinatorial automorphisms of this facet pairing. More...

## Input and Output

void | regina::detail::FacetPairingBase< dim >::writeTextShort (std::ostream &out) const
| Writes a human-readable representation of this facet pairing to the given output stream. More...
std::string | regina::detail::FacetPairingBase< dim >::toTextRep () const
| Returns a text-based representation of this facet pairing that can be used to reconstruct the facet pairing. More...
void | regina::detail::FacetPairingBase< dim >::writeDot (std::ostream &out, const char *prefix=0, bool subgraph=false, bool labels=false) const
| Writes the graph corresponding to this facet pairing in the Graphviz DOT language. More...
std::string | regina::detail::FacetPairingBase< dim >::dot (const char *prefix=0, bool subgraph=false, bool labels=false) const
| Returns a Graphviz DOT representation of the graph that describes this facet pairing. More...
static FacetPairing< dim > * | regina::detail::FacetPairingBase< dim >::fromTextRep (const std::string &rep)
| Reconstructs a facet pairing from a text-based representation. More...
static void | regina::detail::FacetPairingBase< dim >::writeDotHeader (std::ostream &out, const char *graphName=0)
| Writes header information for a Graphviz DOT file that will describe the graphs for one or more facet pairings. More...
static std::string | regina::detail::FacetPairingBase< dim >::dotHeader (const char *graphName=0)
| Returns header information for a Graphviz DOT file that will describe the graphs for one or more facet pairings. More...
static void | regina::detail::FacetPairingBase< dim >::findAllPairings (size_t nSimplices, BoolSet boundary, int nBdryFacets, Use use, void *useArgs=0)
| Generates all possible facet pairings satisfying the given constraints. More...
| regina::detail::FacetPairingBase< dim >::FacetPairingBase (size_t size)
| Creates a new facet pairing. More...
FacetSpec< dim > & | regina::detail::FacetPairingBase< dim >::dest (const FacetSpec< dim > &source)
| Returns the other facet to which the given simplex facet is paired. More...
FacetSpec< dim > & | regina::detail::FacetPairingBase< dim >::dest (size_t simp, unsigned facet)
| Returns the other facet to which the given simplex facet is paired. More...
FacetSpec< dim > & | regina::detail::FacetPairingBase< dim >::operator[] (const FacetSpec< dim > &source)
| Returns the other facet to which the given simplex facet is paired. More...
bool | regina::detail::FacetPairingBase< dim >::noDest (const FacetSpec< dim > &source) const
| Determines whether the matching for the given simplex facet has not yet been determined. More...
bool | regina::detail::FacetPairingBase< dim >::noDest (size_t simp, unsigned facet) const
| Determines whether the matching for the given simplex facet has not yet been determined. More...
bool | regina::detail::FacetPairingBase< dim >::isCanonicalInternal (IsoList &list) const
| Determines whether this facet pairing is in canonical (smallest lexicographical) form, given a small set of assumptions. More...

## Constructors and Destructors

| regina::detail::TriangulationBase< dim >::TriangulationBase ()
| Default constructor. More...
| regina::detail::TriangulationBase< dim >::TriangulationBase (const TriangulationBase< dim > &copy)
| Creates a new copy of the given triangulation. More...
| regina::detail::TriangulationBase< dim >::TriangulationBase (const TriangulationBase< dim > &copy, bool cloneProps)
| Creates a new copy of the given triangulation, with the option of whether or not to clone its computed properties also. More...
| regina::detail::TriangulationBase< dim >::~TriangulationBase ()
| Destroys this triangulation. More...

## Simplices

size_t | regina::detail::TriangulationBase< dim >::size () const
| Returns the number of top-dimensional simplices in the triangulation. More...
const std::vector< Simplex< dim > * > & | regina::detail::TriangulationBase< dim >::simplices () const
| Returns all top-dimensional simplices in the triangulation. More...
Simplex< dim > * | regina::detail::TriangulationBase< dim >::simplex (size_t index)
| Returns the top-dimensional simplex at the given index in the triangulation. More...
const Simplex< dim > * | regina::detail::TriangulationBase< dim >::simplex (size_t index) const
| Returns the top-dimensional simplex at the given index in the triangulation. More...
Simplex< dim > * | regina::detail::TriangulationBase< dim >::newSimplex ()
| Creates a new top-dimensional simplex and adds it to this triangulation. More...
Simplex< dim > * | regina::detail::TriangulationBase< dim >::newSimplex (const std::string &desc)
| Creates a new top-dimensional simplex with the given description and adds it to this triangulation. More...
void | regina::detail::TriangulationBase< dim >::removeSimplex (Simplex< dim > *simplex)
| Removes the given top-dimensional simplex from this triangulation. More...
void | regina::detail::TriangulationBase< dim >::removeSimplexAt (size_t index)
| Removes the top-dimensional simplex at the given index in this triangulation. More...
void | regina::detail::TriangulationBase< dim >::removeAllSimplices ()
| Removes all simplices from the triangulation. More...
void | regina::detail::TriangulationBase< dim >::swapContents (Triangulation< dim > &other)
| Swaps the contents of this and the given triangulation. More...
void | regina::detail::TriangulationBase< dim >::moveContentsTo (Triangulation< dim > &dest)
| Moves the contents of this triangulation into the given destination triangulation, without destroying any pre-existing contents. More...

## Skeletal Queries

size_t | regina::detail::TriangulationBase< dim >::countComponents () const
| Returns the number of connected components in this triangulation. More...
size_t | regina::detail::TriangulationBase< dim >::countBoundaryComponents () const
| Returns the number of boundary components in this triangulation. More...
template<int subdim>
size_t | regina::detail::TriangulationBase< dim >::countFaces () const
| Returns the number of subdim-faces in this triangulation. More...
std::vector< size_t > | regina::detail::TriangulationBase< dim >::fVector () const
| Returns the f-vector of this triangulation, which counts the number of faces of all dimensions. More...
const std::vector< Component< dim > * > & | regina::detail::TriangulationBase< dim >::components () const
| Returns all connected components of this triangulation. More...
const std::vector< BoundaryComponent< dim > * > & | regina::detail::TriangulationBase< dim >::boundaryComponents () const
| Returns all boundary components of this triangulation. More...
template<int subdim>
const FaceList< dim, subdim > & | regina::detail::TriangulationBase< dim >::faces () const
| Returns an object that allows iteration through and random access to all subdim-faces of this triangulation. More...
Component< dim > * | regina::detail::TriangulationBase< dim >::component (size_t index) const
| Returns the requested connected component of this triangulation. More...
BoundaryComponent< dim > * | regina::detail::TriangulationBase< dim >::boundaryComponent (size_t index) const
| Returns the requested boundary component of this triangulation. More...
template<int subdim>
Face< dim, subdim > * | regina::detail::TriangulationBase< dim >::face (size_t index) const
| Returns the requested subdim-face of this triangulation. More...

## Basic Properties

bool | regina::detail::TriangulationBase< dim >::isEmpty () const
| Determines whether this triangulation is empty. More...
bool | regina::detail::TriangulationBase< dim >::isValid () const
| Determines if this triangulation is valid. More...
bool | regina::detail::TriangulationBase< dim >::hasBoundaryFacets () const
| Determines if this triangulation has any boundary facets. More...
size_t | regina::detail::TriangulationBase< dim >::countBoundaryFacets () const
| Returns the total number of boundary facets in this triangulation. More...
bool | regina::detail::TriangulationBase< dim >::isOrientable () const
| Determines if this triangulation is orientable. More...
bool | regina::detail::TriangulationBase< dim >::isConnected () const
| Determines if this triangulation is connected. More...
bool | regina::detail::TriangulationBase< dim >::isOriented () const
| Determines if this triangulation is oriented; that is, if the vertices of its top-dimensional simplices are labelled in a way that preserves orientation across adjacent facets. More...
long | regina::detail::TriangulationBase< dim >::eulerCharTri () const
| Returns the Euler characteristic of this triangulation. More...

## Algebraic Properties

const GroupPresentation & | regina::detail::TriangulationBase< dim >::fundamentalGroup () const
| Returns the fundamental group of this triangulation. More...
void | regina::detail::TriangulationBase< dim >::simplifiedFundamentalGroup (GroupPresentation *newGroup)
| Notifies the triangulation that you have simplified the presentation of its fundamental group. More...
const AbelianGroup & | regina::detail::TriangulationBase< dim >::homology () const
| Returns the first homology group for this triangulation. More...
const AbelianGroup & | regina::detail::TriangulationBase< dim >::homologyH1 () const
| Returns the first homology group for this triangulation. More...

## Skeletal Transformations

void | regina::detail::TriangulationBase< dim >::orient ()
| Relabels the vertices of top-dimensional simplices in this triangulation so that all simplices are oriented consistently, if possible. More...

## Subdivisions, Extensions and Covers

void | regina::detail::TriangulationBase< dim >::makeDoubleCover ()
| Converts this triangulation into its double cover. More...
void | regina::detail::TriangulationBase< dim >::barycentricSubdivision ()
| Does a barycentric subdivision of the triangulation. More...
bool | regina::detail::TriangulationBase< dim >::finiteToIdeal ()
| Converts each real boundary component into a cusp (i.e., an ideal vertex). More...

## Decompositions

size_t | regina::detail::TriangulationBase< dim >::splitIntoComponents (Packet *componentParent=0, bool setLabels=true)
| Splits a disconnected triangulation into many smaller triangulations, one for each component. More...

## Isomorphism Testing

bool | regina::detail::TriangulationBase< dim >::isIdenticalTo (const Triangulation< dim > &other) const
| Determines if this triangulation is combinatorially identical to the given triangulation. More...
std::unique_ptr< Isomorphism< dim > > | regina::detail::TriangulationBase< dim >::isIsomorphicTo (const Triangulation< dim > &other) const
| Determines if this triangulation is combinatorially isomorphic to the given triangulation. More...
std::unique_ptr< Isomorphism< dim > > | regina::detail::TriangulationBase< dim >::isContainedIn (const Triangulation< dim > &other) const
| Determines if an isomorphic copy of this triangulation is contained within the given triangulation, possibly as a subcomplex of some larger component (or components). More...
template<typename OutputIterator >
size_t | regina::detail::TriangulationBase< dim >::findAllIsomorphisms (const Triangulation< dim > &other, OutputIterator output) const
| Finds all ways in which this triangulation is combinatorially isomorphic to the given triangulation. More...
template<typename OutputIterator >
size_t | regina::detail::TriangulationBase< dim >::findAllSubcomplexesIn (const Triangulation< dim > &other, OutputIterator output) const
| Finds all ways in which an isomorphic copy of this triangulation is contained within the given triangulation, possibly as a subcomplex of some larger component (or components). More...
bool | regina::detail::TriangulationBase< dim >::makeCanonical ()
| Relabel the top-dimensional simplices and their vertices so that this triangulation is in canonical form. More...

## Building Triangulations

void | regina::detail::TriangulationBase< dim >::insertTriangulation (const Triangulation< dim > &source)
| Inserts a copy of the given triangulation into this triangulation. More...
void | regina::detail::TriangulationBase< dim >::insertConstruction (size_t nSimplices, const int adjacencies[][dim+1], const int gluings[][dim+1][dim+1])
| Inserts a given triangulation into this triangulation, where the given triangulation is described by a pair of integer arrays. More...

## Exporting Triangulations

std::string | regina::detail::TriangulationBase< dim >::isoSig (Isomorphism< dim > **relabelling=0) const
| Constructs the isomorphism signature for this triangulation. More...
std::string | regina::detail::TriangulationBase< dim >::dumpConstruction () const
| Returns C++ code that can be used with insertConstruction() to reconstruct this triangulation. More...

## Importing Triangulations

template<int , int , int >
struct | regina::detail::TriangulationBase< dim >::FaceCalculator
template<int , int >
struct | regina::detail::TriangulationBase< dim >::BoundaryComponentCalculator
template<int , int >
class | regina::detail::TriangulationBase< dim >::WeakFaceList
class | regina::detail::XMLTriangulationReaderBase< dim >
static Triangulation< dim > * | regina::detail::TriangulationBase< dim >::fromIsoSig (const std::string &sig)
| Recovers a full triangulation from an isomorphism signature. More...
static size_t | regina::detail::TriangulationBase< dim >::isoSigComponentSize (const std::string &sig)
| Deduces the number of top-dimensional simplices in a connected triangulation from its isomorphism signature. More...
void | regina::detail::TriangulationBase< dim >::ensureSkeleton () const
| Ensures that all "on demand" skeletal objects have been calculated. More...
bool | regina::detail::TriangulationBase< dim >::calculatedSkeleton () const
| Determines whether the skeletal objects and properties of this triangulation have been calculated. More...
void | regina::detail::TriangulationBase< dim >::calculateSkeleton ()
| Calculates all skeletal objects for this triangulation. More...
void | regina::detail::TriangulationBase< dim >::clearBaseProperties ()
| Clears all properties that are managed by this base class. More...
void | regina::detail::TriangulationBase< dim >::swapBaseProperties (TriangulationBase< dim > &other)
| Swaps all properties that are managed by this base class, including skeletal data, with the given triangulation. More...
void | regina::detail::TriangulationBase< dim >::writeXMLBaseProperties (std::ostream &out) const
| Writes a chunk of XML containing properties of this triangulation. More...

## Detailed Description

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

## Typedef Documentation

## BoundaryComponentIterator

template<int dim>

typedef std::vector<BoundaryComponent<dim>*>::const_iterator regina::detail::TriangulationBase< dim >::BoundaryComponentIterator

Used to iterate through boundary components.

## ComponentIterator

template<int dim>

typedef std::vector<Component<dim>*>::const_iterator regina::detail::TriangulationBase< dim >::ComponentIterator

Used to iterate through connected components.

## FacetMask

template<int dim>

typedef IntOfMinSize<(dim / 8) + 1>::utype regina::detail::SimplexBase< dim >::FacetMask

An unsigned integer type with at least dim+1 bits.

This can be used as a bitmask for the dim+1 facets (or vertices) of a dim-simplex.

## Holder [1/3]

template<int dim, int subdim>

typedef std::vector<Face<dim, subdim>*> regina::detail::FaceListHolder< Component< dim >, subdim >::Holder

The data type used by Component<dim> to store the list of all subdim-faces of the connected component.

The function Component<dim>::faces<subdim>() returns a const reference to this type.

## Holder [2/3]

template<int dim, int subdim>

typedef std::vector<Face<dim, subdim>*> regina::detail::FaceListHolder< BoundaryComponentFaceStorage< dim, true >, subdim >::Holder

The data type used by BoundaryComponent<dim> to store the list of all subdim-faces of the boundary component.

The function BoundaryComponent<dim>::faces<subdim>() returns a const reference to this type.

## Holder [3/3]

template<int dim, int subdim>

typedef FaceList<dim, subdim> regina::detail::FaceListHolder< detail::TriangulationBase< dim >, subdim >::Holder

The data type used by Triangulation<dim> to store the list of all subdim-faces of the triangulation.

The function Triangulation<dim>::faces<subdim>() returns a const reference to this type.

## IsoList

template<int dim>

typedef std::list<Isomorphism<dim>*> regina::detail::FacetPairingBase< dim >::IsoList

A list of isomorphisms on facet pairings.

Such an isomorphism can be used to convert one facet pairing into another.

This type is used to store all automorphisms of a facet pairing; that is, all isomorphisms that map the facet pairing to itself.

## PropType [1/2]

template<int dim>

typedef Property<AbelianGroup, StoreManagedPtr> regina::detail::XMLTriangulationReaderBase< dim >::AbelianGroupPropertyReader::PropType

The type of the property currently being read.

## PropType [2/2]

template<int dim>

typedef Property<GroupPresentation, StoreManagedPtr> regina::detail::XMLTriangulationReaderBase< dim >::GroupPresentationPropertyReader::PropType

The type of the property currently being read.

## SimplexIterator

template<int dim>

typedef std::vector<Simplex<dim>*>::const_iterator regina::detail::TriangulationBase< dim >::SimplexIterator

Used to iterate through top-dimensional simplices.

## Use

template<int dim>

typedef void(* regina::detail::FacetPairingBase< dim >::Use) (const FacetPairing< dim > *, const IsoList *, void *)

A routine that can do arbitrary processing upon a facet pairing and its automorphisms.

Such routines are used to process pairings that are found when running findAllPairings().

The first parameter passed should be a facet pairing (this should not be deallocated by this routine). The second parameter should be a list of all automorphisms of this pairing (this should not be deallocated either). The third parameter may contain arbitrary data as passed to findAllPairings().

Note that the first two parameters passed might be `null` to signal that facet pairing generation has finished.

## Function Documentation

## AbelianGroupPropertyReader()

template<int dim>

regina::detail::XMLTriangulationReaderBase< dim >::AbelianGroupPropertyReader::AbelianGroupPropertyReader | ( | PropType & | prop | ) |

inline

Creates a new reader that stores its results in the given triangulation property.

Parameters

  prop | a reference to the triangulation property in which the data that is read should be stored.

## adjacentFacet()

template<int dim>

int regina::detail::SimplexBase< dim >::adjacentFacet | ( | int | facet | ) | const

inline

If the given facet of this simplex is glued to facet f of some adjacent simplex, then this routine returns the adjacent facet number f.

The return value from this routine is identical to adjacentGluing(facet)[facet].

Precondition
  The given facet of this simplex has some adjacent simplex (possibly this one) glued to it. In other words, adjacentSimplex(facet) is not `null`.

Parameters

  facet | the facet of this simplex that we are examining. This must be between 0 and dim inclusive.

Returns
  the corresponding facet number of the adjacent simplex that is glued to the given facet of this simplex.

## adjacentGluing()

template<int dim>

Perm< dim+1 > regina::detail::SimplexBase< dim >::adjacentGluing | ( | int | facet | ) | const

inline

Returns a permutation that indicates precisely how this simplex is glued to the adjacent simplex across the given facet.

In detail: suppose that the given facet of this simplex is glued to an adjacent simplex A. Then this gluing induces a mapping from the vertices of this simplex to the vertices of A. We can express this mapping in the form of a permutation p, where:

- for any v ≠ facet, the gluing identifies vertex v of this simplex with vertex p[v] of simplex A;
- p[facet] indicates the facet of A that is on the other side of the gluing (i.e., the facet of A that is glued to the given facet of this simplex).

Precondition
  The given facet of this simplex has some adjacent simplex (possibly this one) glued to it. In other words, adjacentSimplex(facet) is not `null`.

Parameters

  facet | the facet of this simplex that we are examining. This must be between 0 and dim inclusive.

Returns
  a permutation that maps the vertices of this simplex to the vertices of the adjacent simplex, as described above.

## adjacentSimplex()

template<int dim>

Simplex< dim > * regina::detail::SimplexBase< dim >::adjacentSimplex | ( | int | facet | ) | const

inline

Returns the adjacent simplex that is glued to the given facet of this simplex.

If there is no adjacent simplex (i.e., the given facet lies on the triangulation boundary), then this routine will return 0.

Parameters

  facet | the facet of this simplex to examine; this must be between 0 and dim inclusive.

Returns
  the adjacent simplex glued to the given facet, or 0 if the given facet lies on the boundary.

## allowsInvalidFaces()

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

constexpr

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:\n Not present.

Parameters

  dim | the dimension of the underlying triangulations.
  subdim | the 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
| ) |  |

constexpr

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:\n Not present.

Parameters

  dim | the dimension of the underlying triangulations.
  subdim | the 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.

## apply()

template<int dim>

Triangulation< dim > * regina::detail::IsomorphismBase< dim >::apply | ( | const Triangulation< dim > * | original | ) | const

Applies this isomorphism to the given triangulation, and returns the result as a new triangulation.

An isomorphism represents a combinatorial map from a triangulation T to a triangulation U. This routine treats the given triangulation as the domain T, and returns the corresponding range U. The given triangulation T is not modified in any way.

In more detail: A new triangulation U is returned, so that this isomorphism represents a one-to-one, onto and boundary complete isomorphism from T to U. That is, T and U will be combinatorially identical triangulations, and this isomorphism describes the mapping from the simplices of T and their facets to the simplices of U and their facets.

The resulting triangulation U is newly created, and must be destroyed by the caller of this routine.

There are several preconditions to this routine. This routine does a small amount of sanity checking (and returns 0 if an error is detected), but it certainly does not check the full set of preconditions. It is up to the caller of this routine to verify that all of the following preconditions are met.

Precondition
  The number of simplices in the given triangulation is precisely the number returned by size() for this isomorphism.
  The simplex images are precisely 0,1,...,size()-1 in some order (i.e., this isomorphism does not represent a mapping from a smaller triangulation into a larger triangulation).

Parameters

  original | the triangulation to which this isomorphism should be applied.

Returns
  the new isomorphic triangulation, or 0 if a problem was encountered (i.e., an unmet precondition was noticed).

## applyInPlace()

template<int dim>

void regina::detail::IsomorphismBase< dim >::applyInPlace | ( | Triangulation< dim > * | tri | ) | const

Applies this isomorphism to the given triangulation, modifying the given triangulation directly.

This is similar to apply(), except that instead of creating a new triangulation, the simplices and vertices of the given triangulation are modified in-place.

See apply() for further details on how this operation is performed.

As with apply(), there are several preconditions to this routine. This routine does a small amount of sanity checking (and returns without changes if an error is detected), but it certainly does not check the full set of preconditions. It is up to the caller of this routine to verify that all of the following preconditions are met.

Precondition
  The number of simplices in the given triangulation is precisely the number returned by size() for this isomorphism.
  The simplex images are precisely 0,1,...,size()-1 in some order (i.e., this isomorphism does not represent a mapping from a smaller triangulation into a larger triangulation).

Parameters

  tri | the triangulation to which this isomorphism should be applied.

## back()

template<int dim, int codim>

const FaceEmbedding< dim, dim - codim > & regina::detail::FaceStorage< dim, codim >::back | ( |  | ) | const

inline

Returns the last appearance of this face within a top-dimensional simplex of the underlying triangluation.

This is equivalent to calling `embedding(degree()-1)`.

In most cases, the ordering of appearances is arbitrary. The exception is for codimension 2, where the appearances of a face are ordered in a way that follows the link around the face (which in codimension 2 is always a path or a cycle). In particular, for a boundary face of codimension 2, both front() and back() will refer to the two appearances of this face on the (dim-1)-dimensional boundary.

Returns
  details of the last appearance.

## ball()

template<int dim>

Triangulation< dim > * regina::detail::ExampleBase< dim >::ball | ( |  | ) |

static

Bounded Triangulations.

Returns a one-simplex triangulation of the dim-ball.

Returns
  a newly constructed triangulation, which must be destroyed by the caller of this routine.

## ballBundle()

template<int dim>

Triangulation< dim > * regina::detail::ExampleBase< dim >::ballBundle | ( |  | ) |

static

Returns a triangulation of the product space `B^(dim-1) x S^1`.

This will use one simplex in odd dimensions, or two simplices in even dimensions.

Returns
  a newly constructed triangulation, which must be destroyed by the caller of this routine.

## barycentricSubdivision()

template<int dim>

void regina::detail::TriangulationBase< dim >::barycentricSubdivision | ( |  | ) |

Does a barycentric subdivision of the triangulation.

This is done in-place, i.e., the triangulation will be modified directly.

Each top-dimensional simplex s is divided into (dim + 1) factorial sub-simplices by placing an extra vertex at the centroid of every face of every dimension. Each of these sub-simplices t is described by a permutation p of (0, ..., dim). The vertices of such a sub-simplex t are:

- vertex p[0] of s;
- the centre of edge (p[0], p[1]) of s;
- the centroid of triangle (p[0], p[1], p[2]) of s;
- ...
- the centroid of face (p[0], p[1], p[2], p[dim]) of s, which is the entire simplex s itself.

The sub-simplices have their vertices numbered in a way that mirrors the original simplex s:

- vertex p[0] of s will be labelled p[0] in t;
- the centre of edge (p[0], p[1]) of s will be labelled p[1] in t;
- the centroid of triangle (p[0], p[1], p[2]) of s will be labelled p[2] in t;
- ...
- the centroid of s itself will be labelled p[dim] in t.

If simplex s has index i in the original triangulation, then its sub-simplex corresponding to permutation p will have index `((dim + 1)! * i + p.index())` in the resulting triangulation. In other words: sub-simplices are ordered first according to the original simplex that contains them, and then according to the lexicographical ordering of the corresponding permutations p.

Precondition
  dim is one of Regina's standard dimensions. This precondition is a safety net, since in higher dimensions the triangulation would explode too quickly in size (and for the highest dimensions, possibly beyond the limits of `size_t`).

Warning
  In dimensions 3 and 4, both the labelling and ordering of sub-simplices in the subdivided triangulation has changed as of Regina 5.1. (Earlier versions of Regina made no guarantee about the labelling and ordering; these guarantees are also new to Regina 5.1).

## begin()

template<int dim, int codim>

std::vector< FaceEmbedding< dim, dim - codim > >::const_iterator regina::detail::FaceStorage< dim, codim >::begin | ( |  | ) | const

inline

A begin function for iterating through all appearances of this face within the various top-dimensional simplices of the underlying triangulation.

In most cases, the ordering of appearances is arbitrary. The exception is for codimension 2, where these appearances are ordered in a way that follows the link around the face (which in codimension 2 is always a path or a cycle).

An iteration from begin() to end() will run through degree() appearances in total.

Python:\n Not present. However, Python users can call
  the Python-only routine embeddings(), which will return all appearances (from begin() through to end()) in a Python sequence.

Returns
  a iterator that points to the first appearance.

## boundaryComponent() [1/3]

template<int dim, int subdim>

BoundaryComponent< dim > * regina::detail::FaceBase< dim, subdim >::boundaryComponent | ( |  | ) | const

inline

Returns the boundary component of the triangulation to which this face belongs.

See the note in the BoundaryComponent overview regarding what happens if the link of the face itself has more than one boundary component. Note that such a link makes both the face and the underlying triangulation invalid.

For dimensions in which ideal and/or invalid vertices are both possible and recognised: an ideal vertex will have its own individual boundary component to which it belongs, and so will an invalid vertex boundary component if the invalid vertex does not already belong to some real boundary component.

Returns
  the boundary component containing this face, or 0 if this face does not lie entirely within the boundary of the triangulation.

## boundaryComponent() [2/3]

template<int dim>

BoundaryComponent< dim > * regina::detail::ComponentBase< dim >::boundaryComponent | ( | size_t | index | ) | const

inline

Returns the boundary component at the given index in this component.

Note that the index of a boundary component within this component may not be the same as its index within the overall triangulation.

Parameters

  index | specifies which boundary component to return; this should be between 0 and countBoundaryComponents()-1 inclusive.

Returns
  the requested boundary component.

## boundaryComponent() [3/3]

template<int dim>

BoundaryComponent< dim > * regina::detail::TriangulationBase< dim >::boundaryComponent | ( | size_t | index | ) | const

inline

Returns the requested boundary component of this triangulation.

Note that each time the triangulation changes, all boundary components will be deleted and replaced with new ones. Therefore this object should be considered temporary only.

Parameters

  index | the index of the desired boundary component; this must be between 0 and countBoundaryComponents()-1 inclusive.

Returns
  the requested boundary component.

## BoundaryComponentBase()

template<int dim>

regina::detail::BoundaryComponentBase< dim >::BoundaryComponentBase | ( |  | ) |

protected default

Default constructor that leaves orientability uninitialised.

## BoundaryComponentFaceStorage()

template<int dim>

regina::detail::BoundaryComponentFaceStorage< dim, false >::BoundaryComponentFaceStorage | ( |  | ) |

inline protected

Default constructor that initialises the number of ridges to zero.

## boundaryComponents() [1/2]

template<int dim>

const std::vector< BoundaryComponent< dim > * > & regina::detail::ComponentBase< dim >::boundaryComponents | ( |  | ) | const

Returns all boundary components in this component.

The reference that is returned will remain valid only for as long as this component object exists. In particular, the reference will become invalid any time that the triangulation changes (since all component objects will be destroyed and others rebuilt in their place).

Python:\n This routine returns a python list.

Returns
  the list of all boundary components.

## boundaryComponents() [2/2]

template<int dim>

const std::vector< BoundaryComponent< dim > * > & regina::detail::TriangulationBase< dim >::boundaryComponents | ( |  | ) | const

inline

Returns all boundary components of this triangulation.

Note that, in Regina's standard dimensions, each ideal vertex forms its own boundary component, and some invalid vertices do also. See the BoundaryComponent class notes for full details on what constitutes a boundary component in standard and non-standard dimensions.

Bear in mind that each time the triangulation changes, all boundary component objects will be deleted and replaced with new ones. Therefore these boundary component objects should be considered temporary only.

In contrast, this reference to the list of BoundaryComponent objects will remain valid and up-to-date for as long as the triangulation exists.

Python:\n This routine returns a python list.

Returns
  the list of all boundary components.

## BoundaryComponentStorage()

template<int dim, bool allFaces, bool allowVertex, bool canBuild_>

regina::detail::BoundaryComponentStorage< dim, allFaces, allowVertex, canBuild_ >::BoundaryComponentStorage | ( |  | ) |

inline protected

Initialises the cached boundary triangulation to `null`.

## build()

template<int dim, bool allFaces, bool allowVertex, bool canBuild_>

const Triangulation<dim-1>* regina::detail::BoundaryComponentStorage< dim, allFaces, allowVertex, canBuild_ >::build | ( |  | ) | const

inline

Returns the full (dim-1)-dimensional triangulation of this boundary component.

Note that this triangulation is read-only (though of course you can clone it and then operate upon the clone).

If this is a real boundary component (i.e., it is built from one or more (dim-1)-faces), then the triangulation of this boundary component is as follows:

- Let i lie between 0 and size()-1 inclusive. Then simplex i of the returned (dim-1)-dimensional triangulation is a copy of `facet(i)` of this boundary component, and its vertices 0,...,dim-1 are numbered in the same way. To relate these (dim-1)-face vertex numbers to the vertex numbers of top-dimensional simplices in the overall dim-dimensional triangulation, see Simplex<dim>::faceMapping<dim-1>().
- If this boundary component stores lower-dimensional faces (i.e., if the template argument allFaces is `true`), then a similar correspondence holds for these lower-dimensional faces also: for each i, k-face i of the returned triangulation is a copy of `face<k>(i)` of this boundary component, and its vertices are numbered in the same way.

If this boundary component consists only of a single vertex (i.e., this is an ideal or invalid vertex boundary component), then this routine returns the triangulation of the corresponding vertex link. See Vertex::link() for details.

This routine is fast, since it caches the boundary triangulation. Moreover, it is guaranteed that the full skeleton of this (dim-1)-dimensional triangulation will have been generated already.

Returns
  the triangulation of this boundary component.

## buildVertexLink() [1/2]

template<int dim, bool allFaces, bool allowVertex_>

const Triangulation<dim-1>* regina::detail::BoundaryComponentFaceInterface< dim, allFaces, allowVertex_ >::buildVertexLink | ( |  | ) | const

inline protected

Triangulates the vertex link for an ideal or invalid vertex boundary component.

Returns
  the triangulated vertex link.

## buildVertexLink() [2/2]

template<int dim, bool allFaces>

constexpr const Triangulation<dim-1>* regina::detail::BoundaryComponentFaceInterface< dim, allFaces, false >::buildVertexLink | ( |  | ) | const

inline constexpr protected

Always returns `null`.

In general, this routine triangulates the vertex link for an ideal or invalid vertex boundary component. However, this specialisation is used for cases where such boundary components are either not recognised or not possible, and so this routine returns `null` always.

Returns
  `null`.

## calculate()

template<int dim, int subdim, int codim>

static void regina::detail::FaceCalculator< dim, subdim, codim >::calculate | ( | TriangulationBase< dim > & | t | ) |

inline static

Calculates all faces of dimension ≤ subdim in the given triangulation.

Parameters

  t | the triangulation whose faces should be calculated.

## calculatedSkeleton()

template<int dim>

bool regina::detail::TriangulationBase< dim >::calculatedSkeleton | ( |  | ) | const

inline protected

Determines whether the skeletal objects and properties of this triangulation have been calculated.

These are only calculated "on demand", when a skeletal property is first queried.

Returns
  `true` if and only if the skeleton has been calculated.

## calculateSkeleton()

template<int dim>

void regina::detail::TriangulationBase< dim >::calculateSkeleton | ( |  | ) |

protected

Calculates all skeletal objects for this triangulation.

For this parent class, calculateSkeleton() computes properties such as connected components, orientability, and lower-dimensional faces. Some Triangulation<dim> subclasses may track additional skeletal data, in which case they should reimplement this function. Their reimplementations must call this parent implementation.

You should never call this function directly; instead call ensureSkeleton() instead.

Precondition
  No skeletal objects have been computed, and the corresponding internal lists are all empty.

Warning
  Any call to calculateSkeleton() must first cast down to Triangulation<dim>. You should never directly call this parent implementation (unless of course you are reimplementing calculateSkeleton() in a Triangulation<dim> subclass).

## clear()

template<int dim, int subdim>

void regina::detail::SimplexFaces< dim, subdim >::clear | ( |  | ) |

inline protected

Resets all face pointers to null.

The faces themselves are not destroyed, and the mapping permutations are not touched.

## clearBaseProperties()

template<int dim>

void regina::detail::TriangulationBase< dim >::clearBaseProperties | ( |  | ) |

protected

Clears all properties that are managed by this base class.

This includes deleting all skeletal objects and emptying the corresponding internal lists, as well as clearing other cached properties and deallocating the corresponding memory where required.

Note that TriangulationBase never calls this routine itself. Typically clearBaseProperties() is only ever called by Triangulation<dim>::clearAllProperties(), which in turn is called by "atomic" routines that change the triangluation (before firing packet change events), as well as the Triangulation<dim> destructor.

## component() [1/5]

template<int dim>

Component< dim > * regina::detail::SimplexBase< dim >::component | ( |  | ) | const

inline

Returns the connected component of the triangulation to which this simplex belongs.

Returns
  the component containing this simplex.

## component() [2/5]

template<int dim, bool allFaces_>

Component<dim>* regina::detail::BoundaryComponentFaceStorage< dim, allFaces_ >::component | ( |  | ) | const

inline

Returns the connected component of the triangulation to which this boundary component belongs.

Returns
  the component containing this boundary component.

## component() [3/5]

template<int dim>

Component<dim>* regina::detail::BoundaryComponentFaceStorage< dim, false >::component | ( |  | ) | const

inline

Returns the connected component of the triangulation to which this boundary component belongs.

Returns
  the component containing this boundary component.

## component() [4/5]

template<int dim, int subdim>

Component< dim > * regina::detail::FaceBase< dim, subdim >::component | ( |  | ) | const

inline

Returns the component of the triangulation to which this face belongs.

Returns
  the component containing this face.

## component() [5/5]

template<int dim>

Component< dim > * regina::detail::TriangulationBase< dim >::component | ( | size_t | index | ) | const

inline

Returns the requested connected component of this triangulation.

Note that each time the triangulation changes, all component objects will be deleted and replaced with new ones. Therefore this component object should be considered temporary only.

Parameters

  index | the index of the desired component; this must be between 0 and countComponents()-1 inclusive.

Returns
  the requested component.

## ComponentBase()

template<int dim>

regina::detail::ComponentBase< dim >::ComponentBase | ( |  | ) |

inline protected

Default constructor.

Marks the component as orientable, with no boundary facets.

## components()

template<int dim>

const std::vector< Component< dim > * > & regina::detail::TriangulationBase< dim >::components | ( |  | ) | const

inline

Returns all connected components of this triangulation.

Note that each time the triangulation changes, all component objects will be deleted and replaced with new ones. Therefore these component objects should be considered temporary only.

In contrast, this reference to the list of all components will remain valid and up-to-date for as long as the triangulation exists.

Python:\n This routine returns a python list.

Returns
  the list of all components.

## compute()

template<int dim, int subdim>

static long regina::detail::EulerCalculator< dim, subdim >::compute | ( | const TriangulationBase< dim > & | tri | ) |

inline static

Computes the alternating sum of the number of faces of tri of dimensions subdim, ..., dim.

Specifically, this computes `tri.countFaces<subdim>() - tri.countFaces<subdim+1>() + ... +/- tri.countFaces<dim>()`.

Parameters

  tri | the triangulations whose face counts are to be computed.

Returns
  the resulting "partial" Euler characteristic.

## 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

  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.

## countBoundaryComponents() [1/2]

template<int dim>

size_t regina::detail::ComponentBase< dim >::countBoundaryComponents | ( |  | ) | const

inline

Returns the number of boundary components in this component.

Returns
  the number of boundary components.

## countBoundaryComponents() [2/2]

template<int dim>

size_t regina::detail::TriangulationBase< dim >::countBoundaryComponents | ( |  | ) | const

inline

Returns the number of boundary components in this triangulation.

Note that, in Regina's standard dimensions, each ideal vertex forms its own boundary component, and some invalid vertices do also. See the BoundaryComponent class notes for full details on what constitutes a boundary component in standard and non-standard dimensions.

Returns
  the number of boundary components.

## countBoundaryFacets() [1/2]

template<int dim>

size_t regina::detail::ComponentBase< dim >::countBoundaryFacets | ( |  | ) | const

inline

Returns the number of boundary facets in this component.

A boundary facet is a (dim-1)-dimensional facet of a top-dimensional simplex that is not joined to any adjacent simplex.

This routine runs in constant time (since the result is computed in advance, when the component is first created).

Returns
  the total number of boundary facets.

## countBoundaryFacets() [2/2]

template<int dim>

size_t regina::detail::TriangulationBase< dim >::countBoundaryFacets | ( |  | ) | const

inline

Returns the total number of boundary facets in this triangulation.

This routine counts facets of top-dimensional simplices that are not glued to some adjacent top-dimensional simplex.

Returns
  the total number of boundary facets.

## countComponents()

template<int dim>

size_t regina::detail::TriangulationBase< dim >::countComponents | ( |  | ) | const

inline

Returns the number of connected components in this triangulation.

Returns
  the number of connected components.

## countFaces() [1/2]

template<int dim, bool allFaces_>
template<int subdim>

size_t regina::detail::BoundaryComponentFaceStorage< dim, allFaces_ >::countFaces | ( |  | ) | const

inline

Returns the number of subdim-faces in this boundary component.

This routine is only available where dim is one of Regina's standard dimensions.

Python:\n Python does not support templates. Instead,
  Python users should call this function in the form `countFaces(subdim)`; that is, the template parameter subdim becomes the first argument of the function.

Template Parameters

  subdim | the dimension of the faces to query. This must be between 0 and dim-1 inclusive.

Returns
  the number of subdim-faces.

## countFaces() [2/2]

template<int dim>
template<int subdim>

size_t regina::detail::TriangulationBase< dim >::countFaces | ( |  | ) | const

inline

Returns the number of subdim-faces in this triangulation.

Precondition
  The template argument subdim is between 0 and dim-1 inclusive.

Python:\n Python does not support templates. Instead,
  Python users should call this function in the form `countFaces(subdim)`; that is, the template parameter subdim becomes the first argument of the function.

Returns
  the number of subdim-faces.

## countRidges() [1/2]

template<int dim, bool allFaces_>

size_t regina::detail::BoundaryComponentFaceStorage< dim, allFaces_ >::countRidges | ( |  | ) | const

inline

Returns the number of (dim-2)-faces in this boundary component.

If this is an ideal or invalid vertex boundary component, then this routine will return 0.

Returns
  the number of (dim-2)-faces in this boundary component.

## countRidges() [2/2]

template<int dim>

size_t regina::detail::BoundaryComponentFaceStorage< dim, false >::countRidges | ( |  | ) | const

inline

Returns the number of (dim-2)-faces in this boundary component.

If this is an ideal or invalid vertex boundary component, then this routine will return 0.

Returns
  the number of (dim-2)-faces in this boundary component.

## degree()

template<int dim, int codim>

size_t regina::detail::FaceStorage< dim, codim >::degree | ( |  | ) | const

inline

Returns the degree of this face.

This is the number of different ways in which the face appears within the various top-dimensional simplices of the underlying triangulation.

Note that if this face appears multiple times within the same top-dimensional simplex, then it will be counted multiple times by this routine.

Returns
  the degree of this face.

## deleteFaces()

template<int dim>

void regina::detail::FaceListSuite< dim >::deleteFaces | ( |  | ) |

inline protected

Deletes all faces of dimension subdim and below.

This routine destroys the corresponding Face objects and clears the lists that contain them.

## description()

template<int dim>

const std::string & regina::detail::SimplexBase< dim >::description | ( |  | ) | const

inline

Returns the description associated with this simplex.

Returns
  the description of this simplex, or the empty string if no description is stored.

## dest() [1/4]

template<int dim>

FacetSpec< dim > & regina::detail::FacetPairingBase< dim >::dest | ( | const FacetSpec< dim > & | source | ) |

inline protected

Returns the other facet to which the given simplex facet is paired.

If the given facet is left deliberately unmatched, the value returned will be boundary (as returned by FacetSpec<dim>::isBoundary()).

Precondition
  The given facet is a real simplex facet (not boundary, before-the-start or past-the-end).

Parameters

  source | the facet under investigation.

Returns
  the other facet to which the given facet is paired.

## dest() [2/4]

template<int dim>

const FacetSpec< dim > & regina::detail::FacetPairingBase< dim >::dest | ( | const FacetSpec< dim > & | source | ) | const

inline

Returns the other facet to which the given simplex facet is paired.

If the given facet is left deliberately unmatched, the value returned will be boundary (as returned by FacetSpec<dim>::isBoundary()).

Precondition
  The given facet is a real simplex facet (not boundary, before-the-start or past-the-end).

Parameters

  source | the facet under investigation.

Returns
  the other facet to which the given facet is paired.

## dest() [3/4]

template<int dim>

FacetSpec< dim > & regina::detail::FacetPairingBase< dim >::dest | ( | size_t | simp,
|  | unsigned | facet
| ) |  |

inline protected

Returns the other facet to which the given simplex facet is paired.

If the given facet is left deliberately unmatched, the value returned will be boundary (as returned by FacetSpec<dim>::isBoundary()).

Parameters

  simp | the simplex under investigation (this must be strictly less than the total number of simplices under consideration).
  facet | the facet of the given simplex under investigation (between 0 and dim inclusive).

Returns
  the other facet to which the given facet is paired.

## dest() [4/4]

template<int dim>

const FacetSpec< dim > & regina::detail::FacetPairingBase< dim >::dest | ( | size_t | simp,
|  | unsigned | facet
| ) |  | const

inline

Returns the other facet to which the given simplex facet is paired.

If the given facet is left deliberately unmatched, the value returned will be boundary (as returned by FacetSpec<dim>::isBoundary()).

Parameters

  simp | the simplex under investigation (this must be strictly less than the total number of simplices under consideration).
  facet | the facet of the given simplex under investigation (between 0 and dim inclusive).

Returns
  the other facet to which the given facet is paired.

## dot()

template<int dim>

std::string regina::detail::FacetPairingBase< dim >::dot | ( | const char * | prefix = `0`,
|  | bool | subgraph = `false`,
|  | bool | labels = `false`
| ) |  | const

Returns a Graphviz DOT representation of the graph that describes this facet pairing.

This routine simply returns the output of writeDot() as a string, instead of dumping it to an output stream.

All arguments are the same as for writeDot(); see the writeDot() notes for further details.

Returns
  the output of writeDot(), as outlined above.

## dotHeader()

template<int dim>

static std::string regina::detail::FacetPairingBase< dim >::dotHeader | ( | const char * | graphName = `0` | ) |

static

Returns header information for a Graphviz DOT file that will describe the graphs for one or more facet pairings.

This routine simply returns the output of writeDotHeader() as a string, instead of dumping it to an output stream.

All arguments are the same as for writeDotHeader(); see the writeDotHeader() notes for further details.

Returns
  the output of writeDotHeader(), as outlined above.

## doubleCone()

template<int dim, bool available>

Triangulation< dim > * regina::detail::ExampleFromLowDim< dim, available >::doubleCone | ( | const Triangulation< dim-1 > & | base | ) |

static

Returns a double cone over the given (dim-1)-dimensional triangulation.

If the given triangulation represents the manifold `M`, then this returns an ideal triangulation of the product `M x I` (with two ideal boundary components). A copy of the original triangulation base can be found at the centre of this construction, formed from the dim-simplices that sit between the two ideal vertices.

Note that, as a special case, if `M` is either a sphere or a ball, then this routine returns a (dim)-sphere or a (dim)-ball (since "ideal spheres" and "ideal balls" just become regular internal and boundary vertices respectively).

This construction is essentially the suspension of the triangulation base. We do not call it this however, since from a topological point of view, to form the ideal triangulation of `M x I` we "remove" the vertices at the apex of each cone.

Warning
  If the given (dim-1)-dimensional triangulation has any boundary whatsoever (either real or ideal), then unless it is a (dim-1)-ball, you will obtain an invalid dim-manifold triangulation as a result.

Returns
  a newly constructed triangulation, which must be destroyed by the caller of this routine.

## dumpConstruction()

template<int dim>

std::string regina::detail::TriangulationBase< dim >::dumpConstruction | ( |  | ) | const

Returns C++ code that can be used with insertConstruction() to reconstruct this triangulation.

The code produced will consist of the following:

- the declaration and initialisation of two integer arrays, describing the gluings between simplices of this trianguation;
- two additional lines that declare a new Triangulation<dim> and call insertConstruction() to rebuild this triangulation.

The main purpose of this routine is to generate the two integer arrays, which can be tedious and error-prone to code up by hand.

Note that the number of lines of code produced grows linearly with the number of simplices. If this triangulation is very large, the returned string will be very large as well.

Returns
  the C++ code that was generated.

## embedding()

template<int dim, int codim>

const FaceEmbedding< dim, dim - codim > & regina::detail::FaceStorage< dim, codim >::embedding | ( | size_t | index | ) | const

inline

Returns one of the ways in which this face appears within a top-dimensional simplex of the underlying triangluation.

For convenience, you can also use begin() and end() to iterate through all such appearances.

In most cases, the ordering of appearances is arbitrary. The exception is for codimension 2, where these appearances are ordered in a way that follows the link around the face (which in codimension 2 is always a path or a cycle).

Parameters

  index | the index of the requested appearance. This must be between 0 and degree()-1 inclusive.

Returns
  details of the requested appearance.

## end()

template<int dim, int codim>

std::vector< FaceEmbedding< dim, dim - codim > >::const_iterator regina::detail::FaceStorage< dim, codim >::end | ( |  | ) | const

inline

An end function for iterating through all appearances of this face within the various top-dimensional simplices of the underlying triangulation.

In most cases, the ordering of appearances is arbitrary. The exception is for codimension 2, where these appearances are ordered in a way that follows the link around the face (which in codimension 2 is always a path or a cycle).

An iteration from begin() to end() will run through degree() appearances in total.

Python:\n Not present. However, Python users can call
  the Python-only routine embeddings(), which will return all appearances (from begin() through to end()) in a Python sequence.

Returns
  a "beyond the end" iterator that comes immediately after the last appearance.

## endContentSubElement()

template<int dim>

void regina::detail::XMLTriangulationReaderBase< dim >::endContentSubElement | ( | const std::string & | subTagName,
|  | XMLElementReader * | subReader
| ) |  |

inline override virtual

Used instead of endSubElement() for XML subelements that are not child packets or packet tags.

The default implementation does nothing.

Parameters

  subTagName | the name of the subelement closing tag.
  subReader | the child reader that was used to parse the subelement (this is the reader that was returned by the corresponding startContentSubElement() call). It is guaranteed that endElement() has already been called upon this child reader and that the child reader has not yet been destroyed.

Reimplemented from regina::XMLPacketReader.

## endSubElement() [1/2]

template<int dim>

void regina::detail::XMLTriangulationReaderBase< dim >::AbelianGroupPropertyReader::endSubElement | ( | const std::string & | subTagName,
|  | XMLElementReader * | subReader
| ) |  |

inline virtual

Signifies that parsing has finished for a subelement of this XML element.

The default implementation does nothing.

Parameters

  subTagName | the name of the subelement closing tag.
  subReader | the child reader that was used to parse the subelement (this is the reader that was returned by the corresponding startSubElement() call). It is guaranteed that endElement() has already been called upon this child reader and that the child reader has not yet been destroyed.

Reimplemented from regina::XMLElementReader.

## endSubElement() [2/2]

template<int dim>

void regina::detail::XMLTriangulationReaderBase< dim >::GroupPresentationPropertyReader::endSubElement | ( | const std::string & | subTagName,
|  | XMLElementReader * | subReader
| ) |  |

inline virtual

Signifies that parsing has finished for a subelement of this XML element.

The default implementation does nothing.

Parameters

  subTagName | the name of the subelement closing tag.
  subReader | the child reader that was used to parse the subelement (this is the reader that was returned by the corresponding startSubElement() call). It is guaranteed that endElement() has already been called upon this child reader and that the child reader has not yet been destroyed.

Reimplemented from regina::XMLElementReader.

## ensureSkeleton()

template<int dim>

void regina::detail::TriangulationBase< dim >::ensureSkeleton | ( |  | ) | const

inline protected

Ensures that all "on demand" skeletal objects have been calculated.

## eulerCharTri()

template<int dim>

long regina::detail::TriangulationBase< dim >::eulerCharTri | ( |  | ) | const

inline

Returns the Euler characteristic of this triangulation.

This will be evaluated strictly as the alternating sum of the number of i-faces (that is, `countVertices() - countEdges() + countTriangles() - ...`).

Note that this routine handles ideal triangulations in a non-standard way. Since it computes the Euler characteristic of the triangulation (and not the underlying manifold), this routine will treat each ideal boundary component as a single vertex, and not as an entire (dim-1)-dimensional boundary component.

In Regina's standard dimensions, for a routine that handles ideal boundary components properly (by treating them as (dim-1)-dimensional boundary components when computing Euler characteristic), you can use the routine eulerCharManifold() instead.

Returns
  the Euler characteristic of this triangulation.

## ExampleBase()

template<int dim>

regina::detail::ExampleBase< dim >::ExampleBase | ( |  | ) |

delete

Closed Triangulations.

Explicitly disable the default constructor.

## face() [1/5]

template<int dim, int subdim>

int regina::detail::FaceEmbeddingBase< dim, subdim >::face | ( |  | ) | const

inline

Returns the corresponding face number of simplex().

This identifies which face of the top-dimensional simplex simplex() refers to the underlying subdim-face of the triangulation.

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

## face() [2/5]

template<int dim>
template<int subdim>

Face< dim, subdim > * regina::detail::SimplexBase< dim >::face | ( | int | face | ) | const

inline

Returns the subdim-face of the underlying triangulation that appears as the given subdim-face of this simplex.

See FaceNumbering<dim, subdim> for the conventions of how subdim-faces are numbered within a dim-simplex.

Python:\n Python does not support templates. Instead,
  Python users should call this function in the form `face(subdim, face)`; that is, the template parameter subdim becomes the first argument of the function.

Parameters

  face | the subdim-face of this simplex to examine. This should be between 0 and (dim+1 choose subdim+1)-1 inclusive.

Returns
  the corresponding subdim-face of the triangulation.

## face() [3/5]

template<int dim, int subdim>
template<int lowerdim>

Face< dim, lowerdim > * regina::detail::FaceBase< dim, subdim >::face | ( | int | face | ) | const

inline

Returns the lowerdim-face of the underlying triangulation that appears as the given lowerdim-dimensional subface of this face.

The argument face must represent a lowerdim-face number within a subdim-simplex. This lowerdim-face number will be interpreted with respect to the inherent labelling (0, ..., subdim) of the vertices of this subdim-face. See FaceEmbedding<dim, subdim>::vertices() for details on how these map to the vertex numbers of the dim-dimensional simplices that contain this face in the overall triangulation.

See FaceNumbering<subdim, lowerdim> for the conventions of how lowerdim-faces are numbered within a subdim-simplex.

Python:\n Python does not support templates. Instead,
  Python users should call this function in the form `face(lowerdim, face)`; that is, the template parameter lowerdim becomes the first argument of the function.

Parameters

  face | the lowerdim-face of this subdim-face to examine. This should be between 0 and (subdim+1 choose lowerdim+1)-1 inclusive.

Returns
  the corresponding lowerdim-face of the triangulation.

## face() [4/5]

template<int dim, bool allFaces_>
template<int subdim>

Face<dim, subdim>* regina::detail::BoundaryComponentFaceStorage< dim, allFaces_ >::face | ( | size_t | index | ) | const

inline

Returns the requested subdim-face in this boundary component.

Note that the index of a face in the boundary component need not be the index of the same face in the overall triangulation. However, if this is a real boundary component (i.e., it is built from one or more (dim-1)-faces), then the index of each subdim-face in this boundary component will match the index of the corresponding subdim-face in the (dim-1)-manifold triangulation returned by build().

This routine is only available where dim is one of Regina's standard dimensions.

Python:\n Python does not support templates. Instead,
  Python users should call this function in the form `face(subdim, index)`; that is, the template parameter subdim becomes the first argument of the function.

Template Parameters

  subdim | the dimension of the face to query. This must be between 0 and dim-1 inclusive.

Parameters

  index | the index of the desired face, ranging from 0 to countFaces<subdim>()-1 inclusive.

Returns
  the requested face.

## face() [5/5]

template<int dim>
template<int subdim>

Face< dim, subdim > * regina::detail::TriangulationBase< dim >::face | ( | size_t | index | ) | const

inline

Returns the requested subdim-face of this triangulation.

Precondition
  The template argument subdim is between 0 and dim-1 inclusive.

Python:\n Python does not support templates. Instead,
  Python users should call this function in the form `face(subdim, index)`; that is, the template parameter subdim becomes the first argument of the function.

Parameters

  index | the index of the desired face, ranging from 0 to countFaces<subdim>()-1 inclusive.

Returns
  the requested face.

## FaceBase()

template<int dim, int subdim>

regina::detail::FaceBase< dim, subdim >::FaceBase | ( | Component< dim > * | component | ) |

inline protected

Creates a new face.

The face will be initialised as belong to no boundary component.

Parameters

  component | the component of the underlying triangulation to which the new face belongs.

## FaceEmbeddingBase() [1/3]

template<int dim, int subdim>

regina::detail::FaceEmbeddingBase< dim, subdim >::FaceEmbeddingBase | ( |  | ) |

inline

Default constructor.

This object is unusable until it has some data assigned to it using `operator =`.

Python:\n Not present.

## FaceEmbeddingBase() [2/3]

template<int dim, int subdim>

regina::detail::FaceEmbeddingBase< dim, subdim >::FaceEmbeddingBase | ( | const FaceEmbeddingBase< dim, subdim > & | cloneMe | ) |

inline

Creates a new copy of the given object.

Parameters

  cloneMe | the object to copy.

## FaceEmbeddingBase() [3/3]

template<int dim, int subdim>

regina::detail::FaceEmbeddingBase< dim, subdim >::FaceEmbeddingBase | ( | Simplex< dim > * | simplex,
|  | int | face
| ) |  |

inline

Creates a new object containing the given data.

Parameters

  simplex | the top-dimensional simplex in which the underlying subdim-face of the triangulation is contained.
  face | the corresponding face number of simplex. This must be between 0 and (dim+1 choose subdim+1)-1 inclusive.

## faceMapping() [1/2]

template<int dim>
template<int subdim>

Perm< dim+1 > regina::detail::SimplexBase< dim >::faceMapping | ( | int | face | ) | const

inline

Examines the given subdim-face of this simplex, and returns the mapping between the underlying subdim-face of the triangulation and the individual vertices of this simplex.

Specifically:

- Suppose several subdim-faces of several top-dimensional simplices are identified within the overall triangulation. Then we call this a single "<i>subdim</i>-face of the triangulation", and arbitrarily label its vertices (0, ..., subdim).
- Now let F denote the subdim-face of the triangulation that corresponds to subdim-face number face of this simplex. Then this routine returns a map from vertices (0, ..., subdim) of F to the corresponding vertex numbers of this simplex.
- In particular, if this routine returns the permutation p, then the images p[0,...,subdim] will be some permutation of the vertices Face<dim, subdim>::ordering[0,...,subdim].
- If F also appears as face number k in some other simplex s, then for each i in the range 0 ≤ i ≤ subdim, vertex `p[i]` of this simplex will be identified with vertex s.faceMapping(k)[i] of simplex s.

If the link of the underlying subdim-face is orientable, then this permutation maps the remaining numbers (subdim+1, ..., dim) to the remaining vertex numbers of this simplex in a manner that preserves orientation as you walk through the many different simplices that contain the same underlying subdim-face. Specifically:

- The images of (subdim+1, ..., dim) under this permutation imply an orientation for the (dim - subdim - 1)-face opposite F in this simplex. These orientations will be consistent for all simplices containing F.
- For faces of codimension two (e.g., edges in a 3-manifold triangulation), this orientation condition is even stronger. Here the link of the face F must be a path (for a boundary face) or a cycle (for an internal face). In each simplex we can form a directed edge from the image of dim-1 to the image of dim under this permutation, and together these directed edges form a directed path or cycle that follows the link of the face F. Moreover, an iteration through the corresponding FaceEmbedding<dim, subdim> objects in order from `F.begin()` to `F.end()`, will follow this directed path in order from start to end. (In the case where the link of F is a cycle, the start point in the list of FaceEmbedding objects will be arbitrary.)

Note that, even if the link is orientable, there are still arbitrary decisions to be made for the images of (subdim+1, ..., dim), since there will always be (dim-subdim)!/2 possible mappings that yield the correct orientation.

Note
  This routine returns the same permutation as FaceEmbedding<dim, subdim>::vertices(), in the context of the FaceEmbedding<dim, subdim> object that refers to subdim-face number face of this simplex.

Python:\n Python does not support templates. Instead,
  Python users should call this function in the form `faceMapping(subdim, face)`; that is, the template parameter subdim becomes the first argument of the function.

Parameters

  face | the subdim-face of this simplex to examine. This should be between 0 and (dim+1 choose subdim+1)-1 inclusive.

Returns
  a mapping from the vertices of the underlying subdim-face of the triangulation to the vertices of this simplex.

## faceMapping() [2/2]

template<int dim, int subdim>
template<int lowerdim>

Perm< dim+1 > regina::detail::FaceBase< dim, subdim >::faceMapping | ( | int | face | ) | const

Examines the given lowerdim-dimensional subface of this face, and returns the mapping between the underlying lowerdim-face of the triangulation and the individual vertices of this face.

The argument face must represent a lowerdim-face number within a subdim-simplex. This lowerdim-face number will be interpreted with respect to the inherent labelling (0, ..., subdim) of the vertices of this subdim-face. See FaceEmbedding<dim, subdim>::vertices() for details on how these map to the vertex numbers of the dim-dimensional simplices that contain this face in the overall triangulation.

Let F denote this subdim-face of the triangulation, and let L denote the lowerdim-face of the triangulation that corresponds to the given subface of F. Then the permutation returned by this routine maps the vertex numbers (0, ..., lowerdim) of L to the corresponding vertex numbers of F. This is with respect to the inherent labellings (0, ..., lowerdim) and (0, ..., subdim) of the vertices of L and F respectively.

In particular, if this routine returns the permutation p, then the images p[0,...,lowerdim] will be some permutation of the vertices Face<subdim, lowerdim>::ordering(face)[0,...,lowerdim].

This routine differs from Simplex<dim>::faceMapping<lowerdim>() in how it handles the images of (lowerdim+1, ..., dim):

- This routine will map (lowerdim+1, ..., subdim) to the remaining vertices of this face in an arbitrary order, and will map (subdim+1, ..., dim) to (subdim+1, ..., dim) again in an arbitrary order.
- In contrast, Simplex<dim>::faceMapping<lowerdim>() chooses the images of (lowerdim+1, ..., dim) to satisfy an additional orientability constraint.

See FaceNumbering<subdim, lowerdim> for the conventions of how lowerdim-faces are numbered within a subdim-simplex.

Python:\n Python does not support templates. Instead,
  Python users should call this function in the form `faceMapping(lowerdim, face)`; that is, the template parameter lowerdim becomes the first argument of the function.

Parameters

  face | the lowerdim-face of this subdim-face to examine. This should be between 0 and (subdim+1 choose lowerdim+1)-1 inclusive.

Returns
  a mapping from the vertices of the underlying lowerdim-face of the triangulation to the vertices of this subdim-face.

## faceNumber()

template<int dim, int subdim>

static unsigned regina::detail::FaceNumberingAPI< dim, subdim >::faceNumber | ( | Perm< 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

  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.

## FaceOrientability()

template<bool allowsNonorientable>

regina::detail::FaceOrientability< allowsNonorientable >::FaceOrientability | ( |  | ) |

protected

Initialises the link of this face as orientable.

## faces() [1/2]

template<int dim, bool allFaces_>
template<int subdim>

const std::vector<Face<dim, subdim>*>& regina::detail::BoundaryComponentFaceStorage< dim, allFaces_ >::faces | ( |  | ) | const

inline

Returns all subdim-faces in this boundary component.

The reference that is returned will remain valid only for as long as this boundary component object exists. In particular, the reference will become invalid any time that the triangulation changes (since all boundary component objects will be destroyed and others rebuilt in their place).

Python:\n Python users should call this function in the
  form `faces(subdim)`. It will then return a Python list containing all the subdim-faces of the boundary component. Be warned that, unlike in C++, this Python list will be a snapshot of the faces when this function is called, and will not be kept up-to-date as the triangulation changes.

Template Parameters

  subdim | the dimension of the faces to query. This must be between 0 and dim-1 inclusive.

Returns
  access to the list of all subdim-faces.

## faces() [2/2]

template<int dim>
template<int subdim>

const FaceList< dim, subdim > & regina::detail::TriangulationBase< dim >::faces | ( |  | ) | const

inline

Returns an object that allows iteration through and random access to all subdim-faces of this triangulation.

Bear in mind that each time the triangulation changes, all face objects will be deleted and replaced with new ones. Therefore these face objects should be considered temporary only.

In contrast, this reference to the FaceList object itself will remain valid and up-to-date for as long as the triangulation exists.

Python:\n Python users should call this function in the
  form `faces(subdim)`. It will then return a Python list containing all the subdim-faces of the triangulation. Be warned that, unlike in C++, this Python list will be a snapshot of the faces when this function is called, and will not be kept up-to-date as the triangulation changes.

Returns
  access to the list of all subdim-faces.

## facet() [1/2]

template<int dim, bool allFaces_>

Face<dim, dim-1>* regina::detail::BoundaryComponentFaceStorage< dim, allFaces_ >::facet | ( | size_t | index | ) | const

inline

Returns the requested (dim-1)-face in this boundary component.

These are the top-dimensional faces for a real boundary component.

Note that the index of a face in the boundary component need not be the index of the same face in the overall triangulation. However, if this is a real boundary component (i.e., it is built from one or more (dim-1)-faces), then the index of each (dim-1)-face in this boundary component will match the index of the corresponding top-dimensional simplex in the (dim-1)-manifold triangulation returned by build().

Parameters

  index | the index of the desired face, ranging from 0 to size()-1 inclusive.

Returns
  the requested face.

## facet() [2/2]

template<int dim>

Face<dim, dim-1>* regina::detail::BoundaryComponentFaceStorage< dim, false >::facet | ( | size_t | index | ) | const

inline

Returns the requested (dim-1)-face in this boundary component.

These are the top-dimensional faces for a real boundary component.

Note that the index of a face in the boundary component need not be the index of the same face in the overall triangulation. However, the index of each (dim-1)-face in this boundary component will match the index of the corresponding top-dimensional simplex in the (dim-1)-manifold triangulation returned by build().

Parameters

  index | the index of the desired face, ranging from 0 to size()-1 inclusive.

Returns
  the requested face.

## facetInMaximalForest()

template<int dim>

bool regina::detail::SimplexBase< dim >::facetInMaximalForest | ( | int | facet | ) | const

inline

Determines whether the given facet of this simplex belongs to the maximal forest that has been chosen for the dual 1-skeleton of the underlying triangulation.

When the skeletal structure of a triangulation is first computed, a maximal forest in the dual 1-skeleton of the triangulation is also constructed. Each dual edge in this maximal forest represents a (dim-1)-face of the (primal) triangulation.

This maximal forest will remain fixed until the triangulation changes, at which point it will be recomputed (as will all other skeletal objects, such as connected components and so on). There is no guarantee that, when it is recomputed, the maximal forest will use the same dual edges as before.

This routine identifies which (dim-1)-faces of the triangulation belong to the dual forest. Because it lives in the Simplex class, this routine can even be used for those dimensions that do not have explicit classes for (dim-1)-faces of the triangulation.

If the skeleton has already been computed, then this routine is very fast (since it just returns a precomputed answer).

Parameters

  facet | the facet of this simplex that we are examining. This must be between 0 and dim inclusive.

Returns
  `true` if and only if the given facet of this simplex corresponds to a dual edge in the maximal forest chosen for the dual 1-skeleton.

## FacetPairingBase() [1/3]

template<int dim>

regina::detail::FacetPairingBase< dim >::FacetPairingBase | ( | const FacetPairingBase< dim > & | cloneMe | ) |

Creates a new facet pairing that is a clone of the given facet pairing.

Parameters

  cloneMe | the facet pairing to clone.

## FacetPairingBase() [2/3]

template<int dim>

regina::detail::FacetPairingBase< dim >::FacetPairingBase | ( | const Triangulation< dim > & | tri | ) |

Creates the facet pairing of given triangulation.

This is the facet pairing that describes how the facets of simplices in the given triangulation are joined together, as described in the class notes.

Precondition
  The given triangulation is not empty.

Parameters

  tri | the triangulation whose facet pairing should be constructed.

## FacetPairingBase() [3/3]

template<int dim>

regina::detail::FacetPairingBase< dim >::FacetPairingBase | ( | size_t | size | ) |

inline protected

Creates a new facet pairing.

All internal arrays will be allocated but not initialised.

Precondition
  size is at least 1.

Parameters

  size | the number of simplices under consideration in this new facet pairing.

## facetPerm() [1/2]

template<int dim>

Perm< dim+1 > & regina::detail::IsomorphismBase< dim >::facetPerm | ( | unsigned | sourceSimp | ) |

inline

Returns a read-write reference to the permutation that is applied to the (dim + 1) facets of the given source simplex under this isomorphism.

Facet i of source simplex sourceSimp will be mapped to facet `facetPerm(sourceSimp)[i]` of simplex `simpImage(sourceSimp)`.

Python:\n This is not available for Python users.
  However, the read-only version of this routine is.

Parameters

  sourceSimp | the index of the source simplex containing the original (dim + 1) facets; this must be between 0 and `size()-1` inclusive.

Returns
  a read-write reference to the permutation applied to the facets of the source simplex.

## facetPerm() [2/2]

template<int dim>

Perm< dim+1 > regina::detail::IsomorphismBase< dim >::facetPerm | ( | unsigned | sourceSimp | ) | const

inline

Determines the permutation that is applied to the (dim + 1) facets of the given source simplex under this isomorphism.

Facet i of source simplex sourceSimp will be mapped to face `facetPerm(sourceSimp)[i]` of simplex `simpImage(sourceSimp)`.

Parameters

  sourceSimp | the index of the source simplex containing the original (dim + 1) facets; this must be between 0 and `size()-1` inclusive.

Returns
  the permutation applied to the facets of the source simplex.

## facets() [1/2]

template<int dim, bool allFaces_>

const std::vector<Face<dim, dim-1>*>& regina::detail::BoundaryComponentFaceStorage< dim, allFaces_ >::facets | ( |  | ) | const

inline

Returns all (dim-1)-faces in this boundary component.

The reference that is returned will remain valid only for as long as this boundary component object exists. In particular, the reference will become invalid any time that the triangulation changes (since all boundary component objects will be destroyed and others rebuilt in their place).

Python:\n This routine returns a python list.

Returns
  the list of all (dim-1)-faces.

## facets() [2/2]

template<int dim>

const std::vector<Face<dim, dim-1>*>& regina::detail::BoundaryComponentFaceStorage< dim, false >::facets | ( |  | ) | const

inline

Returns all (dim-1)-faces in this boundary component.

The reference that is returned will remain valid only for as long as this boundary component object exists. In particular, the reference will become invalid any time that the triangulation changes (since all boundary component objects will be destroyed and others rebuilt in their place).

Python:\n This routine returns a python list.

Returns
  the list of all (dim-1)-faces.

## FaceValidity() [1/2]

template<bool allowsInvalid, bool testLinks>

regina::detail::FaceValidity< allowsInvalid, testLinks >::FaceValidity | ( |  | ) |

protected

Initialises this face as valid.

## FaceValidity() [2/2]

regina::detail::FaceValidity< true, false >::FaceValidity | ( |  | ) |

inline protected

Initialises this face as valid.

## fillFVector()

template<int dim>

void regina::detail::FaceListSuite< dim >::fillFVector | ( | std::vector< size_t > & | result | ) | const

inline protected

Fills the given vector with the first (subdim + 1) elements of the f-vector.

Specifically, this routine pushes the values f[0], ..., f[subdim] onto the end of the given vector, where f[k] denotes the number of k-faces that this object stores.

Parameters

  result | the vector in which the results will be placed.

## findAllIsomorphisms()

template<int dim>
template<typename OutputIterator >

size_t regina::detail::TriangulationBase< dim >::findAllIsomorphisms | ( | const Triangulation< dim > & | other,
|  | OutputIterator | output
| ) |  | const

inline

Finds all ways in which this triangulation is combinatorially isomorphic to the given triangulation.

This routine behaves identically to isIsomorphicTo(), except that instead of returning just one isomorphism, all such isomorphisms are returned.

See the isIsomorphicTo() notes for additional information.

The isomorphisms that are found will be written to the given output iterator. This iterator must accept objects of type Isomorphism<dim>*. As an example, output might be a back_insert_iterator for a std::vector<Isomorphism<dim>*>.

The isomorphisms that are written to the given output iterator will be newly created, and the caller of this routine is responsible for destroying them.

Python:\n The output argument is not present.
  Instead, this routine returns a python list containing all of the isomorphisms that were found.

Warning
  For large dimensions, this routine can become extremely slow: its running time includes a factor of (dim+1)!.

Parameters

  other | the triangulation to compare with this one.
  output | the output iterator to which the isomorphisms will be written.

Returns
  the number of isomorphisms that were found.

## findAllPairings()

template<int dim>

void regina::detail::FacetPairingBase< dim >::findAllPairings | ( | size_t | nSimplices,
|  | BoolSet | boundary,
|  | int | nBdryFacets,
|  | Use | use,
|  | void * | useArgs = `0`
| ) |  |

inline static

Generates all possible facet pairings satisfying the given constraints.

Only connected facet pairings (pairings in which each simplex can be reached from each other via a series of individual matched facets) will be produced.

Each facet pairing will be produced precisely once up to isomorphism. Facet pairings are considered isomorphic if they are related by a relabelling of the simplices and/or a renumbering of the (dim + 1) facets of each simplex. Each facet pairing that is generated will be a lexicographically minimal representative of its isomorphism class, i.e., will be in canonical form as described by isCanonical().

For each facet pairing that is generated, routine use (as passed to this function) will be called with that pairing and its automorphisms as arguments.

Once the generation of facet pairings has finished, routine use will be called once more, this time with `null` as its first two arguments (for the facet pairing and its automorphisms).

Because this class cannot represent an empty facet pairing, if the argument nSimplices is zero then no facet pairings will be generated at all.

Todo:

  Optimise (long-term): When generating facet pairings, do some checking to eliminate cases in which simplex (k > 0) can be swapped with simplex 0 to produce a smaller representation of the same pairing.

  Feature: Allow cancellation of facet pairing generation.

Python:\n Not present, even in the dimension-specific
  subclasses.

Parameters

  nSimplices | the number of simplices whose facets should be (potentially) matched.
  boundary | determines whether any facets may be left unmatched. This set should contain `true` if pairings with at least one unmatched facet are to be generated, and should contain `false` if pairings with no unmatched facets are to be generated.

  nBdryFacets

  specifies the precise number of facets that should be left unmatched. If this parameter is negative, it is ignored and no additional restriction is imposed. If parameter boundary does not contain `true`, this parameter is likewise ignored. If parameter boundary does contain true and this parameter is non-negative, only pairings with precisely this many unmatched facets will be generated. In particular, if this parameter is positive then pairings with no unmatched facets will not be produced irrespective of whether `false` is contained in parameter boundary. Note that, in order to produce any pairings at all, this parameter must be of the same parity as `nSimplices * (dim+1)`, and can be at most `(dim-1) * nSimplices + 2`.

  use | the function to call upon each facet pairing that is found. The first parameter passed to this function will be a facet pairing. The second parameter will be a list of all its automorphisms (relabellings of simplices and individual simplex facets that produce the exact same pairing). The third parameter will be parameter useArgs as was passed to this routine.
  useArgs | the pointer to pass as the final parameter for the function use which will be called upon each pairing found.

## findAllSubcomplexesIn()

template<int dim>
template<typename OutputIterator >

size_t regina::detail::TriangulationBase< dim >::findAllSubcomplexesIn | ( | const Triangulation< dim > & | other,
|  | OutputIterator | output
| ) |  | const

inline

Finds all ways in which an isomorphic copy of this triangulation is contained within the given triangulation, possibly as a subcomplex of some larger component (or components).

This routine behaves identically to isContainedIn(), except that instead of returning just one isomorphism (which may be boundary incomplete and need not be onto), all such isomorphisms are returned.

See the isContainedIn() notes for additional information.

The isomorphisms that are found will be written to the given output iterator. This iterator must accept objects of type Isomorphism<dim>*. As an example, output might be a back_insert_iterator for a std::vector<Isomorphism<dim>*>.

The isomorphisms that are written to the given output iterator will be newly created, and the caller of this routine is responsible for destroying them.

Warning
  For large dimensions, this routine can become extremely slow: its running time includes a factor of (dim+1)!.

Python:\n Not present.

Parameters

  other | the triangulation in which to search for isomorphic copies of this triangulation.
  output | the output iterator to which the isomorphisms will be written.

Returns
  the number of isomorphisms that were found.

## findAutomorphisms()

template<int dim>

void regina::detail::FacetPairingBase< dim >::findAutomorphisms | ( | IsoList & | list | ) | const

inline

Fills the given list with the set of all combinatorial automorphisms of this facet pairing.

An automorphism is a relabelling of the simplices and/or a renumbering of the (dim + 1) facets of each simplex resulting in precisely the same facet pairing.

This routine uses optimisations that can cause unpredictable breakages if this facet pairing is not in canonical form.

The automorphisms placed in the given list will be newly created; it is the responsibility of the caller of this routine to deallocate them.

Precondition
  The given list is empty.
  This facet pairing is connected, i.e., it is possible to reach any simplex from any other simplex via a series of matched facet pairs.
  This facet pairing is in canonical form as described by isCanonical().

Python:\n Not present, even in the dimension-specific
  subclasses.

Parameters

  list | the list into which the newly created automorphisms will be placed.

## finiteToIdeal()

template<int dim>

bool regina::detail::TriangulationBase< dim >::finiteToIdeal | ( |  | ) |

Converts each real boundary component into a cusp (i.e., an ideal vertex).

Only boundary components formed from real (dim-1)-faces will be affected; ideal boundary components are already cusps and so will not be changed.

One side-effect of this operation is that all spherical boundary components will be filled in with balls.

This operation is performed by attaching a new dim-simplex to each boundary (dim-1)-face, and then gluing these new simplices together in a way that mirrors the adjacencies of the underlying boundary facets. Each boundary component will thereby be pushed up through the new simplices and converted into a cusp formed using vertices of these new simplices.

In Regina's standard dimensions, where triangulations also support an idealToFinite() operation, this routine is a loose converse of that operation.

In dimension 2, every boundary component is spherical and so this routine simply fills all the punctures in the underlying surface. (In dimension 2, triangulations cannot have cusps).

Warning
  If a real boundary component contains vertices whose links are not discs, this operation may have unexpected results.

Returns
  `true` if changes were made, or `false` if the original triangulation contained no real boundary components.

## fromIsoSig()

template<int dim>

static Triangulation<dim>* regina::detail::TriangulationBase< dim >::fromIsoSig | ( | const std::string & | sig | ) |

static

Recovers a full triangulation from an isomorphism signature.

See isoSig() for more information on isomorphism signatures. It will be assumed that the signature describes a triangulation of dimension dim.

The triangulation that is returned will be newly created, and it is the responsibility of the caller of this routine to destroy it.

Calling isoSig() followed by fromIsoSig() is not guaranteed to produce an identical triangulation to the original, but it is guaranteed to produce a combinatorially isomorphic triangulation. In other words, fromIsoSig() may reconstruct the triangulation with its simplices and/or vertices relabelled. The optional argument to isoSig() allows you to determine the precise relabelling that will be used, if you need to know it.

For a full and precise description of the isomorphism signature format for 3-manifold triangulations, see Simplification paths in the Pachner graphs of closed orientable 3-manifold triangulations, Burton, 2011, `arXiv:1110.6080`. The format for other dimensions is essentially the same, but with minor dimension-specific adjustments.

Warning
  Do not mix isomorphism signatures between dimensions! It is possible that the same string could corresponding to both a p-dimensional triangulation and a q-dimensional triangulation for different dimensions p and q.

Parameters

  sig | the isomorphism signature of the triangulation to construct. Note that isomorphism signature are case-sensitive (unlike, for example, dehydration strings for 3-manifolds).

Returns
  a newly allocated triangulation if the reconstruction was successful, or `null` if the given string was not a valid dim-dimensional isomorphism signature.

## fromTextRep()

template<int dim>

static FacetPairing<dim>* regina::detail::FacetPairingBase< dim >::fromTextRep | ( | const std::string & | rep | ) |

static

Reconstructs a facet pairing from a text-based representation.

This text-based representation must be in the format produced by routine toTextRep().

The facet pairing returned will be newly constructed; it is the responsibility of the caller of this routine to deallocate it.

Precondition
  The facet pairing to be reconstructed involves at least one simplex.

Parameters

  rep | a text-based representation of a facet pairing, as produced by routine toTextRep().

Returns
  the corresponding newly constructed facet pairing, or `null` if the given text-based representation was invalid.

## front()

template<int dim, int codim>

const FaceEmbedding< dim, dim - codim > & regina::detail::FaceStorage< dim, codim >::front | ( |  | ) | const

inline

Returns the first appearance of this face within a top-dimensional simplex of the underlying triangluation.

This is equivalent to calling `*begin()`, or `embedding(0)`.

In most cases, the ordering of appearances is arbitrary. The exception is for codimension 2, where the appearances of a face are ordered in a way that follows the link around the face (which in codimension 2 is always a path or a cycle). In particular, for a boundary face of codimension 2, both front() and back() will refer to the two appearances of this face on the (dim-1)-dimensional boundary.

Returns
  details of the first appearance.

## fundamentalGroup()

template<int dim>

const GroupPresentation & regina::detail::TriangulationBase< dim >::fundamentalGroup | ( |  | ) | const

Returns the fundamental group of this triangulation.

The fundamental group is computed in the dual 2-skeleton. This means:

- If the triangulation contains any ideal vertices, the fundamental group will be calculated as if each such vertex had been truncated.
- Likewise, if the triangulation contains any invalid faces of dimension 0,1,...,(dim-3), these will effectively be truncated also.
- In contrast, if the triangulation contains any invalid (dim-2)-faces (i.e., codimension-2-faces that are identified with themselves under a non-trivial map), the fundamental group will be computed without truncating the centroid of the face. For instance, if a 3-manifold triangulation has an edge identified with itself in reverse, then the fundamental group will be computed without truncating the resulting projective plane cusp. This means that, if a barycentric subdivision is performed on a such a triangulation, the result of fundamentalGroup() might change.

Bear in mind that each time the triangulation changes, the fundamental group will be deleted. Thus the reference that is returned from this routine should not be kept for later use. Instead, fundamentalGroup() should be called again; this will be instantaneous if the group has already been calculated.

Precondition
  This triangulation has at most one component.

Warning
  In dimension 3, if you are calling this from the subclass SnapPeaTriangulation then any fillings on the cusps will be ignored. (This is the same as for every routine implemented by Regina's Triangulation<3> class.) If you wish to compute the fundamental group with fillings, call SnapPeaTriangulation::fundamentalGroupFilled() instead.

Returns
  the fundamental group.

## fVector()

template<int dim>

std::vector< size_t > regina::detail::TriangulationBase< dim >::fVector | ( |  | ) | const

inline

Returns the f-vector of this triangulation, which counts the number of faces of all dimensions.

The vector that is returned will have length dim+1. If this vector is f, then f[k] will be the number of k-faces for each 0 ≤ k ≤ dim.

This routine is significantly more heavyweight than countFaces(). Its advantage is that, unlike the templatised countFaces(), it allows you to count faces whose dimensions are not known until runtime.

Returns
  the f-vector of this triangulation.

## GroupPresentationPropertyReader()

template<int dim>

regina::detail::XMLTriangulationReaderBase< dim >::GroupPresentationPropertyReader::GroupPresentationPropertyReader | ( | PropType & | prop | ) |

inline

Creates a new reader that stores its results in the given triangulation property.

Parameters

  prop | a reference to the triangulation property in which the data that is read should be stored.

## hasBadIdentification() [1/2]

template<bool allowsInvalid, bool testLinks>

bool regina::detail::FaceValidity< allowsInvalid, testLinks >::hasBadIdentification | ( |  | ) | const

Determines if this face is identified with itself under a non-identity permutation.

For example, if this face is an edge then this routine tests whether the edge is identified with itself in reverse.

Such a face will always be marked as invalid. Note that, for standard dimensions dim, there are other types of invalid faces also. See isValid() for a full discussion of what it means for a face to be valid.

Returns
  `true` if and only if this face is identified with itself under a non-identity permutation.

## hasBadIdentification() [2/2]

bool regina::detail::FaceValidity< true, false >::hasBadIdentification | ( |  | ) | const

inline

Determines if this face is identified with itself under a non-identity permutation.

For example, if this face is an edge then this routine tests whether the edge is identified with itself in reverse.

For this class, hasBadIdentification() returns `true` if and only if isValid() returns `false`. This is in contrast to standard dimensions, where there are other types of invalid faces also. See FaceValidity<true, true>::isValid() for a full discussion of what it means for a face to be valid, and how this differs between standard and non-standard dimensions.

Returns
  `true` if and only if this face is identified with itself under a non-identity permutation.

## hasBadLink()

template<bool allowsInvalid, bool testLinks>

bool regina::detail::FaceValidity< allowsInvalid, testLinks >::hasBadLink | ( |  | ) | const

Determines if this face does not have an appropriate link.

See condition (2) in the documentation for isValid() for a full description of what "appropriate" means.

This routine is only available where dim is one of Regina's standard dimensions, since testing this condition in arbitrary dimensions is undecidable. For higher dimensions dim, this routine is not present.

A face whose link is not appropriate will always be marked as invalid. Note that there are other types of invalid faces also. See isValid() for a full discussion of what it means for a face to be valid.

Returns
  `true` if and only if the link of this face is not appropriate.

## hasBoundary()

template<int dim>

bool regina::detail::SimplexBase< dim >::hasBoundary | ( |  | ) | const

Determines if this simplex has any facets that lie on the triangulation boundary.

In other words, this routine determines whether any facet of this simplex is not currently glued to an adjacent simplex.

Returns
  `true` if and only if this simplex has any boundary facets.

## hasBoundaryFacets() [1/2]

template<int dim>

bool regina::detail::ComponentBase< dim >::hasBoundaryFacets | ( |  | ) | const

inline

Determines if this component has any boundary facets.

This routine returns `true` if and only if this component contains some top-dimensional simplex with at least one facet that is not glued to an adjacent simplex.

Returns
  `true` if and only if this component has boundary facet(s).

## hasBoundaryFacets() [2/2]

template<int dim>

bool regina::detail::TriangulationBase< dim >::hasBoundaryFacets | ( |  | ) | const

inline

Determines if this triangulation has any boundary facets.

This routine returns `true` if and only if the triangulation contains some top-dimension simplex with at least one facet that is not glued to an adjacent simplex.

Returns
  `true` if and only if there are boundary facets.

## homology()

template<int dim>

const AbelianGroup & regina::detail::TriangulationBase< dim >::homology | ( |  | ) | const

Returns the first homology group for this triangulation.

The homology is computed in the dual 2-skeleton. This means:

- If the triangulation contains any ideal vertices, the homology will be calculated as if each such vertex had been truncated.
- Likewise, if the triangulation contains any invalid faces of dimension 0,1,...,(dim-3), these will effectively be truncated also.
- In contrast, if the triangulation contains any invalid (dim-2)-faces (i.e., codimension-2-faces that are identified with themselves under a non-trivial map), the homology will be computed without truncating the centroid of the face. For instance, if a 3-manifold triangulation has an edge identified with itself in reverse, then the homology will be computed without truncating the resulting projective plane cusp. This means that, if a barycentric subdivision is performed on a such a triangulation, the result of homology() might change.

This routine can also be accessed via the alias homologyH1() (a name that is more specific, but a little longer to type).

Bear in mind that each time the triangulation changes, the homology groups will be deleted. Thus the reference that is returned from this routine should not be kept for later use. Instead, homology() should be called again; this will be instantaneous if the group has already been calculated.

Warning
  In dimension 3, if you are calling this from the subclass SnapPeaTriangulation then any fillings on the cusps will be ignored. (This is the same as for every routine implemented by Regina's Triangulation<3> class.) If you wish to compute homology with fillings, call SnapPeaTriangulation::homologyFilled() instead.

Returns
  the first homology group.

## homologyH1()

template<int dim>

const AbelianGroup & regina::detail::TriangulationBase< dim >::homologyH1 | ( |  | ) | const

inline

Returns the first homology group for this triangulation.

This is identical to calling homology(). See the homology() documentation for further details.

Returns
  the first homology group.

## identify()

template<int dim, int subdim>

static void regina::detail::BoundaryComponentCalculator< dim, subdim >::identify | ( | TriangulationBase< dim > & | t,
|  | BoundaryComponent< dim > * | bc,
|  | Face< dim, dim-1 > * | facet
| ) |  |

inline static

Identifies and marks all faces of dimension ≤ subdim within the given boundary facet of the given dim-dimensional triangulation.

This routine pushes all such subdim-faces onto the relevant list for the given boundary component, and also marks the boundary component within these subdim-faces themselves.

Parameters

  t | the underlying triangulation.
  bc | the boundary component of t currently under construction.
  facet | a boundary facet that belongs to bc.

## identity()

template<int dim>

Isomorphism< dim > * regina::detail::IsomorphismBase< dim >::identity | ( | unsigned | nSimplices | ) |

inline static

Returns the identity isomorphism for the given number of simplices.

This isomorphism sends every simplex and every vertex to itself.

The isomorphism will be newly constructed, and must be destroyed by the caller of this routine.

Parameters

  nSimplices | the number of simplices that the new isomorphism should operate upon.

Returns
  the newly constructed identity isomorphism.

## index() [1/4]

template<int dim>

size_t regina::detail::ComponentBase< dim >::index | ( |  | ) | const

inline

Returns the index of this component within the underlying triangulation.

Returns
  the index of this component.

## index() [2/4]

template<int dim>

size_t regina::detail::SimplexBase< dim >::index | ( |  | ) | const

inline

Returns the index of this simplex in the underlying triangulation.

The index will be an integer between 0 and `triangulation()->size()-1` inclusive.

Note that indexing may change when a simplex is added to or removed from the underlying triangulation.

Returns
  the index of this simplex.

## index() [3/4]

template<int dim, int subdim>

size_t regina::detail::FaceBase< dim, subdim >::index | ( |  | ) | const

inline

Returns the index of this face within the underlying triangulation.

Returns
  the index of this face.

## index() [4/4]

template<int dim>

size_t regina::detail::BoundaryComponentBase< dim >::index | ( |  | ) | const

inline

Returns the index of this boundary component in the underlying triangulation.

Returns
  the index of this boundary component.

## initialChars()

template<int dim>

void regina::detail::XMLSimplexReader< dim >::initialChars | ( | const std::string & | chars | ) |

virtual

Signifies that the initial text belonging to this XML element has been read.

The initial text is everything between the opening tag and the first subelement or closing tag.

The default implementation does nothing.

Parameters

  chars | the initial text for this element.

Reimplemented from regina::XMLElementReader.

## inMaximalForest()

template<int dim, int codim>

bool regina::detail::FaceStorage< dim, codim >::inMaximalForest | ( |  | ) | const

Determines whether a codimension-1-face represents a dual edge in the maximal forest that has been chosen for the dual 1-skeleton of the triangulation.

This routine is only available for faces of codimension 1; that is, (dim-1)-faces of a dim-dimensional triangulation.

When the skeletal structure of a triangulation is first computed, a maximal forest in the dual 1-skeleton of the triangulation is also constructed. Each dual edge in this maximal forest represents a (dim-1)-face of the (primal) triangulation.

This maximal forest will remain fixed until the triangulation changes, at which point it will be recomputed (as will all other skeletal objects, such as connected components and so on). There is no guarantee that, when it is recomputed, the maximal forest will use the same dual edges as before.

This routine identifies whether this (dim-1)-face belongs to the dual forest. In this sense it performs a similar role to Simplex::facetInMaximalForest(), but this routine is typically easier to use.

If the skeleton has already been computed, then this routine is very fast (since it just returns a precomputed answer).

Returns
  `true` if and only if this (dim-1)-face represents a dual edge in the maximal forest.

## insertConstruction()

template<int dim>

void regina::detail::TriangulationBase< dim >::insertConstruction | ( | size_t | nSimplices,
|  | const int | adjacencies[][dim+1],
|  | const int | gluings[][dim+1][dim+1]
| ) |  |

Inserts a given triangulation into this triangulation, where the given triangulation is described by a pair of integer arrays.

The main purpose of this routine is to allow users to hard-code triangulations into C++ source files. In particular, all of the simplex gluings can be hard-coded into a pair of integer arrays at the beginning of the source file, avoiding an otherwise tedious sequence of many calls to Simplex<dim>::join(). If you have a particular triangulation that you would like to hard-code in this way, you can call dumpConstruction() to generate the corresponding integer arrays as C++ source code.

This routine will insert an additional nSimplices top-dimensional simplices into this triangulation. We number these simplices 0,1,...,nSimplices-1. The gluings between these new simplices should be stored in the two arrays as follows.

The adjacencies array describes which simplices are joined to which others. Specifically, `adjacencies[s][f]` indicates which of the new simplices is joined to facet f of simplex s. This should be between 0 and nSimplices-1 inclusive, or -1 if facet f of simplex s is to be left as a boundary facet.

The gluings array describes the particular gluing permutations used to join these simplices together. Specifically, `gluings[s][f][0..dim]` should describe the permutation used to join facet f of simplex s to its adjacent simplex. These dim+1 integers should be 0,1,...,dim in some order, so that `gluings[s][f][i]` contains the image of i under this permutation. If facet f of simplex s is to be left as a boundary facet, then `gluings[s][f][0..dim]` may contain anything (and will be duly ignored).

If this triangulation is empty before this routine is called, then the new simplices will be given indices 0,1,...,nSimplices-1 according to the numbering described above. Otherwise they will be inserted after any pre-existing simplices, and so they will be given larger indices instead. In the latter case, the adjacencies array should still refer to the new simplices as 0,1,...,nSimplices-1, and this routine will handle any renumbering automatically at runtime.

It is the responsibility of the caller of this routine to ensure that the given arrays are correct and consistent. No error checking will be performed by this routine.

Python:\n Not present.

Parameters

  nSimplices | the number of additional simplices to insert.
  adjacencies | describes which simplices are adjace to which others, as described above. This array must have initial dimension at least nSimplices.
  gluings | describes the specific gluing permutations, as described above. This array must also have initial dimension at least nSimplices.

## insertTriangulation()

template<int dim>

void regina::detail::TriangulationBase< dim >::insertTriangulation | ( | const Triangulation< dim > & | source | ) |

Inserts a copy of the given triangulation into this triangulation.

The top-dimensional simplices of source will be copied into this triangulation in the same order in which they appear in source. That is, if the original size of this triangulation was S, then the simplex at index i in source will be copied into this triangulation as a new simplex at index S+i.

The copies will use the same vertex numbering and descriptions as the original simplices from source, and any gluings between the simplices of source will likewise be copied across as gluings between their copies in this triangulation.

This routine behaves correctly when source is this triangulation.

Parameters

  source | the triangulation whose copy will be inserted.

## isBoundary()

template<int dim, int subdim>

bool regina::detail::FaceBase< dim, subdim >::isBoundary | ( |  | ) | const

inline

Determines if this face lies entirely on the boundary of the triangulation.

For dimensions in which ideal and/or invalid vertices are both possible and recognised: both ideal and invalid vertices are considered to be on the boundary.

Returns
  `true` if and only if this face lies on the boundary.

## isCanonical()

template<int dim>

bool regina::detail::FacetPairingBase< dim >::isCanonical | ( |  | ) | const

Determines whether this facet pairing is in canonical form, i.e., is a lexicographically minimal representative of its isomorphism class.

Isomorphisms of facet pairings correspond to relabellings of simplices and relabellings of the (dim + 1) facets within each simplex.

Facet pairings are ordered by lexicographical comparison of `dest(0,0)`, `dest(0,1)`, ..., `dest(size()-1,dim)`.

Precondition
  This facet pairing is connected, i.e., it is possible to reach any simplex from any other simplex via a series of matched facet pairs.

Returns
  `true` if and only if this facet pairing is in canonical form.

## isCanonicalInternal()

template<int dim>

bool regina::detail::FacetPairingBase< dim >::isCanonicalInternal | ( | IsoList & | list | ) | const

protected

Determines whether this facet pairing is in canonical (smallest lexicographical) form, given a small set of assumptions.

If this facet pairing is in canonical form, the given list will be filled with the set of all combinatorial automorphisms of this facet pairing. If not, the given list will be left empty.

Precondition
  The given list is empty.
  For each simplex t, the only case in which `dest(t,i)` is greater than `dest(t,i+1)` is where facets `(t,i)` and `(t,i+1)` are paired together.
  For each simplex t > 0, it is true that `dest(t,0).simp < t`.
  The sequence `dest(1,0)`, `dest(2,0)`, ..., `dest(n-1,0)` is strictly increasing, where n is the total number of simplices under investigation.

Parameters

  list | the list into which automorphisms will be placed if appropriate.

Returns
  `true` if and only if this facet pairing is in canonical form.

## isClosed()

template<int dim>

bool regina::detail::FacetPairingBase< dim >::isClosed | ( |  | ) | const

Determines whether this facet pairing is closed.

A closed facet pairing has no unmatched facets.

## isConnected()

template<int dim>

bool regina::detail::TriangulationBase< dim >::isConnected | ( |  | ) | const

inline

Determines if this triangulation is connected.

Returns
  `true` if and only if this triangulation is connected.

## isContainedIn()

template<int dim>

std::unique_ptr< Isomorphism< dim > > regina::detail::TriangulationBase< dim >::isContainedIn | ( | const Triangulation< dim > & | other | ) | const

inline

Determines if an isomorphic copy of this triangulation is contained within the given triangulation, possibly as a subcomplex of some larger component (or components).

Specifically, this routine determines if there is a boundary incomplete combinatorial isomorphism from this triangulation to other. Boundary incomplete isomorphisms are described in detail in the Isomorphism class notes.

In particular, note that facets of top-dimensional simplices that lie on the boundary of this triangulation need not correspond to boundary facets of other, and that other may contain more top-dimensional simplices than this triangulation.

If a boundary incomplete isomorphism is found, the details of this isomorphism are returned. The isomorphism is newly constructed, and so to assist with memory management is returned as a std::unique_ptr. Thus, to test whether an isomorphism exists without having to explicitly deal with the isomorphism itself, you can call `if (isContainedIn(other).get())` and the newly created isomorphism (if it exists) will be automatically destroyed.

If more than one such isomorphism exists, only one will be returned. For a routine that returns all such isomorphisms, see findAllSubcomplexesIn().

Warning
  For large dimensions, this routine can become extremely slow: its running time includes a factor of (dim+1)!.

Parameters

  other | the triangulation in which to search for an isomorphic copy of this triangulation.

Returns
  details of the isomorphism if such a copy is found, or a null pointer otherwise.

## isEmpty()

template<int dim>

bool regina::detail::TriangulationBase< dim >::isEmpty | ( |  | ) | const

inline

Determines whether this triangulation is empty.

An empty triangulation is one with no simplices at all.

Returns
  `true` if and only if this triangulation is empty.

## isIdeal()

template<int dim, bool allFaces, bool allowVertex_>

bool regina::detail::BoundaryComponentFaceInterface< dim, allFaces, allowVertex_ >::isIdeal | ( |  | ) | const

inline

Determines if this boundary component is ideal.

This is the case if and only if it consists of a single ideal vertex and no faces of any other dimensions.

See the BoundaryComponent class notes for an overview of ideal boundary components, which can only occur in dimensions ≥ 3, and which are only recognised where dim is one of Regina's standard dimensions.

Note that a boundary component formed from a single invalid vertex is not considered to be ideal. This means that, if a boundary component contains no faces of positive dimension, then one and only one of isIdeal() and isInvalidVertex() will return `true`.

This routine is only available where dim is at least 3 and is one of Regina's standard dimensions.

Returns
  `true` if and only if this boundary component is ideal.

## isIdenticalTo()

template<int dim>

bool regina::detail::TriangulationBase< dim >::isIdenticalTo | ( | const Triangulation< dim > & | other | ) | const

Determines if this triangulation is combinatorially identical to the given triangulation.

Here "identical" means that the triangulations have the same number of top-dimensional simplices, with gluings between the same pairs of numbered simplices using the same gluing permutations. In other words, "identical" means that the triangulations are isomorphic via the identity isomorphism.

For the less strict notion of isomorphic triangulations, which allows relabelling of the top-dimensional simplices and their vertices, see isIsomorphicTo() instead.

This test does not examine the textual simplex descriptions, as seen in Simplex<dim>::description(); these may still differ. It also does not test whether lower-dimensional faces are numbered identically (vertices, edges and so on); this routine is only concerned with top-dimensional simplices.

(At the time of writing, two identical triangulations will always number their lower-dimensional faces in the same way. However, it is conceivable that in future versions of Regina there may be situations in which identical triangulations can acquire different numberings for vertices, edges, and so on.)

Parameters

  other | the triangulation to compare with this one.

Returns
  `true` if and only if the two triangulations are combinatorially identical.

## isIdentity()

template<int dim>

bool regina::detail::IsomorphismBase< dim >::isIdentity | ( |  | ) | const

Determines whether or not this is an identity isomorphism.

In an identity isomorphism, each simplex image is itself, and within each simplex the facet/vertex permutation is the identity permutation.

Returns
  `true` if this is an identity isomorphism, or `false` otherwise.

## isInvalidVertex()

template<int dim, bool allFaces, bool allowVertex_>

bool regina::detail::BoundaryComponentFaceInterface< dim, allFaces, allowVertex_ >::isInvalidVertex | ( |  | ) | const

inline

Determines if this boundary component consists of a single invalid vertex and nothing else.

In particular, such a boundary component must contain no faces of any positive dimension.

See the BoundaryComponent class notes for an overview of invalid vertex boundary components, which can only occur in dimensions ≥ 4, and which are only recognised where dim is one of Regina's standard dimensions.

An invalid vertex is only placed in its own boundary component if it does not already belong to some larger boundary component (for instance, if its link is an ideal (dim-1)-manifold triangulation). This means that, for a boundary component consisting of one or more (dim-1)-faces, this routine will return `false` even if the boundary component also includes one or more invalid vertices.

Note that, if a boundary component contains no faces of positive dimension, then one and only one of isIdeal() and isInvalidVertex() will return `true`.

This routine is only available where dim is at least 3 and is one of Regina's standard dimensions.

Returns
  `true` if and only if this boundary component consists of a single invalid vertex and nothing else.

## isIsomorphicTo()

template<int dim>

std::unique_ptr< Isomorphism< dim > > regina::detail::TriangulationBase< dim >::isIsomorphicTo | ( | const Triangulation< dim > & | other | ) | const

inline

Determines if this triangulation is combinatorially isomorphic to the given triangulation.

Two triangulations are isomorphic if and only it is possible to relabel their top-dimensional simplices and the (dim+1) vertices of each simplex in a way that makes the two triangulations combinatorially identical, as returned by isIdenticalTo().

Equivalently, two triangulations are isomorphic if and only if there is a one-to-one and onto boundary complete combinatorial isomorphism from this triangulation to other, as described in the Isomorphism class notes.

In particular, note that this triangulation and other must contain the same number of top-dimensional simplices for such an isomorphism to exist.

If the triangulations are isomorphic, then this routine returns one such boundary complete isomorphism (i.e., one such relabelling). The isomorphism will be newly constructed, and to assist with memory management, it will be returned as a std::unique_ptr. Thus, to test whether an isomorphism exists without having to explicitly manage with the isomorphism itself, you can just call `if (isIsomorphicTo(other).get())`, in which case the newly created isomorphism (if it exists) will be automatically destroyed.

There may be many such isomorphisms between the two triangulations. If you need to find all such isomorphisms, you may call findAllIsomorphisms() instead.

If you need to ensure that top-dimensional simplices are labelled the same in both triangulations (i.e., that the triangulations are related by the identity isomorphism), you should call the stricter test isIdenticalTo() instead.

Warning
  For large dimensions, this routine can become extremely slow: its running time includes a factor of (dim+1)!.

Todo:
  Optimise: Improve the complexity by choosing a simplex mapping from each component and following gluings to determine the others.

Parameters

  other | the triangulation to compare with this one.

Returns
  details of the isomorphism if the two triangulations are combinatorially isomorphic, or a null pointer otherwise.

## isLinkOrientable() [1/2]

template<bool allowsNonorientable>

bool regina::detail::FaceOrientability< allowsNonorientable >::isLinkOrientable | ( |  | ) | const

Determines if the link of this face is orientable.

This routine is fast: it uses pre-computed information, and does not need to build a full triangulation of the link.

Warning
  If this face is identified with itself under a non-identity permutation (which makes the face invalid), then the return value of this routine is undefined.

Returns
  `true` if and only if the link is orientable.

## isLinkOrientable() [2/2]

bool regina::detail::FaceOrientability< false >::isLinkOrientable | ( |  | ) | const

inline

Determines if the link of this face is orientable.

This routine always returns `true`, since this specialisation of FaceOrientability is for dimensions in which links of faces are always orientable.

Returns
  `true`.

## isolate()

template<int dim>

void regina::detail::SimplexBase< dim >::isolate | ( |  | ) |

Unglues this simplex from any adjacent simplices.

As a result, every facet of this simplex will become a boundary facet, and this simplex will form its own separate component of the underlying triangulation.

If there were any adjacent simplices to begin with, these will be updated automatically.

This routine is safe to call even if there are no adjacent simplices (in which case it will do nothing).

## IsomorphismBase() [1/2]

template<int dim>

regina::detail::IsomorphismBase< dim >::IsomorphismBase | ( | const IsomorphismBase< dim > & | copy | ) |

inline

Creates a new copy of the given isomorphism.

Parameters

  copy | the isomorphism to copy.

## IsomorphismBase() [2/2]

template<int dim>

regina::detail::IsomorphismBase< dim >::IsomorphismBase | ( | unsigned | nSimplices | ) |

inline

Creates a new isomorphism with no initialisation.

The images of the simplices and their vertices must be explicitly set using simpImage() and facetPerm().

Parameters

  nSimplices | the number of simplices in the source triangulation associated with this isomorphism. This is allowed to be zero.

## isOrientable() [1/3]

template<int dim>

bool regina::detail::ComponentBase< dim >::isOrientable | ( |  | ) | const

inline

Determines if this component is orientable.

This routine runs in constant time (since orientability is determined in advance, when the component is first created).

Returns
  `true` if and only if this component is orientable.

## isOrientable() [2/3]

template<int dim>

bool regina::detail::TriangulationBase< dim >::isOrientable | ( |  | ) | const

inline

Determines if this triangulation is orientable.

Returns
  `true` if and only if this triangulation is orientable.

## isOrientable() [3/3]

template<int dim>

bool regina::detail::BoundaryComponentBase< dim >::isOrientable | ( |  | ) | const

inline

Determines if this boundary component is orientable.

If this is an ideal or invalid vertex boundary component, then the orientability of the corresponding vertex link is returned.

This routine is fast; in particular, it is pre-computed and does not build a full triangulation of the boundary component.

Returns
  `true` if and only if this boundary component is orientable.

## isOriented()

template<int dim>

bool regina::detail::TriangulationBase< dim >::isOriented | ( |  | ) | const

Determines if this triangulation is oriented; that is, if the vertices of its top-dimensional simplices are labelled in a way that preserves orientation across adjacent facets.

Specifically, this routine returns `true` if and only if every gluing permutation has negative sign.

Note that orientable triangulations are not always oriented by default. You can call orient() if you need the top-dimensional simplices to be oriented consistently as described above.

A non-orientable triangulation can never be oriented.

Returns
  `true` if and only if all top-dimensional simplices are oriented consistently.

Author
  Matthias Goerner

## isoSig()

template<int dim>

std::string regina::detail::TriangulationBase< dim >::isoSig | ( | Isomorphism< dim > ** | relabelling = `0` | ) | const

Constructs the isomorphism signature for this triangulation.

An isomorphism signature is a compact text representation of a triangulation that uniquely determines the triangulation up to combinatorial isomorphism. That is, two triangulations of dimension dim are combinatorially isomorphic if and only if their isomorphism signatures are the same.

The isomorphism signature is constructed entirely of printable characters, and has length proportional to `n log n`, where n is the number of top-dimenisonal simplices.

Whilst the format of an isomorphism signature bears some similarity to dehydration strings for 3-manifolds, they are more general: isomorphism signatures can be used with any triangulations, including closed, bounded and/or disconnected triangulations, as well as triangulations with many simplices. Note also that 3-manifold dehydration strings are not unique up to isomorphism (they depend on the particular labelling of tetrahedra).

The time required to construct the isomorphism signature of a triangulation is `O((dim!) n^2 log^2 n)`. Whilst this is fine for large triangulation, it will be extremly slow for large dimensions.

The routine fromIsoSig() can be used to recover a triangulation from an isomorphism signature. The triangulation recovered might not be identical to the original, but it will be combinatorially isomorphic.

If relabelling is non-null (i.e., it points to some Isomorphism pointer p), then it will be modified to point to a new isomorphism that describes the precise relationship between this triangulation and the reconstruction from fromIsoSig(). Specifically, the triangulation that is reconstructed from fromIsoSig() will be combinatorially identical to `relabelling.apply(this)`.

For a full and precise description of the isomorphism signature format for 3-manifold triangulations, see Simplification paths in the Pachner graphs of closed orientable 3-manifold triangulations, Burton, 2011, `arXiv:1110.6080`. The format for other dimensions is essentially the same, but with minor dimension-specific adjustments.

Python:\n The isomorphism argument is not present.
  Instead there are two routines: fromIsoSig(), which returns a string only, and fromIsoSigDetail(), which returns a pair (signature, relabelling).

Precondition
  If relabelling is non-null, then this triangulation must be non-empty and connected. The facility to return a relabelling for disconnected triangulations may be added to Regina in a later release.

Warning
  Do not mix isomorphism signatures between dimensions! It is possible that the same string could corresponding to both a p-dimensional triangulation and a q-dimensional triangulation for different dimensions p and q.

Parameters

  relabelling | if this is non-null, it will be modified to point to a new isomorphism that describes the relationship between this triangulation and the triangulation that will be reconstructed from fromIsoSig(), as described above.

Returns
  the isomorphism signature of this triangulation.

## isoSigComponentSize()

template<int dim>

static size_t regina::detail::TriangulationBase< dim >::isoSigComponentSize | ( | const std::string & | sig | ) |

static

Deduces the number of top-dimensional simplices in a connected triangulation from its isomorphism signature.

See isoSig() for more information on isomorphism signatures. It will be assumed that the signature describes a triangulation of dimension dim.

If the signature describes a connected triangulation, this routine will simply return the size of that triangulation (e.g., the number of tetrahedra in the case dim = 3). You can also pass an isomorphism signature that describes a disconnected triangulation; however, this routine will only return the number of top-dimensional simplices in the first connected component. If you need the total size of a disconnected triangulation, you will need to reconstruct the full triangulation by calling fromIsoSig() instead.

This routine is very fast, since it only examines the first few characters of the isomorphism signature (in which the size of the first component is encoded). However, a side-effect of this is that it is possible to pass an invalid isomorphism signature and still receive a positive result. If you need to test whether a signature is valid or not, you must call fromIsoSig() instead, which will examine the entire signature in full.

Warning
  Do not mix isomorphism signatures between dimensions! It is possible that the same string could corresponding to both a p-dimensional triangulation and a q-dimensional triangulation for different dimensions p and q.

Parameters

  sig | the isomorphism signature of a dim-dimensional triangulation. Note that isomorphism signature are case-sensitive (unlike, for example, dehydration strings for 3-manifolds).

Returns
  the number of top-dimensional simplices in the first connected component, or 0 if this could not be determined because the given string was not a valid isomorphism signature.

## isReal()

template<int dim, bool allFaces, bool allowVertex_>

bool regina::detail::BoundaryComponentFaceInterface< dim, allFaces, allowVertex_ >::isReal | ( |  | ) | const

inline

Determines if this boundary component is real.

This is the case if and only if it is formed from one or more (dim-1)-faces.

See the BoundaryComponent class notes for an overview of real, ideal, and invalid vertex boundary components.

This routine is only available where dim is at least 3 and is one of Regina's standard dimensions. (In other dimensions, real boundary components are the only types of boundary component that Regina will recognise.)

Returns
  `true` if and only if this boundary component is real.

## isUnmatched() [1/2]

template<int dim>

bool regina::detail::FacetPairingBase< dim >::isUnmatched | ( | const FacetSpec< dim > & | source | ) | const

inline

Determines whether the given simplex facet has been left deliberately unmatched.

Precondition
  The given facet is a real simplex facet (not boundary, before-the-start or past-the-end).

Parameters

  source | the facet under investigation.

Returns
  `true` if the given facet has been left unmatched, or `false` if the given facet is paired with some other facet.

## isUnmatched() [2/2]

template<int dim>

bool regina::detail::FacetPairingBase< dim >::isUnmatched | ( | size_t | simp,
|  | unsigned | facet
| ) |  | const

inline

Determines whether the given simplex facet has been left deliberately unmatched.

Parameters

  simp | the simplex under investigation (this must be strictly less than the total number of simplices under consideration).
  facet | the facet of the given simplex under investigation (between 0 and dim inclusive).

Returns
  `true` if the given facet has been left unmatched, or `false` if the given facet is paired with some other facet.

## isValid() [1/5]

template<int dim>

bool regina::detail::ComponentBase< dim >::isValid | ( |  | ) | const

inline

Determines if this component is valid.

This uses the same criteria as Triangulation<dim>::isValid(); see the Triangulation<dim>::isValid() documentation for details.

As with Triangulation<dim>, this tests for bad self-identifications in all dimensions, but only tests for bad links in Regina's standard dimensions.

Returns
  `true` if and only if this component is valid.

## isValid() [2/5]

template<bool allowsInvalid, bool testLinks>

bool regina::detail::FaceValidity< allowsInvalid, testLinks >::isValid | ( |  | ) | const

Determines if this face is valid.

There are several conditions that might make a subdim-face of a dim-dimensional triangulation invalid:

1. if the face is identified with itself under a non-identity permutation (e.g., an edge is identified with itself in reverse, or a triangle is identified with itself under a rotation);
2. if the face does not have an appropriate link. Here the meaning of "appropriate" depends upon the type of face:
   - for a face that belongs to some boundary facet(s) of the triangulation, its link must be a topological ball;
   - for a vertex that does not belong to any boundary facets, its link must be a closed (dim - 1)-manifold;
   - for a (subdim ≥ 1)-face that does not belong to any boundary facets, its link must be a topological sphere.

Condition (1) is tested for all dimensions subdim and dim. Condition (2) is more difficult, since it relies on undecidable problems. As a result, (2) is only tested when dim is one of Regina's standard dimensions.

If this face is invalid, then it is possible to find out why. In non-standard dimensions, this must mean that the face fails condition (1) above. In standard dimensions, you can call the functions hasBadIdentification() and/or hasBadLink() to determine whether the failure is due to conditions (1) or (2) respectively.

Returns
  for standard dimensions dim, returns `true` if and only if this face is valid according to both conditions (1) and (2) above; for non-standard dimensions dim, returns `true` if and only if this face is valid according to condition (1).

## isValid() [3/5]

template<bool testLinks>

bool regina::detail::FaceValidity< false, testLinks >::isValid | ( |  | ) | const

inline

Always returns `true`.

In general, this routine determines whether a face is valid. However, this particular class is used for dimensions in which faces are always valid, and so this routine returns `true` always.

See FaceValidity<true, true>::isValid() for a general discussion on what it means for a face to be valid.

Returns
  `true`.

## isValid() [4/5]

bool regina::detail::FaceValidity< true, false >::isValid | ( |  | ) | const

inline

Determines if this face is valid.

This class is used for non-standard dimensions, where a face is defined to be valid if and only if it is not identified with itself under a non-identity permutation. For example, an edge is valid if and only if it is not identified with itself in reverse, and a triangle is valid if and only if it is is not identified with itself under a non-trivial rotation or reflection.

Note that the definition of validity is richer in Regina's standard dimensions, where we also consider the topology of the link of a face. See FaceValidity<true, true> for a full discussion of what it means for a face to be valid, and how this differs between standard and non-standard dimensions.

Returns
  `true` if and only if this face is not identified with itself under a non-identity permutation.

## isValid() [5/5]

template<int dim>

bool regina::detail::TriangulationBase< dim >::isValid | ( |  | ) | const

inline

Determines if this triangulation is valid.

There are several conditions that might make a dim-dimensional triangulation invalid:

1. if some face is identified with itself under a non-identity permutation (e.g., an edge is identified with itself in reverse, or a triangle is identified with itself under a rotation);
2. if some subdim-face does not have an appropriate link. Here the meaning of "appropriate" depends upon the type of face:
   - for a face that belongs to some boundary facet(s) of this triangulation, its link must be a topological ball;
   - for a vertex that does not belong to any boundary facets, its link must be a closed (dim - 1)-manifold;
   - for a (subdim ≥ 1)-face that does not belong to any boundary facets, its link must be a topological sphere.

Condition (1) is tested for all dimensions dim. Condition (2) is more difficult, since it relies on undecidable problems. As a result, (2) is only tested when dim is one of Regina's standard dimensions.

If a triangulation is invalid then you can call Face<dim, subdim>::isValid() to discover exactly which face(s) are responsible, and you can call Face<dim, subdim>::hasBadIdentification() and/or Face<dim, subdim>::hasBadLink() to discover exactly which conditions fail.

Note that all invalid vertices are considered to be on the boundary; see isBoundary() for details.

Returns
  `true` if and only if this triangulation is valid.

## join()

template<int dim>

void regina::detail::SimplexBase< dim >::join | ( | int | myFacet,
|  | Simplex< dim > * | you,
|  | Perm< dim+1 > | gluing
| ) |  |

Joins the given facet of this simplex to some facet of another simplex.

The other simplex will be updated automatically (i.e., you only need to call join() from one side of the gluing).

You may join a facet of this simplex to some different facet of the same simplex (i.e., you may pass you == `this`), though you cannot join a facet to itself.

Precondition
  This and the given simplex belong to the same triangulation.
  The given facet of this simplex is not currently glued to anything.
  The corresponding facet of the other simplex (i.e., facet gluing[myFacet] of you) is likewise not currently glued to anything.
  We are not attempting to glue a facet to itself (i.e., we do not have both you == `this` and gluing[myFacet] == myFacet).

Parameters

  myFacet | the facet of this simplex that will be glued to the given simplex you. This facet number must be between 0 and dim inclusive.
  you | the other simplex that will be glued to the given facet of this simplex.
  gluing | a permutation that describes how the vertices of this simplex will map to the vertices of you across the new gluing. This permutation should be in the form described by adjacentGluing().

## makeCanonical()

template<int dim>

bool regina::detail::TriangulationBase< dim >::makeCanonical | ( |  | ) |

Relabel the top-dimensional simplices and their vertices so that this triangulation is in canonical form.

This is essentially the lexicographically smallest labelling when the facet gluings are written out in order.

Two triangulations are isomorphic if and only if their canonical forms are identical.

The lexicographic ordering assumes that the facet gluings are written in order of simplex index and then facet number. Each gluing is written as the destination simplex index followed by the gluing permutation (which in turn is written as the images of 0,1,...,dim in order).

Precondition
  This routine currently works only when the triangulation is connected. It may be extended to work with disconnected triangulations in later versions of Regina.

Returns
  `true` if the triangulation was changed, or `false` if the triangulation was in canonical form to begin with.

## makeDoubleCover()

template<int dim>

void regina::detail::TriangulationBase< dim >::makeDoubleCover | ( |  | ) |

Converts this triangulation into its double cover.

Each orientable component will be duplicated, and each non-orientable component will be converted into its orientable double cover.

## markBadIdentification() [1/3]

template<bool allowsInvalid, bool testLinks>

void regina::detail::FaceValidity< allowsInvalid, testLinks >::markBadIdentification | ( |  | ) |

protected

Marks this face as having a non-identity self-identification.

## markBadIdentification() [2/3]

template<bool testLinks>

void regina::detail::FaceValidity< false, testLinks >::markBadIdentification | ( |  | ) |

inline protected

Marks this face as having a non-identity self-identification.

This routine should never be called, since this specialisation of FaceValidity is for dimensions in which faces are always valid.

It is provided to support dimension-agnostic code, but its implementation does nothing.

## markBadIdentification() [3/3]

void regina::detail::FaceValidity< true, false >::markBadIdentification | ( |  | ) |

inline protected

Marks this face as having a non-identity self-identification.

## markBadLink() [1/2]

template<bool allowsInvalid, bool testLinks>

void regina::detail::FaceValidity< allowsInvalid, testLinks >::markBadLink | ( |  | ) |

protected

Marks this face as having a bad link.

## markBadLink() [2/2]

template<bool testLinks>

void regina::detail::FaceValidity< false, testLinks >::markBadLink | ( |  | ) |

inline protected

Marks this face as having a bad link.

This routine should never be called, since this specialisation of FaceValidity is for dimensions in which faces are always valid.

It is provided to support dimension-agnostic code, but its implementation does nothing.

## markLinkNonorientable() [1/2]

template<bool allowsNonorientable>

void regina::detail::FaceOrientability< allowsNonorientable >::markLinkNonorientable | ( |  | ) |

protected

Marks the link of this face as non-orientable.

## markLinkNonorientable() [2/2]

void regina::detail::FaceOrientability< false >::markLinkNonorientable | ( |  | ) |

inline protected

Marks the link of this face as non-orientable.

This routine should never be called, since this specialisation of FaceOrientability is for dimensions in which links of faces are always orientable.

It is provided to support dimension-agnostic code, but its implementation does nothing.

## moveContentsTo()

template<int dim>

void regina::detail::TriangulationBase< dim >::moveContentsTo | ( | Triangulation< dim > & | dest | ) |

Moves the contents of this triangulation into the given destination triangulation, without destroying any pre-existing contents.

All top-dimensional simplices that currently belong to dest will remain there (and will keep the same indices in dest). All top-dimensional simplices that belong to this triangulation will be moved into dest also (but in general their indices will change).

This triangulation will become empty as a result.

Any pointers or references to Simplex<dim> objects will remain valid.

Precondition
  dest is not this triangulation.

Parameters

  dest | the triangulation into which simplices should be moved.

## newSimplex() [1/2]

template<int dim>

Simplex< dim > * regina::detail::TriangulationBase< dim >::newSimplex | ( |  | ) |

Creates a new top-dimensional simplex and adds it to this triangulation.

The new simplex will have an empty description. All (dim+1) facets of the new simplex will be boundary facets.

The new simplex will become the last simplex in this triangulation; that is, it will have index size()-1.

Returns
  the new simplex.

## newSimplex() [2/2]

template<int dim>

Simplex< dim > * regina::detail::TriangulationBase< dim >::newSimplex | ( | const std::string & | desc | ) |

Creates a new top-dimensional simplex with the given description and adds it to this triangulation.

All (dim+1) facets of the new simplex will be boundary facets.

Descriptions are optional, may have any format, and may be empty. How descriptions are used is entirely up to the user.

The new simplex will become the last simplex in this triangulation; that is, it will have index size()-1.

Parameters

  desc | the description to give to the new simplex.

Returns
  the new simplex.

## noDest() [1/2]

template<int dim>

bool regina::detail::FacetPairingBase< dim >::noDest | ( | const FacetSpec< dim > & | source | ) | const

inline protected

Determines whether the matching for the given simplex facet has not yet been determined.

This is signalled by a facet matched to itself.

Precondition
  The given facet is a real simplex facet (not boundary, before-the-start or past-the-end).

Parameters

  source | the facet under investigation.

Returns
  `true` if the matching for the given facet has not yet been determined, or `false` otherwise.

## noDest() [2/2]

template<int dim>

bool regina::detail::FacetPairingBase< dim >::noDest | ( | size_t | simp,
|  | unsigned | facet
| ) |  | const

inline protected

Determines whether the matching for the given simplex facet has not yet been determined.

This is signalled by a facet matched to itself.

Parameters

  simp | the simplex under investigation (this must be strictly less than the total number of simplices under consideration).
  facet | the facet of the given simplex under investigation (between 0 and dim inclusive).

Returns
  `true` if the matching for the given facet has not yet been determined, or `false` otherwise.

## operator!=() [1/2]

template<int dim, int subdim>

bool regina::detail::FaceEmbeddingBase< dim, subdim >::operator!= | ( | const FaceEmbeddingBase< dim, subdim > & | rhs | ) | const

inline

Tests whether this and the given object are different.

Here "different" means that they do not refer to the same face of the same top-dimensional simplex.

Parameters

  rhs | the object to compare with this.

Returns
  `true` if and only if both object are identical.

## operator!=() [2/2]

template<int dim, int subdim>
template<int tridim>

bool regina::detail::WeakFaceList< dim, subdim >::ReorderIterator< tridim >::operator!= | ( | const ReorderIterator< tridim > & | rhs | ) | const

inline

Tests whether this and the given iterator point to different faces.

## operator*()

template<int dim, int subdim>
template<int tridim>

Face<tridim, subdim>* regina::detail::WeakFaceList< dim, subdim >::ReorderIterator< tridim >::operator* | ( |  | ) | const

inline

Returns the face of the other triangulation tri that corresponds to the current face in this list.

See the iterator class notes for details.

## operator++() [1/2]

template<int dim, int subdim>
template<int tridim>

ReorderIterator& regina::detail::WeakFaceList< dim, subdim >::ReorderIterator< tridim >::operator++ | ( |  | ) |

inline

Preincrement operator that steps to the next face in this list.

## operator++() [2/2]

template<int dim, int subdim>
template<int tridim>

ReorderIterator regina::detail::WeakFaceList< dim, subdim >::ReorderIterator< tridim >::operator++ | ( | int |  | ) |

inline

Postincrement operator that steps to the next face in this list.

## operator=() [1/2]

template<int dim, int subdim>

FaceEmbeddingBase< dim, subdim > & regina::detail::FaceEmbeddingBase< dim, subdim >::operator= | ( | const FaceEmbeddingBase< dim, subdim > & | cloneMe | ) |

inline

Makes this a copy of the given object.

Parameters

  cloneMe | the object to copy.

## operator=() [2/2]

template<int dim, int subdim>

SimplexFaces& regina::detail::SimplexFaces< dim, subdim >::operator= | ( | const SimplexFaces< dim, subdim > & |  | ) |

delete

Explicitly disable the assignment operator.

## operator==() [1/2]

template<int dim, int subdim>

bool regina::detail::FaceEmbeddingBase< dim, subdim >::operator== | ( | const FaceEmbeddingBase< dim, subdim > & | rhs | ) | const

inline

Tests whether this and the given object are identical.

Here "identical" means that they refer to the same face of the same top-dimensional simplex.

Parameters

  rhs | the object to compare with this.

Returns
  `true` if and only if both object are identical.

## operator==() [2/2]

template<int dim, int subdim>
template<int tridim>

bool regina::detail::WeakFaceList< dim, subdim >::ReorderIterator< tridim >::operator== | ( | const ReorderIterator< tridim > & | rhs | ) | const

inline

Tests whether this and the given iterator point to the same face.

## operator[]() [1/3]

template<int dim>

FacetSpec< dim > & regina::detail::FacetPairingBase< dim >::operator[] | ( | const FacetSpec< dim > & | source | ) |

inline protected

Returns the other facet to which the given simplex facet is paired.

This is a convenience operator whose behaviour is identical to that of dest(const FacetSpec<dim>&).

If the given facet is left deliberately unmatched, the value returned will be boundary (as returned by FacetSpec<dim>::isBoundary()).

Precondition
  The given facet is a real simplex facet (not boundary, before-the-start or past-the-end).

Parameters

  source | the facet under investigation.

Returns
  the other facet to which the given facet is paired.

## operator[]() [2/3]

template<int dim>

FacetSpec< dim > regina::detail::IsomorphismBase< dim >::operator[] | ( | const FacetSpec< dim > & | source | ) | const

inline

Determines the image of the given source simplex facet under this isomorphism.

This operator returns by value: it cannot be used to alter the isomorphism.

Parameters

  source | the given source simplex facet; this must be one of the (dim + 1) facets of one of the size() simplices in the source triangulation.

Returns
  the image of the source simplex facet under this isomorphism.

## operator[]() [3/3]

template<int dim>

const FacetSpec< dim > & regina::detail::FacetPairingBase< dim >::operator[] | ( | const FacetSpec< dim > & | source | ) | const

inline

Returns the other facet to which the given simplex facet is paired.

This is a convenience operator whose behaviour is identical to that of dest(const FacetSpec<dim>&).

If the given facet is left deliberately unmatched, the value returned will be boundary (as returned by FacetSpec<dim>::isBoundary()).

Precondition
  The given facet is a real simplex facet (not boundary, before-the-start or past-the-end).

Parameters

  source | the facet under investigation.

Returns
  the other facet to which the given facet is paired.

## ordering()

template<int dim, int subdim>

static Perm<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

  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.

## orient()

template<int dim>

void regina::detail::TriangulationBase< dim >::orient | ( |  | ) |

Relabels the vertices of top-dimensional simplices in this triangulation so that all simplices are oriented consistently, if possible.

This routine works by flipping vertices (dim - 1) and dim of each top-dimensional simplices that has negative orientation. The result will be a triangulation where the top-dimensional simplices have their vertices labelled in a way that preserves orientation across adjacent facets. In particular, every gluing permutation will have negative sign.

If this triangulation includes both orientable and non-orientable components, the orientable components will be oriented as described above and the non-orientable components will be left untouched.

## orientation()

template<int dim>

int regina::detail::SimplexBase< dim >::orientation | ( |  | ) | const

inline

Returns the orientation of this simplex in the dim-dimensional triangulation.

The orientation of each top-dimensional simplex is always +1 or -1. In an orientable component of a triangulation, adjacent simplices have the same orientations if one could be transposed onto the other without reflection, and they have opposite orientations if a reflection would be required. In a non-orientable component, orientations are arbitrary (but they will still all be +1 or -1).

Returns
  +1 or -1 according to the orientation of this triangle.

## packet()

template<int dim>

Packet * regina::detail::XMLTriangulationReaderBase< dim >::packet | ( |  | ) |

inline override virtual

Returns the newly allocated packet that has been read by this element reader.

Deallocation of this new packet is not the responsibility of this class. Once this routine gives a non-zero return value, it should continue to give the same non-zero return value from this point onwards.

If this routine is ever to give a non-zero return value, it must be giving that non-zero return value by the time the first child packet or packet tag is encountered; otherwise child packets will not be inserted into the packet tree and/or packet tags will not be added.

The newly allocated packet should not be given a packet label. This will be done by XMLPacketReader::endSubElement().

The newly allocated packet may or may not be inserted in the packet tree structure; this does not matter (although if it is inserted it must be inserted in the correct place).

The newly allocated packet should not be given any associated packet tags. This will be done by XMLPacketReader::startSubElement().

The default implementation returns 0.

Returns
  the packet that has been read, or 0 if packet reading is incomplete, the packet should be ignored or an error occurred.

Reimplemented from regina::XMLPacketReader.

## propertyReader()

template<int dim>

XMLElementReader * regina::detail::XMLTriangulationReaderBase< dim >::propertyReader | ( | const std::string & | subTagName,
|  | const regina::xml::XMLPropertyDict & | subTagProps
| ) |  |

inline protected

Returns a reader for the generic triangulation property with the given subtag name.

If subTagName refers to a property that is managed by the generic base class TriangulationBase<dim>, then this routine returns an appropriate element reader. Otherwise this routine returns `null`.

Parameters

  subTagName | the name of the XML subelement opening tag.
  subTagProps | the properties associated with the subelement opening tag.

Returns
  a newly created element reader if the corresponding triangulation property is managed by TriangulationBase<dim>, or `null` otherwise.

## push_back() [1/5]

template<int dim, int codim>

void regina::detail::FaceStorage< dim, codim >::push_back | ( | const FaceEmbedding< dim, dim - codim > & | emb | ) |

inline protected

Internal routine to help build the skeleton of a triangulation.

This routine pushes the given object onto the end of the internal list of appearances of this face within top-dimensional simplices.

Parameters

  emb | the appearance to push onto the end of the internal list.

## push_back() [2/5]

template<int dim>

void regina::detail::BoundaryComponentFaceStorage< dim, false >::push_back | ( | Face< dim, dim-1 > * | face | ) |

inline protected

Pushes the given face onto the end of the list of (dim-1)-faces of this boundary component.

This class does not take ownership of the given face.

Parameters

  face | the face to append to the list.

## push_back() [3/5]

template<int dim>

void regina::detail::BoundaryComponentFaceStorage< dim, false >::push_back | ( | Face< dim, dim-2 > * |  | ) |

inline protected

Increments the number of (dim-2)-faces in this boundary component.

Since this boundary component class does not store any lower-dimensional faces, this routine does not store the given face.

## push_back() [4/5]

template<int dim>
template<int subdim>

void regina::detail::BoundaryComponentFaceStorage< dim, false >::push_back | ( | Face< dim, subdim > * |  | ) |

inline protected

Does nothing, since this boundary component does not store lower-dimensional faces.

Template Parameters

  subdim | the dimension of the given face. This must be between 0 and dim-3 inclusive.

## push_back() [5/5]

template<int dim, bool allFaces_>
template<int subdim>

void regina::detail::BoundaryComponentFaceStorage< dim, allFaces_ >::push_back | ( | Face< dim, subdim > * | face | ) |

inline protected

Pushes the given face onto the end of the list of subdim-faces of this boundary component.

This class does not take ownership of the given face.

Template Parameters

  subdim | the dimension of the face to append. This must be between 0 and dim-1 inclusive.

Parameters

  face | the face to append to the list.

## random()

template<int dim>

Isomorphism< dim > * regina::detail::IsomorphismBase< dim >::random | ( | unsigned | nSimplices | ) |

static

Returns a random isomorphism for the given number of simplices.

This isomorphism will reorder simplices 0 to `nSimplices-1` in a random fashion, and for each simplex a random permutation of its (dim + 1) vertices will be selected.

The isomorphism will be newly constructed, and must be destroyed by the caller of this routine.

Note that both the STL random number generator and the standard C function rand() are used in this routine. All possible isomorphisms for the given number of simplices are equally likely.

Parameters

  nSimplices | the number of simplices that the new isomorphism should operate upon.

Returns
  the newly constructed random isomorphism.

## removeAllSimplices()

template<int dim>

void regina::detail::TriangulationBase< dim >::removeAllSimplices | ( |  | ) |

inline

Removes all simplices from the triangulation.

As a result, this triangulation will become empty.

All of the simplices that belong to this triangulation will be destroyed immediately.

## removeSimplex()

template<int dim>

void regina::detail::TriangulationBase< dim >::removeSimplex | ( | Simplex< dim > * | simplex | ) |

inline

Removes the given top-dimensional simplex from this triangulation.

The given simplex will be unglued from any adjacent simplices (if any), and will be destroyed immediately.

Precondition
  The given simplex is a top-dimensional simplex in this triangulation.

Parameters

  simplex | the simplex to remove.

## removeSimplexAt()

template<int dim>

void regina::detail::TriangulationBase< dim >::removeSimplexAt | ( | size_t | index | ) |

inline

Removes the top-dimensional simplex at the given index in this triangulation.

This is equivalent to calling `removeSimplex(simplex(index))`.

The given simplex will be unglued from any adjacent simplices (if any), and will be destroyed immediately.

Parameters

  index | specifies which top-dimensionalsimplex to remove; this must be between 0 and size()-1 inclusive.

## reorderAndRelabelFaces() [1/4]

template<int dim>

void regina::detail::BoundaryComponentFaceStorage< dim, false >::reorderAndRelabelFaces | ( | Triangulation< dim-1 > * |  | ) | const

inline protected

Reorders all lower-dimensional faces of the given triangulation so that they appear in the same order as the corresponding faces of this boundary component, and relabels these faces so that their vertices are numbered in a corresponding way.

This affects all faces of dimensions 0,...,(dim-2).

In this specialised class template, this function does nothing because faces of dimension 0,...,(dim-2) are not stored.

## reorderAndRelabelFaces() [2/4]

template<int dim, bool allFaces_>

void regina::detail::BoundaryComponentFaceStorage< dim, allFaces_ >::reorderAndRelabelFaces | ( | Triangulation< dim-1 > * | tri | ) | const

inline protected

Reorders all lower-dimensional faces of the given triangulation so that they appear in the same order as the corresponding faces of this boundary component, and relabels these faces so that their vertices are numbered in a corresponding way.

This affects all faces of dimensions 0,...,(dim-2).

Precondition
  This is a real boundary component.
  tri is a triangulation of this boundary component.
  For each i, the ith top-dimensional simplex of tri corresponds to the ith (dim-1)-face of this boundary component, and has its vertices 0,...,(dim-1) labelled in the same way.

Parameters

  tri | a triangulation of this boundary component, as described above.

## reorderAndRelabelFaces() [3/4]

template<int dim, int subdim>
template<int tridim>

void regina::detail::WeakFaceList< dim, subdim >::reorderAndRelabelFaces | ( | Triangulation< tridim > * | tri,
|  | const std::vector< Face< dim, tridim > * > & | tridimFaces
| ) |  | const

inline protected

Reorders and relabels all subdim-faces of the given triangulation so that they appear in the same order as the corresponding faces in this list, and so that their vertices are numbered in a corresponding way.

Precondition
  The subdim-faces of the given triangulation tri are in one-to-one correspondence with the subdim-faces in this list, though not necessarily in the same order. Moreover, for each i and j, this correspondence maps the ith subdim-face of `tri->simplex(j)` to the ith subdim-face of `tridimFaces[j]`.

Template Parameters

  tridim | the dimension of the given triangulation. This must be strictly larger than subdim, but it need not be equal to dim.

Parameters

  tri | a tridim-dimensional triangulation, as described above.
  tridimFaces | a list of tridim-faces that together contain all of the faces in this list, and that are in an ordered one-to-one correspondence with the top-dimensional simplices of tri as described in the precondition above.

## reorderAndRelabelFaces() [4/4]

template<int dim, int subdim>
template<int tridim>

void regina::detail::WeakFaceListSuite< dim, subdim >::reorderAndRelabelFaces | ( | Triangulation< tridim > * | tri,
|  | const std::vector< Face< dim, tridim > * > & | tridimFaces
| ) |  | const

inline protected

Reorders and relabels all faces of all dimensions 0,...,subdim of the given triangulation, so that for each k, the k-faces of the given triangulation appear in the same order as the corresponding k-faces in this suite, and have their vertices numbered in a corresponding way.

Precondition
  For each dimension k = 0,...,subdim, the k-faces of the given triangulation tri are in one-to-one correspondence with the k-faces in this suite, though not necessarily in the same order. Moreover, for each i and j, this correspondence maps the ith k-face of `tri->simplex(j)` to the ith k-face of `tridimFaces[j]`.

Template Parameters

  tridim | the dimension of the given triangulation. This must be strictly larger than subdim, but it need not be equal to dim.

Parameters

  tri | a tridim-dimensional triangulation, as described above.
  tridimFaces | a list of tridim-faces that together contain all of the faces in this suite, and that are in an ordered one-to-one correspondence with the top-dimensional simplices of tri as described in the precondition above.

## ReorderIterator() [1/3]

template<int dim, int subdim>
template<int tridim>

regina::detail::WeakFaceList< dim, subdim >::ReorderIterator< tridim >::ReorderIterator | ( |  | ) |

inline

Creates an uninitialised iterator.

## ReorderIterator() [2/3]

template<int dim, int subdim>
template<int tridim>

regina::detail::WeakFaceList< dim, subdim >::ReorderIterator< tridim >::ReorderIterator | ( | const ReorderIterator< tridim > & |  | ) |

default

Copy constructor.

## ReorderIterator() [3/3]

template<int dim, int subdim>
template<int tridim>

regina::detail::WeakFaceList< dim, subdim >::ReorderIterator< tridim >::ReorderIterator | ( | typename std::vector< Face< dim, subdim > * >::const_iterator | it,
|  | Face< tridim, subdim > ** | map
| ) |  |

inline

Creates an iterator that points to the given face of this list, using the given map to convert faces of this list to faces of the other triangulation tri.

See the iterator class notes for details.

## sameDegrees() [1/3]

template<int dim, int subdim>

bool regina::detail::FaceListSuite< dim >::sameDegrees | ( | const FaceListSuite< dim, subdim > & | other | ) | const

inline protected

Tests whether this and the given triangulation have the same k-face degree sequences, for each facial dimension k ≤ subdim.

For the purposes of this routine, degree sequences are considered to be unordered.

Precondition
  This and the given triangulation are known to have the same number of k-faces as each other, for each facial dimension k ≤ subdim.

Parameters

  other | the triangulation to compare against this.

Returns
  `true` if and only if all degree sequences considered are equal.

## sameDegrees() [2/3]

template<int dim, int subdim>

bool regina::detail::SimplexFaces< dim, subdim >::sameDegrees | ( | const SimplexFaces< dim, subdim > & | other,
|  | Perm< dim+1 > | p
| ) |  | const

protected

Tests whether the subdim-face degrees of this and the given simplex are identical, under the given relabelling.

Parameters

  other | the simplex to compare against this.
  p | a mapping from the vertices of this simplex to the vertices of other.

Returns
  `true` if and only if, for every i, subdim-face number i of this simplex has the same degree as its image in other under the relabelling p.

## sameDegrees() [3/3]

template<int dim, int subdim>

bool regina::detail::SimplexFacesSuite< dim >::sameDegrees | ( | const SimplexFacesSuite< dim, subdim > & | other,
|  | Perm< dim+1 > | p
| ) |  | const

inline protected

Tests whether the k-face degrees of this and the given simplex are identical, under the given relabelling, for all faces of all dimensions k ≤ subdim.

Parameters

  other | the simplex to compare against this.
  p | a mapping from the vertices of this simplex to the vertices of other.

Returns
  `true` if and only if, for every i and every facial dimension k ≤ subdim, k-face number i of this simplex has the same degree as its image in other under the relabelling p.

## sameFVector()

template<int dim, int subdim>

bool regina::detail::FaceListSuite< dim >::sameFVector | ( | const FaceListSuite< dim, subdim > & | other | ) | const

inline protected

Tests whether this and the given triangulation have the same number of k-faces, for each facial dimension k ≤ subdim.

Parameters

  other | the triangulation to compare against this.

Returns
  `true` if and only if the face counts considered are identical for both triangluations.

## setDescription()

template<int dim>

void regina::detail::SimplexBase< dim >::setDescription | ( | const std::string & | desc | ) |

inline

Sets the description associated with this simplex.

This may be any text whatsoever; typically it is intended to be human-readable. Descriptions do not need to be unique.

To remove an existing description, you can simply set the description to the empty string.

Parameters

  desc | the new description to assign to this simplex.

## simpImage() [1/2]

template<int dim>

int & regina::detail::IsomorphismBase< dim >::simpImage | ( | unsigned | sourceSimp | ) |

inline

Determines the image of the given source simplex under this isomorphism.

Python:\n This is not available for Python users.
  However, the read-only version of this routine is.

Parameters

  sourceSimp | the index of the source simplex; this must be between 0 and `size()-1` inclusive.

Returns
  a reference to the index of the destination simplex that the source simplex maps to.

## simpImage() [2/2]

template<int dim>

int regina::detail::IsomorphismBase< dim >::simpImage | ( | unsigned | sourceSimp | ) | const

inline

Determines the image of the given source simplex under this isomorphism.

Parameters

  sourceSimp | the index of the source simplex; this must be between 0 and `size()-1` inclusive.

Returns
  the index of the destination simplex that the source simplex maps to.

## simplex() [1/5]

template<int dim>

constexpr static const char* regina::detail::XMLTriangulationTags< dim >::simplex | ( |  | ) |

static constexpr

The XML tag that stores a single top-dimensional simplex in a dim-dimensional triangulation.

## simplex() [2/5]

template<int dim, int subdim>

Simplex< dim > * regina::detail::FaceEmbeddingBase< dim, subdim >::simplex | ( |  | ) | const

inline

Returns the top-dimensional simplex in which the underlying subdim-face of the triangulation is contained.

Returns
  the top-dimensional simplex.

## simplex() [3/5]

template<int dim>

Simplex< dim > * regina::detail::TriangulationBase< dim >::simplex | ( | size_t | index | ) |

inline

Returns the top-dimensional simplex at the given index in the triangulation.

Note that indexing may change when a simplex is added to or removed from the triangulation.

Parameters

  index | specifies which simplex to return; this value should be between 0 and size()-1 inclusive.

Returns
  the indexth top-dimensional simplex.

## simplex() [4/5]

template<int dim>

Simplex< dim > * regina::detail::ComponentBase< dim >::simplex | ( | size_t | index | ) | const

inline

Returns the top-dimensional simplex at the given index in this component.

Note that the index within this component may not be the same as the index within the overall triangulation.

Parameters

  index | specifies which simplex to return; this value should be between 0 and size()-1 inclusive.

Returns
  the indexth top-dimensional simplex.

## simplex() [5/5]

template<int dim>

const Simplex< dim > * regina::detail::TriangulationBase< dim >::simplex | ( | size_t | index | ) | const

inline

Returns the top-dimensional simplex at the given index in the triangulation.

Note that indexing may change when a simplex is added to or removed from the triangulation.

Parameters

  index | specifies which simplex to return; this value should be between 0 and size()-1 inclusive.

Returns
  the indexth top-dimensional simplex.

## SimplexBase() [1/2]

template<int dim>

regina::detail::SimplexBase< dim >::SimplexBase | ( | const std::string & | desc,
|  | Triangulation< dim > * | tri
| ) |  |

inline protected

Creates a new simplex with the given description and no facets joined to anything.

Parameters

  desc | the description to give the new simplex.
  tri | the triangulation to which the new simplex belongs.

## SimplexBase() [2/2]

template<int dim>

regina::detail::SimplexBase< dim >::SimplexBase | ( | Triangulation< dim > * | tri | ) |

inline protected

Creates a new simplex with no description and no facets joined to anything.

Parameters

  tri | the triangulation to which the new simplex belongs.

## SimplexFaces()

template<int dim, int subdim>

regina::detail::SimplexFaces< dim, subdim >::SimplexFaces | ( | const SimplexFaces< dim, subdim > & |  | ) |

delete

Explicitly disable the copy constructor.

## simplices() [1/3]

template<int dim>

constexpr static const char* regina::detail::XMLTriangulationTags< dim >::simplices | ( |  | ) |

static constexpr

The XML tag that stores the set of all top-dimensional simplices for a dim-dimensional triangulation.

## simplices() [2/3]

template<int dim>

const std::vector< Simplex< dim > * > & regina::detail::ComponentBase< dim >::simplices | ( |  | ) | const

inline

Returns all top-dimensional simplices in this component.

The reference that is returned will remain valid only for as long as this component object exists. In particular, the reference will become invalid any time that the triangulation changes (since all component objects will be destroyed and others rebuilt in their place).

Python:\n This routine returns a python list.

Returns
  the list of all top-dimensional simplices.

## simplices() [3/3]

template<int dim>

const std::vector< Simplex< dim > * > & regina::detail::TriangulationBase< dim >::simplices | ( |  | ) | const

inline

Returns all top-dimensional simplices in the triangulation.

The reference that is returned will remain valid for as long as the triangulation exists: even as simplices are added and/or removed, it will always reflect the simplices that are currently in the triangulation.

Python:\n This routine returns a python list.

Returns
  the list of all top-dimensional simplices.

## simplicialSphere()

template<int dim>

Triangulation< dim > * regina::detail::ExampleBase< dim >::simplicialSphere | ( |  | ) |

static

Returns the standard (dim+2)-simplex triangulation of the dim-sphere as the boundary of a (dim+1)-simplex.

Returns
  a newly constructed triangulation, which must be destroyed by the caller of this routine.

## simplifiedFundamentalGroup()

template<int dim>

void regina::detail::TriangulationBase< dim >::simplifiedFundamentalGroup | ( | GroupPresentation * | newGroup | ) |

inline

Notifies the triangulation that you have simplified the presentation of its fundamental group.

The old group presentation will be destroyed, and this triangulation will take ownership of the new (hopefully simpler) group that is passed.

This routine is useful for situations in which some external body (such as GAP) has simplified the group presentation better than Regina can.

Regina does not verify that the new group presentation is equivalent to the old, since this is - well, hard.

If the fundamental group has not yet been calculated for this triangulation, this routine will nevertheless take ownership of the new group, under the assumption that you have worked out the group through some other clever means without ever having needed to call fundamentalGroup() at all.

Note that this routine will not fire a packet change event.

Parameters

  newGroup | a new (and hopefully simpler) presentation of the fundamental group of this triangulation.

## singleCone()

template<int dim, bool available>

Triangulation< dim > * regina::detail::ExampleFromLowDim< dim, available >::singleCone | ( | const Triangulation< dim-1 > & | base | ) |

static

Returns a single cone over the given (dim-1)-dimensional triangulation.

If the given triangulation represents the manifold `M`, then this returns a triangulation of the product `M x I` that has one real boundary component and one ideal boundary component. The triangulation of the real boundary component will be identical to the original (dim-1)-dimensional triangulation base.

Warning
  If the given (dim-1)-dimensional triangulation has any boundary whatsoever (either real or ideal), then unless it is a (dim-1)-ball, you will obtain an invalid dim-manifold triangulation as a result.

Returns
  a newly constructed triangulation, which must be destroyed by the caller of this routine.

## size() [1/7]

template<int dim>

constexpr static const char* regina::detail::XMLTriangulationTags< dim >::size | ( |  | ) |

static constexpr

The XML attribute that stores the number of top-dimensional simplices in a dim-dimensional triangulation.

## size() [2/7]

template<int dim>

unsigned regina::detail::IsomorphismBase< dim >::size | ( |  | ) | const

inline

Returns the number of simplices in the source triangulation associated with this isomorphism.

Note that this is always less than or equal to the number of simplices in the destination triangulation.

Returns
  the number of simplices in the source triangulation.

## size() [3/7]

template<int dim>

size_t regina::detail::ComponentBase< dim >::size | ( |  | ) | const

inline

Returns the number of top-dimensional simplices in this component.

Returns
  The number of top-dimensional simplices.

## size() [4/7]

template<int dim>

size_t regina::detail::FacetPairingBase< dim >::size | ( |  | ) | const

inline

Returns the number of simplices whose facets are described by this facet pairing.

Returns
  the number of simplices under consideration.

## size() [5/7]

template<int dim, bool allFaces_>

size_t regina::detail::BoundaryComponentFaceStorage< dim, allFaces_ >::size | ( |  | ) | const

inline

Returns the number of (dim-1)-faces in this boundary component.

These are the top-dimensional faces for a real boundary component.

If this is an ideal or invalid vertex boundary component, then this routine will return 0.

Returns
  the number of (dim-1)-faces in this boundary component.

## size() [6/7]

template<int dim>

size_t regina::detail::TriangulationBase< dim >::size | ( |  | ) | const

inline

Returns the number of top-dimensional simplices in the triangulation.

Returns
  The number of top-dimensional simplices.

## size() [7/7]

template<int dim>

size_t regina::detail::BoundaryComponentFaceStorage< dim, false >::size | ( |  | ) | const

inline

Returns the number of (dim-1)-faces in this boundary component.

These are the top-dimensional faces for a real boundary component.

Returns
  the number of (dim-1)-faces in this boundary component.

## sphere()

template<int dim>

Triangulation< dim > * regina::detail::ExampleBase< dim >::sphere | ( |  | ) |

static

Returns a two-simplex triangulation of the dim-sphere.

Returns
  a newly constructed triangulation, which must be destroyed by the caller of this routine.

## sphereBundle()

template<int dim>

Triangulation< dim > * regina::detail::ExampleBase< dim >::sphereBundle | ( |  | ) |

static

Returns a two-simplex triangulation of the product space `S^(dim-1) x S^1`.

Returns
  a newly constructed triangulation, which must be destroyed by the caller of this routine.

## splitIntoComponents()

template<int dim>

size_t regina::detail::TriangulationBase< dim >::splitIntoComponents | ( | Packet * | componentParent = `0`,
|  | bool | setLabels = `true`
| ) |  |

Splits a disconnected triangulation into many smaller triangulations, one for each component.

The new component triangulations will be inserted as children of the given parent packet. The original triangulation (i.e., this triangulation) will be left unchanged.

If the given parent packet is 0, the new component triangulations will be inserted as children of this triangulation.

By default, this routine will assign sensible packet labels to each of the new component triangulations. If these component triangulations are only temporary objects used as part of some larger algorithm, then labels are unnecessary - in this case you can pass setLabels as `false` to avoid the (small) overhead that these packet labels incur.

Parameters

  componentParent | the packet beneath which the new component triangulations will be inserted, or 0 if they should be inserted directly beneath this triangulation.
  setLabels | `true` if the new component triangulations should be assigned sensible packet labels, or `false` if they should be left without labels at all.

Returns
  the number of new component triangulations constructed.

## startContentSubElement()

template<int dim>

XMLElementReader * regina::detail::XMLTriangulationReaderBase< dim >::startContentSubElement | ( | const std::string & | subTagName,
|  | const regina::xml::XMLPropertyDict & | subTagProps
| ) |  |

override virtual

Used instead of startSubElement() for XML subelements that are not child packets or packet tags.

The default implementation returns a new XMLElementReader which can be used to ignore the subelement completely.

Parameters

  subTagName | the name of the subelement opening tag.
  subTagProps | the properties associated with the subelement opening tag.

Returns
  a newly created element reader that will be used to parse the subelement. This class should not take care of the new reader's destruction; that will be done by the parser.

Reimplemented from regina::XMLPacketReader.

## startElement() [1/2]

template<int dim>

void regina::detail::XMLSimplexReader< dim >::startElement | ( | const std::string & | tagName,
|  | const regina::xml::XMLPropertyDict & | tagProps,
|  | XMLElementReader * | parentReader
| ) |  |

inline virtual

Signifies that parsing of this XML element is beginning.

The default implementation does nothing.

Parameters

  tagName | the name of the opening tag for this element.
  tagProps | the properties associated with the opening tag.
  parentReader | the reader currently parsing the parent XML element, or 0 if this is the top-level element. If this paraneter is non-zero, it is guaranteed that startSubElement() has already been called upon the parent reader.

Reimplemented from regina::XMLElementReader.

## startElement() [2/2]

template<int dim>

void regina::detail::XMLSimplicesReader< dim >::startElement | ( | const std::string & | tagName,
|  | const regina::xml::XMLPropertyDict & | tagProps,
|  | XMLElementReader * | parentReader
| ) |  |

virtual

Signifies that parsing of this XML element is beginning.

The default implementation does nothing.

Parameters

  tagName | the name of the opening tag for this element.
  tagProps | the properties associated with the opening tag.
  parentReader | the reader currently parsing the parent XML element, or 0 if this is the top-level element. If this paraneter is non-zero, it is guaranteed that startSubElement() has already been called upon the parent reader.

Reimplemented from regina::XMLElementReader.

## startSubElement() [1/3]

template<int dim>

XMLElementReader * regina::detail::XMLSimplicesReader< dim >::startSubElement | ( | const std::string & | subTagName,
|  | const regina::xml::XMLPropertyDict & | subTagProps
| ) |  |

virtual

Signifies that a subelement of this XML element is about to be parsed.

The default implementation returns a new XMLElementReader which can be used to ignore the subelement completely.

Parameters

  subTagName | the name of the subelement opening tag.
  subTagProps | the properties associated with the subelement opening tag.

Returns
  a newly created element reader that will be used to parse the subelement. This class should not take care of the new reader's destruction; that will be done by the parser.

Reimplemented from regina::XMLElementReader.

## startSubElement() [2/3]

template<int dim>

XMLElementReader * regina::detail::XMLTriangulationReaderBase< dim >::AbelianGroupPropertyReader::startSubElement | ( | const std::string & | subTagName,
|  | const regina::xml::XMLPropertyDict & | subTagProps
| ) |  |

inline virtual

Signifies that a subelement of this XML element is about to be parsed.

The default implementation returns a new XMLElementReader which can be used to ignore the subelement completely.

Parameters

  subTagName | the name of the subelement opening tag.
  subTagProps | the properties associated with the subelement opening tag.

Returns
  a newly created element reader that will be used to parse the subelement. This class should not take care of the new reader's destruction; that will be done by the parser.

Reimplemented from regina::XMLElementReader.

## startSubElement() [3/3]

template<int dim>

XMLElementReader * regina::detail::XMLTriangulationReaderBase< dim >::GroupPresentationPropertyReader::startSubElement | ( | const std::string & | subTagName,
|  | const regina::xml::XMLPropertyDict & | subTagProps
| ) |  |

inline virtual

Signifies that a subelement of this XML element is about to be parsed.

The default implementation returns a new XMLElementReader which can be used to ignore the subelement completely.

Parameters

  subTagName | the name of the subelement opening tag.
  subTagProps | the properties associated with the subelement opening tag.

Returns
  a newly created element reader that will be used to parse the subelement. This class should not take care of the new reader's destruction; that will be done by the parser.

Reimplemented from regina::XMLElementReader.

## swapBaseProperties()

template<int dim>

void regina::detail::TriangulationBase< dim >::swapBaseProperties | ( | TriangulationBase< dim > & | other | ) |

protected

Swaps all properties that are managed by this base class, including skeletal data, with the given triangulation.

Note that TriangulationBase never calls this routine itself. Typically swapBaseProperties() is only ever called by Triangulation<dim>::swapAllProperties(), which in turn is called by swapContents().

Parameters

  other | the triangulation whose properties should be swapped with this.

## swapContents()

template<int dim>

void regina::detail::TriangulationBase< dim >::swapContents | ( | Triangulation< dim > & | other | ) |

Swaps the contents of this and the given triangulation.

All top-dimensional simplices that belong to this triangulation will be moved to other, and all top-dimensional simplices that belong to other will be moved to this triangulation. Likewise, all skeletal objects (such as lower-dimensional faces, components, and boundary components) and all cached properties (such as homology and fundamental group) will be swapped.

In particular, any pointers or references to Simplex<dim> and/or Face<dim, subdim> objects will remain valid.

This routine will behave correctly if other is in fact this triangulation.

Parameters

  other | the triangulation whose contents should be swapped with this.

## swapFaces()

template<int dim, int subdim>

void regina::detail::FaceListSuite< dim >::swapFaces | ( | FaceListSuite< dim, subdim > & | other | ) |

inline protected

Swaps all faces of dimension subdim and below with those of the given triangulation.

Parameters

  other | the face storage for the triangulation whose faces are to be swapped with this.

## toTextRep()

template<int dim>

std::string regina::detail::FacetPairingBase< dim >::toTextRep | ( |  | ) | const

Returns a text-based representation of this facet pairing that can be used to reconstruct the facet pairing.

This reconstruction is done through routine fromTextRep().

The text produced is not particularly readable; for a human-readable text representation, see routine str() instead.

The string returned will contain no newlines.

Returns
  a text-based representation of this facet pairing.

## triangulation() [1/4]

template<int dim>

Triangulation< dim > * regina::detail::SimplexBase< dim >::triangulation | ( |  | ) | const

inline

Returns the triangulation to which this simplex belongs.

Returns
  the triangulation containing this simplex.

## triangulation() [2/4]

template<int dim, bool allFaces_>

Triangulation<dim>* regina::detail::BoundaryComponentFaceStorage< dim, allFaces_ >::triangulation | ( |  | ) | const

inline

Returns the triangulation to which this boundary component belongs.

Returns
  the triangulation containing this boundary component.

## triangulation() [3/4]

template<int dim>

Triangulation<dim>* regina::detail::BoundaryComponentFaceStorage< dim, false >::triangulation | ( |  | ) | const

inline

Returns the triangulation to which this boundary component belongs.

Returns
  the triangulation containing this boundary component.

## triangulation() [4/4]

template<int dim, int subdim>

Triangulation< dim > * regina::detail::FaceBase< dim, subdim >::triangulation | ( |  | ) | const

inline

Returns the triangulation to which this face belongs.

Returns
  the triangulation containing this face.

## TriangulationBase() [1/3]

template<int dim>

regina::detail::TriangulationBase< dim >::TriangulationBase | ( |  | ) |

inline

Default constructor.

Creates an empty triangulation.

## TriangulationBase() [2/3]

template<int dim>

regina::detail::TriangulationBase< dim >::TriangulationBase | ( | const TriangulationBase< dim > & | copy | ) |

inline

Creates a new copy of the given triangulation.

This will clone any computed properties (such as homology, fundamental group, and so on) of the given triangulation also. If you want a "clean" copy that resets all properties to unknown, you can use the two-argument copy constructor instead.

Parameters

  copy | the triangulation to copy.

## TriangulationBase() [3/3]

template<int dim>

regina::detail::TriangulationBase< dim >::TriangulationBase | ( | const TriangulationBase< dim > & | copy,
|  | bool | cloneProps
| ) |  |

Creates a new copy of the given triangulation, with the option of whether or not to clone its computed properties also.

Parameters

  copy | the triangulation to copy.
  cloneProps | `true` if this should also clone any computed properties of the given triangulation (such as homology, fundamental group, and so on), or `false` if the new triangulation should have all properties marked as unknown.

## twistedBallBundle()

template<int dim>

Triangulation< dim > * regina::detail::ExampleBase< dim >::twistedBallBundle | ( |  | ) |

static

Returns a triangulation of the twisted product space `B^(dim-1) x~ S^1`.

This will use one simplex in even dimensions, or two simplices in odd dimensions.

Returns
  a newly constructed triangulation, which must be destroyed by the caller of this routine.

## twistedSphereBundle()

template<int dim>

Triangulation< dim > * regina::detail::ExampleBase< dim >::twistedSphereBundle | ( |  | ) |

static

Returns a two-simplex triangulation of the twisted product space `S^(dim-1) x~ S^1`.

Returns
  a newly constructed triangulation, which must be destroyed by the caller of this routine.

## unjoin()

template<int dim>

Simplex< dim > * regina::detail::SimplexBase< dim >::unjoin | ( | int | myFacet | ) |

Unglues the given facet of this simplex from whatever it is joined to.

As a result, the given facet of this simplex will become a boundary facet.

If there was an adjacent simplex to begin with, then this other simplex will be updated automatically (i.e., you only need to call unjoin() from one side of the gluing).

This routine is safe to call even if the given facet is already a boundary facet (in which case it will do nothing).

Parameters

  myFacet | the facet of this simplex whose gluing we will undo. This should be between 0 and dim inclusive.

Returns
  the simplex that was originally glued to the given facet of this simplex, or 0 if this was already a boundary facet.

## vertices()

template<int dim, int subdim>

Perm< dim+1 > regina::detail::FaceEmbeddingBase< dim, subdim >::vertices | ( |  | ) | const

inline

Maps vertices (0,...,subdim) of the underlying subdim-face of the triangulation to the corresponding vertex numbers of simplex().

If the link of the underlying subdim-face is orientable, then this permutation also maps (subdim+1, ..., dim) to the remaining vertex numbers of simplex() in a manner that preserves orientation as you walk through the many different FaceEmbedding objects for the same underlying subdim-face.

This routine returns the same permutation as `simplex().faceMapping<subdim>(face())`. See Simplex<dim>::faceMapping() for details.

Returns
  a mapping from the vertices of the underlying subdim-face to the corresponding vertices of simplex().

## writeDot()

template<int dim>

void regina::detail::FacetPairingBase< dim >::writeDot | ( | std::ostream & | out,
|  | const char * | prefix = `0`,
|  | bool | subgraph = `false`,
|  | bool | labels = `false`
| ) |  | const

Writes the graph corresponding to this facet pairing in the Graphviz DOT language.

Every vertex of this graph represents a simplex, and every edge represents a pair of simplex facets that are joined together. Note that for a closed triangulation this graph will be entirely (dim + 1)-valent; for triangulations with boundary facets, some graph vertices will have degree dim or less.

The graph can either be written as a complete DOT graph, or as a clustered subgraph within some larger DOT graph (according to whether the argument subgraph is passed as `false` or `true`).

If a complete DOT graph is being written, the output may be used as a standalone DOT file ready for use with Graphviz.

If a subgraph is being written, the output will contain a single `subgraph` section that should be inserted into some larger DOT file. Note that the output generated by writeDotHeader(), followed by one or more subgraphs and then a closing curly brace will suffice. The subgraph name will begin with the string `pairing_`.

The argument prefix will be prepended to the name of each graph vertex, and will also be used in the name of the graph or subgraph. Using unique prefixes becomes important if you are calling writeDot() several times to generate several subgraphs for use in a single DOT file. If the prefix argument is null or empty then a default prefix will be used.

Note that this routine generates undirected graphs, not directed graphs. The final DOT file should be used with either the neato or fdp programs shipped with Graphviz.

Python:\n The out argument is not present; instead
  standard output is assumed.

Parameters

  out | the output stream to which to write.
  prefix | a string to prepend to the name of each graph vertex, and to include in the graph or subgraph name; see above for details.
  subgraph | `false` if a complete standalone DOT graph should be output, or `true` if a clustered subgraph should be output for use in some larger DOT file.
  labels | indicates whether graph vertices will be labelled with the corresponding simplex numbers. This feature is currently experimental, and the default is `false`.

See also
  http://www.graphviz.org/

## writeDotHeader()

template<int dim>

static void regina::detail::FacetPairingBase< dim >::writeDotHeader | ( | std::ostream & | out,
|  | const char * | graphName = `0`
| ) |  |

static

Writes header information for a Graphviz DOT file that will describe the graphs for one or more facet pairings.

See the writeDot() documentation for further information on such graphs.

The output will be in the Graphviz DOT language, and will include appropriate display settings for graphs, edges and nodes. The opening brace for a `graph` section of the DOT file is included.

This routine may be used with writeDot() to generate a single DOT file containing the graphs for several different facet pairings. A complete DOT file can be produced by calling this routine, then calling writeDot() in subgraph mode for each facet pairing, then outputting a final closing curly brace.

Note that if you require a DOT file containing the graph for only a single facet pairing, this routine is unnecessary; you may simply call writeDot() in full graph mode instead.

This routine is suitable for generating undirected graphs, not directed graphs. The final DOT file should be used with either the neato or fdp programs shipped with Graphviz.

Python:\n The out argument is not present; instead
  standard output is assumed.

Parameters

  out | the output stream to which to write.
  graphName | the name of the graph in the DOT file. If this is null or empty then a default graph name will be used.

See also
  http://www.graphviz.org/

## writeTextLong() [1/6]

template<int dim>

void regina::detail::ComponentBase< dim >::writeTextLong | ( | std::ostream & | out | ) | const

Writes a detailed text representation of this object to the given output stream.

Python:\n Not present.

Parameters

  out | the output stream to which to write.

## writeTextLong() [2/6]

template<int dim>

void regina::detail::IsomorphismBase< dim >::writeTextLong | ( | std::ostream & | out | ) | const

inline

Writes a detailed text representation of this object to the given output stream.

Python:\n Not present.

Parameters

  out | the output stream to which to write.

## writeTextLong() [3/6]

template<int dim>

void regina::detail::SimplexBase< dim >::writeTextLong | ( | std::ostream & | out | ) | const

Writes a detailed text representation of this object to the given output stream.

Python:\n Not present.

Parameters

  out | the output stream to which to write.

## writeTextLong() [4/6]

template<int dim, bool allFaces, bool allowVertex_>

void regina::detail::BoundaryComponentFaceInterface< dim, allFaces, allowVertex_ >::writeTextLong | ( | std::ostream & | out | ) | const

inline

Writes a detailed text representation of this object to the given output stream.

Python:\n Not present.

Parameters

  out | the output stream to which to write.

## writeTextLong() [5/6]

template<int dim, bool allFaces>

void regina::detail::BoundaryComponentFaceInterface< dim, allFaces, false >::writeTextLong | ( | std::ostream & | out | ) | const

inline

Writes a detailed text representation of this object to the given output stream.

Python:\n Not present.

Parameters

  out | the output stream to which to write.

## writeTextLong() [6/6]

template<int dim, int subdim>

void regina::detail::FaceBase< dim, subdim >::writeTextLong | ( | std::ostream & | out | ) | const

Writes a detailed text representation of this object to the given output stream.

The class Face<dim, subdim> may safely override this function, since the output routines cast down to Face<dim, subdim> before calling it.

Python:\n Not present.

Parameters

  out | the output stream to which to write.

## writeTextShort() [1/8]

template<int dim, int subdim>

void regina::detail::FaceEmbeddingBase< dim, subdim >::writeTextShort | ( | std::ostream & | out | ) | const

inline

Writes a short text representation of this object to the given output stream.

Python:\n Not present.

Parameters

  out | the output stream to which to write.

## writeTextShort() [2/8]

template<int dim>

void regina::detail::ComponentBase< dim >::writeTextShort | ( | std::ostream & | out | ) | const

Writes a short text representation of this object to the given output stream.

Python:\n Not present.

Parameters

  out | the output stream to which to write.

## writeTextShort() [3/8]

template<int dim>

void regina::detail::IsomorphismBase< dim >::writeTextShort | ( | std::ostream & | out | ) | const

inline

Writes a short text representation of this object to the given output stream.

Python:\n Not present.

Parameters

  out | the output stream to which to write.

## writeTextShort() [4/8]

template<int dim>

void regina::detail::FacetPairingBase< dim >::writeTextShort | ( | std::ostream & | out | ) | const

Writes a human-readable representation of this facet pairing to the given output stream.

The string returned will contain no newlines.

Python:\n Not present.

Parameters

  out | the output stream to which to write.

## writeTextShort() [5/8]

template<int dim>

void regina::detail::SimplexBase< dim >::writeTextShort | ( | std::ostream & | out | ) | const

inline

Writes a short text representation of this object to the given output stream.

Python:\n Not present.

Parameters

  out | the output stream to which to write.

## writeTextShort() [6/8]

template<int dim, bool allFaces, bool allowVertex_>

void regina::detail::BoundaryComponentFaceInterface< dim, allFaces, allowVertex_ >::writeTextShort | ( | std::ostream & | out | ) | const

inline

Writes a short text representation of this object to the given output stream.

Python:\n Not present.

Parameters

  out | the output stream to which to write.

## writeTextShort() [7/8]

template<int dim, bool allFaces>

void regina::detail::BoundaryComponentFaceInterface< dim, allFaces, false >::writeTextShort | ( | std::ostream & | out | ) | const

inline

Writes a short text representation of this object to the given output stream.

Python:\n Not present.

Parameters

  out | the output stream to which to write.

## writeTextShort() [8/8]

template<int dim, int subdim>

void regina::detail::FaceBase< dim, subdim >::writeTextShort | ( | std::ostream & | out | ) | const

inline

Writes a short text representation of this object to the given output stream.

The class Face<dim, subdim> may safely override this function, since the output routines cast down to Face<dim, subdim> before calling it.

Python:\n Not present.

Parameters

  out | the output stream to which to write.

## writeXMLBaseProperties()

template<int dim>

void regina::detail::TriangulationBase< dim >::writeXMLBaseProperties | ( | std::ostream & | out | ) | const

protected

Writes a chunk of XML containing properties of this triangulation.

This routine covers those properties that are managed by this base class TriangulationBase and that have already been computed for this triangulation.

This routine is typically called from within Triangulation<dim>::writeXMLPacketData(). The XML elements that it writes are child elements of the `packet` element.

Parameters

  out | the output stream to which the XML should be written.

## XMLSimplexReader()

template<int dim>

regina::detail::XMLSimplexReader< dim >::XMLSimplexReader | ( | Triangulation< dim > * | tri,
|  | size_t | whichSimplex
| ) |  |

inline

Creates a new simplex element reader.

Precondition
  The given triangulation tri already contains at least (whichSimplex + 1) top-dimensional simplices.

Parameters

  tri | the triangulation containing the simplex being read.
  whichSimplex | the index of the simplex being read within the triangulation tri.

## XMLSimplicesReader()

template<int dim>

regina::detail::XMLSimplicesReader< dim >::XMLSimplicesReader | ( | Triangulation< dim > * | tri | ) |

inline

Creates a new simplices element reader.

The given triangulation should be empty; its simplices will be created by this reader.

Parameters

  tri | the triangulation being read.

## XMLTriangulationReaderBase()

template<int dim>

regina::detail::XMLTriangulationReaderBase< dim >::XMLTriangulationReaderBase | ( | XMLTreeResolver & | resolver | ) |

inline

Creates a new triangulation reader.

Parameters

  resolver | the master resolver that will be used to fix dangling packet references after the entire XML file has been read.

## ~BoundaryComponentStorage()

template<int dim, bool allFaces, bool allowVertex, bool canBuild_>

regina::detail::BoundaryComponentStorage< dim, allFaces, allowVertex, canBuild_ >::~BoundaryComponentStorage | ( |  | ) |

Destroys this object.

The cached boundary component triangulation will be destroyed also.

## ~FacetPairingBase()

template<int dim>

regina::detail::FacetPairingBase< dim >::~FacetPairingBase | ( |  | ) |

inline

Deallocates any memory used by this structure.

## ~IsomorphismBase()

template<int dim>

regina::detail::IsomorphismBase< dim >::~IsomorphismBase | ( |  | ) |

inline

Destroys this isomorphism.

## ~TriangulationBase()

template<int dim>

regina::detail::TriangulationBase< dim >::~TriangulationBase | ( |  | ) |

inline

Destroys this triangulation.

The simplices within this triangulation will also be destroyed.

## Variable Documentation

## allFaces [1/2]

template<int dim, bool allFaces_>

constexpr bool regina::detail::BoundaryComponentFaceStorage< dim, allFaces_ >::allFaces = true

static constexpr

A compile-time constant indicating whether this boundary component class stores all lower-dimensional faces (`true`), or only faces of dimension dim-1 (`false`).

This is a compile-time constant only, with no linkage - any attempt to create a reference or pointer to it will give a linker error.

Python:\n Not present.

## allFaces [2/2]

template<int dim>

constexpr bool regina::detail::BoundaryComponentFaceStorage< dim, false >::allFaces = false

static constexpr

A compile-time constant indicating whether this boundary component class stores all lower-dimensional faces (`true`), or only faces of dimension dim-1 (`false`).

This is a compile-time constant only, with no linkage - any attempt to create a reference or pointer to it will give a linker error.

Python:\n Not present.

## allowVertex [1/2]

template<int dim, bool allFaces, bool allowVertex_>

constexpr bool regina::detail::BoundaryComponentFaceInterface< dim, allFaces, allowVertex_ >::allowVertex = true

static constexpr

A compile-time constant indicating whether ideal and/or invalid vertex boundary components are both possible and recognised by this boundary component class.

This is a compile-time constant only, with no linkage - any attempt to create a reference or pointer to it will give a linker error.

Python:\n Not present.

## allowVertex [2/2]

template<int dim, bool allFaces>

constexpr bool regina::detail::BoundaryComponentFaceInterface< dim, allFaces, false >::allowVertex = false

static constexpr

A compile-time constant indicating whether ideal and/or invalid vertex boundary components are both possible and recognised by this boundary component class.

This is a compile-time constant only, with no linkage - any attempt to create a reference or pointer to it will give a linker error.

Python:\n Not present.

## binomSmall_

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

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

For all values 0 ≤ k ≤ n ≤ 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.

## boundary_

template<int dim, bool allFaces, bool allowVertex, bool canBuild_>

Triangulation<dim-1>* regina::detail::BoundaryComponentStorage< dim, allFaces, allowVertex, canBuild_ >::boundary_

protected

A full triangulation of the boundary component.

This may be pre-computed when the triangulation skeleton is constructed, or it may be `null` in which case it will be built on demand. For ideal or invalid vertices, this is always `null` since the triangulation is cached by the vertex class instead.

## boundaryComponents_

template<int dim>

MarkedVector<BoundaryComponent<dim> > regina::detail::TriangulationBase< dim >::boundaryComponents_

protected

The components that form the boundary of the triangulation.

## canBuild [1/2]

template<int dim, bool allFaces, bool allowVertex, bool canBuild_>

constexpr bool regina::detail::BoundaryComponentStorage< dim, allFaces, allowVertex, canBuild_ >::canBuild = true

static constexpr

A compile-time constant indicating whether this boundary component class supports triangulating boundary components.

This is a compile-time constant only, with no linkage - any attempt to create a reference or pointer to it will give a linker error.

Python:\n Not present.

## canBuild [2/2]

template<int dim, bool allFaces, bool allowVertex>

constexpr bool regina::detail::BoundaryComponentStorage< dim, allFaces, allowVertex, false >::canBuild = false

static constexpr

A compile-time constant indicating whether this boundary component class supports triangulating boundary components.

This is a compile-time constant only, with no linkage - any attempt to create a reference or pointer to it will give a linker error.

Python:\n Not present.

## dim

template<int dim_>

constexpr const char* regina::detail::Strings< dim_ >::dim

static constexpr

A string that gives the dimension dim as a number.

An example for dim = 3 is "3".

## dimension

template<int dim>

constexpr int regina::detail::TriangulationBase< dim >::dimension = dim

static constexpr

A compile-time constant that gives the dimension of the triangulation.

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

## edgeVertex [2/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]`.

## face

template<int dim_>

constexpr const char* regina::detail::Strings< dim_ >::face

static constexpr

A string that gives the name of a dim-face, all in lower case.

An example for dim = 3 is "tetrahedron". An example for dim = 7 is "7-face".

## Face

template<int dim_>

constexpr const char* regina::detail::Strings< dim_ >::Face

static constexpr

A string that gives the name of a dim-face, with the first word capitalised.

An example for dim = 3 is "Tetrahedron". An example for dim = 7 is "7-face".

## face_

template<int dim, int subdim>

Face<dim, subdim>* regina::detail::SimplexFaces< dim, subdim >::face_[FaceNumbering< dim, subdim >::nFaces]

protected

The faces of the underlying triangulation that form the individual subdim-faces of this simplex.

## faces

template<int dim_>

constexpr const char* regina::detail::Strings< dim_ >::faces

static constexpr

A string that gives the plural name of a dim-face, all in lower case.

An example for dim = 3 is "tetrahedra". An example for dim = 7 is "7-faces".

## Faces

template<int dim_>

constexpr const char* regina::detail::Strings< dim_ >::Faces

static constexpr

A string that gives the plural name of a dim-face, with the first word capitalised.

An example for dim = 3 is "Tetrahedra". An example for dim = 7 is "7-faces".

## faces_

template<int dim, int subdim>

std::vector<Face<dim, subdim>*> regina::detail::WeakFaceList< dim, subdim >::faces_

protected

The list of faces.

## facetPerm_

template<int dim>

Perm<dim+1>* regina::detail::IsomorphismBase< dim >::facetPerm_

protected

The permutation applied to the facets of each source simplex.

This array has size nSimplices_.

## facets_

template<int dim>

std::vector<Face<dim, dim-1>*> regina::detail::BoundaryComponentFaceStorage< dim, false >::facets_

protected

List of all (dim-1)-simplices in the boundary component.

## mapping_

template<int dim, int subdim>

Perm<dim+1> regina::detail::SimplexFaces< dim, subdim >::mapping_[FaceNumbering< dim, subdim >::nFaces]

protected

For each subdim-face of this simplex, maps vertices (0,1,...,subdim) of the underlying subdim-face of the triangulation to the corresponding vertices of this simplex, as described by faceMapping().

## nFaces [1/13]

template<int dim, int subdim, bool lex>

constexpr int regina::detail::FaceNumberingImpl< dim, subdim, lex >::nFaces

static constexpr

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 constexpr

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 constexpr

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

## nFaces [4/13]

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

static constexpr

The total number of vertices in each edge.

## nFaces [5/13]

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

static constexpr

The total number of vertices in each triangle.

## nFaces [6/13]

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

static constexpr

The total number of edges in each triangle.

## nFaces [7/13]

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

static constexpr

The total number of vertices in each tetrahedron.

## nFaces [8/13]

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

static constexpr

The total number of edges in each tetrahedron.

## nFaces [9/13]

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

static constexpr

The total number of triangles in each tetrahedron.

## nFaces [10/13]

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

static constexpr

The total number of vertices in each pentachoron.

## nFaces [11/13]

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

static constexpr

The total number of edges in each pentachoron.

## nFaces [12/13]

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

static constexpr

The total number of triangles in each pentachoron.

## nFaces [13/13]

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

static constexpr

The total number of tetrahedra in each pentachoron.

## nRidges_

template<int dim>

size_t regina::detail::BoundaryComponentFaceStorage< dim, false >::nRidges_

protected

The number of (dim-2)-faces in the boundary component.

## nSimplices_

template<int dim>

unsigned regina::detail::IsomorphismBase< dim >::nSimplices_

protected

The number of simplices in the source triangulation.

## orientable_

template<int dim>

bool regina::detail::BoundaryComponentBase< dim >::orientable_

protected

Is this boundary component orientable?

## pairs_

template<int dim>

FacetSpec<dim>* regina::detail::FacetPairingBase< dim >::pairs_

protected

The other facet to which each simplex facet is paired.

If a simplex facet is left unmatched, the corresponding element of this array will be boundary (as returned by FacetSpec<dim>::isBoundary()). If the destination for a particular facet has not yet been decided, the facet will be paired to itself.

## simpImage_

template<int dim>

int* regina::detail::IsomorphismBase< dim >::simpImage_

protected

Stores the simplex of the destination triangulation that each simplex of the source triangulation maps to.

This array has size nSimplices_.

## simplex

template<int dim_>

constexpr const char* regina::detail::Strings< dim_ >::simplex

static constexpr

A string that gives the name of a dim-simplex, all in lower case.

An example for dim = 3 is "tetrahedron". An example for dim = 7 is "7-simplex".

## Simplex

template<int dim_>

constexpr const char* regina::detail::Strings< dim_ >::Simplex

static constexpr

A string that gives the name of a dim-simplex, with the first word capitalised.

An example for dim = 3 is "Tetrahedron". An example for dim = 7 is "7-simplex".

## simplices_

template<int dim>

MarkedVector<Simplex<dim> > regina::detail::TriangulationBase< dim >::simplices_

protected

The top-dimensional simplices that form the triangulation.

## size_

template<int dim>

size_t regina::detail::FacetPairingBase< dim >::size_

protected

The number of simplices under consideration.

## tri_

template<int dim>

Triangulation<dim>* regina::detail::XMLTriangulationReaderBase< dim >::tri_

protected

The triangulation currently being read.

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

## valid_ [1/2]

template<int dim>

bool regina::detail::ComponentBase< dim >::valid_

protected

Is this component valid? See Triangulation<dim>::isValid() for details on what this means.

## valid_ [2/2]

template<int dim>

bool regina::detail::TriangulationBase< dim >::valid_

protected

Is this triangulation valid? See isValid() for details on what this means.

## Friends

## Triangulation< dim >

template<int dim>

friend class Triangulation< dim >

friend

Allow access to private members.

regina::detail::FaceNumberingImpl::nFaces
static constexpr int nFaces
The total number of subdim-dimensional faces in each dim-dimensional simplex.
Definition: facenumbering.h:228
regina::detail::FaceNumberingImpl< dim, subdim, false >::nFaces
static constexpr int nFaces
The total number of subdim-dimensional faces in each dim-dimensional simplex.
Definition: facenumbering.h:421

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