multipers 2.3.0__cp310-cp310-win_amd64.whl → 2.3.2b1__cp310-cp310-win_amd64.whl

multipers/gudhi/truc.h

@@ -1,21 +1,27 @@
 #pragma once
+#include "gudhi/Matrix.h"
+#include "gudhi/mma_interface_matrix.h"
 #include "gudhi/Multi_persistence/Line.h"
 #include "multiparameter_module_approximation/format_python-cpp.h"
 #include <gudhi/One_critical_filtration.h>
 #include <gudhi/Multi_critical_filtration.h>
 #include <algorithm>
-#include <boost/mpl/aux_/na_fwd.hpp>
 #include <cassert>
+#include <csignal>
 #include <cstddef>
 #include <cstdint>
-// #include <gudhi/Simplex_tree/multi_filtrations/Finitely_critical_filtrations.h>
 #include <iostream>
 #include <limits>
 #include <numeric>
 #include <oneapi/tbb/enumerable_thread_specific.h>
 #include <oneapi/tbb/parallel_for.h>
+#include <oneapi/tbb/parallel_sort.h>
 #include <oneapi/tbb/task_group.h>
+#include <oneapi/tbb/mutex.h>
+#include <ostream>
+#include <ranges>
 #include <sstream>
+#include <stdexcept>
 #include <string>
 #include <utility>
 #include <vector>
@@ -27,6 +33,12 @@ namespace multiparameter {
 namespace truc_interface {
 using index_type = std::uint32_t;
 
+template <typename T, typename = void>
+struct has_columns : std::false_type {};
+
+template <typename T>
+struct has_columns<T, std::void_t<typename T::options>> : std::true_type {};
+
 class PresentationStructure {
  public:
   PresentationStructure() {}
@@ -71,9 +83,10 @@ class PresentationStructure {
 
   inline friend std::ostream &operator<<(std::ostream &stream, const PresentationStructure &structure) {
     stream << "Boundary:\n";
-    stream << "{";
-    for (const auto &stuff : structure.generators) {
-      stream << "{";
+    stream << "{\n";
+    for (auto i : std::views::iota(0u, structure.size())) {
+      const auto &stuff = structure.generators[i];
+      stream << i << ": {";
       for (auto truc : stuff) stream << truc << ", ";
 
       if (!stuff.empty()) stream << "\b" << "\b ";
@@ -116,6 +129,32 @@ class PresentationStructure {
     return idx;
   }
 
+  PresentationStructure permute(const std::vector<index_type> &order) const {
+    if (order.size() > generators.size()) {
+      throw std::invalid_argument("Permutation order must have the same size as the number of generators.");
+    }
+    index_type flag = -1;
+    std::vector<index_type> inverse_order(generators.size(), flag);
+    for (std::size_t i = 0; i < order.size(); i++) {
+      inverse_order[order[i]] = i;
+    }
+    std::vector<std::vector<index_type>> new_generators(order.size());
+    std::vector<int> new_generator_dimensions(order.size());
+
+    for (auto i : std::views::iota(0u, order.size())) {
+      new_generators[i].reserve(generators[order[i]].size());
+      for (std::size_t j = 0; j < generators[order[i]].size(); j++) {
+        index_type stuff = inverse_order[generators[order[i]][j]];
+        if (stuff != flag) new_generators[i].push_back(stuff);
+      }
+      std::sort(new_generators[i].begin(), new_generators[i].end());
+      new_generator_dimensions[i] = generator_dimensions[order[i]];
+    }
+    return PresentationStructure(new_generators, new_generator_dimensions);
+  }
+
+  void update_matrix(std::vector<std::vector<index_type>> &new_gens) { std::swap(generators, new_gens); }
+
  private:
   std::vector<std::vector<index_type>> generators;
   std::vector<int> generator_dimensions;
@@ -184,7 +223,7 @@ class SimplicialStructure {
 
   inline unsigned int max_dimension() const { return max_dimension_; }
 
-  int prune_above_dimension(int dim) { throw; }
+  int prune_above_dimension([[maybe_unused]] int dim) { throw "Not implemented"; }
 
  private:
   std::vector<std::vector<index_type>> boundaries;
@@ -196,9 +235,11 @@ template <class PersBackend, class Structure, class MultiFiltration>
 class Truc {
  public:
   using Filtration_value = MultiFiltration;
+  using MultiFiltrations = std::vector<MultiFiltration>;
   using value_type = typename MultiFiltration::value_type;
   using split_barcode =
       std::vector<std::vector<std::pair<typename MultiFiltration::value_type, typename MultiFiltration::value_type>>>;
+  using split_barcode_idx = std::vector<std::vector<std::pair<int, int>>>;
   template <typename value_type = value_type>
   using flat_barcode = std::vector<std::pair<int, std::pair<value_type, value_type>>>;
 
@@ -238,18 +279,389 @@ class Truc {
     std::iota(generator_order.begin(), generator_order.end(), 0);  // range
   }
 
-  Truc() {};
-
-  Truc &operator=(const Truc &other) {
-    generator_filtration_values = other.generator_filtration_values;
-    generator_order = other.generator_order;
-    structure = other.structure;
-    persistence = other.persistence;
-    filtration_container = other.filtration_container;
+  Truc(const Truc &other)
+      : generator_filtration_values(other.generator_filtration_values),
+        generator_order(other.generator_order),
+        structure(other.structure),
+        filtration_container(other.filtration_container),
+        persistence(other.persistence) {
     persistence._update_permutation_ptr(generator_order);
+  }
+
+  Truc &operator=(Truc other) {
+    if (this != &other) {
+      generator_filtration_values = other.generator_filtration_values;
+      generator_order = other.generator_order;
+      structure = other.structure;
+      filtration_container = other.filtration_container;
+      persistence = other.persistence;
+      persistence._update_permutation_ptr(generator_order);
+    }
     return *this;
+  }
+
+  Truc() {};
+
+  inline bool dimension_order(const index_type &i, const index_type &j) const {
+    return structure.dimension(i) < structure.dimension(j);
+  };
+
+  inline bool colexical_order(const index_type &i, const index_type &j) const {
+    if (structure.dimension(i) > structure.dimension(j)) return false;
+    if (structure.dimension(i) < structure.dimension(j)) return true;
+    if constexpr (MultiFiltration::is_multicritical())  // TODO : this may not be the best
+      throw "Not implemented in the multicritical case";
+
+    for (int idx = generator_filtration_values[i].num_parameters() - 1; idx >= 0; --idx) {
+      if (generator_filtration_values[i][idx] < generator_filtration_values[j][idx])
+        return true;
+      else if (generator_filtration_values[i][idx] > generator_filtration_values[j][idx])
+        return false;
+    }
+    return false;
+  };
+
+  // TODO : inside of MultiFiltration
+  inline static bool lexical_order(const MultiFiltration &a, const MultiFiltration &b) {
+    if constexpr (MultiFiltration::is_multicritical())  // TODO : this may not be the best
+      throw "Not implemented in the multicritical case";
+    if (a.is_plus_inf() || a.is_nan() || b.is_minus_inf()) return false;
+    if (b.is_plus_inf() || b.is_nan() || a.is_minus_inf()) return true;
+    for (auto idx = 0u; idx < a.num_parameters(); ++idx) {
+      if (a[idx] < b[idx])
+        return true;
+      else if (a[idx] > b[idx])
+        return false;
+    }
+    return false;
+  };
+
+  inline bool lexical_order(const index_type &i, const index_type &j) const {
+    if (structure.dimension(i) > structure.dimension(j)) return false;
+    if (structure.dimension(i) < structure.dimension(j)) return true;
+    if constexpr (MultiFiltration::is_multicritical())  // TODO : this may not be the best
+      throw "Not implemented in the multicritical case";
+
+    for (int idx = 0; idx < generator_filtration_values[i].num_parameters(); ++idx) {
+      if (generator_filtration_values[i][idx] < generator_filtration_values[j][idx])
+        return true;
+      else if (generator_filtration_values[i][idx] > generator_filtration_values[j][idx])
+        return false;
+    }
+    return false;
   };
 
+  inline Truc permute(const std::vector<index_type> &permutation) const {
+    auto num_new_gen = permutation.size();
+    if (permutation.size() > this->num_generators()) {
+      throw std::invalid_argument("Invalid permutation size. Got " + std::to_string(num_new_gen) + " expected " +
+                                  std::to_string(this->num_generators()) + ".");
+    }
+    std::vector<MultiFiltration> new_filtration(num_new_gen);
+    for (auto i : std::views::iota(0u, num_new_gen)) {  // assumes permutation has correct indices.
+      new_filtration[i] = generator_filtration_values[permutation[i]];
+    }
+    return Truc(structure.permute(permutation), new_filtration);
+  }
+
+  template <class Fun>
+  inline std::pair<Truc, std::vector<index_type>> rearange_sort(const Fun &&fun) const {
+    std::vector<index_type> permutation(generator_order.size());
+    std::iota(permutation.begin(), permutation.end(), 0);
+    tbb::parallel_sort(permutation.begin(), permutation.end(), [&](std::size_t i, std::size_t j) { return fun(i, j); });
+    return {permute(permutation), permutation};
+  }
+
+  std::pair<Truc, std::vector<index_type>> colexical_rearange() const {
+    return rearange_sort([this](std::size_t i, std::size_t j) { return this->colexical_order(i, j); });
+  }
+
+  template <bool generator_only = false>
+  std::conditional_t<generator_only, std::pair<std::vector<std::vector<index_type>>, MultiFiltrations>, Truc>
+  projective_cover_kernel(int dim) {
+    if constexpr (MultiFiltration::is_multicritical() || !std::is_same_v<Structure, PresentationStructure> ||
+                  !has_columns<PersBackend>::value)  // TODO : this may not be the best
+    {
+      throw std::invalid_argument("Not implemented for this Truc");
+    } else {
+      // TODO : this only works for 2 parameter modules. Optimize w.r.t. this.
+      const bool verbose = false;
+      // filtration values are assumed to be dim + colexicographically sorted
+      // vector seem to be good here
+      using SmallMatrix = Gudhi::persistence_matrix::Matrix<
+          Gudhi::multiparameter::truc_interface::fix_presentation_options<PersBackend::options::column_type, false>>;
+
+      int nd = 0;
+      int ndpp = 0;
+      for (auto i : std::views::iota(0u, structure.size())) {
+        if (structure.dimension(i) == dim) {
+          nd++;
+        } else if (structure.dimension(i) == dim + 1) {
+          ndpp++;
+        } else {
+          throw std::invalid_argument("This truc contains bad dimensions. Got " +
+                                      std::to_string(structure.dimension(i)) + " expected " + std::to_string(dim) +
+                                      " or " + std::to_string(dim + 1) + " in position " + std::to_string(i) + "  .");
+        }
+      }
+      if (ndpp == 0)
+        throw std::invalid_argument("Given dimension+1 has no simplices. Got " + std::to_string(nd) + " " +
+                                    std::to_string(ndpp) + ".");
+      // lexico iterator
+      auto lex_cmp = [&](const MultiFiltration &a, const MultiFiltration &b) { return lexical_order(a, b); };
+
+      struct SmallQueue {
+        SmallQueue() {};
+
+        struct MFWrapper {
+          MFWrapper(const MultiFiltration &g) : g(g) {};
+
+          MFWrapper(const MultiFiltration &g, int col) : g(g) { some_cols.insert(col); }
+
+          MFWrapper(const MultiFiltration &g, std::initializer_list<int> cols)
+              : g(g), some_cols(cols.begin(), cols.end()) {}
+
+          inline void insert(int col) const { some_cols.insert(col); }
+
+          inline bool operator<(const MFWrapper &other) const { return lexical_order(g, other.g); }
+
+         public:
+          MultiFiltration g;
+          mutable std::set<int> some_cols;
+        };
+
+        inline void insert(const MultiFiltration &g, int col) {
+          auto it = queue.find(g);
+          if (it != queue.end()) {
+            it->insert(col);
+          } else {
+            queue.emplace(g, col);
+          }
+        };
+
+        inline void insert(const MultiFiltration &g, const std::initializer_list<int> &cols) {
+          auto it = queue.find(g);
+          if (it != queue.end()) {
+            for (int c : cols) it->insert(c);
+          } else {
+            queue.emplace(g, cols);
+          }
+        };
+
+        inline bool empty() const { return queue.empty(); }
+
+        inline MultiFiltration pop() {
+          if (queue.empty()) [[unlikely]]
+            throw std::runtime_error("Queue is empty");
+
+          auto out = std::move(*queue.begin());
+          queue.erase(queue.begin());
+          std::swap(last_cols, out.some_cols);
+          return out.g;
+        }
+
+        const auto &get_current_cols() const { return last_cols; }
+
+       private:
+        std::set<MFWrapper> queue;
+        std::set<int> last_cols;
+      };
+
+      SmallQueue lexico_it;
+      SmallMatrix M(nd + ndpp);
+      for (int i = 0; i < nd + ndpp; i++) {
+        const auto &b = structure[i];
+        M.insert_boundary(b);
+      }
+      SmallMatrix N(nd + ndpp);  // slave
+      for (auto i : std::views::iota(0u, static_cast<unsigned int>(nd + ndpp))) {
+        N.insert_boundary({i});
+      };
+
+      auto get_fil = [&](int i) -> MultiFiltration & { return generator_filtration_values[i]; };
+      auto get_pivot = [&](int j) -> int {
+        const auto &col = M.get_column(j);
+        return col.size() > 0 ? (*col.rbegin()).get_row_index() : -1;
+      };
+
+      if constexpr (verbose) {
+        std::cout << "Initial matrix (" << nd << " + " << ndpp << "):" << std::endl;
+        for (int i = 0; i < nd + ndpp; i++) {
+          std::cout << "Column " << i << " : {";
+          for (const auto &j : M.get_column(i)) std::cout << j << " ";
+          std::cout << "} | " << get_fil(i) << std::endl;
+        }
+      }
+
+      // TODO : pivot caches are small : maybe use a flat container instead ?
+      std::vector<std::set<int>> pivot_cache(nd + ndpp);  // this[pivot] = cols of given pivot (<=nd)
+      std::vector<bool> reduced_columns(nd + ndpp);       // small cache
+      MultiFiltration grid_value;
+
+      std::vector<std::vector<index_type>> out_structure;
+      out_structure.reserve(2 * ndpp);
+      std::vector<MultiFiltration> out_filtration;
+      out_filtration.reserve(2 * ndpp);
+      std::vector<int> out_dimension;
+      out_dimension.reserve(2 * ndpp);
+      if constexpr (!generator_only) {
+        for (auto i : std::views::iota(nd, nd + ndpp)) {
+          out_structure.push_back({});
+          out_filtration.push_back(this->get_filtration_values()[i]);
+          out_dimension.push_back(this->structure.dimension(i));
+        }
+      }
+      // pivot cache
+      if constexpr (verbose) {
+        std::cout << "Initial pivot cache:\n";
+      }
+      for (int j : std::views::iota(nd, nd + ndpp)) {
+        int col_pivot = get_pivot(j);
+        if (col_pivot < 0) {
+          reduced_columns[j] = true;
+          continue;
+        };
+        auto &current_pivot_cache = pivot_cache[col_pivot];
+        current_pivot_cache.emplace_hint(current_pivot_cache.cend(), j);  // j is increasing
+      }
+      if constexpr (verbose) {
+        int i = 0;
+        for (const auto &cols : pivot_cache) {
+          std::cout << " - " << i++ << " : ";
+          for (const auto &col : cols) {
+            std::cout << col << " ";
+          }
+          std::cout << std::endl;
+        }
+      }
+
+      // if constexpr (!use_grid) {
+      if constexpr (verbose) std::cout << "Initial grid queue:\n";
+      for (int j : std::views::iota(nd, nd + ndpp)) {
+        int col_pivot = get_pivot(j);
+        if (col_pivot < 0) continue;
+        lexico_it.insert(get_fil(j), j);
+        auto it = pivot_cache[col_pivot].find(j);
+        if (it == pivot_cache[col_pivot].end()) [[unlikely]]
+          throw std::runtime_error("Column " + std::to_string(j) + " not in pivot cache");
+        it++;
+        // for (int k : pivot_cache[col_pivot]) {
+        for (auto _k = it; _k != pivot_cache[col_pivot].end(); ++_k) {
+          int k = *_k;
+          if (k <= j) [[unlikely]]
+            throw std::runtime_error("Column " + std::to_string(k) + " is not a future column");
+          auto prev = get_fil(k);
+          prev.push_to_least_common_upper_bound(get_fil(j));
+          if constexpr (verbose) std::cout << " -  (" << j << ", " << k << ") are interacting at " << prev << "\n";
+          lexico_it.insert(std::move(prev), k);
+        }
+      }
+      // TODO : check poset cache ?
+      if constexpr (verbose) std::cout << std::flush;
+      // }
+      auto reduce_column = [&](int j) -> bool {
+        int pivot = get_pivot(j);
+        if constexpr (verbose) std::cout << "Reducing column " << j << " with pivot " << pivot << "\n";
+        if (pivot < 0) {
+          if (!reduced_columns[j]) {
+            std::vector<index_type> _b(N.get_column(j).begin(), N.get_column(j).end());
+            for (auto &stuff : _b) stuff -= nd;
+            out_structure.push_back(std::move(_b));
+            out_filtration.emplace_back(grid_value.begin(), grid_value.end());
+            if constexpr (!generator_only) out_dimension.emplace_back(this->structure.dimension(j) + 1);
+            reduced_columns[j] = true;
+          }
+          return false;
+        }
+        if constexpr (verbose) std::cout << "Previous registered pivot : " << *pivot_cache[pivot].begin() << std::endl;
+        // WARN : we lazy update variables linked with col j...
+        if (pivot_cache[pivot].size() == 0) {
+          return false;
+        }
+        for (int k : pivot_cache[pivot]) {
+          if (k >= j) {  // cannot reduce more here. this is a (local) pivot.
+            return false;
+          }
+          if (get_fil(k) <= grid_value) {
+            M.add_to(k, j);
+            N.add_to(k, j);
+            // std::cout << "Adding " << k << " to " << j << " at grid time " << grid_value << std::endl;
+            pivot_cache[pivot].erase(j);
+            // WARN : we update the pivot cache after the update loop
+            if (get_pivot(j) >= pivot) {
+              throw std::runtime_error("Addition failed ? current " + std::to_string(get_pivot(j)) + " previous " +
+                                       std::to_string(pivot));
+            }
+            return true;  // pivot has changed
+          }
+        }
+        return false;  // for loop exhausted (j may not be there because of lazy)
+      };
+      auto chores_after_new_pivot = [&](int j) {
+        int col_pivot = get_pivot(j);
+        if (col_pivot < 0) {
+          if (!reduced_columns[j]) throw std::runtime_error("Empty column should have been detected before");
+          return;
+        };
+        auto [it, was_there] = pivot_cache[col_pivot].insert(j);
+        it++;
+        // if constexpr (!use_grid) {
+        for (auto _k = it; _k != pivot_cache[col_pivot].end(); ++_k) {
+          int k = *_k;
+          if (k <= j) [[unlikely]]
+            throw std::runtime_error("(chores)  col " + std::to_string(k) + " is not a future column");
+          if (get_fil(k) >= get_fil(j)) continue;
+          auto prev = get_fil(k);
+          prev.push_to_least_common_upper_bound(get_fil(j));
+          if (lex_cmp(grid_value, prev)) {
+            if constexpr (verbose)
+              std::cout << "(chores) Updating grid queue, (" << j << ", " << k << ") are interacting at " << prev
+                        << std::endl;
+            lexico_it.insert(prev, k);
+          }
+        }
+        // }
+      };
+      if constexpr (verbose) {
+        std::cout << "Initially reduced columns: [";
+        for (int i = 0; i < nd + ndpp; i++) {
+          std::cout << reduced_columns[i] << ", ";
+        }
+        std::cout << "]" << std::endl;
+      }
+      while (!lexico_it.empty()) {
+        // if constexpr (use_grid) {
+        //   grid_value = lexico_it.next();
+        // } else {
+        grid_value = std::move(lexico_it.pop());
+        // }
+        if constexpr (verbose) {
+          std::cout << "Grid value: " << grid_value << std::endl;
+          std::cout << "    Reduced cols: ";
+          for (int i = 0; i < nd + ndpp; i++) {
+            std::cout << reduced_columns[i] << ", ";
+          }
+          std::cout << "]" << std::endl;
+        }
+
+        for (int i : lexico_it.get_current_cols()) {
+          if constexpr (false) {
+            if ((reduced_columns[i] || !(get_fil(i) <= grid_value))) continue;
+            if ((get_fil(i) > grid_value)) break;
+          }
+          while (reduce_column(i));
+          chores_after_new_pivot(i);
+        }
+      }
+      // std::cout<< grid_.str() << std::endl;
+      if constexpr (generator_only)
+        return {out_structure, out_dimension};
+      else {
+        return Truc(out_structure, out_dimension, out_filtration);
+      }
+    }
+  }
+
   template <bool ignore_inf>
   std::vector<std::pair<int, std::vector<index_type>>> get_current_boundary_matrix() {
     std::vector<index_type> permutation(generator_order.size());
@@ -261,9 +673,9 @@ class Truc {
                                          return filtration_container[val] == MultiFiltration::Generator::T_inf;
                                        }),
                         permutation.end());
-      std::sort(permutation.begin(), permutation.end());
+      tbb::parallel_sort(permutation.begin(), permutation.end());
     }
-    std::sort(permutation.begin(), permutation.end(), [&](std::size_t i, std::size_t j) {
+    tbb::parallel_sort(permutation.begin(), permutation.end(), [&](std::size_t i, std::size_t j) {
       if (structure.dimension(i) > structure.dimension(j)) return false;
       if (structure.dimension(i) < structure.dimension(j)) return true;
       return filtration_container[i] < filtration_container[j];
@@ -320,7 +732,9 @@ class Truc {
 
   template <class array1d>
   inline void set_one_filtration(const array1d &truc) {
-    assert(truc.size() == this->num_generators());
+    if (truc.size() != this->num_generators())
+      throw std::invalid_argument("(setting one filtration) Bad size. Got " + std::to_string(truc.size()) +
+                                  " expected " + std::to_string(this->num_generators()));
     this->filtration_container = truc;
   }
 
@@ -334,7 +748,7 @@ class Truc {
       const bool ignore_inf) const {  // needed ftm as PersBackend only points there
     constexpr const bool verbose = false;
     if (one_filtration.size() != this->num_generators()) {
-      throw;
+      throw std::runtime_error("The one parameter filtration doesn't have a proper size.");
     }
     out_gen_order.resize(this->num_generators());
     std::iota(out_gen_order.begin(),
@@ -375,7 +789,7 @@ class Truc {
     return PersBackend(structure, out_gen_order);
   }
 
-  inline const bool has_persistence() { return this->persistence.size(); };
+  inline bool has_persistence() const { return this->persistence.size(); };
 
   inline void compute_persistence(const bool ignore_inf = true) {
     this->persistence = this->compute_persistence_out(
@@ -419,6 +833,49 @@ class Truc {
     vineyard_update(this->persistence, this->filtration_container, this->generator_order);
   }
 
+  inline split_barcode_idx get_barcode_idx(
+      PersBackend &persistence) const {
+    auto barcode_indices = persistence.get_barcode();
+    split_barcode_idx out(this->structure.max_dimension() + 1);  // TODO : This doesn't allow for negative dimensions
+    for (const auto &bar : barcode_indices) {
+      int death = bar.death == static_cast<typename PersBackend::pos_index>(-1) ? -1 : bar.death;
+      out[bar.dim].push_back({bar.birth, death});
+    }
+    return out;
+  }
+
+  // puts the degree-ordered bc starting out_ptr, and returns the "next" pointer.
+  // corresond to an array of shape (num_bar, 2);
+  template <bool return_shape = false>
+  inline std::conditional_t<return_shape, std::pair<std::vector<int>, int*>, int*> get_barcode_idx(
+      PersBackend &persistence,
+      int *start_ptr) const {
+    const auto &bc = persistence.barcode();
+    if (bc.size() == 0) return start_ptr;
+    std::vector<int> shape(this->structure.max_dimension());
+    for (const auto &b : bc) shape[b.dim]++;
+    // dim in barcode may be unsorted...
+    std::vector<int *> ptr_shifts(shape.size());
+    int shape_cumsum = 0;
+    for (auto i : std::views::iota(0u, bc.size())) {
+      if (i != 0u) shape_cumsum += shape[i - 1];
+      // 2 for (birth, death)
+      ptr_shifts[i] = 2 * shape_cumsum + start_ptr;
+    }
+    for (const auto &b : bc) {
+      int *current_loc = ptr_shifts[b.dim];
+      *(current_loc++) = b.birth;
+      *(current_loc++) = b.death == static_cast<typename PersBackend::pos_index>(-1) ? -1 : b.death;
+    }
+
+    if constexpr (return_shape)
+      return {shape, ptr_shifts.back()};
+    else
+      return ptr_shifts.back();
+  }
+
+    
+
   inline split_barcode get_barcode(
       PersBackend &persistence,
       const std::vector<typename MultiFiltration::value_type> &filtration_container) const {
@@ -454,7 +911,7 @@ class Truc {
                   << " --" << bar.death << "(" << death_filtration << ")"
                   << " dim " << bar.dim << std::endl;
       }
-      if (birth_filtration < death_filtration)
+      if (birth_filtration <= death_filtration)
         out[bar.dim].push_back({birth_filtration, death_filtration});
       else {
         out[bar.dim].push_back({inf, inf});
@@ -465,6 +922,8 @@ class Truc {
 
   inline split_barcode get_barcode() { return get_barcode(this->persistence, this->filtration_container); }
 
+  inline split_barcode_idx get_barcode_idx() { return get_barcode_idx(this->persistence); }
+
   template <typename value_type = value_type>
   static inline flat_nodim_barcode<value_type> get_flat_nodim_barcode(
       PersBackend &persistence,
@@ -492,7 +951,7 @@ class Truc {
                   << std::endl;
       }
 
-      if (birth_filtration < death_filtration)
+      if (birth_filtration <= death_filtration)
         out[idx] = {birth_filtration, death_filtration};
       else {
         out[idx] = {inf, inf};
@@ -529,7 +988,7 @@ class Truc {
                   << std::endl;
       }
 
-      if (birth_filtration < death_filtration)
+      if (birth_filtration <= death_filtration)
         out[idx] = {bar.dim, {birth_filtration, death_filtration}};
       else {
         out[idx] = {bar.dim, {inf, inf}};
@@ -635,6 +1094,8 @@ class Truc {
     return out;
   }
 
+  inline int get_dimension(int i) const { return structure.dimension(i); }
+
   inline void prune_above_dimension(int max_dim) {
     int idx = structure.prune_above_dimension(max_dim);
     generator_filtration_values.resize(idx);
@@ -651,12 +1112,15 @@ class Truc {
     return out;
   }
 
-  auto coarsen_on_grid(const std::vector<std::vector<typename MultiFiltration::value_type>> grid) {
+  auto coarsen_on_grid(const std::vector<std::vector<typename MultiFiltration::value_type>>& grid) {
     using return_type = decltype(std::declval<MultiFiltration>().template as_type<std::int32_t>());
     std::vector<return_type> coords(this->num_generators());
-    for (std::size_t gen = 0u; gen < coords.size(); ++gen) {
+    // for (std::size_t gen = 0u; gen < coords.size(); ++gen) { // TODO : parallelize
+    //   coords[gen] = compute_coordinates_in_grid<int32_t>(generator_filtration_values[gen], grid);
+    // }
+    tbb::parallel_for(static_cast<std::size_t>(0u), coords.size(), [&](std::size_t gen){
       coords[gen] = compute_coordinates_in_grid<int32_t>(generator_filtration_values[gen], grid);
-    }
+    });
     return Truc<PersBackend, Structure, return_type>(structure, coords);
   }
 
@@ -718,7 +1182,7 @@ class Truc {
 
     inline TrucThread weak_copy() const { return TrucThread(*truc_ptr); }
 
-    inline const bool has_persistence() { return this->persistence.size(); };
+    inline bool has_persistence() const { return this->persistence.size(); };
 
     inline const PersBackend &get_persistence() const { return persistence; }
 
@@ -769,6 +1233,10 @@ class Truc {
 
     inline split_barcode get_barcode() { return truc_ptr->get_barcode(this->persistence, this->filtration_container); }
 
+    inline split_barcode_idx get_barcode_idx() {
+      return truc_ptr->get_barcode_idx(this->persistence);
+    }
+
     inline std::size_t num_generators() const { return this->truc_ptr->structure.size(); }
 
     inline std::size_t num_parameters() const {
@@ -783,6 +1251,14 @@ class Truc {
       return this->filtration_container;
     }
 
+    template <class array1d>
+    inline void set_one_filtration(const array1d &truc) {
+      if (truc.size() != this->num_generators())
+        throw std::invalid_argument("(setting one filtration) Bad size. Got " + std::to_string(truc.size()) +
+                                    " expected " + std::to_string(this->num_generators()));
+      this->filtration_container = truc;
+    }
+
    private:
     const Truc *truc_ptr;
     std::vector<index_type> generator_order;                                 // size fixed at construction time,
@@ -795,21 +1271,34 @@ class Truc {
    * returns barcodes of the f(multipers)
    *
    */
-  template <typename Fun, typename Fun_arg>
-  inline std::vector<split_barcode> barcodes(Fun &&f, const std::vector<Fun_arg> &args, const bool ignore_inf = true) {
+  template <typename Fun, typename Fun_arg, bool idx = false, bool custom = false>
+  inline std::conditional_t<idx, std::vector<split_barcode_idx>, std::vector<split_barcode>>
+  barcodes(Fun &&f, const std::vector<Fun_arg> &args, const bool ignore_inf = true) {
     if (args.size() == 0) {
       return {};
     }
-    std::vector<split_barcode> out(args.size());
+    std::conditional_t<idx, std::vector<split_barcode_idx>, std::vector<split_barcode>> out(args.size());
 
     if constexpr (PersBackend::is_vine) {
-      this->push_to(f(args[0]));
+      if constexpr (custom)
+        this->set_one_filtration(f(args[0]));
+      else
+        this->push_to(f(args[0]));
       this->compute_persistence();
-      out[0] = this->get_barcode();
+      if constexpr (idx)
+        out[0] = this->get_barcode_idx();
+      else
+        out[0] = this->get_barcode();
       for (auto i = 1u; i < args.size(); ++i) {
-        this->push_to(f(args[i]));
+        if constexpr (custom)
+          this->set_one_filtration(f(args[i]));
+        else
+          this->push_to(f(args[i]));
         this->vineyard_update();
-        out[i] = this->get_barcode();
+        if constexpr (idx)
+          out[i] = this->get_barcode_idx();
+        else
+          out[i] = this->get_barcode();
       }
 
     } else {
@@ -817,9 +1306,15 @@ class Truc {
       tbb::enumerable_thread_specific<ThreadSafe> thread_locals(local_template);
       tbb::parallel_for(static_cast<std::size_t>(0), args.size(), [&](const std::size_t &i) {
         ThreadSafe &s = thread_locals.local();
-        s.push_to(f(args[i]));
+        if constexpr (custom)
+          s.set_one_filtration(f(args[i]));
+        else
+          s.push_to(f(args[i]));
         s.compute_persistence(ignore_inf);
-        out[i] = s.get_barcode();
+        if constexpr (idx) {
+          out[i] = s.get_barcode_idx();
+        } else
+          out[i] = s.get_barcode();
       });
     }
     return out;
@@ -827,19 +1322,37 @@ class Truc {
 
   // FOR Python interface, but I'm not fan. Todo: do the lambda function in
   // cython?
-  inline std::vector<split_barcode> persistence_on_lines(const std::vector<std::vector<value_type>> &basepoints) {
+  inline std::vector<split_barcode> persistence_on_lines(const std::vector<std::vector<value_type>> &basepoints,
+                                                         bool ignore_inf) {
     return barcodes(
         [](const std::vector<value_type> &basepoint) { return Gudhi::multi_persistence::Line<value_type>(basepoint); },
-        basepoints);
+        basepoints,
+        ignore_inf);
+  }
+
+  inline std::vector<split_barcode_idx> custom_persistences(const value_type *filtrations, int size, bool ignore_inf) {
+    std::vector<const value_type *> args(size);
+    for (auto i = 0; i < size; ++i) args[i] = filtrations + this->num_generators() * i;
+
+    auto fun = [&](const value_type *one_filtration_ptr) {
+      std::vector<value_type> fil(this->num_generators());
+      for (auto i : std::views::iota(0u, this->num_generators())) {
+        fil[i] = *(one_filtration_ptr + i);
+      }
+      return std::move(fil);
+    };
+    return barcodes<decltype(fun), const value_type *, true, true>(std::move(fun), args, ignore_inf);
   }
 
   inline std::vector<split_barcode> persistence_on_lines(
-      const std::vector<std::pair<std::vector<value_type>, std::vector<value_type>>> &bp_dirs) {
+      const std::vector<std::pair<std::vector<value_type>, std::vector<value_type>>> &bp_dirs,
+      bool ignore_inf) {
     return barcodes(
         [](const std::pair<std::vector<value_type>, std::vector<value_type>> &bpdir) {
           return Gudhi::multi_persistence::Line<value_type>(bpdir.first, bpdir.second);
         },
-        bp_dirs);
+        bp_dirs,
+        ignore_inf);
   }
 
   void build_from_scc_file(const std::string &inFilePath,
@@ -877,9 +1390,9 @@ class Truc {
   //                                  bool reverse);
 
  private:
-  std::vector<MultiFiltration> generator_filtration_values;  // defined at construction time. Const
-  std::vector<index_type> generator_order;  // size fixed at construction time, // TODO : CHANGE THAT TO UINT32
-  Structure structure;                      // defined at construction time. Const
+  MultiFiltrations generator_filtration_values;                            // defined at construction time. Const
+  std::vector<index_type> generator_order;                                 // size fixed at construction time
+  Structure structure;                                                     // defined at construction time. Const
   std::vector<typename MultiFiltration::value_type> filtration_container;  // filtration of the current slice
   PersBackend persistence;  // generated by the structure, and generator_order.