gpu::linalg

Device cholesky — host bridge (download → cheatah host kernel → upload).

Device inv — host bridge (LU with partial pivoting + whole-identity back-solve).

Device pinv — host bridge (Moore–Penrose pseudo-inverse via Golub–Reinsch SVD; the result is the transposed shape n×m for an m×n input).

Device matrix_power — host bridge (binary exponentiation; negative n via the host inverse).

Device solve — host bridge (x from A·x = b via LU with partial pivoting).

Device lstsq — host bridge (min ‖Ax−b‖, computed as pinv(A)·b on the host).

Device svdvals — host bridge (descending singular values, length min(m,n) — the values-only fast path of the Golub–Reinsch reduction, a large constant factor below the full svd).

Device qr — host bridge (reduced Householder QR; requires rows ≥ cols, from the host kernel).

Device svd — host bridge (Golub–Reinsch; requires rows ≥ cols, from the host kernel).

Device eig — host bridge (Hessenberg + shifted QR; COMPLEX outputs from a real or complex square input, since a real matrix can have complex eigenpairs).

Device eigvals — host bridge (the COMPLEX spectrum of a real or complex square matrix, descending; symmetric input routes through tridiagonal QL on the host, the rest through Hessenberg + shifted QR).

Device eigh — host bridge (Householder tridiagonalization + QL for a symmetric/Hermitian input: a REAL spectrum plus eigenvectors matching the input's element type).

Device eigvalsh — host bridge (the REAL spectrum of a symmetric/Hermitian matrix, descending — tridiagonal QL skipping the eigenvector accumulation).

Device det — host bridge (LU with partial pivoting; pivot product × permutation sign).

Device slogdet — host bridge (sign and log|det| via LU — the overflow-safe determinant).

Device cond — host bridge (largest/smallest singular-value ratio from a Golub–Reinsch SVD).

Device matrix_rank — host bridge (SVD singular-value thresholding).

Device norm — host bridge (L2 for vectors, Frobenius for matrices — dispatched on rank by the host kernel).

Whether the device context can come up on this machine — a cached one-shot probe that NEVER throws.

Why available() is false — the probe's exception text, "" while available.

Device batched 2-D im2col GATHER into the caller's column block: col[(c·KH+kh)·KW+kw, b·OO + oh·OW + ow] = x[b, c, oh·stride − pad + kh, ow·stride − pad + kw] with out-of-plane (padding) cells written as ZEROS — a FULL overwrite, so a reused workspace needs no zeroing pass.

Device batched 2-D col2im — the EXACT adjoint of im2col2d, in GATHER form: each dx cell sums its ≤ KH·KW contributing dcol cells (skipping stride-incompatible and out-of-range kernel offsets), one thread per dx element, FULL overwrite (the scatter-add's zeroing folded in).

Device conv forward epilogue, fused THREE-in-one — bias add + activation + layout transpose: a[(b·F+f)·OO + o] = act(yc[f·B·OO + b·OO + o] + bias[f]), taking the GEMM's filter-major [F, B·OO] output to the per-sample [B, F·OO] activation block in ONE dispatch.

Device conv backward epilogue (the adjoint of conv_bias_act's act + layout, fused): dyc[f·B·OO + b·OO + o] = d[(b·F+f)·OO + o] · act'(a[(b·F+f)·OO + o]) — the chain-rule step and the transpose back to filter-major in ONE dispatch.

out = a + b (same shape).

out = a − b (same shape).

out = a ⊙ b, the Hadamard product (same shape).

out = a ⊘ b, elementwise division (same shape).

out = α·x + y in ONE dispatch — the fused training-loop primitive (same shapes; operator chaining costs two dispatches and a temporary).

√a elementwise, allocating (cheatah's sqrt ufunc spelling).

eᵃ elementwise, allocating.

ln a elementwise, allocating (same f64 host-evaluation note as exp).

|a| elementwise, allocating.

Σ aᵢ over the whole array — the DETERMINISTIC partial-sum contract (a size-picked one- or two-stage partial kernel + an on-device finalize, fused into one submission; fixed association order, so the same bits come back every run).

The arithmetic mean Σ aᵢ / n (n = 0 yields 0, matching an empty sum).

a + b elementwise (the spelling purr's codegen emits; resolves here by ADL).

a − b elementwise.

a ⊙ b elementwise.

a ⊘ b elementwise.

a += b in place.

a −= b in place.

a ⊙= b in place.

a ⊘= b in place.

The transfer/dispatch ledger of the process-wide context (uploads, downloads, dispatches).

Zero the ledger (examples call this right before a hot loop, then assert on stats).

Upload a host array into a fresh device array (same shape + element type; the operand must be contiguous — pack first via ndarray's reshape/copy if it is a strided view, else this throws).

Download a device array into a fresh host array (same shape + element type).

A device array of the given shape, every element value (ndarray's full).

A double device array of zeros (ndarray's zeros) — the device-side fill kernel, no upload.

A double device array of ones (ndarray's ones) — the device-side fill kernel, no upload.

Same shape/element as a, every element value — ADL-reachable, so generic code can call it unqualified on either container.

Zeros with a's shape/element (ADL-reachable).

Ones with a's shape/element (ADL-reachable).

A 1-D device array from a host vector (ndarray's array).

A 0-d scalar device array.

Evenly spaced values in [start, stop) with the given step (ndarray's arange; a zero step throws).

Reshape — ZERO-COPY: device arrays are always contiguous, so the new view shares the buffer (throws on a negative dimension, an element-count overflow, or a count mismatch).

Read ONE element by signed multi-index (ndarray's get) — a single-element SYNC POINT (exactly sizeof(T) crosses the bus; throws on a rank mismatch or an out-of-range index).

Render like ndarray renders (downloads, then reuses ndarray's own to_string — identical output by construction).

Stream form — same rendering as ndarray's operator<< (a SYNC POINT, via to_string).

Element count as cheatah's signed integer (ndarray's size_of).

Device arrays are always contiguous (parity with ndarray's is_contiguous).

Element conversion (ndarray's astype) — HOST round-trip today (documented; a device convert kernel is a listed next step).

Device GEMM: out = a @ b, row-major, a is M×K, b is K×N, out is M×N.

Device outer product: out[n×m] = aᵢ·bⱼ.

Device conjugate transpose: out[c×r] = aᴴ for an r×c input (the kernel conjugates complex elements; conjugation is the identity for real ones).

Device Kronecker product: out[(ar·br)×(ac·bc)] = a ⊗ b.

Device dot product (bilinear Σ aᵢbᵢ) into the caller's scalar — the DeviceArray overload of cheatah's scalar-out reduction kernel, dispatched as deterministic partial sums (the same bits every run), finalized on device and downloaded as ONE element.

Device vdot: the Hermitian Σ conj(aᵢ)·bᵢ for complex elements (its own conjugating kernel); for real elements the conjugation is the identity and it shares dot's kernel.

Device inner product — the bilinear Σ aᵢbᵢ, identical to dot for flattened vectors (dispatched through the same kernel).

Device trace (diagonal sum of a 2-D matrix) into the caller's scalar — deterministic partial sums over the strided diagonal, summed on the host in a fixed order.

The host container under its device-parity name: step<host_array>(…) vs step<device_array>(…) is the entire CPU↔GPU switch.