multipers 2.7.0b4__tar.gz → 2.7.0b6__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multipers
-Version: 2.7.0b4
+Version: 2.7.0b6
 Summary: Multiparameter Topological Persistence for Machine Learning
 Keywords: TDA,Persistence,Multiparameter,sklearn,autodiff
 Author-Email: David Loiseaux <david.lapous@proton.me>, Hannah Schreiber <hannah.schreiber@inria.fr>
@@ -84,22 +84,25 @@ This library features a bunch of different functions and helpers. See below for
 <br>Filled box refers to implemented or interfaced code.
  - [x] [[Multiparameter Module Approximation, JACT]](https://doi.org/10.1007/s41468-025-00222-y) provides the multiparameter simplicial structure, as well as technics for approximating modules, via interval-decomposable modules. It is also very useful for visualization.
  - [x] [[Stable Vectorization of Multiparameter Persistent Homology using Signed Barcodes as Measures, NeurIPS2023]](https://proceedings.neurips.cc/paper_files/paper/2023/hash/d75c474bc01735929a1fab5d0de3b189-Abstract-Conference.html) provides fast representations of multiparameter persistence modules, by using their signed barcodes decompositions encoded into signed measures. Implemented decompositions : Euler surfaces, Hilbert function, rank invariant (i.e. rectangles). It also provides representation technics for Machine Learning, i.e., Sliced Wasserstein kernels, and Vectorizations.
- - [x] [[A Framework for Fast and Stable Representations of Multiparameter Persistent Homology Decompositions, NeurIPS2023]](https://proceedings.neurips.cc/paper_files/paper/2023/hash/702b67152ec4435795f681865b67999c-Abstract-Conference.html) Provides a vectorization framework for interval decomposable modules, for Machine Learning. Currently implemented as an extension of MMA.
+ - [x] [[A Framework for Fast and Stable Representations of Multiparameter Persistent Homology Decompositions, NeurIPS2023]](https://proceedings.neurips.cc/paper_files/paper/2023/hash/702b67152ec4435795f681865b67999c-Abstract-Conference.html) Provides a vectorization framework for interval decomposable modules, for Machine Learning. Implemented as an extension of MMA.
  - [x] [[Differentiability and Optimization of Multiparameter Persistent Homology, ICML2024]](https://proceedings.mlr.press/v235/scoccola24a.html) An approach to compute a (clarke) gradient for any reasonable multiparameter persistent invariant. Currently, any `multipers` computation is auto-differentiable using this strategy, provided that the input are pytorch gradient capable tensor.
  - [x] [[Multiparameter Persistence Landscapes, JMLR]](https://jmlr.org/papers/v21/19-054.html) A vectorization technic for multiparameter persistence modules.
  - [x] [[Filtration-Domination in Bifiltered Graphs, ALENEX2023]](https://doi.org/10.1137/1.9781611977561.ch3) Allows for 2-parameter edge collapses for 1-critical clique complexes. Very useful to speed up, e.g., Rips-Codensity bifiltrations.
  - [x] [[Fast free resolutions of bifiltered chain complexes]](https://arxiv.org/abs/2512.08652) One-critical representation of multicritical filtrations, using [multi_critical](https://bitbucket.org/mkerber/multi_critical).
  - [x] [[Chunk Reduction for Multi-Parameter Persistent Homology, SoCG2019]](https://doi.org/10.4230/LIPIcs.SoCG.2019.37) Multi-filtration preprocessing algorithm for homology computations.
  - [x] [[Computing Minimal Presentations and Bigraded Betti Numbers of 2-Parameter Persistent Homology, JAAG]](https://doi.org/10.1137/20M1388425) Minimal presentation of multiparameter persistence modules, using [mpfree](https://bitbucket.org/mkerber/mpfree/src/master/). Hilbert, Rank Decomposition Signed Measures, and MMA decompositions can be computed using the mpfree backend.
- - [x] [[Hera]](https://github.com/anigmetov/hera) Matching distance between 2-parameter presentations, 1-parameter bottleneck/wasserstein distances.
+ - [x] [[Hera]](https://github.com/anigmetov/hera) Matching distance between 2-parameter presentations, 1-parameter bottleneck/wasserstein distances ([[paper]](https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.SoCG.2020.53))
  - [x] [[Decomposing Multiparameter Persistence Modules, SoCG2025]](https://doi.org/10.4230/LIPIcs.SoCG.2025.41) Using the [AIDA](https://github.com/JanJend/AIDA) and [Persistence-Algebra](https://github.com/JanJend/Persistence-Algebra/) libraries.
  - [x] [[Delaunay Bifiltrations of Functions on Point Clouds, SODA2024]](https://epubs.siam.org/doi/10.1137/1.9781611977912.173) Provides an alternative to function rips bifiltrations, using Delaunay complexes. Very good alternative to Rips-Density like bifiltrations.
- - [x] [[Delaunay Core Bifiltration]](https://arxiv.org/abs/2405.01214) Bifiltration for point clouds, taking into account the density. Similar to Rips-Density. 
+ - [x] [[Delaunay Core Bifiltration, JACT]](https://doi.org/10.1007/s41468-025-00226-8) Bifiltration for point clouds, taking into account the density. Similar to Rips-Density. 
  - [x] [[Computing the Multicover Bifiltration, SOCG2021]](https://doi.org/10.4230/LIPIcs.SoCG.2021.27) Rhomboid Tiling bifiltration. Equivalent to the multicover bifiltration, using [rhomboidtiling](https://github.com/geoo89/rhomboidtiling).
- - [x] [[Rivet]](https://github.com/rivetTDA/rivet) Interactive two parameter persistence
+ - [x] [[Rivet]](https://github.com/rivetTDA/rivet) Interactive two parameter persistence. 
  - [x] [[Kernel Operations on the GPU, with Autodiff, without Memory Overflows, JMLR]](http://jmlr.org/papers/v22/20-275.html) Although not linked, at first glance, to persistence in any way, this library allows computing blazingly fast signed measures convolutions (and more!) with custom kernels. 
- - [x] [[Projected distances for multi-parameter persistence modules]](https://arxiv.org/abs/2206.08818) Provides a strategy to estimate the convolution distance between multiparameter persistence module using projected barcodes. Implementation is a WIP.
+ - [x] [[Projected distances for multi-parameter persistence modules, Institut Fourier]](https://aif.centre-mersenne.org/articles/10.5802/aif.3752/) and [[Computation of $\gamma$-linear projected barcodes, JACT]](https://doi.org/10.1007/s41468-025-00209-9) Provides a strategy to estimate the convolution distance between multiparameter persistence module using projected barcodes.
  - [x] [[Efficient Two-Parameter Persistence Computation via Cohomology, SoCG2023]](https://doi.org/10.4230/LIPIcs.SoCG.2023.15) Minimal presentations for 2-parameter persistence algorithm.
+ - [x] [[deg_rips]](https://bitbucket.org/mkerber/deg_rips) Efficient implementation of the DegreeRips bifiltration. Alternative to the multipers-native one.
+ - [ ] [[Multiscale Clusterings BiFiltration, ICLR2026]](https://openreview.net/forum?id=E7D6uybODJ) WIP implementation. 
+
 
 If I missed something, or you want to add something, feel free to open an issue.
 
@@ -110,7 +113,7 @@ If I missed something, or you want to add something, feel free to open an issue.
 (Möbius inversion in python, degree-rips using [persistable](https://github.com/LuisScoccola/persistable) and [RIVET](https://github.com/rivetTDA/rivet/)),<br>
 [Mathieu Carrière](https://www-sop.inria.fr/members/Mathieu.Carriere/) (Sliced Wasserstein),<br>
 [Odin Hoff Gardå](https://odinhg.github.io/) (Delaunay Core bifiltration),<br>
-[Michael Kerber](https://www.geometrie.tugraz.at/kerber/) ([mpfree](https://bitbucket.org/mkerber/mpfree/src/master/), [function_delaunay](https://bitbucket.org/mkerber/function_delaunay), [multi_critical](https://bitbucket.org/mkerber/multi_critical), [multi_chunk](https://bitbucket.org/mkerber/multi_chunk) backends),<br>
+[Michael Kerber](https://www.geometrie.tugraz.at/kerber/) ([mpfree](https://bitbucket.org/mkerber/mpfree/src/master/), [function_delaunay](https://bitbucket.org/mkerber/function_delaunay), [multi_critical](https://bitbucket.org/mkerber/multi_critical), [multi_chunk](https://bitbucket.org/mkerber/multi_chunk), [[deg_rips]](https://bitbucket.org/mkerber/deg_rips) backends),<br>
 [Jan Jendrysiak](https://github.com/JanJend) ([Module Decomposition (AIDA)](https://github.com/JanJend/AIDA), [Persistence Algebra](https://github.com/JanJend/Persistence-Algebra)).<br>
 
 ## Licensing
@@ -144,5 +147,9 @@ you can use the following journal bibtex entry
 }
 ```
 ## Contributions
-Feel free to contribute, report a bug on a pipeline, or ask for documentation by opening an issue.<br>
-In particular, if you have a nice example or application that is not taken care in the documentation (see the `./docs/notebooks/` folder), please contact me to add it there.
+Feel free to contribute, report a bug on a pipeline, or ask for documentation
+by opening an issue.<br>
+A good amount of doc pages are empty notebooks that just need to be filled!  
+In particular, if you have a nice example or application that is not taken care
+in the documentation (see the `./docs/notebooks/` folder), please open a PR or
+contact me to add it there.

{multipers-2.7.0b4 → multipers-2.7.0b6}/README.md

@@ -45,22 +45,25 @@ This library features a bunch of different functions and helpers. See below for
 <br>Filled box refers to implemented or interfaced code.
  - [x] [[Multiparameter Module Approximation, JACT]](https://doi.org/10.1007/s41468-025-00222-y) provides the multiparameter simplicial structure, as well as technics for approximating modules, via interval-decomposable modules. It is also very useful for visualization.
  - [x] [[Stable Vectorization of Multiparameter Persistent Homology using Signed Barcodes as Measures, NeurIPS2023]](https://proceedings.neurips.cc/paper_files/paper/2023/hash/d75c474bc01735929a1fab5d0de3b189-Abstract-Conference.html) provides fast representations of multiparameter persistence modules, by using their signed barcodes decompositions encoded into signed measures. Implemented decompositions : Euler surfaces, Hilbert function, rank invariant (i.e. rectangles). It also provides representation technics for Machine Learning, i.e., Sliced Wasserstein kernels, and Vectorizations.
- - [x] [[A Framework for Fast and Stable Representations of Multiparameter Persistent Homology Decompositions, NeurIPS2023]](https://proceedings.neurips.cc/paper_files/paper/2023/hash/702b67152ec4435795f681865b67999c-Abstract-Conference.html) Provides a vectorization framework for interval decomposable modules, for Machine Learning. Currently implemented as an extension of MMA.
+ - [x] [[A Framework for Fast and Stable Representations of Multiparameter Persistent Homology Decompositions, NeurIPS2023]](https://proceedings.neurips.cc/paper_files/paper/2023/hash/702b67152ec4435795f681865b67999c-Abstract-Conference.html) Provides a vectorization framework for interval decomposable modules, for Machine Learning. Implemented as an extension of MMA.
  - [x] [[Differentiability and Optimization of Multiparameter Persistent Homology, ICML2024]](https://proceedings.mlr.press/v235/scoccola24a.html) An approach to compute a (clarke) gradient for any reasonable multiparameter persistent invariant. Currently, any `multipers` computation is auto-differentiable using this strategy, provided that the input are pytorch gradient capable tensor.
  - [x] [[Multiparameter Persistence Landscapes, JMLR]](https://jmlr.org/papers/v21/19-054.html) A vectorization technic for multiparameter persistence modules.
  - [x] [[Filtration-Domination in Bifiltered Graphs, ALENEX2023]](https://doi.org/10.1137/1.9781611977561.ch3) Allows for 2-parameter edge collapses for 1-critical clique complexes. Very useful to speed up, e.g., Rips-Codensity bifiltrations.
  - [x] [[Fast free resolutions of bifiltered chain complexes]](https://arxiv.org/abs/2512.08652) One-critical representation of multicritical filtrations, using [multi_critical](https://bitbucket.org/mkerber/multi_critical).
  - [x] [[Chunk Reduction for Multi-Parameter Persistent Homology, SoCG2019]](https://doi.org/10.4230/LIPIcs.SoCG.2019.37) Multi-filtration preprocessing algorithm for homology computations.
  - [x] [[Computing Minimal Presentations and Bigraded Betti Numbers of 2-Parameter Persistent Homology, JAAG]](https://doi.org/10.1137/20M1388425) Minimal presentation of multiparameter persistence modules, using [mpfree](https://bitbucket.org/mkerber/mpfree/src/master/). Hilbert, Rank Decomposition Signed Measures, and MMA decompositions can be computed using the mpfree backend.
- - [x] [[Hera]](https://github.com/anigmetov/hera) Matching distance between 2-parameter presentations, 1-parameter bottleneck/wasserstein distances.
+ - [x] [[Hera]](https://github.com/anigmetov/hera) Matching distance between 2-parameter presentations, 1-parameter bottleneck/wasserstein distances ([[paper]](https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.SoCG.2020.53))
  - [x] [[Decomposing Multiparameter Persistence Modules, SoCG2025]](https://doi.org/10.4230/LIPIcs.SoCG.2025.41) Using the [AIDA](https://github.com/JanJend/AIDA) and [Persistence-Algebra](https://github.com/JanJend/Persistence-Algebra/) libraries.
  - [x] [[Delaunay Bifiltrations of Functions on Point Clouds, SODA2024]](https://epubs.siam.org/doi/10.1137/1.9781611977912.173) Provides an alternative to function rips bifiltrations, using Delaunay complexes. Very good alternative to Rips-Density like bifiltrations.
- - [x] [[Delaunay Core Bifiltration]](https://arxiv.org/abs/2405.01214) Bifiltration for point clouds, taking into account the density. Similar to Rips-Density. 
+ - [x] [[Delaunay Core Bifiltration, JACT]](https://doi.org/10.1007/s41468-025-00226-8) Bifiltration for point clouds, taking into account the density. Similar to Rips-Density. 
  - [x] [[Computing the Multicover Bifiltration, SOCG2021]](https://doi.org/10.4230/LIPIcs.SoCG.2021.27) Rhomboid Tiling bifiltration. Equivalent to the multicover bifiltration, using [rhomboidtiling](https://github.com/geoo89/rhomboidtiling).
- - [x] [[Rivet]](https://github.com/rivetTDA/rivet) Interactive two parameter persistence
+ - [x] [[Rivet]](https://github.com/rivetTDA/rivet) Interactive two parameter persistence. 
  - [x] [[Kernel Operations on the GPU, with Autodiff, without Memory Overflows, JMLR]](http://jmlr.org/papers/v22/20-275.html) Although not linked, at first glance, to persistence in any way, this library allows computing blazingly fast signed measures convolutions (and more!) with custom kernels. 
- - [x] [[Projected distances for multi-parameter persistence modules]](https://arxiv.org/abs/2206.08818) Provides a strategy to estimate the convolution distance between multiparameter persistence module using projected barcodes. Implementation is a WIP.
+ - [x] [[Projected distances for multi-parameter persistence modules, Institut Fourier]](https://aif.centre-mersenne.org/articles/10.5802/aif.3752/) and [[Computation of $\gamma$-linear projected barcodes, JACT]](https://doi.org/10.1007/s41468-025-00209-9) Provides a strategy to estimate the convolution distance between multiparameter persistence module using projected barcodes.
  - [x] [[Efficient Two-Parameter Persistence Computation via Cohomology, SoCG2023]](https://doi.org/10.4230/LIPIcs.SoCG.2023.15) Minimal presentations for 2-parameter persistence algorithm.
+ - [x] [[deg_rips]](https://bitbucket.org/mkerber/deg_rips) Efficient implementation of the DegreeRips bifiltration. Alternative to the multipers-native one.
+ - [ ] [[Multiscale Clusterings BiFiltration, ICLR2026]](https://openreview.net/forum?id=E7D6uybODJ) WIP implementation. 
+
 
 If I missed something, or you want to add something, feel free to open an issue.
 
@@ -71,7 +74,7 @@ If I missed something, or you want to add something, feel free to open an issue.
 (Möbius inversion in python, degree-rips using [persistable](https://github.com/LuisScoccola/persistable) and [RIVET](https://github.com/rivetTDA/rivet/)),<br>
 [Mathieu Carrière](https://www-sop.inria.fr/members/Mathieu.Carriere/) (Sliced Wasserstein),<br>
 [Odin Hoff Gardå](https://odinhg.github.io/) (Delaunay Core bifiltration),<br>
-[Michael Kerber](https://www.geometrie.tugraz.at/kerber/) ([mpfree](https://bitbucket.org/mkerber/mpfree/src/master/), [function_delaunay](https://bitbucket.org/mkerber/function_delaunay), [multi_critical](https://bitbucket.org/mkerber/multi_critical), [multi_chunk](https://bitbucket.org/mkerber/multi_chunk) backends),<br>
+[Michael Kerber](https://www.geometrie.tugraz.at/kerber/) ([mpfree](https://bitbucket.org/mkerber/mpfree/src/master/), [function_delaunay](https://bitbucket.org/mkerber/function_delaunay), [multi_critical](https://bitbucket.org/mkerber/multi_critical), [multi_chunk](https://bitbucket.org/mkerber/multi_chunk), [[deg_rips]](https://bitbucket.org/mkerber/deg_rips) backends),<br>
 [Jan Jendrysiak](https://github.com/JanJend) ([Module Decomposition (AIDA)](https://github.com/JanJend/AIDA), [Persistence Algebra](https://github.com/JanJend/Persistence-Algebra)).<br>
 
 ## Licensing
@@ -105,5 +108,9 @@ you can use the following journal bibtex entry
 }
 ```
 ## Contributions
-Feel free to contribute, report a bug on a pipeline, or ask for documentation by opening an issue.<br>
-In particular, if you have a nice example or application that is not taken care in the documentation (see the `./docs/notebooks/` folder), please contact me to add it there.
+Feel free to contribute, report a bug on a pipeline, or ask for documentation
+by opening an issue.<br>
+A good amount of doc pages are empty notebooks that just need to be filled!  
+In particular, if you have a nice example or application that is not taken care
+in the documentation (see the `./docs/notebooks/` folder), please open a PR or
+contact me to add it there.

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

@@ -22,6 +22,7 @@ endif()
 multipers_default_disable_flag("multi_critical" MULTIPERS_DISABLE_MULTI_CRITICAL_INTERFACE)
 multipers_default_disable_flag("rhomboid" MULTIPERS_DISABLE_RHOMBOID_TILING_INTERFACE)
 multipers_default_disable_flag("hera" MULTIPERS_DISABLE_HERA_INTERFACE)
+multipers_default_disable_flag("persistence_algebra" MULTIPERS_DISABLE_PERSISTENCE_ALGEBRA_INTERFACE)
 
 if(WIN32)
   set(MULTIPERS_DISABLE_MPFREE_INTERFACE ON)
@@ -38,6 +39,8 @@ if(WIN32)
   message(STATUS "[rhomboid] Forced MULTIPERS_DISABLE_RHOMBOID_TILING_INTERFACE=${MULTIPERS_DISABLE_RHOMBOID_TILING_INTERFACE} on WIN32")
   set(MULTIPERS_DISABLE_HERA_INTERFACE ON)
   message(STATUS "[hera] Forced MULTIPERS_DISABLE_HERA_INTERFACE=${MULTIPERS_DISABLE_HERA_INTERFACE} on WIN32")
+  set(MULTIPERS_DISABLE_PERSISTENCE_ALGEBRA_INTERFACE ON)
+  message(STATUS "[persistence_algebra] Forced MULTIPERS_DISABLE_PERSISTENCE_ALGEBRA_INTERFACE=${MULTIPERS_DISABLE_PERSISTENCE_ALGEBRA_INTERFACE} on WIN32")
 endif()
 
 if(NOT MULTIPERS_HAS_FLAT_FILTRATION_CONTAINER)
@@ -111,6 +114,7 @@ set(MULTIPERS_INTERFACE_DISABLE_FLAGS
   MULTIPERS_DISABLE_MULTI_CRITICAL_INTERFACE
   MULTIPERS_DISABLE_RHOMBOID_TILING_INTERFACE
   MULTIPERS_DISABLE_HERA_INTERFACE
+  MULTIPERS_DISABLE_PERSISTENCE_ALGEBRA_INTERFACE
 )
 
 set(MULTIPERS_INTERFACE_DISABLE_DEFINITIONS "")
@@ -875,6 +879,14 @@ function(multipers_configure_module module_name target_name)
       target_include_directories(${target_name} PRIVATE ${MULTIPERS_AIDA_INCLUDE_DIRS})
     endif()
 
+  elseif(module_name STREQUAL "_persistence_algebra_interface")
+    if(NOT MULTIPERS_DISABLE_PERSISTENCE_ALGEBRA_INTERFACE)
+      multipers_link_nanobind_runtime(${target_name})
+      multipers_link_openmp(${target_name})
+      multipers_link_tbb(${target_name})
+      target_include_directories(${target_name} PRIVATE "${CMAKE_SOURCE_DIR}/ext/Persistence-Algebra/include")
+    endif()
+
   elseif(module_name STREQUAL "_hera_interface")
     if(NOT MULTIPERS_DISABLE_HERA_INTERFACE)
       multipers_link_shared_core(${target_name})
@@ -978,6 +990,7 @@ set(MULTIPERS_NANOBIND_MODULES
   _multi_critical_interface
   _rhomboid_tiling_interface
   _aida_interface
+  _persistence_algebra_interface
 )
 
 foreach(module_name IN LISTS MULTIPERS_NANOBIND_MODULES)

{multipers-2.7.0b4 → multipers-2.7.0b6}/ext/gudhi-devel/src/Multi_persistence/include/gudhi/Multi_persistence/Box.h

@@ -62,6 +62,42 @@ class Box
     // second."));
   }
 
+  /**
+   * @brief Move constructs a box from the two given corners. Assumes that \f$ lowerCorner \le @p upperCorner \f$ and
+   * if both are finite values, they have the same dimension.
+   *
+   * @param lowerCorner First corner of the box. Has to be smaller than `upperCorner`.
+   * @param upperCorner Second corner of the box. Has to be greater than `lowerCorner`.
+   */
+  Box(Point_t &&lowerCorner, Point_t &&upperCorner)
+      : lowerCorner_(std::move(lowerCorner)), upperCorner_(std::move(upperCorner)) {
+    GUDHI_CHECK(lowerCorner_.size() == upperCorner_.size(),
+                std::invalid_argument("The two corners of the box don't have the same dimension."));
+    // GUDHI_CHECK(lowerCorner_ <= upperCorner_,
+    //             std::invalid_argument("The first corner is not smaller than the second."));
+  }
+
+  /**
+   * @brief Constructs a box from the two given corners. Assumes that \f$ lowerCorner \le @p upperCorner \f$ and
+   * if both are finite values, they have the same dimension.
+   * 
+   * @tparam CoordinateIterator1 Forward iterator derefencing to an arithmetic value convertible to `T`.
+   * @tparam CoordinateIterator2 Forward iterator derefencing to an arithmetic value convertible to `T`.
+   * @param lowerBegin Begin iterator of the lower corner.
+   * @param lowerEnd End iterator of the lower corner.
+   * @param upperBegin Begin iterator of the upper corner.
+   * @param upperEnd End iterator of the upper corner.
+   */
+  template <class CoordinateIterator1, class CoordinateIterator2>
+  Box(CoordinateIterator1 lowerBegin, CoordinateIterator1 lowerEnd, CoordinateIterator2 upperBegin,
+      CoordinateIterator2 upperEnd)
+      : lowerCorner_(lowerBegin, lowerEnd), upperCorner_(upperBegin, upperEnd) {
+    GUDHI_CHECK(lowerCorner_.size() == upperCorner_.size(),
+                std::invalid_argument("The two corners of the box don't have the same dimension."));
+    // GUDHI_CHECK(lowerCorner_ <= upperCorner_,
+    //             std::invalid_argument("The first corner is not smaller than the second."));
+  }
+
   /**
    * @brief Constructs a box from the two given corners. Assumes that \f$ box.first \le @p box.second \f$ and
    * if both are finite values, they have the same dimension.
@@ -154,9 +190,9 @@ class Box
   }
 
   /**
-   * @brief Returns the dimension of the box.
+   * @brief Returns the number of coordinates of the box.
    */
-  [[nodiscard]] std::size_t get_dimension() const { return lowerCorner_.size(); }
+  [[nodiscard]] std::size_t get_number_of_coordinates() const { return lowerCorner_.size(); }
 
   /**
    * @brief Inflates the box by delta.
@@ -206,15 +242,15 @@ class Box
     }
     if (b.is_trivial()) return a;
 
-    GUDHI_CHECK(a.get_dimension() == b.get_dimension(), "Both boxes to enclose do not have the same dimension.");
+    GUDHI_CHECK(a.get_number_of_coordinates() == b.get_number_of_coordinates(), "Both boxes to enclose do not have the same dimension.");
 
-    Point_t lower(a.get_dimension());
-    Point_t upper(a.get_dimension());
+    Point_t lower(a.get_number_of_coordinates());
+    Point_t upper(a.get_number_of_coordinates());
     const auto &aLower = a.get_lower_corner();
     const auto &aUpper = a.get_upper_corner();
     const auto &bLower = b.get_lower_corner();
     const auto &bUpper = b.get_upper_corner();
-    for (unsigned int i = 0; i < a.get_dimension(); ++i) {
+    for (unsigned int i = 0; i < a.get_number_of_coordinates(); ++i) {
       lower[i] = std::min(aLower[i], bLower[i]);
       upper[i] = std::max(aUpper[i], bUpper[i]);
     }
@@ -222,6 +258,44 @@ class Box
     return Box(lower, upper);
   }
 
+  /**
+   * @brief Serialize given value into the buffer at given pointer.
+   *
+   * @param value Value to serialize.
+   * @param start Pointer to the start of the space in the buffer where to store the serialization.
+   * @return End position of the serialization in the buffer.
+   */
+  friend char *serialize_value_to_char_buffer(const Box &value, char *start) {
+    char *curr = start;
+    curr = serialize_value_to_char_buffer(value.lowerCorner_, curr);
+    curr = serialize_value_to_char_buffer(value.upperCorner_, curr);
+    return curr;
+  }
+
+  /**
+   * @brief Deserialize the value from a buffer at given pointer and stores it in given value.
+   *
+   * @param value Value to fill with the deserialized box.
+   * @param start Pointer to the start of the space in the buffer where the serialization is stored.
+   * @return End position of the serialization in the buffer.
+   */
+  friend const char *deserialize_value_from_char_buffer(Box &value, const char *start) {
+    const char *curr = start;
+    curr = deserialize_value_from_char_buffer(value.lowerCorner_, curr);
+    curr = deserialize_value_from_char_buffer(value.upperCorner_, curr);
+    return curr;
+  }
+
+  /**
+   * @brief Returns the serialization size of the given box.
+   */
+  friend std::size_t get_serialization_size_of(const Box &value) {
+    std::size_t size = 0;
+    // both corners have same length and same value type
+    size += get_serialization_size_of(value.lowerCorner_) * 2;
+    return size;
+  }
+
  private:
   Point_t lowerCorner_; /**< Lowest of defining corners. */
   Point_t upperCorner_; /**< Greatest of defining corners. */

{multipers-2.7.0b4 → multipers-2.7.0b6}/ext/gudhi-devel/src/Multi_persistence/include/gudhi/Multi_persistence/Line.h

@@ -21,10 +21,12 @@
 
 #include <cstddef>
 #include <stdexcept>
+#include <type_traits>
 
 #include <gudhi/Debug_utils.h>
 #include <gudhi/Multi_persistence/Box.h>
 #include <gudhi/Multi_persistence/Point.h>
+#include <gudhi/Multi_persistence/utils.h>
 #include <gudhi/Multi_filtration/multi_filtration_utils.h>
 
 namespace Gudhi {
@@ -76,25 +78,75 @@ class Line
    */
   Line(const Point_t &x, const Point_t &vector) : basePoint_(x), direction_(vector) { _check_direction(); }
 
+  /**
+   * @brief Constructs a line going through the given point in the direction of the given vector.
+   * If the vector has no coordinates, the slope is assumed to be 1.
+   * Otherwise, the vector has to be non trivial and all its coordinates have to be positive.
+   *
+   * @param x A point of the line. Will be moved.
+   * @param vector Direction of the line. Positive and non trivial. Will be moved.
+   */
+  Line(Point_t &&x, Point_t &&vector) : basePoint_(std::move(x)), direction_(std::move(vector)) { _check_direction(); }
+
+  /**
+   * @brief Constructs a line going through the given point with slope 1.
+   * 
+   * @tparam CoordinateIterator Forward iterator derefencing to an arithmetic value convertible to `T`.
+   * @param begin Begin iterator of the point.
+   * @param end End iterator of the point.
+   */
+  template <class CoordinateIterator,
+            class = std::enable_if_t<is_forward_iterator_v<CoordinateIterator> > >
+  Line(CoordinateIterator begin, CoordinateIterator end) : basePoint_(begin, end), direction_() {}
+
+  /**
+   * @brief Constructs a line going through the given point in the direction of the given range.
+   * If the range is empty, the slope is assumed to be 1.
+   * Otherwise, the range has to be non trivial and all its coordinates have to be positive.
+   * 
+   * @tparam CoordinateIterator Forward iterator derefencing to an arithmetic value convertible to `T`.
+   * @tparam DirectionIterator Forward iterator derefencing to an arithmetic value convertible to `T`.
+   * @param baseBegin Begin iterator of the point.
+   * @param baseEnd End iterator of the point.
+   * @param dirBegin Begin iterator of the direction.
+   * @param dirEnd End iterator of the direction.
+   */
+  template <class CoordinateIterator, class DirectionIterator>
+  Line(CoordinateIterator baseBegin, CoordinateIterator baseEnd, DirectionIterator dirBegin, DirectionIterator dirEnd)
+      : basePoint_(baseBegin, baseEnd), direction_(dirBegin, dirEnd) {
+    _check_direction();
+  }
+
   /**
    * @brief Returns the coordinates of the point on the line with "time" parameter `t`. That is, the point \f$ x \f$
    * such that \f$ x[i] = base\_point[i] + t \times direction[i] \f$ for all \f$ i \in [0, n - 1] \f$ with \f$ n \f$
    * the number of coordinates.
+   * 
+   * @tparam U Arithmetic type.
+   *
+   * @note If `U` is different from `T` (e.g., `T` is `unsigned int`, but `t` is `-1` and so signed), make sure
+   * that the result remains in the scope of `T` (e.g., in the previous example, if the point computed ends up having
+   * negative coordinates, the result will underflow into very big integers), except if the overflow/underflow
+   * behaviour is wanted.
    */
-  Point_t operator[](T t) const
+  template<typename U = T>
+  Point_t operator[](U t) const
   {
     GUDHI_CHECK(direction_.size() == 0 || direction_.size() == basePoint_.size(),
                 "Direction and base point do not have the same dimension.");
 
-    if (Gudhi::multi_filtration::_is_nan(t) || t == Point_t::T_inf || t == Point_t::T_m_inf)
+    if (Gudhi::multi_filtration::_is_nan(t) || t == Point<U>::T_inf || t == Point<U>::T_m_inf)
       return Point_t(basePoint_.size(), t);
 
     Point_t x(basePoint_.size());
 
+    // static_cast because T can be unsigned while U is signed and still valid (i.e. result is positive)
     if (direction_.size() > 0) {
-      for (std::size_t i = 0; i < x.size(); i++) x[i] = basePoint_[i] + (t * direction_[i]);
-    } else
-      for (std::size_t i = 0; i < x.size(); i++) x[i] = basePoint_[i] + t;
+      for (std::size_t i = 0; i < x.size(); i++)
+        x[i] = static_cast<U>(basePoint_[i]) + (t * static_cast<U>(direction_[i]));
+    } else {
+      for (std::size_t i = 0; i < x.size(); i++) x[i] = static_cast<U>(basePoint_[i]) + t;
+    }
 
     return x;
   }