multipers 2.3.3b6__cp313-cp313-macosx_11_0_arm64.whl

multipers/gudhi/mma_interface_coh.h

@@ -0,0 +1,256 @@
+/*    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 options.h
+ * @author Hannah Schreiber
+ * @brief Interface of the matrix for MMA
+ */
+
+#ifndef MMA_INTERFACE_COH_H
+#define MMA_INTERFACE_COH_H
+
+#include <cstddef>
+#include <limits>
+#include <ostream>
+#include <utility>
+#include <vector>
+
+#include <gudhi/persistence_interval.h>
+#include <gudhi/Persistent_cohomology.h>
+
+namespace Gudhi {
+namespace multiparameter {
+namespace truc_interface {
+
+template <class Structure>
+class Boundary_matrix_as_filtered_complex_for_coh {
+ public:
+  using Simplex_key = std::uint32_t;
+  using Simplex_handle = Simplex_key;
+  using Filtration_value = Simplex_key;
+  using Dimension = int;
+
+  class Filtration_range_iterator
+      : public boost::iterator_facade<Filtration_range_iterator, const Simplex_handle &, boost::forward_traversal_tag> {
+   public:
+    Filtration_range_iterator(const std::vector<Simplex_handle> *new_to_old_perm = nullptr)
+        : new_to_old_perm_(new_to_old_perm), currPos_(0) {
+      if (new_to_old_perm_ != nullptr) {
+        find_next_valid_index();
+      }
+    }
+
+   private:
+    // mandatory for the boost::iterator_facade inheritance.
+    friend class boost::iterator_core_access;
+
+    const std::vector<Simplex_handle> *new_to_old_perm_;
+    std::size_t currPos_;
+
+    bool equal(Filtration_range_iterator const &other) const {
+      return new_to_old_perm_ == other.new_to_old_perm_ && currPos_ == other.currPos_;
+    }
+
+    const Simplex_handle &dereference() const { return (*new_to_old_perm_)[currPos_]; }
+
+    void increment() {
+      ++currPos_;
+      find_next_valid_index();
+    }
+
+    void set_to_end() {
+      new_to_old_perm_ = nullptr;
+      currPos_ = 0;
+    }
+
+    void find_next_valid_index() {
+      while (currPos_ < new_to_old_perm_->size() && dereference() >= new_to_old_perm_->size()) ++currPos_;
+      if (currPos_ == new_to_old_perm_->size()) set_to_end();
+    }
+  };
+
+  class Filtration_simplex_range {
+   public:
+    using iterator = Filtration_range_iterator;
+
+    Filtration_simplex_range(std::vector<Simplex_handle> const *new_to_old_perm)
+        : new_to_old_perm_(new_to_old_perm), size_(-1) {}
+
+    iterator begin() const { return iterator(new_to_old_perm_); }
+
+    iterator end() const { return iterator(); }
+
+    std::size_t size() {
+      if (size_ == static_cast<std::size_t>(-1)) {
+        size_ = 0;
+        for (auto i : *new_to_old_perm_) {
+          if (i < new_to_old_perm_->size()) ++size_;
+        }
+      }
+      return size_;
+    }
+
+    inline friend std::ostream &operator<<(std::ostream &stream, const Filtration_simplex_range &range) {
+      stream << "Filtration_simplex_range: ";
+      for (const auto idx : range) {
+        stream << idx << " ";
+      }
+      stream << "\n";
+      return stream;
+    }
+
+   private:
+    std::vector<Simplex_handle> const *new_to_old_perm_;
+    std::size_t size_;
+  };
+
+  Boundary_matrix_as_filtered_complex_for_coh() : boundaries_(nullptr), new_to_old_perm_(nullptr) {}
+
+  Boundary_matrix_as_filtered_complex_for_coh(const Structure &boundaries,
+                                              const std::vector<Simplex_handle> &permutation)
+      : boundaries_(&boundaries),
+        new_to_old_perm_(&permutation),
+        keys_(permutation.size(), -1),
+        keysToSH_(permutation.size(), -1) {
+    assert(permutation.size() == boundaries.size());
+  }
+
+  friend void swap(Boundary_matrix_as_filtered_complex_for_coh &be1, Boundary_matrix_as_filtered_complex_for_coh &be2) {
+    std::swap(be1.boundaries_, be2.boundaries_);
+    std::swap(be1.new_to_old_perm_, be2.new_to_old_perm_);
+    be1.keys_.swap(be2.keys_);
+    be1.keysToSH_.swap(be2.keysToSH_);
+  }
+
+  std::size_t num_simplices() const { return boundaries_->size(); }
+
+  Filtration_value filtration(Simplex_handle sh) const {
+    return sh == null_simplex() ? std::numeric_limits<Filtration_value>::max() : keys_[sh];
+  }
+
+  Dimension dimension() const { return boundaries_->max_dimension(); }
+
+  Dimension dimension(Simplex_handle sh) const { return sh == null_simplex() ? -1 : boundaries_->dimension(sh); }
+
+  void assign_key(Simplex_handle sh, Simplex_key key) {
+    if (sh != null_simplex()) keys_[sh] = key;
+    if (key != null_key()) keysToSH_[key] = sh;
+  }
+
+  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); }
+
+  Simplex_handle simplex(Simplex_key key) const { return key == null_key() ? null_simplex() : keysToSH_[key]; }
+
+  static constexpr Simplex_handle null_simplex() { return static_cast<Simplex_handle>(-1); }
+
+  std::pair<Simplex_handle, Simplex_handle> endpoints(Simplex_handle sh) const {
+    if (sh == null_simplex()) return {null_simplex(), null_simplex()};
+    assert(dimension(sh) == 1);
+    const auto &col = (*boundaries_)[sh];
+    assert(col.size() == 2);
+    return {col[0], col[1]};
+  }
+
+  Filtration_simplex_range filtration_simplex_range() const { return Filtration_simplex_range(new_to_old_perm_); }
+
+  const std::vector<Simplex_handle> &boundary_simplex_range(Simplex_handle sh) const { return (*boundaries_)[sh]; }
+
+  void set_permutation(const std::vector<Simplex_handle> &permutation) { new_to_old_perm_ = &permutation; }
+
+  friend std::ostream &operator<<(std::ostream &stream, const Boundary_matrix_as_filtered_complex_for_coh &structure) {
+    std::vector<Simplex_key> inv(structure.new_to_old_perm_->size());
+    for (unsigned int i = 0; i < structure.new_to_old_perm_->size(); ++i) {
+      inv[(*structure.new_to_old_perm_)[i]] = i;
+    }
+
+    stream << "[\n";
+    for (auto i : structure.filtration_simplex_range()) {
+      stream << "[";
+      for (const auto &stuff : structure.boundary_simplex_range(i)) stream << inv[stuff] << ", ";
+      stream << "]\n";
+    }
+
+    stream << "]\n";
+    return stream;
+  }
+
+ private:
+  Structure const *boundaries_;
+  std::vector<Simplex_handle> const *new_to_old_perm_;
+  std::vector<Simplex_key> keys_;
+  std::vector<Simplex_handle> keysToSH_;
+};
+
+template <class Boundary_matrix_type>
+class Persistence_backend_cohomology {
+ public:
+  using MatrixComplex = Boundary_matrix_as_filtered_complex_for_coh<Boundary_matrix_type>;
+  using pos_index = typename MatrixComplex::Simplex_key;
+  using dimension_type = typename MatrixComplex::Dimension;
+  using bar = Gudhi::persistence_matrix::Persistence_interval<dimension_type, typename MatrixComplex::Simplex_handle>;
+  using Barcode = std::vector<bar>;
+  using Field_Zp = Gudhi::persistent_cohomology::Field_Zp;
+  using Persistent_cohomology = Gudhi::persistent_cohomology::Persistent_cohomology<MatrixComplex, Field_Zp>;
+  static const bool is_vine = false;
+  using Index = typename MatrixComplex::Simplex_handle;
+  using cycle_type = void;
+
+  Persistence_backend_cohomology() {};
+
+  Persistence_backend_cohomology(const Boundary_matrix_type &boundaries, std::vector<Index> &permutation)
+      : matrix_(boundaries, permutation) {}
+
+  friend void swap(Persistence_backend_cohomology &be1, Persistence_backend_cohomology &be2) {
+    swap(be1.matrix_, be2.matrix_);
+  }
+
+  dimension_type get_dimension(pos_index i) { return matrix_.dimension(matrix_.simplex(i)); }
+
+  Barcode get_barcode() {
+    Persistent_cohomology pcoh(matrix_, true);
+    pcoh.init_coefficients(2);
+    pcoh.compute_persistent_cohomology(0, false);
+
+    const auto &pairs = pcoh.get_persistent_pairs();
+    Barcode barcode(pairs.size());
+
+    unsigned int i = 0;
+    for (const auto &p : pairs) {
+      auto &b = barcode[i];
+      b.dim = matrix_.dimension(get<0>(p));
+      b.birth = get<0>(p);
+      b.death = get<1>(p);
+      ++i;
+    }
+
+    return barcode;
+  }
+
+  std::size_t size() { return matrix_.num_simplices(); }
+
+  friend std::ostream &operator<<(std::ostream &stream, Persistence_backend_cohomology &structure) {
+    stream << structure.matrix_ << "\n";
+    return stream;
+  }
+
+  void _update_permutation_ptr(std::vector<Index> &perm) { matrix_.set_permutation(perm); }
+
+ private:
+  MatrixComplex matrix_;
+};
+
+}  // namespace truc_interface
+}  // namespace multiparameter
+}  // namespace Gudhi
+
+#endif  // MMA_INTERFACE_COH_H

multipers/gudhi/mma_interface_h0.h

@@ -0,0 +1,223 @@
+
+/*    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
+ */
+/**
+ * @file options.h
+ * @author Hannah Schreiber
+ * @brief Interface of the matrix for MMA
+ */
+
+#ifndef MMA_INTERFACE_H0_H
+#define MMA_INTERFACE_H0_H
+
+#include <cstddef>
+#include <iostream>
+#include <utility>
+#include <vector>
+
+#include <boost/iterator/iterator_facade.hpp>
+
+#include <naive_merge_tree.h>
+
+namespace Gudhi {
+namespace multiparameter {
+namespace truc_interface {
+
+template <class Boundary_matrix_type>
+class Persistence_backend_h0 {
+ public:
+  using pos_index = int;
+  using dimension_type = int;
+  using cycle_type = std::vector<unsigned int>;
+  static const bool is_vine = true;
+
+  std::vector<cycle_type> get_representative_cycles([[maybe_unused]] bool update = true) const { throw "Unimplemented"; }
+
+  class Barcode_iterator : public boost::iterator_facade<Barcode_iterator, const Bar &, boost::forward_traversal_tag> {
+   public:
+    Barcode_iterator(const std::vector<Bar> *barcode, const std::vector<std::size_t> *inv)
+        : barcode_(barcode->size() == 0 ? nullptr : barcode), perm_(barcode->size() == 0 ? nullptr : inv), currPos_(0) {
+      if (barcode->size() != 0) {
+        auto &b = barcode_->operator[](currPos_);
+        currBar_.dim = b.dim;
+        currBar_.birth = perm_->operator[](b.birth);
+        currBar_.death = b.death == -1 ? -1 : perm_->operator[](b.death);
+      }
+    }
+
+    Barcode_iterator() : barcode_(nullptr), perm_(nullptr), currPos_(0) {}
+
+   private:
+    // mandatory for the boost::iterator_facade inheritance.
+    friend class boost::iterator_core_access;
+
+    const std::vector<Bar> *barcode_;
+    const std::vector<std::size_t> *perm_;
+    std::size_t currPos_;
+    Bar currBar_;
+
+    bool equal(Barcode_iterator const &other) const {
+      return barcode_ == other.barcode_ && perm_ == other.perm_ && currPos_ == other.currPos_;
+    }
+
+    const Bar &dereference() const { return currBar_; }
+
+    void increment() {
+      ++currPos_;
+      if (currPos_ == barcode_->size()) {
+        barcode_ = nullptr;
+        perm_ = nullptr;
+        currPos_ = 0;
+      } else {
+        auto &b = barcode_->operator[](currPos_);
+        currBar_.dim = b.dim;
+        currBar_.birth = perm_->operator[](b.birth);
+        currBar_.death = b.death == -1 ? -1 : perm_->operator[](b.death);
+      }
+    }
+  };
+
+  class Barcode {
+   public:
+    using iterator = Barcode_iterator;
+
+    Barcode(Naive_merge_forest &mf, const std::vector<std::size_t> *perm) : barcode_(&mf.get_barcode()), perm_(perm) {}
+
+    iterator begin() const { return Barcode_iterator(barcode_, perm_); }
+
+    iterator end() const { return Barcode_iterator(); }
+
+    std::size_t size() const { return barcode_->size(); }
+
+    inline friend std::ostream &operator<<(std::ostream &stream, Barcode &structure) {
+      stream << "Barcode: " << structure.size() << "\n";
+      for (const auto bar : structure) {
+        stream << "[" << bar.dim << "] ";
+        stream << bar.birth << ", " << bar.death;
+        stream << "\n";
+      }
+      stream << "\n";
+      return stream;
+    }
+
+   private:
+    const std::vector<Bar> *barcode_;
+    const std::vector<std::size_t> *perm_;
+  };
+
+  Persistence_backend_h0() {}
+
+  Persistence_backend_h0(const Boundary_matrix_type &boundaries, std::vector<std::size_t> &permutation)
+      : pers_(boundaries.size(), boundaries.num_vertices()),
+        boundaries_(&boundaries),
+        permutation_(&permutation),
+        permutationInv_(permutation_->size()) {
+    unsigned int c = 0;
+    for (std::size_t i : *permutation_) {
+      if (i == static_cast<std::size_t>(-1)) {
+        c++;
+        continue;
+      }
+      permutationInv_[i] = c;
+      if (boundaries.dimension(i) == 0) {
+        pers_.add_vertex(c++);
+      } else if (boundaries.dimension(i) == 1) {
+        pers_.add_edge(c++, permutationInv_[boundaries[i][0]], permutationInv_[boundaries[i][1]]);
+      } else {
+        std::cout << "Simplex of dimension > 1 got ignored.\n";
+      }
+    }
+    pers_.initialize();
+  }
+
+  Persistence_backend_h0(const Persistence_backend_h0 &toCopy)
+      : pers_(toCopy.pers_),
+        boundaries_(toCopy.boundaries_),
+        permutation_(toCopy.permutation_),
+        permutationInv_(toCopy.permutationInv_) {}
+
+  Persistence_backend_h0(Persistence_backend_h0 &&other) noexcept
+      : pers_(std::move(other.pers_)),
+        boundaries_(std::exchange(other.boundaries_, nullptr)),
+        permutation_(std::exchange(other.permutation_, nullptr)),
+        permutationInv_(std::move(other.permutationInv_)) {}
+
+  Persistence_backend_h0 &operator=(Persistence_backend_h0 other) {
+    swap(pers_, other.pers_);
+    std::swap(boundaries_, other.boundaries_);
+    std::swap(permutation_, other.permutation_);
+    permutationInv_.swap(other.permutationInv_);
+    return *this;
+  }
+
+  friend void swap(Persistence_backend_h0 &be1, Persistence_backend_h0 &be2) {
+    swap(be1.pers_, be2.pers_);
+    std::swap(be1.boundaries_, be2.boundaries_);
+    std::swap(be1.permutation_, be2.permutation_);
+    be1.permutationInv_.swap(be2.permutationInv_);
+  }
+
+  dimension_type get_dimension(pos_index i) { return pers_.get_dimension(i); }
+
+  void vine_swap(pos_index i) {
+    if (pers_.get_dimension(i) == 0) {
+      if (pers_.get_dimension(i + 1) == 1) {
+        const auto &boundary = boundaries_->operator[](permutation_->operator[](i + 1));
+        pers_.vertex_edge_swap(i, permutationInv_[boundary[0]], permutationInv_[boundary[1]]);
+        std::swap(permutationInv_[permutation_->operator[](i)], permutationInv_[permutation_->operator[](i + 1)]);
+        return;
+      }
+      pers_.vertex_swap(i);
+      std::swap(permutationInv_[permutation_->operator[](i)], permutationInv_[permutation_->operator[](i + 1)]);
+      return;
+    }
+
+    if (pers_.get_dimension(i + 1) == 1) {
+      const auto &boundary1 = boundaries_->operator[](permutation_->operator[](i));
+      const auto &boundary2 = boundaries_->operator[](permutation_->operator[](i + 1));
+      pers_.edge_edge_swap(i,
+                           permutationInv_[boundary1[0]],
+                           permutationInv_[boundary1[1]],
+                           permutationInv_[boundary2[0]],
+                           permutationInv_[boundary2[1]]);
+      std::swap(permutationInv_[permutation_->operator[](i)], permutationInv_[permutation_->operator[](i + 1)]);
+      return;
+    }
+
+    const auto &boundary = boundaries_->operator[](permutation_->operator[](i));
+    pers_.edge_vertex_swap(i, permutationInv_[boundary[0]], permutationInv_[boundary[1]]);
+    std::swap(permutationInv_[permutation_->operator[](i)], permutationInv_[permutation_->operator[](i + 1)]);
+  }
+
+  Barcode get_barcode() { return Barcode(pers_, permutation_); }
+
+  std::size_t size() {
+    throw;  // TODO:
+  }
+
+  inline friend std::ostream &operator<<(std::ostream &stream, Persistence_backend_h0 &structure) {
+    stream << structure.pers_;
+    stream << std::endl;
+    return stream;
+  }
+
+  inline void _update_permutation_ptr(std::vector<std::size_t> &perm) { permutation_ = &perm; }
+
+ private:
+  Naive_merge_forest pers_;
+  const Boundary_matrix_type *boundaries_;
+  std::vector<std::size_t> *permutation_;
+  std::vector<std::size_t> permutationInv_;
+};
+}  // namespace truc_interface
+}  // namespace multiparameter
+}  // namespace Gudhi
+#endif  // MMA_INTERFACE_H0_H