numba-cuda 0.22.0__cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl

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

@@ -0,0 +1,203 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
+import numpy as np
+from collections import namedtuple
+
+from numba import cuda
+from numba.cuda.testing import unittest, CUDATestCase
+
+
+class TestCudaArrayArg(CUDATestCase):
+    def test_array_ary(self):
+        @cuda.jit("double(double[:],int64)", device=True, inline="always")
+        def device_function(a, c):
+            return a[c]
+
+        @cuda.jit("void(double[:],double[:])")
+        def kernel(x, y):
+            i = cuda.grid(1)
+            y[i] = device_function(x, i)
+
+        x = np.arange(10, dtype=np.double)
+        y = np.zeros_like(x)
+        kernel[10, 1](x, y)
+        self.assertTrue(np.all(x == y))
+
+    def test_unituple(self):
+        @cuda.jit
+        def f(r, x):
+            r[0] = x[0]
+            r[1] = x[1]
+            r[2] = x[2]
+
+        x = (1, 2, 3)
+        r = np.zeros(len(x), dtype=np.int64)
+        f[1, 1](r, x)
+
+        for i in range(len(x)):
+            self.assertEqual(r[i], x[i])
+
+    def test_tuple(self):
+        @cuda.jit
+        def f(r1, r2, x):
+            r1[0] = x[0]
+            r1[1] = x[1]
+            r1[2] = x[2]
+            r2[0] = x[3]
+            r2[1] = x[4]
+            r2[2] = x[5]
+
+        x = (1, 2, 3, 4.5, 5.5, 6.5)
+        r1 = np.zeros(len(x) // 2, dtype=np.int64)
+        r2 = np.zeros(len(x) // 2, dtype=np.float64)
+        f[1, 1](r1, r2, x)
+
+        for i in range(len(r1)):
+            self.assertEqual(r1[i], x[i])
+
+        for i in range(len(r2)):
+            self.assertEqual(r2[i], x[i + len(r1)])
+
+    def test_namedunituple(self):
+        @cuda.jit
+        def f(r, x):
+            r[0] = x.x
+            r[1] = x.y
+
+        Point = namedtuple("Point", ("x", "y"))
+        x = Point(1, 2)
+        r = np.zeros(len(x), dtype=np.int64)
+        f[1, 1](r, x)
+
+        self.assertEqual(r[0], x.x)
+        self.assertEqual(r[1], x.y)
+
+    def test_namedtuple(self):
+        @cuda.jit
+        def f(r1, r2, x):
+            r1[0] = x.x
+            r1[1] = x.y
+            r2[0] = x.r
+
+        Point = namedtuple("Point", ("x", "y", "r"))
+        x = Point(1, 2, 2.236)
+        r1 = np.zeros(2, dtype=np.int64)
+        r2 = np.zeros(1, dtype=np.float64)
+        f[1, 1](r1, r2, x)
+
+        self.assertEqual(r1[0], x.x)
+        self.assertEqual(r1[1], x.y)
+        self.assertEqual(r2[0], x.r)
+
+    def test_empty_tuple(self):
+        @cuda.jit
+        def f(r, x):
+            r[0] = len(x)
+
+        x = tuple()
+        r = np.ones(1, dtype=np.int64)
+        f[1, 1](r, x)
+
+        self.assertEqual(r[0], 0)
+
+    def test_tuple_of_empty_tuples(self):
+        @cuda.jit
+        def f(r, x):
+            r[0] = len(x)
+            r[1] = len(x[0])
+
+        x = ((), (), ())
+        r = np.ones(2, dtype=np.int64)
+        f[1, 1](r, x)
+
+        self.assertEqual(r[0], 3)
+        self.assertEqual(r[1], 0)
+
+    def test_tuple_of_tuples(self):
+        @cuda.jit
+        def f(r, x):
+            r[0] = len(x)
+            r[1] = len(x[0])
+            r[2] = len(x[1])
+            r[3] = len(x[2])
+            r[4] = x[1][0]
+            r[5] = x[1][1]
+            r[6] = x[2][0]
+            r[7] = x[2][1]
+            r[8] = x[2][2]
+
+        x = ((), (5, 6), (8, 9, 10))
+        r = np.ones(9, dtype=np.int64)
+        f[1, 1](r, x)
+
+        self.assertEqual(r[0], 3)
+        self.assertEqual(r[1], 0)
+        self.assertEqual(r[2], 2)
+        self.assertEqual(r[3], 3)
+        self.assertEqual(r[4], 5)
+        self.assertEqual(r[5], 6)
+        self.assertEqual(r[6], 8)
+        self.assertEqual(r[7], 9)
+        self.assertEqual(r[8], 10)
+
+    def test_tuple_of_tuples_and_scalars(self):
+        @cuda.jit
+        def f(r, x):
+            r[0] = len(x)
+            r[1] = len(x[0])
+            r[2] = x[0][0]
+            r[3] = x[0][1]
+            r[4] = x[0][2]
+            r[5] = x[1]
+
+        x = ((6, 5, 4), 7)
+        r = np.ones(9, dtype=np.int64)
+        f[1, 1](r, x)
+
+        self.assertEqual(r[0], 2)
+        self.assertEqual(r[1], 3)
+        self.assertEqual(r[2], 6)
+        self.assertEqual(r[3], 5)
+        self.assertEqual(r[4], 4)
+        self.assertEqual(r[5], 7)
+
+    def test_tuple_of_arrays(self):
+        @cuda.jit
+        def f(x):
+            i = cuda.grid(1)
+            if i < len(x[0]):
+                x[0][i] = x[1][i] + x[2][i]
+
+        N = 10
+        x0 = np.zeros(N)
+        x1 = np.ones_like(x0)
+        x2 = x1 * 3
+        x = (x0, x1, x2)
+        f[1, N](x)
+
+        np.testing.assert_equal(x0, x1 + x2)
+
+    def test_tuple_of_array_scalar_tuple(self):
+        @cuda.jit
+        def f(r, x):
+            r[0] = x[0][0]
+            r[1] = x[0][1]
+            r[2] = x[1]
+            r[3] = x[2][0]
+            r[4] = x[2][1]
+
+        z = np.arange(2, dtype=np.int64)
+        x = (2 * z, 10, (4, 3))
+        r = np.zeros(5, dtype=np.int64)
+        f[1, 1](r, x)
+
+        self.assertEqual(r[0], 0)
+        self.assertEqual(r[1], 2)
+        self.assertEqual(r[2], 10)
+        self.assertEqual(r[3], 4)
+        self.assertEqual(r[4], 3)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,63 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
+import numpy as np
+from numba import cuda
+from numba.cuda.testing import CUDATestCase
+import unittest
+from numba.cuda import config
+
+
+def reinterpret_array_type(byte_arr, start, stop, output):
+    # Tested with just one thread
+    val = byte_arr[start:stop].view(np.int32)[0]
+    output[0] = val
+
+
+class TestCudaArrayMethods(CUDATestCase):
+    def setUp(self):
+        self.old_nrt_setting = config.CUDA_ENABLE_NRT
+        config.CUDA_ENABLE_NRT = True
+        super(TestCudaArrayMethods, self).setUp()
+
+    def tearDown(self):
+        config.CUDA_ENABLE_NRT = self.old_nrt_setting
+        super(TestCudaArrayMethods, self).tearDown()
+
+    def test_reinterpret_array_type(self):
+        """
+        Reinterpret byte array as int32 in the GPU.
+        """
+        pyfunc = reinterpret_array_type
+        kernel = cuda.jit(pyfunc)
+
+        byte_arr = np.arange(256, dtype=np.uint8)
+        itemsize = np.dtype(np.int32).itemsize
+        for start in range(0, 256, itemsize):
+            stop = start + itemsize
+            expect = byte_arr[start:stop].view(np.int32)[0]
+
+            output = np.zeros(1, dtype=np.int32)
+            kernel[1, 1](byte_arr, start, stop, output)
+
+            got = output[0]
+            self.assertEqual(expect, got)
+
+    def test_array_copy(self):
+        val = np.array([1, 2, 3])[::-1]
+
+        @cuda.jit
+        def kernel(out):
+            q = val.copy()
+            for i in range(len(out)):
+                out[i] = q[i]
+
+        out = cuda.to_device(np.zeros(len(val), dtype="float64"))
+
+        kernel[1, 1](out)
+        for i, j in zip(out.copy_to_host(), val):
+            self.assertEqual(i, j)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,360 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+import numpy as np
+
+from numba.cuda.tests.support import TestCase, MemoryLeakMixin
+from numba import cuda
+from numba.cuda.testing import skip_on_cudasim
+from numba.cuda.misc.special import literal_unroll
+from numba.cuda import config
+
+
+@skip_on_cudasim("doesn't work in the simulator")
+class TestArrayReductions(MemoryLeakMixin, TestCase):
+    """
+    Test array reduction methods and functions such as .sum(), .max(), etc.
+    """
+
+    def setUp(self):
+        super(TestArrayReductions, self).setUp()
+        np.random.seed(42)
+        self.old_nrt_setting = config.CUDA_ENABLE_NRT
+        self.old_perf_warnings_setting = config.DISABLE_PERFORMANCE_WARNINGS
+        config.CUDA_ENABLE_NRT = True
+        config.DISABLE_PERFORMANCE_WARNINGS = 1
+
+    def tearDown(self):
+        config.CUDA_ENABLE_NRT = self.old_nrt_setting
+        config.DISABLE_PERFORMANCE_WARNINGS = self.old_perf_warnings_setting
+        super(TestArrayReductions, self).tearDown()
+
+    def test_all_basic(self):
+        cases = (
+            np.float64([1.0, 0.0, float("inf"), float("nan")]),
+            np.float64([1.0, -0.0, float("inf"), float("nan")]),
+            np.float64([1.0, 1.5, float("inf"), float("nan")]),
+            np.float64([[1.0, 1.5], [float("inf"), float("nan")]]),
+            np.float64([[1.0, 1.5], [1.5, 1.0]]),
+        )
+
+        @cuda.jit
+        def kernel(out):
+            i = 0
+            for case in literal_unroll(cases):
+                out[i] = np.all(case)
+                i += 1
+
+        expected = np.array([np.all(a) for a in cases], dtype=np.bool_)
+        out = cuda.to_device(np.zeros(len(cases), dtype=np.bool_))
+        kernel[1, 1](out)
+        got = out.copy_to_host()
+        self.assertPreciseEqual(expected, got)
+
+    def test_any_basic(self):
+        cases = (
+            np.float64([0.0, -0.0, 0.0, 0.0]),
+            np.float64([0.0, -0.0, np.nan, 0.0]),
+            np.float64([0.0, -0.0, float("inf"), 0.0]),
+            np.float64([0.0, -0.0, 1.5, 0.0]),
+            np.float64([[0.0, -0.0], [1.5, 0.0]]),
+            np.float64([[0.0, -0.0], [1.5, 0.0]])[::-1],
+        )
+
+        @cuda.jit
+        def kernel(out):
+            i = 0
+            for arr in literal_unroll(cases):
+                out[i] = np.any(arr)
+                i += 1
+
+        expected = np.array([np.any(a) for a in cases], dtype=np.bool_)
+        out = cuda.to_device(np.zeros(len(cases), dtype=np.bool_))
+        kernel[1, 1](out)
+        self.assertPreciseEqual(expected, out.copy_to_host())
+
+    def test_sum_basic(self):
+        arrays = (
+            np.float64([1.0, 2.0, 0.0, -0.0, 1.0, -1.5]),
+            np.float64([-0.0, -1.5]),
+            np.float64([-1.5, 2.5, float("inf")]),
+            np.float64([-1.5, 2.5, -float("inf")]),
+            np.float64([-1.5, 2.5, float("inf"), -float("inf")]),
+            np.float64([np.nan, -1.5, 2.5, np.nan, 3.0]),
+            np.float64(
+                [np.nan, -1.5, 2.5, np.nan, float("inf"), -float("inf"), 3.0]
+            ),
+            np.float64([5.0, np.nan, -1.5, np.nan]),
+            np.float64([np.nan, np.nan]),
+        )
+
+        @cuda.jit
+        def kernel(out):
+            i = 0
+            for arr in literal_unroll(arrays):
+                out[i] = np.sum(arr)
+                i += 1
+
+        expected = np.array([np.sum(a) for a in arrays], dtype=np.float64)
+        out = cuda.to_device(np.zeros(len(arrays), dtype=np.float64))
+        kernel[1, 1](out)
+        self.assertPreciseEqual(expected, out.copy_to_host())
+
+    def test_mean_basic(self):
+        arrays = (
+            np.float64([1.0, 2.0, 0.0, -0.0, 1.0, -1.5]),
+            np.float64([-0.0, -1.5]),
+            np.float64([-1.5, 2.5, float("inf")]),
+            np.float64([-1.5, 2.5, -float("inf")]),
+            np.float64([-1.5, 2.5, float("inf"), -float("inf")]),
+            np.float64([np.nan, -1.5, 2.5, np.nan, 3.0]),
+            np.float64(
+                [np.nan, -1.5, 2.5, np.nan, float("inf"), -float("inf"), 3.0]
+            ),
+            np.float64([5.0, np.nan, -1.5, np.nan]),
+            np.float64([np.nan, np.nan]),
+        )
+
+        @cuda.jit
+        def kernel(out):
+            i = 0
+            for arr in literal_unroll(arrays):
+                out[i] = np.mean(arr)
+                i += 1
+
+        expected = np.array([np.mean(a) for a in arrays], dtype=np.float64)
+        out = cuda.to_device(np.zeros(len(arrays), dtype=np.float64))
+        kernel[1, 1](out)
+        self.assertPreciseEqual(expected, out.copy_to_host())
+
+    def test_var_basic(self):
+        arrays = (
+            np.float64([1.0, 2.0, 0.0, -0.0, 1.0, -1.5]),
+            np.float64([-0.0, -1.5]),
+            np.float64([-1.5, 2.5, float("inf")]),
+            np.float64([-1.5, 2.5, -float("inf")]),
+            np.float64([-1.5, 2.5, float("inf"), -float("inf")]),
+            np.float64([np.nan, -1.5, 2.5, np.nan, 3.0]),
+            np.float64(
+                [np.nan, -1.5, 2.5, np.nan, float("inf"), -float("inf"), 3.0]
+            ),
+            np.float64([5.0, np.nan, -1.5, np.nan]),
+            np.float64([np.nan, np.nan]),
+        )
+
+        @cuda.jit
+        def kernel(out):
+            i = 0
+            for arr in literal_unroll(arrays):
+                out[i] = np.var(arr)
+                i += 1
+
+        expected = np.array([np.var(a) for a in arrays], dtype=np.float64)
+        out = cuda.to_device(np.zeros(len(arrays), dtype=np.float64))
+        kernel[1, 1](out)
+        self.assertPreciseEqual(expected, out.copy_to_host(), prec="double")
+
+    def test_std_basic(self):
+        arrays = (
+            np.float64([1.0, 2.0, 0.0, -0.0, 1.0, -1.5]),
+            np.float64([-0.0, -1.5]),
+            np.float64([-1.5, 2.5, float("inf")]),
+            np.float64([-1.5, 2.5, -float("inf")]),
+            np.float64([-1.5, 2.5, float("inf"), -float("inf")]),
+            np.float64([np.nan, -1.5, 2.5, np.nan, 3.0]),
+            np.float64(
+                [np.nan, -1.5, 2.5, np.nan, float("inf"), -float("inf"), 3.0]
+            ),
+            np.float64([5.0, np.nan, -1.5, np.nan]),
+            np.float64([np.nan, np.nan]),
+        )
+
+        @cuda.jit
+        def kernel(out):
+            i = 0
+            for arr in literal_unroll(arrays):
+                out[i] = np.std(arr)
+                i += 1
+
+        expected = np.array([np.std(a) for a in arrays], dtype=np.float64)
+        out = cuda.to_device(np.zeros(len(arrays), dtype=np.float64))
+        kernel[1, 1](out)
+        self.assertPreciseEqual(expected, out.copy_to_host())
+
+    def test_min_basic(self):
+        arrays = (
+            np.float64([1.0, 2.0, 0.0, -0.0, 1.0, -1.5]),
+            np.float64([-0.0, -1.5]),
+            np.float64([-1.5, 2.5, float("inf")]),
+            np.float64([-1.5, 2.5, -float("inf")]),
+            np.float64([-1.5, 2.5, float("inf"), -float("inf")]),
+            np.float64([np.nan, -1.5, 2.5, np.nan, 3.0]),
+            np.float64(
+                [np.nan, -1.5, 2.5, np.nan, float("inf"), -float("inf"), 3.0]
+            ),
+            np.float64([5.0, np.nan, -1.5, np.nan]),
+            np.float64([np.nan, np.nan]),
+        )
+
+        @cuda.jit
+        def kernel(out):
+            i = 0
+            for arr in literal_unroll(arrays):
+                out[i] = np.min(arr)
+                i += 1
+
+        expected = np.array([np.min(a) for a in arrays], dtype=np.float64)
+        out = cuda.to_device(np.zeros(len(arrays), dtype=np.float64))
+        kernel[1, 1](out)
+        self.assertPreciseEqual(expected, out.copy_to_host())
+
+    def test_max_basic(self):
+        arrays = (
+            np.float64([1.0, 2.0, 0.0, -0.0, 1.0, -1.5]),
+            np.float64([-0.0, -1.5]),
+            np.float64([-1.5, 2.5, float("inf")]),
+            np.float64([-1.5, 2.5, -float("inf")]),
+            np.float64([-1.5, 2.5, float("inf"), -float("inf")]),
+            np.float64([np.nan, -1.5, 2.5, np.nan, 3.0]),
+            np.float64(
+                [np.nan, -1.5, 2.5, np.nan, float("inf"), -float("inf"), 3.0]
+            ),
+            np.float64([5.0, np.nan, -1.5, np.nan]),
+            np.float64([np.nan, np.nan]),
+        )
+
+        @cuda.jit
+        def kernel(out):
+            i = 0
+            for arr in literal_unroll(arrays):
+                out[i] = np.max(arr)
+                i += 1
+
+        expected = np.array([np.max(a) for a in arrays], dtype=np.float64)
+        out = cuda.to_device(np.zeros(len(arrays), dtype=np.float64))
+        kernel[1, 1](out)
+        self.assertPreciseEqual(expected, out.copy_to_host())
+
+    def test_nanmin_basic(self):
+        arrays = (
+            np.float64([1.0, 2.0, 0.0, -0.0, 1.0, -1.5]),
+            np.float64([-0.0, -1.5]),
+            np.float64([-1.5, 2.5, np.nan]),
+            np.float64([-1.5, 2.5, float("inf")]),
+            np.float64([-1.5, 2.5, -float("inf")]),
+            np.float64([-1.5, 2.5, float("inf"), -float("inf")]),
+            np.float64([np.nan, -1.5, 2.5, np.nan, 3.0]),
+            np.float64([5.0, np.nan, -1.5, np.nan]),
+            np.float64([np.nan, np.nan]),
+        )
+
+        @cuda.jit
+        def kernel(out):
+            i = 0
+            for arr in literal_unroll(arrays):
+                out[i] = np.nanmin(arr)
+                i += 1
+
+        expected = np.array([np.nanmin(a) for a in arrays], dtype=np.float64)
+        out = cuda.to_device(np.zeros(len(arrays), dtype=np.float64))
+        kernel[1, 1](out)
+        self.assertPreciseEqual(expected, out.copy_to_host())
+
+    def test_nanmax_basic(self):
+        arrays = (
+            np.float64([1.0, 2.0, 0.0, -0.0, 1.0, -1.5]),
+            np.float64([-0.0, -1.5]),
+            np.float64([-1.5, 2.5, np.nan]),
+            np.float64([-1.5, 2.5, float("inf")]),
+            np.float64([-1.5, 2.5, -float("inf")]),
+            np.float64([-1.5, 2.5, float("inf"), -float("inf")]),
+            np.float64([np.nan, -1.5, 2.5, np.nan, 3.0]),
+            np.float64([5.0, np.nan, -1.5, np.nan]),
+            np.float64([np.nan, np.nan]),
+        )
+
+        @cuda.jit
+        def kernel(out):
+            i = 0
+            for arr in literal_unroll(arrays):
+                out[i] = np.nanmax(arr)
+                i += 1
+
+        expected = np.array([np.nanmax(a) for a in arrays], dtype=np.float64)
+        out = cuda.to_device(np.zeros(len(arrays), dtype=np.float64))
+        kernel[1, 1](out)
+        self.assertPreciseEqual(expected, out.copy_to_host())
+
+    def test_nanmean_basic(self):
+        arrays = (
+            np.float64([1.0, 2.0, 0.0, -0.0, 1.0, -1.5]),
+            np.float64([-0.0, -1.5]),
+            np.float64([-1.5, 2.5, np.nan]),
+            np.float64([np.nan, -1.5, 2.5, np.nan, 3.0]),
+            np.float64(
+                [np.nan, -1.5, 2.5, np.nan, float("inf"), -float("inf"), 3.0]
+            ),
+            np.float64([5.0, np.nan, -1.5, np.nan]),
+            np.float64([np.nan, np.nan]),
+        )
+
+        @cuda.jit
+        def kernel(out):
+            i = 0
+            for arr in literal_unroll(arrays):
+                out[i] = np.nanmean(arr)
+                i += 1
+
+        expected = np.array([np.nanmean(a) for a in arrays], dtype=np.float64)
+        out = cuda.to_device(np.zeros(len(arrays), dtype=np.float64))
+        kernel[1, 1](out)
+        self.assertPreciseEqual(expected, out.copy_to_host())
+
+    def test_nansum_basic(self):
+        arrays = (
+            np.float64([1.0, 2.0, 0.0, -0.0, 1.0, -1.5]),
+            np.float64([-0.0, -1.5]),
+            np.float64([-1.5, 2.5, np.nan]),
+            np.float64([-1.5, 2.5, float("inf")]),
+            np.float64([-1.5, 2.5, -float("inf")]),
+            np.float64([-1.5, 2.5, float("inf"), -float("inf")]),
+            np.float64([np.nan, -1.5, 2.5, np.nan, 3.0]),
+            np.float64([5.0, np.nan, -1.5, np.nan]),
+            np.float64([np.nan, np.nan]),
+        )
+
+        @cuda.jit
+        def kernel(out):
+            i = 0
+            for arr in literal_unroll(arrays):
+                out[i] = np.nansum(arr)
+                i += 1
+
+        expected = np.array([np.nansum(a) for a in arrays], dtype=np.float64)
+        out = cuda.to_device(np.zeros(len(arrays), dtype=np.float64))
+        kernel[1, 1](out)
+        self.assertPreciseEqual(expected, out.copy_to_host())
+
+    def test_nanprod_basic(self):
+        arrays = (
+            np.float64([1.0, 2.0, 0.0, -0.0, 1.0, -1.5]),
+            np.float64([-0.0, -1.5]),
+            np.float64([-1.5, 2.5, np.nan]),
+            np.float64([-1.5, 2.5, float("inf")]),
+            np.float64([-1.5, 2.5, -float("inf")]),
+            np.float64([-1.5, 2.5, float("inf"), -float("inf")]),
+            np.float64([np.nan, -1.5, 2.5, np.nan, 3.0]),
+            np.float64([5.0, np.nan, -1.5, np.nan]),
+            np.float64([np.nan, np.nan]),
+        )
+
+        @cuda.jit
+        def kernel(out):
+            i = 0
+            for arr in literal_unroll(arrays):
+                out[i] = np.nanprod(arr)
+                i += 1
+
+        expected = np.array([np.nanprod(a) for a in arrays], dtype=np.float64)
+        out = cuda.to_device(np.zeros(len(arrays), dtype=np.float64))
+        kernel[1, 1](out)
+        self.assertPreciseEqual(expected, out.copy_to_host())