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

multipers/slicer.pyx

@@ -448,6 +448,13 @@ cdef class _KSlicer_Matrix0_vine_i32:
         self.truc = C_KSlicer_Matrix0_vine_i32(c_generator_maps,c_generator_dimensions, c_filtration_values)
         self.minpres_degree = -1
     
+    def to_colexical(self)->_KSlicer_Matrix0_vine_i32:
+        assert not self.is_squeezed, "Unsqueeze first"
+        new_slicer = _KSlicer_Matrix0_vine_i32()
+        new_slicer.truc = self.truc.colexical_rearange()
+        new_slicer.minpres_degree = self.minpres_degree
+        return new_slicer
+
     def copy(self)->_KSlicer_Matrix0_vine_i32:
         """
         Returns a copy of the slicer.
@@ -491,7 +498,7 @@ cdef class _KSlicer_Matrix0_vine_i32:
         direction = 1 if direction is None else np.asarray(direction)[None,None,:]
         return tuple(bc[:,:,None]*direction + basepoint for bc in bcs)
 
-    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False):
+    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Computes the persistence on a line L defined by 
          - a basepoint (num_parameters,) array
@@ -500,7 +507,7 @@ cdef class _KSlicer_Matrix0_vine_i32:
         Warning: This is not parallelizable. Use `persitence_on_lines`.
         """
         self.push_to_line(basepoint,direction)
-        self.truc.compute_persistence()
+        self.truc.compute_persistence(ignore_infinite_filtration_values)
         if keep_inf:
             bcs = tuple(np.asarray(stuff, dtype = np.int32) for stuff in self.truc.get_barcode())
         else:
@@ -510,7 +517,7 @@ cdef class _KSlicer_Matrix0_vine_i32:
             bcs = _KSlicer_Matrix0_vine_i32._bc_to_full(bcs, basepoint, direction)
         return bcs
 
-    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False):
+    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Same as `persistence_on_line`, but with vineyards operation between
         lines if `self.is_vine`, and in parallel otherwise.
@@ -521,11 +528,11 @@ cdef class _KSlicer_Matrix0_vine_i32:
         if directions is None:
             c_basepoints = basepoints
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_basepoints)
+                c_out = self.truc.persistence_on_lines(c_basepoints, ignore_infinite_filtration_values)
         else:
             c_truc = zip(basepoints,directions)
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_truc)
+                c_out = self.truc.persistence_on_lines(c_truc, ignore_infinite_filtration_values)
         cdef int num_bc = c_basepoints.size()
         
         if keep_inf:
@@ -838,6 +845,13 @@ cdef class _KSlicer_Matrix1_vine_i32:
         self.truc = C_KSlicer_Matrix1_vine_i32(c_generator_maps,c_generator_dimensions, c_filtration_values)
         self.minpres_degree = -1
     
+    def to_colexical(self)->_KSlicer_Matrix1_vine_i32:
+        assert not self.is_squeezed, "Unsqueeze first"
+        new_slicer = _KSlicer_Matrix1_vine_i32()
+        new_slicer.truc = self.truc.colexical_rearange()
+        new_slicer.minpres_degree = self.minpres_degree
+        return new_slicer
+
     def copy(self)->_KSlicer_Matrix1_vine_i32:
         """
         Returns a copy of the slicer.
@@ -881,7 +895,7 @@ cdef class _KSlicer_Matrix1_vine_i32:
         direction = 1 if direction is None else np.asarray(direction)[None,None,:]
         return tuple(bc[:,:,None]*direction + basepoint for bc in bcs)
 
-    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False):
+    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Computes the persistence on a line L defined by 
          - a basepoint (num_parameters,) array
@@ -890,7 +904,7 @@ cdef class _KSlicer_Matrix1_vine_i32:
         Warning: This is not parallelizable. Use `persitence_on_lines`.
         """
         self.push_to_line(basepoint,direction)
-        self.truc.compute_persistence()
+        self.truc.compute_persistence(ignore_infinite_filtration_values)
         if keep_inf:
             bcs = tuple(np.asarray(stuff, dtype = np.int32) for stuff in self.truc.get_barcode())
         else:
@@ -900,7 +914,7 @@ cdef class _KSlicer_Matrix1_vine_i32:
             bcs = _KSlicer_Matrix1_vine_i32._bc_to_full(bcs, basepoint, direction)
         return bcs
 
-    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False):
+    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Same as `persistence_on_line`, but with vineyards operation between
         lines if `self.is_vine`, and in parallel otherwise.
@@ -911,11 +925,11 @@ cdef class _KSlicer_Matrix1_vine_i32:
         if directions is None:
             c_basepoints = basepoints
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_basepoints)
+                c_out = self.truc.persistence_on_lines(c_basepoints, ignore_infinite_filtration_values)
         else:
             c_truc = zip(basepoints,directions)
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_truc)
+                c_out = self.truc.persistence_on_lines(c_truc, ignore_infinite_filtration_values)
         cdef int num_bc = c_basepoints.size()
         
         if keep_inf:
@@ -1228,6 +1242,13 @@ cdef class _KSlicer_Matrix0_vine_i64:
         self.truc = C_KSlicer_Matrix0_vine_i64(c_generator_maps,c_generator_dimensions, c_filtration_values)
         self.minpres_degree = -1
     
+    def to_colexical(self)->_KSlicer_Matrix0_vine_i64:
+        assert not self.is_squeezed, "Unsqueeze first"
+        new_slicer = _KSlicer_Matrix0_vine_i64()
+        new_slicer.truc = self.truc.colexical_rearange()
+        new_slicer.minpres_degree = self.minpres_degree
+        return new_slicer
+
     def copy(self)->_KSlicer_Matrix0_vine_i64:
         """
         Returns a copy of the slicer.
@@ -1271,7 +1292,7 @@ cdef class _KSlicer_Matrix0_vine_i64:
         direction = 1 if direction is None else np.asarray(direction)[None,None,:]
         return tuple(bc[:,:,None]*direction + basepoint for bc in bcs)
 
-    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False):
+    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Computes the persistence on a line L defined by 
          - a basepoint (num_parameters,) array
@@ -1280,7 +1301,7 @@ cdef class _KSlicer_Matrix0_vine_i64:
         Warning: This is not parallelizable. Use `persitence_on_lines`.
         """
         self.push_to_line(basepoint,direction)
-        self.truc.compute_persistence()
+        self.truc.compute_persistence(ignore_infinite_filtration_values)
         if keep_inf:
             bcs = tuple(np.asarray(stuff, dtype = np.int64) for stuff in self.truc.get_barcode())
         else:
@@ -1290,7 +1311,7 @@ cdef class _KSlicer_Matrix0_vine_i64:
             bcs = _KSlicer_Matrix0_vine_i64._bc_to_full(bcs, basepoint, direction)
         return bcs
 
-    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False):
+    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Same as `persistence_on_line`, but with vineyards operation between
         lines if `self.is_vine`, and in parallel otherwise.
@@ -1301,11 +1322,11 @@ cdef class _KSlicer_Matrix0_vine_i64:
         if directions is None:
             c_basepoints = basepoints
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_basepoints)
+                c_out = self.truc.persistence_on_lines(c_basepoints, ignore_infinite_filtration_values)
         else:
             c_truc = zip(basepoints,directions)
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_truc)
+                c_out = self.truc.persistence_on_lines(c_truc, ignore_infinite_filtration_values)
         cdef int num_bc = c_basepoints.size()
         
         if keep_inf:
@@ -1618,6 +1639,13 @@ cdef class _KSlicer_Matrix1_vine_i64:
         self.truc = C_KSlicer_Matrix1_vine_i64(c_generator_maps,c_generator_dimensions, c_filtration_values)
         self.minpres_degree = -1
     
+    def to_colexical(self)->_KSlicer_Matrix1_vine_i64:
+        assert not self.is_squeezed, "Unsqueeze first"
+        new_slicer = _KSlicer_Matrix1_vine_i64()
+        new_slicer.truc = self.truc.colexical_rearange()
+        new_slicer.minpres_degree = self.minpres_degree
+        return new_slicer
+
     def copy(self)->_KSlicer_Matrix1_vine_i64:
         """
         Returns a copy of the slicer.
@@ -1661,7 +1689,7 @@ cdef class _KSlicer_Matrix1_vine_i64:
         direction = 1 if direction is None else np.asarray(direction)[None,None,:]
         return tuple(bc[:,:,None]*direction + basepoint for bc in bcs)
 
-    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False):
+    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Computes the persistence on a line L defined by 
          - a basepoint (num_parameters,) array
@@ -1670,7 +1698,7 @@ cdef class _KSlicer_Matrix1_vine_i64:
         Warning: This is not parallelizable. Use `persitence_on_lines`.
         """
         self.push_to_line(basepoint,direction)
-        self.truc.compute_persistence()
+        self.truc.compute_persistence(ignore_infinite_filtration_values)
         if keep_inf:
             bcs = tuple(np.asarray(stuff, dtype = np.int64) for stuff in self.truc.get_barcode())
         else:
@@ -1680,7 +1708,7 @@ cdef class _KSlicer_Matrix1_vine_i64:
             bcs = _KSlicer_Matrix1_vine_i64._bc_to_full(bcs, basepoint, direction)
         return bcs
 
-    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False):
+    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Same as `persistence_on_line`, but with vineyards operation between
         lines if `self.is_vine`, and in parallel otherwise.
@@ -1691,11 +1719,11 @@ cdef class _KSlicer_Matrix1_vine_i64:
         if directions is None:
             c_basepoints = basepoints
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_basepoints)
+                c_out = self.truc.persistence_on_lines(c_basepoints, ignore_infinite_filtration_values)
         else:
             c_truc = zip(basepoints,directions)
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_truc)
+                c_out = self.truc.persistence_on_lines(c_truc, ignore_infinite_filtration_values)
         cdef int num_bc = c_basepoints.size()
         
         if keep_inf:
@@ -2008,6 +2036,13 @@ cdef class _KSlicer_Matrix0_vine_f32:
         self.truc = C_KSlicer_Matrix0_vine_f32(c_generator_maps,c_generator_dimensions, c_filtration_values)
         self.minpres_degree = -1
     
+    def to_colexical(self)->_KSlicer_Matrix0_vine_f32:
+        assert not self.is_squeezed, "Unsqueeze first"
+        new_slicer = _KSlicer_Matrix0_vine_f32()
+        new_slicer.truc = self.truc.colexical_rearange()
+        new_slicer.minpres_degree = self.minpres_degree
+        return new_slicer
+
     def copy(self)->_KSlicer_Matrix0_vine_f32:
         """
         Returns a copy of the slicer.
@@ -2051,7 +2086,7 @@ cdef class _KSlicer_Matrix0_vine_f32:
         direction = 1 if direction is None else np.asarray(direction)[None,None,:]
         return tuple(bc[:,:,None]*direction + basepoint for bc in bcs)
 
-    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False):
+    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Computes the persistence on a line L defined by 
          - a basepoint (num_parameters,) array
@@ -2060,7 +2095,7 @@ cdef class _KSlicer_Matrix0_vine_f32:
         Warning: This is not parallelizable. Use `persitence_on_lines`.
         """
         self.push_to_line(basepoint,direction)
-        self.truc.compute_persistence()
+        self.truc.compute_persistence(ignore_infinite_filtration_values)
         if keep_inf:
             bcs = tuple(np.asarray(stuff, dtype = np.float32) for stuff in self.truc.get_barcode())
         else:
@@ -2070,7 +2105,7 @@ cdef class _KSlicer_Matrix0_vine_f32:
             bcs = _KSlicer_Matrix0_vine_f32._bc_to_full(bcs, basepoint, direction)
         return bcs
 
-    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False):
+    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Same as `persistence_on_line`, but with vineyards operation between
         lines if `self.is_vine`, and in parallel otherwise.
@@ -2081,11 +2116,11 @@ cdef class _KSlicer_Matrix0_vine_f32:
         if directions is None:
             c_basepoints = basepoints
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_basepoints)
+                c_out = self.truc.persistence_on_lines(c_basepoints, ignore_infinite_filtration_values)
         else:
             c_truc = zip(basepoints,directions)
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_truc)
+                c_out = self.truc.persistence_on_lines(c_truc, ignore_infinite_filtration_values)
         cdef int num_bc = c_basepoints.size()
         
         if keep_inf:
@@ -2398,6 +2433,13 @@ cdef class _KSlicer_Matrix1_vine_f32:
         self.truc = C_KSlicer_Matrix1_vine_f32(c_generator_maps,c_generator_dimensions, c_filtration_values)
         self.minpres_degree = -1
     
+    def to_colexical(self)->_KSlicer_Matrix1_vine_f32:
+        assert not self.is_squeezed, "Unsqueeze first"
+        new_slicer = _KSlicer_Matrix1_vine_f32()
+        new_slicer.truc = self.truc.colexical_rearange()
+        new_slicer.minpres_degree = self.minpres_degree
+        return new_slicer
+
     def copy(self)->_KSlicer_Matrix1_vine_f32:
         """
         Returns a copy of the slicer.
@@ -2441,7 +2483,7 @@ cdef class _KSlicer_Matrix1_vine_f32:
         direction = 1 if direction is None else np.asarray(direction)[None,None,:]
         return tuple(bc[:,:,None]*direction + basepoint for bc in bcs)
 
-    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False):
+    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Computes the persistence on a line L defined by 
          - a basepoint (num_parameters,) array
@@ -2450,7 +2492,7 @@ cdef class _KSlicer_Matrix1_vine_f32:
         Warning: This is not parallelizable. Use `persitence_on_lines`.
         """
         self.push_to_line(basepoint,direction)
-        self.truc.compute_persistence()
+        self.truc.compute_persistence(ignore_infinite_filtration_values)
         if keep_inf:
             bcs = tuple(np.asarray(stuff, dtype = np.float32) for stuff in self.truc.get_barcode())
         else:
@@ -2460,7 +2502,7 @@ cdef class _KSlicer_Matrix1_vine_f32:
             bcs = _KSlicer_Matrix1_vine_f32._bc_to_full(bcs, basepoint, direction)
         return bcs
 
-    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False):
+    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Same as `persistence_on_line`, but with vineyards operation between
         lines if `self.is_vine`, and in parallel otherwise.
@@ -2471,11 +2513,11 @@ cdef class _KSlicer_Matrix1_vine_f32:
         if directions is None:
             c_basepoints = basepoints
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_basepoints)
+                c_out = self.truc.persistence_on_lines(c_basepoints, ignore_infinite_filtration_values)
         else:
             c_truc = zip(basepoints,directions)
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_truc)
+                c_out = self.truc.persistence_on_lines(c_truc, ignore_infinite_filtration_values)
         cdef int num_bc = c_basepoints.size()
         
         if keep_inf:
@@ -2788,6 +2830,13 @@ cdef class _KSlicer_Matrix0_vine_f64:
         self.truc = C_KSlicer_Matrix0_vine_f64(c_generator_maps,c_generator_dimensions, c_filtration_values)
         self.minpres_degree = -1
     
+    def to_colexical(self)->_KSlicer_Matrix0_vine_f64:
+        assert not self.is_squeezed, "Unsqueeze first"
+        new_slicer = _KSlicer_Matrix0_vine_f64()
+        new_slicer.truc = self.truc.colexical_rearange()
+        new_slicer.minpres_degree = self.minpres_degree
+        return new_slicer
+
     def copy(self)->_KSlicer_Matrix0_vine_f64:
         """
         Returns a copy of the slicer.
@@ -2831,7 +2880,7 @@ cdef class _KSlicer_Matrix0_vine_f64:
         direction = 1 if direction is None else np.asarray(direction)[None,None,:]
         return tuple(bc[:,:,None]*direction + basepoint for bc in bcs)
 
-    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False):
+    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Computes the persistence on a line L defined by 
          - a basepoint (num_parameters,) array
@@ -2840,7 +2889,7 @@ cdef class _KSlicer_Matrix0_vine_f64:
         Warning: This is not parallelizable. Use `persitence_on_lines`.
         """
         self.push_to_line(basepoint,direction)
-        self.truc.compute_persistence()
+        self.truc.compute_persistence(ignore_infinite_filtration_values)
         if keep_inf:
             bcs = tuple(np.asarray(stuff, dtype = np.float64) for stuff in self.truc.get_barcode())
         else:
@@ -2850,7 +2899,7 @@ cdef class _KSlicer_Matrix0_vine_f64:
             bcs = _KSlicer_Matrix0_vine_f64._bc_to_full(bcs, basepoint, direction)
         return bcs
 
-    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False):
+    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Same as `persistence_on_line`, but with vineyards operation between
         lines if `self.is_vine`, and in parallel otherwise.
@@ -2861,11 +2910,11 @@ cdef class _KSlicer_Matrix0_vine_f64:
         if directions is None:
             c_basepoints = basepoints
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_basepoints)
+                c_out = self.truc.persistence_on_lines(c_basepoints, ignore_infinite_filtration_values)
         else:
             c_truc = zip(basepoints,directions)
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_truc)
+                c_out = self.truc.persistence_on_lines(c_truc, ignore_infinite_filtration_values)
         cdef int num_bc = c_basepoints.size()
         
         if keep_inf:
@@ -3178,6 +3227,13 @@ cdef class _KSlicer_Matrix1_vine_f64:
         self.truc = C_KSlicer_Matrix1_vine_f64(c_generator_maps,c_generator_dimensions, c_filtration_values)
         self.minpres_degree = -1
     
+    def to_colexical(self)->_KSlicer_Matrix1_vine_f64:
+        assert not self.is_squeezed, "Unsqueeze first"
+        new_slicer = _KSlicer_Matrix1_vine_f64()
+        new_slicer.truc = self.truc.colexical_rearange()
+        new_slicer.minpres_degree = self.minpres_degree
+        return new_slicer
+
     def copy(self)->_KSlicer_Matrix1_vine_f64:
         """
         Returns a copy of the slicer.
@@ -3221,7 +3277,7 @@ cdef class _KSlicer_Matrix1_vine_f64:
         direction = 1 if direction is None else np.asarray(direction)[None,None,:]
         return tuple(bc[:,:,None]*direction + basepoint for bc in bcs)
 
-    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False):
+    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Computes the persistence on a line L defined by 
          - a basepoint (num_parameters,) array
@@ -3230,7 +3286,7 @@ cdef class _KSlicer_Matrix1_vine_f64:
         Warning: This is not parallelizable. Use `persitence_on_lines`.
         """
         self.push_to_line(basepoint,direction)
-        self.truc.compute_persistence()
+        self.truc.compute_persistence(ignore_infinite_filtration_values)
         if keep_inf:
             bcs = tuple(np.asarray(stuff, dtype = np.float64) for stuff in self.truc.get_barcode())
         else:
@@ -3240,7 +3296,7 @@ cdef class _KSlicer_Matrix1_vine_f64:
             bcs = _KSlicer_Matrix1_vine_f64._bc_to_full(bcs, basepoint, direction)
         return bcs
 
-    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False):
+    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Same as `persistence_on_line`, but with vineyards operation between
         lines if `self.is_vine`, and in parallel otherwise.
@@ -3251,11 +3307,11 @@ cdef class _KSlicer_Matrix1_vine_f64:
         if directions is None:
             c_basepoints = basepoints
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_basepoints)
+                c_out = self.truc.persistence_on_lines(c_basepoints, ignore_infinite_filtration_values)
         else:
             c_truc = zip(basepoints,directions)
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_truc)
+                c_out = self.truc.persistence_on_lines(c_truc, ignore_infinite_filtration_values)
         cdef int num_bc = c_basepoints.size()
         
         if keep_inf:
@@ -3559,6 +3615,13 @@ cdef class _Slicer_Matrix0_vine_i32:
         self.truc = C_Slicer_Matrix0_vine_i32(c_generator_maps,c_generator_dimensions, c_filtration_values)
         self.minpres_degree = -1
     
+    def to_colexical(self)->_Slicer_Matrix0_vine_i32:
+        assert not self.is_squeezed, "Unsqueeze first"
+        new_slicer = _Slicer_Matrix0_vine_i32()
+        new_slicer.truc = self.truc.colexical_rearange()
+        new_slicer.minpres_degree = self.minpres_degree
+        return new_slicer
+
     def copy(self)->_Slicer_Matrix0_vine_i32:
         """
         Returns a copy of the slicer.
@@ -3602,7 +3665,7 @@ cdef class _Slicer_Matrix0_vine_i32:
         direction = 1 if direction is None else np.asarray(direction)[None,None,:]
         return tuple(bc[:,:,None]*direction + basepoint for bc in bcs)
 
-    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False):
+    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Computes the persistence on a line L defined by 
          - a basepoint (num_parameters,) array
@@ -3611,7 +3674,7 @@ cdef class _Slicer_Matrix0_vine_i32:
         Warning: This is not parallelizable. Use `persitence_on_lines`.
         """
         self.push_to_line(basepoint,direction)
-        self.truc.compute_persistence()
+        self.truc.compute_persistence(ignore_infinite_filtration_values)
         if keep_inf:
             bcs = tuple(np.asarray(stuff, dtype = np.int32) for stuff in self.truc.get_barcode())
         else:
@@ -3621,7 +3684,7 @@ cdef class _Slicer_Matrix0_vine_i32:
             bcs = _Slicer_Matrix0_vine_i32._bc_to_full(bcs, basepoint, direction)
         return bcs
 
-    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False):
+    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Same as `persistence_on_line`, but with vineyards operation between
         lines if `self.is_vine`, and in parallel otherwise.
@@ -3632,11 +3695,11 @@ cdef class _Slicer_Matrix0_vine_i32:
         if directions is None:
             c_basepoints = basepoints
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_basepoints)
+                c_out = self.truc.persistence_on_lines(c_basepoints, ignore_infinite_filtration_values)
         else:
             c_truc = zip(basepoints,directions)
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_truc)
+                c_out = self.truc.persistence_on_lines(c_truc, ignore_infinite_filtration_values)
         cdef int num_bc = c_basepoints.size()
         
         if keep_inf:
@@ -3961,6 +4024,13 @@ cdef class _Slicer_Matrix1_vine_i32:
         self.truc = C_Slicer_Matrix1_vine_i32(c_generator_maps,c_generator_dimensions, c_filtration_values)
         self.minpres_degree = -1
     
+    def to_colexical(self)->_Slicer_Matrix1_vine_i32:
+        assert not self.is_squeezed, "Unsqueeze first"
+        new_slicer = _Slicer_Matrix1_vine_i32()
+        new_slicer.truc = self.truc.colexical_rearange()
+        new_slicer.minpres_degree = self.minpres_degree
+        return new_slicer
+
     def copy(self)->_Slicer_Matrix1_vine_i32:
         """
         Returns a copy of the slicer.
@@ -4004,7 +4074,7 @@ cdef class _Slicer_Matrix1_vine_i32:
         direction = 1 if direction is None else np.asarray(direction)[None,None,:]
         return tuple(bc[:,:,None]*direction + basepoint for bc in bcs)
 
-    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False):
+    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Computes the persistence on a line L defined by 
          - a basepoint (num_parameters,) array
@@ -4013,7 +4083,7 @@ cdef class _Slicer_Matrix1_vine_i32:
         Warning: This is not parallelizable. Use `persitence_on_lines`.
         """
         self.push_to_line(basepoint,direction)
-        self.truc.compute_persistence()
+        self.truc.compute_persistence(ignore_infinite_filtration_values)
         if keep_inf:
             bcs = tuple(np.asarray(stuff, dtype = np.int32) for stuff in self.truc.get_barcode())
         else:
@@ -4023,7 +4093,7 @@ cdef class _Slicer_Matrix1_vine_i32:
             bcs = _Slicer_Matrix1_vine_i32._bc_to_full(bcs, basepoint, direction)
         return bcs
 
-    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False):
+    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Same as `persistence_on_line`, but with vineyards operation between
         lines if `self.is_vine`, and in parallel otherwise.
@@ -4034,11 +4104,11 @@ cdef class _Slicer_Matrix1_vine_i32:
         if directions is None:
             c_basepoints = basepoints
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_basepoints)
+                c_out = self.truc.persistence_on_lines(c_basepoints, ignore_infinite_filtration_values)
         else:
             c_truc = zip(basepoints,directions)
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_truc)
+                c_out = self.truc.persistence_on_lines(c_truc, ignore_infinite_filtration_values)
         cdef int num_bc = c_basepoints.size()
         
         if keep_inf:
@@ -4363,6 +4433,13 @@ cdef class _Slicer_Matrix0_vine_i64:
         self.truc = C_Slicer_Matrix0_vine_i64(c_generator_maps,c_generator_dimensions, c_filtration_values)
         self.minpres_degree = -1
     
+    def to_colexical(self)->_Slicer_Matrix0_vine_i64:
+        assert not self.is_squeezed, "Unsqueeze first"
+        new_slicer = _Slicer_Matrix0_vine_i64()
+        new_slicer.truc = self.truc.colexical_rearange()
+        new_slicer.minpres_degree = self.minpres_degree
+        return new_slicer
+
     def copy(self)->_Slicer_Matrix0_vine_i64:
         """
         Returns a copy of the slicer.
@@ -4406,7 +4483,7 @@ cdef class _Slicer_Matrix0_vine_i64:
         direction = 1 if direction is None else np.asarray(direction)[None,None,:]
         return tuple(bc[:,:,None]*direction + basepoint for bc in bcs)
 
-    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False):
+    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Computes the persistence on a line L defined by 
          - a basepoint (num_parameters,) array
@@ -4415,7 +4492,7 @@ cdef class _Slicer_Matrix0_vine_i64:
         Warning: This is not parallelizable. Use `persitence_on_lines`.
         """
         self.push_to_line(basepoint,direction)
-        self.truc.compute_persistence()
+        self.truc.compute_persistence(ignore_infinite_filtration_values)
         if keep_inf:
             bcs = tuple(np.asarray(stuff, dtype = np.int64) for stuff in self.truc.get_barcode())
         else:
@@ -4425,7 +4502,7 @@ cdef class _Slicer_Matrix0_vine_i64:
             bcs = _Slicer_Matrix0_vine_i64._bc_to_full(bcs, basepoint, direction)
         return bcs
 
-    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False):
+    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Same as `persistence_on_line`, but with vineyards operation between
         lines if `self.is_vine`, and in parallel otherwise.
@@ -4436,11 +4513,11 @@ cdef class _Slicer_Matrix0_vine_i64:
         if directions is None:
             c_basepoints = basepoints
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_basepoints)
+                c_out = self.truc.persistence_on_lines(c_basepoints, ignore_infinite_filtration_values)
         else:
             c_truc = zip(basepoints,directions)
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_truc)
+                c_out = self.truc.persistence_on_lines(c_truc, ignore_infinite_filtration_values)
         cdef int num_bc = c_basepoints.size()
         
         if keep_inf:
@@ -4765,6 +4842,13 @@ cdef class _Slicer_Matrix1_vine_i64:
         self.truc = C_Slicer_Matrix1_vine_i64(c_generator_maps,c_generator_dimensions, c_filtration_values)
         self.minpres_degree = -1
     
+    def to_colexical(self)->_Slicer_Matrix1_vine_i64:
+        assert not self.is_squeezed, "Unsqueeze first"
+        new_slicer = _Slicer_Matrix1_vine_i64()
+        new_slicer.truc = self.truc.colexical_rearange()
+        new_slicer.minpres_degree = self.minpres_degree
+        return new_slicer
+
     def copy(self)->_Slicer_Matrix1_vine_i64:
         """
         Returns a copy of the slicer.
@@ -4808,7 +4892,7 @@ cdef class _Slicer_Matrix1_vine_i64:
         direction = 1 if direction is None else np.asarray(direction)[None,None,:]
         return tuple(bc[:,:,None]*direction + basepoint for bc in bcs)
 
-    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False):
+    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Computes the persistence on a line L defined by 
          - a basepoint (num_parameters,) array
@@ -4817,7 +4901,7 @@ cdef class _Slicer_Matrix1_vine_i64:
         Warning: This is not parallelizable. Use `persitence_on_lines`.
         """
         self.push_to_line(basepoint,direction)
-        self.truc.compute_persistence()
+        self.truc.compute_persistence(ignore_infinite_filtration_values)
         if keep_inf:
             bcs = tuple(np.asarray(stuff, dtype = np.int64) for stuff in self.truc.get_barcode())
         else:
@@ -4827,7 +4911,7 @@ cdef class _Slicer_Matrix1_vine_i64:
             bcs = _Slicer_Matrix1_vine_i64._bc_to_full(bcs, basepoint, direction)
         return bcs
 
-    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False):
+    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Same as `persistence_on_line`, but with vineyards operation between
         lines if `self.is_vine`, and in parallel otherwise.
@@ -4838,11 +4922,11 @@ cdef class _Slicer_Matrix1_vine_i64:
         if directions is None:
             c_basepoints = basepoints
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_basepoints)
+                c_out = self.truc.persistence_on_lines(c_basepoints, ignore_infinite_filtration_values)
         else:
             c_truc = zip(basepoints,directions)
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_truc)
+                c_out = self.truc.persistence_on_lines(c_truc, ignore_infinite_filtration_values)
         cdef int num_bc = c_basepoints.size()
         
         if keep_inf:
@@ -5167,6 +5251,13 @@ cdef class _Slicer_Matrix0_vine_f32:
         self.truc = C_Slicer_Matrix0_vine_f32(c_generator_maps,c_generator_dimensions, c_filtration_values)
         self.minpres_degree = -1
     
+    def to_colexical(self)->_Slicer_Matrix0_vine_f32:
+        assert not self.is_squeezed, "Unsqueeze first"
+        new_slicer = _Slicer_Matrix0_vine_f32()
+        new_slicer.truc = self.truc.colexical_rearange()
+        new_slicer.minpres_degree = self.minpres_degree
+        return new_slicer
+
     def copy(self)->_Slicer_Matrix0_vine_f32:
         """
         Returns a copy of the slicer.
@@ -5210,7 +5301,7 @@ cdef class _Slicer_Matrix0_vine_f32:
         direction = 1 if direction is None else np.asarray(direction)[None,None,:]
         return tuple(bc[:,:,None]*direction + basepoint for bc in bcs)
 
-    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False):
+    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Computes the persistence on a line L defined by 
          - a basepoint (num_parameters,) array
@@ -5219,7 +5310,7 @@ cdef class _Slicer_Matrix0_vine_f32:
         Warning: This is not parallelizable. Use `persitence_on_lines`.
         """
         self.push_to_line(basepoint,direction)
-        self.truc.compute_persistence()
+        self.truc.compute_persistence(ignore_infinite_filtration_values)
         if keep_inf:
             bcs = tuple(np.asarray(stuff, dtype = np.float32) for stuff in self.truc.get_barcode())
         else:
@@ -5229,7 +5320,7 @@ cdef class _Slicer_Matrix0_vine_f32:
             bcs = _Slicer_Matrix0_vine_f32._bc_to_full(bcs, basepoint, direction)
         return bcs
 
-    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False):
+    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Same as `persistence_on_line`, but with vineyards operation between
         lines if `self.is_vine`, and in parallel otherwise.
@@ -5240,11 +5331,11 @@ cdef class _Slicer_Matrix0_vine_f32:
         if directions is None:
             c_basepoints = basepoints
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_basepoints)
+                c_out = self.truc.persistence_on_lines(c_basepoints, ignore_infinite_filtration_values)
         else:
             c_truc = zip(basepoints,directions)
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_truc)
+                c_out = self.truc.persistence_on_lines(c_truc, ignore_infinite_filtration_values)
         cdef int num_bc = c_basepoints.size()
         
         if keep_inf:
@@ -5569,6 +5660,13 @@ cdef class _Slicer_Matrix1_vine_f32:
         self.truc = C_Slicer_Matrix1_vine_f32(c_generator_maps,c_generator_dimensions, c_filtration_values)
         self.minpres_degree = -1
     
+    def to_colexical(self)->_Slicer_Matrix1_vine_f32:
+        assert not self.is_squeezed, "Unsqueeze first"
+        new_slicer = _Slicer_Matrix1_vine_f32()
+        new_slicer.truc = self.truc.colexical_rearange()
+        new_slicer.minpres_degree = self.minpres_degree
+        return new_slicer
+
     def copy(self)->_Slicer_Matrix1_vine_f32:
         """
         Returns a copy of the slicer.
@@ -5612,7 +5710,7 @@ cdef class _Slicer_Matrix1_vine_f32:
         direction = 1 if direction is None else np.asarray(direction)[None,None,:]
         return tuple(bc[:,:,None]*direction + basepoint for bc in bcs)
 
-    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False):
+    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Computes the persistence on a line L defined by 
          - a basepoint (num_parameters,) array
@@ -5621,7 +5719,7 @@ cdef class _Slicer_Matrix1_vine_f32:
         Warning: This is not parallelizable. Use `persitence_on_lines`.
         """
         self.push_to_line(basepoint,direction)
-        self.truc.compute_persistence()
+        self.truc.compute_persistence(ignore_infinite_filtration_values)
         if keep_inf:
             bcs = tuple(np.asarray(stuff, dtype = np.float32) for stuff in self.truc.get_barcode())
         else:
@@ -5631,7 +5729,7 @@ cdef class _Slicer_Matrix1_vine_f32:
             bcs = _Slicer_Matrix1_vine_f32._bc_to_full(bcs, basepoint, direction)
         return bcs
 
-    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False):
+    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Same as `persistence_on_line`, but with vineyards operation between
         lines if `self.is_vine`, and in parallel otherwise.
@@ -5642,11 +5740,11 @@ cdef class _Slicer_Matrix1_vine_f32:
         if directions is None:
             c_basepoints = basepoints
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_basepoints)
+                c_out = self.truc.persistence_on_lines(c_basepoints, ignore_infinite_filtration_values)
         else:
             c_truc = zip(basepoints,directions)
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_truc)
+                c_out = self.truc.persistence_on_lines(c_truc, ignore_infinite_filtration_values)
         cdef int num_bc = c_basepoints.size()
         
         if keep_inf:
@@ -5971,6 +6069,13 @@ cdef class _Slicer_Matrix0_vine_f64:
         self.truc = C_Slicer_Matrix0_vine_f64(c_generator_maps,c_generator_dimensions, c_filtration_values)
         self.minpres_degree = -1
     
+    def to_colexical(self)->_Slicer_Matrix0_vine_f64:
+        assert not self.is_squeezed, "Unsqueeze first"
+        new_slicer = _Slicer_Matrix0_vine_f64()
+        new_slicer.truc = self.truc.colexical_rearange()
+        new_slicer.minpres_degree = self.minpres_degree
+        return new_slicer
+
     def copy(self)->_Slicer_Matrix0_vine_f64:
         """
         Returns a copy of the slicer.
@@ -6014,7 +6119,7 @@ cdef class _Slicer_Matrix0_vine_f64:
         direction = 1 if direction is None else np.asarray(direction)[None,None,:]
         return tuple(bc[:,:,None]*direction + basepoint for bc in bcs)
 
-    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False):
+    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Computes the persistence on a line L defined by 
          - a basepoint (num_parameters,) array
@@ -6023,7 +6128,7 @@ cdef class _Slicer_Matrix0_vine_f64:
         Warning: This is not parallelizable. Use `persitence_on_lines`.
         """
         self.push_to_line(basepoint,direction)
-        self.truc.compute_persistence()
+        self.truc.compute_persistence(ignore_infinite_filtration_values)
         if keep_inf:
             bcs = tuple(np.asarray(stuff, dtype = np.float64) for stuff in self.truc.get_barcode())
         else:
@@ -6033,7 +6138,7 @@ cdef class _Slicer_Matrix0_vine_f64:
             bcs = _Slicer_Matrix0_vine_f64._bc_to_full(bcs, basepoint, direction)
         return bcs
 
-    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False):
+    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Same as `persistence_on_line`, but with vineyards operation between
         lines if `self.is_vine`, and in parallel otherwise.
@@ -6044,11 +6149,11 @@ cdef class _Slicer_Matrix0_vine_f64:
         if directions is None:
             c_basepoints = basepoints
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_basepoints)
+                c_out = self.truc.persistence_on_lines(c_basepoints, ignore_infinite_filtration_values)
         else:
             c_truc = zip(basepoints,directions)
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_truc)
+                c_out = self.truc.persistence_on_lines(c_truc, ignore_infinite_filtration_values)
         cdef int num_bc = c_basepoints.size()
         
         if keep_inf:
@@ -6373,6 +6478,13 @@ cdef class _Slicer_Matrix1_vine_f64:
         self.truc = C_Slicer_Matrix1_vine_f64(c_generator_maps,c_generator_dimensions, c_filtration_values)
         self.minpres_degree = -1
     
+    def to_colexical(self)->_Slicer_Matrix1_vine_f64:
+        assert not self.is_squeezed, "Unsqueeze first"
+        new_slicer = _Slicer_Matrix1_vine_f64()
+        new_slicer.truc = self.truc.colexical_rearange()
+        new_slicer.minpres_degree = self.minpres_degree
+        return new_slicer
+
     def copy(self)->_Slicer_Matrix1_vine_f64:
         """
         Returns a copy of the slicer.
@@ -6416,7 +6528,7 @@ cdef class _Slicer_Matrix1_vine_f64:
         direction = 1 if direction is None else np.asarray(direction)[None,None,:]
         return tuple(bc[:,:,None]*direction + basepoint for bc in bcs)
 
-    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False):
+    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Computes the persistence on a line L defined by 
          - a basepoint (num_parameters,) array
@@ -6425,7 +6537,7 @@ cdef class _Slicer_Matrix1_vine_f64:
         Warning: This is not parallelizable. Use `persitence_on_lines`.
         """
         self.push_to_line(basepoint,direction)
-        self.truc.compute_persistence()
+        self.truc.compute_persistence(ignore_infinite_filtration_values)
         if keep_inf:
             bcs = tuple(np.asarray(stuff, dtype = np.float64) for stuff in self.truc.get_barcode())
         else:
@@ -6435,7 +6547,7 @@ cdef class _Slicer_Matrix1_vine_f64:
             bcs = _Slicer_Matrix1_vine_f64._bc_to_full(bcs, basepoint, direction)
         return bcs
 
-    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False):
+    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Same as `persistence_on_line`, but with vineyards operation between
         lines if `self.is_vine`, and in parallel otherwise.
@@ -6446,11 +6558,11 @@ cdef class _Slicer_Matrix1_vine_f64:
         if directions is None:
             c_basepoints = basepoints
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_basepoints)
+                c_out = self.truc.persistence_on_lines(c_basepoints, ignore_infinite_filtration_values)
         else:
             c_truc = zip(basepoints,directions)
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_truc)
+                c_out = self.truc.persistence_on_lines(c_truc, ignore_infinite_filtration_values)
         cdef int num_bc = c_basepoints.size()
         
         if keep_inf:
@@ -6784,6 +6896,13 @@ cdef class _KSlicer_Matrix0_i32:
         self.truc = C_KSlicer_Matrix0_i32(c_generator_maps,c_generator_dimensions, c_filtration_values)
         self.minpres_degree = -1
     
+    def to_colexical(self)->_KSlicer_Matrix0_i32:
+        assert not self.is_squeezed, "Unsqueeze first"
+        new_slicer = _KSlicer_Matrix0_i32()
+        new_slicer.truc = self.truc.colexical_rearange()
+        new_slicer.minpres_degree = self.minpres_degree
+        return new_slicer
+
     def copy(self)->_KSlicer_Matrix0_i32:
         """
         Returns a copy of the slicer.
@@ -6827,7 +6946,7 @@ cdef class _KSlicer_Matrix0_i32:
         direction = 1 if direction is None else np.asarray(direction)[None,None,:]
         return tuple(bc[:,:,None]*direction + basepoint for bc in bcs)
 
-    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False):
+    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Computes the persistence on a line L defined by 
          - a basepoint (num_parameters,) array
@@ -6836,7 +6955,7 @@ cdef class _KSlicer_Matrix0_i32:
         Warning: This is not parallelizable. Use `persitence_on_lines`.
         """
         self.push_to_line(basepoint,direction)
-        self.truc.compute_persistence()
+        self.truc.compute_persistence(ignore_infinite_filtration_values)
         if keep_inf:
             bcs = tuple(np.asarray(stuff, dtype = np.int32) for stuff in self.truc.get_barcode())
         else:
@@ -6846,7 +6965,7 @@ cdef class _KSlicer_Matrix0_i32:
             bcs = _KSlicer_Matrix0_i32._bc_to_full(bcs, basepoint, direction)
         return bcs
 
-    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False):
+    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Same as `persistence_on_line`, but with vineyards operation between
         lines if `self.is_vine`, and in parallel otherwise.
@@ -6857,11 +6976,11 @@ cdef class _KSlicer_Matrix0_i32:
         if directions is None:
             c_basepoints = basepoints
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_basepoints)
+                c_out = self.truc.persistence_on_lines(c_basepoints, ignore_infinite_filtration_values)
         else:
             c_truc = zip(basepoints,directions)
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_truc)
+                c_out = self.truc.persistence_on_lines(c_truc, ignore_infinite_filtration_values)
         cdef int num_bc = c_basepoints.size()
         
         if keep_inf:
@@ -7156,6 +7275,13 @@ cdef class _KSlicer_Matrix1_i32:
         self.truc = C_KSlicer_Matrix1_i32(c_generator_maps,c_generator_dimensions, c_filtration_values)
         self.minpres_degree = -1
     
+    def to_colexical(self)->_KSlicer_Matrix1_i32:
+        assert not self.is_squeezed, "Unsqueeze first"
+        new_slicer = _KSlicer_Matrix1_i32()
+        new_slicer.truc = self.truc.colexical_rearange()
+        new_slicer.minpres_degree = self.minpres_degree
+        return new_slicer
+
     def copy(self)->_KSlicer_Matrix1_i32:
         """
         Returns a copy of the slicer.
@@ -7199,7 +7325,7 @@ cdef class _KSlicer_Matrix1_i32:
         direction = 1 if direction is None else np.asarray(direction)[None,None,:]
         return tuple(bc[:,:,None]*direction + basepoint for bc in bcs)
 
-    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False):
+    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Computes the persistence on a line L defined by 
          - a basepoint (num_parameters,) array
@@ -7208,7 +7334,7 @@ cdef class _KSlicer_Matrix1_i32:
         Warning: This is not parallelizable. Use `persitence_on_lines`.
         """
         self.push_to_line(basepoint,direction)
-        self.truc.compute_persistence()
+        self.truc.compute_persistence(ignore_infinite_filtration_values)
         if keep_inf:
             bcs = tuple(np.asarray(stuff, dtype = np.int32) for stuff in self.truc.get_barcode())
         else:
@@ -7218,7 +7344,7 @@ cdef class _KSlicer_Matrix1_i32:
             bcs = _KSlicer_Matrix1_i32._bc_to_full(bcs, basepoint, direction)
         return bcs
 
-    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False):
+    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Same as `persistence_on_line`, but with vineyards operation between
         lines if `self.is_vine`, and in parallel otherwise.
@@ -7229,11 +7355,11 @@ cdef class _KSlicer_Matrix1_i32:
         if directions is None:
             c_basepoints = basepoints
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_basepoints)
+                c_out = self.truc.persistence_on_lines(c_basepoints, ignore_infinite_filtration_values)
         else:
             c_truc = zip(basepoints,directions)
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_truc)
+                c_out = self.truc.persistence_on_lines(c_truc, ignore_infinite_filtration_values)
         cdef int num_bc = c_basepoints.size()
         
         if keep_inf:
@@ -7528,6 +7654,13 @@ cdef class _KSlicer_Matrix0_i64:
         self.truc = C_KSlicer_Matrix0_i64(c_generator_maps,c_generator_dimensions, c_filtration_values)
         self.minpres_degree = -1
     
+    def to_colexical(self)->_KSlicer_Matrix0_i64:
+        assert not self.is_squeezed, "Unsqueeze first"
+        new_slicer = _KSlicer_Matrix0_i64()
+        new_slicer.truc = self.truc.colexical_rearange()
+        new_slicer.minpres_degree = self.minpres_degree
+        return new_slicer
+
     def copy(self)->_KSlicer_Matrix0_i64:
         """
         Returns a copy of the slicer.
@@ -7571,7 +7704,7 @@ cdef class _KSlicer_Matrix0_i64:
         direction = 1 if direction is None else np.asarray(direction)[None,None,:]
         return tuple(bc[:,:,None]*direction + basepoint for bc in bcs)
 
-    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False):
+    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Computes the persistence on a line L defined by 
          - a basepoint (num_parameters,) array
@@ -7580,7 +7713,7 @@ cdef class _KSlicer_Matrix0_i64:
         Warning: This is not parallelizable. Use `persitence_on_lines`.
         """
         self.push_to_line(basepoint,direction)
-        self.truc.compute_persistence()
+        self.truc.compute_persistence(ignore_infinite_filtration_values)
         if keep_inf:
             bcs = tuple(np.asarray(stuff, dtype = np.int64) for stuff in self.truc.get_barcode())
         else:
@@ -7590,7 +7723,7 @@ cdef class _KSlicer_Matrix0_i64:
             bcs = _KSlicer_Matrix0_i64._bc_to_full(bcs, basepoint, direction)
         return bcs
 
-    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False):
+    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Same as `persistence_on_line`, but with vineyards operation between
         lines if `self.is_vine`, and in parallel otherwise.
@@ -7601,11 +7734,11 @@ cdef class _KSlicer_Matrix0_i64:
         if directions is None:
             c_basepoints = basepoints
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_basepoints)
+                c_out = self.truc.persistence_on_lines(c_basepoints, ignore_infinite_filtration_values)
         else:
             c_truc = zip(basepoints,directions)
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_truc)
+                c_out = self.truc.persistence_on_lines(c_truc, ignore_infinite_filtration_values)
         cdef int num_bc = c_basepoints.size()
         
         if keep_inf:
@@ -7900,6 +8033,13 @@ cdef class _KSlicer_Matrix1_i64:
         self.truc = C_KSlicer_Matrix1_i64(c_generator_maps,c_generator_dimensions, c_filtration_values)
         self.minpres_degree = -1
     
+    def to_colexical(self)->_KSlicer_Matrix1_i64:
+        assert not self.is_squeezed, "Unsqueeze first"
+        new_slicer = _KSlicer_Matrix1_i64()
+        new_slicer.truc = self.truc.colexical_rearange()
+        new_slicer.minpres_degree = self.minpres_degree
+        return new_slicer
+
     def copy(self)->_KSlicer_Matrix1_i64:
         """
         Returns a copy of the slicer.
@@ -7943,7 +8083,7 @@ cdef class _KSlicer_Matrix1_i64:
         direction = 1 if direction is None else np.asarray(direction)[None,None,:]
         return tuple(bc[:,:,None]*direction + basepoint for bc in bcs)
 
-    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False):
+    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Computes the persistence on a line L defined by 
          - a basepoint (num_parameters,) array
@@ -7952,7 +8092,7 @@ cdef class _KSlicer_Matrix1_i64:
         Warning: This is not parallelizable. Use `persitence_on_lines`.
         """
         self.push_to_line(basepoint,direction)
-        self.truc.compute_persistence()
+        self.truc.compute_persistence(ignore_infinite_filtration_values)
         if keep_inf:
             bcs = tuple(np.asarray(stuff, dtype = np.int64) for stuff in self.truc.get_barcode())
         else:
@@ -7962,7 +8102,7 @@ cdef class _KSlicer_Matrix1_i64:
             bcs = _KSlicer_Matrix1_i64._bc_to_full(bcs, basepoint, direction)
         return bcs
 
-    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False):
+    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Same as `persistence_on_line`, but with vineyards operation between
         lines if `self.is_vine`, and in parallel otherwise.
@@ -7973,11 +8113,11 @@ cdef class _KSlicer_Matrix1_i64:
         if directions is None:
             c_basepoints = basepoints
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_basepoints)
+                c_out = self.truc.persistence_on_lines(c_basepoints, ignore_infinite_filtration_values)
         else:
             c_truc = zip(basepoints,directions)
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_truc)
+                c_out = self.truc.persistence_on_lines(c_truc, ignore_infinite_filtration_values)
         cdef int num_bc = c_basepoints.size()
         
         if keep_inf:
@@ -8272,6 +8412,13 @@ cdef class _KSlicer_Matrix0_f32:
         self.truc = C_KSlicer_Matrix0_f32(c_generator_maps,c_generator_dimensions, c_filtration_values)
         self.minpres_degree = -1
     
+    def to_colexical(self)->_KSlicer_Matrix0_f32:
+        assert not self.is_squeezed, "Unsqueeze first"
+        new_slicer = _KSlicer_Matrix0_f32()
+        new_slicer.truc = self.truc.colexical_rearange()
+        new_slicer.minpres_degree = self.minpres_degree
+        return new_slicer
+
     def copy(self)->_KSlicer_Matrix0_f32:
         """
         Returns a copy of the slicer.
@@ -8315,7 +8462,7 @@ cdef class _KSlicer_Matrix0_f32:
         direction = 1 if direction is None else np.asarray(direction)[None,None,:]
         return tuple(bc[:,:,None]*direction + basepoint for bc in bcs)
 
-    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False):
+    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Computes the persistence on a line L defined by 
          - a basepoint (num_parameters,) array
@@ -8324,7 +8471,7 @@ cdef class _KSlicer_Matrix0_f32:
         Warning: This is not parallelizable. Use `persitence_on_lines`.
         """
         self.push_to_line(basepoint,direction)
-        self.truc.compute_persistence()
+        self.truc.compute_persistence(ignore_infinite_filtration_values)
         if keep_inf:
             bcs = tuple(np.asarray(stuff, dtype = np.float32) for stuff in self.truc.get_barcode())
         else:
@@ -8334,7 +8481,7 @@ cdef class _KSlicer_Matrix0_f32:
             bcs = _KSlicer_Matrix0_f32._bc_to_full(bcs, basepoint, direction)
         return bcs
 
-    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False):
+    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Same as `persistence_on_line`, but with vineyards operation between
         lines if `self.is_vine`, and in parallel otherwise.
@@ -8345,11 +8492,11 @@ cdef class _KSlicer_Matrix0_f32:
         if directions is None:
             c_basepoints = basepoints
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_basepoints)
+                c_out = self.truc.persistence_on_lines(c_basepoints, ignore_infinite_filtration_values)
         else:
             c_truc = zip(basepoints,directions)
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_truc)
+                c_out = self.truc.persistence_on_lines(c_truc, ignore_infinite_filtration_values)
         cdef int num_bc = c_basepoints.size()
         
         if keep_inf:
@@ -8644,6 +8791,13 @@ cdef class _KSlicer_Matrix1_f32:
         self.truc = C_KSlicer_Matrix1_f32(c_generator_maps,c_generator_dimensions, c_filtration_values)
         self.minpres_degree = -1
     
+    def to_colexical(self)->_KSlicer_Matrix1_f32:
+        assert not self.is_squeezed, "Unsqueeze first"
+        new_slicer = _KSlicer_Matrix1_f32()
+        new_slicer.truc = self.truc.colexical_rearange()
+        new_slicer.minpres_degree = self.minpres_degree
+        return new_slicer
+
     def copy(self)->_KSlicer_Matrix1_f32:
         """
         Returns a copy of the slicer.
@@ -8687,7 +8841,7 @@ cdef class _KSlicer_Matrix1_f32:
         direction = 1 if direction is None else np.asarray(direction)[None,None,:]
         return tuple(bc[:,:,None]*direction + basepoint for bc in bcs)
 
-    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False):
+    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Computes the persistence on a line L defined by 
          - a basepoint (num_parameters,) array
@@ -8696,7 +8850,7 @@ cdef class _KSlicer_Matrix1_f32:
         Warning: This is not parallelizable. Use `persitence_on_lines`.
         """
         self.push_to_line(basepoint,direction)
-        self.truc.compute_persistence()
+        self.truc.compute_persistence(ignore_infinite_filtration_values)
         if keep_inf:
             bcs = tuple(np.asarray(stuff, dtype = np.float32) for stuff in self.truc.get_barcode())
         else:
@@ -8706,7 +8860,7 @@ cdef class _KSlicer_Matrix1_f32:
             bcs = _KSlicer_Matrix1_f32._bc_to_full(bcs, basepoint, direction)
         return bcs
 
-    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False):
+    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Same as `persistence_on_line`, but with vineyards operation between
         lines if `self.is_vine`, and in parallel otherwise.
@@ -8717,11 +8871,11 @@ cdef class _KSlicer_Matrix1_f32:
         if directions is None:
             c_basepoints = basepoints
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_basepoints)
+                c_out = self.truc.persistence_on_lines(c_basepoints, ignore_infinite_filtration_values)
         else:
             c_truc = zip(basepoints,directions)
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_truc)
+                c_out = self.truc.persistence_on_lines(c_truc, ignore_infinite_filtration_values)
         cdef int num_bc = c_basepoints.size()
         
         if keep_inf:
@@ -9016,6 +9170,13 @@ cdef class _KSlicer_Matrix0_f64:
         self.truc = C_KSlicer_Matrix0_f64(c_generator_maps,c_generator_dimensions, c_filtration_values)
         self.minpres_degree = -1
     
+    def to_colexical(self)->_KSlicer_Matrix0_f64:
+        assert not self.is_squeezed, "Unsqueeze first"
+        new_slicer = _KSlicer_Matrix0_f64()
+        new_slicer.truc = self.truc.colexical_rearange()
+        new_slicer.minpres_degree = self.minpres_degree
+        return new_slicer
+
     def copy(self)->_KSlicer_Matrix0_f64:
         """
         Returns a copy of the slicer.
@@ -9059,7 +9220,7 @@ cdef class _KSlicer_Matrix0_f64:
         direction = 1 if direction is None else np.asarray(direction)[None,None,:]
         return tuple(bc[:,:,None]*direction + basepoint for bc in bcs)
 
-    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False):
+    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Computes the persistence on a line L defined by 
          - a basepoint (num_parameters,) array
@@ -9068,7 +9229,7 @@ cdef class _KSlicer_Matrix0_f64:
         Warning: This is not parallelizable. Use `persitence_on_lines`.
         """
         self.push_to_line(basepoint,direction)
-        self.truc.compute_persistence()
+        self.truc.compute_persistence(ignore_infinite_filtration_values)
         if keep_inf:
             bcs = tuple(np.asarray(stuff, dtype = np.float64) for stuff in self.truc.get_barcode())
         else:
@@ -9078,7 +9239,7 @@ cdef class _KSlicer_Matrix0_f64:
             bcs = _KSlicer_Matrix0_f64._bc_to_full(bcs, basepoint, direction)
         return bcs
 
-    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False):
+    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Same as `persistence_on_line`, but with vineyards operation between
         lines if `self.is_vine`, and in parallel otherwise.
@@ -9089,11 +9250,11 @@ cdef class _KSlicer_Matrix0_f64:
         if directions is None:
             c_basepoints = basepoints
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_basepoints)
+                c_out = self.truc.persistence_on_lines(c_basepoints, ignore_infinite_filtration_values)
         else:
             c_truc = zip(basepoints,directions)
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_truc)
+                c_out = self.truc.persistence_on_lines(c_truc, ignore_infinite_filtration_values)
         cdef int num_bc = c_basepoints.size()
         
         if keep_inf:
@@ -9388,6 +9549,13 @@ cdef class _KSlicer_Matrix1_f64:
         self.truc = C_KSlicer_Matrix1_f64(c_generator_maps,c_generator_dimensions, c_filtration_values)
         self.minpres_degree = -1
     
+    def to_colexical(self)->_KSlicer_Matrix1_f64:
+        assert not self.is_squeezed, "Unsqueeze first"
+        new_slicer = _KSlicer_Matrix1_f64()
+        new_slicer.truc = self.truc.colexical_rearange()
+        new_slicer.minpres_degree = self.minpres_degree
+        return new_slicer
+
     def copy(self)->_KSlicer_Matrix1_f64:
         """
         Returns a copy of the slicer.
@@ -9431,7 +9599,7 @@ cdef class _KSlicer_Matrix1_f64:
         direction = 1 if direction is None else np.asarray(direction)[None,None,:]
         return tuple(bc[:,:,None]*direction + basepoint for bc in bcs)
 
-    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False):
+    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Computes the persistence on a line L defined by 
          - a basepoint (num_parameters,) array
@@ -9440,7 +9608,7 @@ cdef class _KSlicer_Matrix1_f64:
         Warning: This is not parallelizable. Use `persitence_on_lines`.
         """
         self.push_to_line(basepoint,direction)
-        self.truc.compute_persistence()
+        self.truc.compute_persistence(ignore_infinite_filtration_values)
         if keep_inf:
             bcs = tuple(np.asarray(stuff, dtype = np.float64) for stuff in self.truc.get_barcode())
         else:
@@ -9450,7 +9618,7 @@ cdef class _KSlicer_Matrix1_f64:
             bcs = _KSlicer_Matrix1_f64._bc_to_full(bcs, basepoint, direction)
         return bcs
 
-    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False):
+    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Same as `persistence_on_line`, but with vineyards operation between
         lines if `self.is_vine`, and in parallel otherwise.
@@ -9461,11 +9629,11 @@ cdef class _KSlicer_Matrix1_f64:
         if directions is None:
             c_basepoints = basepoints
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_basepoints)
+                c_out = self.truc.persistence_on_lines(c_basepoints, ignore_infinite_filtration_values)
         else:
             c_truc = zip(basepoints,directions)
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_truc)
+                c_out = self.truc.persistence_on_lines(c_truc, ignore_infinite_filtration_values)
         cdef int num_bc = c_basepoints.size()
         
         if keep_inf:
@@ -9751,6 +9919,13 @@ cdef class _Slicer_Matrix0_i32:
         self.truc = C_Slicer_Matrix0_i32(c_generator_maps,c_generator_dimensions, c_filtration_values)
         self.minpres_degree = -1
     
+    def to_colexical(self)->_Slicer_Matrix0_i32:
+        assert not self.is_squeezed, "Unsqueeze first"
+        new_slicer = _Slicer_Matrix0_i32()
+        new_slicer.truc = self.truc.colexical_rearange()
+        new_slicer.minpres_degree = self.minpres_degree
+        return new_slicer
+
     def copy(self)->_Slicer_Matrix0_i32:
         """
         Returns a copy of the slicer.
@@ -9794,7 +9969,7 @@ cdef class _Slicer_Matrix0_i32:
         direction = 1 if direction is None else np.asarray(direction)[None,None,:]
         return tuple(bc[:,:,None]*direction + basepoint for bc in bcs)
 
-    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False):
+    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Computes the persistence on a line L defined by 
          - a basepoint (num_parameters,) array
@@ -9803,7 +9978,7 @@ cdef class _Slicer_Matrix0_i32:
         Warning: This is not parallelizable. Use `persitence_on_lines`.
         """
         self.push_to_line(basepoint,direction)
-        self.truc.compute_persistence()
+        self.truc.compute_persistence(ignore_infinite_filtration_values)
         if keep_inf:
             bcs = tuple(np.asarray(stuff, dtype = np.int32) for stuff in self.truc.get_barcode())
         else:
@@ -9813,7 +9988,7 @@ cdef class _Slicer_Matrix0_i32:
             bcs = _Slicer_Matrix0_i32._bc_to_full(bcs, basepoint, direction)
         return bcs
 
-    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False):
+    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Same as `persistence_on_line`, but with vineyards operation between
         lines if `self.is_vine`, and in parallel otherwise.
@@ -9824,11 +9999,11 @@ cdef class _Slicer_Matrix0_i32:
         if directions is None:
             c_basepoints = basepoints
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_basepoints)
+                c_out = self.truc.persistence_on_lines(c_basepoints, ignore_infinite_filtration_values)
         else:
             c_truc = zip(basepoints,directions)
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_truc)
+                c_out = self.truc.persistence_on_lines(c_truc, ignore_infinite_filtration_values)
         cdef int num_bc = c_basepoints.size()
         
         if keep_inf:
@@ -10135,6 +10310,13 @@ cdef class _Slicer_Matrix1_i32:
         self.truc = C_Slicer_Matrix1_i32(c_generator_maps,c_generator_dimensions, c_filtration_values)
         self.minpres_degree = -1
     
+    def to_colexical(self)->_Slicer_Matrix1_i32:
+        assert not self.is_squeezed, "Unsqueeze first"
+        new_slicer = _Slicer_Matrix1_i32()
+        new_slicer.truc = self.truc.colexical_rearange()
+        new_slicer.minpres_degree = self.minpres_degree
+        return new_slicer
+
     def copy(self)->_Slicer_Matrix1_i32:
         """
         Returns a copy of the slicer.
@@ -10178,7 +10360,7 @@ cdef class _Slicer_Matrix1_i32:
         direction = 1 if direction is None else np.asarray(direction)[None,None,:]
         return tuple(bc[:,:,None]*direction + basepoint for bc in bcs)
 
-    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False):
+    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Computes the persistence on a line L defined by 
          - a basepoint (num_parameters,) array
@@ -10187,7 +10369,7 @@ cdef class _Slicer_Matrix1_i32:
         Warning: This is not parallelizable. Use `persitence_on_lines`.
         """
         self.push_to_line(basepoint,direction)
-        self.truc.compute_persistence()
+        self.truc.compute_persistence(ignore_infinite_filtration_values)
         if keep_inf:
             bcs = tuple(np.asarray(stuff, dtype = np.int32) for stuff in self.truc.get_barcode())
         else:
@@ -10197,7 +10379,7 @@ cdef class _Slicer_Matrix1_i32:
             bcs = _Slicer_Matrix1_i32._bc_to_full(bcs, basepoint, direction)
         return bcs
 
-    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False):
+    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Same as `persistence_on_line`, but with vineyards operation between
         lines if `self.is_vine`, and in parallel otherwise.
@@ -10208,11 +10390,11 @@ cdef class _Slicer_Matrix1_i32:
         if directions is None:
             c_basepoints = basepoints
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_basepoints)
+                c_out = self.truc.persistence_on_lines(c_basepoints, ignore_infinite_filtration_values)
         else:
             c_truc = zip(basepoints,directions)
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_truc)
+                c_out = self.truc.persistence_on_lines(c_truc, ignore_infinite_filtration_values)
         cdef int num_bc = c_basepoints.size()
         
         if keep_inf:
@@ -10519,6 +10701,13 @@ cdef class _Slicer_Matrix0_i64:
         self.truc = C_Slicer_Matrix0_i64(c_generator_maps,c_generator_dimensions, c_filtration_values)
         self.minpres_degree = -1
     
+    def to_colexical(self)->_Slicer_Matrix0_i64:
+        assert not self.is_squeezed, "Unsqueeze first"
+        new_slicer = _Slicer_Matrix0_i64()
+        new_slicer.truc = self.truc.colexical_rearange()
+        new_slicer.minpres_degree = self.minpres_degree
+        return new_slicer
+
     def copy(self)->_Slicer_Matrix0_i64:
         """
         Returns a copy of the slicer.
@@ -10562,7 +10751,7 @@ cdef class _Slicer_Matrix0_i64:
         direction = 1 if direction is None else np.asarray(direction)[None,None,:]
         return tuple(bc[:,:,None]*direction + basepoint for bc in bcs)
 
-    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False):
+    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Computes the persistence on a line L defined by 
          - a basepoint (num_parameters,) array
@@ -10571,7 +10760,7 @@ cdef class _Slicer_Matrix0_i64:
         Warning: This is not parallelizable. Use `persitence_on_lines`.
         """
         self.push_to_line(basepoint,direction)
-        self.truc.compute_persistence()
+        self.truc.compute_persistence(ignore_infinite_filtration_values)
         if keep_inf:
             bcs = tuple(np.asarray(stuff, dtype = np.int64) for stuff in self.truc.get_barcode())
         else:
@@ -10581,7 +10770,7 @@ cdef class _Slicer_Matrix0_i64:
             bcs = _Slicer_Matrix0_i64._bc_to_full(bcs, basepoint, direction)
         return bcs
 
-    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False):
+    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Same as `persistence_on_line`, but with vineyards operation between
         lines if `self.is_vine`, and in parallel otherwise.
@@ -10592,11 +10781,11 @@ cdef class _Slicer_Matrix0_i64:
         if directions is None:
             c_basepoints = basepoints
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_basepoints)
+                c_out = self.truc.persistence_on_lines(c_basepoints, ignore_infinite_filtration_values)
         else:
             c_truc = zip(basepoints,directions)
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_truc)
+                c_out = self.truc.persistence_on_lines(c_truc, ignore_infinite_filtration_values)
         cdef int num_bc = c_basepoints.size()
         
         if keep_inf:
@@ -10903,6 +11092,13 @@ cdef class _Slicer_Matrix1_i64:
         self.truc = C_Slicer_Matrix1_i64(c_generator_maps,c_generator_dimensions, c_filtration_values)
         self.minpres_degree = -1
     
+    def to_colexical(self)->_Slicer_Matrix1_i64:
+        assert not self.is_squeezed, "Unsqueeze first"
+        new_slicer = _Slicer_Matrix1_i64()
+        new_slicer.truc = self.truc.colexical_rearange()
+        new_slicer.minpres_degree = self.minpres_degree
+        return new_slicer
+
     def copy(self)->_Slicer_Matrix1_i64:
         """
         Returns a copy of the slicer.
@@ -10946,7 +11142,7 @@ cdef class _Slicer_Matrix1_i64:
         direction = 1 if direction is None else np.asarray(direction)[None,None,:]
         return tuple(bc[:,:,None]*direction + basepoint for bc in bcs)
 
-    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False):
+    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Computes the persistence on a line L defined by 
          - a basepoint (num_parameters,) array
@@ -10955,7 +11151,7 @@ cdef class _Slicer_Matrix1_i64:
         Warning: This is not parallelizable. Use `persitence_on_lines`.
         """
         self.push_to_line(basepoint,direction)
-        self.truc.compute_persistence()
+        self.truc.compute_persistence(ignore_infinite_filtration_values)
         if keep_inf:
             bcs = tuple(np.asarray(stuff, dtype = np.int64) for stuff in self.truc.get_barcode())
         else:
@@ -10965,7 +11161,7 @@ cdef class _Slicer_Matrix1_i64:
             bcs = _Slicer_Matrix1_i64._bc_to_full(bcs, basepoint, direction)
         return bcs
 
-    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False):
+    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Same as `persistence_on_line`, but with vineyards operation between
         lines if `self.is_vine`, and in parallel otherwise.
@@ -10976,11 +11172,11 @@ cdef class _Slicer_Matrix1_i64:
         if directions is None:
             c_basepoints = basepoints
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_basepoints)
+                c_out = self.truc.persistence_on_lines(c_basepoints, ignore_infinite_filtration_values)
         else:
             c_truc = zip(basepoints,directions)
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_truc)
+                c_out = self.truc.persistence_on_lines(c_truc, ignore_infinite_filtration_values)
         cdef int num_bc = c_basepoints.size()
         
         if keep_inf:
@@ -11287,6 +11483,13 @@ cdef class _Slicer_Matrix0_f32:
         self.truc = C_Slicer_Matrix0_f32(c_generator_maps,c_generator_dimensions, c_filtration_values)
         self.minpres_degree = -1
     
+    def to_colexical(self)->_Slicer_Matrix0_f32:
+        assert not self.is_squeezed, "Unsqueeze first"
+        new_slicer = _Slicer_Matrix0_f32()
+        new_slicer.truc = self.truc.colexical_rearange()
+        new_slicer.minpres_degree = self.minpres_degree
+        return new_slicer
+
     def copy(self)->_Slicer_Matrix0_f32:
         """
         Returns a copy of the slicer.
@@ -11330,7 +11533,7 @@ cdef class _Slicer_Matrix0_f32:
         direction = 1 if direction is None else np.asarray(direction)[None,None,:]
         return tuple(bc[:,:,None]*direction + basepoint for bc in bcs)
 
-    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False):
+    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Computes the persistence on a line L defined by 
          - a basepoint (num_parameters,) array
@@ -11339,7 +11542,7 @@ cdef class _Slicer_Matrix0_f32:
         Warning: This is not parallelizable. Use `persitence_on_lines`.
         """
         self.push_to_line(basepoint,direction)
-        self.truc.compute_persistence()
+        self.truc.compute_persistence(ignore_infinite_filtration_values)
         if keep_inf:
             bcs = tuple(np.asarray(stuff, dtype = np.float32) for stuff in self.truc.get_barcode())
         else:
@@ -11349,7 +11552,7 @@ cdef class _Slicer_Matrix0_f32:
             bcs = _Slicer_Matrix0_f32._bc_to_full(bcs, basepoint, direction)
         return bcs
 
-    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False):
+    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Same as `persistence_on_line`, but with vineyards operation between
         lines if `self.is_vine`, and in parallel otherwise.
@@ -11360,11 +11563,11 @@ cdef class _Slicer_Matrix0_f32:
         if directions is None:
             c_basepoints = basepoints
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_basepoints)
+                c_out = self.truc.persistence_on_lines(c_basepoints, ignore_infinite_filtration_values)
         else:
             c_truc = zip(basepoints,directions)
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_truc)
+                c_out = self.truc.persistence_on_lines(c_truc, ignore_infinite_filtration_values)
         cdef int num_bc = c_basepoints.size()
         
         if keep_inf:
@@ -11671,6 +11874,13 @@ cdef class _Slicer_Matrix1_f32:
         self.truc = C_Slicer_Matrix1_f32(c_generator_maps,c_generator_dimensions, c_filtration_values)
         self.minpres_degree = -1
     
+    def to_colexical(self)->_Slicer_Matrix1_f32:
+        assert not self.is_squeezed, "Unsqueeze first"
+        new_slicer = _Slicer_Matrix1_f32()
+        new_slicer.truc = self.truc.colexical_rearange()
+        new_slicer.minpres_degree = self.minpres_degree
+        return new_slicer
+
     def copy(self)->_Slicer_Matrix1_f32:
         """
         Returns a copy of the slicer.
@@ -11714,7 +11924,7 @@ cdef class _Slicer_Matrix1_f32:
         direction = 1 if direction is None else np.asarray(direction)[None,None,:]
         return tuple(bc[:,:,None]*direction + basepoint for bc in bcs)
 
-    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False):
+    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Computes the persistence on a line L defined by 
          - a basepoint (num_parameters,) array
@@ -11723,7 +11933,7 @@ cdef class _Slicer_Matrix1_f32:
         Warning: This is not parallelizable. Use `persitence_on_lines`.
         """
         self.push_to_line(basepoint,direction)
-        self.truc.compute_persistence()
+        self.truc.compute_persistence(ignore_infinite_filtration_values)
         if keep_inf:
             bcs = tuple(np.asarray(stuff, dtype = np.float32) for stuff in self.truc.get_barcode())
         else:
@@ -11733,7 +11943,7 @@ cdef class _Slicer_Matrix1_f32:
             bcs = _Slicer_Matrix1_f32._bc_to_full(bcs, basepoint, direction)
         return bcs
 
-    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False):
+    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Same as `persistence_on_line`, but with vineyards operation between
         lines if `self.is_vine`, and in parallel otherwise.
@@ -11744,11 +11954,11 @@ cdef class _Slicer_Matrix1_f32:
         if directions is None:
             c_basepoints = basepoints
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_basepoints)
+                c_out = self.truc.persistence_on_lines(c_basepoints, ignore_infinite_filtration_values)
         else:
             c_truc = zip(basepoints,directions)
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_truc)
+                c_out = self.truc.persistence_on_lines(c_truc, ignore_infinite_filtration_values)
         cdef int num_bc = c_basepoints.size()
         
         if keep_inf:
@@ -12055,6 +12265,13 @@ cdef class _Slicer_Matrix0_f64:
         self.truc = C_Slicer_Matrix0_f64(c_generator_maps,c_generator_dimensions, c_filtration_values)
         self.minpres_degree = -1
     
+    def to_colexical(self)->_Slicer_Matrix0_f64:
+        assert not self.is_squeezed, "Unsqueeze first"
+        new_slicer = _Slicer_Matrix0_f64()
+        new_slicer.truc = self.truc.colexical_rearange()
+        new_slicer.minpres_degree = self.minpres_degree
+        return new_slicer
+
     def copy(self)->_Slicer_Matrix0_f64:
         """
         Returns a copy of the slicer.
@@ -12098,7 +12315,7 @@ cdef class _Slicer_Matrix0_f64:
         direction = 1 if direction is None else np.asarray(direction)[None,None,:]
         return tuple(bc[:,:,None]*direction + basepoint for bc in bcs)
 
-    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False):
+    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Computes the persistence on a line L defined by 
          - a basepoint (num_parameters,) array
@@ -12107,7 +12324,7 @@ cdef class _Slicer_Matrix0_f64:
         Warning: This is not parallelizable. Use `persitence_on_lines`.
         """
         self.push_to_line(basepoint,direction)
-        self.truc.compute_persistence()
+        self.truc.compute_persistence(ignore_infinite_filtration_values)
         if keep_inf:
             bcs = tuple(np.asarray(stuff, dtype = np.float64) for stuff in self.truc.get_barcode())
         else:
@@ -12117,7 +12334,7 @@ cdef class _Slicer_Matrix0_f64:
             bcs = _Slicer_Matrix0_f64._bc_to_full(bcs, basepoint, direction)
         return bcs
 
-    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False):
+    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Same as `persistence_on_line`, but with vineyards operation between
         lines if `self.is_vine`, and in parallel otherwise.
@@ -12128,11 +12345,11 @@ cdef class _Slicer_Matrix0_f64:
         if directions is None:
             c_basepoints = basepoints
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_basepoints)
+                c_out = self.truc.persistence_on_lines(c_basepoints, ignore_infinite_filtration_values)
         else:
             c_truc = zip(basepoints,directions)
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_truc)
+                c_out = self.truc.persistence_on_lines(c_truc, ignore_infinite_filtration_values)
         cdef int num_bc = c_basepoints.size()
         
         if keep_inf:
@@ -12439,6 +12656,13 @@ cdef class _Slicer_Matrix1_f64:
         self.truc = C_Slicer_Matrix1_f64(c_generator_maps,c_generator_dimensions, c_filtration_values)
         self.minpres_degree = -1
     
+    def to_colexical(self)->_Slicer_Matrix1_f64:
+        assert not self.is_squeezed, "Unsqueeze first"
+        new_slicer = _Slicer_Matrix1_f64()
+        new_slicer.truc = self.truc.colexical_rearange()
+        new_slicer.minpres_degree = self.minpres_degree
+        return new_slicer
+
     def copy(self)->_Slicer_Matrix1_f64:
         """
         Returns a copy of the slicer.
@@ -12482,7 +12706,7 @@ cdef class _Slicer_Matrix1_f64:
         direction = 1 if direction is None else np.asarray(direction)[None,None,:]
         return tuple(bc[:,:,None]*direction + basepoint for bc in bcs)
 
-    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False):
+    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Computes the persistence on a line L defined by 
          - a basepoint (num_parameters,) array
@@ -12491,7 +12715,7 @@ cdef class _Slicer_Matrix1_f64:
         Warning: This is not parallelizable. Use `persitence_on_lines`.
         """
         self.push_to_line(basepoint,direction)
-        self.truc.compute_persistence()
+        self.truc.compute_persistence(ignore_infinite_filtration_values)
         if keep_inf:
             bcs = tuple(np.asarray(stuff, dtype = np.float64) for stuff in self.truc.get_barcode())
         else:
@@ -12501,7 +12725,7 @@ cdef class _Slicer_Matrix1_f64:
             bcs = _Slicer_Matrix1_f64._bc_to_full(bcs, basepoint, direction)
         return bcs
 
-    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False):
+    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Same as `persistence_on_line`, but with vineyards operation between
         lines if `self.is_vine`, and in parallel otherwise.
@@ -12512,11 +12736,11 @@ cdef class _Slicer_Matrix1_f64:
         if directions is None:
             c_basepoints = basepoints
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_basepoints)
+                c_out = self.truc.persistence_on_lines(c_basepoints, ignore_infinite_filtration_values)
         else:
             c_truc = zip(basepoints,directions)
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_truc)
+                c_out = self.truc.persistence_on_lines(c_truc, ignore_infinite_filtration_values)
         cdef int num_bc = c_basepoints.size()
         
         if keep_inf:
@@ -12832,6 +13056,13 @@ cdef class _KSlicer_GudhiCohomology0_i32:
         self.truc = C_KSlicer_GudhiCohomology0_i32(c_generator_maps,c_generator_dimensions, c_filtration_values)
         self.minpres_degree = -1
     
+    def to_colexical(self)->_KSlicer_GudhiCohomology0_i32:
+        assert not self.is_squeezed, "Unsqueeze first"
+        new_slicer = _KSlicer_GudhiCohomology0_i32()
+        new_slicer.truc = self.truc.colexical_rearange()
+        new_slicer.minpres_degree = self.minpres_degree
+        return new_slicer
+
     def copy(self)->_KSlicer_GudhiCohomology0_i32:
         """
         Returns a copy of the slicer.
@@ -12875,7 +13106,7 @@ cdef class _KSlicer_GudhiCohomology0_i32:
         direction = 1 if direction is None else np.asarray(direction)[None,None,:]
         return tuple(bc[:,:,None]*direction + basepoint for bc in bcs)
 
-    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False):
+    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Computes the persistence on a line L defined by 
          - a basepoint (num_parameters,) array
@@ -12884,7 +13115,7 @@ cdef class _KSlicer_GudhiCohomology0_i32:
         Warning: This is not parallelizable. Use `persitence_on_lines`.
         """
         self.push_to_line(basepoint,direction)
-        self.truc.compute_persistence()
+        self.truc.compute_persistence(ignore_infinite_filtration_values)
         if keep_inf:
             bcs = tuple(np.asarray(stuff, dtype = np.int32) for stuff in self.truc.get_barcode())
         else:
@@ -12894,7 +13125,7 @@ cdef class _KSlicer_GudhiCohomology0_i32:
             bcs = _KSlicer_GudhiCohomology0_i32._bc_to_full(bcs, basepoint, direction)
         return bcs
 
-    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False):
+    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Same as `persistence_on_line`, but with vineyards operation between
         lines if `self.is_vine`, and in parallel otherwise.
@@ -12905,11 +13136,11 @@ cdef class _KSlicer_GudhiCohomology0_i32:
         if directions is None:
             c_basepoints = basepoints
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_basepoints)
+                c_out = self.truc.persistence_on_lines(c_basepoints, ignore_infinite_filtration_values)
         else:
             c_truc = zip(basepoints,directions)
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_truc)
+                c_out = self.truc.persistence_on_lines(c_truc, ignore_infinite_filtration_values)
         cdef int num_bc = c_basepoints.size()
         
         if keep_inf:
@@ -13204,6 +13435,13 @@ cdef class _KSlicer_GudhiCohomology0_i64:
         self.truc = C_KSlicer_GudhiCohomology0_i64(c_generator_maps,c_generator_dimensions, c_filtration_values)
         self.minpres_degree = -1
     
+    def to_colexical(self)->_KSlicer_GudhiCohomology0_i64:
+        assert not self.is_squeezed, "Unsqueeze first"
+        new_slicer = _KSlicer_GudhiCohomology0_i64()
+        new_slicer.truc = self.truc.colexical_rearange()
+        new_slicer.minpres_degree = self.minpres_degree
+        return new_slicer
+
     def copy(self)->_KSlicer_GudhiCohomology0_i64:
         """
         Returns a copy of the slicer.
@@ -13247,7 +13485,7 @@ cdef class _KSlicer_GudhiCohomology0_i64:
         direction = 1 if direction is None else np.asarray(direction)[None,None,:]
         return tuple(bc[:,:,None]*direction + basepoint for bc in bcs)
 
-    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False):
+    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Computes the persistence on a line L defined by 
          - a basepoint (num_parameters,) array
@@ -13256,7 +13494,7 @@ cdef class _KSlicer_GudhiCohomology0_i64:
         Warning: This is not parallelizable. Use `persitence_on_lines`.
         """
         self.push_to_line(basepoint,direction)
-        self.truc.compute_persistence()
+        self.truc.compute_persistence(ignore_infinite_filtration_values)
         if keep_inf:
             bcs = tuple(np.asarray(stuff, dtype = np.int64) for stuff in self.truc.get_barcode())
         else:
@@ -13266,7 +13504,7 @@ cdef class _KSlicer_GudhiCohomology0_i64:
             bcs = _KSlicer_GudhiCohomology0_i64._bc_to_full(bcs, basepoint, direction)
         return bcs
 
-    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False):
+    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Same as `persistence_on_line`, but with vineyards operation between
         lines if `self.is_vine`, and in parallel otherwise.
@@ -13277,11 +13515,11 @@ cdef class _KSlicer_GudhiCohomology0_i64:
         if directions is None:
             c_basepoints = basepoints
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_basepoints)
+                c_out = self.truc.persistence_on_lines(c_basepoints, ignore_infinite_filtration_values)
         else:
             c_truc = zip(basepoints,directions)
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_truc)
+                c_out = self.truc.persistence_on_lines(c_truc, ignore_infinite_filtration_values)
         cdef int num_bc = c_basepoints.size()
         
         if keep_inf:
@@ -13576,6 +13814,13 @@ cdef class _KSlicer_GudhiCohomology0_f32:
         self.truc = C_KSlicer_GudhiCohomology0_f32(c_generator_maps,c_generator_dimensions, c_filtration_values)
         self.minpres_degree = -1
     
+    def to_colexical(self)->_KSlicer_GudhiCohomology0_f32:
+        assert not self.is_squeezed, "Unsqueeze first"
+        new_slicer = _KSlicer_GudhiCohomology0_f32()
+        new_slicer.truc = self.truc.colexical_rearange()
+        new_slicer.minpres_degree = self.minpres_degree
+        return new_slicer
+
     def copy(self)->_KSlicer_GudhiCohomology0_f32:
         """
         Returns a copy of the slicer.
@@ -13619,7 +13864,7 @@ cdef class _KSlicer_GudhiCohomology0_f32:
         direction = 1 if direction is None else np.asarray(direction)[None,None,:]
         return tuple(bc[:,:,None]*direction + basepoint for bc in bcs)
 
-    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False):
+    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Computes the persistence on a line L defined by 
          - a basepoint (num_parameters,) array
@@ -13628,7 +13873,7 @@ cdef class _KSlicer_GudhiCohomology0_f32:
         Warning: This is not parallelizable. Use `persitence_on_lines`.
         """
         self.push_to_line(basepoint,direction)
-        self.truc.compute_persistence()
+        self.truc.compute_persistence(ignore_infinite_filtration_values)
         if keep_inf:
             bcs = tuple(np.asarray(stuff, dtype = np.float32) for stuff in self.truc.get_barcode())
         else:
@@ -13638,7 +13883,7 @@ cdef class _KSlicer_GudhiCohomology0_f32:
             bcs = _KSlicer_GudhiCohomology0_f32._bc_to_full(bcs, basepoint, direction)
         return bcs
 
-    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False):
+    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Same as `persistence_on_line`, but with vineyards operation between
         lines if `self.is_vine`, and in parallel otherwise.
@@ -13649,11 +13894,11 @@ cdef class _KSlicer_GudhiCohomology0_f32:
         if directions is None:
             c_basepoints = basepoints
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_basepoints)
+                c_out = self.truc.persistence_on_lines(c_basepoints, ignore_infinite_filtration_values)
         else:
             c_truc = zip(basepoints,directions)
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_truc)
+                c_out = self.truc.persistence_on_lines(c_truc, ignore_infinite_filtration_values)
         cdef int num_bc = c_basepoints.size()
         
         if keep_inf:
@@ -13948,6 +14193,13 @@ cdef class _KSlicer_GudhiCohomology0_f64:
         self.truc = C_KSlicer_GudhiCohomology0_f64(c_generator_maps,c_generator_dimensions, c_filtration_values)
         self.minpres_degree = -1
     
+    def to_colexical(self)->_KSlicer_GudhiCohomology0_f64:
+        assert not self.is_squeezed, "Unsqueeze first"
+        new_slicer = _KSlicer_GudhiCohomology0_f64()
+        new_slicer.truc = self.truc.colexical_rearange()
+        new_slicer.minpres_degree = self.minpres_degree
+        return new_slicer
+
     def copy(self)->_KSlicer_GudhiCohomology0_f64:
         """
         Returns a copy of the slicer.
@@ -13991,7 +14243,7 @@ cdef class _KSlicer_GudhiCohomology0_f64:
         direction = 1 if direction is None else np.asarray(direction)[None,None,:]
         return tuple(bc[:,:,None]*direction + basepoint for bc in bcs)
 
-    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False):
+    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Computes the persistence on a line L defined by 
          - a basepoint (num_parameters,) array
@@ -14000,7 +14252,7 @@ cdef class _KSlicer_GudhiCohomology0_f64:
         Warning: This is not parallelizable. Use `persitence_on_lines`.
         """
         self.push_to_line(basepoint,direction)
-        self.truc.compute_persistence()
+        self.truc.compute_persistence(ignore_infinite_filtration_values)
         if keep_inf:
             bcs = tuple(np.asarray(stuff, dtype = np.float64) for stuff in self.truc.get_barcode())
         else:
@@ -14010,7 +14262,7 @@ cdef class _KSlicer_GudhiCohomology0_f64:
             bcs = _KSlicer_GudhiCohomology0_f64._bc_to_full(bcs, basepoint, direction)
         return bcs
 
-    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False):
+    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Same as `persistence_on_line`, but with vineyards operation between
         lines if `self.is_vine`, and in parallel otherwise.
@@ -14021,11 +14273,11 @@ cdef class _KSlicer_GudhiCohomology0_f64:
         if directions is None:
             c_basepoints = basepoints
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_basepoints)
+                c_out = self.truc.persistence_on_lines(c_basepoints, ignore_infinite_filtration_values)
         else:
             c_truc = zip(basepoints,directions)
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_truc)
+                c_out = self.truc.persistence_on_lines(c_truc, ignore_infinite_filtration_values)
         cdef int num_bc = c_basepoints.size()
         
         if keep_inf:
@@ -14311,6 +14563,13 @@ cdef class _Slicer_GudhiCohomology0_i32:
         self.truc = C_Slicer_GudhiCohomology0_i32(c_generator_maps,c_generator_dimensions, c_filtration_values)
         self.minpres_degree = -1
     
+    def to_colexical(self)->_Slicer_GudhiCohomology0_i32:
+        assert not self.is_squeezed, "Unsqueeze first"
+        new_slicer = _Slicer_GudhiCohomology0_i32()
+        new_slicer.truc = self.truc.colexical_rearange()
+        new_slicer.minpres_degree = self.minpres_degree
+        return new_slicer
+
     def copy(self)->_Slicer_GudhiCohomology0_i32:
         """
         Returns a copy of the slicer.
@@ -14354,7 +14613,7 @@ cdef class _Slicer_GudhiCohomology0_i32:
         direction = 1 if direction is None else np.asarray(direction)[None,None,:]
         return tuple(bc[:,:,None]*direction + basepoint for bc in bcs)
 
-    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False):
+    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Computes the persistence on a line L defined by 
          - a basepoint (num_parameters,) array
@@ -14363,7 +14622,7 @@ cdef class _Slicer_GudhiCohomology0_i32:
         Warning: This is not parallelizable. Use `persitence_on_lines`.
         """
         self.push_to_line(basepoint,direction)
-        self.truc.compute_persistence()
+        self.truc.compute_persistence(ignore_infinite_filtration_values)
         if keep_inf:
             bcs = tuple(np.asarray(stuff, dtype = np.int32) for stuff in self.truc.get_barcode())
         else:
@@ -14373,7 +14632,7 @@ cdef class _Slicer_GudhiCohomology0_i32:
             bcs = _Slicer_GudhiCohomology0_i32._bc_to_full(bcs, basepoint, direction)
         return bcs
 
-    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False):
+    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Same as `persistence_on_line`, but with vineyards operation between
         lines if `self.is_vine`, and in parallel otherwise.
@@ -14384,11 +14643,11 @@ cdef class _Slicer_GudhiCohomology0_i32:
         if directions is None:
             c_basepoints = basepoints
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_basepoints)
+                c_out = self.truc.persistence_on_lines(c_basepoints, ignore_infinite_filtration_values)
         else:
             c_truc = zip(basepoints,directions)
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_truc)
+                c_out = self.truc.persistence_on_lines(c_truc, ignore_infinite_filtration_values)
         cdef int num_bc = c_basepoints.size()
         
         if keep_inf:
@@ -14695,6 +14954,13 @@ cdef class _Slicer_GudhiCohomology0_i64:
         self.truc = C_Slicer_GudhiCohomology0_i64(c_generator_maps,c_generator_dimensions, c_filtration_values)
         self.minpres_degree = -1
     
+    def to_colexical(self)->_Slicer_GudhiCohomology0_i64:
+        assert not self.is_squeezed, "Unsqueeze first"
+        new_slicer = _Slicer_GudhiCohomology0_i64()
+        new_slicer.truc = self.truc.colexical_rearange()
+        new_slicer.minpres_degree = self.minpres_degree
+        return new_slicer
+
     def copy(self)->_Slicer_GudhiCohomology0_i64:
         """
         Returns a copy of the slicer.
@@ -14738,7 +15004,7 @@ cdef class _Slicer_GudhiCohomology0_i64:
         direction = 1 if direction is None else np.asarray(direction)[None,None,:]
         return tuple(bc[:,:,None]*direction + basepoint for bc in bcs)
 
-    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False):
+    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Computes the persistence on a line L defined by 
          - a basepoint (num_parameters,) array
@@ -14747,7 +15013,7 @@ cdef class _Slicer_GudhiCohomology0_i64:
         Warning: This is not parallelizable. Use `persitence_on_lines`.
         """
         self.push_to_line(basepoint,direction)
-        self.truc.compute_persistence()
+        self.truc.compute_persistence(ignore_infinite_filtration_values)
         if keep_inf:
             bcs = tuple(np.asarray(stuff, dtype = np.int64) for stuff in self.truc.get_barcode())
         else:
@@ -14757,7 +15023,7 @@ cdef class _Slicer_GudhiCohomology0_i64:
             bcs = _Slicer_GudhiCohomology0_i64._bc_to_full(bcs, basepoint, direction)
         return bcs
 
-    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False):
+    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Same as `persistence_on_line`, but with vineyards operation between
         lines if `self.is_vine`, and in parallel otherwise.
@@ -14768,11 +15034,11 @@ cdef class _Slicer_GudhiCohomology0_i64:
         if directions is None:
             c_basepoints = basepoints
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_basepoints)
+                c_out = self.truc.persistence_on_lines(c_basepoints, ignore_infinite_filtration_values)
         else:
             c_truc = zip(basepoints,directions)
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_truc)
+                c_out = self.truc.persistence_on_lines(c_truc, ignore_infinite_filtration_values)
         cdef int num_bc = c_basepoints.size()
         
         if keep_inf:
@@ -15079,6 +15345,13 @@ cdef class _Slicer_GudhiCohomology0_f32:
         self.truc = C_Slicer_GudhiCohomology0_f32(c_generator_maps,c_generator_dimensions, c_filtration_values)
         self.minpres_degree = -1
     
+    def to_colexical(self)->_Slicer_GudhiCohomology0_f32:
+        assert not self.is_squeezed, "Unsqueeze first"
+        new_slicer = _Slicer_GudhiCohomology0_f32()
+        new_slicer.truc = self.truc.colexical_rearange()
+        new_slicer.minpres_degree = self.minpres_degree
+        return new_slicer
+
     def copy(self)->_Slicer_GudhiCohomology0_f32:
         """
         Returns a copy of the slicer.
@@ -15122,7 +15395,7 @@ cdef class _Slicer_GudhiCohomology0_f32:
         direction = 1 if direction is None else np.asarray(direction)[None,None,:]
         return tuple(bc[:,:,None]*direction + basepoint for bc in bcs)
 
-    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False):
+    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Computes the persistence on a line L defined by 
          - a basepoint (num_parameters,) array
@@ -15131,7 +15404,7 @@ cdef class _Slicer_GudhiCohomology0_f32:
         Warning: This is not parallelizable. Use `persitence_on_lines`.
         """
         self.push_to_line(basepoint,direction)
-        self.truc.compute_persistence()
+        self.truc.compute_persistence(ignore_infinite_filtration_values)
         if keep_inf:
             bcs = tuple(np.asarray(stuff, dtype = np.float32) for stuff in self.truc.get_barcode())
         else:
@@ -15141,7 +15414,7 @@ cdef class _Slicer_GudhiCohomology0_f32:
             bcs = _Slicer_GudhiCohomology0_f32._bc_to_full(bcs, basepoint, direction)
         return bcs
 
-    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False):
+    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Same as `persistence_on_line`, but with vineyards operation between
         lines if `self.is_vine`, and in parallel otherwise.
@@ -15152,11 +15425,11 @@ cdef class _Slicer_GudhiCohomology0_f32:
         if directions is None:
             c_basepoints = basepoints
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_basepoints)
+                c_out = self.truc.persistence_on_lines(c_basepoints, ignore_infinite_filtration_values)
         else:
             c_truc = zip(basepoints,directions)
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_truc)
+                c_out = self.truc.persistence_on_lines(c_truc, ignore_infinite_filtration_values)
         cdef int num_bc = c_basepoints.size()
         
         if keep_inf:
@@ -15463,6 +15736,13 @@ cdef class _Slicer_GudhiCohomology0_f64:
         self.truc = C_Slicer_GudhiCohomology0_f64(c_generator_maps,c_generator_dimensions, c_filtration_values)
         self.minpres_degree = -1
     
+    def to_colexical(self)->_Slicer_GudhiCohomology0_f64:
+        assert not self.is_squeezed, "Unsqueeze first"
+        new_slicer = _Slicer_GudhiCohomology0_f64()
+        new_slicer.truc = self.truc.colexical_rearange()
+        new_slicer.minpres_degree = self.minpres_degree
+        return new_slicer
+
     def copy(self)->_Slicer_GudhiCohomology0_f64:
         """
         Returns a copy of the slicer.
@@ -15506,7 +15786,7 @@ cdef class _Slicer_GudhiCohomology0_f64:
         direction = 1 if direction is None else np.asarray(direction)[None,None,:]
         return tuple(bc[:,:,None]*direction + basepoint for bc in bcs)
 
-    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False):
+    def persistence_on_line(self,basepoint,direction=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Computes the persistence on a line L defined by 
          - a basepoint (num_parameters,) array
@@ -15515,7 +15795,7 @@ cdef class _Slicer_GudhiCohomology0_f64:
         Warning: This is not parallelizable. Use `persitence_on_lines`.
         """
         self.push_to_line(basepoint,direction)
-        self.truc.compute_persistence()
+        self.truc.compute_persistence(ignore_infinite_filtration_values)
         if keep_inf:
             bcs = tuple(np.asarray(stuff, dtype = np.float64) for stuff in self.truc.get_barcode())
         else:
@@ -15525,7 +15805,7 @@ cdef class _Slicer_GudhiCohomology0_f64:
             bcs = _Slicer_GudhiCohomology0_f64._bc_to_full(bcs, basepoint, direction)
         return bcs
 
-    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False):
+    def persistence_on_lines(self, basepoints=None, directions=None, bool keep_inf=True, bool full=False, bool ignore_infinite_filtration_values = True):
         """
         Same as `persistence_on_line`, but with vineyards operation between
         lines if `self.is_vine`, and in parallel otherwise.
@@ -15536,11 +15816,11 @@ cdef class _Slicer_GudhiCohomology0_f64:
         if directions is None:
             c_basepoints = basepoints
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_basepoints)
+                c_out = self.truc.persistence_on_lines(c_basepoints, ignore_infinite_filtration_values)
         else:
             c_truc = zip(basepoints,directions)
             with nogil:
-                c_out = self.truc.persistence_on_lines(c_truc)
+                c_out = self.truc.persistence_on_lines(c_truc, ignore_infinite_filtration_values)
         cdef int num_bc = c_basepoints.size()
         
         if keep_inf:
@@ -15851,9 +16131,9 @@ def from_function_delaunay(
     backend : slicer backend, e.g. "matrix", "clement"
     vineyard : bool, use a vineyard-compatible backend
     """
-    from multipers.io import _init_external_softwares, function_delaunay_presentation_to_slicer
+    from multipers.io import _check_available, function_delaunay_presentation_to_slicer
     s = multipers.Slicer(None, backend=backend, vineyard=vineyard, dtype=dtype)
-    _init_external_softwares(requires=["function_delaunay"])
+    assert _check_available("function_delaunay"), f"Could not find function_delaunay"
     function_delaunay_presentation_to_slicer(s, points, grades, degree=degree, verbose=verbose,clear=clear)
     if degree >= 0:
         s.minpres_degree = degree
@@ -15897,12 +16177,12 @@ def minimal_presentation(
     and returns it as a slicer.
     Backends differents than `mpfree` are unstable.
     """
-    from multipers.io import _init_external_softwares, input_path, scc_reduce_from_str_to_slicer
+    from multipers.io import _check_available, input_path, scc_reduce_from_str_to_slicer
     if is_slicer(slicer) and slicer.is_minpres and not force:
         from warnings import warn
         warn(f"The slicer seems to be already reduced, from homology of degree {slicer.minpres_degree}.")
         return slicer
-    _init_external_softwares(requires=[backend])
+    assert _check_available(backend), f"Backend {backend} is not available."
     if len(degrees)>0:
         def todo(int degree):
             return minimal_presentation(slicer, degree=degree, backend=backend, slicer_backend=slicer_backend, vineyard=vineyard, id=id, **minpres_kwargs)