multipers 2.0.0__cp310-cp310-macosx_13_0_arm64.whl

multipers/tensor.pxd

@@ -0,0 +1,13 @@
+from libc.stdint cimport uint16_t
+from libcpp.vector cimport vector
+from libcpp cimport bool, float
+
+
+ctypedef float dtype
+ctypedef uint16_t index_type
+
+cdef extern from "tensor/tensor.h" namespace "tensor":
+	cdef cppclass static_tensor_view[float, uint16_t]:
+		static_tensor_view()   except + nogil
+		static_tensor_view(dtype*,const  vector[index_type]&) except + nogil
+		const vector[index_type]& get_resolution() 

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,40 @@
+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(sm1, sm2, exact=True, max_error=1e-5):
+    if not exact:
+        from multipers.distances import sm_distance
+
+        for sm1_, sm2_ in zip(sm1, sm2, strict=True):
+            d = sm_distance(sm1_, sm2_)
+            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}"

multipers/tests/old_test_rank_invariant.py

@@ -0,0 +1,91 @@
+import multipers as mp
+import numpy as np 
+from multipers.ml.signed_betti import signed_betti
+from multipers.hilbert_function import hilbert_surface
+from multipers.euler_characteristic import euler_surface
+
+def test_1():
+	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()
+	assert np.array_equal(mp.hilbert(st, grid_shape=[3,3,3], degrees=[0]),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(mp.hilbert(st, grid_shape=[3,3,3], degrees=[0])[0], mp.euler(st, grid_shape=[3,3,3]))
+
+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())
+	assert np.array_equal(hilbert_surface(st, grid_shape=[3,3,3,3], degrees=[0])[1][0],(mp.euler(st, grid_shape=[3,3,3,3], degree=0)))
+
+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])
+	(a,b),  = mp.signed_measure(st, degree=1, mass_default=None)
+	assert np.array_equal(a, [[1,1]]) and np.array_equal(b, [1])
+	assert mp.signed_measure(st, degree=1)[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())
+	assert np.array_equal(signed_betti(mp.euler(st, grid_shape=[3,3,3], degree=0)), mp.euler(st, grid_shape=[3,3,3], degree=0, inverse=True))
+	assert np.array_equal(mp.signed_measure(st, grid_shape=[3,3,3], degree=0, unsparse=True)[0], mp.euler(st, grid_shape=[3,3,3], degree=0, inverse=True, zero_pad=True))
+	assert mp.signed_measure(st, degree=0)[0][1].sum() == 0
+
+
+def test_5():
+	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())
+	assert np.array_equal(signed_betti(mp.hilbert(st, grid_shape=[3,3,3,3], degrees=[0])[0]),mp.euler(st, grid_shape=[3,3,3,3], degree=0, inverse=True))
+	assert np.array_equal(mp.signed_measure(st, grid_shape=[3,3,3,3], degree=0, unsparse=True)[0], mp.euler(st, grid_shape=[3,3,3,3], degree=0, inverse=True, zero_pad=True))
+	assert mp.signed_measure(st, grid_shape=[3,3,3,3], degree=0)[0][1].sum() == 0
+
+def test_6():
+	for num_parameters in range(2,4):
+		st = mp.SimplexTreeMulti(num_parameters=num_parameters)
+		f = np.random.randint(5,size=st.num_parameters)
+		st.insert([0,1], f)
+		st.insert([2,1], f)
+		st.insert([0,3], f)
+		st.insert([3,2], f)
+		tensor = mp.signed_measure(st, degree=1, unsparse=True, mass_default=None, infer_grid=False)[0]
+		print(tensor, f)
+		tensor[*f]-=1
+		assert np.all(tensor == 0), print(np.all(tensor==0))
+
+
+
+

multipers/tests/test_diff_helper.py

@@ -0,0 +1,74 @@
+import gudhi as gd
+import numpy as np
+
+import multipers as mp
+
+mp.simplex_tree_multi.SAFE_CONVERSION = True
+
+
+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
+
+mp.simplex_tree_multi.SAFE_CONVERSION = True
+
+
+# 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,51 @@
+import numpy as np
+
+import multipers as mp
+
+mp.simplex_tree_multi.SAFE_CONVERSION = True
+
+
+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(), [[1.0, 0.0], [0.0, 1.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)
+
+
+# def test_2():
+#     st = mp.SimplexTreeMulti(num_parameters=2)
+#     st.insert([0], [1, 2])
+#     st.insert([0, 1], [2, 2])
+#     mod = st.persistence_approximation(
+#         box=[[0, 0], [4, 4]], slicer_backend="graph", max_error=0.1
+#     )
+#     assert len(mod) == 1
+#     assert np.isclose(
+#         mod.representation(degrees=[0], plot=False, resolution=5, kernel="linear", p=1),
+#         np.array(
+#             [
+#                 [
+#                     [0, 0, 0, 0, 0],
+#                     [0, 0, 0, 0, 0],
+#                     [0, 1, 1, 1, 1],
+#                     [0, 1, 2, 2, 2],
+#                     [0, 1, 2, 2, 2],
+#                 ]
+#             ]
+#         ),
+#     ).all()

multipers/tests/test_point_clouds.py

@@ -0,0 +1,59 @@
+import numpy as np
+
+import multipers as mp
+import multipers.ml.point_clouds as mmp
+from multipers.tests import assert_sm
+
+mp.simplex_tree_multi.SAFE_CONVERSION = True
+np.random.seed(0)
+
+
+def test_throw_test():
+    pts = np.array([[1, 1], [2, 2]], dtype=np.float32)
+    st = mmp.PointCloud2SimplexTree(masses=[0.1]).fit_transform([pts])[0][0]
+    assert isinstance(st, mp.simplex_tree_multi.SimplexTreeMulti_type)
+    st = mmp.PointCloud2SimplexTree(bandwidths=[-0.1], complex="alpha").fit_transform(
+        [pts]
+    )[0][0]
+    assert isinstance(st, mp.simplex_tree_multi.SimplexTreeMulti_type)
+    st1, st2 = mmp.PointCloud2SimplexTree(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(
+        st.persistence_approximation(),
+        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
+
+
+# def test_1():
+#     import multipers.data
+#
+#     pts = mp.data.noisy_annulus(20, 20)
+#     st = mmp.PointCloud2SimplexTree(bandwidths=[-0.5], expand_dim=2).fit_transform(
+#         [pts]
+#     )[0][0]
+#     F = st.get_filtration_grid()
+#     for invariant in ["hilbert", "rank"]:
+#         sm1 = mp.signed_measure(
+#             st.grid_squeeze(F), degree=1, invariant=invariant, mass_default=None
+#         )
+#         st.collapse_edges(-2, ignore_warning=True)
+#         s = mp.Slicer(st, dtype=np.float64)
+#         mp.io._init_external_softwares()
+#         if mp.io.pathes["mpfree"] is None:
+#             from warnings import warn
+#
+#             warn("Could not find mpfree, skipping this test")
+#         else:
+#             s = s.minpres(degree=1).grid_squeeze(F)
+#         sm2 = mp.signed_measure(s, invariant=invariant, degree=1)
+#         assert_sm(
+#             sm1, sm2, exact=False, max_error=0.1
+#         )  ## TODO : Fix this. Error is too large (grid not the same ? )

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."