pyopencl 2024.2.7__cp39-cp39-macosx_11_0_arm64.whl → 2024.3__cp39-cp39-macosx_11_0_arm64.whl

pyopencl/compyte/ndarray/test_gpu_ndarray.py

@@ -1,487 +0,0 @@
-import copy
-
-import numpy
-import pygpu_ndarray as gpu_ndarray
-
-enable_double = True
-enable_double = False
-
-dtypes_all = ["float32",
-              "int8", "int16", "int32", "int64",
-              "uint8", "uint16", "uint32", "uint64",
-              "complex64",
-              ]
-
-dtypes_no_complex = ["float32",
-                     "int8", "int16", "int32", "int64",
-                     "uint8", "uint16", "uint32", "uint64",
-                     ]
-if enable_double:
-    dtypes_all += ["float64", "complex128"]
-    dtypes_no_complex += ["float64"]
-
-
-def check_flags(x, y):
-    assert x.flags["C_CONTIGUOUS"] == y.flags["C_CONTIGUOUS"]
-    assert x.flags["F_CONTIGUOUS"] == y.flags["F_CONTIGUOUS"]
-    assert x.flags["WRITEABLE"] == y.flags["WRITEABLE"]
-    assert x.flags["OWNDATA"] == y.flags["OWNDATA"]
-    assert x.flags["ALIGNED"] == y.flags["ALIGNED"]
-    assert x.flags["UPDATEIFCOPY"] == y.flags["UPDATEIFCOPY"]
-
-
-def check_meta(x, y):
-    assert x.shape == y.shape
-    assert x.dtype == y.dtype
-    assert x.strides == y.strides
-    check_flags(x, y)
-
-
-def check_all(x, y):
-    check_meta(x, y)
-    assert numpy.allclose(numpy.asarray(x), numpy.asarray(y))
-
-
-def gen_gpu_nd_array(shape_orig, dtype='float32', offseted_outer=False,
-                     offseted_inner=False, sliced=1, order='c'):
-    if sliced is True:
-        sliced = 2
-    elif sliced is False:
-        sliced = 1
-    shape = numpy.asarray(shape_orig).copy()
-    if sliced != 1 and len(shape) > 0:
-        shape[0] *= numpy.absolute(sliced)
-    if offseted_outer and len(shape) > 0:
-        shape[0] += 1
-    if offseted_inner and len(shape) > 0:
-        shape[-1] += 1
-
-    a = numpy.random.rand(*shape) * 10
-    if dtype.startswith("u"):
-        a = numpy.absolute(a)
-    a = numpy.asarray(a, dtype=dtype)
-    assert order in ['c', 'f']
-    if order == 'f' and len(shape) > 0:
-        a = numpy.asfortranarray(a)
-    b = gpu_ndarray.GpuNdArrayObject(a)
-    if order == 'f' and len(shape) > 0 and b.size > 1:
-        assert b.flags['F_CONTIGUOUS']
-
-    if offseted_outer and len(shape) > 0:
-        b = b[1:]
-        a = a[1:]
-        assert b.offset != 0
-    if offseted_inner and len(shape) > 0:
-        # The b[..., 1:] act as the test for this subtensor case.
-        b = b[..., 1:]
-        a = a[..., 1:]
-        assert b.offset != 0
-    if sliced != 1 and len(shape) > 0:
-        a = a[::sliced]
-        b = b[::sliced]
-
-    if False and shape_orig == ():
-        assert a.shape == (1,)
-        assert b.shape == (1,)
-    else:
-        assert a.shape == shape_orig, (a.shape, shape_orig)
-        assert b.shape == shape_orig, (b.shape, shape_orig)
-
-    assert numpy.allclose(a, numpy.asarray(b))
-
-    return a, b
-
-
-def product(*args, **kwds):
-    # product('ABCD', 'xy') --> Ax Ay Bx By Cx Cy Dx Dy
-    # product(range(2), repeat=3) --> 000 001 010 011 100 101 110 111
-    pools = list(map(tuple, args)) * kwds.get('repeat', 1)
-    result = [[]]
-    for pool in pools:
-        result = [x + [y] for x in result for y in pool]
-    for prod in result:
-        yield tuple(prod)
-
-
-def test_transfer():
-    for shp in [(), (5,), (6, 7), (4, 8, 9), (1, 8, 9)]:
-        for dtype in dtypes_all:
-            for offseted in [True, False]:
-                a, b = gen_gpu_nd_array(shp, dtype, offseted)
-                c = numpy.asarray(b)
-
-                assert numpy.allclose(c, a)
-                assert a.shape == b.shape == c.shape
-                assert a.strides == b.strides == c.strides
-                assert a.dtype == b.dtype == c.dtype == dtype
-                assert c.flags.c_contiguous
-
-
-def test_transfer_not_contiguous():
-    """
-    Test transfer when the input on the CPU is not contiguous
-    TODO: test when the input on the gpu is not contiguous
-    """
-    for shp in [(5,), (6, 7), (4, 8, 9), (1, 8, 9)]:
-        for dtype in dtypes_all:
-            a = numpy.random.rand(*shp) * 10
-            a = a[::-1]
-            b = gpu_ndarray.GpuNdArrayObject(a)
-            c = numpy.asarray(b)
-
-            assert numpy.allclose(c, a)
-            assert a.shape == b.shape == c.shape
-            # We copy a to a c contiguous array before the transfer
-            assert (-a.strides[0],) + a.strides[1:] == b.strides == c.strides
-            assert a.dtype == b.dtype == c.dtype
-            assert c.flags.c_contiguous
-
-
-def test_transfer_fortran():
-    for shp in [(5,), (6, 7), (4, 8, 9), (1, 8, 9)]:
-        for dtype in dtypes_all:
-            a = numpy.random.rand(*shp) * 10
-            a_ = numpy.asfortranarray(a)
-            if len(shp) > 1:
-                assert a_.strides != a.strides
-            a = a_
-            b = gpu_ndarray.GpuNdArrayObject(a)
-            c = numpy.asarray(b)
-
-            assert a.shape == b.shape == c.shape
-            assert a.dtype == b.dtype == c.dtype
-            assert a.flags.f_contiguous
-            assert c.flags.f_contiguous
-            assert a.strides == b.strides == c.strides
-            assert numpy.allclose(c, a)
-
-
-def test_ascontiguousarray():
-    for shp in [(), (5,), (6, 7), (4, 8, 9), (1, 8, 9)]:
-        for dtype in dtypes_all:
-            for offseted_o in [True, False]:
-                for offseted_i in [True, True]:
-                    for sliced in [1, 2, -1, -2]:
-                        for order in ['f', 'c']:
-                            #print shp, dtype, offseted_o, offseted_i,
-                            #print sliced, order
-                            cpu, gpu = gen_gpu_nd_array(shp, dtype, offseted_o,
-                                                        offseted_i,
-                                                        sliced, order)
-
-                            a = numpy.ascontiguousarray(cpu)
-                            b = gpu_ndarray.ascontiguousarray(gpu)
-
-                            # numpy upcast with a view to 1d scalar.
-                            if (sliced != 1 or shp == () or
-                                (offseted_i and len(shp) > 1)):
-                                assert b is not gpu
-                                if sliced == 1 and not offseted_i:
-                                    assert ((a.data is cpu.data) ==
-                                            (b.bytes is gpu.bytes))
-                            else:
-                                assert b is gpu
-
-                            assert a.shape == b.shape
-                            assert a.dtype == b.dtype
-                            assert a.flags.c_contiguous
-                            assert b.flags['C_CONTIGUOUS']
-                            assert a.strides == b.strides
-                            assert numpy.allclose(cpu, a)
-                            assert numpy.allclose(cpu, b)
-
-
-def test_asfortranarray():
-    for shp in [(), (5,), (6, 7), (4, 8, 9), (1, 8, 9)]:
-        for dtype in dtypes_all:
-            for offseted_outer in [True, False]:
-                for offseted_inner in [True, False]:
-                    for sliced in [1, 2, -1, -2]:
-                        for order in ['f', 'c']:
-#print shp, dtype, offseted_outer, offseted_inner, sliced, order
-                            cpu, gpu = gen_gpu_nd_array(shp, dtype,
-                                                        offseted_outer,
-                                                        offseted_inner,
-                                                        sliced,
-                                                        order)
-
-                            a = numpy.asfortranarray(cpu)
-                            b = gpu_ndarray.asfortranarray(gpu)
-
-                            # numpy upcast with a view to 1d scalar.
-                            if (sliced != 1 or shp == () or
-                                (offseted_outer and len(shp) > 1) or
-                                (order != 'f' and len(shp) > 1)):
-                                assert b is not gpu
-                                if (sliced == 1 and not offseted_outer and
-                                    order != 'c'):
-                                    assert ((a.data is cpu.data) ==
-                                            (b.bytes is gpu.bytes))
-                            else:
-                                assert b is gpu
-                                pass
-
-                            assert a.shape == b.shape
-                            assert a.dtype == b.dtype
-                            assert a.flags.f_contiguous
-                            if shp != ():
-                                assert b.flags['F_CONTIGUOUS']
-                            assert a.strides == b.strides
-                            assert numpy.allclose(cpu, a)
-                            assert numpy.allclose(cpu, b)
-
-
-def test_zeros():
-    for shp in [(), (0,), (5,),
-                (0, 0), (1, 0), (0, 1), (6, 7),
-                (0, 0, 0), (1, 0, 0), (0, 1, 0), (0, 0, 1),
-                (4, 8, 9), (1, 8, 9)]:
-        for order in ["C", "F"]:
-            for dtype in dtypes_all:
-                x = numpy.zeros(shp, dtype, order)
-                y = gpu_ndarray.zeros(shp, dtype, order)
-                check_all(x, y)
-    x = gpu_ndarray.zeros(())  # no dtype and order param
-    y = numpy.zeros(())
-    check_meta(x, y)
-
-    try:
-        gpu_ndarray.zeros()
-        assert False
-    except TypeError:
-        pass
-
-
-def test_empty():
-    for shp in [(), (0,), (5,),
-                (0, 0), (1, 0), (0, 1), (6, 7),
-                (0, 0, 0), (1, 0, 0), (0, 1, 0), (0, 0, 1),
-                (4, 8, 9), (1, 8, 9)]:
-        for order in ["C", "F"]:
-            for dtype in dtypes_all:
-                x = numpy.empty(shp, dtype, order)
-                y = gpu_ndarray.empty(shp, dtype, order)
-                check_meta(x, y)
-    x = gpu_ndarray.empty(())  # no dtype and order param
-    y = numpy.empty(())
-    check_meta(x, y)
-    try:
-        gpu_ndarray.empty()
-        assert False
-    except TypeError:
-        pass
-
-
-def test_mapping_getitem_ellipsis():
-    for shp in [(5,), (6, 7), (4, 8, 9), (1, 8, 9)]:
-        for dtype in dtypes_all:
-            for offseted in [True, False]:
-                a, a_gpu = gen_gpu_nd_array(shp, dtype, offseted)
-
-                b = a_gpu[...]
-                assert b.bytes == a_gpu.bytes
-                assert b.strides == a.strides
-                assert b.shape == a.shape
-                b_cpu = numpy.asarray(b)
-                assert numpy.allclose(a, b_cpu)
-
-
-def test_copy_view():
-    from ..array import may_share_memory
-
-    def check_memory_region(a, a_op, b, b_op):
-        assert numpy.may_share_memory(a, a_op) == may_share_memory(b, b_op)
-
-        if a_op.base is None:
-            assert b_op.base is None
-        else:
-            assert a_op.base is a
-            if b.base:
-                # We avoid having a series of object connected by base.
-                # This is to don't bloc the garbage collection.
-                assert b_op.base is b.base
-            else:
-                assert b_op.base is b
-
-    for shp in [(5,), (6, 7), (4, 8, 9), (1, 8, 9)]:
-        for dtype in dtypes_all:
-            for offseted in [False, True]:
-                # order1 is the order of the original data
-                for order1 in ['c', 'f']:
-                    # order2 is the order wanted after copy
-                    for order2 in ['c', 'f']:
-                        print(shp, dtype, offseted, order1, order2)
-                        #TODO test copy unbroadcast!
-                        a, b = gen_gpu_nd_array(shp, dtype, offseted,
-                                                order=order1)
-
-                        assert numpy.allclose(a, numpy.asarray(b))
-                        check_flags(a, b)
-
-                        c = b.copy(order2)
-                        assert numpy.allclose(a, numpy.asarray(c))
-                        check_flags(c, a.copy(order2))
-                        check_memory_region(a, a.copy(order2), b, c)
-
-                        d = copy.copy(b)
-                        assert numpy.allclose(a, numpy.asarray(d))
-                        check_flags(d, copy.copy(a))
-                        check_memory_region(a, copy.copy(a), b, d)
-
-                        e = b.view()
-                        assert numpy.allclose(a, numpy.asarray(e))
-                        check_flags(e, a.view())
-                        check_memory_region(a, a.view(), b, e)
-
-                        f = copy.deepcopy(b)
-                        assert numpy.allclose(a, numpy.asarray(f))
-                        check_flags(f, copy.deepcopy(a))
-                        check_memory_region(a, copy.deepcopy(a), b, f)
-
-                        g = copy.copy(b.view())
-                        assert numpy.allclose(a, numpy.asarray(g))
-                        check_memory_region(a, copy.copy(a.view()), b, g)
-                        check_flags(g, copy.copy(a.view()))
-
-
-def test_len():
-    for shp in [(5,), (6, 7), (4, 8, 9), (1, 8, 9)]:
-        for dtype in dtypes_all:
-            for offseted in [True, False]:
-                a, a_gpu = gen_gpu_nd_array(shp, dtype, offseted)
-                assert len(a_gpu) == shp[0]
-
-
-def test_mapping_getitem_w_int():
-    def _cmp(x, y):
-        assert x.shape == y.shape
-        assert x.dtype == y.dtype
-        assert x.strides == y.strides
-        assert x.flags["C_CONTIGUOUS"] == y.flags["C_CONTIGUOUS"]
-        assert x.flags["F_CONTIGUOUS"] == y.flags["F_CONTIGUOUS"]
-        if x.flags["WRITEABLE"] != y.flags["WRITEABLE"]:
-            assert x.ndim == 0
-            assert not x.flags["OWNDATA"]
-            assert y.flags["OWNDATA"]
-        else:
-            assert x.flags["WRITEABLE"] == y.flags["WRITEABLE"]
-            assert x.flags["OWNDATA"] == y.flags["OWNDATA"]
-        assert x.flags["ALIGNED"] == y.flags["ALIGNED"]
-        assert x.flags["UPDATEIFCOPY"] == y.flags["UPDATEIFCOPY"]
-        x = numpy.asarray(x)
-        assert x.shape == y.shape
-        assert x.dtype == y.dtype
-        assert x.strides == y.strides
-        if not numpy.all(x == y):
-            print(x)
-            print(y)
-        assert numpy.all(x == y), (x, y)
-
-    def _cmpNs(x, y):
-        """
-        Don't compare the stride after the transfer
-        There is a copy that have been made on the gpu before the transfer
-        """
-        assert x.shape == y.shape
-        assert x.dtype == y.dtype
-        assert x.strides == y.strides
-        assert x.flags["C_CONTIGUOUS"] == y.flags["C_CONTIGUOUS"]
-        assert x.flags["F_CONTIGUOUS"] == y.flags["F_CONTIGUOUS"]
-        assert x.flags["WRITEABLE"] == y.flags["WRITEABLE"]
-        assert x.flags["ALIGNED"] == y.flags["ALIGNED"]
-        assert x.flags["OWNDATA"] == y.flags["OWNDATA"]
-        assert x.flags["UPDATEIFCOPY"] == y.flags["UPDATEIFCOPY"]
-        x_ = numpy.asarray(x)
-        assert x_.shape == y.shape
-        assert x_.dtype == y.dtype
-        if not numpy.all(x_ == y):
-            print(x_)
-            print(y)
-        assert numpy.all(x_ == y), (x_, y)
-        pass
-
-    def _cmpf(x, *y):
-        try:
-            x.__getitem__(y)
-        except IndexError:
-            pass
-        else:
-            raise Exception("Did not generate out or bound error")
-
-    def _cmpfV(x, *y):
-        try:
-            if len(y) == 1:
-                x.__getitem__(*y)
-            else:
-                x.__getitem__(y)
-        except ValueError:
-            pass
-        else:
-            raise Exception("Did not generate value error")
-
-    for dtype in dtypes_all:
-        for offseted in [True, False]:
-            # test vector
-            dim = (2,)
-            a, _a = gen_gpu_nd_array(dim, dtype, offseted)
-
-            import sys
-            init_ref_count = sys.getrefcount(_a)
-            _cmp(_a[...], a[...])
-            _cmp(_a[...], a[...])
-            _cmp(_a[...], a[...])
-            _cmp(_a[...], a[...])
-            _cmp(_a[...], a[...])
-
-            _cmp(_a[-1], a[-1])
-            _cmp(_a[1], a[1])
-            _cmp(_a[0], a[0])
-            _cmp(_a[::1], a[::1])
-            _cmpNs(_a[::-1], a[::-1])
-            _cmp(_a[...], a[...])
-            _cmpf(_a, 2)
-
-            # test scalar
-            dim = ()
-            a, _a = gen_gpu_nd_array(dim, dtype, offseted)
-            _cmp(_a[...], a[...])
-            _cmpf(_a, 0)
-            _cmpfV(_a, slice(1))
-
-            # test 4d-tensor
-            dim = (5, 4, 3, 2)
-            a, _a = gen_gpu_nd_array(dim, dtype, offseted)
-            _cmpf(_a, slice(-1), slice(-1), 10, -10)
-            _cmpf(_a, slice(-1), slice(-1), -10, slice(-1))
-            _cmpf(_a, 0, slice(0, -1, -20), -10)
-            _cmpf(_a, 10)
-            _cmpf(_a, (10, 0, 0, 0))
-            _cmpf(_a, -10)
-
-            #test with integer
-            _cmp(_a[1], a[1])
-            _cmp(_a[-1], a[-1])
-            _cmp(_a[numpy.int64(1)], a[numpy.int64(1)])
-            _cmp(_a[numpy.int64(-1)], a[numpy.int64(-1)])
-
-            #test with slice
-            _cmp(_a[1:], a[1:])
-            _cmp(_a[1:2], a[1:2])
-            _cmp(_a[-1:1], a[-1:1])
-
-            #test with tuple (mix slice, integer, numpy.int64)
-            _cmpNs(_a[0, 0, ::numpy.int64(-1), ::-1], a[0, 0, ::-1, ::-1])
-            _cmpNs(_a[:, :, ::numpy.int64(-1), ::-1], a[:, :, ::-1, ::-1])
-            _cmpNs(_a[:, :, numpy.int64(1), -1], a[:, :, 1, -1])
-            _cmpNs(_a[:, :, ::-1, ::-1], a[:, :, ::-1, ::-1])
-            _cmpNs(_a[:, :, ::-10, ::-10], a[:, :, ::-10, ::-10])
-            _cmpNs(_a[:, :, 1, -1], a[:, :, 1, -1])
-            _cmpNs(_a[:, :, -1, :], a[:, :, -1, :])
-            _cmpNs(_a[:, ::-2, -1, :], a[:, ::-2, -1, :])
-            _cmpNs(_a[:, ::-20, -1, :], a[:, ::-20, -1, :])
-            _cmpNs(_a[:, ::-2, -1], a[:, ::-2, -1])
-            _cmpNs(_a[0, ::-2, -1], a[0, ::-2, -1])
-            _cmp(_a[-1, -1, -1, -2], a[-1, -1, -1, -2])
-
-            #test ellipse
-            _cmp(_a[...], a[...])

pyopencl-2024.2.7.dist-info/RECORD

@@ -1,56 +0,0 @@
-pyopencl/algorithm.py,sha256=y3wnm2l-0mzIy1dwcZmKR2iLGPVMIlwbgAAsM3elJVg,51265
-pyopencl/clmath.py,sha256=lOxQzE6BEp5-nVRuGu0hgxzk_gcx7aTiy_hRFxAPmcI,8222
-pyopencl/version.py,sha256=PhHAIjtUGVQ2wTVlqgoOrcC_2rkvNMmqvy1rRDqWOhg,267
-pyopencl/capture_call.py,sha256=MJDOVqU6s8rJ5nmd5zOcqNe7GLXad2NwGeTpG60Kau0,5661
-pyopencl/reduction.py,sha256=OZMkLGt5KUp3HG2k0mkXBgF04IGWXzdhuZHy_IAwL1g,25524
-pyopencl/tools.py,sha256=3L0FggJ_nhw4M0KG1yG1VgMPdfA6NttY0nG7Yk6Glts,45993
-pyopencl/elementwise.py,sha256=VMw6A6wGaaBOsxdofjBq9Hyv6l0m9cGKVh2HwsfMuu4,38602
-pyopencl/_cl.cpython-39-darwin.so,sha256=_jBbGiRSYCQZKXVeuZldcnblwFQ8UnfaNbuVL9rVsh4,473864
-pyopencl/cache.py,sha256=PltNiHqrAmX7Tgg9BfFdheAHU6qwkg0tjbtCPKKryls,15959
-pyopencl/__init__.py,sha256=-3X3PY8QfGO_DRGrFcRh9iZqG9S6_2P68vx66ItOM0E,81108
-pyopencl/cltypes.py,sha256=DdBVPBU2bRuIbT8ImhWFIQosrefMOkAa4mY4yoSnurc,4818
-pyopencl/invoker.py,sha256=Tua5-JV8TlumHVLcNSWhzBiOvQNVBOWj1fUOhrtcjPI,14023
-pyopencl/ipython_ext.py,sha256=bN-5I06Nb53_2qE0KfKXxK27Gn4tG3EDj11Az8iTb28,1914
-pyopencl/scan.py,sha256=YAFn7V3T8Pb5XKMSY0JlzwSF_op4PxS-tIWdiq4vyiU,65529
-pyopencl/_cluda.py,sha256=KKUxizD1iQEuZ_TmmFZNJ8IdXa8x8uT9HgB0nmAlYLw,2074
-pyopencl/_mymako.py,sha256=VnxoyODc-_wVcWhKgQqUYVh_Iun5498Yg4W0WmGhTwk,610
-pyopencl/array.py,sha256=yazv6DHRsKzlMuR0OFMn465RihWpIe_OUAWlAS8oQHE,111717
-pyopencl/bitonic_sort.py,sha256=-gTe-1CfMwxkKKdvlB7x5vIyCeS3NxZRD7GVrYeXfuo,7960
-pyopencl/bitonic_sort_templates.py,sha256=Y1de5klU8GRo2pKlh1cZyYf_NBSIPDbhO83VLLnUgmk,16172
-pyopencl/clrandom.py,sha256=wAzoB6U4cNCipy5xbeYrrvDbqx_QFLmp_FeqIAu3K7I,13043
-pyopencl/compyte/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyopencl/compyte/dtypes.py,sha256=FQ1KrstfEIV_ikNNvbC1JODX9rLQ-Yo8-QhAwD-4v9I,9809
-pyopencl/compyte/.gitignore,sha256=HVYtbKRtOCPWZavrgYqO2u7UKFiE7g7ympmuQzKbBBw,168
-pyopencl/compyte/.git,sha256=hqjyvpQvk3kzLjhnlN4Ht1Pgj7gEz1d0hTK9YSPe5T8,44
-pyopencl/compyte/array.py,sha256=9dUSCSb475naOADXWhgpQb72Yx1FjKWMEaU6jRwdq90,7422
-pyopencl/compyte/ndarray/pygpu_language_opencl.cpp,sha256=kyY6wV_h_-uAj8IOO6c9gYHoxJ5Bir83M7XptAUx3u8,7946
-pyopencl/compyte/ndarray/pygpu_ndarray.h,sha256=eEn0lxqjyD_M21ALlD7YHy3_SkUpQQj58up0q7GsKoE,1665
-pyopencl/compyte/ndarray/gen_reduction.py,sha256=JrhJ40Q-8PNphso3jliZSVGWzLnA5-pKkDNZTJNRtbA,56315
-pyopencl/compyte/ndarray/pygpu_ndarray_object.h,sha256=mX8vcy4lgNIgX6xkB5T6U1XkD_Ysk-dW_EChrTYaJWE,9059
-pyopencl/compyte/ndarray/Makefile,sha256=fArNjiMX22zYkdTa3SMdEa0POCv5sSmR5X5cQnR-7t0,1236
-pyopencl/compyte/ndarray/test_gpu_elemwise.py,sha256=sZn24yDa3WgK_AoIs6HCL6-UslZf0aYiPByo__PbtJw,18438
-pyopencl/compyte/ndarray/setup_opencl.py,sha256=Xvmj3iaRjBXI2sEzTTYKxgFCoEyDaiP9ZGJ989RLSqc,3809
-pyopencl/compyte/ndarray/gen_elemwise.py,sha256=KZdZZ6higOqGuxpp9aLDECWuL3jT9zuSy8I7cLCAdKY,76820
-pyopencl/compyte/ndarray/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyopencl/compyte/ndarray/pygpu_ndarray.cpp,sha256=z8Foyjr9F6HH9EDzmdkTCcqO7Echf7KRifCNfvSvHZ8,51525
-pyopencl/compyte/ndarray/test_gpu_ndarray.py,sha256=a0PV3JVH7TG9-jZdBcrJwuqqnWD5LTsOQGr_bftghVA,17781
-pyopencl/compyte/ndarray/gpu_ndarray.h,sha256=3elPl8SzlpZHTAa-nlOeD7M5YOqVN-7whd5tMWx9zHY,1005
-pyopencl/compyte/ndarray/pygpu_language_cuda.cu,sha256=YO2xyBAtWwXx8RMvn-C2HHSjvjU-oEOpMzrF-CwGVDI,29323
-pyopencl/compyte/ndarray/pygpu_language.h,sha256=HSAfiG0W87aBoT6UAQl1ODQpdWr7GtSMtMtDpEjQkAI,7049
-pyopencl/characterize/__init__.py,sha256=MM56Q4P2IH-piykKeenHgsXYnAcB2HiTj0ftnYVYNVc,14346
-pyopencl/characterize/performance.py,sha256=TD8-cNnGnn46sQwfR5xNF2nr8yQcrmhuzJaYB13pSqk,6866
-pyopencl/cl/pyopencl-bessel-y.cl,sha256=VDy8l4lVxO8VcJR_maeGu_Qjnw27j28zBwhaTKDhBBg,12297
-pyopencl/cl/pyopencl-hankel-complex.cl,sha256=JSm38L6cOdnDssVqzKCNgjMrILT5ExkYAxz7i8rQBtA,31561
-pyopencl/cl/pyopencl-bessel-j.cl,sha256=69d5WoqajYSubLgA6OVwYw0yOHGt64zY97J8isnsQgU,23274
-pyopencl/cl/pyopencl-bessel-j-complex.cl,sha256=o-17yK_wBFqRiGgTYHg9waooTEKt1SCoguMUbg2LOB0,6026
-pyopencl/cl/pyopencl-airy.cl,sha256=S6S84BX6v6E9ZuGB7mdbFygUY99BaManrWMf47Ms7NA,8122
-pyopencl/cl/pyopencl-eval-tbl.cl,sha256=YNi_hyeE4GtDwzx3mLOMRIHh9jOOzMwSv-F2F1lMevg,2616
-pyopencl/cl/pyopencl-complex.h,sha256=gy7Ge9tuDeLYdpM8KIvKK347AxK5XPFhlVjJfgPtIlI,8544
-pyopencl/cl/pyopencl-random123/threefry.cl,sha256=2WmQGxx5gPSv22UL9_MlXv0eMug91k3bC-5_yQ4wlnI,54699
-pyopencl/cl/pyopencl-random123/philox.cl,sha256=vYcQH7Vw13Q3qkW5Nhy1HTUDbWLGKoloE1YP0VWk6vU,21740
-pyopencl/cl/pyopencl-random123/array.h,sha256=nIV0zDWYuybldNgtsh79icNtDXHYdDsSpFaWIvDTyw4,17088
-pyopencl/cl/pyopencl-random123/openclfeatures.h,sha256=pAPbl7JkQgJxulSuGGevpaI43P7PwiH2mYxtNfHq59M,2881
-pyopencl-2024.2.7.dist-info/RECORD,,
-pyopencl-2024.2.7.dist-info/WHEEL,sha256=IRWDGdz2SPFuu4rzqH5GOjJor8PmcV4n4TCkf27undY,111
-pyopencl-2024.2.7.dist-info/METADATA,sha256=ERdfvmBnVfT5Wi7CEbe-KmHyLOHB1ZIiujMMwluRW30,4670
-pyopencl-2024.2.7.dist-info/licenses/LICENSE,sha256=wiBvs-UC54bB5DswWuvB66B96b4hkYw_VLt8IR0cBPI,15284