Vertex Enumeration

Polytope vertex enumeration algorithms. More...

## Classes

class | regina::DoubleDescription
| Implements a modified double description method for polytope vertex enumeration. More...
class | regina::EnumConstraints
| Represents an individual validity constraint for use with polytope vertex enumeration. More...
class | regina::HilbertCD
| Implements a modified Contejean-Devie algorithm for enumerating Hilbert bases. More...
class | regina::HilbertDual
| Implements a modified dual algorithm for enumerating Hilbert bases. More...
class | regina::HilbertPrimal
| Implements a modified primal algorithm for enumerating Hilbert bases. More...
class | regina::MaxAdmissible
| Used to enumerate all maximal admissible faces of a polyhedral cone under a given set of admissibility constraints. More...
class | regina::PosOrder
| A comparison object that sorts hyperplanes by position vectors. More...
struct | regina::LPConstraintBase::Coefficients
| Stores the extra coefficients in a single column for the nConstraints additional rows that we add to the tableaux to describe the nConstraints additional linear equations or inequalities. More...
class | regina::LPConstraintBase
| A base class for additional linear constraints that we can add to the tableaux of normal surface or angle structure matching equations. More...
class | regina::LPConstraintSubspace
| A subclass of LPConstraintBase used for constraints defined entirely by homogeneous linear equations. More...
struct | regina::LPConstraintNone::Coefficients
| Stores the extra coefficients in the tableaux associated with this constraint class (which for this class is a no-op, since in this case there are no extra coefficients). More...
class | regina::LPConstraintNone
| A do-nothing class that imposes no additional linear constraints on the tableaux of normal surface or angle structure matching equations. More...
struct | regina::LPConstraintEuler::Coefficients
| Stores the extra coefficients in the tableaux associated with this constraint class (in this case, one extra integer per column). More...
class | regina::LPConstraintEuler
| A class that constraints the tableaux of normal surface matching equations to ensure that Euler characteristic is strictly positive. More...
struct | regina::LPConstraintNonSpun::Coefficients
| Stores the extra coefficients in the tableaux associated with this constraint class (in this case, two extra integers per column). More...
class | regina::LPConstraintNonSpun
| A class that constraints the tableaux of normal surface matching equations to ensure that normal surfaces in an ideal triangulation are compact (thereby avoiding spun normal surfaces with infinitely many triangles). More...
class | regina::BanConstraintBase
| A base class for additional banning and marking constraints that we can place on tree traversal algorithms. More...
class | regina::BanNone
| A do-nothing class that bans no coordinates and marks no coordinates. More...
class | regina::BanBoundary
| A class that bans normal disc types that meet the boundary of the underlying triangulation. More...
class | regina::BanTorusBoundary
| A class that bans and marks disc types associated with torus boundary components. More...
class | regina::LPMatrix< IntType >
| A matrix class for use with linear programming. More...
struct | regina::LPCol< LPConstraint >
| Used by LPInitialTableaux<LPConstraint> to store a single column of the adjusted matching equation matrix in sparse form. More...
class | regina::LPInitialTableaux< LPConstraint >
| Stores an adjusted matrix of homogeneous linear matching equations based on a given triangulation, in sparse form. More...
class | regina::LPData< LPConstraint, IntType >
| Stores an intermediate tableaux for the dual simplex method, and contains all of the core machinery for using the dual simplex method. More...
class | regina::TreeTraversal< LPConstraint, BanConstraint, IntType >
| A base class for searches that employ the tree traversal algorithm for enumerating and locating vertex normal surfaces and taut angle structures. More...
class | regina::TreeEnumeration< LPConstraint, BanConstraint, IntType >
| The main entry point for the tree traversal algorithm to enumerate all vertex normal or almost normal surfaces in a 3-manifold triangulation. More...
class | regina::TautEnumeration< LPConstraint, BanConstraint, IntType >
| The main entry point for the tree traversal algorithm to enumerate all taut angle structures in a 3-manifold triangulation. More...
class | regina::TreeSingleSoln< LPConstraint, BanConstraint, IntType >
| The main entry point for the tree traversal / branching algorithm to locate a single non-trivial normal surface satisfying given constraints within a 3-manifold triangulation. More...
class | regina::TypeTrie< nTypes >
| A trie that stores a set of type vectors of a fixed length. More...

## Typedefs

typedef DoubleDescription | regina::NDoubleDescription
| Deprecated typedef for backward compatibility. More...
typedef EnumConstraints | regina::NEnumConstraintList
| Deprecated typedef for backward compatibility. More...
typedef HilbertCD | regina::NHilbertCD
| Deprecated typedef for backward compatibility. More...
typedef HilbertDual | regina::NHilbertDual
| Deprecated typedef for backward compatibility. More...
typedef HilbertPrimal | regina::NHilbertPrimal
| Deprecated typedef for backward compatibility. More...
typedef PosOrder | regina::NPosOrder
| Deprecated typedef for backward compatibility. More...
template<class LPConstraint , typename BanConstraint , typename IntType >
using | regina::NTreeTraversal = TreeTraversal< LPConstraint, BanConstraint, IntType >
| Deprecated typedef for backward compatibility. More...
template<class LPConstraint = LPConstraintNone, typename BanConstraint = BanNone, typename IntType = Integer>
using | regina::NTreeEnumeration = TreeEnumeration< LPConstraint, BanConstraint, IntType >
| Deprecated typedef for backward compatibility. More...
template<class LPConstraint = LPConstraintNone, typename BanConstraint = BanNone, typename IntType = Integer>
using | regina::NTautEnumeration = TautEnumeration< LPConstraint, BanConstraint, IntType >
| Deprecated typedef for backward compatibility. More...
template<class LPConstraint = LPConstraintNone, typename BanConstraint = BanNone, typename IntType = Integer>
using | regina::NTreeSingleSoln = TreeSingleSoln< LPConstraint, BanConstraint, IntType >
| Deprecated typedef for backward compatibility. More...
template<int nTypes>
using | regina::NTypeTrie = TypeTrie< nTypes >
| Deprecated typedef for backward compatibility. More...

## Enumerations

enum | { regina::LPConstraintBase::nConstraints }
enum | { nConstraints = 0 }
enum | { nConstraints = 1 }
enum | { nConstraints = 2 }

## Functions

| regina::LPConstraintBase::Coefficients::Coefficients ()
| Creates an uninitialised set of coefficients for a single column. More...
template<typename IntType >
void | regina::LPConstraintBase::Coefficients::fillFinalRows (LPMatrix< IntType > &m, unsigned col) const
| Explicitly fills the final row(s) of the given tableaux matrix with the coefficients stored in this Coefficients structure. More...
template<typename IntType >
IntType | regina::LPConstraintBase::Coefficients::innerProduct (const LPMatrix< IntType > &m, unsigned mRow) const
| Computes the inner product of (i) the final nConstraints entries in the given row of the given matrix with (ii) the nConstraints column coefficients stored in this data structure. More...
template<typename IntType >
IntType | regina::LPConstraintBase::Coefficients::innerProductOct (const LPMatrix< IntType > &m, unsigned mRow) const
| A variant of innerProduct() that takes into account any adjustments to these linear constraint(s) that are required when this is a quadrilateral column being used to represent an octagon type. More...
static bool | regina::LPConstraintBase::addRows (LPCol< LPConstraintBase > *col, const int *columnPerm, const Triangulation< 3 > *tri)
| Explicitly constructs equations for the linear function(s) constrained by this class. More...
template<typename IntType >
static void | regina::LPConstraintBase::constrain (LPData< LPConstraintNone, IntType > &lp, unsigned numCols)
| Explicitly constraints each of these linear functions to an equality or inequality in the underlying tableaux. More...
static bool | regina::LPConstraintBase::verify (const NormalSurface *s)
| Ensures that the given normal surface satisfies the extra constraints described by this class. More...
static bool | regina::LPConstraintBase::verify (const AngleStructure *s)
| Ensures that the given angle structure satisfies the extra constraints described by this class. More...
static bool | regina::LPConstraintBase::supported (NormalCoords coords)
| Indicates whether the given coordinate system is supported by this constraint class. More...
template<typename IntType >
void | regina::LPConstraintNone::Coefficients::fillFinalRows (LPMatrix< IntType > &m, unsigned col) const
template<typename IntType >
IntType | regina::LPConstraintNone::Coefficients::innerProduct (const LPMatrix< IntType > &, unsigned) const
template<typename IntType >
IntType | regina::LPConstraintNone::Coefficients::innerProductOct (const LPMatrix< IntType > &, unsigned) const
static bool | regina::LPConstraintNone::addRows (LPCol< regina::LPConstraintNone > *, const int *, const Triangulation< 3 > *)
template<typename IntType >
static void | regina::LPConstraintNone::constrain (LPData< regina::LPConstraintNone, IntType > &, unsigned)
static bool | regina::LPConstraintNone::verify (const NormalSurface *)
static bool | regina::LPConstraintNone::verify (const AngleStructure *)
static bool | regina::LPConstraintNone::supported (NormalCoords coords)
template<typename IntType >
void | regina::LPConstraintEuler::Coefficients::fillFinalRows (LPMatrix< IntType > &m, unsigned col) const
template<typename IntType >
IntType | regina::LPConstraintEuler::Coefficients::innerProduct (const LPMatrix< IntType > &m, unsigned mRow) const
template<typename IntType >
IntType | regina::LPConstraintEuler::Coefficients::innerProductOct (const LPMatrix< IntType > &m, unsigned mRow) const
static bool | regina::LPConstraintEuler::addRows (LPCol< regina::LPConstraintEuler > *col, const int *columnPerm, const Triangulation< 3 > *tri)
template<typename IntType >
static void | regina::LPConstraintEuler::constrain (LPData< regina::LPConstraintEuler, IntType > &lp, unsigned numCols)
static bool | regina::LPConstraintEuler::verify (const NormalSurface *s)
static bool | regina::LPConstraintEuler::verify (const AngleStructure *)
static bool | regina::LPConstraintEuler::supported (NormalCoords coords)
template<typename IntType >
void | regina::LPConstraintNonSpun::Coefficients::fillFinalRows (LPMatrix< IntType > &m, unsigned col) const
template<typename IntType >
IntType | regina::LPConstraintNonSpun::Coefficients::innerProduct (const LPMatrix< IntType > &m, unsigned mRow) const
template<typename IntType >
IntType | regina::LPConstraintNonSpun::Coefficients::innerProductOct (const LPMatrix< IntType > &m, unsigned mRow) const
static bool | regina::LPConstraintNonSpun::addRows (LPCol< regina::LPConstraintNonSpun > *col, const int *columnPerm, const Triangulation< 3 > *tri)
template<typename IntType >
static void | regina::LPConstraintNonSpun::constrain (LPData< regina::LPConstraintNonSpun, IntType > &lp, unsigned numCols)
static bool | regina::LPConstraintNonSpun::verify (const NormalSurface *s)
static bool | regina::LPConstraintNonSpun::verify (const AngleStructure *)
static bool | regina::LPConstraintNonSpun::supported (NormalCoords coords)
| regina::BanConstraintBase::BanConstraintBase (const Triangulation< 3 > *tri, int coords)
| Constructs and initialises the banned_ and marked_ arrays to be entirely `false`. More...
| regina::BanConstraintBase::~BanConstraintBase ()
| Destroys this object and all associated data. More...
template<class LPConstraint , typename IntType >
void | regina::BanConstraintBase::enforceBans (LPData< LPConstraint, IntType > &lp) const
| Enforces all bans described by this class in the given tableaux. More...
void | regina::BanConstraintBase::init (const int *columnPerm)
| Identifies which coordinates to ban and mark, and records the corresponding tableaux columns in the banned_ and marked_ arrays respectively. More...
static bool | regina::BanConstraintBase::supported (NormalCoords coords)
| Indicates whether the given coordinate system is supported by this constraint class. More...
| regina::BanNone::BanNone (const Triangulation< 3 > *tri, int coords)
| Constructs and initialises the banned_ and marked_ arrays to be entirely `false`, as described in the BanConstraintBase superclass constructor. More...
void | regina::BanNone::init (const int *)
static bool | regina::BanNone::supported (NormalCoords coords)
| regina::BanBoundary::BanBoundary (const Triangulation< 3 > *tri, int coords)
| Constructs and initialises the banned_ and marked_ arrays to be entirely `false`, as described in the BanConstraintBase superclass constructor. More...
void | regina::BanBoundary::init (const int *columnPerm)
static bool | regina::BanBoundary::supported (NormalCoords coords)
| regina::BanTorusBoundary::BanTorusBoundary (const Triangulation< 3 > *tri, int coords)
| Constructs and initialises the banned_ and marked_ arrays to be entirely `false`, as described in the BanConstraintBase superclass constructor. More...
void | regina::BanTorusBoundary::init (const int *columnPerm)
static bool | regina::BanTorusBoundary::supported (NormalCoords coords)

## Variables

int | regina::LPConstraintEuler::Coefficients::euler
| The coefficient of the Euler characteristic function for the corresponding column of the matching equation matrix. More...
int | regina::LPConstraintNonSpun::Coefficients::meridian
| The coefficient of the meridian equation for the corresponding column of the matching equation matrix. More...
int | regina::LPConstraintNonSpun::Coefficients::longitude
| The coefficient of the longitude equation for the corresponding column of the matching equation matrix. More...
const Triangulation< 3 > * | regina::BanConstraintBase::tri_
| The triangulation with which we are working. More...
int | regina::BanConstraintBase::coords_
| The normal or almost normal coordinate system in which we are working. More...
bool * | regina::BanConstraintBase::banned_
| Indicates which columns of a tableaux correspond to banned coordinates (e.g., banned normal disc types). More...
bool * | regina::BanConstraintBase::marked_
| Indicates which columns of a tableaux correspond to marked coordinates (e.g., marked normal disc types). More...

## Detailed Description

Polytope vertex enumeration algorithms.

## Typedef Documentation

## NDoubleDescription

typedef DoubleDescription regina::NDoubleDescription

Deprecated typedef for backward compatibility.

This typedef will be removed in a future release of Regina.

Deprecated:
  The class NDoubleDescription has now been renamed to DoubleDescription.

## NEnumConstraintList

typedef EnumConstraints regina::NEnumConstraintList

Deprecated typedef for backward compatibility.

This typedef will be removed in a future release of Regina.

Deprecated:
  The class NEnumConstraintList has now been renamed to EnumConstraints.

## NHilbertCD

typedef HilbertCD regina::NHilbertCD

Deprecated typedef for backward compatibility.

This typedef will be removed in a future release of Regina.

Deprecated:
  The class NHilbertCD has now been renamed to HilbertCD.

## NHilbertDual

typedef HilbertDual regina::NHilbertDual

Deprecated typedef for backward compatibility.

This typedef will be removed in a future release of Regina.

Deprecated:
  The class NHilbertDual has now been renamed to HilbertDual.

## NHilbertPrimal

typedef HilbertPrimal regina::NHilbertPrimal

Deprecated typedef for backward compatibility.

This typedef will be removed in a future release of Regina.

Deprecated:
  The class NHilbertPrimal has now been renamed to HilbertPrimal.

## NPosOrder

typedef PosOrder regina::NPosOrder

Deprecated typedef for backward compatibility.

This typedef will be removed in a future release of Regina.

Deprecated:
  The class NPosOrder has now been renamed to PosOrder.

## NTautEnumeration

template<class LPConstraint = LPConstraintNone, typename BanConstraint = BanNone, typename IntType = Integer>

using regina::NTautEnumeration = typedef TautEnumeration<LPConstraint, BanConstraint, IntType>

Deprecated typedef for backward compatibility.

This typedef will be removed in a future release of Regina.

Deprecated:
  The class NTautEnumeration has now been renamed to TautEnumeration.

## NTreeEnumeration

template<class LPConstraint = LPConstraintNone, typename BanConstraint = BanNone, typename IntType = Integer>

using regina::NTreeEnumeration = typedef TreeEnumeration<LPConstraint, BanConstraint, IntType>

Deprecated typedef for backward compatibility.

This typedef will be removed in a future release of Regina.

Deprecated:
  The class NTreeEnumeration has now been renamed to TreeEnumeration.

## NTreeSingleSoln

template<class LPConstraint = LPConstraintNone, typename BanConstraint = BanNone, typename IntType = Integer>

using regina::NTreeSingleSoln = typedef TreeSingleSoln<LPConstraint, BanConstraint, IntType>

Deprecated typedef for backward compatibility.

This typedef will be removed in a future release of Regina.

Deprecated:
  The class NTreeSingleSoln has now been renamed to TreeSingleSoln.

## NTreeTraversal

template<class LPConstraint , typename BanConstraint , typename IntType >

using regina::NTreeTraversal = typedef TreeTraversal<LPConstraint, BanConstraint, IntType>

Deprecated typedef for backward compatibility.

This typedef will be removed in a future release of Regina.

Deprecated:
  The class NTreeTraversal has now been renamed to TreeTraversal.

## NTypeTrie

template<int nTypes>

using regina::NTypeTrie = typedef TypeTrie<nTypes>

Deprecated typedef for backward compatibility.

This typedef will be removed in a future release of Regina.

Deprecated:
  The class NTypeTrie has now been renamed to TypeTrie.

## Enumeration Type Documentation

## anonymous enum

anonymous enum

Enumerator
nConstraints | The number of additional linear constraints that we impose. Each constraint will generate one new variable (column) and one new equation (row) in the tableaux.

## Function Documentation

## addRows()

static bool regina::LPConstraintBase::addRows | ( | LPCol< LPConstraintBase > * | col,
|  | const int * | columnPerm,
|  | const Triangulation< 3 > * | tri
| ) |  |

static

Explicitly constructs equations for the linear function(s) constrained by this class.

Specifically, this routine takes an array of Coefficients objects (one for each column of the initial tableaux) and fills in the necessary coefficient data.

The precise form of the linear function(s) will typically depend upon the underlying triangulation. For this reason, the triangulation is explicitly passed, along with the permutation that indicates which columns of the initial tableaux correspond to which normal or angle structure coordinates.

More precisely: recall that, for each linear function, the initial tableaux acquires one new variable x_i that evaluates this linear function f(x). This routine must create the corresponding row that sets `f(x) - x_i = 0`. Thus it must construct the coefficients of f(x) in the columns corresponding to normal coordinates, and it must also set a coefficient of -1 in the column for the corresponding new variable.

For each subclass S of LPConstraintBase, the array col must be an array of objects of type LPCol<S>. The class LPCol<S> is itself a larger subclass of the Coefficients class. This exact type must be used because the compiler must know how large each column object is in order to correct access each element of the given array.

As described in the LPInitialTableaux class notes, it might not be possible to construct the linear functions (since the triangulation might not satisfy the necessary requirements). In this case, this routine should ensure that the linear functions are in fact the zero functions, and should return `false` (but it must still set -1 coefficients for the new variables as described above). Otherwise (if the linear function were successfully constructed) this routine should return `true`.

If you are implementing this routine in a subclass that works with angle structure coordinates, remember that your linear constraints must not interact with the scaling coordinate (the final angle structure coordinate that is used to projectivise the angle structure polytope into a polyhedral cone). Your implementation of this routine must ensure that your linear constraints all have coefficient zero in this column.

Precondition
  For all coefficients in the array col, the Coefficients substructures have all been initialised with the default constructor and not modified since.

Parameters

  col | the array of columns as stored in the initial tableaux (i.e., the data member LPInitialTableaux::col_).
  columnPerm | the corresponding permutation of columns that describes how columns of the tableaux correspond to normal or angle structure coordinates in the underlying triangulation (i.e., the data member LPInitialTableaux::columnPerm_).
  tri | the underlying triangulation.

Returns
  `true` if the linear functions were successfully constructed, or `false` if not (in which case they will be replaced with the zero functions instead).

## BanBoundary()

regina::BanBoundary::BanBoundary | ( | const Triangulation< 3 > * | tri,
|  | int | coords
| ) |  |

inline protected

Constructs and initialises the banned_ and marked_ arrays to be entirely `false`, as described in the BanConstraintBase superclass constructor.

Warning
  Before you use this object, the routine init() must be called to fill in the banned_ and marked_ arrays with the correct data. Otherwise you will have no banned or marked disc types at all.

Parameters

  tri | the triangulation with which we are working.
  coords | the normal or almost normal coordinate system in which we are working. This must be one of NS_QUAD, NS_STANDARD, NS_AN_QUAD_OCT, or NS_AN_STANDARD.

## BanConstraintBase()

regina::BanConstraintBase::BanConstraintBase | ( | const Triangulation< 3 > * | tri,
|  | int | coords
| ) |  |

protected

Constructs and initialises the banned_ and marked_ arrays to be entirely `false`.

The only purpose of passing the triangulation and coordinate system is to determine how many normal or angle structure coordinates we are dealing with.

Warning
  Before you use this object, the routine init() must be called to fill in the banned_ and marked_ arrays with the correct data. Otherwise you will have no banned or marked disc types at all.

Parameters

  tri | the triangulation with which we are working.
  coords | the coordinate system in which we are working. This must be one of NS_QUAD, NS_STANDARD, NS_AN_QUAD_OCT, NS_AN_STANDARD, or NS_ANGLE.

## BanNone()

regina::BanNone::BanNone | ( | const Triangulation< 3 > * | tri,
|  | int | coords
| ) |  |

inline protected

Constructs and initialises the banned_ and marked_ arrays to be entirely `false`, as described in the BanConstraintBase superclass constructor.

Although one should normally call the routine init() before using this object, for BanNone this is not strictly necessary since there are no coordinates to ban or mark.

Parameters

  tri | the triangulation with which we are working.
  coords | the coordinate system in which we are working. This must be one of NS_QUAD, NS_STANDARD, NS_AN_QUAD_OCT, NS_AN_STANDARD, or NS_ANGLE.

## BanTorusBoundary()

regina::BanTorusBoundary::BanTorusBoundary | ( | const Triangulation< 3 > * | tri,
|  | int | coords
| ) |  |

inline protected

Constructs and initialises the banned_ and marked_ arrays to be entirely `false`, as described in the BanConstraintBase superclass constructor.

Warning
  Before you use this object, the routine init() must be called to fill in the banned_ and marked_ arrays with the correct data. Otherwise you will have no banned or marked disc types at all.

Parameters

  tri | the triangulation with which we are working.
  coords | the normal or almost normal coordinate system in which we are working. This must be one of NS_QUAD, NS_STANDARD, NS_AN_QUAD_OCT, or NS_AN_STANDARD.

## Coefficients()

regina::LPConstraintBase::Coefficients::Coefficients | ( |  | ) |

Creates an uninitialised set of coefficients for a single column.

These cofficients must be initialised through a call to addRows() before they can be used.

## constrain()

template<typename IntType >

static void regina::LPConstraintBase::constrain | ( | LPData< LPConstraintNone, IntType > & | lp,
|  | unsigned | numCols
| ) |  |

static

Explicitly constraints each of these linear functions to an equality or inequality in the underlying tableaux.

This will typically consist of a series of calls to LPData::constrainZero() and/or LPData::constrainPositive().

The variables for these extra linear functions are stored in columns `numCols - nConstraints`, ..., `numCols - 1` of the given tableaux, and so your calls to LPData::constrainZero() and/or LPData::constrainPositive() should operate on these (and only these) columns.

Precondition
  These column coefficients belong to the initial starting tableaux (LPInitialTableaux) from which the given tableaux is derived.

Parameters

  lp | the tableaux in which to constrain these linear functions.
  numCols | the number of columns in the given tableaux.

## enforceBans()

template<class LPConstraint , typename IntType >

void regina::BanConstraintBase::enforceBans | ( | LPData< LPConstraint, IntType > & | lp | ) | const

inline protected

Enforces all bans described by this class in the given tableaux.

Specifically, for each banned coordinate, this routine calls LPData::constrainZero() on the corresponding coordinate column.

Parameters

  lp | the tableaux in which to enforce the bans.

## fillFinalRows()

template<typename IntType >

void regina::LPConstraintBase::Coefficients::fillFinalRows | ( | LPMatrix< IntType > & | m,
|  | unsigned | col
| ) |  | const

Explicitly fills the final row(s) of the given tableaux matrix with the coefficients stored in this Coefficients structure.

In essence, this routine simply copies this sparse and/or specialised representation of the final row(s) into a more standard dense matrix representation.

This routine should only affect the final nConstraints entries in the given column of the matrix. It may assume that these final row(s) have already been initialised to zero.

Precondition
  The given matrix has at least nConstraints rows and at least col + 1 columns.
  The final nConstraints entries in column col of the given matrix have already been set to zero.

Parameters

  m | the matrix in which to place these column coefficients.
  col | the column of the given matrix in which to place these coefficients.

## init()

void regina::BanConstraintBase::init | ( | const int * | columnPerm | ) |

protected

Identifies which coordinates to ban and mark, and records the corresponding tableaux columns in the banned_ and marked_ arrays respectively.

Parameters

  columnPerm | the permutation of columns that describes how columns of the tableaux correspond to normal or angle strutcure coordinates in the underlying triangulation. Specifically, this permutation must be the same permutation returned by LPInitialTableaux::columnPerm().

## innerProduct()

template<typename IntType >

IntType regina::LPConstraintBase::Coefficients::innerProduct | ( | const LPMatrix< IntType > & | m,
|  | unsigned | mRow
| ) |  | const

Computes the inner product of (i) the final nConstraints entries in the given row of the given matrix with (ii) the nConstraints column coefficients stored in this data structure.

Precondition
  The given matrix has at least nConstraints columns and at least mRow + 1 rows.

Parameters

  m | the matrix whose row we will use in the inner product.
  mRow | the row of the matrix m to use in the inner product.

Returns
  the resulting portion of the inner product.

## innerProductOct()

template<typename IntType >

IntType regina::LPConstraintBase::Coefficients::innerProductOct | ( | const LPMatrix< IntType > & | m,
|  | unsigned | mRow
| ) |  | const

A variant of innerProduct() that takes into account any adjustments to these linear constraint(s) that are required when this is a quadrilateral column being used to represent an octagon type.

The LPData class offers support for octagonal almost normal surfaces, in which exactly one tetrahedron is allowed to have exactly one octagon type. We represent such an octagon as a pair of incompatible quadrilaterals within the same tetrahedron. See the LPData class notes for details on how this works.

In some settings, our extra linear constraints must behave differently in the presence of octagons (i.e., the coefficient of the octagon type is not just the sum of coefficients of the two constituent quadrilateral types). This routine effectively allows us to adjust the tableaux accordingly.

Specifically: this routine computes the inner product of (i) the final nConstraints entries in the given row of the given matrix with (ii) the nConstraints column coefficients stored in this data structure. We assume that this column in the underlying tableaux describes one of the two quadrilateral coordinates in some tetrahedron that together form an octagon type, and if necessary we implicitly adjust the coefficients stored in this data structure accordingly.

This routine is not used with angle structure coordinates.

Precondition
  The given matrix has at least nConstraints columns and at least mRow + 1 rows.
  This column of the underlying tableaux describes one of the two quadrilateral coordinates that are being combined to form an octagon type within some tetrahedron.

Parameters

  m | the matrix whose row we will use in the inner product.
  mRow | the row of the matrix m to use in the inner product.

Returns
  the resulting portion of the inner product.

## supported() [1/2]

static bool regina::LPConstraintBase::supported | ( | NormalCoords | coords | ) |

static

Indicates whether the given coordinate system is supported by this constraint class.

This routine assumes that the given system is already known to be supported by the generic tree traversal infrastructure, and only returns `false` if there are additional prerequisites imposed by this particular constraint class that the given system does not satisfy. If this constraint class does not impose any of its own additional conditions, this routine may simply return `true`.

Parameters

  coords | the coordinate system being queried; this must be one of the coordinate systems known to be supported by the generic TreeTraversal infrastructure.

Returns
  `true` if and only if this coordinate system is also supported by this specific constraint class.

## supported() [2/2]

static bool regina::BanConstraintBase::supported | ( | NormalCoords | coords | ) |

static protected

Indicates whether the given coordinate system is supported by this constraint class.

This routine assumes that the given system is already known to be supported by the generic tree traversal infrastructure, and only returns `false` if there are additional prerequisites imposed by this particular constraint class that the given system does not satisfy. If this constraint class does not impose any of its own additional conditions, this routine may simply return `true`.

Parameters

  coords | the coordinate system being queried; this must be one of the coordinate systems known to be supported by the generic TreeTraversal infrastructure.

Returns
  `true` if and only if this coordinate system is also supported by this specific constraint class.

## verify() [1/2]

static bool regina::LPConstraintBase::verify | ( | const NormalSurface * | s | ) |

static

Ensures that the given normal surface satisfies the extra constraints described by this class.

Ideally this test is not based on explicitly recomputing the linear function(s), but instead runs independent tests. For instance, if this class is used to constraint Euler characteristic, then ideally this routine would call s->eulerChar() and test the return value of that routine instead.

If these linear constraints work with angle structure coordinates (not normal or almost normal surfaces), then this routine should return `false`.

Parameters

  s | the surface to test.

Returns
  `true` if the given surface satisfies these linear constraints, or `false` if it does not.

## verify() [2/2]

static bool regina::LPConstraintBase::verify | ( | const AngleStructure * | s | ) |

static

Ensures that the given angle structure satisfies the extra constraints described by this class.

Ideally this test is not based on explicitly recomputing the linear function(s), but instead runs independent tests; see the related routine verify(const NormalSurface*) for examples.

If these linear constraints work with normal or almost normal surfaces (not angle structure coordinates), then this routine should return `false`.

Parameters

  s | the angle structure to test.

Returns
  `true` if the given angle structure satisfies these linear constraints, or `false` if it does not.

## ~BanConstraintBase()

regina::BanConstraintBase::~BanConstraintBase | ( |  | ) |

inline protected

Destroys this object and all associated data.

## Variable Documentation

## banned_

bool* regina::BanConstraintBase::banned_

protected

Indicates which columns of a tableaux correspond to banned coordinates (e.g., banned normal disc types).

The size of this array is the number of normal or angle structure coordinates (so we explicitly exclude extra columns that arise from the template parameter LPConstraint.

## coords_

int regina::BanConstraintBase::coords_

protected

The normal or almost normal coordinate system in which we are working.

This must be one of NS_QUAD, NS_STANDARD, NS_AN_QUAD_OCT, NS_AN_STANDARD, or NS_ANGLE.

## euler

int regina::LPConstraintEuler::Coefficients::euler

The coefficient of the Euler characteristic function for the corresponding column of the matching equation matrix.

## longitude

int regina::LPConstraintNonSpun::Coefficients::longitude

The coefficient of the longitude equation for the corresponding column of the matching equation matrix.

## marked_

bool* regina::BanConstraintBase::marked_

protected

Indicates which columns of a tableaux correspond to marked coordinates (e.g., marked normal disc types).

The size of this array is the number of normal or angle structure coordinates (so we explicitly exclude extra columns that arise from the template parameter LPConstraint.

## meridian

int regina::LPConstraintNonSpun::Coefficients::meridian

The coefficient of the meridian equation for the corresponding column of the matching equation matrix.

## tri_

const Triangulation<3>* regina::BanConstraintBase::tri_

protected

The triangulation with which we are working.

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