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

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

@@ -17,13 +17,23 @@ RSQRT2PI = 0.39894228040143267793994605993438
 
 def cnd(d):
     K = 1.0 / (1.0 + 0.2316419 * np.abs(d))
-    ret_val = (RSQRT2PI * np.exp(-0.5 * d * d) *
-               (K * (A1 + K * (A2 + K * (A3 + K * (A4 + K * A5))))))
+    ret_val = (
+        RSQRT2PI
+        * np.exp(-0.5 * d * d)
+        * (K * (A1 + K * (A2 + K * (A3 + K * (A4 + K * A5)))))
+    )
     return np.where(d > 0, 1.0 - ret_val, ret_val)
 
 
-def black_scholes(callResult, putResult, stockPrice, optionStrike, optionYears,
-                  Riskfree, Volatility):
+def black_scholes(
+    callResult,
+    putResult,
+    stockPrice,
+    optionStrike,
+    optionYears,
+    Riskfree,
+    Volatility,
+):
     S = stockPrice
     X = optionStrike
     T = optionYears
@@ -35,9 +45,9 @@ def black_scholes(callResult, putResult, stockPrice, optionStrike, optionYears,
     cndd1 = cnd(d1)
     cndd2 = cnd(d2)
 
-    expRT = np.exp(- R * T)
-    callResult[:] = (S * cndd1 - X * expRT * cndd2)
-    putResult[:] = (X * expRT * (1.0 - cndd2) - S * (1.0 - cndd1))
+    expRT = np.exp(-R * T)
+    callResult[:] = S * cndd1 - X * expRT * cndd2
+    putResult[:] = X * expRT * (1.0 - cndd2) - S * (1.0 - cndd1)
 
 
 def randfloat(rand_var, low, high):
@@ -61,34 +71,54 @@ class TestBlackScholes(CUDATestCase):
 
         # numpy
         for i in range(iterations):
-            black_scholes(callResultNumpy, putResultNumpy, stockPrice,
-                          optionStrike, optionYears, RISKFREE, VOLATILITY)
+            black_scholes(
+                callResultNumpy,
+                putResultNumpy,
+                stockPrice,
+                optionStrike,
+                optionYears,
+                RISKFREE,
+                VOLATILITY,
+            )
 
         @cuda.jit(double(double), device=True, inline=True)
         def cnd_cuda(d):
             K = 1.0 / (1.0 + 0.2316419 * math.fabs(d))
-            ret_val = (RSQRT2PI * math.exp(-0.5 * d * d) *
-                       (K * (A1 + K * (A2 + K * (A3 + K * (A4 + K * A5))))))
+            ret_val = (
+                RSQRT2PI
+                * math.exp(-0.5 * d * d)
+                * (K * (A1 + K * (A2 + K * (A3 + K * (A4 + K * A5)))))
+            )
             if d > 0:
                 ret_val = 1.0 - ret_val
             return ret_val
 
-        @cuda.jit(void(double[:], double[:], double[:], double[:], double[:],
-                       double, double))
+        @cuda.jit(
+            void(
+                double[:],
+                double[:],
+                double[:],
+                double[:],
+                double[:],
+                double,
+                double,
+            )
+        )
         def black_scholes_cuda(callResult, putResult, S, X, T, R, V):
             i = cuda.threadIdx.x + cuda.blockIdx.x * cuda.blockDim.x
             if i >= S.shape[0]:
                 return
             sqrtT = math.sqrt(T[i])
-            d1 = ((math.log(S[i] / X[i]) + (R + 0.5 * V * V) * T[i])
-                  / (V * sqrtT))
+            d1 = (math.log(S[i] / X[i]) + (R + 0.5 * V * V) * T[i]) / (
+                V * sqrtT
+            )
             d2 = d1 - V * sqrtT
             cndd1 = cnd_cuda(d1)
             cndd2 = cnd_cuda(d2)
 
-            expRT = math.exp((-1. * R) * T[i])
-            callResult[i] = (S[i] * cndd1 - X[i] * expRT * cndd2)
-            putResult[i] = (X[i] * expRT * (1.0 - cndd2) - S[i] * (1.0 - cndd1))
+            expRT = math.exp((-1.0 * R) * T[i])
+            callResult[i] = S[i] * cndd1 - X[i] * expRT * cndd2
+            putResult[i] = X[i] * expRT * (1.0 - cndd2) - S[i] * (1.0 - cndd1)
 
         # numba
         blockdim = 512, 1
@@ -102,8 +132,14 @@ class TestBlackScholes(CUDATestCase):
 
         for i in range(iterations):
             black_scholes_cuda[griddim, blockdim, stream](
-                d_callResult, d_putResult, d_stockPrice, d_optionStrike,
-                d_optionYears, RISKFREE, VOLATILITY)
+                d_callResult,
+                d_putResult,
+                d_stockPrice,
+                d_optionStrike,
+                d_optionYears,
+                RISKFREE,
+                VOLATILITY,
+            )
         d_callResult.copy_to_host(callResultNumba, stream)
         d_putResult.copy_to_host(putResultNumba, stream)
         stream.synchronize()
@@ -116,5 +152,5 @@ class TestBlackScholes(CUDATestCase):
         self.assertTrue(max_abs_err < 1e-13)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

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

@@ -12,13 +12,13 @@ def boolean_func(A, vertial):
 
 class TestCudaBoolean(CUDATestCase):
     def test_boolean(self):
-        func = cuda.jit('void(float64[:], bool_)')(boolean_func)
-        A = np.array([0], dtype='float64')
+        func = cuda.jit("void(float64[:], bool_)")(boolean_func)
+        A = np.array([0], dtype="float64")
         func[1, 1](A, True)
         self.assertTrue(A[0] == 123)
         func[1, 1](A, False)
         self.assertTrue(A[0] == 321)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

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

@@ -8,15 +8,22 @@ import warnings
 
 from numba import cuda
 from numba.core.errors import NumbaWarning
-from numba.cuda.testing import (CUDATestCase, skip_on_cudasim,
-                                skip_unless_cc_60, skip_if_cudadevrt_missing,
-                                skip_if_mvc_enabled, test_data_dir)
+from numba.cuda.testing import (
+    CUDATestCase,
+    skip_on_cudasim,
+    skip_unless_cc_60,
+    skip_if_cudadevrt_missing,
+    skip_if_mvc_enabled,
+    test_data_dir,
+)
 from numba.tests.support import SerialMixin
-from numba.tests.test_caching import (DispatcherCacheUsecasesTest,
-                                      skip_bad_access)
+from numba.tests.test_caching import (
+    DispatcherCacheUsecasesTest,
+    skip_bad_access,
+)
 
 
-@skip_on_cudasim('Simulator does not implement caching')
+@skip_on_cudasim("Simulator does not implement caching")
 class CUDACachingTest(SerialMixin, DispatcherCacheUsecasesTest):
     here = os.path.dirname(__file__)
     usecases_file = os.path.join(here, "cache_usecases.py")
@@ -72,23 +79,23 @@ class CUDACachingTest(SerialMixin, DispatcherCacheUsecasesTest):
         mod = self.import_module()
         f = mod.many_locals
         f[1, 1]()
-        self.check_pycache(2) # 1 index, 1 data
+        self.check_pycache(2)  # 1 index, 1 data
 
     def test_closure(self):
         mod = self.import_module()
 
         with warnings.catch_warnings():
-            warnings.simplefilter('error', NumbaWarning)
+            warnings.simplefilter("error", NumbaWarning)
 
             f = mod.closure1
-            self.assertPreciseEqual(f(3), 6) # 3 + 3 = 6
+            self.assertPreciseEqual(f(3), 6)  # 3 + 3 = 6
             f = mod.closure2
-            self.assertPreciseEqual(f(3), 8) # 3 + 5 = 8
+            self.assertPreciseEqual(f(3), 8)  # 3 + 5 = 8
             f = mod.closure3
-            self.assertPreciseEqual(f(3), 10) # 3 + 7 = 10
+            self.assertPreciseEqual(f(3), 10)  # 3 + 7 = 10
             f = mod.closure4
-            self.assertPreciseEqual(f(3), 12) # 3 + 9 = 12
-            self.check_pycache(5) # 1 nbi, 4 nbc
+            self.assertPreciseEqual(f(3), 12)  # 3 + 9 = 12
+            self.check_pycache(5)  # 1 nbi, 4 nbc
 
     def test_cache_reuse(self):
         mod = self.import_module()
@@ -158,7 +165,7 @@ class CUDACachingTest(SerialMixin, DispatcherCacheUsecasesTest):
 
     @skip_unless_cc_60
     @skip_if_cudadevrt_missing
-    @skip_if_mvc_enabled('CG not supported with MVC')
+    @skip_if_mvc_enabled("CG not supported with MVC")
     def test_cache_cg(self):
         # Functions using cooperative groups should be cacheable. See Issue
         # #8888: https://github.com/numba/numba/issues/8888
@@ -174,7 +181,7 @@ class CUDACachingTest(SerialMixin, DispatcherCacheUsecasesTest):
 
     @skip_unless_cc_60
     @skip_if_cudadevrt_missing
-    @skip_if_mvc_enabled('CG not supported with MVC')
+    @skip_if_mvc_enabled("CG not supported with MVC")
     def test_cache_cg_clean_run(self):
         # See Issue #9432: https://github.com/numba/numba/issues/9432
         # If a cached function using CG sync was the first thing to compile,
@@ -191,9 +198,11 @@ class CUDACachingTest(SerialMixin, DispatcherCacheUsecasesTest):
             mod.cg_usecase(0)
             """ % dict(tempdir=self.tempdir, modname=self.modname)
 
-        popen = subprocess.Popen([sys.executable, "-c", code],
-                                 stdout=subprocess.PIPE,
-                                 stderr=subprocess.PIPE)
+        popen = subprocess.Popen(
+            [sys.executable, "-c", code],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
         out, err = popen.communicate(timeout=60)
         if popen.returncode != 0:
             raise AssertionError(
@@ -212,8 +221,9 @@ class CUDACachingTest(SerialMixin, DispatcherCacheUsecasesTest):
         f = mod.add_usecase
         # Remove this function's cache files at the end, to avoid accumulation
         # across test calls.
-        self.addCleanup(shutil.rmtree, f.func.stats.cache_path,
-                        ignore_errors=True)
+        self.addCleanup(
+            shutil.rmtree, f.func.stats.cache_path, ignore_errors=True
+        )
 
         self.assertPreciseEqual(f(2, 3), 6)
         # It's a cache miss since the file was copied to a new temp location
@@ -230,8 +240,9 @@ class CUDACachingTest(SerialMixin, DispatcherCacheUsecasesTest):
         self.check_pycache(0)
 
     @skip_bad_access
-    @unittest.skipIf(os.name == "nt",
-                     "cannot easily make a directory read-only on Windows")
+    @unittest.skipIf(
+        os.name == "nt", "cannot easily make a directory read-only on Windows"
+    )
     def test_non_creatable_pycache(self):
         # Make it impossible to create the __pycache__ directory
         old_perms = os.stat(self.tempdir).st_mode
@@ -241,11 +252,12 @@ class CUDACachingTest(SerialMixin, DispatcherCacheUsecasesTest):
         self._test_pycache_fallback()
 
     @skip_bad_access
-    @unittest.skipIf(os.name == "nt",
-                     "cannot easily make a directory read-only on Windows")
+    @unittest.skipIf(
+        os.name == "nt", "cannot easily make a directory read-only on Windows"
+    )
     def test_non_writable_pycache(self):
         # Make it impossible to write to the __pycache__ directory
-        pycache = os.path.join(self.tempdir, '__pycache__')
+        pycache = os.path.join(self.tempdir, "__pycache__")
         os.mkdir(pycache)
         old_perms = os.stat(pycache).st_mode
         os.chmod(pycache, 0o500)
@@ -254,15 +266,16 @@ class CUDACachingTest(SerialMixin, DispatcherCacheUsecasesTest):
         self._test_pycache_fallback()
 
     def test_cannot_cache_linking_libraries(self):
-        link = str(test_data_dir / 'jitlink.ptx')
-        msg = 'Cannot pickle CUDACodeLibrary with linking files'
+        link = str(test_data_dir / "jitlink.ptx")
+        msg = "Cannot pickle CUDACodeLibrary with linking files"
         with self.assertRaisesRegex(RuntimeError, msg):
-            @cuda.jit('void()', cache=True, link=[link])
+
+            @cuda.jit("void()", cache=True, link=[link])
             def f():
                 pass
 
 
-@skip_on_cudasim('Simulator does not implement caching')
+@skip_on_cudasim("Simulator does not implement caching")
 class CUDAAndCPUCachingTest(SerialMixin, DispatcherCacheUsecasesTest):
     here = os.path.dirname(__file__)
     usecases_file = os.path.join(here, "cache_with_cpu_usecases.py")
@@ -353,7 +366,7 @@ def get_different_cc_gpus():
     return None
 
 
-@skip_on_cudasim('Simulator does not implement caching')
+@skip_on_cudasim("Simulator does not implement caching")
 class TestMultiCCCaching(SerialMixin, DispatcherCacheUsecasesTest):
     here = os.path.dirname(__file__)
     usecases_file = os.path.join(here, "cache_usecases.py")
@@ -370,7 +383,7 @@ class TestMultiCCCaching(SerialMixin, DispatcherCacheUsecasesTest):
     def test_cache(self):
         gpus = get_different_cc_gpus()
         if not gpus:
-            self.skipTest('Need two different CCs for multi-CC cache test')
+            self.skipTest("Need two different CCs for multi-CC cache test")
 
         self.check_pycache(0)
         mod = self.import_module()
@@ -482,13 +495,13 @@ def child_initializer():
     # Disable occupancy and implicit copy warnings in processes in a
     # multiprocessing pool.
     from numba.core import config
+
     config.CUDA_LOW_OCCUPANCY_WARNINGS = 0
     config.CUDA_WARN_ON_IMPLICIT_COPY = 0
 
 
-@skip_on_cudasim('Simulator does not implement caching')
+@skip_on_cudasim("Simulator does not implement caching")
 class TestMultiprocessCache(SerialMixin, DispatcherCacheUsecasesTest):
-
     # Nested multiprocessing.Pool raises AssertionError:
     # "daemonic processes are not allowed to have children"
     _numba_parallel_test_ = False
@@ -513,7 +526,7 @@ class TestMultiprocessCache(SerialMixin, DispatcherCacheUsecasesTest):
         f = mod.simple_usecase_caller
         n = 3
         try:
-            ctx = multiprocessing.get_context('spawn')
+            ctx = multiprocessing.get_context("spawn")
         except AttributeError:
             ctx = multiprocessing
 
@@ -526,7 +539,7 @@ class TestMultiprocessCache(SerialMixin, DispatcherCacheUsecasesTest):
         self.assertEqual(res, n * (n - 1) // 2)
 
 
-@skip_on_cudasim('Simulator does not implement the CUDACodeLibrary')
+@skip_on_cudasim("Simulator does not implement the CUDACodeLibrary")
 class TestCUDACodeLibrary(CUDATestCase):
     # For tests of miscellaneous CUDACodeLibrary behaviour that we wish to
     # explicitly check
@@ -539,7 +552,7 @@ class TestCUDACodeLibrary(CUDATestCase):
         # Usually a CodeLibrary requires a real CodeGen, but since we don't
         # interact with it, anything will do
         codegen = object()
-        name = 'library'
+        name = "library"
         cl = CUDACodeLibrary(codegen, name)
-        with self.assertRaisesRegex(RuntimeError, 'Cannot pickle unfinalized'):
+        with self.assertRaisesRegex(RuntimeError, "Cannot pickle unfinalized"):
             cl._reduce_states()

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

@@ -4,8 +4,7 @@ from numba.cuda import compile_ptx
 from numba.core.types import f2, i1, i2, i4, i8, u1, u2, u4, u8
 from numba import cuda
 from numba.core import types
-from numba.cuda.testing import (CUDATestCase, skip_on_cudasim,
-                                skip_unless_cc_53)
+from numba.cuda.testing import CUDATestCase, skip_on_cudasim, skip_unless_cc_53
 from numba.types import float16, float32
 import itertools
 import unittest
@@ -50,7 +49,7 @@ def to_uint64(x):
 def to_float16(x):
     # When division and operators on float16 types are supported, this should
     # be changed to match the implementation in to_float32.
-    return (np.float16(x) * np.float16(0.5))
+    return np.float16(x) * np.float16(0.5)
 
 
 def to_float32(x):
@@ -76,6 +75,7 @@ def to_complex128(x):
 # - The device version uses cuda.fp16.hmul
 # - The host version uses the * operator
 
+
 def cuda_int_literal_to_float16(x):
     # Note that we need to use `2` and not `np.float16(2)` to ensure that this
     # types as a literal int and not a const float16.
@@ -128,7 +128,7 @@ class TestCasting(CUDATestCase):
                     self.assertEqual(cfunc(-12.3), pyfunc(-12.3))
                     self.assertEqual(cfunc(-12.3), int(-12.3))
 
-    @skip_on_cudasim('Compilation unsupported in the simulator')
+    @skip_on_cudasim("Compilation unsupported in the simulator")
     def test_float16_to_int_ptx(self):
         pyfuncs = (to_int8, to_int16, to_int32, to_int64)
         sizes = (8, 16, 32, 64)
@@ -150,7 +150,7 @@ class TestCasting(CUDATestCase):
                     self.assertEqual(cfunc(12.3), pyfunc(12.3))
                     self.assertEqual(cfunc(12.3), int(12.3))
 
-    @skip_on_cudasim('Compilation unsupported in the simulator')
+    @skip_on_cudasim("Compilation unsupported in the simulator")
     def test_float16_to_uint_ptx(self):
         pyfuncs = (to_uint8, to_uint16, to_uint32, to_uint64)
         sizes = (8, 16, 32, 64)
@@ -171,17 +171,18 @@ class TestCasting(CUDATestCase):
 
     @skip_unless_cc_53
     def test_literal_to_float16(self):
-        cudafuncs = (cuda_int_literal_to_float16,
-                     cuda_float_literal_to_float16)
-        hostfuncs = (reference_int_literal_to_float16,
-                     reference_float_literal_to_float16)
+        cudafuncs = (cuda_int_literal_to_float16, cuda_float_literal_to_float16)
+        hostfuncs = (
+            reference_int_literal_to_float16,
+            reference_float_literal_to_float16,
+        )
 
         for cudafunc, hostfunc in zip(cudafuncs, hostfuncs):
             with self.subTest(func=cudafunc):
                 cfunc = self._create_wrapped(cudafunc, np.float16, np.float16)
                 self.assertEqual(cfunc(321), hostfunc(321))
 
-    @skip_on_cudasim('Compilation unsupported in the simulator')
+    @skip_on_cudasim("Compilation unsupported in the simulator")
     def test_int_to_float16_ptx(self):
         fromtys = (i1, i2, i4, i8)
         sizes = (8, 16, 32, 64)
@@ -190,7 +191,7 @@ class TestCasting(CUDATestCase):
             ptx, _ = compile_ptx(to_float16, (ty,), device=True)
             self.assertIn(f"cvt.rn.f16.s{size}", ptx)
 
-    @skip_on_cudasim('Compilation unsupported in the simulator')
+    @skip_on_cudasim("Compilation unsupported in the simulator")
     def test_uint_to_float16_ptx(self):
         fromtys = (u1, u2, u4, u8)
         sizes = (8, 16, 32, 64)
@@ -211,12 +212,14 @@ class TestCasting(CUDATestCase):
                 # the CUDA target doesn't yet implement division (or operators)
                 # for float16 values, so we test by comparing with the computed
                 # expression instead.
-                np.testing.assert_allclose(cfunc(12.3),
-                                           toty(12.3) / toty(2), rtol=0.0003)
-                np.testing.assert_allclose(cfunc(-12.3),
-                                           toty(-12.3) / toty(2), rtol=0.0003)
-
-    @skip_on_cudasim('Compilation unsupported in the simulator')
+                np.testing.assert_allclose(
+                    cfunc(12.3), toty(12.3) / toty(2), rtol=0.0003
+                )
+                np.testing.assert_allclose(
+                    cfunc(-12.3), toty(-12.3) / toty(2), rtol=0.0003
+                )
+
+    @skip_on_cudasim("Compilation unsupported in the simulator")
     def test_float16_to_float_ptx(self):
         pyfuncs = (to_float32, to_float64)
         postfixes = ("f32", "f64")
@@ -239,12 +242,14 @@ class TestCasting(CUDATestCase):
                     # to match the casting that is automatically applied when
                     # passing the input to the cfunc as part of wrapping it in
                     # an array of type fromtype.
-                    np.testing.assert_allclose(cfunc(3.21),
-                                               pyfunc(fromty(3.21)))
-                    np.testing.assert_allclose(cfunc(-3.21),
-                                               pyfunc(fromty(-3.21)) + 0j)
-
-    @skip_on_cudasim('Compilation unsupported in the simulator')
+                    np.testing.assert_allclose(
+                        cfunc(3.21), pyfunc(fromty(3.21))
+                    )
+                    np.testing.assert_allclose(
+                        cfunc(-3.21), pyfunc(fromty(-3.21)) + 0j
+                    )
+
+    @skip_on_cudasim("Compilation unsupported in the simulator")
     def test_native_cast(self):
         float32_ptx, _ = cuda.compile_ptx(native_cast, (float32,), device=True)
         self.assertIn("st.f32", float32_ptx)
@@ -253,5 +258,5 @@ class TestCasting(CUDATestCase):
         self.assertIn("st.u16", float16_ptx)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

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

@@ -1,21 +1,26 @@
 import numpy as np
 
 from numba import cuda, types
-from numba.cuda.testing import (skip_on_cudasim, test_data_dir, unittest,
-                                CUDATestCase)
+from numba.cuda.testing import (
+    skip_on_cudasim,
+    test_data_dir,
+    unittest,
+    CUDATestCase,
+)
 from numba.tests.support import skip_unless_cffi
 
 
 @skip_unless_cffi
-@skip_on_cudasim('Simulator does not support linking')
+@skip_on_cudasim("Simulator does not support linking")
 class TestCFFI(CUDATestCase):
     def test_from_buffer(self):
         import cffi
+
         ffi = cffi.FFI()
 
-        link = str(test_data_dir / 'jitlink.ptx')
+        link = str(test_data_dir / "jitlink.ptx")
         sig = types.void(types.CPointer(types.int32))
-        array_mutator = cuda.declare_device('array_mutator', sig)
+        array_mutator = cuda.declare_device("array_mutator", sig)
 
         @cuda.jit(link=[link])
         def mutate_array(x):
@@ -29,5 +34,5 @@ class TestCFFI(CUDATestCase):
         self.assertEqual(x[0], x[1])
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()