Regina Calculation Engine
Classes | Macros | Typedefs | Enumerations | Functions | Variables | Friends
Normal Surfaces

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::DiscSpecstd::iterator_traits< regina::DiscSpecIterator >::value_type
 
typedef const regina::DiscSpecstd::iterator_traits< regina::DiscSpecIterator >::pointer
 
typedef const regina::DiscSpecstd::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< NormalListFlagsregina::NormalList
 
A combination of flags for types of normal surface lists. More...
 
typedef regina::Flags< NormalAlgFlagsregina::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...
 

Enumerations

enum  regina::NormalCoords {
  regina::NS_STANDARD = 0, regina::NS_QUAD = 1, regina::NS_QUAD_CLOSED = 10, regina::NS_AN_LEGACY = 100,
  regina::NS_AN_QUAD_OCT = 101, regina::NS_AN_STANDARD = 102, regina::NS_AN_QUAD_OCT_CLOSED = 110, regina::NS_EDGE_WEIGHT = 200,
  regina::NS_TRIANGLE_ARCS = 201, regina::NS_ORIENTED = 300, regina::NS_ORIENTED_QUAD = 301, regina::NS_ANGLE = 400
}
 Represents different coordinate systems that can be used for enumerating and displaying normal surfaces. More...
 
enum  regina::NormalListFlags {
  regina::NS_LIST_DEFAULT = 0x0000, regina::NS_EMBEDDED_ONLY = 0x0001, regina::NS_IMMERSED_SINGULAR = 0x0002, regina::NS_VERTEX = 0x0004,
  regina::NS_FUNDAMENTAL = 0x0008, regina::NS_LEGACY = 0x4000, regina::NS_CUSTOM = 0x8000
}
 
Represents different lists of normal surfaces that might be constructed for a given 3-manifold triangulation. More...
 
enum  regina::NormalAlgFlags {
  regina::NS_ALG_DEFAULT = 0x0000, regina::NS_VERTEX_VIA_REDUCED = 0x0001, regina::NS_VERTEX_STD_DIRECT = 0x0002, regina::NS_VERTEX_TREE = 0x0010,
  regina::NS_VERTEX_DD = 0x0020, regina::NS_HILBERT_PRIMAL = 0x0100, regina::NS_HILBERT_DUAL = 0x0200, regina::NS_HILBERT_CD = 0x0400,
  regina::NS_HILBERT_FULLCONE = 0x0800, regina::NS_ALG_LEGACY = 0x4000, regina::NS_ALG_CUSTOM = 0x8000
}
 
Represents options and variants of algorithms for enumerating various types of normal surfaces in 3-manifold triangulations. More...
 
enum  regina::SurfaceExportFields {
  regina::surfaceExportName = 0x0001, regina::surfaceExportEuler = 0x0002, regina::surfaceExportOrient = 0x0004, regina::surfaceExportSides = 0x0008,
  regina::surfaceExportBdry = 0x0010, regina::surfaceExportLink = 0x0020, regina::surfaceExportType = 0x0040, regina::surfaceExportNone = 0,
  regina::surfaceExportAllButName = 0x007e, regina::surfaceExportAll = 0x007f
}
 Used to describe a field, or a set of fields, that can be exported alongside a normal surface list. More...
 
enum  regina::SurfaceFilterType { regina::NS_FILTER_DEFAULT = 0, regina::NS_FILTER_PROPERTIES = 1, regina::NS_FILTER_COMBINATION = 2 }
 Represents different types of filter classes that can be used to filter lists of normal surfaces in 3-manifold triangulations. 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...
 
DiscSpecregina::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
 
DiscSetTetregina::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
 
DiscSetTetDataregina::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...
 
DiscSetTetregina::DiscSetSurface::tetDiscs (size_t tetIndex) const
 Returns the specific set of discs living inside the given tetrahedron. More...
 
DiscSpecregina::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
 
DiscSetSurfaceregina::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
 
DiscSetSurfaceDataregina::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...
 
DiscSpecIteratorregina::DiscSpecIterator::operator= (const DiscSpecIterator &)=default
 Default copy assignment operator. More...
 
DiscSpecIteratorregina::DiscSpecIterator::operator++ ()
 
Preincrement operator. More...
 
DiscSpecIterator regina::DiscSpecIterator::operator++ (int)
 
Postincrement operator. More...
 
const DiscSpecregina::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...
 
NormalSurfaceVectorregina::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...
 
MatrixIntregina::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...
 
EnumConstraintsregina::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 DiscSetSurfaceregina::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...
 

Detailed Description

Normal surfaces in 3-manifold triangulations.

Macro Definition Documentation

◆ REGINA_NORMAL_SURFACE_FLAVOUR

#define REGINA_NORMAL_SURFACE_FLAVOUR (   class_,
  id,
  superclass 
)
Value:
public: \
typedef NormalInfo<id> Info; \
static constexpr const NormalCoords coordsID = id; \
inline class_(const class_& cloneMe) : \
superclass(cloneMe.coords()) {} \
inline virtual NormalSurfaceVector* clone() const override { \
return new class_(*this); \
} \
inline virtual bool allowsAlmostNormal() const override { \
return Info::almostNormal; \
} \
inline virtual bool allowsSpun() const override { \
return Info::spun; \
} \
inline virtual bool allowsOriented() const override { \
return Info::oriented; \
}
NormalCoords
Represents different coordinate systems that can be used for enumerating and displaying normal surfac...
Definition: normalcoords.h:59

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:

  • a compile-time constant coordsID that is equal to the corresponding NormalCoords constant;
  • a typedef Info, which refers to the corresponding specialisation of the NormalInfo<> template;
  • a copy constructor that takes a vector of the same subclass;
  • declarations and implementations of the virtual functions NormalSurfaceVector::clone(), NormalSurfaceVector::allowsAlmostNormal(), NormalSurfaceVector::allowsSpun(), and NormalSurfaceVector::allowsOriented().
Parameters
class_the name of this subclass of NormalSurfaceVector.
idthe corresponding NNormalCoords constant.
superclassthe vector class from which class_ is derived. This is typically NormalSurfaceVector, though in some cases it may be different (e.g., NSVectorMirrored).

◆ REGINA_SURFACE_FILTER

#define REGINA_SURFACE_FILTER (   class_,
  id 
)
Value:
public: \
static constexpr const SurfaceFilterType filterTypeID = id; \
inline virtual SurfaceFilterType filterType() const override { \
return id; \
} \
inline virtual std::string filterTypeName() const override { \
return SurfaceFilterInfo<id>::name(); \
}
SurfaceFilterType
Represents different types of filter classes that can be used to filter lists of normal surfaces in 3...
Definition: surfacefiltertype.h:58

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:

  • a compile-time constant filterTypeID, which is equal to the corresponding SurfaceFilterType constant;
  • declarations and implementations of the virtual functions SurfaceFilter::filterType() and SurfaceFilter::filterTypeName();
Parameters
class_the name of this descendant class of SurfaceFilter.
idthe corresponding SurfaceFilterType constant.

Typedef Documentation

◆ DataPtr

template<class T >
typedef T* regina::DiscSetTetData< T >::DataPtr

A type that is a pointer to the data stored with each disc.

◆ NDiscSetSurface

Deprecated typedef for backward compatibility.

This typedef will be removed in a future release of Regina.

Deprecated:
The class NDiscSetSurface has now been renamed to DiscSetSurface.

◆ NDiscSetSurfaceData

template<class T >
using regina::NDiscSetSurfaceData = typedef DiscSetSurfaceData<T>

Deprecated typedef for backward compatibility.

This typedef will be removed in a future release of Regina.

Deprecated:
The class NDiscSetSurfaceData has now been renamed to DiscSetSurfaceData.

◆ NDiscSetTet

Deprecated typedef for backward compatibility.

This typedef will be removed in a future release of Regina.

Deprecated:
The class NDiscSetTet has now been renamed to DiscSetTet.

◆ NDiscSetTetData

template<class T >
using regina::NDiscSetTetData = typedef DiscSetTetData<T>

Deprecated typedef for backward compatibility.

This typedef will be removed in a future release of Regina.

Deprecated:
The class NDiscSetTetData has now been renamed to DiscSetTetData.

◆ NDiscSpec

Deprecated typedef for backward compatibility.

This typedef will be removed in a future release of Regina.

Deprecated:
The class NDiscSpec has now been renamed to DiscSpec.

◆ NDiscType

Deprecated typedef for backward compatibility.

This typedef will be removed in a future release of Regina.

Deprecated:
The class NDiscType has now been renamed to DiscType.

◆ NNormalSurface

Deprecated typedef for backward compatibility.

This typedef will be removed in a future release of Regina.

Deprecated:
The class NNormalSurface has now been renamed to NormalSurface.

◆ NNormalSurfaceList

Deprecated typedef for backward compatibility.

This typedef will be removed in a future release of Regina.

Deprecated:
The class NNormalSurfaceList has now been renamed to NormalSurfaces.

◆ NNormalSurfaceVector

Deprecated typedef for backward compatibility.

This typedef will be removed in a future release of Regina.

Deprecated:
The class NNormalSurfaceVector has now been renamed to NormalSurfaceVector.

◆ NNormalSurfaceVectorANStandard

Deprecated typedef for backward compatibility.

This typedef will be removed in a future release of Regina.

Deprecated:
The class NNormalSurfaceVectorANStandard has now been renamed to NSVectorANStandard.

◆ NNormalSurfaceVectorMirrored

Deprecated typedef for backward compatibility.

This typedef will be removed in a future release of Regina.

Deprecated:
The class NNormalSurfaceVectorMirrored has now been renamed to NSVectorMirrored.

◆ NNormalSurfaceVectorOriented

Deprecated typedef for backward compatibility.

This typedef will be removed in a future release of Regina.

Deprecated:
The class NNormalSurfaceVectorOriented has now been renamed to NSVectorOriented.

◆ NNormalSurfaceVectorOrientedQuad

Deprecated typedef for backward compatibility.

This typedef will be removed in a future release of Regina.

Deprecated:
The class NNormalSurfaceVectorOrientedQuad has now been renamed to NSVectorOrientedQuad.

◆ NNormalSurfaceVectorQuad

Deprecated typedef for backward compatibility.

This typedef will be removed in a future release of Regina.

Deprecated:
The class NNormalSurfaceVectorQuad has now been renamed to NSVectorQuad.

◆ NNormalSurfaceVectorQuadOct

Deprecated typedef for backward compatibility.

This typedef will be removed in a future release of Regina.

Deprecated:
The class NNormalSurfaceVectorQuadOct has now been renamed to NSVectorQuadOct.

◆ NNormalSurfaceVectorStandard

Deprecated typedef for backward compatibility.

This typedef will be removed in a future release of Regina.

Deprecated:
The class NNormalSurfaceVectorStandard has now been renamed to NSVectorStandard.

◆ NormalAlg


A combination of flags for types of normal surface lists.

Python
This is present, and all values in the NormalAlgFlags enumeration type are treated as members of this NormalAlg class.

◆ NormalList


A combination of flags for types of normal surface lists.

Python
This is present, and all values in the NormalListFlags enumeration type are treated as members of this NormalList class.

◆ NPrismSpec

Deprecated typedef for backward compatibility.

This typedef will be removed in a future release of Regina.

Deprecated:
The class NPrismSpec has now been renamed to PrismSpec.

◆ NSurfaceFilter

Deprecated typedef for backward compatibility.

This typedef will be removed in a future release of Regina.

Deprecated:
The class NSurfaceFilter has now been renamed to SurfaceFilter.

◆ NSurfaceFilterCombination

Deprecated typedef for backward compatibility.

This typedef will be removed in a future release of Regina.

Deprecated:
The class NSurfaceFilterCombination has now been renamed to SurfaceFilterCombination.

◆ NSurfaceFilterProperties

Deprecated typedef for backward compatibility.

This typedef will be removed in a future release of Regina.

Deprecated:
The class NSurfaceFilterProperties has now been renamed to SurfaceFilterProperties.

Enumeration Type Documentation

◆ NormalAlgFlags


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().

Python
The values in this enumeration type are present, but they are treated by Python as NormalList objects (and they can be combined and/or queried as such). The underlying enumeration type is not exposed to Python.
Enumerator
NS_ALG_DEFAULT 

An empty flag, indicating to an enumeration routine that it should use its default behaviour.

The numeric value of this flag is zero (i.e., it has no effect when combined with other flags using bitwise OR).

NS_VERTEX_VIA_REDUCED 

When enumerating in standard normal or almost normal coordinates, this flag indicates that the algorithm should first enumerate in quadrilateral or quadrilateral-octagon coordinates, and then expand this "reduced" solution set to the (typically larger) "standard" solution set.

This is typically much faster than a direct enumeration in standard normal or almost normal coordinates, and enumeration routines will use this option where possible unless explicitly requested not to (via the flag NS_VERTEX_STD_DIRECT).

For an explanation of this procedure, see B. A. Burton, "Converting between quadrilateral and standard solution sets in normal surface theory", Algebr. Geom. Topol. 9 (2009), 2121-2174.

This flag is incompatible with NS_VERTEX_STD_DIRECT.

NS_VERTEX_STD_DIRECT 

When enumerating in standard normal or almost normal coordinates, this flag indicates that the algorithm should work directly in that coordinate system, and should not go via the "reduced" (quadrilateral or quadrilateral-octagon) coordinate system.

This is typically much slower than going via the reduced system, and users should only request this if they have a specialised need. See NS_VERTEX_VIA_REDUCED for further information.

This flag is incompatible with NS_VERTEX_VIA_REDUCED.

NS_VERTEX_TREE 

When enumerating vertex normal surfaces, this flag indicates that the tree traversal algorithm should be used.

This algorithm is based on linear and integer programming techniques, and has many desirable properties including a relatively low overhead. Enumeration algorithms will use it if possible unless a different method is explicitly requested.

For details on the tree traversal algorithm, see B. A. Burton and M. Ozlen, "A tree traversal algorithm for decision problems in knot theory and 3-manifold topology", Algorithmica 65 (2013), pp. 772-801.

This flag is incompatible with NS_VERTEX_DD.

NS_VERTEX_DD 

When enumerating vertex normal surfaces, this flag indicates that a modified double description method should be used.

This algorithm can suffer from a combinatorial explosion with larger problems, leading to extremely large time and memory footprints. Users should only request this if they have some specialised need.

For details on the modified double description method, see B. A. Burton, "Optimizing the double description method for normal surface enumeration", Mathematics of Computation 79 (2010), pp. 453-484.

This flag is incompatible with NS_VERTEX_TREE.

NS_HILBERT_PRIMAL 

When enumerating fundamental normal surfaces, this flag indicates that the primal method should be used for enumerating a Hilbert basis.

The primal method is recommended, and enumeration algorithms will use it if possible unless a different method is explicitly requested. This method uses code from Normaliz for parts of its processing.

For details and comparisons of the various options for enumerating fundamental normal surfaces, see B. A. Burton, "Enumerating fundamental normal surfaces: Algorithms, experiments and invariants", ALENEX 2014: Proceedings of the Meeting on Algorithm Engineering & Experiments, SIAM, 2014, pp. 112-124.

This flag is incompatible with NS_HILBERT_DUAL, NS_HILBERT_CD and NS_HILBERT_FULLCONE.

NS_HILBERT_DUAL 

When enumerating fundamental normal surfaces, this flag indicates that the dual method should be used for enumerating a Hilbert basis.

The dual method is fast (like the primal method), but its performance is highly variable; for this reason the primal method is recommended instead. This method does not make use of Normaliz, and is the recommended method for situations in which Normaliz is not available for some reason.

For details and comparisons of the various options for enumerating fundamental normal surfaces, see B. A. Burton, "Enumerating fundamental normal surfaces: Algorithms, experiments and invariants", ALENEX 2014: Proceedings of the Meeting on Algorithm Engineering & Experiments, SIAM, 2014, pp. 112-124.

This flag is incompatible with NS_HILBERT_PRIMAL, NS_HILBERT_CD and NS_HILBERT_FULLCONE.

NS_HILBERT_CD 

When enumerating fundamental normal surfaces, this flag indicates that a modified Contejean-Devie procedure should be used for enumerating a Hilbert basis.

The Contejean-Devie procedure is typically much slower than either the primal or dual method, and users should only request it if they have some specialised need.

For details and comparisons of the various options for enumerating fundamental normal surfaces, see B. A. Burton, "Enumerating fundamental normal surfaces: Algorithms, experiments and invariants", ALENEX 2014: Proceedings of the Meeting on Algorithm Engineering & Experiments, SIAM, 2014, pp. 112-124.

This flag is incompatible with NS_HILBERT_PRIMAL, NS_HILBERT_DUAL and NS_HILBERT_FULLCONE.

NS_HILBERT_FULLCONE 

When enumerating fundamental normal surfaces, this flag indicates that a Hilbert basis for the full solution cone should be constructed, and additional combinatorial constraints (such as the quadrilateral constraints) should only be enforced as the final step.

If you are only enumerating properly embedded surfaces then this procedure extremely slow, and users should only request it if they have some specialised need.

For details and comparisons of the various options for enumerating fundamental normal surfaces, see B. A. Burton, "Enumerating fundamental normal surfaces: Algorithms, experiments and invariants", ALENEX 2014: Proceedings of the Meeting on Algorithm Engineering & Experiments, SIAM, 2014, pp. 112-124.

This flag is incompatible with NS_HILBERT_PRIMAL, NS_HILBERT_DUAL and NS_HILBERT_CD.

NS_ALG_LEGACY 

Indicates that a normal surface list was enumerated using an older version of Regina (4.93 or earlier).

These older versions did not retain details of the algorithm used to build each list, and so in such cases no further algorithmic information is available.

If this flag is passed to an enumeration algorithm, it will be ignored.

NS_ALG_CUSTOM 

Indicates that a normal surface list was built using a customised algorithm.

In such cases, no further details on the algorithm are available.

If this flag is passed to an enumeration algorithm, it will be ignored.

◆ 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.

Enumerator
NS_STANDARD 

Represents standard triangle-quadrilateral coordinates for normal surfaces.

NS_QUAD 

Represents quadrilateral coordinates for normal surfaces.

For details, see "Normal surface Q-theory", Jeffrey L. Tollefson, Pacific J. Math. 183 (1998), no. 2, 359–374.

NS_QUAD_CLOSED 

Represents quadrilateral coordinates in ideal triangulations for enumerating closed surfaces only (thus excluding spun-normal surfaces).

The coordinates themselves are identical to quadrilateral coordinates, as described by NS_QUAD; however, the enumeration procedure introduces additional constraints. The resulting solution space is the space Q_0 as described in "Computing closed essential surfaces in knot complements", by Burton, Coward and Tillmann, in SCG ’13: Proceedings of the 29th Annual Symposium on Computational Geometry, ACM, 2013, pp. 405–414.

Precondition
Regina can only create matching equations in this coordinate system for a limited class of triangulations. Currently, such triangulations must be oriented and ideal, with precisely one torus cusp and no other boundary components or internal vertices. Moreover, SnapPea must be able to work with them without retriangulating (though this should follow from the other constraints).
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 quadrilateral-octagon coordinates for octagonal almost normal surfaces.

For details, see "Quadrilateral-octagon coordinates for almost normal surfaces", Benjamin A. Burton, Experiment. Math. 19 (2010), 285-315.

NS_AN_STANDARD 

Represents standard triangle-quadrilateral-octagon coordinates for octagonal almost normal surfaces.

NS_AN_QUAD_OCT_CLOSED 

Represents quadrilateral-octagon coordinates in ideal triangulations for enumerating closed surfaces only (thus excluding spun-almost normal surfaces).

The coordinates themselves are identical to quadrilateral-octagon coordinates, as described by NS_AN_QUAD_OCT; however, the enumeration procedure introduces additional constraints.

Precondition
Regina can only create matching equations in this coordinate system for a limited class of triangulations. Currently, such triangulations must be oriented and ideal, with precisely one torus cusp and no other boundary components or internal vertices. Moreover, SnapPea must be able to work with them without retriangulating (though this should follow from the other constraints).
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_ORIENTED 

Represents standard triangle-quadrilateral 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.

Precondition
This coordinate system must not be used with any of Regina's routines unless they explicitly declare that NS_ANGLE is allowed.

◆ NormalListFlags


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.

Python
The values in this enumeration type are present, but they are treated by Python as NormalList objects (and they can be combined and/or queried as such). The underlying enumeration type is not exposed to Python.
Enumerator
NS_LIST_DEFAULT 

An empty flag, indicating to an enumeration routine that it should use its default behaviour.

The numeric value of this flag is zero (i.e., it has no effect when combined with other flags using bitwise OR).

NS_EMBEDDED_ONLY 

Indicates that this list is restricted to properly embedded surfaces only.

This flag is incompatible with NS_IMMERSED_SINGULAR.

NS_IMMERSED_SINGULAR 

Indicates that the scope of this list includes not just properly embedded surfaces, but also immersed and/or branched surfaces.

This is no guarantee that the list contains immersed and/or branched surfaces; it merely states that such surfaces have not been explicitly excluded (in particular, the quadrilateral constraints have not been enforced).

This flag is incompatible with NS_EMBEDDED_ONLY.

NS_VERTEX 

Indicates a list of all vertex normal surfaces, with respect to the particular normal coordinate system used by the list.

This flag is incompatible with NS_FUNDAMENTAL.

NS_FUNDAMENTAL 

Indicates a list of all fundamental normal surfaces, with respect to the particular normal coordinate system used by the list.

This flag is incompatible with NS_VERTEX.

NS_LEGACY 

Indicates a list that was constructed using an old version of Regina (4.93 or earlier).

These older versions did not retain details of how each list was constructed, beyond whether immersed and/or singular surfaces were included. Therefore no information is available for such lists, other than the presence or absence of the NS_EMBEDDED_ONLY and/or NS_IMMERSED_SINGULAR flags.

If this flag is passed to an enumeration routine, it will be ignored.

NS_CUSTOM 

Indicates some other type of list, typically hand-crafted by the user or built by some customised algorithm.

If this flag is passed to an enumeration routine, it will be ignored.

◆ SurfaceExportFields

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 TRUE or FALSE, or will be left empty if the orientability cannot be computed.

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.

◆ SurfaceFilterType

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.

Function Documentation

◆ adjacentDisc()

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].

Parameters
discthe given normal disc; this must be a disc in this disc set.
arcthe given normal arc; this must actually be an arc on the boundary of the given normal disc (although it may run in either direction).
adjArcreturns 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.
Returns
the normal disc adjacent to the given disc along the given arc, or 0 if there is no adjacent disc. This disc specifier will be newly created, and it is up to the caller of this routine to dispose of it.

◆ arcFromDisc()

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.

Precondition
The given normal disc actually meets a normal arc of the given type on the given face.
Parameters
arcFacethe face of this tetrahedron containing the normal arc (between 0 and 3 inclusive).
arcVertexthe vertex of this tetrahedron about which the normal arc runs (between 0 and 3 inclusive); arcFace and arcVertex should not be the same.
discTypethe disc type of the given normal disc; this should be between 0 and 9 inclusive, as described in the DiscSpec class notes.
discNumberindicates which normal disc of the given disc type is referred to (between 0 and nDiscs(discType)-1 inclusive).
Returns
the number of the normal arc of the given type that belongs to the given normal disc. Arcs of a given type (where arcFace and arcVertex together define the arc type) are numbered starting at 0 from the tetrahedron vertex outwards.

◆ begin()

DiscSpecIterator regina::DiscSetSurface::begin ( ) const
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:

DiscSetSurface* discs = ...;
for (const DiscSpec& s : *discs) { ... }

In Python, a DiscSetSurface can be treated as an iterable object, again iterating through all normal discs:

discs = ...
for s in discs:
...
Returns
an iterator at the beginning of the range of all normal discs.

◆ data() [1/2]

template<class T >
T& regina::DiscSetTetData< T >::data ( int  discType,
unsigned long  discNumber 
)
inline

Retrieves a reference to the data corresponding to the given normal disc.

Parameters
discTypethe disc type of the given normal disc; this should be between 0 and 9 inclusive, as described in the DiscSpec class notes.
discNumberindicates which normal disc of the given disc type is referred to; this should be between 0 and nDiscs(discType)-1 inclusive.
Returns
a reference to the data corresponding to the given normal disc.

◆ data() [2/2]

template<class T >
T& regina::DiscSetSurfaceData< T >::data ( const DiscSpec disc)
inline

Retrieves a reference to the data corresponding to the given normal disc.

Parameters
discthe disc whose data we require; this must refer to a disc within this disc set.
Returns
a reference to the data corresponding to the given normal disc.

◆ discFromArc()

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.

Precondition
The given normal arc actually exists in the normal surface with which this DiscSetTet object was created.
Parameters
arcFacethe face of this tetrahedron containing the normal arc (between 0 and 3 inclusive).
arcVertexthe vertex of this tetrahedron about which the normal arc runs (between 0 and 3 inclusive); arcFace and arcVertex should not be the same.
arcNumberindicates 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.
discTypereturns 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.
discNumberreturns 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.

◆ discOrientationFollowsEdge()

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.

Precondition
The given normal arc lies on a normal disc of the given type.
Parameters
discTypethe normal disc type under consideration; this should be between 0 and 9 inclusive, as described by the DiscSpec class notes.
vertexthe vertex about which the normal arc runs.
edgeStartthe start vertex of the edge to which the normal arc is parallel.
edgeEndthe end vertex of the edge to which the normal arc is parallel.

◆ DiscSetSurface() [1/2]

regina::DiscSetSurface::DiscSetSurface ( const NormalSurface surface,
bool  b 
)
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.

Warning
After calling this constructor, each DiscSetTet object in the discSets array must be created, since the DiscSetSurface destructor will attempt to destroy them! The discSets array will have size surface.triangulation()->size().
Parameters
surfacethe normal surface whose discs we shall use.
bthis parameter is ignored.

◆ DiscSetSurface() [2/2]

regina::DiscSetSurface::DiscSetSurface ( const NormalSurface surface)

Creates a new disc set corresponding to the discs of the given normal surface.

Parameters
surfacethe normal surface whose discs we shall use.

◆ DiscSetSurfaceData() [1/2]

template<class T >
regina::DiscSetSurfaceData< T >::DiscSetSurfaceData ( const NormalSurface surface)
inline

Creates a new disc set corresponding to the discs of the given normal surface.

The data for each disc will remain uninitialised.

Parameters
surfacethe normal surface whose discs we shall use.

◆ DiscSetSurfaceData() [2/2]

template<class T >
regina::DiscSetSurfaceData< T >::DiscSetSurfaceData ( const NormalSurface surface,
const T &  initValue 
)
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.

Parameters
surfacethe normal surface whose discs we shall use.
initValuethe value with which to initialise the data corresponding to each disc.

◆ DiscSetTet() [1/2]

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.

Parameters
surfacethe normal surface whose discs we shall use.
tetIndexthe 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.

◆ DiscSetTet() [2/2]

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.

Parameters
tri0the number of triangular discs surrounding vertex 0.
tri1the number of triangular discs surrounding vertex 1.
tri2the number of triangular discs surrounding vertex 2.
tri3the number of triangular discs surrounding vertex 3.
quad0the number of quadrilateral discs of type 0.
quad1the number of quadrilateral discs of type 1.
quad2the number of quadrilateral discs of type 2.
oct0the number of octahedral discs of type 0.
oct1the number of octahedral discs of type 1.
oct2the number of octahedral discs of type 2.

◆ DiscSetTetData() [1/3]

template<class T >
regina::DiscSetTetData< T >::DiscSetTetData ( const NormalSurface surface,
size_t  tetIndex 
)
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.

Parameters
surfacethe normal surface whose discs we shall use.
tetIndexthe 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.

◆ DiscSetTetData() [2/3]

template<class T >
regina::DiscSetTetData< T >::DiscSetTetData ( const NormalSurface surface,
size_t  tetIndex,
const T &  initValue 
)
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.

Parameters
surfacethe normal surface whose discs we shall use.
tetIndexthe 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.
initValuethe value with which to initialise the data corresponding to each disc.

◆ DiscSetTetData() [3/3]

template<class T >
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 
)
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.

Parameters
tri0the number of triangular discs surrounding vertex 0.
tri1the number of triangular discs surrounding vertex 1.
tri2the number of triangular discs surrounding vertex 2.
tri3the number of triangular discs surrounding vertex 3.
quad0the number of quadrilateral discs of type 0.
quad1the number of quadrilateral discs of type 1.
quad2the number of quadrilateral discs of type 2.
oct0the number of octahedral discs of type 0.
oct1the number of octahedral discs of type 1.
oct2the number of octahedral discs of type 2.

◆ DiscSpec() [1/3]

regina::DiscSpec::DiscSpec ( )
inline

Creates a new uninitialised disc specifier.

◆ DiscSpec() [2/3]

regina::DiscSpec::DiscSpec ( size_t  newTetIndex,
int  newType,
unsigned long  newNumber 
)
inline

Creates a new disc specifier containing the given values.

Parameters
newTetIndexthe index in the triangulation of the tetrahedron containing the disc.
newTypethe disc type; this is between 0 and 9 inclusive, as described in the DiscSpec class notes.
newNumberspecifies which disc of the particular type in the particular tetrahedron is being referred to; discs are numbered as described in the DiscSpec class notes.

◆ DiscSpec() [3/3]

regina::DiscSpec::DiscSpec ( const DiscSpec cloneMe)
default

Creates a new disc specifier that is a clone of the given specifier.

Parameters
cloneMethe disc specifier to clone.

◆ DiscSpecIterator() [1/3]

regina::DiscSpecIterator::DiscSpecIterator ( )
inline

Creates a new uninitialised iterator.

This iterator cannot be used or queried until either init() or the assignmemnt operator is called.

◆ DiscSpecIterator() [2/3]

regina::DiscSpecIterator::DiscSpecIterator ( const DiscSetSurface discSet)
inline

Creates a new iterator pointing to the first disc in the given disc set.

Parameters
discSetthe disc set used to initialise this iterator.

◆ DiscSpecIterator() [3/3]

regina::DiscSpecIterator::DiscSpecIterator ( const DiscSpecIterator )
default

Default copy constructor.

◆ done()

bool regina::DiscSpecIterator::done ( ) const
inline

Determines if this iterator is past-the-end.

Returns
true if and only if this iterator is past-the-end.

◆ end()

DiscSpecIterator regina::DiscSetSurface::end ( ) const
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.

Returns
an iterator at the end of the range of all normal discs.

◆ forCoords() [1/2]

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.

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.

Precondition
The function object must have a typedef ReturnType indicating the return type of the corresponding templated bracket operator. Inheriting from Returns<...> is a convenient way to ensure this.
Python
Not present.
Parameters
coordsthe given normal coordinate system.
functhe function object whose bracket operator we will call with a NormalInfo<coords> object.
defaultReturnthe value to return if the given coordinate system is invalid.
argsany 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.
Returns
the return value from the corresponding bracket operator of func, or defaultReturn if the given coordinate system is invalid.

◆ forCoords() [2/2]

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.

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.

Precondition
There must not exist a type FunctionObject::ReturnType. (or, if FunctionObject is a reference to a class/struct F, there must likewise not exist a type F::ReturnType). The existence of a type FunctionObject::ReturnType will cause the non-void variant of forCoords() to be used instead.
Python
Not present.
Parameters
coordsthe given normal coordinate system.
functhe function object whose bracket operator we will call with a NormalInfo<coords> object.
argsany 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.
Returns
nothing; the return type ReturnsTraits<FunctionObject>::Void simply evaluates to void.

◆ forFilter() [1/2]

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.

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.

Precondition
The function object must have a typedef ReturnType indicating the return type of the corresponding templated bracket operator. Inheriting from Returns<...> is a convenient way to ensure this.
Python
Not present.
Parameters
filterthe given type of normal surface filter.
functhe function object whose bracket operator we will call with a SurfaceFilterInfo<filter> object.
defaultReturnthe value to return if the given filter type is not valid.
argsany 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.
Returns
the return value from the corresponding bracket operator of func, or defaultReturn if the given filter type is not valid.

◆ forFilter() [2/2]

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.

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.

Precondition
There must not exist a type FunctionObject::ReturnType (or, if FunctionObject is a reference to a class/struct F, there must likewise not exist a type F::ReturnType). The existence of a type FunctionObject::ReturnType will cause the non-void variant of forFilter() to be used instead.
Python
Not present.
Parameters
filterthe given type of normal surface filter.
functhe function object whose bracket operator we will call with a SurfaceFilterInfo<filter> object.
argsany 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.
Returns
nothing; the return type ReturnsTraits<FunctionObject>::Void simply evaluates to void.

◆ init()

void regina::DiscSpecIterator::init ( const DiscSetSurface discSet)
inline

Points this iterator to the first disc in the given disc set.

Parameters
discSetthe disc set used to reinitialise this iterator.

◆ makeEmbeddedConstraints()

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.

Python
Not present.
Parameters
triangulationthe triangulation upon which these validity constraints will be based.
coordsthe coordinate system to be used.
Returns
a newly allocated set of constraints.

◆ makeMatchingEquations()

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.

Parameters
triangulationthe triangulation upon which these matching equations will be based.
coordsthe coordinate system to be used.
Returns
a newly allocated set of matching equations, or null if Regina is not able to construct them for the given combination of triangulation and coordinate system.

◆ makeZeroVector()

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.

Python
Not present.
Parameters
triangulationthe triangulation upon which the underlying coordinate system is based.
coordsthe coordinate system to be used.
Returns
a new zero vector of the correct class and length.

◆ nDiscs() [1/2]

unsigned long regina::DiscSetTet::nDiscs ( int  type) const
inline

Determines the number of discs of the given type inside this tetrahedron.

Parameters
typethe disc type to examine; this should be between 0 and 9 inclusive. Disc types are outlined in the DiscSpec class notes.
Returns
the number of discs of the given type inside this tetrahedron.

◆ nDiscs() [2/2]

unsigned long regina::DiscSetSurface::nDiscs ( size_t  tetIndex,
int  type 
) const
inline

Determines the number of discs of the given type inside the given tetrahedron.

Parameters
tetIndexthe index in the triangulation of the tetrahedron to examine.
typethe disc type to examine; this should be between 0 and 9 inclusive. Disc types are outlined in the DiscSpec class notes.
Returns
the number of discs of the given type inside the given tetrahedron.

◆ nTets()

size_t regina::DiscSetSurface::nTets ( ) const
inline

Returns the number of tetrahedra in the underlying triangulation.

Returns
the number of tetrahedra.

◆ numberDiscsAwayFromVertex()

bool regina::numberDiscsAwayFromVertex ( int  discType,
int  vertex 
)

Determines whether or not normal discs of the given type are numbered away from the given vertex.

Parameters
discTypethe normal disc type under consideration; this should be between 0 and 9 inclusive, as described by the DiscSpec class notes.
vertexthe vertex under consideration; this should be between 0 and 3 inclusive.
Returns
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.

◆ operator!=() [1/2]

bool regina::DiscSpec::operator!= ( const DiscSpec other) const
inline

Determines if this and the given disc specifier contain different information.

Parameters
otherthe disc specifier to compare with this.
Returns
true if and only if this and the given disc specifier contain different information.

◆ operator!=() [2/2]

bool regina::DiscSpecIterator::operator!= ( const DiscSpecIterator other) const
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.

Parameters
otherthe iterator to compare with this.
Returns
true if and only if this and the given iterator are equal.

◆ operator*()

const DiscSpec & regina::DiscSpecIterator::operator* ( ) const
inline


Returns a reference to the disc pointed to by this iterator.

Precondition
This iterator is not past-the-end.
Python
This routine is called deref(), since Python does not support the dereference operator.
Returns
a reference to the disc pointed to by this iterator.

◆ operator++() [1/2]

DiscSpecIterator & regina::DiscSpecIterator::operator++ ( )
inline


Preincrement operator.

Precondition
This iterator is not past-the-end.
Python
Not present; instead this class implements 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.
Returns
a reference to this iterator.

◆ operator++() [2/2]

DiscSpecIterator regina::DiscSpecIterator::operator++ ( int  )
inline


Postincrement operator.

Precondition
This iterator is not past-the-end.
Python
Not present; instead this class implements 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.
Returns
a copy of this iterator before it was incremented.

◆ operator<<() [1/3]

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).

Parameters
outthe output stream to which to write.
specthe prism specifier to write.
Returns
a reference to out.

◆ operator<<() [2/3]

std::ostream & regina::operator<< ( std::ostream &  out,
const DiscType type 
)
inline

Writes the given disc type to the given output stream.

The disc type will be written as a pair (tetIndex, type).

Parameters
outthe output stream to which to write.
typethe disc type to write.
Returns
a reference to the given output stream.

◆ operator<<() [3/3]

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).

Parameters
outthe output stream to which to write.
specthe disc specifier to write.
Returns
a reference to out.

◆ operator=() [1/2]

DiscSpec& regina::DiscSpec::operator= ( const DiscSpec cloneMe)
default

Copies the values from the given disc specifier into this specifier.

Parameters
cloneMethe disc specifier whose values should be copied.
Returns
a reference to this disc specifier.

◆ operator=() [2/2]

DiscSpecIterator& regina::DiscSpecIterator::operator= ( const DiscSpecIterator )
default

Default copy assignment operator.

◆ operator==() [1/2]

bool regina::DiscSpec::operator== ( const DiscSpec other) const
inline

Determines if this and the given disc specifier contain identical information.

Parameters
otherthe disc specifier to compare with this.
Returns
true if and only if this and the given disc specifier contain identical information.

◆ operator==() [2/2]

bool regina::DiscSpecIterator::operator== ( const DiscSpecIterator other) const
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.

Parameters
otherthe iterator to compare with this.
Returns
true if and only if this and the given iterator are equal.

◆ operator|() [1/2]

NormalList regina::operator| ( NormalListFlags  lhs,
NormalListFlags  rhs 
)
inline

Returns the bitwise OR of the two given flags.

Parameters
lhsthe first flag to combine.
rhsthe second flag to combine.
Returns
the combination of both flags.

◆ operator|() [2/2]

NormalAlg regina::operator| ( NormalAlgFlags  lhs,
NormalAlgFlags  rhs 
)
inline

Returns the bitwise OR of the two given flags.

Parameters
lhsthe first flag to combine.
rhsthe second flag to combine.
Returns
the combination of both flags.

◆ tetDiscs()

DiscSetTet & regina::DiscSetSurface::tetDiscs ( size_t  tetIndex) const
inline

Returns the specific set of discs living inside the given tetrahedron.

Parameters
tetIndexthe index in the triangulation of the given tetrahedron.
Returns
the set of discs inside the given tetrahedron.

◆ ~DiscSetSurface()

virtual regina::DiscSetSurface::~DiscSetSurface ( )
virtual

Destroys this set of discs and deallocates all associated memory.

◆ ~DiscSetTet()

regina::DiscSetTet::~DiscSetTet ( )
inlinevirtual

Destroys this disc set.

◆ ~DiscSetTetData()

template<class T >
virtual regina::DiscSetTetData< T >::~DiscSetTetData ( )
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.

Variable Documentation

◆ current

DiscSpec regina::DiscSpecIterator::current
protected

The disc currently pointed to.

◆ discSets

DiscSetTet** regina::DiscSetSurface::discSets
protected

The disc sets corresponding to each tetrahedron.

◆ internalData

template<class T >
DataPtr regina::DiscSetTetData< T >::internalData[10]
protected

Stores the data corresponding to each normal disc.

◆ internalDiscSet

const DiscSetSurface* regina::DiscSpecIterator::internalDiscSet
protected

The disc set through which we are iterating.

◆ internalNDiscs

unsigned long regina::DiscSetTet::internalNDiscs[10]
protected

The number of discs of each type.

◆ number

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.

◆ octDiscArcs

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.

C++
This array is replaced by a macro octDiscArcs(discType, arcIndex) that essentially looks up the corresponding array. This is necessary because of a bug in gcc 2.95.

◆ quadDefn

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.

◆ quadDiscArcs

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.

C++
This array is replaced by a macro quadDiscArcs(discType, arcIndex) that essentially looks up the corresponding array. This is necessary because of a bug in gcc 2.95.

◆ quadMeeting

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.

◆ quadPartner

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].

◆ quadSeparating

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).

◆ quadString

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.

◆ tetIndex

size_t regina::DiscSpec::tetIndex

The index in the triangulation of the tetrahedron containing the disc.

◆ triangulation

const Triangulation<3>* regina::DiscSetSurface::triangulation
protected

The triangulation in which the normal surface lives.

◆ triDiscArcs

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.

C++
This array is replaced by a macro triDiscArcs(discType, arcIndex) that essentially looks up the corresponding array. This is necessary because of a bug in gcc 2.95.

◆ type

int regina::DiscSpec::type

The disc type; this is between 0 and 9 inclusive, as described in the DiscSpec class notes.

Friends

◆ operator<<

std::ostream& operator<< ( std::ostream &  out,
const DiscSpec spec 
)
friend

Writes the given disc specifier to the given output stream.

The disc specifier will be written as a triple (tetIndex, type, number).

Parameters
outthe output stream to which to write.
specthe disc specifier to write.
Returns
a reference to out.

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