multipers 2.2.3__cp311-cp311-win_amd64.whl → 2.3.1__cp311-cp311-win_amd64.whl

multipers/tests/test_python-cpp_conversion.py

@@ -1,82 +0,0 @@
-import numpy as np
-import multipers as mp
-import gudhi as gd
-
-
-mp.simplex_tree_multi.SAFE_CONVERSION = False
-
-
-def test_random_alpha_safe_conversion():
-    x = np.random.uniform(size=(200, 2))
-    num_parameter = 4
-    st_gudhi = gd.AlphaComplex(points=x).create_simplex_tree()
-    st_multi = mp.SimplexTreeMulti(
-        st_gudhi, num_parameters=num_parameter, safe_conversion=True
-    )
-    assert (
-        np.all([s in st_multi for s, f in st_gudhi.get_simplices()])
-        and st_gudhi.num_simplices() == st_multi.num_simplices
-    ), "Simplices conversion failed."
-    assert np.all(
-        [f.shape[0] == num_parameter for _, f in st_multi.get_simplices()]
-    ), "Number of parameters is inconcistent"
-    assert np.all(
-        [np.isclose(st_multi.filtration(s)[0], f) for s, f in st_gudhi.get_simplices()]
-    ), "Filtration values conversion failed."
-
-
-def test_random_alpha_unsafe_conversion():
-    x = np.random.uniform(size=(200, 2))
-    num_parameter = 4
-    st_gudhi = gd.AlphaComplex(points=x).create_simplex_tree()
-    st_multi = mp.SimplexTreeMulti(
-        st_gudhi, num_parameters=num_parameter, safe_conversion=False
-    )
-    assert (
-        np.all([s in st_multi for s, f in st_gudhi.get_simplices()])
-        and st_gudhi.num_simplices() == st_multi.num_simplices
-    ), "Simplices conversion failed."
-    assert np.all(
-        [f.shape[0] == num_parameter for _, f in st_multi.get_simplices()]
-    ), "Number of parameters is inconcistent"
-    assert np.all(
-        [np.isclose(st_multi.filtration(s)[0], f) for s, f in st_gudhi.get_simplices()]
-    ), "Filtration values conversion failed."
-
-
-def test_random_rips_safe_conversion():
-    x = np.random.uniform(size=(100, 2))
-    num_parameter = 4
-    st_gudhi = gd.RipsComplex(points=x).create_simplex_tree()
-    st_multi = mp.SimplexTreeMulti(
-        st_gudhi, num_parameters=num_parameter, safe_conversion=True
-    )
-    assert (
-        np.all([s in st_multi for s, f in st_gudhi.get_simplices()])
-        and st_gudhi.num_simplices() == st_multi.num_simplices
-    ), "Simplices conversion failed."
-    assert np.all(
-        [f.shape[0] == num_parameter for _, f in st_multi.get_simplices()]
-    ), "Number of parameters is inconcistent"
-    assert np.all(
-        [np.isclose(st_multi.filtration(s)[0], f) for s, f in st_gudhi.get_simplices()]
-    ), "Filtration values conversion failed."
-
-
-def test_random_alpha_unsafe_conversion():
-    x = np.random.uniform(size=(100, 2))
-    num_parameter = 4
-    st_gudhi = gd.RipsComplex(points=x).create_simplex_tree()
-    st_multi = mp.SimplexTreeMulti(
-        st_gudhi, num_parameters=num_parameter, safe_conversion=False
-    )
-    assert (
-        np.all([s in st_multi for s, f in st_gudhi.get_simplices()])
-        and st_gudhi.num_simplices() == st_multi.num_simplices
-    ), "Simplices conversion failed."
-    assert np.all(
-        [f.shape[0] == num_parameter for _, f in st_multi.get_simplices()]
-    ), "Number of parameters is inconcistent"
-    assert np.all(
-        [np.isclose(st_multi.filtration(s)[0], f) for s, f in st_gudhi.get_simplices()]
-    ), "Filtration values conversion failed."

multipers/tests/test_signed_betti.py

@@ -1,181 +0,0 @@
-import numpy as np 
-from multipers.point_measure import signed_betti, rank_decomposition_by_rectangles
-
-
-# only tests rank functions with 1 and 2 parameters
-def test_rank_decomposition():
-    # rank of an interval module in 1D on a grid with 2 elements
-    ri = np.array(
-        [
-            [
-                1,  # 0,0
-                1,  # 0,1
-            ],
-            [0, 1],  # 1,0  # 1,1
-        ]
-    )
-    expected_rd = np.array(
-        [
-            [
-                0,  # 0,0
-                1,  # 0,1
-            ],
-            [0, 0],  # 1,0  # 1,1
-        ]
-    )
-    rd = rank_decomposition_by_rectangles(ri)
-    for i in range(2):
-        for i_ in range(i, 2):
-            assert rd[i, i_] == expected_rd[i, i_]
-
-    # rank of a sum of two rectangles in 2D on a grid of 2 elements
-    ri = np.array(
-        [
-            [
-                [
-                    [1, 1],  # (0,0), (0,0)  # (0,0), (0,1)
-                    [1, 1],  # (0,0), (1,0)  # (0,0), (1,1)
-                ],
-                [
-                    [0, 1],  # (0,1), (0,0)  # (0,1), (0,1)
-                    [0, 1],  # (0,1), (1,0)  # (0,1), (1,1)
-                ],
-            ],
-            [
-                [
-                    [0, 0],  # (1,0), (0,0)  # (1,0), (0,1)
-                    [2, 2],  # (1,0), (1,0)  # (1,0), (1,1)
-                ],
-                [
-                    [0, 0],  # (1,1), (0,0)  # (1,1), (0,1)
-                    [0, 2],  # (1,1), (1,0)  # (1,1), (1,1)
-                ],
-            ],
-        ]
-    )
-    expected_rd = np.array(
-        [
-            [
-                [
-                    [0, 0],  # (0,0), (0,0)  # (0,0), (0,1)
-                    [0, 1],  # (0,0), (1,0)  # (0,0), (1,1)
-                ],
-                [
-                    [0, 0],  # (0,1), (0,0)  # (0,1), (0,1)
-                    [0, 0],  # (0,1), (1,0)  # (0,1), (1,1)
-                ],
-            ],
-            [
-                [
-                    [0, 0],  # (1,0), (0,0)  # (1,0), (0,1)
-                    [0, 1],  # (1,0), (1,0)  # (1,0), (1,1)
-                ],
-                [
-                    [0, 0],  # (1,1), (0,0)  # (1,1), (0,1)
-                    [0, 0],  # (1,1), (1,0)  # (1,1), (1,1)
-                ],
-            ],
-        ]
-    )
-
-    rd = rank_decomposition_by_rectangles(ri)
-    for i in range(2):
-        for i_ in range(i, 2):
-            for j in range(2):
-                for j_ in range(j, 2):
-                    assert rd[i, j, i_, j_] == expected_rd[i, j, i_, j_]
-
-
-# only tests Hilbert functions with 1, 2, 3, and 4 parameters
-def _test_signed_betti():
-    np.random.seed(0)
-    N = 4
-
-    # test 1D
-    for _ in range(N):
-        a = np.random.randint(10, 30)
-
-        f = np.random.randint(0, 40, size=(a))
-        sb = signed_betti(f)
-
-        check = np.zeros(f.shape)
-        for i in range(f.shape[0]):
-            for i_ in range(0, i + 1):
-                check[i] += sb[i_]
-
-        assert np.allclose(check, f)
-
-    # test 2D
-    for _ in range(N):
-        a = np.random.randint(10, 30)
-        b = np.random.randint(10, 30)
-
-        f = np.random.randint(0, 40, size=(a, b))
-        sb = signed_betti(f)
-
-        check = np.zeros(f.shape)
-        for i in range(f.shape[0]):
-            for j in range(f.shape[1]):
-                for i_ in range(0, i + 1):
-                    for j_ in range(0, j + 1):
-                        check[i, j] += sb[i_, j_]
-
-        assert np.allclose(check, f)
-
-    # test 3D
-    for _ in range(N):
-        a = np.random.randint(10, 20)
-        b = np.random.randint(10, 20)
-        c = np.random.randint(10, 20)
-
-        f = np.random.randint(0, 40, size=(a, b, c))
-        sb = signed_betti(f)
-
-        check = np.zeros(f.shape)
-        for i in range(f.shape[0]):
-            for j in range(f.shape[1]):
-                for k in range(f.shape[2]):
-                    for i_ in range(0, i + 1):
-                        for j_ in range(0, j + 1):
-                            for k_ in range(0, k + 1):
-                                check[i, j, k] += sb[i_, j_, k_]
-
-        assert np.allclose(check, f)
-
-    # test 4D
-    for _ in range(N):
-        a = np.random.randint(5, 10)
-        b = np.random.randint(5, 10)
-        c = np.random.randint(5, 10)
-        d = np.random.randint(5, 10)
-
-        f = np.random.randint(0, 40, size=(a, b, c, d))
-        sb = signed_betti(f)
-
-        check = np.zeros(f.shape)
-        for i in range(f.shape[0]):
-            for j in range(f.shape[1]):
-                for k in range(f.shape[2]):
-                    for l in range(f.shape[3]):
-                        for i_ in range(0, i + 1):
-                            for j_ in range(0, j + 1):
-                                for k_ in range(0, k + 1):
-                                    for l_ in range(0, l + 1):
-                                        check[i, j, k, l] += sb[i_, j_, k_, l_]
-
-        assert np.allclose(check, f)
-
-    for threshold in [True, False]:
-        for _ in range(N):
-            a = np.random.randint(5, 10)
-            b = np.random.randint(5, 10)
-            c = np.random.randint(5, 10)
-            d = np.random.randint(5, 10)
-            e = np.random.randint(5, 10)
-            f = np.random.randint(5, 10)
-
-            f = np.random.randint(0, 40, size=(a, b, c, d,e,f))
-            sb = signed_betti(f, threshold=threshold)
-            sb_ = signed_betti(f, threshold=threshold)
-
-            assert np.allclose(sb, sb_)

multipers/tests/test_signed_measure.py

@@ -1,89 +0,0 @@
-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

@@ -1,221 +0,0 @@
-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)