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

warp/tests/test_lerp.py

@@ -5,14 +5,16 @@
 # distribution of this software and related documentation without an express
 # license agreement from NVIDIA CORPORATION is strictly prohibited.
 
+import unittest
 from dataclasses import dataclass
 from typing import Any
-import unittest
 
 import numpy as np
 
 import warp as wp
-from warp.tests.test_base import *
+from warp.tests.unittest_utils import *
+
+wp.init()
 
 
 @dataclass
@@ -162,8 +164,6 @@ TEST_DATA = {
     ),
 }
 
-wp.init()
-
 
 def test_lerp(test, device):
     def make_kernel_fn(data_type):
@@ -179,84 +179,83 @@ def test_lerp(test, device):
 
     for data_type in TEST_DATA:
         kernel_fn = make_kernel_fn(data_type)
-        module = wp.get_module(kernel_fn.__module__)
         kernel = wp.Kernel(
             func=kernel_fn,
             key=f"test_lerp_{data_type.__name__}_kernel",
-            module=module,
         )
 
-        for test_data in TEST_DATA[data_type]:
-            a = wp.array(
-                [test_data.a],
-                dtype=data_type,
-                device=device,
-                requires_grad=True,
-            )
-            b = wp.array(
-                [test_data.b],
-                dtype=data_type,
-                device=device,
-                requires_grad=True,
-            )
-            t = wp.array(
-                [test_data.t],
-                dtype=float,
-                device=device,
-                requires_grad=True,
-            )
-            out = wp.array(
-                [0] * wp.types.type_length(data_type),
-                dtype=data_type,
-                device=device,
-                requires_grad=True,
-            )
-
-            tape = wp.Tape()
-            with tape:
-                wp.launch(
-                    kernel,
-                    dim=1,
-                    inputs=[a, b, t, out],
+        with test.subTest(data_type=data_type):
+            for test_data in TEST_DATA[data_type]:
+                a = wp.array(
+                    [test_data.a],
+                    dtype=data_type,
                     device=device,
+                    requires_grad=True,
                 )
-
-            assert_np_equal(
-                out.numpy(),
-                np.array([test_data.expected]),
-                tol=1e-6,
-            )
-
-            if test_data.check_backwards():
-                tape.backward(out)
-
-                assert_np_equal(
-                    tape.gradients[a].numpy(),
-                    np.array([test_data.expected_adj_a]),
-                    tol=1e-6,
+                b = wp.array(
+                    [test_data.b],
+                    dtype=data_type,
+                    device=device,
+                    requires_grad=True,
                 )
-                assert_np_equal(
-                    tape.gradients[b].numpy(),
-                    np.array([test_data.expected_adj_b]),
-                    tol=1e-6,
+                t = wp.array(
+                    [test_data.t],
+                    dtype=float,
+                    device=device,
+                    requires_grad=True,
+                )
+                out = wp.array(
+                    [0] * wp.types.type_length(data_type),
+                    dtype=data_type,
+                    device=device,
+                    requires_grad=True,
                 )
+
+                tape = wp.Tape()
+                with tape:
+                    wp.launch(
+                        kernel,
+                        dim=1,
+                        inputs=[a, b, t, out],
+                        device=device,
+                    )
+
                 assert_np_equal(
-                    tape.gradients[t].numpy(),
-                    np.array([test_data.expected_adj_t]),
+                    out.numpy(),
+                    np.array([test_data.expected]),
                     tol=1e-6,
                 )
 
+                if test_data.check_backwards():
+                    tape.backward(out)
+
+                    assert_np_equal(
+                        tape.gradients[a].numpy(),
+                        np.array([test_data.expected_adj_a]),
+                        tol=1e-6,
+                    )
+                    assert_np_equal(
+                        tape.gradients[b].numpy(),
+                        np.array([test_data.expected_adj_b]),
+                        tol=1e-6,
+                    )
+                    assert_np_equal(
+                        tape.gradients[t].numpy(),
+                        np.array([test_data.expected_adj_t]),
+                        tol=1e-6,
+                    )
+
+
+devices = get_test_devices()
+
 
-def register(parent):
-    devices = get_test_devices()
+class TestLerp(unittest.TestCase):
+    pass
 
-    class TestLerp(parent):
-        pass
 
-    add_function_test(TestLerp, "test_lerp", test_lerp, devices=devices)
-    return TestLerp
+add_function_test(TestLerp, "test_lerp", test_lerp, devices=devices)
 
 
 if __name__ == "__main__":
-    _ = register(unittest.TestCase)
+    wp.build.clear_kernel_cache()
     unittest.main(verbosity=2)

warp/tests/test_lvalue.py

@@ -0,0 +1,493 @@
+# 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()
+
+
+@wp.kernel
+def rmw_array_kernel(foos: wp.array(dtype=wp.uint32)):
+    i = wp.tid()
+
+    foos[i] += wp.uint32(1)
+
+
+def test_rmw_array(test, device):
+    arr = wp.zeros((10,), dtype=wp.uint32, device=device)
+
+    wp.launch(
+        kernel=rmw_array_kernel,
+        dim=(10,),
+        inputs=[arr],
+        device=device,
+    )
+    wp.synchronize()
+
+    for f in arr.list():
+        if f != 1:
+            raise AssertionError(f"Unexpected result, got: {f} expected: {1}")
+
+
+@wp.struct
+class RmwFoo:
+    field: wp.uint32
+
+
+@wp.kernel
+def rmw_array_struct_kernel(foos: wp.array(dtype=RmwFoo)):
+    i = wp.tid()
+    foos[i].field += wp.uint32(1)
+
+
+def test_rmw_array_struct(test, device):
+    foos = wp.zeros((10,), dtype=RmwFoo, device=device)
+
+    wp.launch(
+        kernel=rmw_array_struct_kernel,
+        dim=(10,),
+        inputs=[foos],
+        device=device,
+    )
+    wp.synchronize()
+
+    expected = RmwFoo()
+    expected.field = 1
+    for f in foos.list():
+        if f.field != expected.field:
+            raise AssertionError(f"Unexpected result, got: {f} expected: {expected}")
+
+
+@wp.func
+def lookup(foos: wp.array(dtype=wp.uint32), index: int):
+    return foos[index]
+
+
+@wp.kernel
+def lookup_kernel(foos: wp.array(dtype=wp.uint32)):
+    i = wp.tid()
+
+    x = lookup(foos, i)
+    foos[i] = x + wp.uint32(1)
+
+
+def test_lookup(test, device):
+    arr = wp.zeros((10,), dtype=wp.uint32, device=device)
+
+    wp.launch(
+        kernel=lookup_kernel,
+        dim=(10,),
+        inputs=[arr],
+        device=device,
+    )
+    wp.synchronize()
+
+    for f in arr.list():
+        if f != 1:
+            raise AssertionError(f"Unexpected result, got: {f} expected: {1}")
+
+
+@wp.func
+def lookup3(foos: wp.array(dtype=wp.float32), index: int):
+    return foos[index]
+
+
+@wp.kernel
+def grad_kernel(foos: wp.array(dtype=wp.float32), bars: wp.array(dtype=wp.float32)):
+    i = wp.tid()
+
+    x = lookup3(foos, i)
+    bars[i] = x * wp.float32(i) + 1.0
+
+
+def test_grad(test, device):
+    num = 10
+    data = np.linspace(20, 20 + num, num, endpoint=False, dtype=np.float32)
+    input = wp.array(data, device=device, requires_grad=True)
+    output = wp.zeros(num, dtype=wp.float32, device=device)
+
+    ones = wp.array(np.ones(len(output)), dtype=wp.float32, device=device)
+
+    tape = wp.Tape()
+    with tape:
+        wp.launch(
+            kernel=grad_kernel,
+            dim=(num,),
+            inputs=[input],
+            outputs=[output],
+            device=device,
+        )
+
+    tape.backward(grads={output: ones})
+
+    wp.synchronize()
+
+    # test forward results
+    for i, f in enumerate(output.list()):
+        expected = data[i] * i + 1
+        if f != expected:
+            raise AssertionError(f"Unexpected result, got: {f} expected: {expected}")
+
+    # test backward results
+    for i, f in enumerate(tape.gradients[input].list()):
+        expected = i
+        if f != expected:
+            raise AssertionError(f"Unexpected result, got: {f} expected: {expected}")
+
+
+@wp.func
+def lookup2(foos: wp.array(dtype=wp.uint32), index: int):
+    if index % 2 == 0:
+        x = foos[index]
+        x = wp.uint32(0)
+        return x
+    else:
+        return foos[index]
+
+
+@wp.kernel
+def lookup2_kernel(foos: wp.array(dtype=wp.uint32)):
+    i = wp.tid()
+
+    x = lookup2(foos, i)
+    foos[i] = x + wp.uint32(1)
+
+
+def test_lookup2(test, device):
+    arr = wp.zeros((10,), dtype=wp.uint32, device=device)
+
+    wp.launch(
+        kernel=lookup2_kernel,
+        dim=(10,),
+        inputs=[arr],
+        device=device,
+    )
+    wp.synchronize()
+
+    for f in arr.list():
+        if f != 1:
+            raise AssertionError(f"Unexpected result, got: {f} expected: {1}")
+
+
+@wp.kernel
+def unary_kernel(foos: wp.array(dtype=wp.uint32)):
+    i = wp.tid()
+
+    foos[i] = wp.uint32(-1)
+    x = -foos[i]
+    foos[i] = x
+
+
+def test_unary(test, device):
+    arr = wp.zeros((10,), dtype=wp.uint32, device=device)
+
+    wp.launch(
+        kernel=unary_kernel,
+        dim=(10,),
+        inputs=[arr],
+        device=device,
+    )
+    wp.synchronize()
+
+    for f in arr.list():
+        if f != 1:
+            raise AssertionError(f"Unexpected result, got: {f} expected: {1}")
+
+
+@wp.kernel
+def rvalue_kernel(foos: wp.array(dtype=wp.uint32)):
+    i = wp.tid()
+
+    if foos[i] < wp.uint32(1):
+        foos[i] = wp.uint32(1)
+
+
+def test_rvalue(test, device):
+    arr = wp.zeros((10,), dtype=wp.uint32, device=device)
+
+    wp.launch(
+        kernel=rvalue_kernel,
+        dim=(10,),
+        inputs=[arr],
+        device=device,
+    )
+    wp.synchronize()
+
+    for f in arr.list():
+        if f != 1:
+            raise AssertionError(f"Unexpected result, got: {f} expected: {1}")
+
+
+# Tests, among other things, that assigning a reference to a new variable does
+# not create a reference
+@wp.kernel
+def intermediate_kernel(foos: wp.array(dtype=wp.uint32)):
+    i = wp.tid()
+
+    x = foos[i]
+    x = x + wp.uint32(1)
+    foos[i] = x
+
+
+def test_intermediate(test, device):
+    arr = wp.zeros((10,), dtype=wp.uint32, device=device)
+
+    wp.launch(
+        kernel=intermediate_kernel,
+        dim=(10,),
+        inputs=[arr],
+        device=device,
+    )
+    wp.synchronize()
+
+    for f in arr.list():
+        if f != 1:
+            raise AssertionError(f"Unexpected result, got: {f} expected: {1}")
+
+
+@wp.kernel
+def array_kernel(foos: wp.array(dtype=wp.uint32)):
+    i = wp.tid()
+    foos[i] = wp.uint32(1)
+
+
+def test_array_assign(test, device):
+    arr = wp.zeros((10,), dtype=wp.uint32, device=device)
+
+    wp.launch(
+        kernel=array_kernel,
+        dim=(10,),
+        inputs=[arr],
+        device=device,
+    )
+    wp.synchronize()
+
+    for f in arr.list():
+        if f != 1:
+            raise AssertionError(f"Unexpected result, got: {f} expected: {1}")
+
+
+@wp.func
+def increment(arg: wp.uint32):
+    return arg + wp.uint32(1)
+
+
+@wp.kernel
+def array_call_kernel(foos: wp.array(dtype=wp.uint32)):
+    i = wp.tid()
+    foos[i] = increment(foos[i])
+
+
+def test_array_call_assign(test, device):
+    arr = wp.zeros((10,), dtype=wp.uint32, device=device)
+
+    wp.launch(
+        kernel=array_kernel,
+        dim=(10,),
+        inputs=[arr],
+        device=device,
+    )
+    wp.synchronize()
+
+    for f in arr.list():
+        if f != 1:
+            raise AssertionError(f"Unexpected result, got: {f} expected: {1}")
+
+
+@wp.struct
+class Foo:
+    field: wp.uint32
+
+
+@wp.kernel
+def array_struct_kernel(foos: wp.array(dtype=Foo)):
+    i = wp.tid()
+    foos[i].field = wp.uint32(1)
+
+
+def test_array_struct_assign(test, device):
+    foos = wp.zeros((10,), dtype=Foo, device=device)
+
+    wp.launch(
+        kernel=array_struct_kernel,
+        dim=(10,),
+        inputs=[foos],
+        device=device,
+    )
+    wp.synchronize()
+
+    expected = Foo()
+    expected.field = 1
+    for f in foos.list():
+        if f.field != expected.field:
+            raise AssertionError(f"Unexpected result, got: {f} expected: {expected}")
+
+
+@wp.struct
+class Bar:
+    field: wp.uint32
+
+
+@wp.struct
+class Baz:
+    bar: Bar
+
+
+@wp.kernel
+def array_struct_struct_kernel(foos: wp.array(dtype=Baz)):
+    i = wp.tid()
+    foos[i].bar.field = wp.uint32(1)
+
+
+def test_array_struct_struct_assign(test, device):
+    foos = wp.zeros((10,), dtype=Baz, device=device)
+
+    wp.launch(
+        kernel=array_struct_struct_kernel,
+        dim=(10,),
+        inputs=[foos],
+        device=device,
+    )
+    wp.synchronize()
+
+    expected = Baz()
+    expected.bar.field = 1
+    for f in foos.list():
+        if f.bar.field != expected.bar.field:
+            raise AssertionError(f"Unexpected result, got: {f} expected: {expected}")
+
+
+@wp.struct
+class S:
+    a: wp.uint32
+    b: wp.float32
+
+
+@wp.struct
+class F:
+    x: wp.float32
+    s: S
+    y: wp.int32
+
+
+@wp.kernel
+def complex_kernel(foos: wp.array(dtype=F)):
+    i = wp.tid()
+    foos[i].x += wp.float32(1.0)
+    foos[i].y = wp.int32(2)
+    foos[i].s.b += wp.float32(3.0)
+    foos[i].s.a = wp.uint32(foos[i].y)
+
+
+def test_complex(test, device):
+    foos = wp.zeros((10,), dtype=F, device=device)
+
+    wp.launch(
+        kernel=complex_kernel,
+        dim=(10,),
+        inputs=[foos],
+        device=device,
+    )
+    wp.synchronize()
+
+    expected = F()
+    expected.x = 1.0
+    expected.y = 2
+    expected.s.b = 3.0
+    expected.s.a = expected.y
+    for f in foos.list():
+        if f.x != expected.x or f.y != expected.y or f.s.a != expected.s.a or f.s.b != expected.s.b:
+            raise AssertionError(f"Unexpected result, got: {f} expected: {expected}")
+
+
+@wp.struct
+class Svec:
+    a: wp.uint32
+    b: wp.vec2f
+
+
+@wp.struct
+class Fvec:
+    x: wp.vec2f
+    s: Svec
+    y: wp.int32
+
+
+@wp.kernel
+def swizzle_kernel(foos: wp.array(dtype=Fvec)):
+    i = wp.tid()
+
+    foos[i].x += wp.vec2f(1.0, 2.0)
+    foos[i].y = wp.int32(3)
+    foos[i].s.b = wp.vec2f(4.0, 5.0)
+    foos[i].s.b.y = wp.float32(6.0)
+    foos[i].s.b.x = foos[i].x.y
+    foos[i].s.a = wp.uint32(foos[i].y)
+
+
+def test_swizzle(test, device):
+    foos = wp.zeros((10,), dtype=Fvec, device=device)
+
+    wp.launch(
+        kernel=swizzle_kernel,
+        dim=(10,),
+        inputs=[foos],
+        device=device,
+    )
+    wp.synchronize()
+
+    expected = Fvec()
+    expected.x = wp.vec2f(1.0, 2.0)
+    expected.y = 3
+    expected.s.b = wp.vec2f(4.0, 5.0)
+    expected.s.b.y = 6.0
+    expected.s.b.x = expected.x.y
+    expected.s.a = expected.y
+    for f in foos.list():
+        if f.x != expected.x or f.y != expected.y or f.s.a != expected.s.a or f.s.b != expected.s.b:
+            raise AssertionError(f"Unexpected result, got: {f} expected: {expected}")
+
+
+devices = get_test_devices()
+
+
+class TestLValue(unittest.TestCase):
+    def test_swizzle_error_invalid_attribute(self):
+        v = wp.vec3(1, 2, 3)
+        with self.assertRaisesRegex(
+            AttributeError,
+            r"'vec3f' object has no attribute 'foo'$",
+        ):
+            v.foo
+
+        try:
+            v.bar = 123
+        except AttributeError:
+            self.fail()
+
+
+add_function_test(TestLValue, "test_rmw_array", test_rmw_array, devices=devices)
+add_function_test(TestLValue, "test_rmw_array_struct", test_rmw_array_struct, devices=devices)
+add_function_test(TestLValue, "test_lookup", test_lookup, devices=devices)
+add_function_test(TestLValue, "test_lookup2", test_lookup2, devices=devices)
+add_function_test(TestLValue, "test_grad", test_grad, devices=devices)
+add_function_test(TestLValue, "test_unary", test_unary, devices=devices)
+add_function_test(TestLValue, "test_rvalue", test_rvalue, devices=devices)
+add_function_test(TestLValue, "test_intermediate", test_intermediate, devices=devices)
+add_function_test(TestLValue, "test_array_assign", test_array_assign, devices=devices)
+add_function_test(TestLValue, "test_array_struct_assign", test_array_struct_assign, devices=devices)
+add_function_test(TestLValue, "test_array_struct_struct_assign", test_array_struct_struct_assign, devices=devices)
+add_function_test(TestLValue, "test_complex", test_complex, devices=devices)
+add_function_test(TestLValue, "test_swizzle", test_swizzle, devices=devices)
+
+
+if __name__ == "__main__":
+    wp.build.clear_kernel_cache()
+    unittest.main(verbosity=2)

warp/tests/test_marching_cubes.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()
 
@@ -39,7 +37,7 @@ def test_marching_cubes(test, device):
 
     radius = dim / 4.0
 
-    wp.launch(make_field, dim=field.shape, inputs=[field, wp.vec3(dim / 2, dim / 2, dim / 2), radius], device="cuda")
+    wp.launch(make_field, dim=field.shape, inputs=[field, wp.vec3(dim / 2, dim / 2, dim / 2), radius], device=device)
 
     iso.surface(field=field, threshold=0.0)
 
@@ -49,18 +47,19 @@ def test_marching_cubes(test, device):
 
     test.assertTrue(np.max(error) < 1.0)
 
+    iso.resize(nx=dim * 2, ny=dim * 2, nz=dim * 2, max_verts=max_verts, max_tris=max_tris)
+
+
+devices = get_unique_cuda_test_devices()
 
-def register(parent):
-    devices = ["cuda"]
 
-    class TestMarchingCubes(parent):
-        pass
+class TestMarchingCubes(unittest.TestCase):
+    pass
 
-    add_function_test(TestMarchingCubes, "test_marching_cubes", test_marching_cubes, devices=devices)
 
-    return TestMarchingCubes
+add_function_test(TestMarchingCubes, "test_marching_cubes", test_marching_cubes, devices=devices)
 
 
 if __name__ == "__main__":
-    c = register(unittest.TestCase)
+    wp.build.clear_kernel_cache()
     unittest.main(verbosity=2)