numba-cuda 0.8.1__py3-none-any.whl → 0.9.0__py3-none-any.whl

numba_cuda/numba/cuda/tests/cudapy/test_userexc.py

@@ -13,7 +13,6 @@ regex_pattern = (
 
 
 class TestUserExc(CUDATestCase):
-
     def setUp(self):
         super().setUp()
         # LTO optimizes away the exception status due to an oversight
@@ -29,7 +28,7 @@ class TestUserExc(CUDATestCase):
             elif x == 2:
                 raise MyError("foo")
 
-        test_exc[1, 1](0)    # no raise
+        test_exc[1, 1](0)  # no raise
         with self.assertRaises(MyError) as cm:
             test_exc[1, 1](1)
         if not config.ENABLE_CUDASIM:
@@ -43,5 +42,5 @@ class TestUserExc(CUDATestCase):
         self.assertIn("tid=[0, 0, 0] ctaid=[0, 0, 0]: foo", str(cm.exception))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

numba_cuda/numba/cuda/tests/cudapy/test_vector_type.py

@@ -44,12 +44,7 @@ def make_kernel(vtype):
         res[2] = v.z
 
     def kernel_4elem(res):
-        v = vobj(
-            base_type(0),
-            base_type(1),
-            base_type(2),
-            base_type(3)
-        )
+        v = vobj(base_type(0), base_type(1), base_type(2), base_type(3))
         res[0] = v.x
         res[1] = v.y
         res[2] = v.z
@@ -59,7 +54,7 @@ def make_kernel(vtype):
         1: kernel_1elem,
         2: kernel_2elem,
         3: kernel_3elem,
-        4: kernel_4elem
+        4: kernel_4elem,
     }[vtype.num_elements]
     return cuda.jit(host_function)
 
@@ -83,13 +78,13 @@ def make_fancy_creation_kernel(vtype):
         three = base_type(3.0)
         four = base_type(4.0)
 
-        j = 0   # index of the result array
+        j = 0  # index of the result array
 
         # Construct a 1-component vector type, possible combination includes:
         # 2C1 = 2 combinations.
 
         f1_1 = v1(one)  # 1
-        f1_2 = v1(f1_1) # 1
+        f1_2 = v1(f1_1)  # 1
 
         res[0] = f1_1.x
         res[1] = f1_2.x
@@ -98,11 +93,11 @@ def make_fancy_creation_kernel(vtype):
         # Construct a 2-component vector type, possible combination includes:
         # 1 + 2C1 * 2 = 5 combinations
 
-        f2_1 = v2(two, three)       # 2 3
-        f2_2 = v2(f1_1, three)      # 1 3
-        f2_3 = v2(two, f1_1)        # 2 1
-        f2_4 = v2(f1_1, f1_1)       # 1 1
-        f2_5 = v2(f2_1)             # 2 3
+        f2_1 = v2(two, three)  # 2 3
+        f2_2 = v2(f1_1, three)  # 1 3
+        f2_3 = v2(two, f1_1)  # 2 1
+        f2_4 = v2(f1_1, f1_1)  # 1 1
+        f2_5 = v2(f2_1)  # 2 3
 
         for v in (f2_1, f2_2, f2_3, f2_4, f2_5):
             res[j] = v.x
@@ -112,24 +107,37 @@ def make_fancy_creation_kernel(vtype):
         # Construct a 3-component vector type, possible combination includes:
         # 1 + 2C1 * 2 + 2^3 = 13 combinations
 
-        f3_1 = v3(f2_1, one)            # 2 3 1
-        f3_2 = v3(f2_1, f1_1)           # 2 3 1
-        f3_3 = v3(one, f2_1)            # 1 2 3
-        f3_4 = v3(f1_1, f2_1)           # 1 2 3
-
-        f3_5 = v3(one, two, three)      # 1 2 3
-        f3_6 = v3(f1_1, two, three)     # 1 2 3
-        f3_7 = v3(one, f1_1, three)     # 1 1 3
-        f3_8 = v3(one, two, f1_1)       # 1 2 1
-        f3_9 = v3(f1_1, f1_1, three)    # 1 1 3
-        f3_10 = v3(one, f1_1, f1_1)     # 1 1 1
-        f3_11 = v3(f1_1, two, f1_1)     # 1 2 1
-        f3_12 = v3(f1_1, f1_1, f1_1)    # 1 1 1
-
-        f3_13 = v3(f3_1)                # 2 3 1
-
-        for v in (f3_1, f3_2, f3_3, f3_4, f3_5, f3_6, f3_7, f3_8, f3_9,
-                  f3_10, f3_11, f3_12, f3_13):
+        f3_1 = v3(f2_1, one)  # 2 3 1
+        f3_2 = v3(f2_1, f1_1)  # 2 3 1
+        f3_3 = v3(one, f2_1)  # 1 2 3
+        f3_4 = v3(f1_1, f2_1)  # 1 2 3
+
+        f3_5 = v3(one, two, three)  # 1 2 3
+        f3_6 = v3(f1_1, two, three)  # 1 2 3
+        f3_7 = v3(one, f1_1, three)  # 1 1 3
+        f3_8 = v3(one, two, f1_1)  # 1 2 1
+        f3_9 = v3(f1_1, f1_1, three)  # 1 1 3
+        f3_10 = v3(one, f1_1, f1_1)  # 1 1 1
+        f3_11 = v3(f1_1, two, f1_1)  # 1 2 1
+        f3_12 = v3(f1_1, f1_1, f1_1)  # 1 1 1
+
+        f3_13 = v3(f3_1)  # 2 3 1
+
+        for v in (
+            f3_1,
+            f3_2,
+            f3_3,
+            f3_4,
+            f3_5,
+            f3_6,
+            f3_7,
+            f3_8,
+            f3_9,
+            f3_10,
+            f3_11,
+            f3_12,
+            f3_13,
+        ):
             res[j] = v.x
             res[j + 1] = v.y
             res[j + 2] = v.z
@@ -138,48 +146,80 @@ def make_fancy_creation_kernel(vtype):
         # Construct a 4-component vector type, possible combination includes:
         # 1 + (2C1 * 2 + 1) + 3C1 * 2^2 + 2^4 = 34 combinations
 
-        f4_1 = v4(one, two, three, four)    # 1 2 3 4
-        f4_2 = v4(f1_1, two, three, four)   # 1 2 3 4
-        f4_3 = v4(one, f1_1, three, four)   # 1 1 3 4
-        f4_4 = v4(one, two, f1_1, four)     # 1 2 1 4
-        f4_5 = v4(one, two, three, f1_1)    # 1 2 3 1
+        f4_1 = v4(one, two, three, four)  # 1 2 3 4
+        f4_2 = v4(f1_1, two, three, four)  # 1 2 3 4
+        f4_3 = v4(one, f1_1, three, four)  # 1 1 3 4
+        f4_4 = v4(one, two, f1_1, four)  # 1 2 1 4
+        f4_5 = v4(one, two, three, f1_1)  # 1 2 3 1
         f4_6 = v4(f1_1, f1_1, three, four)  # 1 1 3 4
-        f4_7 = v4(f1_1, two, f1_1, four)    # 1 2 1 4
-        f4_8 = v4(f1_1, two, three, f1_1)   # 1 2 3 1
-        f4_9 = v4(one, f1_1, f1_1, four)    # 1 1 1 4
+        f4_7 = v4(f1_1, two, f1_1, four)  # 1 2 1 4
+        f4_8 = v4(f1_1, two, three, f1_1)  # 1 2 3 1
+        f4_9 = v4(one, f1_1, f1_1, four)  # 1 1 1 4
         f4_10 = v4(one, f1_1, three, f1_1)  # 1 1 3 1
-        f4_11 = v4(one, two, f1_1, f1_1)    # 1 2 1 1
+        f4_11 = v4(one, two, f1_1, f1_1)  # 1 2 1 1
         f4_12 = v4(f1_1, f1_1, f1_1, four)  # 1 1 1 4
-        f4_13 = v4(f1_1, f1_1, three, f1_1) # 1 1 3 1
-        f4_14 = v4(f1_1, two, f1_1, f1_1)   # 1 2 1 1
-        f4_15 = v4(one, f1_1, f1_1, f1_1)   # 1 1 1 1
+        f4_13 = v4(f1_1, f1_1, three, f1_1)  # 1 1 3 1
+        f4_14 = v4(f1_1, two, f1_1, f1_1)  # 1 2 1 1
+        f4_15 = v4(one, f1_1, f1_1, f1_1)  # 1 1 1 1
         f4_16 = v4(f1_1, f1_1, f1_1, f1_1)  # 1 1 1 1
 
-        f4_17 = v4(f2_1, two, three)        # 2 3 2 3
-        f4_18 = v4(f2_1, f1_1, three)       # 2 3 1 3
-        f4_19 = v4(f2_1, two, f1_1)         # 2 3 2 1
-        f4_20 = v4(f2_1, f1_1, f1_1)        # 2 3 1 1
-        f4_21 = v4(one, f2_1, three)        # 1 2 3 3
-        f4_22 = v4(f1_1, f2_1, three)       # 1 2 3 3
-        f4_23 = v4(one, f2_1, f1_1)         # 1 2 3 1
-        f4_24 = v4(f1_1, f2_1, f1_1)        # 1 2 3 1
-        f4_25 = v4(one, four, f2_1)         # 1 4 2 3
-        f4_26 = v4(f1_1, four, f2_1)        # 1 4 2 3
-        f4_27 = v4(one, f1_1, f2_1)         # 1 1 2 3
-        f4_28 = v4(f1_1, f1_1, f2_1)        # 1 1 2 3
-
-        f4_29 = v4(f2_1, f2_1)              # 2 3 2 3
-        f4_30 = v4(f3_1, four)              # 2 3 1 4
-        f4_31 = v4(f3_1, f1_1)              # 2 3 1 1
-        f4_32 = v4(four, f3_1)              # 4 2 3 1
-        f4_33 = v4(f1_1, f3_1)              # 1 2 3 1
-
-        f4_34 = v4(f4_1)                    # 1 2 3 4
-
-        for v in (f4_1, f4_2, f4_3, f4_4, f4_5, f4_6, f4_7, f4_8, f4_9, f4_10,
-                  f4_11, f4_12, f4_13, f4_14, f4_15, f4_16, f4_17, f4_18, f4_19,
-                  f4_20, f4_21, f4_22, f4_23, f4_24, f4_25, f4_26, f4_27, f4_28,
-                  f4_29, f4_30, f4_31, f4_32, f4_33, f4_34):
+        f4_17 = v4(f2_1, two, three)  # 2 3 2 3
+        f4_18 = v4(f2_1, f1_1, three)  # 2 3 1 3
+        f4_19 = v4(f2_1, two, f1_1)  # 2 3 2 1
+        f4_20 = v4(f2_1, f1_1, f1_1)  # 2 3 1 1
+        f4_21 = v4(one, f2_1, three)  # 1 2 3 3
+        f4_22 = v4(f1_1, f2_1, three)  # 1 2 3 3
+        f4_23 = v4(one, f2_1, f1_1)  # 1 2 3 1
+        f4_24 = v4(f1_1, f2_1, f1_1)  # 1 2 3 1
+        f4_25 = v4(one, four, f2_1)  # 1 4 2 3
+        f4_26 = v4(f1_1, four, f2_1)  # 1 4 2 3
+        f4_27 = v4(one, f1_1, f2_1)  # 1 1 2 3
+        f4_28 = v4(f1_1, f1_1, f2_1)  # 1 1 2 3
+
+        f4_29 = v4(f2_1, f2_1)  # 2 3 2 3
+        f4_30 = v4(f3_1, four)  # 2 3 1 4
+        f4_31 = v4(f3_1, f1_1)  # 2 3 1 1
+        f4_32 = v4(four, f3_1)  # 4 2 3 1
+        f4_33 = v4(f1_1, f3_1)  # 1 2 3 1
+
+        f4_34 = v4(f4_1)  # 1 2 3 4
+
+        for v in (
+            f4_1,
+            f4_2,
+            f4_3,
+            f4_4,
+            f4_5,
+            f4_6,
+            f4_7,
+            f4_8,
+            f4_9,
+            f4_10,
+            f4_11,
+            f4_12,
+            f4_13,
+            f4_14,
+            f4_15,
+            f4_16,
+            f4_17,
+            f4_18,
+            f4_19,
+            f4_20,
+            f4_21,
+            f4_22,
+            f4_23,
+            f4_24,
+            f4_25,
+            f4_26,
+            f4_27,
+            f4_28,
+            f4_29,
+            f4_30,
+            f4_31,
+            f4_32,
+            f4_33,
+            f4_34,
+        ):
             res[j] = v.x
             res[j + 1] = v.y
             res[j + 2] = v.z
@@ -190,13 +230,13 @@ def make_fancy_creation_kernel(vtype):
 
 
 class TestCudaVectorType(CUDATestCase):
-
     def test_basic(self):
         """Basic test that makes sure that vector type and aliases
         are available within the cuda module from both device and
         simulator mode. This is an important sanity check, since other
         tests below tests the vector type objects programmatically.
         """
+
         @cuda.jit("void(float64[:])")
         def kernel(arr):
             v1 = cuda.float64x4(1.0, 3.0, 5.0, 7.0)
@@ -227,66 +267,201 @@ class TestCudaVectorType(CUDATestCase):
             with self.subTest(vty=vty):
                 kernel = make_fancy_creation_kernel(vty)
 
-                expected = np.array([
-                    # 1-component vectors
-                    1,
-                    1,
-                    # 2-component vectors
-                    2, 3,
-                    1, 3,
-                    2, 1,
-                    1, 1,
-                    2, 3,
-                    # 3-component vectors
-                    2, 3, 1,
-                    2, 3, 1,
-                    1, 2, 3,
-                    1, 2, 3,
-                    1, 2, 3,
-                    1, 2, 3,
-                    1, 1, 3,
-                    1, 2, 1,
-                    1, 1, 3,
-                    1, 1, 1,
-                    1, 2, 1,
-                    1, 1, 1,
-                    2, 3, 1,
-                    # 4-component vectors
-                    1, 2, 3, 4,
-                    1, 2, 3, 4,
-                    1, 1, 3, 4,
-                    1, 2, 1, 4,
-                    1, 2, 3, 1,
-                    1, 1, 3, 4,
-                    1, 2, 1, 4,
-                    1, 2, 3, 1,
-                    1, 1, 1, 4,
-                    1, 1, 3, 1,
-                    1, 2, 1, 1,
-                    1, 1, 1, 4,
-                    1, 1, 3, 1,
-                    1, 2, 1, 1,
-                    1, 1, 1, 1,
-                    1, 1, 1, 1,
-                    2, 3, 2, 3,
-                    2, 3, 1, 3,
-                    2, 3, 2, 1,
-                    2, 3, 1, 1,
-                    1, 2, 3, 3,
-                    1, 2, 3, 3,
-                    1, 2, 3, 1,
-                    1, 2, 3, 1,
-                    1, 4, 2, 3,
-                    1, 4, 2, 3,
-                    1, 1, 2, 3,
-                    1, 1, 2, 3,
-                    2, 3, 2, 3,
-                    2, 3, 1, 4,
-                    2, 3, 1, 1,
-                    4, 2, 3, 1,
-                    1, 2, 3, 1,
-                    1, 2, 3, 4
-                ])
+                expected = np.array(
+                    [
+                        # 1-component vectors
+                        1,
+                        1,
+                        # 2-component vectors
+                        2,
+                        3,
+                        1,
+                        3,
+                        2,
+                        1,
+                        1,
+                        1,
+                        2,
+                        3,
+                        # 3-component vectors
+                        2,
+                        3,
+                        1,
+                        2,
+                        3,
+                        1,
+                        1,
+                        2,
+                        3,
+                        1,
+                        2,
+                        3,
+                        1,
+                        2,
+                        3,
+                        1,
+                        2,
+                        3,
+                        1,
+                        1,
+                        3,
+                        1,
+                        2,
+                        1,
+                        1,
+                        1,
+                        3,
+                        1,
+                        1,
+                        1,
+                        1,
+                        2,
+                        1,
+                        1,
+                        1,
+                        1,
+                        2,
+                        3,
+                        1,
+                        # 4-component vectors
+                        1,
+                        2,
+                        3,
+                        4,
+                        1,
+                        2,
+                        3,
+                        4,
+                        1,
+                        1,
+                        3,
+                        4,
+                        1,
+                        2,
+                        1,
+                        4,
+                        1,
+                        2,
+                        3,
+                        1,
+                        1,
+                        1,
+                        3,
+                        4,
+                        1,
+                        2,
+                        1,
+                        4,
+                        1,
+                        2,
+                        3,
+                        1,
+                        1,
+                        1,
+                        1,
+                        4,
+                        1,
+                        1,
+                        3,
+                        1,
+                        1,
+                        2,
+                        1,
+                        1,
+                        1,
+                        1,
+                        1,
+                        4,
+                        1,
+                        1,
+                        3,
+                        1,
+                        1,
+                        2,
+                        1,
+                        1,
+                        1,
+                        1,
+                        1,
+                        1,
+                        1,
+                        1,
+                        1,
+                        1,
+                        2,
+                        3,
+                        2,
+                        3,
+                        2,
+                        3,
+                        1,
+                        3,
+                        2,
+                        3,
+                        2,
+                        1,
+                        2,
+                        3,
+                        1,
+                        1,
+                        1,
+                        2,
+                        3,
+                        3,
+                        1,
+                        2,
+                        3,
+                        3,
+                        1,
+                        2,
+                        3,
+                        1,
+                        1,
+                        2,
+                        3,
+                        1,
+                        1,
+                        4,
+                        2,
+                        3,
+                        1,
+                        4,
+                        2,
+                        3,
+                        1,
+                        1,
+                        2,
+                        3,
+                        1,
+                        1,
+                        2,
+                        3,
+                        2,
+                        3,
+                        2,
+                        3,
+                        2,
+                        3,
+                        1,
+                        4,
+                        2,
+                        3,
+                        1,
+                        1,
+                        4,
+                        2,
+                        3,
+                        1,
+                        1,
+                        2,
+                        3,
+                        1,
+                        1,
+                        2,
+                        3,
+                        4,
+                    ]
+                )
                 arr = np.zeros(expected.shape)
                 kernel[1, 1](arr)
                 np.testing.assert_almost_equal(arr, expected)