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

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

@@ -22,9 +22,17 @@ def atomic_cast_none(num):
 
 
 @cuda.jit(device=True)
-def atomic_binary_1dim_shared(ary, idx, op2, ary_dtype, ary_nelements,
-                              binop_func, cast_func, initializer,
-                              neg_idx):
+def atomic_binary_1dim_shared(
+    ary,
+    idx,
+    op2,
+    ary_dtype,
+    ary_nelements,
+    binop_func,
+    cast_func,
+    initializer,
+    neg_idx,
+):
     tid = cuda.threadIdx.x
     sm = cuda.shared.array(ary_nelements, ary_dtype)
     sm[tid] = initializer
@@ -38,8 +46,9 @@ def atomic_binary_1dim_shared(ary, idx, op2, ary_dtype, ary_nelements,
 
 
 @cuda.jit(device=True)
-def atomic_binary_1dim_shared2(ary, idx, op2, ary_dtype, ary_nelements,
-                               binop_func, cast_func):
+def atomic_binary_1dim_shared2(
+    ary, idx, op2, ary_dtype, ary_nelements, binop_func, cast_func
+):
     tid = cuda.threadIdx.x
     sm = cuda.shared.array(ary_nelements, ary_dtype)
     sm[tid] = ary[tid]
@@ -51,8 +60,9 @@ def atomic_binary_1dim_shared2(ary, idx, op2, ary_dtype, ary_nelements,
 
 
 @cuda.jit(device=True)
-def atomic_binary_2dim_shared(ary, op2, ary_dtype, ary_shape,
-                              binop_func, y_cast_func, neg_idx):
+def atomic_binary_2dim_shared(
+    ary, op2, ary_dtype, ary_shape, binop_func, y_cast_func, neg_idx
+):
     tx = cuda.threadIdx.x
     ty = cuda.threadIdx.y
     sm = cuda.shared.array(ary_shape, ary_dtype)
@@ -77,8 +87,9 @@ def atomic_binary_2dim_global(ary, op2, binop_func, y_cast_func, neg_idx):
 
 
 @cuda.jit(device=True)
-def atomic_binary_1dim_global(ary, idx, ary_nelements, op2,
-                              binop_func, neg_idx):
+def atomic_binary_1dim_global(
+    ary, idx, ary_nelements, op2, binop_func, neg_idx
+):
     tid = cuda.threadIdx.x
     bin = int(idx[tid] % ary_nelements)
     if neg_idx:
@@ -87,53 +98,79 @@ def atomic_binary_1dim_global(ary, idx, ary_nelements, op2,
 
 
 def atomic_add(ary):
-    atomic_binary_1dim_shared(ary, ary, 1, uint32, 32,
-                              cuda.atomic.add, atomic_cast_none, 0, False)
+    atomic_binary_1dim_shared(
+        ary, ary, 1, uint32, 32, cuda.atomic.add, atomic_cast_none, 0, False
+    )
 
 
 def atomic_add_wrap(ary):
-    atomic_binary_1dim_shared(ary, ary, 1, uint32, 32,
-                              cuda.atomic.add, atomic_cast_none, 0, True)
+    atomic_binary_1dim_shared(
+        ary, ary, 1, uint32, 32, cuda.atomic.add, atomic_cast_none, 0, True
+    )
 
 
 def atomic_add2(ary):
-    atomic_binary_2dim_shared(ary, 1, uint32, (4, 8),
-                              cuda.atomic.add, atomic_cast_none, False)
+    atomic_binary_2dim_shared(
+        ary, 1, uint32, (4, 8), cuda.atomic.add, atomic_cast_none, False
+    )
 
 
 def atomic_add2_wrap(ary):
-    atomic_binary_2dim_shared(ary, 1, uint32, (4, 8),
-                              cuda.atomic.add, atomic_cast_none, True)
+    atomic_binary_2dim_shared(
+        ary, 1, uint32, (4, 8), cuda.atomic.add, atomic_cast_none, True
+    )
 
 
 def atomic_add3(ary):
-    atomic_binary_2dim_shared(ary, 1, uint32, (4, 8),
-                              cuda.atomic.add, atomic_cast_to_uint64, False)
+    atomic_binary_2dim_shared(
+        ary, 1, uint32, (4, 8), cuda.atomic.add, atomic_cast_to_uint64, False
+    )
 
 
 def atomic_add_float(ary):
-    atomic_binary_1dim_shared(ary, ary, 1.0, float32, 32,
-                              cuda.atomic.add, atomic_cast_to_int, 0.0, False)
+    atomic_binary_1dim_shared(
+        ary,
+        ary,
+        1.0,
+        float32,
+        32,
+        cuda.atomic.add,
+        atomic_cast_to_int,
+        0.0,
+        False,
+    )
 
 
 def atomic_add_float_wrap(ary):
-    atomic_binary_1dim_shared(ary, ary, 1.0, float32, 32,
-                              cuda.atomic.add, atomic_cast_to_int, 0.0, True)
+    atomic_binary_1dim_shared(
+        ary,
+        ary,
+        1.0,
+        float32,
+        32,
+        cuda.atomic.add,
+        atomic_cast_to_int,
+        0.0,
+        True,
+    )
 
 
 def atomic_add_float_2(ary):
-    atomic_binary_2dim_shared(ary, 1.0, float32, (4, 8),
-                              cuda.atomic.add, atomic_cast_none, False)
+    atomic_binary_2dim_shared(
+        ary, 1.0, float32, (4, 8), cuda.atomic.add, atomic_cast_none, False
+    )
 
 
 def atomic_add_float_2_wrap(ary):
-    atomic_binary_2dim_shared(ary, 1.0, float32, (4, 8),
-                              cuda.atomic.add, atomic_cast_none, True)
+    atomic_binary_2dim_shared(
+        ary, 1.0, float32, (4, 8), cuda.atomic.add, atomic_cast_none, True
+    )
 
 
 def atomic_add_float_3(ary):
-    atomic_binary_2dim_shared(ary, 1.0, float32, (4, 8),
-                              cuda.atomic.add, atomic_cast_to_uint64, False)
+    atomic_binary_2dim_shared(
+        ary, 1.0, float32, (4, 8), cuda.atomic.add, atomic_cast_to_uint64, False
+    )
 
 
 def atomic_add_double_global(idx, ary):
@@ -153,78 +190,117 @@ def atomic_add_double_global_2_wrap(ary):
 
 
 def atomic_add_double_global_3(ary):
-    atomic_binary_2dim_global(ary, 1, cuda.atomic.add, atomic_cast_to_uint64,
-                              False)
+    atomic_binary_2dim_global(
+        ary, 1, cuda.atomic.add, atomic_cast_to_uint64, False
+    )
 
 
 def atomic_add_double(idx, ary):
-    atomic_binary_1dim_shared(ary, idx, 1.0, float64, 32,
-                              cuda.atomic.add, atomic_cast_none, 0.0, False)
+    atomic_binary_1dim_shared(
+        ary,
+        idx,
+        1.0,
+        float64,
+        32,
+        cuda.atomic.add,
+        atomic_cast_none,
+        0.0,
+        False,
+    )
 
 
 def atomic_add_double_wrap(idx, ary):
-    atomic_binary_1dim_shared(ary, idx, 1.0, float64, 32,
-                              cuda.atomic.add, atomic_cast_none, 0.0, True)
+    atomic_binary_1dim_shared(
+        ary, idx, 1.0, float64, 32, cuda.atomic.add, atomic_cast_none, 0.0, True
+    )
 
 
 def atomic_add_double_2(ary):
-    atomic_binary_2dim_shared(ary, 1.0, float64, (4, 8),
-                              cuda.atomic.add, atomic_cast_none, False)
+    atomic_binary_2dim_shared(
+        ary, 1.0, float64, (4, 8), cuda.atomic.add, atomic_cast_none, False
+    )
 
 
 def atomic_add_double_2_wrap(ary):
-    atomic_binary_2dim_shared(ary, 1.0, float64, (4, 8),
-                              cuda.atomic.add, atomic_cast_none, True)
+    atomic_binary_2dim_shared(
+        ary, 1.0, float64, (4, 8), cuda.atomic.add, atomic_cast_none, True
+    )
 
 
 def atomic_add_double_3(ary):
-    atomic_binary_2dim_shared(ary, 1.0, float64, (4, 8),
-                              cuda.atomic.add, atomic_cast_to_uint64, False)
+    atomic_binary_2dim_shared(
+        ary, 1.0, float64, (4, 8), cuda.atomic.add, atomic_cast_to_uint64, False
+    )
 
 
 def atomic_sub(ary):
-    atomic_binary_1dim_shared(ary, ary, 1, uint32, 32,
-                              cuda.atomic.sub, atomic_cast_none, 0, False)
+    atomic_binary_1dim_shared(
+        ary, ary, 1, uint32, 32, cuda.atomic.sub, atomic_cast_none, 0, False
+    )
 
 
 def atomic_sub2(ary):
-    atomic_binary_2dim_shared(ary, 1, uint32, (4, 8),
-                              cuda.atomic.sub, atomic_cast_none, False)
+    atomic_binary_2dim_shared(
+        ary, 1, uint32, (4, 8), cuda.atomic.sub, atomic_cast_none, False
+    )
 
 
 def atomic_sub3(ary):
-    atomic_binary_2dim_shared(ary, 1, uint32, (4, 8),
-                              cuda.atomic.sub, atomic_cast_to_uint64, False)
+    atomic_binary_2dim_shared(
+        ary, 1, uint32, (4, 8), cuda.atomic.sub, atomic_cast_to_uint64, False
+    )
 
 
 def atomic_sub_float(ary):
-    atomic_binary_1dim_shared(ary, ary, 1.0, float32, 32,
-                              cuda.atomic.sub, atomic_cast_to_int, 0.0, False)
+    atomic_binary_1dim_shared(
+        ary,
+        ary,
+        1.0,
+        float32,
+        32,
+        cuda.atomic.sub,
+        atomic_cast_to_int,
+        0.0,
+        False,
+    )
 
 
 def atomic_sub_float_2(ary):
-    atomic_binary_2dim_shared(ary, 1.0, float32, (4, 8),
-                              cuda.atomic.sub, atomic_cast_none, False)
+    atomic_binary_2dim_shared(
+        ary, 1.0, float32, (4, 8), cuda.atomic.sub, atomic_cast_none, False
+    )
 
 
 def atomic_sub_float_3(ary):
-    atomic_binary_2dim_shared(ary, 1.0, float32, (4, 8),
-                              cuda.atomic.sub, atomic_cast_to_uint64, False)
+    atomic_binary_2dim_shared(
+        ary, 1.0, float32, (4, 8), cuda.atomic.sub, atomic_cast_to_uint64, False
+    )
 
 
 def atomic_sub_double(idx, ary):
-    atomic_binary_1dim_shared(ary, idx, 1.0, float64, 32,
-                              cuda.atomic.sub, atomic_cast_none, 0.0, False)
+    atomic_binary_1dim_shared(
+        ary,
+        idx,
+        1.0,
+        float64,
+        32,
+        cuda.atomic.sub,
+        atomic_cast_none,
+        0.0,
+        False,
+    )
 
 
 def atomic_sub_double_2(ary):
-    atomic_binary_2dim_shared(ary, 1.0, float64, (4, 8),
-                              cuda.atomic.sub, atomic_cast_none, False)
+    atomic_binary_2dim_shared(
+        ary, 1.0, float64, (4, 8), cuda.atomic.sub, atomic_cast_none, False
+    )
 
 
 def atomic_sub_double_3(ary):
-    atomic_binary_2dim_shared(ary, 1.0, float64, (4, 8),
-                              cuda.atomic.sub, atomic_cast_to_uint64, False)
+    atomic_binary_2dim_shared(
+        ary, 1.0, float64, (4, 8), cuda.atomic.sub, atomic_cast_to_uint64, False
+    )
 
 
 def atomic_sub_double_global(idx, ary):
@@ -232,28 +308,33 @@ def atomic_sub_double_global(idx, ary):
 
 
 def atomic_sub_double_global_2(ary):
-    atomic_binary_2dim_global(ary, 1.0, cuda.atomic.sub, atomic_cast_none,
-                              False)
+    atomic_binary_2dim_global(
+        ary, 1.0, cuda.atomic.sub, atomic_cast_none, False
+    )
 
 
 def atomic_sub_double_global_3(ary):
-    atomic_binary_2dim_shared(ary, 1.0, float64, (4, 8),
-                              cuda.atomic.sub, atomic_cast_to_uint64, False)
+    atomic_binary_2dim_shared(
+        ary, 1.0, float64, (4, 8), cuda.atomic.sub, atomic_cast_to_uint64, False
+    )
 
 
 def atomic_and(ary, op2):
-    atomic_binary_1dim_shared(ary, ary, op2, uint32, 32,
-                              cuda.atomic.and_, atomic_cast_none, 1, False)
+    atomic_binary_1dim_shared(
+        ary, ary, op2, uint32, 32, cuda.atomic.and_, atomic_cast_none, 1, False
+    )
 
 
 def atomic_and2(ary, op2):
-    atomic_binary_2dim_shared(ary, op2, uint32, (4, 8),
-                              cuda.atomic.and_, atomic_cast_none, False)
+    atomic_binary_2dim_shared(
+        ary, op2, uint32, (4, 8), cuda.atomic.and_, atomic_cast_none, False
+    )
 
 
 def atomic_and3(ary, op2):
-    atomic_binary_2dim_shared(ary, op2, uint32, (4, 8),
-                              cuda.atomic.and_, atomic_cast_to_uint64, False)
+    atomic_binary_2dim_shared(
+        ary, op2, uint32, (4, 8), cuda.atomic.and_, atomic_cast_to_uint64, False
+    )
 
 
 def atomic_and_global(idx, ary, op2):
@@ -261,23 +342,27 @@ def atomic_and_global(idx, ary, op2):
 
 
 def atomic_and_global_2(ary, op2):
-    atomic_binary_2dim_global(ary, op2, cuda.atomic.and_,
-                              atomic_cast_none, False)
+    atomic_binary_2dim_global(
+        ary, op2, cuda.atomic.and_, atomic_cast_none, False
+    )
 
 
 def atomic_or(ary, op2):
-    atomic_binary_1dim_shared(ary, ary, op2, uint32, 32,
-                              cuda.atomic.or_, atomic_cast_none, 0, False)
+    atomic_binary_1dim_shared(
+        ary, ary, op2, uint32, 32, cuda.atomic.or_, atomic_cast_none, 0, False
+    )
 
 
 def atomic_or2(ary, op2):
-    atomic_binary_2dim_shared(ary, op2, uint32, (4, 8),
-                              cuda.atomic.or_, atomic_cast_none, False)
+    atomic_binary_2dim_shared(
+        ary, op2, uint32, (4, 8), cuda.atomic.or_, atomic_cast_none, False
+    )
 
 
 def atomic_or3(ary, op2):
-    atomic_binary_2dim_shared(ary, op2, uint32, (4, 8),
-                              cuda.atomic.or_, atomic_cast_to_uint64, False)
+    atomic_binary_2dim_shared(
+        ary, op2, uint32, (4, 8), cuda.atomic.or_, atomic_cast_to_uint64, False
+    )
 
 
 def atomic_or_global(idx, ary, op2):
@@ -285,23 +370,27 @@ def atomic_or_global(idx, ary, op2):
 
 
 def atomic_or_global_2(ary, op2):
-    atomic_binary_2dim_global(ary, op2, cuda.atomic.or_,
-                              atomic_cast_none, False)
+    atomic_binary_2dim_global(
+        ary, op2, cuda.atomic.or_, atomic_cast_none, False
+    )
 
 
 def atomic_xor(ary, op2):
-    atomic_binary_1dim_shared(ary, ary, op2, uint32, 32,
-                              cuda.atomic.xor, atomic_cast_none, 0, False)
+    atomic_binary_1dim_shared(
+        ary, ary, op2, uint32, 32, cuda.atomic.xor, atomic_cast_none, 0, False
+    )
 
 
 def atomic_xor2(ary, op2):
-    atomic_binary_2dim_shared(ary, op2, uint32, (4, 8),
-                              cuda.atomic.xor, atomic_cast_none, False)
+    atomic_binary_2dim_shared(
+        ary, op2, uint32, (4, 8), cuda.atomic.xor, atomic_cast_none, False
+    )
 
 
 def atomic_xor3(ary, op2):
-    atomic_binary_2dim_shared(ary, op2, uint32, (4, 8),
-                              cuda.atomic.xor, atomic_cast_to_uint64, False)
+    atomic_binary_2dim_shared(
+        ary, op2, uint32, (4, 8), cuda.atomic.xor, atomic_cast_to_uint64, False
+    )
 
 
 def atomic_xor_global(idx, ary, op2):
@@ -309,33 +398,39 @@ def atomic_xor_global(idx, ary, op2):
 
 
 def atomic_xor_global_2(ary, op2):
-    atomic_binary_2dim_global(ary, op2, cuda.atomic.xor,
-                              atomic_cast_none, False)
+    atomic_binary_2dim_global(
+        ary, op2, cuda.atomic.xor, atomic_cast_none, False
+    )
 
 
 def atomic_inc32(ary, idx, op2):
-    atomic_binary_1dim_shared2(ary, idx, op2, uint32, 32,
-                               cuda.atomic.inc, atomic_cast_none)
+    atomic_binary_1dim_shared2(
+        ary, idx, op2, uint32, 32, cuda.atomic.inc, atomic_cast_none
+    )
 
 
 def atomic_inc64(ary, idx, op2):
-    atomic_binary_1dim_shared2(ary, idx, op2, uint64, 32,
-                               cuda.atomic.inc, atomic_cast_to_int)
+    atomic_binary_1dim_shared2(
+        ary, idx, op2, uint64, 32, cuda.atomic.inc, atomic_cast_to_int
+    )
 
 
 def atomic_inc2_32(ary, op2):
-    atomic_binary_2dim_shared(ary, op2, uint32, (4, 8),
-                              cuda.atomic.inc, atomic_cast_none, False)
+    atomic_binary_2dim_shared(
+        ary, op2, uint32, (4, 8), cuda.atomic.inc, atomic_cast_none, False
+    )
 
 
 def atomic_inc2_64(ary, op2):
-    atomic_binary_2dim_shared(ary, op2, uint64, (4, 8),
-                              cuda.atomic.inc, atomic_cast_none, False)
+    atomic_binary_2dim_shared(
+        ary, op2, uint64, (4, 8), cuda.atomic.inc, atomic_cast_none, False
+    )
 
 
 def atomic_inc3(ary, op2):
-    atomic_binary_2dim_shared(ary, op2, uint32, (4, 8),
-                              cuda.atomic.inc, atomic_cast_to_uint64, False)
+    atomic_binary_2dim_shared(
+        ary, op2, uint32, (4, 8), cuda.atomic.inc, atomic_cast_to_uint64, False
+    )
 
 
 def atomic_inc_global(idx, ary, op2):
@@ -343,33 +438,39 @@ def atomic_inc_global(idx, ary, op2):
 
 
 def atomic_inc_global_2(ary, op2):
-    atomic_binary_2dim_global(ary, op2, cuda.atomic.inc,
-                              atomic_cast_none, False)
+    atomic_binary_2dim_global(
+        ary, op2, cuda.atomic.inc, atomic_cast_none, False
+    )
 
 
 def atomic_dec32(ary, idx, op2):
-    atomic_binary_1dim_shared2(ary, idx, op2, uint32, 32,
-                               cuda.atomic.dec, atomic_cast_none)
+    atomic_binary_1dim_shared2(
+        ary, idx, op2, uint32, 32, cuda.atomic.dec, atomic_cast_none
+    )
 
 
 def atomic_dec64(ary, idx, op2):
-    atomic_binary_1dim_shared2(ary, idx, op2, uint64, 32,
-                               cuda.atomic.dec, atomic_cast_to_int)
+    atomic_binary_1dim_shared2(
+        ary, idx, op2, uint64, 32, cuda.atomic.dec, atomic_cast_to_int
+    )
 
 
 def atomic_dec2_32(ary, op2):
-    atomic_binary_2dim_shared(ary, op2, uint32, (4, 8),
-                              cuda.atomic.dec, atomic_cast_none, False)
+    atomic_binary_2dim_shared(
+        ary, op2, uint32, (4, 8), cuda.atomic.dec, atomic_cast_none, False
+    )
 
 
 def atomic_dec2_64(ary, op2):
-    atomic_binary_2dim_shared(ary, op2, uint64, (4, 8),
-                              cuda.atomic.dec, atomic_cast_none, False)
+    atomic_binary_2dim_shared(
+        ary, op2, uint64, (4, 8), cuda.atomic.dec, atomic_cast_none, False
+    )
 
 
 def atomic_dec3(ary, op2):
-    atomic_binary_2dim_shared(ary, op2, uint32, (4, 8),
-                              cuda.atomic.dec, atomic_cast_to_uint64, False)
+    atomic_binary_2dim_shared(
+        ary, op2, uint32, (4, 8), cuda.atomic.dec, atomic_cast_to_uint64, False
+    )
 
 
 def atomic_dec_global(idx, ary, op2):
@@ -377,23 +478,27 @@ def atomic_dec_global(idx, ary, op2):
 
 
 def atomic_dec_global_2(ary, op2):
-    atomic_binary_2dim_global(ary, op2, cuda.atomic.dec,
-                              atomic_cast_none, False)
+    atomic_binary_2dim_global(
+        ary, op2, cuda.atomic.dec, atomic_cast_none, False
+    )
 
 
 def atomic_exch(ary, idx, op2):
-    atomic_binary_1dim_shared2(ary, idx, op2, uint32, 32,
-                               cuda.atomic.exch, atomic_cast_none)
+    atomic_binary_1dim_shared2(
+        ary, idx, op2, uint32, 32, cuda.atomic.exch, atomic_cast_none
+    )
 
 
 def atomic_exch2(ary, op2):
-    atomic_binary_2dim_shared(ary, op2, uint32, (4, 8),
-                              cuda.atomic.exch, atomic_cast_none, False)
+    atomic_binary_2dim_shared(
+        ary, op2, uint32, (4, 8), cuda.atomic.exch, atomic_cast_none, False
+    )
 
 
 def atomic_exch3(ary, op2):
-    atomic_binary_2dim_shared(ary, op2, uint64, (4, 8),
-                              cuda.atomic.exch, atomic_cast_none, False)
+    atomic_binary_2dim_shared(
+        ary, op2, uint64, (4, 8), cuda.atomic.exch, atomic_cast_none, False
+    )
 
 
 def atomic_exch_global(idx, ary, op2):
@@ -401,7 +506,6 @@ def atomic_exch_global(idx, ary, op2):
 
 
 def gen_atomic_extreme_funcs(func):
-
     fns = dedent("""
     def atomic(res, ary):
         tx = cuda.threadIdx.x
@@ -431,21 +535,39 @@ def gen_atomic_extreme_funcs(func):
             res[0] = smres[0]
     """).format(func=func)
     ld = {}
-    exec(fns, {'cuda': cuda, 'float64': float64, 'uint64': uint64}, ld)
-    return (ld['atomic'], ld['atomic_double_normalizedindex'],
-            ld['atomic_double_oneindex'], ld['atomic_double_shared'])
-
-
-(atomic_max, atomic_max_double_normalizedindex, atomic_max_double_oneindex,
- atomic_max_double_shared) = gen_atomic_extreme_funcs('cuda.atomic.max')
-(atomic_min, atomic_min_double_normalizedindex, atomic_min_double_oneindex,
- atomic_min_double_shared) = gen_atomic_extreme_funcs('cuda.atomic.min')
-(atomic_nanmax, atomic_nanmax_double_normalizedindex,
- atomic_nanmax_double_oneindex, atomic_nanmax_double_shared) = \
-    gen_atomic_extreme_funcs('cuda.atomic.nanmax')
-(atomic_nanmin, atomic_nanmin_double_normalizedindex,
- atomic_nanmin_double_oneindex, atomic_nanmin_double_shared) = \
-    gen_atomic_extreme_funcs('cuda.atomic.nanmin')
+    exec(fns, {"cuda": cuda, "float64": float64, "uint64": uint64}, ld)
+    return (
+        ld["atomic"],
+        ld["atomic_double_normalizedindex"],
+        ld["atomic_double_oneindex"],
+        ld["atomic_double_shared"],
+    )
+
+
+(
+    atomic_max,
+    atomic_max_double_normalizedindex,
+    atomic_max_double_oneindex,
+    atomic_max_double_shared,
+) = gen_atomic_extreme_funcs("cuda.atomic.max")
+(
+    atomic_min,
+    atomic_min_double_normalizedindex,
+    atomic_min_double_oneindex,
+    atomic_min_double_shared,
+) = gen_atomic_extreme_funcs("cuda.atomic.min")
+(
+    atomic_nanmax,
+    atomic_nanmax_double_normalizedindex,
+    atomic_nanmax_double_oneindex,
+    atomic_nanmax_double_shared,
+) = gen_atomic_extreme_funcs("cuda.atomic.nanmax")
+(
+    atomic_nanmin,
+    atomic_nanmin_double_normalizedindex,
+    atomic_nanmin_double_oneindex,
+    atomic_nanmin_double_shared,
+) = gen_atomic_extreme_funcs("cuda.atomic.nanmin")
 
 
 def atomic_compare_and_swap(res, old, ary, fill_val):
@@ -476,10 +598,10 @@ class TestCudaAtomics(CUDATestCase):
         ary_wrap = ary.copy()
         orig = ary.copy()
 
-        cuda_atomic_add = cuda.jit('void(uint32[:])')(atomic_add)
+        cuda_atomic_add = cuda.jit("void(uint32[:])")(atomic_add)
         cuda_atomic_add[1, 32](ary)
 
-        cuda_atomic_add_wrap = cuda.jit('void(uint32[:])')(atomic_add_wrap)
+        cuda_atomic_add_wrap = cuda.jit("void(uint32[:])")(atomic_add_wrap)
         cuda_atomic_add_wrap[1, 32](ary_wrap)
 
         gold = np.zeros(32, dtype=np.uint32)
@@ -494,10 +616,10 @@ class TestCudaAtomics(CUDATestCase):
         ary_wrap = ary.copy()
         orig = ary.copy()
 
-        cuda_atomic_add2 = cuda.jit('void(uint32[:,:])')(atomic_add2)
+        cuda_atomic_add2 = cuda.jit("void(uint32[:,:])")(atomic_add2)
         cuda_atomic_add2[1, (4, 8)](ary)
 
-        cuda_atomic_add2_wrap = cuda.jit('void(uint32[:,:])')(atomic_add2_wrap)
+        cuda_atomic_add2_wrap = cuda.jit("void(uint32[:,:])")(atomic_add2_wrap)
         cuda_atomic_add2_wrap[1, (4, 8)](ary_wrap)
 
         self.assertTrue(np.all(ary == orig + 1))
@@ -506,7 +628,7 @@ class TestCudaAtomics(CUDATestCase):
     def test_atomic_add3(self):
         ary = np.random.randint(0, 32, size=32).astype(np.uint32).reshape(4, 8)
         orig = ary.copy()
-        cuda_atomic_add3 = cuda.jit('void(uint32[:,:])')(atomic_add3)
+        cuda_atomic_add3 = cuda.jit("void(uint32[:,:])")(atomic_add3)
         cuda_atomic_add3[1, (4, 8)](ary)
 
         self.assertTrue(np.all(ary == orig + 1))
@@ -516,10 +638,10 @@ class TestCudaAtomics(CUDATestCase):
         ary_wrap = ary.copy()
         orig = ary.copy().astype(np.intp)
 
-        cuda_atomic_add_float = cuda.jit('void(float32[:])')(atomic_add_float)
+        cuda_atomic_add_float = cuda.jit("void(float32[:])")(atomic_add_float)
         cuda_atomic_add_float[1, 32](ary)
 
-        add_float_wrap = cuda.jit('void(float32[:])')(atomic_add_float_wrap)
+        add_float_wrap = cuda.jit("void(float32[:])")(atomic_add_float_wrap)
         add_float_wrap[1, 32](ary_wrap)
 
         gold = np.zeros(32, dtype=np.uint32)
@@ -534,10 +656,10 @@ class TestCudaAtomics(CUDATestCase):
         ary_wrap = ary.copy()
         orig = ary.copy()
 
-        cuda_atomic_add2 = cuda.jit('void(float32[:,:])')(atomic_add_float_2)
+        cuda_atomic_add2 = cuda.jit("void(float32[:,:])")(atomic_add_float_2)
         cuda_atomic_add2[1, (4, 8)](ary)
 
-        cuda_func_wrap = cuda.jit('void(float32[:,:])')(atomic_add_float_2_wrap)
+        cuda_func_wrap = cuda.jit("void(float32[:,:])")(atomic_add_float_2_wrap)
         cuda_func_wrap[1, (4, 8)](ary_wrap)
 
         self.assertTrue(np.all(ary == orig + 1))
@@ -546,7 +668,7 @@ class TestCudaAtomics(CUDATestCase):
     def test_atomic_add_float_3(self):
         ary = np.random.randint(0, 32, size=32).astype(np.float32).reshape(4, 8)
         orig = ary.copy()
-        cuda_atomic_add3 = cuda.jit('void(float32[:,:])')(atomic_add_float_3)
+        cuda_atomic_add3 = cuda.jit("void(float32[:,:])")(atomic_add_float_3)
         cuda_atomic_add3[1, (4, 8)](ary)
 
         self.assertTrue(np.all(ary == orig + 1))
@@ -561,24 +683,24 @@ class TestCudaAtomics(CUDATestCase):
             inst = "(red|atom)"
 
             if shared:
-                inst = f'{inst}\\.shared'
+                inst = f"{inst}\\.shared"
 
-            self.assertRegex(asm, f'{inst}.add.f64', asm)
+            self.assertRegex(asm, f"{inst}.add.f64", asm)
         else:
             if shared:
-                self.assertIn('atom.shared.cas.b64', asm)
+                self.assertIn("atom.shared.cas.b64", asm)
             else:
-                self.assertIn('atom.cas.b64', asm)
+                self.assertIn("atom.cas.b64", asm)
 
     def test_atomic_add_double(self):
         idx = np.random.randint(0, 32, size=32, dtype=np.int64)
         ary = np.zeros(32, np.float64)
         ary_wrap = ary.copy()
 
-        cuda_fn = cuda.jit('void(int64[:], float64[:])')(atomic_add_double)
+        cuda_fn = cuda.jit("void(int64[:], float64[:])")(atomic_add_double)
         cuda_fn[1, 32](idx, ary)
 
-        wrap_fn = cuda.jit('void(int64[:], float64[:])')(atomic_add_double_wrap)
+        wrap_fn = cuda.jit("void(int64[:], float64[:])")(atomic_add_double_wrap)
         wrap_fn[1, 32](idx, ary_wrap)
 
         gold = np.zeros(32, dtype=np.uint32)
@@ -595,10 +717,10 @@ class TestCudaAtomics(CUDATestCase):
         ary_wrap = ary.copy()
         orig = ary.copy()
 
-        cuda_fn = cuda.jit('void(float64[:,:])')(atomic_add_double_2)
+        cuda_fn = cuda.jit("void(float64[:,:])")(atomic_add_double_2)
         cuda_fn[1, (4, 8)](ary)
 
-        cuda_fn_wrap = cuda.jit('void(float64[:,:])')(atomic_add_double_2_wrap)
+        cuda_fn_wrap = cuda.jit("void(float64[:,:])")(atomic_add_double_2_wrap)
         cuda_fn_wrap[1, (4, 8)](ary_wrap)
 
         np.testing.assert_equal(ary, orig + 1)
@@ -609,7 +731,7 @@ class TestCudaAtomics(CUDATestCase):
     def test_atomic_add_double_3(self):
         ary = np.random.randint(0, 32, size=32).astype(np.float64).reshape(4, 8)
         orig = ary.copy()
-        cuda_func = cuda.jit('void(float64[:,:])')(atomic_add_double_3)
+        cuda_func = cuda.jit("void(float64[:,:])")(atomic_add_double_3)
         cuda_func[1, (4, 8)](ary)
 
         np.testing.assert_equal(ary, orig + 1)
@@ -620,7 +742,7 @@ class TestCudaAtomics(CUDATestCase):
         ary = np.zeros(32, np.float64)
         ary_wrap = ary.copy()
 
-        sig = 'void(int64[:], float64[:])'
+        sig = "void(int64[:], float64[:])"
         cuda_func = cuda.jit(sig)(atomic_add_double_global)
         wrap_cuda_func = cuda.jit(sig)(atomic_add_double_global_wrap)
 
@@ -641,7 +763,7 @@ class TestCudaAtomics(CUDATestCase):
         ary_wrap = ary.copy()
         orig = ary.copy()
 
-        sig = 'void(float64[:,:])'
+        sig = "void(float64[:,:])"
         cuda_func = cuda.jit(sig)(atomic_add_double_global_2)
         wrap_cuda_func = cuda.jit(sig)(atomic_add_double_global_2_wrap)
 
@@ -656,7 +778,7 @@ class TestCudaAtomics(CUDATestCase):
     def test_atomic_add_double_global_3(self):
         ary = np.random.randint(0, 32, size=32).astype(np.float64).reshape(4, 8)
         orig = ary.copy()
-        cuda_func = cuda.jit('void(float64[:,:])')(atomic_add_double_global_3)
+        cuda_func = cuda.jit("void(float64[:,:])")(atomic_add_double_global_3)
         cuda_func[1, (4, 8)](ary)
 
         np.testing.assert_equal(ary, orig + 1)
@@ -665,7 +787,7 @@ class TestCudaAtomics(CUDATestCase):
     def test_atomic_sub(self):
         ary = np.random.randint(0, 32, size=32).astype(np.uint32)
         orig = ary.copy()
-        cuda_atomic_sub = cuda.jit('void(uint32[:])')(atomic_sub)
+        cuda_atomic_sub = cuda.jit("void(uint32[:])")(atomic_sub)
         cuda_atomic_sub[1, 32](ary)
 
         gold = np.zeros(32, dtype=np.uint32)
@@ -677,21 +799,21 @@ class TestCudaAtomics(CUDATestCase):
     def test_atomic_sub2(self):
         ary = np.random.randint(0, 32, size=32).astype(np.uint32).reshape(4, 8)
         orig = ary.copy()
-        cuda_atomic_sub2 = cuda.jit('void(uint32[:,:])')(atomic_sub2)
+        cuda_atomic_sub2 = cuda.jit("void(uint32[:,:])")(atomic_sub2)
         cuda_atomic_sub2[1, (4, 8)](ary)
         self.assertTrue(np.all(ary == orig - 1))
 
     def test_atomic_sub3(self):
         ary = np.random.randint(0, 32, size=32).astype(np.uint32).reshape(4, 8)
         orig = ary.copy()
-        cuda_atomic_sub3 = cuda.jit('void(uint32[:,:])')(atomic_sub3)
+        cuda_atomic_sub3 = cuda.jit("void(uint32[:,:])")(atomic_sub3)
         cuda_atomic_sub3[1, (4, 8)](ary)
         self.assertTrue(np.all(ary == orig - 1))
 
     def test_atomic_sub_float(self):
         ary = np.random.randint(0, 32, size=32).astype(np.float32)
         orig = ary.copy().astype(np.intp)
-        cuda_atomic_sub_float = cuda.jit('void(float32[:])')(atomic_sub_float)
+        cuda_atomic_sub_float = cuda.jit("void(float32[:])")(atomic_sub_float)
         cuda_atomic_sub_float[1, 32](ary)
 
         gold = np.zeros(32, dtype=np.float32)
@@ -703,21 +825,21 @@ class TestCudaAtomics(CUDATestCase):
     def test_atomic_sub_float_2(self):
         ary = np.random.randint(0, 32, size=32).astype(np.float32).reshape(4, 8)
         orig = ary.copy()
-        cuda_atomic_sub2 = cuda.jit('void(float32[:,:])')(atomic_sub_float_2)
+        cuda_atomic_sub2 = cuda.jit("void(float32[:,:])")(atomic_sub_float_2)
         cuda_atomic_sub2[1, (4, 8)](ary)
         self.assertTrue(np.all(ary == orig - 1))
 
     def test_atomic_sub_float_3(self):
         ary = np.random.randint(0, 32, size=32).astype(np.float32).reshape(4, 8)
         orig = ary.copy()
-        cuda_atomic_sub3 = cuda.jit('void(float32[:,:])')(atomic_sub_float_3)
+        cuda_atomic_sub3 = cuda.jit("void(float32[:,:])")(atomic_sub_float_3)
         cuda_atomic_sub3[1, (4, 8)](ary)
         self.assertTrue(np.all(ary == orig - 1))
 
     def test_atomic_sub_double(self):
         idx = np.random.randint(0, 32, size=32, dtype=np.int64)
         ary = np.zeros(32, np.float64)
-        cuda_func = cuda.jit('void(int64[:], float64[:])')(atomic_sub_double)
+        cuda_func = cuda.jit("void(int64[:], float64[:])")(atomic_sub_double)
         cuda_func[1, 32](idx, ary)
 
         gold = np.zeros(32, dtype=np.float64)
@@ -729,21 +851,21 @@ class TestCudaAtomics(CUDATestCase):
     def test_atomic_sub_double_2(self):
         ary = np.random.randint(0, 32, size=32).astype(np.float64).reshape(4, 8)
         orig = ary.copy()
-        cuda_func = cuda.jit('void(float64[:,:])')(atomic_sub_double_2)
+        cuda_func = cuda.jit("void(float64[:,:])")(atomic_sub_double_2)
         cuda_func[1, (4, 8)](ary)
         np.testing.assert_equal(ary, orig - 1)
 
     def test_atomic_sub_double_3(self):
         ary = np.random.randint(0, 32, size=32).astype(np.float64).reshape(4, 8)
         orig = ary.copy()
-        cuda_func = cuda.jit('void(float64[:,:])')(atomic_sub_double_3)
+        cuda_func = cuda.jit("void(float64[:,:])")(atomic_sub_double_3)
         cuda_func[1, (4, 8)](ary)
         np.testing.assert_equal(ary, orig - 1)
 
     def test_atomic_sub_double_global(self):
         idx = np.random.randint(0, 32, size=32, dtype=np.int64)
         ary = np.zeros(32, np.float64)
-        sig = 'void(int64[:], float64[:])'
+        sig = "void(int64[:], float64[:])"
         cuda_func = cuda.jit(sig)(atomic_sub_double_global)
         cuda_func[1, 32](idx, ary)
 
@@ -756,14 +878,14 @@ class TestCudaAtomics(CUDATestCase):
     def test_atomic_sub_double_global_2(self):
         ary = np.random.randint(0, 32, size=32).astype(np.float64).reshape(4, 8)
         orig = ary.copy()
-        cuda_func = cuda.jit('void(float64[:,:])')(atomic_sub_double_global_2)
+        cuda_func = cuda.jit("void(float64[:,:])")(atomic_sub_double_global_2)
         cuda_func[1, (4, 8)](ary)
         np.testing.assert_equal(ary, orig - 1)
 
     def test_atomic_sub_double_global_3(self):
         ary = np.random.randint(0, 32, size=32).astype(np.float64).reshape(4, 8)
         orig = ary.copy()
-        cuda_func = cuda.jit('void(float64[:,:])')(atomic_sub_double_global_3)
+        cuda_func = cuda.jit("void(float64[:,:])")(atomic_sub_double_global_3)
         cuda_func[1, (4, 8)](ary)
         np.testing.assert_equal(ary, orig - 1)
 
@@ -771,7 +893,7 @@ class TestCudaAtomics(CUDATestCase):
         rand_const = np.random.randint(500)
         ary = np.random.randint(0, 32, size=32).astype(np.uint32)
         orig = ary.copy()
-        cuda_func = cuda.jit('void(uint32[:], uint32)')(atomic_and)
+        cuda_func = cuda.jit("void(uint32[:], uint32)")(atomic_and)
         cuda_func[1, 32](ary, rand_const)
 
         gold = ary.copy()
@@ -784,7 +906,7 @@ class TestCudaAtomics(CUDATestCase):
         rand_const = np.random.randint(500)
         ary = np.random.randint(0, 32, size=32).astype(np.uint32).reshape(4, 8)
         orig = ary.copy()
-        cuda_atomic_and2 = cuda.jit('void(uint32[:,:], uint32)')(atomic_and2)
+        cuda_atomic_and2 = cuda.jit("void(uint32[:,:], uint32)")(atomic_and2)
         cuda_atomic_and2[1, (4, 8)](ary, rand_const)
         self.assertTrue(np.all(ary == orig & rand_const))
 
@@ -792,7 +914,7 @@ class TestCudaAtomics(CUDATestCase):
         rand_const = np.random.randint(500)
         ary = np.random.randint(0, 32, size=32).astype(np.uint32).reshape(4, 8)
         orig = ary.copy()
-        cuda_atomic_and3 = cuda.jit('void(uint32[:,:], uint32)')(atomic_and3)
+        cuda_atomic_and3 = cuda.jit("void(uint32[:,:], uint32)")(atomic_and3)
         cuda_atomic_and3[1, (4, 8)](ary, rand_const)
         self.assertTrue(np.all(ary == orig & rand_const))
 
@@ -800,7 +922,7 @@ class TestCudaAtomics(CUDATestCase):
         rand_const = np.random.randint(500)
         idx = np.random.randint(0, 32, size=32, dtype=np.int32)
         ary = np.random.randint(0, 32, size=32, dtype=np.int32)
-        sig = 'void(int32[:], int32[:], int32)'
+        sig = "void(int32[:], int32[:], int32)"
         cuda_func = cuda.jit(sig)(atomic_and_global)
         cuda_func[1, 32](idx, ary, rand_const)
 
@@ -814,7 +936,7 @@ class TestCudaAtomics(CUDATestCase):
         rand_const = np.random.randint(500)
         ary = np.random.randint(0, 32, size=32).astype(np.uint32).reshape(4, 8)
         orig = ary.copy()
-        cuda_func = cuda.jit('void(uint32[:,:], uint32)')(atomic_and_global_2)
+        cuda_func = cuda.jit("void(uint32[:,:], uint32)")(atomic_and_global_2)
         cuda_func[1, (4, 8)](ary, rand_const)
         np.testing.assert_equal(ary, orig & rand_const)
 
@@ -822,7 +944,7 @@ class TestCudaAtomics(CUDATestCase):
         rand_const = np.random.randint(500)
         ary = np.random.randint(0, 32, size=32).astype(np.uint32)
         orig = ary.copy()
-        cuda_func = cuda.jit('void(uint32[:], uint32)')(atomic_or)
+        cuda_func = cuda.jit("void(uint32[:], uint32)")(atomic_or)
         cuda_func[1, 32](ary, rand_const)
 
         gold = np.zeros(32, dtype=np.uint32)
@@ -835,7 +957,7 @@ class TestCudaAtomics(CUDATestCase):
         rand_const = np.random.randint(500)
         ary = np.random.randint(0, 32, size=32).astype(np.uint32).reshape(4, 8)
         orig = ary.copy()
-        cuda_atomic_and2 = cuda.jit('void(uint32[:,:], uint32)')(atomic_or2)
+        cuda_atomic_and2 = cuda.jit("void(uint32[:,:], uint32)")(atomic_or2)
         cuda_atomic_and2[1, (4, 8)](ary, rand_const)
         self.assertTrue(np.all(ary == orig | rand_const))
 
@@ -843,7 +965,7 @@ class TestCudaAtomics(CUDATestCase):
         rand_const = np.random.randint(500)
         ary = np.random.randint(0, 32, size=32).astype(np.uint32).reshape(4, 8)
         orig = ary.copy()
-        cuda_atomic_and3 = cuda.jit('void(uint32[:,:], uint32)')(atomic_or3)
+        cuda_atomic_and3 = cuda.jit("void(uint32[:,:], uint32)")(atomic_or3)
         cuda_atomic_and3[1, (4, 8)](ary, rand_const)
         self.assertTrue(np.all(ary == orig | rand_const))
 
@@ -851,7 +973,7 @@ class TestCudaAtomics(CUDATestCase):
         rand_const = np.random.randint(500)
         idx = np.random.randint(0, 32, size=32, dtype=np.int32)
         ary = np.random.randint(0, 32, size=32, dtype=np.int32)
-        sig = 'void(int32[:], int32[:], int32)'
+        sig = "void(int32[:], int32[:], int32)"
         cuda_func = cuda.jit(sig)(atomic_or_global)
         cuda_func[1, 32](idx, ary, rand_const)
 
@@ -865,7 +987,7 @@ class TestCudaAtomics(CUDATestCase):
         rand_const = np.random.randint(500)
         ary = np.random.randint(0, 32, size=32).astype(np.uint32).reshape(4, 8)
         orig = ary.copy()
-        cuda_func = cuda.jit('void(uint32[:,:], uint32)')(atomic_or_global_2)
+        cuda_func = cuda.jit("void(uint32[:,:], uint32)")(atomic_or_global_2)
         cuda_func[1, (4, 8)](ary, rand_const)
         np.testing.assert_equal(ary, orig | rand_const)
 
@@ -873,7 +995,7 @@ class TestCudaAtomics(CUDATestCase):
         rand_const = np.random.randint(500)
         ary = np.random.randint(0, 32, size=32).astype(np.uint32)
         orig = ary.copy()
-        cuda_func = cuda.jit('void(uint32[:], uint32)')(atomic_xor)
+        cuda_func = cuda.jit("void(uint32[:], uint32)")(atomic_xor)
         cuda_func[1, 32](ary, rand_const)
 
         gold = np.zeros(32, dtype=np.uint32)
@@ -886,7 +1008,7 @@ class TestCudaAtomics(CUDATestCase):
         rand_const = np.random.randint(500)
         ary = np.random.randint(0, 32, size=32).astype(np.uint32).reshape(4, 8)
         orig = ary.copy()
-        cuda_atomic_xor2 = cuda.jit('void(uint32[:,:], uint32)')(atomic_xor2)
+        cuda_atomic_xor2 = cuda.jit("void(uint32[:,:], uint32)")(atomic_xor2)
         cuda_atomic_xor2[1, (4, 8)](ary, rand_const)
         self.assertTrue(np.all(ary == orig ^ rand_const))
 
@@ -894,7 +1016,7 @@ class TestCudaAtomics(CUDATestCase):
         rand_const = np.random.randint(500)
         ary = np.random.randint(0, 32, size=32).astype(np.uint32).reshape(4, 8)
         orig = ary.copy()
-        cuda_atomic_xor3 = cuda.jit('void(uint32[:,:], uint32)')(atomic_xor3)
+        cuda_atomic_xor3 = cuda.jit("void(uint32[:,:], uint32)")(atomic_xor3)
         cuda_atomic_xor3[1, (4, 8)](ary, rand_const)
         self.assertTrue(np.all(ary == orig ^ rand_const))
 
@@ -903,7 +1025,7 @@ class TestCudaAtomics(CUDATestCase):
         idx = np.random.randint(0, 32, size=32, dtype=np.int32)
         ary = np.random.randint(0, 32, size=32, dtype=np.int32)
         gold = ary.copy()
-        sig = 'void(int32[:], int32[:], int32)'
+        sig = "void(int32[:], int32[:], int32)"
         cuda_func = cuda.jit(sig)(atomic_xor_global)
         cuda_func[1, 32](idx, ary, rand_const)
 
@@ -916,12 +1038,12 @@ class TestCudaAtomics(CUDATestCase):
         rand_const = np.random.randint(500)
         ary = np.random.randint(0, 32, size=32).astype(np.uint32).reshape(4, 8)
         orig = ary.copy()
-        cuda_func = cuda.jit('void(uint32[:,:], uint32)')(atomic_xor_global_2)
+        cuda_func = cuda.jit("void(uint32[:,:], uint32)")(atomic_xor_global_2)
         cuda_func[1, (4, 8)](ary, rand_const)
         np.testing.assert_equal(ary, orig ^ rand_const)
 
     def inc_dec_1dim_setup(self, dtype):
-        rconst = np.random.randint(32,  dtype=dtype)
+        rconst = np.random.randint(32, dtype=dtype)
         rary = np.random.randint(0, 32, size=32).astype(dtype)
         ary_idx = np.arange(32, dtype=dtype)
         return rconst, rary, ary_idx
@@ -951,131 +1073,141 @@ class TestCudaAtomics(CUDATestCase):
 
     def test_atomic_inc_32(self):
         rand_const, ary, idx = self.inc_dec_1dim_setup(dtype=np.uint32)
-        sig = 'void(uint32[:], uint32[:], uint32)'
+        sig = "void(uint32[:], uint32[:], uint32)"
         self.check_inc_index(ary, idx, rand_const, sig, 1, 32, atomic_inc32)
 
     def test_atomic_inc_64(self):
         rand_const, ary, idx = self.inc_dec_1dim_setup(dtype=np.uint64)
-        sig = 'void(uint64[:], uint64[:], uint64)'
+        sig = "void(uint64[:], uint64[:], uint64)"
         self.check_inc_index(ary, idx, rand_const, sig, 1, 32, atomic_inc64)
 
     def test_atomic_inc2_32(self):
         rand_const, ary = self.inc_dec_2dim_setup(np.uint32)
-        sig = 'void(uint32[:,:], uint32)'
-        self.check_inc(ary, rand_const, sig, 1, (4,8), atomic_inc2_32)
+        sig = "void(uint32[:,:], uint32)"
+        self.check_inc(ary, rand_const, sig, 1, (4, 8), atomic_inc2_32)
 
     def test_atomic_inc2_64(self):
         rand_const, ary = self.inc_dec_2dim_setup(np.uint64)
-        sig = 'void(uint64[:,:], uint64)'
-        self.check_inc(ary, rand_const, sig, 1, (4,8), atomic_inc2_64)
+        sig = "void(uint64[:,:], uint64)"
+        self.check_inc(ary, rand_const, sig, 1, (4, 8), atomic_inc2_64)
 
     def test_atomic_inc3(self):
         rand_const, ary = self.inc_dec_2dim_setup(np.uint32)
-        sig = 'void(uint32[:,:], uint32)'
-        self.check_inc(ary, rand_const, sig, 1, (4,8), atomic_inc3)
+        sig = "void(uint32[:,:], uint32)"
+        self.check_inc(ary, rand_const, sig, 1, (4, 8), atomic_inc3)
 
     def test_atomic_inc_global_32(self):
         rand_const, ary, idx = self.inc_dec_1dim_setup(dtype=np.uint32)
-        sig = 'void(uint32[:], uint32[:], uint32)'
-        self.check_inc_index2(ary, idx, rand_const, sig, 1, 32,
-                              atomic_inc_global)
+        sig = "void(uint32[:], uint32[:], uint32)"
+        self.check_inc_index2(
+            ary, idx, rand_const, sig, 1, 32, atomic_inc_global
+        )
 
     def test_atomic_inc_global_64(self):
         rand_const, ary, idx = self.inc_dec_1dim_setup(dtype=np.uint64)
-        sig = 'void(uint64[:], uint64[:], uint64)'
-        self.check_inc_index2(ary, idx, rand_const, sig, 1, 32,
-                              atomic_inc_global)
+        sig = "void(uint64[:], uint64[:], uint64)"
+        self.check_inc_index2(
+            ary, idx, rand_const, sig, 1, 32, atomic_inc_global
+        )
 
     def test_atomic_inc_global_2_32(self):
         rand_const, ary = self.inc_dec_2dim_setup(np.uint32)
-        sig = 'void(uint32[:,:], uint32)'
-        self.check_inc(ary, rand_const, sig, 1, (4,8), atomic_inc_global_2)
+        sig = "void(uint32[:,:], uint32)"
+        self.check_inc(ary, rand_const, sig, 1, (4, 8), atomic_inc_global_2)
 
     def test_atomic_inc_global_2_64(self):
         rand_const, ary = self.inc_dec_2dim_setup(np.uint64)
-        sig = 'void(uint64[:,:], uint64)'
-        self.check_inc(ary, rand_const, sig, 1, (4,8), atomic_inc_global_2)
+        sig = "void(uint64[:,:], uint64)"
+        self.check_inc(ary, rand_const, sig, 1, (4, 8), atomic_inc_global_2)
 
     def check_dec_index(self, ary, idx, rconst, sig, nblocks, blksize, func):
         orig = ary.copy()
         cuda_func = cuda.jit(sig)(func)
         cuda_func[nblocks, blksize](ary, idx, rconst)
-        np.testing.assert_equal(ary, np.where(orig == 0, rconst,
-                                              np.where(orig > rconst,
-                                                       rconst,
-                                                       orig - 1)))
+        np.testing.assert_equal(
+            ary,
+            np.where(
+                orig == 0, rconst, np.where(orig > rconst, rconst, orig - 1)
+            ),
+        )
 
     def check_dec_index2(self, ary, idx, rconst, sig, nblocks, blksize, func):
         orig = ary.copy()
         cuda_func = cuda.jit(sig)(func)
         cuda_func[nblocks, blksize](idx, ary, rconst)
-        np.testing.assert_equal(ary, np.where(orig == 0, rconst,
-                                              np.where(orig > rconst,
-                                                       rconst,
-                                                       orig - 1)))
+        np.testing.assert_equal(
+            ary,
+            np.where(
+                orig == 0, rconst, np.where(orig > rconst, rconst, orig - 1)
+            ),
+        )
 
     def check_dec(self, ary, rconst, sig, nblocks, blksize, func):
         orig = ary.copy()
         cuda_func = cuda.jit(sig)(func)
         cuda_func[nblocks, blksize](ary, rconst)
-        np.testing.assert_equal(ary, np.where(orig == 0, rconst,
-                                              np.where(orig > rconst,
-                                                       rconst,
-                                                       orig - 1)))
+        np.testing.assert_equal(
+            ary,
+            np.where(
+                orig == 0, rconst, np.where(orig > rconst, rconst, orig - 1)
+            ),
+        )
 
     def test_atomic_dec_32(self):
         rand_const, ary, idx = self.inc_dec_1dim_setup(dtype=np.uint32)
-        sig = 'void(uint32[:], uint32[:], uint32)'
+        sig = "void(uint32[:], uint32[:], uint32)"
         self.check_dec_index(ary, idx, rand_const, sig, 1, 32, atomic_dec32)
 
     def test_atomic_dec_64(self):
         rand_const, ary, idx = self.inc_dec_1dim_setup(dtype=np.uint64)
-        sig = 'void(uint64[:], uint64[:], uint64)'
+        sig = "void(uint64[:], uint64[:], uint64)"
         self.check_dec_index(ary, idx, rand_const, sig, 1, 32, atomic_dec64)
 
     def test_atomic_dec2_32(self):
         rand_const, ary = self.inc_dec_2dim_setup(np.uint32)
-        sig = 'void(uint32[:,:], uint32)'
-        self.check_dec(ary, rand_const, sig, 1, (4,8), atomic_dec2_32)
+        sig = "void(uint32[:,:], uint32)"
+        self.check_dec(ary, rand_const, sig, 1, (4, 8), atomic_dec2_32)
 
     def test_atomic_dec2_64(self):
         rand_const, ary = self.inc_dec_2dim_setup(np.uint64)
-        sig = 'void(uint64[:,:], uint64)'
-        self.check_dec(ary, rand_const, sig, 1, (4,8), atomic_dec2_64)
+        sig = "void(uint64[:,:], uint64)"
+        self.check_dec(ary, rand_const, sig, 1, (4, 8), atomic_dec2_64)
 
     def test_atomic_dec3_new(self):
         rand_const, ary = self.inc_dec_2dim_setup(np.uint32)
-        sig = 'void(uint32[:,:], uint32)'
-        self.check_dec(ary, rand_const, sig, 1, (4,8), atomic_dec3)
+        sig = "void(uint32[:,:], uint32)"
+        self.check_dec(ary, rand_const, sig, 1, (4, 8), atomic_dec3)
 
     def test_atomic_dec_global_32(self):
         rand_const, ary, idx = self.inc_dec_1dim_setup(dtype=np.uint32)
-        sig = 'void(uint32[:], uint32[:], uint32)'
-        self.check_dec_index2(ary, idx, rand_const, sig, 1, 32,
-                              atomic_dec_global)
+        sig = "void(uint32[:], uint32[:], uint32)"
+        self.check_dec_index2(
+            ary, idx, rand_const, sig, 1, 32, atomic_dec_global
+        )
 
     def test_atomic_dec_global_64(self):
         rand_const, ary, idx = self.inc_dec_1dim_setup(dtype=np.uint64)
-        sig = 'void(uint64[:], uint64[:], uint64)'
-        self.check_dec_index2(ary, idx, rand_const, sig, 1, 32,
-                              atomic_dec_global)
+        sig = "void(uint64[:], uint64[:], uint64)"
+        self.check_dec_index2(
+            ary, idx, rand_const, sig, 1, 32, atomic_dec_global
+        )
 
     def test_atomic_dec_global2_32(self):
         rand_const, ary = self.inc_dec_2dim_setup(np.uint32)
-        sig = 'void(uint32[:,:], uint32)'
-        self.check_dec(ary, rand_const, sig, 1, (4,8), atomic_dec_global_2)
+        sig = "void(uint32[:,:], uint32)"
+        self.check_dec(ary, rand_const, sig, 1, (4, 8), atomic_dec_global_2)
 
     def test_atomic_dec_global2_64(self):
         rand_const, ary = self.inc_dec_2dim_setup(np.uint64)
-        sig = 'void(uint64[:,:], uint64)'
-        self.check_dec(ary, rand_const, sig, 1, (4,8), atomic_dec_global_2)
+        sig = "void(uint64[:,:], uint64)"
+        self.check_dec(ary, rand_const, sig, 1, (4, 8), atomic_dec_global_2)
 
     def test_atomic_exch(self):
         rand_const = np.random.randint(50, 100, dtype=np.uint32)
         ary = np.random.randint(0, 32, size=32).astype(np.uint32)
         idx = np.arange(32, dtype=np.uint32)
 
-        cuda_func = cuda.jit('void(uint32[:], uint32[:], uint32)')(atomic_exch)
+        cuda_func = cuda.jit("void(uint32[:], uint32[:], uint32)")(atomic_exch)
         cuda_func[1, 32](ary, idx, rand_const)
 
         np.testing.assert_equal(ary, rand_const)
@@ -1084,7 +1216,7 @@ class TestCudaAtomics(CUDATestCase):
         rand_const = np.random.randint(50, 100, dtype=np.uint32)
         ary = np.random.randint(0, 32, size=32).astype(np.uint32).reshape(4, 8)
 
-        cuda_func = cuda.jit('void(uint32[:,:], uint32)')(atomic_exch2)
+        cuda_func = cuda.jit("void(uint32[:,:], uint32)")(atomic_exch2)
         cuda_func[1, (4, 8)](ary, rand_const)
         np.testing.assert_equal(ary, rand_const)
 
@@ -1092,7 +1224,7 @@ class TestCudaAtomics(CUDATestCase):
         rand_const = np.random.randint(50, 100, dtype=np.uint64)
         ary = np.random.randint(0, 32, size=32).astype(np.uint64).reshape(4, 8)
 
-        cuda_func = cuda.jit('void(uint64[:,:], uint64)')(atomic_exch3)
+        cuda_func = cuda.jit("void(uint64[:,:], uint64)")(atomic_exch3)
         cuda_func[1, (4, 8)](ary, rand_const)
         np.testing.assert_equal(ary, rand_const)
 
@@ -1101,7 +1233,7 @@ class TestCudaAtomics(CUDATestCase):
         idx = np.arange(32, dtype=np.uint32)
         ary = np.random.randint(0, 32, size=32, dtype=np.uint32)
 
-        sig = 'void(uint32[:], uint32[:], uint32)'
+        sig = "void(uint32[:], uint32[:], uint32)"
         cuda_func = cuda.jit(sig)(atomic_exch_global)
         cuda_func[1, 32](idx, ary, rand_const)
         np.testing.assert_equal(ary, rand_const)
@@ -1135,8 +1267,9 @@ class TestCudaAtomics(CUDATestCase):
     def test_atomic_max_double_normalizedindex(self):
         vals = np.random.randint(0, 65535, size=(32, 32)).astype(np.float64)
         res = np.zeros(1, np.float64)
-        cuda_func = cuda.jit('void(float64[:], float64[:,:])')(
-            atomic_max_double_normalizedindex)
+        cuda_func = cuda.jit("void(float64[:], float64[:,:])")(
+            atomic_max_double_normalizedindex
+        )
         cuda_func[32, 32](res, vals)
 
         gold = np.max(vals)
@@ -1145,8 +1278,9 @@ class TestCudaAtomics(CUDATestCase):
     def test_atomic_max_double_oneindex(self):
         vals = np.random.randint(0, 128, size=32).astype(np.float64)
         res = np.zeros(1, np.float64)
-        cuda_func = cuda.jit('void(float64[:], float64[:])')(
-            atomic_max_double_oneindex)
+        cuda_func = cuda.jit("void(float64[:], float64[:])")(
+            atomic_max_double_oneindex
+        )
         cuda_func[1, 32](res, vals)
 
         gold = np.max(vals)
@@ -1182,8 +1316,9 @@ class TestCudaAtomics(CUDATestCase):
     def test_atomic_min_double_normalizedindex(self):
         vals = np.random.randint(0, 65535, size=(32, 32)).astype(np.float64)
         res = np.ones(1, np.float64) * 65535
-        cuda_func = cuda.jit('void(float64[:], float64[:,:])')(
-            atomic_min_double_normalizedindex)
+        cuda_func = cuda.jit("void(float64[:], float64[:,:])")(
+            atomic_min_double_normalizedindex
+        )
         cuda_func[32, 32](res, vals)
 
         gold = np.min(vals)
@@ -1192,8 +1327,9 @@ class TestCudaAtomics(CUDATestCase):
     def test_atomic_min_double_oneindex(self):
         vals = np.random.randint(0, 128, size=32).astype(np.float64)
         res = np.ones(1, np.float64) * 128
-        cuda_func = cuda.jit('void(float64[:], float64[:])')(
-            atomic_min_double_oneindex)
+        cuda_func = cuda.jit("void(float64[:], float64[:])")(
+            atomic_min_double_oneindex
+        )
         cuda_func[1, 32](res, vals)
 
         gold = np.min(vals)
@@ -1211,16 +1347,15 @@ class TestCudaAtomics(CUDATestCase):
     # the result will be ary[idx] for either of ary[idx] or val being NaN.
 
     def _test_atomic_minmax_nan_location(self, func):
+        cuda_func = cuda.jit("void(float64[:], float64[:,:])")(func)
 
-        cuda_func = cuda.jit('void(float64[:], float64[:,:])')(func)
-
-        vals = np.random.randint(0, 128, size=(1,1)).astype(np.float64)
+        vals = np.random.randint(0, 128, size=(1, 1)).astype(np.float64)
         res = np.zeros(1, np.float64) + np.nan
         cuda_func[1, 1](res, vals)
         np.testing.assert_equal(res, [np.nan])
 
     def _test_atomic_minmax_nan_val(self, func):
-        cuda_func = cuda.jit('void(float64[:], float64[:,:])')(func)
+        cuda_func = cuda.jit("void(float64[:], float64[:,:])")(func)
 
         res = np.random.randint(0, 128, size=1).astype(np.float64)
         gold = res.copy()
@@ -1244,7 +1379,7 @@ class TestCudaAtomics(CUDATestCase):
     def test_atomic_max_double_shared(self):
         vals = np.random.randint(0, 32, size=32).astype(np.float64)
         res = np.zeros(1, np.float64)
-        sig = 'void(float64[:], float64[:])'
+        sig = "void(float64[:], float64[:])"
         cuda_func = cuda.jit(sig)(atomic_max_double_shared)
         cuda_func[1, 32](res, vals)
 
@@ -1254,7 +1389,7 @@ class TestCudaAtomics(CUDATestCase):
     def test_atomic_min_double_shared(self):
         vals = np.random.randint(0, 32, size=32).astype(np.float64)
         res = np.ones(1, np.float64) * 32
-        sig = 'void(float64[:], float64[:])'
+        sig = "void(float64[:], float64[:])"
         cuda_func = cuda.jit(sig)(atomic_min_double_shared)
         cuda_func[1, 32](res, vals)
 
@@ -1289,64 +1424,120 @@ class TestCudaAtomics(CUDATestCase):
         np.testing.assert_array_equal(expect_out, out)
 
     def test_atomic_compare_and_swap(self):
-        self.check_cas(n=100, fill=-99, unfill=-1, dtype=np.int32,
-                       cas_func=atomic_compare_and_swap)
+        self.check_cas(
+            n=100,
+            fill=-99,
+            unfill=-1,
+            dtype=np.int32,
+            cas_func=atomic_compare_and_swap,
+        )
 
     def test_atomic_compare_and_swap2(self):
-        self.check_cas(n=100, fill=-45, unfill=-1, dtype=np.int64,
-                       cas_func=atomic_compare_and_swap)
+        self.check_cas(
+            n=100,
+            fill=-45,
+            unfill=-1,
+            dtype=np.int64,
+            cas_func=atomic_compare_and_swap,
+        )
 
     def test_atomic_compare_and_swap3(self):
         rfill = np.random.randint(50, 500, dtype=np.uint32)
         runfill = np.random.randint(1, 25, dtype=np.uint32)
-        self.check_cas(n=100, fill=rfill, unfill=runfill, dtype=np.uint32,
-                       cas_func=atomic_compare_and_swap)
+        self.check_cas(
+            n=100,
+            fill=rfill,
+            unfill=runfill,
+            dtype=np.uint32,
+            cas_func=atomic_compare_and_swap,
+        )
 
     def test_atomic_compare_and_swap4(self):
         rfill = np.random.randint(50, 500, dtype=np.uint64)
         runfill = np.random.randint(1, 25, dtype=np.uint64)
-        self.check_cas(n=100, fill=rfill, unfill=runfill, dtype=np.uint64,
-                       cas_func=atomic_compare_and_swap)
+        self.check_cas(
+            n=100,
+            fill=rfill,
+            unfill=runfill,
+            dtype=np.uint64,
+            cas_func=atomic_compare_and_swap,
+        )
 
     def test_atomic_cas_1dim(self):
-        self.check_cas(n=100, fill=-99, unfill=-1, dtype=np.int32,
-                       cas_func=atomic_cas_1dim)
+        self.check_cas(
+            n=100, fill=-99, unfill=-1, dtype=np.int32, cas_func=atomic_cas_1dim
+        )
 
     def test_atomic_cas_2dim(self):
-        self.check_cas(n=100, fill=-99, unfill=-1, dtype=np.int32,
-                       cas_func=atomic_cas_2dim, ndim=2)
+        self.check_cas(
+            n=100,
+            fill=-99,
+            unfill=-1,
+            dtype=np.int32,
+            cas_func=atomic_cas_2dim,
+            ndim=2,
+        )
 
     def test_atomic_cas2_1dim(self):
-        self.check_cas(n=100, fill=-45, unfill=-1, dtype=np.int64,
-                       cas_func=atomic_cas_1dim)
+        self.check_cas(
+            n=100, fill=-45, unfill=-1, dtype=np.int64, cas_func=atomic_cas_1dim
+        )
 
     def test_atomic_cas2_2dim(self):
-        self.check_cas(n=100, fill=-45, unfill=-1, dtype=np.int64,
-                       cas_func=atomic_cas_2dim, ndim=2)
+        self.check_cas(
+            n=100,
+            fill=-45,
+            unfill=-1,
+            dtype=np.int64,
+            cas_func=atomic_cas_2dim,
+            ndim=2,
+        )
 
     def test_atomic_cas3_1dim(self):
         rfill = np.random.randint(50, 500, dtype=np.uint32)
         runfill = np.random.randint(1, 25, dtype=np.uint32)
-        self.check_cas(n=100, fill=rfill, unfill=runfill, dtype=np.uint32,
-                       cas_func=atomic_cas_1dim)
+        self.check_cas(
+            n=100,
+            fill=rfill,
+            unfill=runfill,
+            dtype=np.uint32,
+            cas_func=atomic_cas_1dim,
+        )
 
     def test_atomic_cas3_2dim(self):
         rfill = np.random.randint(50, 500, dtype=np.uint32)
         runfill = np.random.randint(1, 25, dtype=np.uint32)
-        self.check_cas(n=100, fill=rfill, unfill=runfill, dtype=np.uint32,
-                       cas_func=atomic_cas_2dim, ndim=2)
+        self.check_cas(
+            n=100,
+            fill=rfill,
+            unfill=runfill,
+            dtype=np.uint32,
+            cas_func=atomic_cas_2dim,
+            ndim=2,
+        )
 
     def test_atomic_cas4_1dim(self):
         rfill = np.random.randint(50, 500, dtype=np.uint64)
         runfill = np.random.randint(1, 25, dtype=np.uint64)
-        self.check_cas(n=100, fill=rfill, unfill=runfill, dtype=np.uint64,
-                       cas_func=atomic_cas_1dim)
+        self.check_cas(
+            n=100,
+            fill=rfill,
+            unfill=runfill,
+            dtype=np.uint64,
+            cas_func=atomic_cas_1dim,
+        )
 
     def test_atomic_cas4_2dim(self):
         rfill = np.random.randint(50, 500, dtype=np.uint64)
         runfill = np.random.randint(1, 25, dtype=np.uint64)
-        self.check_cas(n=100, fill=rfill, unfill=runfill, dtype=np.uint64,
-                       cas_func=atomic_cas_2dim, ndim=2)
+        self.check_cas(
+            n=100,
+            fill=rfill,
+            unfill=runfill,
+            dtype=np.uint64,
+            cas_func=atomic_cas_2dim,
+            ndim=2,
+        )
 
     # Tests that the atomic add, min, and max operations return the old value -
     # in the simulator, they did not (see Issue #5458). The max and min have
@@ -1438,34 +1629,36 @@ class TestCudaAtomics(CUDATestCase):
         np.testing.assert_equal(res, gold)
 
     def test_atomic_nanmax_int32(self):
-        self.check_atomic_nanmax(dtype=np.int32, lo=-65535, hi=65535,
-                                 init_val=0)
+        self.check_atomic_nanmax(
+            dtype=np.int32, lo=-65535, hi=65535, init_val=0
+        )
 
     def test_atomic_nanmax_uint32(self):
-        self.check_atomic_nanmax(dtype=np.uint32, lo=0, hi=65535,
-                                 init_val=0)
+        self.check_atomic_nanmax(dtype=np.uint32, lo=0, hi=65535, init_val=0)
 
     def test_atomic_nanmax_int64(self):
-        self.check_atomic_nanmax(dtype=np.int64, lo=-65535, hi=65535,
-                                 init_val=0)
+        self.check_atomic_nanmax(
+            dtype=np.int64, lo=-65535, hi=65535, init_val=0
+        )
 
     def test_atomic_nanmax_uint64(self):
-        self.check_atomic_nanmax(dtype=np.uint64, lo=0, hi=65535,
-                                 init_val=0)
+        self.check_atomic_nanmax(dtype=np.uint64, lo=0, hi=65535, init_val=0)
 
     def test_atomic_nanmax_float32(self):
-        self.check_atomic_nanmax(dtype=np.float32, lo=-65535, hi=65535,
-                                 init_val=np.nan)
+        self.check_atomic_nanmax(
+            dtype=np.float32, lo=-65535, hi=65535, init_val=np.nan
+        )
 
     def test_atomic_nanmax_double(self):
-        self.check_atomic_nanmax(dtype=np.float64, lo=-65535, hi=65535,
-                                 init_val=np.nan)
+        self.check_atomic_nanmax(
+            dtype=np.float64, lo=-65535, hi=65535, init_val=np.nan
+        )
 
     def test_atomic_nanmax_double_shared(self):
         vals = np.random.randint(0, 32, size=32).astype(np.float64)
         vals[1::2] = np.nan
         res = np.array([0], dtype=vals.dtype)
-        sig = 'void(float64[:], float64[:])'
+        sig = "void(float64[:], float64[:])"
         cuda_func = cuda.jit(sig)(atomic_nanmax_double_shared)
         cuda_func[1, 32](res, vals)
 
@@ -1476,8 +1669,9 @@ class TestCudaAtomics(CUDATestCase):
         vals = np.random.randint(0, 128, size=32).astype(np.float64)
         vals[1::2] = np.nan
         res = np.zeros(1, np.float64)
-        cuda_func = cuda.jit('void(float64[:], float64[:])')(
-            atomic_max_double_oneindex)
+        cuda_func = cuda.jit("void(float64[:], float64[:])")(
+            atomic_max_double_oneindex
+        )
         cuda_func[1, 32](res, vals)
 
         gold = np.nanmax(vals)
@@ -1495,34 +1689,36 @@ class TestCudaAtomics(CUDATestCase):
         np.testing.assert_equal(res, gold)
 
     def test_atomic_nanmin_int32(self):
-        self.check_atomic_nanmin(dtype=np.int32, lo=-65535, hi=65535,
-                                 init_val=0)
+        self.check_atomic_nanmin(
+            dtype=np.int32, lo=-65535, hi=65535, init_val=0
+        )
 
     def test_atomic_nanmin_uint32(self):
-        self.check_atomic_nanmin(dtype=np.uint32, lo=0, hi=65535,
-                                 init_val=0)
+        self.check_atomic_nanmin(dtype=np.uint32, lo=0, hi=65535, init_val=0)
 
     def test_atomic_nanmin_int64(self):
-        self.check_atomic_nanmin(dtype=np.int64, lo=-65535, hi=65535,
-                                 init_val=0)
+        self.check_atomic_nanmin(
+            dtype=np.int64, lo=-65535, hi=65535, init_val=0
+        )
 
     def test_atomic_nanmin_uint64(self):
-        self.check_atomic_nanmin(dtype=np.uint64, lo=0, hi=65535,
-                                 init_val=0)
+        self.check_atomic_nanmin(dtype=np.uint64, lo=0, hi=65535, init_val=0)
 
     def test_atomic_nanmin_float(self):
-        self.check_atomic_nanmin(dtype=np.float32, lo=-65535, hi=65535,
-                                 init_val=np.nan)
+        self.check_atomic_nanmin(
+            dtype=np.float32, lo=-65535, hi=65535, init_val=np.nan
+        )
 
     def test_atomic_nanmin_double(self):
-        self.check_atomic_nanmin(dtype=np.float64, lo=-65535, hi=65535,
-                                 init_val=np.nan)
+        self.check_atomic_nanmin(
+            dtype=np.float64, lo=-65535, hi=65535, init_val=np.nan
+        )
 
     def test_atomic_nanmin_double_shared(self):
         vals = np.random.randint(0, 32, size=32).astype(np.float64)
         vals[1::2] = np.nan
         res = np.array([32], dtype=vals.dtype)
-        sig = 'void(float64[:], float64[:])'
+        sig = "void(float64[:], float64[:])"
         cuda_func = cuda.jit(sig)(atomic_nanmin_double_shared)
         cuda_func[1, 32](res, vals)
 
@@ -1533,8 +1729,9 @@ class TestCudaAtomics(CUDATestCase):
         vals = np.random.randint(0, 128, size=32).astype(np.float64)
         vals[1::2] = np.nan
         res = np.array([128], np.float64)
-        cuda_func = cuda.jit('void(float64[:], float64[:])')(
-            atomic_min_double_oneindex)
+        cuda_func = cuda.jit("void(float64[:], float64[:])")(
+            atomic_min_double_oneindex
+        )
         cuda_func[1, 32](res, vals)
 
         gold = np.nanmin(vals)
@@ -1610,5 +1807,5 @@ class TestCudaAtomics(CUDATestCase):
         self._test_atomic_nan_returns_old(kernel, 11)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()