warp-lang 1.0.0b2__py3-none-manylinux2014_x86_64.whl → 1.0.0b6__py3-none-manylinux2014_x86_64.whl

warp/tests/test_conditional.py

@@ -5,17 +5,10 @@
 # distribution of this software and related documentation without an express
 # license agreement from NVIDIA CORPORATION is strictly prohibited.
 
-# include parent path
-import os
-import sys
-import numpy as np
-import math
-import ctypes
+import unittest
 
 import warp as wp
-from warp.tests.test_base import *
-
-import unittest
+from warp.tests.unittest_utils import *
 
 wp.init()
 
@@ -138,25 +131,116 @@ def test_bool_param_conditional(foo: bool):
     wp.expect_eq(x, 123)
 
 
-def register(parent):
-    devices = get_test_devices()
+@wp.kernel
+def test_conditional_chain_basic():
+    x = -1
+
+    if 0 < x < 1:
+        success = False
+    else:
+        success = True
+    wp.expect_eq(success, True)
+
+
+@wp.kernel
+def test_conditional_chain_empty_range():
+    x = -1
+    y = 4
+
+    if -2 <= x <= 10 <= y:
+        success = False
+    else:
+        success = True
+    wp.expect_eq(success, True)
+
+
+@wp.kernel
+def test_conditional_chain_faker():
+    x = -1
+
+    # Not actually a chained inequality
+    if (-2 < x) < (1 > 0):
+        success = False
+    else:
+        success = True
+    wp.expect_eq(success, True)
+
+
+@wp.kernel
+def test_conditional_chain_and():
+    x = -1
+
+    if (-2 < x < 0) and (-1 <= x <= -1):
+        success = True
+    else:
+        success = False
+    wp.expect_eq(success, True)
+
+
+@wp.kernel
+def test_conditional_chain_eqs():
+    x = wp.int32(10)
+    y = 10
+    z = -10
+
+    if x == y != z:
+        success = True
+    else:
+        success = False
+    wp.expect_eq(success, True)
+
+
+@wp.kernel
+def test_conditional_chain_mixed():
+    x = 0
+
+    if x < 10 == 1:
+        success = False
+    else:
+        success = True
+    wp.expect_eq(success, True)
+
+
+def test_conditional_unequal_types(test: unittest.TestCase, device):
+    # The bad kernel must be in a separate module, otherwise the current module would fail to load
+    from warp.tests.aux_test_conditional_unequal_types_kernels import (
+        unequal_types_kernel,
+    )
+
+    with test.assertRaises(TypeError):
+        wp.launch(unequal_types_kernel, dim=(1,), inputs=[], device=device)
+
+    # remove all references to the bad module so that subsequent calls to wp.force_load()
+    # won't try to load it unless we explicitly re-import it again
+    del wp.context.user_modules["warp.tests.aux_test_conditional_unequal_types_kernels"]
+    del sys.modules["warp.tests.aux_test_conditional_unequal_types_kernels"]
+
+
+devices = get_test_devices()
+
 
-    class TestConditional(parent):
-        pass
+class TestConditional(unittest.TestCase):
+    pass
 
-    add_kernel_test(TestConditional, kernel=test_conditional_if_else, dim=1, devices=devices)
-    add_kernel_test(TestConditional, kernel=test_conditional_if_else_nested, dim=1, devices=devices)
-    add_kernel_test(TestConditional, kernel=test_boolean_and, dim=1, devices=devices)
-    add_kernel_test(TestConditional, kernel=test_boolean_or, dim=1, devices=devices)
-    add_kernel_test(TestConditional, kernel=test_boolean_compound, dim=1, devices=devices)
-    add_kernel_test(TestConditional, kernel=test_boolean_literal, dim=1, devices=devices)
-    add_kernel_test(TestConditional, kernel=test_int_logical_not, dim=1, devices=devices)
-    add_kernel_test(TestConditional, kernel=test_int_conditional_assign_overload, dim=1, devices=devices)
-    add_kernel_test(TestConditional, kernel=test_bool_param_conditional, dim=1, inputs=[True], devices=devices)
 
-    return TestConditional
+add_kernel_test(TestConditional, kernel=test_conditional_if_else, dim=1, devices=devices)
+add_kernel_test(TestConditional, kernel=test_conditional_if_else_nested, dim=1, devices=devices)
+add_kernel_test(TestConditional, kernel=test_boolean_and, dim=1, devices=devices)
+add_kernel_test(TestConditional, kernel=test_boolean_or, dim=1, devices=devices)
+add_kernel_test(TestConditional, kernel=test_boolean_compound, dim=1, devices=devices)
+add_kernel_test(TestConditional, kernel=test_boolean_literal, dim=1, devices=devices)
+add_kernel_test(TestConditional, kernel=test_int_logical_not, dim=1, devices=devices)
+add_kernel_test(TestConditional, kernel=test_int_conditional_assign_overload, dim=1, devices=devices)
+add_kernel_test(TestConditional, kernel=test_bool_param_conditional, dim=1, inputs=[True], devices=devices)
+add_kernel_test(TestConditional, kernel=test_conditional_chain_basic, dim=1, devices=devices)
+add_kernel_test(TestConditional, kernel=test_conditional_chain_empty_range, dim=1, devices=devices)
+add_kernel_test(TestConditional, kernel=test_conditional_chain_faker, dim=1, devices=devices)
+add_kernel_test(TestConditional, kernel=test_conditional_chain_and, dim=1, devices=devices)
+add_kernel_test(TestConditional, kernel=test_conditional_chain_eqs, dim=1, devices=devices)
+add_kernel_test(TestConditional, kernel=test_conditional_chain_mixed, dim=1, devices=devices)
+add_function_test(TestConditional, "test_conditional_unequal_types", test_conditional_unequal_types, devices=devices)
 
 
 if __name__ == "__main__":
-    c = register(unittest.TestCase)
+    wp.build.clear_kernel_cache()
     unittest.main(verbosity=2)

warp/tests/test_copy.py

@@ -5,13 +5,12 @@
 # distribution of this software and related documentation without an express
 # license agreement from NVIDIA CORPORATION is strictly prohibited.
 
-# include parent path
+import unittest
+
 import numpy as np
 
 import warp as wp
-from warp.tests.test_base import *
-
-import unittest
+from warp.tests.unittest_utils import *
 
 wp.init()
 
@@ -200,18 +199,17 @@ def test_copy_indexed(test, device):
         assert_np_equal(a4.numpy(), expected4 * s)
 
 
-def register(parent):
-    devices = get_test_devices()
+devices = get_test_devices()
+
 
-    class TestCopy(parent):
-        pass
+class TestCopy(unittest.TestCase):
+    pass
 
-    add_function_test(TestCopy, "test_copy_strided", test_copy_strided, devices=devices)
-    add_function_test(TestCopy, "test_copy_indexed", test_copy_indexed, devices=devices)
 
-    return TestCopy
+add_function_test(TestCopy, "test_copy_strided", test_copy_strided, devices=devices)
+add_function_test(TestCopy, "test_copy_indexed", test_copy_indexed, devices=devices)
 
 
 if __name__ == "__main__":
-    c = register(unittest.TestCase)
+    wp.build.clear_kernel_cache()
     unittest.main(verbosity=2)

warp/tests/test_ctypes.py

@@ -5,14 +5,12 @@
 # distribution of this software and related documentation without an express
 # license agreement from NVIDIA CORPORATION is strictly prohibited.
 
-# include parent path
+import unittest
+
 import numpy as np
-import math
 
 import warp as wp
-from warp.tests.test_base import *
-
-import unittest
+from warp.tests.unittest_utils import *
 
 wp.init()
 
@@ -24,11 +22,11 @@ def add_vec2(dest: wp.array(dtype=wp.vec2), c: wp.vec2):
 
 
 @wp.kernel
-def transform_vec2(dest: wp.array(dtype=wp.vec2), m: wp.mat22, v: wp.vec2):
+def transform_vec2(dest_right: wp.array(dtype=wp.vec2), dest_left: wp.array(dtype=wp.vec2), m: wp.mat22, v: wp.vec2):
     tid = wp.tid()
 
-    p = wp.mul(m, v)
-    dest[tid] = p
+    dest_right[tid] = wp.mul(m, v)
+    dest_left[tid] = wp.mul(v, m)
 
 
 @wp.kernel
@@ -38,11 +36,11 @@ def add_vec3(dest: wp.array(dtype=wp.vec3), c: wp.vec3):
 
 
 @wp.kernel
-def transform_vec3(dest: wp.array(dtype=wp.vec3), m: wp.mat33, v: wp.vec3):
+def transform_vec3(dest_right: wp.array(dtype=wp.vec3), dest_left: wp.array(dtype=wp.vec3), m: wp.mat33, v: wp.vec3):
     tid = wp.tid()
 
-    p = wp.mul(m, v)
-    dest[tid] = p
+    dest_right[tid] = wp.mul(m, v)
+    dest_left[tid] = wp.mul(v, m)
 
 
 @wp.kernel
@@ -63,12 +61,14 @@ def test_vec2_arg(test, device, n):
 
 
 def test_vec2_transform(test, device, n):
-    dest = wp.zeros(n=n, dtype=wp.vec2, device=device)
+    dest_right = wp.zeros(n=n, dtype=wp.vec2, device=device)
+    dest_left = wp.zeros(n=n, dtype=wp.vec2, device=device)
     c = np.array((1.0, 2.0))
     m = np.array(((3.0, -1.0), (2.5, 4.0)))
 
-    wp.launch(transform_vec2, dim=n, inputs=[dest, m, c], device=device)
-    test.assertTrue(np.array_equal(dest.numpy(), np.tile(m @ c, (n, 1))))
+    wp.launch(transform_vec2, dim=n, inputs=[dest_right, dest_left, m, c], device=device)
+    test.assertTrue(np.array_equal(dest_right.numpy(), np.tile(m @ c, (n, 1))))
+    test.assertTrue(np.array_equal(dest_left.numpy(), np.tile(c @ m, (n, 1))))
 
 
 def test_vec3_arg(test, device, n):
@@ -80,25 +80,45 @@ def test_vec3_arg(test, device, n):
 
 
 def test_vec3_transform(test, device, n):
-    dest = wp.zeros(n=n, dtype=wp.vec3, device=device)
+    dest_right = wp.zeros(n=n, dtype=wp.vec3, device=device)
+    dest_left = wp.zeros(n=n, dtype=wp.vec3, device=device)
     c = np.array((1.0, 2.0, 3.0))
     m = np.array(((1.0, 2.0, 3.0), (4.0, 5.0, 6.0), (7.0, 8.0, 9.0)))
 
-    wp.launch(transform_vec3, dim=n, inputs=[dest, m, c], device=device)
-    test.assertTrue(np.array_equal(dest.numpy(), np.tile(m @ c, (n, 1))))
+    wp.launch(transform_vec3, dim=n, inputs=[dest_right, dest_left, m, c], device=device)
+    test.assertTrue(np.array_equal(dest_right.numpy(), np.tile(m @ c, (n, 1))))
+    test.assertTrue(np.array_equal(dest_left.numpy(), np.tile(c @ m, (n, 1))))
 
 
 def test_transform_multiply(test, device, n):
-    a = wp.transform((0.0, 1.0, 0.0), wp.utils.quat_identity())
+    a = wp.transform((0.0, 1.0, 0.0), wp.quat_identity())
 
     x = []
     for i in range(10):
-        x.append(wp.utils.transform_identity())
+        x.append(wp.transform_identity())
 
     xforms = wp.array(x, dtype=wp.transform, device=device)
     wp.launch(transform_multiply, dim=n, inputs=[xforms, a], device=device)
 
 
+transformf = wp.types.transformation(dtype=wp.float32)
+
+
+@wp.kernel
+def test_transformation_constructor():
+    a = wp.transformation(wp.vec3(0.0), wp.quat_identity())
+    b = transformf(wp.vec3(0.0), wp.quat_identity())
+    c = wp.transform_identity(dtype=wp.float64)
+
+
+spatial_vector = wp.types.vector(length=6, dtype=wp.float32)
+
+
+@wp.kernel
+def test_spatial_vector_constructor():
+    a = wp.spatial_vector(wp.vec3(0.0), wp.vec3(0.0))
+
+
 # construct kernel + test harness for given matrix / vector types
 def make_matrix_test(dim, matrix, vector):
     def test_matrix_kernel(
@@ -126,8 +146,7 @@ def make_matrix_test(dim, matrix, vector):
     # register a custom kernel (no decorator) function
     # this lets us register the same function definition
     # against multiple symbols, with different arg types
-    module = wp.get_module(test_matrix_kernel.__module__)
-    kernel = wp.Kernel(func=test_matrix_kernel, key=f"test_mat{dim}{dim}_kernel", module=module)
+    kernel = wp.Kernel(func=test_matrix_kernel, key=f"test_mat{dim}{dim}_kernel")
 
     def test_matrix(test, device):
         rng = np.random.default_rng(42)
@@ -535,74 +554,79 @@ def test_transform_matrix():
     wp.expect_near(r_2, r_0 - t, 1.0e-4)
 
 
-def register(parent):
-    devices = get_test_devices()
-
-    class TestCTypes(parent):
-        pass
-
-    inputs = [
-        wp.vec2(1.0, 2.0),
-        wp.vec3(1.0, 2.0, 3.0),
-        wp.vec4(1.0, 2.0, 3.0, 4.0),
-        wp.mat22(1.0, 2.0, 3.0, 4.0),
-        wp.mat33(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-        wp.mat44(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-    ]
-
-    add_function_test(TestCTypes, "test_mat22", test_mat22, devices=devices)
-    add_function_test(TestCTypes, "test_mat33", test_mat33, devices=devices)
-    add_function_test(TestCTypes, "test_mat44", test_mat44, devices=devices)
-    add_kernel_test(
-        TestCTypes,
-        name="test_scalar_arg_types",
-        kernel=test_scalar_arg_types,
-        dim=1,
-        inputs=[-64, 255, -64, 255, -64, 255, -64, 255, 3.14159, 3.14159],
-        devices=devices,
-    )
-    add_kernel_test(
-        TestCTypes,
-        name="test_scalar_arg_types_explicit",
-        kernel=test_scalar_arg_types,
-        dim=1,
-        inputs=[
-            wp.int8(-64),
-            wp.uint8(255),
-            wp.int16(-64),
-            wp.uint16(255),
-            wp.int32(-64),
-            wp.uint32(255),
-            wp.int64(-64),
-            wp.uint64(255),
-            wp.float32(3.14159),
-            wp.float64(3.14159),
-        ],
-        devices=devices,
-    )
-    add_kernel_test(
-        TestCTypes, name="test_vector_arg_types", kernel=test_vector_arg_types, dim=1, inputs=inputs, devices=devices
-    )
-    add_kernel_test(TestCTypes, name="test_type_convesrions", kernel=test_type_conversions, dim=1, devices=devices)
-
-    add_function_test(
-        TestCTypes, "test_scalar_array_load", test_scalar_array_types, devices=devices, load=True, store=False
-    )
-    add_function_test(
-        TestCTypes, "test_scalar_array_store", test_scalar_array_types, devices=devices, load=False, store=True
-    )
-    add_function_test(TestCTypes, "test_vec2_arg", test_vec2_arg, devices=devices, n=8)
-    add_function_test(TestCTypes, "test_vec2_transform", test_vec2_transform, devices=devices, n=8)
-    add_function_test(TestCTypes, "test_vec3_arg", test_vec3_arg, devices=devices, n=8)
-    add_function_test(TestCTypes, "test_vec3_transform", test_vec3_transform, devices=devices, n=8)
-    add_function_test(TestCTypes, "test_transform_multiply", test_transform_multiply, devices=devices, n=8)
-    add_kernel_test(TestCTypes, name="test_transform_matrix", kernel=test_transform_matrix, dim=1, devices=devices)
-    add_function_test(TestCTypes, "test_scalar_array", test_scalar_array, devices=devices)
-    add_function_test(TestCTypes, "test_vector_array", test_vector_array, devices=devices)
-
-    return TestCTypes
+devices = get_test_devices()
+
+
+class TestCTypes(unittest.TestCase):
+    pass
+
+
+inputs = [
+    wp.vec2(1.0, 2.0),
+    wp.vec3(1.0, 2.0, 3.0),
+    wp.vec4(1.0, 2.0, 3.0, 4.0),
+    wp.mat22(1.0, 2.0, 3.0, 4.0),
+    wp.mat33(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+    wp.mat44(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+]
+
+add_function_test(TestCTypes, "test_mat22", test_mat22, devices=devices)
+add_function_test(TestCTypes, "test_mat33", test_mat33, devices=devices)
+add_function_test(TestCTypes, "test_mat44", test_mat44, devices=devices)
+add_kernel_test(
+    TestCTypes, name="test_transformation_constructor", kernel=test_transformation_constructor, dim=1, devices=devices
+)
+add_kernel_test(
+    TestCTypes, name="test_spatial_vector_constructor", kernel=test_spatial_vector_constructor, dim=1, devices=devices
+)
+add_kernel_test(
+    TestCTypes,
+    name="test_scalar_arg_types",
+    kernel=test_scalar_arg_types,
+    dim=1,
+    inputs=[-64, 255, -64, 255, -64, 255, -64, 255, 3.14159, 3.14159],
+    devices=devices,
+)
+add_kernel_test(
+    TestCTypes,
+    name="test_scalar_arg_types_explicit",
+    kernel=test_scalar_arg_types,
+    dim=1,
+    inputs=[
+        wp.int8(-64),
+        wp.uint8(255),
+        wp.int16(-64),
+        wp.uint16(255),
+        wp.int32(-64),
+        wp.uint32(255),
+        wp.int64(-64),
+        wp.uint64(255),
+        wp.float32(3.14159),
+        wp.float64(3.14159),
+    ],
+    devices=devices,
+)
+add_kernel_test(
+    TestCTypes, name="test_vector_arg_types", kernel=test_vector_arg_types, dim=1, inputs=inputs, devices=devices
+)
+add_kernel_test(TestCTypes, name="test_type_convesrions", kernel=test_type_conversions, dim=1, devices=devices)
+
+add_function_test(
+    TestCTypes, "test_scalar_array_load", test_scalar_array_types, devices=devices, load=True, store=False
+)
+add_function_test(
+    TestCTypes, "test_scalar_array_store", test_scalar_array_types, devices=devices, load=False, store=True
+)
+add_function_test(TestCTypes, "test_vec2_arg", test_vec2_arg, devices=devices, n=8)
+add_function_test(TestCTypes, "test_vec2_transform", test_vec2_transform, devices=devices, n=8)
+add_function_test(TestCTypes, "test_vec3_arg", test_vec3_arg, devices=devices, n=8)
+add_function_test(TestCTypes, "test_vec3_transform", test_vec3_transform, devices=devices, n=8)
+add_function_test(TestCTypes, "test_transform_multiply", test_transform_multiply, devices=devices, n=8)
+add_kernel_test(TestCTypes, name="test_transform_matrix", kernel=test_transform_matrix, dim=1, devices=devices)
+add_function_test(TestCTypes, "test_scalar_array", test_scalar_array, devices=devices)
+add_function_test(TestCTypes, "test_vector_array", test_vector_array, devices=devices)
 
 
 if __name__ == "__main__":
-    c = register(unittest.TestCase)
+    wp.build.clear_kernel_cache()
     unittest.main(verbosity=2)

warp/tests/test_dense.py

@@ -1,11 +1,15 @@
-import numpy as np
-import math
-
-import warp as wp
-from warp.tests.test_base import *
+# Copyright (c) 2022 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 unittest
 
+import warp as wp
+from warp.tests.unittest_utils import *
+
 wp.init()
 
 
@@ -42,19 +46,22 @@ def eval_dense_solve(
     wp.dense_solve(n, A, L, b, x)
 
 
-def register(parent):
-    devices = get_test_devices()
-
-    class TestDense(parent):
-        pass
-
+def test_dense_compilation(test, device):
     # just testing compilation of the dense matrix routines
     # most are deprecated / WIP
-    wp.force_load()
+    wp.load_module(device=device)
+
+
+devices = get_test_devices()
+
+
+class TestDense(unittest.TestCase):
+    pass
+
 
-    return TestDense
+add_function_test(TestDense, "test_dense_compilation", test_dense_compilation, devices=devices)
 
 
 if __name__ == "__main__":
-    c = register(unittest.TestCase)
+    wp.build.clear_kernel_cache()
     unittest.main(verbosity=2)

warp/tests/test_devices.py

@@ -0,0 +1,98 @@
+# 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 unittest
+
+import warp as wp
+from warp.tests.unittest_utils import *
+
+wp.init()
+
+
+def test_devices_get_cuda_device_functions(test, device):
+    test.assertTrue(device.is_cuda)
+    test.assertTrue(wp.is_device_available(device))
+
+    device_ordinal = device.ordinal
+    current_device = wp.get_cuda_device(device_ordinal)
+    test.assertEqual(current_device, device)
+    current_device = wp.get_cuda_device()  # No-ordinal version
+    test.assertTrue(wp.is_device_available(current_device))
+
+    if device == current_device:
+        test.assertEqual(device, "cuda")
+    else:
+        test.assertNotEqual(device, "cuda")
+
+    preferred_device = wp.get_preferred_device()
+    test.assertTrue(wp.is_device_available(preferred_device))
+
+
+def test_devices_map_cuda_device(test, device):
+    with wp.ScopedDevice(device):
+        saved_alias = device.alias
+        # Map alias twice to check code path
+        wp.map_cuda_device("new_alias")
+        wp.map_cuda_device("new_alias")
+        wp.context.runtime.rename_device(device, saved_alias)
+
+
+def test_devices_unmap_imaginary_device(test, device):
+    with test.assertRaises(RuntimeError):
+        wp.unmap_cuda_device("imaginary_device:0")
+
+
+def test_devices_verify_cuda_device(test, device):
+    verify_cuda_saved = wp.config.verify_cuda
+
+    wp.config.verify_cuda = True
+
+    wp.context.runtime.verify_cuda_device(device)
+
+    wp.config.verify_cuda = verify_cuda_saved
+
+
+@unittest.skipUnless(wp.is_cuda_available(), "Requires CUDA")
+def test_devices_can_access_self(test, device):
+    test.assertTrue(device.can_access(device))
+
+    for warp_device in wp.get_devices():
+        device_str = str(warp_device)
+
+        if (device.is_cpu and warp_device.is_cuda) or (device.is_cuda and warp_device.is_cpu):
+            test.assertFalse(device.can_access(warp_device))
+            test.assertNotEqual(device, warp_device)
+            test.assertNotEqual(device, device_str)
+
+
+devices = get_test_devices()
+
+
+class TestDevices(unittest.TestCase):
+    pass
+
+
+add_function_test(
+    TestDevices,
+    "test_devices_get_cuda_device_functions",
+    test_devices_get_cuda_device_functions,
+    devices=get_unique_cuda_test_devices(),
+)
+add_function_test(
+    TestDevices, "test_devices_map_cuda_device", test_devices_map_cuda_device, devices=get_unique_cuda_test_devices()
+)
+add_function_test(
+    TestDevices, "test_devices_unmap_imaginary_device", test_devices_unmap_imaginary_device, devices=devices
+)
+add_function_test(TestDevices, "test_devices_verify_cuda_device", test_devices_verify_cuda_device, devices=devices)
+
+add_function_test(TestDevices, "test_devices_can_access_self", test_devices_can_access_self, devices=devices)
+
+
+if __name__ == "__main__":
+    wp.build.clear_kernel_cache()
+    unittest.main(verbosity=2)