regina::SatCube Class Reference
Standard Triangulations and Subcomplexes

A saturated block that is a six-tetrahedron cube. More...

`#include <subcomplex/satblocktypes.h>`

Inheritance diagram for regina::SatCube:

## Public Types

typedef std::set< Tetrahedron< 3 > * > | TetList
| The data structure used to store a list of tetrahedra that should not be examined by isBlock(). More...

## Public Member Functions

| SatCube (const SatCube &cloneMe)
| Constructs a clone of the given block structure. More...
virtual SatBlock * | clone () const
| Returns a newly created clone of this saturated block structure. More...
virtual void | adjustSFS (SFSpace &sfs, bool reflect) const
| Adjusts the given Seifert fibred space to insert the contents of this saturated block. More...
virtual void | writeTextShort (std::ostream &out) const
| Writes a short text representation of this object to the given output stream. More...
virtual void | writeAbbr (std::ostream &out, bool tex=false) const
| Writes an abbreviated name or symbol for this block to the given output stream. More...
unsigned | nAnnuli () const
| Returns the number of annuli on the boundary of this saturated block. More...
const SatAnnulus & | annulus (unsigned 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 (unsigned whichAnnulus) const
| Returns whether there is another saturated block listed as being adjacent to the given boundary annulus of this block. More...
SatBlock * | adjacentBlock (unsigned whichAnnulus) const
| Returns the saturated block listed as being adjacent to the given boundary annulus of this block. More...
unsigned | adjacentAnnulus (unsigned 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 (unsigned whichAnnulus) const
| Returns whether the adjacency along the given boundary annulus of this block is reflected. More...
bool | adjacentBackwards (unsigned whichAnnulus) const
| Returns whether the adjacency along the given boundary annulus of this block is backwards. More...
void | setAdjacent (unsigned whichAnnulus, SatBlock *adjBlock, unsigned adjAnnulus, bool adjReflected, bool adjBackwards)
| Lists the given saturated block as being adjacent to the given boundary annulus of this block. More...
virtual void | transform (const Triangulation< 3 > *originalTri, const Isomorphism< 3 > *iso, Triangulation< 3 > *newTri)
| Adjusts the structure of this block according to the given isomorphism between triangulations. More...
void | nextBoundaryAnnulus (unsigned thisAnnulus, SatBlock *&nextBlock, unsigned &nextAnnulus, bool &refVert, bool &refHoriz, bool followPrev)
| 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...
virtual void | writeTextLong (std::ostream &out) const
| Writes a detailed text representation of this object to the given output stream. 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...

## Static Public Member Functions

static SatCube * | isBlockCube (const SatAnnulus &annulus, TetList &avoidTets)
| Determines whether the given annulus is a boundary annulus for a block of this type (cube). More...
static SatCube * | insertBlock (Triangulation< 3 > &tri)
| Inserts a new copy of a cube block into the given triangulation, and returns the corresponding block structure. More...
static SatBlock * | isBlock (const SatAnnulus &annulus, TetList &avoidTets)
| Determines whether the given annulus is in fact a boundary annulus for a recognised type of saturated block. More...

## Protected Member Functions

| SatCube ()
| Constructs an uninitialised block. More...

## Static Protected Member Functions

static bool | isBad (Tetrahedron< 3 > *t, const TetList &list)
| Determines whether the given tetrahedron is contained within the given list. More...
template<class List >
static bool | isBad (Tetrahedron< 3 > *t, const List &list)
| Determines whether the given tetrahedron is contained within the given list. More...
static bool | notUnique (Tetrahedron< 3 > *test)
| Determines whether the given tetrahedron pointer is null. More...
static bool | notUnique (Tetrahedron< 3 > *test, Tetrahedron< 3 > *other1)
| Determines whether the given tetrahedron pointer is null or equal to another from the given list. More...
static bool | notUnique (Tetrahedron< 3 > *test, Tetrahedron< 3 > *other1, Tetrahedron< 3 > *other2)
| Determines whether the given tetrahedron pointer is null or equal to another from the given list. More...
static bool | notUnique (Tetrahedron< 3 > *test, Tetrahedron< 3 > *other1, Tetrahedron< 3 > *other2, Tetrahedron< 3 > *other3)
| Determines whether the given tetrahedron pointer is null or equal to another from the given list. More...
static bool | notUnique (Tetrahedron< 3 > *test, Tetrahedron< 3 > *other1, Tetrahedron< 3 > *other2, Tetrahedron< 3 > *other3, Tetrahedron< 3 > *other4)
| Determines whether the given tetrahedron pointer is null or equal to another from the given list. More...

## Protected Attributes

unsigned | 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...
unsigned * | 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...

## Detailed Description

A saturated block that is a six-tetrahedron cube.

There are several ways of triangulating a cube with six tetrahedra; the specific method used here is illustrated in the diagram below (where the top face of the cube is identified with the bottom).

Note that none of the four tetrahedra that meet the boundary annuli touch each other, and that each of these four boundary tetrahedra meet both central tetrahedra. Note also that (unlike other triangulations) this cube cannot be split vertically into two triangular prisms.

## Member Typedef Documentation

## TetList

typedef std::set<Tetrahedron<3>*> regina::SatBlock::TetList

inherited

The data structure used to store a list of tetrahedra that should not be examined by isBlock().

## Constructor & Destructor Documentation

## SatCube() [1/2]

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

inline

Constructs a clone of the given block structure.

Parameters

  cloneMe | the block structure to clone.

## SatCube() [2/2]

regina::SatCube::SatCube | ( |  | ) |

inline protected

Constructs an uninitialised block.

The boundary annuli must be initialised before this block can be used.

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

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

unsigned regina::SatBlock::adjacentAnnulus | ( | unsigned | whichAnnulus | ) | const

inline inherited

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 nAnnuli()-1 inclusive.

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

## adjacentBackwards()

bool regina::SatBlock::adjacentBackwards | ( | unsigned | whichAnnulus | ) | const

inline inherited

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 nAnnuli()-1 inclusive.

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

## adjacentBlock()

SatBlock * regina::SatBlock::adjacentBlock | ( | unsigned | whichAnnulus | ) | const

inline inherited

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 nAnnuli()-1 inclusive.

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

## adjacentReflected()

bool regina::SatBlock::adjacentReflected | ( | unsigned | whichAnnulus | ) | const

inline inherited

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 nAnnuli()-1 inclusive.

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

## adjustSFS()

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

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.

Implements regina::SatBlock.

## annulus()

const SatAnnulus & regina::SatBlock::annulus | ( | unsigned | which | ) | const

inline inherited

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

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

Parameters

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

Returns
  a reference to the requested boundary annulus.

## clone()

SatBlock * regina::SatCube::clone | ( |  | ) | const

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

Implements regina::SatBlock.

## detail()

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

## hasAdjacentBlock()

bool regina::SatBlock::hasAdjacentBlock | ( | unsigned | whichAnnulus | ) | const

inline inherited

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 nAnnuli()-1 inclusive.

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

## insertBlock()

static SatCube* regina::SatCube::insertBlock | ( | Triangulation< 3 > & | tri | ) |

static

Inserts a new copy of a cube block into the given triangulation, and returns the corresponding block structure.

The given triangulation will not be emptied before the new tetrahedra are inserted.

Parameters

  tri | the triangulation into which the new block should be inserted.

Returns
  structural details of the newly inserted block.

## isBad() [1/2]

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

static protected inherited

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.

## isBad() [2/2]

template<class List >

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

inline static protected inherited

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.

## isBlock()

static SatBlock* regina::SatBlock::isBlock | ( | const SatAnnulus & | annulus,
|  | TetList & | avoidTets
| ) |  |

static inherited

Determines whether the given annulus is in fact a boundary annulus for a recognised type of saturated block.

The annulus should be represented from the inside of the proposed saturated block.

Only certain types of saturated block are recognised by this routine. More exotic saturated blocks will not be identified, and this routine will return `null` in such cases.

The given list of tetrahedra will not be examined by this routine. That is, only saturated blocks that do not contain any of these tetrahedra will be considered. As a consequence, if the given annulus uses any of these tetrahedra then `null` will be returned.

If a block is found on the other hand, all of the tetrahedra within this block will be added to the given list.

In the event that a block is found, it is guaranteed that the given annulus will be listed as annulus number 0 in the block structure, without any horizontal or vertical reflection.

Python:
  The second argument avoidTets is not present. An empty list will be passed instead.

Parameters

  annulus | the proposed boundary annulus that should form part of the new saturated block.
  avoidTets | the list of tetrahedra that should not be considered, and to which any new tetrahedra will be added.

Returns
  details of the saturated block if one was found, or `null` if none was found.

## isBlockCube()

static SatCube* regina::SatCube::isBlockCube | ( | const SatAnnulus & | annulus,
|  | TetList & | avoidTets
| ) |  |

static

Determines whether the given annulus is a boundary annulus for a block of this type (cube).

This routine is a specific case of SatBlock::isBlock(); see that routine for further details.

Parameters

  annulus | the proposed boundary annulus that should form part of the new saturated block.
  avoidTets | the list of tetrahedra that should not be considered, and to which any new tetrahedra will be added.

Returns
  details of the saturated block if one was found, or `null` if none was found.

## nAnnuli()

unsigned regina::SatBlock::nAnnuli | ( |  | ) | const

inline inherited

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

Returns
  the number of boundary annuli.

## nextBoundaryAnnulus()

void regina::SatBlock::nextBoundaryAnnulus | ( | unsigned | thisAnnulus,
|  | SatBlock *& | nextBlock,
|  | unsigned & | nextAnnulus,
|  | bool & | refVert,
|  | bool & | refHoriz,
|  | bool | followPrev
| ) |  |

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 returned in the arguments nextBlock and nextAnnulus respectively.

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 argument refVert 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 argument refHoriz 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 refVert 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).

Python:
  This routine only takes two arguments (thisAnnulus and followPrev). The return value is a tuple of four values: the block returned in nextBlock, the integer returned in nextAnnulus, the boolean returned in refVert, and the boolean returned in refHoriz.

Parameters

  thisAnnulus | describes which original boundary annulus of this block to examine; this must be between 0 and nAnnuli()-1 inclusive.
  nextBlock | a reference used to return the block containing the next boundary annulus around from thisAnnulus.
  nextAnnulus | a reference used to return the specific annulus number within nextBlock of the next annulus around; this will be between 0 and nextBlock->nAnnuli()-1 inclusive, and the corresponding annulus will have no block adjacent to it.
  refVert | a reference used to return `true` if the next annulus around is vertically reflected, or `false` if not; see above for details.
  refHoriz | a reference used to return `true` if the next annulus around is horizontally reflected, or `false` if not; see above for details.
  followPrev | `true` if we should find the previous boundary annulus, or `false` if we should find the next boundary annulus.

## notUnique() [1/5]

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

inline static protected inherited

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 | ( | Tetrahedron< 3 > * | test,
|  | Tetrahedron< 3 > * | other1
| ) |  |

inline static protected inherited

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 | ( | Tetrahedron< 3 > * | test,
|  | Tetrahedron< 3 > * | other1,
|  | Tetrahedron< 3 > * | other2
| ) |  |

inline static protected inherited

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 | ( | Tetrahedron< 3 > * | test,
|  | Tetrahedron< 3 > * | other1,
|  | Tetrahedron< 3 > * | other2,
|  | Tetrahedron< 3 > * | other3
| ) |  |

inline static protected inherited

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 | ( | Tetrahedron< 3 > * | test,
|  | Tetrahedron< 3 > * | other1,
|  | Tetrahedron< 3 > * | other2,
|  | Tetrahedron< 3 > * | other3,
|  | Tetrahedron< 3 > * | other4
| ) |  |

inline static protected inherited

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

  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.

## setAdjacent()

void regina::SatBlock::setAdjacent | ( | unsigned | whichAnnulus,
|  | SatBlock * | adjBlock,
|  | unsigned | adjAnnulus,
|  | bool | adjReflected,
|  | bool | adjBackwards
| ) |  |

inline inherited

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

Both block structures (this and the given block) will be updated.

Parameters

  whichAnnulus | indicates which boundary annulus of this block has the new adjacency; this must be between 0 and nAnnuli()-1 inclusive.
  adjBlock | the other saturated block that is adjacent to this.
  adjAnnulus | indicates which boundary annulus of the adjacent block meets the given boundary annulus of this block; this must be between 0 and adjBlock->nAnnuli()-1 inclusive.
  adjReflected | indicates whether the new adjacency is reflected (see the class notes for details).
  adjBackwards | indicates whether the new adjacency is backwards (see the class notes for details).

## str()

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

inherited

Returns a short text representation of this object.

This text should be human-readable, should fit on a single line, and should not end with a newline. Where possible, it should use plain ASCII characters.

Python:
  In addition to str(), this is also used as the Python "stringification" function `__str__()`.

Returns
  a short text representation of this object.

## transform()

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

virtual inherited

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 inherited

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 nAnnuli()-1 and 0.

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

## utf8()

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

inherited

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

Like str(), this text should be human-readable, should fit on a single line, and should not end with a newline. In addition, it may use unicode characters to make the output more pleasant to read. This string will be encoded in UTF-8.

Returns
  a short text representation of this object.

## writeAbbr()

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

inline 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:
  The parameter out does not exist; standard output will be used.

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.

Implements regina::SatBlock.

## writeTextLong()

void regina::SatBlock::writeTextLong | ( | std::ostream & | out | ) | const

inline virtual inherited

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

This may be reimplemented by subclasses, but the parent SatBlock class offers a reasonable default implementation.

Python:
  Not present.

Parameters

  out | the output stream to which to write.

## writeTextShort()

void regina::SatCube::writeTextShort | ( | std::ostream & | out | ) | const

inline virtual

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

This must be implemented by subclasses.

Python:
  Not present.

Parameters

  out | the output stream to which to write.

Implements regina::SatBlock.

## Member Data Documentation

## adjAnnulus_

unsigned* regina::SatBlock::adjAnnulus_

protected inherited

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 inherited

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 inherited

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 inherited

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 inherited

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

## nAnnuli_

unsigned regina::SatBlock::nAnnuli_

protected inherited

The number of boundary annuli.

## twistedBoundary_

bool regina::SatBlock::twistedBoundary_

protected inherited

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

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

- subcomplex/satblocktypes.h

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