multipers 2.3.3b6__cp310-cp310-win_amd64.whl → 2.3.4__cp310-cp310-win_amd64.whl

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

@@ -81,7 +81,8 @@ def _plot_signed_measure_4(
     **plt_kwargs,  # ignored ftm
 ):
     # compute the maximal rectangle area
-    pts = np.clip(pts, a_min=-np.inf, a_max=np.array((*threshold, *threshold))[None, :])
+    pts = np.clip(pts, a_min=-np.inf,
+                  a_max=np.array((*threshold, *threshold))[None, :])
     alpha_rescaling = 0
     for rectangle, weight in zip(pts, weights):
         if rectangle[2] >= x_smoothing * rectangle[0]:
@@ -170,7 +171,8 @@ def plot_signed_measures(signed_measures, threshold=None, size=4):
             nrows=1, ncols=num_degrees, figsize=(num_degrees * size, size)
         )
     for ax, signed_measure in zip(axes, signed_measures):
-        plot_signed_measure(signed_measure=signed_measure, ax=ax, threshold=threshold)
+        plot_signed_measure(signed_measure=signed_measure,
+                            ax=ax, threshold=threshold)
     plt.tight_layout()
 
 
@@ -200,13 +202,17 @@ def plot_surface(
             cmap = matplotlib.colormaps["gray_r"]
         else:
             cmap = _cmap
+    if discrete_surface or not contour:
+        # for shading="flat"
+        grid = [np.concatenate([g, [g[-1]*1.1 - .1*g[0]]]) for g in grid]
     if discrete_surface:
         if has_negative_values:
             bounds = np.arange(-5, 6, 1, dtype=int)
         else:
             bounds = np.arange(0, 11, 1, dtype=int)
         norm = matplotlib.colors.BoundaryNorm(bounds, cmap.N, extend="max")
-        im = ax.pcolormesh(grid[0], grid[1], hf.T, cmap=cmap, norm=norm, **plt_args)
+        im = ax.pcolormesh(grid[0], grid[1], hf.T, cmap=cmap,
+                           norm=norm, shading="flat", **plt_args)
         cbar = fig.colorbar(
             matplotlib.cm.ScalarMappable(cmap=cmap, norm=norm),
             spacing="proportional",
@@ -216,10 +222,12 @@ def plot_surface(
         return im
 
     if contour:
-        levels = plt_args.pop("levels", 20)
-        im = ax.contourf(grid[0], grid[1], hf.T, cmap=cmap, levels=levels, **plt_args)
+        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)
+        im = ax.pcolormesh(grid[0], grid[1], hf.T,
+                           cmap=cmap,  shading="flat", **plt_args)
     return im
 
 
@@ -314,25 +322,30 @@ def plot2d_PyModule(
                         trivial_summand = False
                     if shapely:
                         list_of_rect.append(
-                            _rectangle_box(birth[0], birth[1], death[0], death[1])
+                            _rectangle_box(
+                                birth[0], birth[1], death[0], death[1])
                         )
                     else:
                         list_of_rect.append(
-                            _rectangle(birth, death, cmap(i / n_summands), alpha)
+                            _rectangle(birth, death, cmap(
+                                i / n_summands), alpha)
                         )
         if not (trivial_summand):
             if separated:
                 fig, ax = plt.subplots()
-                ax.set(xlim=[box[0][0], box[1][0]], ylim=[box[0][1], box[1][1]])
+                ax.set(xlim=[box[0][0], box[1][0]],
+                       ylim=[box[0][1], box[1][1]])
             if shapely:
                 summand_shape = union_all(list_of_rect)
                 if type(summand_shape) is _Polygon:
                     xs, ys = summand_shape.exterior.xy
-                    ax.fill(xs, ys, alpha=alpha, fc=cmap(i / n_summands), ec="None")
+                    ax.fill(xs, ys, alpha=alpha, fc=cmap(
+                        i / n_summands), ec="None")
                 else:
                     for polygon in summand_shape.geoms:
                         xs, ys = polygon.exterior.xy
-                        ax.fill(xs, ys, alpha=alpha, fc=cmap(i / n_summands), ec="None")
+                        ax.fill(xs, ys, alpha=alpha, fc=cmap(
+                            i / n_summands), ec="None")
             else:
                 for rectangle in list_of_rect:
                     ax.add_patch(rectangle)
@@ -396,7 +409,8 @@ def plot_simplicial_complex(
         if len(s) == 2:  # simplexe = segment
             xx = np.array([pts[a, 0] for a in s])
             yy = np.array([pts[a, 1] for a in s])
-            plt.plot(xx, yy, c=color(density), alpha=1, zorder=10 * density, lw=1.5)
+            plt.plot(xx, yy, c=color(density), alpha=1,
+                     zorder=10 * density, lw=1.5)
         if len(s) == 3:  # simplexe = triangle
             xx = np.array([pts[a, 0] for a in s])
             yy = np.array([pts[a, 1] for a in s])

multipers/simplex_tree_multi.pxd

@@ -117,8 +117,8 @@ cdef extern from "Simplex_tree_multi_interface.h" namespace "Gudhi::multiparamet
     void to_std(intptr_t, Line[double],int ) nogil 
     void to_std_linear_projection(intptr_t, vector[double]) nogil
     void squeeze_filtration_inplace(vector[vector[double]] &, bool) nogil
-    void squeeze_filtration(intptr_t, vector[vector[double]] &) nogil
-    void unsqueeze_filtration(intptr_t, vector[vector[double]] &) nogil
+    void squeeze_filtration(intptr_t, vector[vector[double]] &) except + nogil
+    void unsqueeze_filtration(intptr_t, vector[vector[double]] &) except + nogil
     vector[vector[vector[value_type]]] get_filtration_values(const vector[int]&) nogil
 
 

multipers/simplex_tree_multi.pyx

@@ -625,6 +625,41 @@ cdef class SimplexTreeMulti_KFi32:
         """
         return self.get_ptr().prune_above_dimension(dimension)
 
+    def expansion(self, int max_dim)->SimplexTreeMulti_KFi32:
+        """Expands the simplex tree containing only its one skeleton
+        until dimension max_dim.
+
+        The expanded simplicial complex until dimension :math:`d`
+        attached to a graph :math:`G` is the maximal simplicial complex of
+        dimension at most :math:`d` admitting the graph :math:`G` as
+        :math:`1`-skeleton.
+        The filtration value assigned to a simplex is the maximal filtration
+        value of one of its edges.
+
+        The simplex tree must contain no simplex of dimension bigger than
+        1 when calling the method.
+
+        :param max_dim: The maximal dimension.
+        :type max_dim: int
+        """
+        with nogil:
+            self.get_ptr().expansion(max_dim)
+            # This is a fix for multipersistence. FIXME expansion in c++
+            self.get_ptr().make_filtration_non_decreasing()
+        return self
+
+    def make_filtration_non_decreasing(self)->bool: 
+        """This function ensures that each simplex has a higher filtration
+        value than its faces by increasing the filtration values.
+
+        :returns: True if any filtration value was modified,
+            False if the filtration was already non-decreasing.
+        :rtype: bool
+        """
+        cdef bool out
+        with nogil:
+            out = self.get_ptr().make_filtration_non_decreasing()
+        return out
 
     def reset_filtration(self, filtration, min_dim = 0)->SimplexTreeMulti_KFi32:
         """This function resets the filtration value of all the simplices of dimension at least min_dim. Resets all the
@@ -3217,6 +3252,41 @@ cdef class SimplexTreeMulti_KFi64:
         """
         return self.get_ptr().prune_above_dimension(dimension)
 
+    def expansion(self, int max_dim)->SimplexTreeMulti_KFi64:
+        """Expands the simplex tree containing only its one skeleton
+        until dimension max_dim.
+
+        The expanded simplicial complex until dimension :math:`d`
+        attached to a graph :math:`G` is the maximal simplicial complex of
+        dimension at most :math:`d` admitting the graph :math:`G` as
+        :math:`1`-skeleton.
+        The filtration value assigned to a simplex is the maximal filtration
+        value of one of its edges.
+
+        The simplex tree must contain no simplex of dimension bigger than
+        1 when calling the method.
+
+        :param max_dim: The maximal dimension.
+        :type max_dim: int
+        """
+        with nogil:
+            self.get_ptr().expansion(max_dim)
+            # This is a fix for multipersistence. FIXME expansion in c++
+            self.get_ptr().make_filtration_non_decreasing()
+        return self
+
+    def make_filtration_non_decreasing(self)->bool: 
+        """This function ensures that each simplex has a higher filtration
+        value than its faces by increasing the filtration values.
+
+        :returns: True if any filtration value was modified,
+            False if the filtration was already non-decreasing.
+        :rtype: bool
+        """
+        cdef bool out
+        with nogil:
+            out = self.get_ptr().make_filtration_non_decreasing()
+        return out
 
     def reset_filtration(self, filtration, min_dim = 0)->SimplexTreeMulti_KFi64:
         """This function resets the filtration value of all the simplices of dimension at least min_dim. Resets all the
@@ -5809,6 +5879,41 @@ cdef class SimplexTreeMulti_KFf32:
         """
         return self.get_ptr().prune_above_dimension(dimension)
 
+    def expansion(self, int max_dim)->SimplexTreeMulti_KFf32:
+        """Expands the simplex tree containing only its one skeleton
+        until dimension max_dim.
+
+        The expanded simplicial complex until dimension :math:`d`
+        attached to a graph :math:`G` is the maximal simplicial complex of
+        dimension at most :math:`d` admitting the graph :math:`G` as
+        :math:`1`-skeleton.
+        The filtration value assigned to a simplex is the maximal filtration
+        value of one of its edges.
+
+        The simplex tree must contain no simplex of dimension bigger than
+        1 when calling the method.
+
+        :param max_dim: The maximal dimension.
+        :type max_dim: int
+        """
+        with nogil:
+            self.get_ptr().expansion(max_dim)
+            # This is a fix for multipersistence. FIXME expansion in c++
+            self.get_ptr().make_filtration_non_decreasing()
+        return self
+
+    def make_filtration_non_decreasing(self)->bool: 
+        """This function ensures that each simplex has a higher filtration
+        value than its faces by increasing the filtration values.
+
+        :returns: True if any filtration value was modified,
+            False if the filtration was already non-decreasing.
+        :rtype: bool
+        """
+        cdef bool out
+        with nogil:
+            out = self.get_ptr().make_filtration_non_decreasing()
+        return out
 
     def reset_filtration(self, filtration, min_dim = 0)->SimplexTreeMulti_KFf32:
         """This function resets the filtration value of all the simplices of dimension at least min_dim. Resets all the
@@ -8401,6 +8506,41 @@ cdef class SimplexTreeMulti_KFf64:
         """
         return self.get_ptr().prune_above_dimension(dimension)
 
+    def expansion(self, int max_dim)->SimplexTreeMulti_KFf64:
+        """Expands the simplex tree containing only its one skeleton
+        until dimension max_dim.
+
+        The expanded simplicial complex until dimension :math:`d`
+        attached to a graph :math:`G` is the maximal simplicial complex of
+        dimension at most :math:`d` admitting the graph :math:`G` as
+        :math:`1`-skeleton.
+        The filtration value assigned to a simplex is the maximal filtration
+        value of one of its edges.
+
+        The simplex tree must contain no simplex of dimension bigger than
+        1 when calling the method.
+
+        :param max_dim: The maximal dimension.
+        :type max_dim: int
+        """
+        with nogil:
+            self.get_ptr().expansion(max_dim)
+            # This is a fix for multipersistence. FIXME expansion in c++
+            self.get_ptr().make_filtration_non_decreasing()
+        return self
+
+    def make_filtration_non_decreasing(self)->bool: 
+        """This function ensures that each simplex has a higher filtration
+        value than its faces by increasing the filtration values.
+
+        :returns: True if any filtration value was modified,
+            False if the filtration was already non-decreasing.
+        :rtype: bool
+        """
+        cdef bool out
+        with nogil:
+            out = self.get_ptr().make_filtration_non_decreasing()
+        return out
 
     def reset_filtration(self, filtration, min_dim = 0)->SimplexTreeMulti_KFf64:
         """This function resets the filtration value of all the simplices of dimension at least min_dim. Resets all the

multipers/simplex_tree_multi.pyx.tp

@@ -869,7 +869,6 @@ cdef class SimplexTreeMulti_{{FSHORT}}:
         """
         return self.get_ptr().prune_above_dimension(dimension)
 
-    {{if not is_kcritical}}
     def expansion(self, int max_dim)->SimplexTreeMulti_{{FSHORT}}:
         """Expands the simplex tree containing only its one skeleton
         until dimension max_dim.
@@ -905,7 +904,6 @@ cdef class SimplexTreeMulti_{{FSHORT}}:
         with nogil:
             out = self.get_ptr().make_filtration_non_decreasing()
         return out
-    {{endif}}
 
     def reset_filtration(self, filtration, min_dim = 0)->SimplexTreeMulti_{{FSHORT}}:
         """This function resets the filtration value of all the simplices of dimension at least min_dim. Resets all the

multipers/slicer.pyx

@@ -19914,7 +19914,7 @@ def _from_bitmapi64(image, **slicer_kwargs):
             #     print(f"F = {np.asarray(F[i])}")
     slicer = _Slicer(gen_maps, gen_dims, filtration_values)
     return slicer
-def _from_bitmapf64(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_bitmapf64(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.float64) - _Slicer._inf_value()
-    cdef double[:,:] F = filtration_values
-    cdef double[:,:] 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_bitmapf64(image, **slicer_kwargs):
             #     print(f"F = {np.asarray(F[i])}")
     slicer = _Slicer(gen_maps, gen_dims, filtration_values)
     return slicer
-def _from_bitmapf32(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_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.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:
@@ -19990,7 +19990,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_bitmapf64(image, **slicer_kwargs):
     from multipers import Slicer
     dtype = slicer_kwargs.get("dtype", image.dtype)
     slicer_kwargs["dtype"] = dtype
@@ -20008,9 +20008,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.float64) - _Slicer._inf_value()
+    cdef double[:,:] F = filtration_values
+    cdef double[:,:] c_img = image.reshape(-1,num_parameters)
     with nogil:
         for i in range(num_gens):
             # with gil:
@@ -20033,12 +20033,12 @@ def from_bitmap(img, **kwargs):
     img = np.asarray(img)
     if img.dtype == np.int64:
         return _from_bitmapi64(img, **kwargs)
-    if img.dtype == np.float64:
-        return _from_bitmapf64(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.float64:
+        return _from_bitmapf64(img, **kwargs)
     raise ValueError(f"Invalid dtype. Got {img.dtype=}, was expecting {available_dtype=}.")
 
 def from_function_delaunay(

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multipers
-Version: 2.3.3b6
+Version: 2.3.4
 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>
@@ -44,7 +44,7 @@ This library aims to provide easy to use and performant strategies for applied m
 ## Compiled packages
 | Source | Version | Downloads | Platforms | 
 | --- | --- | --- | --- | 
-| [![Conda Recipe](https://img.shields.io/badge/conda-recipe-green.svg)](https://anaconda.org/conda-forge/multipers)| [![Conda Version](https://img.shields.io/conda/vn/conda-forge/multipers.svg)](https://anaconda.org/conda-forge/multipers) |  [![Conda Downloads](https://img.shields.io/conda/dn/conda-forge/multipers.svg)](https://anaconda.org/conda-forge/multipers) |[![Conda Platforms](https://img.shields.io/conda/pn/conda-forge/multipers.svg)](https://anaconda.org/conda-forge/multipers) | 
+| [![Conda Recipe](https://img.shields.io/badge/conda-recipe-green.svg)](https://github.com/conda-forge/multipers-feedstock)| [![Conda Version](https://img.shields.io/conda/vn/conda-forge/multipers.svg)](https://anaconda.org/conda-forge/multipers) |  [![Conda Downloads](https://img.shields.io/conda/dn/conda-forge/multipers.svg)](https://anaconda.org/conda-forge/multipers) |[![Conda Platforms](https://img.shields.io/conda/pn/conda-forge/multipers.svg)](https://anaconda.org/conda-forge/multipers) | 
 | [![pip Recipe](https://img.shields.io/badge/pip-package-green.svg)](https:///pypi.org/project/multipers) | [![PyPI](https://img.shields.io/pypi/v/multipers?color=green)](https://pypi.org/project/multipers) | [![ pip downloads](https://static.pepy.tech/badge/multipers)](https://pepy.tech/project/multipers) | |