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

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

@@ -0,0 +1,37 @@
+# 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 import float32, int32, void
+from numba.cuda.testing import unittest, CUDATestCase
+
+
+class TestCudaPy2Div(CUDATestCase):
+    def test_py2_div_issue(self):
+        @cuda.jit(void(float32[:], float32[:], float32[:], int32))
+        def preCalc(y, yA, yB, numDataPoints):
+            i = cuda.grid(1)
+            # k is unused, but may be part of the trigger for the bug this
+            # tests for.
+            k = i % numDataPoints  # noqa: F841
+
+            ans = float32(1.001 * float32(i))
+
+            y[i] = ans
+            yA[i] = ans * 1.0
+            yB[i] = ans / 1.0
+
+        numDataPoints = 15
+
+        y = np.zeros(numDataPoints, dtype=np.float32)
+        yA = np.zeros(numDataPoints, dtype=np.float32)
+        yB = np.zeros(numDataPoints, dtype=np.float32)
+        preCalc[1, 15](y, yA, yB, numDataPoints)
+
+        self.assertTrue(np.all(y == yA))
+        self.assertTrue(np.all(y == yB))
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,117 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
+import math
+
+import numpy as np
+
+from numba import cuda
+from numba.cuda.testing import unittest
+from numba.cuda.testing import (
+    skip_on_cudasim,
+    CUDATestCase,
+    skip_on_standalone_numba_cuda,
+)
+
+from numba.cuda.random import (
+    xoroshiro128p_uniform_float32,
+    xoroshiro128p_normal_float32,
+    xoroshiro128p_uniform_float64,
+    xoroshiro128p_normal_float64,
+)
+
+
+# Distributions
+UNIFORM = 1
+NORMAL = 2
+
+
+@cuda.jit
+def rng_kernel_float32(states, out, count, distribution):
+    thread_id = cuda.grid(1)
+
+    for i in range(count):
+        idx = thread_id * count + i
+
+        if distribution == UNIFORM:
+            out[idx] = xoroshiro128p_uniform_float32(states, thread_id)
+        elif distribution == NORMAL:
+            out[idx] = xoroshiro128p_normal_float32(states, thread_id)
+
+
+@cuda.jit
+def rng_kernel_float64(states, out, count, distribution):
+    thread_id = cuda.grid(1)
+
+    for i in range(count):
+        idx = thread_id * count + i
+
+        if distribution == UNIFORM:
+            out[idx] = xoroshiro128p_uniform_float64(states, thread_id)
+        elif distribution == NORMAL:
+            out[idx] = xoroshiro128p_normal_float64(states, thread_id)
+
+
+@skip_on_standalone_numba_cuda
+class TestCudaRandomXoroshiro128p(CUDATestCase):
+    def test_create(self):
+        states = cuda.random.create_xoroshiro128p_states(10, seed=1)
+        s = states.copy_to_host()
+        self.assertEqual(len(np.unique(s)), 10)
+
+    def test_create_subsequence_start(self):
+        states = cuda.random.create_xoroshiro128p_states(10, seed=1)
+        s1 = states.copy_to_host()
+
+        states = cuda.random.create_xoroshiro128p_states(
+            10, seed=1, subsequence_start=3
+        )
+        s2 = states.copy_to_host()
+
+        # Starting seeds should match up with offset of 3
+        np.testing.assert_array_equal(s1[3:], s2[:-3])
+
+    def test_create_stream(self):
+        stream = cuda.stream()
+        states = cuda.random.create_xoroshiro128p_states(
+            10, seed=1, stream=stream
+        )
+        s = states.copy_to_host()
+        self.assertEqual(len(np.unique(s)), 10)
+
+    def check_uniform(self, kernel_func, dtype):
+        states = cuda.random.create_xoroshiro128p_states(32 * 2, seed=1)
+        out = np.zeros(2 * 32 * 32, dtype=np.float32)
+
+        kernel_func[2, 32](states, out, 32, UNIFORM)
+        self.assertAlmostEqual(out.min(), 0.0, delta=1e-3)
+        self.assertAlmostEqual(out.max(), 1.0, delta=1e-3)
+        self.assertAlmostEqual(out.mean(), 0.5, delta=1.5e-2)
+        self.assertAlmostEqual(out.std(), 1.0 / (2 * math.sqrt(3)), delta=6e-3)
+
+    def test_uniform_float32(self):
+        self.check_uniform(rng_kernel_float32, np.float32)
+
+    @skip_on_cudasim("skip test for speed under cudasim")
+    def test_uniform_float64(self):
+        self.check_uniform(rng_kernel_float64, np.float64)
+
+    def check_normal(self, kernel_func, dtype):
+        states = cuda.random.create_xoroshiro128p_states(32 * 2, seed=1)
+        out = np.zeros(2 * 32 * 32, dtype=dtype)
+
+        kernel_func[2, 32](states, out, 32, NORMAL)
+
+        self.assertAlmostEqual(out.mean(), 0.0, delta=4e-3)
+        self.assertAlmostEqual(out.std(), 1.0, delta=2e-3)
+
+    def test_normal_float32(self):
+        self.check_normal(rng_kernel_float32, np.float32)
+
+    @skip_on_cudasim("skip test for speed under cudasim")
+    def test_normal_float64(self):
+        self.check_normal(rng_kernel_float64, np.float64)
+
+
+if __name__ == "__main__":
+    unittest.main()