cunumpy 0.6.3__tar.gz → 0.7.1__tar.gz

{cunumpy-0.6.3/src/cunumpy.egg-info → cunumpy-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cunumpy
-Version: 0.6.3
+Version: 0.7.1
 Summary: Simple wrapper for numpy and cupy. Replace `import numpy as np` with `import cunumpy as xp`.
 Author: Max
 License: MIT License
@@ -41,19 +41,13 @@ Requires-Dist: array-api-compat
 Requires-Dist: maybempi>=0.1.2
 Requires-Dist: numpy
 Provides-Extra: dev
-Requires-Dist: ruff; extra == "dev"
 Requires-Dist: cunumpy[docs,test-compiled]; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: pyproject-fmt; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
 Provides-Extra: docs
+Requires-Dist: griffe; extra == "docs"
 Requires-Dist: ipykernel; extra == "docs"
-Requires-Dist: myst-parser; extra == "docs"
-Requires-Dist: nbconvert; extra == "docs"
-Requires-Dist: nbsphinx; extra == "docs"
-Requires-Dist: numpydoc; extra == "docs"
-Requires-Dist: jupyterlab; extra == "docs"
-Requires-Dist: pre-commit; extra == "docs"
-Requires-Dist: pyproject-fmt; extra == "docs"
-Requires-Dist: sphinx; extra == "docs"
-Requires-Dist: sphinx-book-theme; extra == "docs"
 Provides-Extra: metal
 Requires-Dist: mlx; (sys_platform == "darwin" and platform_machine == "arm64") and extra == "metal"
 Provides-Extra: test
@@ -104,7 +98,7 @@ never hide a NumPy name:
 
 Everything except `xp.cuda`, `xp.arguments` and `CudaKernel` works on both backends.
 `MetalKernel` runs Metal kernels on the GPU of an Apple silicon Mac (MLX, float32, NumPy arrays;
-`pip install 'cunumpy[metal]'`, see [the guide](docs/source/kernels/metal-kernel.md)).
+`pip install 'cunumpy[metal]'`, see [the guide](https://max-models.github.io/cunumpy/kernels/metal-kernel/)).
 
 ## Install
 
@@ -120,7 +114,7 @@ installation instructions for your system. CuNumpy does not install CUDA.
 `array-api-compat` supplies NumPy and CuPy compatibility modules with more
 consistent behavior for shared array operations. CuNumpy uses them internally;
 your arrays remain ordinary NumPy or CuPy arrays. See [why CuNumpy uses
-`array-api-compat`](docs/source/array-api-compat.md) for a plain-language
+`array-api-compat`](https://max-models.github.io/cunumpy/guides/array-api-compat/) for a plain-language
 explanation and examples.
 
 ## Choose a backend
@@ -146,7 +140,7 @@ Use `xp.set_backend("cupy", strict=True)` to raise when CUDA is unavailable,
 preserving the previous backend. `xp.backend_info()` returns structured backend,
 dependency, and CUDA diagnostics. Reusable streams/events, MPI staging, cell
 ranges, and prepared reductions are described in the
-[execution helpers guide](docs/source/guides/execution-helpers.md).
+[execution helpers guide](https://max-models.github.io/cunumpy/guides/execution-helpers/).
 
 Use `use_backend()` for a temporary selection. It restores the previous
 selection when the block exits, including when an exception is raised:
@@ -367,7 +361,7 @@ read-only inputs. For a keyword call, declare the keyword name, such as
 `outputs=("out",)`. A wrong declaration can leave GPU output values stale.
 The wrapper can also traverse arrays nested in lists, tuples, dictionaries,
 and selected application objects; see [Host kernels with GPU
-data](docs/source/kernels/pyccel-kernel.md) for `object_modules`, `is_array`,
+data](https://max-models.github.io/cunumpy/kernels/pyccel-kernel/) for `object_modules`, `is_array`,
 aliasing, and output declarations.
 
 ## Write CUDA kernels next to host kernels
@@ -504,8 +498,8 @@ an explicit `grid`, with dynamic shared memory (`shared_mem`) and a `stream`.
 C++ function templates are instantiated with `template_args`, and
 `CudaKernelVariants` caches kernels whose source is generated per variant
 (e.g. per dimension and dtype). See [Writing CUDA
-kernels](docs/source/kernels/cuda-kernel.md) and [CUDA
-headers](docs/source/kernels/cuda-headers.md) for details.
+kernels](https://max-models.github.io/cunumpy/kernels/cuda-kernel/) and [CUDA
+headers](https://max-models.github.io/cunumpy/kernels/cuda-headers/) for details.
 
 Kernels run asynchronously, so a CUDA error (an illegal memory access, say)
 normally surfaces at a later `.get()` or MPI call, far from the kernel that
@@ -565,36 +559,36 @@ mirror.to_host()  # vector._data holds the result on both backends
 
 CuNumpy supports the NumPy backend in Pyodide. It does not provide CuPy/CUDA
 there. Ordinary Python callables can be wrapped with `PyccelKernel` without
-compilation. See the [Pyodide guide](docs/source/pyodide.md) for a complete
+compilation. See the [Pyodide guide](https://max-models.github.io/cunumpy/pyodide/) for a complete
 installation example and compatibility notes.
 
 ## Documentation
 
-The full documentation lives in [`docs/source`](docs/source/index.md) and is
+The full documentation lives in [`docs/`](docs/) (Astro + Starlight, `make docs-build`) and is
 published at <https://max-models.github.io/cunumpy/>:
 
-* Getting started: [installation](docs/source/installation.md) and a
-  [quickstart](docs/source/quickstart.md) with a map of which guide covers what.
-* User guide: [choosing a backend](docs/source/guides/backends.md),
-  [backend-agnostic code](docs/source/guides/portable-code.md),
-  [data movement](docs/source/guides/data-movement.md),
-  [devices, memory and streams](docs/source/guides/gpu-devices.md),
-  [MPI with one rank per GPU](docs/source/guides/mpi.md),
-  [timing and profiling](docs/source/guides/profiling.md).
-* Porting kernels: [overview](docs/source/kernels/overview.md),
-  [`PyccelKernel`](docs/source/kernels/pyccel-kernel.md),
-  [`CudaKernel`](docs/source/kernels/cuda-kernel.md),
-  [`Kernel` and `KernelCatalog`](docs/source/kernels/dispatch.md),
-  [argument objects and structs](docs/source/kernels/arguments.md),
-  [accumulation kernels](docs/source/kernels/accumulation.md),
-  [debugging](docs/source/kernels/debugging.md),
-  [testing](docs/source/kernels/testing.md).
-* [Worked examples](docs/source/examples/index.md),
-  [best practices](docs/source/best-practices.md),
-  [troubleshooting](docs/source/troubleshooting.md),
-  [Pyodide](docs/source/pyodide.md), the
-  [API overview](docs/source/api.md) and the
-  [API reference](docs/source/reference/index.md).
+* Getting started: [installation](https://max-models.github.io/cunumpy/getting-started/installation/) and a
+  [quickstart](https://max-models.github.io/cunumpy/getting-started/quickstart/) with a map of which guide covers what.
+* User guide: [choosing a backend](https://max-models.github.io/cunumpy/guides/backends/),
+  [backend-agnostic code](https://max-models.github.io/cunumpy/guides/portable-code/),
+  [data movement](https://max-models.github.io/cunumpy/guides/data-movement/),
+  [devices, memory and streams](https://max-models.github.io/cunumpy/guides/gpu-devices/),
+  [MPI with one rank per GPU](https://max-models.github.io/cunumpy/guides/mpi/),
+  [timing and profiling](https://max-models.github.io/cunumpy/guides/profiling/).
+* Porting kernels: [overview](https://max-models.github.io/cunumpy/kernels/overview/),
+  [`PyccelKernel`](https://max-models.github.io/cunumpy/kernels/pyccel-kernel/),
+  [`CudaKernel`](https://max-models.github.io/cunumpy/kernels/cuda-kernel/),
+  [`Kernel` and `KernelCatalog`](https://max-models.github.io/cunumpy/kernels/dispatch/),
+  [argument objects and structs](https://max-models.github.io/cunumpy/kernels/arguments/),
+  [accumulation kernels](https://max-models.github.io/cunumpy/kernels/accumulation/),
+  [debugging](https://max-models.github.io/cunumpy/kernels/debugging/),
+  [testing](https://max-models.github.io/cunumpy/kernels/testing/).
+* [Worked examples](https://max-models.github.io/cunumpy/examples/),
+  [best practices](https://max-models.github.io/cunumpy/best-practices/),
+  [troubleshooting](https://max-models.github.io/cunumpy/troubleshooting/),
+  [Pyodide](https://max-models.github.io/cunumpy/pyodide/), the
+  [API overview](https://max-models.github.io/cunumpy/reference/overview/) and the
+  [API reference](https://max-models.github.io/cunumpy/reference/).
 
 ### For AI coding assistants
 

{cunumpy-0.6.3 → cunumpy-0.7.1}/README.md

@@ -37,7 +37,7 @@ never hide a NumPy name:
 
 Everything except `xp.cuda`, `xp.arguments` and `CudaKernel` works on both backends.
 `MetalKernel` runs Metal kernels on the GPU of an Apple silicon Mac (MLX, float32, NumPy arrays;
-`pip install 'cunumpy[metal]'`, see [the guide](docs/source/kernels/metal-kernel.md)).
+`pip install 'cunumpy[metal]'`, see [the guide](https://max-models.github.io/cunumpy/kernels/metal-kernel/)).
 
 ## Install
 
@@ -53,7 +53,7 @@ installation instructions for your system. CuNumpy does not install CUDA.
 `array-api-compat` supplies NumPy and CuPy compatibility modules with more
 consistent behavior for shared array operations. CuNumpy uses them internally;
 your arrays remain ordinary NumPy or CuPy arrays. See [why CuNumpy uses
-`array-api-compat`](docs/source/array-api-compat.md) for a plain-language
+`array-api-compat`](https://max-models.github.io/cunumpy/guides/array-api-compat/) for a plain-language
 explanation and examples.
 
 ## Choose a backend
@@ -79,7 +79,7 @@ Use `xp.set_backend("cupy", strict=True)` to raise when CUDA is unavailable,
 preserving the previous backend. `xp.backend_info()` returns structured backend,
 dependency, and CUDA diagnostics. Reusable streams/events, MPI staging, cell
 ranges, and prepared reductions are described in the
-[execution helpers guide](docs/source/guides/execution-helpers.md).
+[execution helpers guide](https://max-models.github.io/cunumpy/guides/execution-helpers/).
 
 Use `use_backend()` for a temporary selection. It restores the previous
 selection when the block exits, including when an exception is raised:
@@ -300,7 +300,7 @@ read-only inputs. For a keyword call, declare the keyword name, such as
 `outputs=("out",)`. A wrong declaration can leave GPU output values stale.
 The wrapper can also traverse arrays nested in lists, tuples, dictionaries,
 and selected application objects; see [Host kernels with GPU
-data](docs/source/kernels/pyccel-kernel.md) for `object_modules`, `is_array`,
+data](https://max-models.github.io/cunumpy/kernels/pyccel-kernel/) for `object_modules`, `is_array`,
 aliasing, and output declarations.
 
 ## Write CUDA kernels next to host kernels
@@ -437,8 +437,8 @@ an explicit `grid`, with dynamic shared memory (`shared_mem`) and a `stream`.
 C++ function templates are instantiated with `template_args`, and
 `CudaKernelVariants` caches kernels whose source is generated per variant
 (e.g. per dimension and dtype). See [Writing CUDA
-kernels](docs/source/kernels/cuda-kernel.md) and [CUDA
-headers](docs/source/kernels/cuda-headers.md) for details.
+kernels](https://max-models.github.io/cunumpy/kernels/cuda-kernel/) and [CUDA
+headers](https://max-models.github.io/cunumpy/kernels/cuda-headers/) for details.
 
 Kernels run asynchronously, so a CUDA error (an illegal memory access, say)
 normally surfaces at a later `.get()` or MPI call, far from the kernel that
@@ -498,36 +498,36 @@ mirror.to_host()  # vector._data holds the result on both backends
 
 CuNumpy supports the NumPy backend in Pyodide. It does not provide CuPy/CUDA
 there. Ordinary Python callables can be wrapped with `PyccelKernel` without
-compilation. See the [Pyodide guide](docs/source/pyodide.md) for a complete
+compilation. See the [Pyodide guide](https://max-models.github.io/cunumpy/pyodide/) for a complete
 installation example and compatibility notes.
 
 ## Documentation
 
-The full documentation lives in [`docs/source`](docs/source/index.md) and is
+The full documentation lives in [`docs/`](docs/) (Astro + Starlight, `make docs-build`) and is
 published at <https://max-models.github.io/cunumpy/>:
 
-* Getting started: [installation](docs/source/installation.md) and a
-  [quickstart](docs/source/quickstart.md) with a map of which guide covers what.
-* User guide: [choosing a backend](docs/source/guides/backends.md),
-  [backend-agnostic code](docs/source/guides/portable-code.md),
-  [data movement](docs/source/guides/data-movement.md),
-  [devices, memory and streams](docs/source/guides/gpu-devices.md),
-  [MPI with one rank per GPU](docs/source/guides/mpi.md),
-  [timing and profiling](docs/source/guides/profiling.md).
-* Porting kernels: [overview](docs/source/kernels/overview.md),
-  [`PyccelKernel`](docs/source/kernels/pyccel-kernel.md),
-  [`CudaKernel`](docs/source/kernels/cuda-kernel.md),
-  [`Kernel` and `KernelCatalog`](docs/source/kernels/dispatch.md),
-  [argument objects and structs](docs/source/kernels/arguments.md),
-  [accumulation kernels](docs/source/kernels/accumulation.md),
-  [debugging](docs/source/kernels/debugging.md),
-  [testing](docs/source/kernels/testing.md).
-* [Worked examples](docs/source/examples/index.md),
-  [best practices](docs/source/best-practices.md),
-  [troubleshooting](docs/source/troubleshooting.md),
-  [Pyodide](docs/source/pyodide.md), the
-  [API overview](docs/source/api.md) and the
-  [API reference](docs/source/reference/index.md).
+* Getting started: [installation](https://max-models.github.io/cunumpy/getting-started/installation/) and a
+  [quickstart](https://max-models.github.io/cunumpy/getting-started/quickstart/) with a map of which guide covers what.
+* User guide: [choosing a backend](https://max-models.github.io/cunumpy/guides/backends/),
+  [backend-agnostic code](https://max-models.github.io/cunumpy/guides/portable-code/),
+  [data movement](https://max-models.github.io/cunumpy/guides/data-movement/),
+  [devices, memory and streams](https://max-models.github.io/cunumpy/guides/gpu-devices/),
+  [MPI with one rank per GPU](https://max-models.github.io/cunumpy/guides/mpi/),
+  [timing and profiling](https://max-models.github.io/cunumpy/guides/profiling/).
+* Porting kernels: [overview](https://max-models.github.io/cunumpy/kernels/overview/),
+  [`PyccelKernel`](https://max-models.github.io/cunumpy/kernels/pyccel-kernel/),
+  [`CudaKernel`](https://max-models.github.io/cunumpy/kernels/cuda-kernel/),
+  [`Kernel` and `KernelCatalog`](https://max-models.github.io/cunumpy/kernels/dispatch/),
+  [argument objects and structs](https://max-models.github.io/cunumpy/kernels/arguments/),
+  [accumulation kernels](https://max-models.github.io/cunumpy/kernels/accumulation/),
+  [debugging](https://max-models.github.io/cunumpy/kernels/debugging/),
+  [testing](https://max-models.github.io/cunumpy/kernels/testing/).
+* [Worked examples](https://max-models.github.io/cunumpy/examples/),
+  [best practices](https://max-models.github.io/cunumpy/best-practices/),
+  [troubleshooting](https://max-models.github.io/cunumpy/troubleshooting/),
+  [Pyodide](https://max-models.github.io/cunumpy/pyodide/), the
+  [API overview](https://max-models.github.io/cunumpy/reference/overview/) and the
+  [API reference](https://max-models.github.io/cunumpy/reference/).
 
 ### For AI coding assistants
 

{cunumpy-0.6.3 → cunumpy-0.7.1}/pyproject.toml

@@ -5,7 +5,7 @@ requires = [ "setuptools", "wheel" ]
 
 [project]
 name = "cunumpy"
-version = "0.6.3"
+version = "0.7.1"
 description = "Simple wrapper for numpy and cupy. Replace `import numpy as np` with `import cunumpy as xp`."
 readme = "README.md"
 keywords = [ "python" ]
@@ -28,22 +28,14 @@ dependencies = [
 ]
 
 optional-dependencies.dev = [
-  "ruff",
   "cunumpy[test-compiled,docs]",
-]
-# https://medium.com/@pratikdomadiya123/build-project-documentation-quickly-with-the-sphinx-python-2a9732b66594
-optional-dependencies.docs = [
-  "ipykernel",
-  "myst-parser",
-  "nbconvert",
-  "nbsphinx",
-  "numpydoc",
-  "jupyterlab",
   "pre-commit",
   "pyproject-fmt",
-  "sphinx",
-  "sphinx-book-theme",
+  "ruff",
 ]
+# the API reference of the docs site (docs/, Astro + Starlight) reads the docstrings with griffe;
+# the shared docs workflow registers an ipykernel even without notebooks
+optional-dependencies.docs = [ "griffe", "ipykernel" ]
 optional-dependencies.metal = [ "mlx; sys_platform == 'darwin' and platform_machine == 'arm64'" ]
 optional-dependencies.test = [ "coverage", "pytest", "scipy" ]
 optional-dependencies.test-compiled = [ "cunumpy[test]", "pyccel" ]

{cunumpy-0.6.3 → cunumpy-0.7.1}/src/cunumpy/LLM_GUIDE.md

@@ -5,7 +5,7 @@ correct code with `cunumpy`. It ships inside the installed package
 (`<site-packages>/cunumpy/LLM_GUIDE.md`; locate it with
 `python -c "import cunumpy, pathlib; print(pathlib.Path(cunumpy.__file__).parent / 'LLM_GUIDE.md')"`).
 It is self-contained. The full documentation is at
-https://max-models.github.io/cunumpy/ and in `docs/source/` of the repository.
+https://max-models.github.io/cunumpy/ and in `docs/` of the repository.
 
 ## What cunumpy is
 
@@ -83,7 +83,7 @@ https://max-models.github.io/cunumpy/ and in `docs/source/` of the repository.
 | host kernels compiled at first call (your compile function), NumPy fallback | `from_package(..., host_suffix="_pyccel", compile_host=my_compile, host_fallback={...})` -> `xp.kernels.CompiledHostKernel` |
 | host arrays reach kernels while CuPy is active | `Kernel(..., dispatch="arrays")` / `from_package(..., dispatch="arrays")`: CUDA only for device arguments |
 | one kernel folder declares its kernel in its own `__init__.py` | `kernel = xp.kernels.Kernel.from_folder(__name__, host_suffix="_pyccel", compile_host=..., dispatch="arrays")`; `<name>_numba.py`, `<name>_numpy.py` in the folder are further host implementations |
-| bring a `dispatch="arrays"` kernel's arguments to the side of the main array | `xp.kernels.as_kernel_array(a, like=grid, dtype=float)`; outputs: `with xp.kernels.kernel_output(out, like=grid, dtype=float) as buf:`; `strided=True` passes NumPy views in C order with gaps (`a[:, :n]`) to Pyccel hosts without a copy |
+| bring a `dispatch="arrays"` kernel's arguments to the side of the main array | `xp.kernels.as_kernel_array(a, like=grid, dtype=float)`; outputs: `with xp.kernels.kernel_output(out, like=grid, dtype=float) as buf:` (several: `with xp.kernels.kernel_outputs(a, b, like=grid, dtype=float) as (buf_a, buf_b):`); `strided=True` passes NumPy views in C order with gaps (`a[:, :n]`) to Pyccel hosts without a copy |
 | choose the host implementation (pyccel/numba/numpy/python) | `xp.kernels.set_host_kernel_implementation("numpy")`, `with xp.kernels.use_host_kernel_implementation(...)`, `CUNUMPY_HOST_KERNEL_IMPLEMENTATION=numpy`; default: first available of pyccel, numba, numpy; `kernel.selected()` |
 | require CUDA for device kernel dispatch | `xp.kernels.set_device_kernel_implementation("cuda")`, `get_device_kernel_implementation()`, `with xp.kernels.use_device_kernel_implementation(...)`, `CUNUMPY_DEVICE_KERNEL_IMPLEMENTATION=cuda`; default `None` preserves `missing_cuda` policy; explicit CUDA rejects host fallback |
 | check host and CUDA kernels take the same parameters | `catalog.check_signatures()` (in a unit test) |

{cunumpy-0.6.3 → cunumpy-0.7.1}/src/cunumpy/__init__.py

@@ -55,8 +55,8 @@ from cunumpy.xp import (
 )
 
 try:
-    #: The installed version of cunumpy; ``"0.0.0+unknown"`` without package metadata.
     __version__ = version("cunumpy")
+    """The installed version of cunumpy; ``"0.0.0+unknown"`` without package metadata."""
 except PackageNotFoundError:
     __version__ = "0.0.0+unknown"
 

{cunumpy-0.6.3 → cunumpy-0.7.1}/src/cunumpy/_algorithms.py

@@ -380,6 +380,8 @@ def sort_by_key(keys: Any, *arrays: Any, axis: int = 0) -> tuple[Any, ...]:
     radix sort; on NumPy, integer keys of more than 4096 entries get an LSD
     radix sort too (one stable ``uint16`` argsort per 16-bit digit the key range
     needs), about ten times faster than NumPy's stable sort of 64-bit integers.
+    On NumPy, a 2-D array sorted along its last axis (component-major markers) is
+    gathered row by row, about twice as fast as ``take`` along that axis.
 
     Parameters
     ----------
@@ -437,12 +439,27 @@ def sort_by_key(keys: Any, *arrays: Any, axis: int = 0) -> tuple[Any, ...]:
         keys[order],
         order,
         *(
-            xpm.take(array, order, axis=array_axis)
+            _take_along_axis(xpm, array, order, array_axis)
             for array, array_axis in zip(arrays, axes, strict=True)
         ),
     )
 
 
+def _take_along_axis(xpm: Any, array: Any, order: Any, axis: int) -> Any:
+    """Return `array` taken at `order` along `axis`, as a new C-contiguous array.
+
+    A component-major ``(ncomp, n)`` NumPy array is gathered one contiguous row at a
+    time, which is about twice as fast as ``take`` along its last axis; everything
+    else, and CuPy, goes through ``take``.
+    """
+    if xpm is np and array.ndim == 2 and axis == 1:
+        gathered = np.empty((array.shape[0], order.shape[0]), dtype=array.dtype)
+        for row in range(array.shape[0]):
+            gathered[row] = array[row][order]
+        return gathered
+    return xpm.take(array, order, axis=axis)
+
+
 def compact_by_mask(mask: Any, *arrays: Any, axis: int = 0) -> int:
     """Move the entries where `mask` is True to the front of every array, in place.
 

{cunumpy-0.6.3 → cunumpy-0.7.1}/src/cunumpy/_cuda_kernel.py

@@ -116,10 +116,11 @@ def cuda_include_dir() -> str:
     return str(_CUDA_INCLUDE_DIR)
 
 
-#: NVRTC options added in debug mode: line information for
-#: ``compute-sanitizer``/``nsys`` and bounds checks in the array views
-#: (no ``-G``: NVRTC does not support it).
 DEBUG_OPTIONS = ("-lineinfo", "-DCUNUMPY_BOUNDS_CHECK")
+"""NVRTC options added in debug mode: line information for
+``compute-sanitizer``/``nsys`` and bounds checks in the array views
+(no ``-G``: NVRTC does not support it).
+"""
 
 
 class CudaArguments:

{cunumpy-0.6.3 → cunumpy-0.7.1}/src/cunumpy/_device.py

@@ -192,10 +192,11 @@ def memory_info() -> tuple[int, int] | None:
     return cp.cuda.runtime.memGetInfo()
 
 
-#: Dynamic shared memory per block that every CUDA device provides without an
-#: opt-in (48 KiB); also the answer of :func:`max_shared_memory_per_block`
-#: without a GPU.
 DEFAULT_SHARED_MEMORY_PER_BLOCK = 48 * 1024
+"""Dynamic shared memory per block that every CUDA device provides without an
+opt-in (48 KiB); also the answer of :func:`max_shared_memory_per_block`
+without a GPU.
+"""
 
 
 def max_shared_memory_per_block(

{cunumpy-0.6.3 → cunumpy-0.7.1}/src/cunumpy/_dispatch.py

@@ -64,10 +64,11 @@ def _on_device(arg: Any) -> bool:
     return _is_device_array(arg) or callable(getattr(type(arg), "__cuda_args__", None))
 
 
-#: Longest name a Fortran compiler accepts. Pyccel names the wrapper module of a
-#: host kernel module ``bind_c_<module>``, so a module name longer than
-#: ``63 - len("bind_c_")`` characters cannot be compiled with the Fortran backend.
 FORTRAN_NAME_LIMIT = 63
+"""Longest name a Fortran compiler accepts. Pyccel names the wrapper module of a
+host kernel module ``bind_c_<module>``, so a module name longer than
+``63 - len("bind_c_")`` characters cannot be compiled with the Fortran backend.
+"""
 
 
 def _pyccel_stub_parameters(function: Any) -> list[str] | None:

{cunumpy-0.6.3 → cunumpy-0.7.1}/src/cunumpy/_fake_cupyx.py

@@ -29,7 +29,6 @@ from typing import Any
 
 import numpy as np
 
-#: The subpackages of ``cupyx.scipy``; the same as ``_scipy_backend.SUBMODULES``.
 SUBPACKAGES = (
     "fft",
     "fftpack",
@@ -44,21 +43,19 @@ SUBPACKAGES = (
     "special",
     "stats",
 )
+"""The subpackages of ``cupyx.scipy``; the same as ``_scipy_backend.SUBMODULES``."""
 
 
 def _names(text: str) -> frozenset[str]:
     return frozenset(text.split())
 
 
-#: The CuPy release whose ``cupyx.scipy`` names :data:`NAMES` lists: the oldest
-#: supported one (``cunumpy.xp.MIN_CUPY_VERSION``), so code that runs on the
-#: fake runs on every supported CuPy. Newer CuPy releases have more names.
 NAMES_VERSION = "14.0.0"
+"""The CuPy release whose ``cupyx.scipy`` names :data:`NAMES` lists: the oldest
+supported one (``cunumpy.xp.MIN_CUPY_VERSION``), so code that runs on the
+fake runs on every supported CuPy. Newer CuPy releases have more names.
+"""
 
-#: The public names of each ``cupyx.scipy`` subpackage in CuPy
-#: :data:`NAMES_VERSION`. Check them against an installed CuPy with
-#: ``python testing/cupyx_names.py`` (the GPU CI does, in
-#: ``tests/unit/test_cupyx_names.py``).
 NAMES = {
     "fft": _names(
         """
@@ -193,6 +190,11 @@ NAMES = {
         """,
     ),
 }
+"""The public names of each ``cupyx.scipy`` subpackage in CuPy
+:data:`NAMES_VERSION`. Check them against an installed CuPy with
+``python testing/cupyx_names.py`` (the GPU CI does, in
+``tests/unit/test_cupyx_names.py``).
+"""
 
 
 def public_names(module: types.ModuleType) -> frozenset[str]:

{cunumpy-0.6.3 → cunumpy-0.7.1}/src/cunumpy/_kernel.py

@@ -438,9 +438,10 @@ class PyccelKernel:
         return self._outputs
 
 
-#: The names of the host implementations a kernel can have, see
-#: :class:`~cunumpy.kernels.HostImplementations`.
 HOST_IMPLEMENTATIONS = ("pyccel", "numba", "numpy", "python")
+"""The names of the host implementations a kernel can have, see
+:class:`~cunumpy.kernels.HostImplementations`.
+"""
 
 
 def _check_implementation(name: str | None) -> str | None:
@@ -536,8 +537,8 @@ def use_host_kernel_implementation(name: str | None) -> Iterator[None]:
         _KERNEL_IMPLEMENTATION = previous
 
 
-#: The names of the device implementations a kernel can have.
 DEVICE_IMPLEMENTATIONS = ("cuda",)
+"""The names of the device implementations a kernel can have."""
 
 
 def _check_device_implementation(name: str | None) -> str | None:
@@ -950,7 +951,16 @@ def _with_unit_axis_strides(array: np.ndarray) -> np.ndarray:
     extent = array.itemsize
     for axis in reversed(range(array.ndim)):
         if array.shape[axis] == 1:
-            strides[axis] = max(strides[axis], extent)
+            # Any stride is valid for a length-1 axis, but Pyccel's C-order check
+            # wants each stride at least the extent of the axes inside it. Inside
+            # a longer axis, use exactly the C stride, so that the outer stride
+            # (e.g. 8 in a (2, 1) array with strides (8, 16)) still covers it;
+            # a leading length-1 axis may keep a larger stride (a row of a
+            # wider array, ``storage[1:2, :n]``).
+            if any(length > 1 for length in array.shape[:axis]):
+                strides[axis] = extent
+            else:
+                strides[axis] = max(strides[axis], extent)
         else:
             extent = strides[axis] * array.shape[axis]
     if tuple(strides) == array.strides:
@@ -1052,6 +1062,18 @@ def _same_memory(buffer: Any, out: Any) -> bool:
     )
 
 
+def _copy_back(buffer: Any, out: Any) -> None:
+    """Write `buffer` into `out`, on its own side, unless they share their memory."""
+    if _same_memory(buffer, out):
+        return
+    if is_gpu(out) and not is_gpu(buffer):
+        out[...] = to_cupy(buffer)
+    elif not is_gpu(out) and is_gpu(buffer):
+        out[...] = to_numpy(buffer)
+    else:
+        out[...] = buffer
+
+
 class _KernelOutput:
     """The context manager of :func:`kernel_output` (a class: cheaper than a generator)."""
 
@@ -1070,16 +1092,8 @@ class _KernelOutput:
         exc: BaseException | None,
         traceback: TracebackType | None,
     ) -> None:
-        if exc_type is not None:
-            return
-        buffer, out = self._buffer, self._out
-        if not _same_memory(buffer, out):
-            if is_gpu(out) and not is_gpu(buffer):
-                out[...] = to_cupy(buffer)
-            elif not is_gpu(out) and is_gpu(buffer):
-                out[...] = to_numpy(buffer)
-            else:
-                out[...] = buffer
+        if exc_type is None:
+            _copy_back(self._buffer, self._out)
 
 
 def kernel_output(
@@ -1118,6 +1132,73 @@ def kernel_output(
     return _KernelOutput(out, as_kernel_array(out, like, dtype, strided=strided))
 
 
+class _KernelOutputs:
+    """The context manager of :func:`kernel_outputs`."""
+
+    __slots__ = ("_buffers", "_outs")
+
+    def __init__(self, outs: tuple[Any, ...], buffers: tuple[Any, ...]) -> None:
+        self._outs = outs
+        self._buffers = buffers
+
+    def __enter__(self) -> tuple[Any, ...]:
+        return self._buffers
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        if exc_type is None:
+            for buffer, out in zip(self._buffers, self._outs, strict=True):
+                _copy_back(buffer, out)
+
+
+def kernel_outputs(
+    *outs: Any, like: Any, dtype: Any = None, strided: bool = False
+) -> _KernelOutputs:
+    """Provide the output buffers of several arrays in one block.
+
+    As :func:`~cunumpy.kernels.kernel_output` for each of `outs`, with one
+    context manager for all: cheaper for a kernel that writes several arrays,
+    called at every step. Each buffer is its array itself if
+    :func:`~cunumpy.kernels.as_kernel_array` takes it unchanged, else a
+    converted copy written back into the array when the block ends without an
+    error.
+
+    Parameters
+    ----------
+    *outs : array
+        The arrays the kernel should write.
+    like : array
+        A CuPy array for a device kernel, anything else for a host kernel.
+    dtype : dtype, optional
+        Required dtype of every buffer; by default any.
+    strided : bool, optional
+        As for :func:`~cunumpy.kernels.as_kernel_array`. Default False.
+
+    Returns
+    -------
+    context manager
+        Yields the tuple of buffers to pass to the kernel, in the order of
+        `outs`.
+
+    Examples
+    --------
+    >>> x = np.zeros(2)
+    >>> counts = np.zeros(2, dtype=np.float32)
+    >>> with xp.kernels.kernel_outputs(x, counts, like=x, dtype=float) as (a, b):
+    ...     a[:] = 1.0  # x itself
+    ...     b[:] = 2.5  # a float64 copy, written back into counts
+    >>> x, counts
+    (array([1., 1.]), array([2.5, 2.5], dtype=float32))
+    """
+    return _KernelOutputs(
+        outs, tuple(as_kernel_array(out, like, dtype, strided=strided) for out in outs)
+    )
+
+
 _SCALAR_ANNOTATIONS = {"int", "float", "bool", "complex", "str"}
 
 

{cunumpy-0.6.3 → cunumpy-0.7.1}/src/cunumpy/_morton.py

@@ -33,8 +33,8 @@ __all__ = [
     "morton_scales",
 ]
 
-#: Largest number of bits per axis that fits a uint64 key, by dimension.
 MAX_MORTON_LEVELS = {2: 32, 3: 21}
+"""Largest number of bits per axis that fits a uint64 key, by dimension."""
 
 _SPREAD = {
     2: (