Regina Calculation Engine
Classes | Typedefs | Functions | Variables | Friends
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...
 
struct  regina::detail::PachnerHelper< dim, k >
 Internal class used to perform Pachner moves on a triangulation. More...
 
class  regina::detail::TriangulationBase< dim >::TopologyLock
 Creates a temporary lock on the topological properties of the given 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, StoreManagedPtrregina::detail::XMLTriangulationReaderBase< dim >::AbelianGroupPropertyReader::PropType
 The type of the property currently being read. More...
 
typedef Property< GroupPresentation, StoreManagedPtrregina::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...
 
ReorderIterator & regina::detail::WeakFaceList< dim, subdim >::ReorderIterator< tridim >::operator= (const ReorderIterator &)=default
 Assignment operator. 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...
 
 regina::detail::WeakFaceList< dim, subdim >::WeakFaceList ()=default
 Default constructor that leaves the list of faces empty. 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...
 
 regina::detail::WeakFaceList< dim, subdim >::WeakFaceList (const WeakFaceList &)=delete
 
WeakFaceListregina::detail::WeakFaceList< dim, subdim >::operator= (const WeakFaceList &)=delete
 
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 (const BoundaryComponentFaceStorage &)=delete
 
BoundaryComponentFaceStorageregina::detail::BoundaryComponentFaceStorage< dim, false >::operator= (const BoundaryComponentFaceStorage &)=delete
 
 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 (const BoundaryComponentBase &)=delete
 
BoundaryComponentBaseregina::detail::BoundaryComponentBase< dim >::operator= (const BoundaryComponentBase &)=delete
 
 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 (const ComponentBase &)=delete
 
ComponentBaseregina::detail::ComponentBase< dim >::operator= (const ComponentBase &)=delete
 
 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...
 
static Triangulation< dim > * regina::detail::ExampleBase< dim >::sphere ()
 Closed Triangulations. 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)=default
 Creates a new copy of the given object. More...
 
FaceEmbeddingBaseregina::detail::FaceEmbeddingBase< dim, subdim >::operator= (const FaceEmbeddingBase &cloneMe)=default
 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...
 
 regina::detail::FaceStorage< dim, codim >::FaceStorage (const FaceStorage &)=delete
 
FaceStorageregina::detail::FaceStorage< dim, codim >::operator= (const FaceStorage &)=delete
 
 regina::detail::FaceStorage< dim, codim >::FaceStorage ()=default
 Default constructor that leaves the list of embeddings empty. 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 > &src)
 Creates a new copy of the given isomorphism. More...
 
 regina::detail::IsomorphismBase< dim >::IsomorphismBase (IsomorphismBase< dim > &&src) noexcept
 Moves the given isomorphism into this new isomorphism. More...
 
 regina::detail::IsomorphismBase< dim >::~IsomorphismBase ()
 Destroys this isomorphism. More...
 
IsomorphismBaseregina::detail::IsomorphismBase< dim >::operator= (const IsomorphismBase &src)
 Copies the given isomorphism into this isomorphism. More...
 
IsomorphismBaseregina::detail::IsomorphismBase< dim >::operator= (IsomorphismBase &&src) noexcept
 Moves the given isomorphism into 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, bool even=false)
 Returns a random isomorphism for the given number of simplices. 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...
 
 regina::detail::SimplexFaces< dim, subdim >::SimplexFaces (const SimplexFaces &)=delete
 
SimplexFacesregina::detail::SimplexFaces< dim, subdim >::operator= (const SimplexFaces &)=delete
 
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 ksubdim. 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...
 
Face< dim, 1 > * regina::detail::SimplexBase< dim >::edge (int i, int j) const
 Returns the edge of this simplex that connects the two given vertices 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 (const SimplexBase &)=delete
 
SimplexBaseregina::detail::SimplexBase< dim >::operator= (const SimplexBase &)=delete
 
 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 ksubdim. 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 ksubdim. 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...
 
static bool regina::detail::PachnerHelper< dim, k >::pachner (Triangulation< dim > *tri, Face< dim, k > *f, bool check, bool perform)
 Performs a (dim - k + 1)-(k + 1) move about the given face. More...
 
 regina::detail::TriangulationBase< dim >::TopologyLock::TopologyLock (TriangulationBase< dim > *tri)
 Creates a new lock on the given triangulation. More...
 
 regina::detail::TriangulationBase< dim >::TopologyLock::~TopologyLock ()
 Removes this lock on the associated triangulation. 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 *) override
 Signifies that parsing of this XML element is beginning. More...
 
virtual void regina::detail::XMLSimplexReader< dim >::initialChars (const std::string &chars) override
 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 *) override
 Signifies that parsing of this XML element is beginning. More...
 
virtual XMLElementReaderregina::detail::XMLSimplicesReader< dim >::startSubElement (const std::string &subTagName, const regina::xml::XMLPropertyDict &) override
 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 Packetregina::detail::XMLTriangulationReaderBase< dim >::packet () override
 
virtual XMLElementReaderregina::detail::XMLTriangulationReaderBase< dim >::startContentSubElement (const std::string &subTagName, const regina::xml::XMLPropertyDict &subTagProps) override
 
virtual void regina::detail::XMLTriangulationReaderBase< dim >::endContentSubElement (const std::string &subTagName, XMLElementReader *subReader) override
 
 regina::detail::XMLTriangulationReaderBase< dim >::AbelianGroupPropertyReader::AbelianGroupPropertyReader (PropType &prop)
 Creates a new reader that stores its results in the given triangulation property. More...
 
virtual XMLElementReaderregina::detail::XMLTriangulationReaderBase< dim >::AbelianGroupPropertyReader::startSubElement (const std::string &subTagName, const regina::xml::XMLPropertyDict &) override
 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) override
 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 XMLElementReaderregina::detail::XMLTriangulationReaderBase< dim >::GroupPresentationPropertyReader::startSubElement (const std::string &subTagName, const regina::xml::XMLPropertyDict &) override
 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) override
 Signifies that parsing has finished for a subelement of this XML element. More...
 
XMLElementReaderregina::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...
 
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...
 
int regina::detail::TriangulationBase< dim >::topologyLock_
 If non-zero, this will cause Triangulation<dim>::clearAllProperties() to preserve any computed properties that related to the manifold (as opposed to the specific triangulation). 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...
 
FacetPairingBaseregina::detail::FacetPairingBase< dim >::operator= (const FacetPairingBase &)=delete
 
 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 GroupPresentationregina::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 AbelianGroupregina::detail::TriangulationBase< dim >::homology () const
 Returns the first homology group for this triangulation. More...
 
const AbelianGroupregina::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...
 
void regina::detail::TriangulationBase< dim >::reflect ()
 Relabels the vertices of top-dimensional simplices in this triangulation so that all simplices reflect their orientation. More...
 
template<int k>
bool regina::detail::TriangulationBase< dim >::pachner (Face< dim, k > *f, bool check=true, bool perform=true)
 Checks the eligibility of and/or performs a (dim + 1 - k)-(k + 1) Pachner move about the given k-face. 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=nullptr, 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 >
struct regina::detail::TriangulationBase< dim >::PachnerHelper
 
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...
 
TriangulationBaseregina::detail::TriangulationBase< dim >::operator= (const TriangulationBase &)=delete
 
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]

The type of the property currently being read.

◆ PropType [2/2]

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
propa 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
facetthe 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 vfacet, 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
facetthe 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
facetthe 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
dimthe dimension of the underlying triangulations.
subdimthe dimension of the faces in question.
Returns
true if such faces may be invalid, or false if subdim-faces of dim-dimensional triangluations are always valid.

◆ allowsNonOrientableLinks()

constexpr bool regina::detail::allowsNonOrientableLinks ( int  dim,
int  subdim 
)
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
dimthe dimension of the underlying triangulations.
subdimthe dimension of the faces in question.
Returns
true if such faces may have non-orientable links, or false if the links of subdim-faces of dim-dimensional triangluations are always orientable.

◆ 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).
Todo:
Lock the topological properties of the underlying manifold, to avoid recomputing them after the isomorphism is applied.
Parameters
originalthe 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).
Todo:
Lock the topological properties of the underlying manifold, to avoid recomputing them after the isomorphism is applied.
Parameters
trithe 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
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).
Todo:
Lock the topological properties of the underlying manifold, to avoid recomputing them after the subdivision. However, only do this for valid triangulations (since we can have scenarios where invalid triangulations becoming valid and ideal after subdivision, which may change properties such as Triangulation<4>::knownSimpleLinks).

◆ begin()

template<int dim, int codim>
std::vector< FaceEmbedding< dim, dim - codim > >::const_iterator regina::detail::FaceStorage< dim, codim >::begin
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
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
indexspecifies 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
indexthe 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 ( )
protecteddefault

Default constructor that leaves orientability uninitialised.

◆ BoundaryComponentFaceStorage()

template<int dim>
regina::detail::BoundaryComponentFaceStorage< dim, false >::BoundaryComponentFaceStorage ( )
inlineprotected

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

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

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
inlineprotected

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
inlineconstexprprotected

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

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

Parameters
tthe triangulation whose faces should be calculated.

◆ calculatedSkeleton()

template<int dim>
bool regina::detail::TriangulationBase< dim >::calculatedSkeleton
inlineprotected

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
inlineprotected

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
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
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
indexthe 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
inlineprotected

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

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
trithe 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
facea subdim-face number in a dim-simplex; this must be between 0 and (dim+1 choose subdim+1)-1 inclusive.
vertexa vertex number in a dim-simplex; this must be between 0 and dim inclusive.
Returns
true if and only if the given subdim-face contains the given vertex.

◆ countBoundaryComponents() [1/2]

template<int dim>
size_t regina::detail::ComponentBase< dim >::countBoundaryComponents
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
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
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
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
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
subdimthe 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
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
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
inlineprotected

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

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
sourcethe 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
sourcethe 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 
)
inlineprotected

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
simpthe simplex under investigation (this must be strictly less than the total number of simplices under consideration).
facetthe 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
simpthe simplex under investigation (this must be strictly less than the total number of simplices under consideration).
facetthe 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

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.

◆ edge()

template<int dim>
Face<dim, 1>* regina::detail::SimplexBase< dim >::edge ( int  i,
int  j 
) const
inline

Returns the edge of this simplex that connects the two given vertices of this simplex.

This is a convenience routine to avoid more cumbersome calls to Edge<dim>::faceNumber(). In dimensions 3 and 4 (where the array Edge<dim>::edgeNumber is defined), this routine is identical to calling edge(Edge<dim>::edgeNumber[i][j]).

Parameters
ithe vertex of this simplex that forms one endpoint of the edge; this must be between 0 and dim inclusive.
jthe vertex of this simplex that forms the other endpoint of the edge; this must be between 0 and dim inclusive, and must also be different from i.
Returns
the edge of this simplex that connects vertices i and j of this simplex.

◆ 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
indexthe 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
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.

◆ endSubElement() [1/2]

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

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

The default implementation does nothing.

Parameters
subTagNamethe name of the subelement closing tag.
subReaderthe 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 
)
inlineoverridevirtual

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

The default implementation does nothing.

Parameters
subTagNamethe name of the subelement closing tag.
subReaderthe 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
inlineprotected

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

◆ eulerCharTri()

template<int dim>
long regina::detail::TriangulationBase< dim >::eulerCharTri
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.

◆ face() [1/5]

template<int dim, int subdim>
int regina::detail::FaceEmbeddingBase< dim, subdim >::face
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
facethe 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
facethe 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
subdimthe dimension of the face to query. This must be between 0 and dim-1 inclusive.
Parameters
indexthe 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
indexthe 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)
inlineprotected

Creates a new face.

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

Parameters
componentthe 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)
default

Creates a new copy of the given object.

Parameters
cloneMethe 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
simplexthe top-dimensional simplex in which the underlying subdim-face of the triangulation is contained.
facethe 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 ≤ isubdim, 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
facethe 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
facethe 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
verticesa permutation whose first (subdim + 1) elements represent some vertex numbers in a dim-simplex.
Returns
the corresponding subdim-face number in the dim-simplex. This will be between 0 and (dim+1 choose subdim+1)-1 inclusive.

◆ 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
subdimthe 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
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.

◆ FaceStorage()

template<int dim, int codim>
regina::detail::FaceStorage< dim, codim >::FaceStorage ( )
protecteddefault

Default constructor that leaves the list of embeddings empty.

◆ 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
indexthe 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
indexthe 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
facetthe 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
cloneMethe 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
trithe triangulation whose facet pairing should be constructed.

◆ FacetPairingBase() [3/3]

template<int dim>
regina::detail::FacetPairingBase< dim >::FacetPairingBase ( size_t  size)
inlineprotected

Creates a new facet pairing.

All internal arrays will be allocated but not initialised.

Precondition
size is at least 1.
Parameters
sizethe 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
sourceSimpthe 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
sourceSimpthe 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 ( )
inlineprotected

Initialises this face as valid.

◆ fillFVector()

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

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
resultthe 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
otherthe triangulation to compare with this one.
outputthe 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 
)
inlinestatic

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
nSimplicesthe number of simplices whose facets should be (potentially) matched.
boundarydetermines 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.
nBdryFacetsspecifies 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.
usethe 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.
useArgsthe 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
otherthe triangulation in which to search for isomorphic copies of this triangulation.
outputthe 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
listthe 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
sigthe isomorphism signature of the triangulation to construct. Note that isomorphism signatures 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
repa 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
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

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
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 ≤ kdim.

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

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

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

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
tthe underlying triangulation.
bcthe boundary component of t currently under construction.
faceta boundary facet that belongs to bc.

◆ identity()

template<int dim>
Isomorphism< dim > regina::detail::IsomorphismBase< dim >::identity ( unsigned  nSimplices)
inlinestatic

Returns the identity isomorphism for the given number of simplices.

This isomorphism sends every simplex and every vertex to itself.

Parameters
nSimplicesthe number of simplices that the new isomorphism should operate upon.
Returns
the identity isomorphism.

◆ index() [1/4]

template<int dim>
size_t regina::detail::ComponentBase< dim >::index
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
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
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)
overridevirtual

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
charsthe 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
nSimplicesthe number of additional simplices to insert.
adjacenciesdescribes which simplices are adjace to which others, as described above. This array must have initial dimension at least nSimplices.
gluingsdescribes 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
sourcethe triangulation whose copy will be inserted.

◆ isBoundary()

template<int dim, int subdim>
bool regina::detail::FaceBase< dim, subdim >::isBoundary
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
listthe 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
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
otherthe 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
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
otherthe 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

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
otherthe 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/3]

template<int dim>
regina::detail::IsomorphismBase< dim >::IsomorphismBase ( const IsomorphismBase< dim > &  src)
inline

Creates a new copy of the given isomorphism.

This constructor induces a deep copy of src.

Parameters
srcthe isomorphism to copy.

◆ IsomorphismBase() [2/3]

template<int dim>
regina::detail::IsomorphismBase< dim >::IsomorphismBase ( IsomorphismBase< dim > &&  src)
inlinenoexcept

Moves the given isomorphism into this new isomorphism.

This is a fast (constant time) operation.

The isomorphism that is passed (src) will no longer be usable.

Parameters
srcthe isomorphism to move.

◆ IsomorphismBase() [3/3]

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

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: isoSig(), which returns a string only, and isoSigDetail(), 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
relabellingif 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
sigthe 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
sourcethe 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
simpthe simplex under investigation (this must be strictly less than the total number of simplices under consideration).
facetthe 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
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
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
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
myFacetthe facet of this simplex that will be glued to the given simplex you. This facet number must be between 0 and dim inclusive.
youthe other simplex that will be glued to the given facet of this simplex.
gluinga 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
inlineprotected

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

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
inlineprotected

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

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
destthe 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
descthe 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
inlineprotected

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
sourcethe 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
inlineprotected

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

This is signalled by a facet matched to itself.

Parameters
simpthe simplex under investigation (this must be strictly less than the total number of simplices under consideration).
facetthe 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
rhsthe 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/4]

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

Makes this a copy of the given object.

Parameters
cloneMethe object to copy.

◆ operator=() [2/4]

template<int dim>
IsomorphismBase< dim > & regina::detail::IsomorphismBase< dim >::operator= ( const IsomorphismBase< dim > &  src)

Copies the given isomorphism into this isomorphism.

It does not matter if this and the given isomorphism use different numbers of simplices; if they do then this isomorphism will be resized as a result.

This operator induces a deep copy of src.

Parameters
srcthe isomorphism to copy.
Returns
a reference to this isomorphism.

◆ operator=() [3/4]

template<int dim, int subdim>
template<int tridim>
ReorderIterator& regina::detail::WeakFaceList< dim, subdim >::ReorderIterator< tridim >::operator= ( const ReorderIterator< tridim > &  )
default

Assignment operator.

◆ operator=() [4/4]

template<int dim>
IsomorphismBase< dim > & regina::detail::IsomorphismBase< dim >::operator= ( IsomorphismBase< dim > &&  src)
noexcept

Moves the given isomorphism into this isomorphism.

This is a fast (constant time) operation.

It does not matter if this and the given isomorphism use different numbers of simplices; if they do then this isomorphism will be resized as a result.

The isomorphism that is passed (src) will no longer be usable.

Parameters
srcthe isomorphism to move.
Returns
a reference to this isomorphism.

◆ 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
rhsthe 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)
inlineprotected

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
sourcethe facet under investigation.
Returns
the other facet to which the given facet is paired.

◆ operator[]() [2/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
sourcethe facet under investigation.
Returns
the other facet to which the given facet is paired.

◆ operator[]() [3/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
sourcethe 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.

◆ 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
faceidentifies which subdim-face of a dim-dimensional simplex to query. This must be between 0 and (dim+1 choose subdim+1)-1 inclusive.
Returns
the corresponding canonical ordering of the simplex vertices.

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

◆ pachner() [1/2]

template<int dim>
template<int k>
bool regina::detail::TriangulationBase< dim >::pachner ( Face< dim, k > *  f,
bool  check = true,
bool  perform = true 
)
inline

Checks the eligibility of and/or performs a (dim + 1 - k)-(k + 1) Pachner move about the given k-face.

This involves replacing the (dim + 1 - k) top-dimensional simplices meeting that k-face with (k + 1) new top-dimensional simplices joined along a new internal (dim - k)-face. This can be done iff (i) the given k-face is valid and non-boundary; (ii) the (dim + 1 - k) top-dimensional simplices that contain it are distinct; and (iii) these simplices are joined in such a way that the link of the given k-face is the standard triangulation of the (dim - 1 - k)-sphere as the boundary of a (dim - \k)-simplex.

If the routine is asked to both check and perform, the move will only be performed if the check shows it is legal. In In the special case k = dim, the move is always legal and so the check argument will simply be ignored.

Note that after performing this move, all skeletal objects (facets, components, etc.) will be reconstructed, which means any pointers to old skeletal objects (such as the argument v) can no longer be used.

If this triangulation is currently oriented, then this Pachner move will label the new top-dimensional simplices in a way that preserves the orientation.

See the page on Pachner moves on triangulations for definitions and terminology relating to Pachner moves. After the move, the new belt face will be formed from vertices 0,1,...,(dim - k) of simplices().back().

Warning
For the case k = dim in Regina's standard dimensions, the labelling of the belt face has changed as of Regina 5.2. In versions 5.1 and earlier, the belt face was simplices().back()->vertex(dim), and as of version 5.2 it is now simplices().back()->vertex(0). The deprecated routines Triangulation<2>::oneThreeMove(), Triangulation<3>::oneFourMove() and Triangulation<4>::oneFiveMove() maintain the old behaviour if you need it.
Precondition
If the move is being performed and no check is being run, it must be known in advance that the move is legal.
The given k-face is a k-face of this triangulation.
Parameters
fthe k-face about which to perform the move.
checktrue if we are to check whether the move is allowed (defaults to true).
performtrue if we are to perform the move (defaults to true).
Returns
If check is true, the function returns true if and only if the requested move may be performed without changing the topology of the manifold. If check is false, the function simply returns true.
Template Parameters
kthe dimension of the given face. This must be between 0 and (dim) inclusive. You can still perform a Pachner move about a 0-face dim-face, but these moves use specialised implementations (as opposed to this generic template implementation).

◆ pachner() [2/2]

template<int dim, int k>
static bool regina::detail::PachnerHelper< dim, k >::pachner ( Triangulation< dim > *  tri,
Face< dim, k > *  f,
bool  check,
bool  perform 
)
static

Performs a (dim - k + 1)-(k + 1) move about the given face.

This routine contains the real implementation of TriangulationBase::pachner<k>(); see that routine for further details.

Precondition
If the move is being performed and no check is being run, it must be known in advance that the move is legal.
The given k-face is a k-face of the given triangulation.
Parameters
trithe triangulation upon which to perform the Pachner move.
fthe specific k-face about which to perform the move.
checktrue if the move should be tested for eligibility.
performtrue if the move should actually be performed.
Returns
If check is true, this function returns true if and only if the requested move may be performed without changing the topology of the manifold. If check is false, this function simply returns true.

◆ propertyReader()

template<int dim>
XMLElementReader * regina::detail::XMLTriangulationReaderBase< dim >::propertyReader ( const std::string &  subTagName,
const regina::xml::XMLPropertyDict subTagProps 
)
inlineprotected

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
subTagNamethe name of the XML subelement opening tag.
subTagPropsthe 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)
inlineprotected

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
embthe 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)
inlineprotected

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
facethe 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 > *  )
inlineprotected

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 > *  )
inlineprotected

Does nothing, since this boundary component does not store lower-dimensional faces.

Template Parameters
subdimthe 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)
inlineprotected

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
subdimthe dimension of the face to append. This must be between 0 and dim-1 inclusive.
Parameters
facethe face to append to the list.

◆ random()

template<int dim>
Isomorphism< dim > regina::detail::IsomorphismBase< dim >::random ( unsigned  nSimplices,
bool  even = false 
)
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.

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
nSimplicesthe number of simplices that the new isomorphism should operate upon.
evenif true, then every simplex will have its vertices permuted with an even permutation. This means that, if the random isomorphism is applied to an oriented triangulation, it will preserve the orientation.
Returns
the new random isomorphism.

◆ reflect()

template<int dim>
void regina::detail::TriangulationBase< dim >::reflect

Relabels the vertices of top-dimensional simplices in this triangulation so that all simplices reflect their orientation.

In particular, if this triangulation is oriented, then it will be converted into an isomorphic triangulation with the opposite orientation.

This routine works by flipping vertices (dim - 1) and dim of every top-dimensional simplex.

◆ 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
simplexthe 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
indexspecifies 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
inlineprotected

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
inlineprotected

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
tria 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
inlineprotected

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
tridimthe dimension of the given triangulation. This must be strictly larger than subdim, but it need not be equal to dim.
Parameters
tria tridim-dimensional triangulation, as described above.
tridimFacesa 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
inlineprotected

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
tridimthe dimension of the given triangulation. This must be strictly larger than subdim, but it need not be equal to dim.
Parameters
tria tridim-dimensional triangulation, as described above.
tridimFacesa 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
inlineprotected

Tests whether this and the given triangulation have the same k-face degree sequences, for each facial dimension ksubdim.

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 ksubdim.
Parameters
otherthe 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
otherthe simplex to compare against this.
pa 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
inlineprotected

Tests whether the k-face degrees of this and the given simplex are identical, under the given relabelling, for all faces of all dimensions ksubdim.

Parameters
otherthe simplex to compare against this.
pa 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 ksubdim, 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
inlineprotected

Tests whether this and the given triangulation have the same number of k-faces, for each facial dimension ksubdim.

Parameters
otherthe 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
descthe 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
sourceSimpthe 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
sourceSimpthe 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 ( )
staticconstexpr

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
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
indexspecifies 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
indexspecifies 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
indexspecifies 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 
)
inlineprotected

Creates a new simplex with the given description and no facets joined to anything.

Parameters
descthe description to give the new simplex.
trithe triangulation to which the new simplex belongs.

◆ SimplexBase() [2/2]

template<int dim>
regina::detail::SimplexBase< dim >::SimplexBase ( Triangulation< dim > *  tri)
inlineprotected

Creates a new simplex with no description and no facets joined to anything.

Parameters
trithe triangulation to which the new simplex belongs.

◆ simplices() [1/3]

template<int dim>
constexpr static const char* regina::detail::XMLTriangulationTags< dim >::simplices ( )
staticconstexpr

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

The XML attribute that stores the number of top-dimensional simplices in a dim-dimensional triangulation.

◆ size() [2/7]

template<int dim>
size_t regina::detail::ComponentBase< dim >::size
inline

Returns the number of top-dimensional simplices in this component.

Returns
The number of top-dimensional simplices.

◆ size() [3/7]

template<int dim>
unsigned regina::detail::IsomorphismBase< dim >::size
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() [4/7]

template<int dim>
size_t regina::detail::FacetPairingBase< dim >::size
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
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

Closed Triangulations.

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 = nullptr,
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 null, 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
componentParentthe packet beneath which the new component triangulations will be inserted, or null if they should be inserted directly beneath this triangulation.
setLabelstrue 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.

◆ startElement() [1/2]

template<int dim>
void regina::detail::XMLSimplexReader< dim >::startElement ( const std::string &  tagName,
const regina::xml::XMLPropertyDict tagProps,
XMLElementReader parentReader 
)
inlineoverridevirtual

Signifies that parsing of this XML element is beginning.

The default implementation does nothing.

Parameters
tagNamethe name of the opening tag for this element.
tagPropsthe properties associated with the opening tag.
parentReaderthe 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 
)
overridevirtual

Signifies that parsing of this XML element is beginning.

The default implementation does nothing.

Parameters
tagNamethe name of the opening tag for this element.
tagPropsthe properties associated with the opening tag.
parentReaderthe 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 
)
overridevirtual

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
subTagNamethe name of the subelement opening tag.
subTagPropsthe 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 
)
inlineoverridevirtual

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
subTagNamethe name of the subelement opening tag.
subTagPropsthe 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 
)
inlineoverridevirtual

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
subTagNamethe name of the subelement opening tag.
subTagPropsthe 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
otherthe 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
otherthe triangulation whose contents should be swapped with this.

◆ swapFaces()

template<int dim, int subdim>
void regina::detail::FaceListSuite< dim >::swapFaces ( FaceListSuite< dim, subdim > &  other)
inlineprotected

Swaps all faces of dimension subdim and below with those of the given triangulation.

Parameters
otherthe face storage for the triangulation whose faces are to be swapped with this.

◆ TopologyLock()

template<int dim>
regina::detail::TriangulationBase< dim >::TopologyLock::TopologyLock ( TriangulationBase< dim > *  tri)

Creates a new lock on the given triangulation.

Parameters
trithe triangulation whose topological properties are to be locked. This may be null (in which case the lock has no effect).

◆ 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
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
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
copythe 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
copythe triangulation to copy.
clonePropstrue 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
myFacetthe 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
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().

◆ WeakFaceList()

template<int dim, int subdim>
regina::detail::WeakFaceList< dim, subdim >::WeakFaceList ( )
protecteddefault

Default constructor that leaves the list of faces empty.

◆ 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
outthe output stream to which to write.
prefixa string to prepend to the name of each graph vertex, and to include in the graph or subgraph name; see above for details.
subgraphfalse 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.
labelsindicates 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
outthe output stream to which to write.
graphNamethe 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
outthe 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
outthe 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
outthe 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
outthe 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
outthe 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
outthe 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
outthe 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
outthe output stream to which to write.

◆ writeTextShort() [3/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
outthe output stream to which to write.

◆ writeTextShort() [4/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
outthe 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
outthe 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
outthe 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
outthe 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
outthe 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
outthe 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
trithe triangulation containing the simplex being read.
whichSimplexthe 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
trithe triangulation being read.

◆ XMLTriangulationReaderBase()

Creates a new triangulation reader.

Parameters
resolverthe 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.

◆ ~TopologyLock()

template<int dim>
regina::detail::TriangulationBase< dim >::TopologyLock::~TopologyLock

Removes this lock on the associated triangulation.

◆ ~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
staticconstexpr

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.

◆ allFaces [2/2]

template<int dim>
constexpr bool regina::detail::BoundaryComponentFaceStorage< dim, false >::allFaces = false
staticconstexpr

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.

◆ allowVertex [1/2]

template<int dim, bool allFaces, bool allowVertex_>
constexpr bool regina::detail::BoundaryComponentFaceInterface< dim, allFaces, allowVertex_ >::allowVertex = true
staticconstexpr

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.

◆ allowVertex [2/2]

template<int dim, bool allFaces>
constexpr bool regina::detail::BoundaryComponentFaceInterface< dim, allFaces, false >::allowVertex = false
staticconstexpr

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.

◆ 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
staticconstexpr

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.

◆ canBuild [2/2]

template<int dim, bool allFaces, bool allowVertex>
constexpr bool regina::detail::BoundaryComponentStorage< dim, allFaces, allowVertex, false >::canBuild = false
staticconstexpr

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.

◆ dim

template<int dim_>
constexpr const char* regina::detail::Strings< dim_ >::dim
staticconstexpr

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
staticconstexpr

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
staticconstexpr

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
staticconstexpr

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
staticconstexpr

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
staticconstexpr

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

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

◆ nFaces [4/13]

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

The total number of vertices in each edge.

◆ nFaces [5/13]

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

The total number of vertices in each triangle.

◆ nFaces [6/13]

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

The total number of edges in each triangle.

◆ nFaces [7/13]

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

The total number of vertices in each tetrahedron.

◆ nFaces [8/13]

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

The total number of edges in each tetrahedron.

◆ nFaces [9/13]

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

The total number of triangles in each tetrahedron.

◆ nFaces [10/13]

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

The total number of vertices in each pentachoron.

◆ nFaces [11/13]

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

The total number of edges in each pentachoron.

◆ nFaces [12/13]

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

The total number of triangles in each pentachoron.

◆ nFaces [13/13]

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

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
staticconstexpr

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
staticconstexpr

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.

◆ topologyLock_

template<int dim>
int regina::detail::TriangulationBase< dim >::topologyLock_
protected

If non-zero, this will cause Triangulation<dim>::clearAllProperties() to preserve any computed properties that related to the manifold (as opposed to the specific triangulation).

This allows you to avoid recomputing expensive invariants when the underlying manifold is retriangulated.

This property should be managed by creating and destroying TopologyLock objects. The precise value of topologyLock_ indicates the number of TopologyLock objects that currently exist for this triangulation.

◆ 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:212
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:405

Copyright © 1999-2018, 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).