multipers 2.3.0__cp312-cp312-win_amd64.whl → 2.3.2__cp312-cp312-win_amd64.whl

multipers/filtrations/filtrations.py

@@ -1,22 +1,25 @@
 from collections.abc import Sequence
 from typing import Optional
+from warnings import warn
 
 import gudhi as gd
 import numpy as np
 from numpy.typing import ArrayLike
 from scipy.spatial import KDTree
-from scipy.spatial.distance import cdist
 
-from multipers.ml.convolutions import DTM, available_kernels
+from multipers.array_api import api_from_tensor, api_from_tensors
+from multipers.filtrations.density import DTM, available_kernels
+from multipers.grids import compute_grid
 from multipers.simplex_tree_multi import SimplexTreeMulti, SimplexTreeMulti_type
 
 try:
     import pykeops
 
-    from multipers.ml.convolutions import KDE
+    from multipers.filtrations.density import KDE
 except ImportError:
+
     from sklearn.neighbors import KernelDensity
-    from warnings import warn
+
     warn("pykeops not found. Falling back to sklearn.")
 
     def KDE(bandwidth, kernel, return_log):
@@ -28,8 +31,8 @@ def RipsLowerstar(
     *,
     points: Optional[ArrayLike] = None,
     distance_matrix: Optional[ArrayLike] = None,
-    function=None,
-    threshold_radius=None,
+    function: Optional[ArrayLike] = None,
+    threshold_radius: Optional[float] = None,
 ):
     """
     Computes the Rips complex, with the usual rips filtration as a first parameter,
@@ -44,22 +47,37 @@ def RipsLowerstar(
         points is not None or distance_matrix is not None
     ), "`points` or `distance_matrix` has to be given."
     if distance_matrix is None:
-        distance_matrix = cdist(points, points)  # this may be slow...
+        api = api_from_tensor(points)
+        points = api.astensor(points)
+        D = api.cdist(points, points)  # this may be slow...
+    else:
+        api = api_from_tensor(distance_matrix)
+        D = api.astensor(distance_matrix)
+
     if threshold_radius is None:
-        threshold_radius = np.min(np.max(distance_matrix, axis=1))
+        threshold_radius = api.min(api.maxvalues(D, axis=1))
     st = gd.SimplexTree.create_from_array(
-        distance_matrix, max_filtration=threshold_radius
+        api.asnumpy(D), max_filtration=threshold_radius
     )
     if function is None:
         return SimplexTreeMulti(st, num_parameters=1)
 
-    function = np.asarray(function)
+    function = api.astensor(function)
     if function.ndim == 1:
         function = function[:, None]
+    if function.ndim != 2:
+        raise ValueError(
+            f"`function.ndim` should be 0 or 1 . Got {function.ndim=}.{function=}"
+        )
     num_parameters = function.shape[1] + 1
     st = SimplexTreeMulti(st, num_parameters=num_parameters)
     for i in range(function.shape[1]):
-        st.fill_lowerstar(function[:, i], parameter=1 + i)
+        st.fill_lowerstar(api.asnumpy(function[:, i]), parameter=1 + i)
+    if api.has_grad(D) or api.has_grad(function):
+        from multipers.grids import compute_grid
+
+        grid = compute_grid([D.ravel(), *[f for f in function.T]])
+        st = st.grid_squeeze(grid)
     return st
 
 
@@ -99,6 +117,7 @@ def DelaunayLowerstar(
     dtype=np.float64,
     verbose: bool = False,
     clear: bool = True,
+    flagify: bool = False,
 ):
     """
     Computes the Function Delaunay bifiltration. Similar to RipsLowerstar, but most suited for low-dimensional euclidean data.
@@ -110,23 +129,44 @@ def DelaunayLowerstar(
      - threshold_radius:  max edge length of the rips. Defaults at min(max(distance_matrix, axis=1)).
     """
     from multipers.slicer import from_function_delaunay
+
+    if flagify and reduce_degree >= 0:
+        raise ValueError(
+            "Got {reduce_degree=} and {flagify=}. Cannot flagify with reduce degree."
+        )
     assert distance_matrix is None, "Delaunay cannot be built from distance matrices"
     if threshold_radius is not None:
         raise NotImplementedError("Delaunay with threshold not implemented yet.")
-    points = np.asarray(points)
-    function = np.asarray(function).squeeze()
+    api = api_from_tensors(points, function)
+    if not flagify and (api.has_grad(points) or api.has_grad(function)):
+        warn("Cannot keep points gradient unless using `flagify=True`.")
+    points = api.astensor(points)
+    function = api.astensor(function).squeeze()
     assert (
         function.ndim == 1
     ), "Delaunay Lowerstar is only compatible with 1 additional parameter."
-    return from_function_delaunay(
-        points,
-        function,
+    slicer = from_function_delaunay(
+        api.asnumpy(points),
+        api.asnumpy(function),
         degree=reduce_degree,
         vineyard=vineyard,
         dtype=dtype,
         verbose=verbose,
         clear=clear,
     )
+    if flagify:
+        from multipers.slicer import to_simplextree
+
+        slicer = to_simplextree(slicer)
+        slicer.flagify(2)
+
+        if api.has_grad(points) or api.has_grad(function):
+            distances = api.cdist(points, points) / 2
+            grid = compute_grid([distances.ravel(), function])
+            slicer = slicer.grid_squeeze(grid)
+            slicer = slicer._clean_filtration_grid()
+
+    return slicer
 
 
 def DelaunayCodensity(
@@ -142,6 +182,7 @@ def DelaunayCodensity(
     dtype=np.float64,
     verbose: bool = False,
     clear: bool = True,
+    flagify: bool = False,
 ):
     """
     TODO
@@ -165,6 +206,7 @@ def DelaunayCodensity(
         dtype=dtype,
         verbose=verbose,
         clear=clear,
+        flagify=flagify,
     )
 
 
@@ -178,6 +220,23 @@ def Cubical(image: ArrayLike, **slicer_kwargs):
      - ** args : specify non-default slicer parameters
     """
     from multipers.slicer import from_bitmap
+
+    api = api_from_tensor(image)
+    image = api.astensor(image)
+    if api.has_grad(image):
+        img2 = image.reshape(-1, image.shape[-1]).T
+        grid = compute_grid(img2)
+        coord_img = np.empty(image.shape, dtype=np.int32)
+        slice_shape = image.shape[:-1]
+        for i in range(image.shape[-1]):
+            coord_img[..., i] = np.searchsorted(
+                api.asnumpy(grid[i]),
+                api.asnumpy(image[..., i]).reshape(-1),
+            ).reshape(slice_shape)
+        slicer = from_bitmap(coord_img, **slicer_kwargs)
+        slicer.filtration_grid = grid
+        return slicer
+
     return from_bitmap(image, **slicer_kwargs)
 
 
@@ -214,7 +273,7 @@ def CoreDelaunay(
         ks = np.arange(1, len(points) + 1)
     else:
         ks = np.asarray(ks, dtype=int)
-    ks:np.ndarray
+    ks: np.ndarray
 
     assert len(ks) > 0, "The parameter ks must contain at least one value."
     assert np.all(ks > 0), "All values in ks must be positive."

multipers/grids.pyx

@@ -1,6 +1,6 @@
 
 from libc.stdint cimport intptr_t, int32_t, int64_t
-from libcpp cimport bool,int,long, float
+from libcpp cimport bool,int, float
 
 cimport numpy as cnp
 import numpy as np
@@ -9,7 +9,8 @@ cnp.import_array()
 
 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
 
 available_strategies = ["regular","regular_closest", "regular_left", "partition", "quantile", "precomputed"]
 Lstrategies = Literal["regular","regular_closest", "regular_left", "partition", "quantile", "precomputed"]
@@ -17,13 +18,22 @@ Lstrategies = Literal["regular","regular_closest", "regular_left", "partition",
 ctypedef fused some_int:
     int32_t
     int64_t
-    int
-    long
 
 ctypedef fused some_float:
     float
     double
 
+def sanitize_grid(grid, bool numpyfy=False):
+    if len(grid) == 0:
+        raise ValueError("empty filtration grid")
+    api = api_from_tensors(*grid)
+    if numpyfy:
+        grid = tuple(api.asnumpy(g) for g in grid)
+    else:
+        # copy here may not be necessary, but cheap
+        grid = tuple(api.astensor(g) for g in grid) 
+    assert np.all([g.ndim==1 for g in grid])
+    return grid
 
 def compute_grid(
         x,
@@ -63,37 +73,57 @@ def compute_grid(
 
 
     cdef bool is_numpy_compatible = True
-    if is_slicer(x):
+    if (is_slicer(x) or is_simplextree_multi(x)) and x.is_squeezed:
+        initial_grid = x.filtration_grid
+        api = api_from_tensors(*initial_grid)
+    elif is_slicer(x):
         initial_grid = x.get_filtrations_values().T
+        api = npapi
     elif is_simplextree_multi(x):
         initial_grid = x.get_filtration_grid()
+        api = npapi
     elif is_mma(x):
         initial_grid = x.get_filtration_values()
+        api = npapi
     elif isinstance(x, np.ndarray):
         initial_grid = x
+        api = npapi
     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:
+        if isinstance(first, tuple) and getattr(first[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)
+            api = api_from_tensors(*initial_grid)
+            initial_grid = api.cat(initial_grid, axis=1)
+            # if isinstance(initial_grid[0], np.ndarray):
+            #     initial_grid = np.concatenate(initial_grid, axis=1)
+            # else:
+            #     is_numpy_compatible = 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:
+            api = api_from_tensors(*x)
+            initial_grid = tuple(api.astensor(f) for f in x)
+            # 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
+
+    num_parameters = len(initial_grid)
+    try:
+        int(resolution)
+        resolution = [resolution]*num_parameters
+    except TypeError:
+        pass
+
+    if api is npapi:
         return _compute_grid_numpy(
         initial_grid,
         resolution=resolution, 
@@ -104,8 +134,10 @@ def compute_grid(
         dense = dense,
         )
     from multipers.torch.diff_grids import get_grid
-    return get_grid(strategy)(initial_grid,resolution)
-
+    grid = get_grid(strategy)(initial_grid,resolution)
+    if dense:
+        grid = todense(grid)
+    return grid
 
 
 
@@ -136,14 +168,6 @@ def _compute_grid_numpy(
     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:
@@ -208,7 +232,7 @@ def todense(grid, bool product_order=False):
 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)])
+    f_regular_closest = np.asarray([f[<int64_t>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
 
@@ -254,7 +278,7 @@ def push_to_grid(some_float[:,:] points, grid, bool return_coordinate=False):
     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)
+    cdef cnp.ndarray[int64_t,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:
@@ -271,7 +295,31 @@ def coarsen_points(some_float[:,:] points, strategy="exact", int resolution=-1,
         return push_to_grid(points, grid, coordinate), grid
     return push_to_grid(points, grid, coordinate)
 
-
+def _inf_value(array):
+    if isinstance(array, type|np.dtype):
+        dtype = np.dtype(array) # torch types are not types
+    elif isinstance(array, np.ndarray):
+        dtype = np.dtype(array.dtype)
+    else:
+        import torch
+        if isinstance(array, torch.Tensor):
+            dtype=array.dtype
+        elif isinstance(array, torch.dtype):
+            dtype=array
+        else:
+            raise ValueError(f"unknown input of type {type(array)=} {array=}")
+
+    if isinstance(dtype, np.dtype):
+        if dtype.kind == 'f':
+            return np.asarray(np.inf,dtype=dtype)
+        if dtype.kind == 'i':
+            return np.iinfo(dtype).max
+    # torch only here.
+    if dtype.is_floating_point:
+        return torch.tensor(torch.inf, dtype=dtype)
+    else:
+        return torch.iinfo(dtype).max
+    raise ValueError(f"Dtype must be integer or floating like (got {dtype})")
 
 def evaluate_in_grid(pts, grid, mass_default=None):
     """    
@@ -280,6 +328,7 @@ def evaluate_in_grid(pts, grid, mass_default=None):
      - pts: of the form array[int, ndim=2]
      - grid of the form Iterable[array[float, ndim=1]]
     """
+    assert pts.ndim == 2
     first_filtration = grid[0]
     dtype = first_filtration.dtype
     if isinstance(first_filtration, np.ndarray):
@@ -295,12 +344,18 @@ def evaluate_in_grid(pts, grid, mass_default=None):
         def empty_like(x):
             return torch.empty(x.shape,dtype=dtype)
 
-    coords= empty_like(pts)
-    for i in range(coords.shape[1]):
+    coords=empty_like(pts)
+    cdef int dim = coords.shape[1]
+    pts_inf = _inf_value(pts)
+    coords_inf = _inf_value(coords)
+    idx = np.argwhere(pts == pts_inf)
+    pts[idx] == 0
+    for i in range(dim):
         coords[:,i] = grid[i][pts[:,i]]
+    coords[idx] = coords_inf
     return coords
 
-def sm_in_grid(pts, weights, grid, int num_parameters=-1, mass_default=None):
+def sm_in_grid(pts, weights, grid, mass_default=None):
     """Given a measure whose points are coordinates,
     pushes this measure in this grid.
     Input
@@ -310,34 +365,33 @@ def sm_in_grid(pts, weights, grid, int num_parameters=-1, mass_default=None):
      - 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 pts.ndim != 2:
+        raise ValueError(f"invalid dirac locations. got {pts.ndim=} != 2")
+    if len(grid) == 0:
+        raise ValueError(f"Empty grid given. Got {grid=}")
+    cdef int num_parameters  = pts.shape[1]
+    if mass_default is None:
+        api = api_from_tensors(*grid)
+    else:
+        api = api_from_tensors(*grid, mass_default)
+
+    _grid = list(grid)
+    _mass_default = None if mass_default is None else api.astensor(mass_default)
+    while len(_grid) < num_parameters:
+        _grid += [api.cat([
+                (gt:=api.astensor(g))[1:],
+                api.astensor(_inf_value(api.asnumpy(gt))).reshape(1)
+            ]) for g in grid]
         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]]
+            _mass_default = api.cat([_mass_default,mass_default])
+    grid = tuple(_grid)
+    mass_default = _mass_default
+
+    coords = evaluate_in_grid(np.asarray(pts, dtype=int), grid, mass_default)
     return (coords, weights)
 
 # TODO : optimize with memoryviews / typing
-def sms_in_grid(sms, grid, int num_parameters=-1, mass_default=None):
+def sms_in_grid(sms, grid, mass_default=None):
     """Given a measure whose points are coordinates,
     pushes this measure in this grid.
     Input
@@ -346,5 +400,34 @@ def sms_in_grid(sms, grid, int num_parameters=-1, mass_default=None):
        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)
+    sms = tuple(sm_in_grid(pts,weights,grid=grid, mass_default=mass_default) for pts,weights in sms)
     return sms
+
+
+def _push_pts_to_line(pts, basepoint, direction=None):
+    api = api_from_tensors(pts, basepoint)
+    pts = api.astensor(pts)
+    basepoint = api.astensor(basepoint)
+    num_parameters = basepoint.shape[0]
+    if direction is not None:
+        if not api.is_promotable(direction):
+            raise ValueError(f"Incompatible input types. Got {type(pts)=}, {type(basepoint)=}, {type(direction)=}")
+
+        direction = api.astensor(direction)
+        ok_idx = direction > 0
+        if ok_idx.sum() == 0:
+            raise ValueError(f"Got invalid direction {direction}")
+        zero_idx = None if ok_idx.all() else direction == 0
+    else:
+        direction = api.tensor([1], dtype=int)
+        ok_idx = slice(None)
+        zero_idx = None
+    xa = api.maxvalues(
+        (pts[:, ok_idx] - basepoint[ok_idx]) / direction[ok_idx], axis=1, keepdims=True
+    )
+    if zero_idx is not None:
+        xb = api.where(pts[:, zero_idx] <= basepoint[zero_idx], -np.inf, np.inf)
+        xs = api.maxvalues(api.cat([xa, xb], axis=1), axis=1, keepdims=True)
+    else:
+        xs = xa
+    return xs.squeeze()

multipers/gudhi/Simplex_tree_multi_interface.h

@@ -21,6 +21,8 @@
 #include "multiparameter_module_approximation/format_python-cpp.h"
 
 #include <iostream>
+#include <ranges>
+#include <stdexcept>
 #include <utility>  // std::pair
 #include <vector>
 #include <limits>  // has_quiet_NaN
@@ -165,7 +167,7 @@ class Simplex_tree_multi_interface
 
   void compute_extended_filtration() { throw std::logic_error("Incompatible with multipers"); }
 
-  Simplex_tree_multi_interface *collapse_edges(int nb_collapse_iteration) {
+  Simplex_tree_multi_interface *collapse_edges([[maybe_unused]] int nb_collapse_iteration) {
     throw std::logic_error("Incompatible with multipers");
   }
 
@@ -292,6 +294,39 @@ class Simplex_tree_multi_interface
     }
   }
 
+  void unsqueeze_filtration(const intptr_t grid_st_ptr,
+                            const std::vector<std::vector<double>> &grid) {  // TODO : this is const but GUDHI
+    if constexpr (Filtration::is_multicritical())
+      throw std::invalid_argument("Multicritical not supported yet");
+    else {
+      constexpr const bool verbose = false;
+      using int_fil_type = decltype(std::declval<Filtration>().template as_type<std::int32_t>());
+      using st_coord_type = Simplex_tree_multi_interface<int_fil_type, int32_t>;
+      st_coord_type &grid_st = *(st_coord_type *)grid_st_ptr;  // TODO : maybe fix this.
+      std::vector<int> simplex_vertex;
+      int num_parameters = grid_st.get_number_of_parameters();
+      for (auto &simplex_handle : grid_st.complex_simplex_range()) {
+        const auto &simplex_filtration = grid_st.filtration(simplex_handle);
+        if constexpr (verbose) std::cout << "Filtration " << simplex_filtration << "\n";
+        Filtration splx_filtration(simplex_filtration.size(), 1.);
+        if (simplex_filtration.is_finite()) {
+          for (auto i : std::views::iota(num_parameters)) splx_filtration[i] = grid[i][simplex_filtration[i]];
+        } else if (simplex_filtration.is_plus_inf()) {
+          splx_filtration = Filtration().inf();
+        } else if (simplex_filtration.is_minus_inf()) {
+          splx_filtration = Filtration().minus_inf();
+        } else if (simplex_filtration.is_nan()) {
+          splx_filtration = Filtration().nan();
+        }
+        if constexpr (verbose) std::cout << "Filtration " << splx_filtration << "\n";
+        for (const auto s : grid_st.simplex_vertex_range(simplex_handle)) simplex_vertex.push_back(s);
+        this->insert_simplex(simplex_vertex, splx_filtration);
+        if constexpr (verbose) std::cout << "Coords in st" << this->filtration(this->find(simplex_vertex)) << std::endl;
+        simplex_vertex.clear();
+      }
+    }
+  }
+
   void squeeze_filtration(const intptr_t outptr,
                           const std::vector<std::vector<double>> &grid) {  // TODO : this is const but GUDHI
     constexpr const bool verbose = false;

multipers/gudhi/gudhi/Multi_persistence/Box.h

@@ -149,6 +149,9 @@ class Box {
     lowerCorner_ -= delta;
     upperCorner_ += delta;
   }
+  friend bool operator==(const Box& a, const Box&b){
+    return a.upperCorner_ == b.upperCorner_ && a.lowerCorner_ == b.lowerCorner_;
+  }
 
   /**
    * @brief Outstream operator.

multipers/gudhi/gudhi/One_critical_filtration.h

@@ -30,7 +30,7 @@
 #include <gudhi/Debug_utils.h>
 
 namespace Gudhi {
-namespace multi_filtration { 
+namespace multi_filtration {
 
 /**
  * @class One_critical_filtration one_critical_filtration.h gudhi/one_critical_filtration.h
@@ -1034,13 +1034,21 @@ class One_critical_filtration : public std::vector<T> {
                 "The grid should not be smaller than the number of parameters in the filtration value.");
     for (std::size_t parameter = 0u; parameter < Base::size(); ++parameter) {
       const auto &filtration = grid[parameter];
-      auto d =
-          std::distance(filtration.begin(),
-                        std::lower_bound(filtration.begin(),
-                                         filtration.end(),
-                                         static_cast<typename oned_array::value_type>(Base::operator[](parameter))));
-      d = d == filtration.size() ? filtration.size() - 1 : d;
-      Base::operator[](parameter) = coordinate ? static_cast<T>(d) : static_cast<T>(filtration[d]);
+      int num_filtration_values = filtration.size();
+      auto this_at_param = static_cast<typename oned_array::value_type>(Base::operator[](parameter));
+      auto it = std::lower_bound(filtration.begin(), filtration.end(), this_at_param);
+      std::size_t idx;
+      if (it == filtration.end()) {
+        idx = num_filtration_values - 1;
+      } else if (it == filtration.begin()) {
+        idx = 0;
+      } else {
+        auto prev = it - 1;
+        idx = (std::abs(*prev - this_at_param) <= std::abs(*it - this_at_param))
+                  ? std::distance(filtration.begin(), prev)
+                  : std::distance(filtration.begin(), it);
+      }
+      Base::operator[](parameter) = coordinate ? static_cast<T>(idx) : static_cast<T>(filtration[idx]);
     }
   }
 
@@ -1393,7 +1401,8 @@ class One_critical_filtration : public std::vector<T> {
   }
 };
 
-}}  // namespace Gudhi::multi_filtration
+}  // namespace multi_filtration
+}  // namespace Gudhi
 
 namespace std {
 

multipers/gudhi/mma_interface_h0.h

@@ -39,7 +39,7 @@ class Persistence_backend_h0 {
   using cycle_type = std::vector<unsigned int>;
   static const bool is_vine = true;
 
-  std::vector<cycle_type> get_representative_cycles(bool update = true) const { throw "Unimplemented"; }
+  std::vector<cycle_type> get_representative_cycles([[maybe_unused]] bool update = true) const { throw "Unimplemented"; }
 
   class Barcode_iterator : public boost::iterator_facade<Barcode_iterator, const Bar &, boost::forward_traversal_tag> {
    public:

multipers/gudhi/mma_interface_matrix.h

@@ -60,10 +60,19 @@ struct No_vine_multi_persistence_options : Gudhi::persistence_matrix::Default_op
   static const bool has_vine_update = false;
 };
 
+template <Gudhi::persistence_matrix::Column_types column_type = Gudhi::persistence_matrix::Column_types::INTRUSIVE_SET, bool row_access = true>
+struct fix_presentation_options : Gudhi::persistence_matrix::Default_options<column_type, true> {
+  using Index = std::uint32_t;
+  static const bool has_row_access = row_access;
+  static const bool has_map_column_container = false;
+  static const bool has_removable_columns = false;  // WARN : idx will change if map is not true
+};
+
 template <class Matrix_options, class Boundary_matrix_type>
 class Persistence_backend_matrix {
  public:
   using matrix_type = Gudhi::persistence_matrix::Matrix<Matrix_options>;
+  using options = Matrix_options;
   using cycle_type = typename matrix_type::Cycle;
   static const bool is_vine = Matrix_options::has_vine_update;
 
@@ -228,7 +237,7 @@ class Persistence_backend_matrix {
 
   inline Barcode get_barcode() { return Barcode(matrix_, permutation_); }
 
-  inline std::size_t size() { return this->matrix_.get_number_of_columns(); }
+  inline std::size_t size() const { return this->matrix_.get_number_of_columns(); }
 
   inline friend std::ostream &operator<<(std::ostream &stream, Persistence_backend_matrix &structure) {
     stream << "[\n";

multipers/gudhi/naive_merge_tree.h

@@ -314,7 +314,7 @@ class Naive_merge_forest {
   struct Barcode {
     Barcode() {}
 
-    Barcode(int numberOfSimplices, int numberOfVertices)
+    Barcode(int numberOfSimplices, [[maybe_unused]] int numberOfVertices)
         : barcode_(numberOfSimplices), positionToBar_(numberOfSimplices), nextBarIndex_(0) {}
 
     friend void swap(Barcode &mf1, Barcode &mf2) {