multipers 2.3.0__cp310-cp310-win_amd64.whl → 2.3.2__cp310-cp310-win_amd64.whl

multipers/simplex_tree_multi.pyx.tp

@@ -66,7 +66,8 @@ cimport cython
 from gudhi.simplex_tree import SimplexTree ## Small hack for typing
 from typing import Iterable,Literal,Optional
 from tqdm import tqdm
-from multipers.grids import Lstrategies, compute_grid
+from multipers.grids import Lstrategies, compute_grid, sanitize_grid
+from multipers.array_api import api_from_tensor
 from multipers.point_measure import signed_betti, rank_decomposition_by_rectangles, sparsify
 
 from warnings import warn
@@ -98,15 +99,15 @@ cdef class SimplexTreeMulti_{{FSHORT}}:
     """
     cdef public intptr_t thisptr
 
-    cdef public vector[vector[double]] filtration_grid
-    cdef public bool _is_function_simplextree 
+    cdef public object filtration_grid
+    cdef public bool _is_function_simplextree  # TODO : deprecate
     # Get the pointer casted as it should be
     cdef Simplex_tree_multi_interface[{{FSHORT}}, {{CTYPE}}]* get_ptr(self) noexcept nogil:
         return <Simplex_tree_multi_interface[{{FSHORT}}, {{CTYPE}}]*>(self.thisptr)
 
     # cdef Simplex_tree_persistence_interface * pcohptr
     # Fake constructor that does nothing but documenting the constructor
-    def __init__(self, other = None, num_parameters:int=2,default_values=[], safe_conversion=False):
+    def __init__(self, other = None, num_parameters:int=-1,default_values=[], safe_conversion=False):
         """SimplexTreeMulti constructor.
 
         :param other: If `other` is `None` (default value), an empty `SimplexTreeMulti` is created.
@@ -139,7 +140,7 @@ cdef class SimplexTreeMulti_{{FSHORT}}:
     def is_kcritical(self)->bool:
       return {{is_kcritical}}
     # The real cython constructor
-    def __cinit__(self, other = None, int num_parameters=2, 
+    def __cinit__(self, other = None, int num_parameters=-1, 
                   default_values=np.asarray([SimplexTreeMulti_{{FSHORT}}.T_minus_inf()]), # I'm not sure why `[]` does not work. Cython bug ? 
                   bool safe_conversion=False,
                   ): #TODO doc
@@ -156,10 +157,13 @@ cdef class SimplexTreeMulti_{{FSHORT}}:
             if isinstance(other, SimplexTreeMulti_{{FSHORT}}):
                 other_ptr = other.thisptr
                 self.thisptr = <intptr_t>(new Simplex_tree_multi_interface[{{FSHORT}}, {{CTYPE}}](dereference(<Simplex_tree_multi_interface[{{FSHORT}}, {{CTYPE}}]*>other_ptr))) ## prevents calling destructor of other
-                num_parameters = other.num_parameters
+                if num_parameters <=0:
+                    num_parameters = other.num_parameters
                 self.filtration_grid = other.filtration_grid
             elif isinstance(other, SimplexTree): # Constructs a SimplexTreeMulti from a SimplexTree
                 self.thisptr = <intptr_t>(new Simplex_tree_multi_interface[{{FSHORT}}, {{CTYPE}}]())
+                if num_parameters <= 0:
+                    num_parameters = 1
                 if safe_conversion or SAFE_CONVERSION:
                     new_st_multi  = _safe_simplextree_multify_{{FSHORT}}(other, num_parameters = num_parameters, default_values=np.asarray(default_values))
                     self.thisptr, new_st_multi.thisptr = new_st_multi.thisptr, self.thisptr
@@ -174,10 +178,12 @@ cdef class SimplexTreeMulti_{{FSHORT}}:
             else:
                 raise TypeError("`other` argument requires to be of type `SimplexTree`, `SimplexTreeMulti`, or `None`.")
         else:
+            if num_parameters <=0:
+                num_parameters = 2 # I don't know how dangerous this is, but this is mostly used.
             self.thisptr = <intptr_t>(new Simplex_tree_multi_interface[{{FSHORT}}, {{CTYPE}}]())
-        self.get_ptr().set_number_of_parameters(num_parameters)
+        self.set_num_parameter(num_parameters)
         self._is_function_simplextree = False
-        self.filtration_grid=[[]*num_parameters]
+        self.filtration_grid=[]
 
     def __dealloc__(self):
         cdef Simplex_tree_multi_interface[{{FSHORT}},{{CTYPE}}]* ptr = self.get_ptr()
@@ -187,6 +193,9 @@ cdef class SimplexTreeMulti_{{FSHORT}}:
 
     def __repr__(self):
         return f"SimplexTreeMulti[dtype={np.dtype(self.dtype).name},num_param={self.num_parameters},kcritical={self.is_kcritical},is_squeezed={self.is_squeezed},max_dim={self.dimension}]" 
+    def __len__(self):
+        return self.num_simplices
+
     def __getstate__(self):
         """:returns: Serialized (or flattened) SimplexTree data structure in order to pickle SimplexTree.
         :rtype: numpy.array of shape (n,)
@@ -963,7 +972,16 @@ cdef class SimplexTreeMulti_{{FSHORT}}:
             out = self.get_ptr().get_edge_list()
         return out
 
-    def collapse_edges(self, int num=1, int max_dimension = 0, bool progress=False, bool strong=True, bool full=False, bool ignore_warning=False)->SimplexTreeMulti_{{FSHORT}}:
+    def collapse_edges(
+            self,
+            int num=1,
+            int max_dimension = 0,
+            bool progress=False,
+            bool strong=True,
+            bool full=False,
+            bool ignore_warning=False,
+            bool auto_clean=True,
+        )->SimplexTreeMulti_{{FSHORT}}:
         """Edge collapse for 1-critical 2-parameter clique complex (see https://arxiv.org/abs/2211.05574).
         It uses the code from the github repository https://github.com/aj-alonso/filtration_domination .
 
@@ -1013,6 +1031,8 @@ cdef class SimplexTreeMulti_{{FSHORT}}:
         edges = _collapse_edge_list(edges, num=num, full=full, strong=strong, progress=progress)
         # Retrieves the collapsed simplicial complex
         self._reconstruct_from_edge_list(edges, swap=True, expand_dimension=max_dimension)
+        if self.is_squeezed and auto_clean:
+            self._clean_filtration_grid()
         return self
 
     @cython.inline
@@ -1249,11 +1269,26 @@ cdef class SimplexTreeMulti_{{FSHORT}}:
             out = self.get_ptr().get_filtration_values(degrees)
         filtrations_values =  [np.asarray(filtration) for filtration in out]
         # Removes infs
-        if inf_to_nan:
+        if inf_to_nan and np.dtype(filtrations_values[0].dtype).kind == 'f':
             for i,f in enumerate(filtrations_values):
                 filtrations_values[i][f == np.inf] = np.nan
                 filtrations_values[i][f == - np.inf] = np.nan
         return filtrations_values
+    def _clean_filtration_grid(self):
+        """
+        Removes the values in filtration_grid that are not linked to any splx.
+        """
+        if not self.is_squeezed:
+            raise ValueError("No grid to clean.")
+        F = self.filtration_grid
+        self.filtration_grid=None
+        cleaned_coordinates = compute_grid(self)
+        new_st = self.grid_squeeze(cleaned_coordinates)
+
+        self.thisptr, new_st.thisptr = new_st.thisptr, self.thisptr
+        self.filtration_grid = tuple(f[g] for f,g in zip(F,cleaned_coordinates))
+        return self
+
 
 
     def get_filtration_grid(self, resolution:Iterable[int]|None=None, degrees:Iterable[int]|None=None, drop_quantiles:float|tuple=0, grid_strategy:_available_strategies="exact")->Iterable[np.ndarray]:
@@ -1289,8 +1324,16 @@ cdef class SimplexTreeMulti_{{FSHORT}}:
         return compute_grid(filtrations_values, resolution=resolution,strategy=grid_strategy,drop_quantiles=drop_quantiles)
 
 
-
-    def grid_squeeze(self, filtration_grid:np.ndarray|list|None=None, bool coordinate_values=True, force=False, grid_strategy:_available_strategies = "exact", inplace=False, **filtration_grid_kwargs):
+    def grid_squeeze(
+            self,
+            filtration_grid:np.ndarray|list|None=None,
+            bool coordinate_values=True,
+            bool force=False,
+            str strategy:_available_strategies = "exact",
+            grid_strategy=None,
+            bool inplace=False,
+            **filtration_grid_kwargs
+        )->SimplexTreeMulti_{{FSHORT[:-3] + "i32"}} | SimplexTreeMulti_{{FSHORT}}:
         """
         Fit the filtration of the simplextree to a grid.
 
@@ -1301,26 +1344,50 @@ cdef class SimplexTreeMulti_{{FSHORT}}:
         """
         if not force and self.is_squeezed:
             raise Exception("SimplexTree already squeezed, use `force=True` if that's really what you want to do.") 
+
+        if grid_strategy is not None:
+            warn("`grid_strategy` is deprecated, use `strategy` instead.",DeprecationWarning)
+            strategy=grid_strategy
+
+        if self.is_squeezed:
+            warn("(copy warning) Squeezing an already squeezed slicer.")
+            temp = self.unsqueeze()
+            subgrid = compute_grid(self.filtration_grid, strategy=strategy, resolution=resolution)
+            return temp.grid_squeeze(subgrid, coordinates=coordinates, inplace=inplace)
+
         #TODO : multi-critical
         if filtration_grid is None:  
-            filtration_grid = self.get_filtration_grid(grid_strategy=grid_strategy, **filtration_grid_kwargs)
-        cdef vector[vector[double]] c_filtration_grid = filtration_grid
-        assert <int>c_filtration_grid.size() == self.get_ptr().get_number_of_parameters(), f"Grid has to be of size {self.num_parameters}, got {filtration_grid.size()}"
-        cdef intptr_t ptr = self.thisptr
+            filtration_grid = self.get_filtration_grid(grid_strategy=strategy, **filtration_grid_kwargs)
+        else:
+            filtration_grid = sanitize_grid(filtration_grid)
+            if len(filtration_grid) != self.num_parameters:
+                raise ValueError(f"Invalid grid to squeeze onto. Got {len(filtration_grid)=} != {self.num_parameters=}.")
+        api = api_from_tensor(filtration_grid[0])
+        cdef vector[vector[double]] c_filtration_grid = tuple(api.asnumpy(f).astype(np.float64) for f in filtration_grid) # may be faster with loop on views
         if coordinate_values and inplace:
-            self.filtration_grid = c_filtration_grid
+            self.filtration_grid = filtration_grid
         if inplace or not coordinate_values:
           self.get_ptr().squeeze_filtration_inplace(c_filtration_grid, coordinate_values)
         else:
           out = SimplexTreeMulti_{{FSHORT[:-3] + "i32"}}(num_parameters=self.num_parameters)
           self.get_ptr().squeeze_filtration(out.thisptr, c_filtration_grid)
-          out.filtration_grid = c_filtration_grid
+          out.filtration_grid = filtration_grid
           return out
         return self
 
+    def unsqueeze(self, grid=None)->SimplexTreeMulti_{{FSHORT[:-3] + "f64"}}:
+        from multipers.grids import sanitize_grid
+        grid = self.filtration_grid if grid is None else grid
+
+        cdef vector[vector[double]] cgrid = sanitize_grid(grid, numpyfy=True)
+        new_slicer = SimplexTreeMulti_{{FSHORT[:-3] + "f64"}}()
+        new_slicer.get_ptr().unsqueeze_filtration(self.thisptr, cgrid)
+
+        return new_slicer
+
     @property
     def is_squeezed(self)->bool:
-        return self.num_vertices > 0 and len(self.filtration_grid)>0 and len(self.filtration_grid[0]) > 0
+        return self.num_vertices > 0 and self.filtration_grid is not None and len(self.filtration_grid)>0 and len(self.filtration_grid[0]) > 0
 
     @property
     def dtype(self)->type:
@@ -1632,7 +1699,7 @@ def is_simplextree_multi(input)->bool:
 
 
 
-def SimplexTreeMulti(input=None, int num_parameters=2, dtype:type = np.float64, bool kcritical = False,**kwargs) ->  SimplexTreeMulti_type:
+def SimplexTreeMulti(input=None, int num_parameters=-1, dtype:type = np.float64, bool kcritical = False,**kwargs) ->  SimplexTreeMulti_type:
     """SimplexTreeMulti constructor.
 
     :param other: If `other` is `None` (default value), an empty `SimplexTreeMulti` is created.
@@ -1804,7 +1871,8 @@ def _euler_signed_measure(simplextree, mass_default=None, bool verbose=False):
   `[signed_measure_of_degree for degree in degrees]`
   with `signed_measure_of_degree` of the form `(dirac location, dirac weights)`.
   """
-  assert len(simplextree.filtration_grid[0]) > 0, "Squeeze grid first."
+  if not simplextree.is_squeezed:
+      raise ValueError("Squeeze grid first.")
   cdef bool zero_pad = mass_default is not None
   # assert simplextree.num_parameters == 2
   grid_shape = np.array([len(f) for f in simplextree.filtration_grid])
@@ -1898,9 +1966,9 @@ def _rank_signed_measure(simplextree, vector[indices_type] degrees, mass_default
     else:
         mass_default = np.asarray(mass_default)
         assert mass_default.ndim == 1 and mass_default.shape[0] == simplextree.num_parameters, "Mass default has to be an array like of shape (num_parameters,)"
-    if zero_pad:
-        for i, _ in enumerate(grid_shape):
-            grid_shape[i] += 1 # adds a 0
+    # if zero_pad:
+    #     for i, _ in enumerate(grid_shape):
+    #         grid_shape[i] += 1 # adds a 0
         # grid_conversion = tuple(np.concatenate([f, [mass_default[i]]]) for i,f in enumerate(grid_conversion))
 
     assert len(grid_shape) == simplextree.num_parameters, "Grid shape size has to be the number of parameters."