multipers 2.3.1__cp312-cp312-win_amd64.whl → 2.3.2b1__cp312-cp312-win_amd64.whl

multipers/simplex_tree_multi.pyx

@@ -51,7 +51,8 @@ cimport cython
 from gudhi.simplex_tree import SimplexTree ## Small hack for typing
 from typing import Iterable,Literal,Optional
 from tqdm import tqdm
-from multipers.grids import Lstrategies, compute_grid
+from multipers.grids import Lstrategies, compute_grid, sanitize_grid
+from multipers.array_api import api_from_tensor
 from multipers.point_measure import signed_betti, rank_decomposition_by_rectangles, sparsify
 
 from warnings import warn
@@ -81,8 +82,8 @@ cdef class SimplexTreeMulti_KFi32:
     """
     cdef public intptr_t thisptr
 
-    cdef public vector[vector[double]] filtration_grid
-    cdef public bool _is_function_simplextree 
+    cdef public object filtration_grid
+    cdef public bool _is_function_simplextree  # TODO : deprecate
     # Get the pointer casted as it should be
     cdef Simplex_tree_multi_interface[KFi32, int32_t]* get_ptr(self) noexcept nogil:
         return <Simplex_tree_multi_interface[KFi32, int32_t]*>(self.thisptr)
@@ -153,7 +154,7 @@ cdef class SimplexTreeMulti_KFi32:
             self.thisptr = <intptr_t>(new Simplex_tree_multi_interface[KFi32, int32_t]())
         self.set_num_parameter(num_parameters)
         self._is_function_simplextree = False
-        self.filtration_grid=[[]*num_parameters]
+        self.filtration_grid=[]
 
     def __dealloc__(self):
         cdef Simplex_tree_multi_interface[KFi32,int32_t]* ptr = self.get_ptr()
@@ -821,11 +822,26 @@ cdef class SimplexTreeMulti_KFi32:
             out = self.get_ptr().get_filtration_values(degrees)
         filtrations_values =  [np.asarray(filtration) for filtration in out]
         # Removes infs
-        if inf_to_nan:
+        if inf_to_nan and np.dtype(filtrations_values[0].dtype).kind == 'f':
             for i,f in enumerate(filtrations_values):
                 filtrations_values[i][f == np.inf] = np.nan
                 filtrations_values[i][f == - np.inf] = np.nan
         return filtrations_values
+    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_st = self.grid_squeeze(cleaned_coordinates)
+
+        self.thisptr, new_st.thisptr = new_st.thisptr, self.thisptr
+        self.filtration_grid = tuple(f[g] for f,g in zip(F,cleaned_coordinates))
+        return self
+
 
 
     def get_filtration_grid(self, resolution:Iterable[int]|None=None, degrees:Iterable[int]|None=None, drop_quantiles:float|tuple=0, grid_strategy:_available_strategies="exact")->Iterable[np.ndarray]:
@@ -861,8 +877,16 @@ cdef class SimplexTreeMulti_KFi32:
         return compute_grid(filtrations_values, resolution=resolution,strategy=grid_strategy,drop_quantiles=drop_quantiles)
 
 
-
-    def grid_squeeze(self, filtration_grid:np.ndarray|list|None=None, bool coordinate_values=True, force=False, grid_strategy:_available_strategies = "exact", inplace=False, **filtration_grid_kwargs):
+    def grid_squeeze(
+            self,
+            filtration_grid:np.ndarray|list|None=None,
+            bool coordinate_values=True,
+            force=False,
+            strategy:_available_strategies = "exact",
+            grid_strategy=None,
+            inplace=False,
+            **filtration_grid_kwargs
+        )->SimplexTreeMulti_KFi32 | SimplexTreeMulti_KFi32:
         """
         Fit the filtration of the simplextree to a grid.
 
@@ -873,26 +897,50 @@ cdef class SimplexTreeMulti_KFi32:
         """
         if not force and self.is_squeezed:
             raise Exception("SimplexTree already squeezed, use `force=True` if that's really what you want to do.") 
+
+        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)
+
         #TODO : multi-critical
         if filtration_grid is None:  
-            filtration_grid = self.get_filtration_grid(grid_strategy=grid_strategy, **filtration_grid_kwargs)
-        cdef vector[vector[double]] c_filtration_grid = filtration_grid
-        assert <int>c_filtration_grid.size() == self.get_ptr().get_number_of_parameters(), f"Grid has to be of size {self.num_parameters}, got {filtration_grid.size()}"
-        cdef intptr_t ptr = self.thisptr
+            filtration_grid = self.get_filtration_grid(grid_strategy=strategy, **filtration_grid_kwargs)
+        else:
+            filtration_grid = sanitize_grid(filtration_grid)
+            if len(filtration_grid) != self.num_parameters:
+                raise ValueError(f"Invalid grid to squeeze onto. Got {len(filtration_grid)=} != {self.num_parameters=}.")
+        api = api_from_tensor(filtration_grid[0])
+        cdef vector[vector[double]] c_filtration_grid = tuple(api.asnumpy(f).astype(np.float64) for f in filtration_grid) # may be faster with loop on views
         if coordinate_values and inplace:
-            self.filtration_grid = c_filtration_grid
+            self.filtration_grid = filtration_grid
         if inplace or not coordinate_values:
           self.get_ptr().squeeze_filtration_inplace(c_filtration_grid, coordinate_values)
         else:
           out = SimplexTreeMulti_KFi32(num_parameters=self.num_parameters)
           self.get_ptr().squeeze_filtration(out.thisptr, c_filtration_grid)
-          out.filtration_grid = c_filtration_grid
+          out.filtration_grid = filtration_grid
           return out
         return self
 
+    def unsqueeze(self, grid=None)->SimplexTreeMulti_KFf64:
+        from multipers.grids import sanitize_grid
+        grid = self.filtration_grid if grid is None else grid
+
+        cdef vector[vector[double]] cgrid = sanitize_grid(grid, numpyfy=True)
+        new_slicer = SimplexTreeMulti_KFf64()
+        new_slicer.get_ptr().unsqueeze_filtration(self.thisptr, cgrid)
+
+        return new_slicer
+
     @property
     def is_squeezed(self)->bool:
-        return self.num_vertices > 0 and len(self.filtration_grid)>0 and len(self.filtration_grid[0]) > 0
+        return self.num_vertices > 0 and self.filtration_grid is not None and len(self.filtration_grid)>0 and len(self.filtration_grid[0]) > 0
 
     @property
     def dtype(self)->type:
@@ -1185,8 +1233,8 @@ cdef class SimplexTreeMulti_Fi32:
     """
     cdef public intptr_t thisptr
 
-    cdef public vector[vector[double]] filtration_grid
-    cdef public bool _is_function_simplextree 
+    cdef public object filtration_grid
+    cdef public bool _is_function_simplextree  # TODO : deprecate
     # Get the pointer casted as it should be
     cdef Simplex_tree_multi_interface[Fi32, int32_t]* get_ptr(self) noexcept nogil:
         return <Simplex_tree_multi_interface[Fi32, int32_t]*>(self.thisptr)
@@ -1257,7 +1305,7 @@ cdef class SimplexTreeMulti_Fi32:
             self.thisptr = <intptr_t>(new Simplex_tree_multi_interface[Fi32, int32_t]())
         self.set_num_parameter(num_parameters)
         self._is_function_simplextree = False
-        self.filtration_grid=[[]*num_parameters]
+        self.filtration_grid=[]
 
     def __dealloc__(self):
         cdef Simplex_tree_multi_interface[Fi32,int32_t]* ptr = self.get_ptr()
@@ -2202,11 +2250,26 @@ cdef class SimplexTreeMulti_Fi32:
             out = self.get_ptr().get_filtration_values(degrees)
         filtrations_values =  [np.asarray(filtration) for filtration in out]
         # Removes infs
-        if inf_to_nan:
+        if inf_to_nan and np.dtype(filtrations_values[0].dtype).kind == 'f':
             for i,f in enumerate(filtrations_values):
                 filtrations_values[i][f == np.inf] = np.nan
                 filtrations_values[i][f == - np.inf] = np.nan
         return filtrations_values
+    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_st = self.grid_squeeze(cleaned_coordinates)
+
+        self.thisptr, new_st.thisptr = new_st.thisptr, self.thisptr
+        self.filtration_grid = tuple(f[g] for f,g in zip(F,cleaned_coordinates))
+        return self
+
 
 
     def get_filtration_grid(self, resolution:Iterable[int]|None=None, degrees:Iterable[int]|None=None, drop_quantiles:float|tuple=0, grid_strategy:_available_strategies="exact")->Iterable[np.ndarray]:
@@ -2242,8 +2305,16 @@ cdef class SimplexTreeMulti_Fi32:
         return compute_grid(filtrations_values, resolution=resolution,strategy=grid_strategy,drop_quantiles=drop_quantiles)
 
 
-
-    def grid_squeeze(self, filtration_grid:np.ndarray|list|None=None, bool coordinate_values=True, force=False, grid_strategy:_available_strategies = "exact", inplace=False, **filtration_grid_kwargs):
+    def grid_squeeze(
+            self,
+            filtration_grid:np.ndarray|list|None=None,
+            bool coordinate_values=True,
+            force=False,
+            strategy:_available_strategies = "exact",
+            grid_strategy=None,
+            inplace=False,
+            **filtration_grid_kwargs
+        )->SimplexTreeMulti_Fi32 | SimplexTreeMulti_Fi32:
         """
         Fit the filtration of the simplextree to a grid.
 
@@ -2254,26 +2325,50 @@ cdef class SimplexTreeMulti_Fi32:
         """
         if not force and self.is_squeezed:
             raise Exception("SimplexTree already squeezed, use `force=True` if that's really what you want to do.") 
+
+        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)
+
         #TODO : multi-critical
         if filtration_grid is None:  
-            filtration_grid = self.get_filtration_grid(grid_strategy=grid_strategy, **filtration_grid_kwargs)
-        cdef vector[vector[double]] c_filtration_grid = filtration_grid
-        assert <int>c_filtration_grid.size() == self.get_ptr().get_number_of_parameters(), f"Grid has to be of size {self.num_parameters}, got {filtration_grid.size()}"
-        cdef intptr_t ptr = self.thisptr
+            filtration_grid = self.get_filtration_grid(grid_strategy=strategy, **filtration_grid_kwargs)
+        else:
+            filtration_grid = sanitize_grid(filtration_grid)
+            if len(filtration_grid) != self.num_parameters:
+                raise ValueError(f"Invalid grid to squeeze onto. Got {len(filtration_grid)=} != {self.num_parameters=}.")
+        api = api_from_tensor(filtration_grid[0])
+        cdef vector[vector[double]] c_filtration_grid = tuple(api.asnumpy(f).astype(np.float64) for f in filtration_grid) # may be faster with loop on views
         if coordinate_values and inplace:
-            self.filtration_grid = c_filtration_grid
+            self.filtration_grid = filtration_grid
         if inplace or not coordinate_values:
           self.get_ptr().squeeze_filtration_inplace(c_filtration_grid, coordinate_values)
         else:
           out = SimplexTreeMulti_Fi32(num_parameters=self.num_parameters)
           self.get_ptr().squeeze_filtration(out.thisptr, c_filtration_grid)
-          out.filtration_grid = c_filtration_grid
+          out.filtration_grid = filtration_grid
           return out
         return self
 
+    def unsqueeze(self, grid=None)->SimplexTreeMulti_Ff64:
+        from multipers.grids import sanitize_grid
+        grid = self.filtration_grid if grid is None else grid
+
+        cdef vector[vector[double]] cgrid = sanitize_grid(grid, numpyfy=True)
+        new_slicer = SimplexTreeMulti_Ff64()
+        new_slicer.get_ptr().unsqueeze_filtration(self.thisptr, cgrid)
+
+        return new_slicer
+
     @property
     def is_squeezed(self)->bool:
-        return self.num_vertices > 0 and len(self.filtration_grid)>0 and len(self.filtration_grid[0]) > 0
+        return self.num_vertices > 0 and self.filtration_grid is not None and len(self.filtration_grid)>0 and len(self.filtration_grid[0]) > 0
 
     @property
     def dtype(self)->type:
@@ -2564,8 +2659,8 @@ cdef class SimplexTreeMulti_KFi64:
     """
     cdef public intptr_t thisptr
 
-    cdef public vector[vector[double]] filtration_grid
-    cdef public bool _is_function_simplextree 
+    cdef public object filtration_grid
+    cdef public bool _is_function_simplextree  # TODO : deprecate
     # Get the pointer casted as it should be
     cdef Simplex_tree_multi_interface[KFi64, int64_t]* get_ptr(self) noexcept nogil:
         return <Simplex_tree_multi_interface[KFi64, int64_t]*>(self.thisptr)
@@ -2636,7 +2731,7 @@ cdef class SimplexTreeMulti_KFi64:
             self.thisptr = <intptr_t>(new Simplex_tree_multi_interface[KFi64, int64_t]())
         self.set_num_parameter(num_parameters)
         self._is_function_simplextree = False
-        self.filtration_grid=[[]*num_parameters]
+        self.filtration_grid=[]
 
     def __dealloc__(self):
         cdef Simplex_tree_multi_interface[KFi64,int64_t]* ptr = self.get_ptr()
@@ -3304,11 +3399,26 @@ cdef class SimplexTreeMulti_KFi64:
             out = self.get_ptr().get_filtration_values(degrees)
         filtrations_values =  [np.asarray(filtration) for filtration in out]
         # Removes infs
-        if inf_to_nan:
+        if inf_to_nan and np.dtype(filtrations_values[0].dtype).kind == 'f':
             for i,f in enumerate(filtrations_values):
                 filtrations_values[i][f == np.inf] = np.nan
                 filtrations_values[i][f == - np.inf] = np.nan
         return filtrations_values
+    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_st = self.grid_squeeze(cleaned_coordinates)
+
+        self.thisptr, new_st.thisptr = new_st.thisptr, self.thisptr
+        self.filtration_grid = tuple(f[g] for f,g in zip(F,cleaned_coordinates))
+        return self
+
 
 
     def get_filtration_grid(self, resolution:Iterable[int]|None=None, degrees:Iterable[int]|None=None, drop_quantiles:float|tuple=0, grid_strategy:_available_strategies="exact")->Iterable[np.ndarray]:
@@ -3344,8 +3454,16 @@ cdef class SimplexTreeMulti_KFi64:
         return compute_grid(filtrations_values, resolution=resolution,strategy=grid_strategy,drop_quantiles=drop_quantiles)
 
 
-
-    def grid_squeeze(self, filtration_grid:np.ndarray|list|None=None, bool coordinate_values=True, force=False, grid_strategy:_available_strategies = "exact", inplace=False, **filtration_grid_kwargs):
+    def grid_squeeze(
+            self,
+            filtration_grid:np.ndarray|list|None=None,
+            bool coordinate_values=True,
+            force=False,
+            strategy:_available_strategies = "exact",
+            grid_strategy=None,
+            inplace=False,
+            **filtration_grid_kwargs
+        )->SimplexTreeMulti_KFi32 | SimplexTreeMulti_KFi64:
         """
         Fit the filtration of the simplextree to a grid.
 
@@ -3356,26 +3474,50 @@ cdef class SimplexTreeMulti_KFi64:
         """
         if not force and self.is_squeezed:
             raise Exception("SimplexTree already squeezed, use `force=True` if that's really what you want to do.") 
+
+        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)
+
         #TODO : multi-critical
         if filtration_grid is None:  
-            filtration_grid = self.get_filtration_grid(grid_strategy=grid_strategy, **filtration_grid_kwargs)
-        cdef vector[vector[double]] c_filtration_grid = filtration_grid
-        assert <int>c_filtration_grid.size() == self.get_ptr().get_number_of_parameters(), f"Grid has to be of size {self.num_parameters}, got {filtration_grid.size()}"
-        cdef intptr_t ptr = self.thisptr
+            filtration_grid = self.get_filtration_grid(grid_strategy=strategy, **filtration_grid_kwargs)
+        else:
+            filtration_grid = sanitize_grid(filtration_grid)
+            if len(filtration_grid) != self.num_parameters:
+                raise ValueError(f"Invalid grid to squeeze onto. Got {len(filtration_grid)=} != {self.num_parameters=}.")
+        api = api_from_tensor(filtration_grid[0])
+        cdef vector[vector[double]] c_filtration_grid = tuple(api.asnumpy(f).astype(np.float64) for f in filtration_grid) # may be faster with loop on views
         if coordinate_values and inplace:
-            self.filtration_grid = c_filtration_grid
+            self.filtration_grid = filtration_grid
         if inplace or not coordinate_values:
           self.get_ptr().squeeze_filtration_inplace(c_filtration_grid, coordinate_values)
         else:
           out = SimplexTreeMulti_KFi32(num_parameters=self.num_parameters)
           self.get_ptr().squeeze_filtration(out.thisptr, c_filtration_grid)
-          out.filtration_grid = c_filtration_grid
+          out.filtration_grid = filtration_grid
           return out
         return self
 
+    def unsqueeze(self, grid=None)->SimplexTreeMulti_KFf64:
+        from multipers.grids import sanitize_grid
+        grid = self.filtration_grid if grid is None else grid
+
+        cdef vector[vector[double]] cgrid = sanitize_grid(grid, numpyfy=True)
+        new_slicer = SimplexTreeMulti_KFf64()
+        new_slicer.get_ptr().unsqueeze_filtration(self.thisptr, cgrid)
+
+        return new_slicer
+
     @property
     def is_squeezed(self)->bool:
-        return self.num_vertices > 0 and len(self.filtration_grid)>0 and len(self.filtration_grid[0]) > 0
+        return self.num_vertices > 0 and self.filtration_grid is not None and len(self.filtration_grid)>0 and len(self.filtration_grid[0]) > 0
 
     @property
     def dtype(self)->type:
@@ -3668,8 +3810,8 @@ cdef class SimplexTreeMulti_Fi64:
     """
     cdef public intptr_t thisptr
 
-    cdef public vector[vector[double]] filtration_grid
-    cdef public bool _is_function_simplextree 
+    cdef public object filtration_grid
+    cdef public bool _is_function_simplextree  # TODO : deprecate
     # Get the pointer casted as it should be
     cdef Simplex_tree_multi_interface[Fi64, int64_t]* get_ptr(self) noexcept nogil:
         return <Simplex_tree_multi_interface[Fi64, int64_t]*>(self.thisptr)
@@ -3740,7 +3882,7 @@ cdef class SimplexTreeMulti_Fi64:
             self.thisptr = <intptr_t>(new Simplex_tree_multi_interface[Fi64, int64_t]())
         self.set_num_parameter(num_parameters)
         self._is_function_simplextree = False
-        self.filtration_grid=[[]*num_parameters]
+        self.filtration_grid=[]
 
     def __dealloc__(self):
         cdef Simplex_tree_multi_interface[Fi64,int64_t]* ptr = self.get_ptr()
@@ -4685,11 +4827,26 @@ cdef class SimplexTreeMulti_Fi64:
             out = self.get_ptr().get_filtration_values(degrees)
         filtrations_values =  [np.asarray(filtration) for filtration in out]
         # Removes infs
-        if inf_to_nan:
+        if inf_to_nan and np.dtype(filtrations_values[0].dtype).kind == 'f':
             for i,f in enumerate(filtrations_values):
                 filtrations_values[i][f == np.inf] = np.nan
                 filtrations_values[i][f == - np.inf] = np.nan
         return filtrations_values
+    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_st = self.grid_squeeze(cleaned_coordinates)
+
+        self.thisptr, new_st.thisptr = new_st.thisptr, self.thisptr
+        self.filtration_grid = tuple(f[g] for f,g in zip(F,cleaned_coordinates))
+        return self
+
 
 
     def get_filtration_grid(self, resolution:Iterable[int]|None=None, degrees:Iterable[int]|None=None, drop_quantiles:float|tuple=0, grid_strategy:_available_strategies="exact")->Iterable[np.ndarray]:
@@ -4725,8 +4882,16 @@ cdef class SimplexTreeMulti_Fi64:
         return compute_grid(filtrations_values, resolution=resolution,strategy=grid_strategy,drop_quantiles=drop_quantiles)
 
 
-
-    def grid_squeeze(self, filtration_grid:np.ndarray|list|None=None, bool coordinate_values=True, force=False, grid_strategy:_available_strategies = "exact", inplace=False, **filtration_grid_kwargs):
+    def grid_squeeze(
+            self,
+            filtration_grid:np.ndarray|list|None=None,
+            bool coordinate_values=True,
+            force=False,
+            strategy:_available_strategies = "exact",
+            grid_strategy=None,
+            inplace=False,
+            **filtration_grid_kwargs
+        )->SimplexTreeMulti_Fi32 | SimplexTreeMulti_Fi64:
         """
         Fit the filtration of the simplextree to a grid.
 
@@ -4737,26 +4902,50 @@ cdef class SimplexTreeMulti_Fi64:
         """
         if not force and self.is_squeezed:
             raise Exception("SimplexTree already squeezed, use `force=True` if that's really what you want to do.") 
+
+        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)
+
         #TODO : multi-critical
         if filtration_grid is None:  
-            filtration_grid = self.get_filtration_grid(grid_strategy=grid_strategy, **filtration_grid_kwargs)
-        cdef vector[vector[double]] c_filtration_grid = filtration_grid
-        assert <int>c_filtration_grid.size() == self.get_ptr().get_number_of_parameters(), f"Grid has to be of size {self.num_parameters}, got {filtration_grid.size()}"
-        cdef intptr_t ptr = self.thisptr
+            filtration_grid = self.get_filtration_grid(grid_strategy=strategy, **filtration_grid_kwargs)
+        else:
+            filtration_grid = sanitize_grid(filtration_grid)
+            if len(filtration_grid) != self.num_parameters:
+                raise ValueError(f"Invalid grid to squeeze onto. Got {len(filtration_grid)=} != {self.num_parameters=}.")
+        api = api_from_tensor(filtration_grid[0])
+        cdef vector[vector[double]] c_filtration_grid = tuple(api.asnumpy(f).astype(np.float64) for f in filtration_grid) # may be faster with loop on views
         if coordinate_values and inplace:
-            self.filtration_grid = c_filtration_grid
+            self.filtration_grid = filtration_grid
         if inplace or not coordinate_values:
           self.get_ptr().squeeze_filtration_inplace(c_filtration_grid, coordinate_values)
         else:
           out = SimplexTreeMulti_Fi32(num_parameters=self.num_parameters)
           self.get_ptr().squeeze_filtration(out.thisptr, c_filtration_grid)
-          out.filtration_grid = c_filtration_grid
+          out.filtration_grid = filtration_grid
           return out
         return self
 
+    def unsqueeze(self, grid=None)->SimplexTreeMulti_Ff64:
+        from multipers.grids import sanitize_grid
+        grid = self.filtration_grid if grid is None else grid
+
+        cdef vector[vector[double]] cgrid = sanitize_grid(grid, numpyfy=True)
+        new_slicer = SimplexTreeMulti_Ff64()
+        new_slicer.get_ptr().unsqueeze_filtration(self.thisptr, cgrid)
+
+        return new_slicer
+
     @property
     def is_squeezed(self)->bool:
-        return self.num_vertices > 0 and len(self.filtration_grid)>0 and len(self.filtration_grid[0]) > 0
+        return self.num_vertices > 0 and self.filtration_grid is not None and len(self.filtration_grid)>0 and len(self.filtration_grid[0]) > 0
 
     @property
     def dtype(self)->type:
@@ -5047,8 +5236,8 @@ cdef class SimplexTreeMulti_KFf32:
     """
     cdef public intptr_t thisptr
 
-    cdef public vector[vector[double]] filtration_grid
-    cdef public bool _is_function_simplextree 
+    cdef public object filtration_grid
+    cdef public bool _is_function_simplextree  # TODO : deprecate
     # Get the pointer casted as it should be
     cdef Simplex_tree_multi_interface[KFf32, float]* get_ptr(self) noexcept nogil:
         return <Simplex_tree_multi_interface[KFf32, float]*>(self.thisptr)
@@ -5119,7 +5308,7 @@ cdef class SimplexTreeMulti_KFf32:
             self.thisptr = <intptr_t>(new Simplex_tree_multi_interface[KFf32, float]())
         self.set_num_parameter(num_parameters)
         self._is_function_simplextree = False
-        self.filtration_grid=[[]*num_parameters]
+        self.filtration_grid=[]
 
     def __dealloc__(self):
         cdef Simplex_tree_multi_interface[KFf32,float]* ptr = self.get_ptr()
@@ -5787,11 +5976,26 @@ cdef class SimplexTreeMulti_KFf32:
             out = self.get_ptr().get_filtration_values(degrees)
         filtrations_values =  [np.asarray(filtration) for filtration in out]
         # Removes infs
-        if inf_to_nan:
+        if inf_to_nan and np.dtype(filtrations_values[0].dtype).kind == 'f':
             for i,f in enumerate(filtrations_values):
                 filtrations_values[i][f == np.inf] = np.nan
                 filtrations_values[i][f == - np.inf] = np.nan
         return filtrations_values
+    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_st = self.grid_squeeze(cleaned_coordinates)
+
+        self.thisptr, new_st.thisptr = new_st.thisptr, self.thisptr
+        self.filtration_grid = tuple(f[g] for f,g in zip(F,cleaned_coordinates))
+        return self
+
 
 
     def get_filtration_grid(self, resolution:Iterable[int]|None=None, degrees:Iterable[int]|None=None, drop_quantiles:float|tuple=0, grid_strategy:_available_strategies="exact")->Iterable[np.ndarray]:
@@ -5827,8 +6031,16 @@ cdef class SimplexTreeMulti_KFf32:
         return compute_grid(filtrations_values, resolution=resolution,strategy=grid_strategy,drop_quantiles=drop_quantiles)
 
 
-
-    def grid_squeeze(self, filtration_grid:np.ndarray|list|None=None, bool coordinate_values=True, force=False, grid_strategy:_available_strategies = "exact", inplace=False, **filtration_grid_kwargs):
+    def grid_squeeze(
+            self,
+            filtration_grid:np.ndarray|list|None=None,
+            bool coordinate_values=True,
+            force=False,
+            strategy:_available_strategies = "exact",
+            grid_strategy=None,
+            inplace=False,
+            **filtration_grid_kwargs
+        )->SimplexTreeMulti_KFi32 | SimplexTreeMulti_KFf32:
         """
         Fit the filtration of the simplextree to a grid.
 
@@ -5839,26 +6051,50 @@ cdef class SimplexTreeMulti_KFf32:
         """
         if not force and self.is_squeezed:
             raise Exception("SimplexTree already squeezed, use `force=True` if that's really what you want to do.") 
+
+        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)
+
         #TODO : multi-critical
         if filtration_grid is None:  
-            filtration_grid = self.get_filtration_grid(grid_strategy=grid_strategy, **filtration_grid_kwargs)
-        cdef vector[vector[double]] c_filtration_grid = filtration_grid
-        assert <int>c_filtration_grid.size() == self.get_ptr().get_number_of_parameters(), f"Grid has to be of size {self.num_parameters}, got {filtration_grid.size()}"
-        cdef intptr_t ptr = self.thisptr
+            filtration_grid = self.get_filtration_grid(grid_strategy=strategy, **filtration_grid_kwargs)
+        else:
+            filtration_grid = sanitize_grid(filtration_grid)
+            if len(filtration_grid) != self.num_parameters:
+                raise ValueError(f"Invalid grid to squeeze onto. Got {len(filtration_grid)=} != {self.num_parameters=}.")
+        api = api_from_tensor(filtration_grid[0])
+        cdef vector[vector[double]] c_filtration_grid = tuple(api.asnumpy(f).astype(np.float64) for f in filtration_grid) # may be faster with loop on views
         if coordinate_values and inplace:
-            self.filtration_grid = c_filtration_grid
+            self.filtration_grid = filtration_grid
         if inplace or not coordinate_values:
           self.get_ptr().squeeze_filtration_inplace(c_filtration_grid, coordinate_values)
         else:
           out = SimplexTreeMulti_KFi32(num_parameters=self.num_parameters)
           self.get_ptr().squeeze_filtration(out.thisptr, c_filtration_grid)
-          out.filtration_grid = c_filtration_grid
+          out.filtration_grid = filtration_grid
           return out
         return self
 
+    def unsqueeze(self, grid=None)->SimplexTreeMulti_KFf64:
+        from multipers.grids import sanitize_grid
+        grid = self.filtration_grid if grid is None else grid
+
+        cdef vector[vector[double]] cgrid = sanitize_grid(grid, numpyfy=True)
+        new_slicer = SimplexTreeMulti_KFf64()
+        new_slicer.get_ptr().unsqueeze_filtration(self.thisptr, cgrid)
+
+        return new_slicer
+
     @property
     def is_squeezed(self)->bool:
-        return self.num_vertices > 0 and len(self.filtration_grid)>0 and len(self.filtration_grid[0]) > 0
+        return self.num_vertices > 0 and self.filtration_grid is not None and len(self.filtration_grid)>0 and len(self.filtration_grid[0]) > 0
 
     @property
     def dtype(self)->type:
@@ -6151,8 +6387,8 @@ cdef class SimplexTreeMulti_Ff32:
     """
     cdef public intptr_t thisptr
 
-    cdef public vector[vector[double]] filtration_grid
-    cdef public bool _is_function_simplextree 
+    cdef public object filtration_grid
+    cdef public bool _is_function_simplextree  # TODO : deprecate
     # Get the pointer casted as it should be
     cdef Simplex_tree_multi_interface[Ff32, float]* get_ptr(self) noexcept nogil:
         return <Simplex_tree_multi_interface[Ff32, float]*>(self.thisptr)
@@ -6223,7 +6459,7 @@ cdef class SimplexTreeMulti_Ff32:
             self.thisptr = <intptr_t>(new Simplex_tree_multi_interface[Ff32, float]())
         self.set_num_parameter(num_parameters)
         self._is_function_simplextree = False
-        self.filtration_grid=[[]*num_parameters]
+        self.filtration_grid=[]
 
     def __dealloc__(self):
         cdef Simplex_tree_multi_interface[Ff32,float]* ptr = self.get_ptr()
@@ -7168,11 +7404,26 @@ cdef class SimplexTreeMulti_Ff32:
             out = self.get_ptr().get_filtration_values(degrees)
         filtrations_values =  [np.asarray(filtration) for filtration in out]
         # Removes infs
-        if inf_to_nan:
+        if inf_to_nan and np.dtype(filtrations_values[0].dtype).kind == 'f':
             for i,f in enumerate(filtrations_values):
                 filtrations_values[i][f == np.inf] = np.nan
                 filtrations_values[i][f == - np.inf] = np.nan
         return filtrations_values
+    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_st = self.grid_squeeze(cleaned_coordinates)
+
+        self.thisptr, new_st.thisptr = new_st.thisptr, self.thisptr
+        self.filtration_grid = tuple(f[g] for f,g in zip(F,cleaned_coordinates))
+        return self
+
 
 
     def get_filtration_grid(self, resolution:Iterable[int]|None=None, degrees:Iterable[int]|None=None, drop_quantiles:float|tuple=0, grid_strategy:_available_strategies="exact")->Iterable[np.ndarray]:
@@ -7208,8 +7459,16 @@ cdef class SimplexTreeMulti_Ff32:
         return compute_grid(filtrations_values, resolution=resolution,strategy=grid_strategy,drop_quantiles=drop_quantiles)
 
 
-
-    def grid_squeeze(self, filtration_grid:np.ndarray|list|None=None, bool coordinate_values=True, force=False, grid_strategy:_available_strategies = "exact", inplace=False, **filtration_grid_kwargs):
+    def grid_squeeze(
+            self,
+            filtration_grid:np.ndarray|list|None=None,
+            bool coordinate_values=True,
+            force=False,
+            strategy:_available_strategies = "exact",
+            grid_strategy=None,
+            inplace=False,
+            **filtration_grid_kwargs
+        )->SimplexTreeMulti_Fi32 | SimplexTreeMulti_Ff32:
         """
         Fit the filtration of the simplextree to a grid.
 
@@ -7220,26 +7479,50 @@ cdef class SimplexTreeMulti_Ff32:
         """
         if not force and self.is_squeezed:
             raise Exception("SimplexTree already squeezed, use `force=True` if that's really what you want to do.") 
+
+        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)
+
         #TODO : multi-critical
         if filtration_grid is None:  
-            filtration_grid = self.get_filtration_grid(grid_strategy=grid_strategy, **filtration_grid_kwargs)
-        cdef vector[vector[double]] c_filtration_grid = filtration_grid
-        assert <int>c_filtration_grid.size() == self.get_ptr().get_number_of_parameters(), f"Grid has to be of size {self.num_parameters}, got {filtration_grid.size()}"
-        cdef intptr_t ptr = self.thisptr
+            filtration_grid = self.get_filtration_grid(grid_strategy=strategy, **filtration_grid_kwargs)
+        else:
+            filtration_grid = sanitize_grid(filtration_grid)
+            if len(filtration_grid) != self.num_parameters:
+                raise ValueError(f"Invalid grid to squeeze onto. Got {len(filtration_grid)=} != {self.num_parameters=}.")
+        api = api_from_tensor(filtration_grid[0])
+        cdef vector[vector[double]] c_filtration_grid = tuple(api.asnumpy(f).astype(np.float64) for f in filtration_grid) # may be faster with loop on views
         if coordinate_values and inplace:
-            self.filtration_grid = c_filtration_grid
+            self.filtration_grid = filtration_grid
         if inplace or not coordinate_values:
           self.get_ptr().squeeze_filtration_inplace(c_filtration_grid, coordinate_values)
         else:
           out = SimplexTreeMulti_Fi32(num_parameters=self.num_parameters)
           self.get_ptr().squeeze_filtration(out.thisptr, c_filtration_grid)
-          out.filtration_grid = c_filtration_grid
+          out.filtration_grid = filtration_grid
           return out
         return self
 
+    def unsqueeze(self, grid=None)->SimplexTreeMulti_Ff64:
+        from multipers.grids import sanitize_grid
+        grid = self.filtration_grid if grid is None else grid
+
+        cdef vector[vector[double]] cgrid = sanitize_grid(grid, numpyfy=True)
+        new_slicer = SimplexTreeMulti_Ff64()
+        new_slicer.get_ptr().unsqueeze_filtration(self.thisptr, cgrid)
+
+        return new_slicer
+
     @property
     def is_squeezed(self)->bool:
-        return self.num_vertices > 0 and len(self.filtration_grid)>0 and len(self.filtration_grid[0]) > 0
+        return self.num_vertices > 0 and self.filtration_grid is not None and len(self.filtration_grid)>0 and len(self.filtration_grid[0]) > 0
 
     @property
     def dtype(self)->type:
@@ -7530,8 +7813,8 @@ cdef class SimplexTreeMulti_KFf64:
     """
     cdef public intptr_t thisptr
 
-    cdef public vector[vector[double]] filtration_grid
-    cdef public bool _is_function_simplextree 
+    cdef public object filtration_grid
+    cdef public bool _is_function_simplextree  # TODO : deprecate
     # Get the pointer casted as it should be
     cdef Simplex_tree_multi_interface[KFf64, double]* get_ptr(self) noexcept nogil:
         return <Simplex_tree_multi_interface[KFf64, double]*>(self.thisptr)
@@ -7602,7 +7885,7 @@ cdef class SimplexTreeMulti_KFf64:
             self.thisptr = <intptr_t>(new Simplex_tree_multi_interface[KFf64, double]())
         self.set_num_parameter(num_parameters)
         self._is_function_simplextree = False
-        self.filtration_grid=[[]*num_parameters]
+        self.filtration_grid=[]
 
     def __dealloc__(self):
         cdef Simplex_tree_multi_interface[KFf64,double]* ptr = self.get_ptr()
@@ -8270,11 +8553,26 @@ cdef class SimplexTreeMulti_KFf64:
             out = self.get_ptr().get_filtration_values(degrees)
         filtrations_values =  [np.asarray(filtration) for filtration in out]
         # Removes infs
-        if inf_to_nan:
+        if inf_to_nan and np.dtype(filtrations_values[0].dtype).kind == 'f':
             for i,f in enumerate(filtrations_values):
                 filtrations_values[i][f == np.inf] = np.nan
                 filtrations_values[i][f == - np.inf] = np.nan
         return filtrations_values
+    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_st = self.grid_squeeze(cleaned_coordinates)
+
+        self.thisptr, new_st.thisptr = new_st.thisptr, self.thisptr
+        self.filtration_grid = tuple(f[g] for f,g in zip(F,cleaned_coordinates))
+        return self
+
 
 
     def get_filtration_grid(self, resolution:Iterable[int]|None=None, degrees:Iterable[int]|None=None, drop_quantiles:float|tuple=0, grid_strategy:_available_strategies="exact")->Iterable[np.ndarray]:
@@ -8310,8 +8608,16 @@ cdef class SimplexTreeMulti_KFf64:
         return compute_grid(filtrations_values, resolution=resolution,strategy=grid_strategy,drop_quantiles=drop_quantiles)
 
 
-
-    def grid_squeeze(self, filtration_grid:np.ndarray|list|None=None, bool coordinate_values=True, force=False, grid_strategy:_available_strategies = "exact", inplace=False, **filtration_grid_kwargs):
+    def grid_squeeze(
+            self,
+            filtration_grid:np.ndarray|list|None=None,
+            bool coordinate_values=True,
+            force=False,
+            strategy:_available_strategies = "exact",
+            grid_strategy=None,
+            inplace=False,
+            **filtration_grid_kwargs
+        )->SimplexTreeMulti_KFi32 | SimplexTreeMulti_KFf64:
         """
         Fit the filtration of the simplextree to a grid.
 
@@ -8322,26 +8628,50 @@ cdef class SimplexTreeMulti_KFf64:
         """
         if not force and self.is_squeezed:
             raise Exception("SimplexTree already squeezed, use `force=True` if that's really what you want to do.") 
+
+        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)
+
         #TODO : multi-critical
         if filtration_grid is None:  
-            filtration_grid = self.get_filtration_grid(grid_strategy=grid_strategy, **filtration_grid_kwargs)
-        cdef vector[vector[double]] c_filtration_grid = filtration_grid
-        assert <int>c_filtration_grid.size() == self.get_ptr().get_number_of_parameters(), f"Grid has to be of size {self.num_parameters}, got {filtration_grid.size()}"
-        cdef intptr_t ptr = self.thisptr
+            filtration_grid = self.get_filtration_grid(grid_strategy=strategy, **filtration_grid_kwargs)
+        else:
+            filtration_grid = sanitize_grid(filtration_grid)
+            if len(filtration_grid) != self.num_parameters:
+                raise ValueError(f"Invalid grid to squeeze onto. Got {len(filtration_grid)=} != {self.num_parameters=}.")
+        api = api_from_tensor(filtration_grid[0])
+        cdef vector[vector[double]] c_filtration_grid = tuple(api.asnumpy(f).astype(np.float64) for f in filtration_grid) # may be faster with loop on views
         if coordinate_values and inplace:
-            self.filtration_grid = c_filtration_grid
+            self.filtration_grid = filtration_grid
         if inplace or not coordinate_values:
           self.get_ptr().squeeze_filtration_inplace(c_filtration_grid, coordinate_values)
         else:
           out = SimplexTreeMulti_KFi32(num_parameters=self.num_parameters)
           self.get_ptr().squeeze_filtration(out.thisptr, c_filtration_grid)
-          out.filtration_grid = c_filtration_grid
+          out.filtration_grid = filtration_grid
           return out
         return self
 
+    def unsqueeze(self, grid=None)->SimplexTreeMulti_KFf64:
+        from multipers.grids import sanitize_grid
+        grid = self.filtration_grid if grid is None else grid
+
+        cdef vector[vector[double]] cgrid = sanitize_grid(grid, numpyfy=True)
+        new_slicer = SimplexTreeMulti_KFf64()
+        new_slicer.get_ptr().unsqueeze_filtration(self.thisptr, cgrid)
+
+        return new_slicer
+
     @property
     def is_squeezed(self)->bool:
-        return self.num_vertices > 0 and len(self.filtration_grid)>0 and len(self.filtration_grid[0]) > 0
+        return self.num_vertices > 0 and self.filtration_grid is not None and len(self.filtration_grid)>0 and len(self.filtration_grid[0]) > 0
 
     @property
     def dtype(self)->type:
@@ -8634,8 +8964,8 @@ cdef class SimplexTreeMulti_Ff64:
     """
     cdef public intptr_t thisptr
 
-    cdef public vector[vector[double]] filtration_grid
-    cdef public bool _is_function_simplextree 
+    cdef public object filtration_grid
+    cdef public bool _is_function_simplextree  # TODO : deprecate
     # Get the pointer casted as it should be
     cdef Simplex_tree_multi_interface[Ff64, double]* get_ptr(self) noexcept nogil:
         return <Simplex_tree_multi_interface[Ff64, double]*>(self.thisptr)
@@ -8706,7 +9036,7 @@ cdef class SimplexTreeMulti_Ff64:
             self.thisptr = <intptr_t>(new Simplex_tree_multi_interface[Ff64, double]())
         self.set_num_parameter(num_parameters)
         self._is_function_simplextree = False
-        self.filtration_grid=[[]*num_parameters]
+        self.filtration_grid=[]
 
     def __dealloc__(self):
         cdef Simplex_tree_multi_interface[Ff64,double]* ptr = self.get_ptr()
@@ -9651,11 +9981,26 @@ cdef class SimplexTreeMulti_Ff64:
             out = self.get_ptr().get_filtration_values(degrees)
         filtrations_values =  [np.asarray(filtration) for filtration in out]
         # Removes infs
-        if inf_to_nan:
+        if inf_to_nan and np.dtype(filtrations_values[0].dtype).kind == 'f':
             for i,f in enumerate(filtrations_values):
                 filtrations_values[i][f == np.inf] = np.nan
                 filtrations_values[i][f == - np.inf] = np.nan
         return filtrations_values
+    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_st = self.grid_squeeze(cleaned_coordinates)
+
+        self.thisptr, new_st.thisptr = new_st.thisptr, self.thisptr
+        self.filtration_grid = tuple(f[g] for f,g in zip(F,cleaned_coordinates))
+        return self
+
 
 
     def get_filtration_grid(self, resolution:Iterable[int]|None=None, degrees:Iterable[int]|None=None, drop_quantiles:float|tuple=0, grid_strategy:_available_strategies="exact")->Iterable[np.ndarray]:
@@ -9691,8 +10036,16 @@ cdef class SimplexTreeMulti_Ff64:
         return compute_grid(filtrations_values, resolution=resolution,strategy=grid_strategy,drop_quantiles=drop_quantiles)
 
 
-
-    def grid_squeeze(self, filtration_grid:np.ndarray|list|None=None, bool coordinate_values=True, force=False, grid_strategy:_available_strategies = "exact", inplace=False, **filtration_grid_kwargs):
+    def grid_squeeze(
+            self,
+            filtration_grid:np.ndarray|list|None=None,
+            bool coordinate_values=True,
+            force=False,
+            strategy:_available_strategies = "exact",
+            grid_strategy=None,
+            inplace=False,
+            **filtration_grid_kwargs
+        )->SimplexTreeMulti_Fi32 | SimplexTreeMulti_Ff64:
         """
         Fit the filtration of the simplextree to a grid.
 
@@ -9703,26 +10056,50 @@ cdef class SimplexTreeMulti_Ff64:
         """
         if not force and self.is_squeezed:
             raise Exception("SimplexTree already squeezed, use `force=True` if that's really what you want to do.") 
+
+        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)
+
         #TODO : multi-critical
         if filtration_grid is None:  
-            filtration_grid = self.get_filtration_grid(grid_strategy=grid_strategy, **filtration_grid_kwargs)
-        cdef vector[vector[double]] c_filtration_grid = filtration_grid
-        assert <int>c_filtration_grid.size() == self.get_ptr().get_number_of_parameters(), f"Grid has to be of size {self.num_parameters}, got {filtration_grid.size()}"
-        cdef intptr_t ptr = self.thisptr
+            filtration_grid = self.get_filtration_grid(grid_strategy=strategy, **filtration_grid_kwargs)
+        else:
+            filtration_grid = sanitize_grid(filtration_grid)
+            if len(filtration_grid) != self.num_parameters:
+                raise ValueError(f"Invalid grid to squeeze onto. Got {len(filtration_grid)=} != {self.num_parameters=}.")
+        api = api_from_tensor(filtration_grid[0])
+        cdef vector[vector[double]] c_filtration_grid = tuple(api.asnumpy(f).astype(np.float64) for f in filtration_grid) # may be faster with loop on views
         if coordinate_values and inplace:
-            self.filtration_grid = c_filtration_grid
+            self.filtration_grid = filtration_grid
         if inplace or not coordinate_values:
           self.get_ptr().squeeze_filtration_inplace(c_filtration_grid, coordinate_values)
         else:
           out = SimplexTreeMulti_Fi32(num_parameters=self.num_parameters)
           self.get_ptr().squeeze_filtration(out.thisptr, c_filtration_grid)
-          out.filtration_grid = c_filtration_grid
+          out.filtration_grid = filtration_grid
           return out
         return self
 
+    def unsqueeze(self, grid=None)->SimplexTreeMulti_Ff64:
+        from multipers.grids import sanitize_grid
+        grid = self.filtration_grid if grid is None else grid
+
+        cdef vector[vector[double]] cgrid = sanitize_grid(grid, numpyfy=True)
+        new_slicer = SimplexTreeMulti_Ff64()
+        new_slicer.get_ptr().unsqueeze_filtration(self.thisptr, cgrid)
+
+        return new_slicer
+
     @property
     def is_squeezed(self)->bool:
-        return self.num_vertices > 0 and len(self.filtration_grid)>0 and len(self.filtration_grid[0]) > 0
+        return self.num_vertices > 0 and self.filtration_grid is not None and len(self.filtration_grid)>0 and len(self.filtration_grid[0]) > 0
 
     @property
     def dtype(self)->type:
@@ -10243,7 +10620,8 @@ def _euler_signed_measure(simplextree, mass_default=None, bool verbose=False):
   `[signed_measure_of_degree for degree in degrees]`
   with `signed_measure_of_degree` of the form `(dirac location, dirac weights)`.
   """
-  assert len(simplextree.filtration_grid[0]) > 0, "Squeeze grid first."
+  if not simplextree.is_squeezed:
+      raise ValueError("Squeeze grid first.")
   cdef bool zero_pad = mass_default is not None
   # assert simplextree.num_parameters == 2
   grid_shape = np.array([len(f) for f in simplextree.filtration_grid])
@@ -10361,9 +10739,9 @@ def _rank_signed_measure(simplextree, vector[indices_type] degrees, mass_default
     else:
         mass_default = np.asarray(mass_default)
         assert mass_default.ndim == 1 and mass_default.shape[0] == simplextree.num_parameters, "Mass default has to be an array like of shape (num_parameters,)"
-    if zero_pad:
-        for i, _ in enumerate(grid_shape):
-            grid_shape[i] += 1 # adds a 0
+    # if zero_pad:
+    #     for i, _ in enumerate(grid_shape):
+    #         grid_shape[i] += 1 # adds a 0
         # grid_conversion = tuple(np.concatenate([f, [mass_default[i]]]) for i,f in enumerate(grid_conversion))
 
     assert len(grid_shape) == simplextree.num_parameters, "Grid shape size has to be the number of parameters."