Upload folder using huggingface_hub (part 22)

.gitattributes

@@ -549,3 +549,7 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 .venv/lib/python3.12/site-packages/torch/_inductor/fx_passes/__pycache__/split_cat.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
 .venv/lib/python3.12/site-packages/torch/_inductor/heuristics/template/__pycache__/triton.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
 .venv/lib/python3.12/site-packages/torch/_inductor/runtime/__pycache__/triton_heuristics.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_refs/__pycache__/__init__.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_subclasses/__pycache__/fake_impls.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_subclasses/__pycache__/fake_tensor.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_vendor/quack/__pycache__/gemm_sm100.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text

.venv/lib/python3.12/site-packages/torch/_native/ops/topk/_common.py

@@ -0,0 +1,71 @@
+"""Shared eligibility checks and reshape helpers for topk overrides.
+
+Both the CuTeDSL and Triton paths operate on a 2D ``(M, N)`` fp32 row-major
+view of ``self`` where ``dim`` points at the last axis. This module hosts the
+checks the conds share (contiguity, dim normalisation, COW) and the reshape
+helpers the impls share.
+"""
+
+import math
+
+import torch
+
+
+def any_cow(*tensors: torch.Tensor) -> bool:
+    return any(
+        torch._C._is_cow_tensor(t)  # pyrefly: ignore[missing-attribute]
+        for t in tensors
+    )
+
+
+def normalise_dim(self: torch.Tensor, dim: int) -> int:
+    """Translate a possibly-negative dim into its non-negative form.
+
+    Returns ``-1`` if the dim is out of range (cond callers should reject
+    in that case).
+    """
+    if self.ndim == 0:
+        return -1
+    if dim < -self.ndim or dim >= self.ndim:
+        return -1
+    return dim % self.ndim
+
+
+def last_dim_row_major_ok(self: torch.Tensor, dim: int) -> bool:
+    """True iff reducing over ``dim`` is equivalent to reducing over the last
+    axis of a 2D ``(prod(leading dims), N)`` row-major view.
+
+    Requires ``dim`` to be the last axis and ``self`` to be contiguous in the
+    standard row-major sense; together they ensure the flatten-to-2D view we
+    pass to the kernel is a view (not a copy) and has stride-1 on N.
+    """
+    norm = normalise_dim(self, dim)
+    if norm != self.ndim - 1:
+        return False
+    return self.is_contiguous()
+
+
+def flatten_last_dim(self: torch.Tensor) -> torch.Tensor:
+    """View nD self as 2D ``(M, N)`` with ``N = self.shape[-1]``.
+
+    Caller must have verified ``last_dim_row_major_ok`` so this is a view.
+    """
+    if self.ndim == 2:
+        return self
+    if self.ndim == 1:
+        return self.view(1, self.shape[0])
+    N = self.shape[-1]
+    M = math.prod(self.shape[:-1])
+    return self.view(M, N)
+
+
+def unflatten_last_dim(
+    flat_values: torch.Tensor, flat_indices: torch.Tensor, self: torch.Tensor, k: int
+) -> tuple[torch.Tensor, torch.Tensor]:
+    """Reshape the 2D ``(M, K)`` kernel outputs back into ``self``'s shape."""
+    if self.ndim == 2:
+        return flat_values, flat_indices
+    if self.ndim == 1:
+        return flat_values.view(k), flat_indices.view(k)
+    out_shape = self.shape[:-1] + (k,)
+    return flat_values.view(out_shape), flat_indices.view(out_shape)

.venv/lib/python3.12/site-packages/torch/_native/ops/topk/cutedsl_impl.py

@@ -0,0 +1,230 @@
+"""CuTeDSL override registrations for ``aten::topk``.
+
+Two kernels, picked by (K, N) - see ``cutedsl_kernels.py``:
+
+  * Register-resident (small K, small N): K in {16, 32}, N a power of 2
+    in a per-K range (see ``_REGISTER_N_RANGE``). Each warp sorts one
+    row entirely in registers and writes only K outputs to gmem.
+    Bit-exact to aten on values; indices on ties land in
+    ``(value desc, idx asc)`` order which doesn't match aten's small-K
+    CUDA kernel - same gather invariant though.
+
+  * Fused radix-select (larger K): K in {64, 128, 256, 512, 1024}.
+    Four radix byte passes over smem histograms, then a cooperative
+    bitonic sort of the K survivors. Two phase-2/phase-3 specialisations:
+      - Deterministic (under ``torch.use_deterministic_algorithms``):
+        block-wide prefix-sum gather + lex ``(ord, -idx)`` sort.
+        Bit-exact match to aten on values and indices.
+      - Non-deterministic: smem atomic-counter gather + ord-only sort.
+        Faster (~5-10%); indices may differ across runs on threshold ties.
+
+Common eligibility (see ``_cond``):
+  - fp32 input, CUDA, not COW
+  - ``largest=True``, ``sorted=True``
+  - reducing over the last axis, ``self`` contiguous (2D flatten is a view)
+  - row count at least one full wave of SMs (perf gate)
+
+Per-kernel additional eligibility:
+  - register: K in {16, 32}, N pow2 in supported range above
+  - radix: K in {64, 128, 256, 512, 1024}, ``N >= MIN_N_MULT[k] * k``,
+    ``N % 4 == 0`` (128-bit vector loads)
+
+Anything else falls through to aten.
+"""
+
+import functools
+import math
+
+import torch
+
+from ... import cutedsl_utils as cu
+from ._common import (
+    any_cow,
+    flatten_last_dim,
+    last_dim_row_major_ok,
+    unflatten_last_dim,
+)
+
+
+_RADIX_KS: frozenset[int] = frozenset({64, 128, 256, 512, 1024})
+_REGISTER_KS: frozenset[int] = frozenset({16, 32})
+_SUPPORTED_KS: frozenset[int] = _RADIX_KS | _REGISTER_KS
+
+# Per-K minimum N for the radix kernel below which aten wins on B200.
+# At low N the radix sweep (4 passes + gather) has too many passes over
+# too little data to beat aten's launch-bound multi-pass kernel.
+# K=512 needs ~8*K, K=1024 needs ~32*K because their smem footprint
+# drops occupancy.
+_RADIX_MIN_N_MULTIPLIER: dict[int, int] = {
+    64: 2,
+    128: 2,
+    256: 2,
+    512: 8,
+    1024: 32,
+}
+
+# Register kernel per-K (min, max) N range, both bounds powers of 2.
+# Below the min, VEC = N/32 is too small (most lanes idle, bitonic
+# overhead dominates) and aten wins at large M. Above the max, radix
+# (K=32) or aten (K=16 N>2048) takes over.
+# Tuned on B200: K=16 wins down to N=64 across all M; K=32 only beats
+# both aten and radix at exactly N=256.
+_REGISTER_N_RANGE: dict[int, tuple[int, int]] = {
+    16: (64, 2048),
+    32: (256, 256),
+}
+
+
+def _is_pow2(x: int) -> bool:
+    return x > 0 and (x & (x - 1)) == 0
+
+
+def _kernel_for(k: int, n: int) -> str | None:
+    """Pick the kernel for (K, N): "register", "radix", or None (aten)."""
+    if k in _REGISTER_KS:
+        n_min, n_max = _REGISTER_N_RANGE[k]
+        if _is_pow2(n) and n_min <= n <= n_max:
+            return "register"
+    if k in _RADIX_KS:
+        if n >= _RADIX_MIN_N_MULTIPLIER[k] * k and (n % 4) == 0:
+            return "radix"
+    return None
+
+
+@functools.cache
+def _min_rows_for_full_wave(device_idx: int) -> int:
+    """Row threshold below which the one-CTA-per-row kernel underutilises
+    the GPU. A full wave is SM-count CTAs; below that, aten's multi-CTA
+    kernel gets more parallelism out of the same rows and wins."""
+    return torch.cuda.get_device_properties(device_idx).multi_processor_count
+
+
+def _eligible(
+    self: torch.Tensor, k: int, dim: int, largest: bool, sorted_: bool
+) -> bool:
+    if not self.is_cuda or self.dtype != torch.float32:
+        return False
+    if any_cow(self):
+        return False
+    if not largest or not sorted_:
+        return False
+    if not last_dim_row_major_ok(self, dim):
+        return False
+    N = self.shape[-1] if self.ndim >= 1 else 0
+    if _kernel_for(k, N) is None:
+        return False
+    # Performance gate: reject shapes where aten is faster. One CTA per
+    # row (radix) or one warp per row (register) - either way row_count
+    # below SM_count leaves the GPU underutilised.
+    M = math.prod(self.shape[:-1]) if self.ndim >= 1 else 0
+    if M < _min_rows_for_full_wave(self.device.index or 0):
+        return False
+    return True
+
+
+def _cond(
+    self: torch.Tensor,
+    k: int,
+    dim: int = -1,
+    largest: bool = True,
+    sorted: bool = True,
+    *args,
+    **kwargs,
+) -> bool:
+    return _eligible(self, int(k), int(dim), bool(largest), bool(sorted))
+
+
+def _out_cond(
+    self: torch.Tensor,
+    k: int,
+    dim: int = -1,
+    largest: bool = True,
+    sorted: bool = True,
+    *,
+    values: torch.Tensor,
+    indices: torch.Tensor,
+) -> bool:
+    if not _cond(self, k, dim, largest, sorted):
+        return False
+    if any_cow(values, indices):
+        return False
+    expected_shape = self.shape[:-1] + (k,)
+    if values.dtype != torch.float32 or values.shape != expected_shape:
+        return False
+    if indices.dtype != torch.int64 or indices.shape != expected_shape:
+        return False
+    return True
+
+
+def _run(self: torch.Tensor, k: int) -> tuple[torch.Tensor, torch.Tensor]:
+    from .cutedsl_kernels import topk_radix, topk_register
+
+    self_2d = flatten_last_dim(self)
+    N = self_2d.shape[-1]
+    kernel = _kernel_for(k, N)
+
+    def _launch() -> tuple[torch.Tensor, torch.Tensor]:
+        if kernel == "register":
+            return topk_register(self_2d, k)
+        # Pick the deterministic kernel under torch.use_deterministic_algorithms
+        # (kept off by default for perf; the non-det kernel still produces
+        # correct top-K values but indices may differ on ties).
+        deterministic = torch.are_deterministic_algorithms_enabled()
+        return topk_radix(self_2d, k, deterministic=deterministic)
+
+    # The Python-native dispatch path does not get an automatic CUDA device
+    # guard before launching the kernel (unlike the generated C++ ATen path),
+    # so the CuTeDSL kernel runs on the current device's stream. Guard the
+    # launch when the input is not already on the current device, while leaving
+    # the common already-current path direct to avoid the context-manager
+    # overhead. See #187983 for the same fix on the bmm override.
+    device = self.get_device()
+    if device == torch.cuda.current_device():
+        values_2d, indices_2d = _launch()
+    else:
+        with torch.cuda.device(device):
+            values_2d, indices_2d = _launch()
+    return unflatten_last_dim(values_2d, indices_2d, self, k)
+
+
+def _impl(
+    self: torch.Tensor,
+    k: int,
+    dim: int = -1,
+    largest: bool = True,
+    sorted: bool = True,
+    *args,
+    **kwargs,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    return _run(self, int(k))
+
+
+def _out_impl(
+    self: torch.Tensor,
+    k: int,
+    dim: int = -1,
+    largest: bool = True,
+    sorted: bool = True,
+    *,
+    values: torch.Tensor,
+    indices: torch.Tensor,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    v, i = _run(self, int(k))
+    values.copy_(v)
+    indices.copy_(i)
+    return values, indices
+
+
+def register_to_dispatch() -> None:
+    for op_symbol, cond, impl in (
+        ("topk", _cond, _impl),
+        ("topk.values", _out_cond, _out_impl),
+    ):
+        cu.register_op_override(
+            "aten",
+            op_symbol,
+            "CUDA",
+            cond=cond,
+            impl=impl,
+            allow_multiple_override=True,
+        )

.venv/lib/python3.12/site-packages/torch/_native/ops/topk/cutedsl_kernels.py

@@ -0,0 +1,874 @@
+"""CuTeDSL fp32 top-K kernels.
+
+Two kernels live here, picked by K and N in ``cutedsl_impl.py``:
+
+``topk_radix`` - fused radix-select for K in {64,128,256,512,1024}.
+Layout per CTA (one row):
+  * Phase 1 - four radix byte passes (MSB to LSB) build shared-memory
+    histograms via smem atomic-add; thread 0 scans descending to locate
+    the bin that contains the k-th-largest ordinal.
+  * Phase 2 - gather elements at-or-above the radix threshold. Two
+    specialisations selected by the ``deterministic`` constexpr:
+      - True: per-step block-wide exclusive prefix sums hand each
+        thread an exact write slot, eq-tied elements stage in a side
+        buffer; first ``remaining_k`` of them are appended in input
+        order. Stable across runs.
+      - False: smem atomic counters claim slots on the fly. Cheaper
+        but indices on threshold ties depend on atomic resolution
+        order.
+  * Phase 3 - cooperative bitonic sort descending. Block size is
+    ``max(K, 256)``; K threads own one element each, the rest sit the
+    sort out but still reach every barrier. Comparator is lex
+    ``(ord, -idx)`` (deterministic) or ord-only (non-deterministic).
+  * Phase 4 - write (values, indices) to global memory.
+
+``topk_register`` - register-resident top-K for K in {16, 32} with
+N a power of 2 in [K, 2048]. Each warp owns one row; ``ROWS_PER_CTA``
+warps share a CTA. Per-thread VEC = N/32 elements held in registers,
+encoded as Int64 ``(ord << 32) | ~idx`` keys so a descending sort gives
+``(value desc, idx asc)`` matching aten. Local bitonic sort, then a
+warp-cooperative bitonic-topk merge across butterfly partners. No smem,
+no global staging - only the final K writes hit gmem. Bit-exact to aten.
+
+Both kernels do one launch; only loads/stores of the input and final
+outputs hit global memory.
+"""
+
+import math
+
+import cuda.bindings.driver as cuda  # pyrefly: ignore[missing-import]
+
+import cutlass
+import cutlass.cute as cute
+from cutlass import const_expr, Float32, Int32, Int64
+from cutlass._mlir.dialects import llvm
+from cutlass.cutlass_dsl import dsl_user_op, T
+
+import torch
+from torch._native.instrumentation import instrumented_cutedsl_cache
+
+
+_NEG_INF_BITS: int = 0xFF800000
+_N_HIST_BINS: int = 256
+
+
+def _num_threads_for_k(k: int) -> int:
+    """Pick block size for a given K.
+
+    Bitonic sort in phase 3 assigns one element per thread, so we need
+    at least K threads. Using ``max(K, _N_HIST_BINS)`` keeps the phase-1
+    histogram-zero loop one-shot for small K while letting K grow up to
+    the CUDA 1024-thread cap.
+    """
+    return max(k, _N_HIST_BINS)
+
+
+@dsl_user_op
+def _elem_ptr(x: cute.Tensor, coord, *, loc=None, ip=None) -> cute.Pointer:
+    return x.iterator + cute.crd2idx(coord, x.layout, loc=loc, ip=ip)
+
+
+@dsl_user_op
+def _bitcast_f32_to_i32(val, *, loc=None, ip=None) -> Int32:
+    return Int32(llvm.bitcast(T.i32(), Float32(val).ir_value()))
+
+
+@dsl_user_op
+def _bitcast_i32_to_f32(val, *, loc=None, ip=None) -> Float32:
+    return Float32(llvm.bitcast(T.f32(), Int32(val).ir_value()))
+
+
+@cute.jit
+def _f32_to_radix_ord(val: Float32) -> Int32:
+    """Map fp32 to a monotone Int32 ordinal whose unsigned MSB->LSB byte
+    order matches descending fp32 order. Negatives invert all bits;
+    non-negatives keep their bits. With the byte-0 xor of 0x80 (applied
+    at the histogram-bin level), this gives a total order suitable for
+    MSB-first radix select.
+
+    NaN of either sign maps to 0x7FFFFFFF (the largest ordinal under the
+    byte-0 xor), matching aten's TopKTypeConfig<float> behaviour: NaN
+    sorts at the very top of largest-first topk regardless of sign.
+    """
+    bits = _bitcast_f32_to_i32(val)
+    ord_ = bits ^ ((bits >> Int32(31)) & Int32(0x7FFFFFFF))
+    # NaN detection: bits with all-ones exponent and non-zero mantissa.
+    # Equivalent to ``val != val``, but the DSL doesn't expose that
+    # comparator; the bit test is exact for IEEE-754 fp32.
+    is_nan = (bits & Int32(0x7FFFFFFF)) > Int32(0x7F800000)
+    return Int32(0x7FFFFFFF) if is_nan else ord_
+
+
+def _smem_scalar(smem: cutlass.utils.SmemAllocator, dtype) -> cute.Tensor:
+    """Allocate a single-element smem tensor (scalar bookkeeping slot)."""
+    return smem.allocate_tensor(dtype, cute.make_layout((1,)), byte_alignment=4)
+
+
+@cute.jit
+def _load_vec_f32(ptr: cute.Pointer, vec_elems: cutlass.Constexpr) -> cute.Tensor:
+    """Vectorized gmem -> rmem load of ``vec_elems`` contiguous fp32.
+
+    Cute picks the widest safe instruction (e.g. LDG.128 for a 4-wide
+    fp32 tile) from the static shape.
+    """
+    gsrc = cute.make_tensor(ptr, cute.make_layout(vec_elems))
+    rvals = cute.make_rmem_tensor(vec_elems, Float32)
+    cute.autovec_copy(gsrc, rvals)
+    return rvals
+
+
+@cute.jit
+def _warp_inclusive_prefix(val: Int32, lane: Int32) -> Int32:
+    """Inclusive Hillis-Steele prefix sum across a single warp."""
+    for i in cutlass.range_constexpr(int(math.log2(cute.arch.WARP_SIZE))):
+        offset = 1 << i
+        # mask_and_clamp=0 so lanes < offset get 0 (no contribution).
+        partial = cute.arch.shuffle_sync_up(val, offset=offset, mask_and_clamp=0)
+        if lane >= Int32(offset):
+            val = val + partial
+    return val
+
+
+@cute.jit
+def _block_excl_prefix_i32(
+    val: Int32,
+    scratch: cute.Tensor,
+    lane: Int32,
+    warp: Int32,
+    num_warps: cutlass.Constexpr,
+) -> tuple[Int32, Int32]:
+    """Block-wide exclusive prefix sum over per-thread ``val``.
+
+    Returns ``(excl_pfx, total)``: ``excl_pfx`` is this thread's
+    exclusive prefix; ``total`` is the sum across all threads in the
+    block. ``scratch`` must have at least ``num_warps + 1`` Int32 slots
+    and is clobbered.
+
+    Implementation: warp-level Hillis-Steele scan, then warp 0 scans
+    the per-warp totals to produce per-warp offsets, then add.
+    """
+    WARP_SIZE = const_expr(cute.arch.WARP_SIZE)
+    # Step 1: per-warp inclusive scan.
+    incl = _warp_inclusive_prefix(val, lane)
+    excl_intra = incl - val
+    # Step 2: last lane in each warp publishes warp's inclusive total.
+    if lane == Int32(WARP_SIZE - 1):
+        scratch[warp] = incl
+    cute.arch.barrier()
+    # Step 3: warp 0 prefix-sums the per-warp totals.
+    if warp == Int32(0):
+        warp_val = Int32(0)
+        if lane < Int32(num_warps):
+            warp_val = scratch[lane]
+        warp_incl = _warp_inclusive_prefix(warp_val, lane)
+        warp_excl = warp_incl - warp_val
+        if lane < Int32(num_warps):
+            scratch[lane] = warp_excl
+        # Stash the block total in a slot beyond the per-warp set so
+        # other warps can read it without a second reduction.
+        if lane == Int32(num_warps - 1):
+            scratch[num_warps] = warp_incl
+    cute.arch.barrier()
+    excl_pfx = scratch[warp] + excl_intra
+    total = scratch[num_warps]
+    cute.arch.barrier()  # let everyone consume scratch before next call
+    return excl_pfx, total
+
+
+class _RadixSelectTopK:
+    """One-CTA-per-row fused radix-select + bitonic sort.
+
+    ``N``, ``K`` and ``deterministic`` are specialised at compile time:
+    the JIT cache keys on ``(N, K, deterministic)`` so a row-length or
+    determinism-mode change forces a recompile.
+
+    When ``deterministic`` is True, phase 2 uses block-wide prefix-sum
+    scans for input-stable gather and phase 3's bitonic comparator uses
+    a lex ``(ord, -idx)`` key. Output matches aten bit-exactly.
+
+    When ``deterministic`` is False, phase 2 uses smem atomic counters
+    for the gather and phase 3 sorts by ord-only. Faster (no extra smem
+    bookkeeping, no per-step block barrier on the gather), but ties at
+    the threshold radix bin are resolved non-deterministically and
+    indices may differ across runs.
+    """
+
+    VEC: int = 4
+
+    def __init__(self, N: int, K: int, deterministic: bool = True):
+        self.N = N
+        self.K = K
+        self.deterministic = deterministic
+        self.NUM_THREADS = _num_threads_for_k(K)
+        self.NUM_STAGES = int(math.log2(K))
+        TILE = self.NUM_THREADS * self.VEC
+        self.VEC_ITERS = N // TILE
+        self.VEC_TAIL_START = self.VEC_ITERS * TILE
+        self.SCALAR_TAIL_ITERS = (
+            N - self.VEC_TAIL_START + self.NUM_THREADS - 1
+        ) // self.NUM_THREADS
+
+    @cute.jit
+    def __call__(
+        self,
+        mX: cute.Tensor,
+        mValues: cute.Tensor,
+        mIndices: cute.Tensor,
+        stream: cuda.CUstream,
+    ):
+        M = mX.shape[0]
+        self.kernel(mX, mValues, mIndices).launch(
+            grid=[M, 1, 1],
+            block=[self.NUM_THREADS, 1, 1],
+            stream=stream,
+        )
+
+    @cute.kernel
+    def kernel(self, mX: cute.Tensor, mValues: cute.Tensor, mIndices: cute.Tensor):
+        tidx, _, _ = cute.arch.thread_idx()
+        row, _, _ = cute.arch.block_idx()
+
+        N = const_expr(self.N)
+        K = const_expr(self.K)
+        NT = const_expr(self.NUM_THREADS)
+        VEC = const_expr(self.VEC)
+        VEC_ITERS = const_expr(self.VEC_ITERS)
+        VEC_TAIL_START = const_expr(self.VEC_TAIL_START)
+        SCALAR_TAIL_ITERS = const_expr(self.SCALAR_TAIL_ITERS)
+        N_HIST_BINS = const_expr(_N_HIST_BINS)
+
+        smem = cutlass.utils.SmemAllocator()
+        s_hist = smem.allocate_tensor(
+            Int32, cute.make_layout((256,)), byte_alignment=16
+        )
+        s_prefix = _smem_scalar(smem, Int32)
+        s_mask = _smem_scalar(smem, Int32)
+        s_rem_k = _smem_scalar(smem, Int32)
+        # Phase-2 bookkeeping. Non-deterministic gather uses two
+        # atomic-add counters; deterministic gather carries running
+        # totals in registers.
+        s_write_ctr = _smem_scalar(smem, Int32)
+        s_eq_ctr = _smem_scalar(smem, Int32)
+        s_vals = smem.allocate_tensor(
+            Float32, cute.make_layout((K,)), byte_alignment=16
+        )
+        s_ords = smem.allocate_tensor(Int32, cute.make_layout((K,)), byte_alignment=16)
+        s_idxs = smem.allocate_tensor(Int32, cute.make_layout((K,)), byte_alignment=16)
+        # Side buffer for equal-threshold elements (deterministic gather only).
+        # Always allocated to keep the smem layout straightforward;
+        # measurements show no occupancy benefit from making it conditional.
+        s_eq_vals = smem.allocate_tensor(
+            Float32, cute.make_layout((K,)), byte_alignment=16
+        )
+        s_eq_idxs = smem.allocate_tensor(
+            Int32, cute.make_layout((K,)), byte_alignment=16
+        )
+
+        if tidx == 0:
+            s_prefix[0] = Int32(0)
+            s_mask[0] = Int32(0)
+            s_rem_k[0] = Int32(K)
+        cute.arch.barrier()
+
+        # Phase 1: four radix byte passes, MSB to LSB.
+        for byte_pos in cutlass.range_constexpr(4):
+            shift = (3 - byte_pos) * 8
+            xor_val = 128 if byte_pos == 0 else 0
+
+            # Zero the 256-bin histogram. When NT > 256 (e.g. K=1024) only
+            # the first 256 threads participate; the histogram is always
+            # exactly 256 bins regardless of K.
+            if tidx < N_HIST_BINS:
+                s_hist[tidx] = Int32(0)
+            cute.arch.barrier()
+
+            prefix = s_prefix[0]
+            decided_mask = s_mask[0]
+
+            if byte_pos == 0:
+                # First pass: decided_mask==0, every element participates.
+                for step in cutlass.range(VEC_ITERS):
+                    base = step * NT * VEC + tidx * VEC
+                    rvals = _load_vec_f32(_elem_ptr(mX, (row, base)), VEC)
+                    for vi in cutlass.range_constexpr(self.VEC):
+                        ords = _f32_to_radix_ord(rvals[vi])
+                        byte_val = ((ords >> Int32(shift)) & Int32(255)) ^ Int32(
+                            xor_val
+                        )
+                        cute.arch.atomic_add(_elem_ptr(s_hist, byte_val), Int32(1))
+                for step in cutlass.range(SCALAR_TAIL_ITERS):
+                    idx = VEC_TAIL_START + step * NT + tidx
+                    if idx < N:
+                        ords = _f32_to_radix_ord(mX[row, idx])
+                        byte_val = ((ords >> Int32(shift)) & Int32(255)) ^ Int32(
+                            xor_val
+                        )
+                        cute.arch.atomic_add(_elem_ptr(s_hist, byte_val), Int32(1))
+            else:
+                for step in cutlass.range(VEC_ITERS):
+                    base = step * NT * VEC + tidx * VEC
+                    rvals = _load_vec_f32(_elem_ptr(mX, (row, base)), VEC)
+                    for vi in cutlass.range_constexpr(self.VEC):
+                        ords = _f32_to_radix_ord(rvals[vi])
+                        if (ords & decided_mask) == prefix:
+                            byte_val = ((ords >> Int32(shift)) & Int32(255)) ^ Int32(
+                                xor_val
+                            )
+                            cute.arch.atomic_add(_elem_ptr(s_hist, byte_val), Int32(1))
+                for step in cutlass.range(SCALAR_TAIL_ITERS):
+                    idx = VEC_TAIL_START + step * NT + tidx
+                    if idx < N:
+                        ords = _f32_to_radix_ord(mX[row, idx])
+                        if (ords & decided_mask) == prefix:
+                            byte_val = ((ords >> Int32(shift)) & Int32(255)) ^ Int32(
+                                xor_val
+                            )
+                            cute.arch.atomic_add(_elem_ptr(s_hist, byte_val), Int32(1))
+            cute.arch.barrier()
+
+            # Thread 0 picks the bin that contains the k-th-largest.
+            if tidx == 0:
+                remaining_k = s_rem_k[0]
+                acc = Int32(0)
+                found = Int32(0)
+                sel_bin = Int32(0)
+                elems_above = Int32(0)
+
+                for b in cutlass.range(256):
+                    bin_idx = Int32(255) - b
+                    count = s_hist[bin_idx]
+                    if found == Int32(0):
+                        if acc + count >= remaining_k:
+                            sel_bin = bin_idx
+                            elems_above = acc
+                            found = Int32(1)
+                    acc = acc + count
+
+                actual_byte = sel_bin ^ Int32(xor_val)
+                s_prefix[0] = prefix | (actual_byte << Int32(shift))
+                s_mask[0] = decided_mask | (Int32(255) << Int32(shift))
+                s_rem_k[0] = remaining_k - elems_above
+
+            cute.arch.barrier()
+
+        # Phase 2: gather elements at-or-above the radix threshold.
+        # Two implementations selected at compile time:
+        #   * Deterministic: per-step block-wide exclusive prefix sums
+        #     give each thread an exact write slot; eq-threshold ties
+        #     stage in a side buffer and the first ``remaining_k`` get
+        #     appended in input-index order.
+        #   * Non-deterministic: smem atomic counters claim slots on
+        #     the fly. Faster but tied elements at the threshold bin
+        #     are picked in atomic-resolution order.
+        threshold = s_prefix[0]
+        remaining_k = s_rem_k[0]
+
+        if tidx == 0:
+            s_write_ctr[0] = Int32(0)
+            s_eq_ctr[0] = Int32(0)
+        if tidx < K:
+            s_vals[tidx] = _bitcast_i32_to_f32(Int32(_NEG_INF_BITS))
+            s_idxs[tidx] = Int32(0)
+        cute.arch.barrier()
+
+        if const_expr(self.deterministic):
+            WARP_SIZE = const_expr(cute.arch.WARP_SIZE)
+            NUM_WARPS = const_expr(NT // WARP_SIZE)
+            lane_idx = tidx % Int32(WARP_SIZE)
+            warp_idx = tidx // Int32(WARP_SIZE)
+
+            # --- Vec + scalar tail (deterministic) ---
+            # Pack (n_above, n_eq) into a single Int32 as (high16, low16) so
+            # we can run one block-wide prefix sum per step instead of two.
+            # Per-step bounds: above+eq counts <= VEC*NT = 4*1024 = 4096,
+            # comfortably below 2^16; the sums share no bits so the low-half
+            # never carries into the high half.
+            #
+            # Carry the running bases in registers (every thread has
+            # ``packed_step_total`` from the scan) instead of going through
+            # smem each step.
+            above_base = Int32(0)
+            eq_base = Int32(0)
+            for step in cutlass.range(VEC_ITERS):
+                base = step * NT * VEC + tidx * VEC
+                rvals = _load_vec_f32(_elem_ptr(mX, (row, base)), VEC)
+
+                # Hoist per-element classification into per-lane registers
+                # so the count pass and write pass don't redo the radix-ord
+                # transform and threshold compare.
+                # Class encoding: 2 = above, 1 = eq, 0 = below.
+                cls_reg = cute.make_rmem_tensor(VEC, Int32)
+                packed_local = Int32(0)
+                for vi in cutlass.range_constexpr(self.VEC):
+                    o = _f32_to_radix_ord(rvals[vi])
+                    if o > threshold:
+                        cls_reg[vi] = Int32(2)
+                        packed_local = packed_local + Int32(1 << 16)
+                    elif o == threshold:
+                        cls_reg[vi] = Int32(1)
+                        packed_local = packed_local + Int32(1)
+                    else:
+                        cls_reg[vi] = Int32(0)
+
+                # Block-wide exclusive prefix sum. ``s_hist`` is reused as
+                # scratch for the warp-total scan (Phase 1 is done with it).
+                packed_pfx, packed_step_total = _block_excl_prefix_i32(
+                    packed_local, s_hist, lane_idx, warp_idx, NUM_WARPS
+                )
+                above_pfx = packed_pfx >> Int32(16)
+                eq_pfx = packed_pfx & Int32(0xFFFF)
+
+                # Per-thread write offsets within this step.
+                my_above = above_base + above_pfx
+                my_eq = eq_base + eq_pfx
+                for vi in cutlass.range_constexpr(self.VEC):
+                    val_f32 = rvals[vi]
+                    cls = cls_reg[vi]
+                    idx = base + Int32(vi)
+                    if cls == Int32(2):
+                        if my_above < Int32(K):
+                            s_vals[my_above] = val_f32
+                            s_idxs[my_above] = Int32(idx)
+                        my_above = my_above + Int32(1)
+                    elif cls == Int32(1):
+                        if my_eq < remaining_k:
+                            s_eq_vals[my_eq] = val_f32
+                            s_eq_idxs[my_eq] = Int32(idx)
+                        my_eq = my_eq + Int32(1)
+
+                # Advance running bases. Cap eq at remaining_k - we never
+                # need more. All threads update in registers; no smem.
+                above_base = above_base + (packed_step_total >> Int32(16))
+                eq_base = min(
+                    remaining_k, eq_base + (packed_step_total & Int32(0xFFFF))
+                )
+
+            # --- Scalar tail ---
+            for step in cutlass.range(SCALAR_TAIL_ITERS):
+                idx = VEC_TAIL_START + step * NT + tidx
+                valid = idx < N
+                packed_local = Int32(0)
+                if valid:
+                    ords = _f32_to_radix_ord(mX[row, idx])
+                    if ords > threshold:
+                        packed_local = Int32(1 << 16)
+                    elif ords == threshold:
+                        packed_local = Int32(1)
+
+                packed_pfx, packed_step_total = _block_excl_prefix_i32(
+                    packed_local, s_hist, lane_idx, warp_idx, NUM_WARPS
+                )
+                above_pfx = packed_pfx >> Int32(16)
+                eq_pfx = packed_pfx & Int32(0xFFFF)
+
+                my_above = above_base + above_pfx
+                my_eq = eq_base + eq_pfx
+                if valid:
+                    val_f32 = mX[row, idx]
+                    ords = _f32_to_radix_ord(val_f32)
+                    if ords > threshold:
+                        if my_above < Int32(K):
+                            s_vals[my_above] = val_f32
+                            s_idxs[my_above] = Int32(idx)
+                    elif ords == threshold:
+                        if my_eq < remaining_k:
+                            s_eq_vals[my_eq] = val_f32
+                            s_eq_idxs[my_eq] = Int32(idx)
+
+                above_base = above_base + (packed_step_total >> Int32(16))
+                eq_base = min(
+                    remaining_k, eq_base + (packed_step_total & Int32(0xFFFF))
+                )
+
+            # The eq-merge below has each thread read s_eq_vals[tidx - n_above],
+            # i.e. a slot written by some other thread during the gather above.
+            # The last barrier inside _block_excl_prefix_i32 fires *before* the
+            # final per-step writes to s_eq_vals, so cross-thread visibility of
+            # those writes isn't guaranteed without a fresh barrier here.
+            cute.arch.barrier()
+
+            # Append eq-bucket survivors after the above-bucket ones to
+            # fill ``s_vals`` / ``s_idxs`` to exactly K entries.
+            n_above = above_base
+            if tidx < K:
+                offset_into_eq = Int32(tidx) - n_above
+                if offset_into_eq >= Int32(0) and offset_into_eq < remaining_k:
+                    s_vals[tidx] = s_eq_vals[offset_into_eq]
+                    s_idxs[tidx] = s_eq_idxs[offset_into_eq]
+            cute.arch.barrier()
+        else:
+            # Non-deterministic atomic-counter gather.
+            for step in cutlass.range(VEC_ITERS):
+                base = step * NT * VEC + tidx * VEC
+                rvals = _load_vec_f32(_elem_ptr(mX, (row, base)), VEC)
+                for vi in cutlass.range_constexpr(self.VEC):
+                    val_f32 = rvals[vi]
+                    idx = base + Int32(vi)
+                    ords = _f32_to_radix_ord(val_f32)
+                    if ords > threshold:
+                        pos = cute.arch.atomic_add(_elem_ptr(s_write_ctr, 0), Int32(1))
+                        if pos < Int32(K):
+                            s_vals[pos] = val_f32
+                            s_idxs[pos] = Int32(idx)
+                    elif ords == threshold:
+                        eq_pos = cute.arch.atomic_add(_elem_ptr(s_eq_ctr, 0), Int32(1))
+                        if eq_pos < remaining_k:
+                            pos = cute.arch.atomic_add(
+                                _elem_ptr(s_write_ctr, 0), Int32(1)
+                            )
+                            if pos < Int32(K):
+                                s_vals[pos] = val_f32
+                                s_idxs[pos] = Int32(idx)
+            for step in cutlass.range(SCALAR_TAIL_ITERS):
+                idx = VEC_TAIL_START + step * NT + tidx
+                if idx < N:
+                    val_f32 = mX[row, idx]
+                    ords = _f32_to_radix_ord(val_f32)
+                    if ords > threshold:
+                        pos = cute.arch.atomic_add(_elem_ptr(s_write_ctr, 0), Int32(1))
+                        if pos < Int32(K):
+                            s_vals[pos] = val_f32
+                            s_idxs[pos] = Int32(idx)
+                    elif ords == threshold:
+                        eq_pos = cute.arch.atomic_add(_elem_ptr(s_eq_ctr, 0), Int32(1))
+                        if eq_pos < remaining_k:
+                            pos = cute.arch.atomic_add(
+                                _elem_ptr(s_write_ctr, 0), Int32(1)
+                            )
+                            if pos < Int32(K):
+                                s_vals[pos] = val_f32
+                                s_idxs[pos] = Int32(idx)
+            cute.arch.barrier()
+
+        # Phase 3: cooperative bitonic sort (descending) on a composite
+        # ``(ord, ~idx)`` Int64 key so equal-value entries break ties by
+        # input index, matching aten's stable ordering.
+        # K lanes own one element each; lanes >= K clamp their smem
+        # index to a dummy slot so they can participate in barriers
+        # without OOB reads/writes. The writes from those lanes are
+        # discarded via the `tidx < K` guard on the store.
+        sort_tidx = tidx if tidx < Int32(K) else Int32(0)
+        if tidx < K:
+            s_ords[tidx] = _f32_to_radix_ord(s_vals[sort_tidx])
+        cute.arch.barrier()
+
+        for stage in cutlass.range_constexpr(self.NUM_STAGES):
+            for sub_rev in cutlass.range_constexpr(stage + 1):
+                sub = stage - sub_rev
+                step_size = 1 << sub
+
+                # Snapshot both participants before the barrier; after the
+                # barrier the other thread may have overwritten its slot,
+                # so we must read our own ord now. Inactive lanes clamp
+                # their partner index to 0 (a safe in-bounds read) - their
+                # resulting comparisons are discarded by the store guard.
+                partner = (tidx ^ Int32(step_size)) if tidx < Int32(K) else Int32(0)
+                my_o = s_ords[sort_tidx]
+                my_i = s_idxs[sort_tidx]
+                p_o = s_ords[partner]
+                p_v = s_vals[partner]
+                p_i = s_idxs[partner]
+                cute.arch.barrier()
+
+                # Comparator. Deterministic mode uses a lex
+                # ``(ord, -idx)`` tie-break so equal-ord entries land in
+                # ascending-idx order (matching aten). Non-deterministic
+                # mode skips the tiebreak (cheaper compare-exchange).
+                if const_expr(self.deterministic):
+                    self_lt_partner = (my_o < p_o) or (my_o == p_o and my_i > p_i)
+                    self_gt_partner = (my_o > p_o) or (my_o == p_o and my_i < p_i)
+                else:
+                    self_lt_partner = my_o < p_o
+                    self_gt_partner = my_o > p_o
+                block_dir = (tidx >> Int32(stage + 1)) & Int32(1)
+                if tidx < K:
+                    if tidx < partner:
+                        if block_dir == Int32(0):
+                            if self_lt_partner:
+                                s_ords[tidx] = p_o
+                                s_vals[tidx] = p_v
+                                s_idxs[tidx] = p_i
+                        else:
+                            if self_gt_partner:
+                                s_ords[tidx] = p_o
+                                s_vals[tidx] = p_v
+                                s_idxs[tidx] = p_i
+                    else:
+                        if block_dir == Int32(0):
+                            if self_gt_partner:
+                                s_ords[tidx] = p_o
+                                s_vals[tidx] = p_v
+                                s_idxs[tidx] = p_i
+                        else:
+                            if self_lt_partner:
+                                s_ords[tidx] = p_o
+                                s_vals[tidx] = p_v
+                                s_idxs[tidx] = p_i
+                cute.arch.barrier()
+
+        # Phase 4: results to gmem.
+        if tidx < K:
+            mValues[row, tidx] = s_vals[tidx]
+            mIndices[row, tidx] = s_idxs[tidx]
+
+
+def _make_fake_tensor(dtype, shape, divisibility=1):
+    stride = tuple(
+        cute.sym_int64(divisibility=divisibility) if i != len(shape) - 1 else 1
+        for i in range(len(shape))
+    )
+    return cute.runtime.make_fake_tensor(
+        dtype,
+        shape,
+        stride=stride,
+        assumed_align=divisibility * dtype.width // 8,
+    )
+
+
+@instrumented_cutedsl_cache(
+    "aten::topk",
+    key_fn=lambda N, K, deterministic: f"radix N={N} K={K} det={deterministic}",
+)
+def _compile_topk_radix(N: int, K: int, deterministic: bool):
+    batch_sym = cute.sym_int()
+    div_n = math.gcd(4, N)
+    div_k = math.gcd(4, K)
+    x_fake = _make_fake_tensor(Float32, (batch_sym, N), div_n)
+    v_fake = _make_fake_tensor(Float32, (batch_sym, K), div_k)
+    i_fake = _make_fake_tensor(Int32, (batch_sym, K), div_k)
+    return cute.compile(
+        _RadixSelectTopK(N, K, deterministic=deterministic),
+        x_fake,
+        v_fake,
+        i_fake,
+        cute.runtime.make_fake_stream(use_tvm_ffi_env_stream=True),
+        options="--enable-tvm-ffi",
+    )
+
+
+def topk_radix(
+    x: torch.Tensor, k: int, *, deterministic: bool = True
+) -> tuple[torch.Tensor, torch.Tensor]:
+    """Fused radix-select top-K for fp32 2D contiguous ``x``.
+
+    Returns ``(values[M, K]: fp32, indices[M, K]: int64)`` with K sorted
+    descending per row. Caller must ensure ``k`` is in the supported set
+    (see ``cutedsl_impl.py``) and ``N % 4 == 0``.
+
+    ``deterministic`` controls the gather + sort tie-breaking strategy:
+    True (default) uses prefix-sum gather + lex comparator and matches
+    aten bit-exactly; False uses smem atomic gather + ord-only sort and
+    is faster but indices may differ on ties.
+    """
+    M, N = x.shape
+    out_v = torch.empty(M, k, dtype=torch.float32, device=x.device)
+    # Kernel writes int32 indices; widen before returning to match aten.
+    out_i_i32 = torch.empty(M, k, dtype=torch.int32, device=x.device)
+    _compile_topk_radix(N, k, deterministic)(x, out_v, out_i_i32)
+    return out_v, out_i_i32.to(torch.int64)
+
+
+# ---------------------------------------------------------------------------
+# Register-resident top-K (small K, small N).
+# ---------------------------------------------------------------------------
+
+
+@cute.jit
+def _make_key(val: Float32, idx: Int32) -> Int64:
+    """Compose the descending-sort key: ``(ord_u32 << 32) | (~idx_u32)``.
+
+    Sorting this Int64 descending gives ``(value desc, idx asc)`` -
+    exactly aten's tie-break order. Real fp32 inputs (no NaN) keep keys
+    away from INT64_MIN, leaving that bit pattern free as a sentinel.
+    """
+    ord32 = _f32_to_radix_ord(val)
+    ord64 = Int64(ord32) & Int64(0xFFFFFFFF)
+    inv_idx64 = Int64(~idx) & Int64(0xFFFFFFFF)
+    return (ord64 << Int64(32)) | inv_idx64
+
+
+@cute.jit
+def _decode_key(key: Int64) -> tuple[Float32, Int32]:
+    ord32 = Int32(key >> Int64(32))
+    inv_idx = Int32(key & Int64(0xFFFFFFFF))
+    val_bits = ord32 ^ ((ord32 >> Int32(31)) & Int32(0x7FFFFFFF))
+    return Float32(llvm.bitcast(T.f32(), val_bits.ir_value())), ~inv_idx
+
+
+@cute.jit
+def _cas_desc(arr: cute.Tensor, i: cutlass.Constexpr, j: cutlass.Constexpr) -> None:
+    a = arr[i]
+    b = arr[j]
+    if a < b:
+        arr[i] = b
+        arr[j] = a
+
+
+@cute.jit
+def _bitonic_sort_desc(arr: cute.Tensor, n: cutlass.Constexpr) -> None:
+    if const_expr(n > 1):
+        num_stages = int(math.log2(n))
+        for s in cutlass.range_constexpr(num_stages):
+            for sub_rev in cutlass.range_constexpr(s + 1):
+                step = 1 << (s - sub_rev)
+                for i in cutlass.range_constexpr(n):
+                    j = i ^ step
+                    if j > i:
+                        block_dir = (i >> (s + 1)) & 1
+                        if block_dir == 0:
+                            _cas_desc(arr, i, j)
+                        else:
+                            a = arr[i]
+                            b = arr[j]
+                            if a > b:
+                                arr[i] = b
+                                arr[j] = a
+
+
+@cute.jit
+def _bitonic_merge_desc(arr: cute.Tensor, n: cutlass.Constexpr) -> None:
+    """Merge a bitonic sequence of length n into descending sorted."""
+    if const_expr(n > 1):
+        num_levels = int(math.log2(n))
+        for level in cutlass.range_constexpr(num_levels):
+            length = n >> level
+            step = length // 2
+            for i in cutlass.range_constexpr(n // length):
+                start_i = i * length
+                for j in cutlass.range_constexpr(step):
+                    _cas_desc(arr, start_i + j, start_i + j + step)
+
+
+@cute.jit
+def _topk_merge_desc(a: cute.Tensor, b: cute.Tensor, K: cutlass.Constexpr) -> None:
+    """Top-K of two K-sorted-descending sequences, in place into ``a``.
+
+    ``a[i] <- max(a[i], b[K-1-i])`` yields a bitonic sequence in ``a``;
+    one bitonic merge of length K finishes it.
+    """
+    for i in cutlass.range_constexpr(K):
+        x = a[i]
+        y = b[K - 1 - i]
+        if y > x:
+            a[i] = y
+    _bitonic_merge_desc(a, K)
+
+
+class _RegisterTopK:
+    """Register-resident top-K. Each warp owns one row; ``ROWS_PER_CTA``
+    warps per CTA. K in {16, 32}, N a power of 2 in [K, 2048].
+    """
+
+    def __init__(self, N: int, K: int, rows_per_cta: int = 4):
+        self.N = N
+        self.K = K
+        self.VEC = N // 32
+        self.ROWS_PER_CTA = rows_per_cta
+        self.NUM_THREADS = 32 * rows_per_cta
+
+    @cute.jit
+    def __call__(
+        self,
+        mX: cute.Tensor,
+        mValues: cute.Tensor,
+        mIndices: cute.Tensor,
+        stream: cuda.CUstream,
+    ):
+        M = mX.shape[0]
+        ROWS = const_expr(self.ROWS_PER_CTA)
+        num_blocks = (M + ROWS - 1) // ROWS
+        self.kernel(mX, mValues, mIndices).launch(
+            grid=[num_blocks, 1, 1],
+            block=[self.NUM_THREADS, 1, 1],
+            stream=stream,
+        )
+
+    @cute.kernel
+    def kernel(self, mX: cute.Tensor, mValues: cute.Tensor, mIndices: cute.Tensor):
+        tidx, _, _ = cute.arch.thread_idx()
+        bidx, _, _ = cute.arch.block_idx()
+
+        K = const_expr(self.K)
+        VEC = const_expr(self.VEC)
+        ROWS = const_expr(self.ROWS_PER_CTA)
+        WARP_SIZE = const_expr(cute.arch.WARP_SIZE)
+
+        warp_idx = tidx // Int32(WARP_SIZE)
+        lane_idx = tidx % Int32(WARP_SIZE)
+        row = Int32(bidx) * Int32(ROWS) + warp_idx
+
+        M = mX.shape[0]
+        # CuTeDSL can't early-return on a dynamic predicate. Clamp the row
+        # for loads to keep them in-bounds, and gate the writes only.
+        row_safe = row if row < M else Int32(0)
+        in_bounds = row < M
+
+        # Per-thread Int64 keys covering this row's VEC-sized stripe.
+        keys = cute.make_rmem_tensor(VEC, Int64)
+        for i in cutlass.range_constexpr(VEC):
+            col = lane_idx * Int32(VEC) + Int32(i)
+            keys[i] = _make_key(mX[row_safe, col], col)
+
+        _bitonic_sort_desc(keys, VEC)
+
+        # Build per-thread top-K. If VEC < K, pad with INT64_MIN so the
+        # sentinel sorts strictly below any real key; if VEC >= K take the
+        # leading K (already sorted).
+        topk = cute.make_rmem_tensor(K, Int64)
+        if const_expr(VEC >= K):
+            for i in cutlass.range_constexpr(K):
+                topk[i] = keys[i]
+        else:
+            SENTINEL = const_expr(-(1 << 63))
+            for i in cutlass.range_constexpr(VEC):
+                topk[i] = keys[i]
+            for i in cutlass.range_constexpr(K - VEC):
+                topk[VEC + i] = Int64(SENTINEL)
+            _bitonic_sort_desc(topk, K)
+
+        # Warp-cooperative top-K merge via butterfly shuffles.
+        log2_warp = const_expr(int(math.log2(WARP_SIZE)))
+        for s in cutlass.range_constexpr(log2_warp):
+            other = cute.make_rmem_tensor(K, Int64)
+            for i in cutlass.range_constexpr(K):
+                other[i] = cute.arch.shuffle_sync_bfly(topk[i], offset=Int32(1 << s))
+            _topk_merge_desc(topk, other, K)
+
+        # Lane 0 of each warp now holds the row's top-K descending.
+        if lane_idx == Int32(0) and in_bounds:
+            for i in cutlass.range_constexpr(K):
+                v, idx = _decode_key(topk[i])
+                mValues[row, i] = v
+                mIndices[row, i] = idx
+
+
+@instrumented_cutedsl_cache("aten::topk", key_fn=lambda N, K: f"register N={N} K={K}")
+def _compile_topk_register(N: int, K: int):
+    batch_sym = cute.sym_int()
+    div_n = math.gcd(4, N)
+    div_k = math.gcd(4, K)
+    x_fake = _make_fake_tensor(Float32, (batch_sym, N), div_n)
+    v_fake = _make_fake_tensor(Float32, (batch_sym, K), div_k)
+    i_fake = _make_fake_tensor(Int32, (batch_sym, K), div_k)
+    return cute.compile(
+        _RegisterTopK(N, K),
+        x_fake,
+        v_fake,
+        i_fake,
+        cute.runtime.make_fake_stream(use_tvm_ffi_env_stream=True),
+        options="--enable-tvm-ffi",
+    )
+
+
+def topk_register(x: torch.Tensor, k: int) -> tuple[torch.Tensor, torch.Tensor]:
+    """Register-resident top-K for fp32 2D contiguous ``x``.
+
+    Returns ``(values[M, K]: fp32, indices[M, K]: int64)``, descending,
+    bit-exact to aten on both values and indices. Caller must ensure
+    ``k`` in {16, 32} and ``N`` is a power of 2 in [k, 2048].
+    """
+    M, N = x.shape
+    out_v = torch.empty(M, k, dtype=torch.float32, device=x.device)
+    out_i_i32 = torch.empty(M, k, dtype=torch.int32, device=x.device)
+    _compile_topk_register(N, k)(x, out_v, out_i_i32)
+    return out_v, out_i_i32.to(torch.int64)

.venv/lib/python3.12/site-packages/torch/_native/registry.py

@@ -0,0 +1,1147 @@
+import logging
+from collections.abc import Callable, Iterable
+from dataclasses import dataclass, field
+from typing import ParamSpec, TypeVar
+
+import torch.library
+
+
+__all__ = [
+    "UserOrderingFn",
+    "register_op_override",
+    "reorder_graphs_from_user_function",
+    "reenable_op_overrides",
+    "deregister_op_overrides",
+    "get_dsl_operations",
+    "native_decomp_table",
+]
+
+log = logging.getLogger(__name__)
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+_OpCondFn = Callable[P, bool]
+_OpImplFn = Callable[P, R]
+
+
+@dataclass
+class _OverrideNode:
+    """Track function override data."""
+
+    dsl_name: str
+    op_symbol: str
+    dispatch_key: str
+    cond_fn: _OpCondFn
+    impl_fn: _OpImplFn
+    # Identifier of the opaque `_native::<node_id>` op that carries this
+    # override's impl. Assigned once at registration time and never reused --
+    # reorder / deregister / reenable do not change it, so the cached
+    # `_defined_native_ops` entry remains valid.
+    node_id: str
+    unconditional_override: bool = False
+    active: bool = True
+
+
+UserOrderingFn = Callable[[str, str, list[_OverrideNode]], list[_OverrideNode]]
+
+
+@dataclass
+class _FilterState:
+    """Manages filtering state for override nodes."""
+
+    _dsl_names: set[str] = field(default_factory=set)
+    _op_symbols: set[str] = field(default_factory=set)
+    _dispatch_keys: set[str] = field(default_factory=set)
+
+    def check_enabled(self, node: _OverrideNode) -> bool:
+        """
+        Check if a node is enabled based on current filter state.
+
+        Args:
+            node: The override node to check
+
+        Returns:
+            bool: True if the node should be enabled, False if filtered out
+        """
+        if node.dsl_name in self._dsl_names:
+            return False
+
+        if node.op_symbol in self._op_symbols:
+            return False
+
+        if node.dispatch_key in self._dispatch_keys:
+            return False
+
+        return True
+
+    def update(
+        self,
+        dsl_names: str | Iterable[str] | None,
+        op_symbols: str | Iterable[str] | None,
+        dispatch_keys: str | Iterable[str] | None,
+        remove_keys: bool = False,
+    ) -> None:
+        """
+        Update filter sets as (current | new) or (current ~ new).
+
+        Args:
+            dsl_names: DSL names to add/remove from filter
+            op_symbols: Operation symbols to add/remove from filter
+            dispatch_keys: Dispatch keys to add/remove from filter
+            remove_keys: If True, remove keys from filter; if False, add them
+
+        Note:
+            Uses set.discard as it doesn't raise an exception if the element
+            wasn't in the set to begin with.
+        """
+        if remove_keys:
+            self._dsl_names -= set(_resolve_iterable(dsl_names))
+            self._op_symbols -= set(_resolve_iterable(op_symbols))
+            self._dispatch_keys -= set(_resolve_iterable(dispatch_keys))
+        else:
+            self._dsl_names |= set(_resolve_iterable(dsl_names))
+            self._op_symbols |= set(_resolve_iterable(op_symbols))
+            self._dispatch_keys |= set(_resolve_iterable(dispatch_keys))
+
+    def build_disable_key_set(self) -> set[tuple[str, str]]:
+        """
+        Build a set of dictionary keys based on the current filter state.
+
+        Returns:
+            set[tuple[str, str]]: Set of (op_symbol, dispatch_key) tuples
+        """
+        return _build_key_set(
+            self._dsl_names,
+            self._op_symbols,
+            self._dispatch_keys,
+        )
+
+    def __str__(self) -> str:
+        """Return string representation of filter state."""
+        s = ""
+        s += "Filter State:\n"
+        s += "  === DSL: ===\n"
+        for i, dsl in enumerate(self._dsl_names):
+            s += f"    {i}: {dsl}\n"
+        s += "  === OP SYMBOL: ===\n"
+        for i, op in enumerate(self._op_symbols):
+            s += f"    {i}: {op}\n"
+        s += "  === DISPATCH KEYS: ===\n"
+        for i, key in enumerate(self._dispatch_keys):
+            s += f"    {i}: {key}\n"
+
+        return s
+
+
+# Store the global override filtering state
+_filter_state: _FilterState = _FilterState()
+
+# Store torch.library.Library instances
+_libs: dict[tuple[str, str], torch.library.Library] = {}
+
+# Decomposition-style routers for the compile / export path, keyed by aten
+# OpOverload. Built in `_register_overrides_from_graph` alongside the eager
+# `Library.impl` routers.
+#
+# This dict is *not* written into any global compile/export decomp table (in
+# particular, not into torch._inductor.decomposition.decompositions). Users
+# opt into the overrides explicitly by passing `native_decomp_table()` to
+# `ExportedProgram.run_decompositions(...)`, or by threading it through
+# Dynamo/Inductor config for `torch.compile`. Reasons:
+#
+#   1. torch._inductor.decomposition.decompositions is an Inductor internal
+#      with no stability guarantee; writing to it couples us to Inductor's
+#      refactors.
+#   2. Global writes would affect *every* consumer of that table (tests,
+#      third-party backends, etc.), with no scoping.
+#   3. Import-time writes would force `import torch._native` to also pull in
+#      inductor → dynamo → triton, breaking
+#      `test_no_dsl_imports_after_import_torch`.
+#
+# Keeping the table registry-local means `import torch._native` stays cheap
+# and consumers control exactly when and where overrides take effect.
+_native_decomp_overrides: dict[object, Callable] = {}
+
+
+def _has_cow_tensor(*args, **kwargs) -> bool:
+    def is_cow_tensor(arg) -> bool:
+        if isinstance(arg, torch.Tensor):
+            return torch._C._is_cow_tensor(arg)  # pyrefly: ignore[missing-attribute]
+        if isinstance(arg, (list, tuple)):
+            return any(is_cow_tensor(item) for item in arg)
+        if isinstance(arg, dict):
+            return any(is_cow_tensor(item) for item in arg.values())
+        return False
+
+    return any(is_cow_tensor(arg) for arg in args) or any(
+        is_cow_tensor(arg) for arg in kwargs.values()
+    )
+
+
+# store graph structures
+_GraphsType = dict[tuple[str, str], list[_OverrideNode]]
+_graphs: _GraphsType = {}
+
+_MappingType = dict[str, list[tuple[str, str]]]
+
+# map a {dsl, op, dispatch_key} to keys to all graphs that contain it
+_dsl_name_to_lib_graph: _MappingType = {}
+_dispatch_key_to_lib_graph: _MappingType = {}
+_op_symbol_to_lib_graph: _MappingType = {}
+
+# Monotonic counter used to mint stable, unique `_native::<id>` op names.
+# Must never decrease across the process, since `_defined_native_ops`
+# pins a fake kernel for each minted id.
+_node_id_counter: int = 0
+
+# Dispatch keys where installing an override would break the registry's
+# assumptions. The eager router is wired at a backend key so aten's
+# higher-priority Autograd/Autocast kernels handle those layers, and the
+# fake kernel for `_native::<id>` redispatches to the aten op's meta -- if
+# the override lived at Meta or CompositeImplicitAutograd, that
+# redispatch would loop back into the router.
+_DISALLOWED_DISPATCH_KEYS: frozenset[str] = frozenset(
+    {"Meta", "CompositeImplicitAutograd", "CompositeExplicitAutograd"}
+)
+
+
+def _build_key_set(
+    dsl_names: str | Iterable[str] | None,
+    op_symbols: str | Iterable[str] | None,
+    dispatch_keys: str | Iterable[str] | None,
+) -> set[tuple[str, str]]:
+    """
+    Build a set of dictionary keys based on filter criteria.
+
+    Args:
+        dsl_names: DSL names to include in key set
+        op_symbols: Operation symbols to include in key set
+        dispatch_keys: Dispatch keys to include in key set
+
+    Returns:
+        set[tuple[str, str]]: Set of (op_symbol, dispatch_key) tuples
+    """
+    key_set: set[tuple[str, str]] = set()
+
+    def _append_to_set(
+        entries: str | Iterable[str] | None, graph_lib_dict: _MappingType
+    ) -> None:
+        """Helper to add matching keys from graph_lib_dict to key_set."""
+        resolved_entries = _resolve_iterable(entries)
+
+        for entry in resolved_entries:
+            if entry in graph_lib_dict:
+                for key in graph_lib_dict[entry]:
+                    key_set.add(key)
+
+    _append_to_set(dsl_names, _dsl_name_to_lib_graph)
+    _append_to_set(op_symbols, _op_symbol_to_lib_graph)
+    _append_to_set(dispatch_keys, _dispatch_key_to_lib_graph)
+
+    return key_set
+
+
+def _print_override_graphs(*, print_inactive: bool = False) -> None:
+    """
+    Print all override graphs for debugging purposes.
+
+    Args:
+        print_inactive: Whether to print inactive nodes
+    """
+    for (op, key), node_list in _graphs.items():
+        print(f"{op=}, {key=}")
+
+        for i, node in enumerate(node_list):
+            if node.active or print_inactive:
+                s: str = f"    {i}: {node.dsl_name=}, {node.unconditional_override=}"
+                if print_inactive:
+                    s += f" {node.active=}"
+
+                print(s)
+
+
+# One DEF/FRAGMENT library per namespace -- only one is allowed per process.
+_def_libs: dict[str, torch.library.Library] = {}
+# Ops that have already been `define`d on the _native namespace.
+_defined_native_ops: set[str] = set()
+# IMPL libraries on the aten namespace, keyed by (op_symbol, dispatch_key).
+# One library per op/key pair so we can call `_destroy()` on it to tear down
+# just that one override without affecting other ops at the same dispatch
+# key. Torch's Library has no per-kernel removal API -- `_destroy` on the
+# library is the only teardown mechanism.
+_aten_override_libs: dict[tuple[str, str], torch.library.Library] = {}
+
+
+def _get_def_library(namespace: str) -> torch.library.Library:
+    if namespace not in _def_libs:
+        _def_libs[namespace] = torch.library.Library(namespace, "FRAGMENT")
+    return _def_libs[namespace]
+
+
+def _get_or_create_library(dispatch_key: str) -> torch.library.Library:
+    """
+    Get or create the _native IMPL library for a given dispatch key.
+
+    One library per dispatch key is shared across all overridden ops.
+    """
+    global _libs
+
+    key = ("_native", dispatch_key)
+    if key not in _libs:
+        _libs[key] = torch.library.Library("_native", "IMPL", dispatch_key)
+
+    return _libs[key]
+
+
+def _install_aten_override(op_symbol: str, dispatch_key: str, kernel: Callable) -> None:
+    """
+    Install (or replace) an aten kernel at (op_symbol, dispatch_key).
+
+    Creates a fresh Library per (op, key) so we can tear down just this
+    one override via `_destroy_aten_override` without affecting any other
+    override at the same dispatch key.
+    """
+    key = (op_symbol, dispatch_key)
+    # Destroy any existing library so its kernel is fully removed before
+    # we install the new one. `_destroy` calls into the dispatcher to
+    # unregister all kernels on the library.
+    existing = _aten_override_libs.pop(key, None)
+    if existing is not None:
+        existing._destroy()
+
+    lib = torch.library.Library("aten", "IMPL", dispatch_key)
+    lib.impl(op_symbol, kernel, dispatch_key, with_keyset=True)
+    _aten_override_libs[key] = lib
+
+
+def _destroy_aten_override(op_symbol: str, dispatch_key: str) -> None:
+    """Tear down the aten override at (op_symbol, dispatch_key), if any."""
+    lib = _aten_override_libs.pop((op_symbol, dispatch_key), None)
+    if lib is not None:
+        lib._destroy()
+
+
+def _resolve_aten_overload(op_symbol: str) -> "torch._ops.OpOverload | None":
+    """
+    Resolve `op_symbol` to a concrete OpOverload on `torch.ops.aten`.
+
+    Accepts bare names ("bmm" → aten.bmm.default) and overload-qualified
+    names ("add_.Tensor" → aten.add_.Tensor). Returns None if the op is not
+    registered (e.g. a test-only op_symbol that never hit the C++ dispatcher).
+    """
+    name, _, overload_name = op_symbol.partition(".")
+    overload_name = overload_name or "default"
+    try:
+        packet = getattr(torch.ops.aten, name)
+        return getattr(packet, overload_name)
+    except AttributeError:
+        return None
+
+
+def _aten_schema_tail(op_symbol: str) -> str:
+    """Return the schema of at::<op_symbol> with the `aten::<name>` prefix stripped.
+
+    Accepts bare names ("bmm" → aten.bmm.default) and overload-qualified
+    names ("add_.Tensor" → aten.add_.Tensor).
+    """
+    overload = _resolve_aten_overload(op_symbol)
+    if overload is None:
+        raise AttributeError(f"aten op not found for op_symbol={op_symbol!r}")
+    s = str(overload._schema)
+    # "aten::bmm(Tensor self, Tensor mat2) -> Tensor" -> "(Tensor self, Tensor mat2) -> Tensor"
+    _, rest = s.split("::", 1)
+    _, args = rest.split("(", 1)
+    return f"({args}"
+
+
+def _define_native_op_once(name: str, op_symbol: str) -> None:
+    # Invariant: callers must only install the eager router at a real backend
+    # dispatch key (CPU, CUDA, XPU, ...). The fake kernel below redispatches
+    # to the aten op, and if the router were installed at Meta /
+    # CompositeImplicitAutograd that redispatch would re-enter the router.
+    # `register_op_override` enforces this via `_DISALLOWED_DISPATCH_KEYS`.
+    if name in _defined_native_ops:
+        return
+    _get_def_library("_native").define(f"{name}{_aten_schema_tail(op_symbol)}")
+    # Fake/meta kernel: required so export / dynamo / AOTAutograd can shape-infer
+    # through the opaque _native op. Reusing the aten op's meta is safe because
+    # the schema (and therefore shape rules) is cloned from it.
+    aten_overload = _resolve_aten_overload(op_symbol)
+    torch.library.register_fake(f"_native::{name}")(
+        lambda *args, _aten_overload=aten_overload, **kwargs: _aten_overload(
+            *args, **kwargs
+        )
+    )
+    # No autograd or autocast kernels are registered on _native::<id>. Because
+    # the router is registered at the backend dispatch key (e.g. CUDA), aten's
+    # own higher-priority kernels on aten::<op> handle both:
+    #   - Autograd: AutogradCUDA sees aten::<op> in the autograd graph and
+    #     uses aten's built-in derivative formula.
+    #   - Autocast: AutocastCUDA casts inputs to the autocast dtype before
+    #     redispatching down to our CUDA-level router.
+    _defined_native_ops.add(name)
+
+
+def _register_node_impl(
+    lib: torch.library.Library, node: _OverrideNode, dispatch_key: str
+) -> None:
+    """
+    Register a single node implementation with the library.
+
+    Args:
+        lib: The torch.library.Library instance
+        node: The override node to register
+        dispatch_key: The dispatch key for registration
+    """
+    if not node.node_id:
+        raise ValueError(
+            f"_OverrideNode must have a non-empty node_id before registration "
+            f"(dsl_name={node.dsl_name!r}, op_symbol={node.op_symbol!r})"
+        )
+    _define_native_op_once(node.node_id, node.op_symbol)
+    lib.impl(
+        node.node_id,
+        node.impl_fn,
+        dispatch_key,
+        with_keyset=False,
+        allow_override=True,
+    )
+
+
+def _resolve_iterable(iterable: str | Iterable[str] | None) -> Iterable[str]:
+    """
+    Resolve various input types to a consistent iterable of strings.
+
+    Args:
+        iterable: String, iterable of strings, or None
+
+    Returns:
+        Iterable[str]: Consistent iterable output
+    """
+    if iterable is None:
+        return []
+
+    if not isinstance(iterable, Iterable) or isinstance(iterable, str):
+        return (iterable,)
+
+    return iterable
+
+
+def reenable_op_overrides(
+    *,
+    enable_dsl_names: str | list[str] | None = None,
+    enable_op_symbols: str | list[str] | None = None,
+    enable_dispatch_keys: str | list[str] | None = None,
+) -> None:
+    """
+    Re-enable overrides by removing them from filter state and reregistering.
+
+    Args:
+        enable_dsl_names: DSL names to re-enable
+        enable_op_symbols: Operation symbols to re-enable
+        enable_dispatch_keys: Dispatch keys to re-enable
+
+    Note:
+        This function uses reverse filter state management (removing from
+        filters to enable).
+    """
+    log.info(
+        "Re-registering ops by dsl: %s, op_symbol: %s, dispatch_key: %s",
+        enable_dsl_names,
+        enable_op_symbols,
+        enable_dispatch_keys,
+    )
+
+    # Update the filters - note `remove_keys=True` because
+    # we are removing keys from the filters (vs. adding them)
+    _filter_state.update(
+        enable_dsl_names,
+        enable_op_symbols,
+        enable_dispatch_keys,
+        remove_keys=True,
+    )
+
+    # Get the set of keys that need to be reprocessed
+    key_set: set[tuple[str, str]] = _build_key_set(
+        enable_dsl_names,
+        enable_op_symbols,
+        enable_dispatch_keys,
+    )
+
+    # Process each affected graph with updated filter state
+    for key in key_set:
+        op_symbol, dispatch_key = key
+
+        if key in _graphs:
+            # Note: We don't need to cleanup and recreate the library here
+            # since we're just updating the registration with new filter state
+            _register_overrides_from_graph(
+                op_symbol, dispatch_key, _graphs[key], filter_state=_filter_state
+            )
+
+
+def deregister_op_overrides(
+    *,
+    disable_dsl_names: str | list[str] | None = None,
+    disable_op_symbols: str | list[str] | None = None,
+    disable_dispatch_keys: str | list[str] | None = None,
+) -> None:
+    """
+    De-register overrides by updating filter state and reregistering graphs.
+
+    Args:
+        disable_dsl_names: DSL names to disable
+        disable_op_symbols: Operation symbols to disable
+        disable_dispatch_keys: Dispatch keys to disable
+
+    Note:
+        This function uses filter state management to selectively disable
+        operations.
+    """
+    log.info(
+        "De-registering ops by dsl: %s, op_symbol: %s, dispatch_key: %s",
+        disable_dsl_names,
+        disable_op_symbols,
+        disable_dispatch_keys,
+    )
+
+    # Update filter state to disable specified entries
+    _filter_state.update(disable_dsl_names, disable_op_symbols, disable_dispatch_keys)
+
+    # Get the set of keys that need to be reprocessed
+    key_set: set[tuple[str, str]] = _filter_state.build_disable_key_set()
+
+    # Process each affected graph with filter state
+    for key in key_set:
+        op_symbol, dispatch_key = key
+
+        if key in _graphs:
+            _cleanup_and_reregister_graph(
+                op_symbol,
+                dispatch_key,
+                _graphs[key],
+                filter_state=_filter_state,
+            )
+
+
+def get_dsl_operations(dsl_name: str) -> list[str]:
+    """Get list of operations registered by a specific DSL.
+
+    Args:
+        dsl_name: Name of the DSL to query.
+
+    Returns:
+        Sorted list of operation names registered by the DSL.
+    """
+    operations = set()
+    for (op_symbol, _), nodes in _graphs.items():
+        for node in nodes:
+            if node.dsl_name == dsl_name:
+                operations.add(op_symbol)
+                break
+    return sorted(operations)
+
+
+def _update_registration_maps(
+    dsl_name: str,
+    op_symbol: str,
+    dispatch_key: str,
+    key: tuple[str, str],
+) -> None:
+    """
+    Update the registration mapping dictionaries.
+
+    Args:
+        dsl_name: The DSL name
+        op_symbol: The operation symbol
+        dispatch_key: The dispatch key
+        key: The dictionary key tuple
+    """
+    global _dsl_name_to_lib_graph
+    global _op_symbol_to_lib_graph
+    global _dispatch_key_to_lib_graph
+
+    def _get_new_entry_or_append(
+        registration: dict[str, list[tuple[str, str]]],
+        symbol: str,
+        key: tuple[str, str],
+    ) -> None:
+        """Helper to add key to registration list or create new entry."""
+        entry_list = registration.get(symbol)
+
+        if entry_list is None:
+            entry_list = [key]
+            registration[symbol] = entry_list
+        else:
+            entry_list.append(key)
+
+    _get_new_entry_or_append(_dsl_name_to_lib_graph, dsl_name, key)
+    _get_new_entry_or_append(_op_symbol_to_lib_graph, op_symbol, key)
+    _get_new_entry_or_append(_dispatch_key_to_lib_graph, dispatch_key, key)
+
+
+def _always_true(*args: object, **kwargs: object) -> bool:
+    return True
+
+
+def register_op_override(
+    backend: str,
+    lib_symbol: str,
+    op_symbol: str,
+    dispatch_key: str,
+    cond: _OpCondFn | None,
+    impl: _OpImplFn,
+    *,
+    allow_multiple_override: bool = False,
+    unconditional_override: bool = False,
+) -> None:
+    """
+    Register a passed override function to the dispatcher.
+
+    Actually a graph-building operation; real registration happens later.
+
+    Args:
+        backend: The backend name (DSL name)
+        lib_symbol: Library you're overriding symbols in (must be "aten")
+        op_symbol: Name of the operation you're overriding
+        dispatch_key: Dispatch key to override
+        cond: Predicate choosing whether `impl` applies to a given call. May
+            be None if `unconditional_override=True`.
+        impl: Implementation function for the override
+        allow_multiple_override: Allow overriding an existing override
+        unconditional_override: Implementation doesn't have a fallback and
+            doesn't require torch.DispatchKeySet as the first argument. When
+            True, a trivially-True predicate is supplied for the router if
+            `cond` is None.
+
+    Raises:
+        ValueError: If lib_symbol is not "aten", if dispatch_key is in
+            _DISALLOWED_DISPATCH_KEYS (Meta / CompositeImplicitAutograd /
+            CompositeExplicitAutograd), or if cond is None without
+            unconditional_override=True.
+    """
+    if lib_symbol != "aten":
+        raise ValueError(f'Unsupported lib_symbol (must be "aten", got: "{lib_symbol}"')
+
+    if dispatch_key in _DISALLOWED_DISPATCH_KEYS:
+        raise ValueError(
+            f"dispatch_key={dispatch_key!r} is not supported. Overrides must be "
+            f"installed at a backend key (e.g. CPU, CUDA, XPU); the router's fake "
+            f"kernel redispatches to aten and would recurse otherwise."
+        )
+
+    if cond is None:
+        if not unconditional_override:
+            raise ValueError("cond must be provided unless unconditional_override=True")
+        cond = _always_true
+
+    key = (op_symbol, dispatch_key)
+
+    global _graphs, _node_id_counter
+    op_graph = _graphs.get(key, [])
+
+    # Mint a stable id for the opaque `_native::<node_id>` op. `_sanitized`
+    # strips dots from overload-qualified names so the result is a valid op
+    # name. The monotonic counter guarantees uniqueness even if the same
+    # (op_symbol, dsl_name) is registered, deregistered, and re-registered.
+    _sanitized = op_symbol.replace(".", "_")
+    node_id = f"{_sanitized}_{backend}_{_node_id_counter}"
+    _node_id_counter += 1
+
+    op_graph.append(
+        _OverrideNode(
+            dsl_name=backend,
+            op_symbol=op_symbol,
+            dispatch_key=dispatch_key,
+            cond_fn=cond,
+            impl_fn=impl,
+            unconditional_override=unconditional_override,
+            node_id=node_id,
+        )
+    )
+    _graphs[key] = op_graph
+    # Build additional maps helpful for de-registration
+    _update_registration_maps(backend, op_symbol, dispatch_key, key=key)
+
+
+def _should_reregister_graph(
+    original_graph: list[_OverrideNode],
+    new_graph: list[_OverrideNode],
+    *,
+    force_reregister: bool = False,
+) -> bool:
+    """
+    Determine if a graph needs reregistration based on changes.
+
+    Args:
+        original_graph: The original graph before modification
+        new_graph: The graph after modification
+        force_reregister: If True, always reregister regardless of changes
+
+    Returns:
+        bool: True if reregistration is needed
+    """
+    if force_reregister:
+        return True
+
+    # Check if the graph structure has changed
+    return original_graph != new_graph
+
+
+def _cleanup_and_reregister_graph(
+    op_symbol: str,
+    dispatch_key: str,
+    graph: list[_OverrideNode],
+    *,
+    filter_state: _FilterState | None = None,
+) -> None:
+    """
+    Reregister a graph's routes from scratch.
+
+    Used by reorder / deregister / reenable. Libraries are intentionally
+    long-lived singletons; we rebuild the per-op router closure here.
+
+    Args:
+        op_symbol: The operation symbol
+        dispatch_key: The dispatch key
+        graph: The graph to register
+        filter_state: Optional filter state for conditional registration
+    """
+    _register_overrides_from_graph(
+        op_symbol,
+        dispatch_key,
+        graph,
+        filter_state=filter_state,
+    )
+
+
+def _apply_graph_transformation(
+    transformation_fn: UserOrderingFn,
+    *,
+    keys_to_process: set[tuple[str, str]] | None = None,
+    reregister_overrides: bool = False,
+    filter_state: _FilterState | None = None,
+) -> None:
+    """
+    Apply a transformation function to graphs and optionally reregister.
+
+    This is the core pattern used by reorder_graphs_from_user_function and
+    can be reused for other graph transformation operations.
+
+    Args:
+        transformation_fn: Function to transform each graph
+        keys_to_process: Keys to process, or None for all graphs
+        reregister_overrides: Whether to reregister changed graphs
+        filter_state: Optional filter state for conditional registration
+
+    Note:
+        If transformation_fn raises an exception for a specific graph, that graph
+        will be skipped and processing will continue with remaining graphs.
+    """
+    global _graphs
+
+    # Determine which graphs to process
+    target_keys = (
+        keys_to_process if keys_to_process is not None else set(_graphs.keys())
+    )
+
+    # Process each graph
+    for op_symbol, dispatch_key in list(target_keys):
+        if (op_symbol, dispatch_key) not in _graphs:
+            continue  # Skip if graph doesn't exist
+
+        original_graph = list(_graphs[(op_symbol, dispatch_key)])
+
+        # Apply the transformation with error handling
+        try:
+            new_graph = transformation_fn(op_symbol, dispatch_key, original_graph)
+        except (TypeError, ValueError, AttributeError, RuntimeError):
+            log.warning(
+                "Graph transformation failed for %s/%s. Preserving original graph.",
+                op_symbol,
+                dispatch_key,
+                exc_info=True,
+            )
+            continue
+        except Exception:
+            log.exception(
+                "Unexpected error in graph transformation for %s/%s. Preserving original graph.",
+                op_symbol,
+                dispatch_key,
+            )
+            continue
+
+        # Validate that the transformation returned a valid result
+        if not isinstance(new_graph, list):
+            log.warning(
+                "Graph transformation returned invalid type %s for %s/%s. Expected list. Preserving original graph.",
+                type(new_graph).__name__,
+                op_symbol,
+                dispatch_key,
+            )
+            continue
+
+        # Update the graph
+        _graphs[(op_symbol, dispatch_key)] = new_graph
+
+        # Reregister if needed
+        if reregister_overrides and _should_reregister_graph(
+            original_graph, new_graph, force_reregister=False
+        ):
+            _cleanup_and_reregister_graph(
+                op_symbol,
+                dispatch_key,
+                new_graph,
+                filter_state=filter_state,
+            )
+
+
+def native_decomp_table(
+    overrides_only: bool = False,
+) -> dict[object, Callable]:
+    """
+    Return a decomposition table suitable for passing to
+    ``ExportedProgram.run_decompositions`` or to Inductor / Dynamo as a
+    decomposition set for ``torch.compile``.
+
+    This is the canonical way to apply native overrides outside of eager.
+    Callers opt in explicitly -- the registry does **not** install into any
+    global compile/export decomp table on its own. This preserves three
+    properties:
+
+      * ``import torch._native`` doesn't transitively import inductor /
+        dynamo / triton.
+      * No other consumer (ONNX, tests, third-party backends) accidentally
+        picks up our overrides.
+      * Scoping is up to the caller: pass the table only where routing is
+        desired.
+
+    By default, the returned table contains
+    ``torch.export.default_decompositions()`` with native-registered
+    overrides layered on top -- matching typical "run the usual
+    decompositions, plus my overrides" intent. The override entries win
+    over any same-op default, because they're merged last.
+
+    Example:
+
+        ep = torch.export.export(model, args)
+        ep = ep.run_decompositions(
+            torch._native.registry.native_decomp_table()
+        )
+
+    Args:
+        overrides_only: If True, return only the native-registered overrides
+            and no default aten decompositions. Useful for inspection /
+            debugging, or when composing tables manually.
+
+    Returns:
+        A dict mapping ``OpOverload`` to decomposition callable.
+    """
+    if overrides_only:
+        table: dict[object, Callable] = {}
+    else:
+        # Local import: keeps `import torch._native` from pulling in
+        # torch.export (and its transitive imports) at module load time.
+        from torch.export import default_decompositions
+
+        table = dict(default_decompositions())
+    # Merge overrides last so they win on conflicts.
+    table.update(_native_decomp_overrides)
+    return table
+
+
+def _register_overrides_from_graph(
+    op_symbol: str,
+    dispatch_key: str,
+    graph: list[_OverrideNode],
+    *,
+    filter_state: _FilterState | None = None,
+) -> None:
+    """
+    Register all overrides in a single graph.
+
+    Args:
+        op_symbol: The operation symbol
+        dispatch_key: The dispatch key
+        graph: List of override nodes to register
+        filter_state: Optional filter state for conditional registration
+    """
+    lib = _get_or_create_library(dispatch_key)
+
+    cond_impl: list[tuple[_OpCondFn, str]] = []
+
+    # node.node_id is minted once at `register_op_override` time and is
+    # stable across reorder / deregister / reenable -- never regenerate it
+    # here, since `_defined_native_ops` pins a fake kernel against each id.
+    for node in graph:
+        enable = True
+        if filter_state:
+            enable = filter_state.check_enabled(node)
+
+        if enable:
+            _register_node_impl(lib, node, dispatch_key)
+            cond_impl.append((node.cond_fn, node.node_id))
+            node.active = True
+        else:
+            node.active = False
+
+    overload = _resolve_aten_overload(op_symbol)
+
+    # Tear down any existing aten override so either (a) the op cleanly
+    # reverts to native aten (empty cond_impl), or (b) the subsequent
+    # `get_kernel` call returns the native kernel rather than a stale
+    # previously-installed router.
+    _destroy_aten_override(op_symbol, dispatch_key)
+
+    # If no active conds remain for this (op, key), leave the native op
+    # behavior intact and drop any decomp table entry.
+    if not cond_impl:
+        if overload is not None:
+            _native_decomp_overrides.pop(overload, None)
+        return
+
+    # Capture the prior kernel at this (op, dispatch_key) *before* we install
+    # our override. The fallback path calls it via `call_boxed`, which
+    # re-enters the dispatcher with the original kernel handle -- bypassing
+    # our just-registered router and avoiding the recursion that would
+    # otherwise appear in aten's backward formulas (e.g. bmm's backward
+    # calls bmm, which would route back to us).
+    fallback_kernel = torch.library.get_kernel(f"aten::{op_symbol}", dispatch_key)
+
+    # Build the router closures. Both share a first-match-wins loop over
+    # `cond_impl`; they differ only in
+    #   (a) whether cond exceptions fail loudly or silently, and
+    #   (b) what to do when no cond matches.
+    #
+    # Eager routers run on real tensors where cond exceptions indicate a
+    # genuine bug; missing a match falls back to the captured native kernel.
+    #
+    # Compile/export routers run under FakeTensor where some predicates are
+    # undefined (e.g. _is_cow_tensor), so we swallow cond exceptions and
+    # treat them as non-matches. On no-match we return NotImplemented so
+    # Inductor reuses the default lowering rather than recursing.
+    _NO_MATCH = object()  # sentinel; impl return values of None would be valid outputs
+
+    def _dispatch(args, kwargs, swallow_cond_exceptions: bool):
+        for cond, impl_name in cond_impl:
+            try:
+                matched = cond(*args, **kwargs)
+            except Exception:
+                if not swallow_cond_exceptions:
+                    raise
+                continue
+            if matched:
+                return getattr(torch.ops._native, impl_name)(*args, **kwargs)
+        return _NO_MATCH
+
+    def eager_router(
+        keyset, *args, _fallback=fallback_kernel, _aten_overload=overload, **kwargs
+    ):
+        # This branch is only safe while Dynamo is actively tracing this Python
+        # router. The broader compile-session flag can be true when this router
+        # executes eagerly; redispatching to aten there would re-enter us.
+        #
+        # COW state is guarded by Dynamo's _is_cow_tensor handler but is not
+        # modeled in the compiled graph. If a COW input reaches this router,
+        # keep the existing eager path so COW-preserving fallback semantics are
+        # maintained instead of compiling through aten and materializing it.
+        if (
+            torch.compiler.is_dynamo_compiling()
+            and _aten_overload is not None
+            and not _has_cow_tensor(*args, **kwargs)
+        ):
+            return _aten_overload(*args, **kwargs)
+
+        result = _dispatch(args, kwargs, swallow_cond_exceptions=False)
+        if result is _NO_MATCH:
+            return _fallback.call_boxed(keyset, *args, **kwargs)
+        return result
+
+    def compile_router(*args, **kwargs):
+        result = _dispatch(args, kwargs, swallow_cond_exceptions=True)
+        if result is _NO_MATCH:
+            return NotImplemented
+        return result
+
+    # Eager path: install a fresh aten override for this (op, key).
+    _install_aten_override(op_symbol, dispatch_key, eager_router)
+
+    # Compile / export path: record the router in our own decomp table.
+    # Callers opt in via `native_decomp_table()` -- we deliberately do NOT
+    # write into torch._inductor.decomposition.decompositions (see the
+    # comment on `_native_decomp_overrides` for why).
+    if overload is not None:
+        _native_decomp_overrides[overload] = compile_router
+
+
+def _register_all_overrides() -> None:
+    """
+    Perform all registration calls from previously-built override graphs.
+    """
+    for key, graph in _graphs.items():
+        op_symbol, dispatch_key = key
+
+        _register_overrides_from_graph(
+            op_symbol,
+            dispatch_key,
+            graph,
+        )
+
+
+def reorder_graphs_from_user_function(
+    fn: UserOrderingFn,
+    *,
+    reregister_overrides: bool = False,
+) -> None:
+    """
+    Reorder override graphs using a user-provided ordering function.
+
+    Args:
+        fn: User-provided function that takes (op_symbol, dispatch_key, graph)
+            and returns a reordered graph
+        reregister_overrides: Whether to reregister graphs that have changed
+
+    Note:
+        This function uses the common graph transformation pattern and can serve
+        as an example for other graph manipulation operations.
+    """
+    _apply_graph_transformation(
+        transformation_fn=fn,
+        reregister_overrides=reregister_overrides,
+    )
+
+
+def _apply_graph_filter(
+    filter_fn: Callable[[str, str, _OverrideNode], bool],
+    *,
+    reregister_overrides: bool = False,
+) -> None:
+    """
+    Apply a filter function to remove nodes from graphs.
+
+    This is a convenience function that uses the graph transformation pattern
+    to filter out unwanted nodes.
+
+    Args:
+        filter_fn: Function that takes (op_symbol, dispatch_key, node) and
+            returns True to keep the node, False to remove it
+        reregister_overrides: Whether to reregister modified graphs
+
+    Example:
+        # Remove all nodes with "deprecated" in the DSL name
+        _apply_graph_filter(
+            lambda op, dk, node: "deprecated" not in node.dsl_name,
+            reregister_overrides=True
+        )
+
+    Note:
+        If filter_fn raises an exception for a specific graph, the original
+        graph will be preserved and processing will continue.
+    """
+
+    def filtering_transformation(
+        op_symbol: str, dispatch_key: str, graph: list[_OverrideNode]
+    ) -> list[_OverrideNode]:
+        """Apply filter_fn to graph with error handling."""
+        try:
+            return [node for node in graph if filter_fn(op_symbol, dispatch_key, node)]
+        except (TypeError, ValueError, AttributeError, RuntimeError):
+            log.warning(
+                "Graph transformation failed for %s/%s. Preserving original graph.",
+                op_symbol,
+                dispatch_key,
+                exc_info=True,
+            )
+            return graph
+        except Exception:
+            log.exception(
+                "Unexpected error in graph transformation for %s/%s. Preserving original graph.",
+                op_symbol,
+                dispatch_key,
+            )
+            return graph
+
+    _apply_graph_transformation(
+        transformation_fn=filtering_transformation,
+        reregister_overrides=reregister_overrides,
+    )
+
+
+def _apply_selective_reordering(
+    condition_fn: Callable[[str, str], bool],
+    ordering_fn: UserOrderingFn,
+    *,
+    reregister_overrides: bool = False,
+) -> None:
+    """
+    Apply reordering only to graphs that match a condition.
+
+    This allows for more targeted reordering operations.
+
+    Args:
+        condition_fn: Function that takes (op_symbol, dispatch_key) and
+            returns True if the graph should be reordered
+        ordering_fn: Ordering function to apply to matching graphs
+        reregister_overrides: Whether to reregister modified graphs
+
+    Example:
+        # Only reorder CUDA operations
+        _apply_selective_reordering(
+            condition_fn=lambda op, dk: dk == "CUDA",
+            ordering_fn=lambda op, dk, g: sorted(g, key=lambda n: n.dsl_name),
+            reregister_overrides=True
+        )
+
+    Note:
+        If condition_fn or ordering_fn raises an exception for a specific graph,
+        the original graph will be preserved and processing will continue.
+    """
+
+    def conditional_transformation(
+        op_symbol: str, dispatch_key: str, graph: list[_OverrideNode]
+    ) -> list[_OverrideNode]:
+        """Apply ordering_fn conditionally based on condition_fn result."""
+        try:
+            should_reorder = condition_fn(op_symbol, dispatch_key)
+        except (TypeError, ValueError, AttributeError, RuntimeError):
+            log.warning(
+                "Graph transformation failed for %s/%s. Preserving original graph.",
+                op_symbol,
+                dispatch_key,
+                exc_info=True,
+            )
+            return graph
+        except Exception:
+            log.exception(
+                "Unexpected error in graph transformation for %s/%s. Preserving original graph.",
+                op_symbol,
+                dispatch_key,
+            )
+            return graph
+
+        if should_reorder:
+            try:
+                return ordering_fn(op_symbol, dispatch_key, graph)
+            except (TypeError, ValueError, AttributeError, RuntimeError):
+                log.warning(
+                    "Graph transformation failed for %s/%s. Preserving original graph.",
+                    op_symbol,
+                    dispatch_key,
+                    exc_info=True,
+                )
+                return graph
+            except Exception:
+                log.exception(
+                    "Unexpected error in graph transformation for %s/%s. Preserving original graph.",
+                    op_symbol,
+                    dispatch_key,
+                )
+                return graph
+
+        return graph  # Return unchanged if condition doesn't match
+
+    _apply_graph_transformation(
+        transformation_fn=conditional_transformation,
+        reregister_overrides=reregister_overrides,
+    )

.venv/lib/python3.12/site-packages/torch/_native/triton/__init__.py

@@ -0,0 +1,4 @@
+from .const_tensor_wrapper import ConstTensorWrapper
+
+
+__all__ = ["ConstTensorWrapper"]

.venv/lib/python3.12/site-packages/torch/_native/triton/const_tensor_wrapper.py

@@ -0,0 +1,62 @@
+import torch
+
+
+class ConstTensorWrapper:
+    """Read-only, zero-copy view of a tensor for Triton kernel arguments.
+
+    Triton extracts a kernel pointer argument by duck typing: any object with a
+    ``data_ptr()`` method and a ``dtype`` is treated as a pointer (see Triton's
+    ``jit.py``). ``ConstTensorWrapper`` overrides ``data_ptr()`` to return
+    ``const_data_ptr()``, so passing a copy-on-write tensor to an argument the
+    kernel only reads does not materialize it. The remaining attributes Triton
+    inspects during specialization and launch are forwarded to the wrapped
+    tensor.
+
+    Only wrap arguments the kernel treats as read-only (loads, never stores).
+    Triton does not enforce this; wrapping a written argument is a bug.
+
+    Accessors run under DisableTorchFunctionSubclass so the wrapper never
+    re-enters __torch_function__: const_data_ptr() and friends are dispatched
+    methods, and re-entering while an override is mid-redispatch trips the
+    "cannot skip two levels of __torch_function__" guard.
+    """
+
+    def __init__(self, tensor: torch.Tensor) -> None:
+        self._tensor = tensor
+
+    def data_ptr(self) -> int:
+        with torch._C.DisableTorchFunctionSubclass():
+            # const_data_ptr() exists at runtime but is absent from the stubs.
+            return self._tensor.const_data_ptr()  # type: ignore[attr-defined]
+
+    @property
+    def dtype(self) -> torch.dtype:
+        return self._tensor.dtype
+
+    @property
+    def device(self) -> torch.device:
+        return self._tensor.device
+
+    @property
+    def shape(self) -> torch.Size:
+        return self._tensor.shape
+
+    @property
+    def ndim(self) -> int:
+        return self._tensor.ndim
+
+    def dim(self) -> int:
+        with torch._C.DisableTorchFunctionSubclass():
+            return self._tensor.dim()
+
+    def size(self, dim: int | None = None) -> torch.Size | int:
+        with torch._C.DisableTorchFunctionSubclass():
+            return self._tensor.size() if dim is None else self._tensor.size(dim)
+
+    def stride(self, dim: int | None = None) -> tuple[int, ...] | int:
+        with torch._C.DisableTorchFunctionSubclass():
+            return self._tensor.stride() if dim is None else self._tensor.stride(dim)
+
+    def element_size(self) -> int:
+        with torch._C.DisableTorchFunctionSubclass():
+            return self._tensor.element_size()

.venv/lib/python3.12/site-packages/torch/_native/triton_utils.py

@@ -0,0 +1,137 @@
+import functools
+import logging
+import sys
+from typing import cast
+
+from torch._vendor.packaging.version import Version
+
+from ..backends import cuda as _cuda
+from .common_utils import (
+    _available_version,
+    _unavailable_reason,
+    check_native_jit_disabled,
+    check_native_version_skip,
+)
+from .dsl_registry import dsl_registry, DSLModuleProtocol
+from .registry import (
+    _OpCondFn,
+    _OpImplFn,
+    deregister_op_overrides as _deregister_op_overrides_impl,
+    register_op_override as _register_op_override_impl,
+)
+
+
+log = logging.getLogger(__name__)
+
+
+_TRITON_DSL_NAME = "triton"
+_TRITON_REQUIRED_VERSION_MAJOR = 3
+_TRITON_MINIMUM_VERSION_MINOR = 6
+
+
+@functools.cache
+def _check_runtime_available() -> tuple[bool, Version | None]:
+    """
+    Check if triton is available
+
+    NOTE: must not import at this point
+    """
+    # Skip all checks if running on CPU-only binary
+    if not _cuda.is_built():
+        return (False, None)
+
+    deps = [
+        ("triton", "triton"),
+    ]
+    reason = _unavailable_reason(deps)
+    if reason is None:
+        available = True
+        version = _available_version("triton")
+    else:
+        # info, not warning: see cutedsl_utils._check_runtime_available for
+        # rationale (missing optional deps is the common case; surface via
+        # TORCH_LOGS=+native_dsl when needed).
+        log.info("triton native DSL ops require: `triton` %s", reason)
+        available = False
+        version = None
+    return available, version
+
+
+def runtime_available() -> bool:
+    available, _ = _check_runtime_available()
+    return available
+
+
+def runtime_version() -> None | Version:
+    _, version = _check_runtime_available()
+    return version
+
+
+@functools.cache
+def _version_is_sufficient() -> bool:
+    _, version = _check_runtime_available()
+
+    if version is None:
+        return False
+
+    # Either exact version, or same major
+    major_ok = version.major == _TRITON_REQUIRED_VERSION_MAJOR
+    minor_ok = version.minor >= _TRITON_MINIMUM_VERSION_MINOR
+
+    if (major_ok and minor_ok) or check_native_version_skip():
+        return True
+
+    log.info(
+        "triton version %s is not sufficient (>= (%s.%s.*)); "
+        "set TORCH_NATIVE_SKIP_VERSION_CHECK=1 to override",
+        version,
+        _TRITON_REQUIRED_VERSION_MAJOR,
+        _TRITON_MINIMUM_VERSION_MINOR,
+    )
+    return False
+
+
+def deregister_op_overrides() -> None:
+    """
+    Deregister all ops through triton
+    """
+    _deregister_op_overrides_impl(disable_dsl_names=_TRITON_DSL_NAME)
+
+
+def register_op_override(
+    lib_symbol: str,
+    op_symbol: str,
+    dispatch_key: str,
+    cond: _OpCondFn | None,
+    impl: _OpImplFn,
+    *,
+    allow_multiple_override: bool = False,
+    unconditional_override: bool = False,
+) -> None:
+    """
+    See torch/_native/registry.py for the underlying implementation
+    and arguments. This is a thin, DSL-checking wrapper over
+    _register_op_override_impl
+    """
+    available, version = _check_runtime_available()
+    if (not available) or check_native_jit_disabled():
+        return
+
+    if not _version_is_sufficient():
+        return
+
+    _register_op_override_impl(
+        _TRITON_DSL_NAME,
+        lib_symbol,
+        op_symbol,
+        dispatch_key,
+        cond,
+        impl,
+        allow_multiple_override=allow_multiple_override,
+        unconditional_override=unconditional_override,
+    )
+
+
+# Register this DSL module with the registry
+# Note: Import-time registration ensures DSL is available when module is loaded
+dsl_registry.register_dsl("triton", cast(DSLModuleProtocol, sys.modules[__name__]))

.venv/lib/python3.12/site-packages/torch/_numpy/__init__.py

@@ -0,0 +1,34 @@
+# mypy: ignore-errors
+
+from . import fft, linalg, random
+from ._dtypes import *  # noqa: F403
+from ._funcs import *  # noqa: F403
+from ._getlimits import finfo, iinfo
+from ._ndarray import (
+    array,
+    asarray,
+    ascontiguousarray,
+    can_cast,
+    from_dlpack,
+    ndarray,
+    newaxis,
+    result_type,
+)
+from ._ufuncs import *  # noqa: F403
+from ._util import AxisError, UFuncTypeError
+
+
+from math import pi, e  # usort: skip
+
+
+all = all  # noqa: PLW0127
+alltrue = all
+
+any = any  # noqa: PLW0127
+sometrue = any
+
+inf = float("inf")
+nan = float("nan")
+
+False_ = False
+True_ = True

.venv/lib/python3.12/site-packages/torch/_numpy/_binary_ufuncs_impl.py

@@ -0,0 +1,85 @@
+# mypy: ignore-errors
+
+"""Export torch work functions for binary ufuncs, rename/tweak to match numpy.
+This listing is further exported to public symbols in the `torch._numpy/_ufuncs.py` module.
+"""
+
+import torch
+from torch import (  # noqa: F401
+    add,
+    arctan2,
+    bitwise_and,
+    bitwise_left_shift as left_shift,
+    bitwise_or,
+    bitwise_right_shift as right_shift,
+    bitwise_xor,
+    copysign,
+    divide,
+    eq as equal,
+    float_power,
+    floor_divide,
+    fmax,
+    fmin,
+    fmod,
+    gcd,
+    greater,
+    greater_equal,
+    heaviside,
+    hypot,
+    lcm,
+    ldexp,
+    less,
+    less_equal,
+    logaddexp,
+    logaddexp2,
+    logical_and,
+    logical_or,
+    logical_xor,
+    maximum,
+    minimum,
+    multiply,
+    nextafter,
+    not_equal,
+    pow as power,
+    remainder,
+    remainder as mod,
+    subtract,
+    true_divide,
+)
+
+from . import _dtypes_impl, _util
+
+
+# work around torch limitations w.r.t. numpy
+def matmul(x, y):
+    # work around:
+    #  - RuntimeError: expected scalar type Int but found Double
+    #  - RuntimeError: "addmm_impl_cpu_" not implemented for 'Bool'
+    #  - RuntimeError: "addmm_impl_cpu_" not implemented for 'Half'
+    dtype = _dtypes_impl.result_type_impl(x, y)
+    is_bool = dtype == torch.bool
+    is_half = (x.dtype == torch.float16 or y.dtype == torch.float16) and (
+        x.is_cpu or y.is_cpu
+    )
+
+    work_dtype = dtype
+    if is_bool:
+        work_dtype = torch.uint8
+    if is_half:
+        work_dtype = torch.float32
+
+    x = _util.cast_if_needed(x, work_dtype)
+    y = _util.cast_if_needed(y, work_dtype)
+
+    result = torch.matmul(x, y)
+
+    if work_dtype != dtype:
+        result = result.to(dtype)
+
+    return result
+
+
+# a stub implementation of divmod, should be improved after
+# https://github.com/pytorch/pytorch/issues/90820 is fixed in pytorch
+def divmod(x, y):
+    return x // y, x % y

.venv/lib/python3.12/site-packages/torch/_numpy/_casting_dicts.py

@@ -0,0 +1,1368 @@
+# mypy: ignore-errors
+
+import torch
+
+
+# These two dicts are autogenerated with autogen/gen_dtypes.py,
+# using numpy version 1.24.3.
+
+_can_cast_dict = {
+    "no": {
+        torch.float16: {
+            torch.float16: True,
+            torch.float32: False,
+            torch.float64: False,
+            torch.complex64: False,
+            torch.complex128: False,
+            torch.uint8: False,
+            torch.uint16: False,
+            torch.uint32: False,
+            torch.uint64: False,
+            torch.int8: False,
+            torch.int16: False,
+            torch.int32: False,
+            torch.int64: False,
+            torch.bool: False,
+        },
+        torch.float32: {
+            torch.float16: False,
+            torch.float32: True,
+            torch.float64: False,
+            torch.complex64: False,
+            torch.complex128: False,
+            torch.uint8: False,
+            torch.uint16: False,
+            torch.uint32: False,
+            torch.uint64: False,
+            torch.int8: False,
+            torch.int16: False,
+            torch.int32: False,
+            torch.int64: False,
+            torch.bool: False,
+        },
+        torch.float64: {
+            torch.float16: False,
+            torch.float32: False,
+            torch.float64: True,
+            torch.complex64: False,
+            torch.complex128: False,
+            torch.uint8: False,
+            torch.uint16: False,
+            torch.uint32: False,
+            torch.uint64: False,
+            torch.int8: False,
+            torch.int16: False,
+            torch.int32: False,
+            torch.int64: False,
+            torch.bool: False,
+        },
+        torch.complex64: {
+            torch.float16: False,
+            torch.float32: False,
+            torch.float64: False,
+            torch.complex64: True,
+            torch.complex128: False,
+            torch.uint8: False,
+            torch.uint16: False,
+            torch.uint32: False,
+            torch.uint64: False,
+            torch.int8: False,
+            torch.int16: False,
+            torch.int32: False,
+            torch.int64: False,
+            torch.bool: False,
+        },
+        torch.complex128: {
+            torch.float16: False,
+            torch.float32: False,
+            torch.float64: False,
+            torch.complex64: False,
+            torch.complex128: True,
+            torch.uint8: False,
+            torch.uint16: False,
+            torch.uint32: False,
+            torch.uint64: False,
+            torch.int8: False,
+            torch.int16: False,
+            torch.int32: False,
+            torch.int64: False,
+            torch.bool: False,
+        },
+        torch.uint8: {
+            torch.float16: False,
+            torch.float32: False,
+            torch.float64: False,
+            torch.complex64: False,
+            torch.complex128: False,
+            torch.uint8: True,
+            torch.uint16: False,
+            torch.uint32: False,
+            torch.uint64: False,
+            torch.int8: False,
+            torch.int16: False,
+            torch.int32: False,
+            torch.int64: False,
+            torch.bool: False,
+        },
+        torch.uint16: {
+            torch.float16: False,
+            torch.float32: False,
+            torch.float64: False,
+            torch.complex64: False,
+            torch.complex128: False,
+            torch.uint8: False,
+            torch.uint16: True,
+            torch.uint32: False,
+            torch.uint64: False,
+            torch.int8: False,
+            torch.int16: False,
+            torch.int32: False,
+            torch.int64: False,
+            torch.bool: False,
+        },
+        torch.uint32: {
+            torch.float16: False,
+            torch.float32: False,
+            torch.float64: False,
+            torch.complex64: False,
+            torch.complex128: False,
+            torch.uint8: False,
+            torch.uint16: False,
+            torch.uint32: True,
+            torch.uint64: False,
+            torch.int8: False,
+            torch.int16: False,
+            torch.int32: False,
+            torch.int64: False,
+            torch.bool: False,
+        },
+        torch.uint64: {
+            torch.float16: False,
+            torch.float32: False,
+            torch.float64: False,
+            torch.complex64: False,
+            torch.complex128: False,
+            torch.uint8: False,
+            torch.uint16: False,
+            torch.uint32: False,
+            torch.uint64: True,
+            torch.int8: False,
+            torch.int16: False,
+            torch.int32: False,
+            torch.int64: False,
+            torch.bool: False,
+        },
+        torch.int8: {
+            torch.float16: False,
+            torch.float32: False,
+            torch.float64: False,
+            torch.complex64: False,
+            torch.complex128: False,
+            torch.uint8: False,
+            torch.uint16: False,
+            torch.uint32: False,
+            torch.uint64: False,
+            torch.int8: True,
+            torch.int16: False,
+            torch.int32: False,
+            torch.int64: False,
+            torch.bool: False,
+        },
+        torch.int16: {
+            torch.float16: False,
+            torch.float32: False,
+            torch.float64: False,
+            torch.complex64: False,
+            torch.complex128: False,
+            torch.uint8: False,
+            torch.uint16: False,
+            torch.uint32: False,
+            torch.uint64: False,
+            torch.int8: False,
+            torch.int16: True,
+            torch.int32: False,
+            torch.int64: False,
+            torch.bool: False,
+        },
+        torch.int32: {
+            torch.float16: False,
+            torch.float32: False,
+            torch.float64: False,
+            torch.complex64: False,
+            torch.complex128: False,
+            torch.uint8: False,
+            torch.uint16: False,
+            torch.uint32: False,
+            torch.uint64: False,
+            torch.int8: False,
+            torch.int16: False,
+            torch.int32: True,
+            torch.int64: False,
+            torch.bool: False,
+        },
+        torch.int64: {
+            torch.float16: False,
+            torch.float32: False,
+            torch.float64: False,
+            torch.complex64: False,
+            torch.complex128: False,
+            torch.uint8: False,
+            torch.uint16: False,
+            torch.uint32: False,
+            torch.uint64: False,
+            torch.int8: False,
+            torch.int16: False,
+            torch.int32: False,
+            torch.int64: True,
+            torch.bool: False,
+        },
+        torch.bool: {
+            torch.float16: False,
+            torch.float32: False,
+            torch.float64: False,
+            torch.complex64: False,
+            torch.complex128: False,
+            torch.uint8: False,
+            torch.uint16: False,
+            torch.uint32: False,
+            torch.uint64: False,
+            torch.int8: False,
+            torch.int16: False,
+            torch.int32: False,
+            torch.int64: False,
+            torch.bool: True,
+        },
+    },
+    "equiv": {
+        torch.float16: {
+            torch.float16: True,
+            torch.float32: False,
+            torch.float64: False,
+            torch.complex64: False,
+            torch.complex128: False,
+            torch.uint8: False,
+            torch.uint16: False,
+            torch.uint32: False,
+            torch.uint64: False,
+            torch.int8: False,
+            torch.int16: False,
+            torch.int32: False,
+            torch.int64: False,
+            torch.bool: False,
+        },
+        torch.float32: {
+            torch.float16: False,
+            torch.float32: True,
+            torch.float64: False,
+            torch.complex64: False,
+            torch.complex128: False,
+            torch.uint8: False,
+            torch.uint16: False,
+            torch.uint32: False,
+            torch.uint64: False,
+            torch.int8: False,
+            torch.int16: False,
+            torch.int32: False,
+            torch.int64: False,
+            torch.bool: False,
+        },
+        torch.float64: {
+            torch.float16: False,
+            torch.float32: False,
+            torch.float64: True,
+            torch.complex64: False,
+            torch.complex128: False,
+            torch.uint8: False,
+            torch.uint16: False,
+            torch.uint32: False,
+            torch.uint64: False,
+            torch.int8: False,
+            torch.int16: False,
+            torch.int32: False,
+            torch.int64: False,
+            torch.bool: False,
+        },
+        torch.complex64: {
+            torch.float16: False,
+            torch.float32: False,
+            torch.float64: False,
+            torch.complex64: True,
+            torch.complex128: False,
+            torch.uint8: False,
+            torch.uint16: False,
+            torch.uint32: False,
+            torch.uint64: False,
+            torch.int8: False,
+            torch.int16: False,
+            torch.int32: False,
+            torch.int64: False,
+            torch.bool: False,
+        },
+        torch.complex128: {
+            torch.float16: False,
+            torch.float32: False,
+            torch.float64: False,
+            torch.complex64: False,
+            torch.complex128: True,
+            torch.uint8: False,
+            torch.uint16: False,
+            torch.uint32: False,
+            torch.uint64: False,
+            torch.int8: False,
+            torch.int16: False,
+            torch.int32: False,
+            torch.int64: False,
+            torch.bool: False,
+        },
+        torch.uint8: {
+            torch.float16: False,
+            torch.float32: False,
+            torch.float64: False,
+            torch.complex64: False,
+            torch.complex128: False,
+            torch.uint8: True,
+            torch.uint16: False,
+            torch.uint32: False,
+            torch.uint64: False,
+            torch.int8: False,
+            torch.int16: False,
+            torch.int32: False,
+            torch.int64: False,
+            torch.bool: False,
+        },
+        torch.uint16: {
+            torch.float16: False,
+            torch.float32: False,
+            torch.float64: False,
+            torch.complex64: False,
+            torch.complex128: False,
+            torch.uint8: False,
+            torch.uint16: True,
+            torch.uint32: False,
+            torch.uint64: False,
+            torch.int8: False,
+            torch.int16: False,
+            torch.int32: False,
+            torch.int64: False,
+            torch.bool: False,
+        },
+        torch.uint32: {
+            torch.float16: False,
+            torch.float32: False,
+            torch.float64: False,
+            torch.complex64: False,
+            torch.complex128: False,
+            torch.uint8: False,
+            torch.uint16: False,
+            torch.uint32: True,
+            torch.uint64: False,
+            torch.int8: False,
+            torch.int16: False,
+            torch.int32: False,
+            torch.int64: False,
+            torch.bool: False,
+        },
+        torch.uint64: {
+            torch.float16: False,
+            torch.float32: False,
+            torch.float64: False,
+            torch.complex64: False,
+            torch.complex128: False,
+            torch.uint8: False,
+            torch.uint16: False,
+            torch.uint32: False,
+            torch.uint64: True,
+            torch.int8: False,
+            torch.int16: False,
+            torch.int32: False,
+            torch.int64: False,
+            torch.bool: False,
+        },
+        torch.int8: {
+            torch.float16: False,
+            torch.float32: False,
+            torch.float64: False,
+            torch.complex64: False,
+            torch.complex128: False,
+            torch.uint8: False,
+            torch.uint16: False,
+            torch.uint32: False,
+            torch.uint64: False,
+            torch.int8: True,
+            torch.int16: False,
+            torch.int32: False,
+            torch.int64: False,
+            torch.bool: False,
+        },
+        torch.int16: {
+            torch.float16: False,
+            torch.float32: False,
+            torch.float64: False,
+            torch.complex64: False,
+            torch.complex128: False,
+            torch.uint8: False,
+            torch.uint16: False,
+            torch.uint32: False,
+            torch.uint64: False,
+            torch.int8: False,
+            torch.int16: True,
+            torch.int32: False,
+            torch.int64: False,
+            torch.bool: False,
+        },
+        torch.int32: {
+            torch.float16: False,
+            torch.float32: False,
+            torch.float64: False,
+            torch.complex64: False,
+            torch.complex128: False,
+            torch.uint8: False,
+            torch.uint16: False,
+            torch.uint32: False,
+            torch.uint64: False,
+            torch.int8: False,
+            torch.int16: False,
+            torch.int32: True,
+            torch.int64: False,
+            torch.bool: False,
+        },
+        torch.int64: {
+            torch.float16: False,
+            torch.float32: False,
+            torch.float64: False,
+            torch.complex64: False,
+            torch.complex128: False,
+            torch.uint8: False,
+            torch.uint16: False,
+            torch.uint32: False,
+            torch.uint64: False,
+            torch.int8: False,
+            torch.int16: False,
+            torch.int32: False,
+            torch.int64: True,
+            torch.bool: False,
+        },
+        torch.bool: {
+            torch.float16: False,
+            torch.float32: False,
+            torch.float64: False,
+            torch.complex64: False,
+            torch.complex128: False,
+            torch.uint8: False,
+            torch.uint16: False,
+            torch.uint32: False,
+            torch.uint64: False,
+            torch.int8: False,
+            torch.int16: False,
+            torch.int32: False,
+            torch.int64: False,
+            torch.bool: True,
+        },
+    },
+    "safe": {
+        torch.float16: {
+            torch.float16: True,
+            torch.float32: True,
+            torch.float64: True,
+            torch.complex64: True,
+            torch.complex128: True,
+            torch.uint8: False,
+            torch.uint16: False,
+            torch.uint32: False,
+            torch.uint64: False,
+            torch.int8: False,
+            torch.int16: False,
+            torch.int32: False,
+            torch.int64: False,
+            torch.bool: False,
+        },
+        torch.float32: {
+            torch.float16: False,
+            torch.float32: True,
+            torch.float64: True,
+            torch.complex64: True,
+            torch.complex128: True,
+            torch.uint8: False,
+            torch.uint16: False,
+            torch.uint32: False,
+            torch.uint64: False,
+            torch.int8: False,
+            torch.int16: False,
+            torch.int32: False,
+            torch.int64: False,
+            torch.bool: False,
+        },
+        torch.float64: {
+            torch.float16: False,
+            torch.float32: False,
+            torch.float64: True,
+            torch.complex64: False,
+            torch.complex128: True,
+            torch.uint8: False,
+            torch.uint16: False,
+            torch.uint32: False,
+            torch.uint64: False,
+            torch.int8: False,
+            torch.int16: False,
+            torch.int32: False,
+            torch.int64: False,
+            torch.bool: False,
+        },
+        torch.complex64: {
+            torch.float16: False,
+            torch.float32: False,
+            torch.float64: False,
+            torch.complex64: True,
+            torch.complex128: True,
+            torch.uint8: False,
+            torch.uint16: False,
+            torch.uint32: False,
+            torch.uint64: False,
+            torch.int8: False,
+            torch.int16: False,
+            torch.int32: False,
+            torch.int64: False,
+            torch.bool: False,
+        },
+        torch.complex128: {
+            torch.float16: False,
+            torch.float32: False,
+            torch.float64: False,
+            torch.complex64: False,
+            torch.complex128: True,
+            torch.uint8: False,
+            torch.uint16: False,
+            torch.uint32: False,
+            torch.uint64: False,
+            torch.int8: False,
+            torch.int16: False,
+            torch.int32: False,
+            torch.int64: False,
+            torch.bool: False,
+        },
+        torch.uint8: {
+            torch.float16: True,
+            torch.float32: True,
+            torch.float64: True,
+            torch.complex64: True,
+            torch.complex128: True,
+            torch.uint8: True,
+            torch.uint16: True,
+            torch.uint32: True,
+            torch.uint64: True,
+            torch.int8: False,
+            torch.int16: True,
+            torch.int32: True,
+            torch.int64: True,
+            torch.bool: False,
+        },
+        torch.uint16: {
+            torch.float16: False,
+            torch.float32: True,
+            torch.float64: True,
+            torch.complex64: True,
+            torch.complex128: True,
+            torch.uint8: False,
+            torch.uint16: True,
+            torch.uint32: True,
+            torch.uint64: True,
+            torch.int8: False,
+            torch.int16: False,
+            torch.int32: True,
+            torch.int64: True,
+            torch.bool: False,
+        },
+        torch.uint32: {
+            torch.float16: False,
+            torch.float32: False,
+            torch.float64: True,
+            torch.complex64: False,
+            torch.complex128: True,
+            torch.uint8: False,
+            torch.uint16: False,
+            torch.uint32: True,
+            torch.uint64: True,
+            torch.int8: False,
+            torch.int16: False,
+            torch.int32: False,
+            torch.int64: True,
+            torch.bool: False,
+        },
+        torch.uint64: {
+            torch.float16: False,
+            torch.float32: False,
+            torch.float64: True,
+            torch.complex64: False,
+            torch.complex128: True,
+            torch.uint8: False,
+            torch.uint16: False,
+            torch.uint32: False,
+            torch.uint64: True,
+            torch.int8: False,
+            torch.int16: False,
+            torch.int32: False,
+            torch.int64: False,
+            torch.bool: False,
+        },
+        torch.int8: {
+            torch.float16: True,
+            torch.float32: True,
+            torch.float64: True,
+            torch.complex64: True,
+            torch.complex128: True,
+            torch.uint8: False,
+            torch.uint16: False,
+            torch.uint32: False,
+            torch.uint64: False,
+            torch.int8: True,
+            torch.int16: True,
+            torch.int32: True,
+            torch.int64: True,
+            torch.bool: False,
+        },
+        torch.int16: {
+            torch.float16: False,
+            torch.float32: True,
+            torch.float64: True,
+            torch.complex64: True,
+            torch.complex128: True,
+            torch.uint8: False,
+            torch.uint16: False,
+            torch.uint32: False,
+            torch.uint64: False,
+            torch.int8: False,
+            torch.int16: True,
+            torch.int32: True,
+            torch.int64: True,
+            torch.bool: False,
+        },
+        torch.int32: {
+            torch.float16: False,
+            torch.float32: False,
+            torch.float64: True,
+            torch.complex64: False,
+            torch.complex128: True,
+            torch.uint8: False,
+            torch.uint16: False,
+            torch.uint32: False,
+            torch.uint64: False,
+            torch.int8: False,
+            torch.int16: False,
+            torch.int32: True,
+            torch.int64: True,
+            torch.bool: False,
+        },
+        torch.int64: {
+            torch.float16: False,
+            torch.float32: False,
+            torch.float64: True,
+            torch.complex64: False,
+            torch.complex128: True,
+            torch.uint8: False,
+            torch.uint16: False,
+            torch.uint32: False,
+            torch.uint64: False,
+            torch.int8: False,
+            torch.int16: False,
+            torch.int32: False,
+            torch.int64: True,
+            torch.bool: False,
+        },
+        torch.bool: {
+            torch.float16: True,
+            torch.float32: True,
+            torch.float64: True,
+            torch.complex64: True,
+            torch.complex128: True,
+            torch.uint8: True,
+            torch.uint16: True,
+            torch.uint32: True,
+            torch.uint64: True,
+            torch.int8: True,
+            torch.int16: True,
+            torch.int32: True,
+            torch.int64: True,
+            torch.bool: True,
+        },
+    },
+    "same_kind": {
+        torch.float16: {
+            torch.float16: True,
+            torch.float32: True,
+            torch.float64: True,
+            torch.complex64: True,
+            torch.complex128: True,
+            torch.uint8: False,
+            torch.uint16: False,
+            torch.uint32: False,
+            torch.uint64: False,
+            torch.int8: False,
+            torch.int16: False,
+            torch.int32: False,
+            torch.int64: False,
+            torch.bool: False,
+        },
+        torch.float32: {
+            torch.float16: True,
+            torch.float32: True,
+            torch.float64: True,
+            torch.complex64: True,
+            torch.complex128: True,
+            torch.uint8: False,
+            torch.uint16: False,
+            torch.uint32: False,
+            torch.uint64: False,
+            torch.int8: False,
+            torch.int16: False,
+            torch.int32: False,
+            torch.int64: False,
+            torch.bool: False,
+        },
+        torch.float64: {
+            torch.float16: True,
+            torch.float32: True,
+            torch.float64: True,
+            torch.complex64: True,
+            torch.complex128: True,
+            torch.uint8: False,
+            torch.uint16: False,
+            torch.uint32: False,
+            torch.uint64: False,
+            torch.int8: False,
+            torch.int16: False,
+            torch.int32: False,
+            torch.int64: False,
+            torch.bool: False,
+        },
+        torch.complex64: {
+            torch.float16: False,
+            torch.float32: False,
+            torch.float64: False,
+            torch.complex64: True,
+            torch.complex128: True,
+            torch.uint8: False,
+            torch.uint16: False,
+            torch.uint32: False,
+            torch.uint64: False,
+            torch.int8: False,
+            torch.int16: False,
+            torch.int32: False,
+            torch.int64: False,
+            torch.bool: False,
+        },
+        torch.complex128: {
+            torch.float16: False,
+            torch.float32: False,
+            torch.float64: False,
+            torch.complex64: True,
+            torch.complex128: True,
+            torch.uint8: False,
+            torch.uint16: False,
+            torch.uint32: False,
+            torch.uint64: False,
+            torch.int8: False,
+            torch.int16: False,
+            torch.int32: False,
+            torch.int64: False,
+            torch.bool: False,
+        },
+        torch.uint8: {
+            torch.float16: True,
+            torch.float32: True,
+            torch.float64: True,
+            torch.complex64: True,
+            torch.complex128: True,
+            torch.uint8: True,
+            torch.uint16: True,
+            torch.uint32: True,
+            torch.uint64: True,
+            torch.int8: True,
+            torch.int16: True,
+            torch.int32: True,
+            torch.int64: True,
+            torch.bool: False,
+        },
+        torch.uint16: {
+            torch.float16: True,
+            torch.float32: True,
+            torch.float64: True,
+            torch.complex64: True,
+            torch.complex128: True,
+            torch.uint8: True,
+            torch.uint16: True,
+            torch.uint32: True,
+            torch.uint64: True,
+            torch.int8: True,
+            torch.int16: True,
+            torch.int32: True,
+            torch.int64: True,
+            torch.bool: False,
+        },
+        torch.uint32: {
+            torch.float16: True,
+            torch.float32: True,
+            torch.float64: True,
+            torch.complex64: True,
+            torch.complex128: True,
+            torch.uint8: True,
+            torch.uint16: True,
+            torch.uint32: True,
+            torch.uint64: True,
+            torch.int8: True,
+            torch.int16: True,
+            torch.int32: True,
+            torch.int64: True,
+            torch.bool: False,
+        },
+        torch.uint64: {
+            torch.float16: True,
+            torch.float32: True,
+            torch.float64: True,
+            torch.complex64: True,
+            torch.complex128: True,
+            torch.uint8: True,
+            torch.uint16: True,
+            torch.uint32: True,
+            torch.uint64: True,
+            torch.int8: True,
+            torch.int16: True,
+            torch.int32: True,
+            torch.int64: True,
+            torch.bool: False,
+        },
+        torch.int8: {
+            torch.float16: True,
+            torch.float32: True,
+            torch.float64: True,
+            torch.complex64: True,
+            torch.complex128: True,
+            torch.uint8: False,
+            torch.uint16: False,
+            torch.uint32: False,
+            torch.uint64: False,
+            torch.int8: True,
+            torch.int16: True,
+            torch.int32: True,
+            torch.int64: True,
+            torch.bool: False,
+        },
+        torch.int16: {
+            torch.float16: True,
+            torch.float32: True,
+            torch.float64: True,
+            torch.complex64: True,
+            torch.complex128: True,
+            torch.uint8: False,
+            torch.uint16: False,
+            torch.uint32: False,
+            torch.uint64: False,
+            torch.int8: True,
+            torch.int16: True,
+            torch.int32: True,
+            torch.int64: True,
+            torch.bool: False,
+        },
+        torch.int32: {
+            torch.float16: True,
+            torch.float32: True,
+            torch.float64: True,
+            torch.complex64: True,
+            torch.complex128: True,
+            torch.uint8: False,
+            torch.uint16: False,
+            torch.uint32: False,
+            torch.uint64: False,
+            torch.int8: True,
+            torch.int16: True,
+            torch.int32: True,
+            torch.int64: True,
+            torch.bool: False,
+        },
+        torch.int64: {
+            torch.float16: True,
+            torch.float32: True,
+            torch.float64: True,
+            torch.complex64: True,
+            torch.complex128: True,
+            torch.uint8: False,
+            torch.uint16: False,
+            torch.uint32: False,
+            torch.uint64: False,
+            torch.int8: True,
+            torch.int16: True,
+            torch.int32: True,
+            torch.int64: True,
+            torch.bool: False,
+        },
+        torch.bool: {
+            torch.float16: True,
+            torch.float32: True,
+            torch.float64: True,
+            torch.complex64: True,
+            torch.complex128: True,
+            torch.uint8: True,
+            torch.uint16: True,
+            torch.uint32: True,
+            torch.uint64: True,
+            torch.int8: True,
+            torch.int16: True,
+            torch.int32: True,
+            torch.int64: True,
+            torch.bool: True,
+        },
+    },
+    "unsafe": {
+        torch.float16: {
+            torch.float16: True,
+            torch.float32: True,
+            torch.float64: True,
+            torch.complex64: True,
+            torch.complex128: True,
+            torch.uint8: True,
+            torch.uint16: True,
+            torch.uint32: True,
+            torch.uint64: True,
+            torch.int8: True,
+            torch.int16: True,
+            torch.int32: True,
+            torch.int64: True,
+            torch.bool: True,
+        },
+        torch.float32: {
+            torch.float16: True,
+            torch.float32: True,
+            torch.float64: True,
+            torch.complex64: True,
+            torch.complex128: True,
+            torch.uint8: True,
+            torch.uint16: True,
+            torch.uint32: True,
+            torch.uint64: True,
+            torch.int8: True,
+            torch.int16: True,
+            torch.int32: True,
+            torch.int64: True,
+            torch.bool: True,
+        },
+        torch.float64: {
+            torch.float16: True,
+            torch.float32: True,
+            torch.float64: True,
+            torch.complex64: True,
+            torch.complex128: True,
+            torch.uint8: True,
+            torch.uint16: True,
+            torch.uint32: True,
+            torch.uint64: True,
+            torch.int8: True,
+            torch.int16: True,
+            torch.int32: True,
+            torch.int64: True,
+            torch.bool: True,
+        },
+        torch.complex64: {
+            torch.float16: True,
+            torch.float32: True,
+            torch.float64: True,
+            torch.complex64: True,
+            torch.complex128: True,
+            torch.uint8: True,
+            torch.uint16: True,
+            torch.uint32: True,
+            torch.uint64: True,
+            torch.int8: True,
+            torch.int16: True,
+            torch.int32: True,
+            torch.int64: True,
+            torch.bool: True,
+        },
+        torch.complex128: {
+            torch.float16: True,
+            torch.float32: True,
+            torch.float64: True,
+            torch.complex64: True,
+            torch.complex128: True,
+            torch.uint8: True,
+            torch.uint16: True,
+            torch.uint32: True,
+            torch.uint64: True,
+            torch.int8: True,
+            torch.int16: True,
+            torch.int32: True,
+            torch.int64: True,
+            torch.bool: True,
+        },
+        torch.uint8: {
+            torch.float16: True,
+            torch.float32: True,
+            torch.float64: True,
+            torch.complex64: True,
+            torch.complex128: True,
+            torch.uint8: True,
+            torch.uint16: True,
+            torch.uint32: True,
+            torch.uint64: True,
+            torch.int8: True,
+            torch.int16: True,
+            torch.int32: True,
+            torch.int64: True,
+            torch.bool: True,
+        },
+        torch.uint16: {
+            torch.float16: True,
+            torch.float32: True,
+            torch.float64: True,
+            torch.complex64: True,
+            torch.complex128: True,
+            torch.uint8: True,
+            torch.uint16: True,
+            torch.uint32: True,
+            torch.uint64: True,
+            torch.int8: True,
+            torch.int16: True,
+            torch.int32: True,
+            torch.int64: True,
+            torch.bool: True,
+        },
+        torch.uint32: {
+            torch.float16: True,
+            torch.float32: True,
+            torch.float64: True,
+            torch.complex64: True,
+            torch.complex128: True,
+            torch.uint8: True,
+            torch.uint16: True,
+            torch.uint32: True,
+            torch.uint64: True,
+            torch.int8: True,
+            torch.int16: True,
+            torch.int32: True,
+            torch.int64: True,
+            torch.bool: True,
+        },
+        torch.uint64: {
+            torch.float16: True,
+            torch.float32: True,
+            torch.float64: True,
+            torch.complex64: True,
+            torch.complex128: True,
+            torch.uint8: True,
+            torch.uint16: True,
+            torch.uint32: True,
+            torch.uint64: True,
+            torch.int8: True,
+            torch.int16: True,
+            torch.int32: True,
+            torch.int64: True,
+            torch.bool: True,
+        },
+        torch.int8: {
+            torch.float16: True,
+            torch.float32: True,
+            torch.float64: True,
+            torch.complex64: True,
+            torch.complex128: True,
+            torch.uint8: True,
+            torch.uint16: True,
+            torch.uint32: True,
+            torch.uint64: True,
+            torch.int8: True,
+            torch.int16: True,
+            torch.int32: True,
+            torch.int64: True,
+            torch.bool: True,
+        },
+        torch.int16: {
+            torch.float16: True,
+            torch.float32: True,
+            torch.float64: True,
+            torch.complex64: True,
+            torch.complex128: True,
+            torch.uint8: True,
+            torch.uint16: True,
+            torch.uint32: True,
+            torch.uint64: True,
+            torch.int8: True,
+            torch.int16: True,
+            torch.int32: True,
+            torch.int64: True,
+            torch.bool: True,
+        },
+        torch.int32: {
+            torch.float16: True,
+            torch.float32: True,
+            torch.float64: True,
+            torch.complex64: True,
+            torch.complex128: True,
+            torch.uint8: True,
+            torch.uint16: True,
+            torch.uint32: True,
+            torch.uint64: True,
+            torch.int8: True,
+            torch.int16: True,
+            torch.int32: True,
+            torch.int64: True,
+            torch.bool: True,
+        },
+        torch.int64: {
+            torch.float16: True,
+            torch.float32: True,
+            torch.float64: True,
+            torch.complex64: True,
+            torch.complex128: True,
+            torch.uint8: True,
+            torch.uint16: True,
+            torch.uint32: True,
+            torch.uint64: True,
+            torch.int8: True,
+            torch.int16: True,
+            torch.int32: True,
+            torch.int64: True,
+            torch.bool: True,
+        },
+        torch.bool: {
+            torch.float16: True,
+            torch.float32: True,
+            torch.float64: True,
+            torch.complex64: True,
+            torch.complex128: True,
+            torch.uint8: True,
+            torch.uint16: True,
+            torch.uint32: True,
+            torch.uint64: True,
+            torch.int8: True,
+            torch.int16: True,
+            torch.int32: True,
+            torch.int64: True,
+            torch.bool: True,
+        },
+    },
+}
+
+
+_result_type_dict = {
+    torch.float16: {
+        torch.float16: torch.float16,
+        torch.float32: torch.float32,
+        torch.float64: torch.float64,
+        torch.complex64: torch.complex64,
+        torch.complex128: torch.complex128,
+        torch.uint8: torch.float16,
+        torch.uint16: torch.float32,
+        torch.uint32: torch.float64,
+        torch.uint64: torch.float64,
+        torch.int8: torch.float16,
+        torch.int16: torch.float32,
+        torch.int32: torch.float64,
+        torch.int64: torch.float64,
+        torch.bool: torch.float16,
+    },
+    torch.float32: {
+        torch.float16: torch.float32,
+        torch.float32: torch.float32,
+        torch.float64: torch.float64,
+        torch.complex64: torch.complex64,
+        torch.complex128: torch.complex128,
+        torch.uint8: torch.float32,
+        torch.uint16: torch.float32,
+        torch.uint32: torch.float64,
+        torch.uint64: torch.float64,
+        torch.int8: torch.float32,
+        torch.int16: torch.float32,
+        torch.int32: torch.float64,
+        torch.int64: torch.float64,
+        torch.bool: torch.float32,
+    },
+    torch.float64: {
+        torch.float16: torch.float64,
+        torch.float32: torch.float64,
+        torch.float64: torch.float64,
+        torch.complex64: torch.complex128,
+        torch.complex128: torch.complex128,
+        torch.uint8: torch.float64,
+        torch.uint16: torch.float64,
+        torch.uint32: torch.float64,
+        torch.uint64: torch.float64,
+        torch.int8: torch.float64,
+        torch.int16: torch.float64,
+        torch.int32: torch.float64,
+        torch.int64: torch.float64,
+        torch.bool: torch.float64,
+    },
+    torch.complex64: {
+        torch.float16: torch.complex64,
+        torch.float32: torch.complex64,
+        torch.float64: torch.complex128,
+        torch.complex64: torch.complex64,
+        torch.complex128: torch.complex128,
+        torch.uint8: torch.complex64,
+        torch.uint16: torch.complex64,
+        torch.uint32: torch.complex128,
+        torch.uint64: torch.complex128,
+        torch.int8: torch.complex64,
+        torch.int16: torch.complex64,
+        torch.int32: torch.complex128,
+        torch.int64: torch.complex128,
+        torch.bool: torch.complex64,
+    },
+    torch.complex128: {
+        torch.float16: torch.complex128,
+        torch.float32: torch.complex128,
+        torch.float64: torch.complex128,
+        torch.complex64: torch.complex128,
+        torch.complex128: torch.complex128,
+        torch.uint8: torch.complex128,
+        torch.uint16: torch.complex128,
+        torch.uint32: torch.complex128,
+        torch.uint64: torch.complex128,
+        torch.int8: torch.complex128,
+        torch.int16: torch.complex128,
+        torch.int32: torch.complex128,
+        torch.int64: torch.complex128,
+        torch.bool: torch.complex128,
+    },
+    torch.uint8: {
+        torch.float16: torch.float16,
+        torch.float32: torch.float32,
+        torch.float64: torch.float64,
+        torch.complex64: torch.complex64,
+        torch.complex128: torch.complex128,
+        torch.uint8: torch.uint8,
+        torch.uint16: torch.uint16,
+        torch.uint32: torch.uint32,
+        torch.uint64: torch.uint64,
+        torch.int8: torch.int16,
+        torch.int16: torch.int16,
+        torch.int32: torch.int32,
+        torch.int64: torch.int64,
+        torch.bool: torch.uint8,
+    },
+    torch.uint16: {
+        torch.float16: torch.float32,
+        torch.float32: torch.float32,
+        torch.float64: torch.float64,
+        torch.complex64: torch.complex64,
+        torch.complex128: torch.complex128,
+        torch.uint8: torch.uint16,
+        torch.uint16: torch.uint16,
+        torch.uint32: torch.uint32,
+        torch.uint64: torch.uint64,
+        torch.int8: torch.int32,
+        torch.int16: torch.int32,
+        torch.int32: torch.int32,
+        torch.int64: torch.int64,
+        torch.bool: torch.uint16,
+    },
+    torch.uint32: {
+        torch.float16: torch.float64,
+        torch.float32: torch.float64,
+        torch.float64: torch.float64,
+        torch.complex64: torch.complex128,
+        torch.complex128: torch.complex128,
+        torch.uint8: torch.uint32,
+        torch.uint16: torch.uint32,
+        torch.uint32: torch.uint32,
+        torch.uint64: torch.uint64,
+        torch.int8: torch.int64,
+        torch.int16: torch.int64,
+        torch.int32: torch.int64,
+        torch.int64: torch.int64,
+        torch.bool: torch.uint32,
+    },
+    torch.uint64: {
+        torch.float16: torch.float64,
+        torch.float32: torch.float64,
+        torch.float64: torch.float64,
+        torch.complex64: torch.complex128,
+        torch.complex128: torch.complex128,
+        torch.uint8: torch.uint64,
+        torch.uint16: torch.uint64,
+        torch.uint32: torch.uint64,
+        torch.uint64: torch.uint64,
+        torch.int8: torch.float64,
+        torch.int16: torch.float64,
+        torch.int32: torch.float64,
+        torch.int64: torch.float64,
+        torch.bool: torch.uint64,
+    },
+    torch.int8: {
+        torch.float16: torch.float16,
+        torch.float32: torch.float32,
+        torch.float64: torch.float64,
+        torch.complex64: torch.complex64,
+        torch.complex128: torch.complex128,
+        torch.uint8: torch.int16,
+        torch.uint16: torch.int32,
+        torch.uint32: torch.int64,
+        torch.uint64: torch.float64,
+        torch.int8: torch.int8,
+        torch.int16: torch.int16,
+        torch.int32: torch.int32,
+        torch.int64: torch.int64,
+        torch.bool: torch.int8,
+    },
+    torch.int16: {
+        torch.float16: torch.float32,
+        torch.float32: torch.float32,
+        torch.float64: torch.float64,
+        torch.complex64: torch.complex64,
+        torch.complex128: torch.complex128,
+        torch.uint8: torch.int16,
+        torch.uint16: torch.int32,
+        torch.uint32: torch.int64,
+        torch.uint64: torch.float64,
+        torch.int8: torch.int16,
+        torch.int16: torch.int16,
+        torch.int32: torch.int32,
+        torch.int64: torch.int64,
+        torch.bool: torch.int16,
+    },
+    torch.int32: {
+        torch.float16: torch.float64,
+        torch.float32: torch.float64,
+        torch.float64: torch.float64,
+        torch.complex64: torch.complex128,
+        torch.complex128: torch.complex128,
+        torch.uint8: torch.int32,
+        torch.uint16: torch.int32,
+        torch.uint32: torch.int64,
+        torch.uint64: torch.float64,
+        torch.int8: torch.int32,
+        torch.int16: torch.int32,
+        torch.int32: torch.int32,
+        torch.int64: torch.int64,
+        torch.bool: torch.int32,
+    },
+    torch.int64: {
+        torch.float16: torch.float64,
+        torch.float32: torch.float64,
+        torch.float64: torch.float64,
+        torch.complex64: torch.complex128,
+        torch.complex128: torch.complex128,
+        torch.uint8: torch.int64,
+        torch.uint16: torch.int64,
+        torch.uint32: torch.int64,
+        torch.uint64: torch.float64,
+        torch.int8: torch.int64,
+        torch.int16: torch.int64,
+        torch.int32: torch.int64,
+        torch.int64: torch.int64,
+        torch.bool: torch.int64,
+    },
+    torch.bool: {
+        torch.float16: torch.float16,
+        torch.float32: torch.float32,
+        torch.float64: torch.float64,
+        torch.complex64: torch.complex64,
+        torch.complex128: torch.complex128,
+        torch.uint8: torch.uint8,
+        torch.uint16: torch.uint16,
+        torch.uint32: torch.uint32,
+        torch.uint64: torch.uint64,
+        torch.int8: torch.int8,
+        torch.int16: torch.int16,
+        torch.int32: torch.int32,
+        torch.int64: torch.int64,
+        torch.bool: torch.bool,
+    },
+}

.venv/lib/python3.12/site-packages/torch/_numpy/_dtypes.py

@@ -0,0 +1,470 @@
+"""Define analogs of numpy dtypes supported by pytorch.
+Define the scalar types and supported dtypes and numpy <--> torch dtype mappings.
+"""
+
+from __future__ import annotations
+
+import builtins
+from typing import TYPE_CHECKING, TypeGuard, TypeVar
+
+import torch
+
+from . import _dtypes_impl
+
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from ._ndarray import ndarray
+
+
+_T = TypeVar("_T")
+
+
+# ### Scalar types ###
+
+
+class generic:
+    name = "generic"
+    # Concrete scalar types below set these; declared here so the dtype machinery
+    # can read them off any scalar type.
+    typecode: str
+    torch_dtype: torch.dtype
+
+    def __new__(cls, value: object) -> ndarray:
+        # NumPy scalars are modelled as 0-D arrays
+        # so a call to np.float32(4) produces a 0-D array.
+
+        from ._ndarray import asarray, ndarray
+
+        if isinstance(value, str) and value in ["inf", "nan"]:
+            value = {"inf": torch.inf, "nan": torch.nan}[value]
+
+        if isinstance(value, ndarray):
+            return value.astype(cls)
+        else:
+            return asarray(value, dtype=cls)
+
+
+##################
+# abstract types #
+##################
+
+
+class number(generic):
+    name = "number"
+
+
+class integer(number):
+    name = "integer"
+
+
+class inexact(number):
+    name = "inexact"
+
+
+class signedinteger(integer):
+    name = "signedinteger"
+
+
+class unsignedinteger(integer):
+    name = "unsignedinteger"
+
+
+class floating(inexact):
+    name = "floating"
+
+
+class complexfloating(inexact):
+    name = "complexfloating"
+
+
+_abstract_dtypes = [
+    "generic",
+    "number",
+    "integer",
+    "signedinteger",
+    "unsignedinteger",
+    "inexact",
+    "floating",
+    "complexfloating",
+]
+
+# ##### concrete types
+
+# signed integers
+
+
+class int8(signedinteger):
+    name = "int8"
+    typecode = "b"
+    torch_dtype = torch.int8
+
+
+class int16(signedinteger):
+    name = "int16"
+    typecode = "h"
+    torch_dtype = torch.int16
+
+
+class int32(signedinteger):
+    name = "int32"
+    typecode = "i"
+    torch_dtype = torch.int32
+
+
+class int64(signedinteger):
+    name = "int64"
+    typecode = "l"
+    torch_dtype = torch.int64
+
+
+# unsigned integers
+
+
+class uint8(unsignedinteger):
+    name = "uint8"
+    typecode = "B"
+    torch_dtype = torch.uint8
+
+
+class uint16(unsignedinteger):
+    name = "uint16"
+    typecode = "H"
+    torch_dtype = torch.uint16
+
+
+class uint32(signedinteger):
+    name = "uint32"
+    typecode = "I"
+    torch_dtype = torch.uint32
+
+
+class uint64(signedinteger):
+    name = "uint64"
+    typecode = "L"
+    torch_dtype = torch.uint64
+
+
+# floating point
+
+
+class float16(floating):
+    name = "float16"
+    typecode = "e"
+    torch_dtype = torch.float16
+
+
+class float32(floating):
+    name = "float32"
+    typecode = "f"
+    torch_dtype = torch.float32
+
+
+class float64(floating):
+    name = "float64"
+    typecode = "d"
+    torch_dtype = torch.float64
+
+
+class complex64(complexfloating):
+    name = "complex64"
+    typecode = "F"
+    torch_dtype = torch.complex64
+
+
+class complex128(complexfloating):
+    name = "complex128"
+    typecode = "D"
+    torch_dtype = torch.complex128
+
+
+class bool_(generic):
+    name = "bool_"
+    typecode = "?"
+    torch_dtype = torch.bool
+
+
+# name aliases
+_name_aliases = {
+    "intp": int64,
+    "int_": int64,
+    "intc": int32,
+    "byte": int8,
+    "short": int16,
+    "longlong": int64,  # XXX: is this correct?
+    "ulonglong": uint64,
+    "ubyte": uint8,
+    "half": float16,
+    "single": float32,
+    "double": float64,
+    "float_": float64,
+    "csingle": complex64,
+    "singlecomplex": complex64,
+    "cdouble": complex128,
+    "cfloat": complex128,
+    "complex_": complex128,
+}
+# We register float_ = float32 and so on
+for name, obj in _name_aliases.items():
+    vars()[name] = obj
+
+
+# Replicate this NumPy-defined way of grouping scalar types,
+# cf tests/core/test_scalar_methods.py
+sctypes = {
+    "int": [int8, int16, int32, int64],
+    "uint": [uint8, uint16, uint32, uint64],
+    "float": [float16, float32, float64],
+    "complex": [complex64, complex128],
+    "others": [bool_],
+}
+
+
+# Support mappings/functions
+
+_names = {st.name: st for cat in sctypes for st in sctypes[cat]}
+_typecodes = {st.typecode: st for cat in sctypes for st in sctypes[cat]}
+_torch_dtypes = {st.torch_dtype: st for cat in sctypes for st in sctypes[cat]}
+
+
+_aliases = {
+    "u1": uint8,
+    "i1": int8,
+    "i2": int16,
+    "i4": int32,
+    "i8": int64,
+    "b": int8,  # XXX: srsly?
+    "f2": float16,
+    "f4": float32,
+    "f8": float64,
+    "c8": complex64,
+    "c16": complex128,
+    # numpy-specific trailing underscore
+    "bool_": bool_,
+}
+
+
+_python_types = {
+    int: int64,
+    float: float64,
+    complex: complex128,
+    builtins.bool: bool_,
+    # also allow stringified names of python types
+    int.__name__: int64,
+    float.__name__: float64,
+    complex.__name__: complex128,
+    builtins.bool.__name__: bool_,
+}
+
+
+def sctype_from_string(s: object) -> type[generic]:
+    """Normalize a string value: a type 'name' or a typecode or a width alias."""
+    if s in _names:
+        return _names[s]
+    if s in _name_aliases:
+        return _name_aliases[s]
+    if s in _typecodes:
+        return _typecodes[s]
+    if s in _aliases:
+        return _aliases[s]
+    if s in _python_types:
+        return _python_types[s]
+    raise TypeError(f"data type {s!r} not understood")
+
+
+def sctype_from_torch_dtype(torch_dtype: torch.dtype) -> type[generic]:
+    return _torch_dtypes[torch_dtype]
+
+
+# ### DTypes. ###
+
+
+def dtype(arg: object) -> DType:
+    if arg is None:
+        arg = _dtypes_impl.default_dtypes().float_dtype
+    return DType(arg)
+
+
+class DType:
+    _scalar_type: type[generic]
+
+    def __init__(self, arg: object) -> None:
+        # a pytorch object?
+        if isinstance(arg, torch.dtype):
+            sctype = _torch_dtypes[arg]
+        elif isinstance(arg, torch.Tensor):
+            sctype = _torch_dtypes[arg.dtype]
+        # a scalar type?
+        elif issubclass_(arg, generic):
+            sctype = arg
+        # a dtype already?
+        elif isinstance(arg, DType):
+            sctype = arg._scalar_type
+        # a has a right attribute?
+        elif hasattr(arg, "dtype"):
+            sctype = arg.dtype._scalar_type
+        else:
+            sctype = sctype_from_string(arg)
+        self._scalar_type = sctype
+
+    @property
+    def name(self) -> str:
+        return self._scalar_type.name
+
+    @property
+    def type(self) -> type[generic]:
+        return self._scalar_type
+
+    @property
+    def kind(self) -> str:
+        # https://numpy.org/doc/stable/reference/generated/numpy.dtype.kind.html
+        return _torch_dtypes[self.torch_dtype].name[0]
+
+    @property
+    def typecode(self) -> str:
+        return self._scalar_type.typecode
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, DType):
+            return self._scalar_type == other._scalar_type
+        try:
+            other_instance = DType(other)
+        except TypeError:
+            return False
+        return self._scalar_type == other_instance._scalar_type
+
+    @property
+    def torch_dtype(self) -> torch.dtype:
+        return self._scalar_type.torch_dtype
+
+    def __hash__(self) -> int:
+        return hash(self._scalar_type.name)
+
+    def __repr__(self) -> str:
+        return f'dtype("{self.name}")'
+
+    __str__ = __repr__
+
+    @property
+    def itemsize(self) -> int:
+        elem = self.type(1)
+        return elem.tensor.element_size()
+
+    def __getstate__(self) -> builtins.type[generic]:
+        return self._scalar_type
+
+    def __setstate__(self, value: builtins.type[generic]) -> None:
+        self._scalar_type = value
+
+
+typecodes = {
+    "All": "efdFDBbhil?",
+    "AllFloat": "efdFD",
+    "AllInteger": "Bbhil",
+    "Integer": "bhil",
+    "UnsignedInteger": "B",
+    "Float": "efd",
+    "Complex": "FD",
+}
+
+
+# ### Defaults and dtype discovery
+
+
+def set_default_dtype(
+    fp_dtype: object = "numpy", int_dtype: object = "numpy"
+) -> Callable[[], _dtypes_impl.DefaultDTypes]:
+    """Set the (global) defaults for fp, complex, and int dtypes.
+
+    The complex dtype is inferred from the float (fp) dtype. It has
+    a width at least twice the width of the float dtype,
+    i.e., it's complex128 for float64 and complex64 for float32.
+
+    Parameters
+    ----------
+    fp_dtype
+        Allowed values are "numpy", "pytorch" or dtype_like things which
+        can be converted into a DType instance.
+        Default is "numpy" (i.e. float64).
+    int_dtype
+        Allowed values are "numpy", "pytorch" or dtype_like things which
+        can be converted into a DType instance.
+        Default is "numpy" (i.e. int64).
+
+    Returns
+    -------
+    The old default dtype state: a namedtuple with attributes ``float_dtype``,
+    ``complex_dtypes`` and ``int_dtype``. These attributes store *pytorch*
+    dtypes.
+
+    Notes
+    ------------
+    This function has a side effect: it sets the global state with the provided dtypes.
+
+    The complex dtype has bit width of at least twice the width of the float
+    dtype, i.e. it's complex128 for float64 and complex64 for float32.
+
+    """
+    if fp_dtype not in ["numpy", "pytorch"]:
+        fp_dtype = dtype(fp_dtype).torch_dtype
+    if int_dtype not in ["numpy", "pytorch"]:
+        int_dtype = dtype(int_dtype).torch_dtype
+
+    if fp_dtype == "numpy":
+        float_dtype = torch.float64
+    elif fp_dtype == "pytorch":
+        float_dtype = torch.float32
+    else:
+        float_dtype = fp_dtype
+
+    complex_dtype = {
+        torch.float64: torch.complex128,
+        torch.float32: torch.complex64,
+        torch.float16: torch.complex64,
+    }[float_dtype]
+
+    if int_dtype in ["numpy", "pytorch"]:
+        int_dtype = torch.int64
+
+    new_defaults = _dtypes_impl.DefaultDTypes(
+        float_dtype=float_dtype, complex_dtype=complex_dtype, int_dtype=int_dtype
+    )
+
+    # set the new global state and return the old state
+    old_defaults = _dtypes_impl.default_dtypes
+    # pyrefly: ignore[bad-assignment]  # TODO
+    _dtypes_impl._default_dtypes = new_defaults
+    return old_defaults
+
+
+def issubclass_(arg: object, klass: type[_T]) -> TypeGuard[type[_T]]:
+    # issubclass() raises TypeError if arg is not a class; guard explicitly so a
+    # non-class arg returns False (and narrows arg to type[_T] on success).
+    return isinstance(arg, type) and issubclass(arg, klass)
+
+
+def issubdtype(arg1: object, arg2: object) -> bool:
+    # cf https://github.com/numpy/numpy/blob/v1.24.0/numpy/core/numerictypes.py#L356-L420
+
+    # We also accept strings even if NumPy doesn't as dtypes are serialized as their
+    # string representation in dynamo's graph
+    def str_to_abstract(t: object) -> object:
+        if isinstance(t, str) and t in _abstract_dtypes:
+            return globals()[t]
+        return t
+
+    arg1 = str_to_abstract(arg1)
+    arg2 = str_to_abstract(arg2)
+
+    if not issubclass_(arg1, generic):
+        arg1 = dtype(arg1).type
+    if not issubclass_(arg2, generic):
+        arg2 = dtype(arg2).type
+    return issubclass(arg1, arg2)
+
+
+__all__ = ["dtype", "DType", "typecodes", "issubdtype", "set_default_dtype", "sctypes"]
+__all__ += list(_names.keys())
+__all__ += list(_name_aliases.keys())
+__all__ += _abstract_dtypes  # noqa: PLE0605

.venv/lib/python3.12/site-packages/torch/_numpy/_dtypes_impl.py

@@ -0,0 +1,230 @@
+# mypy: ignore-errors
+
+"""Dtypes/scalar type implementations with torch dtypes.
+
+Here `dtype` is always a torch.dtype, this module knows nothing about
+scalar types, wrapper dtypes or anything like that. PyTorch only.
+"""
+
+from collections import namedtuple
+
+import torch
+
+
+# defaults : mimic NumPy, allow user control
+DefaultDTypes = namedtuple(
+    "DefaultDTypes", ["float_dtype", "complex_dtype", "int_dtype"]
+)
+
+# a global state
+# We set it the first time we call default_dtypes() to avoid importing
+# torch._dynamo.config and create a circular reference
+_default_dtypes = None
+
+
+def default_dtypes():
+    global _default_dtypes
+    if _default_dtypes is None:
+        import torch._dynamo.config as config
+
+        _default_dtypes = DefaultDTypes(
+            float_dtype=getattr(torch, config.numpy_default_float),
+            complex_dtype=getattr(torch, config.numpy_default_complex),
+            int_dtype=getattr(torch, config.numpy_default_int),
+        )
+        if not isinstance(_default_dtypes.float_dtype, torch.dtype):
+            raise AssertionError(
+                f"float_dtype must be a torch.dtype, got {type(_default_dtypes.float_dtype)}"
+            )
+        if not isinstance(_default_dtypes.complex_dtype, torch.dtype):
+            raise AssertionError(
+                f"complex_dtype must be a torch.dtype, got {type(_default_dtypes.complex_dtype)}"
+            )
+        if not isinstance(_default_dtypes.int_dtype, torch.dtype):
+            raise AssertionError(
+                f"int_dtype must be a torch.dtype, got {type(_default_dtypes.int_dtype)}"
+            )
+    return _default_dtypes
+
+
+def get_default_dtype_for(dtype):
+    """Default scalar type given sctype category."""
+    if dtype == torch.bool:
+        return dtype
+    if dtype.is_complex:
+        return default_dtypes().complex_dtype
+    if dtype.is_floating_point:
+        return default_dtypes().float_dtype
+    # else, it must be (some) integer
+    return default_dtypes().int_dtype
+
+
+from . import _casting_dicts as _cd
+
+
+def can_cast_impl(from_torch_dtype, to_torch_dtype, casting):
+    return _cd._can_cast_dict[casting][from_torch_dtype][to_torch_dtype]
+
+
+def result_type_impl(*tensors):
+    # NB: torch dtypes here
+    dtyp = tensors[0].dtype
+    if len(tensors) == 1:
+        return dtyp
+
+    for curr in tensors[1:]:
+        dtyp = _cd._result_type_dict[dtyp][curr.dtype]
+
+    return dtyp
+
+
+def python_type_for_torch(dtyp):
+    """Get a python scalar type a torch dtype"""
+    if dtyp.is_floating_point:
+        typ = float
+    elif dtyp.is_complex:
+        typ = complex
+    elif dtyp == torch.bool:
+        typ = bool
+    else:
+        typ = int
+    return typ
+
+
+# ### NEP 50 helpers ###
+
+_SCALAR_TYPES = (int, bool, float, complex)
+
+_SCALAR_AND_SYMBOLIC_TYPES = (
+    *_SCALAR_TYPES,
+    torch.SymInt,
+    torch.SymFloat,
+    torch.SymBool,
+)
+
+_NEP50_FUNCS_TENSOR_ONLY = (
+    "minimum",
+    "maximum",
+    "logaddexp",
+    "logaddexp2",
+    "lcm",
+    "gcd",
+    "hypot",
+    "heaviside",
+    "fmod",
+    "fmin",
+    "fmax",
+    "copysign",
+    "arctan2",
+)
+
+
+def is_scalar(x):
+    return isinstance(x, _SCALAR_TYPES)
+
+
+def is_scalar_or_symbolic(x):
+    return isinstance(x, _SCALAR_AND_SYMBOLIC_TYPES)
+
+
+def _dtype_for_scalar(py_type):
+    return {
+        bool: torch.bool,
+        torch.SymBool: torch.bool,
+        int: torch.int64,
+        torch.SymInt: torch.int64,
+        float: torch.float64,
+        torch.SymFloat: torch.float64,
+        complex: torch.complex128,
+    }[py_type]
+
+
+def _dtype_for_scalar_or_tensor(x):
+    return x.dtype if isinstance(x, torch.Tensor) else _dtype_for_scalar(type(x))
+
+
+def is_float_or_fp_tensor(x):
+    return _dtype_for_scalar_or_tensor(x).is_floating_point
+
+
+def is_complex_or_complex_tensor(x):
+    return _dtype_for_scalar_or_tensor(x).is_complex
+
+
+def _category(dtype):
+    return {
+        torch.bool: 0,
+        torch.SymBool: 0,
+        # int
+        torch.uint8: 1,
+        torch.int8: 1,
+        torch.int16: 1,
+        torch.int32: 1,
+        torch.int64: 1,
+        torch.SymInt: 1,
+        # float
+        torch.float16: 2,
+        torch.float32: 2,
+        torch.float64: 2,
+        torch.SymFloat: 2,
+        # complex
+        torch.complex64: 3,
+        torch.complex128: 3,
+    }[dtype]
+
+
+def nep50_to_tensors(x1, x2, handle_weaks, function_name):
+    """If either of inputs is a python scalar, type-promote with NEP 50."""
+
+    def to_tensor(scalar, dtype=None):
+        if dtype is None:
+            dtype = _dtype_for_scalar(type(scalar))
+            dtype = get_default_dtype_for(dtype)
+        return torch.as_tensor(scalar, dtype=dtype)
+
+    x1_is_weak = not isinstance(x1, torch.Tensor)
+    x2_is_weak = not isinstance(x2, torch.Tensor)
+    if not handle_weaks or (x1_is_weak and x2_is_weak):
+        x1 = to_tensor(x1) if x1_is_weak else x1
+        x2 = to_tensor(x2) if x2_is_weak else x2
+        return x1, x2
+
+    # scalar <op> tensor: NEP 50
+    if x1_is_weak == x2_is_weak:
+        raise AssertionError(
+            f"Expected exactly one weak type, got x1_is_weak={x1_is_weak}, x2_is_weak={x2_is_weak}"
+        )
+
+    weak, not_weak = (x1, x2) if x1_is_weak else (x2, x1)
+
+    # find the dtype for the weak's type
+    weak_dtype = _dtype_for_scalar(type(weak))
+
+    cat_weak = _category(weak_dtype)
+    cat_not_weak = _category(not_weak.dtype)
+
+    dt = not_weak.dtype if cat_weak <= cat_not_weak else None
+
+    # special-case complex + float32
+    if weak_dtype.is_complex and not_weak.dtype == torch.float32:
+        dt = torch.complex64
+
+    # detect overflows: in PyTorch, uint8(-1) wraps around to 255,
+    # while NEP50 mandates an exception.
+    #
+    # Note that we only check if each element of the binop overflows,
+    # not the result. Consider, e.g. `uint8(100) + 200`. Operands are OK
+    # in uint8, but the result overflows and wrap around 255.
+    # Numpy emits a RuntimeWarning, PyTorch does not, and we do not either.
+    if cat_weak == 1 and cat_not_weak == 1:
+        # integers
+        iinfo = torch.iinfo(not_weak.dtype)
+        if not (iinfo.min <= weak <= iinfo.max):
+            raise OverflowError(
+                f"Python integer {weak} out of bounds for {not_weak.dtype}"
+            )
+    if weak_dtype != dt or function_name in _NEP50_FUNCS_TENSOR_ONLY:
+        # finally, can make `weak` into a 0D tensor, if both parameters are required to be tensor.
+        weak = to_tensor(weak, dt)
+
+    return (weak, not_weak) if x1_is_weak else (not_weak, weak)

.venv/lib/python3.12/site-packages/torch/_numpy/_funcs.py

@@ -0,0 +1,76 @@
+# mypy: ignore-errors
+
+import inspect
+import itertools
+
+from . import _funcs_impl, _reductions_impl
+from ._normalizations import normalizer
+
+
+# _funcs_impl.py contains functions which mimic NumPy's eponymous equivalents,
+# and consume/return PyTorch tensors/dtypes.
+# They are also type annotated.
+# Pull these functions from _funcs_impl and decorate them with @normalizer, which
+# - Converts any input `np.ndarray`, `torch._numpy.ndarray`, list of lists, Python scalars, etc into a `torch.Tensor`.
+# - Maps NumPy dtypes to PyTorch dtypes
+# - If the input to the `axis` kwarg is an ndarray, it maps it into a tuple
+# - Implements the semantics for the `out=` arg
+# - Wraps back the outputs into `torch._numpy.ndarrays`
+
+
+def _public_functions(mod):
+    def is_public_function(f):
+        return inspect.isfunction(f) and not f.__name__.startswith("_")
+
+    return inspect.getmembers(mod, is_public_function)
+
+
+# We fill in __all__ in the loop below
+__all__ = []
+
+# decorate implementer functions with argument normalizers and export to the top namespace
+for name, func in itertools.chain(
+    _public_functions(_funcs_impl), _public_functions(_reductions_impl)
+):
+    if name in ["percentile", "quantile", "median"]:
+        decorated = normalizer(func, promote_scalar_result=True)
+    elif name == "einsum":
+        # normalized manually
+        decorated = func
+    else:
+        decorated = normalizer(func)
+
+    decorated.__qualname__ = name
+    decorated.__name__ = name
+    vars()[name] = decorated
+    __all__.append(name)
+
+
+"""
+Vendored objects from numpy.lib.index_tricks
+"""
+
+
+class IndexExpression:
+    """
+    Written by Konrad Hinsen <hinsen@cnrs-orleans.fr>
+    last revision: 1999-7-23
+
+    Cosmetic changes by T. Oliphant 2001
+    """
+
+    def __init__(self, maketuple):
+        self.maketuple = maketuple
+
+    def __getitem__(self, item):
+        if self.maketuple and not isinstance(item, tuple):
+            return (item,)
+        else:
+            return item
+
+
+index_exp = IndexExpression(maketuple=True)
+s_ = IndexExpression(maketuple=False)
+
+
+__all__ += ["index_exp", "s_"]

.venv/lib/python3.12/site-packages/torch/_numpy/_funcs_impl.py

@@ -0,0 +1,2064 @@
+# mypy: ignore-errors
+
+"""A thin pytorch / numpy compat layer.
+
+Things imported from here have numpy-compatible signatures but operate on
+pytorch tensors.
+"""
+
+# Contents of this module ends up in the main namespace via _funcs.py
+# where type annotations are used in conjunction with the @normalizer decorator.
+from __future__ import annotations
+
+import builtins
+import itertools
+import operator
+from typing import TYPE_CHECKING
+
+import torch
+
+from . import _dtypes_impl, _util
+
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    from ._normalizations import (
+        ArrayLike,
+        ArrayLikeOrScalar,
+        CastingModes,
+        DTypeLike,
+        NDArray,
+        NotImplementedType,
+        OutArray,
+    )
+
+
+def copy(
+    a: ArrayLike, order: NotImplementedType = "K", subok: NotImplementedType = False
+):
+    return a.clone()
+
+
+def copyto(
+    dst: NDArray,
+    src: ArrayLike,
+    casting: CastingModes | None = "same_kind",
+    where: NotImplementedType = None,
+):
+    (src,) = _util.typecast_tensors((src,), dst.dtype, casting=casting)
+    dst.copy_(src)
+
+
+def atleast_1d(*arys: ArrayLike):
+    res = torch.atleast_1d(*arys)
+    if isinstance(res, tuple):
+        return list(res)
+    else:
+        return res
+
+
+def atleast_2d(*arys: ArrayLike):
+    res = torch.atleast_2d(*arys)
+    if isinstance(res, tuple):
+        return list(res)
+    else:
+        return res
+
+
+def atleast_3d(*arys: ArrayLike):
+    res = torch.atleast_3d(*arys)
+    if isinstance(res, tuple):
+        return list(res)
+    else:
+        return res
+
+
+def _concat_check(tup, dtype, out):
+    if tup == ():
+        raise ValueError("need at least one array to concatenate")
+
+    """Check inputs in concatenate et al."""
+    if out is not None and dtype is not None:
+        # mimic numpy
+        raise TypeError(
+            "concatenate() only takes `out` or `dtype` as an "
+            "argument, but both were provided."
+        )
+
+
+def _concat_cast_helper(tensors, out=None, dtype=None, casting="same_kind"):
+    """Figure out dtypes, cast if necessary."""
+
+    if out is not None or dtype is not None:
+        # figure out the type of the inputs and outputs
+        out_dtype = out.dtype.torch_dtype if dtype is None else dtype
+    else:
+        out_dtype = _dtypes_impl.result_type_impl(*tensors)
+
+    # cast input arrays if necessary; do not broadcast them against `out`
+    tensors = _util.typecast_tensors(tensors, out_dtype, casting)
+
+    return tensors
+
+
+def _concatenate(
+    tensors, axis=0, out=None, dtype=None, casting: CastingModes | None = "same_kind"
+):
+    # pure torch implementation, used below and in cov/corrcoef below
+    tensors, axis = _util.axis_none_flatten(*tensors, axis=axis)
+    tensors = _concat_cast_helper(tensors, out, dtype, casting)
+    return torch.cat(tensors, axis)
+
+
+def concatenate(
+    ar_tuple: Sequence[ArrayLike],
+    axis=0,
+    out: OutArray | None = None,
+    dtype: DTypeLike | None = None,
+    casting: CastingModes | None = "same_kind",
+):
+    _concat_check(ar_tuple, dtype, out=out)
+    result = _concatenate(ar_tuple, axis=axis, out=out, dtype=dtype, casting=casting)
+    return result
+
+
+def vstack(
+    tup: Sequence[ArrayLike],
+    *,
+    dtype: DTypeLike | None = None,
+    casting: CastingModes | None = "same_kind",
+):
+    _concat_check(tup, dtype, out=None)
+    tensors = _concat_cast_helper(tup, dtype=dtype, casting=casting)
+    return torch.vstack(tensors)
+
+
+row_stack = vstack
+
+
+def hstack(
+    tup: Sequence[ArrayLike],
+    *,
+    dtype: DTypeLike | None = None,
+    casting: CastingModes | None = "same_kind",
+):
+    _concat_check(tup, dtype, out=None)
+    tensors = _concat_cast_helper(tup, dtype=dtype, casting=casting)
+    return torch.hstack(tensors)
+
+
+def dstack(
+    tup: Sequence[ArrayLike],
+    *,
+    dtype: DTypeLike | None = None,
+    casting: CastingModes | None = "same_kind",
+):
+    # XXX: in numpy 1.24 dstack does not have dtype and casting keywords
+    # but {h,v}stack do.  Hence add them here for consistency.
+    _concat_check(tup, dtype, out=None)
+    tensors = _concat_cast_helper(tup, dtype=dtype, casting=casting)
+    return torch.dstack(tensors)
+
+
+def column_stack(
+    tup: Sequence[ArrayLike],
+    *,
+    dtype: DTypeLike | None = None,
+    casting: CastingModes | None = "same_kind",
+):
+    # XXX: in numpy 1.24 column_stack does not have dtype and casting keywords
+    # but row_stack does. (because row_stack is an alias for vstack, really).
+    # Hence add these keywords here for consistency.
+    _concat_check(tup, dtype, out=None)
+    tensors = _concat_cast_helper(tup, dtype=dtype, casting=casting)
+    return torch.column_stack(tensors)
+
+
+def stack(
+    arrays: Sequence[ArrayLike],
+    axis=0,
+    out: OutArray | None = None,
+    *,
+    dtype: DTypeLike | None = None,
+    casting: CastingModes | None = "same_kind",
+):
+    _concat_check(arrays, dtype, out=out)
+
+    tensors = _concat_cast_helper(arrays, dtype=dtype, casting=casting)
+    result_ndim = tensors[0].ndim + 1
+    axis = _util.normalize_axis_index(axis, result_ndim)
+    return torch.stack(tensors, axis=axis)
+
+
+def append(arr: ArrayLike, values: ArrayLike, axis=None):
+    if axis is None:
+        if arr.ndim != 1:
+            arr = arr.flatten()
+        values = values.flatten()
+        axis = arr.ndim - 1
+    return _concatenate((arr, values), axis=axis)
+
+
+# ### split ###
+
+
+def _split_helper(tensor, indices_or_sections, axis, strict=False):
+    if isinstance(indices_or_sections, int):
+        return _split_helper_int(tensor, indices_or_sections, axis, strict)
+    elif isinstance(indices_or_sections, (list, tuple)):
+        # NB: drop split=..., it only applies to split_helper_int
+        return _split_helper_list(tensor, list(indices_or_sections), axis)
+    else:
+        raise TypeError(f"split_helper: {type(indices_or_sections)}")
+
+
+def _split_helper_int(tensor, indices_or_sections, axis, strict=False):
+    if not isinstance(indices_or_sections, int):
+        raise NotImplementedError("split: indices_or_sections")
+
+    axis = _util.normalize_axis_index(axis, tensor.ndim)
+
+    # numpy: l%n chunks of size (l//n + 1), the rest are sized l//n
+    l, n = tensor.shape[axis], indices_or_sections
+
+    if n <= 0:
+        raise ValueError
+
+    if l % n == 0:
+        num, sz = n, l // n
+        lst = [sz] * num
+    else:
+        if strict:
+            raise ValueError("array split does not result in an equal division")
+
+        num, sz = l % n, l // n + 1
+        lst = [sz] * num
+
+    lst += [sz - 1] * (n - num)
+
+    return torch.split(tensor, lst, axis)
+
+
+def _split_helper_list(tensor, indices_or_sections, axis):
+    if not isinstance(indices_or_sections, list):
+        raise NotImplementedError("split: indices_or_sections: list")
+    # numpy expects indices, while torch expects lengths of sections
+    # also, numpy appends zero-size arrays for indices above the shape[axis]
+    lst = [x for x in indices_or_sections if x <= tensor.shape[axis]]
+    num_extra = len(indices_or_sections) - len(lst)
+
+    lst.append(tensor.shape[axis])
+    lst = [
+        lst[0],
+    ] + [a - b for a, b in zip(lst[1:], lst[:-1])]
+    lst += [0] * num_extra
+
+    return torch.split(tensor, lst, axis)
+
+
+def array_split(ary: ArrayLike, indices_or_sections, axis=0):
+    return _split_helper(ary, indices_or_sections, axis)
+
+
+def split(ary: ArrayLike, indices_or_sections, axis=0):
+    return _split_helper(ary, indices_or_sections, axis, strict=True)
+
+
+def hsplit(ary: ArrayLike, indices_or_sections):
+    if ary.ndim == 0:
+        raise ValueError("hsplit only works on arrays of 1 or more dimensions")
+    axis = 1 if ary.ndim > 1 else 0
+    return _split_helper(ary, indices_or_sections, axis, strict=True)
+
+
+def vsplit(ary: ArrayLike, indices_or_sections):
+    if ary.ndim < 2:
+        raise ValueError("vsplit only works on arrays of 2 or more dimensions")
+    return _split_helper(ary, indices_or_sections, 0, strict=True)
+
+
+def dsplit(ary: ArrayLike, indices_or_sections):
+    if ary.ndim < 3:
+        raise ValueError("dsplit only works on arrays of 3 or more dimensions")
+    return _split_helper(ary, indices_or_sections, 2, strict=True)
+
+
+def kron(a: ArrayLike, b: ArrayLike):
+    return torch.kron(a, b)
+
+
+def vander(x: ArrayLike, N=None, increasing=False):
+    return torch.vander(x, N, increasing)
+
+
+# ### linspace, geomspace, logspace and arange ###
+
+
+def linspace(
+    start: ArrayLike,
+    stop: ArrayLike,
+    num=50,
+    endpoint=True,
+    retstep=False,
+    dtype: DTypeLike | None = None,
+    axis=0,
+):
+    if axis != 0 or retstep or not endpoint:
+        raise NotImplementedError
+    if dtype is None:
+        dtype = _dtypes_impl.default_dtypes().float_dtype
+    # XXX: raises TypeError if start or stop are not scalars
+    return torch.linspace(start, stop, num, dtype=dtype)
+
+
+def geomspace(
+    start: ArrayLike,
+    stop: ArrayLike,
+    num=50,
+    endpoint=True,
+    dtype: DTypeLike | None = None,
+    axis=0,
+):
+    if axis != 0 or not endpoint:
+        raise NotImplementedError
+    base = torch.pow(stop / start, 1.0 / (num - 1))
+    logbase = torch.log(base)
+    return torch.logspace(
+        torch.log(start) / logbase,
+        torch.log(stop) / logbase,
+        num,
+        base=base,
+    )
+
+
+def logspace(
+    start,
+    stop,
+    num=50,
+    endpoint=True,
+    base=10.0,
+    dtype: DTypeLike | None = None,
+    axis=0,
+):
+    if axis != 0 or not endpoint:
+        raise NotImplementedError
+    return torch.logspace(start, stop, num, base=base, dtype=dtype)
+
+
+def arange(
+    start: ArrayLikeOrScalar | None = None,
+    stop: ArrayLikeOrScalar | None = None,
+    step: ArrayLikeOrScalar | None = 1,
+    dtype: DTypeLike | None = None,
+    *,
+    like: NotImplementedType = None,
+):
+    if step == 0:
+        raise ZeroDivisionError
+    if stop is None and start is None:
+        raise TypeError
+    if stop is None:
+        # XXX: this breaks if start is passed as a kwarg:
+        # arange(start=4) should raise (no stop) but doesn't
+        start, stop = 0, start
+    if start is None:
+        start = 0
+
+    # the dtype of the result
+    if dtype is None:
+        dtype = (
+            _dtypes_impl.default_dtypes().float_dtype
+            if any(_dtypes_impl.is_float_or_fp_tensor(x) for x in (start, stop, step))
+            else _dtypes_impl.default_dtypes().int_dtype
+        )
+    work_dtype = torch.float64 if dtype.is_complex else dtype
+
+    # RuntimeError: "lt_cpu" not implemented for 'ComplexFloat'. Fall back to eager.
+    if any(_dtypes_impl.is_complex_or_complex_tensor(x) for x in (start, stop, step)):
+        raise NotImplementedError
+
+    if (step > 0 and start > stop) or (step < 0 and start < stop):
+        # empty range
+        return torch.empty(0, dtype=dtype)
+
+    result = torch.arange(start, stop, step, dtype=work_dtype)
+    result = _util.cast_if_needed(result, dtype)
+    return result
+
+
+# ### zeros/ones/empty/full ###
+
+
+def empty(
+    shape,
+    dtype: DTypeLike | None = None,
+    order: NotImplementedType = "C",
+    *,
+    like: NotImplementedType = None,
+):
+    if dtype is None:
+        dtype = _dtypes_impl.default_dtypes().float_dtype
+    return torch.empty(shape, dtype=dtype)
+
+
+# NB: *_like functions deliberately deviate from numpy: it has subok=True
+# as the default; we set subok=False and raise on anything else.
+
+
+def empty_like(
+    prototype: ArrayLike,
+    dtype: DTypeLike | None = None,
+    order: NotImplementedType = "K",
+    subok: NotImplementedType = False,
+    shape=None,
+):
+    result = torch.empty_like(prototype, dtype=dtype)
+    if shape is not None:
+        result = result.reshape(shape)
+    return result
+
+
+def full(
+    shape,
+    fill_value: ArrayLike,
+    dtype: DTypeLike | None = None,
+    order: NotImplementedType = "C",
+    *,
+    like: NotImplementedType = None,
+):
+    if isinstance(shape, int):
+        shape = (shape,)
+    if dtype is None:
+        dtype = fill_value.dtype
+    if not isinstance(shape, (tuple, list)):
+        shape = (shape,)
+    return torch.full(shape, fill_value, dtype=dtype)
+
+
+def full_like(
+    a: ArrayLike,
+    fill_value,
+    dtype: DTypeLike | None = None,
+    order: NotImplementedType = "K",
+    subok: NotImplementedType = False,
+    shape=None,
+):
+    # XXX: fill_value broadcasts
+    result = torch.full_like(a, fill_value, dtype=dtype)
+    if shape is not None:
+        result = result.reshape(shape)
+    return result
+
+
+def ones(
+    shape,
+    dtype: DTypeLike | None = None,
+    order: NotImplementedType = "C",
+    *,
+    like: NotImplementedType = None,
+):
+    if dtype is None:
+        dtype = _dtypes_impl.default_dtypes().float_dtype
+    return torch.ones(shape, dtype=dtype)
+
+
+def ones_like(
+    a: ArrayLike,
+    dtype: DTypeLike | None = None,
+    order: NotImplementedType = "K",
+    subok: NotImplementedType = False,
+    shape=None,
+):
+    result = torch.ones_like(a, dtype=dtype)
+    if shape is not None:
+        result = result.reshape(shape)
+    return result
+
+
+def zeros(
+    shape,
+    dtype: DTypeLike | None = None,
+    order: NotImplementedType = "C",
+    *,
+    like: NotImplementedType = None,
+):
+    if dtype is None:
+        dtype = _dtypes_impl.default_dtypes().float_dtype
+    return torch.zeros(shape, dtype=dtype)
+
+
+def zeros_like(
+    a: ArrayLike,
+    dtype: DTypeLike | None = None,
+    order: NotImplementedType = "K",
+    subok: NotImplementedType = False,
+    shape=None,
+):
+    result = torch.zeros_like(a, dtype=dtype)
+    if shape is not None:
+        result = result.reshape(shape)
+    return result
+
+
+# ### cov & corrcoef ###
+
+
+def _xy_helper_corrcoef(x_tensor, y_tensor=None, rowvar=True):
+    """Prepare inputs for cov and corrcoef."""
+
+    # https://github.com/numpy/numpy/blob/v1.24.0/numpy/lib/function_base.py#L2636
+    if y_tensor is not None:
+        # make sure x and y are at least 2D
+        ndim_extra = 2 - x_tensor.ndim
+        if ndim_extra > 0:
+            x_tensor = x_tensor.view((1,) * ndim_extra + x_tensor.shape)
+        if not rowvar and x_tensor.shape[0] != 1:
+            x_tensor = x_tensor.mT
+        x_tensor = x_tensor.clone()
+
+        ndim_extra = 2 - y_tensor.ndim
+        if ndim_extra > 0:
+            y_tensor = y_tensor.view((1,) * ndim_extra + y_tensor.shape)
+        if not rowvar and y_tensor.shape[0] != 1:
+            y_tensor = y_tensor.mT
+        y_tensor = y_tensor.clone()
+
+        x_tensor = _concatenate((x_tensor, y_tensor), axis=0)
+
+    return x_tensor
+
+
+def corrcoef(
+    x: ArrayLike,
+    y: ArrayLike | None = None,
+    rowvar=True,
+    bias=None,
+    ddof=None,
+    *,
+    dtype: DTypeLike | None = None,
+):
+    if bias is not None or ddof is not None:
+        # deprecated in NumPy
+        raise NotImplementedError
+    xy_tensor = _xy_helper_corrcoef(x, y, rowvar)
+
+    is_half = (xy_tensor.dtype == torch.float16) and xy_tensor.is_cpu
+    if is_half:
+        # work around torch's "addmm_impl_cpu_" not implemented for 'Half'"
+        dtype = torch.float32
+
+    xy_tensor = _util.cast_if_needed(xy_tensor, dtype)
+    result = torch.corrcoef(xy_tensor)
+
+    if is_half:
+        result = result.to(torch.float16)
+
+    return result
+
+
+def cov(
+    m: ArrayLike,
+    y: ArrayLike | None = None,
+    rowvar=True,
+    bias=False,
+    ddof=None,
+    fweights: ArrayLike | None = None,
+    aweights: ArrayLike | None = None,
+    *,
+    dtype: DTypeLike | None = None,
+):
+    m = _xy_helper_corrcoef(m, y, rowvar)
+
+    if ddof is None:
+        ddof = 1 if bias == 0 else 0
+
+    is_half = (m.dtype == torch.float16) and m.is_cpu
+    if is_half:
+        # work around torch's "addmm_impl_cpu_" not implemented for 'Half'"
+        dtype = torch.float32
+
+    m = _util.cast_if_needed(m, dtype)
+    result = torch.cov(m, correction=ddof, aweights=aweights, fweights=fweights)
+
+    if is_half:
+        result = result.to(torch.float16)
+
+    return result
+
+
+def _conv_corr_impl(a, v, mode):
+    dt = _dtypes_impl.result_type_impl(a, v)
+    a = _util.cast_if_needed(a, dt)
+    v = _util.cast_if_needed(v, dt)
+
+    padding = v.shape[0] - 1 if mode == "full" else mode
+
+    if padding == "same" and v.shape[0] % 2 == 0:
+        # UserWarning: Using padding='same' with even kernel lengths and odd
+        # dilation may require a zero-padded copy of the input be created
+        # (Triggered internally at pytorch/aten/src/ATen/native/Convolution.cpp:1010.)
+        raise NotImplementedError("mode='same' and even-length weights")
+
+    # NumPy only accepts 1D arrays; PyTorch requires 2D inputs and 3D weights
+    aa = a[None, :]
+    vv = v[None, None, :]
+
+    result = torch.nn.functional.conv1d(aa, vv, padding=padding)
+
+    # torch returns a 2D result, numpy returns a 1D array
+    return result[0, :]
+
+
+def convolve(a: ArrayLike, v: ArrayLike, mode="full"):
+    # NumPy: if v is longer than a, the arrays are swapped before computation
+    if a.shape[0] < v.shape[0]:
+        a, v = v, a
+
+    # flip the weights since numpy does and torch does not
+    v = torch.flip(v, (0,))
+
+    return _conv_corr_impl(a, v, mode)
+
+
+def correlate(a: ArrayLike, v: ArrayLike, mode="valid"):
+    v = torch.conj_physical(v)
+    return _conv_corr_impl(a, v, mode)
+
+
+# ### logic & element selection ###
+
+
+def bincount(x: ArrayLike, /, weights: ArrayLike | None = None, minlength=0):
+    if x.numel() == 0:
+        # edge case allowed by numpy
+        x = x.new_empty(0, dtype=int)
+
+    int_dtype = _dtypes_impl.default_dtypes().int_dtype
+    (x,) = _util.typecast_tensors((x,), int_dtype, casting="safe")
+
+    return torch.bincount(x, weights, minlength)
+
+
+def where(
+    condition: ArrayLike,
+    x: ArrayLikeOrScalar | None = None,
+    y: ArrayLikeOrScalar | None = None,
+    /,
+):
+    if (x is None) != (y is None):
+        raise ValueError("either both or neither of x and y should be given")
+
+    if condition.dtype != torch.bool:
+        condition = condition.to(torch.bool)
+
+    if x is None and y is None:
+        result = torch.where(condition)
+    else:
+        result = torch.where(condition, x, y)
+    return result
+
+
+# ###### module-level queries of object properties
+
+
+def ndim(a: ArrayLike):
+    return a.ndim
+
+
+def shape(a: ArrayLike):
+    return tuple(a.shape)
+
+
+def size(a: ArrayLike, axis=None):
+    if axis is None:
+        return a.numel()
+    else:
+        return a.shape[axis]
+
+
+# ###### shape manipulations and indexing
+
+
+def expand_dims(a: ArrayLike, axis):
+    shape = _util.expand_shape(a.shape, axis)
+    return a.view(shape)  # never copies
+
+
+def flip(m: ArrayLike, axis=None):
+    # XXX: semantic difference: np.flip returns a view, torch.flip copies
+    if axis is None:
+        axis = tuple(range(m.ndim))
+    else:
+        axis = _util.normalize_axis_tuple(axis, m.ndim)
+    return torch.flip(m, axis)
+
+
+def flipud(m: ArrayLike):
+    return torch.flipud(m)
+
+
+def fliplr(m: ArrayLike):
+    return torch.fliplr(m)
+
+
+def rot90(m: ArrayLike, k=1, axes=(0, 1)):
+    axes = _util.normalize_axis_tuple(axes, m.ndim)
+    return torch.rot90(m, k, axes)
+
+
+# ### broadcasting and indices ###
+
+
+def broadcast_to(array: ArrayLike, shape, subok: NotImplementedType = False):
+    return torch.broadcast_to(array, size=shape)
+
+
+# This is a function from tuples to tuples, so we just reuse it.  However,
+# dynamo expects its __module__ to be torch._numpy
+def broadcast_shapes(*args):
+    return torch.broadcast_shapes(*args)
+
+
+def broadcast_arrays(*args: ArrayLike, subok: NotImplementedType = False):
+    return torch.broadcast_tensors(*args)
+
+
+def meshgrid(*xi: ArrayLike, copy=True, sparse=False, indexing="xy"):
+    ndim = len(xi)
+
+    if indexing not in ["xy", "ij"]:
+        raise ValueError("Valid values for `indexing` are 'xy' and 'ij'.")
+
+    s0 = (1,) * ndim
+    output = [x.reshape(s0[:i] + (-1,) + s0[i + 1 :]) for i, x in enumerate(xi)]
+
+    if indexing == "xy" and ndim > 1:
+        # switch first and second axis
+        output[0] = output[0].reshape((1, -1) + s0[2:])
+        output[1] = output[1].reshape((-1, 1) + s0[2:])
+
+    if not sparse:
+        # Return the full N-D matrix (not only the 1-D vector)
+        output = torch.broadcast_tensors(*output)
+
+    if copy:
+        output = [x.clone() for x in output]
+
+    return list(output)  # match numpy, return a list
+
+
+def indices(dimensions, dtype: DTypeLike | None = int, sparse=False):
+    # https://github.com/numpy/numpy/blob/v1.24.0/numpy/core/numeric.py#L1691-L1791
+    dimensions = tuple(dimensions)
+    N = len(dimensions)
+    shape = (1,) * N
+    if sparse:
+        res = ()
+    else:
+        res = torch.empty((N,) + dimensions, dtype=dtype)
+    for i, dim in enumerate(dimensions):
+        idx = torch.arange(dim, dtype=dtype).reshape(
+            shape[:i] + (dim,) + shape[i + 1 :]
+        )
+        if sparse:
+            res = res + (idx,)
+        else:
+            res[i] = idx
+    return res
+
+
+# ### tri*-something ###
+
+
+def tril(m: ArrayLike, k=0):
+    return torch.tril(m, k)
+
+
+def triu(m: ArrayLike, k=0):
+    return torch.triu(m, k)
+
+
+def tril_indices(n, k=0, m=None):
+    if m is None:
+        m = n
+    return torch.tril_indices(n, m, offset=k)
+
+
+def triu_indices(n, k=0, m=None):
+    if m is None:
+        m = n
+    return torch.triu_indices(n, m, offset=k)
+
+
+def tril_indices_from(arr: ArrayLike, k=0):
+    if arr.ndim != 2:
+        raise ValueError("input array must be 2-d")
+    # Return a tensor rather than a tuple to avoid a graphbreak
+    return torch.tril_indices(arr.shape[0], arr.shape[1], offset=k)
+
+
+def triu_indices_from(arr: ArrayLike, k=0):
+    if arr.ndim != 2:
+        raise ValueError("input array must be 2-d")
+    # Return a tensor rather than a tuple to avoid a graphbreak
+    return torch.triu_indices(arr.shape[0], arr.shape[1], offset=k)
+
+
+def tri(
+    N,
+    M=None,
+    k=0,
+    dtype: DTypeLike | None = None,
+    *,
+    like: NotImplementedType = None,
+):
+    if M is None:
+        M = N
+    tensor = torch.ones((N, M), dtype=dtype)
+    return torch.tril(tensor, diagonal=k)
+
+
+# ### equality, equivalence, allclose ###
+
+
+def isclose(a: ArrayLike, b: ArrayLike, rtol=1.0e-5, atol=1.0e-8, equal_nan=False):
+    dtype = _dtypes_impl.result_type_impl(a, b)
+    a = _util.cast_if_needed(a, dtype)
+    b = _util.cast_if_needed(b, dtype)
+    return torch.isclose(a, b, rtol=rtol, atol=atol, equal_nan=equal_nan)
+
+
+def allclose(a: ArrayLike, b: ArrayLike, rtol=1e-05, atol=1e-08, equal_nan=False):
+    dtype = _dtypes_impl.result_type_impl(a, b)
+    a = _util.cast_if_needed(a, dtype)
+    b = _util.cast_if_needed(b, dtype)
+    return torch.allclose(a, b, rtol=rtol, atol=atol, equal_nan=equal_nan)
+
+
+def _tensor_equal(a1, a2, equal_nan=False):
+    # Implementation of array_equal/array_equiv.
+    if a1.shape != a2.shape:
+        return False
+    cond = a1 == a2
+    if equal_nan:
+        cond = cond | (torch.isnan(a1) & torch.isnan(a2))
+    return cond.all().item()
+
+
+def array_equal(a1: ArrayLike, a2: ArrayLike, equal_nan=False):
+    return _tensor_equal(a1, a2, equal_nan=equal_nan)
+
+
+def array_equiv(a1: ArrayLike, a2: ArrayLike):
+    # *almost* the same as array_equal: _equiv tries to broadcast, _equal does not
+    try:
+        a1_t, a2_t = torch.broadcast_tensors(a1, a2)
+    except RuntimeError:
+        # failed to broadcast => not equivalent
+        return False
+    return _tensor_equal(a1_t, a2_t)
+
+
+def nan_to_num(
+    x: ArrayLike, copy: NotImplementedType = True, nan=0.0, posinf=None, neginf=None
+):
+    # work around RuntimeError: "nan_to_num" not implemented for 'ComplexDouble'
+    if x.is_complex():
+        re = torch.nan_to_num(x.real, nan=nan, posinf=posinf, neginf=neginf)
+        im = torch.nan_to_num(x.imag, nan=nan, posinf=posinf, neginf=neginf)
+        return re + 1j * im
+    else:
+        return torch.nan_to_num(x, nan=nan, posinf=posinf, neginf=neginf)
+
+
+# ### put/take_along_axis ###
+
+
+def take(
+    a: ArrayLike,
+    indices: ArrayLike,
+    axis=None,
+    out: OutArray | None = None,
+    mode: NotImplementedType = "raise",
+):
+    (a,), axis = _util.axis_none_flatten(a, axis=axis)
+    axis = _util.normalize_axis_index(axis, a.ndim)
+    idx = (slice(None),) * axis + (indices, ...)
+    result = a[idx]
+    return result
+
+
+def take_along_axis(arr: ArrayLike, indices: ArrayLike, axis):
+    (arr,), axis = _util.axis_none_flatten(arr, axis=axis)
+    axis = _util.normalize_axis_index(axis, arr.ndim)
+    return torch.take_along_dim(arr, indices, axis)
+
+
+def put(
+    a: NDArray,
+    indices: ArrayLike,
+    values: ArrayLike,
+    mode: NotImplementedType = "raise",
+):
+    v = values.type(a.dtype)
+    # If indices is larger than v, expand v to at least the size of indices. Any
+    # unnecessary trailing elements are then trimmed.
+    if indices.numel() > v.numel():
+        ratio = (indices.numel() + v.numel() - 1) // v.numel()
+        v = v.unsqueeze(0).expand((ratio,) + v.shape)
+    # Trim unnecessary elements, regardless if v was expanded or not. Note
+    # np.put() trims v to match indices by default too.
+    if indices.numel() < v.numel():
+        v = v.flatten()
+        v = v[: indices.numel()]
+    a.put_(indices, v)
+    return None
+
+
+def put_along_axis(arr: ArrayLike, indices: ArrayLike, values: ArrayLike, axis):
+    (arr,), axis = _util.axis_none_flatten(arr, axis=axis)
+    axis = _util.normalize_axis_index(axis, arr.ndim)
+
+    indices, values = torch.broadcast_tensors(indices, values)
+    values = _util.cast_if_needed(values, arr.dtype)
+    result = torch.scatter(arr, axis, indices, values)
+    arr.copy_(result.reshape(arr.shape))
+    return None
+
+
+def choose(
+    a: ArrayLike,
+    choices: Sequence[ArrayLike],
+    out: OutArray | None = None,
+    mode: NotImplementedType = "raise",
+):
+    # First, broadcast elements of `choices`
+    choices = torch.stack(torch.broadcast_tensors(*choices))
+
+    # Use an analog of `gather(choices, 0, a)` which broadcasts `choices` vs `a`:
+    # (taken from https://github.com/pytorch/pytorch/issues/9407#issuecomment-1427907939)
+    idx_list = [
+        torch.arange(dim).view((1,) * i + (dim,) + (1,) * (choices.ndim - i - 1))
+        for i, dim in enumerate(choices.shape)
+    ]
+
+    idx_list[0] = a
+    return choices[tuple(idx_list)].squeeze(0)
+
+
+# ### unique et al. ###
+
+
+def unique(
+    ar: ArrayLike,
+    return_index: NotImplementedType = False,
+    return_inverse=False,
+    return_counts=False,
+    axis=None,
+    *,
+    equal_nan: NotImplementedType = True,
+):
+    (ar,), axis = _util.axis_none_flatten(ar, axis=axis)
+    axis = _util.normalize_axis_index(axis, ar.ndim)
+
+    result = torch.unique(
+        ar, return_inverse=return_inverse, return_counts=return_counts, dim=axis
+    )
+
+    return result
+
+
+def nonzero(a: ArrayLike):
+    return torch.nonzero(a, as_tuple=True)
+
+
+def argwhere(a: ArrayLike):
+    return torch.argwhere(a)
+
+
+def flatnonzero(a: ArrayLike):
+    return torch.flatten(a).nonzero(as_tuple=True)[0]
+
+
+def clip(
+    a: ArrayLike,
+    min: ArrayLike | None = None,
+    max: ArrayLike | None = None,
+    out: OutArray | None = None,
+):
+    return torch.clamp(a, min, max)
+
+
+def repeat(a: ArrayLike, repeats: ArrayLikeOrScalar, axis=None):
+    return torch.repeat_interleave(a, repeats, axis)
+
+
+def tile(A: ArrayLike, reps):
+    if isinstance(reps, int):
+        reps = (reps,)
+    return torch.tile(A, reps)
+
+
+def resize(a: ArrayLike, new_shape=None):
+    # implementation vendored from
+    # https://github.com/numpy/numpy/blob/v1.24.0/numpy/core/fromnumeric.py#L1420-L1497
+    if new_shape is None:
+        return a
+
+    if isinstance(new_shape, int):
+        new_shape = (new_shape,)
+
+    a = a.flatten()
+
+    new_size = 1
+    for dim_length in new_shape:
+        new_size *= dim_length
+        if dim_length < 0:
+            raise ValueError("all elements of `new_shape` must be non-negative")
+
+    if a.numel() == 0 or new_size == 0:
+        # First case must zero fill. The second would have repeats == 0.
+        return torch.zeros(new_shape, dtype=a.dtype)
+
+    repeats = -(-new_size // a.numel())  # ceil division
+    a = concatenate((a,) * repeats)[:new_size]
+
+    return reshape(a, new_shape)
+
+
+# ### diag et al. ###
+
+
+def diagonal(a: ArrayLike, offset=0, axis1=0, axis2=1):
+    axis1 = _util.normalize_axis_index(axis1, a.ndim)
+    axis2 = _util.normalize_axis_index(axis2, a.ndim)
+    return torch.diagonal(a, offset, axis1, axis2)
+
+
+def trace(
+    a: ArrayLike,
+    offset=0,
+    axis1=0,
+    axis2=1,
+    dtype: DTypeLike | None = None,
+    out: OutArray | None = None,
+):
+    result = torch.diagonal(a, offset, dim1=axis1, dim2=axis2).sum(-1, dtype=dtype)
+    return result
+
+
+def eye(
+    N,
+    M=None,
+    k=0,
+    dtype: DTypeLike | None = None,
+    order: NotImplementedType = "C",
+    *,
+    like: NotImplementedType = None,
+):
+    if dtype is None:
+        dtype = _dtypes_impl.default_dtypes().float_dtype
+    if M is None:
+        M = N
+    z = torch.zeros(N, M, dtype=dtype)
+    z.diagonal(k).fill_(1)
+    return z
+
+
+def identity(n, dtype: DTypeLike | None = None, *, like: NotImplementedType = None):
+    return torch.eye(n, dtype=dtype)
+
+
+def diag(v: ArrayLike, k=0):
+    return torch.diag(v, k)
+
+
+def diagflat(v: ArrayLike, k=0):
+    return torch.diagflat(v, k)
+
+
+def diag_indices(n, ndim=2):
+    idx = torch.arange(n)
+    return (idx,) * ndim
+
+
+def diag_indices_from(arr: ArrayLike):
+    if not arr.ndim >= 2:
+        raise ValueError("input array must be at least 2-d")
+    # For more than d=2, the strided formula is only valid for arrays with
+    # all dimensions equal, so we check first.
+    s = arr.shape
+    if s[1:] != s[:-1]:
+        raise ValueError("All dimensions of input must be of equal length")
+    return diag_indices(s[0], arr.ndim)
+
+
+def fill_diagonal(a: ArrayLike, val: ArrayLike, wrap=False):
+    if a.ndim < 2:
+        raise ValueError("array must be at least 2-d")
+    if val.numel() == 0 and not wrap:
+        a.fill_diagonal_(val)
+        return a
+
+    if val.ndim == 0:
+        val = val.unsqueeze(0)
+
+    # torch.Tensor.fill_diagonal_ only accepts scalars
+    # If the size of val is too large, then val is trimmed
+    if a.ndim == 2:
+        tall = a.shape[0] > a.shape[1]
+        # wrap does nothing for wide matrices...
+        if not wrap or not tall:
+            # Never wraps
+            diag = a.diagonal()
+            diag.copy_(val[: diag.numel()])
+        else:
+            # wraps and tall... leaving one empty line between diagonals?!
+            max_, min_ = a.shape
+            idx = torch.arange(max_ - max_ // (min_ + 1))
+            mod = idx % min_
+            div = idx // min_
+            a[(div * (min_ + 1) + mod, mod)] = val[: idx.numel()]
+    else:
+        idx = diag_indices_from(a)
+        # a.shape = (n, n, ..., n)
+        a[idx] = val[: a.shape[0]]
+
+    return a
+
+
+def vdot(a: ArrayLike, b: ArrayLike, /):
+    # 1. torch only accepts 1D arrays, numpy flattens
+    # 2. torch requires matching dtype, while numpy casts (?)
+    t_a, t_b = torch.atleast_1d(a, b)
+    if t_a.ndim > 1:
+        t_a = t_a.flatten()
+    if t_b.ndim > 1:
+        t_b = t_b.flatten()
+
+    dtype = _dtypes_impl.result_type_impl(t_a, t_b)
+    is_half = dtype == torch.float16 and (t_a.is_cpu or t_b.is_cpu)
+    is_bool = dtype == torch.bool
+
+    # work around torch's "dot" not implemented for 'Half', 'Bool'
+    if is_half:
+        dtype = torch.float32
+    elif is_bool:
+        dtype = torch.uint8
+
+    t_a = _util.cast_if_needed(t_a, dtype)
+    t_b = _util.cast_if_needed(t_b, dtype)
+
+    result = torch.vdot(t_a, t_b)
+
+    if is_half:
+        result = result.to(torch.float16)
+    elif is_bool:
+        result = result.to(torch.bool)
+
+    return result
+
+
+def tensordot(a: ArrayLike, b: ArrayLike, axes=2):
+    if isinstance(axes, (list, tuple)):
+        axes = [[ax] if isinstance(ax, int) else ax for ax in axes]
+
+    target_dtype = _dtypes_impl.result_type_impl(a, b)
+    a = _util.cast_if_needed(a, target_dtype)
+    b = _util.cast_if_needed(b, target_dtype)
+
+    return torch.tensordot(a, b, dims=axes)
+
+
+def dot(a: ArrayLike, b: ArrayLike, out: OutArray | None = None):
+    dtype = _dtypes_impl.result_type_impl(a, b)
+    is_bool = dtype == torch.bool
+    if is_bool:
+        dtype = torch.uint8
+
+    a = _util.cast_if_needed(a, dtype)
+    b = _util.cast_if_needed(b, dtype)
+
+    if a.ndim == 0 or b.ndim == 0:
+        result = a * b
+    else:
+        result = torch.matmul(a, b)
+
+    if is_bool:
+        result = result.to(torch.bool)
+
+    return result
+
+
+def inner(a: ArrayLike, b: ArrayLike, /):
+    dtype = _dtypes_impl.result_type_impl(a, b)
+    is_half = dtype == torch.float16 and (a.is_cpu or b.is_cpu)
+    is_bool = dtype == torch.bool
+
+    if is_half:
+        # work around torch's "addmm_impl_cpu_" not implemented for 'Half'"
+        dtype = torch.float32
+    elif is_bool:
+        dtype = torch.uint8
+
+    a = _util.cast_if_needed(a, dtype)
+    b = _util.cast_if_needed(b, dtype)
+
+    result = torch.inner(a, b)
+
+    if is_half:
+        result = result.to(torch.float16)
+    elif is_bool:
+        result = result.to(torch.bool)
+    return result
+
+
+def outer(a: ArrayLike, b: ArrayLike, out: OutArray | None = None):
+    return torch.outer(a, b)
+
+
+def cross(a: ArrayLike, b: ArrayLike, axisa=-1, axisb=-1, axisc=-1, axis=None):
+    # implementation vendored from
+    # https://github.com/numpy/numpy/blob/v1.24.0/numpy/core/numeric.py#L1486-L1685
+    if axis is not None:
+        axisa, axisb, axisc = (axis,) * 3
+
+    # Check axisa and axisb are within bounds
+    axisa = _util.normalize_axis_index(axisa, a.ndim)
+    axisb = _util.normalize_axis_index(axisb, b.ndim)
+
+    # Move working axis to the end of the shape
+    a = torch.moveaxis(a, axisa, -1)
+    b = torch.moveaxis(b, axisb, -1)
+    msg = "incompatible dimensions for cross product\n(dimension must be 2 or 3)"
+    if a.shape[-1] not in (2, 3) or b.shape[-1] not in (2, 3):
+        raise ValueError(msg)
+
+    # Create the output array
+    shape = broadcast_shapes(a[..., 0].shape, b[..., 0].shape)
+    if a.shape[-1] == 3 or b.shape[-1] == 3:
+        shape += (3,)
+        # Check axisc is within bounds
+        axisc = _util.normalize_axis_index(axisc, len(shape))
+    dtype = _dtypes_impl.result_type_impl(a, b)
+    cp = torch.empty(shape, dtype=dtype)
+
+    # recast arrays as dtype
+    a = _util.cast_if_needed(a, dtype)
+    b = _util.cast_if_needed(b, dtype)
+
+    # create local aliases for readability
+    a0 = a[..., 0]
+    a1 = a[..., 1]
+    if a.shape[-1] == 3:
+        a2 = a[..., 2]
+    b0 = b[..., 0]
+    b1 = b[..., 1]
+    if b.shape[-1] == 3:
+        b2 = b[..., 2]
+    if cp.ndim != 0 and cp.shape[-1] == 3:
+        cp0 = cp[..., 0]
+        cp1 = cp[..., 1]
+        cp2 = cp[..., 2]
+
+    if a.shape[-1] == 2:
+        if b.shape[-1] == 2:
+            # a0 * b1 - a1 * b0
+            cp[...] = a0 * b1 - a1 * b0
+            return cp
+        else:
+            if b.shape[-1] != 3:
+                raise AssertionError(f"b.shape[-1] must be 3, got {b.shape[-1]}")
+            # cp0 = a1 * b2 - 0  (a2 = 0)
+            # cp1 = 0 - a0 * b2  (a2 = 0)
+            # cp2 = a0 * b1 - a1 * b0
+            cp0[...] = a1 * b2
+            cp1[...] = -a0 * b2
+            cp2[...] = a0 * b1 - a1 * b0
+    else:
+        if a.shape[-1] != 3:
+            raise AssertionError(f"a.shape[-1] must be 3, got {a.shape[-1]}")
+        if b.shape[-1] == 3:
+            cp0[...] = a1 * b2 - a2 * b1
+            cp1[...] = a2 * b0 - a0 * b2
+            cp2[...] = a0 * b1 - a1 * b0
+        else:
+            if b.shape[-1] != 2:
+                raise AssertionError(f"b.shape[-1] must be 2, got {b.shape[-1]}")
+            cp0[...] = -a2 * b1
+            cp1[...] = a2 * b0
+            cp2[...] = a0 * b1 - a1 * b0
+
+    return torch.moveaxis(cp, -1, axisc)
+
+
+def einsum(*operands, out=None, dtype=None, order="K", casting="safe", optimize=False):
+    # Have to manually normalize *operands and **kwargs, following the NumPy signature
+    # We have a local import to avoid polluting the global space, as it will be then
+    # exported in funcs.py
+    from ._ndarray import ndarray
+    from ._normalizations import (
+        maybe_copy_to,
+        normalize_array_like,
+        normalize_casting,
+        normalize_dtype,
+        wrap_tensors,
+    )
+
+    dtype = normalize_dtype(dtype)
+    casting = normalize_casting(casting)
+    if out is not None and not isinstance(out, ndarray):
+        raise TypeError("'out' must be an array")
+    if order != "K":
+        raise NotImplementedError("'order' parameter is not supported.")
+
+    # parse arrays and normalize them
+    sublist_format = not isinstance(operands[0], str)
+    if sublist_format:
+        # op, str, op, str ... [sublistout] format: normalize every other argument
+
+        # - if sublistout is not given, the length of operands is even, and we pick
+        #   odd-numbered elements, which are arrays.
+        # - if sublistout is given, the length of operands is odd, we peel off
+        #   the last one, and pick odd-numbered elements, which are arrays.
+        #   Without [:-1], we would have picked sublistout, too.
+        array_operands = operands[:-1][::2]
+    else:
+        # ("ij->", arrays) format
+        subscripts, array_operands = operands[0], operands[1:]
+
+    tensors = [normalize_array_like(op) for op in array_operands]
+    target_dtype = _dtypes_impl.result_type_impl(*tensors) if dtype is None else dtype
+
+    # work around 'bmm' not implemented for 'Half' etc
+    is_half = target_dtype == torch.float16 and all(t.is_cpu for t in tensors)
+    if is_half:
+        target_dtype = torch.float32
+
+    is_short_int = target_dtype in [torch.uint8, torch.int8, torch.int16, torch.int32]
+    if is_short_int:
+        target_dtype = torch.int64
+
+    tensors = _util.typecast_tensors(tensors, target_dtype, casting)
+
+    from torch.backends import opt_einsum
+
+    try:
+        # set the global state to handle the optimize=... argument, restore on exit
+        if opt_einsum.is_available():
+            old_strategy = torch.backends.opt_einsum.strategy
+            old_enabled = torch.backends.opt_einsum.enabled
+
+            # torch.einsum calls opt_einsum.contract_path, which runs into
+            # https://github.com/dgasmith/opt_einsum/issues/219
+            # for strategy={True, False}
+            if optimize is True:
+                optimize = "auto"
+            elif optimize is False:
+                torch.backends.opt_einsum.enabled = False
+
+            torch.backends.opt_einsum.strategy = optimize
+
+        if sublist_format:
+            # recombine operands
+            sublists = operands[1::2]
+            has_sublistout = len(operands) % 2 == 1
+            if has_sublistout:
+                sublistout = operands[-1]
+            operands = list(itertools.chain.from_iterable(zip(tensors, sublists)))
+            if has_sublistout:
+                operands.append(sublistout)
+
+            result = torch.einsum(*operands)
+        else:
+            result = torch.einsum(subscripts, *tensors)
+
+    finally:
+        if opt_einsum.is_available():
+            torch.backends.opt_einsum.strategy = old_strategy
+            torch.backends.opt_einsum.enabled = old_enabled
+
+    result = maybe_copy_to(out, result)
+    return wrap_tensors(result)
+
+
+# ### sort and partition ###
+
+
+def _sort_helper(tensor, axis, kind, order):
+    if tensor.dtype.is_complex:
+        raise NotImplementedError(f"sorting {tensor.dtype} is not supported")
+    (tensor,), axis = _util.axis_none_flatten(tensor, axis=axis)
+    axis = _util.normalize_axis_index(axis, tensor.ndim)
+
+    stable = kind == "stable"
+
+    return tensor, axis, stable
+
+
+def sort(a: ArrayLike, axis=-1, kind=None, order: NotImplementedType = None):
+    # `order` keyword arg is only relevant for structured dtypes; so not supported here.
+    a, axis, stable = _sort_helper(a, axis, kind, order)
+    result = torch.sort(a, dim=axis, stable=stable)
+    return result.values
+
+
+def argsort(a: ArrayLike, axis=-1, kind=None, order: NotImplementedType = None):
+    a, axis, stable = _sort_helper(a, axis, kind, order)
+    return torch.argsort(a, dim=axis, stable=stable)
+
+
+def searchsorted(
+    a: ArrayLike, v: ArrayLike, side="left", sorter: ArrayLike | None = None
+):
+    if a.dtype.is_complex:
+        raise NotImplementedError(f"searchsorted with dtype={a.dtype}")
+
+    return torch.searchsorted(a, v, side=side, sorter=sorter)
+
+
+# ### swap/move/roll axis ###
+
+
+def moveaxis(a: ArrayLike, source, destination):
+    source = _util.normalize_axis_tuple(source, a.ndim, "source")
+    destination = _util.normalize_axis_tuple(destination, a.ndim, "destination")
+    return torch.moveaxis(a, source, destination)
+
+
+def swapaxes(a: ArrayLike, axis1, axis2):
+    axis1 = _util.normalize_axis_index(axis1, a.ndim)
+    axis2 = _util.normalize_axis_index(axis2, a.ndim)
+    return torch.swapaxes(a, axis1, axis2)
+
+
+def rollaxis(a: ArrayLike, axis, start=0):
+    # Straight vendor from:
+    # https://github.com/numpy/numpy/blob/v1.24.0/numpy/core/numeric.py#L1259
+    #
+    # Also note this function in NumPy is mostly retained for backwards compat
+    # (https://stackoverflow.com/questions/29891583/reason-why-numpy-rollaxis-is-so-confusing)
+    # so let's not touch it unless hard pressed.
+    n = a.ndim
+    axis = _util.normalize_axis_index(axis, n)
+    if start < 0:
+        start += n
+    msg = "'%s' arg requires %d <= %s < %d, but %d was passed in"
+    if not (0 <= start < n + 1):
+        raise _util.AxisError(msg % ("start", -n, "start", n + 1, start))
+    if axis < start:
+        # it's been removed
+        start -= 1
+    if axis == start:
+        # numpy returns a view, here we try returning the tensor itself
+        # return tensor[...]
+        return a
+    axes = list(range(n))
+    axes.remove(axis)
+    axes.insert(start, axis)
+    return a.view(axes)
+
+
+def roll(a: ArrayLike, shift, axis=None):
+    if axis is not None:
+        axis = _util.normalize_axis_tuple(axis, a.ndim, allow_duplicate=True)
+        if not isinstance(shift, tuple):
+            shift = (shift,) * len(axis)
+    return torch.roll(a, shift, axis)
+
+
+# ### shape manipulations ###
+
+
+def squeeze(a: ArrayLike, axis=None):
+    if axis == ():
+        result = a
+    elif axis is None:
+        result = a.squeeze()
+    else:
+        if isinstance(axis, tuple):
+            result = a
+            for ax in axis:
+                result = a.squeeze(ax)
+        else:
+            result = a.squeeze(axis)
+    return result
+
+
+def reshape(a: ArrayLike, newshape, order: NotImplementedType = "C"):
+    # if sh = (1, 2, 3), numpy allows both .reshape(sh) and .reshape(*sh)
+    newshape = newshape[0] if len(newshape) == 1 else newshape
+    return a.reshape(newshape)
+
+
+# NB: cannot use torch.reshape(a, newshape) above, because of
+# (Pdb) torch.reshape(torch.as_tensor([1]), 1)
+# *** TypeError: reshape(): argument 'shape' (position 2) must be tuple of SymInts, not int
+
+
+def transpose(a: ArrayLike, axes=None):
+    # numpy allows both .transpose(sh) and .transpose(*sh)
+    # also older code uses axes being a list
+    if axes in [(), None, (None,)]:
+        axes = tuple(reversed(range(a.ndim)))
+    elif len(axes) == 1:
+        axes = axes[0]
+    return a.permute(axes)
+
+
+def ravel(a: ArrayLike, order: NotImplementedType = "C"):
+    return torch.flatten(a)
+
+
+def diff(
+    a: ArrayLike,
+    n=1,
+    axis=-1,
+    prepend: ArrayLike | None = None,
+    append: ArrayLike | None = None,
+):
+    axis = _util.normalize_axis_index(axis, a.ndim)
+
+    if n < 0:
+        raise ValueError(f"order must be non-negative but got {n}")
+
+    if n == 0:
+        # match numpy and return the input immediately
+        return a
+
+    if prepend is not None:
+        shape = list(a.shape)
+        shape[axis] = prepend.shape[axis] if prepend.ndim > 0 else 1
+        prepend = torch.broadcast_to(prepend, shape)
+
+    if append is not None:
+        shape = list(a.shape)
+        shape[axis] = append.shape[axis] if append.ndim > 0 else 1
+        append = torch.broadcast_to(append, shape)
+
+    return torch.diff(a, n, axis=axis, prepend=prepend, append=append)
+
+
+# ### math functions ###
+
+
+def angle(z: ArrayLike, deg=False):
+    result = torch.angle(z)
+    if deg:
+        result = result * (180 / torch.pi)
+    return result
+
+
+def sinc(x: ArrayLike):
+    return torch.sinc(x)
+
+
+# NB: have to normalize *varargs manually
+def gradient(f: ArrayLike, *varargs, axis=None, edge_order=1):
+    N = f.ndim  # number of dimensions
+
+    varargs = _util.ndarrays_to_tensors(varargs)
+
+    if axis is None:
+        axes = tuple(range(N))
+    else:
+        axes = _util.normalize_axis_tuple(axis, N)
+
+    len_axes = len(axes)
+    n = len(varargs)
+    if n == 0:
+        # no spacing argument - use 1 in all axes
+        dx = [1.0] * len_axes
+    elif n == 1 and (_dtypes_impl.is_scalar(varargs[0]) or varargs[0].ndim == 0):
+        # single scalar or 0D tensor for all axes (np.ndim(varargs[0]) == 0)
+        dx = varargs * len_axes
+    elif n == len_axes:
+        # scalar or 1d array for each axis
+        dx = list(varargs)
+        for i, distances in enumerate(dx):
+            distances = torch.as_tensor(distances)
+            if distances.ndim == 0:
+                continue
+            elif distances.ndim != 1:
+                raise ValueError("distances must be either scalars or 1d")
+            if len(distances) != f.shape[axes[i]]:
+                raise ValueError(
+                    "when 1d, distances must match "
+                    "the length of the corresponding dimension"
+                )
+            if not (distances.dtype.is_floating_point or distances.dtype.is_complex):
+                distances = distances.double()
+
+            diffx = torch.diff(distances)
+            # if distances are constant reduce to the scalar case
+            # since it brings a consistent speedup
+            if (diffx == diffx[0]).all():
+                diffx = diffx[0]
+            dx[i] = diffx
+    else:
+        raise TypeError("invalid number of arguments")
+
+    if edge_order > 2:
+        raise ValueError("'edge_order' greater than 2 not supported")
+
+    # use central differences on interior and one-sided differences on the
+    # endpoints. This preserves second order-accuracy over the full domain.
+
+    outvals = []
+
+    # create slice objects --- initially all are [:, :, ..., :]
+    slice1 = [slice(None)] * N
+    slice2 = [slice(None)] * N
+    slice3 = [slice(None)] * N
+    slice4 = [slice(None)] * N
+
+    otype = f.dtype
+    if _dtypes_impl.python_type_for_torch(otype) in (int, bool):
+        # Convert to floating point.
+        # First check if f is a numpy integer type; if so, convert f to float64
+        # to avoid modular arithmetic when computing the changes in f.
+        f = f.double()
+        otype = torch.float64
+
+    for axis, ax_dx in zip(axes, dx):
+        if f.shape[axis] < edge_order + 1:
+            raise ValueError(
+                "Shape of array too small to calculate a numerical gradient, "
+                "at least (edge_order + 1) elements are required."
+            )
+        # result allocation
+        out = torch.empty_like(f, dtype=otype)
+
+        # spacing for the current axis (NB: np.ndim(ax_dx) == 0)
+        uniform_spacing = _dtypes_impl.is_scalar(ax_dx) or ax_dx.ndim == 0
+
+        # Numerical differentiation: 2nd order interior
+        slice1[axis] = slice(1, -1)
+        slice2[axis] = slice(None, -2)
+        slice3[axis] = slice(1, -1)
+        slice4[axis] = slice(2, None)
+
+        if uniform_spacing:
+            out[tuple(slice1)] = (f[tuple(slice4)] - f[tuple(slice2)]) / (2.0 * ax_dx)
+        else:
+            dx1 = ax_dx[0:-1]
+            dx2 = ax_dx[1:]
+            a = -(dx2) / (dx1 * (dx1 + dx2))
+            b = (dx2 - dx1) / (dx1 * dx2)
+            c = dx1 / (dx2 * (dx1 + dx2))
+            # fix the shape for broadcasting
+            shape = [1] * N
+            shape[axis] = -1
+            a = a.reshape(shape)
+            b = b.reshape(shape)
+            c = c.reshape(shape)
+            # 1D equivalent -- out[1:-1] = a * f[:-2] + b * f[1:-1] + c * f[2:]
+            out[tuple(slice1)] = (
+                a * f[tuple(slice2)] + b * f[tuple(slice3)] + c * f[tuple(slice4)]
+            )
+
+        # Numerical differentiation: 1st order edges
+        if edge_order == 1:
+            slice1[axis] = 0
+            slice2[axis] = 1
+            slice3[axis] = 0
+            dx_0 = ax_dx if uniform_spacing else ax_dx[0]
+            # 1D equivalent -- out[0] = (f[1] - f[0]) / (x[1] - x[0])
+            out[tuple(slice1)] = (f[tuple(slice2)] - f[tuple(slice3)]) / dx_0
+
+            slice1[axis] = -1
+            slice2[axis] = -1
+            slice3[axis] = -2
+            dx_n = ax_dx if uniform_spacing else ax_dx[-1]
+            # 1D equivalent -- out[-1] = (f[-1] - f[-2]) / (x[-1] - x[-2])
+            out[tuple(slice1)] = (f[tuple(slice2)] - f[tuple(slice3)]) / dx_n
+
+        # Numerical differentiation: 2nd order edges
+        else:
+            slice1[axis] = 0
+            slice2[axis] = 0
+            slice3[axis] = 1
+            slice4[axis] = 2
+            if uniform_spacing:
+                a = -1.5 / ax_dx
+                b = 2.0 / ax_dx
+                c = -0.5 / ax_dx
+            else:
+                dx1 = ax_dx[0]
+                dx2 = ax_dx[1]
+                a = -(2.0 * dx1 + dx2) / (dx1 * (dx1 + dx2))
+                b = (dx1 + dx2) / (dx1 * dx2)
+                c = -dx1 / (dx2 * (dx1 + dx2))
+            # 1D equivalent -- out[0] = a * f[0] + b * f[1] + c * f[2]
+            out[tuple(slice1)] = (
+                a * f[tuple(slice2)] + b * f[tuple(slice3)] + c * f[tuple(slice4)]
+            )
+
+            slice1[axis] = -1
+            slice2[axis] = -3
+            slice3[axis] = -2
+            slice4[axis] = -1
+            if uniform_spacing:
+                a = 0.5 / ax_dx
+                b = -2.0 / ax_dx
+                c = 1.5 / ax_dx
+            else:
+                dx1 = ax_dx[-2]
+                dx2 = ax_dx[-1]
+                a = (dx2) / (dx1 * (dx1 + dx2))
+                b = -(dx2 + dx1) / (dx1 * dx2)
+                c = (2.0 * dx2 + dx1) / (dx2 * (dx1 + dx2))
+            # 1D equivalent -- out[-1] = a * f[-3] + b * f[-2] + c * f[-1]
+            out[tuple(slice1)] = (
+                a * f[tuple(slice2)] + b * f[tuple(slice3)] + c * f[tuple(slice4)]
+            )
+
+        outvals.append(out)
+
+        # reset the slice object in this dimension to ":"
+        slice1[axis] = slice(None)
+        slice2[axis] = slice(None)
+        slice3[axis] = slice(None)
+        slice4[axis] = slice(None)
+
+    if len_axes == 1:
+        return outvals[0]
+    else:
+        return outvals
+
+
+# ### Type/shape etc queries ###
+
+
+def round(a: ArrayLike, decimals=0, out: OutArray | None = None):
+    if a.is_floating_point():
+        result = torch.round(a, decimals=decimals)
+    elif a.is_complex():
+        # RuntimeError: "round_cpu" not implemented for 'ComplexFloat'
+        result = torch.complex(
+            torch.round(a.real, decimals=decimals),
+            torch.round(a.imag, decimals=decimals),
+        )
+    else:
+        # RuntimeError: "round_cpu" not implemented for 'int'
+        result = a
+    return result
+
+
+around = round
+round_ = round
+
+
+def real_if_close(a: ArrayLike, tol=100):
+    if not torch.is_complex(a):
+        return a
+    if tol > 1:
+        # Undocumented in numpy: if tol < 1, it's an absolute tolerance!
+        # Otherwise, tol > 1 is relative tolerance, in units of the dtype epsilon
+        # https://github.com/numpy/numpy/blob/v1.24.0/numpy/lib/type_check.py#L577
+        tol = tol * torch.finfo(a.dtype).eps
+
+    mask = torch.abs(a.imag) < tol
+    return a.real if mask.all() else a
+
+
+def real(a: ArrayLike):
+    return torch.real(a)
+
+
+def imag(a: ArrayLike):
+    if a.is_complex():
+        return a.imag
+    return torch.zeros_like(a)
+
+
+def iscomplex(x: ArrayLike):
+    if torch.is_complex(x):
+        return x.imag != 0
+    return torch.zeros_like(x, dtype=torch.bool)
+
+
+def isreal(x: ArrayLike):
+    if torch.is_complex(x):
+        return x.imag == 0
+    return torch.ones_like(x, dtype=torch.bool)
+
+
+def iscomplexobj(x: ArrayLike):
+    return torch.is_complex(x)
+
+
+def isrealobj(x: ArrayLike):
+    return not torch.is_complex(x)
+
+
+def isneginf(x: ArrayLike, out: OutArray | None = None):
+    return torch.isneginf(x)
+
+
+def isposinf(x: ArrayLike, out: OutArray | None = None):
+    return torch.isposinf(x)
+
+
+def i0(x: ArrayLike):
+    return torch.special.i0(x)
+
+
+def isscalar(a):
+    # We need to use normalize_array_like, but we don't want to export it in funcs.py
+    from ._normalizations import normalize_array_like
+
+    try:
+        t = normalize_array_like(a)
+        return t.numel() == 1
+    except Exception:
+        return False
+
+
+# ### Filter windows ###
+
+
+def hamming(M):
+    dtype = _dtypes_impl.default_dtypes().float_dtype
+    return torch.hamming_window(M, periodic=False, dtype=dtype)
+
+
+def hanning(M):
+    dtype = _dtypes_impl.default_dtypes().float_dtype
+    return torch.hann_window(M, periodic=False, dtype=dtype)
+
+
+def kaiser(M, beta):
+    dtype = _dtypes_impl.default_dtypes().float_dtype
+    return torch.kaiser_window(M, beta=beta, periodic=False, dtype=dtype)
+
+
+def blackman(M):
+    dtype = _dtypes_impl.default_dtypes().float_dtype
+    return torch.blackman_window(M, periodic=False, dtype=dtype)
+
+
+def bartlett(M):
+    dtype = _dtypes_impl.default_dtypes().float_dtype
+    return torch.bartlett_window(M, periodic=False, dtype=dtype)
+
+
+# ### Dtype routines ###
+
+# vendored from https://github.com/numpy/numpy/blob/v1.24.0/numpy/lib/type_check.py#L666
+
+
+array_type = [
+    [torch.float16, torch.float32, torch.float64],
+    [None, torch.complex64, torch.complex128],
+]
+array_precision = {
+    torch.float16: 0,
+    torch.float32: 1,
+    torch.float64: 2,
+    torch.complex64: 1,
+    torch.complex128: 2,
+}
+
+
+def common_type(*tensors: ArrayLike):
+    is_complex = False
+    precision = 0
+    for a in tensors:
+        t = a.dtype
+        if iscomplexobj(a):
+            is_complex = True
+        if not (t.is_floating_point or t.is_complex):
+            p = 2  # array_precision[_nx.double]
+        else:
+            p = array_precision.get(t)
+            if p is None:
+                raise TypeError("can't get common type for non-numeric array")
+        precision = builtins.max(precision, p)
+    if is_complex:
+        return array_type[1][precision]
+    else:
+        return array_type[0][precision]
+
+
+# ### histograms ###
+
+
+def histogram(
+    a: ArrayLike,
+    bins: ArrayLike = 10,
+    range=None,
+    normed=None,
+    weights: ArrayLike | None = None,
+    density=None,
+):
+    if normed is not None:
+        raise ValueError("normed argument is deprecated, use density= instead")
+
+    if weights is not None and weights.dtype.is_complex:
+        raise NotImplementedError("complex weights histogram.")
+
+    is_a_int = not (a.dtype.is_floating_point or a.dtype.is_complex)
+    is_w_int = weights is None or not weights.dtype.is_floating_point
+    if is_a_int:
+        a = a.double()
+
+    if weights is not None:
+        weights = _util.cast_if_needed(weights, a.dtype)
+
+    if isinstance(bins, torch.Tensor):
+        if bins.ndim == 0:
+            # bins was a single int
+            bins = operator.index(bins)
+        else:
+            bins = _util.cast_if_needed(bins, a.dtype)
+
+    if range is None:
+        h, b = torch.histogram(a, bins, weight=weights, density=bool(density))
+    else:
+        h, b = torch.histogram(
+            a, bins, range=range, weight=weights, density=bool(density)
+        )
+
+    if not density and is_w_int:
+        h = h.long()
+    if is_a_int:
+        b = b.long()
+
+    return h, b
+
+
+def histogram2d(
+    x,
+    y,
+    bins=10,
+    range: ArrayLike | None = None,
+    normed=None,
+    weights: ArrayLike | None = None,
+    density=None,
+):
+    # vendored from https://github.com/numpy/numpy/blob/v1.24.0/numpy/lib/twodim_base.py#L655-L821
+    if len(x) != len(y):
+        raise ValueError("x and y must have the same length.")
+
+    try:
+        N = len(bins)
+    except TypeError:
+        N = 1
+
+    if N != 1 and N != 2:
+        bins = [bins, bins]
+
+    h, e = histogramdd((x, y), bins, range, normed, weights, density)
+
+    return h, e[0], e[1]
+
+
+def histogramdd(
+    sample,
+    bins=10,
+    range: ArrayLike | None = None,
+    normed=None,
+    weights: ArrayLike | None = None,
+    density=None,
+):
+    # have to normalize manually because `sample` interpretation differs
+    # for a list of lists and a 2D array
+    if normed is not None:
+        raise ValueError("normed argument is deprecated, use density= instead")
+
+    from ._normalizations import normalize_array_like, normalize_seq_array_like
+
+    if isinstance(sample, (list, tuple)):
+        sample = normalize_array_like(sample).T
+    else:
+        sample = normalize_array_like(sample)
+
+    sample = torch.atleast_2d(sample)
+
+    if not (sample.dtype.is_floating_point or sample.dtype.is_complex):
+        sample = sample.double()
+
+    # bins is either an int, or a sequence of ints or a sequence of arrays
+    bins_is_array = not (
+        isinstance(bins, int) or builtins.all(isinstance(b, int) for b in bins)
+    )
+    if bins_is_array:
+        bins = normalize_seq_array_like(bins)
+        bins_dtypes = [b.dtype for b in bins]
+        bins = [_util.cast_if_needed(b, sample.dtype) for b in bins]
+
+    if range is not None:
+        range = range.flatten().tolist()
+
+    if weights is not None:
+        # range=... is required : interleave min and max values per dimension
+        mm = sample.aminmax(dim=0)
+        range = torch.cat(mm).reshape(2, -1).T.flatten()
+        range = tuple(range.tolist())
+        weights = _util.cast_if_needed(weights, sample.dtype)
+        w_kwd = {"weight": weights}
+    else:
+        w_kwd = {}
+
+    h, b = torch.histogramdd(sample, bins, range, density=bool(density), **w_kwd)
+
+    if bins_is_array:
+        b = [_util.cast_if_needed(bb, dtyp) for bb, dtyp in zip(b, bins_dtypes)]
+
+    return h, b
+
+
+# ### odds and ends
+
+
+def min_scalar_type(a: ArrayLike, /):
+    # https://github.com/numpy/numpy/blob/maintenance/1.24.x/numpy/core/src/multiarray/convert_datatype.c#L1288
+
+    from ._dtypes import DType
+
+    if a.numel() > 1:
+        # numpy docs: "For non-scalar array a, returns the vector's dtype unmodified."
+        return DType(a.dtype)
+
+    if a.dtype == torch.bool:
+        dtype = torch.bool
+
+    elif a.dtype.is_complex:
+        fi = torch.finfo(torch.float32)
+        fits_in_single = a.dtype == torch.complex64 or (
+            fi.min <= a.real <= fi.max and fi.min <= a.imag <= fi.max
+        )
+        dtype = torch.complex64 if fits_in_single else torch.complex128
+
+    elif a.dtype.is_floating_point:
+        for dt in [torch.float16, torch.float32, torch.float64]:
+            fi = torch.finfo(dt)
+            if fi.min <= a <= fi.max:
+                dtype = dt
+                break
+    else:
+        # must be integer
+        for dt in [torch.uint8, torch.int8, torch.int16, torch.int32, torch.int64]:
+            # Prefer unsigned int where possible, as numpy does.
+            ii = torch.iinfo(dt)
+            if ii.min <= a <= ii.max:
+                dtype = dt
+                break
+
+    return DType(dtype)
+
+
+def pad(array: ArrayLike, pad_width: ArrayLike, mode="constant", **kwargs):
+    if mode != "constant":
+        raise NotImplementedError
+    value = kwargs.get("constant_values", 0)
+    # `value` must be a python scalar for torch.nn.functional.pad
+    typ = _dtypes_impl.python_type_for_torch(array.dtype)
+    value = typ(value)
+
+    pad_width = torch.broadcast_to(pad_width, (array.ndim, 2))
+    pad_width = torch.flip(pad_width, (0,)).flatten()
+
+    return torch.nn.functional.pad(array, tuple(pad_width), value=value)

.venv/lib/python3.12/site-packages/torch/_numpy/_getlimits.py

@@ -0,0 +1,15 @@
+# mypy: ignore-errors
+
+import torch
+
+from . import _dtypes
+
+
+def finfo(dtyp):
+    torch_dtype = _dtypes.dtype(dtyp).torch_dtype
+    return torch.finfo(torch_dtype)
+
+
+def iinfo(dtyp):
+    torch_dtype = _dtypes.dtype(dtyp).torch_dtype
+    return torch.iinfo(torch_dtype)

.venv/lib/python3.12/site-packages/torch/_numpy/_ndarray.py

@@ -0,0 +1,733 @@
+# mypy: ignore-errors
+
+from __future__ import annotations
+
+import builtins
+import math
+import operator
+from collections.abc import Sequence
+
+import torch
+
+from . import _dtypes, _dtypes_impl, _funcs, _ufuncs, _util
+from ._normalizations import (
+    ArrayLike,
+    normalize_array_like,
+    normalizer,
+    NotImplementedType,
+)
+
+
+newaxis = None
+
+FLAGS = [
+    "C_CONTIGUOUS",
+    "F_CONTIGUOUS",
+    "OWNDATA",
+    "WRITEABLE",
+    "ALIGNED",
+    "WRITEBACKIFCOPY",
+    "FNC",
+    "FORC",
+    "BEHAVED",
+    "CARRAY",
+    "FARRAY",
+]
+
+SHORTHAND_TO_FLAGS = {
+    "C": "C_CONTIGUOUS",
+    "F": "F_CONTIGUOUS",
+    "O": "OWNDATA",
+    "W": "WRITEABLE",
+    "A": "ALIGNED",
+    "X": "WRITEBACKIFCOPY",
+    "B": "BEHAVED",
+    "CA": "CARRAY",
+    "FA": "FARRAY",
+}
+
+
+class Flags:
+    def __init__(self, flag_to_value: dict):
+        invalid_keys = [k for k in flag_to_value if k not in FLAGS]
+        if invalid_keys:
+            raise AssertionError(f"Invalid flag keys: {invalid_keys}")
+        self._flag_to_value = flag_to_value
+
+    def __getattr__(self, attr: str):
+        if attr.islower() and attr.upper() in FLAGS:
+            return self[attr.upper()]
+        else:
+            raise AttributeError(f"No flag attribute '{attr}'")
+
+    def __getitem__(self, key):
+        if key in SHORTHAND_TO_FLAGS:
+            key = SHORTHAND_TO_FLAGS[key]
+        if key in FLAGS:
+            try:
+                return self._flag_to_value[key]
+            except KeyError as e:
+                raise NotImplementedError(f"{key=}") from e
+        else:
+            raise KeyError(f"No flag key '{key}'")
+
+    def __setattr__(self, attr, value):
+        if attr.islower() and attr.upper() in FLAGS:
+            self[attr.upper()] = value
+        else:
+            super().__setattr__(attr, value)
+
+    def __setitem__(self, key, value):
+        if key in FLAGS or key in SHORTHAND_TO_FLAGS:
+            raise NotImplementedError("Modifying flags is not implemented")
+        else:
+            raise KeyError(f"No flag key '{key}'")
+
+
+def create_method(fn, name=None):
+    name = name or fn.__name__
+
+    def f(*args, **kwargs):
+        return fn(*args, **kwargs)
+
+    f.__name__ = name
+    f.__qualname__ = f"ndarray.{name}"
+    return f
+
+
+# Map ndarray.name_method -> np.name_func
+# If name_func == None, it means that name_method == name_func
+methods = {
+    "clip": None,
+    "nonzero": None,
+    "repeat": None,
+    "round": None,
+    "squeeze": None,
+    "swapaxes": None,
+    "ravel": None,
+    # linalg
+    "diagonal": None,
+    "dot": None,
+    "trace": None,
+    # sorting
+    "argsort": None,
+    "searchsorted": None,
+    # reductions
+    "argmax": None,
+    "argmin": None,
+    "any": None,
+    "all": None,
+    "max": None,
+    "min": None,
+    "ptp": None,
+    "sum": None,
+    "prod": None,
+    "mean": None,
+    "var": None,
+    "std": None,
+    # scans
+    "cumsum": None,
+    "cumprod": None,
+    # advanced indexing
+    "take": None,
+    "choose": None,
+}
+
+dunder = {
+    "abs": "absolute",
+    "invert": None,
+    "pos": "positive",
+    "neg": "negative",
+    "gt": "greater",
+    "lt": "less",
+    "ge": "greater_equal",
+    "le": "less_equal",
+}
+
+# dunder methods with right-looking and in-place variants
+ri_dunder = {
+    "add": None,
+    "sub": "subtract",
+    "mul": "multiply",
+    "truediv": "divide",
+    "floordiv": "floor_divide",
+    "pow": "power",
+    "mod": "remainder",
+    "and": "bitwise_and",
+    "or": "bitwise_or",
+    "xor": "bitwise_xor",
+    "lshift": "left_shift",
+    "rshift": "right_shift",
+    "matmul": None,
+}
+
+
+def _upcast_int_indices(index):
+    if isinstance(index, torch.Tensor):
+        if index.dtype in (torch.int8, torch.int16, torch.int32, torch.uint8):
+            return index.to(torch.int64)
+    elif isinstance(index, tuple):
+        return tuple(_upcast_int_indices(i) for i in index)
+    return index
+
+
+def _has_advanced_indexing(index):
+    """Check if there's any advanced indexing"""
+    return any(
+        isinstance(idx, (Sequence, bool))
+        or (isinstance(idx, torch.Tensor) and (idx.dtype == torch.bool or idx.ndim > 0))
+        for idx in index
+    )
+
+
+def _numpy_compatible_indexing(index):
+    """Convert scalar indices to lists when advanced indexing is present for NumPy compatibility."""
+    if not isinstance(index, tuple):
+        index = (index,)
+
+    # Check if there's any advanced indexing (sequences, booleans, or tensors)
+    has_advanced = _has_advanced_indexing(index)
+
+    if not has_advanced:
+        return index
+
+    # Convert integer scalar indices to single-element lists when advanced indexing is present
+    # Note: Do NOT convert boolean scalars (True/False) as they have special meaning in NumPy
+    converted = []
+    for idx in index:
+        if isinstance(idx, int) and not isinstance(idx, bool):
+            # Integer scalars should be converted to lists
+            converted.append([idx])
+        elif (
+            isinstance(idx, torch.Tensor)
+            and idx.ndim == 0
+            and not torch.is_floating_point(idx)
+            and idx.dtype != torch.bool
+        ):
+            # Zero-dimensional tensors holding integers should be treated the same as integer scalars
+            converted.append([idx])
+        else:
+            # Everything else (booleans, lists, slices, etc.) stays as is
+            converted.append(idx)
+
+    return tuple(converted)
+
+
+def _get_bool_depth(s):
+    """Returns the depth of a boolean sequence/tensor"""
+    if isinstance(s, bool):
+        return True, 0
+    if isinstance(s, torch.Tensor) and s.dtype == torch.bool:
+        return True, s.ndim
+    if not (isinstance(s, Sequence) and s and s[0] != s):
+        return False, 0
+    is_bool, depth = _get_bool_depth(s[0])
+    return is_bool, depth + 1
+
+
+def _numpy_empty_ellipsis_patch(index, tensor_ndim):
+    """
+    Patch for NumPy-compatible ellipsis behavior when ellipsis doesn't match any dimensions.
+
+    In NumPy, when an ellipsis (...) doesn't actually match any dimensions of the input array,
+    it still acts as a separator between advanced indices. PyTorch doesn't have this behavior.
+
+    This function detects when we have:
+    1. Advanced indexing on both sides of an ellipsis
+    2. The ellipsis doesn't actually match any dimensions
+    """
+    if not isinstance(index, tuple):
+        index = (index,)
+
+    # Find ellipsis position
+    ellipsis_pos = None
+    for i, idx in enumerate(index):
+        if idx is Ellipsis:
+            ellipsis_pos = i
+            break
+
+    # If no ellipsis, no patch needed
+    if ellipsis_pos is None:
+        return index, lambda x: x, lambda x: x
+
+    # Count non-ellipsis dimensions consumed by the index
+    consumed_dims = 0
+    for idx in index:
+        is_bool, depth = _get_bool_depth(idx)
+        if is_bool:
+            consumed_dims += depth
+        elif idx is Ellipsis or idx is None:
+            continue
+        else:
+            consumed_dims += 1
+
+    # Calculate how many dimensions the ellipsis should match
+    ellipsis_dims = tensor_ndim - consumed_dims
+
+    # Check if ellipsis doesn't match any dimensions
+    if ellipsis_dims == 0:
+        # Check if we have advanced indexing on both sides of ellipsis
+        left_advanced = _has_advanced_indexing(index[:ellipsis_pos])
+        right_advanced = _has_advanced_indexing(index[ellipsis_pos + 1 :])
+
+        if left_advanced and right_advanced:
+            # This is the case where NumPy and PyTorch differ
+            # We need to ensure the advanced indices are treated as separated
+            new_index = index[:ellipsis_pos] + (None,) + index[ellipsis_pos + 1 :]
+            end_ndims = 1 + sum(
+                1 for idx in index[ellipsis_pos + 1 :] if isinstance(idx, slice)
+            )
+
+            def squeeze_fn(x):
+                return x.squeeze(-end_ndims)
+
+            def unsqueeze_fn(x):
+                if isinstance(x, torch.Tensor) and x.ndim >= end_ndims:
+                    return x.unsqueeze(-end_ndims)
+                return x
+
+            return new_index, squeeze_fn, unsqueeze_fn
+
+    return index, lambda x: x, lambda x: x
+
+
+# Used to indicate that a parameter is unspecified (as opposed to explicitly
+# `None`)
+class _Unspecified:
+    pass
+
+
+_Unspecified.unspecified = _Unspecified()
+
+###############################################################
+#                      ndarray class                          #
+###############################################################
+
+
+class ndarray:
+    def __init__(self, t=None):
+        if t is None:
+            self.tensor = torch.Tensor()
+        elif isinstance(t, torch.Tensor):
+            self.tensor = t
+        else:
+            raise ValueError(
+                "ndarray constructor is not recommended; prefer"
+                "either array(...) or zeros/empty(...)"
+            )
+
+    # Register NumPy functions as methods
+    for method, name in methods.items():
+        fn = getattr(_funcs, name or method)
+        vars()[method] = create_method(fn, method)
+
+    # Regular methods but coming from ufuncs
+    conj = create_method(_ufuncs.conjugate, "conj")
+    conjugate = create_method(_ufuncs.conjugate)
+
+    for method, name in dunder.items():
+        fn = getattr(_ufuncs, name or method)
+        method = f"__{method}__"
+        vars()[method] = create_method(fn, method)
+
+    for method, name in ri_dunder.items():
+        fn = getattr(_ufuncs, name or method)
+        plain = f"__{method}__"
+        vars()[plain] = create_method(fn, plain)
+        rvar = f"__r{method}__"
+        vars()[rvar] = create_method(lambda self, other, fn=fn: fn(other, self), rvar)
+        ivar = f"__i{method}__"
+        vars()[ivar] = create_method(
+            lambda self, other, fn=fn: fn(self, other, out=self), ivar
+        )
+
+    # There's no __idivmod__
+    __divmod__ = create_method(_ufuncs.divmod, "__divmod__")
+    __rdivmod__ = create_method(
+        lambda self, other: _ufuncs.divmod(other, self), "__rdivmod__"
+    )
+
+    # prevent loop variables leaking into the ndarray class namespace
+    del ivar, rvar, name, plain, fn, method
+
+    @property
+    def shape(self):
+        return tuple(self.tensor.shape)
+
+    @property
+    def size(self):
+        return self.tensor.numel()
+
+    @property
+    def ndim(self):
+        return self.tensor.ndim
+
+    @property
+    def dtype(self):
+        return _dtypes.dtype(self.tensor.dtype)
+
+    @property
+    def strides(self):
+        elsize = self.tensor.element_size()
+        return tuple(stride * elsize for stride in self.tensor.stride())
+
+    @property
+    def itemsize(self):
+        return self.tensor.element_size()
+
+    @property
+    def flags(self):
+        # Note contiguous in torch is assumed C-style
+        return Flags(
+            {
+                "C_CONTIGUOUS": self.tensor.is_contiguous(),
+                "F_CONTIGUOUS": self.T.tensor.is_contiguous(),
+                "OWNDATA": self.tensor._base is None,
+                "WRITEABLE": True,  # pytorch does not have readonly tensors
+            }
+        )
+
+    @property
+    def data(self):
+        return self.tensor.data_ptr()
+
+    @property
+    def nbytes(self):
+        return self.tensor.storage().nbytes()
+
+    @property
+    def T(self):
+        return self.transpose()
+
+    @property
+    def real(self):
+        return _funcs.real(self)
+
+    @real.setter
+    def real(self, value):
+        self.tensor.real = asarray(value).tensor
+
+    @property
+    def imag(self):
+        return _funcs.imag(self)
+
+    @imag.setter
+    def imag(self, value):
+        self.tensor.imag = asarray(value).tensor
+
+    @property
+    def flat(self):
+        return self.ravel()
+
+    # ctors
+    def astype(self, dtype, order="K", casting="unsafe", subok=True, copy=True):
+        if order != "K":
+            raise NotImplementedError(f"astype(..., order={order} is not implemented.")
+        if casting != "unsafe":
+            raise NotImplementedError(
+                f"astype(..., casting={casting} is not implemented."
+            )
+        if not subok:
+            raise NotImplementedError(f"astype(..., subok={subok} is not implemented.")
+        if not copy:
+            raise NotImplementedError(f"astype(..., copy={copy} is not implemented.")
+        torch_dtype = _dtypes.dtype(dtype).torch_dtype
+        t = self.tensor.to(torch_dtype)
+        return ndarray(t)
+
+    @normalizer
+    def copy(self: ArrayLike, order: NotImplementedType = "C"):
+        return self.clone()
+
+    @normalizer
+    def flatten(self: ArrayLike, order: NotImplementedType = "C"):
+        return torch.flatten(self)
+
+    def resize(self, *new_shape, refcheck=False):
+        # NB: differs from np.resize: fills with zeros instead of making repeated copies of input.
+        if refcheck:
+            raise NotImplementedError(
+                f"resize(..., refcheck={refcheck} is not implemented."
+            )
+        if new_shape in [(), (None,)]:
+            return
+
+        # support both x.resize((2, 2)) and x.resize(2, 2)
+        if len(new_shape) == 1:
+            new_shape = new_shape[0]
+        if isinstance(new_shape, int):
+            new_shape = (new_shape,)
+
+        if builtins.any(x < 0 for x in new_shape):
+            raise ValueError("all elements of `new_shape` must be non-negative")
+
+        new_numel, old_numel = math.prod(new_shape), self.tensor.numel()
+
+        self.tensor.resize_(new_shape)
+
+        if new_numel >= old_numel:
+            # zero-fill new elements
+            if not self.tensor.is_contiguous():
+                raise AssertionError("tensor must be contiguous for resize with growth")
+            b = self.tensor.flatten()  # does not copy
+            b[old_numel:].zero_()
+
+    def view(self, dtype=_Unspecified.unspecified, type=_Unspecified.unspecified):
+        if dtype is _Unspecified.unspecified:
+            dtype = self.dtype
+        if type is not _Unspecified.unspecified:
+            raise NotImplementedError(f"view(..., type={type} is not implemented.")
+        torch_dtype = _dtypes.dtype(dtype).torch_dtype
+        tview = self.tensor.view(torch_dtype)
+        return ndarray(tview)
+
+    @normalizer
+    def fill(self, value: ArrayLike):
+        # Both Pytorch and NumPy accept 0D arrays/tensors and scalars, and
+        # error out on D > 0 arrays
+        self.tensor.fill_(value)
+
+    def tolist(self):
+        return self.tensor.tolist()
+
+    def __iter__(self):
+        return (ndarray(x) for x in self.tensor.__iter__())
+
+    def __str__(self):
+        return (
+            str(self.tensor)
+            .replace("tensor", "torch.ndarray")
+            .replace("dtype=torch.", "dtype=")
+        )
+
+    __repr__ = create_method(__str__)
+
+    def __eq__(self, other):
+        try:
+            return _ufuncs.equal(self, other)
+        except (RuntimeError, TypeError):
+            # Failed to convert other to array: definitely not equal.
+            falsy = torch.full(self.shape, fill_value=False, dtype=bool)
+            return asarray(falsy)
+
+    def __ne__(self, other):
+        return ~(self == other)
+
+    def __index__(self):
+        try:
+            return operator.index(self.tensor.item())
+        except Exception as exc:
+            raise TypeError(
+                "only integer scalar arrays can be converted to a scalar index"
+            ) from exc
+
+    def __bool__(self):
+        return bool(self.tensor)
+
+    def __int__(self):
+        return int(self.tensor)
+
+    def __float__(self):
+        return float(self.tensor)
+
+    def __complex__(self):
+        return complex(self.tensor)
+
+    def is_integer(self):
+        try:
+            v = self.tensor.item()
+            result = int(v) == v
+        except Exception:
+            result = False
+        return result
+
+    def __len__(self):
+        return self.tensor.shape[0]
+
+    def __contains__(self, x):
+        return self.tensor.__contains__(x)
+
+    def transpose(self, *axes):
+        # np.transpose(arr, axis=None) but arr.transpose(*axes)
+        return _funcs.transpose(self, axes)
+
+    def reshape(self, *shape, order="C"):
+        # arr.reshape(shape) and arr.reshape(*shape)
+        return _funcs.reshape(self, shape, order=order)
+
+    def sort(self, axis=-1, kind=None, order=None):
+        # ndarray.sort works in-place
+        _funcs.copyto(self, _funcs.sort(self, axis, kind, order))
+
+    def item(self, *args):
+        # Mimic NumPy's implementation with three special cases (no arguments,
+        # a flat index and a multi-index):
+        # https://github.com/numpy/numpy/blob/main/numpy/_core/src/multiarray/methods.c#L702
+        if args == ():
+            return self.tensor.item()
+        elif len(args) == 1:
+            # int argument
+            return self.ravel()[args[0]]
+        else:
+            return self.__getitem__(args)
+
+    def __getitem__(self, index):
+        tensor = self.tensor
+
+        def neg_step(i, s):
+            if not (isinstance(s, slice) and s.step is not None and s.step < 0):
+                return s
+
+            nonlocal tensor
+            tensor = torch.flip(tensor, (i,))
+
+            # Account for the fact that a slice includes the start but not the end
+            if not (isinstance(s.start, int) or s.start is None):
+                raise AssertionError(
+                    f"slice start must be int or None, got {type(s.start).__name__}"
+                )
+            if not (isinstance(s.stop, int) or s.stop is None):
+                raise AssertionError(
+                    f"slice stop must be int or None, got {type(s.stop).__name__}"
+                )
+            start = s.stop + 1 if s.stop else None
+            stop = s.start + 1 if s.start else None
+
+            return slice(start, stop, -s.step)
+
+        if isinstance(index, Sequence):
+            index = type(index)(neg_step(i, s) for i, s in enumerate(index))
+        else:
+            index = neg_step(0, index)
+        index = _util.ndarrays_to_tensors(index)
+        index = _upcast_int_indices(index)
+        # Apply NumPy-compatible indexing conversion
+        index = _numpy_compatible_indexing(index)
+        # Apply NumPy-compatible empty ellipsis behavior
+        index, maybe_squeeze, _ = _numpy_empty_ellipsis_patch(index, tensor.ndim)
+        return maybe_squeeze(ndarray(tensor.__getitem__(index)))
+
+    def __setitem__(self, index, value):
+        index = _util.ndarrays_to_tensors(index)
+        index = _upcast_int_indices(index)
+        # Apply NumPy-compatible indexing conversion
+        index = _numpy_compatible_indexing(index)
+        # Apply NumPy-compatible empty ellipsis behavior
+        index, _, maybe_unsqueeze = _numpy_empty_ellipsis_patch(index, self.tensor.ndim)
+
+        if not _dtypes_impl.is_scalar(value):
+            value = normalize_array_like(value)
+            value = _util.cast_if_needed(value, self.tensor.dtype)
+
+        return self.tensor.__setitem__(index, maybe_unsqueeze(value))
+
+    take = _funcs.take
+    put = _funcs.put
+
+    def __dlpack__(self, *, stream=None):
+        return self.tensor.__dlpack__(stream=stream)
+
+    def __dlpack_device__(self):
+        return self.tensor.__dlpack_device__()
+
+
+def _tolist(obj):
+    """Recursively convert tensors into lists."""
+    a1 = []
+    for elem in obj:
+        if isinstance(elem, (list, tuple)):
+            elem = _tolist(elem)
+        if isinstance(elem, ndarray):
+            a1.append(elem.tensor.tolist())
+        else:
+            a1.append(elem)
+    return a1
+
+
+# This is the ideally the only place which talks to ndarray directly.
+# The rest goes through asarray (preferred) or array.
+
+
+def array(obj, dtype=None, *, copy=True, order="K", subok=False, ndmin=0, like=None):
+    if subok is not False:
+        raise NotImplementedError("'subok' parameter is not supported.")
+    if like is not None:
+        raise NotImplementedError("'like' parameter is not supported.")
+    if order != "K":
+        raise NotImplementedError
+
+    # a happy path
+    if (
+        isinstance(obj, ndarray)
+        and copy is False
+        and dtype is None
+        and ndmin <= obj.ndim
+    ):
+        return obj
+
+    if isinstance(obj, (list, tuple)):
+        # FIXME and they have the same dtype, device, etc
+        if obj and all(isinstance(x, torch.Tensor) for x in obj):
+            # list of arrays: *under torch.Dynamo* these are FakeTensors
+            obj = torch.stack(obj)
+        else:
+            # XXX: remove tolist
+            # lists of ndarrays: [1, [2, 3], ndarray(4)] convert to lists of lists
+            obj = _tolist(obj)
+
+    # is obj an ndarray already?
+    if isinstance(obj, ndarray):
+        obj = obj.tensor
+
+    # is a specific dtype requested?
+    torch_dtype = None
+    if dtype is not None:
+        torch_dtype = _dtypes.dtype(dtype).torch_dtype
+
+    tensor = _util._coerce_to_tensor(obj, torch_dtype, copy, ndmin)
+    return ndarray(tensor)
+
+
+def asarray(a, dtype=None, order="K", *, like=None):
+    return array(a, dtype=dtype, order=order, like=like, copy=False, ndmin=0)
+
+
+def ascontiguousarray(a, dtype=None, *, like=None):
+    arr = asarray(a, dtype=dtype, like=like)
+    if not arr.tensor.is_contiguous():
+        arr.tensor = arr.tensor.contiguous()
+    return arr
+
+
+def from_dlpack(x, /):
+    t = torch.from_dlpack(x)
+    return ndarray(t)
+
+
+def _extract_dtype(entry):
+    try:
+        dty = _dtypes.dtype(entry)
+    except Exception:
+        dty = asarray(entry).dtype
+    return dty
+
+
+def can_cast(from_, to, casting="safe"):
+    from_ = _extract_dtype(from_)
+    to_ = _extract_dtype(to)
+
+    return _dtypes_impl.can_cast_impl(from_.torch_dtype, to_.torch_dtype, casting)
+
+
+def result_type(*arrays_and_dtypes):
+    tensors = []
+    for entry in arrays_and_dtypes:
+        try:
+            t = asarray(entry).tensor
+        except (RuntimeError, ValueError, TypeError):
+            dty = _dtypes.dtype(entry)
+            t = torch.empty(1, dtype=dty.torch_dtype)
+        tensors.append(t)
+
+    torch_dtype = _dtypes_impl.result_type_impl(*tensors)
+    return _dtypes.dtype(torch_dtype)

.venv/lib/python3.12/site-packages/torch/_numpy/_normalizations.py

@@ -0,0 +1,349 @@
+""" "Normalize" arguments: convert array_likes to tensors, dtypes to torch dtypes and so on."""
+
+from __future__ import annotations
+
+import functools
+import inspect
+import operator
+import typing
+from typing import TYPE_CHECKING
+
+import torch
+
+from . import _dtypes, _dtypes_impl, _util
+
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from ._ndarray import ndarray
+
+
+# These names are used both as static type annotations and as runtime markers:
+# the `normalizer` decorator dispatches on the *string* form of each parameter's
+# annotation (e.g. "ArrayLike", "OutArray | None"). Because `from __future__
+# import annotations` is active everywhere these are used, the annotations are
+# never evaluated, so the static type below is what each parameter resolves to
+# *after* normalization runs (e.g. an ArrayLike argument is a torch.Tensor by the
+# time the implementer body sees it).
+ArrayLike: typing.TypeAlias = torch.Tensor
+Scalar = int | float | complex | bool
+ArrayLikeOrScalar = ArrayLike | Scalar
+
+# DTypeLike normalizes to a torch.dtype (or None when no dtype is given).
+DTypeLike: typing.TypeAlias = "torch.dtype | None"
+# AxisLike is an axis specification: a single axis, a tuple of axes, or None.
+AxisLike: typing.TypeAlias = "int | tuple[int, ...] | None"
+# NDArray normalizes to the wrapped tensor.
+NDArray: typing.TypeAlias = torch.Tensor
+# CastingModes is one of the numpy casting strings.
+CastingModes: typing.TypeAlias = str
+# KeepDims is the keepdims flag; handled entirely by the normalizer.
+KeepDims: typing.TypeAlias = bool
+
+# OutArray is to annotate the out= array argument.
+#
+# This one is special is several respects:
+# First, It needs to be an NDArray, and we need to preserve the `result is out`
+# semantics. Therefore, we cannot just extract the Tensor from the out array.
+# So we never pass the out array to implementer functions and handle it in the
+# `normalizer` below.
+# Second, the out= argument can be either keyword or positional argument, and
+# as a positional arg, it can be anywhere in the signature.
+# To handle all this, we define a special `OutArray` annotation and dispatch on it.
+#
+OutArray: typing.TypeAlias = "ndarray"
+
+# NotImplementedType marks unsupported parameters; the normalizer raises unless
+# the argument equals the (always None) default, so the value is never used.
+NotImplementedType: typing.TypeAlias = None
+
+
+def normalize_array_like(
+    x: object,
+    parm: inspect.Parameter | None = None,  # codespell:ignore
+) -> torch.Tensor:
+    from ._ndarray import asarray
+
+    return asarray(x).tensor
+
+
+def normalize_array_like_or_scalar(
+    x: object,
+    parm: inspect.Parameter | None = None,  # codespell:ignore
+) -> torch.Tensor | Scalar:
+    if _dtypes_impl.is_scalar_or_symbolic(x):
+        return x  # pyrefly: ignore[bad-return]
+    return normalize_array_like(x, parm)  # codespell:ignore
+
+
+def normalize_optional_array_like_or_scalar(
+    x: object,
+    parm: inspect.Parameter | None = None,  # codespell:ignore
+) -> torch.Tensor | Scalar | None:
+    if x is None:
+        return None
+    return normalize_array_like_or_scalar(x, parm)  # codespell:ignore
+
+
+def normalize_optional_array_like(
+    x: object,
+    parm: inspect.Parameter | None = None,  # codespell:ignore
+) -> torch.Tensor | None:
+    # This explicit normalizer is needed because otherwise normalize_array_like
+    # does not run for a parameter annotated as Optional[ArrayLike]
+    return None if x is None else normalize_array_like(x, parm)  # codespell:ignore
+
+
+def normalize_seq_array_like(
+    x: typing.Iterable[object],
+    parm: inspect.Parameter | None = None,  # codespell:ignore
+) -> tuple[torch.Tensor, ...]:
+    return tuple(normalize_array_like(value) for value in x)
+
+
+def normalize_dtype(
+    dtype: object,
+    parm: inspect.Parameter | None = None,  # codespell:ignore
+) -> torch.dtype | None:
+    # cf _decorators.dtype_to_torch
+    torch_dtype = None
+    if dtype is not None:
+        torch_dtype = _dtypes.dtype(dtype).torch_dtype
+    return torch_dtype
+
+
+def normalize_not_implemented(
+    arg: object,
+    parm: inspect.Parameter,  # codespell:ignore
+) -> None:
+    if arg != parm.default:  # codespell:ignore
+        raise NotImplementedError(
+            f"'{parm.name}' parameter is not supported."  # codespell:ignore
+        )
+
+
+def normalize_axis_like(
+    arg: AxisLike | ndarray,
+    parm: inspect.Parameter | None = None,  # codespell:ignore
+) -> AxisLike:
+    from ._ndarray import ndarray
+
+    if isinstance(arg, ndarray):
+        return operator.index(arg)
+    return arg
+
+
+def normalize_ndarray(
+    arg: object,
+    parm: inspect.Parameter | None = None,  # codespell:ignore
+) -> torch.Tensor | None:
+    # check the arg is an ndarray, extract its tensor attribute
+    if arg is None:
+        return arg
+
+    from ._ndarray import ndarray
+
+    if not isinstance(arg, ndarray):
+        name = parm.name if parm is not None else "argument"  # codespell:ignore
+        raise TypeError(f"'{name}' must be an array")
+    return arg.tensor
+
+
+def normalize_outarray(
+    arg: object,
+    parm: inspect.Parameter | None = None,  # codespell:ignore
+) -> ndarray | None:
+    # almost normalize_ndarray, only return the array, not its tensor
+    if arg is None:
+        return arg
+    from ._ndarray import ndarray
+
+    # Dynamo can pass torch tensors as out arguments,
+    # wrap it in an ndarray before processing
+    if isinstance(arg, torch.Tensor):
+        arg = ndarray(arg)
+
+    if not isinstance(arg, ndarray):
+        name = parm.name if parm is not None else "argument"  # codespell:ignore
+        raise TypeError(f"'{name}' must be an array")
+    return arg
+
+
+def normalize_casting(
+    arg: object,
+    parm: inspect.Parameter | None = None,  # codespell:ignore
+) -> CastingModes:
+    valid = ("no", "equiv", "safe", "same_kind", "unsafe")
+    if not isinstance(arg, str) or arg not in valid:
+        raise ValueError(
+            f"casting must be one of 'no', 'equiv', 'safe', 'same_kind', or 'unsafe' (got '{arg}')"
+        )
+    return arg
+
+
+# The registered normalizers have intentionally heterogeneous signatures
+# (e.g. normalize_seq_array_like takes an iterable), so the common callable
+# type erases the parameter list.
+normalizers: dict[str, Callable[..., object]] = {
+    "ArrayLike": normalize_array_like,
+    "ArrayLikeOrScalar": normalize_array_like_or_scalar,
+    "Optional[ArrayLike]": normalize_optional_array_like,
+    "ArrayLike | None": normalize_optional_array_like,
+    "Sequence[ArrayLike]": normalize_seq_array_like,
+    "Optional[ArrayLikeOrScalar]": normalize_optional_array_like_or_scalar,
+    "ArrayLikeOrScalar | None": normalize_optional_array_like_or_scalar,
+    "Optional[NDArray]": normalize_ndarray,
+    "NDArray | None": normalize_ndarray,
+    "Optional[OutArray]": normalize_outarray,
+    "OutArray | None": normalize_outarray,
+    "NDArray": normalize_ndarray,
+    "Optional[DTypeLike]": normalize_dtype,
+    "DTypeLike | None": normalize_dtype,
+    "AxisLike": normalize_axis_like,
+    "NotImplementedType": normalize_not_implemented,
+    "Optional[CastingModes]": normalize_casting,
+    "CastingModes | None": normalize_casting,
+}
+
+
+def maybe_normalize(arg: object, parm: inspect.Parameter) -> object:  # codespell:ignore
+    """Normalize arg if a normalizer is registered."""
+    normalizer = normalizers.get(parm.annotation)  # codespell:ignore
+    return normalizer(arg, parm) if normalizer else arg  # codespell:ignore
+
+
+# ### Return value helpers ###
+
+
+def maybe_copy_to(
+    out: ndarray | None, result: object, promote_scalar_result: bool = False
+) -> object:
+    # NB: here out is either an ndarray or None
+    if out is None:
+        return result
+    elif isinstance(result, torch.Tensor):
+        if result.shape != out.shape:
+            can_fit = result.numel() == 1 and out.ndim == 0
+            if promote_scalar_result and can_fit:
+                result = result.squeeze()
+            else:
+                raise ValueError(
+                    f"Bad size of the out array: out.shape = {out.shape}"
+                    f" while result.shape = {result.shape}."
+                )
+        out.tensor.copy_(result)
+        return out
+    elif isinstance(result, (tuple, list)):
+        return type(result)(
+            maybe_copy_to(o, r, promote_scalar_result) for o, r in zip(out, result)
+        )
+    else:
+        raise AssertionError  # We should never hit this path
+
+
+def wrap_tensors(result: object) -> object:
+    from ._ndarray import ndarray
+
+    if isinstance(result, torch.Tensor):
+        return ndarray(result)
+    elif isinstance(result, (tuple, list)):
+        result = type(result)(wrap_tensors(x) for x in result)
+    return result
+
+
+def array_or_scalar(
+    values: torch.Tensor,
+    py_type: type[int | float | complex | bool] = float,
+    return_scalar: bool = False,
+) -> int | float | complex | bool | ndarray:
+    if return_scalar:
+        return py_type(values.item())
+    else:
+        from ._ndarray import ndarray
+
+        return ndarray(values)
+
+
+# ### The main decorator to normalize arguments / postprocess the output ###
+
+_P = typing.ParamSpec("_P")
+_R = typing.TypeVar("_R")
+
+
+@typing.overload
+def normalizer(_func: Callable[_P, _R]) -> Callable[_P, _R]: ...
+
+
+@typing.overload
+def normalizer(
+    _func: None = None, *, promote_scalar_result: bool = False
+) -> Callable[[Callable[_P, _R]], Callable[_P, _R]]: ...
+
+
+def normalizer(
+    _func: Callable[_P, _R] | None = None, *, promote_scalar_result: bool = False
+) -> Callable[_P, _R] | Callable[[Callable[_P, _R]], Callable[_P, _R]]:
+    def normalizer_inner(func: Callable[_P, _R]) -> Callable[_P, _R]:
+        @functools.wraps(func)
+        def wrapped(*args: _P.args, **kwds: _P.kwargs) -> _R:
+            sig = inspect.signature(func)
+            params = sig.parameters
+            first_param = next(iter(params.values()))
+
+            # NumPy's API does not have positional args before variadic positional args
+            norm_args: tuple[object, ...]
+            if first_param.kind == inspect.Parameter.VAR_POSITIONAL:
+                norm_args = tuple(maybe_normalize(arg, first_param) for arg in args)
+            else:
+                # NB: extra unknown arguments: pass through, will raise in func(*args) below
+                norm_args = (
+                    tuple(
+                        maybe_normalize(arg, parm)  # codespell:ignore
+                        for arg, parm in zip(args, params.values())  # codespell:ignore
+                    )
+                    + args[len(params.values()) :]
+                )
+
+            norm_kwds = {
+                name: maybe_normalize(arg, params[name]) if name in params else arg
+                for name, arg in kwds.items()
+            }
+
+            # The normalizer rebuilds args/kwds, so they are no longer the
+            # ParamSpec-tracked *args/**kwargs; the call is correct at runtime.
+            # pyrefly: ignore[invalid-param-spec]
+            result: object = func(*norm_args, **norm_kwds)
+
+            # keepdims
+            bound_args = None
+            if "keepdims" in params and params["keepdims"].annotation == "KeepDims":
+                # keepdims can be in any position so we need sig.bind
+                bound_args = sig.bind(*norm_args, **norm_kwds).arguments
+                if bound_args.get("keepdims", False):
+                    # In this case the first arg is the initial tensor and
+                    # the second arg is (optionally) the axis
+                    tensor = norm_args[0]
+                    axis = bound_args.get("axis")
+                    if not isinstance(tensor, torch.Tensor):
+                        raise AssertionError("keepdims requires a tensor first arg")
+                    # pyrefly: ignore[bad-argument-type]
+                    result = _util.apply_keepdims(result, axis, tensor.ndim)
+
+            # out
+            if "out" in params:
+                # out can be in any position so we need sig.bind
+                if bound_args is None:
+                    bound_args = sig.bind(*norm_args, **norm_kwds).arguments
+                out = bound_args.get("out")
+                result = maybe_copy_to(out, result, promote_scalar_result)
+            result = wrap_tensors(result)
+
+            return result  # pyrefly: ignore[bad-return]
+
+        return wrapped
+
+    if _func is None:
+        return normalizer_inner
+    else:
+        return normalizer_inner(_func)

.venv/lib/python3.12/site-packages/torch/_numpy/_reductions_impl.py

@@ -0,0 +1,480 @@
+"""Implementation of reduction operations, to be wrapped into arrays, dtypes etc
+in the 'public' layer.
+
+Anything here only deals with torch objects, e.g. "dtype" is a torch.dtype instance etc
+"""
+
+from __future__ import annotations
+
+import functools
+from typing import Concatenate, ParamSpec, TYPE_CHECKING, TypeVar
+
+import torch
+
+from . import _dtypes_impl, _util
+
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from ._normalizations import (
+        ArrayLike,
+        AxisLike,
+        DTypeLike,
+        KeepDims,
+        NotImplementedType,
+        OutArray,
+    )
+
+
+_P = ParamSpec("_P")
+_R = TypeVar("_R")
+
+
+def _deco_axis_expand(
+    func: Callable[Concatenate[torch.Tensor, AxisLike, _P], _R],
+) -> Callable[Concatenate[torch.Tensor, AxisLike, _P], _R]:
+    """
+    Generically handle axis arguments in reductions.
+    axis is *always* the 2nd arg in the function so no need to have a look at its signature
+    """
+
+    @functools.wraps(func)
+    def wrapped(
+        a: torch.Tensor, axis: AxisLike = None, *args: _P.args, **kwds: _P.kwargs
+    ) -> _R:
+        if axis is not None:
+            axis = _util.normalize_axis_tuple(axis, a.ndim)
+
+        if axis == ():
+            # So we insert a length-one axis and run the reduction along it.
+            # We cannot return a.clone() as this would sidestep the checks inside the function
+            newshape = _util.expand_shape(a.shape, axis=0)
+            a = a.reshape(newshape)
+            axis = (0,)
+
+        return func(a, axis, *args, **kwds)
+
+    return wrapped
+
+
+def _atleast_float(dtype: torch.dtype | None, other_dtype: torch.dtype) -> torch.dtype:
+    """Return a dtype that is real or complex floating-point.
+
+    For inputs that are boolean or integer dtypes, this returns the default
+    float dtype; inputs that are complex get converted to the default complex
+    dtype; real floating-point dtypes (`float*`) get passed through unchanged
+    """
+    if dtype is None:
+        dtype = other_dtype
+    if not (dtype.is_floating_point or dtype.is_complex):
+        return _dtypes_impl.default_dtypes().float_dtype
+    return dtype
+
+
+@_deco_axis_expand
+def count_nonzero(
+    a: ArrayLike, axis: AxisLike = None, *, keepdims: KeepDims = False
+) -> torch.Tensor:
+    return a.count_nonzero(axis)
+
+
+@_deco_axis_expand
+def argmax(
+    a: ArrayLike,
+    axis: AxisLike = None,
+    out: OutArray | None = None,
+    *,
+    keepdims: KeepDims = False,
+) -> torch.Tensor:
+    if a.is_complex():
+        raise NotImplementedError(f"argmax with dtype={a.dtype}.")
+
+    axis = _util.allow_only_single_axis(axis)
+
+    if a.dtype == torch.bool:
+        # RuntimeError: "argmax_cpu" not implemented for 'Bool'
+        a = a.to(torch.uint8)
+
+    return torch.argmax(a, axis)
+
+
+@_deco_axis_expand
+def argmin(
+    a: ArrayLike,
+    axis: AxisLike = None,
+    out: OutArray | None = None,
+    *,
+    keepdims: KeepDims = False,
+) -> torch.Tensor:
+    if a.is_complex():
+        raise NotImplementedError(f"argmin with dtype={a.dtype}.")
+
+    axis = _util.allow_only_single_axis(axis)
+
+    if a.dtype == torch.bool:
+        # RuntimeError: "argmin_cpu" not implemented for 'Bool'
+        a = a.to(torch.uint8)
+
+    return torch.argmin(a, axis)
+
+
+@_deco_axis_expand
+def any(
+    a: ArrayLike,
+    axis: AxisLike = None,
+    out: OutArray | None = None,
+    keepdims: KeepDims = False,
+    *,
+    where: NotImplementedType = None,
+) -> torch.Tensor:
+    axis = _util.allow_only_single_axis(axis)
+    return torch.any(a) if axis is None else torch.any(a, dim=axis)
+
+
+@_deco_axis_expand
+def all(
+    a: ArrayLike,
+    axis: AxisLike = None,
+    out: OutArray | None = None,
+    keepdims: KeepDims = False,
+    *,
+    where: NotImplementedType = None,
+) -> torch.Tensor:
+    axis = _util.allow_only_single_axis(axis)
+    return torch.all(a) if axis is None else torch.all(a, dim=axis)
+
+
+@_deco_axis_expand
+def amax(
+    a: ArrayLike,
+    axis: AxisLike = None,
+    out: OutArray | None = None,
+    keepdims: KeepDims = False,
+    initial: NotImplementedType = None,
+    where: NotImplementedType = None,
+) -> torch.Tensor:
+    if a.is_complex():
+        raise NotImplementedError(f"amax with dtype={a.dtype}")
+
+    return a.amax() if axis is None else a.amax(axis)
+
+
+max = amax
+
+
+@_deco_axis_expand
+def amin(
+    a: ArrayLike,
+    axis: AxisLike = None,
+    out: OutArray | None = None,
+    keepdims: KeepDims = False,
+    initial: NotImplementedType = None,
+    where: NotImplementedType = None,
+) -> torch.Tensor:
+    if a.is_complex():
+        raise NotImplementedError(f"amin with dtype={a.dtype}")
+
+    return a.amin() if axis is None else a.amin(axis)
+
+
+min = amin
+
+
+@_deco_axis_expand
+def ptp(
+    a: ArrayLike,
+    axis: AxisLike = None,
+    out: OutArray | None = None,
+    keepdims: KeepDims = False,
+) -> torch.Tensor:
+    amax = a.amax() if axis is None else a.amax(axis)
+    amin = a.amin() if axis is None else a.amin(axis)
+    return amax - amin
+
+
+@_deco_axis_expand
+def sum(
+    a: ArrayLike,
+    axis: AxisLike = None,
+    dtype: DTypeLike | None = None,
+    out: OutArray | None = None,
+    keepdims: KeepDims = False,
+    initial: NotImplementedType = None,
+    where: NotImplementedType = None,
+) -> torch.Tensor:
+    if dtype is not None and not isinstance(dtype, torch.dtype):
+        raise AssertionError(
+            f"dtype must be None or a torch.dtype, got {type(dtype).__name__}"
+        )
+
+    if dtype == torch.bool:
+        dtype = _dtypes_impl.default_dtypes().int_dtype
+
+    if axis is None:
+        return a.sum(dtype=dtype)
+    return a.sum(dim=axis, dtype=dtype)
+
+
+@_deco_axis_expand
+def prod(
+    a: ArrayLike,
+    axis: AxisLike = None,
+    dtype: DTypeLike | None = None,
+    out: OutArray | None = None,
+    keepdims: KeepDims = False,
+    initial: NotImplementedType = None,
+    where: NotImplementedType = None,
+) -> torch.Tensor:
+    axis = _util.allow_only_single_axis(axis)
+
+    if dtype == torch.bool:
+        dtype = _dtypes_impl.default_dtypes().int_dtype
+
+    if axis is None:
+        return a.prod(dtype=dtype)
+    return a.prod(dim=axis, dtype=dtype)
+
+
+product = prod
+
+
+@_deco_axis_expand
+def mean(
+    a: ArrayLike,
+    axis: AxisLike = None,
+    dtype: DTypeLike | None = None,
+    out: OutArray | None = None,
+    keepdims: KeepDims = False,
+    *,
+    where: NotImplementedType = None,
+) -> torch.Tensor:
+    dtype = _atleast_float(dtype, a.dtype)
+
+    if axis is None:
+        return a.mean(dtype=dtype)
+    return a.mean(dim=axis, dtype=dtype)
+
+
+@_deco_axis_expand
+def std(
+    a: ArrayLike,
+    axis: AxisLike = None,
+    dtype: DTypeLike | None = None,
+    out: OutArray | None = None,
+    ddof: float = 0,
+    keepdims: KeepDims = False,
+    *,
+    where: NotImplementedType = None,
+) -> torch.Tensor:
+    in_dtype = dtype
+    dtype = _atleast_float(dtype, a.dtype)
+    tensor = _util.cast_if_needed(a, dtype)
+    result = tensor.std(dim=axis, correction=ddof)
+    return _util.cast_if_needed(result, in_dtype)
+
+
+@_deco_axis_expand
+def var(
+    a: ArrayLike,
+    axis: AxisLike = None,
+    dtype: DTypeLike | None = None,
+    out: OutArray | None = None,
+    ddof: float = 0,
+    keepdims: KeepDims = False,
+    *,
+    where: NotImplementedType = None,
+) -> torch.Tensor:
+    in_dtype = dtype
+    dtype = _atleast_float(dtype, a.dtype)
+    tensor = _util.cast_if_needed(a, dtype)
+    result = tensor.var(dim=axis, correction=ddof)
+    return _util.cast_if_needed(result, in_dtype)
+
+
+# cumsum / cumprod are almost reductions:
+#   1. no keepdims
+#   2. axis=None flattens
+
+
+def cumsum(
+    a: ArrayLike,
+    axis: AxisLike = None,
+    dtype: DTypeLike | None = None,
+    out: OutArray | None = None,
+) -> torch.Tensor:
+    if dtype == torch.bool:
+        dtype = _dtypes_impl.default_dtypes().int_dtype
+    if dtype is None:
+        dtype = a.dtype
+
+    # pyrefly: ignore[bad-argument-type]
+    (a,), axis = _util.axis_none_flatten(a, axis=axis)
+    axis = _util.normalize_axis_index(axis, a.ndim)
+
+    # torch accepts the numpy-compat `axis=` alias, but its stub only lists `dim`.
+    # pyrefly: ignore[missing-argument, unexpected-keyword]
+    return a.cumsum(axis=axis, dtype=dtype)
+
+
+def cumprod(
+    a: ArrayLike,
+    axis: AxisLike = None,
+    dtype: DTypeLike | None = None,
+    out: OutArray | None = None,
+) -> torch.Tensor:
+    if dtype == torch.bool:
+        dtype = _dtypes_impl.default_dtypes().int_dtype
+    if dtype is None:
+        dtype = a.dtype
+
+    # pyrefly: ignore[bad-argument-type]
+    (a,), axis = _util.axis_none_flatten(a, axis=axis)
+    axis = _util.normalize_axis_index(axis, a.ndim)
+
+    # torch accepts the numpy-compat `axis=` alias, but its stub only lists `dim`.
+    # pyrefly: ignore[missing-argument, unexpected-keyword]
+    return a.cumprod(axis=axis, dtype=dtype)
+
+
+cumproduct = cumprod
+
+
+def average(
+    a: ArrayLike,
+    axis: int | None = None,
+    weights: ArrayLike | None = None,
+    returned: bool = False,
+    *,
+    keepdims: bool = False,
+) -> torch.Tensor | tuple[torch.Tensor, torch.Tensor]:
+    if weights is None:
+        result = mean(a, axis)
+        wsum = torch.as_tensor(a.numel() / result.numel(), dtype=result.dtype)
+    else:
+        if not a.dtype.is_floating_point:
+            a = a.double()
+
+        # axis & weights
+        if a.shape != weights.shape:
+            if axis is None:
+                raise TypeError(
+                    "Axis must be specified when shapes of a and weights differ."
+                )
+            if weights.ndim != 1:
+                raise TypeError(
+                    "1D weights expected when shapes of a and weights differ."
+                )
+            if weights.shape[0] != a.shape[axis]:
+                raise ValueError(
+                    "Length of weights not compatible with specified axis."
+                )
+
+            # setup weight to broadcast along axis
+            weights = torch.broadcast_to(weights, (a.ndim - 1) * (1,) + weights.shape)
+            weights = weights.swapaxes(-1, axis)
+
+        # do the work
+        result_dtype = _dtypes_impl.result_type_impl(a, weights)
+        numerator = sum(a * weights, axis, dtype=result_dtype)
+        wsum = sum(weights, axis, dtype=result_dtype)
+        result = numerator / wsum
+
+    # We process keepdims manually because the decorator does not deal with variadic returns
+    if keepdims:
+        result = _util.apply_keepdims(result, axis, a.ndim)
+
+    if returned:
+        if wsum.shape != result.shape:
+            wsum = torch.broadcast_to(wsum, result.shape).clone()
+        return result, wsum
+    else:
+        return result
+
+
+# Not using deco_axis_expand as it assumes that axis is the second arg
+def quantile(
+    a: ArrayLike,
+    q: ArrayLike,
+    axis: AxisLike = None,
+    out: OutArray | None = None,
+    overwrite_input: bool = False,
+    method: str = "linear",
+    keepdims: KeepDims = False,
+    *,
+    interpolation: NotImplementedType = None,
+) -> torch.Tensor:
+    if overwrite_input:
+        # raise NotImplementedError("overwrite_input in quantile not implemented.")
+        # NumPy documents that `overwrite_input` MAY modify inputs:
+        # https://numpy.org/doc/stable/reference/generated/numpy.percentile.html#numpy-percentile
+        # Here we choose to work out-of-place because why not.
+        pass
+
+    if not a.dtype.is_floating_point:
+        dtype = _dtypes_impl.default_dtypes().float_dtype
+        a = a.to(dtype)
+
+    # edge case: torch.quantile only supports float32 and float64
+    if a.dtype == torch.float16:
+        a = a.to(torch.float32)
+
+    if axis is None:
+        a = a.flatten()
+        q = q.flatten()
+        axis = (0,)
+    else:
+        axis = _util.normalize_axis_tuple(axis, a.ndim)
+
+    # FIXME(Mario) Doesn't np.quantile accept a tuple?
+    # torch.quantile does accept a number. If we don't want to implement the tuple behaviour
+    # (it's deffo low prio) change `normalize_axis_tuple` into a normalize_axis index above.
+    axis = _util.allow_only_single_axis(axis)
+
+    q = _util.cast_if_needed(q, a.dtype)
+
+    return torch.quantile(a, q, axis, interpolation=method)
+
+
+def percentile(
+    a: ArrayLike,
+    q: ArrayLike,
+    axis: AxisLike = None,
+    out: OutArray | None = None,
+    overwrite_input: bool = False,
+    method: str = "linear",
+    keepdims: KeepDims = False,
+    *,
+    interpolation: NotImplementedType = None,
+) -> torch.Tensor:
+    # np.percentile(float_tensor, 30) : q.dtype is int64 => q / 100.0 is float32
+    if _dtypes_impl.python_type_for_torch(q.dtype) is int:
+        q = q.to(_dtypes_impl.default_dtypes().float_dtype)
+    qq = q / 100.0
+
+    return quantile(
+        a,
+        qq,
+        axis=axis,
+        overwrite_input=overwrite_input,
+        method=method,
+        keepdims=keepdims,
+        interpolation=interpolation,
+    )
+
+
+def median(
+    a: ArrayLike,
+    axis: int | None = None,
+    out: OutArray | None = None,
+    overwrite_input: bool = False,
+    keepdims: KeepDims = False,
+) -> torch.Tensor:
+    return quantile(
+        a,
+        torch.as_tensor(0.5),
+        axis=axis,
+        overwrite_input=overwrite_input,
+        out=out,
+        keepdims=keepdims,
+    )

.venv/lib/python3.12/site-packages/torch/_numpy/_ufuncs.py

@@ -0,0 +1,332 @@
+# mypy: ignore-errors
+
+from __future__ import annotations
+
+import torch
+
+from . import _binary_ufuncs_impl, _dtypes_impl, _unary_ufuncs_impl, _util
+from ._normalizations import (
+    ArrayLike,
+    ArrayLikeOrScalar,
+    CastingModes,
+    DTypeLike,
+    normalizer,
+    NotImplementedType,
+    OutArray,
+)
+
+
+def _ufunc_postprocess(result, out, casting):
+    if out is not None:
+        result = _util.typecast_tensor(result, out.dtype.torch_dtype, casting)
+        result = torch.broadcast_to(result, out.shape)
+    return result
+
+
+# ############# Binary ufuncs ######################
+
+_binary = [
+    name
+    for name in dir(_binary_ufuncs_impl)
+    if not name.startswith("_") and name not in ["torch", "matmul", "divmod", "ldexp"]
+]
+
+
+NEP50_FUNCS = (
+    "add",
+    "subtract",
+    "multiply",
+    "floor_divide",
+    "true_divide",
+    "divide",
+    "remainder",
+    "bitwise_and",
+    "bitwise_or",
+    "bitwise_xor",
+    "bitwise_left_shift",
+    "bitwise_right_shift",
+    "hypot",
+    "arctan2",
+    "logaddexp",
+    "logaddexp2",
+    "heaviside",
+    "copysign",
+    "fmax",
+    "minimum",
+    "fmin",
+    "maximum",
+    "fmod",
+    "gcd",
+    "lcm",
+    "pow",
+)
+
+
+def deco_binary_ufunc(torch_func):
+    """Common infra for binary ufuncs.
+
+    Normalize arguments, sort out type casting, broadcasting and delegate to
+    the pytorch functions for the actual work.
+    """
+
+    @normalizer
+    def wrapped(
+        x1: ArrayLikeOrScalar,
+        x2: ArrayLikeOrScalar,
+        /,
+        out: OutArray | None = None,
+        *,
+        where: NotImplementedType = True,
+        casting: CastingModes | None = "same_kind",
+        order: NotImplementedType = "K",
+        dtype: DTypeLike | None = None,
+        subok: NotImplementedType = False,
+        signature: NotImplementedType = None,
+        extobj: NotImplementedType = None,
+    ):
+        if dtype is not None:
+
+            def cast(x, dtype):
+                if isinstance(x, torch.Tensor):
+                    return _util.typecast_tensor(x, dtype, casting)
+                else:
+                    return torch.as_tensor(x, dtype=dtype)
+
+            x1 = cast(x1, dtype)
+            x2 = cast(x2, dtype)
+        elif isinstance(x1, torch.Tensor) and isinstance(x2, torch.Tensor):
+            dtype = _dtypes_impl.result_type_impl(x1, x2)
+            x1, x2 = _util.typecast_tensors((x1, x2), dtype, casting)
+        else:
+            x1, x2 = _dtypes_impl.nep50_to_tensors(
+                x1, x2, torch_func.__name__ in NEP50_FUNCS, torch_func.__name__
+            )
+
+        result = torch_func(x1, x2)
+
+        return _ufunc_postprocess(result, out, casting)
+
+    wrapped.__qualname__ = torch_func.__name__
+    wrapped.__name__ = torch_func.__name__
+
+    return wrapped
+
+
+# matmul's signature is _slightly_ different from other ufuncs:
+# - no where=...
+# - additional axis=..., axes=...
+# - no NEP50 scalars in or out
+@normalizer
+def matmul(
+    x1: ArrayLike,
+    x2: ArrayLike,
+    /,
+    out: OutArray | None = None,
+    *,
+    casting: CastingModes | None = "same_kind",
+    order: NotImplementedType = "K",
+    dtype: DTypeLike | None = None,
+    subok: NotImplementedType = False,
+    signature: NotImplementedType = None,
+    extobj: NotImplementedType = None,
+    axes: NotImplementedType = None,
+    axis: NotImplementedType = None,
+):
+    if dtype is None:
+        dtype = _dtypes_impl.result_type_impl(x1, x2)
+    x1, x2 = _util.typecast_tensors((x1, x2), dtype, casting)
+
+    result = _binary_ufuncs_impl.matmul(x1, x2)
+
+    result = _ufunc_postprocess(result, out, casting)
+    return result
+
+
+# ldexp casting is special : the dtype of the result == dtype of the 1st arg
+@normalizer
+def ldexp(
+    x1: ArrayLikeOrScalar,
+    x2: ArrayLikeOrScalar,
+    /,
+    out: OutArray | None = None,
+    *,
+    where: NotImplementedType = True,
+    casting: CastingModes | None = "same_kind",
+    order: NotImplementedType = "K",
+    dtype: DTypeLike | None = None,
+    subok: NotImplementedType = False,
+    signature: NotImplementedType = None,
+    extobj: NotImplementedType = None,
+):
+    if dtype is not None:
+        if isinstance(x1, torch.Tensor):
+            x1 = _util.typecast_tensor(x1, dtype, casting)
+        else:
+            x1 = torch.as_tensor(x1, dtype=dtype)
+    else:
+        if not isinstance(x1, torch.Tensor):
+            x1 = torch.as_tensor(x1)
+            x1 = _util.cast_int_to_float(x1)
+
+    x2 = torch.as_tensor(x2)
+    # the second arg must be integer
+    if _dtypes_impl._category(x2.dtype) != 1:
+        raise ValueError("ldexp 2nd arg must be integer")
+
+    result = _binary_ufuncs_impl.ldexp(x1, x2)
+
+    if x1.dtype == torch.float16:
+        # torch.ldexp(f16, int) -> f32, undo it
+        result = result.to(torch.float16)
+
+    return _ufunc_postprocess(result, out, casting)
+
+
+# nin=2, nout=2
+@normalizer
+def divmod(
+    x1: ArrayLike,
+    x2: ArrayLike,
+    out1: OutArray | None = None,
+    out2: OutArray | None = None,
+    /,
+    out: tuple[OutArray | None, OutArray | None] = (None, None),
+    *,
+    where: NotImplementedType = True,
+    casting: CastingModes | None = "same_kind",
+    order: NotImplementedType = "K",
+    dtype: DTypeLike | None = None,
+    subok: NotImplementedType = False,
+    signature: NotImplementedType = None,
+    extobj: NotImplementedType = None,
+):
+    # make sure we either have no out arrays at all, or there is either
+    # out1, out2, or out=tuple, but not both
+    num_outs = sum(x is not None for x in [out1, out2])
+    if num_outs == 1:
+        raise ValueError("both out1 and out2 need to be provided")
+    elif num_outs == 2:
+        o1, o2 = out
+        if o1 is not None or o2 is not None:
+            raise TypeError(
+                "cannot specify 'out' as both a positional and keyword argument"
+            )
+    else:
+        out1, out2 = out
+
+    if dtype is None:
+        dtype = _dtypes_impl.result_type_impl(x1, x2)
+    x1, x2 = _util.typecast_tensors((x1, x2), dtype, casting)
+
+    quot, rem = _binary_ufuncs_impl.divmod(x1, x2)
+
+    quot = _ufunc_postprocess(quot, out1, casting)
+    rem = _ufunc_postprocess(rem, out2, casting)
+    return quot, rem
+
+
+#
+# Attach ufuncs to this module, for a further export to the public namespace in __init__.py
+#
+for name in _binary:
+    ufunc = getattr(_binary_ufuncs_impl, name)
+    vars()[name] = deco_binary_ufunc(ufunc)
+
+
+def modf(x, /, *args, **kwds):
+    quot, rem = divmod(x, 1, *args, **kwds)
+    return rem, quot
+
+
+_binary = _binary + ["divmod", "modf", "matmul", "ldexp"]
+
+
+# ############# Unary ufuncs ######################
+
+
+_unary = [
+    name
+    for name in dir(_unary_ufuncs_impl)
+    if not name.startswith("_") and name != "torch"
+]
+
+
+# these are ufunc(int) -> float
+_fp_unary = [
+    "arccos",
+    "arccosh",
+    "arcsin",
+    "arcsinh",
+    "arctan",
+    "arctanh",
+    "cbrt",
+    "cos",
+    "cosh",
+    "deg2rad",
+    "degrees",
+    "exp",
+    "exp2",
+    "expm1",
+    "log",
+    "log10",
+    "log1p",
+    "log2",
+    "rad2deg",
+    "radians",
+    "reciprocal",
+    "sin",
+    "sinh",
+    "sqrt",
+    "square",
+    "tan",
+    "tanh",
+    "trunc",
+]
+
+
+def deco_unary_ufunc(torch_func):
+    """Common infra for unary ufuncs.
+
+    Normalize arguments, sort out type casting, broadcasting and delegate to
+    the pytorch functions for the actual work.
+    """
+
+    @normalizer
+    def wrapped(
+        x: ArrayLike,
+        /,
+        out: OutArray | None = None,
+        *,
+        where=True,
+        casting: CastingModes | None = "same_kind",
+        order="K",
+        dtype: DTypeLike | None = None,
+        subok: NotImplementedType = False,
+        signature=None,
+        extobj=None,
+    ):
+        if dtype is not None:
+            x = _util.typecast_tensor(x, dtype, casting)
+
+        if torch_func.__name__ in _fp_unary:
+            x = _util.cast_int_to_float(x)
+
+        result = torch_func(x)
+        result = _ufunc_postprocess(result, out, casting)
+        return result
+
+    wrapped.__qualname__ = torch_func.__name__
+    wrapped.__name__ = torch_func.__name__
+
+    return wrapped
+
+
+#
+# Attach ufuncs to this module, for a further export to the public namespace in __init__.py
+#
+for name in _unary:
+    ufunc = getattr(_unary_ufuncs_impl, name)
+    vars()[name] = deco_unary_ufunc(ufunc)
+
+
+__all__ = _binary + _unary  # noqa: PLE0605

.venv/lib/python3.12/site-packages/torch/_numpy/_unary_ufuncs_impl.py

@@ -0,0 +1,72 @@
+# mypy: ignore-errors
+
+"""Export torch work functions for unary ufuncs, rename/tweak to match numpy.
+This listing is further exported to public symbols in the `_numpy/_ufuncs.py` module.
+"""
+
+import torch
+from torch import (  # noqa: F401
+    absolute as fabs,
+    arccos,
+    arccosh,
+    arcsin,
+    arcsinh,
+    arctan,
+    arctanh,
+    bitwise_not,
+    bitwise_not as invert,
+    ceil,
+    conj_physical as conjugate,
+    cos,
+    cosh,
+    deg2rad,
+    deg2rad as radians,
+    exp,
+    exp2,
+    expm1,
+    floor,
+    isfinite,
+    isinf,
+    isnan,
+    log,
+    log10,
+    log1p,
+    log2,
+    logical_not,
+    negative,
+    rad2deg,
+    rad2deg as degrees,
+    reciprocal,
+    round as fix,
+    round as rint,
+    sign,
+    signbit,
+    sin,
+    sinh,
+    sqrt,
+    square,
+    tan,
+    tanh,
+    trunc,
+)
+
+
+# special cases: torch does not export these names
+def cbrt(x):
+    return torch.pow(x, 1 / 3)
+
+
+def positive(x):
+    return +x
+
+
+def absolute(x):
+    # work around torch.absolute not impl for bools
+    if x.dtype == torch.bool:
+        return x
+    return torch.absolute(x)
+
+
+# TODO set __name__ and __qualname__
+abs = absolute
+conj = conjugate

.venv/lib/python3.12/site-packages/torch/_numpy/_util.py

@@ -0,0 +1,297 @@
+"""Assorted utilities, which do not need anything other than torch and stdlib."""
+
+import operator
+from collections.abc import Iterable, Sequence, Sized
+from typing import TypeGuard
+
+import torch
+
+from . import _dtypes_impl
+
+
+# https://github.com/numpy/numpy/blob/v1.23.0/numpy/distutils/misc_util.py#L497-L504
+def is_sequence(seq: object) -> TypeGuard[Sized]:
+    if isinstance(seq, str):
+        return False
+    if not isinstance(seq, Sized):
+        return False
+    try:
+        len(seq)
+    except Exception:
+        return False
+    return True
+
+
+class AxisError(ValueError, IndexError):
+    pass
+
+
+class UFuncTypeError(TypeError, RuntimeError):
+    pass
+
+
+def cast_if_needed(tensor: torch.Tensor, dtype: torch.dtype | None) -> torch.Tensor:
+    # NB: no casting if dtype=None
+    if dtype is not None and tensor.dtype != dtype:
+        tensor = tensor.to(dtype)
+    return tensor
+
+
+def cast_int_to_float(x: torch.Tensor) -> torch.Tensor:
+    # cast integers and bools to the default float dtype
+    if _dtypes_impl._category(x.dtype) < 2:
+        x = x.to(_dtypes_impl.default_dtypes().float_dtype)
+    return x
+
+
+# a replica of the version in ./numpy/numpy/core/src/multiarray/common.h
+def normalize_axis_index(ax: int, ndim: int, argname: str | None = None) -> int:
+    if not (-ndim <= ax < ndim):
+        raise AxisError(f"axis {ax} is out of bounds for array of dimension {ndim}")
+    if ax < 0:
+        ax += ndim
+    return ax
+
+
+# from https://github.com/numpy/numpy/blob/main/numpy/core/numeric.py#L1378
+def normalize_axis_tuple(
+    axis: int | Iterable[int],
+    ndim: int,
+    argname: str | None = None,
+    allow_duplicate: bool = False,
+) -> tuple[int, ...]:
+    """
+    Normalizes an axis argument into a tuple of non-negative integer axes.
+
+    This handles shorthands such as ``1`` and converts them to ``(1,)``,
+    as well as performing the handling of negative indices covered by
+    `normalize_axis_index`.
+
+    By default, this forbids axes from being specified multiple times.
+    Used internally by multi-axis-checking logic.
+
+    Parameters
+    ----------
+    axis : int, iterable of int
+        The un-normalized index or indices of the axis.
+    ndim : int
+        The number of dimensions of the array that `axis` should be normalized
+        against.
+    argname : str, optional
+        A prefix to put before the error message, typically the name of the
+        argument.
+    allow_duplicate : bool, optional
+        If False, the default, disallow an axis from being specified twice.
+
+    Returns
+    -------
+    normalized_axes : tuple of int
+        The normalized axis index, such that `0 <= normalized_axis < ndim`
+    """
+    # Optimization to speed-up the most common cases.
+    axes: Iterable[int]
+    if isinstance(axis, (tuple, list)):
+        axes = axis
+    else:
+        # operator.index handles the scalar shorthand (int and __index__-like
+        # objects); a TypeError means axis is already an iterable of ints.
+        try:
+            axes = [operator.index(axis)]  # pyrefly: ignore[bad-argument-type]
+        except TypeError:
+            axes = axis  # pyrefly: ignore[bad-assignment]
+    # Going via an iterator directly is slower than via list comprehension.
+    result = tuple(normalize_axis_index(ax, ndim, argname) for ax in axes)
+    if not allow_duplicate and len(set(map(int, result))) != len(result):
+        if argname:
+            raise ValueError(f"repeated axis in `{argname}` argument")
+        else:
+            raise ValueError("repeated axis")
+    return result
+
+
+def allow_only_single_axis(axis: int | tuple[int, ...] | None) -> int | None:
+    if axis is None:
+        return axis
+    if isinstance(axis, int):
+        return axis
+    if len(axis) != 1:
+        raise NotImplementedError("does not handle tuple axis")
+    return axis[0]
+
+
+def expand_shape(
+    arr_shape: Sequence[int], axis: int | tuple[int, ...] | list[int]
+) -> list[int]:
+    # taken from numpy 1.23.x, expand_dims function
+    axis_seq = axis if isinstance(axis, (list, tuple)) else (axis,)
+    out_ndim = len(axis_seq) + len(arr_shape)
+    normalized = normalize_axis_tuple(axis_seq, out_ndim)
+    shape_it = iter(arr_shape)
+    shape = [1 if ax in normalized else next(shape_it) for ax in range(out_ndim)]
+    return shape
+
+
+def apply_keepdims(
+    tensor: torch.Tensor, axis: int | tuple[int, ...] | None, ndim: int
+) -> torch.Tensor:
+    if axis is None:
+        # tensor was a scalar
+        shape = (1,) * ndim
+        tensor = tensor.expand(shape).contiguous()
+    else:
+        shape = expand_shape(tensor.shape, axis)
+        tensor = tensor.reshape(shape)
+    return tensor
+
+
+def axis_none_flatten(
+    *tensors: torch.Tensor, axis: int | None = None
+) -> tuple[tuple[torch.Tensor, ...], int]:
+    """Flatten the arrays if axis is None."""
+    if axis is None:
+        tensors = tuple(ar.flatten() for ar in tensors)
+        return tensors, 0
+    else:
+        return tensors, axis
+
+
+def typecast_tensor(
+    t: torch.Tensor, target_dtype: torch.dtype, casting: str
+) -> torch.Tensor:
+    """Dtype-cast tensor to target_dtype.
+
+    Parameters
+    ----------
+    t : torch.Tensor
+        The tensor to cast
+    target_dtype : torch dtype object
+        The array dtype to cast all tensors to
+    casting : str
+        The casting mode, see `np.can_cast`
+
+     Returns
+     -------
+    `torch.Tensor` of the `target_dtype` dtype
+
+     Raises
+     ------
+     ValueError
+        if the argument cannot be cast according to the `casting` rule
+
+    """
+    can_cast = _dtypes_impl.can_cast_impl
+
+    if not can_cast(t.dtype, target_dtype, casting=casting):
+        raise TypeError(
+            f"Cannot cast array data from {t.dtype} to"
+            f" {target_dtype} according to the rule '{casting}'"
+        )
+    return cast_if_needed(t, target_dtype)
+
+
+def typecast_tensors(
+    tensors: Sequence[torch.Tensor], target_dtype: torch.dtype, casting: str
+) -> tuple[torch.Tensor, ...]:
+    return tuple(typecast_tensor(t, target_dtype, casting) for t in tensors)
+
+
+def _try_convert_to_tensor(obj: object) -> torch.Tensor:
+    try:
+        tensor = torch.as_tensor(obj)
+    except Exception as e:
+        mesg = f"failed to convert {obj} to ndarray. \nInternal error is: {str(e)}."
+        raise NotImplementedError(mesg)  # noqa: B904
+    return tensor
+
+
+def _coerce_to_tensor(
+    obj: object,
+    dtype: torch.dtype | None = None,
+    copy: bool = False,
+    ndmin: int = 0,
+) -> torch.Tensor:
+    """The core logic of the array(...) function.
+
+    Parameters
+    ----------
+    obj : tensor_like
+        The thing to coerce
+    dtype : torch.dtype object or None
+        Coerce to this torch dtype
+    copy : bool
+        Copy or not
+    ndmin : int
+        The results as least this many dimensions
+    is_weak : bool
+        Whether obj is a weakly typed python scalar.
+
+    Returns
+    -------
+    tensor : torch.Tensor
+        a tensor object with requested dtype, ndim and copy semantics.
+
+    Notes
+    -----
+    This is almost a "tensor_like" coercive function. Does not handle wrapper
+    ndarrays (those should be handled in the ndarray-aware layer prior to
+    invoking this function).
+    """
+    if isinstance(obj, torch.Tensor):
+        tensor = obj
+    else:
+        # tensor.dtype is the pytorch default, typically float32. If obj's elements
+        # are not exactly representable in float32, we've lost precision:
+        # >>> torch.as_tensor(1e12).item() - 1e12
+        # -4096.0
+        default_dtype = torch.get_default_dtype()
+        torch.set_default_dtype(_dtypes_impl.get_default_dtype_for(torch.float32))
+        try:
+            tensor = _try_convert_to_tensor(obj)
+        finally:
+            torch.set_default_dtype(default_dtype)
+
+    # type cast if requested
+    tensor = cast_if_needed(tensor, dtype)
+
+    # adjust ndim if needed
+    ndim_extra = ndmin - tensor.ndim
+    if ndim_extra > 0:
+        tensor = tensor.view((1,) * ndim_extra + tensor.shape)
+
+    # special handling for np._CopyMode
+    try:
+        copy = bool(copy)
+    except ValueError:
+        # TODO handle _CopyMode.IF_NEEDED correctly
+        copy = False
+    # copy if requested
+    if copy:
+        tensor = tensor.clone()
+
+    return tensor
+
+
+def ndarrays_to_tensors(*inputs: object) -> object:
+    """Convert all ndarrays from `inputs` to tensors. (other things are intact)"""
+    from ._ndarray import ndarray
+
+    if len(inputs) == 0:
+        return ValueError()
+    elif len(inputs) == 1:
+        input_ = inputs[0]
+        if isinstance(input_, ndarray):
+            return input_.tensor
+        elif isinstance(input_, tuple):
+            result = []
+            for sub_input in input_:
+                sub_result = ndarrays_to_tensors(sub_input)
+                result.append(sub_result)
+            return tuple(result)
+        else:
+            return input_
+    else:
+        if not isinstance(inputs, tuple):
+            raise AssertionError(
+                f"Expected inputs to be a tuple, got {type(inputs).__name__}"
+            )
+        return ndarrays_to_tensors(inputs)

.venv/lib/python3.12/site-packages/torch/_numpy/fft.py

@@ -0,0 +1,191 @@
+from __future__ import annotations
+
+import functools
+from typing import Concatenate, ParamSpec, TYPE_CHECKING, TypeVar
+
+import torch
+
+from . import _dtypes_impl, _util
+from ._normalizations import ArrayLike, normalizer
+
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Sequence
+
+
+_P = ParamSpec("_P")
+_R = TypeVar("_R")
+
+
+def upcast(
+    func: Callable[Concatenate[torch.Tensor, _P], _R],
+) -> Callable[Concatenate[torch.Tensor, _P], _R]:
+    """NumPy fft casts inputs to 64 bit and *returns 64-bit results*."""
+
+    @functools.wraps(func)
+    def wrapped(tensor: torch.Tensor, *args: _P.args, **kwds: _P.kwargs) -> _R:
+        target_dtype = (
+            _dtypes_impl.default_dtypes().complex_dtype
+            if tensor.is_complex()
+            else _dtypes_impl.default_dtypes().float_dtype
+        )
+        tensor = _util.cast_if_needed(tensor, target_dtype)
+        return func(tensor, *args, **kwds)
+
+    return wrapped
+
+
+@normalizer
+@upcast
+def fft(
+    a: ArrayLike, n: int | None = None, axis: int = -1, norm: str | None = None
+) -> torch.Tensor:
+    return torch.fft.fft(a, n, dim=axis, norm=norm)
+
+
+@normalizer
+@upcast
+def ifft(
+    a: ArrayLike, n: int | None = None, axis: int = -1, norm: str | None = None
+) -> torch.Tensor:
+    return torch.fft.ifft(a, n, dim=axis, norm=norm)
+
+
+@normalizer
+@upcast
+def rfft(
+    a: ArrayLike, n: int | None = None, axis: int = -1, norm: str | None = None
+) -> torch.Tensor:
+    return torch.fft.rfft(a, n, dim=axis, norm=norm)
+
+
+@normalizer
+@upcast
+def irfft(
+    a: ArrayLike, n: int | None = None, axis: int = -1, norm: str | None = None
+) -> torch.Tensor:
+    return torch.fft.irfft(a, n, dim=axis, norm=norm)
+
+
+@normalizer
+@upcast
+def fftn(
+    a: ArrayLike,
+    s: Sequence[int] | None = None,
+    axes: Sequence[int] | None = None,
+    norm: str | None = None,
+) -> torch.Tensor:
+    return torch.fft.fftn(a, s, dim=axes, norm=norm)
+
+
+@normalizer
+@upcast
+def ifftn(
+    a: ArrayLike,
+    s: Sequence[int] | None = None,
+    axes: Sequence[int] | None = None,
+    norm: str | None = None,
+) -> torch.Tensor:
+    return torch.fft.ifftn(a, s, dim=axes, norm=norm)
+
+
+@normalizer
+@upcast
+def rfftn(
+    a: ArrayLike,
+    s: Sequence[int] | None = None,
+    axes: Sequence[int] | None = None,
+    norm: str | None = None,
+) -> torch.Tensor:
+    return torch.fft.rfftn(a, s, dim=axes, norm=norm)
+
+
+@normalizer
+@upcast
+def irfftn(
+    a: ArrayLike,
+    s: Sequence[int] | None = None,
+    axes: Sequence[int] | None = None,
+    norm: str | None = None,
+) -> torch.Tensor:
+    return torch.fft.irfftn(a, s, dim=axes, norm=norm)
+
+
+@normalizer
+@upcast
+def fft2(
+    a: ArrayLike,
+    s: Sequence[int] | None = None,
+    axes: Sequence[int] = (-2, -1),
+    norm: str | None = None,
+) -> torch.Tensor:
+    return torch.fft.fft2(a, s, dim=axes, norm=norm)
+
+
+@normalizer
+@upcast
+def ifft2(
+    a: ArrayLike,
+    s: Sequence[int] | None = None,
+    axes: Sequence[int] = (-2, -1),
+    norm: str | None = None,
+) -> torch.Tensor:
+    return torch.fft.ifft2(a, s, dim=axes, norm=norm)
+
+
+@normalizer
+@upcast
+def rfft2(
+    a: ArrayLike,
+    s: Sequence[int] | None = None,
+    axes: Sequence[int] = (-2, -1),
+    norm: str | None = None,
+) -> torch.Tensor:
+    return torch.fft.rfft2(a, s, dim=axes, norm=norm)
+
+
+@normalizer
+@upcast
+def irfft2(
+    a: ArrayLike,
+    s: Sequence[int] | None = None,
+    axes: Sequence[int] = (-2, -1),
+    norm: str | None = None,
+) -> torch.Tensor:
+    return torch.fft.irfft2(a, s, dim=axes, norm=norm)
+
+
+@normalizer
+@upcast
+def hfft(
+    a: ArrayLike, n: int | None = None, axis: int = -1, norm: str | None = None
+) -> torch.Tensor:
+    return torch.fft.hfft(a, n, dim=axis, norm=norm)
+
+
+@normalizer
+@upcast
+def ihfft(
+    a: ArrayLike, n: int | None = None, axis: int = -1, norm: str | None = None
+) -> torch.Tensor:
+    return torch.fft.ihfft(a, n, dim=axis, norm=norm)
+
+
+@normalizer
+def fftfreq(n: int, d: float = 1.0) -> torch.Tensor:
+    return torch.fft.fftfreq(n, d)
+
+
+@normalizer
+def rfftfreq(n: int, d: float = 1.0) -> torch.Tensor:
+    return torch.fft.rfftfreq(n, d)
+
+
+@normalizer
+def fftshift(x: ArrayLike, axes: int | Sequence[int] | None = None) -> torch.Tensor:
+    return torch.fft.fftshift(x, axes)
+
+
+@normalizer
+def ifftshift(x: ArrayLike, axes: int | Sequence[int] | None = None) -> torch.Tensor:
+    return torch.fft.ifftshift(x, axes)

.venv/lib/python3.12/site-packages/torch/_numpy/linalg.py

@@ -0,0 +1,267 @@
+from __future__ import annotations
+
+import functools
+import math
+from typing import ParamSpec, TYPE_CHECKING, TypeVar
+
+import torch
+
+from . import _dtypes_impl, _util
+from ._normalizations import ArrayLike, KeepDims, normalizer, OutArray
+
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Sequence
+
+
+_P = ParamSpec("_P")
+_R = TypeVar("_R")
+
+
+class LinAlgError(Exception):
+    pass
+
+
+def _atleast_float_1(a: torch.Tensor) -> torch.Tensor:
+    if not (a.dtype.is_floating_point or a.dtype.is_complex):
+        a = a.to(_dtypes_impl.default_dtypes().float_dtype)
+    return a
+
+
+def _atleast_float_2(
+    a: torch.Tensor, b: torch.Tensor
+) -> tuple[torch.Tensor, torch.Tensor]:
+    dtyp = _dtypes_impl.result_type_impl(a, b)
+    if not (dtyp.is_floating_point or dtyp.is_complex):
+        dtyp = _dtypes_impl.default_dtypes().float_dtype
+
+    a = _util.cast_if_needed(a, dtyp)
+    b = _util.cast_if_needed(b, dtyp)
+    return a, b
+
+
+def linalg_errors(func: Callable[_P, _R]) -> Callable[_P, _R]:
+    @functools.wraps(func)
+    def wrapped(*args: _P.args, **kwds: _P.kwargs) -> _R:
+        try:
+            return func(*args, **kwds)
+        except torch._C._LinAlgError as e:  # pyrefly: ignore[missing-attribute]  # TODO
+            raise LinAlgError(*e.args)  # noqa: B904
+
+    return wrapped
+
+
+# ### Matrix and vector products ###
+
+
+@normalizer
+@linalg_errors
+def matrix_power(a: ArrayLike, n: int) -> torch.Tensor:
+    a = _atleast_float_1(a)
+    return torch.linalg.matrix_power(a, n)
+
+
+@normalizer
+@linalg_errors
+def multi_dot(
+    inputs: Sequence[ArrayLike], *, out: OutArray | None = None
+) -> torch.Tensor:
+    return torch.linalg.multi_dot(inputs)
+
+
+# ### Solving equations and inverting matrices ###
+
+
+@normalizer
+@linalg_errors
+def solve(a: ArrayLike, b: ArrayLike) -> torch.Tensor:
+    a, b = _atleast_float_2(a, b)
+    return torch.linalg.solve(a, b)
+
+
+@normalizer
+@linalg_errors
+def lstsq(
+    a: ArrayLike, b: ArrayLike, rcond: float | None = None
+) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+    a, b = _atleast_float_2(a, b)
+    # NumPy is using gelsd: https://github.com/numpy/numpy/blob/v1.24.0/numpy/linalg/umath_linalg.cpp#L3991
+    # on CUDA, only `gels` is available though, so use it instead
+    driver = "gels" if a.is_cuda or b.is_cuda else "gelsd"
+    return torch.linalg.lstsq(a, b, rcond=rcond, driver=driver)
+
+
+@normalizer
+@linalg_errors
+def inv(a: ArrayLike) -> torch.Tensor:
+    a = _atleast_float_1(a)
+    result = torch.linalg.inv(a)
+    return result
+
+
+@normalizer
+@linalg_errors
+def pinv(a: ArrayLike, rcond: float = 1e-15, hermitian: bool = False) -> torch.Tensor:
+    a = _atleast_float_1(a)
+    return torch.linalg.pinv(a, rtol=rcond, hermitian=hermitian)
+
+
+@normalizer
+@linalg_errors
+def tensorsolve(
+    a: ArrayLike, b: ArrayLike, axes: Sequence[int] | None = None
+) -> torch.Tensor:
+    a, b = _atleast_float_2(a, b)
+    return torch.linalg.tensorsolve(a, b, dims=axes)
+
+
+@normalizer
+@linalg_errors
+def tensorinv(a: ArrayLike, ind: int = 2) -> torch.Tensor:
+    a = _atleast_float_1(a)
+    return torch.linalg.tensorinv(a, ind=ind)
+
+
+# ### Norms and other numbers ###
+
+
+@normalizer
+@linalg_errors
+def det(a: ArrayLike) -> torch.Tensor:
+    a = _atleast_float_1(a)
+    return torch.linalg.det(a)
+
+
+@normalizer
+@linalg_errors
+def slogdet(a: ArrayLike) -> tuple[torch.Tensor, torch.Tensor]:
+    a = _atleast_float_1(a)
+    return torch.linalg.slogdet(a)
+
+
+@normalizer
+@linalg_errors
+def cond(x: ArrayLike, p: int | str | None = None) -> torch.Tensor:
+    x = _atleast_float_1(x)
+
+    # check if empty
+    # cf: https://github.com/numpy/numpy/blob/v1.24.0/numpy/linalg/linalg.py#L1744
+    if x.numel() == 0 and math.prod(x.shape[-2:]) == 0:
+        raise LinAlgError("cond is not defined on empty arrays")
+
+    result = torch.linalg.cond(x, p=p)
+
+    # Convert nans to infs (numpy does it in a data-dependent way, depending on
+    # whether the input array has nans or not)
+    # XXX: NumPy does this: https://github.com/numpy/numpy/blob/v1.24.0/numpy/linalg/linalg.py#L1744
+    return torch.where(torch.isnan(result), float("inf"), result)
+
+
+@normalizer
+@linalg_errors
+def matrix_rank(
+    a: ArrayLike, tol: float | None = None, hermitian: bool = False
+) -> torch.Tensor | int:
+    a = _atleast_float_1(a)
+
+    if a.ndim < 2:
+        return int((a != 0).any())
+
+    if tol is None:
+        # follow https://github.com/numpy/numpy/blob/v1.24.0/numpy/linalg/linalg.py#L1885
+        atol = 0
+        rtol = max(a.shape[-2:]) * torch.finfo(a.dtype).eps
+    else:
+        atol, rtol = tol, 0
+    return torch.linalg.matrix_rank(a, atol=atol, rtol=rtol, hermitian=hermitian)
+
+
+@normalizer
+@linalg_errors
+def norm(
+    x: ArrayLike,
+    ord: int | float | str | None = None,
+    axis: int | tuple[int, ...] | None = None,
+    keepdims: KeepDims = False,
+) -> torch.Tensor:
+    x = _atleast_float_1(x)
+    return torch.linalg.norm(x, ord=ord, dim=axis)
+
+
+# ### Decompositions ###
+
+
+@normalizer
+@linalg_errors
+def cholesky(a: ArrayLike) -> torch.Tensor:
+    a = _atleast_float_1(a)
+    return torch.linalg.cholesky(a)
+
+
+@normalizer
+@linalg_errors
+def qr(
+    a: ArrayLike, mode: str = "reduced"
+) -> tuple[torch.Tensor, torch.Tensor] | torch.Tensor:
+    a = _atleast_float_1(a)
+    result = torch.linalg.qr(a, mode=mode)
+    if mode == "r":
+        # match NumPy
+        return result.R
+    return result
+
+
+@normalizer
+@linalg_errors
+def svd(
+    a: ArrayLike,
+    full_matrices: bool = True,
+    compute_uv: bool = True,
+    hermitian: bool = False,
+) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor] | torch.Tensor:
+    a = _atleast_float_1(a)
+    if not compute_uv:
+        return torch.linalg.svdvals(a)
+
+    # NB: ignore the hermitian= argument (no pytorch equivalent)
+    result = torch.linalg.svd(a, full_matrices=full_matrices)
+    return result
+
+
+# ### Eigenvalues and eigenvectors ###
+
+
+@normalizer
+@linalg_errors
+def eig(a: ArrayLike) -> tuple[torch.Tensor, torch.Tensor]:
+    a = _atleast_float_1(a)
+    w, vt = torch.linalg.eig(a)
+
+    if not a.is_complex() and w.is_complex() and (w.imag == 0).all():
+        w = w.real
+        vt = vt.real
+    return w, vt
+
+
+@normalizer
+@linalg_errors
+def eigh(a: ArrayLike, UPLO: str = "L") -> tuple[torch.Tensor, torch.Tensor]:
+    a = _atleast_float_1(a)
+    return torch.linalg.eigh(a, UPLO=UPLO)
+
+
+@normalizer
+@linalg_errors
+def eigvals(a: ArrayLike) -> torch.Tensor:
+    a = _atleast_float_1(a)
+    result = torch.linalg.eigvals(a)
+    if not a.is_complex() and result.is_complex() and (result.imag == 0).all():
+        result = result.real
+    return result
+
+
+@normalizer
+@linalg_errors
+def eigvalsh(a: ArrayLike, UPLO: str = "L") -> torch.Tensor:
+    a = _atleast_float_1(a)
+    return torch.linalg.eigvalsh(a, UPLO=UPLO)

.venv/lib/python3.12/site-packages/torch/_numpy/random.py

@@ -0,0 +1,191 @@
+# mypy: ignore-errors
+
+"""Wrapper to mimic (parts of) np.random API surface.
+
+NumPy has strict guarantees on reproducibility etc; here we don't give any.
+
+Q: default dtype is float64 in numpy
+
+"""
+
+from __future__ import annotations
+
+import functools
+from math import sqrt
+
+import torch
+
+from . import _dtypes_impl, _util
+from ._normalizations import array_or_scalar, ArrayLike, normalizer
+
+
+__all__ = [
+    "seed",
+    "random_sample",
+    "sample",
+    "random",
+    "rand",
+    "randn",
+    "normal",
+    "choice",
+    "randint",
+    "shuffle",
+    "uniform",
+]
+
+
+def use_numpy_random():
+    # local import to avoid ref cycles
+    import torch._dynamo.config as config
+
+    return config.use_numpy_random_stream
+
+
+def deco_stream(func):
+    @functools.wraps(func)
+    def inner(*args, **kwds):
+        if not use_numpy_random():
+            return func(*args, **kwds)
+        else:
+            import numpy
+
+            from ._ndarray import ndarray
+
+            f = getattr(numpy.random, func.__name__)
+
+            # numpy funcs accept numpy ndarrays, unwrap
+            args = tuple(
+                arg.tensor.numpy() if isinstance(arg, ndarray) else arg for arg in args
+            )
+            kwds = {
+                key: val.tensor.numpy() if isinstance(val, ndarray) else val
+                for key, val in kwds.items()
+            }
+
+            value = f(*args, **kwds)
+
+            # `value` can be either numpy.ndarray or python scalar (or None)
+            if isinstance(value, numpy.ndarray):
+                value = ndarray(torch.as_tensor(value))
+
+            return value
+
+    return inner
+
+
+@deco_stream
+def seed(seed=None):
+    if seed is not None:
+        torch.random.manual_seed(seed)
+
+
+@deco_stream
+def random_sample(size=None):
+    if size is None:
+        size = ()
+    dtype = _dtypes_impl.default_dtypes().float_dtype
+    values = torch.empty(size, dtype=dtype).uniform_()
+    return array_or_scalar(values, return_scalar=size == ())
+
+
+def rand(*size):
+    if size == ():
+        size = None
+    return random_sample(size)
+
+
+sample = random_sample
+random = random_sample
+
+
+@deco_stream
+def uniform(low=0.0, high=1.0, size=None):
+    if size is None:
+        size = ()
+    dtype = _dtypes_impl.default_dtypes().float_dtype
+    values = torch.empty(size, dtype=dtype).uniform_(low, high)
+    return array_or_scalar(values, return_scalar=size == ())
+
+
+@deco_stream
+def randn(*size):
+    dtype = _dtypes_impl.default_dtypes().float_dtype
+    values = torch.randn(size, dtype=dtype)
+    return array_or_scalar(values, return_scalar=size == ())
+
+
+@deco_stream
+def normal(loc=0.0, scale=1.0, size=None):
+    if size is None:
+        size = ()
+    dtype = _dtypes_impl.default_dtypes().float_dtype
+    values = torch.empty(size, dtype=dtype).normal_(loc, scale)
+    return array_or_scalar(values, return_scalar=size == ())
+
+
+@deco_stream
+def shuffle(x):
+    # no @normalizer because we do not cast e.g. lists to tensors
+    from ._ndarray import ndarray
+
+    if isinstance(x, torch.Tensor):
+        tensor = x
+    elif isinstance(x, ndarray):
+        tensor = x.tensor
+    else:
+        raise NotImplementedError("We do not random.shuffle lists in-place")
+
+    perm = torch.randperm(tensor.shape[0])
+    xp = tensor[perm]
+    tensor.copy_(xp)
+
+
+@deco_stream
+def randint(low, high=None, size=None):
+    if size is None:
+        size = ()
+    if not isinstance(size, (tuple, list)):
+        size = (size,)
+    if high is None:
+        low, high = 0, low
+    values = torch.randint(low, high, size=size)
+    return array_or_scalar(values, int, return_scalar=size == ())
+
+
+@deco_stream
+@normalizer
+def choice(a: ArrayLike, size=None, replace=True, p: ArrayLike | None = None):
+    # https://stackoverflow.com/questions/59461811/random-choice-with-pytorch
+    if a.numel() == 1:
+        a = torch.arange(a)
+
+    # TODO: check a.dtype is integer -- cf np.random.choice(3.4) which raises
+
+    # number of draws
+    if size is None:
+        num_el = 1
+    elif _util.is_sequence(size):
+        num_el = 1
+        for el in size:
+            num_el *= el
+    else:
+        num_el = size
+
+    # prepare the probabilities
+    if p is None:
+        p = torch.ones_like(a) / a.shape[0]
+
+    # cf https://github.com/numpy/numpy/blob/main/numpy/random/mtrand.pyx#L973
+    atol = sqrt(torch.finfo(p.dtype).eps)
+    if abs(p.sum() - 1.0) > atol:
+        raise ValueError("probabilities do not sum to 1.")
+
+    # actually sample
+    indices = torch.multinomial(p, num_el, replacement=replace)
+
+    if _util.is_sequence(size):
+        indices = indices.reshape(size)
+
+    samples = a[indices]
+
+    return samples

.venv/lib/python3.12/site-packages/torch/_numpy/testing/__init__.py

@@ -0,0 +1,20 @@
+# mypy: ignore-errors
+
+from .utils import (
+    _gen_alignment_data,
+    assert_,
+    assert_allclose,
+    assert_almost_equal,
+    assert_array_almost_equal,
+    assert_array_equal,
+    assert_array_less,
+    assert_equal,
+    assert_raises_regex,
+    assert_warns,
+    HAS_REFCOUNT,
+    IS_WASM,
+    suppress_warnings,
+)
+
+
+# from .testing import assert_allclose    # FIXME

.venv/lib/python3.12/site-packages/torch/_numpy/testing/utils.py

@@ -0,0 +1,2453 @@
+# mypy: ignore-errors
+
+"""
+Utility function to facilitate testing.
+
+"""
+
+import contextlib
+import gc
+import operator
+import os
+import platform
+import pprint
+import re
+import shutil
+import sys
+import warnings
+from functools import wraps
+from io import StringIO
+from tempfile import mkdtemp, mkstemp
+from warnings import WarningMessage
+
+import torch._numpy as np
+from torch._numpy import arange, asarray as asanyarray, empty, float32, intp, ndarray
+
+
+__all__ = [
+    "assert_equal",
+    "assert_almost_equal",
+    "assert_approx_equal",
+    "assert_array_equal",
+    "assert_array_less",
+    "assert_string_equal",
+    "assert_",
+    "assert_array_almost_equal",
+    "build_err_msg",
+    "decorate_methods",
+    "print_assert_equal",
+    "verbose",
+    "assert_",
+    "assert_array_almost_equal_nulp",
+    "assert_raises_regex",
+    "assert_array_max_ulp",
+    "assert_warns",
+    "assert_no_warnings",
+    "assert_allclose",
+    "IgnoreException",
+    "clear_and_catch_warnings",
+    "temppath",
+    "tempdir",
+    "IS_PYPY",
+    "HAS_REFCOUNT",
+    "IS_WASM",
+    "suppress_warnings",
+    "assert_array_compare",
+    "assert_no_gc_cycles",
+    "break_cycles",
+    "IS_PYSTON",
+]
+
+
+verbose = 0
+
+IS_WASM = platform.machine() in ["wasm32", "wasm64"]
+IS_PYPY = sys.implementation.name == "pypy"
+IS_PYSTON = hasattr(sys, "pyston_version_info")
+HAS_REFCOUNT = getattr(sys, "getrefcount", None) is not None and not IS_PYSTON
+
+
+def assert_(val, msg=""):
+    """
+    Assert that works in release mode.
+    Accepts callable msg to allow deferring evaluation until failure.
+
+    The Python built-in ``assert`` does not work when executing code in
+    optimized mode (the ``-O`` flag) - no byte-code is generated for it.
+
+    For documentation on usage, refer to the Python documentation.
+
+    """
+    __tracebackhide__ = True  # Hide traceback for py.test
+    if not val:
+        try:
+            smsg = msg()
+        except TypeError:
+            smsg = msg
+        raise AssertionError(smsg)
+
+
+def gisnan(x):
+    return np.isnan(x)
+
+
+def gisfinite(x):
+    return np.isfinite(x)
+
+
+def gisinf(x):
+    return np.isinf(x)
+
+
+def build_err_msg(
+    arrays,
+    err_msg,
+    header="Items are not equal:",
+    verbose=True,
+    names=("ACTUAL", "DESIRED"),
+    precision=8,
+):
+    msg = ["\n" + header]
+    if err_msg:
+        if err_msg.find("\n") == -1 and len(err_msg) < 79 - len(header):
+            msg = [msg[0] + " " + err_msg]
+        else:
+            msg.append(err_msg)
+    if verbose:
+        for i, a in enumerate(arrays):
+            if isinstance(a, ndarray):
+                # precision argument is only needed if the objects are ndarrays
+                # r_func = partial(array_repr, precision=precision)
+                r_func = ndarray.__repr__
+            else:
+                r_func = repr
+
+            try:
+                r = r_func(a)
+            except Exception as exc:
+                r = f"[repr failed for <{type(a).__name__}>: {exc}]"
+            if r.count("\n") > 3:
+                r = "\n".join(r.splitlines()[:3])
+                r += "..."
+            msg.append(f" {names[i]}: {r}")
+    return "\n".join(msg)
+
+
+def assert_equal(actual, desired, err_msg="", verbose=True):
+    """
+    Raises an AssertionError if two objects are not equal.
+
+    Given two objects (scalars, lists, tuples, dictionaries or numpy arrays),
+    check that all elements of these objects are equal. An exception is raised
+    at the first conflicting values.
+
+    When one of `actual` and `desired` is a scalar and the other is array_like,
+    the function checks that each element of the array_like object is equal to
+    the scalar.
+
+    This function handles NaN comparisons as if NaN was a "normal" number.
+    That is, AssertionError is not raised if both objects have NaNs in the same
+    positions.  This is in contrast to the IEEE standard on NaNs, which says
+    that NaN compared to anything must return False.
+
+    Parameters
+    ----------
+    actual : array_like
+        The object to check.
+    desired : array_like
+        The expected object.
+    err_msg : str, optional
+        The error message to be printed in case of failure.
+    verbose : bool, optional
+        If True, the conflicting values are appended to the error message.
+
+    Raises
+    ------
+    AssertionError
+        If actual and desired are not equal.
+
+    Examples
+    --------
+    >>> np.testing.assert_equal([4, 5], [4, 6])
+    Traceback (most recent call last):
+        ...
+    AssertionError:
+    Items are not equal:
+    item=1
+     ACTUAL: 5
+     DESIRED: 6
+
+    The following comparison does not raise an exception.  There are NaNs
+    in the inputs, but they are in the same positions.
+
+    >>> np.testing.assert_equal(np.array([1.0, 2.0, np.nan]), [1, 2, np.nan])
+
+    """
+    __tracebackhide__ = True  # Hide traceback for py.test
+
+    num_nones = sum([actual is None, desired is None])
+    if num_nones == 1:
+        raise AssertionError(f"Not equal: {actual} != {desired}")
+    elif num_nones == 2:
+        return True
+    # else, carry on
+
+    if isinstance(actual, np.DType) or isinstance(desired, np.DType):
+        result = actual == desired
+        if not result:
+            raise AssertionError(f"Not equal: {actual} != {desired}")
+        else:
+            return True
+
+    if isinstance(desired, str) and isinstance(actual, str):
+        if actual != desired:
+            raise AssertionError(f"Strings not equal: {actual!r} != {desired!r}")
+        return
+
+    if isinstance(desired, dict):
+        if not isinstance(actual, dict):
+            raise AssertionError(repr(type(actual)))
+        assert_equal(len(actual), len(desired), err_msg, verbose)
+        for k in desired:
+            if k not in actual:
+                raise AssertionError(repr(k))
+            assert_equal(actual[k], desired[k], f"key={k!r}\n{err_msg}", verbose)
+        return
+    if isinstance(desired, (list, tuple)) and isinstance(actual, (list, tuple)):
+        assert_equal(len(actual), len(desired), err_msg, verbose)
+        for k in range(len(desired)):
+            assert_equal(actual[k], desired[k], f"item={k!r}\n{err_msg}", verbose)
+        return
+
+    from torch._numpy import imag, iscomplexobj, isscalar, ndarray, real, signbit
+
+    if isinstance(actual, ndarray) or isinstance(desired, ndarray):
+        return assert_array_equal(actual, desired, err_msg, verbose)
+    msg = build_err_msg([actual, desired], err_msg, verbose=verbose)
+
+    # Handle complex numbers: separate into real/imag to handle
+    # nan/inf/negative zero correctly
+    # XXX: catch ValueError for subclasses of ndarray where iscomplex fail
+    try:
+        usecomplex = iscomplexobj(actual) or iscomplexobj(desired)
+    except (ValueError, TypeError):
+        usecomplex = False
+
+    if usecomplex:
+        if iscomplexobj(actual):
+            actualr = real(actual)
+            actuali = imag(actual)
+        else:
+            actualr = actual
+            actuali = 0
+        if iscomplexobj(desired):
+            desiredr = real(desired)
+            desiredi = imag(desired)
+        else:
+            desiredr = desired
+            desiredi = 0
+        try:
+            assert_equal(actualr, desiredr)
+            assert_equal(actuali, desiredi)
+        except AssertionError:
+            raise AssertionError(msg)  # noqa: B904
+
+    # isscalar test to check cases such as [np.nan] != np.nan
+    if isscalar(desired) != isscalar(actual):
+        raise AssertionError(msg)
+
+    # Inf/nan/negative zero handling
+    try:
+        isdesnan = gisnan(desired)
+        isactnan = gisnan(actual)
+        if isdesnan and isactnan:
+            return  # both nan, so equal
+
+        if desired == 0 and actual == 0:
+            if not signbit(desired) == signbit(actual):
+                raise AssertionError(msg)
+
+    except (TypeError, ValueError, NotImplementedError):
+        pass
+
+    try:
+        # Explicitly use __eq__ for comparison, gh-2552
+        if not (desired == actual):
+            raise AssertionError(msg)
+
+    except (DeprecationWarning, FutureWarning) as e:
+        # this handles the case when the two types are not even comparable
+        if "elementwise == comparison" in e.args[0]:
+            raise AssertionError(msg)  # noqa: B904
+        else:
+            raise
+
+
+def print_assert_equal(test_string, actual, desired):
+    """
+    Test if two objects are equal, and print an error message if test fails.
+
+    The test is performed with ``actual == desired``.
+
+    Parameters
+    ----------
+    test_string : str
+        The message supplied to AssertionError.
+    actual : object
+        The object to test for equality against `desired`.
+    desired : object
+        The expected result.
+
+    Examples
+    --------
+    >>> np.testing.print_assert_equal(
+    ...     "Test XYZ of func xyz", [0, 1], [0, 1]
+    ... )  # doctest: +SKIP
+    >>> np.testing.print_assert_equal(
+    ...     "Test XYZ of func xyz", [0, 1], [0, 2]
+    ... )  # doctest: +SKIP
+    Traceback (most recent call last):
+    ...
+    AssertionError: Test XYZ of func xyz failed
+    ACTUAL:
+    [0, 1]
+    DESIRED:
+    [0, 2]
+
+    """
+    __tracebackhide__ = True  # Hide traceback for py.test
+    import pprint
+
+    if actual != desired:
+        msg = StringIO()
+        msg.write(test_string)
+        msg.write(" failed\nACTUAL: \n")
+        pprint.pprint(actual, msg)
+        msg.write("DESIRED: \n")
+        pprint.pprint(desired, msg)
+        raise AssertionError(msg.getvalue())
+
+
+def assert_almost_equal(actual, desired, decimal=7, err_msg="", verbose=True):
+    """
+    Raises an AssertionError if two items are not equal up to desired
+    precision.
+
+    .. note:: It is recommended to use one of `assert_allclose`,
+              `assert_array_almost_equal_nulp` or `assert_array_max_ulp`
+              instead of this function for more consistent floating point
+              comparisons.
+
+    The test verifies that the elements of `actual` and `desired` satisfy.
+
+        ``abs(desired-actual) < float64(1.5 * 10**(-decimal))``
+
+    That is a looser test than originally documented, but agrees with what the
+    actual implementation in `assert_array_almost_equal` did up to rounding
+    vagaries. An exception is raised at conflicting values. For ndarrays this
+    delegates to assert_array_almost_equal
+
+    Parameters
+    ----------
+    actual : array_like
+        The object to check.
+    desired : array_like
+        The expected object.
+    decimal : int, optional
+        Desired precision, default is 7.
+    err_msg : str, optional
+        The error message to be printed in case of failure.
+    verbose : bool, optional
+        If True, the conflicting values are appended to the error message.
+
+    Raises
+    ------
+    AssertionError
+      If actual and desired are not equal up to specified precision.
+
+    See Also
+    --------
+    assert_allclose: Compare two array_like objects for equality with desired
+                     relative and/or absolute precision.
+    assert_array_almost_equal_nulp, assert_array_max_ulp, assert_equal
+
+    Examples
+    --------
+    >>> from torch._numpy.testing import assert_almost_equal
+    >>> assert_almost_equal(2.3333333333333, 2.33333334)
+    >>> assert_almost_equal(2.3333333333333, 2.33333334, decimal=10)
+    Traceback (most recent call last):
+        ...
+    AssertionError:
+    Arrays are not almost equal to 10 decimals
+     ACTUAL: 2.3333333333333
+     DESIRED: 2.33333334
+
+    >>> assert_almost_equal(
+    ...     np.array([1.0, 2.3333333333333]), np.array([1.0, 2.33333334]), decimal=9
+    ... )
+    Traceback (most recent call last):
+        ...
+    AssertionError:
+    Arrays are not almost equal to 9 decimals
+    <BLANKLINE>
+    Mismatched elements: 1 / 2 (50%)
+    Max absolute difference: 6.666699636781459e-09
+    Max relative difference: 2.8571569790287484e-09
+     x: torch.ndarray([1.0000, 2.3333], dtype=float64)
+     y: torch.ndarray([1.0000, 2.3333], dtype=float64)
+
+    """
+    __tracebackhide__ = True  # Hide traceback for py.test
+    from torch._numpy import imag, iscomplexobj, ndarray, real
+
+    # Handle complex numbers: separate into real/imag to handle
+    # nan/inf/negative zero correctly
+    # XXX: catch ValueError for subclasses of ndarray where iscomplex fail
+    try:
+        usecomplex = iscomplexobj(actual) or iscomplexobj(desired)
+    except ValueError:
+        usecomplex = False
+
+    def _build_err_msg():
+        header = f"Arrays are not almost equal to {decimal:d} decimals"
+        return build_err_msg([actual, desired], err_msg, verbose=verbose, header=header)
+
+    if usecomplex:
+        if iscomplexobj(actual):
+            actualr = real(actual)
+            actuali = imag(actual)
+        else:
+            actualr = actual
+            actuali = 0
+        if iscomplexobj(desired):
+            desiredr = real(desired)
+            desiredi = imag(desired)
+        else:
+            desiredr = desired
+            desiredi = 0
+        try:
+            assert_almost_equal(actualr, desiredr, decimal=decimal)
+            assert_almost_equal(actuali, desiredi, decimal=decimal)
+        except AssertionError:
+            raise AssertionError(_build_err_msg())  # noqa: B904
+
+    if isinstance(actual, (ndarray, tuple, list)) or isinstance(
+        desired, (ndarray, tuple, list)
+    ):
+        return assert_array_almost_equal(actual, desired, decimal, err_msg)
+    try:
+        # If one of desired/actual is not finite, handle it specially here:
+        # check that both are nan if any is a nan, and test for equality
+        # otherwise
+        if not (gisfinite(desired) and gisfinite(actual)):
+            if gisnan(desired) or gisnan(actual):
+                if not (gisnan(desired) and gisnan(actual)):
+                    raise AssertionError(_build_err_msg())
+            else:
+                if not desired == actual:
+                    raise AssertionError(_build_err_msg())
+            return
+    except (NotImplementedError, TypeError):
+        pass
+    if abs(desired - actual) >= np.float64(1.5 * 10.0 ** (-decimal)):
+        raise AssertionError(_build_err_msg())
+
+
+def assert_approx_equal(actual, desired, significant=7, err_msg="", verbose=True):
+    """
+    Raises an AssertionError if two items are not equal up to significant
+    digits.
+
+    .. note:: It is recommended to use one of `assert_allclose`,
+              `assert_array_almost_equal_nulp` or `assert_array_max_ulp`
+              instead of this function for more consistent floating point
+              comparisons.
+
+    Given two numbers, check that they are approximately equal.
+    Approximately equal is defined as the number of significant digits
+    that agree.
+
+    Parameters
+    ----------
+    actual : scalar
+        The object to check.
+    desired : scalar
+        The expected object.
+    significant : int, optional
+        Desired precision, default is 7.
+    err_msg : str, optional
+        The error message to be printed in case of failure.
+    verbose : bool, optional
+        If True, the conflicting values are appended to the error message.
+
+    Raises
+    ------
+    AssertionError
+      If actual and desired are not equal up to specified precision.
+
+    See Also
+    --------
+    assert_allclose: Compare two array_like objects for equality with desired
+                     relative and/or absolute precision.
+    assert_array_almost_equal_nulp, assert_array_max_ulp, assert_equal
+
+    Examples
+    --------
+    >>> np.testing.assert_approx_equal(
+    ...     0.12345677777777e-20, 0.1234567e-20
+    ... )  # doctest: +SKIP
+    >>> np.testing.assert_approx_equal(
+    ...     0.12345670e-20,
+    ...     0.12345671e-20,  # doctest: +SKIP
+    ...     significant=8,
+    ... )
+    >>> np.testing.assert_approx_equal(
+    ...     0.12345670e-20,
+    ...     0.12345672e-20,  # doctest: +SKIP
+    ...     significant=8,
+    ... )
+    Traceback (most recent call last):
+        ...
+    AssertionError:
+    Items are not equal to 8 significant digits:
+     ACTUAL: 1.234567e-21
+     DESIRED: 1.2345672e-21
+
+    the evaluated condition that raises the exception is
+
+    >>> abs(0.12345670e-20 / 1e-21 - 0.12345672e-20 / 1e-21) >= 10 ** -(8 - 1)
+    True
+
+    """
+    __tracebackhide__ = True  # Hide traceback for py.test
+    import numpy as np
+
+    (actual, desired) = map(float, (actual, desired))
+    if desired == actual:
+        return
+    # Normalized the numbers to be in range (-10.0,10.0)
+    # scale = float(pow(10,math.floor(math.log10(0.5*(abs(desired)+abs(actual))))))
+    scale = 0.5 * (np.abs(desired) + np.abs(actual))
+    scale = np.power(10, np.floor(np.log10(scale)))
+    try:
+        sc_desired = desired / scale
+    except ZeroDivisionError:
+        sc_desired = 0.0
+    try:
+        sc_actual = actual / scale
+    except ZeroDivisionError:
+        sc_actual = 0.0
+    msg = build_err_msg(
+        [actual, desired],
+        err_msg,
+        header=f"Items are not equal to {significant:d} significant digits:",
+        verbose=verbose,
+    )
+    try:
+        # If one of desired/actual is not finite, handle it specially here:
+        # check that both are nan if any is a nan, and test for equality
+        # otherwise
+        if not (gisfinite(desired) and gisfinite(actual)):
+            if gisnan(desired) or gisnan(actual):
+                if not (gisnan(desired) and gisnan(actual)):
+                    raise AssertionError(msg)
+            else:
+                if not desired == actual:
+                    raise AssertionError(msg)
+            return
+    except (TypeError, NotImplementedError):
+        pass
+    if np.abs(sc_desired - sc_actual) >= np.power(10.0, -(significant - 1)):
+        raise AssertionError(msg)
+
+
+def assert_array_compare(
+    comparison,
+    x,
+    y,
+    err_msg="",
+    verbose=True,
+    header="",
+    precision=6,
+    equal_nan=True,
+    equal_inf=True,
+    *,
+    strict=False,
+):
+    __tracebackhide__ = True  # Hide traceback for py.test
+    from torch._numpy import all, array, asarray, bool_, inf, isnan, max
+
+    x = asarray(x)
+    y = asarray(y)
+
+    def array2string(a):
+        return str(a)
+
+    # original array for output formatting
+    ox, oy = x, y
+
+    def func_assert_same_pos(x, y, func=isnan, hasval="nan"):
+        """Handling nan/inf.
+
+        Combine results of running func on x and y, checking that they are True
+        at the same locations.
+
+        """
+        __tracebackhide__ = True  # Hide traceback for py.test
+        x_id = func(x)
+        y_id = func(y)
+        # We include work-arounds here to handle three types of slightly
+        # pathological ndarray subclasses:
+        # (1) all() on `masked` array scalars can return masked arrays, so we
+        #     use != True
+        # (2) __eq__ on some ndarray subclasses returns Python booleans
+        #     instead of element-wise comparisons, so we cast to bool_() and
+        #     use isinstance(..., bool) checks
+        # (3) subclasses with bare-bones __array_function__ implementations may
+        #     not implement np.all(), so favor using the .all() method
+        # We are not committed to supporting such subclasses, but it's nice to
+        # support them if possible.
+        if (x_id == y_id).all().item() is not True:
+            msg = build_err_msg(
+                [x, y],
+                err_msg + f"\nx and y {hasval} location mismatch:",
+                verbose=verbose,
+                header=header,
+                names=("x", "y"),
+                precision=precision,
+            )
+            raise AssertionError(msg)
+        # If there is a scalar, then here we know the array has the same
+        # flag as it everywhere, so we should return the scalar flag.
+        if isinstance(x_id, bool) or x_id.ndim == 0:
+            return bool_(x_id)
+        elif isinstance(y_id, bool) or y_id.ndim == 0:
+            return bool_(y_id)
+        else:
+            return y_id
+
+    try:
+        if strict:
+            cond = x.shape == y.shape and x.dtype == y.dtype
+        else:
+            cond = (x.shape == () or y.shape == ()) or x.shape == y.shape
+        if not cond:
+            if x.shape != y.shape:
+                reason = f"\n(shapes {x.shape}, {y.shape} mismatch)"
+            else:
+                reason = f"\n(dtypes {x.dtype}, {y.dtype} mismatch)"
+            msg = build_err_msg(
+                [x, y],
+                err_msg + reason,
+                verbose=verbose,
+                header=header,
+                names=("x", "y"),
+                precision=precision,
+            )
+            raise AssertionError(msg)
+
+        flagged = bool_(False)
+
+        if equal_nan:
+            flagged = func_assert_same_pos(x, y, func=isnan, hasval="nan")
+
+        if equal_inf:
+            flagged |= func_assert_same_pos(
+                x, y, func=lambda xy: xy == +inf, hasval="+inf"
+            )
+            flagged |= func_assert_same_pos(
+                x, y, func=lambda xy: xy == -inf, hasval="-inf"
+            )
+
+        if flagged.ndim > 0:
+            x, y = x[~flagged], y[~flagged]
+            # Only do the comparison if actual values are left
+            if x.size == 0:
+                return
+        elif flagged:
+            # no sense doing comparison if everything is flagged.
+            return
+
+        val = comparison(x, y)
+
+        if isinstance(val, bool):
+            cond = val
+            reduced = array([val])
+        else:
+            reduced = val.ravel()
+            cond = reduced.all()
+
+        # The below comparison is a hack to ensure that fully masked
+        # results, for which val.ravel().all() returns np.ma.masked,
+        # do not trigger a failure (np.ma.masked != True evaluates as
+        # np.ma.masked, which is falsy).
+        if not cond:
+            n_mismatch = reduced.size - int(reduced.sum(dtype=intp))
+            n_elements = flagged.size if flagged.ndim != 0 else reduced.size
+            percent_mismatch = 100 * n_mismatch / n_elements
+            remarks = [
+                f"Mismatched elements: {n_mismatch} / {n_elements} ({percent_mismatch:.3g}%)"
+            ]
+
+            # with errstate(all='ignore'):
+            # ignore errors for non-numeric types
+            with contextlib.suppress(TypeError, RuntimeError):
+                error = abs(x - y)
+                if np.issubdtype(x.dtype, np.unsignedinteger):
+                    error2 = abs(y - x)
+                    np.minimum(error, error2, out=error)
+                max_abs_error = max(error)
+                remarks.append(
+                    "Max absolute difference: " + array2string(max_abs_error.item())
+                )
+
+                # note: this definition of relative error matches that one
+                # used by assert_allclose (found in np.isclose)
+                # Filter values where the divisor would be zero
+                nonzero = bool_(y != 0)
+                if all(~nonzero):
+                    max_rel_error = array(inf)
+                else:
+                    max_rel_error = max(error[nonzero] / abs(y[nonzero]))
+                remarks.append(
+                    "Max relative difference: " + array2string(max_rel_error.item())
+                )
+
+            err_msg += "\n" + "\n".join(remarks)
+            msg = build_err_msg(
+                [ox, oy],
+                err_msg,
+                verbose=verbose,
+                header=header,
+                names=("x", "y"),
+                precision=precision,
+            )
+            raise AssertionError(msg)
+    except ValueError:
+        import traceback
+
+        efmt = traceback.format_exc()
+        header = f"error during assertion:\n\n{efmt}\n\n{header}"
+
+        msg = build_err_msg(
+            [x, y],
+            err_msg,
+            verbose=verbose,
+            header=header,
+            names=("x", "y"),
+            precision=precision,
+        )
+        raise ValueError(msg)  # noqa: B904
+
+
+def assert_array_equal(x, y, err_msg="", verbose=True, *, strict=False):
+    """
+    Raises an AssertionError if two array_like objects are not equal.
+
+    Given two array_like objects, check that the shape is equal and all
+    elements of these objects are equal (but see the Notes for the special
+    handling of a scalar). An exception is raised at shape mismatch or
+    conflicting values. In contrast to the standard usage in numpy, NaNs
+    are compared like numbers, no assertion is raised if both objects have
+    NaNs in the same positions.
+
+    The usual caution for verifying equality with floating point numbers is
+    advised.
+
+    Parameters
+    ----------
+    x : array_like
+        The actual object to check.
+    y : array_like
+        The desired, expected object.
+    err_msg : str, optional
+        The error message to be printed in case of failure.
+    verbose : bool, optional
+        If True, the conflicting values are appended to the error message.
+    strict : bool, optional
+        If True, raise an AssertionError when either the shape or the data
+        type of the array_like objects does not match. The special
+        handling for scalars mentioned in the Notes section is disabled.
+
+    Raises
+    ------
+    AssertionError
+        If actual and desired objects are not equal.
+
+    See Also
+    --------
+    assert_allclose: Compare two array_like objects for equality with desired
+                     relative and/or absolute precision.
+    assert_array_almost_equal_nulp, assert_array_max_ulp, assert_equal
+
+    Notes
+    -----
+    When one of `x` and `y` is a scalar and the other is array_like, the
+    function checks that each element of the array_like object is equal to
+    the scalar. This behaviour can be disabled with the `strict` parameter.
+
+    Examples
+    --------
+    The first assert does not raise an exception:
+
+    >>> np.testing.assert_array_equal(
+    ...     [1.0, 2.33333, np.nan], [np.exp(0), 2.33333, np.nan]
+    ... )
+
+    Use `assert_allclose` or one of the nulp (number of floating point values)
+    functions for these cases instead:
+
+    >>> np.testing.assert_allclose(
+    ...     [1.0, np.pi, np.nan], [1, np.sqrt(np.pi) ** 2, np.nan], rtol=1e-10, atol=0
+    ... )
+
+    As mentioned in the Notes section, `assert_array_equal` has special
+    handling for scalars. Here the test checks that each value in `x` is 3:
+
+    >>> x = np.full((2, 5), fill_value=3)
+    >>> np.testing.assert_array_equal(x, 3)
+
+    Use `strict` to raise an AssertionError when comparing a scalar with an
+    array:
+
+    >>> np.testing.assert_array_equal(x, 3, strict=True)
+    Traceback (most recent call last):
+        ...
+    AssertionError:
+    Arrays are not equal
+    <BLANKLINE>
+    (shapes (2, 5), () mismatch)
+     x: torch.ndarray([[3, 3, 3, 3, 3],
+            [3, 3, 3, 3, 3]])
+     y: torch.ndarray(3)
+
+    The `strict` parameter also ensures that the array data types match:
+
+    >>> x = np.array([2, 2, 2])
+    >>> y = np.array([2.0, 2.0, 2.0], dtype=np.float32)
+    >>> np.testing.assert_array_equal(x, y, strict=True)
+    Traceback (most recent call last):
+        ...
+    AssertionError:
+    Arrays are not equal
+    <BLANKLINE>
+    (dtypes dtype("int64"), dtype("float32") mismatch)
+     x: torch.ndarray([2, 2, 2])
+     y: torch.ndarray([2., 2., 2.])
+    """
+    __tracebackhide__ = True  # Hide traceback for py.test
+    assert_array_compare(
+        operator.__eq__,
+        x,
+        y,
+        err_msg=err_msg,
+        verbose=verbose,
+        header="Arrays are not equal",
+        strict=strict,
+    )
+
+
+def assert_array_almost_equal(x, y, decimal=6, err_msg="", verbose=True):
+    """
+    Raises an AssertionError if two objects are not equal up to desired
+    precision.
+
+    .. note:: It is recommended to use one of `assert_allclose`,
+              `assert_array_almost_equal_nulp` or `assert_array_max_ulp`
+              instead of this function for more consistent floating point
+              comparisons.
+
+    The test verifies identical shapes and that the elements of ``actual`` and
+    ``desired`` satisfy.
+
+        ``abs(desired-actual) < 1.5 * 10**(-decimal)``
+
+    That is a looser test than originally documented, but agrees with what the
+    actual implementation did up to rounding vagaries. An exception is raised
+    at shape mismatch or conflicting values. In contrast to the standard usage
+    in numpy, NaNs are compared like numbers, no assertion is raised if both
+    objects have NaNs in the same positions.
+
+    Parameters
+    ----------
+    x : array_like
+        The actual object to check.
+    y : array_like
+        The desired, expected object.
+    decimal : int, optional
+        Desired precision, default is 6.
+    err_msg : str, optional
+      The error message to be printed in case of failure.
+    verbose : bool, optional
+        If True, the conflicting values are appended to the error message.
+
+    Raises
+    ------
+    AssertionError
+        If actual and desired are not equal up to specified precision.
+
+    See Also
+    --------
+    assert_allclose: Compare two array_like objects for equality with desired
+                     relative and/or absolute precision.
+    assert_array_almost_equal_nulp, assert_array_max_ulp, assert_equal
+
+    Examples
+    --------
+    the first assert does not raise an exception
+
+    >>> np.testing.assert_array_almost_equal([1.0, 2.333, np.nan], [1.0, 2.333, np.nan])
+
+    >>> np.testing.assert_array_almost_equal(
+    ...     [1.0, 2.33333, np.nan], [1.0, 2.33339, np.nan], decimal=5
+    ... )
+    Traceback (most recent call last):
+        ...
+    AssertionError:
+    Arrays are not almost equal to 5 decimals
+    <BLANKLINE>
+    Mismatched elements: 1 / 3 (33.3%)
+    Max absolute difference: 5.999999999994898e-05
+    Max relative difference: 2.5713661239633743e-05
+     x: torch.ndarray([1.0000, 2.3333,    nan], dtype=float64)
+     y: torch.ndarray([1.0000, 2.3334,    nan], dtype=float64)
+
+    >>> np.testing.assert_array_almost_equal(
+    ...     [1.0, 2.33333, np.nan], [1.0, 2.33333, 5], decimal=5
+    ... )
+    Traceback (most recent call last):
+        ...
+    AssertionError:
+    Arrays are not almost equal to 5 decimals
+    <BLANKLINE>
+    x and y nan location mismatch:
+     x: torch.ndarray([1.0000, 2.3333,    nan], dtype=float64)
+     y: torch.ndarray([1.0000, 2.3333, 5.0000], dtype=float64)
+
+    """
+    __tracebackhide__ = True  # Hide traceback for py.test
+    from torch._numpy import any as npany, float_, issubdtype, number, result_type
+
+    def compare(x, y):
+        try:
+            if npany(gisinf(x)) or npany(gisinf(y)):
+                xinfid = gisinf(x)
+                yinfid = gisinf(y)
+                if not (xinfid == yinfid).all():
+                    return False
+                # if one item, x and y is +- inf
+                if x.size == y.size == 1:
+                    return x == y
+                x = x[~xinfid]
+                y = y[~yinfid]
+        except (TypeError, NotImplementedError):
+            pass
+
+        # make sure y is an inexact type to avoid abs(MIN_INT); will cause
+        # casting of x later.
+        dtype = result_type(y, 1.0)
+        y = asanyarray(y, dtype)
+        z = abs(x - y)
+
+        if not issubdtype(z.dtype, number):
+            z = z.astype(float_)  # handle object arrays
+
+        return z < 1.5 * 10.0 ** (-decimal)
+
+    assert_array_compare(
+        compare,
+        x,
+        y,
+        err_msg=err_msg,
+        verbose=verbose,
+        header=f"Arrays are not almost equal to {decimal:d} decimals",
+        precision=decimal,
+    )
+
+
+def assert_array_less(x, y, err_msg="", verbose=True):
+    """
+    Raises an AssertionError if two array_like objects are not ordered by less
+    than.
+
+    Given two array_like objects, check that the shape is equal and all
+    elements of the first object are strictly smaller than those of the
+    second object. An exception is raised at shape mismatch or incorrectly
+    ordered values. Shape mismatch does not raise if an object has zero
+    dimension. In contrast to the standard usage in numpy, NaNs are
+    compared, no assertion is raised if both objects have NaNs in the same
+    positions.
+
+
+
+    Parameters
+    ----------
+    x : array_like
+      The smaller object to check.
+    y : array_like
+      The larger object to compare.
+    err_msg : string
+      The error message to be printed in case of failure.
+    verbose : bool
+        If True, the conflicting values are appended to the error message.
+
+    Raises
+    ------
+    AssertionError
+      If actual and desired objects are not equal.
+
+    See Also
+    --------
+    assert_array_equal: tests objects for equality
+    assert_array_almost_equal: test objects for equality up to precision
+
+
+
+    Examples
+    --------
+    >>> np.testing.assert_array_less([1.0, 1.0, np.nan], [1.1, 2.0, np.nan])
+    >>> np.testing.assert_array_less([1.0, 1.0, np.nan], [1, 2.0, np.nan])
+    Traceback (most recent call last):
+        ...
+    AssertionError:
+    Arrays are not less-ordered
+    <BLANKLINE>
+    Mismatched elements: 1 / 3 (33.3%)
+    Max absolute difference: 1.0
+    Max relative difference: 0.5
+     x: torch.ndarray([1.,  1., nan], dtype=float64)
+     y: torch.ndarray([1.,  2., nan], dtype=float64)
+
+    >>> np.testing.assert_array_less([1.0, 4.0], 3)
+    Traceback (most recent call last):
+        ...
+    AssertionError:
+    Arrays are not less-ordered
+    <BLANKLINE>
+    Mismatched elements: 1 / 2 (50%)
+    Max absolute difference: 2.0
+    Max relative difference: 0.6666666666666666
+     x: torch.ndarray([1., 4.], dtype=float64)
+     y: torch.ndarray(3)
+
+    >>> np.testing.assert_array_less([1.0, 2.0, 3.0], [4])
+    Traceback (most recent call last):
+        ...
+    AssertionError:
+    Arrays are not less-ordered
+    <BLANKLINE>
+    (shapes (3,), (1,) mismatch)
+     x: torch.ndarray([1., 2., 3.], dtype=float64)
+     y: torch.ndarray([4])
+
+    """
+    __tracebackhide__ = True  # Hide traceback for py.test
+    assert_array_compare(
+        operator.__lt__,
+        x,
+        y,
+        err_msg=err_msg,
+        verbose=verbose,
+        header="Arrays are not less-ordered",
+        equal_inf=False,
+    )
+
+
+def assert_string_equal(actual, desired):
+    """
+    Test if two strings are equal.
+
+    If the given strings are equal, `assert_string_equal` does nothing.
+    If they are not equal, an AssertionError is raised, and the diff
+    between the strings is shown.
+
+    Parameters
+    ----------
+    actual : str
+        The string to test for equality against the expected string.
+    desired : str
+        The expected string.
+
+    Examples
+    --------
+    >>> np.testing.assert_string_equal("abc", "abc")  # doctest: +SKIP
+    >>> np.testing.assert_string_equal("abc", "abcd")  # doctest: +SKIP
+    Traceback (most recent call last):
+      File "<stdin>", line 1, in <module>
+    ...
+    AssertionError: Differences in strings:
+    - abc+ abcd?    +
+
+    """
+    # delay import of difflib to reduce startup time
+    __tracebackhide__ = True  # Hide traceback for py.test
+    import difflib
+
+    if not isinstance(actual, str):
+        raise AssertionError(repr(type(actual)))
+    if not isinstance(desired, str):
+        raise AssertionError(repr(type(desired)))
+    if desired == actual:
+        return
+
+    diff = list(
+        difflib.Differ().compare(actual.splitlines(True), desired.splitlines(True))
+    )
+    diff_list = []
+    while diff:
+        d1 = diff.pop(0)
+        if d1.startswith("  "):
+            continue
+        if d1.startswith("- "):
+            l = [d1]
+            d2 = diff.pop(0)
+            if d2.startswith("? "):
+                l.append(d2)
+                d2 = diff.pop(0)
+            if not d2.startswith("+ "):
+                raise AssertionError(repr(d2))
+            l.append(d2)
+            if diff:
+                d3 = diff.pop(0)
+                if d3.startswith("? "):
+                    l.append(d3)
+                else:
+                    diff.insert(0, d3)
+            if d2[2:] == d1[2:]:
+                continue
+            diff_list.extend(l)
+            continue
+        raise AssertionError(repr(d1))
+    if not diff_list:
+        return
+    msg = f"Differences in strings:\n{''.join(diff_list).rstrip()}"
+    if actual != desired:
+        raise AssertionError(msg)
+
+
+import unittest
+
+
+class _Dummy(unittest.TestCase):
+    def nop(self):
+        pass
+
+
+_d = _Dummy("nop")
+
+
+def assert_raises_regex(exception_class, expected_regexp, *args, **kwargs):
+    """
+    assert_raises_regex(exception_class, expected_regexp, callable, *args,
+                        **kwargs)
+    assert_raises_regex(exception_class, expected_regexp)
+
+    Fail unless an exception of class exception_class and with message that
+    matches expected_regexp is thrown by callable when invoked with arguments
+    args and keyword arguments kwargs.
+
+    Alternatively, can be used as a context manager like `assert_raises`.
+
+    Notes
+    -----
+    .. versionadded:: 1.9.0
+
+    """
+    __tracebackhide__ = True  # Hide traceback for py.test
+    return _d.assertRaisesRegex(exception_class, expected_regexp, *args, **kwargs)
+
+
+def decorate_methods(cls, decorator, testmatch=None):
+    """
+    Apply a decorator to all methods in a class matching a regular expression.
+
+    The given decorator is applied to all public methods of `cls` that are
+    matched by the regular expression `testmatch`
+    (``testmatch.search(methodname)``). Methods that are private, i.e. start
+    with an underscore, are ignored.
+
+    Parameters
+    ----------
+    cls : class
+        Class whose methods to decorate.
+    decorator : function
+        Decorator to apply to methods
+    testmatch : compiled regexp or str, optional
+        The regular expression. Default value is None, in which case the
+        nose default (``re.compile(r'(?:^|[\\b_\\.%s-])[Tt]est' % os.sep)``)
+        is used.
+        If `testmatch` is a string, it is compiled to a regular expression
+        first.
+
+    """
+    if testmatch is None:
+        testmatch = re.compile(rf"(?:^|[\\b_\\.{os.sep}-])[Tt]est")
+    else:
+        testmatch = re.compile(testmatch)
+    cls_attr = cls.__dict__
+
+    # delayed import to reduce startup time
+    from inspect import isfunction
+
+    methods = [_m for _m in cls_attr.values() if isfunction(_m)]
+    for function in methods:
+        try:
+            if hasattr(function, "compat_func_name"):
+                funcname = function.compat_func_name
+            else:
+                funcname = function.__name__
+        except AttributeError:
+            # not a function
+            continue
+        if testmatch.search(funcname) and not funcname.startswith("_"):
+            setattr(cls, funcname, decorator(function))
+    return
+
+
+def _assert_valid_refcount(op):
+    """
+    Check that ufuncs don't mishandle refcount of object `1`.
+    Used in a few regression tests.
+    """
+    if not HAS_REFCOUNT:
+        return True
+
+    import gc
+
+    import numpy as np
+
+    b = np.arange(100 * 100).reshape(100, 100)
+    c = b
+    i = 1
+
+    gc.disable()
+    try:
+        rc = sys.getrefcount(i)
+        for _ in range(15):
+            d = op(b, c)
+        assert_(sys.getrefcount(i) >= rc)
+    finally:
+        gc.enable()
+    del d  # for pyflakes
+
+
+def assert_allclose(
+    actual,
+    desired,
+    rtol=1e-7,
+    atol=0,
+    equal_nan=True,
+    err_msg="",
+    verbose=True,
+    check_dtype=False,
+):
+    """
+    Raises an AssertionError if two objects are not equal up to desired
+    tolerance.
+
+    Given two array_like objects, check that their shapes and all elements
+    are equal (but see the Notes for the special handling of a scalar). An
+    exception is raised if the shapes mismatch or any values conflict. In
+    contrast to the standard usage in numpy, NaNs are compared like numbers,
+    no assertion is raised if both objects have NaNs in the same positions.
+
+    The test is equivalent to ``allclose(actual, desired, rtol, atol)`` (note
+    that ``allclose`` has different default values). It compares the difference
+    between `actual` and `desired` to ``atol + rtol * abs(desired)``.
+
+    .. versionadded:: 1.5.0
+
+    Parameters
+    ----------
+    actual : array_like
+        Array obtained.
+    desired : array_like
+        Array desired.
+    rtol : float, optional
+        Relative tolerance.
+    atol : float, optional
+        Absolute tolerance.
+    equal_nan : bool, optional.
+        If True, NaNs will compare equal.
+    err_msg : str, optional
+        The error message to be printed in case of failure.
+    verbose : bool, optional
+        If True, the conflicting values are appended to the error message.
+
+    Raises
+    ------
+    AssertionError
+        If actual and desired are not equal up to specified precision.
+
+    See Also
+    --------
+    assert_array_almost_equal_nulp, assert_array_max_ulp
+
+    Notes
+    -----
+    When one of `actual` and `desired` is a scalar and the other is
+    array_like, the function checks that each element of the array_like
+    object is equal to the scalar.
+
+    Examples
+    --------
+    >>> x = [1e-5, 1e-3, 1e-1]
+    >>> y = np.arccos(np.cos(x))
+    >>> np.testing.assert_allclose(x, y, rtol=1e-5, atol=0)
+
+    """
+    __tracebackhide__ = True  # Hide traceback for py.test
+
+    def compare(x, y):
+        return np.isclose(x, y, rtol=rtol, atol=atol, equal_nan=equal_nan)
+
+    actual, desired = asanyarray(actual), asanyarray(desired)
+    header = f"Not equal to tolerance rtol={rtol:g}, atol={atol:g}"
+
+    if check_dtype:
+        if actual.dtype != desired.dtype:
+            raise AssertionError(f"dtype mismatch: {actual.dtype} != {desired.dtype}")
+
+    assert_array_compare(
+        compare,
+        actual,
+        desired,
+        err_msg=str(err_msg),
+        verbose=verbose,
+        header=header,
+        equal_nan=equal_nan,
+    )
+
+
+def assert_array_almost_equal_nulp(x, y, nulp=1):
+    """
+    Compare two arrays relatively to their spacing.
+
+    This is a relatively robust method to compare two arrays whose amplitude
+    is variable.
+
+    Parameters
+    ----------
+    x, y : array_like
+        Input arrays.
+    nulp : int, optional
+        The maximum number of unit in the last place for tolerance (see Notes).
+        Default is 1.
+
+    Returns
+    -------
+    None
+
+    Raises
+    ------
+    AssertionError
+        If the spacing between `x` and `y` for one or more elements is larger
+        than `nulp`.
+
+    See Also
+    --------
+    assert_array_max_ulp : Check that all items of arrays differ in at most
+        N Units in the Last Place.
+    spacing : Return the distance between x and the nearest adjacent number.
+
+    Notes
+    -----
+    An assertion is raised if the following condition is not met::
+
+        abs(x - y) <= nulp * spacing(maximum(abs(x), abs(y)))
+
+    Examples
+    --------
+    >>> x = np.array([1.0, 1e-10, 1e-20])
+    >>> eps = np.finfo(x.dtype).eps
+    >>> np.testing.assert_array_almost_equal_nulp(x, x * eps / 2 + x)  # doctest: +SKIP
+
+    >>> np.testing.assert_array_almost_equal_nulp(x, x * eps + x)  # doctest: +SKIP
+    Traceback (most recent call last):
+      ...
+    AssertionError: X and Y are not equal to 1 ULP (max is 2)
+
+    """
+    __tracebackhide__ = True  # Hide traceback for py.test
+    import numpy as np
+
+    ax = np.abs(x)
+    ay = np.abs(y)
+    ref = nulp * np.spacing(np.where(ax > ay, ax, ay))
+    if not np.all(np.abs(x - y) <= ref):
+        if np.iscomplexobj(x) or np.iscomplexobj(y):
+            msg = f"X and Y are not equal to {nulp:d} ULP"
+        else:
+            max_nulp = np.max(nulp_diff(x, y))
+            msg = f"X and Y are not equal to {nulp:d} ULP (max is {max_nulp:g})"
+        raise AssertionError(msg)
+
+
+def assert_array_max_ulp(a, b, maxulp=1, dtype=None):
+    """
+    Check that all items of arrays differ in at most N Units in the Last Place.
+
+    Parameters
+    ----------
+    a, b : array_like
+        Input arrays to be compared.
+    maxulp : int, optional
+        The maximum number of units in the last place that elements of `a` and
+        `b` can differ. Default is 1.
+    dtype : dtype, optional
+        Data-type to convert `a` and `b` to if given. Default is None.
+
+    Returns
+    -------
+    ret : ndarray
+        Array containing number of representable floating point numbers between
+        items in `a` and `b`.
+
+    Raises
+    ------
+    AssertionError
+        If one or more elements differ by more than `maxulp`.
+
+    Notes
+    -----
+    For computing the ULP difference, this API does not differentiate between
+    various representations of NAN (ULP difference between 0x7fc00000 and 0xffc00000
+    is zero).
+
+    See Also
+    --------
+    assert_array_almost_equal_nulp : Compare two arrays relatively to their
+        spacing.
+
+    Examples
+    --------
+    >>> a = np.linspace(0.0, 1.0, 100)
+    >>> res = np.testing.assert_array_max_ulp(a, np.arcsin(np.sin(a)))  # doctest: +SKIP
+
+    """
+    __tracebackhide__ = True  # Hide traceback for py.test
+    import numpy as np
+
+    ret = nulp_diff(a, b, dtype)
+    if not np.all(ret <= maxulp):
+        raise AssertionError(
+            f"Arrays are not almost equal up to {maxulp:g} "
+            f"ULP (max difference is {np.max(ret):g} ULP)"
+        )
+    return ret
+
+
+def nulp_diff(x, y, dtype=None):
+    """For each item in x and y, return the number of representable floating
+    points between them.
+
+    Parameters
+    ----------
+    x : array_like
+        first input array
+    y : array_like
+        second input array
+    dtype : dtype, optional
+        Data-type to convert `x` and `y` to if given. Default is None.
+
+    Returns
+    -------
+    nulp : array_like
+        number of representable floating point numbers between each item in x
+        and y.
+
+    Notes
+    -----
+    For computing the ULP difference, this API does not differentiate between
+    various representations of NAN (ULP difference between 0x7fc00000 and 0xffc00000
+    is zero).
+
+    Examples
+    --------
+    # By definition, epsilon is the smallest number such as 1 + eps != 1, so
+    # there should be exactly one ULP between 1 and 1 + eps
+    >>> nulp_diff(1, 1 + np.finfo(x.dtype).eps)  # doctest: +SKIP
+    1.0
+    """
+    import numpy as np
+
+    if dtype:
+        x = np.asarray(x, dtype=dtype)
+        y = np.asarray(y, dtype=dtype)
+    else:
+        x = np.asarray(x)
+        y = np.asarray(y)
+
+    t = np.common_type(x, y)
+    if np.iscomplexobj(x) or np.iscomplexobj(y):
+        raise NotImplementedError("_nulp not implemented for complex array")
+
+    x = np.array([x], dtype=t)
+    y = np.array([y], dtype=t)
+
+    x[np.isnan(x)] = np.nan
+    y[np.isnan(y)] = np.nan
+
+    if not x.shape == y.shape:
+        raise ValueError(f"x and y do not have the same shape: {x.shape} - {y.shape}")
+
+    def _diff(rx, ry, vdt):
+        diff = np.asarray(rx - ry, dtype=vdt)
+        return np.abs(diff)
+
+    rx = integer_repr(x)
+    ry = integer_repr(y)
+    return _diff(rx, ry, t)
+
+
+def _integer_repr(x, vdt, comp):
+    # Reinterpret binary representation of the float as sign-magnitude:
+    # take into account two's-complement representation
+    # See also
+    # https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/
+    rx = x.view(vdt)
+    if rx.size != 1:
+        rx[rx < 0] = comp - rx[rx < 0]
+    else:
+        if rx < 0:
+            rx = comp - rx
+
+    return rx
+
+
+def integer_repr(x):
+    """Return the signed-magnitude interpretation of the binary representation
+    of x."""
+    import numpy as np
+
+    if x.dtype == np.float16:
+        return _integer_repr(x, np.int16, np.int16(-(2**15)))
+    elif x.dtype == np.float32:
+        return _integer_repr(x, np.int32, np.int32(-(2**31)))
+    elif x.dtype == np.float64:
+        return _integer_repr(x, np.int64, np.int64(-(2**63)))
+    else:
+        raise ValueError(f"Unsupported dtype {x.dtype}")
+
+
+@contextlib.contextmanager
+def _assert_warns_context(warning_class, name=None):
+    __tracebackhide__ = True  # Hide traceback for py.test
+    with suppress_warnings() as sup:
+        l = sup.record(warning_class)
+        yield
+        if not len(l) > 0:
+            name_str = f" when calling {name}" if name is not None else ""
+            raise AssertionError("No warning raised" + name_str)
+
+
+def assert_warns(warning_class, *args, **kwargs):
+    """
+    Fail unless the given callable throws the specified warning.
+
+    A warning of class warning_class should be thrown by the callable when
+    invoked with arguments args and keyword arguments kwargs.
+    If a different type of warning is thrown, it will not be caught.
+
+    If called with all arguments other than the warning class omitted, may be
+    used as a context manager:
+
+        with assert_warns(SomeWarning):
+            do_something()
+
+    The ability to be used as a context manager is new in NumPy v1.11.0.
+
+    .. versionadded:: 1.4.0
+
+    Parameters
+    ----------
+    warning_class : class
+        The class defining the warning that `func` is expected to throw.
+    func : callable, optional
+        Callable to test
+    *args : Arguments
+        Arguments for `func`.
+    **kwargs : Kwargs
+        Keyword arguments for `func`.
+
+    Returns
+    -------
+    The value returned by `func`.
+
+    Examples
+    --------
+    >>> import warnings
+    >>> def deprecated_func(num):
+    ...     warnings.warn("Please upgrade", DeprecationWarning)
+    ...     return num * num
+    >>> with np.testing.assert_warns(DeprecationWarning):
+    ...     assert deprecated_func(4) == 16
+    >>> # or passing a func
+    >>> ret = np.testing.assert_warns(DeprecationWarning, deprecated_func, 4)
+    >>> assert ret == 16
+    """
+    if not args:
+        return _assert_warns_context(warning_class)
+
+    func = args[0]
+    args = args[1:]
+    with _assert_warns_context(warning_class, name=func.__name__):
+        return func(*args, **kwargs)
+
+
+@contextlib.contextmanager
+def _assert_no_warnings_context(name=None):
+    __tracebackhide__ = True  # Hide traceback for py.test
+    with warnings.catch_warnings(record=True) as l:
+        warnings.simplefilter("always")
+        yield
+        if len(l) > 0:
+            name_str = f" when calling {name}" if name is not None else ""
+            raise AssertionError(f"Got warnings{name_str}: {l}")
+
+
+def assert_no_warnings(*args, **kwargs):
+    """
+    Fail if the given callable produces any warnings.
+
+    If called with all arguments omitted, may be used as a context manager:
+
+        with assert_no_warnings():
+            do_something()
+
+    The ability to be used as a context manager is new in NumPy v1.11.0.
+
+    .. versionadded:: 1.7.0
+
+    Parameters
+    ----------
+    func : callable
+        The callable to test.
+    \\*args : Arguments
+        Arguments passed to `func`.
+    \\*\\*kwargs : Kwargs
+        Keyword arguments passed to `func`.
+
+    Returns
+    -------
+    The value returned by `func`.
+
+    """
+    if not args:
+        return _assert_no_warnings_context()
+
+    func = args[0]
+    args = args[1:]
+    with _assert_no_warnings_context(name=func.__name__):
+        return func(*args, **kwargs)
+
+
+def _gen_alignment_data(dtype=float32, type="binary", max_size=24):
+    """
+    generator producing data with different alignment and offsets
+    to test simd vectorization
+
+    Parameters
+    ----------
+    dtype : dtype
+        data type to produce
+    type : string
+        'unary': create data for unary operations, creates one input
+                 and output array
+        'binary': create data for binary operations, creates two input
+                 and output array
+    max_size : integer
+        maximum size of data to produce
+
+    Returns
+    -------
+    if type is 'unary' yields one output, one input array and a message
+    containing information on the data
+    if type is 'binary' yields one output array, two input array and a message
+    containing information on the data
+
+    """
+    ufmt = "unary offset=(%d, %d), size=%d, dtype=%r, %s"
+    bfmt = "binary offset=(%d, %d, %d), size=%d, dtype=%r, %s"
+    for o in range(3):
+        for s in range(o + 2, max(o + 3, max_size)):
+            if type == "unary":
+
+                def inp():
+                    return arange(s, dtype=dtype)[o:]
+
+                out = empty((s,), dtype=dtype)[o:]
+                yield out, inp(), ufmt % (o, o, s, dtype, "out of place")
+                d = inp()
+                yield d, d, ufmt % (o, o, s, dtype, "in place")
+                yield (
+                    out[1:],
+                    inp()[:-1],
+                    ufmt
+                    % (
+                        o + 1,
+                        o,
+                        s - 1,
+                        dtype,
+                        "out of place",
+                    ),
+                )
+                yield (
+                    out[:-1],
+                    inp()[1:],
+                    ufmt
+                    % (
+                        o,
+                        o + 1,
+                        s - 1,
+                        dtype,
+                        "out of place",
+                    ),
+                )
+                yield inp()[:-1], inp()[1:], ufmt % (o, o + 1, s - 1, dtype, "aliased")
+                yield inp()[1:], inp()[:-1], ufmt % (o + 1, o, s - 1, dtype, "aliased")
+            if type == "binary":
+
+                def inp1():
+                    return arange(s, dtype=dtype)[o:]
+
+                inp2 = inp1
+                out = empty((s,), dtype=dtype)[o:]
+                yield out, inp1(), inp2(), bfmt % (o, o, o, s, dtype, "out of place")
+                d = inp1()
+                yield d, d, inp2(), bfmt % (o, o, o, s, dtype, "in place1")
+                d = inp2()
+                yield d, inp1(), d, bfmt % (o, o, o, s, dtype, "in place2")
+                yield (
+                    out[1:],
+                    inp1()[:-1],
+                    inp2()[:-1],
+                    bfmt
+                    % (
+                        o + 1,
+                        o,
+                        o,
+                        s - 1,
+                        dtype,
+                        "out of place",
+                    ),
+                )
+                yield (
+                    out[:-1],
+                    inp1()[1:],
+                    inp2()[:-1],
+                    bfmt
+                    % (
+                        o,
+                        o + 1,
+                        o,
+                        s - 1,
+                        dtype,
+                        "out of place",
+                    ),
+                )
+                yield (
+                    out[:-1],
+                    inp1()[:-1],
+                    inp2()[1:],
+                    bfmt
+                    % (
+                        o,
+                        o,
+                        o + 1,
+                        s - 1,
+                        dtype,
+                        "out of place",
+                    ),
+                )
+                yield (
+                    inp1()[1:],
+                    inp1()[:-1],
+                    inp2()[:-1],
+                    bfmt
+                    % (
+                        o + 1,
+                        o,
+                        o,
+                        s - 1,
+                        dtype,
+                        "aliased",
+                    ),
+                )
+                yield (
+                    inp1()[:-1],
+                    inp1()[1:],
+                    inp2()[:-1],
+                    bfmt
+                    % (
+                        o,
+                        o + 1,
+                        o,
+                        s - 1,
+                        dtype,
+                        "aliased",
+                    ),
+                )
+                yield (
+                    inp1()[:-1],
+                    inp1()[:-1],
+                    inp2()[1:],
+                    bfmt
+                    % (
+                        o,
+                        o,
+                        o + 1,
+                        s - 1,
+                        dtype,
+                        "aliased",
+                    ),
+                )
+
+
+class IgnoreException(Exception):
+    "Ignoring this exception due to disabled feature"
+
+
+@contextlib.contextmanager
+def tempdir(*args, **kwargs):
+    """Context manager to provide a temporary test folder.
+
+    All arguments are passed as this to the underlying tempfile.mkdtemp
+    function.
+
+    """
+    tmpdir = mkdtemp(*args, **kwargs)
+    try:
+        yield tmpdir
+    finally:
+        shutil.rmtree(tmpdir)
+
+
+@contextlib.contextmanager
+def temppath(*args, **kwargs):
+    """Context manager for temporary files.
+
+    Context manager that returns the path to a closed temporary file. Its
+    parameters are the same as for tempfile.mkstemp and are passed directly
+    to that function. The underlying file is removed when the context is
+    exited, so it should be closed at that time.
+
+    Windows does not allow a temporary file to be opened if it is already
+    open, so the underlying file must be closed after opening before it
+    can be opened again.
+
+    """
+    fd, path = mkstemp(*args, **kwargs)
+    os.close(fd)
+    try:
+        yield path
+    finally:
+        os.remove(path)
+
+
+class clear_and_catch_warnings(warnings.catch_warnings):
+    """Context manager that resets warning registry for catching warnings
+
+    Warnings can be slippery, because, whenever a warning is triggered, Python
+    adds a ``__warningregistry__`` member to the *calling* module.  This makes
+    it impossible to retrigger the warning in this module, whatever you put in
+    the warnings filters.  This context manager accepts a sequence of `modules`
+    as a keyword argument to its constructor and:
+
+    * stores and removes any ``__warningregistry__`` entries in given `modules`
+      on entry;
+    * resets ``__warningregistry__`` to its previous state on exit.
+
+    This makes it possible to trigger any warning afresh inside the context
+    manager without disturbing the state of warnings outside.
+
+    For compatibility with Python 3.0, please consider all arguments to be
+    keyword-only.
+
+    Parameters
+    ----------
+    record : bool, optional
+        Specifies whether warnings should be captured by a custom
+        implementation of ``warnings.showwarning()`` and be appended to a list
+        returned by the context manager. Otherwise None is returned by the
+        context manager. The objects appended to the list are arguments whose
+        attributes mirror the arguments to ``showwarning()``.
+    modules : sequence, optional
+        Sequence of modules for which to reset warnings registry on entry and
+        restore on exit. To work correctly, all 'ignore' filters should
+        filter by one of these modules.
+
+    Examples
+    --------
+    >>> import warnings
+    >>> with np.testing.clear_and_catch_warnings(  # doctest: +SKIP
+    ...     modules=[np.core.fromnumeric]
+    ... ):
+    ...     warnings.simplefilter("always")
+    ...     warnings.filterwarnings("ignore", module="np.core.fromnumeric")
+    ...     # do something that raises a warning but ignore those in
+    ...     # np.core.fromnumeric
+    """
+
+    class_modules = ()
+
+    def __init__(self, record=False, modules=()):
+        self.modules = set(modules).union(self.class_modules)
+        self._warnreg_copies = {}
+        super().__init__(record=record)
+
+    def __enter__(self):
+        for mod in self.modules:
+            if hasattr(mod, "__warningregistry__"):
+                mod_reg = mod.__warningregistry__
+                self._warnreg_copies[mod] = mod_reg.copy()
+                mod_reg.clear()
+        return super().__enter__()
+
+    def __exit__(self, *exc_info):
+        super().__exit__(*exc_info)
+        for mod in self.modules:
+            if hasattr(mod, "__warningregistry__"):
+                mod.__warningregistry__.clear()
+            if mod in self._warnreg_copies:
+                mod.__warningregistry__.update(self._warnreg_copies[mod])
+
+
+class suppress_warnings:
+    """
+    Context manager and decorator doing much the same as
+    ``warnings.catch_warnings``.
+
+    However, it also provides a filter mechanism to work around
+    https://bugs.python.org/issue4180.
+
+    This bug causes Python before 3.4 to not reliably show warnings again
+    after they have been ignored once (even within catch_warnings). It
+    means that no "ignore" filter can be used easily, since following
+    tests might need to see the warning. Additionally it allows easier
+    specificity for testing warnings and can be nested.
+
+    Parameters
+    ----------
+    forwarding_rule : str, optional
+        One of "always", "once", "module", or "location". Analogous to
+        the usual warnings module filter mode, it is useful to reduce
+        noise mostly on the outmost level. Unsuppressed and unrecorded
+        warnings will be forwarded based on this rule. Defaults to "always".
+        "location" is equivalent to the warnings "default", match by exact
+        location the warning originated from.
+
+    Notes
+    -----
+    Filters added inside the context manager will be discarded again
+    when leaving it. Upon entering all filters defined outside a
+    context will be applied automatically.
+
+    When a recording filter is added, matching warnings are stored in the
+    ``log`` attribute as well as in the list returned by ``record``.
+
+    If filters are added and the ``module`` keyword is given, the
+    warning registry of this module will additionally be cleared when
+    applying it, entering the context, or exiting it. This could cause
+    warnings to appear a second time after leaving the context if they
+    were configured to be printed once (default) and were already
+    printed before the context was entered.
+
+    Nesting this context manager will work as expected when the
+    forwarding rule is "always" (default). Unfiltered and unrecorded
+    warnings will be passed out and be matched by the outer level.
+    On the outmost level they will be printed (or caught by another
+    warnings context). The forwarding rule argument can modify this
+    behaviour.
+
+    Like ``catch_warnings`` this context manager is not threadsafe.
+
+    Examples
+    --------
+
+    With a context manager::
+
+        with np.testing.suppress_warnings() as sup:
+            sup.filter(DeprecationWarning, "Some text")
+            sup.filter(module=np.ma.core)
+            log = sup.record(FutureWarning, "Does this occur?")
+            command_giving_warnings()
+            # The FutureWarning was given once, the filtered warnings were
+            # ignored. All other warnings abide outside settings (may be
+            # printed/error)
+            assert_(len(log) == 1)
+            assert_(len(sup.log) == 1)  # also stored in log attribute
+
+    Or as a decorator::
+
+        sup = np.testing.suppress_warnings()
+        sup.filter(module=np.ma.core)  # module must match exactly
+
+
+        @sup
+        def some_function():
+            # do something which causes a warning in np.ma.core
+            pass
+    """
+
+    def __init__(self, forwarding_rule="always"):
+        self._entered = False
+
+        # Suppressions are either instance or defined inside one with block:
+        self._suppressions = []
+
+        if forwarding_rule not in {"always", "module", "once", "location"}:
+            raise ValueError("unsupported forwarding rule.")
+        self._forwarding_rule = forwarding_rule
+
+    def _clear_registries(self):
+        if hasattr(warnings, "_filters_mutated"):
+            # clearing the registry should not be necessary on new pythons,
+            # instead the filters should be mutated.
+            warnings._filters_mutated()
+            return
+        # Simply clear the registry, this should normally be harmless,
+        # note that on new pythons it would be invalidated anyway.
+        for module in self._tmp_modules:
+            if hasattr(module, "__warningregistry__"):
+                module.__warningregistry__.clear()
+
+    def _filter(self, category=Warning, message="", module=None, record=False):
+        if record:
+            record = []  # The log where to store warnings
+        else:
+            record = None
+        if self._entered:
+            if module is None:
+                warnings.filterwarnings("always", category=category, message=message)
+            else:
+                module_regex = module.__name__.replace(".", r"\.") + "$"
+                warnings.filterwarnings(
+                    "always", category=category, message=message, module=module_regex
+                )
+                self._tmp_modules.add(module)
+                self._clear_registries()
+
+            self._tmp_suppressions.append(
+                (category, message, re.compile(message, re.IGNORECASE), module, record)
+            )
+        else:
+            self._suppressions.append(
+                (category, message, re.compile(message, re.IGNORECASE), module, record)
+            )
+
+        return record
+
+    def filter(self, category=Warning, message="", module=None):
+        """
+        Add a new suppressing filter or apply it if the state is entered.
+
+        Parameters
+        ----------
+        category : class, optional
+            Warning class to filter
+        message : string, optional
+            Regular expression matching the warning message.
+        module : module, optional
+            Module to filter for. Note that the module (and its file)
+            must match exactly and cannot be a submodule. This may make
+            it unreliable for external modules.
+
+        Notes
+        -----
+        When added within a context, filters are only added inside
+        the context and will be forgotten when the context is exited.
+        """
+        self._filter(category=category, message=message, module=module, record=False)
+
+    def record(self, category=Warning, message="", module=None):
+        """
+        Append a new recording filter or apply it if the state is entered.
+
+        All warnings matching will be appended to the ``log`` attribute.
+
+        Parameters
+        ----------
+        category : class, optional
+            Warning class to filter
+        message : string, optional
+            Regular expression matching the warning message.
+        module : module, optional
+            Module to filter for. Note that the module (and its file)
+            must match exactly and cannot be a submodule. This may make
+            it unreliable for external modules.
+
+        Returns
+        -------
+        log : list
+            A list which will be filled with all matched warnings.
+
+        Notes
+        -----
+        When added within a context, filters are only added inside
+        the context and will be forgotten when the context is exited.
+        """
+        return self._filter(
+            category=category, message=message, module=module, record=True
+        )
+
+    def __enter__(self):
+        if self._entered:
+            raise RuntimeError("cannot enter suppress_warnings twice.")
+
+        self._orig_show = warnings.showwarning
+        self._filters = warnings.filters
+        warnings.filters = self._filters[:]
+
+        self._entered = True
+        self._tmp_suppressions = []
+        self._tmp_modules = set()
+        self._forwarded = set()
+
+        self.log = []  # reset global log (no need to keep same list)
+
+        for cat, mess, _, mod, log in self._suppressions:
+            if log is not None:
+                del log[:]  # clear the log
+            if mod is None:
+                warnings.filterwarnings("always", category=cat, message=mess)
+            else:
+                module_regex = mod.__name__.replace(".", r"\.") + "$"
+                warnings.filterwarnings(
+                    "always", category=cat, message=mess, module=module_regex
+                )
+                self._tmp_modules.add(mod)
+        warnings.showwarning = self._showwarning
+        self._clear_registries()
+
+        return self
+
+    def __exit__(self, *exc_info):
+        warnings.showwarning = self._orig_show
+        warnings.filters = self._filters
+        self._clear_registries()
+        self._entered = False
+        del self._orig_show
+        del self._filters
+
+    def _showwarning(
+        self, message, category, filename, lineno, *args, use_warnmsg=None, **kwargs
+    ):
+        for cat, _, pattern, mod, rec in (self._suppressions + self._tmp_suppressions)[
+            ::-1
+        ]:
+            if issubclass(category, cat) and pattern.match(message.args[0]) is not None:
+                if mod is None:
+                    # Message and category match, either recorded or ignored
+                    if rec is not None:
+                        msg = WarningMessage(
+                            message, category, filename, lineno, **kwargs
+                        )
+                        self.log.append(msg)
+                        rec.append(msg)
+                    return
+                # Use startswith, because warnings strips the c or o from
+                # .pyc/.pyo files.
+                elif mod.__file__.startswith(filename):
+                    # The message and module (filename) match
+                    if rec is not None:
+                        msg = WarningMessage(
+                            message, category, filename, lineno, **kwargs
+                        )
+                        self.log.append(msg)
+                        rec.append(msg)
+                    return
+
+        # There is no filter in place, so pass to the outside handler
+        # unless we should only pass it once
+        if self._forwarding_rule == "always":
+            if use_warnmsg is None:
+                self._orig_show(message, category, filename, lineno, *args, **kwargs)
+            else:
+                self._orig_showmsg(use_warnmsg)
+            return
+
+        if self._forwarding_rule == "once":
+            signature = (message.args, category)
+        elif self._forwarding_rule == "module":
+            signature = (message.args, category, filename)
+        elif self._forwarding_rule == "location":
+            signature = (message.args, category, filename, lineno)
+
+        if signature in self._forwarded:
+            return
+        self._forwarded.add(signature)
+        if use_warnmsg is None:
+            self._orig_show(message, category, filename, lineno, *args, **kwargs)
+        else:
+            self._orig_showmsg(use_warnmsg)
+
+    def __call__(self, func):
+        """
+        Function decorator to apply certain suppressions to a whole
+        function.
+        """
+
+        @wraps(func)
+        def new_func(*args, **kwargs):
+            with self:
+                return func(*args, **kwargs)
+
+        return new_func
+
+
+@contextlib.contextmanager
+def _assert_no_gc_cycles_context(name=None):
+    __tracebackhide__ = True  # Hide traceback for py.test
+
+    # not meaningful to test if there is no refcounting
+    if not HAS_REFCOUNT:
+        yield
+        return
+
+    assert_(gc.isenabled())
+    gc.disable()
+    gc_debug = gc.get_debug()
+    try:
+        for _ in range(100):
+            if gc.collect() == 0:
+                break
+        else:
+            raise RuntimeError(
+                "Unable to fully collect garbage - perhaps a __del__ method "
+                "is creating more reference cycles?"
+            )
+
+        gc.set_debug(gc.DEBUG_SAVEALL)
+        yield
+        # gc.collect returns the number of unreachable objects in cycles that
+        # were found -- we are checking that no cycles were created in the context
+        n_objects_in_cycles = gc.collect()
+        objects_in_cycles = gc.garbage[:]
+    finally:
+        del gc.garbage[:]
+        gc.set_debug(gc_debug)
+        gc.enable()
+
+    if n_objects_in_cycles:
+        name_str = f" when calling {name}" if name is not None else ""
+        raise AssertionError(
+            "Reference cycles were found{}: {} objects were collected, "
+            "of which {} are shown below:{}".format(
+                name_str,
+                n_objects_in_cycles,
+                len(objects_in_cycles),
+                "".join(
+                    "\n  {} object with id={}:\n    {}".format(
+                        type(o).__name__,
+                        id(o),
+                        pprint.pformat(o).replace("\n", "\n    "),
+                    )
+                    for o in objects_in_cycles
+                ),
+            )
+        )
+
+
+def assert_no_gc_cycles(*args, **kwargs):
+    """
+    Fail if the given callable produces any reference cycles.
+
+    If called with all arguments omitted, may be used as a context manager:
+
+        with assert_no_gc_cycles():
+            do_something()
+
+    .. versionadded:: 1.15.0
+
+    Parameters
+    ----------
+    func : callable
+        The callable to test.
+    \\*args : Arguments
+        Arguments passed to `func`.
+    \\*\\*kwargs : Kwargs
+        Keyword arguments passed to `func`.
+
+    Returns
+    -------
+    Nothing. The result is deliberately discarded to ensure that all cycles
+    are found.
+
+    """
+    if not args:
+        return _assert_no_gc_cycles_context()
+
+    func = args[0]
+    args = args[1:]
+    with _assert_no_gc_cycles_context(name=func.__name__):
+        func(*args, **kwargs)
+
+
+def break_cycles():
+    """
+    Break reference cycles by calling gc.collect
+    Objects can call other objects' methods (for instance, another object's
+     __del__) inside their own __del__. On PyPy, the interpreter only runs
+    between calls to gc.collect, so multiple calls are needed to completely
+    release all cycles.
+    """
+
+    gc.collect()
+    if IS_PYPY:
+        # a few more, just to make sure all the finalizers are called
+        gc.collect()
+        gc.collect()
+        gc.collect()
+        gc.collect()
+
+
+def requires_memory(free_bytes):
+    """Decorator to skip a test if not enough memory is available"""
+    import pytest
+
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*a, **kw):
+            msg = check_free_memory(free_bytes)
+            if msg is not None:
+                pytest.skip(msg)
+
+            try:
+                return func(*a, **kw)
+            except MemoryError:
+                # Probably ran out of memory regardless: don't regard as failure
+                pytest.xfail("MemoryError raised")
+
+        return wrapper
+
+    return decorator
+
+
+def check_free_memory(free_bytes):
+    """
+    Check whether `free_bytes` amount of memory is currently free.
+    Returns: None if enough memory available, otherwise error message
+    """
+    env_var = "NPY_AVAILABLE_MEM"
+    env_value = os.environ.get(env_var)
+    if env_value is not None:
+        try:
+            mem_free = _parse_size(env_value)
+        except ValueError as exc:
+            raise ValueError(  # noqa: B904
+                f"Invalid environment variable {env_var}: {exc}"
+            )
+
+        msg = (
+            f"{free_bytes / 1e9} GB memory required, but environment variable "
+            f"NPY_AVAILABLE_MEM={env_value} set"
+        )
+    else:
+        mem_free = _get_mem_available()
+
+        if mem_free is None:
+            msg = (
+                "Could not determine available memory; set NPY_AVAILABLE_MEM "
+                "environment variable (e.g. NPY_AVAILABLE_MEM=16GB) to run "
+                "the test."
+            )
+            mem_free = -1
+        else:
+            msg = f"{free_bytes / 1e9} GB memory required, but {mem_free / 1e9} GB available"
+
+    return msg if mem_free < free_bytes else None
+
+
+def _parse_size(size_str):
+    """Convert memory size strings ('12 GB' etc.) to float"""
+    suffixes = {
+        "": 1,
+        "b": 1,
+        "k": 1000,
+        "m": 1000**2,
+        "g": 1000**3,
+        "t": 1000**4,
+        "kb": 1000,
+        "mb": 1000**2,
+        "gb": 1000**3,
+        "tb": 1000**4,
+        "kib": 1024,
+        "mib": 1024**2,
+        "gib": 1024**3,
+        "tib": 1024**4,
+    }
+
+    size_re = re.compile(
+        r"^\s*(\d+|\d+\.\d+)\s*({})\s*$".format("|".join(suffixes.keys())),
+        re.IGNORECASE,
+    )
+
+    m = size_re.match(size_str.lower())
+    if not m or m.group(2) not in suffixes:
+        raise ValueError(f"value {size_str!r} not a valid size")
+    return int(float(m.group(1)) * suffixes[m.group(2)])
+
+
+def _get_mem_available():
+    """Return available memory in bytes, or None if unknown."""
+    try:
+        import psutil
+
+        return psutil.virtual_memory().available
+    except (ImportError, AttributeError):
+        pass
+
+    if sys.platform.startswith("linux"):
+        info = {}
+        with open("/proc/meminfo") as f:
+            for line in f:
+                p = line.split()
+                info[p[0].strip(":").lower()] = int(p[1]) * 1024
+
+        if "memavailable" in info:
+            # Linux >= 3.14
+            return info["memavailable"]
+        else:
+            return info["memfree"] + info["cached"]
+
+    return None
+
+
+def _no_tracing(func):
+    """
+    Decorator to temporarily turn off tracing for the duration of a test.
+    Needed in tests that check refcounting, otherwise the tracing itself
+    influences the refcounts
+    """
+    if not hasattr(sys, "gettrace"):
+        return func
+    else:
+
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            original_trace = sys.gettrace()
+            try:
+                sys.settrace(None)
+                return func(*args, **kwargs)
+            finally:
+                sys.settrace(original_trace)
+
+        return wrapper
+
+
+def _get_glibc_version():
+    try:
+        ver = os.confstr("CS_GNU_LIBC_VERSION").rsplit(" ")[1]
+    except Exception:
+        ver = "0.0"
+
+    return ver
+
+
+_glibcver = _get_glibc_version()
+
+
+def _glibc_older_than(x):
+    return _glibcver != "0.0" and _glibcver < x

.venv/lib/python3.12/site-packages/torch/_opaque_base.py

@@ -0,0 +1,11 @@
+import logging
+
+
+log = logging.getLogger(__name__)
+
+log.warning("torch._opaque_base is deprecated, use torch._custom_class_base instead")
+
+from torch._custom_class_base import (  # noqa: F401
+    CustomClassBase as OpaqueBase,
+    CustomClassBaseMeta as OpaqueBaseMeta,
+)