Loading...
Searching...
No Matches
Gudhi::persistence_matrix::Chain_matrix< Master_matrix > Class Template Reference
Persistence Matrix

Matrix structure storing a compatible base of a filtered chain complex. See [zigzag]. The base is constructed from the boundaries of the cells in the complex. Allows the persistent homology to be computed, as well as representative cycles. Supports vineyards (see [vineyards]) and the removal of maximal cells while maintaining a valid barcode. Provides an access to its columns and rows. More...

`#include <gudhi/Persistence_matrix/Chain_matrix.h>`

## Public Types

using | Field_operators = typename Master_matrix::Field_operators
| Field operators class. Necessary only if PersistenceMatrixOptions::is_z2 is false.
using | Field_element = typename Master_matrix::Element
using | Column = typename Master_matrix::Column
using | Row = typename Master_matrix::Row
using | Entry = typename Master_matrix::Matrix_entry
using | Entry_constructor = typename Master_matrix::Entry_constructor
using | Column_settings = typename Master_matrix::Column_settings
using | Boundary = typename Master_matrix::Boundary
using | Entry_representative = typename Master_matrix::Entry_representative
using | Index = typename Master_matrix::Index
using | ID_index = typename Master_matrix::ID_index
using | Pos_index = typename Master_matrix::Pos_index
using | Dimension = typename Master_matrix::Dimension

## Public Member Functions

| Chain_matrix (Column_settings *colSettings)
| Constructs an empty matrix. Only available if PersistenceMatrixOptions::has_column_pairings is true or PersistenceMatrixOptions::has_vine_update is false. Otherwise, birth and death comparators have to be provided.
template<class Boundary_range = Boundary>
| Chain_matrix (const std::vector< Boundary_range > &orderedBoundaries, Column_settings *colSettings)

Constructs a new matrix from the given ranges of Matrix::Entry_representative. Each range corresponds to a column (the order of the ranges are preserved). The content of the ranges is assumed to be sorted by increasing IDs. The IDs of the simplices are also assumed to be consecutive, ordered by filtration value, starting with 0. Only available if PersistenceMatrixOptions::has_column_pairings is true or PersistenceMatrixOptions::has_vine_update is false. Otherwise, birth and death comparators have to be provided.

| Chain_matrix (unsigned int numberOfColumns, Column_settings *colSettings)
| Constructs a new empty matrix and reserves space for the given number of columns. Only available if PersistenceMatrixOptions::has_column_pairings is true or PersistenceMatrixOptions::has_vine_update is false. Otherwise, birth and death comparators have to be provided.
template<typename BirthComparatorFunction, typename DeathComparatorFunction>
| Chain_matrix (Column_settings *colSettings, const BirthComparatorFunction &birthComparator, const DeathComparatorFunction &deathComparator)
| Constructs an empty matrix and stores the given comparators.
template<typename BirthComparatorFunction, typename DeathComparatorFunction, class Boundary_range = Boundary>
| Chain_matrix (const std::vector< Boundary_range > &orderedBoundaries, Column_settings *colSettings, const BirthComparatorFunction &birthComparator, const DeathComparatorFunction &deathComparator)
| Constructs a new matrix from the given ranges of Matrix::Entry_representative. Each range corresponds to a column (the order of the ranges are preserved). The content of the ranges is assumed to be sorted by increasing IDs. The IDs of the simplices are also assumed to be consecutive, ordered by filtration value, starting with 0.
template<typename BirthComparatorFunction, typename DeathComparatorFunction>
| Chain_matrix (unsigned int numberOfColumns, Column_settings *colSettings, const BirthComparatorFunction &birthComparator, const DeathComparatorFunction &deathComparator)
| Constructs a new empty matrix and reserves space for the given number of columns.
| Chain_matrix (const Chain_matrix &matrixToCopy, Column_settings *colSettings=nullptr)
| Copy constructor. If `colSettings` is not a null pointer, its value is kept instead of the one in the copied matrix.
| Chain_matrix (Chain_matrix &&other) noexcept
| Move constructor.
template<class Boundary_range = Boundary>
std::vector< Entry_representative > | insert_boundary (const Boundary_range &boundary, Dimension dim=Master_matrix::template get_null_value< Dimension >())

Inserts at the end of the matrix a new ordered column corresponding to the given boundary. This means that it is assumed that this method is called on boundaries in the order of the filtration. It also assumes that the cells in the given boundary are identified by their relative position in the filtration, starting at 0. If it is not the case, use the other insert_boundary instead by indicating the cell ID used in the boundaries when the cell is inserted.

template<class Boundary_range = Boundary>
std::vector< Entry_representative > | insert_boundary (ID_index cellID, const Boundary_range &boundary, Dimension dim=Master_matrix::template get_null_value< Dimension >())
| It does the same as the other version, but allows the boundary cells to be identified without restrictions except that all IDs have to be strictly increasing in the order of filtration. Note that you should avoid then to use the other insertion method to avoid overwriting IDs.
Column & | get_column (Index columnIndex)
| Returns the column at the given MatIdx index. The type of the column depends on the chosen options, see PersistenceMatrixOptions::column_type.
const Column & | get_column (Index columnIndex) const
| Returns the column at the given MatIdx index. The type of the column depends on the chosen options, see PersistenceMatrixOptions::column_type.
void | remove_maximal_cell (ID_index cellID)

Only available if PersistenceMatrixOptions::has_removable_columns and PersistenceMatrixOptions::has_vine_update are true, as well as, PersistenceMatrixOptions::has_map_column_container and PersistenceMatrixOptions::has_column_pairings. Assumes that the cell is maximal in the current complex and removes it such that the matrix remains consistent (i.e., the matrix is still a compatible bases of the chain complex in the sense of [zigzag]). The maximality of the cell is not verified. Also updates the barcode if it is stored.

void | remove_maximal_cell (ID_index cellID, const std::vector< ID_index > &columnsToSwap)

Only available if PersistenceMatrixOptions::has_removable_columns, PersistenceMatrixOptions::has_vine_update and PersistenceMatrixOptions::has_map_column_container are true. Assumes that the cell is maximal in the current complex and removes it such that the matrix remains consistent (i.e., it is still a compatible bases of the chain complex in the sense of [zigzag]). The maximality of the cell is not verified. Also updates the barcode if it is stored.

void | remove_last ()
| Only available if PersistenceMatrixOptions::has_removable_columns is true and, if PersistenceMatrixOptions::has_map_column_container is true or PersistenceMatrixOptions::has_vine_update is false. Removes the last cell in the filtration from the matrix and updates the barcode if it is stored.
Index | get_number_of_columns () const
| Returns the current number of columns in the matrix.
Dimension | get_column_dimension (Index columnIndex) const
| Returns the dimension of the given column.
void | add_to (Index sourceColumnIndex, Index targetColumnIndex)
| Adds column at `sourceColumnIndex` onto the column at `targetColumnIndex` in the matrix.
void | multiply_target_and_add_to (Index sourceColumnIndex, const Field_element &coefficient, Index targetColumnIndex)
| Multiplies the target column with the coefficient and then adds the source column to it. That is: targetColumn = (targetColumn * coefficient) + sourceColumn.
void | multiply_source_and_add_to (const Field_element &coefficient, Index sourceColumnIndex, Index targetColumnIndex)
| Multiplies the source column with the coefficient before adding it to the target column. That is: targetColumn += (coefficient * sourceColumn). The source column will not be modified.
bool | is_zero_entry (Index columnIndex, ID_index rowIndex) const
| Indicates if the entry at given coordinates has value zero.
bool | is_zero_column (Index columnIndex)
| Indicates if the column at given index has value zero. Note that if the matrix is valid, this method should always return false.
Index | get_column_with_pivot (ID_index cellID) const
| Returns the column with given row index as pivot. Assumes that the pivot exists.
ID_index | get_pivot (Index columnIndex)
| Returns the row index of the pivot of the given column.
void | reset (Column_settings *colSettings)
| Resets the matrix to an empty matrix.
Chain_matrix & | operator= (const Chain_matrix &other)
| Assign operator.

## Friends

void | swap (Chain_matrix &matrix1, Chain_matrix &matrix2)
| Swap operator.

## Detailed Description

template<class Master_matrix>
class Gudhi::persistence_matrix::Chain_matrix< Master_matrix >

Matrix structure storing a compatible base of a filtered chain complex. See [zigzag]. The base is constructed from the boundaries of the cells in the complex. Allows the persistent homology to be computed, as well as representative cycles. Supports vineyards (see [vineyards]) and the removal of maximal cells while maintaining a valid barcode. Provides an access to its columns and rows.

Template Parameters

  Master_matrix | An instantiation of Matrix from which all types and options are deduced.

## Member Typedef Documentation

## Boundary

template<class Master_matrix>

using Gudhi::persistence_matrix::Chain_matrix< Master_matrix >::Boundary = typename Master_matrix::Boundary

Type of an input column.

## Column

template<class Master_matrix>

using Gudhi::persistence_matrix::Chain_matrix< Master_matrix >::Column = typename Master_matrix::Column

Column type.

## Column_settings

template<class Master_matrix>

using Gudhi::persistence_matrix::Chain_matrix< Master_matrix >::Column_settings = typename Master_matrix::Column_settings

Structure giving access to the columns to necessary external classes.

## Dimension

template<class Master_matrix>

using Gudhi::persistence_matrix::Chain_matrix< Master_matrix >::Dimension = typename Master_matrix::Dimension

Dimension value type.

## Entry

template<class Master_matrix>

using Gudhi::persistence_matrix::Chain_matrix< Master_matrix >::Entry = typename Master_matrix::Matrix_entry

Matrix entry type.

## Entry_constructor

template<class Master_matrix>

using Gudhi::persistence_matrix::Chain_matrix< Master_matrix >::Entry_constructor = typename Master_matrix::Entry_constructor

Factory of Entry classes.

## Entry_representative

template<class Master_matrix>

using Gudhi::persistence_matrix::Chain_matrix< Master_matrix >::Entry_representative = typename Master_matrix::Entry_representative

Entry content representative.

## Field_element

template<class Master_matrix>

using Gudhi::persistence_matrix::Chain_matrix< Master_matrix >::Field_element = typename Master_matrix::Element

Type of an field element.

## ID_index

template<class Master_matrix>

using Gudhi::persistence_matrix::Chain_matrix< Master_matrix >::ID_index = typename Master_matrix::ID_index

IDIdx index type.

## Index

template<class Master_matrix>

using Gudhi::persistence_matrix::Chain_matrix< Master_matrix >::Index = typename Master_matrix::Index

MatIdx index type.

## Pos_index

template<class Master_matrix>

using Gudhi::persistence_matrix::Chain_matrix< Master_matrix >::Pos_index = typename Master_matrix::Pos_index

PosIdx index type.

## Row

template<class Master_matrix>

using Gudhi::persistence_matrix::Chain_matrix< Master_matrix >::Row = typename Master_matrix::Row

Row type, only necessary with row access option.

## Constructor & Destructor Documentation

## Chain_matrix() [1/8]

template<class Master_matrix>

Gudhi::persistence_matrix::Chain_matrix< Master_matrix >::Chain_matrix | ( | Column_settings * | colSettings | ) |

inline

Constructs an empty matrix. Only available if PersistenceMatrixOptions::has_column_pairings is true or PersistenceMatrixOptions::has_vine_update is false. Otherwise, birth and death comparators have to be provided.

Parameters

  colSettings | Pointer to an existing setting structure for the columns. The structure should contain all the necessary external classes specifically necessary for the chosen column type, such as custom allocators.

## Chain_matrix() [2/8]

template<class Master_matrix>
template<class Boundary_range>

Gudhi::persistence_matrix::Chain_matrix< Master_matrix >::Chain_matrix | ( | const std::vector< Boundary_range > & | orderedBoundaries,
|  | Column_settings * | colSettings )

inline

Constructs a new matrix from the given ranges of Matrix::Entry_representative. Each range corresponds to a column (the order of the ranges are preserved). The content of the ranges is assumed to be sorted by increasing IDs. The IDs of the simplices are also assumed to be consecutive, ordered by filtration value, starting with 0. Only available if PersistenceMatrixOptions::has_column_pairings is true or PersistenceMatrixOptions::has_vine_update is false. Otherwise, birth and death comparators have to be provided.

Template Parameters

  Boundary_range | Range type for Matrix::Entry_representative ranges. Assumed to have a begin(), end() and size() method.

Parameters

  orderedBoundaries

  Range of boundaries: `orderedBoundaries` is interpreted as a boundary matrix of a filtered simplicial complex, whose boundaries are ordered by filtration order. Therefore, orderedBoundaries[i] should store the boundary of the \( i^{th} \) simplex in the filtration, as an ordered list of indices of its facets (again those indices correspond to their respective position in the matrix). That is why the indices of the simplices are assumed to be consecutive and starting with 0 (an empty boundary is interpreted as a vertex boundary and not as a non existing simplex). All dimensions up to the maximal dimension of interest have to be present. If only a higher dimension is of interest and not everything should be stored, then use the insert_boundary method instead (after creating the matrix with the Chain_matrix(unsigned int numberOfColumns, Column_settings* colSettings) constructor preferably).

  colSettings | Pointer to an existing setting structure for the columns. The structure should contain all the necessary external classes specifically necessary for the chosen column type, such as custom allocators.

## Chain_matrix() [3/8]

template<class Master_matrix>

Gudhi::persistence_matrix::Chain_matrix< Master_matrix >::Chain_matrix | ( | unsigned int | numberOfColumns,
|  | Column_settings * | colSettings )

inline

Constructs a new empty matrix and reserves space for the given number of columns. Only available if PersistenceMatrixOptions::has_column_pairings is true or PersistenceMatrixOptions::has_vine_update is false. Otherwise, birth and death comparators have to be provided.

Parameters

  numberOfColumns | Number of columns to reserve space for.
  colSettings | Pointer to an existing setting structure for the columns. The structure should contain all the necessary external classes specifically necessary for the chosen column type, such as custom allocators.

## Chain_matrix() [4/8]

template<class Master_matrix>
template<typename BirthComparatorFunction, typename DeathComparatorFunction>

Gudhi::persistence_matrix::Chain_matrix< Master_matrix >::Chain_matrix | ( | Column_settings * | colSettings,
|  | const BirthComparatorFunction & | birthComparator,
|  | const DeathComparatorFunction & | deathComparator )

inline

Constructs an empty matrix and stores the given comparators.

Warning
  If PersistenceMatrixOptions::has_vine_update is false, the comparators are not used. And if PersistenceMatrixOptions::has_vine_update is true, but PersistenceMatrixOptions::has_column_pairings is also true, the comparators are ignored and the current barcode is used to compare birth and deaths. Therefore it is useless to provide them in those cases.

Template Parameters

  BirthComparatorFunction | Type of the birth comparator: (Pos_index, Pos_index) -> bool
  DeathComparatorFunction | Type of the death comparator: (Pos_index, Pos_index) -> bool

Parameters

  colSettings | Pointer to an existing setting structure for the columns. The structure should contain all the necessary external classes specifically necessary for the chosen column type, such as custom allocators.
  birthComparator | Method taking two PosIdx indices as input and returning true if and only if the birth associated to the first position is strictly less than birth associated to the second one with respect to some self defined order. It is used while swapping two unpaired or two negative columns.
  deathComparator | Method taking two PosIdx indices as input and returning true if and only if the death associated to the first position is strictly less than death associated to the second one with respect to some self defined order. It is used while swapping two positive but paired columns.

## Chain_matrix() [5/8]

template<class Master_matrix>
template<typename BirthComparatorFunction, typename DeathComparatorFunction, class Boundary_range>

Gudhi::persistence_matrix::Chain_matrix< Master_matrix >::Chain_matrix | ( | const std::vector< Boundary_range > & | orderedBoundaries,
|  | Column_settings * | colSettings,
|  | const BirthComparatorFunction & | birthComparator,
|  | const DeathComparatorFunction & | deathComparator )

inline

Constructs a new matrix from the given ranges of Matrix::Entry_representative. Each range corresponds to a column (the order of the ranges are preserved). The content of the ranges is assumed to be sorted by increasing IDs. The IDs of the simplices are also assumed to be consecutive, ordered by filtration value, starting with 0.

Warning
  If PersistenceMatrixOptions::has_vine_update is false, the comparators are not used. And if PersistenceMatrixOptions::has_vine_update is true, but PersistenceMatrixOptions::has_column_pairings is also true, the comparators are ignored and the current barcode is used to compare birth and deaths. Therefore it is useless to provide them in those cases.

Template Parameters

  BirthComparatorFunction | Type of the birth comparator: (Pos_index, Pos_index) -> bool
  DeathComparatorFunction | Type of the death comparator: (Pos_index, Pos_index) -> bool
  Boundary_range | Range type for Matrix::Entry_representative ranges. Assumed to have a begin(), end() and size() method.

Parameters

  orderedBoundaries

  Range of boundaries: `orderedBoundaries` is interpreted as a boundary matrix of a filtered simplicial complex, whose boundaries are ordered by filtration order. Therefore, orderedBoundaries[i] should store the boundary of the \( i^{th} \) simplex in the filtration, as an ordered list of indices of its facets (again those indices correspond to their respective position in the matrix). That is why the indices of the simplices are assumed to be consecutive and starting with 0 (an empty boundary is interpreted as a vertex boundary and not as a non existing simplex). All dimensions up to the maximal dimension of interest have to be present. If only a higher dimension is of interest and not everything should be stored, then use the insert_boundary method instead (after creating the matrix with the Chain_matrix(unsigned int, Column_settings*, const BirthComparatorFunction&, const DeathComparatorFunction&) constructor preferably).

  colSettings | Pointer to an existing setting structure for the columns. The structure should contain all the necessary external classes specifically necessary for the chosen column type, such as custom allocators.
  birthComparator | Method taking two PosIdx indices as input and returning true if and only if the birth associated to the first position is strictly less than birth associated to the second one with respect to some self defined order. It is used while swapping two unpaired or two negative columns.
  deathComparator | Method taking two PosIdx indices as input and returning true if and only if the death associated to the first position is strictly less than death associated to the second one with respect to some self defined order. It is used while swapping two positive but paired columns.

## Chain_matrix() [6/8]

template<class Master_matrix>
template<typename BirthComparatorFunction, typename DeathComparatorFunction>

Gudhi::persistence_matrix::Chain_matrix< Master_matrix >::Chain_matrix | ( | unsigned int | numberOfColumns,
|  | Column_settings * | colSettings,
|  | const BirthComparatorFunction & | birthComparator,
|  | const DeathComparatorFunction & | deathComparator )

inline

Constructs a new empty matrix and reserves space for the given number of columns.

Warning
  If PersistenceMatrixOptions::has_vine_update is false, the comparators are not used. And if PersistenceMatrixOptions::has_vine_update is true, but PersistenceMatrixOptions::has_column_pairings is also true, the comparators are ignored and the current barcode is used to compare birth and deaths. Therefore it is useless to provide them in those cases.

Template Parameters

  BirthComparatorFunction | Type of the birth comparator: (Pos_index, Pos_index) -> bool
  DeathComparatorFunction | Type of the death comparator: (Pos_index, Pos_index) -> bool

Parameters

  numberOfColumns | Number of columns to reserve space for.
  colSettings | Pointer to an existing setting structure for the columns. The structure should contain all the necessary external classes specifically necessary for the chosen column type, such as custom allocators.
  birthComparator | Method taking two PosIdx indices as input and returning true if and only if the birth associated to the first position is strictly less than birth associated to the second one with respect to some self defined order. It is used while swapping two unpaired or two negative columns.
  deathComparator | Method taking two PosIdx indices as input and returning true if and only if the death associated to the first position is strictly less than death associated to the second one with respect to some self defined order. It is used while swapping two positive but paired columns.

## Chain_matrix() [7/8]

template<class Master_matrix>

Gudhi::persistence_matrix::Chain_matrix< Master_matrix >::Chain_matrix | ( | const Chain_matrix< Master_matrix > & | matrixToCopy,
|  | Column_settings * | colSettings = nullptr )

inline

Copy constructor. If `colSettings` is not a null pointer, its value is kept instead of the one in the copied matrix.

Parameters

  matrixToCopy | Matrix to copy.
  colSettings | Either a pointer to an existing setting structure for the columns or a null pointer. The structure should contain all the necessary external classes specifically necessary for the chosen column type, such as custom allocators. If null pointer, the pointer stored in `matrixToCopy` is used instead.

## Chain_matrix() [8/8]

template<class Master_matrix>

Gudhi::persistence_matrix::Chain_matrix< Master_matrix >::Chain_matrix | ( | Chain_matrix< Master_matrix > && | other | ) |

inline noexcept

Move constructor.

Parameters

  other | Matrix to move.

## Member Function Documentation

## add_to()

template<class Master_matrix>

void Gudhi::persistence_matrix::Chain_matrix< Master_matrix >::add_to | ( | Index | sourceColumnIndex,
|  | Index | targetColumnIndex )

inline

Adds column at `sourceColumnIndex` onto the column at `targetColumnIndex` in the matrix.

Warning
  They will be no verification to ensure that the addition makes sense for the validity of a chain matrix. For example, a right-to-left addition could corrupt the computation of the barcode if done blindly. So should be used with care.

Parameters

  sourceColumnIndex | MatIdx index of the source column.
  targetColumnIndex | MatIdx index of the target column.

## get_column() [1/2]

template<class Master_matrix>

Chain_matrix< Master_matrix >::Column & Gudhi::persistence_matrix::Chain_matrix< Master_matrix >::get_column | ( | Index | columnIndex | ) |

inline

Returns the column at the given MatIdx index. The type of the column depends on the chosen options, see PersistenceMatrixOptions::column_type.

Parameters

  columnIndex | MatIdx index of the column to return.

Returns
  Reference to the column.

## get_column() [2/2]

template<class Master_matrix>

const Chain_matrix< Master_matrix >::Column & Gudhi::persistence_matrix::Chain_matrix< Master_matrix >::get_column | ( | Index | columnIndex | ) | const

inline

Returns the column at the given MatIdx index. The type of the column depends on the chosen options, see PersistenceMatrixOptions::column_type.

Parameters

  columnIndex | MatIdx index of the column to return.

Returns
  Const reference to the column.

## get_column_dimension()

template<class Master_matrix>

Chain_matrix< Master_matrix >::Dimension Gudhi::persistence_matrix::Chain_matrix< Master_matrix >::get_column_dimension | ( | Index | columnIndex | ) | const

inline

Returns the dimension of the given column.

Parameters

  columnIndex | MatIdx index of the column representing the cell.

Returns
  Dimension of the cell.

## get_column_with_pivot()

template<class Master_matrix>

Chain_matrix< Master_matrix >::Index Gudhi::persistence_matrix::Chain_matrix< Master_matrix >::get_column_with_pivot | ( | ID_index | cellID | ) | const

inline

Returns the column with given row index as pivot. Assumes that the pivot exists.

Parameters

  cellID | Row index of the pivot.

Returns
  MatIdx index of the column with the given pivot.

## get_number_of_columns()

template<class Master_matrix>

Chain_matrix< Master_matrix >::Index Gudhi::persistence_matrix::Chain_matrix< Master_matrix >::get_number_of_columns | ( |  | ) | const

inline

Returns the current number of columns in the matrix.

Returns
  The number of columns.

## get_pivot()

template<class Master_matrix>

Chain_matrix< Master_matrix >::ID_index Gudhi::persistence_matrix::Chain_matrix< Master_matrix >::get_pivot | ( | Index | columnIndex | ) |

inline

Returns the row index of the pivot of the given column.

Parameters

  columnIndex | MatIdx index of the column

Returns
  The row index of the pivot.

## insert_boundary() [1/2]

template<class Master_matrix>
template<class Boundary_range = Boundary>

std::vector< Entry_representative > Gudhi::persistence_matrix::Chain_matrix< Master_matrix >::insert_boundary | ( | const Boundary_range & | boundary,
|  | Dimension | dim = Master_matrix::template get_null_value< Dimension >() )

Inserts at the end of the matrix a new ordered column corresponding to the given boundary. This means that it is assumed that this method is called on boundaries in the order of the filtration. It also assumes that the cells in the given boundary are identified by their relative position in the filtration, starting at 0. If it is not the case, use the other insert_boundary instead by indicating the cell ID used in the boundaries when the cell is inserted.

Different to the constructor, the boundaries do not have to come from a simplicial complex, but also from a more general entry complex. This includes cubical complexes or Morse complexes for example.

When inserted, the given boundary is reduced and from the reduction process, the column is deduced in the form of: IDIdx + linear combination of older column IDIdxs. If the barcode is stored, it will be updated.

Template Parameters

  Boundary_range | Range of Matrix::Entry_representative. Assumed to have a begin(), end() and size() method.

Parameters

  boundary | Boundary generating the new column. The content should be ordered by ID.
  dim | Dimension of the cell whose boundary is given. If the complex is simplicial, this parameter can be omitted as it can be deduced from the size of the boundary.

Returns
  The MatIdx indices of the unpaired chains used to reduce the boundary.

## insert_boundary() [2/2]

template<class Master_matrix>
template<class Boundary_range = Boundary>

std::vector< Entry_representative > Gudhi::persistence_matrix::Chain_matrix< Master_matrix >::insert_boundary | ( | ID_index | cellID,
|  | const Boundary_range & | boundary,
|  | Dimension | dim = Master_matrix::template get_null_value< Dimension >() )

It does the same as the other version, but allows the boundary cells to be identified without restrictions except that all IDs have to be strictly increasing in the order of filtration. Note that you should avoid then to use the other insertion method to avoid overwriting IDs.

As a cell has to be inserted before one of its cofaces in a valid filtration (recall that it is assumed that the cells are inserted by order of filtration), it is sufficient to indicate the ID of the cell being inserted.

Template Parameters

  Boundary_range | Range of Matrix::Entry_representative. Assumed to have a begin(), end() and size() method.

Parameters

  cellID | IDIdx index to use to identify the new cell.
  boundary | Boundary generating the new column. The indices of the boundary have to correspond to the `cellID` values of precedent calls of the method for the corresponding cells and should be ordered in increasing order.
  dim | Dimension of the cell whose boundary is given. If the complex is simplicial, this parameter can be omitted as it can be deduced from the size of the boundary.

Returns
  The MatIdx index of the inserted boundary.

## is_zero_column()

template<class Master_matrix>

bool Gudhi::persistence_matrix::Chain_matrix< Master_matrix >::is_zero_column | ( | Index | columnIndex | ) |

inline

Indicates if the column at given index has value zero. Note that if the matrix is valid, this method should always return false.

Parameters

  columnIndex | MatIdx index of the column.

Returns
  true If the column has value zero.
  false Otherwise.

## is_zero_entry()

template<class Master_matrix>

bool Gudhi::persistence_matrix::Chain_matrix< Master_matrix >::is_zero_entry | ( | Index | columnIndex,
|  | ID_index | rowIndex ) const

inline

Indicates if the entry at given coordinates has value zero.

Parameters

  columnIndex | MatIdx index of the column of the entry.
  rowIndex | Row index of the row of the entry.

Returns
  true If the entry has value zero.
  false Otherwise.

## multiply_source_and_add_to()

template<class Master_matrix>

void Gudhi::persistence_matrix::Chain_matrix< Master_matrix >::multiply_source_and_add_to | ( | const Field_element & | coefficient,
|  | Index | sourceColumnIndex,
|  | Index | targetColumnIndex )

inline

Multiplies the source column with the coefficient before adding it to the target column. That is: targetColumn += (coefficient * sourceColumn). The source column will not be modified.

Warning
  They will be no verification to ensure that the addition makes sense for the validity of a chain matrix. For example, a right-to-left addition could corrupt the computation of the barcode if done blindly. So should be used with care.

Parameters

  coefficient | Value to multiply.
  sourceColumnIndex | MatIdx index of the source column.
  targetColumnIndex | MatIdx index of the target column.

## multiply_target_and_add_to()

template<class Master_matrix>

void Gudhi::persistence_matrix::Chain_matrix< Master_matrix >::multiply_target_and_add_to | ( | Index | sourceColumnIndex,
|  | const Field_element & | coefficient,
|  | Index | targetColumnIndex )

inline

Multiplies the target column with the coefficient and then adds the source column to it. That is: targetColumn = (targetColumn * coefficient) + sourceColumn.

Warning
  They will be no verification to ensure that the addition makes sense for the validity of a chain matrix. For example, a right-to-left addition could corrupt the computation of the barcode if done blindly. So should be used with care.

Parameters

  sourceColumnIndex | MatIdx index of the source column.
  coefficient | Value to multiply.
  targetColumnIndex | MatIdx index of the target column.

## remove_last()

template<class Master_matrix>

void Gudhi::persistence_matrix::Chain_matrix< Master_matrix >::remove_last | ( |  | ) |

inline

Only available if PersistenceMatrixOptions::has_removable_columns is true and, if PersistenceMatrixOptions::has_map_column_container is true or PersistenceMatrixOptions::has_vine_update is false. Removes the last cell in the filtration from the matrix and updates the barcode if it is stored.

See also remove_maximal_cell.

Warning
  If PersistenceMatrixOptions::has_vine_update is true, the last cell does not have to be at the end of the matrix container and therefore has to be searched first. In this case, if the user already knows the IDIdx of the last cell, calling remove_maximal_cell(cellID, {}) instead allows to skip the search.

## remove_maximal_cell() [1/2]

template<class Master_matrix>

void Gudhi::persistence_matrix::Chain_matrix< Master_matrix >::remove_maximal_cell | ( | ID_index | cellID | ) |

inline

Only available if PersistenceMatrixOptions::has_removable_columns and PersistenceMatrixOptions::has_vine_update are true, as well as, PersistenceMatrixOptions::has_map_column_container and PersistenceMatrixOptions::has_column_pairings. Assumes that the cell is maximal in the current complex and removes it such that the matrix remains consistent (i.e., the matrix is still a compatible bases of the chain complex in the sense of [zigzag]). The maximality of the cell is not verified. Also updates the barcode if it is stored.

Note that using the other version of the method could perform better depending on how the data is maintained on the side of the user, that is, if providing the second parameter is easy.

See also remove_last.

Parameters

  cellID | IDIdx index of the cell to remove

## remove_maximal_cell() [2/2]

template<class Master_matrix>

void Gudhi::persistence_matrix::Chain_matrix< Master_matrix >::remove_maximal_cell | ( | ID_index | cellID,
|  | const std::vector< ID_index > & | columnsToSwap )

inline

Only available if PersistenceMatrixOptions::has_removable_columns, PersistenceMatrixOptions::has_vine_update and PersistenceMatrixOptions::has_map_column_container are true. Assumes that the cell is maximal in the current complex and removes it such that the matrix remains consistent (i.e., it is still a compatible bases of the chain complex in the sense of [zigzag]). The maximality of the cell is not verified. Also updates the barcode if it is stored.

To maintain the compatibility, vine swaps are done to move the cell up to the end of the filtration. Once at the end, the removal is trivial. But for chain matrices, swaps do not actually swap the position of the column every time, so the cells appearing after `cellID` in the filtration have to be searched first within the matrix. If the user has an easy access to the IDIdx of the cells in the order of filtration, passing them by argument with `columnsToSwap` allows to skip a linear search process. Typically, if the user knows that the cell he wants to remove is already the last cell of the filtration, calling remove_maximal_cell(cellID, {}) will be faster than remove_last().

See also remove_last.

Parameters

  cellID | IDIdx index of the cell to remove
  columnsToSwap | Vector of IDIdx indices of the cells coming after `cellID` in the filtration.

## reset()

template<class Master_matrix>

void Gudhi::persistence_matrix::Chain_matrix< Master_matrix >::reset | ( | Column_settings * | colSettings | ) |

inline

Resets the matrix to an empty matrix.

Parameters

  colSettings | Pointer to an existing setting structure for the columns. The structure should contain all the necessary external classes specifically necessary for the chosen column type, such as custom allocators.

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

- include/gudhi/Persistence_matrix/Chain_matrix.h