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

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

@@ -8,6 +8,7 @@ import numpy as np
 
 # Dummy function definitions to overload
 
+
 def generic_func_1():
     pass
 
@@ -83,109 +84,124 @@ CUDA_TARGET_OL_CALLS_TARGET_OL = 43
 
 # Overload implementations
 
-@overload(generic_func_1, target='generic')
+
+@overload(generic_func_1, target="generic")
 def ol_generic_func_1(x):
     def impl(x):
         x[0] *= GENERIC_FUNCTION_1
+
     return impl
 
 
-@overload(cuda_func_1, target='cuda')
+@overload(cuda_func_1, target="cuda")
 def ol_cuda_func_1(x):
     def impl(x):
         x[0] *= CUDA_FUNCTION_1
+
     return impl
 
 
-@overload(generic_func_2, target='generic')
+@overload(generic_func_2, target="generic")
 def ol_generic_func_2(x):
     def impl(x):
         x[0] *= GENERIC_FUNCTION_2
+
     return impl
 
 
-@overload(cuda_func_2, target='cuda')
+@overload(cuda_func_2, target="cuda")
 def ol_cuda_func(x):
     def impl(x):
         x[0] *= CUDA_FUNCTION_2
+
     return impl
 
 
-@overload(generic_calls_generic, target='generic')
+@overload(generic_calls_generic, target="generic")
 def ol_generic_calls_generic(x):
     def impl(x):
         x[0] *= GENERIC_CALLS_GENERIC
         generic_func_1(x)
+
     return impl
 
 
-@overload(generic_calls_cuda, target='generic')
+@overload(generic_calls_cuda, target="generic")
 def ol_generic_calls_cuda(x):
     def impl(x):
         x[0] *= GENERIC_CALLS_CUDA
         cuda_func_1(x)
+
     return impl
 
 
-@overload(cuda_calls_generic, target='cuda')
+@overload(cuda_calls_generic, target="cuda")
 def ol_cuda_calls_generic(x):
     def impl(x):
         x[0] *= CUDA_CALLS_GENERIC
         generic_func_1(x)
+
     return impl
 
 
-@overload(cuda_calls_cuda, target='cuda')
+@overload(cuda_calls_cuda, target="cuda")
 def ol_cuda_calls_cuda(x):
     def impl(x):
         x[0] *= CUDA_CALLS_CUDA
         cuda_func_1(x)
+
     return impl
 
 
-@overload(target_overloaded, target='generic')
+@overload(target_overloaded, target="generic")
 def ol_target_overloaded_generic(x):
     def impl(x):
         x[0] *= GENERIC_TARGET_OL
+
     return impl
 
 
-@overload(target_overloaded, target='cuda')
+@overload(target_overloaded, target="cuda")
 def ol_target_overloaded_cuda(x):
     def impl(x):
         x[0] *= CUDA_TARGET_OL
+
     return impl
 
 
-@overload(generic_calls_target_overloaded, target='generic')
+@overload(generic_calls_target_overloaded, target="generic")
 def ol_generic_calls_target_overloaded(x):
     def impl(x):
         x[0] *= GENERIC_CALLS_TARGET_OL
         target_overloaded(x)
+
     return impl
 
 
-@overload(cuda_calls_target_overloaded, target='cuda')
+@overload(cuda_calls_target_overloaded, target="cuda")
 def ol_cuda_calls_target_overloaded(x):
     def impl(x):
         x[0] *= CUDA_CALLS_TARGET_OL
         target_overloaded(x)
+
     return impl
 
 
-@overload(target_overloaded_calls_target_overloaded, target='generic')
+@overload(target_overloaded_calls_target_overloaded, target="generic")
 def ol_generic_calls_target_overloaded_generic(x):
     def impl(x):
         x[0] *= GENERIC_TARGET_OL_CALLS_TARGET_OL
         target_overloaded(x)
+
     return impl
 
 
-@overload(target_overloaded_calls_target_overloaded, target='cuda')
+@overload(target_overloaded_calls_target_overloaded, target="cuda")
 def ol_generic_calls_target_overloaded_cuda(x):
     def impl(x):
         x[0] *= CUDA_TARGET_OL_CALLS_TARGET_OL
         target_overloaded(x)
+
     return impl
 
 
@@ -193,10 +209,11 @@ def ol_generic_calls_target_overloaded_cuda(x):
 def ol_default_values_and_kwargs(out, x, y=5, z=6):
     def impl(out, x, y=5, z=6):
         out[0], out[1] = x + y, z
+
     return impl
 
 
-@skip_on_cudasim('Overloading not supported in cudasim')
+@skip_on_cudasim("Overloading not supported in cudasim")
 class TestOverload(CUDATestCase):
     def check_overload(self, kernel, expected):
         x = np.ones(1, dtype=np.int32)
@@ -311,7 +328,7 @@ class TestOverload(CUDATestCase):
         MyDummy, MyDummyType = self.make_dummy_type()
         mydummy_type = typeof(MyDummy())
 
-        @overload_attribute(MyDummyType, 'cuda_only', target='cuda')
+        @overload_attribute(MyDummyType, "cuda_only", target="cuda")
         def ov_dummy_cuda_attr(obj):
             def imp(obj):
                 return 42
@@ -330,6 +347,7 @@ class TestOverload(CUDATestCase):
             msg = "Unknown attribute 'cuda_only'"
 
         with self.assertRaisesRegex(TypingError, msg):
+
             @njit(types.int64(mydummy_type))
             def illegal_target_attr_use(x):
                 return x.cuda_only
@@ -345,14 +363,15 @@ class TestOverload(CUDATestCase):
         """
         Test default values and kwargs.
         """
+
         @cuda.jit()
         def kernel(a, b, out):
             default_values_and_kwargs(out, a, z=b)
 
         out = np.empty(2, dtype=np.int64)
-        kernel[1,1](1, 2, out)
+        kernel[1, 1](1, 2, out)
         self.assertEqual(tuple(out), (6, 2))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

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

@@ -47,7 +47,7 @@ def vec_pow_inplace_binop(r, x):
 
 def random_complex(N):
     np.random.seed(123)
-    return (np.random.random(1) + np.random.random(1) * 1j)
+    return np.random.random(1) + np.random.random(1) * 1j
 
 
 class TestCudaPowi(CUDATestCase):
@@ -59,7 +59,7 @@ class TestCudaPowi(CUDATestCase):
         A = np.arange(10, dtype=np.float64).reshape(2, 5)
         Aout = np.empty_like(A)
         kernel[1, A.shape](A, power, Aout)
-        self.assertTrue(np.allclose(Aout, A ** power))
+        self.assertTrue(np.allclose(Aout, A**power))
 
     def test_powi_binop(self):
         dec = cuda.jit(void(float64[:, :], int8, float64[:, :]))
@@ -69,7 +69,7 @@ class TestCudaPowi(CUDATestCase):
         A = np.arange(10, dtype=np.float64).reshape(2, 5)
         Aout = np.empty_like(A)
         kernel[1, A.shape](A, power, Aout)
-        self.assertTrue(np.allclose(Aout, A ** power))
+        self.assertTrue(np.allclose(Aout, A**power))
 
     # Relative tolerance kwarg is provided because 1.0e-7 (the default for
     # assert_allclose) is a bit tight for single precision.
@@ -81,7 +81,7 @@ class TestCudaPowi(CUDATestCase):
 
         cfunc = cuda.jit(func)
         cfunc[1, N](r, x, y)
-        np.testing.assert_allclose(r, x ** y, rtol=rtol)
+        np.testing.assert_allclose(r, x**y, rtol=rtol)
 
         # Checks special cases
         x = np.asarray([0.0j, 1.0j], dtype=dtype)
@@ -89,7 +89,7 @@ class TestCudaPowi(CUDATestCase):
         r = np.zeros_like(x)
 
         cfunc[1, 2](r, x, y)
-        np.testing.assert_allclose(r, x ** y, rtol=rtol)
+        np.testing.assert_allclose(r, x**y, rtol=rtol)
 
     def test_cpow_complex64_pow(self):
         self._test_cpow(np.complex64, vec_pow, rtol=3.0e-7)
@@ -107,7 +107,7 @@ class TestCudaPowi(CUDATestCase):
         N = 32
         x = random_complex(N).astype(dtype)
         y = random_complex(N).astype(dtype)
-        r = x ** y
+        r = x**y
 
         cfunc = cuda.jit(vec_pow_inplace_binop)
         cfunc[1, N](x, y)
@@ -120,5 +120,5 @@ class TestCudaPowi(CUDATestCase):
         self._test_cpow_inplace_binop(np.complex128, rtol=3.0e-7)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

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

@@ -113,7 +113,7 @@ class TestPrint(CUDATestCase):
     def test_cuhello(self):
         output, _ = self.run_code(cuhello_usecase)
         actual = [line.strip() for line in output.splitlines()]
-        expected = ['-42'] * 6 + ['%d 999' % i for i in range(6)]
+        expected = ["-42"] * 6 + ["%d 999" % i for i in range(6)]
         # The output of GPU threads is intermingled, but each print()
         # call is still atomic
         self.assertEqual(sorted(actual), expected)
@@ -136,7 +136,7 @@ class TestPrint(CUDATestCase):
     def test_string(self):
         output, _ = self.run_code(printstring_usecase)
         lines = [line.strip() for line in output.splitlines(True)]
-        expected = ['%d hop! 999' % i for i in range(3)]
+        expected = ["%d hop! 999" % i for i in range(3)]
         self.assertEqual(sorted(lines), expected)
 
     def test_dim3(self):
@@ -145,7 +145,7 @@ class TestPrint(CUDATestCase):
         expected = [str(i) for i in np.ndindex(2, 2, 2)]
         self.assertEqual(sorted(lines), expected)
 
-    @skip_on_cudasim('cudasim can print unlimited output')
+    @skip_on_cudasim("cudasim can print unlimited output")
     def test_too_many_args(self):
         # Tests that we emit the format string and warn when there are more
         # than 32 arguments, in common with CUDA C/C++ printf - this is due to
@@ -155,14 +155,16 @@ class TestPrint(CUDATestCase):
         output, errors = self.run_code(print_too_many_usecase)
 
         # Check that the format string was printed instead of formatted garbage
-        expected_fmt_string = ' '.join(['%lld' for _ in range(33)])
+        expected_fmt_string = " ".join(["%lld" for _ in range(33)])
         self.assertIn(expected_fmt_string, output)
 
         # Check for the expected warning about formatting more than 32 items
-        warn_msg = ('CUDA print() cannot print more than 32 items. The raw '
-                    'format string will be emitted by the kernel instead.')
+        warn_msg = (
+            "CUDA print() cannot print more than 32 items. The raw "
+            "format string will be emitted by the kernel instead."
+        )
         self.assertIn(warn_msg, errors)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

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

@@ -29,5 +29,5 @@ class TestCudaPy2Div(CUDATestCase):
         self.assertTrue(np.all(y == yB))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

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

@@ -6,9 +6,12 @@ from numba import cuda
 from numba.cuda.testing import unittest
 from numba.cuda.testing import skip_on_cudasim, CUDATestCase
 
-from numba.cuda.random import \
-    xoroshiro128p_uniform_float32, xoroshiro128p_normal_float32, \
-    xoroshiro128p_uniform_float64, xoroshiro128p_normal_float64
+from numba.cuda.random import (
+    xoroshiro128p_uniform_float32,
+    xoroshiro128p_normal_float32,
+    xoroshiro128p_uniform_float64,
+    xoroshiro128p_normal_float64,
+)
 
 
 # Distributions
@@ -52,8 +55,9 @@ class TestCudaRandomXoroshiro128p(CUDATestCase):
         states = cuda.random.create_xoroshiro128p_states(10, seed=1)
         s1 = states.copy_to_host()
 
-        states = cuda.random.create_xoroshiro128p_states(10, seed=1,
-                                                         subsequence_start=3)
+        states = cuda.random.create_xoroshiro128p_states(
+            10, seed=1, subsequence_start=3
+        )
         s2 = states.copy_to_host()
 
         # Starting seeds should match up with offset of 3
@@ -61,8 +65,9 @@ class TestCudaRandomXoroshiro128p(CUDATestCase):
 
     def test_create_stream(self):
         stream = cuda.stream()
-        states = cuda.random.create_xoroshiro128p_states(10, seed=1,
-                                                         stream=stream)
+        states = cuda.random.create_xoroshiro128p_states(
+            10, seed=1, stream=stream
+        )
         s = states.copy_to_host()
         self.assertEqual(len(np.unique(s)), 10)
 
@@ -79,7 +84,7 @@ class TestCudaRandomXoroshiro128p(CUDATestCase):
     def test_uniform_float32(self):
         self.check_uniform(rng_kernel_float32, np.float32)
 
-    @skip_on_cudasim('skip test for speed under cudasim')
+    @skip_on_cudasim("skip test for speed under cudasim")
     def test_uniform_float64(self):
         self.check_uniform(rng_kernel_float64, np.float64)
 
@@ -95,10 +100,10 @@ class TestCudaRandomXoroshiro128p(CUDATestCase):
     def test_normal_float32(self):
         self.check_normal(rng_kernel_float32, np.float32)
 
-    @skip_on_cudasim('skip test for speed under cudasim')
+    @skip_on_cudasim("skip test for speed under cudasim")
     def test_normal_float64(self):
         self.check_normal(rng_kernel_float64, np.float64)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()