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

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()

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

@@ -14,14 +14,17 @@ class TestConstStringCodegen(unittest.TestCase):
 
         targetctx = cuda_target.target_context
         mod = targetctx.create_module("")
-        textstring = 'A Little Brown Fox'
+        textstring = "A Little Brown Fox"
         gv0 = targetctx.insert_const_string(mod, textstring)
         # Insert the same const string a second time - the first should be
         # reused.
         targetctx.insert_const_string(mod, textstring)
 
-        res = re.findall(r"@\"__conststring__.*internal.*constant.*\["
-                         r"19\s+x\s+i8\]", str(mod))
+        res = re.findall(
+            r"@\"__conststring__.*internal.*constant.*\["
+            r"19\s+x\s+i8\]",
+            str(mod),
+        )
         # Ensure that the const string was only inserted once
         self.assertEqual(len(res), 1)
 
@@ -30,12 +33,16 @@ class TestConstStringCodegen(unittest.TestCase):
         # Using insert_const_string
         fn = ir.Function(mod, fnty, "test_insert_const_string")
         builder = ir.IRBuilder(fn.append_basic_block())
-        res = builder.addrspacecast(gv0, ir.PointerType(ir.IntType(8)),
-                                    'generic')
+        res = builder.addrspacecast(
+            gv0, ir.PointerType(ir.IntType(8)), "generic"
+        )
         builder.ret(res)
 
-        matches = re.findall(r"@\"__conststring__.*internal.*constant.*\["
-                             r"19\s+x\s+i8\]", str(mod))
+        matches = re.findall(
+            r"@\"__conststring__.*internal.*constant.*\["
+            r"19\s+x\s+i8\]",
+            str(mod),
+        )
         self.assertEqual(len(matches), 1)
 
         # Using insert_string_const_addrspace
@@ -44,11 +51,14 @@ class TestConstStringCodegen(unittest.TestCase):
         res = targetctx.insert_string_const_addrspace(builder, textstring)
         builder.ret(res)
 
-        matches = re.findall(r"@\"__conststring__.*internal.*constant.*\["
-                             r"19\s+x\s+i8\]", str(mod))
+        matches = re.findall(
+            r"@\"__conststring__.*internal.*constant.*\["
+            r"19\s+x\s+i8\]",
+            str(mod),
+        )
         self.assertEqual(len(matches), 1)
 
-        ptx = compile_ir(str(mod)).decode('ascii')
+        ptx = compile_ir(str(mod)).decode("ascii")
         matches = list(re.findall(r"\.const.*__conststring__", ptx))
 
         self.assertEqual(len(matches), 1)
@@ -70,8 +80,8 @@ class TestConstString(CUDATestCase):
         # Expected result, e.g.:
         #     ['XYZ' 'XYZ' 'XYZ' 'XYZ' 'XYZ' 'XYZ' 'XYZ' 'XYZ' '']
         expected = np.zeros_like(arr)
-        expected[:-1] = 'XYZ'
-        expected[-1] = ''
+        expected[:-1] = "XYZ"
+        expected[-1] = ""
         np.testing.assert_equal(arr, expected)
 
     def test_assign_const_byte_string(self):
@@ -88,42 +98,42 @@ class TestConstString(CUDATestCase):
         # Expected result, e.g.:
         #     [b'XYZ' b'XYZ' b'XYZ' b'XYZ' b'XYZ' b'XYZ' b'XYZ' b'XYZ' b'']
         expected = np.zeros_like(arr)
-        expected[:-1] = b'XYZ'
-        expected[-1] = b''
+        expected[:-1] = b"XYZ"
+        expected[-1] = b""
         np.testing.assert_equal(arr, expected)
 
     def test_assign_const_string_in_record(self):
         @cuda.jit
         def f(a):
-            a[0]['x'] = 1
-            a[0]['y'] = 'ABC'
-            a[1]['x'] = 2
-            a[1]['y'] = 'XYZ'
+            a[0]["x"] = 1
+            a[0]["y"] = "ABC"
+            a[1]["x"] = 2
+            a[1]["y"] = "XYZ"
 
-        dt = np.dtype([('x', np.int32), ('y', np.dtype('<U12'))])
+        dt = np.dtype([("x", np.int32), ("y", np.dtype("<U12"))])
         a = np.zeros(2, dt)
 
         f[1, 1](a)
 
-        reference = np.asarray([(1, 'ABC'), (2, 'XYZ')], dtype=dt)
+        reference = np.asarray([(1, "ABC"), (2, "XYZ")], dtype=dt)
         np.testing.assert_array_equal(reference, a)
 
     def test_assign_const_bytes_in_record(self):
         @cuda.jit
         def f(a):
-            a[0]['x'] = 1
-            a[0]['y'] = b'ABC'
-            a[1]['x'] = 2
-            a[1]['y'] = b'XYZ'
+            a[0]["x"] = 1
+            a[0]["y"] = b"ABC"
+            a[1]["x"] = 2
+            a[1]["y"] = b"XYZ"
 
-        dt = np.dtype([('x', np.float32), ('y', np.dtype('S12'))])
+        dt = np.dtype([("x", np.float32), ("y", np.dtype("S12"))])
         a = np.zeros(2, dt)
 
         f[1, 1](a)
 
-        reference = np.asarray([(1, b'ABC'), (2, b'XYZ')], dtype=dt)
+        reference = np.asarray([(1, b"ABC"), (2, b"XYZ")], dtype=dt)
         np.testing.assert_array_equal(reference, a)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

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

@@ -5,30 +5,26 @@ from numba.cuda.testing import unittest, CUDATestCase
 from numba.core.config import ENABLE_CUDASIM
 
 CONST_EMPTY = np.array([])
-CONST1D = np.arange(10, dtype=np.float64) / 2.
-CONST2D = np.asfortranarray(
-    np.arange(100, dtype=np.int32).reshape(10, 10))
-CONST3D = ((np.arange(5 * 5 * 5, dtype=np.complex64).reshape(5, 5, 5) + 1j) /
-           2j)
+CONST1D = np.arange(10, dtype=np.float64) / 2.0
+CONST2D = np.asfortranarray(np.arange(100, dtype=np.int32).reshape(10, 10))
+CONST3D = (np.arange(5 * 5 * 5, dtype=np.complex64).reshape(5, 5, 5) + 1j) / 2j
 CONST3BYTES = np.arange(3, dtype=np.uint8)
 
-CONST_RECORD_EMPTY = np.array(
-    [],
-    dtype=[('x', float), ('y', int)])
-CONST_RECORD = np.array(
-    [(1.0, 2), (3.0, 4)],
-    dtype=[('x', float), ('y', int)])
+CONST_RECORD_EMPTY = np.array([], dtype=[("x", float), ("y", int)])
+CONST_RECORD = np.array([(1.0, 2), (3.0, 4)], dtype=[("x", float), ("y", int)])
 CONST_RECORD_ALIGN = np.array(
     [(1, 2, 3, 0xDEADBEEF, 8), (4, 5, 6, 0xBEEFDEAD, 10)],
     dtype=np.dtype(
         dtype=[
-            ('a', np.uint8),
-            ('b', np.uint8),
-            ('x', np.uint8),
-            ('y', np.uint32),
-            ('z', np.uint8),
+            ("a", np.uint8),
+            ("b", np.uint8),
+            ("x", np.uint8),
+            ("y", np.uint32),
+            ("z", np.uint8),
         ],
-        align=True))
+        align=True,
+    ),
+)
 
 
 def cuconstEmpty(A):
@@ -68,18 +64,18 @@ def cuconstRecEmpty(A):
 def cuconstRec(A, B):
     C = cuda.const.array_like(CONST_RECORD)
     i = cuda.grid(1)
-    A[i] = C[i]['x']
-    B[i] = C[i]['y']
+    A[i] = C[i]["x"]
+    B[i] = C[i]["y"]
 
 
 def cuconstRecAlign(A, B, C, D, E):
     Z = cuda.const.array_like(CONST_RECORD_ALIGN)
     i = cuda.grid(1)
-    A[i] = Z[i]['a']
-    B[i] = Z[i]['b']
-    C[i] = Z[i]['x']
-    D[i] = Z[i]['y']
-    E[i] = Z[i]['z']
+    A[i] = Z[i]["a"]
+    B[i] = Z[i]["b"]
+    C[i] = Z[i]["x"]
+    D[i] = Z[i]["y"]
+    E[i] = Z[i]["z"]
 
 
 def cuconstAlign(z):
@@ -99,50 +95,52 @@ class TestCudaConstantMemory(CUDATestCase):
 
         if not ENABLE_CUDASIM:
             self.assertIn(
-                'ld.const.f64',
+                "ld.const.f64",
                 jcuconst.inspect_asm(sig),
-                "as we're adding to it, load as a double")
+                "as we're adding to it, load as a double",
+            )
 
     def test_const_empty(self):
-        jcuconstEmpty = cuda.jit('void(int64[:])')(cuconstEmpty)
+        jcuconstEmpty = cuda.jit("void(int64[:])")(cuconstEmpty)
         A = np.full(1, fill_value=-1, dtype=np.int64)
         jcuconstEmpty[1, 1](A)
         self.assertTrue(np.all(A == 0))
 
     def test_const_align(self):
-        jcuconstAlign = cuda.jit('void(float64[:])')(cuconstAlign)
+        jcuconstAlign = cuda.jit("void(float64[:])")(cuconstAlign)
         A = np.full(3, fill_value=np.nan, dtype=float)
         jcuconstAlign[1, 3](A)
         self.assertTrue(np.all(A == (CONST3BYTES + CONST1D[:3])))
 
     def test_const_array_2d(self):
-        sig = (int32[:,:],)
+        sig = (int32[:, :],)
         jcuconst2d = cuda.jit(sig)(cuconst2d)
-        A = np.zeros_like(CONST2D, order='C')
+        A = np.zeros_like(CONST2D, order="C")
         jcuconst2d[(2, 2), (5, 5)](A)
         self.assertTrue(np.all(A == CONST2D))
 
         if not ENABLE_CUDASIM:
             self.assertIn(
-                'ld.const.u32',
+                "ld.const.u32",
                 jcuconst2d.inspect_asm(sig),
-                "load the ints as ints")
+                "load the ints as ints",
+            )
 
     def test_const_array_3d(self):
-        sig = (complex64[:,:,:],)
+        sig = (complex64[:, :, :],)
         jcuconst3d = cuda.jit(sig)(cuconst3d)
-        A = np.zeros_like(CONST3D, order='F')
+        A = np.zeros_like(CONST3D, order="F")
         jcuconst3d[1, (5, 5, 5)](A)
         self.assertTrue(np.all(A == CONST3D))
 
         if not ENABLE_CUDASIM:
             asm = jcuconst3d.inspect_asm(sig)
-            complex_load = 'ld.const.v2.f32'
-            description = 'Load the complex as a vector of 2x f32'
+            complex_load = "ld.const.v2.f32"
+            description = "Load the complex as a vector of 2x f32"
             self.assertIn(complex_load, asm, description)
 
     def test_const_record_empty(self):
-        jcuconstRecEmpty = cuda.jit('void(int64[:])')(cuconstRecEmpty)
+        jcuconstRecEmpty = cuda.jit("void(int64[:])")(cuconstRecEmpty)
         A = np.full(1, fill_value=-1, dtype=np.int64)
         jcuconstRecEmpty[1, 1](A)
         self.assertTrue(np.all(A == 0))
@@ -153,8 +151,8 @@ class TestCudaConstantMemory(CUDATestCase):
         jcuconst = cuda.jit(cuconstRec).specialize(A, B)
 
         jcuconst[2, 1](A, B)
-        np.testing.assert_allclose(A, CONST_RECORD['x'])
-        np.testing.assert_allclose(B, CONST_RECORD['y'])
+        np.testing.assert_allclose(A, CONST_RECORD["x"])
+        np.testing.assert_allclose(B, CONST_RECORD["y"])
 
     def test_const_record_align(self):
         A = np.zeros(2, dtype=np.float64)
@@ -165,12 +163,12 @@ class TestCudaConstantMemory(CUDATestCase):
         jcuconst = cuda.jit(cuconstRecAlign).specialize(A, B, C, D, E)
 
         jcuconst[2, 1](A, B, C, D, E)
-        np.testing.assert_allclose(A, CONST_RECORD_ALIGN['a'])
-        np.testing.assert_allclose(B, CONST_RECORD_ALIGN['b'])
-        np.testing.assert_allclose(C, CONST_RECORD_ALIGN['x'])
-        np.testing.assert_allclose(D, CONST_RECORD_ALIGN['y'])
-        np.testing.assert_allclose(E, CONST_RECORD_ALIGN['z'])
+        np.testing.assert_allclose(A, CONST_RECORD_ALIGN["a"])
+        np.testing.assert_allclose(B, CONST_RECORD_ALIGN["b"])
+        np.testing.assert_allclose(C, CONST_RECORD_ALIGN["x"])
+        np.testing.assert_allclose(D, CONST_RECORD_ALIGN["y"])
+        np.testing.assert_allclose(E, CONST_RECORD_ALIGN["z"])
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()