Regina Calculation Engine
|
Classes | |
class | regina::BoundaryComponent< 3 > |
A component of the boundary of a 3-manifold triangulation. More... | |
class | regina::Component< 3 > |
Represents a connected component of a 3-manifold triangulation. More... | |
class | regina::Face< 3, 3 > |
Represents a tetrahedron within a 3-manifold triangulation. More... | |
class | regina::Face< 3, 2 > |
Represents a triangle in the skeleton of a 3-manifold triangulation. More... | |
class | regina::Triangulation< 3 > |
Represents a 3-dimensional triangulation, typically of a 3-manifold. More... | |
class | regina::Face< 3, 0 > |
Represents a vertex in the skeleton of a 3-manifold triangulation. More... | |
Typedefs | |
typedef std::vector< Tetrahedron< 3 > * >::const_iterator | regina::Triangulation< 3 >::TetrahedronIterator |
A dimension-specific alias for SimplexIterator, used to iterate through tetrahedra. More... | |
typedef FaceList< 3, 2 >::Iterator | regina::Triangulation< 3 >::TriangleIterator |
Used to iterate through triangles. More... | |
typedef FaceList< 3, 1 >::Iterator | regina::Triangulation< 3 >::EdgeIterator |
Used to iterate through edges. More... | |
typedef FaceList< 3, 0 >::Iterator | regina::Triangulation< 3 >::VertexIterator |
Used to iterate through vertices. More... | |
typedef std::map< std::pair< unsigned long, bool >, Cyclotomic > | regina::Triangulation< 3 >::TuraevViroSet |
A map from (r, parity) pairs to Turaev-Viro invariants, as described by turaevViro(). More... | |
Enumerations | |
enum | regina::Face< 3, 2 >::Type { regina::Face< 3, 2 >::UNKNOWN_TYPE = 0, regina::Face< 3, 2 >::TRIANGLE = 1, regina::Face< 3, 2 >::SCARF = 2, regina::Face< 3, 2 >::PARACHUTE = 3, regina::Face< 3, 2 >::CONE = 4, regina::Face< 3, 2 >::MOBIUS = 5, regina::Face< 3, 2 >::HORN = 6, regina::Face< 3, 2 >::DUNCEHAT = 7, regina::Face< 3, 2 >::L31 = 8 } |
The type of a triangle, which indicates how the vertices and edges of the triangle are identified together. More... | |
enum | regina::Face< 3, 0 >::LinkType { regina::Face< 3, 0 >::SPHERE = 1, regina::Face< 3, 0 >::DISC = 2, regina::Face< 3, 0 >::TORUS = 3, regina::Face< 3, 0 >::KLEIN_BOTTLE = 4, regina::Face< 3, 0 >::NON_STANDARD_CUSP = 5, regina::Face< 3, 0 >::INVALID = 6 } |
Categorises the possible links of a vertex into a small number of common types. More... | |
Functions | |
long | regina::BoundaryComponent< 3 >::eulerChar () const |
Returns the Euler characteristic of this boundary component. More... | |
template<int subdim> | |
size_t | regina::Component< 3 >::countFaces () const |
Returns the number of subdim-faces in this component. More... | |
template<int subdim> | |
const std::vector< Face< 3, subdim > * > & | regina::Component< 3 >::faces () const |
Returns a reference to the list of all subdim-faces in this component. More... | |
template<int subdim> | |
Face< 3, subdim > * | regina::Component< 3 >::face (size_t index) const |
Returns the requested subdim-face in this component. More... | |
bool | regina::Component< 3 >::isIdeal () const |
Determines if this component is ideal. More... | |
bool | regina::Component< 3 >::isClosed () const |
Determines if this component is closed. More... | |
Simplex< 3 > * | regina::Face< 3, 3 >::adjacentTetrahedron (int face) const |
A dimension-specific alias for adjacentSimplex(). More... | |
int | regina::Face< 3, 3 >::adjacentFace (int face) const |
A dimension-specific alias for adjacentFacet(). More... | |
Type | regina::Face< 3, 2 >::type () |
Returns a description of the triangle type. More... | |
int | regina::Face< 3, 2 >::subtype () |
Return the triangle vertex or triangle edge that plays a special role for the triangle type of this triangle. More... | |
bool | regina::Face< 3, 2 >::isMobiusBand () |
Determines whether this triangle is wrapped up to form a Mobius band. More... | |
bool | regina::Face< 3, 2 >::isCone () |
Determines whether this triangle is wrapped up to form a cone. More... | |
regina::Face< 3, 0 >::~Face () | |
Default destructor. More... | |
LinkType | regina::Face< 3, 0 >::link () const |
Returns a broad categorisation of the link of the vertex. More... | |
const Triangulation< 2 > * | regina::Face< 3, 0 >::buildLink () const |
Returns a full 2-manifold triangulation describing the link of this vertex. More... | |
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. More... | |
bool | regina::Face< 3, 0 >::isLinkClosed () const |
Determines if the link of this vertex is closed. More... | |
bool | regina::Face< 3, 0 >::isIdeal () const |
Determines if this vertex is an ideal vertex. More... | |
bool | regina::Face< 3, 0 >::isStandard () const |
Determines if this vertex is standard. More... | |
REGINA_INLINE_REQUIRED long | regina::Face< 3, 0 >::linkEulerChar () const |
Returns the Euler characteristic of the vertex link. More... | |
void | regina::Face< 3, 0 >::writeTextShort (std::ostream &out) const |
Writes a short text representation of this object to the given output stream. More... | |
Friends | |
class | regina::BoundaryComponent< 3 >::Triangulation< 3 > |
class | regina::BoundaryComponent< 3 >::detail::TriangulationBase< 3 > |
class | regina::Component< 3 >::Triangulation< 3 > |
class | regina::Component< 3 >::detail::TriangulationBase< 3 > |
class | regina::Face< 3, 3 >::Triangulation< 3 > |
class | regina::Face< 3, 3 >::detail::TriangulationBase< 3 > |
Allow access to private members. More... | |
class | regina::Face< 3, 2 >::Triangulation< 3 > |
class | regina::Face< 3, 2 >::detail::TriangulationBase< 3 > |
class | regina::Face< 3, 0 >::Triangulation< 3 > |
class | regina::Face< 3, 0 >::detail::TriangulationBase< 3 > |
Constructors and Destructors | |
regina::Triangulation< 3 >::Triangulation () | |
Default constructor. More... | |
regina::Triangulation< 3 >::Triangulation (const Triangulation< 3 > ©) | |
Creates a new copy of the given triangulation. More... | |
regina::Triangulation< 3 >::Triangulation (const Triangulation ©, 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::Triangulation< 3 >::Triangulation (const std::string &description) | |
"Magic" constructor that tries to find some way to interpret the given string as a triangulation. More... | |
regina::Triangulation< 3 >::Triangulation (snappy.Manifold m) | |
Python-only constructor that copies the given SnapPy manifold. More... | |
regina::Triangulation< 3 >::Triangulation (snappy.Triangulation t) | |
Python-only constructor that copies the given SnapPy triangulation. More... | |
virtual REGINA_INLINE_REQUIRED | regina::Triangulation< 3 >::~Triangulation () |
Destroys this triangulation. More... | |
Packet Administration | |
virtual void | regina::Triangulation< 3 >::writeTextShort (std::ostream &out) const override |
Writes a short text representation of this object to the given output stream. More... | |
virtual void | regina::Triangulation< 3 >::writeTextLong (std::ostream &out) const override |
Writes a detailed text representation of this object to the given output stream. More... | |
virtual bool | regina::Triangulation< 3 >::dependsOnParent () const override |
Determines if this packet depends upon its parent. More... | |
Tetrahedra | |
Tetrahedron< 3 > * | regina::Triangulation< 3 >::newTetrahedron () |
A dimension-specific alias for newSimplex(). More... | |
Tetrahedron< 3 > * | regina::Triangulation< 3 >::newTetrahedron (const std::string &desc) |
A dimension-specific alias for newSimplex(). More... | |
void | regina::Triangulation< 3 >::removeTetrahedron (Tetrahedron< 3 > *tet) |
A dimension-specific alias for removeSimplex(). More... | |
void | regina::Triangulation< 3 >::removeTetrahedronAt (size_t index) |
A dimension-specific alias for removeSimplexAt(). More... | |
void | regina::Triangulation< 3 >::removeAllTetrahedra () |
A dimension-specific alias for removeAllSimplices(). More... | |
Skeletal Queries | |
bool | regina::Triangulation< 3 >::hasTwoSphereBoundaryComponents () const |
Determines if this triangulation contains any two-sphere boundary components. More... | |
bool | regina::Triangulation< 3 >::hasNegativeIdealBoundaryComponents () const |
Determines if this triangulation contains any ideal boundary components with negative Euler characteristic. More... | |
Basic Properties | |
long | regina::Triangulation< 3 >::eulerCharManifold () const |
Returns the Euler characteristic of the corresponding compact 3-manifold. More... | |
bool | regina::Triangulation< 3 >::isIdeal () const |
Determines if this triangulation is ideal. More... | |
bool | regina::Triangulation< 3 >::isStandard () const |
Determines if this triangulation is standard. More... | |
bool | regina::Triangulation< 3 >::isClosed () const |
Determines if this triangulation is closed. More... | |
bool | regina::Triangulation< 3 >::isOrdered () const |
Determines if this triangulation is ordered; that is, if tetrahedron vertices are labelled so that all gluing permutations are order-preserving on the tetrahedron faces. More... | |
Algebraic Properties | |
const AbelianGroup & | regina::Triangulation< 3 >::homologyRel () const |
Returns the relative first homology group with respect to the boundary for this triangulation. More... | |
const AbelianGroup & | regina::Triangulation< 3 >::homologyBdry () const |
Returns the first homology group of the boundary for this triangulation. More... | |
const AbelianGroup & | regina::Triangulation< 3 >::homologyH2 () const |
Returns the second homology group for this triangulation. More... | |
unsigned long | regina::Triangulation< 3 >::homologyH2Z2 () const |
Returns the second homology group with coefficients in Z_2 for this triangulation. More... | |
Cyclotomic | regina::Triangulation< 3 >::turaevViro (unsigned long r, bool parity=true, Algorithm alg=ALG_DEFAULT, ProgressTracker *tracker=nullptr) const |
Computes the given Turaev-Viro state sum invariant of this 3-manifold using exact arithmetic. More... | |
double | regina::Triangulation< 3 >::turaevViroApprox (unsigned long r, unsigned long whichRoot=1, Algorithm alg=ALG_DEFAULT) const |
Computes the given Turaev-Viro state sum invariant of this 3-manifold using a fast but inexact floating-point approximation. More... | |
const TuraevViroSet & | regina::Triangulation< 3 >::allCalculatedTuraevViro () const |
Returns the cache of all Turaev-Viro state sum invariants that have been calculated for this 3-manifold. More... | |
Edge< 3 > * | regina::Triangulation< 3 >::longitude () |
Modifies a triangulated knot complement so that the algebraic longitude follows a single boundary edge, and returns this edge. More... | |
std::pair< Edge< 3 > *, Edge< 3 > * > | regina::Triangulation< 3 >::meridianLongitude () |
Modifies a triangulated knot complement so that the meridian and algebraic longitude each follow a single boundary edge, and returns these two edges. More... | |
Normal Surfaces and Angle Structures | |
bool | regina::Triangulation< 3 >::isZeroEfficient () |
Determines if this triangulation is 0-efficient. More... | |
bool | regina::Triangulation< 3 >::knowsZeroEfficient () const |
Is it already known whether or not this triangulation is 0-efficient? See isZeroEfficient() for further details. More... | |
bool | regina::Triangulation< 3 >::hasSplittingSurface () |
Determines whether this triangulation has a normal splitting surface. More... | |
bool | regina::Triangulation< 3 >::knowsSplittingSurface () const |
Is it already known whether or not this triangulation has a splitting surface? See hasSplittingSurface() for further details. More... | |
NormalSurface * | regina::Triangulation< 3 >::hasNonTrivialSphereOrDisc () |
Searches for a non-vertex-linking normal sphere or disc within this triangulation. More... | |
NormalSurface * | regina::Triangulation< 3 >::hasOctagonalAlmostNormalSphere () |
Searches for an octagonal almost normal 2-sphere within this triangulation. More... | |
const AngleStructure * | regina::Triangulation< 3 >::findStrictAngleStructure () const |
Searches for a strict angle structure on this triangulation. More... | |
bool | regina::Triangulation< 3 >::hasStrictAngleStructure () const |
Determines whether this triangulation supports a strict angle structure. More... | |
bool | regina::Triangulation< 3 >::knowsStrictAngleStructure () const |
Is it already known (or trivial to determine) whether or not this triangulation supports a strict angle structure? See hasStrictAngleStructure() for further details. More... | |
Skeletal Transformations | |
void | regina::Triangulation< 3 >::maximalForestInBoundary (std::set< Edge< 3 > * > &edgeSet, std::set< Vertex< 3 > * > &vertexSet) const |
Produces a maximal forest in the 1-skeleton of the triangulation boundary. More... | |
void | regina::Triangulation< 3 >::maximalForestInSkeleton (std::set< Edge< 3 > * > &edgeSet, bool canJoinBoundaries=true) const |
Produces a maximal forest in the triangulation's 1-skeleton. More... | |
bool | regina::Triangulation< 3 >::intelligentSimplify () |
Attempts to simplify the triangulation using fast and greedy heuristics. More... | |
bool | regina::Triangulation< 3 >::simplifyToLocalMinimum (bool perform=true) |
Uses all known simplification moves to reduce the triangulation monotonically to some local minimum number of tetrahedra. More... | |
bool | regina::Triangulation< 3 >::simplifyExhaustive (int height=1, unsigned nThreads=1, ProgressTrackerOpen *tracker=nullptr) |
Attempts to simplify this triangulation using a slow but exhaustive search through the Pachner graph. More... | |
template<typename Action , typename... Args> | |
bool | regina::Triangulation< 3 >::retriangulate (int height, unsigned nThreads, ProgressTrackerOpen *tracker, Action &&action, Args &&... args) const |
Explores all triangulations that can be reached from this via Pachner moves, without exceeding a given number of additional tetrahedra. More... | |
bool | regina::Triangulation< 3 >::fourOneMove (Vertex< 3 > *v, bool check=true, bool perform=true) |
Deprecated function that checks the eligibility of and/or performs a 4-1 Pachner move upon the given vertex. More... | |
bool | regina::Triangulation< 3 >::threeTwoMove (Edge< 3 > *e, bool check=true, bool perform=true) |
Deprecated function that checks the eligibility of and/or performs a 3-2 move about the given edge. More... | |
bool | regina::Triangulation< 3 >::twoThreeMove (Triangle< 3 > *t, bool check=true, bool perform=true) |
Deprecated function that checks the eligibility of and/or performs a 2-3 move about the given triangle. More... | |
bool | regina::Triangulation< 3 >::oneFourMove (Tetrahedron< 3 > *t, bool check=true, bool perform=true) |
Deprecated function that checks the eligibility of and/or performs a 1-4 Pachner move upon the given tetrahedron. More... | |
bool | regina::Triangulation< 3 >::fourFourMove (Edge< 3 > *e, int newAxis, bool check=true, bool perform=true) |
Checks the eligibility of and/or performs a 4-4 move about the given edge. More... | |
bool | regina::Triangulation< 3 >::twoZeroMove (Edge< 3 > *e, bool check=true, bool perform=true) |
Checks the eligibility of and/or performs a 2-0 move about the given edge of degree 2. More... | |
bool | regina::Triangulation< 3 >::twoZeroMove (Vertex< 3 > *v, bool check=true, bool perform=true) |
Checks the eligibility of and/or performs a 2-0 move about the given vertex of degree 2. More... | |
bool | regina::Triangulation< 3 >::twoOneMove (Edge< 3 > *e, int edgeEnd, bool check=true, bool perform=true) |
Checks the eligibility of and/or performs a 2-1 move about the given edge. More... | |
bool | regina::Triangulation< 3 >::openBook (Triangle< 3 > *t, bool check=true, bool perform=true) |
Checks the eligibility of and/or performs a book opening move about the given triangle. More... | |
bool | regina::Triangulation< 3 >::closeBook (Edge< 3 > *e, bool check=true, bool perform=true) |
Checks the eligibility of and/or performs a book closing move about the given boundary edge. More... | |
bool | regina::Triangulation< 3 >::shellBoundary (Tetrahedron< 3 > *t, bool check=true, bool perform=true) |
Checks the eligibility of and/or performs a boundary shelling move on the given tetrahedron. More... | |
bool | regina::Triangulation< 3 >::collapseEdge (Edge< 3 > *e, bool check=true, bool perform=true) |
Checks the eligibility of and/or performs a collapse of an edge between two distinct vertices. More... | |
void | regina::Triangulation< 3 >::reorderTetrahedraBFS (bool reverse=false) |
Reorders the tetrahedra of this triangulation using a breadth-first search, so that small-numbered tetrahedra are adjacent to other small-numbered tetrahedra. More... | |
bool | regina::Triangulation< 3 >::order (bool forceOriented=false) |
Relabels tetrahedron vertices in this triangulation to give an ordered triangulation, if possible. More... | |
Decompositions | |
long | regina::Triangulation< 3 >::connectedSumDecomposition (Packet *primeParent=nullptr, bool setLabels=true) |
Splits this triangulation into its connected sum decomposition. More... | |
bool | regina::Triangulation< 3 >::isThreeSphere () const |
Determines whether this is a triangulation of a 3-sphere. More... | |
bool | regina::Triangulation< 3 >::knowsThreeSphere () const |
Is it already known (or trivial to determine) whether or not this is a triangulation of a 3-sphere? See isThreeSphere() for further details. More... | |
bool | regina::Triangulation< 3 >::isBall () const |
Determines whether this is a triangulation of a 3-dimensional ball. More... | |
bool | regina::Triangulation< 3 >::knowsBall () const |
Is it already known (or trivial to determine) whether or not this is a triangulation of a 3-dimensional ball? See isBall() for further details. More... | |
Packet * | regina::Triangulation< 3 >::makeZeroEfficient () |
Converts this into a 0-efficient triangulation of the same underlying 3-manifold. More... | |
bool | regina::Triangulation< 3 >::isSolidTorus () const |
Determines whether this is a triangulation of the solid torus; that is, the unknot complement. More... | |
bool | regina::Triangulation< 3 >::knowsSolidTorus () const |
Is it already known (or trivial to determine) whether or not this is a triangulation of a solid torus (that is, the unknot complement)? See isSolidTorus() for further details. More... | |
bool | regina::Triangulation< 3 >::isIrreducible () const |
Determines whether the underlying 3-manifold (which must be closed) is irreducible. More... | |
bool | regina::Triangulation< 3 >::knowsIrreducible () const |
Is it already known (or trivial to determine) whether or not the underlying 3-manifold is irreducible? See isIrreducible() for further details. More... | |
bool | regina::Triangulation< 3 >::hasCompressingDisc () const |
Searches for a compressing disc within the underlying 3-manifold. More... | |
bool | regina::Triangulation< 3 >::knowsCompressingDisc () const |
Is it already known (or trivial to determine) whether or not the underlying 3-manifold contains a compressing disc? See hasCompressingDisc() for further details. More... | |
bool | regina::Triangulation< 3 >::isHaken () const |
Determines whether the underlying 3-manifold (which must be closed and orientable) is Haken. More... | |
bool | regina::Triangulation< 3 >::knowsHaken () const |
Is it already known (or trivial to determine) whether or not the underlying 3-manifold is Haken? See isHaken() for further details. More... | |
bool | regina::Triangulation< 3 >::hasSimpleCompressingDisc () const |
Searches for a "simple" compressing disc inside this triangulation. More... | |
const TreeDecomposition & | regina::Triangulation< 3 >::niceTreeDecomposition () const |
Returns a nice tree decomposition of the face pairing graph of this triangulation. More... | |
Subdivisions, Extensions and Covers | |
bool | regina::Triangulation< 3 >::idealToFinite () |
Converts an ideal triangulation into a finite triangulation. More... | |
void | regina::Triangulation< 3 >::pinchEdge (Edge< 3 > *e) |
Pinches an internal edge to a point. More... | |
void | regina::Triangulation< 3 >::drillEdge (Edge< 3 > *e, bool simplify=true) |
Deprecated routine that drills out a regular neighbourhood of the given edge of the triangulation. More... | |
void | regina::Triangulation< 3 >::puncture (Tetrahedron< 3 > *tet=nullptr) |
Punctures this manifold by removing a 3-ball from the interior of the given tetrahedron. More... | |
Building Triangulations | |
Tetrahedron< 3 > * | regina::Triangulation< 3 >::layerOn (Edge< 3 > *edge) |
Performs a layering upon the given boundary edge of the triangulation. More... | |
bool | regina::Triangulation< 3 >::fillTorus (unsigned long cuts0, unsigned long cuts1, unsigned long cuts2, BoundaryComponent< 3 > *bc=nullptr) |
Fills a two-triangle torus boundary component by attaching a solid torus along a given curve. More... | |
bool | regina::Triangulation< 3 >::fillTorus (Edge< 3 > *e0, Edge< 3 > *e1, Edge< 3 > *e2, unsigned long cuts0, unsigned long cuts1, unsigned long cuts2) |
Fills a two-triangle torus boundary component by attaching a solid torus along a given curve. More... | |
Tetrahedron< 3 > * | regina::Triangulation< 3 >::insertLayeredSolidTorus (unsigned long cuts0, unsigned long cuts1) |
Inserts a new layered solid torus into the triangulation. More... | |
void | regina::Triangulation< 3 >::insertLayeredLensSpace (unsigned long p, unsigned long q) |
Inserts a new layered lens space L(p,q) into the triangulation. More... | |
void | regina::Triangulation< 3 >::insertLayeredLoop (unsigned long length, bool twisted) |
Inserts a layered loop of the given length into this triangulation. More... | |
void | regina::Triangulation< 3 >::insertAugTriSolidTorus (long a1, long b1, long a2, long b2, long a3, long b3) |
Inserts an augmented triangular solid torus with the given parameters into this triangulation. More... | |
void | regina::Triangulation< 3 >::insertSFSOverSphere (long a1=1, long b1=0, long a2=1, long b2=0, long a3=1, long b3=0) |
Inserts an orientable Seifert fibred space with at most three exceptional fibres over the 2-sphere into this triangulation. More... | |
void | regina::Triangulation< 3 >::connectedSumWith (const Triangulation &other) |
Forms the connected sum of this triangulation with the given triangulation. More... | |
bool | regina::Triangulation< 3 >::insertRehydration (const std::string &dehydration) |
Inserts the rehydration of the given string into this triangulation. More... | |
Exporting Triangulations | |
std::string | regina::Triangulation< 3 >::dehydrate () const |
Dehydrates this triangulation into an alphabetical string. More... | |
virtual std::string | regina::Triangulation< 3 >::snapPea () const |
Returns a string containing the full contents of a SnapPea data file that describes this triangulation. More... | |
virtual void | regina::Triangulation< 3 >::snapPea (std::ostream &out) const |
Writes the full contents of a SnapPea data file describing this triangulation to the given output stream. More... | |
virtual bool | regina::Triangulation< 3 >::saveSnapPea (const char *filename) const |
Writes this triangulation to the given file using SnapPea's native file format. More... | |
std::string | regina::Triangulation< 3 >::recogniser () const |
Returns a string that expresses this triangulation in Matveev's 3-manifold recogniser format. More... | |
std::string | regina::Triangulation< 3 >::recognizer () const |
A synonym for recogniser(). More... | |
void | regina::Triangulation< 3 >::recogniser (std::ostream &out) const |
Writes a string expressing this triangulation in Matveev's 3-manifold recogniser format to the given output stream. More... | |
void | regina::Triangulation< 3 >::recognizer (std::ostream &out) const |
A synonym for recognizer(std::ostream&). More... | |
bool | regina::Triangulation< 3 >::saveRecogniser (const char *filename) const |
Writes this triangulation to the given file in Matveev's 3-manifold recogniser format. More... | |
bool | regina::Triangulation< 3 >::saveRecognizer (const char *filename) const |
A synonym for saveRecogniser(). More... | |
Importing Triangulations | |
class | regina::Face< 3, 3 > |
class | regina::detail::SimplexBase< 3 > |
class | regina::detail::TriangulationBase< 3 > |
class | regina::XMLTriangulationReader< 3 > |
static Triangulation< 3 > * | regina::Triangulation< 3 >::enterTextTriangulation (std::istream &in, std::ostream &out) |
Allows the user to interactively enter a triangulation in plain text. More... | |
static Triangulation< 3 > * | regina::Triangulation< 3 >::rehydrate (const std::string &dehydration) |
Rehydrates the given alphabetical string into a new triangulation. More... | |
static Triangulation< 3 > * | regina::Triangulation< 3 >::fromSnapPea (const std::string &snapPeaData) |
Extracts the tetrahedron gluings from a string that contains the full contents of a SnapPea data file. More... | |
static XMLPacketReader * | regina::Triangulation< 3 >::xmlReader (Packet *parent, XMLTreeResolver &resolver) |
virtual Packet * | regina::Triangulation< 3 >::internalClonePacket (Packet *parent) const override |
Makes a newly allocated copy of this packet. More... | |
virtual void | regina::Triangulation< 3 >::writeXMLPacketData (std::ostream &out) const override |
Writes a chunk of XML containing the data for this packet only. More... | |
Details for implementing triangulations of 3-manifolds.
typedef FaceList<3, 1>::Iterator regina::Triangulation< 3 >::EdgeIterator |
Used to iterate through edges.
typedef std::vector<Tetrahedron<3>*>::const_iterator regina::Triangulation< 3 >::TetrahedronIterator |
A dimension-specific alias for SimplexIterator, used to iterate through tetrahedra.
typedef FaceList<3, 2>::Iterator regina::Triangulation< 3 >::TriangleIterator |
Used to iterate through triangles.
typedef std::map<std::pair<unsigned long, bool>, Cyclotomic> regina::Triangulation< 3 >::TuraevViroSet |
A map from (r, parity) pairs to Turaev-Viro invariants, as described by turaevViro().
typedef FaceList<3, 0>::Iterator regina::Triangulation< 3 >::VertexIterator |
Used to iterate through vertices.
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).
enum regina::Face< 3, 2 >::Type |
The type of a triangle, which indicates how the vertices and edges of the triangle are identified together.
Here the vertices of a triangle are considered unlabelled (so a relabelling will not change the triangle type).
|
inline |
A dimension-specific alias for adjacentFacet().
See adjacentFacet() for further information.
|
inline |
A dimension-specific alias for adjacentSimplex().
See adjacentSimplex() for further information.
|
inline |
Returns the cache of all Turaev-Viro state sum invariants that have been calculated for this 3-manifold.
This cache is updated every time turaevViro() is called, and is emptied whenever the triangulation is modified.
Turaev-Viro invariants are identified by an (r, parity) pair as described in the turaevViro() documentation. The cache is just a set that maps (r, parity) pairs to the corresponding invariant values.
For even values of r, the parity is ignored when calling turaevViro() (since the even and odd versions of the invariant contain essentially the same information). Therefore, in this cache, all even values of r will have the corresponding parities set to false
.
|
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.
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).
bool regina::Triangulation< 3 >::closeBook | ( | Edge< 3 > * | e, |
bool | check = true , |
||
bool | perform = true |
||
) |
Checks the eligibility of and/or performs a book closing move about the given boundary edge.
This involves taking a boundary edge of the triangulation and folding together the two boundary triangles on either side. This move is the inverse of the openBook() move, and is used to simplify the boundary of the triangulation. This move can be done if:
There are in fact several other "distinctness" conditions on the edges e1, e2, f1 and f2, but they follow automatically from the "distinct vertices" condition above.
If the routine is asked to both check and perform, the move will only be performed if the check shows it is legal.
Note that after performing this move, all skeletal objects (triangles, components, etc.) will be reconstructed, which means any pointers to old skeletal objects (such as the argument f) can no longer be used.
e | the edge 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
. bool regina::Triangulation< 3 >::collapseEdge | ( | Edge< 3 > * | e, |
bool | check = true , |
||
bool | perform = true |
||
) |
Checks the eligibility of and/or performs a collapse of an edge between two distinct vertices.
This operation (when it is allowed) does not change the topology of the manifold, decreases the number of vertices by one, and also decreases the number of tetrahedra.
If the routine is asked to both check and perform, the move will only be performed if the check shows it is legal.
If you are trying to reduce the number of vertices without changing the topology, and if e is an edge connecting an internal vertex with some different vertex, then either collapseEdge() or pinchEdge() may be more appropriate for your situation.
Note that after performing this move, all skeletal objects (triangles, components, etc.) will be reconstructed, which means any pointers to old skeletal objects (such as the argument e) can no longer be used.
The eligibility requirements for this move are somewhat involved, and are discussed in detail in the collapseEdge() source code for those who are interested.
e | the edge to collapse. |
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 given edge may be collapsed without changing the topology of the manifold. If check is false
, the function simply returns true
. long regina::Triangulation< 3 >::connectedSumDecomposition | ( | Packet * | primeParent = nullptr , |
bool | setLabels = true |
||
) |
Splits this triangulation into its connected sum decomposition.
The individual prime 3-manifold triangulations that make up this decomposition will be inserted as children of the given parent packet. The original triangulation will be left unchanged.
For non-orientable triangulations, this routine is only guaranteed to succeed if the original manifold contains no embedded two-sided projective planes. If the manifold does contain embedded two-sided projective planes, then this routine might still succeed but it might fail; however, such a failure will always be detected, and in such a case this routine will return -1 instead (without building any prime summands at all).
Note that this routine is currently only available for closed triangulations; see the list of preconditions for full details.
If the given parent packet is 0, the new prime summand triangulations will be inserted as children of this triangulation.
This routine can optionally assign unique (and sensible) packet labels to each of the new prime summand triangulations. Note however that uniqueness testing may be slow, so this assignment of labels should be disabled if the summand triangulations are only temporary objects used as part of a larger routine.
If this is a triangulation of a 3-sphere then no prime summand triangulations will be created at all, and this routine will return 0.
The underlying algorithm appears in "A new approach to crushing 3-manifold triangulations", Discrete and Computational Geometry 52:1 (2014), pp. 116-139. This algorithm is based on the Jaco-Rubinstein 0-efficiency algorithm, and works in both orientable and non-orientable settings.
primeParent | the packet beneath which the new prime summand triangulations will be inserted, or 0 if they should be inserted directly beneath this triangulation. |
setLabels | true if the new prime summand triangulations should be assigned unique packet labels, or false if they should be left without labels at all. |
void regina::Triangulation< 3 >::connectedSumWith | ( | const Triangulation< 3 > & | other | ) |
Forms the connected sum of this triangulation with the given triangulation.
This triangulation will be altered directly.
If this and the given triangulation are both oriented, then the result will be oriented also, and the connected sum will respect these orientations.
If one or both triangulations contains multiple connected components, this routine will connect the components containing tetrahedron 0 of each triangulation, and will copy any additional components across with no modification.
If either triangulation is empty, then the result will simply be a clone of the other triangulation.
This and/or the given triangulation may be bounded or ideal, or even invalid; in all cases the connected sum will be formed correctly. Note, however, that the result might possibly contain internal vertices (even if the original triangulations do not).
It is allowed to pass this triangulation as other.
other | the triangulation to sum with this. |
size_t regina::Component< 3 >::countFaces | ( | ) | const |
Returns the number of subdim-faces in this component.
countFaces(subdim)
; that is, the template parameter subdim becomes the first argument of the function.std::string regina::Triangulation< 3 >::dehydrate | ( | ) | const |
Dehydrates this triangulation into an alphabetical string.
A dehydration string is a compact text representation of a triangulation, introduced by Callahan, Hildebrand and Weeks for their cusped hyperbolic census (see below). The dehydration string of an n-tetrahedron triangulation consists of approximately (but not precisely) 5n/2 lower-case letters.
Dehydration strings come with some restrictions:
The routine rehydrate() can be used to recover a triangulation from a dehydration string. Note that the triangulation recovered might not be identical to the original, but it is guaranteed to be an isomorphic copy.
For a full description of the dehydrated triangulation format, see A Census of Cusped Hyperbolic 3-Manifolds, Callahan, Hildebrand and Weeks, Mathematics of Computation 68/225, 1999.
|
inlineoverridevirtual |
Determines if this packet depends upon its parent.
This is true if the parent cannot be altered without invalidating or otherwise upsetting this packet.
true
if and only if this packet depends on its parent. Implements regina::Packet.
Reimplemented in regina::SnapPeaTriangulation.
void regina::Triangulation< 3 >::drillEdge | ( | Edge< 3 > * | e, |
bool | simplify = true |
||
) |
Deprecated routine that drills out a regular neighbourhood of the given edge of the triangulation.
The drilling is done by (i) performing two barycentric subdivisions, (ii) removing all tetrahedra that touch the original edge, and then (iii) simplifying the resulting triangulation (unless the optional argument simplify is false
).
e | the edge to drill out. |
simplify | true if the triangulation should be simplified, as described above. This is highly recommended, due to the second barycentric subdivision. |
|
static |
Allows the user to interactively enter a triangulation in plain text.
Prompts will be sent to the given output stream and information will be read from the given input stream.
in | the input stream from which text will be read. |
out | the output stream to which prompts will be written. |
|
inline |
Returns the Euler characteristic of this boundary component.
If this boundary component is ideal, the Euler characteristic of the link of the corresponding ideal vertex is returned.
long regina::Triangulation< 3 >::eulerCharManifold | ( | ) | const |
Returns the Euler characteristic of the corresponding compact 3-manifold.
Instead of simply calculating V-E+F-T, this routine also:
For ideal triangulations, this routine therefore computes the proper Euler characteristic of the manifold (unlike eulerCharTri(), which does not).
For triangulations whose vertex links are all spheres or discs, this routine and eulerCharTri() give identical results.
Face<3, subdim>* regina::Component< 3 >::face | ( | size_t | index | ) | const |
Returns the requested subdim-face in this component.
Note that the index of a face in the component need not be the index of the same face in the overall 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. |
const std::vector<Face<3, subdim>*>& regina::Component< 3 >::faces | ( | ) | const |
Returns a reference to the list of all subdim-faces in this component.
faces(subdim)
. It will then return a Python list containing all the subdim-faces of the triangulation.bool regina::Triangulation< 3 >::fillTorus | ( | Edge< 3 > * | e0, |
Edge< 3 > * | e1, | ||
Edge< 3 > * | e2, | ||
unsigned long | cuts0, | ||
unsigned long | cuts1, | ||
unsigned long | cuts2 | ||
) |
Fills a two-triangle torus boundary component by attaching a solid torus along a given curve.
The three edges of the boundary component should be passed as the arguments e0, e1 and e2. The boundary component will then be filled with a solid torus whose meridional curve cuts these three edges cuts0, cuts1 and cuts2 times respectively.
For the filling to be performed successfully, the three given edges must belong to the same boundary component, and this boundary component must be a two-triangle torus. Moreover, the integers cuts0, cuts1 and cuts2 must be coprime, and two of them must add to give the third. If any of these conditions are not met, then this routine will do nothing and return false
.
The triangulation will be simplified before returning.
There are two versions of fillTorus(); the other takes a boundary component, and sets e0, e1 and e2 to its three edges according to Regina's own edge numbering. This version of fillTorus() should be used when you know how the filling curve cuts each boundary edge but you do not know how these edges are indexed in the corresponding boundary component.
e0 | one of the three edges of the boundary component to fill. |
e1 | the second of the three edges of the boundary component to fill. |
e2 | the second of the three edges of the boundary component to fill. |
cuts0 | the number of times that the meridional curve of the new solid torus should cut the edge e0. |
cuts1 | the number of times that the meridional curve of the new solid torus should cut the edge e1. |
cuts2 | the number of times that the meridional curve of the new solid torus should cut the edge e2. |
true
if the boundary component was filled successfully, or false
if one of the required conditions as described above is not satisfied. bool regina::Triangulation< 3 >::fillTorus | ( | unsigned long | cuts0, |
unsigned long | cuts1, | ||
unsigned long | cuts2, | ||
BoundaryComponent< 3 > * | bc = nullptr |
||
) |
Fills a two-triangle torus boundary component by attaching a solid torus along a given curve.
The boundary component to be filled should be passed as the argument bc; if the triangulation has exactly one boundary component then you may omit bc (i.e., pass null
), and the (unique) boundary component will be inferred.
If the boundary component cannot be inferred, and/or if the selected boundary component is not a two-triangle torus, then this routine will do nothing and return false
.
Otherwise the given boundary component will be filled with a solid torus whose meridional curve cuts the edges bc->edge(0)
, bc->edge(1)
and bc->edge(2)
a total of cuts0, cuts1 and cuts2 times respectively.
For the filling to be performed successfully, the integers cuts0, cuts1 and cuts2 must be coprime, and two of them must add to give the third. Otherwise, as above, this routine will do nothing and return false
.
The triangulation will be simplified before returning.
There are two versions of fillTorus(); the other takes three explicit edges instead of a boundary component. You should use the other version if you know how the filling curve cuts each boundary edge but you do not know how these edges are indexed in the boundary component.
cuts0 | the number of times that the meridional curve of the new solid torus should cut the edge bc->edge(0) . |
cuts1 | the number of times that the meridional curve of the new solid torus should cut the edge bc->edge(1) . |
cuts2 | the number of times that the meridional curve of the new solid torus should cut the edge bc->edge(2) . |
bc | the boundary component to fill. If the triangulation has precisely one boundary component then this may be null . |
true
if the boundary component was filled successfully, or false
if one of the required conditions as described above is not satisfied. const AngleStructure* regina::Triangulation< 3 >::findStrictAngleStructure | ( | ) | const |
Searches for a strict angle structure on this triangulation.
Recall that a strict angle structure is one in which every angle is strictly between 0 and π. If a strict angle structure does exist, then this routine is guaranteed to find one.
The underlying algorithm runs a single linear program (it does not enumerate all vertex angle structures). This means that it is likely to be fast even for large triangulations.
If you are only interested in whether a strict angle structure exists (i.e., you are not interested in the specific angles themselves), then you may call hasStrictAngleStructure() instead.
The angle structure returned (if any) is cached internally alongside this triangulation. This means that, as long as the triangulation does not change, subsequent calls to findStrictAngleStructure() will return identical pointers and will be essentially instantaneous.
If the triangulation changes however, then the cached angle structure will be deleted. This means that you should not store the returned pointer for later use; instead you should just call findStrictAngleStructure() again.
bool regina::Triangulation< 3 >::fourFourMove | ( | Edge< 3 > * | e, |
int | newAxis, | ||
bool | check = true , |
||
bool | perform = true |
||
) |
Checks the eligibility of and/or performs a 4-4 move about the given edge.
This involves replacing the four tetrahedra joined at that edge with four tetrahedra joined along a different edge. Consider the octahedron made up of the four original tetrahedra; this has three internal axes. The initial four tetrahedra meet along the given edge which forms one of these axes; the new tetrahedra will meet along a different axis. This move can be done iff (i) the edge is valid and non-boundary, and (ii) the four tetrahedra are distinct.
If the routine is asked to both check and perform, the move will only be performed if the check shows it is legal.
Note that after performing this move, all skeletal objects (triangles, components, etc.) will be reconstructed, which means any pointers to old skeletal objects (such as the argument e) can no longer be used.
e | the edge about which to perform the move. |
newAxis | Specifies which axis of the octahedron the new tetrahedra should meet along; this should be 0 or 1. Consider the four original tetrahedra in the order described by Edge<3>::embedding(0,...,3); call these tetrahedra 0, 1, 2 and
|
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
.
|
inline |
Deprecated function that checks the eligibility of and/or performs a 4-1 Pachner move upon the given vertex.
This is an alias for pachner(Vertex<3>*, bool, bool); see that routine for further details.
v | the vertex 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
.
|
static |
Extracts the tetrahedron gluings from a string that contains the full contents of a SnapPea data file.
All other SnapPea-specific information (such as peripheral curves) will be ignored, since Regina's Triangulation<3> class does not track such information itself.
If you wish to preserve all SnapPea-specific information from the data file, you should work with the SnapPeaTriangulation class instead (which uses the SnapPea kernel directly, and can therefore store anything that SnapPea can).
If you wish to read a triangulation from a SnapPea file, you should likewise call the SnapPeaTriangulation constructor, giving the filename as argument. This will read all SnapPea-specific information (as described above), and also avoids constructing an enormous intermediate string.
The triangulation that is returned will be newly created. If the SnapPea data is not in the correct format, this routine will return 0 instead.
snapPeaData | a string containing the full contents of a SnapPea data file. |
bool regina::Triangulation< 3 >::hasCompressingDisc | ( | ) | const |
Searches for a compressing disc within the underlying 3-manifold.
Let M be the underlying 3-manifold and let B be its boundary. By a compressing disc, we mean a disc D properly embedded in M, where the boundary of D lies in B but does not bound a disc in B.
This routine will first call the heuristic routine hasSimpleCompressingDisc() in the hope of obtaining a fast answer. If this fails, it will do one of two things:
This routine will work on a copy of this triangulation, not the original. In particular, the copy will be simplified, which means that there is no harm in calling this routine on an unsimplified triangulation.
If this triangulation has no boundary components, this routine will simply return false
.
true
if the underlying 3-manifold contains a compressing disc, or false
if it does not.
|
inline |
Determines if this triangulation contains any ideal boundary components with negative Euler characteristic.
true
if and only if there is at least one such boundary component. NormalSurface* regina::Triangulation< 3 >::hasNonTrivialSphereOrDisc | ( | ) |
Searches for a non-vertex-linking normal sphere or disc within this triangulation.
If such a surface exists within this triangulation, this routine is guaranteed to find one.
Note that the surface returned (if any) depends upon this triangulation, and so the surface must be destroyed before this triangulation is destroyed.
NormalSurface* regina::Triangulation< 3 >::hasOctagonalAlmostNormalSphere | ( | ) |
Searches for an octagonal almost normal 2-sphere within this triangulation.
If such a surface exists, this routine is guaranteed to find one.
Note that the surface returned (if any) depends upon this triangulation, and so the surface must be destroyed before this triangulation is destroyed.
bool regina::Triangulation< 3 >::hasSimpleCompressingDisc | ( | ) | const |
Searches for a "simple" compressing disc inside this triangulation.
Let M be the underlying 3-manifold and let B be its boundary. By a compressing disc, we mean a disc D properly embedded in M, where the boundary of D lies in B but does not bound a disc in B.
By a simple compressing disc, we mean a compressing disc that has a very simple combinatorial structure (here "simple" is subject to change; see the warning below). Examples include the compressing disc inside a 1-tetrahedron solid torus, or a compressing disc formed from a single internal triangle surrounded by three boundary edges.
The purpose of this routine is to avoid working with normal surfaces within a large triangulation where possible. This routine is relatively fast, and if it returns true
then this 3-manifold definitely contains a compressing disc. If this routine returns false
then there might or might not be a compressing disc; the user will need to perform a full normal surface enumeration using hasCompressingDisc() to be sure.
This routine will work on a copy of this triangulation, not the original. In particular, the copy will be simplified, which means that there is no harm in calling this routine on an unsimplified triangulation.
If this triangulation has no boundary components, this routine will simply return false
.
For further information on this test, see "The Weber-Seifert dodecahedral space is non-Haken", Benjamin A. Burton, J. Hyam Rubinstein and Stephan Tillmann, Trans. Amer. Math. Soc. 364:2 (2012), pp. 911-932.
true
if a simple compressing disc was found, or false
if not. Note that even with a return value of false
, there might still be a compressing disc (just not one with a simple combinatorial structure). bool regina::Triangulation< 3 >::hasSplittingSurface | ( | ) |
Determines whether this triangulation has a normal splitting surface.
See NormalSurface::isSplitting() for details regarding normal splitting surfaces.
true
if and only if this triangulation has a normal splitting surface.
|
inline |
Determines whether this triangulation supports a strict angle structure.
Recall that a strict angle structure is one in which every angle is strictly between 0 and π.
This routine is equivalent to calling findStrictAngleStructure() and testing whether the return value is non-null.
The underlying algorithm runs a single linear program (it does not enumerate all vertex angle structures). This means that it is likely to be fast even for large triangulations.
true
if a strict angle structure exists on this triangulation, or 0 if not.
|
inline |
Determines if this triangulation contains any two-sphere boundary components.
true
if and only if there is at least one two-sphere boundary component. const AbelianGroup& regina::Triangulation< 3 >::homologyBdry | ( | ) | const |
Returns the first homology group of the boundary for this triangulation.
Note that ideal vertices are considered part of the boundary.
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, homologyBdry() should be called again; this will be instantaneous if the group has already been calculated.
This routine is fairly fast, since it deduces the homology of each boundary component through knowing what kind of surface it is.
const AbelianGroup& regina::Triangulation< 3 >::homologyH2 | ( | ) | const |
Returns the second homology group for this triangulation.
If this triangulation contains any ideal vertices, the homology group will be calculated as if each such vertex had been truncated. The algorithm used calculates various first homology groups and uses homology and cohomology theorems to deduce the second homology group.
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, homologyH2() should be called again; this will be instantaneous if the group has already been calculated.
|
inline |
Returns the second homology group with coefficients in Z_2 for this triangulation.
If this triangulation contains any ideal vertices, the homology group will be calculated as if each such vertex had been truncated. The algorithm used calculates the relative first homology group with respect to the boundary and uses homology and cohomology theorems to deduce the second homology group.
This group will simply be the direct sum of several copies of Z_2, so the number of Z_2 terms is returned.
const AbelianGroup& regina::Triangulation< 3 >::homologyRel | ( | ) | const |
Returns the relative first homology group with respect to the boundary for this triangulation.
Note that ideal vertices are considered part of the boundary.
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, homologyRel() should be called again; this will be instantaneous if the group has already been calculated.
bool regina::Triangulation< 3 >::idealToFinite | ( | ) |
Converts an ideal triangulation into a finite triangulation.
All ideal or invalid vertices are truncated and thus converted into real boundary components made from unglued faces of tetrahedra.
Note that this operation is a loose converse of finiteToIdeal().
true
if and only if the triangulation was changed. void regina::Triangulation< 3 >::insertAugTriSolidTorus | ( | long | a1, |
long | b1, | ||
long | a2, | ||
long | b2, | ||
long | a3, | ||
long | b3 | ||
) |
Inserts an augmented triangular solid torus with the given parameters into this triangulation.
Almost all augmented triangular solid tori represent Seifert fibred spaces with three or fewer exceptional fibres. Augmented triangular solid tori are described in more detail in the AugTriSolidTorus class notes.
The resulting Seifert fibred space will be SFS((a1,b1) (a2,b2) (a3,b3) (1,1)), where the parameters a1, ..., b3 are passed as arguments to this routine. The three layered solid tori that are attached to the central triangular solid torus will be LST(|a1|, |b1|, |-a1-b1|), ..., LST(|a3|, |b3|, |-a3-b3|).
The new tetrahedra will be inserted at the end of the list of tetrahedra in the triangulation.
a1 | a parameter describing the first layered solid torus in the augmented triangular solid torus; this may be either positive or negative. |
b1 | a parameter describing the first layered solid torus in the augmented triangular solid torus; this may be either positive or negative. |
a2 | a parameter describing the second layered solid torus in the augmented triangular solid torus; this may be either positive or negative. |
b2 | a parameter describing the second layered solid torus in the augmented triangular solid torus; this may be either positive or negative. |
a3 | a parameter describing the third layered solid torus in the augmented triangular solid torus; this may be either positive or negative. |
b3 | a parameter describing the third layered solid torus in the augmented triangular solid torus; this may be either positive or negative. |
void regina::Triangulation< 3 >::insertLayeredLensSpace | ( | unsigned long | p, |
unsigned long | q | ||
) |
Inserts a new layered lens space L(p,q) into the triangulation.
The lens space will be created by gluing together two layered solid tori in a way that uses the fewest possible tetrahedra.
The new tetrahedra will be inserted at the end of the list of tetrahedra in the triangulation.
p | a parameter of the desired lens space. |
q | a parameter of the desired lens space. |
void regina::Triangulation< 3 >::insertLayeredLoop | ( | unsigned long | length, |
bool | twisted | ||
) |
Inserts a layered loop of the given length into this triangulation.
Layered loops are described in more detail in the LayeredLoop class notes.
The new tetrahedra will be inserted at the end of the list of tetrahedra in the triangulation.
length | the length of the new layered loop; this must be strictly positive. |
twisted | true if the new layered loop should be twisted, or false if it should be untwisted. |
Tetrahedron<3>* regina::Triangulation< 3 >::insertLayeredSolidTorus | ( | unsigned long | cuts0, |
unsigned long | cuts1 | ||
) |
Inserts a new layered solid torus into the triangulation.
The meridinal disc of the layered solid torus will intersect the three edges of the boundary torus in cuts0, cuts1 and (cuts0 + cuts1) points respectively.
The boundary torus will always consist of faces 012 and 013 of the tetrahedron containing this boundary torus (this tetrahedron will be returned). In face 012, edges 12, 02 and 01 will meet the meridinal disc cuts0, cuts1 and (cuts0 + cuts1) times respectively. The only exceptions are if these three intersection numbers are (1,1,2) or (0,1,1), in which case edges 12, 02 and 01 will meet the meridinal disc (1, 2 and 1) or (1, 1 and 0) times respectively.
The new tetrahedra will be inserted at the end of the list of tetrahedra in the triangulation.
cuts0 | the smallest of the three desired intersection numbers. |
cuts1 | the second smallest of the three desired intersection numbers. |
bool regina::Triangulation< 3 >::insertRehydration | ( | const std::string & | dehydration | ) |
Inserts the rehydration of the given string into this triangulation.
If you simply wish to convert a dehydration string into a new triangulation, use the static routine rehydrate() instead. See dehydrate() for more information on dehydration strings.
This routine will first rehydrate the given string into a proper triangulation. The tetrahedra from the rehydrated triangulation will then be inserted into this triangulation in the same order in which they appear in the rehydrated triangulation, and the numbering of their vertices (0-3) will not change.
The routine dehydrate() can be used to extract a dehydration string from an existing triangulation. Dehydration followed by rehydration might not produce a triangulation identical to the original, but it is guaranteed to produce an isomorphic copy. See dehydrate() for the reasons behind this.
For a full description of the dehydrated triangulation format, see A Census of Cusped Hyperbolic 3-Manifolds, Callahan, Hildebrand and Weeks, Mathematics of Computation 68/225, 1999.
dehydration | a dehydrated representation of the triangulation to insert. Case is irrelevant; all letters will be treated as if they were lower case. |
true
if the insertion was successful, or false
if the given string could not be rehydrated.void regina::Triangulation< 3 >::insertSFSOverSphere | ( | long | a1 = 1 , |
long | b1 = 0 , |
||
long | a2 = 1 , |
||
long | b2 = 0 , |
||
long | a3 = 1 , |
||
long | b3 = 0 |
||
) |
Inserts an orientable Seifert fibred space with at most three exceptional fibres over the 2-sphere into this triangulation.
The inserted Seifert fibred space will be SFS((a1,b1) (a2,b2) (a3,b3) (1,1)), where the parameters a1, ..., b3 are passed as arguments to this routine.
The three pairs of parameters (a,b) do not need to be normalised, i.e., the parameters can be positive or negative and b may lie outside the range [0..a). There is no separate twisting parameter; each additional twist can be incorporated into the existing parameters by replacing some pair (a,b) with the pair (a,a+b). For Seifert fibred spaces with less than three exceptional fibres, some or all of the parameter pairs may be (1,k) or even (1,0).
The new tetrahedra will be inserted at the end of the list of tetrahedra in the triangulation.
a1 | a parameter describing the first exceptional fibre. |
b1 | a parameter describing the first exceptional fibre. |
a2 | a parameter describing the second exceptional fibre. |
b2 | a parameter describing the second exceptional fibre. |
a3 | a parameter describing the third exceptional fibre. |
b3 | a parameter describing the third exceptional fibre. |
bool regina::Triangulation< 3 >::intelligentSimplify | ( | ) |
Attempts to simplify the triangulation using fast and greedy heuristics.
This routine will attempt to reduce both the number of tetrahedra and the number of boundary triangles (with the number of tetrahedra as its priority).
Currently this routine uses simplifyToLocalMinimum() in combination with random 4-4 moves, book opening moves and book closing moves.
Although intelligentSimplify() works very well most of the time, it can occasionally get stuck; in such cases you may wish to try the more powerful but (much) slower simplifyExhaustive() instead.
true
if and only if the triangulation was successfully simplified. Otherwise this triangulation will not be changed.
|
inlineoverrideprotectedvirtual |
Makes a newly allocated copy of this packet.
This routine should not insert the new packet into the tree structure, clone the packet's associated tags or give the packet a label. It should also not clone any descendants of this packet.
You may assume that the new packet will eventually be inserted into the tree beneath either the same parent as this packet or a clone of that parent.
parent | the parent beneath which the new packet will eventually be inserted. |
Implements regina::Packet.
Reimplemented in regina::SnapPeaTriangulation.
bool regina::Triangulation< 3 >::isBall | ( | ) | const |
Determines whether this is a triangulation of a 3-dimensional ball.
This routine is based on isThreeSphere(), which in turn combines Rubinstein's 3-sphere recognition algorithm with Jaco and Rubinstein's 0-efficiency prime decomposition algorithm.
true
if and only if this is a triangulation of a 3-dimensional ball.
|
inline |
Determines if this component is closed.
This is the case if and only if it has no boundary. Note that ideal components are not closed.
true
if and only if this component is closed.
|
inline |
Determines if this triangulation is closed.
This is the case if and only if it has no boundary. Note that ideal triangulations are not closed.
true
if and only if this triangulation is closed.
|
inline |
Determines whether this triangle is wrapped up to form a cone.
Note that several different triangle types (as returned by type()) can produce this result. Note also that a triangle can be both a Mobius band and a cone.
true
if and only if this triangle is a cone. bool regina::Triangulation< 3 >::isHaken | ( | ) | const |
Determines whether the underlying 3-manifold (which must be closed and orientable) is Haken.
In other words, this routine determines whether the underlying 3-manifold contains an embedded closed two-sided incompressible surface.
Currently Hakenness testing is available only for irreducible manifolds. This routine will first test whether the manifold is irreducible and, if it is not, will return false
immediately.
true
if and only if the underlying 3-manifold is irreducible and Haken.
|
inline |
Determines if this component is ideal.
This is the case if and only if it contains an ideal vertex as described by Vertex<3>::isIdeal().
true
if and only if this component is ideal.
|
inline |
Determines if this vertex is an ideal vertex.
This requires the vertex link to be closed and not a 2-sphere.
true
if and only if this is an ideal vertex.
|
inline |
Determines if this triangulation is ideal.
This is the case if and only if one of the vertex links is closed and not a 2-sphere. Note that the triangulation is not required to be valid.
true
if and only if this triangulation is ideal. bool regina::Triangulation< 3 >::isIrreducible | ( | ) | const |
Determines whether the underlying 3-manifold (which must be closed) is irreducible.
In other words, this routine determines whether every embedded sphere in the underlying 3-manifold bounds a ball.
If the underlying 3-manifold is orientable, this routine will use fast crushing and branch-and-bound methods. If the underlying 3-manifold is non-orientable, it will use a (much slower) full enumeration of vertex normal surfaces.
true
if and only if the underlying 3-manifold is irreducible.
|
inline |
Determines if the link of this vertex is closed.
true
if and only if the link of this vertex is closed.
|
inline |
Determines whether this triangle is wrapped up to form a Mobius band.
Note that several different triangle types (as returned by type()) can produce this result. Note also that a triangle can be both a Mobius band and a cone.
true
if and only if this triangle is a Mobius band. bool regina::Triangulation< 3 >::isOrdered | ( | ) | const |
Determines if this triangulation is ordered; that is, if tetrahedron vertices are labelled so that all gluing permutations are order-preserving on the tetrahedron faces.
Equivalently, this tests whether the edges of the triangulation can all be oriented such that they induce a consistent ordering on the vertices of each tetrahedron.
Triangulations are not ordered by default, and indeed some cannot be ordered at all. The routine order() will attempt to relabel tetrahedron vertices to give an ordered triangulation.
true
if and only if all gluing permutations are order preserving on the tetrahedron faces.bool regina::Triangulation< 3 >::isSolidTorus | ( | ) | const |
Determines whether this is a triangulation of the solid torus; that is, the unknot complement.
This routine can be used on a triangulation with real boundary triangles, or on an ideal triangulation (in which case all ideal vertices will be assumed to be truncated).
true
if and only if this is either a real (compact) or ideal (non-compact) triangulation of the solid torus.
|
inline |
Determines if this vertex is standard.
This requires the vertex link to be a sphere, disc, torus or Klein bottle.
true
if and only if this vertex is standard.
|
inline |
Determines if this triangulation is standard.
This is the case if and only if every vertex is standard. See Vertex<3>::isStandard() for further details.
true
if and only if this triangulation is standard. bool regina::Triangulation< 3 >::isThreeSphere | ( | ) | const |
Determines whether this is a triangulation of a 3-sphere.
This routine relies upon a combination of Rubinstein's 3-sphere recognition algorithm and Jaco and Rubinstein's 0-efficiency prime decomposition algorithm.
true
if and only if this is a 3-sphere triangulation. bool regina::Triangulation< 3 >::isZeroEfficient | ( | ) |
Determines if this triangulation is 0-efficient.
A triangulation is 0-efficient if its only normal spheres and discs are vertex linking, and if it has no 2-sphere boundary components.
true
if and only if this triangulation is 0-efficient. bool regina::Triangulation< 3 >::knowsBall | ( | ) | const |
Is it already known (or trivial to determine) whether or not this is a triangulation of a 3-dimensional ball? See isBall() for further details.
If this property is indeed already known, future calls to isBall() will be very fast (simply returning the precalculated value).
If this property is not already known, this routine will nevertheless run some very fast preliminary tests to see if the answer is obviously no. If so, it will store false
as the precalculated value for isBall() and this routine will return true
.
Otherwise a call to isBall() may potentially require more significant work, and so this routine will return false
.
true
if and only if this property is already known or trivial to calculate. bool regina::Triangulation< 3 >::knowsCompressingDisc | ( | ) | const |
Is it already known (or trivial to determine) whether or not the underlying 3-manifold contains a compressing disc? See hasCompressingDisc() for further details.
If this property is indeed already known, future calls to hasCompressingDisc() will be very fast (simply returning the precalculated value).
If this property is not already known, this routine will nevertheless run some very fast preliminary tests to see if the answer is obviously no. If so, it will store false
as the precalculated value for hasCompressingDisc() and this routine will return true
.
Otherwise a call to hasCompressingDisc() may potentially require more significant work, and so this routine will return false
.
true
if and only if this property is already known or trivial to calculate. bool regina::Triangulation< 3 >::knowsHaken | ( | ) | const |
Is it already known (or trivial to determine) whether or not the underlying 3-manifold is Haken? See isHaken() for further details.
If this property is indeed already known, future calls to isHaken() will be very fast (simply returning the precalculated value).
true
if and only if this property is already known or trivial to calculate. bool regina::Triangulation< 3 >::knowsIrreducible | ( | ) | const |
Is it already known (or trivial to determine) whether or not the underlying 3-manifold is irreducible? See isIrreducible() for further details.
If this property is indeed already known, future calls to isIrreducible() will be very fast (simply returning the precalculated value).
true
if and only if this property is already known or trivial to calculate. bool regina::Triangulation< 3 >::knowsSolidTorus | ( | ) | const |
Is it already known (or trivial to determine) whether or not this is a triangulation of a solid torus (that is, the unknot complement)? See isSolidTorus() for further details.
If this property is indeed already known, future calls to isSolidTorus() will be very fast (simply returning the precalculated value).
If this property is not already known, this routine will nevertheless run some very fast preliminary tests to see if the answer is obviously no. If so, it will store false
as the precalculated value for isSolidTorus() and this routine will return true
.
Otherwise a call to isSolidTorus() may potentially require more significant work, and so this routine will return false
.
true
if and only if this property is already known or trivial to calculate.
|
inline |
Is it already known whether or not this triangulation has a splitting surface? See hasSplittingSurface() for further details.
If this property is already known, future calls to hasSplittingSurface() will be very fast (simply returning the precalculated value).
true
if and only if this property is already known. bool regina::Triangulation< 3 >::knowsStrictAngleStructure | ( | ) | const |
Is it already known (or trivial to determine) whether or not this triangulation supports a strict angle structure? See hasStrictAngleStructure() for further details.
If this property is indeed already known, future calls to findStrictAngleStructure() and hasStrictAngleStructure() will be very fast (simply returning the precalculated solution).
true
if and only if this property is already known or trivial to calculate. bool regina::Triangulation< 3 >::knowsThreeSphere | ( | ) | const |
Is it already known (or trivial to determine) whether or not this is a triangulation of a 3-sphere? See isThreeSphere() for further details.
If this property is indeed already known, future calls to isThreeSphere() will be very fast (simply returning the precalculated value).
If this property is not already known, this routine will nevertheless run some very fast preliminary tests to see if the answer is obviously no. If so, it will store false
as the precalculated value for isThreeSphere() and this routine will return true
.
Otherwise a call to isThreeSphere() may potentially require more significant work, and so this routine will return false
.
true
if and only if this property is already known or trivial to calculate.
|
inline |
Is it already known whether or not this triangulation is 0-efficient? See isZeroEfficient() for further details.
If this property is already known, future calls to isZeroEfficient() will be very fast (simply returning the precalculated value).
true
if and only if this property is already known. Tetrahedron<3>* regina::Triangulation< 3 >::layerOn | ( | Edge< 3 > * | edge | ) |
Performs a layering upon the given boundary edge of the triangulation.
See the Layering class notes for further details on what a layering entails.
The new tetrahedron will be returned, and the new boundary edge that it creates will be edge 5 (i.e., the edge joining vertices 2 and 3) of this tetrahedron.
edge | the boundary edge upon which to layer. |
|
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().
|
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().
Edge<3>* regina::Triangulation< 3 >::longitude | ( | ) |
Modifies a triangulated knot complement so that the algebraic longitude follows a single boundary edge, and returns this edge.
Assuming that this triangulation represents the complement of a knot in the 3-sphere, this routine:
Whilst this routine returns less information than meridianLongitude(), it (1) runs much faster since it is based on fast algebraic calculations, and (2) guarantees to terminate. In contrast, meridianLongitude() must repeatedly try to test for 3-spheres, and (as a result of only using fast 3-sphere recognition heuristics) does not guarantee to terminate.
At present this routine is fairly restrictive in what triangulations it can work with: it requires the triangulation to be one-vertex and have real (not ideal) boundary. These restrictions may be eased in future versions of Regina.
If the algebraic longitude is already represented by a single boundary edge, then it is guaranteed that this routine will not modify the triangulation, and will simply return this boundary edge.
null
if an error (such as an integer overflow) occurred during the computation. Packet* regina::Triangulation< 3 >::makeZeroEfficient | ( | ) |
Converts this into a 0-efficient triangulation of the same underlying 3-manifold.
A triangulation is 0-efficient if its only normal spheres and discs are vertex linking, and if it has no 2-sphere boundary components.
Note that this routine is currently only available for closed orientable triangulations; see the list of preconditions for details. The 0-efficiency algorithm of Jaco and Rubinstein is used.
If the underlying 3-manifold is prime, it can always be made 0-efficient (with the exception of the special cases RP3 and S2xS1 as noted below). In this case the original triangulation will be modified directly and 0 will be returned.
If the underyling 3-manifold is RP3 or S2xS1, it cannot be made 0-efficient; in this case the original triangulation will be reduced to a two-tetrahedron minimal triangulation and 0 will again be returned.
If the underlying 3-manifold is not prime, it cannot be made 0-efficient. In this case the original triangulation will remain unchanged and a new connected sum decomposition will be returned. This will be presented as a newly allocated container packet with one child triangulation for each prime summand.
void regina::Triangulation< 3 >::maximalForestInBoundary | ( | std::set< Edge< 3 > * > & | edgeSet, |
std::set< Vertex< 3 > * > & | vertexSet | ||
) | const |
Produces a maximal forest in the 1-skeleton of the triangulation boundary.
Both given sets will be emptied and the edges and vertices of the maximal forest will be placed into them. A vertex that forms its own boundary component (such as an ideal vertex) will still be placed in vertexSet
.
Note that the edge and vertex pointers returned will become invalid once the triangulation has changed.
edgeSet | the set to be emptied and into which the edges of the maximal forest will be placed. |
vertexSet | the set to be emptied and into which the vertices of the maximal forest will be placed. |
void regina::Triangulation< 3 >::maximalForestInSkeleton | ( | std::set< Edge< 3 > * > & | edgeSet, |
bool | canJoinBoundaries = true |
||
) | const |
Produces a maximal forest in the triangulation's 1-skeleton.
The given set will be emptied and will have the edges of the maximal forest placed into it. It can be specified whether or not different boundary components may be joined by the maximal forest.
An edge leading to an ideal vertex is still a candidate for inclusion in the maximal forest. For the purposes of this algorithm, any ideal vertex will be treated as any other vertex (and will still be considered part of its own boundary component).
Note that the edge pointers returned will become invalid once the triangulation has changed.
edgeSet | the set to be emptied and into which the edges of the maximal forest will be placed. |
canJoinBoundaries | true if and only if different boundary components are allowed to be joined by the maximal forest. |
std::pair<Edge<3>*, Edge<3>*> regina::Triangulation< 3 >::meridianLongitude | ( | ) |
Modifies a triangulated knot complement so that the meridian and algebraic longitude each follow a single boundary edge, and returns these two edges.
Assuming that this triangulation represents the complement of a knot in the 3-sphere, this routine:
This routine uses fast heuristics to locate the meridian; as a result, it does not guarantee to terminate (but if you find a case where it does not, please let the Regina developers know!). If it does return then it guarantees that the result is correct.
Whilst this routine returns more information than longitude(), note that longitude() (1) runs much faster since it is based on fast algebraic calculations, and (2) guarantees to terminate.
At present this routine is fairly restrictive in what triangulations it can work with: it requires the triangulation to be one-vertex and have real (not ideal) boundary. These restrictions may be eased in future versions of Regina.
If the meridian and algebraic longitude are already both represented by single boundary edges, then it is guaranteed that this routine will not modify the triangulation, and will simply return these two boundary edges.
null
, null
).
|
inline |
A dimension-specific alias for newSimplex().
See newSimplex() for further information.
|
inline |
A dimension-specific alias for newSimplex().
See newSimplex() for further information.
|
inline |
Returns a nice tree decomposition of the face pairing graph of this triangulation.
This can (for example) be used in implementing algorithms that are fixed-parameter tractable in the treewidth of the face pairing graph.
See TreeDecomposition for further details on tree decompositions, and see TreeDecomposition::makeNice() for details on what it means to be a nice tree decomposition.
This routine is fast: it will use a greedy algorithm to find a tree decomposition with (hopefully) small width, but with no guarantees that the width of this tree decomposition is the smallest possible.
The tree decomposition will be cached, so that if this routine is called a second time (and the underlying triangulation has not been changed) then the same tree decomposition will be returned immediately.
|
inline |
Deprecated function that checks the eligibility of and/or performs a 1-4 Pachner move upon the given tetrahedron.
This differs from pachner(Simplex<3>*, bool, bool) in the labelling of the new tetrahedra:
simplices().back()->vertex(0)
, for consistency with Pachner moves on faces of other dimensions;simplices().back()->vertex(3)
, for consistency with earlier versions of Regina.t | the tetrahedron about which to perform the move. |
check | this argument is ignored, since this move is always legal. |
perform | true if we are to perform the move (defaults to true ). |
true
always. bool regina::Triangulation< 3 >::openBook | ( | Triangle< 3 > * | t, |
bool | check = true , |
||
bool | perform = true |
||
) |
Checks the eligibility of and/or performs a book opening move about the given triangle.
This involves taking a triangle meeting the boundary along two edges, and ungluing it to create two new boundary triangles (thus exposing the tetrahedra it initially joined). This move is the inverse of the closeBook() move, and is used to open the way for new shellBoundary() moves.
This move can be done if:
If the routine is asked to both check and perform, the move will only be performed if the check shows it is legal.
Note that after performing this move, all skeletal objects (triangles, components, etc.) will be reconstructed, which means any pointers to old skeletal objects (such as the argument f) can no longer be used.
t | the triangle 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
. bool regina::Triangulation< 3 >::order | ( | bool | forceOriented = false | ) |
Relabels tetrahedron vertices in this triangulation to give an ordered triangulation, if possible.
To be an ordered triangulation, all face gluings (when restricted to the tetrahedron face) must be order preserving. In other words, it must be possible to orient all edges of the triangulation in such a fashion that they are consistent with the ordering of the vertices in each tetrahedron.
If it is possible to order this triangulation, the vertices of each tetrahedron will be relabelled accordingly and this routine will return true
. Otherwise, this routine will return false
and the triangulation will not be changed.
forceOriented | true if the triangulation must be both ordered and oriented, in which case this routine will return false if the triangulation cannot be oriented and ordered at the same time. See orient() for further details. |
true
if the triangulation has been successfully ordered as described above, or false
if not.void regina::Triangulation< 3 >::pinchEdge | ( | Edge< 3 > * | e | ) |
Pinches an internal edge to a point.
Topologically, this collapses the edge to a point with no further side-effects, and it increases the number of tetrahedra by two.
This operation can be performed on any internal edge, without further constraints. Two particularly useful settings are:
We do not allow e to lie entirely on the triangulation boundary, because the implementation actually collapses an internal curve parallel to e, not the edge e itself (and so if e is a boundary edge then the topological effect would not be as intended). We do allow e to be an internal edge with both endpoints on the boundary, but note that in this case the resulting topological operation would render the triangulation invalid.
If you are trying to reduce the number of vertices without changing the topology, and if e is an edge connecting an internal vertex with some different vertex, then either collapseEdge() or pinchEdge() may be more appropriate for your situation.
Note that after performing this move, all skeletal objects (triangles, components, etc.) will be reconstructed, which means any pointers to old skeletal objects (such as the argument e) can no longer be used.
e | the edge to collapse. |
void regina::Triangulation< 3 >::puncture | ( | Tetrahedron< 3 > * | tet = nullptr | ) |
Punctures this manifold by removing a 3-ball from the interior of the given tetrahedron.
If no tetrahedron is specified (i.e., the tetrahedron pointer is null
), then the puncture will be taken from the interior of tetrahedron 0.
The puncture will not meet the boundary of the tetrahedron, so nothing will go wrong if the tetrahedron has boundary facets and/or ideal vertices. A side-effect of this, however, is that the resulting triangulation will contain additional vertices, and will almost certainly be far from minimal. It is highly recommended that you run intelligentSimplify() if you do not need to preserve the combinatorial structure of the new triangulation.
The puncturing is done by subdividing the original tetrahedron. The new tetrahedra will have orientations consistent with the original tetrahedra, so if the triangulation was originally oriented then it will also be oriented after this routine has been called. See isOriented() for further details on oriented triangulations.
The new sphere boundary will be formed from two triangles; specifically, face 0 of the last and second-last tetrahedra of the triangulation. These two triangles will be joined so that vertex 1 of each tetrahedron coincides, and vertices 2,3 of one map to vertices 3,2 of the other.
tet
is non-null then it is in fact a tetrahedron of this triangulation.tet | the tetrahedron inside which the puncture will be taken. This may be null (the default), in which case the first tetrahedron will be used. |
std::string regina::Triangulation< 3 >::recogniser | ( | ) | const |
Returns a string that expresses this triangulation in Matveev's 3-manifold recogniser format.
void regina::Triangulation< 3 >::recogniser | ( | std::ostream & | out | ) | const |
Writes a string expressing this triangulation in Matveev's 3-manifold recogniser format to the given output stream.
out | the output stream to which the recogniser data file will be written. |
std::string regina::Triangulation< 3 >::recognizer | ( | ) | const |
A synonym for recogniser().
This returns a string that expresses this triangulation in Matveev's 3-manifold recogniser format.
|
inline |
A synonym for recognizer(std::ostream&).
This writes a string expressing this triangulation in Matveev's 3-manifold recogniser format to the given output stream.
out | the output stream to which the recogniser data file will be written. |
|
static |
Rehydrates the given alphabetical string into a new triangulation.
See dehydrate() for more information on dehydration strings.
This routine will rehydrate the given string into a new triangulation, and return this new triangulation.
The converse routine dehydrate() can be used to extract a dehydration string from an existing triangulation. Dehydration followed by rehydration might not produce a triangulation identical to the original, but it is guaranteed to produce an isomorphic copy. See dehydrate() for the reasons behind this.
For a full description of the dehydrated triangulation format, see A Census of Cusped Hyperbolic 3-Manifolds, Callahan, Hildebrand and Weeks, Mathematics of Computation 68/225, 1999.
dehydration | a dehydrated representation of the triangulation to construct. Case is irrelevant; all letters will be treated as if they were lower case. |
|
inline |
A dimension-specific alias for removeAllSimplices().
See removeAllSimplices() for further information.
|
inline |
A dimension-specific alias for removeSimplex().
See removeSimplex() for further information.
|
inline |
A dimension-specific alias for removeSimplexAt().
See removeSimplexAt() for further information.
void regina::Triangulation< 3 >::reorderTetrahedraBFS | ( | bool | reverse = false | ) |
Reorders the tetrahedra of this triangulation using a breadth-first search, so that small-numbered tetrahedra are adjacent to other small-numbered tetrahedra.
Specifically, the reordering will operate as follows. Tetrahedron 0 will remain tetrahedron 0. Its immediate neighbours will be numbered 1, 2, 3 and 4 (though if these neighbours are not distinct then of course fewer labels will be required). Their immediate neighbours will in turn be numbered 5, 6, and so on, ultimately following a breadth-first search throughout the entire triangulation.
If the optional argument reverse is true
, then tetrahedron numbers will be assigned in reverse order. That is, tetrahedron 0 will become tetrahedron n-1, its neighbours will become tetrahedra n-2 down to n-5, and so on.
reverse | true if the new tetrahedron numbers should be assigned in reverse order, as described above. |
|
inline |
Explores all triangulations that can be reached from this via Pachner moves, without exceeding a given number of additional tetrahedra.
Specifically, this routine will iterate through all triangulations that can be reached from this triangulation via 2-3 and 3-2 Pachner moves, without ever exceeding height additional tetrahedra beyond the original number.
For every such triangulation (including this starting triangulation), this routine will call action (which must be a function or some other callable object).
true
, then this indicates that processing should stop immediately (i.e., no more triangulations will be processed).This routine can be very slow and very memory-intensive, since the number of triangulations it visits may be superexponential in the number of tetrahedra, and it records every triangulation that it visits (so as to avoid revisiting the same triangulation again). It is highly recommended that you begin with height = 1, and if necessary try increasing height one at a time until this routine becomes too expensive to run.
If height is negative, then there will be no bound on the number of additional tetrahedra. This means that the routine will never terminate, unless action returns true
for some triangulation that is passed to it.
If a progress tracker is passed, then the exploration of triangulations will take place in a new thread and this routine will return immediately.
To assist with performance, this routine can run in parallel (multithreaded) mode; simply pass the number of parallel threads in the argument nThreads. Even in multithreaded mode, if no progress tracker is passed then this routine will not return until processing has finished (i.e., either action returned true
, or the search was exhausted). All calls to action will be protected by a mutex (i.e., different threads will never be calling action at the same time).
If no progress tracker was passed then it will immediately return false
; otherwise the progress tracker will immediately be marked as finished.
height | the maximum number of additional tetrahedra to allow beyond the number of tetrahedra originally present in the triangulation, or a negative number if this should not be bounded. |
nThreads | the number of threads to use. If this is 1 or smaller then the routine will run single-threaded. |
tracker | a progress tracker through which progress will be reported, or 0 if no progress reporting is required. |
action | a function (or other callable object) to call upon each triangulation that is found. |
args | any additional arguments that should be passed to action, following the initial triangulation argument. |
true
or false
immediately according to whether a new thread could or could not be started. If no progress tracker is passed, then this routine will return true
if some call to action returned true
(thereby terminating the search early), or false
if the search ran to completion. bool regina::Triangulation< 3 >::saveRecogniser | ( | const char * | filename | ) | const |
Writes this triangulation to the given file in Matveev's 3-manifold recogniser format.
filename | the name of the Recogniser file to which to write. |
true
if and only if the file was successfully written.
|
inline |
A synonym for saveRecogniser().
This writes this triangulation to the given file in Matveev's 3-manifold recogniser format.
filename | the name of the Recogniser file to which to write. |
true
if and only if the file was successfully written.
|
virtual |
Writes this triangulation to the given file using SnapPea's native file format.
Regarding what gets stored in the SnapPea data file:
If this triangulation is empty, invalid, or contains boundary triangles (which SnapPea cannot represent), then the file will not be written and this routine will return false
.
filename | the name of the SnapPea file to which to write. |
true
if and only if the file was successfully written. Reimplemented in regina::SnapPeaTriangulation.
bool regina::Triangulation< 3 >::shellBoundary | ( | Tetrahedron< 3 > * | t, |
bool | check = true , |
||
bool | perform = true |
||
) |
Checks the eligibility of and/or performs a boundary shelling move on the given tetrahedron.
This involves simply popping off a tetrahedron that touches the boundary. This can be done if:
If the routine is asked to both check and perform, the move will only be performed if the check shows it is legal.
Note that after performing this move, all skeletal objects (triangles, components, etc.) will be reconstructed, which means any pointers to old skeletal objects can no longer be used.
t | the tetrahedron upon 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
. bool regina::Triangulation< 3 >::simplifyExhaustive | ( | int | height = 1 , |
unsigned | nThreads = 1 , |
||
ProgressTrackerOpen * | tracker = nullptr |
||
) |
Attempts to simplify this triangulation using a slow but exhaustive search through the Pachner graph.
This routine is more powerful but much slower than intelligentSimplify().
Specifically, this routine will iterate through all triangulations that can be reached from this triangulation via 2-3 and 3-2 Pachner moves, without ever exceeding height additional tetrahedra beyond the original number.
If at any stage it finds a triangulation with fewer tetrahedra than the original, then this routine will call intelligentSimplify() to shrink the triangulation further if possible and will then return true
. If it cannot find a triangulation with fewer tetrahedra then it will leave this triangulation unchanged and return false
.
This routine can be very slow and very memory-intensive: the number of triangulations it visits may be superexponential in the number of tetrahedra, and it records every triangulation that it visits (so as to avoid revisiting the same triangulation again). It is highly recommended that you begin with height = 1, and if this fails then try increasing height one at a time until either you find a simplification or the routine becomes too expensive to run.
If height is negative, then there will be no bound on the number of additional tetrahedra. This means that the routine will not terminate until a simpler triangulation is found. If no simpler diagram exists then the only way to terminate this function is to cancel the operation via a progress tracker (read on for details).
If you want a fast simplification routine, you should call intelligentSimplify() instead. The benefit of simplifyExhaustive() is that, for very stubborn triangulations where intelligentSimplify() finds itself stuck at a local minimum, simplifyExhaustive() is able to "climb out" of such wells.
If a progress tracker is passed, then the exhaustive simplification will take place in a new thread and this routine will return immediately. In this case, you will need to use some other means to determine whether the triangulation was eventually simplified (e.g., by examining size() after the tracker indicates that the operation has finished).
To assist with performance, this routine can run in parallel (multithreaded) mode; simply pass the number of parallel threads in the argument nThreads. Even in multithreaded mode, if no progress tracker is passed then this routine will not return until processing has finished (i.e., either the triangulation was simplified or the search was exhausted).
If this routine is unable to simplify the triangulation, then the triangulation will not be changed.
If no progress tracker was passed then it will immediately return false
; otherwise the progress tracker will immediately be marked as finished.
height | the maximum number of additional tetrahedra to allow beyond the number of tetrahedra originally present in the triangulation, or a negative number if this should not be bounded. |
nThreads | the number of threads to use. If this is 1 or smaller then the routine will run single-threaded. |
tracker | a progress tracker through which progress will be reported, or 0 if no progress reporting is required. |
true
or false
immediately according to whether a new thread could or could not be started. If no progress tracker is passed, then this routine will return true
if and only if the triangulation was successfully simplified to fewer tetrahedra. bool regina::Triangulation< 3 >::simplifyToLocalMinimum | ( | bool | perform = true | ) |
Uses all known simplification moves to reduce the triangulation monotonically to some local minimum number of tetrahedra.
End users will probably not want to call this routine. You should call intelligentSimplify() if you want a fast (and usually effective) means of simplifying a triangulation, or you should call simplifyExhaustive() if you are still stuck and you want to try a slower but more powerful method instead.
The moves used by this routine include 3-2, 2-0 (edge and vertex), 2-1 and boundary shelling moves.
Moves that do not reduce the number of tetrahedra (such as 4-4 moves or book opening moves) are not used in this routine. Such moves do however feature in intelligentSimplify().
perform | true if we are to perform the simplifications, or false if we are only to investigate whether simplifications are possible (defaults to true ). |
true
, this routine returns true
if and only if the triangulation was changed to reduce the number of tetrahedra; if perform is false
, this routine returns true
if and only if it determines that it is capable of performing such a change.
|
virtual |
Returns a string containing the full contents of a SnapPea data file that describes this triangulation.
In particular, this string can be used in a Python session to pass the triangulation directly to SnapPy (without writing to the filesystem).
Regarding what gets stored in the SnapPea data file:
If you wish to export a triangulation to a SnapPea file, you should call saveSnapPea() instead (which has better performance, and does not require you to construct an enormous intermediate string).
If this triangulation is empty, invalid, or contains boundary triangles (which SnapPea cannot represent), then the resulting string will be empty.
Reimplemented in regina::SnapPeaTriangulation.
|
virtual |
Writes the full contents of a SnapPea data file describing this triangulation to the given output stream.
Regarding what gets stored in the SnapPea data file:
If you wish to extract the SnapPea data file as a string, you should call the zero-argument routine snapPea() instead. If you wish to write to a real SnapPea data file on the filesystem, you should call saveSnapPea() (which is also available in Python).
If this triangulation is empty, invalid, or contains boundary triangles (which SnapPea cannot represent), then nothing will be written to the output stream.
out | the output stream to which the SnapPea data file will be written. |
Reimplemented in regina::SnapPeaTriangulation.
|
inline |
Return the triangle vertex or triangle edge that plays a special role for the triangle type of this triangle.
Note that this routine is only relevant for some triangle types. The triangle type is returned by type().
|
inline |
Deprecated function that checks the eligibility of and/or performs a 3-2 move about the given edge.
This is an alias for pachner(Edge<3>*, bool, bool); see that routine for further details.
e | the edge 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
.
|
inline |
Default constructor.
Creates an empty triangulation.
regina::Triangulation< 3 >::Triangulation | ( | const std::string & | description | ) |
"Magic" constructor that tries to find some way to interpret the given string as a triangulation.
At present, Regina understands the following types of strings (and attempts to parse them in the following order):
This list may grow in future versions of Regina.
Regina will also set the packet label accordingly.
If Regina cannot interpret the given string, this will be left as the empty triangulation.
description | a string that describes a 3-manifold triangulation. |
regina::Triangulation< 3 >::Triangulation | ( | const Triangulation< 3 > & | 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. |
|
inline |
Creates a new copy of the given triangulation.
The packet tree structure and packet label are not copied.
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::Triangulation< 3 >::Triangulation | ( | snappy.Manifold | m | ) |
Python-only constructor that copies the given SnapPy manifold.
m | a SnapPy object of type snappy.Manifold. |
regina::Triangulation< 3 >::Triangulation | ( | snappy.Triangulation< 3 > | t | ) |
Python-only constructor that copies the given SnapPy triangulation.
m | a SnapPy object of type snappy.Triangulation. |
Cyclotomic regina::Triangulation< 3 >::turaevViro | ( | unsigned long | r, |
bool | parity = true , |
||
Algorithm | alg = ALG_DEFAULT , |
||
ProgressTracker * | tracker = nullptr |
||
) | const |
Computes the given Turaev-Viro state sum invariant of this 3-manifold using exact arithmetic.
The initial data for the Turaev-Viro invariant is as described in the paper of Turaev and Viro, "State sum invariants of 3-manifolds and quantum 6j-symbols", Topology, vol. 31, no. 4, 1992, pp 865-902. In particular, Section 7 of this paper describes the initial data as determined by an integer r >= 3, and a root of unity q0 of degree 2r for which q0^2 is a primitive root of unity of degree r. There are several cases to consider:
true
. Here the invariant is again computed as an element of the cyclotomic field of order 2r. As before, there is no need to give further information as to which root of unity is used, since switching between roots of unity does not yield new information.false
. In this case the invariant is computed as an element of the cyclotomic field of order r. Again, there is no need to give further information as to which root of unity is used.This routine works entirely within the relevant cyclotomic field, which yields exact results but adds a significant overhead to the running time. If you want a fast floating-point approximation, you can call turaevViroApprox() instead.
Unlike this routine, turaevViroApprox() requires a precise specification of which root of unity is used (since it returns a numerical real value). The numerical value obtained by calling turaevViroApprox(r, whichRoot)
should be the same as turaevViro(r, parity).evaluate(whichRoot)
, where parity is true
or false
according to whether whichRoot is odd or even respectively. Of course in practice the numerical values might be very different, since turaevViroApprox() performs significantly more floating point operations, and so is subject to a much larger potential numerical error.
If the requested Turaev-Viro invariant has already been computed, then the result will be cached and so this routine will be very fast (since it just returns the previously computed result). Otherwise the computation could be quite slow, particularly for larger triangulations and/or larger values of r. This (potentially) long computation can be managed by passing a progress tracker:
r | the integer r as described above; this must be at least 3. |
parity | determines for odd r whether q0 is a primitive 2rth or rth root of unity, as described above. |
alg | the algorithm with which to compute the invariant. If you are not sure, the default value (ALG_DEFAULT) is a safe choice. |
tracker | a progress tracker through will progress will be reported, or 0 if no progress reporting is required. |
double regina::Triangulation< 3 >::turaevViroApprox | ( | unsigned long | r, |
unsigned long | whichRoot = 1 , |
||
Algorithm | alg = ALG_DEFAULT |
||
) | const |
Computes the given Turaev-Viro state sum invariant of this 3-manifold using a fast but inexact floating-point approximation.
The initial data for the Turaev-Viro invariant is as described in the paper of Turaev and Viro, "State sum invariants of 3-manifolds and quantum 6j-symbols", Topology, vol. 31, no. 4, 1992, pp 865-902. In particular, Section 7 describes the initial data as determined by an integer r >= 3 and a root of unity q0 of degree 2r for which q0^2 is a primitive root of unity of degree r.
The argument whichRoot specifies which root of unity is used for q0. Specifically, q0 will be the root of unity e^(2i * Pi * whichRoot / 2r)
. There are additional preconditions on whichRoot to ensure that q0^2 is a primitive root of unity of degree r; see below for details.
This same invariant can be computed by calling turaevViro(r, parity).evaluate(whichRoot)
, where parity is true
or false
according to whether whichRoot is odd or even respectively. Calling turaevViroApprox() is significantly faster (since it avoids the overhead of working in cyclotomic fields), but may also lead to a much larger numerical error (since this routine might perform an exponential number of floating point operations, whereas the alternative only uses floating point for the final call to Cyclotomic::evaluate()).
These invariants, although computed in the complex field, should all be reals. Thus the return type is an ordinary double.
r | the integer r as described above; this must be at least 3. |
whichRoot | specifies which root of unity is used for q0, as described above. |
alg | the algorithm with which to compute the invariant. If you are not sure, the default value (ALG_DEFAULT) is a safe choice. |
bool regina::Triangulation< 3 >::twoOneMove | ( | Edge< 3 > * | e, |
int | edgeEnd, | ||
bool | check = true , |
||
bool | perform = true |
||
) |
Checks the eligibility of and/or performs a 2-1 move about the given edge.
This involves taking an edge meeting only one tetrahedron just once and merging that tetrahedron with one of the tetrahedra joining it.
This can be done assuming the following conditions:
e
to the vertex of the second tetrahedron not touching the original tetrahedron. These edges must be distinct and may not both be in the boundary.There are additional "distinct and not both boundary" conditions on faces of the second tetrahedron, but those follow automatically from the final condition above.
If the routine is asked to both check and perform, the move will only be performed if the check shows it is legal.
Note that after performing this move, all skeletal objects (triangles, components, etc.) will be reconstructed, which means any pointers to old skeletal objects (such as the argument e) can no longer be used.
e | the edge about which to perform the move. |
edgeEnd | the end of the edge opposite that at which the second tetrahedron (to be merged) is joined. The end is 0 or 1, corresponding to the labelling (0,1) of the vertices of the edge as described in EdgeEmbedding<3>::vertices(). |
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
.
|
inline |
Deprecated function that checks the eligibility of and/or performs a 2-3 move about the given triangle.
This is an alias for pachner(Triangle<3>*, bool, bool); see that routine for further details.
t | the triangle 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
. bool regina::Triangulation< 3 >::twoZeroMove | ( | Edge< 3 > * | e, |
bool | check = true , |
||
bool | perform = true |
||
) |
Checks the eligibility of and/or performs a 2-0 move about the given edge of degree 2.
This involves taking the two tetrahedra joined at that edge and squashing them flat. This can be done if:
e
in each tetrahedron are distinct and not both boundary;If the routine is asked to both check and perform, the move will only be performed if the check shows it is legal.
Note that after performing this move, all skeletal objects (triangles, components, etc.) will be reconstructed, which means any pointers to old skeletal objects (such as the argument e) can no longer be used.
e | the edge 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
. bool regina::Triangulation< 3 >::twoZeroMove | ( | Vertex< 3 > * | v, |
bool | check = true , |
||
bool | perform = true |
||
) |
Checks the eligibility of and/or performs a 2-0 move about the given vertex of degree 2.
This involves taking the two tetrahedra joined at that vertex and squashing them flat. This can be done if:
v
in each tetrahedron are distinct and not both boundary;If the routine is asked to both check and perform, the move will only be performed if the check shows it is legal.
Note that after performing this move, all skeletal objects (triangles, components, etc.) will be reconstructed, which means any pointers to old skeletal objects (such as the argument v) can no longer be used.
v | the vertex 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
. Type regina::Face< 3, 2 >::type | ( | ) |
Returns a description of the triangle type.
This will be one of the eight shapes described by the Type enumeration, indicating how the edges and vertices of the triangle are identified.
|
overridevirtual |
Writes a detailed text representation of this object to the given output stream.
This may be reimplemented by subclasses, but the parent Packet class offers a reasonable default implementation.
out | the output stream to which to write. |
Reimplemented from regina::Packet.
Reimplemented in regina::SnapPeaTriangulation.
void regina::Face< 3, 0 >::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. |
|
inlineoverridevirtual |
Writes a short text representation of this object to the given output stream.
This must be reimplemented by subclasses.
out | the output stream to which to write. |
Implements regina::Packet.
Reimplemented in regina::SnapPeaTriangulation.
|
overrideprotectedvirtual |
Writes a chunk of XML containing the data for this packet only.
You may assume that the packet opening tag (including the packet type and label) has already been written, and that all child packets followed by the corresponding packet closing tag will be written immediately after this routine is called. This routine need only write the internal data stored in this specific packet.
out | the output stream to which the XML should be written. |
Implements regina::Packet.
Reimplemented in regina::SnapPeaTriangulation.
regina::Face< 3, 0 >::~Face | ( | ) |
Default destructor.
|
inlinevirtual |
Destroys this triangulation.
The constituent tetrahedra, the cellular structure and all other properties will also be destroyed.
|
friend |
Allow access to private members.