multipers 2.2.3__cp311-cp311-win_amd64.whl

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

multipers/grids.pyx

@@ -0,0 +1,350 @@
+
+from libc.stdint cimport intptr_t, int32_t, int64_t
+from libcpp cimport bool,int,long, float
+
+cimport numpy as cnp
+import numpy as np
+cnp.import_array()
+
+
+from typing import Iterable,Literal,Optional
+from itertools import product
+
+
+available_strategies = ["regular","regular_closest", "regular_left", "partition", "quantile", "precomputed"]
+Lstrategies = Literal["regular","regular_closest", "regular_left", "partition", "quantile", "precomputed"]
+
+ctypedef fused some_int:
+    int32_t
+    int64_t
+    int
+    long
+
+ctypedef fused some_float:
+    float
+    double
+
+
+def compute_grid(
+        x,
+        resolution:Optional[int|Iterable[int]]=None, 
+        strategy:Lstrategies="exact", 
+        bool unique=True, 
+        some_float _q_factor=1., 
+        drop_quantiles=[0,0],
+        bool dense = False,
+        ):
+    """
+    Computes a grid from filtration values, using some strategy.
+
+    Input
+    -----
+    
+    - `filtrations_values`: `Iterable[filtration of parameter for parameter]`
+       where `filtration_of_parameter` is a array[float, ndim=1]
+     - `resolution`:Optional[int|tuple[int]]
+     - `strategy`: either exact, regular, regular_closest, regular_left, partition, quantile, or precomputed.
+     - `unique`: if true, doesn't repeat values in the output grid.
+     - `drop_quantiles` : drop some filtration values according to these quantiles
+    Output
+    ------
+
+    Iterable[array[float, ndim=1]] : the 1d-grid for each parameter.
+    """
+
+    from multipers.slicer import is_slicer
+    from multipers.simplex_tree_multi import is_simplextree_multi
+    from multipers.mma_structures import is_mma
+
+    if resolution is not None and strategy == "exact":
+        raise ValueError("The 'exact' strategy does not support resolution.")
+    if strategy != "exact":
+        assert resolution is not None, "A resolution is required for non-exact strategies"
+
+
+    cdef bool is_numpy_compatible = True
+    if is_slicer(x):
+        initial_grid = x.get_filtrations_values().T
+    elif is_simplextree_multi(x):
+        initial_grid = x.get_filtration_grid()
+    elif is_mma(x):
+        initial_grid = x.get_filtration_values()
+    elif isinstance(x, np.ndarray):
+        initial_grid = x
+    else:
+        x = tuple(x)
+        if len(x) == 0: return []
+        first = x[0]
+        ## is_sm, i.e., iterable tuple(pts,weights)
+        if isinstance(x[0], tuple) and getattr(x[0][0], "shape", None) is not None:
+            initial_grid = tuple(f[0].T for f in x)
+            if isinstance(initial_grid[0], np.ndarray):
+                initial_grid = np.concatenate(initial_grid, axis=1)
+            else:
+                is_numpy_compatbile = False
+                import torch
+                assert isinstance(first[0], torch.Tensor), "Only numpy and torch are supported ftm."
+                initial_grid = torch.cat(initial_grid, axis=1)
+        ## is grid-like (num_params, num_pts)
+        elif isinstance(first,list) or isinstance(first, tuple) or isinstance(first, np.ndarray):
+            initial_grid = tuple(f for f in x)
+        else:
+            is_numpy_compatible = False
+            import torch
+            assert isinstance(first, torch.Tensor), "Only numpy and torch are supported ftm."
+            initial_grid = x
+    if is_numpy_compatible:
+        return _compute_grid_numpy(
+        initial_grid,
+        resolution=resolution, 
+        strategy = strategy, 
+        unique = unique, 
+        _q_factor=_q_factor, 
+        drop_quantiles=drop_quantiles,
+        dense = dense,
+        )
+    from multipers.torch.diff_grids import get_grid
+    return get_grid(strategy)(initial_grid,resolution)
+
+
+
+
+
+
+def _compute_grid_numpy(
+        filtrations_values,
+        resolution=None, 
+        strategy:Lstrategies="exact", 
+        bool unique=True, 
+        some_float _q_factor=1., 
+        drop_quantiles=[0,0],
+        bool dense = False,
+        ):
+    """
+    Computes a grid from filtration values, using some strategy.
+
+    Input
+    -----
+     - `filtrations_values`: `Iterable[filtration of parameter for parameter]`
+       where `filtration_of_parameter` is a array[float, ndim=1]
+     - `resolution`:Optional[int|tuple[int]]
+     - `strategy`: either exact, regular, regular_closest, regular_left, partition, quantile, or precomputed.
+     - `unique`: if true, doesn't repeat values in the output grid.
+     - `drop_quantiles` : drop some filtration values according to these quantiles
+    Output
+    ------
+    Iterable[array[float, ndim=1]] : the 1d-grid for each parameter.
+    """
+    num_parameters = len(filtrations_values)
+    if resolution is None and strategy not in ["exact", "precomputed"]:
+        raise ValueError("Resolution must be provided for this strategy.")
+    elif resolution is not None:
+        try:
+            int(resolution)
+            resolution = [resolution]*num_parameters
+        except:
+            pass
+    try:
+        a,b=drop_quantiles
+    except:
+        a,b=drop_quantiles,drop_quantiles
+
+    if a != 0 or b != 0:
+        boxes = np.asarray([np.quantile(filtration, [a, b], axis=1, method='closest_observation') for filtration in filtrations_values])
+        min_filtration, max_filtration = np.min(boxes, axis=(0,1)), np.max(boxes, axis=(0,1)) # box, birth/death, filtration
+        filtrations_values = [
+                filtration[(m<filtration) * (filtration <M)] 
+                for filtration, m,M in zip(filtrations_values, min_filtration, max_filtration)
+                ]
+
+    to_unique = lambda f : np.unique(f) if isinstance(f,np.ndarray) else f.unique()
+    ## match doesn't work with cython BUG
+    if strategy == "exact":
+        F=tuple(to_unique(f) for f in filtrations_values)
+    elif strategy == "quantile":
+        F = tuple(to_unique(f) for f in filtrations_values)
+        max_resolution = [min(len(f),r) for f,r in zip(F,resolution)]
+        F = tuple( np.quantile(f, q=np.linspace(0,1,num=int(r*_q_factor)), axis=0, method='closest_observation') for f,r in zip(F, resolution) )
+        if unique:
+            F = tuple(to_unique(f) for f in F)
+            if np.all(np.asarray(max_resolution) > np.asarray([len(f) for f in F])):
+                return _compute_grid_numpy(filtrations_values=filtrations_values, resolution=resolution, strategy="quantile",_q_factor=1.5*_q_factor)
+    elif strategy == "regular":
+        F = tuple(np.linspace(np.min(f),np.max(f),num=r, dtype=np.asarray(f).dtype) for f,r in zip(filtrations_values, resolution))
+    elif strategy == "regular_closest":
+        F = tuple(_todo_regular_closest(f,r, unique) for f,r in zip(filtrations_values, resolution))
+    elif strategy == "regular_left":
+        F = tuple(_todo_regular_left(f,r, unique) for f,r in zip(filtrations_values, resolution))
+    elif strategy == "torch_regular_closest":
+        F = tuple(_torch_regular_closest(f,r, unique) for f,r in zip(filtrations_values, resolution))
+    elif strategy == "partition":
+        F = tuple(_todo_partition(f,r, unique) for f,r in zip(filtrations_values, resolution))
+    elif strategy == "precomputed":
+        F=filtrations_values
+    else:
+        raise ValueError(f"Invalid strategy {strategy}. Pick something in {available_strategies}.")
+    if dense:
+        return todense(F)
+    return F
+
+def todense(grid, bool product_order=False):
+    if len(grid) == 0:
+        return np.empty(0)
+    if not isinstance(grid[0], np.ndarray):
+        import torch
+        assert isinstance(grid[0], torch.Tensor)
+        from multipers.torch.diff_grids import todense
+        return todense(grid)
+    dtype = grid[0].dtype
+    if product_order:
+        return np.fromiter(product(*grid), dtype=np.dtype((dtype, len(grid))), count=np.prod([len(f) for f in grid]))
+    mesh = np.meshgrid(*grid)
+    coordinates = np.concatenate(tuple(stuff.ravel()[:,None] for stuff in mesh), axis=1, dtype=dtype)
+    return coordinates
+
+
+
+## TODO : optimize. Pykeops ?
+def _todo_regular_closest(some_float[:] f, int r, bool unique):
+    f_array = np.asarray(f)
+    f_regular = np.linspace(np.min(f), np.max(f),num=r, dtype=f_array.dtype)
+    f_regular_closest = np.asarray([f[<long>np.argmin(np.abs(f_array-f_regular[i]))] for i in range(r)])
+    if unique: f_regular_closest = np.unique(f_regular_closest)
+    return f_regular_closest
+
+def _todo_regular_left(some_float[:] f, int r, bool unique):
+    sorted_f = np.sort(f)
+    f_regular = np.linspace(sorted_f[0],sorted_f[-1],num=r, dtype=sorted_f.dtype)
+    f_regular_closest = sorted_f[np.searchsorted(sorted_f,f_regular)]
+    if unique: f_regular_closest = np.unique(f_regular_closest)
+    return f_regular_closest
+
+def _torch_regular_closest(f, int r, bool unique=True):
+    import torch
+    f_regular = torch.linspace(f.min(),f.max(), r, dtype=f.dtype)
+    f_regular_closest =torch.tensor([f[(f-x).abs().argmin()] for x in f_regular]) 
+    if unique: f_regular_closest = f_regular_closest.unique()
+    return f_regular_closest
+
+def _todo_partition(some_float[:] data,int resolution, bool unique):
+    if data.shape[0] < resolution: resolution=data.shape[0]
+    k = data.shape[0] // resolution
+    partitions = np.partition(data, k)
+    f = partitions[[i*k for i in range(resolution)]]
+    if unique: f= np.unique(f)
+    return f
+
+
+def compute_bounding_box(stuff, inflate = 0.):
+    r"""
+    Returns a array of shape (2, num_parameters)
+    such that for any filtration value $y$ of something in stuff,
+    then if (x,z) is the output of this function, we have
+    $x\le y \le z$.
+    """
+    box = np.array(compute_grid(stuff,strategy="regular",resolution=2)).T
+    if inflate:
+        box[0] -= inflate
+        box[1] += inflate
+    return box
+
+def push_to_grid(some_float[:,:] points, grid, bool return_coordinate=False):
+    """
+    Given points and a grid (list of one parameter grids),
+    pushes the points onto the grid.
+    """
+    num_points, num_parameters = points.shape[0], points.shape[1]
+    cdef cnp.ndarray[long,ndim=2] coordinates = np.empty((num_points, num_parameters),dtype=np.int64)
+    for parameter in range(num_parameters):
+        coordinates[:,parameter] = np.searchsorted(grid[parameter],points[:,parameter])
+    if return_coordinate:
+        return coordinates
+    out = np.empty((num_points,num_parameters), grid[0].dtype)
+    for parameter in range(num_parameters):
+        out[:,parameter] = grid[parameter][coordinates[:,parameter]]
+    return out
+
+
+def coarsen_points(some_float[:,:] points, strategy="exact", int resolution=-1, bool coordinate=False):
+    grid = _compute_grid_numpy(points.T, strategy=strategy, resolution=resolution)
+    if coordinate:
+        return push_to_grid(points, grid, coordinate), grid
+    return push_to_grid(points, grid, coordinate)
+
+
+
+def evaluate_in_grid(pts, grid, mass_default=None):
+    """    
+    Input
+    -----
+     - pts: of the form array[int, ndim=2]
+     - grid of the form Iterable[array[float, ndim=1]]
+    """
+    first_filtration = grid[0]
+    dtype = first_filtration.dtype
+    if isinstance(first_filtration, np.ndarray):
+        if mass_default is not None:
+            grid = tuple(np.concatenate([g, [m]]) for g,m in zip(grid, mass_default))
+        def empty_like(x):
+            return np.empty_like(x, dtype=dtype)
+    else: 
+        import torch
+        # assert isinstance(first_filtration, torch.Tensor), f"Invalid grid type. Got {type(grid[0])}, expected numpy or torch array."
+        if mass_default is not None:
+            grid = tuple(torch.cat([g, torch.tensor(m)[None]]) for g,m in zip(grid, mass_default))
+        def empty_like(x):
+            return torch.empty(x.shape,dtype=dtype)
+
+    coords= empty_like(pts)
+    for i in range(coords.shape[1]):
+        coords[:,i] = grid[i][pts[:,i]]
+    return coords
+
+def sm_in_grid(pts, weights, grid, int num_parameters=-1, mass_default=None):
+    """Given a measure whose points are coordinates,
+    pushes this measure in this grid.
+    Input
+    -----
+     - pts: of the form array[int, ndim=2]
+     - weights: array[int, ndim=1]
+     - grid of the form Iterable[array[float, ndim=1]]
+     - num_parameters: number of parameters
+    """
+    first_filtration = grid[0]
+    dtype = first_filtration.dtype
+    def to_int(x):
+        return np.asarray(x,dtype=np.int64)
+    if isinstance(first_filtration, np.ndarray):
+        if mass_default is not None:
+            grid = tuple(np.concatenate([g, [m]]) for g,m in zip(grid, mass_default))
+        def empty_like(x, weights):
+            return np.empty_like(x, dtype=dtype), np.asarray(weights)
+    else: 
+        import torch
+        # assert isinstance(first_filtration, torch.Tensor), f"Invalid grid type. Got {type(grid[0])}, expected numpy or torch array."
+        if mass_default is not None:
+            grid = tuple(torch.cat([g, torch.tensor(m)[None]]) for g,m in zip(grid, mass_default))
+        def empty_like(x, weights):
+            return torch.empty(x.shape,dtype=dtype), torch.from_numpy(weights)
+
+    pts = to_int(pts)
+    coords,weights = empty_like(pts,weights)
+    for i in range(coords.shape[1]):
+        if num_parameters > 0:
+            coords[:,i] = grid[i%num_parameters][pts[:,i]]
+        else:
+            coords[:,i] = grid[i][pts[:,i]]
+    return (coords, weights)
+
+# TODO : optimize with memoryviews / typing
+def sms_in_grid(sms, grid, int num_parameters=-1, mass_default=None):
+    """Given a measure whose points are coordinates,
+    pushes this measure in this grid.
+    Input
+    -----
+     - sms: of the form (signed_measure_like for num_measures)
+       where signed_measure_like = tuple(array[int, ndim=2], array[int])
+     - grid of the form Iterable[array[float, ndim=1]]
+    """
+    sms = tuple(sm_in_grid(pts,weights,grid=grid,num_parameters=num_parameters, mass_default=mass_default) for pts,weights in sms)
+    return sms