multipers 2.3.3b6__cp313-cp313-win_amd64.whl → 2.3.3b7__cp313-cp313-win_amd64.whl

multipers/_signed_measure_meta.py

@@ -279,10 +279,6 @@ def signed_measure(
                     ignore_inf=ignore_infinite_filtration_values,
                 )
                 fix_mass_default = False
-
-                if "hook" in invariant:
-                    from multipers.point_measure import rectangle_to_hook_minimal_signed_barcode
-                    sms = [rectangle_to_hook_minimal_signed_barcode(pts,w) for pts,w in sms]
                 if verbose:
                     print("Done.")
             elif filtered_complex_.is_minpres:
@@ -345,9 +341,6 @@ def signed_measure(
                 expand_collapse=expand_collapse,
             )
             fix_mass_default = False
-            if "hook" in invariant:
-                from multipers.point_measure import rectangle_to_hook_minimal_signed_barcode
-                sms = [rectangle_to_hook_minimal_signed_barcode(pts,w) for pts,w in sms]
             if verbose:
                 print("Done.")
         elif len(degrees) == 1 and degrees[0] is None:
@@ -420,6 +413,10 @@ def signed_measure(
         sms = zero_out_sms(sms, mass_default=mass_default)
         if verbose:
             print("Done.")
+
+    if invariant == "hook":
+        from multipers.point_measure import rectangle_to_hook_minimal_signed_barcode
+        sms = [rectangle_to_hook_minimal_signed_barcode(pts,w) for pts,w in sms]
     if plot:
         plot_signed_measures(sms)
     return sms

multipers/array_api/__init__.py

@@ -1,7 +1,15 @@
 import multipers.array_api.numpy as npapi
 
 
-def api_from_tensor(x, *, verbose: bool = False):
+def api_from_tensor(x, *, verbose: bool = False, strict=False):
+    if strict:
+        if npapi.is_tensor(x):
+            return npapi
+        import multipers.array_api.torch as torchapi
+
+        if torchapi.is_tensor(x):
+            return torchapi
+        raise ValueError(f"Unsupported (strict) type {type(x)=}")
     if npapi.is_promotable(x):
         if verbose:
             print("using numpy backend")
@@ -43,3 +51,12 @@ def api_from_tensors(*args):
 def to_numpy(x):
     api = api_from_tensor(x)
     return api.asnumpy(x)
+
+
+def check_keops():
+    import os
+
+    if os.name == "nt":
+        # see https://github.com/getkeops/keops/pull/421
+        return False
+    return npapi.check_keops()

multipers/array_api/numpy.py

@@ -19,10 +19,69 @@ max = _np.max
 repeat_interleave = _np.repeat
 cdist = cdist  # type: ignore[no-redef]
 unique = _np.unique
+inf = _np.inf
+searchsorted = _np.searchsorted
+LazyTensor = None
+
+# Test keops
+_is_keops_available = None
+
+
+def check_keops():
+    global _is_keops_available, LazyTensor
+    if _is_keops_available is not None:
+        return _is_keops_available
+    import pykeops.numpy as pknp
+    from pykeops.numpy import LazyTensor as LT
+
+    formula = "SqNorm2(x - y)"
+    var = ["x = Vi(3)", "y = Vj(3)"]
+    expected_res = _np.array([63.0, 90.0])
+    x = _np.arange(1, 10).reshape(-1, 3).astype("float32")
+    y = _np.arange(3, 9).reshape(-1, 3).astype("float32")
+
+    my_conv = pknp.Genred(formula, var)
+    try:
+        _is_keops_available = _np.allclose(my_conv(x, y).flatten(), expected_res)
+        LazyTensor = LT
+    except:
+        from warnings import warn
+
+        warn("Could not initialize keops (numpy). using workarounds")
+        _is_keops_available = False
+
+    return _is_keops_available
+
+
+def from_numpy(x):
+    return _np.asarray(x)
+
+
+def ascontiguous(x):
+    return _np.ascontiguousarray(x)
+
+
+def sort(x, axis=-1):
+    return _np.sort(x, axis=axis)
+
+
+def device(x):  # type: ignore[no-unused-arg]
+    return None
+
+
+# type: ignore[no-unused-arg]
+def linspace(low, high, r, device=None, dtype=None):
+    return _np.linspace(low, high, r, dtype=dtype)
+
+
+def cartesian_product(*arrays, dtype=None):
+    mesh = _np.meshgrid(*arrays, indexing="ij")
+    coordinates = _np.stack(mesh, axis=-1).reshape(-1, len(arrays)).astype(dtype)
+    return coordinates
 
 
 def quantile_closest(x, q, axis=None):
-    return _np.quantile(x, q, axis=axis, interpolation="closest_observation")
+    return _np.quantile(x, q, axis=axis, method="closest_observation")
 
 
 def minvalues(x: _np.ndarray, **kwargs):
@@ -33,6 +92,10 @@ def maxvalues(x: _np.ndarray, **kwargs):
     return _np.max(x, **kwargs)
 
 
+def is_tensor(x):
+    return isinstance(x, _np.ndarray)
+
+
 def is_promotable(x):
     return isinstance(x, _np.ndarray | list | tuple)
 

multipers/array_api/torch.py

@@ -15,6 +15,60 @@ zeros = _t.zeros
 min = _t.min
 max = _t.max
 repeat_interleave = _t.repeat_interleave
+linspace = _t.linspace
+cartesian_product = _t.cartesian_prod
+inf = _t.inf
+searchsorted = _t.searchsorted
+LazyTensor = None
+
+
+_is_keops_available = None
+
+
+def check_keops():
+    global _is_keops_available, LazyTensor
+    if _is_keops_available is not None:
+        return _is_keops_available
+    try:
+        import pykeops.torch as pknp
+        from pykeops.torch import LazyTensor as LT
+
+        formula = "SqNorm2(x - y)"
+        var = ["x = Vi(3)", "y = Vj(3)"]
+        expected_res = _t.tensor([63.0, 90.0])
+        x = _t.arange(1, 10, dtype=_t.float32).view(-1, 3)
+        y = _t.arange(3, 9, dtype=_t.float32).view(-1, 3)
+
+        my_conv = pknp.Genred(formula, var)
+        _is_keops_available = _t.allclose(
+            my_conv(x, y).view(-1), _t.tensor(expected_res).type(_t.float32)
+        )
+        LazyTensor = LT
+
+    except:
+        from warnings import warn
+
+        warn("Could not initialize keops (torch). using workarounds")
+
+        _is_keops_available = False
+
+    return _is_keops_available
+
+
+def from_numpy(x):
+    return _t.from_numpy(x)
+
+
+def ascontiguous(x):
+    return _t.as_tensor(x).contiguous()
+
+
+def device(x):
+    return x.device
+
+
+def sort(x, axis=-1):
+    return _t.sort(x, dim=axis).values
 
 
 # in our context, this allows to get a correct gradient.
@@ -28,10 +82,10 @@ def unique(x, assume_sorted=False, _mean=True):
     _, c = _t.unique(x, sorted=True, return_counts=True)
     if _mean:
         x = _t.segment_reduce(data=x, reduce="mean", lengths=c, unsafe=True, axis=0)
-        return x
-
-    c = _np.concatenate([[0], _np.cumsum(c[:-1])])
-    return x[c]
+    else:
+        c = _np.concatenate([[0], _np.cumsum(c[:-1])])
+        x = x[c]
+    return x
 
 
 def quantile_closest(x, q, axis=None):
@@ -50,6 +104,10 @@ def asnumpy(x):
     return x.detach().numpy()
 
 
+def is_tensor(x):
+    return isinstance(x, _t.Tensor)
+
+
 def is_promotable(x):
     return isinstance(x, _t.Tensor)
 

multipers/filtrations/density.py

@@ -1,9 +1,10 @@
 from collections.abc import Callable, Iterable
 from typing import Any, Literal, Union
+
 import numpy as np
 
+from multipers.array_api import api_from_tensor, api_from_tensors
 
-from multipers.array_api import api_from_tensor
 global available_kernels
 available_kernels = Union[
     Literal[
@@ -176,23 +177,24 @@ def _pts_convolution_pykeops(
     Pykeops convolution
     """
     if isinstance(pts, np.ndarray):
-        _asarray_weights = lambda x : np.asarray(x, dtype=pts.dtype)
+        _asarray_weights = lambda x: np.asarray(x, dtype=pts.dtype)
         _asarray_grid = _asarray_weights
     else:
         import torch
-        _asarray_weights = lambda x : torch.from_numpy(x).type(pts.dtype)
-        _asarray_grid = lambda x : x.type(pts.dtype)
+
+        _asarray_weights = lambda x: torch.from_numpy(x).type(pts.dtype)
+        _asarray_grid = lambda x: x.type(pts.dtype)
     kde = KDE(kernel=kernel, bandwidth=bandwidth, **more_kde_args)
-    return kde.fit(
-        pts, sample_weights=_asarray_weights(pts_weights)
-    ).score_samples(_asarray_grid(grid_iterator))
+    return kde.fit(pts, sample_weights=_asarray_weights(pts_weights)).score_samples(
+        _asarray_grid(grid_iterator)
+    )
 
 
 def gaussian_kernel(x_i, y_j, bandwidth):
     D = x_i.shape[-1]
     exponent = -(((x_i - y_j) / bandwidth) ** 2).sum(dim=-1) / 2
     # float is necessary for some reason (pykeops fails)
-    kernel = (exponent).exp() / float((bandwidth*np.sqrt(2 * np.pi))**D) 
+    kernel = (exponent).exp() / float((bandwidth * np.sqrt(2 * np.pi)) ** D)
     return kernel
 
 
@@ -359,49 +361,6 @@ class KDE:
         )
 
 
-def batch_signed_measure_convolutions(
-    signed_measures,  # array of shape (num_data,num_pts,D)
-    x,  # array of shape (num_x, D) or (num_data, num_x, D)
-    bandwidth,  # either float or matrix if multivariate kernel
-    kernel: available_kernels,
-):
-    """
-    Input
-    -----
-     - signed_measures: unragged, of shape (num_data, num_pts, D+1)
-       where last coord is weights, (0 for dummy points)
-     - x : the points to convolve (num_x,D)
-     - bandwidth : the bandwidths or covariance matrix inverse or ... of the kernel
-     - kernel : "gaussian", "multivariate_gaussian", "exponential", or Callable (x_i, y_i, bandwidth)->float
-
-    Output
-    ------
-    Array of shape (num_convolutions, (num_axis), num_data,
-    Array of shape (num_convolutions, (num_axis), num_data, max_x_size)
-    """
-    if signed_measures.ndim == 2:
-        signed_measures = signed_measures[None, :, :]
-    sms = signed_measures[..., :-1]
-    weights = signed_measures[..., -1]
-    if isinstance(signed_measures, np.ndarray):
-        from pykeops.numpy import LazyTensor
-    else:
-        import torch
-
-        assert isinstance(signed_measures, torch.Tensor)
-        from pykeops.torch import LazyTensor
-
-    _sms = LazyTensor(sms[..., None, :].contiguous())
-    _x = x[..., None, :, :].contiguous()
-
-    sms_kernel = _kernel(kernel)(_sms, _x, bandwidth)
-    out = (sms_kernel * weights[..., None, None].contiguous()).sum(
-        signed_measures.ndim - 2
-    )
-    assert out.shape[-1] == 1, "Pykeops bug fixed, TODO : refix this "
-    out = out[..., 0]  ## pykeops bug + ensures its a tensor
-    # assert out.shape == (x.shape[0], x.shape[1]), f"{x.shape=}, {out.shape=}"
-    return out
 
 
 class DTM:
@@ -532,7 +491,7 @@ class KNNmean:
 
         # Symbolic distance matrix:
         if self.metric == "euclidean":
-            D_ij = ((X_i - X_j) ** 2).sum(-1) ** (1/2)
+            D_ij = ((X_i - X_j) ** 2).sum(-1) ** (1 / 2)
         elif self.metric == "manhattan":
             D_ij = (X_i - X_j).abs().sum(-1)
         elif self.metric == "angular":

multipers/grids.pyx

@@ -11,6 +11,7 @@ from typing import Iterable,Literal,Optional
 from itertools import product
 from multipers.array_api import api_from_tensor, api_from_tensors
 from multipers.array_api import numpy as npapi
+from multipers.array_api import check_keops
 
 available_strategies = ["regular","regular_closest", "regular_left", "partition", "quantile", "precomputed"]
 Lstrategies = Literal["regular","regular_closest", "regular_left", "partition", "quantile", "precomputed"]
@@ -168,39 +169,39 @@ def _compute_grid_numpy(
     Iterable[array[float, ndim=1]] : the 1d-grid for each parameter.
     """
     num_parameters = len(filtrations_values)
+    api = api_from_tensors(filtrations_values)
     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
+        boxes = api.astensor([api.quantile_closest(filtration, [a, b], axis=1) for filtration in filtrations_values])
+        min_filtration, max_filtration = api.minvalues(boxes, axis=(0,1)), api.maxvalues(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)
+        F=tuple(api.unique(f) for f in filtrations_values)
     elif strategy == "quantile":
-        F = tuple(to_unique(f) for f in filtrations_values)
+        F = tuple(api.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) )
+        F = tuple( api.quantile_closest(f, q=np.linspace(0,1,num=int(r*_q_factor)), axis=0) for f,r in zip(F, resolution) )
         if unique:
-            F = tuple(to_unique(f) for f in F)
+            F = tuple(api.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))
+        F = tuple(_todo_regular(f,r,api) 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))
+        F = tuple(_todo_regular_closest(f,r, unique,api) 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))
+        F = tuple(_todo_regular_left(f,r, unique,api) 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":
@@ -214,41 +215,75 @@ def _compute_grid_numpy(
 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
+    api = api_from_tensors(grid)
+    # if product_order:
+    #     if not api.backend ==np:
+    #         raise NotImplementedError("only numpy here.")
+    #     return np.fromiter(product(*grid), dtype=np.dtype((dtype, len(grid))), count=np.prod([len(f) for f in grid]))
+    return api.cartesian_product(*grid)
+    # 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.stack(mesh, axis=-1).reshape(-1, len(grid)).astype(dtype)
+    # return coordinates
 
 
 
 ## TODO : optimize. Pykeops ?
-def _todo_regular_closest(some_float[:] f, int r, bool unique):
+def _todo_regular(f, int r, api):
+    with api.no_grad():
+        return api.linspace(api.min(f), api.max(f), r)
+
+def _project_on_1d_grid(f,grid, bool unique, api):
+    # api=api_from_tensors(f,grid)
+    if f.ndim != 1:
+        raise ValueError(f"Got ndim!=1. {f=}")
+    f = api.unique(f)
+    with api.no_grad():
+        _f = api.LazyTensor(f[:, None, None])
+        _f_reg = api.LazyTensor(grid[None, :, None])
+        indices = (_f - _f_reg).abs().argmin(0).ravel()
+    f = api.cat([f, api.tensor([api.inf], dtype=f.dtype)])
+    f_proj = f[indices]
+    if unique:
+        f_proj = api.unique(f_proj)
+    return f_proj
+
+def _todo_regular_closest_keops(f, int r, bool unique, api):
+    f = api.astensor(f)
+    with api.no_grad():
+        f_regular = api.linspace(api.min(f), api.max(f), r, device = api.device(f),dtype=f.dtype)
+    return _project_on_1d_grid(f,f_regular,unique,api)
+
+def _todo_regular_closest_old(some_float[:] f, int r, bool unique, api=None):
     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[<int64_t>np.argmin(np.abs(f_array-f_regular[i]))] for i in range(r)])
+    f_regular_closest = np.asarray([f[<int64_t>np.argmin(np.abs(f_array-f_regular[i]))] for i in range(r)], dtype=f_array.dtype)
     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):
+def _todo_regular_left(f, int r, bool unique,api):
+    sorted_f = api.sort(f)
+    with api.no_grad():
+        f_regular = api.linspace(sorted_f[0],sorted_f[-1],r, dtype=sorted_f.dtype, device=api.device(sorted_f))
+        idx=api.searchsorted(sorted_f,f_regular)
+    f_regular_closest = sorted_f[idx]
+    if unique: f_regular_closest = api.unique(f_regular_closest)
+    return f_regular_closest
+
+def _todo_regular_left_old(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]
@@ -259,6 +294,12 @@ def _todo_partition(some_float[:] data,int resolution, bool unique):
     return f
 
 
+if check_keops():
+    _todo_regular_closest = _todo_regular_closest_keops
+else:
+    _todo_regular_closest = _todo_regular_closest_old
+
+
 def compute_bounding_box(stuff, inflate = 0.):
     r"""
     Returns a array of shape (2, num_parameters)

multipers/ml/signed_measures.py

@@ -9,12 +9,107 @@ from sklearn.base import BaseEstimator, TransformerMixin
 from tqdm import tqdm
 
 import multipers as mp
-from multipers.array_api import api_from_tensor
+from multipers.array_api import api_from_tensor, api_from_tensors
 from multipers.filtrations.density import available_kernels, convolution_signed_measures
-from multipers.grids import compute_grid
+from multipers.grids import compute_grid, todense
 from multipers.point_measure import rank_decomposition_by_rectangles, signed_betti
 
 
+def batch_signed_measure_convolutions(
+    signed_measures,  # array of shape (num_data,num_pts,D)
+    x,  # array of shape (num_x, D) or (num_data, num_x, D)
+    bandwidth,  # either float or matrix if multivariate kernel
+    kernel: available_kernels,
+    api=None,
+):
+    """
+    Input
+    -----
+     - signed_measures: unragged, of shape (num_data, num_pts, D+1)
+       where last coord is weights, (0 for dummy points)
+     - x : the points to convolve (num_x,D)
+     - bandwidth : the bandwidths or covariance matrix inverse or ... of the kernel
+     - kernel : "gaussian", "multivariate_gaussian", "exponential", or Callable (x_i, y_i, bandwidth)->float
+
+    Output
+    ------
+    Array of shape (num_convolutions, (num_axis), num_data,
+    Array of shape (num_convolutions, (num_axis), num_data, max_x_size)
+    """
+    from multipers.filtrations.density import _kernel
+
+    if api is None:
+        api = api_from_tensors(signed_measures, x)
+    if signed_measures.ndim == 2:
+        signed_measures = signed_measures[None, :, :]
+    sms = signed_measures[..., :-1]
+    weights = signed_measures[..., -1]
+    _sms = api.LazyTensor(api.ascontiguous(sms[..., None, :]))
+    _x = api.ascontiguous(x[..., None, :, :])
+
+    sms_kernel = _kernel(kernel)(_sms, _x, bandwidth)
+    out = (sms_kernel * api.ascontiguous(weights[..., None, None])).sum(
+        signed_measures.ndim - 2
+    )
+    assert out.shape[-1] == 1, "Pykeops bug fixed, TODO : refix this "
+    out = out[..., 0]  ## pykeops bug + ensures its a tensor
+    # assert out.shape == (x.shape[0], x.shape[1]), f"{x.shape=}, {out.shape=}"
+    return out
+
+
+def sm2deep(signed_measure, api=None):
+    if api is None:
+        api = api_from_tensor(signed_measure[0])
+    dirac_positions, dirac_signs = signed_measure
+    dtype = dirac_positions.dtype
+    new_shape = list(dirac_positions.shape)
+    new_shape[1] += 1
+    c = api.empty(new_shape, dtype=dtype)
+    c[:, :-1] = dirac_positions
+    c[:, -1] = api.astensor(dirac_signs)
+    return c
+
+
+def deep_unrag(sms, api=None):
+    if api is None:
+        api = api_from_tensor(sms[0][0])
+    num_sm = len(sms)
+    if num_sm == 0:
+        return api.tensor([])
+    first = sms[0][0]
+    num_parameters = first.shape[1]
+    dtype = first.dtype
+    deep_sms = tuple(sm2deep(sm, api=api) for sm in sms)
+    max_num_pts = np.max([sm[0].shape[0] for sm in sms])
+    unragged_sms = api.zeros((num_sm, max_num_pts, num_parameters + 1), dtype=dtype)
+
+    for data in range(num_sm):
+        sm = deep_sms[data]
+        a, b = sm.shape
+        unragged_sms[data, :a, :b] = sm
+    return unragged_sms
+
+
+def sm_convolution(
+    sms,
+    grid,
+    bandwidth,
+    kernel: available_kernels = "gaussian",
+    plot: bool = False,
+    **plt_kwargs,
+):
+    dense_grid = todense(grid)
+    api = api_from_tensors(sms[0][0], dense_grid)
+    sms = deep_unrag(sms, api=api)
+    convs = batch_signed_measure_convolutions(
+        sms, dense_grid, bandwidth, kernel, api=api
+    ).reshape(sms.shape[0], *(len(g) for g in grid))
+    if plot:
+        from multipers.plots import plot_surfaces
+        plot_surfaces((grid, convs), **plt_kwargs)
+    return convs
+
+
 class FilteredComplex2SignedMeasure(BaseEstimator, TransformerMixin):
     """
     Input
@@ -547,27 +642,6 @@ def rescale_sparse_signed_measure(
     return out
 
 
-def sm2deep(signed_measure):
-    dirac_positions, dirac_signs = signed_measure
-    dtype = dirac_positions.dtype
-    new_shape = list(dirac_positions.shape)
-    new_shape[1] += 1
-    if isinstance(dirac_positions, np.ndarray):
-        c = np.empty(new_shape, dtype=dtype)
-        c[:, :-1] = dirac_positions
-        c[:, -1] = dirac_signs
-
-    else:
-        import torch
-
-        c = torch.empty(new_shape, dtype=dtype)
-        c[:, :-1] = dirac_positions
-        if isinstance(dirac_signs, np.ndarray):
-            dirac_signs = torch.from_numpy(dirac_signs)
-        c[:, -1] = dirac_signs
-    return c
-
-
 class SignedMeasureFormatter(BaseEstimator, TransformerMixin):
     """
     Input
@@ -759,7 +833,9 @@ class SignedMeasureFormatter(BaseEstimator, TransformerMixin):
                 self._filtrations_bounds.append(filtration_bounds)
                 self._normalization_factors.append(normalization_factors)
             self._filtrations_bounds = self._backend.astensor(self._filtrations_bounds)
-            self._normalization_factors = self._backend.astensor(self._normalization_factors)
+            self._normalization_factors = self._backend.astensor(
+                self._normalization_factors
+            )
             # else:
             #     (
             #         self._filtrations_bounds,
@@ -784,9 +860,11 @@ class SignedMeasureFormatter(BaseEstimator, TransformerMixin):
             ]
             # axis, filtration_values
             filtration_values = [
-                self._backend.astensor(compute_grid(
-                    f_ax.T, resolution=self.resolution, strategy=self.grid_strategy
-                ))
+                self._backend.astensor(
+                    compute_grid(
+                        f_ax.T, resolution=self.resolution, strategy=self.grid_strategy
+                    )
+                )
                 for f_ax in filtration_values
             ]
             self._infered_grids = filtration_values

multipers/mma_structures.pyx

@@ -751,7 +751,7 @@ cdef class PyModule_f64:
               axs = [plt.gca()]
             for image, degree, i in zip(image_vector, degrees, range(num_degrees)):
                 ax = axs[i]
-                temp = multipers.plots.plot_surface(grid, image.T, ax=ax)
+                temp = multipers.plots.plot_surface(grid, image, ax=ax)
                 plt.colorbar(temp, ax = ax)
                 if degree < 0 :
                     ax.set_title(rf"$H_{i}$ $2$-persistence image")
@@ -1712,7 +1712,7 @@ cdef class PyModule_f32:
               axs = [plt.gca()]
             for image, degree, i in zip(image_vector, degrees, range(num_degrees)):
                 ax = axs[i]
-                temp = multipers.plots.plot_surface(grid, image.T, ax=ax)
+                temp = multipers.plots.plot_surface(grid, image, ax=ax)
                 plt.colorbar(temp, ax = ax)
                 if degree < 0 :
                     ax.set_title(rf"$H_{i}$ $2$-persistence image")

multipers/mma_structures.pyx.tp

@@ -773,7 +773,7 @@ cdef class PyModule_{{SHORT}}:
               axs = [plt.gca()]
             for image, degree, i in zip(image_vector, degrees, range(num_degrees)):
                 ax = axs[i]
-                temp = multipers.plots.plot_surface(grid, image.T, ax=ax)
+                temp = multipers.plots.plot_surface(grid, image, ax=ax)
                 plt.colorbar(temp, ax = ax)
                 if degree < 0 :
                     ax.set_title(rf"$H_{i}$ $2$-persistence image")

multipers/plots.py

@@ -216,7 +216,7 @@ def plot_surface(
         return im
 
     if contour:
-        levels = plt_args.pop("levels", 20)
+        levels = plt_args.pop("levels", 50)
         im = ax.contourf(grid[0], grid[1], hf.T, cmap=cmap, levels=levels, **plt_args)
     else:
         im = ax.pcolormesh(grid[0], grid[1], hf.T, cmap=cmap, **plt_args)

multipers/slicer.pxd

@@ -2013,51 +2013,51 @@ cdef extern from "multiparameter_module_approximation/approximation.h" namespace
 
 import multipers.slicer as mps
 from cython.operator cimport dereference
-cdef inline Module[double] _multiparameter_module_approximation_f64(object slicer, One_critical_filtration[double] direction, double max_error, Box[double] box, bool threshold, bool complete, bool verbose):
+cdef inline Module[float] _multiparameter_module_approximation_f32(object slicer, One_critical_filtration[float] direction, float max_error, Box[float] box, bool threshold, bool complete, bool verbose):
   import multipers.slicer as mps
   cdef intptr_t slicer_ptr = <intptr_t>(slicer.get_ptr())
-  cdef Module[double] mod
+  cdef Module[float] mod
   if False:
     pass
-  elif isinstance(slicer, mps._KSlicer_Matrix0_vine_f64):
+  elif isinstance(slicer, mps._KSlicer_Matrix0_vine_f32):
     with nogil:
-      mod = multiparameter_module_approximation(dereference(<C_KSlicer_Matrix0_vine_f64*>(slicer_ptr)), direction, max_error, box, threshold, complete, verbose)
+      mod = multiparameter_module_approximation(dereference(<C_KSlicer_Matrix0_vine_f32*>(slicer_ptr)), direction, max_error, box, threshold, complete, verbose)
     return mod
-  elif isinstance(slicer, mps._KSlicer_Matrix1_vine_f64):
+  elif isinstance(slicer, mps._KSlicer_Matrix1_vine_f32):
     with nogil:
-      mod = multiparameter_module_approximation(dereference(<C_KSlicer_Matrix1_vine_f64*>(slicer_ptr)), direction, max_error, box, threshold, complete, verbose)
+      mod = multiparameter_module_approximation(dereference(<C_KSlicer_Matrix1_vine_f32*>(slicer_ptr)), direction, max_error, box, threshold, complete, verbose)
     return mod
-  elif isinstance(slicer, mps._Slicer_Matrix0_vine_f64):
+  elif isinstance(slicer, mps._Slicer_Matrix0_vine_f32):
     with nogil:
-      mod = multiparameter_module_approximation(dereference(<C_Slicer_Matrix0_vine_f64*>(slicer_ptr)), direction, max_error, box, threshold, complete, verbose)
+      mod = multiparameter_module_approximation(dereference(<C_Slicer_Matrix0_vine_f32*>(slicer_ptr)), direction, max_error, box, threshold, complete, verbose)
     return mod
-  elif isinstance(slicer, mps._Slicer_Matrix1_vine_f64):
+  elif isinstance(slicer, mps._Slicer_Matrix1_vine_f32):
     with nogil:
-      mod = multiparameter_module_approximation(dereference(<C_Slicer_Matrix1_vine_f64*>(slicer_ptr)), direction, max_error, box, threshold, complete, verbose)
+      mod = multiparameter_module_approximation(dereference(<C_Slicer_Matrix1_vine_f32*>(slicer_ptr)), direction, max_error, box, threshold, complete, verbose)
     return mod
   else:
     raise ValueError(f"Unsupported slicer type {type(slicer)}")
-cdef inline Module[float] _multiparameter_module_approximation_f32(object slicer, One_critical_filtration[float] direction, float max_error, Box[float] box, bool threshold, bool complete, bool verbose):
+cdef inline Module[double] _multiparameter_module_approximation_f64(object slicer, One_critical_filtration[double] direction, double max_error, Box[double] box, bool threshold, bool complete, bool verbose):
   import multipers.slicer as mps
   cdef intptr_t slicer_ptr = <intptr_t>(slicer.get_ptr())
-  cdef Module[float] mod
+  cdef Module[double] mod
   if False:
     pass
-  elif isinstance(slicer, mps._KSlicer_Matrix0_vine_f32):
+  elif isinstance(slicer, mps._KSlicer_Matrix0_vine_f64):
     with nogil:
-      mod = multiparameter_module_approximation(dereference(<C_KSlicer_Matrix0_vine_f32*>(slicer_ptr)), direction, max_error, box, threshold, complete, verbose)
+      mod = multiparameter_module_approximation(dereference(<C_KSlicer_Matrix0_vine_f64*>(slicer_ptr)), direction, max_error, box, threshold, complete, verbose)
     return mod
-  elif isinstance(slicer, mps._KSlicer_Matrix1_vine_f32):
+  elif isinstance(slicer, mps._KSlicer_Matrix1_vine_f64):
     with nogil:
-      mod = multiparameter_module_approximation(dereference(<C_KSlicer_Matrix1_vine_f32*>(slicer_ptr)), direction, max_error, box, threshold, complete, verbose)
+      mod = multiparameter_module_approximation(dereference(<C_KSlicer_Matrix1_vine_f64*>(slicer_ptr)), direction, max_error, box, threshold, complete, verbose)
     return mod
-  elif isinstance(slicer, mps._Slicer_Matrix0_vine_f32):
+  elif isinstance(slicer, mps._Slicer_Matrix0_vine_f64):
     with nogil:
-      mod = multiparameter_module_approximation(dereference(<C_Slicer_Matrix0_vine_f32*>(slicer_ptr)), direction, max_error, box, threshold, complete, verbose)
+      mod = multiparameter_module_approximation(dereference(<C_Slicer_Matrix0_vine_f64*>(slicer_ptr)), direction, max_error, box, threshold, complete, verbose)
     return mod
-  elif isinstance(slicer, mps._Slicer_Matrix1_vine_f32):
+  elif isinstance(slicer, mps._Slicer_Matrix1_vine_f64):
     with nogil:
-      mod = multiparameter_module_approximation(dereference(<C_Slicer_Matrix1_vine_f32*>(slicer_ptr)), direction, max_error, box, threshold, complete, verbose)
+      mod = multiparameter_module_approximation(dereference(<C_Slicer_Matrix1_vine_f64*>(slicer_ptr)), direction, max_error, box, threshold, complete, verbose)
     return mod
   else:
     raise ValueError(f"Unsupported slicer type {type(slicer)}")

multipers/slicer.pyx

@@ -19876,7 +19876,7 @@ cdef extern from "gudhi/cubical_to_boundary.h" namespace "":
   void _to_boundary(const vector[unsigned int]&, vector[vector[unsigned int]]&, vector[int]&) except + nogil
   void get_vertices(unsigned int, cset[unsigned int]&, const vector[vector[unsigned int]]&) nogil
 
-def _from_bitmapf32(image, **slicer_kwargs):
+def _from_bitmapi64(image, **slicer_kwargs):
     from multipers import Slicer
     dtype = slicer_kwargs.get("dtype", image.dtype)
     slicer_kwargs["dtype"] = dtype
@@ -19894,9 +19894,9 @@ def _from_bitmapf32(image, **slicer_kwargs):
     cdef cset[unsigned int] vertices
 
     cdef unsigned int num_gens = gen_dims.size()
-    filtration_values = np.zeros(shape=(num_gens, num_parameters), dtype = np.float32) - _Slicer._inf_value()
-    cdef float[:,:] F = filtration_values
-    cdef float[:,:] c_img = image.reshape(-1,num_parameters)
+    filtration_values = np.zeros(shape=(num_gens, num_parameters), dtype = np.int64) - _Slicer._inf_value()
+    cdef int64_t[:,:] F = filtration_values
+    cdef int64_t[:,:] c_img = image.reshape(-1,num_parameters)
     with nogil:
         for i in range(num_gens):
             # with gil:
@@ -19914,7 +19914,7 @@ def _from_bitmapf32(image, **slicer_kwargs):
             #     print(f"F = {np.asarray(F[i])}")
     slicer = _Slicer(gen_maps, gen_dims, filtration_values)
     return slicer
-def _from_bitmapi32(image, **slicer_kwargs):
+def _from_bitmapf32(image, **slicer_kwargs):
     from multipers import Slicer
     dtype = slicer_kwargs.get("dtype", image.dtype)
     slicer_kwargs["dtype"] = dtype
@@ -19932,9 +19932,9 @@ def _from_bitmapi32(image, **slicer_kwargs):
     cdef cset[unsigned int] vertices
 
     cdef unsigned int num_gens = gen_dims.size()
-    filtration_values = np.zeros(shape=(num_gens, num_parameters), dtype = np.int32) - _Slicer._inf_value()
-    cdef int32_t[:,:] F = filtration_values
-    cdef int32_t[:,:] c_img = image.reshape(-1,num_parameters)
+    filtration_values = np.zeros(shape=(num_gens, num_parameters), dtype = np.float32) - _Slicer._inf_value()
+    cdef float[:,:] F = filtration_values
+    cdef float[:,:] c_img = image.reshape(-1,num_parameters)
     with nogil:
         for i in range(num_gens):
             # with gil:
@@ -19952,7 +19952,7 @@ def _from_bitmapi32(image, **slicer_kwargs):
             #     print(f"F = {np.asarray(F[i])}")
     slicer = _Slicer(gen_maps, gen_dims, filtration_values)
     return slicer
-def _from_bitmapi64(image, **slicer_kwargs):
+def _from_bitmapi32(image, **slicer_kwargs):
     from multipers import Slicer
     dtype = slicer_kwargs.get("dtype", image.dtype)
     slicer_kwargs["dtype"] = dtype
@@ -19970,9 +19970,9 @@ def _from_bitmapi64(image, **slicer_kwargs):
     cdef cset[unsigned int] vertices
 
     cdef unsigned int num_gens = gen_dims.size()
-    filtration_values = np.zeros(shape=(num_gens, num_parameters), dtype = np.int64) - _Slicer._inf_value()
-    cdef int64_t[:,:] F = filtration_values
-    cdef int64_t[:,:] c_img = image.reshape(-1,num_parameters)
+    filtration_values = np.zeros(shape=(num_gens, num_parameters), dtype = np.int32) - _Slicer._inf_value()
+    cdef int32_t[:,:] F = filtration_values
+    cdef int32_t[:,:] c_img = image.reshape(-1,num_parameters)
     with nogil:
         for i in range(num_gens):
             # with gil:
@@ -20031,12 +20031,12 @@ def _from_bitmapf64(image, **slicer_kwargs):
 
 def from_bitmap(img, **kwargs):
     img = np.asarray(img)
+    if img.dtype == np.int64:
+        return _from_bitmapi64(img, **kwargs)
     if img.dtype == np.float32:
         return _from_bitmapf32(img, **kwargs)
     if img.dtype == np.int32:
         return _from_bitmapi32(img, **kwargs)
-    if img.dtype == np.int64:
-        return _from_bitmapi64(img, **kwargs)
     if img.dtype == np.float64:
         return _from_bitmapf64(img, **kwargs)
     raise ValueError(f"Invalid dtype. Got {img.dtype=}, was expecting {available_dtype=}.")

{multipers-2.3.3b6.dist-info → multipers-2.3.3b7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multipers
-Version: 2.3.3b6
+Version: 2.3.3b7
 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>

{multipers-2.3.3b6.dist-info → multipers-2.3.3b7.dist-info}/RECORD

@@ -1,35 +1,35 @@
 multipers/__init__.py,sha256=y4BfbXAY2M2yZYob758IegZHwIbRgmKrph6lwe6WR6Q,733
-multipers/_signed_measure_meta.py,sha256=fscSXOekUX_TkxucOKpb3oNJoct_IrjMZcqiwxPvmSY,17930
+multipers/_signed_measure_meta.py,sha256=YgGhy6miY2sagJMzV8JAfos-aoR4JV6F7RUNjpmT3nU,17676
 multipers/_slicer_meta.py,sha256=mjIGR-B6HnQLSiMowEQ8EWQkD_IF3bBnDVzvwrZugZ4,7203
 multipers/distances.py,sha256=uAZj2GtUQp50OxN2qU7sl2JqsmJ74IG9j5tZapLO2Us,6220
 multipers/filtration_conversions.pxd,sha256=Je7a3F4zS1PQn6Ul1YCXgA6p39X2FouStru-XtN-aOw,10800
 multipers/filtration_conversions.pxd.tp,sha256=_9tUvZVUA7J_RUM3q7BxY48fYgDHCUA7Xhy4nBfLLs0,3309
 multipers/filtrations.pxd,sha256=08ONkZNCjs8Nme8lcD9myPz-K662sA-EDpSwzgC2_ts,9461
-multipers/function_rips.cp313-win_amd64.pyd,sha256=sDLCoM2S7sqYiqjNYrtmTNQgmuUewXe9aZsf5VTPeTg,332288
+multipers/function_rips.cp313-win_amd64.pyd,sha256=Vy6KUtnb9z6Ocb_m8D1xK9nVRjVskSl19HjhOSEWUtY,332288
 multipers/function_rips.pyx,sha256=j5NjbK3YrAv_2s8YHB1JB0k6m9NC7RQCSFlJe-w_kgE,5252
-multipers/grids.cp313-win_amd64.pyd,sha256=jjmqPWuMVftLpRvEVAl7SyAf0RdFnqeqNTBNhtqDqZM,479744
-multipers/grids.pyx,sha256=ONN_RKkuxqwb9IaS9gd42FUGaiBLc8QWcd3L-ubZjKE,16575
-multipers/io.cp313-win_amd64.pyd,sha256=WM0rASfVqREFD-rp8W0HbJNjFkiaOIl8y60lghRGILg,220160
+multipers/grids.cp313-win_amd64.pyd,sha256=hfX8m-SdBYlM_i9V_RF08xvcLJKt0TIyIZ2DMr2Nsss,472576
+multipers/grids.pyx,sha256=4329-4IwlvZKEsmVXrG91kNl1pi-q5RzSrl8EHo2EKk,17981
+multipers/io.cp313-win_amd64.pyd,sha256=wtJDNCLp22AQqsO9iEJCG_MCifueTf8Lc8Jiq2jXTEY,220160
 multipers/io.pyx,sha256=pQBH_rSqaCZqDSxTLnhlyECP3fLbX2tR_RKJHydHm_0,22210
-multipers/mma_structures.cp313-win_amd64.pyd,sha256=ZxyeciW9bPLkvHfa57IFSxtcQhP-C46CZ9EGN6M9G-Q,1280000
+multipers/mma_structures.cp313-win_amd64.pyd,sha256=IbiCf8rnWhcpzFOVJayY9a7tBPW25-_USXxcwuYeqJ4,1280512
 multipers/mma_structures.pxd,sha256=jh1QnQRidt_VK0CK7losQi6rAl_1qG5DNuR23J42pUA,6595
-multipers/mma_structures.pyx,sha256=4zNC6ePfFKMvx0MrH-FqJVouyTMciRc49oevKDnsJhI,109530
-multipers/mma_structures.pyx.tp,sha256=hWuuk9USDFa8CbQVRHNjWSAdGgpkWKvSCNjTtVuSzwM,42299
+multipers/mma_structures.pyx,sha256=1FQ_sqkpHHkCyCLLKkR9lUgZKDZFt-YgjnDd8NGmw6Q,109526
+multipers/mma_structures.pyx.tp,sha256=QLo4ZZDnFuWNot771jYkYHc9ZQq6CJIpkRkeRwGi7XA,42297
 multipers/multiparameter_edge_collapse.py,sha256=MFt0eKQQSv2354omeIqOmzASYTKIMsYdxZHFZauQr8g,1229
-multipers/multiparameter_module_approximation.cp313-win_amd64.pyd,sha256=f0dY4vjrIwUzMS92s_Fkj4-W65xJ2PxxS7zIrSIMQUQ,450560
+multipers/multiparameter_module_approximation.cp313-win_amd64.pyd,sha256=30WzGs1urkKh5i3IluiRxsLUVnMHRKPwrHGjymNdb7U,450560
 multipers/multiparameter_module_approximation.pyx,sha256=wp7la7Z9wBngnfw6WOVddf93mPyXf4HfNT6dKW2Z0r0,9030
 multipers/pickle.py,sha256=YYVt4iHiD16E1x5Yn_4mX6P5P8rKi56pNGjJo5IzPhc,2579
-multipers/plots.py,sha256=-yOaufE_flzrZDQIgwhchvJIo0MBJMrUJKuo_sKG6IM,14918
-multipers/point_measure.cp313-win_amd64.pyd,sha256=UlCNj-x36P8dGJJY4r7McYw8RUjkCS0UMxc-0VRktL8,596480
+multipers/plots.py,sha256=ZJmOD5fgy0y_U-rjhR6pZ2WD8HFndpKMh5IKlU62QkI,14918
+multipers/point_measure.cp313-win_amd64.pyd,sha256=HeyDYV6wRyvBf0YwwpsJ0tY3pl-XnV7LHNEhFy4NyLA,596480
 multipers/point_measure.pyx,sha256=ovpyvjMdOPBOK_0TT0VoK4b2t8m5InFdKmRBB6biTts,14077
-multipers/simplex_tree_multi.cp313-win_amd64.pyd,sha256=m2GZ5vqmjcPPqfaQxuUsPuxrKf6ynN8b4M6EMn_GVCA,3612672
+multipers/simplex_tree_multi.cp313-win_amd64.pyd,sha256=wBH0k6ELNIH6kAAXbYM74-8AZecNqUY5wjmRA_kE3q4,3612672
 multipers/simplex_tree_multi.pxd,sha256=KpyDEQNPoMC2sOU9-d4LtrGXx_UVCJGxMJ1kk1AzHgU,6631
 multipers/simplex_tree_multi.pyx,sha256=13x2WFMExcukd_2CrLOJa3Edex3WNqaSSrGBmPhYoDM,499100
 multipers/simplex_tree_multi.pyx.tp,sha256=YFzVUJPWNOOpRiyOgaYlFR_DJ_57rAQLsOp2W0l71_s,89318
-multipers/slicer.cp313-win_amd64.pyd,sha256=wlZ4jNniPFPuVRjzfTXxVXYJNAkbrqwB66LRgcyt1mI,11666432
-multipers/slicer.pxd,sha256=fzA-lL_QWyUMf9rRSpcKG35QNS9UXEmVC9r7kR0geho,185230
+multipers/slicer.cp313-win_amd64.pyd,sha256=rOlKuzDnyAfQiaK0lJz0E6HkbOQZI-Hjye9TuIiMYGQ,11666432
+multipers/slicer.pxd,sha256=bHcV5COzDcjhaVcL3bWSHivUYtdkSx4bdj24fVOe_DU,185230
 multipers/slicer.pxd.tp,sha256=fLOUPtPGqiY9o1fPDyc_whBrgKLh_6HVfvl7OtE-34Y,10243
-multipers/slicer.pyx,sha256=fQ0zZwgwWZPXWw_rKvMCwbHXw2RQTJFSLkxiEHrrzVE,894493
+multipers/slicer.pyx,sha256=jgPdo6ERvmQOYJE-L4XtOFOeRsZO5qGsVSpgLKj604E,894493
 multipers/slicer.pyx.tp,sha256=GCL7xUZccfmnIoY4bk05L5ODkSNzEzXgodp0VkH-xT8,44584
 multipers/tbb12.dll,sha256=flSoIAkNVECA5vNkh5jLn1jcZNxTw3yb2tuTtxn6oEE,344576
 multipers/tbbbind_2_5.dll,sha256=4JWlgl4aJJ3m5NIE85AgQi46REU3UkIJwNsKnh9aK_c,23552
@@ -37,9 +37,9 @@ multipers/tbbmalloc.dll,sha256=r9y_3nR6Rpc68g1F7Oci8EpunjWIJQU-zjLIVXc9SDY,11366
 multipers/tbbmalloc_proxy.dll,sha256=5vcuiOpM9KTAY7daWxCsAc2MU_l8K3TWpw0kz-Xh0sk,30720
 multipers/tensor.pxd,sha256=MSmaMU0sOP9CHLmg4dym7nOGaI1S4cOdM01TQ9flI54,417
 multipers/test.pyx,sha256=-g7WU-jKrZK8H0c-6eAPsfrApjvTKrUoswVYFu8LoV4,1798
-multipers/array_api/__init__.py,sha256=072Lk60jfw3re6iCY3EorteHEoQ7vbUgpMpuGCpfh04,1109
-multipers/array_api/numpy.py,sha256=1l9zL3jP8xhKYpXRjGzhHw4DP_tGdMQ3WRS8Tcmf3xc,816
-multipers/array_api/torch.py,sha256=o8ekBau6G46LHd8-b_cWu_vPWIBiTfE4Dz5UL0xWwxY,1257
+multipers/array_api/__init__.py,sha256=jyvi7Gzd7Si_imgaodz80fcA-68MikAGk8g79_vj6yo,1545
+multipers/array_api/numpy.py,sha256=HZHJitXSb2Y3f-JNg47afmYoExgqT6dOx7sfcM9vvaA,2324
+multipers/array_api/torch.py,sha256=7PKiSgA4TCaTspsC7wiMXUtHgSiTfSFyNtuMYU31xNo,2550
 multipers/data/MOL2.py,sha256=nLZHy2OSFN9Z2uJKsbqWOEG2R7G-uH6dCLHG48UjvR4,15428
 multipers/data/UCR.py,sha256=PuT8l3i26y0goBzIESwdgJAe6YFCyDiWSoxECcP5rhs,798
 multipers/data/__init__.py,sha256=w7uUe4LOHbdbKU4R8MNs7em65wZJN0v5ukoG1otFanQ,24
@@ -50,7 +50,7 @@ multipers/data/pytorch2simplextree.py,sha256=cvOJTUleK_qEbcpygRD77GuQl_0qDsSjjD6
 multipers/data/shape3d.py,sha256=AE-vvjKrhKxOwMo-lurUsFqqLjIg5obo-RTbRZF_5Mk,3893
 multipers/data/synthetic.py,sha256=RvLWIBE5j99kJSt-D7cnPGI3c7skD4p8_qofJbMIXM0,3078
 multipers/filtrations/__init__.py,sha256=Lg0EHe2cxT32UQAg0kr_Vpua-xPBZxGol8VIfz8UwWk,319
-multipers/filtrations/density.py,sha256=z_QwAi_5EdUoKXc6s7N-qWM7n6r5hWHiHeJkLPWhE-w,19818
+multipers/filtrations/density.py,sha256=XNPHCwyC8FwAdSfNp1ofxcxfP5ZFGZ6K-DUeXsfM4eg,18155
 multipers/filtrations/filtrations.py,sha256=r3WS4GMBvcJ0ryIMbNHFgep0FCtl3h404V_SbMM8hN0,13333
 multipers/gudhi/Persistence_slices_interface.h,sha256=QnUeCCKi9K8CfqI3W5i3Ra1Jy2Z1IIivr3MIpnBsnYU,6562
 multipers/gudhi/Simplex_tree_interface.h,sha256=kkq8pE3jKGLY1dK7sYpb_uERHaWGurrRXfaw_ygs-mY,10217
@@ -146,7 +146,7 @@ multipers/ml/kernels.py,sha256=XWfvKY68-c9E-MpRzdNqGzGD6K24Aizx95TkiSeAtIY,6175
 multipers/ml/mma.py,sha256=mSwYqSHWGiboEiMnxArCuhHyrOExPYdML2Mbx4dTO7s,23950
 multipers/ml/one.py,sha256=np5jM8gywm65TsK1yeZ1BDWqP-Ym-7hz4brTXI_0imk,20119
 multipers/ml/point_clouds.py,sha256=nTkSjSzQy6S10-sZ0uwBp_Fs2EIWleB7yHncK2b_xLg,13770
-multipers/ml/signed_measures.py,sha256=LCf0gAfQ7y4q9gI7s72Y4nwgP6U8HZenwGrMDdK-azY,58339
+multipers/ml/signed_measures.py,sha256=pwV6-XAQnS5itlfGgA64qxPomBqOuqsd-ulnkoYFdto,60981
 multipers/ml/sliced_wasserstein.py,sha256=jgq4ND3EWwwJBopqRvfJLsoOptiMHjS3zEAENBmPJDc,18644
 multipers/ml/tools.py,sha256=DOPcqmvZP2bA7M08GrwccdebwDq1HEwYdhNRGT7eZMI,3453
 multipers/multi_parameter_rank_invariant/diff_helpers.h,sha256=wMCOhAewWd6-lulLND0y8M0MZoru6zn_8J3qfXDjLds,3477
@@ -178,8 +178,8 @@ multipers/tests/__init__.py,sha256=-7Fj-zFAfBJv18trg0CPglQTmYu_ehySZGqtJzPlN8U,1
 multipers/torch/__init__.py,sha256=OLxIiZ389uCqehpUxBPUI_x1SYu531onc4tiTscAuIw,27
 multipers/torch/diff_grids.py,sha256=2YK-c351tBpj8sfzjf26fbE1l0xlWse7oVVfDHD3zwM,7492
 multipers/torch/rips_density.py,sha256=H-kmSzY8hXhmVn15Oltc71DHs1IUHg5oPRgNyWW8L4Q,11706
-multipers-2.3.3b6.dist-info/licenses/LICENSE,sha256=UsQRnvlo_9wpQS9DNt52GEraERHwK2GIRwuqr2Yv5JI,1071
-multipers-2.3.3b6.dist-info/METADATA,sha256=0zSGxpVm4912cviaU4-M6i-GMYDdQtoDLr25L35Xq6I,9817
-multipers-2.3.3b6.dist-info/WHEEL,sha256=qV0EIPljj1XC_vuSatRWjn02nZIz3N1t8jsZz7HBr2U,101
-multipers-2.3.3b6.dist-info/top_level.txt,sha256=L9e0AGmhRzrNw9FpuUx-zlqi5NcBOmrI9wYY8kYWr8A,10
-multipers-2.3.3b6.dist-info/RECORD,,
+multipers-2.3.3b7.dist-info/licenses/LICENSE,sha256=UsQRnvlo_9wpQS9DNt52GEraERHwK2GIRwuqr2Yv5JI,1071
+multipers-2.3.3b7.dist-info/METADATA,sha256=rWZTaAJnyv6X11zYE1N_EMCUrmhHZ4bmaK_uG4E7Ma8,9817
+multipers-2.3.3b7.dist-info/WHEEL,sha256=qV0EIPljj1XC_vuSatRWjn02nZIz3N1t8jsZz7HBr2U,101
+multipers-2.3.3b7.dist-info/top_level.txt,sha256=L9e0AGmhRzrNw9FpuUx-zlqi5NcBOmrI9wYY8kYWr8A,10
+multipers-2.3.3b7.dist-info/RECORD,,