pyopencl 2026.1.1__cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl

pyopencl/cltypes.py

@@ -0,0 +1,217 @@
+from __future__ import annotations
+
+
+__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
+from typing import TYPE_CHECKING, Any, cast
+
+import numpy as np
+
+from pyopencl.tools import get_or_register_dtype
+
+
+if TYPE_CHECKING:
+    import builtins
+    from collections.abc import MutableSequence
+
+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() -> tuple[
+        dict[tuple[np.dtype[Any], builtins.int], np.dtype[Any]],
+        dict[np.dtype[Any], tuple[np.dtype[Any], builtins.int]]]:
+    mapping = [(k, globals()[k]) for k in
+                ["char", "uchar", "short", "ushort", "int",
+                 "uint", "long", "ulong", "float", "double"]]
+
+    def set_global(key: str, val: np.dtype[Any]) -> None:
+        globals()[key] = val
+
+    vec_types: dict[tuple[np.dtype[Any], builtins.int], np.dtype[Any]] = {}
+    vec_type_to_scalar_and_count: dict[np.dtype[Any],
+                                       tuple[np.dtype[Any], builtins.int]] = {}
+
+    field_names = ["x", "y", "z", "w"]
+
+    counts = [2, 3, 4, 8, 16]
+
+    for base_name, base_type in mapping:
+        for count in counts:
+            name = f"{base_name}{count}"
+            titles = cast("MutableSequence[str | None]", field_names[:count])
+
+            padded_count = count
+            if count == 3:
+                padded_count = 4
+
+            names = [f"s{i}" for i in range(count)]
+            while len(names) < padded_count:
+                pad = len(names) - count
+                names.append(f"padding{pad}")
+
+            if len(titles) < len(names):
+                pad = len(names) - len(titles)
+                titles.extend([None] * pad)
+
+            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, strict=True)])
+                except TypeError:
+                    dtype = np.dtype([(n, base_type) for n in names])
+
+            assert isinstance(dtype, np.dtype)
+            get_or_register_dtype(name, dtype)
+            set_global(name, dtype)
+
+            def create_array(dtype: np.dtype[Any],
+                             count: int,
+                             padded_count: int,
+                             *args: Any, **kwargs: Any) -> dict[str, Any]:
+                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 kwargs.items():
+                    array[key] = val
+
+                return array
+
+            set_global(
+                f"make_{name}",
+                eval("lambda *args, **kwargs: "
+                     f"create_array(dtype, {count}, {padded_count}, *args, **kwargs)",
+                     {"create_array": create_array, "dtype": dtype}))
+            set_global(
+                f"filled_{name}",
+                eval(f"lambda val: make_{name}(*[val]*{count})"))
+            set_global(f"zeros_{name}", eval(f"lambda: filled_{name}(0)"))
+            set_global(f"ones_{name}", eval(f"lambda: filled_{name}(1)"))
+
+            base_dtype = np.dtype(base_type)
+            vec_types[base_dtype, count] = dtype
+            vec_type_to_scalar_and_count[dtype] = base_dtype, count
+
+    return vec_types, vec_type_to_scalar_and_count
+
+
+vec_types, vec_type_to_scalar_and_count = _create_vector_types()
+
+# }}}
+
+char2: np.dtype[Any]
+char3: np.dtype[Any]
+char4: np.dtype[Any]
+char8: np.dtype[Any]
+char16: np.dtype[Any]
+
+uchar2: np.dtype[Any]
+uchar3: np.dtype[Any]
+uchar4: np.dtype[Any]
+uchar8: np.dtype[Any]
+uchar16: np.dtype[Any]
+
+short2: np.dtype[Any]
+short3: np.dtype[Any]
+short4: np.dtype[Any]
+short8: np.dtype[Any]
+short16: np.dtype[Any]
+
+ushort2: np.dtype[Any]
+ushort3: np.dtype[Any]
+ushort4: np.dtype[Any]
+ushort8: np.dtype[Any]
+ushort16: np.dtype[Any]
+
+int2: np.dtype[Any]
+int3: np.dtype[Any]
+int4: np.dtype[Any]
+int8: np.dtype[Any]
+int16: np.dtype[Any]
+
+uint2: np.dtype[Any]
+uint3: np.dtype[Any]
+uint4: np.dtype[Any]
+uint8: np.dtype[Any]
+uint16: np.dtype[Any]
+
+long2: np.dtype[Any]
+long3: np.dtype[Any]
+long4: np.dtype[Any]
+long8: np.dtype[Any]
+long16: np.dtype[Any]
+
+ulong2: np.dtype[Any]
+ulong3: np.dtype[Any]
+ulong4: np.dtype[Any]
+ulong8: np.dtype[Any]
+ulong16: np.dtype[Any]
+
+float2: np.dtype[Any]
+float3: np.dtype[Any]
+float4: np.dtype[Any]
+float8: np.dtype[Any]
+float16: np.dtype[Any]
+
+double2: np.dtype[Any]
+double3: np.dtype[Any]
+double4: np.dtype[Any]
+double8: np.dtype[Any]
+double16: np.dtype[Any]
+
+# 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,211 @@
+__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.
+"""
+
+from typing import Any, Protocol
+
+import numpy as np
+from typing_extensions import override
+
+
+def f_contiguous_strides(itemsize: int, shape: tuple[int, ...]) -> tuple[int, ...]:
+    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: int, shape: tuple[int, ...]) -> tuple[int, ...]:
+    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: tuple[int, ...],
+            strides2: tuple[int, ...],
+            shape: tuple[int, ...]
+        ) -> bool:
+    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, strict=True):
+        if s != 1 and st1 != st2:
+            return False
+
+    return True
+
+
+def is_f_contiguous_strides(
+            strides: tuple[int, ...],
+            itemsize: int,
+            shape: tuple[int, ...]
+        ) -> bool:
+    from pytools import product
+    return (
+            equal_strides(strides, f_contiguous_strides(itemsize, shape), shape)
+            or product(shape) == 0)
+
+
+def is_c_contiguous_strides(
+            strides: tuple[int, ...],
+            itemsize: int,
+            shape: tuple[int, ...]
+        ) -> bool:
+    from pytools import product
+    return (equal_strides(strides, c_contiguous_strides(itemsize, shape), shape)
+            or product(shape) == 0)
+
+
+class ArrayIsh(Protocol):
+    shape: tuple[int, ...]
+    strides: tuple[int, ...]
+    dtype: np.dtype[Any]
+
+
+class ArrayFlags:
+    def __init__(self, ary: ArrayIsh) -> None:
+        self.f_contiguous: bool = is_f_contiguous_strides(
+            ary.strides, ary.dtype.itemsize, ary.shape)
+        self.c_contiguous: bool = is_c_contiguous_strides(
+            ary.strides, ary.dtype.itemsize, ary.shape)
+        self.forc: bool = self.f_contiguous or self.c_contiguous
+
+    @override
+    def __repr__(self) -> str:
+        return (
+                f"  C_CONTIGUOUS : {self.c_contiguous}\n"
+                f"  F_CONTIGUOUS : {self.f_contiguous}"
+                )
+
+    @override
+    def __str__(self) -> str:
+        return repr(self)
+
+
+def get_common_dtype(obj1: ArrayIsh, obj2: ArrayIsh,
+                     allow_double: bool) -> np.dtype[Any]:
+    # 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
+
+
+# {{{ 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)):
+            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))
+
+# }}}