multipers 2.2.3__cp310-cp310-win_amd64.whl → 2.3.1__cp310-cp310-win_amd64.whl

multipers/multiparameter_module_approximation.pyx

@@ -1,217 +1,218 @@
-"""!
-@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
-
-###########################################################################
-## 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._slicer_meta import Slicer
-from multipers.mma_structures import *
-from multipers.mma_structures import PyModule_type
-from typing import Union
-import multipers
-import multipers.io as mio
-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 = [],
-        )->PyModule_type:
-
-    cdef Module[float] mod_f32
-    cdef Module[double] mod_f64
-    cdef intptr_t ptr
-    if not slicer.is_vine:
-        print(r"Got a non-vine slicer as an input. Use `vineyard=True` to remove this copy.", file=sys.stderr)
-        slicer = Slicer(slicer, vineyard=True)
-    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,_py21c_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,_py21c_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)
-
-    return approx_mod
-
-def module_approximation(
-        input:Union[SimplexTreeMulti_type,Slicer_type, tuple],
-        box:Optional[np.ndarray]=None,
-        float max_error=-1, 
-        int nlines=500,
-        slicer_backend:Literal["matrix","clement","graph"]="matrix",
-        minpres:Optional[Literal["mpfree"]]=None,
-        degree:Optional[int]=None,
-        bool complete=True, 
-        bool threshold=False, 
-        bool verbose=False,
-        bool ignore_warning=False,
-        id="",
-        list[float] direction = [],
-        list[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 = 200
-        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.
-    slicer_backend: Either "matrix","clement", or "graph".
-        If a simplextree is given, it is first converted to this structure,
-        with different choices of backends.
-    minpres: (Optional) "mpfree" only for the moment.
-        If given, and the input is a simplextree, 
-        computes a minimal presentation before starting the computation.
-        A degree has to be given.
-    degree: int Only required when minpres is given.
-        Homological degree of the minimal degree.
-    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(s.is_minpres for s in input), "Modules cannot be merged unless they are minimal presentations."
-        assert np.unique([s.minpres_degree for s in input]).shape[0] == len(input), "Multiple modules are at the same degree, cannot merge modules" 
-        if len(input) == 0:
-            return PyModule_f64()
-        if n_jobs <= 1: 
-            modules = tuple(module_approximation(slicer, box, max_error, nlines, slicer_backend, minpres, degree, complete, threshold, verbose, ignore_warning, id, direction, swap_box_coords) for slicer in input)
-        else:
-            modules = tuple(Parallel(n_jobs=n_jobs, prefer="threads")(
-                delayed(module_approximation)(slicer, box, max_error, nlines, slicer_backend, minpres, degree, complete, threshold, verbose, ignore_warning, id, direction, swap_box_coords)
-                for slicer in input
-            ))
-        mod = PyModule_f64().set_box(PyBox_f64(*modules[0].get_box()))
-        for i,m in enumerate(modules):
-            mod.merge(m, input[i].minpres_degree)
-        return mod
-    if box is None:
-        if is_simplextree_multi(input):
-            box = input.filtration_bounds()
-        else:
-            box = input.filtration_bounds()
-    box = np.asarray(box)
-
-    # empty coords
-    zero_idx = box[1] == box[0]
-    if np.any(zero_idx):
-        box[1] += zero_idx
-
-    for i in swap_box_coords:
-        box[0,i], box[1,i] = box[1,i], box[0,i]
-    num_parameters = box.shape[1]
-    if num_parameters <=0:
-        num_parameters = box.shape[1]
-    assert len(direction) == 0 or len(direction) == len(box[0]), f"Invalid line direction, 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 max_error <= 0:
-        max_error = (prod/nlines)**(1/(num_parameters-1))
-
-    if not ignore_warning and prod >= 10_000:
-        raise ValueError(f"""
-Warning : the number of lines (around {np.round(prod)}) may be too high. 
-Try to increase the precision parameter, or set `ignore_warning=True` to compute this module. 
-Returning the trivial module."""
-        )
-    if is_simplextree_multi(input):
-        input = multipers.Slicer(input,backend=slicer_backend, vineyard=True)
-    assert is_slicer(input), "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,
-            )
-
-
-
-
-
+"""!
+@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
+
+###########################################################################
+## 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 = [],
+        )->PyModule_type:
+
+    cdef Module[float] mod_f32
+    cdef Module[double] mod_f64
+    cdef intptr_t ptr
+    if not slicer.is_vine:
+        print(r"Got a non-vine slicer as an input. Use `vineyard=True` to remove this copy.", file=sys.stderr)
+        from multipers._slicer_meta import Slicer
+        slicer = Slicer(slicer, vineyard=True, backend="matrix")
+    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,_py21c_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,_py21c_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)
+
+    return approx_mod
+
+def module_approximation(
+        input:Union[SimplexTreeMulti_type,Slicer_type, tuple],
+        box:Optional[np.ndarray]=None,
+        float max_error=-1, 
+        int nlines=557,
+        slicer_backend:Literal["matrix","clement","graph"]="matrix",
+        minpres:Optional[Literal["mpfree"]]=None,
+        degree:Optional[int]=None,
+        bool complete=True, 
+        bool threshold=False, 
+        bool verbose=False,
+        bool ignore_warning=False,
+        id="",
+        list[float] direction = [],
+        list[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 = 200
+        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.
+    slicer_backend: Either "matrix","clement", or "graph".
+        If a simplextree is given, it is first converted to this structure,
+        with different choices of backends.
+    minpres: (Optional) "mpfree" only for the moment.
+        If given, and the input is a simplextree, 
+        computes a minimal presentation before starting the computation.
+        A degree has to be given.
+    degree: int Only required when minpres is given.
+        Homological degree of the minimal degree.
+    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(s.is_minpres for s in input), "Modules cannot be merged unless they are minimal presentations."
+        assert np.unique([s.minpres_degree for s in input]).shape[0] == len(input), "Multiple modules are at the same degree, cannot merge modules" 
+        if len(input) == 0:
+            return PyModule_f64()
+        if n_jobs <= 1: 
+            modules = tuple(module_approximation(slicer, box, max_error, nlines, slicer_backend, minpres, degree, complete, threshold, verbose, ignore_warning, id, direction, swap_box_coords) for slicer in input)
+        else:
+            modules = tuple(Parallel(n_jobs=n_jobs, prefer="threads")(
+                delayed(module_approximation)(slicer, box, max_error, nlines, slicer_backend, minpres, degree, complete, threshold, verbose, ignore_warning, id, direction, swap_box_coords)
+                for slicer in input
+            ))
+        mod = PyModule_f64().set_box(PyBox_f64(*modules[0].get_box()))
+        for i,m in enumerate(modules):
+            mod.merge(m, input[i].minpres_degree)
+        return mod
+    if len(input) == 0:
+        return PyModule_f64()
+    if box is None:
+        if is_simplextree_multi(input):
+            box = input.filtration_bounds()
+        else:
+            box = input.filtration_bounds()
+    box = np.asarray(box)
+
+    # empty coords
+    zero_idx = box[1] == box[0]
+    if np.any(zero_idx):
+        box[1] += zero_idx
+
+    for i in swap_box_coords:
+        box[0,i], box[1,i] = box[1,i], box[0,i]
+    num_parameters = box.shape[1]
+    if num_parameters <=0:
+        num_parameters = box.shape[1]
+    assert len(direction) == 0 or len(direction) == len(box[0]), f"Invalid line direction, 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 max_error <= 0:
+        max_error = (prod/nlines)**(1/(num_parameters-1))
+
+    if not ignore_warning and prod >= 10_000:
+        raise ValueError(f"""
+Warning : the number of lines (around {np.round(prod)}) may be too high. 
+Try to increase the precision parameter, or set `ignore_warning=True` to compute this module. 
+Returning the trivial module."""
+        )
+    if is_simplextree_multi(input):
+        from multipers._slicer_meta import Slicer
+        input = Slicer(input,backend=slicer_backend, vineyard=True)
+    assert is_slicer(input), "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,
+            )
+
+
+
+
+

multipers/pickle.py

@@ -1,53 +1,90 @@
-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 !")
+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 !")
+