pyopencl 2024.2.2__cp312-cp312-win_amd64.whl → 2024.2.5__cp312-cp312-win_amd64.whl

pyopencl-2024.2.2.data/data/test/test_arrays_in_structs.py

@@ -1,100 +0,0 @@
-__copyright__ = "Copyright (C) 2020 Sotiris Niarchos"
-
-__license__ = """
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-"""
-
-import numpy as np
-
-import pyopencl as cl
-import pyopencl.cltypes as cltypes
-import pyopencl.tools as cl_tools
-from pyopencl import mem_flags
-from pyopencl.tools import \
-    pytest_generate_tests_for_pyopencl as pytest_generate_tests  # noqa: F401
-
-
-def test_struct_with_array_fields(ctx_factory):
-    #
-    # typedef struct {
-    #     uint x[2];
-    #     float y;
-    #     uint z[3][4];
-    # } my_struct;
-    #
-    cl_ctx = ctx_factory()
-    device = cl_ctx.devices[0]
-    queue = cl.CommandQueue(cl_ctx)
-
-    my_struct = np.dtype([
-        ("x", cltypes.uint, 2),
-        ("y", cltypes.int),
-        ("z", cltypes.uint, (3, 4))
-    ])
-    my_struct, cdecl = cl_tools.match_dtype_to_c_struct(
-        device, "my_struct", my_struct
-    )
-
-    # a random buffer of 4 structs
-    my_struct_arr = np.array([
-        ([81, 24], -57, [[15, 28, 45,  7], [71, 95, 65, 84], [2, 11, 59,  9]]),
-        ([5, 20],  47, [[15, 53,  7, 59], [73, 22, 27, 86], [59,  6, 39, 49]]),
-        ([11, 99], -32, [[73, 83,  4, 65], [19, 21, 22, 27], [1, 55,  6, 64]]),
-        ([57, 38], -54, [[74, 90, 38, 67], [77, 30, 99, 18], [91,  3, 63, 67]])
-    ], dtype=my_struct)
-
-    expected_res = []
-    for x in my_struct_arr:
-        expected_res.append(int(np.sum(x[0]) + x[1] + np.sum(x[2])))
-    expected_res = np.array(expected_res, dtype=cltypes.int)
-
-    kernel_src = """%s
-    // this kernel sums every number contained in each struct
-    __kernel void array_structs(__global my_struct *structs, __global int *res) {
-        int i = get_global_id(0);
-        my_struct s = structs[i];
-        res[i] = s.x[0] + s.x[1] + s.y;
-        for (int r = 0; r < 3; r++)
-            for (int c = 0; c < 4; c++)
-                res[i] += s.z[r][c];
-    }""" % cdecl
-
-    mem_flags1 = mem_flags.READ_ONLY | mem_flags.COPY_HOST_PTR
-    mem_flags2 = mem_flags.WRITE_ONLY
-
-    my_struct_buf = cl.Buffer(cl_ctx, mem_flags1, hostbuf=my_struct_arr)
-    res_buf = cl.Buffer(cl_ctx, mem_flags2, size=expected_res.nbytes)
-
-    program = cl.Program(cl_ctx, kernel_src).build()
-    kernel = program.array_structs
-    kernel(queue, (4,), None, my_struct_buf, res_buf)
-
-    res = np.empty_like(expected_res)
-    cl.enqueue_copy(queue, res, res_buf)
-
-    assert (res == expected_res).all()
-
-
-if __name__ == "__main__":
-    import sys
-    if len(sys.argv) > 1:
-        exec(sys.argv[1])
-    else:
-        from pytest import main
-        main([__file__])

pyopencl-2024.2.2.data/data/test/test_clmath.py

@@ -1,529 +0,0 @@
-__copyright__ = "Copyright (C) 2009 Andreas Kloeckner"
-
-__license__ = """
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-"""
-
-import math
-
-import numpy as np
-import pytest
-
-import pyopencl as cl
-import pyopencl.array as cl_array
-import pyopencl.clmath as clmath
-from pyopencl.characterize import has_double_support, has_struct_arg_count_bug
-from pyopencl.tools import \
-    pytest_generate_tests_for_pyopencl as pytest_generate_tests  # noqa: F401
-
-
-try:
-    import faulthandler
-except ImportError:
-    pass
-else:
-    faulthandler.enable()
-
-
-sizes = [10, 128, 1 << 10, 1 << 11, 1 << 13]
-
-
-numpy_func_names = {
-        "asin": "arcsin",
-        "acos": "arccos",
-        "atan": "arctan",
-        }
-
-
-def make_unary_function_test(name, limits=(0, 1), threshold=0, use_complex=False):
-    (a, b) = limits
-    a = float(a)
-    b = float(b)
-
-    def test(ctx_factory):
-        context = ctx_factory()
-        queue = cl.CommandQueue(context)
-
-        gpu_func = getattr(clmath, name)
-        cpu_func = getattr(np, numpy_func_names.get(name, name))
-
-        dev = context.devices[0]
-
-        if has_double_support(dev):
-            if use_complex and has_struct_arg_count_bug(dev) == "apple":
-                dtypes = [np.float32, np.float64, np.complex64]
-            elif use_complex:
-                dtypes = [np.float32, np.float64, np.complex64, np.complex128]
-            else:
-                dtypes = [np.float32, np.float64]
-        else:
-            if use_complex:
-                dtypes = [np.float32, np.complex64]
-            else:
-                dtypes = [np.float32]
-
-        for s in sizes:
-            for dtype in dtypes:
-                dtype = np.dtype(dtype)
-
-                args = cl_array.arange(queue, a, b, (b-a)/s, dtype=dtype)
-                if dtype.kind == "c":
-                    # args = args + dtype.type(1j) * args
-                    args = args + args * dtype.type(1j)
-
-                gpu_results = gpu_func(args).get()
-                cpu_results = cpu_func(args.get())
-
-                my_threshold = threshold
-                if dtype.kind == "c" and isinstance(use_complex, float):
-                    my_threshold = use_complex
-
-                max_err = np.max(np.abs(cpu_results - gpu_results))
-                assert (max_err <= my_threshold).all(), \
-                        (max_err, name, dtype)
-
-    return test
-
-
-test_ceil = make_unary_function_test("ceil", (-10, 10))
-test_floor = make_unary_function_test("ceil", (-10, 10))
-test_fabs = make_unary_function_test("fabs", (-10, 10))
-test_exp = make_unary_function_test("exp", (-3, 3), 1e-5, use_complex=True)
-test_log = make_unary_function_test("log", (1e-5, 1), 1e-6, use_complex=True)
-test_log10 = make_unary_function_test("log10", (1e-5, 1), 5e-7)
-test_sqrt = make_unary_function_test("sqrt", (1e-5, 1), 3e-7, use_complex=True)
-
-test_sin = make_unary_function_test("sin", (-10, 10), 2e-7, use_complex=2e-2)
-test_cos = make_unary_function_test("cos", (-10, 10), 2e-7, use_complex=2e-2)
-test_asin = make_unary_function_test("asin", (-0.9, 0.9), 5e-7)
-test_acos = make_unary_function_test("acos", (-0.9, 0.9), 5e-7)
-test_tan = make_unary_function_test("tan",
-        (-math.pi/2 + 0.1, math.pi/2 - 0.1), 4e-5, use_complex=True)
-test_atan = make_unary_function_test("atan", (-10, 10), 2e-7)
-
-test_sinh = make_unary_function_test("sinh", (-3, 3), 3e-6, use_complex=2e-3)
-test_cosh = make_unary_function_test("cosh", (-3, 3), 3e-6, use_complex=2e-3)
-test_tanh = make_unary_function_test("tanh", (-3, 3), 2e-6, use_complex=True)
-
-
-def test_atan2(ctx_factory):
-    context = ctx_factory()
-    queue = cl.CommandQueue(context)
-
-    for s in sizes:
-        a = (cl_array.arange(queue, s, dtype=np.float32) - np.float32(s / 2)) / 100
-        a2 = (s / 2 - 1 - cl_array.arange(queue, s, dtype=np.float32)) / 100
-        b = clmath.atan2(a, a2)
-
-        a = a.get()
-        a2 = a2.get()
-        b = b.get()
-
-        for i in range(s):
-            assert abs(math.atan2(a[i], a2[i]) - b[i]) < 1e-6
-
-
-def test_atan2pi(ctx_factory):
-    context = ctx_factory()
-    queue = cl.CommandQueue(context)
-
-    for s in sizes:
-        a = (cl_array.arange(queue, s, dtype=np.float32) - np.float32(s / 2)) / 100
-        a2 = (s / 2 - 1 - cl_array.arange(queue, s, dtype=np.float32)) / 100
-        b = clmath.atan2pi(a, a2)
-
-        a = a.get()
-        a2 = a2.get()
-        b = b.get()
-
-        for i in range(s):
-            assert abs(math.atan2(a[i], a2[i]) / math.pi - b[i]) < 1e-6
-
-
-def test_fmod(ctx_factory):
-    context = ctx_factory()
-    queue = cl.CommandQueue(context)
-
-    for s in sizes:
-        a = cl_array.arange(queue, s, dtype=np.float32)/10
-        a2 = cl_array.arange(queue, s, dtype=np.float32)/45.2 + 0.1
-        b = clmath.fmod(a, a2)
-
-        # https://salsa.debian.org/opencl-team/python-pyopencl/-/merge_requests/3#note_383761
-        assert np.max(np.abs((np.fmod(a.get(), a2.get()) - b.get()))) < 1e-4
-
-
-def test_ldexp(ctx_factory):
-    context = ctx_factory()
-    queue = cl.CommandQueue(context)
-
-    for s in sizes:
-        a = cl_array.arange(queue, s, dtype=np.float32)
-        a2 = cl_array.arange(queue, s, dtype=np.float32)*1e-3
-        b = clmath.ldexp(a, a2)
-
-        a = a.get()
-        a2 = a2.get()
-        b = b.get()
-
-        for i in range(s):
-            assert math.ldexp(a[i], int(a2[i])) == b[i]
-
-
-def test_modf(ctx_factory):
-    context = ctx_factory()
-    queue = cl.CommandQueue(context)
-
-    for s in sizes:
-        a = cl_array.arange(queue, s, dtype=np.float32)/10
-        fracpart, intpart = clmath.modf(a)
-
-        a = a.get()
-        intpart = intpart.get()
-        fracpart = fracpart.get()
-
-        for i in range(s):
-            fracpart_true, intpart_true = math.modf(a[i])
-
-            assert intpart_true == intpart[i]
-            assert abs(fracpart_true - fracpart[i]) < 1e-4
-
-
-def test_frexp(ctx_factory):
-    context = ctx_factory()
-    queue = cl.CommandQueue(context)
-
-    for s in sizes:
-        a = cl_array.arange(queue, s, dtype=np.float32)/10
-        significands, exponents = clmath.frexp(a)
-
-        a = a.get()
-        significands = significands.get()
-        exponents = exponents.get()
-
-        for i in range(s):
-            sig_true, ex_true = math.frexp(a[i])
-
-            assert sig_true == significands[i]
-            assert ex_true == exponents[i]
-
-
-def test_bessel(ctx_factory):
-    try:
-        import scipy.special as spec
-    except ImportError:
-        from pytest import skip
-        skip("scipy not present--cannot test Bessel function")
-
-    ctx = ctx_factory()
-    queue = cl.CommandQueue(ctx)
-
-    if not has_double_support(ctx.devices[0]):
-        from pytest import skip
-        skip("no double precision support--cannot test bessel function")
-
-    nterms = 30
-
-    try:
-        from pyfmmlib import hank103_vec, jfuns2d
-    except ImportError:
-        use_pyfmmlib = False
-    else:
-        use_pyfmmlib = True
-
-    print("PYFMMLIB", use_pyfmmlib)
-
-    if use_pyfmmlib:
-        a = np.logspace(-3, 3, 10**6)
-    else:
-        a = np.logspace(-5, 5, 10**6)
-
-    for which_func, cl_func, scipy_func, is_rel in [
-            ("j", clmath.bessel_jn, spec.jn, False),
-            ("y", clmath.bessel_yn, spec.yn, True)
-            ]:
-        if is_rel:
-            def get_err(check, ref):
-                return np.max(np.abs(check-ref)) / np.max(np.abs(ref))
-        else:
-            def get_err(check, ref):
-                return np.max(np.abs(check-ref))
-
-        if use_pyfmmlib:
-            pfymm_result = np.empty((len(a), nterms), dtype=np.complex128)
-            if which_func == "j":
-                for i, a_i in enumerate(a):
-                    if i % 100000 == 0:
-                        print("%.1f %%" % (100 * i/len(a)))
-                    ier, fjs, _, _ = jfuns2d(nterms, a_i, 1, 0, 10000)
-                    pfymm_result[i] = fjs[:nterms]
-                assert ier == 0
-            elif which_func == "y":
-                h0, h1 = hank103_vec(a, ifexpon=1)
-                pfymm_result[:, 0] = h0.imag
-                pfymm_result[:, 1] = h1.imag
-
-        a_dev = cl_array.to_device(queue, a)
-
-        for n in range(0, nterms):
-            cl_bessel = cl_func(n, a_dev).get()
-            scipy_bessel = scipy_func(n, a)
-
-            error_scipy = get_err(cl_bessel, scipy_bessel)
-            assert error_scipy < 1e-10, error_scipy
-
-            if use_pyfmmlib and (
-                    which_func == "j"
-                    or (which_func == "y" and n in [0, 1])):
-                pyfmm_bessel = pfymm_result[:, n]
-                error_pyfmm = get_err(cl_bessel, pyfmm_bessel)
-                assert error_pyfmm < 1e-10, error_pyfmm
-                error_pyfmm_scipy = get_err(scipy_bessel, pyfmm_bessel)
-                print(which_func, n, error_scipy, error_pyfmm, error_pyfmm_scipy)
-            else:
-                print(which_func, n, error_scipy)
-
-            assert not np.isnan(cl_bessel).any()
-
-            if 0 and n == 15:
-                import matplotlib.pyplot as pt
-
-                #pt.plot(scipy_bessel)
-                #pt.plot(cl_bessel)
-
-                pt.loglog(a, np.abs(cl_bessel-scipy_bessel), label="vs scipy")
-                if use_pyfmmlib:
-                    pt.loglog(a, np.abs(cl_bessel-pyfmm_bessel), label="vs pyfmmlib")
-                pt.legend()
-                pt.show()
-
-
-@pytest.mark.parametrize("ref_src", ["pyfmmlib", "scipy"])
-def test_complex_bessel(ctx_factory, ref_src):
-    ctx = ctx_factory()
-    queue = cl.CommandQueue(ctx)
-
-    if not has_double_support(ctx.devices[0]):
-        from pytest import skip
-        skip("no double precision support--cannot test complex bessel function")
-
-    v = 40
-    n = 10**5
-
-    rng = np.random.default_rng(seed=13)
-    z = (
-        np.logspace(-5, 2, n)
-        * np.exp(1j * 2 * np.pi * rng.random(n)))
-
-    if ref_src == "pyfmmlib":
-        pyfmmlib = pytest.importorskip("pyfmmlib")
-
-        jv_ref = np.zeros(len(z), "complex")
-
-        vin = v+1
-
-        for i in range(len(z)):
-            ier, fjs, _, _ = pyfmmlib.jfuns2d(vin, z[i], 1, 0, 10000)
-            assert ier == 0
-            jv_ref[i] = fjs[v]
-
-    elif ref_src == "scipy":
-        spec = pytest.importorskip("scipy.special")
-        jv_ref = spec.jv(v, z)
-
-    else:
-        raise ValueError("ref_src")
-
-    z_dev = cl_array.to_device(queue, z)
-
-    jv_dev = clmath.bessel_jn(v, z_dev)
-
-    abs_err_jv = np.abs(jv_dev.get() - jv_ref)
-    abs_jv_ref = np.abs(jv_ref)
-    rel_err_jv = abs_err_jv/abs_jv_ref
-
-    # use absolute error instead if the function value itself is too small
-    tiny = 1e-300
-    ind = abs_jv_ref < tiny
-    rel_err_jv[ind] = abs_err_jv[ind]
-
-    # if the reference value is inf or nan, set the error to zero
-    ind1 = np.isinf(abs_jv_ref)
-    ind2 = np.isnan(abs_jv_ref)
-
-    rel_err_jv[ind1] = 0
-    rel_err_jv[ind2] = 0
-
-    if 0:
-        print(abs(z))
-        print(np.abs(jv_ref))
-        print(np.abs(jv_dev.get()))
-        print(rel_err_jv)
-
-    max_err = np.max(rel_err_jv)
-    assert max_err <= 2e-13, max_err
-
-    print("Jv", np.max(rel_err_jv))
-
-    if 0:
-        import matplotlib.pyplot as pt
-        pt.loglog(np.abs(z), rel_err_jv)
-        pt.show()
-
-
-@pytest.mark.parametrize("ref_src", ["pyfmmlib", "scipy"])
-def test_hankel_01_complex(ctx_factory, ref_src):
-    ctx = ctx_factory()
-    queue = cl.CommandQueue(ctx)
-
-    if not has_double_support(ctx.devices[0]):
-        from pytest import skip
-        skip("no double precision support--cannot test complex bessel function")
-
-    rng = np.random.default_rng(seed=11)
-    n = 10**6
-    z = (
-        np.logspace(-5, 2, n)
-        * np.exp(1j * 2 * np.pi * rng.random(n)))
-
-    def get_err(check, ref):
-        return np.max(np.abs(check-ref)) / np.max(np.abs(ref))
-
-    if ref_src == "pyfmmlib":
-        pyfmmlib = pytest.importorskip("pyfmmlib")
-        h0_ref, h1_ref = pyfmmlib.hank103_vec(z, ifexpon=1)
-    elif ref_src == "scipy":
-        spec = pytest.importorskip("scipy.special")
-        h0_ref = spec.hankel1(0, z)
-        h1_ref = spec.hankel1(1, z)
-
-    else:
-        raise ValueError("ref_src")
-
-    z_dev = cl_array.to_device(queue, z)
-
-    h0_dev, h1_dev = clmath.hankel_01(z_dev)
-
-    rel_err_h0 = np.abs(h0_dev.get() - h0_ref)/np.abs(h0_ref)
-    rel_err_h1 = np.abs(h1_dev.get() - h1_ref)/np.abs(h1_ref)
-
-    max_rel_err_h0 = np.max(rel_err_h0)
-    max_rel_err_h1 = np.max(rel_err_h1)
-
-    print("H0", max_rel_err_h0)
-    print("H1", max_rel_err_h1)
-
-    assert max_rel_err_h0 < 4e-13
-    assert max_rel_err_h1 < 2e-13
-
-    if 0:
-        import matplotlib.pyplot as pt
-        pt.loglog(np.abs(z), rel_err_h0)
-        pt.loglog(np.abs(z), rel_err_h1)
-        pt.show()
-
-
-@pytest.mark.parametrize("dtype", [np.complex64, np.complex128])
-def test_complex_muladd(ctx_factory, dtype):
-    ctx = ctx_factory()
-    queue = cl.CommandQueue(ctx)
-
-    if dtype == np.complex128 and not has_double_support(ctx.devices[0]):
-        from pytest import skip
-        skip("no double precision support")
-
-    if dtype == np.complex64:
-        real_type = np.float32
-        real_type_name = "float"
-    else:
-        real_type = np.float64
-        real_type_name = "double"
-
-    rng = np.random.default_rng(seed=11)
-    n = 100
-
-    arrs = [rng.random(n, dtype=real_type) + 1j*rng.random(n, dtype=real_type)
-            for i in range(3)]
-    arrs = [arr.astype(dtype) for arr in arrs]
-
-    arrs_dev = [cl_array.to_device(queue, arr) for arr in arrs]
-
-    prg_str = """
-    #if __OPENCL_C_VERSION__ < 120
-    #pragma OPENCL EXTENSION cl_khr_fp64: enable
-    #endif
-    #define PYOPENCL_DEFINE_CDOUBLE
-
-    #include <pyopencl-complex.h>
-
-    __kernel void foo(
-        __global const c{real_type_name}_t *a,
-        __global const c{real_type_name}_t *b,
-        __global const c{real_type_name}_t *c,
-        __global c{real_type_name}_t *res
-        )
-    {{
-        int gid = get_global_id(0);
-        res[gid] = c{real_type_name}_fma(a[gid], b[gid], c[gid]);
-    }}
-    """.format(real_type_name=real_type_name)
-
-    prg = cl.Program(ctx, prg_str).build()
-    knl = prg.foo
-
-    result_dev = cl_array.empty_like(arrs_dev[0])
-    knl(queue, (n,), None, arrs_dev[0].data,
-            arrs_dev[1].data, arrs_dev[2].data, result_dev.data)
-
-    ref = arrs[0] * arrs[1] + arrs[2]
-
-    rel_err = np.abs(result_dev.get() - ref)/np.abs(ref)
-
-    if dtype == np.complex64:
-        assert np.max(rel_err) < 1e-6
-    else:
-        assert np.max(rel_err) < 1e-12
-
-
-def test_outoforderqueue_clmath(ctx_factory):
-    context = ctx_factory()
-    try:
-        queue = cl.CommandQueue(context,
-               properties=cl.command_queue_properties.OUT_OF_ORDER_EXEC_MODE_ENABLE)
-    except Exception:
-        pytest.skip("out-of-order queue not available")
-
-    rng = np.random.default_rng(seed=42)
-    a = rng.random(10**6, dtype=np.float32)
-    a_gpu = cl_array.to_device(queue, a)
-    # testing that clmath functions wait for and create events
-    b_gpu = clmath.fabs(clmath.sin(a_gpu * 5))
-    queue.finish()
-    b1 = b_gpu.get()
-    b = np.abs(np.sin(a * 5))
-    assert np.abs(b1 - b).mean() < 1e-5
-
-
-if __name__ == "__main__":
-    import sys
-    if len(sys.argv) > 1:
-        exec(sys.argv[1])
-    else:
-        from pytest import main
-        main([__file__])

pyopencl-2024.2.2.data/data/test/test_clrandom.py

@@ -1,75 +0,0 @@
-__copyright__ = "Copyright (C) 2018 Matt Wala"
-
-__license__ = """
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-"""
-
-import numpy as np
-import pytest
-
-import pyopencl as cl
-import pyopencl.clrandom as clrandom
-import pyopencl.cltypes as cltypes
-from pyopencl.characterize import has_double_support
-from pyopencl.tools import \
-    pytest_generate_tests_for_pyopencl as pytest_generate_tests  # noqa: F401
-
-
-try:
-    import faulthandler
-except ImportError:
-    pass
-else:
-    faulthandler.enable()
-
-
-@pytest.mark.parametrize("rng_class", [
-    clrandom.PhiloxGenerator,
-    clrandom.ThreefryGenerator])
-@pytest.mark.parametrize("dtype", [
-    np.int32,
-    np.int64,
-    np.float32,
-    np.float64,
-    cltypes.float2,         # type: ignore[attr-defined]
-    cltypes.float3,         # type: ignore[attr-defined]
-    cltypes.float4,         # type: ignore[attr-defined]
-    ])
-def test_clrandom_dtypes(ctx_factory, rng_class, dtype):
-    cl_ctx = ctx_factory()
-    if dtype == np.float64 and not has_double_support(cl_ctx.devices[0]):
-        pytest.skip("double precision not supported on this device")
-    rng = rng_class(cl_ctx)
-
-    size = 10
-
-    with cl.CommandQueue(cl_ctx) as queue:
-        rng.uniform(queue, size, dtype)
-
-        if dtype not in (np.int32, np.int64):
-            rng.normal(queue, size, dtype)
-
-
-if __name__ == "__main__":
-    import sys
-    if len(sys.argv) > 1:
-        exec(sys.argv[1])
-    else:
-        from pytest import main
-        main([__file__])