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

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)
@@ -982,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,14 +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 < .99 * precision) { // for machine error ?
+      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>
@@ -2083,12 +2113,14 @@ inline void Summand<value_type>::complete_death(const value_type precision) {
       value_type d = d_inf(death_corners_[i], death_corners_[j]);
       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()
@@ -96,7 +102,7 @@ def module_approximation(
         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,10 +162,10 @@ 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()))
@@ -168,6 +174,11 @@ def module_approximation(
         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()
@@ -192,11 +203,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:

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