pyopencl 2024.2.2__cp310-cp310-macosx_11_0_arm64.whl → 2024.2.5__cp310-cp310-macosx_11_0_arm64.whl

pyopencl/compyte/ndarray/pygpu_ndarray.h

@@ -0,0 +1,71 @@
+#ifndef _PYGPU_NDARRAY_H
+#define _PYGPU_NDARRAY_H
+#ifndef OFFSET
+#define OFFSET 0
+#endif
+
+//#include <Python.h>
+//#include <structmember.h>
+#include <stdio.h>
+#include <numpy/arrayobject.h>
+
+#include "pygpu_ndarray_object.h"
+#include "gpu_ndarray.h"
+#include "pygpu_language.h"
+
+/*
+ * Return a PyGpuNdArray whose 'nd' dimensions are all 0.
+ * if nd==-1, it is not initialized.
+ */
+PyObject * PyGpuNdArray_New(int nd=-1);
+
+/**
+ * Return 1 for a PyGpuNdArrayObject otw 0
+ */
+int 
+PyGpuNdArray_Check(const PyObject * ob);
+
+/**
+ * Return 1 for a PyGpuNdArrayObject otw 0
+ */
+int 
+PyGpuNdArray_CheckExact(const PyObject * ob);
+
+/**
+ * Transfer the contents of numpy array `obj` to `self`.
+ *
+ * self is reallocated to have the correct dimensions if necessary.
+ */
+int PyGpuNdArray_CopyFromArray(PyGpuNdArrayObject * self, PyArrayObject*obj);
+
+static int 
+PyGpuNdArray_add_offset(PyGpuNdArrayObject * self, int offset);
+
+static int 
+PyGpuNdArray_set_data(PyGpuNdArrayObject * self, char * data, PyObject * base, int offset=0);
+
+static PyObject *
+PyGpuNdArray_Subscript(PyObject * py_self, PyObject * key);
+
+static PyObject *
+PyGpuNdArray_Copy(PyGpuNdArrayObject * self, NPY_ORDER order=NPY_CORDER);
+
+static PyObject *
+PyGpuNdArray_Zeros(int nd, npy_intp* dims, PyArray_Descr* dtype, int fortran);
+
+static PyObject *
+PyGpuNdArray_Empty(int nd, npy_intp* dims, PyArray_Descr* dtype, int fortran);
+
+#endif
+
+/*
+  Local Variables:
+  mode:c++
+  c-basic-offset:4
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0))
+  indent-tabs-mode:nil
+  fill-column:79
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:textwidth=79 :

pyopencl/compyte/ndarray/pygpu_ndarray_object.h

@@ -0,0 +1,232 @@
+/**
+ * struct PyGPUArrayObject
+ *
+ * This is a Python type.  
+ *
+ */
+#ifndef _PYGPU_NDARRAY_OBJECT_H
+#define _PYGPU_NDARRAY_OBJECT_H
+
+#include <Python.h>
+#include <numpy/arrayobject.h>
+#include "gpu_ndarray.h"
+
+typedef struct PyGpuNdArrayObject{
+  PyObject_HEAD
+
+  GpuNdArray gpu_ndarray; //no pointer, just inlined.
+  PyObject * base;
+  PyArray_Descr * descr; // for numpy-like desc
+  int data_allocated; //the number of bytes allocated for devdata
+} PyGpuNdArrayObject;
+
+#define PyGpuNdArray_NDIM(obj) (((PyGpuNdArrayObject *)obj)->gpu_ndarray.nd)
+#define PyGpuNdArray_DATA(obj) (((PyGpuNdArrayObject *)obj)->gpu_ndarray.data)
+#define PyGpuNdArray_BYTES(obj) (((PyGpuNdArrayObject *)obj)->gpu_ndarray.data)
+#define PyGpuNdArray_OFFSET(obj) (((PyGpuNdArrayObject *)(obj))->gpu_ndarray.offset)
+#define PyGpuNdArray_DIMS(obj) (((PyGpuNdArrayObject *)obj)->gpu_ndarray.dimensions)
+#define PyGpuNdArray_STRIDES(obj) (((PyGpuNdArrayObject *)obj)->gpu_ndarray.strides)
+#define PyGpuNdArray_DIM(obj,n) (PyGpuNdArray_DIMS(obj)[n])
+#define PyGpuNdArray_STRIDE(obj,n) (PyGpuNdArray_STRIDES(obj)[n])
+#define PyGpuNdArray_BASE(obj) (((PyGpuNdArrayObject *)obj)->base)
+#define PyGpuNdArray_DESCR(obj) (((PyGpuNdArrayObject *)obj)->descr)
+#define PyGpuNdArray_FLAGS(obj) (((PyGpuNdArrayObject *)obj)->gpu_ndarray.flags)
+#define PyGpuNdArray_ITEMSIZE(obj) (((PyGpuNdArrayObject *)obj)->descr->elsize)
+#define PyGpuNdArray_TYPE(obj) (((PyGpuNdArrayObject *)(obj))->descr->type_num)
+
+#define PyGpuNdArray_SIZE(obj) PyArray_MultiplyList(PyGpuNdArray_DIMS(obj),PyGpuNdArray_NDIM(obj))
+//npy_intp PyGpuNdArray_Size(PyObject* obj);
+//npy_intp PyGpuNdArray_NBYTES(PyObject* arr);
+
+/*
+  Flags accessor
+ */
+#define PyGpuNdArray_CHKFLAGS(m, FLAGS)                              \
+        ((((PyGpuNdArrayObject *)(m))->gpu_ndarray.flags & (FLAGS)) == (FLAGS))
+
+#define PyGpuNdArray_ISCONTIGUOUS(m) PyGpuNdArray_CHKFLAGS(m, NPY_CONTIGUOUS)
+#define PyGpuNdArray_ISFORTRAN(m) (PyGpuNdArray_CHKFLAGS(m, NPY_F_CONTIGUOUS) && \
+                                   PyGpuNdArray_NDIM(m) > 1)
+#define PyGpuNdArray_FORTRAN_IF(m) (PyGpuNdArray_CHKFLAGS(m, NPY_F_CONTIGUOUS)? \
+                                    NPY_F_CONTIGUOUS : 0)
+#define PyGpuNdArray_ISONESEGMENT(m) (PyGpuNdArray_NDIM(m) == 0 || \
+                                      PyGpuNdArray_ISCONTIGUOUS(m) || \
+                                      PyGpuNdArray_ISFORTRAN(m))
+#define PyGpuNdArray_ISWRITEABLE(m) PyGpuNdArray_CHKFLAGS(m, NPY_WRITEABLE)
+#define PyGpuNdArray_ISALIGNED(m) PyGpuNdArray_CHKFLAGS(m, NPY_ALIGNED)
+
+#define PyGpuNdArray_ISNBO(arg) ((arg) != NPY_OPPBYTE)
+// THE NEXT ONE SEEM BAD...
+#define PyGpuNdArray_IsNativeByteOrder PyArray_ISNBO
+#define PyGpuNdArray_ISNOTSWAPPED(m) PyArray_ISNBO(PyArray_DESCR(m)->byteorder)
+#define PyGpuNdArray_FLAGSWAP(m, flags) (PyGpuNdArray_CHKFLAGS(m, flags) && PyGpuNdArray_ISNOTSWAPPED(m))
+
+#define PyGpuNdArray_ISCARRAY(m) PyGpuNdArray_FLAGSWAP(m, NPY_CARRAY)
+#define PyGpuNdArray_ISCARRAY_RO(m) PyGpuNdArray_FLAGSWAP(m, NPY_CARRAY_RO)
+#define PyGpuNdArray_ISFARRAY(m) PyGpuNdArray_FLAGSWAP(m, NPY_FARRAY)
+#define PyGpuNdArray_ISFARRAY_RO(m) PyGpuNdArray_FLAGSWAP(m, NPY_FARRAY_RO)
+#define PyGpuNdArray_ISBEHAVED(m) PyGpuNdArray_FLAGSWAP(m, NPY_BEHAVED)
+#define PyGpuNdArray_ISBEHAVED_RO(m) PyGpuNdArray_FLAGSWAP(m, NPY_ALIGNED)
+
+static
+void PyGpuNdArray_fprint(FILE * fd, const PyGpuNdArrayObject *self)
+{
+    fprintf(fd, "PyGpuNdArrayObject <%p, %p> nd=%i data_allocated=%d\n",
+	    self, PyGpuNdArray_DATA(self), PyGpuNdArray_NDIM(self), self->data_allocated);
+    fprintf(fd, "\tITEMSIZE: %d\n", PyGpuNdArray_ITEMSIZE(self));
+    fprintf(fd, "\tTYPENUM: %d\n", PyGpuNdArray_TYPE(self));
+    fprintf(fd, "\tRefcount: %ld\n", (long int)self->ob_refcnt);
+    fprintf(fd, "\tBASE: %p\n", PyGpuNdArray_BASE(self));
+    fprintf(fd, "\tHOST_DIMS:      ");
+    for (int i = 0; i < PyGpuNdArray_NDIM(self); ++i)
+    {
+        fprintf(fd, "%ld\t", PyGpuNdArray_DIMS(self)[i]);
+    }
+    fprintf(fd, "\n\tHOST_STRIDES: ");
+    for (int i = 0; i < PyGpuNdArray_NDIM(self); ++i)
+    {
+        fprintf(fd, "%ld\t", PyGpuNdArray_STRIDES(self)[i]);
+    }
+    fprintf(fd, "\n\tFLAGS: ");
+    fprintf(fd, "\n\t\tC_CONTIGUOUS: %d", PyGpuNdArray_ISCONTIGUOUS(self));
+    fprintf(fd, "\n\t\tPyGpuNdArray_ISFORTRAN: %d PyGpuNdArray_FORTRAN_IF:%d F_CONTIGUOUS: %d",
+            PyGpuNdArray_ISFORTRAN(self), PyGpuNdArray_FORTRAN_IF(self), PyGpuNdArray_CHKFLAGS(self, NPY_FORTRAN));
+    fprintf(fd, "\n\t\tOWNDATA: %d", PyGpuNdArray_CHKFLAGS(self, NPY_OWNDATA));
+    fprintf(fd, "\n\t\tWRITEABLE: %d", PyGpuNdArray_ISWRITEABLE(self));
+    fprintf(fd, "\n\t\tALIGNED: %d", PyGpuNdArray_ISALIGNED(self));
+    fprintf(fd, "\n\t\tUPDATEIFCOPY: %d", PyGpuNdArray_CHKFLAGS(self, NPY_UPDATEIFCOPY));
+    fprintf(fd, "\n");
+
+}
+static
+void PyArray_fprint(FILE * fd, const PyArrayObject *self)
+{
+    fprintf(fd, "PyArrayObject <%p, %p> nd=%i\n",
+	    self, PyArray_DATA(self), PyArray_NDIM(self));
+    fprintf(fd, "\tITEMSIZE: %d\n", PyArray_ITEMSIZE(self));
+    fprintf(fd, "\tTYPENUM: %d\n", PyArray_TYPE(self));
+    fprintf(fd, "\tHOST_DIMS:      ");
+    for (int i = 0; i < PyArray_NDIM(self); ++i)
+    {
+        fprintf(fd, "%ld\t", PyArray_DIMS(self)[i]);
+    }
+    fprintf(fd, "\n\tHOST_STRIDES: ");
+    for (int i = 0; i < PyArray_NDIM(self); ++i)
+    {
+        fprintf(fd, "%ld\t", PyArray_STRIDES(self)[i]);
+    }
+    fprintf(fd, "\n\tFLAGS: ");
+    fprintf(fd, "\n\t\tC_CONTIGUOUS: %d", PyArray_ISCONTIGUOUS(self));
+    fprintf(fd, "\n\t\tPyArray_ISFORTRAN: %d PyArray_FORTRAN_IF:%d F_CONTIGUOUS: %d",
+            PyArray_ISFORTRAN(self), PyArray_FORTRAN_IF(self), PyArray_CHKFLAGS(self, NPY_FORTRAN));
+    fprintf(fd, "\n\t\tOWNDATA: %d", PyArray_CHKFLAGS(self, NPY_OWNDATA));
+    fprintf(fd, "\n\t\tWRITEABLE: %d", PyArray_ISWRITEABLE(self));
+    fprintf(fd, "\n\t\tALIGNED: %d", PyArray_ISALIGNED(self));
+    fprintf(fd, "\n\t\tUPDATEIFCOPY: %d", PyArray_CHKFLAGS(self, NPY_UPDATEIFCOPY));
+    fprintf(fd, "\n");
+
+}
+
+template <typename T>
+static T ceil_intdiv(T a, T b)
+{
+    return (a/b) + ((a % b) ? 1: 0);
+}
+
+
+//Compute if the resulting array is c contiguous
+static bool
+PyGpuNdArray_is_c_contiguous(const PyGpuNdArrayObject * self)
+{
+    bool c_contiguous = true;
+    int size = PyGpuNdArray_ITEMSIZE(self);
+    for (int i = PyGpuNdArray_NDIM(self)-1; (i >= 0) && c_contiguous; --i) {
+        if (PyGpuNdArray_STRIDE(self, i) != size) {
+            c_contiguous = false;
+        }
+        size = size * PyGpuNdArray_DIM(self, i);
+    }
+    return c_contiguous;
+}
+
+//Compute if the resulting array is f contiguous
+static bool
+PyGpuNdArray_is_f_contiguous(const PyGpuNdArrayObject * self)
+{
+    bool f_contiguous = true;
+    int size = PyGpuNdArray_ITEMSIZE(self);
+    for (int i = 0; i < PyGpuNdArray_NDIM(self) && f_contiguous; ++i) {
+        if (PyGpuNdArray_STRIDE(self, i) != size) {
+            f_contiguous = false;
+        }
+        size = size * PyGpuNdArray_DIM(self, i);
+    }
+    return f_contiguous;
+}
+
+static PyObject *
+PyGpuNdArray_as_c_contiguous(PyObject* dummy, PyObject* args, PyObject *kargs);
+static PyObject *
+PyGpuNdArray_as_f_contiguous(PyObject* dummy, PyObject* args, PyObject *kargs);
+
+/**
+ * [Re]allocate a PyGpuNdArrayObject with access to 'nd' dimensions.
+ *
+ * Note: This does not allocate storage for data.
+ */
+static
+int PyGpuNdArray_set_nd(PyGpuNdArrayObject * self, const int nd)
+{
+    if (nd != PyGpuNdArray_NDIM(self))
+    {
+        if(0) fprintf(stderr, "PyGpuNdArray_set_nd: modif nd=%i to nd=%i\n", PyGpuNdArray_NDIM(self), nd);
+    
+        if (PyGpuNdArray_DIMS(self)){
+            free(PyGpuNdArray_DIMS(self));
+            PyGpuNdArray_DIMS(self) = NULL;
+            PyGpuNdArray_NDIM(self) = -1;
+        }
+        if (PyGpuNdArray_STRIDES(self)){
+            free(PyGpuNdArray_STRIDES(self));
+            PyGpuNdArray_STRIDES(self) = NULL;
+            PyGpuNdArray_NDIM(self) = -1;
+        }
+        if (nd == -1) return 0;
+
+        PyGpuNdArray_DIMS(self) = (npy_intp*)malloc(nd*sizeof(npy_intp));
+        if (NULL == PyGpuNdArray_DIMS(self))
+        {
+            PyErr_SetString(PyExc_MemoryError, "PyGpuNdArray_set_nd: Failed to allocate dimensions");
+            return -1;
+        }
+        PyGpuNdArray_STRIDES(self) = (npy_intp*)malloc(nd*sizeof(npy_intp));
+        if (NULL == PyGpuNdArray_STRIDES(self))
+        {
+            PyErr_SetString(PyExc_MemoryError, "PyGpuNdArray_set_nd: Failed to allocate str");
+            return -1;
+        }
+        //initialize all dimensions and strides to 0
+        for (int i = 0; i < nd; ++i)
+        {
+            PyGpuNdArray_DIM(self, i) = 0;
+            PyGpuNdArray_STRIDES(self)[i] = 0;
+        }
+
+        PyGpuNdArray_NDIM(self) = nd;
+	if(0) fprintf(stderr, "PyGpuNdArray_set_nd: end\n");
+    }
+    return 0;
+}
+
+#endif
+/*
+  Local Variables:
+  mode:c++
+  c-basic-offset:4
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0))
+  indent-tabs-mode:nil
+  fill-column:79
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:textwidth=79 :

pyopencl/tools.py

@@ -348,96 +348,98 @@ def _monkeypatch_svm_docstrings():
 
     # {{{ PooledSVM
 
-    PooledSVM.__doc__ = """
-    An object representing a :class:`SVMPool`-based allocation of
-    :ref:`svm`.  Analogous to :class:`~pyopencl.SVMAllocation`, however once
-    this object is deleted, its associated device memory is returned to the
-    pool from which it came.
+    PooledSVM.__doc__ = (  # pylint: disable=possibly-used-before-assignment
+        """An object representing a :class:`SVMPool`-based allocation of
+        :ref:`svm`.  Analogous to :class:`~pyopencl.SVMAllocation`, however once
+        this object is deleted, its associated device memory is returned to the
+        pool from which it came.
 
-    .. versionadded:: 2022.2
+        .. versionadded:: 2022.2
 
-    .. note::
+        .. note::
 
-        If the :class:`SVMAllocator` for the :class:`SVMPool` that allocated an
-        object of this type is associated with an (in-order)
-        :class:`~pyopencl.CommandQueue`, sufficient synchronization is provided
-        to ensure operations enqueued before deallocation complete before
-        operations from a different use (possibly in a different queue) are
-        permitted to start. This applies when :class:`release` is called and
-        also when the object is freed automatically by the garbage collector.
+            If the :class:`SVMAllocator` for the :class:`SVMPool` that allocated an
+            object of this type is associated with an (in-order)
+            :class:`~pyopencl.CommandQueue`, sufficient synchronization is provided
+            to ensure operations enqueued before deallocation complete before
+            operations from a different use (possibly in a different queue) are
+            permitted to start. This applies when :class:`release` is called and
+            also when the object is freed automatically by the garbage collector.
 
-    Is a :class:`pyopencl.SVMPointer`.
+        Is a :class:`pyopencl.SVMPointer`.
 
-    Supports structural equality and hashing.
+        Supports structural equality and hashing.
 
-    .. automethod:: release
+        .. automethod:: release
 
-        Return the held memory to the pool. See the note about synchronization
-        behavior during deallocation above.
+            Return the held memory to the pool. See the note about synchronization
+            behavior during deallocation above.
 
-    .. automethod:: enqueue_release
+        .. automethod:: enqueue_release
 
-        Synonymous to :meth:`release`, for consistency with
-        :class:`~pyopencl.SVMAllocation`. Note that, unlike
-        :meth:`pyopencl.SVMAllocation.enqueue_release`, specifying a queue
-        or events to be waited for is not supported.
+            Synonymous to :meth:`release`, for consistency with
+            :class:`~pyopencl.SVMAllocation`. Note that, unlike
+            :meth:`pyopencl.SVMAllocation.enqueue_release`, specifying a queue
+            or events to be waited for is not supported.
 
-    .. automethod:: bind_to_queue
+        .. automethod:: bind_to_queue
 
-        Analogous to :meth:`pyopencl.SVMAllocation.bind_to_queue`.
+            Analogous to :meth:`pyopencl.SVMAllocation.bind_to_queue`.
 
-    .. automethod:: unbind_from_queue
+        .. automethod:: unbind_from_queue
 
-        Analogous to :meth:`pyopencl.SVMAllocation.unbind_from_queue`.
-    """
+            Analogous to :meth:`pyopencl.SVMAllocation.unbind_from_queue`.
+        """)
 
     # }}}
 
     # {{{ SVMAllocator
 
-    SVMAllocator.__doc__ = """
-    .. versionadded:: 2022.2
+    SVMAllocator.__doc__ = (  # pylint: disable=possibly-used-before-assignment
+        """
+        .. versionadded:: 2022.2
 
-    .. automethod:: __init__
+        .. automethod:: __init__
 
-        :arg flags: See :class:`~pyopencl.svm_mem_flags`.
-        :arg queue: If not specified, allocations will be freed
-            eagerly, irrespective of whether pending/enqueued operations
-            are still using the memory.
+            :arg flags: See :class:`~pyopencl.svm_mem_flags`.
+            :arg queue: If not specified, allocations will be freed
+                eagerly, irrespective of whether pending/enqueued operations
+                are still using the memory.
 
-            If specified, deallocation of memory will be enqueued
-            with the given queue, and will only be performed
-            after previously-enqueue operations in the queue have
-            completed.
+                If specified, deallocation of memory will be enqueued
+                with the given queue, and will only be performed
+                after previously-enqueue operations in the queue have
+                completed.
 
-            It is an error to specify an out-of-order queue.
+                It is an error to specify an out-of-order queue.
 
-            .. warning::
+                .. warning::
 
-                Not specifying a queue will typically lead to undesired
-                behavior, including crashes and memory corruption.
-                See the warning in :ref:`svm`.
+                    Not specifying a queue will typically lead to undesired
+                    behavior, including crashes and memory corruption.
+                    See the warning in :ref:`svm`.
 
-    .. automethod:: __call__
+        .. automethod:: __call__
 
-        Return a :class:`~pyopencl.SVMAllocation` of the given *size*.
-    """
+            Return a :class:`~pyopencl.SVMAllocation` of the given *size*.
+        """)
 
     # }}}
 
     # {{{ SVMPool
 
-    SVMPool.__doc__ = remove_common_indentation("""
-    A memory pool for OpenCL device memory in :ref:`SVM <svm>` form.
-    *allocator* must be an instance of :class:`SVMAllocator`.
+    SVMPool.__doc__ = (  # pylint: disable=possibly-used-before-assignment
+        remove_common_indentation("""
+        A memory pool for OpenCL device memory in :ref:`SVM <svm>` form.
+        *allocator* must be an instance of :class:`SVMAllocator`.
 
-    .. versionadded:: 2022.2
+        .. versionadded:: 2022.2
 
-    .. automethod:: __init__
-    .. automethod:: __call__
+        .. automethod:: __init__
+        .. automethod:: __call__
 
-        Return a :class:`PooledSVM` of the given *size*.
-    """) + _MEMPOOL_IFACE_DOCS
+            Return a :class:`PooledSVM` of the given *size*.
+        """) + _MEMPOOL_IFACE_DOCS)
 
     # }}}
 
@@ -1363,6 +1365,8 @@ class _TemplateRenderer:
                 parsed_arg = arg
             elif isinstance(arg, tuple):
                 parsed_arg = ScalarArg(self.parse_type(arg[0]), arg[1])
+            else:
+                raise TypeError("unexpected argument type: %s" % type(arg))
 
             parsed_args.append(parsed_arg)
 

pyopencl/version.py

@@ -1,3 +1,9 @@
-VERSION = (2024, 2, 2)
-VERSION_STATUS = ""
-VERSION_TEXT = ".".join(str(x) for x in VERSION) + VERSION_STATUS
+import re
+from importlib import metadata
+
+
+VERSION_TEXT = metadata.version("pyopencl")
+_match = re.match("^([0-9.]+)([a-z0-9]*?)$", VERSION_TEXT)
+assert _match is not None
+VERSION_STATUS = _match.group(2)
+VERSION = tuple(int(nr) for nr in _match.group(1).split("."))

{pyopencl-2024.2.2.dist-info → pyopencl-2024.2.5.dist-info}/METADATA

@@ -1,13 +1,10 @@
 Metadata-Version: 2.1
 Name: pyopencl
-Version: 2024.2.2
+Version: 2024.2.5
 Summary: Python wrapper for OpenCL
-Home-page: http://mathema.tician.de/software/pyopencl
-Author: Andreas Kloeckner
-Author-email: inform@tiker.net
-License: MIT
-Classifier: Environment :: Console
+Author-Email: Andreas Kloeckner <inform@tiker.net>
 Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Other Audience
 Classifier: Intended Audience :: Science/Research
@@ -19,19 +16,22 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Scientific/Engineering :: Mathematics
 Classifier: Topic :: Scientific/Engineering :: Physics
+Project-URL: Homepage, https://mathema.tician.de/software/pyopencl
+Project-URL: Documentation, https://documen.tician.de/pyopencl
+Project-URL: Repository, https://github.com/inducer/pyopencl
 Requires-Python: ~=3.8
-License-File: LICENSE
+Requires-Dist: importlib-resources; python_version < "3.9"
 Requires-Dist: numpy
-Requires-Dist: pytools >=2022.1.13
-Requires-Dist: platformdirs >=2.2.0
-Requires-Dist: importlib-resources ; python_version < "3.9"
+Requires-Dist: platformdirs>=2.2.0
+Requires-Dist: pytools>=2022.1.13
+Requires-Dist: oclgrind_binary_distribution>=18.3; extra == "oclgrind"
+Requires-Dist: pocl_binary_distribution>=1.2; extra == "pocl"
+Requires-Dist: Mako; extra == "test"
+Requires-Dist: pytest>=7.0.0; extra == "test"
 Provides-Extra: oclgrind
-Requires-Dist: oclgrind-binary-distribution >=18.3 ; extra == 'oclgrind'
 Provides-Extra: pocl
-Requires-Dist: pocl-binary-distribution >=1.2 ; extra == 'pocl'
 Provides-Extra: test
-Requires-Dist: pytest >=7.0.0 ; extra == 'test'
-Requires-Dist: Mako ; extra == 'test'
+Description-Content-Type: text/x-rst
 
 PyOpenCL: Pythonic Access to OpenCL, with Arrays and Algorithms
 ===============================================================

pyopencl-2024.2.5.dist-info/RECORD

@@ -0,0 +1,56 @@
+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/cache.py,sha256=PltNiHqrAmX7Tgg9BfFdheAHU6qwkg0tjbtCPKKryls,15959
+pyopencl/__init__.py,sha256=-3X3PY8QfGO_DRGrFcRh9iZqG9S6_2P68vx66ItOM0E,81108
+pyopencl/cltypes.py,sha256=DdBVPBU2bRuIbT8ImhWFIQosrefMOkAa4mY4yoSnurc,4818
+pyopencl/invoker.py,sha256=7pjVh0CDkRTNHc1PVQV9Lxhi-0FXvJHtq-jDzLJUypk,13994
+pyopencl/_cl.cpython-310-darwin.so,sha256=j2MYmvCOoZlVaPNhlo0LUuRQAjSjwRD95XzN5qcja_I,473672
+pyopencl/ipython_ext.py,sha256=bN-5I06Nb53_2qE0KfKXxK27Gn4tG3EDj11Az8iTb28,1914
+pyopencl/scan.py,sha256=NbhwamNMcoJaCfeQX2eciQdWEhlAfVxIOTRy5oaUAx8,65500
+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.5.dist-info/RECORD,,
+pyopencl-2024.2.5.dist-info/WHEEL,sha256=Tkl0AM11OgIVI8mC-sanPd5i7v9tiS1lP91mPhYZ8Sg,113
+pyopencl-2024.2.5.dist-info/METADATA,sha256=8a7shvaPQtnTN1WLHY1h9N2Ix-RaTV-rDwEKuBz3qhc,4671
+pyopencl-2024.2.5.dist-info/licenses/LICENSE,sha256=wiBvs-UC54bB5DswWuvB66B96b4hkYw_VLt8IR0cBPI,15284

{pyopencl-2024.2.2.dist-info → pyopencl-2024.2.5.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: skbuild 0.17.6
+Generator: scikit-build-core 0.9.5
 Root-Is-Purelib: false
 Tag: cp310-cp310-macosx_11_0_arm64
 

pyopencl-2024.2.2.data/data/CITATION.cff

@@ -1,74 +0,0 @@
-cff-version: 1.2.0
-message: "If you use this software, please cite it as below."
-authors:
-- family-names: "Kloeckner"
-  given-names: "Andreas"
-  orcid: "https://orcid.org/0000-0003-1228-519X"
-- family-names: "Yu"
-  given-names: "Yichao"
-- family-names: "Wala"
-  given-names: "Matt"
-- family-names: "Fernando"
-  given-names: "Isuru"
-- family-names: "Bencun"
-  given-names: "Marko"
-- family-names: "Kulkarni"
-  given-names: "Kaushik"
-- family-names: "Diener"
-  given-names: "Matthias"
-- family-names: "Gao"
-  given-names: "Hao"
-- family-names: "Fikl"
-  given-names: "Alex"
-- family-names: "Weiner"
-  given-names: "Zach"
-- family-names: "Weigert"
-  given-names: "Martin"
-- family-names: "Palmer"
-  given-names: "Rebecca"
-- family-names: "Latham"
-  given-names: "Shane"
-- family-names: "Magno"
-  given-names: "Gonçalo"
-- family-names: "Fuller"
-  given-names: "Henry"
-- family-names: "Mackenzie"
-  given-names: "Jonathan"
-- family-names: "Niarchos"
-  given-names: "Sotiris"
-- family-names: "Gill"
-  given-names: "Shahzaib"
-- family-names: "Gohlke"
-  given-names: "Christoph"
-- family-names: "Bhosale"
-  given-names: "Aditya"
-- family-names: "Rothberg"
-  given-names: "Alex"
-- family-names: "Ey"
-  given-names: "Emanuel"
-- family-names: "Rapp"
-  given-names: "Holger"
-- family-names: "van der Walt"
-  given-names: "Stefan"
-# Removed pending resolution of https://github.com/zenodo/zenodo/issues/2343
-# - alias: "gw0"
-- family-names: "Thalhammer"
-  given-names: "Gregor"
-- family-names: "Kieffer"
-  given-names: "Jerome"
-- family-names: "Poliarnyi"
-  given-names: "Nikolai"
-- family-names: "Bollinger"
-  given-names: "Drew"
-- family-names: "Nitz"
-  given-names: "Alex"
-- family-names: "Bokota"
-  given-names: "Grzegorz"
-  orcid: 'https://orcid.org/0000-0002-5470-1676'
-
-title: "PyOpenCL"
-version: 2022.1.3
-doi: 10.5281/zenodo.6533956
-date-released: 2022-03-10
-url: "https://github.com/inducer/pyopencl"
-license: MIT