Represents a saturated block in a Seifert fibred space. More...

#include <subcomplex/satblock.h>

Inheritance diagram for regina::SatBlock:

Public Types
using	TetList = std::set< const Tetrahedron< 3 > * >
	The data structure used to store a list of tetrahedra that should not be examined when searching for saturated blocks. More...

Public Member Functions
virtual	~SatBlock ()
	Destroys all internal arrays. More...

size_t	countAnnuli () const
	Returns the number of annuli on the boundary of this saturated block. More...

const SatAnnulus &	annulus (size_t which) const
	Returns details of the requested annulus on the boundary of this saturated block. More...

bool	twistedBoundary () const
	Is the ring of boundary annuli twisted to form a long Mobius strip? More...

bool	hasAdjacentBlock (size_t whichAnnulus) const
	Returns whether there is another saturated block listed as being adjacent to the given boundary annulus of this block. More...

const SatBlock *	adjacentBlock (size_t whichAnnulus) const
	Returns the saturated block listed as being adjacent to the given boundary annulus of this block. More...

size_t	adjacentAnnulus (size_t whichAnnulus) const
	Returns which specific annulus of the adjacent block is listed as being adjacent to the given boundary annulus of this block. More...

bool	adjacentReflected (size_t whichAnnulus) const
	Returns whether the adjacency along the given boundary annulus of this block is reflected. More...

bool	adjacentBackwards (size_t whichAnnulus) const
	Returns whether the adjacency along the given boundary annulus of this block is backwards. More...

virtual void	adjustSFS (SFSpace &sfs, bool reflect) const =0
	Adjusts the given Seifert fibred space to insert the contents of this saturated block. More...

std::tuple< const SatBlock *, size_t, bool, bool >	nextBoundaryAnnulus (size_t thisAnnulus, bool followPrev) const
	Finds the next (or previous) boundary annulus around from this, treating all adjacent blocks as part of a single large saturated region. More...

std::string	abbr (bool tex=false) const
	Returns an abbreviated name or symbol for this block. More...

virtual void	writeAbbr (std::ostream &out, bool tex=false) const =0
	Writes an abbreviated name or symbol for this block to the given output stream. More...

bool	operator< (const SatBlock &compare) const
	Implements a consistent ordering of saturated blocks. More...

virtual bool	operator== (const SatBlock &other) const =0
	Determines whether this and the given object represent saturated blocks of the same type with the same combinatorial parameters. More...

bool	operator!= (const SatBlock &other) const
	Determines whether this and the given object do not represent saturated blocks of the same type with the same combinatorial parameters. More...

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

SatBlock &	operator= (const SatBlock &)=delete

void	writeTextLong (std::ostream &out) const
	A default implementation for detailed output. 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
	SatBlock (size_t nAnnuli, bool twistedBoundary=false)
	Constructor for a block with the given number of annuli on the boundary. More...

	SatBlock (const SatBlock &cloneMe)
	Creates a new clone of the given block. More...

virtual SatBlock *	clone () const =0
	Returns a newly created clone of this saturated block structure. More...

bool	identicalBoundary (const SatBlock &other) const
	Determines whether this and the given block have identical boundaries. More...

SatBlockModel	modelWith (Triangulation< 3 > *triangulation)
	Returns a new model that combines this block structure with the given triangulation. More...

virtual void	transform (const Triangulation< 3 > &originalTri, const Isomorphism< 3 > &iso, const Triangulation< 3 > &newTri)
	Adjusts the structure of this block according to the given isomorphism between triangulations. More...

Static Protected Member Functions
static bool	isBad (const Tetrahedron< 3 > *t, const TetList &list)
	Determines whether the given tetrahedron is contained within the given list. More...

template<class List >
static bool	isBad (const Tetrahedron< 3 > *t, const List &list)
	Determines whether the given tetrahedron is contained within the given list. More...

static bool	notUnique (const Tetrahedron< 3 > *test)
	Determines whether the given tetrahedron pointer is null. More...

static bool	notUnique (const Tetrahedron< 3 > test, const Tetrahedron< 3 > other1)
	Determines whether the given tetrahedron pointer is null or equal to another from the given list. More...

static bool	notUnique (const Tetrahedron< 3 > test, const Tetrahedron< 3 > other1, const Tetrahedron< 3 > *other2)
	Determines whether the given tetrahedron pointer is null or equal to another from the given list. More...

static bool	notUnique (const Tetrahedron< 3 > test, const Tetrahedron< 3 > other1, const Tetrahedron< 3 > other2, const Tetrahedron< 3 > other3)
	Determines whether the given tetrahedron pointer is null or equal to another from the given list. More...

static bool	notUnique (const Tetrahedron< 3 > test, const Tetrahedron< 3 > other1, const Tetrahedron< 3 > other2, const Tetrahedron< 3 > other3, const Tetrahedron< 3 > *other4)
	Determines whether the given tetrahedron pointer is null or equal to another from the given list. More...

Protected Attributes
size_t	nAnnuli_
	The number of boundary annuli. More...

SatAnnulus *	annulus_
	Details of each boundary annulus, as seen from the inside of this saturated block. More...

bool	twistedBoundary_
	Is the ring of boundary annuli twisted to form a Mobius band? More...

SatBlock **	adjBlock_
	The saturated block joined to each boundary annulus; this may be null if there is no adjacency or if this information is not known. More...

size_t *	adjAnnulus_
	Describes which specific annulus of the adjacent saturated block is joined to each boundary annulus of this block. More...

bool *	adjReflected_
	Describes whether the adjacency for each boundary annulus is reflected (see the class notes above). More...

bool *	adjBackwards_
	Describes whether the adjacency for each boundary annulus is backwards (see the class notes above). More...

Friends
class	SatBlockModel

class	SatRegion

Detailed Description

Represents a saturated block in a Seifert fibred space.

A saturated block is a connected set of tetrahedra built from a subset of fibres (no fibres may enter or exit the boundary of the block). In addition, the boundary of this block must be a ring of saturated annuli, as described by the SatAnnulus class. Aside from this ring of saturated annuli, there may be no other boundary triangles within the block.

The boundary annuli are numbered consecutively as illustrated below, where the markings 0 and 1 within the triangles represent the first and second triangle of each annulus (see the SatAnnulus class notes for details). Note that the following diagram is viewed from inside the block.

              -+---+---+---+---+---+---+-
               |0 /|0 /|0 /|0 /|0 /|0 /|
           ... | / | / | / | / | / | / | ...
               |/ 1|/ 1|/ 1|/ 1|/ 1|/ 1|
              -+---+---+---+---+---+---+-
Annulus #  ...  n-2 n-1  0   1   2   3   ...

The ring of boundary annuli may optionally be twisted, so that together the annuli form a long Mobius band. In this case, for the purposes of labelling and marking annuli, the twist occurs between annuli n-1 and 0. Be careful when dealing with blocks with twisted boundaries, since with twists it is possible to identify an edge with itself in reverse (thus producing something that is not a 3-manifold triangulation).

Each saturated block corresponds to a piece of the base orbifold of the larger Seifert fibred space. For the purpose of connecting the base orbifold together, we assume that the boundary of this particular piece runs horizontally in the diagram above (specifically following the horizontal edges of the boundary annuli, as described in the SatAnnulus class notes). Insisting on such a boundary may lead to (1,k) twists within the block; these are accounted for by the virtual adjustSFS() routine.

Saturated blocks are generally joined to one another (or themselves) along their boundary annuli. For this purpose, each saturated block contains a list of which annulus of this block is adjacent to which annulus of which other block. Adjacencies may be reflected, meaning that the adjacent annulus has its fibres reversed (i.e., the adjacent annulus has undergone an up-to-down reflection); they may also be backwards, meaning that the first triangle of one annulus is joined to the second triangle of the other (and vice versa).

This is an abstract base class: its subclasses correspond to different combinatorial constructions (or in some cases, parameterised families of constructions). Each subclass of SatBlock:

must override all pure virtual functions (of course);
should override transform() if the subclass contains additional data that needs to be altered when an isomorphism is applied;
should not override writeTextLong(), since SatBlock uses short output only.

SatBlock does not support value semantics: blocks cannot be copied, swapped, or manually constructed. Their memory is managed by the SatRegion class (or in special cases the SatBlockModel class), and their locations in memory define them. See SatRegion for further details.

Member Typedef Documentation

◆ TetList

using regina::SatBlock::TetList = std::set<const Tetrahedron<3>*>

The data structure used to store a list of tetrahedra that should not be examined when searching for saturated blocks.

Constructor & Destructor Documentation

◆ ~SatBlock()

regina::SatBlock::~SatBlock ( )

inlinevirtual

Destroys all internal arrays.

Note that any adjacent blocks that are referenced by the adjBlock array will not be destroyed.

◆ SatBlock() [1/2]

regina::SatBlock::SatBlock	(	size_t	nAnnuli,
		bool	twistedBoundary = `false`
	)

inlineprotected

Constructor for a block with the given number of annuli on the boundary.

All arrays will be constructed but their contents will remain uninitialised, with the exception that the adjBlock array will be filled with null pointers.

Parameters

nAnnuli	the number of annuli on the boundary of this block; this must be strictly positive.
twistedBoundary	`true` if the ring of boundary annuli is twisted to form a long Mobius band, or `false` (the default) if it is not.

◆ SatBlock() [2/2]

regina::SatBlock::SatBlock ( const SatBlock & cloneMe )

protected

Creates a new clone of the given block.

Note that the new adjBlock_ array will contain pointers to the same adjacent blocks as the original. That is, adjacent blocks will not be cloned also; instead pointers to adjacent blocks will simply be copied across.

Parameters

cloneMe the saturated block to clone.

Member Function Documentation

◆ abbr()

std::string regina::SatBlock::abbr ( bool tex = false ) const

Returns an abbreviated name or symbol for this block.

This name will reflect the particular block type, but may not provide thorough details.

The name will be no more than a handful of characters long, and will not include a newline (or surrounding dollar signs in TeX mode).

Parameters

tex	`true` if the name should be formatted for TeX, or `false` if it should be in plain text format.

Returns: an abbreviated name for this block.

◆ adjacentAnnulus()

size_t regina::SatBlock::adjacentAnnulus ( size_t whichAnnulus ) const

inline

Returns which specific annulus of the adjacent block is listed as being adjacent to the given boundary annulus of this block.

Precondition: The given annulus of this block actually has an adjacent block listed.

Parameters

whichAnnulus indicates which boundary annulus of this block should be examined; this must be between 0 and countAnnuli()-1 inclusive.

Returns: the corresponding annulus number on the other block that is adjacent along this annulus.

◆ adjacentBackwards()

bool regina::SatBlock::adjacentBackwards ( size_t whichAnnulus ) const

inline

Returns whether the adjacency along the given boundary annulus of this block is backwards.

See the class notes for a discussion of backwards adjacencies.

Precondition: The given annulus of this block actually has an adjacent block listed.

Parameters

whichAnnulus indicates which boundary annulus of this block should be examined; this must be between 0 and countAnnuli()-1 inclusive.

Returns: true if the corresponding adjacency is backwards, or false if it is not.

◆ adjacentBlock()

const SatBlock * regina::SatBlock::adjacentBlock ( size_t whichAnnulus ) const

inline

Returns the saturated block listed as being adjacent to the given boundary annulus of this block.

Parameters

whichAnnulus indicates which boundary annulus of this block should be examined; this must be between 0 and countAnnuli()-1 inclusive.

Returns: the other block adjacent along this annulus, or null if there is no adjacent block listed.

◆ adjacentReflected()

bool regina::SatBlock::adjacentReflected ( size_t whichAnnulus ) const

inline

Returns whether the adjacency along the given boundary annulus of this block is reflected.

See the class notes for a discussion of reflected adjacencies.

Precondition: The given annulus of this block actually has an adjacent block listed.

Parameters

whichAnnulus indicates which boundary annulus of this block should be examined; this must be between 0 and countAnnuli()-1 inclusive.

Returns: true if the corresponding adjacency is reflected, or false if it is not.

◆ adjustSFS()

virtual void regina::SatBlock::adjustSFS	(	SFSpace &	sfs,
		bool	reflect
	)		const

pure virtual

Adjusts the given Seifert fibred space to insert the contents of this saturated block.

In particular, the space should be adjusted as though an ordinary solid torus (base orbifold a disc, no twists or exceptional fibres) had been replaced by this block. This description does not make sense for blocks with twisted boundary; the twisted case is discussed below.

If the argument reflect is true, it should be assumed that this saturated block is being reflected before being inserted into the larger Seifert fibred space. That is, any twists or exceptional fibres should be negated before being added.

Regarding the signs of exceptional fibres: Consider a saturated block containing a solid torus whose meridinal curve runs p times horizontally around the boundary in order through annuli 0,1,... and follows the fibres q times from bottom to top (as depicted in the diagram in the SatBlock class notes). Then this saturated block adds a positive (p, q) fibre to the underlying Seifert fibred space.

If the ring of saturated annuli bounding this block is twisted then the situation becomes more complex. It can be proven that such a block must contain a twisted reflector boundary in the base orbifold (use Z_2 homology with fibre-reversing paths to show that the base orbifold must contain another twisted boundary component, and then recall that real boundaries are not allowed inside blocks).

In this twisted boundary case, it should be assumed that the twisted reflector boundary is already stored in the given Seifert fibred space. This routine should make any further changes that are required (there may well be none). That is, the space should be adjusted as though a trivial Seifert fibred space over the annulus with one twisted reflector boundary (and one twisted puncture corresponding to the block boundary) had been replaced by this block. In particular, this routine should not add the reflector boundary itself.

Parameters

sfs	the Seifert fibred space to adjust.
reflect	`true` if this block is to be reflected, or `false` if it should be inserted directly.

Implemented in regina::SatMobius, regina::SatLST, regina::SatTriPrism, regina::SatCube, regina::SatReflectorStrip, and regina::SatLayering.

◆ annulus()

const SatAnnulus & regina::SatBlock::annulus ( size_t which ) const

inline

Returns details of the requested annulus on the boundary of this saturated block.

Annuli are numbered from 0 to countAnnuli()-1 as described in the class notes.

Parameters

which indicates which boundary annulus is requested; this must be between 0 and countAnnuli()-1 inclusive.

Returns: a reference to the requested boundary annulus.

◆ clone()

virtual SatBlock * regina::SatBlock::clone ( ) const

protectedpure virtual

Returns a newly created clone of this saturated block structure.

A clone of the correct subclass of SatBlock will be returned. For this reason, each subclass of SatBlock must implement this routine.

Returns: a new clone of this block.

Implemented in regina::SatMobius, regina::SatLST, regina::SatTriPrism, regina::SatCube, regina::SatReflectorStrip, and regina::SatLayering.

◆ countAnnuli()

size_t regina::SatBlock::countAnnuli ( ) const

inline

Returns the number of annuli on the boundary of this saturated block.

Returns: the number of boundary annuli.

◆ detail()

std::string regina::Output< SatBlock , supportsUtf8 >::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.

◆ hasAdjacentBlock()

bool regina::SatBlock::hasAdjacentBlock ( size_t whichAnnulus ) const

inline

Returns whether there is another saturated block listed as being adjacent to the given boundary annulus of this block.

Parameters

whichAnnulus indicates which boundary annulus of this block should be examined; this must be between 0 and countAnnuli()-1 inclusive.

Returns: true if the given boundary annulus has an adjacent block listed, or false otherwise.

◆ identicalBoundary()

bool regina::SatBlock::identicalBoundary ( const SatBlock & other ) const

inlineprotected

Determines whether this and the given block have identical boundaries.

This requires not just that both boundaries represent the same subcomplex of the underlying triangulation, but also that the boundaries use identical saturated annuli, and that these annuli appear in the same order.

Parameters

other the block to compare with this.

Returns: true if and only if this and the given block have identical boundaries, as described above.

◆ isBad() [1/2]

template<class List >

static bool regina::SatBlock::isBad	(	const Tetrahedron< 3 > *	t,
		const List &	list
	)

inlinestaticprotected

Determines whether the given tetrahedron is contained within the given list.

This is intended as a helper routine for isBlock() and related routines. It is a generic routine for working with arbitrary list types.

Precondition: Forward iterators of type List::const_iterator that span the given list can be obtained by calling list.begin() and list.end().

Parameters

t	the tetrahedron to search for.
list	the list in which to search.

Returns: true if and only if the given tetrahedron was found.

◆ isBad() [2/2]

static bool regina::SatBlock::isBad	(	const Tetrahedron< 3 > *	t,
		const TetList &	list
	)

staticprotected

Determines whether the given tetrahedron is contained within the given list.

This is intended as a helper routine for isBlock() and related routines.

Parameters

t	the tetrahedron to search for.
list	the list in which to search.

Returns: true if and only if the given tetrahedron was found.

◆ modelWith()

SatBlockModel regina::SatBlock::modelWith ( Triangulation< 3 > * triangulation )

inlineprotected

Returns a new model that combines this block structure with the given triangulation.

The new model will take ownership of both this block and the given triangulation.

The purpose of this routine is, essentially, to give subclasses access to the private SatBlockModel constructor (which SatBlock can access as a friend class, but which subclasses cannot).

Parameters

triangulation an explicit triangulation of this block structure.

Returns: a model that holds this block and the given triangulation.

◆ nextBoundaryAnnulus()

std::tuple< const SatBlock *, size_t, bool, bool > regina::SatBlock::nextBoundaryAnnulus	(	size_t	thisAnnulus,
		bool	followPrev
	)		const

Finds the next (or previous) boundary annulus around from this, treating all adjacent blocks as part of a single large saturated region.

Suppose that all saturated blocks are merged together according to adjacent boundary annuli, forming larger saturated structures. The remaining annuli that do not have adjacent blocks will group together to form several large boundary rings. Note that each boundary ring might involve annuli from several different blocks, and might or might not have a twist (thus forming a large Klein bottle instead of a large torus).

This routine is used to trace around such a boundary ring. It is assumed that annulus thisAnnulus of this block forms part of a boundary ring (i.e., it has no adjacent block). This routine will then return the next/previous annulus around from this in the large boundary ring. Here "next" means in the direction following from the second triangle of this annulus, and "previous" means in the direction following from the first triangle; the boolean argument followPrev controls which we will be used. This next/previous annulus might belong to another block, or it might even be this original annulus again.

The next/previous annulus itself is not returned, but rather a reference as to how it appears within its enclosing saturated block. Specifically, a block and corresponding annulus number will be included as the first two elements of the returned tuple.

It is possible that the next/previous annulus as it appears within the returned block is oriented differently from how it appears within this large boundary ring. For this reason, two booleans are returned also. The third element of the returned tuple will describe whether the annulus is reflected vertically as it appears within the large boundary ring (i.e., the first and second triangles remain the same but the fibre direction is reversed). Similarly, the fourth element of the tuple will describe whether the annulus is reflected horizontally as it appears within the large boundary ring (i.e., first and second triangles are switched but the fibre direction is unchanged).

It is possible that both a horizontal and vertical reflection take place. Note that any kind of reflection will also affect the locations of the 0/1/2 markings as described in the SatAnnulus class notes.

Finally, note that if the large boundary ring is twisted (i.e., it forms a Klein bottle), then following the entire boundary ring around using this routine will bring you back to the starting annulus but with the vertical reflection flag set.

Precondition: Annulus thisAnnulus of this block has no block adjacent to it.

Warning: If you wish to trace around an entire boundary ring, you will need to adjust the argument followPrev according to whether or not the current annulus is reflected horizontally (since, under a horizontal reflection, "next" becomes "previous" and vice versa).

Parameters

thisAnnulus	describes which original boundary annulus of this block to examine; this must be between 0 and countAnnuli()-1 inclusive.
followPrev	`true` if we should find the previous boundary annulus, or `false` if we should find the next boundary annulus.

Returns: a tuple (nextBlock, nextAnnulus, refVert, refHoriz), where: nextBlock is the block containing the next boundary annulus around from thisAnnulus; nextAnnulus is the specific annulus number within nextBlock of the next annulus around (between 0 and nextBlock->countAnnuli()-1 inclusive, and the corresponding annulus will have no block adjacent to it); refVert is true iff the next annulus around is vertically reflected; and refHoriz is true iff the next annulus around is horizontally reflected (see above for details on reflections).

◆ notUnique() [1/5]

bool regina::SatBlock::notUnique ( const Tetrahedron< 3 > * test )

inlinestaticprotected

Determines whether the given tetrahedron pointer is null.

This is intended as a helper routine for isBlock() and related routines. Despite its trivial implementation, it is provided to make long blocks of code easier to read and distinguish by functionality.

The name notUnique() may seem strang for what is essentially a nullity test; in fact this routine is offered as a degenerate case of other variants of notUnique() that take more tetrahedra as arguments.

Parameters

test	the tetrahedron pointer to test.

Returns: true if test is null, or false otherwise.

◆ notUnique() [2/5]

bool regina::SatBlock::notUnique	(	const Tetrahedron< 3 > *	test,
		const Tetrahedron< 3 > *	other1
	)

inlinestaticprotected

Determines whether the given tetrahedron pointer is null or equal to another from the given list.

This is intended as a helper routine for isBlock() and related routines. Despite its trivial implementation, it is provided to make long blocks of code easier to read and distinguish by functionality.

Parameters

test	the tetrahedron pointer to test.
other1	another tetrahedron that will be compared with test.

Returns: true if test is null or equal to other1, or false otherwise.

◆ notUnique() [3/5]

bool regina::SatBlock::notUnique	(	const Tetrahedron< 3 > *	test,
		const Tetrahedron< 3 > *	other1,
		const Tetrahedron< 3 > *	other2
	)

inlinestaticprotected

Determines whether the given tetrahedron pointer is null or equal to another from the given list.

This is intended as a helper routine for isBlock() and related routines. Despite its trivial implementation, it is provided to make long blocks of code easier to read and distinguish by functionality.

Parameters

test	the tetrahedron pointer to test.
other1	another tetrahedron that will be compared with test.
other2	another tetrahedron that will be compared with test.

Returns: true if test is null or equal to other1 or other2, or false otherwise.

◆ notUnique() [4/5]

bool regina::SatBlock::notUnique	(	const Tetrahedron< 3 > *	test,
		const Tetrahedron< 3 > *	other1,
		const Tetrahedron< 3 > *	other2,
		const Tetrahedron< 3 > *	other3
	)

inlinestaticprotected

Determines whether the given tetrahedron pointer is null or equal to another from the given list.

This is intended as a helper routine for isBlock() and related routines. Despite its trivial implementation, it is provided to make long blocks of code easier to read and distinguish by functionality.

Parameters

test	the tetrahedron pointer to test.
other1	another tetrahedron that will be compared with test.
other2	another tetrahedron that will be compared with test.
other3	another tetrahedron that will be compared with test.

Returns: true if test is null or equal to other1, other2 or other3, or false otherwise.

◆ notUnique() [5/5]

bool regina::SatBlock::notUnique	(	const Tetrahedron< 3 > *	test,
		const Tetrahedron< 3 > *	other1,
		const Tetrahedron< 3 > *	other2,
		const Tetrahedron< 3 > *	other3,
		const Tetrahedron< 3 > *	other4
	)

inlinestaticprotected

Determines whether the given tetrahedron pointer is null or equal to another from the given list.

This is intended as a helper routine for isBlock() and related routines. Despite its trivial implementation, it is provided to make long blocks of code easier to read and distinguish by functionality.

Parameters

test	the tetrahedron pointer to test.
other1	another tetrahedron that will be compared with test.
other2	another tetrahedron that will be compared with test.
other3	another tetrahedron that will be compared with test.
other4	another tetrahedron that will be compared with test.

Returns: true if test is null or equal to other1, other2, other3 or other4, or false otherwise.

◆ operator!=()

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

inline

Determines whether this and the given object do not represent saturated blocks of the same type with the same combinatorial parameters.

See the equality test operator==() for examples of what is meant by "the same combinatorial parameters".

Parameters

other the saturated block to compare with this.

Returns: true if and only if this and the given object do not represent blocks of the same type with the same parameters.

◆ operator<()

bool regina::SatBlock::operator< ( const SatBlock & compare ) const

Implements a consistent ordering of saturated blocks.

This ordering is purely aesthetic on the part of the author, and is subject to change in future versions of Regina.

Parameters

compare the saturated block with which this will be compared.

Returns: true if this block comes before the given block according to the ordering of saturated blocks, or false if either the blocks are identical or this block comes after the given block.

◆ operator==()

virtual bool regina::SatBlock::operator== ( const SatBlock & other ) const

pure virtual

Determines whether this and the given object represent saturated blocks of the same type with the same combinatorial parameters.

As examples of what is meant by "combinatorial parameters":

Any two SatCube objects will compare as equal, since there is only one combinatorial type of SatCube.
Two SatReflectorStrip objects will compare as equal if their rings of bounary annuli have the same length and are either both twisted or both untwisted.
Two SatLST objects will compare as equal if their internal layered solid tori have the same three integer parameters (identifying how the meridinal disc meets the three boundary edges), and their corresponding boundary edges are attached to the horizontal/vertical/diagonal edges of the boundary annulus in the same way.

Parameters

other the saturated block to compare with this.

Returns: true if and only if this and the given object represent blocks of the same type with the same parameters.

Implemented in regina::SatMobius, regina::SatLST, regina::SatTriPrism, regina::SatCube, regina::SatReflectorStrip, and regina::SatLayering.

◆ str()

std::string regina::Output< SatBlock , supportsUtf8 >::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.

◆ transform()

virtual void regina::SatBlock::transform	(	const Triangulation< 3 > &	originalTri,
		const Isomorphism< 3 > &	iso,
		const Triangulation< 3 > &	newTri
	)

protectedvirtual

Adjusts the structure of this block according to the given isomorphism between triangulations.

Any triangulation-specific information will be transformed accordingly (for instance, the routine SatAnnulus::transform() will be called for each boundary annulus).

Information regarding adjacent blocks will not be changed. Only structural information for this particular block will be updated.

The given isomorphism must describe a mapping from originalTri to newTri, and this block must currently refer to tetrahedra in originalTri. After this routine is called the block will instead refer to the corresponding tetrahedra in newTri (with changes in vertex/face numbering also accounted for).

Precondition: This block currently refers to tetrahedra in originalTri, and iso describes a mapping from originalTri to newTri.

Warning: Any subclasses of SatBlock that store additional triangulation-specific information will need to override this routine. When doing so, be sure to call SatBlock::transform() so that the generic changes defined here will still take place.

Parameters

originalTri	the triangulation currently used by this saturated block.
iso	the mapping from originalTri to newTri.
newTri	the triangulation to be used by the updated block structure.

Reimplemented in regina::SatLST.

◆ twistedBoundary()

bool regina::SatBlock::twistedBoundary ( ) const

inline

Is the ring of boundary annuli twisted to form a long Mobius strip?

Recall from the class notes that the twist occurs between boundary annuli countAnnuli()-1 and 0.

Returns: true if the ring of boundary annuli is twisted, or false if not.

◆ utf8()

std::string regina::Output< SatBlock , supportsUtf8 >::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.

◆ writeAbbr()

virtual void regina::SatBlock::writeAbbr	(	std::ostream &	out,
		bool	tex = `false`
	)		const

pure virtual

Writes an abbreviated name or symbol for this block to the given output stream.

This name should reflect the particular block type, but need not provide thorough details.

The output should be no more than a handful of characters long, and no newline should be written. In TeX mode, no leading or trailing dollar signs should be written.

Python: Not present. Instead use the variant abbr() that returns a string.

Parameters

out	the output stream to which to write.
tex	`true` if the output should be formatted for TeX, or `false` if it should be in plain text format.

Implemented in regina::SatMobius, regina::SatLST, regina::SatTriPrism, regina::SatCube, regina::SatReflectorStrip, and regina::SatLayering.

◆ writeTextLong()

void regina::ShortOutput< SatBlock , false >::writeTextLong ( std::ostream & out ) const

inlineinherited

A default implementation for detailed output.

This routine simply calls T::writeTextShort() and appends a final newline.

Python: Not present. Instead you can call detail() from the subclass T, which returns this output as a string.

Parameters

out	the output stream to which to write.

◆ writeTextShort()

virtual void regina::SatBlock::writeTextShort ( std::ostream & out ) const

pure virtual

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

This must be implemented by subclasses.

Python: Not present. Use str() instead.

Parameters

out	the output stream to which to write.

Implemented in regina::SatMobius, regina::SatLST, regina::SatTriPrism, regina::SatCube, regina::SatReflectorStrip, and regina::SatLayering.

Member Data Documentation

◆ adjAnnulus_

size_t* regina::SatBlock::adjAnnulus_

protected

Describes which specific annulus of the adjacent saturated block is joined to each boundary annulus of this block.

Values may be undefined if the corresponding entries in the adjBlock array is null.

◆ adjBackwards_

bool* regina::SatBlock::adjBackwards_

protected

Describes whether the adjacency for each boundary annulus is backwards (see the class notes above).

Values may be undefined if the corresponding entries in the adjBlock array is null.

◆ adjBlock_

SatBlock** regina::SatBlock::adjBlock_

protected

The saturated block joined to each boundary annulus; this may be null if there is no adjacency or if this information is not known.

◆ adjReflected_

bool* regina::SatBlock::adjReflected_

protected

Describes whether the adjacency for each boundary annulus is reflected (see the class notes above).

Values may be undefined if the corresponding entries in the adjBlock array is null.

◆ annulus_

SatAnnulus* regina::SatBlock::annulus_

protected

Details of each boundary annulus, as seen from the inside of this saturated block.

◆ nAnnuli_

size_t regina::SatBlock::nAnnuli_

protected

The number of boundary annuli.

◆ twistedBoundary_

bool regina::SatBlock::twistedBoundary_

protected

Is the ring of boundary annuli twisted to form a Mobius band?

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

subcomplex/satblock.h

Public Types

Public Member Functions

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ TetList

Constructor & Destructor Documentation

◆ ~SatBlock()

◆ SatBlock() [1/2]

◆ SatBlock() [2/2]

Member Function Documentation

◆ abbr()

◆ adjacentAnnulus()

◆ adjacentBackwards()

◆ adjacentBlock()

◆ adjacentReflected()

◆ adjustSFS()

◆ annulus()

◆ clone()

◆ countAnnuli()

◆ detail()

◆ hasAdjacentBlock()

◆ identicalBoundary()

◆ isBad() [1/2]

◆ isBad() [2/2]

◆ modelWith()

◆ nextBoundaryAnnulus()

◆ notUnique() [1/5]

◆ notUnique() [2/5]

◆ notUnique() [3/5]

◆ notUnique() [4/5]

◆ notUnique() [5/5]

◆ operator!=()

◆ operator<()

◆ operator==()

◆ str()

◆ transform()

◆ twistedBoundary()

◆ utf8()

◆ writeAbbr()

◆ writeTextLong()

◆ writeTextShort()

Member Data Documentation

◆ adjAnnulus_

◆ adjBackwards_

◆ adjBlock_

◆ adjReflected_

◆ annulus_

◆ nAnnuli_

◆ twistedBoundary_