Regina Calculation Engine

Normal surfaces in 3manifold triangulations. More...
Classes  
struct  regina::NDiscSpec 
Specifies a single normal disc in a normal surface. More...  
class  regina::NDiscSetTet 
Represents a set of normal discs inside a single tetrahedron. More...  
class  regina::NDiscSetTetData< T > 
Stores data of type T for every normal disc inside a single tetrahedron. More...  
class  regina::NDiscSetSurface 
Represents the set of all normal discs forming a normal surface. More...  
class  regina::NDiscSetSurfaceData< T > 
Stores data of type T for every normal disc within a particular normal surface. More...  
class  regina::NDiscSpecIterator 
An iterator used for running through all normal discs in a normal surface. More...  
struct  regina::NDiscType 
Identifies a single normal or almost normal disc type within a triangulation. More...  
struct  regina::NormalInfo< coordType > 
A template that stores information about a particular normal coordinate system. More...  
class  regina::NNormalSurfaceVector 
Stores the vector of a single normal surface in a 3manifold. More...  
class  regina::NNormalSurface 
Represents a single normal surface in a 3manifold. More...  
struct  regina::PacketInfo< PACKET_NORMALSURFACELIST > 
Stores information about the normal surface list packet. More...  
class  regina::NNormalSurfaceList 
A packet representing a collection of normal surfaces in a 3manifold. More...  
struct  regina::NPrismSpec 
Specifies a single triangular prism in a tetrahedron. More...  
class  regina::NPrismSetSurface 
Represents the set of prisms defined by slicing along all the quads in a particular normal surface. More...  
struct  regina::NormalInfo< NS_AN_STANDARD > 
Stores information about standard almost normal coordinates. More...  
class  regina::NNormalSurfaceVectorANStandard 
An almost normal surface vector using standard trianglequadoct coordinates. More...  
class  regina::NNormalSurfaceVectorMirrored 
A normal surface vector that is mirrored in another coordinate system to avoid frequent lengthy calculations. More...  
struct  regina::NormalInfo< NS_ORIENTED > 
Stores information about transversely oriented standard normal coordinates. More...  
class  regina::NNormalSurfaceVectorOriented 
A normal surface vector using transversely oriented standard (trianglequad) coordinates. More...  
struct  regina::NormalInfo< NS_ORIENTED_QUAD > 
Stores information about transversely oriented quad normal coordinates. More...  
class  regina::NNormalSurfaceVectorOrientedQuad 
A normal surface vector using transversely oriented quadrilateral coordinates. More...  
struct  regina::NormalInfo< NS_QUAD > 
Stores information about quad normal coordinates. More...  
class  regina::NNormalSurfaceVectorQuad 
A normal surface vector using quad coordinates. More...  
struct  regina::NormalInfo< NS_AN_QUAD_OCT > 
Stores information about quadoct almost normal coordinates. More...  
class  regina::NNormalSurfaceVectorQuadOct 
An almost normal surface vector using quadoct coordinates. More...  
struct  regina::NormalInfo< NS_STANDARD > 
Stores information about standard normal coordinates. More...  
class  regina::NNormalSurfaceVectorStandard 
A normal surface vector using standard trianglequad coordinates. More...  
struct  regina::SurfaceFilterInfo< filterType > 
A template that stores information about a particular type of normal surface filter. More...  
struct  regina::PacketInfo< PACKET_SURFACEFILTER > 
Stores information about the normal surface filter packet type. More...  
struct  regina::SurfaceFilterInfo< NS_FILTER_DEFAULT > 
Stores information about the default acceptall surface filter. More...  
class  regina::NSurfaceFilter 
A packet that accepts or rejects normal surfaces. More...  
class  regina::NSurfaceSubset 
Represents a subset of a normal surface list. More...  
class  regina::NXMLFilterReader 
An XML element reader that reads the specific details of a normal surface filter. More...  
class  regina::NXMLFilterPacketReader 
An XML packet reader that reads a single surface filter. More...  
class  regina::NXMLNormalSurfaceReader 
An XML element reader that reads a single normal surface. More...  
class  regina::NXMLNormalSurfaceListReader 
An XML packet reader that reads a single normal surface list. More...  
struct  regina::SurfaceFilterInfo< NS_FILTER_COMBINATION > 
Stores information about the combination surface filter. More...  
class  regina::NSurfaceFilterCombination 
A normal surface filter that simply combines other filters. More...  
struct  regina::SurfaceFilterInfo< NS_FILTER_PROPERTIES > 
Stores information about the propertybased surface filter. More...  
class  regina::NSurfaceFilterProperties 
A normal surface filter that filters by basic properties of the normal surface. More...  
Macros  
#define  REGINA_NORMAL_SURFACE_FLAVOUR(class_, id) 
Defines various constants, types and virtual functions for a subclass of NNormalSurfaceVector. More...  
#define  REGINA_SURFACE_FILTER(class_, id) 
Defines various constants, types and virtual functions for a descendant class of NSurfaceFilter. More...  
Typedefs  
typedef NewFunction1 < NNormalSurfaceVector, size_t >  regina::NewNormalSurfaceVector 
A legacy typedef provided for backward compatibility only. 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...  
Functions  
template<typename FunctionObject >  
FunctionObject::ReturnType  regina::forCoords (NormalCoords coords, FunctionObject func, typename FunctionObject::ReturnType defaultReturn) 
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 VoidFunctionObject >  
void  regina::forCoords (NormalCoords coords, VoidFunctionObject func) 
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 >  
FunctionObject::ReturnType  regina::forFlavour (NormalCoords coords, FunctionObject func, typename FunctionObject::ReturnType defaultReturn) 
A deprecated alias for the registrybased template function forCoords(). More...  
template<typename VoidFunctionObject >  
void  regina::forFlavour (NormalCoords coords, VoidFunctionObject func) 
A deprecated alias for the registrybased template function forCoords(). More...  
template<typename FunctionObject >  
FunctionObject::ReturnType  regina::forFilter (SurfaceFilterType filter, FunctionObject func, typename FunctionObject::ReturnType defaultReturn) 
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 VoidFunctionObject >  
void  regina::forFilter (SurfaceFilterType filter, VoidFunctionObject func) 
Allows the user to call a template function whose template parameter matches a given value of SurfaceFilterType, which is not known until runtime. More...  
REGINA_API std::ostream &  regina::operator<< (std::ostream &out, const NDiscSpec &spec) 
Writes the given disc specifier to the given output stream. More...  
REGINA_API 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...  
REGINA_API 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_API std::ostream &  regina::operator<< (std::ostream &out, const NDiscType &type) 
Writes the given disc type to the given output stream. More...  
REGINA_API NNormalSurfaceVector *  regina::makeZeroVector (const NTriangulation *triangulation, NormalCoords coords) 
Returns a new normal surface vector of the appropriate length for the given triangulation and the given coordinate system. More...  
REGINA_API NMatrixInt *  regina::makeMatchingEquations (const NTriangulation *triangulation, NormalCoords coords) 
Creates a new set of normal surface matching equations for the given triangulation using the given coordinate system. More...  
REGINA_API NEnumConstraintList *  regina::makeEmbeddedConstraints (const NTriangulation *triangulation, NormalCoords coords) 
Creates a new set of validity constraints representing the condition that normal surfaces be embedded. 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...  
REGINA_API std::ostream &  regina::operator<< (std::ostream &out, const NPrismSpec &spec) 
Writes the given prism specifier to the given output stream. More...  
Variables  
REGINA_API const int  regina::vertexSplit [4][4] 
Lists which vertex splits separate which pairs of vertices. More...  
REGINA_API const int  regina::vertexSplitMeeting [4][4][2] 
Lists which vertex splits meet which edges. More...  
REGINA_API const int  regina::vertexSplitDefn [3][4] 
Lists the vertices which each vertex split splits. More...  
REGINA_API const int  regina::vertexSplitPartner [3][4] 
Lists the second vertex with which each vertex is paired under each vertex split. More...  
REGINA_API const char  regina::vertexSplitString [3][6] 
Contains strings describing which vertices each vertex split splits. More...  
REGINA_API const NPerm4  regina::triDiscArcs [4][3] 
Lists in consecutive order the directed normal arcs that form the boundary of each type of triangular normal disc. More...  
REGINA_API const NPerm4  regina::quadDiscArcs [3][4] 
Lists in consecutive order the directed normal arcs that form the boundary of each type of quadrilateral normal disc. More...  
REGINA_API const NPerm4  regina::octDiscArcs [3][8] 
Lists in consecutive order the directed normal arcs that form the boundary of each type of octagonal normal disc. More...  
Normal surfaces in 3manifold triangulations.
#define REGINA_NORMAL_SURFACE_FLAVOUR  (  class_,  
id  
) 
Defines various constants, types and virtual functions for a subclass of NNormalSurfaceVector.
Every subclass of NNormalSurfaceVector 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 NNormalSurfaceVector. 
id  the corresponding NNormalCoords constant. 
#define REGINA_SURFACE_FILTER  (  class_,  
id  
) 
Defines various constants, types and virtual functions for a descendant class of NSurfaceFilter.
Every descendant class of NSurfaceFilter 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 NSurfaceFilter. 
id  the corresponding SurfaceFilterType constant. 
typedef NewFunction1<NNormalSurfaceVector, size_t> regina::NewNormalSurfaceVector 
A legacy typedef provided for backward compatibility only.
typedef regina::Flags<NormalAlgFlags> regina::NormalAlg 
A combination of flags for types of normal surface lists.
typedef regina::Flags<NormalListFlags> regina::NormalList 
A combination of flags for types of normal surface lists.
Represents options and variants of algorithms for enumerating various types of normal surfaces.
These options are typically combined in a bitwise fashion using the NormalAlgs type, and then passed to enumeration routines such as NNormalSurfaceList::vertex().
enum regina::NormalCoords 
Represents different coordinate systems that can be used for enumerating and displaying normal surfaces.
IDs 09999 are reserved for future use by Regina. If you are extending Regina to include your own coordinate system, you should choose an ID >= 10000.
Enumerator  

NS_STANDARD 
Represents standard trianglequadrilateral coordinates for normal surfaces. 
NS_QUAD 
Represents quadrilateral coordinates for normal surfaces. For details, see "Normal surface Qtheory", Jeffrey L. Tollefson, Pacific J. Math. 183 (1998), no. 2, 359–374. 
NS_AN_LEGACY 
Indicates that a list of almost normal surfaces was created using Regina 4.5.1 or earlier, where surfaces with more than one octagon of the same type were stripped out of the final solution set. As of Regina 4.6 such surfaces are now included in the solution set, since we need them if we wish to enumerate all almost normal surfaces (not just the vertex almost normal surfaces). This coordinate system is only used with legacy data files; new vectors and lists cannot be created in this coordinate system. The underlying coordinates are identical to those of NS_AN_STANDARD. 
NS_AN_QUAD_OCT 
Represents quadrilateraloctagon coordinates for octagonal almost normal surfaces. For details, see "Quadrilateraloctagon coordinates for almost normal surfaces", Benjamin A. Burton, Experiment. Math. 19 (2010), 285315. 
NS_AN_STANDARD 
Represents standard trianglequadrilateraloctagon coordinates for octagonal almost normal surfaces. 
NS_EDGE_WEIGHT 
Represents edge weight coordinates for normal surfaces. This coordinate system is for display only; surface vectors and lists cannot be created in this coordinate system. 
NS_TRIANGLE_ARCS 
Represents triangle arc coordinates for normal surfaces. This coordinate system is for display only; surface vectors and lists cannot be created in this coordinate system. 
NS_FACE_ARCS 
A deprecated alias for NS_TRIANGLE_ARCS. This represents triangle arc coordinates for normal surfaces. See NS_TRIANGLE_ARCS for further details.

NS_ORIENTED 
Represents standard trianglequadrilateral coordinates for transversely oriented normal surfaces. 
NS_ORIENTED_QUAD 
Represents quadrilateral coordinates for transversely oriented normal surfaces. 
NS_ANGLE 
Represents angle structure coordinates. This coordinate system is not for use with normal surfaces: it cannot be used either to display them or enumerate them. Instead it is for use with angle structures on triangulations. Because the combinatorics and linear algebra of angle strutures are tightly related to those of normal surfaces, we include NS_ANGLE here so that angle structure routines can make use of some of Regina's existing normal surface machinery. For a triangulation with n tetrahedra, this system has 3n+1 coordinates. The first 3n are analogous to quadrilateral coordinates (specifically, for each quadrilateral type Q, the corresponding angle structure coordinate represents the pair of angles in the same tetrahedron that Q does not meet). The final coordinate is a scaling coordinate, used to projectivise the angle structure polytope so that it becomes a polyhedral cone that is invariant under (positive) scaling. If the final scaling coordinate is s, then a rational value of x in any other coordinate position should be interpreted as the angle x.π/s.

Represents different lists of normal surfaces that might be constructed for a given 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 NNormalSurfaceList::saveCSVStandard() or NNormalSurfaceList::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 userassigned 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 onesided or twosided. 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 spunnormal 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 NNormalSurface::boundaryIntersections() for further information on interpreting these values. 
surfaceExportLink 
Represents whether a surface is a single vertex link or a thin edge link. See NNormalSurface::isVertexLink() and NNormalSurface::isThinEdgeLink() for details. This will be written as a humanreadable string. 
surfaceExportType 
Represents any additional highlevel properties of a surface, such as whether it is a splitting surface or a central surface. This will be written as a humanreadable 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 userassigned 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 userassigned 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 3manifold triangulations.
IDs 09999 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 NSurfaceFilter class: a donothing filter that accepts any normal surface. 
NS_FILTER_PROPERTIES 
Represents the NSurfaceFilterProperties subclass: a filter that examines simple properties of a normal surface. 
NS_FILTER_COMBINATION 
Represents the NSurfaceFilterCombination subclass: a filter that combines other filters using boolean AND or OR. 
REGINA_API 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 NDiscSpec 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. 
FunctionObject::ReturnType regina::forCoords  (  NormalCoords  coords, 
FunctionObject  func,  
typename FunctionObject::ReturnType  defaultReturn  
) 
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 unary bracket operator, so that func(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(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 twoargument variant of forCoords() that works with void functions.
coords  the given normal coordinate system. 
func  the function object whose unary bracket operator we will call with a NormalInfo<coords> object. 
defaultReturn  the value to return if the given coordinate system is invalid. 
void regina::forCoords  (  NormalCoords  coords, 
VoidFunctionObject  func  
) 
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 unary bracket operator, so that func(NormalInfo<c>)
is defined for any valid NormalCoords enum value c. Then, when the user calls forCoords(coords, func)
, this routine will call func(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 threeargument variant of forCoords() that works with functions with return values.
coords  the given normal coordinate system. 
func  the function object whose unary bracket operator we will call with a NormalInfo<coords> object. 
FunctionObject::ReturnType regina::forFilter  (  SurfaceFilterType  filter, 
FunctionObject  func,  
typename FunctionObject::ReturnType  defaultReturn  
) 
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 unary bracket operator, so that func(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(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 twoargument variant of forFilter() that works with void functions.
filter  the given type of normal surface filter. 
func  the function object whose unary bracket operator we will call with a SurfaceFilterInfo<filter> object. 
defaultReturn  the value to return if the given filter type is not valid. 
void regina::forFilter  (  SurfaceFilterType  filter, 
VoidFunctionObject  func  
) 
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 unary bracket operator, so that func(SurfaceFilterInfo<t>)
is defined for any valid SurfaceFilterType enum value t. Then, when the user calls forFilter(filter, func)
, this routine will call func(SurfaceFilterInfo<filter>)
in turn. If filter does not denote a valid filter type, then forFilter() will do nothing.
There is also a threeargument variant of forFilter() that works with functions with return values.
filter  the given type of normal surface filter. 
func  the function object whose unary bracket operator we will call with a SurfaceFilterInfo<filter> object. 

inline 
A deprecated alias for the registrybased template function forCoords().
See forCoords() for further details.

inline 
A deprecated alias for the registrybased template function forCoords().
See forCoords() for further details.
REGINA_API NEnumConstraintList* regina::makeEmbeddedConstraints  (  const NTriangulation *  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. 
REGINA_API NMatrixInt* regina::makeMatchingEquations  (  const NTriangulation *  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.
triangulation  the triangulation upon which these matching equations will be based. 
coords  the coordinate system to be used. 
REGINA_API NNormalSurfaceVector* regina::makeZeroVector  (  const NTriangulation *  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 NNormalSurfaceVector 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. 
REGINA_API 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 NDiscSpec 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. REGINA_API std::ostream& regina::operator<<  (  std::ostream &  out, 
const NPrismSpec &  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. 
REGINA_API std::ostream& regina::operator<<  (  std::ostream &  out, 
const NDiscSpec &  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. 

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. 

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. 
REGINA_API const NPerm4 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 NNormalSurface::getOctCoord() 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. REGINA_API const NPerm4 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 NNormalSurface::getQuadCoord() 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. REGINA_API const NPerm4 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 NNormalSurface::getTriangleCoord() 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. REGINA_API const int regina::vertexSplit[4][4] 
Lists which vertex splits separate which pairs of vertices.
There are three vertex splits, numbered 0,1,2. Each vertex split separates the four tetrahedron vertices 0,1,2,3 into two pairs. vertexSplit[i][j]
is the number of the vertex split that keeps vertices i
and j
together.
It is guaranteed that vertex split i will keep the vertices of edge i together (and will therefore also keep the vertices of edge 5i together).
REGINA_API const int regina::vertexSplitDefn[3][4] 
Lists the vertices which each vertex split splits.
See regina::vertexSplit for details on what a vertex split is. Vertex split number i
splits the vertex pairs vertexSplitDefn[i][0,1]
and vertexSplitDefn[i][2,3]
.
It is guaranteed that:
vertexSplitDefn[i][0] < vertexSplitDefn[i][1]
;vertexSplitDefn[i][2] < vertexSplitDefn[i][3]
;vertexSplitDefn[i][0] < vertexSplitDefn[i][2]
. REGINA_API const int regina::vertexSplitMeeting[4][4][2] 
Lists which vertex splits meet which edges.
See regina::vertexSplit for details on what a vertex split is. vertexSplitMeeting[i][j][0,1]
are the numbers of the two vertex splits that meet the edge joining tetrahedron vertices i
and j
.
REGINA_API const int regina::vertexSplitPartner[3][4] 
Lists the second vertex with which each vertex is paired under each vertex split.
See regina::vertexSplit for details on what a vertex split is. Vertex split number i
pairs vertex v
with vertex vertexSplitPartner[i][v]
.
REGINA_API const char regina::vertexSplitString[3][6] 
Contains strings describing which vertices each vertex split splits.
See regina::vertexSplit for details on what a vertex split is. The string describing vertex split number i
is vertexSplitString[i]
and is of the form 02/13
, which in this case is the vertex split that splits vertices 0,2 from vertices 1,3.