Autodoc¶

Generated from the header Doxygen comments (doxygen + moxygen). For a curated view see the Reference and Cheat sheet.

Classes¶

Enumerations¶

ellipsis_t¶

enum ellipsis_t

The ellipsis marker (numpy ...) for the unspecified middle axes.

Its own type (an empty enum) keeps it distinct from any real extent value, and being an enum it is a valid non-type template argument for anyshape<...>.

It has two roles that never overlap, so one marker serves both:

• when indexing, t(1, ellipsis, 2) stands for as many all as fill the rank;

• in an anyshape<...> boundary tag it marks the rank-erased region — there it is conventionally spelled etc ("and so on"), an alias of ellipsis. So ellipsis/ellipsis_t is the primary name and etc/etc_t the alias: t(1, etc, 2) == t(1, ellipsis, 2) and anyshape<ellipsis, 3> == anyshape<etc, 3>. (The _is_ellipsis indexing trait lives in [indexing.h](#indexingh).)

storage¶

enum storage

Ownership / memory-space of a tensor's storage.

view / stack need no allocator. The owning modes differ only in where the memory lives and how it is (de)allocated:

• heap : ordinary C++ new[] / delete[] (host memory).

• gpu : cudaMalloc (device memory; not host-dereferenceable).

• pinned : cudaMallocHost (page-locked host memory — pytorch's "pinned").

• mapped : cudaHostAlloc (page-locked + device-mapped / zero-copy). The gpu/pinned/mapped storage is defined in the opt-in [teeny/cuda.h](#cudah) (which needs the CUDA runtime); using them without it is a compile error.

Typedefs¶

ccontiguous¶

using ccontiguous = layout_right

Names for the two contiguous layouts: ccontiguous is C-contiguous (row-major, layout_right), fcontiguous is Fortran-contiguous (column-major, layout_left).

Use wherever a Layout is expected — this is teeny's default and preferred spelling.

fcontiguous¶

using fcontiguous = layout_left

corder¶

using corder = ccontiguous

Legacy aliases (corder/forder); prefer ccontiguous/fcontiguous.

forder¶

using forder = fcontiguous

dynamic_strides¶

using dynamic_strides = layout_stride

dynamic_strides — the all-runtime strided layout (layout_stride, a full runtime stride array).

Prefer teeny's strides<S...> (folds known strides to immediates, and is what slicing produces); dynamic_strides is strides<> with every stride runtime.

Int¶

using Int = integral_constant< int, V >

Long¶

using Long = integral_constant< long, V >

Size¶

using Size = integral_constant< size_t, V >

UInt¶

using UInt = integral_constant< unsigned, V >

Diff¶

using Diff = integral_constant< ptrdiff_t, V >

Bool¶

using Bool = integral_constant< bool, V >

Int8¶

using Int8 = integral_constant< int8_t, V >

Int16¶

using Int16 = integral_constant< int16_t, V >

Int32¶

using Int32 = integral_constant< int32_t, V >

Int64¶

using Int64 = integral_constant< int64_t, V >

UInt8¶

using UInt8 = integral_constant< uint8_t, V >

UInt16¶

using UInt16 = integral_constant< uint16_t, V >

UInt32¶

using UInt32 = integral_constant< uint32_t, V >

UInt64¶

using UInt64 = integral_constant< uint64_t, V >

I1¶

using I1 = Int8< V >

I2¶

using I2 = Int16< V >

I4¶

using I4 = Int32< V >

I8¶

using I8 = Int64< V >

U1¶

using U1 = UInt8< V >

U2¶

using U2 = UInt16< V >

U4¶

using U4 = UInt32< V >

U8¶

using U8 = UInt64< V >

i1¶

using i1 = int8_t

i2¶

using i2 = int16_t

i4¶

using i4 = int32_t

i8¶

using i8 = int64_t

u1¶

using u1 = uint8_t

u2¶

using u2 = uint16_t

u4¶

using u4 = uint32_t

u8¶

using u8 = uint64_t

f4¶

using f4 = float

f8¶

using f8 = double

shape¶

using shape = extents< int64_t, _dyn_extent(E)... >

User-friendly shape type: shape<2,3,4> == extents<int64_t, 2,3,4>.

The fixed-size int64_t index type matches DLPack's shape exactly, so it drops straight onto ndarray bindings. A dynamic dimension can be spelled either dynamic_extent or, numpy-style, -1 — so shape<-1,2,3> == shape<dynamic_extent,2,3> == extents<int64_t, dynamic_extent, 2, 3>. Use it in place of extents<...>: local<double, shape<3,3>>, owned<float, shape<-1,4>>.

shape_as¶

using shape_as = extents< Idx, _dyn_extent(E)... >

shape<...> with an explicit index type: shape_as<int32_t, -1,3,3>.

shape<> is the int64 default (DLPack's index type); shape32<...> narrows the offset math to int32 for the kernel-boundary view (see reindex). The -1 == dynamic rule is the same.

shape32¶

using shape32 = shape_as< int32_t, E... >

rank¶

using rank = dextents< int64_t, N >

Fully-dynamic shape of a given rank: rank<3> == shape<-1,-1,-1> == extents<int64_t, dynamic_extent, dynamic_extent, dynamic_extent>.

Handy for a rank-N view whose sizes are all runtime: view<float, rank<3>>. rank<0> is the rank-0 (scalar) shape.

etc_t¶

using etc_t = ellipsis_t

etc — the anyshape<...> spelling of ellipsis (same marker, same value).

dtype_arg_t¶

using dtype_arg_t = _kw::resolve_t< _dtype_arg, Expl, void, _is_dtype, Dflt, Tags... >

gpu¶

using gpu = tensor< T, Shape, Layout, storage::gpu >

Owning tensor in device (GPU) memory (move-only).

gpu<T,E>(extents).

pinned¶

using pinned = tensor< T, Shape, Layout, storage::pinned >

Owning tensor in page-locked ("pinned") host memory (move-only).

pinned<T,E>(extents) — pytorch's pin_memory.

mapped¶

using mapped = tensor< T, Shape, Layout, storage::mapped >

Owning tensor in mapped (zero-copy) host memory (move-only).

mapped<T,E>(extents).

dyn_tensor¶

using dyn_tensor = tensor< T, dextents< offset_t, R >, layout_stride, O >

A fixed-rank, fully-dynamic, arbitrarily-strided tensor view.

O is the memory space of the view — [storage::view](#namespacetny_1a269cef88b5ff5cb896f1766df7f21508a1bda80f2be4d3658e0baa43fbe7ae8c1) (host) by default, [storage::gpu_view](#namespacetny_1a269cef88b5ff5cb896f1766df7f21508a716b431c57855c3a30f4c286ad4f0299) when the pointer lives in device memory (see anyrank's Space).

half¶

using half = __half

IEEE binary16 — the native CUDA __half under nvcc.

bfloat16¶

using bfloat16 = __nv_bfloat16

bfloat16 — the native CUDA __nv_bfloat16 under nvcc.

compute_type_t¶

using compute_type_t = typename compute_type< T >::type

f2¶

using f2 = half

bf16¶

using bf16 = bfloat16

layout_static_stride¶

using layout_static_stride = strides< S... >

Back-compat alias: the original all-static-stride layout name.

layout_arg_t¶

using layout_arg_t = _kw::resolve_t< _kw::keep_tag, Expl, void, _is_layout_tag, Dflt, Tags... >

layout_arg_t: the Layout a call site should use – an explicit template argument (Expl != void) wins, else a bare ccontiguous{}/fcontiguous{} tag found in Tags..., else the library default Dflt; supplying BOTH an explicit Expl and a tag is a static_assert.

That precedence rule (and its wording) lives ONCE, in _kw::resolve (kwargs.h) – shared with dtype_arg_t/storage_arg. Unlike dtype_arg_t, no unwrapping is needed here: the tag itself IS the layout type, so the answer is the tag that was found (keep_tag, which also supplies Dflt when there was none).

promote_t¶

using promote_t = typename _promote< A, B, true >::type

reduce_type_t¶

using reduce_type_t = conditional_t<(is_floating_point< T >::value||!is_same< compute_type_t< T >, T >::value), conditional_t<(sizeof(T) >=sizeof(double)), T, double >, conditional_t<(sizeof(T) >=8), T, conditional_t< is_signed< T >::value, int64_t, uint64_t > > >

Default accumulator type for a reduction over element type T.

double for floating-point types narrower than double (float, half, bfloat16) — enough headroom that summing many low-precision values doesn't lose catastrophically; a floating type already at least as wide as double (double itself, or long double) keeps itself — long double is double-sized on some ABIs (e.g. MSVC, arm64 macOS), where widening it would be a no-op precision-wise but a needless type change. Integer types narrower than 8 bytes accumulate in 64-bit (int64_t if signed, uint64_t if unsigned — bool counts as unsigned) so that summing / multiplying many small integers can't overflow mid-accumulation (signed overflow is UB); integers already ≥8 bytes keep their own type. The RESULT is still cast back to the element type T (accumulate wide, cast down); a caller who wants the untruncated wide value uses the explicit accumulator (sum<int64_t>(a)). Half types are spotted via [compute_type](#compute_type) (the only T whose compute type differs from itself). Override per call, e.g. sum<float>(a).

storage_c¶

using storage_c = integral_constant< storage, O >

Value-tag carrier for an ownership mode, for the factories' value-tag backend form, e.g.

empty<T>(shape, storage_c<[storage::gpu](#namespacetny_1a269cef88b5ff5cb896f1766df7f21508a0aa0be2a866411d9ff03515227454947)>{}).

view¶

using view = tensor< T, Shape, Layout, storage::view >

A non-owning view type.

Construct as view<T,E>(ptr, extents).

local¶

using local = tensor< T, Shape, Layout, storage::stack >

Stack-owned tensor (fully static shape).

Use local<T,E>{}.

owned¶

using owned = tensor< T, Shape, Layout, storage::heap >

Heap-owned tensor (host only, move-only).

Use owned<T,E>(extents).

Functions¶

make_gpu¶

template<class T = void, class Layout = void, class Shape, class... Tags> auto make_gpu(Shape e, Tags... tags)

make_pinned¶

template<class T = void, class Layout = void, class Shape, class... Tags> auto make_pinned(Shape e, Tags... tags)

make_mapped¶

template<class T = void, class Layout = void, class Shape, class... Tags> auto make_mapped(Shape e, Tags... tags)

to¶

template<storage Space, class ET = void, bool Force = false, class T, class Shape, class Layout, storage O> auto to(const tensor< T, Shape, Layout, O > & x)

Move x to memory space Space ([storage::gpu](#namespacetny_1a269cef88b5ff5cb896f1766df7f21508a0aa0be2a866411d9ff03515227454947)/pinned/mapped/heap), optionally converting the element type to ET — the memory-backend half of pytorch's .to.

ET defaults to the source type.

auto d = to<storage::gpu>(h);           // upload host -> device
auto e = to<storage::gpu, half>(h);     // convert to half AND upload
auto c = to<storage::heap>(d);          // download device -> host

       auto v = to<storage::gpu>(g);              // g is gpu (or a gpu_view slice) -> a view, no copy
       auto k = to<storage::gpu, void, true>(g);  // forced: a fresh gpu copy

:::note The no-copy branch returns a borrow of x (a gpu_view for a device source, else a host view), so it must outlive the result — same lifetime rule as [view()](#view)/permute()/slicing. On a temporary the rvalue overload below instead moves a same-space dense owning source (steals its buffer) or forces a copy, so nothing dangles. NB a contiguous device download copies exactly numel; a strided device download still copies its full span (over-copies — #50).

:::

to¶

template<storage Space, class ET = void, bool Force = false, class T, class Shape, class Layout, storage O> auto to(tensor< T, Shape, Layout, O > && x)

Rvalue overload of to<Space>: a temporary source cannot be borrowed (the no-copy branch would dangle — and for a device temporary would point at freed device memory).

A same-space, same-dtype, dense OWNING temporary is moved (its buffer stolen — no copy, no round-trip); otherwise this forces a fresh owning copy (which, for a device->device contiguous source, is the device-to-device path above, not a host round-trip).

to_dlpack¶

template<class T, class Shape, class Layout, storage O, enable_if_t< storage_is_view(O), int > = 0> DLManagedTensor * to_dlpack(const tensor< T, Shape, Layout, O > & t, DLDevice dev = { _dl::device_of< O >(), 0 })

Export a view (view / gpu_view / pinned_view / mapped_view) to a DLManagedTensor (borrows the data — the caller must keep the underlying memory alive; only the metadata is owned by the capsule).

The device defaults to the tensor's memory space (kDLCPU for a host view, kDLCUDA for a gpu_view, kDLCUDAHost for a pinned_view/ mapped_view; pass dev to override). The consumer owns the returned pointer and MUST call m->deleter(m) exactly once.

to_dlpack¶

template<class T, class Shape, class Layout, storage O, enable_if_t< storage_is_owning(O), int > = 0> DLManagedTensor * to_dlpack(tensor< T, Shape, Layout, O > && t)

Export an owning tensor, TRANSFERRING ownership of the buffer into the capsule (the tensor is moved-from; the capsule's deleter frees the buffer).

Device is taken from the tensor's memory space.

to_dltensor¶

template<class T, class Shape, class Layout, storage O> DLTensor to_dltensor(const tensor< T, Shape, Layout, O > & t, int64_t * shape_out, int64_t * strides_out, DLDevice dev = { _dl::device_of< O >(), 0 })

Export to a bare DLTensor (unmanaged — no capsule, no deleter, no allocation).

Borrows both the data AND the shape/stride arrays: the caller supplies shape_out/strides_out (each ≥ t.rank()``int64_ts), which this fills, and the returned DLTensor points at them + t.data(). The caller must keep the tensor's memory and those two buffers alive for as long as the DLTensor is used. Use for a consumer that takes a plain DLTensor rather than a managed capsule. Device defaults to the tensor's memory space (override with dev). Works for any storage (a pure borrow).

from_dlpack¶

template<class T, storage Space = storage::view> auto from_dlpack(const DLManagedTensor * m)

Import a DLManagedTensor of known element type T as an anyrank (runtime rank).

The shape/stride METADATA is copied into the carrier (so it is self-contained), while the DATA is BORROWED — the caller keeps m alive while the view is used, then calls m->deleter(m). A null strides (DLPack's C-contiguous shorthand) is expanded to row-major. byte_offset is folded into the data pointer.

Space is the memory space to tag the carrier with (default [storage::view](#namespacetny_1a269cef88b5ff5cb896f1766df7f21508a1bda80f2be4d3658e0baa43fbe7ae8c1) = host); every view peeled off it inherits it. It is checked against m->dl_tensor.device: importing a kDLCUDA capsule as the default host Space trips _TNY_CHECK — spell from_dlpack<T, [storage::gpu_view](#namespacetny_1a269cef88b5ff5cb896f1766df7f21508a716b431c57855c3a30f4c286ad4f0299)>(m) so fixed()/peel_front yield device-tagged views (no host deref of a device pointer). (Closes the #38 hole where the device field was ignored and a device capsule silently became a host view.)

from_dlpack¶

template<class T, storage Space = storage::view> auto from_dlpack(const DLTensor * dt)

Import a bare DLTensor (unmanaged — no deleter).

Borrows the data, copies the metadata; the CALLER owns the whole lifetime (there is nothing to free). Use when a producer hands you a plain DLTensor* rather than a capsule. Same Space/device check as the managed overload.

from_dlpack¶

template<class T, storage Space = storage::view> auto from_dlpack(const DLManagedTensorVersioned * m)

Import a versioned managed tensor (DLPack 1.0+, what a modern __dlpack__(max_version=…) emits).

Reads its dl_tensor payload; as with the classic capsule the caller keeps m alive and calls m->deleter(m).

from_dlpack¶

template<class T, class S, storage Space = storage::view, class Layout = keep_strides, enable_if_t< _is_anyshape< S >::value, int > = 0> auto from_dlpack(const DLManagedTensor * m, Layout = {})

Import with a STATIC TRAILING shape baked into the carrier's type — from_dlpack<float, anyshape<etc,-1,-1,3>>(m) for a (*batch, *spatial, C) tensor with a static channel count.

The payload's trailing dims are debug-checked against the tag once, here at the import boundary (next to the producer), then folded into every fixed/peel_front cell — no per-call recast. etc = the erased batch (see anyshape); the Space device check is the same as the tag-less overloads. Accepts all three carriers.

Pass a layout tag by value to also fold the trailing STRIDES: from_dlpack<float, anyshape<etc,-1,-1,3>>(m, ccontiguous{}) bakes a C-contiguous inner block (checked vs the payload's strides here — the "input is contiguous" precondition, asserted at the boundary once instead of a per-call recast/dispatch_layout). Default [keep_strides](#keep_strides) keeps them runtime.

from_dlpack¶

template<class T, class S, storage Space = storage::view, class Layout = keep_strides, enable_if_t< _is_anyshape< S >::value, int > = 0> auto from_dlpack(const DLTensor * dt, Layout = {})

from_dlpack¶

template<class T, class S, storage Space = storage::view, class Layout = keep_strides, enable_if_t< _is_anyshape< S >::value, int > = 0> auto from_dlpack(const DLManagedTensorVersioned * m, Layout = {})

from_dlpack¶

template<class T, size_t R, storage Space = storage::view> auto from_dlpack(const DLManagedTensor * m)

Import as a fixed-rank view (requires the payload's ndim == R).

Returns a layout_stride tensor view borrowing the data. Space (default host [storage::view](#namespacetny_1a269cef88b5ff5cb896f1766df7f21508a1bda80f2be4d3658e0baa43fbe7ae8c1)) tags the view and is checked against the device, as in the anyrank overloads — from_dlpack<T, R, [storage::gpu_view](#namespacetny_1a269cef88b5ff5cb896f1766df7f21508a716b431c57855c3a30f4c286ad4f0299)>(m) for a device tensor. Accepts all three carriers (managed / bare / versioned).

from_dlpack¶

template<class T, size_t R, storage Space = storage::view> auto from_dlpack(const DLTensor * dt)

from_dlpack¶

template<class T, size_t R, storage Space = storage::view> auto from_dlpack(const DLManagedTensorVersioned * m)

dispatch_dlpack¶

template<storage Space = storage::view, class Carrier, class F> bool dispatch_dlpack(const Carrier * m, F && f)

Import + dispatch: read the dtype/rank from the DLManagedTensor and call f with a fixed-rank typed view (one instantiation per (dtype, rank)).

Returns false if the dtype/rank is outside the supported set. Data borrowed; caller owns m. Space (default host [storage::view](#namespacetny_1a269cef88b5ff5cb896f1766df7f21508a1bda80f2be4d3658e0baa43fbe7ae8c1)) tags the views and is checked against the capsule's device — dispatch a device capsule with dispatch_dlpack<[storage::gpu_view](#namespacetny_1a269cef88b5ff5cb896f1766df7f21508a716b431c57855c3a30f4c286ad4f0299)>(m, f).

dispatch_dlpack_dtype¶

template<storage Space = storage::view, class Carrier, class F> bool dispatch_dlpack_dtype(const Carrier * m, F && f)

Import + dtype-only dispatch that PRESERVES the rank: read the dtype from the capsule and call f with the typed anyrank (rank still dynamic), instead of collapsing to a fixed rank like dispatch_dlpack.

The caller then peels its own axes — the (*batch, *spatial, C) batch idiom for (auto cell : at.peel_front<-Sr>()) …, which instantiates the kernel once per Sr, not once per total rank. Returns false for an unsupported dtype. Data borrowed; caller owns m. Space tags the carrier and is checked against the capsule's device (see from_dlpack).

reindex¶

template<class Idx2, class T, class offset_t, class Meta, storage Space, class Tail, class TailS, class Head, class HeadS> auto reindex(const anyrank< T, offset_t, Meta, Space, Tail, TailS, Head, HeadS > & a)

Free forms of reindex/index_fits for anyrank — the whole-carrier twins of tensor's free forms (tensor.h): deduce the carrier, so a type-dependent receiver (e.g.

inside a generic dispatch_dlpack_dtype- style functor) can write reindex<Idx2>(at) / index_fits<Idx2>(at) without the .template disambiguator. (Idx2 is a TYPE, so there is no value form.) [anyrank::reindex](#reindex-3) is const-only (unlike tensor's mutable/const pair), so only one overload is needed here. No MaxRank parameter: it would sit 10th in the deduced list, so a caller could not practically override it without spelling out every preceding deduced parameter by hand; this free form always takes the member's own default (the carrier's max_rank) — call the member directly (at.reindex<Idx2, 8>()) when a custom capacity is needed.

index_fits¶

template<class Idx2, class T, class offset_t, class Meta, storage Space, class Tail, class TailS, class Head, class HeadS> bool index_fits(const anyrank< T, offset_t, Meta, Space, Tail, TailS, Head, HeadS > & a)

as_anyrank¶

template<storage Space = storage::view, class T, class offset_t> anyrank< T, offset_t, _meta_view< offset_t >, Space > as_anyrank(T * data, offset_t * shape, offset_t * stride, int ndim)

Build an anyrank that wraps the caller's shape/stride arrays with no copy (the default) — e.g.

straight off a DLPack tensor. The arrays must outlive the carrier. HOST only: the pointers are not valid inside a device kernel, so peel/dispatch on the host and pass the resulting fixed-rank views to the device. To instead copy into an inline, device-passable store, pass the copy_meta tag (overload below). DLPack strides are in ELEMENTS; numpy __array_interface__ in BYTES (divide by the itemsize first).

Space is the memory space of data (default [storage::view](#namespacetny_1a269cef88b5ff5cb896f1766df7f21508a1bda80f2be4d3658e0baa43fbe7ae8c1) = host); pass as_anyrank<[storage::gpu_view](#namespacetny_1a269cef88b5ff5cb896f1766df7f21508a716b431c57855c3a30f4c286ad4f0299)>(...) for a device pointer so the views peeled off it are gpu_view-tagged. (The shape/stride metadata arrays are host either way — Space labels the DATA, not the metadata store.)

as_anyrank¶

template<size_t MaxRank = TNY_MAX_RANK, storage Space = storage::view, class T, class offset_t> anyrank< T, offset_t, _meta_store< offset_t, MaxRank >, Space > as_anyrank(T * data, const offset_t * shape, const offset_t * stride, int ndim, copy_meta_t)

as_anyrank(data, shape, stride, ndim, copy_meta) — COPY shape/stride into an inline store, so the carrier is trivially copyable and can be passed into a CUDA kernel by value (peel on device).

MaxRank sets the inline capacity (default TNY_MAX_RANK); pass it as as_anyrank<64>(..., copy_meta). Accepts const arrays (it copies).

as_anyrank¶

template<storage Space = storage::view, class T, class offset_t, class S, class Layout = keep_strides, enable_if_t< _is_anyshape< S >::value, int > = 0> auto as_anyrank(T * data, offset_t * shape, offset_t * stride, int ndim, S, Layout = {})

as_anyrank(..., anyshape<etc,c,c>{}[, layout]) — carry a STATIC TRAILING shape (and, with a layout tag, static trailing STRIDES) in the carrier's type, so fixed/peel_front hand out cells with those inner extents/strides already folded (no per-call recast).

The runtime shape/strides' trailing dims are debug-checked against the tag once, here, then trusted. etc = the erased batch; the dims after it are the static tail (see anyshape). The optional layout tag chooses the trailing strides (like recast's 2nd arg): [keep_strides](#keep_strides) (default — strides stay runtime), ccontiguous/fcontiguous (fold the contiguous inner block — the "input is contiguous" precondition, checked here), or strides<S...> (impose them). Wraps the caller's arrays (no copy).

as_anyrank¶

template<size_t MaxRank = TNY_MAX_RANK, storage Space = storage::view, class T, class offset_t, class S, class Layout = keep_strides, enable_if_t< _is_anyshape< S >::value, int > = 0> auto as_anyrank(T * data, const offset_t * shape, const offset_t * stride, int ndim, copy_meta_t, S, Layout = {})

as_anyrank(..., copy_meta, anyshape<etc,c,c>{}[, layout]) — the static-tail carrier over an INLINE (device-passable) meta store.

dispatch_index¶

template<class Idx2 = int32_t, class V, class F> void dispatch_index(V && v, F && f)

Narrow a view's — or a whole anyrank carrier's — OFFSET INDEX WIDTH to Idx2 (default int32_t) when the narrowing is lossless, then call f — else call f with the argument as-is.

The kernel-boundary primitive behind the int32 fast path (#115): it instantiates f for BOTH widths and picks at run time via index_fits/reindex, so a genuinely dynamic view runs its offset math in 32-bit (half the by-value footprint, fewer device registers) exactly when that is lossless. _TNY_HOST; preserves the view's mutability. Use it standalone on a known-rank view (or a peel_front batch cell), or via dispatch_rank<narrow_index> to fuse it with the rank dispatch.

for (auto cell : at.peel_front<-Sr>()) dispatch_index(cell, [&](auto c){ kernel<Sr>(c); });

if (at.index_fits<int32_t>()) launch(at.reindex<int32_t>());
else                              launch(at);

dispatch_layout¶

template<class T, class E, storage O, class F> void dispatch_layout(tensor< T, E, dynamic_strides, O > v, F && f)

Runtime-classify a DYNAMIC-strided view's contiguity and hand f a view whose LAYOUT is baked into the type — ccontiguous (C-order) or fcontiguous (F-order) when the runtime strides match, else the original dynamic_strides.

The layout counterpart of dispatch_index. An anyrank boundary erases the producer's contiguity into layout_stride, so a later recast<shape<…>> can only KEEP runtime strides. dispatch_layout cheaply checks (is_dense<ccontiguous>() / <fcontiguous>() — a stride compare, no data touched) and, in the contiguous arms, hands f a view whose strides are EXTENT-DERIVED — so recast<shape<-1,c,c>>() then folds the inner strides to immediates SAFELY (no "I promise it's contiguous" — the runtime check already proved it). f is instantiated up to 3× (only the matching arm runs), so make it generic over the view type.

OPT-IN per call site (like dispatch_index): do NOT wrap from_dlpack in it by default — it triples instantiations and composes multiplicatively with the rank/width dispatchers. Reach for it when the inner block's folded strides actually matter (a small static-C kernel; see the efficient-kernels guide).

for (auto cell : at.peel_front<-Sr>())
    dispatch_layout(cell, [&](auto v){ kernel<Sr>(v.recast(shape<-1,c,c>{})); });

dispatch_rank¶

template<bool Narrow = false, class T, class offset_t, class Meta, storage Space, class Tail, class TailS, class Head, class HeadS, class F> bool dispatch_rank(const anyrank< T, offset_t, Meta, Space, Tail, TailS, Head, HeadS > & t, F && f)

Call f with a fixed-rank view of t chosen by its runtime ndim.

f is a generic callable instantiated once per possible rank; the kernel it launches is fully static. Returns false if ndim exceeds max_rank. Prefer peel_front<-Sr> when only the trailing dims need to be static — one instantiation instead of one per total rank.

dispatch_rank(as_anyrank(data, size, stride, ndim), [&](auto v){ kernel(v); });

dispatch_rank<narrow_index>(at, [&](auto v){ kernel(v); });   // int32 cells when they fit

dispatch_value¶

template<int... Vs, class F> bool dispatch_value(int v, F && f)

Turn a runtime value into a compile-time one from a candidate list.

dispatch_value<1,2,3>(D, f) calls f(Int<k>{}) for the matching candidate k == D (so f receives a static integral_constant it can use as a template argument), and returns whether any matched.

dispatch_value<1,2,3>(ndim_spatial, [&](auto d){ kernel<d.value>(view); });

candidates¶

constexpr noexcept

template<int... Vs, class V> constexpr constexpr candidates_t< Vs... > candidates(V v) noexcept

candidates<1,2,3>(d) — one dispatch_values parameter: the compile-time candidates as template arguments, the runtime value as the argument.

v may be any integer or enum type — a bound/order enum dispatches without a hand-written static_cast at the call site (the candidates are plain ints, and so is the integral_constant``f receives, exactly as with dispatch_value).

dispatch_values¶

template<class F, class... Ls> bool dispatch_values(F && f, Ls... lists)

The product form of dispatch_value: turn SEVERAL runtime values into compile-time ones in one call, one candidate list per parameter.

f is called with one integral_constant per list, in list order, when every value matched one of its own candidates; the return value says whether it ran. Pure sugar over the nesting — same per-parameter match test, same instantiation count (once per combination of candidates), and the same failure contract per parameter: a value outside its list simply doesn't fire (no assert, no abort), so f is not called and the call returns false.

dispatch_values([&](auto D, auto O, auto B){ kernel<D.value, O.value, B.value>(v); },
                candidates<1,2,3>(spatial_ndim),      // spatial rank
                candidates<0,1,2,3>(order),           // interpolation order
                candidates<0,1,2,3,4,5,6,7>(bnd));    // boundary condition (an enum)

slice¶

template<class A, class B> auto slice(A start, B stop)

A python-like slice [start : stop : step) for operator() / slice_along.

none marks an open end; negative bounds wrap (count from the back); step defaults to 1 and may exceed 1.

slice(1, 4) = [1,4); slice(none, 4) = [0,4); slice(2, none) = [2,end); slice(0, none, 2) = every other element; slice(none, none) keeps the whole axis (== all, which is preferable when you want the axis kept — it folds and preserves static extents). A ranged axis is resolved at run time (its extent becomes dynamic); axes kept with all stay static.

slice¶

template<class A, class B, class S> auto slice(A start, B stop, S step)

slice¶

template<long Start, long Stop, long Step = 1> auto slice()

peel_at¶

template<size_t... Axes, class MD> auto peel_at(const MD & src, typename MD::index_type i)

The i-th sub-view obtained by peeling Axes... (0 <= i < product of the peeled extents).

Peeled axes vary in row-major order (the last listed axis fastest). Returns a [tny::tensor](#tensor) view. A raw mdspan carries no memory space, so this tags the result as a host view; the [tny::tensor](#tensor) overloads below preserve the source's space.

peel_at¶

template<long... Axes, class T, class E, class L, storage O> auto peel_at(tensor< T, E, L, O > & t, typename tensor< T, E, L, O >::index_type i)

peel_at¶

template<long... Axes, class T, class E, class L, storage O> auto peel_at(const tensor< T, E, L, O > & t, typename tensor< T, E, L, O >::index_type i)

peel_at¶

template<long... Axes, class T, class E, class L, storage O> auto peel_at(tensor< T, E, L, O > & t, typename tensor< T, E, L, O >::index_type i, axis< Axes... >)

peel_at¶

template<long... Axes, class T, class E, class L, storage O> auto peel_at(const tensor< T, E, L, O > & t, typename tensor< T, E, L, O >::index_type i, axis< Axes... >)

peel¶

template<long... Axes, class T, class E, class L, storage O> auto peel(tensor< T, E, L, O > & t)

Build a range of sub-views by peeling Axes... of t.

Non-const t yields mutable peel; const t yields read-only peel.

peel¶

template<long... Axes, class T, class E, class L, storage O> auto peel(const tensor< T, E, L, O > & t)

peel¶

template<long... Axes, class T, class E, class L, storage O> auto peel(tensor< T, E, L, O > & t, axis< Axes... >)

peel¶

template<long... Axes, class T, class E, class L, storage O> auto peel(const tensor< T, E, L, O > & t, axis< Axes... >)

peel_of¶

template<size_t... Axes, class MD> peel_range< MD, storage::view, Axes... > peel_of(const MD & m)

Build a range of sub-views over a raw mdspan.

peel_front¶

template<long N, class T, class E, class L, storage O> auto peel_front(tensor< T, E, L, O > & t)

Peel the FIRST N axes -> a range of sub-views over the rest — the runtime-batch-rank half of (*batch, *spatial, C).

N is signed: peel_front<3> peels 3 leading dims; peel_front<-1> keeps the last axis (peels all but it), so negative = "keep the last |N|".

peel_front¶

template<long N, class T, class E, class L, storage O> auto peel_front(const tensor< T, E, L, O > & t)

peel_front_at¶

template<long N, class T, class E, class L, storage O> auto peel_front_at(tensor< T, E, L, O > & t, typename tensor< T, E, L, O >::index_type i)

The i-th sub-view obtained by peeling the first N axes (grid-stride style).

peel_front_at¶

template<long N, class T, class E, class L, storage O> auto peel_front_at(const tensor< T, E, L, O > & t, typename tensor< T, E, L, O >::index_type i)

size_front¶

template<long N, class T, class E, class L, storage O> tensor< T, E, L, O >::index_type size_front(const tensor< T, E, L, O > & t)

The number of sub-views peel_front<N>(t) would yield — the product of the peeled leading extents — computed directly, without materialising the range.

Same signed N as peel_front: size_front<3>(t) multiplies the first 3 extents; size_front<-2>(t) the all-but-last-two (the flattened batch count of a (*batch, C, C) tensor).

peel_zip¶

template<long... Axes, class Ta, class Ea, class La, storage Oa, class Tb, class Eb, class Lb, storage Ob> auto peel_zip(tensor< Ta, Ea, La, Oa > & a, tensor< Tb, Eb, Lb, Ob > & b)

Zip-peel 2 tensors' Axes... in lock-step -> a range of tuple<ViewA,ViewB> (numpy-style broadcast: shapes may differ as long as they're broadcast-compatible; Axes... name axes in the BROADCAST rank's numbering — the larger of the two operands' own ranks — negatives wrap against it).

A distinct name from peel (see the design note above peel_zip_range), not an overload.

The operands need not share an INDEX TYPE: the cells carry one wide enough — and, where the operands disagree on signedness, signed enough — to address every operand exactly, so a reversed view (flip, or a negative slice step) zipped against an unsigned-indexed tensor steps backwards instead of wrapping to a huge positive offset (#362).

peel_zip¶

template<long... Axes, class Ta, class Ea, class La, storage Oa, class Tb, class Eb, class Lb, storage Ob> auto peel_zip(const tensor< Ta, Ea, La, Oa > & a, const tensor< Tb, Eb, Lb, Ob > & b)

peel_zip¶

template<long... Axes, class Ta, class Ea, class La, storage Oa, class Tb, class Eb, class Lb, storage Ob> auto peel_zip(tensor< Ta, Ea, La, Oa > & a, tensor< Tb, Eb, Lb, Ob > & b, axis< Axes... >)

peel_zip¶

template<long... Axes, class Ta, class Ea, class La, storage Oa, class Tb, class Eb, class Lb, storage Ob> auto peel_zip(const tensor< Ta, Ea, La, Oa > & a, const tensor< Tb, Eb, Lb, Ob > & b, axis< Axes... >)

peel_zip¶

template<long... Axes, class Ta, class Ea, class La, storage Oa, class Tb, class Eb, class Lb, storage Ob, class Tc, class Ec, class Lc, storage Oc> auto peel_zip(tensor< Ta, Ea, La, Oa > & a, tensor< Tb, Eb, Lb, Ob > & b, tensor< Tc, Ec, Lc, Oc > & c)

Zip-peel 3 tensors' Axes... in lock-step -> a range of tuple<ViewA,ViewB,ViewC> (same broadcast/axis-numbering rule as the 2-tensor form).

The "triangle's three vertex tensors" idiom.

peel_zip¶

template<long... Axes, class Ta, class Ea, class La, storage Oa, class Tb, class Eb, class Lb, storage Ob, class Tc, class Ec, class Lc, storage Oc> auto peel_zip(const tensor< Ta, Ea, La, Oa > & a, const tensor< Tb, Eb, Lb, Ob > & b, const tensor< Tc, Ec, Lc, Oc > & c)