A collection of normal hypersurfaces in a 4-manifold triangulation. More...

#include <hypersurface/normalhypersurfaces.h>

Inheritance diagram for regina::NormalHypersurfaces:

Classes
class	VectorIterator
	A bidirectional iterator that runs through the raw vectors for hypersurfaces in this list. More...

Public Member Functions
	NormalHypersurfaces (const Triangulation< 4 > &triangulation, HyperCoords coords, HyperList which=HS_LIST_DEFAULT, HyperAlg algHints=HS_ALG_DEFAULT, ProgressTracker *tracker=nullptr)
	A unified constructor for enumerating various classes of normal hypersurfaces within a given triangulation. More...

	NormalHypersurfaces (const NormalHypersurfaces &)=default
	Constructs a new copy of the given list. More...

	NormalHypersurfaces (NormalHypersurfaces &&src) noexcept=default
	Moves the given list into this new list. More...

NormalHypersurfaces &	operator= (const NormalHypersurfaces &src)
	Sets this to be a (deep) copy of the given list. More...

NormalHypersurfaces &	operator= (NormalHypersurfaces &&src)
	Moves the contents of the given list into this list. More...

void	swap (NormalHypersurfaces &other)
	Swaps the contents of this and the given list. More...

HyperCoords	coords () const
	Returns the coordinate system that was originally used to enumerate the hypersurfaces in this list. More...

HyperList	which () const
	Returns details of which normal hypersurfaces this list represents within the underlying triangulation. More...

HyperAlg	algorithm () const
	Returns details of the algorithm that was used to enumerate this list. More...

bool	allowsNonCompact () const
	Determines if the coordinate system that was used for enumeration allows for non-compact hypersurfaces. More...

bool	isEmbeddedOnly () const
	Returns whether this list is known to contain only embedded normal hypersurfaces. More...

const Triangulation< 4 > &	triangulation () const
	Returns the triangulation in which these normal hypersurfaces live. More...

size_t	size () const
	Returns the number of hypersurfaces stored in this list. More...

const NormalHypersurface &	hypersurface (size_t index) const
	Returns the hypersurface at the requested index in this list. More...

const NormalHypersurface &	operator[] (size_t index) const
	Returns the hypersurface at the requested index in this list. More...

auto	begin () const
	Returns a C++ iterator at the beginning of this list of hypersurfaces. More...

auto	end () const
	Returns a C++ iterator beyond the end of this list of hypersurfaces. More...

auto	__iter__ () const
	Returns a Python iterator over the normal hypersurfaces in this list. More...

bool	operator== (const NormalHypersurfaces &other) const
	Determines whether this and the given list contain the same set of normal hypersurfaces. More...

bool	operator!= (const NormalHypersurfaces &other) const
	Determines whether this and the given list contain different sets of normal hypersurfaces. More...

void	writeTextShort (std::ostream &out) const
	Writes a short text representation of this object to the given output stream. More...

void	writeTextLong (std::ostream &out) const
	Writes a detailed text representation of this object to the given output stream. More...

template<typename Comparison >
void	sort (Comparison &&comp)
	Sorts the hypersurfaces in this list according to the given criterion. More...

MatrixInt	recreateMatchingEquations () const
	Returns the matching equations that were used to create this normal hypersurface list. More...

VectorIterator	beginVectors () const
	A C++ iterator that gives access to the raw vectors for hypersurfaces in this list, pointing to the beginning of this hypersurface list. More...

VectorIterator	endVectors () const
	A C++ iterator that gives access to the raw vectors for hypersurfaces in this list, pointing past the end of this hypersurface list. More...

auto	vectors () const
	Returns a Python iterable object that iterates over the raw vectors for all hypersurfaces in this list. More...

std::shared_ptr< PacketOf< NormalHypersurfaces > >	packet ()
	Returns the packet that holds this data, if there is one. More...

std::shared_ptr< const PacketOf< NormalHypersurfaces > >	packet () const
	Returns the packet that holds this data, if there is one. More...

std::string	anonID () const
	A unique string ID that can be used in place of a packet ID. More...

std::string	str () const
	Returns a short text representation of this object. More...

std::string	utf8 () const
	Returns a short text representation of this object using unicode characters. More...

std::string	detail () const
	Returns a detailed text representation of this object. More...

Protected Member Functions
	NormalHypersurfaces (HyperCoords coords, HyperList which, HyperAlg algorithm, const Triangulation< 4 > &triangulation)
	Creates an empty list of normal hypersurfaces with the given parameters. More...

	NormalHypersurfaces (HyperCoords coords, HyperList which, HyperAlg algorithm, const SnapshotRef< Triangulation< 4 > > &triangulation)
	Creates an empty list of normal hypersurfaces with the given parameters. More...

Protected Attributes
std::vector< NormalHypersurface >	surfaces_
	Contains all normal hypersurfaces in this list. More...

SnapshotRef< Triangulation< 4 > >	triangulation_
	The triangulation in which these normal hypersurfaces lie. More...

HyperCoords	coords_
	The coordinate system that was originally used to enumerate the normal hypersurfaces in this list. More...

HyperList	which_
	Indicates which normal hypersurfaces these represent within the underlying triangulation. More...

HyperAlg	algorithm_
	Stores the details of the enumeration algorithm that was used to generate this list. More...

PacketHeldBy	heldBy_
	Indicates whether this Held object is in fact the inherited data for a PacketOf<Held>. More...

Friends
class	XMLNormalHypersurfacesReader

class	XMLLegacyNormalHypersurfacesReader

class	XMLWriter< NormalHypersurfaces >

Detailed Description

A collection of normal hypersurfaces in a 4-manifold triangulation.

There are some important changes to this class as of Regina 7.0:

A normal hypersurface list does not need to be a child packet of the underlying triangulation, and indeed does not need to interact with the packet tree at all.
You are welcome to modify or even destroy the original triangulation; if you do then this list will automatically make a private copy of the original triangulation as an ongoing reference. Different normal hypersurface lists can all share the same private copy, so this is not an expensive process.
You should now create normal hypersurface lists using the class constructor (but which, unlike the old enumerate(), does not insert the list into the packet tree). There is no need to use enumerate() any more.

Since Regina 7.0, this is no longer a "packet type" that can be inserted directly into the packet tree. Instead a normal hypersurface list is now a standalone mathematatical object, which makes it slimmer and faster for ad-hoc use. The consequences of this are:

If you create your own NormalHypersurfaces object, it will not have any of the usual packet infrastructure. You cannot add it into the packet tree, and it will not support a label, tags, child/parent packets, and/or event listeners.
To include an NormalHypersurfaces object in the packet tree, you must create a new PacketOf<NormalHypersurfaces>. This is a packet type, and supports labels, tags, child/parent packets, and event listeners. It derives from NormalHypersurfaces, and so inherits the full NormalHypersurfaces interface.
If you are adding new functions to this class that edit the list, you must still remember to create a ChangeEventSpan. This will ensure that, if the list is being managed by a PacketOf<NormalHypersurfaces>, then the appropriate packet change events will be fired. All other events (aside from packetToBeChanged() and packetWasChanged() are managed directly by the PacketOf<NormalHypersurfaces> wrapper class.

See the NormalHypersurface class notes for details of what to do when introducing a new coordinate system.

This class implements C++ move semantics and adheres to the C++ Swappable requirement. It is designed to avoid deep copies wherever possible, even when passing or returning objects by value.

Constructor & Destructor Documentation

◆ NormalHypersurfaces() [1/5]

regina::NormalHypersurfaces::NormalHypersurfaces	(	const Triangulation< 4 > &	triangulation,
		HyperCoords	coords,
		HyperList	which = `HS_LIST_DEFAULT`,
		HyperAlg	algHints = `HS_ALG_DEFAULT`,
		ProgressTracker *	tracker = `nullptr`
	)

inline

A unified constructor for enumerating various classes of normal hypersurfaces within a given triangulation.

The HyperCoords argument allows you to specify an underlying coordinate system in which to do the enumeration (e.g., standard coordinates or prism coordinates). This choice of coordinate system will affect which surfaces are produced, since vertex/fundamental surfaces in one system are not necessarily vertex/fundamental in another.

The HyperList argument is a combination of flags that allows you to specify exactly which normal hypersurfaces you require. This includes (i) whether you want all vertex hypersurfaces or all fundamental hypersurfaces, which defaults to HS_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 hypersurfaces, which defaults to HS_EMBEDDED_ONLY if you specify neither or both.

The HyperAlg 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 HS_ALG_DEFAULT (which makes no hints at all) will allow Regina to choose what it thinks will be the most efficient method.

The enumerated hypersurfaces will be stored in this new normal hypersurface list, and their representations will be scaled down to use the smallest possible integer coordinates.

Unlike the old enumerate() function, the new normal hypersurface list will not be inserted into the packet tree. Moreover, the given triangulation may change or even be destroyed without causing problems. See the class notes for details.

If a progress tracker is passed, 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.

This constructor will not return until the enumeration of hypersurfaces is complete, regardless of whether a progress tracker was passed. If you need the behaviour of the old enumerate() (where passing a progress tracker caused the enumeration to start in the background), simply call this constructor in a new detached thread. Note that this enumeration can be extremely slow for larger triangulations, and so there could be good reasons to do this.

If an error occurs, then this routine will thrown an exception. In this case, no normal hypersurface list will be created, and the progress tracker (if passed) will be marked as finished. See the exception specifications below for details.

Exceptions

InvalidArgument The matching equations could not be created for the given triangulation in the given coordinate system, due to an error that should have been preventable with the right checks in advance. This can only happen in certain coordinate systems, and for all such coordinate systems this is explicitly described in the HyperCoords enum documentation.

UnsolvedCase The list of hypersurfaces could not be be created for the given triangulation in the given coordinate system, due to an error that was "genuinely" unforseeable. Currently there are two scenarios in which this could happen: (i) the matching equations could not be constructed, which can only happen in certain coordinate systems where this is explicitly described in the HyperCoords enum documentation; or (ii) the arguments require enumerating fundamental normal surfaces using the primal Hilbert basis algorithm, and Normaliz was unable to complete its portion of the task, which in theory should never happen at all.

Python: The global interpreter lock will be released while this constructor runs, so you can use it with Python-based multithreading.

Parameters

triangulation	the triangulation upon which this list of normal hypersurfaces will be based.
coords	the coordinate system to be used. This must be one of the system that Regina is able to use for enumeration; this is documented alongside each HyperCoords enum value.
which	indicates which normal hypersurfaces 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.

◆ NormalHypersurfaces() [2/5]

regina::NormalHypersurfaces::NormalHypersurfaces ( const NormalHypersurfaces & )

default

Constructs a new copy of the given list.

◆ NormalHypersurfaces() [3/5]

regina::NormalHypersurfaces::NormalHypersurfaces ( NormalHypersurfaces && src )

defaultnoexcept

Moves the given list into this new list.

This is a fast (constant time) operation.

The list that is passed will no longer be usable.

Note: This operator is marked noexcept, and in particular does not fire any change events. This is because this list is freshly constructed (and therefore has no listeners yet), and because we assume that src is about to be destroyed (an action that will fire a packet destruction event).

Parameters

src	the list to move.

◆ NormalHypersurfaces() [4/5]

regina::NormalHypersurfaces::NormalHypersurfaces	(	HyperCoords	coords,
		HyperList	which,
		HyperAlg	algorithm,
		const Triangulation< 4 > &	triangulation
	)

inlineprotected

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

◆ NormalHypersurfaces() [5/5]

regina::NormalHypersurfaces::NormalHypersurfaces	(	HyperCoords	coords,
		HyperList	which,
		HyperAlg	algorithm,
		const SnapshotRef< Triangulation< 4 > > &	triangulation
	)

inlineprotected

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

Member Function Documentation

◆ iter()

auto regina::NormalHypersurfaces::__iter__ ( ) const

Returns a Python iterator over the normal hypersurfaces in this list.

In Python, a normal hypersurface list can be treated as an iterable object:

list = NormalHypersurfaces(...)
for s in list:
    ...

C++: Not present. For C++ users, NormalHypersurfaces provides the usual begin() and end() functions instead. In particular, you can iterate over the normal hypersurfaces in this list in the usual way using a range-based for loop.

Returns: an iterator over the normal hypersurfaces in this list.

◆ algorithm()

HyperAlg regina::NormalHypersurfaces::algorithm ( ) const

inline

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

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

Returns: details of the algorithm used to enumerate this list.

◆ allowsNonCompact()

bool regina::NormalHypersurfaces::allowsNonCompact ( ) const

inline

Determines if the coordinate system that was used for enumeration allows for non-compact hypersurfaces.

This does not test whether any of the hypersurfaces in this list are actually non-compact; it simply returns a basic property of the coordinate system that was used for enumeration.

Returns: true if and only if non-compact normal hypersurfaces are supported.

◆ anonID()

std::string regina::PacketData< NormalHypersurfaces >::anonID

inherited

A unique string ID that can be used in place of a packet ID.

This is an alternative to Packet::internalID(), and is designed for use when Held is not actually wrapped by a PacketOf<Held>. (An example of such a scenario is when a normal surface list needs to write its triangulation to file, but the triangulation is a standalone object that is not stored in a packet.)

The ID that is returned will:

remain fixed throughout the lifetime of the program for a given object, even if the contents of the object are changed;
not clash with the anonID() returned from any other object, or with the internalID() returned from any packet of any type;

These IDs are not preserved when copying or moving one object to another, and are not preserved when writing to a Regina data file and then reloading the file contents.

Warning: If this object is wrapped in a PacketOf<Held>, then anonID() and Packet::internalID() may return different values.

See Packet::internalID() for further details.

Returns: a unique ID that identifies this object.

◆ begin()

auto regina::NormalHypersurfaces::begin ( ) const

inline

Returns a C++ iterator at the beginning of this list of hypersurfaces.

These begin() and end() functions allow you to iterate through all hypersurfaces in this list using a range-based for loop:

NormalHypersurfaces list(...);

for (const NormalHypersurface& s : list) { ... }

regina::NormalHypersurfaces::NormalHypersurfaces

NormalHypersurfaces(const Triangulation< 4 > &triangulation, HyperCoords coords, HyperList which=HS_LIST_DEFAULT, HyperAlg algHints=HS_ALG_DEFAULT, ProgressTracker *tracker=nullptr)

A unified constructor for enumerating various classes of normal hypersurfaces within a given triangul...

Definition: normalhypersurfaces.h:1011

The type that is returned will be a lightweight iterator type, guaranteed to satisfy the C++ LegacyRandomAccessIterator requirement. The precise C++ type of the iterator is subject to change, so C++ users should use auto (just like this declaration does).

Python: Not present. For Python users, NormalHypersurfaces implements the Python iterable interface. You can iterate over the normal hypersurfaces in this list in the same way that you would iterate over any native Python container.

Returns: an iterator at the beginning of this list.

◆ beginVectors()

NormalHypersurfaces::VectorIterator regina::NormalHypersurfaces::beginVectors ( ) const

inline

A C++ iterator that gives access to the raw vectors for hypersurfaces in this list, pointing to the beginning of this hypersurface list.

Python: Not present. Use vectors() instead, which returns an iterable object for iterating over these same raw vectors.

Returns: an iterator at the beginning of this hypersurface list.

◆ coords()

HyperCoords regina::NormalHypersurfaces::coords ( ) const

inline

Returns the coordinate system that was originally used to enumerate the hypersurfaces in this list.

Returns: the coordinate system used.

◆ detail()

std::string regina::Output< NormalHypersurfaces , false >::detail ( ) const

inherited

Returns a detailed text representation of this object.

This text may span many lines, and should provide the user with all the information they could want. It should be human-readable, should not contain extremely long lines (which cause problems for users reading the output in a terminal), and should end with a final newline. There are no restrictions on the underlying character set.

Returns: a detailed text representation of this object.

◆ end()

auto regina::NormalHypersurfaces::end ( ) const

inline

Returns a C++ iterator beyond the end of this list of hypersurfaces.

These begin() and end() routines allow you to iterate through all hypersurfaces in this list using a range-based for loop. See the begin() documentation for further details.

Python: Not present. For Python users, NormalHypersurfaces implements the Python iterable interface. You can iterate over the normal hypersurfaces in this list in the same way that you would iterate over any native Python container.

Returns: an iterator beyond the end of this list.

◆ endVectors()

NormalHypersurfaces::VectorIterator regina::NormalHypersurfaces::endVectors ( ) const

inline

A C++ iterator that gives access to the raw vectors for hypersurfaces in this list, pointing past the end of this hypersurface list.

This iterator is not dereferenceable.

Python: Not present. Use vectors() instead, which returns an iterable object for iterating over these same raw vectors.

Returns: an iterator past the end of this hypersurface list.

◆ hypersurface()

const NormalHypersurface & regina::NormalHypersurfaces::hypersurface ( size_t index ) const

inline

Returns the hypersurface at the requested index in this list.

This is identical to using the square bracket operator.

Parameters

index the index of the requested hypersurface in this list; this must be between 0 and size()-1 inclusive.

Returns: the normal hypersurface at the requested index in this list.

◆ isEmbeddedOnly()

bool regina::NormalHypersurfaces::isEmbeddedOnly ( ) const

inline

Returns whether this list is known to contain only embedded normal hypersurfaces.

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

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

◆ operator!=()

bool regina::NormalHypersurfaces::operator!= ( const NormalHypersurfaces & other ) const

inline

Determines whether this and the given list contain different sets of normal hypersurfaces.

The lists will be compared as multisets: the order of the hypersurfaces in each list does not matter; however, in the unusual scenario where a list the same hypersurface multiple times, multiplicity does matter.

Like the comparison operators for NormalHypersurface, it does not matter whether the lists work with different triangulations, or different encodings, or if one but not the other supports non-compact hypersurfaces. The individual hypersurfaces will simply be compared by examining or computing the number of normal pieces of each type.

In particular, this routine is safe to call even if this and the given list work with different triangulations:

If the two triangulations have the same size, then this routine will compare hypersurfaces as though they were transplanted into the same triangulation using the same pentachoron numbering and the same normal piece types.
If the two triangulations have different sizes, then this comparison will return true (i.e., the lists will be considered different).

Parameters

other the list to be compared with this list.

Returns: true if both lists do not represent the same multiset of normal hypersurfaces, or false if they do.

◆ operator=() [1/2]

NormalHypersurfaces & regina::NormalHypersurfaces::operator= ( const NormalHypersurfaces & src )

inline

Sets this to be a (deep) copy of the given list.

Parameters

src	the list to copy.

Returns: a reference to this list.

◆ operator=() [2/2]

NormalHypersurfaces & regina::NormalHypersurfaces::operator= ( NormalHypersurfaces && src )

inline

Moves the contents of the given list into this list.

This is a fast (constant time) operation.

The list that is passed (src) will no longer be usable.

Note: This operator is not marked noexcept, since it fires change events on this list which may in turn call arbitrary code via any registered packet listeners. It deliberately does not fire change events on src, since it assumes that src is about to be destroyed (which will fire a destruction event instead).

Parameters

src	the list to move.

Returns: a reference to this list.

◆ operator==()

bool regina::NormalHypersurfaces::operator== ( const NormalHypersurfaces & other ) const

Determines whether this and the given list contain the same set of normal hypersurfaces.

The lists will be compared as multisets: the order of the hypersurfaces in each list does not matter; however, in the unusual scenario where a list the same hypersurface multiple times, multiplicity does matter.

Like the comparison operators for NormalHypersurface, it does not matter whether the lists work with different triangulations, or different encodings, or if one but not the other supports non-compact hypersurfaces. The individual hypersurfaces will simply be compared by examining or computing the number of normal pieces of each type.

In particular, this routine is safe to call even if this and the given list work with different triangulations:

If the two triangulations have the same size, then this routine will compare hypersurfaces as though they were transplanted into the same triangulation using the same pentachoron numbering and the same normal piece types.
If the two triangulations have different sizes, then this comparison will return false.

Parameters

other the list to be compared with this list.

Returns: true if both lists represent the same multiset of normal hypersurfaces, or false if not.

◆ operator[]()

const NormalHypersurface & regina::NormalHypersurfaces::operator[] ( size_t index ) const

inline

Returns the hypersurface at the requested index in this list.

This is identical to calling hypersurface().

Parameters

index the index of the requested hypersurface in this list; this must be between 0 and size()-1 inclusive.

Returns: the normal hypersurface at the requested index in this list.

◆ packet() [1/2]

std::shared_ptr< PacketOf< NormalHypersurfaces > > regina::PacketData< NormalHypersurfaces >::packet ( )

inlineinherited

Returns the packet that holds this data, if there is one.

If this object is being held by a packet p of type PacketOf<Held>, then that packet p will be returned. Otherwise, if this is a "standalone" object of type Held, then this routine will return null.

There is a special case when dealing with a packet q that holds a SnapPea triangulation. Here q is of type PacketOf<SnapPeaTriangulation>, and it holds a Triangulation<3> "indirectly" in the sense that Packetof<SnapPeaTriangulation> derives from SnapPeaTriangulation, which in turn derives from Triangulation<3>. In this scenario:

calling Triangulation<3>::packet() will return null, since there is no "direct" PacketOf<Triangulation<3>>;
calling SnapPeaTriangulation::packet() will return the enclosing packet q, since there is a PacketOf<SnapPeaTriangulation>;
calling the special routine Triangulation<3>::inAnyPacket() will also return the "indirect" enclosing packet q.

The function inAnyPacket() is specific to Triangulation<3>, and is not offered for other Held types.

Returns: the packet that holds this data, or null if this data is not (directly) held by a packet.

◆ packet() [2/2]

std::shared_ptr< const PacketOf< NormalHypersurfaces > > regina::PacketData< NormalHypersurfaces >::packet ( ) const

inlineinherited

Returns the packet that holds this data, if there is one.

See the non-const version of this function for further details, and in particular for how this functions operations in the special case of a packet that holds a SnapPea triangulation.

Returns: the packet that holds this data, or null if this data is not (directly) held by a packet.

◆ recreateMatchingEquations()

MatrixInt regina::NormalHypersurfaces::recreateMatchingEquations ( ) const

inline

Returns the matching equations that were used to create this normal hypersurface list.

This matrix is not cached: 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() throws an exception (because the triangulation is not supported by the chosen coordinate system). However, this routine will always succeed, because if makeMatchingEquations() had failed then this normal hypersurface list would not have been created in the first place.

Returns: the matching equations used to create this normal hypersurface list.

◆ size()

size_t regina::NormalHypersurfaces::size ( ) const

inline

Returns the number of hypersurfaces stored in this list.

Python: This is also used to implement the Python special method len().

Returns: the number of hypersurfaces.

◆ sort()

template<typename Comparison >

void regina::NormalHypersurfaces::sort ( Comparison && comp )

inline

Sorts the hypersurfaces in this list according to the given criterion.

This sort is stable, i.e., hypersurfaces that are equivalent under the given criterion will remain in the same relative order.

The implementation of this routine uses std::stable_sort.

Python: This is available in Python, and comp may be a pure Python function.

Parameters

comp	a binary function (or other callable object) that accepts two const HyperSurface references, and returns `true` if and only if the first hypersurface should appear before the second in the sorted list.

◆ str()

std::string regina::Output< NormalHypersurfaces , false >::str ( ) const

inherited

Returns a short text representation of this object.

This text should be human-readable, should use plain ASCII characters where possible, and should not contain any newlines.

Within these limits, this short text ouptut should be as information-rich as possible, since in most cases this forms the basis for the Python __str__() and __repr__() functions.

Python: The Python "stringification" function __str__() will use precisely this function, and for most classes the Python __repr__() function will incorporate this into its output.

Returns: a short text representation of this object.

◆ swap()

void regina::NormalHypersurfaces::swap ( NormalHypersurfaces & other )

Swaps the contents of this and the given list.

This routine will behave correctly if other is in fact this list.

Note: This swap function is not marked noexcept, since it fires change events on both lists which may in turn call arbitrary code via any registered packet listeners.

Parameters

other the list whose contents should be swapped with this.

◆ triangulation()

const Triangulation< 4 > & regina::NormalHypersurfaces::triangulation ( ) const

inline

Returns the triangulation in which these normal hypersurfaces live.

This will be a snapshot frozen in time of the triangulation that was originally passed to the NormalHypersurfaces constructor.

This will return a correct result even if the original triangulation has since been modified or destroyed. However, in order to ensure this behaviour, it is possible that at different points in time this function may return references to different C++ objects.

The rules for using the triangulation() reference are:

Do not keep the resulting reference as a long-term reference or pointer of your own, since in time you may find yourself referring to the wrong object (see above). Just call this function again.
You must respect the read-only nature of the result (i.e., you must not cast the constness away). The snapshotting process detects modifications, and modifying the frozen snapshot may result in an exception being thrown.

Warning: As of Regina 7.0, you cannot access this triangulation via the packet tree as Packet::parent(). This is because normal hypersurface lists can now be kept anywhere in the packet tree, or can be kept as standalone objects outside the packet tree entirely.

Returns: a reference to the underlying triangulation.

◆ utf8()

std::string regina::Output< NormalHypersurfaces , false >::utf8 ( ) const

inherited

Returns a short text representation of this object using unicode characters.

Like str(), this text should be human-readable, should not contain any newlines, and (within these constraints) should be as information-rich as is reasonable.

Unlike str(), this function may use unicode characters to make the output more pleasant to read. The string that is returned will be encoded in UTF-8.

Returns: a short text representation of this object.

◆ vectors()

auto regina::NormalHypersurfaces::vectors ( ) const

Returns a Python iterable object that iterates over the raw vectors for all hypersurfaces in this list.

For example:

list = NormalHypersurfaces(...)
for v in list.vectors():
    ...

C++: Not present. For C++ users, NormalHypersurfaces provides beginVectors() and endVectors() instead, which together define an iterator range over these same raw vectors.

Returns: an iterator over the normal hypersurfaces in this list.

◆ which()

HyperList regina::NormalHypersurfaces::which ( ) const

inline

Returns details of which normal hypersurfaces this list represents within the underlying triangulation.

This may not be the same HyperList that was passed to the class constructor. In particular, default values will have been explicitly filled in (such as HS_VERTEX and/or HS_EMBEDDED_ONLY), and invalid and/or redundant values will have been removed.

Returns: details of what this list represents.

◆ writeTextLong()

void regina::NormalHypersurfaces::writeTextLong ( std::ostream & out ) const

Writes a detailed text representation of this object to the given output stream.

Python: Not present. Use detail() instead.

Parameters

out	the output stream to which to write.

◆ writeTextShort()

void regina::NormalHypersurfaces::writeTextShort ( std::ostream & out ) const

Writes a short text representation of this object to the given output stream.

Python: Not present. Use str() instead.

Parameters

out	the output stream to which to write.

Member Data Documentation

◆ algorithm_

HyperAlg regina::NormalHypersurfaces::algorithm_

protected

Stores the details of the enumeration algorithm that was used to generate this list.

This might not be the same as the algorithmHints flag that was originally passed to the enumeration routine (e.g., if invalid or inappropriate flags were passed).

◆ coords_

HyperCoords regina::NormalHypersurfaces::coords_

protected

The coordinate system that was originally used to enumerate the normal hypersurfaces in this list.

◆ heldBy_

PacketHeldBy regina::PacketData< NormalHypersurfaces >::heldBy_

protectedinherited

Indicates whether this Held object is in fact the inherited data for a PacketOf<Held>.

As a special case, this field is also used to indicate when a Triangulation<3> is in fact the inherited data for a SnapPeaTriangulation. See the PacketHeldBy enumeration for more details on the different values that this data member can take.

◆ surfaces_

std::vector<NormalHypersurface> regina::NormalHypersurfaces::surfaces_

protected

Contains all normal hypersurfaces in this list.

◆ triangulation_

SnapshotRef<Triangulation<4> > regina::NormalHypersurfaces::triangulation_

protected

The triangulation in which these normal hypersurfaces lie.

◆ which_

HyperList regina::NormalHypersurfaces::which_

protected

Indicates which normal hypersurfaces these represent within the underlying triangulation.

The documentation for this class was generated from the following file:

hypersurface/normalhypersurfaces.h

Classes

Public Member Functions

Protected Member Functions

Protected Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ NormalHypersurfaces() [1/5]

◆ NormalHypersurfaces() [2/5]

◆ NormalHypersurfaces() [3/5]

◆ NormalHypersurfaces() [4/5]

◆ NormalHypersurfaces() [5/5]

Member Function Documentation

◆ __iter__()

◆ algorithm()

◆ allowsNonCompact()

◆ anonID()

◆ begin()

◆ beginVectors()

◆ coords()

◆ detail()

◆ end()

◆ endVectors()

◆ hypersurface()

◆ isEmbeddedOnly()

◆ operator!=()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ operator==()

◆ operator[]()

◆ packet() [1/2]

◆ packet() [2/2]

◆ recreateMatchingEquations()

◆ size()

◆ sort()

◆ str()

◆ swap()

◆ triangulation()

◆ utf8()

◆ vectors()

◆ which()

◆ writeTextLong()

◆ writeTextShort()

Member Data Documentation

◆ algorithm_

◆ coords_

◆ heldBy_

◆ surfaces_

◆ triangulation_

◆ which_

◆ iter()