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

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

@@ -1,7 +1,11 @@
 from math import sqrt
 from numba import cuda, float32, int16, int32, int64, uint32, void
-from numba.cuda import (compile, compile_for_current_device, compile_ptx,
-                        compile_ptx_for_current_device)
+from numba.cuda import (
+    compile,
+    compile_for_current_device,
+    compile_ptx,
+    compile_ptx_for_current_device,
+)
 from numba.cuda.cudadrv import runtime
 from numba.cuda.testing import skip_on_cudasim, unittest, CUDATestCase
 
@@ -12,7 +16,7 @@ def f_module(x, y):
     return x + y
 
 
-@skip_on_cudasim('Compilation unsupported in the simulator')
+@skip_on_cudasim("Compilation unsupported in the simulator")
 class TestCompile(unittest.TestCase):
     def test_global_kernel(self):
         def f(r, x, y):
@@ -24,11 +28,11 @@ class TestCompile(unittest.TestCase):
         ptx, resty = compile_ptx(f, args)
 
         # Kernels should not have a func_retval parameter
-        self.assertNotIn('func_retval', ptx)
+        self.assertNotIn("func_retval", ptx)
         # .visible .func is used to denote a device function
-        self.assertNotIn('.visible .func', ptx)
+        self.assertNotIn(".visible .func", ptx)
         # .visible .entry would denote the presence of a global function
-        self.assertIn('.visible .entry', ptx)
+        self.assertIn(".visible .entry", ptx)
         # Return type for kernels should always be void
         self.assertEqual(resty, void)
 
@@ -41,11 +45,11 @@ class TestCompile(unittest.TestCase):
 
         # Device functions take a func_retval parameter for storing the
         # returned value in by reference
-        self.assertIn('func_retval', ptx)
+        self.assertIn("func_retval", ptx)
         # .visible .func is used to denote a device function
-        self.assertIn('.visible .func', ptx)
+        self.assertIn(".visible .func", ptx)
         # .visible .entry would denote the presence of a global function
-        self.assertNotIn('.visible .entry', ptx)
+        self.assertNotIn(".visible .entry", ptx)
         # Inferred return type as expected?
         self.assertEqual(resty, float32)
 
@@ -71,21 +75,21 @@ class TestCompile(unittest.TestCase):
 
         # Without fastmath, fma contraction is enabled by default, but ftz and
         # approximate div / sqrt is not.
-        self.assertIn('fma.rn.f32', ptx)
-        self.assertIn('div.rn.f32', ptx)
-        self.assertIn('sqrt.rn.f32', ptx)
+        self.assertIn("fma.rn.f32", ptx)
+        self.assertIn("div.rn.f32", ptx)
+        self.assertIn("sqrt.rn.f32", ptx)
 
         ptx, resty = compile_ptx(f, args, device=True, fastmath=True)
 
         # With fastmath, ftz and approximate div / sqrt are enabled
-        self.assertIn('fma.rn.ftz.f32', ptx)
-        self.assertIn('div.approx.ftz.f32', ptx)
-        self.assertIn('sqrt.approx.ftz.f32', ptx)
+        self.assertIn("fma.rn.ftz.f32", ptx)
+        self.assertIn("div.approx.ftz.f32", ptx)
+        self.assertIn("sqrt.approx.ftz.f32", ptx)
 
     def check_debug_info(self, ptx):
         # A debug_info section should exist in the PTX. Whitespace varies
         # between CUDA toolkit versions.
-        self.assertRegex(ptx, '\\.section\\s+\\.debug_info')
+        self.assertRegex(ptx, "\\.section\\s+\\.debug_info")
         # A .file directive should be produced and include the name of the
         # source. The path and whitespace may vary, so we accept anything
         # ending in the filename of this module.
@@ -136,23 +140,25 @@ class TestCompile(unittest.TestCase):
         def f(x, y):
             return x[0] + y[0]
 
-        with self.assertRaisesRegex(TypeError, 'must have void return type'):
+        with self.assertRaisesRegex(TypeError, "must have void return type"):
             compile_ptx(f, (uint32[::1], uint32[::1]))
 
     def test_c_abi_disallowed_for_kernel(self):
         def f(x, y):
             return x + y
 
-        with self.assertRaisesRegex(NotImplementedError,
-                                    "The C ABI is not supported for kernels"):
+        with self.assertRaisesRegex(
+            NotImplementedError, "The C ABI is not supported for kernels"
+        ):
             compile_ptx(f, (int32, int32), abi="c")
 
     def test_unsupported_abi(self):
         def f(x, y):
             return x + y
 
-        with self.assertRaisesRegex(NotImplementedError,
-                                    "Unsupported ABI: fastcall"):
+        with self.assertRaisesRegex(
+            NotImplementedError, "Unsupported ABI: fastcall"
+        ):
             compile_ptx(f, (int32, int32), abi="fastcall")
 
     def test_c_abi_device_function(self):
@@ -166,8 +172,11 @@ class TestCompile(unittest.TestCase):
         # The function name should match the Python function name (not the
         # qualname, which includes additional info), and its return value
         # should be 32 bits
-        self.assertRegex(ptx, r"\.visible\s+\.func\s+\(\.param\s+\.b32\s+"
-                              r"func_retval0\)\s+f\(")
+        self.assertRegex(
+            ptx,
+            r"\.visible\s+\.func\s+\(\.param\s+\.b32\s+"
+            r"func_retval0\)\s+f\(",
+        )
 
         # If we compile for 64-bit integers, the return type should be 64 bits
         # wide
@@ -175,44 +184,60 @@ class TestCompile(unittest.TestCase):
         self.assertRegex(ptx, r"\.visible\s+\.func\s+\(\.param\s+\.b64")
 
     def test_c_abi_device_function_module_scope(self):
-        ptx, resty = compile_ptx(f_module, int32(int32, int32), device=True,
-                                 abi="c")
+        ptx, resty = compile_ptx(
+            f_module, int32(int32, int32), device=True, abi="c"
+        )
 
         # The function name should match the Python function name, and its
         # return value should be 32 bits
-        self.assertRegex(ptx, r"\.visible\s+\.func\s+\(\.param\s+\.b32\s+"
-                              r"func_retval0\)\s+f_module\(")
+        self.assertRegex(
+            ptx,
+            r"\.visible\s+\.func\s+\(\.param\s+\.b32\s+"
+            r"func_retval0\)\s+f_module\(",
+        )
 
     def test_c_abi_with_abi_name(self):
-        abi_info = {'abi_name': '_Z4funcii'}
-        ptx, resty = compile_ptx(f_module, int32(int32, int32), device=True,
-                                 abi="c", abi_info=abi_info)
+        abi_info = {"abi_name": "_Z4funcii"}
+        ptx, resty = compile_ptx(
+            f_module,
+            int32(int32, int32),
+            device=True,
+            abi="c",
+            abi_info=abi_info,
+        )
 
         # The function name should match the one given in the ABI info, and its
         # return value should be 32 bits
-        self.assertRegex(ptx, r"\.visible\s+\.func\s+\(\.param\s+\.b32\s+"
-                              r"func_retval0\)\s+_Z4funcii\(")
+        self.assertRegex(
+            ptx,
+            r"\.visible\s+\.func\s+\(\.param\s+\.b32\s+"
+            r"func_retval0\)\s+_Z4funcii\(",
+        )
 
     def test_compile_defaults_to_c_abi(self):
         ptx, resty = compile(f_module, int32(int32, int32), device=True)
 
         # The function name should match the Python function name, and its
         # return value should be 32 bits
-        self.assertRegex(ptx, r"\.visible\s+\.func\s+\(\.param\s+\.b32\s+"
-                              r"func_retval0\)\s+f_module\(")
+        self.assertRegex(
+            ptx,
+            r"\.visible\s+\.func\s+\(\.param\s+\.b32\s+"
+            r"func_retval0\)\s+f_module\(",
+        )
 
     def test_compile_to_ltoir(self):
         if runtime.get_version() < (11, 5):
             self.skipTest("-gen-lto unavailable in this toolkit version")
 
-        ltoir, resty = compile(f_module, int32(int32, int32), device=True,
-                               output="ltoir")
+        ltoir, resty = compile(
+            f_module, int32(int32, int32), device=True, output="ltoir"
+        )
 
         # There are no tools to interpret the LTOIR output, but we can check
         # that we appear to have obtained an LTOIR file. This magic number is
         # not documented, but is expected to remain consistent.
         LTOIR_MAGIC = 0x7F4E43ED
-        header = int.from_bytes(ltoir[:4], byteorder='little')
+        header = int.from_bytes(ltoir[:4], byteorder="little")
         self.assertEqual(header, LTOIR_MAGIC)
         self.assertEqual(resty, int32)
 
@@ -220,11 +245,15 @@ class TestCompile(unittest.TestCase):
         illegal_output = "illegal"
         msg = f"Unsupported output type: {illegal_output}"
         with self.assertRaisesRegex(NotImplementedError, msg):
-            compile(f_module, int32(int32, int32), device=True,
-                    output=illegal_output)
+            compile(
+                f_module,
+                int32(int32, int32),
+                device=True,
+                output=illegal_output,
+            )
 
 
-@skip_on_cudasim('Compilation unsupported in the simulator')
+@skip_on_cudasim("Compilation unsupported in the simulator")
 class TestCompileForCurrentDevice(CUDATestCase):
     def _check_ptx_for_current_device(self, compile_function):
         def add(x, y):
@@ -237,7 +266,7 @@ class TestCompileForCurrentDevice(CUDATestCase):
         # closest compute capability supported by the current toolkit.
         device_cc = cuda.get_current_device().compute_capability
         cc = cuda.cudadrv.nvvm.find_closest_arch(device_cc)
-        target = f'.target sm_{cc[0]}{cc[1]}'
+        target = f".target sm_{cc[0]}{cc[1]}"
         self.assertIn(target, ptx)
 
     def test_compile_ptx_for_current_device(self):
@@ -247,10 +276,10 @@ class TestCompileForCurrentDevice(CUDATestCase):
         self._check_ptx_for_current_device(compile_for_current_device)
 
 
-@skip_on_cudasim('Compilation unsupported in the simulator')
+@skip_on_cudasim("Compilation unsupported in the simulator")
 class TestCompileOnlyTests(unittest.TestCase):
-    '''For tests where we can only check correctness by examining the compiler
-    output rather than observing the effects of execution.'''
+    """For tests where we can only check correctness by examining the compiler
+    output rather than observing the effects of execution."""
 
     def test_nanosleep(self):
         def use_nanosleep(x):
@@ -262,15 +291,20 @@ class TestCompileOnlyTests(unittest.TestCase):
         ptx, resty = compile_ptx(use_nanosleep, (uint32,), cc=(7, 0))
 
         nanosleep_count = 0
-        for line in ptx.split('\n'):
-            if 'nanosleep.u32' in line:
+        for line in ptx.split("\n"):
+            if "nanosleep.u32" in line:
                 nanosleep_count += 1
 
         expected = 2
-        self.assertEqual(expected, nanosleep_count,
-                         (f'Got {nanosleep_count} nanosleep instructions, '
-                          f'expected {expected}'))
+        self.assertEqual(
+            expected,
+            nanosleep_count,
+            (
+                f"Got {nanosleep_count} nanosleep instructions, "
+                f"expected {expected}"
+            ),
+        )
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

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

@@ -6,20 +6,34 @@ import numpy as np
 from numba.cuda.testing import unittest, CUDATestCase
 from numba.core import types
 from numba import cuda
-from numba.tests.complex_usecases import (real_usecase, imag_usecase,
-                                          conjugate_usecase, phase_usecase,
-                                          polar_as_complex_usecase,
-                                          rect_usecase, isnan_usecase,
-                                          isinf_usecase, isfinite_usecase,
-                                          exp_usecase, log_usecase,
-                                          log_base_usecase, log10_usecase,
-                                          sqrt_usecase, asin_usecase,
-                                          acos_usecase, atan_usecase,
-                                          cos_usecase, sin_usecase,
-                                          tan_usecase, acosh_usecase,
-                                          asinh_usecase, atanh_usecase,
-                                          cosh_usecase, sinh_usecase,
-                                          tanh_usecase)
+from numba.tests.complex_usecases import (
+    real_usecase,
+    imag_usecase,
+    conjugate_usecase,
+    phase_usecase,
+    polar_as_complex_usecase,
+    rect_usecase,
+    isnan_usecase,
+    isinf_usecase,
+    isfinite_usecase,
+    exp_usecase,
+    log_usecase,
+    log_base_usecase,
+    log10_usecase,
+    sqrt_usecase,
+    asin_usecase,
+    acos_usecase,
+    atan_usecase,
+    cos_usecase,
+    sin_usecase,
+    tan_usecase,
+    acosh_usecase,
+    asinh_usecase,
+    atanh_usecase,
+    cosh_usecase,
+    sinh_usecase,
+    tanh_usecase,
+)
 from numba.np import numpy_support
 
 
@@ -29,15 +43,18 @@ def compile_scalar_func(pyfunc, argtypes, restype):
     assert not isinstance(restype, types.Array)
     device_func = cuda.jit(restype(*argtypes), device=True)(pyfunc)
 
-    kernel_types = [types.Array(tp, 1, "C")
-                    for tp in [restype] + list(argtypes)]
+    kernel_types = [
+        types.Array(tp, 1, "C") for tp in [restype] + list(argtypes)
+    ]
 
     if len(argtypes) == 1:
+
         def kernel_func(out, a):
             i = cuda.grid(1)
             if i < out.shape[0]:
                 out[i] = device_func(a[i])
     elif len(argtypes) == 2:
+
         def kernel_func(out, a, b):
             i = cuda.grid(1)
             if i < out.shape[0]:
@@ -49,8 +66,9 @@ def compile_scalar_func(pyfunc, argtypes, restype):
 
     def kernel_wrapper(values):
         n = len(values)
-        inputs = [np.empty(n, dtype=numpy_support.as_dtype(tp))
-                  for tp in argtypes]
+        inputs = [
+            np.empty(n, dtype=numpy_support.as_dtype(tp)) for tp in argtypes
+        ]
         output = np.empty(n, dtype=numpy_support.as_dtype(restype))
         for i, vs in enumerate(values):
             for v, inp in zip(vs, inputs):
@@ -58,42 +76,70 @@ def compile_scalar_func(pyfunc, argtypes, restype):
         args = [output] + inputs
         kernel[int(math.ceil(n / 256)), 256](*args)
         return list(output)
+
     return kernel_wrapper
 
 
 class BaseComplexTest(CUDATestCase):
-
     def basic_values(self):
-        reals = [-0.0, +0.0, 1, -1, +1.5, -3.5,
-                 float('-inf'), float('+inf'), float('nan')]
+        reals = [
+            -0.0,
+            +0.0,
+            1,
+            -1,
+            +1.5,
+            -3.5,
+            float("-inf"),
+            float("+inf"),
+            float("nan"),
+        ]
         return [complex(x, y) for x, y in itertools.product(reals, reals)]
 
     def more_values(self):
-        reals = [0.0, +0.0, 1, -1, -math.pi, +math.pi,
-                 float('-inf'), float('+inf'), float('nan')]
+        reals = [
+            0.0,
+            +0.0,
+            1,
+            -1,
+            -math.pi,
+            +math.pi,
+            float("-inf"),
+            float("+inf"),
+            float("nan"),
+        ]
         return [complex(x, y) for x, y in itertools.product(reals, reals)]
 
     def non_nan_values(self):
-        reals = [-0.0, +0.0, 1, -1, -math.pi, +math.pi,
-                 float('inf'), float('-inf')]
+        reals = [
+            -0.0,
+            +0.0,
+            1,
+            -1,
+            -math.pi,
+            +math.pi,
+            float("inf"),
+            float("-inf"),
+        ]
         return [complex(x, y) for x, y in itertools.product(reals, reals)]
 
     def run_func(self, pyfunc, sigs, values, ulps=1, ignore_sign_on_zero=False):
         for sig in sigs:
             if isinstance(sig, types.Type):
-                sig = sig,
+                sig = (sig,)
             if isinstance(sig, tuple):
                 # Assume return type is the type of first argument
                 sig = sig[0](*sig)
-            prec = ('single'
-                    if sig.args[0] in (types.float32, types.complex64)
-                    else 'double')
+            prec = (
+                "single"
+                if sig.args[0] in (types.float32, types.complex64)
+                else "double"
+            )
             cudafunc = compile_scalar_func(pyfunc, sig.args, sig.return_type)
             ok_values = []
             expected_list = []
             for args in values:
                 if not isinstance(args, (list, tuple)):
-                    args = args,
+                    args = (args,)
                 try:
                     expected_list.append(pyfunc(*args))
                     ok_values.append(args)
@@ -102,24 +148,31 @@ class BaseComplexTest(CUDATestCase):
                     continue
             got_list = cudafunc(ok_values)
             for got, expected, args in zip(got_list, expected_list, ok_values):
-                msg = 'for input %r with prec %r' % (args, prec)
-                self.assertPreciseEqual(got, expected, prec=prec,
-                                        ulps=ulps,
-                                        ignore_sign_on_zero=ignore_sign_on_zero,
-                                        msg=msg)
+                msg = "for input %r with prec %r" % (args, prec)
+                self.assertPreciseEqual(
+                    got,
+                    expected,
+                    prec=prec,
+                    ulps=ulps,
+                    ignore_sign_on_zero=ignore_sign_on_zero,
+                    msg=msg,
+                )
 
     run_unary = run_func
     run_binary = run_func
 
 
 class TestComplex(BaseComplexTest):
-
     def check_real_image(self, pyfunc):
         values = self.basic_values()
-        self.run_unary(pyfunc,
-                       [tp.underlying_float(tp)
-                        for tp in (types.complex64, types.complex128)],
-                       values)
+        self.run_unary(
+            pyfunc,
+            [
+                tp.underlying_float(tp)
+                for tp in (types.complex64, types.complex128)
+            ],
+            values,
+        )
 
     def test_real(self):
         self.check_real_image(real_usecase)
@@ -130,9 +183,7 @@ class TestComplex(BaseComplexTest):
     def test_conjugate(self):
         pyfunc = conjugate_usecase
         values = self.basic_values()
-        self.run_unary(pyfunc,
-                       [types.complex64, types.complex128],
-                       values)
+        self.run_unary(pyfunc, [types.complex64, types.complex128], values)
 
 
 class TestCMath(BaseComplexTest):
@@ -141,26 +192,44 @@ class TestCMath(BaseComplexTest):
     """
 
     def check_predicate_func(self, pyfunc):
-        self.run_unary(pyfunc,
-                       [types.boolean(tp)
-                        for tp in (types.complex128, types.complex64)],
-                       self.basic_values())
-
-    def check_unary_func(self, pyfunc, ulps=1, values=None,
-                         returns_float=False, ignore_sign_on_zero=False):
+        self.run_unary(
+            pyfunc,
+            [types.boolean(tp) for tp in (types.complex128, types.complex64)],
+            self.basic_values(),
+        )
+
+    def check_unary_func(
+        self,
+        pyfunc,
+        ulps=1,
+        values=None,
+        returns_float=False,
+        ignore_sign_on_zero=False,
+    ):
         if returns_float:
+
             def sig(tp):
                 return tp.underlying_float(tp)
         else:
+
             def sig(tp):
                 return tp(tp)
-        self.run_unary(pyfunc, [sig(types.complex128)],
-                       values or self.more_values(), ulps=ulps,
-                       ignore_sign_on_zero=ignore_sign_on_zero)
+
+        self.run_unary(
+            pyfunc,
+            [sig(types.complex128)],
+            values or self.more_values(),
+            ulps=ulps,
+            ignore_sign_on_zero=ignore_sign_on_zero,
+        )
         # Avoid discontinuities around pi when in single precision.
-        self.run_unary(pyfunc, [sig(types.complex64)],
-                       values or self.basic_values(), ulps=ulps,
-                       ignore_sign_on_zero=ignore_sign_on_zero)
+        self.run_unary(
+            pyfunc,
+            [sig(types.complex64)],
+            values or self.basic_values(),
+            ulps=ulps,
+            ignore_sign_on_zero=ignore_sign_on_zero,
+        )
 
     # Conversions
 
@@ -172,11 +241,14 @@ class TestCMath(BaseComplexTest):
 
     def test_rect(self):
         def do_test(tp, seed_values):
-            values = [(z.real, z.imag) for z in seed_values
-                      if not math.isinf(z.imag) or z.real == 0]
+            values = [
+                (z.real, z.imag)
+                for z in seed_values
+                if not math.isinf(z.imag) or z.real == 0
+            ]
             float_type = tp.underlying_float
-            self.run_binary(rect_usecase, [tp(float_type, float_type)],
-                            values)
+            self.run_binary(rect_usecase, [tp(float_type, float_type)], values)
+
         do_test(types.complex128, self.more_values())
         # Avoid discontinuities around pi when in single precision.
         do_test(types.complex64, self.basic_values())
@@ -202,10 +274,11 @@ class TestCMath(BaseComplexTest):
 
     def test_log_base(self):
         values = list(itertools.product(self.more_values(), self.more_values()))
-        value_types = [(types.complex128, types.complex128),
-                       (types.complex64, types.complex64)]
-        self.run_binary(log_base_usecase, value_types, values,
-                        ulps=3)
+        value_types = [
+            (types.complex128, types.complex128),
+            (types.complex64, types.complex64),
+        ]
+        self.run_binary(log_base_usecase, value_types, values, ulps=3)
 
     def test_log10(self):
         self.check_unary_func(log10_usecase)
@@ -222,8 +295,9 @@ class TestCMath(BaseComplexTest):
         self.check_unary_func(asin_usecase, ulps=2)
 
     def test_atan(self):
-        self.check_unary_func(atan_usecase, ulps=2,
-                              values=self.non_nan_values())
+        self.check_unary_func(
+            atan_usecase, ulps=2, values=self.non_nan_values()
+        )
 
     def test_cos(self):
         self.check_unary_func(cos_usecase, ulps=2)
@@ -233,8 +307,7 @@ class TestCMath(BaseComplexTest):
         self.check_unary_func(sin_usecase, ulps=2)
 
     def test_tan(self):
-        self.check_unary_func(tan_usecase, ulps=2,
-                              ignore_sign_on_zero=True)
+        self.check_unary_func(tan_usecase, ulps=2, ignore_sign_on_zero=True)
 
     # Hyperbolic functions
 
@@ -245,8 +318,7 @@ class TestCMath(BaseComplexTest):
         self.check_unary_func(asinh_usecase, ulps=2)
 
     def test_atanh(self):
-        self.check_unary_func(atanh_usecase, ulps=2,
-                              ignore_sign_on_zero=True)
+        self.check_unary_func(atanh_usecase, ulps=2, ignore_sign_on_zero=True)
 
     def test_cosh(self):
         self.check_unary_func(cosh_usecase, ulps=2)
@@ -255,8 +327,7 @@ class TestCMath(BaseComplexTest):
         self.check_unary_func(sinh_usecase, ulps=2)
 
     def test_tanh(self):
-        self.check_unary_func(tanh_usecase, ulps=2,
-                              ignore_sign_on_zero=True)
+        self.check_unary_func(tanh_usecase, ulps=2, ignore_sign_on_zero=True)
 
 
 class TestAtomicOnComplexComponents(CUDATestCase):
@@ -292,5 +363,5 @@ class TestAtomicOnComplexComponents(CUDATestCase):
         np.testing.assert_equal(arr1 + 1j, arr2)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

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

@@ -5,7 +5,7 @@ from numba.cuda.testing import unittest, CUDATestCase
 
 class TestCudaComplex(CUDATestCase):
     def test_cuda_complex_arg(self):
-        @cuda.jit('void(complex128[:], complex128)')
+        @cuda.jit("void(complex128[:], complex128)")
         def foo(a, b):
             i = cuda.grid(1)
             a[i] += b
@@ -16,5 +16,5 @@ class TestCudaComplex(CUDATestCase):
         self.assertTrue(np.allclose(a, a0 + 2j))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()