Id_to_index_overlay.h

Go to the documentation of this file.

/*    This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
 *    See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
 *    Author(s):       Hannah Schreiber
 *
 *    Copyright (C) 2022 Inria
 *
 *    Modification(s):
 *      - YYYY/MM Author: Description of the modification
 */

 
#ifndef PM_ID_TO_POS_TRANSLATION_H
#define PM_ID_TO_POS_TRANSLATION_H
 
#include <vector>
#include <cassert>
#include <utility>    //std::swap, std::move & std::exchange
#include <algorithm>  //std::transform
#include <stdexcept>  //std::invalid_argument
 
namespace Gudhi {
namespace persistence_matrix {

template <class Underlying_matrix, class Master_matrix>
class Id_to_index_overlay
{
 public:
  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; 
  using Field_operators = typename Master_matrix::Field_operators;
  using Field_element = typename Master_matrix::Element;               
  using Boundary = typename Master_matrix::Boundary;                   
  using Column = typename Master_matrix::Column;                       
  using Row = typename Master_matrix::Row;                             
  using Bar = typename Master_matrix::Bar;                             
  using Barcode = typename Master_matrix::Barcode;                     
  using Cycle = typename Master_matrix::Cycle;                         
  using Entry_constructor = typename Master_matrix::Entry_constructor; 
  using Column_settings = typename Master_matrix::Column_settings;     

  Id_to_index_overlay(Column_settings* colSettings);
  template <class Boundary_range = Boundary>
  Id_to_index_overlay(const std::vector<Boundary_range>& orderedBoundaries, Column_settings* colSettings);
  Id_to_index_overlay(unsigned int numberOfColumns, Column_settings* colSettings);
  template <typename BirthComparatorFunction, typename DeathComparatorFunction>
  Id_to_index_overlay(Column_settings* colSettings,
                      const BirthComparatorFunction& birthComparator,
                      const DeathComparatorFunction& deathComparator);
  template <typename BirthComparatorFunction, typename DeathComparatorFunction, class Boundary_range>
  Id_to_index_overlay(const std::vector<Boundary_range>& orderedBoundaries,
                      Column_settings* colSettings,
                      const BirthComparatorFunction& birthComparator,
                      const DeathComparatorFunction& deathComparator);
  template <typename BirthComparatorFunction, typename DeathComparatorFunction>
  Id_to_index_overlay(unsigned int numberOfColumns,
                      Column_settings* colSettings,
                      const BirthComparatorFunction& birthComparator,
                      const DeathComparatorFunction& deathComparator);
  Id_to_index_overlay(const Id_to_index_overlay& matrixToCopy, Column_settings* colSettings = nullptr);
  Id_to_index_overlay(Id_to_index_overlay&& other) noexcept;
  ~Id_to_index_overlay();

  template <class Boundary_range = Boundary>
  void insert_boundary(const Boundary_range& boundary,
                       Dimension dim = Master_matrix::template get_null_value<Dimension>());
  template <class Boundary_range = Boundary>
  void insert_boundary(ID_index cellIndex,
                       const Boundary_range& boundary,
                       Dimension dim = Master_matrix::template get_null_value<Dimension>());
  template <class Boundary_range = Boundary>
  void insert_maximal_cell(Index columnIndex,
                           const Boundary_range& boundary,
                           Dimension dim = Master_matrix::template get_null_value<Dimension>());
  template <class Boundary_range = Boundary>
  void insert_maximal_cell(Index columnIndex,
                           ID_index cellIndex,
                           const Boundary_range& boundary,
                           Dimension dim = Master_matrix::template get_null_value<Dimension>());
  Column& get_column(ID_index cellID);
  Row& get_row(ID_index rowIndex);
  void erase_empty_row(ID_index rowIndex);
  void remove_maximal_cell(ID_index cellID);
  void remove_maximal_cell(ID_index cellID, const std::vector<ID_index>& columnsToSwap);
  void remove_last();

  Dimension get_max_dimension() const;
  Index get_number_of_columns() const;
  Dimension get_column_dimension(ID_index cellID) const;

  void add_to(ID_index sourceCellID, ID_index targetCellID);
  void multiply_target_and_add_to(ID_index sourceCellID, const Field_element& coefficient, ID_index targetCellID);
  void multiply_source_and_add_to(const Field_element& coefficient, ID_index sourceCellID, ID_index targetCellID);

  void zero_entry(ID_index cellID, ID_index rowIndex);
  void zero_column(ID_index cellID);
  bool is_zero_entry(ID_index cellID, ID_index rowIndex) const;
  bool is_zero_column(ID_index cellID);

  ID_index get_column_with_pivot(ID_index cellIndex) const;
  ID_index get_pivot(ID_index cellID);

  void reset(Column_settings* colSettings)
  {
    matrix_.reset(colSettings);
    if constexpr (Master_matrix::Option_list::is_of_boundary_type)
      if (idToIndex_ != nullptr) idToIndex_->clear();
    nextIndex_ = 0;
  }

  Id_to_index_overlay& operator=(const Id_to_index_overlay& other);
  Id_to_index_overlay& operator=(Id_to_index_overlay&& other) noexcept;

  friend void swap(Id_to_index_overlay& matrix1, Id_to_index_overlay& matrix2) noexcept
  {
    swap(matrix1.matrix_, matrix2.matrix_);
    std::swap(matrix1.idToIndex_, matrix2.idToIndex_);
    std::swap(matrix1.nextIndex_, matrix2.nextIndex_);
  }
 
  void print();  // for debug
 
  // access to optional methods

  const Barcode& get_current_barcode();

  void swap_columns(ID_index cellID1, ID_index cellID2);
  void swap_rows(Index rowIndex1, Index rowIndex2);
  ID_index vine_swap_with_z_eq_1_case(ID_index cellID1, ID_index cellID2);
  ID_index vine_swap(ID_index cellID1, ID_index cellID2);

  void update_all_representative_cycles(Dimension dim = Master_matrix::template get_null_value<Dimension>());
  void update_representative_cycle(const Bar& bar);
  const std::vector<Cycle>& get_all_representative_cycles() const;
  const Cycle& get_representative_cycle(const Bar& bar) const;
 
 private:
  using Dictionary = typename Master_matrix::template Dictionary<Index>;
 
  Underlying_matrix matrix_; 
  Dictionary* idToIndex_;    
  Index nextIndex_;          
 
  void _initialize_map(unsigned int size);
  Index _id_to_index(ID_index id) const;
  Index& _id_to_index(ID_index id);
 
  template <bool dir>
  void _move_column_in_RU(Pos_index start, Pos_index end);
};
 
template <class Underlying_matrix, class Master_matrix>
inline Id_to_index_overlay<Underlying_matrix, Master_matrix>::Id_to_index_overlay(Column_settings* colSettings)
    : matrix_(colSettings), idToIndex_(nullptr), nextIndex_(0)
{
  _initialize_map(0);
}
 
template <class Underlying_matrix, class Master_matrix>
template <class Boundary_range>
inline Id_to_index_overlay<Underlying_matrix, Master_matrix>::Id_to_index_overlay(
    const std::vector<Boundary_range>& orderedBoundaries,
    Column_settings* colSettings)
    : matrix_(orderedBoundaries, colSettings), idToIndex_(nullptr), nextIndex_(orderedBoundaries.size())
{
  _initialize_map(orderedBoundaries.size());
  if constexpr (Master_matrix::Option_list::is_of_boundary_type) {
    for (unsigned int i = 0; i < orderedBoundaries.size(); i++) {
      _id_to_index(i) = i;
    }
  }
}
 
template <class Underlying_matrix, class Master_matrix>
inline Id_to_index_overlay<Underlying_matrix, Master_matrix>::Id_to_index_overlay(unsigned int numberOfColumns,
                                                                                  Column_settings* colSettings)
    : matrix_(numberOfColumns, colSettings), idToIndex_(nullptr), nextIndex_(0)
{
  _initialize_map(numberOfColumns);
}
 
template <class Underlying_matrix, class Master_matrix>
template <typename BirthComparatorFunction, typename DeathComparatorFunction>
inline Id_to_index_overlay<Underlying_matrix, Master_matrix>::Id_to_index_overlay(
    Column_settings* colSettings,
    const BirthComparatorFunction& birthComparator,
    const DeathComparatorFunction& deathComparator)
    : matrix_(colSettings, birthComparator, deathComparator), idToIndex_(nullptr), nextIndex_(0)
{
  _initialize_map(0);
}
 
template <class Underlying_matrix, class Master_matrix>
template <typename BirthComparatorFunction, typename DeathComparatorFunction, class Boundary_range>
inline Id_to_index_overlay<Underlying_matrix, Master_matrix>::Id_to_index_overlay(
    const std::vector<Boundary_range>& orderedBoundaries,
    Column_settings* colSettings,
    const BirthComparatorFunction& birthComparator,
    const DeathComparatorFunction& deathComparator)
    : matrix_(orderedBoundaries, colSettings, birthComparator, deathComparator),
      idToIndex_(nullptr),
      nextIndex_(orderedBoundaries.size())
{
  _initialize_map(orderedBoundaries.size());
  if constexpr (Master_matrix::Option_list::is_of_boundary_type) {
    for (unsigned int i = 0; i < orderedBoundaries.size(); i++) {
      _id_to_index(i) = i;
    }
  }
}
 
template <class Underlying_matrix, class Master_matrix>
template <typename BirthComparatorFunction, typename DeathComparatorFunction>
inline Id_to_index_overlay<Underlying_matrix, Master_matrix>::Id_to_index_overlay(
    unsigned int numberOfColumns,
    Column_settings* colSettings,
    const BirthComparatorFunction& birthComparator,
    const DeathComparatorFunction& deathComparator)
    : matrix_(numberOfColumns, colSettings, birthComparator, deathComparator), idToIndex_(nullptr), nextIndex_(0)
{
  _initialize_map(numberOfColumns);
}
 
template <class Underlying_matrix, class Master_matrix>
inline Id_to_index_overlay<Underlying_matrix, Master_matrix>::Id_to_index_overlay(
    const Id_to_index_overlay& matrixToCopy,
    Column_settings* colSettings)
    : matrix_(matrixToCopy.matrix_, colSettings), idToIndex_(nullptr), nextIndex_(matrixToCopy.nextIndex_)
{
  if constexpr (Master_matrix::Option_list::is_of_boundary_type) {
    idToIndex_ = new Dictionary(*matrixToCopy.idToIndex_);
  } else {
    idToIndex_ = &matrix_.pivotToColumnIndex_;
  }
}
 
template <class Underlying_matrix, class Master_matrix>
inline Id_to_index_overlay<Underlying_matrix, Master_matrix>::Id_to_index_overlay(Id_to_index_overlay&& other) noexcept
    : matrix_(std::move(other.matrix_)),
      idToIndex_(std::exchange(other.idToIndex_, nullptr)),
      nextIndex_(std::exchange(other.nextIndex_, 0))
{
}
 
template <class Underlying_matrix, class Master_matrix>
inline Id_to_index_overlay<Underlying_matrix, Master_matrix>::~Id_to_index_overlay()
{
  if constexpr (Master_matrix::Option_list::is_of_boundary_type) {
    delete idToIndex_;
  }
}
 
template <class Underlying_matrix, class Master_matrix>
template <class Boundary_range>
inline void Id_to_index_overlay<Underlying_matrix, Master_matrix>::insert_boundary(const Boundary_range& boundary,
                                                                                   Dimension dim)
{
  matrix_.insert_boundary(boundary, dim);
  if constexpr (Master_matrix::Option_list::is_of_boundary_type) {
    if constexpr (Master_matrix::Option_list::has_map_column_container) {
      idToIndex_->emplace(nextIndex_, nextIndex_);
    } else {
      if (idToIndex_->size() == nextIndex_) {
        idToIndex_->push_back(nextIndex_);
      } else {
        _id_to_index(nextIndex_) = nextIndex_;
      }
    }
    ++nextIndex_;
  }
}
 
template <class Underlying_matrix, class Master_matrix>
template <class Boundary_range>
inline void Id_to_index_overlay<Underlying_matrix, Master_matrix>::insert_boundary(ID_index cellIndex,
                                                                                   const Boundary_range& boundary,
                                                                                   Dimension dim)
{
  if constexpr (Master_matrix::Option_list::has_map_column_container) {
    GUDHI_CHECK(idToIndex_->find(cellIndex) == idToIndex_->end(),
                std::invalid_argument("Id_to_index_overlay::insert_boundary - Index for simplex already chosen!"));
  } else {
    GUDHI_CHECK(
        (idToIndex_->size() <= cellIndex || _id_to_index(cellIndex) == Master_matrix::template get_null_value<Index>()),
        std::invalid_argument("Id_to_index_overlay::insert_boundary - Index for simplex already chosen!"));
  }
  matrix_.insert_boundary(cellIndex, boundary, dim);
  if constexpr (Master_matrix::Option_list::is_of_boundary_type) {
    if constexpr (Master_matrix::Option_list::has_map_column_container) {
      idToIndex_->emplace(cellIndex, nextIndex_);
    } else {
      if (idToIndex_->size() <= cellIndex) {
        idToIndex_->resize(cellIndex + 1, Master_matrix::template get_null_value<Index>());
      }
      _id_to_index(cellIndex) = nextIndex_;
    }
    ++nextIndex_;
  }
}
 
template <class Underlying_matrix, class Master_matrix>
template <class Boundary_range>
inline void Id_to_index_overlay<Underlying_matrix, Master_matrix>::insert_maximal_cell(Index columnIndex,
                                                                                       const Boundary_range& boundary,
                                                                                       Dimension dim)
{
  GUDHI_CHECK(columnIndex >= 0, std::invalid_argument("Indices have to be positive."));
 
  if constexpr (Master_matrix::Option_list::is_of_boundary_type) {
    insert_boundary(boundary, dim);
 
    if (get_number_of_columns() == 1) return;
 
    // false = backward direction
    _move_column_in_RU<false>(get_number_of_columns() - 1, columnIndex);
  } else {
    matrix_.insert_maximal_cell(columnIndex, boundary, dim);
  }
}
 
template <class Underlying_matrix, class Master_matrix>
template <class Boundary_range>
inline void Id_to_index_overlay<Underlying_matrix, Master_matrix>::insert_maximal_cell(Index columnIndex,
                                                                                       ID_index cellIndex,
                                                                                       const Boundary_range& boundary,
                                                                                       Dimension dim)
{
  GUDHI_CHECK(columnIndex >= 0, std::invalid_argument("Indices have to be positive."));
 
  if constexpr (Master_matrix::Option_list::is_of_boundary_type) {
    insert_boundary(cellIndex, boundary, dim);
 
    if (get_number_of_columns() == 1) return;
 
    // false = backward direction
    _move_column_in_RU<false>(get_number_of_columns() - 1, columnIndex);
  } else {
    matrix_.insert_maximal_cell(columnIndex, cellIndex, boundary, dim);
  }
}
 
template <class Underlying_matrix, class Master_matrix>
inline typename Id_to_index_overlay<Underlying_matrix, Master_matrix>::Column&
Id_to_index_overlay<Underlying_matrix, Master_matrix>::get_column(ID_index cellID)
{
  return matrix_.get_column(_id_to_index(cellID));
}
 
template <class Underlying_matrix, class Master_matrix>
inline typename Id_to_index_overlay<Underlying_matrix, Master_matrix>::Row&
Id_to_index_overlay<Underlying_matrix, Master_matrix>::get_row(ID_index rowIndex)
{
  return matrix_.get_row(rowIndex);
}
 
template <class Underlying_matrix, class Master_matrix>
inline void Id_to_index_overlay<Underlying_matrix, Master_matrix>::erase_empty_row(ID_index rowIndex)
{
  return matrix_.erase_empty_row(rowIndex);
}
 
template <class Underlying_matrix, class Master_matrix>
inline void Id_to_index_overlay<Underlying_matrix, Master_matrix>::remove_maximal_cell(ID_index cellID)
{
  if constexpr (Master_matrix::Option_list::is_of_boundary_type) {
    // true = forward direction
    _move_column_in_RU<true>(_id_to_index(cellID), nextIndex_ - 1);
    // nextIndex_ is used in _move_column_in_RU, should not be decremented before
    --nextIndex_;
    matrix_.remove_last();
    GUDHI_CHECK(_id_to_index(cellID) == nextIndex_,
                std::logic_error("Id_to_index_overlay::remove_maximal_cell - Indexation problem."));
 
    if constexpr (Master_matrix::Option_list::has_map_column_container) {
      idToIndex_->erase(cellID);
    } else {
      _id_to_index(cellID) = Master_matrix::template get_null_value<Index>();
    }
  } else {
    matrix_.remove_maximal_cell(cellID);
  }
}
 
template <class Underlying_matrix, class Master_matrix>
inline void Id_to_index_overlay<Underlying_matrix, Master_matrix>::remove_maximal_cell(
    ID_index cellID,
    const std::vector<ID_index>& columnsToSwap)
{
  static_assert(!Master_matrix::Option_list::is_of_boundary_type,
                "'remove_maximal_cell(ID_index,const std::vector<Index>&)' is not available for the chosen options.");
  std::vector<Index> translatedIndices;
  std::transform(columnsToSwap.cbegin(), columnsToSwap.cend(), std::back_inserter(translatedIndices), [&](ID_index id) {
    return _id_to_index(id);
  });
  matrix_.remove_maximal_cell(cellID, translatedIndices);
}
 
template <class Underlying_matrix, class Master_matrix>
inline void Id_to_index_overlay<Underlying_matrix, Master_matrix>::remove_last()
{
  if (idToIndex_->empty()) return;  // empty matrix
 
  matrix_.remove_last();
 
  if constexpr (Master_matrix::Option_list::is_of_boundary_type) {
    --nextIndex_;
    if constexpr (Master_matrix::Option_list::has_map_column_container) {
      auto it = idToIndex_->begin();
      while (it->second != nextIndex_) ++it;  // should never reach idToIndex_->end()
      idToIndex_->erase(it);
    } else {
      Index id = idToIndex_->size() - 1;
      // should always stop before reaching -1
      while (_id_to_index(id) == Master_matrix::template get_null_value<Index>()) --id;
      GUDHI_CHECK(_id_to_index(id) == nextIndex_,
                  std::logic_error("Id_to_index_overlay::remove_last - Indexation problem."));
      _id_to_index(id) = Master_matrix::template get_null_value<Index>();
    }
  }
}
 
template <class Underlying_matrix, class Master_matrix>
inline typename Id_to_index_overlay<Underlying_matrix, Master_matrix>::Dimension
Id_to_index_overlay<Underlying_matrix, Master_matrix>::get_max_dimension() const
{
  return matrix_.get_max_dimension();
}
 
template <class Underlying_matrix, class Master_matrix>
inline typename Id_to_index_overlay<Underlying_matrix, Master_matrix>::Index
Id_to_index_overlay<Underlying_matrix, Master_matrix>::get_number_of_columns() const
{
  return matrix_.get_number_of_columns();
}
 
template <class Underlying_matrix, class Master_matrix>
inline typename Id_to_index_overlay<Underlying_matrix, Master_matrix>::Dimension
Id_to_index_overlay<Underlying_matrix, Master_matrix>::get_column_dimension(ID_index cellID) const
{
  return matrix_.get_column_dimension(_id_to_index(cellID));
}
 
template <class Underlying_matrix, class Master_matrix>
inline void Id_to_index_overlay<Underlying_matrix, Master_matrix>::add_to(ID_index sourceCellID, ID_index targetCellID)
{
  return matrix_.add_to(_id_to_index(sourceCellID), _id_to_index(targetCellID));
}
 
template <class Underlying_matrix, class Master_matrix>
inline void Id_to_index_overlay<Underlying_matrix, Master_matrix>::multiply_target_and_add_to(
    ID_index sourceCellID,
    const Field_element& coefficient,
    ID_index targetCellID)
{
  return matrix_.multiply_target_and_add_to(_id_to_index(sourceCellID), coefficient, _id_to_index(targetCellID));
}
 
template <class Underlying_matrix, class Master_matrix>
inline void Id_to_index_overlay<Underlying_matrix, Master_matrix>::multiply_source_and_add_to(
    const Field_element& coefficient,
    ID_index sourceCellID,
    ID_index targetCellID)
{
  return matrix_.multiply_source_and_add_to(coefficient, _id_to_index(sourceCellID), _id_to_index(targetCellID));
}
 
template <class Underlying_matrix, class Master_matrix>
inline void Id_to_index_overlay<Underlying_matrix, Master_matrix>::zero_entry(ID_index cellID, ID_index rowIndex)
{
  return matrix_.zero_entry(_id_to_index(cellID), rowIndex);
}
 
template <class Underlying_matrix, class Master_matrix>
inline void Id_to_index_overlay<Underlying_matrix, Master_matrix>::zero_column(ID_index cellID)
{
  return matrix_.zero_column(_id_to_index(cellID));
}
 
template <class Underlying_matrix, class Master_matrix>
inline bool Id_to_index_overlay<Underlying_matrix, Master_matrix>::is_zero_entry(ID_index cellID,
                                                                                 ID_index rowIndex) const
{
  return matrix_.is_zero_entry(_id_to_index(cellID), rowIndex);
}
 
template <class Underlying_matrix, class Master_matrix>
inline bool Id_to_index_overlay<Underlying_matrix, Master_matrix>::is_zero_column(ID_index cellID)
{
  return matrix_.is_zero_column(_id_to_index(cellID));
}
 
template <class Underlying_matrix, class Master_matrix>
inline typename Id_to_index_overlay<Underlying_matrix, Master_matrix>::ID_index
Id_to_index_overlay<Underlying_matrix, Master_matrix>::get_column_with_pivot(ID_index cellIndex) const
{
  if constexpr (Master_matrix::Option_list::is_of_boundary_type) {
    Index pos = matrix_.get_column_with_pivot(cellIndex);
    ID_index i = 0;
    while (_id_to_index(i) != pos) ++i;
    return i;
  } else {
    return cellIndex;
  }
}
 
template <class Underlying_matrix, class Master_matrix>
inline typename Id_to_index_overlay<Underlying_matrix, Master_matrix>::ID_index
Id_to_index_overlay<Underlying_matrix, Master_matrix>::get_pivot(ID_index cellID)
{
  if constexpr (Master_matrix::Option_list::is_of_boundary_type) {
    return matrix_.get_pivot(_id_to_index(cellID));
  } else {
    return cellID;
  }
}
 
template <class Underlying_matrix, class Master_matrix>
inline Id_to_index_overlay<Underlying_matrix, Master_matrix>&
Id_to_index_overlay<Underlying_matrix, Master_matrix>::operator=(const Id_to_index_overlay& other)
{
  if (this == &other) return *this;
 
  matrix_ = other.matrix_;
  if constexpr (Master_matrix::Option_list::is_of_boundary_type) {
    delete idToIndex_;
    idToIndex_ = other.idToIndex_;
  } else {
    idToIndex_ = &matrix_.pivotToColumnIndex_;
  }
  nextIndex_ = other.nextIndex_;
 
  return *this;
}
 
template <class Underlying_matrix, class Master_matrix>
inline Id_to_index_overlay<Underlying_matrix, Master_matrix>&
Id_to_index_overlay<Underlying_matrix, Master_matrix>::operator=(Id_to_index_overlay&& other) noexcept
{
  if (this == &other) return *this;
 
  matrix_ = std::move(other.matrix_);
  if constexpr (Master_matrix::Option_list::is_of_boundary_type) {
    delete idToIndex_;
  }
  idToIndex_ = std::exchange(other.idToIndex_, nullptr);
  nextIndex_ = std::exchange(other.nextIndex_, 0);
 
  return *this;
}
 
template <class Underlying_matrix, class Master_matrix>
inline void Id_to_index_overlay<Underlying_matrix, Master_matrix>::print()
{
  return matrix_.print();
}
 
template <class Underlying_matrix, class Master_matrix>
inline const typename Id_to_index_overlay<Underlying_matrix, Master_matrix>::Barcode&
Id_to_index_overlay<Underlying_matrix, Master_matrix>::get_current_barcode()
{
  return matrix_.get_current_barcode();
}
 
template <class Underlying_matrix, class Master_matrix>
inline void Id_to_index_overlay<Underlying_matrix, Master_matrix>::update_all_representative_cycles(Dimension dim)
{
  matrix_.update_all_representative_cycles(dim);
}
 
template <class Underlying_matrix, class Master_matrix>
inline void Id_to_index_overlay<Underlying_matrix, Master_matrix>::update_representative_cycle(const Bar& bar)
{
  matrix_.update_representative_cycle(bar);
}
 
template <class Underlying_matrix, class Master_matrix>
inline const std::vector<typename Id_to_index_overlay<Underlying_matrix, Master_matrix>::Cycle>&
Id_to_index_overlay<Underlying_matrix, Master_matrix>::get_all_representative_cycles() const
{
  return matrix_.get_all_representative_cycles();
}
 
template <class Underlying_matrix, class Master_matrix>
inline const typename Id_to_index_overlay<Underlying_matrix, Master_matrix>::Cycle&
Id_to_index_overlay<Underlying_matrix, Master_matrix>::get_representative_cycle(const Bar& bar) const
{
  return matrix_.get_representative_cycle(bar);
}
 
template <class Underlying_matrix, class Master_matrix>
inline void Id_to_index_overlay<Underlying_matrix, Master_matrix>::swap_columns(ID_index cellID1, ID_index cellID2)
{
  matrix_.swap_columns(_id_to_index(cellID1), _id_to_index(cellID2));
  std::swap(idToIndex_->at(cellID1), idToIndex_->at(cellID2));
}
 
template <class Underlying_matrix, class Master_matrix>
inline void Id_to_index_overlay<Underlying_matrix, Master_matrix>::swap_rows(Index rowIndex1, Index rowIndex2)
{
  matrix_.swap_rows(rowIndex1, rowIndex2);
}
 
template <class Underlying_matrix, class Master_matrix>
inline typename Id_to_index_overlay<Underlying_matrix, Master_matrix>::ID_index
Id_to_index_overlay<Underlying_matrix, Master_matrix>::vine_swap_with_z_eq_1_case(ID_index cellID1, ID_index cellID2)
{
  Index first = _id_to_index(cellID1);
  Index second = _id_to_index(cellID2);
  if (first > second) std::swap(first, second);
 
  if constexpr (Master_matrix::Option_list::is_of_boundary_type) {
    GUDHI_CHECK(second - first == 1,
                std::invalid_argument(
                    "Id_to_index_overlay::vine_swap_with_z_eq_1_case - The columns to swap are not contiguous."));
 
    bool change = matrix_.vine_swap_with_z_eq_1_case(first);
 
    std::swap(idToIndex_->at(cellID1), idToIndex_->at(cellID2));
 
    if (change) {
      return cellID1;
    }
    return cellID2;
  } else {
    return matrix_.vine_swap_with_z_eq_1_case(first, second);
  }
}
 
template <class Underlying_matrix, class Master_matrix>
inline typename Id_to_index_overlay<Underlying_matrix, Master_matrix>::ID_index
Id_to_index_overlay<Underlying_matrix, Master_matrix>::vine_swap(ID_index cellID1, ID_index cellID2)
{
  Index first = _id_to_index(cellID1);
  Index second = _id_to_index(cellID2);
  if (first > second) std::swap(first, second);
 
  if constexpr (Master_matrix::Option_list::is_of_boundary_type) {
    GUDHI_CHECK(second - first == 1,
                std::invalid_argument("Id_to_index_overlay::vine_swap - The columns to swap are not contiguous."));
 
    bool change = matrix_.vine_swap(first);
 
    std::swap(idToIndex_->at(cellID1), idToIndex_->at(cellID2));
 
    if (change) {
      return cellID1;
    }
    return cellID2;
  } else {
    return matrix_.vine_swap(first, second);
  }
}
 
template <class Underlying_matrix, class Master_matrix>
inline void Id_to_index_overlay<Underlying_matrix, Master_matrix>::_initialize_map([[maybe_unused]] unsigned int size)
{
  if constexpr (Master_matrix::Option_list::is_of_boundary_type) {
    if constexpr (Master_matrix::Option_list::has_map_column_container) {
      idToIndex_ = new Dictionary(size);
    } else {
      idToIndex_ = new Dictionary(size, Master_matrix::template get_null_value<Index>());
    }
  } else {
    idToIndex_ = &matrix_.pivotToColumnIndex_;
  }
}
 
template <class Underlying_matrix, class Master_matrix>
inline typename Id_to_index_overlay<Underlying_matrix, Master_matrix>::Index
Id_to_index_overlay<Underlying_matrix, Master_matrix>::_id_to_index(ID_index id) const
{
  if constexpr (Master_matrix::Option_list::has_map_column_container) {
    return idToIndex_->at(id);
  } else {
    return idToIndex_->operator[](id);
  }
}
 
template <class Underlying_matrix, class Master_matrix>
inline typename Id_to_index_overlay<Underlying_matrix, Master_matrix>::Index&
Id_to_index_overlay<Underlying_matrix, Master_matrix>::_id_to_index(ID_index id)
{
  return idToIndex_->operator[](id);  // for maps, the entry is created if not existing as needed in the constructors
}
 
template <class Underlying_matrix, class Master_matrix>
template <bool dir>
inline void Id_to_index_overlay<Underlying_matrix, Master_matrix>::_move_column_in_RU(Pos_index start, Pos_index end)
{
  // nextIndex_ would be overkill if start (dir == true) / end (dir == false) was different from end of matrix
  // but it is not used that way for now
  std::vector<ID_index> indexToID(nextIndex_);
  if constexpr (Master_matrix::Option_list::has_map_column_container) {
    for (auto& p : *idToIndex_) {
      indexToID[p.second] = p.first;
    }
  } else {
    for (ID_index i = 0; i < idToIndex_->size(); ++i) {
      if (_id_to_index(i) != Master_matrix::template get_null_value<Index>()) indexToID[_id_to_index(i)] = i;
    }
  }
  if constexpr (dir) {
    for (Index curr = start; curr < end; ++curr) {
      matrix_.vine_swap(curr);
      std::swap(idToIndex_->at(indexToID[curr]), idToIndex_->at(indexToID[curr + 1]));
      std::swap(indexToID[curr], indexToID[curr + 1]);
    }
  } else {
    for (Index curr = start; curr > end; --curr) {
      matrix_.vine_swap(curr - 1);
      std::swap(idToIndex_->at(indexToID[curr - 1]), idToIndex_->at(indexToID[curr]));
      std::swap(indexToID[curr - 1], indexToID[curr]);
    }
  }
}
 
}  // namespace persistence_matrix
}  // namespace Gudhi
 
#endif  // PM_ID_TO_POS_TRANSLATION_H