warp-lang 1.8.1__py3-none-macosx_10_13_universal2.whl → 1.9.1__py3-none-macosx_10_13_universal2.whl

warp/tests/sim/test_coloring.py

@@ -150,7 +150,7 @@ def test_coloring_trimesh(test, device):
         edge_indices_cpu = wp.array(model.edge_indices.numpy()[:, 2:], dtype=int, device="cpu")
 
         # coloring without bending
-        num_colors_greedy = wp.context.runtime.core.graph_coloring(
+        num_colors_greedy = wp.context.runtime.core.wp_graph_coloring(
             model.particle_count,
             edge_indices_cpu.__ctype__(),
             ColoringAlgorithm.GREEDY.value,
@@ -163,7 +163,7 @@ def test_coloring_trimesh(test, device):
             device="cpu",
         )
 
-        num_colors_mcs = wp.context.runtime.core.graph_coloring(
+        num_colors_mcs = wp.context.runtime.core.wp_graph_coloring(
             model.particle_count,
             edge_indices_cpu.__ctype__(),
             ColoringAlgorithm.MCS.value,
@@ -178,13 +178,13 @@ def test_coloring_trimesh(test, device):
 
         # coloring with bending
         edge_indices_cpu_with_bending = construct_trimesh_graph_edges(model.edge_indices, True)
-        num_colors_greedy = wp.context.runtime.core.graph_coloring(
+        num_colors_greedy = wp.context.runtime.core.wp_graph_coloring(
             model.particle_count,
             edge_indices_cpu_with_bending.__ctype__(),
             ColoringAlgorithm.GREEDY.value,
             particle_colors.__ctype__(),
         )
-        wp.context.runtime.core.balance_coloring(
+        wp.context.runtime.core.wp_balance_coloring(
             model.particle_count,
             edge_indices_cpu_with_bending.__ctype__(),
             num_colors_greedy,
@@ -198,13 +198,13 @@ def test_coloring_trimesh(test, device):
             device="cpu",
         )
 
-        num_colors_mcs = wp.context.runtime.core.graph_coloring(
+        num_colors_mcs = wp.context.runtime.core.wp_graph_coloring(
             model.particle_count,
             edge_indices_cpu_with_bending.__ctype__(),
             ColoringAlgorithm.MCS.value,
             particle_colors.__ctype__(),
         )
-        max_min_ratio = wp.context.runtime.core.balance_coloring(
+        max_min_ratio = wp.context.runtime.core.wp_balance_coloring(
             model.particle_count,
             edge_indices_cpu_with_bending.__ctype__(),
             num_colors_mcs,

warp/tests/test_array.py

@@ -364,6 +364,7 @@ def test_slicing(test, device):
     slice_e = arr[-1:3, :, :]  # test mixed slicing
     slice_e2 = slice_e[0, 0, :]  # test 2x slicing
     slice_f = arr[0:3:2, 0, :]  # test step
+    slice_g = arr[1:1, :0, -1:-1]  # test empty slice
 
     assert_array_equal(slice_a, wp.array(np_arr[1, :, :], dtype=float, device=device))
     assert_array_equal(slice_b, wp.array(np_arr[1:2, :, :], dtype=float, device=device))
@@ -371,6 +372,7 @@ def test_slicing(test, device):
     assert_array_equal(slice_d, wp.array(np_arr[-2:-1, :, :], dtype=float, device=device))
     assert_array_equal(slice_e, wp.array(np_arr[-1:3, :, :], dtype=float, device=device))
     assert_array_equal(slice_e2, wp.array(np_arr[2, 0, :], dtype=float, device=device))
+    assert slice_g.shape == np_arr[1:1, :0, -1:-1].shape == (0, 0, 0)
 
     # wp does not support copying from/to non-contiguous arrays
     # stepped windows must read on the device the original array was created on
@@ -2902,10 +2904,8 @@ def test_direct_from_numpy(test, device):
 
 
 @wp.kernel
-def kernel_array_from_ptr(
-    ptr: wp.uint64,
-):
-    arr = wp.array(ptr=ptr, shape=(2, 3), dtype=wp.float32)
+def kernel_array_from_ptr(arr_orig: wp.array2d(dtype=wp.float32)):
+    arr = wp.array(ptr=arr_orig.ptr, shape=(2, 3), dtype=wp.float32)
     arr[0, 0] = 1.0
     arr[0, 1] = 2.0
     arr[0, 2] = 3.0
@@ -2913,7 +2913,56 @@ def kernel_array_from_ptr(
 
 def test_kernel_array_from_ptr(test, device):
     arr = wp.zeros(shape=(2, 3), dtype=wp.float32, device=device)
-    wp.launch(kernel_array_from_ptr, dim=(1,), inputs=(arr.ptr,), device=device)
+    wp.launch(kernel_array_from_ptr, dim=(1,), inputs=(arr,), device=device)
+    assert_np_equal(arr.numpy(), np.array(((1.0, 2.0, 3.0), (0.0, 0.0, 0.0))))
+
+
+@wp.struct
+class MyStruct:
+    a: wp.float32
+    b: wp.float32
+    c: wp.float32
+
+
+@wp.kernel
+def kernel_array_from_ptr_struct(arr_orig: wp.array(dtype=MyStruct)):
+    arr = wp.array(ptr=arr_orig.ptr, shape=(2,), dtype=MyStruct)
+    arr[0].a = 1.0
+    arr[0].b = 2.0
+    arr[0].c = 3.0
+    arr[1].a = 4.0
+    arr[1].b = 5.0
+    arr[1].c = 6.0
+
+
+def test_kernel_array_from_ptr_struct(test, device):
+    arr = wp.zeros(shape=(2,), dtype=MyStruct, device=device)
+    wp.launch(kernel_array_from_ptr_struct, dim=(1,), inputs=(arr,), device=device)
+    arr_np = arr.numpy()
+    expected = np.zeros_like(arr_np)
+    expected[0] = (1.0, 2.0, 3.0)
+    expected[1] = (4.0, 5.0, 6.0)
+    assert_np_equal(arr_np, expected)
+
+
+@wp.kernel
+def kernel_array_from_ptr_variable_shape(
+    ptr: wp.uint64,
+    shape_x: int,
+    shape_y: int,
+):
+    arr = wp.array(ptr=ptr, shape=(shape_x, shape_y), dtype=wp.float32)
+    arr[0, 0] = 1.0
+    arr[0, 1] = 2.0
+    if shape_y > 2:
+        arr[0, 2] = 3.0
+
+
+def test_kernel_array_from_ptr_variable_shape(test, device):
+    arr = wp.zeros(shape=(2, 3), dtype=wp.float32, device=device)
+    wp.launch(kernel_array_from_ptr_variable_shape, dim=(1,), inputs=(arr.ptr, 2, 2), device=device)
+    assert_np_equal(arr.numpy(), np.array(((1.0, 2.0, 0.0), (0.0, 0.0, 0.0))))
+    wp.launch(kernel_array_from_ptr_variable_shape, dim=(1,), inputs=(arr.ptr, 2, 3), device=device)
     assert_np_equal(arr.numpy(), np.array(((1.0, 2.0, 3.0), (0.0, 0.0, 0.0))))
 
 
@@ -3185,6 +3234,10 @@ add_function_test(TestArray, "test_array_inplace_diff_ops", test_array_inplace_d
 add_function_test(TestArray, "test_array_inplace_non_diff_ops", test_array_inplace_non_diff_ops, devices=devices)
 add_function_test(TestArray, "test_direct_from_numpy", test_direct_from_numpy, devices=["cpu"])
 add_function_test(TestArray, "test_kernel_array_from_ptr", test_kernel_array_from_ptr, devices=devices)
+add_function_test(TestArray, "test_kernel_array_from_ptr_struct", test_kernel_array_from_ptr_struct, devices=devices)
+add_function_test(
+    TestArray, "test_kernel_array_from_ptr_variable_shape", test_kernel_array_from_ptr_variable_shape, devices=devices
+)
 
 add_function_test(TestArray, "test_array_from_int32_domain", test_array_from_int32_domain, devices=devices)
 add_function_test(TestArray, "test_array_from_int64_domain", test_array_from_int64_domain, devices=devices)

warp/tests/test_codegen.py

@@ -463,7 +463,7 @@ def test_error_unmatched_arguments(test, device):
     kernel = wp.Kernel(func=kernel_2_fn)
     with test.assertRaisesRegex(
         RuntimeError,
-        r"Input types must be exactly the same, got \['vec2f', 'vector\(length=2, dtype=float16\)'\]",
+        r"Input types must be exactly the same, got \['vec2f', 'vec2h'\]",
     ):
         wp.launch(kernel, dim=1, device=device)
 
@@ -756,6 +756,7 @@ def test_multiple_return_values(test, device):
         test_multiple_return_values_quat_to_axis_angle_kernel,
         dim=1,
         inputs=(q, expected_axis, expected_angle),
+        device=device,
     )
 
     # fmt: off
@@ -791,9 +792,9 @@ def test_multiple_return_values(test, device):
 
     test.assertAlmostEqual(V[0][0], expected_V[0][0], places=5)
     test.assertAlmostEqual(V[0][1], expected_V[0][1], places=5)
-    test.assertAlmostEqual(V[0][2], expected_V[0][2], places=5)
+    test.assertAlmostEqual(V[0][2], expected_V[0][2], places=4)  # precision issue on ARM64 (GH-905)
     test.assertAlmostEqual(V[1][0], expected_V[1][0], places=5)
-    test.assertAlmostEqual(V[1][1], expected_V[1][1], places=5)
+    test.assertAlmostEqual(V[1][1], expected_V[1][1], places=4)  # precision issue on ARM64 (GH-905)
     test.assertAlmostEqual(V[1][2], expected_V[1][2], places=5)
     test.assertAlmostEqual(V[2][0], expected_V[2][0], places=5)
     test.assertAlmostEqual(V[2][1], expected_V[2][1], places=5)

warp/tests/test_context.py

@@ -17,24 +17,17 @@ import unittest
 from typing import List, Tuple
 
 import warp as wp
-from warp.tests.unittest_utils import *
-
-
-def test_context_type_str(test, device):
-    assert wp.context.type_str(List[int]) == "List[int]"
-    assert wp.context.type_str(List[float]) == "List[float]"
-
-    assert wp.context.type_str(Tuple[int]) == "Tuple[int]"
-    assert wp.context.type_str(Tuple[float]) == "Tuple[float]"
-    assert wp.context.type_str(Tuple[int, float]) == "Tuple[int, float]"
-    assert wp.context.type_str(Tuple[int, ...]) == "Tuple[int, ...]"
 
 
 class TestContext(unittest.TestCase):
-    pass
-
-
-add_function_test(TestContext, "test_context_type_str", test_context_type_str)
+    def test_context_type_str(self):
+        self.assertEqual(wp.context.type_str(List[int]), "List[int]")
+        self.assertEqual(wp.context.type_str(List[float]), "List[float]")
+
+        self.assertEqual(wp.context.type_str(Tuple[int]), "Tuple[int]")
+        self.assertEqual(wp.context.type_str(Tuple[float]), "Tuple[float]")
+        self.assertEqual(wp.context.type_str(Tuple[int, float]), "Tuple[int, float]")
+        self.assertEqual(wp.context.type_str(Tuple[int, ...]), "Tuple[int, ...]")
 
 
 if __name__ == "__main__":

warp/tests/test_enum.py

@@ -0,0 +1,136 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import enum
+import unittest
+
+import warp as wp
+from warp.tests.unittest_utils import *
+
+
+class MyIntEnum(enum.IntEnum):
+    A = 1
+    B = 2
+    C = 3
+
+
+class MyIntFlag(enum.IntFlag):
+    A = 1
+    B = enum.auto()
+    C = enum.auto()
+
+
+def test_intenum_ints(test, device):
+    @wp.kernel
+    def expect_intenum_ints():
+        wp.expect_eq(MyIntEnum.A, 1)
+        wp.expect_eq(MyIntEnum.B, 2)
+        wp.expect_eq(MyIntEnum.C, 3)
+        wp.expect_eq(MyIntEnum.A + MyIntEnum.B, MyIntEnum.C)
+
+    wp.launch(expect_intenum_ints, dim=1, device=device)
+
+
+def test_intflag_ints(test, device):
+    @wp.kernel
+    def expect_intflag_ints():
+        wp.expect_eq(MyIntFlag.A, 1)
+        wp.expect_eq(MyIntFlag.B, 2)
+        wp.expect_eq(MyIntFlag.C, 4)
+        wp.expect_eq(MyIntFlag.A | MyIntFlag.B, 3)
+        wp.expect_eq(MyIntFlag.A | MyIntFlag.B | MyIntFlag.C, 7)
+
+    wp.launch(expect_intflag_ints, dim=1, device=device)
+
+
+def test_alternative_accessors(test, device):
+    @wp.kernel
+    def expect_alternative_accessors():
+        wp.expect_eq(int(MyIntEnum.A), 1)
+        wp.expect_eq(int(MyIntEnum.B.value), 2)
+        wp.expect_eq(MyIntEnum.C.value, 3)
+        wp.expect_eq(MyIntEnum.A + int(MyIntEnum.B) + 0, MyIntEnum.C)
+        wp.expect_eq(int(MyIntFlag.A), 1)
+        wp.expect_eq(int(MyIntFlag.B.value), 2)
+        wp.expect_eq(MyIntFlag.C.value, 4)
+        wp.expect_eq(MyIntFlag.A | int(MyIntFlag.B), 3)
+        wp.expect_eq(MyIntFlag.A | MyIntFlag.B.value | MyIntFlag.C, 7)
+
+    wp.launch(expect_alternative_accessors, dim=1, device=device)
+
+
+def test_static_accessors(test, device):
+    @wp.kernel
+    def expect_static_accessors():
+        wp.expect_eq(wp.static(MyIntEnum.A), 1)
+        wp.expect_eq(wp.static(int(MyIntEnum.A)), 1)
+        wp.expect_eq(wp.static(MyIntEnum.A.value), 1)
+        wp.expect_eq(wp.static(MyIntFlag.A), 1)
+        wp.expect_eq(wp.static(int(MyIntFlag.A)), 1)
+        wp.expect_eq(wp.static(MyIntFlag.A.value), 1)
+
+    wp.launch(expect_static_accessors, dim=1, device=device)
+
+
+def test_intflag_compare(test, device):
+    @wp.kernel
+    def compute_intflag_compare(ins: wp.array(dtype=wp.int32), outs: wp.array(dtype=wp.int32)):
+        tid = wp.tid()
+        if ins[tid] & MyIntFlag.A:
+            outs[tid] += MyIntFlag.A
+        if ins[tid] & MyIntFlag.B:
+            outs[tid] += MyIntFlag.B
+        if ins[tid] & MyIntFlag.C:
+            outs[tid] += MyIntFlag.C
+
+    with wp.ScopedDevice(device):
+        ins = wp.array(
+            [
+                0,
+                MyIntFlag.A,
+                MyIntFlag.B,
+                MyIntFlag.C,
+                MyIntFlag.A | MyIntFlag.B,
+                MyIntFlag.A | MyIntFlag.B | MyIntFlag.C,
+            ],
+            dtype=wp.int32,
+        )
+        outs = wp.zeros(len(ins), dtype=wp.int32)
+        wp.launch(compute_intflag_compare, dim=len(ins), inputs=[ins], outputs=[outs])
+        outs = outs.numpy()
+        test.assertEqual(outs[0], 0)
+        test.assertEqual(outs[1], 1)
+        test.assertEqual(outs[2], 2)
+        test.assertEqual(outs[3], 4)
+        test.assertEqual(outs[4], 3)
+        test.assertEqual(outs[5], 7)
+
+
+class TestEnum(unittest.TestCase):
+    pass
+
+
+devices = get_test_devices()
+
+add_function_test(TestEnum, "test_intenum_ints", test_intenum_ints, devices=devices)
+add_function_test(TestEnum, "test_intflag_ints", test_intflag_ints, devices=devices)
+add_function_test(TestEnum, "test_intflag_compare", test_intflag_compare, devices=devices)
+add_function_test(TestEnum, "test_alternative_accessors", test_alternative_accessors, devices=devices)
+add_function_test(TestEnum, "test_static_accessors", test_static_accessors, devices=devices)
+
+
+if __name__ == "__main__":
+    wp.clear_kernel_cache()
+    unittest.main(verbosity=2)

warp/tests/test_examples.py

@@ -52,7 +52,7 @@ from warp.tests.unittest_utils import (
 )
 from warp.utils import check_p2p
 
-wp.init()  # For wp.context.runtime.core.is_debug_enabled()
+wp.init()  # For wp.context.runtime.core.wp_is_debug_enabled()
 
 
 def _build_command_line_options(test_options: Dict[str, Any]) -> list:
@@ -331,7 +331,7 @@ add_example_test(
     name="optim.example_softbody_properties",
     devices=test_devices,
     test_options_cuda={
-        "train_iters": 1 if warp.context.runtime.core.is_debug_enabled() else 3,
+        "train_iters": 1 if warp.context.runtime.core.wp_is_debug_enabled() else 3,
     },
     test_options_cpu={"train_iters": 1},
 )

warp/tests/test_fem.py

@@ -46,6 +46,11 @@ def linear_form(s: Sample, u: Field):
     return u(s)
 
 
+@integrand
+def bilinear_form(s: Sample, u: Field, v: Field):
+    return u(s) * v(s)
+
+
 @integrand
 def scaled_linear_form(s: Sample, u: Field, scale: wp.array(dtype=float)):
     return u(s) * scale[0]
@@ -869,7 +874,7 @@ def test_deformed_geometry(test, device):
             np.sum(side_measures.numpy()), scale**2 * (0.5 * 6 * (N + 1) + N * 2 * math.sqrt(3.0)), places=4
         )
 
-        @wp.kernel
+        @fem.cache.dynamic_kernel(suffix=deformed_geo.name, kernel_options={"enable_backward": False})
         def _test_deformed_geometry_normal(
             geo_index_arg: geo.SideIndexArg, geo_arg: geo.SideArg, def_arg: deformed_geo.SideArg, rotation: wp.vec3
         ):
@@ -921,7 +926,7 @@ def test_deformed_geometry_codimensional(test, device):
 
         deformed_geo = pos_field.make_deformed_geometry()
 
-        @wp.kernel
+        @fem.cache.dynamic_kernel(suffix=deformed_geo.name, kernel_options={"enable_backward": False})
         def _test_deformed_geometry_normal_codimensional(
             geo_arg: geo.CellArg, def_arg: deformed_geo.CellArg, rotation: wp.vec3
         ):
@@ -1868,8 +1873,6 @@ def test_vector_spaces(test, device):
             fields={"field": div_field.trace()},
         )
 
-    return
-
     with wp.ScopedDevice(device):
         positions, tri_vidx = _gen_trimesh(3, 5)
 
@@ -1953,7 +1956,7 @@ def test_vector_spaces(test, device):
         )
 
 
-@wp.kernel
+@wp.kernel(enable_backward=False)
 def test_qr_eigenvalues():
     tol = 5.0e-7
 
@@ -2008,7 +2011,7 @@ def test_qr_eigenvalues():
     wp.expect_near(wp.ddot(Err6, Err6), 0.0, 1.0e-13)
 
 
-@wp.kernel
+@wp.kernel(enable_backward=False)
 def test_qr_inverse():
     rng = wp.rand_init(4356, wp.tid())
     M = wp.mat33(
@@ -2055,6 +2058,45 @@ def test_array_axpy(test, device):
     assert_np_equal(y.grad.numpy(), beta * np.ones(N))
 
 
+def test_integrate_high_order(test_field, device):
+    with wp.ScopedDevice(device):
+        geo = fem.Grid3D(res=(1, 1, 1))
+        space = fem.make_polynomial_space(geo, degree=4)
+        test_field = fem.make_test(space)
+        trial_field = fem.make_trial(space)
+
+        # compare consistency of tile-based "dispatch" assembly and generic
+        v0 = fem.integrate(
+            linear_form, fields={"u": test_field}, assembly="dispatch", kernel_options={"enable_backward": False}
+        )
+        v1 = fem.integrate(
+            linear_form, fields={"u": test_field}, assembly="generic", kernel_options={"enable_backward": False}
+        )
+
+        assert_np_equal(v0.numpy(), v1.numpy(), tol=1.0e-6)
+
+        h0 = fem.integrate(
+            bilinear_form,
+            fields={"v": test_field, "u": trial_field},
+            assembly="dispatch",
+            kernel_options={"enable_backward": False},
+        )
+        h1 = fem.integrate(
+            bilinear_form,
+            fields={"v": test_field, "u": trial_field},
+            assembly="generic",
+            kernel_options={"enable_backward": False},
+        )
+
+        h0_nnz = h0.nnz_sync()
+        h1_nnz = h1.nnz_sync()
+        assert h0.shape == h1.shape
+        assert h0_nnz == h1_nnz
+        assert_array_equal(h0.offsets[: h0.nrow + 1], h1.offsets[: h1.nrow + 1])
+        assert_array_equal(h0.columns[:h0_nnz], h1.columns[:h1_nnz])
+        assert_np_equal(h0.values[:h0_nnz].numpy(), h1.values[:h1_nnz].numpy(), tol=1.0e-6)
+
+
 devices = get_test_devices()
 cuda_devices = get_selected_cuda_test_devices()
 
@@ -2088,6 +2130,7 @@ add_function_test(TestFem, "test_point_basis", test_point_basis)
 add_function_test(TestFem, "test_particle_quadratures", test_particle_quadratures)
 add_function_test(TestFem, "test_nodal_quadrature", test_nodal_quadrature)
 add_function_test(TestFem, "test_implicit_fields", test_implicit_fields)
+add_function_test(TestFem, "test_integrate_high_order", test_integrate_high_order, devices=cuda_devices)
 
 
 class TestFemUtilities(unittest.TestCase):