pyopencl 2024.2.7__cp310-cp310-win_amd64.whl → 2024.3__cp310-cp310-win_amd64.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/__init__.py,sha256=Fyeu2A8r8dEzo8yDZcXNT-UAJE_ZSIJD_pFKz9kp4wc,83513
-pyopencl/_cl.cp310-win_amd64.pyd,sha256=2aTkDVwmWRuqMdcUMlN3xHyl19q65XGdr8M2i3TuyEg,565760
-pyopencl/_cluda.py,sha256=5coLt4eR5BOLgfUesgnaTx_nUhZ6BBhYi9dodvl7cbc,2128
-pyopencl/_mymako.py,sha256=MKVghtWIXkYppStYGfz2VcaK6qCZ6ICzloMCEE4ee0M,624
-pyopencl/algorithm.py,sha256=_TYrGd-bY0fDT5wPvkLlIvZMoKFM_lcI-VZ7KfsMS7Q,52711
-pyopencl/array.py,sha256=kU8ifBb6p10PEc6Lj_VLHAl-N2uhVtnP5KSJdHUAis0,115144
-pyopencl/bitonic_sort.py,sha256=SNsyWNATAMs5GGLSkUILxkKF2DdONo8_EpBK01rZOWQ,8200
-pyopencl/bitonic_sort_templates.py,sha256=CzjCacG-YgzzXb0ia0oMKT27RlmmWdRtO2w4_OJrnTA,16766
-pyopencl/cache.py,sha256=uwIl76P7kcapH1OZEmHzPBmkQFKLOVd0o9enYI8cU94,16493
-pyopencl/capture_call.py,sha256=ydQPYy8AyWmDf8amCZaiBIvzEOPvPRzIwtecOu1kR4g,5837
-pyopencl/characterize/__init__.py,sha256=rBhH9M6wkp2fYs51vx9BHgNVl-N1Vz_2ofV0uhPsGk0,14802
-pyopencl/characterize/performance.py,sha256=xwyt4SsABo4LipXzjRF7TKz8LVBcLmZZ5os6f7hp3Go,7103
-pyopencl/cl/pyopencl-airy.cl,sha256=HSUEWbUN2MNzuhvDP3LB9dVY_3dhjFSWXhvGQsrA8VA,8446
-pyopencl/cl/pyopencl-bessel-j-complex.cl,sha256=XOUBUZFxgra9nUAymnbJugcOa1lQyj-fwiZA9ly3rdI,6264
-pyopencl/cl/pyopencl-bessel-j.cl,sha256=V16uWa8t1b0oxNHRCLhCqxzR-28yr-5ZslqHkw2Ved0,24358
-pyopencl/cl/pyopencl-bessel-y.cl,sha256=kD6u2qtgmrNNq75w5uaxHdrvb6oeeTPgrGpF29ERsuE,12732
-pyopencl/cl/pyopencl-complex.h,sha256=DHFUM2sHCv50m4LJvvIpF8sMWc5yOO6kYu9nWlScl6A,8847
-pyopencl/cl/pyopencl-eval-tbl.cl,sha256=SDYB_RkW7jtN_Y_xhCbwGjBSNmBpMg8T4ZXlrP_2q9U,2736
-pyopencl/cl/pyopencl-hankel-complex.cl,sha256=yrxPF4wgr9bTzG4SyJsVbij5SODoJvWaDRDDuo4zrs4,32005
-pyopencl/cl/pyopencl-random123/array.h,sha256=oTYPJfU7s4IXy8xRc3H0rqMq4mgyVxd7UuLSf3liUPY,17413
-pyopencl/cl/pyopencl-random123/openclfeatures.h,sha256=jauJ1WEspr-YNefAuUwPhapl_JQDVa6my_h4fLl-p4o,2974
-pyopencl/cl/pyopencl-random123/philox.cl,sha256=KqPbLt54UwrHPvBe7v4ZMzqI2oGrzp0c0QzqVhydNCY,22226
-pyopencl/cl/pyopencl-random123/threefry.cl,sha256=bC78-HJVuc4AFiNppglDQiN8cZRD45hG1PPdi4Sdt-o,55563
-pyopencl/clmath.py,sha256=GL9s0YwKpCgvsGl6ndoWXEngPFWAqRRR_HOoQm57OA8,8502
-pyopencl/clrandom.py,sha256=5RS-1duIm-sauChyd8VjBden3DLqfdjp4D9Csnk6BRg,13451
-pyopencl/cltypes.py,sha256=2jCvMMBtkhXxfbBFBfM4NSFKRg7kEo1tlwGJQlyiwmQ,4955
-pyopencl/compyte/.git,sha256=hqjyvpQvk3kzLjhnlN4Ht1Pgj7gEz1d0hTK9YSPe5T8,44
-pyopencl/compyte/.gitignore,sha256=PFMRSJycIqPtcpEn7VqbcenWJqHFDuYtwQm_tLbADt8,189
-pyopencl/compyte/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyopencl/compyte/array.py,sha256=IJzw-dSS_injEiLVNHLlSRi0R2F1sO_8xeeK-XezsSo,7636
-pyopencl/compyte/dtypes.py,sha256=nEieOLmnNJQcU6sNJJoBe7qZXAqu4sOgHQXKC8SGDi8,10099
-pyopencl/compyte/ndarray/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyopencl/compyte/ndarray/gen_elemwise.py,sha256=5NlbUth3Reu2ag6DmCp_JjPcIoF6Af4w5cuAg3h9-W4,78727
-pyopencl/compyte/ndarray/gen_reduction.py,sha256=BElJhHtAdmL5gkTqeHY1yMe0eYMoDcQWIBSQvsxVc_4,57826
-pyopencl/compyte/ndarray/gpu_ndarray.h,sha256=Ji02dMlp7ZGBCODfr43UIp_bxMG5GIrSLM-UlpCHbOk,1040
-pyopencl/compyte/ndarray/Makefile,sha256=-dQIN5YQMUibWFTrS6AULvVg4xHsscpndJgD5I6L27E,1266
-pyopencl/compyte/ndarray/pygpu_language.h,sha256=k3WOwdxSdqjjix0RPl1IIFrB_Y1s0mzcMVwTuqBY4Hw,7256
-pyopencl/compyte/ndarray/pygpu_language_cuda.cu,sha256=MtmiYZfui-v3q9w7fNgl1BrJzAkNJiw5Hk4RXXqnAdg,29945
-pyopencl/compyte/ndarray/pygpu_language_opencl.cpp,sha256=U_wcdA848sIFuRkkSCe36OMwAE0d37717mpR9MANy8k,8263
-pyopencl/compyte/ndarray/pygpu_ndarray.cpp,sha256=10vRhLLRWkhB4BuEeUt39hMadtUhZCZaCmsE_dCpe3Y,53071
-pyopencl/compyte/ndarray/pygpu_ndarray.h,sha256=sev2JF5tBU0QKT56Fc7wcT6N3bcfy5ND6HMA0RlYZg8,1736
-pyopencl/compyte/ndarray/pygpu_ndarray_object.h,sha256=LyC78nKfoOgmzLxFw45LKNrT4GhrzWkZOlfsXSjJ_eg,9291
-pyopencl/compyte/ndarray/setup_opencl.py,sha256=XSF-qDieVIEaHph25gTs3fg8A4okd3fESfbiyX7yRTA,3910
-pyopencl/compyte/ndarray/test_gpu_elemwise.py,sha256=83Ju3lNNU8BcSvqG6QbgcHx_VbVo_-0vVwEBrmYjWtw,18849
-pyopencl/compyte/ndarray/test_gpu_ndarray.py,sha256=GHBG4TlGxQD2VxJi6p-UPidR8Uy2QJakfp40EsWuEhM,18268
-pyopencl/elementwise.py,sha256=-4L6OtCEQyaNuJJOYq0y36P_TVp0OXs8Zy4oqG8OkZw,39766
-pyopencl/invoker.py,sha256=F-bxrqGo9pzPSR5k9XxREBRjUVU6tjnjh2nsoSaMtjQ,14442
-pyopencl/ipython_ext.py,sha256=5Le00IDI2iGP4VtqeHln6YBJOweGuXcr_HsdPEDzGwc,1982
-pyopencl/reduction.py,sha256=FiOAQy0ZjkD7-JrwI7pD98IWIbPZoEnSuil_LY3RcOU,26304
-pyopencl/scan.py,sha256=03IbhUwxLgV3LnTvA3JbHylUYVvCol7OV9-tPPrymYk,67428
-pyopencl/tools.py,sha256=ILqLyTdSXQlUwJxDXKPbu5nwuqschsFLjy48TmRqMyk,47510
-pyopencl/version.py,sha256=Fp_v5G59_24Um9NujHpex3VRwdffKTwtN8tjiQl5QOQ,276
-pyopencl-2024.2.7.dist-info/METADATA,sha256=ERdfvmBnVfT5Wi7CEbe-KmHyLOHB1ZIiujMMwluRW30,4670
-pyopencl-2024.2.7.dist-info/WHEEL,sha256=-UgCblpinadfg0PAykASFusSBw01wo3_NiYBKVftpF0,105
-pyopencl-2024.2.7.dist-info/licenses/LICENSE,sha256=jib9h6nV8oAvCkKPKDecpLakmQi1SktCn4YXmllgySY,15566
-pyopencl-2024.2.7.dist-info/RECORD,,