multipers 2.4.0b1__tar.gz → 2.4.2b1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multipers
-Version: 2.4.0b1
+Version: 2.4.2b1
 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.2b1}/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.2b1}/_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.2b1}/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.2b1}/multipers/_signed_measure_meta.py

@@ -162,7 +162,7 @@ def signed_measure(
             grid = filtered_complex.filtration_grid
 
     if mass_default is None:
-        mass_default = mass_default
+        pass
     elif isinstance(mass_default, str):
         if mass_default == "auto":
             mass_default = np.array([1.1 * np.max(f) - 0.1 * np.min(f) for f in grid])
@@ -228,7 +228,7 @@ def signed_measure(
                     zero_pad=fix_mass_default,
                     # grid_shape=tuple(len(g) for g in grid),
                     ignore_inf=ignore_infinite_filtration_values,
-                    verbose=verbose
+                    verbose=verbose,
                 )
                 fix_mass_default = False
                 if verbose:
@@ -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.2b1}/multipers/_slicer_meta.py

@@ -52,8 +52,7 @@ def _blocks2boundary_dimension_grades(
                 b[0] if len(b[0]) > 0 else np.empty((0, num_parameters))
                 for b in rblocks
             ),
-            dtype=filtration_type,
-        )
+        ).astype(filtration_type)
     boundary = tuple(x + S[i] for i, b in enumerate(rblocks) for x in b[1])
     dimensions = np.fromiter(
         (i for i, b in enumerate(rblocks) for _ in range(len(b[0]))), dtype=int
@@ -62,6 +61,7 @@ def _blocks2boundary_dimension_grades(
 
 
 def _slicer_from_simplextree(st, backend, vineyard):
+    backend = backend.lower() if isinstance(backend, str) else backend
     if vineyard:
         if backend == "matrix":
             slicer = mps._SlicerVineSimplicial(st)
@@ -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
@@ -176,7 +172,7 @@ def Slicer(
     else:
         vineyard = False if vineyard is None else vineyard
         column_type = "INTRUSIVE_SET" if column_type is None else column_type
-        backend = "Matrix" if backend is None else backend
+        backend = "matrix" if backend is None else backend
 
     _Slicer = mps.get_matrix_slicer(
         is_vineyard=vineyard,
@@ -193,7 +189,7 @@ def Slicer(
         return _Slicer()
     elif mps.is_slicer(st):
         slicer = _Slicer(st)
-    elif is_simplextree_multi(st) and backend == "Graph":
+    elif is_simplextree_multi(st) and backend == "graph":
         slicer = _slicer_from_simplextree(st, backend, vineyard)
         if st.is_squeezed:
             slicer.filtration_grid = st.filtration_grid
@@ -222,7 +218,9 @@ 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.2b1}/multipers/array_api/__init__.py

@@ -1,5 +1,5 @@
 import multipers.array_api.numpy as npapi
-
+available_api = [npapi]
 
 def api_from_tensor(x, *, verbose: bool = False, strict=False):
     if strict:

{multipers-2.4.0b1 → multipers-2.4.2b1}/multipers/array_api/numpy.py

@@ -24,8 +24,19 @@ searchsorted = _np.searchsorted
 LazyTensor = None
 abs = _np.abs
 exp = _np.exp
+log = _np.log
 sin = _np.sin
 cos = _np.cos
+matmul = _np.matmul
+einsum = _np.einsum
+
+
+def argsort(x, axis=-1):
+    return _np.argsort(x, axis=axis)
+
+
+def astype(x, dtype):
+    return astensor(x).astype(dtype=dtype)
 
 
 def clip(x, min=None, max=None):
@@ -122,3 +133,26 @@ def is_promotable(x):
 
 def has_grad(_):
     return False
+
+
+def to_device(x, device):
+    if device is None or str(device) in {"None", "cpu"}:
+        return x
+    raise ValueError(
+        f"NumPy backend only supports CPU tensors, requested device {device!r}."
+    )
+
+
+def size(x):
+    return int(_np.size(x))
+
+
+def dtype_is_float(dtype):
+    try:
+        return _np.issubdtype(_np.dtype(dtype), _np.floating)
+    except TypeError:
+        return False
+
+
+def dtype_default():
+    return _np.array(0.0).dtype

{multipers-2.4.0b1 → multipers-2.4.2b1}/multipers/array_api/torch.py

@@ -1,5 +1,9 @@
 import numpy as _np
 import torch as _t
+import multipers.array_api as _mpapi
+import sys
+
+_mpapi.available_api.append(sys.modules[__name__])
 
 backend = _t
 cat = _t.cat
@@ -23,8 +27,19 @@ LazyTensor = None
 relu = _t.relu
 abs = _t.abs
 exp = _t.exp
+log = _t.log
 sin = _t.sin
 cos = _t.cos
+matmul = _t.matmul
+einsum = _t.einsum
+
+
+def argsort(x, axis=-1):
+    return _t.argsort(x, dim=axis)
+
+
+def astype(x, dtype):
+    return astensor(x).type(dtype)
 
 
 _is_keops_available = None
@@ -34,7 +49,6 @@ def clip(x, min=None, max=None):
     return _t.clamp(x, min, max)
 
 
-
 def split_with_sizes(arr, sizes):
     return arr.split_with_sizes(sizes)
 
@@ -131,3 +145,21 @@ def is_promotable(x):
 
 def has_grad(x):
     return x.requires_grad
+
+
+def to_device(x, device):
+    if device is None:
+        return x
+    return x.to(device)
+
+
+def size(x):
+    return x.numel()
+
+
+def dtype_is_float(dtype):
+    return getattr(dtype, "is_floating_point", False)
+
+
+def dtype_default():
+    return _t.get_default_dtype()

{multipers-2.4.0b1 → multipers-2.4.2b1}/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()