multipers 2.2.3__cp311-cp311-win_amd64.whl

multipers/test.pyx

@@ -0,0 +1,44 @@
+# cimport multipers.tensor as mt
+from libc.stdint cimport intptr_t, uint16_t
+from libcpp.vector cimport vector
+from libcpp cimport bool, int, float
+from libcpp.utility cimport pair
+from typing import Optional,Iterable,Callable
+
+
+ctypedef float value_type 
+# ctypedef uint16_t index_type 
+
+import numpy as np
+# cimport numpy as cnp
+# cnp.import_array()
+
+# cdef extern from "multi_parameter_rank_invariant/rank_invariant.h" namespace "Gudhi::rank_invariant":
+#     void get_hilbert_surface(const intptr_t, mt.static_tensor_view, const vector[index_type], const vector[index_type], index_type, index_type, const vector[index_type], bool, bool) except + nogil
+
+
+from multipers.simplex_tree_multi import SimplexTreeMulti
+
+
+def numpy_to_tensor(array:np.ndarray):
+    cdef vector[index_type] shape = array.shape
+    cdef dtype[::1] contigus_array_view = np.ascontiguousarray(array)
+    cdef dtype* dtype_ptr = &contigus_array_view[0]
+    cdef mt.static_tensor_view tensor
+    with nogil:
+        tensor = mt.static_tensor_view(dtype_ptr, shape)
+    return tensor.get_resolution()
+
+# def hilbert2d(simplextree:SimplexTreeMulti, grid_shape:np.ndarray|list, vector[index_type] degrees, bool mobius_inversion):
+# 	# assert simplextree.num_parameters == 2
+# 	cdef intptr_t ptr = simplextree.thisptr
+# 	cdef vector[index_type] c_grid_shape = grid_shape
+# 	cdef dtype[::1] container = np.zeros(grid_shape, dtype=np.float32).flatten()
+# 	cdef dtype* container_ptr = &container[0]
+# 	cdef mt.static_tensor_view c_container = mt.static_tensor_view(container_ptr, c_grid_shape)
+# 	cdef index_type i = 0
+# 	cdef index_type j = 1
+# 	cdef vector[index_type] fixed_values = [[],[]]
+# 	# get_hilbert_surface(ptr, c_container, c_grid_shape, degrees,i,j,fixed_values, False, False)
+# 	return container.reshape(grid_shape)
+

multipers/tests/__init__.py

@@ -0,0 +1,57 @@
+import numpy as np
+
+
+def assert_st_simplices(st, dump):
+    """
+    Checks that the simplextree has the same
+    filtration as the dump.
+    """
+
+    assert np.all(
+        [
+            np.isclose(a, b).all()
+            for x, y in zip(st.get_simplices(), dump, strict=True)
+            for a, b in zip(x, y, strict=True)
+        ]
+    )
+
+
+def sort_sm(sms):
+    idx = np.argsort([sm[0][:, 0] for sm in sms])
+    return tuple((sm[0][idx], sm[1][idx]) for sm in sms)
+
+
+def assert_sm_pair(sm1, sm2, exact=True, max_error=1e-3, reg=0.1):
+    if not exact:
+        from multipers.distances import sm_distance
+
+        d = sm_distance(sm1, sm2, reg=0.1)
+        assert d < max_error, f"Failed comparison:\n{sm1}\n{sm2},\n with distance {d}."
+        return
+    assert np.all(
+        [
+            np.isclose(a, b).all()
+            for x, y in zip(sm1, sm2, strict=True)
+            for a, b in zip(x, y, strict=True)
+        ]
+    ), f"Failed comparison:\n-----------------\n{sm1}\n-----------------\n{sm2}"
+
+
+def assert_sm(*args, exact=True, max_error=1e-5, reg=0.1):
+    sms = tuple(args)
+    for i in range(len(sms) - 1):
+        assert_sm_pair(sms[i], sms[i + 1], exact=exact, max_error=max_error, reg=reg)
+
+
+def random_st(npts=100, num_parameters=2, max_dim=2):
+    import gudhi as gd
+
+    import multipers as mp
+    from multipers.data import noisy_annulus
+
+    x = noisy_annulus(npts // 2, npts - npts // 2, dim=max_dim)
+    st = gd.AlphaComplex(points=x).create_simplex_tree()
+    st = mp.SimplexTreeMulti(st, num_parameters=num_parameters)
+    for p in range(num_parameters):
+        st.fill_lowerstar(np.random.uniform(size=npts), p)
+    return st

multipers/tests/test_diff_helper.py

@@ -0,0 +1,73 @@
+import gudhi as gd
+import numpy as np
+
+import multipers as mp
+
+
+
+def test_h1_rips_density():
+    num_pts = 100
+    dim = 2
+    pts = np.random.uniform(size=(num_pts, dim))
+    weights = np.random.uniform(size=num_pts)
+    st = gd.RipsComplex(points=pts).create_simplex_tree()
+    st = mp.SimplexTreeMulti(st, num_parameters=2)
+    st.fill_lowerstar(weights, parameter=1)
+    st.collapse_edges(num=100)
+    st.expansion(2)
+    # F=st.get_filtration_grid()
+    # st.grid_squeeze(F, coordinate_values=True)
+    (sm,) = mp.signed_measure(st, degree=1, plot=True, mass_default=None)
+    pts, weights = sm
+    sm_indices, unmappable_points = st.pts_to_indices(pts, simplices_dimensions=[1, 0])
+    assert len(unmappable_points) == 0, "Found unmappable points in Rips edges ?"
+    filtration_values = np.array([f for _, f in st.get_simplices()])
+    reconstructed_measure = np.asarray(
+        [
+            [filtration_values[i][parameter] for parameter, i in enumerate(indices)]
+            for indices in sm_indices
+        ]
+    )
+    assert np.array_equal(
+        reconstructed_measure, pts
+    ), "Reconstructed measure is not equal to original measure ?"
+
+
+def test_h0_rips_density():
+    num_pts = 100
+    dim = 2
+    pts = np.random.uniform(size=(num_pts, dim))
+    weights = np.random.uniform(size=num_pts)
+    st = gd.RipsComplex(points=pts).create_simplex_tree()
+    st = mp.SimplexTreeMulti(st, num_parameters=2)
+    st.fill_lowerstar(weights, parameter=1)
+    st.collapse_edges(full=True)
+    # F=st.get_filtration_grid()
+    # st.grid_squeeze(F, coordinate_values=True)
+    (sm,) = mp.signed_measure(st, degree=0, plot=True, mass_default=None)
+    pts, weights = sm
+    _, unmappable_points = st.pts_to_indices(pts, simplices_dimensions=[1, 0])
+    assert (
+        pts[unmappable_points[:, 0]][:, 0] == 0
+    ).all(), "Unmapped points of H0 have to be the nodes of the rips."
+
+
+# def test_h1_rips_density_rank():
+# 	num_pts = 100
+# 	dim=2
+# 	pts = np.random.uniform(size=(num_pts,dim))
+# 	weights = np.random.uniform(size=num_pts)
+# 	st = gd.RipsComplex(points=pts).create_simplex_tree()
+# 	st = mp.SimplexTreeMulti(st, num_parameters=2)
+# 	st.fill_lowerstar(weights, parameter=1)
+# 	st.collapse_edges(full=True)
+# 	st.expansion(2)
+# 	# F=st.get_filtration_grid()
+# 	# st.grid_squeeze(F, coordinate_values=True)
+# 	sm, = mp.signed_measure(st, degree=1, plot=True, mass_default=None, invariant="rank_invariant", resolution=20, grid_strategy="quantile")
+# 	pts, weights = sm
+# 	sm_indices, unmappable_points = signed_measure_indices(st,pts, simplices_dimensions = [1,0])
+# 	assert len(unmappable_points) == 0,  'Found unmappable points in Rips edges ?'
+# 	filtration_values = np.array([f for _,f in st.get_simplices()])
+# 	reconstructed_measure = np.asarray([[filtration_values[i][parameter%2] for parameter,i in enumerate(indices)] for indices in sm_indices])
+# 	assert np.array_equal(reconstructed_measure, pts), 'Reconstructed measure is not equal to original measure ?'

multipers/tests/test_hilbert_function.py

@@ -0,0 +1,82 @@
+import numpy as np
+
+import multipers as mp
+from multipers import signed_measure
+
+
+
+
+# def test_1(): # TODO: test integrate_measure instead
+#     st = mp.SimplexTreeMulti(num_parameters=3)
+#     st.insert([0], [1, 0, 0])
+#     st.insert([1], [0, 1, 0])
+#     st.insert([2], [0, 0, 1])
+#     st.insert([0, 1, 2], [2, 2, 2])
+#     st.make_filtration_non_decreasing()
+#     st = st.grid_squeeze(grid_strategy="exact")
+#     assert np.array_equal(
+#         hilbert_surface(st, degrees=[0])[1],
+#         np.array(
+#             [
+#                 [
+#                     [[0, 1, 1], [1, 2, 2], [1, 2, 2]],
+#                     [[1, 2, 2], [2, 3, 3], [2, 3, 3]],
+#                     [[1, 2, 2], [2, 3, 3], [2, 3, 1]],
+#                 ]
+#             ]
+#         ),
+#     )
+#     assert np.array_equal(hilbert_surface(st, degrees=[0])[1][0], euler_surface(st)[1])
+
+
+# def test_2():
+#     st = mp.SimplexTreeMulti(num_parameters=4)
+#     st.insert([0], [1, 0, 0, 0])
+#     st.insert([1], [0, 1, 0, 0])
+#     st.insert([2], [0, 0, 1, 0])
+#     st.insert([3], [0, 0, 0, 1])
+#     st.insert([0, 1, 2, 3], [2, 2, 2, 2])
+#     st.make_filtration_non_decreasing()
+#     # list(st.get_simplices())
+#     st.grid_squeeze(grid_strategy="exact")
+#     assert np.array_equal(
+#         hilbert_surface(st, degrees=[0])[1][0], (euler_surface(st)[1])
+#     )
+
+
+def test_3():
+    st = mp.SimplexTreeMulti(num_parameters=2)
+    st.insert([0, 1, 2], [1] * st.num_parameters)
+    st.remove_maximal_simplex([0, 1, 2])
+    st = st.grid_squeeze(grid_strategy="exact")
+    ((a, b),) = mp.signed_measure(st, degrees=[1], mass_default=None)
+    assert np.array_equal(a, [[1, 1]]) and np.array_equal(b, [1])
+    assert mp.signed_measure(st, degrees=[1], mass_default="inf")[0][1].sum() == 0
+
+
+def test_4():
+    st = mp.SimplexTreeMulti(num_parameters=3)
+    st.insert([0], [1, 0, 0])
+    st.insert([1], [0, 1, 0])
+    st.insert([2], [0, 0, 1])
+    st.insert([0, 1, 2], [2, 2, 2])
+    st.make_filtration_non_decreasing()
+    # list(st.get_simplices())
+    st.grid_squeeze(grid_strategy="exact")
+    assert signed_measure(st, degrees=[0], mass_default="inf")[0][1].sum() == 0
+
+
+def test_5():
+    num_param = 7
+    st = mp.SimplexTreeMulti(num_parameters=num_param)
+    for i in range(num_param):
+        f = np.zeros(num_param)
+        f[i] = 1
+        st.insert([i], f)
+    st.insert(np.arange(num_param), [2] * num_param)
+    assert not st.make_filtration_non_decreasing()
+    st.grid_squeeze()
+    (a, b), (c, d) = signed_measure(st, degrees=[0, 1])
+    assert np.all(a[-1] == 2)
+    assert np.sum(b) == 1 and b[-1] == -(num_param - 1)
+    assert c.shape == (0, num_param)

multipers/tests/test_mma.py

@@ -0,0 +1,83 @@
+import numpy as np
+import pytest
+
+import multipers as mp
+import multipers.ml.mma as mma
+from multipers.tests import 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])
+    mma_pymodule = st.persistence_approximation()
+    assert np.array_equal(mma_pymodule[0].get_birth_list(), [[0.0, 1.0], [1.0, 0.0]])
+    assert np.array_equal(mma_pymodule[0].get_death_list(), [[np.inf, np.inf]])
+
+
+def test_img():
+    simplextree = mp.SimplexTreeMulti(num_parameters=4)
+    simplextree.insert([0], [1, 2, 3, 4])
+    mod = simplextree.persistence_approximation(
+        box=[[0, 0, 0, 0], [5, 5, 5, 5]], max_error=1.0
+    )
+    img = mod.representation(resolution=6, kernel="linear")
+    assert np.isclose(img[0, 2, 3, 4, 5], 0.5)
+    assert np.isclose(img[0, 1, 1, 1, 1], 0)
+    assert np.isclose(img[0, 3, 4, 5, 5], 1)
+
+
+@pytest.mark.parametrize("n_jobs", [1, 2])
+@pytest.mark.parametrize("prune_degrees_above", [0, 1, None])
+def test_pipeline1(prune_degrees_above, n_jobs):
+    args = locals()
+    st = random_st(npts=50, max_dim=1).collapse_edges(-2)
+    st.expansion(2)
+    (truc1,) = mma.FilteredComplex2MMA(**args).fit_transform([[st]])[0]
+    (truc2,) = mma.FilteredComplex2MMA(**args).fit_transform([[mp.Slicer(st)]])[0]
+    box = st.filtration_bounds()
+    st_copy = st.copy()
+    if prune_degrees_above is not None:
+        st_copy.prune_above_dimension(prune_degrees_above)
+    output = mp.module_approximation(st_copy, box=box).representation(
+        bandwidth=0.1, kernel="linear"
+    )
+    assert np.sum(output) > 0, "Invalid mma rpz"
+    assert np.array_equal(
+        truc1.representation(bandwidth=0.1, kernel="linear"),
+        truc2.representation(bandwidth=0.1, kernel="linear"),
+    ), "Slicer == Simplextree not satisfied"
+    assert np.array_equal(truc1.representation(bandwidth=0.1, kernel="linear"), output)
+
+    st = [random_st(npts=50).collapse_edges(-2, ignore_warning=True) for _ in range(5)]
+    some_fited_pipeline = mma.FilteredComplex2MMA(**args).fit([st])
+    truc1 = some_fited_pipeline.transform([st])
+    truc2 = mma.FilteredComplex2MMA(**args).fit_transform(
+        [[mp.Slicer(truc) for truc in st]]
+    )
+    for a, b in zip(truc1, truc2):
+        assert np.array_equal(
+            a[0].representation(bandwidth=0.01, kernel="linear"),
+            b[0].representation(bandwidth=0.01, kernel="linear"),
+        ), "Slicer == Simplextree not satisfied"
+
+
+@pytest.mark.parametrize("n_jobs", [1, 2])
+@pytest.mark.parametrize("prune_degrees_above", [1, None])
+@pytest.mark.parametrize("expand_dim", [None, 2, 3])
+def test_pipeline2(prune_degrees_above, n_jobs, expand_dim):
+    args = locals()
+    st = random_st(max_dim=1)
+    st.collapse_edges(-2)
+    truc = mma.FilteredComplex2MMA(**args).fit_transform([[st]])[0]
+    box = st.filtration_bounds()
+    st_copy = st.copy()
+    # if prune_degrees_above is not None:
+    #     st_copy.prune_above_dimension(prune_degrees_above)
+    if expand_dim is not None:
+        st_copy.expansion(expand_dim)
+
+    output = mp.module_approximation(st_copy, box=box).representation(bandwidth=0.01)
+    assert np.array_equal(truc[0].representation(bandwidth=-0.01), output)

multipers/tests/test_point_clouds.py

@@ -0,0 +1,49 @@
+import numpy as np
+
+import multipers as mp
+import pytest
+import platform 
+np.random.seed(0)
+
+
+@pytest.mark.skipif(
+    platform.system() == "Windows",
+    reason="Detected windows. Pykeops is not compatible with windows yet. Skipping this ftm.",
+)
+def test_throw_test():
+    import multipers.ml.point_clouds as mmp
+    pts = np.array([[1, 1], [2, 2]], dtype=np.float32)
+    st = mmp.PointCloud2FilteredComplex(masses=[0.1]).fit_transform([pts])[0][0]
+    assert isinstance(st, mp.simplex_tree_multi.SimplexTreeMulti_type)
+    st = mmp.PointCloud2FilteredComplex(bandwidths=[-0.1], complex="alpha").fit_transform(
+        [pts]
+    )[0][0]
+    assert isinstance(st, mp.simplex_tree_multi.SimplexTreeMulti_type)
+
+    st = mmp.PointCloud2FilteredComplex(masses=[0.1], complex="alpha", output_type="slicer_novine").fit_transform(
+        [pts]
+    )[0][0]
+    assert isinstance(st, mp.slicer.Slicer_type)
+    assert st.is_vine is False
+
+    st = mmp.PointCloud2FilteredComplex(masses=[0.1], complex="alpha", output_type="slicer").fit_transform(
+        [pts]
+    )[0][0]
+    assert isinstance(st, mp.slicer.Slicer_type)
+    assert st.is_vine
+
+    st1, st2 = mmp.PointCloud2FilteredComplex(bandwidths=[0.1], masses=[0.1]).fit_transform(
+        [pts]
+    )[0]
+    assert isinstance(st1, mp.simplex_tree_multi.SimplexTreeMulti_type)
+    assert isinstance(st2, mp.simplex_tree_multi.SimplexTreeMulti_type)
+    ## ensures it doesn't throw
+    assert isinstance(
+        mp.module_approximation(st),
+        mp.multiparameter_module_approximation.PyModule_type,
+    )
+    assert mp.signed_measure(st, degree=None, invariant="euler")[0][0].ndim == 2
+    assert mp.signed_measure(st, degree=0, invariant="hilbert")[0][0].ndim == 2
+    assert mp.signed_measure(st, degree=0, invariant="rank")[0][0].ndim == 2
+    assert mp.signed_measure(st, degree=0, invariant="rank")[0][0].shape[1] == 4
+

multipers/tests/test_python-cpp_conversion.py

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

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