multipers 2.3.0__cp310-cp310-win_amd64.whl → 2.3.2b1__cp310-cp310-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,15 +82,15 @@ 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)
 
     # cdef Simplex_tree_persistence_interface * pcohptr
     # Fake constructor that does nothing but documenting the constructor
-    def __init__(self, other = None, num_parameters:int=2,default_values=[], safe_conversion=False):
+    def __init__(self, other = None, num_parameters:int=-1,default_values=[], safe_conversion=False):
         """SimplexTreeMulti constructor.
 
         :param other: If `other` is `None` (default value), an empty `SimplexTreeMulti` is created.
@@ -114,7 +115,7 @@ cdef class SimplexTreeMulti_KFi32:
     def is_kcritical(self)->bool:
       return True
     # The real cython constructor
-    def __cinit__(self, other = None, int num_parameters=2, 
+    def __cinit__(self, other = None, int num_parameters=-1, 
                   default_values=np.asarray([SimplexTreeMulti_KFi32.T_minus_inf()]), # I'm not sure why `[]` does not work. Cython bug ? 
                   bool safe_conversion=False,
                   ): #TODO doc
@@ -127,10 +128,13 @@ cdef class SimplexTreeMulti_KFi32:
             if isinstance(other, SimplexTreeMulti_KFi32):
                 other_ptr = other.thisptr
                 self.thisptr = <intptr_t>(new Simplex_tree_multi_interface[KFi32, int32_t](dereference(<Simplex_tree_multi_interface[KFi32, int32_t]*>other_ptr))) ## prevents calling destructor of other
-                num_parameters = other.num_parameters
+                if num_parameters <=0:
+                    num_parameters = other.num_parameters
                 self.filtration_grid = other.filtration_grid
             elif isinstance(other, SimplexTree): # Constructs a SimplexTreeMulti from a SimplexTree
                 self.thisptr = <intptr_t>(new Simplex_tree_multi_interface[KFi32, int32_t]())
+                if num_parameters <= 0:
+                    num_parameters = 1
                 if safe_conversion or SAFE_CONVERSION:
                     new_st_multi  = _safe_simplextree_multify_KFi32(other, num_parameters = num_parameters, default_values=np.asarray(default_values))
                     self.thisptr, new_st_multi.thisptr = new_st_multi.thisptr, self.thisptr
@@ -145,10 +149,12 @@ cdef class SimplexTreeMulti_KFi32:
             else:
                 raise TypeError("`other` argument requires to be of type `SimplexTree`, `SimplexTreeMulti`, or `None`.")
         else:
+            if num_parameters <=0:
+                num_parameters = 2 # I don't know how dangerous this is, but this is mostly used.
             self.thisptr = <intptr_t>(new Simplex_tree_multi_interface[KFi32, int32_t]())
-        self.get_ptr().set_number_of_parameters(num_parameters)
+        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()
@@ -158,6 +164,9 @@ cdef class SimplexTreeMulti_KFi32:
 
     def __repr__(self):
         return f"SimplexTreeMulti[dtype={np.dtype(self.dtype).name},num_param={self.num_parameters},kcritical={self.is_kcritical},is_squeezed={self.is_squeezed},max_dim={self.dimension}]" 
+    def __len__(self):
+        return self.num_simplices
+
     def __getstate__(self):
         """:returns: Serialized (or flattened) SimplexTree data structure in order to pickle SimplexTree.
         :rtype: numpy.array of shape (n,)
@@ -813,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]:
@@ -853,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.
 
@@ -865,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:
@@ -1177,15 +1233,15 @@ 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)
 
     # cdef Simplex_tree_persistence_interface * pcohptr
     # Fake constructor that does nothing but documenting the constructor
-    def __init__(self, other = None, num_parameters:int=2,default_values=[], safe_conversion=False):
+    def __init__(self, other = None, num_parameters:int=-1,default_values=[], safe_conversion=False):
         """SimplexTreeMulti constructor.
 
         :param other: If `other` is `None` (default value), an empty `SimplexTreeMulti` is created.
@@ -1210,7 +1266,7 @@ cdef class SimplexTreeMulti_Fi32:
     def is_kcritical(self)->bool:
       return False
     # The real cython constructor
-    def __cinit__(self, other = None, int num_parameters=2, 
+    def __cinit__(self, other = None, int num_parameters=-1, 
                   default_values=np.asarray([SimplexTreeMulti_Fi32.T_minus_inf()]), # I'm not sure why `[]` does not work. Cython bug ? 
                   bool safe_conversion=False,
                   ): #TODO doc
@@ -1223,10 +1279,13 @@ cdef class SimplexTreeMulti_Fi32:
             if isinstance(other, SimplexTreeMulti_Fi32):
                 other_ptr = other.thisptr
                 self.thisptr = <intptr_t>(new Simplex_tree_multi_interface[Fi32, int32_t](dereference(<Simplex_tree_multi_interface[Fi32, int32_t]*>other_ptr))) ## prevents calling destructor of other
-                num_parameters = other.num_parameters
+                if num_parameters <=0:
+                    num_parameters = other.num_parameters
                 self.filtration_grid = other.filtration_grid
             elif isinstance(other, SimplexTree): # Constructs a SimplexTreeMulti from a SimplexTree
                 self.thisptr = <intptr_t>(new Simplex_tree_multi_interface[Fi32, int32_t]())
+                if num_parameters <= 0:
+                    num_parameters = 1
                 if safe_conversion or SAFE_CONVERSION:
                     new_st_multi  = _safe_simplextree_multify_Fi32(other, num_parameters = num_parameters, default_values=np.asarray(default_values))
                     self.thisptr, new_st_multi.thisptr = new_st_multi.thisptr, self.thisptr
@@ -1241,10 +1300,12 @@ cdef class SimplexTreeMulti_Fi32:
             else:
                 raise TypeError("`other` argument requires to be of type `SimplexTree`, `SimplexTreeMulti`, or `None`.")
         else:
+            if num_parameters <=0:
+                num_parameters = 2 # I don't know how dangerous this is, but this is mostly used.
             self.thisptr = <intptr_t>(new Simplex_tree_multi_interface[Fi32, int32_t]())
-        self.get_ptr().set_number_of_parameters(num_parameters)
+        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()
@@ -1254,6 +1315,9 @@ cdef class SimplexTreeMulti_Fi32:
 
     def __repr__(self):
         return f"SimplexTreeMulti[dtype={np.dtype(self.dtype).name},num_param={self.num_parameters},kcritical={self.is_kcritical},is_squeezed={self.is_squeezed},max_dim={self.dimension}]" 
+    def __len__(self):
+        return self.num_simplices
+
     def __getstate__(self):
         """:returns: Serialized (or flattened) SimplexTree data structure in order to pickle SimplexTree.
         :rtype: numpy.array of shape (n,)
@@ -2186,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]:
@@ -2226,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.
 
@@ -2238,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:
@@ -2548,15 +2659,15 @@ 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)
 
     # cdef Simplex_tree_persistence_interface * pcohptr
     # Fake constructor that does nothing but documenting the constructor
-    def __init__(self, other = None, num_parameters:int=2,default_values=[], safe_conversion=False):
+    def __init__(self, other = None, num_parameters:int=-1,default_values=[], safe_conversion=False):
         """SimplexTreeMulti constructor.
 
         :param other: If `other` is `None` (default value), an empty `SimplexTreeMulti` is created.
@@ -2581,7 +2692,7 @@ cdef class SimplexTreeMulti_KFi64:
     def is_kcritical(self)->bool:
       return True
     # The real cython constructor
-    def __cinit__(self, other = None, int num_parameters=2, 
+    def __cinit__(self, other = None, int num_parameters=-1, 
                   default_values=np.asarray([SimplexTreeMulti_KFi64.T_minus_inf()]), # I'm not sure why `[]` does not work. Cython bug ? 
                   bool safe_conversion=False,
                   ): #TODO doc
@@ -2594,10 +2705,13 @@ cdef class SimplexTreeMulti_KFi64:
             if isinstance(other, SimplexTreeMulti_KFi64):
                 other_ptr = other.thisptr
                 self.thisptr = <intptr_t>(new Simplex_tree_multi_interface[KFi64, int64_t](dereference(<Simplex_tree_multi_interface[KFi64, int64_t]*>other_ptr))) ## prevents calling destructor of other
-                num_parameters = other.num_parameters
+                if num_parameters <=0:
+                    num_parameters = other.num_parameters
                 self.filtration_grid = other.filtration_grid
             elif isinstance(other, SimplexTree): # Constructs a SimplexTreeMulti from a SimplexTree
                 self.thisptr = <intptr_t>(new Simplex_tree_multi_interface[KFi64, int64_t]())
+                if num_parameters <= 0:
+                    num_parameters = 1
                 if safe_conversion or SAFE_CONVERSION:
                     new_st_multi  = _safe_simplextree_multify_KFi64(other, num_parameters = num_parameters, default_values=np.asarray(default_values))
                     self.thisptr, new_st_multi.thisptr = new_st_multi.thisptr, self.thisptr
@@ -2612,10 +2726,12 @@ cdef class SimplexTreeMulti_KFi64:
             else:
                 raise TypeError("`other` argument requires to be of type `SimplexTree`, `SimplexTreeMulti`, or `None`.")
         else:
+            if num_parameters <=0:
+                num_parameters = 2 # I don't know how dangerous this is, but this is mostly used.
             self.thisptr = <intptr_t>(new Simplex_tree_multi_interface[KFi64, int64_t]())
-        self.get_ptr().set_number_of_parameters(num_parameters)
+        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()
@@ -2625,6 +2741,9 @@ cdef class SimplexTreeMulti_KFi64:
 
     def __repr__(self):
         return f"SimplexTreeMulti[dtype={np.dtype(self.dtype).name},num_param={self.num_parameters},kcritical={self.is_kcritical},is_squeezed={self.is_squeezed},max_dim={self.dimension}]" 
+    def __len__(self):
+        return self.num_simplices
+
     def __getstate__(self):
         """:returns: Serialized (or flattened) SimplexTree data structure in order to pickle SimplexTree.
         :rtype: numpy.array of shape (n,)
@@ -3280,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]:
@@ -3320,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.
 
@@ -3332,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:
@@ -3644,15 +3810,15 @@ 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)
 
     # cdef Simplex_tree_persistence_interface * pcohptr
     # Fake constructor that does nothing but documenting the constructor
-    def __init__(self, other = None, num_parameters:int=2,default_values=[], safe_conversion=False):
+    def __init__(self, other = None, num_parameters:int=-1,default_values=[], safe_conversion=False):
         """SimplexTreeMulti constructor.
 
         :param other: If `other` is `None` (default value), an empty `SimplexTreeMulti` is created.
@@ -3677,7 +3843,7 @@ cdef class SimplexTreeMulti_Fi64:
     def is_kcritical(self)->bool:
       return False
     # The real cython constructor
-    def __cinit__(self, other = None, int num_parameters=2, 
+    def __cinit__(self, other = None, int num_parameters=-1, 
                   default_values=np.asarray([SimplexTreeMulti_Fi64.T_minus_inf()]), # I'm not sure why `[]` does not work. Cython bug ? 
                   bool safe_conversion=False,
                   ): #TODO doc
@@ -3690,10 +3856,13 @@ cdef class SimplexTreeMulti_Fi64:
             if isinstance(other, SimplexTreeMulti_Fi64):
                 other_ptr = other.thisptr
                 self.thisptr = <intptr_t>(new Simplex_tree_multi_interface[Fi64, int64_t](dereference(<Simplex_tree_multi_interface[Fi64, int64_t]*>other_ptr))) ## prevents calling destructor of other
-                num_parameters = other.num_parameters
+                if num_parameters <=0:
+                    num_parameters = other.num_parameters
                 self.filtration_grid = other.filtration_grid
             elif isinstance(other, SimplexTree): # Constructs a SimplexTreeMulti from a SimplexTree
                 self.thisptr = <intptr_t>(new Simplex_tree_multi_interface[Fi64, int64_t]())
+                if num_parameters <= 0:
+                    num_parameters = 1
                 if safe_conversion or SAFE_CONVERSION:
                     new_st_multi  = _safe_simplextree_multify_Fi64(other, num_parameters = num_parameters, default_values=np.asarray(default_values))
                     self.thisptr, new_st_multi.thisptr = new_st_multi.thisptr, self.thisptr
@@ -3708,10 +3877,12 @@ cdef class SimplexTreeMulti_Fi64:
             else:
                 raise TypeError("`other` argument requires to be of type `SimplexTree`, `SimplexTreeMulti`, or `None`.")
         else:
+            if num_parameters <=0:
+                num_parameters = 2 # I don't know how dangerous this is, but this is mostly used.
             self.thisptr = <intptr_t>(new Simplex_tree_multi_interface[Fi64, int64_t]())
-        self.get_ptr().set_number_of_parameters(num_parameters)
+        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()
@@ -3721,6 +3892,9 @@ cdef class SimplexTreeMulti_Fi64:
 
     def __repr__(self):
         return f"SimplexTreeMulti[dtype={np.dtype(self.dtype).name},num_param={self.num_parameters},kcritical={self.is_kcritical},is_squeezed={self.is_squeezed},max_dim={self.dimension}]" 
+    def __len__(self):
+        return self.num_simplices
+
     def __getstate__(self):
         """:returns: Serialized (or flattened) SimplexTree data structure in order to pickle SimplexTree.
         :rtype: numpy.array of shape (n,)
@@ -4653,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]:
@@ -4693,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.
 
@@ -4705,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:
@@ -5015,15 +5236,15 @@ 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)
 
     # cdef Simplex_tree_persistence_interface * pcohptr
     # Fake constructor that does nothing but documenting the constructor
-    def __init__(self, other = None, num_parameters:int=2,default_values=[], safe_conversion=False):
+    def __init__(self, other = None, num_parameters:int=-1,default_values=[], safe_conversion=False):
         """SimplexTreeMulti constructor.
 
         :param other: If `other` is `None` (default value), an empty `SimplexTreeMulti` is created.
@@ -5048,7 +5269,7 @@ cdef class SimplexTreeMulti_KFf32:
     def is_kcritical(self)->bool:
       return True
     # The real cython constructor
-    def __cinit__(self, other = None, int num_parameters=2, 
+    def __cinit__(self, other = None, int num_parameters=-1, 
                   default_values=np.asarray([SimplexTreeMulti_KFf32.T_minus_inf()]), # I'm not sure why `[]` does not work. Cython bug ? 
                   bool safe_conversion=False,
                   ): #TODO doc
@@ -5061,10 +5282,13 @@ cdef class SimplexTreeMulti_KFf32:
             if isinstance(other, SimplexTreeMulti_KFf32):
                 other_ptr = other.thisptr
                 self.thisptr = <intptr_t>(new Simplex_tree_multi_interface[KFf32, float](dereference(<Simplex_tree_multi_interface[KFf32, float]*>other_ptr))) ## prevents calling destructor of other
-                num_parameters = other.num_parameters
+                if num_parameters <=0:
+                    num_parameters = other.num_parameters
                 self.filtration_grid = other.filtration_grid
             elif isinstance(other, SimplexTree): # Constructs a SimplexTreeMulti from a SimplexTree
                 self.thisptr = <intptr_t>(new Simplex_tree_multi_interface[KFf32, float]())
+                if num_parameters <= 0:
+                    num_parameters = 1
                 if safe_conversion or SAFE_CONVERSION:
                     new_st_multi  = _safe_simplextree_multify_KFf32(other, num_parameters = num_parameters, default_values=np.asarray(default_values))
                     self.thisptr, new_st_multi.thisptr = new_st_multi.thisptr, self.thisptr
@@ -5079,10 +5303,12 @@ cdef class SimplexTreeMulti_KFf32:
             else:
                 raise TypeError("`other` argument requires to be of type `SimplexTree`, `SimplexTreeMulti`, or `None`.")
         else:
+            if num_parameters <=0:
+                num_parameters = 2 # I don't know how dangerous this is, but this is mostly used.
             self.thisptr = <intptr_t>(new Simplex_tree_multi_interface[KFf32, float]())
-        self.get_ptr().set_number_of_parameters(num_parameters)
+        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()
@@ -5092,6 +5318,9 @@ cdef class SimplexTreeMulti_KFf32:
 
     def __repr__(self):
         return f"SimplexTreeMulti[dtype={np.dtype(self.dtype).name},num_param={self.num_parameters},kcritical={self.is_kcritical},is_squeezed={self.is_squeezed},max_dim={self.dimension}]" 
+    def __len__(self):
+        return self.num_simplices
+
     def __getstate__(self):
         """:returns: Serialized (or flattened) SimplexTree data structure in order to pickle SimplexTree.
         :rtype: numpy.array of shape (n,)
@@ -5747,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]:
@@ -5787,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.
 
@@ -5799,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:
@@ -6111,15 +6387,15 @@ 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)
 
     # cdef Simplex_tree_persistence_interface * pcohptr
     # Fake constructor that does nothing but documenting the constructor
-    def __init__(self, other = None, num_parameters:int=2,default_values=[], safe_conversion=False):
+    def __init__(self, other = None, num_parameters:int=-1,default_values=[], safe_conversion=False):
         """SimplexTreeMulti constructor.
 
         :param other: If `other` is `None` (default value), an empty `SimplexTreeMulti` is created.
@@ -6144,7 +6420,7 @@ cdef class SimplexTreeMulti_Ff32:
     def is_kcritical(self)->bool:
       return False
     # The real cython constructor
-    def __cinit__(self, other = None, int num_parameters=2, 
+    def __cinit__(self, other = None, int num_parameters=-1, 
                   default_values=np.asarray([SimplexTreeMulti_Ff32.T_minus_inf()]), # I'm not sure why `[]` does not work. Cython bug ? 
                   bool safe_conversion=False,
                   ): #TODO doc
@@ -6157,10 +6433,13 @@ cdef class SimplexTreeMulti_Ff32:
             if isinstance(other, SimplexTreeMulti_Ff32):
                 other_ptr = other.thisptr
                 self.thisptr = <intptr_t>(new Simplex_tree_multi_interface[Ff32, float](dereference(<Simplex_tree_multi_interface[Ff32, float]*>other_ptr))) ## prevents calling destructor of other
-                num_parameters = other.num_parameters
+                if num_parameters <=0:
+                    num_parameters = other.num_parameters
                 self.filtration_grid = other.filtration_grid
             elif isinstance(other, SimplexTree): # Constructs a SimplexTreeMulti from a SimplexTree
                 self.thisptr = <intptr_t>(new Simplex_tree_multi_interface[Ff32, float]())
+                if num_parameters <= 0:
+                    num_parameters = 1
                 if safe_conversion or SAFE_CONVERSION:
                     new_st_multi  = _safe_simplextree_multify_Ff32(other, num_parameters = num_parameters, default_values=np.asarray(default_values))
                     self.thisptr, new_st_multi.thisptr = new_st_multi.thisptr, self.thisptr
@@ -6175,10 +6454,12 @@ cdef class SimplexTreeMulti_Ff32:
             else:
                 raise TypeError("`other` argument requires to be of type `SimplexTree`, `SimplexTreeMulti`, or `None`.")
         else:
+            if num_parameters <=0:
+                num_parameters = 2 # I don't know how dangerous this is, but this is mostly used.
             self.thisptr = <intptr_t>(new Simplex_tree_multi_interface[Ff32, float]())
-        self.get_ptr().set_number_of_parameters(num_parameters)
+        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()
@@ -6188,6 +6469,9 @@ cdef class SimplexTreeMulti_Ff32:
 
     def __repr__(self):
         return f"SimplexTreeMulti[dtype={np.dtype(self.dtype).name},num_param={self.num_parameters},kcritical={self.is_kcritical},is_squeezed={self.is_squeezed},max_dim={self.dimension}]" 
+    def __len__(self):
+        return self.num_simplices
+
     def __getstate__(self):
         """:returns: Serialized (or flattened) SimplexTree data structure in order to pickle SimplexTree.
         :rtype: numpy.array of shape (n,)
@@ -7120,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]:
@@ -7160,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.
 
@@ -7172,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:
@@ -7482,15 +7813,15 @@ 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)
 
     # cdef Simplex_tree_persistence_interface * pcohptr
     # Fake constructor that does nothing but documenting the constructor
-    def __init__(self, other = None, num_parameters:int=2,default_values=[], safe_conversion=False):
+    def __init__(self, other = None, num_parameters:int=-1,default_values=[], safe_conversion=False):
         """SimplexTreeMulti constructor.
 
         :param other: If `other` is `None` (default value), an empty `SimplexTreeMulti` is created.
@@ -7515,7 +7846,7 @@ cdef class SimplexTreeMulti_KFf64:
     def is_kcritical(self)->bool:
       return True
     # The real cython constructor
-    def __cinit__(self, other = None, int num_parameters=2, 
+    def __cinit__(self, other = None, int num_parameters=-1, 
                   default_values=np.asarray([SimplexTreeMulti_KFf64.T_minus_inf()]), # I'm not sure why `[]` does not work. Cython bug ? 
                   bool safe_conversion=False,
                   ): #TODO doc
@@ -7528,10 +7859,13 @@ cdef class SimplexTreeMulti_KFf64:
             if isinstance(other, SimplexTreeMulti_KFf64):
                 other_ptr = other.thisptr
                 self.thisptr = <intptr_t>(new Simplex_tree_multi_interface[KFf64, double](dereference(<Simplex_tree_multi_interface[KFf64, double]*>other_ptr))) ## prevents calling destructor of other
-                num_parameters = other.num_parameters
+                if num_parameters <=0:
+                    num_parameters = other.num_parameters
                 self.filtration_grid = other.filtration_grid
             elif isinstance(other, SimplexTree): # Constructs a SimplexTreeMulti from a SimplexTree
                 self.thisptr = <intptr_t>(new Simplex_tree_multi_interface[KFf64, double]())
+                if num_parameters <= 0:
+                    num_parameters = 1
                 if safe_conversion or SAFE_CONVERSION:
                     new_st_multi  = _safe_simplextree_multify_KFf64(other, num_parameters = num_parameters, default_values=np.asarray(default_values))
                     self.thisptr, new_st_multi.thisptr = new_st_multi.thisptr, self.thisptr
@@ -7546,10 +7880,12 @@ cdef class SimplexTreeMulti_KFf64:
             else:
                 raise TypeError("`other` argument requires to be of type `SimplexTree`, `SimplexTreeMulti`, or `None`.")
         else:
+            if num_parameters <=0:
+                num_parameters = 2 # I don't know how dangerous this is, but this is mostly used.
             self.thisptr = <intptr_t>(new Simplex_tree_multi_interface[KFf64, double]())
-        self.get_ptr().set_number_of_parameters(num_parameters)
+        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()
@@ -7559,6 +7895,9 @@ cdef class SimplexTreeMulti_KFf64:
 
     def __repr__(self):
         return f"SimplexTreeMulti[dtype={np.dtype(self.dtype).name},num_param={self.num_parameters},kcritical={self.is_kcritical},is_squeezed={self.is_squeezed},max_dim={self.dimension}]" 
+    def __len__(self):
+        return self.num_simplices
+
     def __getstate__(self):
         """:returns: Serialized (or flattened) SimplexTree data structure in order to pickle SimplexTree.
         :rtype: numpy.array of shape (n,)
@@ -8214,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]:
@@ -8254,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.
 
@@ -8266,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:
@@ -8578,15 +8964,15 @@ 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)
 
     # cdef Simplex_tree_persistence_interface * pcohptr
     # Fake constructor that does nothing but documenting the constructor
-    def __init__(self, other = None, num_parameters:int=2,default_values=[], safe_conversion=False):
+    def __init__(self, other = None, num_parameters:int=-1,default_values=[], safe_conversion=False):
         """SimplexTreeMulti constructor.
 
         :param other: If `other` is `None` (default value), an empty `SimplexTreeMulti` is created.
@@ -8611,7 +8997,7 @@ cdef class SimplexTreeMulti_Ff64:
     def is_kcritical(self)->bool:
       return False
     # The real cython constructor
-    def __cinit__(self, other = None, int num_parameters=2, 
+    def __cinit__(self, other = None, int num_parameters=-1, 
                   default_values=np.asarray([SimplexTreeMulti_Ff64.T_minus_inf()]), # I'm not sure why `[]` does not work. Cython bug ? 
                   bool safe_conversion=False,
                   ): #TODO doc
@@ -8624,10 +9010,13 @@ cdef class SimplexTreeMulti_Ff64:
             if isinstance(other, SimplexTreeMulti_Ff64):
                 other_ptr = other.thisptr
                 self.thisptr = <intptr_t>(new Simplex_tree_multi_interface[Ff64, double](dereference(<Simplex_tree_multi_interface[Ff64, double]*>other_ptr))) ## prevents calling destructor of other
-                num_parameters = other.num_parameters
+                if num_parameters <=0:
+                    num_parameters = other.num_parameters
                 self.filtration_grid = other.filtration_grid
             elif isinstance(other, SimplexTree): # Constructs a SimplexTreeMulti from a SimplexTree
                 self.thisptr = <intptr_t>(new Simplex_tree_multi_interface[Ff64, double]())
+                if num_parameters <= 0:
+                    num_parameters = 1
                 if safe_conversion or SAFE_CONVERSION:
                     new_st_multi  = _safe_simplextree_multify_Ff64(other, num_parameters = num_parameters, default_values=np.asarray(default_values))
                     self.thisptr, new_st_multi.thisptr = new_st_multi.thisptr, self.thisptr
@@ -8642,10 +9031,12 @@ cdef class SimplexTreeMulti_Ff64:
             else:
                 raise TypeError("`other` argument requires to be of type `SimplexTree`, `SimplexTreeMulti`, or `None`.")
         else:
+            if num_parameters <=0:
+                num_parameters = 2 # I don't know how dangerous this is, but this is mostly used.
             self.thisptr = <intptr_t>(new Simplex_tree_multi_interface[Ff64, double]())
-        self.get_ptr().set_number_of_parameters(num_parameters)
+        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()
@@ -8655,6 +9046,9 @@ cdef class SimplexTreeMulti_Ff64:
 
     def __repr__(self):
         return f"SimplexTreeMulti[dtype={np.dtype(self.dtype).name},num_param={self.num_parameters},kcritical={self.is_kcritical},is_squeezed={self.is_squeezed},max_dim={self.dimension}]" 
+    def __len__(self):
+        return self.num_simplices
+
     def __getstate__(self):
         """:returns: Serialized (or flattened) SimplexTree data structure in order to pickle SimplexTree.
         :rtype: numpy.array of shape (n,)
@@ -9587,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]:
@@ -9627,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.
 
@@ -9639,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:
@@ -9968,7 +10409,7 @@ def is_simplextree_multi(input)->bool:
 
 
 
-def SimplexTreeMulti(input=None, int num_parameters=2, dtype:type = np.float64, bool kcritical = False,**kwargs) ->  SimplexTreeMulti_type:
+def SimplexTreeMulti(input=None, int num_parameters=-1, dtype:type = np.float64, bool kcritical = False,**kwargs) ->  SimplexTreeMulti_type:
     """SimplexTreeMulti constructor.
 
     :param other: If `other` is `None` (default value), an empty `SimplexTreeMulti` is created.
@@ -10179,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])
@@ -10297,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."