multipers 2.3.0__cp312-cp312-win_amd64.whl → 2.3.2__cp312-cp312-win_amd64.whl

multipers/mma_structures.pyx

@@ -97,6 +97,11 @@ cdef class PySummand_f64:
             return v[0].num_parameters()
         v = self.sum.get_death_list()
         return v[0].num_parameters()
+    def __eq__(self, PySummand_f64 other):
+        return self.sum == other.sum 
+
+
+
 
 cdef inline get_summand_filtration_values_f64(Summand[double] summand):
     r"""
@@ -161,6 +166,10 @@ cdef class PyModule_f64:
 
     cdef set(self, Module[double] m):
         self.cmod = m
+
+    def __eq__(self, PyModule_f64 other):
+        return self.cmod == other.cmod
+
     def merge(self, PyModule_f64 other, int dim=-1):
         r"""
         Merges two modules into one
@@ -176,7 +185,9 @@ cdef class PyModule_f64:
         Copy module from a memory pointer. Unsafe.
         """
         self.cmod = move(dereference(<Module[double]*>(module_ptr)))
-    def set_box(self, PyBox_f64 pybox):
+    def set_box(self, box):
+        assert len(box) == 2, "Box format is [low, hight]"
+        pybox = PyBox_f64(box[0], box[1])
         cdef Box[double] cbox = pybox.box
         with nogil:
             self.cmod.set_box(cbox)
@@ -580,7 +591,6 @@ cdef class PyModule_f64:
         cdef Box[double] c_box = Box[double](box)
         out = np.array(self.cmod.get_landscape(degree, k, c_box, resolution))
         if plot:
-            plt.figure()
             aspect = (box[1][0]-box[0][0]) / (box[1][1]-box[0][1])
             extent = [box[0][0], box[1][0], box[0][1], box[1][1]]
             plt.imshow(out.T, origin="lower", extent=extent, aspect=aspect)
@@ -614,7 +624,6 @@ cdef class PyModule_f64:
         out = np.array(self.cmod.get_landscapes(degree, ks, Box[double](box), resolution))
         if plot:
             to_plot = np.sum(out, axis=0)
-            plt.figure()
             aspect = (box[1][0]-box[0][0]) / (box[1][1]-box[0][1])
             extent = [box[0][0], box[1][0], box[0][1], box[1][1]]
             plt.imshow(to_plot.T, origin="lower", extent=extent, aspect=aspect)
@@ -961,8 +970,8 @@ cdef dump_summand_f64(Summand[double]& summand):
     cdef vector[One_critical_filtration[double]] births = summand.get_birth_list()
     cdef vector[One_critical_filtration[double]] deaths = summand.get_death_list()
     return (
-            _vff21cview_f64(births, copy=True), ## copy as local variables
-            _vff21cview_f64(deaths, copy=True),
+            np.array(_vff21cview_f64(births)),
+            np.array(_vff21cview_f64(deaths)),
             summand.get_dimension(),
             )
 
@@ -1049,6 +1058,11 @@ cdef class PySummand_f32:
             return v[0].num_parameters()
         v = self.sum.get_death_list()
         return v[0].num_parameters()
+    def __eq__(self, PySummand_f32 other):
+        return self.sum == other.sum 
+
+
+
 
 cdef inline get_summand_filtration_values_f32(Summand[float] summand):
     r"""
@@ -1113,6 +1127,10 @@ cdef class PyModule_f32:
 
     cdef set(self, Module[float] m):
         self.cmod = m
+
+    def __eq__(self, PyModule_f32 other):
+        return self.cmod == other.cmod
+
     def merge(self, PyModule_f32 other, int dim=-1):
         r"""
         Merges two modules into one
@@ -1128,7 +1146,9 @@ cdef class PyModule_f32:
         Copy module from a memory pointer. Unsafe.
         """
         self.cmod = move(dereference(<Module[float]*>(module_ptr)))
-    def set_box(self, PyBox_f32 pybox):
+    def set_box(self, box):
+        assert len(box) == 2, "Box format is [low, hight]"
+        pybox = PyBox_f32(box[0], box[1])
         cdef Box[float] cbox = pybox.box
         with nogil:
             self.cmod.set_box(cbox)
@@ -1532,7 +1552,6 @@ cdef class PyModule_f32:
         cdef Box[float] c_box = Box[float](box)
         out = np.array(self.cmod.get_landscape(degree, k, c_box, resolution))
         if plot:
-            plt.figure()
             aspect = (box[1][0]-box[0][0]) / (box[1][1]-box[0][1])
             extent = [box[0][0], box[1][0], box[0][1], box[1][1]]
             plt.imshow(out.T, origin="lower", extent=extent, aspect=aspect)
@@ -1566,7 +1585,6 @@ cdef class PyModule_f32:
         out = np.array(self.cmod.get_landscapes(degree, ks, Box[float](box), resolution))
         if plot:
             to_plot = np.sum(out, axis=0)
-            plt.figure()
             aspect = (box[1][0]-box[0][0]) / (box[1][1]-box[0][1])
             extent = [box[0][0], box[1][0], box[0][1], box[1][1]]
             plt.imshow(to_plot.T, origin="lower", extent=extent, aspect=aspect)
@@ -1913,8 +1931,8 @@ cdef dump_summand_f32(Summand[float]& summand):
     cdef vector[One_critical_filtration[float]] births = summand.get_birth_list()
     cdef vector[One_critical_filtration[float]] deaths = summand.get_death_list()
     return (
-            _vff21cview_f32(births, copy=True), ## copy as local variables
-            _vff21cview_f32(deaths, copy=True),
+            np.array(_vff21cview_f32(births)),
+            np.array(_vff21cview_f32(deaths)),
             summand.get_dimension(),
             )
 
@@ -2001,6 +2019,11 @@ cdef class PySummand_i32:
             return v[0].num_parameters()
         v = self.sum.get_death_list()
         return v[0].num_parameters()
+    def __eq__(self, PySummand_i32 other):
+        return self.sum == other.sum 
+
+
+
 
 cdef inline get_summand_filtration_values_i32(Summand[int32_t] summand):
     r"""
@@ -2065,6 +2088,10 @@ cdef class PyModule_i32:
 
     cdef set(self, Module[int32_t] m):
         self.cmod = m
+
+    def __eq__(self, PyModule_i32 other):
+        return self.cmod == other.cmod
+
     def merge(self, PyModule_i32 other, int dim=-1):
         r"""
         Merges two modules into one
@@ -2080,7 +2107,9 @@ cdef class PyModule_i32:
         Copy module from a memory pointer. Unsafe.
         """
         self.cmod = move(dereference(<Module[int32_t]*>(module_ptr)))
-    def set_box(self, PyBox_i32 pybox):
+    def set_box(self, box):
+        assert len(box) == 2, "Box format is [low, hight]"
+        pybox = PyBox_i32(box[0], box[1])
         cdef Box[int32_t] cbox = pybox.box
         with nogil:
             self.cmod.set_box(cbox)
@@ -2281,8 +2310,8 @@ cdef dump_summand_i32(Summand[int32_t]& summand):
     cdef vector[One_critical_filtration[int32_t]] births = summand.get_birth_list()
     cdef vector[One_critical_filtration[int32_t]] deaths = summand.get_death_list()
     return (
-            _vff21cview_i32(births, copy=True), ## copy as local variables
-            _vff21cview_i32(deaths, copy=True),
+            np.array(_vff21cview_i32(births)),
+            np.array(_vff21cview_i32(deaths)),
             summand.get_dimension(),
             )
 
@@ -2369,6 +2398,11 @@ cdef class PySummand_i64:
             return v[0].num_parameters()
         v = self.sum.get_death_list()
         return v[0].num_parameters()
+    def __eq__(self, PySummand_i64 other):
+        return self.sum == other.sum 
+
+
+
 
 cdef inline get_summand_filtration_values_i64(Summand[int64_t] summand):
     r"""
@@ -2433,6 +2467,10 @@ cdef class PyModule_i64:
 
     cdef set(self, Module[int64_t] m):
         self.cmod = m
+
+    def __eq__(self, PyModule_i64 other):
+        return self.cmod == other.cmod
+
     def merge(self, PyModule_i64 other, int dim=-1):
         r"""
         Merges two modules into one
@@ -2448,7 +2486,9 @@ cdef class PyModule_i64:
         Copy module from a memory pointer. Unsafe.
         """
         self.cmod = move(dereference(<Module[int64_t]*>(module_ptr)))
-    def set_box(self, PyBox_i64 pybox):
+    def set_box(self, box):
+        assert len(box) == 2, "Box format is [low, hight]"
+        pybox = PyBox_i64(box[0], box[1])
         cdef Box[int64_t] cbox = pybox.box
         with nogil:
             self.cmod.set_box(cbox)
@@ -2649,8 +2689,8 @@ cdef dump_summand_i64(Summand[int64_t]& summand):
     cdef vector[One_critical_filtration[int64_t]] births = summand.get_birth_list()
     cdef vector[One_critical_filtration[int64_t]] deaths = summand.get_death_list()
     return (
-            _vff21cview_i64(births, copy=True), ## copy as local variables
-            _vff21cview_i64(deaths, copy=True),
+            np.array(_vff21cview_i64(births)),
+            np.array(_vff21cview_i64(deaths)),
             summand.get_dimension(),
             )
 

multipers/mma_structures.pyx.tp

@@ -118,6 +118,11 @@ cdef class PySummand_{{SHORT}}:
             return v[0].num_parameters()
         v = self.sum.get_death_list()
         return v[0].num_parameters()
+    def __eq__(self, PySummand_{{SHORT}} other):
+        return self.sum == other.sum 
+
+
+
 
 cdef inline get_summand_filtration_values_{{SHORT}}(Summand[{{CTYPE}}] summand):
     r"""
@@ -182,6 +187,10 @@ cdef class PyModule_{{SHORT}}:
 
     cdef set(self, Module[{{CTYPE}}] m):
         self.cmod = m
+
+    def __eq__(self, PyModule_{{SHORT}} other):
+        return self.cmod == other.cmod
+
     def merge(self, PyModule_{{SHORT}} other, int dim=-1):
         r"""
         Merges two modules into one
@@ -197,7 +206,9 @@ cdef class PyModule_{{SHORT}}:
         Copy module from a memory pointer. Unsafe.
         """
         self.cmod = move(dereference(<Module[{{CTYPE}}]*>(module_ptr)))
-    def set_box(self, PyBox_{{SHORT}} pybox):
+    def set_box(self, box):
+        assert len(box) == 2, "Box format is [low, hight]"
+        pybox = PyBox_{{SHORT}}(box[0], box[1])
         cdef Box[{{CTYPE}}] cbox = pybox.box
         with nogil:
             self.cmod.set_box(cbox)
@@ -602,7 +613,6 @@ cdef class PyModule_{{SHORT}}:
         cdef Box[{{CTYPE}}] c_box = Box[{{CTYPE}}](box)
         out = np.array(self.cmod.get_landscape(degree, k, c_box, resolution))
         if plot:
-            plt.figure()
             aspect = (box[1][0]-box[0][0]) / (box[1][1]-box[0][1])
             extent = [box[0][0], box[1][0], box[0][1], box[1][1]]
             plt.imshow(out.T, origin="lower", extent=extent, aspect=aspect)
@@ -636,7 +646,6 @@ cdef class PyModule_{{SHORT}}:
         out = np.array(self.cmod.get_landscapes(degree, ks, Box[{{CTYPE}}](box), resolution))
         if plot:
             to_plot = np.sum(out, axis=0)
-            plt.figure()
             aspect = (box[1][0]-box[0][0]) / (box[1][1]-box[0][1])
             extent = [box[0][0], box[1][0], box[0][1], box[1][1]]
             plt.imshow(to_plot.T, origin="lower", extent=extent, aspect=aspect)
@@ -984,8 +993,8 @@ cdef dump_summand_{{SHORT}}(Summand[{{CTYPE}}]& summand):
     cdef vector[One_critical_filtration[{{CTYPE}}]] births = summand.get_birth_list()
     cdef vector[One_critical_filtration[{{CTYPE}}]] deaths = summand.get_death_list()
     return (
-            _vff21cview_{{SHORT}}(births, copy=True), ## copy as local variables
-            _vff21cview_{{SHORT}}(deaths, copy=True),
+            np.array(_vff21cview_{{SHORT}}(births)),
+            np.array(_vff21cview_{{SHORT}}(deaths)),
             summand.get_dimension(),
             )
 

multipers/multiparameter_module_approximation/approximation.h

@@ -28,6 +28,7 @@
 #include <limits>
 #include <oneapi/tbb/parallel_for.h>
 #include <string>
+#include <type_traits>
 #include <utility>
 #include <vector>
 
@@ -88,6 +89,8 @@ class Module {
                    const bool threshold);
   typename module_type::iterator begin();
   typename module_type::iterator end();
+  typename module_type::const_iterator begin() const;
+  typename module_type::const_iterator end() const;
 
   void clean();
   void fill(const value_type precision);
@@ -192,6 +195,16 @@ class Module {
 
   std::vector<int> inline get_degree_splits() const;
 
+  inline friend bool operator==(const Module &a, const Module &b) {
+    if (a.get_dimension() != b.get_dimension()) return false;
+    if (a.box_ != b.box_) return false;
+    if (a.size() != b.size()) return false;
+    for (auto i : std::views::iota(0u, a.size())) {
+      if (a[i] != b[i]) return false;
+    }
+    return true;
+  }
+
  private:
   module_type module_;
   Box<value_type> box_;
@@ -281,6 +294,10 @@ class Summand {
     // 	std::swap(sum1.updateDistance_, sum2.updateDistance_);
   };
 
+  friend bool operator==(const Summand &a, const Summand &b) {
+    return a.dimension_ == b.dimension_ && a.birth_corners_ == b.birth_corners_ && a.death_corners_ == b.death_corners_;
+  }
+
   bool contains(const filtration_type &x) const;
 
   inline Box<value_type> get_bounds() const {
@@ -812,11 +829,21 @@ inline typename Module<value_type>::module_type::iterator Module<value_type>::be
   return module_.begin();
 }
 
+template <typename value_type>
+inline typename Module<value_type>::module_type::const_iterator Module<value_type>::begin() const {
+  return module_.cbegin();
+}
+
 template <typename value_type>
 inline typename Module<value_type>::module_type::iterator Module<value_type>::end() {
   return module_.end();
 }
 
+template <typename value_type>
+inline typename Module<value_type>::module_type::const_iterator Module<value_type>::end() const {
+  return module_.cend();
+}
+
 template <typename value_type>
 inline void Module<value_type>::add_summand(Summand<value_type> summand, int degree) {
   if (degree >= 0) summand.set_dimension(degree);
@@ -2046,14 +2073,16 @@ const Gudhi::multi_filtration::Multi_critical_filtration<value_type> &Summand<va
 
 template <typename value_type>
 inline void Summand<value_type>::clean() {
-  // birth_corners_.erase(
-  //     std::remove_if(birth_corners_.begin(), birth_corners_.end(),
-  //                    [](const std::vector<value_type> &bp) {
-  //                      return std::any_of(
-  //                          bp.begin(), bp.end(),
-  //                          [](float value) { return !std::isfinite(value); });
-  //                    }),
-  //     birth_corners_.end());
+  // birth_corners_.erase(std::remove_if(birth_corners_.begin(),
+  //                                     birth_corners_.end(),
+  //                                     [](const std::vector<value_type> &bp) {
+  //                                       // return std::any_of(
+  //                                       //     bp.begin(), bp.end(),
+  //                                       //     [](float value) { return !std::isfinite(value); });
+  //                                       bp.size() == 0;
+  //                                     }),
+  //                      birth_corners_.end());
+  // birth_corners_.simplify();
   // TODO : clean
 }
 
@@ -2064,13 +2093,15 @@ inline void Summand<value_type>::complete_birth(const value_type precision) {
   for (std::size_t i = 0; i < birth_corners_.num_generators(); i++) {
     for (std::size_t j = i + 1; j < birth_corners_.num_generators(); j++) {
       value_type dinf = d_inf(birth_corners_[i], birth_corners_[j]);
-      if (dinf < 1.1 * precision) {
+      if (dinf < .99 * precision) {  // for machine error ?
         _factorize_min(birth_corners_[i], birth_corners_[j]);
-        birth_corners_[j].clear();
+        birth_corners_[j] = std::remove_reference_t<decltype(birth_corners_[j])>::inf();
+        i++;
       }
     }
   }
-  _clean(birth_corners_);
+  birth_corners_.simplify();
+  // _clean(birth_corners_);
 }
 
 template <typename value_type>
@@ -2080,13 +2111,16 @@ inline void Summand<value_type>::complete_death(const value_type precision) {
   for (std::size_t i = 0; i < death_corners_.num_generators(); i++) {
     for (std::size_t j = i + 1; j < death_corners_.num_generators(); j++) {
       value_type d = d_inf(death_corners_[i], death_corners_[j]);
-      if (d < 1.1 * precision) {
+      if (d < .99 * precision) {
         _factorize_max(death_corners_[i], death_corners_[j]);
-        death_corners_[j].clear();
+        death_corners_[j] = std::remove_reference_t<decltype(death_corners_[j])>::minus_inf();
+        i++;
       }
     }
   }
-  _clean(death_corners_);
+
+  death_corners_.simplify();
+  // _clean(death_corners_);
 }
 
 template <typename value_type>

multipers/multiparameter_module_approximation.pyx

@@ -14,6 +14,7 @@ import numpy as np
 from typing import List
 from joblib import Parallel, delayed
 import sys
+from warnings import warn
 
 ###########################################################################
 ## CPP CLASSES
@@ -56,15 +57,20 @@ def module_approximation_from_slicer(
         bool threshold=False,
         bool verbose=False,
         list[float] direction = [],
+        bool warnings = True,
         )->PyModule_type:
 
     cdef Module[float] mod_f32
     cdef Module[double] mod_f64
     cdef intptr_t ptr
     if not slicer.is_vine:
-        print(r"Got a non-vine slicer as an input. Use `vineyard=True` to remove this copy.", file=sys.stderr)
+        if warnings:
+            warn(r"(copy warning) Got a non-vine slicer as an input. Use `vineyard=True` to remove this copy.")
         from multipers._slicer_meta import Slicer
         slicer = Slicer(slicer, vineyard=True, backend="matrix")
+    if slicer.is_squeezed:
+        raise ValueError("Got a squeezed slicer. Should have been unsqueezed before !")
+
     direction_ = np.asarray(direction, dtype=slicer.dtype)
     if slicer.dtype == np.float32:
         approx_mod = PyModule_f32()
@@ -89,14 +95,14 @@ def module_approximation(
         input:Union[SimplexTreeMulti_type,Slicer_type, tuple],
         box:Optional[np.ndarray]=None,
         float max_error=-1, 
-        int nlines=500,
+        int nlines=557,
         slicer_backend:Literal["matrix","clement","graph"]="matrix",
         minpres:Optional[Literal["mpfree"]]=None,
         degree:Optional[int]=None,
         bool complete=True, 
         bool threshold=False, 
         bool verbose=False,
-        bool ignore_warning=False,
+        bool ignore_warnings=False,
         id="",
         list[float] direction = [],
         list[int] swap_box_coords = [],
@@ -156,16 +162,24 @@ def module_approximation(
         if len(input) == 0:
             return PyModule_f64()
         if n_jobs <= 1: 
-            modules = tuple(module_approximation(slicer, box, max_error, nlines, slicer_backend, minpres, degree, complete, threshold, verbose, ignore_warning, id, direction, swap_box_coords) for slicer in input)
+            modules = tuple(module_approximation(slicer, box, max_error, nlines, slicer_backend, minpres, degree, complete, threshold, verbose, ignore_warnings, id, direction, swap_box_coords) for slicer in input)
         else:
             modules = tuple(Parallel(n_jobs=n_jobs, prefer="threads")(
-                delayed(module_approximation)(slicer, box, max_error, nlines, slicer_backend, minpres, degree, complete, threshold, verbose, ignore_warning, id, direction, swap_box_coords)
+                delayed(module_approximation)(slicer, box, max_error, nlines, slicer_backend, minpres, degree, complete, threshold, verbose, ignore_warnings, id, direction, swap_box_coords)
                 for slicer in input
             ))
-        mod = PyModule_f64().set_box(PyBox_f64(*modules[0].get_box()))
+        box = modules[0].get_box()
+        mod = PyModule_f64().set_box(box)
         for i,m in enumerate(modules):
             mod.merge(m, input[i].minpres_degree)
         return mod
+    if len(input) == 0:
+        return PyModule_f64()
+    if input.is_squeezed:
+        if not ignore_warnings:
+            warn("(copy warning) Got a squeezed input. ")
+        input = input.unsqueeze()
+
     if box is None:
         if is_simplextree_multi(input):
             box = input.filtration_bounds()
@@ -190,11 +204,16 @@ def module_approximation(
     if max_error <= 0:
         max_error = (prod/nlines)**(1/(num_parameters-1))
 
-    if not ignore_warning and prod >= 10_000:
+    if not ignore_warnings and prod >= 10_000:
         raise ValueError(f"""
 Warning : the number of lines (around {np.round(prod)}) may be too high. 
+This may be due to extreme box or filtration bounds :
+
+{box=}
+
 Try to increase the precision parameter, or set `ignore_warning=True` to compute this module. 
-Returning the trivial module."""
+Returning the trivial module.
+"""
         )
     if is_simplextree_multi(input):
         from multipers._slicer_meta import Slicer

multipers/plots.py

@@ -137,6 +137,7 @@ def plot_signed_measure(signed_measure, threshold=None, ax=None, **plt_kwargs):
             else:
                 pts_ = pts
             threshold = np.max(np.ma.masked_invalid(pts_), axis=0)
+        threshold = np.max([threshold, [plt.gca().get_xlim()[1], plt.gca().get_ylim()[1]]], axis=0)
     if isinstance(pts, np.ndarray):
         pass
     else:
@@ -254,7 +255,7 @@ def plot2d_PyModule(
     dimension=-1,
     separated=False,
     min_persistence=0,
-    alpha=1,
+    alpha=.8,
     verbose=False,
     save=False,
     dpi=200,

multipers/point_measure.pyx

@@ -89,6 +89,7 @@ def integrate_measure(
         grid_strategy:str="regular",
         resolution:int|list[int]=100,
         bool return_grid=False,
+        bool plot=False,
         **get_fitration_kwargs,
         ):
     """
@@ -126,6 +127,9 @@ def integrate_measure(
     for i in range(num_pts): 
         cone = tuple(slice(c,r) for r,c in zip(resolution,pts_coords[:,i]))
         out[cone] += weights[i] 
+    if plot:
+        from multipers.plots import plot_surface
+        plot_surface(filtration_grid, out, discrete_surface=True)
     if return_grid:
         return out,filtration_grid
     return out
@@ -211,7 +215,7 @@ def zero_out_sm(pts,weights, mass_default):
     C = np.concatenate([C, np.ones((C.shape[0],1))], axis=1).astype(np.bool_)
     
     # signs of each corner
-    Cw = 1-2*((~C).sum(axis=1)%2)
+    Cw = 1-2*((~C).sum(axis=1) & 1)
 
     # something useless in the end to ensure that the shape is correct (as we added 1 in pts)
     mass_default = np.concatenate([mass_default,[np.nan]]) 
@@ -299,7 +303,7 @@ def barcode_from_rank_sm(
     return out
 
 
-def estimate_rank_from_rank_sm(sm:tuple, a, b) -> int:
+def estimate_rank_from_rank_sm(sm:tuple, a, b)->np.int64:
     """
     Given a rank signed measure (sm) and two points (a) and (b),
     estimates the rank between these two points.

multipers/simplex_tree_multi.pxd

@@ -118,6 +118,7 @@ cdef extern from "Simplex_tree_multi_interface.h" namespace "Gudhi::multiparamet
     void to_std_linear_projection(intptr_t, vector[double]) nogil
     void squeeze_filtration_inplace(vector[vector[double]] &, bool) nogil
     void squeeze_filtration(intptr_t, vector[vector[double]] &) nogil
+    void unsqueeze_filtration(intptr_t, vector[vector[double]] &) nogil
     vector[vector[vector[value_type]]] get_filtration_values(const vector[int]&) nogil