Represents a specific set of gluing permutations to complement a particular pairwise matching of simplex facets. More...

#include <census/gluingperms.h>

Inheritance diagram for regina::GluingPerms< dim >:

Public Types
using	Index = typename Perm< dim >::Index
	A native signed integer type large enough to count all permutations on dim elements. More...

Public Member Functions
	GluingPerms (const FacetPairing< dim > &pairing)
	Creates a new permutation set. More...

	GluingPerms (FacetPairing< dim > &&pairing)
	Creates a new permutation set. More...

	GluingPerms (const GluingPerms< dim > &src)
	Creates a new copy of the given gluing permutation set. More...

	GluingPerms (GluingPerms< dim > &&src) noexcept
	Moves the contents of the given gluing permutation set into this new gluing permutation set. More...

	GluingPerms (std::istream &in)
	Reads a new set of gluing permutations from the given input stream. More...

	~GluingPerms ()
	Deallocates any memory used by this structure. More...

GluingPerms &	operator= (const GluingPerms &src)
	Sets this to be a copy of the given gluing permutation set. More...

GluingPerms &	operator= (GluingPerms &&src) noexcept
	Moves the contents of the given gluing permutation set into this new gluing permutation set. More...

void	swap (GluingPerms &other) noexcept
	Swaps the contents of this and the given gluing permutation set. More...

size_t	size () const
	Returns the total number of simplices under consideration. More...

const FacetPairing< dim > &	pairing () const
	Returns the specific pairing of simplex facets that this set of gluing permutations complements. More...

Perm< dim+1 >	perm (const FacetSpec< dim > &source) const
	Returns the gluing permutation associated with the given simplex facet. More...

Perm< dim+1 >	perm (size_t simp, int facet) const
	Returns the gluing permutation associated with the given simplex facet. More...

Index	permIndex (const FacetSpec< dim > &source) const
	Returns the index into array Perm<dim+1>::Sn_1 describing how the the given facet is joined to its partner. More...

Index	permIndex (size_t simp, int facet) const
	Returns the index into array Perm<dim+1>::Sn_1 describing how the the given facet is joined to its partner. More...

Index &	permIndex (const FacetSpec< dim > &source)
	Offers write access to the index into array Perm<dim+1>::Sn_1 describing how the the given facet is joined to its partner. More...

Index &	permIndex (size_t simp, int facet)
	Offers write access to the index into array Perm<dim+1>::Sn_1 describing how the the given facet is joined to its partner. More...

void	setPermIndex (const FacetSpec< dim > &source, Index index)
	Python-only routine that sets the index into array Perm<dim+1>::Sn_1 describing how the the given facet is joined to its partner. More...

void	setPermIndex (size_t simp, int facet, Index index)
	Python-only routine that sets the index into array Perm<dim+1>::Sn_1 describing how the the given facet is joined to its partner. More...

Triangulation< dim >	triangulate () const
	Returns the triangulation modelled by this set of gluing permutations and the associated simplex facet pairing. More...

void	dumpData (std::ostream &out) const
	Dumps all internal data in a plain text format to the given output stream. More...

std::string	data () const
	Returns all internal data in a plain text format. More...

Index	gluingToIndex (const FacetSpec< dim > &source, const Perm< dim+1 > &gluing) const
	Returns the index into array Perm<dim+1>::Sn_1 corresponding to the given gluing permutation from the given facet to its partner. More...

Index	gluingToIndex (size_t simp, int facet, const Perm< dim+1 > &gluing) const
	Returns the index into array Perm<dim+1>::Sn_1 corresponding to the given gluing permutation from the given facet to its partner. More...

Perm< dim+1 >	indexToGluing (const FacetSpec< dim > &source, Index index) const
	Returns the gluing permutation from the given facet to its partner that corresponds to the given index into array Perm<dim+1>::Sn_1. More...

Perm< dim+1 >	indexToGluing (size_t simp, int facet, Index index) const
	Returns the gluing permutation from the given facet to its partner that corresponds to the given index into array Perm<dim+1>::Sn_1. More...

bool	operator== (const GluingPerms &other) const
	Determines if this and the given gluing permutation set are identical. More...

bool	operator!= (const GluingPerms &other) const
	Determines if this and the given gluing permutation set are not identical. More...

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

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

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 GluingPerms	fromData (const std::string &data)
	Reads a new set of gluing permutations from the given string. More...

Detailed Description

template<int dim>
class regina::GluingPerms< dim >

Represents a specific set of gluing permutations to complement a particular pairwise matching of simplex facets.

Given a pairwise matching of facets (as described by class FacetPairing<dim>), each facet that is matched with some other facet will have an associated permutation of (dim + 1) elements.

If a facet is matched with some other facet, the two associated permutations in this set will be inverses. If a facet is left deliberately unmatched, it will have no associated permutation in this set.

Such a set of permutations models part of the structure of a triangulation, in which each simplex facet that is glued to another facet has a corresponding gluing permutation (and the matched facet has the inverse gluing permutation).

The main purpose of this class is to provide a way of quickly describing and manipulating the combinatorial structure of a triangulation without the overhead of a full-blown Triangulation<dim> object. In particular, this class was designed for use in census enumeration, which involves rapid construction and editing of these permutations. To convert this into a full Triangulation<dim> object, you can call triangulate().

Internally, this class stores each permutation as an index into Perm<dim+1>::Sn_1 (that is, an index into the permutation group S_dim). Importantly, you can only set permutations using these indices, via the non-const permIndex() function - access to the permutations themselves is read-only. You can use indexToGluing() and gluingToIndex() to convert between indicex and permutations, or you can use the read-only member function perm() which returns the permutation directly. Note that this correspondence is non-trivial, and depends on the details of the underlying facet pairing.

This class also supports a special "not yet chosen" permutation, represented using the permutation index -1. Attempting to convert this to a real permutation using perm() or indexToGluing() is not allowed, and will result in undefined behaviour.

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

Headers: Parts of this template class are implemented in a separate header (gluingperms-impl.h), which is not included automatically by this file. However, typical end users should never need this extra header, since Regina's calculation engine already includes explicit instantiations for all dimensions.

Template Parameters

dim	the dimension of the underlying triangulation that is being modelled. This must be between 2 and 15 inclusive.

Member Typedef Documentation

◆ Index

template<int dim>

using regina::GluingPerms< dim >::Index = typename Perm<dim>::Index

A native signed integer type large enough to count all permutations on dim elements.

Constructor & Destructor Documentation

◆ GluingPerms() [1/5]

template<int dim>

regina::GluingPerms< dim >::GluingPerms ( const FacetPairing< dim > & pairing )

inline

Creates a new permutation set.

All internal permutations will be marked as not yet chosen, and any attempt to query them before setting them to explicit values will result in undefined behaviour. The corresponding permutation indices will be set to -1.

This constructor induces a deep copy of the given facet pairing.

Precondition: The given facet pairing is connected, i.e., it is possible to reach any simplex from any other simplex via a series of matched facet pairs.; The given facet pairing is in canonical form as described by FacetPairing::isCanonical(). Note that all facet pairings constructed by FacetPairing::findAllPairings() are of this form.

Parameters

pairing the specific pairing of simplex facets that this permutation set will complement.

◆ GluingPerms() [2/5]

template<int dim>

regina::GluingPerms< dim >::GluingPerms ( FacetPairing< dim > && pairing )

inline

Creates a new permutation set.

All internal permutations will be marked as not yet chosen, and any attempt to query them before setting them to explicit values will result in undefined behaviour. The corresponding permutation indices will be set to -1.

This constructor moves the contents of the given facet pairing into this object. After it returns, pairing will no longer be usable.

Precondition: The given facet pairing is connected, i.e., it is possible to reach any simplex from any other simplex via a series of matched facet pairs.; The given facet pairing is in canonical form as described by FacetPairing::isCanonical(). Note that all facet pairings constructed by FacetPairing::findAllPairings() are of this form.

Parameters

pairing the specific pairing of simplex facets that this permutation set will complement.

◆ GluingPerms() [3/5]

template<int dim>

regina::GluingPerms< dim >::GluingPerms ( const GluingPerms< dim > & src )

inline

Creates a new copy of the given gluing permutation set.

Parameters

src	the gluing permutations to copy.

◆ GluingPerms() [4/5]

template<int dim>

regina::GluingPerms< dim >::GluingPerms ( GluingPerms< dim > && src )

inlinenoexcept

Moves the contents of the given gluing permutation set into this new gluing permutation set.

This is a fast (constant time) operation.

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

Parameters

src	the gluing permutations to move.

◆ GluingPerms() [5/5]

template<int dim>

regina::GluingPerms< dim >::GluingPerms ( std::istream & in )

Reads a new set of gluing permutations from the given input stream.

This routine reads data in the format written by dumpData().

Warning: The data format is liable to change between Regina releases. Data in this format should be used on a short-term temporary basis only.

Exceptions

InvalidInput The data found in the input stream is invalid, incomplete, or incorrectly formatted.

Python: Not present. Instead call fromData(), which takes this same input data in string format.

Parameters

in	the input stream from which to read.

◆ ~GluingPerms()

template<int dim>

regina::GluingPerms< dim >::~GluingPerms

inline

Deallocates any memory used by this structure.

Member Function Documentation

◆ data()

template<int dim>

std::string regina::GluingPerms< dim >::data ( ) const

Returns all internal data in a plain text format.

This gluing permutation sert can be recreated from this text data by calling fromData().

This routine may be useful for transferring objects from one processor to another.

This routine returns the same information that dumpData() writes.

Warning: The data format is liable to change between Regina releases. Data in this format should be used on a short-term temporary basis only.

Returns: all of this object's internal data in plain text format.

◆ detail()

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

◆ dumpData()

template<int dim>

void regina::GluingPerms< dim >::dumpData ( std::ostream & out ) const

Dumps all internal data in a plain text format to the given output stream.

This object can be recreated from this text data by calling the input stream constructor for this class.

This routine may be useful for transferring objects from one processor to another.

This routine outputs the same information that data() returns.

Warning: The data format is liable to change between Regina releases. Data in this format should be used on a short-term temporary basis only.

Python: Not present. You can instead use data(), which returns this same information as a string. However, the matching input stream constructor is not available in Python either, so it is recommended that Python users use fromData() instead.

Parameters

out	the output stream to which the data should be written.

◆ fromData()

template<int dim>

static GluingPerms regina::GluingPerms< dim >::fromData ( const std::string & data )

static

Reads a new set of gluing permutations from the given string.

This routine reads data in the format written by data().

Warning: The data format is liable to change between Regina releases. Data in this format should be used on a short-term temporary basis only.

Exceptions

InvalidArgument The data found in the given string is invalid, incomplete, or incorrectly formatted.

Parameters

data	the data from which to reconstruct a gluing permutation set.

Returns: the reconstructed gluing permutation set.

◆ gluingToIndex() [1/2]

template<int dim>

Index regina::GluingPerms< dim >::gluingToIndex	(	const FacetSpec< dim > &	source,
		const Perm< dim+1 > &	gluing
	)		const

Returns the index into array Perm<dim+1>::Sn_1 corresponding to the given gluing permutation from the given facet to its partner.

This need not be the index into Perm<dim+1>::Sn_1 that is currently stored for the given facet.

Indices into array Perm<dim+1>::Sn_1 are stored internally in the array permIndices_. Full gluing permutations on the other hand are used in constructing triangulations.

Precondition: The given simplex facet has a partner according to the underlying facet pairing, i.e., is not a boundary facet.; If the given simplex facet and its partner are facets x and y of their respective simplices, then the given gluing permutation maps x to y.

Parameters

source	the simplex facet under investigation.
gluing	a possible gluing permutation from the given simplex facet to its partner according to the underlying facet pairing.

Returns: the index into Perm<dim+1>::Sn_1 corresponding to the given gluing permutation; this will be between 0 and dim!-1 inclusive.

◆ gluingToIndex() [2/2]

template<int dim>

Index regina::GluingPerms< dim >::gluingToIndex	(	size_t	simp,
		int	facet,
		const Perm< dim+1 > &	gluing
	)		const

Returns the index into array Perm<dim+1>::Sn_1 corresponding to the given gluing permutation from the given facet to its partner.

This need not be the index into Perm<dim+1>::Sn_1 that is currently stored for the given facet.

Indices into array Perm<dim+1>::Sn_1 are stored internally in the array permIndices_. Full gluing permutations on the other hand are used in constructing triangulations.

Precondition: The given simplex facet has a partner according to the underlying facet pairing, i.e., is not a boundary facet.; If the given simplex facet and its partner are facets x and y of their respective simplices, then the given gluing permutation maps x to y.

Parameters

simp	the simplex under investigation; this must be strictly less than the total number of simplices under consideration.
facet	the facet of the given simplex under investigation; this must be between 0 and dim inclusive.
gluing	a possible gluing permutation from the given simplex facet to its partner according to the underlying facet pairing.

Returns: the index into Perm<dim+1>::Sn_1 corresponding to the given gluing permutation; this will be between 0 and dim!-1 inclusive.

◆ indexToGluing() [1/2]

template<int dim>

Perm< dim+1 > regina::GluingPerms< dim >::indexToGluing	(	const FacetSpec< dim > &	source,
		Index	index
	)		const

inline

Returns the gluing permutation from the given facet to its partner that corresponds to the given index into array Perm<dim+1>::Sn_1.

This index into Perm<dim+1>::Sn_1 need not be the index that is currently stored for the given facet.

Indices into array Perm<dim+1>::Sn_1 are stored internally in the array permIndices_. Full gluing permutations on the other hand are used in constructing triangulations.

If the given simplex facet and its partner according to the underlying facet pairing are facets x and y of their respective simplices, then the resulting gluing permutation will map x to y.

Precondition: The given simplex facet has a partner according to the underlying facet pairing, i.e., is not a boundary facet.

Parameters

source	the simplex facet under investigation.
index	an index into Perm<dim+1>::Sn_1; this must be between 0 and dim!-1 inclusive.

Returns: the gluing permutation corresponding to the given index into Perm<dim+1>::Sn_1.

◆ indexToGluing() [2/2]

template<int dim>

Perm< dim+1 > regina::GluingPerms< dim >::indexToGluing	(	size_t	simp,
		int	facet,
		Index	index
	)		const

inline

Returns the gluing permutation from the given facet to its partner that corresponds to the given index into array Perm<dim+1>::Sn_1.

This index into Perm<dim+1>::Sn_1 need not be the index that is currently stored for the given facet.

Indices into array Perm<dim+1>::Sn_1 are stored internally in the array permIndices_. Full gluing permutations on the other hand are used in constructing triangulations.

If the given simplex facet and its partner according to the underlying facet pairing are facets x and y of their respective simplices, then the resulting gluing permutation will map x to y.

Precondition: The given simplex facet has a partner according to the underlying facet pairing, i.e., is not a boundary facet.

Parameters

simp	the simplex under investigation; this must be strictly less than the total number of simplices under consideration.
facet	the facet of the given simplex under investigation; this must be between 0 and dim inclusive.
index	an index into Perm<dim+1>::Sn_1; this must be between 0 and dim!-1 inclusive.

Returns: the gluing permutation corresponding to the given index into Perm<dim+1>::Sn_1.

◆ operator!=()

template<int dim>

bool regina::GluingPerms< dim >::operator!= ( const GluingPerms< dim > & other ) const

inline

Determines if this and the given gluing permutation set are not identical.

To be identical, the two sets must use identical facet pairings and all of their corresponding permutations must be the same.

Parameters

other the gluing permutation set to compare with this.

Returns: true if and only if this and the given set are not identical.

◆ operator=() [1/2]

template<int dim>

GluingPerms< dim > & regina::GluingPerms< dim >::operator= ( const GluingPerms< dim > & src )

inline

Sets this to be a copy of the given gluing permutation set.

Parameters

src	the gluing permutations to copy.

Returns: a reference to this gluing permutation set.

◆ operator=() [2/2]

template<int dim>

GluingPerms< dim > & regina::GluingPerms< dim >::operator= ( GluingPerms< dim > && src )

inlinenoexcept

Moves the contents of the given gluing permutation set into this new gluing permutation set.

This is a fast (constant time) operation.

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

Parameters

src	the gluing permutations to move.

Returns: a reference to this gluing permutation set.

◆ operator==()

template<int dim>

bool regina::GluingPerms< dim >::operator== ( const GluingPerms< dim > & other ) const

inline

Determines if this and the given gluing permutation set are identical.

To be identical, the two sets must use identical facet pairings and all of their corresponding permutations must be the same.

Parameters

other the gluing permutation set to compare with this.

Returns: true if and only if this and the given set are identical.

◆ pairing()

template<int dim>

const FacetPairing< dim > & regina::GluingPerms< dim >::pairing

inline

Returns the specific pairing of simplex facets that this set of gluing permutations complements.

Returns: the corresponding simplex facet pairing.

◆ perm() [1/2]

template<int dim>

Perm< dim+1 > regina::GluingPerms< dim >::perm ( const FacetSpec< dim > & source ) const

inline

Returns the gluing permutation associated with the given simplex facet.

Precondition: The given facet is actually paired with some other facet in the underlying pairwise matching (see routine pairing()).; The given facet is a real simplex facet (not boundary, before-the-start or past-the-end).; The requested permutation is not the special "not yet chosen" value (i.e., the internal index that is stored for it is not -1).

Parameters

source the simplex facet under investigation.

Returns: the associated gluing permutation.

◆ perm() [2/2]

template<int dim>

Perm< dim+1 > regina::GluingPerms< dim >::perm	(	size_t	simp,
		int	facet
	)		const

inline

Returns the gluing permutation associated with the given simplex facet.

Precondition: The given facet is actually paired with some other facet in the underlying pairwise matching (see routine pairing()).; The requested permutation is not the special "not yet chosen" value (i.e., the internal index that is stored for it is not -1).

Parameters

simp	the simplex under investigation (this must be strictly less than the total number of simplices under consideration).
facet	the facet of the given simplex under investigation (between 0 and dim inclusive).

Returns: the associated gluing permutation.

◆ permIndex() [1/4]

template<int dim>

GluingPerms< dim >::Index & regina::GluingPerms< dim >::permIndex ( const FacetSpec< dim > & source )

inline

Offers write access to the index into array Perm<dim+1>::Sn_1 describing how the the given facet is joined to its partner.

Note that this is not the S_n index of the gluing permutation on (dim + 1) elements, but rather the index of a permutation on just dim elements. You can use indexToGluing() and gluingToIndex() to convert between these indices and gluing permutations, or you can call perm() for read-only access to the gluing permutation directly.

As described in the class notes, this index can be a real permutation index between 0 and (dim!)-1 inclusive, or it may be the special value -1 indicating that the permutation has not yet been chosen.

Precondition: The given facet is a real simplex facet (not boundary, before-the-start or past-the-end).

Python: For Python users, permIndex() is a read-only function that returns by value. To edit this index, use the Python-only routine setPermIndex() instead.

Parameters

source the simplex facet under investigation.

Returns: a reference to the corresponding array index.

◆ permIndex() [2/4]

template<int dim>

GluingPerms< dim >::Index regina::GluingPerms< dim >::permIndex ( const FacetSpec< dim > & source ) const

inline

Returns the index into array Perm<dim+1>::Sn_1 describing how the the given facet is joined to its partner.

Note that this is not the S_n index of the gluing permutation on (dim + 1) elements, but rather the index of a permutation on just dim elements. You can use indexToGluing() and gluingToIndex() to convert between these indices and gluing permutations, or you can call perm() to read the gluing permutation directly.

As described in the class notes, this index could be a real permutation index between 0 and (dim!)-1 inclusive, or it could be the special value -1 indicating that the permutation has not yet been chosen.

Precondition: The given facet is a real simplex facet (not boundary, before-the-start or past-the-end).

Parameters

source the simplex facet under investigation.

Returns: a reference to the corresponding array index.

◆ permIndex() [3/4]

template<int dim>

GluingPerms< dim >::Index & regina::GluingPerms< dim >::permIndex	(	size_t	simp,
		int	facet
	)

inline

Offers write access to the index into array Perm<dim+1>::Sn_1 describing how the the given facet is joined to its partner.

Note that this is not the S_n index of the gluing permutation on (dim + 1) elements, but rather the index of a permutation on just dim elements. You can use indexToGluing() and gluingToIndex() to convert between these indices and gluing permutations, or you can call perm() for read-only access to the gluing permutation directly.

As described in the class notes, this index can be a real permutation index between 0 and (dim!)-1 inclusive, or it may be the special value -1 indicating that the permutation has not yet been chosen.

Python: For Python users, permIndex() is a read-only function that returns by value. To edit this index, use the Python-only routine setPermIndex() instead.

Parameters

simp	the simplex under investigation (this must be strictly less than the total number of simplices under consideration).
facet	the facet of the given simplex under investigation (between 0 and dim inclusive).

Returns: a reference to the corresponding array index.

◆ permIndex() [4/4]

template<int dim>

GluingPerms< dim >::Index regina::GluingPerms< dim >::permIndex	(	size_t	simp,
		int	facet
	)		const

inline

Returns the index into array Perm<dim+1>::Sn_1 describing how the the given facet is joined to its partner.

Note that this is not the S_n index of the gluing permutation on (dim + 1) elements, but rather the index of a permutation on just dim elements. You can use indexToGluing() and gluingToIndex() to convert between these indices and gluing permutations, or you can call perm() to read the gluing permutation directly.

As described in the class notes, this index could be a real permutation index between 0 and (dim!)-1 inclusive, or it could be the special value -1 indicating that the permutation has not yet been chosen.

Parameters

simp	the simplex under investigation (this must be strictly less than the total number of simplices under consideration).
facet	the facet of the given simplex under investigation (between 0 and dim inclusive).

Returns: a reference to the corresponding array index.

◆ setPermIndex() [1/2]

template<int dim>

void regina::GluingPerms< dim >::setPermIndex	(	const FacetSpec< dim > &	source,
		Index	index
	)

Python-only routine that sets the index into array Perm<dim+1>::Sn_1 describing how the the given facet is joined to its partner.

Note that this is not the S_n index of the gluing permutation on (dim + 1) elements, but rather the index of a permutation on just dim elements. You can use indexToGluing() and gluingToIndex() to convert between these indices and gluing permutations.

As described in the class notes, this index can be a real permutation index between 0 and (dim!)-1 inclusive, or it may be the special value -1 indicating that the permutation has not yet been chosen.

Precondition: The given facet is a real simplex facet (not boundary, before-the-start or past-the-end).

C++: Not present. For C++ users, permIndex() is used for both reading and writing: just write permIndex(source) = index.

Parameters

source	the simplex facet under consideration.
index	the new value of the corresponding array index.

◆ setPermIndex() [2/2]

template<int dim>

void regina::GluingPerms< dim >::setPermIndex	(	size_t	simp,
		int	facet,
		Index	index
	)

Python-only routine that sets the index into array Perm<dim+1>::Sn_1 describing how the the given facet is joined to its partner.

Note that this is not the S_n index of the gluing permutation on (dim + 1) elements, but rather the index of a permutation on just dim elements. You can use indexToGluing() and gluingToIndex() to convert between these indices and gluing permutations.

As described in the class notes, this index can be a real permutation index between 0 and (dim!)-1 inclusive, or it may be the special value -1 indicating that the permutation has not yet been chosen.

C++: Not present. For C++ users, permIndex() is used for both reading and writing: just write permIndex(simp, facet) = index.

Parameters

simp	the simplex under consideration (this must be strictly less than the total number of simplices under consideration).
facet	the facet of the given simplex under consideration (between 0 and dim inclusive).
index	the new value of the corresponding array index.

◆ size()

template<int dim>

size_t regina::GluingPerms< dim >::size

inline

Returns the total number of simplices under consideration.

Returns: the number of simplices under consideration.

◆ str()

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

inherited

Returns a short text representation of this object.

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

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

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

Returns: a short text representation of this object.

◆ swap()

template<int dim>

void regina::GluingPerms< dim >::swap ( GluingPerms< dim > & other )

inlinenoexcept

Swaps the contents of this and the given gluing permutation set.

Parameters

other the set whose contents should be swapped with this.

◆ triangulate()

template<int dim>

Triangulation< dim > regina::GluingPerms< dim >::triangulate ( ) const

Returns the triangulation modelled by this set of gluing permutations and the associated simplex facet pairing.

Each matched pair of facets and their associated permutations will be realised as two simplex facets in the triangulation glued together with the corresponding gluing permutation. Each unmatched facet will be realised as a boundary facet in the triangulation.

Precondition: For every simplex facet in the underlying facet pairing that is glued to a partner, the corresponding gluing permutation in this set is not the special "not yet chosen" value (i.e., does not have internal index -1).

Returns: the triangulation modelled by this structure.

◆ utf8()

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

inherited

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

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

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

Returns: a short text representation of this object.

◆ writeTextLong()

template<int dim>

void regina::GluingPerms< dim >::writeTextLong ( std::ostream & out ) const

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

Python: Not present. Use detail() instead.

Parameters

out	the output stream to which to write.

◆ writeTextShort()

template<int dim>

void regina::GluingPerms< dim >::writeTextShort ( std::ostream & out ) const

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

Python: Not present. Use str() instead.

Parameters

out	the output stream to which to write.

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

census/gluingperms.h

Public Types

Public Member Functions

Static Public Member Functions

Detailed Description

Member Typedef Documentation

◆ Index

Constructor & Destructor Documentation

◆ GluingPerms() [1/5]

◆ GluingPerms() [2/5]

◆ GluingPerms() [3/5]

◆ GluingPerms() [4/5]

◆ GluingPerms() [5/5]

◆ ~GluingPerms()

Member Function Documentation

◆ data()

◆ detail()

◆ dumpData()

◆ fromData()

◆ gluingToIndex() [1/2]

◆ gluingToIndex() [2/2]

◆ indexToGluing() [1/2]

◆ indexToGluing() [2/2]

◆ operator!=()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ operator==()

◆ pairing()

◆ perm() [1/2]

◆ perm() [2/2]

◆ permIndex() [1/4]

◆ permIndex() [2/4]

◆ permIndex() [3/4]

◆ permIndex() [4/4]

◆ setPermIndex() [1/2]

◆ setPermIndex() [2/2]

◆ size()

◆ str()

◆ swap()

◆ triangulate()

◆ utf8()

◆ writeTextLong()

◆ writeTextShort()