multipers 2.4.0b1__cp312-cp312-macosx_11_0_arm64.whl

multipers/gudhi/gudhi/Persistence_matrix/allocators/entry_constructors.h

@@ -0,0 +1,122 @@
+/*    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) 2024 Inria
+ *
+ *    Modification(s):
+ *      - YYYY/MM Author: Description of the modification
+ */
+
+/**
+ * @file entry_constructors.h
+ * @author Hannah Schreiber
+ * @brief Contains different versions of @ref Gudhi::persistence_matrix::Entry factories.
+ */
+
+#ifndef PM_COLUMN_ENTRY_CONSTRUCTORS_H
+#define PM_COLUMN_ENTRY_CONSTRUCTORS_H
+
+#include <utility>  //std::swap
+
+#include <gudhi/Simple_object_pool.h>
+
+namespace Gudhi {
+namespace persistence_matrix {
+
+/**
+ * @private
+ * @ingroup persistence_matrix
+ *
+ * @brief @ref Entry factory. Constructs and destroys entry pointers with new and delete.
+ *
+ * @tparam Entry @ref Entry with the right templates.
+ */
+template <class Entry>
+struct New_entry_constructor {
+  /**
+   * @brief Default constructor.
+   */
+  New_entry_constructor() = default;
+
+  /**
+   * @brief Constructs an entry with the given entry arguments.
+   *
+   * @param u Arguments forwarded to the @ref Entry constructor.
+   * @return @ref Entry pointer.
+   */
+  template <class... U>
+  Entry* construct(U&&... u) const
+  {
+    return new Entry(std::forward<U>(u)...);
+  }
+
+  /**
+   * @brief Destroys the given entry.
+   *
+   * @param entry @ref Entry pointer.
+   */
+  void destroy(Entry* entry) const { delete entry; }
+
+  /**
+   * @brief Swap operator.
+   */
+  friend void swap([[maybe_unused]] New_entry_constructor& col1,
+                   [[maybe_unused]] New_entry_constructor& col2) noexcept {}
+};
+
+/**
+ * @private
+ * @ingroup persistence_matrix
+ *
+ * @brief @ref Entry factory. Uses @ref Gudhi::Simple_object_pool, which is based on boost::object_pool,
+ * to construct and destroy entry pointer.
+ *
+ * @tparam Entry @ref Entry with the right templates.
+ */
+template <class Entry>
+struct Pool_entry_constructor {
+ public:
+  /**
+   * @brief Default constructor.
+   *
+   */
+  Pool_entry_constructor() : entryPool_() {}
+
+  // TODO: what does happen when the pool is copied?
+
+  /**
+   * @brief Constructs an entry with the given entry arguments.
+   *
+   * @param u Arguments forwarded to the @ref Entry constructor.
+   * @return @ref Entry pointer.
+   */
+  template <class... U>
+  Entry* construct(U&&... u)
+  {
+    return entryPool_.construct(std::forward<U>(u)...);
+  }
+
+  /**
+   * @brief Destroys the given entry.
+   *
+   * @param entry @ref Entry pointer.
+   */
+  void destroy(Entry* entry) { entryPool_.destroy(entry); }
+
+  /**
+   * @brief Swap operator.
+   */
+  friend void swap(Pool_entry_constructor& col1, Pool_entry_constructor& col2) noexcept
+  {
+    std::swap(col1.entryPool_, col2.entryPool_);
+  }
+
+ private:
+  Simple_object_pool<Entry> entryPool_; /**< Entry pool. */
+};
+
+}  // namespace persistence_matrix
+}  // namespace Gudhi
+
+#endif  // PM_COLUMN_ENTRY_CONSTRUCTORS_H

multipers/gudhi/gudhi/Persistence_matrix/base_pairing.h

@@ -0,0 +1,260 @@
+/*    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-24 Inria
+ *
+ *    Modification(s):
+ *      - YYYY/MM Author: Description of the modification
+ */
+
+/**
+ * @file base_pairing.h
+ * @author Hannah Schreiber
+ * @brief Contains the @ref Gudhi::persistence_matrix::Base_pairing class and
+ * @ref Gudhi::persistence_matrix::Dummy_base_pairing structure.
+ */
+
+#ifndef PM_BASE_PAIRING_H
+#define PM_BASE_PAIRING_H
+
+#include <utility>  //std::swap & std::move
+#include <unordered_map>
+#include <algorithm>
+#include <vector>
+
+#include <gudhi/Persistence_matrix/index_mapper.h>
+
+namespace Gudhi {
+namespace persistence_matrix {
+
+/**
+ * @ingroup persistence_matrix
+ *
+ * @brief Empty structure.
+ * Inherited instead of @ref Base_pairing, when the computation of the barcode was not enabled or if the pairing
+ * is already managed by the vine update classes.
+ */
+struct Dummy_base_pairing {
+  friend void swap([[maybe_unused]] Dummy_base_pairing& d1, [[maybe_unused]] Dummy_base_pairing& d2) noexcept {}
+};
+
+/**
+ * @class Base_pairing base_pairing.h gudhi/Persistence_matrix/base_pairing.h
+ * @ingroup persistence_matrix
+ *
+ * @brief Class managing the barcode for @ref Boundary_matrix if the option was enabled.
+ *
+ * @tparam Master_matrix An instantiation of @ref Matrix from which all types and options are deduced.
+ */
+template <class Master_matrix>
+class Base_pairing
+    : protected std::conditional_t<
+          Master_matrix::Option_list::has_removable_columns,
+          Index_mapper<std::unordered_map<typename Master_matrix::Pos_index, typename Master_matrix::ID_index> >,
+          Dummy_index_mapper>
+{
+ protected:
+  using Pos_index = typename Master_matrix::Pos_index;
+  using ID_index = typename Master_matrix::ID_index;
+  // PIDM = Position to ID Map
+  using PIDM = std::conditional_t<Master_matrix::Option_list::has_removable_columns,
+                                  Index_mapper<std::unordered_map<Pos_index, ID_index> >,
+                                  Dummy_index_mapper>;
+
+ public:
+  using Bar = typename Master_matrix::Bar;                           /**< Bar type. */
+  using Barcode = typename Master_matrix::Barcode;                   /**< Barcode type. */
+  using Column = typename Master_matrix::Column;                     /**< Column type. */
+  using Index = typename Master_matrix::Index;                       /**< Container index type. */
+
+  /**
+   * @brief Default constructor.
+   */
+  Base_pairing();
+
+  /**
+   * @brief Reduces the matrix stored in @ref Boundary_matrix and computes the corresponding barcode.
+   *
+   * @warning The barcode will not be recomputed if the matrix is modified later after calling this method
+   * for the first time. So call it only once the matrix is finalized. This behaviour could be changed in the future,
+   * if the need is mentioned.
+   *
+   * @return Const reference to the barcode.
+   */
+  const Barcode& get_current_barcode();
+
+  /**
+   * @brief Swap operator.
+   */
+  friend void swap(Base_pairing& pairing1, Base_pairing& pairing2) noexcept
+  {
+    if constexpr (Master_matrix::Option_list::has_removable_columns) {
+      swap(static_cast<PIDM&>(pairing1), static_cast<PIDM&>(pairing2));
+    }
+    pairing1.barcode_.swap(pairing2.barcode_);
+    pairing1.deathToBar_.swap(pairing2.deathToBar_);
+    pairing1.idToPosition_.swap(pairing2.idToPosition_);
+    std::swap(pairing1.isReduced_, pairing2.isReduced_);
+  }
+
+ protected:
+  void _remove_last(Pos_index columnIndex);
+  void _insert_id_position(ID_index id, Pos_index pos);
+  void _reset();
+
+ private:
+  using Dictionary = typename Master_matrix::Bar_dictionary;
+  using Base_matrix = typename Master_matrix::Master_boundary_matrix;
+
+  Barcode barcode_;       /**< Bar container. */
+  Dictionary deathToBar_; /**< Map from death index to bar index. */
+  bool isReduced_;        /**< True if `_reduce()` was called. */
+  /**
+   * @brief Map from cell ID to cell position. Only stores a pair if ID != position.
+   */
+  std::unordered_map<ID_index, Pos_index> idToPosition_;  // TODO: test other map types
+
+  void _reduce();
+  void _reduce_column_with(Column& toReduce, Column& toAdd);
+
+  // access to inheriting Boundary_matrix class
+  constexpr Base_matrix* _matrix() { return static_cast<Base_matrix*>(this); }
+
+  constexpr const Base_matrix* _matrix() const { return static_cast<const Base_matrix*>(this); }
+};
+
+template <class Master_matrix>
+inline Base_pairing<Master_matrix>::Base_pairing() : PIDM(), isReduced_(false)
+{}
+
+template <class Master_matrix>
+inline const typename Base_pairing<Master_matrix>::Barcode& Base_pairing<Master_matrix>::get_current_barcode()
+{
+  if (!isReduced_) _reduce();
+  return barcode_;
+}
+
+template <class Master_matrix>
+inline void Base_pairing<Master_matrix>::_reduce()
+{
+  constexpr const Pos_index nullDeath = Master_matrix::template get_null_value<Pos_index>();
+  constexpr const Index nullIndex = Master_matrix::template get_null_value<Index>();
+  constexpr const ID_index nullPivot = Master_matrix::template get_null_value<ID_index>();
+
+  std::unordered_map<Index, Index> negativeColumns(_matrix()->get_number_of_columns());
+
+  auto dim = _matrix()->get_max_dimension();
+  std::vector<std::vector<Index> > columnsByDim(dim + 1);
+  for (auto& v : columnsByDim) v.reserve(_matrix()->get_number_of_columns());
+  for (unsigned int i = 0; i < _matrix()->get_number_of_columns(); i++) {
+    columnsByDim[dim - _matrix()->get_column_dimension(i)].push_back(i);
+  }
+
+  for (const auto& cols : columnsByDim) {
+    for (Index i : cols) {
+      auto& curr = _matrix()->get_column(i);
+      if (curr.is_empty()) {
+        if (negativeColumns.find(i) == negativeColumns.end()) {
+          barcode_.emplace_back(i, nullDeath, dim);
+        }
+      } else {
+        ID_index pivot = curr.get_pivot();
+        auto it = idToPosition_.find(pivot);
+        Index pivotColumnNumber = it == idToPosition_.end() ? pivot : it->second;
+        auto itNeg = negativeColumns.find(pivotColumnNumber);
+        Index pivotKiller = itNeg == negativeColumns.end() ? nullIndex : itNeg->second;
+
+        while (pivot != nullPivot && pivotKiller != nullIndex) {
+          _reduce_column_with(curr, _matrix()->get_column(pivotKiller));
+          pivot = curr.get_pivot();
+          it = idToPosition_.find(pivot);
+          pivotColumnNumber = it == idToPosition_.end() ? pivot : it->second;
+          itNeg = negativeColumns.find(pivotColumnNumber);
+          pivotKiller = itNeg == negativeColumns.end() ? nullIndex : itNeg->second;
+        }
+
+        if (pivot != nullPivot) {
+          negativeColumns.emplace(pivotColumnNumber, i);
+          _matrix()->get_column(pivotColumnNumber).clear();
+          barcode_.emplace_back(pivotColumnNumber, i, dim - 1);
+        } else {
+          curr.clear();
+          barcode_.emplace_back(i, nullDeath, dim);
+        }
+      }
+    }
+    --dim;
+  }
+
+  if constexpr (Master_matrix::Option_list::has_removable_columns) {
+    // sort barcode by birth such that a removal is trivial
+    std::sort(barcode_.begin(), barcode_.end(), [](const Bar& b1, const Bar& b2) { return b1.birth < b2.birth; });
+    // map can only be constructed once barcode is sorted
+    for (Index i = 0; i < barcode_.size(); ++i) {
+      auto d = barcode_[i].death;
+      if (d != Master_matrix::template get_null_value<Pos_index>()) {
+        deathToBar_.emplace(d, i);
+      }
+    }
+  }
+
+  isReduced_ = true;
+}
+
+template <class Master_matrix>
+inline void Base_pairing<Master_matrix>::_reduce_column_with(Column& toReduce, Column& toAdd)
+{
+  if constexpr (Master_matrix::Option_list::is_z2) {
+    toReduce += toAdd;
+  } else {
+    typename Master_matrix::Element coeff = toAdd.get_pivot_value();
+    auto& operators = _matrix()->colSettings_->operators;
+    coeff = operators.get_inverse(coeff);
+    operators.multiply_inplace(coeff, operators.get_characteristic() - toReduce.get_pivot_value());
+    toReduce.multiply_source_and_add(toAdd, coeff);
+  }
+}
+
+template <class Master_matrix>
+inline void Base_pairing<Master_matrix>::_remove_last(Pos_index columnIndex)
+{
+  static_assert(Master_matrix::Option_list::has_removable_columns, "remove_last not available.");
+
+  if (isReduced_) {
+    auto it = deathToBar_.find(columnIndex);
+
+    if (it == deathToBar_.end()) {  // birth
+      barcode_.pop_back();          // sorted by birth and columnIndex has to be the highest one
+    } else {                        // death
+      barcode_[it->second].death = Master_matrix::template get_null_value<Pos_index>();
+      deathToBar_.erase(it);
+    };
+  }
+
+  auto it = PIDM::map_.find(columnIndex);
+  if (it != PIDM::map_.end()) {
+    idToPosition_.erase(it->second);
+    PIDM::map_.erase(it);
+  }
+}
+
+template <class Master_matrix>
+inline void Base_pairing<Master_matrix>::_insert_id_position(ID_index id, Pos_index pos)
+{
+  idToPosition_.emplace(id, pos);
+}
+
+template <class Master_matrix>
+inline void Base_pairing<Master_matrix>::_reset()
+{
+  barcode_.clear();
+  deathToBar_.clear();
+  isReduced_ = false;
+  idToPosition_.clear();
+}
+
+}  // namespace persistence_matrix
+}  // namespace Gudhi
+
+#endif  // PM_BASE_PAIRING_H

multipers/gudhi/gudhi/Persistence_matrix/base_swap.h

@@ -0,0 +1,288 @@
+/*    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-23 Inria
+ *
+ *    Modification(s):
+ *      - YYYY/MM Author: Description of the modification
+ */
+
+/**
+ * @file base_swap.h
+ * @author Hannah Schreiber
+ * @brief Contains the @ref Gudhi::persistence_matrix::Base_swap class and
+ * @ref Gudhi::persistence_matrix::Dummy_base_swap structure.
+ */
+
+#ifndef PM_BASE_SWAP_H
+#define PM_BASE_SWAP_H
+
+#include <utility>    //std::swap, std::move & std::exchange
+#include <algorithm>  //std::max
+
+namespace Gudhi {
+namespace persistence_matrix {
+
+/**
+ * @ingroup persistence_matrix
+ *
+ * @brief Empty structure.
+ * Inherited instead of @ref Base_swap, when the column and row swaps are not enabled.
+ */
+struct Dummy_base_swap {
+  friend void swap([[maybe_unused]] Dummy_base_swap& d1, [[maybe_unused]] Dummy_base_swap& d2) noexcept {}
+
+  Dummy_base_swap([[maybe_unused]] unsigned int numberOfColumns = 0) {}
+};
+
+/**
+ * @class Base_swap base_swap.h gudhi/Persistence_matrix/base_swap.h
+ * @ingroup persistence_matrix
+ *
+ * @brief Class managing the column and row swaps in @ref Base_matrix and @ref Boundary_matrix.
+ *
+ * @tparam Master_matrix An instantiation of @ref Matrix from which all types and options are deduced.
+ * @tparam Base_matrix Either @ref Base_matrix or @ref Boundary_matrix.
+ */
+template <class Master_matrix, class Base_matrix>
+class Base_swap
+{
+ public:
+  using Column_container = typename Master_matrix::Column_container; /**< Column container type. */
+  using Index = typename Master_matrix::Index;                       /**< Container index type. */
+  using ID_index = typename Master_matrix::ID_index;                 /**< @ref IDIdx index type. */
+
+  /**
+   * @brief Default constructor.
+   */
+  Base_swap();
+  /**
+   * @brief As default constructor, but reserves spaces for @p numberOfColumns columns.
+   *
+   * @param numberOfColumns Number of columns to reserve space for.
+   */
+  Base_swap(unsigned int numberOfColumns);
+  /**
+   * @brief Copy constructor.
+   *
+   * @param matrixToCopy Matrix to copy.
+   */
+  Base_swap(const Base_swap& matrixToCopy) = default;
+  /**
+   * @brief Move constructor.
+   *
+   * @param other Matrix to move.
+   */
+  Base_swap(Base_swap&& other) noexcept;
+
+  ~Base_swap() = default;
+
+  /**
+   * @brief Swaps the two columns at given indices in the column container. Does not updates the column index value,
+   * potentially stored in the entries. This will be done when calling `_orderRows()`.
+   *
+   * @param columnIndex1 First @ref MatIdx column index.
+   * @param columnIndex2 Second @ref MatIdx column index.
+   */
+  void swap_columns(Index columnIndex1, Index columnIndex2);
+  /**
+   * @brief Swaps the two rows at the given indices, but in a lazy manner. That is, the swap is registered but not
+   * executed. The reordering will be done when calling `_orderRows()`.
+   *
+   * @param rowIndex1 First row index.
+   * @param rowIndex2 Second row index.
+   */
+  void swap_rows(ID_index rowIndex1, ID_index rowIndex2);
+
+  /**
+   * @brief Assign operator.
+   */
+  Base_swap& operator=(const Base_swap& other) = default;
+  /**
+   * @brief Move assign operator.
+   */
+  Base_swap& operator=(Base_swap&& other) noexcept;
+
+  /**
+   * @brief Swap operator.
+   */
+  friend void swap(Base_swap& base1, Base_swap& base2) noexcept
+  {
+    base1.indexToRow_.swap(base2.indexToRow_);
+    base1.rowToIndex_.swap(base2.rowToIndex_);
+    std::swap(base1.rowSwapped_, base2.rowSwapped_);
+  }
+
+ protected:
+  void _orderRows();
+  void _initialize_row_index(Index index);
+  Index _erase_row(Index index);
+  Index _get_row_index(Index index) const;
+  bool _row_were_swapped() const;
+  void _reset();
+
+ private:
+  using Index_dictionary = typename Master_matrix::template Dictionary<Index>;
+  using Row_dictionary = typename Master_matrix::template Dictionary<ID_index>;
+
+  Index_dictionary indexToRow_; /**< Map from row index to actual index in row container. */
+  Row_dictionary rowToIndex_;   /**< Map from index in row container to "public" row index. */
+  bool rowSwapped_;             /**< True if any rows were swapped since last call to `_orderRows()`. */
+
+  // access to inheriting matrix class
+  constexpr Base_matrix* _matrix() { return static_cast<Base_matrix*>(this); }
+
+  constexpr const Base_matrix* _matrix() const { return static_cast<const Base_matrix*>(this); }
+};
+
+template <class Master_matrix, class Base_matrix>
+inline Base_swap<Master_matrix, Base_matrix>::Base_swap() : rowSwapped_(false)
+{
+}
+
+template <class Master_matrix, class Base_matrix>
+inline Base_swap<Master_matrix, Base_matrix>::Base_swap(unsigned int numberOfColumns)
+    : indexToRow_(numberOfColumns), rowToIndex_(numberOfColumns), rowSwapped_(false)
+{
+  for (Index i = 0; i < numberOfColumns; i++) {
+    indexToRow_[i] = i;
+    rowToIndex_[i] = i;
+  }
+}
+
+template <class Master_matrix, class Base_matrix>
+inline Base_swap<Master_matrix, Base_matrix>::Base_swap(Base_swap&& other) noexcept
+    : indexToRow_(std::move(other.indexToRow_)),
+      rowToIndex_(std::move(other.rowToIndex_)),
+      rowSwapped_(std::exchange(other.rowSwapped_, false))
+{
+}
+
+template <class Master_matrix, class Base_matrix>
+inline void Base_swap<Master_matrix, Base_matrix>::swap_columns(Index columnIndex1, Index columnIndex2)
+{
+  swap(_matrix()->matrix_.at(columnIndex1), _matrix()->matrix_.at(columnIndex2));
+  if constexpr (Master_matrix::Option_list::has_row_access) rowSwapped_ = true;  // to update column index in entries.
+}
+
+template <class Master_matrix, class Base_matrix>
+inline void Base_swap<Master_matrix, Base_matrix>::swap_rows(ID_index rowIndex1, ID_index rowIndex2)
+{
+  rowSwapped_ = true;
+
+  if constexpr (Master_matrix::Option_list::has_map_column_container) {
+    auto it1 = indexToRow_.find(rowIndex1);
+    auto it2 = indexToRow_.find(rowIndex2);
+
+    if (it1 == indexToRow_.end() && it2 == indexToRow_.end()) return;
+
+    if (it1 == indexToRow_.end()) {
+      indexToRow_.emplace(rowIndex1, it2->second);
+      rowToIndex_.at(it2->second) = rowIndex1;
+      indexToRow_.erase(it2->second);
+      return;
+    }
+
+    if (it2 == indexToRow_.end()) {
+      indexToRow_.emplace(rowIndex2, it1->second);
+      rowToIndex_.at(it1->second) = rowIndex2;
+      indexToRow_.erase(it1);
+      return;
+    }
+
+    std::swap(rowToIndex_.at(it1->second), rowToIndex_.at(it2->second));
+    std::swap(it1->second, it2->second);
+  } else {
+    for (auto i = indexToRow_.size(); i <= std::max(rowIndex1, rowIndex2); ++i) indexToRow_.push_back(i);
+
+    std::swap(rowToIndex_[indexToRow_[rowIndex1]], rowToIndex_[indexToRow_[rowIndex2]]);
+    std::swap(indexToRow_[rowIndex1], indexToRow_[rowIndex2]);
+  }
+}
+
+template <class Master_matrix, class Base_matrix>
+inline Base_swap<Master_matrix, Base_matrix>& Base_swap<Master_matrix, Base_matrix>::operator=(
+    Base_swap&& other) noexcept
+{
+  if (this == &other) return *this;
+
+  indexToRow_ = std::move(other.indexToRow_);
+  rowToIndex_ = std::move(other.rowToIndex_);
+  rowSwapped_ = std::exchange(other.rowSwapped_, false);
+  return *this;
+}
+
+template <class Master_matrix, class Base_matrix>
+inline void Base_swap<Master_matrix, Base_matrix>::_orderRows()
+{
+  for (unsigned int i = 0; i < _matrix()->get_number_of_columns(); i++) {
+    _matrix()->matrix_.at(i).reorder(rowToIndex_, i);
+  }
+  for (Index i = 0; i < _matrix()->get_number_of_columns(); i++) {
+    indexToRow_[i] = i;
+    rowToIndex_[i] = i;
+  }
+  rowSwapped_ = false;
+}
+
+template <class Master_matrix, class Base_matrix>
+inline void Base_swap<Master_matrix, Base_matrix>::_initialize_row_index(Index index)
+{
+  if constexpr (Master_matrix::Option_list::has_map_column_container) {
+    indexToRow_.emplace(index, index);
+    rowToIndex_.emplace(index, index);
+  } else {
+    indexToRow_.reserve(index + 1);
+    rowToIndex_.reserve(index + 1);
+    for (Index i = indexToRow_.size(); i <= index; ++i) {
+      indexToRow_.push_back(i);
+      rowToIndex_.push_back(i);
+    }
+  }
+}
+
+template <class Master_matrix, class Base_matrix>
+inline typename Base_swap<Master_matrix, Base_matrix>::Index Base_swap<Master_matrix, Base_matrix>::_erase_row(
+    Index index)
+{
+  if constexpr (Master_matrix::Option_list::has_map_column_container) {
+    auto it = indexToRow_.find(index);
+    auto rowID = it->second;
+    rowToIndex_.erase(rowID);
+    indexToRow_.erase(it);
+    return rowID;
+  } else {
+    return indexToRow_[index];
+  }
+}
+
+template <class Master_matrix, class Base_matrix>
+inline typename Base_swap<Master_matrix, Base_matrix>::Index Base_swap<Master_matrix, Base_matrix>::_get_row_index(
+    Index index) const
+{
+  if constexpr (Master_matrix::Option_list::has_map_column_container) {
+    return indexToRow_.at(index);
+  } else {
+    return indexToRow_[index];
+  }
+}
+
+template <class Master_matrix, class Base_matrix>
+inline bool Base_swap<Master_matrix, Base_matrix>::_row_were_swapped() const
+{
+  return rowSwapped_;
+}
+
+template <class Master_matrix, class Base_matrix>
+inline void Base_swap<Master_matrix, Base_matrix>::_reset()
+{
+  indexToRow_.clear();
+  rowToIndex_.clear();
+  rowSwapped_ = false;
+}
+
+}  // namespace persistence_matrix
+}  // namespace Gudhi
+
+#endif  // PM_BASE_SWAP_H