warp-lang 1.8.0__py3-none-macosx_10_13_universal2.whl → 1.9.0__py3-none-macosx_10_13_universal2.whl

warp/tests/test_vec.py

@@ -74,111 +74,6 @@ def test_length_mismatch(test, device):
         wp.launch(kernel, dim=1, inputs=[], device=device)
 
 
-def test_anon_constructor_error_length_mismatch(test, device):
-    @wp.kernel
-    def kernel():
-        wp.vector(
-            wp.vector(length=2, dtype=float),
-            length=3,
-            dtype=float,
-        )
-
-    with test.assertRaisesRegex(
-        RuntimeError,
-        r"incompatible vector of length 3 given when copy constructing a vector of length 2$",
-    ):
-        wp.launch(
-            kernel,
-            dim=1,
-            inputs=[],
-            device=device,
-        )
-
-
-def test_anon_constructor_error_numeric_arg_missing(test, device):
-    @wp.kernel
-    def kernel():
-        wp.vector(1.0, 2.0, length=12345)
-
-    with test.assertRaisesRegex(
-        RuntimeError,
-        r"incompatible number of values given \(2\) when constructing a vector of length 12345$",
-    ):
-        wp.launch(
-            kernel,
-            dim=1,
-            inputs=[],
-            device=device,
-        )
-
-
-def test_anon_constructor_error_length_arg_missing(test, device):
-    @wp.kernel
-    def kernel():
-        wp.vector()
-
-    with test.assertRaisesRegex(
-        RuntimeError,
-        r"the `length` argument must be specified when zero-initializing a vector$",
-    ):
-        wp.launch(
-            kernel,
-            dim=1,
-            inputs=[],
-            device=device,
-        )
-
-
-def test_anon_constructor_error_numeric_args_mismatch(test, device):
-    @wp.kernel
-    def kernel():
-        wp.vector(1.0, 2)
-
-    with test.assertRaisesRegex(
-        RuntimeError,
-        r"all values given when constructing a vector must have the same type$",
-    ):
-        wp.launch(
-            kernel,
-            dim=1,
-            inputs=[],
-            device=device,
-        )
-
-
-def test_tpl_constructor_error_incompatible_sizes(test, device):
-    @wp.kernel
-    def kernel():
-        wp.vec3(wp.vec2(1.0, 2.0))
-
-    with test.assertRaisesRegex(
-        RuntimeError, "incompatible vector of length 3 given when copy constructing a vector of length 2"
-    ):
-        wp.launch(
-            kernel,
-            dim=1,
-            inputs=[],
-            device=device,
-        )
-
-
-def test_tpl_constructor_error_numeric_args_mismatch(test, device):
-    @wp.kernel
-    def kernel():
-        wp.vec2(1.0, 2)
-
-    with test.assertRaisesRegex(
-        RuntimeError,
-        r"all values given when constructing a vector must have the same type$",
-    ):
-        wp.launch(
-            kernel,
-            dim=1,
-            inputs=[],
-            device=device,
-        )
-
-
 def test_negation(test, device, dtype, register_kernels=False):
     rng = np.random.default_rng(123)
 
@@ -312,32 +207,15 @@ def test_subtraction_unsigned(test, device, dtype, register_kernels=False):
     def check_subtraction_unsigned():
         wp.expect_eq(vec2(wptype(3), wptype(4)) - vec2(wptype(1), wptype(2)), vec2(wptype(2), wptype(2)))
         wp.expect_eq(
-            vec3(
-                wptype(3),
-                wptype(4),
-                wptype(4),
-            )
-            - vec3(wptype(1), wptype(2), wptype(3)),
+            vec3(wptype(3), wptype(4), wptype(4)) - vec3(wptype(1), wptype(2), wptype(3)),
             vec3(wptype(2), wptype(2), wptype(1)),
         )
         wp.expect_eq(
-            vec4(
-                wptype(3),
-                wptype(4),
-                wptype(4),
-                wptype(5),
-            )
-            - vec4(wptype(1), wptype(2), wptype(3), wptype(4)),
+            vec4(wptype(3), wptype(4), wptype(4), wptype(5)) - vec4(wptype(1), wptype(2), wptype(3), wptype(4)),
             vec4(wptype(2), wptype(2), wptype(1), wptype(1)),
         )
         wp.expect_eq(
-            vec5(
-                wptype(3),
-                wptype(4),
-                wptype(4),
-                wptype(5),
-                wptype(4),
-            )
+            vec5(wptype(3), wptype(4), wptype(4), wptype(5), wptype(4))
             - vec5(wptype(1), wptype(2), wptype(3), wptype(4), wptype(4)),
             vec5(wptype(2), wptype(2), wptype(1), wptype(1), wptype(0)),
         )
@@ -445,16 +323,7 @@ def test_subtraction(test, device, dtype, register_kernels=False):
         wp.launch(
             kernel,
             dim=1,
-            inputs=[
-                s2,
-                s3,
-                s4,
-                s5,
-                v2,
-                v3,
-                v4,
-                v5,
-            ],
+            inputs=[s2, s3, s4, s5, v2, v3, v4, v5],
             outputs=[v20, v21, v30, v31, v32, v40, v41, v42, v43, v50, v51, v52, v53, v54],
             device=device,
         )
@@ -557,18 +426,7 @@ def test_length(test, device, dtype, register_kernels=False):
 
     tape = wp.Tape()
     with tape:
-        wp.launch(
-            kernel,
-            dim=1,
-            inputs=[
-                v2,
-                v3,
-                v4,
-                v5,
-            ],
-            outputs=[l2, l3, l4, l5, l22, l23, l24, l25],
-            device=device,
-        )
+        wp.launch(kernel, dim=1, inputs=[v2, v3, v4, v5], outputs=[l2, l3, l4, l5, l22, l23, l24, l25], device=device)
 
     assert_np_equal(l2.numpy()[0], 2 * np.linalg.norm(v2.numpy()), tol=10 * tol)
     assert_np_equal(l3.numpy()[0], 2 * np.linalg.norm(v3.numpy()), tol=10 * tol)
@@ -791,18 +649,7 @@ def test_normalize(test, device, dtype, register_kernels=False):
     ]
     tape0 = wp.Tape()
     with tape0:
-        wp.launch(
-            normalize_kernel,
-            dim=1,
-            inputs=[
-                v2,
-                v3,
-                v4,
-                v5,
-            ],
-            outputs=outputs0,
-            device=device,
-        )
+        wp.launch(normalize_kernel, dim=1, inputs=[v2, v3, v4, v5], outputs=outputs0, device=device)
 
     outputs1 = [
         n20_alt,
@@ -838,22 +685,7 @@ def test_normalize(test, device, dtype, register_kernels=False):
     for ncmp, ncmpalt in zip(outputs0, outputs1):
         assert_np_equal(ncmp.numpy()[0], ncmpalt.numpy()[0], tol=10 * tol)
 
-    invecs = [
-        v2,
-        v2,
-        v3,
-        v3,
-        v3,
-        v4,
-        v4,
-        v4,
-        v4,
-        v5,
-        v5,
-        v5,
-        v5,
-        v5,
-    ]
+    invecs = [v2, v2, v3, v3, v3, v4, v4, v4, v4, v5, v5, v5, v5, v5]
     for ncmp, ncmpalt, v in zip(outputs0, outputs1, invecs):
         tape0.backward(loss=ncmp)
         tape1.backward(loss=ncmpalt)
@@ -957,154 +789,7 @@ def test_crossproduct(test, device, dtype, register_kernels=False):
         tape.zero()
 
 
-def test_casting_constructors(test, device, dtype, register_kernels=False):
-    np_type = np.dtype(dtype)
-    wp_type = wp.types.np_dtype_to_warp_type[np_type]
-    vec3 = wp.types.vector(length=3, dtype=wp_type)
-
-    np16 = np.dtype(np.float16)
-    wp16 = wp.types.np_dtype_to_warp_type[np16]
-
-    np32 = np.dtype(np.float32)
-    wp32 = wp.types.np_dtype_to_warp_type[np32]
-
-    np64 = np.dtype(np.float64)
-    wp64 = wp.types.np_dtype_to_warp_type[np64]
-
-    def cast_float16(a: wp.array(dtype=wp_type, ndim=2), b: wp.array(dtype=wp16, ndim=2)):
-        tid = wp.tid()
-
-        v1 = vec3(a[tid, 0], a[tid, 1], a[tid, 2])
-        v2 = wp.vector(v1, dtype=wp16)
-
-        b[tid, 0] = v2[0]
-        b[tid, 1] = v2[1]
-        b[tid, 2] = v2[2]
-
-    def cast_float32(a: wp.array(dtype=wp_type, ndim=2), b: wp.array(dtype=wp32, ndim=2)):
-        tid = wp.tid()
-
-        v1 = vec3(a[tid, 0], a[tid, 1], a[tid, 2])
-        v2 = wp.vector(v1, dtype=wp32)
-
-        b[tid, 0] = v2[0]
-        b[tid, 1] = v2[1]
-        b[tid, 2] = v2[2]
-
-    def cast_float64(a: wp.array(dtype=wp_type, ndim=2), b: wp.array(dtype=wp64, ndim=2)):
-        tid = wp.tid()
-
-        v1 = vec3(a[tid, 0], a[tid, 1], a[tid, 2])
-        v2 = wp.vector(v1, dtype=wp64)
-
-        b[tid, 0] = v2[0]
-        b[tid, 1] = v2[1]
-        b[tid, 2] = v2[2]
-
-    kernel_16 = getkernel(cast_float16, suffix=dtype.__name__)
-    kernel_32 = getkernel(cast_float32, suffix=dtype.__name__)
-    kernel_64 = getkernel(cast_float64, suffix=dtype.__name__)
-
-    if register_kernels:
-        return
-
-    # check casting to float 16
-    a = wp.array(np.ones((1, 3), dtype=np_type), dtype=wp_type, requires_grad=True, device=device)
-    b = wp.array(np.zeros((1, 3), dtype=np16), dtype=wp16, requires_grad=True, device=device)
-    b_result = np.ones((1, 3), dtype=np16)
-    b_grad = wp.array(np.ones((1, 3), dtype=np16), dtype=wp16, device=device)
-    a_grad = wp.array(np.ones((1, 3), dtype=np_type), dtype=wp_type, device=device)
-
-    tape = wp.Tape()
-    with tape:
-        wp.launch(kernel=kernel_16, dim=1, inputs=[a, b], device=device)
-
-    tape.backward(grads={b: b_grad})
-    out = tape.gradients[a].numpy()
-
-    assert_np_equal(b.numpy(), b_result)
-    assert_np_equal(out, a_grad.numpy())
-
-    # check casting to float 32
-    a = wp.array(np.ones((1, 3), dtype=np_type), dtype=wp_type, requires_grad=True, device=device)
-    b = wp.array(np.zeros((1, 3), dtype=np32), dtype=wp32, requires_grad=True, device=device)
-    b_result = np.ones((1, 3), dtype=np32)
-    b_grad = wp.array(np.ones((1, 3), dtype=np32), dtype=wp32, device=device)
-    a_grad = wp.array(np.ones((1, 3), dtype=np_type), dtype=wp_type, device=device)
-
-    tape = wp.Tape()
-    with tape:
-        wp.launch(kernel=kernel_32, dim=1, inputs=[a, b], device=device)
-
-    tape.backward(grads={b: b_grad})
-    out = tape.gradients[a].numpy()
-
-    assert_np_equal(b.numpy(), b_result)
-    assert_np_equal(out, a_grad.numpy())
-
-    # check casting to float 64
-    a = wp.array(np.ones((1, 3), dtype=np_type), dtype=wp_type, requires_grad=True, device=device)
-    b = wp.array(np.zeros((1, 3), dtype=np64), dtype=wp64, requires_grad=True, device=device)
-    b_result = np.ones((1, 3), dtype=np64)
-    b_grad = wp.array(np.ones((1, 3), dtype=np64), dtype=wp64, device=device)
-    a_grad = wp.array(np.ones((1, 3), dtype=np_type), dtype=wp_type, device=device)
-
-    tape = wp.Tape()
-    with tape:
-        wp.launch(kernel=kernel_64, dim=1, inputs=[a, b], device=device)
-
-    tape.backward(grads={b: b_grad})
-    out = tape.gradients[a].numpy()
-
-    assert_np_equal(b.numpy(), b_result)
-    assert_np_equal(out, a_grad.numpy())
-
-
-@wp.kernel
-def test_vector_constructor_value_func():
-    a = wp.vec2()
-    b = wp.vector(a, dtype=wp.float16)
-    c = wp.vector(a)
-    d = wp.vector(a, length=2)
-    e = wp.vector(1.0, 2.0, 3.0, dtype=float)
-
-
-# Test matrix constructors using explicit type (float16)
-# note that these tests are specifically not using generics / closure
-# args to create kernels dynamically (like the rest of this file)
-# as those use different code paths to resolve arg types which
-# has lead to regressions.
-@wp.kernel
-def test_constructors_explicit_precision():
-    # construction for custom matrix types
-    ones = wp.vector(wp.float16(1.0), length=2)
-    zeros = wp.vector(length=2, dtype=wp.float16)
-    custom = wp.vector(wp.float16(0.0), wp.float16(1.0))
-
-    for i in range(2):
-        wp.expect_eq(ones[i], wp.float16(1.0))
-        wp.expect_eq(zeros[i], wp.float16(0.0))
-        wp.expect_eq(custom[i], wp.float16(i))
-
-
-# Same as above but with a default (float/int) type
-# which tests some different code paths that
-# need to ensure types are correctly canonicalized
-# during codegen
-@wp.kernel
-def test_constructors_default_precision():
-    # construction for custom matrix types
-    ones = wp.vector(1.0, length=2)
-    zeros = wp.vector(length=2, dtype=float)
-    custom = wp.vector(0.0, 1.0)
-
-    for i in range(2):
-        wp.expect_eq(ones[i], 1.0)
-        wp.expect_eq(zeros[i], 0.0)
-        wp.expect_eq(custom[i], float(i))
-
-
-@wp.kernel
+@wp.kernel(module="unique")
 def test_vector_mutation(expected: wp.types.vector(length=10, dtype=float)):
     v = wp.vector(length=10, dtype=float)
 
@@ -1117,30 +802,11 @@ def test_vector_mutation(expected: wp.types.vector(length=10, dtype=float)):
     wp.expect_eq(v, expected)
 
 
-CONSTANT_LENGTH = wp.constant(10)
-
-
-# tests that we can use global constants in length keyword argument
-# for vector constructor
-@wp.kernel
-def test_constructors_constant_length():
-    v = wp.vector(length=(CONSTANT_LENGTH), dtype=float)
-
-    for i in range(CONSTANT_LENGTH):
-        v[i] = float(i)
-
-
 Vec123 = wp.vec(123, dtype=wp.float16)
 
 
-@wp.kernel
-def vector_len_kernel(
-    v1: wp.vec2,
-    v2: wp.vec(3, float),
-    v3: wp.vec(Any, float),
-    v4: Vec123,
-    out: wp.array(dtype=int),
-):
+@wp.kernel(module="unique")
+def vector_len_kernel(v1: wp.vec2, v2: wp.vec(3, float), v3: wp.vec(Any, float), v4: Vec123, out: wp.array(dtype=int)):
     length = wp.static(len(v1))
     wp.expect_eq(len(v1), 2)
     out[0] = len(v1)
@@ -1256,39 +922,6 @@ def test_vec_assign(test, device):
     run(vec_assign_attribute)
 
 
-def test_vec_assign_copy(test, device):
-    saved_enable_vector_component_overwrites_setting = wp.config.enable_vector_component_overwrites
-    try:
-        wp.config.enable_vector_component_overwrites = True
-
-        @wp.kernel
-        def vec_assign_overwrite(x: wp.array(dtype=wp.vec3), y: wp.array(dtype=wp.vec3)):
-            tid = wp.tid()
-
-            a = wp.vec3()
-            b = x[tid]
-            a = b
-            a[1] = 3.0
-
-            y[tid] = a
-
-        x = wp.ones(1, dtype=wp.vec3, device=device, requires_grad=True)
-        y = wp.zeros(1, dtype=wp.vec3, device=device, requires_grad=True)
-
-        tape = wp.Tape()
-        with tape:
-            wp.launch(vec_assign_overwrite, dim=1, inputs=[x, y], device=device)
-
-        y.grad = wp.ones_like(y, requires_grad=False)
-        tape.backward()
-
-        assert_np_equal(y.numpy(), np.array([[1.0, 3.0, 1.0]], dtype=float))
-        assert_np_equal(x.grad.numpy(), np.array([[1.0, 0.0, 1.0]], dtype=float))
-
-    finally:
-        wp.config.enable_vector_component_overwrites = saved_enable_vector_component_overwrites_setting
-
-
 @wp.kernel
 def vec_array_extract_subscript(x: wp.array2d(dtype=wp.vec3), y: wp.array2d(dtype=float)):
     i, j = wp.tid()
@@ -1364,7 +997,7 @@ def test_vec_array_assign(test, device):
     run(vec_array_assign_attribute)
 
 
-@wp.kernel
+@wp.kernel(module="unique")
 def vec_add_inplace_subscript(x: wp.array(dtype=wp.vec3), y: wp.array(dtype=wp.vec3)):
     i = wp.tid()
 
@@ -1378,7 +1011,7 @@ def vec_add_inplace_subscript(x: wp.array(dtype=wp.vec3), y: wp.array(dtype=wp.v
     y[i] = a
 
 
-@wp.kernel
+@wp.kernel(module="unique")
 def vec_add_inplace_attribute(x: wp.array(dtype=wp.vec3), y: wp.array(dtype=wp.vec3)):
     i = wp.tid()
 
@@ -1458,7 +1091,7 @@ def test_vec_sub_inplace(test, device):
     run(vec_sub_inplace_attribute)
 
 
-@wp.kernel
+@wp.kernel(module="unique")
 def vec_array_add_inplace(x: wp.array(dtype=wp.vec3), y: wp.array(dtype=wp.vec3)):
     i = wp.tid()
 
@@ -1502,6 +1135,202 @@ def test_vec_array_sub_inplace(test, device):
     assert_np_equal(x.grad.numpy(), np.array([[-1.0, -1.0, -1.0]], dtype=float))
 
 
+@wp.kernel
+def scalar_vec_div(x: wp.array(dtype=wp.vec3), y: wp.array(dtype=wp.vec3)):
+    i = wp.tid()
+    y[i] = 1.0 / x[i]
+
+
+def test_scalar_vec_div(test, device):
+    x = wp.array((wp.vec3(1.0, 2.0, 4.0),), dtype=wp.vec3, requires_grad=True, device=device)
+    y = wp.ones(1, dtype=wp.vec3, requires_grad=True, device=device)
+
+    tape = wp.Tape()
+    with tape:
+        wp.launch(scalar_vec_div, 1, inputs=(x,), outputs=(y,), device=device)
+
+    y.grad = wp.ones_like(y)
+    tape.backward()
+
+    assert_np_equal(y.numpy(), np.array(((1.0, 0.5, 0.25),), dtype=float))
+    assert_np_equal(x.grad.numpy(), np.array(((-1.0, -0.25, -0.0625),), dtype=float))
+
+
+def test_vec_indexing_assign(test, device):
+    @wp.func
+    def fn():
+        v = wp.vec4(1.0, 2.0, 3.0, 4.0)
+
+        v[0] = 123.0
+        v[1] *= 2.0
+
+        wp.expect_eq(v[0], 123.0)
+        wp.expect_eq(v[1], 4.0)
+        wp.expect_eq(v[2], 3.0)
+        wp.expect_eq(v[3], 4.0)
+
+        v[-1] = 123.0
+        v[-2] *= 2.0
+
+        wp.expect_eq(v[-1], 123.0)
+        wp.expect_eq(v[-2], 6.0)
+        wp.expect_eq(v[-3], 4.0)
+        wp.expect_eq(v[-4], 123.0)
+
+    @wp.kernel(module="unique")
+    def kernel():
+        fn()
+
+    wp.launch(kernel, 1, device=device)
+    wp.synchronize()
+    fn()
+
+
+def test_vec_slicing_assign(test, device):
+    vec0 = wp.vec(0, float)
+    vec1 = wp.vec(1, float)
+    vec2 = wp.vec(2, float)
+    vec3 = wp.vec(3, float)
+    vec4 = wp.vec(4, float)
+
+    @wp.func
+    def fn():
+        v = wp.vec4(1.0, 2.0, 3.0, 4.0)
+
+        wp.expect_eq(v[:] == vec4(1.0, 2.0, 3.0, 4.0), True)
+        wp.expect_eq(v[-123:123] == vec4(1.0, 2.0, 3.0, 4.0), True)
+        wp.expect_eq(v[123:] == vec0(), True)
+        wp.expect_eq(v[:-123] == vec0(), True)
+        wp.expect_eq(v[::123] == vec1(1.0), True)
+
+        wp.expect_eq(v[1:] == vec3(2.0, 3.0, 4.0), True)
+        wp.expect_eq(v[-2:] == vec2(3.0, 4.0), True)
+        wp.expect_eq(v[:2] == vec2(1.0, 2.0), True)
+        wp.expect_eq(v[:-1] == vec3(1.0, 2.0, 3.0), True)
+        wp.expect_eq(v[::2] == vec2(1.0, 3.0), True)
+        wp.expect_eq(v[1::2] == vec2(2.0, 4.0), True)
+        wp.expect_eq(v[::-1] == vec4(4.0, 3.0, 2.0, 1.0), True)
+        wp.expect_eq(v[::-2] == vec2(4.0, 2.0), True)
+        wp.expect_eq(v[1::-2] == vec1(2.0), True)
+
+        v[1:] = vec3(5.0, 6.0, 7.0)
+        wp.expect_eq(v == wp.vec4(1.0, 5.0, 6.0, 7.0), True)
+
+        v[-2:] = vec2(8.0, 9.0)
+        wp.expect_eq(v == wp.vec4(1.0, 5.0, 8.0, 9.0), True)
+
+        v[:2] = vec2(10.0, 11.0)
+        wp.expect_eq(v == wp.vec4(10.0, 11.0, 8.0, 9.0), True)
+
+        v[:-1] = vec3(12.0, 13.0, 14.0)
+        wp.expect_eq(v == wp.vec4(12.0, 13.0, 14.0, 9.0), True)
+
+        v[::2] = vec2(15.0, 16.0)
+        wp.expect_eq(v == wp.vec4(15.0, 13.0, 16.0, 9.0), True)
+
+        v[1::2] = vec2(17.0, 18.0)
+        wp.expect_eq(v == wp.vec4(15.0, 17.0, 16.0, 18.0), True)
+
+        v[::-1] = vec4(19.0, 20.0, 21.0, 22.0)
+        wp.expect_eq(v == wp.vec4(22.0, 21.0, 20.0, 19.0), True)
+
+        v[::-2] = vec2(23.0, 24.0)
+        wp.expect_eq(v == wp.vec4(22.0, 24.0, 20.0, 23.0), True)
+
+        v[1::-2] = vec1(25.0)
+        wp.expect_eq(v == wp.vec4(22.0, 25.0, 20.0, 23.0), True)
+
+        v[1:] += vec3(26.0, 27.0, 28.0)
+        wp.expect_eq(v == wp.vec4(22.0, 51.0, 47.0, 51.0), True)
+
+        v[:-1] -= vec3(29.0, 30.0, 31.0)
+        wp.expect_eq(v == wp.vec4(-7.0, 21.0, 16.0, 51.0), True)
+
+        v[:] %= vec4(32.0, 33.0, 34.0, 35.0)
+        wp.expect_eq(v == wp.vec4(-7.0, 21.0, 16.0, 16.0), True)
+
+    @wp.kernel(module="unique")
+    def kernel():
+        fn()
+
+    wp.launch(kernel, 1, device=device)
+    wp.synchronize()
+    fn()
+
+
+def test_vec_assign_inplace_errors(test, device):
+    @wp.kernel
+    def kernel_1():
+        v = wp.vec4(1.0, 2.0, 3.0, 4.0)
+        v[1:] = wp.vec3d(wp.float64(5.0), wp.float64(6.0), wp.float64(7.0))
+
+    with test.assertRaisesRegex(
+        ValueError,
+        r"The provided vector is expected to be of length 3 with dtype float32.$",
+    ):
+        wp.launch(kernel_1, dim=1, device=device)
+
+    @wp.kernel
+    def kernel_2():
+        v = wp.vec4(1.0, 2.0, 3.0, 4.0)
+        v[1:] = wp.float64(5.0)
+
+    with test.assertRaisesRegex(
+        ValueError,
+        r"The provided value is expected to be a vector of length 3, with dtype float32.$",
+    ):
+        wp.launch(kernel_2, dim=1, device=device)
+
+    @wp.kernel
+    def kernel_3():
+        v = wp.vec4(1.0, 2.0, 3.0, 4.0)
+        v[1:] = wp.mat22(5.0, 6.0, 7.0, 8.0)
+
+    with test.assertRaisesRegex(
+        ValueError,
+        r"The provided value is expected to be a vector of length 3, with dtype float32.$",
+    ):
+        wp.launch(kernel_3, dim=1, device=device)
+
+    @wp.kernel
+    def kernel_4():
+        v = wp.vec4(1.0, 2.0, 3.0, 4.0)
+        v[1:] = wp.vec2(5.0, 6.0)
+
+    with test.assertRaisesRegex(
+        ValueError,
+        r"The length of the provided vector \(2\) isn't compatible with the given slice \(expected 3\).$",
+    ):
+        wp.launch(kernel_4, dim=1, device=device)
+
+
+def test_vec_slicing_assign_backward(test, device):
+    @wp.kernel(module="unique")
+    def kernel(arr_x: wp.array(dtype=wp.vec2), arr_y: wp.array(dtype=wp.vec4)):
+        i = wp.tid()
+
+        y = arr_y[i]
+
+        y[:2] = arr_x[i]
+        y[1:-1] += arr_x[i][:2]
+        y[3:1:-1] -= arr_x[i][0:]
+
+        arr_y[i] = y
+
+    x = wp.ones(1, dtype=wp.vec2, requires_grad=True, device=device)
+    y = wp.zeros(1, dtype=wp.vec4, requires_grad=True, device=device)
+
+    tape = wp.Tape()
+    with tape:
+        wp.launch(kernel, 1, inputs=(x,), outputs=(y,), device=device)
+
+    y.grad = wp.ones_like(y)
+    tape.backward()
+
+    assert_np_equal(y.numpy(), np.array(((1.0, 2.0, 0.0, -1.0),), dtype=float))
+    assert_np_equal(x.grad.numpy(), np.array(((1.0, 1.0),), dtype=float))
+
+
 devices = get_test_devices()
 
 
@@ -1520,11 +1349,6 @@ class TestVec(unittest.TestCase):
         self.assertSequenceEqual(v, (0, 1, 2))
 
 
-add_kernel_test(TestVec, test_vector_constructor_value_func, dim=1, devices=devices)
-add_kernel_test(TestVec, test_constructors_explicit_precision, dim=1, devices=devices)
-add_kernel_test(TestVec, test_constructors_default_precision, dim=1, devices=devices)
-add_kernel_test(TestVec, test_constructors_constant_length, dim=1, devices=devices)
-
 vec10 = wp.types.vector(length=10, dtype=float)
 add_kernel_test(
     TestVec,
@@ -1561,71 +1385,22 @@ for dtype in np_float_types:
     add_function_test_register_kernel(
         TestVec, f"test_normalize_{dtype.__name__}", test_normalize, devices=devices, dtype=dtype
     )
-    add_function_test_register_kernel(
-        TestVec,
-        f"test_casting_constructors_{dtype.__name__}",
-        test_casting_constructors,
-        devices=devices,
-        dtype=dtype,
-    )
 
-add_function_test(
-    TestVec,
-    "test_length_mismatch",
-    test_length_mismatch,
-    devices=devices,
-)
-add_function_test(
-    TestVec,
-    "test_anon_constructor_error_length_mismatch",
-    test_anon_constructor_error_length_mismatch,
-    devices=devices,
-)
-add_function_test(
-    TestVec,
-    "test_anon_constructor_error_numeric_arg_missing",
-    test_anon_constructor_error_numeric_arg_missing,
-    devices=devices,
-)
-add_function_test(
-    TestVec,
-    "test_anon_constructor_error_length_arg_missing",
-    test_anon_constructor_error_length_arg_missing,
-    devices=devices,
-)
-add_function_test(
-    TestVec,
-    "test_anon_constructor_error_numeric_args_mismatch",
-    test_anon_constructor_error_numeric_args_mismatch,
-    devices=devices,
-)
-add_function_test(
-    TestVec,
-    "test_tpl_constructor_error_incompatible_sizes",
-    test_tpl_constructor_error_incompatible_sizes,
-    devices=devices,
-)
-add_function_test(
-    TestVec,
-    "test_tpl_constructor_error_numeric_args_mismatch",
-    test_tpl_constructor_error_numeric_args_mismatch,
-    devices=devices,
-)
-add_function_test(
-    TestVec,
-    "test_vector_len",
-    test_vector_len,
-    devices=devices,
-)
+add_function_test(TestVec, "test_length_mismatch", test_length_mismatch, devices=devices)
+add_function_test(TestVec, "test_vector_len", test_vector_len, devices=devices)
 add_function_test(TestVec, "test_vec_extract", test_vec_extract, devices=devices)
 add_function_test(TestVec, "test_vec_assign", test_vec_assign, devices=devices)
-add_function_test(TestVec, "test_vec_assign_copy", test_vec_assign_copy, devices=devices)
 add_function_test(TestVec, "test_vec_array_extract", test_vec_array_extract, devices=devices)
 add_function_test(TestVec, "test_vec_array_assign", test_vec_array_assign, devices=devices)
 add_function_test(TestVec, "test_vec_add_inplace", test_vec_add_inplace, devices=devices)
 add_function_test(TestVec, "test_vec_sub_inplace", test_vec_sub_inplace, devices=devices)
 add_function_test(TestVec, "test_vec_array_add_inplace", test_vec_array_add_inplace, devices=devices)
 add_function_test(TestVec, "test_vec_array_sub_inplace", test_vec_array_sub_inplace, devices=devices)
+add_function_test(TestVec, "test_scalar_vec_div", test_scalar_vec_div, devices=devices)
+add_function_test(TestVec, "test_vec_indexing_assign", test_vec_indexing_assign, devices=devices)
+add_function_test(TestVec, "test_vec_slicing_assign", test_vec_slicing_assign, devices=devices)
+add_function_test(TestVec, "test_vec_assign_inplace_errors", test_vec_assign_inplace_errors, devices=devices)
+add_function_test(TestVec, "test_vec_slicing_assign_backward", test_vec_slicing_assign_backward, devices=devices)
 
 
 if __name__ == "__main__":