multipers 2.3.3b6__cp310-cp310-macosx_11_0_arm64.whl

multipers/filtrations/filtrations.py

@@ -0,0 +1,361 @@
+from collections.abc import Sequence
+from typing import Optional
+from warnings import warn
+
+import gudhi as gd
+import numpy as np
+from numpy.typing import ArrayLike
+from scipy.spatial import KDTree
+
+from multipers.array_api import api_from_tensor, api_from_tensors
+from multipers.filtrations.density import DTM, available_kernels
+from multipers.grids import compute_grid
+from multipers.simplex_tree_multi import SimplexTreeMulti, SimplexTreeMulti_type
+
+try:
+    import pykeops
+
+    from multipers.filtrations.density import KDE
+except ImportError:
+    from sklearn.neighbors import KernelDensity
+
+    warn("pykeops not found. Falling back to sklearn.")
+
+    def KDE(bandwidth, kernel, return_log):
+        assert return_log, "Sklearn returns log-density."
+        return KernelDensity(bandwidth=bandwidth, kernel=kernel)
+
+
+def RipsLowerstar(
+    *,
+    points: Optional[ArrayLike] = None,
+    distance_matrix: Optional[ArrayLike] = None,
+    function: Optional[ArrayLike] = None,
+    threshold_radius: Optional[float] = None,
+):
+    """
+    Computes the Rips complex, with the usual rips filtration as a first parameter,
+    and the lower star multi filtration as other parameter.
+
+    Input:
+     - points or distance_matrix: ArrayLike
+     - function : ArrayLike of shape (num_data, num_parameters -1)
+     - threshold_radius:  max edge length of the rips. Defaults at min(max(distance_matrix, axis=1)).
+    """
+    assert (
+        points is not None or distance_matrix is not None
+    ), "`points` or `distance_matrix` has to be given."
+    if distance_matrix is None:
+        api = api_from_tensor(points)
+        points = api.astensor(points)
+        D = api.cdist(points, points)  # this may be slow...
+    else:
+        api = api_from_tensor(distance_matrix)
+        D = api.astensor(distance_matrix)
+
+    if threshold_radius is None:
+        threshold_radius = api.min(api.maxvalues(D, axis=1))
+    st = gd.SimplexTree.create_from_array(
+        api.asnumpy(D), max_filtration=threshold_radius
+    )
+    if function is None:
+        return SimplexTreeMulti(st, num_parameters=1)
+
+    function = api.astensor(function)
+    if function.ndim == 1:
+        function = function[:, None]
+    if function.ndim != 2:
+        raise ValueError(
+            f"""
+            `function.ndim` should be 0 or 1 . Got {function.ndim=}.{function=}
+            """
+        )
+    num_parameters = function.shape[1] + 1
+    st = SimplexTreeMulti(st, num_parameters=num_parameters)
+    for i in range(function.shape[1]):
+        st.fill_lowerstar(api.asnumpy(function[:, i]), parameter=1 + i)
+    if api.has_grad(D) or api.has_grad(function):
+        from multipers.grids import compute_grid
+
+        grid = compute_grid([D.ravel(), *[f for f in function.T]])
+        st = st.grid_squeeze(grid)
+    return st
+
+
+def RipsCodensity(
+    points: ArrayLike,
+    bandwidth: Optional[float] = None,
+    *,
+    return_log: bool = True,
+    dtm_mass: Optional[float] = None,
+    kernel: available_kernels = "gaussian",
+    threshold_radius: Optional[float] = None,
+):
+    """
+    Computes the Rips density filtration.
+    """
+    assert (
+        bandwidth is None or dtm_mass is None
+    ), "Density estimation is either via kernels or dtm."
+    if bandwidth is not None:
+        kde = KDE(bandwidth=bandwidth, kernel=kernel, return_log=return_log)
+        f = -kde.fit(points).score_samples(points)
+    elif dtm_mass is not None:
+        f = DTM(masses=[dtm_mass]).fit(points).score_samples(points)[0]
+    else:
+        raise ValueError("Bandwidth or DTM mass has to be given.")
+    return RipsLowerstar(points=points, function=f, threshold_radius=threshold_radius)
+
+
+def DelaunayLowerstar(
+    points: ArrayLike,
+    function: ArrayLike,
+    *,
+    distance_matrix: Optional[ArrayLike] = None,
+    threshold_radius: Optional[float] = None,
+    reduce_degree: int = -1,
+    vineyard: Optional[bool] = None,
+    dtype=np.float64,
+    verbose: bool = False,
+    clear: bool = True,
+    flagify: bool = False,
+):
+    """
+    Computes the Function Delaunay bifiltration. Similar to RipsLowerstar, but most suited for low-dimensional euclidean data.
+    See [Delaunay bifiltrations of functions on point clouds, Alonso et al] https://doi.org/10.1137/1.9781611977912.173
+
+    Input:
+     - points or distance_matrix: ArrayLike
+     - function : ArrayLike of shape (num_data, )
+     - threshold_radius:  max edge length of the rips. Defaults at min(max(distance_matrix, axis=1)).
+    """
+    from multipers.slicer import from_function_delaunay
+
+    if flagify and reduce_degree >= 0:
+        raise ValueError(
+            "Got {reduce_degree=} and {flagify=}. Cannot flagify with reduce degree."
+        )
+    assert distance_matrix is None, "Delaunay cannot be built from distance matrices"
+    if threshold_radius is not None:
+        raise NotImplementedError("Delaunay with threshold not implemented yet.")
+    api = api_from_tensors(points, function)
+    if not flagify and (api.has_grad(points) or api.has_grad(function)):
+        warn("Cannot keep points gradient unless using `flagify=True`.")
+    points = api.astensor(points)
+    function = api.astensor(function).squeeze()
+    assert (
+        function.ndim == 1
+    ), "Delaunay Lowerstar is only compatible with 1 additional parameter."
+    slicer = from_function_delaunay(
+        api.asnumpy(points),
+        api.asnumpy(function),
+        degree=reduce_degree,
+        vineyard=vineyard,
+        dtype=dtype,
+        verbose=verbose,
+        clear=clear,
+    )
+    if reduce_degree >= 0:
+        # Force resolution to avoid confusion with hilbert.
+        slicer = slicer.minpres(degree=reduce_degree, force=True)
+    if flagify:
+        from multipers.slicer import to_simplextree
+
+        slicer = to_simplextree(slicer)
+        slicer.flagify(2)
+
+        if api.has_grad(points) or api.has_grad(function):
+            distances = api.cdist(points, points) / 2
+            grid = compute_grid([distances.ravel(), function])
+            slicer = slicer.grid_squeeze(grid)
+            slicer = slicer._clean_filtration_grid()
+
+    return slicer
+
+
+def DelaunayCodensity(
+    points: ArrayLike,
+    bandwidth: Optional[float] = None,
+    *,
+    return_log: bool = True,
+    dtm_mass: Optional[float] = None,
+    kernel: available_kernels = "gaussian",
+    threshold_radius: Optional[float] = None,
+    reduce_degree: int = -1,
+    vineyard: Optional[bool] = None,
+    dtype=np.float64,
+    verbose: bool = False,
+    clear: bool = True,
+    flagify: bool = False,
+):
+    """
+    TODO
+    """
+    assert (
+        bandwidth is None or dtm_mass is None
+    ), "Density estimation is either via kernels or dtm."
+    if bandwidth is not None:
+        kde = KDE(bandwidth=bandwidth, kernel=kernel, return_log=return_log)
+        f = -kde.fit(points).score_samples(points)
+    elif dtm_mass is not None:
+        f = DTM(masses=[dtm_mass]).fit(points).score_samples(points)[0]
+    else:
+        raise ValueError("Bandwidth or DTM mass has to be given.")
+    return DelaunayLowerstar(
+        points=points,
+        function=f,
+        threshold_radius=threshold_radius,
+        reduce_degree=reduce_degree,
+        vineyard=vineyard,
+        dtype=dtype,
+        verbose=verbose,
+        clear=clear,
+        flagify=flagify,
+    )
+
+
+def Cubical(image: ArrayLike, **slicer_kwargs):
+    """
+    Computes the cubical filtration of an image.
+    The last axis dimention is interpreted as the number of parameters.
+
+    Input:
+     - image: ArrayLike of shape (*image_resolution, num_parameters)
+     - ** args : specify non-default slicer parameters
+    """
+    from multipers.slicer import from_bitmap
+
+    api = api_from_tensor(image)
+    image = api.astensor(image)
+    if api.has_grad(image):
+        img2 = image.reshape(-1, image.shape[-1]).T
+        grid = compute_grid(img2)
+        coord_img = np.empty(image.shape, dtype=np.int32)
+        slice_shape = image.shape[:-1]
+        for i in range(image.shape[-1]):
+            coord_img[..., i] = np.searchsorted(
+                api.asnumpy(grid[i]),
+                api.asnumpy(image[..., i]).reshape(-1),
+            ).reshape(slice_shape)
+        slicer = from_bitmap(coord_img, **slicer_kwargs)
+        slicer.filtration_grid = grid
+        return slicer
+
+    return from_bitmap(image, **slicer_kwargs)
+
+
+def DegreeRips(*, points=None, distance_matrix=None, ks=None, threshold_radius=None):
+    """
+    The DegreeRips filtration.
+    """
+
+    raise NotImplementedError("Use the default implentation ftm.")
+
+
+def CoreDelaunay(
+    points: ArrayLike,
+    *,
+    beta: float = 1.0,
+    ks: Optional[Sequence[int]] = None,
+    precision: str = "safe",
+    verbose: bool = False,
+    max_alpha_square: float = float("inf"),
+) -> SimplexTreeMulti_type:
+    """
+    Computes the Delaunay core bifiltration of a point cloud presented in the paper "Core Bifiltration" https://arxiv.org/abs/2405.01214, and returns the (multi-critical) bifiltration as a SimplexTreeMulti. The Delaunay core bifiltration is an alpha complex version of the core bifiltration which is smaller in size. Moreover, along the horizontal line k=1, the Delaunay core bifiltration is identical to the alpha complex.
+
+    Input:
+     - points: The point cloud as an ArrayLike of shape (n, d) where n is the number of points and d is the dimension of the points.
+     - beta: The beta parameter for the Delaunay Core Bifiltration (default 1.0).
+     - ks: The list of k-values to include in the bifiltration (default None). If None, the k-values are set to [1, 2, ..., n] where n is the number of points in the point cloud. For large point clouds, it is recommended to set ks to a smaller list of k-values to reduce computation time. The values in ks must all be integers, positive, and less than or equal to the number of points in the point cloud.
+     - precision: The precision of the computation of the AlphaComplex, one of ['safe', 'exact', 'fast'] (default 'safe'). See the GUDHI documentation for more information.
+     - verbose: Whether to print progress messages (default False).
+     - max_alpha_square: The maximum squared alpha value to consider when createing the alpha complex (default inf). See the GUDHI documentation for more information.
+    """
+    points = np.asarray(points)
+    if ks is None:
+        ks = np.arange(1, len(points) + 1)
+    else:
+        ks = np.asarray(ks, dtype=int)
+    ks: np.ndarray
+
+    assert len(ks) > 0, "The parameter ks must contain at least one value."
+    assert np.all(ks > 0), "All values in ks must be positive."
+    assert np.all(
+        ks <= len(points)
+    ), "All values in ks must be less than or equal to the number of points in the point cloud."
+    assert len(points) > 0, "The point cloud must contain at least one point."
+    assert points.ndim == 2, f"The point cloud must be a 2D array, got {points.ndim}D."
+    assert beta >= 0, f"The parameter beta must be positive, got {beta}."
+    assert precision in [
+        "safe",
+        "exact",
+        "fast",
+    ], f"""
+    The parameter precision must be one of ['safe', 'exact', 'fast'],
+    got {precision}.
+    """
+
+    if verbose:
+        print(
+            f"""Computing the Delaunay Core Bifiltration
+            of {len(points)} points in dimension {points.shape[1]}
+            with parameters:
+            """
+        )
+        print(f"\tbeta = {beta}")
+        print(f"\tks = {ks}")
+
+    if verbose:
+        print("Building the alpha complex...")
+    alpha_complex = gd.AlphaComplex(
+        points=points, precision=precision
+    ).create_simplex_tree(max_alpha_square=max_alpha_square)
+
+    if verbose:
+        print("Computing the k-nearest neighbor distances...")
+    knn_distances = KDTree(points).query(points, k=ks)[0]
+
+    max_dim = alpha_complex.dimension()
+    vertex_arrays_in_dimension = [[] for _ in range(max_dim + 1)]
+    squared_alphas_in_dimension = [[] for _ in range(max_dim + 1)]
+    for simplex, alpha_squared in alpha_complex.get_simplices():
+        dim = len(simplex) - 1
+        squared_alphas_in_dimension[dim].append(alpha_squared)
+        vertex_arrays_in_dimension[dim].append(simplex)
+
+    alphas_in_dimension = [
+        np.sqrt(np.array(alpha_squared, dtype=np.float64))
+        for alpha_squared in squared_alphas_in_dimension
+    ]
+    vertex_arrays_in_dimension = [
+        np.array(vertex_array, dtype=np.int32)
+        for vertex_array in vertex_arrays_in_dimension
+    ]
+
+    simplex_tree_multi = SimplexTreeMulti(
+        num_parameters=2, kcritical=True, dtype=np.float64
+    )
+
+    for dim, (vertex_array, alphas) in enumerate(
+        zip(vertex_arrays_in_dimension, alphas_in_dimension)
+    ):
+        num_simplices = len(vertex_array)
+        if verbose:
+            print(
+                f"""
+                Inserting {num_simplices} simplices of dimension {dim}
+                ({num_simplices * len(ks)} birth values)...
+                """
+            )
+        max_knn_distances = np.max(knn_distances[vertex_array], axis=1)
+        critical_radii = np.maximum(alphas[:, None], beta * max_knn_distances)
+        filtrations = np.stack(
+            (critical_radii, -ks * np.ones_like(critical_radii)), axis=-1
+        )
+        simplex_tree_multi.insert_batch(vertex_array.T, filtrations)
+
+    if verbose:
+        print("Done computing the Delaunay Core Bifiltration.")
+
+    return simplex_tree_multi

multipers/filtrations.pxd

@@ -0,0 +1,224 @@
+from libcpp.utility cimport pair
+from libcpp cimport bool
+from libcpp.vector cimport vector
+from libcpp cimport tuple
+from libc.stdint cimport uintptr_t,intptr_t
+from cpython cimport Py_buffer
+
+
+cdef extern from "gudhi/One_critical_filtration.h" namespace "Gudhi::multi_filtration":
+    cdef cppclass One_critical_filtration[T=*]:
+        ## Copied from cython vector
+        ctypedef size_t size_type
+        ctypedef ptrdiff_t difference_type
+        ctypedef T value_type
+
+        cppclass const_iterator
+        cppclass iterator:
+            iterator() except +
+            iterator(iterator&) except +
+            value_type& operator*()
+            iterator operator++()
+            iterator operator--()
+            iterator operator++(int)
+            iterator operator--(int)
+            iterator operator+(size_type)
+            iterator operator-(size_type)
+            difference_type operator-(iterator)
+            difference_type operator-(const_iterator)
+            bint operator==(iterator)
+            bint operator==(const_iterator)
+            bint operator!=(iterator)
+            bint operator!=(const_iterator)
+            bint operator<(iterator)
+            bint operator<(const_iterator)
+            bint operator>(iterator)
+            bint operator>(const_iterator)
+            bint operator<=(iterator)
+            bint operator<=(const_iterator)
+            bint operator>=(iterator)
+            bint operator>=(const_iterator)
+        cppclass const_iterator:
+            const_iterator() except +
+            const_iterator(iterator&) except +
+            const_iterator(const_iterator&) except +
+            operator=(iterator&) except +
+            const value_type& operator*()
+            const_iterator operator++()
+            const_iterator operator--()
+            const_iterator operator++(int)
+            const_iterator operator--(int)
+            const_iterator operator+(size_type)
+            const_iterator operator-(size_type)
+            difference_type operator-(iterator)
+            difference_type operator-(const_iterator)
+            bint operator==(iterator)
+            bint operator==(const_iterator)
+            bint operator!=(iterator)
+            bint operator!=(const_iterator)
+            bint operator<(iterator)
+            bint operator<(const_iterator)
+            bint operator>(iterator)
+            bint operator>(const_iterator)
+            bint operator<=(iterator)
+            bint operator<=(const_iterator)
+            bint operator>=(iterator)
+            bint operator>=(const_iterator)
+
+        cppclass const_reverse_iterator
+        cppclass reverse_iterator:
+            reverse_iterator() except +
+            reverse_iterator(reverse_iterator&) except +
+            value_type& operator*()
+            reverse_iterator operator++()
+            reverse_iterator operator--()
+            reverse_iterator operator++(int)
+            reverse_iterator operator--(int)
+            reverse_iterator operator+(size_type)
+            reverse_iterator operator-(size_type)
+            difference_type operator-(iterator)
+            difference_type operator-(const_iterator)
+            bint operator==(reverse_iterator)
+            bint operator==(const_reverse_iterator)
+            bint operator!=(reverse_iterator)
+            bint operator!=(const_reverse_iterator)
+            bint operator<(reverse_iterator)
+            bint operator<(const_reverse_iterator)
+            bint operator>(reverse_iterator)
+            bint operator>(const_reverse_iterator)
+            bint operator<=(reverse_iterator)
+            bint operator<=(const_reverse_iterator)
+            bint operator>=(reverse_iterator)
+            bint operator>=(const_reverse_iterator)
+        cppclass const_reverse_iterator:
+            const_reverse_iterator() except +
+            const_reverse_iterator(reverse_iterator&) except +
+            operator=(reverse_iterator&) except +
+            const value_type& operator*()
+            const_reverse_iterator operator++()
+            const_reverse_iterator operator--()
+            const_reverse_iterator operator++(int)
+            const_reverse_iterator operator--(int)
+            const_reverse_iterator operator+(size_type)
+            const_reverse_iterator operator-(size_type)
+            difference_type operator-(iterator)
+            difference_type operator-(const_iterator)
+            bint operator==(reverse_iterator)
+            bint operator==(const_reverse_iterator)
+            bint operator!=(reverse_iterator)
+            bint operator!=(const_reverse_iterator)
+            bint operator<(reverse_iterator)
+            bint operator<(const_reverse_iterator)
+            bint operator>(reverse_iterator)
+            bint operator>(const_reverse_iterator)
+            bint operator<=(reverse_iterator)
+            bint operator<=(const_reverse_iterator)
+            bint operator>=(reverse_iterator)
+            bint operator>=(const_reverse_iterator)
+        value_type& operator[](size_type)
+        #vector& operator=(vector&)
+        void assign(size_type, const value_type&)
+        void assign[InputIt](InputIt, InputIt) except +
+        value_type& at(size_type) except +
+        value_type& back()
+        iterator begin()
+        const_iterator const_begin "begin"()
+        const_iterator cbegin()
+        size_type capacity()
+        void clear() nogil
+        bint empty() nogil
+        iterator end()
+        const_iterator const_end "end"()
+        const_iterator cend()
+        iterator erase(iterator)
+        iterator erase(iterator, iterator)
+        value_type& front()
+        iterator insert(iterator, const value_type&) except +
+        iterator insert(iterator, size_type, const value_type&) except +
+        iterator insert[InputIt](iterator, InputIt, InputIt) except +
+        size_type max_size()
+        void pop_back()
+        void push_back(value_type&) except + nogil
+        reverse_iterator rbegin()
+        const_reverse_iterator const_rbegin "rbegin"()
+        const_reverse_iterator crbegin()
+        reverse_iterator rend()
+        const_reverse_iterator const_rend "rend"()
+        const_reverse_iterator crend()
+        void reserve(size_type) except + nogil
+        void resize(size_type) except + nogil
+        void resize(size_type, value_type&) except +
+        # size_type size()
+        size_type num_parameters() nogil
+        size_type num_generators() nogil
+        void swap(vector&)
+
+        # C++11 methods
+        value_type* data()
+        const value_type* const_data "data"()
+        void shrink_to_fit() except +
+        iterator emplace(const_iterator, ...) except +
+        value_type& emplace_back(...) except +
+
+        ## end of copied from cython vector
+
+        One_critical_filtration()  except + nogil
+        One_critical_filtration(vector[value_type]&) except + nogil
+        One_critical_filtration(One_critical_filtration&) except + nogil
+
+        One_critical_filtration(int) nogil
+        One_critical_filtration& operator=(const One_critical_filtration&) except +
+        @staticmethod
+        vector[value_type]& vector[value_type]() nogil
+        
+        void push_to_least_common_upper_bound(One_critical_filtration[T]&) nogil
+        void pull_to_greatest_common_lower_bound(One_critical_filtration[T]&) nogil
+
+        bool is_finite() nogil
+
+        
+cdef extern from "gudhi/Multi_critical_filtration.h" namespace "Gudhi::multi_filtration":
+    cdef cppclass Multi_critical_filtration[T=*]:
+        ctypedef size_t size_type
+        ctypedef One_critical_filtration[T] filtration_type
+        Multi_critical_filtration()  except + nogil
+        Multi_critical_filtration(One_critical_filtration[T]) except +
+        Multi_critical_filtration[T]& operator=(const Multi_critical_filtration[T]&) except +
+        size_t num_parameters() noexcept nogil
+        size_t num_generators() noexcept  nogil
+        void add_guaranteed_generator(One_critical_filtration[T]) nogil
+        void add_generator(One_critical_filtration[T]) nogil
+        void reserve(size_t) noexcept nogil
+        void simplify() nogil
+        void set_num_generators(size_t) nogil
+        One_critical_filtration[T]& operator[](int) nogil
+
+        void push_to_least_common_upper_bound(One_critical_filtration[T]&) except + nogil
+        void pull_to_greatest_common_lower_bound(One_critical_filtration[T]&) except + nogil
+
+cdef extern from "gudhi/Multi_persistence/Box.h" namespace "Gudhi::multi_persistence":
+    cdef cppclass Box[T=*]:
+        ctypedef vector[T] corner_type
+        Box()   except +
+        Box( vector[T]&,  vector[T]&) nogil 
+        Box( pair[vector[T], vector[T]]&) nogil  
+        void inflate(T)  nogil 
+        const One_critical_filtration[T]& get_lower_corner()  nogil 
+        const One_critical_filtration[T]& get_upper_corner()  nogil 
+        bool contains(vector[T]&)  nogil
+        pair[One_critical_filtration[T], One_critical_filtration[T]] get_bounding_corners() nogil
+
+cdef extern from "gudhi/Multi_persistence/Line.h" namespace "Gudhi::multi_persistence":
+    cdef cppclass Line[T=*]:
+        ctypedef One_critical_filtration[T] point_type
+        Line()   except + nogil
+        Line(One_critical_filtration[T]&)   except + nogil
+        Line(One_critical_filtration[T]&, One_critical_filtration[T]&)   except + nogil
+
+
+
+
+
+# ------ useful types:
+# ctypedef One_critical_filtration[float] Generator
+# ctypedef Multi_critical_filtration[float] kcritical

multipers/function_rips.pyx

@@ -0,0 +1,105 @@
+# cimport multipers.tensor as mt
+from libc.stdint cimport intptr_t, uint16_t, uint32_t, int32_t
+from libcpp.vector cimport vector
+from libcpp cimport bool, int, float
+from libcpp.utility cimport pair, tuple
+from typing import Optional,Iterable,Callable
+
+import numpy as np
+cimport numpy as cnp
+cnp.import_array()
+
+ctypedef double value_type 
+python_value_type=np.float64
+
+ctypedef int32_t indices_type # uint fails for some reason
+python_indices_type=np.int32
+
+ctypedef int32_t tensor_dtype
+python_tensor_dtype = np.int32
+
+ctypedef pair[vector[vector[indices_type]], vector[tensor_dtype]] signed_measure_type
+
+
+from multipers.simplex_tree_multi import SimplexTreeMulti_Ff64
+from gudhi.simplex_tree import SimplexTree
+
+cdef extern from "multi_parameter_rank_invariant/function_rips.h" namespace "Gudhi::multiparameter::function_rips":
+	void compute_function_rips_surface_python(const intptr_t, tensor_dtype* , const vector[indices_type], indices_type,indices_type, bool, bool, indices_type) except + nogil
+	signed_measure_type compute_function_rips_signed_measure_python(const intptr_t, tensor_dtype* , const vector[indices_type], indices_type,indices_type, bool, bool, indices_type) except + nogil
+	pair[vector[value_type],int] get_degree_rips_st_python(const intptr_t,const intptr_t, const vector[int]) except + nogil
+
+
+import multipers.grids as mpg
+
+
+
+def get_degree_rips(st, vector[int] degrees, grid_strategy="exact", resolution=0):
+	assert isinstance(st,SimplexTree), "Input has to be a Gudhi simplextree for now."
+	assert st.dimension() == 1, "Simplextree has to be of dimension 1. You can use the `prune_above_dimension` method."
+	degree_rips_st = SimplexTreeMulti_Ff64(num_parameters=degrees.size())
+	cdef intptr_t simplextree_ptr = st.thisptr
+	cdef intptr_t st_multi_ptr = degree_rips_st.thisptr
+	cdef pair[vector[value_type],int] out
+	with nogil:
+		out = get_degree_rips_st_python(simplextree_ptr, st_multi_ptr, degrees)
+	filtrations = np.asarray(out.first)
+	cdef int max_degree = out.second
+	cdef bool inf_flag = filtrations[-1] == np.inf
+	if inf_flag:
+		filtrations = filtrations[:-1]
+	filtrations, = mpg.compute_grid([filtrations],strategy=grid_strategy,resolution=resolution)
+	if inf_flag:
+		filtrations = np.concatenate([filtrations, [np.inf]])
+	degree_rips_st.grid_squeeze([filtrations]*degree_rips_st.num_parameters, inplace=True, coordinate_values=True)
+	degree_rips_st.filtration_grid = [filtrations, np.asarray(degrees)[::-1]]
+	degree_rips_st._is_function_simplextree=True
+	return degree_rips_st,max_degree
+
+def function_rips_surface(st_multi, vector[indices_type] homological_degrees, bool mobius_inversion=True, bool zero_pad=False, indices_type n_jobs=0):
+	assert st_multi.is_squeezed, "Squeeze first !"
+	cdef intptr_t st_multi_ptr = st_multi.thisptr
+	cdef indices_type I = len(st_multi.filtration_grid[0])
+	cdef indices_type J = st_multi.num_parameters
+	container_shape = (homological_degrees.size(),I,J)
+	container_array = np.ascontiguousarray(np.zeros(container_shape, dtype=python_tensor_dtype).flatten())
+	assert len(container_array) < np.iinfo(np.uint32).max, "Too large container. Raise an issue on github if you encounter this issue. (Due to tensor's operator[])"
+	cdef tensor_dtype[::1] container = container_array
+	cdef tensor_dtype* container_ptr = &container[0]
+	with nogil:
+		compute_function_rips_surface_python(st_multi_ptr,container_ptr, homological_degrees, I,J, mobius_inversion, zero_pad, n_jobs)
+	filtration_grid = st_multi.filtration_grid
+	if filtration_grid[0][-1] == np.inf:
+		filtration_grid[0][-1] = filtration_grid[0][-2]
+	return filtration_grid, container_array.reshape(container_shape)
+
+
+
+def function_rips_signed_measure(st_multi, vector[indices_type] homological_degrees, bool mobius_inversion=True, bool zero_pad=False, indices_type n_jobs=0, bool reconvert = True):
+	assert st_multi.is_squeezed
+	cdef intptr_t st_multi_ptr = st_multi.thisptr
+	cdef indices_type I = len(st_multi.filtration_grid[0])
+	cdef indices_type J = st_multi.num_parameters
+	container_shape = (homological_degrees.size(),I,J)
+	container_array = np.ascontiguousarray(np.zeros(container_shape, dtype=python_tensor_dtype).flatten())
+	assert len(container_array) < np.iinfo(np.uint32).max, "Too large container. Raise an issue on github if you encounter this issue. (Due to tensor's operator[])"
+	cdef tensor_dtype[::1] container = container_array
+	cdef tensor_dtype* container_ptr = &container[0]
+	cdef signed_measure_type out 
+	# TODO nogil
+	with nogil:
+		out = compute_function_rips_signed_measure_python(st_multi_ptr,container_ptr, homological_degrees, I,J, mobius_inversion, zero_pad, n_jobs)
+	pts, weights = np.asarray(out.first, dtype=int).reshape(-1, 3), np.asarray(out.second, dtype=int)
+
+	degree_indices = [np.argwhere(pts[:,0] == degree_index).flatten() for degree_index, degree in enumerate(homological_degrees)] ## TODO : maybe optimize
+	sms = [(pts[id,1:],weights[id]) for id in degree_indices]
+	if not reconvert: return sms
+
+	grid_conversion = st_multi.filtration_grid
+	for degree_index,(pts,weights) in enumerate(sms):
+		coords = np.empty(shape=pts.shape, dtype=float)
+		for i in range(coords.shape[1]):
+			coords[:,i] = np.asarray(grid_conversion[i])[pts[:,i]]
+		sms[degree_index]=(coords, weights)
+	
+	return sms