warp-lang 1.7.0__py3-none-macosx_10_13_universal2.whl → 1.7.2rc1__py3-none-macosx_10_13_universal2.whl

warp/tests/test_builtins_resolution.py

@@ -84,25 +84,25 @@ def test_int_int_args_support(test, device, dtype):
     else:
         with test.assertRaisesRegex(
             RuntimeError,
-            rf"Couldn't find a function 'mul' compatible with " rf"the arguments '{dtype.__name__}, int'$",
+            rf"Couldn't find a function 'mul' compatible with the arguments '{dtype.__name__}, int'$",
         ):
             wp.mul(dtype(value), value)
 
         with test.assertRaisesRegex(
             RuntimeError,
-            rf"Couldn't find a function 'mul' compatible with " rf"the arguments '{np_type.__name__}, int'$",
+            rf"Couldn't find a function 'mul' compatible with the arguments '{np_type.__name__}, int'$",
         ):
             wp.mul(nps(np_type, value), value)
 
         with test.assertRaisesRegex(
             RuntimeError,
-            rf"Couldn't find a function 'mul' compatible with " rf"the arguments 'int, {dtype.__name__}'$",
+            rf"Couldn't find a function 'mul' compatible with the arguments 'int, {dtype.__name__}'$",
         ):
             wp.mul(value, dtype(value))
 
         with test.assertRaisesRegex(
             RuntimeError,
-            rf"Couldn't find a function 'mul' compatible with " rf"the arguments 'int, {np_type.__name__}'$",
+            rf"Couldn't find a function 'mul' compatible with the arguments 'int, {np_type.__name__}'$",
         ):
             wp.mul(value, nps(np_type, value))
 
@@ -189,73 +189,73 @@ def test_mat_mat_args_support(test, device, dtype):
         else:
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'ddot' compatible with " r"the arguments 'mat_t, tuple'$",
+                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 " r"the arguments 'tuple, tuple'$",
+                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 " r"the arguments 'tuple, tuple'$",
+                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 " r"the arguments 'tuple, tuple'$",
+                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 " r"the arguments 'tuple, tuple'$",
+                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 " r"the arguments 'ndarray, tuple'$",
+                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 " r"the arguments 'tuple, mat_t'$",
+                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 " r"the arguments 'tuple, tuple'$",
+                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 " r"the arguments 'tuple, tuple'$",
+                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 " r"the arguments 'tuple, tuple'$",
+                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 " r"the arguments 'tuple, tuple'$",
+                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 " r"the arguments 'tuple, ndarray'$",
+                r"Couldn't find a function 'ddot' compatible with the arguments 'tuple, ndarray'$",
             ):
                 wp.ddot(a_values, np.array(npv(np_type, b_values)))
 
@@ -300,49 +300,49 @@ def test_mat_float_args_support(test, device, dtype):
         else:
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'mul' compatible with " r"the arguments 'mat_t, float'$",
+                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 " r"the arguments 'tuple, float'$",
+                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 " r"the arguments 'tuple, float'$",
+                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 " r"the arguments 'tuple, float'$",
+                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 " r"the arguments 'tuple, float'$",
+                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 " r"the arguments 'ndarray, float'$",
+                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 " rf"the arguments 'tuple, {dtype.__name__}'$",
+                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 " rf"the arguments 'tuple, {np_type.__name__}'$",
+                rf"Couldn't find a function 'mul' compatible with the arguments 'tuple, {np_type.__name__}'$",
             ):
                 wp.mul(a_values, nps(np_type, b_value))
 
@@ -401,49 +401,49 @@ def test_vec_vec_args_support(test, device, dtype):
         else:
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'dot' compatible with " r"the arguments 'vec_t, tuple'$",
+                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 " r"the arguments 'tuple, tuple'$",
+                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 " r"the arguments 'tuple, tuple'$",
+                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 " r"the arguments 'ndarray, tuple'$",
+                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 " r"the arguments 'tuple, vec_t'$",
+                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 " r"the arguments 'tuple, tuple'$",
+                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 " r"the arguments 'tuple, tuple'$",
+                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 " r"the arguments 'tuple, ndarray'$",
+                r"Couldn't find a function 'dot' compatible with the arguments 'tuple, ndarray'$",
             ):
                 wp.dot(a_values, np.array(npv(np_type, b_values)))
 
@@ -480,37 +480,37 @@ def test_vec_float_args_support(test, device, dtype):
         else:
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'mul' compatible with " r"the arguments 'vec_t, float'$",
+                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 " r"the arguments 'tuple, float'$",
+                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 " r"the arguments 'tuple, float'$",
+                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 " r"the arguments 'ndarray, float'$",
+                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 " rf"the arguments 'tuple, {dtype.__name__}'$",
+                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 " rf"the arguments 'tuple, {np_type.__name__}'$",
+                rf"Couldn't find a function 'mul' compatible with the arguments 'tuple, {np_type.__name__}'$",
             ):
                 wp.mul(a_values, nps(np_type, b_value))
 

warp/tests/test_codegen.py

@@ -482,7 +482,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 \[\"vector\(length=2, dtype=<class 'warp.types.float32'>\)\", \"vector\(length=2, dtype=<class 'warp.types.float16'>\)\"\]",
+        r"Input types must be exactly the same, got \['vec2f', 'vector\(length=2, dtype=float16\)'\]",
     ):
         wp.launch(kernel, dim=1, device=device)
 
@@ -672,6 +672,27 @@ def test_while_condition_eval():
         it.valid = False
 
 
+@wp.kernel
+def conditional_return_or_sum(result: wp.array(dtype=wp.int32)):
+    tid = wp.tid()
+
+    if tid < 256:
+        return
+
+    wp.atomic_add(result, 0, 1)
+
+
+def test_codegen_return_in_kernel(test, device):
+    result = wp.zeros(1, dtype=wp.int32, device=device)
+
+    grid_size = 1024
+
+    # On CUDA devices, this becomes a grid-stride loop
+    wp.launch(conditional_return_or_sum, dim=grid_size, inputs=[result], block_dim=256, max_blocks=1, device=device)
+
+    test.assertEqual(result.numpy()[0], grid_size - 256)
+
+
 class TestCodeGen(unittest.TestCase):
     pass
 
@@ -803,8 +824,8 @@ add_function_test(
 add_kernel_test(TestCodeGen, name="test_call_syntax", kernel=test_call_syntax, dim=1, devices=devices)
 add_kernel_test(TestCodeGen, name="test_shadow_builtin", kernel=test_shadow_builtin, dim=1, devices=devices)
 add_kernel_test(TestCodeGen, name="test_while_condition_eval", kernel=test_while_condition_eval, dim=1, devices=devices)
-
+add_function_test(TestCodeGen, "test_codegen_return_in_kernel", test_codegen_return_in_kernel, devices=devices)
 
 if __name__ == "__main__":
     wp.clear_kernel_cache()
-    unittest.main(verbosity=2, failfast=True)
+    unittest.main(verbosity=2)

warp/tests/test_examples.py

@@ -36,6 +36,7 @@ Use "test_timeout" to override the default test timeout threshold of 600 seconds
 """
 
 import os
+import platform
 import subprocess
 import sys
 import unittest
@@ -239,12 +240,21 @@ add_example_test(
     devices=test_devices,
     test_options={"usd_required": True, "headless": True},
 )
-add_example_test(
-    TestCoreExamples,
-    name="core.example_raymarch",
-    devices=test_devices,
-    test_options={"height": 512, "width": 1024, "headless": True},
-)
+if platform.system() == "Windows":
+    # Skip GPU testing because of obscure NVRTC bug with illegal memory access
+    add_example_test(
+        TestCoreExamples,
+        name="core.example_raymarch",
+        devices=[wp.get_device("cpu")],
+        test_options={"height": 512, "width": 1024, "headless": True},
+    )
+else:
+    add_example_test(
+        TestCoreExamples,
+        name="core.example_raymarch",
+        devices=test_devices,
+        test_options={"height": 512, "width": 1024, "headless": True},
+    )
 add_example_test(
     TestCoreExamples,
     name="core.example_sample_mesh",

warp/tests/test_fem.py

@@ -14,6 +14,7 @@
 # limitations under the License.
 
 import math
+import platform
 import unittest
 from typing import Any
 
@@ -475,6 +476,22 @@ def _test_geo_cells(
     wp.atomic_add(cell_measures, s.element_index, fem.measure(domain, s) * s.qp_weight)
 
 
+@fem.integrand(kernel_options={"enable_backward": False})
+def _test_cell_lookup(
+    s: fem.Sample,
+    domain: fem.Domain,
+):
+    pos = domain(s)
+
+    s_guess = fem.lookup(domain, pos, s)
+    wp.expect_eq(s_guess.element_index, s.element_index)
+    wp.expect_near(domain(s_guess), pos, 0.001)
+
+    s_noguess = fem.lookup(domain, pos)
+    wp.expect_eq(s_noguess.element_index, s.element_index)
+    wp.expect_near(domain(s_noguess), pos, 0.001)
+
+
 @fem.integrand(kernel_options={"enable_backward": False, "max_unroll": 1})
 def _test_geo_sides(
     s: fem.Sample,
@@ -527,7 +544,7 @@ def _test_side_normals(
         wp.expect_near(F_cross[k], nor[k], 0.0001)
 
 
-def _launch_test_geometry_kernel(geo: fem.Geometry, device):
+def _launch_test_geometry_kernel(geo: fem.Geometry, device, test_cell_lookup: bool = True):
     cell_measures = wp.zeros(dtype=float, device=device, shape=geo.cell_count())
     cell_quadrature = fem.RegularQuadrature(fem.Cells(geo), order=2)
 
@@ -540,6 +557,12 @@ def _launch_test_geometry_kernel(geo: fem.Geometry, device):
             quadrature=cell_quadrature,
             values={"cell_measures": cell_measures},
         )
+        if test_cell_lookup:
+            fem.interpolate(
+                _test_cell_lookup,
+                quadrature=cell_quadrature,
+            )
+
         fem.interpolate(
             _test_geo_sides,
             quadrature=side_quadrature,
@@ -577,7 +600,7 @@ def test_triangle_mesh(test, device):
     with wp.ScopedDevice(device):
         positions, tri_vidx = _gen_trimesh(N, N)
 
-    geo = fem.Trimesh2D(tri_vertex_indices=tri_vidx, positions=positions)
+    geo = fem.Trimesh2D(tri_vertex_indices=tri_vidx, positions=positions, build_bvh=True)
 
     test.assertEqual(geo.cell_count(), 2 * (N) ** 2)
     test.assertEqual(geo.vertex_count(), (N + 1) ** 2)
@@ -595,7 +618,7 @@ def test_triangle_mesh(test, device):
     positions = np.hstack((positions, np.ones((positions.shape[0], 1))))
     positions = wp.array(positions, device=device, dtype=wp.vec3)
 
-    geo = fem.Trimesh3D(tri_vertex_indices=tri_vidx, positions=positions)
+    geo = fem.Trimesh3D(tri_vertex_indices=tri_vidx, positions=positions, build_bvh=True)
 
     test.assertEqual(geo.cell_count(), 2 * (N) ** 2)
     test.assertEqual(geo.vertex_count(), (N + 1) ** 2)
@@ -621,7 +644,7 @@ def test_quad_mesh(test, device):
     test.assertEqual(geo.side_count(), 2 * (N + 1) * N)
     test.assertEqual(geo.boundary_side_count(), 4 * N)
 
-    side_measures, cell_measures = _launch_test_geometry_kernel(geo, device)
+    side_measures, cell_measures = _launch_test_geometry_kernel(geo, device, test_cell_lookup=False)
 
     assert_np_equal(side_measures.numpy(), np.full(side_measures.shape, 1.0 / (N)), tol=1.0e-4)
     assert_np_equal(cell_measures.numpy(), np.full(cell_measures.shape, 1.0 / (N**2)), tol=1.0e-4)
@@ -639,7 +662,7 @@ def test_quad_mesh(test, device):
     test.assertEqual(geo.side_count(), 2 * (N + 1) * N)
     test.assertEqual(geo.boundary_side_count(), 4 * N)
 
-    side_measures, cell_measures = _launch_test_geometry_kernel(geo, device)
+    side_measures, cell_measures = _launch_test_geometry_kernel(geo, device, test_cell_lookup=False)
 
     assert_np_equal(side_measures.numpy(), np.full(side_measures.shape, 1.0 / (N)), tol=1.0e-4)
     assert_np_equal(cell_measures.numpy(), np.full(cell_measures.shape, 1.0 / (N**2)), tol=1.0e-4)
@@ -668,7 +691,7 @@ def test_tet_mesh(test, device):
     with wp.ScopedDevice(device):
         positions, tet_vidx = _gen_tetmesh(N, N, N)
 
-    geo = fem.Tetmesh(tet_vertex_indices=tet_vidx, positions=positions)
+    geo = fem.Tetmesh(tet_vertex_indices=tet_vidx, positions=positions, build_bvh=True)
 
     test.assertEqual(geo.cell_count(), 5 * (N) ** 3)
     test.assertEqual(geo.vertex_count(), (N + 1) ** 3)
@@ -696,7 +719,7 @@ def test_hex_mesh(test, device):
     test.assertEqual(geo.boundary_side_count(), 6 * N * N)
     test.assertEqual(geo.edge_count(), 3 * N * (N + 1) ** 2)
 
-    side_measures, cell_measures = _launch_test_geometry_kernel(geo, device)
+    side_measures, cell_measures = _launch_test_geometry_kernel(geo, device, test_cell_lookup=False)
 
     assert_np_equal(side_measures.numpy(), np.full(side_measures.shape, 1.0 / (N**2)), tol=1.0e-4)
     assert_np_equal(cell_measures.numpy(), np.full(cell_measures.shape, 1.0 / (N**3)), tol=1.0e-4)
@@ -732,6 +755,9 @@ def _refinement_field(x: wp.vec3):
 def test_adaptive_nanogrid(test, device):
     # 3 res-1 voxels, 8 res-0 voxels
 
+    if platform.system() == "Windows" or (device.is_cuda and wp.context.runtime.toolkit_version[0] == 11):
+        test.skipTest("Skipping test due to NVRTC bug on CUDA 11 and Windows")
+
     res0 = wp.array(
         [
             [2, 2, 0],
@@ -756,7 +782,6 @@ def test_adaptive_nanogrid(test, device):
         dtype=int,
         device=device,
     )
-
     grid0 = wp.Volume.allocate_by_voxels(res0, 0.5, device=device)
     grid1 = wp.Volume.allocate_by_voxels(res1, 1.0, device=device)
     geo = fem.adaptive_nanogrid_from_hierarchy([grid0, grid1])
@@ -793,15 +818,15 @@ def _rigid_deformation_field(s: Sample, domain: Domain, translation: wp.vec3, ro
 def test_deformed_geometry(test, device):
     N = 3
 
+    translation = [1.0, 2.0, 3.0]
+    rotation = [0.0, math.pi / 4.0, 0.0]
+    scale = 2.0
+
     with wp.ScopedDevice(device):
         positions, tet_vidx = _gen_tetmesh(N, N, N)
 
         geo = fem.Tetmesh(tet_vertex_indices=tet_vidx, positions=positions)
 
-        translation = [1.0, 2.0, 3.0]
-        rotation = [0.0, math.pi / 4.0, 0.0]
-        scale = 2.0
-
         vector_space = fem.make_polynomial_space(geo, dtype=wp.vec3, degree=2)
         pos_field = vector_space.make_field()
         fem.interpolate(
@@ -819,7 +844,7 @@ def test_deformed_geometry(test, device):
         test.assertEqual(geo.side_count(), 6 * (N + 1) * N**2 + (N**3) * 4)
         test.assertEqual(geo.boundary_side_count(), 12 * N * N)
 
-        side_measures, cell_measures = _launch_test_geometry_kernel(deformed_geo, wp.get_device())
+        side_measures, cell_measures = _launch_test_geometry_kernel(deformed_geo, device, test_cell_lookup=False)
 
         test.assertAlmostEqual(
             np.sum(cell_measures.numpy()), scale**3, places=4, msg=f"cell_measures = {cell_measures.numpy()}"
@@ -853,6 +878,56 @@ def test_deformed_geometry(test, device):
             ],
         )
 
+
+def test_deformed_geometry_codimensional(test, device):
+    N = 3
+
+    translation = [1.0, 2.0, 3.0]
+    rotation = [0.0, math.pi / 4.0, 0.0]
+    scale = 2.0
+
+    with wp.ScopedDevice(device):
+        # Test with Trimesh3d (different space and cell dimensions)
+        positions, tri_vidx = _gen_trimesh(N, N)
+        positions = positions.numpy()
+        positions = np.hstack((positions, np.ones((positions.shape[0], 1))))
+        positions = wp.array(positions, device=device, dtype=wp.vec3)
+
+        geo = fem.Trimesh3D(tri_vertex_indices=tri_vidx, positions=positions)
+
+        vector_space = fem.make_polynomial_space(geo, dtype=wp.vec3, degree=1)
+        pos_field = vector_space.make_field()
+        fem.interpolate(
+            _rigid_deformation_field,
+            dest=pos_field,
+            values={"translation": translation, "rotation": rotation, "scale": scale},
+        )
+
+        deformed_geo = pos_field.make_deformed_geometry()
+
+        @wp.kernel
+        def _test_deformed_geometry_normal_codimensional(
+            geo_arg: geo.CellArg, def_arg: deformed_geo.CellArg, rotation: wp.vec3
+        ):
+            i = wp.tid()
+
+            s = make_free_sample(i, Coords(0.5, 0.5, 0.0))
+            geo_n = geo.cell_normal(geo_arg, s)
+            def_n = deformed_geo.cell_normal(def_arg, s)
+
+            q = wp.quat_from_axis_angle(wp.normalize(rotation), wp.length(rotation))
+            wp.expect_near(wp.quat_rotate(q, geo_n), def_n, 0.001)
+
+        wp.launch(
+            _test_deformed_geometry_normal_codimensional,
+            dim=geo.cell_count(),
+            inputs=[
+                geo.cell_arg_value(wp.get_device()),
+                deformed_geo.cell_arg_value(wp.get_device()),
+                rotation,
+            ],
+        )
+
     wp.synchronize()
 
 
@@ -1847,7 +1922,7 @@ def test_vector_spaces(test, device):
 
 @wp.kernel
 def test_qr_eigenvalues():
-    tol = 1.0e-8
+    tol = 5.0e-7
 
     # zero
     Zero = wp.mat33(0.0)
@@ -1971,6 +2046,9 @@ add_function_test(TestFem, "test_hex_mesh", test_hex_mesh, devices=devices)
 add_function_test(TestFem, "test_nanogrid", test_nanogrid, devices=cuda_devices)
 add_function_test(TestFem, "test_adaptive_nanogrid", test_adaptive_nanogrid, devices=cuda_devices)
 add_function_test(TestFem, "test_deformed_geometry", test_deformed_geometry, devices=devices)
+add_function_test(
+    TestFem, "test_deformed_geometry_codimensional", test_deformed_geometry_codimensional, devices=devices
+)
 add_function_test(TestFem, "test_vector_spaces", test_vector_spaces, devices=devices)
 add_function_test(TestFem, "test_dof_mapper", test_dof_mapper)
 add_function_test(TestFem, "test_point_basis", test_point_basis)
@@ -1984,6 +2062,7 @@ class TestFemUtilities(unittest.TestCase):
 
 
 add_kernel_test(TestFemUtilities, test_qr_eigenvalues, dim=1, devices=devices)
+
 add_kernel_test(TestFemUtilities, test_qr_inverse, dim=100, devices=devices)
 add_function_test(TestFemUtilities, "test_array_axpy", test_array_axpy)
 

warp/tests/test_func.py

@@ -421,7 +421,7 @@ class TestFunc(unittest.TestCase):
         b = wp.mat22d(1.0, 2.0, 3.0, 4.0)
         with self.assertRaisesRegex(
             RuntimeError,
-            r"^Couldn't find a function 'mul' compatible with " r"the arguments 'mat22f, mat22d'$",
+            r"^Couldn't find a function 'mul' compatible with the arguments 'mat22f, mat22d'$",
         ):
             a * b