pyopencl 2024.2.2__cp311-cp311-macosx_11_0_arm64.whl → 2024.2.4__cp311-cp311-macosx_11_0_arm64.whl

pyopencl-2024.2.2.data/data/contrib/pyopencl.vim

@@ -1,84 +0,0 @@
-" Vim highlighting for PyOpenCL
-" -----------------------------
-"
-" (C) Andreas Kloeckner 2011, MIT license
-"
-" Uses parts of mako.vim by Armin Ronacher.
-"
-" Installation:
-" Just drop this file into ~/.vim/syntax/pyopencl.vim
-"
-" Then do 
-" :set filetype=pyopencl
-" and use 
-" """//CL// ...code..."""
-" for OpenCL code included in your Python file.
-"
-" You may also include a line
-" vim: filetype=pyopencl.python
-" at the end of your file to set the file type automatically.
-"
-" Optional: Install opencl.vim from
-" http://www.vim.org/scripts/script.php?script_id=3157
-
-runtime! syntax/python.vim
-
-unlet b:current_syntax
-try
-  syntax include @clCode syntax/opencl.vim
-catch
-  syntax include @clCode syntax/c.vim
-endtry
-
-unlet b:current_syntax
-syn include @pythonTop syntax/python.vim
-
-" {{{ mako
-
-syn region clmakoLine start="^\s*%" skip="\\$" end="$"
-syn region clmakoVariable start=#\${# end=#}# contains=@pythonTop
-syn region clmakoBlock start=#<%!# end=#%># keepend contains=@pythonTop
-
-syn match clmakoAttributeKey containedin=clmakoTag contained "[a-zA-Z_][a-zA-Z0-9_]*="
-syn region clmakoAttributeValue containedin=clmakoTag contained start=/"/ skip=/\\"/ end=/"/
-syn region clmakoAttributeValue containedin=clmakoTag contained start=/'/ skip=/\\'/ end=/'/
-
-syn region clmakoTag start="</\?%\(def\|call\|page\|include\|namespace\|inherit\|self:[_[:alnum:]]\+\)\>" end="/\?>"
-
-" The C highlighter's paren error detection screws up highlighting of 
-" Mako variables in C parens--turn it off.
-
-syn clear cParen
-syn clear cParenError
-if !exists("c_no_bracket_error")
-  syn clear cBracket
-endif
-
-syn cluster clmakoCode contains=clmakoLine,clmakoVariable,clmakoBlock,clmakoTag
-
-hi link clmakoLine Preproc
-hi link clmakoVariable Preproc
-hi link clmakoBlock Preproc
-hi link clmakoTag Define
-hi link clmakoAttributeKey String
-hi link clmakoAttributeValue String
-
-" }}}
-
-syn region pythonCLString
-      \ start=+[uU]\=\z('''\|"""\)//CL\(:[a-zA-Z_0-9]\+\)\?//+ end="\z1" keepend
-      \ contains=@clCode,@clmakoCode
-
-syn region pythonCLRawString
-      \ start=+[uU]\=[rR]\z('''\|"""\)//CL\(:[a-zA-Z_0-9]\+\)\?//+ end="\z1" keepend
-      \ contains=@clCode,@clmakoCode
-
-" Uncomment if you still want the code highlighted as a string.
-" hi link pythonCLString String
-" hi link pythonCLRawString String
-
-syntax sync fromstart
-
-let b:current_syntax = "pyopencl"
-
-" vim: foldmethod=marker

pyopencl-2024.2.2.data/data/doc/Makefile

@@ -1,23 +0,0 @@
-# Minimal makefile for Sphinx documentation
-#
-
-# You can set these variables from the command line, and also
-# from the environment for the first two.
-SPHINXOPTS    ?= -W -n
-SPHINXBUILD   ?= python $(shell which sphinx-build)
-SOURCEDIR     = .
-BUILDDIR      = _build
-
-# Put it first so that "make" without argument is like "make help".
-help:
-	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
-
-constants:
-	python make_constants.py > constants.inc
-
-.PHONY: help Makefile
-
-# Catch-all target: route all unknown targets to Sphinx using the new
-# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
-%: Makefile constants
-	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)

pyopencl-2024.2.2.data/data/doc/algorithm.rst

@@ -1,214 +0,0 @@
-Parallel Algorithms
-===================
-
-.. include:: subst.rst
-
-Element-wise expression evaluation ("map")
-------------------------------------------
-
-.. module:: pyopencl.elementwise
-
-Evaluating involved expressions on :class:`pyopencl.array.Array` instances by
-using overloaded operators can be somewhat inefficient, because a new temporary
-is created for each intermediate result. The functionality in the module
-:mod:`pyopencl.elementwise` contains tools to help generate kernels that
-evaluate multi-stage expressions on one or several operands in a single pass.
-
-.. autoclass:: ElementwiseKernel
-
-Here's a usage example:
-
-.. literalinclude:: ../examples/demo_elementwise.py
-
-(You can find this example as
-:download:`examples/demo_elementwise.py <../examples/demo_elementwise.py>`
-in the PyOpenCL distribution.)
-
-.. _custom-reductions:
-
-Sums and counts ("reduce")
---------------------------
-
-.. module:: pyopencl.reduction
-
-.. autoclass:: ReductionKernel
-
-Here's a usage example::
-
-    a = pyopencl.array.arange(queue, 400, dtype=numpy.float32)
-    b = pyopencl.array.arange(queue, 400, dtype=numpy.float32)
-
-    krnl = ReductionKernel(ctx, numpy.float32, neutral="0",
-            reduce_expr="a+b", map_expr="x[i]*y[i]",
-            arguments="__global float *x, __global float *y")
-
-    my_dot_prod = krnl(a, b).get()
-
-.. _custom-scan:
-
-Prefix Sums ("scan")
---------------------
-
-.. module:: pyopencl.scan
-
-.. |scan_extra_args| replace:: a list of tuples *(name, value)* specifying
-    extra arguments to pass to the scan procedure. For version 2013.1,
-    *value* must be a of a :mod:`numpy` sized scalar type. As of version 2013.2,
-    *value* may also be a :class:`pyopencl.array.Array`.
-.. |preamble| replace:: A snippet of C that is inserted into the compiled kernel
-    before the actual kernel function. May be used for, e.g. type definitions
-    or include statements.
-
-A prefix sum is a running sum of an array, as provided by
-e.g. :func:`numpy.cumsum`::
-
-    >>> import numpy as np
-    >>> a = [1,1,1,1,1,2,2,2,2,2]
-    >>> np.cumsum(a)
-    array([ 1,  2,  3,  4,  5,  7,  9, 11, 13, 15])
-
-This is a very simple example of what a scan can do. It turns out that scans
-are significantly more versatile. They are a basic building block of many
-non-trivial parallel algorithms. Many of the operations enabled by scans seem
-difficult to parallelize because of loop-carried dependencies.
-
-.. seealso::
-
-    `Prefix sums and their applications <https://doi.org/10.1184/R1/6608579.v1>`__, by Guy Blelloch.
-        This article gives an overview of some surprising applications of scans.
-
-    :ref:`predefined-scans`
-        These operations built into PyOpenCL are realized using
-        :class:`GenericScanKernel`.
-
-Usage Example
-^^^^^^^^^^^^^
-
-This example illustrates the implementation of a simplified version of
-:func:`pyopencl.algorithm.copy_if`,
-which copies integers from an array into the (variable-size) output if they are
-greater than 300::
-
-    knl = GenericScanKernel(
-            ctx, np.int32,
-            arguments="__global int *ary, __global int *out",
-            input_expr="(ary[i] > 300) ? 1 : 0",
-            scan_expr="a+b", neutral="0",
-            output_statement="""
-                if (prev_item != item) out[item-1] = ary[i];
-                """)
-
-    out = a.copy()
-    knl(a, out)
-
-    a_host = a.get()
-    out_host = a_host[a_host > 300]
-
-    assert (out_host == out.get()[:len(out_host)]).all()
-
-The value being scanned over is a number of flags indicating whether each array
-element is greater than 300. These flags are computed by *input_expr*. The
-prefix sum over this array gives a running count of array items greater than
-300. The *output_statement* the compares ``prev_item`` (the previous item's scan
-result, i.e. index) to ``item`` (the current item's scan result, i.e.
-index). If they differ, i.e. if the predicate was satisfied at this
-position, then the item is stored in the output at the computed index.
-
-This example does not make use of the following advanced features also available
-in PyOpenCL:
-
-* Segmented scans
-
-* Access to the previous item in *input_expr* (e.g. for comparisons)
-  See the `implementation <https://github.com/inducer/pyopencl/blob/36afe57784368e8d2505bc7cad8df964ba3c0264/pyopencl/algorithm.py#L226>`__
-  of :func:`pyopencl.algorithm.unique` for an example.
-
-Making Custom Scan Kernels
-^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-.. versionadded:: 2013.1
-
-.. autoclass:: GenericScanKernel
-
-Debugging aids
-~~~~~~~~~~~~~~
-
-.. autoclass:: GenericDebugScanKernel
-
-.. _predefined-scans:
-
-Simple / Legacy Interface
-^^^^^^^^^^^^^^^^^^^^^^^^^
-
-.. class:: ExclusiveScanKernel(ctx, dtype, scan_expr, neutral, name_prefix="scan", options=[], preamble="", devices=None)
-
-    Generates a kernel that can compute a `prefix sum
-    <https://en.wikipedia.org/wiki/Prefix_sum>`__
-    using any associative operation given as *scan_expr*.
-    *scan_expr* uses the formal values "a" and "b" to indicate two operands of
-    an associative binary operation. *neutral* is the neutral element
-    of *scan_expr*, obeying *scan_expr(a, neutral) == a*.
-
-    *dtype* specifies the type of the arrays being operated on.
-    *name_prefix* is used for kernel names to ensure recognizability
-    in profiles and logs. *options* is a list of compiler options to use
-    when building. *preamble* specifies a string of code that is
-    inserted before the actual kernels. *devices* may be used to restrict
-    the set of devices on which the kernel is meant to run. (defaults
-    to all devices in the context *ctx*.
-
-    .. method:: __call__(self, input_ary, output_ary=None, allocator=None, queue=None)
-
-.. class:: InclusiveScanKernel(ctx, dtype, scan_expr, neutral=None, name_prefix="scan", options=[], preamble="", devices=None)
-
-    Works like :class:`ExclusiveScanKernel`.
-
-    .. versionchanged:: 2013.1
-        *neutral* is now always required.
-
-For the array ``[1, 2, 3]``, inclusive scan results in ``[1, 3, 6]``, and exclusive
-scan results in ``[0, 1, 3]``.
-
-Here's a usage example::
-
-    knl = InclusiveScanKernel(context, np.int32, "a+b")
-
-    n = 2**20-2**18+5
-    rng = np.random.default_rng(seed=42)
-    host_data = rng.integers(0, 10, size=n, dtype=np.int32)
-    dev_data = cl_array.to_device(queue, host_data)
-
-    knl(dev_data)
-    assert (dev_data.get() == np.cumsum(host_data, axis=0)).all()
-
-Predicated copies ("partition", "unique", ...)
-----------------------------------------------
-
-.. module:: pyopencl.algorithm
-
-.. autofunction:: copy_if
-
-.. autofunction:: remove_if
-
-.. autofunction:: partition
-
-.. autofunction:: unique
-
-Sorting (radix sort)
---------------------
-
-.. autoclass:: RadixSort
-
-    .. automethod:: __call__
-
-Building many variable-size lists
----------------------------------
-
-.. autoclass:: ListOfListsBuilder
-
-Bitonic Sort
-------------
-
-.. module:: pyopencl.bitonic_sort
-
-.. autoclass:: BitonicSort

pyopencl-2024.2.2.data/data/doc/array.rst

@@ -1,305 +0,0 @@
-Multi-dimensional arrays
-========================
-
-.. module:: pyopencl.array
-
-The functionality in this module provides something of a work-alike for
-:mod:`numpy` arrays, but with all operations executed on the CL compute device.
-
-Data Types
-----------
-
-PyOpenCL provides some amount of integration between the :mod:`numpy`
-type system, as represented by :class:`numpy.dtype`, and the types
-available in OpenCL. All the simple scalar types map straightforwardly
-to their CL counterparts.
-
-.. _vector-types:
-
-Vector Types
-^^^^^^^^^^^^
-
-.. class :: vec
-
-    All of OpenCL's supported vector types, such as ``float3`` and ``long4`` are
-    available as :mod:`numpy` data types within this class. These
-    :class:`numpy.dtype` instances have field names of ``x``, ``y``, ``z``, and ``w``
-    just like their OpenCL counterparts. They will work both for parameter passing
-    to kernels as well as for passing data back and forth between kernels and
-    Python code. For each type, a ``make_type`` function is also provided (e.g.
-    ``make_float3(x, y, z)``).
-
-    If you want to construct a pre-initialized vector type you have three new
-    functions to choose from:
-
-    * ``zeros_type()``
-    * ``ones_type()``
-    * ``filled_type(fill_value)``
-
-    .. versionadded:: 2014.1
-
-    .. versionchanged:: 2014.1
-
-        The ``make_type`` functions have a default value (0) for each component.
-        Relying on the default values has been deprecated. Either specify all
-        components or use one of th new flavors mentioned above for constructing
-        a vector.
-
-Custom data types
-^^^^^^^^^^^^^^^^^
-
-If you would like to use your own (struct/union/whatever) data types in array
-operations where you supply operation source code, define those types in the
-*preamble* passed to :class:`pyopencl.elementwise.ElementwiseKernel`,
-:class:`pyopencl.reduction.ReductionKernel` (or similar), and let PyOpenCL know
-about them using this function:
-
-.. currentmodule:: pyopencl.tools
-
-.. autofunction:: get_or_register_dtype
-
-.. exception:: TypeNameNotKnown
-
-    .. versionadded:: 2013.1
-
-.. function:: register_dtype(dtype, name)
-
-    .. versionchanged:: 2013.1
-        This function has been deprecated. It is recommended that you develop
-        against the new interface, :func:`get_or_register_dtype`.
-
-.. function:: dtype_to_ctype(dtype)
-
-    Returns a C name registered for *dtype*.
-
-    .. versionadded: 2013.1
-
-This function helps with producing C/OpenCL declarations for structured
-:class:`numpy.dtype` instances:
-
-.. autofunction:: match_dtype_to_c_struct
-
-A more complete example of how to use custom structured types can be
-found in :file:`examples/demo-struct-reduce.py` in the PyOpenCL
-distribution.
-
-.. currentmodule:: pyopencl.array
-
-Complex Numbers
-^^^^^^^^^^^^^^^
-
-PyOpenCL's :class:`Array` type supports complex numbers out of the box, by
-simply using the corresponding :mod:`numpy` types.
-
-If you would like to use this support in your own kernels, here's how to
-proceed: Since OpenCL 1.2 (and earlier) do not specify native complex number
-support, PyOpenCL works around that deficiency. By saying::
-
-    #include <pyopencl-complex.h>
-
-in your kernel, you get complex types ``cfloat_t`` and ``cdouble_t``, along with
-functions defined on them such as ``cfloat_mul(a, b)`` or ``cdouble_log(z)``.
-Elementwise kernels automatically include the header if your kernel has
-complex input or output.
-See the `source file
-<https://github.com/inducer/pyopencl/blob/main/pyopencl/cl/pyopencl-complex.h>`__
-for a precise list of what's available.
-
-If you need double precision support, please::
-
-    #define PYOPENCL_DEFINE_CDOUBLE
-
-before including the header, as DP support apparently cannot be reliably
-autodetected.
-
-Under the hood, the complex types are struct types as defined in the header.
-Ideally, you should only access the structs through the provided functions,
-never directly.
-
-.. versionadded:: 2012.1
-
-.. versionchanged:: 2015.2
-
-    **[INCOMPATIBLE]** Changed PyOpenCL's complex numbers from ``float2`` and
-    ``double2`` OpenCL vector types to custom ``struct``. This was changed
-    because it very easily introduced bugs where
-
-    * complex*complex
-    * real+complex
-
-    *look* like they may do the right thing, but silently do the wrong thing.
-
-The :class:`Array` Class
-------------------------
-
-.. autoclass:: Array
-
-.. autoexception:: ArrayHasOffsetError
-
-Constructing :class:`Array` Instances
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-.. autofunction:: to_device
-.. function:: empty(queue, shape, dtype, order="C", allocator=None, data=None)
-
-    A synonym for the :class:`Array` constructor.
-
-.. autofunction:: zeros
-.. autofunction:: empty_like
-.. autofunction:: zeros_like
-.. autofunction:: arange
-.. autofunction:: take
-.. autofunction:: concatenate
-.. autofunction:: stack
-
-Manipulating :class:`Array` instances
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-.. autofunction:: transpose
-.. autofunction:: reshape
-
-Conditionals
-^^^^^^^^^^^^
-
-.. autofunction:: if_positive
-.. autofunction:: maximum
-.. autofunction:: minimum
-
-Logical Operations
-^^^^^^^^^^^^^^^^^^
-
-.. autofunction:: logical_and
-.. autofunction:: logical_or
-.. autofunction:: logical_not
-
-.. _reductions:
-
-Reductions
-^^^^^^^^^^
-
-.. autofunction:: sum
-.. autofunction:: all
-.. autofunction:: any
-.. autofunction:: dot
-.. autofunction:: vdot
-.. autofunction:: subset_dot
-.. autofunction:: max
-.. autofunction:: min
-.. autofunction:: subset_max
-.. autofunction:: subset_min
-
-See also :ref:`custom-reductions`.
-
-Elementwise Functions on :class:`Array` Instances
--------------------------------------------------
-
-.. module:: pyopencl.clmath
-
-The :mod:`pyopencl.clmath` module contains exposes array versions of the C
-functions available in the OpenCL standard. (See table 6.8 in the spec.)
-
-.. function:: acos(array, queue=None)
-.. function:: acosh(array, queue=None)
-.. function:: acospi(array, queue=None)
-
-.. function:: asin(array, queue=None)
-.. function:: asinh(array, queue=None)
-.. function:: asinpi(array, queue=None)
-
-.. function:: atan(array, queue=None)
-.. autofunction:: atan2
-.. function:: atanh(array, queue=None)
-.. function:: atanpi(array, queue=None)
-.. autofunction:: atan2pi
-
-.. function:: cbrt(array, queue=None)
-.. function:: ceil(array, queue=None)
-.. TODO: copysign
-
-.. function:: cos(array, queue=None)
-.. function:: cosh(array, queue=None)
-.. function:: cospi(array, queue=None)
-
-.. function:: erfc(array, queue=None)
-.. function:: erf(array, queue=None)
-.. function:: exp(array, queue=None)
-.. function:: exp2(array, queue=None)
-.. function:: exp10(array, queue=None)
-.. function:: expm1(array, queue=None)
-
-.. function:: fabs(array, queue=None)
-.. TODO: fdim
-.. function:: floor(array, queue=None)
-.. TODO: fma
-.. TODO: fmax
-.. TODO: fmin
-
-.. function:: fmod(arg, mod, queue=None)
-
-    Return the floating point remainder of the division ``arg / mod``,
-    for each element in ``arg`` and ``mod``.
-
-.. TODO: fract
-
-
-.. function:: frexp(arg, queue=None)
-
-    Return a tuple ``(significands, exponents)`` such that
-    ``arg == significand * 2**exponent``.
-
-.. TODO: hypot
-
-.. function:: ilogb(array, queue=None)
-.. function:: ldexp(significand, exponent, queue=None)
-
-    Return a new array of floating point values composed from the
-    entries of ``significand`` and ``exponent``, paired together as
-    ``result = significand * 2**exponent``.
-
-
-.. function:: lgamma(array, queue=None)
-.. TODO: lgamma_r
-
-.. function:: log(array, queue=None)
-.. function:: log2(array, queue=None)
-.. function:: log10(array, queue=None)
-.. function:: log1p(array, queue=None)
-.. function:: logb(array, queue=None)
-
-.. TODO: mad
-.. TODO: maxmag
-.. TODO: minmag
-
-
-.. function:: modf(arg, queue=None)
-
-    Return a :class:`tuple` ``(fracpart, intpart)`` of arrays containing the
-    integer and fractional parts of ``arg``.
-
-.. function:: nan(array, queue=None)
-
-.. TODO: nextafter
-.. TODO: remainder
-.. TODO: remquo
-
-.. function:: rint(array, queue=None)
-.. TODO: rootn
-.. function:: round(array, queue=None)
-
-.. function:: sin(array, queue=None)
-.. TODO: sincos
-.. function:: sinh(array, queue=None)
-.. function:: sinpi(array, queue=None)
-
-.. function:: sqrt(array, queue=None)
-
-.. function:: tan(array, queue=None)
-.. function:: tanh(array, queue=None)
-.. function:: tanpi(array, queue=None)
-.. function:: tgamma(array, queue=None)
-.. function:: trunc(array, queue=None)
-
-Generating Arrays of Random Numbers
------------------------------------
-
-.. automodule:: pyopencl.clrandom

pyopencl-2024.2.2.data/data/doc/conf.py

@@ -1,26 +0,0 @@
-from urllib.request import urlopen
-
-
-_conf_url = \
-        "https://raw.githubusercontent.com/inducer/sphinxconfig/main/sphinxconfig.py"
-with urlopen(_conf_url) as _inf:
-    exec(compile(_inf.read(), _conf_url, "exec"), globals())
-
-exclude_patterns = ["subst.rst"]
-
-copyright = "2009-21, Andreas Kloeckner"
-
-ver_dic = {}
-with open("../pyopencl/version.py") as ver_file:
-    ver_src = ver_file.read()
-exec(compile(ver_src, "../pyopencl/version.py", "exec"), ver_dic)
-version = ".".join(str(x) for x in ver_dic["VERSION"])
-# The full version, including alpha/beta/rc tags.
-release = ver_dic["VERSION_TEXT"]
-
-intersphinx_mapping = {
-    "python": ("https://docs.python.org/3", None),
-    "numpy": ("https://numpy.org/doc/stable/", None),
-    "mako": ("https://docs.makotemplates.org/en/latest", None),
-    "pytools": ("https://documen.tician.de/pytools", None),
-}