multipers 2.4.0b1__cp312-cp312-macosx_11_0_arm64.whl

multipers/gudhi/gudhi/Multi_persistence/Multi_parameter_filtered_complex_pcoh_interface.h

@@ -0,0 +1,268 @@
+/*    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) 2025 Inria
+ *
+ *    Modification(s):
+ *      - YYYY/MM Author: Description of the modification
+ */
+
+/**
+ * @file Multi_parameter_filtered_complex_pcoh_interface.h
+ * @author Hannah Schreiber
+ * @brief Contains the @ref Gudhi::multi_persistence::Multi_parameter_filtered_complex_pcoh_interface class.
+ */
+
+#ifndef MP_COMPLEX_PCOH_INTERFACE_H_INCLUDED
+#define MP_COMPLEX_PCOH_INTERFACE_H_INCLUDED
+
+#include <utility>
+#include <vector>
+
+#include <gudhi/Debug_utils.h>
+#include <gudhi/Multi_parameter_filtered_complex.h>
+
+namespace Gudhi {
+namespace multi_persistence {
+
+/**
+ * @class Multi_parameter_filtered_complex_pcoh_interface Multi_parameter_filtered_complex_pcoh_interface.h \
+ * gudhi/Multi_persistence/Multi_parameter_filtered_complex_pcoh_interface.h
+ * @ingroup multi_persistence
+ *
+ * @brief Interface respecting the @ref FilteredComplex concept to use
+ * @ref Gudhi::persistent_cohomology::Persistent_cohomology with an instantiation of
+ * @ref Multi_parameter_filtered_complex.
+ *
+ * @tparam MultiFiltrationValue Filtration value type used in @ref Multi_parameter_filtered_complex.
+ */
+template <class MultiFiltrationValue>
+class Multi_parameter_filtered_complex_pcoh_interface
+{
+ public:
+  using Complex = Multi_parameter_filtered_complex<MultiFiltrationValue>; /**< Complex type */
+  using Simplex_key = std::uint32_t;                                      /**< Simplex_key type */
+  using Simplex_handle = Simplex_key;                                     /**< Simplex_handle type */
+  using Filtration_value = Simplex_key;                                   /**< Internal filtration value type */
+  using Dimension = int;                                                  /**< Internal dimension type */
+  using Map = std::vector<Simplex_handle>;                                /**< Map type */
+  using Filtration_simplex_range = Map;                                   /**< Filtration_simplex_range type */
+  using Boundary_simplex_range = Map;                                     /**< Boundary_simplex_range type */
+
+  /**
+   * @brief Default constructor, storing null pointers.Can be tested with @ref is_initialized(), but any other method
+   * should not be used with this constructor.
+   */
+  Multi_parameter_filtered_complex_pcoh_interface() : boundaries_(nullptr), newToOldPerm_(nullptr) {}
+
+  /**
+   * @brief Constructs the interface and stores a pointer to the given complex and the given permutation. Assumes that
+   * the pointers remain valid through the whole life of the instance. If they get invalidated, they can be updated
+   * via the copy/move constructors if the content did not change (otherwise, reconstruct from scratch with
+   * @ref reinitialize).
+   *
+   * @param boundaries Complex to interface.
+   * @param permutation Permutation map indicating the order of the cells stored in @p boundaries as a standard
+   * 1-dimensional filtration. I.e., `permutation[i]` corresponds to the index in `boundaries` which should be
+   * used as the i-th cell in the filtration.
+   */
+  Multi_parameter_filtered_complex_pcoh_interface(const Complex &boundaries, const Map &permutation)
+      : boundaries_(&boundaries), newToOldPerm_(&permutation), keys_(boundaries.get_number_of_cycle_generators(), -1)
+  {}
+
+  Multi_parameter_filtered_complex_pcoh_interface(const Multi_parameter_filtered_complex_pcoh_interface &other) =
+      delete;
+
+  /**
+   * @brief Copy constructor. Copies the complex pointer from @p other and updates the permutation pointer with the
+   * given map if the complex was initialized.
+   *
+   * @param other Interface to copy.
+   * @param permutation Permutation map. Has to correspond to the same map than in @p other, except that its address
+   * does not have to be the same.
+   */
+  Multi_parameter_filtered_complex_pcoh_interface(const Multi_parameter_filtered_complex_pcoh_interface &other,
+                                                  const Map &permutation)
+      : boundaries_(other.boundaries_),
+        newToOldPerm_(boundaries_ != nullptr ? &permutation : nullptr),
+        keys_(other.keys_)
+  {
+    GUDHI_CHECK(!other.is_initialized() || permutation == *other.newToOldPerm_,
+                "Only the address of the permutation vector is allowed to change, not its content.");
+  }
+
+  /**
+   * @brief Copy constructor. Updates the pointers with the given complex and map if @p other was initialized.
+   *
+   * @param other Interface to copy.
+   * @param boundaries Complex. Has to correspond to the same complex than in @p other, except that its address
+   * does not have to be the same.
+   * @param permutation Permutation map. Has to correspond to the same map than in @p other, except that its address
+   * does not have to be the same.
+   */
+  Multi_parameter_filtered_complex_pcoh_interface(const Multi_parameter_filtered_complex_pcoh_interface &other,
+                                                  const Complex &boundaries,
+                                                  const Map &permutation)
+      : boundaries_(other.is_initialized() ? &boundaries : nullptr),
+        newToOldPerm_(other.is_initialized() ? &permutation : nullptr),
+        keys_(other.keys_)
+  {
+    GUDHI_CHECK(!other.is_initialized() || permutation == *other.newToOldPerm_,
+                "Only the address of the permutation vector is allowed to change, not its content.");
+    GUDHI_CHECK(!other.is_initialized() || boundaries.get_boundaries() == *other.boundaries_->get_boundaries(),
+                "Only the address of the complex is allowed to change, not its content.");
+  }
+
+  Multi_parameter_filtered_complex_pcoh_interface(Multi_parameter_filtered_complex_pcoh_interface &&other) = delete;
+
+  /**
+   * @brief Move constructor. Moves the complex pointer from @p other and updates the permutation pointer with the
+   * given map if the complex was initialized.
+   *
+   * @param other Interface to move.
+   * @param permutation Permutation map. Has to correspond to the same map than in @p other, except that its address
+   * does not have to be the same.
+   */
+  Multi_parameter_filtered_complex_pcoh_interface(Multi_parameter_filtered_complex_pcoh_interface &&other,
+                                                  const Map &permutation)
+      : boundaries_(std::exchange(other.boundaries_, nullptr)),
+        newToOldPerm_(boundaries_ != nullptr ? &permutation : nullptr),
+        keys_(std::move(other.keys_))
+  {
+    other.newToOldPerm_ = nullptr;
+  }
+
+  /**
+   * @brief Move constructor. Updates the pointers with the given complex and map if @p other was initialized.
+   *
+   * @param other Interface to move.
+   * @param boundaries Complex. Has to correspond to the same complex than in @p other, except that its address
+   * does not have to be the same.
+   * @param permutation Permutation map. Has to correspond to the same map than in @p other, except that its address
+   * does not have to be the same.
+   */
+  Multi_parameter_filtered_complex_pcoh_interface(Multi_parameter_filtered_complex_pcoh_interface &&other,
+                                                  const Complex &boundaries,
+                                                  const Map &permutation)
+      : boundaries_(other.is_initialized() ? &boundaries : nullptr),
+        newToOldPerm_(other.is_initialized() ? &permutation : nullptr),
+        keys_(std::move(other.keys_))
+  {
+    other.boundaries_ = nullptr;
+    other.newToOldPerm_ = nullptr;
+  }
+
+  ~Multi_parameter_filtered_complex_pcoh_interface() = default;
+
+  Multi_parameter_filtered_complex_pcoh_interface &operator=(
+      const Multi_parameter_filtered_complex_pcoh_interface &other) = delete;
+  Multi_parameter_filtered_complex_pcoh_interface &operator=(
+      Multi_parameter_filtered_complex_pcoh_interface &&other) noexcept = delete;
+
+  /**
+   * @brief Swap operator.
+   */
+  friend void swap(Multi_parameter_filtered_complex_pcoh_interface &be1,
+                   Multi_parameter_filtered_complex_pcoh_interface &be2) noexcept
+  {
+    std::swap(be1.boundaries_, be2.boundaries_);
+    std::swap(be1.newToOldPerm_, be2.newToOldPerm_);
+    be1.keys_.swap(be2.keys_);
+  }
+
+  /**
+   * @brief Reinitializes the interface with the new given complex and permutation.
+   * To use instead of the classical assign operator `operator=`.
+   */
+  void reinitialize(const Complex &boundaries, const Map &permutation)
+  {
+    boundaries_ = &boundaries;
+    newToOldPerm_ = &permutation;
+    keys_ = Map(boundaries.get_number_of_cycle_generators(), -1);
+  }
+
+  void reset()
+  {
+    boundaries_ = nullptr;
+    newToOldPerm_ = nullptr;
+    keys_.clear();
+  }
+
+  /**
+   * @brief Returns `true` if and only if all pointers are not null.
+   */
+  [[nodiscard]] bool is_initialized() const { return boundaries_ != nullptr && newToOldPerm_ != nullptr; }
+
+  [[nodiscard]] std::size_t num_simplices() const { return newToOldPerm_->size(); }
+
+  [[nodiscard]] Filtration_value filtration(Simplex_handle sh) const
+  {
+    return sh == null_simplex() ? std::numeric_limits<Filtration_value>::max() : keys_[sh];
+  }
+
+  [[nodiscard]] Dimension dimension() const { return boundaries_->get_max_dimension(); }
+
+  [[nodiscard]] Dimension dimension(Simplex_handle sh) const
+  {
+    return sh == null_simplex() ? -1 : boundaries_->get_dimensions()[sh];
+  }
+
+  // assumes that pcoh will assign the keys from 0 to n in order of filtrations
+  void assign_key(Simplex_handle sh, Simplex_key key)
+  {
+    if (sh != null_simplex()) keys_[sh] = key;
+  }
+
+  [[nodiscard]] Simplex_key key(Simplex_handle sh) const { return sh == null_simplex() ? null_key() : keys_[sh]; }
+
+  static constexpr Simplex_key null_key() { return static_cast<Simplex_key>(-1); }
+
+  [[nodiscard]] Simplex_handle simplex(Simplex_key key) const
+  {
+    return key == null_key() ? null_simplex() : (*newToOldPerm_)[key];
+  }
+
+  static constexpr Simplex_handle null_simplex() { return static_cast<Simplex_handle>(-1); }
+
+  // only used in update_cohomology_groups_edge, so not used without optimizations
+  [[nodiscard]] std::pair<Simplex_handle, Simplex_handle> endpoints(Simplex_handle sh) const
+  {
+    if (sh == null_simplex()) return {null_simplex(), null_simplex()};
+    GUDHI_CHECK(dimension(sh) == 1, "Endpoints only available for edges.");
+    const auto &col = boundary_simplex_range(sh);
+    GUDHI_CHECK(col.size() == 2, "Edge should have two vertices as border.");
+    return {col[0], col[1]};
+  }
+
+  [[nodiscard]] const Filtration_simplex_range &filtration_simplex_range() const { return *newToOldPerm_; }
+
+  [[nodiscard]] const Boundary_simplex_range &boundary_simplex_range(Simplex_handle sh) const
+  {
+    return boundaries_->get_boundaries()[sh];
+  }
+
+  friend std::ostream &operator<<(std::ostream &stream,
+                                  const Multi_parameter_filtered_complex_pcoh_interface &complex)
+  {
+    stream << "[\n";
+    for (auto i : complex.filtration_simplex_range()) {
+      stream << "[";
+      for (const auto &idx : complex.boundary_simplex_range(i)) stream << complex.keys_[idx] << ", ";
+      stream << "]\n";
+    }
+
+    stream << "]\n";
+    return stream;
+  }
+
+ private:
+  Complex const *boundaries_; /**< Pointer to complex. */
+  Map const *newToOldPerm_;   /**< Pointer to filtration position to complex position map. */
+  Map keys_;                  /**< Keys assigned to a cell. TODO: potentially the identity. If yes, to remove. */
+};
+
+}  // namespace multi_persistence
+}  // namespace Gudhi
+
+#endif  // MP_COMPLEX_PCOH_INTERFACE_H_INCLUDED

multipers/gudhi/gudhi/Multi_persistence/Persistence_interface_cohomology.h

@@ -0,0 +1,159 @@
+/*    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) 2025 Inria
+ *
+ *    Modification(s):
+ *      - YYYY/MM Author: Description of the modification
+ */
+
+/**
+ * @file Persistence_interface_cohomology.h
+ * @author Hannah Schreiber
+ * @brief Contains the @ref Gudhi::multi_persistence::Persistence_interface_cohomology class.
+ */
+
+#ifndef MP_PERSISTENCE_INTERFACE_COHOMOLOGY_H_INCLUDED
+#define MP_PERSISTENCE_INTERFACE_COHOMOLOGY_H_INCLUDED
+
+#include <vector>
+
+#include <boost/range/iterator_range_core.hpp>
+
+#include <gudhi/Multi_persistence/Multi_parameter_filtered_complex_pcoh_interface.h>
+#include <gudhi/persistence_interval.h>
+#include <gudhi/Persistent_cohomology.h>
+
+namespace Gudhi {
+namespace multi_persistence {
+
+/**
+ * @class Persistence_interface_cohomology Persistence_interface_cohomology.h \
+ * gudhi/Multi_persistence/Persistence_interface_cohomology.h
+ * @ingroup multi_persistence
+ *
+ * @brief Interface respecting the @ref PersistenceAlgorithm concept to use @ref Slicer with the cohomology
+ * algorithm implemented in @ref Gudhi::persistent_cohomology::Persistent_cohomology.
+ *
+ * @tparam MultiFiltrationValue Filtration value type used in @ref Slicer.
+ */
+template <class MultiFiltrationValue>
+class Persistence_interface_cohomology
+{
+ public:
+  using PCOH_complex = Multi_parameter_filtered_complex_pcoh_interface<MultiFiltrationValue>;
+  using Complex = typename PCOH_complex::Complex;                                /**< Complex type */
+  using Dimension = typename PCOH_complex::Dimension;                            /**< Dimension type */
+  using Index = typename PCOH_complex::Simplex_key;                              /**< Index type */
+  using Map = typename PCOH_complex::Map;                                        /**< Map type */
+  using Bar = Gudhi::persistence_matrix::Persistence_interval<Dimension, Index>; /**< Bar type */
+  using Field_Zp = Gudhi::persistent_cohomology::Field_Zp;
+  using Persistent_cohomology = Gudhi::persistent_cohomology::Persistent_cohomology<PCOH_complex, Field_Zp>;
+  using Barcode = std::vector<Bar>;                                              /**< Barcode type */
+  template<class Complex>
+  using As_type = Persistence_interface_cohomology<typename Complex::Filtration_value>; /**< This type. */
+
+  static constexpr const auto nullDeath = Bar::inf;
+  static constexpr const bool is_vine = false;        /** False. */
+  static constexpr const bool has_rep_cycles = false; /** False. */
+
+  Persistence_interface_cohomology() : interface_(), barcode_() {}
+
+  // `permutation` is assumed to have stable size, i.e., its address never changes
+  Persistence_interface_cohomology(const Complex& cpx, const Map& permutation) : interface_(cpx, permutation)
+  {
+    _initialize();
+  }
+
+  Persistence_interface_cohomology(const Persistence_interface_cohomology& other) = delete;
+
+  // permutation is assumed to be the same than from the copied object, just its address can change
+  Persistence_interface_cohomology(const Persistence_interface_cohomology& other, const Map& permutation)
+      : interface_(other.interface_, permutation), barcode_(other.barcode_)
+  {}
+
+  Persistence_interface_cohomology(Persistence_interface_cohomology&& other) = delete;
+
+  // permutation is assumed to be the same than from the moved object, just its address can change
+  Persistence_interface_cohomology(Persistence_interface_cohomology&& other, const Map& permutation)
+      : interface_(std::move(other.interface_), permutation), barcode_(std::move(other.barcode_))
+  {}
+
+  ~Persistence_interface_cohomology() = default;
+
+  Persistence_interface_cohomology& operator=(const Persistence_interface_cohomology& other) = delete;
+  Persistence_interface_cohomology& operator=(Persistence_interface_cohomology&& other) noexcept = delete;
+
+  // TODO: swap?
+
+  template <class Complex>
+  void reinitialize(const Complex& cpx, const Map& permutation)
+  {
+    interface_.reinitialize(cpx, permutation);
+    _initialize();
+  }
+
+  void reset()
+  {
+    interface_.reset();
+    barcode_.clear();
+  }
+
+  [[nodiscard]] bool is_initialized() const { return interface_.is_initialized(); }
+
+  Dimension get_dimension(Index i) const
+  {
+    GUDHI_CHECK(is_initialized(), "Dimension can not be computed uninitialized.");
+    return interface_.dimension(interface_.simplex(i));
+  }
+
+  const Barcode& get_barcode()
+  {
+    GUDHI_CHECK(is_initialized(), "Barcode can not be computed uninitialized.");
+    return barcode_;
+  }
+
+  /**
+   * @brief Outstream operator.
+   */
+  friend std::ostream& operator<<(std::ostream& stream, const Persistence_interface_cohomology& pers)
+  {
+    stream << "Complex:\n";
+    stream << pers.interface_ << "\n";
+    stream << "Barcode:\n";
+    for (const auto bar : pers.barcode_) {
+      stream << bar << "\n";
+    }
+    stream << "\n";
+
+    return stream;
+  }
+
+ private:
+  PCOH_complex interface_;
+  Barcode barcode_;
+
+  void _initialize()
+  {
+    Persistent_cohomology pcoh(interface_, true);
+    pcoh.init_coefficients(2);
+    pcoh.compute_persistent_cohomology_without_optimizations(0);
+    const auto& pairs = pcoh.get_persistent_pairs();
+
+    barcode_ = Barcode(pairs.size());
+    Index i = 0;
+    for (const auto& p : pairs) {
+      auto& b = barcode_[i];
+      b.dim = interface_.dimension(get<0>(p));
+      b.birth = get<0>(p);
+      b.death = get<1>(p) == PCOH_complex::null_simplex() ? Bar::inf : get<1>(p);
+      ++i;
+    }
+  }
+};
+
+}  // namespace multi_persistence
+}  // namespace Gudhi
+
+#endif  // MP_PERSISTENCE_INTERFACE_COHOMOLOGY_H_INCLUDED