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

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

@@ -12,18 +12,17 @@ from numba.tests.enum_usecases import (
     Shape,
     Planet,
     RequestError,
-    IntEnumWithNegatives
+    IntEnumWithNegatives,
 )
 
 
 class EnumTest(CUDATestCase):
-
     pairs = [
         (Color.red, Color.red),
         (Color.red, Color.green),
         (Planet.EARTH, Planet.EARTH),
         (Planet.VENUS, Planet.MARS),
-        (Shape.circle, IntEnumWithNegatives.two) # IntEnum, same value
+        (Shape.circle, IntEnumWithNegatives.two),  # IntEnum, same value
     ]
 
     def test_compare(self):
@@ -45,7 +44,7 @@ class EnumTest(CUDATestCase):
         def f(out):
             # Lookup of an enum member on its class
             out[0] = Color.red == Color.green
-            out[1] = Color['red'] == Color['green']
+            out[1] = Color["red"] == Color["green"]
 
         cuda_f = cuda.jit(f)
         got = np.zeros((2,), dtype=np.bool_)
@@ -106,16 +105,16 @@ class EnumTest(CUDATestCase):
     def test_vectorize(self):
         def f(x):
             if x != RequestError.not_found:
-                return RequestError['internal_error']
+                return RequestError["internal_error"]
             else:
                 return RequestError.dummy
 
-        cuda_func = vectorize("int64(int64)", target='cuda')(f)
+        cuda_func = vectorize("int64(int64)", target="cuda")(f)
         arr = np.array([2, 404, 500, 404], dtype=np.int64)
         expected = np.array([f(x) for x in arr], dtype=np.int64)
         got = cuda_func(arr)
         self.assertPreciseEqual(expected, got)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

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

@@ -17,34 +17,49 @@ class TestJitErrors(CUDATestCase):
 
         with self.assertRaises(ValueError) as raises:
             kernfunc[(1, 2, 3, 4), (5, 6)]
-        self.assertIn("griddim must be a sequence of 1, 2 or 3 integers, "
-                      "got [1, 2, 3, 4]",
-                      str(raises.exception))
+        self.assertIn(
+            "griddim must be a sequence of 1, 2 or 3 integers, "
+            "got [1, 2, 3, 4]",
+            str(raises.exception),
+        )
 
         with self.assertRaises(ValueError) as raises:
-            kernfunc[(1, 2,), (3, 4, 5, 6)]
-        self.assertIn("blockdim must be a sequence of 1, 2 or 3 integers, "
-                      "got [3, 4, 5, 6]",
-                      str(raises.exception))
+            kernfunc[
+                (
+                    1,
+                    2,
+                ),
+                (3, 4, 5, 6),
+            ]
+        self.assertIn(
+            "blockdim must be a sequence of 1, 2 or 3 integers, "
+            "got [3, 4, 5, 6]",
+            str(raises.exception),
+        )
 
     def test_non_integral_dims(self):
         kernfunc = cuda.jit(noop)
 
         with self.assertRaises(TypeError) as raises:
             kernfunc[2.0, 3]
-        self.assertIn("griddim must be a sequence of integers, got [2.0]",
-                      str(raises.exception))
+        self.assertIn(
+            "griddim must be a sequence of integers, got [2.0]",
+            str(raises.exception),
+        )
 
         with self.assertRaises(TypeError) as raises:
             kernfunc[2, 3.0]
-        self.assertIn("blockdim must be a sequence of integers, got [3.0]",
-                      str(raises.exception))
+        self.assertIn(
+            "blockdim must be a sequence of integers, got [3.0]",
+            str(raises.exception),
+        )
 
     def _test_unconfigured(self, kernfunc):
         with self.assertRaises(ValueError) as raises:
             kernfunc(0)
-        self.assertIn("launch configuration was not specified",
-                      str(raises.exception))
+        self.assertIn(
+            "launch configuration was not specified", str(raises.exception)
+        )
 
     def test_unconfigured_typed_cudakernel(self):
         kernfunc = cuda.jit("void(int32)")(noop)
@@ -54,7 +69,7 @@ class TestJitErrors(CUDATestCase):
         kernfunc = cuda.jit(noop)
         self._test_unconfigured(kernfunc)
 
-    @skip_on_cudasim('TypingError does not occur on simulator')
+    @skip_on_cudasim("TypingError does not occur on simulator")
     def test_typing_error(self):
         # see #5860, this is present to catch changes to error reporting
         # accidentally breaking the CUDA target
@@ -75,5 +90,5 @@ class TestJitErrors(CUDATestCase):
         self.assertIn("NameError: name 'floor' is not defined", excstr)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

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

@@ -83,20 +83,19 @@ class TestException(CUDATestCase):
                         x[i] += x[i] // y[i]
 
         n = 32
-        got_x = 1. / (np.arange(n) + 0.01)
-        got_y = 1. / (np.arange(n) + 0.01)
+        got_x = 1.0 / (np.arange(n) + 0.01)
+        got_y = 1.0 / (np.arange(n) + 0.01)
         problematic[1, n](got_x, got_y)
 
-        expect_x = 1. / (np.arange(n) + 0.01)
-        expect_y = 1. / (np.arange(n) + 0.01)
+        expect_x = 1.0 / (np.arange(n) + 0.01)
+        expect_y = 1.0 / (np.arange(n) + 0.01)
         oracle[1, n](expect_x, expect_y)
 
         np.testing.assert_almost_equal(expect_x, got_x)
         np.testing.assert_almost_equal(expect_y, got_y)
 
     def test_raise_causing_warp_diverge(self):
-        """Test case for issue #2655.
-        """
+        """Test case for issue #2655."""
         self.case_raise_causing_warp_diverge(with_debug_mode=False)
 
     # The following two cases relate to Issue #7806: Division by zero stops the
@@ -117,8 +116,8 @@ class TestException(CUDATestCase):
 
         f[1, 1](r, x, y)
 
-        self.assertTrue(np.isinf(r[0]), 'Expected inf from div by zero')
-        self.assertEqual(r[1], y[0], 'Expected execution to continue')
+        self.assertTrue(np.isinf(r[0]), "Expected inf from div by zero")
+        self.assertEqual(r[1], y[0], "Expected execution to continue")
 
     def test_zero_division_error_in_debug(self):
         # When debug is True:
@@ -146,15 +145,15 @@ class TestException(CUDATestCase):
         with self.assertRaises(exc):
             f[1, 1](r, x, y)
 
-        self.assertEqual(r[0], 0, 'Expected result to be left unset')
-        self.assertEqual(r[1], 0, 'Expected execution to stop')
+        self.assertEqual(r[0], 0, "Expected result to be left unset")
+        self.assertEqual(r[1], 0, "Expected execution to stop")
 
     @xfail_unless_cudasim
     def test_raise_in_device_function(self):
         # This is an expected failure because reporting of exceptions raised in
         # device functions does not work correctly - see Issue #8036:
         # https://github.com/numba/numba/issues/8036
-        msg = 'Device Function Error'
+        msg = "Device Function Error"
 
         @cuda.jit(device=True)
         def f():
@@ -170,5 +169,5 @@ class TestException(CUDATestCase):
         self.assertIn(msg, str(raises.exception))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

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

@@ -8,12 +8,13 @@ class Interval:
     """
     A half-open interval on the real number line.
     """
+
     def __init__(self, lo, hi):
         self.lo = lo
         self.hi = hi
 
     def __repr__(self):
-        return 'Interval(%f, %f)' % (self.lo, self.hi)
+        return "Interval(%f, %f)" % (self.lo, self.hi)
 
     @property
     def width(self):
@@ -32,16 +33,21 @@ def sum_intervals(i, j):
 
 if not config.ENABLE_CUDASIM:
     from numba.core import cgutils
-    from numba.core.extending import (lower_builtin, make_attribute_wrapper,
-                                      models, register_model, type_callable,
-                                      typeof_impl)
+    from numba.core.extending import (
+        lower_builtin,
+        make_attribute_wrapper,
+        models,
+        register_model,
+        type_callable,
+        typeof_impl,
+    )
     from numba.core.typing.templates import AttributeTemplate
     from numba.cuda.cudadecl import registry as cuda_registry
     from numba.cuda.cudaimpl import lower_attr as cuda_lower_attr
 
     class IntervalType(types.Type):
         def __init__(self):
-            super().__init__(name='Interval')
+            super().__init__(name="Interval")
 
     interval_type = IntervalType()
 
@@ -54,19 +60,20 @@ if not config.ENABLE_CUDASIM:
         def typer(lo, hi):
             if isinstance(lo, types.Float) and isinstance(hi, types.Float):
                 return interval_type
+
         return typer
 
     @register_model(IntervalType)
     class IntervalModel(models.StructModel):
         def __init__(self, dmm, fe_type):
             members = [
-                ('lo', types.float64),
-                ('hi', types.float64),
+                ("lo", types.float64),
+                ("hi", types.float64),
             ]
             models.StructModel.__init__(self, dmm, fe_type, members)
 
-    make_attribute_wrapper(IntervalType, 'lo', 'lo')
-    make_attribute_wrapper(IntervalType, 'hi', 'hi')
+    make_attribute_wrapper(IntervalType, "lo", "lo")
+    make_attribute_wrapper(IntervalType, "hi", "hi")
 
     @lower_builtin(Interval, types.Float, types.Float)
     def impl_interval(context, builder, sig, args):
@@ -84,14 +91,14 @@ if not config.ENABLE_CUDASIM:
         def resolve_width(self, mod):
             return types.float64
 
-    @cuda_lower_attr(IntervalType, 'width')
+    @cuda_lower_attr(IntervalType, "width")
     def cuda_Interval_width(context, builder, sig, arg):
         lo = builder.extract_value(arg, 0)
         hi = builder.extract_value(arg, 1)
         return builder.fsub(hi, lo)
 
 
-@skip_on_cudasim('Extensions not supported in the simulator')
+@skip_on_cudasim("Extensions not supported in the simulator")
 class TestExtending(CUDATestCase):
     def test_attributes(self):
         @cuda.jit
@@ -151,5 +158,5 @@ class TestExtending(CUDATestCase):
         np.testing.assert_allclose(r, expected)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

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

@@ -5,8 +5,7 @@ from numba.cuda.compiler import compile_ptx_for_current_device, compile_ptx
 from math import cos, sin, tan, exp, log, log10, log2, pow, tanh
 from operator import truediv
 import numpy as np
-from numba.cuda.testing import (CUDATestCase, skip_on_cudasim,
-                                skip_unless_cc_75)
+from numba.cuda.testing import CUDATestCase, skip_on_cudasim, skip_unless_cc_75
 import unittest
 
 
@@ -24,10 +23,9 @@ class FastMathCriterion:
         test.assertTrue(all(i not in prec for i in self.prec_unexpected))
 
 
-@skip_on_cudasim('Fastmath and PTX inspection not available on cudasim')
+@skip_on_cudasim("Fastmath and PTX inspection not available on cudasim")
 class TestFastMathOption(CUDATestCase):
     def _test_fast_math_common(self, pyfunc, sig, device, criterion):
-
         # Test jit code path
         fastver = cuda.jit(sig, device=device, fastmath=True)(pyfunc)
         precver = cuda.jit(sig, device=device)(pyfunc)
@@ -40,9 +38,7 @@ class TestFastMathOption(CUDATestCase):
         fastptx, _ = compile_ptx_for_current_device(
             pyfunc, sig, device=device, fastmath=True
         )
-        precptx, _ = compile_ptx_for_current_device(
-            pyfunc, sig, device=device
-        )
+        precptx, _ = compile_ptx_for_current_device(pyfunc, sig, device=device)
 
         criterion.check(self, fastptx, precptx)
 
@@ -69,7 +65,9 @@ class TestFastMathOption(CUDATestCase):
 
         self._test_fast_math_common(
             kernel,
-            (float32[::1], float32, float32), device=False, criterion=criterion
+            (float32[::1], float32, float32),
+            device=False,
+            criterion=criterion,
         )
         self._test_fast_math_common(
             device, (float32, float32), device=True, criterion=criterion
@@ -79,39 +77,41 @@ class TestFastMathOption(CUDATestCase):
         self._test_fast_math_unary(
             cos,
             FastMathCriterion(
-                fast_expected=['cos.approx.ftz.f32 '],
-                prec_unexpected=['cos.approx.ftz.f32 ']
-            )
+                fast_expected=["cos.approx.ftz.f32 "],
+                prec_unexpected=["cos.approx.ftz.f32 "],
+            ),
         )
 
     def test_sinf(self):
         self._test_fast_math_unary(
             sin,
             FastMathCriterion(
-                fast_expected=['sin.approx.ftz.f32 '],
-                prec_unexpected=['sin.approx.ftz.f32 ']
-            )
+                fast_expected=["sin.approx.ftz.f32 "],
+                prec_unexpected=["sin.approx.ftz.f32 "],
+            ),
         )
 
     def test_tanf(self):
         self._test_fast_math_unary(
             tan,
-            FastMathCriterion(fast_expected=[
-                'sin.approx.ftz.f32 ',
-                'cos.approx.ftz.f32 ',
-                'div.approx.ftz.f32 '
-            ], prec_unexpected=['sin.approx.ftz.f32 '])
+            FastMathCriterion(
+                fast_expected=[
+                    "sin.approx.ftz.f32 ",
+                    "cos.approx.ftz.f32 ",
+                    "div.approx.ftz.f32 ",
+                ],
+                prec_unexpected=["sin.approx.ftz.f32 "],
+            ),
         )
 
     @skip_unless_cc_75
     def test_tanhf(self):
-
         self._test_fast_math_unary(
             tanh,
             FastMathCriterion(
-                fast_expected=['tanh.approx.f32 '],
-                prec_unexpected=['tanh.approx.f32 ']
-            )
+                fast_expected=["tanh.approx.f32 "],
+                prec_unexpected=["tanh.approx.f32 "],
+            ),
         )
 
     def test_tanhf_compile_ptx(self):
@@ -119,74 +119,85 @@ class TestFastMathOption(CUDATestCase):
             r[0] = tanh(x)
 
         def tanh_common_test(cc, criterion):
-            fastptx, _ = compile_ptx(tanh_kernel, (float32[::1], float32),
-                                     fastmath=True, cc=cc)
-            precptx, _ = compile_ptx(tanh_kernel, (float32[::1], float32),
-                                     cc=cc)
+            fastptx, _ = compile_ptx(
+                tanh_kernel, (float32[::1], float32), fastmath=True, cc=cc
+            )
+            precptx, _ = compile_ptx(
+                tanh_kernel, (float32[::1], float32), cc=cc
+            )
             criterion.check(self, fastptx, precptx)
 
-        tanh_common_test(cc=(7, 5), criterion=FastMathCriterion(
-            fast_expected=['tanh.approx.f32 '],
-            prec_unexpected=['tanh.approx.f32 ']
-        ))
+        tanh_common_test(
+            cc=(7, 5),
+            criterion=FastMathCriterion(
+                fast_expected=["tanh.approx.f32 "],
+                prec_unexpected=["tanh.approx.f32 "],
+            ),
+        )
 
-        tanh_common_test(cc=(7, 0),
-                         criterion=FastMathCriterion(
-            fast_expected=['ex2.approx.ftz.f32 ',
-                           'rcp.approx.ftz.f32 '],
-            prec_unexpected=['tanh.approx.f32 ']))
+        tanh_common_test(
+            cc=(7, 0),
+            criterion=FastMathCriterion(
+                fast_expected=["ex2.approx.ftz.f32 ", "rcp.approx.ftz.f32 "],
+                prec_unexpected=["tanh.approx.f32 "],
+            ),
+        )
 
     def test_expf(self):
         self._test_fast_math_unary(
             exp,
             FastMathCriterion(
-                fast_unexpected=['fma.rn.f32 '],
-                prec_expected=['fma.rn.f32 ']
-            )
+                fast_unexpected=["fma.rn.f32 "], prec_expected=["fma.rn.f32 "]
+            ),
         )
 
     def test_logf(self):
         # Look for constant used to convert from log base 2 to log base e
         self._test_fast_math_unary(
-            log, FastMathCriterion(
-                fast_expected=['lg2.approx.ftz.f32 ', '0f3F317218'],
-                prec_unexpected=['lg2.approx.ftz.f32 '],
-            )
+            log,
+            FastMathCriterion(
+                fast_expected=["lg2.approx.ftz.f32 ", "0f3F317218"],
+                prec_unexpected=["lg2.approx.ftz.f32 "],
+            ),
         )
 
     def test_log10f(self):
         # Look for constant used to convert from log base 2 to log base 10
         self._test_fast_math_unary(
-            log10, FastMathCriterion(
-                fast_expected=['lg2.approx.ftz.f32 ', '0f3E9A209B'],
-                prec_unexpected=['lg2.approx.ftz.f32 ']
-            )
+            log10,
+            FastMathCriterion(
+                fast_expected=["lg2.approx.ftz.f32 ", "0f3E9A209B"],
+                prec_unexpected=["lg2.approx.ftz.f32 "],
+            ),
         )
 
     def test_log2f(self):
         self._test_fast_math_unary(
-            log2, FastMathCriterion(
-                fast_expected=['lg2.approx.ftz.f32 '],
-                prec_unexpected=['lg2.approx.ftz.f32 ']
-            )
+            log2,
+            FastMathCriterion(
+                fast_expected=["lg2.approx.ftz.f32 "],
+                prec_unexpected=["lg2.approx.ftz.f32 "],
+            ),
         )
 
     def test_powf(self):
         self._test_fast_math_binary(
-            pow, FastMathCriterion(
-                fast_expected=['lg2.approx.ftz.f32 '],
-                prec_unexpected=['lg2.approx.ftz.f32 '],
-            )
+            pow,
+            FastMathCriterion(
+                fast_expected=["lg2.approx.ftz.f32 "],
+                prec_unexpected=["lg2.approx.ftz.f32 "],
+            ),
         )
 
     def test_divf(self):
         self._test_fast_math_binary(
-            truediv, FastMathCriterion(
-                fast_expected=['div.approx.ftz.f32 '],
-                fast_unexpected=['div.rn.f32'],
-                prec_expected=['div.rn.f32'],
-                prec_unexpected=['div.approx.ftz.f32 '],
-            )
+            truediv,
+            FastMathCriterion(
+                fast_expected=["div.approx.ftz.f32 "],
+                fast_unexpected=["div.rn.f32"],
+                prec_expected=["div.rn.f32"],
+                prec_unexpected=["div.approx.ftz.f32 "],
+            ),
         )
 
     def test_divf_exception(self):
@@ -232,13 +243,13 @@ class TestFastMathOption(CUDATestCase):
         # https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#floating-point-instructions-div
 
         # The fast version should use the "fast, approximate divide" variant
-        self.assertIn('div.approx.f32', fastver.inspect_asm(sig))
+        self.assertIn("div.approx.f32", fastver.inspect_asm(sig))
         # The precise version should use the "IEEE 754 compliant rounding"
         # variant, and neither of the "approximate divide" variants.
-        self.assertIn('div.rn.f32', precver.inspect_asm(sig))
-        self.assertNotIn('div.approx.f32', precver.inspect_asm(sig))
-        self.assertNotIn('div.full.f32', precver.inspect_asm(sig))
+        self.assertIn("div.rn.f32", precver.inspect_asm(sig))
+        self.assertNotIn("div.approx.f32", precver.inspect_asm(sig))
+        self.assertNotIn("div.full.f32", precver.inspect_asm(sig))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

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

@@ -44,9 +44,11 @@ class TestForAll(CUDATestCase):
         # negative element count.
         with self.assertRaises(ValueError) as raises:
             foo.forall(-1)
-        self.assertIn("Can't create ForAll with negative task count",
-                      str(raises.exception))
+        self.assertIn(
+            "Can't create ForAll with negative task count",
+            str(raises.exception),
+        )
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

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

@@ -17,13 +17,15 @@ class TestFreeVar(CUDATestCase):
         @cuda.jit("(float32[::1], intp)")
         def foo(A, i):
             "Dummy function"
-            sdata = cuda.shared.array(size,   # size is freevar
-                                      dtype=nbtype)  # nbtype is freevar
+            sdata = cuda.shared.array(
+                size,  # size is freevar
+                dtype=nbtype,
+            )  # nbtype is freevar
             A[i] = sdata[i]
 
         A = np.arange(2, dtype="float32")
         foo[1, 1](A, 0)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

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

@@ -62,5 +62,5 @@ class TestCudaFrexpLdexp(CUDATestCase):
         self.template_test_ldexp(np.float64, float64)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

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

@@ -29,8 +29,7 @@ def coop_smem2d(ary):
 
 class TestCudaTestGlobal(CUDATestCase):
     def test_global_int_const(self):
-        """Test simple_smem
-        """
+        """Test simple_smem"""
         compiled = cuda.jit("void(int32[:])")(simple_smem)
 
         nelem = 100
@@ -41,8 +40,7 @@ class TestCudaTestGlobal(CUDATestCase):
 
     @unittest.SkipTest
     def test_global_tuple_const(self):
-        """Test coop_smem2d
-        """
+        """Test coop_smem2d"""
         compiled = cuda.jit("void(float32[:,:])")(coop_smem2d)
 
         shape = 10, 20
@@ -56,5 +54,5 @@ class TestCudaTestGlobal(CUDATestCase):
         self.assertTrue(np.allclose(ary, exp))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()