multipers 2.4.0b1__tar.gz → 2.4.1__tar.gz

{multipers-2.4.0b1 → multipers-2.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multipers
-Version: 2.4.0b1
+Version: 2.4.1
 Summary: Multiparameter Topological Persistence for Machine Learning
 Author-email: David Loiseaux <david.lapous@proton.me>, Hannah Schreiber <hannah.schreiber@inria.fr>
 Maintainer-email: David Loiseaux <david.lapous@proton.me>
@@ -86,11 +86,13 @@ This library features a bunch of different functions and helpers. See below for
  - [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.
- - [ ] [WIP] [[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] [WIP] [[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] [[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] [[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. 
  - [ ] [Backend only] [[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.

{multipers-2.4.0b1 → multipers-2.4.1}/README.md

@@ -48,11 +48,13 @@ This library features a bunch of different functions and helpers. See below for
  - [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.
- - [ ] [WIP] [[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] [WIP] [[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] [[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] [[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. 
  - [ ] [Backend only] [[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.

{multipers-2.4.0b1 → multipers-2.4.1}/_tempita_grid_gen.py

@@ -24,13 +24,13 @@ columns_name = [  # only one column is necessary
 ## Value types : CTYPE, PYTHON_TYPE, short
 value_types = [
     ("int32_t", "np.int32", "i32"),  # necessary
-    # ("int64_t", "np.int64",   "i64"),
-    # ("float",   "np.float32", "f32"),
+    ("int64_t", "np.int64",   "i64"),
+    ("float",   "np.float32", "f32"),
     ("double", "np.float64", "f64"),  # necessary
 ]
 COARSENNED_VALUE_TYPE = ("int32_t", "np.int32", "i32")
 REAL_VALUE_TYPE = ("double", "np.float64", "f64")
-
+assert COARSENNED_VALUE_TYPE in value_types and REAL_VALUE_TYPE in value_types
 
 ## True needed for MMA, and False is default value
 vineyards_values = [
@@ -52,7 +52,7 @@ matrix_types = [
     "Matrix",  # necessary
     # "Graph",
     # "Clement",
-    # "GudhiCohomology",
+    "GudhiCohomology",
 ]
 
 filtration_containers = [
@@ -88,11 +88,11 @@ def check_combination(
     if backend_type in ["Graph", "GudhiCohomology"]:
         if column_type[0] != 0:
             return False
-    if filtration_container == "flat":
+    if filtration_container == "Degree_rips_bifiltration":
         if not is_kcritical:
             return False
-        if value_type[0] == "f":
-            return False
+        # if value_type[-1][0] == "f": # needed for mma
+        #     return False
     return True
 
 
@@ -224,6 +224,8 @@ print("#----------------------")
 print("Slicers")
 print("#----------------------")
 print("#----------------------")
+print(*[s["PYTHON_TYPE"] for s in slicers], sep="\n")
+print("----------------------")
 print(*slicers, sep="\n")
 with open("build/tmp/_slicer_names.pkl", "wb") as f:
     pickle.dump(slicers, f)

{multipers-2.4.0b1 → multipers-2.4.1}/multipers/__init__.py

@@ -1,4 +1,5 @@
 from importlib.metadata import version as _version
+import sys
 
 __version__ = _version("multipers")
 # Doc
@@ -11,12 +12,16 @@ from multipers import (
     simplex_tree_multi,
     slicer,
 )
-from multipers._signed_measure_meta import signed_measure
+
+if sys.platform != "win32":
+    from multipers import ops
+
 
 # Shortcuts
 from multipers._slicer_meta import Slicer
 from multipers.multiparameter_module_approximation import module_approximation
 from multipers.simplex_tree_multi import SimplexTreeMulti
+from multipers._signed_measure_meta import signed_measure
 
 __all__ = [
     "data",
@@ -31,3 +36,6 @@ __all__ = [
     "module_approximation",
     "SimplexTreeMulti",
 ]
+
+if sys.platform != "win32":
+    __all__.append("ops")

{multipers-2.4.0b1 → multipers-2.4.1}/multipers/_signed_measure_meta.py

@@ -300,6 +300,7 @@ def signed_measure(
                 mass_default=mass_default,
                 degrees=degrees,
                 expand_collapse=expand_collapse,
+                n_jobs=n_jobs,
             )
             fix_mass_default = False
             if verbose:

{multipers-2.4.0b1 → multipers-2.4.1}/multipers/_slicer_meta.py

@@ -132,10 +132,6 @@ def Slicer(
      - `multipers.module_approximation(this, *args)`
      - `multipers.signed_measure(this, *args)`
 
-    Note : it is recommended and sometime required to apply
-        a minimal presentation before computing these functions !
-    `mp.slicer.minimal_presentation(slicer, *args, **kwargs)`
-
     Input
     -----
      - st : SimplexTreeMulti or scc-like blocks or path to scc file
@@ -222,7 +218,8 @@ You can try using `multipers.slicer.to_simplextree`."""
             filtration_container,
         )
     if reduce:
-        slicer = mps.minimal_presentation(
+        from multipers.ops import minimal_presentation
+        slicer = minimal_presentation(
             slicer,
             backend=reduce_backend,
             slicer_backend=backend,

{multipers-2.4.0b1 → multipers-2.4.1}/multipers/filtration_conversions.pxd

@@ -516,6 +516,158 @@ cdef inline vector[Flat_i32] python_2_vect_Flat_i32(int32_t[:,:] filtrations) no
           f[j] = filtrations[i,j]
         out.emplace_back(f)
     return out
+cdef inline KFlat_i64_2_python(KFlat_i64* x, bool copy=False, bool raw=False):
+  cdef Py_ssize_t k = dereference(x).num_generators()
+
+
+  cdef int num_parameters = 2
+
+  cdef int64_t[:] data_view = <int64_t[:k]>(&(dereference(x)(0,0)))
+  numpy_view = np.asarray(data_view, dtype=np.int64)
+  if raw:
+    return numpy_view
+  return np.concatenate([numpy_view[:,None], np.arange(k, dtype=np.int64)[:,None]], axis=1)
+
+
+cdef inline  vect_KFlat_i64_2_python(vector[KFlat_i64]& x, bool copy = False, bool raw=False):
+  cdef Py_ssize_t num_stuff = x.size()
+  return [KFlat_i64_2_python(&(x[i]), copy=copy, raw=raw) for i in range(num_stuff)]
+
+cdef inline KFlat_i64 python_2_KFlat_i64(int64_t[:,:] filtrations) noexcept nogil:
+    cdef vector[double] f = vector[double](filtrations.shape[0] * filtrations.shape[1])
+    cdef int k = 0;
+    for i in range(filtrations.shape[0]):
+        for j in range(filtrations.shape[1]):
+            f[k] = filtrations[i,j]
+            k = k + 1
+    cdef KFlat_i64 out = KFlat_i64(f.begin(), f.end(), filtrations.shape[1])
+    out.simplify()
+    return out
+
+cdef inline vector[KFlat_i64] python_2_vect_KFlat_i64(int64_t[:,:] filtrations) noexcept nogil:
+    # cdef double[:,:] filtrations = np.asarray(filtrations_, dtype=np.float64)
+    cdef vector[KFlat_i64] out
+    cdef vector[int64_t] f = vector[int64_t](filtrations.shape[1])
+    out.reserve(filtrations.shape[0])
+    for i in range(filtrations.shape[0]):
+        for j in range(filtrations.shape[1]):
+          f[j] = filtrations[i,j]
+        out.emplace_back(f)
+    return out
+cdef inline Flat_i64_2_python(Flat_i64* x, bool copy=False, bool raw=False):
+  cdef Py_ssize_t k = dereference(x).num_generators()
+
+
+  cdef int num_parameters = 2
+
+  cdef int64_t[:] data_view = <int64_t[:k]>(&(dereference(x)(0,0)))
+  numpy_view = np.asarray(data_view, dtype=np.int64)
+  if raw:
+    return numpy_view
+  return np.concatenate([numpy_view[:,None], np.arange(k, dtype=np.int64)[:,None]], axis=1)
+
+
+cdef inline  vect_Flat_i64_2_python(vector[Flat_i64]& x, bool copy = False, bool raw=False):
+  cdef Py_ssize_t num_stuff = x.size()
+  return [Flat_i64_2_python(&(x[i]), copy=copy, raw=raw) for i in range(num_stuff)]
+
+
+
+cdef inline Flat_i64 python_2_Flat_i64(int64_t[:] filtration) noexcept nogil:
+  cdef int num_parameters = filtration.shape[0]
+  cdef Flat_i64 out = Flat_i64(num_parameters) 
+  cdef int64_t* x
+  for i in range(num_parameters):
+    x = &out(0,i)
+    x[0] = filtration[i]
+  return out
+
+cdef inline vector[Flat_i64] python_2_vect_Flat_i64(int64_t[:,:] filtrations) noexcept nogil:
+    # cdef double[:,:] filtrations = np.asarray(filtrations_, dtype=np.float64)
+    cdef vector[Flat_i64] out
+    cdef vector[int64_t] f = vector[int64_t](filtrations.shape[1])
+    out.reserve(filtrations.shape[0])
+    for i in range(filtrations.shape[0]):
+        for j in range(filtrations.shape[1]):
+          f[j] = filtrations[i,j]
+        out.emplace_back(f)
+    return out
+cdef inline KFlat_f32_2_python(KFlat_f32* x, bool copy=False, bool raw=False):
+  cdef Py_ssize_t k = dereference(x).num_generators()
+
+
+  cdef int num_parameters = 2
+
+  cdef float[:] data_view = <float[:k]>(&(dereference(x)(0,0)))
+  numpy_view = np.asarray(data_view, dtype=np.float32)
+  if raw:
+    return numpy_view
+  return np.concatenate([numpy_view[:,None], np.arange(k, dtype=np.float32)[:,None]], axis=1)
+
+
+cdef inline  vect_KFlat_f32_2_python(vector[KFlat_f32]& x, bool copy = False, bool raw=False):
+  cdef Py_ssize_t num_stuff = x.size()
+  return [KFlat_f32_2_python(&(x[i]), copy=copy, raw=raw) for i in range(num_stuff)]
+
+cdef inline KFlat_f32 python_2_KFlat_f32(float[:,:] filtrations) noexcept nogil:
+    cdef vector[double] f = vector[double](filtrations.shape[0] * filtrations.shape[1])
+    cdef int k = 0;
+    for i in range(filtrations.shape[0]):
+        for j in range(filtrations.shape[1]):
+            f[k] = filtrations[i,j]
+            k = k + 1
+    cdef KFlat_f32 out = KFlat_f32(f.begin(), f.end(), filtrations.shape[1])
+    out.simplify()
+    return out
+
+cdef inline vector[KFlat_f32] python_2_vect_KFlat_f32(float[:,:] filtrations) noexcept nogil:
+    # cdef double[:,:] filtrations = np.asarray(filtrations_, dtype=np.float64)
+    cdef vector[KFlat_f32] out
+    cdef vector[float] f = vector[float](filtrations.shape[1])
+    out.reserve(filtrations.shape[0])
+    for i in range(filtrations.shape[0]):
+        for j in range(filtrations.shape[1]):
+          f[j] = filtrations[i,j]
+        out.emplace_back(f)
+    return out
+cdef inline Flat_f32_2_python(Flat_f32* x, bool copy=False, bool raw=False):
+  cdef Py_ssize_t k = dereference(x).num_generators()
+
+
+  cdef int num_parameters = 2
+
+  cdef float[:] data_view = <float[:k]>(&(dereference(x)(0,0)))
+  numpy_view = np.asarray(data_view, dtype=np.float32)
+  if raw:
+    return numpy_view
+  return np.concatenate([numpy_view[:,None], np.arange(k, dtype=np.float32)[:,None]], axis=1)
+
+
+cdef inline  vect_Flat_f32_2_python(vector[Flat_f32]& x, bool copy = False, bool raw=False):
+  cdef Py_ssize_t num_stuff = x.size()
+  return [Flat_f32_2_python(&(x[i]), copy=copy, raw=raw) for i in range(num_stuff)]
+
+
+
+cdef inline Flat_f32 python_2_Flat_f32(float[:] filtration) noexcept nogil:
+  cdef int num_parameters = filtration.shape[0]
+  cdef Flat_f32 out = Flat_f32(num_parameters) 
+  cdef float* x
+  for i in range(num_parameters):
+    x = &out(0,i)
+    x[0] = filtration[i]
+  return out
+
+cdef inline vector[Flat_f32] python_2_vect_Flat_f32(float[:,:] filtrations) noexcept nogil:
+    # cdef double[:,:] filtrations = np.asarray(filtrations_, dtype=np.float64)
+    cdef vector[Flat_f32] out
+    cdef vector[float] f = vector[float](filtrations.shape[1])
+    out.reserve(filtrations.shape[0])
+    for i in range(filtrations.shape[0]):
+        for j in range(filtrations.shape[1]):
+          f[j] = filtrations[i,j]
+        out.emplace_back(f)
+    return out
 cdef inline KFlat_f64_2_python(KFlat_f64* x, bool copy=False, bool raw=False):
   cdef Py_ssize_t k = dereference(x).num_generators()
 
@@ -663,6 +815,148 @@ cdef inline vector[Contiguous_i32] python_2_vect_Contiguous_i32(int32_t[:,:] fil
           f[j] = filtrations[i,j]
         out.emplace_back(f)
     return out
+cdef inline KContiguous_i64_2_python(KContiguous_i64* x, bool copy=False, bool raw=False):
+  cdef Py_ssize_t k = dereference(x).num_generators()
+
+
+  cdef Py_ssize_t p = dereference(x).num_parameters()
+  if dereference(x).is_finite():
+    duplicate = 0
+  else:
+    duplicate = p
+  # TODO  : make it contiguous
+  return [_ff21cview2_i64(&(dereference(x)(i,0)), p, duplicate, copy=copy) for i in range(k)]
+
+
+cdef inline  vect_KContiguous_i64_2_python(vector[KContiguous_i64]& x, bool copy = False, bool raw=False):
+  cdef Py_ssize_t num_stuff = x.size()
+  return [KContiguous_i64_2_python(&(x[i]), copy=copy, raw=raw) for i in range(num_stuff)]
+
+cdef inline KContiguous_i64 python_2_KContiguous_i64(int64_t[:,:] filtrations) noexcept nogil:
+    cdef vector[double] f = vector[double](filtrations.shape[0] * filtrations.shape[1])
+    cdef int k = 0;
+    for i in range(filtrations.shape[0]):
+        for j in range(filtrations.shape[1]):
+            f[k] = filtrations[i,j]
+            k = k + 1
+    cdef KContiguous_i64 out = KContiguous_i64(f.begin(), f.end(), filtrations.shape[1])
+    out.simplify()
+    return out
+
+cdef inline vector[KContiguous_i64] python_2_vect_KContiguous_i64(int64_t[:,:] filtrations) noexcept nogil:
+    # cdef double[:,:] filtrations = np.asarray(filtrations_, dtype=np.float64)
+    cdef vector[KContiguous_i64] out
+    cdef vector[int64_t] f = vector[int64_t](filtrations.shape[1])
+    out.reserve(filtrations.shape[0])
+    for i in range(filtrations.shape[0]):
+        for j in range(filtrations.shape[1]):
+          f[j] = filtrations[i,j]
+        out.emplace_back(f)
+    return out
+# Assumes it's contiguous
+cdef inline Contiguous_i64_2_python(Contiguous_i64* x, bool copy=False, bool raw=False):
+  cdef Py_ssize_t num_parameters = dereference(x).num_parameters()
+  if not dereference(x).is_finite():
+    return np.full(shape=num_parameters, fill_value=dereference(x)(0,0))
+  cdef int64_t[:] x_view = <int64_t[:num_parameters]>(&(dereference(x)(0,0)))
+  return np.array(x_view) if copy else np.asarray(x_view)
+
+cdef inline  vect_Contiguous_i64_2_python(vector[Contiguous_i64]& x, bool copy = False, bool raw=False):
+  cdef Py_ssize_t num_stuff = x.size()
+  return [Contiguous_i64_2_python(&(x[i]), copy=copy, raw=raw) for i in range(num_stuff)]
+
+
+
+cdef inline Contiguous_i64 python_2_Contiguous_i64(int64_t[:] filtration) noexcept nogil:
+  cdef int num_parameters = filtration.shape[0]
+  cdef Contiguous_i64 out = Contiguous_i64(num_parameters) 
+  cdef int64_t* x
+  for i in range(num_parameters):
+    x = &out(0,i)
+    x[0] = filtration[i]
+  return out
+
+cdef inline vector[Contiguous_i64] python_2_vect_Contiguous_i64(int64_t[:,:] filtrations) noexcept nogil:
+    # cdef double[:,:] filtrations = np.asarray(filtrations_, dtype=np.float64)
+    cdef vector[Contiguous_i64] out
+    cdef vector[int64_t] f = vector[int64_t](filtrations.shape[1])
+    out.reserve(filtrations.shape[0])
+    for i in range(filtrations.shape[0]):
+        for j in range(filtrations.shape[1]):
+          f[j] = filtrations[i,j]
+        out.emplace_back(f)
+    return out
+cdef inline KContiguous_f32_2_python(KContiguous_f32* x, bool copy=False, bool raw=False):
+  cdef Py_ssize_t k = dereference(x).num_generators()
+
+
+  cdef Py_ssize_t p = dereference(x).num_parameters()
+  if dereference(x).is_finite():
+    duplicate = 0
+  else:
+    duplicate = p
+  # TODO  : make it contiguous
+  return [_ff21cview2_f32(&(dereference(x)(i,0)), p, duplicate, copy=copy) for i in range(k)]
+
+
+cdef inline  vect_KContiguous_f32_2_python(vector[KContiguous_f32]& x, bool copy = False, bool raw=False):
+  cdef Py_ssize_t num_stuff = x.size()
+  return [KContiguous_f32_2_python(&(x[i]), copy=copy, raw=raw) for i in range(num_stuff)]
+
+cdef inline KContiguous_f32 python_2_KContiguous_f32(float[:,:] filtrations) noexcept nogil:
+    cdef vector[double] f = vector[double](filtrations.shape[0] * filtrations.shape[1])
+    cdef int k = 0;
+    for i in range(filtrations.shape[0]):
+        for j in range(filtrations.shape[1]):
+            f[k] = filtrations[i,j]
+            k = k + 1
+    cdef KContiguous_f32 out = KContiguous_f32(f.begin(), f.end(), filtrations.shape[1])
+    out.simplify()
+    return out
+
+cdef inline vector[KContiguous_f32] python_2_vect_KContiguous_f32(float[:,:] filtrations) noexcept nogil:
+    # cdef double[:,:] filtrations = np.asarray(filtrations_, dtype=np.float64)
+    cdef vector[KContiguous_f32] out
+    cdef vector[float] f = vector[float](filtrations.shape[1])
+    out.reserve(filtrations.shape[0])
+    for i in range(filtrations.shape[0]):
+        for j in range(filtrations.shape[1]):
+          f[j] = filtrations[i,j]
+        out.emplace_back(f)
+    return out
+# Assumes it's contiguous
+cdef inline Contiguous_f32_2_python(Contiguous_f32* x, bool copy=False, bool raw=False):
+  cdef Py_ssize_t num_parameters = dereference(x).num_parameters()
+  if not dereference(x).is_finite():
+    return np.full(shape=num_parameters, fill_value=dereference(x)(0,0))
+  cdef float[:] x_view = <float[:num_parameters]>(&(dereference(x)(0,0)))
+  return np.array(x_view) if copy else np.asarray(x_view)
+
+cdef inline  vect_Contiguous_f32_2_python(vector[Contiguous_f32]& x, bool copy = False, bool raw=False):
+  cdef Py_ssize_t num_stuff = x.size()
+  return [Contiguous_f32_2_python(&(x[i]), copy=copy, raw=raw) for i in range(num_stuff)]
+
+
+
+cdef inline Contiguous_f32 python_2_Contiguous_f32(float[:] filtration) noexcept nogil:
+  cdef int num_parameters = filtration.shape[0]
+  cdef Contiguous_f32 out = Contiguous_f32(num_parameters) 
+  cdef float* x
+  for i in range(num_parameters):
+    x = &out(0,i)
+    x[0] = filtration[i]
+  return out
+
+cdef inline vector[Contiguous_f32] python_2_vect_Contiguous_f32(float[:,:] filtrations) noexcept nogil:
+    # cdef double[:,:] filtrations = np.asarray(filtrations_, dtype=np.float64)
+    cdef vector[Contiguous_f32] out
+    cdef vector[float] f = vector[float](filtrations.shape[1])
+    out.reserve(filtrations.shape[0])
+    for i in range(filtrations.shape[0]):
+        for j in range(filtrations.shape[1]):
+          f[j] = filtrations[i,j]
+        out.emplace_back(f)
+    return out
 cdef inline KContiguous_f64_2_python(KContiguous_f64* x, bool copy=False, bool raw=False):
   cdef Py_ssize_t k = dereference(x).num_generators()
 

{multipers-2.4.0b1 → multipers-2.4.1}/multipers/filtrations/filtrations.py

@@ -259,7 +259,7 @@ def DegreeRips(
     num=None,
     squeeze_strategy="exact",
     squeeze_resolution=None,
-    squeeze=True,
+    squeeze=False,
 ):
     """
     The DegreeRips filtration.