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

multipers/distances.py

@@ -1,198 +1,198 @@
-import numpy as np
-import ot
-
-from multipers.mma_structures import PyMultiDiagrams_type
-from multipers.multiparameter_module_approximation import PyModule_type
-from multipers.simplex_tree_multi import SimplexTreeMulti_type
-
-
-def sm2diff(sm1, sm2):
-    pts = sm1[0]
-    dtype = pts.dtype
-    if isinstance(pts, np.ndarray):
-
-        def backend_concatenate(a, b):
-            return np.concatenate([a, b], axis=0, dtype=dtype)
-
-        def backend_tensor(x):
-            return np.asarray(x, dtype=int)
-
-    else:
-        import torch
-
-        assert isinstance(pts, torch.Tensor), "Invalid backend. Numpy or torch."
-
-        def backend_concatenate(a, b):
-            return torch.concatenate([a, b], dim=0)
-
-        def backend_tensor(x):
-            return torch.tensor(x).type(torch.int)
-
-    pts1, w1 = sm1
-    pts2, w2 = sm2
-    ## TODO: optimize this
-    pos_indices1 = backend_tensor(
-        [i for i, w in enumerate(w1) for _ in range(w) if w > 0]
-    )
-    pos_indices2 = backend_tensor(
-        [i for i, w in enumerate(w2) for _ in range(w) if w > 0]
-    )
-    neg_indices1 = backend_tensor(
-        [i for i, w in enumerate(w1) for _ in range(-w) if w < 0]
-    )
-    neg_indices2 = backend_tensor(
-        [i for i, w in enumerate(w2) for _ in range(-w) if w < 0]
-    )
-    x = backend_concatenate(pts1[pos_indices1], pts2[neg_indices2])
-    y = backend_concatenate(pts1[neg_indices1], pts2[pos_indices2])
-    return x, y
-
-
-def sm_distance(
-    sm1: tuple,
-    sm2: tuple,
-    reg: float = 0,
-    reg_m: float = 0,
-    numItermax: int = 10000,
-    p: float = 1,
-):
-    """
-    Computes the wasserstein distances between two signed measures,
-    of the form
-     - (pts,weights)
-    with
-     - pts : (num_pts, dim) float array
-     - weights : (num_pts,) int array
-
-    Regularisation:
-     - sinkhorn if reg != 0
-     - sinkhorn unbalanced if reg_m != 0
-    """
-    x, y = sm2diff(sm1, sm2)
-    loss = ot.dist(
-        x, y, metric="sqeuclidean", p=p
-    )  # only euc + sqeuclidian are implemented in pot for the moment with torch backend # TODO : check later
-    if isinstance(x, np.ndarray):
-        empty_tensor = np.array([])  # uniform weights
-    else:
-        import torch
-
-        assert isinstance(x, torch.Tensor), "Unimplemented backend."
-        empty_tensor = torch.tensor([])  # uniform weights
-
-    if reg == 0:
-        return ot.lp.emd2(empty_tensor, empty_tensor, M=loss) * len(x)
-    if reg_m == 0:
-        return ot.sinkhorn2(
-            a=empty_tensor, b=empty_tensor, M=loss, reg=reg, numItermax=numItermax
-        )
-    return ot.sinkhorn_unbalanced2(
-        a=empty_tensor,
-        b=empty_tensor,
-        M=loss,
-        reg=reg,
-        reg_m=reg_m,
-        numItermax=numItermax,
-    )
-    # return ot.sinkhorn2(a=onesx,b=onesy,M=loss,reg=reg, numItermax=numItermax)
-    # return ot.bregman.empirical_sinkhorn2(x,y,reg=reg)
-
-
-def estimate_matching(b1: PyMultiDiagrams_type, b2: PyMultiDiagrams_type):
-    assert len(b1) == len(b2)
-    from gudhi.bottleneck import bottleneck_distance
-
-    def get_bc(b: PyMultiDiagrams_type, i: int) -> np.ndarray:
-        temp = b[i].get_points()
-        out = (
-            np.array(temp)[:, :, 0] if len(temp) > 0 else np.empty((0, 2))
-        )  # GUDHI FIX
-        return out
-
-    return max(
-        (bottleneck_distance(get_bc(b1, i), get_bc(b2, i)) for i in range(len(b1)))
-    )
-
-
-# Functions to estimate precision
-def estimate_error(
-    st: SimplexTreeMulti_type,
-    module: PyModule_type,
-    degree: int,
-    nlines: int = 100,
-    verbose: bool = False,
-):
-    """
-    Given an MMA SimplexTree and PyModule, estimates the bottleneck distance using barcodes given by gudhi.
-
-    Parameters
-    ----------
-     - st:SimplexTree
-        The simplextree representing the n-filtered complex. Used to define the gudhi simplextrees on different lines.
-     - module:PyModule
-        The module on which to estimate approximation error, w.r.t. the original simplextree st.
-     - degree:int
-        The homology degree to consider
-
-    Returns
-    -------
-     - float:The estimation of the matching distance, i.e., the maximum of the sampled bottleneck distances.
-
-    """
-    from time import perf_counter
-
-    parameter = 0
-
-    def _get_bc_ST(st, basepoint, degree: int):
-        """
-        Slices an mma simplextree to a gudhi simplextree, and compute its persistence on the diagonal line crossing the given basepoint.
-        """
-        gst = st.project_on_line(
-            basepoint=basepoint, parameter=parameter
-        )  # we consider only the 1rst coordinate (as )
-        gst.compute_persistence()
-        return gst.persistence_intervals_in_dimension(degree)
-
-    from gudhi.bottleneck import bottleneck_distance
-
-    low, high = module.get_box()
-    nfiltration = len(low)
-    basepoints = np.random.uniform(low=low, high=high, size=(nlines, nfiltration))
-    # barcodes from module
-    print("Computing mma barcodes...", flush=1, end="") if verbose else None
-    time = perf_counter()
-    bcs_from_mod = module.barcodes(degree=degree, basepoints=basepoints).get_points()
-    print(f"Done. {perf_counter() - time}s.") if verbose else None
-
-    def clean(dgm):
-        return np.array(
-            [
-                [birth[parameter], death[parameter]]
-                for birth, death in dgm
-                if len(birth) > 0 and birth[parameter] != np.inf
-            ]
-        )
-
-    bcs_from_mod = [
-        clean(dgm) for dgm in bcs_from_mod
-    ]  # we only consider the 1st coordinate of the barcode
-    # Computes gudhi barcodes
-    from tqdm import tqdm
-
-    bcs_from_gudhi = [
-        _get_bc_ST(st, basepoint=basepoint, degree=degree)
-        for basepoint in tqdm(
-            basepoints, disable=not verbose, desc="Computing gudhi barcodes"
-        )
-    ]
-    return max(
-        (
-            bottleneck_distance(a, b)
-            for a, b in tqdm(
-                zip(bcs_from_mod, bcs_from_gudhi),
-                disable=not verbose,
-                total=nlines,
-                desc="Computing bottleneck distances",
-            )
-        )
-    )
+import numpy as np
+import ot
+
+from multipers.mma_structures import PyMultiDiagrams_type
+from multipers.multiparameter_module_approximation import PyModule_type
+from multipers.simplex_tree_multi import SimplexTreeMulti_type
+
+
+def sm2diff(sm1, sm2):
+    pts = sm1[0]
+    dtype = pts.dtype
+    if isinstance(pts, np.ndarray):
+
+        def backend_concatenate(a, b):
+            return np.concatenate([a, b], axis=0, dtype=dtype)
+
+        def backend_tensor(x):
+            return np.asarray(x, dtype=int)
+
+    else:
+        import torch
+
+        assert isinstance(pts, torch.Tensor), "Invalid backend. Numpy or torch."
+
+        def backend_concatenate(a, b):
+            return torch.concatenate([a, b], dim=0)
+
+        def backend_tensor(x):
+            return torch.tensor(x).type(torch.int)
+
+    pts1, w1 = sm1
+    pts2, w2 = sm2
+    ## TODO: optimize this
+    pos_indices1 = backend_tensor(
+        [i for i, w in enumerate(w1) for _ in range(w) if w > 0]
+    )
+    pos_indices2 = backend_tensor(
+        [i for i, w in enumerate(w2) for _ in range(w) if w > 0]
+    )
+    neg_indices1 = backend_tensor(
+        [i for i, w in enumerate(w1) for _ in range(-w) if w < 0]
+    )
+    neg_indices2 = backend_tensor(
+        [i for i, w in enumerate(w2) for _ in range(-w) if w < 0]
+    )
+    x = backend_concatenate(pts1[pos_indices1], pts2[neg_indices2])
+    y = backend_concatenate(pts1[neg_indices1], pts2[pos_indices2])
+    return x, y
+
+
+def sm_distance(
+    sm1: tuple,
+    sm2: tuple,
+    reg: float = 0,
+    reg_m: float = 0,
+    numItermax: int = 10000,
+    p: float = 1,
+):
+    """
+    Computes the wasserstein distances between two signed measures,
+    of the form
+     - (pts,weights)
+    with
+     - pts : (num_pts, dim) float array
+     - weights : (num_pts,) int array
+
+    Regularisation:
+     - sinkhorn if reg != 0
+     - sinkhorn unbalanced if reg_m != 0
+    """
+    x, y = sm2diff(sm1, sm2)
+    loss = ot.dist(
+        x, y, metric="sqeuclidean", p=p
+    )  # only euc + sqeuclidian are implemented in pot for the moment with torch backend # TODO : check later
+    if isinstance(x, np.ndarray):
+        empty_tensor = np.array([])  # uniform weights
+    else:
+        import torch
+
+        assert isinstance(x, torch.Tensor), "Unimplemented backend."
+        empty_tensor = torch.tensor([])  # uniform weights
+
+    if reg == 0:
+        return ot.lp.emd2(empty_tensor, empty_tensor, M=loss) * len(x)
+    if reg_m == 0:
+        return ot.sinkhorn2(
+            a=empty_tensor, b=empty_tensor, M=loss, reg=reg, numItermax=numItermax
+        )
+    return ot.sinkhorn_unbalanced2(
+        a=empty_tensor,
+        b=empty_tensor,
+        M=loss,
+        reg=reg,
+        reg_m=reg_m,
+        numItermax=numItermax,
+    )
+    # return ot.sinkhorn2(a=onesx,b=onesy,M=loss,reg=reg, numItermax=numItermax)
+    # return ot.bregman.empirical_sinkhorn2(x,y,reg=reg)
+
+
+def estimate_matching(b1: PyMultiDiagrams_type, b2: PyMultiDiagrams_type):
+    assert len(b1) == len(b2)
+    from gudhi.bottleneck import bottleneck_distance
+
+    def get_bc(b: PyMultiDiagrams_type, i: int) -> np.ndarray:
+        temp = b[i].get_points()
+        out = (
+            np.array(temp)[:, :, 0] if len(temp) > 0 else np.empty((0, 2))
+        )  # GUDHI FIX
+        return out
+
+    return max(
+        (bottleneck_distance(get_bc(b1, i), get_bc(b2, i)) for i in range(len(b1)))
+    )
+
+
+# Functions to estimate precision
+def estimate_error(
+    st: SimplexTreeMulti_type,
+    module: PyModule_type,
+    degree: int,
+    nlines: int = 100,
+    verbose: bool = False,
+):
+    """
+    Given an MMA SimplexTree and PyModule, estimates the bottleneck distance using barcodes given by gudhi.
+
+    Parameters
+    ----------
+     - st:SimplexTree
+        The simplextree representing the n-filtered complex. Used to define the gudhi simplextrees on different lines.
+     - module:PyModule
+        The module on which to estimate approximation error, w.r.t. the original simplextree st.
+     - degree:int
+        The homology degree to consider
+
+    Returns
+    -------
+     - float:The estimation of the matching distance, i.e., the maximum of the sampled bottleneck distances.
+
+    """
+    from time import perf_counter
+
+    parameter = 0
+
+    def _get_bc_ST(st, basepoint, degree: int):
+        """
+        Slices an mma simplextree to a gudhi simplextree, and compute its persistence on the diagonal line crossing the given basepoint.
+        """
+        gst = st.project_on_line(
+            basepoint=basepoint, parameter=parameter
+        )  # we consider only the 1rst coordinate (as )
+        gst.compute_persistence()
+        return gst.persistence_intervals_in_dimension(degree)
+
+    from gudhi.bottleneck import bottleneck_distance
+
+    low, high = module.get_box()
+    nfiltration = len(low)
+    basepoints = np.random.uniform(low=low, high=high, size=(nlines, nfiltration))
+    # barcodes from module
+    print("Computing mma barcodes...", flush=1, end="") if verbose else None
+    time = perf_counter()
+    bcs_from_mod = module.barcodes(degree=degree, basepoints=basepoints).get_points()
+    print(f"Done. {perf_counter() - time}s.") if verbose else None
+
+    def clean(dgm):
+        return np.array(
+            [
+                [birth[parameter], death[parameter]]
+                for birth, death in dgm
+                if len(birth) > 0 and birth[parameter] != np.inf
+            ]
+        )
+
+    bcs_from_mod = [
+        clean(dgm) for dgm in bcs_from_mod
+    ]  # we only consider the 1st coordinate of the barcode
+    # Computes gudhi barcodes
+    from tqdm import tqdm
+
+    bcs_from_gudhi = [
+        _get_bc_ST(st, basepoint=basepoint, degree=degree)
+        for basepoint in tqdm(
+            basepoints, disable=not verbose, desc="Computing gudhi barcodes"
+        )
+    ]
+    return max(
+        (
+            bottleneck_distance(a, b)
+            for a, b in tqdm(
+                zip(bcs_from_mod, bcs_from_gudhi),
+                disable=not verbose,
+                total=nlines,
+                desc="Computing bottleneck distances",
+            )
+        )
+    )

multipers/filtration_conversions.pxd.tp

@@ -1,84 +1,84 @@
-{{py:
-
-"""
-Filtrations conversions between python and C++
-"""
-
-## Value types : CTYPE, PYTHON_TYPE, short
-value_types = [
-  ("int32_t", "np.int32", "i32"),
-  ("int64_t", "np.int64", "i64"),
-  ("float", "np.float32", "f32"),
-  ("double", "np.float64", "f64"),
-]
-
-}}
-
-# Python to C++ conversions
-from multipers.filtrations cimport One_critical_filtration,Multi_critical_filtration
-from libcpp.vector cimport vector
-from libcpp cimport bool
-cimport numpy as cnp
-import numpy as np
-from libc.stdint cimport int32_t, int64_t
-from cython.operator cimport dereference
-
-{{for CTYPE, PYTYPE, SHORT in value_types}}
-###### ------------------- PY TO CPP
-#### ---------- 
-
-cdef inline Multi_critical_filtration[{{CTYPE}}] _py2kc_{{SHORT}}({{CTYPE}}[:,:] filtrations) noexcept nogil:
-    # cdef {{CTYPE}}[:,:] filtrations = np.asarray(filtrations_, dtype={{PYTYPE}})
-    cdef Multi_critical_filtration[{{CTYPE}}] out
-    out.set_num_generators(filtrations.shape[0])
-    for i in range(filtrations.shape[0]):
-        out[i].resize(filtrations.shape[1])
-        for j in range(filtrations.shape[1]):
-            out[i][j] = filtrations[i,j]
-    out.simplify()
-    return out
-
-cdef inline One_critical_filtration[{{CTYPE}}] _py21c_{{SHORT}}({{CTYPE}}[:] filtration) noexcept nogil:
-    # cdef {{CTYPE}}[:] filtration = np.asarray(filtration_, dtype={{PYTYPE}})
-    cdef One_critical_filtration[{{CTYPE}}] out = One_critical_filtration[{{CTYPE}}](0)
-    out.reserve(len(filtration))
-    for i in range(len(filtration)):
-        out.push_back(filtration[i])
-    return out
-
-
-cdef inline vector[One_critical_filtration[{{CTYPE}}]] _py2v1c_{{SHORT}}({{CTYPE}}[:,:] filtrations) noexcept nogil:
-    # cdef {{CTYPE}}[:,:] filtrations = np.asarray(filtrations_, dtype={{PYTYPE}})
-    cdef vector[One_critical_filtration[{{CTYPE}}]] out
-    out.reserve(filtrations.shape[0])
-    for i in range(filtrations.shape[0]):
-        out.push_back(_py21c_{{SHORT}}(filtrations[i,:]))
-    return out
-
-
-###### ------------------- CPP to PY
-
-
-## CYTHON BUG: using tuples here will cause some weird issues. 
-cdef inline _ff21cview_{{SHORT}}(One_critical_filtration[{{CTYPE}}]* x, bool copy=False, int duplicate=0):
-  cdef Py_ssize_t num_parameters = dereference(x).num_parameters()
-  if copy and duplicate and not dereference(x).is_finite():
-    return np.full(shape=duplicate, fill_value=dereference(x)[0])
-  cdef {{CTYPE}}[:] x_view = <{{CTYPE}}[:num_parameters]>(&(dereference(x)[0]))
-  return np.array(x_view) if copy else np.asarray(x_view)
-
-cdef inline _ff2kcview_{{SHORT}}(Multi_critical_filtration[{{CTYPE}}]* x, bool copy=False, int duplicate=0):
-  cdef Py_ssize_t k = dereference(x).num_generators()
-  return [_ff21cview_{{SHORT}}(&(dereference(x)[i]), copy=copy, duplicate=duplicate) for i in range(k)]
-
-
-cdef inline  _vff21cview_{{SHORT}}(vector[One_critical_filtration[{{CTYPE}}]]& x, bool copy = False, int duplicate=0):
-  cdef Py_ssize_t num_stuff = x.size()
-  return [_ff21cview_{{SHORT}}(&(x[i]), copy=copy, duplicate=duplicate) for i in range(num_stuff)]
-
-cdef inline  _vff2kcview_{{SHORT}}(vector[Multi_critical_filtration[{{CTYPE}}]]& x, bool copy = False, int duplicate=0):
-  cdef Py_ssize_t num_stuff = x.size()
-  return [_ff2kcview_{{SHORT}}(&(x[i]), copy=copy, duplicate=duplicate) for i in range(num_stuff)]
-
-{{endfor}}
-
+{{py:
+
+"""
+Filtrations conversions between python and C++
+"""
+
+## Value types : CTYPE, PYTHON_TYPE, short
+value_types = [
+  ("int32_t", "np.int32", "i32"),
+  ("int64_t", "np.int64", "i64"),
+  ("float", "np.float32", "f32"),
+  ("double", "np.float64", "f64"),
+]
+
+}}
+
+# Python to C++ conversions
+from multipers.filtrations cimport One_critical_filtration,Multi_critical_filtration
+from libcpp.vector cimport vector
+from libcpp cimport bool
+cimport numpy as cnp
+import numpy as np
+from libc.stdint cimport int32_t, int64_t
+from cython.operator cimport dereference
+
+{{for CTYPE, PYTYPE, SHORT in value_types}}
+###### ------------------- PY TO CPP
+#### ---------- 
+
+cdef inline Multi_critical_filtration[{{CTYPE}}] _py2kc_{{SHORT}}({{CTYPE}}[:,:] filtrations) noexcept nogil:
+    # cdef {{CTYPE}}[:,:] filtrations = np.asarray(filtrations_, dtype={{PYTYPE}})
+    cdef Multi_critical_filtration[{{CTYPE}}] out
+    out.set_num_generators(filtrations.shape[0])
+    for i in range(filtrations.shape[0]):
+        out[i].resize(filtrations.shape[1])
+        for j in range(filtrations.shape[1]):
+            out[i][j] = filtrations[i,j]
+    out.simplify()
+    return out
+
+cdef inline One_critical_filtration[{{CTYPE}}] _py21c_{{SHORT}}({{CTYPE}}[:] filtration) noexcept nogil:
+    # cdef {{CTYPE}}[:] filtration = np.asarray(filtration_, dtype={{PYTYPE}})
+    cdef One_critical_filtration[{{CTYPE}}] out = One_critical_filtration[{{CTYPE}}](0)
+    out.reserve(len(filtration))
+    for i in range(len(filtration)):
+        out.push_back(filtration[i])
+    return out
+
+
+cdef inline vector[One_critical_filtration[{{CTYPE}}]] _py2v1c_{{SHORT}}({{CTYPE}}[:,:] filtrations) noexcept nogil:
+    # cdef {{CTYPE}}[:,:] filtrations = np.asarray(filtrations_, dtype={{PYTYPE}})
+    cdef vector[One_critical_filtration[{{CTYPE}}]] out
+    out.reserve(filtrations.shape[0])
+    for i in range(filtrations.shape[0]):
+        out.push_back(_py21c_{{SHORT}}(filtrations[i,:]))
+    return out
+
+
+###### ------------------- CPP to PY
+
+
+## CYTHON BUG: using tuples here will cause some weird issues. 
+cdef inline _ff21cview_{{SHORT}}(One_critical_filtration[{{CTYPE}}]* x, bool copy=False, int duplicate=0):
+  cdef Py_ssize_t num_parameters = dereference(x).num_parameters()
+  if copy and duplicate and not dereference(x).is_finite():
+    return np.full(shape=duplicate, fill_value=dereference(x)[0])
+  cdef {{CTYPE}}[:] x_view = <{{CTYPE}}[:num_parameters]>(&(dereference(x)[0]))
+  return np.array(x_view) if copy else np.asarray(x_view)
+
+cdef inline _ff2kcview_{{SHORT}}(Multi_critical_filtration[{{CTYPE}}]* x, bool copy=False, int duplicate=0):
+  cdef Py_ssize_t k = dereference(x).num_generators()
+  return [_ff21cview_{{SHORT}}(&(dereference(x)[i]), copy=copy, duplicate=duplicate) for i in range(k)]
+
+
+cdef inline  _vff21cview_{{SHORT}}(vector[One_critical_filtration[{{CTYPE}}]]& x, bool copy = False, int duplicate=0):
+  cdef Py_ssize_t num_stuff = x.size()
+  return [_ff21cview_{{SHORT}}(&(x[i]), copy=copy, duplicate=duplicate) for i in range(num_stuff)]
+
+cdef inline  _vff2kcview_{{SHORT}}(vector[Multi_critical_filtration[{{CTYPE}}]]& x, bool copy = False, int duplicate=0):
+  cdef Py_ssize_t num_stuff = x.size()
+  return [_ff2kcview_{{SHORT}}(&(x[i]), copy=copy, duplicate=duplicate) for i in range(num_stuff)]
+
+{{endfor}}
+

multipers/filtrations/__init__.py

@@ -0,0 +1,18 @@
+from .filtrations import (
+    CoreDelaunay,
+    Cubical,
+    DegreeRips,
+    DelaunayCodensity,
+    DelaunayLowerstar,
+    RipsCodensity,
+    RipsLowerstar,
+)
+__all__ = [
+    "CoreDelaunay",
+    "Cubical",
+    "DegreeRips",
+    "DelaunayCodensity",
+    "DelaunayLowerstar",
+    "RipsCodensity",
+    "RipsLowerstar",
+]