warp-lang 1.9.1__py3-none-manylinux_2_34_aarch64.whl → 1.10.0rc2__py3-none-manylinux_2_34_aarch64.whl

warp/tests/test_builtins_resolution.py

@@ -13,7 +13,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import contextlib
 import unittest
 
 import numpy as np
@@ -27,28 +26,8 @@ def nps(dtype, value):
     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]
+    np_type = wp._src.types.warp_type_to_np_dtype[dtype]
     value = -1234567890123456789
     expected = wp.invert(dtype(value))
 
@@ -56,7 +35,7 @@ def test_int_arg_support(test, device, dtype):
 
 
 def test_float_arg_support(test, device, dtype):
-    np_type = wp.types.warp_type_to_np_dtype[dtype]
+    np_type = wp._src.types.warp_type_to_np_dtype[dtype]
     value = 1.23
     expected = wp.sin(dtype(value))
 
@@ -64,7 +43,7 @@ def test_float_arg_support(test, device, dtype):
 
 
 def test_int_int_args_support(test, device, dtype):
-    np_type = wp.types.warp_type_to_np_dtype[dtype]
+    np_type = wp._src.types.warp_type_to_np_dtype[dtype]
     value = -1234567890
     expected = wp.mul(dtype(value), dtype(value))
 
@@ -107,414 +86,6 @@ def test_int_int_args_support(test, device, dtype):
             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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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
@@ -565,7 +136,6 @@ class TestBuiltinsResolution(unittest.TestCase):
 
     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))
@@ -579,13 +149,8 @@ class TestBuiltinsResolution(unittest.TestCase):
         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))
@@ -599,13 +164,8 @@ class TestBuiltinsResolution(unittest.TestCase):
         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))
@@ -619,15 +179,9 @@ class TestBuiltinsResolution(unittest.TestCase):
         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))
@@ -641,17 +195,9 @@ class TestBuiltinsResolution(unittest.TestCase):
         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))
@@ -665,17 +211,9 @@ class TestBuiltinsResolution(unittest.TestCase):
         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))
@@ -689,15 +227,8 @@ class TestBuiltinsResolution(unittest.TestCase):
         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
@@ -730,15 +261,8 @@ class TestBuiltinsResolution(unittest.TestCase):
         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
@@ -801,10 +325,6 @@ class TestBuiltinsResolution(unittest.TestCase):
         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,
@@ -824,7 +344,6 @@ class TestBuiltinsResolution(unittest.TestCase):
             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
@@ -929,10 +448,6 @@ class TestBuiltinsResolution(unittest.TestCase):
         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
@@ -948,9 +463,6 @@ class TestBuiltinsResolution(unittest.TestCase):
         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)
 
@@ -964,9 +476,6 @@ class TestBuiltinsResolution(unittest.TestCase):
         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
@@ -982,9 +491,6 @@ class TestBuiltinsResolution(unittest.TestCase):
         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)
 
@@ -998,9 +504,6 @@ class TestBuiltinsResolution(unittest.TestCase):
         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
@@ -1016,9 +519,6 @@ class TestBuiltinsResolution(unittest.TestCase):
         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)
 
@@ -1032,9 +532,6 @@ class TestBuiltinsResolution(unittest.TestCase):
         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)
@@ -1051,9 +548,6 @@ class TestBuiltinsResolution(unittest.TestCase):
         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)
 
@@ -1067,9 +561,6 @@ class TestBuiltinsResolution(unittest.TestCase):
         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)
@@ -1086,9 +577,6 @@ class TestBuiltinsResolution(unittest.TestCase):
         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)
 
@@ -1102,9 +590,6 @@ class TestBuiltinsResolution(unittest.TestCase):
         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)
@@ -1121,9 +606,6 @@ class TestBuiltinsResolution(unittest.TestCase):
         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)
 
@@ -1137,9 +619,6 @@ class TestBuiltinsResolution(unittest.TestCase):
         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
@@ -1162,9 +641,6 @@ class TestBuiltinsResolution(unittest.TestCase):
         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
@@ -1193,9 +669,6 @@ class TestBuiltinsResolution(unittest.TestCase):
         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
@@ -1230,11 +703,8 @@ class TestBuiltinsResolution(unittest.TestCase):
         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:
+for dtype in wp._src.types.int_types:
     add_function_test(
         TestBuiltinsResolution,
         f"test_int_arg_support_{dtype.__name__}",
@@ -1248,49 +718,13 @@ for dtype in wp.types.int_types:
         dtype=dtype,
     )
 
-for dtype in wp.types.float_types:
+for dtype in wp._src.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__":