Normal Surfaces

## 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
| An iterator used for running through all normal discs in a normal surface. More...
struct | regina::DiscType
| Identifies a single normal or almost normal disc type within a triangulation. More...
class | regina::MatrixIntDomain< T >
| Represents a matrix of elements from a given integral domain 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::VectorIterator
| A bidirectional iterator that runs through the raw vectors for surfaces in this list. More...
struct | regina::NormalSurfaces::SurfaceInserter
| An output iterator used to insert surfaces into an NormalSurfaces. 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::NSVectorQuadOct
| An almost normal surface vector using quad-oct coordinates. 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 DiscType | regina::NDiscType
| Deprecated typedef for backward compatibility. More...
typedef regina::Flags< NormalListFlags > | regina::NormalList
| A combination of flags for types of normal surface lists. More...
typedef regina::Flags< NormalAlgFlags > | regina::NormalAlg
| A combination of flags for types of normal surface lists. More...
typedef NormalSurfaceVector | regina::NNormalSurfaceVector
| Deprecated typedef for backward compatibility. More...
typedef NormalSurface | regina::NNormalSurface
| Deprecated typedef for backward compatibility. More...
typedef NormalSurfaces | regina::NNormalSurfaceList
| Deprecated typedef for backward compatibility. More...
typedef NSVectorANStandard | regina::NNormalSurfaceVectorANStandard
| Deprecated typedef for backward compatibility. More...
typedef NSVectorMirrored | regina::NNormalSurfaceVectorMirrored
| Deprecated typedef for backward compatibility. More...
typedef NSVectorOriented | regina::NNormalSurfaceVectorOriented
| Deprecated typedef for backward compatibility. More...
typedef NSVectorOrientedQuad | regina::NNormalSurfaceVectorOrientedQuad
| Deprecated typedef for backward compatibility. More...
typedef NSVectorQuad | regina::NNormalSurfaceVectorQuad
| Deprecated typedef for backward compatibility. More...
typedef NSVectorQuadOct | regina::NNormalSurfaceVectorQuadOct
| Deprecated typedef for backward compatibility. More...
typedef NSVectorStandard | regina::NNormalSurfaceVectorStandard
| Deprecated typedef for backward compatibility. More...
typedef PrismSpec | regina::NPrismSpec
| Deprecated typedef for backward compatibility. More...
typedef SurfaceFilter | regina::NSurfaceFilter
| Deprecated typedef for backward compatibility. More...
typedef SurfaceFilterCombination | regina::NSurfaceFilterCombination
| Deprecated typedef for backward compatibility. More...
typedef SurfaceFilterProperties | regina::NSurfaceFilterProperties
| Deprecated typedef for backward compatibility. More...

## Enumerations

enum | regina::NormalCoords { regina::NS_STANDARD = 0, regina::NS_QUAD = 1, regina::NS_AN_LEGACY = 100, regina::NS_AN_QUAD_OCT = 101, regina::NS_AN_STANDARD = 102, 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)
| Creates a new disc specifier that is a clone of the given specifier. More...
DiscSpec & | regina::DiscSpec::operator= (const DiscSpec &cloneMe)
| 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::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::DiscSetSurface::DiscSetSurface (const NormalSurface &surface, bool b)
| Creates a new disc set corresponding to the discs of the given normal surface. More...
| regina::DiscSetSurface::DiscSetSurface (const NormalSurface &surface)
| Creates a new disc set corresponding to the discs of the given normal surface. More...
virtual | regina::DiscSetSurface::~DiscSetSurface ()
| Destroys this set of discs and deallocates all associated memory. More...
size_t | regina::DiscSetSurface::nTets () const
| Returns the number of tetrahedra in the underlying triangulation. More...
unsigned long | regina::DiscSetSurface::nDiscs (size_t tetIndex, int type) const
| Determines the number of discs of the given type inside the given tetrahedron. More...
DiscSetTet & | regina::DiscSetSurface::tetDiscs (size_t tetIndex) const
| Returns the specific set of discs living inside the given tetrahedron. More...
DiscSpec * | regina::DiscSetSurface::adjacentDisc (const DiscSpec &disc, Perm< 4 > arc, Perm< 4 > &adjArc) const
| Determines which normal disc is adjacent to the given normal disc along the given directed normal arc in the surface described by this disc set. More...
| 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::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...
void | regina::DiscSpecIterator::init (const DiscSetSurface &discSet)
| Points this iterator to the first disc in the given disc set. More...
void | regina::DiscSpecIterator::operator++ ()
| Points this iterator to the next disc, or makes it past-the-end if there is no next disc. More...
void | regina::DiscSpecIterator::operator++ (int)
| Points this iterator to the next disc, or makes it past-the-end if there is no next disc. More...
const DiscSpec & | regina::DiscSpecIterator::operator* () const
| Returns a reference to the disc pointed to by this iterator. More...
bool | regina::DiscSpecIterator::done () const
| Determines if this iterator is past-the-end. More...
bool | regina::DiscSpecIterator::operator== (const DiscSpecIterator &other) const
| Determines if this and the given iterator are equal. More...
bool | regina::DiscSpecIterator::operator!= (const DiscSpecIterator &other) const
| Determines if this and the given iterator are different. More...
| regina::DiscType::DiscType ()
| Creates a new disc type initialised to NONE. More...
| regina::DiscType::DiscType (size_t newTetIndex, int newType)
| Creates a new disc type initialised with the given values. More...
| regina::DiscType::DiscType (const DiscType &cloneMe)
| Creates a copy of the given disc type. More...
DiscType & | regina::DiscType::operator= (const DiscType &cloneMe)
| Sets this to a copy of the given disc type. More...
bool | regina::DiscType::operator== (const DiscType &compare) const
| Determines if this and the given disc type are identical. More...
bool | regina::DiscType::operator!= (const DiscType &compare) const
| Determines if this and the given disc type are different. More...
bool | regina::DiscType::operator< (const DiscType &compare) const
| Provides an ordering of disc types. 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...
| regina::NormalSurfaceVector::NormalSurfaceVector (size_t length)
| Creates a new vector all of whose entries are initialised to zero. More...
| regina::NormalSurfaceVector::NormalSurfaceVector (const Vector< LargeInteger > &cloneMe)
| Creates a new vector that is a clone of the given vector. More...
virtual | regina::NormalSurfaceVector::~NormalSurfaceVector ()
| A virtual destructor. More...
const Ray & | regina::NormalSurfaceVector::coords () const
| Gives read-only access to the underlying vector of coordinates. More...
virtual NormalSurfaceVector * | regina::NormalSurfaceVector::clone () const =0
| Creates a newly allocated clone of this vector. More...
size_t | regina::NormalSurfaceVector::size () const
| Returns the number of coordinates in the underlying vector. More...
const NLargeInteger & | regina::NormalSurfaceVector::operator[] (size_t index) const
| Returns the given coordinate from the underlying vector. More...
virtual void | regina::NormalSurfaceVector::setElement (size_t index, const LargeInteger &value)
| Sets the given normal coordinate to the given value. More...
virtual void | regina::NormalSurfaceVector::operator+= (const NormalSurfaceVector &other)
| Adds the given vector to this vector. More...
virtual void | regina::NormalSurfaceVector::scaleDown ()
| Scales this vector down by the greatest common divisor of all its elements. More...
virtual bool | regina::NormalSurfaceVector::allowsAlmostNormal () const =0
| Determines if the specific underlying coordinate system allows for almost normal surfaces, that is, allows for octagonal discs. More...
virtual bool | regina::NormalSurfaceVector::allowsSpun () const =0
| Determines if the specific underlying coordinate system allows for spun-normal surfaces; that is, surfaces with infinitely many triangles. More...
virtual bool | regina::NormalSurfaceVector::allowsOriented () const =0
| Determines if the specific underlying coordinate system allows for transversely oriented normal surfaces. More...
virtual bool | regina::NormalSurfaceVector::hasMultipleOctDiscs (const Triangulation< 3 > *triang) const
| Determines if this normal surface has more than one octagonal disc. More...
virtual bool | regina::NormalSurfaceVector::isCompact (const Triangulation< 3 > *triang) const
| Determines if the normal surface represented is compact (has finitely many discs). More...
virtual bool | regina::NormalSurfaceVector::isVertexLinking (const Triangulation< 3 > *triang) const
| Determines if the normal surface represented is vertex linking. More...
virtual const Vertex< 3 > * | regina::NormalSurfaceVector::isVertexLink (const Triangulation< 3 > *triang) const
| Determines if a rational multiple of the normal surface represented is the link of a single vertex. More...
virtual std::pair< const Edge< 3 > *, const Edge< 3 > * > | regina::NormalSurfaceVector::isThinEdgeLink (const Triangulation< 3 > *triang) const
| Determines if a rational multiple of the normal surface represented is the thin link of a single edge. More...
virtual bool | regina::NormalSurfaceVector::isSplitting (const Triangulation< 3 > *triang) const
| Determines if the normal surface represented is a splitting surface in the given triangulation. More...
virtual LargeInteger | regina::NormalSurfaceVector::isCentral (const Triangulation< 3 > *triang) const
| Determines if the normal surface represented is a central surface in the given triangulation. More...
virtual LargeInteger | regina::NormalSurfaceVector::triangles (size_t tetIndex, int vertex, const Triangulation< 3 > *triang) const =0
| Returns the number of triangular discs of the given type in this normal surface. More...
virtual LargeInteger | regina::NormalSurfaceVector::orientedTriangles (size_t tetIndex, int vertex, const Triangulation< 3 > *triang, bool orientation) const
| Returns the number of oriented triangular discs of the given type in this normal surface. More...
virtual LargeInteger | regina::NormalSurfaceVector::quads (size_t tetIndex, int quadType, const Triangulation< 3 > *triang) const =0
| Returns the number of quadrilateral discs of the given type in this normal surface. More...
virtual LargeInteger | regina::NormalSurfaceVector::orientedQuads (size_t tetIndex, int quadType, const Triangulation< 3 > *triang, bool orientation) const
| Returns the number of oriented quadrilateral discs of the given type in this normal surface. More...
virtual LargeInteger | regina::NormalSurfaceVector::octs (size_t tetIndex, int octType, const Triangulation< 3 > *triang) const =0
| Returns the number of octagonal discs of the given type in this normal surface. More...
virtual LargeInteger | regina::NormalSurfaceVector::edgeWeight (size_t edgeIndex, const Triangulation< 3 > *triang) const =0
| Returns the number of times this normal surface crosses the given edge. More...
virtual LargeInteger | regina::NormalSurfaceVector::arcs (size_t triIndex, int triVertex, const Triangulation< 3 > *triang) const =0
| Returns the number of arcs in which this normal surface intersects the given triangle in the given direction. More...
static NormalSurfaceVector * | regina::NormalSurfaceVector::makeZeroVector (const Triangulation< 3 > *triangulation)
| Returns a new normal surface vector of the appropriate length for the given triangulation and for the coordinate system corresponding to this subclass of NormalSurfaceVector. More...
static MatrixInt * | regina::NormalSurfaceVector::makeMatchingEquations (const Triangulation< 3 > *triangulation)
| Creates a new set of normal surface matching equations for the given triangulation using the coordinate system corresponding to this particular subclass of NormalSurfaceVector. More...
static EnumConstraints * | regina::NormalSurfaceVector::makeEmbeddedConstraints (const Triangulation< 3 > *triangulation)
| Creates a new set of validity constraints representing the condition that normal surfaces be embedded. More...
| regina::NormalSurface::NormalSurface (const Triangulation< 3 > *triang, NormalSurfaceVector *newVector)
| Creates a new normal surface inside the given triangulation with the given coordinate vector. More...
| regina::NormalSurface::NormalSurface (const Triangulation< 3 > *triang, NormalCoords coordSystem, List allCoords)
| A Python-only routine that creates a new normal surface inside the given triangulation with the given coordinate vector. More...
| regina::NormalSurface::~NormalSurface ()
| Destroys this normal surface. More...
NormalSurface * | regina::NormalSurface::clone () const
| Creates a newly allocated clone of this normal surface. More...
NormalSurface * | regina::NormalSurface::doubleSurface () const
| Creates a newly allocated surface that is the double of this surface. More...
LargeInteger | regina::NormalSurface::triangles (size_t tetIndex, int vertex) const
| Returns the number of triangular discs of the given type in this normal surface. More...
LargeInteger | regina::NormalSurface::orientedTriangles (size_t tetIndex, int vertex, bool orientation) const
| Returns the number of oriented triangular discs of the given type in this normal surface. More...
LargeInteger | regina::NormalSurface::quads (size_t tetIndex, int quadType) const
| Returns the number of quadrilateral discs of the given type in this normal surface. More...
LargeInteger | regina::NormalSurface::orientedQuads (size_t tetIndex, int quadType, bool orientation) const
| Returns the number of oriented quadrilateral discs of the given type in this normal surface. More...
LargeInteger | regina::NormalSurface::octs (size_t tetIndex, int octType) const
| Returns the number of octagonal discs of the given type in this normal surface. More...
LargeInteger | regina::NormalSurface::edgeWeight (size_t edgeIndex) const
| Returns the number of times this normal surface crosses the given edge. More...
LargeInteger | regina::NormalSurface::arcs (size_t triIndex, int triVertex) const
| Returns the number of arcs in which this normal surface intersects the given triangle in the given direction. More...
DiscType | regina::NormalSurface::octPosition () const
| Determines the first coordinate position at which this surface has a non-zero octagonal coordinate. More...
size_t | regina::NormalSurface::countCoords () const
| Returns the number of coordinates in the specific underlying coordinate system being used. More...
const Triangulation< 3 > * | regina::NormalSurface::triangulation () const
| Returns the triangulation in which this normal surface resides. More...
const std::string & | regina::NormalSurface::name () const
| Returns the name associated with this normal surface. More...
void | regina::NormalSurface::setName (const std::string &newName)
| Sets the name associated with this normal surface. More...
void | regina::NormalSurface::writeTextShort (std::ostream &out) const
| Writes this surface to the given output stream, using standard triangle-quad-oct coordinates. More...
void | regina::NormalSurface::writeRawVector (std::ostream &out) const
| Writes the underlying coordinate vector to the given output stream in text format. More...
void | regina::NormalSurface::writeXMLData (std::ostream &out) const
| Writes a chunk of XML containing this normal surface and all of its properties. More...
bool | regina::NormalSurface::isEmpty () const
| Determines if this normal surface is empty (has no discs whatsoever). More...
bool | regina::NormalSurface::isCompact () const
| Determines if this normal surface is compact (has finitely many discs). More...
LargeInteger | regina::NormalSurface::eulerChar () const
| Returns the Euler characteristic of this surface. More...
bool | regina::NormalSurface::isOrientable () const
| Returns whether or not this surface is orientable. More...
bool | regina::NormalSurface::isTwoSided () const
| Returns whether or not this surface is two-sided. More...
bool | regina::NormalSurface::isConnected () const
| Returns whether or not this surface is connected. More...
bool | regina::NormalSurface::hasRealBoundary () const
| Determines if this surface has any real boundary, that is, whether it meets any boundary triangles of the triangulation. More...
bool | regina::NormalSurface::isVertexLinking () const
| Determines whether or not this surface is vertex linking. More...
const Vertex< 3 > * | regina::NormalSurface::isVertexLink () const
| Determines whether or not a rational multiple of this surface is the link of a single vertex. More...
std::pair< const Edge< 3 > *, const Edge< 3 > * > | regina::NormalSurface::isThinEdgeLink () const
| Determines whether or not a rational multiple of this surface is the thin link of a single edge. More...
bool | regina::NormalSurface::isSplitting () const
| Determines whether or not this surface is a splitting surface. More...
LargeInteger | regina::NormalSurface::isCentral () const
| Determines whether or not this surface is a central surface. More...
bool | regina::NormalSurface::isCompressingDisc (bool knownConnected=false) const
| Determines whether this surface represents a compressing disc in the underlying 3-manifold. More...
bool | regina::NormalSurface::isIncompressible () const
| Determines whether this is an incompressible surface within the surrounding 3-manifold. More...
Triangulation< 3 > * | regina::NormalSurface::cutAlong () const
| Cuts the associated triangulation along this surface and returns a newly created resulting triangulation. More...
Triangulation< 3 > * | regina::NormalSurface::crush () const
| Crushes this surface to a point in the associated triangulation and returns a newly created resulting triangulation. More...
bool | regina::NormalSurface::sameSurface (const NormalSurface &other) const
| Determines whether this and the given surface in fact represent the same normal (or almost normal) surface. More...
bool | regina::NormalSurface::normal () const
| Determines whether this surface contains only triangle and/or quadrilateral discs. More...
bool | regina::NormalSurface::embedded () const
| Determines whether this surface is embedded. More...
bool | regina::NormalSurface::locallyCompatible (const NormalSurface &other) const
| Determines whether this and the given surface are locally compatible. More...
bool | regina::NormalSurface::disjoint (const NormalSurface &other) const
| Determines whether this and the given surface can be placed within the surrounding triangulation so that they do not intersect anywhere at all, without changing either normal isotopy class. More...
MatrixInt * | regina::NormalSurface::boundaryIntersections () const
| Computes the information about the boundary slopes of this surface at each cusp of the triangulation. More...
const Ray & | regina::NormalSurface::rawVector () const
| Gives read-only access to the raw vector that sits beneath this normal surface. More...
bool | regina::NormalSurface::systemAllowsAlmostNormal () const
| Determines if the underlying coordinate system being used allows for almost normal surfaces, that is, allows for octagonal discs. More...
bool | regina::NormalSurface::systemAllowsSpun () const
| Determines if the underlying coordinate system being used allows for spun normal surfaces. More...
bool | regina::NormalSurface::systemAllowsOriented () const
| Determines if the underlying coordinate system being used allows for transversely oriented normal surfaces. More...
void | regina::NormalSurface::calculateOctPosition () const
| Calculates the position of the first non-zero octagon coordinate and stores it as a property. More...
void | regina::NormalSurface::calculateEulerChar () const
| Calculates the Euler characteristic of this surface and stores it as a property. More...
void | regina::NormalSurface::calculateOrientable () const
| Calculates whether this surface is orientable and/or two-sided and stores the results as properties. More...
void | regina::NormalSurface::calculateRealBoundary () const
| Calculates whether this surface has any real boundary and stores the result as a property. More...
virtual | regina::NormalSurfaces::~NormalSurfaces ()
| Destroys this list and all the surfaces within. More...
static NormalSurfaces * | regina::NormalSurfaces::enumerate (Triangulation< 3 > *owner, NormalCoords coords, NormalList which=NS_LIST_DEFAULT, NormalAlg algHints=NS_ALG_DEFAULT, ProgressTracker *tracker=0)
| A unified routine for enumerating various classes of normal surfaces within a given triangulation. More...
NormalCoords | regina::NormalSurfaces::coords () const
| Returns the coordinate system being used by the surfaces stored in this set. More...
NormalList | regina::NormalSurfaces::which () const
| Returns details of which normal surfaces this list represents within the underlying triangulation. More...
NormalAlg | regina::NormalSurfaces::algorithm () const
| Returns details of the algorithm that was used to enumerate this list. More...
bool | regina::NormalSurfaces::allowsAlmostNormal () const
| Determines if the coordinate system being used allows for almost normal surfaces, that is, allows for octagonal discs. More...
bool | regina::NormalSurfaces::allowsSpun () const
| Determines if the coordinate system being used allows for spun normal surfaces. More...
bool | regina::NormalSurfaces::allowsOriented () const
| Determines if the coordinate system being used allows for transversely oriented normal surfaces. More...
bool | regina::NormalSurfaces::isEmbeddedOnly () const
| Returns whether this list was constructed to contain only properly embedded surfaces. More...
Triangulation< 3 > * | regina::NormalSurfaces::triangulation () const
| Returns the triangulation in which these normal surfaces live. More...
size_t | regina::NormalSurfaces::size () const
| Returns the number of surfaces stored in this list. More...
const NormalSurface * | regina::NormalSurfaces::surface (size_t index) const
| Returns the surface at the requested index in this set. More...
void | regina::NormalSurfaces::writeAllSurfaces (std::ostream &out) const
| Writes the number of surfaces in this set followed by the details of each surface to the given output stream. More...
virtual void | regina::NormalSurfaces::writeTextShort (std::ostream &out) const
| Writes a short text representation of this object to the given output stream. More...
virtual void | regina::NormalSurfaces::writeTextLong (std::ostream &out) const
| Writes a detailed text representation of this object to the given output stream. More...
static XMLPacketReader * | regina::NormalSurfaces::xmlReader (Packet *parent, XMLTreeResolver &resolver)
virtual bool | regina::NormalSurfaces::dependsOnParent () const
| Determines if this packet depends upon its parent. More...
NormalSurfaces * | regina::NormalSurfaces::quadToStandard () const
| Converts the set of all embedded vertex normal surfaces in quadrilateral space to the set of all embedded vertex normal surfaces in standard (tri-quad) space. More...
NormalSurfaces * | regina::NormalSurfaces::quadOctToStandardAN () const
| Converts the set of all embedded vertex almost normal surfaces in quadrilateral-octagon space to the set of all embedded vertex almost normal surfaces in the standard tri-quad-oct space. More...
NormalSurfaces * | regina::NormalSurfaces::standardToQuad () const
| Converts the set of all embedded vertex normal surfaces in standard (tri-quad) space to the set of all embedded vertex normal surfaces in quadrilateral space. More...
NormalSurfaces * | regina::NormalSurfaces::standardANToQuadOct () const
| Converts the set of all embedded vertex almost normal surfaces in standard tri-quad-oct space to the set of all embedded vertex almost normal surfaces in the smaller quadrilateral-octagon space. More...
NormalSurfaces * | regina::NormalSurfaces::filterForLocallyCompatiblePairs () const
| Creates a new list filled with the surfaces from this list that have at least one locally compatible partner. More...
NormalSurfaces * | regina::NormalSurfaces::filterForDisjointPairs () const
| Creates a new list filled with the surfaces from this list that have at least one disjoint partner. More...
NormalSurfaces * | regina::NormalSurfaces::filterForPotentiallyIncompressible () const
| Creates a new list filled with only the surfaces from this list that "might" represent two-sided incompressible surfaces. More...
MatrixInt * | regina::NormalSurfaces::recreateMatchingEquations () const
| Returns a newly created matrix containing the matching equations that were used to create this normal surface list. More...
bool | regina::NormalSurfaces::saveCSVStandard (const char *filename, int additionalFields=regina::surfaceExportAll)
| Exports this list of normal surfaces as a plain text CSV (comma-separated value) file, using standard coordinates. More...
bool | regina::NormalSurfaces::saveCSVEdgeWeight (const char *filename, int additionalFields=regina::surfaceExportAll)
| Exports the given list of normal surfaces as a plain text CSV (comma-separated value) file, using edge weight coordinates. More...
VectorIterator | regina::NormalSurfaces::beginVectors () const
| An iterator that gives access to the raw vectors for surfaces in this list, pointing to the beginning of this surface list. More...
VectorIterator | regina::NormalSurfaces::endVectors () const
| An iterator that gives access to the raw vectors for surfaces in this list, pointing past the end of this surface list. More...
| regina::NormalSurfaces::VectorIterator::VectorIterator ()
| Creates a new uninitialised iterator. More...
| regina::NormalSurfaces::VectorIterator::VectorIterator (const VectorIterator &cloneMe)
| Creates a copy of the given iterator. More...
VectorIterator & | regina::NormalSurfaces::VectorIterator::operator= (const VectorIterator &cloneMe)
| Makes this a copy of the given iterator. More...
bool | regina::NormalSurfaces::VectorIterator::operator== (const VectorIterator &other) const
| Compares this with the given operator for equality. More...
bool | regina::NormalSurfaces::VectorIterator::operator!= (const VectorIterator &other) const
| Compares this with the given operator for inequality. More...
const Ray & | regina::NormalSurfaces::VectorIterator::operator* () const
| Returns the raw vector for the normal surface that this iterator is currently pointing to. More...
VectorIterator & | regina::NormalSurfaces::VectorIterator::operator++ ()
| The preincrement operator. More...
VectorIterator | regina::NormalSurfaces::VectorIterator::operator++ (int)
| The postincrement operator. More...
VectorIterator & | regina::NormalSurfaces::VectorIterator::operator-- ()
| The predecrement operator. More...
VectorIterator | regina::NormalSurfaces::VectorIterator::operator-- (int)
| The postdecrement operator. More...
| regina::NormalSurfaces::NormalSurfaces (NormalCoords coords, NormalList which, NormalAlg algorithm)
| Creates an empty list of normal surfaces with the given parameters. More...
virtual Packet * | regina::NormalSurfaces::internalClonePacket (Packet *parent) const
| Makes a newly allocated copy of this packet. More...
virtual void | regina::NormalSurfaces::writeXMLPacketData (std::ostream &out) const
| Writes a chunk of XML containing the data for this packet only. More...
| regina::NormalSurfaces::SurfaceInserter::SurfaceInserter (NormalSurfaces &newList, Triangulation< 3 > *newOwner)
| Creates a new output iterator. More...
| regina::NormalSurfaces::SurfaceInserter::SurfaceInserter (const SurfaceInserter &cloneMe)
| Creates a new output iterator that is a clone of the given iterator. More...
SurfaceInserter & | regina::NormalSurfaces::SurfaceInserter::operator= (const SurfaceInserter &cloneMe)
| Sets this iterator to be a clone of the given output iterator. More...
SurfaceInserter & | regina::NormalSurfaces::SurfaceInserter::operator= (NormalSurface *surface)
| Appends a normal surface to the end of the appropriate surface list. More...
SurfaceInserter & | regina::NormalSurfaces::SurfaceInserter::operator= (NormalSurfaceVector *vector)
| Appends the normal surface corresponding to the given vector to the end of the appropriate surface list. More...
SurfaceInserter & | regina::NormalSurfaces::SurfaceInserter::operator* ()
| Returns a reference to this output iterator. More...
SurfaceInserter & | regina::NormalSurfaces::SurfaceInserter::operator++ ()
| Returns a reference to this output iterator. More...
SurfaceInserter & | regina::NormalSurfaces::SurfaceInserter::operator++ (int)
| Returns a reference to this output iterator. More...
| regina::NormalSurfaces::Enumerator::Enumerator (NormalSurfaces *list, Triangulation< 3 > *triang, ProgressTracker *tracker)
| Creates a new functor with the given parameters. More...
template<typename Coords >
void | regina::NormalSurfaces::Enumerator::operator() ()
| Performs the real enumeration work, in a setting where the underlying coordinate system is a compile-time constant. More...
NormalSurfaceVector * | regina::makeZeroVector (const Triangulation< 3 > *triangulation, NormalCoords coords)
| Returns a new normal surface vector of the appropriate length for the given triangulation and the given coordinate system. More...
MatrixInt * | regina::makeMatchingEquations (const Triangulation< 3 > *triangulation, NormalCoords coords)
| Creates a new set of normal surface matching equations for the given triangulation using the given coordinate system. More...
EnumConstraints * | regina::makeEmbeddedConstraints (const Triangulation< 3 > *triangulation, NormalCoords coords)
| Creates a new set of validity constraints representing the condition that normal surfaces be embedded. More...
| regina::NSVectorANStandard::NSVectorANStandard (size_t length)
| Creates a new vector all of whose entries are initialised to zero. More...
| regina::NSVectorANStandard::NSVectorANStandard (const Vector< LargeInteger > &cloneMe)
| Creates a new vector that is a clone of the given vector. More...
virtual LargeInteger | regina::NSVectorANStandard::triangles (size_t tetIndex, int vertex, const Triangulation< 3 > *triang) const
| Returns the number of triangular discs of the given type in this normal surface. More...
virtual LargeInteger | regina::NSVectorANStandard::quads (size_t tetIndex, int quadType, const Triangulation< 3 > *triang) const
| Returns the number of quadrilateral discs of the given type in this normal surface. More...
virtual LargeInteger | regina::NSVectorANStandard::octs (size_t tetIndex, int octType, const Triangulation< 3 > *triang) const
| Returns the number of octagonal discs of the given type in this normal surface. More...
virtual LargeInteger | regina::NSVectorANStandard::edgeWeight (size_t edgeIndex, const Triangulation< 3 > *triang) const
| Returns the number of times this normal surface crosses the given edge. More...
virtual LargeInteger | regina::NSVectorANStandard::arcs (size_t triIndex, int triVertex, const Triangulation< 3 > *triang) const
| Returns the number of arcs in which this normal surface intersects the given triangle in the given direction. More...
static NormalSurfaceVector * | regina::NSVectorANStandard::makeZeroVector (const Triangulation< 3 > *triangulation)
static MatrixInt * | regina::NSVectorANStandard::makeMatchingEquations (const Triangulation< 3 > *triangulation)
static EnumConstraints * | regina::NSVectorANStandard::makeEmbeddedConstraints (const Triangulation< 3 > *triangulation)
| regina::NSVectorMirrored::NSVectorMirrored (size_t length)
| Creates a new vector all of whose entries are initialised to zero. More...
| regina::NSVectorMirrored::NSVectorMirrored (const Vector< LargeInteger > &cloneMe)
| Creates a new vector that is a clone of the given vector. More...
virtual | regina::NSVectorMirrored::~NSVectorMirrored ()
| Destroys this vector and its mirror if appropriate. More...
virtual NormalSurfaceVector * | regina::NSVectorMirrored::makeMirror (const Triangulation< 3 > *triang) const =0
| Creates a new mirror vector corresponding to this vector. More...
static NormalSurfaceVector * | regina::NSVectorMirrored::makeMirror (const Ray &original, const Triangulation< 3 > *triang)
| Creates a new mirror vector corresponding to the given vector. More...
virtual void | regina::NSVectorMirrored::setElement (size_t index, const LargeInteger &value) override
| Sets the given normal coordinate to the given value. More...
virtual void | regina::NSVectorMirrored::operator+= (const NormalSurfaceVector &other) override
| Adds the given vector to this vector. More...
virtual void | regina::NSVectorMirrored::scaleDown () override
| Scales this vector down by the greatest common divisor of all its elements. More...
virtual LargeInteger | regina::NSVectorMirrored::triangles (size_t tetIndex, int vertex, const Triangulation< 3 > *triang) const override
| Returns the number of triangular discs of the given type in this normal surface. More...
virtual LargeInteger | regina::NSVectorMirrored::orientedTriangles (size_t tetIndex, int vertex, const Triangulation< 3 > *triang, bool orientation) const override
| Returns the number of oriented triangular discs of the given type in this normal surface. More...
virtual LargeInteger | regina::NSVectorMirrored::quads (size_t tetIndex, int quadType, const Triangulation< 3 > *triang) const override
| Returns the number of quadrilateral discs of the given type in this normal surface. More...
virtual LargeInteger | regina::NSVectorMirrored::orientedQuads (size_t tetIndex, int quadType, const Triangulation< 3 > *triang, bool orientation) const override
| Returns the number of oriented quadrilateral discs of the given type in this normal surface. More...
virtual LargeInteger | regina::NSVectorMirrored::octs (size_t tetIndex, int octType, const Triangulation< 3 > *triang) const override
| Returns the number of octagonal discs of the given type in this normal surface. More...
virtual LargeInteger | regina::NSVectorMirrored::edgeWeight (size_t edgeIndex, const Triangulation< 3 > *triang) const override
| Returns the number of times this normal surface crosses the given edge. More...
virtual LargeInteger | regina::NSVectorMirrored::arcs (size_t triIndex, int triVertex, const Triangulation< 3 > *triang) const override
| Returns the number of arcs in which this normal surface intersects the given triangle in the given direction. More...
| regina::NSVectorOriented::NSVectorOriented (size_t length)
| Creates a new vector all of whose entries are initialised to zero. More...
| regina::NSVectorOriented::NSVectorOriented (const Vector< LargeInteger > &cloneMe)
| Creates a new vector that is a clone of the given vector. More...
virtual LargeInteger | regina::NSVectorOriented::triangles (size_t tetIndex, int vertex, const Triangulation< 3 > *triang) const
| Returns the number of triangular discs of the given type in this normal surface. More...
virtual LargeInteger | regina::NSVectorOriented::quads (size_t tetIndex, int quadType, const Triangulation< 3 > *triang) const
| Returns the number of quadrilateral discs of the given type in this normal surface. More...
virtual LargeInteger | regina::NSVectorOriented::orientedTriangles (size_t tetIndex, int vertex, const Triangulation< 3 > *triang, bool orientation) const
| Returns the number of oriented triangular discs of the given type in this normal surface. More...
virtual LargeInteger | regina::NSVectorOriented::orientedQuads (size_t tetIndex, int quadType, const Triangulation< 3 > *triang, bool orientation) const
| Returns the number of oriented quadrilateral discs of the given type in this normal surface. More...
virtual LargeInteger | regina::NSVectorOriented::octs (size_t tetIndex, int octType, const Triangulation< 3 > *triang) const
| Returns the number of octagonal discs of the given type in this normal surface. More...
virtual LargeInteger | regina::NSVectorOriented::edgeWeight (size_t edgeIndex, const Triangulation< 3 > *triang) const
| Returns the number of times this normal surface crosses the given edge. More...
virtual LargeInteger | regina::NSVectorOriented::arcs (size_t triIndex, int triVertex, const Triangulation< 3 > *triang) const
| Returns the number of arcs in which this normal surface intersects the given triangle in the given direction. More...
static NormalSurfaceVector * | regina::NSVectorOriented::makeZeroVector (const Triangulation< 3 > *triangulation)
static MatrixInt * | regina::NSVectorOriented::makeMatchingEquations (const Triangulation< 3 > *triangulation)
static EnumConstraints * | regina::NSVectorOriented::makeEmbeddedConstraints (const Triangulation< 3 > *triangulation)
| regina::NSVectorOrientedQuad::NSVectorOrientedQuad (size_t length)
| Creates a new vector all of whose entries are initialised to zero. More...
| regina::NSVectorOrientedQuad::NSVectorOrientedQuad (const Vector< LargeInteger > &cloneMe)
| Creates a new vector that is a clone of the given vector. More...
static NormalSurfaceVector * | regina::NSVectorOrientedQuad::makeMirror (const Ray &original, const Triangulation< 3 > *triang)
virtual NormalSurfaceVector * | regina::NSVectorOrientedQuad::makeMirror (const Triangulation< 3 > *triang) const
| Creates a new mirror vector corresponding to this vector. More...
virtual const Vertex< 3 > * | regina::NSVectorOrientedQuad::isVertexLink (const Triangulation< 3 > *triang) const
| Determines if a rational multiple of the normal surface represented is the link of a single vertex. More...
virtual LargeInteger | regina::NSVectorOrientedQuad::quads (size_t tetIndex, int quadType, const Triangulation< 3 > *triang) const
| Returns the number of quadrilateral discs of the given type in this normal surface. More...
virtual LargeInteger | regina::NSVectorOrientedQuad::orientedQuads (size_t tetIndex, int quadType, const Triangulation< 3 > *triang, bool orientation) const
| Returns the number of oriented quadrilateral discs of the given type in this normal surface. More...
virtual LargeInteger | regina::NSVectorOrientedQuad::octs (size_t tetIndex, int octType, const Triangulation< 3 > *triang) const
| Returns the number of octagonal discs of the given type in this normal surface. More...
static NormalSurfaceVector * | regina::NSVectorOrientedQuad::makeZeroVector (const Triangulation< 3 > *triangulation)
static MatrixInt * | regina::NSVectorOrientedQuad::makeMatchingEquations (const Triangulation< 3 > *triangulation)
static EnumConstraints * | regina::NSVectorOrientedQuad::makeEmbeddedConstraints (const Triangulation< 3 > *triangulation)
| regina::NSVectorQuad::NSVectorQuad (size_t length)
| Creates a new vector all of whose entries are initialised to zero. More...
| regina::NSVectorQuad::NSVectorQuad (const Vector< LargeInteger > &cloneMe)
| Creates a new vector that is a clone of the given vector. More...
static NormalSurfaceVector * | regina::NSVectorQuad::makeMirror (const Ray &original, const Triangulation< 3 > *triang)
virtual NormalSurfaceVector * | regina::NSVectorQuad::makeMirror (const Triangulation< 3 > *triang) const
| Creates a new mirror vector corresponding to this vector. More...
virtual const Vertex< 3 > * | regina::NSVectorQuad::isVertexLink (const Triangulation< 3 > *triang) const
| Determines if a rational multiple of the normal surface represented is the link of a single vertex. More...
virtual LargeInteger | regina::NSVectorQuad::octs (size_t tetIndex, int octType, const Triangulation< 3 > *triang) const
| Returns the number of octagonal discs of the given type in this normal surface. More...
static NormalSurfaceVector * | regina::NSVectorQuad::makeZeroVector (const Triangulation< 3 > *triangulation)
static MatrixInt * | regina::NSVectorQuad::makeMatchingEquations (const Triangulation< 3 > *triangulation)
static EnumConstraints * | regina::NSVectorQuad::makeEmbeddedConstraints (const Triangulation< 3 > *triangulation)
| regina::NSVectorQuadOct::NSVectorQuadOct (size_t length)
| Creates a new vector all of whose entries are initialised to zero. More...
| regina::NSVectorQuadOct::NSVectorQuadOct (const Vector< LargeInteger > &cloneMe)
| Creates a new vector that is a clone of the given vector. More...
static NormalSurfaceVector * | regina::NSVectorQuadOct::makeMirror (const Ray &original, const Triangulation< 3 > *triang)
virtual NormalSurfaceVector * | regina::NSVectorQuadOct::makeMirror (const Triangulation< 3 > *triang) const
| Creates a new mirror vector corresponding to this vector. More...
virtual const Vertex< 3 > * | regina::NSVectorQuadOct::isVertexLink (const Triangulation< 3 > *triang) const
| Determines if a rational multiple of the normal surface represented is the link of a single vertex. More...
static NormalSurfaceVector * | regina::NSVectorQuadOct::makeZeroVector (const Triangulation< 3 > *triangulation)
static MatrixInt * | regina::NSVectorQuadOct::makeMatchingEquations (const Triangulation< 3 > *triangulation)
static EnumConstraints * | regina::NSVectorQuadOct::makeEmbeddedConstraints (const Triangulation< 3 > *triangulation)
| regina::NSVectorStandard::NSVectorStandard (size_t length)
| Creates a new vector all of whose entries are initialised to zero. More...
| regina::NSVectorStandard::NSVectorStandard (const Vector< LargeInteger > &cloneMe)
| Creates a new vector that is a clone of the given vector. More...
virtual LargeInteger | regina::NSVectorStandard::triangles (size_t tetIndex, int vertex, const Triangulation< 3 > *triang) const
| Returns the number of triangular discs of the given type in this normal surface. More...
virtual LargeInteger | regina::NSVectorStandard::quads (size_t tetIndex, int quadType, const Triangulation< 3 > *triang) const
| Returns the number of quadrilateral discs of the given type in this normal surface. More...
virtual LargeInteger | regina::NSVectorStandard::octs (size_t tetIndex, int octType, const Triangulation< 3 > *triang) const
| Returns the number of octagonal discs of the given type in this normal surface. More...
virtual LargeInteger | regina::NSVectorStandard::edgeWeight (size_t edgeIndex, const Triangulation< 3 > *triang) const
| Returns the number of times this normal surface crosses the given edge. More...
virtual LargeInteger | regina::NSVectorStandard::arcs (size_t triIndex, int triVertex, const Triangulation< 3 > *triang) const
| Returns the number of arcs in which this normal surface intersects the given triangle in the given direction. More...
static NormalSurfaceVector * | regina::NSVectorStandard::makeZeroVector (const Triangulation< 3 > *triangulation)
static MatrixInt * | regina::NSVectorStandard::makeMatchingEquations (const Triangulation< 3 > *triangulation)
static EnumConstraints * | regina::NSVectorStandard::makeEmbeddedConstraints (const Triangulation< 3 > *triangulation)
| regina::PrismSpec::PrismSpec ()
| Creates a new uninitialised prism specifier. More...
| regina::PrismSpec::PrismSpec (size_t newTetIndex, int newEdge)
| Creates a new prism specifier containing the given values. More...
| regina::PrismSpec::PrismSpec (const PrismSpec &cloneMe)
| Creates a new prism specifier that is a clone of the given specifier. More...
PrismSpec & | regina::PrismSpec::operator= (const PrismSpec &cloneMe)
| Copies the values from the given prism specifier into this specifier. More...
bool | regina::PrismSpec::operator== (const PrismSpec &other) const
| Determines if this and the given prism specifier contain identical information. More...
bool | regina::PrismSpec::operator!= (const PrismSpec &other) const
| Determines if this and the given prism specifier contain different information. More...
std::ostream & | regina::operator<< (std::ostream &out, const PrismSpec &spec)
| Writes the given prism specifier to the given output stream. More...
| regina::SurfaceFilter::SurfaceFilter ()
| Creates a new default surface filter. More...
| regina::SurfaceFilter::SurfaceFilter (const SurfaceFilter &cloneMe)
| Creates a new default surface filter. More...
virtual | regina::SurfaceFilter::~SurfaceFilter ()
| Destroys this surface filter. More...
virtual bool | regina::SurfaceFilter::accept (const NormalSurface &surface) const
| Decides whether or not the given normal surface is accepted by this filter. More...
virtual SurfaceFilterType | regina::SurfaceFilter::filterType () const
| Returns the unique integer ID corresponding to the filtering method that is this particular subclass of SurfaceFilter. More...
virtual std::string | regina::SurfaceFilter::filterTypeName () const
| Returns a string description of the filtering method that is this particular subclass of SurfaceFilter. More...
static XMLFilterReader * | regina::SurfaceFilter::xmlFilterReader (Packet *parent)
| Returns a newly created XML filter reader that will read the details of a particular type of surface filter. More...
virtual void | regina::SurfaceFilter::writeTextShort (std::ostream &out) const
| Writes a short text representation of this object to the given output stream. More...
static XMLPacketReader * | regina::SurfaceFilter::xmlReader (Packet *parent, XMLTreeResolver &resolver)
virtual bool | regina::SurfaceFilter::dependsOnParent () const
| Determines if this packet depends upon its parent. More...
virtual void | regina::SurfaceFilter::writeXMLFilterData (std::ostream &out) const
| Writes a chunk of XML containing the details of this filter. More...
virtual Packet * | regina::SurfaceFilter::internalClonePacket (Packet *parent) const
| Makes a newly allocated copy of this packet. More...
virtual void | regina::SurfaceFilter::writeXMLPacketData (std::ostream &out) const
| Writes a chunk of XML containing the data for this packet only. More...
| regina::SurfaceFilterCombination::SurfaceFilterCombination ()
| Creates a new surface filter that accepts all normal surfaces. More...
| regina::SurfaceFilterCombination::SurfaceFilterCombination (const SurfaceFilterCombination &cloneMe)
| Creates a new surface filter that is a clone of the given surface filter. More...
bool | regina::SurfaceFilterCombination::usesAnd () const
| Determines whether this is an and or an or combination. More...
void | regina::SurfaceFilterCombination::setUsesAnd (bool value)
| Sets whether this is an and or an or combination. More...
virtual bool | regina::SurfaceFilterCombination::accept (const NormalSurface &surface) const
| Decides whether or not the given normal surface is accepted by this filter. More...
virtual void | regina::SurfaceFilterCombination::writeTextLong (std::ostream &out) const
| Writes a detailed text representation of this object to the given output stream. More...
static XMLFilterReader * | regina::SurfaceFilterCombination::xmlFilterReader (Packet *parent)
virtual Packet * | regina::SurfaceFilterCombination::internalClonePacket (Packet *parent) const
| Makes a newly allocated copy of this packet. More...
virtual void | regina::SurfaceFilterCombination::writeXMLFilterData (std::ostream &out) const
| Writes a chunk of XML containing the details of this filter. More...
| regina::SurfaceFilterProperties::SurfaceFilterProperties ()
| Creates a new surface filter that accepts all normal surfaces. More...
| regina::SurfaceFilterProperties::SurfaceFilterProperties (const SurfaceFilterProperties &cloneMe)
| Creates a new surface filter that is a clone of the given surface filter. More...
const std::set< LargeInteger > & | regina::SurfaceFilterProperties::eulerChars () const
| Returns the set of allowable Euler characteristics. More...
size_t | regina::SurfaceFilterProperties::countEulerChars () const
| Returns the number of allowable Euler characteristics. More...
LargeInteger | regina::SurfaceFilterProperties::eulerChar (size_t index) const
| Returns the allowable Euler characteristic at the given index in the set. More...
BoolSet | regina::SurfaceFilterProperties::orientability () const
| Returns the set of allowable orientabilities. More...
BoolSet | regina::SurfaceFilterProperties::compactness () const
| Returns the set of allowable compactness properties. More...
BoolSet | regina::SurfaceFilterProperties::realBoundary () const
| Returns the set of allowable has-real-boundary properties. More...
void | regina::SurfaceFilterProperties::setEulerChars (const std::set< LargeInteger > &s)
| Sets the allowable Euler characteristics to the given set. More...
void | regina::SurfaceFilterProperties::addEulerChar (const LargeInteger &ec)
| Adds the given Euler characteristic to the set of allowable Euler characteristics. More...
void | regina::SurfaceFilterProperties::removeEulerChar (const LargeInteger &ec)
| Removes the given Euler characteristic from the set of allowable Euler characteristics. More...
void | regina::SurfaceFilterProperties::removeAllEulerChars ()
| Empties the set of allowable Euler characteristics. More...
void | regina::SurfaceFilterProperties::setOrientability (const BoolSet &value)
| Sets the set of allowable orientabilities. More...
void | regina::SurfaceFilterProperties::setCompactness (const BoolSet &value)
| Sets the set of allowable compactness properties. More...
void | regina::SurfaceFilterProperties::setRealBoundary (const BoolSet &value)
| Sets the set of allowable has-real-boundary properties. More...
virtual bool | regina::SurfaceFilterProperties::accept (const NormalSurface &surface) const
| Decides whether or not the given normal surface is accepted by this filter. More...
virtual void | regina::SurfaceFilterProperties::writeTextLong (std::ostream &out) const
| Writes a detailed text representation of this object to the given output stream. More...
static XMLFilterReader * | regina::SurfaceFilterProperties::xmlFilterReader (Packet *parent)
virtual Packet * | regina::SurfaceFilterProperties::internalClonePacket (Packet *parent) const
| Makes a newly allocated copy of this packet. More...
virtual void | regina::SurfaceFilterProperties::writeXMLFilterData (std::ostream &out) const
| Writes a chunk of XML containing the details of this filter. More...
| regina::XMLFilterReader::XMLFilterReader ()
| Creates a new filter element reader. More...
virtual SurfaceFilter * | regina::XMLFilterReader::filter ()
| Returns the newly allocated filter that has been read by this element reader. More...
| regina::XMLFilterPacketReader::XMLFilterPacketReader (Packet *newParent, XMLTreeResolver &resolver)
| Creates a new surface filter packet reader. More...
virtual Packet * | regina::XMLFilterPacketReader::packet () override
| Returns the newly allocated packet that has been read by this element reader. More...
virtual XMLElementReader * | regina::XMLFilterPacketReader::startContentSubElement (const std::string &subTagName, const regina::xml::XMLPropertyDict &subTagProps) override
| Used instead of startSubElement() for XML subelements that are not child packets or packet tags. More...
virtual void | regina::XMLFilterPacketReader::endContentSubElement (const std::string &subTagName, XMLElementReader *subReader) override
| Used instead of endSubElement() for XML subelements that are not child packets or packet tags. More...
| regina::XMLNormalSurfaceReader::XMLNormalSurfaceReader (const Triangulation< 3 > *newTri, NormalCoords newCoords)
| Creates a new normal surface reader. More...
NormalSurface * | regina::XMLNormalSurfaceReader::surface ()
| Returns the normal surface that has been read. More...
virtual void | regina::XMLNormalSurfaceReader::startElement (const std::string &tagName, const regina::xml::XMLPropertyDict &tagProps, XMLElementReader *parentReader)
| Signifies that parsing of this XML element is beginning. More...
virtual void | regina::XMLNormalSurfaceReader::initialChars (const std::string &chars)
| Signifies that the initial text belonging to this XML element has been read. More...
virtual XMLElementReader * | regina::XMLNormalSurfaceReader::startSubElement (const std::string &subTagName, const regina::xml::XMLPropertyDict &subTagProps)
| Signifies that a subelement of this XML element is about to be parsed. More...
| regina::XMLNormalSurfacesReader::XMLNormalSurfacesReader (const Triangulation< 3 > *newTri, XMLTreeResolver &resolver)
| Creates a new normal surface list reader. More...
virtual Packet * | regina::XMLNormalSurfacesReader::packet () override
| Returns the newly allocated packet that has been read by this element reader. More...
virtual XMLElementReader * | regina::XMLNormalSurfacesReader::startContentSubElement (const std::string &subTagName, const regina::xml::XMLPropertyDict &subTagProps) override
| Used instead of startSubElement() for XML subelements that are not child packets or packet tags. More...
virtual void | regina::XMLNormalSurfacesReader::endContentSubElement (const std::string &subTagName, XMLElementReader *subReader) override
| Used instead of endSubElement() for XML subelements that are not child packets or packet tags. More...

## Variables

size_t | regina::DiscSpec::tetIndex
| The index in the triangulation of the tetrahedron containing the disc. More...
int | regina::DiscSpec::type
| The disc type; this is between 0 and 9 inclusive, as described in the DiscSpec class notes. More...
unsigned long | regina::DiscSpec::number
| Specifies which disc of the particular type in the particular tetrahedron is being referred to; discs are numbered as described in the DiscSpec class notes. More...
unsigned long | regina::DiscSetTet::internalNDiscs [10]
| The number of discs of each type. More...
DataPtr | regina::DiscSetTetData< T >::internalData [10]
| Stores the data corresponding to each normal disc. More...
DiscSetTet ** | regina::DiscSetSurface::discSets
| The disc sets corresponding to each tetrahedron. More...
const Triangulation< 3 > * | regina::DiscSetSurface::triangulation
| The triangulation in which the normal surface lives. More...
const DiscSetSurface * | regina::DiscSpecIterator::internalDiscSet
| The disc set through which we are iterating. More...
DiscSpec | regina::DiscSpecIterator::current
| The disc currently pointed to. More...
static const DiscType | regina::DiscType::NONE
| Represents a "null" disc type. More...
size_t | regina::DiscType::tetIndex
| The index within the triangulation of the tetrahedron containing this disc type. More...
int | regina::DiscType::type
| Identifies the disc type within the specified tetrahedron. 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...
Ray | regina::NormalSurfaceVector::coords_
| The raw vector of normal coordinates. More...
NormalSurfaceVector * | regina::NormalSurface::vector
| Contains the coordinates of the normal surface in whichever space is appropriate. More...
const Triangulation< 3 > * | regina::NormalSurface::triangulation_
| The triangulation in which this normal surface resides. More...
std::string | regina::NormalSurface::name_
| An optional name associated with this surface. More...
Property< DiscType > | regina::NormalSurface::octPosition_
| The position of the first non-zero octagonal coordinate, or DiscType::NONE if there is no non-zero octagonal coordinate. More...
Property< LargeInteger > | regina::NormalSurface::eulerChar_
| The Euler characteristic of this surface. More...
Property< bool > | regina::NormalSurface::orientable
| Is this surface orientable? More...
Property< bool > | regina::NormalSurface::twoSided
| Is this surface two-sided? More...
Property< bool > | regina::NormalSurface::connected
| Is this surface connected? More...
Property< bool > | regina::NormalSurface::realBoundary
| Does this surface have real boundary (i.e. More...
Property< bool > | regina::NormalSurface::compact
| Is this surface compact (i.e. More...
std::vector< NormalSurface * > | regina::NormalSurfaces::surfaces
| Contains the normal surfaces stored in this packet. More...
NormalCoords | regina::NormalSurfaces::coords_
| Stores which coordinate system is being used by the normal surfaces in this packet. More...
NormalList | regina::NormalSurfaces::which_
| Indicates which normal surfaces these represent within the underlying triangulation. More...
NormalAlg | regina::NormalSurfaces::algorithm_
| Stores the details of the enumeration algorithm that was used to generate this list. More...
NormalSurfaces * | regina::NormalSurfaces::SurfaceInserter::list
| The list into which surfaces will be inserted. More...
Triangulation< 3 > * | regina::NormalSurfaces::SurfaceInserter::owner
| The triangulation in which the surfaces to be inserted are contained. More...
size_t | regina::PrismSpec::tetIndex
| The index in the triangulation of the tetrahedron containing the prism. More...
int | regina::PrismSpec::edge
| The edge of the tetrahedron that is contained in this prism. More...

## Friends

class | regina::NormalSurface::XMLNormalSurfaceReader
class | regina::NormalSurfaces::VectorIterator::NormalSurfaces
class | regina::NormalSurfaces::XMLNormalSurfacesReader
std::ostream & | regina::DiscSpec::operator<< (std::ostream &out, const DiscSpec &spec)
| Writes the given disc specifier to the given output stream. More...
std::ostream & | regina::PrismSpec::operator<< (std::ostream &out, const PrismSpec &spec)
| Writes the given prism 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 { \
return new class_(*this); \
} \
inline virtual bool allowsAlmostNormal() const { \
return Info::almostNormal; \
} \
inline virtual bool allowsSpun() const { \
return Info::spun; \
} \
inline virtual bool allowsOriented() const { \
return Info::oriented; \
}

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.
  id | the corresponding NNormalCoords constant.
  superclass | the vector class from which class_ is derived. This is typically NormalSurfaceVector, though in some cases it may be different (e.g., NSVectorMirrored).

## REGINA_SURFACE_FILTER

#define REGINA_SURFACE_FILTER | ( |  | class_,
|  |  | id
| ) |  |

Value:
public: \
static constexpr const SurfaceFilterType filterTypeID = id; \
inline virtual SurfaceFilterType filterType() const { \
return id; \
} \
inline virtual std::string filterTypeName() const { \
return SurfaceFilterInfo<id>::name(); \
}

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.
  id | the 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

typedef DiscSetSurface regina::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

typedef DiscSetTet regina::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

typedef DiscSpec regina::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

typedef DiscType regina::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

typedef NormalSurface regina::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

typedef NormalSurfaces regina::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

typedef NormalSurfaceVector regina::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

typedef NSVectorANStandard regina::NNormalSurfaceVectorANStandard

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.

## NNormalSurfaceVectorMirrored

typedef NSVectorMirrored regina::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

typedef NSVectorOriented regina::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

typedef NSVectorOrientedQuad regina::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

typedef NSVectorQuad regina::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

typedef NSVectorQuadOct regina::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

typedef NSVectorStandard regina::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

typedef regina::Flags<NormalAlgFlags> regina::NormalAlg

A combination of flags for types of normal surface lists.

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

## NormalList

typedef regina::Flags<NormalListFlags> regina::NormalList

A combination of flags for types of normal surface lists.

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

## NPrismSpec

typedef PrismSpec regina::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

typedef SurfaceFilter regina::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

typedef SurfaceFilterCombination regina::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

typedef SurfaceFilterProperties regina::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

enum regina::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:\n 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

enum regina::NormalCoords

Represents different coordinate systems that can be used for enumerating and displaying normal surfaces.

IDs 0-9999 are reserved for future use by Regina. If you are extending Regina to include your own coordinate system, you should choose an ID >= 10000.

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_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_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

enum regina::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:\n 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

enum regina::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

enum regina::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

## accept() [1/3]

bool regina::SurfaceFilter::accept | ( | const NormalSurface & | surface | ) | const

inline virtual

Decides whether or not the given normal surface is accepted by this filter.

The default implementation simply returns `true`.

Parameters

  surface | the normal surface under investigation.

Returns
  `true` if and only if the given surface is accepted by this filter.

Reimplemented in regina::SurfaceFilterProperties, and regina::SurfaceFilterCombination.

## accept() [2/3]

virtual bool regina::SurfaceFilterCombination::accept | ( | const NormalSurface & | surface | ) | const

virtual

Decides whether or not the given normal surface is accepted by this filter.

The default implementation simply returns `true`.

Parameters

  surface | the normal surface under investigation.

Returns
  `true` if and only if the given surface is accepted by this filter.

Reimplemented from regina::SurfaceFilter.

## accept() [3/3]

virtual bool regina::SurfaceFilterProperties::accept | ( | const NormalSurface & | surface | ) | const

virtual

Decides whether or not the given normal surface is accepted by this filter.

The default implementation simply returns `true`.

Parameters

  surface | the normal surface under investigation.

Returns
  `true` if and only if the given surface is accepted by this filter.

Reimplemented from regina::SurfaceFilter.

## addEulerChar()

void regina::SurfaceFilterProperties::addEulerChar | ( | const LargeInteger & | ec | ) |

inline

Adds the given Euler characteristic to the set of allowable Euler characteristics.

See eulerChars() for further details.

Parameters

  ec | the new allowable Euler characteristic.

## 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

  disc | the given normal disc; this must be a disc in this disc set.
  arc | the given normal arc; this must actually be an arc on the boundary of the given normal disc (although it may run in either direction).
  adjArc | returns the same directed normal arc that was passed, but expressed in terms of the vertices of the adjacent tetrahedron. Any value may be initially passed. If there is no adjacent disc/tetrahedron, this permutation will remain unchanged.

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.

## algorithm()

NormalAlg regina::NormalSurfaces::algorithm | ( |  | ) | const

inline

Returns details of the algorithm that was used to enumerate this list.

These may not be the same NormalAlg flags that were passed to enumerate(). In particular, default values will have been explicitly filled in, invalid and/or redundant values will have been removed, and unavailable and/or unsupported combinations of algorithm flags will be replaced with whatever algorithm was actually used.

Returns
  details of the algorithm used to enumerate this list.

## allowsAlmostNormal() [1/2]

bool regina::NormalSurfaces::allowsAlmostNormal | ( |  | ) | const

Determines if the coordinate system being used allows for almost normal surfaces, that is, allows for octagonal discs.

Returns
  `true` if and only if almost normal surfaces are allowed.

## allowsAlmostNormal() [2/2]

virtual bool regina::NormalSurfaceVector::allowsAlmostNormal | ( |  | ) | const

pure virtual

Determines if the specific underlying coordinate system allows for almost normal surfaces, that is, allows for octagonal discs.

Note that this has nothing to do with whether or not this specific surface contains octagonal discs.

Returns
  `true` if and only if almost normal surfaces are allowed.

## allowsOriented() [1/2]

bool regina::NormalSurfaces::allowsOriented | ( |  | ) | const

Determines if the coordinate system being used allows for transversely oriented normal surfaces.

Returns
  `true` if and only if transverse orientations are supported.

## allowsOriented() [2/2]

virtual bool regina::NormalSurfaceVector::allowsOriented | ( |  | ) | const

pure virtual

Determines if the specific underlying coordinate system allows for transversely oriented normal surfaces.

Returns
  `true` if and only if transverse orientations are supported.

## allowsSpun() [1/2]

bool regina::NormalSurfaces::allowsSpun | ( |  | ) | const

Determines if the coordinate system being used allows for spun normal surfaces.

Returns
  `true` if and only if spun normal surface are supported.

## allowsSpun() [2/2]

virtual bool regina::NormalSurfaceVector::allowsSpun | ( |  | ) | const

pure virtual

Determines if the specific underlying coordinate system allows for spun-normal surfaces; that is, surfaces with infinitely many triangles.

Note that this has nothing to do with whether or not this specific surface contains infinitely many triangles.

Returns
  `true` if and only if spun-normal surfaces are allowed.

## 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

  arcFace | the face of this tetrahedron containing the normal arc (between 0 and 3 inclusive).
  arcVertex | the vertex of this tetrahedron about which the normal arc runs (between 0 and 3 inclusive); arcFace and arcVertex should not be the same.
  discType | the disc type of the given normal disc; this should be between 0 and 9 inclusive, as described in the DiscSpec class notes.
  discNumber | indicates which normal disc of the given disc type is referred to (between 0 and `nDiscs(discType)-1` inclusive).

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.

## arcs() [1/6]

LargeInteger regina::NormalSurface::arcs | ( | size_t | triIndex,
|  | int | triVertex
| ) |  | const

inline

Returns the number of arcs in which this normal surface intersects the given triangle in the given direction.

Parameters

  triIndex | the index in the triangulation of the triangle in which we are interested; this should be between 0 and Triangulation<3>::countTriangles()-1 inclusive.
  triVertex | the vertex of the triangle (0, 1 or 2) around which the arcs of intersection that we are interested in lie; only these arcs will be counted.

Returns
  the number of times this normal surface intersect the given triangle with the given arc type.

## arcs() [2/6]

virtual LargeInteger regina::NSVectorStandard::arcs | ( | size_t | triIndex,
|  | int | triVertex,
|  | const Triangulation< 3 > * | triang
| ) |  | const

virtual

Returns the number of arcs in which this normal surface intersects the given triangle in the given direction.

See NormalSurface::arcs() for further details.

Parameters

  triIndex | the index in the triangulation of the triangle in which we are interested; this should be between 0 and Triangulation<3>::countTriangles()-1 inclusive.
  triVertex | the vertex of the triangle (0, 1 or 2) around which the arcs of intersection that we are interested in lie; only these arcs will be counted.
  triang | the triangulation in which this normal surface lives.

Returns
  the number of times this normal surface intersect the given triangle with the given arc type.

Implements regina::NormalSurfaceVector.

## arcs() [3/6]

virtual LargeInteger regina::NSVectorANStandard::arcs | ( | size_t | triIndex,
|  | int | triVertex,
|  | const Triangulation< 3 > * | triang
| ) |  | const

virtual

Returns the number of arcs in which this normal surface intersects the given triangle in the given direction.

See NormalSurface::arcs() for further details.

Parameters

  triIndex | the index in the triangulation of the triangle in which we are interested; this should be between 0 and Triangulation<3>::countTriangles()-1 inclusive.
  triVertex | the vertex of the triangle (0, 1 or 2) around which the arcs of intersection that we are interested in lie; only these arcs will be counted.
  triang | the triangulation in which this normal surface lives.

Returns
  the number of times this normal surface intersect the given triangle with the given arc type.

Implements regina::NormalSurfaceVector.

## arcs() [4/6]

virtual LargeInteger regina::NSVectorOriented::arcs | ( | size_t | triIndex,
|  | int | triVertex,
|  | const Triangulation< 3 > * | triang
| ) |  | const

virtual

Returns the number of arcs in which this normal surface intersects the given triangle in the given direction.

See NormalSurface::arcs() for further details.

Parameters

  triIndex | the index in the triangulation of the triangle in which we are interested; this should be between 0 and Triangulation<3>::countTriangles()-1 inclusive.
  triVertex | the vertex of the triangle (0, 1 or 2) around which the arcs of intersection that we are interested in lie; only these arcs will be counted.
  triang | the triangulation in which this normal surface lives.

Returns
  the number of times this normal surface intersect the given triangle with the given arc type.

Implements regina::NormalSurfaceVector.

## arcs() [5/6]

virtual LargeInteger regina::NormalSurfaceVector::arcs | ( | size_t | triIndex,
|  | int | triVertex,
|  | const Triangulation< 3 > * | triang
| ) |  | const

pure virtual

Returns the number of arcs in which this normal surface intersects the given triangle in the given direction.

See NormalSurface::arcs() for further details.

Parameters

  triIndex | the index in the triangulation of the triangle in which we are interested; this should be between 0 and Triangulation<3>::countTriangles()-1 inclusive.
  triVertex | the vertex of the triangle (0, 1 or 2) around which the arcs of intersection that we are interested in lie; only these arcs will be counted.
  triang | the triangulation in which this normal surface lives.

Returns
  the number of times this normal surface intersect the given triangle with the given arc type.

Implemented in regina::NSVectorMirrored, regina::NSVectorOriented, regina::NSVectorANStandard, and regina::NSVectorStandard.

## arcs() [6/6]

LargeInteger regina::NSVectorMirrored::arcs | ( | size_t | triIndex,
|  | int | triVertex,
|  | const Triangulation< 3 > * | triang
| ) |  | const

inline override virtual

Returns the number of arcs in which this normal surface intersects the given triangle in the given direction.

See NormalSurface::arcs() for further details.

Parameters

  triIndex | the index in the triangulation of the triangle in which we are interested; this should be between 0 and Triangulation<3>::countTriangles()-1 inclusive.
  triVertex | the vertex of the triangle (0, 1 or 2) around which the arcs of intersection that we are interested in lie; only these arcs will be counted.
  triang | the triangulation in which this normal surface lives.

Returns
  the number of times this normal surface intersect the given triangle with the given arc type.

Implements regina::NormalSurfaceVector.

## beginVectors()

NormalSurfaces::VectorIterator regina::NormalSurfaces::beginVectors | ( |  | ) | const

inline

An iterator that gives access to the raw vectors for surfaces in this list, pointing to the beginning of this surface list.

Python:\n Not present.

Returns
  an iterator at the beginning of this surface list.

## boundaryIntersections()

MatrixInt* regina::NormalSurface::boundaryIntersections | ( |  | ) | const

Computes the information about the boundary slopes of this surface at each cusp of the triangulation.

This is for use with spun-normal surfaces (since for closed surfaces all boundary slopes are zero).

This routine is only available for use with SnapPea triangulations, since it needs to know the specific meridian and longitude on each cusp. This information is only available through the SnapPea kernel, since Regina does not use or store peripheral curves for its own Triangulation<3> class. Therefore, if the underlying triangulation (as returned by triangulation()) is not of the subclass SnapPeaTriangulation, this routine will simply return 0.

All cusps are treated as complete. That is, any Dehn fillings stored in the SnapPea triangulation will be ignored.

The results are returned in a matrix with V rows and two columns, where V is the number of vertices in the triangulation. If row i of the matrix contains the integers M and L, this indicates that at the ith cusp, the boundary curves have algebraic intersection number M with the meridian and L with the longitude. Equivalently, the boundary curves pass L times around the meridian and -M times around the longitude. The rational boundary slope is therefore `-L/M`, and there are `gcd(L,M)` boundary curves with this slope.

The orientations of the boundary curves of a spun-normal surface are chosen so that if meridian and longitude are a positive basis as vieved from the cusp, then as one travels along an oriented boundary curve, the spun-normal surface spirals into the cusp to one's right and down into the manifold to one's left.

If the triangulation contains more than one vertex, the rows in the resulting matrix are ordered by cusp index (as stored by SnapPea). You can call SnapPeaTriangulation::cuspVertex() to map these to Regina's vertex indices if needed.

At present, Regina can only compute boundary slopes if the triangulation is oriented, if every vertex link in the triangulation is a torus, and if the underlying coordinate system is for normal surfaces (not almost normal surfaces). If these conditions are not met, this routine will return 0.

Author
  William Pettersson and Stephan Tillmann

Returns
  a newly allocated matrix with number_of_vertices rows and two columns as described above, or 0 if the boundary slopes cannot be computed (e.g., if the underlying triangulation is not of type SnapPeaTriangulation, or if it fails to meet the preconditions outlined above).

## calculateEulerChar()

void regina::NormalSurface::calculateEulerChar | ( |  | ) | const

protected

Calculates the Euler characteristic of this surface and stores it as a property.

Precondition
  This normal surface is compact (has finitely many discs).

## calculateOctPosition()

void regina::NormalSurface::calculateOctPosition | ( |  | ) | const

protected

Calculates the position of the first non-zero octagon coordinate and stores it as a property.

## calculateOrientable()

void regina::NormalSurface::calculateOrientable | ( |  | ) | const

protected

Calculates whether this surface is orientable and/or two-sided and stores the results as properties.

Precondition
  This normal surface is compact (has finitely many discs).

## calculateRealBoundary()

void regina::NormalSurface::calculateRealBoundary | ( |  | ) | const

protected

Calculates whether this surface has any real boundary and stores the result as a property.

## clone() [1/2]

NormalSurface* regina::NormalSurface::clone | ( |  | ) | const

Creates a newly allocated clone of this normal surface.

The name of the normal surface will not be copied to the clone; instead the clone will have an empty name.

Returns
  a clone of this normal surface.

## clone() [2/2]

virtual NormalSurfaceVector* regina::NormalSurfaceVector::clone | ( |  | ) | const

pure virtual

Creates a newly allocated clone of this vector.

The clone will be of the same subclass of NormalSurfaceVector as this vector.

## compactness()

BoolSet regina::SurfaceFilterProperties::compactness | ( |  | ) | const

inline

Returns the set of allowable compactness properties.

Note that this is a subset of `{ true, false }`. Any surface whose compactness property is not in this set will not be accepted by this filter.

Returns
  the set of allowable compactness properties.

## coords() [1/2]

NormalCoords regina::NormalSurfaces::coords | ( |  | ) | const

inline

Returns the coordinate system being used by the surfaces stored in this set.

Returns
  the coordinate system used.

## coords() [2/2]

const Ray & regina::NormalSurfaceVector::coords | ( |  | ) | const

inline

Gives read-only access to the underlying vector of coordinates.

Returns
  the vector of coordinates.

## countCoords()

size_t regina::NormalSurface::countCoords | ( |  | ) | const

inline

Returns the number of coordinates in the specific underlying coordinate system being used.

Returns
  the number of coordinates.

## countEulerChars()

size_t regina::SurfaceFilterProperties::countEulerChars | ( |  | ) | const

inline

Returns the number of allowable Euler characteristics.

See eulerChars() for further details.

Returns
  the number of allowable Euler characteristics.

## crush()

Triangulation<3>* regina::NormalSurface::crush | ( |  | ) | const

Crushes this surface to a point in the associated triangulation and returns a newly created resulting triangulation.

The original triangulation is not changed.

Crushing the surface will produce a number of tetrahedra, triangular pillows and/or footballs. The pillows and footballs will then be flattened to triangles and edges respectively (resulting in the possible changes mentioned below) to produce a proper triangulation.

Note that the new triangulation will have at most the same number of tetrahedra as the old triangulation, and will have strictly fewer tetrahedra if this surface is not vertex linking.

The act of flattening pillows and footballs as described above can lead to unintended topological side-effects, beyond the effects of merely cutting along this surface and identifying the new boundary surface(s) to points. Examples of these unintended side-effects can include connected sum decompositions, removal of 3-spheres and small Lens spaces and so on; a full list of possible changes is beyond the scope of this API documentation.

Warning
  This routine can have unintended topological side-effects, as described above.
  In exceptional cases with non-orientable 3-manifolds, these side-effects might lead to invalid edges (edges whose midpoints are projective plane cusps).

Precondition
  This normal surface is compact and embedded.
  This normal surface contains no octagonal discs.

Returns
  a pointer to the newly allocated resulting triangulation.

## cutAlong()

Triangulation<3>* regina::NormalSurface::cutAlong | ( |  | ) | const

Cuts the associated triangulation along this surface and returns a newly created resulting triangulation.

The original triangulation is not changed.

Note that, unlike crushing a surface to a point, this operation will not change the topology of the underlying 3-manifold beyond simply slicing along this surface.

Warning
  The number of tetrahedra in the new triangulation can be very large.

Precondition
  This normal surface is compact and embedded.
  This normal surface contains no octagonal discs.

Returns
  a pointer to the newly allocated resulting triangulation.

## data() [1/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

  disc | the 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.

## data() [2/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

  discType | the disc type of the given normal disc; this should be between 0 and 9 inclusive, as described in the DiscSpec class notes.
  discNumber | indicates which normal disc of the given disc type is referred to; this should be between 0 and `nDiscs(discType)-1` inclusive.

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

## dependsOnParent() [1/2]

bool regina::SurfaceFilter::dependsOnParent | ( |  | ) | const

inline virtual

Determines if this packet depends upon its parent.

This is true if the parent cannot be altered without invalidating or otherwise upsetting this packet.

Returns
  `true` if and only if this packet depends on its parent.

Implements regina::Packet.

## dependsOnParent() [2/2]

bool regina::NormalSurfaces::dependsOnParent | ( |  | ) | const

inline virtual

Determines if this packet depends upon its parent.

This is true if the parent cannot be altered without invalidating or otherwise upsetting this packet.

Returns
  `true` if and only if this packet depends on its parent.

Implements regina::Packet.

## 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

  arcFace | the face of this tetrahedron containing the normal arc (between 0 and 3 inclusive).
  arcVertex | the vertex of this tetrahedron about which the normal arc runs (between 0 and 3 inclusive); arcFace and arcVertex should not be the same.
  arcNumber | indicates which normal arc of the given type is referred to. Arcs of a given type (where arcFace and arcVertex together define the arc type) are numbered starting at 0 from the tetrahedron vertex outwards.
  discType | returns the disc type of the normal disc that meets the given normal arc; this will be between 0 and 9 inclusive, as described in the DiscSpec class notes. Any value may be initially passed.
  discNumber | returns a number that indicates which normal disc of the returned disc type (`discType`) meets the given normal arc; this will be between 0 and `nDiscs(discType)-1` inclusive. Any value may be initially passed.

## 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

  discType | the normal disc type under consideration; this should be between 0 and 9 inclusive, as described by the DiscSpec class notes.
  vertex | the vertex about which the normal arc runs.
  edgeStart | the start vertex of the edge to which the normal arc is parallel.
  edgeEnd | the end vertex of the edge to which the normal arc is parallel.

## DiscSetSurface() [1/2]

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

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

Parameters

  surface | the normal surface whose discs we shall use.

## DiscSetSurface() [2/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

  surface | the normal surface whose discs we shall use.
  b | this parameter is ignored.

## 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

  surface | the 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

  surface | the normal surface whose discs we shall use.
  initValue | the 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

  surface | the normal surface whose discs we shall use.
  tetIndex | the index in the triangulation of the tetrahedron that our discs must lie in; this must be between 0 and `tri.size()-1` inclusive, where `tri` is the triangulation containing the given normal surface.

## 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

  tri0 | the number of triangular discs surrounding vertex 0.
  tri1 | the number of triangular discs surrounding vertex 1.
  tri2 | the number of triangular discs surrounding vertex 2.
  tri3 | the number of triangular discs surrounding vertex 3.
  quad0 | the number of quadrilateral discs of type 0.
  quad1 | the number of quadrilateral discs of type 1.
  quad2 | the number of quadrilateral discs of type 2.
  oct0 | the number of octahedral discs of type 0.
  oct1 | the number of octahedral discs of type 1.
  oct2 | the number of octahedral discs of type 2.

## 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

  surface | the normal surface whose discs we shall use.
  tetIndex | the index in the triangulation of the tetrahedron that our discs must lie in; this must be between 0 and `tri.size()-1` inclusive, where `tri` is the triangulation containing the given normal surface.

## 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

  surface | the normal surface whose discs we shall use.
  tetIndex | the index in the triangulation of the tetrahedron that our discs must lie in; this must be between 0 and `tri.size()-1` inclusive, where `tri` is the triangulation containing the given normal surface.
  initValue | the value with which to initialise the data corresponding to each disc.

## 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

  tri0 | the number of triangular discs surrounding vertex 0.
  tri1 | the number of triangular discs surrounding vertex 1.
  tri2 | the number of triangular discs surrounding vertex 2.
  tri3 | the number of triangular discs surrounding vertex 3.
  quad0 | the number of quadrilateral discs of type 0.
  quad1 | the number of quadrilateral discs of type 1.
  quad2 | the number of quadrilateral discs of type 2.
  oct0 | the number of octahedral discs of type 0.
  oct1 | the number of octahedral discs of type 1.
  oct2 | the number of octahedral discs of type 2.

## DiscSpec() [1/3]

regina::DiscSpec::DiscSpec | ( |  | ) |

inline

Creates a new uninitialised disc specifier.

## DiscSpec() [2/3]

regina::DiscSpec::DiscSpec | ( | const DiscSpec & | cloneMe | ) |

inline

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

Parameters

  cloneMe | the disc specifier to clone.

## DiscSpec() [3/3]

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

inline

Creates a new disc specifier containing the given values.

Parameters

  newTetIndex | the index in the triangulation of the tetrahedron containing the disc.
  newType | the disc type; this is between 0 and 9 inclusive, as described in the DiscSpec class notes.
  newNumber | specifies which disc of the particular type in the particular tetrahedron is being referred to; discs are numbered as described in the DiscSpec class notes.

## DiscSpecIterator() [1/2]

regina::DiscSpecIterator::DiscSpecIterator | ( |  | ) |

inline

Creates a new uninitialised iterator.

This iterator cannot be used or queried until init() is called.

## DiscSpecIterator() [2/2]

regina::DiscSpecIterator::DiscSpecIterator | ( | const DiscSetSurface & | discSet | ) |

inline

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

Parameters

  discSet | the disc set used to initialise this iterator.

## DiscType() [1/3]

regina::DiscType::DiscType | ( |  | ) |

inline

Creates a new disc type initialised to NONE.

## DiscType() [2/3]

regina::DiscType::DiscType | ( | const DiscType & | cloneMe | ) |

inline

Creates a copy of the given disc type.

Parameters

  cloneMe | the disc type to clone.

## DiscType() [3/3]

regina::DiscType::DiscType | ( | size_t | newTetIndex,
|  | int | newType
| ) |  |

inline

Creates a new disc type initialised with the given values.

Parameters

  newTetIndex | the index within the triangulation of the tetrahedron containing this disc type.
  newType | the specific disc type within the given tetrahedron; see the class notes for the meaning of this field.

## disjoint()

bool regina::NormalSurface::disjoint | ( | const NormalSurface & | other | ) | const

Determines whether this and the given surface can be placed within the surrounding triangulation so that they do not intersect anywhere at all, without changing either normal isotopy class.

This is a global constraint, and therefore gives a stronger test than locallyCompatible(). However, this global constraint is also much slower to test; the running time is proportional to the total number of normal discs in both surfaces.

Note that this routine has a number of preconditions. Most importantly, it will only work if both this and the given surface use the same coordinate system. Running this test over two surfaces with different coordinate systems could give unpredictable results, and might crash the program entirely.

Precondition
  Both this and the given normal surface live within the same 3-manifold triangulation.
  Both this and the given normal surface are stored using the same coordinate system (i.e., the same subclass of NormalSurfaceVector).
  Both this and the given surface are compact (have finitely many discs), embedded, non-empty and connected.

Parameters

  other | the other surface to test alongside this surface for potential intersections.

Returns
  `true` if both surfaces can be embedded without intersecting anywhere, or `false` if this and the given surface are forced to intersect at some point.

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

## doubleSurface()

NormalSurface* regina::NormalSurface::doubleSurface | ( |  | ) | const

Creates a newly allocated surface that is the double of this surface.

Returns
  the double of this normal surface.

## edgeWeight() [1/6]

LargeInteger regina::NormalSurface::edgeWeight | ( | size_t | edgeIndex | ) | const

inline

Returns the number of times this normal surface crosses the given edge.

Parameters

  edgeIndex | the index in the triangulation of the edge in which we are interested; this should be between 0 and Triangulation<3>::countEdges()-1 inclusive.

Returns
  the number of times this normal surface crosses the given edge.

## edgeWeight() [2/6]

virtual LargeInteger regina::NSVectorStandard::edgeWeight | ( | size_t | edgeIndex,
|  | const Triangulation< 3 > * | triang
| ) |  | const

virtual

Returns the number of times this normal surface crosses the given edge.

See NormalSurface::edgeWeight() for further details.

Parameters

  edgeIndex | the index in the triangulation of the edge in which we are interested; this should be between 0 and Triangulation<3>::countEdges()-1 inclusive.
  triang | the triangulation in which this normal surface lives.

Returns
  the number of times this normal surface crosses the given edge.

Implements regina::NormalSurfaceVector.

## edgeWeight() [3/6]

virtual LargeInteger regina::NSVectorANStandard::edgeWeight | ( | size_t | edgeIndex,
|  | const Triangulation< 3 > * | triang
| ) |  | const

virtual

Returns the number of times this normal surface crosses the given edge.

See NormalSurface::edgeWeight() for further details.

Parameters

  edgeIndex | the index in the triangulation of the edge in which we are interested; this should be between 0 and Triangulation<3>::countEdges()-1 inclusive.
  triang | the triangulation in which this normal surface lives.

Returns
  the number of times this normal surface crosses the given edge.

Implements regina::NormalSurfaceVector.

## edgeWeight() [4/6]

virtual LargeInteger regina::NSVectorOriented::edgeWeight | ( | size_t | edgeIndex,
|  | const Triangulation< 3 > * | triang
| ) |  | const

virtual

Returns the number of times this normal surface crosses the given edge.

See NormalSurface::edgeWeight() for further details.

Parameters

  edgeIndex | the index in the triangulation of the edge in which we are interested; this should be between 0 and Triangulation<3>::countEdges()-1 inclusive.
  triang | the triangulation in which this normal surface lives.

Returns
  the number of times this normal surface crosses the given edge.

Implements regina::NormalSurfaceVector.

## edgeWeight() [5/6]

virtual LargeInteger regina::NormalSurfaceVector::edgeWeight | ( | size_t | edgeIndex,
|  | const Triangulation< 3 > * | triang
| ) |  | const

pure virtual

Returns the number of times this normal surface crosses the given edge.

See NormalSurface::edgeWeight() for further details.

Parameters

  edgeIndex | the index in the triangulation of the edge in which we are interested; this should be between 0 and Triangulation<3>::countEdges()-1 inclusive.
  triang | the triangulation in which this normal surface lives.

Returns
  the number of times this normal surface crosses the given edge.

Implemented in regina::NSVectorMirrored, regina::NSVectorOriented, regina::NSVectorANStandard, and regina::NSVectorStandard.

## edgeWeight() [6/6]

LargeInteger regina::NSVectorMirrored::edgeWeight | ( | size_t | edgeIndex,
|  | const Triangulation< 3 > * | triang
| ) |  | const

inline override virtual

Returns the number of times this normal surface crosses the given edge.

See NormalSurface::edgeWeight() for further details.

Parameters

  edgeIndex | the index in the triangulation of the edge in which we are interested; this should be between 0 and Triangulation<3>::countEdges()-1 inclusive.
  triang | the triangulation in which this normal surface lives.

Returns
  the number of times this normal surface crosses the given edge.

Implements regina::NormalSurfaceVector.

## embedded()

bool regina::NormalSurface::embedded | ( |  | ) | const

Determines whether this surface is embedded.

This is true if and only if the surface contains no conflicting quadrilateral and/or octagon types.

Returns
  `true` if and only if this surface is embedded.

## endContentSubElement() [1/2]

virtual void regina::XMLFilterPacketReader::endContentSubElement | ( | const std::string & | subTagName,
|  | XMLElementReader * | subReader
| ) |  |

override virtual

Used instead of endSubElement() for XML subelements that are not child packets or packet tags.

The default implementation does nothing.

Parameters

  subTagName | the name of the subelement closing tag.
  subReader | the child reader that was used to parse the subelement (this is the reader that was returned by the corresponding startContentSubElement() call). It is guaranteed that endElement() has already been called upon this child reader and that the child reader has not yet been destroyed.

Reimplemented from regina::XMLPacketReader.

## endContentSubElement() [2/2]

virtual void regina::XMLNormalSurfacesReader::endContentSubElement | ( | const std::string & | subTagName,
|  | XMLElementReader * | subReader
| ) |  |

override virtual

Used instead of endSubElement() for XML subelements that are not child packets or packet tags.

The default implementation does nothing.

Parameters

  subTagName | the name of the subelement closing tag.
  subReader | the child reader that was used to parse the subelement (this is the reader that was returned by the corresponding startContentSubElement() call). It is guaranteed that endElement() has already been called upon this child reader and that the child reader has not yet been destroyed.

Reimplemented from regina::XMLPacketReader.

## endVectors()

NormalSurfaces::VectorIterator regina::NormalSurfaces::endVectors | ( |  | ) | const

inline

An iterator that gives access to the raw vectors for surfaces in this list, pointing past the end of this surface list.

This iterator is not dereferenceable.

Python:\n Not present.

Returns
  an iterator past the end of this surface list.

## enumerate()

static NormalSurfaces* regina::NormalSurfaces::enumerate | ( | Triangulation< 3 > * | owner,
|  | NormalCoords | coords,
|  | NormalList | which = `NS_LIST_DEFAULT`,
|  | NormalAlg | algHints = `NS_ALG_DEFAULT`,
|  | ProgressTracker * | tracker = `0`
| ) |  |

static

A unified routine for enumerating various classes of normal surfaces within a given triangulation.

The NormalCoords argument allows you to specify an underlying coordinate system (e.g., standard coordinates, quadrilateral coordinates or almost normal coordinates).

The NormalList argument is a combination of flags that allows you to specify exactly which normal surfaces you require. This includes (i) whether you want all vertex surfaces or all fundamental surfaces, which defaults to NS_VERTEX if you specify neither or both; and (ii) whether you want only properly embedded surfaces or you also wish to include immersed and/or singular surfaces, which defaults to NS_EMBEDDED_ONLY if you specify neither or both.

The NormalAlg argument is a combination of flags that allows you to control the underlying enumeration algorithm. These flags are treated as hints only: if your selection of algorithm is invalid, unavailable or unsupported then Regina will choose something more appropriate. Unless you have some specialised need, the default NS_ALG_DEFAULT (which makes no hints at all) will allow Regina to choose what it thinks will be the most efficient method.

The enumerated surfaces will be stored in a new normal surface list, and their representations will be scaled down to use the smallest possible integer coordinates. This normal surface list will be inserted into the packet tree as the last child of the given triangulation. This triangulation must remain the parent of this normal surface list, and must not change while this normal surface list remains in existence.

If a progress tracker is passed, the normal surface enumeration will take place in a new thread and this routine will return immediately. If the user cancels the operation from another thread, then the normal surface list will not be inserted into the packet tree (but the caller of this routine will still need to delete it). Regarding progress tracking, this routine will declare and work through a series of stages whose combined weights sum to 1; typically this means that the given tracker must not have been used before.

If no progress tracker is passed, the enumeration will run in the current thread and this routine will return only when the enumeration is complete. Note that this enumeration can be extremely slow for larger triangulations.

Parameters

  owner | the triangulation upon which this list of normal surfaces will be based.
  coords | the coordinate system to be used.
  which | indicates which normal surfaces should be enumerated.
  algHints | passes requests to Regina for which specific enumeration algorithm should be used.
  tracker | a progress tracker through which progress will be reported, or 0 if no progress reporting is required.

Returns
  the newly created normal surface list. Note that if a progress tracker is passed then this list may not be completely filled when this routine returns. If a progress tracker is passed and a new thread could not be started, this routine returns 0 (and no normal surface list is created).

## Enumerator()

regina::NormalSurfaces::Enumerator::Enumerator | ( | NormalSurfaces * | list,
|  | Triangulation< 3 > * | triang,
|  | ProgressTracker * | tracker
| ) |  |

inline

Creates a new functor with the given parameters.

Parameters

  list | the surface list to be filled.
  triang | the triangulation in which these surfaces lie.
  tracker | the progress tracker to use for progress reporting and cancellation polling, or 0 if these capabilities are not required.

## eulerChar() [1/2]

LargeInteger regina::NormalSurface::eulerChar | ( |  | ) | const

inline

Returns the Euler characteristic of this surface.

This routine caches its results, which means that once it has been called for a particular surface, subsequent calls return the answer immediately.

Precondition
  This normal surface is compact (has finitely many discs).

Returns
  the Euler characteristic.

## eulerChar() [2/2]

LargeInteger regina::SurfaceFilterProperties::eulerChar | ( | size_t | index | ) | const

Returns the allowable Euler characteristic at the given index in the set.

See eulerChars() for further details.

Parameters

  index | the index in the set of allowable Euler characteristics; this must be between 0 and countEulerChars()-1 inclusive.

Returns
  the requested allowable Euler characteristic.

## eulerChars()

const std::set< LargeInteger > & regina::SurfaceFilterProperties::eulerChars | ( |  | ) | const

inline

Returns the set of allowable Euler characteristics.

Any surface whose Euler characteristic is not in this set will not be accepted by this filter. The set will be given in ascending order with no element repeated.

If this set is empty, all Euler characteristics will be accepted.

Python:\n This routine returns a python sequence.

Returns
  the set of allowable Euler characteristics.

## filter()

SurfaceFilter * regina::XMLFilterReader::filter | ( |  | ) |

inline virtual

Returns the newly allocated filter that has been read by this element reader.

Deallocation of this new filter is not the responsibility of this class. Once this routine gives a non-zero return value, it should continue to give the same non-zero return value from this point onwards.

The default implementation returns 0.

Returns
  the filter that has been read, or 0 if filter reading is incomplete, the filter should be ignored or an error occurred.

## filterForDisjointPairs()

NormalSurfaces* regina::NormalSurfaces::filterForDisjointPairs | ( |  | ) | const

Creates a new list filled with the surfaces from this list that have at least one disjoint partner.

In other words, a surface S from this list will be placed in the new list if and only if there is some other surface T in this list for which S and T can be made to intersect nowhere at all, without changing either normal isotopy class. See NormalSurface::disjoint() for further details on disjointness testing.

This routine cannot deal with empty, disconnected or non-compact surfaces. Such surfaces will be silently ignored, and will not be used in any disjointness tests (in particular, they will never be considered as a "disjoint partner" for any other surface).

The new list will be inserted as a new child packet of the underlying triangulation (specifically, as the final child). As a convenience, the new list will also be returned from this routine.

This original list is not altered in any way. Likewise, the surfaces in the new list are deep copies of the originals (so they can be altered without affecting the original surfaces).

Precondition
  This list contains only embedded normal surfaces. More precisely, isEmbeddedOnly() must return `true`.
  All surfaces within this list are stored using the same coordinate system (i.e., the same subclass of NormalSurfaceVector).

Warning
  If this list contains a vertex link (plus at least one other surface), then the new list will be identical to the old (i.e., every surface will be copied across).

Todo:
  Deal properly with surfaces that are too large to handle.

Returns
  the new list, which will also have been inserted as a new child packet of the underlying triangulation.

## filterForLocallyCompatiblePairs()

NormalSurfaces* regina::NormalSurfaces::filterForLocallyCompatiblePairs | ( |  | ) | const

Creates a new list filled with the surfaces from this list that have at least one locally compatible partner.

In other words, a surface S from this list will be placed in the new list if and only if there is some other surface T in this list for which S and T are locally compatible. See NormalSurface::locallyCompatible() for further details on compatibility testing.

The new list will be inserted as a new child packet of the underlying triangulation (specifically, as the final child). As a convenience, the new list will also be returned from this routine.

This original list is not altered in any way. Likewise, the surfaces in the new list are deep copies of the originals (so they can be altered without affecting the original surfaces).

Precondition
  This list contains only embedded normal surfaces. More precisely, isEmbeddedOnly() must return `true`.

Warning
  If this list contains a vertex link (plus at least one other surface), then the new list will be identical to the old (i.e., every surface will be copied across).

Returns
  the new list, which will also have been inserted as a new child packet of the underlying triangulation.

## filterForPotentiallyIncompressible()

NormalSurfaces* regina::NormalSurfaces::filterForPotentiallyIncompressible | ( |  | ) | const

Creates a new list filled with only the surfaces from this list that "might" represent two-sided incompressible surfaces.

More precisely, we consider all two-sided surfaces in this list, as well as the two-sided double covers of all one-sided surfaces in this list (see below for details on how one-sided surfaces are handled). Each of these surfaces is examined using relatively fast heuristic tests for incompressibility. Any surface that is definitely not incompressible is thrown away, and all other surfaces are placed in the new list.

Therefore, it is guaranteed that every incompressible surface from the old list will be placed in the new list. However, it is not known whether any given surface in the new list is indeed incompressible.

See NormalSurface::isIncompressible() for the definition of incompressibility that is used here. Note in particular that spheres are never considered incompressible.

As indicated above, this filter works exclusively with two-sided surfaces. If a surface in this list is one-sided, the heuristic incompressibility tests will be run on its two-sided double cover. Nevertheless, if the tests pass, the original one-sided surface (not the double cover) will be added to the new list.

The new list will be inserted as a new child packet of the underlying triangulation (specifically, as the final child). As a convenience, the new list will also be returned from this routine.

This original list is not altered in any way. Likewise, the surfaces in the new list are deep copies of the originals (so they can be altered without affecting the original surfaces).

Currently the heuristic tests include (i) throwing away all vertex links and thin edge links, and then (ii) cutting along the remaining surfaces and running Triangulation<3>::hasSimpleCompressingDisc() on the resulting bounded triangulations. For more details on these tests see "The Weber-Seifert dodecahedral space is non-Haken", Benjamin A. Burton, J. Hyam Rubinstein and Stephan Tillmann, Trans. Amer. Math. Soc. 364:2 (2012), pp. 911-932.

Precondition
  The underlying 3-manifold triangulation is valid and closed. In particular, it has no ideal vertices.
  This list contains only embedded normal surfaces. More precisely, isEmbeddedOnly() must return `true`.
  This list contains only compact, connected normal surfaces.
  No surfaces in this list contain any octagonal discs.

Warning
  The behaviour of this routine is subject to change in future versions of Regina, since additional tests may be added to improve the power of this filtering.

Todo:
  Add progress tracking.

Returns
  the new list, which will also have been inserted as a new child packet of the underlying triangulation.

## filterType()

virtual SurfaceFilterType regina::SurfaceFilter::filterType | ( |  | ) | const

virtual

Returns the unique integer ID corresponding to the filtering method that is this particular subclass of SurfaceFilter.

Returns
  the unique integer filtering method ID.

## filterTypeName()

virtual std::string regina::SurfaceFilter::filterTypeName | ( |  | ) | const

virtual

Returns a string description of the filtering method that is this particular subclass of SurfaceFilter.

Returns
  a string description of this filtering method.

## forCoords() [1/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:\n Not present.

Parameters

  coords | the given normal coordinate system.
  func | the function object whose bracket operator we will call with a NormalInfo<coords> object.
  args | any additional arguments to pass to the bracket operator for func. These will be copied/moved, so if you wish to pass references then you may need to wrap them in std::ref or std::cref.

Returns
  nothing; the return type `ReturnsTraits<FunctionObject>::Void` simply evaluates to `void`.

## forCoords() [2/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:\n Not present.

Parameters

  coords | the given normal coordinate system.
  func | the function object whose bracket operator we will call with a NormalInfo<coords> object.
  defaultReturn | the value to return if the given coordinate system is invalid.
  args | any additional arguments to pass to the bracket operator for func. These will be copied/moved, so if you wish to pass references then you may need to wrap them in std::ref or std::cref.

Returns
  the return value from the corresponding bracket operator of func, or defaultReturn if the given coordinate system is invalid.

## forFilter() [1/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:\n Not present.

Parameters

  filter | the given type of normal surface filter.
  func | the function object whose bracket operator we will call with a SurfaceFilterInfo<filter> object.
  args | any additional arguments to pass to the bracket operator for func. These will be copied/moved, so if you wish to pass references then you may need to wrap then in std::ref or std::cref.

Returns
  nothing; the return type `ReturnsTraits<FunctionObject>::Void` simply evaluates to `void`.

## forFilter() [2/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:\n Not present.

Parameters

  filter | the given type of normal surface filter.
  func | the function object whose bracket operator we will call with a SurfaceFilterInfo<filter> object.
  defaultReturn | the value to return if the given filter type is not valid.
  args | any additional arguments to pass to the bracket operator for func. These will be copied/moved, so if you wish to pass references then you may need to wrap then in std::ref or std::cref.

Returns
  the return value from the corresponding bracket operator of func, or defaultReturn if the given filter type is not valid.

## hasMultipleOctDiscs()

virtual bool regina::NormalSurfaceVector::hasMultipleOctDiscs | ( | const Triangulation< 3 > * | triang | ) | const

virtual

Determines if this normal surface has more than one octagonal disc.

It may be assumed that at most one octagonal disc type exists in this surface. This routine will return `true` if an octagonal type does exist and its coordinate is greater than one.

The default implementation for this routine simply calculates all the octagonal coordinates and returns as soon as a positive or negative result can be established. Subclasses of NormalSurfaceVector should override this if they can provide a faster implementation.

If a subclass does not allow for almost normal surfaces, this routine will never be called and thus does not need to be overwritten.

Precondition
  At most one octagonal disc type exists in this surface.
  This normal surface vector is using a coordinate system that allows for almost normal surfaces.

Parameters

  triang | the triangulation in which this normal surface lives.

Returns
  `true` if and only if there is an octagonal disc type present and its coordinate is greater than one.

## hasRealBoundary()

bool regina::NormalSurface::hasRealBoundary | ( |  | ) | const

inline

Determines if this surface has any real boundary, that is, whether it meets any boundary triangles of the triangulation.

This routine caches its results, which means that once it has been called for a particular surface, subsequent calls return the answer immediately.

Returns
  `true` if and only if this surface has real boundary.

## init()

void regina::DiscSpecIterator::init | ( | const DiscSetSurface & | discSet | ) |

inline

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

Parameters

  discSet | the disc set used to reinitialise this iterator.

## initialChars()

virtual void regina::XMLNormalSurfaceReader::initialChars | ( | const std::string & | chars | ) |

virtual

Signifies that the initial text belonging to this XML element has been read.

The initial text is everything between the opening tag and the first subelement or closing tag.

The default implementation does nothing.

Parameters

  chars | the initial text for this element.

Reimplemented from regina::XMLElementReader.

## internalClonePacket() [1/4]

Packet * regina::SurfaceFilter::internalClonePacket | ( | Packet * | parent | ) | const

inline protected virtual

Makes a newly allocated copy of this packet.

This routine should not insert the new packet into the tree structure, clone the packet's associated tags or give the packet a label. It should also not clone any descendants of this packet.

You may assume that the new packet will eventually be inserted into the tree beneath either the same parent as this packet or a clone of that parent.

Parameters

  parent | the parent beneath which the new packet will eventually be inserted.

Returns
  the newly allocated packet.

Implements regina::Packet.

Reimplemented in regina::SurfaceFilterProperties, and regina::SurfaceFilterCombination.

## internalClonePacket() [2/4]

Packet * regina::SurfaceFilterCombination::internalClonePacket | ( | Packet * | parent | ) | const

inline protected virtual

Makes a newly allocated copy of this packet.

This routine should not insert the new packet into the tree structure, clone the packet's associated tags or give the packet a label. It should also not clone any descendants of this packet.

You may assume that the new packet will eventually be inserted into the tree beneath either the same parent as this packet or a clone of that parent.

Parameters

  parent | the parent beneath which the new packet will eventually be inserted.

Returns
  the newly allocated packet.

Reimplemented from regina::SurfaceFilter.

## internalClonePacket() [3/4]

Packet * regina::SurfaceFilterProperties::internalClonePacket | ( | Packet * | parent | ) | const

inline protected virtual

Makes a newly allocated copy of this packet.

This routine should not insert the new packet into the tree structure, clone the packet's associated tags or give the packet a label. It should also not clone any descendants of this packet.

You may assume that the new packet will eventually be inserted into the tree beneath either the same parent as this packet or a clone of that parent.

Parameters

  parent | the parent beneath which the new packet will eventually be inserted.

Returns
  the newly allocated packet.

Reimplemented from regina::SurfaceFilter.

## internalClonePacket() [4/4]

virtual Packet* regina::NormalSurfaces::internalClonePacket | ( | Packet * | parent | ) | const

protected virtual

Makes a newly allocated copy of this packet.

This routine should not insert the new packet into the tree structure, clone the packet's associated tags or give the packet a label. It should also not clone any descendants of this packet.

You may assume that the new packet will eventually be inserted into the tree beneath either the same parent as this packet or a clone of that parent.

Parameters

  parent | the parent beneath which the new packet will eventually be inserted.

Returns
  the newly allocated packet.

Implements regina::Packet.

## isCentral() [1/2]

LargeInteger regina::NormalSurface::isCentral | ( |  | ) | const

inline

Determines whether or not this surface is a central surface.

A central surface is a compact surface containing at most one normal or almost normal disc per tetrahedron. If this surface is central, the number of tetrahedra that it meets (i.e., the number of discs in the surface) will be returned.

Note that the results of this routine are not cached. Thus the results will be reevaluated every time this routine is called.

Todo:
  Optimise: Cache results.

Returns
  the number of tetrahedra that this surface meets if it is a central surface, or 0 if it is not a central surface.

## isCentral() [2/2]

virtual LargeInteger regina::NormalSurfaceVector::isCentral | ( | const Triangulation< 3 > * | triang | ) | const

virtual

Determines if the normal surface represented is a central surface in the given triangulation.

A central surface is a compact surface containing at most one normal or almost normal disc per tetrahedron. If the surface is central, the number of tetrahedra it meets (i.e., the number of discs in the surface) will be returned.

The default implementation for this routine simply runs through and checks the count for each disc type. Subclasses of NormalSurfaceVector should override this if they can provide a faster implementation.

Parameters

  triang | the triangulation in which this normal surface lives.

Returns
  the number of tetrahedra that the surface meets if it is a central surface, or 0 if it is not a central surface.

## isCompact() [1/2]

bool regina::NormalSurface::isCompact | ( |  | ) | const

inline

Determines if this normal surface is compact (has finitely many discs).

This routine caches its results, which means that once it has been called for a particular surface, subsequent calls return the answer immediately.

Returns
  `true` if and only if this normal surface is compact.

## isCompact() [2/2]

virtual bool regina::NormalSurfaceVector::isCompact | ( | const Triangulation< 3 > * | triang | ) | const

virtual

Determines if the normal surface represented is compact (has finitely many discs).

The default implementation for this routine simply runs through every disc type until a disc type with infinite disc count is found or all disc types have been examined. Subclasses of NormalSurfaceVector should override this if they can provide a faster implementation.

Parameters

  triang | the triangulation in which this normal surface lives.

Returns
  `true` if and only if the normal surface represented is compact.

## isCompressingDisc()

bool regina::NormalSurface::isCompressingDisc | ( | bool | knownConnected = `false` | ) | const

Determines whether this surface represents a compressing disc in the underlying 3-manifold.

Let this surface be D and let the underlying 3-manifold be M with boundary B. To be a compressing disc, D must be a properly embedded disc in M, and the boundary of D must not bound a disc in B.

The implementation of this routine is somewhat inefficient at present, since it cuts along the disc, retriangulates and then examines the resulting boundary components.

Precondition
  This normal surface is compact and embedded.
  This normal surface contains no octagonal discs.

Todo:

  Optimise: Reimplement this to avoid cutting along surfaces.

  Bug: Check for absurdly large numbers of discs and bail accordingly.

Warning
  This routine might cut along the surface and retriangulate, and so may run out of memory if the normal coordinates are extremely large.

Parameters

  knownConnected | `true` if this normal surface is already known to be connected (for instance, if it came from an enumeration of vertex normal surfaces), or `false` if we should not assume any such information about this surface.

Returns
  `true` if this surface is a compressing disc, or `false` if this surface is not a compressing disc.

## isConnected()

bool regina::NormalSurface::isConnected | ( |  | ) | const

inline

Returns whether or not this surface is connected.

This routine caches its results, which means that once it has been called for a particular surface, subsequent calls return the answer immediately.

Precondition
  This normal surface is compact (has finitely many discs).

Warning
  This routine explicitly builds the normal discs, and so may run out of memory if the normal coordinates are extremely large.

Returns
  `true` if this surface is connected, or `false` if this surface is disconnected.

## isEmbeddedOnly()

bool regina::NormalSurfaces::isEmbeddedOnly | ( |  | ) | const

inline

Returns whether this list was constructed to contain only properly embedded surfaces.

If this returns `false`, it does not guarantee that immersed and/or singular surfaces are present; it merely indicates that they were not deliberately excluded (for instance, the quadrilateral constraints were not enforced).

Returns
  `true` if this list was constructed to contain only properly embedded surfaces, or `false` otherwise.

## isEmpty()

bool regina::NormalSurface::isEmpty | ( |  | ) | const

Determines if this normal surface is empty (has no discs whatsoever).

## isIncompressible()

bool regina::NormalSurface::isIncompressible | ( |  | ) | const

Determines whether this is an incompressible surface within the surrounding 3-manifold.

At present, this routine is only implemented for surfaces embedded within closed and irreducible 3-manifold triangulations.

Let D be some disc embedded in the underlying 3-manifold, and let B be the boundary of D. We call D a compressing disc for this surface if (i) the intersection of D with this surface is the boundary B, and (ii) although B bounds a disc within the 3-manifold, it does not bound a disc within this surface.

We declare this surface to be incompressible if there are no such compressing discs. For our purposes, spheres are never considered incompressible (so if this surface is a sphere then this routine will always return `false`).

This test is designed exclusively for two-sided surfaces. If this surface is one-sided, the incompressibility test will be run on its two-sided double cover.

Warning
  This routine may in some circumstances be extremely slow. This is because the underlying algorithm cuts along this surface, retriangulates (possibly using a very large number of tetrahedra), and then searches for a normal compressing disc in each component of the cut-open triangulation.

Precondition
  The underlying triangulation is valid and closed, and represents an irreducible 3-manifold.
  This normal surface is compact, embedded and connected, and contains no octagonal discs.

Returns
  `true` if this surface is incompressible, or `false` if this surface is not incompressible (or if it is a sphere).

## isOrientable()

bool regina::NormalSurface::isOrientable | ( |  | ) | const

inline

Returns whether or not this surface is orientable.

This routine caches its results, which means that once it has been called for a particular surface, subsequent calls return the answer immediately.

Precondition
  This normal surface is compact (has finitely many discs).

Warning
  This routine explicitly builds the normal discs, and so may run out of memory if the normal coordinates are extremely large.

Returns
  `true` if this surface is orientable, or `false` if this surface is non-orientable.

## isSplitting() [1/2]

bool regina::NormalSurface::isSplitting | ( |  | ) | const

inline

Determines whether or not this surface is a splitting surface.

A splitting surface is a compact surface containing precisely one quad per tetrahedron and no other normal (or almost normal) discs.

Note that the results of this routine are not cached. Thus the results will be reevaluated every time this routine is called.

Todo:
  Optimise: Cache results.

Returns
  `true` if and only if this is a splitting surface.

## isSplitting() [2/2]

virtual bool regina::NormalSurfaceVector::isSplitting | ( | const Triangulation< 3 > * | triang | ) | const

virtual

Determines if the normal surface represented is a splitting surface in the given triangulation.

A splitting surface is a compact surface containing precisely one quad per tetrahedron and no other normal (or almost normal) discs.

The default implementation for this routine simply runs through and checks the count for each disc type. Subclasses of NormalSurfaceVector should override this if they can provide a faster implementation.

Parameters

  triang | the triangulation in which this normal surface lives.

Returns
  `true` if and only if the normal surface represented is a splitting surface.

## isThinEdgeLink() [1/2]

std::pair< const Edge< 3 > *, const Edge< 3 > * > regina::NormalSurface::isThinEdgeLink | ( |  | ) | const

inline

Determines whether or not a rational multiple of this surface is the thin link of a single edge.

If there are two different edges e1 and e2 for which this surface could be expressed as the thin link of either e1 or e2, the pair (e1,e2) will be returned. If this surface is the thin link of only one edge e, the pair (e,0) will be returned. If this surface is not the thin link of any edges, the pair (0,0) will be returned.

Note that the results of this routine are not cached. Thus the results will be reevaluated every time this routine is called.

Todo:
  Optimise: Cache results.

Python:\n This routine returns a tuple of size 2.

Returns
  a pair containing the edge(s) linked by this surface, as described above.

## isThinEdgeLink() [2/2]

virtual std::pair<const Edge<3>*, const Edge<3>*> regina::NormalSurfaceVector::isThinEdgeLink | ( | const Triangulation< 3 > * | triang | ) | const

virtual

Determines if a rational multiple of the normal surface represented is the thin link of a single edge.

If there are two different edges e1 and e2 for which the surface could be expressed as the thin link of either e1 or e2, the pair (e1,e2) will be returned. If the surface is the thin link of only one edge e, the pair (e,0) will be returned. If the surface is not the thin link of any edges, the pair (0,0) will be returned.

The default implementation for this routine involves counting the number of discs of every type. Subclasses of NormalSurfaceVector should override this if they can provide a faster implementation.

Parameters

  triang | the triangulation in which this normal surface lives.

Returns
  a pair containing the edge(s) linked by this surface, as described above.

## isTwoSided()

bool regina::NormalSurface::isTwoSided | ( |  | ) | const

inline

Returns whether or not this surface is two-sided.

This routine caches its results, which means that once it has been called for a particular surface, subsequent calls return the answer immediately.

Precondition
  This normal surface is compact (has finitely many discs).

Warning
  This routine explicitly builds the normal discs, and so may run out of memory if the normal coordinates are extremely large.

Returns
  `true` if this surface is two-sided, or `false` if this surface is one-sided.

## isVertexLink() [1/5]

const Vertex< 3 > * regina::NormalSurface::isVertexLink | ( |  | ) | const

inline

Determines whether or not a rational multiple of this surface is the link of a single vertex.

Note that the results of this routine are not cached. Thus the results will be reevaluated every time this routine is called.

Todo:
  Optimise: Cache results.

Returns
  the vertex linked by this surface, or 0 if this surface is not the link of a single vertex.

## isVertexLink() [2/5]

const Vertex< 3 > * regina::NSVectorQuad::isVertexLink | ( | const Triangulation< 3 > * | triang | ) | const

inline virtual

Determines if a rational multiple of the normal surface represented is the link of a single vertex.

The default implementation for this routine involves counting the number of discs of every type. Subclasses of NormalSurfaceVector should override this if they can provide a faster implementation.

Parameters

  triang | the triangulation in which this normal surface lives.

Returns
  the vertex linked by this surface, or 0 if this surface is not the link of a single vertex.

Reimplemented from regina::NormalSurfaceVector.

## isVertexLink() [3/5]

const Vertex< 3 > * regina::NSVectorQuadOct::isVertexLink | ( | const Triangulation< 3 > * | triang | ) | const

inline virtual

Determines if a rational multiple of the normal surface represented is the link of a single vertex.

The default implementation for this routine involves counting the number of discs of every type. Subclasses of NormalSurfaceVector should override this if they can provide a faster implementation.

Parameters

  triang | the triangulation in which this normal surface lives.

Returns
  the vertex linked by this surface, or 0 if this surface is not the link of a single vertex.

Reimplemented from regina::NormalSurfaceVector.

## isVertexLink() [4/5]

const Vertex< 3 > * regina::NSVectorOrientedQuad::isVertexLink | ( | const Triangulation< 3 > * | triang | ) | const

inline virtual

Determines if a rational multiple of the normal surface represented is the link of a single vertex.

The default implementation for this routine involves counting the number of discs of every type. Subclasses of NormalSurfaceVector should override this if they can provide a faster implementation.

Parameters

  triang | the triangulation in which this normal surface lives.

Returns
  the vertex linked by this surface, or 0 if this surface is not the link of a single vertex.

Reimplemented from regina::NormalSurfaceVector.

## isVertexLink() [5/5]

virtual const Vertex<3>* regina::NormalSurfaceVector::isVertexLink | ( | const Triangulation< 3 > * | triang | ) | const

virtual

Determines if a rational multiple of the normal surface represented is the link of a single vertex.

The default implementation for this routine involves counting the number of discs of every type. Subclasses of NormalSurfaceVector should override this if they can provide a faster implementation.

Parameters

  triang | the triangulation in which this normal surface lives.

Returns
  the vertex linked by this surface, or 0 if this surface is not the link of a single vertex.

Reimplemented in regina::NSVectorOrientedQuad, regina::NSVectorQuadOct, and regina::NSVectorQuad.

## isVertexLinking() [1/2]

bool regina::NormalSurface::isVertexLinking | ( |  | ) | const

inline

Determines whether or not this surface is vertex linking.

A vertex linking surface contains only triangles.

Note that the results of this routine are not cached. Thus the results will be reevaluated every time this routine is called.

Todo:
  Optimise: Cache results.

Returns
  `true` if and only if this surface is vertex linking.

## isVertexLinking() [2/2]

virtual bool regina::NormalSurfaceVector::isVertexLinking | ( | const Triangulation< 3 > * | triang | ) | const

virtual

Determines if the normal surface represented is vertex linking.

A vertex linking surface contains only triangles.

The default implementation for this routine simply runs through every non-triangular disc type ensuring that each has no corresponding discs. Subclasses of NormalSurfaceVector should override this if they can provide a faster implementation.

Parameters

  triang | the triangulation in which this normal surface lives.

Returns
  `true` if and only if the normal surface represented is vertex linking.

## locallyCompatible()

bool regina::NormalSurface::locallyCompatible | ( | const NormalSurface & | other | ) | const

Determines whether this and the given surface are locally compatible.

Local compatibility means that, within each individual tetrahedron of the triangulation, it is possible to arrange the normal discs of both surfaces so that none intersect.

This is a local constraint, not a global constraint. That is, we do not insist that we can avoid intersections within all tetrahedra simultaneously. To test the global constraint, see the (much slower) routine disjoint() instead.

Local compatibility can be formulated in terms of normal disc types. Two normal (or almost normal) surfaces are locally compatible if and only if they together have at most one quadrilateral or octagonal disc type per tetrahedron.

Note again that this is a local constraint only. In particular, for almost normal surfaces, it does not insist that there is at most one octagonal disc type anywhere within the triangulation.

If one of the two surfaces breaks the local compatibility constraints on its own (for instance, it contains two different quadrilateral disc types within the same tetrahedron), then this routine will return `false` regardless of what the other surface contains.

Precondition
  Both this and the given normal surface live within the same 3-manifold triangulation.

Parameters

  other | the other surface to test for local compatibility with this surface.

Returns
  `true` if the two surfaces are locally compatible, or `false` if they are not.

## makeEmbeddedConstraints() [1/2]

static EnumConstraints* regina::NormalSurfaceVector::makeEmbeddedConstraints | ( | const Triangulation< 3 > * | triangulation | ) |

static

Creates a new set of validity constraints representing the condition that normal surfaces be embedded.

The validity constraints will be expressed relative to the coordinate system corresponding to this particular subclass of NormalSurfaceVector.

Parameters

  triangulation | the triangulation upon which these validity constraints will be based.

Returns
  a newly allocated set of constraints.

## makeEmbeddedConstraints() [2/2]

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:\n Not present.

Parameters

  triangulation | the triangulation upon which these validity constraints will be based.
  coords | the coordinate system to be used.

Returns
  a newly allocated set of constraints.

## makeMatchingEquations() [1/2]

static MatrixInt* regina::NormalSurfaceVector::makeMatchingEquations | ( | const Triangulation< 3 > * | triangulation | ) |

static

Creates a new set of normal surface matching equations for the given triangulation using the coordinate system corresponding to this particular subclass of NormalSurfaceVector.

See regina::makeMatchingEquations() for further details.

Parameters

  triangulation | the triangulation upon which these matching equations will be based.

Returns
  a newly allocated set of matching equations.

## makeMatchingEquations() [2/2]

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.

Parameters

  triangulation | the triangulation upon which these matching equations will be based.
  coords | the coordinate system to be used.

Returns
  a newly allocated set of matching equations.

## makeMirror() [1/5]

static NormalSurfaceVector* regina::NSVectorMirrored::makeMirror | ( | const Ray & | original,
|  | const Triangulation< 3 > * | triang
| ) |  |

static

Creates a new mirror vector corresponding to the given vector.

This function should be implemented by each subclass of NSVectorMirrored.

This function must return a newly created vector that describes the given normal surface in a different coordinate system:

- The given vector must be in the coordinate system described by the subclass in which this function is implemented.
- The return vector must be in the corresponding "standard" coordinate system (i.e., NSVectorStandard if this subclass is NSVectorQuad, or NSVectorANStandard if this subclass is NSVectorQuadOct, and so on.)

Parameters

  original | a vector in the coordinate system corresponding to the subclass in which this function is implemented.
  triang | the triangulation in which the corresponding normal surface lives.

Returns
  a newly created vector that describes the same normal surface in a "standard" coordinate system, as described above.

## makeMirror() [2/5]

NormalSurfaceVector * regina::NSVectorQuad::makeMirror | ( | const Triangulation< 3 > * | triang | ) | const

inline virtual

Creates a new mirror vector corresponding to this vector.

This function must return a newly created vector that describes this normal surface in the corresponding "standard" coordinate system (i.e., NSVectorStandard if this subclass is NSVectorQuad, or NSVectorANStandard if this subclass is NSVectorQuadOct, and so on.)

Typically subclasses should implement this function by calling the corresponding static makeMirror() function, which does the real work.

Parameters

  triang | the triangulation in which this normal surface lives.

Returns
  a newly created vector that describes the same normal surface in a "standard" coordinate system, as described above.

Implements regina::NSVectorMirrored.

## makeMirror() [3/5]

NormalSurfaceVector * regina::NSVectorQuadOct::makeMirror | ( | const Triangulation< 3 > * | triang | ) | const

inline virtual

Creates a new mirror vector corresponding to this vector.

This function must return a newly created vector that describes this normal surface in the corresponding "standard" coordinate system (i.e., NSVectorStandard if this subclass is NSVectorQuad, or NSVectorANStandard if this subclass is NSVectorQuadOct, and so on.)

Typically subclasses should implement this function by calling the corresponding static makeMirror() function, which does the real work.

Parameters

  triang | the triangulation in which this normal surface lives.

Returns
  a newly created vector that describes the same normal surface in a "standard" coordinate system, as described above.

Implements regina::NSVectorMirrored.

## makeMirror() [4/5]

NormalSurfaceVector * regina::NSVectorOrientedQuad::makeMirror | ( | const Triangulation< 3 > * | triang | ) | const

inline virtual

Creates a new mirror vector corresponding to this vector.

This function must return a newly created vector that describes this normal surface in the corresponding "standard" coordinate system (i.e., NSVectorStandard if this subclass is NSVectorQuad, or NSVectorANStandard if this subclass is NSVectorQuadOct, and so on.)

Typically subclasses should implement this function by calling the corresponding static makeMirror() function, which does the real work.

Parameters

  triang | the triangulation in which this normal surface lives.

Returns
  a newly created vector that describes the same normal surface in a "standard" coordinate system, as described above.

Implements regina::NSVectorMirrored.

## makeMirror() [5/5]

virtual NormalSurfaceVector* regina::NSVectorMirrored::makeMirror | ( | const Triangulation< 3 > * | triang | ) | const

pure virtual

Creates a new mirror vector corresponding to this vector.

This function must return a newly created vector that describes this normal surface in the corresponding "standard" coordinate system (i.e., NSVectorStandard if this subclass is NSVectorQuad, or NSVectorANStandard if this subclass is NSVectorQuadOct, and so on.)

Typically subclasses should implement this function by calling the corresponding static makeMirror() function, which does the real work.

Parameters

  triang | the triangulation in which this normal surface lives.

Returns
  a newly created vector that describes the same normal surface in a "standard" coordinate system, as described above.

Implemented in regina::NSVectorOrientedQuad, regina::NSVectorQuadOct, and regina::NSVectorQuad.

## makeZeroVector() [1/2]

static NormalSurfaceVector* regina::NormalSurfaceVector::makeZeroVector | ( | const Triangulation< 3 > * | triangulation | ) |

static

Returns a new normal surface vector of the appropriate length for the given triangulation and for the coordinate system corresponding to this subclass of NormalSurfaceVector.

All elements of the new vector will be initialised to zero.

See regina::makeZeroVector() for further details.

Parameters

  triangulation | the triangulation upon which the underlying coordinate system is based.

Returns
  a new zero vector of the correct class and length.

## makeZeroVector() [2/2]

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:\n Not present.

Parameters

  triangulation | the triangulation upon which the underlying coordinate system is based.
  coords | the coordinate system to be used.

Returns
  a new zero vector of the correct class and length.

## name()

const std::string & regina::NormalSurface::name | ( |  | ) | const

inline

Returns the name associated with this normal surface.

Names are optional and need not be unique. The default name for a surface is the empty string.

Returns
  the name of associated with this surface.

## 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

  type | the 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

  tetIndex | the index in the triangulation of the tetrahedron to examine.
  type | the disc type to examine; this should be between 0 and 9 inclusive. Disc types are outlined in the DiscSpec class notes.

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

## normal()

bool regina::NormalSurface::normal | ( |  | ) | const

inline

Determines whether this surface contains only triangle and/or quadrilateral discs.

This is to distinguish normal surfaces from more general surfaces such as almost normal surfaces (which also contain octagonal pieces).

Even if the underlying coordinate system supports other disc types (such as octagons), this routine will still return `true` if this particular surface does not use them. This is in contrast to the routine NormalSurfaces::allowsAlmostNormal(), which only examines the underlying coordinate system.

Returns
  `true` if and only if this surface contains only triangles and/or quadrilaterals.

## NormalSurface() [1/2]

regina::NormalSurface::NormalSurface | ( | const Triangulation< 3 > * | triang,
|  | NormalCoords | coordSystem,
|  | List | allCoords
| ) |  |

A Python-only routine that creates a new normal surface inside the given triangulation with the given coordinate vector.

Precondition
  The given coordinate system is one in which Regina is able to enumerate and store normal surfaces (not a system like regina::NS_EDGE_WEIGHT, which is for viewing purposes only).
  The given coordinate vector represents a normal surface inside the given triangulation (in particular, it satisfies the relevant system of matching equations). This will not be checked, and things will go wrong if you break it.

C++:\n Not available; this routine is for Python only.

Parameters

  triang | the triangulation in which this normal surface resides.
  coordSystem | the coordinate system used by this normal surface.
  allCoords | the corresponding vector of normal coordinates, expressed as a Python list. The list elements will be converted internally to LargeInteger objects.

## NormalSurface() [2/2]

regina::NormalSurface::NormalSurface | ( | const Triangulation< 3 > * | triang,
|  | NormalSurfaceVector * | newVector
| ) |  |

Creates a new normal surface inside the given triangulation with the given coordinate vector.

This normal surface will claim ownership of the given vector (i.e., you should not change or delete the vector yourself afterwards).

Precondition
  The given coordinate vector represents a normal surface inside the given triangulation.
  The given coordinate vector cannot be the null pointer.

Python:\n Not present.

Parameters

  triang | the triangulation in which this normal surface resides.
  newVector | a vector containing the coordinates of the normal surface in whichever space is appropriate.

## NormalSurfaces()

regina::NormalSurfaces::NormalSurfaces | ( | NormalCoords | coords,
|  | NormalList | which,
|  | NormalAlg | algorithm
| ) |  |

inline protected

Creates an empty list of normal surfaces with the given parameters.

Parameters

  coords | the coordinate system to be used for filling this list.
  which | indicates which normal surfaces these will represent within the underlying triangulation.
  algorithm | details of the enumeration algorithm that will be used to fill this list.

## NormalSurfaceVector() [1/2]

regina::NormalSurfaceVector::NormalSurfaceVector | ( | const Vector< LargeInteger > & | cloneMe | ) |

inline

Creates a new vector that is a clone of the given vector.

Parameters

  cloneMe | the vector to clone.

## NormalSurfaceVector() [2/2]

regina::NormalSurfaceVector::NormalSurfaceVector | ( | size_t | length | ) |

inline

Creates a new vector all of whose entries are initialised to zero.

Parameters

  length | the number of elements in the new vector.

## NSVectorANStandard() [1/2]

regina::NSVectorANStandard::NSVectorANStandard | ( | const Vector< LargeInteger > & | cloneMe | ) |

inline

Creates a new vector that is a clone of the given vector.

Parameters

  cloneMe | the vector to clone.

## NSVectorANStandard() [2/2]

regina::NSVectorANStandard::NSVectorANStandard | ( | size_t | length | ) |

inline

Creates a new vector all of whose entries are initialised to zero.

Parameters

  length | the number of elements in the new vector.

## NSVectorMirrored() [1/2]

regina::NSVectorMirrored::NSVectorMirrored | ( | const Vector< LargeInteger > & | cloneMe | ) |

inline

Creates a new vector that is a clone of the given vector.

Parameters

  cloneMe | the vector to clone.

## NSVectorMirrored() [2/2]

regina::NSVectorMirrored::NSVectorMirrored | ( | size_t | length | ) |

inline

Creates a new vector all of whose entries are initialised to zero.

Parameters

  length | the number of elements in the new vector.

## NSVectorOriented() [1/2]

regina::NSVectorOriented::NSVectorOriented | ( | const Vector< LargeInteger > & | cloneMe | ) |

inline

Creates a new vector that is a clone of the given vector.

Parameters

  cloneMe | the vector to clone.

## NSVectorOriented() [2/2]

regina::NSVectorOriented::NSVectorOriented | ( | size_t | length | ) |

inline

Creates a new vector all of whose entries are initialised to zero.

Parameters

  length | the number of elements in the new vector.

## NSVectorOrientedQuad() [1/2]

regina::NSVectorOrientedQuad::NSVectorOrientedQuad | ( | const Vector< LargeInteger > & | cloneMe | ) |

inline

Creates a new vector that is a clone of the given vector.

Parameters

  cloneMe | the vector to clone.

## NSVectorOrientedQuad() [2/2]

regina::NSVectorOrientedQuad::NSVectorOrientedQuad | ( | size_t | length | ) |

inline

Creates a new vector all of whose entries are initialised to zero.

Parameters

  length | the number of elements in the new vector.

## NSVectorQuad() [1/2]

regina::NSVectorQuad::NSVectorQuad | ( | const Vector< LargeInteger > & | cloneMe | ) |

inline

Creates a new vector that is a clone of the given vector.

Parameters

  cloneMe | the vector to clone.

## NSVectorQuad() [2/2]

regina::NSVectorQuad::NSVectorQuad | ( | size_t | length | ) |

inline

Creates a new vector all of whose entries are initialised to zero.

Parameters

  length | the number of elements in the new vector.

## NSVectorQuadOct() [1/2]

regina::NSVectorQuadOct::NSVectorQuadOct | ( | const Vector< LargeInteger > & | cloneMe | ) |

inline

Creates a new vector that is a clone of the given vector.

Parameters

  cloneMe | the vector to clone.

## NSVectorQuadOct() [2/2]

regina::NSVectorQuadOct::NSVectorQuadOct | ( | size_t | length | ) |

inline

Creates a new vector all of whose entries are initialised to zero.

Parameters

  length | the number of elements in the new vector.

## NSVectorStandard() [1/2]

regina::NSVectorStandard::NSVectorStandard | ( | const Vector< LargeInteger > & | cloneMe | ) |

inline

Creates a new vector that is a clone of the given vector.

Parameters

  cloneMe | the vector to clone.

## NSVectorStandard() [2/2]

regina::NSVectorStandard::NSVectorStandard | ( | size_t | length | ) |

inline

Creates a new vector all of whose entries are initialised to zero.

Parameters

  length | the number of elements in the new vector.

## 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

  discType | the normal disc type under consideration; this should be between 0 and 9 inclusive, as described by the DiscSpec class notes.
  vertex | the vertex under consideration; this should be between 0 and 3 inclusive.

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.

## octPosition()

DiscType regina::NormalSurface::octPosition | ( |  | ) | const

inline

Determines the first coordinate position at which this surface has a non-zero octagonal coordinate.

In other words, if this routine returns the disc type t, then the octagonal coordinate returned by octs(t.tetIndex, t.type) is non-zero. Here DiscType::type represents an octagon type within a tetrahedron, and takes values between 0 and 2 inclusive.

If this surface does not contain any octagons, this routine returns DiscType::NONE instead.

This routine caches its results, which means that once it has been called for a particular surface, subsequent calls return the answer immediately. Moreover, if the underlying coordinate system does not support almost normal surfaces, then even the first call is fast (it returns DiscType::NONE immediately).

Returns
  the position of the first non-zero octagonal coordinate, or DiscType::NONE if there is no such coordinate.

## octs() [1/8]

LargeInteger regina::NormalSurface::octs | ( | size_t | tetIndex,
|  | int | octType
| ) |  | const

inline

Returns the number of octagonal discs of the given type in this normal surface.

In each tetrahedron, there are three types of octagons, defined by how they separate the four tetrahedron vertices into two pairs. Octagon type i (for i = 0, 1 or 2) is defined to intersect edges i and (5-i) of the tetrahedron twice each, and to intersect the remaining edges once each. This means:

- type 0 separates vertices 0,1 of the tetrahedron from vertices 2,3;
- type 1 separates vertices 0,2 of the tetrahedron from vertices 1,3;
- type 2 separates vertices 0,3 of the tetrahedron from vertices 1,2.

If you are using a coordinate system that adorns discs with additional information (such as orientation), this routine returns the total number of octagons in the given tetrahedron of the given type.

Parameters

  tetIndex | the index in the triangulation of the tetrahedron in which the requested octagons reside; this should be between 0 and Triangulation<3>::size()-1 inclusive.
  octType | the type of this octagon in the given tetrahedron; this should be 0, 1 or 2, as described above.

Returns
  the number of octagonal discs of the given type.

## octs() [2/8]

LargeInteger regina::NSVectorStandard::octs | ( | size_t | tetIndex,
|  | int | octType,
|  | const Triangulation< 3 > * | triang
| ) |  | const

inline virtual

Returns the number of octagonal discs of the given type in this normal surface.

See NormalSurface::octs() for further details.

Parameters

  tetIndex | the index in the triangulation of the tetrahedron in which the requested octagons reside; this should be between 0 and Triangulation<3>::size()-1 inclusive.
  octType | the type of this octagon in the given tetrahedron; this should be 0, 1 or 2.
  triang | the triangulation in which this normal surface lives.

Returns
  the number of octagonal discs of the given type.

Implements regina::NormalSurfaceVector.

## octs() [3/8]

LargeInteger regina::NSVectorQuad::octs | ( | size_t | tetIndex,
|  | int | octType,
|  | const Triangulation< 3 > * | triang
| ) |  | const

inline virtual

Returns the number of octagonal discs of the given type in this normal surface.

See NormalSurface::octs() for further details.

Parameters

  tetIndex | the index in the triangulation of the tetrahedron in which the requested octagons reside; this should be between 0 and Triangulation<3>::size()-1 inclusive.
  octType | the type of this octagon in the given tetrahedron; this should be 0, 1 or 2.
  triang | the triangulation in which this normal surface lives.

Returns
  the number of octagonal discs of the given type.

Reimplemented from regina::NSVectorMirrored.

## octs() [4/8]

LargeInteger regina::NSVectorANStandard::octs | ( | size_t | tetIndex,
|  | int | octType,
|  | const Triangulation< 3 > * | triang
| ) |  | const

inline virtual

Returns the number of octagonal discs of the given type in this normal surface.

See NormalSurface::octs() for further details.

Parameters

  tetIndex | the index in the triangulation of the tetrahedron in which the requested octagons reside; this should be between 0 and Triangulation<3>::size()-1 inclusive.
  octType | the type of this octagon in the given tetrahedron; this should be 0, 1 or 2.
  triang | the triangulation in which this normal surface lives.

Returns
  the number of octagonal discs of the given type.

Implements regina::NormalSurfaceVector.

## octs() [5/8]

LargeInteger regina::NSVectorOriented::octs | ( | size_t | tetIndex,
|  | int | octType,
|  | const Triangulation< 3 > * | triang
| ) |  | const

inline virtual

Returns the number of octagonal discs of the given type in this normal surface.

See NormalSurface::octs() for further details.

Parameters

  tetIndex | the index in the triangulation of the tetrahedron in which the requested octagons reside; this should be between 0 and Triangulation<3>::size()-1 inclusive.
  octType | the type of this octagon in the given tetrahedron; this should be 0, 1 or 2.
  triang | the triangulation in which this normal surface lives.

Returns
  the number of octagonal discs of the given type.

Implements regina::NormalSurfaceVector.

## octs() [6/8]

LargeInteger regina::NSVectorOrientedQuad::octs | ( | size_t | tetIndex,
|  | int | octType,
|  | const Triangulation< 3 > * | triang
| ) |  | const

inline virtual

Returns the number of octagonal discs of the given type in this normal surface.

See NormalSurface::octs() for further details.

Parameters

  tetIndex | the index in the triangulation of the tetrahedron in which the requested octagons reside; this should be between 0 and Triangulation<3>::size()-1 inclusive.
  octType | the type of this octagon in the given tetrahedron; this should be 0, 1 or 2.
  triang | the triangulation in which this normal surface lives.

Returns
  the number of octagonal discs of the given type.

Reimplemented from regina::NSVectorMirrored.

## octs() [7/8]

virtual LargeInteger regina::NormalSurfaceVector::octs | ( | size_t | tetIndex,
|  | int | octType,
|  | const Triangulation< 3 > * | triang
| ) |  | const

pure virtual

Returns the number of octagonal discs of the given type in this normal surface.

See NormalSurface::octs() for further details.

Parameters

  tetIndex | the index in the triangulation of the tetrahedron in which the requested octagons reside; this should be between 0 and Triangulation<3>::size()-1 inclusive.
  octType | the type of this octagon in the given tetrahedron; this should be 0, 1 or 2.
  triang | the triangulation in which this normal surface lives.

Returns
  the number of octagonal discs of the given type.

Implemented in regina::NSVectorMirrored, regina::NSVectorOrientedQuad, regina::NSVectorOriented, regina::NSVectorANStandard, regina::NSVectorQuad, and regina::NSVectorStandard.

## octs() [8/8]

LargeInteger regina::NSVectorMirrored::octs | ( | size_t | tetIndex,
|  | int | octType,
|  | const Triangulation< 3 > * | triang
| ) |  | const

inline override virtual

Returns the number of octagonal discs of the given type in this normal surface.

See NormalSurface::octs() for further details.

Parameters

  tetIndex | the index in the triangulation of the tetrahedron in which the requested octagons reside; this should be between 0 and Triangulation<3>::size()-1 inclusive.
  octType | the type of this octagon in the given tetrahedron; this should be 0, 1 or 2.
  triang | the triangulation in which this normal surface lives.

Returns
  the number of octagonal discs of the given type.

Implements regina::NormalSurfaceVector.

Reimplemented in regina::NSVectorOrientedQuad, and regina::NSVectorQuad.

## operator!=() [1/5]

bool regina::DiscSpec::operator!= | ( | const DiscSpec & | other | ) | const

inline

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

Parameters

  other | the disc specifier to compare with this.

Returns
  `true` if and only if this and the given disc specifier contain different information.

## operator!=() [2/5]

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

  other | the iterator to compare with this.

Returns
  `true` if and only if this and the given iterator are equal.

## operator!=() [3/5]

bool regina::DiscType::operator!= | ( | const DiscType & | compare | ) | const

inline

Determines if this and the given disc type are different.

This is the negation of the equality test; see operator == for further details.

Returns
  `true` if this and the given disc type are different, or `false` if they are identical.

## operator!=() [4/5]

bool regina::PrismSpec::operator!= | ( | const PrismSpec & | other | ) | const

inline

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

Parameters

  other | the prism specifier to compare with this.

Returns
  `true` if and only if this and the given prism specifier contain different information.

## operator!=() [5/5]

bool regina::NormalSurfaces::VectorIterator::operator!= | ( | const VectorIterator & | other | ) | const

inline

Compares this with the given operator for inequality.

Parameters

  other | the iterator to compare this with.

Returns
  `false` if the iterators point to the same element of the same normal surface list, or `true` if they do not.

## operator()()

template<typename Coords >

void regina::NormalSurfaces::Enumerator::operator() | ( |  | ) |

Performs the real enumeration work, in a setting where the underlying coordinate system is a compile-time constant.

We assume here that neither list_->which_ nor list_->algorithm_ have been sanity-checked.

This routine fills list_ with surfaces, and then once this is finished it inserts list_ into the packet tree as a child of triang_.

Template Parameters

  Coords | an instance of the NormalInfo<> template class.

## operator*() [1/3]

NormalSurfaces::SurfaceInserter & regina::NormalSurfaces::SurfaceInserter::operator* | ( |  | ) |

inline

Returns a reference to this output iterator.

Returns
  this output iterator.

## operator*() [2/3]

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:\n 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*() [3/3]

const Ray & regina::NormalSurfaces::VectorIterator::operator* | ( |  | ) | const

inline

Returns the raw vector for the normal surface that this iterator is currently pointing to.

Precondition
  This iterator is dereferenceable (in particular, it is not past-the-end).

Returns
  the corresponding normal surface vector.

## operator++() [1/6]

void regina::DiscSpecIterator::operator++ | ( |  | ) |

inline

Points this iterator to the next disc, or makes it past-the-end if there is no next disc.

Unlike most standard increment operators, this operator returns `void`. One consequence of this is that the preincrement and postincrement operators for this class are identical. This interface will need to be made more standard some day.

Precondition
  This iterator is not past-the-end.

Python:\n This routine is called inc(), since Python does
  not support the increment operator.

## operator++() [2/6]

NormalSurfaces::VectorIterator & regina::NormalSurfaces::VectorIterator::operator++ | ( |  | ) |

inline

The preincrement operator.

Returns
  a reference to this iterator after the increment.

## operator++() [3/6]

NormalSurfaces::SurfaceInserter & regina::NormalSurfaces::SurfaceInserter::operator++ | ( |  | ) |

inline

Returns a reference to this output iterator.

Returns
  this output iterator.

## operator++() [4/6]

void regina::DiscSpecIterator::operator++ | ( | int |  | ) |

inline

Points this iterator to the next disc, or makes it past-the-end if there is no next disc.

Unlike most standard increment operators, this operator returns `void`. One consequence of this is that the preincrement and postincrement operators for this class are identical. This interface will need to be made more standard some day.

Precondition
  This iterator is not past-the-end.

Python:\n This routine is called inc(), since Python does
  not support the increment operator.

## operator++() [5/6]

NormalSurfaces::VectorIterator regina::NormalSurfaces::VectorIterator::operator++ | ( | int |  | ) |

inline

The postincrement operator.

Returns
  a copy of this iterator before the increment took place.

## operator++() [6/6]

NormalSurfaces::SurfaceInserter & regina::NormalSurfaces::SurfaceInserter::operator++ | ( | int |  | ) |

inline

Returns a reference to this output iterator.

Returns
  this output iterator.

## operator+=() [1/2]

void regina::NormalSurfaceVector::operator+= | ( | const NormalSurfaceVector & | other | ) |

inline virtual

Adds the given vector to this vector.

This behaves correctly in the case where other is this.

The default implementation simply adds the coordinates of the underlying vectors. Subclasses should reimplement this if they carry any additional information that also needs adjusting.

Precondition
  This and the given vector represent normal surfaces in the same triangulation, and use the same normal coordinate system.

Parameters

  other | the vector to add to this vector.

Reimplemented in regina::NSVectorMirrored.

## operator+=() [2/2]

void regina::NSVectorMirrored::operator+= | ( | const NormalSurfaceVector & | other | ) |

inline override virtual

Adds the given vector to this vector.

This behaves correctly in the case where other is this.

The default implementation simply adds the coordinates of the underlying vectors. Subclasses should reimplement this if they carry any additional information that also needs adjusting.

Precondition
  This and the given vector represent normal surfaces in the same triangulation, and use the same normal coordinate system.

Parameters

  other | the vector to add to this vector.

Reimplemented from regina::NormalSurfaceVector.

## operator--() [1/2]

NormalSurfaces::VectorIterator & regina::NormalSurfaces::VectorIterator::operator-- | ( |  | ) |

inline

The predecrement operator.

Returns
  a reference to this iterator after the decrement.

## operator--() [2/2]

NormalSurfaces::VectorIterator regina::NormalSurfaces::VectorIterator::operator-- | ( | int |  | ) |

inline

The postdecrement operator.

Returns
  a copy of this iterator before the decrement took place.

## operator<()

bool regina::DiscType::operator< | ( | const DiscType & | compare | ) | const

inline

Provides an ordering of disc types.

Types are ordered first by tetrahedron and then by type. NONE is considered less than all "meaningful" disc types.

Returns
  `true` if this disc type appears before the given disc type in the ordering, or `false` if not.

## operator<<() [1/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

  out | the output stream to which to write.
  spec | the disc specifier to write.

Returns
  a reference to out.

## operator<<() [2/3]

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

Writes the given disc type to the given output stream.

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

Parameters

  out | the output stream to which to write.
  type | the disc type to write.

Returns
  a reference to the given output stream.

## operator<<() [3/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

  out | the output stream to which to write.
  spec | the prism specifier to write.

Returns
  a reference to out.

## operator=() [1/7]

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

inline

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

Parameters

  cloneMe | the disc specifier whose values should be copied.

Returns
  a reference to this disc specifier.

## operator=() [2/7]

DiscType & regina::DiscType::operator= | ( | const DiscType & | cloneMe | ) |

inline

Sets this to a copy of the given disc type.

Parameters

  cloneMe | the disc type to clone.

Returns
  a reference to this disc type.

## operator=() [3/7]

PrismSpec & regina::PrismSpec::operator= | ( | const PrismSpec & | cloneMe | ) |

inline

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

Parameters

  cloneMe | the prism specifier whose values should be copied.

Returns
  a reference to this prism specifier.

## operator=() [4/7]

NormalSurfaces::SurfaceInserter & regina::NormalSurfaces::SurfaceInserter::operator= | ( | const SurfaceInserter & | cloneMe | ) |

inline

Sets this iterator to be a clone of the given output iterator.

Parameters

  cloneMe | the output iterator to clone.

Returns
  this output iterator.

## operator=() [5/7]

NormalSurfaces::VectorIterator & regina::NormalSurfaces::VectorIterator::operator= | ( | const VectorIterator & | cloneMe | ) |

inline

Makes this a copy of the given iterator.

Parameters

  cloneMe | the iterator to clone.

Returns
  a reference to this iterator.

## operator=() [6/7]

NormalSurfaces::SurfaceInserter & regina::NormalSurfaces::SurfaceInserter::operator= | ( | NormalSurface * | surface | ) |

inline

Appends a normal surface to the end of the appropriate surface list.

The given surface will be deallocated with the other surfaces in this list when the list is eventually destroyed.

Parameters

  surface | the normal surface to insert.

Returns
  this output iterator.

## operator=() [7/7]

NormalSurfaces::SurfaceInserter & regina::NormalSurfaces::SurfaceInserter::operator= | ( | NormalSurfaceVector * | vector | ) |

inline

Appends the normal surface corresponding to the given vector to the end of the appropriate surface list.

The given vector will be owned by the newly created normal surface and will be deallocated with the other surfaces in this list when the list is eventually destroyed.

Warning
  The behaviour of this routine has changed! As of Regina 4.6, this routine no longer checks for multiple octagonal discs. See the SurfaceInserter class notes for details.

Parameters

  vector | the vector of the normal surface to insert.

Returns
  this output iterator.

## operator==() [1/5]

bool regina::DiscSpec::operator== | ( | const DiscSpec & | other | ) | const

inline

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

Parameters

  other | the disc specifier to compare with this.

Returns
  `true` if and only if this and the given disc specifier contain identical information.

## operator==() [2/5]

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

  other | the iterator to compare with this.

Returns
  `true` if and only if this and the given iterator are equal.

## operator==() [3/5]

bool regina::DiscType::operator== | ( | const DiscType & | compare | ) | const

inline

Determines if this and the given disc type are identical.

Note that NONE is considered identical to NONE, and that NONE will not be equal to any "meaningful" disc type (specifically, a disc type for which type is non-negative).

Returns
  `true` if this and the given disc type are identical, or `false` if they are different.

## operator==() [4/5]

bool regina::PrismSpec::operator== | ( | const PrismSpec & | other | ) | const

inline

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

Parameters

  other | the prism specifier to compare with this.

Returns
  `true` if and only if this and the given prism specifier contain identical information.

## operator==() [5/5]

bool regina::NormalSurfaces::VectorIterator::operator== | ( | const VectorIterator & | other | ) | const

inline

Compares this with the given operator for equality.

Parameters

  other | the iterator to compare this with.

Returns
  `true` if the iterators point to the same element of the same normal surface list, or `false` if they do not.

## operator[]()

const NLargeInteger & regina::NormalSurfaceVector::operator[] | ( | size_t | index | ) | const

inline

Returns the given coordinate from the underlying vector.

Parameters

  index | the index of the coordinate to retrieve; this must be between 0 and size()-1 inclusive.

Returns
  the coordinate at the given index.

## operator|() [1/2]

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

inline

Returns the bitwise OR of the two given flags.

Parameters

  lhs | the first flag to combine.
  rhs | the second flag to combine.

Returns
  the combination of both flags.

## operator|() [2/2]

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

inline

Returns the bitwise OR of the two given flags.

Parameters

  lhs | the first flag to combine.
  rhs | the second flag to combine.

Returns
  the combination of both flags.

## orientability()

BoolSet regina::SurfaceFilterProperties::orientability | ( |  | ) | const

inline

Returns the set of allowable orientabilities.

Note that this is a subset of `{ true, false }`. Any surface whose orientability is not in this set will not be accepted by this filter.

Returns
  the set of allowable orientabilities.

## orientedQuads() [1/5]

LargeInteger regina::NormalSurface::orientedQuads | ( | size_t | tetIndex,
|  | int | quadType,
|  | bool | orientation
| ) |  | const

inline

Returns the number of oriented quadrilateral discs of the given type in this normal surface.

This routine is for coordinate systems that support transversely oriented normal surfaces; for details see "The Thurston norm via normal surfaces", Stephan Tillmann and Daryl Cooper, Pacific Journal of Mathematics 239 (2009), 1-15.

An oriented quadrilateral disc type is identified by specifying a tetrahedron, a quadrilateral type (0, 1 or 2) as described in quads(), and a boolean orientation. The `true` orientation indicates a transverse orientation pointing to the edge containing vertex 0 of the tetrahedron, and the `false` orientation indicates a transverse orientation pointing to the opposite edge.

If the underlying coordinate system does not support transverse orientation, this routine will simply return zero.

Parameters

  tetIndex | the index in the triangulation of the tetrahedron in which the requested quadrilaterals reside; this should be between 0 and Triangulation<3>::size()-1 inclusive.
  quadType | the type of this quadrilateral in the given tetrahedron; this should be 0, 1 or 2, as described above.
  orientation | the orientation of the quadrilateral disc

Returns
  the number of quadrilateral discs of the given type.

## orientedQuads() [2/5]

LargeInteger regina::NSVectorOriented::orientedQuads | ( | size_t | tetIndex,
|  | int | quadType,
|  | const Triangulation< 3 > * | triang,
|  | bool | orientation
| ) |  | const

inline virtual

Returns the number of oriented quadrilateral discs of the given type in this normal surface.

See NormalSurface::orientedQuads() for further details.

The default implementation of this routine returns zero, which is suitable for coordinate systems that do not support transverse orientation.

Parameters

  tetIndex | the index in the triangulation of the tetrahedron in which the requested quadrilaterals reside; this should be between 0 and Triangulation<3>::size()-1 inclusive.
  quadType | the type of this quadrilateral in the given tetrahedron; this should be 0, 1 or 2.
  triang | the triangulation in which this normal surface lives.
  orientation | the orientation of the normal discs.

Returns
  the number of quadrilateral discs of the given type.

Reimplemented from regina::NormalSurfaceVector.

## orientedQuads() [3/5]

LargeInteger regina::NSVectorOrientedQuad::orientedQuads | ( | size_t | tetIndex,
|  | int | quadType,
|  | const Triangulation< 3 > * | triang,
|  | bool | orientation
| ) |  | const

inline virtual

Returns the number of oriented quadrilateral discs of the given type in this normal surface.

See NormalSurface::orientedQuads() for further details.

The default implementation of this routine returns zero, which is suitable for coordinate systems that do not support transverse orientation.

Parameters

  tetIndex | the index in the triangulation of the tetrahedron in which the requested quadrilaterals reside; this should be between 0 and Triangulation<3>::size()-1 inclusive.
  quadType | the type of this quadrilateral in the given tetrahedron; this should be 0, 1 or 2.
  triang | the triangulation in which this normal surface lives.
  orientation | the orientation of the normal discs.

Returns
  the number of quadrilateral discs of the given type.

Reimplemented from regina::NSVectorMirrored.

## orientedQuads() [4/5]

virtual LargeInteger regina::NormalSurfaceVector::orientedQuads | ( | size_t | tetIndex,
|  | int | quadType,
|  | const Triangulation< 3 > * | triang,
|  | bool | orientation
| ) |  | const

virtual

Returns the number of oriented quadrilateral discs of the given type in this normal surface.

See NormalSurface::orientedQuads() for further details.

The default implementation of this routine returns zero, which is suitable for coordinate systems that do not support transverse orientation.

Parameters

  tetIndex | the index in the triangulation of the tetrahedron in which the requested quadrilaterals reside; this should be between 0 and Triangulation<3>::size()-1 inclusive.
  quadType | the type of this quadrilateral in the given tetrahedron; this should be 0, 1 or 2.
  triang | the triangulation in which this normal surface lives.
  orientation | the orientation of the normal discs.

Returns
  the number of quadrilateral discs of the given type.

Reimplemented in regina::NSVectorMirrored, regina::NSVectorOrientedQuad, and regina::NSVectorOriented.

## orientedQuads() [5/5]

LargeInteger regina::NSVectorMirrored::orientedQuads | ( | size_t | tetIndex,
|  | int | quadType,
|  | const Triangulation< 3 > * | triang,
|  | bool | orientation
| ) |  | const

inline override virtual

Returns the number of oriented quadrilateral discs of the given type in this normal surface.

See NormalSurface::orientedQuads() for further details.

The default implementation of this routine returns zero, which is suitable for coordinate systems that do not support transverse orientation.

Parameters

  tetIndex | the index in the triangulation of the tetrahedron in which the requested quadrilaterals reside; this should be between 0 and Triangulation<3>::size()-1 inclusive.
  quadType | the type of this quadrilateral in the given tetrahedron; this should be 0, 1 or 2.
  triang | the triangulation in which this normal surface lives.
  orientation | the orientation of the normal discs.

Returns
  the number of quadrilateral discs of the given type.

Reimplemented from regina::NormalSurfaceVector.

Reimplemented in regina::NSVectorOrientedQuad.

## orientedTriangles() [1/4]

LargeInteger regina::NormalSurface::orientedTriangles | ( | size_t | tetIndex,
|  | int | vertex,
|  | bool | orientation
| ) |  | const

inline

Returns the number of oriented triangular discs of the given type in this normal surface.

This routine is for coordinate systems that support transversely oriented normal surfaces; for details see "The Thurston norm via normal surfaces", Stephan Tillmann and Daryl Cooper, Pacific Journal of Mathematics 239 (2009), 1-15.

An oriented triangular disc type is identified by specifying a tetrahedron, a vertex of that tetrahedron that the triangle surrounds, and a boolean orientation. The `true` orientation indicates a transverse orientation pointing to the nearby vertex, and the `false` orientation indicates a transverse orientation pointing to the opposite face.

If the underlying coordinate system does not support transverse orientation, this routine will simply return zero.

Parameters

  tetIndex | the index in the triangulation of the tetrahedron in which the requested triangles reside; this should be between 0 and Triangulation<3>::size()-1 inclusive.
  vertex | the vertex of the given tetrahedron around which the requested triangles lie; this should be between 0 and 3 inclusive.
  orientation | the orientation of the triangle

Returns
  the number of triangular discs of the given type.

## orientedTriangles() [2/4]

LargeInteger regina::NSVectorOriented::orientedTriangles | ( | size_t | tetIndex,
|  | int | vertex,
|  | const Triangulation< 3 > * | triang,
|  | bool | orientation
| ) |  | const

inline virtual

Returns the number of oriented triangular discs of the given type in this normal surface.

See NormalSurface::orientedTriangles() for further details.

The default implementation of this routine returns zero, which is suitable for coordinate systems that do not support transverse orientation.

Parameters

  tetIndex | the index in the triangulation of the tetrahedron in which the requested triangles reside; this should be between 0 and Triangulation<3>::size()-1 inclusive.
  vertex | the vertex of the given tetrahedron around which the requested triangles lie; this should be between 0 and 3 inclusive.
  triang | the triangulation in which this normal surface lives.
  orientation | the orientation of the normal discs.

Returns
  the number of triangular discs of the given type.

Reimplemented from regina::NormalSurfaceVector.

## orientedTriangles() [3/4]

virtual LargeInteger regina::NormalSurfaceVector::orientedTriangles | ( | size_t | tetIndex,
|  | int | vertex,
|  | const Triangulation< 3 > * | triang,
|  | bool | orientation
| ) |  | const

virtual

Returns the number of oriented triangular discs of the given type in this normal surface.

See NormalSurface::orientedTriangles() for further details.

The default implementation of this routine returns zero, which is suitable for coordinate systems that do not support transverse orientation.

Parameters

  tetIndex | the index in the triangulation of the tetrahedron in which the requested triangles reside; this should be between 0 and Triangulation<3>::size()-1 inclusive.
  vertex | the vertex of the given tetrahedron around which the requested triangles lie; this should be between 0 and 3 inclusive.
  triang | the triangulation in which this normal surface lives.
  orientation | the orientation of the normal discs.

Returns
  the number of triangular discs of the given type.

Reimplemented in regina::NSVectorMirrored, and regina::NSVectorOriented.

## orientedTriangles() [4/4]

LargeInteger regina::NSVectorMirrored::orientedTriangles | ( | size_t | tetIndex,
|  | int | vertex,
|  | const Triangulation< 3 > * | triang,
|  | bool | orientation
| ) |  | const

inline override virtual

Returns the number of oriented triangular discs of the given type in this normal surface.

See NormalSurface::orientedTriangles() for further details.

The default implementation of this routine returns zero, which is suitable for coordinate systems that do not support transverse orientation.

Parameters

  tetIndex | the index in the triangulation of the tetrahedron in which the requested triangles reside; this should be between 0 and Triangulation<3>::size()-1 inclusive.
  vertex | the vertex of the given tetrahedron around which the requested triangles lie; this should be between 0 and 3 inclusive.
  triang | the triangulation in which this normal surface lives.
  orientation | the orientation of the normal discs.

Returns
  the number of triangular discs of the given type.

Reimplemented from regina::NormalSurfaceVector.

## packet() [1/2]

Packet * regina::XMLFilterPacketReader::packet | ( |  | ) |

inline override virtual

Returns the newly allocated packet that has been read by this element reader.

Deallocation of this new packet is not the responsibility of this class. Once this routine gives a non-zero return value, it should continue to give the same non-zero return value from this point onwards.

If this routine is ever to give a non-zero return value, it must be giving that non-zero return value by the time the first child packet or packet tag is encountered; otherwise child packets will not be inserted into the packet tree and/or packet tags will not be added.

The newly allocated packet should not be given a packet label. This will be done by XMLPacketReader::endSubElement().

The newly allocated packet may or may not be inserted in the packet tree structure; this does not matter (although if it is inserted it must be inserted in the correct place).

The newly allocated packet should not be given any associated packet tags. This will be done by XMLPacketReader::startSubElement().

The default implementation returns 0.

Returns
  the packet that has been read, or 0 if packet reading is incomplete, the packet should be ignored or an error occurred.

Reimplemented from regina::XMLPacketReader.

## packet() [2/2]

Packet * regina::XMLNormalSurfacesReader::packet | ( |  | ) |

inline override virtual

Returns the newly allocated packet that has been read by this element reader.

Deallocation of this new packet is not the responsibility of this class. Once this routine gives a non-zero return value, it should continue to give the same non-zero return value from this point onwards.

If this routine is ever to give a non-zero return value, it must be giving that non-zero return value by the time the first child packet or packet tag is encountered; otherwise child packets will not be inserted into the packet tree and/or packet tags will not be added.

The newly allocated packet should not be given a packet label. This will be done by XMLPacketReader::endSubElement().

The newly allocated packet may or may not be inserted in the packet tree structure; this does not matter (although if it is inserted it must be inserted in the correct place).

The newly allocated packet should not be given any associated packet tags. This will be done by XMLPacketReader::startSubElement().

The default implementation returns 0.

Returns
  the packet that has been read, or 0 if packet reading is incomplete, the packet should be ignored or an error occurred.

Reimplemented from regina::XMLPacketReader.

## PrismSpec() [1/3]

regina::PrismSpec::PrismSpec | ( |  | ) |

inline

Creates a new uninitialised prism specifier.

## PrismSpec() [2/3]

regina::PrismSpec::PrismSpec | ( | const PrismSpec & | cloneMe | ) |

inline

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

Parameters

  cloneMe | the prism specifier to clone.

## PrismSpec() [3/3]

regina::PrismSpec::PrismSpec | ( | size_t | newTetIndex,
|  | int | newEdge
| ) |  |

inline

Creates a new prism specifier containing the given values.

Parameters

  newTetIndex | the index in the triangulation of the tetrahedron containing the prism.
  newEdge | the edge of the tetrahedron that is contained in this prism; this must be between 0 and 5 inclusive.

## quadOctToStandardAN()

NormalSurfaces* regina::NormalSurfaces::quadOctToStandardAN | ( |  | ) | const

Converts the set of all embedded vertex almost normal surfaces in quadrilateral-octagon space to the set of all embedded vertex almost normal surfaces in the standard tri-quad-oct space.

This routine is the almost normal analogue to the quadToStandard() conversion routine; see the quadToStandard() documentation for further information.

Precondition
  The underlying triangulation (the parent packet of this normal surface list) is valid, and the link of every vertex is either a sphere or a disc.
  This surface list is precisely the set of all embedded vertex almost normal surfaces in quadrilateral-octagon space; no more, no less. Moreover, these vectors are stored using quadrilateral-octagon coordinates. Typically this means that it was obtained through enumerate(), with the coordinate system set to NS_AN_QUAD_OCT and with embeddedOnly set to `true`.

Returns
  a full list of vertex almost normal surfaces in standard tri-quad-oct coordinates, or 0 if any of the basic sanity checks failed.

## quads() [1/7]

LargeInteger regina::NormalSurface::quads | ( | size_t | tetIndex,
|  | int | quadType
| ) |  | const

inline

Returns the number of quadrilateral discs of the given type in this normal surface.

In each tetrahedron, there are three types of quadrilaterals, defined by how they separate the four tetrahedron vertices into two pairs. Quadrilateral type i (for i = 0, 1 or 2) is defined to separate edge i of the tetrahedron from edge (5-i). That is:

- type 0 separates vertices 0,1 of the tetrahedron from vertices 2,3;
- type 1 separates vertices 0,2 of the tetrahedron from vertices 1,3;
- type 2 separates vertices 0,3 of the tetrahedron from vertices 1,2.

If you are using a coordinate system that adorns discs with additional information (such as orientation), this routine returns the total number of quadrilaterals in the given tetrahedron of the given type.

Parameters

  tetIndex | the index in the triangulation of the tetrahedron in which the requested quadrilaterals reside; this should be between 0 and Triangulation<3>::size()-1 inclusive.
  quadType | the type of this quadrilateral in the given tetrahedron; this should be 0, 1 or 2, as described above.

Returns
  the number of quadrilateral discs of the given type.

## quads() [2/7]

LargeInteger regina::NSVectorStandard::quads | ( | size_t | tetIndex,
|  | int | quadType,
|  | const Triangulation< 3 > * | triang
| ) |  | const

inline virtual

Returns the number of quadrilateral discs of the given type in this normal surface.

See NormalSurface::quads() for further details.

Parameters

  tetIndex | the index in the triangulation of the tetrahedron in which the requested quadrilaterals reside; this should be between 0 and Triangulation<3>::size()-1 inclusive.
  quadType | the type of this quadrilateral in the given tetrahedron; this should be 0, 1 or 2.
  triang | the triangulation in which this normal surface lives.

Returns
  the number of quadrilateral discs of the given type.

Implements regina::NormalSurfaceVector.

## quads() [3/7]

LargeInteger regina::NSVectorOriented::quads | ( | size_t | tetIndex,
|  | int | quadType,
|  | const Triangulation< 3 > * | triang
| ) |  | const

inline virtual

Returns the number of quadrilateral discs of the given type in this normal surface.

See NormalSurface::quads() for further details.

Parameters

  tetIndex | the index in the triangulation of the tetrahedron in which the requested quadrilaterals reside; this should be between 0 and Triangulation<3>::size()-1 inclusive.
  quadType | the type of this quadrilateral in the given tetrahedron; this should be 0, 1 or 2.
  triang | the triangulation in which this normal surface lives.

Returns
  the number of quadrilateral discs of the given type.

Implements regina::NormalSurfaceVector.

## quads() [4/7]

LargeInteger regina::NSVectorANStandard::quads | ( | size_t | tetIndex,
|  | int | quadType,
|  | const Triangulation< 3 > * | triang
| ) |  | const

inline virtual

Returns the number of quadrilateral discs of the given type in this normal surface.

See NormalSurface::quads() for further details.

Parameters

  tetIndex | the index in the triangulation of the tetrahedron in which the requested quadrilaterals reside; this should be between 0 and Triangulation<3>::size()-1 inclusive.
  quadType | the type of this quadrilateral in the given tetrahedron; this should be 0, 1 or 2.
  triang | the triangulation in which this normal surface lives.

Returns
  the number of quadrilateral discs of the given type.

Implements regina::NormalSurfaceVector.

## quads() [5/7]

LargeInteger regina::NSVectorOrientedQuad::quads | ( | size_t | tetIndex,
|  | int | quadType,
|  | const Triangulation< 3 > * | triang
| ) |  | const

inline virtual

Returns the number of quadrilateral discs of the given type in this normal surface.

See NormalSurface::quads() for further details.

Parameters

  tetIndex | the index in the triangulation of the tetrahedron in which the requested quadrilaterals reside; this should be between 0 and Triangulation<3>::size()-1 inclusive.
  quadType | the type of this quadrilateral in the given tetrahedron; this should be 0, 1 or 2.
  triang | the triangulation in which this normal surface lives.

Returns
  the number of quadrilateral discs of the given type.

Reimplemented from regina::NSVectorMirrored.

## quads() [6/7]

virtual LargeInteger regina::NormalSurfaceVector::quads | ( | size_t | tetIndex,
|  | int | quadType,
|  | const Triangulation< 3 > * | triang
| ) |  | const

pure virtual

Returns the number of quadrilateral discs of the given type in this normal surface.

See NormalSurface::quads() for further details.

Parameters

  tetIndex | the index in the triangulation of the tetrahedron in which the requested quadrilaterals reside; this should be between 0 and Triangulation<3>::size()-1 inclusive.
  quadType | the type of this quadrilateral in the given tetrahedron; this should be 0, 1 or 2.
  triang | the triangulation in which this normal surface lives.

Returns
  the number of quadrilateral discs of the given type.

Implemented in regina::NSVectorMirrored, regina::NSVectorOrientedQuad, regina::NSVectorANStandard, regina::NSVectorOriented, and regina::NSVectorStandard.

## quads() [7/7]

LargeInteger regina::NSVectorMirrored::quads | ( | size_t | tetIndex,
|  | int | quadType,
|  | const Triangulation< 3 > * | triang
| ) |  | const

inline override virtual

Returns the number of quadrilateral discs of the given type in this normal surface.

See NormalSurface::quads() for further details.

Parameters

  tetIndex | the index in the triangulation of the tetrahedron in which the requested quadrilaterals reside; this should be between 0 and Triangulation<3>::size()-1 inclusive.
  quadType | the type of this quadrilateral in the given tetrahedron; this should be 0, 1 or 2.
  triang | the triangulation in which this normal surface lives.

Returns
  the number of quadrilateral discs of the given type.

Implements regina::NormalSurfaceVector.

Reimplemented in regina::NSVectorOrientedQuad.

## quadToStandard()

NormalSurfaces* regina::NormalSurfaces::quadToStandard | ( |  | ) | const

Converts the set of all embedded vertex normal surfaces in quadrilateral space to the set of all embedded vertex normal surfaces in standard (tri-quad) space.

The initial list in quadrilateral space is taken to be this normal surface list; the final list in standard space will be inserted as a new child packet of the underlying triangulation (specifically, as the final child). As a convenience, the final list will also be returned from this routine.

This routine can only be used with normal surfaces, not almost normal surfaces. For almost normal surfaces, see the similar routine quadOctToStandardAN().

This procedure is available for any triangulation whose vertex links are all spheres and/or discs, and is much faster than enumerating surfaces directly in standard tri-quad coordinates. The underlying algorithm is described in detail in "Converting between quadrilateral and standard solution sets in normal surface theory", Benjamin A. Burton, Algebr. Geom. Topol. 9 (2009), 2121-2174.

Typically users do not need to call this routine directly, since the standard enumerate() routine will use it implicitly where possible. That is, when asked for standard vertex surfaces, enumerate() will first find all quadrilateral vertex surfaces and then use this procedure to convert them to standard vertex surfaces; this is generally orders of magnitude faster than enumerating surfaces directly in standard coordinates.

Nevertheless, this standalone routine is provided as a convenience for users who already have a set of quadrilateral vertex surfaces, and who simply wish to convert them to a set of standard vertex surfaces without the cost of implicitly enumerating the quadrilateral vertex surfaces again.

It should be noted that this routine does not simply convert vectors from one form to another; instead it converts a full solution set of vertex surfaces in quadrilateral coordinates to a full solution set of vertex surfaces in standard coordinates. Typically there are many more vertex surfaces in standard coordinates (all of which this routine will find).

This routine will run some very basic sanity checks before starting. Specifically, it will check the validity and vertex links of the underlying triangulation, and will verify that the coordinate system and embedded-only flag are set to NS_QUAD and `true` respectively. If any of these checks fails, this routine will do nothing and return 0.

Precondition
  The underlying triangulation (the parent packet of this normal surface list) is valid, and the link of every vertex is either a sphere or a disc.
  This normal surface list is precisely the set of all embedded vertex normal surfaces in quadrilateral space; no more, no less. Moreover, these vectors are stored using quadrilateral coordinates. Typically this means that it was obtained through enumerate(), with the coordinate system set to NS_QUAD and with embeddedOnly set to `true`.

Returns
  a full list of vertex normal surfaces in standard (tri-quad) coordinates, or 0 if any of the basic sanity checks failed.

## rawVector()

const Ray & regina::NormalSurface::rawVector | ( |  | ) | const

inline

Gives read-only access to the raw vector that sits beneath this normal surface.

Generally users should not need this function. However, it is provided here in case the need should arise (e.g., for reasons of efficiency).

Warning
  A NormalSurface does not know what underlying coordinate system its raw vector uses. Unless you already know the coordinate system in advance (i.e., you created the surface yourself), it is best to keep to the coordinate-system-agnostic access functions such as NormalSurfaceVector::triangles() and NormalSurfaceVector::quads().

Python:\n Not present.

Returns
  the underlying raw vector.

## realBoundary()

BoolSet regina::SurfaceFilterProperties::realBoundary | ( |  | ) | const

inline

Returns the set of allowable has-real-boundary properties.

Note that this is a subset of `{ true, false }`. Any surface whose has-real-boundary property is not in this set will not be accepted by this filter.

Returns
  the set of allowable has-real-boundary properties.

## recreateMatchingEquations()

MatrixInt* regina::NormalSurfaces::recreateMatchingEquations | ( |  | ) | const

Returns a newly created matrix containing the matching equations that were used to create this normal surface list.

The destruction of this matrix is the responsibility of the caller of this routine. Multiple calls to this routine will result in the construction of multiple matrices. This routine in fact merely calls makeMatchingEquations() with the appropriate parameters.

The format of the matrix is identical to that returned by makeMatchingEquations().

Returns
  the matching equations used to create this normal surface list.

## removeAllEulerChars()

void regina::SurfaceFilterProperties::removeAllEulerChars | ( |  | ) |

inline

Empties the set of allowable Euler characteristics.

See eulerChars() for further details.

Note that this will mean that this filter will allow any Euler characteristic to pass.

## removeEulerChar()

void regina::SurfaceFilterProperties::removeEulerChar | ( | const LargeInteger & | ec | ) |

inline

Removes the given Euler characteristic from the set of allowable Euler characteristics.

See eulerChars() for further details.

Note that if the allowable set is completely emptied, this filter will allow any Euler characteristic to pass.

Precondition
  The given Euler characteristic is currently in the allowable set.

Parameters

  ec | the allowable Euler characteristic to remove.

## sameSurface()

bool regina::NormalSurface::sameSurface | ( | const NormalSurface & | other | ) | const

Determines whether this and the given surface in fact represent the same normal (or almost normal) surface.

Specifically, this routine examines (or computes) the number of normal or almost normal discs of each type, and returns `true` if and only if these counts are the same for both surfaces.

It does not matter what coordinate systems the two surfaces use. In particular, it does not matter if this and the given surface use different coordinate systems, and it does not matter if one surface uses an almost normal coordinate system and the other does not.

Precondition
  Both this and the given normal surface live within the same 3-manifold triangulation.

Parameters

  other | the surface to be compared with this surface.

Returns
  `true` if both surfaces represent the same normal or almost normal surface, or `false` if not.

## saveCSVEdgeWeight()

bool regina::NormalSurfaces::saveCSVEdgeWeight | ( | const char * | filename,
|  | int | additionalFields = `regina::surfaceExportAll`
| ) |  |

Exports the given list of normal surfaces as a plain text CSV (comma-separated value) file, using edge weight coordinates.

CSV files are human-readable and human-editable, and are suitable for importing into spreadsheets and databases.

The surfaces will be exported in edge weight coordinates. Thus there will be one coordinate for each edge of the underlying triangulation; each such coordinate will become a separate field in the CSV file.

As well as the normal surface coordinates, additional properties of the normal surfaces (such as Euler characteristic, orientability, and so on) can be included as extra fields in the export. Users can select precisely which properties to include by passing a bitmask, formed as a bitwise or combination of constants from the regina::SurfaceExportFields enumeration type.

The CSV format used here begins with a header row, and uses commas as field separators. Text fields with arbitrary contents are placed inside double quotes, and the double quote character itself is represented by a pair of double quotes. Thus the string `my "normal" surface's name` would be stored as `"my ""normal"" surface's name"`.

Internationalisation:\n This routine makes no assumptions about the
  character encoding used in the given file name, and simply passes it through unchanged to low-level C/C++ file I/O routines. Any user strings such as surface names will be written in UTF-8.

Parameters

  filename | the name of the CSV file to export to.
  additionalFields | a bitwise combination of constants from regina::SurfaceExportFields indicating which additional properties of surfaces should be included in the export.

Returns
  `true` if the export was successful, or `false` otherwise.

## saveCSVStandard()

bool regina::NormalSurfaces::saveCSVStandard | ( | const char * | filename,
|  | int | additionalFields = `regina::surfaceExportAll`
| ) |  |

Exports this list of normal surfaces as a plain text CSV (comma-separated value) file, using standard coordinates.

CSV files are human-readable and human-editable, and are suitable for importing into spreadsheets and databases.

The surfaces will be exported in standard coordinates (tri-quad coordinates for normal surfaces, or tri-quad-oct coordinates for almost normal surfaces). Each coordinate will become a separate field in the CSV file.

As well as the normal surface coordinates, additional properties of the normal surfaces (such as Euler characteristic, orientability, and so on) can be included as extra fields in the export. Users can select precisely which properties to include by passing a bitmask, formed as a bitwise or combination of constants from the regina::SurfaceExportFields enumeration type.

The CSV format used here begins with a header row, and uses commas as field separators. Text fields with arbitrary contents are placed inside double quotes, and the double quote character itself is represented by a pair of double quotes. Thus the string `my "normal" surface's name` would be stored as `"my ""normal"" surface's name"`.

Internationalisation:\n This routine makes no assumptions about the
  character encoding used in the given file name, and simply passes it through unchanged to low-level C/C++ file I/O routines. Any user strings such as surface names will be written in UTF-8.

Parameters

  filename | the name of the CSV file to export to.
  additionalFields | a bitwise combination of constants from regina::SurfaceExportFields indicating which additional properties of surfaces should be included in the export.

Returns
  `true` if the export was successful, or `false` otherwise.

## scaleDown() [1/2]

void regina::NormalSurfaceVector::scaleDown | ( |  | ) |

inline virtual

Scales this vector down by the greatest common divisor of all its elements.

The resulting vector will be the smallest multiple of the original that maintains integral entries, and these entries will have the same signs as the originals.

This routine poses no problem for vectors containing infinite elements; such elements are simply ignored and left at infinity.

The default implementation simply scales down the underlying vector. Subclasses should reimplement this if they carry any additional information that also needs adjusting.

Reimplemented in regina::NSVectorMirrored.

## scaleDown() [2/2]

void regina::NSVectorMirrored::scaleDown | ( |  | ) |

inline override virtual

Scales this vector down by the greatest common divisor of all its elements.

The resulting vector will be the smallest multiple of the original that maintains integral entries, and these entries will have the same signs as the originals.

This routine poses no problem for vectors containing infinite elements; such elements are simply ignored and left at infinity.

The default implementation simply scales down the underlying vector. Subclasses should reimplement this if they carry any additional information that also needs adjusting.

Reimplemented from regina::NormalSurfaceVector.

## setCompactness()

void regina::SurfaceFilterProperties::setCompactness | ( | const BoolSet & | value | ) |

inline

Sets the set of allowable compactness properties.

See compactness() for further details.

Parameters

  value | the new set of allowable compactness properties.

## setElement() [1/2]

void regina::NormalSurfaceVector::setElement | ( | size_t | index,
|  | const LargeInteger & | value
| ) |  |

inline virtual

Sets the given normal coordinate to the given value.

The default implementation simply sets the coordinate in the underlying vector. Subclasses should reimplement this if they carry any additional information that also need adjusting.

Parameters

  index | the index of the coordinate to set; this must be between 0 and size()-1 inclusive.
  value | the new value to assign to the given coordinate.

Reimplemented in regina::NSVectorMirrored.

## setElement() [2/2]

void regina::NSVectorMirrored::setElement | ( | size_t | index,
|  | const LargeInteger & | value
| ) |  |

inline override virtual

Sets the given normal coordinate to the given value.

The default implementation simply sets the coordinate in the underlying vector. Subclasses should reimplement this if they carry any additional information that also need adjusting.

Parameters

  index | the index of the coordinate to set; this must be between 0 and size()-1 inclusive.
  value | the new value to assign to the given coordinate.

Reimplemented from regina::NormalSurfaceVector.

## setEulerChars()

void regina::SurfaceFilterProperties::setEulerChars | ( | const std::set< LargeInteger > & | s | ) |

inline

Sets the allowable Euler characteristics to the given set.

See eulerChars() for further details.

Interfaces:\n Not present.

Parameters

  s | the new set of allowable Euler characteristics.

## setName()

void regina::NormalSurface::setName | ( | const std::string & | newName | ) |

inline

Sets the name associated with this normal surface.

Names are optional and need not be unique. The default name for a surface is the empty string.

Parameters

  newName | the new name to associate with this surface.

## setOrientability()

void regina::SurfaceFilterProperties::setOrientability | ( | const BoolSet & | value | ) |

inline

Sets the set of allowable orientabilities.

See orientability() for further details.

Parameters

  value | the new set of allowable orientabilities.

## setRealBoundary()

void regina::SurfaceFilterProperties::setRealBoundary | ( | const BoolSet & | value | ) |

inline

Sets the set of allowable has-real-boundary properties.

See realBoundary() for further details.

Parameters

  value | the new set of allowable has-real-boundary properties.

## setUsesAnd()

void regina::SurfaceFilterCombination::setUsesAnd | ( | bool | value | ) |

inline

Sets whether this is an and or an or combination.

Parameters

  value | `true` if this is to be an and combination, or `false` if this is to be an or combination.

## size() [1/2]

size_t regina::NormalSurfaces::size | ( |  | ) | const

inline

Returns the number of surfaces stored in this list.

Returns
  the number of surfaces.

## size() [2/2]

size_t regina::NormalSurfaceVector::size | ( |  | ) | const

inline

Returns the number of coordinates in the underlying vector.

Returns
  the number of coordinates.

## standardANToQuadOct()

NormalSurfaces* regina::NormalSurfaces::standardANToQuadOct | ( |  | ) | const

Converts the set of all embedded vertex almost normal surfaces in standard tri-quad-oct space to the set of all embedded vertex almost normal surfaces in the smaller quadrilateral-octagon space.

This routine is the almost normal analogue to the standardToQuad() conversion routine; see the standardToQuad() documentation for further information.

Precondition
  The underlying triangulation (the parent packet of this normal surface list) is valid, and the link of every vertex is either a sphere or a disc.
  This normal surface list is precisely the set of all embedded vertex almost normal surfaces in standard tri-quad-oct space; no more, no less. Typically this means that it was obtained through enumerate(), with the coordinate system set to NS_AN_STANDARD and with embeddedOnly set to `true`.

Returns
  a full list of vertex almost normal surfaces in quadrilateral-octagon coordinates, or 0 if any of the basic sanity checks failed.

## standardToQuad()

NormalSurfaces* regina::NormalSurfaces::standardToQuad | ( |  | ) | const

Converts the set of all embedded vertex normal surfaces in standard (tri-quad) space to the set of all embedded vertex normal surfaces in quadrilateral space.

The initial list in standard space is taken to be this normal surface list; the final list in quadrilateral space will be inserted as a new child packet of the underlying triangulation (specifically, as the final child). As a convenience, the final list will also be returned from this routine.

This routine can only be used with normal surfaces, not almost normal surfaces. For almost normal surfaces, see the similar routine standardANToQuadOct().

This procedure is available for any triangulation whose vertex links are all spheres and/or discs. The underlying algorithm is described in detail in "Converting between quadrilateral and standard solution sets in normal surface theory", Benjamin A. Burton, Algebr. Geom. Topol. 9 (2009), 2121-2174.

It should be noted that this routine does not simply convert vectors from one form to another; instead it converts a full solution set of vertex surfaces in standard coordinates to a full solution set of vertex surfaces in quadrilateral coordinates. Typically there are far fewer vertex surfaces in quadrilateral coordinates (all of which this routine will find).

This routine will run some very basic sanity checks before starting. Specifically, it will check the validity and vertex links of the underlying triangulation, and will verify that the coordinate system and embedded-only flag are set to NS_STANDARD and `true` respectively. If any of these checks fails, this routine will do nothing and return 0.

Precondition
  The underlying triangulation (the parent packet of this normal surface list) is valid, and the link of every vertex is either a sphere or a disc.
  This normal surface list is precisely the set of all embedded vertex normal surfaces in standard (tri-quad) space; no more, no less. Moreover, these vectors are stored using standard coordinates. Typically this means that this list was obtained through enumerate(), with the coordinate system set to NS_STANDARD and with embeddedOnly set to `true`.

Returns
  a full list of vertex normal surfaces in quadrilateral coordinates, or 0 if any of the basic sanity checks failed.

## startContentSubElement() [1/2]

virtual XMLElementReader* regina::XMLFilterPacketReader::startContentSubElement | ( | const std::string & | subTagName,
|  | const regina::xml::XMLPropertyDict & | subTagProps
| ) |  |

override virtual

Used instead of startSubElement() for XML subelements that are not child packets or packet tags.

The default implementation returns a new XMLElementReader which can be used to ignore the subelement completely.

Parameters

  subTagName | the name of the subelement opening tag.
  subTagProps | the properties associated with the subelement opening tag.

Returns
  a newly created element reader that will be used to parse the subelement. This class should not take care of the new reader's destruction; that will be done by the parser.

Reimplemented from regina::XMLPacketReader.

## startContentSubElement() [2/2]

virtual XMLElementReader* regina::XMLNormalSurfacesReader::startContentSubElement | ( | const std::string & | subTagName,
|  | const regina::xml::XMLPropertyDict & | subTagProps
| ) |  |

override virtual

Used instead of startSubElement() for XML subelements that are not child packets or packet tags.

The default implementation returns a new XMLElementReader which can be used to ignore the subelement completely.

Parameters

  subTagName | the name of the subelement opening tag.
  subTagProps | the properties associated with the subelement opening tag.

Returns
  a newly created element reader that will be used to parse the subelement. This class should not take care of the new reader's destruction; that will be done by the parser.

Reimplemented from regina::XMLPacketReader.

## startElement()

virtual void regina::XMLNormalSurfaceReader::startElement | ( | const std::string & | tagName,
|  | const regina::xml::XMLPropertyDict & | tagProps,
|  | XMLElementReader * | parentReader
| ) |  |

virtual

Signifies that parsing of this XML element is beginning.

The default implementation does nothing.

Parameters

  tagName | the name of the opening tag for this element.
  tagProps | the properties associated with the opening tag.
  parentReader | the reader currently parsing the parent XML element, or 0 if this is the top-level element. If this paraneter is non-zero, it is guaranteed that startSubElement() has already been called upon the parent reader.

Reimplemented from regina::XMLElementReader.

## startSubElement()

virtual XMLElementReader* regina::XMLNormalSurfaceReader::startSubElement | ( | const std::string & | subTagName,
|  | const regina::xml::XMLPropertyDict & | subTagProps
| ) |  |

virtual

Signifies that a subelement of this XML element is about to be parsed.

The default implementation returns a new XMLElementReader which can be used to ignore the subelement completely.

Parameters

  subTagName | the name of the subelement opening tag.
  subTagProps | the properties associated with the subelement opening tag.

Returns
  a newly created element reader that will be used to parse the subelement. This class should not take care of the new reader's destruction; that will be done by the parser.

Reimplemented from regina::XMLElementReader.

## surface() [1/2]

NormalSurface * regina::XMLNormalSurfaceReader::surface | ( |  | ) |

inline

Returns the normal surface that has been read.

Returns
  the newly allocated normal surface, or 0 if an error occurred.

## surface() [2/2]

const NormalSurface * regina::NormalSurfaces::surface | ( | size_t | index | ) | const

inline

Returns the surface at the requested index in this set.

Parameters

  index | the index of the requested surface in this set; this must be between 0 and size()-1 inclusive.

Returns
  the normal surface at the requested index in this set.

## SurfaceFilter() [1/2]

regina::SurfaceFilter::SurfaceFilter | ( |  | ) |

inline

Creates a new default surface filter.

This will simply accept all normal surfaces.

## SurfaceFilter() [2/2]

regina::SurfaceFilter::SurfaceFilter | ( | const SurfaceFilter & | cloneMe | ) |

inline

Creates a new default surface filter.

This will simply accept all normal surfaces. Note that the given parameter is ignored.

Parameters

  cloneMe | this parameter is ignored.

## SurfaceFilterCombination() [1/2]

regina::SurfaceFilterCombination::SurfaceFilterCombination | ( |  | ) |

inline

Creates a new surface filter that accepts all normal surfaces.

This will be an and filter.

## SurfaceFilterCombination() [2/2]

regina::SurfaceFilterCombination::SurfaceFilterCombination | ( | const SurfaceFilterCombination & | cloneMe | ) |

inline

Creates a new surface filter that is a clone of the given surface filter.

Parameters

  cloneMe | the surface filter to clone.

## SurfaceFilterProperties() [1/2]

regina::SurfaceFilterProperties::SurfaceFilterProperties | ( |  | ) |

inline

Creates a new surface filter that accepts all normal surfaces.

## SurfaceFilterProperties() [2/2]

regina::SurfaceFilterProperties::SurfaceFilterProperties | ( | const SurfaceFilterProperties & | cloneMe | ) |

inline

Creates a new surface filter that is a clone of the given surface filter.

Parameters

  cloneMe | the surface filter to clone.

## SurfaceInserter() [1/2]

regina::NormalSurfaces::SurfaceInserter::SurfaceInserter | ( | const SurfaceInserter & | cloneMe | ) |

inline

Creates a new output iterator that is a clone of the given iterator.

Parameters

  cloneMe | the output iterator to clone.

## SurfaceInserter() [2/2]

regina::NormalSurfaces::SurfaceInserter::SurfaceInserter | ( | NormalSurfaces & | newList,
|  | Triangulation< 3 > * | newOwner
| ) |  |

inline

Creates a new output iterator.

The member variables of this iterator will be initialised according to the parameters passed to this constructor.

Parameters

  newList | the list into which surfaces will be inserted.
  newOwner | the triangulation in which the surfaces to be inserted are contained.

## systemAllowsAlmostNormal()

bool regina::NormalSurface::systemAllowsAlmostNormal | ( |  | ) | const

inline

Determines if the underlying coordinate system being used allows for almost normal surfaces, that is, allows for octagonal discs.

This is a property of the coordinate system in which this surface is natively stored, not a property of the surface itself. For example, if this surface has no octagons but is stored using standard almost normal coordinates, then this routine will return `true`.

Returns
  `true` if and only if almost normal surfaces are allowed in the underlying coordinate system.

## systemAllowsOriented()

bool regina::NormalSurface::systemAllowsOriented | ( |  | ) | const

inline

Determines if the underlying coordinate system being used allows for transversely oriented normal surfaces.

Returns
  `true` if and only if transverse orientations are supported in the underlying coordinate system.

## systemAllowsSpun()

bool regina::NormalSurface::systemAllowsSpun | ( |  | ) | const

inline

Determines if the underlying coordinate system being used allows for spun normal surfaces.

This is a property of the coordinate system in which this surface is natively stored, not a property of the surface itself. For example, if this surface is compact but is stored using quad coordinates, then this routine will return `true`.

Returns
  `true` if and only if spun normal surface are supported in the underlying coordinate system.

## tetDiscs()

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

inline

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

Parameters

  tetIndex | the index in the triangulation of the given tetrahedron.

Returns
  the set of discs inside the given tetrahedron.

## triangles() [1/6]

LargeInteger regina::NormalSurface::triangles | ( | size_t | tetIndex,
|  | int | vertex
| ) |  | const

inline

Returns the number of triangular discs of the given type in this normal surface.

A triangular disc type is identified by specifying a tetrahedron and a vertex of that tetrahedron that the triangle surrounds.

If you are using a coordinate system that adorns discs with additional information (such as orientation), this routine returns the total number of triangles in the given tetrahedron of the given type.

Parameters

  tetIndex | the index in the triangulation of the tetrahedron in which the requested triangles reside; this should be between 0 and Triangulation<3>::size()-1 inclusive.
  vertex | the vertex of the given tetrahedron around which the requested triangles lie; this should be between 0 and 3 inclusive.

Returns
  the number of triangular discs of the given type.

## triangles() [2/6]

LargeInteger regina::NSVectorStandard::triangles | ( | size_t | tetIndex,
|  | int | vertex,
|  | const Triangulation< 3 > * | triang
| ) |  | const

inline virtual

Returns the number of triangular discs of the given type in this normal surface.

See NormalSurface::triangles() for further details.

Parameters

  tetIndex | the index in the triangulation of the tetrahedron in which the requested triangles reside; this should be between 0 and Triangulation<3>::size()-1 inclusive.
  vertex | the vertex of the given tetrahedron around which the requested triangles lie; this should be between 0 and 3 inclusive.
  triang | the triangulation in which this normal surface lives.

Returns
  the number of triangular discs of the given type.

Implements regina::NormalSurfaceVector.

## triangles() [3/6]

LargeInteger regina::NSVectorOriented::triangles | ( | size_t | tetIndex,
|  | int | vertex,
|  | const Triangulation< 3 > * | triang
| ) |  | const

inline virtual

Returns the number of triangular discs of the given type in this normal surface.

See NormalSurface::triangles() for further details.

Parameters

  tetIndex | the index in the triangulation of the tetrahedron in which the requested triangles reside; this should be between 0 and Triangulation<3>::size()-1 inclusive.
  vertex | the vertex of the given tetrahedron around which the requested triangles lie; this should be between 0 and 3 inclusive.
  triang | the triangulation in which this normal surface lives.

Returns
  the number of triangular discs of the given type.

Implements regina::NormalSurfaceVector.

## triangles() [4/6]

LargeInteger regina::NSVectorANStandard::triangles | ( | size_t | tetIndex,
|  | int | vertex,
|  | const Triangulation< 3 > * | triang
| ) |  | const

inline virtual

Returns the number of triangular discs of the given type in this normal surface.

See NormalSurface::triangles() for further details.

Parameters

  tetIndex | the index in the triangulation of the tetrahedron in which the requested triangles reside; this should be between 0 and Triangulation<3>::size()-1 inclusive.
  vertex | the vertex of the given tetrahedron around which the requested triangles lie; this should be between 0 and 3 inclusive.
  triang | the triangulation in which this normal surface lives.

Returns
  the number of triangular discs of the given type.

Implements regina::NormalSurfaceVector.

## triangles() [5/6]

virtual LargeInteger regina::NormalSurfaceVector::triangles | ( | size_t | tetIndex,
|  | int | vertex,
|  | const Triangulation< 3 > * | triang
| ) |  | const

pure virtual

Returns the number of triangular discs of the given type in this normal surface.

See NormalSurface::triangles() for further details.

Parameters

  tetIndex | the index in the triangulation of the tetrahedron in which the requested triangles reside; this should be between 0 and Triangulation<3>::size()-1 inclusive.
  vertex | the vertex of the given tetrahedron around which the requested triangles lie; this should be between 0 and 3 inclusive.
  triang | the triangulation in which this normal surface lives.

Returns
  the number of triangular discs of the given type.

Implemented in regina::NSVectorMirrored, regina::NSVectorANStandard, regina::NSVectorOriented, and regina::NSVectorStandard.

## triangles() [6/6]

LargeInteger regina::NSVectorMirrored::triangles | ( | size_t | tetIndex,
|  | int | vertex,
|  | const Triangulation< 3 > * | triang
| ) |  | const

inline override virtual

Returns the number of triangular discs of the given type in this normal surface.

See NormalSurface::triangles() for further details.

Parameters

  tetIndex | the index in the triangulation of the tetrahedron in which the requested triangles reside; this should be between 0 and Triangulation<3>::size()-1 inclusive.
  vertex | the vertex of the given tetrahedron around which the requested triangles lie; this should be between 0 and 3 inclusive.
  triang | the triangulation in which this normal surface lives.

Returns
  the number of triangular discs of the given type.

Implements regina::NormalSurfaceVector.

## triangulation() [1/2]

Triangulation<3>* regina::NormalSurfaces::triangulation | ( |  | ) | const

Returns the triangulation in which these normal surfaces live.

Returns
  the triangulation in which these surfaces live.

## triangulation() [2/2]

const Triangulation< 3 > * regina::NormalSurface::triangulation | ( |  | ) | const

inline

Returns the triangulation in which this normal surface resides.

Returns
  the underlying triangulation.

## usesAnd()

bool regina::SurfaceFilterCombination::usesAnd | ( |  | ) | const

inline

Determines whether this is an and or an or combination.

Returns
  `true` if this is an and combination, or `false` if this is an or combination.

## VectorIterator() [1/2]

regina::NormalSurfaces::VectorIterator::VectorIterator | ( |  | ) |

inline

Creates a new uninitialised iterator.

## VectorIterator() [2/2]

regina::NormalSurfaces::VectorIterator::VectorIterator | ( | const VectorIterator & | cloneMe | ) |

inline

Creates a copy of the given iterator.

Parameters

  cloneMe | the iterator to clone.

## which()

NormalList regina::NormalSurfaces::which | ( |  | ) | const

inline

Returns details of which normal surfaces this list represents within the underlying triangulation.

This may not be the same NormalList that was passed to enumerate(). In particular, default values will have been explicitly filled in (such as NS_VERTEX and/or NS_EMBEDDED_ONLY), and invalid and/or redundant values will have been removed.

Returns
  details of what this list represents.

## writeAllSurfaces()

void regina::NormalSurfaces::writeAllSurfaces | ( | std::ostream & | out | ) | const

Writes the number of surfaces in this set followed by the details of each surface to the given output stream.

Output will be over many lines.

Python:\n Parameter out is not present and is assumed
  to be standard output.

Parameters

  out | the output stream to which to write.

## writeRawVector()

void regina::NormalSurface::writeRawVector | ( | std::ostream & | out | ) | const

inline

Writes the underlying coordinate vector to the given output stream in text format.

No indication will be given as to which coordinate system is being used or what each coordinate means. No newline will be written.

Python:\n The paramater out does not exist, and is
  taken to be standard output.

Parameters

  out | the output stream to which to write.

## writeTextLong() [1/3]

void regina::SurfaceFilterCombination::writeTextLong | ( | std::ostream & | out | ) | const

inline virtual

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

This may be reimplemented by subclasses, but the parent Packet class offers a reasonable default implementation.

Python:\n Not present.

Parameters

  out | the output stream to which to write.

Reimplemented from regina::Packet.

## writeTextLong() [2/3]

virtual void regina::NormalSurfaces::writeTextLong | ( | std::ostream & | out | ) | const

virtual

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

This may be reimplemented by subclasses, but the parent Packet class offers a reasonable default implementation.

Python:\n Not present.

Parameters

  out | the output stream to which to write.

Reimplemented from regina::Packet.

## writeTextLong() [3/3]

virtual void regina::SurfaceFilterProperties::writeTextLong | ( | std::ostream & | out | ) | const

virtual

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

This may be reimplemented by subclasses, but the parent Packet class offers a reasonable default implementation.

Python:\n Not present.

Parameters

  out | the output stream to which to write.

Reimplemented from regina::Packet.

## writeTextShort() [1/3]

void regina::SurfaceFilter::writeTextShort | ( | std::ostream & | out | ) | const

inline virtual

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

This must be reimplemented by subclasses.

Python:\n Not present.

Parameters

  out | the output stream to which to write.

Implements regina::Packet.

## writeTextShort() [2/3]

virtual void regina::NormalSurfaces::writeTextShort | ( | std::ostream & | out | ) | const

virtual

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

This must be reimplemented by subclasses.

Python:\n Not present.

Parameters

  out | the output stream to which to write.

Implements regina::Packet.

## writeTextShort() [3/3]

void regina::NormalSurface::writeTextShort | ( | std::ostream & | out | ) | const

Writes this surface to the given output stream, using standard triangle-quad-oct coordinates.

Octagonal coordinates will only be written if the surface is stored using a coordinate system that supports almost normal surfaces.

Python:\n Not present.

Parameters

  out | the output stream to which to write.

## writeXMLData()

void regina::NormalSurface::writeXMLData | ( | std::ostream & | out | ) | const

Writes a chunk of XML containing this normal surface and all of its properties.

This routine will be called from within NormalSurfaces::writeXMLPacketData().

Python:\n Not present.

Parameters

  out | the output stream to which the XML should be written.

## writeXMLFilterData() [1/3]

void regina::SurfaceFilter::writeXMLFilterData | ( | std::ostream & | out | ) | const

inline protected virtual

Writes a chunk of XML containing the details of this filter.

You may assume that the filter opening tag (including the filter type) has already been written, and that the filter closing tag will be written immediately after this routine is called. This routine need only write the additional details corresponding to this particular subclass of SurfaceFilter.

Parameters

  out | the output stream to which the XML should be written.

Reimplemented in regina::SurfaceFilterProperties, and regina::SurfaceFilterCombination.

## writeXMLFilterData() [2/3]

virtual void regina::SurfaceFilterCombination::writeXMLFilterData | ( | std::ostream & | out | ) | const

protected virtual

Writes a chunk of XML containing the details of this filter.

You may assume that the filter opening tag (including the filter type) has already been written, and that the filter closing tag will be written immediately after this routine is called. This routine need only write the additional details corresponding to this particular subclass of SurfaceFilter.

Parameters

  out | the output stream to which the XML should be written.

Reimplemented from regina::SurfaceFilter.

## writeXMLFilterData() [3/3]

virtual void regina::SurfaceFilterProperties::writeXMLFilterData | ( | std::ostream & | out | ) | const

protected virtual

Writes a chunk of XML containing the details of this filter.

You may assume that the filter opening tag (including the filter type) has already been written, and that the filter closing tag will be written immediately after this routine is called. This routine need only write the additional details corresponding to this particular subclass of SurfaceFilter.

Parameters

  out | the output stream to which the XML should be written.

Reimplemented from regina::SurfaceFilter.

## writeXMLPacketData() [1/2]

virtual void regina::SurfaceFilter::writeXMLPacketData | ( | std::ostream & | out | ) | const

protected virtual

Writes a chunk of XML containing the data for this packet only.

You may assume that the packet opening tag (including the packet type and label) has already been written, and that all child packets followed by the corresponding packet closing tag will be written immediately after this routine is called. This routine need only write the internal data stored in this specific packet.

Parameters

  out | the output stream to which the XML should be written.

Implements regina::Packet.

## writeXMLPacketData() [2/2]

virtual void regina::NormalSurfaces::writeXMLPacketData | ( | std::ostream & | out | ) | const

protected virtual

Writes a chunk of XML containing the data for this packet only.

You may assume that the packet opening tag (including the packet type and label) has already been written, and that all child packets followed by the corresponding packet closing tag will be written immediately after this routine is called. This routine need only write the internal data stored in this specific packet.

Parameters

  out | the output stream to which the XML should be written.

Implements regina::Packet.

## XMLFilterPacketReader()

regina::XMLFilterPacketReader::XMLFilterPacketReader | ( | Packet * | newParent,
|  | XMLTreeResolver & | resolver
| ) |  |

inline

Creates a new surface filter packet reader.

Parameters

  newParent | the parent packet of the filter to be read, or 0 if this filter is to be tree matriarch.
  resolver | the master resolver that will be used to fix dangling packet references after the entire XML file has been read.

## XMLFilterReader()

regina::XMLFilterReader::XMLFilterReader | ( |  | ) |

inline

Creates a new filter element reader.

## xmlFilterReader()

static XMLFilterReader* regina::SurfaceFilter::xmlFilterReader | ( | Packet * | parent | ) |

static

Returns a newly created XML filter reader that will read the details of a particular type of surface filter.

You may assume that the filter to be read is of the same type as the class in which you are implementing this routine.

The XML filter reader should read exactly what writeXMLFilterData() writes, and vice versa.

parent represents the packet which will become the new filter's parent in the tree structure. This information is for reference only, and need not be used. See the description of parameter parent in Packet::xmlReader() for further details.

Python:\n Not present.

Parameters

  parent | the packet which will become the new filter's parent in the tree structure, or 0 if the new filter is to be tree matriarch.

Returns
  the newly created XML filter reader.

## XMLNormalSurfaceReader()

regina::XMLNormalSurfaceReader::XMLNormalSurfaceReader | ( | const Triangulation< 3 > * | newTri,
|  | NormalCoords | newCoords
| ) |  |

inline

Creates a new normal surface reader.

Parameters

  newTri | the triangulation in which this normal surface lives.
  newCoords | the coordinate system used by this normal surface.

## XMLNormalSurfacesReader()

regina::XMLNormalSurfacesReader::XMLNormalSurfacesReader | ( | const Triangulation< 3 > * | newTri,
|  | XMLTreeResolver & | resolver
| ) |  |

inline

Creates a new normal surface list reader.

Parameters

  newTri | the triangulation in which these normal surfaces live.
  resolver | the master resolver that will be used to fix dangling packet references after the entire XML file has been read.

## ~DiscSetSurface()

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

virtual

Destroys this set of discs and deallocates all associated memory.

## ~DiscSetTet()

regina::DiscSetTet::~DiscSetTet | ( |  | ) |

inline virtual

Destroys this disc set.

## ~DiscSetTetData()

template<class T >

virtual regina::DiscSetTetData< T >::~DiscSetTetData | ( |  | ) |

inline virtual

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.

## ~NormalSurface()

regina::NormalSurface::~NormalSurface | ( |  | ) |

inline

Destroys this normal surface.

The underlying vector of coordinates will also be deallocated.

## ~NormalSurfaces()

regina::NormalSurfaces::~NormalSurfaces | ( |  | ) |

inline virtual

Destroys this list and all the surfaces within.

## ~NormalSurfaceVector()

regina::NormalSurfaceVector::~NormalSurfaceVector | ( |  | ) |

inline virtual

A virtual destructor.

This is required because here we introduce virtual functions into the Ray hierarchy.

## ~NSVectorMirrored()

regina::NSVectorMirrored::~NSVectorMirrored | ( |  | ) |

inline virtual

Destroys this vector and its mirror if appropriate.

## ~SurfaceFilter()

regina::SurfaceFilter::~SurfaceFilter | ( |  | ) |

inline virtual

Destroys this surface filter.

## Variable Documentation

## algorithm_

NormalAlg regina::NormalSurfaces::algorithm_

protected

Stores the details of the enumeration algorithm that was used to generate this list.

This might not be the same as the algorithmHints flag passed to the corresponding enumeration routine (e.g., if invalid or inappropriate flags were passed).

## compact

Property<bool> regina::NormalSurface::compact

mutable protected

Is this surface compact (i.e.

does it only contain finitely many discs)?

## connected

Property<bool> regina::NormalSurface::connected

mutable protected

Is this surface connected?

## coords_ [1/2]

NormalCoords regina::NormalSurfaces::coords_

protected

Stores which coordinate system is being used by the normal surfaces in this packet.

## coords_ [2/2]

Ray regina::NormalSurfaceVector::coords_

protected

The raw vector of normal coordinates.

## current

DiscSpec regina::DiscSpecIterator::current

protected

The disc currently pointed to.

## discSets

DiscSetTet** regina::DiscSetSurface::discSets

protected

The disc sets corresponding to each tetrahedron.

## edge

int regina::PrismSpec::edge

The edge of the tetrahedron that is contained in this prism.

## eulerChar_

Property<LargeInteger> regina::NormalSurface::eulerChar_

mutable protected

The Euler characteristic of this surface.

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

## list

NormalSurfaces* regina::NormalSurfaces::SurfaceInserter::list

The list into which surfaces will be inserted.

## name_

std::string regina::NormalSurface::name_

protected

An optional name associated with this surface.

## NONE

const DiscType regina::DiscType::NONE

static

Represents a "null" disc type.

Here the type member is negative, to distinguish it from "meaningful" disc types in which type is always zero or positive.

## 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++:\n 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.

## octPosition_

Property<DiscType> regina::NormalSurface::octPosition_

mutable protected

The position of the first non-zero octagonal coordinate, or DiscType::NONE if there is no non-zero octagonal coordinate.

Here DiscType::type is an octagon type between 0 and 2 inclusive.

## orientable

Property<bool> regina::NormalSurface::orientable

mutable protected

Is this surface orientable?

## owner

Triangulation<3>* regina::NormalSurfaces::SurfaceInserter::owner

The triangulation in which the surfaces to be inserted are contained.

## 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++:\n 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.

## realBoundary

Property<bool> regina::NormalSurface::realBoundary

mutable protected

Does this surface have real boundary (i.e.

does it meet any boundary triangles)?

## surfaces

std::vector<NormalSurface*> regina::NormalSurfaces::surfaces

protected

Contains the normal surfaces stored in this packet.

## tetIndex [1/3]

size_t regina::PrismSpec::tetIndex

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

## tetIndex [2/3]

size_t regina::DiscType::tetIndex

The index within the triangulation of the tetrahedron containing this disc type.

This must be between 0 and Triangulation<3>::size()-1 inclusive.

## tetIndex [3/3]

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.

## triangulation_

const Triangulation<3>* regina::NormalSurface::triangulation_

protected

The triangulation in which this normal surface resides.

## 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++:\n 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.

## twoSided

Property<bool> regina::NormalSurface::twoSided

mutable protected

Is this surface two-sided?

## type [1/2]

int regina::DiscType::type

Identifies the disc type within the specified tetrahedron.

The precise meaning of this member is left up to the user, though it must be non-negative for "meaningful" disc types. See the DiscType class notes for details.

## type [2/2]

int regina::DiscSpec::type

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

## vector

NormalSurfaceVector* regina::NormalSurface::vector

protected

Contains the coordinates of the normal surface in whichever space is appropriate.

## which_

NormalList regina::NormalSurfaces::which_

protected

Indicates which normal surfaces these represent within the underlying triangulation.

## Friends

## operator<< [1/2]

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

  out | the output stream to which to write.
  spec | the disc specifier to write.

Returns
  a reference to out.

## operator<< [2/2]

std::ostream& operator<< | ( | std::ostream & | out,
|  | const PrismSpec & | spec
| ) |  |

friend

Writes the given prism specifier to the given output stream.

The prism specifier will be written as a pair `(tetIndex, edge)`.

Parameters

  out | the output stream to which to write.
  spec | the prism specifier to write.

Returns
  a reference to out.

regina::SurfaceFilterType
SurfaceFilterType
Represents different types of filter classes that can be used to filter lists of normal surfaces in 3...
Definition: surfacefiltertype.h:57
regina::NormalCoords
NormalCoords
Represents different coordinate systems that can be used for enumerating and displaying normal surfac...
Definition: normalcoords.h:58

Copyright © 1999-2016, 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).