multipers 2.4.0b1__cp312-cp312-macosx_11_0_arm64.whl

multipers/multiparameter_module_approximation.pyx

@@ -0,0 +1,286 @@
+"""!
+@package mma
+@brief Files containing the C++ cythonized functions.
+@author David Loiseaux
+@copyright Copyright (c) 2022 Inria.
+"""
+
+# distutils: language = c++
+
+###########################################################################
+## PYTHON LIBRARIES
+import gudhi as gd
+import numpy as np
+from typing import List
+from joblib import Parallel, delayed
+import sys
+from warnings import warn
+
+###########################################################################
+## CPP CLASSES
+from libc.stdint cimport intptr_t
+from libc.stdint cimport uintptr_t
+
+###########################################################################
+## CYTHON TYPES
+from libcpp.vector cimport vector
+from libcpp.utility cimport pair
+#from libcpp.list cimport list as clist
+from libcpp cimport bool
+from libcpp cimport int
+from typing import Iterable,Optional, Literal
+from cython.operator import dereference
+#########################################################################
+## Multipersistence Module Approximation Classes
+from multipers.mma_structures cimport *
+from multipers.filtrations cimport *
+from multipers.filtration_conversions cimport *
+cimport numpy as cnp
+
+
+#########################################################################
+## Small hack for typing
+from multipers.simplex_tree_multi import is_simplextree_multi, SimplexTreeMulti_type
+from multipers.slicer import Slicer_type, is_slicer
+from multipers.mma_structures import *
+from multipers.mma_structures import PyModule_type
+from typing import Union
+from multipers.slicer cimport _multiparameter_module_approximation_f32, _multiparameter_module_approximation_f64
+
+
+
+def module_approximation_from_slicer(
+        slicer:Slicer_type,
+        box:Optional[np.ndarray]=None,
+        max_error=-1,
+        bool complete=True,
+        bool threshold=False,
+        bool verbose=False,
+        list[float] direction = [],
+        bool warnings = True,
+        unsqueeze_grid = None,
+        )->PyModule_type:
+
+    cdef Module[float] mod_f32
+    cdef Module[double] mod_f64
+    cdef intptr_t ptr
+    if not slicer.is_vine:
+        if warnings:
+            warn(r"(copy warning) Got a non-vine slicer as an input. Use `vineyard=True` to remove this copy.")
+        from multipers._slicer_meta import Slicer
+        slicer = Slicer(slicer, vineyard=True, backend="matrix")
+    # if slicer.is_squeezed and unsqueeze_grid not None:
+    #     raise ValueError("Got a squeezed slicer. Should have been unsqueezed before !")
+
+    direction_ = np.asarray(direction, dtype=slicer.dtype)
+    if slicer.dtype == np.float32:
+        approx_mod = PyModule_f32()
+        if box is None:
+            box = slicer.filtration_bounds()
+        mod_f32 = _multiparameter_module_approximation_f32(slicer,_py2p_f32(direction_), max_error,Box[float](box),threshold, complete, verbose)
+        ptr = <intptr_t>(&mod_f32)
+    elif slicer.dtype == np.float64:
+        approx_mod = PyModule_f64()
+        if box is None:
+            box = slicer.filtration_bounds()
+        mod_f64 = _multiparameter_module_approximation_f64(slicer,_py2p_f64(direction_), max_error,Box[double](box),threshold, complete, verbose)
+        ptr = <intptr_t>(&mod_f64)
+    else:
+        raise ValueError(f"Slicer must be float-like. Got {slicer.dtype}.")
+
+    approx_mod._set_from_ptr(ptr)
+
+    if unsqueeze_grid is not None:
+        if verbose:
+            print("Reevaluating module in filtration grid...",end="", flush=True)
+        approx_mod.evaluate_in_grid(unsqueeze_grid)
+        from multipers.grids import compute_bounding_box
+        if len(approx_mod):
+            approx_mod.set_box(compute_bounding_box(approx_mod))
+        if verbose:
+            print("Done.",flush=True)
+
+    return approx_mod
+
+def module_approximation(
+        input:Union[SimplexTreeMulti_type,Slicer_type, tuple],
+        box:Optional[np.ndarray]=None,
+        double max_error=-1, 
+        int nlines=557,
+        bool from_coordinates = False,
+        bool complete=True, 
+        bool threshold=False, 
+        bool verbose=False,
+        bool ignore_warnings=False,
+        vector[double] direction = [],
+        vector[int] swap_box_coords = [],
+        *,
+        int n_jobs = -1,
+        )->PyModule_type:
+    """Computes an interval module approximation of a multiparameter filtration.
+
+    Parameters
+    ----------
+    input: SimplexTreeMulti or Slicer-like.
+        Holds the multifiltered complex.
+    max_error: positive float
+        Trade-off between approximation and computational complexity.
+        Upper bound of the module approximation, in bottleneck distance, 
+        for interval-decomposable modules.
+    nlines: int = 557
+        Alternative to max_error;
+        specifies the number of persistence computation used for the approximation.
+    box : (Optional) pair of list of floats
+        Defines a rectangle on which to compute the approximation.
+        Format : [x,y], This defines a rectangle on which we draw the lines,
+        uniformly drawn (with a max_error step).
+        The first line is `x`. 
+        **Warning**: For custom boxes, and directions, you **must** ensure
+        that the first line captures a generic barcode.
+    direction: float[:] = []
+        If given, the line are drawn with this angle.
+        **Warning**: You must ensure that the first line, defined by box,
+        captures a generic barcode.
+    threshold: bool
+        When true, intersects the module support with the box,
+        i.e. no more infinite summands.
+    verbose: bool
+        Prints C++ infos.
+    ignore_warning : bool
+        Unless set to true, prevents computing on more than 10k lines. 
+        Useful to prevent a segmentation fault due to "infinite" recursion.
+    Returns
+    -------
+    PyModule
+        An interval decomposable module approximation of the module defined by the
+        homology of this multi-filtration.
+    """
+    if isinstance(input, tuple) or isinstance(input, list):
+        
+        assert all(is_slicer(s) and (s.is_minpres or len(s)==0) for s in input), "Modules cannot be merged unless they are minimal presentations."
+        
+        assert (np.unique([s.minpres_degree for s in input if len(s)], return_counts=True)[1] <=1).all(), "Multiple modules are at the same degree, cannot merge modules" 
+        if len(input) == 0:
+            return PyModule_f64()
+        modules = tuple(Parallel(n_jobs=n_jobs, prefer="threads")(
+            delayed(module_approximation)(
+                input=slicer,
+                box=box,
+                max_error=max_error,
+                nlines=nlines,
+                from_coordinates=from_coordinates,
+                complete=complete,
+                threshold=threshold,
+                verbose=verbose,
+                ignore_warnings=ignore_warnings,
+                direction=direction,
+                swap_box_coords=swap_box_coords,
+            )
+            for slicer in input
+        ))
+        box = np.array([
+            np.min([m.get_box()[0] for m in modules if len(m)], axis=0),
+            np.max([m.get_box()[1] for m in modules if len(m)], axis=0),
+        ])
+        mod = PyModule_f64().set_box(box)
+        for i,m in enumerate(modules):
+            mod.merge(m, input[i].minpres_degree)
+        return mod
+    if len(input) == 0:
+        if verbose:
+            print("Empty input, returning the trivial module.")
+        return PyModule_f64()
+
+
+    cdef bool is_degenerate=False
+    for i in range(direction.size()):
+        if direction[i]<0:
+            raise ValueError(f"Got an invalid negative direction. {direction=}")
+        if direction[i] == 0:
+            is_degenerate=True
+    if is_degenerate and not ignore_warnings:
+        warn("Got a degenerate direction. This function may fail if the first line is not generic.")
+
+    if from_coordinates and not input.is_squeezed:
+        input = input.grid_squeeze()
+    unsqueeze_grid = None
+    if input.is_squeezed:
+        if not ignore_warnings:
+            warn("(copy warning) Got a squeezed input. ")
+        if verbose:
+            print("Preparing filtration (unsqueeze)... ",end="", flush=True)
+        if from_coordinates:
+            from multipers.grids import sanitize_grid
+            unsqueeze_grid = sanitize_grid(input.filtration_grid, numpyfy=True, add_inf=True)
+            input = input.astype(dtype=np.float64)
+            if direction.size() == 0:
+                _direction = np.asarray([1/g.size for g in unsqueeze_grid], dtype=np.float64)
+                _direction /= np.sqrt((_direction**2).sum())
+                direction = _direction
+            if verbose:
+                print(f"Updated  `{direction=}`, and `{max_error=}` ",end="")
+
+        else:
+            input = input.unsqueeze()
+        if verbose:
+            print("Done.", flush=True)
+
+
+
+    if box is None:
+        if verbose:
+            print("No box given. Using filtration bounds to infer it.")
+        box = input.filtration_bounds()
+        if verbose:
+            print(f"Using {box=}.",flush=True)
+
+    box = np.asarray(box)
+    if box.ndim !=2:
+        raise ValueError(f"Invalid box dimension. Got {box.ndim=} != 2")
+    # empty coords
+    zero_idx = box[1] == box[0]
+    if np.any(zero_idx):
+        if not ignore_warnings:
+            warn(f"Got {(box[1] == box[0])=} trivial box coordinates.")
+        box[1] += zero_idx
+
+    for i in swap_box_coords:
+        box[[0,1],i] = box[[1,0],i]
+    num_parameters = box.shape[1]
+    if num_parameters <=0:
+        num_parameters = box.shape[1]
+    assert direction.size() == 0 or direction.size() == box[0].size, f"Invalid line direction size, has to be 0 or {num_parameters=}"
+
+    prod = sum(np.abs(box[1] - box[0])[:i].prod() * np.abs(box[1] - box[0])[i+1:].prod() for i in range(0,num_parameters) if (direction.size() ==0 or direction[i]!=0))
+
+    if max_error <= 0:
+        max_error = (prod/nlines)**(1/(num_parameters-1))
+
+    estimated_nlines = prod/(max_error**(num_parameters -1))
+    if not ignore_warnings and estimated_nlines >= 10_000:
+        raise ValueError(f"""
+Warning : the number of lines (around {np.round(estimated_nlines)}) may be too high. 
+This may be due to extreme box or filtration bounds :
+
+{box=}
+
+Try to increase the precision parameter, or set `ignore_warnings=True` to compute this module. 
+Returning the trivial module.
+"""
+        )
+    if is_simplextree_multi(input):
+        from multipers._slicer_meta import Slicer
+        input = Slicer(input,backend="matrix", vineyard=True)
+    if not is_slicer(input):
+        raise ValueError("First argument must be a simplextree or a slicer !")
+    return module_approximation_from_slicer(
+            slicer=input,
+            box=box,
+            max_error=max_error,
+            complete=complete,
+            threshold=threshold,
+            verbose=verbose,
+            direction=direction,
+            unsqueeze_grid=unsqueeze_grid,
+            )
+

multipers/ops.pyx

@@ -0,0 +1,231 @@
+import cython
+from multipers.vector_interface cimport *
+import numpy as np
+import multipers as mp
+
+@cython.boundscheck(False)
+@cython.wraparound(False) 
+cdef vector[pair[double, double]] array_view_to_vect_pair(double[:, :] arr_view) noexcept nogil:
+    cdef int n = arr_view.shape[0]
+    cdef vector[pair[double, double]] result_vector
+    result_vector.resize(n)
+    for i in range(n):
+        result_vector[i] = pair[double, double](arr_view[i, 0], arr_view[i, 1])
+    return result_vector
+
+def _aida(col_degrees, row_degrees, matrix):
+  cdef multipers_interface_input stuff = multipers_interface_input(col_degrees, row_degrees, matrix)
+  cdef AIDA_functor truc 
+  truc.config.show_info = True
+  truc.config.sort_output = True
+  truc.config.sort = True
+  cdef multipers_interface_output stuff2 = truc.multipers_interface(stuff)
+  out = []
+  for i in range(stuff2.summands.size()):
+    out.append((stuff2.summands[i].col_degrees, stuff2.summands[i].row_degrees, stuff2.summands[i].matrix))
+  return out
+
+def aida(s, bool sort=True, bool verbose=False, bool progress = False):
+    """
+    Decomposes (a minimal presentation of a) 2-parameter persistence module as
+    a direct sum of indecomposables.
+
+    From [Decomposing Multiparameter Persistence Modules](https://doi.org/10.4230/LIPIcs.SoCG.2025.41).
+
+    Parameters:
+     - s : The slicer to reduce. Has to be a minimal presentation.
+     - verbose : shows log.
+     - progress : shows a progress bar
+     - sort : sorts the input first in a colexical order (debug)
+    """
+
+    from multipers.slicer import is_slicer
+    if not is_slicer(s):
+        raise ValueError(f"Input has to be a slicer. Got {type(s)=}.")
+    if not s.is_minpres:
+        raise ValueError(f"AIDA takes a minimal presentation as an input. Got {s.minpres_degree=}.")
+    if s.num_parameters != 2 or not s.is_minpres:
+        raise ValueError(f"AIDA is only compatible with 2-parameter minimal presentations. Got {s.num_parameters=} and {s.is_minpres=}.")
+    cdef bool is_squeezed = s.is_squeezed
+
+    cdef int degree = s.minpres_degree 
+    if sort:
+        s = s.to_colexical()
+    F = np.asarray(s.get_filtrations())
+    D = s.get_dimensions()
+    cdef double[:,:] row_degree_ = np.asarray(F[D==degree],   dtype = np.float64)
+    cdef double[:,:] col_degree_ = np.asarray(F[D==degree+1], dtype = np.float64)
+    cdef vector[pair[double,double]] row_degree = array_view_to_vect_pair(row_degree_)
+    cdef vector[pair[double,double]] col_degree = array_view_to_vect_pair(col_degree_)
+    i,j = np.searchsorted(D, [degree+1,degree+2])
+    cdef vector[vector[int]] matrix = s.get_boundaries()[i:j]
+
+    cdef AIDA_functor truc 
+    cdef multipers_interface_input stuff 
+    cdef multipers_interface_output stuff2
+    with nogil:
+        truc.config.show_info = verbose
+        truc.config.sort_output = False
+        truc.config.sort = sort
+        truc.config.progress = progress
+        stuff = multipers_interface_input(col_degree, row_degree, matrix)
+        stuff2 = truc.multipers_interface(stuff)
+    out = []
+    _Slicer = mp.Slicer(return_type_only=True, dtype=np.float64)
+    out = [_Slicer() for _ in range(stuff2.summands.size())]
+    dim_container_ = s.get_dimensions().copy()
+    cdef int32_t[:] dim_container = np.asarray(dim_container_, dtype=np.int32)
+    cdef list boundary_container
+    cdef vector[pair[double,double]] FR
+    cdef vector[pair[double,double]] FG
+    cdef vector[vector[int]] B
+    for i in range(stuff2.summands.size()):
+        FR = stuff2.summands[i].col_degrees
+        FG = stuff2.summands[i].row_degrees
+        B = stuff2.summands[i].matrix
+
+        for j in range(FG.size()):
+            dim_container[j] = degree
+        for j in range(FG.size(),FG.size()+FR.size()):
+            dim_container[j] = degree +1
+
+        boundary_container = [[] for _ in range(FG.size())]
+        boundary_container.extend(B)
+        
+        if FR.size() == 0:
+            filtration_values = np.asarray(FG)
+        else:
+            filtration_values = np.concatenate([FG,FR], dtype=np.float64)
+
+        s_summand = _Slicer(
+            boundary_container,
+            dim_container[:FG.size()+FR.size()],
+            filtration_values
+        )
+        if s.is_squeezed:
+            s_summand.filtration_grid = s.filtration_grid
+            s_summand._clean_filtration_grid()
+        out[i] = s_summand
+            
+    return out
+
+def one_criticalify(
+        slicer,
+        bool reduce=False,
+        degree:Optional[int]=None,
+        bool clear = True,
+        swedish:Optional[bool] = None,
+        bool verbose = False,
+        bool kcritical=False,
+        str algo:Literal["path","tree"]="path",
+    ):
+    """
+    Computes a free implicit representation  of a given multi-critical
+    multifiltration of a given homological degree (i.e., for a given
+    homological degree, a quasi-isomorphic 1-critical filtration), or free
+    resolution of the multifiltration (i.e., quasi-isomorphic 1-critical chain
+    complex).
+
+    From [Fast free resolutions of bifiltered chain complexes](https://doi.org/10.48550/arXiv.2512.08652), 
+    whose code is available here: https://bitbucket.org/mkerber/multi_critical
+
+    Parameters:
+     - slicer : multicritical filtration to represent
+     - reduce : returns a (or multiple, see degree) minimal presentation(s) instead of the chain complex.
+     - degree : If an int is given, and `reduce` is true, only returns the minimal presentation of this degree.
+                If None is given and `reduce` is true, returns a minimal presentation of all possible degrees.
+                If reduce is false : has no effect.
+     - clear : Clears the temporary files.
+     - swedish : if True, `reduce=True` and `degree=None` skips the computation of the 1critical chain complex,
+                 and directly (sequentially) computes the individual minimal presentations.
+     - verbose : shows log
+     - kcritical : do not use
+     - algo : see ref.
+    """
+    from multipers.io import _multi_critical_from_slicer
+    from multipers.slicer import is_slicer
+    if not is_slicer(slicer):
+        raise ValueError(f"Invalid input. Expected `SlicerType` got {type(slicer)=}.")
+    if not slicer.is_kcritical:
+        return slicer
+    if slicer.is_squeezed:
+        F = slicer.filtration_grid
+    else:
+        F = None
+    out = _multi_critical_from_slicer(
+           slicer, reduce=reduce, algo=algo,
+           degree=degree, clear=clear,
+           swedish=swedish, verbose=verbose,
+           kcritical=kcritical
+    )
+    if is_slicer(out, allow_minpres=False):
+        out.filtration_grid = F
+    else:
+        for stuff in out:
+            stuff.filtration_grid = F
+    return out
+
+def minimal_presentation(
+        slicer,
+        int degree = -1, 
+        degrees:Iterable[int]=[],
+        str backend:Literal["mpfree", "2pac", ""]="mpfree", 
+        int n_jobs = -1,
+        bool force=False,
+        bool auto_clean = True,
+        ):
+    """
+    Computes a minimal presentation a (1-critical) multifiltered  complex.
+
+    From [Fast minimal presentations of bi-graded persistence modules](https://doi.org/10.1137/1.9781611976472.16),
+    whose code is available here: https://bitbucket.org/mkerber/mpfree
+
+    Backends differents than `mpfree` are unstable.
+
+    Parameters:
+     - slicer : the filtration/free implicit representation to reduce
+     - degree : the homological degree to reduce
+     - degrees : a list of homological degrees to reduce. Output will be a list.
+     - backend : a callable `scc`-compatible backend
+     - n_jobs : process minpres in parallel if degrees is given
+     - force : if input is already reduced, force the re-computation of the minimal presentation.
+     - auto_clean : if input is squeezed, some filtraton values may disappear.
+       This is a postprocessing to remove unnecessary coordinates.
+    """
+    from multipers.io import _init_external_softwares, scc_reduce_from_str_to_slicer
+    from joblib import Parallel, delayed
+    from multipers.slicer import is_slicer
+    from multipers import Slicer
+    import os
+    import tempfile
+
+    if is_slicer(slicer) and slicer.is_minpres and not force:
+        from warnings import warn
+        warn(f"(unnecessary computation) The slicer seems to be already reduced, from homology of degree {slicer.minpres_degree}.")
+        return slicer
+    _init_external_softwares(requires=[backend])
+    if len(degrees)>0:
+        def todo(int degree):
+            return minimal_presentation(slicer, degree=degree, backend=backend, force=force, auto_clean=auto_clean)
+        return tuple(
+          Parallel(n_jobs=n_jobs, backend="threading")(delayed(todo)(d) for d in degrees)
+        )
+    assert degree>=0, f"Degree not provided."
+    if not np.any(slicer.get_dimensions() == degree):
+        return type(slicer)()
+    dimension = slicer.dimension - degree # latest  = L-1, which is empty, -1 for degree 0, -2 for degree 1 etc.
+    with tempfile.TemporaryDirectory(prefix="multipers") as tmpdir:
+        tmp_path = os.path.join(tmpdir, "multipers.scc")
+        slicer.to_scc(path=tmp_path, strip_comments=True, degree=degree-1, unsqueeze = False)
+        new_slicer = type(slicer)()
+        if backend=="mpfree":
+            shift_dimension=degree-1
+        else:
+            shift_dimension=degree
+        scc_reduce_from_str_to_slicer(path=tmp_path, slicer=new_slicer, dimension=dimension, backend=backend, shift_dimension=shift_dimension)
+
+        new_slicer.minpres_degree = degree
+        new_slicer.filtration_grid = slicer.filtration_grid if slicer.is_squeezed else None
+        if new_slicer.is_squeezed and auto_clean:
+            new_slicer = new_slicer._clean_filtration_grid()
+        return new_slicer

multipers/pickle.py

@@ -0,0 +1,89 @@
+import numpy as np
+
+
+def save_with_axis(path: str, signed_measures):
+    np.savez(
+        path,
+        **{
+            f"{i}_{axis}_{degree}": np.c_[
+                sm_of_degree[0], sm_of_degree[1][:, np.newaxis]
+            ]
+            for i, sm in enumerate(signed_measures)
+            for axis, sm_of_axis in enumerate(sm)
+            for degree, sm_of_degree in enumerate(sm_of_axis)
+        },
+    )
+
+
+def save_without_axis(path: str, signed_measures):
+    np.savez(
+        path,
+        **{
+            f"{i}_{degree}": np.c_[sm_of_degree[0], sm_of_degree[1][:, np.newaxis]]
+            for i, sm in enumerate(signed_measures)
+            for degree, sm_of_degree in enumerate(sm)
+        },
+    )
+
+
+def get_sm_with_axis(sms, idx, axis, degree):
+    sm = sms[f"{idx}_{axis}_{degree}"]
+    return (sm[:, :-1], sm[:, -1])
+
+
+def get_sm_without_axis(sms, idx, degree):
+    sm = sms[f"{idx}_{degree}"]
+    return (sm[:, :-1], sm[:, -1])
+
+
+def load_without_axis(sms):
+    indices = np.array(
+        [[int(i) for i in key.split("_")] for key in sms.keys()], dtype=int
+    )
+    num_data, num_degrees = indices.max(axis=0) + 1
+    signed_measures_reconstructed = [
+        [get_sm_without_axis(sms, idx, degree) for degree in range(num_degrees)]
+        for idx in range(num_data)
+    ]
+    return signed_measures_reconstructed
+
+
+# test : np.all([np.array_equal(a[0],b[0]) and np.array_equal(a[1],b[1]) and len(a) == len(b) == 2 for x,y in zip(signed_measures_reconstructed,signed_measures_reconstructed) for a,b in zip(x,y)])
+
+
+def load_with_axis(sms):
+    indices = np.array(
+        [[int(i) for i in key.split("_")] for key in sms.keys()], dtype=int
+    )
+    num_data, num_axis, num_degrees = indices.max(axis=0) + 1
+    signed_measures_reconstructed = [
+        [
+            [get_sm_with_axis(sms, idx, axis, degree) for degree in range(num_degrees)]
+            for axis in range(num_axis)
+        ]
+        for idx in range(num_data)
+    ]
+    return signed_measures_reconstructed
+
+
+def save(path: str, signed_measures):
+    if isinstance(signed_measures[0][0], tuple):
+        save_without_axis(path=path, signed_measures=signed_measures)
+    else:
+        save_with_axis(path=path, signed_measures=signed_measures)
+
+
+def load(path: str):
+    sms = np.load(path)
+    item = None
+    for i in sms.keys():
+        item = i
+        break
+    n = len(item.split("_"))
+    match n:
+        case 2:
+            return load_without_axis(sms)
+        case 3:
+            return load_with_axis(sms)
+        case _:
+            raise Exception("Invalid Signed Measure !")