multipers 2.3.3b7__cp311-cp311-win_amd64.whl → 2.3.5b1__cp311-cp311-win_amd64.whl

multipers/point_measure.pyx

@@ -366,7 +366,7 @@ def rectangle_to_hook_minimal_signed_barcode(pts,w,):
     # print("horizontal:", pts_H)
     
     
-    new_w = api.cat([-w, w, w,  w_proj,w_V,w_H])
+    new_w = np.concatenate([-w, w, w,  w_proj,w_V,w_H])
     
     pts_b0a1 = api.tensor(pts)
     pts_b0a1[:,3] = pts[:,1]

multipers/simplex_tree_multi.pxd

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

multipers/simplex_tree_multi.pyx

@@ -479,10 +479,9 @@ cdef class SimplexTreeMulti_KFi32:
             preincrement(it)
 
 
+    def _get_raw_filtration(self):
+       raise NotImplementedError("Not implemented for multicritical filtrations")
 
-    def persistence_approximation(self, **kwargs):
-        from multipers.multiparameter_module_approximation import module_approximation
-        return module_approximation(self, **kwargs)
 
 
     def get_skeleton(self, dimension)->Iterable[tuple[np.ndarray,np.ndarray]]:
@@ -625,6 +624,41 @@ cdef class SimplexTreeMulti_KFi32:
         """
         return self.get_ptr().prune_above_dimension(dimension)
 
+    def expansion(self, int max_dim)->SimplexTreeMulti_KFi32:
+        """Expands the simplex tree containing only its one skeleton
+        until dimension max_dim.
+
+        The expanded simplicial complex until dimension :math:`d`
+        attached to a graph :math:`G` is the maximal simplicial complex of
+        dimension at most :math:`d` admitting the graph :math:`G` as
+        :math:`1`-skeleton.
+        The filtration value assigned to a simplex is the maximal filtration
+        value of one of its edges.
+
+        The simplex tree must contain no simplex of dimension bigger than
+        1 when calling the method.
+
+        :param max_dim: The maximal dimension.
+        :type max_dim: int
+        """
+        with nogil:
+            self.get_ptr().expansion(max_dim)
+            # This is a fix for multipersistence. FIXME expansion in c++
+            self.get_ptr().make_filtration_non_decreasing()
+        return self
+
+    def make_filtration_non_decreasing(self)->bool: 
+        """This function ensures that each simplex has a higher filtration
+        value than its faces by increasing the filtration values.
+
+        :returns: True if any filtration value was modified,
+            False if the filtration was already non-decreasing.
+        :rtype: bool
+        """
+        cdef bool out
+        with nogil:
+            out = self.get_ptr().make_filtration_non_decreasing()
+        return out
 
     def reset_filtration(self, filtration, min_dim = 0)->SimplexTreeMulti_KFi32:
         """This function resets the filtration value of all the simplices of dimension at least min_dim. Resets all the
@@ -881,7 +915,6 @@ cdef class SimplexTreeMulti_KFi32:
             self,
             filtration_grid:np.ndarray|list|None=None,
             bool coordinate_values=True,
-            bool force=False,
             str strategy:_available_strategies = "exact",
             resolution:Optional[int|list[int]] = None,
             bool coordinates = False,
@@ -897,8 +930,6 @@ cdef class SimplexTreeMulti_KFi32:
         :param coordinate_values: If true, the filtrations values of the simplices will be set to the coordinate of the filtration grid.
         :type coordinate_values: bool
         """
-        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)
@@ -908,7 +939,7 @@ cdef class SimplexTreeMulti_KFi32:
             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)
+            return temp.grid_squeeze(sanitize_grid(subgrid, numpyfy=True), coordinates=coordinates, inplace=inplace)
 
         #TODO : multi-critical
         if filtration_grid is None:  
@@ -1742,10 +1773,25 @@ cdef class SimplexTreeMulti_Fi32:
             preincrement(it)
 
 
+    def _get_raw_filtration(self):
+        if self.is_squeezed:
+            raise NotImplementedError("Not implemented for squeezed filtrations")
+        cdef int num_parameters = self.num_parameters
+        cdef int32_t[:,:] current_filtration = np.empty((self.num_simplices, self.num_parameters), dtype=self.dtype)
+
+        cdef Simplex_tree_multi_simplices_iterator[Fi32] it = self.get_ptr().get_simplices_iterator_begin()
+        cdef Simplex_tree_multi_simplices_iterator[Fi32] end = self.get_ptr().get_simplices_iterator_end()
+
+        cdef int i=0
+        with nogil:
+            while it != end:
+                pair_sf = <pair[simplex_type, Fi32*]> self.get_ptr().get_simplex_and_filtration(dereference(it))
+                for j in range(num_parameters):
+                    current_filtration[i,j] = dereference(pair_sf.second)[j]
+                preincrement(it)
+                i = i+1
+        return np.asarray(current_filtration, dtype=self.dtype)
 
-    def persistence_approximation(self, **kwargs):
-        from multipers.multiparameter_module_approximation import module_approximation
-        return module_approximation(self, **kwargs)
 
 
     def get_skeleton(self, dimension)->Iterable[tuple[np.ndarray,np.ndarray]]:
@@ -2322,7 +2368,6 @@ cdef class SimplexTreeMulti_Fi32:
             self,
             filtration_grid:np.ndarray|list|None=None,
             bool coordinate_values=True,
-            bool force=False,
             str strategy:_available_strategies = "exact",
             resolution:Optional[int|list[int]] = None,
             bool coordinates = False,
@@ -2338,8 +2383,6 @@ cdef class SimplexTreeMulti_Fi32:
         :param coordinate_values: If true, the filtrations values of the simplices will be set to the coordinate of the filtration grid.
         :type coordinate_values: bool
         """
-        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)
@@ -2349,7 +2392,7 @@ cdef class SimplexTreeMulti_Fi32:
             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)
+            return temp.grid_squeeze(sanitize_grid(subgrid, numpyfy=True), coordinates=coordinates, inplace=inplace)
 
         #TODO : multi-critical
         if filtration_grid is None:  
@@ -3071,10 +3114,9 @@ cdef class SimplexTreeMulti_KFi64:
             preincrement(it)
 
 
+    def _get_raw_filtration(self):
+       raise NotImplementedError("Not implemented for multicritical filtrations")
 
-    def persistence_approximation(self, **kwargs):
-        from multipers.multiparameter_module_approximation import module_approximation
-        return module_approximation(self, **kwargs)
 
 
     def get_skeleton(self, dimension)->Iterable[tuple[np.ndarray,np.ndarray]]:
@@ -3217,6 +3259,41 @@ cdef class SimplexTreeMulti_KFi64:
         """
         return self.get_ptr().prune_above_dimension(dimension)
 
+    def expansion(self, int max_dim)->SimplexTreeMulti_KFi64:
+        """Expands the simplex tree containing only its one skeleton
+        until dimension max_dim.
+
+        The expanded simplicial complex until dimension :math:`d`
+        attached to a graph :math:`G` is the maximal simplicial complex of
+        dimension at most :math:`d` admitting the graph :math:`G` as
+        :math:`1`-skeleton.
+        The filtration value assigned to a simplex is the maximal filtration
+        value of one of its edges.
+
+        The simplex tree must contain no simplex of dimension bigger than
+        1 when calling the method.
+
+        :param max_dim: The maximal dimension.
+        :type max_dim: int
+        """
+        with nogil:
+            self.get_ptr().expansion(max_dim)
+            # This is a fix for multipersistence. FIXME expansion in c++
+            self.get_ptr().make_filtration_non_decreasing()
+        return self
+
+    def make_filtration_non_decreasing(self)->bool: 
+        """This function ensures that each simplex has a higher filtration
+        value than its faces by increasing the filtration values.
+
+        :returns: True if any filtration value was modified,
+            False if the filtration was already non-decreasing.
+        :rtype: bool
+        """
+        cdef bool out
+        with nogil:
+            out = self.get_ptr().make_filtration_non_decreasing()
+        return out
 
     def reset_filtration(self, filtration, min_dim = 0)->SimplexTreeMulti_KFi64:
         """This function resets the filtration value of all the simplices of dimension at least min_dim. Resets all the
@@ -3473,7 +3550,6 @@ cdef class SimplexTreeMulti_KFi64:
             self,
             filtration_grid:np.ndarray|list|None=None,
             bool coordinate_values=True,
-            bool force=False,
             str strategy:_available_strategies = "exact",
             resolution:Optional[int|list[int]] = None,
             bool coordinates = False,
@@ -3489,8 +3565,6 @@ cdef class SimplexTreeMulti_KFi64:
         :param coordinate_values: If true, the filtrations values of the simplices will be set to the coordinate of the filtration grid.
         :type coordinate_values: bool
         """
-        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)
@@ -3500,7 +3574,7 @@ cdef class SimplexTreeMulti_KFi64:
             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)
+            return temp.grid_squeeze(sanitize_grid(subgrid, numpyfy=True), coordinates=coordinates, inplace=inplace)
 
         #TODO : multi-critical
         if filtration_grid is None:  
@@ -4334,10 +4408,25 @@ cdef class SimplexTreeMulti_Fi64:
             preincrement(it)
 
 
+    def _get_raw_filtration(self):
+        if self.is_squeezed:
+            raise NotImplementedError("Not implemented for squeezed filtrations")
+        cdef int num_parameters = self.num_parameters
+        cdef int64_t[:,:] current_filtration = np.empty((self.num_simplices, self.num_parameters), dtype=self.dtype)
+
+        cdef Simplex_tree_multi_simplices_iterator[Fi64] it = self.get_ptr().get_simplices_iterator_begin()
+        cdef Simplex_tree_multi_simplices_iterator[Fi64] end = self.get_ptr().get_simplices_iterator_end()
+
+        cdef int i=0
+        with nogil:
+            while it != end:
+                pair_sf = <pair[simplex_type, Fi64*]> self.get_ptr().get_simplex_and_filtration(dereference(it))
+                for j in range(num_parameters):
+                    current_filtration[i,j] = dereference(pair_sf.second)[j]
+                preincrement(it)
+                i = i+1
+        return np.asarray(current_filtration, dtype=self.dtype)
 
-    def persistence_approximation(self, **kwargs):
-        from multipers.multiparameter_module_approximation import module_approximation
-        return module_approximation(self, **kwargs)
 
 
     def get_skeleton(self, dimension)->Iterable[tuple[np.ndarray,np.ndarray]]:
@@ -4914,7 +5003,6 @@ cdef class SimplexTreeMulti_Fi64:
             self,
             filtration_grid:np.ndarray|list|None=None,
             bool coordinate_values=True,
-            bool force=False,
             str strategy:_available_strategies = "exact",
             resolution:Optional[int|list[int]] = None,
             bool coordinates = False,
@@ -4930,8 +5018,6 @@ cdef class SimplexTreeMulti_Fi64:
         :param coordinate_values: If true, the filtrations values of the simplices will be set to the coordinate of the filtration grid.
         :type coordinate_values: bool
         """
-        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)
@@ -4941,7 +5027,7 @@ cdef class SimplexTreeMulti_Fi64:
             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)
+            return temp.grid_squeeze(sanitize_grid(subgrid, numpyfy=True), coordinates=coordinates, inplace=inplace)
 
         #TODO : multi-critical
         if filtration_grid is None:  
@@ -5663,10 +5749,9 @@ cdef class SimplexTreeMulti_KFf32:
             preincrement(it)
 
 
+    def _get_raw_filtration(self):
+       raise NotImplementedError("Not implemented for multicritical filtrations")
 
-    def persistence_approximation(self, **kwargs):
-        from multipers.multiparameter_module_approximation import module_approximation
-        return module_approximation(self, **kwargs)
 
 
     def get_skeleton(self, dimension)->Iterable[tuple[np.ndarray,np.ndarray]]:
@@ -5809,6 +5894,41 @@ cdef class SimplexTreeMulti_KFf32:
         """
         return self.get_ptr().prune_above_dimension(dimension)
 
+    def expansion(self, int max_dim)->SimplexTreeMulti_KFf32:
+        """Expands the simplex tree containing only its one skeleton
+        until dimension max_dim.
+
+        The expanded simplicial complex until dimension :math:`d`
+        attached to a graph :math:`G` is the maximal simplicial complex of
+        dimension at most :math:`d` admitting the graph :math:`G` as
+        :math:`1`-skeleton.
+        The filtration value assigned to a simplex is the maximal filtration
+        value of one of its edges.
+
+        The simplex tree must contain no simplex of dimension bigger than
+        1 when calling the method.
+
+        :param max_dim: The maximal dimension.
+        :type max_dim: int
+        """
+        with nogil:
+            self.get_ptr().expansion(max_dim)
+            # This is a fix for multipersistence. FIXME expansion in c++
+            self.get_ptr().make_filtration_non_decreasing()
+        return self
+
+    def make_filtration_non_decreasing(self)->bool: 
+        """This function ensures that each simplex has a higher filtration
+        value than its faces by increasing the filtration values.
+
+        :returns: True if any filtration value was modified,
+            False if the filtration was already non-decreasing.
+        :rtype: bool
+        """
+        cdef bool out
+        with nogil:
+            out = self.get_ptr().make_filtration_non_decreasing()
+        return out
 
     def reset_filtration(self, filtration, min_dim = 0)->SimplexTreeMulti_KFf32:
         """This function resets the filtration value of all the simplices of dimension at least min_dim. Resets all the
@@ -6065,7 +6185,6 @@ cdef class SimplexTreeMulti_KFf32:
             self,
             filtration_grid:np.ndarray|list|None=None,
             bool coordinate_values=True,
-            bool force=False,
             str strategy:_available_strategies = "exact",
             resolution:Optional[int|list[int]] = None,
             bool coordinates = False,
@@ -6081,8 +6200,6 @@ cdef class SimplexTreeMulti_KFf32:
         :param coordinate_values: If true, the filtrations values of the simplices will be set to the coordinate of the filtration grid.
         :type coordinate_values: bool
         """
-        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)
@@ -6092,7 +6209,7 @@ cdef class SimplexTreeMulti_KFf32:
             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)
+            return temp.grid_squeeze(sanitize_grid(subgrid, numpyfy=True), coordinates=coordinates, inplace=inplace)
 
         #TODO : multi-critical
         if filtration_grid is None:  
@@ -6926,10 +7043,25 @@ cdef class SimplexTreeMulti_Ff32:
             preincrement(it)
 
 
+    def _get_raw_filtration(self):
+        if self.is_squeezed:
+            raise NotImplementedError("Not implemented for squeezed filtrations")
+        cdef int num_parameters = self.num_parameters
+        cdef float[:,:] current_filtration = np.empty((self.num_simplices, self.num_parameters), dtype=self.dtype)
+
+        cdef Simplex_tree_multi_simplices_iterator[Ff32] it = self.get_ptr().get_simplices_iterator_begin()
+        cdef Simplex_tree_multi_simplices_iterator[Ff32] end = self.get_ptr().get_simplices_iterator_end()
+
+        cdef int i=0
+        with nogil:
+            while it != end:
+                pair_sf = <pair[simplex_type, Ff32*]> self.get_ptr().get_simplex_and_filtration(dereference(it))
+                for j in range(num_parameters):
+                    current_filtration[i,j] = dereference(pair_sf.second)[j]
+                preincrement(it)
+                i = i+1
+        return np.asarray(current_filtration, dtype=self.dtype)
 
-    def persistence_approximation(self, **kwargs):
-        from multipers.multiparameter_module_approximation import module_approximation
-        return module_approximation(self, **kwargs)
 
 
     def get_skeleton(self, dimension)->Iterable[tuple[np.ndarray,np.ndarray]]:
@@ -7506,7 +7638,6 @@ cdef class SimplexTreeMulti_Ff32:
             self,
             filtration_grid:np.ndarray|list|None=None,
             bool coordinate_values=True,
-            bool force=False,
             str strategy:_available_strategies = "exact",
             resolution:Optional[int|list[int]] = None,
             bool coordinates = False,
@@ -7522,8 +7653,6 @@ cdef class SimplexTreeMulti_Ff32:
         :param coordinate_values: If true, the filtrations values of the simplices will be set to the coordinate of the filtration grid.
         :type coordinate_values: bool
         """
-        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)
@@ -7533,7 +7662,7 @@ cdef class SimplexTreeMulti_Ff32:
             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)
+            return temp.grid_squeeze(sanitize_grid(subgrid, numpyfy=True), coordinates=coordinates, inplace=inplace)
 
         #TODO : multi-critical
         if filtration_grid is None:  
@@ -8255,10 +8384,9 @@ cdef class SimplexTreeMulti_KFf64:
             preincrement(it)
 
 
+    def _get_raw_filtration(self):
+       raise NotImplementedError("Not implemented for multicritical filtrations")
 
-    def persistence_approximation(self, **kwargs):
-        from multipers.multiparameter_module_approximation import module_approximation
-        return module_approximation(self, **kwargs)
 
 
     def get_skeleton(self, dimension)->Iterable[tuple[np.ndarray,np.ndarray]]:
@@ -8401,6 +8529,41 @@ cdef class SimplexTreeMulti_KFf64:
         """
         return self.get_ptr().prune_above_dimension(dimension)
 
+    def expansion(self, int max_dim)->SimplexTreeMulti_KFf64:
+        """Expands the simplex tree containing only its one skeleton
+        until dimension max_dim.
+
+        The expanded simplicial complex until dimension :math:`d`
+        attached to a graph :math:`G` is the maximal simplicial complex of
+        dimension at most :math:`d` admitting the graph :math:`G` as
+        :math:`1`-skeleton.
+        The filtration value assigned to a simplex is the maximal filtration
+        value of one of its edges.
+
+        The simplex tree must contain no simplex of dimension bigger than
+        1 when calling the method.
+
+        :param max_dim: The maximal dimension.
+        :type max_dim: int
+        """
+        with nogil:
+            self.get_ptr().expansion(max_dim)
+            # This is a fix for multipersistence. FIXME expansion in c++
+            self.get_ptr().make_filtration_non_decreasing()
+        return self
+
+    def make_filtration_non_decreasing(self)->bool: 
+        """This function ensures that each simplex has a higher filtration
+        value than its faces by increasing the filtration values.
+
+        :returns: True if any filtration value was modified,
+            False if the filtration was already non-decreasing.
+        :rtype: bool
+        """
+        cdef bool out
+        with nogil:
+            out = self.get_ptr().make_filtration_non_decreasing()
+        return out
 
     def reset_filtration(self, filtration, min_dim = 0)->SimplexTreeMulti_KFf64:
         """This function resets the filtration value of all the simplices of dimension at least min_dim. Resets all the
@@ -8657,7 +8820,6 @@ cdef class SimplexTreeMulti_KFf64:
             self,
             filtration_grid:np.ndarray|list|None=None,
             bool coordinate_values=True,
-            bool force=False,
             str strategy:_available_strategies = "exact",
             resolution:Optional[int|list[int]] = None,
             bool coordinates = False,
@@ -8673,8 +8835,6 @@ cdef class SimplexTreeMulti_KFf64:
         :param coordinate_values: If true, the filtrations values of the simplices will be set to the coordinate of the filtration grid.
         :type coordinate_values: bool
         """
-        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)
@@ -8684,7 +8844,7 @@ cdef class SimplexTreeMulti_KFf64:
             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)
+            return temp.grid_squeeze(sanitize_grid(subgrid, numpyfy=True), coordinates=coordinates, inplace=inplace)
 
         #TODO : multi-critical
         if filtration_grid is None:  
@@ -9518,10 +9678,25 @@ cdef class SimplexTreeMulti_Ff64:
             preincrement(it)
 
 
+    def _get_raw_filtration(self):
+        if self.is_squeezed:
+            raise NotImplementedError("Not implemented for squeezed filtrations")
+        cdef int num_parameters = self.num_parameters
+        cdef double[:,:] current_filtration = np.empty((self.num_simplices, self.num_parameters), dtype=self.dtype)
+
+        cdef Simplex_tree_multi_simplices_iterator[Ff64] it = self.get_ptr().get_simplices_iterator_begin()
+        cdef Simplex_tree_multi_simplices_iterator[Ff64] end = self.get_ptr().get_simplices_iterator_end()
+
+        cdef int i=0
+        with nogil:
+            while it != end:
+                pair_sf = <pair[simplex_type, Ff64*]> self.get_ptr().get_simplex_and_filtration(dereference(it))
+                for j in range(num_parameters):
+                    current_filtration[i,j] = dereference(pair_sf.second)[j]
+                preincrement(it)
+                i = i+1
+        return np.asarray(current_filtration, dtype=self.dtype)
 
-    def persistence_approximation(self, **kwargs):
-        from multipers.multiparameter_module_approximation import module_approximation
-        return module_approximation(self, **kwargs)
 
 
     def get_skeleton(self, dimension)->Iterable[tuple[np.ndarray,np.ndarray]]:
@@ -10098,7 +10273,6 @@ cdef class SimplexTreeMulti_Ff64:
             self,
             filtration_grid:np.ndarray|list|None=None,
             bool coordinate_values=True,
-            bool force=False,
             str strategy:_available_strategies = "exact",
             resolution:Optional[int|list[int]] = None,
             bool coordinates = False,
@@ -10114,8 +10288,6 @@ cdef class SimplexTreeMulti_Ff64:
         :param coordinate_values: If true, the filtrations values of the simplices will be set to the coordinate of the filtration grid.
         :type coordinate_values: bool
         """
-        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)
@@ -10125,7 +10297,7 @@ cdef class SimplexTreeMulti_Ff64:
             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)
+            return temp.grid_squeeze(sanitize_grid(subgrid, numpyfy=True), coordinates=coordinates, inplace=inplace)
 
         #TODO : multi-critical
         if filtration_grid is None:  

multipers/simplex_tree_multi.pyx.tp

@@ -715,10 +715,29 @@ cdef class SimplexTreeMulti_{{FSHORT}}:
             preincrement(it)
 
 
+    def _get_raw_filtration(self):
+       {{if is_kcritical}}
+       raise NotImplementedError("Not implemented for multicritical filtrations")
+       {{else}}
+        if self.is_squeezed:
+            raise NotImplementedError("Not implemented for squeezed filtrations")
+        cdef int num_parameters = self.num_parameters
+        cdef {{CTYPE}}[:,:] current_filtration = np.empty((self.num_simplices, self.num_parameters), dtype=self.dtype)
+
+        cdef Simplex_tree_multi_simplices_iterator[{{FSHORT}}] it = self.get_ptr().get_simplices_iterator_begin()
+        cdef Simplex_tree_multi_simplices_iterator[{{FSHORT}}] end = self.get_ptr().get_simplices_iterator_end()
+
+        cdef int i=0
+        with nogil:
+            while it != end:
+                pair_sf = <pair[simplex_type, {{FSHORT}}*]> self.get_ptr().get_simplex_and_filtration(dereference(it))
+                for j in range(num_parameters):
+                    current_filtration[i,j] = dereference(pair_sf.second)[j]
+                preincrement(it)
+                i = i+1
+        return np.asarray(current_filtration, dtype=self.dtype)
+        {{endif}}
 
-    def persistence_approximation(self, **kwargs):
-        from multipers.multiparameter_module_approximation import module_approximation
-        return module_approximation(self, **kwargs)
 
 
     def get_skeleton(self, dimension)->Iterable[tuple[np.ndarray,np.ndarray]]:
@@ -869,7 +888,6 @@ cdef class SimplexTreeMulti_{{FSHORT}}:
         """
         return self.get_ptr().prune_above_dimension(dimension)
 
-    {{if not is_kcritical}}
     def expansion(self, int max_dim)->SimplexTreeMulti_{{FSHORT}}:
         """Expands the simplex tree containing only its one skeleton
         until dimension max_dim.
@@ -905,7 +923,6 @@ cdef class SimplexTreeMulti_{{FSHORT}}:
         with nogil:
             out = self.get_ptr().make_filtration_non_decreasing()
         return out
-    {{endif}}
 
     def reset_filtration(self, filtration, min_dim = 0)->SimplexTreeMulti_{{FSHORT}}:
         """This function resets the filtration value of all the simplices of dimension at least min_dim. Resets all the
@@ -1328,7 +1345,6 @@ cdef class SimplexTreeMulti_{{FSHORT}}:
             self,
             filtration_grid:np.ndarray|list|None=None,
             bool coordinate_values=True,
-            bool force=False,
             str strategy:_available_strategies = "exact",
             resolution:Optional[int|list[int]] = None,
             bool coordinates = False,
@@ -1344,8 +1360,6 @@ cdef class SimplexTreeMulti_{{FSHORT}}:
         :param coordinate_values: If true, the filtrations values of the simplices will be set to the coordinate of the filtration grid.
         :type coordinate_values: bool
         """
-        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)
@@ -1355,7 +1369,7 @@ cdef class SimplexTreeMulti_{{FSHORT}}:
             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)
+            return temp.grid_squeeze(sanitize_grid(subgrid, numpyfy=True), coordinates=coordinates, inplace=inplace)
 
         #TODO : multi-critical
         if filtration_grid is None: