multipers 2.7.0b3__tar.gz → 2.7.0b4__tar.gz

{multipers-2.7.0b3 → multipers-2.7.0b4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multipers
-Version: 2.7.0b3
+Version: 2.7.0b4
 Summary: Multiparameter Topological Persistence for Machine Learning
 Keywords: TDA,Persistence,Multiparameter,sklearn,autodiff
 Author-Email: David Loiseaux <david.lapous@proton.me>, Hannah Schreiber <hannah.schreiber@inria.fr>

{multipers-2.7.0b3 → multipers-2.7.0b4}/cmake/MultipersBuild.cmake

@@ -770,6 +770,9 @@ function(multipers_configure_module module_name target_name)
   elseif(module_name STREQUAL "_function_rips_nanobind")
     multipers_link_tbb(${target_name})
 
+  elseif(module_name STREQUAL "_mcbif_nanobind")
+    multipers_link_tbb(${target_name})
+
   elseif(module_name STREQUAL "_core_delaunay_nanobind")
     multipers_link_tbb(${target_name})
     multipers_link_cgal(${target_name})
@@ -963,6 +966,7 @@ set(MULTIPERS_NANOBIND_MODULES
   _mma_nanobind
   _simplex_tree_multi_nanobind
   _function_rips_nanobind
+  _mcbif_nanobind
   _core_delaunay_nanobind
   _grid_helper_nanobind
   _mpfree_interface

multipers-2.7.0b4/multipers/_mcbif_nanobind.cpp

@@ -0,0 +1,398 @@
+#include <nanobind/nanobind.h>
+#include <nanobind/ndarray.h>
+#include <nanobind/stl/string.h>
+
+#include <oneapi/tbb/parallel_for.h>
+#include <tbb/parallel_sort.h>
+
+#include <algorithm>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <iterator>
+#include <limits>
+#include <map>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "Simplex_tree_multi_interface.h"
+#include "ext_interface/nanobind_registry_helpers.hpp"
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace mpmcbif {
+
+using multipers::nanobind_helpers::is_simplextree_object;
+using multipers::nanobind_helpers::visit_simplextree_wrapper;
+
+using Simplex = std::vector<int>;
+using Cluster = std::vector<int>;
+
+struct SimplexData {
+  Simplex simplex;
+  std::vector<size_t> occurrence_indices;
+};
+
+struct NerveSimplexInfo {
+  Simplex simplex;
+  Cluster intersection;
+};
+
+inline Cluster intersect_sorted(const Cluster& left, const Cluster& right) {
+  Cluster out;
+  out.reserve(std::min(left.size(), right.size()));
+  std::set_intersection(left.begin(), left.end(), right.begin(), right.end(), std::back_inserter(out));
+  return out;
+}
+
+inline std::vector<Cluster> clusters_for_partition(const int64_t* row, size_t num_points) {
+  std::map<int64_t, Cluster> by_label;
+  for (size_t vertex = 0; vertex < num_points; ++vertex) {
+    by_label[row[vertex]].push_back(static_cast<int>(vertex));
+  }
+
+  std::vector<Cluster> clusters;
+  clusters.reserve(by_label.size());
+  for (auto& [label, cluster] : by_label) {
+    (void)label;
+    clusters.push_back(std::move(cluster));
+  }
+  return clusters;
+}
+
+inline SimplexData build_nerve_simplex_data(const Simplex& simplex,
+                                            const std::vector<std::vector<size_t>>& cluster_occurrences,
+                                            size_t num_partitions) {
+  std::vector<size_t> rows;
+  rows.reserve(num_partitions);
+  for (size_t start_index = 0; start_index < num_partitions; ++start_index) {
+    bool found = true;
+    size_t end_index = 0;
+    for (int cluster_id : simplex) {
+      const auto& occurrences = cluster_occurrences[static_cast<size_t>(cluster_id)];
+      auto occurrence_it = std::lower_bound(occurrences.begin(), occurrences.end(), start_index);
+      if (occurrence_it == occurrences.end()) {
+        found = false;
+        break;
+      }
+      end_index = std::max(end_index, *occurrence_it);
+    }
+    if (!found) {
+      break;
+    }
+    rows.push_back(end_index);
+  }
+  return {simplex, std::move(rows)};
+}
+
+inline void append_occurrence(std::vector<size_t>& occurrences, size_t partition_index) {
+  if (occurrences.empty() || occurrences.back() != partition_index) {
+    occurrences.push_back(partition_index);
+  }
+}
+
+inline void append_standard_combinations(std::map<Simplex, std::vector<size_t>>& simplex_occurrences,
+                                         const Cluster& cluster,
+                                         size_t partition_index,
+                                         size_t target_size,
+                                         size_t start,
+                                         Simplex& simplex) {
+  if (simplex.size() == target_size) {
+    append_occurrence(simplex_occurrences[simplex], partition_index);
+    return;
+  }
+
+  const size_t remaining = target_size - simplex.size();
+  for (size_t i = start; i + remaining <= cluster.size(); ++i) {
+    simplex.push_back(cluster[i]);
+    append_standard_combinations(simplex_occurrences, cluster, partition_index, target_size, i + 1, simplex);
+    simplex.pop_back();
+  }
+}
+
+inline void append_standard_cluster_simplices(std::map<Simplex, std::vector<size_t>>& simplex_occurrences,
+                                              const Cluster& cluster,
+                                              size_t partition_index,
+                                              int max_dim) {
+  Simplex simplex;
+  const size_t max_size = std::min(cluster.size(), static_cast<size_t>(max_dim) + 1);
+  for (size_t target_size = 1; target_size <= max_size; ++target_size) {
+    append_standard_combinations(simplex_occurrences, cluster, partition_index, target_size, 0, simplex);
+  }
+}
+
+inline std::vector<SimplexData> build_standard_simplices(const int64_t* partitions,
+                                                         size_t num_partitions,
+                                                         size_t num_points,
+                                                         int max_dim) {
+  std::map<Simplex, std::vector<size_t>> simplex_occurrences;
+  for (size_t partition_index = 0; partition_index < num_partitions; ++partition_index) {
+    const int64_t* row = partitions + partition_index * num_points;
+    auto clusters = clusters_for_partition(row, num_points);
+    for (const auto& cluster : clusters) {
+      append_standard_cluster_simplices(simplex_occurrences, cluster, partition_index, max_dim);
+    }
+  }
+
+  std::vector<SimplexData> out;
+  out.reserve(simplex_occurrences.size());
+  for (auto& [simplex, occurrences] : simplex_occurrences) {
+    out.push_back({std::move(simplex), std::move(occurrences)});
+  }
+  return out;
+}
+
+inline void add_nerve_simplex(std::map<Simplex, std::vector<size_t>>& nerve_simplices, Simplex simplex) {
+  std::sort(simplex.begin(), simplex.end());
+  nerve_simplices.try_emplace(std::move(simplex), std::vector<size_t>{});
+}
+
+inline std::vector<SimplexData> build_nerve_simplices(const int64_t* partitions,
+                                                      size_t num_partitions,
+                                                      size_t num_points,
+                                                      int max_dim) {
+  std::map<Cluster, int> cluster_id_by_vertices;
+  std::vector<Cluster> cluster_vertices;
+  std::vector<std::vector<size_t>> cluster_occurrences;
+  std::vector<std::vector<int>> new_cluster_ids_by_partition;
+  new_cluster_ids_by_partition.reserve(num_partitions);
+
+  for (size_t partition_index = 0; partition_index < num_partitions; ++partition_index) {
+    const int64_t* row = partitions + partition_index * num_points;
+    auto clusters = clusters_for_partition(row, num_points);
+    std::vector<int> new_cluster_ids;
+    for (auto& cluster : clusters) {
+      auto [it, inserted] = cluster_id_by_vertices.emplace(cluster, static_cast<int>(cluster_vertices.size()));
+      const int cluster_id = it->second;
+      if (inserted) {
+        cluster_vertices.push_back(std::move(cluster));
+        cluster_occurrences.emplace_back();
+        new_cluster_ids.push_back(cluster_id);
+      }
+      append_occurrence(cluster_occurrences[static_cast<size_t>(cluster_id)], partition_index);
+    }
+    new_cluster_ids_by_partition.push_back(std::move(new_cluster_ids));
+  }
+
+  std::map<Simplex, std::vector<size_t>> nerve_simplices;
+  const size_t requested_max_simplex_size = static_cast<size_t>(max_dim) + 1;
+  const size_t max_simplex_size =
+      std::min(std::min(requested_max_simplex_size, cluster_vertices.size()), num_partitions);
+  std::vector<std::vector<NerveSimplexInfo>> simplices_by_size(max_simplex_size + 1);
+
+  for (const auto& new_cluster_ids : new_cluster_ids_by_partition) {
+    for (int cluster_id : new_cluster_ids) {
+      const Cluster& cluster = cluster_vertices[static_cast<size_t>(cluster_id)];
+
+      for (size_t size = max_simplex_size - 1; size >= 1; --size) {
+        const size_t simplex_count = simplices_by_size[size].size();
+        for (size_t simplex_index = 0; simplex_index < simplex_count; ++simplex_index) {
+          const auto& previous = simplices_by_size[size][simplex_index];
+          auto intersection = intersect_sorted(cluster, previous.intersection);
+          if (!intersection.empty()) {
+            Simplex simplex = previous.simplex;
+            simplex.push_back(cluster_id);
+            add_nerve_simplex(nerve_simplices, simplex);
+            simplices_by_size[size + 1].push_back({std::move(simplex), std::move(intersection)});
+          }
+        }
+        if (size == 1) {
+          break;
+        }
+      }
+
+      Simplex vertex = {cluster_id};
+      add_nerve_simplex(nerve_simplices, vertex);
+      simplices_by_size[1].push_back({std::move(vertex), cluster});
+    }
+  }
+
+  std::vector<Simplex> simplices;
+  simplices.reserve(nerve_simplices.size());
+  for (const auto& [simplex, ignored] : nerve_simplices) {
+    (void)ignored;
+    simplices.push_back(simplex);
+  }
+
+  std::vector<SimplexData> out(simplices.size());
+  const auto build_one = [&](size_t simplex_index) {
+    out[simplex_index] = build_nerve_simplex_data(simplices[simplex_index], cluster_occurrences, num_partitions);
+  };
+  if (simplices.size() < 1024) {
+    for (size_t simplex_index = 0; simplex_index < simplices.size(); ++simplex_index) {
+      build_one(simplex_index);
+    }
+  } else {
+    tbb::parallel_for(size_t{0}, simplices.size(), build_one);
+  }
+  return out;
+}
+
+inline std::vector<double> rows_from_standard_occurrences(const std::vector<size_t>& occurrences,
+                                                          const double* filtration_indices) {
+  std::vector<double> flat_rows;
+  if (occurrences.empty()) {
+    return flat_rows;
+  }
+
+  flat_rows.reserve(occurrences.size() * 2);
+  for (auto occurrence_it = occurrences.rbegin(); occurrence_it != occurrences.rend(); ++occurrence_it) {
+    const size_t occurrence = *occurrence_it;
+    flat_rows.push_back(-filtration_indices[occurrence]);
+    flat_rows.push_back(filtration_indices[occurrence]);
+  }
+  return flat_rows;
+}
+
+inline std::vector<double> rows_from_nerve_end_indices(const std::vector<size_t>& end_indices,
+                                                       const double* filtration_indices) {
+  std::vector<double> flat_rows;
+  flat_rows.reserve(end_indices.size() * 2);
+  size_t best_end_index = std::numeric_limits<size_t>::max();
+  for (size_t offset = end_indices.size(); offset > 0; --offset) {
+    const size_t start_index = offset - 1;
+    const size_t end_index = end_indices[start_index];
+    if (end_index >= best_end_index) {
+      continue;
+    }
+    flat_rows.push_back(-filtration_indices[start_index]);
+    flat_rows.push_back(filtration_indices[end_index]);
+    best_end_index = end_index;
+  }
+  return flat_rows;
+}
+
+template <typename Tree, typename Filtration>
+bool insert_kcritical_simplex(Tree& tree, const Simplex& simplex, const Filtration& filtration) {
+  using BaseTree = typename Tree::Base_tree;
+  auto& base_tree = static_cast<BaseTree&>(tree);
+  auto result =
+      base_tree.insert_simplex_and_subfaces(BaseTree::Filtration_maintenance::LOWER_EXISTING, simplex, filtration);
+  return result.first != tree.null_simplex();
+}
+
+template <typename Wrapper>
+void fill_mcbif_simplextree(Wrapper& wrapper,
+                            const int64_t* partitions,
+                            size_t num_partitions,
+                            size_t num_points,
+                            const double* filtration_indices,
+                            int max_dim,
+                            const std::string& method) {
+  using Tree = std::remove_reference_t<decltype(wrapper.tree)>;
+  using Filtration = typename Tree::Filtration_value;
+
+  std::vector<SimplexData> simplex_data;
+  if (method == "standard") {
+    simplex_data = build_standard_simplices(partitions, num_partitions, num_points, max_dim);
+  } else if (method == "nerve") {
+    simplex_data = build_nerve_simplices(partitions, num_partitions, num_points, max_dim);
+  } else {
+    throw nb::value_error("method must be 'standard' or 'nerve'.");
+  }
+
+  tbb::parallel_sort(simplex_data.begin(), simplex_data.end(), [](const SimplexData& left, const SimplexData& right) {
+    if (left.simplex.size() != right.simplex.size()) {
+      return left.simplex.size() < right.simplex.size();
+    }
+    return left.simplex < right.simplex;
+  });
+
+  wrapper.tree.clear();
+  wrapper.tree.set_num_parameters(2);
+
+  bool inserted = false;
+  for (const auto& data : simplex_data) {
+    std::vector<double> flat_rows;
+    if (method == "standard") {
+      flat_rows = rows_from_standard_occurrences(data.occurrence_indices, filtration_indices);
+    } else if (method == "nerve") {
+      flat_rows = rows_from_nerve_end_indices(data.occurrence_indices, filtration_indices);
+    } else {
+      throw nb::value_error("method must be 'standard' or 'nerve'.");
+    }
+    if (flat_rows.empty()) {
+      continue;
+    }
+    Filtration filtration(flat_rows.begin(), flat_rows.end(), 2);
+    inserted |= insert_kcritical_simplex(wrapper.tree, data.simplex, filtration);
+  }
+  if (inserted) {
+    wrapper.tree.clear_filtration();
+  }
+}
+
+inline void validate_filtration_indices(const double* filtration_indices, size_t num_partitions) {
+  for (size_t i = 0; i < num_partitions; ++i) {
+    if (!std::isfinite(filtration_indices[i])) {
+      throw nb::value_error("filtration_indices must be finite.");
+    }
+    if (i > 0 && !(filtration_indices[i - 1] < filtration_indices[i])) {
+      throw nb::value_error("filtration_indices must be strictly increasing.");
+    }
+  }
+}
+
+inline void build_mcbif_dispatch(
+    nb::object& out,
+    const nb::ndarray<nb::numpy, const int64_t, nb::ndim<2>, nb::c_contig>& partitions,
+    const nb::ndarray<nb::numpy, const double, nb::ndim<1>, nb::c_contig>& filtration_indices,
+    int max_dim,
+    const std::string& method) {
+  const size_t num_partitions = partitions.shape(0);
+  const size_t num_points = partitions.shape(1);
+  visit_simplextree_wrapper(out, [&]<typename Desc>(auto& wrapper) {
+    if constexpr (Desc::is_kcritical && std::is_same_v<typename Desc::value_type, double>) {
+      nb::gil_scoped_release release;
+      fill_mcbif_simplextree(
+          wrapper, partitions.data(), num_partitions, num_points, filtration_indices.data(), max_dim, method);
+    } else {
+      throw nb::type_error("build_mcbif_simplextree expects a float64 k-critical SimplexTreeMulti target.");
+    }
+  });
+}
+
+}  // namespace mpmcbif
+
+NB_MODULE(_mcbif_nanobind, m) {
+  m.def(
+      "build_mcbif_simplextree",
+      [](nb::object target,
+         nb::ndarray<nb::numpy, const int64_t, nb::ndim<2>, nb::c_contig> partitions,
+         nb::ndarray<nb::numpy, const double, nb::ndim<1>, nb::c_contig> filtration_indices,
+         int max_dim,
+         std::string method) -> nb::object {
+        if (!mpmcbif::is_simplextree_object(target)) {
+          throw nb::type_error("build_mcbif_simplextree expects a SimplexTreeMulti target.");
+        }
+        if (partitions.shape(0) == 0) {
+          throw nb::value_error("partitions must contain at least one partition.");
+        }
+        if (partitions.shape(1) == 0) {
+          throw nb::value_error("partitions must contain at least one point.");
+        }
+        if (filtration_indices.shape(0) != partitions.shape(0)) {
+          throw nb::value_error("filtration_indices length must match the number of partitions.");
+        }
+        if (max_dim < 0) {
+          throw nb::value_error("max_dim must be nonnegative.");
+        }
+        if (method != "standard" && method != "nerve") {
+          throw nb::value_error("method must be 'standard' or 'nerve'.");
+        }
+        mpmcbif::validate_filtration_indices(filtration_indices.data(), filtration_indices.shape(0));
+
+        nb::object out = target.type()();
+        mpmcbif::build_mcbif_dispatch(out, partitions, filtration_indices, max_dim, method);
+        return out;
+      },
+      "target"_a,
+      "partitions"_a,
+      "filtration_indices"_a,
+      "max_dim"_a,
+      "method"_a);
+}

{multipers-2.7.0b3 → multipers-2.7.0b4}/multipers/array_api/__init__.py

@@ -147,9 +147,9 @@ def api_from_tensors(*args, jit_promote: bool = False):
     raise ValueError(f"Incompatible types got {[type(x) for x in args]=}.")
 
 
-def to_numpy(x, dtype=None):
+def to_numpy(x, dtype=None, contiguous=False):
     api = api_from_tensor(x)
-    return api.asnumpy(x, dtype=dtype)
+    return api.asnumpy(x, dtype=dtype, contiguous=contiguous)
 
 
 def check_keops():

{multipers-2.7.0b3 → multipers-2.7.0b4}/multipers/array_api/jax.py

@@ -85,8 +85,13 @@ def astype(x, dtype):
     return astensor(x).astype(dtype)
 
 
-def astensor(x, contiguous=False, dtype=None):
-    return _jnp.asarray(x, dtype=dtype)
+def astensor(x, contiguous=False, dtype=None, device=None):
+    out = _jnp.asarray(x, dtype=dtype)
+    return to_device(out, device)
+
+
+def zeros(shape, dtype=None, device=None):
+    return to_device(_jnp.zeros(shape, dtype=dtype), device)
 
 
 def check_keops():
@@ -194,8 +199,11 @@ def pdist(x, p=2):
     return distances[row_idx, col_idx]
 
 
-def asnumpy(x, dtype=None):
-    return _np.asarray(_jax.lax.stop_gradient(x), dtype=dtype)
+def asnumpy(x, dtype=None, contiguous=False):
+    x = _jax.lax.stop_gradient(x)
+    if contiguous:
+        return _np.ascontiguousarray(x, dtype=dtype)
+    return _np.asarray(x, dtype=dtype)
 
 
 def is_tensor(x):

{multipers-2.7.0b3 → multipers-2.7.0b4}/multipers/array_api/numpy.py

@@ -18,13 +18,17 @@ _has_jit = _numba is not None
 int64 = _np.int64
 cat = _np.concatenate
 det = _np.linalg.det
-asnumpy = _np.asarray
+def asnumpy(x, dtype=None, contiguous=False):
+    if contiguous:
+        return _np.ascontiguousarray(x, dtype=dtype)
+    return _np.asarray(x, dtype=dtype)
+
+
 tensor = _np.array
 stack = _np.stack
 empty = _np.empty
 where = _np.where
 no_grad = nullcontext
-zeros = _np.zeros
 min = _np.min
 max = _np.max
 reshape = _np.reshape
@@ -76,12 +80,16 @@ def jit(fn=None, **kwargs):
     return decorator(fn)
 
 
-def astensor(x, contiguous=False, dtype=None):
+def astensor(x, contiguous=False, dtype=None, device=None):
     if contiguous:
         return _np.ascontiguousarray(x, dtype=dtype)
     return _np.asarray(x, dtype=dtype)
 
 
+def zeros(shape, dtype=None, device=None):
+    return _np.zeros(shape, dtype=dtype)
+
+
 def unique(x, assume_sorted=False, _mean=False):
     return _np.unique(x)
 

{multipers-2.7.0b3 → multipers-2.7.0b4}/multipers/array_api/torch.py

@@ -29,7 +29,6 @@ where = _torch.where
 no_grad = _torch.no_grad
 cdist = _torch.cdist
 pdist = _torch.pdist
-zeros = _torch.zeros
 min = _torch.min
 max = _torch.max
 repeat_interleave = _torch.repeat_interleave
@@ -107,13 +106,19 @@ def astype(x, dtype):
     return astensor(x).to(dtype=dtype)
 
 
-def astensor(x, contiguous=False, dtype=None):
+def astensor(x, contiguous=False, dtype=None, device=None):
     out = _torch.as_tensor(x, dtype=dtype)
+    if device is not None:
+        out = out.to(device=device)
     if contiguous:
         out = out.contiguous()
     return out
 
 
+def zeros(shape, dtype=None, device=None):
+    return _torch.zeros(shape, dtype=dtype, device=device)
+
+
 def clip(x, min=None, max=None):
     return _torch.clamp(x, min=min, max=max)
 
@@ -248,8 +253,10 @@ def maxvalues(x, axis=None, dim=None, keepdims=False, keepdim=None):
     return _torch.max(x)
 
 
-def asnumpy(x, dtype=None):
+def asnumpy(x, dtype=None, contiguous=False):
     out = x.cpu().detach().numpy()
+    if contiguous:
+        return _np.ascontiguousarray(out, dtype=dtype)
     if dtype is not None:
         out = out.astype(dtype, copy=False)
     return out

{multipers-2.7.0b3 → multipers-2.7.0b4}/multipers/ext_interface/multi_critical_interface.hpp

@@ -119,18 +119,44 @@ inline bool multi_critical_interface_available() { return MULTIPERS_HAS_MULTI_CR
 namespace multi_critical_detail {
 
 inline std::mutex& multi_critical_interface_mutex() {
-  // Only timer globals still require process-global serialization.
+  // The vendored backend exposes verbose flags as process-global variables.
+  // Serialize calls while the log guard mutates and restores them.
   static std::mutex m;
   return m;
 }
 
-inline bool multi_critical_interface_needs_global_state_lock() {
-#if MULTI_CRITICAL_TIMERS || MULTI_CHUNK_TIMERS || MPFREE_TIMERS
-  return true;
-#else
-  return false;
-#endif
-}
+inline bool multi_critical_interface_needs_global_state_lock() { return true; }
+
+struct multi_critical_log_guard {
+  explicit multi_critical_log_guard(bool verbose_output)
+      : old_multi_critical_verbose(multi_critical::verbose),
+        old_multi_critical_very_verbose(multi_critical::very_verbose),
+        old_multi_chunk_verbose(multi_chunk::verbose),
+        old_mpfree_verbose(mpfree::verbose),
+        old_mpp_utils_verbose(mpp_utils::verbose) {
+    const bool enabled =
+        verbose_output || backend_log_policy::backend_log_enabled(backend_log_policy::backend_log_bit::multi_critical);
+    multi_critical::verbose = enabled;
+    multi_critical::very_verbose = false;
+    multi_chunk::verbose = enabled;
+    mpfree::verbose = false;
+    mpp_utils::verbose = false;
+  }
+
+  ~multi_critical_log_guard() {
+    multi_critical::verbose = old_multi_critical_verbose;
+    multi_critical::very_verbose = old_multi_critical_very_verbose;
+    multi_chunk::verbose = old_multi_chunk_verbose;
+    mpfree::verbose = old_mpfree_verbose;
+    mpp_utils::verbose = old_mpp_utils_verbose;
+  }
+
+  bool old_multi_critical_verbose;
+  bool old_multi_critical_very_verbose;
+  bool old_multi_chunk_verbose;
+  bool old_mpfree_verbose;
+  bool old_mpp_utils_verbose;
+};
 
 using Graded_matrix = mpp_utils::Graded_matrix<phat::vector_vector>;
 
@@ -371,7 +397,6 @@ inline std::vector<Graded_matrix> compute_free_resolution_matrices(
   }
 
   multi_critical_input_parser<index_type> parser(input);
-  (void)verbose_output;
 
   std::vector<Graded_matrix> matrices;
   multi_critical::free_resolution(parser, matrices, use_logpath);
@@ -441,6 +466,7 @@ multi_critical_interface_output<index_type> multi_critical_resolution_interface(
   if (multi_critical_detail::multi_critical_interface_needs_global_state_lock()) {
     lock.emplace(multi_critical_detail::multi_critical_interface_mutex());
   }
+  multi_critical_detail::multi_critical_log_guard log_guard(verbose_output);
 
   auto matrices =
       multi_critical_detail::compute_free_resolution_matrices(input, use_logpath, use_multi_chunk, verbose_output);
@@ -477,6 +503,7 @@ multi_critical_interface_output<index_type> multi_critical_minpres_interface(
   if (multi_critical_detail::multi_critical_interface_needs_global_state_lock()) {
     lock.emplace(multi_critical_detail::multi_critical_interface_mutex());
   }
+  multi_critical_detail::multi_critical_log_guard log_guard(verbose_output);
 
   if (degree < 0) {
     throw std::invalid_argument("multi_critical minimal presentation expects a non-negative degree.");
@@ -496,7 +523,6 @@ multi_critical_interface_output<index_type> multi_critical_minpres_interface(
 
   multi_critical_detail::Graded_matrix min_rep;
 
-  (void)verbose_output;
   mpfree::compute_minimal_presentation(first, second, min_rep, false, false);
 
   return multi_critical_detail::convert_minpres<index_type>(min_rep, degree);
@@ -513,6 +539,7 @@ std::vector<multi_critical_interface_output<index_type> > multi_critical_minpres
   if (multi_critical_detail::multi_critical_interface_needs_global_state_lock()) {
     lock.emplace(multi_critical_detail::multi_critical_interface_mutex());
   }
+  multi_critical_detail::multi_critical_log_guard log_guard(verbose_output);
 
   std::vector<multi_critical_interface_output<index_type> > out;
 
@@ -523,7 +550,6 @@ std::vector<multi_critical_interface_output<index_type> > multi_critical_minpres
   }
 
   out.reserve(matrices.size() - 2);
-  (void)verbose_output;
 
   for (int degree = 0; degree < static_cast<int>(matrices.size()) - 2; ++degree) {
     const int internal_degree = degree + 1;

{multipers-2.7.0b3 → multipers-2.7.0b4}/multipers/filtrations/__init__.py

@@ -6,6 +6,7 @@ from .filtrations import (
     DegreeRips,
     DelaunayCodensity,
     DelaunayLowerstar,
+    MultiscaleClusteringBifiltration,
     RipsCodensity,
     RipsLowerstar,
     RhomboidBifiltration,
@@ -17,6 +18,7 @@ __all__ = [
     "DegreeRips",
     "DelaunayCodensity",
     "DelaunayLowerstar",
+    "MultiscaleClusteringBifiltration",
     "RipsCodensity",
     "RipsLowerstar",
     "RhomboidBifiltration",