Regina Calculation Engine
|
Normal surfaces in 3-manifold triangulations. More...
Classes | |
struct | regina::DiscSpec |
Specifies a single normal disc in a normal surface. More... | |
class | regina::DiscSetTet |
Represents a set of normal discs inside a single tetrahedron. More... | |
class | regina::DiscSetTetData< T > |
Stores data of type T for every normal disc inside a single tetrahedron. More... | |
class | regina::DiscSetSurface |
Represents the set of all normal discs forming a normal surface. More... | |
class | regina::DiscSetSurfaceData< T > |
Stores data of type T for every normal disc within a particular normal surface. More... | |
class | regina::DiscSpecIterator |
A forward iterator used for running through all normal discs in a normal surface. More... | |
struct | std::iterator_traits< regina::DiscSpecIterator > |
struct | regina::DiscType |
Identifies a single normal or almost normal disc type within a triangulation. More... | |
class | regina::Matrix< T, ring > |
Represents a matrix of elements of the given type T. More... | |
struct | regina::NormalInfo< coordType > |
A template that stores information about a particular normal coordinate system. More... | |
class | regina::NormalSurfaceVector |
Stores the vector of a single normal surface in a 3-manifold. More... | |
class | regina::NormalSurface |
Represents a single normal surface in a 3-manifold. More... | |
class | regina::NormalSurfaces |
A packet representing a collection of normal surfaces in a 3-manifold. More... | |
class | regina::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::NSVectorANStandard |
An almost normal surface vector using standard triangle-quad-oct coordinates. More... | |
class | regina::NSVectorMirrored |
A normal surface vector that is mirrored in another coordinate system to avoid frequent lengthy calculations. More... | |
class | regina::NSVectorOriented |
A normal surface vector using transversely oriented standard (triangle-quad) coordinates. More... | |
class | regina::NSVectorOrientedQuad |
A normal surface vector using transversely oriented quadrilateral coordinates. More... | |
class | regina::NSVectorQuad |
A normal surface vector using quad coordinates. More... | |
class | regina::NSVectorQuadClosed |
The vector for a normal surface in an ideal triangulation, expressed using quad coordinates and enumerated to include closed surfaces only. More... | |
class | regina::NSVectorQuadOct |
An almost normal surface vector using quad-oct coordinates. More... | |
class | regina::NSVectorQuadOctClosed |
The vector for an almost normal surface in an ideal triangulation, expressed using quad-oct coordinates and enumerated to include closed surfaces only. More... | |
class | regina::NSVectorStandard |
A normal surface vector using standard triangle-quad coordinates. More... | |
struct | regina::PrismSpec |
Specifies a single triangular prism in a tetrahedron. More... | |
struct | regina::SurfaceFilterInfo< filterType > |
A template that stores information about a particular type of normal surface filter. More... | |
class | regina::SurfaceFilter |
A packet that accepts or rejects normal surfaces. More... | |
class | regina::SurfaceFilterCombination |
A normal surface filter that simply combines other filters. More... | |
class | regina::SurfaceFilterProperties |
A normal surface filter that filters by basic properties of the normal surface. More... | |
class | regina::XMLFilterReader |
An XML element reader that reads the specific details of a normal surface filter. More... | |
class | regina::XMLFilterPacketReader |
An XML packet reader that reads a single surface filter. More... | |
class | regina::XMLNormalSurfaceReader |
An XML element reader that reads a single normal surface. More... | |
class | regina::XMLNormalSurfacesReader |
An XML packet reader that reads a single normal surface list. More... | |
Macros | |
#define | REGINA_NORMAL_SURFACE_FLAVOUR(class_, id, superclass) |
Defines various constants, types and virtual functions for a subclass of NormalSurfaceVector. More... | |
#define | REGINA_SURFACE_FILTER(class_, id) |
Defines various constants, types and virtual functions for a descendant class of SurfaceFilter. More... | |
Typedefs | |
typedef T * | regina::DiscSetTetData< T >::DataPtr |
A type that is a pointer to the data stored with each disc. More... | |
typedef DiscSpec | regina::NDiscSpec |
Deprecated typedef for backward compatibility. More... | |
typedef DiscSetTet | regina::NDiscSetTet |
Deprecated typedef for backward compatibility. More... | |
template<class T > | |
using | regina::NDiscSetTetData = DiscSetTetData< T > |
Deprecated typedef for backward compatibility. More... | |
typedef DiscSetSurface | regina::NDiscSetSurface |
Deprecated typedef for backward compatibility. More... | |
template<class T > | |
using | regina::NDiscSetSurfaceData = DiscSetSurfaceData< T > |
Deprecated typedef for backward compatibility. More... | |
typedef long | std::iterator_traits< regina::DiscSpecIterator >::difference_type |
typedef const regina::DiscSpec & | std::iterator_traits< regina::DiscSpecIterator >::value_type |
typedef const regina::DiscSpec * | std::iterator_traits< regina::DiscSpecIterator >::pointer |
typedef const regina::DiscSpec & | std::iterator_traits< regina::DiscSpecIterator >::reference |
typedef std::forward_iterator_tag | std::iterator_traits< regina::DiscSpecIterator >::iterator_category |
typedef DiscType | regina::NDiscType |
Deprecated typedef for backward compatibility. More... | |
typedef regina::Flags< NormalListFlags > | regina::NormalList |
A combination of flags for types of normal surface lists. More... | |
typedef regina::Flags< NormalAlgFlags > | regina::NormalAlg |
A combination of flags for types of normal surface lists. More... | |
typedef NormalSurfaceVector | regina::NNormalSurfaceVector |
Deprecated typedef for backward compatibility. More... | |
typedef NormalSurface | regina::NNormalSurface |
Deprecated typedef for backward compatibility. More... | |
typedef NormalSurfaces | regina::NNormalSurfaceList |
Deprecated typedef for backward compatibility. More... | |
typedef NSVectorANStandard | regina::NNormalSurfaceVectorANStandard |
Deprecated typedef for backward compatibility. More... | |
typedef NSVectorMirrored | regina::NNormalSurfaceVectorMirrored |
Deprecated typedef for backward compatibility. More... | |
typedef NSVectorOriented | regina::NNormalSurfaceVectorOriented |
Deprecated typedef for backward compatibility. More... | |
typedef NSVectorOrientedQuad | regina::NNormalSurfaceVectorOrientedQuad |
Deprecated typedef for backward compatibility. More... | |
typedef NSVectorQuad | regina::NNormalSurfaceVectorQuad |
Deprecated typedef for backward compatibility. More... | |
typedef NSVectorQuadOct | regina::NNormalSurfaceVectorQuadOct |
Deprecated typedef for backward compatibility. More... | |
typedef NSVectorStandard | regina::NNormalSurfaceVectorStandard |
Deprecated typedef for backward compatibility. More... | |
typedef PrismSpec | regina::NPrismSpec |
Deprecated typedef for backward compatibility. More... | |
typedef SurfaceFilter | regina::NSurfaceFilter |
Deprecated typedef for backward compatibility. More... | |
typedef SurfaceFilterCombination | regina::NSurfaceFilterCombination |
Deprecated typedef for backward compatibility. More... | |
typedef SurfaceFilterProperties | regina::NSurfaceFilterProperties |
Deprecated typedef for backward compatibility. More... | |
Functions | |
template<typename FunctionObject , typename... Args> | |
ReturnsTraits< FunctionObject >::ReturnType | regina::forCoords (NormalCoords coords, FunctionObject &&func, typename ReturnsTraits< FunctionObject >::ReturnType defaultReturn, Args &&... args) |
Allows the user to call a template function whose template parameter matches a given value of NormalCoords, which is not known until runtime. More... | |
template<typename FunctionObject , typename... Args> | |
ReturnsTraits< FunctionObject >::Void | regina::forCoords (NormalCoords coords, FunctionObject &&func, Args &&... args) |
Allows the user to call a template function whose template parameter matches a given value of NormalCoords, which is not known until runtime. More... | |
regina::DiscSpec::DiscSpec () | |
Creates a new uninitialised disc specifier. More... | |
regina::DiscSpec::DiscSpec (size_t newTetIndex, int newType, unsigned long newNumber) | |
Creates a new disc specifier containing the given values. More... | |
regina::DiscSpec::DiscSpec (const DiscSpec &cloneMe)=default | |
Creates a new disc specifier that is a clone of the given specifier. More... | |
DiscSpec & | regina::DiscSpec::operator= (const DiscSpec &cloneMe)=default |
Copies the values from the given disc specifier into this specifier. More... | |
bool | regina::DiscSpec::operator== (const DiscSpec &other) const |
Determines if this and the given disc specifier contain identical information. More... | |
bool | regina::DiscSpec::operator!= (const DiscSpec &other) const |
Determines if this and the given disc specifier contain different information. More... | |
std::ostream & | regina::operator<< (std::ostream &out, const DiscSpec &spec) |
Writes the given disc specifier to the given output stream. More... | |
bool | regina::numberDiscsAwayFromVertex (int discType, int vertex) |
Determines whether or not normal discs of the given type are numbered away from the given vertex. More... | |
bool | regina::discOrientationFollowsEdge (int discType, int vertex, int edgeStart, int edgeEnd) |
Determines whether or not the natural boundary orientation of a normal disc of the given type follows the given directed normal arc. More... | |
regina::DiscSetTet::DiscSetTet (const NormalSurface &surface, size_t tetIndex) | |
Creates a new set of normal discs corresponding to the discs of the given normal surface that lie within the given tetrahedron. More... | |
regina::DiscSetTet::DiscSetTet (unsigned long tri0, unsigned long tri1, unsigned long tri2, unsigned long tri3, unsigned long quad0, unsigned long quad1, unsigned long quad2, unsigned long oct0=0, unsigned long oct1=0, unsigned long oct2=0) | |
Creates a new set of normal discs where the number of discs of each type is explicitly given. More... | |
virtual | regina::DiscSetTet::~DiscSetTet () |
Destroys this disc set. More... | |
unsigned long | regina::DiscSetTet::nDiscs (int type) const |
Determines the number of discs of the given type inside this tetrahedron. More... | |
unsigned long | regina::DiscSetTet::arcFromDisc (int arcFace, int arcVertex, int discType, unsigned long discNumber) const |
Determines which normal arc of a given type on a given face of this tetrahedron corresponds to the given normal disc. More... | |
void | regina::DiscSetTet::discFromArc (int arcFace, int arcVertex, unsigned long arcNumber, int &discType, unsigned long &discNumber) const |
Determines which normal disc in this tetrahedron meets the given normal arc on the given face. More... | |
regina::DiscSetTet::DiscSetTet (const DiscSetTet &)=delete | |
DiscSetTet & | regina::DiscSetTet::operator= (const DiscSetTet &)=delete |
regina::DiscSetTetData< T >::DiscSetTetData (const NormalSurface &surface, size_t tetIndex) | |
Creates a new disc set corresponding to the discs of the given normal surface that lie within the given tetrahedron. More... | |
regina::DiscSetTetData< T >::DiscSetTetData (const NormalSurface &surface, size_t tetIndex, const T &initValue) | |
Creates a new disc set corresponding to the discs of the given normal surface that lie within the given tetrahedron. More... | |
regina::DiscSetTetData< T >::DiscSetTetData (unsigned long tri0, unsigned long tri1, unsigned long tri2, unsigned long tri3, unsigned long quad0, unsigned long quad1, unsigned long quad2, unsigned long oct0=0, unsigned long oct1=0, unsigned long oct2=0) | |
Creates a new disc set where the number of discs of each type is explicitly given. More... | |
virtual | regina::DiscSetTetData< T >::~DiscSetTetData () |
Destroys this disc set and deallocates all data arrays. More... | |
T & | regina::DiscSetTetData< T >::data (int discType, unsigned long discNumber) |
Retrieves a reference to the data corresponding to the given normal disc. More... | |
regina::DiscSetTetData< T >::DiscSetTetData (const DiscSetTet &)=delete | |
DiscSetTetData & | regina::DiscSetTetData< T >::operator= (const DiscSetTet &)=delete |
regina::DiscSetSurface::DiscSetSurface (const NormalSurface &surface, bool b) | |
Creates a new disc set corresponding to the discs of the given normal surface. More... | |
regina::DiscSetSurface::DiscSetSurface (const NormalSurface &surface) | |
Creates a new disc set corresponding to the discs of the given normal surface. More... | |
virtual | regina::DiscSetSurface::~DiscSetSurface () |
Destroys this set of discs and deallocates all associated memory. More... | |
size_t | regina::DiscSetSurface::nTets () const |
Returns the number of tetrahedra in the underlying triangulation. More... | |
unsigned long | regina::DiscSetSurface::nDiscs (size_t tetIndex, int type) const |
Determines the number of discs of the given type inside the given tetrahedron. More... | |
DiscSetTet & | regina::DiscSetSurface::tetDiscs (size_t tetIndex) const |
Returns the specific set of discs living inside the given tetrahedron. More... | |
DiscSpec * | regina::DiscSetSurface::adjacentDisc (const DiscSpec &disc, Perm< 4 > arc, Perm< 4 > &adjArc) const |
Determines which normal disc is adjacent to the given normal disc along the given directed normal arc in the surface described by this disc set. More... | |
DiscSpecIterator | regina::DiscSetSurface::begin () const |
Returns an iterator at the beginning of the range of all normal discs in the underlying normal surface. More... | |
DiscSpecIterator | regina::DiscSetSurface::end () const |
Returns an iterator at the end of the range of all normal discs in the underlying normal surface. More... | |
regina::DiscSetSurface::DiscSetSurface (const DiscSetSurface &)=delete | |
DiscSetSurface & | regina::DiscSetSurface::operator= (const DiscSetSurface &)=delete |
regina::DiscSetSurfaceData< T >::DiscSetSurfaceData (const NormalSurface &surface) | |
Creates a new disc set corresponding to the discs of the given normal surface. More... | |
regina::DiscSetSurfaceData< T >::DiscSetSurfaceData (const NormalSurface &surface, const T &initValue) | |
Creates a new disc set corresponding to the discs of the given normal surface. More... | |
T & | regina::DiscSetSurfaceData< T >::data (const DiscSpec &disc) |
Retrieves a reference to the data corresponding to the given normal disc. More... | |
regina::DiscSetSurfaceData< T >::DiscSetSurfaceData (const DiscSetSurfaceData &)=delete | |
DiscSetSurfaceData & | regina::DiscSetSurfaceData< T >::operator= (const DiscSetSurfaceData &)=delete |
regina::DiscSpecIterator::DiscSpecIterator () | |
Creates a new uninitialised iterator. More... | |
regina::DiscSpecIterator::DiscSpecIterator (const DiscSetSurface &discSet) | |
Creates a new iterator pointing to the first disc in the given disc set. More... | |
regina::DiscSpecIterator::DiscSpecIterator (const DiscSpecIterator &)=default | |
Default copy constructor. More... | |
void | regina::DiscSpecIterator::init (const DiscSetSurface &discSet) |
Points this iterator to the first disc in the given disc set. More... | |
DiscSpecIterator & | regina::DiscSpecIterator::operator= (const DiscSpecIterator &)=default |
Default copy assignment operator. More... | |
DiscSpecIterator & | regina::DiscSpecIterator::operator++ () |
Preincrement operator. More... | |
DiscSpecIterator | regina::DiscSpecIterator::operator++ (int) |
Postincrement operator. More... | |
const DiscSpec & | regina::DiscSpecIterator::operator* () const |
Returns a reference to the disc pointed to by this iterator. More... | |
bool | regina::DiscSpecIterator::done () const |
Determines if this iterator is past-the-end. More... | |
bool | regina::DiscSpecIterator::operator== (const DiscSpecIterator &other) const |
Determines if this and the given iterator are equal. More... | |
bool | regina::DiscSpecIterator::operator!= (const DiscSpecIterator &other) const |
Determines if this and the given iterator are different. More... | |
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)=default | |
Creates a copy of the given disc type. More... | |
DiscType & | regina::DiscType::operator= (const DiscType &cloneMe)=default |
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 LargeInteger & | 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... | |
NormalSurfaceVector & | regina::NormalSurfaceVector::operator= (const NormalSurfaceVector &)=delete |
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... | |
size_t | regina::NormalSurface::countBoundaries () const |
Returns the number of disjoint boundary curves on this 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... | |
regina::NormalSurface::NormalSurface (const NormalSurface &)=delete | |
NormalSurface & | regina::NormalSurface::operator= (const NormalSurface &)=delete |
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... | |
void | regina::NormalSurface::calculateBoundaries () const |
Computes the number of disjoint boundary curves 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=nullptr) |
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 override |
Writes a short text representation of this object to the given output stream. More... | |
virtual void | regina::NormalSurfaces::writeTextLong (std::ostream &out) const override |
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 override |
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... | |
template<typename Comparison > | |
void | regina::NormalSurfaces::sort (Comparison &&comp) |
Sorts the surfaces in this list according to the given criterion. 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)=default | |
Creates a copy of the given iterator. More... | |
VectorIterator & | regina::NormalSurfaces::VectorIterator::operator= (const VectorIterator &cloneMe)=default |
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 override |
Makes a newly allocated copy of this packet. More... | |
virtual void | regina::NormalSurfaces::writeXMLPacketData (std::ostream &out) const override |
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)=default | |
Creates a new output iterator that is a clone of the given iterator. More... | |
SurfaceInserter & | regina::NormalSurfaces::SurfaceInserter::operator= (const SurfaceInserter &cloneMe)=default |
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, MatrixInt *eqns, ProgressTracker *tracker) | |
Creates a new functor with the given parameters. More... | |
regina::NormalSurfaces::Enumerator::Enumerator (Enumerator &&)=default | |
Default move constructor. 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... | |
regina::NormalSurfaces::Enumerator::Enumerator (const Enumerator &)=delete | |
Enumerator & | regina::NormalSurfaces::Enumerator::operator= (const Enumerator &)=delete |
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 override |
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 override |
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 override |
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 override |
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 override |
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 override |
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 override |
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 override |
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 override |
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 override |
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 override |
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 override |
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 override |
Creates a new mirror vector corresponding to this vector. More... | |
virtual const Vertex< 3 > * | regina::NSVectorOrientedQuad::isVertexLink (const Triangulation< 3 > *triang) const override |
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 override |
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 override |
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 override |
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 override |
Creates a new mirror vector corresponding to this vector. More... | |
virtual const Vertex< 3 > * | regina::NSVectorQuad::isVertexLink (const Triangulation< 3 > *triang) const override |
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 override |
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::NSVectorQuadClosed::NSVectorQuadClosed (size_t length) | |
Creates a new vector all of whose entries are initialised to zero. More... | |
regina::NSVectorQuadClosed::NSVectorQuadClosed (const Vector< LargeInteger > &cloneMe) | |
Creates a new vector that is a clone of the given vector. More... | |
static NormalSurfaceVector * | regina::NSVectorQuadClosed::makeZeroVector (const Triangulation< 3 > *triangulation) |
static MatrixInt * | regina::NSVectorQuadClosed::makeMatchingEquations (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 override |
Creates a new mirror vector corresponding to this vector. More... | |
virtual const Vertex< 3 > * | regina::NSVectorQuadOct::isVertexLink (const Triangulation< 3 > *triang) const override |
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::NSVectorQuadOctClosed::NSVectorQuadOctClosed (size_t length) | |
Creates a new vector all of whose entries are initialised to zero. More... | |
regina::NSVectorQuadOctClosed::NSVectorQuadOctClosed (const Vector< LargeInteger > &cloneMe) | |
Creates a new vector that is a clone of the given vector. More... | |
static NormalSurfaceVector * | regina::NSVectorQuadOctClosed::makeZeroVector (const Triangulation< 3 > *triangulation) |
static MatrixInt * | regina::NSVectorQuadOctClosed::makeMatchingEquations (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 override |
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 override |
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 override |
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 override |
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 override |
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)=default | |
Creates a new prism specifier that is a clone of the given specifier. More... | |
PrismSpec & | regina::PrismSpec::operator= (const PrismSpec &cloneMe)=default |
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 override |
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 override |
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 override |
Makes a newly allocated copy of this packet. More... | |
virtual void | regina::SurfaceFilter::writeXMLPacketData (std::ostream &out) const override |
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 override |
Decides whether or not the given normal surface is accepted by this filter. More... | |
virtual void | regina::SurfaceFilterCombination::writeTextLong (std::ostream &out) const override |
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 override |
Makes a newly allocated copy of this packet. More... | |
virtual void | regina::SurfaceFilterCombination::writeXMLFilterData (std::ostream &out) const override |
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 override |
Decides whether or not the given normal surface is accepted by this filter. More... | |
virtual void | regina::SurfaceFilterProperties::writeTextLong (std::ostream &out) const override |
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 override |
Makes a newly allocated copy of this packet. More... | |
virtual void | regina::SurfaceFilterProperties::writeXMLFilterData (std::ostream &out) const override |
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) override |
Signifies that parsing of this XML element is beginning. More... | |
virtual void | regina::XMLNormalSurfaceReader::initialChars (const std::string &chars) override |
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) override |
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< size_t > | regina::NormalSurface::boundaries_ |
The number of disjoint boundary curves on 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... | |
static constexpr const SurfaceFilterType | regina::SurfaceFilter::filterTypeID |
A compile-time constant that identifies this type of surface filter. More... | |
Friends | |
class | regina::DiscSpecIterator::DiscSetSurface |
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... | |
Normal surfaces in 3-manifold triangulations.
#define REGINA_NORMAL_SURFACE_FLAVOUR | ( | class_, | |
id, | |||
superclass | |||
) |
Defines various constants, types and virtual functions for a subclass of NormalSurfaceVector.
Every subclass of NormalSurfaceVector must include REGINA_NORMAL_SURFACE_FLAVOUR at the beginning of the class definition.
This macro provides the class with:
class_ | the name of this subclass of NormalSurfaceVector. |
id | the corresponding NNormalCoords constant. |
superclass | the vector class from which class_ is derived. This is typically NormalSurfaceVector, though in some cases it may be different (e.g., NSVectorMirrored). |
#define REGINA_SURFACE_FILTER | ( | class_, | |
id | |||
) |
Defines various constants, types and virtual functions for a descendant class of SurfaceFilter.
Every descendant class of SurfaceFilter must include REGINA_SURFACE_FILTER at the beginning of the class definition.
This macro provides the class with:
class_ | the name of this descendant class of SurfaceFilter. |
id | the corresponding SurfaceFilterType constant. |
typedef T* regina::DiscSetTetData< T >::DataPtr |
A type that is a pointer to the data stored with each disc.
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
using regina::NDiscSetSurfaceData = typedef DiscSetSurfaceData<T> |
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
typedef DiscSetTet regina::NDiscSetTet |
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
using regina::NDiscSetTetData = typedef DiscSetTetData<T> |
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
typedef DiscSpec regina::NDiscSpec |
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
typedef DiscType regina::NDiscType |
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
typedef NormalSurface regina::NNormalSurface |
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
typedef regina::Flags<NormalAlgFlags> regina::NormalAlg |
A combination of flags for types of normal surface lists.
A combination of flags for types of normal surface lists.
typedef PrismSpec regina::NPrismSpec |
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
typedef SurfaceFilter regina::NSurfaceFilter |
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
Represents options and variants of algorithms for enumerating various types of normal surfaces in 3-manifold triangulations.
These options are typically combined in a bitwise fashion using the NormalAlg type, and then passed to enumeration routines such as NormalSurfaces::enumerate().
enum regina::NormalCoords |
Represents different coordinate systems that can be used for enumerating and displaying normal surfaces.
IDs 0-9999 are reserved for future use by Regina. If you are extending Regina to include your own coordinate system, you should choose an ID >= 10000.
Represents different lists of normal surfaces that might be constructed for a given 3-manifold triangulation.
The NormalList enumeration refers to the contents of the list, whereas the NormalAlgFlags enumeration refers to the algorithm used to build it.
Used to describe a field, or a set of fields, that can be exported alongside a normal surface list.
This enumeration type is used with export routines such as NormalSurfaces::saveCSVStandard() or NormalSurfaces::saveCSVEdgeWeight().
This type describes fields in addition to normal coordinates, not the normal coordinates themselves (which are always exported). Each field describes some property of a single normal surface, and corresponds to a single column in a table of normal surfaces.
This type should be treated as a bitmask: you can describe a set of fields by combining the values for individual fields using bitwise or.
The list of available fields may grow with future releases of Regina.
Enumerator | |
---|---|
surfaceExportName | Represents the user-assigned surface name. |
surfaceExportEuler | Represents the calculated Euler characteristic of a surface. This will be an integer, and will be left empty if the Euler characteristic cannot be computed. |
surfaceExportOrient | Represents the calculated property of whether a surface is orientable. This will be the string |
surfaceExportSides | Represents the calculated property of whether a surface is one-sided or two-sided. This will be the integer 1 or 2, or will be left empty if the "sidedness" cannot be computed. |
surfaceExportBdry | Represents the calculated property of whether a surface is bounded. In most cases, this will be one of the strings "closed", "real bdry" or "infinite" (where "infinite" indicates a surface with infinitely many discs). For spun-normal surfaces in certain ideal triangulations, this string will be followed by the boundary slopes of the surface at the cusps: these written as a list of pairs (p, q), one for each cusp, indicating that the boundary curves of the surface run p times around the meridian and q times around the longitude. See NormalSurface::boundaryIntersections() for further information on interpreting these values. |
surfaceExportLink | Represents whether a surface is a single vertex link or a thin edge link. See NormalSurface::isVertexLink() and NormalSurface::isThinEdgeLink() for details. This will be written as a human-readable string. |
surfaceExportType | Represents any additional high-level properties of a surface, such as whether it is a splitting surface or a central surface. This will be written as a human-readable string. This field is somewhat arbitrary, and the precise properties it describes are subject to change in future releases of Regina. |
surfaceExportNone | Indicates that no additional fields should be exported. |
surfaceExportAllButName | Indicates that all available fields should be exported, except for the user-assigned surface name. Since the list of available fields may grow with future releases, the numerical value of this constant may change as a result. |
surfaceExportAll | Indicates that all available fields should be exported, including the user-assigned surface name. Since the list of available fields may grow with future releases, the numerical value of this constant may change as a result. |
Represents different types of filter classes that can be used to filter lists of normal surfaces in 3-manifold triangulations.
IDs 0-9999 are reserved for future use by Regina. If you are extending Regina to include your own filter class, you should choose an ID >= 10000.
Enumerator | |
---|---|
NS_FILTER_DEFAULT | Represents the SurfaceFilter class: a do-nothing filter that accepts any normal surface. |
NS_FILTER_PROPERTIES | Represents the SurfaceFilterProperties subclass: a filter that examines simple properties of a normal surface. |
NS_FILTER_COMBINATION | Represents the SurfaceFilterCombination subclass: a filter that combines other filters using boolean AND or OR. |
|
inlinevirtual |
Decides whether or not the given normal surface is accepted by this filter.
The default implementation simply returns true
.
surface | the normal surface under investigation. |
true
if and only if the given surface is accepted by this filter. Reimplemented in regina::SurfaceFilterProperties, and regina::SurfaceFilterCombination.
|
overridevirtual |
Decides whether or not the given normal surface is accepted by this filter.
The default implementation simply returns true
.
surface | the normal surface under investigation. |
true
if and only if the given surface is accepted by this filter. Reimplemented from regina::SurfaceFilter.
|
overridevirtual |
Decides whether or not the given normal surface is accepted by this filter.
The default implementation simply returns true
.
surface | the normal surface under investigation. |
true
if and only if the given surface is accepted by this filter. Reimplemented from regina::SurfaceFilter.
|
inline |
Adds the given Euler characteristic to the set of allowable Euler characteristics.
See eulerChars() for further details.
ec | the new allowable Euler characteristic. |
DiscSpec* regina::DiscSetSurface::adjacentDisc | ( | const DiscSpec & | disc, |
Perm< 4 > | arc, | ||
Perm< 4 > & | adjArc | ||
) | const |
Determines which normal disc is adjacent to the given normal disc along the given directed normal arc in the surface described by this disc set.
A directed normal arc will be specified by a permutation p, where the arc runs around vertex p[0]
parallel to the directed edge from vertex p[1]
to p[2]
.
disc | the given normal disc; this must be a disc in this disc set. |
arc | the given normal arc; this must actually be an arc on the boundary of the given normal disc (although it may run in either direction). |
adjArc | returns the same directed normal arc that was passed, but expressed in terms of the vertices of the adjacent tetrahedron. Any value may be initially passed. If there is no adjacent disc/tetrahedron, this permutation will remain unchanged. |
|
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.
bool regina::NormalSurfaces::allowsAlmostNormal | ( | ) | const |
Determines if the coordinate system being used allows for almost normal surfaces, that is, allows for octagonal discs.
true
if and only if almost normal surfaces are allowed.
|
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.
true
if and only if almost normal surfaces are allowed. bool regina::NormalSurfaces::allowsOriented | ( | ) | const |
Determines if the coordinate system being used allows for transversely oriented normal surfaces.
true
if and only if transverse orientations are supported.
|
pure virtual |
Determines if the specific underlying coordinate system allows for transversely oriented normal surfaces.
true
if and only if transverse orientations are supported. bool regina::NormalSurfaces::allowsSpun | ( | ) | const |
Determines if the coordinate system being used allows for spun normal surfaces.
true
if and only if spun normal surface are supported.
|
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.
true
if and only if spun-normal surfaces are allowed. unsigned long regina::DiscSetTet::arcFromDisc | ( | int | arcFace, |
int | arcVertex, | ||
int | discType, | ||
unsigned long | discNumber | ||
) | const |
Determines which normal arc of a given type on a given face of this tetrahedron corresponds to the given normal disc.
arcFace | the face of this tetrahedron containing the normal arc (between 0 and 3 inclusive). |
arcVertex | the vertex of this tetrahedron about which the normal arc runs (between 0 and 3 inclusive); arcFace and arcVertex should not be the same. |
discType | the disc type of the given normal disc; this should be between 0 and 9 inclusive, as described in the DiscSpec class notes. |
discNumber | indicates which normal disc of the given disc type is referred to (between 0 and nDiscs(discType)-1 inclusive). |
|
inline |
Returns the number of arcs in which this normal surface intersects the given triangle in the given direction.
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. |
|
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.
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. |
Implemented in regina::NSVectorStandard, regina::NSVectorOriented, regina::NSVectorMirrored, and regina::NSVectorANStandard.
|
overridevirtual |
Returns the number of arcs in which this normal surface intersects the given triangle in the given direction.
See NormalSurface::arcs() for further details.
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. |
Implements regina::NormalSurfaceVector.
|
inlineoverridevirtual |
Returns the number of arcs in which this normal surface intersects the given triangle in the given direction.
See NormalSurface::arcs() for further details.
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. |
Implements regina::NormalSurfaceVector.
|
overridevirtual |
Returns the number of arcs in which this normal surface intersects the given triangle in the given direction.
See NormalSurface::arcs() for further details.
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. |
Implements regina::NormalSurfaceVector.
|
overridevirtual |
Returns the number of arcs in which this normal surface intersects the given triangle in the given direction.
See NormalSurface::arcs() for further details.
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. |
Implements regina::NormalSurfaceVector.
|
inline |
Returns an iterator at the beginning of the range of all normal discs in the underlying normal surface.
These begin() and end() routines allow you to iterate through all normal discs using C++11 range-based for
loops:
In Python, a DiscSetSurface can be treated as an iterable object, again iterating through all normal discs:
|
inline |
An iterator that gives access to the raw vectors for surfaces in this list, pointing to the beginning of this surface list.
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.
|
protected |
Computes the number of disjoint boundary curves and stores the result as a property.
|
protected |
Calculates the Euler characteristic of this surface and stores it as a property.
|
protected |
Calculates the position of the first non-zero octagon coordinate and stores it as a property.
|
protected |
Calculates whether this surface is orientable and/or two-sided and stores the results as properties.
|
protected |
Calculates whether this surface has any real boundary and stores the result as a property.
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.
|
pure virtual |
Creates a newly allocated clone of this vector.
The clone will be of the same subclass of NormalSurfaceVector as this vector.
|
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.
|
inline |
Gives read-only access to the underlying vector of coordinates.
|
inline |
Returns the coordinate system being used by the surfaces stored in this set.
|
inline |
Returns the number of disjoint boundary curves on 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.
|
inline |
Returns the number of coordinates in the specific underlying coordinate system being used.
|
inline |
Returns the number of allowable Euler characteristics.
See eulerChars() for further details.
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.
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.
|
inline |
Retrieves a reference to the data corresponding to the given normal disc.
disc | the disc whose data we require; this must refer to a disc within this disc set. |
|
inline |
Retrieves a reference to the data corresponding to the given normal disc.
discType | the disc type of the given normal disc; this should be between 0 and 9 inclusive, as described in the DiscSpec class notes. |
discNumber | indicates which normal disc of the given disc type is referred to; this should be between 0 and nDiscs(discType)-1 inclusive. |
|
inlineoverridevirtual |
Determines if this packet depends upon its parent.
This is true if the parent cannot be altered without invalidating or otherwise upsetting this packet.
true
if and only if this packet depends on its parent. Implements regina::Packet.
|
inlineoverridevirtual |
Determines if this packet depends upon its parent.
This is true if the parent cannot be altered without invalidating or otherwise upsetting this packet.
true
if and only if this packet depends on its parent. Implements regina::Packet.
void regina::DiscSetTet::discFromArc | ( | int | arcFace, |
int | arcVertex, | ||
unsigned long | arcNumber, | ||
int & | discType, | ||
unsigned long & | discNumber | ||
) | const |
Determines which normal disc in this tetrahedron meets the given normal arc on the given face.
arcFace | the face of this tetrahedron containing the normal arc (between 0 and 3 inclusive). |
arcVertex | the vertex of this tetrahedron about which the normal arc runs (between 0 and 3 inclusive); arcFace and arcVertex should not be the same. |
arcNumber | indicates which normal arc of the given type is referred to. Arcs of a given type (where arcFace and arcVertex together define the arc type) are numbered starting at 0 from the tetrahedron vertex outwards. |
discType | returns the disc type of the normal disc that meets the given normal arc; this will be between 0 and 9 inclusive, as described in the DiscSpec class notes. Any value may be initially passed. |
discNumber | returns a number that indicates which normal disc of the returned disc type (discType ) meets the given normal arc; this will be between 0 and nDiscs(discType)-1 inclusive. Any value may be initially passed. |
bool regina::discOrientationFollowsEdge | ( | int | discType, |
int | vertex, | ||
int | edgeStart, | ||
int | edgeEnd | ||
) |
Determines whether or not the natural boundary orientation of a normal disc of the given type follows the given directed normal arc.
Natural boundary orientation is defined by arrays regina::triDiscArcs, regina::quadDiscArcs and regina::octDiscArcs.
discType | the normal disc type under consideration; this should be between 0 and 9 inclusive, as described by the DiscSpec class notes. |
vertex | the vertex about which the normal arc runs. |
edgeStart | the start vertex of the edge to which the normal arc is parallel. |
edgeEnd | the end vertex of the edge to which the normal arc is parallel. |
regina::DiscSetSurface::DiscSetSurface | ( | const NormalSurface & | surface | ) |
Creates a new disc set corresponding to the discs of the given normal surface.
surface | the normal surface whose discs we shall use. |
|
protected |
Creates a new disc set corresponding to the discs of the given normal surface.
The array of tetrahedron disc set pointers will be created but the DiscSetTet objects themselves will not be created.
This constructor should be called from constructors of subclasses who wish to use objects of a subclass of DiscSetTet, which this constructor allows them to create for themselves.
surface.triangulation()->size()
.surface | the normal surface whose discs we shall use. |
b | this parameter is ignored. |
|
inline |
Creates a new disc set corresponding to the discs of the given normal surface.
The data for each disc will remain uninitialised.
surface | the normal surface whose discs we shall use. |
|
inline |
Creates a new disc set corresponding to the discs of the given normal surface.
The data for each disc will be initialised to the given value.
surface | the normal surface whose discs we shall use. |
initValue | the value with which to initialise the data corresponding to each disc. |
regina::DiscSetTet::DiscSetTet | ( | const NormalSurface & | surface, |
size_t | tetIndex | ||
) |
Creates a new set of normal discs corresponding to the discs of the given normal surface that lie within the given tetrahedron.
surface | the normal surface whose discs we shall use. |
tetIndex | the index in the triangulation of the tetrahedron that our discs must lie in; this must be between 0 and tri.size()-1 inclusive, where tri is the triangulation containing the given normal surface. |
regina::DiscSetTet::DiscSetTet | ( | unsigned long | tri0, |
unsigned long | tri1, | ||
unsigned long | tri2, | ||
unsigned long | tri3, | ||
unsigned long | quad0, | ||
unsigned long | quad1, | ||
unsigned long | quad2, | ||
unsigned long | oct0 = 0 , |
||
unsigned long | oct1 = 0 , |
||
unsigned long | oct2 = 0 |
||
) |
Creates a new set of normal discs where the number of discs of each type is explicitly given.
tri0 | the number of triangular discs surrounding vertex 0. |
tri1 | the number of triangular discs surrounding vertex 1. |
tri2 | the number of triangular discs surrounding vertex 2. |
tri3 | the number of triangular discs surrounding vertex 3. |
quad0 | the number of quadrilateral discs of type 0. |
quad1 | the number of quadrilateral discs of type 1. |
quad2 | the number of quadrilateral discs of type 2. |
oct0 | the number of octahedral discs of type 0. |
oct1 | the number of octahedral discs of type 1. |
oct2 | the number of octahedral discs of type 2. |
|
inline |
Creates a new disc set corresponding to the discs of the given normal surface that lie within the given tetrahedron.
The data for each disc will remain uninitialised.
surface | the normal surface whose discs we shall use. |
tetIndex | the index in the triangulation of the tetrahedron that our discs must lie in; this must be between 0 and tri.size()-1 inclusive, where tri is the triangulation containing the given normal surface. |
|
inline |
Creates a new disc set corresponding to the discs of the given normal surface that lie within the given tetrahedron.
The data for each disc will be initialised to the given value.
surface | the normal surface whose discs we shall use. |
tetIndex | the index in the triangulation of the tetrahedron that our discs must lie in; this must be between 0 and tri.size()-1 inclusive, where tri is the triangulation containing the given normal surface. |
initValue | the value with which to initialise the data corresponding to each disc. |
|
inline |
Creates a new disc set where the number of discs of each type is explicitly given.
The data for each disc will remain uninitialised.
tri0 | the number of triangular discs surrounding vertex 0. |
tri1 | the number of triangular discs surrounding vertex 1. |
tri2 | the number of triangular discs surrounding vertex 2. |
tri3 | the number of triangular discs surrounding vertex 3. |
quad0 | the number of quadrilateral discs of type 0. |
quad1 | the number of quadrilateral discs of type 1. |
quad2 | the number of quadrilateral discs of type 2. |
oct0 | the number of octahedral discs of type 0. |
oct1 | the number of octahedral discs of type 1. |
oct2 | the number of octahedral discs of type 2. |
|
inline |
Creates a new uninitialised disc specifier.
|
default |
Creates a new disc specifier that is a clone of the given specifier.
cloneMe | the disc specifier to clone. |
|
inline |
Creates a new disc specifier containing the given values.
newTetIndex | the index in the triangulation of the tetrahedron containing the disc. |
newType | the disc type; this is between 0 and 9 inclusive, as described in the DiscSpec class notes. |
newNumber | specifies which disc of the particular type in the particular tetrahedron is being referred to; discs are numbered as described in the DiscSpec class notes. |
|
inline |
Creates a new uninitialised iterator.
This iterator cannot be used or queried until either init() or the assignmemnt operator is called.
|
inline |
Creates a new iterator pointing to the first disc in the given disc set.
discSet | the disc set used to initialise this iterator. |
|
default |
Default copy constructor.
|
inline |
Creates a new disc type initialised to NONE.
|
default |
Creates a copy of the given disc type.
cloneMe | the disc type to clone. |
|
inline |
Creates a new disc type initialised with the given values.
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. |
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.
other | the other surface to test alongside this surface for potential intersections. |
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.
|
inline |
Determines if this iterator is past-the-end.
true
if and only if this iterator is past-the-end. NormalSurface* regina::NormalSurface::doubleSurface | ( | ) | const |
Creates a newly allocated surface that is the double of this surface.
|
inline |
Returns the number of times this normal surface crosses the given edge.
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. |
|
pure virtual |
Returns the number of times this normal surface crosses the given edge.
See NormalSurface::edgeWeight() for further details.
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. |
Implemented in regina::NSVectorStandard, regina::NSVectorOriented, regina::NSVectorMirrored, and regina::NSVectorANStandard.
|
overridevirtual |
Returns the number of times this normal surface crosses the given edge.
See NormalSurface::edgeWeight() for further details.
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. |
Implements regina::NormalSurfaceVector.
|
inlineoverridevirtual |
Returns the number of times this normal surface crosses the given edge.
See NormalSurface::edgeWeight() for further details.
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. |
Implements regina::NormalSurfaceVector.
|
overridevirtual |
Returns the number of times this normal surface crosses the given edge.
See NormalSurface::edgeWeight() for further details.
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. |
Implements regina::NormalSurfaceVector.
|
overridevirtual |
Returns the number of times this normal surface crosses the given edge.
See NormalSurface::edgeWeight() for further details.
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. |
Implements regina::NormalSurfaceVector.
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.
true
if and only if this surface is embedded.
|
inline |
Returns an iterator at the end of the range of all normal discs in the underlying normal surface.
In C++, the begin() and end() routines allow you to iterate through all normal discs using C++11 range-based for
loops. In Python, a DiscSetSurface can be treated as an iterable object.
See the begin() documentation for further details.
|
overridevirtual |
Used instead of endSubElement() for XML subelements that are not child packets or packet tags.
The default implementation does nothing.
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.
|
overridevirtual |
Used instead of endSubElement() for XML subelements that are not child packets or packet tags.
The default implementation does nothing.
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.
|
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.
|
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.
If an error occurs, then this routine will return null
, no normal surface list will be created, and the progress tracker (if passed) will be marked as finished. Errors can occur in the following scenarios:
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 null if no progress reporting is required. |
null
instead.
|
default |
Default move constructor.
|
inline |
Creates a new functor with the given parameters.
list | the surface list to be filled. |
triang | the triangulation in which these surfaces lie. |
eqns | the matching equations for the given triangulation in the coordinate system corresopnding to list. This object will take ownership of eqns, and the bracket operator will delete it once the enumeration has finished. This pointer must be non-null, i.e., Regina must have been able to construct the matching equations. |
tracker | the progress tracker to use for progress reporting and cancellation polling, or null if these capabilities are not required. |
|
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.
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.
index | the index in the set of allowable Euler characteristics; this must be between 0 and countEulerChars()-1 inclusive. |
|
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.
|
inlinevirtual |
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.
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).
true
. 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).
true
.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.
true
.
|
inlinevirtual |
Returns the unique integer ID corresponding to the filtering method that is this particular subclass of SurfaceFilter.
|
inlinevirtual |
Returns a string description of the filtering method that is this particular subclass of SurfaceFilter.
ReturnsTraits<FunctionObject>::Void regina::forCoords | ( | NormalCoords | coords, |
FunctionObject && | func, | ||
Args &&... | args | ||
) |
Allows the user to call a template function whose template parameter matches a given value of NormalCoords, which is not known until runtime.
In essence, this routine contains a switch/case statement that runs through all possible coordinate sytems.
The advantages of this routine are that (i) the user does not need to repeatedly type such switch/case statements themselves; and (ii) if a new coordinate system is added then only a small amount of code needs to be extended to incorporate it.
This function can only work with coordinate systems in which you can create and store normal surfaces. All other coordinate systems are considered invalid for our purposes here.
In detail: the function object func must define a templated bracket operator, so that func.operator()<NormalInfo<c>>(...)
is defined for any valid NormalCoords enum value c. Then, when the user calls forCoords(coords, func, ...)
, this routine will call func.operator()<NormalInfo<coords>>(...)
in turn. If coords does not denote a valid coordinate system as described above, then forCoords() will do nothing.
There is also a variant of forCoords() that works with functions with return values, and which takes an extra defaultReturn argument.
coords | the given normal coordinate system. |
func | the function object whose bracket operator we will call with a NormalInfo<coords> object. |
args | any additional arguments to pass to the bracket operator for func. These will be copied/moved, so if you wish to pass references then you may need to wrap them in std::ref or std::cref. |
ReturnsTraits<FunctionObject>::Void
simply evaluates to void
. ReturnsTraits<FunctionObject>::ReturnType regina::forCoords | ( | NormalCoords | coords, |
FunctionObject && | func, | ||
typename ReturnsTraits< FunctionObject >::ReturnType | defaultReturn, | ||
Args &&... | args | ||
) |
Allows the user to call a template function whose template parameter matches a given value of NormalCoords, which is not known until runtime.
In essence, this routine contains a switch/case statement that runs through all possible coordinate sytems.
The advantages of this routine are that (i) the user does not need to repeatedly type such switch/case statements themselves; and (ii) if a new coordinate system is added then only a small amount of code needs to be extended to incorporate it.
This function can only work with coordinate systems in which you can create and store normal surfaces. All other coordinate systems are considered invalid for our purposes here.
In detail: the function object func must define a templated bracket operator, so that func.operator()<NormalInfo<c>>(...)
is defined for any valid NormalCoords enum value c. Then, when the user calls forCoords(coords, func, defaultReturn, ...)
, this routine will call func.operator()<NormalInfo<coords>>(...)
and pass back the corresponding return value. If coords does not denote a valid coordinate system as described above, then forCoords() will pass back defaultReturn instead.
There is also a variant of forCoords() that works with void functions, and so does not take the extra defaultReturn argument.
coords | the given normal coordinate system. |
func | the function object whose bracket operator we will call with a NormalInfo<coords> object. |
defaultReturn | the value to return if the given coordinate system is invalid. |
args | any additional arguments to pass to the bracket operator for func. These will be copied/moved, so if you wish to pass references then you may need to wrap them in std::ref or std::cref. |
ReturnsTraits<FunctionObject>::Void regina::forFilter | ( | SurfaceFilterType | filter, |
FunctionObject && | func, | ||
Args &&... | args | ||
) |
Allows the user to call a template function whose template parameter matches a given value of SurfaceFilterType, which is not known until runtime.
In essence, this routine contains a switch/case statement that runs through all possible normal surface filter types.
The advantages of this routine are that (i) the user does not need to repeatedly type such switch/case statements themselves; and (ii) if a new filter type is added then only a small amount of code needs to be extended to incorporate it.
In detail: the function object func must define a templated bracket operator, so that func.operator()<SurfaceFilterInfo<t>>(...)
is defined for any valid SurfaceFilterType enum value t. Then, when the user calls forFilter(filter, func, ...)
, this routine will call func.operator()<SurfaceFilterInfo<filter>>(...)
in turn. If filter does not denote a valid filter type, then forFilter() will do nothing.
There is also a variant of forFilter() that works with functions with return values, and which takes an extra defaultReturn argument.
filter | the given type of normal surface filter. |
func | the function object whose bracket operator we will call with a SurfaceFilterInfo<filter> object. |
args | any additional arguments to pass to the bracket operator for func. These will be copied/moved, so if you wish to pass references then you may need to wrap then in std::ref or std::cref. |
ReturnsTraits<FunctionObject>::Void
simply evaluates to void
. ReturnsTraits<FunctionObject>::ReturnType regina::forFilter | ( | SurfaceFilterType | filter, |
FunctionObject && | func, | ||
typename ReturnsTraits< FunctionObject >::ReturnType | defaultReturn, | ||
Args &&... | args | ||
) |
Allows the user to call a template function whose template parameter matches a given value of SurfaceFilterType, which is not known until runtime.
In essence, this routine contains a switch/case statement that runs through all possible normal surface filter types.
The advantages of this routine are that (i) the user does not need to repeatedly type such switch/case statements themselves; and (ii) if a new filter type is added then only a small amount of code needs to be extended to incorporate it.
In detail: the function object func must define a templated bracket operator, so that func.operator()<SurfaceFilterInfo<t>>(...)
is defined for any valid SurfaceFilterType enum value t. Then, when the user calls forFilter(filter, func, defaultReturn, ...)
, this routine will call func.operator()<SurfaceFilterInfo<filter>>(...)
and pass back the corresponding return value. If filter does not denote a valid filter type, then forFilter() will pass back defaultReturn instead.
There is also a variant of forFilter() that works with void functions, and so does not take the extra defaultReturn argument.
filter | the given type of normal surface filter. |
func | the function object whose bracket operator we will call with a SurfaceFilterInfo<filter> object. |
defaultReturn | the value to return if the given filter type is not valid. |
args | any additional arguments to pass to the bracket operator for func. These will be copied/moved, so if you wish to pass references then you may need to wrap then in std::ref or std::cref. |
|
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.
triang | the triangulation in which this normal surface lives. |
true
if and only if there is an octagonal disc type present and its coordinate is greater than one.
|
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.
true
if and only if this surface has real boundary.
|
inline |
Points this iterator to the first disc in the given disc set.
discSet | the disc set used to reinitialise this iterator. |
|
overridevirtual |
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.
chars | the initial text for this element. |
Reimplemented from regina::XMLElementReader.
|
overrideprotectedvirtual |
Makes a newly allocated copy of this packet.
This routine should not insert the new packet into the tree structure, clone the packet's associated tags or give the packet a label. It should also not clone any descendants of this packet.
You may assume that the new packet will eventually be inserted into the tree beneath either the same parent as this packet or a clone of that parent.
parent | the parent beneath which the new packet will eventually be inserted. |
Implements regina::Packet.
|
inlineoverrideprotectedvirtual |
Makes a newly allocated copy of this packet.
This routine should not insert the new packet into the tree structure, clone the packet's associated tags or give the packet a label. It should also not clone any descendants of this packet.
You may assume that the new packet will eventually be inserted into the tree beneath either the same parent as this packet or a clone of that parent.
parent | the parent beneath which the new packet will eventually be inserted. |
Implements regina::Packet.
Reimplemented in regina::SurfaceFilterProperties, and regina::SurfaceFilterCombination.
|
inlineoverrideprotectedvirtual |
Makes a newly allocated copy of this packet.
This routine should not insert the new packet into the tree structure, clone the packet's associated tags or give the packet a label. It should also not clone any descendants of this packet.
You may assume that the new packet will eventually be inserted into the tree beneath either the same parent as this packet or a clone of that parent.
parent | the parent beneath which the new packet will eventually be inserted. |
Reimplemented from regina::SurfaceFilter.
|
inlineoverrideprotectedvirtual |
Makes a newly allocated copy of this packet.
This routine should not insert the new packet into the tree structure, clone the packet's associated tags or give the packet a label. It should also not clone any descendants of this packet.
You may assume that the new packet will eventually be inserted into the tree beneath either the same parent as this packet or a clone of that parent.
parent | the parent beneath which the new packet will eventually be inserted. |
Reimplemented from regina::SurfaceFilter.
|
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.
|
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.
triang | the triangulation in which this normal surface lives. |
|
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.
true
if and only if this normal surface is compact.
|
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.
triang | the triangulation in which this normal surface lives. |
true
if and only if the normal surface represented is compact. 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.
Optimise: Reimplement this to avoid cutting along surfaces.
Bug: Check for absurdly large numbers of discs and bail accordingly.
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. |
true
if this surface is a compressing disc, or false
if this surface is not a compressing disc.
|
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.
true
if this surface is connected, or false
if this surface is disconnected.
|
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).
true
if this list was constructed to contain only properly embedded surfaces, or false
otherwise. bool regina::NormalSurface::isEmpty | ( | ) | const |
Determines if this normal surface is empty (has no discs whatsoever).
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.
true
if this surface is incompressible, or false
if this surface is not incompressible (or if it is a sphere).
|
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.
true
if this surface is orientable, or false
if this surface is non-orientable.
|
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.
true
if and only if this is a splitting surface.
|
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.
triang | the triangulation in which this normal surface lives. |
true
if and only if the normal surface represented is a splitting surface.
|
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.
|
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.
triang | the triangulation in which this normal surface lives. |
|
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.
true
if this surface is two-sided, or false
if this surface is one-sided.
|
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.
|
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.
triang | the triangulation in which this normal surface lives. |
Reimplemented in regina::NSVectorQuadOct, regina::NSVectorQuad, and regina::NSVectorOrientedQuad.
|
inlineoverridevirtual |
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.
triang | the triangulation in which this normal surface lives. |
Reimplemented from regina::NormalSurfaceVector.
|
inlineoverridevirtual |
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.
triang | the triangulation in which this normal surface lives. |
Reimplemented from regina::NormalSurfaceVector.
|
inlineoverridevirtual |
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.
triang | the triangulation in which this normal surface lives. |
Reimplemented from regina::NormalSurfaceVector.
|
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.
true
if and only if this surface is vertex linking.
|
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.
triang | the triangulation in which this normal surface lives. |
true
if and only if the normal surface represented is vertex linking. 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.
other | the other surface to test for local compatibility with this surface. |
true
if the two surfaces are locally compatible, or false
if they are not.
|
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.
triangulation | the triangulation upon which these validity constraints will be based. |
EnumConstraints* regina::makeEmbeddedConstraints | ( | const Triangulation< 3 > * | triangulation, |
NormalCoords | coords | ||
) |
Creates a new set of validity constraints representing the condition that normal surfaces be embedded.
The validity constraints will be expressed relative to the given coordinate system.
triangulation | the triangulation upon which these validity constraints will be based. |
coords | the coordinate system to be used. |
|
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.
triangulation | the triangulation upon which these matching equations will be based. |
MatrixInt* regina::makeMatchingEquations | ( | const Triangulation< 3 > * | triangulation, |
NormalCoords | coords | ||
) |
Creates a new set of normal surface matching equations for the given triangulation using the given coordinate system.
The returned matrix will be newly allocated and its destruction will be the responsibility of the caller of this routine.
Each equation will be represented as a row of the matrix. Each column of the matrix represents a coordinate in the given coordinate system.
For some coordinate systems, Regina may not be able to create matching equations for all triangulations (these coordinate systems are explicitly mentioned as such in the NormalCoords enum documentation). If Regina cannot create the matching equations as requested, this routine will return null
instead.
triangulation | the triangulation upon which these matching equations will be based. |
coords | the coordinate system to be used. |
null
if Regina is not able to construct them for the given combination of triangulation and coordinate system.
|
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:
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. |
|
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.
triang | the triangulation in which this normal surface lives. |
Implemented in regina::NSVectorQuadOct, regina::NSVectorQuad, and regina::NSVectorOrientedQuad.
|
inlineoverridevirtual |
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.
triang | the triangulation in which this normal surface lives. |
Implements regina::NSVectorMirrored.
|
inlineoverridevirtual |
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.
triang | the triangulation in which this normal surface lives. |
Implements regina::NSVectorMirrored.
|
inlineoverridevirtual |
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.
triang | the triangulation in which this normal surface lives. |
Implements regina::NSVectorMirrored.
|
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.
triangulation | the triangulation upon which the underlying coordinate system is based. |
NormalSurfaceVector* regina::makeZeroVector | ( | const Triangulation< 3 > * | triangulation, |
NormalCoords | coords | ||
) |
Returns a new normal surface vector of the appropriate length for the given triangulation and the given coordinate system.
All elements of this vector will be initialised to zero.
The new vector will be of the subclass of NormalSurfaceVector corresponding to the given coordinate system. The caller of this routine is responsible for destroying the new vector.
triangulation | the triangulation upon which the underlying coordinate system is based. |
coords | the coordinate system to be used. |
|
inline |
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.
|
inline |
Determines the number of discs of the given type inside this tetrahedron.
type | the disc type to examine; this should be between 0 and 9 inclusive. Disc types are outlined in the DiscSpec class notes. |
|
inline |
Determines the number of discs of the given type inside the given tetrahedron.
tetIndex | the index in the triangulation of the tetrahedron to examine. |
type | the disc type to examine; this should be between 0 and 9 inclusive. Disc types are outlined in the DiscSpec class notes. |
|
inline |
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.
true
if and only if this surface contains only triangles and/or quadrilaterals. 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.
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. |
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).
triang | the triangulation in which this normal surface resides. |
newVector | a vector containing the coordinates of the normal surface in whichever space is appropriate. |
|
inlineprotected |
Creates an empty list of normal surfaces with the given 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. |
|
inline |
Creates a new vector that is a clone of the given vector.
cloneMe | the vector to clone. |
|
inline |
Creates a new vector all of whose entries are initialised to zero.
length | the number of elements in the new vector. |
|
inline |
Creates a new vector that is a clone of the given vector.
cloneMe | the vector to clone. |
|
inline |
Creates a new vector all of whose entries are initialised to zero.
length | the number of elements in the new vector. |
|
inline |
Creates a new vector that is a clone of the given vector.
cloneMe | the vector to clone. |
|
inline |
Creates a new vector all of whose entries are initialised to zero.
length | the number of elements in the new vector. |
|
inline |
Creates a new vector that is a clone of the given vector.
cloneMe | the vector to clone. |
|
inline |
Creates a new vector all of whose entries are initialised to zero.
length | the number of elements in the new vector. |
|
inline |
Creates a new vector that is a clone of the given vector.
cloneMe | the vector to clone. |
|
inline |
Creates a new vector all of whose entries are initialised to zero.
length | the number of elements in the new vector. |
|
inline |
Creates a new vector that is a clone of the given vector.
cloneMe | the vector to clone. |
|
inline |
Creates a new vector all of whose entries are initialised to zero.
length | the number of elements in the new vector. |
|
inline |
Creates a new vector that is a clone of the given vector.
cloneMe | the vector to clone. |
|
inline |
Creates a new vector all of whose entries are initialised to zero.
length | the number of elements in the new vector. |
|
inline |
Creates a new vector that is a clone of the given vector.
cloneMe | the vector to clone. |
|
inline |
Creates a new vector all of whose entries are initialised to zero.
length | the number of elements in the new vector. |
|
inline |
Creates a new vector that is a clone of the given vector.
cloneMe | the vector to clone. |
|
inline |
Creates a new vector all of whose entries are initialised to zero.
length | the number of elements in the new vector. |
|
inline |
Creates a new vector that is a clone of the given vector.
cloneMe | the vector to clone. |
|
inline |
Creates a new vector all of whose entries are initialised to zero.
length | the number of elements in the new vector. |
|
inline |
Returns the number of tetrahedra in the underlying triangulation.
bool regina::numberDiscsAwayFromVertex | ( | int | discType, |
int | vertex | ||
) |
Determines whether or not normal discs of the given type are numbered away from the given vertex.
discType | the normal disc type under consideration; this should be between 0 and 9 inclusive, as described by the DiscSpec class notes. |
vertex | the vertex under consideration; this should be between 0 and 3 inclusive. |
true
if normal discs of the given type are numbered away from the given vertex, or false
if they are numbered towards the given vertex.
|
inline |
Determines 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).
|
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:
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.
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. |
|
pure virtual |
Returns the number of octagonal discs of the given type in this normal surface.
See NormalSurface::octs() for further details.
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. |
Implemented in regina::NSVectorStandard, regina::NSVectorQuad, regina::NSVectorOrientedQuad, regina::NSVectorOriented, regina::NSVectorMirrored, and regina::NSVectorANStandard.
|
inlineoverridevirtual |
Returns the number of octagonal discs of the given type in this normal surface.
See NormalSurface::octs() for further details.
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. |
Implements regina::NormalSurfaceVector.
|
inlineoverridevirtual |
Returns the number of octagonal discs of the given type in this normal surface.
See NormalSurface::octs() for further details.
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. |
Implements regina::NormalSurfaceVector.
Reimplemented in regina::NSVectorQuad, and regina::NSVectorOrientedQuad.
|
inlineoverridevirtual |
Returns the number of octagonal discs of the given type in this normal surface.
See NormalSurface::octs() for further details.
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. |
Implements regina::NormalSurfaceVector.
|
inlineoverridevirtual |
Returns the number of octagonal discs of the given type in this normal surface.
See NormalSurface::octs() for further details.
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. |
Reimplemented from regina::NSVectorMirrored.
|
inlineoverridevirtual |
Returns the number of octagonal discs of the given type in this normal surface.
See NormalSurface::octs() for further details.
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. |
Reimplemented from regina::NSVectorMirrored.
|
inlineoverridevirtual |
Returns the number of octagonal discs of the given type in this normal surface.
See NormalSurface::octs() for further details.
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. |
Implements regina::NormalSurfaceVector.
|
inline |
Determines if this and the given disc specifier contain different information.
other | the disc specifier to compare with this. |
true
if and only if this and the given disc specifier contain different information.
|
inline |
Determines if this and the given iterator are different.
Two iterators are considered equal if (i) they were constructed from the same DiscSetSurface object (not two different DiscSetSurface objects with identical contents), and (ii) they point to the same disc of the same tetrahedron.
other | the iterator to compare with this. |
true
if and only if this and the given iterator are equal.
|
inline |
Determines if this and the given disc type are different.
This is the negation of the equality test; see operator == for further details.
true
if this and the given disc type are different, or false
if they are identical.
|
inline |
Determines if this and the given prism specifier contain different information.
other | the prism specifier to compare with this. |
true
if and only if this and the given prism specifier contain different information.
|
inline |
Compares this with the given operator for inequality.
other | the iterator to compare this with. |
false
if the iterators point to the same element of the same normal surface list, or true
if they do not. 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_.
The matching equation matrix eqns_ will be deleted during this routine.
Coords | an instance of the NormalInfo<> template class. |
|
inline |
Returns a reference to this output iterator.
|
inline |
Returns a reference to the disc pointed to by this iterator.
|
inline |
Returns the raw vector for the normal surface that this iterator is currently pointing to.
|
inline |
Preincrement operator.
next()
, which either returns the current packet in the subtree and increments the iterator, or else throws a StopIteration
exception if the iterator is past-the-end.
|
inline |
The preincrement operator.
|
inline |
Returns a reference to this output iterator.
|
inline |
Postincrement operator.
next()
, which either returns the current packet in the subtree and increments the iterator, or else throws a StopIteration
exception if the iterator is past-the-end.
|
inline |
The postincrement operator.
|
inline |
Returns a reference to this output iterator.
|
inlinevirtual |
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.
other | the vector to add to this vector. |
Reimplemented in regina::NSVectorMirrored.
|
inlineoverridevirtual |
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.
other | the vector to add to this vector. |
Reimplemented from regina::NormalSurfaceVector.
|
inline |
The predecrement operator.
|
inline |
The postdecrement operator.
|
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.
true
if this disc type appears before the given disc type in the ordering, or false
if not. std::ostream& regina::operator<< | ( | std::ostream & | out, |
const DiscSpec & | spec | ||
) |
Writes the given disc specifier to the given output stream.
The disc specifier will be written as a triple (tetIndex, type, number)
.
out | the output stream to which to write. |
spec | the disc specifier to write. |
|
inline |
Writes the given disc type to the given output stream.
The disc type will be written as a pair (tetIndex, type)
.
out | the output stream to which to write. |
type | the disc type to write. |
std::ostream& regina::operator<< | ( | std::ostream & | out, |
const PrismSpec & | spec | ||
) |
Writes the given prism specifier to the given output stream.
The prism specifier will be written as a pair (tetIndex, edge)
.
out | the output stream to which to write. |
spec | the prism specifier to write. |
Copies the values from the given disc specifier into this specifier.
cloneMe | the disc specifier whose values should be copied. |
|
default |
Default copy assignment operator.
Sets this to a copy of the given disc type.
cloneMe | the disc type to clone. |
Copies the values from the given prism specifier into this specifier.
cloneMe | the prism specifier whose values should be copied. |
|
default |
Sets this iterator to be a clone of the given output iterator.
cloneMe | the output iterator to clone. |
|
default |
Makes this a copy of the given iterator.
cloneMe | the iterator to clone. |
|
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.
surface | the normal surface to insert. |
|
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.
vector | the vector of the normal surface to insert. |
|
inline |
Determines if this and the given disc specifier contain identical information.
other | the disc specifier to compare with this. |
true
if and only if this and the given disc specifier contain identical information.
|
inline |
Determines if this and the given iterator are equal.
Two iterators are considered equal if (i) they were constructed from the same DiscSetSurface object (not two different DiscSetSurface objects with identical contents), and (ii) they point to the same disc of the same tetrahedron.
other | the iterator to compare with this. |
true
if and only if this and the given iterator are equal.
|
inline |
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).
true
if this and the given disc type are identical, or false
if they are different.
|
inline |
Determines if this and the given prism specifier contain identical information.
other | the prism specifier to compare with this. |
true
if and only if this and the given prism specifier contain identical information.
|
inline |
Compares this with the given operator for equality.
other | the iterator to compare this with. |
true
if the iterators point to the same element of the same normal surface list, or false
if they do not.
|
inline |
|
inline |
Returns the bitwise OR of the two given flags.
lhs | the first flag to combine. |
rhs | the second flag to combine. |
|
inline |
Returns the bitwise OR of the two given flags.
lhs | the first flag to combine. |
rhs | the second flag to combine. |
|
inline |
Returns the 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.
|
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.
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 |
|
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.
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. |
Reimplemented in regina::NSVectorOrientedQuad, regina::NSVectorOriented, and regina::NSVectorMirrored.
|
inlineoverridevirtual |
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.
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. |
Reimplemented from regina::NormalSurfaceVector.
Reimplemented in regina::NSVectorOrientedQuad.
|
inlineoverridevirtual |
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.
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. |
Reimplemented from regina::NormalSurfaceVector.
|
inlineoverridevirtual |
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.
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. |
Reimplemented from regina::NSVectorMirrored.
|
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.
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 |
|
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.
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. |
Reimplemented in regina::NSVectorOriented, and regina::NSVectorMirrored.
|
inlineoverridevirtual |
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.
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. |
Reimplemented from regina::NormalSurfaceVector.
|
inlineoverridevirtual |
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.
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. |
Reimplemented from regina::NormalSurfaceVector.
|
inlineoverridevirtual |
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.
Reimplemented from regina::XMLPacketReader.
|
inlineoverridevirtual |
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.
Reimplemented from regina::XMLPacketReader.
|
inline |
Creates a new uninitialised prism specifier.
|
default |
Creates a new prism specifier that is a clone of the given specifier.
cloneMe | the prism specifier to clone. |
|
inline |
Creates a new prism specifier containing the given values.
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. |
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.
true
.null
if any of the basic sanity checks failed.
|
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:
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.
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. |
|
pure virtual |
Returns the number of quadrilateral discs of the given type in this normal surface.
See NormalSurface::quads() for further details.
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. |
Implemented in regina::NSVectorStandard, regina::NSVectorOrientedQuad, regina::NSVectorOriented, regina::NSVectorMirrored, and regina::NSVectorANStandard.
|
inlineoverridevirtual |
Returns the number of quadrilateral discs of the given type in this normal surface.
See NormalSurface::quads() for further details.
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. |
Implements regina::NormalSurfaceVector.
|
inlineoverridevirtual |
Returns the number of quadrilateral discs of the given type in this normal surface.
See NormalSurface::quads() for further details.
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. |
Implements regina::NormalSurfaceVector.
Reimplemented in regina::NSVectorOrientedQuad.
|
inlineoverridevirtual |
Returns the number of quadrilateral discs of the given type in this normal surface.
See NormalSurface::quads() for further details.
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. |
Implements regina::NormalSurfaceVector.
|
inlineoverridevirtual |
Returns the number of quadrilateral discs of the given type in this normal surface.
See NormalSurface::quads() for further details.
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. |
Reimplemented from regina::NSVectorMirrored.
|
inlineoverridevirtual |
Returns the number of quadrilateral discs of the given type in this normal surface.
See NormalSurface::quads() for further details.
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. |
Implements regina::NormalSurfaceVector.
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 null
.
true
.null
if any of the basic sanity checks failed.
|
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).
|
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.
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().
Note that there are situations in which makeMatchingEquations() returns null
(because the triangulation is not supported by the chosen coordinate system). However, this routine should never return null
, because if makeMatchingEquations() had returned null
then this normal surface list would not have been created in the first place.
|
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.
|
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.
ec | the allowable Euler characteristic to remove. |
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.
other | the surface to be compared with this surface. |
true
if both surfaces represent the same normal or almost normal surface, or false
if not. 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"
.
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. |
true
if the export was successful, or false
otherwise. 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"
.
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. |
true
if the export was successful, or false
otherwise.
|
inlinevirtual |
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.
|
inlineoverridevirtual |
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.
|
inline |
Sets the set of allowable compactness properties.
See compactness() for further details.
value | the new set of allowable compactness properties. |
|
inlinevirtual |
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.
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.
|
inlineoverridevirtual |
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.
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.
|
inline |
Sets the allowable Euler characteristics to the given set.
See eulerChars() for further details.
s | the new set of allowable Euler characteristics. |
|
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.
newName | the new name to associate with this surface. |
|
inline |
Sets the set of allowable orientabilities.
See orientability() for further details.
value | the new set of allowable orientabilities. |
|
inline |
Sets the set of allowable has-real-boundary properties.
See realBoundary() for further details.
value | the new set of allowable has-real-boundary properties. |
|
inline |
Sets whether this is an and or an or combination.
value | true if this is to be an and combination, or false if this is to be an or combination. |
|
inline |
Returns the number of coordinates in the underlying vector.
|
inline |
Returns the number of surfaces stored in this list.
|
inline |
Sorts the surfaces in this list according to the given criterion.
This sort is stable, i.e., surfaces that are equivalent under the given criterion will remain in the same relative order.
The implementation of this routine uses std::stable_sort.
comp | a binary function (or function object) that accepts two const NormalSurface pointers, and returns true if and only if the first surface should appear before the second in the sorted list. |
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.
true
.null
if any of the basic sanity checks failed. 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 null
.
true
.null
if any of the basic sanity checks failed.
|
overridevirtual |
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.
subTagName | the name of the subelement opening tag. |
subTagProps | the properties associated with the subelement opening tag. |
Reimplemented from regina::XMLPacketReader.
|
overridevirtual |
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.
subTagName | the name of the subelement opening tag. |
subTagProps | the properties associated with the subelement opening tag. |
Reimplemented from regina::XMLPacketReader.
|
overridevirtual |
Signifies that parsing of this XML element is beginning.
The default implementation does nothing.
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.
|
overridevirtual |
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.
subTagName | the name of the subelement opening tag. |
subTagProps | the properties associated with the subelement opening tag. |
Reimplemented from regina::XMLElementReader.
|
inline |
Returns the normal surface that has been read.
|
inline |
|
inline |
Creates a new default surface filter.
This will simply accept all normal surfaces.
|
inline |
Creates a new default surface filter.
This will simply accept all normal surfaces. Note that the given parameter is ignored.
cloneMe | this parameter is ignored. |
|
inline |
Creates a new surface filter that accepts all normal surfaces.
This will be an and filter.
|
inline |
Creates a new surface filter that is a clone of the given surface filter.
cloneMe | the surface filter to clone. |
|
inline |
Creates a new surface filter that accepts all normal surfaces.
|
inline |
Creates a new surface filter that is a clone of the given surface filter.
cloneMe | the surface filter to clone. |
|
default |
Creates a new output iterator that is a clone of the given iterator.
cloneMe | the output iterator to clone. |
|
inline |
Creates a new output iterator.
The member variables of this iterator will be initialised according to the parameters passed to this constructor.
newList | the list into which surfaces will be inserted. |
newOwner | the triangulation in which the surfaces to be inserted are contained. |
|
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
.
true
if and only if almost normal surfaces are allowed in the underlying coordinate system.
|
inline |
Determines if the underlying coordinate system being used allows for transversely oriented normal surfaces.
true
if and only if transverse orientations are supported in the underlying coordinate system.
|
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
.
true
if and only if spun normal surface are supported in the underlying coordinate system.
|
inline |
Returns the specific set of discs living inside the given tetrahedron.
tetIndex | the index in the triangulation of the given tetrahedron. |
|
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.
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. |
|
pure virtual |
Returns the number of triangular discs of the given type in this normal surface.
See NormalSurface::triangles() for further details.
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. |
Implemented in regina::NSVectorStandard, regina::NSVectorOriented, regina::NSVectorMirrored, and regina::NSVectorANStandard.
|
inlineoverridevirtual |
Returns the number of triangular discs of the given type in this normal surface.
See NormalSurface::triangles() for further details.
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. |
Implements regina::NormalSurfaceVector.
|
inlineoverridevirtual |
Returns the number of triangular discs of the given type in this normal surface.
See NormalSurface::triangles() for further details.
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. |
Implements regina::NormalSurfaceVector.
|
inlineoverridevirtual |
Returns the number of triangular discs of the given type in this normal surface.
See NormalSurface::triangles() for further details.
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. |
Implements regina::NormalSurfaceVector.
|
inlineoverridevirtual |
Returns the number of triangular discs of the given type in this normal surface.
See NormalSurface::triangles() for further details.
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. |
Implements regina::NormalSurfaceVector.
|
inline |
Returns the triangulation in which this normal surface resides.
Triangulation<3>* regina::NormalSurfaces::triangulation | ( | ) | const |
Returns the triangulation in which these normal surfaces live.
|
inline |
Determines whether this is an and or an or combination.
true
if this is an and combination, or false
if this is an or combination.
|
inline |
Creates a new uninitialised iterator.
|
default |
Creates a copy of the given iterator.
cloneMe | the iterator to clone. |
|
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.
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.
out | the output stream to which to write. |
|
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.
out | the output stream to which to write. |
|
overridevirtual |
Writes a detailed text representation of this object to the given output stream.
This may be reimplemented by subclasses, but the parent Packet class offers a reasonable default implementation.
out | the output stream to which to write. |
Reimplemented from regina::Packet.
|
inlineoverridevirtual |
Writes a detailed text representation of this object to the given output stream.
This may be reimplemented by subclasses, but the parent Packet class offers a reasonable default implementation.
out | the output stream to which to write. |
Reimplemented from regina::Packet.
|
overridevirtual |
Writes a detailed text representation of this object to the given output stream.
This may be reimplemented by subclasses, but the parent Packet class offers a reasonable default implementation.
out | the output stream to which to write. |
Reimplemented from regina::Packet.
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.
out | the output stream to which to write. |
|
overridevirtual |
Writes a short text representation of this object to the given output stream.
This must be reimplemented by subclasses.
out | the output stream to which to write. |
Implements regina::Packet.
|
inlineoverridevirtual |
Writes a short text representation of this object to the given output stream.
This must be reimplemented by subclasses.
out | the output stream to which to write. |
Implements regina::Packet.
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().
out | the output stream to which the XML should be written. |
|
inlineprotectedvirtual |
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.
out | the output stream to which the XML should be written. |
Reimplemented in regina::SurfaceFilterProperties, and regina::SurfaceFilterCombination.
|
overrideprotectedvirtual |
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.
out | the output stream to which the XML should be written. |
Reimplemented from regina::SurfaceFilter.
|
overrideprotectedvirtual |
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.
out | the output stream to which the XML should be written. |
Reimplemented from regina::SurfaceFilter.
|
overrideprotectedvirtual |
Writes a chunk of XML containing the data for this packet only.
You may assume that the packet opening tag (including the packet type and label) has already been written, and that all child packets followed by the corresponding packet closing tag will be written immediately after this routine is called. This routine need only write the internal data stored in this specific packet.
out | the output stream to which the XML should be written. |
Implements regina::Packet.
|
overrideprotectedvirtual |
Writes a chunk of XML containing the data for this packet only.
You may assume that the packet opening tag (including the packet type and label) has already been written, and that all child packets followed by the corresponding packet closing tag will be written immediately after this routine is called. This routine need only write the internal data stored in this specific packet.
out | the output stream to which the XML should be written. |
Implements regina::Packet.
|
inline |
Creates a new surface filter packet reader.
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. |
|
inline |
Creates a new filter element reader.
|
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.
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. |
|
inline |
Creates a new normal surface reader.
newTri | the triangulation in which this normal surface lives. |
newCoords | the coordinate system used by this normal surface. |
|
inline |
Creates a new normal surface list reader.
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. |
|
virtual |
Destroys this set of discs and deallocates all associated memory.
|
inlinevirtual |
Destroys this disc set.
|
inlinevirtual |
Destroys this disc set and deallocates all data arrays.
Note that no assumption is made about type T
, so if data elements are pointers to dynamically allocated objects, these will not be destroyed.
|
inline |
Destroys this normal surface.
The underlying vector of coordinates will also be deallocated.
|
inlinevirtual |
Destroys this list and all the surfaces within.
|
inlinevirtual |
A virtual destructor.
This is required because here we introduce virtual functions into the Ray hierarchy.
|
inlinevirtual |
Destroys this vector and its mirror if appropriate.
|
inlinevirtual |
Destroys this surface filter.
|
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).
|
mutableprotected |
The number of disjoint boundary curves on this surface.
|
mutableprotected |
Is this surface compact (i.e.
does it only contain finitely many discs)?
|
mutableprotected |
Is this surface connected?
|
protected |
The raw vector of normal coordinates.
|
protected |
Stores which coordinate system is being used by the normal surfaces in this packet.
|
protected |
The disc currently pointed to.
|
protected |
The disc sets corresponding to each tetrahedron.
int regina::PrismSpec::edge |
The edge of the tetrahedron that is contained in this prism.
|
mutableprotected |
The Euler characteristic of this surface.
|
staticconstexpr |
A compile-time constant that identifies this type of surface filter.
|
protected |
Stores the data corresponding to each normal disc.
|
protected |
The disc set through which we are iterating.
|
protected |
The number of discs of each type.
NormalSurfaces* regina::NormalSurfaces::SurfaceInserter::list |
The list into which surfaces will be inserted.
|
protected |
An optional name associated with this surface.
|
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.
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.
|
extern |
Lists in consecutive order the directed normal arcs that form the boundary of each type of octagonal normal disc.
Each permutation p represents an arc about vertex p[0]
parallel to the directed edge from p[1]
to p[2]
.
Array octDiscArcs[i]
lists the boundary arcs of the octagonal disc of type i. See NormalSurface::octs() for further details.
Note that permutation octDiscArcs[i][j]
will be even precisely when j
is 0, 1, 4 or 5.
octDiscArcs(discType, arcIndex)
that essentially looks up the corresponding array. This is necessary because of a bug in gcc 2.95. 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.
|
mutableprotected |
Is this surface orientable?
Triangulation<3>* regina::NormalSurfaces::SurfaceInserter::owner |
The triangulation in which the surfaces to be inserted are contained.
|
extern |
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.
|
extern |
Lists in consecutive order the directed normal arcs that form the boundary of each type of quadrilateral normal disc.
Each permutation p represents an arc about vertex p[0]
parallel to the directed edge from p[1]
to p[2]
.
Array quadDiscArcs[i]
lists the boundary arcs of the quadrilateral disc of type i. See NormalSurface::quads() for further details.
Note that permutation quadDiscArcs[i][j]
will be even precisely when j
is even.
quadDiscArcs(discType, arcIndex)
that essentially looks up the corresponding array. This is necessary because of a bug in gcc 2.95.
|
extern |
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
.
|
extern |
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]
.
|
extern |
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).
|
extern |
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.
|
mutableprotected |
Does this surface have real boundary (i.e.
does it meet any boundary triangles)?
|
protected |
Contains the normal surfaces stored in this packet.
size_t regina::DiscSpec::tetIndex |
The index in the triangulation of the tetrahedron containing the disc.
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.
size_t regina::PrismSpec::tetIndex |
The index in the triangulation of the tetrahedron containing the prism.
|
protected |
The triangulation in which the normal surface lives.
|
protected |
The triangulation in which this normal surface resides.
|
extern |
Lists in consecutive order the directed normal arcs that form the boundary of each type of triangular normal disc.
Each permutation p represents an arc about vertex p[0]
parallel to the directed edge from p[1]
to p[2]
.
Array triDiscArcs[i]
lists the boundary arcs of the triangular disc of type i. See NormalSurface::triangles() for further details.
Note that every permutation in this array is even.
triDiscArcs(discType, arcIndex)
that essentially looks up the corresponding array. This is necessary because of a bug in gcc 2.95.
|
mutableprotected |
Is this surface two-sided?
int regina::DiscSpec::type |
The disc type; this is between 0 and 9 inclusive, as described in the DiscSpec class notes.
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.
|
protected |
Contains the coordinates of the normal surface in whichever space is appropriate.
|
protected |
Indicates which normal surfaces these represent within the underlying triangulation.
|
friend |
Writes the given disc specifier to the given output stream.
The disc specifier will be written as a triple (tetIndex, type, number)
.
out | the output stream to which to write. |
spec | the disc specifier to write. |
|
friend |
Writes the given prism specifier to the given output stream.
The prism specifier will be written as a pair (tetIndex, edge)
.
out | the output stream to which to write. |
spec | the prism specifier to write. |