Regina Calculation Engine
|
Implementation details that end users should not need to reference directly. More...
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, StoreManagedPtr > | regina::detail::XMLTriangulationReaderBase< dim >::AbelianGroupPropertyReader::PropType |
The type of the property currently being read. More... | |
typedef Property< GroupPresentation, StoreManagedPtr > | regina::detail::XMLTriangulationReaderBase< dim >::GroupPresentationPropertyReader::PropType |
The type of the property currently being read. More... | |
Functions | |
regina::detail::WeakFaceList< dim, subdim >::ReorderIterator< tridim >::ReorderIterator () | |
Creates an uninitialised iterator. More... | |
regina::detail::WeakFaceList< dim, subdim >::ReorderIterator< tridim >::ReorderIterator (typename std::vector< Face< dim, subdim > * >::const_iterator it, Face< tridim, subdim > **map) | |
Creates an iterator that points to the given face of this list, using the given map to convert faces of this list to faces of the other triangulation tri. More... | |
regina::detail::WeakFaceList< dim, subdim >::ReorderIterator< tridim >::ReorderIterator (const ReorderIterator &)=default | |
Copy constructor. More... | |
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 | |
WeakFaceList & | regina::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 | |
BoundaryComponentFaceStorage & | regina::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 | |
BoundaryComponentBase & | regina::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 | |
ComponentBase & | regina::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... | |
FaceEmbeddingBase & | regina::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 | |
FaceStorage & | regina::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... | |
IsomorphismBase & | regina::detail::IsomorphismBase< dim >::operator= (const IsomorphismBase &src) |
Copies the given isomorphism into this isomorphism. More... | |
IsomorphismBase & | regina::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 | |
SimplexFaces & | regina::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 k ≤ subdim. More... | |
const std::string & | regina::detail::SimplexBase< dim >::description () const |
Returns the description associated with this simplex. More... | |
void | regina::detail::SimplexBase< dim >::setDescription (const std::string &desc) |
Sets the description associated with this simplex. More... | |
size_t | regina::detail::SimplexBase< dim >::index () const |
Returns the index of this simplex in the underlying triangulation. More... | |
Simplex< dim > * | regina::detail::SimplexBase< dim >::adjacentSimplex (int facet) const |
Returns the adjacent simplex that is glued to the given facet of this simplex. More... | |
Perm< dim+1 > | regina::detail::SimplexBase< dim >::adjacentGluing (int facet) const |
Returns a permutation that indicates precisely how this simplex is glued to the adjacent simplex across the given facet. More... | |
int | regina::detail::SimplexBase< dim >::adjacentFacet (int facet) const |
If the given facet of this simplex is glued to facet f of some adjacent simplex, then this routine returns the adjacent facet number f. More... | |
bool | regina::detail::SimplexBase< dim >::hasBoundary () const |
Determines if this simplex has any facets that lie on the triangulation boundary. More... | |
void | regina::detail::SimplexBase< dim >::join (int myFacet, Simplex< dim > *you, Perm< dim+1 > gluing) |
Joins the given facet of this simplex to some facet of another simplex. More... | |
Simplex< dim > * | regina::detail::SimplexBase< dim >::unjoin (int myFacet) |
Unglues the given facet of this simplex from whatever it is joined to. More... | |
void | regina::detail::SimplexBase< dim >::isolate () |
Unglues this simplex from any adjacent simplices. More... | |
Triangulation< dim > * | regina::detail::SimplexBase< dim >::triangulation () const |
Returns the triangulation to which this simplex belongs. More... | |
Component< dim > * | regina::detail::SimplexBase< dim >::component () const |
Returns the connected component of the triangulation to which this simplex belongs. More... | |
template<int subdim> | |
Face< dim, subdim > * | regina::detail::SimplexBase< dim >::face (int face) const |
Returns the subdim-face of the underlying triangulation that appears as the given subdim-face of this simplex. More... | |
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 | |
SimplexBase & | regina::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 k ≤ subdim. More... | |
bool | regina::detail::FaceListSuite< dim, subdim >::sameDegrees (const FaceListSuite< dim, subdim > &other) const |
Tests whether this and the given triangulation have the same k-face degree sequences, for each facial dimension k ≤ subdim. More... | |
static void | regina::detail::FaceCalculator< dim, subdim, codim >::calculate (TriangulationBase< dim > &t) |
Calculates all faces of dimension ≤ subdim in the given triangulation. More... | |
static void | regina::detail::BoundaryComponentCalculator< dim, subdim >::identify (TriangulationBase< dim > &t, BoundaryComponent< dim > *bc, Face< dim, dim-1 > *facet) |
Identifies and marks all faces of dimension ≤ subdim within the given boundary facet of the given dim-dimensional triangulation. More... | |
static long | regina::detail::EulerCalculator< dim, subdim >::compute (const TriangulationBase< dim > &tri) |
Computes the alternating sum of the number of faces of tri of dimensions subdim, ..., dim. More... | |
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 XMLElementReader * | regina::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 Packet * | regina::detail::XMLTriangulationReaderBase< dim >::packet () override |
virtual XMLElementReader * | regina::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 XMLElementReader * | regina::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 XMLElementReader * | regina::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... | |
XMLElementReader * | regina::detail::XMLTriangulationReaderBase< dim >::propertyReader (const std::string &subTagName, const regina::xml::XMLPropertyDict &subTagProps) |
Returns a reader for the generic triangulation property with the given subtag name. More... | |
Variables | |
std::vector< Face< dim, subdim > * > | regina::detail::WeakFaceList< dim, subdim >::faces_ |
The list of faces. More... | |
static constexpr bool | regina::detail::BoundaryComponentFaceStorage< dim, allFaces_ >::allFaces = true |
A compile-time constant indicating whether this boundary component class stores all lower-dimensional faces (true ), or only faces of dimension dim-1 (false ). More... | |
static constexpr bool | regina::detail::BoundaryComponentFaceStorage< dim, false >::allFaces = false |
A compile-time constant indicating whether this boundary component class stores all lower-dimensional faces (true ), or only faces of dimension dim-1 (false ). More... | |
std::vector< Face< dim, dim-1 > * > | regina::detail::BoundaryComponentFaceStorage< dim, false >::facets_ |
List of all (dim-1)-simplices in the boundary component. More... | |
size_t | regina::detail::BoundaryComponentFaceStorage< dim, false >::nRidges_ |
The number of (dim-2)-faces in the boundary component. More... | |
static constexpr bool | regina::detail::BoundaryComponentFaceInterface< dim, allFaces, allowVertex_ >::allowVertex = true |
A compile-time constant indicating whether ideal and/or invalid vertex boundary components are both possible and recognised by this boundary component class. More... | |
static constexpr bool | regina::detail::BoundaryComponentFaceInterface< dim, allFaces, false >::allowVertex = false |
A compile-time constant indicating whether ideal and/or invalid vertex boundary components are both possible and recognised by this boundary component class. More... | |
static constexpr bool | regina::detail::BoundaryComponentStorage< dim, allFaces, allowVertex, canBuild_ >::canBuild = true |
A compile-time constant indicating whether this boundary component class supports triangulating boundary components. More... | |
Triangulation< dim-1 > * | regina::detail::BoundaryComponentStorage< dim, allFaces, allowVertex, canBuild_ >::boundary_ |
A full triangulation of the boundary component. More... | |
static constexpr bool | regina::detail::BoundaryComponentStorage< dim, allFaces, allowVertex, false >::canBuild = false |
A compile-time constant indicating whether this boundary component class supports triangulating boundary components. More... | |
bool | regina::detail::BoundaryComponentBase< dim >::orientable_ |
Is this boundary component orientable? More... | |
bool | regina::detail::ComponentBase< dim >::valid_ |
Is this component valid? See Triangulation<dim>::isValid() for details on what this means. More... | |
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... | |
FacetPairingBase & | regina::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 > ©) | |
Creates a new copy of the given triangulation. More... | |
regina::detail::TriangulationBase< dim >::TriangulationBase (const TriangulationBase< dim > ©, bool cloneProps) | |
Creates a new copy of the given triangulation, with the option of whether or not to clone its computed properties also. More... | |
regina::detail::TriangulationBase< dim >::~TriangulationBase () | |
Destroys this triangulation. More... | |
Simplices | |
size_t | regina::detail::TriangulationBase< dim >::size () const |
Returns the number of top-dimensional simplices in the triangulation. More... | |
const std::vector< Simplex< dim > * > & | regina::detail::TriangulationBase< dim >::simplices () const |
Returns all top-dimensional simplices in the triangulation. More... | |
Simplex< dim > * | regina::detail::TriangulationBase< dim >::simplex (size_t index) |
Returns the top-dimensional simplex at the given index in the triangulation. More... | |
const Simplex< dim > * | regina::detail::TriangulationBase< dim >::simplex (size_t index) const |
Returns the top-dimensional simplex at the given index in the triangulation. More... | |
Simplex< dim > * | regina::detail::TriangulationBase< dim >::newSimplex () |
Creates a new top-dimensional simplex and adds it to this triangulation. More... | |
Simplex< dim > * | regina::detail::TriangulationBase< dim >::newSimplex (const std::string &desc) |
Creates a new top-dimensional simplex with the given description and adds it to this triangulation. More... | |
void | regina::detail::TriangulationBase< dim >::removeSimplex (Simplex< dim > *simplex) |
Removes the given top-dimensional simplex from this triangulation. More... | |
void | regina::detail::TriangulationBase< dim >::removeSimplexAt (size_t index) |
Removes the top-dimensional simplex at the given index in this triangulation. More... | |
void | regina::detail::TriangulationBase< dim >::removeAllSimplices () |
Removes all simplices from the triangulation. More... | |
void | regina::detail::TriangulationBase< dim >::swapContents (Triangulation< dim > &other) |
Swaps the contents of this and the given triangulation. More... | |
void | regina::detail::TriangulationBase< dim >::moveContentsTo (Triangulation< dim > &dest) |
Moves the contents of this triangulation into the given destination triangulation, without destroying any pre-existing contents. More... | |
Skeletal Queries | |
size_t | regina::detail::TriangulationBase< dim >::countComponents () const |
Returns the number of connected components in this triangulation. More... | |
size_t | regina::detail::TriangulationBase< dim >::countBoundaryComponents () const |
Returns the number of boundary components in this triangulation. More... | |
template<int subdim> | |
size_t | regina::detail::TriangulationBase< dim >::countFaces () const |
Returns the number of subdim-faces in this triangulation. More... | |
std::vector< size_t > | regina::detail::TriangulationBase< dim >::fVector () const |
Returns the f-vector of this triangulation, which counts the number of faces of all dimensions. More... | |
const std::vector< Component< dim > * > & | regina::detail::TriangulationBase< dim >::components () const |
Returns all connected components of this triangulation. More... | |
const std::vector< BoundaryComponent< dim > * > & | regina::detail::TriangulationBase< dim >::boundaryComponents () const |
Returns all boundary components of this triangulation. More... | |
template<int subdim> | |
const FaceList< dim, subdim > & | regina::detail::TriangulationBase< dim >::faces () const |
Returns an object that allows iteration through and random access to all subdim-faces of this triangulation. More... | |
Component< dim > * | regina::detail::TriangulationBase< dim >::component (size_t index) const |
Returns the requested connected component of this triangulation. More... | |
BoundaryComponent< dim > * | regina::detail::TriangulationBase< dim >::boundaryComponent (size_t index) const |
Returns the requested boundary component of this triangulation. More... | |
template<int subdim> | |
Face< dim, subdim > * | regina::detail::TriangulationBase< dim >::face (size_t index) const |
Returns the requested subdim-face of this triangulation. More... | |
Basic Properties | |
bool | regina::detail::TriangulationBase< dim >::isEmpty () const |
Determines whether this triangulation is empty. More... | |
bool | regina::detail::TriangulationBase< dim >::isValid () const |
Determines if this triangulation is valid. More... | |
bool | regina::detail::TriangulationBase< dim >::hasBoundaryFacets () const |
Determines if this triangulation has any boundary facets. More... | |
size_t | regina::detail::TriangulationBase< dim >::countBoundaryFacets () const |
Returns the total number of boundary facets in this triangulation. More... | |
bool | regina::detail::TriangulationBase< dim >::isOrientable () const |
Determines if this triangulation is orientable. More... | |
bool | regina::detail::TriangulationBase< dim >::isConnected () const |
Determines if this triangulation is connected. More... | |
bool | regina::detail::TriangulationBase< dim >::isOriented () const |
Determines if this triangulation is oriented; that is, if the vertices of its top-dimensional simplices are labelled in a way that preserves orientation across adjacent facets. More... | |
long | regina::detail::TriangulationBase< dim >::eulerCharTri () const |
Returns the Euler characteristic of this triangulation. More... | |
Algebraic Properties | |
const GroupPresentation & | regina::detail::TriangulationBase< dim >::fundamentalGroup () const |
Returns the fundamental group of this triangulation. More... | |
void | regina::detail::TriangulationBase< dim >::simplifiedFundamentalGroup (GroupPresentation *newGroup) |
Notifies the triangulation that you have simplified the presentation of its fundamental group. More... | |
const AbelianGroup & | regina::detail::TriangulationBase< dim >::homology () const |
Returns the first homology group for this triangulation. More... | |
const AbelianGroup & | regina::detail::TriangulationBase< dim >::homologyH1 () const |
Returns the first homology group for this triangulation. More... | |
Skeletal Transformations | |
void | regina::detail::TriangulationBase< dim >::orient () |
Relabels the vertices of top-dimensional simplices in this triangulation so that all simplices are oriented consistently, if possible. More... | |
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... | |
TriangulationBase & | regina::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... | |
Implementation details that end users should not need to reference directly.
typedef std::vector<BoundaryComponent<dim>*>::const_iterator regina::detail::TriangulationBase< dim >::BoundaryComponentIterator |
Used to iterate through boundary components.
typedef std::vector<Component<dim>*>::const_iterator regina::detail::TriangulationBase< dim >::ComponentIterator |
Used to iterate through connected components.
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.
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.
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.
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.
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.
typedef Property<AbelianGroup, StoreManagedPtr> regina::detail::XMLTriangulationReaderBase< dim >::AbelianGroupPropertyReader::PropType |
The type of the property currently being read.
typedef Property<GroupPresentation, StoreManagedPtr> regina::detail::XMLTriangulationReaderBase< dim >::GroupPresentationPropertyReader::PropType |
The type of the property currently being read.
typedef std::vector<Simplex<dim>*>::const_iterator regina::detail::TriangulationBase< dim >::SimplexIterator |
Used to iterate through top-dimensional simplices.
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.
|
inline |
Creates a new reader that stores its results in the given triangulation property.
prop | a reference to the triangulation property in which the data that is read should be stored. |
|
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].
null
.facet | the facet of this simplex that we are examining. This must be between 0 and dim inclusive. |
|
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:
null
.facet | the facet of this simplex that we are examining. This must be between 0 and dim inclusive. |
|
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.
facet | the facet of this simplex to examine; this must be between 0 and dim inclusive. |
|
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.
dim | the dimension of the underlying triangulations. |
subdim | the dimension of the faces in question. |
true
if such faces may be invalid, or false
if subdim-faces of dim-dimensional triangluations are always valid.
|
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.
dim | the dimension of the underlying triangulations. |
subdim | the dimension of the faces in question. |
true
if such faces may have non-orientable links, or false
if the links of subdim-faces of dim-dimensional triangluations are always orientable. 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.
original | the triangulation to which this isomorphism should be applied. |
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.
tri | the triangulation to which this isomorphism should be applied. |
|
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.
|
static |
Bounded Triangulations.
Returns a one-simplex triangulation of the dim-ball.
|
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.
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:
The sub-simplices have their vertices numbered in a way that mirrors the original simplex s:
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.
size_t
).
|
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.
|
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.
|
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.
index | specifies which boundary component to return; this should be between 0 and countBoundaryComponents()-1 inclusive. |
|
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.
index | the index of the desired boundary component; this must be between 0 and countBoundaryComponents()-1 inclusive. |
|
protecteddefault |
Default constructor that leaves orientability uninitialised.
|
inlineprotected |
Default constructor that initialises the number of ridges to zero.
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).
|
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.
|
inlineprotected |
Initialises the cached boundary triangulation to null
.
|
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:
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>().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.
|
inlineprotected |
Triangulates the vertex link for an ideal or invalid vertex boundary component.
|
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.
null
.
|
inlinestatic |
Calculates all faces of dimension ≤ subdim in the given triangulation.
t | the triangulation whose faces should be calculated. |
|
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.
true
if and only if the skeleton has been calculated.
|
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.
|
inlineprotected |
Resets all face pointers to null.
The faces themselves are not destroyed, and the mapping permutations are not touched.
|
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.
|
inline |
Returns the connected component of the triangulation to which this boundary component belongs.
|
inline |
Returns the connected component of the triangulation to which this boundary component belongs.
|
inline |
Returns the component of the triangulation to which this face belongs.
|
inline |
Returns the connected component of the triangulation to which this simplex belongs.
|
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.
index | the index of the desired component; this must be between 0 and countComponents()-1 inclusive. |
|
inlineprotected |
Default constructor.
Marks the component as orientable, with no boundary facets.
|
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.
|
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>()
.
tri | the triangulations whose face counts are to be computed. |
|
static |
Tests whether the given subdim-face of a dim-dimensional simplex contains the given vertex of the simplex.
face | a subdim-face number in a dim-simplex; this must be between 0 and (dim+1 choose subdim+1)-1 inclusive. |
vertex | a vertex number in a dim-simplex; this must be between 0 and dim inclusive. |
true
if and only if the given subdim-face contains the given vertex.
|
inline |
Returns the number of boundary components in this component.
|
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.
|
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).
|
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.
|
inline |
Returns the number of connected components in this triangulation.
|
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.
countFaces(subdim)
; that is, the template parameter subdim becomes the first argument of the function.subdim | the dimension of the faces to query. This must be between 0 and dim-1 inclusive. |
|
inline |
Returns the number of subdim-faces in this triangulation.
countFaces(subdim)
; that is, the template parameter subdim becomes the first argument of the function.
|
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.
|
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.
|
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.
|
inlineprotected |
Deletes all faces of dimension subdim and below.
This routine destroys the corresponding Face objects and clears the lists that contain them.
|
inline |
Returns the description associated with this simplex.
|
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()).
source | the facet under investigation. |
|
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()).
source | the facet under investigation. |
|
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()).
simp | the simplex under investigation (this must be strictly less than the total number of simplices under consideration). |
facet | the facet of the given simplex under investigation (between 0 and dim inclusive). |
|
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()).
simp | the simplex under investigation (this must be strictly less than the total number of simplices under consideration). |
facet | the facet of the given simplex under investigation (between 0 and dim inclusive). |
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.
|
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.
|
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.
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 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.
|
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])
.
i | the vertex of this simplex that forms one endpoint of the edge; this must be between 0 and dim inclusive. |
j | the 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. |
|
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).
index | the index of the requested appearance. This must be between 0 and degree()-1 inclusive. |
|
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.
|
inlineoverridevirtual |
Signifies that parsing has finished for a subelement of this XML element.
The default implementation does nothing.
subTagName | the name of the subelement closing tag. |
subReader | the child reader that was used to parse the subelement (this is the reader that was returned by the corresponding startSubElement() call). It is guaranteed that endElement() has already been called upon this child reader and that the child reader has not yet been destroyed. |
Reimplemented from regina::XMLElementReader.
|
inlineoverridevirtual |
Signifies that parsing has finished for a subelement of this XML element.
The default implementation does nothing.
subTagName | the name of the subelement closing tag. |
subReader | the child reader that was used to parse the subelement (this is the reader that was returned by the corresponding startSubElement() call). It is guaranteed that endElement() has already been called upon this child reader and that the child reader has not yet been destroyed. |
Reimplemented from regina::XMLElementReader.
|
inlineprotected |
Ensures that all "on demand" skeletal objects have been calculated.
|
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.
|
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.
|
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.
face(lowerdim, face)
; that is, the template parameter lowerdim becomes the first argument of the function.face | the lowerdim-face of this subdim-face to examine. This should be between 0 and (subdim+1 choose lowerdim+1)-1 inclusive. |
|
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.
face(subdim, face)
; that is, the template parameter subdim becomes the first argument of the function.face | the subdim-face of this simplex to examine. This should be between 0 and (dim+1 choose subdim+1)-1 inclusive. |
|
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.
face(subdim, index)
; that is, the template parameter subdim becomes the first argument of the function.subdim | the dimension of the face to query. This must be between 0 and dim-1 inclusive. |
index | the index of the desired face, ranging from 0 to countFaces<subdim>()-1 inclusive. |
|
inline |
Returns the requested subdim-face of this triangulation.
face(subdim, index)
; that is, the template parameter subdim becomes the first argument of the function.index | the index of the desired face, ranging from 0 to countFaces<subdim>()-1 inclusive. |
|
inlineprotected |
Creates a new face.
The face will be initialised as belong to no boundary component.
component | the component of the underlying triangulation to which the new face belongs. |
|
inline |
Default constructor.
This object is unusable until it has some data assigned to it using operator =
.
|
default |
Creates a new copy of the given object.
cloneMe | the object to copy. |
|
inline |
Creates a new object containing the given data.
simplex | the top-dimensional simplex in which the underlying subdim-face of the triangulation is contained. |
face | the corresponding face number of simplex. This must be between 0 and (dim+1 choose subdim+1)-1 inclusive. |
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):
See FaceNumbering<subdim, lowerdim> for the conventions of how lowerdim-faces are numbered within a subdim-simplex.
faceMapping(lowerdim, face)
; that is, the template parameter lowerdim becomes the first argument of the function.face | the lowerdim-face of this subdim-face to examine. This should be between 0 and (subdim+1 choose lowerdim+1)-1 inclusive. |
|
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:
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:
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.
faceMapping(subdim, face)
; that is, the template parameter subdim becomes the first argument of the function.face | the subdim-face of this simplex to examine. This should be between 0 and (dim+1 choose subdim+1)-1 inclusive. |
|
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]
.
vertices | a permutation whose first (subdim + 1) elements represent some vertex numbers in a dim-simplex. |
|
protected |
Initialises the link of this face as orientable.
|
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).
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.subdim | the dimension of the faces to query. This must be between 0 and dim-1 inclusive. |
|
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.
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.
|
protecteddefault |
Default constructor that leaves the list of embeddings empty.
|
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().
index | the index of the desired face, ranging from 0 to size()-1 inclusive. |
|
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().
index | the index of the desired face, ranging from 0 to size()-1 inclusive. |
|
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).
facet | the facet of this simplex that we are examining. This must be between 0 and dim inclusive. |
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. regina::detail::FacetPairingBase< dim >::FacetPairingBase | ( | const FacetPairingBase< dim > & | cloneMe | ) |
Creates a new facet pairing that is a clone of the given facet pairing.
cloneMe | the facet pairing to clone. |
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.
tri | the triangulation whose facet pairing should be constructed. |
|
inlineprotected |
Creates a new facet pairing.
All internal arrays will be allocated but not initialised.
size | the number of simplices under consideration in this new facet pairing. |
|
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)
.
sourceSimp | the index of the source simplex containing the original (dim + 1) facets; this must be between 0 and size()-1 inclusive. |
|
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)
.
sourceSimp | the index of the source simplex containing the original (dim + 1) facets; this must be between 0 and size()-1 inclusive. |
|
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).
|
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).
|
protected |
Initialises this face as valid.
|
inlineprotected |
Initialises this face as valid.
|
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.
result | the vector in which the results will be placed. |
|
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.
other | the triangulation to compare with this one. |
output | the output iterator to which the isomorphisms will be written. |
|
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.
nSimplices | the number of simplices whose facets should be (potentially) matched. |
boundary | determines whether any facets may be left unmatched. This set should contain true if pairings with at least one unmatched facet are to be generated, and should contain false if pairings with no unmatched facets are to be generated. |
nBdryFacets | specifies the precise number of facets that should be left unmatched. If this parameter is negative, it is ignored and no additional restriction is imposed. If parameter boundary does not contain true , this parameter is likewise ignored. If parameter boundary does contain true and this parameter is non-negative, only pairings with precisely this many unmatched facets will be generated. In particular, if this parameter is positive then pairings with no unmatched facets will not be produced irrespective of whether false is contained in parameter boundary. Note that, in order to produce any pairings at all, this parameter must be of the same parity as nSimplices * (dim+1) , and can be at most (dim-1) * nSimplices + 2 . |
use | the function to call upon each facet pairing that is found. The first parameter passed to this function will be a facet pairing. The second parameter will be a list of all its automorphisms (relabellings of simplices and individual simplex facets that produce the exact same pairing). The third parameter will be parameter useArgs as was passed to this routine. |
useArgs | the pointer to pass as the final parameter for the function use which will be called upon each pairing found. |
|
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.
other | the triangulation in which to search for isomorphic copies of this triangulation. |
output | the output iterator to which the isomorphisms will be written. |
|
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.
list | the list into which the newly created automorphisms will be placed. |
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).
true
if changes were made, or false
if the original triangulation contained no real boundary components.
|
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.
sig | the isomorphism signature of the triangulation to construct. Note that isomorphism signatures are case-sensitive (unlike, for example, dehydration strings for 3-manifolds). |
null
if the given string was not a valid dim-dimensional isomorphism signature.
|
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.
rep | a text-based representation of a facet pairing, as produced by routine toTextRep(). |
null
if the given text-based representation was invalid.
|
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.
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:
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.
|
inline |
Returns the f-vector of this triangulation, which counts the number of faces of all dimensions.
The vector that is returned will have length dim+1. If this vector is f, then f[k] will be the number of k-faces for each 0 ≤ k ≤ dim.
This routine is significantly more heavyweight than countFaces(). Its advantage is that, unlike the templatised countFaces(), it allows you to count faces whose dimensions are not known until runtime.
|
inline |
Creates a new reader that stores its results in the given triangulation property.
prop | a reference to the triangulation property in which the data that is read should be stored. |
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.
true
if and only if this face is identified with itself under a non-identity permutation.
|
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.
true
if and only if this face is identified with itself under a non-identity permutation. 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.
true
if and only if the link of this face is not appropriate. 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.
true
if and only if this simplex has any boundary facets.
|
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.
true
if and only if this component has boundary facet(s).
|
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.
true
if and only if there are boundary facets. 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:
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.
|
inline |
Returns the first homology group for this triangulation.
This is identical to calling homology(). See the homology() documentation for further details.
|
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.
t | the underlying triangulation. |
bc | the boundary component of t currently under construction. |
facet | a boundary facet that belongs to bc. |
|
inlinestatic |
Returns the identity isomorphism for the given number of simplices.
This isomorphism sends every simplex and every vertex to itself.
nSimplices | the number of simplices that the new isomorphism should operate upon. |
|
inline |
Returns the index of this boundary component in the underlying triangulation.
|
inline |
Returns the index of this component within the underlying triangulation.
|
inline |
Returns the index of this face within the underlying triangulation.
|
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.
|
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.
chars | the initial text for this element. |
Reimplemented from regina::XMLElementReader.
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).
true
if and only if this (dim-1)-face represents a dual edge in the maximal forest. 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.
nSimplices | the number of additional simplices to insert. |
adjacencies | describes which simplices are adjace to which others, as described above. This array must have initial dimension at least nSimplices. |
gluings | describes the specific gluing permutations, as described above. This array must also have initial dimension at least nSimplices. |
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.
source | the triangulation whose copy will be inserted. |
|
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.
true
if and only if this face lies on the boundary. 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)
.
true
if and only if this facet pairing is in canonical form.
|
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.
dest(t,i)
is greater than dest(t,i+1)
is where facets (t,i)
and (t,i+1)
are paired together. dest(t,0).simp < t
. dest(1,0)
, dest(2,0)
, ..., dest(n-1,0)
is strictly increasing, where n is the total number of simplices under investigation.list | the list into which automorphisms will be placed if appropriate. |
true
if and only if this facet pairing is in canonical form. bool regina::detail::FacetPairingBase< dim >::isClosed | ( | ) | const |
Determines whether this facet pairing is closed.
A closed facet pairing has no unmatched facets.
|
inline |
Determines if this triangulation is connected.
true
if and only if this triangulation is connected.
|
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().
other | the triangulation in which to search for an isomorphic copy of this triangulation. |
|
inline |
Determines whether this triangulation is empty.
An empty triangulation is one with no simplices at all.
true
if and only if this triangulation is empty.
|
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.
true
if and only if this boundary component is ideal. 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.)
other | the triangulation to compare with this one. |
true
if and only if the two triangulations are combinatorially identical. 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.
true
if this is an identity isomorphism, or false
otherwise.
|
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.
true
if and only if this boundary component consists of a single invalid vertex and nothing else.
|
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.
other | the triangulation to compare with this one. |
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.
true
if and only if the link is orientable.
|
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.
true
. 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).
|
inline |
Creates a new copy of the given isomorphism.
This constructor induces a deep copy of src.
src | the isomorphism to copy. |
|
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.
src | the isomorphism to move. |
|
inline |
Creates a new isomorphism with no initialisation.
The images of the simplices and their vertices must be explicitly set using simpImage() and facetPerm().
nSimplices | the number of simplices in the source triangulation associated with this isomorphism. This is allowed to be zero. |
|
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.
true
if and only if this boundary component is orientable.
|
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).
true
if and only if this component is orientable.
|
inline |
Determines if this triangulation is orientable.
true
if and only if this triangulation is orientable. 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.
true
if and only if all top-dimensional simplices are oriented consistently.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.
relabelling | if this is non-null, it will be modified to point to a new isomorphism that describes the relationship between this triangulation and the triangulation that will be reconstructed from fromIsoSig(), as described above. |
|
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.
sig | the isomorphism signature of a dim-dimensional triangulation. Note that isomorphism signature are case-sensitive (unlike, for example, dehydration strings for 3-manifolds). |
|
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.)
true
if and only if this boundary component is real.
|
inline |
Determines whether the given simplex facet has been left deliberately unmatched.
source | the facet under investigation. |
true
if the given facet has been left unmatched, or false
if the given facet is paired with some other facet.
|
inline |
Determines whether the given simplex facet has been left deliberately unmatched.
simp | the simplex under investigation (this must be strictly less than the total number of simplices under consideration). |
facet | the facet of the given simplex under investigation (between 0 and dim inclusive). |
true
if the given facet has been left unmatched, or false
if the given facet is paired with some other facet.
|
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.
true
if and only if this component is valid. 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:
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.
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).
|
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.
true
.
|
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.
true
if and only if this face is not identified with itself under a non-identity permutation.
|
inline |
Determines if this triangulation is valid.
There are several conditions that might make a dim-dimensional triangulation invalid:
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.
true
if and only if this triangulation is valid. 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.
this
and gluing[myFacet] == myFacet).myFacet | the facet of this simplex that will be glued to the given simplex you. This facet number must be between 0 and dim inclusive. |
you | the other simplex that will be glued to the given facet of this simplex. |
gluing | a permutation that describes how the vertices of this simplex will map to the vertices of you across the new gluing. This permutation should be in the form described by adjacentGluing(). |
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).
true
if the triangulation was changed, or false
if the triangulation was in canonical form to begin with. 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.
|
protected |
Marks this face as having a non-identity self-identification.
|
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.
|
inlineprotected |
Marks this face as having a non-identity self-identification.
|
protected |
Marks this face as having a bad link.
|
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.
|
protected |
Marks the link of this face as non-orientable.
|
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.
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.
dest | the triangulation into which simplices should be moved. |
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.
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.
desc | the description to give to the new simplex. |
|
inlineprotected |
Determines whether the matching for the given simplex facet has not yet been determined.
This is signalled by a facet matched to itself.
source | the facet under investigation. |
true
if the matching for the given facet has not yet been determined, or false
otherwise.
|
inlineprotected |
Determines whether the matching for the given simplex facet has not yet been determined.
This is signalled by a facet matched to itself.
simp | the simplex under investigation (this must be strictly less than the total number of simplices under consideration). |
facet | the facet of the given simplex under investigation (between 0 and dim inclusive). |
true
if the matching for the given facet has not yet been determined, or false
otherwise.
|
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.
rhs | the object to compare with this. |
true
if and only if both object are identical.
|
inline |
Tests whether this and the given iterator point to different faces.
|
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.
|
inline |
Preincrement operator that steps to the next face in this list.
|
inline |
Postincrement operator that steps to the next face in this list.
|
default |
Makes this a copy of the given object.
cloneMe | the object to copy. |
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.
src | the isomorphism to copy. |
|
default |
Assignment operator.
|
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.
src | the isomorphism to move. |
|
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.
rhs | the object to compare with this. |
true
if and only if both object are identical.
|
inline |
Tests whether this and the given iterator point to the same face.
|
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()).
source | the facet under investigation. |
|
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()).
source | the facet under investigation. |
|
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.
source | the given source simplex facet; this must be one of the (dim + 1) facets of one of the size() simplices in the source triangulation. |
|
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>():
face | identifies which subdim-face of a dim-dimensional simplex to query. This must be between 0 and (dim+1 choose subdim+1)-1 inclusive. |
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.
|
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).
|
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()
.
simplices().back()->vertex(dim)
, and as of version 5.96 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.f | the k-face about which to perform the move. |
check | true if we are to check whether the move is allowed (defaults to true ). |
perform | true if we are to perform the move (defaults to true ). |
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
.k | the 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). |
|
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.
tri | the triangulation upon which to perform the Pachner move. |
f | the specific k-face about which to perform the move. |
check | true if the move should be tested for eligibility. |
perform | true if the move should actually be performed. |
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
.
|
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
.
subTagName | the name of the XML subelement opening tag. |
subTagProps | the properties associated with the subelement opening tag. |
null
otherwise.
|
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.
emb | the appearance to push onto the end of the internal list. |
|
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.
face | the face to append to the list. |
|
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.
|
inlineprotected |
Does nothing, since this boundary component does not store lower-dimensional faces.
subdim | the dimension of the given face. This must be between 0 and dim-3 inclusive. |
|
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.
subdim | the dimension of the face to append. This must be between 0 and dim-1 inclusive. |
face | the face to append to the list. |
|
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.
All possible isomorphisms for the given number of simplices are equally likely.
This routine is thread-safe, and uses RandomEngine for its random number generation.
nSimplices | the number of simplices that the new isomorphism should operate upon. |
even | if 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. |
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.
|
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.
|
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.
simplex | the simplex to remove. |
|
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.
index | specifies which top-dimensionalsimplex to remove; this must be between 0 and size()-1 inclusive. |
|
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.
|
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).
tri | a triangulation of this boundary component, as described above. |
|
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.
tri->simplex(j)
to the ith subdim-face of tridimFaces[j]
.tridim | the dimension of the given triangulation. This must be strictly larger than subdim, but it need not be equal to dim. |
tri | a tridim-dimensional triangulation, as described above. |
tridimFaces | a list of tridim-faces that together contain all of the faces in this list, and that are in an ordered one-to-one correspondence with the top-dimensional simplices of tri as described in the precondition above. |
|
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.
tri->simplex(j)
to the ith k-face of tridimFaces[j]
.tridim | the dimension of the given triangulation. This must be strictly larger than subdim, but it need not be equal to dim. |
tri | a tridim-dimensional triangulation, as described above. |
tridimFaces | a list of tridim-faces that together contain all of the faces in this suite, and that are in an ordered one-to-one correspondence with the top-dimensional simplices of tri as described in the precondition above. |
|
inline |
Creates an uninitialised iterator.
|
default |
Copy constructor.
|
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.
|
inlineprotected |
Tests whether this and the given triangulation have the same k-face degree sequences, for each facial dimension k ≤ subdim.
For the purposes of this routine, degree sequences are considered to be unordered.
other | the triangulation to compare against this. |
true
if and only if all degree sequences considered are equal.
|
protected |
Tests whether the subdim-face degrees of this and the given simplex are identical, under the given relabelling.
other | the simplex to compare against this. |
p | a mapping from the vertices of this simplex to the vertices of other. |
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.
|
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 k ≤ subdim.
other | the simplex to compare against this. |
p | a mapping from the vertices of this simplex to the vertices of other. |
true
if and only if, for every i and every facial dimension k ≤ subdim, k-face number i of this simplex has the same degree as its image in other under the relabelling p.
|
inlineprotected |
Tests whether this and the given triangulation have the same number of k-faces, for each facial dimension k ≤ subdim.
other | the triangulation to compare against this. |
true
if and only if the face counts considered are identical for both triangluations.
|
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.
desc | the new description to assign to this simplex. |
|
inline |
Determines the image of the given source simplex under this isomorphism.
sourceSimp | the index of the source simplex; this must be between 0 and size()-1 inclusive. |
|
inline |
Determines the image of the given source simplex under this isomorphism.
sourceSimp | the index of the source simplex; this must be between 0 and size()-1 inclusive. |
|
staticconstexpr |
The XML tag that stores a single top-dimensional simplex in a dim-dimensional triangulation.
|
inline |
Returns the top-dimensional simplex in which the underlying subdim-face of the triangulation is contained.
|
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.
index | specifies which simplex to return; this value should be between 0 and size()-1 inclusive. |
|
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.
index | specifies which simplex to return; this value should be between 0 and size()-1 inclusive. |
|
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.
index | specifies which simplex to return; this value should be between 0 and size()-1 inclusive. |
|
inlineprotected |
Creates a new simplex with the given description and no facets joined to anything.
desc | the description to give the new simplex. |
tri | the triangulation to which the new simplex belongs. |
|
inlineprotected |
Creates a new simplex with no description and no facets joined to anything.
tri | the triangulation to which the new simplex belongs. |
|
staticconstexpr |
The XML tag that stores the set of all top-dimensional simplices for a dim-dimensional triangulation.
|
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).
|
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.
|
static |
Returns the standard (dim+2)-simplex triangulation of the dim-sphere as the boundary of a (dim+1)-simplex.
|
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.
newGroup | a new (and hopefully simpler) presentation of the fundamental group of this triangulation. |
|
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.
|
staticconstexpr |
The XML attribute that stores the number of top-dimensional simplices in a dim-dimensional triangulation.
|
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.
|
inline |
Returns the number of (dim-1)-faces in this boundary component.
These are the top-dimensional faces for a real boundary component.
|
inline |
Returns the number of top-dimensional simplices in this component.
|
inline |
Returns the number of simplices whose facets are described by this facet pairing.
|
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.
|
inline |
Returns the number of top-dimensional simplices in the triangulation.
|
static |
Closed Triangulations.
Returns a two-simplex triangulation of the dim-sphere.
|
static |
Returns a two-simplex triangulation of the product space S^(dim-1) x S^1
.
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.
componentParent | the packet beneath which the new component triangulations will be inserted, or null if they should be inserted directly beneath this triangulation. |
setLabels | true if the new component triangulations should be assigned sensible packet labels, or false if they should be left without labels at all. |
|
inlineoverridevirtual |
Signifies that parsing of this XML element is beginning.
The default implementation does nothing.
tagName | the name of the opening tag for this element. |
tagProps | the properties associated with the opening tag. |
parentReader | the reader currently parsing the parent XML element, or 0 if this is the top-level element. If this paraneter is non-zero, it is guaranteed that startSubElement() has already been called upon the parent reader. |
Reimplemented from regina::XMLElementReader.
|
overridevirtual |
Signifies that parsing of this XML element is beginning.
The default implementation does nothing.
tagName | the name of the opening tag for this element. |
tagProps | the properties associated with the opening tag. |
parentReader | the reader currently parsing the parent XML element, or 0 if this is the top-level element. If this paraneter is non-zero, it is guaranteed that startSubElement() has already been called upon the parent reader. |
Reimplemented from regina::XMLElementReader.
|
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.
subTagName | the name of the subelement opening tag. |
subTagProps | the properties associated with the subelement opening tag. |
Reimplemented from regina::XMLElementReader.
|
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.
subTagName | the name of the subelement opening tag. |
subTagProps | the properties associated with the subelement opening tag. |
Reimplemented from regina::XMLElementReader.
|
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.
subTagName | the name of the subelement opening tag. |
subTagProps | the properties associated with the subelement opening tag. |
Reimplemented from regina::XMLElementReader.
|
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().
other | the triangulation whose properties should be swapped with this. |
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.
other | the triangulation whose contents should be swapped with this. |
|
inlineprotected |
Swaps all faces of dimension subdim and below with those of the given triangulation.
other | the face storage for the triangulation whose faces are to be swapped with this. |
regina::detail::TriangulationBase< dim >::TopologyLock::TopologyLock | ( | TriangulationBase< dim > * | tri | ) |
Creates a new lock on the given triangulation.
tri | the triangulation whose topological properties are to be locked. This may be null (in which case the lock has no effect). |
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.
|
inline |
Returns the triangulation to which this boundary component belongs.
|
inline |
Returns the triangulation to which this boundary component belongs.
|
inline |
Returns the triangulation to which this face belongs.
|
inline |
Returns the triangulation to which this simplex belongs.
|
inline |
Default constructor.
Creates an empty triangulation.
|
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.
copy | the triangulation to copy. |
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.
copy | the triangulation to copy. |
cloneProps | true if this should also clone any computed properties of the given triangulation (such as homology, fundamental group, and so on), or false if the new triangulation should have all properties marked as unknown. |
|
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.
|
static |
Returns a two-simplex triangulation of the twisted product space S^(dim-1) x~ S^1
.
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).
myFacet | the facet of this simplex whose gluing we will undo. This should be between 0 and dim inclusive. |
|
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.
|
protecteddefault |
Default constructor that leaves the list of faces empty.
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.
out | the output stream to which to write. |
prefix | a string to prepend to the name of each graph vertex, and to include in the graph or subgraph name; see above for details. |
subgraph | false if a complete standalone DOT graph should be output, or true if a clustered subgraph should be output for use in some larger DOT file. |
labels | indicates whether graph vertices will be labelled with the corresponding simplex numbers. This feature is currently experimental, and the default is false . |
|
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.
out | the output stream to which to write. |
graphName | the name of the graph in the DOT file. If this is null or empty then a default graph name will be used. |
|
inline |
Writes a detailed text representation of this object to the given output stream.
out | the output stream to which to write. |
|
inline |
Writes a detailed text representation of this object to the given output stream.
out | the output stream to which to write. |
void regina::detail::ComponentBase< dim >::writeTextLong | ( | std::ostream & | out | ) | const |
Writes a detailed text representation of this object to the given output stream.
out | the output stream to which to write. |
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.
out | the output stream to which to write. |
|
inline |
Writes a detailed text representation of this object to the given output stream.
out | the output stream to which to write. |
void regina::detail::SimplexBase< dim >::writeTextLong | ( | std::ostream & | out | ) | const |
Writes a detailed text representation of this object to the given output stream.
out | the output stream to which to write. |
|
inline |
Writes a short text representation of this object to the given output stream.
out | the output stream to which to write. |
|
inline |
Writes a short text representation of this object to the given output stream.
out | the output stream to which to write. |
void regina::detail::ComponentBase< dim >::writeTextShort | ( | std::ostream & | out | ) | const |
Writes a short text representation of this object to the given output stream.
out | the output stream to which to write. |
|
inline |
Writes a short text representation of this object to the given output stream.
out | the output stream to which to write. |
|
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.
out | the output stream to which to write. |
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.
out | the output stream to which to write. |
|
inline |
Writes a short text representation of this object to the given output stream.
out | the output stream to which to write. |
|
inline |
Writes a short text representation of this object to the given output stream.
out | the output stream to which to write. |
|
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.
out | the output stream to which the XML should be written. |
|
inline |
Creates a new simplex element reader.
tri | the triangulation containing the simplex being read. |
whichSimplex | the index of the simplex being read within the triangulation tri. |
|
inline |
Creates a new simplices element reader.
The given triangulation should be empty; its simplices will be created by this reader.
tri | the triangulation being read. |
|
inline |
Creates a new triangulation reader.
resolver | the master resolver that will be used to fix dangling packet references after the entire XML file has been read. |
regina::detail::BoundaryComponentStorage< dim, allFaces, allowVertex, canBuild_ >::~BoundaryComponentStorage | ( | ) |
Destroys this object.
The cached boundary component triangulation will be destroyed also.
|
inline |
Deallocates any memory used by this structure.
|
inline |
Destroys this isomorphism.
regina::detail::TriangulationBase< dim >::TopologyLock::~TopologyLock |
Removes this lock on the associated triangulation.
|
inline |
Destroys this triangulation.
The simplices within this triangulation will also be destroyed.
|
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.
|
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.
|
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.
|
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.
|
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.
|
protected |
The components that form the boundary of the triangulation.
|
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.
|
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.
|
staticconstexpr |
A string that gives the dimension dim as a number.
An example for dim = 3 is "3".
|
staticconstexpr |
A compile-time constant that gives the dimension of the triangulation.
|
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.
edgeNumber[i][j]
is equivalent to calling faceNumber(p)
, where p is a permutation that maps 0,1 to i,j in some order.
|
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.
edgeNumber[i][j]
is equivalent to calling faceNumber(p)
, where p is a permutation that maps 0,1 to i,j in some order.
|
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]
.
edgeVertex[i][j]
is equivalent to calling ordering(i)[j]
.
|
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]
.
edgeVertex[i][j]
is equivalent to calling ordering(i)[j]
.
|
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".
|
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".
|
protected |
The faces of the underlying triangulation that form the individual subdim-faces of this simplex.
|
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".
|
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".
|
protected |
The list of faces.
|
protected |
The permutation applied to the facets of each source simplex.
This array has size nSimplices_.
|
protected |
List of all (dim-1)-simplices in the boundary component.
|
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().
|
staticconstexpr |
|
staticconstexpr |
The total number of subdim-dimensional faces in each dim-dimensional simplex.
|
staticconstexpr |
The total number of vertices in each dim-dimensional simplex.
|
staticconstexpr |
The total number of vertices in each edge.
|
staticconstexpr |
The total number of vertices in each triangle.
|
staticconstexpr |
The total number of edges in each triangle.
|
staticconstexpr |
The total number of vertices in each tetrahedron.
|
staticconstexpr |
The total number of edges in each tetrahedron.
|
staticconstexpr |
The total number of triangles in each tetrahedron.
|
staticconstexpr |
The total number of vertices in each pentachoron.
|
staticconstexpr |
The total number of edges in each pentachoron.
|
staticconstexpr |
The total number of triangles in each pentachoron.
|
staticconstexpr |
The total number of tetrahedra in each pentachoron.
|
protected |
The number of (dim-2)-faces in the boundary component.
|
protected |
The number of simplices in the source triangulation.
|
protected |
Is this boundary component orientable?
|
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.
|
protected |
Stores the simplex of the destination triangulation that each simplex of the source triangulation maps to.
This array has size nSimplices_.
|
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".
|
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".
|
protected |
The top-dimensional simplices that form the triangulation.
|
protected |
The number of simplices under consideration.
|
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.
|
protected |
The triangulation currently being read.
|
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.
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.
|
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]
.
triangleVertex[i][j]
is equivalent to calling ordering(i)[j]
.
|
protected |
Is this component valid? See Triangulation<dim>::isValid() for details on what this means.
|
protected |
Is this triangulation valid? See isValid() for details on what this means.
|
friend |
Allow access to private members.