pyopencl 2024.3__cp312-cp312-musllinux_1_2_x86_64.whl

pyopencl/cltypes.py

@@ -0,0 +1,137 @@
+__copyright__ = "Copyright (C) 2016 Jonathan Mackenzie"
+
+__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 warnings
+
+import numpy as np
+
+from pyopencl.tools import get_or_register_dtype
+
+
+if __file__.endswith("array.py"):
+    warnings.warn(
+        "pyopencl.array.vec is deprecated. Please use pyopencl.cltypes.",
+        stacklevel=2)
+
+"""
+This file provides a type mapping from OpenCl type names to their numpy equivalents
+"""
+
+char = np.int8
+uchar = np.uint8
+short = np.int16
+ushort = np.uint16
+int = np.int32
+uint = np.uint32
+long = np.int64
+ulong = np.uint64
+half = np.float16
+float = np.float32
+double = np.float64
+
+
+# {{{ vector types
+
+def _create_vector_types():
+    _mapping = [(k, globals()[k]) for k in
+                ["char", "uchar", "short", "ushort", "int",
+                 "uint", "long", "ulong", "float", "double"]]
+
+    def set_global(key, val):
+        globals()[key] = val
+
+    vec_types = {}
+    vec_type_to_scalar_and_count = {}
+
+    field_names = ["x", "y", "z", "w"]
+
+    counts = [2, 3, 4, 8, 16]
+
+    for base_name, base_type in _mapping:
+        for count in counts:
+            name = "%s%d" % (base_name, count)
+
+            titles = field_names[:count]
+
+            padded_count = count
+            if count == 3:
+                padded_count = 4
+
+            names = ["s%d" % i for i in range(count)]
+            while len(names) < padded_count:
+                names.append("padding%d" % (len(names) - count))
+
+            if len(titles) < len(names):
+                titles.extend((len(names) - len(titles)) * [None])
+
+            try:
+                dtype = np.dtype({
+                    "names": names,
+                    "formats": [base_type] * padded_count,
+                    "titles": titles})
+            except NotImplementedError:
+                try:
+                    dtype = np.dtype([((n, title), base_type)
+                                      for (n, title) in zip(names, titles)])
+                except TypeError:
+                    dtype = np.dtype([(n, base_type) for (n, title)
+                                      in zip(names, titles)])
+
+            get_or_register_dtype(name, dtype)
+
+            set_global(name, dtype)
+
+            def create_array(dtype, count, padded_count, *args, **kwargs):
+                if len(args) < count:
+                    from warnings import warn
+                    warn("default values for make_xxx are deprecated;"
+                         " instead specify all parameters or use"
+                         " cltypes.zeros_xxx",
+                         DeprecationWarning, stacklevel=4)
+
+                padded_args = tuple(list(args) + [0] * (padded_count - len(args)))
+                array = eval("array(padded_args, dtype=dtype)",
+                             {"array": np.array,
+                              "padded_args": padded_args,
+                              "dtype": dtype})
+                for key, val in list(kwargs.items()):
+                    array[key] = val
+                return array
+
+            set_global("make_" + name, eval(
+                "lambda *args, **kwargs: create_array(dtype, %i, %i, "
+                "*args, **kwargs)" % (count, padded_count),
+                {"create_array": create_array, "dtype": dtype}))
+            set_global("filled_" + name, eval(
+                "lambda val: make_%s(*[val]*%i)" % (name, count)))
+            set_global("zeros_" + name, eval("lambda: filled_%s(0)" % (name)))
+            set_global("ones_" + name, eval("lambda: filled_%s(1)" % (name)))
+
+            vec_types[np.dtype(base_type), count] = dtype
+            vec_type_to_scalar_and_count[dtype] = np.dtype(base_type), count
+
+    return vec_types, vec_type_to_scalar_and_count
+
+
+vec_types, vec_type_to_scalar_and_count = _create_vector_types()
+
+# }}}
+
+# vim: foldmethod=marker

pyopencl/compyte/.gitignore

@@ -0,0 +1,21 @@
+build
+.*.sw[po]
+.sw[po]
+*~
+*.pyc
+*.pyo
+*.egg-info
+MANIFEST
+dist
+setuptools*egg
+setuptools.pth
+distribute*egg
+distribute*tar.gz
+*.so
+*.o
+*.aux
+*.bbl
+*.blg
+*.log
+
+.cache

pyopencl/compyte/array.py

@@ -0,0 +1,214 @@
+__copyright__ = "Copyright (C) 2011 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 numpy as np
+
+
+def f_contiguous_strides(itemsize, shape):
+    if shape:
+        strides = [itemsize]
+        for s in shape[:-1]:
+            # NOTE: max(1, s) is used to handle 0-sized axes in `shape`;
+            # the stride for `shape[i] <= 1` doesn't matter, but letting it be 0
+            # is not a good idea: https://github.com/inducer/arraycontext/pull/91
+            strides.append(strides[-1]*max(1, s))
+        return tuple(strides)
+    else:
+        return ()
+
+
+def c_contiguous_strides(itemsize, shape):
+    if shape:
+        strides = [itemsize]
+        for s in shape[:0:-1]:
+            # NOTE: max(1, s) is used to handle 0-sized axes in `shape`;
+            # the stride for `shape[i] <= 1` doesn't matter, but letting it be 0
+            # is not a good idea: https://github.com/inducer/arraycontext/pull/91
+            strides.append(strides[-1]*max(1, s))
+        return tuple(strides[::-1])
+    else:
+        return ()
+
+
+def equal_strides(strides1, strides2, shape):
+    if strides1 == strides2:
+        return True
+
+    if len(strides1) != len(strides2) or len(strides2) != len(shape):
+        return False
+
+    for s, st1, st2 in zip(shape, strides1, strides2):
+        if s != 1 and st1 != st2:
+            return False
+
+    return True
+
+
+def is_f_contiguous_strides(strides, itemsize, shape):
+    from pytools import product
+    return (
+            equal_strides(strides, f_contiguous_strides(itemsize, shape), shape)
+            or product(shape) == 0)  # noqa: W503
+
+
+def is_c_contiguous_strides(strides, itemsize, shape):
+    from pytools import product
+    return (equal_strides(strides, c_contiguous_strides(itemsize, shape), shape)
+            or product(shape) == 0)  # noqa: W503
+
+
+class ArrayFlags:
+    def __init__(self, ary):
+        self.f_contiguous = is_f_contiguous_strides(
+            ary.strides, ary.dtype.itemsize, ary.shape)
+        self.c_contiguous = is_c_contiguous_strides(
+            ary.strides, ary.dtype.itemsize, ary.shape)
+        self.forc = self.f_contiguous or self.c_contiguous
+
+    def __repr__(self):
+        return (
+                f"  C_CONTIGUOUS : {self.c_contiguous}\n"
+                f"  F_CONTIGUOUS : {self.f_contiguous}"
+                )
+
+    def __str__(self):
+        return repr(self)
+
+
+def get_common_dtype(obj1, obj2, allow_double):
+    # Yes, numpy behaves differently depending on whether
+    # we're dealing with arrays or scalars.
+
+    zero1 = np.zeros(1, dtype=obj1.dtype)
+
+    try:
+        zero2 = np.zeros(1, dtype=obj2.dtype)
+    except AttributeError:
+        zero2 = obj2
+
+    result = (zero1 + zero2).dtype
+
+    if not allow_double:
+        if result == np.float64:
+            result = np.dtype(np.float32)
+        elif result == np.complex128:
+            result = np.dtype(np.complex64)
+
+    return result
+
+
+def bound(a):
+    high = a.bytes
+    low = a.bytes
+
+    for stri, shp in zip(a.strides, a.shape):
+        if stri < 0:
+            low += (stri)*(shp-1)
+        else:
+            high += (stri)*(shp-1)
+    return low, high
+
+
+def may_share_memory(a, b):
+    # When this is called with a an ndarray and b
+    # a sparse matrix, numpy.may_share_memory fails.
+    if a is b:
+        return True
+    if a.__class__ is b.__class__:
+        a_l, a_h = bound(a)
+        b_l, b_h = bound(b)
+        if b_l >= a_h or a_l >= b_h:
+            return False
+        return True
+    else:
+        return False
+
+
+# {{{ as_strided implementation
+
+try:
+    from numpy.lib.stride_tricks import as_strided as _as_strided
+    _test_dtype = np.dtype(
+            [("a", np.float64), ("b", np.float64)], align=True)
+    _test_result = _as_strided(np.zeros(10, dtype=_test_dtype))
+    if _test_result.dtype != _test_dtype:
+        raise RuntimeError("numpy's as_strided is broken")
+
+    as_strided = _as_strided
+except Exception:
+    # stolen from numpy to be compatible with older versions of numpy
+    class _DummyArray:
+        """ Dummy object that just exists to hang __array_interface__ dictionaries
+        and possibly keep alive a reference to a base array.
+        """
+        def __init__(self, interface, base=None):
+            self.__array_interface__ = interface
+            self.base = base
+
+    def as_strided(x, shape=None, strides=None):
+        """ Make an ndarray from the given array with the given shape and strides.
+        """
+        # work around Numpy bug 1873 (reported by Irwin Zaid)
+        # Since this is stolen from numpy, this implementation has the same bug.
+        # http://projects.scipy.org/numpy/ticket/1873
+        # == https://github.com/numpy/numpy/issues/2466
+
+        # Do not recreate the array if nothing need to be changed.
+        # This fixes a lot of errors on pypy since DummyArray hack does not
+        # currently (2014/May/17) on pypy.
+
+        if ((shape is None or x.shape == shape)
+                and (strides is None or x.strides == strides)):  # noqa: W503
+            return x
+        if not x.dtype.isbuiltin:
+            if shape is None:
+                shape = x.shape
+            strides = tuple(strides)
+
+            from pytools import product
+            if strides is not None and shape is not None \
+                    and product(shape) == product(x.shape) \
+                    and x.flags.forc:
+                # Workaround: If we're being asked to do what amounts to a
+                # contiguous reshape, at least do that.
+
+                if strides == f_contiguous_strides(x.dtype.itemsize, shape):
+                    result = x.reshape(-1).reshape(*shape, order="F")
+                    assert result.strides == strides
+                    return result
+                elif strides == c_contiguous_strides(x.dtype.itemsize, shape):
+                    result = x.reshape(-1).reshape(*shape, order="C")
+                    assert result.strides == strides
+                    return result
+
+            raise NotImplementedError(
+                    "as_strided won't work on non-builtin arrays for now. "
+                    "See https://github.com/numpy/numpy/issues/2466")
+
+        interface = dict(x.__array_interface__)
+        if shape is not None:
+            interface["shape"] = tuple(shape)
+        if strides is not None:
+            interface["strides"] = tuple(strides)
+        return np.asarray(_DummyArray(interface, base=x))
+
+# }}}

pyopencl/compyte/dtypes.py

@@ -0,0 +1,290 @@
+"""Type mapping helpers."""
+
+
+__copyright__ = "Copyright (C) 2011 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 numpy as np
+
+
+class TypeNameNotKnown(RuntimeError):  # noqa: N818
+    pass
+
+
+# {{{ registry
+
+class DTypeRegistry:
+    def __init__(self):
+        self.dtype_to_name = {}
+        self.name_to_dtype = {}
+
+    def get_or_register_dtype(self, c_names, dtype=None):
+        """Get or register a :class:`numpy.dtype` associated with the C type names
+        in the string list *c_names*. If *dtype* is `None`, no registration is
+        performed, and the :class:`numpy.dtype` must already have been registered.
+        If so, it is returned.  If not, :exc:`TypeNameNotKnown` is raised.
+
+        If *dtype* is not `None`, registration is attempted. If the *c_names* are
+        already known and registered to identical :class:`numpy.dtype` objects,
+        then the previously dtype object of the previously  registered type is
+        returned. If the *c_names* are not yet known, the type is registered. If
+        one of the *c_names* is known but registered to a different type, an error
+        is raised. In this latter case, the type may end up partially registered
+        and any further behavior is undefined.
+
+        .. versionadded:: 2012.2
+        """
+
+        if isinstance(c_names, str):
+            c_names = [c_names]
+
+        if dtype is None:
+            from pytools import single_valued
+            return single_valued(self.name_to_dtype[name] for name in c_names)
+
+        dtype = np.dtype(dtype)
+
+        # check if we've seen an identical dtype, if so retrieve exact dtype object.
+        try:
+            existing_name = self.dtype_to_name[dtype]
+        except KeyError:
+            existed = False
+        else:
+            existed = True
+            existing_dtype = self.name_to_dtype[existing_name]
+            assert existing_dtype == dtype
+            dtype = existing_dtype
+
+        for nm in c_names:
+            try:
+                name_dtype = self.name_to_dtype[nm]
+            except KeyError:
+                self.name_to_dtype[nm] = dtype
+            else:
+                if name_dtype != dtype:
+                    raise RuntimeError("name '%s' already registered to "
+                            "different dtype" % nm)
+
+        if not existed:
+            self.dtype_to_name[dtype] = c_names[0]
+        if str(dtype) not in self.dtype_to_name:
+            self.dtype_to_name[str(dtype)] = c_names[0]
+
+        return dtype
+
+    def dtype_to_ctype(self, dtype):
+        if dtype is None:
+            raise ValueError("dtype may not be None")
+
+        dtype = np.dtype(dtype)
+
+        try:
+            return self.dtype_to_name[dtype]
+        except KeyError:
+            raise ValueError("unable to map dtype '%s'" % dtype) from None
+
+# }}}
+
+
+# {{{ C types
+
+def fill_registry_with_c_types(reg, respect_windows, include_bool=True):
+    import struct
+    from sys import platform
+
+    if include_bool:
+        # bool is of unspecified size in the OpenCL spec and may in fact be
+        # 4-byte.
+        reg.get_or_register_dtype("bool", np.bool_)
+
+    reg.get_or_register_dtype(["signed char", "char"], np.int8)
+    reg.get_or_register_dtype("unsigned char", np.uint8)
+    reg.get_or_register_dtype(["short", "signed short",
+        "signed short int", "short signed int"], np.int16)
+    reg.get_or_register_dtype(["unsigned short",
+        "unsigned short int", "short unsigned int"], np.uint16)
+    reg.get_or_register_dtype(["int", "signed int"], np.int32)
+    reg.get_or_register_dtype(["unsigned", "unsigned int"], np.uint32)
+
+    is_64_bit = struct.calcsize("@P") * 8 == 64
+    if is_64_bit:
+        if "win32" in platform and respect_windows:
+            i64_name = "long long"
+        else:
+            i64_name = "long"
+
+        reg.get_or_register_dtype(
+                [i64_name, "%s int" % i64_name, "signed %s int" % i64_name,
+                    "%s signed int" % i64_name],
+                np.int64)
+        reg.get_or_register_dtype(
+                ["unsigned %s" % i64_name, "unsigned %s int" % i64_name,
+                    "%s unsigned int" % i64_name],
+                np.uint64)
+
+    # http://projects.scipy.org/numpy/ticket/2017
+    if is_64_bit:
+        reg.get_or_register_dtype(["unsigned %s" % i64_name], np.uintp)
+    else:
+        reg.get_or_register_dtype(["unsigned"], np.uintp)
+
+    reg.get_or_register_dtype("float", np.float32)
+    reg.get_or_register_dtype("double", np.float64)
+
+
+def fill_registry_with_opencl_c_types(reg):
+    reg.get_or_register_dtype(["char", "signed char"], np.int8)
+    reg.get_or_register_dtype(["uchar", "unsigned char"], np.uint8)
+    reg.get_or_register_dtype(["short", "signed short",
+        "signed short int", "short signed int"], np.int16)
+    reg.get_or_register_dtype(["ushort", "unsigned short",
+        "unsigned short int", "short unsigned int"], np.uint16)
+    reg.get_or_register_dtype(["int", "signed int"], np.int32)
+    reg.get_or_register_dtype(["uint", "unsigned", "unsigned int"], np.uint32)
+
+    reg.get_or_register_dtype(
+            ["long", "long int", "signed long int",
+                "long signed int"],
+            np.int64)
+    reg.get_or_register_dtype(
+            ["ulong", "unsigned long", "unsigned long int",
+                "long unsigned int"],
+            np.uint64)
+
+    reg.get_or_register_dtype(["intptr_t"], np.intp)
+    reg.get_or_register_dtype(["uintptr_t"], np.uintp)
+
+    reg.get_or_register_dtype("float", np.float32)
+    reg.get_or_register_dtype("double", np.float64)
+
+
+def fill_registry_with_c99_stdint_types(reg):
+    reg.get_or_register_dtype("bool", np.bool_)
+
+    reg.get_or_register_dtype("int8_t", np.int8)
+    reg.get_or_register_dtype("uint8_t", np.uint8)
+    reg.get_or_register_dtype("int16_t", np.int16)
+    reg.get_or_register_dtype("uint16_t", np.uint16)
+    reg.get_or_register_dtype("int32_t", np.int32)
+    reg.get_or_register_dtype("uint32_t", np.uint32)
+    reg.get_or_register_dtype("int64_t", np.int64)
+    reg.get_or_register_dtype("uint64_t", np.uint64)
+    reg.get_or_register_dtype("uintptr_t", np.uintp)
+
+    reg.get_or_register_dtype("float", np.float32)
+    reg.get_or_register_dtype("double", np.float64)
+
+
+def fill_registry_with_c99_complex_types(reg):
+    reg.get_or_register_dtype("float complex", np.complex64)
+    reg.get_or_register_dtype("double complex", np.complex128)
+    reg.get_or_register_dtype("long double complex", np.clongdouble)
+
+# }}}
+
+
+# {{{ backward compatibility
+
+TYPE_REGISTRY = DTypeRegistry()
+
+# These are deprecated and should no longer be used
+DTYPE_TO_NAME = TYPE_REGISTRY.dtype_to_name
+NAME_TO_DTYPE = TYPE_REGISTRY.name_to_dtype
+
+dtype_to_ctype = TYPE_REGISTRY.dtype_to_ctype
+get_or_register_dtype = TYPE_REGISTRY.get_or_register_dtype
+
+
+def _fill_dtype_registry(respect_windows, include_bool=True):
+    fill_registry_with_c_types(
+            TYPE_REGISTRY, respect_windows, include_bool)
+
+# }}}
+
+
+# {{{ c declarator parsing
+
+def parse_c_arg_backend(c_arg, scalar_arg_factory, vec_arg_factory,
+        name_to_dtype=None):
+    if isinstance(name_to_dtype, DTypeRegistry):
+        name_to_dtype = name_to_dtype.name_to_dtype__getitem__
+    elif name_to_dtype is None:
+        name_to_dtype = NAME_TO_DTYPE.__getitem__
+
+    c_arg = (c_arg
+            .replace("const", "")
+            .replace("volatile", "")
+            .replace("__restrict__", "")
+            .replace("restrict", ""))
+
+    # process and remove declarator
+    import re
+    decl_re = re.compile(r"(\**)\s*([_a-zA-Z0-9]+)(\s*\[[ 0-9]*\])*\s*$")
+    decl_match = decl_re.search(c_arg)
+
+    if decl_match is None:
+        raise ValueError("couldn't parse C declarator '%s'" % c_arg)
+
+    name = decl_match.group(2)
+
+    if decl_match.group(1) or decl_match.group(3) is not None:
+        arg_class = vec_arg_factory
+    else:
+        arg_class = scalar_arg_factory
+
+    tp = c_arg[:decl_match.start()]
+    tp = " ".join(tp.split())
+
+    try:
+        dtype = name_to_dtype(tp)
+    except KeyError:
+        raise ValueError("unknown type '%s'" % tp) from None
+
+    return arg_class(dtype, name)
+
+# }}}
+
+
+def register_dtype(dtype, c_names, alias_ok=False):
+    from warnings import warn
+    warn("register_dtype is deprecated. Use get_or_register_dtype instead.",
+            DeprecationWarning, stacklevel=2)
+
+    if isinstance(c_names, str):
+        c_names = [c_names]
+
+    dtype = np.dtype(dtype)
+
+    # check if we've seen this dtype before and error out if a) it was seen before
+    # and b) alias_ok is False.
+
+    if not alias_ok and dtype in TYPE_REGISTRY.dtype_to_name:
+        raise RuntimeError("dtype '%s' already registered (as '%s', new names '%s')"
+                % (dtype, TYPE_REGISTRY.dtype_to_name[dtype], ", ".join(c_names)))
+
+    TYPE_REGISTRY.get_or_register_dtype(c_names, dtype)
+
+
+# vim: foldmethod=marker