Regina Calculation Engine
|
Normal surfaces in 3-manifold triangulations. More...
Classes | |
struct | regina::DiscSpec |
Specifies a single normal disc in a normal surface. More... | |
class | regina::DiscSetTet |
Represents a set of normal discs inside a single tetrahedron. More... | |
class | regina::DiscSetTetData< T > |
Stores data of type T for every normal disc inside a single tetrahedron. More... | |
class | regina::DiscSetSurface |
Represents the set of all normal discs forming a normal surface. More... | |
class | regina::DiscSetSurfaceData< T > |
Stores data of type T for every normal disc within a particular normal surface. More... | |
class | regina::DiscSpecIterator |
A forward iterator used for running through all normal discs in a normal surface. More... | |
struct | std::iterator_traits< regina::DiscSpecIterator > |
struct | regina::DiscType |
Identifies a single normal or almost normal disc type within a triangulation. More... | |
class | regina::Matrix< T, ring > |
Represents a matrix of elements of the given type T. More... | |
struct | regina::NormalInfo< coordType > |
A template that stores information about a particular normal coordinate system. More... | |
class | regina::NormalSurfaceVector |
Stores the vector of a single normal surface in a 3-manifold. More... | |
class | regina::NormalSurface |
Represents a single normal surface in a 3-manifold. More... | |
class | regina::NormalSurfaces |
A packet representing a collection of normal surfaces in a 3-manifold. More... | |
class | regina::NSVectorANStandard |
An almost normal surface vector using standard triangle-quad-oct coordinates. More... | |
class | regina::NSVectorMirrored |
A normal surface vector that is mirrored in another coordinate system to avoid frequent lengthy calculations. More... | |
class | regina::NSVectorOriented |
A normal surface vector using transversely oriented standard (triangle-quad) coordinates. More... | |
class | regina::NSVectorOrientedQuad |
A normal surface vector using transversely oriented quadrilateral coordinates. More... | |
class | regina::NSVectorQuad |
A normal surface vector using quad coordinates. More... | |
class | regina::NSVectorQuadClosed |
The vector for a normal surface in an ideal triangulation, expressed using quad coordinates and enumerated to include closed surfaces only. More... | |
class | regina::NSVectorQuadOct |
An almost normal surface vector using quad-oct coordinates. More... | |
class | regina::NSVectorQuadOctClosed |
The vector for an almost normal surface in an ideal triangulation, expressed using quad-oct coordinates and enumerated to include closed surfaces only. More... | |
class | regina::NSVectorStandard |
A normal surface vector using standard triangle-quad coordinates. More... | |
struct | regina::PrismSpec |
Specifies a single triangular prism in a tetrahedron. More... | |
struct | regina::SurfaceFilterInfo< filterType > |
A template that stores information about a particular type of normal surface filter. More... | |
class | regina::SurfaceFilter |
A packet that accepts or rejects normal surfaces. More... | |
class | regina::SurfaceFilterCombination |
A normal surface filter that simply combines other filters. More... | |
class | regina::SurfaceFilterProperties |
A normal surface filter that filters by basic properties of the normal surface. More... | |
class | regina::XMLFilterReader |
An XML element reader that reads the specific details of a normal surface filter. More... | |
class | regina::XMLFilterPacketReader |
An XML packet reader that reads a single surface filter. More... | |
class | regina::XMLNormalSurfaceReader |
An XML element reader that reads a single normal surface. More... | |
class | regina::XMLNormalSurfacesReader |
An XML packet reader that reads a single normal surface list. More... | |
Macros | |
#define | REGINA_NORMAL_SURFACE_FLAVOUR(class_, id, superclass) |
Defines various constants, types and virtual functions for a subclass of NormalSurfaceVector. More... | |
#define | REGINA_SURFACE_FILTER(class_, id) |
Defines various constants, types and virtual functions for a descendant class of SurfaceFilter. More... | |
Typedefs | |
typedef T * | regina::DiscSetTetData< T >::DataPtr |
A type that is a pointer to the data stored with each disc. More... | |
typedef DiscSpec | regina::NDiscSpec |
Deprecated typedef for backward compatibility. More... | |
typedef DiscSetTet | regina::NDiscSetTet |
Deprecated typedef for backward compatibility. More... | |
template<class T > | |
using | regina::NDiscSetTetData = DiscSetTetData< T > |
Deprecated typedef for backward compatibility. More... | |
typedef DiscSetSurface | regina::NDiscSetSurface |
Deprecated typedef for backward compatibility. More... | |
template<class T > | |
using | regina::NDiscSetSurfaceData = DiscSetSurfaceData< T > |
Deprecated typedef for backward compatibility. More... | |
typedef long | std::iterator_traits< regina::DiscSpecIterator >::difference_type |
typedef const regina::DiscSpec & | std::iterator_traits< regina::DiscSpecIterator >::value_type |
typedef const regina::DiscSpec * | std::iterator_traits< regina::DiscSpecIterator >::pointer |
typedef const regina::DiscSpec & | std::iterator_traits< regina::DiscSpecIterator >::reference |
typedef std::forward_iterator_tag | std::iterator_traits< regina::DiscSpecIterator >::iterator_category |
typedef DiscType | regina::NDiscType |
Deprecated typedef for backward compatibility. More... | |
typedef regina::Flags< NormalListFlags > | regina::NormalList |
A combination of flags for types of normal surface lists. More... | |
typedef regina::Flags< NormalAlgFlags > | regina::NormalAlg |
A combination of flags for types of normal surface lists. More... | |
typedef NormalSurfaceVector | regina::NNormalSurfaceVector |
Deprecated typedef for backward compatibility. More... | |
typedef NormalSurface | regina::NNormalSurface |
Deprecated typedef for backward compatibility. More... | |
typedef NormalSurfaces | regina::NNormalSurfaceList |
Deprecated typedef for backward compatibility. More... | |
typedef NSVectorANStandard | regina::NNormalSurfaceVectorANStandard |
Deprecated typedef for backward compatibility. More... | |
typedef NSVectorMirrored | regina::NNormalSurfaceVectorMirrored |
Deprecated typedef for backward compatibility. More... | |
typedef NSVectorOriented | regina::NNormalSurfaceVectorOriented |
Deprecated typedef for backward compatibility. More... | |
typedef NSVectorOrientedQuad | regina::NNormalSurfaceVectorOrientedQuad |
Deprecated typedef for backward compatibility. More... | |
typedef NSVectorQuad | regina::NNormalSurfaceVectorQuad |
Deprecated typedef for backward compatibility. More... | |
typedef NSVectorQuadOct | regina::NNormalSurfaceVectorQuadOct |
Deprecated typedef for backward compatibility. More... | |
typedef NSVectorStandard | regina::NNormalSurfaceVectorStandard |
Deprecated typedef for backward compatibility. More... | |
typedef PrismSpec | regina::NPrismSpec |
Deprecated typedef for backward compatibility. More... | |
typedef SurfaceFilter | regina::NSurfaceFilter |
Deprecated typedef for backward compatibility. More... | |
typedef SurfaceFilterCombination | regina::NSurfaceFilterCombination |
Deprecated typedef for backward compatibility. More... | |
typedef SurfaceFilterProperties | regina::NSurfaceFilterProperties |
Deprecated typedef for backward compatibility. More... | |
Functions | |
template<typename FunctionObject , typename... Args> | |
ReturnsTraits< FunctionObject >::ReturnType | regina::forCoords (NormalCoords coords, FunctionObject &&func, typename ReturnsTraits< FunctionObject >::ReturnType defaultReturn, Args &&... args) |
Allows the user to call a template function whose template parameter matches a given value of NormalCoords, which is not known until runtime. More... | |
template<typename FunctionObject , typename... Args> | |
ReturnsTraits< FunctionObject >::Void | regina::forCoords (NormalCoords coords, FunctionObject &&func, Args &&... args) |
Allows the user to call a template function whose template parameter matches a given value of NormalCoords, which is not known until runtime. More... | |
regina::DiscSpec::DiscSpec () | |
Creates a new uninitialised disc specifier. More... | |
regina::DiscSpec::DiscSpec (size_t newTetIndex, int newType, unsigned long newNumber) | |
Creates a new disc specifier containing the given values. More... | |
regina::DiscSpec::DiscSpec (const DiscSpec &cloneMe)=default | |
Creates a new disc specifier that is a clone of the given specifier. More... | |
DiscSpec & | regina::DiscSpec::operator= (const DiscSpec &cloneMe)=default |
Copies the values from the given disc specifier into this specifier. More... | |
bool | regina::DiscSpec::operator== (const DiscSpec &other) const |
Determines if this and the given disc specifier contain identical information. More... | |
bool | regina::DiscSpec::operator!= (const DiscSpec &other) const |
Determines if this and the given disc specifier contain different information. More... | |
std::ostream & | regina::operator<< (std::ostream &out, const DiscSpec &spec) |
Writes the given disc specifier to the given output stream. More... | |
bool | regina::numberDiscsAwayFromVertex (int discType, int vertex) |
Determines whether or not normal discs of the given type are numbered away from the given vertex. More... | |
bool | regina::discOrientationFollowsEdge (int discType, int vertex, int edgeStart, int edgeEnd) |
Determines whether or not the natural boundary orientation of a normal disc of the given type follows the given directed normal arc. More... | |
regina::DiscSetTet::DiscSetTet (const NormalSurface &surface, size_t tetIndex) | |
Creates a new set of normal discs corresponding to the discs of the given normal surface that lie within the given tetrahedron. More... | |
regina::DiscSetTet::DiscSetTet (unsigned long tri0, unsigned long tri1, unsigned long tri2, unsigned long tri3, unsigned long quad0, unsigned long quad1, unsigned long quad2, unsigned long oct0=0, unsigned long oct1=0, unsigned long oct2=0) | |
Creates a new set of normal discs where the number of discs of each type is explicitly given. More... | |
virtual | regina::DiscSetTet::~DiscSetTet () |
Destroys this disc set. More... | |
unsigned long | regina::DiscSetTet::nDiscs (int type) const |
Determines the number of discs of the given type inside this tetrahedron. More... | |
unsigned long | regina::DiscSetTet::arcFromDisc (int arcFace, int arcVertex, int discType, unsigned long discNumber) const |
Determines which normal arc of a given type on a given face of this tetrahedron corresponds to the given normal disc. More... | |
void | regina::DiscSetTet::discFromArc (int arcFace, int arcVertex, unsigned long arcNumber, int &discType, unsigned long &discNumber) const |
Determines which normal disc in this tetrahedron meets the given normal arc on the given face. More... | |
regina::DiscSetTet::DiscSetTet (const DiscSetTet &)=delete | |
DiscSetTet & | regina::DiscSetTet::operator= (const DiscSetTet &)=delete |
regina::DiscSetTetData< T >::DiscSetTetData (const NormalSurface &surface, size_t tetIndex) | |
Creates a new disc set corresponding to the discs of the given normal surface that lie within the given tetrahedron. More... | |
regina::DiscSetTetData< T >::DiscSetTetData (const NormalSurface &surface, size_t tetIndex, const T &initValue) | |
Creates a new disc set corresponding to the discs of the given normal surface that lie within the given tetrahedron. More... | |
regina::DiscSetTetData< T >::DiscSetTetData (unsigned long tri0, unsigned long tri1, unsigned long tri2, unsigned long tri3, unsigned long quad0, unsigned long quad1, unsigned long quad2, unsigned long oct0=0, unsigned long oct1=0, unsigned long oct2=0) | |
Creates a new disc set where the number of discs of each type is explicitly given. More... | |
virtual | regina::DiscSetTetData< T >::~DiscSetTetData () |
Destroys this disc set and deallocates all data arrays. More... | |
T & | regina::DiscSetTetData< T >::data (int discType, unsigned long discNumber) |
Retrieves a reference to the data corresponding to the given normal disc. More... | |
regina::DiscSetTetData< T >::DiscSetTetData (const DiscSetTet &)=delete | |
DiscSetTetData & | regina::DiscSetTetData< T >::operator= (const DiscSetTet &)=delete |
regina::DiscSetSurface::DiscSetSurface (const NormalSurface &surface, bool b) | |
Creates a new disc set corresponding to the discs of the given normal surface. More... | |
regina::DiscSetSurface::DiscSetSurface (const NormalSurface &surface) | |
Creates a new disc set corresponding to the discs of the given normal surface. More... | |
virtual | regina::DiscSetSurface::~DiscSetSurface () |
Destroys this set of discs and deallocates all associated memory. More... | |
size_t | regina::DiscSetSurface::nTets () const |
Returns the number of tetrahedra in the underlying triangulation. More... | |
unsigned long | regina::DiscSetSurface::nDiscs (size_t tetIndex, int type) const |
Determines the number of discs of the given type inside the given tetrahedron. More... | |
DiscSetTet & | regina::DiscSetSurface::tetDiscs (size_t tetIndex) const |
Returns the specific set of discs living inside the given tetrahedron. More... | |
DiscSpec * | regina::DiscSetSurface::adjacentDisc (const DiscSpec &disc, Perm< 4 > arc, Perm< 4 > &adjArc) const |
Determines which normal disc is adjacent to the given normal disc along the given directed normal arc in the surface described by this disc set. More... | |
DiscSpecIterator | regina::DiscSetSurface::begin () const |
Returns an iterator at the beginning of the range of all normal discs in the underlying normal surface. More... | |
DiscSpecIterator | regina::DiscSetSurface::end () const |
Returns an iterator at the end of the range of all normal discs in the underlying normal surface. More... | |
regina::DiscSetSurface::DiscSetSurface (const DiscSetSurface &)=delete | |
DiscSetSurface & | regina::DiscSetSurface::operator= (const DiscSetSurface &)=delete |
regina::DiscSetSurfaceData< T >::DiscSetSurfaceData (const NormalSurface &surface) | |
Creates a new disc set corresponding to the discs of the given normal surface. More... | |
regina::DiscSetSurfaceData< T >::DiscSetSurfaceData (const NormalSurface &surface, const T &initValue) | |
Creates a new disc set corresponding to the discs of the given normal surface. More... | |
T & | regina::DiscSetSurfaceData< T >::data (const DiscSpec &disc) |
Retrieves a reference to the data corresponding to the given normal disc. More... | |
regina::DiscSetSurfaceData< T >::DiscSetSurfaceData (const DiscSetSurfaceData &)=delete | |
DiscSetSurfaceData & | regina::DiscSetSurfaceData< T >::operator= (const DiscSetSurfaceData &)=delete |
regina::DiscSpecIterator::DiscSpecIterator () | |
Creates a new uninitialised iterator. More... | |
regina::DiscSpecIterator::DiscSpecIterator (const DiscSetSurface &discSet) | |
Creates a new iterator pointing to the first disc in the given disc set. More... | |
regina::DiscSpecIterator::DiscSpecIterator (const DiscSpecIterator &)=default | |
Default copy constructor. More... | |
void | regina::DiscSpecIterator::init (const DiscSetSurface &discSet) |
Points this iterator to the first disc in the given disc set. More... | |
DiscSpecIterator & | regina::DiscSpecIterator::operator= (const DiscSpecIterator &)=default |
Default copy assignment operator. More... | |
DiscSpecIterator & | regina::DiscSpecIterator::operator++ () |
Preincrement operator. More... | |
DiscSpecIterator | regina::DiscSpecIterator::operator++ (int) |
Postincrement operator. More... | |
const DiscSpec & | regina::DiscSpecIterator::operator* () const |
Returns a reference to the disc pointed to by this iterator. More... | |
bool | regina::DiscSpecIterator::done () const |
Determines if this iterator is past-the-end. More... | |
bool | regina::DiscSpecIterator::operator== (const DiscSpecIterator &other) const |
Determines if this and the given iterator are equal. More... | |
bool | regina::DiscSpecIterator::operator!= (const DiscSpecIterator &other) const |
Determines if this and the given iterator are different. More... | |
std::ostream & | regina::operator<< (std::ostream &out, const DiscType &type) |
Writes the given disc type to the given output stream. More... | |
template<typename FunctionObject , typename... Args> | |
ReturnsTraits< FunctionObject >::ReturnType | regina::forFilter (SurfaceFilterType filter, FunctionObject &&func, typename ReturnsTraits< FunctionObject >::ReturnType defaultReturn, Args &&... args) |
Allows the user to call a template function whose template parameter matches a given value of SurfaceFilterType, which is not known until runtime. More... | |
template<typename FunctionObject , typename... Args> | |
ReturnsTraits< FunctionObject >::Void | regina::forFilter (SurfaceFilterType filter, FunctionObject &&func, Args &&... args) |
Allows the user to call a template function whose template parameter matches a given value of SurfaceFilterType, which is not known until runtime. More... | |
NormalList | regina::operator| (NormalListFlags lhs, NormalListFlags rhs) |
Returns the bitwise OR of the two given flags. More... | |
NormalAlg | regina::operator| (NormalAlgFlags lhs, NormalAlgFlags rhs) |
Returns the bitwise OR of the two given flags. More... | |
NormalSurfaceVector * | regina::makeZeroVector (const Triangulation< 3 > *triangulation, NormalCoords coords) |
Returns a new normal surface vector of the appropriate length for the given triangulation and the given coordinate system. More... | |
MatrixInt * | regina::makeMatchingEquations (const Triangulation< 3 > *triangulation, NormalCoords coords) |
Creates a new set of normal surface matching equations for the given triangulation using the given coordinate system. More... | |
EnumConstraints * | regina::makeEmbeddedConstraints (const Triangulation< 3 > *triangulation, NormalCoords coords) |
Creates a new set of validity constraints representing the condition that normal surfaces be embedded. More... | |
std::ostream & | regina::operator<< (std::ostream &out, const PrismSpec &spec) |
Writes the given prism specifier to the given output stream. More... | |
Variables | |
size_t | regina::DiscSpec::tetIndex |
The index in the triangulation of the tetrahedron containing the disc. More... | |
int | regina::DiscSpec::type |
The disc type; this is between 0 and 9 inclusive, as described in the DiscSpec class notes. More... | |
unsigned long | regina::DiscSpec::number |
Specifies which disc of the particular type in the particular tetrahedron is being referred to; discs are numbered as described in the DiscSpec class notes. More... | |
unsigned long | regina::DiscSetTet::internalNDiscs [10] |
The number of discs of each type. More... | |
DataPtr | regina::DiscSetTetData< T >::internalData [10] |
Stores the data corresponding to each normal disc. More... | |
DiscSetTet ** | regina::DiscSetSurface::discSets |
The disc sets corresponding to each tetrahedron. More... | |
const Triangulation< 3 > * | regina::DiscSetSurface::triangulation |
The triangulation in which the normal surface lives. More... | |
const DiscSetSurface * | regina::DiscSpecIterator::internalDiscSet |
The disc set through which we are iterating. More... | |
DiscSpec | regina::DiscSpecIterator::current |
The disc currently pointed to. More... | |
const int | regina::quadSeparating [4][4] |
Lists which quadrilateral types separate which pairs of vertices in a tetrahedron. More... | |
const int | regina::quadMeeting [4][4][2] |
Lists which quadrilateral types meet which edges in a tetrahedron. More... | |
const int | regina::quadDefn [3][4] |
Lists which vertices each quadrilateral type separates in a tetrahedron. More... | |
const int | regina::quadPartner [3][4] |
Lists the second vertex with which each vertex is paired under each quadrilateral type in a tetrahedron. More... | |
const char | regina::quadString [3][6] |
Contains strings that can be used to represent each quadrilateral type in a tetrahedron. More... | |
const Perm< 4 > | regina::triDiscArcs [4][3] |
Lists in consecutive order the directed normal arcs that form the boundary of each type of triangular normal disc. More... | |
const Perm< 4 > | regina::quadDiscArcs [3][4] |
Lists in consecutive order the directed normal arcs that form the boundary of each type of quadrilateral normal disc. More... | |
const Perm< 4 > | regina::octDiscArcs [3][8] |
Lists in consecutive order the directed normal arcs that form the boundary of each type of octagonal normal disc. More... | |
Friends | |
class | regina::DiscSpecIterator::DiscSetSurface |
std::ostream & | regina::DiscSpec::operator<< (std::ostream &out, const DiscSpec &spec) |
Writes the given disc specifier to the given output stream. More... | |
Normal surfaces in 3-manifold triangulations.
#define REGINA_NORMAL_SURFACE_FLAVOUR | ( | class_, | |
id, | |||
superclass | |||
) |
Defines various constants, types and virtual functions for a subclass of NormalSurfaceVector.
Every subclass of NormalSurfaceVector must include REGINA_NORMAL_SURFACE_FLAVOUR at the beginning of the class definition.
This macro provides the class with:
class_ | the name of this subclass of NormalSurfaceVector. |
id | the corresponding NNormalCoords constant. |
superclass | the vector class from which class_ is derived. This is typically NormalSurfaceVector, though in some cases it may be different (e.g., NSVectorMirrored). |
#define REGINA_SURFACE_FILTER | ( | class_, | |
id | |||
) |
Defines various constants, types and virtual functions for a descendant class of SurfaceFilter.
Every descendant class of SurfaceFilter must include REGINA_SURFACE_FILTER at the beginning of the class definition.
This macro provides the class with:
class_ | the name of this descendant class of SurfaceFilter. |
id | the corresponding SurfaceFilterType constant. |
typedef T* regina::DiscSetTetData< T >::DataPtr |
A type that is a pointer to the data stored with each disc.
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
using regina::NDiscSetSurfaceData = typedef DiscSetSurfaceData<T> |
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
typedef DiscSetTet regina::NDiscSetTet |
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
using regina::NDiscSetTetData = typedef DiscSetTetData<T> |
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
typedef DiscSpec regina::NDiscSpec |
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
typedef DiscType regina::NDiscType |
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
typedef NormalSurface regina::NNormalSurface |
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
typedef regina::Flags<NormalAlgFlags> regina::NormalAlg |
A combination of flags for types of normal surface lists.
A combination of flags for types of normal surface lists.
typedef PrismSpec regina::NPrismSpec |
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
typedef SurfaceFilter regina::NSurfaceFilter |
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
Represents options and variants of algorithms for enumerating various types of normal surfaces in 3-manifold triangulations.
These options are typically combined in a bitwise fashion using the NormalAlg type, and then passed to enumeration routines such as NormalSurfaces::enumerate().
enum regina::NormalCoords |
Represents different coordinate systems that can be used for enumerating and displaying normal surfaces.
IDs 0-9999 are reserved for future use by Regina. If you are extending Regina to include your own coordinate system, you should choose an ID >= 10000.
Represents different lists of normal surfaces that might be constructed for a given 3-manifold triangulation.
The NormalList enumeration refers to the contents of the list, whereas the NormalAlgFlags enumeration refers to the algorithm used to build it.
Used to describe a field, or a set of fields, that can be exported alongside a normal surface list.
This enumeration type is used with export routines such as NormalSurfaces::saveCSVStandard() or NormalSurfaces::saveCSVEdgeWeight().
This type describes fields in addition to normal coordinates, not the normal coordinates themselves (which are always exported). Each field describes some property of a single normal surface, and corresponds to a single column in a table of normal surfaces.
This type should be treated as a bitmask: you can describe a set of fields by combining the values for individual fields using bitwise or.
The list of available fields may grow with future releases of Regina.
Enumerator | |
---|---|
surfaceExportName | Represents the user-assigned surface name. |
surfaceExportEuler | Represents the calculated Euler characteristic of a surface. This will be an integer, and will be left empty if the Euler characteristic cannot be computed. |
surfaceExportOrient | Represents the calculated property of whether a surface is orientable. This will be the string |
surfaceExportSides | Represents the calculated property of whether a surface is one-sided or two-sided. This will be the integer 1 or 2, or will be left empty if the "sidedness" cannot be computed. |
surfaceExportBdry | Represents the calculated property of whether a surface is bounded. In most cases, this will be one of the strings "closed", "real bdry" or "infinite" (where "infinite" indicates a surface with infinitely many discs). For spun-normal surfaces in certain ideal triangulations, this string will be followed by the boundary slopes of the surface at the cusps: these written as a list of pairs (p, q), one for each cusp, indicating that the boundary curves of the surface run p times around the meridian and q times around the longitude. See NormalSurface::boundaryIntersections() for further information on interpreting these values. |
surfaceExportLink | Represents whether a surface is a single vertex link or a thin edge link. See NormalSurface::isVertexLink() and NormalSurface::isThinEdgeLink() for details. This will be written as a human-readable string. |
surfaceExportType | Represents any additional high-level properties of a surface, such as whether it is a splitting surface or a central surface. This will be written as a human-readable string. This field is somewhat arbitrary, and the precise properties it describes are subject to change in future releases of Regina. |
surfaceExportNone | Indicates that no additional fields should be exported. |
surfaceExportAllButName | Indicates that all available fields should be exported, except for the user-assigned surface name. Since the list of available fields may grow with future releases, the numerical value of this constant may change as a result. |
surfaceExportAll | Indicates that all available fields should be exported, including the user-assigned surface name. Since the list of available fields may grow with future releases, the numerical value of this constant may change as a result. |
Represents different types of filter classes that can be used to filter lists of normal surfaces in 3-manifold triangulations.
IDs 0-9999 are reserved for future use by Regina. If you are extending Regina to include your own filter class, you should choose an ID >= 10000.
Enumerator | |
---|---|
NS_FILTER_DEFAULT | Represents the SurfaceFilter class: a do-nothing filter that accepts any normal surface. |
NS_FILTER_PROPERTIES | Represents the SurfaceFilterProperties subclass: a filter that examines simple properties of a normal surface. |
NS_FILTER_COMBINATION | Represents the SurfaceFilterCombination subclass: a filter that combines other filters using boolean AND or OR. |
DiscSpec* regina::DiscSetSurface::adjacentDisc | ( | const DiscSpec & | disc, |
Perm< 4 > | arc, | ||
Perm< 4 > & | adjArc | ||
) | const |
Determines which normal disc is adjacent to the given normal disc along the given directed normal arc in the surface described by this disc set.
A directed normal arc will be specified by a permutation p, where the arc runs around vertex p[0]
parallel to the directed edge from vertex p[1]
to p[2]
.
disc | the given normal disc; this must be a disc in this disc set. |
arc | the given normal arc; this must actually be an arc on the boundary of the given normal disc (although it may run in either direction). |
adjArc | returns the same directed normal arc that was passed, but expressed in terms of the vertices of the adjacent tetrahedron. Any value may be initially passed. If there is no adjacent disc/tetrahedron, this permutation will remain unchanged. |
unsigned long regina::DiscSetTet::arcFromDisc | ( | int | arcFace, |
int | arcVertex, | ||
int | discType, | ||
unsigned long | discNumber | ||
) | const |
Determines which normal arc of a given type on a given face of this tetrahedron corresponds to the given normal disc.
arcFace | the face of this tetrahedron containing the normal arc (between 0 and 3 inclusive). |
arcVertex | the vertex of this tetrahedron about which the normal arc runs (between 0 and 3 inclusive); arcFace and arcVertex should not be the same. |
discType | the disc type of the given normal disc; this should be between 0 and 9 inclusive, as described in the DiscSpec class notes. |
discNumber | indicates which normal disc of the given disc type is referred to (between 0 and nDiscs(discType)-1 inclusive). |
|
inline |
Returns an iterator at the beginning of the range of all normal discs in the underlying normal surface.
These begin() and end() routines allow you to iterate through all normal discs using C++11 range-based for
loops:
In Python, a DiscSetSurface can be treated as an iterable object, again iterating through all normal discs:
|
inline |
Retrieves a reference to the data corresponding to the given normal disc.
discType | the disc type of the given normal disc; this should be between 0 and 9 inclusive, as described in the DiscSpec class notes. |
discNumber | indicates which normal disc of the given disc type is referred to; this should be between 0 and nDiscs(discType)-1 inclusive. |
|
inline |
Retrieves a reference to the data corresponding to the given normal disc.
disc | the disc whose data we require; this must refer to a disc within this disc set. |
void regina::DiscSetTet::discFromArc | ( | int | arcFace, |
int | arcVertex, | ||
unsigned long | arcNumber, | ||
int & | discType, | ||
unsigned long & | discNumber | ||
) | const |
Determines which normal disc in this tetrahedron meets the given normal arc on the given face.
arcFace | the face of this tetrahedron containing the normal arc (between 0 and 3 inclusive). |
arcVertex | the vertex of this tetrahedron about which the normal arc runs (between 0 and 3 inclusive); arcFace and arcVertex should not be the same. |
arcNumber | indicates which normal arc of the given type is referred to. Arcs of a given type (where arcFace and arcVertex together define the arc type) are numbered starting at 0 from the tetrahedron vertex outwards. |
discType | returns the disc type of the normal disc that meets the given normal arc; this will be between 0 and 9 inclusive, as described in the DiscSpec class notes. Any value may be initially passed. |
discNumber | returns a number that indicates which normal disc of the returned disc type (discType ) meets the given normal arc; this will be between 0 and nDiscs(discType)-1 inclusive. Any value may be initially passed. |
bool regina::discOrientationFollowsEdge | ( | int | discType, |
int | vertex, | ||
int | edgeStart, | ||
int | edgeEnd | ||
) |
Determines whether or not the natural boundary orientation of a normal disc of the given type follows the given directed normal arc.
Natural boundary orientation is defined by arrays regina::triDiscArcs, regina::quadDiscArcs and regina::octDiscArcs.
discType | the normal disc type under consideration; this should be between 0 and 9 inclusive, as described by the DiscSpec class notes. |
vertex | the vertex about which the normal arc runs. |
edgeStart | the start vertex of the edge to which the normal arc is parallel. |
edgeEnd | the end vertex of the edge to which the normal arc is parallel. |
|
protected |
Creates a new disc set corresponding to the discs of the given normal surface.
The array of tetrahedron disc set pointers will be created but the DiscSetTet objects themselves will not be created.
This constructor should be called from constructors of subclasses who wish to use objects of a subclass of DiscSetTet, which this constructor allows them to create for themselves.
surface.triangulation()->size()
.surface | the normal surface whose discs we shall use. |
b | this parameter is ignored. |
regina::DiscSetSurface::DiscSetSurface | ( | const NormalSurface & | surface | ) |
Creates a new disc set corresponding to the discs of the given normal surface.
surface | the normal surface whose discs we shall use. |
|
inline |
Creates a new disc set corresponding to the discs of the given normal surface.
The data for each disc will remain uninitialised.
surface | the normal surface whose discs we shall use. |
|
inline |
Creates a new disc set corresponding to the discs of the given normal surface.
The data for each disc will be initialised to the given value.
surface | the normal surface whose discs we shall use. |
initValue | the value with which to initialise the data corresponding to each disc. |
regina::DiscSetTet::DiscSetTet | ( | const NormalSurface & | surface, |
size_t | tetIndex | ||
) |
Creates a new set of normal discs corresponding to the discs of the given normal surface that lie within the given tetrahedron.
surface | the normal surface whose discs we shall use. |
tetIndex | the index in the triangulation of the tetrahedron that our discs must lie in; this must be between 0 and tri.size()-1 inclusive, where tri is the triangulation containing the given normal surface. |
regina::DiscSetTet::DiscSetTet | ( | unsigned long | tri0, |
unsigned long | tri1, | ||
unsigned long | tri2, | ||
unsigned long | tri3, | ||
unsigned long | quad0, | ||
unsigned long | quad1, | ||
unsigned long | quad2, | ||
unsigned long | oct0 = 0 , |
||
unsigned long | oct1 = 0 , |
||
unsigned long | oct2 = 0 |
||
) |
Creates a new set of normal discs where the number of discs of each type is explicitly given.
tri0 | the number of triangular discs surrounding vertex 0. |
tri1 | the number of triangular discs surrounding vertex 1. |
tri2 | the number of triangular discs surrounding vertex 2. |
tri3 | the number of triangular discs surrounding vertex 3. |
quad0 | the number of quadrilateral discs of type 0. |
quad1 | the number of quadrilateral discs of type 1. |
quad2 | the number of quadrilateral discs of type 2. |
oct0 | the number of octahedral discs of type 0. |
oct1 | the number of octahedral discs of type 1. |
oct2 | the number of octahedral discs of type 2. |
|
inline |
Creates a new disc set corresponding to the discs of the given normal surface that lie within the given tetrahedron.
The data for each disc will remain uninitialised.
surface | the normal surface whose discs we shall use. |
tetIndex | the index in the triangulation of the tetrahedron that our discs must lie in; this must be between 0 and tri.size()-1 inclusive, where tri is the triangulation containing the given normal surface. |
|
inline |
Creates a new disc set corresponding to the discs of the given normal surface that lie within the given tetrahedron.
The data for each disc will be initialised to the given value.
surface | the normal surface whose discs we shall use. |
tetIndex | the index in the triangulation of the tetrahedron that our discs must lie in; this must be between 0 and tri.size()-1 inclusive, where tri is the triangulation containing the given normal surface. |
initValue | the value with which to initialise the data corresponding to each disc. |
|
inline |
Creates a new disc set where the number of discs of each type is explicitly given.
The data for each disc will remain uninitialised.
tri0 | the number of triangular discs surrounding vertex 0. |
tri1 | the number of triangular discs surrounding vertex 1. |
tri2 | the number of triangular discs surrounding vertex 2. |
tri3 | the number of triangular discs surrounding vertex 3. |
quad0 | the number of quadrilateral discs of type 0. |
quad1 | the number of quadrilateral discs of type 1. |
quad2 | the number of quadrilateral discs of type 2. |
oct0 | the number of octahedral discs of type 0. |
oct1 | the number of octahedral discs of type 1. |
oct2 | the number of octahedral discs of type 2. |
|
inline |
Creates a new uninitialised disc specifier.
|
inline |
Creates a new disc specifier containing the given values.
newTetIndex | the index in the triangulation of the tetrahedron containing the disc. |
newType | the disc type; this is between 0 and 9 inclusive, as described in the DiscSpec class notes. |
newNumber | specifies which disc of the particular type in the particular tetrahedron is being referred to; discs are numbered as described in the DiscSpec class notes. |
|
default |
Creates a new disc specifier that is a clone of the given specifier.
cloneMe | the disc specifier to clone. |
|
inline |
Creates a new uninitialised iterator.
This iterator cannot be used or queried until either init() or the assignmemnt operator is called.
|
inline |
Creates a new iterator pointing to the first disc in the given disc set.
discSet | the disc set used to initialise this iterator. |
|
default |
Default copy constructor.
|
inline |
Determines if this iterator is past-the-end.
true
if and only if this iterator is past-the-end.
|
inline |
Returns an iterator at the end of the range of all normal discs in the underlying normal surface.
In C++, the begin() and end() routines allow you to iterate through all normal discs using C++11 range-based for
loops. In Python, a DiscSetSurface can be treated as an iterable object.
See the begin() documentation for further details.
ReturnsTraits<FunctionObject>::ReturnType regina::forCoords | ( | NormalCoords | coords, |
FunctionObject && | func, | ||
typename ReturnsTraits< FunctionObject >::ReturnType | defaultReturn, | ||
Args &&... | args | ||
) |
Allows the user to call a template function whose template parameter matches a given value of NormalCoords, which is not known until runtime.
In essence, this routine contains a switch/case statement that runs through all possible coordinate sytems.
The advantages of this routine are that (i) the user does not need to repeatedly type such switch/case statements themselves; and (ii) if a new coordinate system is added then only a small amount of code needs to be extended to incorporate it.
This function can only work with coordinate systems in which you can create and store normal surfaces. All other coordinate systems are considered invalid for our purposes here.
In detail: the function object func must define a templated bracket operator, so that func.operator()<NormalInfo<c>>(...)
is defined for any valid NormalCoords enum value c. Then, when the user calls forCoords(coords, func, defaultReturn, ...)
, this routine will call func.operator()<NormalInfo<coords>>(...)
and pass back the corresponding return value. If coords does not denote a valid coordinate system as described above, then forCoords() will pass back defaultReturn instead.
There is also a variant of forCoords() that works with void functions, and so does not take the extra defaultReturn argument.
coords | the given normal coordinate system. |
func | the function object whose bracket operator we will call with a NormalInfo<coords> object. |
defaultReturn | the value to return if the given coordinate system is invalid. |
args | any additional arguments to pass to the bracket operator for func. These will be copied/moved, so if you wish to pass references then you may need to wrap them in std::ref or std::cref. |
ReturnsTraits<FunctionObject>::Void regina::forCoords | ( | NormalCoords | coords, |
FunctionObject && | func, | ||
Args &&... | args | ||
) |
Allows the user to call a template function whose template parameter matches a given value of NormalCoords, which is not known until runtime.
In essence, this routine contains a switch/case statement that runs through all possible coordinate sytems.
The advantages of this routine are that (i) the user does not need to repeatedly type such switch/case statements themselves; and (ii) if a new coordinate system is added then only a small amount of code needs to be extended to incorporate it.
This function can only work with coordinate systems in which you can create and store normal surfaces. All other coordinate systems are considered invalid for our purposes here.
In detail: the function object func must define a templated bracket operator, so that func.operator()<NormalInfo<c>>(...)
is defined for any valid NormalCoords enum value c. Then, when the user calls forCoords(coords, func, ...)
, this routine will call func.operator()<NormalInfo<coords>>(...)
in turn. If coords does not denote a valid coordinate system as described above, then forCoords() will do nothing.
There is also a variant of forCoords() that works with functions with return values, and which takes an extra defaultReturn argument.
coords | the given normal coordinate system. |
func | the function object whose bracket operator we will call with a NormalInfo<coords> object. |
args | any additional arguments to pass to the bracket operator for func. These will be copied/moved, so if you wish to pass references then you may need to wrap them in std::ref or std::cref. |
ReturnsTraits<FunctionObject>::Void
simply evaluates to void
. ReturnsTraits<FunctionObject>::ReturnType regina::forFilter | ( | SurfaceFilterType | filter, |
FunctionObject && | func, | ||
typename ReturnsTraits< FunctionObject >::ReturnType | defaultReturn, | ||
Args &&... | args | ||
) |
Allows the user to call a template function whose template parameter matches a given value of SurfaceFilterType, which is not known until runtime.
In essence, this routine contains a switch/case statement that runs through all possible normal surface filter types.
The advantages of this routine are that (i) the user does not need to repeatedly type such switch/case statements themselves; and (ii) if a new filter type is added then only a small amount of code needs to be extended to incorporate it.
In detail: the function object func must define a templated bracket operator, so that func.operator()<SurfaceFilterInfo<t>>(...)
is defined for any valid SurfaceFilterType enum value t. Then, when the user calls forFilter(filter, func, defaultReturn, ...)
, this routine will call func.operator()<SurfaceFilterInfo<filter>>(...)
and pass back the corresponding return value. If filter does not denote a valid filter type, then forFilter() will pass back defaultReturn instead.
There is also a variant of forFilter() that works with void functions, and so does not take the extra defaultReturn argument.
filter | the given type of normal surface filter. |
func | the function object whose bracket operator we will call with a SurfaceFilterInfo<filter> object. |
defaultReturn | the value to return if the given filter type is not valid. |
args | any additional arguments to pass to the bracket operator for func. These will be copied/moved, so if you wish to pass references then you may need to wrap then in std::ref or std::cref. |
ReturnsTraits<FunctionObject>::Void regina::forFilter | ( | SurfaceFilterType | filter, |
FunctionObject && | func, | ||
Args &&... | args | ||
) |
Allows the user to call a template function whose template parameter matches a given value of SurfaceFilterType, which is not known until runtime.
In essence, this routine contains a switch/case statement that runs through all possible normal surface filter types.
The advantages of this routine are that (i) the user does not need to repeatedly type such switch/case statements themselves; and (ii) if a new filter type is added then only a small amount of code needs to be extended to incorporate it.
In detail: the function object func must define a templated bracket operator, so that func.operator()<SurfaceFilterInfo<t>>(...)
is defined for any valid SurfaceFilterType enum value t. Then, when the user calls forFilter(filter, func, ...)
, this routine will call func.operator()<SurfaceFilterInfo<filter>>(...)
in turn. If filter does not denote a valid filter type, then forFilter() will do nothing.
There is also a variant of forFilter() that works with functions with return values, and which takes an extra defaultReturn argument.
filter | the given type of normal surface filter. |
func | the function object whose bracket operator we will call with a SurfaceFilterInfo<filter> object. |
args | any additional arguments to pass to the bracket operator for func. These will be copied/moved, so if you wish to pass references then you may need to wrap then in std::ref or std::cref. |
ReturnsTraits<FunctionObject>::Void
simply evaluates to void
.
|
inline |
Points this iterator to the first disc in the given disc set.
discSet | the disc set used to reinitialise this iterator. |
EnumConstraints* regina::makeEmbeddedConstraints | ( | const Triangulation< 3 > * | triangulation, |
NormalCoords | coords | ||
) |
Creates a new set of validity constraints representing the condition that normal surfaces be embedded.
The validity constraints will be expressed relative to the given coordinate system.
triangulation | the triangulation upon which these validity constraints will be based. |
coords | the coordinate system to be used. |
MatrixInt* regina::makeMatchingEquations | ( | const Triangulation< 3 > * | triangulation, |
NormalCoords | coords | ||
) |
Creates a new set of normal surface matching equations for the given triangulation using the given coordinate system.
The returned matrix will be newly allocated and its destruction will be the responsibility of the caller of this routine.
Each equation will be represented as a row of the matrix. Each column of the matrix represents a coordinate in the given coordinate system.
For some coordinate systems, Regina may not be able to create matching equations for all triangulations (these coordinate systems are explicitly mentioned as such in the NormalCoords enum documentation). If Regina cannot create the matching equations as requested, this routine will return null
instead.
triangulation | the triangulation upon which these matching equations will be based. |
coords | the coordinate system to be used. |
null
if Regina is not able to construct them for the given combination of triangulation and coordinate system. NormalSurfaceVector* regina::makeZeroVector | ( | const Triangulation< 3 > * | triangulation, |
NormalCoords | coords | ||
) |
Returns a new normal surface vector of the appropriate length for the given triangulation and the given coordinate system.
All elements of this vector will be initialised to zero.
The new vector will be of the subclass of NormalSurfaceVector corresponding to the given coordinate system. The caller of this routine is responsible for destroying the new vector.
triangulation | the triangulation upon which the underlying coordinate system is based. |
coords | the coordinate system to be used. |
|
inline |
Determines the number of discs of the given type inside this tetrahedron.
type | the disc type to examine; this should be between 0 and 9 inclusive. Disc types are outlined in the DiscSpec class notes. |
|
inline |
Determines the number of discs of the given type inside the given tetrahedron.
tetIndex | the index in the triangulation of the tetrahedron to examine. |
type | the disc type to examine; this should be between 0 and 9 inclusive. Disc types are outlined in the DiscSpec class notes. |
|
inline |
Returns the number of tetrahedra in the underlying triangulation.
bool regina::numberDiscsAwayFromVertex | ( | int | discType, |
int | vertex | ||
) |
Determines whether or not normal discs of the given type are numbered away from the given vertex.
discType | the normal disc type under consideration; this should be between 0 and 9 inclusive, as described by the DiscSpec class notes. |
vertex | the vertex under consideration; this should be between 0 and 3 inclusive. |
true
if normal discs of the given type are numbered away from the given vertex, or false
if they are numbered towards the given vertex.
|
inline |
Determines if this and the given disc specifier contain different information.
other | the disc specifier to compare with this. |
true
if and only if this and the given disc specifier contain different information.
|
inline |
Determines if this and the given iterator are different.
Two iterators are considered equal if (i) they were constructed from the same DiscSetSurface object (not two different DiscSetSurface objects with identical contents), and (ii) they point to the same disc of the same tetrahedron.
other | the iterator to compare with this. |
true
if and only if this and the given iterator are equal.
|
inline |
Returns a reference to the disc pointed to by this iterator.
|
inline |
Preincrement operator.
next()
, which either returns the current packet in the subtree and increments the iterator, or else throws a StopIteration
exception if the iterator is past-the-end.
|
inline |
Postincrement operator.
next()
, which either returns the current packet in the subtree and increments the iterator, or else throws a StopIteration
exception if the iterator is past-the-end.std::ostream& regina::operator<< | ( | std::ostream & | out, |
const PrismSpec & | spec | ||
) |
Writes the given prism specifier to the given output stream.
The prism specifier will be written as a pair (tetIndex, edge)
.
out | the output stream to which to write. |
spec | the prism specifier to write. |
|
inline |
Writes the given disc type to the given output stream.
The disc type will be written as a pair (tetIndex, type)
.
out | the output stream to which to write. |
type | the disc type to write. |
std::ostream& regina::operator<< | ( | std::ostream & | out, |
const DiscSpec & | spec | ||
) |
Writes the given disc specifier to the given output stream.
The disc specifier will be written as a triple (tetIndex, type, number)
.
out | the output stream to which to write. |
spec | the disc specifier to write. |
Copies the values from the given disc specifier into this specifier.
cloneMe | the disc specifier whose values should be copied. |
|
default |
Default copy assignment operator.
|
inline |
Determines if this and the given disc specifier contain identical information.
other | the disc specifier to compare with this. |
true
if and only if this and the given disc specifier contain identical information.
|
inline |
Determines if this and the given iterator are equal.
Two iterators are considered equal if (i) they were constructed from the same DiscSetSurface object (not two different DiscSetSurface objects with identical contents), and (ii) they point to the same disc of the same tetrahedron.
other | the iterator to compare with this. |
true
if and only if this and the given iterator are equal.
|
inline |
Returns the bitwise OR of the two given flags.
lhs | the first flag to combine. |
rhs | the second flag to combine. |
|
inline |
Returns the bitwise OR of the two given flags.
lhs | the first flag to combine. |
rhs | the second flag to combine. |
|
inline |
Returns the specific set of discs living inside the given tetrahedron.
tetIndex | the index in the triangulation of the given tetrahedron. |
|
virtual |
Destroys this set of discs and deallocates all associated memory.
|
inlinevirtual |
Destroys this disc set.
|
inlinevirtual |
Destroys this disc set and deallocates all data arrays.
Note that no assumption is made about type T
, so if data elements are pointers to dynamically allocated objects, these will not be destroyed.
|
protected |
The disc currently pointed to.
|
protected |
The disc sets corresponding to each tetrahedron.
|
protected |
Stores the data corresponding to each normal disc.
|
protected |
The disc set through which we are iterating.
|
protected |
The number of discs of each type.
unsigned long regina::DiscSpec::number |
Specifies which disc of the particular type in the particular tetrahedron is being referred to; discs are numbered as described in the DiscSpec class notes.
const Perm<4> regina::octDiscArcs[3][8] |
Lists in consecutive order the directed normal arcs that form the boundary of each type of octagonal normal disc.
Each permutation p represents an arc about vertex p[0]
parallel to the directed edge from p[1]
to p[2]
.
Array octDiscArcs[i]
lists the boundary arcs of the octagonal disc of type i. See NormalSurface::octs() for further details.
Note that permutation octDiscArcs[i][j]
will be even precisely when j
is 0, 1, 4 or 5.
octDiscArcs(discType, arcIndex)
that essentially looks up the corresponding array. This is necessary because of a bug in gcc 2.95. const int regina::quadDefn[3][4] |
Lists which vertices each quadrilateral type separates in a tetrahedron.
See regina::quadSeparating and NormalSurface::quads() for more information on quadrilateral types.
Quadrilateral type i
splits the vertex pairs quadDefn[i][0,1]
and quadDefn[i][2,3]
.
It is guaranteed that:
quadDefn[i][0] < quadDefn[i][1]
;quadDefn[i][2] < quadDefn[i][3]
;quadDefn[i][0] < quadDefn[i][2]
.This array contains similar information to the function Edge<3>::ordering(). Instead of quadDefn[i][j], you can call Edge<3>::ordering(i)[j]; this will give the same results for j = 0 and 1, but it might switch the results for j = 2 and 3.
const Perm<4> regina::quadDiscArcs[3][4] |
Lists in consecutive order the directed normal arcs that form the boundary of each type of quadrilateral normal disc.
Each permutation p represents an arc about vertex p[0]
parallel to the directed edge from p[1]
to p[2]
.
Array quadDiscArcs[i]
lists the boundary arcs of the quadrilateral disc of type i. See NormalSurface::quads() for further details.
Note that permutation quadDiscArcs[i][j]
will be even precisely when j
is even.
quadDiscArcs(discType, arcIndex)
that essentially looks up the corresponding array. This is necessary because of a bug in gcc 2.95. const int regina::quadMeeting[4][4][2] |
Lists which quadrilateral types meet which edges in a tetrahedron.
See regina::quadSeparating and NormalSurface::quads() for more information on quadrilateral types.
quadMeeting[i][j][0,1]
are the numbers of the two quadrilateral types that meet the edge joining tetrahedron vertices i
and j
.
const int regina::quadPartner[3][4] |
Lists the second vertex with which each vertex is paired under each quadrilateral type in a tetrahedron.
See regina::quadSeparating and NormalSurface::quads() for more information on quadrilateral types.
Quadrilateral type i
pairs vertex v
with vertex quadPartner[i][v]
.
const int regina::quadSeparating[4][4] |
Lists which quadrilateral types separate which pairs of vertices in a tetrahedron.
As outlined in NormalSurface::quads(), there are three quadrilateral types in a tetrahedron, numbered 0, 1 and 2. Each quadrilateral type separates the four tetrahedron vertices 0,1,2,3 into two pairs. quadSeparating[i][j]
is the number of the quadrilateral type that keeps vertices i
and j
together.
It is guaranteed that quadrilateral type i will keep the vertices of edge i together (and will therefore also keep the vertices of edge 5-i together).
const char regina::quadString[3][6] |
Contains strings that can be used to represent each quadrilateral type in a tetrahedron.
See regina::quadSeparating and NormalSurface::quads() for more information on quadrilateral types.
The string describing quadrilateral type i
is quadString[i]
and is of the form 02/13
, which in this case is the quadrilateral type that splits vertices 0,2 from vertices 1,3.
size_t regina::DiscSpec::tetIndex |
The index in the triangulation of the tetrahedron containing the disc.
|
protected |
The triangulation in which the normal surface lives.
const Perm<4> regina::triDiscArcs[4][3] |
Lists in consecutive order the directed normal arcs that form the boundary of each type of triangular normal disc.
Each permutation p represents an arc about vertex p[0]
parallel to the directed edge from p[1]
to p[2]
.
Array triDiscArcs[i]
lists the boundary arcs of the triangular disc of type i. See NormalSurface::triangles() for further details.
Note that every permutation in this array is even.
triDiscArcs(discType, arcIndex)
that essentially looks up the corresponding array. This is necessary because of a bug in gcc 2.95. int regina::DiscSpec::type |
The disc type; this is between 0 and 9 inclusive, as described in the DiscSpec class notes.
|
friend |
Writes the given disc specifier to the given output stream.
The disc specifier will be written as a triple (tetIndex, type, number)
.
out | the output stream to which to write. |
spec | the disc specifier to write. |