multipers 2.3.0__cp311-cp311-win_amd64.whl → 2.3.2__cp311-cp311-win_amd64.whl

multipers/slicer.pyx.tp

@@ -11,6 +11,7 @@ import pickle
 with open("build/tmp/_slicer_names.pkl", "rb") as f:
   slicers=pickle.load(f)
 
+dtypes = set([(D['PY_VALUE_TYPE'], D['C_VALUE_TYPE'], D['SHORT_VALUE_TYPE']) for D in slicers])
 
 }}
 
@@ -20,13 +21,15 @@ from typing import Optional,Literal
 import threading
 import os 
 from joblib import Parallel, delayed
+from warnings import warn
 
 from multipers.slicer cimport *
 from multipers.filtrations cimport *
 from multipers.filtration_conversions cimport *
 ## TODO: these two are not needed, remove that by updating rank code.
 from multipers.point_measure import sparsify, rank_decomposition_by_rectangles
-from multipers.grids import compute_grid
+from multipers.grids import compute_grid, sanitize_grid, evaluate_in_grid, _push_pts_to_line 
+from multipers.array_api import api_from_tensor
 
 import numpy as np
 cimport cython
@@ -104,7 +107,7 @@ _valid_pers_backend = Literal[
 #------------------------------------------------------------------------------
 cdef class {{D['PYTHON_TYPE']}}:
     cdef {{D['C_TEMPLATE_TYPE']}} truc
-    cdef public vector[vector[double]] filtration_grid
+    cdef public object filtration_grid
     cdef public int minpres_degree ## TODO : maybe change directly the degree in the minpres ?
 
     def __repr__(self):
@@ -112,7 +115,7 @@ cdef class {{D['PYTHON_TYPE']}}:
 
     @property
     def is_squeezed(self)->bool:
-        return self.filtration_grid.size() > 0 and self.filtration_grid[0].size() > 0
+        return self.filtration_grid is not None and len(self.filtration_grid) > 0 and len(self.filtration_grid[0]) > 0
     @property
     def is_minpres(self)->bool:
         return self.minpres_degree>=0
@@ -215,6 +218,25 @@ cdef class {{D['PYTHON_TYPE']}}:
         self.minpres_degree = -1
     {{endif}}
     
+    def to_colexical(self, bool return_permutation = False)->{{D['PYTHON_TYPE']}}|tuple[{{D['PYTHON_TYPE']}},np.ndarray]:
+        # assert not self.is_squeezed, "Unsqueeze first, this is not implented yet for squeezed slicers"
+        new_slicer = {{D['PYTHON_TYPE']}}()
+        cdef pair[{{D['C_TEMPLATE_TYPE']}}, vector[unsigned int]] stuff = self.truc.colexical_rearange()
+
+        new_slicer.truc = stuff.first
+        new_slicer.minpres_degree = self.minpres_degree
+        new_slicer.filtration_grid = self.filtration_grid
+
+        if return_permutation:
+            return new_slicer, np.array(stuff.second, dtype=np.int32)
+        return new_slicer
+    def permute_generators(self, permutation)->{{D['PYTHON_TYPE']}}:
+        cdef vector[unsigned int] c_perm = permutation
+        new_slicer = {{D['PYTHON_TYPE']}}()
+        new_slicer.truc = self.truc.permute(c_perm)
+        new_slicer.minpres_degree = self.minpres_degree
+        return new_slicer
+
     def copy(self)->{{D['PYTHON_TYPE']}}:
         """
         Returns a copy of the slicer.
@@ -224,6 +246,21 @@ cdef class {{D['PYTHON_TYPE']}}:
         copy_.minpres_degree = self.minpres_degree
         copy_.filtration_grid = self.filtration_grid
         return copy_
+    def compute_kernel_projective_cover(self, dim:Optional[int]=None)->{{D['PYTHON_TYPE']}}:
+        if len(self) == 0:
+            return {{D['PYTHON_TYPE']}}()
+        if dim is None:
+            dim = self.truc.get_dimension(0)
+        out = {{D['PYTHON_TYPE']}}()
+        out.truc = self.truc.projective_cover_kernel(dim)
+        out.filtration_grid = self.filtration_grid
+        return out
+
+    def get_barcode_idx(self, bool keep_inf = False):
+        """
+        Returns the current barcode.
+        """
+        return tuple(np.asarray(x) if len(x) else np.empty((0,2), dtype=int)for x in self.truc.get_barcode_idx())
     def get_barcode(self, bool keep_inf = False):
         """
         Returns the current barcode.
@@ -232,12 +269,13 @@ cdef class {{D['PYTHON_TYPE']}}:
             bcs = tuple(np.asarray(stuff, dtype = {{D['PY_VALUE_TYPE']}}) for stuff in self.truc.get_barcode())
         else:
             bcs = {{D['PYTHON_TYPE']}}._threshold_bcs(self.truc.get_barcode())
-        return self.truc.get_barcode()
+        return bcs
     def push_to_line(self, basepoint, direction=None)->{{D['PYTHON_TYPE']}}:
         """
         Pushes the current slicer to the line defined by a basepoint and an optional direction.
         If the direction is not provided, it is assumed to be diagonal.
         """
+        {{if D['IS_FLOAT']}}
         basepoint = np.asarray(basepoint, dtype = {{D['PY_VALUE_TYPE']}})
         cdef Line[{{D['C_VALUE_TYPE']}}] line
         if direction is None:
@@ -247,6 +285,9 @@ cdef class {{D['PYTHON_TYPE']}}:
             line = Line[{{D['C_VALUE_TYPE']}}](_py21c_{{D['SHORT_VALUE_TYPE']}}(basepoint),_py21c_{{D['SHORT_VALUE_TYPE']}}(direction))
         self.truc.push_to(line)
         return self
+        {{else}}
+        raise NotImplementedError("There is no `int` slicing.")
+        {{endif}}
 
     @staticmethod
     cdef _threshold_bcs(vector[vector[pair[{{D['C_VALUE_TYPE']}}, {{D['C_VALUE_TYPE']}}]]] bcs):
@@ -254,11 +295,11 @@ cdef class {{D['PYTHON_TYPE']}}:
     @staticmethod
     def _bc_to_full(bcs, basepoint, direction=None):
         # i, (b sv d), coords 
-        basepoint = np.asarray(basepoint)[None,None,:]
-        direction = 1 if direction is None else np.asarray(direction)[None,None,:]
+        basepoint = basepoint[None,None,:]
+        direction = 1 if direction is None else direction[None,None,:]
         return tuple(bc[:,:,None]*direction + basepoint for bc in bcs)
 
-    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False):
+    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Computes the persistence on a line L defined by 
          - a basepoint (num_parameters,) array
@@ -266,8 +307,9 @@ cdef class {{D['PYTHON_TYPE']}}:
         
         Warning: This is not parallelizable. Use `persitence_on_lines`.
         """
+        {{if D['IS_FLOAT']}}
         self.push_to_line(basepoint,direction)
-        self.truc.compute_persistence()
+        self.truc.compute_persistence(ignore_infinite_filtration_values)
         if keep_inf:
             bcs = tuple(np.asarray(stuff, dtype = {{D['PY_VALUE_TYPE']}}) for stuff in self.truc.get_barcode())
         else:
@@ -276,8 +318,36 @@ cdef class {{D['PYTHON_TYPE']}}:
         if full:
             bcs = {{D['PYTHON_TYPE']}}._bc_to_full(bcs, basepoint, direction)
         return bcs
+        {{else}}
+        if not self.is_squeezed:
+            raise ValueError("Unsqueeze tensor, or provide a filtration grid. Cannot slice lines with integers...")
+        api = api_from_tensor(self.filtration_grid[0])
+        s = self.unsqueeze()
+        fil = evaluate_in_grid(np.asarray(self.get_filtrations()), self.filtration_grid)
+        projected_fil =_push_pts_to_line(fil, basepoint, direction)
+        s.compute_persistence(projected_fil)
+        bcs_idx = s.get_barcode_idx()
+        bcs = tuple(
+                api.stack([projected_fil[bc[:,0]], projected_fil[bc[:,1]]], axis=1) 
+                if bc.size>0 
+                else api.empty((0,2), dtype = self.filtration_grid[0].dtype)
+                for bc in bcs_idx
+            )
+        if full:
+            bcs = self._bc_to_full(bcs, basepoint, direction)
+        return bcs
+        {{endif}}
 
-    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False):
+    def _custom_persistences_idx(self, filtration_array, bool ignore_inf=True):
+      filtration_array = np.asarray(filtration_array, dtype= {{D['PY_VALUE_TYPE']}})
+      cdef {{D['C_VALUE_TYPE']}}[:,:] arr_view = filtration_array
+      cdef int size = arr_view.shape[0]
+      if arr_view.shape[1] != self.truc.num_generators():
+          raise ValueError(f"Got filtration array of shape {filtration_array.shape=} / {arr_view.shape=}. Was expecting (-1, {len(self)=})")
+
+      return tuple(tuple(np.array(bc_idx_degree, dtype=int) for bc_idx_degree in bc_idx) for bc_idx in self.truc.custom_persistences(&arr_view[0,0], size, ignore_inf))
+
+    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Same as `persistence_on_line`, but with vineyards operation between
         lines if `self.is_vine`, and in parallel otherwise.
@@ -288,15 +358,17 @@ cdef class {{D['PYTHON_TYPE']}}:
         if directions is None:
             c_basepoints = basepoints
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_basepoints)
+                c_out = self.truc.persistence_on_lines(c_basepoints, ignore_infinite_filtration_values)
         else:
             c_truc = zip(basepoints,directions)
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_truc)
+                c_out = self.truc.persistence_on_lines(c_truc, ignore_infinite_filtration_values)
         cdef int num_bc = c_basepoints.size()
         
         if keep_inf:
-            out = tuple(tuple(np.asarray(y, dtype = {{D['PY_VALUE_TYPE']}}) for y in x) for x in c_out)
+            out = tuple(tuple(
+                np.asarray(y, dtype = {{D['PY_VALUE_TYPE']}}) if len(y)>0 else np.empty((0,2), dtype = {{D['PY_VALUE_TYPE']}})
+            for y in x) for x in c_out)
         else:
             out = tuple({{D['PYTHON_TYPE']}}._threshold_bcs(x) for x in c_out)
 
@@ -311,7 +383,7 @@ cdef class {{D['PYTHON_TYPE']}}:
             self.get_boundaries(),
             self.get_dimensions(),
             self.get_filtrations(),
-            tuple(np.array(f) for f in self.filtration_grid),
+            self.filtration_grid,
             self.minpres_degree,
         )
     def __setstate__(self, tuple dump):
@@ -340,26 +412,50 @@ cdef class {{D['PYTHON_TYPE']}}:
 
 
 
-    def compute_persistence(self,one_filtration=None, bool ignore_infinite_filtration_values = True)->{{D['PYTHON_TYPE']}}:
+    def compute_persistence(self,one_filtration=None, bool ignore_infinite_filtration_values = True)->tuple:
         """
         Computes the current persistence, or the persistence
         given by the filtration one_filtration (num_generators,).
         """
         if one_filtration is not None:
-            self.truc.set_one_filtration(one_filtration)
+            api = api_from_tensor(one_filtration)
+            one_filtration=api.astensor(one_filtration)
+            # self.truc.set_one_filtration(one_filtration)
+            # s = self.unsqueeze()
+            # fil = evaluate_in_grid(np.asarray(self.get_filtrations()), self.filtration_grid)
+            # projected_fil =_push_pts_to_line(fil, basepoint, direction)
+            if one_filtration.ndim > 2 or one_filtration.ndim == 0:
+                raise ValueError(f"Expected a filtration shape of the form ((num_1_param), num_generators). Got {one_filtration.shape=}")
+            squeeze = False
+            if one_filtration.ndim == 1:
+                one_filtration = one_filtration[None]
+                squeeze = True
+
+            bcs = self._custom_persistences_idx(api.asnumpy(one_filtration),ignore_infinite_filtration_values)
+            
+            bcs = tuple(tuple(
+                    api.stack([F[bc[:,0]], F[bc[:,1]]], axis=1) 
+                    if bc.size>0 
+                    else api.empty((0,2), dtype = F.dtype)
+                    for bc in bcs_idx
+                )
+                for bcs_idx,F in zip(bcs,one_filtration)
+            )
+            return bcs[0] if squeeze else bcs
+
         # TODO: Later
         # if len(degrees)>0:
         #     self.truc.compute_persistence(degrees)
         # else:
         #     self.truc.compute_persistence()
         self.truc.compute_persistence(ignore_infinite_filtration_values)
-        return self
-        # return self.truc.get_barcode()
+        # return self
+        return self.get_barcode()
     def get_barcode(self):
         """
         Returns the barcode of the current 1d-persistence.
         """
-        return self.truc.get_barcode()
+        return tuple(np.asarray(bc) for bc in self.truc.get_barcode())
     def sliced_filtration(self,basepoint, direction=None):
         """
         Computes the filtration on a line L defined by 
@@ -432,7 +528,15 @@ cdef class {{D['PYTHON_TYPE']}}:
         Returns the boundaries of the generators.
         """
         return tuple(tuple(b) for b in self.truc.get_boundaries())
-    def grid_squeeze(self, filtration_grid=None, grid_strategy="exact", resolution:Optional[int]=None, bool coordinates=True, bool inplace = False, bool force=False)->{{D['PYTHON_TYPE'][:-3]+"i32"}}|{{D['PYTHON_TYPE']}}:
+    def grid_squeeze(
+            self, 
+            filtration_grid=None,
+            strategy="exact",
+            resolution:Optional[int]=None,
+            bool coordinates=True,
+            bool inplace = False,
+            grid_strategy=None
+        )->{{D['PYTHON_TYPE'][:-3]+"i32"}}|{{D['PYTHON_TYPE']}}:
         """
         Coarsen the filtration values on a grid. This is necessary to compute some invariants.
 
@@ -443,28 +547,53 @@ cdef class {{D['PYTHON_TYPE']}}:
 
          - inplace:bool if true, does the operation inplace, i.e., doesn't return a copy.
         """
-        if not force and self.is_squeezed:
-            raise ValueError("The slicer seems to be already squeezed. Use force=True to resqueeze.")
+        if grid_strategy is not None:
+            warn("`grid_strategy` is deprecated, use `strategy` instead.",DeprecationWarning)
+            strategy=grid_strategy
+
+        if self.is_squeezed:
+            warn("(copy warning) Squeezing an already squeezed slicer.")
+            temp = self.unsqueeze()
+            subgrid = compute_grid(self.filtration_grid, strategy=strategy, resolution=resolution)
+            return temp.grid_squeeze(subgrid, coordinates=coordinates, inplace=inplace)
+
         if filtration_grid is None:
             filtration_grid = compute_grid(
                     self.get_filtrations_values().T,
-                    strategy=grid_strategy,
+                    strategy=strategy,
                     resolution=resolution)
         cdef vector[vector[{{D['C_VALUE_TYPE']}}]] grid = filtration_grid
         if inplace or not coordinates:
             self.truc.coarsen_on_grid_inplace(grid, coordinates)
-            self.filtration_grid = filtration_grid
+            if coordinates:
+                self.filtration_grid = filtration_grid
         else:
           {{if D['COLUMN_TYPE'] is None}}
           raise ValueError("WIP")
           {{else}}
           out = {{D['PYTHON_TYPE'][:-3]+"i32"}}()
           out.truc = self.truc.coarsen_on_grid(grid)
-          out.filtration_grid = filtration_grid
+          if coordinates:
+              out.filtration_grid = sanitize_grid(filtration_grid)
           out.minpres_degree = self.minpres_degree
           return out
           {{endif}}
         return self
+    def _clean_filtration_grid(self):
+        """
+        Removes the values in filtration_grid that are not linked to any splx.
+        """
+        if not self.is_squeezed:
+            raise ValueError("No grid to clean.")
+        F = self.filtration_grid
+        self.filtration_grid=None
+        cleaned_coordinates = compute_grid(self)
+        new_slicer = self.grid_squeeze(cleaned_coordinates)
+
+        self._from_ptr(new_slicer.get_ptr())
+        self.filtration_grid = tuple(f[g] for f,g in zip(F,cleaned_coordinates))
+        return self
+
     def minpres(self,
         int degree=-1, 
         list[int] degrees=[],
@@ -479,7 +608,7 @@ cdef class {{D['PYTHON_TYPE']}}:
         Computes the minimal presentation of the slicer, and returns it as a new slicer.
         See :func:`multipers.slicer.minimal_presentation`.
         """
-        new_slicer = minimal_presentation(self, degree=degree, degrees=degrees, backend=backend, slicer_backend=slicer_backend, vineyard=vineyard, id=id, **minpres_kwargs)
+        new_slicer = minimal_presentation(self, degree=degree, degrees=degrees, backend=backend, slicer_backend=slicer_backend, dtype=dtype, vineyard=vineyard, id=id, **minpres_kwargs)
         return new_slicer
 
     @property
@@ -556,10 +685,11 @@ cdef class {{D['PYTHON_TYPE']}}:
           self.truc.build_from_scc_file(c_path, rivet_compatible, reverse, shift_dimension)
         return self
 
-    def unsqueeze(self, grid=None, dtype = np.float64):
-        from multipers.grids import evaluate_in_grid
+    def unsqueeze(self, grid=None)->{{D['PYTHON_TYPE'][:-3]+"f64"}}:
+        from multipers.grids import evaluate_in_grid, sanitize_grid
         from multipers import Slicer
-        grid = tuple(np.asarray(f) for f in self.filtration_grid) if grid is None else grid
+        grid = self.filtration_grid if grid is None else grid
+        grid = sanitize_grid(grid, numpyfy=True)
         new_filtrations = evaluate_in_grid(np.asarray(self.get_filtrations(), dtype=np.int32), grid)
         new_slicer = {{D['PYTHON_TYPE'][:-3]+"f64"}}(
             self.get_boundaries(),
@@ -580,10 +710,13 @@ cdef extern from "gudhi/cubical_to_boundary.h" namespace "":
   void get_vertices(unsigned int, cset[unsigned int]&, const vector[vector[unsigned int]]&) nogil
 
 
-def from_bitmap(image, **slicer_kwargs):
+{{for pytype,ctype,fshort in dtypes}}
+def _from_bitmap{{fshort}}(image, **slicer_kwargs):
     from multipers import Slicer
-    image = np.asarray(image)
-    slicer_kwargs["dtype"] = slicer_kwargs.get("dtype", image.dtype)
+    dtype = slicer_kwargs.get("dtype", image.dtype)
+    slicer_kwargs["dtype"] = dtype
+    if image.dtype  !=  dtype:
+        raise ValueError(f"Invalid type matching. Got {dtype=} and {image.dtype=}")
     _Slicer = Slicer(return_type_only=True, **slicer_kwargs)
     cdef vector[unsigned int] img_shape = image.shape[:-1]
     cdef unsigned int num_parameters = image.shape[-1]
@@ -593,11 +726,12 @@ def from_bitmap(image, **slicer_kwargs):
     with nogil:
         _to_boundary(img_shape,gen_maps, gen_dims)
 
-    cdef unsigned int num_gens = gen_dims.size()
-    filtration_values = np.zeros(shape=(num_gens, num_parameters), dtype = np.double) - np.inf
-    cdef double[:,:] F = filtration_values
-    cdef double[:,:] c_img = image.reshape(-1,num_parameters)
     cdef cset[unsigned int] vertices
+
+    cdef unsigned int num_gens = gen_dims.size()
+    filtration_values = np.zeros(shape=(num_gens, num_parameters), dtype = {{pytype}}) - _Slicer._inf_value()
+    cdef {{ctype}}[:,:] F = filtration_values
+    cdef {{ctype}}[:,:] c_img = image.reshape(-1,num_parameters)
     with nogil:
         for i in range(num_gens):
             # with gil:
@@ -615,13 +749,22 @@ def from_bitmap(image, **slicer_kwargs):
             #     print(f"F = {np.asarray(F[i])}")
     slicer = _Slicer(gen_maps, gen_dims, filtration_values)
     return slicer
+{{endfor}}
+
+def from_bitmap(img, **kwargs):
+    img = np.asarray(img)
+    {{for pytype,ctype,stype in dtypes}}
+    if img.dtype == {{pytype}}:
+        return _from_bitmap{{stype}}(img, **kwargs)
+    {{endfor}}
+    raise ValueError(f"Invalid dtype. Got {img.dtype=}, was expecting {available_dtype=}.")
 
 def from_function_delaunay(
     points,
     grades,
     int degree=-1,
-    backend: Optional[_valid_pers_backend]=None,
-    vineyard:Optional[bool]=None,
+    backend:Optional[_valid_pers_backend]=None,
+    vineyard=None, # TODO : Optional[bool] when cython fixes it
     dtype=np.float64,
     bool verbose = False,
     bool clear = True,
@@ -636,9 +779,9 @@ def from_function_delaunay(
     backend : slicer backend, e.g. "matrix", "clement"
     vineyard : bool, use a vineyard-compatible backend
     """
-    from multipers.io import _init_external_softwares, function_delaunay_presentation_to_slicer
+    from multipers.io import _check_available, function_delaunay_presentation_to_slicer
     s = multipers.Slicer(None, backend=backend, vineyard=vineyard, dtype=dtype)
-    _init_external_softwares(requires=["function_delaunay"])
+    assert _check_available("function_delaunay"), f"Could not find function_delaunay"
     function_delaunay_presentation_to_slicer(s, points, grades, degree=degree, verbose=verbose,clear=clear)
     if degree >= 0:
         s.minpres_degree = degree
@@ -675,6 +818,7 @@ def minimal_presentation(
         dtype:type|_valid_dtypes=None,
         int n_jobs = -1,
         bool force=False,
+        bool auto_clean = True,
         **minpres_kwargs
         ):
     """
@@ -685,7 +829,7 @@ def minimal_presentation(
     from multipers.io import _init_external_softwares, input_path, scc_reduce_from_str_to_slicer
     if is_slicer(slicer) and slicer.is_minpres and not force:
         from warnings import warn
-        warn(f"The slicer seems to be already reduced, from homology of degree {slicer.minpres_degree}.")
+        warn(f"(unnecessary computation) The slicer seems to be already reduced, from homology of degree {slicer.minpres_degree}.")
         return slicer
     _init_external_softwares(requires=[backend])
     if len(degrees)>0:
@@ -696,22 +840,25 @@ def minimal_presentation(
         )
         # return tuple(minimal_presentation(slicer, degree=d, backend=backend, slicer_backend=slicer_backend, vineyard=vineyard, id=id, **minpres_kwargs) for d in degrees)
     assert degree>=0, f"Degree not provided."
-    filtration_grid = slicer.filtration_grid if slicer.is_squeezed else None
+    if not np.any(slicer.get_dimensions() == degree):
+        return type(slicer)()
     if id is None:
         id = str(threading.get_native_id())
     if dtype is None:
         dtype = slicer.dtype
     dimension = slicer.dimension - degree # latest  = L-1, which is empty, -1 for degree 0, -2 for degree 1 etc.
-    slicer.to_scc(path=input_path+id, strip_comments=True, degree=degree-1)
+    slicer.to_scc(path=input_path+id, strip_comments=True, degree=degree-1, unsqueeze = False)
     new_slicer = multipers.Slicer(None,backend=slicer_backend, vineyard=vineyard, dtype=dtype)
     if backend=="mpfree":
         shift_dimension=degree-1
     else:
         shift_dimension=degree
     scc_reduce_from_str_to_slicer(path=input_path+id, slicer=new_slicer, dimension=dimension, backend=backend, shift_dimension=shift_dimension, **minpres_kwargs)
+
     new_slicer.minpres_degree = degree
-    if filtration_grid is not None:
-      new_slicer.filtration_grid = filtration_grid
+    new_slicer.filtration_grid = slicer.filtration_grid if slicer.is_squeezed else None
+    if new_slicer.is_squeezed and auto_clean:
+        new_slicer = new_slicer._clean_filtration_grid()
     return new_slicer
 
 
@@ -890,24 +1037,38 @@ def _rank_from_slicer(
 
     cdef int num_parameters = len(grid_shape)
 
-    if zero_pad:
-        for i, _ in enumerate(grid_shape):
-            grid_shape[i] += 1 # adds a 0
+    # if zero_pad:
+    #     grid_shape += 1
+        # for i, _ in enumerate(grid_shape):
+        #     grid_shape[i] += 1 # adds a 0
         # for i,f in enumerate(grid_conversion):
         #     grid_conversion[i] = np.concatenate([f, [mass_default[i]]])
 
+
     grid_shape_with_degree = np.asarray(np.concatenate([[len(degrees)], grid_shape, grid_shape]), dtype=python_indices_type)
+    if verbose:
+        print("Container shape: ", grid_shape_with_degree)
     container_array = np.ascontiguousarray(np.zeros(grid_shape_with_degree, dtype=python_tensor_dtype).ravel())
     assert len(container_array) < np.iinfo(python_indices_type).max, "Too large container. Raise an issue on github if you encounter this issue. (Due to tensor's operator[])"
+    # if zero_pad:
+    #     grid_shape_with_degree[1:] -= 1
     cdef vector[indices_type] c_grid_shape = grid_shape_with_degree
     cdef tensor_dtype[::1] container = container_array
     cdef tensor_dtype* container_ptr = &container[0]
 
     ## SLICERS
+    if verbose:
+        print("Computing rank invariant...", end="")
     _compute_rank_invariant(slicer, container_ptr, c_grid_shape, degrees, n_jobs, ignore_inf)
+    if verbose:
+        print("Done.")
 
+    if verbose:
+        print("Computing Möbius inversion...", end="")
+    # if zero_pad:
+    #     grid_shape_with_degree[1:] += 1
     rank = container_array.reshape(grid_shape_with_degree)
-    rank = tuple(rank_decomposition_by_rectangles(rank_of_degree, threshold = zero_pad) for rank_of_degree in rank)
+    rank = tuple(rank_decomposition_by_rectangles(rank_of_degree, threshold=zero_pad) for rank_of_degree in rank)
     if return_raw:
         return rank
     out = []
@@ -921,4 +1082,6 @@ def _rank_from_slicer(
         return coords, weights
 
     out = tuple(clean_rank(rank_decomposition) for rank_decomposition in rank)
+    if verbose:
+        print("Done.")
     return out

multipers/tensor/tensor.h

@@ -583,7 +583,7 @@ class static_tensor_view_view
   // 	}
   // }
   template <typename T = std::initializer_list<indices_type>>
-  inline dtype &operator[](T coords) {
+  inline dtype &operator[]([[maybe_unused]] T coords) {
     throw std::logic_error("Not yet implemented");
     // this->compute_cum_res();
     // assert(this->cum_resolution_view.size() == coords.size());

multipers/tests/__init__.py

@@ -21,11 +21,15 @@ def sort_sm(sms):
     return tuple((sm[0][idx], sm[1][idx]) for sm in sms)
 
 
-def assert_sm_pair(sm1, sm2, exact=True, max_error=1e-3, reg=0.1):
+def assert_sm_pair(sm1, sm2, exact=True, max_error=1e-3, reg=0.1, threshold=None):
     if not exact:
         from multipers.distances import sm_distance
+        if threshold is not None:
+            _inf_value_fix = threshold
+            sm1[0][sm1[0] >threshold] = _inf_value_fix
+            sm2[0][sm2[0] >threshold] = _inf_value_fix
 
-        d = sm_distance(sm1, sm2, reg=0.1)
+        d = sm_distance(sm1, sm2, reg=reg)
         assert d < max_error, f"Failed comparison:\n{sm1}\n{sm2},\n with distance {d}."
         return
     assert np.all(
@@ -37,10 +41,11 @@ def assert_sm_pair(sm1, sm2, exact=True, max_error=1e-3, reg=0.1):
     ), f"Failed comparison:\n-----------------\n{sm1}\n-----------------\n{sm2}"
 
 
-def assert_sm(*args, exact=True, max_error=1e-5, reg=0.1):
+def assert_sm(*args, exact=True, max_error=1e-5, reg=0.1, threshold=None):
     sms = tuple(args)
     for i in range(len(sms) - 1):
-        assert_sm_pair(sms[i], sms[i + 1], exact=exact, max_error=max_error, reg=reg)
+        print(i)
+        assert_sm_pair(sms[i], sms[i + 1], exact=exact, max_error=max_error, reg=reg, threshold=threshold)
 
 
 def random_st(npts=100, num_parameters=2, max_dim=2):

multipers/torch/diff_grids.py

@@ -15,6 +15,8 @@ def get_grid(strategy: Literal["exact", "regular_closest", "regular_left", "quan
     match strategy:
         case "exact":
             return _exact_grid
+        case "regular":
+            return _regular_grid
         case "regular_closest":
             return _regular_closest_grid
         case "regular_left":
@@ -35,27 +37,44 @@ def todense(grid: list[torch.Tensor]):
 
 
 def _exact_grid(filtration_values, r=None):
+    assert r is None
     grid = tuple(_unique_any(f) for f in filtration_values)
     return grid
 
 
-def _regular_closest_grid(filtration_values, r: int):
-    grid = tuple(_regular_closest(f, r) for f in filtration_values)
+def _regular_closest_grid(filtration_values, res):
+    grid = tuple(_regular_closest(f, r) for f,r in zip(filtration_values, res))
     return grid
 
+def _regular_grid(filtration_values, res):
+    grid = tuple(_regular(g,r) for g,r in zip(filtration_values, res))
+    return grid
+
+def _regular(x, r:int):
+    if x.ndim != 1:
+        raise ValueError(f"Got ndim!=1. {x=}")
+    return torch.linspace(start=torch.min(x), end=torch.max(x), steps=r, dtype=x.dtype) 
 
-def _regular_left_grid(filtration_values, r: int):
-    grid = tuple(_regular_left(f, r) for f in filtration_values)
+def _regular_left_grid(filtration_values, res):
+    grid = tuple(_regular_left(f, r) for f,r in zip(filtration_values,res))
     return grid
 
 
-def _quantile_grid(filtration_values, r: int):
-    qs = torch.linspace(0, 1, r)
-    grid = tuple(_unique_any(torch.quantile(f, q=qs)) for f in filtration_values)
+def _quantile_grid(filtration_values, res):
+    grid = tuple(_quantile(f, r) for f,r in zip(filtration_values,res))
     return grid
+def _quantile(x, r):
+    if x.ndim != 1:
+        raise ValueError(f"Got ndim!=1. {x=}")
+    qs = torch.linspace(0, 1, r, dtype=x.dtype)
+    return _unique_any(torch.quantile(x, q=qs))
+
+
 
 
 def _unique_any(x, assume_sorted=False, remove_inf: bool = True):
+    if x.ndim != 1:
+        raise ValueError(f"Got ndim!=1. {x=}")
     if not assume_sorted:
         x, _ = x.sort()
     if remove_inf and x[-1] == torch.inf:
@@ -68,6 +87,8 @@ def _unique_any(x, assume_sorted=False, remove_inf: bool = True):
 
 
 def _regular_left(f, r: int, unique: bool = True):
+    if f.ndim != 1:
+        raise ValueError(f"Got ndim!=1. {f=}")
     f = _unique_any(f)
     with torch.no_grad():
         f_regular = torch.linspace(f[0].item(), f[-1].item(), r, device=f.device)
@@ -79,6 +100,8 @@ def _regular_left(f, r: int, unique: bool = True):
 
 
 def _regular_closest(f, r: int, unique: bool = True):
+    if f.ndim != 1:
+        raise ValueError(f"Got ndim!=1. {f=}")
     f = _unique_any(f)
     with torch.no_grad():
         f_reg = torch.linspace(

multipers/torch/rips_density.py

@@ -5,7 +5,7 @@ import torch
 import gudhi as gd
 
 import multipers as mp
-from multipers.ml.convolutions import DTM, KDE
+from multipers.filtrations.density import DTM, KDE
 from multipers.simplex_tree_multi import _available_strategies
 from multipers.torch.diff_grids import get_grid