multipers 2.3.3b6__cp312-cp312-macosx_11_0_arm64.whl

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

@@ -0,0 +1,139 @@
+/*    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() {}
+
+  /**
+   * @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(New_entry_constructor& col1, New_entry_constructor& col2) {}
+};
+
+/**
+ * @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 Copy constructor.
+   * 
+   * @param col Factory to copy.
+   */
+  Pool_entry_constructor(const Pool_entry_constructor& col) : entryPool_(col.entryPool_) {}
+  /**
+   * @brief Move constructor.
+   * 
+   * @param col Factory to move.
+   */
+  Pool_entry_constructor(Pool_entry_constructor&& col) : entryPool_(std::move(col.entryPool_)) {}
+
+  /**
+   * @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); }
+
+  //TODO: Again, what does it mean to copy the pool?
+  /**
+   * @brief Assign operator.
+   */
+  Pool_entry_constructor& operator=(const Pool_entry_constructor& other) {
+    entryPool_ = other.entryPool_;
+    return *this;
+  }
+  /**
+   * @brief Swap operator.
+   */
+  friend void swap(Pool_entry_constructor& col1, Pool_entry_constructor& col2) {
+    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,230 @@
+/*    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 "boundary_cell_position_to_id_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) {}
+};
+
+/**
+ * @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 : public std::conditional<
+                       Master_matrix::Option_list::has_removable_columns,
+                       Cell_position_to_ID_mapper<typename Master_matrix::ID_index, typename Master_matrix::Pos_index>,
+                       Dummy_pos_mapper
+                    >::type
+{
+ public:
+  using Bar = typename Master_matrix::Bar;                            /**< Bar type. */
+  using Barcode = typename Master_matrix::Barcode;                    /**< Barcode type. */
+  using Column_container = typename Master_matrix::Column_container;  /**< Column container type. */
+  using Index = typename Master_matrix::Index;                        /**< Container index type. */
+  using Dimension = typename Master_matrix::Dimension;                /**< Dimension value 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) {
+    if constexpr (Master_matrix::Option_list::has_removable_columns) {
+      swap(static_cast<Cell_position_to_ID_mapper<ID_index, Pos_index>&>(pairing1),
+           static_cast<Cell_position_to_ID_mapper<ID_index, Pos_index>&>(pairing2));
+    }
+    pairing1.barcode_.swap(pairing2.barcode_);
+    pairing1.deathToBar_.swap(pairing2.deathToBar_);
+    pairing1.idToPosition_.swap(pairing2.idToPosition_);
+    std::swap(pairing1.isReduced_, pairing2.isReduced_);
+  }
+
+ protected:
+  using Pos_index = typename Master_matrix::Pos_index;
+  using ID_index = typename Master_matrix::ID_index;
+  using Dictionary = typename Master_matrix::Bar_dictionary;
+  using Base_matrix = typename Master_matrix::Master_boundary_matrix;
+  //PIDM = Position to ID Map
+  using PIDM = typename std::conditional<Master_matrix::Option_list::has_removable_columns,
+                                         Cell_position_to_ID_mapper<ID_index, Pos_index>,
+                                         Dummy_pos_mapper
+                                        >::type;
+
+  Barcode barcode_;       /**< Bar container. */
+  Dictionary deathToBar_; /**< Map from death index to bar index. */
+  /**
+   * @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
+  bool isReduced_;        /**< True if `_reduce()` was called. */
+
+  void _reduce();
+  void _remove_last(Pos_index columnIndex);
+
+  //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() 
+{
+  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 (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, -1, 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() ? -1 : itNeg->second;
+
+        while (pivot != static_cast<ID_index>(-1) && pivotKiller != static_cast<Index>(-1)) {
+          if constexpr (Master_matrix::Option_list::is_z2) {
+            curr += _matrix()->get_column(pivotKiller);
+          } else {
+            auto& toadd = _matrix()->get_column(pivotKiller);
+            typename Master_matrix::Element coef = toadd.get_pivot_value();
+            auto& operators = _matrix()->colSettings_->operators;
+            coef = operators.get_inverse(coef);
+            operators.multiply_inplace(coef, operators.get_characteristic() - curr.get_pivot_value());
+            curr.multiply_source_and_add(toadd, coef);
+          }
+
+          pivot = curr.get_pivot();
+          it = idToPosition_.find(pivot);
+          pivotColumnNumber = it == idToPosition_.end() ? pivot : it->second;
+          itNeg = negativeColumns.find(pivotColumnNumber);
+          pivotKiller = itNeg == negativeColumns.end() ? -1 : itNeg->second;
+        }
+
+        if (pivot != static_cast<ID_index>(-1)) {
+          negativeColumns.emplace(pivotColumnNumber, i);
+          _matrix()->get_column(pivotColumnNumber).clear();
+          barcode_.emplace_back(pivotColumnNumber, i, dim - 1);
+        } else {
+          curr.clear();
+          barcode_.emplace_back(i, -1, 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 != static_cast<Pos_index>(-1)) {
+        deathToBar_.emplace(d, i);
+      }
+    }
+  }
+
+  isReduced_ = true;
+}
+
+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 = -1;
+      deathToBar_.erase(it);
+    };
+  }
+
+  auto it = PIDM::map_.find(columnIndex);
+  if (it != PIDM::map_.end()){
+    idToPosition_.erase(it->second);
+    PIDM::map_.erase(it);
+  }
+}
+
+}  // namespace persistence_matrix
+}  // namespace Gudhi
+
+#endif  // PM_BASE_PAIRING_H

multipers/gudhi/gudhi/Persistence_matrix/base_swap.h

@@ -0,0 +1,211 @@
+/*    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) {}
+
+  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;
+
+  /**
+   * @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=(Base_swap other);
+  /**
+   * @brief Swap operator.
+   */
+  friend void swap(Base_swap& base1, Base_swap& base2) {
+    base1.indexToRow_.swap(base2.indexToRow_);
+    base1.rowToIndex_.swap(base2.rowToIndex_);
+    std::swap(base1.rowSwapped_, base2.rowSwapped_);
+  }
+
+ protected:
+  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()`. */
+
+  void _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_, 0))
+{}
+
+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)
+{
+  indexToRow_.swap(other.indexToRow_);
+  rowToIndex_.swap(other.rowToIndex_);
+  std::swap(rowSwapped_, other.rowSwapped_);
+  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;
+}
+
+}  // namespace persistence_matrix
+}  // namespace Gudhi
+
+#endif  // PM_BASE_SWAP_H

multipers/gudhi/gudhi/Persistence_matrix/boundary_cell_position_to_id_mapper.h

@@ -0,0 +1,60 @@
+/*    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 boundary_cell_position_to_id_mapper.h
+ * @author Hannah Schreiber
+ * @brief Contains the @ref Gudhi::persistence_matrix::Cell_position_to_ID_mapper class and
+ * @ref Gudhi::persistence_matrix::Dummy_pos_mapper structure.
+ */
+
+#ifndef PM_ID_POS_MAPPER_H
+#define PM_ID_POS_MAPPER_H
+
+#include <unordered_map>
+
+namespace Gudhi {
+namespace persistence_matrix {
+
+/**
+ * @private
+ * @ingroup persistence_matrix
+ *
+ * @brief Empty structure.
+ * Inherited instead of @ref Cell_position_to_ID_mapper.
+ */
+struct Dummy_pos_mapper {
+  friend void swap([[maybe_unused]] Dummy_pos_mapper& d1, [[maybe_unused]] Dummy_pos_mapper& d2) {}
+};
+
+/**
+ * @private
+ * @ingroup persistence_matrix
+ *
+ * @brief Map from cell position to cell ID. Only stores a pair if ID != position and has_removable_column is true.
+ * 
+ * @tparam ID_index @ref IDIdx index type
+ * @tparam Pos_index @ref PosIdx index type
+ */
+template<typename ID_index, typename Pos_index>
+struct Cell_position_to_ID_mapper {
+  using Index_map = std::unordered_map<Pos_index,ID_index>; //TODO: test other map types
+
+  Index_map map_;
+
+  friend void swap(Cell_position_to_ID_mapper& mapper1, Cell_position_to_ID_mapper& mapper2) {
+    mapper1.map_.swap(mapper2.map_);
+  }
+};
+
+}  // namespace persistence_matrix
+}  // namespace Gudhi
+
+#endif  // PM_ID_POS_MAPPER_H

multipers/gudhi/gudhi/Persistence_matrix/boundary_face_position_to_id_mapper.h

@@ -0,0 +1,60 @@
+/*    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_ID_POS_MAPPER_H
+#define PM_ID_POS_MAPPER_H
+
+#include <unordered_map>
+
+namespace Gudhi {
+namespace persistence_matrix {
+
+/**
+ * @private
+ * @ingroup persistence_matrix
+ *
+ * @brief Empty structure.
+ * Inherited instead of @ref Face_position_to_ID_mapper.
+ */
+struct Dummy_pos_mapper {
+  friend void swap([[maybe_unused]] Dummy_pos_mapper& d1, [[maybe_unused]] Dummy_pos_mapper& d2) {}
+};
+
+/**
+ * @private
+ * @ingroup persistence_matrix
+ *
+ * @brief Map from face position to face ID. Only stores a pair if ID != position and has_removable_column is true.
+ * 
+ * @tparam ID_index @ref IDIdx index type
+ * @tparam Pos_index @ref PosIdx index type
+ */
+template<typename ID_index, typename Pos_index>
+struct Face_position_to_ID_mapper {
+  using Index_map = std::unordered_map<Pos_index,ID_index>; //TODO: test other map types
+
+  Index_map map_;
+
+  friend void swap(Face_position_to_ID_mapper& mapper1, Face_position_to_ID_mapper& mapper2) {
+    mapper1.map_.swap(mapper2.map_);
+  }
+};
+
+}  // namespace persistence_matrix
+}  // namespace Gudhi
+
+#endif  // PM_ID_POS_MAPPER_H