multipers 2.2.3__cp310-cp310-win_amd64.whl

multipers/tests/test_signed_measure.py

@@ -0,0 +1,89 @@
+import numpy as np
+import pytest
+
+import multipers as mp
+import multipers.io as mio
+from multipers.tests import assert_sm, random_st
+
+np.random.seed(0)
+
+st = random_st(npts=50).collapse_edges(-2, ignore_warning=True)
+
+invariants = ["euler", "hilbert", "rank"]
+degrees = [0, 1]
+mass_defaults = [None, "auto"]
+strats = [("regular_closest", 20), ("quantile", 20), ("regular", 17)]
+
+mio._init_external_softwares()
+mpfree_flag = mio._check_available("mpfree")
+
+
+@pytest.mark.parametrize("invariant", invariants)
+@pytest.mark.parametrize("degree", degrees)
+@pytest.mark.parametrize("mass_default", mass_defaults)
+@pytest.mark.parametrize("S", strats)
+def test_backends(invariant, degree, mass_default, S):
+    degree = None if invariant == "euler" else degree
+    strat, r = S
+    sms = []
+    sms.append(
+        mp.signed_measure(
+            st,
+            degree=degree,
+            grid_strategy=strat,
+            resolution=r,
+            mass_default=mass_default,
+            invariant=invariant,
+        )[0]
+    )
+    sms.append(
+        mp.signed_measure(
+            st.grid_squeeze(grid_strategy=strat, resolution=r),
+            degree=degree,
+            mass_default=mass_default,
+            invariant=invariant,
+        )[0]
+    )
+    snv = mp.Slicer(st, vineyard=False)
+    sv = mp.Slicer(st, vineyard=True)
+    for s in [sv, snv]:
+        sms.append(
+            mp.signed_measure(
+                s,
+                degree=1,
+                grid_strategy=strat,
+                resolution=r,
+                mass_default=mass_default,
+                invariant=invariant,
+            )[0]
+        )
+    if invariant != "euler":
+        if not mpfree_flag:
+            pytest.skip(r"Skipping next test, as `mpfree` was not found.")
+        else:
+            for s in [sv, snv]:
+                assert s.minpres(degree=degree).is_minpres, "minpres is not minpres"
+                sms.append(
+                    mp.signed_measure(
+                        s.minpres(degree=degree),
+                        degree=degree,
+                        grid_strategy=strat,
+                        resolution=r,
+                        mass_default=mass_default,
+                        invariant=invariant,
+                    )[0]
+                )
+                sms.append(
+                    mp.signed_measure(
+                        st,
+                        grid_strategy=strat,
+                        degree=degree,
+                        resolution=r,
+                        mass_default=mass_default,
+                        backend="mpfree",
+                        invariant=invariant,
+                    )[0]
+                )
+    if mass_default is not None and invariant != "rank":
+        assert sms[0][1].sum() == 0, "Did not remove all of the mass"
+    assert_sm(*sms, exact=False, max_error=0.5)

multipers/tests/test_simplextreemulti.py

@@ -0,0 +1,221 @@
+import pickle as pkl
+
+import gudhi as gd
+import numpy as np
+from numpy import array
+
+import multipers as mp
+import pytest
+from multipers.tests import assert_st_simplices, random_st
+
+
+
+def test_1():
+    st = mp.SimplexTreeMulti(num_parameters=2)
+    st.insert([0], [0, 1])
+    st.insert([1], [1, 0])
+    st.insert([0, 1], [1, 1])
+    it = [([0, 1], [1.0, 1.0]), ([0], [0.0, 1.0]), ([1], [1.0, 0.0])]
+    assert_st_simplices(st, it)
+
+
+def test_2():
+    from gudhi.rips_complex import RipsComplex
+
+    st2 = RipsComplex(points=[[0, 1], [1, 0], [0, 0]]).create_simplex_tree()
+    st2 = mp.SimplexTreeMulti(
+        st2, num_parameters=3, default_values=[1, 2]
+    )  # the gudhi filtration is placed on axis 0
+
+    it = (
+        ([0, 1], [np.sqrt(2), 1.0, 2.0]),
+        ([0, 2], [1.0, 1.0, 2.0]),
+        ([0], [0.0, 1.0, 2.0]),
+        ([1, 2], [1.0, 1.0, 2.0]),
+        ([1], [0.0, 1.0, 2.0]),
+        ([2], [0.0, 1.0, 2.0]),
+    )
+    assert_st_simplices(st2, it)
+
+
+def test_3():
+    st = gd.SimplexTree()  # usual gudhi simplextree
+    st.insert([0, 1], 1)
+    st.insert([1], 0)
+    # converts the simplextree into a multiparameter simplextree
+    for dtype in [np.int32, np.int64, np.float32, np.float64]:
+        try:
+            st_multi = mp.SimplexTreeMulti(st, num_parameters=4, dtype=dtype)
+        except KeyError:
+            import sys
+
+            print(f"type {dtype} not compiled, skipping.", file=sys.stderr)
+            continue  ## dtype not compiled
+        minf = -np.inf if isinstance(dtype(1), np.floating) else np.iinfo(dtype).min
+        it = [
+            (array([0, 1]), array([1.0, minf, minf, minf])),
+            (array([0]), array([1.0, minf, minf, minf])),
+            (array([1]), array([0.0, minf, minf, minf])),
+        ]
+        assert_st_simplices(st_multi, it)
+
+
+has_kcritical = np.any([a().is_kcritical for a in mp.simplex_tree_multi.available_simplextrees])
+@pytest.mark.skipif(
+    not has_kcritical,
+    reason="kcritical simplextree not compiled, skipping this test",
+)
+def test_4():
+    st = mp.SimplexTreeMulti(num_parameters=2, kcritical=True, dtype=np.float64)
+    st.insert([0, 1, 2], [0, 1])
+    st.insert([0, 1, 2], [1, 0])
+    st.remove_maximal_simplex([0, 1, 2])
+    st.insert([0, 1, 2], [1, 2])
+    st.insert([0, 1, 2], [2, 1])
+    st.insert([0, 1, 2], [1.5, 1.5])
+    st.insert([0, 1, 2], [2.5, 0.5])
+    st.insert([0, 1, 2], [0.5, 2.5])
+
+    s = mp.Slicer(st, vineyard=True)
+
+    assert np.array_equal(
+        s.get_filtrations_values(),
+        array(
+            [
+                [0.0, 1.0],
+                [1.0, 0.0],
+                [0.0, 1.0],
+                [1.0, 0.0],
+                [0.0, 1.0],
+                [1.0, 0.0],
+                [0.0, 1.0],
+                [1.0, 0.0],
+                [0.0, 1.0],
+                [1.0, 0.0],
+                [0.0, 1.0],
+                [1.0, 0.0],
+                [0.5, 2.5],
+                [1.0, 2.0],
+                [1.5, 1.5],
+                [2.0, 1.0],
+                [2.5, 0.5],
+            ]
+        ),
+    ), "Invalid conversion from kcritical st to kcritical slicer."
+    death_curve = np.asarray(
+        mp.module_approximation(s, box=[[0, 0], [3, 3]])
+        .get_module_of_degree(1)[0]
+        .get_death_list()
+    )
+    assert np.array_equal(
+        death_curve,
+        array(
+            [
+                [0.5, np.inf],
+                [1.0, 2.5],
+                [1.5, 2.0],
+                [2.0, 1.5],
+                [2.5, 1.0],
+                [np.inf, 0.5],
+            ]
+        ),
+    )
+
+
+def test_make_filtration_non_decreasing():
+    st = mp.SimplexTreeMulti(num_parameters=2)
+    st.insert([0], [1, 2])
+    st.insert([1], [2, 3])
+    st.insert([2], [3, 2])
+
+    st.insert([0, 1], [10, 21])
+    st.insert([2, 0], [11, 20])
+
+    st.insert([0, 1, 2], [-np.inf, -np.inf])
+    assert (st.filtration([1, 2]) == 3).all()
+    assert (st.filtration([0, 1, 2]) == [11, 21]).all()
+    st.make_filtration_non_decreasing()
+    assert (st.filtration([1, 2]) == 3).all()
+    assert (st.filtration([0, 1, 2]) == [11, 21]).all()
+
+
+def test_flagify():
+    st = mp.SimplexTreeMulti(num_parameters=2)
+
+    st.insert([0], [1, 4])
+    st.insert([1], [2, 3])
+    st.insert([2], [3, 2])
+
+    st.insert([0, 1], [21, 20])
+    st.insert([2, 0], [20, 21])
+    st.insert([1, 2])
+    st.insert([0, 1, 2], [41, 55])
+
+    st.flagify(2)
+    assert (st.filtration([0, 1, 2]) == 21).all()
+    st.flagify(1)
+    assert (np.array([f for s, f in st]).max(axis=0) == [3, 4]).all()
+    st.flagify(0)
+    assert (np.array([f for s, f in st]) == -np.inf).all()
+
+
+def test_distance_matrix_filling():
+    X = np.random.uniform(size=(200, 2))
+    D = np.sqrt(((X[None] - X[:, None]) ** 2).sum(axis=-1))
+    st = gd.RipsComplex(distance_matrix=D).create_simplex_tree()
+    st = mp.SimplexTreeMulti(st, num_parameters=1)
+    st2 = mp.SimplexTreeMulti(st)
+    assert st2.num_parameters == 1
+    st2.fill_lowerstar(np.zeros(st.num_vertices), 0)
+    assert st2 != st
+    st2.fill_distance_matrix(D, 0)
+    assert st2 == st
+
+
+def test_serialize():
+    stm = random_st(num_parameters=4)
+    stm2 = pkl.loads(pkl.dumps(stm))
+    assert stm == stm2
+    stm2[[0]][:] = stm2[[0]] + 1
+    assert not stm == stm2
+    st1 = stm.project_on_line(parameter=0)
+    stm = mp.SimplexTreeMulti(st1, num_parameters=3)
+    assert st1 == stm.project_on_line(
+        parameter=0
+    ), "Gudhi<->Multipers conversion failed"
+
+
+@pytest.mark.skipif(
+    not has_kcritical,
+    reason="kcritical simplextree not compiled, skipping this test",
+)
+def test_kcritical_batch_insert():
+
+    st = mp.SimplexTreeMulti(num_parameters=2, kcritical=True, dtype=np.float64)
+
+    vertices = [[0,1]]
+    vertices_filtrations = np.array([[[-1, -2]],[[-2, -1]]])
+    st.insert_batch(vertices,vertices_filtrations)
+
+    edges = np.array([[0, 1],[1, 2], [2,0]]).T
+    edges_filtrations = np.array([
+        [[1,0],[0,1], [np.inf,np.inf]],
+        [[1,0],[0,1], [np.inf,np.inf]],
+        [[1,0],[0,1], [-1,3]],
+    ])
+    st.insert_batch(edges, edges_filtrations)
+
+    triangle = np.array([[0,1,2]]).T
+    triangle_filration = [[[2,2]]]
+    st.insert_batch(triangle, triangle_filration)
+
+    from numpy import array
+    goal = [(array([0, 1, 2]), [array([2., 2.])]),
+         (array([0, 1]), [array([0., 1.]), array([1., 0.])]),
+         (array([0, 2]), [array([-1.,  3.]), array([0., 1.]), array([1., 0.])]),
+         (array([0]), [array([-1., -2.])]),
+         (array([1, 2]), [array([0., 1.]), array([1., 0.])]),
+         (array([1]), [array([-2., -1.])]),
+         (array([2]), [array([0., 1.]), array([1., 0.])])
+    ]
+    assert_st_simplices(st, goal)

multipers/tests/test_slicer.py

@@ -0,0 +1,221 @@
+import numpy as np
+import pytest
+from numpy import array
+
+import multipers as mp
+import multipers.slicer as mps
+from multipers.tests import assert_sm
+import pickle as pkl
+
+mpfree_flag = mp.io._check_available("mpfree")
+fd_flag = mp.io._check_available("function_delaunay")
+
+
+def test_1():
+    st = mp.SimplexTreeMulti(num_parameters=2)
+    st.insert([0], [0, 1])
+    st.insert([1], [1, 0])
+    st.insert([0, 1], [1, 1])
+    for S in mps.available_slicers:
+        if not S().is_vine or not S().col_type or S().is_kcritical:
+            continue
+        from multipers._slicer_meta import _blocks2boundary_dimension_grades
+
+        generator_maps, generator_dimensions, filtration_values = (
+            _blocks2boundary_dimension_grades(
+                st._to_scc(),
+                inplace=False,
+            )
+        )
+        it = S(
+            generator_maps, generator_dimensions, filtration_values
+        ).persistence_on_line([0, 0])
+        assert (
+            len(it) == 2
+        ), "There are simplices of dim 0 and 1, but no pers ? got {}".format(len(it))
+        assert len(it[1]) == 0, "Pers of dim 1 is not empty ? got {}".format(it[1])
+        for x in it[0]:
+            if np.any(np.asarray(x)):
+                continue
+            assert x[0] == 1 and x[1] > 45, "pers should be [1,inf], got {}".format(x)
+
+
+def test_2():
+    st = mp.SimplexTreeMulti(num_parameters=2)
+    st.insert([0], [0, 1])
+    st.insert([1], [1, 0])
+    st.insert([0, 1], [1, 1])
+    st.insert([0, 1, 2], [2, 2])
+    assert mp.slicer.to_simplextree(mp.Slicer(st, dtype=st.dtype)) == st
+
+
+def test_3():
+    st = mp.SimplexTreeMulti(num_parameters=2)
+    st.insert([0], [0, 1])
+    st.insert([1], [1, 0])
+    st.insert([0, 1], [1, 1])
+    sm = mp.signed_measure(st, invariant="rank", degree=0)
+    sm2 = mp.signed_measure(mp.Slicer(st, dtype=np.int32), invariant="rank", degree=0)
+    sm3 = mp.signed_measure(mp.Slicer(st, dtype=np.float64), invariant="rank", degree=0)
+    it = [
+        (
+            array([[0.0, 1.0, 1.0, 1.0], [1.0, 0.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]]),
+            array([1, 1, -1]),
+        )
+    ]
+    assert_sm(sm, it)
+    assert_sm(sm2, it)
+    assert_sm(sm3, it)
+
+
+def test_representative_cycles():
+    truc = [
+        {},
+        {},
+        {},
+        {},
+        {},
+        {},
+        {},
+        {2, 3},
+        {4, 5},
+        {0, 2},
+        {0, 1},
+        {1, 3},
+        {1, 2},
+        {7, 11, 12},
+        {9, 10, 12},
+        {5, 6},
+        {2, 4},
+        {4, 6},
+        {8, 15, 17},
+        {3, 6},
+    ]
+    truc = [list(machin) for machin in truc]
+    slicer = mp.slicer._Slicer_Matrix0_vine_f64(
+        truc,
+        np.array([max(len(x) - 1, 0) for x in truc]),
+        np.array([list(range(len(truc))), list(range(len(truc)))]).T,
+    )
+    slicer.compute_persistence(one_filtration=list(range(len(truc))))
+    cycles = slicer.get_representative_cycles()
+    assert len(cycles) == 3, f"There should be 3 dimensions here, found {len(cycles)}"
+    assert (
+        np.asarray(cycles[0]).shape[0] == 7
+    ), f"Invalid number of 0-cycles, got {np.asarray(cycles[0]).size}"
+    for c in cycles[1]:
+        assert (
+            np.unique(cycles[1][0], return_counts=True)[1] == 2
+        ).all(), f"Found a non-cycle, {cycles[1][0]}"
+    assert len(cycles[2]) == 0, "Found a 2-cycle, which should not exist"
+
+
+def test_pruning():
+    from multipers.tests import random_st
+
+    st = random_st(num_parameters=3, max_dim=4)
+    s = mp.Slicer(st)
+    s.prune_above_dimension(2)
+    s2 = mp.Slicer(s, max_dim=2)
+    assert s.get_dimensions()[-1] == 2, "Failed to prune dimension"
+    st.prune_above_dimension(2)
+    assert (
+        s.get_dimensions() == s2.get_dimensions()
+    ).all(), "pruned dimensions do not coincide"
+    assert s.get_boundaries() == s2.get_boundaries(), "Boundaries changed"
+    assert (
+        s.get_filtrations_values() == s2.get_filtrations_values()
+    ).all(), "Filtrations have changed"
+
+
+def test_scc():
+    import numpy as np
+
+    import multipers as mp
+    from multipers.distances import sm_distance
+    from multipers.io import _check_available
+    from multipers.tests import random_st
+
+    st = random_st(npts=500, num_parameters=2)
+    s = mp.Slicer(st, dtype=np.float64)
+    s.to_scc("truc.scc", degree=1)
+    s2 = mp.Slicer("truc.scc")
+    (a,) = mp.signed_measure(s)
+    (b,) = mp.signed_measure(s2)
+    assert sm_distance(a, b) < np.finfo(np.float64).resolution * s.num_generators
+
+    st = random_st(npts=500)
+    s = mp.Slicer(st).grid_squeeze(inplace=True)
+    s.filtration_grid = []
+    s.to_scc("truc.scc", degree=1)
+    s2 = mp.Slicer("truc.scc", dtype=np.float64)
+    (a,) = mp.signed_measure(s)
+    (b,) = mp.signed_measure(s2)
+    assert sm_distance(a, b) == 0
+
+    st = random_st(npts=200)
+    s = mp.Slicer(st).grid_squeeze(inplace=True)
+    s.filtration_grid = []
+    s.to_scc(
+        "truc.scc",
+    )
+    if _check_available("mpfree"):
+        s2 = mp.Slicer("truc.scc", dtype=np.float64).minpres(1)
+        (a,) = mp.signed_measure(s, degree=1)
+        (b,) = mp.signed_measure(s2, degree=1)
+        assert sm_distance(a, b) == 0
+    else:
+        pytest.skip("Skipped a test bc `mpfree` was not found.")
+
+
+def test_bitmap():
+    img = np.random.uniform(size=(12, 10, 11, 2))
+    num_parameters = img.shape[-1]
+    s = mp.slicer.from_bitmap(img)
+    num_vertices = np.searchsorted(s.get_dimensions(), 1)
+    assert num_vertices == np.prod(img.shape[:-1])
+    assert s.num_parameters == num_parameters
+    assert s.dimension == img.ndim - 1
+    assert np.all(
+        np.asarray(s.get_filtrations()[:num_vertices])
+        == img.reshape(-1, num_parameters)
+    )
+
+
+@pytest.mark.skipif(
+    not fd_flag or not mpfree_flag,
+    reason="Skipped external test as `function_delaunay`, `mpfree` were not found.",
+)
+@pytest.mark.parametrize("dim", [1, 2, 3, 4])
+@pytest.mark.parametrize("degree", [1, 2, 3])
+def test_external(dim, degree):
+    if degree >= dim:
+        return
+    X = np.random.uniform(size=(100, dim))
+    f = np.random.uniform(size=(X.shape[0]))
+    fd = mps.from_function_delaunay(X, f)
+    assert np.array_equal(np.unique(fd.get_dimensions()), np.arange(dim + 2))
+    fd_ = mps.from_function_delaunay(X, f, degree=degree)
+    assert np.array_equal(
+        np.unique(fd_.get_dimensions()), [degree, degree + 1]
+    )  ## only does presentations
+    fd_ = fd.minpres(degree=degree)
+    assert np.array_equal(
+        np.unique(fd_.get_dimensions()), [degree, degree + 1, degree + 2]
+    )  ## resolution by default
+
+def test_pkl():
+    for num_params in range(1,4):
+        img = np.random.uniform(size=(20,20,num_params))
+        img2 = np.array(img)
+        img2[0,0,0]+=1
+        s = mp.slicer.from_bitmap(img)
+        s2 = mp.slicer.from_bitmap(img2)
+        s3 = type(s)(s.get_boundaries()[:-1], s.get_dimensions()[:-1], s.get_filtrations()[:-1])
+        s4 = type(s)(s.get_boundaries(), s.get_dimensions()+1, s.get_filtrations())
+        assert len(s)> np.prod(img.shape[:-1])+1
+        assert s == s.copy()
+        assert s != s2
+        assert s != s3
+        assert s != s4
+        assert s == pkl.loads(pkl.dumps(s))

multipers/torch/__init__.py

@@ -0,0 +1 @@
+from .rips_density import *