multipers 2.0.0__cp310-cp310-macosx_13_0_arm64.whl

multipers/__init__.py

@@ -0,0 +1,11 @@
+# Doc
+import multipers.io
+import multipers.multiparameter_module_approximation
+import multipers.simplex_tree_multi
+import multipers.slicer
+from multipers._signed_measure_meta import signed_measure
+from multipers._slicer_meta import Slicer
+from multipers.multiparameter_module_approximation import module_approximation
+
+# Shortcuts
+from multipers.simplex_tree_multi import SimplexTreeMulti

multipers/_signed_measure_meta.py

@@ -0,0 +1,268 @@
+from typing import Optional, Union
+
+import numpy as np
+
+from multipers.grids import compute_grid, sms_in_grid
+from multipers.plots import plot_signed_measures
+from multipers.point_measure_integration import clean_sms
+from multipers.rank_invariant import rank_from_slicer
+from multipers.simplex_tree_multi import (
+    SimplexTreeMulti_type,
+    _available_strategies,
+    is_simplextree_multi,
+)
+from multipers.slicer import Slicer_type, is_slicer
+
+
+def signed_measure(
+    simplextree: Union[SimplexTreeMulti_type, Slicer_type],
+    degree: Optional[int] = None,
+    degrees=[None],
+    mass_default=None,
+    grid_strategy: _available_strategies = "exact",
+    invariant: Optional[str] = None,
+    plot: bool = False,
+    verbose: bool = False,
+    n_jobs: int = -1,
+    expand_collapse: bool = False,
+    backend: str = "multipers",
+    thread_id: str = "",
+    input_path: Optional[str] = None,
+    grid_conversion: Optional[list] = None,
+    coordinate_measure: bool = False,
+    num_collapses: int = 0,
+    clean: bool = False,
+    **infer_grid_kwargs,
+) -> list[tuple[np.ndarray, np.ndarray]]:
+    """
+    Computes the signed measures given by the decomposition of the hilbert
+    function or the euler characteristic.
+
+    Input
+    -----
+     - simplextree:SimplexTreeMulti, the multifiltered simplicial complex.
+       Its recommended to squeeze the simplextree first.
+     - mass_default: Either None, or 'auto' or 'inf', or array-like of floats.
+       Where to put the default mass to get a zero-mass measure.
+     - degree:int|None / degrees:list[int] the degrees to compute.
+       None represents the euler characteristic.
+     - plot:bool, plots the computed measures if true.
+     - n_jobs:int, number of jobs.
+       Defaults to #cpu, but when doing parallel computations of signed measures, we recommend setting this to 1.
+     - verbose:bool, prints c++ logs.
+
+    Output
+    ------
+    `[signed_measure_of_degree for degree in degrees]`
+    with `signed_measure_of_degree` of the form `(dirac location, dirac weights)`.
+    """
+    if len(degrees) == 1 and degrees[0] is None and degree is not None:
+        degrees = [degree]
+    if None in degrees:
+        assert len(degrees) == 1
+    if len(degrees) == 0:
+        return []
+    if is_slicer(simplextree):
+        if grid_conversion is None and not simplextree.is_squeezed:
+            grid_conversion = compute_grid(
+                simplextree.get_filtrations_values().T,
+                strategy=grid_strategy,
+                **infer_grid_kwargs,
+            )
+        if not simplextree.is_squeezed:
+            simplextree_ = simplextree.grid_squeeze(grid_conversion, coordinates=True)
+        else:
+            simplextree_ = simplextree
+            if grid_conversion is None:
+                grid_conversion = tuple(
+                    np.asarray(f, dtype=np.float64) for f in simplextree.filtration_grid
+                )
+        if invariant == "rank":  # TODO Hilbert from slicer
+            degrees = np.asarray(degrees, dtype=int)
+            return rank_from_slicer(
+                simplextree_,
+                degrees=degrees,
+                n_jobs=n_jobs,
+                grid_shape=tuple(len(g) for g in grid_conversion),
+                grid_conversion=grid_conversion,
+                plot=plot,
+            )
+        return _signed_measure_from_slicer(
+            simplextree_,
+            plot=plot,
+            grid_conversion=grid_conversion,
+            clean=clean,
+        )
+    assert is_simplextree_multi(simplextree), "Input has to be simplextree or slicer."
+    assert invariant is None or invariant in [
+        "hilbert",
+        "rank_invariant",
+        "euler",
+        "rank",
+        "euler_characteristic",
+        "hilbert_function",
+    ]
+    assert not plot or simplextree.num_parameters == 2, "Can only plot 2d measures."
+
+    if not simplextree._is_squeezed:
+        if grid_conversion is None:
+            grid_conversion = simplextree.get_filtration_grid(
+                grid_strategy=grid_strategy,
+                **infer_grid_kwargs,
+            )  # put a warning ?
+        simplextree_ = simplextree.grid_squeeze(
+            grid_conversion,
+            coordinate_values=True,
+            inplace=False,
+            **infer_grid_kwargs,
+        )
+        if num_collapses != 0:
+            simplextree_.collapse_edges(num_collapses)
+    else:
+        simplextree_ = simplextree
+        if grid_conversion is None:
+            grid_conversion = [np.asarray(f) for f in simplextree_.filtration_grid]
+    if coordinate_measure:
+        grid_conversion = None
+
+    if backend != "multipers":
+        if input_path is not None:
+            import multipers.io as mio
+
+            mio.input_path = input_path
+        assert (
+            len(degrees) == 1
+            and mass_default is None
+            and (invariant is None or "hilbert" in invariant)
+        )
+        from multipers.io import reduce_complex
+
+        minimal_presentation = reduce_complex(
+            simplextree_,
+            full_resolution=True,
+            dimension=degrees[0],
+            id=thread_id,
+            backend=backend,
+            verbose=verbose,
+        )
+        sms = _signed_measure_from_scc(
+            minimal_presentation, grid_conversion=grid_conversion
+        )
+        if plot:
+            from multipers.plots import plot_signed_measures
+
+            plot_signed_measures(sms)
+        return sms
+    # assert simplextree.num_parameters == 2
+    if mass_default is None:
+        mass_default = mass_default
+    elif mass_default == "inf":
+        mass_default = np.array([np.inf] * simplextree.num_parameters)
+    elif mass_default == "auto":
+        grid_conversion = [np.asarray(f) for f in simplextree_.filtration_grid]
+        mass_default = np.array(
+            [1.1 * np.max(f) - 0.1 * np.min(f) for f in grid_conversion]
+        )
+    else:
+        mass_default = np.asarray(mass_default)
+        assert (
+            mass_default.ndim == 1
+            and mass_default.shape[0] == simplextree.num_parameters
+        )
+    # assert not coordinate_measure or grid_conversion is None
+
+    if invariant in ["rank_invariant", "rank"]:
+        assert (
+            simplextree.num_parameters == 2
+        ), "Rank invariant only implemented for 2-parameter modules."
+        assert not coordinate_measure, "Not implemented"
+        from multipers.simplex_tree_multi import _rank_signed_measure as smri
+
+        sms = smri(
+            simplextree_,
+            mass_default=mass_default,
+            degrees=degrees,
+            plot=plot,
+            expand_collapse=expand_collapse,
+        )
+    elif len(degrees) == 1 and degrees[0] is None:
+        assert invariant is None or invariant in [
+            "euler",
+            "euler_characteristic",
+        ], "Provide a degree to compute hilbert function."
+        # assert not coordinate_measure, "Not implemented"
+        from multipers.simplex_tree_multi import _euler_signed_measure
+
+        sms = [
+            _euler_signed_measure(
+                simplextree_,
+                mass_default=mass_default,
+                verbose=verbose,
+                plot=plot,
+                grid_conversion=grid_conversion,
+            )
+        ]
+    else:
+        assert invariant is None or invariant in [
+            "hilbert",
+            "hilbert_function",
+        ], "Found homological degrees for euler computation."
+        from multipers.simplex_tree_multi import (
+            _hilbert_signed_measure as hilbert_signed_measure,
+        )
+
+        sms = hilbert_signed_measure(
+            simplextree_,
+            degrees=degrees,
+            mass_default=mass_default,
+            verbose=verbose,
+            plot=plot,
+            n_jobs=n_jobs,
+            expand_collapse=expand_collapse,
+            grid_conversion=grid_conversion,
+        )
+
+    if clean:
+        sms = clean_sms(sms)
+    return sms
+
+
+def _signed_measure_from_scc(
+    minimal_presentation, grid_conversion=None
+) -> list[tuple[np.ndarray, np.ndarray]]:
+    pts = np.concatenate([b[0] for b in minimal_presentation if len(b[0]) > 0])
+    weights = np.concatenate(
+        [
+            (1 - 2 * (i % 2)) * np.ones(len(b[0]))
+            for i, b in enumerate(minimal_presentation)
+        ]
+    )
+    sm = [(pts, weights)]
+    if grid_conversion is not None:
+        sm = sms_in_grid(sm, grid_conversion)
+    return sm
+
+
+def _signed_measure_from_slicer(
+    slicer: Slicer_type,
+    plot: bool = False,
+    grid_conversion=None,
+    clean: bool = False,
+) -> list[tuple[np.ndarray, np.ndarray]]:
+    pts = slicer.get_filtrations()
+    dims = slicer.get_dimensions()
+    weights = 1 - 2 * (
+        (1 + dims) % 2
+    )  # dim 0 is always empty : TODO : make that more clean
+    sm = [(pts, weights)]
+    if slicer.is_squeezed and grid_conversion is None:
+        grid_conversion = [
+            np.asarray(f, dtype=np.float64) for f in slicer.filtration_grid
+        ]
+    if grid_conversion is not None:
+        sm = sms_in_grid(sm, grid_conversion)
+    if clean:
+        sm = clean_sms(sm)
+    if plot:
+        plot_signed_measures(sm)
+    return sm

multipers/_slicer_meta.py

@@ -0,0 +1,171 @@
+from copy import deepcopy
+from typing import Literal, Optional
+
+import numpy as np
+
+import multipers.io as mio
+import multipers.slicer as mps
+from multipers.simplex_tree_multi import is_simplextree_multi
+
+
+## TODO : maybe optimize this with cython
+def _blocks2boundary_dimension_grades(
+    blocks,
+    filtration_type=np.float64,
+    num_parameters: int = -1,
+    inplace: bool = False,
+    is_kcritical: bool = False,
+):
+    """
+    Turns blocks, aka scc, into the input of non-simplicial slicers.
+    """
+    if num_parameters < 0:
+        for b in blocks:
+            if len(b[0]) > 0:
+                if is_kcritical:
+                    num_parameters = np.asarray(b[0][0]).shape[1]
+                else:
+                    num_parameters = np.asarray(b[0]).shape[1]
+                break
+        if num_parameters < 0:
+            raise ValueError("Empty Filtration")
+    rblocks = blocks if inplace else deepcopy(blocks)
+    rblocks.reverse()
+    block_sizes = [len(b[0]) for b in rblocks]
+    S = np.cumsum([0, 0] + block_sizes)
+    if is_kcritical:
+        multifiltration = tuple(
+            stuff
+            for b in rblocks
+            for stuff in (b[0] if len(b[0]) > 0 else [np.empty((0, num_parameters))])
+        )
+
+    else:
+        multifiltration = np.concatenate(
+            tuple(
+                b[0] if len(b[0]) > 0 else np.empty((0, num_parameters))
+                for b in rblocks
+            ),
+            dtype=filtration_type,
+        )
+    boundary = tuple(x + S[i] for i, b in enumerate(rblocks) for x in b[1])
+    dimensions = np.fromiter(
+        (i for i, b in enumerate(rblocks) for _ in range(len(b[0]))), dtype=int
+    )
+    return boundary, dimensions, multifiltration
+
+
+def _slicer_from_simplextree(st, backend, vineyard):
+    if vineyard:
+        if backend == "matrix":
+            slicer = mps._SlicerVineSimplicial(st)
+        elif backend == "clement":
+            raise ValueError("This one takes a minpres")
+        elif backend == "graph":
+            slicer = mps._SlicerVineGraph(st)
+        else:
+            raise ValueError(f"Inimplemented backend {backend}.")
+    else:
+        if backend == "matrix":
+            slicer = mps._SlicerNoVineSimplicial(st)
+        if backend == "clement":
+            raise ValueError("Clement is Vineyard")
+        if backend == "graph":
+            raise ValueError("Graph is Vineyard")
+    return slicer
+
+
+def _slicer_from_blocks(
+    blocks,
+    backend,
+    vineyard: bool,
+    is_kcritical: bool,
+    dtype: type,
+    col: str,
+):
+    boundary, dimensions, multifiltrations = _blocks2boundary_dimension_grades(
+        blocks,
+        inplace=False,
+        is_kcritical=is_kcritical,
+    )
+    if backend == "matrix":
+        slicer = mps.get_matrix_slicer(vineyard, is_kcritical, dtype, col)(
+            boundary, dimensions, multifiltrations
+        )
+    elif backend == "clement":
+        assert dtype == np.float32 and not is_kcritical and vineyard
+        slicer = mps._SlicerClement(boundary, dimensions, multifiltrations)
+    else:
+        raise ValueError(f"Inimplemented backend {backend}.")
+    return slicer
+
+
+def Slicer(
+    st,
+    backend: Literal["matrix", "clement", "graph"] = "matrix",
+    vineyard: bool = True,
+    reduce: bool = False,
+    reduce_backend: Optional[str] = None,
+    dtype=np.float64,
+    is_kcritical: bool = False,
+    column_type: str = "INTRUSIVE_SET",
+) -> mps.Slicer_type:
+    """
+    Given a simplextree or blocks (a.k.a scc for python),
+    returns a structure that can compute persistence on line (or more)
+    slices, eventually vineyard update, etc.
+
+    This can be used to compute interval-decomposable module approximations
+    or signed measures, using, e.g.
+     - `multipers.module_approximation(this, *args)`
+     - `multipers.signed_measure(this, *args)`
+
+    Note : it is recommended and sometime required to apply
+        a minimal presentation before computing these functions !
+    `mp.slicer.minimal_presentation(slicer, *args, **kwargs)`
+
+    Input
+    -----
+     - st : SimplexTreeMulti or scc-like blocks or path to scc file
+     - backend: slicer backend, e.g, "matrix", "clement", "graph"
+     - vineyard: vineyard capable (may slow down computations if true)
+    Output
+    ------
+    The corresponding slicer.
+    """
+    if mps.is_slicer(st):
+        slicer = mps.get_matrix_slicer(vineyard, is_kcritical, dtype, column_type)(
+            st.get_boundaries(), st.get_dimensions(), st.get_filtrations()
+        )
+        if st.is_squeezed:
+            slicer.filtration_grid = st.filtration_grid
+    elif is_simplextree_multi(st) and backend == "graph":
+        slicer = _slicer_from_simplextree(st, backend, vineyard)
+        if st._is_squeezed:
+            slicer.filtration_grid = st.filtration_grid
+    elif backend == "graph":
+        raise ValueError(
+            """
+Graph is simplicial, incompatible with minpres.
+You can try using `multipers.slicer.to_simplextree`."""
+        )
+    else:
+        filtration_grid = None
+        if is_simplextree_multi(st):
+            blocks = st._to_scc()
+            if st._is_squeezed:
+                filtration_grid = st.filtration_grid
+        elif isinstance(st, str):
+            blocks = mio.scc_parser(st)
+        else:
+            blocks = st
+        slicer = _slicer_from_blocks(
+            blocks, backend, vineyard, is_kcritical, dtype, column_type
+        )
+        if filtration_grid is not None:
+            slicer.filtration_grid = filtration_grid
+    if reduce:
+        slicer = mps.minimal_presentation(
+            slicer, backend=reduce_backend, slicer_backend=backend, vineyard=vineyard
+        )
+    return slicer