From 794c25dc50e52db1ba5e72c6600cf8f48001b47a Mon Sep 17 00:00:00 2001 From: hschreiber Date: Thu, 28 May 2026 16:57:51 +0200 Subject: [PATCH 01/10] move add_barcode_to_module --- ext/gudhi-devel | 2 +- multipers/grids.py | 50 +++++++++---------- .../approximation.h | 28 ++++++++++- 3 files changed, 52 insertions(+), 28 deletions(-) diff --git a/ext/gudhi-devel b/ext/gudhi-devel index eeb0845c..96d28bd1 160000 --- a/ext/gudhi-devel +++ b/ext/gudhi-devel @@ -1 +1 @@ -Subproject commit eeb0845c1253f66f8a54741abae6763fc1ff4245 +Subproject commit 96d28bd1f4da2b4278633b34c5e48a6ddc6df6d9 diff --git a/multipers/grids.py b/multipers/grids.py index 4f9436eb..6395fc14 100644 --- a/multipers/grids.py +++ b/multipers/grids.py @@ -654,28 +654,28 @@ def _push_pts_to_lines(pts, basepoints, directions=None, api=None, return_coordi return out, coordinates -def evaluate_mod_in_grid(mod, grid, box=None): - """Given an MMA module, pushes it into the specified grid. - Useful for e.g., make it differentiable. - - Input - ----- - - mod: PyModule - - grid: Iterable of 1d array, for num_parameters - Ouput - ----- - torch-compatible module in the format: - (num_degrees) x (num_interval of degree) x ((num_birth, num_parameter), (num_death, num_parameters)) - - """ - (birth_sizes, death_sizes), births, deaths = mod.to_flat_idx(grid) - births = evaluate_in_grid(births, grid) - deaths = evaluate_in_grid(deaths, grid) - api = api_from_tensors(births, deaths) - diff_mod = tuple( - zip( - api.split_with_sizes(births, birth_sizes.tolist()), - api.split_with_sizes(deaths, death_sizes.tolist()), - ) - ) - return diff_mod +# def evaluate_mod_in_grid(mod, grid, box=None): +# """Given an MMA module, pushes it into the specified grid. +# Useful for e.g., make it differentiable. + +# Input +# ----- +# - mod: PyModule +# - grid: Iterable of 1d array, for num_parameters +# Ouput +# ----- +# torch-compatible module in the format: +# (num_degrees) x (num_interval of degree) x ((num_birth, num_parameter), (num_death, num_parameters)) + +# """ +# (birth_sizes, death_sizes), births, deaths = mod.to_flat_idx(grid) +# births = evaluate_in_grid(births, grid) +# deaths = evaluate_in_grid(deaths, grid) +# api = api_from_tensors(births, deaths) +# diff_mod = tuple( +# zip( +# api.split_with_sizes(births, birth_sizes.tolist()), +# api.split_with_sizes(deaths, death_sizes.tolist()), +# ) +# ) +# return diff_mod diff --git a/multipers/multiparameter_module_approximation/approximation.h b/multipers/multiparameter_module_approximation/approximation.h index 06e86943..a57c5a41 100644 --- a/multipers/multiparameter_module_approximation/approximation.h +++ b/multipers/multiparameter_module_approximation/approximation.h @@ -63,6 +63,30 @@ inline void threshold_filters_list(std::vector &filtersList, co } } +template +inline void add_barcode_to_module(Module &module, + const Line &line, + const std::vector>> &barcode, + bool thresholdToBox) { + const auto& box = module.get_box(); +#ifdef GUDHI_USE_TBB + std::vector shifts(barcode.size(), 0U); + for (std::size_t i = 1U; i < barcode.size(); i++) { + shifts[i] = shifts[i - 1] + barcode[i - 1].size(); + } + tbb::parallel_for(size_t(0), barcode.size(), [&](size_t dim) { + tbb::parallel_for(size_t(0), barcode[dim].size(), [&](size_t j) { + module.get_summand(shifts[dim] + j).add_bar(line, barcode[dim][j][0], barcode[dim][j][1], box, thresholdToBox); + }); + }); +#else + typename Module::Index count = 0; + for (const auto &barDim : barcode) { + for (const auto &bar : barDim) module.get_summand(count++).add_bar(line, bar[0], bar[1], box, thresholdToBox); + } +#endif +} + template class LineIterator { public: @@ -121,7 +145,7 @@ inline void __add_vineyard_trajectory_to_module(Module(), threshold); + add_barcode_to_module(module, new_line, slicer.template get_flat_barcode(), threshold); }; }; @@ -307,7 +331,7 @@ Module multiparameter_module_approximation(Slicer &slicer, ++i; } } - out.add_barcode(current_line, barcode, threshold); + add_barcode_to_module(out, current_line, barcode, threshold); if (verbose) std::cout << "Instantiated " << num_bars << " summands" << std::endl; } From cce065b53a2f92d5f12735f1c2b6b5bab3dbed1d Mon Sep 17 00:00:00 2001 From: hschreiber Date: Fri, 12 Jun 2026 17:01:26 +0200 Subject: [PATCH 02/10] re-factoring module bindings --- ext/gudhi-devel | 2 +- multipers/_mma_nanobind.cpp | 914 +++--------------- multipers/_slicer_nanobind.cpp | 12 +- multipers/gudhi/Module_interface.h | 522 ++++++++++ .../multiparameter_module_approximation.py | 18 +- .../approximation.h | 28 +- multipers/nanobind_mma_registry_helpers.hpp | 35 +- 7 files changed, 725 insertions(+), 806 deletions(-) create mode 100644 multipers/gudhi/Module_interface.h diff --git a/ext/gudhi-devel b/ext/gudhi-devel index 96d28bd1..f0674afe 160000 --- a/ext/gudhi-devel +++ b/ext/gudhi-devel @@ -1 +1 @@ -Subproject commit 96d28bd1f4da2b4278633b34c5e48a6ddc6df6d9 +Subproject commit f0674afe888511714ec7ffe92fbfa48c3e1af1ad diff --git a/multipers/_mma_nanobind.cpp b/multipers/_mma_nanobind.cpp index 7017eccc..b535af68 100644 --- a/multipers/_mma_nanobind.cpp +++ b/multipers/_mma_nanobind.cpp @@ -1,29 +1,22 @@ #include #include #include +#include #include #include #include #include -#include #include #include -#include -#include #include -#include -#include #include #include -#include "Persistence_slices_interface.h" -#include "gudhi/Multi_persistence/Box.h" -#include "gudhi/Multi_persistence/Line.h" -#include "gudhi/Multi_persistence/Module.h" -#include "gudhi/Multi_persistence/Summand.h" -#include "gudhi/Multi_persistence/module_helpers.h" #include +#include +#include +#include "gudhi/Module_interface.h" #include "nanobind_array_utils.hpp" #include "nanobind_dense_array_utils.hpp" #include "nanobind_mma_registry_helpers.hpp" @@ -34,17 +27,13 @@ using namespace nb::literals; namespace mpmma { -using multipers::nanobind_dense_utils::cast_vector_from_array; -using multipers::nanobind_dense_utils::matrix_from_array; using multipers::nanobind_dense_utils::vector_from_array; -using multipers::nanobind_mma_helpers::dispatch_mma_by_template_id; using multipers::nanobind_mma_helpers::is_mma_module_object; using multipers::nanobind_mma_helpers::MMADescriptorList; using multipers::nanobind_mma_helpers::type_list; using multipers::nanobind_utils::matrix_from_handle; using multipers::nanobind_utils::numpy_dtype_type; using multipers::nanobind_utils::owned_array; -using multipers::nanobind_utils::tuple_from_size; using multipers::nanobind_utils::vector_from_handle; template @@ -66,528 +55,79 @@ nb::ndarray corner_pair_to_python(const std::vector& lower, con return owned_array(std::move(flat), {size_t(2), lower.size()}); } -template -nb::tuple dump_summand(const Gudhi::multi_persistence::Summand& summand) { - auto births = summand.compute_flat_upset(); - auto deaths = summand.compute_flat_downset(); - const size_t num_parameters = static_cast(summand.get_number_of_parameters()); - return nb::make_tuple( - corner_matrix_to_python( - std::move(births), static_cast(summand.get_number_of_birth_corners()), num_parameters), - corner_matrix_to_python( - std::move(deaths), static_cast(summand.get_number_of_death_corners()), num_parameters), - summand.get_dimension()); -} - -template -nb::tuple barcode_to_python( - const std::vector::Bar>>& barcode) { - return tuple_from_size(barcode.size(), [&](size_t dim) -> nb::object { - const auto& bars = barcode[dim]; - std::vector flat; - flat.reserve(bars.size() * 2); - for (const auto& bar : bars) { - flat.push_back(bar[0]); - flat.push_back(bar[1]); - } - return nb::cast(owned_array(std::move(flat), {bars.size(), size_t(2)})); - }); -} - -template -Gudhi::multi_persistence::Summand summand_from_dump(nb::handle dump) { - nb::tuple tpl = nb::cast(dump); - auto births = matrix_from_handle(tpl[0]); - auto deaths = matrix_from_handle(tpl[1]); - int degree = nb::cast(tpl[2]); - std::vector flat_births; - std::vector flat_deaths; - size_t num_parameters = births.empty() ? 0 : births[0].size(); - for (const auto& row : births) { - flat_births.insert(flat_births.end(), row.begin(), row.end()); - } - for (const auto& row : deaths) { - flat_deaths.insert(flat_deaths.end(), row.begin(), row.end()); - } - return Gudhi::multi_persistence::Summand(flat_births, flat_deaths, (int)num_parameters, degree); -} - -template -nb::tuple dump_module(const Gudhi::multi_persistence::Module& module) { - auto box = module.get_box(); - std::vector lower(box.get_lower_corner().begin(), box.get_lower_corner().end()); - std::vector upper(box.get_upper_corner().begin(), box.get_upper_corner().end()); - std::vector flat_box; - flat_box.reserve(lower.size() + upper.size()); - flat_box.insert(flat_box.end(), lower.begin(), lower.end()); - flat_box.insert(flat_box.end(), upper.begin(), upper.end()); - nb::object box_arr = nb::cast(owned_array(std::move(flat_box), {size_t(2), box.get_lower_corner().size()})); - - nb::tuple summands = tuple_from_size( - module.size(), [&](size_t i) -> nb::object { return dump_summand(module.get_summand((unsigned int)i)); }); - return nb::make_tuple(box_arr, summands); -} - -template -Gudhi::multi_persistence::Box box_from_rows(const std::vector>& rows) { - if (rows.size() != 2) { - throw std::runtime_error("Expected a box with shape (2, n_parameters)."); - } - return Gudhi::multi_persistence::Box(rows[0], rows[1]); -} - -template -Gudhi::multi_persistence::Box box_from_array(nb::ndarray, nb::c_contig> box) { - return box_from_rows(matrix_from_array(box)); -} - -template -Gudhi::multi_persistence::Line line_from_vectors(const std::vector& basepoint, const std::vector* direction) { - return direction == nullptr ? Gudhi::multi_persistence::Line(basepoint) - : Gudhi::multi_persistence::Line(basepoint, *direction); -} - -template -nb::tuple barcode_from_line_impl(Gudhi::multi_persistence::Module& self, - const std::vector& basepoint, - const std::vector* direction, - int degree) { - auto line = line_from_vectors(basepoint, direction); - decltype(self.get_barcode_from_line(line, degree)) barcode; - { - nb::gil_scoped_release release; - barcode = self.get_barcode_from_line(line, degree); - } - return barcode_to_python(barcode); -} - -template -Gudhi::multi_persistence::Module& evaluate_in_grid_impl(Gudhi::multi_persistence::Module& self, - const GridRange& grid) { - { - nb::gil_scoped_release release; - self.evaluate_in_grid(grid); - } - return self; -} - -template -auto compute_landscapes_box_impl(Gudhi::multi_persistence::Module& self, - int degree, - const RandomAccessValueRange1& ks, - const Gudhi::multi_persistence::Box& box, - const RandomAccessValueRange2& resolution, - int n_jobs) { - std::vector out; - { - nb::gil_scoped_release release; - out = Gudhi::multi_persistence::compute_set_of_module_landscapes(self, degree, ks, box, resolution, n_jobs); - } - return _wrap_as_numpy_array(std::move(out), ks.size(), resolution[0], resolution[1]); -} - -template -auto compute_landscapes_grid_impl(Gudhi::multi_persistence::Module& self, - int degree, - const RandomAccessValueRange& ks, - const std::vector& grid, - int n_jobs) { - std::vector out; - { - nb::gil_scoped_release release; - out = Gudhi::multi_persistence::compute_set_of_module_landscapes(self, degree, ks, grid, n_jobs); - } - return _wrap_as_numpy_array(std::move(out), ks.size(), grid[0].size(), grid[1].size()); -} - -template -nb::ndarray compute_pixels_impl(Gudhi::multi_persistence::Module& self, - const RandomAccessPointRange& coordinates, - const DimensionRange& degrees, - const Gudhi::multi_persistence::Box& box, - T delta, - T p, - bool normalize, - int n_jobs) { - std::vector out; - { - nb::gil_scoped_release release; - out = Gudhi::multi_persistence::compute_module_pixels(self, coordinates, degrees, box, delta, p, normalize, n_jobs); - } - return owned_array(std::move(out), {degrees.size(), coordinates.size()}); -} - -template -nb::ndarray distance_to_impl(Gudhi::multi_persistence::Module& self, - const RandomAccessPointRange& pts, - bool signed_distance, - int n_jobs) { - std::vector out; - { - nb::gil_scoped_release release; - out = Gudhi::multi_persistence::compute_module_distances_to(self, pts, signed_distance, n_jobs); - } - return owned_array(std::move(out), {pts.size(), self.size()}); -} - -template -Gudhi::multi_persistence::Module& set_box_impl(Gudhi::multi_persistence::Module& self, - const Gudhi::multi_persistence::Box& box) { - { - nb::gil_scoped_release release; - self.set_box(box); - } - return self; -} - -template -Gudhi::multi_persistence::Module& rescale_impl(Gudhi::multi_persistence::Module& self, - const std::vector& factors, - int degree) { - { - nb::gil_scoped_release release; - self.rescale(factors, degree); - } - return self; -} - -template -Gudhi::multi_persistence::Module& translate_impl(Gudhi::multi_persistence::Module& self, - const std::vector& factors, - int degree) { - { - nb::gil_scoped_release release; - self.translate(factors, degree); - } - return self; -} - -template -Gudhi::multi_persistence::Module module_from_dump(nb::handle dump) { - nb::tuple tpl = nb::cast(dump); - auto box = matrix_from_handle(tpl[0]); - std::vector lower = box.empty() ? std::vector{} : box[0]; - std::vector upper = box.size() < 2 ? std::vector{} : box[1]; - Gudhi::multi_persistence::Module out; - out.set_box(Gudhi::multi_persistence::Box(lower, upper)); - for (nb::handle summand_dump : nb::iter(tpl[1])) { - out.add_summand(summand_from_dump(summand_dump)); - } - return out; -} - -template -std::vector> filtration_values_from_module(const Gudhi::multi_persistence::Module& module, - bool unique) { - std::vector> values; - size_t num_parameters = module.get_box().get_lower_corner().size(); - values.resize(num_parameters); - for (const auto& summand : module) { - auto births = summand.compute_flat_upset(); - auto deaths = summand.compute_flat_downset(); - const size_t birth_count = static_cast(summand.get_number_of_birth_corners()); - const size_t death_count = static_cast(summand.get_number_of_death_corners()); - for (size_t p = 0; p < num_parameters; ++p) { - for (size_t row = 0; row < birth_count; ++row) { - const T value = births[row * num_parameters + p]; - if constexpr (!std::numeric_limits::has_infinity) { - values[p].push_back(value); - } else if (std::isfinite(static_cast(value))) { - values[p].push_back(value); - } - } - for (size_t row = 0; row < death_count; ++row) { - const T value = deaths[row * num_parameters + p]; - if constexpr (!std::numeric_limits::has_infinity) { - values[p].push_back(value); - } else if (std::isfinite(static_cast(value))) { - values[p].push_back(value); - } - } - } - } - if (unique) { - for (auto& vals : values) { - std::sort(vals.begin(), vals.end()); - vals.erase(std::unique(vals.begin(), vals.end()), vals.end()); - if constexpr (std::numeric_limits::has_infinity) { - const T pos_inf = std::numeric_limits::infinity(); - const T neg_inf = -pos_inf; - if (!vals.empty() && vals.back() == pos_inf) vals.pop_back(); - if (!vals.empty() && vals.front() == neg_inf) vals.erase(vals.begin()); - } - } - } - return values; -} - -template -struct ModuleSummandIterator { - using iterator_category = std::input_iterator_tag; - using value_type = Gudhi::multi_persistence::Summand; - using difference_type = std::ptrdiff_t; - - Gudhi::multi_persistence::Module* module = nullptr; - size_t index = 0; - - value_type operator*() const { return module->get_summand((unsigned int)index); } - - ModuleSummandIterator& operator++() { - ++index; - return *this; - } - - bool operator==(const ModuleSummandIterator& other) const { return module == other.module && index == other.index; } - - bool operator!=(const ModuleSummandIterator& other) const { return !(*this == other); } -}; - -template -nb::object self_handle(Wrapper& self) { - return nb::find(self); -} - template void bind_float_module_methods(Class& cls) { if constexpr (Desc::is_float) { using T = typename Desc::value_type; using Box = Gudhi::multi_persistence::Box; - using Module = Gudhi::multi_persistence::Module; - - cls.def( - "_get_barcode_from_line", - [](Module& self, - nb::ndarray, nb::c_contig> basepoint, - nb::object direction, - int degree) -> nb::tuple { - auto basepoint_values = vector_from_array(basepoint); - if (direction.is_none()) { - return barcode_from_line_impl(self, basepoint_values, nullptr, degree); - } - auto direction_array = nb::cast, nb::c_contig>>(direction); - auto direction_values = vector_from_array(direction_array); - return barcode_from_line_impl(self, basepoint_values, &direction_values, degree); - }, - "basepoint"_a, - "direction"_a = nb::none(), - "degree"_a = -1) - .def( - "evaluate_in_grid", - [](Module& self, nb::handle grid_handle) -> Module& { - return evaluate_in_grid_impl(self, matrix_from_handle(grid_handle)); - }, - nb::rv_policy::reference_internal) - .def( - "evaluate_in_grid", - [](Module& self, nb::ndarray, nb::any_contig> grid) -> Module& { - return evaluate_in_grid_impl(self, Numpy_2d_span(grid)); - }, - nb::rv_policy::reference_internal) - .def( - "_compute_landscapes_box", - [](Module& self, - int degree, - nb::ndarray, nb::c_contig> ks, - nb::ndarray, nb::c_contig> box, - nb::ndarray, nb::c_contig> resolution, - int n_jobs) { - return compute_landscapes_box_impl(self, - degree, - make_element_range(ks.data(), ks.view(), false), - box_from_array(box), - make_element_range(resolution.data(), resolution.view(), false), - n_jobs); - }, - "degree"_a, - "ks"_a, - "box"_a, - "resolution"_a, - "n_jobs"_a = 0) - .def( - "_compute_landscapes_box", - [](Module& self, - int degree, - nb::ndarray, nb::c_contig> ks, - nb::ndarray, nb::c_contig> box, - nb::ndarray, nb::c_contig> resolution, - int n_jobs) { - return compute_landscapes_box_impl(self, - degree, - make_element_range(ks.data(), ks.view(), false), - box_from_array(box), - make_element_range(resolution.data(), resolution.view(), false), - n_jobs); - }, - "degree"_a, - "ks"_a, - "box"_a, - "resolution"_a, - "n_jobs"_a = 0) - .def( - "_compute_landscapes_grid", - [](Module& self, int degree, nb::handle ks_handle, nb::handle grid_handle, int n_jobs) { - auto ks_in = vector_from_handle(ks_handle); - std::vector ks; - ks.reserve(ks_in.size()); - for (int k : ks_in) ks.push_back((unsigned int)k); - return compute_landscapes_grid_impl(self, degree, ks, matrix_from_handle(grid_handle), n_jobs); - }, - "degree"_a, - "ks"_a, - "grid"_a, - "n_jobs"_a = 0) - .def( - "_compute_landscapes_grid", - [](Module& self, - int degree, - nb::ndarray, nb::c_contig> ks, - nb::ndarray, nb::c_contig> grid, - int n_jobs) { - return compute_landscapes_grid_impl( - self, - degree, - make_element_range(ks.data(), ks.view(), false), - multipers::nanobind_dense_utils::non_regular_matrix_from_array(grid), - n_jobs); - }, - "degree"_a, - "ks"_a, - "grid"_a, - "n_jobs"_a = 0) - .def( - "_compute_landscapes_grid", - [](Module& self, - int degree, - nb::ndarray, nb::c_contig> ks, - nb::ndarray, nb::c_contig> grid, - int n_jobs) { - return compute_landscapes_grid_impl( - self, - degree, - make_element_range(ks.data(), ks.view(), false), - multipers::nanobind_dense_utils::non_regular_matrix_from_array(grid), - n_jobs); - }, - "degree"_a, - "ks"_a, - "grid"_a, - "n_jobs"_a = 0) - .def( - "_compute_pixels", - [](Module& self, - nb::handle coordinates_handle, - nb::handle degrees_handle, - nb::handle box_handle, - T delta, - T p, - bool normalize, - int n_jobs) { - return compute_pixels_impl(self, - matrix_from_handle(coordinates_handle), - vector_from_handle(degrees_handle), - box_from_rows(matrix_from_handle(box_handle)), - delta, - p, - normalize, - n_jobs); - }, - "coordinates"_a, - "degrees"_a, - "box"_a, - "delta"_a, - "p"_a, - "normalize"_a = false, - "n_jobs"_a = 0) - .def( - "_compute_pixels", - [](Module& self, - nb::ndarray, nb::any_contig> coordinates, - nb::ndarray, nb::c_contig> degrees, - nb::ndarray, nb::c_contig> box, - T delta, - T p, - bool normalize, - int n_jobs) { - return compute_pixels_impl(self, - Numpy_2d_span(coordinates), - make_element_range(degrees.data(), degrees.view(), false), - box_from_array(box), - delta, - p, - normalize, - n_jobs); - }, - "coordinates"_a, - "degrees"_a, - "box"_a, - "delta"_a, - "p"_a, - "normalize"_a = false, - "n_jobs"_a = 0) - .def( - "_compute_pixels", - [](Module& self, - nb::ndarray, nb::any_contig> coordinates, - nb::ndarray, nb::c_contig> degrees, - nb::ndarray, nb::c_contig> box, - T delta, - T p, - bool normalize, - int n_jobs) { - return compute_pixels_impl(self, - Numpy_2d_span(coordinates), - make_element_range(degrees.data(), degrees.view(), false), - box_from_array(box), - delta, - p, - normalize, - n_jobs); - }, - "coordinates"_a, - "degrees"_a, - "box"_a, - "delta"_a, - "p"_a, - "normalize"_a = false, - "n_jobs"_a = 0) - .def( - "distance_to", - [](Module& self, nb::handle pts_handle, bool signed_distance, int n_jobs) { - return distance_to_impl(self, matrix_from_handle(pts_handle), signed_distance, n_jobs); - }, - "pts"_a, - "signed"_a = false, - "n_jobs"_a = 0) - .def( - "distance_to", - [](Module& self, - nb::ndarray, nb::any_contig> pts, - bool signed_distance, - int n_jobs) { return distance_to_impl(self, Numpy_2d_span(pts), signed_distance, n_jobs); }, - "pts"_a, - "signed"_a = false, - "n_jobs"_a = 0) - .def("get_interleavings", - [](Module& self) -> nb::ndarray { - std::vector interleavings; - { - nb::gil_scoped_release release; - interleavings = Gudhi::multi_persistence::compute_module_interleavings(self, self.get_box()); - } - return owned_array(std::move(interleavings), {interleavings.size()}); - }) - .def( - "get_interleavings", - [](Module& self, - nb::ndarray, nb::c_contig> box) -> nb::ndarray { - std::vector interleavings; - { - nb::gil_scoped_release release; - interleavings = Gudhi::multi_persistence::compute_module_interleavings(self, box_from_array(box)); - } - return owned_array(std::move(interleavings), {interleavings.size()}); - }, - "box"_a); + using Module = Gudhi::multi_persistence::Module_interface; + using NDArray1 = typename Module::Tensor1D; + using NDArray2 = typename Module::Tensor2D; + + cls.def("_get_barcode_from_line", + &Module::get_barcode_from_line, + "basepoint"_a, + "direction"_a = nb::none(), + "degree"_a = -1) + // .def("evaluate_in_grid", nb::overload_cast>&>(&Module::evaluate_in_grid)) + .def("evaluate_in_grid", nb::overload_cast&>(&Module::evaluate_in_grid)) + .def("evaluate_in_grid", nb::overload_cast(&Module::evaluate_in_grid)) + .def("_compute_landscapes_box", + &Module::template compute_landscapes_from_box, + "degree"_a, + "ks"_a, + "box"_a, + "resolution"_a, + "n_jobs"_a = 0) + .def("_compute_landscapes_box", + &Module::template compute_landscapes_from_box, + "degree"_a, + "ks"_a, + "box"_a, + "resolution"_a, + "n_jobs"_a = 0) + .def("_compute_landscapes_grid", + &Module::template compute_landscapes_from_grid, + "degree"_a, + "ks"_a, + "grid"_a, + "n_jobs"_a = 0) + .def("_compute_landscapes_grid", + &Module::template compute_landscapes_from_grid, + "degree"_a, + "ks"_a, + "grid"_a, + "n_jobs"_a = 0) + .def("_compute_pixels", + &Module::template compute_pixels, + "coordinates"_a, + "degrees"_a, + "box"_a, + "delta"_a, + "p"_a, + "normalize"_a = false, + "n_jobs"_a = 0) + .def("_compute_pixels", + &Module::template compute_pixels, + "coordinates"_a, + "degrees"_a, + "box"_a, + "delta"_a, + "p"_a, + "normalize"_a = false, + "n_jobs"_a = 0) + // .def("distance_to", + // nb::overload_cast>&, bool, int>(&Module::compute_distance_to), + // "pts"_a, + // "signed"_a = false, + // "n_jobs"_a = 0) + .def("distance_to", + nb::overload_cast(&Module::compute_distance_to), + "pts"_a, + "signed"_a = false, + "n_jobs"_a = 0) + .def("get_interleavings", nb::overload_cast<>(&Module::compute_interleavings)) + .def("get_interleavings", nb::overload_cast(&Module::compute_interleavings)); } } @@ -673,9 +213,9 @@ void bind_box_class(nb::module_& m) { auto lower = std::vector(self.get_lower_corner().begin(), self.get_lower_corner().end()); auto upper = std::vector(self.get_upper_corner().begin(), self.get_upper_corner().end()); return corner_pair_to_python(lower, upper); - }) - .def("to_multipers", - [](Box& self) -> nb::ndarray { + }) + .def("to_multipers", + [](Box& self) -> nb::ndarray { auto lower = std::vector(self.get_lower_corner().begin(), self.get_lower_corner().end()); auto upper = std::vector(self.get_upper_corner().begin(), self.get_upper_corner().end()); std::vector flat; @@ -684,7 +224,7 @@ void bind_box_class(nb::module_& m) { flat.push_back(lower[i]); flat.push_back(upper[i]); } - return owned_array(std::move(flat), {size_t(2), lower.size()}); + return owned_array(std::move(flat), {size_t(2), lower.size()}); }) .def_prop_ro("_template_id", [](const Box&) -> int { return Desc::template_id; }) .def_prop_ro("dtype", [](const Box&) -> nb::object { return numpy_dtype_type(Desc::dtype_name); }); @@ -693,261 +233,103 @@ void bind_box_class(nb::module_& m) { template void bind_module_class(nb::module_& m) { using T = typename Desc::value_type; - using Module = Gudhi::multi_persistence::Module; + using Module = Gudhi::multi_persistence::Module_interface; + using Summand = typename Module::Summand_t; + using Box = Gudhi::multi_persistence::Box; + using NDArray1 = typename Module::Tensor1D; + using NDArray2 = typename Module::Tensor2D; std::string iterator_name = std::string("_PyModuleIterator_") + std::string(Desc::short_name); auto module_cls = nb::class_(m, Desc::module_name.data()) .def(nb::init<>()) - .def( - "_from_ptr", - [](Module& self, intptr_t ptr) -> Module& { - auto* other = reinterpret_cast(ptr); - self = std::move(*other); - delete other; - return self; - }, - nb::rv_policy::reference_internal) - .def("__len__", [](Module& self) -> int { return self.size(); }) - .def("__eq__", [](Module& self, Module& other) { return self == other; }) + .def(nb::init()) .def_prop_ro("_template_id", [](const Module&) -> int { return Desc::template_id; }) + .def(nb::self == nb::self) + .def("__len__", [](Module& self) -> int { return self.size(); }) .def("__getitem__", - [](Module& self, nb::object key) -> nb::object { - if (nb::isinstance(key)) { - auto [start, stop, step, length] = nb::cast(key).compute(self.size()); - if (start == 0 && stop == static_cast(self.size()) && step == 1 && - length == self.size()) { - return self_handle(self); - } - throw nb::index_error("Only [:] slices are supported."); - } - int index = nb::cast(key); - size_t size = self.size(); - if (size == 0) { - throw nb::index_error("Module is empty."); - } - if (index < 0) { - index += (int)size; - } - if (index < 0 || index >= (int)size) { - throw nb::index_error("Summand index out of range."); - } - return nb::cast(self.get_summand((unsigned int)index)); + [](Module& self, int key) -> Summand& { + int size = self.size(); + if (size == 0) throw nb::index_error("Module is empty."); + if (key < 0) key += size; + if (key < 0 || key >= size) throw nb::index_error("Summand index out of range."); + return self.get_summand(key); }) .def( "__iter__", - [iterator_name](Module& self) { + [iterator_name](const Module& self) { return nb::make_iterator(nb::type(), iterator_name.c_str(), - ModuleSummandIterator{&self, 0}, - ModuleSummandIterator{&self, self.size()}); + self.begin(), + self.end(), + nb::rv_policy::reference_internal); }, nb::keep_alive<0, 1>()) - .def( - "merge", - [](Module& self, Module& other, int dim) -> Module& { - Module c_other = other; - { - nb::gil_scoped_release release; - for (const auto& summand : c_other) self.add_summand(summand, dim); - } - return self; - }, - "other"_a, - "dim"_a = -1, - nb::rv_policy::reference_internal) - .def("permute_summands", - [](Module& self, nb::ndarray, nb::c_contig, nb::device::cpu> permutation) { - Module out; + .def("summands_of_dimension_range", &Module::get_summands_of_dimension_range) + .def_prop_ro("max_degree", &Module::get_max_dimension) + .def_prop_ro("num_parameters", &Module::get_number_of_parameters) + .def("set_box", nb::overload_cast(&Module::set_box)) + .def("set_box", nb::overload_cast(&Module::set_box)) + .def("set_box", nb::overload_cast>&>(&Module::set_box)) + .def("get_bottom", &Module::get_box_lower_corner_view) + .def("get_top", &Module::get_box_upper_corner_view) + .def("get_box", &Module::get_flat_box) + .def("get_bounds", &Module::compute_bounds) + .def("get_filtration_values", &Module::get_flat_filtration_values, "unique"_a = true) + .def("get_dimensions", &Module::get_all_dimension) + .def("merge", nb::overload_cast(&Module::merge)) + .def("merge", nb::overload_cast(&Module::merge)) + .def("_add_mmas", nb::overload_cast(&Module::merge)) // rename this also as 'merge'? + .def("rescale", nb::overload_cast(&Module::rescale), "rescale_factors"_a, "degree"_a = -1) + // .def("rescale", + // nb::overload_cast&, int>(&Module::rescale), + // "rescale_factors"_a, + // "degree"_a = -1) + .def("translate", nb::overload_cast(&Module::translate), "translation"_a, "degree"_a = -1) + // .def("translate", + // nb::overload_cast&, int>(&Module::translate), + // "translation"_a, + // "degree"_a = -1) + .def("permute_summands", &Module::permute_summands) + .def("get_module_of_degree", &Module::get_module_of_degree) + .def("get_module_of_degrees", nb::overload_cast(&Module::get_module_of_degrees)) + .def("get_module_of_degrees", nb::overload_cast&>(&Module::get_module_of_degrees)) + .def("__getstate__", + [](const Module& self) -> nb::ndarray { + std::size_t buffer_size; + char* buffer; { nb::gil_scoped_release release; - out = Gudhi::multi_persistence::build_permuted_module( - self, make_element_range(permutation.data(), permutation.view(), false)); + buffer_size = get_serialization_size_of(self); + buffer = new char[buffer_size]; + serialize_value_to_char_buffer(self, buffer); } - return out; + return _wrap_as_numpy_array(buffer, buffer_size); }) - .def( - "set_box", - [](Module& self, nb::handle box_handle) -> Module& { - return set_box_impl(self, box_from_rows(matrix_from_handle(box_handle))); - }, - nb::rv_policy::reference_internal) - .def( - "set_box", - [](Module& self, nb::ndarray, nb::c_contig> box) -> Module& { - return set_box_impl(self, box_from_array(box)); - }, - nb::rv_policy::reference_internal) - .def("get_module_of_degree", - [](Module& self, int degree) { - Module out; - { - nb::gil_scoped_release release; - out.set_box(self.get_box()); - for (const auto& summand : self) - if (summand.get_dimension() == degree) out.add_summand(summand); - } - return out; - }) - .def("get_module_of_degrees", - [](Module& self, nb::handle degrees_handle) { - auto degrees = vector_from_handle(degrees_handle); - Module out; - { - nb::gil_scoped_release release; - out.set_box(self.get_box()); - for (const auto& summand : self) { - for (int degree : degrees) { - if (degree == summand.get_dimension()) { - out.add_summand(summand); - break; - } - } - } - } - return out; - }) - .def("_get_dump", [](Module& self) -> nb::tuple { return dump_module(self); }) - .def( - "dump", - [](Module& self, nb::object path) -> nb::tuple { - nb::tuple dump = dump_module(self); - if (!path.is_none()) { - nb::object builtins = nb::module_::import_("builtins"); - nb::object pickle = nb::module_::import_("pickle"); - nb::object handle = builtins.attr("open")(path, "wb"); - try { - pickle.attr("dump")(dump, handle); - } catch (...) { - handle.attr("close")(); - throw; - } - handle.attr("close")(); - } - return dump; - }, - "path"_a = nb::none()) - .def( - "_load_dump", - [](Module& self, nb::handle dump) -> Module& { - self = module_from_dump(dump); - return self; - }, - nb::rv_policy::reference_internal) - .def("__getstate__", [](Module& self) -> nb::tuple { return dump_module(self); }) - .def("__setstate__", [](Module& self, nb::handle state) { new (&self) Module(module_from_dump(state)); }) - .def( - "_add_mmas", - [](Module& self, nb::iterable mmas) -> Module& { - for (nb::handle item : mmas) { - Module c_other = nb::cast(item); - { - nb::gil_scoped_release release; - for (const auto& summand : c_other) self.add_summand(summand); - } - } - return self; - }, - nb::rv_policy::reference_internal) - .def("get_bottom", - [](Module& self) -> nb::ndarray { - return owned_array( - std::vector(self.get_box().get_lower_corner().begin(), self.get_box().get_lower_corner().end()), - {self.get_box().get_lower_corner().size()}); - }) - .def("get_top", - [](Module& self) -> nb::ndarray { - return owned_array( - std::vector(self.get_box().get_upper_corner().begin(), self.get_box().get_upper_corner().end()), - {self.get_box().get_upper_corner().size()}); - }) - .def("get_box", - [](Module& self) -> nb::ndarray { - auto lower = - std::vector(self.get_box().get_lower_corner().begin(), self.get_box().get_lower_corner().end()); - auto upper = - std::vector(self.get_box().get_upper_corner().begin(), self.get_box().get_upper_corner().end()); - std::vector flat_box; - flat_box.reserve(lower.size() + upper.size()); - flat_box.insert(flat_box.end(), lower.begin(), lower.end()); - flat_box.insert(flat_box.end(), upper.begin(), upper.end()); - return owned_array(std::move(flat_box), {size_t(2), self.get_box().get_lower_corner().size()}); - }) - .def_prop_ro("max_degree", [](const Module& self) -> int { return self.get_max_dimension(); }) - .def_prop_ro("num_parameters", - [](const Module& self) -> int { return self.get_box().get_lower_corner().size(); }) - .def("get_bounds", - [](Module& self) -> nb::ndarray { - std::pair, std::vector> cbounds; - { - nb::gil_scoped_release release; - auto bounds = self.compute_bounds(); - auto cpp_bounds = bounds.get_bounding_corners(); - cbounds.first.assign(cpp_bounds.first.begin(), cpp_bounds.first.end()); - cbounds.second.assign(cpp_bounds.second.begin(), cpp_bounds.second.end()); - } - return corner_pair_to_python(cbounds.first, cbounds.second); - }) - .def( - "rescale", - [](Module& self, nb::handle factors, int degree) -> Module& { - return rescale_impl(self, vector_from_handle(factors), degree); - }, - "rescale_factors"_a, - "degree"_a = -1, - nb::rv_policy::reference_internal) - .def( - "rescale", - [](Module& self, - nb::ndarray, nb::c_contig> factors, - int degree) -> Module& { return rescale_impl(self, vector_from_array(factors), degree); }, - "rescale_factors"_a, - "degree"_a = -1, - nb::rv_policy::reference_internal) - .def( - "translate", - [](Module& self, nb::handle factors, int degree) -> Module& { - return translate_impl(self, vector_from_handle(factors), degree); - }, - "translation"_a, - "degree"_a = -1, - nb::rv_policy::reference_internal) - .def( - "translate", - [](Module& self, - nb::ndarray, nb::c_contig> factors, - int degree) -> Module& { return translate_impl(self, vector_from_array(factors), degree); }, - "translation"_a, - "degree"_a = -1, - nb::rv_policy::reference_internal) - .def( - "get_filtration_values", - [](Module& self, bool unique) -> std::vector> { - return filtration_values_from_module(self, unique); - }, - "unique"_a = true) - .def("get_dimensions", [](Module& self) -> nb::ndarray { - std::vector dims; - dims.reserve(self.size()); - for (size_t i = 0; i < self.size(); ++i) - dims.push_back((int32_t)self.get_summand((unsigned int)i).get_dimension()); - return owned_array(std::move(dims), {self.size()}); + .def("__setstate__", [](Module& self, nb::ndarray, nb::numpy> state) { + new (&self) Module(Gudhi::multi_persistence::deserialize_from_python(state)); }); bind_float_module_methods(module_cls); module_cls.def_prop_ro("dtype", [](const Module&) -> nb::object { return numpy_dtype_type(Desc::dtype_name); }); - std::string from_dump_name = std::string(Desc::from_dump_name); - m.def( - from_dump_name.c_str(), - [](nb::handle dump) { - Module out; - out = module_from_dump(dump); - return out; - }, - "dump"_a); + std::string range_name = std::string("_SummandByDimensionRange_") + std::string(Desc::short_name); + std::string range_it_name = std::string("_SummandByDimensionIt_") + std::string(Desc::short_name); + + nb::class_(m, range_name.c_str()) + .def(nb::init<>()) + .def( + "__iter__", + [range_it_name](typename Module::Summand_of_dimension_range& r) { + return nb::make_iterator(nb::type(), + range_it_name.c_str(), + r.begin(), + r.end(), + nb::rv_policy::reference_internal); + }, + nb::keep_alive<0, 1>()); } template diff --git a/multipers/_slicer_nanobind.cpp b/multipers/_slicer_nanobind.cpp index a795cfd4..07d11e40 100644 --- a/multipers/_slicer_nanobind.cpp +++ b/multipers/_slicer_nanobind.cpp @@ -32,8 +32,10 @@ #include "ext_interface/nanobind_registry_helpers.hpp" #include "ext_interface/nanobind_registry_runtime.hpp" #include "gudhi/Multi_parameter_filtered_complex.h" +#include "gudhi/Multi_persistence/Box.h" #include "gudhi/slicer_conversion_core.hpp" #include "gudhi/slicer_helpers.h" +#include "gudhi/Module_interface.h" #include #include "multi_parameter_rank_invariant/hilbert_function.h" #include "multi_parameter_rank_invariant/rank_invariant.h" @@ -317,7 +319,7 @@ nb::tuple compute_persistence_on_slices( throw nb::value_error("Expected one filtration value per generator."); } std::vector barcodes(num_slices); - Numpy_2d_span view(values); + Numpy_2d_span view(values); { nb::gil_scoped_release release; if constexpr (Desc::is_vine) { @@ -2083,7 +2085,7 @@ nb::tuple compute_rank_signed_measure_sparse(type_list, } template -nb::object module_approximation_from_desc(typename Desc::wrapper& wrapper, +Gudhi::multi_persistence::Module_interface module_approximation_from_desc(typename Desc::wrapper& wrapper, const std::vector& direction, double max_error, Gudhi::multi_persistence::Box box, @@ -2100,12 +2102,12 @@ nb::object module_approximation_from_desc(typename Desc::wrapper& wrapper, mod = Gudhi::multiparameter::mma::multiparameter_module_approximation( wrapper.truc, direction, max_error, box, threshold, complete, verbose, n_jobs); } - return nb::cast(std::move(mod)); + return {std::move(mod), std::move(box)}; } } template -nb::object compute_module_approximation_from_slicer(type_list, +Gudhi::multi_persistence::Module_interface compute_module_approximation_from_slicer(type_list, nb::handle slicer, const std::vector& direction, double max_error, @@ -2117,7 +2119,7 @@ nb::object compute_module_approximation_from_slicer(type_list, if (!has_slicer_template_id(slicer)) { throw std::runtime_error("Unsupported slicer type for module approximation."); } - return dispatch_slicer_by_template_id(template_id_of(slicer), [&]() -> nb::object { + return dispatch_slicer_by_template_id(template_id_of(slicer), [&]() -> Gudhi::multi_persistence::Module_interface { auto& wrapper = nb::cast(slicer); return module_approximation_from_desc(wrapper, direction, max_error, box, threshold, complete, verbose, n_jobs); }); diff --git a/multipers/gudhi/Module_interface.h b/multipers/gudhi/Module_interface.h new file mode 100644 index 00000000..f1d87396 --- /dev/null +++ b/multipers/gudhi/Module_interface.h @@ -0,0 +1,522 @@ +/* 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): David Loiseaux, Hannah Schreiber + * + * Copyright (C) 2026 Inria + * + * Modification(s): + * - YYYY/MM Author: Description of the modification + */ + +/** + * @file Module_interface.h + * @author David Loiseaux, Hannah Schreiber + * @brief Contains the @ref Gudhi::multi_persistence::Module_interface class for python bindings. + */ + +#ifndef MP_PY_MODULE_H_INCLUDED +#define MP_PY_MODULE_H_INCLUDED + +#include +#include +#include +#include +#include + +#include +#include + +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +namespace Gudhi { +namespace multi_persistence { + +/** + * @private + */ +template +class Module_interface { + public: + using value_type = T; + using Dimension = typename Module::Dimension; + using Summand_t = typename Module::Summand_t; + using iterator = typename Module::iterator; + using const_iterator = typename Module::const_iterator; + using Summand_of_dimension_range = + boost::any_range; + using Tensor1D = nanobind::ndarray, nanobind::any_contig>; + using Tensor2D = nanobind::ndarray, nanobind::any_contig>; + template + using IntTensor1D = nanobind::ndarray, nanobind::any_contig>; + + static constexpr T T_inf = Summand_t::T_inf; /**< Infinity. */ + static constexpr T T_m_inf = Summand_t::T_m_inf; /**< Minus infinity. */ + + Module_interface() = default; + + Module_interface(const Box &box) : module_(), box_(box) {} + + Module_interface(Box &&box) : module_(), box_(std::move(box)) {} + + Module_interface(Module&& mod, Box &&box) : module_(std::move(mod)), box_(std::move(box)) {} + + [[nodiscard]] int get_number_of_parameters() const { + int numParam = module_.get_number_of_parameters(); + if (numParam == get_null_value() && !box_.is_trivial()) return box_.get_number_of_coordinates(); + return numParam; + } + + [[nodiscard]] int size() const { return module_.size(); } + + [[nodiscard]] int get_max_dimension() const { return module_.get_max_dimension(); } + + iterator begin() { return module_.begin(); } + + iterator end() { return module_.end(); } + + const_iterator begin() const { return module_.begin(); } + + const_iterator end() const { return module_.end(); } + + // TODO: nanobind binding for multipers + Summand_of_dimension_range get_summands_of_dimension_range(int degree) const { + // alternative would be to just warn + return empty range instead of throw + if (degree < 0) throw std::invalid_argument("Cannot iterate over summands of negative dimension."); + return module_.get_summands_of_dimension_range(static_cast(degree)) | + boost::adaptors::type_erased(); + } + + auto get_box_lower_corner_view() const { + // no transfer of ownership, dies together with the box + return nanobind::ndarray(box_.get_lower_corner().data(), + {box_.get_number_of_coordinates()}); + } + + auto get_box_upper_corner_view() const { + // no transfer of ownership, dies together with the box + return nanobind::ndarray(box_.get_upper_corner().data(), + {box_.get_number_of_coordinates()}); + } + + auto get_flat_box() const { + std::vector fb(box_.get_lower_corner().retrieve_underlying_container()); + { + nanobind::gil_scoped_release release; + fb.reserve(fb.size() * 2); + fb.insert(fb.end(), box_.get_upper_corner().begin(), box_.get_upper_corner().end()); + } + return _wrap_as_numpy_array(std::move(fb), 2, box_.get_number_of_coordinates()); + } + + Module_interface &set_box(const Box &box) { + box_ = box; + return *this; + } + + Module_interface &set_box(Tensor2D box) { + box_ = get_box_from_tensor(box); + return *this; + } + + Module_interface &set_box(const std::vector> &box) { + if (box.size() != 2) throw std::invalid_argument("Box has to be represented by two corners."); + if (box[0].size() != box[1].size()) + throw std::invalid_argument("Both corners defining the box must have same dimension."); + box_ = Box(box[0], box[1]); + return *this; + } + + [[nodiscard]] nanobind::list get_flat_filtration_values(bool unique) const { + int numParam = module_.get_number_of_parameters(); + if (numParam == get_null_value()) return {}; // empty module + + std::vector> values(numParam); + { + nanobind::gil_scoped_release release; + for (const auto &summand : module_) { + const auto &births = summand.get_upset(); + GUDHI_CHECK(births.num_parameters() == numParam, + std::runtime_error("Upset number of parameters is not coherent.")); + for (int p = 0; p < numParam; ++p) { + for (std::size_t g = 0; g < summand.get_number_of_birth_corners(); ++g) { + const T v = births(g, p); + // in the original, infinite values were never copied + // but if unique is false, I think it makes more sense to keep a bijection on the indices, no? + // btw unique == false is never used in multipers right now, so it does not matter too much + if (!unique || (v != T_inf && v != T_m_inf)) values[p].push_back(v); + } + } + const auto &deaths = summand.get_downset(); + GUDHI_CHECK(deaths.num_parameters() == numParam, + std::runtime_error("Downset number of parameters is not coherent.")); + for (int p = 0; p < numParam; ++p) { + for (std::size_t g = 0; g < summand.get_number_of_death_corners(); ++g) { + const T v = deaths(g, p); + // same question then for births + if (!unique || (v != T_inf && v != T_m_inf)) values[p].push_back(v); + } + } + } + } + + nanobind::list out; + for (auto &vals : values) { + if (unique) { + std::sort(vals.begin(), vals.end()); + vals.erase(std::unique(vals.begin(), vals.end()), vals.end()); + } + out.append(_wrap_as_numpy_array(std::move(vals), vals.size())); + } + return out; + } + + auto get_all_dimension() const { + std::vector dimensions(module_.size()); + { + nanobind::gil_scoped_release release; + for (std::size_t i = 0; i < module_.size(); ++i) { + dimensions[i] = module_.get_summand(i).get_dimension(); + } + } + return _wrap_as_numpy_array(std::move(dimensions), dimensions.size()); + } + + Summand_t &get_summand(int index) { return module_.get_summand(index); } + + const Summand_t &get_summand(int index) const { return module_.get_summand(index); } + + Module_interface &merge(const Module_interface &toMerge) { + { + nanobind::gil_scoped_release release; + module_.merge(toMerge.module_); + } + return *this; + } + + Module_interface &merge(const Module_interface &toMerge, int degree) { + { + nanobind::gil_scoped_release release; + // alternative would be to just warn + return instead of throw + if (degree < 0) throw std::invalid_argument("Cannot merge summands of negative dimension."); + module_.merge(toMerge.module_, static_cast(degree)); + } + return *this; + } + + Module_interface &merge(nanobind::iterable toMerge) { + for (nanobind::handle item : toMerge) { + merge(nanobind::cast(item)); + } + return *this; + } + + auto compute_bounds() const { + Box box; + { + nanobind::gil_scoped_release release; + box = module_.compute_bounds(); + } + auto &corners = box.get_lower_corner().retrieve_underlying_container(); + auto dim = corners.size(); + { + nanobind::gil_scoped_release release; + corners.reserve(dim * 2); + corners.insert(corners.end(), box.get_upper_corner().begin(), box.get_upper_corner().end()); + } + return _wrap_as_numpy_array(std::move(corners), 2, dim); + } + + nanobind::list get_barcode_from_line(Tensor1D basepoint, std::optional direction, int degree) const { + std::vector>> barcode; + nanobind::list out; + { + nanobind::gil_scoped_release release; + Dimension dim = degree < 0 ? get_null_value() : static_cast(degree); + Numpy_span baseView(basepoint); + Line line; + if (direction.has_value()) { + Numpy_span dirView(*direction); + line = Line(baseView.begin(), baseView.end(), dirView.begin(), dirView.end()); + } else { + line = Line(baseView.begin(), baseView.end()); + } + barcode = module_.get_barcode_from_line(line, dim); + } + for (auto &d : barcode) { + out.append(_wrap_as_numpy_array(std::move(d))); + } + return out; + } + + Module_interface &rescale(const std::vector &rescaleFactors, int degree) { + { + nanobind::gil_scoped_release release; + Dimension dim = degree < 0 ? get_null_value() : static_cast(degree); + module_.rescale(rescaleFactors, dim); + } + return *this; + } + + Module_interface &rescale(Tensor1D rescaleFactors, int degree) { + { + nanobind::gil_scoped_release release; + Dimension dim = degree < 0 ? get_null_value() : static_cast(degree); + module_.rescale(Numpy_span(rescaleFactors), dim); + } + return *this; + } + + Module_interface &translate(const std::vector &translation, int degree) { + { + nanobind::gil_scoped_release release; + Dimension dim = degree < 0 ? get_null_value() : static_cast(degree); + module_.translate(translation, dim); + } + return *this; + } + + Module_interface &translate(Tensor1D translation, int degree) { + { + nanobind::gil_scoped_release release; + Dimension dim = degree < 0 ? get_null_value() : static_cast(degree); + module_.translate(Numpy_span(translation), dim); + } + return *this; + } + + Module_interface &evaluate_in_grid(const std::vector> &grid) { + { + nanobind::gil_scoped_release release; + module_.evaluate_in_grid(grid); + } + return *this; + } + + Module_interface &evaluate_in_grid(const std::vector &grid) { + { + nanobind::gil_scoped_release release; + std::vector> views(grid.begin(), grid.end()); + module_.evaluate_in_grid(views); + } + return *this; + } + + Module_interface &evaluate_in_grid(Tensor2D grid) { + { + nanobind::gil_scoped_release release; + module_.evaluate_in_grid(Numpy_2d_span(grid)); + } + return *this; + } + + Module_interface permute_summands(Tensor1D permutation) { + Module_interface out(box_); + { + nanobind::gil_scoped_release release; + out.module_ = Gudhi::multi_persistence::build_permuted_module(module_, Numpy_span(permutation)); + } + return out; + } + + Module_interface get_module_of_degree(int degree) { + if (degree < 0) throw std::invalid_argument("Cannot get summands of negative dimension."); + Module_interface out(box_); + { + nanobind::gil_scoped_release release; + out.module_ = Gudhi::multi_persistence::build_module_of_dimension(module_, degree); + } + return out; + } + + Module_interface get_module_of_degrees(Tensor1D degrees) { + Module_interface out(box_); + { + nanobind::gil_scoped_release release; + out.module_ = Gudhi::multi_persistence::build_module_of_dimension(module_, Numpy_span(degrees)); + } + return out; + } + + Module_interface get_module_of_degrees(const std::vector °rees) { + Module_interface out(box_); + { + nanobind::gil_scoped_release release; + out.module_ = Gudhi::multi_persistence::build_module_of_dimension(module_, degrees); + } + return out; + } + + template + auto compute_landscapes_from_box(int degree, + IntTensor1D ks, + Tensor2D box, + IntTensor1D resolution, + int n_jobs) { + if (degree < 0) throw std::invalid_argument("Landscape dimension has to be positive."); + + std::vector out; + Numpy_span resolutionView(resolution); + { + nanobind::gil_scoped_release release; + out = Gudhi::multi_persistence::compute_set_of_module_landscapes( + module_, degree, Numpy_span(ks), get_box_from_tensor(box), resolutionView, n_jobs); + } + return _wrap_as_numpy_array(std::move(out), ks.shape(0), resolutionView[0], resolutionView[1]); + } + + template + auto compute_landscapes_from_grid(int degree, + IntTensor1D ks, + const std::vector &grid, + int n_jobs) { + if (degree < 0) throw std::invalid_argument("Landscape dimension has to be positive."); + + std::vector out; + { + nanobind::gil_scoped_release release; + out = Gudhi::multi_persistence::compute_set_of_module_landscapes( + module_, degree, Numpy_span(ks), std::vector>(grid.begin(), grid.end()), n_jobs); + } + return _wrap_as_numpy_array(std::move(out), ks.shape(0), grid[0].shape(0), grid[1].shape(0)); + } + + template + auto compute_pixels(Tensor2D coordinates, + IntTensor1D degrees, + Tensor2D box, + T delta, + T p, + bool normalize, + int n_jobs) { + std::vector out; + { + nanobind::gil_scoped_release release; + out = Gudhi::multi_persistence::compute_module_pixels(module_, + Numpy_2d_span(coordinates), + Numpy_span(degrees), + get_box_from_tensor(box), + delta, + p, + normalize, + n_jobs); + } + return _wrap_as_numpy_array(std::move(out), degrees.shape(0), coordinates.shape(0)); + } + + // for some reasons nanobind cannot deduce an "auto" return type for "compute_distance_to" and + // "compute_interleavings", even though it has no problems with the other methods ("compute_pixels" etc.) + // I don't know where this is coming from... + nanobind::ndarray compute_distance_to(const std::vector> &pts, + bool signed_distance, + int n_jobs) { + std::vector out; + { + nanobind::gil_scoped_release release; + out = Gudhi::multi_persistence::compute_module_distances_to(module_, pts, signed_distance, n_jobs); + } + return _wrap_as_numpy_array(std::move(out), pts.size(), module_.size()); + } + + nanobind::ndarray compute_distance_to(Tensor2D pts, bool signed_distance, int n_jobs) { + std::vector out; + { + nanobind::gil_scoped_release release; + out = Gudhi::multi_persistence::compute_module_distances_to(module_, Numpy_2d_span(pts), signed_distance, n_jobs); + } + return _wrap_as_numpy_array(std::move(out), pts.shape(0), module_.size()); + } + + nanobind::ndarray compute_interleavings() { + std::vector interleavings; + { + nanobind::gil_scoped_release release; + interleavings = Gudhi::multi_persistence::compute_module_interleavings(module_, box_); + } + return _wrap_as_numpy_array(std::move(interleavings), interleavings.size()); + } + + nanobind::ndarray compute_interleavings(Tensor2D box) { + std::vector interleavings; + { + nanobind::gil_scoped_release release; + interleavings = Gudhi::multi_persistence::compute_module_interleavings(module_, get_box_from_tensor(box)); + } + return _wrap_as_numpy_array(std::move(interleavings), interleavings.size()); + } + + friend bool operator==(const Module_interface &a, const Module_interface &b) { + bool res; + { + // comparing two modules should be expensive enough that it is worth releasing the GIL? + nanobind::gil_scoped_release release; + res = (a.module_ == b.module_ && a.box_ == b.box_); + } + return res; + } + + friend char *serialize_value_to_char_buffer(const Module_interface &value, char *start) { + char *curr = start; + curr = serialize_value_to_char_buffer(value.box_, curr); + curr = serialize_value_to_char_buffer(value.module_, curr); + return curr; + } + + friend const char *deserialize_value_from_char_buffer(Module_interface &value, const char *start) { + const char *curr = start; + curr = deserialize_value_from_char_buffer(value.box_, curr); + curr = deserialize_value_from_char_buffer(value.module_, curr); + return curr; + } + + friend std::size_t get_serialization_size_of(const Module_interface &value) { + return get_serialization_size_of(value.box_) + get_serialization_size_of(value.module_); + } + + friend void swap(Module_interface &mod1, Module_interface &mod2) noexcept { + swap(mod1.box_, mod2.box_); + swap(mod1.module_, mod2.module_); + } + + private: + Module module_; + Box box_; + + template + static constexpr Y get_null_value() { + return Module::Summand_t::template get_null_value(); + } + + static Box get_box_from_tensor(Tensor2D box) { + Numpy_2d_span boxView(box); + auto lowerView = boxView[0]; + auto upperView = boxView[1]; + return {lowerView.begin(), lowerView.end(), upperView.begin(), upperView.end()}; + } +}; + +template +Module_interface deserialize_from_python( + const nanobind::ndarray, nanobind::numpy> &state) { + Module_interface mod; + { + nanobind::gil_scoped_release release; + deserialize_value_from_char_buffer(mod, state.data()); + } + return mod; +} + +} // namespace multi_persistence +} // namespace Gudhi + +#endif // MP_PY_MODULE_H_INCLUDED diff --git a/multipers/multiparameter_module_approximation.py b/multipers/multiparameter_module_approximation.py index c5ab72a2..5d0872d6 100644 --- a/multipers/multiparameter_module_approximation.py +++ b/multipers/multiparameter_module_approximation.py @@ -98,10 +98,14 @@ def _module_representation( coordinates = mpg.todense(grid) if kernel == "linear": - concatenated_images = np.asarray( - self._compute_pixels( - coordinates, degrees, box, bandwidth, p, normalize, n_jobs - ) + concatenated_images = self._compute_pixels( + np.asarray(coordinates, dtype=self.dtype), + np.asarray(degrees), + np.asarray(box, dtype=self.dtype), + bandwidth, + p, + normalize, + n_jobs, ) else: if kernel == "linear2": @@ -196,8 +200,8 @@ def _module_landscapes( out = np.asarray( self._compute_landscapes_grid( int(degree), - ks.tolist(), - [np.asarray(g, dtype=self.dtype).tolist() for g in grid], + ks, + [np.asarray(g, dtype=self.dtype) for g in grid], int(n_jobs), ) ) @@ -667,7 +671,7 @@ def module_approximation( mod = constructor().set_box(box) for i, m in enumerate(modules): mod.merge( - m.get_module_of_degree(input[i].minpres_degree), input[i].minpres_degree + m, input[i].minpres_degree ) return mod diff --git a/multipers/multiparameter_module_approximation/approximation.h b/multipers/multiparameter_module_approximation/approximation.h index a57c5a41..fe7a91ca 100644 --- a/multipers/multiparameter_module_approximation/approximation.h +++ b/multipers/multiparameter_module_approximation/approximation.h @@ -65,10 +65,10 @@ inline void threshold_filters_list(std::vector &filtersList, co template inline void add_barcode_to_module(Module &module, + const Box& box, const Line &line, const std::vector>> &barcode, bool thresholdToBox) { - const auto& box = module.get_box(); #ifdef GUDHI_USE_TBB std::vector shifts(barcode.size(), 0U); for (std::size_t i = 1U; i < barcode.size(); i++) { @@ -128,6 +128,7 @@ class LineIterator { template inline void __add_vineyard_trajectory_to_module(Module &module, + const Box& box, Slicer &&slicer, LineIterator &line_iterator, const bool threshold, @@ -145,12 +146,13 @@ inline void __add_vineyard_trajectory_to_module(Module(), threshold); + add_barcode_to_module(module, box, new_line, slicer.template get_flat_barcode(), threshold); }; }; template > void _rec_mma(Module &module, + const Box& box, typename Line::Point_t &basepoint, const std::vector &grid_size, int dim_to_iterate, @@ -160,7 +162,7 @@ void _rec_mma(Module &module, if (dim_to_iterate <= 0) { LineIterator line_iterator(std::move(basepoint), precision, grid_size[0]); __add_vineyard_trajectory_to_module( - module, std::move(current_persistence), line_iterator, threshold); + module, box, std::move(current_persistence), line_iterator, threshold); return; } Slicer pers_copy; @@ -170,7 +172,7 @@ void _rec_mma(Module &module, // module pers_copy = current_persistence; basepoint_copy = basepoint; - _rec_mma(module, basepoint_copy, grid_size, dim_to_iterate - 1, pers_copy, precision, threshold); + _rec_mma(module, box, basepoint_copy, grid_size, dim_to_iterate - 1, pers_copy, precision, threshold); basepoint[dim_to_iterate] += precision; // current_persistence.push_to(Line(basepoint)); // current_persistence.update_persistence_computation(); @@ -179,6 +181,7 @@ void _rec_mma(Module &module, template void _rec_mma2(Module &module, + const Box& box, typename Line::Point_t &&basepoint, const Filtration_value &direction, const std::vector &grid_size, @@ -194,12 +197,12 @@ void _rec_mma2(Module &module, LineIterator line_iterator( std::move(basepoint), direction, precision, grid_size[axis]); __add_vineyard_trajectory_to_module( - module, std::move(current_persistence), line_iterator, threshold); + module, box, std::move(current_persistence), line_iterator, threshold); } else { LineIterator line_iterator( std::move(basepoint), direction, precision, grid_size[axis]); __add_vineyard_trajectory_to_module( - module, std::move(current_persistence), line_iterator, threshold); + module, box, std::move(current_persistence), line_iterator, threshold); } return; @@ -207,6 +210,7 @@ void _rec_mma2(Module &module, if (grid_size[dim_to_iterate] == 0) { // no need to copy basepoint, we just skip the dim here _rec_mma2(module, + box, std::move(basepoint), direction, grid_size, @@ -223,6 +227,7 @@ void _rec_mma2(Module &module, const bool is_last = i + 1 == grid_size[dim_to_iterate]; if (is_last) { _rec_mma2(module, + box, std::move(basepoint), direction, grid_size, @@ -234,6 +239,7 @@ void _rec_mma2(Module &module, } else { _rec_mma2( module, + box, typename Line::Point_t(basepoint), direction, grid_size, @@ -266,7 +272,7 @@ Module multiparameter_module_approximation(Slicer &slicer, oneapi::tbb::task_arena arena(n_jobs); return arena.execute([&] { typename Box::Point_t basepoint = box.get_lower_corner(); - const std::size_t num_parameters = box.get_dimension(); + const std::size_t num_parameters = box.get_number_of_coordinates(); std::vector grid_size(num_parameters); std::vector signs(num_parameters); int signs_shifts = 0; @@ -299,8 +305,8 @@ Module multiparameter_module_approximation(Slicer &slicer, if (verbose) std::cout << "Had to flatten/shift coordinate " << arg_max_signs_shifts << " by " << signs_shifts << std::endl; } - Module out(box); - box.inflate(2 * precision); // for infinte summands + Module out; + // box.inflate(2 * precision); // for infinte summands if (verbose) std::cout << "Num parameters : " << num_parameters << std::endl; if (verbose) std::cout << "Box : " << box << std::endl; @@ -331,7 +337,7 @@ Module multiparameter_module_approximation(Slicer &slicer, ++i; } } - add_barcode_to_module(out, current_line, barcode, threshold); + add_barcode_to_module(out, box, current_line, barcode, threshold); if (verbose) std::cout << "Instantiated " << num_bars << " summands" << std::endl; } @@ -384,6 +390,7 @@ Module multiparameter_module_approximation(Slicer &slicer, } // if (!direction.size() || direction[0] > 0) _rec_mma2<0>(out, + box, typename Line::Point_t(basepoint), direction, temp_grid_size, @@ -402,6 +409,7 @@ Module multiparameter_module_approximation(Slicer &slicer, std::cout << std::endl; } _rec_mma2<1>(out, + box, std::move(basepoint), direction, grid_size, diff --git a/multipers/nanobind_mma_registry_helpers.hpp b/multipers/nanobind_mma_registry_helpers.hpp index 806458b5..b22934d0 100644 --- a/multipers/nanobind_mma_registry_helpers.hpp +++ b/multipers/nanobind_mma_registry_helpers.hpp @@ -7,7 +7,8 @@ #include #include -#include "gudhi/Multi_persistence/Module.h" +// #include "gudhi/Multi_persistence/Module.h" +#include "gudhi/Module_interface.h" #include "nanobind_object_utils.hpp" namespace multipers::nanobind_mma_helpers { @@ -67,21 +68,21 @@ static_assert(!std::is_void_v, "Expected an MMA descr static_assert(mma_desc_for_double_impl::matches == 1, "Expected exactly one MMA descriptor with double value type."); -template -decltype(auto) visit_mma_module_wrapper(const nanobind::handle& input, Func&& func) { - return dispatch_mma_by_template_id(template_id_of(input), [&]() -> decltype(auto) { - auto& wrapper = nanobind::cast&>(input); - return std::forward(func).template operator()(wrapper); - }); -} - -template -decltype(auto) visit_const_mma_module_wrapper(const nanobind::handle& input, Func&& func) { - return dispatch_mma_by_template_id(template_id_of(input), [&]() -> decltype(auto) { - const auto& wrapper = nanobind::cast&>(input); - return std::forward(func).template operator()(wrapper); - }); -} +// template +// decltype(auto) visit_mma_module_wrapper(const nanobind::handle& input, Func&& func) { +// return dispatch_mma_by_template_id(template_id_of(input), [&]() -> decltype(auto) { +// auto& wrapper = nanobind::cast&>(input); +// return std::forward(func).template operator()(wrapper); +// }); +// } + +// template +// decltype(auto) visit_const_mma_module_wrapper(const nanobind::handle& input, Func&& func) { +// return dispatch_mma_by_template_id(template_id_of(input), [&]() -> decltype(auto) { +// const auto& wrapper = nanobind::cast&>(input); +// return std::forward(func).template operator()(wrapper); +// }); +// } inline bool is_mma_module_object(const nanobind::handle& input) { std::optional template_id = maybe_template_id_of(input); @@ -89,7 +90,7 @@ inline bool is_mma_module_object(const nanobind::handle& input) { return false; } return dispatch_mma_by_template_id(*template_id, [&]() -> bool { - return nanobind::isinstance>(input); + return nanobind::isinstance>(input); }); } From 38a1f9c04008946ea0a7b29be20998fd61aca53b Mon Sep 17 00:00:00 2001 From: hschreiber Date: Wed, 17 Jun 2026 15:39:34 +0200 Subject: [PATCH 03/10] module helpers --- ext/gudhi-devel | 2 +- multipers/_mma_nanobind.cpp | 3 +-- multipers/gudhi/Module_interface.h | 21 ++++++++++----------- 3 files changed, 12 insertions(+), 14 deletions(-) diff --git a/ext/gudhi-devel b/ext/gudhi-devel index f0674afe..4ae8c4e3 160000 --- a/ext/gudhi-devel +++ b/ext/gudhi-devel @@ -1 +1 @@ -Subproject commit f0674afe888511714ec7ffe92fbfa48c3e1af1ad +Subproject commit 4ae8c4e3feb9439d633eb631c343679a6ae8bd54 diff --git a/multipers/_mma_nanobind.cpp b/multipers/_mma_nanobind.cpp index b535af68..d32c272a 100644 --- a/multipers/_mma_nanobind.cpp +++ b/multipers/_mma_nanobind.cpp @@ -245,6 +245,7 @@ void bind_module_class(nb::module_& m) { nb::class_(m, Desc::module_name.data()) .def(nb::init<>()) .def(nb::init()) + .def_prop_ro("dtype", [](const Module&) -> nb::object { return numpy_dtype_type(Desc::dtype_name); }) .def_prop_ro("_template_id", [](const Module&) -> int { return Desc::template_id; }) .def(nb::self == nb::self) .def("__len__", [](Module& self) -> int { return self.size(); }) @@ -313,8 +314,6 @@ void bind_module_class(nb::module_& m) { bind_float_module_methods(module_cls); - module_cls.def_prop_ro("dtype", [](const Module&) -> nb::object { return numpy_dtype_type(Desc::dtype_name); }); - std::string range_name = std::string("_SummandByDimensionRange_") + std::string(Desc::short_name); std::string range_it_name = std::string("_SummandByDimensionIt_") + std::string(Desc::short_name); diff --git a/multipers/gudhi/Module_interface.h b/multipers/gudhi/Module_interface.h index f1d87396..3a15aa02 100644 --- a/multipers/gudhi/Module_interface.h +++ b/multipers/gudhi/Module_interface.h @@ -89,7 +89,6 @@ class Module_interface { const_iterator end() const { return module_.end(); } - // TODO: nanobind binding for multipers Summand_of_dimension_range get_summands_of_dimension_range(int degree) const { // alternative would be to just warn + return empty range instead of throw if (degree < 0) throw std::invalid_argument("Cannot iterate over summands of negative dimension."); @@ -238,7 +237,7 @@ class Module_interface { } nanobind::list get_barcode_from_line(Tensor1D basepoint, std::optional direction, int degree) const { - std::vector>> barcode; + std::vector>> barcode; nanobind::list out; { nanobind::gil_scoped_release release; @@ -365,7 +364,7 @@ class Module_interface { int n_jobs) { if (degree < 0) throw std::invalid_argument("Landscape dimension has to be positive."); - std::vector out; + std::vector > out; Numpy_span resolutionView(resolution); { nanobind::gil_scoped_release release; @@ -382,7 +381,7 @@ class Module_interface { int n_jobs) { if (degree < 0) throw std::invalid_argument("Landscape dimension has to be positive."); - std::vector out; + std::vector > out; { nanobind::gil_scoped_release release; out = Gudhi::multi_persistence::compute_set_of_module_landscapes( @@ -395,11 +394,11 @@ class Module_interface { auto compute_pixels(Tensor2D coordinates, IntTensor1D degrees, Tensor2D box, - T delta, - T p, + double delta, + double p, bool normalize, int n_jobs) { - std::vector out; + std::vector out; { nanobind::gil_scoped_release release; out = Gudhi::multi_persistence::compute_module_pixels(module_, @@ -420,7 +419,7 @@ class Module_interface { nanobind::ndarray compute_distance_to(const std::vector> &pts, bool signed_distance, int n_jobs) { - std::vector out; + std::vector > out; { nanobind::gil_scoped_release release; out = Gudhi::multi_persistence::compute_module_distances_to(module_, pts, signed_distance, n_jobs); @@ -429,7 +428,7 @@ class Module_interface { } nanobind::ndarray compute_distance_to(Tensor2D pts, bool signed_distance, int n_jobs) { - std::vector out; + std::vector > out; { nanobind::gil_scoped_release release; out = Gudhi::multi_persistence::compute_module_distances_to(module_, Numpy_2d_span(pts), signed_distance, n_jobs); @@ -438,7 +437,7 @@ class Module_interface { } nanobind::ndarray compute_interleavings() { - std::vector interleavings; + std::vector > interleavings; { nanobind::gil_scoped_release release; interleavings = Gudhi::multi_persistence::compute_module_interleavings(module_, box_); @@ -447,7 +446,7 @@ class Module_interface { } nanobind::ndarray compute_interleavings(Tensor2D box) { - std::vector interleavings; + std::vector > interleavings; { nanobind::gil_scoped_release release; interleavings = Gudhi::multi_persistence::compute_module_interleavings(module_, get_box_from_tensor(box)); From 82ddff87d618bb0d8ccad2fa2686067d7b4cae50 Mon Sep 17 00:00:00 2001 From: hschreiber Date: Wed, 17 Jun 2026 18:48:30 +0200 Subject: [PATCH 04/10] add bars on batch of lines for module --- multipers/_mma_nanobind.cpp | 6 ++ multipers/gudhi/Module_interface.h | 103 +++++++++++++++++++++++++++++ 2 files changed, 109 insertions(+) diff --git a/multipers/_mma_nanobind.cpp b/multipers/_mma_nanobind.cpp index e34433e6..5b07eb39 100644 --- a/multipers/_mma_nanobind.cpp +++ b/multipers/_mma_nanobind.cpp @@ -72,6 +72,12 @@ void bind_float_module_methods(Class& cls) { "basepoint"_a, "direction"_a = nb::none(), "degree"_a = -1) + .def("_get_barcodes_from_lines", + &Module::get_barcode_from_lines, + "basepoints"_a, + "directions"_a = nb::none(), + "degree"_a = -1, + "keep_inf"_a = true) // .def("evaluate_in_grid", nb::overload_cast>&>(&Module::evaluate_in_grid)) .def("evaluate_in_grid", nb::overload_cast&>(&Module::evaluate_in_grid)) .def("evaluate_in_grid", nb::overload_cast(&Module::evaluate_in_grid)) diff --git a/multipers/gudhi/Module_interface.h b/multipers/gudhi/Module_interface.h index 3a15aa02..e5c234bf 100644 --- a/multipers/gudhi/Module_interface.h +++ b/multipers/gudhi/Module_interface.h @@ -21,6 +21,7 @@ #include #include #include +#include #include #include @@ -258,6 +259,38 @@ class Module_interface { return out; } + nanobind::list get_barcode_from_lines(Tensor2D basepoints, + std::optional directions, + int degree, + bool keep_inf) const { + std::vector>> barcode; + std::size_t numberOfLines; + { + nanobind::gil_scoped_release release; + Dimension dim = degree < 0 ? get_null_value() : static_cast(degree); + Numpy_2d_span basesView(basepoints); + numberOfLines = basesView.size(); + std::vector> lines(numberOfLines); + if (directions.has_value()) { + Numpy_2d_span dirsView(*directions); + if (numberOfLines != dirsView.size()) + throw std::invalid_argument("If directions are specified, there need to be as many as base points."); + for (std::size_t i = 0; i < lines.size(); ++i) { + auto baseView = basesView[i]; + auto dirView = dirsView[i]; + lines[i] = Line(baseView.begin(), baseView.end(), dirView.begin(), dirView.end()); + } + } else { + for (std::size_t i = 0; i < lines.size(); ++i) { + auto baseView = basesView[i]; + lines[i] = Line(baseView.begin(), baseView.end()); + } + } + barcode = module_.get_barcode_from_range_of_lines(lines, dim); + } + return get_numpy_barcode_from_lines(barcode, numberOfLines, keep_inf); + } + Module_interface &rescale(const std::vector &rescaleFactors, int degree) { { nanobind::gil_scoped_release release; @@ -502,6 +535,76 @@ class Module_interface { auto upperView = boxView[1]; return {lowerView.begin(), lowerView.end(), upperView.begin(), upperView.end()}; } + + static nanobind::list get_numpy_barcode_from_lines_with_inf(std::vector>> &barcode, + std::size_t numberOfLines) { + nanobind::list out; + std::vector splits; + + if (numberOfLines == 0) { + for (auto &d : barcode) { + if (d.size() != 0) throw std::logic_error("No lines but the barcode is not empty... ?"); + out.append(nanobind::make_tuple(_wrap_as_numpy_array(std::move(d), 0, 0, 2), + _wrap_as_numpy_array(std::move(splits), 0))); + } + return out; + ; + } + + for (auto &d : barcode) { + if (d.size() % numberOfLines != 0) + throw std::logic_error("Barcodes do not have consistent sizes from a line to another."); + std::size_t numberOfBars = d.size() / numberOfLines; + out.append(nanobind::make_tuple(_wrap_as_numpy_array(std::move(d), numberOfLines, numberOfBars, 2), + _wrap_as_numpy_array(std::move(splits), 0))); + } + return out; + } + + static nanobind::list get_numpy_barcode_from_lines_without_inf( + std::vector>> &barcode, + std::size_t numberOfLines) { + nanobind::list out; + + if (numberOfLines == 0) { + for (auto &d : barcode) { + if (d.size() != 0) throw std::logic_error("No lines but the barcode is not empty... ?"); + std::vector splits; + out.append( + nanobind::make_tuple(_wrap_as_numpy_array(std::move(d), 0, 2), _wrap_as_numpy_array(std::move(splits), 0))); + } + return out; + } + + for (auto &d : barcode) { + if (d.size() % numberOfLines != 0) + throw std::logic_error("Barcodes do not have consistent sizes from a line to another."); + std::vector splits(numberOfLines - 1); + std::size_t barCount = 0; + std::size_t numberOfBars = d.size() / numberOfLines; + std::vector> bars; + for (std::size_t l = 0; l < numberOfLines; ++l) { + for (std::size_t i = 0; i < numberOfBars; ++i) { + auto &b = d[i + (l * numberOfBars)]; + if (b[0] != Module::T_inf) { + bars.push_back(b); + ++barCount; + } + } + if (l + 1 < numberOfLines) splits[l] = barCount; + } + out.append(nanobind::make_tuple(_wrap_as_numpy_array(std::move(bars), barCount, 2), + _wrap_as_numpy_array(std::move(splits), numberOfLines - 1))); + } + return out; + } + + static nanobind::list get_numpy_barcode_from_lines(std::vector>> &barcode, + std::size_t numberOfLines, + bool keepInf) { + if (keepInf) return get_numpy_barcode_from_lines_with_inf(barcode, numberOfLines); + return get_numpy_barcode_from_lines_without_inf(barcode, numberOfLines); + } }; template From 8067c3e72d159f212ba6721ecc61cdde1890a43a Mon Sep 17 00:00:00 2001 From: hschreiber Date: Thu, 18 Jun 2026 14:30:30 +0200 Subject: [PATCH 05/10] add box property to python Module --- ext/gudhi-devel | 2 +- multipers/_mma_nanobind.cpp | 42 ++++++++++-- multipers/_slicer_nanobind.cpp | 2 +- multipers/gudhi/Module_interface.h | 103 ++++++++++++++++++++++------- 4 files changed, 118 insertions(+), 31 deletions(-) diff --git a/ext/gudhi-devel b/ext/gudhi-devel index 4ae8c4e3..64bbb444 160000 --- a/ext/gudhi-devel +++ b/ext/gudhi-devel @@ -1 +1 @@ -Subproject commit 4ae8c4e3feb9439d633eb631c343679a6ae8bd54 +Subproject commit 64bbb444e2bfd6838aedb1a3061b779a1b21fe58 diff --git a/multipers/_mma_nanobind.cpp b/multipers/_mma_nanobind.cpp index 5b07eb39..3f27881f 100644 --- a/multipers/_mma_nanobind.cpp +++ b/multipers/_mma_nanobind.cpp @@ -279,12 +279,46 @@ void bind_module_class(nb::module_& m) { .def("summands_of_dimension_range", &Module::get_summands_of_dimension_range) .def_prop_ro("max_degree", &Module::get_max_dimension) .def_prop_ro("num_parameters", &Module::get_number_of_parameters) - .def("set_box", nb::overload_cast(&Module::set_box)) - .def("set_box", nb::overload_cast(&Module::set_box)) - .def("set_box", nb::overload_cast>&>(&Module::set_box)) + .def_prop_rw("box", + &Module::get_box_view, + [](Module& self, nb::object box) { + if (nb::ndarray_check(box.ptr())) { + self.set_box(nb::cast(box)); + return; + } + if (nb::isinstance(box)) { + self.set_box(nb::cast(box)); + return; + } + try { + self.set_box(nb::cast>>(box)); + return; + } catch (const nb::cast_error&) { + throw nb::type_error("Box has to be set with a 2D array, nested sequence or a PyBox."); + } + }) + .def("set_box", + [](Module& self, const Box& box) { + PyErr_WarnEx(PyExc_DeprecationWarning, "set_box() is deprecated, use the .box property instead", 1); + return self.set_box(box); + }) + .def("set_box", + [](Module& self, NDArray2 box) { + PyErr_WarnEx(PyExc_DeprecationWarning, "set_box() is deprecated, use the .box property instead", 1); + return self.set_box(box); + }) + .def("set_box", + [](Module& self, const std::vector>& box) { + PyErr_WarnEx(PyExc_DeprecationWarning, "set_box() is deprecated, use the .box property instead", 1); + return self.set_box(box); + }) .def("get_bottom", &Module::get_box_lower_corner_view) .def("get_top", &Module::get_box_upper_corner_view) - .def("get_box", &Module::get_flat_box) + .def("get_box", + [](const Module& self) { + PyErr_WarnEx(PyExc_DeprecationWarning, "get_box() is deprecated, use the .box property instead", 1); + return self.get_box_view(); + }) .def("get_bounds", &Module::compute_bounds) .def("get_filtration_values", &Module::get_flat_filtration_values, "unique"_a = true) .def("get_dimensions", &Module::get_all_dimension) diff --git a/multipers/_slicer_nanobind.cpp b/multipers/_slicer_nanobind.cpp index ca00cbc0..16a05cc4 100644 --- a/multipers/_slicer_nanobind.cpp +++ b/multipers/_slicer_nanobind.cpp @@ -2131,7 +2131,7 @@ Gudhi::multi_persistence::Module_interface module_approximation_from_des mod = Gudhi::multiparameter::mma::multiparameter_module_approximation( wrapper.truc, direction, max_error, box, threshold, complete, verbose, n_jobs); } - return {std::move(mod), std::move(box)}; + return {std::move(mod), box}; } } diff --git a/multipers/gudhi/Module_interface.h b/multipers/gudhi/Module_interface.h index e5c234bf..3898d9a3 100644 --- a/multipers/gudhi/Module_interface.h +++ b/multipers/gudhi/Module_interface.h @@ -60,21 +60,27 @@ class Module_interface { using Tensor2D = nanobind::ndarray, nanobind::any_contig>; template using IntTensor1D = nanobind::ndarray, nanobind::any_contig>; + using Box_t = std::vector; static constexpr T T_inf = Summand_t::T_inf; /**< Infinity. */ static constexpr T T_m_inf = Summand_t::T_m_inf; /**< Minus infinity. */ Module_interface() = default; - Module_interface(const Box &box) : module_(), box_(box) {} + Module_interface(const Box &box) : module_(), box_(get_flat_box(box)) {} - Module_interface(Box &&box) : module_(), box_(std::move(box)) {} + Module_interface(const Box_t &box) : module_(), box_(box) {} - Module_interface(Module&& mod, Box &&box) : module_(std::move(mod)), box_(std::move(box)) {} + Module_interface(Tensor2D box) : module_(), box_(get_flat_box_from_tensor(box)) {} + + Module_interface(Module&& mod, Box_t &&box) : module_(std::move(mod)), box_(std::move(box)) {} + + Module_interface(Module &&mod, const Box &box) + : module_(std::move(mod)), box_(get_flat_box(box)) {} [[nodiscard]] int get_number_of_parameters() const { int numParam = module_.get_number_of_parameters(); - if (numParam == get_null_value() && !box_.is_trivial()) return box_.get_number_of_coordinates(); + if (numParam == get_null_value() && !is_trivial_box(box_)) return box_.size() / 2; return numParam; } @@ -99,41 +105,37 @@ class Module_interface { auto get_box_lower_corner_view() const { // no transfer of ownership, dies together with the box - return nanobind::ndarray(box_.get_lower_corner().data(), - {box_.get_number_of_coordinates()}); + return nanobind::ndarray(box_.data(), {box_.size() / 2}); } auto get_box_upper_corner_view() const { + auto shift = box_.size() / 2; // no transfer of ownership, dies together with the box - return nanobind::ndarray(box_.get_upper_corner().data(), - {box_.get_number_of_coordinates()}); + return nanobind::ndarray(box_.data() + shift, {shift}); } - auto get_flat_box() const { - std::vector fb(box_.get_lower_corner().retrieve_underlying_container()); - { - nanobind::gil_scoped_release release; - fb.reserve(fb.size() * 2); - fb.insert(fb.end(), box_.get_upper_corner().begin(), box_.get_upper_corner().end()); - } - return _wrap_as_numpy_array(std::move(fb), 2, box_.get_number_of_coordinates()); + auto get_box_view() const { + // no transfer of ownership, dies together with the box + return nanobind::ndarray(box_.data(), {2, box_.size() / 2}); } Module_interface &set_box(const Box &box) { - box_ = box; + box_ = get_flat_box(box); return *this; } Module_interface &set_box(Tensor2D box) { - box_ = get_box_from_tensor(box); + box_ = get_flat_box_from_tensor(box); return *this; } - Module_interface &set_box(const std::vector> &box) { + Module_interface &set_box(const std::vector> &box) { if (box.size() != 2) throw std::invalid_argument("Box has to be represented by two corners."); if (box[0].size() != box[1].size()) throw std::invalid_argument("Both corners defining the box must have same dimension."); - box_ = Box(box[0], box[1]); + box_ = Box_t(box[0].begin(), box[0].end()); + box_.reserve(box_.size() * 2); + box_.insert(box_.end(), box[1].begin(), box[1].end()); return *this; } @@ -473,7 +475,7 @@ class Module_interface { std::vector > interleavings; { nanobind::gil_scoped_release release; - interleavings = Gudhi::multi_persistence::compute_module_interleavings(module_, box_); + interleavings = Gudhi::multi_persistence::compute_module_interleavings(module_, get_box_from_tensor(box_)); } return _wrap_as_numpy_array(std::move(interleavings), interleavings.size()); } @@ -499,20 +501,33 @@ class Module_interface { friend char *serialize_value_to_char_buffer(const Module_interface &value, char *start) { char *curr = start; - curr = serialize_value_to_char_buffer(value.box_, curr); + const std::size_t length = value.box_.size(); + const std::size_t argSize = sizeof(T) * length; + const std::size_t typeSize = sizeof(std::size_t); + memcpy(curr, &length, typeSize); + curr += typeSize; + memcpy(curr, value.box_.data(), argSize); + curr += argSize; curr = serialize_value_to_char_buffer(value.module_, curr); return curr; } friend const char *deserialize_value_from_char_buffer(Module_interface &value, const char *start) { const char *curr = start; - curr = deserialize_value_from_char_buffer(value.box_, curr); + const std::size_t typeSize = sizeof(std::size_t); + std::size_t length; + memcpy(&length, curr, typeSize); + curr += typeSize; + std::size_t argSize = sizeof(T) * length; + value.box_.resize(length); + memcpy(value.box_.data(), curr, argSize); + curr += argSize; curr = deserialize_value_from_char_buffer(value.module_, curr); return curr; } friend std::size_t get_serialization_size_of(const Module_interface &value) { - return get_serialization_size_of(value.box_) + get_serialization_size_of(value.module_); + return sizeof(std::size_t) + (sizeof(T) * value.box_.size()) + get_serialization_size_of(value.module_); } friend void swap(Module_interface &mod1, Module_interface &mod2) noexcept { @@ -522,13 +537,29 @@ class Module_interface { private: Module module_; - Box box_; + Box_t box_; template static constexpr Y get_null_value() { return Module::Summand_t::template get_null_value(); } + static bool is_trivial_box(const Box_t &box) { + if (box.empty()) return true; + std::size_t size = box.size() / 2; + std::size_t bstart = 0; + std::size_t ustart = size; + // not completely true, as they can be more NaN values, but I just assume that if something is NaN, all is NaN. + // the loop is faster this way in the non trivial case. + if (Gudhi::multi_filtration::_is_nan(box[bstart]) || Gudhi::multi_filtration::_is_nan(box[ustart])) return true; + while (bstart < size) { + if (box[bstart] != box[ustart]) return false; + ++bstart; + ++ustart; + } + return true; + } + static Box get_box_from_tensor(Tensor2D box) { Numpy_2d_span boxView(box); auto lowerView = boxView[0]; @@ -536,6 +567,28 @@ class Module_interface { return {lowerView.begin(), lowerView.end(), upperView.begin(), upperView.end()}; } + static Box get_box_from_tensor(const Box_t &box) { + std::size_t size = box.size() / 2; + return {box.data(), box.data() + size, box.data() + size, box.data() + (size * 2)}; + } + + static Box_t get_flat_box_from_tensor(Tensor2D box) { + Numpy_2d_span boxView(box); + auto lowerView = boxView[0]; + auto upperView = boxView[1]; + Box_t fb(lowerView.begin(), lowerView.end()); + fb.reserve(fb.size() * 2); + fb.insert(fb.end(), upperView.begin(), upperView.end()); + return fb; + } + + static Box_t get_flat_box(const Box &box) { + Box_t fb(box.get_lower_corner().retrieve_underlying_container()); + fb.reserve(fb.size() * 2); + fb.insert(fb.end(), box.get_upper_corner().begin(), box.get_upper_corner().end()); + return fb; + } + static nanobind::list get_numpy_barcode_from_lines_with_inf(std::vector>> &barcode, std::size_t numberOfLines) { nanobind::list out; From cb0d73e5815a903d57e846481a5f0ffe0582cc12 Mon Sep 17 00:00:00 2001 From: hschreiber Date: Thu, 18 Jun 2026 14:34:03 +0200 Subject: [PATCH 06/10] add box property to python Module --- multipers/_mma_nanobind.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/multipers/_mma_nanobind.cpp b/multipers/_mma_nanobind.cpp index 3f27881f..fc3d6332 100644 --- a/multipers/_mma_nanobind.cpp +++ b/multipers/_mma_nanobind.cpp @@ -254,6 +254,7 @@ void bind_module_class(nb::module_& m) { nb::class_(m, Desc::module_name.data(), nb::dynamic_attr()) .def(nb::init<>()) .def(nb::init()) + .def(nb::init()) .def_prop_ro("dtype", [](const Module&) -> nb::object { return numpy_dtype_type(Desc::dtype_name); }) .def_prop_ro("_template_id", [](const Module&) -> int { return Desc::template_id; }) .def(nb::self == nb::self) From 76533f4aba0068906bad6251f9efa17ea805eef3 Mon Sep 17 00:00:00 2001 From: hschreiber Date: Thu, 18 Jun 2026 15:11:06 +0200 Subject: [PATCH 07/10] small fix --- multipers/_mma_nanobind.cpp | 16 ++++--------- multipers/gudhi/Module_interface.h | 36 +++++++++++++----------------- 2 files changed, 20 insertions(+), 32 deletions(-) diff --git a/multipers/_mma_nanobind.cpp b/multipers/_mma_nanobind.cpp index fc3d6332..b5e401d6 100644 --- a/multipers/_mma_nanobind.cpp +++ b/multipers/_mma_nanobind.cpp @@ -125,18 +125,10 @@ void bind_float_module_methods(Class& cls) { "p"_a, "normalize"_a = false, "n_jobs"_a = 0) - // .def("distance_to", - // nb::overload_cast>&, bool, int>(&Module::compute_distance_to), - // "pts"_a, - // "signed"_a = false, - // "n_jobs"_a = 0) - .def("distance_to", - nb::overload_cast(&Module::compute_distance_to), - "pts"_a, - "signed"_a = false, - "n_jobs"_a = 0) - .def("get_interleavings", nb::overload_cast<>(&Module::compute_interleavings)) - .def("get_interleavings", nb::overload_cast(&Module::compute_interleavings)); + // .def("distance_to", &Module::compute_distance_to_iterable, "pts"_a, "signed"_a = false, "n_jobs"_a = 0) + .def("distance_to", &Module::compute_distance_to_tensor, "pts"_a, "signed"_a = false, "n_jobs"_a = 0) + .def("get_interleavings", &Module::compute_interleavings) + .def("get_interleavings", &Module::compute_interleavings_from_box); } } diff --git a/multipers/gudhi/Module_interface.h b/multipers/gudhi/Module_interface.h index 3898d9a3..c88942d2 100644 --- a/multipers/gudhi/Module_interface.h +++ b/multipers/gudhi/Module_interface.h @@ -73,7 +73,7 @@ class Module_interface { Module_interface(Tensor2D box) : module_(), box_(get_flat_box_from_tensor(box)) {} - Module_interface(Module&& mod, Box_t &&box) : module_(std::move(mod)), box_(std::move(box)) {} + Module_interface(Module &&mod, Box_t &&box) : module_(std::move(mod)), box_(std::move(box)) {} Module_interface(Module &&mod, const Box &box) : module_(std::move(mod)), box_(get_flat_box(box)) {} @@ -141,7 +141,7 @@ class Module_interface { [[nodiscard]] nanobind::list get_flat_filtration_values(bool unique) const { int numParam = module_.get_number_of_parameters(); - if (numParam == get_null_value()) return {}; // empty module + if (numParam == get_null_value()) return {}; // empty module std::vector> values(numParam); { @@ -262,9 +262,9 @@ class Module_interface { } nanobind::list get_barcode_from_lines(Tensor2D basepoints, - std::optional directions, - int degree, - bool keep_inf) const { + std::optional directions, + int degree, + bool keep_inf) const { std::vector>> barcode; std::size_t numberOfLines; { @@ -399,7 +399,7 @@ class Module_interface { int n_jobs) { if (degree < 0) throw std::invalid_argument("Landscape dimension has to be positive."); - std::vector > out; + std::vector> out; Numpy_span resolutionView(resolution); { nanobind::gil_scoped_release release; @@ -416,7 +416,7 @@ class Module_interface { int n_jobs) { if (degree < 0) throw std::invalid_argument("Landscape dimension has to be positive."); - std::vector > out; + std::vector> out; { nanobind::gil_scoped_release release; out = Gudhi::multi_persistence::compute_set_of_module_landscapes( @@ -448,13 +448,9 @@ class Module_interface { return _wrap_as_numpy_array(std::move(out), degrees.shape(0), coordinates.shape(0)); } - // for some reasons nanobind cannot deduce an "auto" return type for "compute_distance_to" and - // "compute_interleavings", even though it has no problems with the other methods ("compute_pixels" etc.) - // I don't know where this is coming from... - nanobind::ndarray compute_distance_to(const std::vector> &pts, - bool signed_distance, - int n_jobs) { - std::vector > out; + // nb::overload_cast has a bit of a problem with "auto" returns. The easiest was the rename. + auto compute_distance_to_iterable(const std::vector> &pts, bool signed_distance, int n_jobs) { + std::vector> out; { nanobind::gil_scoped_release release; out = Gudhi::multi_persistence::compute_module_distances_to(module_, pts, signed_distance, n_jobs); @@ -462,8 +458,8 @@ class Module_interface { return _wrap_as_numpy_array(std::move(out), pts.size(), module_.size()); } - nanobind::ndarray compute_distance_to(Tensor2D pts, bool signed_distance, int n_jobs) { - std::vector > out; + auto compute_distance_to_tensor(Tensor2D pts, bool signed_distance, int n_jobs) { + std::vector> out; { nanobind::gil_scoped_release release; out = Gudhi::multi_persistence::compute_module_distances_to(module_, Numpy_2d_span(pts), signed_distance, n_jobs); @@ -471,8 +467,8 @@ class Module_interface { return _wrap_as_numpy_array(std::move(out), pts.shape(0), module_.size()); } - nanobind::ndarray compute_interleavings() { - std::vector > interleavings; + auto compute_interleavings() { + std::vector> interleavings; { nanobind::gil_scoped_release release; interleavings = Gudhi::multi_persistence::compute_module_interleavings(module_, get_box_from_tensor(box_)); @@ -480,8 +476,8 @@ class Module_interface { return _wrap_as_numpy_array(std::move(interleavings), interleavings.size()); } - nanobind::ndarray compute_interleavings(Tensor2D box) { - std::vector > interleavings; + auto compute_interleavings_from_box(Tensor2D box) { + std::vector> interleavings; { nanobind::gil_scoped_release release; interleavings = Gudhi::multi_persistence::compute_module_interleavings(module_, get_box_from_tensor(box)); From 481bb3a463f3279d2a1f30b36525be833bd4a498 Mon Sep 17 00:00:00 2001 From: hschreiber Date: Thu, 18 Jun 2026 18:57:55 +0200 Subject: [PATCH 08/10] removing box bindings + cleanup summand bindings --- docs/notebooks/ops/AIDA.ipynb | 267 +++++------------- ext/gudhi-devel | 2 +- multipers/_mma_nanobind.cpp | 214 +++++--------- multipers/gudhi/Module_interface.h | 10 +- multipers/gudhi/summand_interface.h | 67 +++++ multipers/ml/mma.py | 2 +- .../multiparameter_module_approximation.py | 8 +- tests/test_mma.py | 2 - tools/tempita_grid_gen.py | 1 - 9 files changed, 215 insertions(+), 358 deletions(-) create mode 100644 multipers/gudhi/summand_interface.h diff --git a/docs/notebooks/ops/AIDA.ipynb b/docs/notebooks/ops/AIDA.ipynb index 05555f6b..445e3ec7 100644 --- a/docs/notebooks/ops/AIDA.ipynb +++ b/docs/notebooks/ops/AIDA.ipynb @@ -31,17 +31,9 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 1, "id": "484b5175-28c8-4a15-9403-593f90018767", - "metadata": { - "execution": { - "iopub.execute_input": "2026-05-04T16:35:59.837139Z", - "iopub.status.busy": "2026-05-04T16:35:59.836874Z", - "iopub.status.idle": "2026-05-04T16:36:01.255447Z", - "shell.execute_reply": "2026-05-04T16:36:01.255014Z", - "shell.execute_reply.started": "2026-05-04T16:35:59.837114Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", @@ -85,19 +77,21 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 2, "id": "b3d566fb-57e8-41ec-b28d-d7650ce4af71", "metadata": { - "execution": { - "iopub.execute_input": "2026-05-04T16:36:03.127767Z", - "iopub.status.busy": "2026-05-04T16:36:03.127408Z", - "iopub.status.idle": "2026-05-04T16:36:03.527880Z", - "shell.execute_reply": "2026-05-04T16:36:03.526989Z", - "shell.execute_reply.started": "2026-05-04T16:36:03.127749Z" - }, "lines_to_next_cell": 2 }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Check sanity 0\n", + "Check sanity 0\n" + ] + } + ], "source": [ "presentation1 = [[],[],[],[0,1],[0],[1],[2],[2],]\n", "dimension1 = [0,0,0,1,1,1,1,1]\n", @@ -117,21 +111,13 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 3, "id": "9b82c674-ccc2-49f2-8c8e-0bb18d746b0a", - "metadata": { - "execution": { - "iopub.execute_input": "2026-05-04T16:36:04.576637Z", - "iopub.status.busy": "2026-05-04T16:36:04.576383Z", - "iopub.status.idle": "2026-05-04T16:36:05.020233Z", - "shell.execute_reply": "2026-05-04T16:36:05.019878Z", - "shell.execute_reply.started": "2026-05-04T16:36:04.576615Z" - } - }, + "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -159,17 +145,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 4, "id": "bb6e6403-0ca8-41c8-89c9-a71facac2d3f", - "metadata": { - "execution": { - "iopub.execute_input": "2026-05-04T16:36:05.976374Z", - "iopub.status.busy": "2026-05-04T16:36:05.975849Z", - "iopub.status.idle": "2026-05-04T16:36:06.233061Z", - "shell.execute_reply": "2026-05-04T16:36:06.232244Z", - "shell.execute_reply.started": "2026-05-04T16:36:05.976345Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "I1,I2 = mp.ops.aida(s1) # the two rectangles" @@ -177,21 +155,13 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 5, "id": "57014afd-cf77-4e78-9c1d-bb84c4db810f", - "metadata": { - "execution": { - "iopub.execute_input": "2026-05-04T16:36:06.785790Z", - "iopub.status.busy": "2026-05-04T16:36:06.785476Z", - "iopub.status.idle": "2026-05-04T16:36:06.886418Z", - "shell.execute_reply": "2026-05-04T16:36:06.885974Z", - "shell.execute_reply.started": "2026-05-04T16:36:06.785767Z" - } - }, + "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -210,17 +180,9 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 6, "id": "3ebc43ab-386c-4e3f-ad59-4fb9ddb0de10", - "metadata": { - "execution": { - "iopub.execute_input": "2026-05-04T16:38:39.559454Z", - "iopub.status.busy": "2026-05-04T16:38:39.559084Z", - "iopub.status.idle": "2026-05-04T16:38:39.564584Z", - "shell.execute_reply": "2026-05-04T16:38:39.563900Z", - "shell.execute_reply.started": "2026-05-04T16:38:39.559427Z" - } - }, + "metadata": {}, "outputs": [ { "data": { @@ -228,7 +190,7 @@ "True" ] }, - "execution_count": 8, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -277,21 +239,13 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 7, "id": "58438775-95d6-45f0-b926-16db34bd62d4", - "metadata": { - "execution": { - "iopub.execute_input": "2026-05-04T16:38:41.327393Z", - "iopub.status.busy": "2026-05-04T16:38:41.327087Z", - "iopub.status.idle": "2026-05-04T16:38:41.359766Z", - "shell.execute_reply": "2026-05-04T16:38:41.359224Z", - "shell.execute_reply.started": "2026-05-04T16:38:41.327371Z" - } - }, + "metadata": {}, "outputs": [], "source": [ - "def get_immuno(i, DATASET_PATH=\"./\"):\n", - " immu_dataset = read_csv(DATASET_PATH+f\"LargeHypoxicRegion{i}.csv\")\n", + "def get_immuno(i, DATASET_PATH=\"~/Datasets/\"):\n", + " immu_dataset = read_csv(DATASET_PATH+f\"SpatialPatterningOfImmuneCells/LargeHypoxicRegion{i}.csv\")\n", " X = np.array(immu_dataset['x'])\n", " X /= np.max(X)\n", " Y = np.asarray(immu_dataset['y'])\n", @@ -317,17 +271,9 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 8, "id": "c4f251a7-a429-40ed-80df-2bf55b7b9cb2", - "metadata": { - "execution": { - "iopub.execute_input": "2026-05-04T16:38:42.511831Z", - "iopub.status.busy": "2026-05-04T16:38:42.511532Z", - "iopub.status.idle": "2026-05-04T16:38:51.369907Z", - "shell.execute_reply": "2026-05-04T16:38:51.369417Z", - "shell.execute_reply.started": "2026-05-04T16:38:42.511812Z" - } - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -338,13 +284,20 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Check sanity 0\n" + ] } ], "source": [ @@ -380,24 +333,16 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 9, "id": "71567383-e521-4500-ae77-009d8f16aad5", - "metadata": { - "execution": { - "iopub.execute_input": "2026-05-04T16:38:53.800058Z", - "iopub.status.busy": "2026-05-04T16:38:53.799563Z", - "iopub.status.idle": "2026-05-04T16:39:47.403276Z", - "shell.execute_reply": "2026-05-04T16:39:47.402845Z", - "shell.execute_reply.started": "2026-05-04T16:38:53.800035Z" - } - }, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "65778\n", - "32889 batches : [##################################################] 100%\n" + "66558\n", + "33279 batches : [##################################################] 100%\n" ] } ], @@ -416,21 +361,13 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 10, "id": "ec504aa4-e2eb-4875-85c4-cb052b963062", - "metadata": { - "execution": { - "iopub.execute_input": "2026-05-04T16:39:52.048885Z", - "iopub.status.busy": "2026-05-04T16:39:52.048649Z", - "iopub.status.idle": "2026-05-04T16:39:52.169158Z", - "shell.execute_reply": "2026-05-04T16:39:52.168799Z", - "shell.execute_reply.started": "2026-05-04T16:39:52.048866Z" - } - }, + "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -457,23 +394,15 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 11, "id": "7b706763-05df-46df-a1b0-eb9bcda9a0b0", - "metadata": { - "execution": { - "iopub.execute_input": "2026-05-04T16:39:55.425986Z", - "iopub.status.busy": "2026-05-04T16:39:55.425760Z", - "iopub.status.idle": "2026-05-04T16:39:58.893729Z", - "shell.execute_reply": "2026-05-04T16:39:58.893090Z", - "shell.execute_reply.started": "2026-05-04T16:39:55.425968Z" - } - }, + "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "100%|████| 17299/17299 [00:02<00:00, 7390.38it/s]\n" + "100%|███████████████████████████████████████████████████████████████████████████████████████████████| 17602/17602 [00:07<00:00, 2376.69it/s]\n" ] } ], @@ -496,21 +425,13 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 12, "id": "af3892ab-63b8-44b2-81b1-fa4352e06f30", - "metadata": { - "execution": { - "iopub.execute_input": "2026-05-04T16:39:59.939511Z", - "iopub.status.busy": "2026-05-04T16:39:59.939254Z", - "iopub.status.idle": "2026-05-04T16:40:00.586098Z", - "shell.execute_reply": "2026-05-04T16:40:00.585588Z", - "shell.execute_reply.started": "2026-05-04T16:39:59.939492Z" - } - }, + "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -525,31 +446,23 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 13, "id": "4ecf9bd3-e7c4-4634-b0a8-e386a2f14f3b", - "metadata": { - "execution": { - "iopub.execute_input": "2026-05-04T16:40:02.234859Z", - "iopub.status.busy": "2026-05-04T16:40:02.234550Z", - "iopub.status.idle": "2026-05-04T16:40:02.269301Z", - "shell.execute_reply": "2026-05-04T16:40:02.268717Z", - "shell.execute_reply.started": "2026-05-04T16:40:02.234836Z" - } - }, + "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([[0.00404313, 0.00462038],\n", - " [0.00406742, 0.00467709],\n", - " [0.00411516, 0.00499765],\n", + "array([[0.00408662, 0.0046928 ],\n", + " [0.00409012, 0.0046955 ],\n", + " [0.00415106, 0.00469863],\n", " ...,\n", - " [0.01985762, 0.0307687 ],\n", - " [0.02421016, 0.02859915],\n", - " [0.03293984, 0.03948577]], shape=(14871, 2))" + " [0.01765638, 0.03080151],\n", + " [0.02642419, 0.03080151],\n", + " [0.03254546, 0.04179183]], shape=(15202, 2))" ] }, - "execution_count": 15, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -570,17 +483,9 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 14, "id": "f64c6590-b36f-4c92-bc1e-e2a02b328e8c", - "metadata": { - "execution": { - "iopub.execute_input": "2026-05-04T16:40:10.610662Z", - "iopub.status.busy": "2026-05-04T16:40:10.610323Z", - "iopub.status.idle": "2026-05-04T16:40:10.614030Z", - "shell.execute_reply": "2026-05-04T16:40:10.613012Z", - "shell.execute_reply.started": "2026-05-04T16:40:10.610637Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "mp.logs.set_level(0)" @@ -588,23 +493,15 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 19, "id": "3c5d974a-361a-4a17-883b-14c80af61177", - "metadata": { - "execution": { - "iopub.execute_input": "2026-05-04T16:40:11.286850Z", - "iopub.status.busy": "2026-05-04T16:40:11.286441Z", - "iopub.status.idle": "2026-05-04T16:40:13.193890Z", - "shell.execute_reply": "2026-05-04T16:40:13.193348Z", - "shell.execute_reply.started": "2026-05-04T16:40:11.286820Z" - } - }, + "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "100%|███| 17299/17299 [00:01<00:00, 10657.88it/s]\n" + "100%|███████████████████████████████████████████████████████████████████████████████████████████████| 17602/17602 [00:13<00:00, 1320.42it/s]\n" ] } ], @@ -617,24 +514,16 @@ ")(stuff) for stuff in tqdm(out))\n", "mma_ = type(mmas[0])()._add_mmas(mmas)\n", "if len(mma_):\n", - " num_parameters = mma_[0].num_parameters()\n", - " mma_.set_box([[0]*num_parameters,[1]*num_parameters])\n", - " mma_.set_box(mp.grids.compute_bounding_box(mma_))" + " num_parameters = mma_[0].num_parameters\n", + " mma_.box = [[0]*num_parameters,[1]*num_parameters]\n", + " mma_.box = mp.grids.compute_bounding_box(mma_)" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 20, "id": "47577d11-5c6f-4e2d-b378-afec8d40d7b7", - "metadata": { - "execution": { - "iopub.execute_input": "2026-05-04T16:40:15.458386Z", - "iopub.status.busy": "2026-05-04T16:40:15.458031Z", - "iopub.status.idle": "2026-05-04T16:40:15.533078Z", - "shell.execute_reply": "2026-05-04T16:40:15.532548Z", - "shell.execute_reply.started": "2026-05-04T16:40:15.458361Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "# For colors in the plot\n", @@ -646,21 +535,13 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 21, "id": "52cc066d-d44d-4d86-b3b8-c39084793092", - "metadata": { - "execution": { - "iopub.execute_input": "2026-05-04T16:40:19.897182Z", - "iopub.status.busy": "2026-05-04T16:40:19.896960Z", - "iopub.status.idle": "2026-05-04T16:40:21.465404Z", - "shell.execute_reply": "2026-05-04T16:40:21.464989Z", - "shell.execute_reply.started": "2026-05-04T16:40:19.897165Z" - } - }, + "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -698,7 +579,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.13.13" + "version": "3.13.12" } }, "nbformat": 4, diff --git a/ext/gudhi-devel b/ext/gudhi-devel index 64bbb444..cfc2d532 160000 --- a/ext/gudhi-devel +++ b/ext/gudhi-devel @@ -1 +1 @@ -Subproject commit 64bbb444e2bfd6838aedb1a3061b779a1b21fe58 +Subproject commit cfc2d5321db0a6b28de74a2e49a397463ecb1b1b diff --git a/multipers/_mma_nanobind.cpp b/multipers/_mma_nanobind.cpp index b5e401d6..0b18d630 100644 --- a/multipers/_mma_nanobind.cpp +++ b/multipers/_mma_nanobind.cpp @@ -1,24 +1,20 @@ +#include +#include +#include + #include #include #include #include -#include -#include #include -#include -#include -#include -#include -#include -#include - #include +#include #include #include + #include "gudhi/Module_interface.h" -#include "nanobind_array_utils.hpp" -#include "nanobind_dense_array_utils.hpp" +#include "gudhi/summand_interface.h" #include "nanobind_mma_registry_helpers.hpp" #include "nanobind_object_utils.hpp" @@ -27,42 +23,71 @@ using namespace nb::literals; namespace mpmma { -using multipers::nanobind_dense_utils::vector_from_array; using multipers::nanobind_mma_helpers::is_mma_module_object; using multipers::nanobind_mma_helpers::MMADescriptorList; using multipers::nanobind_mma_helpers::type_list; -using multipers::nanobind_utils::matrix_from_handle; using multipers::nanobind_utils::numpy_dtype_type; -using multipers::nanobind_utils::owned_array; -using multipers::nanobind_utils::vector_from_handle; - -template -using BoxArray = nb::ndarray, nb::c_contig>; - -template -nb::ndarray corner_matrix_to_python(std::vector&& flat, size_t rows, size_t cols) { - return owned_array(std::move(flat), {rows, cols}); -} -template -nb::ndarray corner_matrix_to_python(const std::vector& flat, size_t rows, size_t cols) { - return owned_array(std::vector(flat.begin(), flat.end()), {rows, cols}); -} +template +void bind_summand_class(nb::module_& m) { + using T = typename Desc::value_type; + using Summand = Gudhi::multi_persistence::Summand; + using Box = Gudhi::multi_persistence::Box; -template -nb::ndarray corner_pair_to_python(const std::vector& lower, const std::vector& upper) { - std::vector flat; - flat.reserve(lower.size() + upper.size()); - flat.insert(flat.end(), lower.begin(), lower.end()); - flat.insert(flat.end(), upper.begin(), upper.end()); - return owned_array(std::move(flat), {size_t(2), lower.size()}); + nb::class_(m, Desc::summand_name.data()) + .def(nb::init<>()) + .def_prop_ro("_template_id", [](const Summand&) -> int { return Desc::template_id; }) + .def_prop_ro("dtype", [](const Summand&) -> nb::object { return numpy_dtype_type(Desc::dtype_name); }) + .def("__eq__", + [](const Summand& self, const Summand& other) { + bool res; + { + // comparing two summands should be expensive enough that it is worth releasing the GIL? + nanobind::gil_scoped_release release; + res = (self == other); + } + return res; + }) + .def_prop_ro("num_parameters", &Summand::get_number_of_parameters) + .def_prop_ro("degree", &Summand::get_dimension) + .def("get_birth_list", + [](const Summand& self) { return Gudhi::multi_persistence::compute_flat_corners(self.get_upset()); }) + .def("get_death_list", + [](const Summand& self) { return Gudhi::multi_persistence::compute_flat_corners(self.get_downset()); }) + .def("get_bounds", + [](const Summand& self) { + std::vector res; + Box bounds; + { + nanobind::gil_scoped_release release; + bounds = self.compute_bounds(); + res.reserve(bounds.get_number_of_coordinates() * 2); + res.insert(res.end(), bounds.get_lower_corner().begin(), bounds.get_lower_corner().end()); + res.insert(res.end(), bounds.get_upper_corner().begin(), bounds.get_upper_corner().end()); + } + return _wrap_as_numpy_array(std::move(res), 2, bounds.get_number_of_coordinates()); + }) + .def("__getstate__", + [](const Summand& self) -> nb::ndarray { + std::size_t buffer_size; + char* buffer; + { + nb::gil_scoped_release release; + buffer_size = get_serialization_size_of(self); + buffer = new char[buffer_size]; + serialize_value_to_char_buffer(self, buffer); + } + return _wrap_as_numpy_array(buffer, buffer_size); + }) + .def("__setstate__", [](Summand& self, nb::ndarray, nb::numpy> state) { + new (&self) Summand(Gudhi::multi_persistence::deserialize_summand_from_python(state)); + }); } template void bind_float_module_methods(Class& cls) { if constexpr (Desc::is_float) { using T = typename Desc::value_type; - using Box = Gudhi::multi_persistence::Box; using Module = Gudhi::multi_persistence::Module_interface; using NDArray1 = typename Module::Tensor1D; using NDArray2 = typename Module::Tensor2D; @@ -132,120 +157,19 @@ void bind_float_module_methods(Class& cls) { } } -template -void bind_summand_class(nb::module_& m) { - using T = typename Desc::value_type; - using Summand = Gudhi::multi_persistence::Summand; - - nb::class_(m, Desc::summand_name.data()) - .def(nb::init<>()) - .def("get_birth_list", - [](Summand& self) -> nb::ndarray { - std::vector births; - const size_t num_parameters = static_cast(self.get_number_of_parameters()); - const size_t num_birth_corners = static_cast(self.get_number_of_birth_corners()); - { - nb::gil_scoped_release release; - births = self.compute_flat_upset(); - } - return corner_matrix_to_python(std::move(births), num_birth_corners, num_parameters); - }) - .def("get_death_list", - [](Summand& self) -> nb::ndarray { - std::vector deaths; - const size_t num_parameters = static_cast(self.get_number_of_parameters()); - const size_t num_death_corners = static_cast(self.get_number_of_death_corners()); - { - nb::gil_scoped_release release; - deaths = self.compute_flat_downset(); - } - return corner_matrix_to_python(std::move(deaths), num_death_corners, num_parameters); - }) - .def_prop_ro("degree", [](const Summand& self) -> int { return self.get_dimension(); }) - .def("get_bounds", - [](Summand& self) -> nb::ndarray { - std::pair, std::vector> cbounds; - { - nb::gil_scoped_release release; - auto bounds = self.compute_bounds(); - auto cpp_bounds = bounds.get_bounding_corners(); - cbounds.first.assign(cpp_bounds.first.begin(), cpp_bounds.first.end()); - cbounds.second.assign(cpp_bounds.second.begin(), cpp_bounds.second.end()); - } - return corner_pair_to_python(cbounds.first, cbounds.second); - }) - .def("num_parameters", [](Summand& self) -> int { return self.get_number_of_parameters(); }) - .def_prop_ro("_template_id", [](const Summand&) -> int { return Desc::template_id; }) - .def_prop_ro("dtype", [](const Summand&) -> nb::object { return numpy_dtype_type(Desc::dtype_name); }) - .def("__eq__", [](Summand& self, Summand& other) { return self == other; }); -} - -template -void bind_box_class(nb::module_& m) { - using T = typename Desc::value_type; - using Box = Gudhi::multi_persistence::Box; - - nb::class_(m, Desc::box_name.data()) - .def(nb::new_([](nb::handle bottom, nb::handle top) { - auto lower = vector_from_handle(bottom); - auto upper = vector_from_handle(top); - return Box(lower, upper); - }), - "bottomCorner"_a, - "topCorner"_a) - .def(nb::new_([](nb::ndarray, nb::c_contig> bottom, - nb::ndarray, nb::c_contig> top) { - return Box(vector_from_array(bottom), vector_from_array(top)); - }), - "bottomCorner"_a, - "topCorner"_a) - .def_prop_ro("num_parameters", [](const Box& self) -> int { return self.get_lower_corner().size(); }) - .def("contains", - [](Box& self, nb::handle x) { - auto values = vector_from_handle(x); - return self.contains(values); - }) - .def("contains", - [](Box& self, nb::ndarray, nb::c_contig> x) { - return self.contains(vector_from_array(x)); - }) - .def("get", - [](Box& self) -> nb::ndarray { - auto lower = std::vector(self.get_lower_corner().begin(), self.get_lower_corner().end()); - auto upper = std::vector(self.get_upper_corner().begin(), self.get_upper_corner().end()); - return corner_pair_to_python(lower, upper); - }) - .def("to_multipers", - [](Box& self) -> nb::ndarray { - auto lower = std::vector(self.get_lower_corner().begin(), self.get_lower_corner().end()); - auto upper = std::vector(self.get_upper_corner().begin(), self.get_upper_corner().end()); - std::vector flat; - flat.reserve(lower.size() * 2); - for (size_t i = 0; i < lower.size(); ++i) { - flat.push_back(lower[i]); - flat.push_back(upper[i]); - } - return owned_array(std::move(flat), {size_t(2), lower.size()}); - }) - .def_prop_ro("_template_id", [](const Box&) -> int { return Desc::template_id; }) - .def_prop_ro("dtype", [](const Box&) -> nb::object { return numpy_dtype_type(Desc::dtype_name); }); -} - template void bind_module_class(nb::module_& m) { using T = typename Desc::value_type; using Module = Gudhi::multi_persistence::Module_interface; using Summand = typename Module::Summand_t; - using Box = Gudhi::multi_persistence::Box; using NDArray1 = typename Module::Tensor1D; using NDArray2 = typename Module::Tensor2D; std::string iterator_name = std::string("_PyModuleIterator_") + std::string(Desc::short_name); auto module_cls = - nb::class_(m, Desc::module_name.data(), nb::dynamic_attr()) + nb::class_(m, Desc::module_name.data()) .def(nb::init<>()) - .def(nb::init()) .def(nb::init()) .def_prop_ro("dtype", [](const Module&) -> nb::object { return numpy_dtype_type(Desc::dtype_name); }) .def_prop_ro("_template_id", [](const Module&) -> int { return Desc::template_id; }) @@ -279,22 +203,13 @@ void bind_module_class(nb::module_& m) { self.set_box(nb::cast(box)); return; } - if (nb::isinstance(box)) { - self.set_box(nb::cast(box)); - return; - } try { self.set_box(nb::cast>>(box)); return; } catch (const nb::cast_error&) { - throw nb::type_error("Box has to be set with a 2D array, nested sequence or a PyBox."); + throw nb::type_error("Box has to be set with a 2D array or a nested sequence."); } }) - .def("set_box", - [](Module& self, const Box& box) { - PyErr_WarnEx(PyExc_DeprecationWarning, "set_box() is deprecated, use the .box property instead", 1); - return self.set_box(box); - }) .def("set_box", [](Module& self, NDArray2 box) { PyErr_WarnEx(PyExc_DeprecationWarning, "set_box() is deprecated, use the .box property instead", 1); @@ -310,7 +225,7 @@ void bind_module_class(nb::module_& m) { .def("get_box", [](const Module& self) { PyErr_WarnEx(PyExc_DeprecationWarning, "get_box() is deprecated, use the .box property instead", 1); - return self.get_box_view(); + return self.get_box_view_ro(); }) .def("get_bounds", &Module::compute_bounds) .def("get_filtration_values", &Module::get_flat_filtration_values, "unique"_a = true) @@ -345,7 +260,7 @@ void bind_module_class(nb::module_& m) { return _wrap_as_numpy_array(buffer, buffer_size); }) .def("__setstate__", [](Module& self, nb::ndarray, nb::numpy> state) { - new (&self) Module(Gudhi::multi_persistence::deserialize_from_python(state)); + new (&self) Module(Gudhi::multi_persistence::deserialize_module_from_python(state)); }); bind_float_module_methods(module_cls); @@ -370,7 +285,6 @@ void bind_module_class(nb::module_& m) { template void bind_mma_type(nb::module_& m) { bind_summand_class(m); - bind_box_class(m); bind_module_class(m); } diff --git a/multipers/gudhi/Module_interface.h b/multipers/gudhi/Module_interface.h index c88942d2..35cd417d 100644 --- a/multipers/gudhi/Module_interface.h +++ b/multipers/gudhi/Module_interface.h @@ -114,11 +114,16 @@ class Module_interface { return nanobind::ndarray(box_.data() + shift, {shift}); } - auto get_box_view() const { + auto get_box_view_ro() const { // no transfer of ownership, dies together with the box return nanobind::ndarray(box_.data(), {2, box_.size() / 2}); } + auto get_box_view() { + // no transfer of ownership, dies together with the box + return nanobind::ndarray(box_.data(), {2, box_.size() / 2}); + } + Module_interface &set_box(const Box &box) { box_ = get_flat_box(box); return *this; @@ -597,7 +602,6 @@ class Module_interface { _wrap_as_numpy_array(std::move(splits), 0))); } return out; - ; } for (auto &d : barcode) { @@ -657,7 +661,7 @@ class Module_interface { }; template -Module_interface deserialize_from_python( +Module_interface deserialize_module_from_python( const nanobind::ndarray, nanobind::numpy> &state) { Module_interface mod; { diff --git a/multipers/gudhi/summand_interface.h b/multipers/gudhi/summand_interface.h new file mode 100644 index 00000000..74eee71a --- /dev/null +++ b/multipers/gudhi/summand_interface.h @@ -0,0 +1,67 @@ +/* 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): David Loiseaux, Hannah Schreiber + * + * Copyright (C) 2026 Inria + * + * Modification(s): + * - YYYY/MM Author: Description of the modification + */ + +/** + * @file summand_interface.h + * @author David Loiseaux, Hannah Schreiber + * @brief Contains @ref Gudhi::multi_persistence::Summand methods for python bindings. + */ + +#ifndef MP_PY_SUMMAND_H_INCLUDED +#define MP_PY_SUMMAND_H_INCLUDED + +#include +#include + +#include +#include + +#include +#include + +namespace Gudhi { +namespace multi_persistence { + +/** + * @private + */ +template +auto compute_flat_corners(const Corners& corners) { + std::vector res(corners.num_generators() * corners.num_parameters()); + { + nanobind::gil_scoped_release release; + Gudhi::Simple_mdspan view(res.data(), corners.num_generators(), corners.num_parameters()); + for (std::size_t g = 0; g < corners.num_generators(); ++g) { + for (std::size_t p = 0; p < corners.num_parameters(); ++p) { + view(g, p) = corners(g, p); + } + } + } + return _wrap_as_numpy_array(std::move(res), corners.num_generators(), corners.num_parameters()); +} + +/** + * @private + */ +template +Summand deserialize_summand_from_python( + const nanobind::ndarray, nanobind::numpy>& state) { + Summand sum; + { + nanobind::gil_scoped_release release; + deserialize_value_from_char_buffer(sum, state.data()); + } + return sum; +} + +} // namespace multi_persistence +} // namespace Gudhi + +#endif // MP_PY_SUMMAND_H_INCLUDED diff --git a/multipers/ml/mma.py b/multipers/ml/mma.py index 580a251f..5d4da7cd 100644 --- a/multipers/ml/mma.py +++ b/multipers/ml/mma.py @@ -9,7 +9,7 @@ import multipers.simplex_tree_multi import multipers.slicer from multipers.grids import compute_grid -from multipers.mma_structures import PyBox_f64, PyModule_type +from multipers.mma_structures import PyModule_type _FilteredComplexType = Union[ mp.slicer.Slicer_type, mp.simplex_tree_multi.SimplexTreeMulti_type diff --git a/multipers/multiparameter_module_approximation.py b/multipers/multiparameter_module_approximation.py index 64a55c11..e40cf16e 100644 --- a/multipers/multiparameter_module_approximation.py +++ b/multipers/multiparameter_module_approximation.py @@ -21,11 +21,8 @@ available_pysummands = tuple( cls for name, cls in sorted(vars(_mma).items()) if name.startswith("PySummand_") ) -available_pyboxes = tuple( - cls for name, cls in sorted(vars(_mma).items()) if name.startswith("PyBox_") -) -for _cls in (*available_pymodules, *available_pysummands, *available_pyboxes): +for _cls in (*available_pymodules, *available_pysummands): globals()[_cls.__name__] = _cls for _name, _value in vars(_mma).items(): @@ -34,7 +31,6 @@ PyModule_type = reduce(or_, available_pymodules) if available_pymodules else Any PySummand_type = reduce(or_, available_pysummands) if available_pysummands else Any -PyBox_type = reduce(or_, available_pyboxes) if available_pyboxes else Any _MMA_CONSTRUCTORS = {np.dtype(cls().dtype): cls for cls in available_pymodules} @@ -815,12 +811,10 @@ def module_approximation( __all__ = [ *(cls.__name__ for cls in available_pymodules), *(cls.__name__ for cls in available_pysummands), - *(cls.__name__ for cls in available_pyboxes), *(name for name in vars(_mma) if name.startswith("from_dump_")), "available_pymodules", "PyModule_type", "PySummand_type", - "PyBox_type", "is_mma", "module_approximation", "module_approximation_from_slicer", diff --git a/tests/test_mma.py b/tests/test_mma.py index e479c327..23cedf8e 100644 --- a/tests/test_mma.py +++ b/tests/test_mma.py @@ -2,7 +2,6 @@ import pytest import multipers as mp -from multipers._mma_nanobind import PyBox_f64 import multipers.ml.mma as mma from multipers.tests import random_st @@ -17,7 +16,6 @@ def test_1(): assert np.array_equal(mma_pymodule[0].get_death_list(), [[np.inf, np.inf]]) assert np.asarray(mma_pymodule[0].get_bounds()).shape[0] == 2 assert np.asarray(mma_pymodule.get_bounds()).shape[0] == 2 - assert np.array_equal(PyBox_f64([0.0, 1.0], [2.0, 3.0]).get(), [[0.0, 1.0], [2.0, 3.0]]) def test_img(): diff --git a/tools/tempita_grid_gen.py b/tools/tempita_grid_gen.py index 9104249e..f4491f2f 100644 --- a/tools/tempita_grid_gen.py +++ b/tools/tempita_grid_gen.py @@ -452,7 +452,6 @@ def _render_mma_nanobind_registry(value_types: list[tuple[str, str, str]]) -> st f' static constexpr std::string_view short_name = "{short}";', f' static constexpr std::string_view dtype_name = "{dtype_name}";', f' static constexpr std::string_view summand_name = "PySummand_{short}";', - f' static constexpr std::string_view box_name = "PyBox_{short}";', f' static constexpr std::string_view module_name = "PyModule_{short}";', f' static constexpr std::string_view from_dump_name = "from_dump_{short}";', "};", From d50dbc275f968120cd0d981a340e2cc88fb83403 Mon Sep 17 00:00:00 2001 From: hschreiber Date: Fri, 19 Jun 2026 16:05:51 +0200 Subject: [PATCH 09/10] remove unnecessary nanobind::any_contig --- ext/gudhi-devel | 2 +- multipers/_slicer_nanobind.cpp | 4 ++-- multipers/gudhi/Module_interface.h | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/ext/gudhi-devel b/ext/gudhi-devel index cfc2d532..b5c1fd57 160000 --- a/ext/gudhi-devel +++ b/ext/gudhi-devel @@ -1 +1 @@ -Subproject commit cfc2d5321db0a6b28de74a2e49a397463ecb1b1b +Subproject commit b5c1fd578db7d04aa9dd0ba3212ed4c0c2438977 diff --git a/multipers/_slicer_nanobind.cpp b/multipers/_slicer_nanobind.cpp index 16a05cc4..a5adc421 100644 --- a/multipers/_slicer_nanobind.cpp +++ b/multipers/_slicer_nanobind.cpp @@ -308,7 +308,7 @@ nb::tuple dim_barcode_to_tuple(const Barcode& barcode) { template nb::tuple compute_persistence_on_slices(Wrapper& self, - const nb::ndarray, nb::any_contig>& values, + const nb::ndarray >& values, bool ignore_infinite_filtration_values) { using Barcode = decltype(self.truc.template get_flat_barcode()); using Concrete = std::remove_reference_t; @@ -1902,7 +1902,7 @@ void bind_slicer_class(nb::module_& m, nb::list& available_slicers) { .def( "_compute_persistence_on_slices", [](Wrapper& self, - nb::ndarray, nb::any_contig> values, + nb::ndarray > values, bool ignore_infinite_filtration_values) -> nb::tuple { return compute_persistence_on_slices(self, values, ignore_infinite_filtration_values); }, diff --git a/multipers/gudhi/Module_interface.h b/multipers/gudhi/Module_interface.h index 35cd417d..8b2ca19a 100644 --- a/multipers/gudhi/Module_interface.h +++ b/multipers/gudhi/Module_interface.h @@ -57,7 +57,7 @@ class Module_interface { using Summand_of_dimension_range = boost::any_range; using Tensor1D = nanobind::ndarray, nanobind::any_contig>; - using Tensor2D = nanobind::ndarray, nanobind::any_contig>; + using Tensor2D = nanobind::ndarray >; template using IntTensor1D = nanobind::ndarray, nanobind::any_contig>; using Box_t = std::vector; From c1186f8d9825e518c2e4368e8d0c21da487151b1 Mon Sep 17 00:00:00 2001 From: hschreiber Date: Tue, 30 Jun 2026 11:18:57 +0200 Subject: [PATCH 10/10] better handling of box setters --- multipers/_mma_nanobind.cpp | 11 ++++++----- multipers/gudhi/Module_interface.h | 15 +++++++++++++++ 2 files changed, 21 insertions(+), 5 deletions(-) diff --git a/multipers/_mma_nanobind.cpp b/multipers/_mma_nanobind.cpp index 0b18d630..428f94e3 100644 --- a/multipers/_mma_nanobind.cpp +++ b/multipers/_mma_nanobind.cpp @@ -199,15 +199,16 @@ void bind_module_class(nb::module_& m) { .def_prop_rw("box", &Module::get_box_view, [](Module& self, nb::object box) { - if (nb::ndarray_check(box.ptr())) { - self.set_box(nb::cast(box)); - return; - } try { + if (nb::ndarray_check(box.ptr())) { + self.set_box(nb::cast(box)); + return; + } self.set_box(nb::cast>>(box)); return; } catch (const nb::cast_error&) { - throw nb::type_error("Box has to be set with a 2D array or a nested sequence."); + throw nb::type_error( + "Box has to be set with an array or a nested sequence of shape (2, p)."); } }) .def("set_box", diff --git a/multipers/gudhi/Module_interface.h b/multipers/gudhi/Module_interface.h index 8b2ca19a..2e3d44ae 100644 --- a/multipers/gudhi/Module_interface.h +++ b/multipers/gudhi/Module_interface.h @@ -38,6 +38,7 @@ #include #include #include +#include #include namespace Gudhi { @@ -125,11 +126,19 @@ class Module_interface { } Module_interface &set_box(const Box &box) { + if (module_.get_number_of_parameters() != get_null_value() && + module_.get_number_of_parameters() != box.get_number_of_coordinates()) + throw std::invalid_argument( + "The given box has not the same number of coordinates than parameters in the stored module"); box_ = get_flat_box(box); return *this; } Module_interface &set_box(Tensor2D box) { + if (module_.get_number_of_parameters() != get_null_value() && + module_.get_number_of_parameters() != box.shape(1)) + throw std::invalid_argument( + "The given box has not the same number of coordinates than parameters in the stored module"); box_ = get_flat_box_from_tensor(box); return *this; } @@ -138,6 +147,10 @@ class Module_interface { if (box.size() != 2) throw std::invalid_argument("Box has to be represented by two corners."); if (box[0].size() != box[1].size()) throw std::invalid_argument("Both corners defining the box must have same dimension."); + if (module_.get_number_of_parameters() != get_null_value() && + module_.get_number_of_parameters() != box[0].size()) + throw std::invalid_argument( + "The given box has not the same number of coordinates than parameters in the stored module"); box_ = Box_t(box[0].begin(), box[0].end()); box_.reserve(box_.size() * 2); box_.insert(box_.end(), box[1].begin(), box[1].end()); @@ -574,6 +587,8 @@ class Module_interface { } static Box_t get_flat_box_from_tensor(Tensor2D box) { + if (box.shape(0) != 2) throw std::invalid_argument("Box has to be represented by two corners."); + Numpy_2d_span boxView(box); auto lowerView = boxView[0]; auto upperView = boxView[1];