multipers 2.3.0__cp311-cp311-win_amd64.whl → 2.3.1__cp311-cp311-win_amd64.whl

multipers/{ml/convolutions.py → filtrations/density.py}

@@ -180,9 +180,10 @@ def _pts_convolution_pykeops(
 
 
 def gaussian_kernel(x_i, y_j, bandwidth):
+    D = x_i.shape[-1]
     exponent = -(((x_i - y_j) / bandwidth) ** 2).sum(dim=-1) / 2
     # float is necessary for some reason (pykeops fails)
-    kernel = (exponent).exp() / (bandwidth * float(np.sqrt(2 * np.pi)))
+    kernel = (exponent).exp() / float((bandwidth*np.sqrt(2 * np.pi))**D) 
     return kernel
 
 
@@ -339,7 +340,7 @@ class KDE:
             kernel *= w
         if return_kernel:
             return kernel
-        density_estimation = kernel.sum(dim=0).ravel() / kernel.shape[0]  # mean
+        density_estimation = kernel.sum(dim=0).squeeze() / kernel.shape[0]  # mean
         return (
             self._backend.log(density_estimation)
             if self.return_log
@@ -497,6 +498,48 @@ class DTM:
         return DTMs
 
 
+## code taken from pykeops doc (https://www.kernel-operations.io/keops/_auto_benchmarks/benchmark_KNN.html)
+class KNNmean:
+    def __init__(self, k: int, metric: str = "euclidean"):
+        self.k = k
+        self.metric = metric
+        self._KNN_fun = None
+        self._x = None
+
+    def fit(self, x):
+        if isinstance(x, np.ndarray):
+            from pykeops.numpy import Vi, Vj
+        else:
+            import torch
+
+            assert isinstance(x, torch.Tensor), "Backend has to be numpy or torch"
+            from pykeops.torch import Vi, Vj
+
+        D = x.shape[1]
+        X_i = Vi(0, D)
+        X_j = Vj(1, D)
+
+        # Symbolic distance matrix:
+        if self.metric == "euclidean":
+            D_ij = ((X_i - X_j) ** 2).sum(-1)
+        elif self.metric == "manhattan":
+            D_ij = (X_i - X_j).abs().sum(-1)
+        elif self.metric == "angular":
+            D_ij = -(X_i | X_j)
+        elif self.metric == "hyperbolic":
+            D_ij = ((X_i - X_j) ** 2).sum(-1) / (X_i[0] * X_j[0])
+        else:
+            raise NotImplementedError(f"The '{self.metric}' distance is not supported.")
+
+        self._x = x
+        self._KNN_fun = D_ij.Kmin(self.k, dim=1)
+        return self
+
+    def score_samples(self, x):
+        assert self._x is not None and self._KNN_fun is not None, "Fit first."
+        return self._KNN_fun(x, self._x).sum(axis=1) / self.k
+
+
 # def _pts_convolution_sparse(pts:np.ndarray, pts_weights:np.ndarray, filtration_grid:Iterable[np.ndarray], kernel="gaussian", bandwidth=0.1, **more_kde_args):
 # 	"""
 # 	Old version of `convolution_signed_measures`. Scikitlearn's convolution is slower than the code above.

multipers/filtrations/filtrations.py

@@ -7,13 +7,13 @@ from numpy.typing import ArrayLike
 from scipy.spatial import KDTree
 from scipy.spatial.distance import cdist
 
-from multipers.ml.convolutions import DTM, available_kernels
+from multipers.filtrations.density import DTM, available_kernels
 from multipers.simplex_tree_multi import SimplexTreeMulti, SimplexTreeMulti_type
 
 try:
     import pykeops
 
-    from multipers.ml.convolutions import KDE
+    from multipers.filtrations.density import KDE
 except ImportError:
     from sklearn.neighbors import KernelDensity
     from warnings import warn

multipers/gudhi/Simplex_tree_multi_interface.h

@@ -165,7 +165,7 @@ class Simplex_tree_multi_interface
 
   void compute_extended_filtration() { throw std::logic_error("Incompatible with multipers"); }
 
-  Simplex_tree_multi_interface *collapse_edges(int nb_collapse_iteration) {
+  Simplex_tree_multi_interface *collapse_edges([[maybe_unused]] int nb_collapse_iteration) {
     throw std::logic_error("Incompatible with multipers");
   }
 

multipers/gudhi/gudhi/One_critical_filtration.h

@@ -1039,7 +1039,8 @@ class One_critical_filtration : public std::vector<T> {
                         std::lower_bound(filtration.begin(),
                                          filtration.end(),
                                          static_cast<typename oned_array::value_type>(Base::operator[](parameter))));
-      d = d == filtration.size() ? filtration.size() - 1 : d;
+      int num_filtration_values = filtration.size();
+      d = d == num_filtration_values ? std::max(num_filtration_values - 1,0) : d;
       Base::operator[](parameter) = coordinate ? static_cast<T>(d) : static_cast<T>(filtration[d]);
     }
   }

multipers/gudhi/mma_interface_h0.h

@@ -39,7 +39,7 @@ class Persistence_backend_h0 {
   using cycle_type = std::vector<unsigned int>;
   static const bool is_vine = true;
 
-  std::vector<cycle_type> get_representative_cycles(bool update = true) const { throw "Unimplemented"; }
+  std::vector<cycle_type> get_representative_cycles([[maybe_unused]] bool update = true) const { throw "Unimplemented"; }
 
   class Barcode_iterator : public boost::iterator_facade<Barcode_iterator, const Bar &, boost::forward_traversal_tag> {
    public:

multipers/gudhi/mma_interface_matrix.h

@@ -60,6 +60,13 @@ struct No_vine_multi_persistence_options : Gudhi::persistence_matrix::Default_op
   static const bool has_vine_update = false;
 };
 
+template <Gudhi::persistence_matrix::Column_types column_type = Gudhi::persistence_matrix::Column_types::INTRUSIVE_SET>
+struct fix_presentation_options : Gudhi::persistence_matrix::Default_options<column_type, true> {
+  using Index = std::uint32_t;
+  static const bool has_map_column_container = true;
+  static const bool has_removable_columns = true;  // WARN : idx will change if map is not true
+};
+
 template <class Matrix_options, class Boundary_matrix_type>
 class Persistence_backend_matrix {
  public:
@@ -228,7 +235,7 @@ class Persistence_backend_matrix {
 
   inline Barcode get_barcode() { return Barcode(matrix_, permutation_); }
 
-  inline std::size_t size() { return this->matrix_.get_number_of_columns(); }
+  inline std::size_t size() const { return this->matrix_.get_number_of_columns(); }
 
   inline friend std::ostream &operator<<(std::ostream &stream, Persistence_backend_matrix &structure) {
     stream << "[\n";

multipers/gudhi/naive_merge_tree.h

@@ -314,7 +314,7 @@ class Naive_merge_forest {
   struct Barcode {
     Barcode() {}
 
-    Barcode(int numberOfSimplices, int numberOfVertices)
+    Barcode(int numberOfSimplices, [[maybe_unused]] int numberOfVertices)
         : barcode_(numberOfSimplices), positionToBar_(numberOfSimplices), nextBarIndex_(0) {}
 
     friend void swap(Barcode &mf1, Barcode &mf2) {

multipers/gudhi/truc.h

@@ -6,6 +6,7 @@
 #include <algorithm>
 #include <boost/mpl/aux_/na_fwd.hpp>
 #include <cassert>
+#include <csignal>
 #include <cstddef>
 #include <cstdint>
 // #include <gudhi/Simplex_tree/multi_filtrations/Finitely_critical_filtrations.h>
@@ -116,6 +117,19 @@ class PresentationStructure {
     return idx;
   }
 
+  PresentationStructure permute(const std::vector<index_type> &order) const {
+    std::vector<std::vector<index_type>> new_generators(generators.size());
+    std::vector<int> new_generator_dimensions(generator_dimensions.size());
+    for (std::size_t i = 0; i < order.size(); i++) {
+      new_generators[i] = std::vector<index_type>(generators[order[i]].size());
+      for (std::size_t j = 0; j < generators[order[i]].size(); j++) {
+        new_generators[i][j] = order[generators[order[i]][j]];
+      }
+      new_generator_dimensions[i] = generator_dimensions[order[i]];
+    }
+    return PresentationStructure(new_generators, new_generator_dimensions);
+  }
+
  private:
   std::vector<std::vector<index_type>> generators;
   std::vector<int> generator_dimensions;
@@ -184,7 +198,7 @@ class SimplicialStructure {
 
   inline unsigned int max_dimension() const { return max_dimension_; }
 
-  int prune_above_dimension(int dim) { throw; }
+  int prune_above_dimension([[maybe_unused]] int dim) { throw "Not implemented"; }
 
  private:
   std::vector<std::vector<index_type>> boundaries;
@@ -238,18 +252,67 @@ class Truc {
     std::iota(generator_order.begin(), generator_order.end(), 0);  // range
   }
 
-  Truc() {};
-
-  Truc &operator=(const Truc &other) {
-    generator_filtration_values = other.generator_filtration_values;
-    generator_order = other.generator_order;
-    structure = other.structure;
-    persistence = other.persistence;
-    filtration_container = other.filtration_container;
+  Truc(const Truc &other)
+      : generator_filtration_values(other.generator_filtration_values),
+        generator_order(other.generator_order),
+        structure(other.structure),
+        filtration_container(other.filtration_container),
+        persistence(other.persistence) {
     persistence._update_permutation_ptr(generator_order);
+  }
+
+  Truc &operator=(Truc other) {
+    if (this != &other) {
+      generator_filtration_values = other.generator_filtration_values;
+      generator_order = other.generator_order;
+      structure = other.structure;
+      filtration_container = other.filtration_container;
+      persistence = other.persistence;
+      persistence._update_permutation_ptr(generator_order);
+    }
     return *this;
+  }
+
+  Truc() {};
+
+  inline bool dimension_order(const index_type &i, const index_type &j) const {
+    return structure.dimension(i) < structure.dimension(j);
+  };
+
+  inline bool colexical_order(const index_type &i, const index_type &j) const  {
+    if (structure.dimension(i) > structure.dimension(j)) return false;
+    if (structure.dimension(i) < structure.dimension(j)) return true;
+    if constexpr (MultiFiltration::is_multicritical())  // TODO : this may not be the best
+      throw "Not implemented in the multicritical case";
+
+    for (int idx = generator_filtration_values[i].num_parameters() - 1; idx >= 0; --idx) {
+      if (generator_filtration_values[i][idx] < generator_filtration_values[j][idx])
+        return true;
+      else if (generator_filtration_values[i][idx] > generator_filtration_values[j][idx])
+        return false;
+    }
+    return false;
   };
 
+
+  template <class Fun>
+  inline Truc rearange_sort(const Fun&& fun) const {
+    std::vector<index_type> permutation(generator_order.size());
+    std::iota(permutation.begin(), permutation.end(), 0);
+    std::sort(permutation.begin(), permutation.end(), [&](std::size_t i, std::size_t j) {
+      return fun(i, j);
+    });
+    std::vector<MultiFiltration> new_filtration(generator_filtration_values.size());
+    for (std::size_t i = 0; i < generator_filtration_values.size(); i++) {
+      new_filtration[i] = generator_filtration_values[permutation[i]];
+    }
+    return Truc(structure.permute(permutation), new_filtration);
+  }
+
+  Truc colexical_rearange() const {
+    return rearange_sort([this](std::size_t i, std::size_t j) { return this->colexical_order(i, j); });
+  }
+
   template <bool ignore_inf>
   std::vector<std::pair<int, std::vector<index_type>>> get_current_boundary_matrix() {
     std::vector<index_type> permutation(generator_order.size());
@@ -375,7 +438,7 @@ class Truc {
     return PersBackend(structure, out_gen_order);
   }
 
-  inline const bool has_persistence() { return this->persistence.size(); };
+  inline bool has_persistence() const { return this->persistence.size(); };
 
   inline void compute_persistence(const bool ignore_inf = true) {
     this->persistence = this->compute_persistence_out(
@@ -718,7 +781,7 @@ class Truc {
 
     inline TrucThread weak_copy() const { return TrucThread(*truc_ptr); }
 
-    inline const bool has_persistence() { return this->persistence.size(); };
+    inline bool has_persistence() const { return this->persistence.size(); };
 
     inline const PersBackend &get_persistence() const { return persistence; }
 
@@ -827,19 +890,23 @@ class Truc {
 
   // FOR Python interface, but I'm not fan. Todo: do the lambda function in
   // cython?
-  inline std::vector<split_barcode> persistence_on_lines(const std::vector<std::vector<value_type>> &basepoints) {
+  inline std::vector<split_barcode> persistence_on_lines(const std::vector<std::vector<value_type>> &basepoints,
+                                                         bool ignore_inf) {
     return barcodes(
         [](const std::vector<value_type> &basepoint) { return Gudhi::multi_persistence::Line<value_type>(basepoint); },
-        basepoints);
+        basepoints,
+        ignore_inf);
   }
 
   inline std::vector<split_barcode> persistence_on_lines(
-      const std::vector<std::pair<std::vector<value_type>, std::vector<value_type>>> &bp_dirs) {
+      const std::vector<std::pair<std::vector<value_type>, std::vector<value_type>>> &bp_dirs,
+      bool ignore_inf) {
     return barcodes(
         [](const std::pair<std::vector<value_type>, std::vector<value_type>> &bpdir) {
           return Gudhi::multi_persistence::Line<value_type>(bpdir.first, bpdir.second);
         },
-        bp_dirs);
+        bp_dirs,
+        ignore_inf);
   }
 
   void build_from_scc_file(const std::string &inFilePath,

multipers/io.pyx

@@ -15,7 +15,7 @@ cimport cython
 # from multipers.filtration_conversions cimport *
 # from multipers.mma_structures cimport boundary_matrix,float,pair,vector,intptr_t
 # cimport numpy as cnp
-
+current_doc_url = "https://davidlapous.github.io/multipers/"
 doc_soft_urls = {
         "mpfree":"https://bitbucket.org/mkerber/mpfree/",
         "multi_chunk":"",
@@ -27,6 +27,8 @@ doc_soft_easy_install = {
 ```sh
 git clone {doc_soft_urls["mpfree"]}
 cd mpfree
+cmake . --fresh
+make
 sudo cp mpfree /usr/bin/
 cd .. 
 rm -rf mpfree
@@ -36,6 +38,8 @@ rm -rf mpfree
 ```sh
 git clone {doc_soft_urls["multi_chunk"]}
 cd multi_chunk
+cmake . --fresh
+make
 sudo cp multi_chunk /usr/bin/
 cd .. 
 rm -rf multi_chunk
@@ -45,6 +49,8 @@ rm -rf multi_chunk
 ```sh
 git clone {doc_soft_urls["function_delaunay"]}
 cd function_delaunay
+cmake . --fresh
+make
 sudo cp main /usr/bin/function_delaunay
 cd ..
 rm -rf function_delaunay
@@ -65,7 +71,6 @@ doc_soft_easy_install = defaultdict(lambda:"<Unknown>", doc_soft_easy_install)
 
 available_reduce_softs = Literal["mpfree","multi_chunk","2pac"]
 
-
 def _path_init(soft:str|os.PathLike):
     a = which(f"./{soft}")
     b = which(f"{soft}")
@@ -222,12 +227,14 @@ def _init_external_softwares(requires=[]):
             if pathes[soft] is None:
                 global doc_soft_urls
                 raise ValueError(f"""
-Did not found {soft}.
+Did not find {soft}.
 Install it from {doc_soft_urls[soft]}, and put it in your current directory,
 or in you $PATH.
+Documentation is available here: {current_doc_url}compilation.html#external-libraries
 For instance:
 {doc_soft_easy_install[soft]}
                                  """)
+_init_external_softwares()
 def _check_available(soft:str):
     _init_external_softwares()
     return pathes.get(soft,None) is not None
@@ -255,8 +262,7 @@ def scc_reduce_from_str(
     backend: "mpfree", "multi_chunk" or "2pac"
     """
     global pathes, input_path, output_path
-    if pathes[backend] is None:
-        _init_external_softwares(requires=[backend])
+    assert _check_available(backend), f"Backend {backend} is not available."
 
 
     resolution_str = "--resolution" if full_resolution else ""
@@ -323,8 +329,7 @@ def scc_reduce_from_str_to_slicer(
     backend: "mpfree", "multi_chunk" or "2pac"
     """
     global pathes, input_path, output_path
-    if pathes[backend] is None:
-        _init_external_softwares(requires=[backend])
+    assert _check_available(backend), f"Backend {backend} is not available."
 
 
     resolution_str = "--resolution" if full_resolution else ""
@@ -443,8 +448,7 @@ def function_delaunay_presentation(
         id = str(threading.get_native_id())
     global input_path, output_path, pathes
     backend = "function_delaunay"
-    if  pathes[backend] is None :
-        _init_external_softwares(requires=[backend])
+    assert _check_available(backend), f"Backend {backend} is not available."
 
     to_write = np.concatenate([point_cloud, function_values.reshape(-1,1)], axis=1)
     np.savetxt(input_path+id,to_write,delimiter=' ')
@@ -492,8 +496,7 @@ def function_delaunay_presentation_to_slicer(
         id = str(threading.get_native_id())
     global input_path, output_path, pathes
     backend = "function_delaunay"
-    if  pathes[backend] is None :
-        _init_external_softwares(requires=[backend])
+    assert _check_available(backend), f"Backend {backend} is not available."
 
     to_write = np.concatenate([point_cloud, function_values.reshape(-1,1)], axis=1)
     np.savetxt(input_path+id,to_write,delimiter=' ')

multipers/ml/point_clouds.py

@@ -10,7 +10,7 @@ from tqdm import tqdm
 
 import multipers as mp
 import multipers.slicer as mps
-from multipers.ml.convolutions import DTM, KDE, available_kernels
+from multipers.filtrations.density import DTM, KDE, available_kernels
 
 
 class PointCloud2FilteredComplex(BaseEstimator, TransformerMixin):
@@ -176,7 +176,7 @@ class PointCloud2FilteredComplex(BaseEstimator, TransformerMixin):
         st = alpha_complex.create_simplex_tree(max_alpha_square=self._threshold**2)
         vertices = np.array([i for (i,), _ in st.get_skeleton(0)])
         new_points = np.asarray(
-            [alpha_complex.get_point(i) for i in vertices]
+            [alpha_complex.get_point(int(i)) for i in vertices]
         )  # Seems to be unsafe for some reason
         # new_points = x
         st = mp.simplex_tree_multi.SimplexTreeMulti(

multipers/ml/signed_measures.py

@@ -1,4 +1,4 @@
-from collections.abc import Callable, Iterable, Sequence
+from collections.abc import Iterable, Sequence
 from itertools import product
 from typing import Optional, Union
 
@@ -10,8 +10,8 @@ from tqdm import tqdm
 
 import multipers as mp
 from multipers.grids import compute_grid as reduce_grid
-from multipers.ml.convolutions import available_kernels, convolution_signed_measures
-from multipers.point_measure import signed_betti, rank_decomposition_by_rectangles
+from multipers.filtrations.density import available_kernels, convolution_signed_measures
+from multipers.point_measure import rank_decomposition_by_rectangles, signed_betti
 
 
 class FilteredComplex2SignedMeasure(BaseEstimator, TransformerMixin):

multipers/mma_structures.pyx

@@ -580,7 +580,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 +613,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)
@@ -1532,7 +1530,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 +1563,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)

multipers/mma_structures.pyx.tp

@@ -602,7 +602,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 +635,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)

multipers/multiparameter_module_approximation/approximation.h

@@ -2064,9 +2064,10 @@ 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();
+        i++;
       }
     }
   }
@@ -2080,9 +2081,10 @@ 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();
+        i++;
       }
     }
   }

multipers/multiparameter_module_approximation.pyx

@@ -89,7 +89,7 @@ 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,
@@ -166,6 +166,8 @@ def module_approximation(
         for i,m in enumerate(modules):
             mod.merge(m, input[i].minpres_degree)
         return mod
+    if len(input) == 0:
+        return PyModule_f64()
     if box is None:
         if is_simplextree_multi(input):
             box = input.filtration_bounds()

multipers/plots.py

@@ -254,7 +254,7 @@ def plot2d_PyModule(
     dimension=-1,
     separated=False,
     min_persistence=0,
-    alpha=1,
+    alpha=.8,
     verbose=False,
     save=False,
     dpi=200,