Spaces:
Sleeping
Sleeping
| # Copyright (c) 2023 NVIDIA CORPORATION. All rights reserved. | |
| # NVIDIA CORPORATION and its licensors retain all intellectual property | |
| # and proprietary rights in and to this software, related documentation | |
| # and any modifications thereto. Any use, reproduction, disclosure or | |
| # distribution of this software and related documentation without an express | |
| # license agreement from NVIDIA CORPORATION is strictly prohibited. | |
| import contextlib | |
| import unittest | |
| import numpy as np | |
| from warp.tests.unittest_utils import * | |
| wp.init() | |
| def nps(dtype, value): | |
| """Creates a NumPy scalar value based on the given data type.""" | |
| # Workaround to avoid deprecation warning messages for integer overflows. | |
| return np.array((value,)).astype(dtype)[0] | |
| def npv(dtype, values): | |
| """Creates a vector of NumPy scalar values based on the given data type.""" | |
| return tuple(nps(dtype, x) for x in values) | |
| def npm(dtype, dim, values): | |
| """Creates a matrix of NumPy scalar values based on the given data type.""" | |
| return tuple(npv(dtype, values[i * dim : (i + 1) * dim]) for i in range(dim)) | |
| def wpv(dtype, values): | |
| """Creates a vector of Warp scalar values based on the given data type.""" | |
| return tuple(dtype(x) for x in values) | |
| def wpm(dtype, dim, values): | |
| """Creates a matrix of Warp scalar values based on the given data type.""" | |
| return tuple(wpv(dtype, values[i * dim : (i + 1) * dim]) for i in range(dim)) | |
| def test_int_arg_support(test, device, dtype): | |
| np_type = wp.types.warp_type_to_np_dtype[dtype] | |
| value = -1234567890123456789 | |
| expected = wp.invert(dtype(value)) | |
| test.assertEqual(wp.invert(nps(np_type, value)), expected) | |
| def test_float_arg_support(test, device, dtype): | |
| np_type = wp.types.warp_type_to_np_dtype[dtype] | |
| value = 1.23 | |
| expected = wp.sin(dtype(value)) | |
| test.assertEqual(wp.sin(nps(np_type, value)), expected) | |
| def test_int_int_args_support(test, device, dtype): | |
| np_type = wp.types.warp_type_to_np_dtype[dtype] | |
| value = -1234567890 | |
| expected = wp.mul(dtype(value), dtype(value)) | |
| test.assertEqual(wp.mul(dtype(value), dtype(value)), expected) | |
| test.assertEqual(wp.mul(dtype(value), nps(np_type, value)), expected) | |
| test.assertEqual(wp.mul(nps(np_type, value), dtype(value)), expected) | |
| test.assertEqual(wp.mul(nps(np_type, value), nps(np_type, value)), expected) | |
| if dtype is wp.int32: | |
| test.assertEqual(wp.mul(dtype(value), value), expected) | |
| test.assertEqual(wp.mul(nps(np_type, value), value), expected) | |
| test.assertEqual(wp.mul(value, value), expected) | |
| test.assertEqual(wp.mul(value, dtype(value)), expected) | |
| test.assertEqual(wp.mul(value, nps(np_type, value)), expected) | |
| else: | |
| with test.assertRaisesRegex( | |
| RuntimeError, | |
| rf"Couldn't find a function 'mul' compatible with " rf"the arguments '{dtype.__name__}, int'$", | |
| ): | |
| wp.mul(dtype(value), value) | |
| with test.assertRaisesRegex( | |
| RuntimeError, | |
| rf"Couldn't find a function 'mul' compatible with " rf"the arguments '{np_type.__name__}, int'$", | |
| ): | |
| wp.mul(nps(np_type, value), value) | |
| with test.assertRaisesRegex( | |
| RuntimeError, | |
| rf"Couldn't find a function 'mul' compatible with " rf"the arguments 'int, {dtype.__name__}'$", | |
| ): | |
| wp.mul(value, dtype(value)) | |
| with test.assertRaisesRegex( | |
| RuntimeError, | |
| rf"Couldn't find a function 'mul' compatible with " rf"the arguments 'int, {np_type.__name__}'$", | |
| ): | |
| wp.mul(value, nps(np_type, value)) | |
| def test_mat_arg_support(test, device, dtype): | |
| np_type = wp.types.warp_type_to_np_dtype[dtype] | |
| mat_cls = wp.types.matrix((3, 3), dtype) | |
| values = (1.23, 2.34, 3.45, 4.56, 5.67, 6.78, 7.89, 8.90, 9.01) | |
| expected = wp.trace(mat_cls(*values)) | |
| with open(os.devnull, "w") as f, contextlib.redirect_stdout(f): | |
| test.assertEqual(wp.trace(wpv(dtype, values)), expected) | |
| test.assertEqual(wp.trace(wpm(dtype, 3, values)), expected) | |
| test.assertEqual(wp.trace(npv(np_type, values)), expected) | |
| test.assertEqual(wp.trace(npm(np_type, 3, values)), expected) | |
| test.assertEqual(wp.trace(np.array(npv(np_type, values))), expected) | |
| def test_mat_mat_args_support(test, device, dtype): | |
| np_type = wp.types.warp_type_to_np_dtype[dtype] | |
| mat_cls = wp.types.matrix((3, 3), dtype) | |
| a_values = (0.12, 1.23, 2.34, 0.12, 1.23, 2.34, 0.12, 1.23, 2.34) | |
| b_values = (2.34, 1.23, 0.12, 2.34, 1.23, 0.12, 2.34, 1.23, 0.12) | |
| expected = wp.ddot(mat_cls(*a_values), mat_cls(*b_values)) | |
| with open(os.devnull, "w") as f, contextlib.redirect_stdout(f): | |
| test.assertEqual(wp.ddot(mat_cls(*a_values), mat_cls(*b_values)), expected) | |
| test.assertEqual(wp.ddot(mat_cls(*a_values), wpv(dtype, b_values)), expected) | |
| test.assertEqual(wp.ddot(mat_cls(*a_values), wpm(dtype, 3, b_values)), expected) | |
| test.assertEqual(wp.ddot(mat_cls(*a_values), npv(np_type, b_values)), expected) | |
| test.assertEqual(wp.ddot(mat_cls(*a_values), npm(np_type, 3, b_values)), expected) | |
| test.assertEqual(wp.ddot(mat_cls(*a_values), np.array(npv(np_type, b_values))), expected) | |
| test.assertEqual(wp.ddot(wpv(dtype, a_values), mat_cls(*b_values)), expected) | |
| test.assertEqual(wp.ddot(wpv(dtype, a_values), wpv(dtype, b_values)), expected) | |
| test.assertEqual(wp.ddot(wpv(dtype, a_values), wpm(dtype, 3, b_values)), expected) | |
| test.assertEqual(wp.ddot(wpv(dtype, a_values), npv(np_type, b_values)), expected) | |
| test.assertEqual(wp.ddot(wpv(dtype, a_values), npm(np_type, 3, b_values)), expected) | |
| test.assertEqual(wp.ddot(wpv(dtype, a_values), np.array(npv(np_type, b_values))), expected) | |
| test.assertEqual(wp.ddot(wpm(dtype, 3, a_values), mat_cls(*b_values)), expected) | |
| test.assertEqual(wp.ddot(wpm(dtype, 3, a_values), wpv(dtype, b_values)), expected) | |
| test.assertEqual(wp.ddot(wpm(dtype, 3, a_values), wpm(dtype, 3, b_values)), expected) | |
| test.assertEqual(wp.ddot(wpm(dtype, 3, a_values), npv(np_type, b_values)), expected) | |
| test.assertEqual(wp.ddot(wpm(dtype, 3, a_values), npm(np_type, 3, b_values)), expected) | |
| test.assertEqual(wp.ddot(wpm(dtype, 3, a_values), np.array(npv(np_type, b_values))), expected) | |
| test.assertEqual(wp.ddot(npv(np_type, a_values), mat_cls(*b_values)), expected) | |
| test.assertEqual(wp.ddot(npv(np_type, a_values), wpv(dtype, b_values)), expected) | |
| test.assertEqual(wp.ddot(npv(np_type, a_values), wpm(dtype, 3, b_values)), expected) | |
| test.assertEqual(wp.ddot(npv(np_type, a_values), npv(np_type, b_values)), expected) | |
| test.assertEqual(wp.ddot(npv(np_type, a_values), npm(np_type, 3, b_values)), expected) | |
| test.assertEqual(wp.ddot(npv(np_type, a_values), np.array(npv(np_type, b_values))), expected) | |
| test.assertEqual(wp.ddot(npm(np_type, 3, a_values), mat_cls(*b_values)), expected) | |
| test.assertEqual(wp.ddot(npm(np_type, 3, a_values), wpv(dtype, b_values)), expected) | |
| test.assertEqual(wp.ddot(npm(np_type, 3, a_values), wpm(dtype, 3, b_values)), expected) | |
| test.assertEqual(wp.ddot(npm(np_type, 3, a_values), npv(np_type, b_values)), expected) | |
| test.assertEqual(wp.ddot(npm(np_type, 3, a_values), npm(np_type, 3, b_values)), expected) | |
| test.assertEqual(wp.ddot(npm(np_type, 3, a_values), np.array(npv(np_type, b_values))), expected) | |
| test.assertEqual(wp.ddot(np.array(npv(np_type, a_values)), mat_cls(*b_values)), expected) | |
| test.assertEqual(wp.ddot(np.array(npv(np_type, a_values)), wpv(dtype, b_values)), expected) | |
| test.assertEqual(wp.ddot(np.array(npv(np_type, a_values)), wpm(dtype, 3, b_values)), expected) | |
| test.assertEqual(wp.ddot(np.array(npv(np_type, a_values)), npv(np_type, b_values)), expected) | |
| test.assertEqual(wp.ddot(np.array(npv(np_type, a_values)), npm(np_type, 3, b_values)), expected) | |
| test.assertEqual(wp.ddot(np.array(npv(np_type, a_values)), np.array(npv(np_type, b_values))), expected) | |
| if dtype is wp.float32: | |
| test.assertEqual(wp.ddot(mat_cls(*a_values), b_values), expected) | |
| test.assertEqual(wp.ddot(wpv(dtype, a_values), b_values), expected) | |
| test.assertEqual(wp.ddot(wpm(dtype, 3, a_values), b_values), expected) | |
| test.assertEqual(wp.ddot(npv(np_type, a_values), b_values), expected) | |
| test.assertEqual(wp.ddot(npm(np_type, 3, a_values), b_values), expected) | |
| test.assertEqual(wp.ddot(a_values, b_values), expected) | |
| test.assertEqual(wp.ddot(np.array(npv(np_type, a_values)), b_values), expected) | |
| test.assertEqual(wp.ddot(a_values, mat_cls(*b_values)), expected) | |
| test.assertEqual(wp.ddot(a_values, wpv(dtype, b_values)), expected) | |
| test.assertEqual(wp.ddot(a_values, wpm(dtype, 3, b_values)), expected) | |
| test.assertEqual(wp.ddot(a_values, npv(np_type, b_values)), expected) | |
| test.assertEqual(wp.ddot(a_values, npm(np_type, 3, b_values)), expected) | |
| test.assertEqual(wp.ddot(a_values, np.array(npv(np_type, b_values))), expected) | |
| else: | |
| with test.assertRaisesRegex( | |
| RuntimeError, | |
| r"Couldn't find a function 'ddot' compatible with " r"the arguments 'mat_t, tuple'$", | |
| ): | |
| wp.ddot(mat_cls(*a_values), b_values) | |
| with test.assertRaisesRegex( | |
| RuntimeError, | |
| r"Couldn't find a function 'ddot' compatible with " r"the arguments 'tuple, tuple'$", | |
| ): | |
| wp.ddot(wpv(dtype, a_values), b_values) | |
| with test.assertRaisesRegex( | |
| RuntimeError, | |
| r"Couldn't find a function 'ddot' compatible with " r"the arguments 'tuple, tuple'$", | |
| ): | |
| wp.ddot(wpm(dtype, 3, a_values), b_values) | |
| with test.assertRaisesRegex( | |
| RuntimeError, | |
| r"Couldn't find a function 'ddot' compatible with " r"the arguments 'tuple, tuple'$", | |
| ): | |
| wp.ddot(npv(np_type, a_values), b_values) | |
| with test.assertRaisesRegex( | |
| RuntimeError, | |
| r"Couldn't find a function 'ddot' compatible with " r"the arguments 'tuple, tuple'$", | |
| ): | |
| wp.ddot(npm(np_type, 3, a_values), b_values) | |
| with test.assertRaisesRegex( | |
| RuntimeError, | |
| r"Couldn't find a function 'ddot' compatible with " r"the arguments 'ndarray, tuple'$", | |
| ): | |
| wp.ddot(np.array(npv(np_type, a_values)), b_values) | |
| with test.assertRaisesRegex( | |
| RuntimeError, | |
| r"Couldn't find a function 'ddot' compatible with " r"the arguments 'tuple, mat_t'$", | |
| ): | |
| wp.ddot(a_values, mat_cls(*b_values)) | |
| with test.assertRaisesRegex( | |
| RuntimeError, | |
| r"Couldn't find a function 'ddot' compatible with " r"the arguments 'tuple, tuple'$", | |
| ): | |
| wp.ddot(a_values, wpv(dtype, b_values)) | |
| with test.assertRaisesRegex( | |
| RuntimeError, | |
| r"Couldn't find a function 'ddot' compatible with " r"the arguments 'tuple, tuple'$", | |
| ): | |
| wp.ddot(a_values, wpm(dtype, 3, b_values)) | |
| with test.assertRaisesRegex( | |
| RuntimeError, | |
| r"Couldn't find a function 'ddot' compatible with " r"the arguments 'tuple, tuple'$", | |
| ): | |
| wp.ddot(a_values, npv(np_type, b_values)) | |
| with test.assertRaisesRegex( | |
| RuntimeError, | |
| r"Couldn't find a function 'ddot' compatible with " r"the arguments 'tuple, tuple'$", | |
| ): | |
| wp.ddot(a_values, npm(np_type, 3, b_values)) | |
| with test.assertRaisesRegex( | |
| RuntimeError, | |
| r"Couldn't find a function 'ddot' compatible with " r"the arguments 'tuple, ndarray'$", | |
| ): | |
| wp.ddot(a_values, np.array(npv(np_type, b_values))) | |
| def test_mat_float_args_support(test, device, dtype): | |
| np_type = wp.types.warp_type_to_np_dtype[dtype] | |
| mat_cls = wp.types.matrix((3, 3), dtype) | |
| a_values = (1.23, 2.34, 3.45, 4.56, 5.67, 6.78, 7.89, 8.90, 9.01) | |
| b_value = 0.12 | |
| expected = wp.mul(mat_cls(*a_values), dtype(b_value)) | |
| with open(os.devnull, "w") as f, contextlib.redirect_stdout(f): | |
| test.assertEqual(wp.mul(mat_cls(*a_values), dtype(b_value)), expected) | |
| test.assertEqual(wp.mul(mat_cls(*a_values), nps(np_type, b_value)), expected) | |
| test.assertEqual(wp.mul(wpv(dtype, a_values), dtype(b_value)), expected) | |
| test.assertEqual(wp.mul(wpv(dtype, a_values), nps(np_type, b_value)), expected) | |
| test.assertEqual(wp.mul(wpm(dtype, 3, a_values), dtype(b_value)), expected) | |
| test.assertEqual(wp.mul(wpm(dtype, 3, a_values), nps(np_type, b_value)), expected) | |
| test.assertEqual(wp.mul(npv(np_type, a_values), dtype(b_value)), expected) | |
| test.assertEqual(wp.mul(npv(np_type, a_values), nps(np_type, b_value)), expected) | |
| test.assertEqual(wp.mul(npm(np_type, 3, a_values), dtype(b_value)), expected) | |
| test.assertEqual(wp.mul(npm(np_type, 3, a_values), nps(np_type, b_value)), expected) | |
| test.assertEqual(wp.mul(np.array(npv(np_type, a_values)), dtype(b_value)), expected) | |
| test.assertEqual(wp.mul(np.array(npv(np_type, a_values)), nps(np_type, b_value)), expected) | |
| if dtype is wp.float32: | |
| test.assertEqual(wp.mul(mat_cls(*a_values), b_value), expected) | |
| test.assertEqual(wp.mul(wpv(dtype, a_values), b_value), expected) | |
| test.assertEqual(wp.mul(wpm(dtype, 3, a_values), b_value), expected) | |
| test.assertEqual(wp.mul(npv(np_type, a_values), b_value), expected) | |
| test.assertEqual(wp.mul(npm(np_type, 3, a_values), b_value), expected) | |
| test.assertEqual(wp.mul(a_values, b_value), expected) | |
| test.assertEqual(wp.mul(np.array(npv(np_type, a_values)), b_value), expected) | |
| test.assertEqual(wp.mul(a_values, dtype(b_value)), expected) | |
| test.assertEqual(wp.mul(a_values, nps(np_type, b_value)), expected) | |
| else: | |
| with test.assertRaisesRegex( | |
| RuntimeError, | |
| r"Couldn't find a function 'mul' compatible with " r"the arguments 'mat_t, float'$", | |
| ): | |
| wp.mul(mat_cls(*a_values), b_value) | |
| with test.assertRaisesRegex( | |
| RuntimeError, | |
| r"Couldn't find a function 'mul' compatible with " r"the arguments 'tuple, float'$", | |
| ): | |
| wp.mul(wpv(dtype, a_values), b_value) | |
| with test.assertRaisesRegex( | |
| RuntimeError, | |
| r"Couldn't find a function 'mul' compatible with " r"the arguments 'tuple, float'$", | |
| ): | |
| wp.mul(wpm(dtype, 3, a_values), b_value) | |
| with test.assertRaisesRegex( | |
| RuntimeError, | |
| r"Couldn't find a function 'mul' compatible with " r"the arguments 'tuple, float'$", | |
| ): | |
| wp.mul(npv(np_type, a_values), b_value) | |
| with test.assertRaisesRegex( | |
| RuntimeError, | |
| r"Couldn't find a function 'mul' compatible with " r"the arguments 'tuple, float'$", | |
| ): | |
| wp.mul(npm(np_type, 3, a_values), b_value) | |
| with test.assertRaisesRegex( | |
| RuntimeError, | |
| r"Couldn't find a function 'mul' compatible with " r"the arguments 'ndarray, float'$", | |
| ): | |
| wp.mul(np.array(npv(np_type, a_values)), b_value) | |
| with test.assertRaisesRegex( | |
| RuntimeError, | |
| rf"Couldn't find a function 'mul' compatible with " rf"the arguments 'tuple, {dtype.__name__}'$", | |
| ): | |
| wp.mul(a_values, dtype(b_value)) | |
| with test.assertRaisesRegex( | |
| RuntimeError, | |
| rf"Couldn't find a function 'mul' compatible with " rf"the arguments 'tuple, {np_type.__name__}'$", | |
| ): | |
| wp.mul(a_values, nps(np_type, b_value)) | |
| def test_vec_arg_support(test, device, dtype): | |
| np_type = wp.types.warp_type_to_np_dtype[dtype] | |
| vec_cls = wp.types.vector(3, dtype) | |
| values = (1.23, 2.34, 3.45) | |
| expected = wp.length(vec_cls(*values)) | |
| with open(os.devnull, "w") as f, contextlib.redirect_stdout(f): | |
| test.assertAlmostEqual(wp.length(wpv(dtype, values)), expected) | |
| test.assertAlmostEqual(wp.length(npv(np_type, values)), expected) | |
| test.assertAlmostEqual(wp.length(np.array(npv(np_type, values))), expected) | |
| def test_vec_vec_args_support(test, device, dtype): | |
| np_type = wp.types.warp_type_to_np_dtype[dtype] | |
| vec_cls = wp.types.vector(3, dtype) | |
| a_values = (1.23, 2.34, 3.45) | |
| b_values = (4.56, 5.67, 6.78) | |
| expected = wp.dot(vec_cls(*a_values), vec_cls(*b_values)) | |
| with open(os.devnull, "w") as f, contextlib.redirect_stdout(f): | |
| test.assertEqual(wp.dot(vec_cls(*a_values), vec_cls(*b_values)), expected) | |
| test.assertEqual(wp.dot(vec_cls(*a_values), wpv(dtype, b_values)), expected) | |
| test.assertEqual(wp.dot(vec_cls(*a_values), npv(np_type, b_values)), expected) | |
| test.assertEqual(wp.dot(vec_cls(*a_values), np.array(npv(np_type, b_values))), expected) | |
| test.assertEqual(wp.dot(wpv(dtype, a_values), vec_cls(*b_values)), expected) | |
| test.assertEqual(wp.dot(wpv(dtype, a_values), wpv(dtype, b_values)), expected) | |
| test.assertEqual(wp.dot(wpv(dtype, a_values), npv(np_type, b_values)), expected) | |
| test.assertEqual(wp.dot(wpv(dtype, a_values), np.array(npv(np_type, b_values))), expected) | |
| test.assertEqual(wp.dot(npv(np_type, a_values), vec_cls(*b_values)), expected) | |
| test.assertEqual(wp.dot(npv(np_type, a_values), wpv(dtype, b_values)), expected) | |
| test.assertEqual(wp.dot(npv(np_type, a_values), npv(np_type, b_values)), expected) | |
| test.assertEqual(wp.dot(npv(np_type, a_values), np.array(npv(np_type, b_values))), expected) | |
| test.assertEqual(wp.dot(np.array(npv(np_type, a_values)), vec_cls(*b_values)), expected) | |
| test.assertEqual(wp.dot(np.array(npv(np_type, a_values)), wpv(dtype, b_values)), expected) | |
| test.assertEqual(wp.dot(np.array(npv(np_type, a_values)), npv(np_type, b_values)), expected) | |
| test.assertEqual(wp.dot(np.array(npv(np_type, a_values)), np.array(npv(np_type, b_values))), expected) | |
| if dtype is wp.float32: | |
| test.assertEqual(wp.dot(vec_cls(*a_values), b_values), expected) | |
| test.assertEqual(wp.dot(wpv(dtype, a_values), b_values), expected) | |
| test.assertEqual(wp.dot(npv(np_type, a_values), b_values), expected) | |
| test.assertEqual(wp.dot(a_values, b_values), expected) | |
| test.assertEqual(wp.dot(np.array(npv(np_type, a_values)), b_values), expected) | |
| test.assertEqual(wp.dot(a_values, vec_cls(*b_values)), expected) | |
| test.assertEqual(wp.dot(a_values, wpv(dtype, b_values)), expected) | |
| test.assertEqual(wp.dot(a_values, npv(np_type, b_values)), expected) | |
| test.assertEqual(wp.dot(a_values, np.array(npv(np_type, b_values))), expected) | |
| else: | |
| with test.assertRaisesRegex( | |
| RuntimeError, | |
| r"Couldn't find a function 'dot' compatible with " r"the arguments 'vec_t, tuple'$", | |
| ): | |
| wp.dot(vec_cls(*a_values), b_values) | |
| with test.assertRaisesRegex( | |
| RuntimeError, | |
| r"Couldn't find a function 'dot' compatible with " r"the arguments 'tuple, tuple'$", | |
| ): | |
| wp.dot(wpv(dtype, a_values), b_values) | |
| with test.assertRaisesRegex( | |
| RuntimeError, | |
| r"Couldn't find a function 'dot' compatible with " r"the arguments 'tuple, tuple'$", | |
| ): | |
| wp.dot(npv(np_type, a_values), b_values) | |
| with test.assertRaisesRegex( | |
| RuntimeError, | |
| r"Couldn't find a function 'dot' compatible with " r"the arguments 'ndarray, tuple'$", | |
| ): | |
| wp.dot(np.array(npv(np_type, a_values)), b_values) | |
| with test.assertRaisesRegex( | |
| RuntimeError, | |
| r"Couldn't find a function 'dot' compatible with " r"the arguments 'tuple, vec_t'$", | |
| ): | |
| wp.dot(a_values, vec_cls(*b_values)) | |
| with test.assertRaisesRegex( | |
| RuntimeError, | |
| r"Couldn't find a function 'dot' compatible with " r"the arguments 'tuple, tuple'$", | |
| ): | |
| wp.dot(a_values, wpv(dtype, b_values)) | |
| with test.assertRaisesRegex( | |
| RuntimeError, | |
| r"Couldn't find a function 'dot' compatible with " r"the arguments 'tuple, tuple'$", | |
| ): | |
| wp.dot(a_values, npv(np_type, b_values)) | |
| with test.assertRaisesRegex( | |
| RuntimeError, | |
| r"Couldn't find a function 'dot' compatible with " r"the arguments 'tuple, ndarray'$", | |
| ): | |
| wp.dot(a_values, np.array(npv(np_type, b_values))) | |
| def test_vec_float_args_support(test, device, dtype): | |
| np_type = wp.types.warp_type_to_np_dtype[dtype] | |
| vec_cls = wp.types.vector(3, dtype) | |
| a_values = (1.23, 2.34, 3.45) | |
| b_value = 4.56 | |
| expected = wp.mul(vec_cls(*a_values), dtype(b_value)) | |
| with open(os.devnull, "w") as f, contextlib.redirect_stdout(f): | |
| test.assertEqual(wp.mul(vec_cls(*a_values), dtype(b_value)), expected) | |
| test.assertEqual(wp.mul(vec_cls(*a_values), nps(np_type, b_value)), expected) | |
| test.assertEqual(wp.mul(wpv(dtype, a_values), dtype(b_value)), expected) | |
| test.assertEqual(wp.mul(wpv(dtype, a_values), nps(np_type, b_value)), expected) | |
| test.assertEqual(wp.mul(npv(np_type, a_values), dtype(b_value)), expected) | |
| test.assertEqual(wp.mul(npv(np_type, a_values), nps(np_type, b_value)), expected) | |
| test.assertEqual(wp.mul(np.array(npv(np_type, a_values)), dtype(b_value)), expected) | |
| test.assertEqual(wp.mul(np.array(npv(np_type, a_values)), nps(np_type, b_value)), expected) | |
| if dtype is wp.float32: | |
| test.assertEqual(wp.mul(vec_cls(*a_values), b_value), expected) | |
| test.assertEqual(wp.mul(wpv(dtype, a_values), b_value), expected) | |
| test.assertEqual(wp.mul(npv(np_type, a_values), b_value), expected) | |
| test.assertEqual(wp.mul(a_values, b_value), expected) | |
| test.assertEqual(wp.mul(np.array(npv(np_type, a_values)), b_value), expected) | |
| test.assertEqual(wp.mul(a_values, dtype(b_value)), expected) | |
| test.assertEqual(wp.mul(a_values, nps(np_type, b_value)), expected) | |
| else: | |
| with test.assertRaisesRegex( | |
| RuntimeError, | |
| r"Couldn't find a function 'mul' compatible with " r"the arguments 'vec_t, float'$", | |
| ): | |
| wp.mul(vec_cls(*a_values), b_value) | |
| with test.assertRaisesRegex( | |
| RuntimeError, | |
| r"Couldn't find a function 'mul' compatible with " r"the arguments 'tuple, float'$", | |
| ): | |
| wp.mul(wpv(dtype, a_values), b_value) | |
| with test.assertRaisesRegex( | |
| RuntimeError, | |
| r"Couldn't find a function 'mul' compatible with " r"the arguments 'tuple, float'$", | |
| ): | |
| wp.mul(npv(np_type, a_values), b_value) | |
| with test.assertRaisesRegex( | |
| RuntimeError, | |
| r"Couldn't find a function 'mul' compatible with " r"the arguments 'ndarray, float'$", | |
| ): | |
| wp.mul(np.array(npv(np_type, a_values)), b_value) | |
| with test.assertRaisesRegex( | |
| RuntimeError, | |
| rf"Couldn't find a function 'mul' compatible with " rf"the arguments 'tuple, {dtype.__name__}'$", | |
| ): | |
| wp.mul(a_values, dtype(b_value)) | |
| with test.assertRaisesRegex( | |
| RuntimeError, | |
| rf"Couldn't find a function 'mul' compatible with " rf"the arguments 'tuple, {np_type.__name__}'$", | |
| ): | |
| wp.mul(a_values, nps(np_type, b_value)) | |
| class TestBuiltinsResolution(unittest.TestCase): | |
| def test_int_arg_overflow(self): | |
| value = -1234567890123456789 | |
| self.assertEqual(wp.invert(wp.int8(value)), 20) | |
| self.assertEqual(wp.invert(wp.int16(value)), -32492) | |
| self.assertEqual(wp.invert(wp.int32(value)), 2112454932) | |
| self.assertEqual(wp.invert(wp.int64(value)), 1234567890123456788) | |
| self.assertEqual(wp.invert(wp.uint8(value)), 20) | |
| self.assertEqual(wp.invert(wp.uint16(value)), 33044) | |
| self.assertEqual(wp.invert(wp.uint32(value)), 2112454932) | |
| self.assertEqual(wp.invert(wp.uint64(value)), 1234567890123456788) | |
| self.assertEqual(wp.invert(value), wp.invert(wp.int32(value))) | |
| def test_float_arg_precision(self): | |
| value = 1.23 | |
| expected = 0.94248880193169748409 | |
| result = wp.sin(wp.float64(value)) | |
| self.assertAlmostEqual(result, expected, places=12) | |
| result = wp.sin(wp.float32(value)) | |
| self.assertNotAlmostEqual(result, expected, places=12) | |
| self.assertAlmostEqual(result, expected, places=5) | |
| result = wp.sin(wp.float16(value)) | |
| self.assertNotAlmostEqual(result, expected, places=5) | |
| self.assertAlmostEqual(result, expected, places=1) | |
| self.assertEqual(wp.sin(value), wp.sin(wp.float32(value))) | |
| def test_int_int_args_overflow(self): | |
| value = -1234567890 | |
| self.assertEqual(wp.mul(wp.int8(value), wp.int8(value)), 68) | |
| self.assertEqual(wp.mul(wp.int16(value), wp.int16(value)), -3004) | |
| self.assertEqual(wp.mul(wp.int32(value), wp.int32(value)), 304084036) | |
| self.assertEqual(wp.mul(wp.int64(value), wp.int64(value)), 1524157875019052100) | |
| self.assertEqual(wp.mul(wp.uint8(value), wp.uint8(value)), 68) | |
| self.assertEqual(wp.mul(wp.uint16(value), wp.uint16(value)), 62532) | |
| self.assertEqual(wp.mul(wp.uint32(value), wp.uint32(value)), 304084036) | |
| self.assertEqual(wp.mul(wp.uint64(value), wp.uint64(value)), 1524157875019052100) | |
| self.assertEqual(wp.mul(value, value), wp.mul(wp.int32(value), wp.int32(value))) | |
| def test_mat22_arg_precision(self): | |
| values = (1.23, 2.34, 3.45, 4.56) | |
| values_2d = (values[0:2], values[2:4]) | |
| expected = 5.78999999999999914735 | |
| result = wp.trace(wp.mat22d(*values)) | |
| self.assertAlmostEqual(result, expected, places=12) | |
| result = wp.trace(wp.mat22f(*values)) | |
| self.assertNotAlmostEqual(result, expected, places=12) | |
| self.assertAlmostEqual(result, expected, places=5) | |
| result = wp.trace(wp.mat22h(*values)) | |
| self.assertNotAlmostEqual(result, expected, places=5) | |
| self.assertAlmostEqual(result, expected, places=1) | |
| with open(os.devnull, "w") as f, contextlib.redirect_stdout(f): | |
| self.assertEqual(wp.trace(values), wp.trace(wp.mat22f(*values))) | |
| self.assertEqual(wp.trace(values_2d), wp.trace(wp.mat22f(*values))) | |
| def test_mat33_arg_precision(self): | |
| values = (1.23, 2.34, 3.45, 4.56, 5.67, 6.78, 7.89, 8.90, 9.01) | |
| values_2d = (values[0:3], values[3:6], values[6:9]) | |
| expected = 15.91000000000000014211 | |
| result = wp.trace(wp.mat33d(*values)) | |
| self.assertAlmostEqual(result, expected, places=12) | |
| result = wp.trace(wp.mat33f(*values)) | |
| self.assertNotAlmostEqual(result, expected, places=12) | |
| self.assertAlmostEqual(result, expected, places=5) | |
| result = wp.trace(wp.mat33h(*values)) | |
| self.assertNotAlmostEqual(result, expected, places=5) | |
| self.assertAlmostEqual(result, expected, places=1) | |
| with open(os.devnull, "w") as f, contextlib.redirect_stdout(f): | |
| self.assertEqual(wp.trace(values), wp.trace(wp.mat33f(*values))) | |
| self.assertEqual(wp.trace(values_2d), wp.trace(wp.mat33f(*values))) | |
| def test_mat44_arg_precision(self): | |
| values = (1.23, 2.34, 3.45, 4.56, 5.67, 6.78, 7.89, 8.90, 9.01, 10.12, 11.23, 12.34, 13.45, 14.56, 15.67, 16.78) | |
| values_2d = (values[0:4], values[4:8], values[8:12], values[12:16]) | |
| expected = 36.02000000000000312639 | |
| result = wp.trace(wp.mat44d(*values)) | |
| self.assertAlmostEqual(result, expected, places=12) | |
| result = wp.trace(wp.mat44f(*values)) | |
| self.assertNotAlmostEqual(result, expected, places=12) | |
| self.assertAlmostEqual(result, expected, places=5) | |
| result = wp.trace(wp.mat44h(*values)) | |
| self.assertNotAlmostEqual(result, expected, places=5) | |
| self.assertAlmostEqual(result, expected, places=1) | |
| with open(os.devnull, "w") as f, contextlib.redirect_stdout(f): | |
| self.assertEqual(wp.trace(values), wp.trace(wp.mat44f(*values))) | |
| self.assertEqual(wp.trace(values_2d), wp.trace(wp.mat44f(*values))) | |
| def test_mat22_mat22_args_precision(self): | |
| a_values = (0.12, 1.23, 0.12, 1.23) | |
| a_values_2d = (a_values[0:2], a_values[2:4]) | |
| b_values = (1.23, 0.12, 1.23, 0.12) | |
| b_values_2d = (b_values[0:2], b_values[2:4]) | |
| expected = 0.59039999999999992486 | |
| result = wp.ddot(wp.mat22d(*a_values), wp.mat22d(*b_values)) | |
| self.assertAlmostEqual(result, expected, places=12) | |
| result = wp.ddot(wp.mat22f(*a_values), wp.mat22f(*b_values)) | |
| self.assertNotAlmostEqual(result, expected, places=12) | |
| self.assertAlmostEqual(result, expected, places=5) | |
| result = wp.ddot(wp.mat22h(*a_values), wp.mat22h(*b_values)) | |
| self.assertNotAlmostEqual(result, expected, places=5) | |
| self.assertAlmostEqual(result, expected, places=1) | |
| with open(os.devnull, "w") as f, contextlib.redirect_stdout(f): | |
| self.assertEqual(wp.ddot(a_values, b_values), wp.ddot(wp.mat22f(*a_values), wp.mat22f(*b_values))) | |
| self.assertEqual(wp.ddot(a_values_2d, b_values_2d), wp.ddot(wp.mat22f(*a_values), wp.mat22f(*b_values))) | |
| self.assertEqual(wp.ddot(a_values, b_values_2d), wp.ddot(wp.mat22f(*a_values), wp.mat22f(*b_values))) | |
| self.assertEqual(wp.ddot(a_values_2d, b_values), wp.ddot(wp.mat22f(*a_values), wp.mat22f(*b_values))) | |
| def test_mat33_mat33_args_precision(self): | |
| a_values = (0.12, 1.23, 2.34, 0.12, 1.23, 2.34, 0.12, 1.23, 2.34) | |
| a_values_2d = (a_values[0:3], a_values[3:6], a_values[6:9]) | |
| b_values = (2.34, 1.23, 0.12, 2.34, 1.23, 0.12, 2.34, 1.23, 0.12) | |
| b_values_2d = (b_values[0:3], b_values[3:6], b_values[6:9]) | |
| expected = 6.22350000000000047606 | |
| result = wp.ddot(wp.mat33d(*a_values), wp.mat33d(*b_values)) | |
| self.assertAlmostEqual(result, expected, places=12) | |
| result = wp.ddot(wp.mat33f(*a_values), wp.mat33f(*b_values)) | |
| self.assertNotAlmostEqual(result, expected, places=12) | |
| self.assertAlmostEqual(result, expected, places=5) | |
| result = wp.ddot(wp.mat33h(*a_values), wp.mat33h(*b_values)) | |
| self.assertNotAlmostEqual(result, expected, places=5) | |
| self.assertAlmostEqual(result, expected, places=1) | |
| with open(os.devnull, "w") as f, contextlib.redirect_stdout(f): | |
| self.assertEqual(wp.ddot(a_values, b_values), wp.ddot(wp.mat33f(*a_values), wp.mat33f(*b_values))) | |
| self.assertEqual(wp.ddot(a_values_2d, b_values_2d), wp.ddot(wp.mat33f(*a_values), wp.mat33f(*b_values))) | |
| self.assertEqual(wp.ddot(a_values, b_values_2d), wp.ddot(wp.mat33f(*a_values), wp.mat33f(*b_values))) | |
| self.assertEqual(wp.ddot(a_values_2d, b_values), wp.ddot(wp.mat33f(*a_values), wp.mat33f(*b_values))) | |
| def test_mat44_mat44_args(self): | |
| a_values = (0.12, 1.23, 2.34, 3.45, 0.12, 1.23, 2.34, 3.45, 0.12, 1.23, 2.34, 3.45, 0.12, 1.23, 2.34, 3.45) | |
| a_values_2d = (a_values[0:4], a_values[4:8], a_values[8:12], a_values[12:16]) | |
| b_values = (3.45, 2.34, 1.23, 0.12, 3.45, 2.34, 1.23, 0.12, 3.45, 2.34, 1.23, 0.12, 3.45, 2.34, 1.23, 0.12) | |
| b_values_2d = (b_values[0:4], b_values[4:8], b_values[8:12], b_values[12:16]) | |
| expected = 26.33760000000000189857 | |
| result = wp.ddot(wp.mat44d(*a_values), wp.mat44d(*b_values)) | |
| self.assertAlmostEqual(result, expected, places=12) | |
| result = wp.ddot(wp.mat44f(*a_values), wp.mat44f(*b_values)) | |
| self.assertNotAlmostEqual(result, expected, places=12) | |
| self.assertAlmostEqual(result, expected, places=5) | |
| result = wp.ddot(wp.mat44h(*a_values), wp.mat44h(*b_values)) | |
| self.assertNotAlmostEqual(result, expected, places=5) | |
| self.assertAlmostEqual(result, expected, places=1) | |
| with open(os.devnull, "w") as f, contextlib.redirect_stdout(f): | |
| self.assertEqual(wp.ddot(a_values, b_values), wp.ddot(wp.mat44f(*a_values), wp.mat44f(*b_values))) | |
| self.assertEqual(wp.ddot(a_values_2d, b_values_2d), wp.ddot(wp.mat44f(*a_values), wp.mat44f(*b_values))) | |
| self.assertEqual(wp.ddot(a_values, b_values_2d), wp.ddot(wp.mat44f(*a_values), wp.mat44f(*b_values))) | |
| self.assertEqual(wp.ddot(a_values_2d, b_values), wp.ddot(wp.mat44f(*a_values), wp.mat44f(*b_values))) | |
| def test_mat22_float_args_precision(self): | |
| a_values = (1.23, 2.34, 3.45, 4.56) | |
| a_values_2d = (a_values[0:2], a_values[2:4]) | |
| b_value = 0.12 | |
| expected_00 = 0.14759999999999998122 | |
| expected_01 = 0.28079999999999999405 | |
| expected_10 = 0.41399999999999997913 | |
| expected_11 = 0.54719999999999990870 | |
| result = wp.mul(wp.mat22d(*a_values), wp.float64(b_value)) | |
| self.assertAlmostEqual(result[0][0], expected_00, places=12) | |
| self.assertAlmostEqual(result[0][1], expected_01, places=12) | |
| self.assertAlmostEqual(result[1][0], expected_10, places=12) | |
| self.assertAlmostEqual(result[1][1], expected_11, places=12) | |
| result = wp.mul(wp.mat22f(*a_values), wp.float32(b_value)) | |
| self.assertNotAlmostEqual(result[0][0], expected_00, places=12) | |
| self.assertNotAlmostEqual(result[0][1], expected_01, places=12) | |
| self.assertNotAlmostEqual(result[1][0], expected_10, places=12) | |
| self.assertNotAlmostEqual(result[1][1], expected_11, places=12) | |
| self.assertAlmostEqual(result[0][0], expected_00, places=5) | |
| self.assertAlmostEqual(result[0][1], expected_01, places=5) | |
| self.assertAlmostEqual(result[1][0], expected_10, places=5) | |
| self.assertAlmostEqual(result[1][1], expected_11, places=5) | |
| result = wp.mul(wp.mat22h(*a_values), wp.float16(b_value)) | |
| self.assertNotAlmostEqual(result[0][0], expected_00, places=5) | |
| self.assertNotAlmostEqual(result[0][1], expected_01, places=5) | |
| self.assertNotAlmostEqual(result[1][0], expected_10, places=5) | |
| self.assertNotAlmostEqual(result[1][1], expected_11, places=5) | |
| self.assertAlmostEqual(result[0][0], expected_00, places=1) | |
| self.assertAlmostEqual(result[0][1], expected_01, places=1) | |
| self.assertAlmostEqual(result[1][0], expected_10, places=1) | |
| self.assertAlmostEqual(result[1][1], expected_11, places=1) | |
| with open(os.devnull, "w") as f, contextlib.redirect_stdout(f): | |
| # Multiplying a 1-D tuple of length 4 is ambiguous because it could match | |
| # either the `vec4f` or `mat22f` overload. As a result, only the 2-D variant | |
| # of the tuple is expected to resolve correctly. | |
| self.assertEqual(wp.mul(a_values_2d, b_value), wp.mul(wp.mat22f(*a_values), wp.float32(b_value))) | |
| def test_mat33_float_args_precision(self): | |
| a_values = (1.23, 2.34, 3.45, 4.56, 5.67, 6.78, 7.89, 8.90, 9.01) | |
| a_values_2d = (a_values[0:3], a_values[3:6], a_values[6:9]) | |
| b_value = 0.12 | |
| expected_00 = 0.14759999999999998122 | |
| expected_01 = 0.28079999999999999405 | |
| expected_02 = 0.41399999999999997913 | |
| expected_10 = 0.54719999999999990870 | |
| expected_11 = 0.68040000000000000480 | |
| expected_12 = 0.81359999999999998987 | |
| expected_20 = 0.94679999999999997495 | |
| expected_21 = 1.06800000000000006040 | |
| expected_22 = 1.08119999999999993889 | |
| result = wp.mul(wp.mat33d(*a_values), wp.float64(b_value)) | |
| self.assertAlmostEqual(result[0][0], expected_00, places=12) | |
| self.assertAlmostEqual(result[0][1], expected_01, places=12) | |
| self.assertAlmostEqual(result[0][2], expected_02, places=12) | |
| self.assertAlmostEqual(result[1][0], expected_10, places=12) | |
| self.assertAlmostEqual(result[1][1], expected_11, places=12) | |
| self.assertAlmostEqual(result[1][2], expected_12, places=12) | |
| self.assertAlmostEqual(result[2][0], expected_20, places=12) | |
| self.assertAlmostEqual(result[2][1], expected_21, places=12) | |
| self.assertAlmostEqual(result[2][2], expected_22, places=12) | |
| result = wp.mul(wp.mat33f(*a_values), wp.float32(b_value)) | |
| self.assertNotAlmostEqual(result[0][0], expected_00, places=12) | |
| self.assertNotAlmostEqual(result[0][1], expected_01, places=12) | |
| self.assertNotAlmostEqual(result[0][2], expected_02, places=12) | |
| self.assertNotAlmostEqual(result[1][0], expected_10, places=12) | |
| self.assertNotAlmostEqual(result[1][1], expected_11, places=12) | |
| self.assertNotAlmostEqual(result[1][2], expected_12, places=12) | |
| self.assertNotAlmostEqual(result[2][0], expected_20, places=12) | |
| self.assertNotAlmostEqual(result[2][1], expected_21, places=12) | |
| self.assertNotAlmostEqual(result[2][2], expected_22, places=12) | |
| self.assertAlmostEqual(result[0][0], expected_00, places=5) | |
| self.assertAlmostEqual(result[0][1], expected_01, places=5) | |
| self.assertAlmostEqual(result[0][2], expected_02, places=5) | |
| self.assertAlmostEqual(result[1][0], expected_10, places=5) | |
| self.assertAlmostEqual(result[1][1], expected_11, places=5) | |
| self.assertAlmostEqual(result[1][2], expected_12, places=5) | |
| self.assertAlmostEqual(result[2][0], expected_20, places=5) | |
| self.assertAlmostEqual(result[2][1], expected_21, places=5) | |
| self.assertAlmostEqual(result[2][2], expected_22, places=5) | |
| result = wp.mul(wp.mat33h(*a_values), wp.float16(b_value)) | |
| self.assertNotAlmostEqual(result[0][0], expected_00, places=5) | |
| self.assertNotAlmostEqual(result[0][1], expected_01, places=5) | |
| self.assertNotAlmostEqual(result[0][2], expected_02, places=5) | |
| self.assertNotAlmostEqual(result[1][0], expected_10, places=5) | |
| self.assertNotAlmostEqual(result[1][1], expected_11, places=5) | |
| self.assertNotAlmostEqual(result[1][2], expected_12, places=5) | |
| self.assertNotAlmostEqual(result[2][0], expected_20, places=5) | |
| self.assertNotAlmostEqual(result[2][1], expected_21, places=5) | |
| self.assertNotAlmostEqual(result[2][2], expected_22, places=5) | |
| self.assertAlmostEqual(result[0][0], expected_00, places=1) | |
| self.assertAlmostEqual(result[0][1], expected_01, places=1) | |
| self.assertAlmostEqual(result[0][2], expected_02, places=1) | |
| self.assertAlmostEqual(result[1][0], expected_10, places=1) | |
| self.assertAlmostEqual(result[1][1], expected_11, places=1) | |
| self.assertAlmostEqual(result[1][2], expected_12, places=1) | |
| self.assertAlmostEqual(result[2][0], expected_20, places=1) | |
| self.assertAlmostEqual(result[2][1], expected_21, places=1) | |
| self.assertAlmostEqual(result[2][2], expected_22, places=1) | |
| with open(os.devnull, "w") as f, contextlib.redirect_stdout(f): | |
| self.assertEqual(wp.mul(a_values, b_value), wp.mul(wp.mat33f(*a_values), wp.float32(b_value))) | |
| self.assertEqual(wp.mul(a_values_2d, b_value), wp.mul(wp.mat33f(*a_values), wp.float32(b_value))) | |
| def test_mat44_float_args_precision(self): | |
| a_values = ( | |
| 1.23, | |
| 2.34, | |
| 3.45, | |
| 4.56, | |
| 5.67, | |
| 6.78, | |
| 7.89, | |
| 8.90, | |
| 9.01, | |
| 10.12, | |
| 11.23, | |
| 12.34, | |
| 13.45, | |
| 14.56, | |
| 15.67, | |
| 16.78, | |
| ) | |
| a_values_2d = (a_values[0:4], a_values[4:8], a_values[8:12], a_values[12:16]) | |
| b_value = 0.12 | |
| expected_00 = 0.14759999999999998122 | |
| expected_01 = 0.28079999999999999405 | |
| expected_02 = 0.41399999999999997913 | |
| expected_03 = 0.54719999999999990870 | |
| expected_10 = 0.68040000000000000480 | |
| expected_11 = 0.81359999999999998987 | |
| expected_12 = 0.94679999999999997495 | |
| expected_13 = 1.06800000000000006040 | |
| expected_20 = 1.08119999999999993889 | |
| expected_21 = 1.21439999999999992397 | |
| expected_22 = 1.34759999999999990905 | |
| expected_23 = 1.48079999999999989413 | |
| expected_30 = 1.61399999999999987921 | |
| expected_31 = 1.74720000000000008633 | |
| expected_32 = 1.88039999999999984936 | |
| expected_33 = 2.01360000000000027853 | |
| result = wp.mul(wp.mat44d(*a_values), wp.float64(b_value)) | |
| self.assertAlmostEqual(result[0][0], expected_00, places=12) | |
| self.assertAlmostEqual(result[0][1], expected_01, places=12) | |
| self.assertAlmostEqual(result[0][2], expected_02, places=12) | |
| self.assertAlmostEqual(result[0][3], expected_03, places=12) | |
| self.assertAlmostEqual(result[1][0], expected_10, places=12) | |
| self.assertAlmostEqual(result[1][1], expected_11, places=12) | |
| self.assertAlmostEqual(result[1][2], expected_12, places=12) | |
| self.assertAlmostEqual(result[1][3], expected_13, places=12) | |
| self.assertAlmostEqual(result[2][0], expected_20, places=12) | |
| self.assertAlmostEqual(result[2][1], expected_21, places=12) | |
| self.assertAlmostEqual(result[2][2], expected_22, places=12) | |
| self.assertAlmostEqual(result[2][3], expected_23, places=12) | |
| self.assertAlmostEqual(result[3][0], expected_30, places=12) | |
| self.assertAlmostEqual(result[3][1], expected_31, places=12) | |
| self.assertAlmostEqual(result[3][2], expected_32, places=12) | |
| self.assertAlmostEqual(result[3][3], expected_33, places=12) | |
| result = wp.mul(wp.mat44f(*a_values), wp.float32(b_value)) | |
| self.assertNotAlmostEqual(result[0][0], expected_00, places=12) | |
| self.assertNotAlmostEqual(result[0][1], expected_01, places=12) | |
| self.assertNotAlmostEqual(result[0][2], expected_02, places=12) | |
| self.assertNotAlmostEqual(result[0][3], expected_03, places=12) | |
| self.assertNotAlmostEqual(result[1][0], expected_10, places=12) | |
| self.assertNotAlmostEqual(result[1][1], expected_11, places=12) | |
| self.assertNotAlmostEqual(result[1][2], expected_12, places=12) | |
| self.assertNotAlmostEqual(result[1][3], expected_13, places=12) | |
| self.assertNotAlmostEqual(result[2][0], expected_20, places=12) | |
| self.assertNotAlmostEqual(result[2][1], expected_21, places=12) | |
| self.assertNotAlmostEqual(result[2][2], expected_22, places=12) | |
| self.assertNotAlmostEqual(result[2][3], expected_23, places=12) | |
| self.assertNotAlmostEqual(result[3][0], expected_30, places=12) | |
| self.assertNotAlmostEqual(result[3][1], expected_31, places=12) | |
| self.assertNotAlmostEqual(result[3][2], expected_32, places=12) | |
| self.assertNotAlmostEqual(result[3][3], expected_33, places=12) | |
| self.assertAlmostEqual(result[0][0], expected_00, places=5) | |
| self.assertAlmostEqual(result[0][1], expected_01, places=5) | |
| self.assertAlmostEqual(result[0][2], expected_02, places=5) | |
| self.assertAlmostEqual(result[0][3], expected_03, places=5) | |
| self.assertAlmostEqual(result[1][0], expected_10, places=5) | |
| self.assertAlmostEqual(result[1][1], expected_11, places=5) | |
| self.assertAlmostEqual(result[1][2], expected_12, places=5) | |
| self.assertAlmostEqual(result[1][3], expected_13, places=5) | |
| self.assertAlmostEqual(result[2][0], expected_20, places=5) | |
| self.assertAlmostEqual(result[2][1], expected_21, places=5) | |
| self.assertAlmostEqual(result[2][2], expected_22, places=5) | |
| self.assertAlmostEqual(result[2][3], expected_23, places=5) | |
| self.assertAlmostEqual(result[3][0], expected_30, places=5) | |
| self.assertAlmostEqual(result[3][1], expected_31, places=5) | |
| self.assertAlmostEqual(result[3][2], expected_32, places=5) | |
| self.assertAlmostEqual(result[3][3], expected_33, places=5) | |
| result = wp.mul(wp.mat44h(*a_values), wp.float16(b_value)) | |
| self.assertNotAlmostEqual(result[0][0], expected_00, places=5) | |
| self.assertNotAlmostEqual(result[0][1], expected_01, places=5) | |
| self.assertNotAlmostEqual(result[0][2], expected_02, places=5) | |
| self.assertNotAlmostEqual(result[0][3], expected_03, places=5) | |
| self.assertNotAlmostEqual(result[1][0], expected_10, places=5) | |
| self.assertNotAlmostEqual(result[1][1], expected_11, places=5) | |
| self.assertNotAlmostEqual(result[1][2], expected_12, places=5) | |
| self.assertNotAlmostEqual(result[1][3], expected_13, places=5) | |
| self.assertNotAlmostEqual(result[2][0], expected_20, places=5) | |
| self.assertNotAlmostEqual(result[2][1], expected_21, places=5) | |
| self.assertNotAlmostEqual(result[2][2], expected_22, places=5) | |
| self.assertNotAlmostEqual(result[2][3], expected_23, places=5) | |
| self.assertNotAlmostEqual(result[3][0], expected_30, places=5) | |
| self.assertNotAlmostEqual(result[3][1], expected_31, places=5) | |
| self.assertNotAlmostEqual(result[3][2], expected_32, places=5) | |
| self.assertNotAlmostEqual(result[3][3], expected_33, places=5) | |
| self.assertAlmostEqual(result[0][0], expected_00, places=1) | |
| self.assertAlmostEqual(result[0][1], expected_01, places=1) | |
| self.assertAlmostEqual(result[0][2], expected_02, places=1) | |
| self.assertAlmostEqual(result[0][3], expected_03, places=1) | |
| self.assertAlmostEqual(result[1][0], expected_10, places=1) | |
| self.assertAlmostEqual(result[1][1], expected_11, places=1) | |
| self.assertAlmostEqual(result[1][2], expected_12, places=1) | |
| self.assertAlmostEqual(result[1][3], expected_13, places=1) | |
| self.assertAlmostEqual(result[2][0], expected_20, places=1) | |
| self.assertAlmostEqual(result[2][1], expected_21, places=1) | |
| self.assertAlmostEqual(result[2][2], expected_22, places=1) | |
| self.assertAlmostEqual(result[2][3], expected_23, places=1) | |
| self.assertAlmostEqual(result[3][0], expected_30, places=1) | |
| self.assertAlmostEqual(result[3][1], expected_31, places=1) | |
| self.assertAlmostEqual(result[3][2], expected_32, places=1) | |
| self.assertAlmostEqual(result[3][3], expected_33, places=1) | |
| with open(os.devnull, "w") as f, contextlib.redirect_stdout(f): | |
| self.assertEqual(wp.mul(a_values, b_value), wp.mul(wp.mat44f(*a_values), wp.float32(b_value))) | |
| self.assertEqual(wp.mul(a_values_2d, b_value), wp.mul(wp.mat44f(*a_values), wp.float32(b_value))) | |
| def test_vec2_arg_precision(self): | |
| values = (1.23, 2.34) | |
| expected = 2.64357712200722438922 | |
| result = wp.length(wp.vec2d(*values)) | |
| self.assertAlmostEqual(result, expected, places=12) | |
| result = wp.length(wp.vec2f(*values)) | |
| self.assertNotAlmostEqual(result, expected, places=12) | |
| self.assertAlmostEqual(result, expected, places=5) | |
| result = wp.length(wp.vec2h(*values)) | |
| self.assertNotAlmostEqual(result, expected, places=5) | |
| self.assertAlmostEqual(result, expected, places=1) | |
| with open(os.devnull, "w") as f, contextlib.redirect_stdout(f): | |
| self.assertEqual(wp.length(values), wp.length(wp.vec2f(*values))) | |
| def test_vec2_arg_overflow(self): | |
| values = (-1234567890, -1234567890) | |
| self.assertEqual(wp.length_sq(wp.vec2b(*values)), -120) | |
| self.assertEqual(wp.length_sq(wp.vec2s(*values)), -6008) | |
| self.assertEqual(wp.length_sq(wp.vec2i(*values)), 608168072) | |
| self.assertEqual(wp.length_sq(wp.vec2l(*values)), 3048315750038104200) | |
| self.assertEqual(wp.length_sq(wp.vec2ub(*values)), 136) | |
| self.assertEqual(wp.length_sq(wp.vec2us(*values)), 59528) | |
| self.assertEqual(wp.length_sq(wp.vec2ui(*values)), 608168072) | |
| self.assertEqual(wp.length_sq(wp.vec2ul(*values)), 3048315750038104200) | |
| with open(os.devnull, "w") as f, contextlib.redirect_stdout(f): | |
| self.assertEqual(wp.length_sq(values), wp.length_sq(wp.vec2i(*values))) | |
| def test_vec3_arg_precision(self): | |
| values = (1.23, 2.34, 3.45) | |
| expected = 4.34637780226247727455 | |
| result = wp.length(wp.vec3d(*values)) | |
| self.assertAlmostEqual(result, expected, places=12) | |
| result = wp.length(wp.vec3f(*values)) | |
| self.assertNotAlmostEqual(result, expected, places=12) | |
| self.assertAlmostEqual(result, expected, places=5) | |
| result = wp.length(wp.vec3h(*values)) | |
| self.assertNotAlmostEqual(result, expected, places=5) | |
| self.assertAlmostEqual(result, expected, places=1) | |
| with open(os.devnull, "w") as f, contextlib.redirect_stdout(f): | |
| self.assertEqual(wp.length(values), wp.length(wp.vec3f(*values))) | |
| def test_vec3_arg_overflow(self): | |
| values = (-1234567890, -1234567890, -1234567890) | |
| self.assertEqual(wp.length_sq(wp.vec3b(*values)), -52) | |
| self.assertEqual(wp.length_sq(wp.vec3s(*values)), -9012) | |
| self.assertEqual(wp.length_sq(wp.vec3i(*values)), 912252108) | |
| self.assertEqual(wp.length_sq(wp.vec3l(*values)), 4572473625057156300) | |
| self.assertEqual(wp.length_sq(wp.vec3ub(*values)), 204) | |
| self.assertEqual(wp.length_sq(wp.vec3us(*values)), 56524) | |
| self.assertEqual(wp.length_sq(wp.vec3ui(*values)), 912252108) | |
| self.assertEqual(wp.length_sq(wp.vec3ul(*values)), 4572473625057156300) | |
| with open(os.devnull, "w") as f, contextlib.redirect_stdout(f): | |
| self.assertEqual(wp.length_sq(values), wp.length_sq(wp.vec3i(*values))) | |
| def test_vec4_arg_precision(self): | |
| values = (1.23, 2.34, 3.45, 4.56) | |
| expected = 6.29957141399317777086 | |
| result = wp.length(wp.vec4d(*values)) | |
| self.assertAlmostEqual(result, expected, places=12) | |
| result = wp.length(wp.vec4f(*values)) | |
| self.assertNotAlmostEqual(result, expected, places=12) | |
| self.assertAlmostEqual(result, expected, places=5) | |
| result = wp.length(wp.vec4h(*values)) | |
| self.assertNotAlmostEqual(result, expected, places=5) | |
| self.assertAlmostEqual(result, expected, places=1) | |
| with open(os.devnull, "w") as f, contextlib.redirect_stdout(f): | |
| self.assertEqual(wp.length(values), wp.length(wp.vec4f(*values))) | |
| def test_vec4_arg_overflow(self): | |
| values = (-1234567890, -1234567890, -1234567890, -1234567890) | |
| self.assertEqual(wp.length_sq(wp.vec4b(*values)), 16) | |
| self.assertEqual(wp.length_sq(wp.vec4s(*values)), -12016) | |
| self.assertEqual(wp.length_sq(wp.vec4i(*values)), 1216336144) | |
| self.assertEqual(wp.length_sq(wp.vec4l(*values)), 6096631500076208400) | |
| self.assertEqual(wp.length_sq(wp.vec4ub(*values)), 16) | |
| self.assertEqual(wp.length_sq(wp.vec4us(*values)), 53520) | |
| self.assertEqual(wp.length_sq(wp.vec4ui(*values)), 1216336144) | |
| self.assertEqual(wp.length_sq(wp.vec4ul(*values)), 6096631500076208400) | |
| with open(os.devnull, "w") as f, contextlib.redirect_stdout(f): | |
| self.assertEqual(wp.length_sq(values), wp.length_sq(wp.vec4i(*values))) | |
| def test_vec2_vec2_args_precision(self): | |
| a_values = (1.23, 2.34) | |
| b_values = (3.45, 4.56) | |
| expected = 14.91389999999999815827 | |
| result = wp.dot(wp.vec2d(*a_values), wp.vec2d(*b_values)) | |
| self.assertAlmostEqual(result, expected, places=12) | |
| result = wp.dot(wp.vec2f(*a_values), wp.vec2f(*b_values)) | |
| self.assertNotAlmostEqual(result, expected, places=12) | |
| self.assertAlmostEqual(result, expected, places=5) | |
| result = wp.dot(wp.vec2h(*a_values), wp.vec2h(*b_values)) | |
| self.assertNotAlmostEqual(result, expected, places=5) | |
| self.assertAlmostEqual(result, expected, places=1) | |
| with open(os.devnull, "w") as f, contextlib.redirect_stdout(f): | |
| self.assertEqual(wp.dot(a_values, b_values), wp.dot(wp.vec2f(*a_values), wp.vec2f(*b_values))) | |
| def test_vec2_vec2_args_overflow(self): | |
| values = (-1234567890, -1234567890) | |
| self.assertEqual(wp.dot(wp.vec2b(*values), wp.vec2b(*values)), -120) | |
| self.assertEqual(wp.dot(wp.vec2s(*values), wp.vec2s(*values)), -6008) | |
| self.assertEqual(wp.dot(wp.vec2i(*values), wp.vec2i(*values)), 608168072) | |
| self.assertEqual(wp.dot(wp.vec2l(*values), wp.vec2l(*values)), 3048315750038104200) | |
| self.assertEqual(wp.dot(wp.vec2ub(*values), wp.vec2ub(*values)), 136) | |
| self.assertEqual(wp.dot(wp.vec2us(*values), wp.vec2us(*values)), 59528) | |
| self.assertEqual(wp.dot(wp.vec2ui(*values), wp.vec2ui(*values)), 608168072) | |
| self.assertEqual(wp.dot(wp.vec2ul(*values), wp.vec2ul(*values)), 3048315750038104200) | |
| with open(os.devnull, "w") as f, contextlib.redirect_stdout(f): | |
| self.assertEqual(wp.dot(values, values), wp.dot(wp.vec2i(*values), wp.vec2i(*values))) | |
| def test_vec3_vec3_args_precision(self): | |
| a_values = (1.23, 2.34, 3.45) | |
| b_values = (4.56, 5.67, 6.78) | |
| expected = 42.26760000000000161435 | |
| result = wp.dot(wp.vec3d(*a_values), wp.vec3d(*b_values)) | |
| self.assertAlmostEqual(result, expected, places=12) | |
| result = wp.dot(wp.vec3f(*a_values), wp.vec3f(*b_values)) | |
| self.assertNotAlmostEqual(result, expected, places=12) | |
| self.assertAlmostEqual(result, expected, places=5) | |
| result = wp.dot(wp.vec3h(*a_values), wp.vec3h(*b_values)) | |
| self.assertNotAlmostEqual(result, expected, places=5) | |
| self.assertAlmostEqual(result, expected, places=1) | |
| with open(os.devnull, "w") as f, contextlib.redirect_stdout(f): | |
| self.assertEqual(wp.dot(a_values, b_values), wp.dot(wp.vec3f(*a_values), wp.vec3f(*b_values))) | |
| def test_vec3_vec3_args_overflow(self): | |
| values = (-1234567890, -1234567890, -1234567890) | |
| self.assertEqual(wp.dot(wp.vec3b(*values), wp.vec3b(*values)), -52) | |
| self.assertEqual(wp.dot(wp.vec3s(*values), wp.vec3s(*values)), -9012) | |
| self.assertEqual(wp.dot(wp.vec3i(*values), wp.vec3i(*values)), 912252108) | |
| self.assertEqual(wp.dot(wp.vec3l(*values), wp.vec3l(*values)), 4572473625057156300) | |
| self.assertEqual(wp.dot(wp.vec3ub(*values), wp.vec3ub(*values)), 204) | |
| self.assertEqual(wp.dot(wp.vec3us(*values), wp.vec3us(*values)), 56524) | |
| self.assertEqual(wp.dot(wp.vec3ui(*values), wp.vec3ui(*values)), 912252108) | |
| self.assertEqual(wp.dot(wp.vec3ul(*values), wp.vec3ul(*values)), 4572473625057156300) | |
| with open(os.devnull, "w") as f, contextlib.redirect_stdout(f): | |
| self.assertEqual(wp.dot(values, values), wp.dot(wp.vec3i(*values), wp.vec3i(*values))) | |
| def test_vec4_vec4_args_precision(self): | |
| a_values = (1.23, 2.34, 3.45, 4.56) | |
| b_values = (5.67, 6.78, 7.89, 8.90) | |
| expected = 90.64379999999999881766 | |
| result = wp.dot(wp.vec4d(*a_values), wp.vec4d(*b_values)) | |
| self.assertAlmostEqual(result, expected, places=12) | |
| result = wp.dot(wp.vec4f(*a_values), wp.vec4f(*b_values)) | |
| self.assertNotAlmostEqual(result, expected, places=12) | |
| self.assertAlmostEqual(result, expected, places=5) | |
| result = wp.dot(wp.vec4h(*a_values), wp.vec4h(*b_values)) | |
| self.assertNotAlmostEqual(result, expected, places=5) | |
| self.assertAlmostEqual(result, expected, places=1) | |
| with open(os.devnull, "w") as f, contextlib.redirect_stdout(f): | |
| self.assertEqual(wp.dot(a_values, b_values), wp.dot(wp.vec4f(*a_values), wp.vec4f(*b_values))) | |
| def test_vec4_vec4_args_overflow(self): | |
| values = (-1234567890, -1234567890, -1234567890, -1234567890) | |
| self.assertEqual(wp.dot(wp.vec4b(*values), wp.vec4b(*values)), 16) | |
| self.assertEqual(wp.dot(wp.vec4s(*values), wp.vec4s(*values)), -12016) | |
| self.assertEqual(wp.dot(wp.vec4i(*values), wp.vec4i(*values)), 1216336144) | |
| self.assertEqual(wp.dot(wp.vec4l(*values), wp.vec4l(*values)), 6096631500076208400) | |
| self.assertEqual(wp.dot(wp.vec4ub(*values), wp.vec4ub(*values)), 16) | |
| self.assertEqual(wp.dot(wp.vec4us(*values), wp.vec4us(*values)), 53520) | |
| self.assertEqual(wp.dot(wp.vec4ui(*values), wp.vec4ui(*values)), 1216336144) | |
| self.assertEqual(wp.dot(wp.vec4ul(*values), wp.vec4ul(*values)), 6096631500076208400) | |
| with open(os.devnull, "w") as f, contextlib.redirect_stdout(f): | |
| self.assertEqual(wp.dot(values, values), wp.dot(wp.vec4i(*values), wp.vec4i(*values))) | |
| def test_vec2_float_args_precision(self): | |
| a_values = (1.23, 2.34) | |
| b_value = 3.45 | |
| expected_x = 4.24350000000000004974 | |
| expected_y = 8.07300000000000039790 | |
| result = wp.mul(wp.vec2d(*a_values), wp.float64(b_value)) | |
| self.assertAlmostEqual(result[0], expected_x, places=12) | |
| self.assertAlmostEqual(result[1], expected_y, places=12) | |
| result = wp.mul(wp.vec2f(*a_values), wp.float32(b_value)) | |
| self.assertNotAlmostEqual(result[0], expected_x, places=12) | |
| self.assertNotAlmostEqual(result[1], expected_y, places=12) | |
| self.assertAlmostEqual(result[0], expected_x, places=5) | |
| self.assertAlmostEqual(result[1], expected_y, places=5) | |
| result = wp.mul(wp.vec2h(*a_values), wp.float16(b_value)) | |
| self.assertNotAlmostEqual(result[0], expected_x, places=5) | |
| self.assertNotAlmostEqual(result[1], expected_y, places=5) | |
| self.assertAlmostEqual(result[0], expected_x, places=1) | |
| self.assertAlmostEqual(result[1], expected_y, places=1) | |
| with open(os.devnull, "w") as f, contextlib.redirect_stdout(f): | |
| self.assertEqual(wp.mul(a_values, b_value), wp.mul(wp.vec2f(*a_values), wp.float32(b_value))) | |
| def test_vec3_float_args_precision(self): | |
| a_values = (1.23, 2.34, 3.45) | |
| b_value = 4.56 | |
| expected_x = 5.60879999999999956373 | |
| expected_y = 10.67039999999999899671 | |
| expected_z = 15.73199999999999931788 | |
| result = wp.mul(wp.vec3d(*a_values), wp.float64(b_value)) | |
| self.assertAlmostEqual(result[0], expected_x, places=12) | |
| self.assertAlmostEqual(result[1], expected_y, places=12) | |
| self.assertAlmostEqual(result[2], expected_z, places=12) | |
| result = wp.mul(wp.vec3f(*a_values), wp.float32(b_value)) | |
| self.assertNotAlmostEqual(result[0], expected_x, places=12) | |
| self.assertNotAlmostEqual(result[1], expected_y, places=12) | |
| self.assertNotAlmostEqual(result[2], expected_z, places=12) | |
| self.assertAlmostEqual(result[0], expected_x, places=5) | |
| self.assertAlmostEqual(result[1], expected_y, places=5) | |
| self.assertAlmostEqual(result[2], expected_z, places=5) | |
| result = wp.mul(wp.vec3h(*a_values), wp.float16(b_value)) | |
| self.assertNotAlmostEqual(result[0], expected_x, places=5) | |
| self.assertNotAlmostEqual(result[1], expected_y, places=5) | |
| self.assertNotAlmostEqual(result[2], expected_z, places=5) | |
| self.assertAlmostEqual(result[0], expected_x, places=1) | |
| self.assertAlmostEqual(result[1], expected_y, places=1) | |
| self.assertAlmostEqual(result[2], expected_z, places=1) | |
| with open(os.devnull, "w") as f, contextlib.redirect_stdout(f): | |
| self.assertEqual(wp.mul(a_values, b_value), wp.mul(wp.vec3f(*a_values), wp.float32(b_value))) | |
| def test_vec4_float_args_precision(self): | |
| a_values = (1.23, 2.34, 3.45, 4.56) | |
| b_value = 5.67 | |
| expected_x = 6.97409999999999996589 | |
| expected_y = 13.26779999999999937188 | |
| expected_z = 19.56150000000000233058 | |
| expected_w = 25.85519999999999640750 | |
| result = wp.mul(wp.vec4d(*a_values), wp.float64(b_value)) | |
| self.assertAlmostEqual(result[0], expected_x, places=12) | |
| self.assertAlmostEqual(result[1], expected_y, places=12) | |
| self.assertAlmostEqual(result[2], expected_z, places=12) | |
| self.assertAlmostEqual(result[3], expected_w, places=12) | |
| result = wp.mul(wp.vec4f(*a_values), wp.float32(b_value)) | |
| self.assertNotAlmostEqual(result[0], expected_x, places=12) | |
| self.assertNotAlmostEqual(result[1], expected_y, places=12) | |
| self.assertNotAlmostEqual(result[2], expected_z, places=12) | |
| self.assertNotAlmostEqual(result[3], expected_w, places=12) | |
| self.assertAlmostEqual(result[0], expected_x, places=5) | |
| self.assertAlmostEqual(result[1], expected_y, places=5) | |
| self.assertAlmostEqual(result[2], expected_z, places=5) | |
| self.assertAlmostEqual(result[3], expected_w, places=5) | |
| result = wp.mul(wp.vec4h(*a_values), wp.float16(b_value)) | |
| self.assertNotAlmostEqual(result[0], expected_x, places=5) | |
| self.assertNotAlmostEqual(result[1], expected_y, places=5) | |
| self.assertNotAlmostEqual(result[2], expected_z, places=5) | |
| self.assertNotAlmostEqual(result[3], expected_w, places=5) | |
| self.assertAlmostEqual(result[0], expected_x, places=1) | |
| self.assertAlmostEqual(result[1], expected_y, places=1) | |
| self.assertAlmostEqual(result[2], expected_z, places=1) | |
| self.assertAlmostEqual(result[3], expected_w, places=1) | |
| with open(os.devnull, "w") as f, contextlib.redirect_stdout(f): | |
| self.assertEqual(wp.mul(a_values, b_value), wp.mul(wp.vec4f(*a_values), wp.float32(b_value))) | |
| for dtype in wp.types.int_types: | |
| add_function_test( | |
| TestBuiltinsResolution, | |
| f"test_int_arg_support_{dtype.__name__}", | |
| test_int_arg_support, | |
| dtype=dtype, | |
| ) | |
| add_function_test( | |
| TestBuiltinsResolution, | |
| f"test_int_int_args_support_{dtype.__name__}", | |
| test_int_int_args_support, | |
| dtype=dtype, | |
| ) | |
| for dtype in wp.types.float_types: | |
| add_function_test( | |
| TestBuiltinsResolution, | |
| f"test_float_arg_support_{dtype.__name__}", | |
| test_float_arg_support, | |
| dtype=dtype, | |
| ) | |
| add_function_test( | |
| TestBuiltinsResolution, | |
| f"test_mat_arg_support_{dtype.__name__}", | |
| test_mat_arg_support, | |
| dtype=dtype, | |
| ) | |
| add_function_test( | |
| TestBuiltinsResolution, | |
| f"test_mat_mat_args_support_{dtype.__name__}", | |
| test_mat_mat_args_support, | |
| dtype=dtype, | |
| ) | |
| add_function_test( | |
| TestBuiltinsResolution, | |
| f"test_mat_float_args_support_{dtype.__name__}", | |
| test_mat_float_args_support, | |
| dtype=dtype, | |
| ) | |
| add_function_test( | |
| TestBuiltinsResolution, | |
| f"test_vec_arg_support_{dtype.__name__}", | |
| test_vec_arg_support, | |
| dtype=dtype, | |
| ) | |
| add_function_test( | |
| TestBuiltinsResolution, | |
| f"test_vec_vec_args_support_{dtype.__name__}", | |
| test_vec_vec_args_support, | |
| dtype=dtype, | |
| ) | |
| add_function_test( | |
| TestBuiltinsResolution, | |
| f"test_vec_float_args_support_{dtype.__name__}", | |
| test_vec_float_args_support, | |
| dtype=dtype, | |
| ) | |
| if __name__ == "__main__": | |
| wp.build.clear_kernel_cache() | |
| unittest.main(verbosity=2) | |