Regina Calculation Engine
Public Types | Public Member Functions | Static Public Member Functions | Static Public Attributes | Protected Member Functions | Friends | List of all members
regina::Face< 3, 0 > Class Template Reference

Represents a vertex in the skeleton of a 3-manifold triangulation. More...

#include <triangulation/dim3.h>

Inheritance diagram for regina::Face< 3, 0 >:
regina::detail::FaceBase< 3, 0 > regina::detail::FaceStorage< dim, dim - subdim > regina::detail::FaceValidity< allowsInvalidFaces(dim, subdim), standardDim(dim)> regina::detail::FaceOrientability< allowsNonOrientableLinks(dim, subdim)> regina::FaceNumbering< dim, subdim > regina::MarkedElement regina::alias::FaceOfSimplex< FaceBase< dim, subdim >, dim, subdim - 1 > regina::Output< Face< dim, subdim > > regina::detail::FaceNumberingImpl< dim, subdim,((dim+1) >=2 *(subdim+1))> regina::detail::FaceNumberingAPI< dim, subdim >

Public Types

enum  LinkType {
  SPHERE = 1, DISC = 2, TORUS = 3, KLEIN_BOTTLE = 4,
  NON_STANDARD_CUSP = 5, INVALID = 6
}
 Categorises the possible links of a vertex into a small number of common types. More...
 

Public Member Functions

 ~Face ()
 Default destructor. More...
 
LinkType link () const
 Returns a broad categorisation of the link of the vertex. More...
 
const Triangulation< 2 > * buildLink () const
 
Returns a full 2-manifold triangulation describing the link of this vertex. More...
 
Triangulation< 2 > * buildLinkDetail (bool labels=true, Isomorphism< 3 > **inclusion=0) const
 
Returns a full 2-manifold triangulation describing the link of this vertex. More...
 
bool isLinkClosed () const
 Determines if the link of this vertex is closed. More...
 
bool isIdeal () const
 Determines if this vertex is an ideal vertex. More...
 
bool isStandard () const
 Determines if this vertex is standard. More...
 
REGINA_INLINE_REQUIRED long linkEulerChar () const
 Returns the Euler characteristic of the vertex link. More...
 
void writeTextShort (std::ostream &out) const
 
Writes a short text representation of this object to the given output stream. More...
 
size_t index () const
 Returns the index of this face within the underlying triangulation. More...
 
Triangulation< dim > * triangulation () const
 Returns the triangulation to which this face belongs. More...
 
Component< dim > * component () const
 Returns the component of the triangulation to which this face belongs. More...
 
BoundaryComponent< dim > * boundaryComponent () const
 Returns the boundary component of the triangulation to which this face belongs. More...
 
bool isBoundary () const
 Determines if this face lies entirely on the boundary of the triangulation. More...
 
Face< dim, lowerdim > * face (int face) const
 
Returns the lowerdim-face of the underlying triangulation that appears as the given lowerdim-dimensional subface of this face. More...
 
Perm< dim+1 > 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 writeTextLong (std::ostream &out) const
 
Writes a detailed text representation of this object to the given output stream. More...
 
size_t degree () const
 Returns the degree of this face. More...
 
const FaceEmbedding< dim, 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 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 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 > & front () const
 Returns the first appearance of this face within a top-dimensional simplex of the underlying triangluation. More...
 
const FaceEmbedding< dim, dim - codim > & back () const
 Returns the last appearance of this face within a top-dimensional simplex of the underlying triangluation. More...
 
bool 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...
 
bool isValid () const
 Determines if this face is valid. More...
 
bool hasBadIdentification () const
 Determines if this face is identified with itself under a non-identity permutation. More...
 
bool hasBadLink () const
 Determines if this face does not have an appropriate link. More...
 
bool isLinkOrientable () const
 Determines if the link of this face is orientable. More...
 
size_t markedIndex () const
 Returns the index at which this object is stored in an MarkedVector. More...
 
std::string str () const
 
Returns a short text representation of this object. More...
 
std::string utf8 () const
 Returns a short text representation of this object using unicode characters. More...
 
std::string detail () const
 Returns a detailed text representation of this object. More...
 

Static Public Member Functions

static Perm< dim+1 > 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 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 containsVertex (unsigned face, unsigned vertex)
 Tests whether the given subdim-face of a dim-dimensional simplex contains the given vertex of the simplex. More...
 

Static Public Attributes

static constexpr int nFaces
 The total number of subdim-dimensional faces in each dim-dimensional simplex. More...
 

Protected Member Functions

void push_back (const FaceEmbedding< dim, dim - codim > &emb)
 Internal routine to help build the skeleton of a triangulation. More...
 
void markBadIdentification ()
 Marks this face as having a non-identity self-identification. More...
 
void markBadLink ()
 Marks this face as having a bad link. More...
 
void markLinkNonorientable ()
 Marks the link of this face as non-orientable. More...
 

Friends

class Triangulation< 3 >
 
class detail::TriangulationBase< 3 >
 

Detailed Description

template<>
class regina::Face< 3, 0 >

Represents a vertex in the skeleton of a 3-manifold triangulation.

This is a specialisation of the generic Face class template; see the documentation for Face for a general overview of how this class works.

These specialisations for Regina's standard dimensions offer significant extra functionality.

Member Enumeration Documentation

◆ LinkType

enum regina::Face< 3, 0 >::LinkType

Categorises the possible links of a vertex into a small number of common types.

Here a vertex link is considered only up to its topology (not the combinatorics of its triangulation).

See also
link
Enumerator
SPHERE 

Specifies a vertex link that is a sphere.

In other words, the vertex is internal.

DISC 

Specifies a vertex link that is a disc.

In other words, the vertex lies on a real boundary component.

TORUS 

Specifies a vertex link that is a torus.

In other words, this is an ideal vertex representing a torus cusp.

KLEIN_BOTTLE 

Specifies a vertex link that is a Klein bottle.

In other words, this is an ideal vertex representing a Klein bottle cusp.

NON_STANDARD_CUSP 

Specifies a vertex link that is closed and is not a sphere, torus or Klein bottle.

In other words, this is an ideal vertex but not one of the standard ideal vertex types.

INVALID 

Specifies a vertex link that has boundary and is not a disc.

In other words, this vertex makes the triangulation invalid.

Constructor & Destructor Documentation

◆ ~Face()

regina::Face< 3, 0 >::~Face ( )

Default destructor.

Member Function Documentation

◆ back()

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

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

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

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

Returns
details of the last appearance.

◆ begin()

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


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

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

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

Python
Not present. However, Python users can call the Python-only routine embeddings(), which will return all appearances (from begin() through to end()) in a Python sequence.
Returns
a iterator that points to the first appearance.

◆ boundaryComponent()

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

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

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

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

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

◆ buildLink()

const Triangulation< 2 > * regina::Face< 3, 0 >::buildLink ( ) const
inline


Returns a full 2-manifold triangulation describing the link of this vertex.

This routine is fast (it uses a pre-computed triangulation if possible). The downside is that the triangulation is read-only, and does not contain any information on how the triangles in the link correspond to tetrahedra in the original triangulation (though this is easily deduced; see below). If you want a writable triangulation, or one with this extra information, then call buildLinkDetail() instead.

The triangulation of the vertex link is built as follows. Let i lie between 0 and degree()-1 inclusive, let tet represent embedding(i).tetrahedron(), and let v represent embedding(i).vertex(). Then buildLink()->triangle(i) is the triangle in the vertex link that "slices off" vertex v from tetrahedron tet. In other words, buildLink()->triangle(i) in the vertex link is parallel to triangle tet->triangle(v) in the surrounding 3-manifold triangulation.

The vertices of each triangle in the vertex link are numbered as follows. Following the discussion above, suppose that buildLink()->triangle(i) sits within tet and is parallel to tet->triangle(v). Then vertices 0,1,2 of the triangle in the link will be parallel to vertices 0,1,2 of the corresponding Triangle<3>. The permutation tet->triangleMapping(v) will map vertices 0,1,2 of the triangle in the link to the corresponding vertices of tet (those opposite v), and will map 3 to v itself.

This Vertex<3> object will retain ownership of the triangulation that is returned. If you wish to edit the triangulation, you should make a new clone and edit the clone instead.

Python
Since Python does not distinguish between const and non-const, this routine will make a deep copy of the vertex link. You are free to modify the triangulation that is returned.
Returns
the read-only triangulated link of the vertex.

◆ buildLinkDetail()

Triangulation<2>* regina::Face< 3, 0 >::buildLinkDetail ( bool  labels = true,
Isomorphism< 3 > **  inclusion = 0 
) const


Returns a full 2-manifold triangulation describing the link of this vertex.

This routine is heavyweight (it computes a new triangulation each time). The benefit is that the triangulation is writeable, and optionally contain detailed information on how the triangles in the link correspond to tetrahedra in the original triangulation. If you do not need this extra information, consider using the faster buildLink() instead.

See the buildLink() documentation for an explanation of exactly how the triangulation will be constructed.

If labels is passed as true, each triangle of the new vertex link will be given a text description of the form t (v), where t is the index of the tetrahedron the triangle is from, and v is the vertex of that tetrahedron that this triangle links.

If inclusion is non-null (i.e., it points to some Isomorphism<3> pointer p), then it will be modified to point to a new Isomorphism<3> that describes in detail how the individual triangles of the link sit within tetrahedra of the original triangulation. Specifically, after this routine is called, p->tetImage(i) will indicate which tetrahedron tet of the 3-manifold triangulation contains the ith triangle of the link. Moreover, p->facePerm(i) will indicate exactly where the ith triangle sits within tet: it will send 3 to the vertex of t that the triangle links, and it will send 0,1,2 to the vertices of tet that are parallel to vertices 0,1,2 of this triangle.

The triangulation that is returned, as well as the isomorphism if one was requested, will be newly allocated. The caller of this routine is responsible for destroying these objects.

Strictly speaking, this is an abuse of the Isomorphism<3> class (the domain is a triangulation of the wrong dimension, and the map is not 1-to-1 into the range tetrahedra). We use it anyway, but you should not attempt to call any high-level routines (such as Isomorphism<3>::apply).

Python
The second (isomorphism) argument is not present. Instead this routine returns a pair (triangulation, isomorphism). As a side-effect, the isomorphism will always be constructed (i.e., it is not optional).
Python
Since Python does not distinguish between const and non-const, this routine will make a deep copy of the vertex link. You are free to modify the triangulation that is returned.
Returns
a newly constructed triangulation of the link of this vertex.

◆ component()

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

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

Returns
the component containing this face.

◆ containsVertex()

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

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

Parameters
facea subdim-face number in a dim-simplex; this must be between 0 and (dim+1 choose subdim+1)-1 inclusive.
vertexa vertex number in a dim-simplex; this must be between 0 and dim inclusive.
Returns
true if and only if the given subdim-face contains the given vertex.

◆ degree()

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

Returns the degree of this face.

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

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

Returns
the degree of this face.

◆ detail()

std::string regina::Output< Face< dim, subdim > , false >::detail ( ) const
inherited

Returns a detailed text representation of this object.

This text may span many lines, and should provide the user with all the information they could want. It should be human-readable, should not contain extremely long lines (which cause problems for users reading the output in a terminal), and should end with a final newline. There are no restrictions on the underlying character set.

Returns
a detailed text representation of this object.

◆ embedding()

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

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

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

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

Parameters
indexthe index of the requested appearance. This must be between 0 and degree()-1 inclusive.
Returns
details of the requested appearance.

◆ end()

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


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

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

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

Python
Not present. However, Python users can call the Python-only routine embeddings(), which will return all appearances (from begin() through to end()) in a Python sequence.
Returns
a "beyond the end" iterator that comes immediately after the last appearance.

◆ face()

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


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

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

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

Python
Python does not support templates. Instead, Python users should call this function in the form face(lowerdim, face); that is, the template parameter lowerdim becomes the first argument of the function.
Parameters
facethe lowerdim-face of this subdim-face to examine. This should be between 0 and (subdim+1 choose lowerdim+1)-1 inclusive.
Returns
the corresponding lowerdim-face of the triangulation.

◆ faceMapping()

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


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

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

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

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

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

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

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

Python
Python does not support templates. Instead, Python users should call this function in the form faceMapping(lowerdim, face); that is, the template parameter lowerdim becomes the first argument of the function.
Parameters
facethe lowerdim-face of this subdim-face to examine. This should be between 0 and (subdim+1 choose lowerdim+1)-1 inclusive.
Returns
a mapping from the vertices of the underlying lowerdim-face of the triangulation to the vertices of this subdim-face.

◆ faceNumber()

template<int dim, int subdim>
static unsigned regina::detail::FaceNumberingAPI< dim, subdim >::faceNumber ( Perm< dim+1 >  vertices)
staticinherited

Identifies which subdim-face in a dim-dimensional simplex is represented by the first (subdim + 1) elements of the given permutation.

In other words, this routine identifies which subdim-face number within a dim-dimensional simplex spans vertices vertices[0, ..., subdim].

Parameters
verticesa permutation whose first (subdim + 1) elements represent some vertex numbers in a dim-simplex.
Returns
the corresponding subdim-face number in the dim-simplex. This will be between 0 and (dim+1 choose subdim+1)-1 inclusive.

◆ front()

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

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

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

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

Returns
details of the first appearance.

◆ hasBadIdentification()

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

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

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

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

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

◆ hasBadLink()

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

Determines if this face does not have an appropriate link.

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

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

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

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

◆ index()

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

Returns the index of this face within the underlying triangulation.

Returns
the index of this face.

◆ inMaximalForest()

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

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

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

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

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

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

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

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

◆ isBoundary()

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

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

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

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

◆ isIdeal()

bool regina::Face< 3, 0 >::isIdeal ( ) const
inline

Determines if this vertex is an ideal vertex.

This requires the vertex link to be closed and not a 2-sphere.

Returns
true if and only if this is an ideal vertex.

◆ isLinkClosed()

bool regina::Face< 3, 0 >::isLinkClosed ( ) const
inline

Determines if the link of this vertex is closed.

Returns
true if and only if the link of this vertex is closed.

◆ isLinkOrientable()

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

Determines if the link of this face is orientable.

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

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

◆ isStandard()

bool regina::Face< 3, 0 >::isStandard ( ) const
inline

Determines if this vertex is standard.

This requires the vertex link to be a sphere, disc, torus or Klein bottle.

Returns
true if and only if this vertex is standard.

◆ isValid()

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

Determines if this face is valid.

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

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

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

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

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

◆ link()

Vertex< 3 >::LinkType regina::Face< 3, 0 >::link ( ) const
inline

Returns a broad categorisation of the link of the vertex.

This considers topological information only, not the combinatorics of how the link is triangulated.

This routine does not require a full triangulation of the vertex link, and so can be much faster than analysing the result of buildLink().

Returns
a broad categorisation of the vertex link.

◆ linkEulerChar()

long regina::Face< 3, 0 >::linkEulerChar ( ) const
inline

Returns the Euler characteristic of the vertex link.

This routine does not require a full triangulation of the vertex link, and so can be much faster than calling buildLink().eulerChar().

Returns
the Euler characteristic of the vertex link.

◆ markBadIdentification()

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

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

◆ markBadLink()

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

Marks this face as having a bad link.

◆ markedIndex()

size_t regina::MarkedElement::markedIndex ( ) const
inlineinherited

Returns the index at which this object is stored in an MarkedVector.

If this object does not belong to an MarkedVector, the return value is undefined.

Returns
the index at which this object is stored.

◆ markLinkNonorientable()

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

Marks the link of this face as non-orientable.

◆ ordering()

template<int dim, int subdim>
static Perm<dim + 1> regina::detail::FaceNumberingAPI< dim, subdim >::ordering ( unsigned  face)
staticinherited

Given a subdim-face number within a dim-dimensional simplex, returns the corresponding canonical ordering of the simplex vertices.

If this canonical ordering is c, then c[0,...,subdim] will be the vertices of the given face in increasing numerical order. That is, c[0] < ... < c[subdim]. The remaining images c[(subdim + 1),...,dim] will be ordered arbitrarily.

Note that this is not the same permutation as returned by Simplex<dim>::faceMapping<subdim>():

  • ordering() is a static function, which returns the same permutation for the same face number, regardless of which dim-simplex we are looking at. The images of 0,...,subdim will always appear in increasing order, and the images of (subdim + 1),...,dim will be arbitrary.
  • faceMapping() examines the underlying face F of the triangulation and, across all appearances of F in different dim-simplices: (i) chooses the images of 0,...,subdim to map to the same respective vertices of F; and (ii) chooses the images of (subdim + 1),...,dim to maintain a "consistent orientation" constraint.
Parameters
faceidentifies which subdim-face of a dim-dimensional simplex to query. This must be between 0 and (dim+1 choose subdim+1)-1 inclusive.
Returns
the corresponding canonical ordering of the simplex vertices.

◆ push_back()

void regina::detail::FaceStorage< dim, codim >::push_back ( const FaceEmbedding< dim, dim - codim > &  emb)
inlineprotectedinherited

Internal routine to help build the skeleton of a triangulation.

This routine pushes the given object onto the end of the internal list of appearances of this face within top-dimensional simplices.

Parameters
embthe appearance to push onto the end of the internal list.

◆ str()

std::string regina::Output< Face< dim, subdim > , false >::str ( ) const
inherited


Returns a short text representation of this object.

This text should be human-readable, should fit on a single line, and should not end with a newline. Where possible, it should use plain ASCII characters.

Python
In addition to str(), this is also used as the Python "stringification" function __str__().
Returns
a short text representation of this object.

◆ triangulation()

Triangulation< dim > * regina::detail::FaceBase< dim, subdim >::triangulation ( ) const
inlineinherited

Returns the triangulation to which this face belongs.

Returns
the triangulation containing this face.

◆ utf8()

std::string regina::Output< Face< dim, subdim > , false >::utf8 ( ) const
inherited

Returns a short text representation of this object using unicode characters.

Like str(), this text should be human-readable, should fit on a single line, and should not end with a newline. In addition, it may use unicode characters to make the output more pleasant to read. This string will be encoded in UTF-8.

Returns
a short text representation of this object.

◆ writeTextLong()

void regina::detail::FaceBase< dim, subdim >::writeTextLong ( std::ostream &  out) const
inherited


Writes a detailed text representation of this object to the given output stream.

The class Face<dim, subdim> may safely override this function, since the output routines cast down to Face<dim, subdim> before calling it.

Python
Not present.
Parameters
outthe output stream to which to write.

◆ writeTextShort()

void regina::Face< 3, 0 >::writeTextShort ( std::ostream &  out) const


Writes a short text representation of this object to the given output stream.

Python
Not present.
Parameters
outthe output stream to which to write.

Member Data Documentation

◆ nFaces

constexpr int regina::detail::FaceNumberingImpl< dim, subdim, lex >::nFaces
staticinherited

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


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

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