Regina 7.3 Calculation Engine
Public Types | Public Member Functions | Protected Member Functions | Static Protected Member Functions | Protected Attributes | Friends | List of all members
regina::SatMobius Class Reference

A degenerate zero-tetrahedron saturated block that corresponds to attaching a Mobius band to a single annulus boundary. More...

#include <subcomplex/satblocktypes.h>

Inheritance diagram for regina::SatMobius:
regina::SatBlock regina::ShortOutput< SatBlock > regina::Output< SatBlock, false >

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

int position () const
 Describes how the Mobius band is attached to the boundary annulus. More...
 
bool operator== (const SatBlock &other) const override
 Determines whether this and the given object represent saturated blocks of the same type with the same combinatorial parameters. More...
 
void adjustSFS (SFSpace &sfs, bool reflect) const override
 Adjusts the given Seifert fibred space to insert the contents of this saturated block. More...
 
void writeTextShort (std::ostream &out) const override
 Writes a short text representation of this object to the given output stream. More...
 
void writeAbbr (std::ostream &out, bool tex=false) const override
 Writes an abbreviated name or symbol for this block to the given output stream. More...
 
size_t countAnnuli () const
 Returns the number of annuli on the boundary of this saturated block. More...
 
const SatAnnulusannulus (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 SatBlockadjacentBlock (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...
 
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...
 
bool operator< (const SatBlock &compare) const
 Implements a consistent ordering of saturated blocks. 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...
 
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

SatBlockclone () const override
 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...
 
SatAnnulusannulus_
 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 SatRegion
 

Detailed Description

A degenerate zero-tetrahedron saturated block that corresponds to attaching a Mobius band to a single annulus boundary.

This is a degenerate case of the layered solid torus (see the class SatLST), where instead of joining a solid torus to an annulus boundary we join a Mobius band. The Mobius band can be thought of as a zero-tetrahedron solid torus with two boundary triangles, which in fact are opposite sides of the same triangle. By attaching a zero-tetrahedron Mobius band to an annulus boundary, we are effectively joining the two triangles of the annulus together.

The meridinal disc of this zero-tetrahedron solid torus meets the three edges of the annulus in 1, 1 and 2 places, so it is in fact a degenerate (1,1,2) layered solid torus. Note that the weight 2 edge is the boundary edge of the Mobius strip.

This class does not support value semantics: it cannot be copied, swapped or manually constructed. Its memory is managed by the SatRegion class, and blocks' locations in memory define them. See SatRegion for further details.

Member Typedef Documentation

◆ TetList

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

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

Member Function Documentation

◆ abbr()

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

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
textrue 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
inlineinherited

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
whichAnnulusindicates 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
inlineinherited

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
whichAnnulusindicates 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
inlineinherited

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

Parameters
whichAnnulusindicates 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
inlineinherited

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

void regina::SatMobius::adjustSFS ( SFSpace sfs,
bool  reflect 
) const
overridevirtual

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
sfsthe Seifert fibred space to adjust.
reflecttrue if this block is to be reflected, or false if it should be inserted directly.

Implements regina::SatBlock.

◆ annulus()

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

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
whichindicates which boundary annulus is requested; this must be between 0 and countAnnuli()-1 inclusive.
Returns
a reference to the requested boundary annulus.

◆ clone()

SatBlock * regina::SatMobius::clone ( ) const
inlineoverrideprotectedvirtual

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.

Implements regina::SatBlock.

◆ countAnnuli()

size_t regina::SatBlock::countAnnuli ( ) const
inlineinherited

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
inlineinherited

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

Parameters
whichAnnulusindicates 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
inlineprotectedinherited

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
otherthe 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 
)
inlinestaticprotectedinherited

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
tthe tetrahedron to search for.
listthe 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 
)
staticprotectedinherited

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

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

Parameters
tthe tetrahedron to search for.
listthe list in which to search.
Returns
true if and only if the given tetrahedron was found.

◆ modelWith()

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

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
triangulationan 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
inherited

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
thisAnnulusdescribes which original boundary annulus of this block to examine; this must be between 0 and countAnnuli()-1 inclusive.
followPrevtrue 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)
inlinestaticprotectedinherited

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
testthe 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 
)
inlinestaticprotectedinherited

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
testthe tetrahedron pointer to test.
other1another 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 
)
inlinestaticprotectedinherited

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
testthe tetrahedron pointer to test.
other1another tetrahedron that will be compared with test.
other2another 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 
)
inlinestaticprotectedinherited

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
testthe tetrahedron pointer to test.
other1another tetrahedron that will be compared with test.
other2another tetrahedron that will be compared with test.
other3another 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 
)
inlinestaticprotectedinherited

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
testthe tetrahedron pointer to test.
other1another tetrahedron that will be compared with test.
other2another tetrahedron that will be compared with test.
other3another tetrahedron that will be compared with test.
other4another 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
inlineinherited

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
otherthe 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
inherited

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
comparethe 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==()

bool regina::SatMobius::operator== ( const SatBlock other) const
inlineoverridevirtual

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

Implements regina::SatBlock.

◆ position()

int regina::SatMobius::position ( ) const
inline

Describes how the Mobius band is attached to the boundary annulus.

The class notes discuss the weight two edge of the Mobius band (or equivalently the boundary edge of the Mobius band). The return value of this routine indicates which edge of the boundary annulus this weight two edge is joined to.

In the SatAnnulus class notes, the three edges of the annulus are denoted vertical, horizontal and boundary, and the vertices of each triangle are given markings 0, 1 and 2.

The return value of this routine takes the value 0, 1 or 2 as follows:

  • 0 means that the weight two edge is joined to the diagonal edge of the annulus (markings 1 and 2);
  • 1 means that the weight two edge is joined to the horizontal edge of the annulus (markings 0 and 2);
  • 2 means that the weight two edge is joined to the vertical edge of the annulus (markings 0 and 1).
Returns
the value 0, 1 or 2 as described above.

◆ 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 
)
protectedvirtualinherited

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
originalTrithe triangulation currently used by this saturated block.
isothe mapping from originalTri to newTri.
newTrithe triangulation to be used by the updated block structure.

Reimplemented in regina::SatLST.

◆ twistedBoundary()

bool regina::SatBlock::twistedBoundary ( ) const
inlineinherited

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

void regina::SatMobius::writeAbbr ( std::ostream &  out,
bool  tex = false 
) const
overridevirtual

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
outthe output stream to which to write.
textrue if the output should be formatted for TeX, or false if it should be in plain text format.

Implements regina::SatBlock.

◆ 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
outthe output stream to which to write.

◆ writeTextShort()

void regina::SatMobius::writeTextShort ( std::ostream &  out) const
overridevirtual

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
outthe output stream to which to write.

Implements regina::SatBlock.

Member Data Documentation

◆ adjAnnulus_

size_t* regina::SatBlock::adjAnnulus_
protectedinherited

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

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

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

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

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

◆ nAnnuli_

size_t regina::SatBlock::nAnnuli_
protectedinherited

The number of boundary annuli.

◆ twistedBoundary_

bool regina::SatBlock::twistedBoundary_
protectedinherited

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


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

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