ClikaRT::Tensor

class

Header: ClikaRT/compute/tensor.h

Types

enum Status

enum class Status

Where a tensor is in its async lifecycle (see status()):

• Unscheduled: lazy; has lineage but no kernel has run (tracing mode).
• Evaluated: the producing kernel was submitted / storage allocated; a kernel-produced tensor stays here even after synchronize.
• Available: ready/host-observed; the state a tensor built straight from a data buffer starts in.

Enumerator	Description
Unscheduled
Evaluated
Available

Declared in ClikaRT/compute/tensor.h, line 118

Static member functions

empty()

static Tensor empty(
    ClikaRT::Span<const std::int64_t> shape,
    DataType dtype,
    StreamOrDevice where = {},
    StreamOrDevice pinned_for = {}
)

Uninitialized tensor.

Declared in ClikaRT/compute/tensor.h, line 138

empty_reserved()

static Tensor empty_reserved(
    ClikaRT::Span<const std::int64_t> shape,
    DataType dtype,
    StreamOrDevice where = {}
)

Uninitialized tensor whose storage BYPASSES the caching pool: the bytes are reserved from the device as one dedicated block, never split or coalesced with pooled memory. Use it for LARGE, lifetime-long buffers (a staged weight slab, a session-long cache); a fragmented pool can fail to place such a request even when enough total memory is free, and the reserve route is immune to that by construction. Small or short-lived tensors belong on the ordinary empty (pooled reuse is what makes them cheap). Same placement contract as empty; a device whose allocator has no reserve fast-path serves it as a plain allocation.

Declared in ClikaRT/compute/tensor.h, line 151

zeros()

static Tensor zeros(
    ClikaRT::Span<const std::int64_t> shape,
    DataType dtype,
    StreamOrDevice where = {},
    StreamOrDevice pinned_for = {}
)

Zero-filled tensor.

Declared in ClikaRT/compute/tensor.h, line 155

ones()

static Tensor ones(
    ClikaRT::Span<const std::int64_t> shape,
    DataType dtype,
    StreamOrDevice where = {},
    StreamOrDevice pinned_for = {}
)

Ones-filled tensor.

Declared in ClikaRT/compute/tensor.h, line 159

full_i64_impl()

static Result<Tensor> full_i64_impl(
    ClikaRT::Span<const std::int64_t> shape,
    std::int64_t value,
    DataType dtype,
    StreamOrDevice where,
    StreamOrDevice pinned_for
)

The exact-integer sibling: the value travels the integer channel end to end, so Int64/UInt64 fills past 2^53 keep their low bits (a double carrier would round them).

Declared in ClikaRT/compute/tensor.h, line 166

full(Span< int64_t>, double, DataType, StreamOrDevice, …)

static Tensor full(
    ClikaRT::Span<const std::int64_t> shape,
    double value,
    DataType dtype,
    StreamOrDevice where = {},
    StreamOrDevice pinned_for = {}
)

Tensor filled with value (cast to dtype).

Declared in ClikaRT/compute/tensor.h, line 167

full(Span< int64_t>, T, DataType, StreamOrDevice, …)

template <``typename T, typename std::enable_if<std::is_integral<T>::value, int>::type = 0``>
static Tensor full(
    ClikaRT::Span<const std::int64_t> shape,
    T value,
    DataType dtype,
    StreamOrDevice where = {},
    StreamOrDevice pinned_for = {}
)

Integral overload: every integer width lands here exactly (never on the double form, and never ambiguously against it; the same shape as ScalarOrTensor's integral ctor).

Declared in ClikaRT/compute/tensor.h, line 174

from_data()

static Tensor from_data(
    const void* data,
    ClikaRT::Span<const std::int64_t> shape,
    DataType dtype,
    StreamOrDevice where = {},
    StreamOrDevice pinned_for = {}
)

Copy host data into a new owned tensor. data must point at numel(shape) * itemsize(dtype) bytes laid out for dtype; those bytes are copied into the tensor (the source buffer is not retained), so its lifetime is independent of the tensor. With a non-CPU placement the data is staged on the host and then moved there. For a zero-copy wrap, use from_blob.

Declared in ClikaRT/compute/tensor.h, line 184

from_blob(void, Span< int64_t>, DataType, StreamOrDevice, …)

static Tensor from_blob(
    void* data,
    ClikaRT::Span<const std::int64_t> shape,
    DataType dtype,
    StreamOrDevice where = {},
    std::function<void(void *)> deleter = {},
    StreamOrDevice pinned_for = {}
)

Wrap externally-owned memory as a tensor without copying. data must point at memory on where's device laid out for dtype (contiguous for this overload). Ownership is signalled by deleter:

• No deleter (default) → borrowed. You keep ownership of data and MUST keep it alive, and its layout unchanged, for as long as the tensor or any view of it is in use. The runtime never reuses/overwrites it. Writes through the buffer are visible through the tensor and vice versa (it is the same memory).
• With a deleter → adopted. The tensor takes ownership and calls deleter(data) once, when its last reference drops; the buffer may then be reused as an op output. The deleter runs when the storage is released, possibly on a runtime thread; a throw from it is caught in your translation unit and discarded. shape is read during the call, not retained. pinned_for on a blob wrap is TAG-ONLY: the pages are yours, so setting it asserts they are already page-locked for the peer (the runtime cannot pin or verify foreign memory) and marks the tensor pinned accordingly.

Declared in ClikaRT/compute/tensor.h, line 206

from_blob(void, Span< int64_t>, Span< int64_t>, DataType, …)

static Tensor from_blob(
    void* data,
    ClikaRT::Span<const std::int64_t> shape,
    ClikaRT::Span<const std::int64_t> strides,
    DataType dtype,
    StreamOrDevice where = {},
    std::function<void(void *)> deleter = {},
    StreamOrDevice pinned_for = {}
)

Wrap externally-owned memory as a tensor without copying. data must point at memory on where's device laid out for dtype (contiguous for this overload). Ownership is signalled by deleter:

• No deleter (default) → borrowed. You keep ownership of data and MUST keep it alive, and its layout unchanged, for as long as the tensor or any view of it is in use. The runtime never reuses/overwrites it. Writes through the buffer are visible through the tensor and vice versa (it is the same memory).
• With a deleter → adopted. The tensor takes ownership and calls deleter(data) once, when its last reference drops; the buffer may then be reused as an op output. The deleter runs when the storage is released, possibly on a runtime thread; a throw from it is caught in your translation unit and discarded. shape is read during the call, not retained. pinned_for on a blob wrap is TAG-ONLY: the pages are yours, so setting it asserts they are already page-locked for the peer (the runtime cannot pin or verify foreign memory) and marks the tensor pinned accordingly.

Declared in ClikaRT/compute/tensor.h, line 215

fake()

static Tensor fake(const FakeTensor& spec)

A tensor with the metadata of spec and NO storage (is_fake() is true): the tensor a module registered from a FakeTensor spec holds until a checkpoint binds it, and the tensor a metadata-only build hands out. Every metadata read answers (shape, dtype, device, element count); a data read raises ClikaRT::Error naming it as declared but unloaded.

Declared in ClikaRT/compute/tensor.h, line 282

Member functions

Tensor()

Tensor() noexcept

A default (undefined) tensor; it holds no storage. defined() is false; the other metadata observers must not be called until it is assigned a real tensor. Useful as a member you fill in later (e.g. a module's parameter handle).

Declared in ClikaRT/compute/tensor.h, line 225

Tensor(Tensor)

Tensor(const Tensor& other)

Copy: a SECOND HANDLE to the same storage (refcounted; no bytes move; an in-place op through either handle is visible through both).

Declared in ClikaRT/compute/tensor.h, line 229

operator=(Tensor)

Tensor& operator=(const Tensor& other)

Copy-assign: rebinds this handle to other's storage (refcounted, no bytes move).

Declared in ClikaRT/compute/tensor.h, line 231

Tensor(Tensor)

Tensor(Tensor&& other) noexcept

Move: transfers the handle; other is left default-constructed (undefined).

Declared in ClikaRT/compute/tensor.h, line 233

operator=(Tensor)

Tensor& operator=(Tensor&& other) noexcept

Move-assign: transfers the handle; other is left default-constructed (undefined).

Declared in ClikaRT/compute/tensor.h, line 235

~Tensor()

~Tensor()

Releases this handle's reference; the storage frees when the last handle drops.

Declared in ClikaRT/compute/tensor.h, line 237

defined()

bool defined() const

True if this tensor holds storage (false for a default/empty tensor).

Declared in ClikaRT/compute/tensor.h, line 246

ndim()

std::int64_t ndim() const

Rank. Always concrete; a tensor's rank is fixed when its producing op is dispatched, even when the dim values are data-dependent.

Declared in ClikaRT/compute/tensor.h, line 249

metadata_ndim()

std::int64_t metadata_ndim() const

Synonym of ndim (rank is structural by nature).

Declared in ClikaRT/compute/tensor.h, line 251

metadata_shape()

std::vector<std::int64_t> metadata_shape() const

The per-dimension sizes as currently recorded.

Declared in ClikaRT/compute/tensor.h, line 253

metadata_sizes()

std::vector<std::int64_t> metadata_sizes() const

Synonym of metadata_shape.

Declared in ClikaRT/compute/tensor.h, line 255

metadata_strides()

std::vector<std::int64_t> metadata_strides() const

The per-dimension strides, in elements, as currently recorded.

Declared in ClikaRT/compute/tensor.h, line 257

metadata_numel()

std::int64_t metadata_numel() const

The element count as currently recorded.

Declared in ClikaRT/compute/tensor.h, line 259

metadata_nbytes()

std::size_t metadata_nbytes() const

Total byte size of the element data as currently recorded.

Declared in ClikaRT/compute/tensor.h, line 261

dtype()

DataType dtype() const

The element dtype. Structural: fixed at creation, free to read, never synchronizes.

Declared in ClikaRT/compute/tensor.h, line 263

device()

Device device() const

The device this tensor is placed on.

Declared in ClikaRT/compute/tensor.h, line 265

stream()

Stream stream() const

The execution stream this tensor is associated with.

Declared in ClikaRT/compute/tensor.h, line 267

is_contiguous()

bool is_contiguous() const

From current metadata (a data-dependent shape refreshes layout when its producer completes).

Declared in ClikaRT/compute/tensor.h, line 270

is_pinned()

bool is_pinned(StreamOrDevice peer = {}) const

True when this tensor's storage is page-locked host memory pinned for peer (transfers to/from that peer skip staging). With no peer, true when pinned for any device. Always false for device-resident storage. A pure metadata read.

Declared in ClikaRT/compute/tensor.h, line 275

is_fake()

bool is_fake() const

True if this tensor is metadata-only: a declared slot (shape / dtype / placement) with NO storage behind it, e.g. a parameter registered from a FakeTensor spec that load_state_dict has not bound yet. A fake tensor's metadata observers all work; reading its data raises ClikaRT::Error.

Declared in ClikaRT/compute/tensor.h, line 288

is_quantized()

bool is_quantized() const

True if this tensor carries a quantization scheme (a quantized tensor).

Declared in ClikaRT/compute/tensor.h, line 290

numel()

std::int64_t numel() const

The element count.

Declared in ClikaRT/compute/tensor.h, line 301

shape()

std::vector<std::int64_t> shape() const

The per-dimension sizes.

Declared in ClikaRT/compute/tensor.h, line 303

sizes()

std::vector<std::int64_t> sizes() const

The per-dimension sizes (synonym of shape).

Declared in ClikaRT/compute/tensor.h, line 305

strides()

std::vector<std::int64_t> strides() const

The per-dimension strides, in elements.

Declared in ClikaRT/compute/tensor.h, line 307

nbytes()

std::size_t nbytes() const

Total byte size of the element data.

Declared in ClikaRT/compute/tensor.h, line 309

to(Device)

Tensor to(Device device) const

Move to device, landing on the calling thread's current lane there: an ambient stream set for device by a placement scope names the lane, otherwise the thread's own asynchronous lane (the stream StreamOrDevice(device).resolve() names); never the device's default stream. A tensor already on device passes through unchanged, unless an ambient stream on that device names the lane it must land on (then it is re-homed onto it).

Declared in ClikaRT/compute/tensor.h, line 321

to(DataType)

Tensor to(DataType dtype) const

Move to device, landing on the calling thread's current lane there: an ambient stream set for device by a placement scope names the lane, otherwise the thread's own asynchronous lane (the stream StreamOrDevice(device).resolve() names); never the device's default stream. A tensor already on device passes through unchanged, unless an ambient stream on that device names the lane it must land on (then it is re-homed onto it).

Declared in ClikaRT/compute/tensor.h, line 324

to(Device, DataType)

Tensor to(Device device, DataType dtype) const

Move to device, landing on the calling thread's current lane there: an ambient stream set for device by a placement scope names the lane, otherwise the thread's own asynchronous lane (the stream StreamOrDevice(device).resolve() names); never the device's default stream. A tensor already on device passes through unchanged, unless an ambient stream on that device names the lane it must land on (then it is re-homed onto it).

Declared in ClikaRT/compute/tensor.h, line 327

contiguous()

Tensor contiguous() const

A row-major contiguous tensor: a metadata-only view when already contiguous, otherwise a freshly packed copy.

Declared in ClikaRT/compute/tensor.h, line 331

pin_memory()

Tensor pin_memory(StreamOrDevice peer) const

A page-locked host copy pinned for peer's DMA, or this tensor itself when already pinned for that peer. The tensor must be CPU-resident (pin never performs a hidden device→host transfer). Bind the result once and write it every step (copy_into) for an allocation-free serving loop.

Declared in ClikaRT/compute/tensor.h, line 338

const_data_ptr()

const void* const_data_ptr() const

Read-only pointer to the tensor's storage, for host-side consumption.

Requires HOST-RESIDENT data: a CPU tensor, or pinned host memory. Any other device tensor raises; move the data with to(Device::cpu()) first, or take device_const_data_ptr() when a kernel on that device is the reader. The pointer addresses the tensor's FIRST element; a non-contiguous view's elements are NOT adjacent; walk by strides() (or densify with ops::contiguous before raw iteration). Never compare tensors by this pointer; distinct tensors may alias one storage.

Throws

• ClikaRT::Error: when the data is not host-resident.

Returns: pointer to the first element, valid while this Tensor (or any alias of its storage) is alive.

Declared in ClikaRT/compute/tensor.h, line 362

mutable_data_ptr()

void* mutable_data_ptr()

Writable pointer to the tensor's storage, const_data_ptr's mutable sibling, same HOST-RESIDENT requirement and stride caveats. Writes land in the shared storage, visible to every alias/view of it. A kernel on the tensor's device writes through device_mutable_data_ptr() instead.

Throws

• ClikaRT::Error: when the data is not host-resident.

Returns: pointer to the first element.

Declared in ClikaRT/compute/tensor.h, line 371

device_const_data_ptr()

const void* device_const_data_ptr() const

Read-only pointer to the tensor's storage on the tensor's own device, for a kernel launched there. No host wait: the pointer is ordered on the tensor's stream, so inside a custom operator's compute() it is valid for a kernel launched on stream().native_handle() (the runtime has already ordered that stream after the inputs' producers). Anywhere else, synchronize() this tensor first and launch on the same stream.

The pointer is what the backend's own kernel API takes for this storage: a device address for a CUDA tensor (a CUDA kernel dereferences it, host code never does), the host address for a CPU tensor, and an opaque buffer handle for the Vulkan and Metal backends. Same first-element and stride caveats as const_data_ptr; never compare tensors by this pointer.

Throws

• ClikaRT::Error: when the tensor carries no data (a traced placeholder).

Returns: pointer to the first element, valid while this Tensor (or any alias of its storage) is alive.

Declared in ClikaRT/compute/tensor.h, line 392

device_mutable_data_ptr()

void* device_mutable_data_ptr()

Writable pointer to the tensor's storage on the tensor's own device, device_const_data_ptr's mutable sibling: same stream ordering, same meaning per backend, same stride caveats. This is how a custom operator's compute() writes its pre-allocated outputs from a device kernel. Writes land in the shared storage, visible to every alias/view of it.

Throws

• ClikaRT::Error: when the tensor carries no data.

Returns: pointer to the first element.

Declared in ClikaRT/compute/tensor.h, line 403

item()

template <``typename T``>
T item() const

Read the single element of a one-element tensor as T (host read; brings the value to the host first). A wrong T for this tensor's dtype, or a numel != 1, raises ClikaRT::Error. T is float/double/an integer width (bool allowed), or float16_t/bfloat16_t for the half dtypes.

Declared in ClikaRT/compute/tensor.h, line 410

item_as_vec()

template <``typename T``>
std::vector<T> item_as_vec() const

Read every element of a 0-D or 1-D tensor as std::vector<T> (host read). Requires the tensor be contiguous and T match its dtype; a Float16 / BFloat16 tensor reads as float16_t / bfloat16_t. bool and sub-byte dtypes are not supported here (use const_data_ptr).

Declared in ClikaRT/compute/tensor.h, line 421

schedule()

void schedule()

Run this tensor's deferred computation (a traced placeholder's, see TracingScope) on the tensor's stream WITHOUT waiting for it: on an asynchronous lane it returns before the value exists; on the default stream it completes inline. synchronize() waits either way. A tensor with no deferred computation is a no-op success.

Declared in ClikaRT/compute/tensor.h, line 435

synchronize()

Tensor& synchronize()

Block until this tensor's pending work has completed, THE settle point where an asynchronous failure surfaces. Returns *this under the value surface, Result<void> under the Result surface; CLIKART_CHECK is the mode-stable spelling.

Declared in ClikaRT/compute/tensor.h, line 442

status()

Status status() const

Where this tensor is in its async lifecycle. Do not call on a default (undefined) tensor.

Declared in ClikaRT/compute/tensor.h, line 446

is_complete()

bool is_complete() const noexcept

True once this tensor's pending work has completed: the poll-style counterpart of synchronize() (which waits) and on_complete() (which calls back). Never blocks: a non-blocking completion query per producer still in flight, no device wait, no host sync. False while a producing kernel is still running; true once it has finished, for a tensor built from a host buffer, for a tensor with no pending work (a traced placeholder included; those are the tensors on_complete calls back without delay), and for a default (undefined) tensor. A true answer surfaces no asynchronous failure and reads no bytes: synchronize() stays the settle point, and a read still goes through the ordinary accessors.

Declared in ClikaRT/compute/tensor.h, line 459

on_complete()

void on_complete(std::function<void(const Tensor &)> callback) const

Register a callback that fires when this tensor's producing kernel finishes, the push-style counterpart to synchronize(). It runs on a small internal callback pool (NOT the thread that called on_complete), and fires immediately if the tensor has no pending work. The callback receives this tensor by const ref. Keep the body short and do not block; a throw from it is swallowed. Thread-safe. A callback that reads a DIFFERENT tensor, one it was not registered on, should hold its own handle to it or synchronize() it first: the callback joins no dispatch ordering, so a concurrent in-place update cannot know to wait for that read.

Declared in ClikaRT/compute/tensor.h, line 470

is_same()

bool is_same(const Tensor& other) const

True if other is the same tensor object (a handle copy of this one). A view (e.g. from ops::reshape) is NOT is_same; use is_alias_of.

Declared in ClikaRT/compute/tensor.h, line 489

is_alias_of()

bool is_alias_of(const Tensor& other) const

True if other shares the same underlying storage (a write through one is visible through the other). A copy and a view both alias their source.

Declared in ClikaRT/compute/tensor.h, line 492

to_string()

std::string to_string() const

A human-readable summary: shape, dtype, device, element count, and the first few values (host-read; large tensors are truncated). For logging / debugging: std::printf("s", t.to_string().c_str()), or stream it (os << t.to_string()). Infallible: a value it cannot read back is shown as a short marker instead.

Declared in ClikaRT/compute/tensor.h, line 501

operator+(ops::ScalarOrTensor)

Tensor operator+(const ops::ScalarOrTensor& other) const

Declared in ClikaRT/compute/tensor.h, line 514

operator-(ops::ScalarOrTensor)

Tensor operator-(const ops::ScalarOrTensor& other) const

Declared in ClikaRT/compute/tensor.h, line 515

operator*()

Tensor operator*(const ops::ScalarOrTensor& other) const

Declared in ClikaRT/compute/tensor.h, line 516

operator/()

Tensor operator/(const ops::ScalarOrTensor& other) const

Declared in ClikaRT/compute/tensor.h, line 517

operator%()

Tensor operator%(const ops::ScalarOrTensor& other) const

Declared in ClikaRT/compute/tensor.h, line 518

operator-()

Tensor operator-() const

Declared in ClikaRT/compute/tensor.h, line 520

operator+()

Tensor operator+() const

Unary plus: identity (returns a copy of the handle).

Declared in ClikaRT/compute/tensor.h, line 522

operator+=()

Tensor& operator+=(const ops::ScalarOrTensor& other)

In-place elementwise += of a scalar or broadcastable tensor, the operator spelling of add_(); same semantics and error conditions as ops::add_. Raises ClikaRT::Error on failure; returns *this.

Declared in ClikaRT/compute/tensor.h, line 528

operator-=()

Tensor& operator-=(const ops::ScalarOrTensor& other)

In-place elementwise -= of a scalar or broadcastable tensor, the operator spelling of sub_(); same semantics and error conditions as ops::sub_. Raises ClikaRT::Error on failure; returns *this.

Declared in ClikaRT/compute/tensor.h, line 533

operator*=()

Tensor& operator*=(const ops::ScalarOrTensor& other)

In-place elementwise *= of a scalar or broadcastable tensor, the operator spelling of mul_(); same semantics and error conditions as ops::mul_. Raises ClikaRT::Error on failure; returns *this.

Declared in ClikaRT/compute/tensor.h, line 538

operator/=()

Tensor& operator/=(const ops::ScalarOrTensor& other)

In-place elementwise /= of a scalar or broadcastable tensor, the operator spelling of div_(); same semantics and error conditions as ops::div_. Raises ClikaRT::Error on failure; returns *this.

Declared in ClikaRT/compute/tensor.h, line 543

operator==()

Tensor operator==(const ops::ScalarOrTensor& other) const

Declared in ClikaRT/compute/tensor.h, line 546

operator!=()

Tensor operator!=(const ops::ScalarOrTensor& other) const

Declared in ClikaRT/compute/tensor.h, line 547

operator<()

Tensor operator<(const ops::ScalarOrTensor& other) const

Declared in ClikaRT/compute/tensor.h, line 548

operator<=()

Tensor operator<=(const ops::ScalarOrTensor& other) const

Declared in ClikaRT/compute/tensor.h, line 549

operator>()

Tensor operator>(const ops::ScalarOrTensor& other) const

Declared in ClikaRT/compute/tensor.h, line 550

operator>=()

Tensor operator>=(const ops::ScalarOrTensor& other) const

Declared in ClikaRT/compute/tensor.h, line 551

abs()

Tensor abs() const

Method form of ops::abs: elementwise absolute value; same contract. Returns a new tensor; raises ClikaRT::Error where ops::abs does.

Declared in ClikaRT/compute/tensor.h, line 556

neg()

Tensor neg() const

Method form of ops::neg: elementwise negation; same contract. Returns a new tensor; raises ClikaRT::Error where ops::neg does.

Declared in ClikaRT/compute/tensor.h, line 559

sum()

Tensor sum() const

Whole-tensor sum to a 0-D tensor, the method form of ops::sum; same reduction semantics and error conditions.

Declared in ClikaRT/compute/tensor.h, line 565

sum(Span< int64_t>, bool)

Tensor sum(ClikaRT::Span<const std::int64_t> dims, bool keepdim = false) const

sum along dims, the method form of ops::sum(x, dims, keepdim); keepdim keeps the reduced dims as size 1. Same semantics and error conditions as the ops:: form.

Declared in ClikaRT/compute/tensor.h, line 569

mean()

Tensor mean() const

Whole-tensor mean to a 0-D tensor, the method form of ops::mean; same reduction semantics and error conditions.

Declared in ClikaRT/compute/tensor.h, line 572

mean(Span< int64_t>, bool)

Tensor mean(ClikaRT::Span<const std::int64_t> dims, bool keepdim = false) const

mean along dims, the method form of ops::mean(x, dims, keepdim); keepdim keeps the reduced dims as size 1. Same semantics and error conditions as the ops:: form.

Declared in ClikaRT/compute/tensor.h, line 576

max()

Tensor max() const

Whole-tensor max to a 0-D tensor, the method form of ops::max; same reduction semantics and error conditions.

Declared in ClikaRT/compute/tensor.h, line 579

max(Span< int64_t>, bool)

Tensor max(ClikaRT::Span<const std::int64_t> dims, bool keepdim = false) const

max along dims, the method form of ops::max(x, dims, keepdim); keepdim keeps the reduced dims as size 1. Same semantics and error conditions as the ops:: form.

Declared in ClikaRT/compute/tensor.h, line 583

min()

Tensor min() const

Whole-tensor min to a 0-D tensor, the method form of ops::min; same reduction semantics and error conditions.

Declared in ClikaRT/compute/tensor.h, line 586

min(Span< int64_t>, bool)

Tensor min(ClikaRT::Span<const std::int64_t> dims, bool keepdim = false) const

min along dims, the method form of ops::min(x, dims, keepdim); keepdim keeps the reduced dims as size 1. Same semantics and error conditions as the ops:: form.

Declared in ClikaRT/compute/tensor.h, line 590

add()

Tensor add(const ops::ScalarOrTensor& other) const

Method form of ops::add with a scalar or broadcastable tensor operand. Returns a NEW tensor and chains fluently (a.relu().add(1.0)); same semantics and error conditions.

Declared in ClikaRT/compute/tensor.h, line 598

sub()

Tensor sub(const ops::ScalarOrTensor& other) const

Method form of ops::sub with a scalar or broadcastable tensor operand. Returns a NEW tensor and chains fluently (a.relu().sub(1.0)); same semantics and error conditions.

Declared in ClikaRT/compute/tensor.h, line 602

mul()

Tensor mul(const ops::ScalarOrTensor& other) const

Method form of ops::mul with a scalar or broadcastable tensor operand. Returns a NEW tensor and chains fluently (a.relu().mul(1.0)); same semantics and error conditions.

Declared in ClikaRT/compute/tensor.h, line 606

div()

Tensor div(const ops::ScalarOrTensor& other) const

Method form of ops::div with a scalar or broadcastable tensor operand. Returns a NEW tensor and chains fluently (a.relu().div(1.0)); same semantics and error conditions.

Declared in ClikaRT/compute/tensor.h, line 610

matmul()

Tensor matmul(Tensor other) const

Method form of ops::matmul: batched matrix multiply with the ops:: broadcasting/promotion contract; returns a new tensor.

Declared in ClikaRT/compute/tensor.h, line 651

reshape()

Tensor reshape(ClikaRT::Span<const ops::IndexBound> shape) const

A dim entry is an int literal OR a 0-D/1-D integer Tensor (an ops::IndexBound, e.g. a shape_host read); see ops::reshape.

Declared in ClikaRT/compute/tensor.h, line 654

softmax()

Tensor softmax(std::int64_t dim = -1) const

Method form of ops::softmax along dim (default -1); same semantics and error conditions.

Declared in ClikaRT/compute/tensor.h, line 657

shape_host()

Tensor shape_host() const

The shape as a HOST-resident Int64 tensor written from metadata: no device kernel, no readback, no stream synchronize (unlike the concrete shape() ints, which wait for an in-flight producer). Feed it to shape-consuming op arguments, e.g. x.reshape({x.shape_host(1), d}).

Declared in ClikaRT/compute/tensor.h, line 662

shape_host(int64_t)

Tensor shape_host(std::int64_t dim) const

One dim of the shape as a 0-D Int64 host tensor (negative dim counts from the end). Same no-sync contract as shape_host().

Declared in ClikaRT/compute/tensor.h, line 665

numel_host()

Tensor numel_host() const

The element count as a 0-D Int64 HOST tensor written from metadata; the same no-sync contract as shape_host(). Composes the flatten idiom x.reshape({x.numel_host()}).

Declared in ClikaRT/compute/tensor.h, line 669

ndim_host()

Tensor ndim_host() const

The rank as a 0-D Int64 HOST tensor written from metadata; the same no-sync contract as shape_host().

Declared in ClikaRT/compute/tensor.h, line 672

pow()

Tensor pow(const ops::ScalarOrTensor& exponent) const

Method form of ops::pow: elementwise power with a scalar or broadcastable exponent; same semantics and error conditions.

Declared in ClikaRT/compute/tensor.h, line 675

index()

Tensor index(ClikaRT::Span<const ops::IndexEntry> indices) const

Advanced indexing: t.index({1, ops::slice_all, idx_tensor}). Entries are the standard vocabulary (ops::IndexEntry): int, bool, Tensor, ops::IndexSlice, ops::ellipsis, ops::new_axis.

Declared in ClikaRT/compute/tensor.h, line 679

index_put()

Tensor index_put(
    ClikaRT::Span<const ops::IndexEntry> indices,
    const ops::ScalarOrTensor& value,
    bool accumulate = false
) const

The out-of-place write-through-index: a copy of this with value written (or accumulated) at the indexed positions.

Declared in ClikaRT/compute/tensor.h, line 682

index_put_()

Tensor& index_put_(
    ClikaRT::Span<const ops::IndexEntry> indices,
    const ops::ScalarOrTensor& value,
    bool accumulate = false
)

In-place t[indices] = value (or += with accumulate); returns *this so it chains. A failure raises ClikaRT::Error.

Declared in ClikaRT/compute/tensor.h, line 685

add_()

Tensor& add_(const ops::ScalarOrTensor& other)

In-place add: writes through this tensor's storage; same formula, arguments, and error conditions as ops::add_. Returns *this under the value surface, Result<void> under the Result surface; CLIKART_CHECK is the mode-stable spelling; views write through their base storage.

Declared in ClikaRT/compute/tensor.h, line 693

sub_()

Tensor& sub_(const ops::ScalarOrTensor& other)

In-place sub: writes through this tensor's storage; same formula, arguments, and error conditions as ops::sub_. Returns *this under the value surface, Result<void> under the Result surface; CLIKART_CHECK is the mode-stable spelling; views write through their base storage.

Declared in ClikaRT/compute/tensor.h, line 697

mul_()

Tensor& mul_(const ops::ScalarOrTensor& other)

In-place mul: writes through this tensor's storage; same formula, arguments, and error conditions as ops::mul_. Returns *this under the value surface, Result<void> under the Result surface; CLIKART_CHECK is the mode-stable spelling; views write through their base storage.

Declared in ClikaRT/compute/tensor.h, line 701

div_()

Tensor& div_(const ops::ScalarOrTensor& other)

In-place div: writes through this tensor's storage; same formula, arguments, and error conditions as ops::div_. Returns *this under the value surface, Result<void> under the Result surface; CLIKART_CHECK is the mode-stable spelling; views write through their base storage.

Declared in ClikaRT/compute/tensor.h, line 705

abs_()

Tensor& abs_()

In-place abs: writes through this tensor's storage; same contract as ops::abs_. Returns *this under the value surface, Result<void> under the Result surface; CLIKART_CHECK is the mode-stable spelling.

Declared in ClikaRT/compute/tensor.h, line 708

neg_()

Tensor& neg_()

In-place neg: writes through this tensor's storage; same contract as ops::neg_. Returns *this under the value surface, Result<void> under the Result surface; CLIKART_CHECK is the mode-stable spelling.

Declared in ClikaRT/compute/tensor.h, line 711

elu()

Tensor elu(
    double alpha,
    double scale,
    double input_scale
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 10

elu_()

Tensor& elu_(
    double alpha,
    double scale,
    double input_scale
)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 12

selu()

Tensor selu() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 14

selu_()

Tensor& selu_()

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 16

celu()

Tensor celu(double alpha) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 18

celu_()

Tensor& celu_(double alpha)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 20

geglu()

Tensor geglu(ops::GeluMode approximate) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 22

reglu()

Tensor reglu() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 24

quick_gelu()

Tensor quick_gelu() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 26

fast_gelu()

Tensor fast_gelu() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 28

glu()

Tensor glu(int64_t dim) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 30

hardshrink()

Tensor hardshrink(double lambd) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 32

hardshrink_()

Tensor& hardshrink_(double lambd)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 34

hardsigmoid()

Tensor hardsigmoid() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 36

hardsigmoid_()

Tensor& hardsigmoid_()

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 38

hardswish()

Tensor hardswish() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 40

hardswish_()

Tensor& hardswish_()

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 42

hardtanh()

Tensor hardtanh(double min_val, double max_val) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 44

hardtanh_()

Tensor& hardtanh_(double min_val, double max_val)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 46

leaky_relu()

Tensor leaky_relu(double negative_slope) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 48

leaky_relu_()

Tensor& leaky_relu_(double negative_slope)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 50

log_sigmoid()

Tensor log_sigmoid() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 52

log_sigmoid_()

Tensor& log_sigmoid_()

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 54

log_softmax()

Tensor log_softmax(int64_t dim, DataType dtype) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 56

log_softmax_()

Tensor& log_softmax_(int64_t dim)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 58

mish()

Tensor mish() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 60

mish_()

Tensor& mish_()

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 62

prelu()

Tensor prelu(Tensor weight) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 64

prelu_()

Tensor& prelu_(Tensor weight)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 66

relu6()

Tensor relu6() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 68

relu6_()

Tensor& relu6_()

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 70

snake()

Tensor snake(
    Tensor alpha,
    Tensor beta,
    double eps
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 72

snake_()

Tensor& snake_(
    Tensor alpha,
    Tensor beta,
    double eps
)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 74

softmax_()

Tensor& softmax_(int64_t dim)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 76

softmin()

Tensor softmin(int64_t dim, DataType dtype) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 78

softmin_()

Tensor& softmin_(int64_t dim)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 80

softplus()

Tensor softplus(double beta, double threshold) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 82

softplus_()

Tensor& softplus_(double beta, double threshold)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 84

softshrink()

Tensor softshrink(double lambd) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 86

softshrink_()

Tensor& softshrink_(double lambd)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 88

softsign()

Tensor softsign() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 90

softsign_()

Tensor& softsign_()

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 92

swiglu()

Tensor swiglu(
    double alpha,
    double beta,
    double limit
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 94

threshold()

Tensor threshold(double threshold, double value) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 96

threshold_()

Tensor& threshold_(double threshold, double value)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 98

scaled_dot_product_attention()

Tensor scaled_dot_product_attention(
    Tensor key,
    Tensor value,
    Tensor attn_mask,
    bool is_causal,
    ops::ScalarOrTensor q_scale,
    ops::ScalarOrTensor k_scale,
    ops::ScalarOrTensor v_scale
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 100

scaled_dot_product_attention_varlen()

Tensor scaled_dot_product_attention_varlen(
    Tensor key,
    Tensor value,
    Tensor cu_seqlens_q,
    Tensor cu_seqlens_k,
    ops::ScalarOrTensor max_seqlen_q,
    ops::ScalarOrTensor max_seqlen_k,
    Tensor attn_mask,
    bool is_causal,
    ops::ScalarOrTensor q_scale,
    ops::ScalarOrTensor k_scale,
    ops::ScalarOrTensor v_scale
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 102

attention()

Tensor attention(
    Tensor key,
    Tensor value,
    Tensor attn_mask,
    Tensor head_sink,
    std::optional<bool> is_causal,
    ops::ScalarOrTensor q_scale,
    std::optional<double> softcap,
    std::optional<int64_t> sliding_window,
    std::optional<bool> smooth_softmax,
    ops::ScalarOrTensor k_scale,
    ops::ScalarOrTensor v_scale
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 104

attention_varlen()

Tensor attention_varlen(
    Tensor key,
    Tensor value,
    Tensor cu_seqlens_q,
    Tensor cu_seqlens_k,
    ops::ScalarOrTensor max_seqlen_q,
    ops::ScalarOrTensor max_seqlen_k,
    Tensor attn_mask,
    Tensor head_sink,
    std::optional<bool> is_causal,
    ops::ScalarOrTensor q_scale,
    std::optional<double> softcap,
    std::optional<int64_t> sliding_window,
    std::optional<bool> smooth_softmax,
    ops::ScalarOrTensor k_scale,
    ops::ScalarOrTensor v_scale
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 106

group_query_attention()

std::array<Tensor 3> group_query_attention(
    Tensor key,
    Tensor value,
    Tensor past_key,
    Tensor past_value,
    Tensor kvcache_start,
    Tensor rope_cos,
    Tensor rope_sin,
    Tensor position_ids,
    Tensor attn_mask,
    std::optional<bool> is_causal,
    ops::ScalarOrTensor q_scale,
    std::optional<double> softcap,
    std::optional<int64_t> sliding_window,
    std::optional<bool> smooth_softmax,
    std::optional<ops::RotaryMode> rotary_mode,
    std::optional<int64_t> num_heads,
    std::optional<int64_t> kv_num_heads,
    Tensor out_present_key,
    Tensor out_present_value,
    ops::ScalarOrTensor k_scale,
    ops::ScalarOrTensor v_scale,
    Tensor head_sink,
    Tensor q_norm_gain,
    Tensor k_norm_gain,
    std::optional<double> qk_norm_eps,
    Tensor slot_ids
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 108

group_query_attention_varlen()

std::array<Tensor 3> group_query_attention_varlen(
    Tensor key,
    Tensor value,
    Tensor cu_seqlens_q,
    Tensor cu_seqlens_k,
    ops::ScalarOrTensor max_seqlen_q,
    ops::ScalarOrTensor max_seqlen_k,
    Tensor past_key,
    Tensor past_value,
    Tensor kvcache_start,
    Tensor rope_cos,
    Tensor rope_sin,
    Tensor position_ids,
    Tensor attn_mask,
    Tensor head_sink,
    std::optional<bool> is_causal,
    ops::ScalarOrTensor q_scale,
    std::optional<double> softcap,
    std::optional<int64_t> sliding_window,
    std::optional<bool> smooth_softmax,
    std::optional<ops::RotaryMode> rotary_mode,
    std::optional<int64_t> num_heads,
    std::optional<int64_t> kv_num_heads,
    Tensor out_present_key,
    Tensor out_present_value,
    ops::ScalarOrTensor k_scale,
    ops::ScalarOrTensor v_scale,
    Tensor q_norm_gain,
    Tensor k_norm_gain,
    std::optional<double> qk_norm_eps,
    Tensor slot_ids
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 110

attention_over_cache()

Tensor attention_over_cache(
    Tensor cache_key,
    Tensor cache_value,
    Tensor kvcache_start,
    Tensor cu_seqlens_q,
    Tensor cu_seqlens_k,
    ops::ScalarOrTensor max_seqlen_q,
    ops::ScalarOrTensor max_seqlen_k,
    Tensor rope_cos,
    Tensor rope_sin,
    Tensor position_ids,
    Tensor attn_mask,
    std::optional<bool> is_causal,
    ops::ScalarOrTensor q_scale,
    std::optional<double> softcap,
    std::optional<int64_t> sliding_window,
    std::optional<bool> smooth_softmax,
    std::optional<ops::RotaryMode> rotary_mode,
    std::optional<int64_t> num_heads,
    std::optional<int64_t> kv_num_heads,
    ops::ScalarOrTensor k_scale,
    ops::ScalarOrTensor v_scale,
    Tensor head_sink,
    Tensor q_norm_gain,
    Tensor k_norm_gain,
    std::optional<double> qk_norm_eps,
    Tensor slot_ids
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 112

atan2()

Tensor atan2(Tensor other) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 114

atan2_()

Tensor& atan2_(Tensor other)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 116

copysign()

Tensor copysign(ops::ScalarOrTensor other) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 118

copysign_()

Tensor& copysign_(ops::ScalarOrTensor other)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 120

floor_divide()

Tensor floor_divide(ops::ScalarOrTensor other) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 122

floor_divide_()

Tensor& floor_divide_(ops::ScalarOrTensor other)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 124

fmax()

Tensor fmax(Tensor other) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 126

fmin()

Tensor fmin(Tensor other) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 128

hypot()

Tensor hypot(Tensor other) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 130

hypot_()

Tensor& hypot_(Tensor other)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 132

logaddexp()

Tensor logaddexp(Tensor other) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 134

logaddexp2()

Tensor logaddexp2(Tensor other) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 136

maximum()

Tensor maximum(Tensor other) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 138

maximum_()

Tensor& maximum_(Tensor other)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 140

minimum()

Tensor minimum(Tensor other) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 142

minimum_()

Tensor& minimum_(Tensor other)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 144

mod()

Tensor mod(ops::ScalarOrTensor other, ops::ModMode mode) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 146

mod_()

Tensor& mod_(ops::ScalarOrTensor other, ops::ModMode mode)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 148

remainder()

Tensor remainder(ops::ScalarOrTensor other) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 150

remainder_()

Tensor& remainder_(ops::ScalarOrTensor other)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 152

fmod()

Tensor fmod(ops::ScalarOrTensor other) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 154

fmod_()

Tensor& fmod_(ops::ScalarOrTensor other)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 156

deg2rad()

Tensor deg2rad() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 158

deg2rad_()

Tensor& deg2rad_()

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 160

rad2deg()

Tensor rad2deg() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 162

rad2deg_()

Tensor& rad2deg_()

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 164

pow_()

Tensor& pow_(ops::ScalarOrTensor exponent)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 166

xlog1py()

Tensor xlog1py(ops::ScalarOrTensor other) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 168

xlogy()

Tensor xlogy(ops::ScalarOrTensor other) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 170

xlogy_()

Tensor& xlogy_(ops::ScalarOrTensor other)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 172

bitwise_and()

Tensor bitwise_and(ops::ScalarOrTensor other) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 174

bitwise_and_()

Tensor& bitwise_and_(ops::ScalarOrTensor other)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 176

bitwise_left_shift()

Tensor bitwise_left_shift(ops::ScalarOrTensor other) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 178

bitwise_left_shift_()

Tensor& bitwise_left_shift_(ops::ScalarOrTensor other)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 180

bitwise_not()

Tensor bitwise_not() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 182

bitwise_not_()

Tensor& bitwise_not_()

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 184

bitwise_or()

Tensor bitwise_or(ops::ScalarOrTensor other) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 186

bitwise_or_()

Tensor& bitwise_or_(ops::ScalarOrTensor other)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 188

bitwise_right_shift()

Tensor bitwise_right_shift(ops::ScalarOrTensor other) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 190

bitwise_right_shift_()

Tensor& bitwise_right_shift_(ops::ScalarOrTensor other)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 192

bitwise_xor()

Tensor bitwise_xor(ops::ScalarOrTensor other) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 194

bitwise_xor_()

Tensor& bitwise_xor_(ops::ScalarOrTensor other)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 196

allclose()

Tensor allclose(
    Tensor other,
    double rtol,
    double atol,
    bool equal_nan
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 198

eq()

Tensor eq(ops::ScalarOrTensor other) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 200

eq_()

Tensor& eq_(ops::ScalarOrTensor other)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 202

ge()

Tensor ge(ops::ScalarOrTensor other) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 204

ge_()

Tensor& ge_(ops::ScalarOrTensor other)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 206

gt()

Tensor gt(ops::ScalarOrTensor other) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 208

gt_()

Tensor& gt_(ops::ScalarOrTensor other)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 210

isclose()

Tensor isclose(
    Tensor other,
    double rtol,
    double atol,
    bool equal_nan
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 212

isfinite()

Tensor isfinite() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 214

isinf()

Tensor isinf() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 216

isnan()

Tensor isnan() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 218

isneginf()

Tensor isneginf() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 220

isposinf()

Tensor isposinf() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 222

le()

Tensor le(ops::ScalarOrTensor other) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 224

le_()

Tensor& le_(ops::ScalarOrTensor other)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 226

logical_and()

Tensor logical_and(Tensor other) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 228

logical_and_()

Tensor& logical_and_(Tensor other)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 230

logical_not()

Tensor logical_not() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 232

logical_not_()

Tensor& logical_not_()

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 234

logical_or()

Tensor logical_or(Tensor other) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 236

logical_or_()

Tensor& logical_or_(Tensor other)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 238

logical_xor()

Tensor logical_xor(Tensor other) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 240

logical_xor_()

Tensor& logical_xor_(Tensor other)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 242

lt()

Tensor lt(ops::ScalarOrTensor other) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 244

lt_()

Tensor& lt_(ops::ScalarOrTensor other)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 246

ne()

Tensor ne(ops::ScalarOrTensor other) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 248

ne_()

Tensor& ne_(ops::ScalarOrTensor other)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 250

conv()

Tensor conv(
    Tensor weight,
    Tensor bias,
    ClikaRT::Span<const std::int64_t> stride,
    ClikaRT::Span<const std::int64_t> padding,
    ClikaRT::Span<const std::int64_t> dilation,
    int64_t groups,
    ops::PadMode mode,
    std::optional<double> value,
    ops::Activation activation
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 252

conv1d()

Tensor conv1d(
    Tensor weight,
    Tensor bias,
    ClikaRT::Span<const std::int64_t> stride,
    ClikaRT::Span<const std::int64_t> padding,
    ClikaRT::Span<const std::int64_t> dilation,
    int64_t groups,
    ops::Activation activation
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 254

conv2d()

Tensor conv2d(
    Tensor weight,
    Tensor bias,
    ClikaRT::Span<const std::int64_t> stride,
    ClikaRT::Span<const std::int64_t> padding,
    ClikaRT::Span<const std::int64_t> dilation,
    int64_t groups,
    ops::Activation activation
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 256

conv3d()

Tensor conv3d(
    Tensor weight,
    Tensor bias,
    ClikaRT::Span<const std::int64_t> stride,
    ClikaRT::Span<const std::int64_t> padding,
    ClikaRT::Span<const std::int64_t> dilation,
    int64_t groups,
    ops::Activation activation
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 258

conv_transpose()

Tensor conv_transpose(
    Tensor weight,
    Tensor bias,
    ClikaRT::Span<const std::int64_t> stride,
    ClikaRT::Span<const std::int64_t> padding,
    ClikaRT::Span<const std::int64_t> output_padding,
    int64_t groups,
    ClikaRT::Span<const std::int64_t> dilation,
    ops::Activation activation
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 260

conv_transpose1d()

Tensor conv_transpose1d(
    Tensor weight,
    Tensor bias,
    ClikaRT::Span<const std::int64_t> stride,
    ClikaRT::Span<const std::int64_t> padding,
    ClikaRT::Span<const std::int64_t> output_padding,
    int64_t groups,
    ClikaRT::Span<const std::int64_t> dilation,
    ops::Activation activation
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 262

conv_transpose2d()

Tensor conv_transpose2d(
    Tensor weight,
    Tensor bias,
    ClikaRT::Span<const std::int64_t> stride,
    ClikaRT::Span<const std::int64_t> padding,
    ClikaRT::Span<const std::int64_t> output_padding,
    int64_t groups,
    ClikaRT::Span<const std::int64_t> dilation,
    ops::Activation activation
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 264

conv_transpose3d()

Tensor conv_transpose3d(
    Tensor weight,
    Tensor bias,
    ClikaRT::Span<const std::int64_t> stride,
    ClikaRT::Span<const std::int64_t> padding,
    ClikaRT::Span<const std::int64_t> output_padding,
    int64_t groups,
    ClikaRT::Span<const std::int64_t> dilation,
    ops::Activation activation
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 266

deform_conv()

Tensor deform_conv(
    Tensor weight,
    Tensor offset,
    Tensor mask,
    Tensor bias,
    ClikaRT::Span<const std::int64_t> stride,
    ClikaRT::Span<const std::int64_t> padding,
    ClikaRT::Span<const std::int64_t> dilation,
    int64_t groups,
    int64_t offset_groups,
    ops::Activation activation
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 268

fold()

Tensor fold(
    ClikaRT::Span<const std::int64_t> output_size,
    ClikaRT::Span<const std::int64_t> kernel_size,
    ClikaRT::Span<const std::int64_t> dilation,
    ClikaRT::Span<const std::int64_t> padding,
    ClikaRT::Span<const std::int64_t> stride,
    ops::PadMode mode,
    std::optional<double> value
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 270

unfold()

Tensor unfold(
    ClikaRT::Span<const std::int64_t> kernel_size,
    ClikaRT::Span<const std::int64_t> dilation,
    ClikaRT::Span<const std::int64_t> padding,
    ClikaRT::Span<const std::int64_t> stride,
    ops::PadMode mode,
    std::optional<double> value
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 272

cast()

Tensor cast(DataType target, bool force_copy) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 274

cast_like()

Tensor cast_like(Tensor reference) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 276

copy()

Tensor copy(StreamOrDevice target, bool force_copy) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 278

clone()

Tensor clone() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 280

copy_()

Tensor& copy_(Tensor src, StreamOrDevice target)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 282

copy_into()

Tensor& copy_into(Tensor src, StreamOrDevice target)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 284

copy_to_cpu()

Tensor copy_to_cpu() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 286

embedding()

Tensor embedding(
    Tensor weight,
    Tensor bias,
    std::optional<ops::Activation> activation
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 288

one_hot()

Tensor one_hot(int64_t num_classes) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 290

rotary_embedding()

Tensor rotary_embedding(
    Tensor position_ids,
    Tensor cos,
    Tensor sin,
    std::optional<ops::RotaryMode> mode,
    std::optional<int64_t> rotary_dim,
    std::optional<double> theta,
    std::optional<ops::RopeScaling> scaling,
    std::optional<double> scale,
    std::optional<double> low_freq_factor,
    std::optional<double> high_freq_factor,
    std::optional<int64_t> original_max_pos,
    std::optional<double> beta_fast,
    std::optional<double> beta_slow,
    Tensor freq_factors
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 292

rotary_embedding_qk()

std::array<Tensor 2> rotary_embedding_qk(
    Tensor key,
    Tensor position_ids,
    Tensor cos,
    Tensor sin,
    std::optional<ops::RotaryMode> mode,
    std::optional<int64_t> rotary_dim,
    std::optional<double> theta,
    std::optional<ops::RopeScaling> scaling,
    std::optional<double> scale,
    std::optional<double> low_freq_factor,
    std::optional<double> high_freq_factor,
    std::optional<int64_t> original_max_pos,
    std::optional<double> beta_fast,
    std::optional<double> beta_slow,
    Tensor freq_factors
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 294

rotary_embedding_varlen()

Tensor rotary_embedding_varlen(
    Tensor cu_seqlens,
    Tensor seqlens,
    Tensor position_ids,
    Tensor cos,
    Tensor sin,
    std::optional<ops::RotaryMode> mode,
    std::optional<int64_t> rotary_dim,
    std::optional<double> theta,
    std::optional<ops::RopeScaling> scaling,
    std::optional<double> scale,
    std::optional<double> low_freq_factor,
    std::optional<double> high_freq_factor,
    std::optional<int64_t> original_max_pos,
    std::optional<double> beta_fast,
    std::optional<double> beta_slow,
    Tensor freq_factors
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 296

rotary_embedding_qk_varlen()

std::array<Tensor 2> rotary_embedding_qk_varlen(
    Tensor key,
    Tensor cu_seqlens,
    Tensor seqlens,
    Tensor position_ids,
    Tensor cos,
    Tensor sin,
    std::optional<ops::RotaryMode> mode,
    std::optional<int64_t> rotary_dim,
    std::optional<double> theta,
    std::optional<ops::RopeScaling> scaling,
    std::optional<double> scale,
    std::optional<double> low_freq_factor,
    std::optional<double> high_freq_factor,
    std::optional<int64_t> original_max_pos,
    std::optional<double> beta_fast,
    std::optional<double> beta_slow,
    Tensor freq_factors
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 298

mrope_rotary_embedding()

Tensor mrope_rotary_embedding(
    Tensor position_ids,
    ClikaRT::Span<const std::int64_t> mrope_sections,
    std::optional<bool> interleaved_sections,
    std::optional<double> theta,
    std::optional<ops::RopeScaling> scaling,
    std::optional<ops::RotaryMode> mode,
    std::optional<int64_t> rotary_dim,
    std::optional<double> scale
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 300

mrope_rotary_embedding_varlen()

Tensor mrope_rotary_embedding_varlen(
    Tensor position_ids,
    ClikaRT::Span<const std::int64_t> mrope_sections,
    std::optional<bool> interleaved_sections,
    std::optional<double> theta,
    std::optional<ops::RopeScaling> scaling,
    std::optional<ops::RotaryMode> mode,
    std::optional<int64_t> rotary_dim,
    std::optional<double> scale
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 302

mrope_rotary_embedding_qk_varlen()

std::array<Tensor 2> mrope_rotary_embedding_qk_varlen(
    Tensor key,
    Tensor position_ids,
    ClikaRT::Span<const std::int64_t> mrope_sections,
    std::optional<bool> interleaved_sections,
    std::optional<double> theta,
    std::optional<ops::RopeScaling> scaling,
    std::optional<ops::RotaryMode> mode,
    std::optional<int64_t> rotary_dim,
    std::optional<double> scale
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 304

empty_like()

Tensor empty_like(StreamOrDevice device) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 306

fill()

Tensor fill(ops::ScalarOrTensor value, StreamOrDevice device) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 308

fill_()

Tensor& fill_(ops::ScalarOrTensor value, StreamOrDevice device)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 310

full_like()

Tensor full_like(ops::ScalarOrTensor fill_value, StreamOrDevice device) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 312

ones_like()

Tensor ones_like(StreamOrDevice device) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 314

zero_()

Tensor& zero_(StreamOrDevice device)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 316

zeros_like()

Tensor zeros_like(StreamOrDevice device) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 318

gather()

Tensor gather(int64_t dim, Tensor index) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 320

take_along_dim()

Tensor take_along_dim(Tensor index, std::optional<int64_t> dim) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 322

take()

Tensor take(Tensor index) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 324

index_add()

Tensor index_add(
    int64_t dim,
    Tensor indices,
    Tensor src
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 326

index_add_()

Tensor& index_add_(
    int64_t dim,
    Tensor indices,
    Tensor src
)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 328

index_copy()

Tensor index_copy(
    int64_t dim,
    Tensor indices,
    Tensor src
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 330

index_copy_()

Tensor& index_copy_(
    int64_t dim,
    Tensor indices,
    Tensor src
)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 332

index_fill()

Tensor index_fill(
    int64_t dim,
    Tensor indices,
    ops::ScalarOrTensor value
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 334

index_fill_()

Tensor& index_fill_(
    int64_t dim,
    Tensor indices,
    ops::ScalarOrTensor value
)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 336

index_select()

Tensor index_select(int64_t dim, Tensor index) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 338

masked_fill()

Tensor masked_fill(Tensor mask, ops::ScalarOrTensor value) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 340

masked_fill_()

Tensor& masked_fill_(Tensor mask, ops::ScalarOrTensor value)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 342

masked_scatter()

Tensor masked_scatter(Tensor mask, Tensor source) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 344

masked_scatter_()

Tensor& masked_scatter_(Tensor mask, Tensor source)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 346

masked_select()

Tensor masked_select(Tensor mask) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 348

nonzero()

Tensor nonzero() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 350

put()

Tensor put(
    Tensor index,
    Tensor source,
    bool accumulate
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 352

put_()

Tensor& put_(
    Tensor index,
    Tensor source,
    bool accumulate
)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 354

scatter()

Tensor scatter(
    int64_t dim,
    Tensor index,
    ops::ScalarOrTensor src
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 356

scatter_()

Tensor& scatter_(
    int64_t dim,
    Tensor index,
    ops::ScalarOrTensor src
)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 358

scatter_add()

Tensor scatter_add(
    int64_t dim,
    Tensor index,
    Tensor src,
    bool deterministic
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 360

scatter_add_()

Tensor& scatter_add_(
    int64_t dim,
    Tensor index,
    Tensor src,
    bool deterministic
)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 362

scatter_reduce()

Tensor scatter_reduce(
    int64_t dim,
    Tensor index,
    Tensor src,
    ops::ScatterReduceMode reduce,
    bool include_self,
    bool deterministic
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 364

scatter_reduce_()

Tensor& scatter_reduce_(
    int64_t dim,
    Tensor index,
    Tensor src,
    ops::ScatterReduceMode reduce,
    bool include_self,
    bool deterministic
)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 366

where(Tensor, Tensor)

Tensor where(Tensor input, Tensor other) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 368

where()

Tensor where() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 370

nms()

Tensor nms(
    Tensor scores,
    std::optional<ops::ScalarOrTensor> max_output_boxes_per_class,
    std::optional<ops::ScalarOrTensor> iou_threshold,
    std::optional<ops::ScalarOrTensor> score_threshold,
    bool center_point_box
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 372

cosine_similarity()

Tensor cosine_similarity(
    Tensor x2,
    int64_t dim,
    std::optional<double> eps
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 374

cross()

Tensor cross(Tensor other, std::optional<int64_t> dim) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 376

dot()

Tensor dot(Tensor other) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 378

inner()

Tensor inner(Tensor other) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 380

kron()

Tensor kron(Tensor other) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 382

mm()

Tensor mm(
    Tensor other,
    Tensor bias,
    std::optional<ops::Activation> activation
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 384

bmm()

Tensor bmm(
    Tensor other,
    Tensor bias,
    std::optional<ops::Activation> activation
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 386

mv()

Tensor mv(
    Tensor vec,
    Tensor bias,
    std::optional<ops::Activation> activation
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 388

linear()

Tensor linear(
    Tensor weight,
    Tensor bias,
    std::optional<ops::Activation> activation,
    double situ_beta,
    double situ_linear_beta
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 390

moe()

Tensor moe(
    Tensor router_logits,
    Tensor fc1_experts,
    Tensor fc2_experts,
    int64_t top_k,
    Tensor fc1_bias,
    Tensor fc2_bias,
    Tensor fc3_experts,
    Tensor fc3_bias,
    Tensor e_score_correction_bias,
    Tensor router_weights,
    std::optional<ops::MoeRouting> routing_mode,
    std::optional<bool> renormalize,
    std::optional<int64_t> n_group,
    std::optional<int64_t> topk_group,
    std::optional<double> routed_scaling_factor,
    std::optional<double> sparse_mixer_eps,
    std::optional<bool> apply_router_weight_on_input,
    std::optional<ops::Activation> activation,
    std::optional<ops::fused::SwigluFusion> swiglu_fusion,
    std::optional<double> swiglu_alpha,
    std::optional<double> swiglu_beta,
    std::optional<double> swiglu_limit,
    std::optional<ops::GeluMode> gelu_mode,
    Tensor shared_output
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 392

outer()

Tensor outer(Tensor other) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 394

tensordot()

Tensor tensordot(
    Tensor b,
    ClikaRT::Span<const std::int64_t> dims_a,
    ClikaRT::Span<const std::int64_t> dims_b
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 396

binary_cross_entropy()

Tensor binary_cross_entropy(
    Tensor target,
    Tensor weight,
    ops::Reduction reduction
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 398

binary_cross_entropy_with_logits()

Tensor binary_cross_entropy_with_logits(
    Tensor target,
    Tensor weight,
    ops::Reduction reduction,
    Tensor pos_weight
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 400

cross_entropy()

Tensor cross_entropy(
    Tensor target,
    Tensor weight,
    std::optional<int64_t> ignore_index,
    ops::Reduction reduction
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 402

huber_loss()

Tensor huber_loss(
    Tensor target,
    ops::Reduction reduction,
    double delta
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 404

kl_div()

Tensor kl_div(
    Tensor target,
    ops::Reduction reduction,
    bool log_target
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 406

l1_loss()

Tensor l1_loss(Tensor target, ops::Reduction reduction) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 408

mse_loss()

Tensor mse_loss(Tensor target, ops::Reduction reduction) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 410

nll_loss()

Tensor nll_loss(
    Tensor target,
    Tensor weight,
    std::optional<int64_t> ignore_index,
    ops::Reduction reduction
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 412

smooth_l1_loss()

Tensor smooth_l1_loss(
    Tensor target,
    ops::Reduction reduction,
    double beta
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 414

atleast_1d()

Tensor atleast_1d() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 416

atleast_2d()

Tensor atleast_2d() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 418

atleast_3d()

Tensor atleast_3d() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 420

diag()

Tensor diag(int64_t diagonal) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 422

diag_embed()

Tensor diag_embed(
    int64_t offset,
    int64_t dim1,
    int64_t dim2
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 424

diagonal()

Tensor diagonal(
    int64_t offset,
    int64_t dim1,
    int64_t dim2
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 426

expand()

Tensor expand(ClikaRT::Span<const ops::ScalarOrTensor> shape, bool bidirectional) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 428

expand_as()

Tensor expand_as(Tensor other) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 430

broadcast_to()

Tensor broadcast_to(ClikaRT::Span<const ops::ScalarOrTensor> shape) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 432

flatten()

Tensor flatten(int64_t start_dim, int64_t end_dim) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 434

flip()

Tensor flip(ClikaRT::Span<const std::int64_t> dims) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 436

fliplr()

Tensor fliplr() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 438

flipud()

Tensor flipud() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 440

pad()

Tensor pad(
    ClikaRT::Span<const ops::ScalarOrTensor> pad,
    ops::PadMode mode,
    std::optional<ops::ScalarOrTensor> value
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 442

rfft()

Tensor rfft(std::optional<std::int64_t> n_fft, bool normalized) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 444

stft()

Tensor stft(
    std::int64_t n_fft,
    std::optional<std::int64_t> hop_length,
    std::optional<std::int64_t> win_length,
    Tensor window,
    bool center,
    ops::PadMode pad_mode,
    bool normalized,
    bool onesided
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 446

resample()

Tensor resample(
    std::int64_t orig_freq,
    std::int64_t new_freq,
    std::int64_t lowpass_filter_width,
    double rolloff,
    std::optional<double> beta
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 448

constant_pad()

Tensor constant_pad(
    ClikaRT::Span<const ops::ScalarOrTensor> pad,
    std::optional<ops::ScalarOrTensor> value
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 450

reflect_pad()

Tensor reflect_pad(ClikaRT::Span<const ops::ScalarOrTensor> pad) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 452

replicate_pad()

Tensor replicate_pad(ClikaRT::Span<const ops::ScalarOrTensor> pad) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 454

circular_pad()

Tensor circular_pad(ClikaRT::Span<const ops::ScalarOrTensor> pad) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 456

permute()

Tensor permute(ClikaRT::Span<const std::int64_t> dims) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 458

transpose()

Tensor transpose(int64_t dim0, int64_t dim1) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 460

repeat()

Tensor repeat(ClikaRT::Span<const ops::ScalarOrTensor> sizes) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 462

tile()

Tensor tile(ClikaRT::Span<const ops::ScalarOrTensor> dims) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 464

repeat_interleave()

Tensor repeat_interleave(
    ops::ScalarOrTensor repeats,
    std::optional<int64_t> dim,
    std::optional<int64_t> output_size
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 466

reshape_as()

Tensor reshape_as(Tensor other) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 468

roll()

Tensor roll(
    ClikaRT::Span<const std::int64_t> shifts,
    ClikaRT::Span<const std::int64_t> dims
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 470

rot90()

Tensor rot90(int64_t k, ClikaRT::Span<const std::int64_t> dims) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 472

select()

Tensor select(int64_t dim, ops::IndexBound index) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 474

slice(int64_t, ops::IndexBound, ops::IndexBound, ops::IndexBound)

Tensor slice(
    int64_t dim,
    ops::IndexBound start,
    ops::IndexBound end,
    ops::IndexBound step
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 476

narrow()

Tensor narrow(
    int64_t dim,
    ops::IndexBound start,
    ops::IndexBound length
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 478

split_with_sizes()

std::vector<Tensor> split_with_sizes(
    ClikaRT::Span<const ops::ScalarOrTensor> sizes,
    int64_t dim
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 480

chunk()

std::vector<Tensor> chunk(int64_t num_chunks, int64_t dim) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 482

split_by_size()

std::vector<Tensor> split_by_size(int64_t chunk_size, int64_t dim) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 484

squeeze()

Tensor squeeze(ClikaRT::Span<const std::int64_t> dim) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 486

squeeze_()

Tensor& squeeze_(ClikaRT::Span<const std::int64_t> dim)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 488

tril()

Tensor tril(int64_t diagonal) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 490

tril_()

Tensor& tril_(int64_t diagonal)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 492

triu()

Tensor triu(int64_t diagonal) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 494

triu_()

Tensor& triu_(int64_t diagonal)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 496

unflatten()

Tensor unflatten(int64_t dim, ClikaRT::Span<const std::int64_t> sizes) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 498

unsqueeze()

Tensor unsqueeze(int64_t dim) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 500

unsqueeze_()

Tensor& unsqueeze_(int64_t dim)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 502

add_layer_norm()

std::array<Tensor 2> add_layer_norm(
    Tensor residual,
    Tensor post_residual,
    ClikaRT::Span<const std::int64_t> normalized_shape,
    Tensor skip_bias,
    Tensor weight,
    Tensor bias,
    std::optional<double> eps,
    std::optional<ops::Activation> activation
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 504

add_rms_norm()

std::array<Tensor 2> add_rms_norm(
    Tensor residual,
    Tensor residual2,
    Tensor post_residual,
    ClikaRT::Span<const std::int64_t> normalized_shape,
    Tensor skip_bias,
    Tensor weight,
    Tensor bias,
    std::optional<double> eps,
    std::optional<ops::Activation> activation
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 506

qk_rms_norm()

std::array<Tensor 3> qk_rms_norm(
    Tensor key,
    Tensor value,
    Tensor query_weight,
    Tensor key_weight,
    std::int64_t head_dim,
    std::optional<double> eps
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 508

qk_rms_norm_()

Tensor& qk_rms_norm_(
    Tensor key,
    Tensor value,
    Tensor query_weight,
    Tensor key_weight,
    std::int64_t head_dim,
    std::optional<double> eps
)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 510

qk_layer_norm()

std::array<Tensor 3> qk_layer_norm(
    Tensor key,
    Tensor value,
    Tensor query_weight,
    Tensor query_bias,
    Tensor key_weight,
    Tensor key_bias,
    std::int64_t head_dim,
    std::optional<double> eps
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 512

qk_layer_norm_()

Tensor& qk_layer_norm_(
    Tensor key,
    Tensor value,
    Tensor query_weight,
    Tensor query_bias,
    Tensor key_weight,
    Tensor key_bias,
    std::int64_t head_dim,
    std::optional<double> eps
)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 514

batch_norm()

Tensor batch_norm(
    Tensor weight,
    Tensor bias,
    Tensor running_mean,
    Tensor running_var,
    std::optional<double> eps,
    std::optional<ops::Activation> activation
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 516

group_norm()

Tensor group_norm(
    int64_t num_groups,
    Tensor weight,
    Tensor bias,
    Tensor running_mean,
    Tensor running_var,
    std::optional<double> eps,
    std::optional<ops::Activation> activation
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 518

instance_norm()

Tensor instance_norm(
    Tensor weight,
    Tensor bias,
    Tensor running_mean,
    Tensor running_var,
    std::optional<double> eps,
    std::optional<ops::Activation> activation
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 520

layer_norm()

Tensor layer_norm(
    ClikaRT::Span<const std::int64_t> normalized_shape,
    Tensor weight,
    Tensor bias,
    std::optional<double> eps,
    std::optional<ops::Activation> activation
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 522

rms_norm()

Tensor rms_norm(
    ClikaRT::Span<const std::int64_t> normalized_shape,
    Tensor weight,
    Tensor bias,
    std::optional<double> eps,
    std::optional<ops::Activation> activation
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 524

gated_rms_norm()

Tensor gated_rms_norm(
    Tensor gate,
    ClikaRT::Span<const std::int64_t> normalized_shape,
    Tensor weight,
    std::optional<double> eps
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 526

causal_conv_update()

Tensor causal_conv_update(
    Tensor weight,
    Tensor bias,
    Tensor state,
    Tensor seq_lens,
    Tensor slot_ids,
    std::optional<ops::Activation> activation
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 528

gated_delta_update()

Tensor gated_delta_update(
    Tensor key,
    Tensor value,
    Tensor beta,
    Tensor gate,
    Tensor state,
    Tensor seq_lens,
    Tensor slot_ids,
    std::optional<double> scale,
    Tensor gate_bias,
    Tensor gate_scale
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 530

ssd_update()

Tensor ssd_update(
    Tensor dt,
    Tensor a_rate,
    Tensor b_mat,
    Tensor c_mat,
    Tensor d_skip,
    Tensor dt_bias,
    Tensor gate,
    Tensor state,
    Tensor seq_lens,
    Tensor slot_ids,
    bool dt_softplus
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 532

mla_attention()

Tensor mla_attention(
    Tensor q_pe,
    Tensor new_ckv,
    Tensor new_kpe,
    Tensor ckv_cache,
    Tensor kpe_cache,
    Tensor kvcache_start,
    Tensor cu_seqlens_q,
    double scale,
    Tensor slot_ids
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 534

ms_deform_attention()

Tensor ms_deform_attention(
    Tensor spatial_shapes,
    Tensor level_start_index,
    Tensor sampling_locations,
    Tensor attention_weights
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 536

adaptive_avg_pool()

Tensor adaptive_avg_pool(ClikaRT::Span<const std::int64_t> output_size) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 538

adaptive_avg_pool1d()

Tensor adaptive_avg_pool1d(ClikaRT::Span<const std::int64_t> output_size) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 540

adaptive_avg_pool2d()

Tensor adaptive_avg_pool2d(ClikaRT::Span<const std::int64_t> output_size) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 542

adaptive_avg_pool3d()

Tensor adaptive_avg_pool3d(ClikaRT::Span<const std::int64_t> output_size) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 544

adaptive_max_pool()

Tensor adaptive_max_pool(ClikaRT::Span<const std::int64_t> output_size) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 546

adaptive_max_pool1d()

Tensor adaptive_max_pool1d(ClikaRT::Span<const std::int64_t> output_size) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 548

adaptive_max_pool2d()

Tensor adaptive_max_pool2d(ClikaRT::Span<const std::int64_t> output_size) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 550

adaptive_max_pool3d()

Tensor adaptive_max_pool3d(ClikaRT::Span<const std::int64_t> output_size) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 552

avg_pool()

Tensor avg_pool(
    ClikaRT::Span<const std::int64_t> kernel_size,
    ClikaRT::Span<const std::int64_t> stride,
    ClikaRT::Span<const std::int64_t> padding,
    bool ceil_mode,
    bool count_include_pad,
    std::optional<int64_t> divisor_override
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 554

avg_pool1d()

Tensor avg_pool1d(
    ClikaRT::Span<const std::int64_t> kernel_size,
    ClikaRT::Span<const std::int64_t> stride,
    ClikaRT::Span<const std::int64_t> padding,
    bool ceil_mode,
    bool count_include_pad
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 556

avg_pool2d()

Tensor avg_pool2d(
    ClikaRT::Span<const std::int64_t> kernel_size,
    ClikaRT::Span<const std::int64_t> stride,
    ClikaRT::Span<const std::int64_t> padding,
    bool ceil_mode,
    bool count_include_pad,
    std::optional<int64_t> divisor_override
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 558

avg_pool3d()

Tensor avg_pool3d(
    ClikaRT::Span<const std::int64_t> kernel_size,
    ClikaRT::Span<const std::int64_t> stride,
    ClikaRT::Span<const std::int64_t> padding,
    bool ceil_mode,
    bool count_include_pad,
    std::optional<int64_t> divisor_override
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 560

max_pool()

Tensor max_pool(
    ClikaRT::Span<const std::int64_t> kernel_size,
    ClikaRT::Span<const std::int64_t> stride,
    ClikaRT::Span<const std::int64_t> padding,
    ClikaRT::Span<const std::int64_t> dilation,
    bool ceil_mode
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 562

max_pool1d()

Tensor max_pool1d(
    ClikaRT::Span<const std::int64_t> kernel_size,
    ClikaRT::Span<const std::int64_t> stride,
    ClikaRT::Span<const std::int64_t> padding,
    ClikaRT::Span<const std::int64_t> dilation,
    bool ceil_mode
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 564

max_pool2d()

Tensor max_pool2d(
    ClikaRT::Span<const std::int64_t> kernel_size,
    ClikaRT::Span<const std::int64_t> stride,
    ClikaRT::Span<const std::int64_t> padding,
    ClikaRT::Span<const std::int64_t> dilation,
    bool ceil_mode
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 566

max_pool3d()

Tensor max_pool3d(
    ClikaRT::Span<const std::int64_t> kernel_size,
    ClikaRT::Span<const std::int64_t> stride,
    ClikaRT::Span<const std::int64_t> padding,
    ClikaRT::Span<const std::int64_t> dilation,
    bool ceil_mode
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 568

max_pool_with_indices()

std::array<Tensor 2> max_pool_with_indices(
    ClikaRT::Span<const std::int64_t> kernel_size,
    ClikaRT::Span<const std::int64_t> stride,
    ClikaRT::Span<const std::int64_t> padding,
    ClikaRT::Span<const std::int64_t> dilation,
    bool ceil_mode
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 570

max_pool1d_with_indices()

std::array<Tensor 2> max_pool1d_with_indices(
    ClikaRT::Span<const std::int64_t> kernel_size,
    ClikaRT::Span<const std::int64_t> stride,
    ClikaRT::Span<const std::int64_t> padding,
    ClikaRT::Span<const std::int64_t> dilation,
    bool ceil_mode
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 572

max_pool2d_with_indices()

std::array<Tensor 2> max_pool2d_with_indices(
    ClikaRT::Span<const std::int64_t> kernel_size,
    ClikaRT::Span<const std::int64_t> stride,
    ClikaRT::Span<const std::int64_t> padding,
    ClikaRT::Span<const std::int64_t> dilation,
    bool ceil_mode
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 574

max_pool3d_with_indices()

std::array<Tensor 2> max_pool3d_with_indices(
    ClikaRT::Span<const std::int64_t> kernel_size,
    ClikaRT::Span<const std::int64_t> stride,
    ClikaRT::Span<const std::int64_t> padding,
    ClikaRT::Span<const std::int64_t> dilation,
    bool ceil_mode
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 576

bernoulli()

Tensor bernoulli(StreamOrDevice device) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 578

bernoulli_()

Tensor& bernoulli_(StreamOrDevice device)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 580

exponential_()

Tensor& exponential_(double lambd, StreamOrDevice device)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 582

multinomial()

Tensor multinomial(
    int64_t num_samples,
    bool replacement,
    StreamOrDevice device
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 584

normal_()

Tensor& normal_(
    ops::ScalarOrTensor mean,
    ops::ScalarOrTensor stddev,
    StreamOrDevice device
)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 586

poisson()

Tensor poisson(StreamOrDevice device) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 588

rand_like()

Tensor rand_like(StreamOrDevice device) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 590

randint_like()

Tensor randint_like(
    int64_t low,
    int64_t high,
    StreamOrDevice device
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 592

randn_like()

Tensor randn_like(StreamOrDevice device) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 594

uniform_()

Tensor& uniform_(
    double low,
    double high,
    StreamOrDevice device
)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 596

random_()

Tensor& random_(
    std::optional<std::int64_t> low,
    std::optional<std::int64_t> high,
    StreamOrDevice device
)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 598

all()

Tensor all(ClikaRT::Span<const std::int64_t> dims, bool keepdim) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 600

amax()

Tensor amax(ClikaRT::Span<const std::int64_t> dims, bool keepdim) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 602

amin()

Tensor amin(ClikaRT::Span<const std::int64_t> dims, bool keepdim) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 604

aminmax()

std::array<Tensor 2> aminmax(std::optional<int64_t> dim, bool keepdim) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 606

any()

Tensor any(ClikaRT::Span<const std::int64_t> dims, bool keepdim) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 608

argmax()

Tensor argmax(
    ClikaRT::Span<const std::int64_t> dims,
    bool keepdim,
    DataType index_dtype
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 610

argmin()

Tensor argmin(
    ClikaRT::Span<const std::int64_t> dims,
    bool keepdim,
    DataType index_dtype
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 612

count_nonzero()

Tensor count_nonzero(ClikaRT::Span<const std::int64_t> dims) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 614

logsumexp()

Tensor logsumexp(ClikaRT::Span<const std::int64_t> dims, bool keepdim) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 616

median()

std::array<Tensor 2> median(std::optional<int64_t> dim, bool keepdim) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 618

nanmean()

Tensor nanmean(ClikaRT::Span<const std::int64_t> dims, bool keepdim) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 620

nanmedian()

std::array<Tensor 2> nanmedian(std::optional<int64_t> dim, bool keepdim) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 622

nansum()

Tensor nansum(ClikaRT::Span<const std::int64_t> dims, bool keepdim) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 624

hash_tensor()

Tensor hash_tensor(
    ClikaRT::Span<const std::int64_t> dims,
    bool keepdim,
    ops::HashTensorMode mode
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 626

hash_64()

Tensor hash_64(std::uint64_t seed) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 628

hash_128()

Tensor hash_128(std::uint64_t seed) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 630

hash_256()

Tensor hash_256(std::uint64_t seed) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 632

hash_chain()

Tensor hash_chain(Tensor parent, std::uint64_t seed) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 634

prod()

Tensor prod(
    ClikaRT::Span<const std::int64_t> dims,
    bool keepdim,
    DataType dtype
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 636

std()

Tensor std(
    ClikaRT::Span<const std::int64_t> dims,
    int64_t correction,
    bool keepdim
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 638

trace()

Tensor trace() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 640

var()

Tensor var(
    ClikaRT::Span<const std::int64_t> dims,
    int64_t correction,
    bool keepdim
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 642

grid_sample()

Tensor grid_sample(
    Tensor grid,
    ops::GridSampleMode mode,
    ops::GridSamplePaddingMode padding_mode,
    bool align_corners
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 644

pixel_shuffle()

Tensor pixel_shuffle(int64_t upscale_factor, ops::PixelShuffleMode mode) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 646

pixel_unshuffle()

Tensor pixel_unshuffle(int64_t downscale_factor, ops::PixelShuffleMode mode) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 648

cummax()

std::array<Tensor 2> cummax(int64_t dim) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 650

cummin()

std::array<Tensor 2> cummin(int64_t dim) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 652

cumprod()

Tensor cumprod(int64_t dim, DataType dtype) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 654

cumprod_()

Tensor& cumprod_(int64_t dim, DataType dtype)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 656

cumsum()

Tensor cumsum(int64_t dim, DataType dtype) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 658

cumsum_()

Tensor& cumsum_(int64_t dim, DataType dtype)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 660

bucketize()

Tensor bucketize(
    Tensor boundaries,
    bool out_int32,
    bool right
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 662

kthvalue()

std::array<Tensor 2> kthvalue(
    int64_t k,
    int64_t dim,
    bool keepdim
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 664

nanquantile()

Tensor nanquantile(
    ops::ScalarOrTensor q,
    std::optional<int64_t> dim,
    bool keepdim,
    ops::QuantileInterp interpolation
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 666

quantile()

Tensor quantile(
    ops::ScalarOrTensor q,
    std::optional<int64_t> dim,
    bool keepdim,
    ops::QuantileInterp interpolation
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 668

searchsorted()

Tensor searchsorted(
    Tensor values,
    bool out_int32,
    bool right,
    std::optional<bool> side,
    Tensor sorter
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 670

topk()

std::array<Tensor 2> topk(
    int64_t k,
    int64_t dim,
    bool largest,
    bool sorted
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 672

bincount()

Tensor bincount(Tensor weights, int64_t minlength) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 674

histogram()

std::array<Tensor 2> histogram(
    int64_t bins,
    Tensor range,
    Tensor weight,
    bool density
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 676

unique()

std::array<Tensor 3> unique(
    bool sorted,
    bool return_inverse,
    bool return_counts,
    std::optional<int64_t> dim
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 678

unique_consecutive()

std::array<Tensor 3> unique_consecutive(
    bool return_inverse,
    bool return_counts,
    std::optional<int64_t> dim
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 680

acos()

Tensor acos() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 682

acos_()

Tensor& acos_()

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 684

acosh()

Tensor acosh() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 686

acosh_()

Tensor& acosh_()

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 688

asin()

Tensor asin() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 690

asin_()

Tensor& asin_()

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 692

asinh()

Tensor asinh() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 694

asinh_()

Tensor& asinh_()

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 696

atan()

Tensor atan() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 698

atan_()

Tensor& atan_()

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 700

atanh()

Tensor atanh() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 702

atanh_()

Tensor& atanh_()

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 704

clamp_min()

Tensor clamp_min(ops::ScalarOrTensor min) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 706

clamp_min_()

Tensor& clamp_min_(ops::ScalarOrTensor min)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 708

clamp_max()

Tensor clamp_max(ops::ScalarOrTensor max) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 710

clamp_max_()

Tensor& clamp_max_(ops::ScalarOrTensor max)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 712

cosh()

Tensor cosh() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 714

cosh_()

Tensor& cosh_()

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 716

diff()

Tensor diff(
    int64_t n,
    int64_t dim,
    Tensor prepend,
    Tensor append
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 718

erf()

Tensor erf() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 720

erf_()

Tensor& erf_()

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 722

erfc()

Tensor erfc() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 724

erfc_()

Tensor& erfc_()

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 726

erfinv()

Tensor erfinv() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 728

erfinv_()

Tensor& erfinv_()

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 730

frac()

Tensor frac() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 732

frac_()

Tensor& frac_()

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 734

frexp()

std::array<Tensor 2> frexp() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 736

log10()

Tensor log10() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 738

log10_()

Tensor& log10_()

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 740

log1p()

Tensor log1p() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 742

log1p_()

Tensor& log1p_()

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 744

log2()

Tensor log2() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 746

log2_()

Tensor& log2_()

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 748

logit()

Tensor logit(std::optional<double> eps) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 750

logit_()

Tensor& logit_(std::optional<double> eps)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 752

nan_to_num()

Tensor nan_to_num(
    std::optional<double> nan,
    std::optional<double> posinf,
    std::optional<double> neginf
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 754

nan_to_num_()

Tensor& nan_to_num_(
    std::optional<double> nan,
    std::optional<double> posinf,
    std::optional<double> neginf
)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 756

sgn()

Tensor sgn() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 758

sgn_()

Tensor& sgn_()

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 760

sinc()

Tensor sinc() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 762

sinc_()

Tensor& sinc_()

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 764

sinh()

Tensor sinh() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 766

sinh_()

Tensor& sinh_()

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 768

tan()

Tensor tan() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 770

tan_()

Tensor& tan_()

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 772

softcap_logits()

Tensor softcap_logits(ops::ScalarOrTensor cap) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 774

softcap_logits_()

Tensor& softcap_logits_(ops::ScalarOrTensor cap)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 776

trunc()

Tensor trunc() const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 778

trunc_()

Tensor& trunc_()

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 780

slice(Span< int64_t>, Span< ops::IndexBound>, Span< ops::IndexBound>, Span< ops::IndexBound>)

Tensor slice(
    ClikaRT::Span<const std::int64_t> dim,
    ClikaRT::Span<const ops::IndexBound> start,
    ClikaRT::Span<const ops::IndexBound> end,
    ClikaRT::Span<const ops::IndexBound> step
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 782

interpolate()

Tensor interpolate(
    ClikaRT::Span<const ops::ScalarOrTensor> sizes,
    ClikaRT::Span<const ops::ScalarOrTensor> scale_factors,
    ops::InterpMode mode,
    std::optional<bool> align_corners,
    bool recompute_scale_factor,
    bool antialias
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 784

upsample_nearest1d()

Tensor upsample_nearest1d(
    ClikaRT::Span<const ops::ScalarOrTensor> sizes,
    ClikaRT::Span<const ops::ScalarOrTensor> scale_factors
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 786

upsample_nearest2d()

Tensor upsample_nearest2d(
    ClikaRT::Span<const ops::ScalarOrTensor> sizes,
    ClikaRT::Span<const ops::ScalarOrTensor> scale_factors
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 788

upsample_nearest3d()

Tensor upsample_nearest3d(
    ClikaRT::Span<const ops::ScalarOrTensor> sizes,
    ClikaRT::Span<const ops::ScalarOrTensor> scale_factors
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 790

upsample_linear1d()

Tensor upsample_linear1d(
    ClikaRT::Span<const ops::ScalarOrTensor> sizes,
    ClikaRT::Span<const ops::ScalarOrTensor> scale_factors,
    bool align_corners
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 792

upsample_bilinear2d()

Tensor upsample_bilinear2d(
    ClikaRT::Span<const ops::ScalarOrTensor> sizes,
    ClikaRT::Span<const ops::ScalarOrTensor> scale_factors,
    bool align_corners
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 794

upsample_trilinear3d()

Tensor upsample_trilinear3d(
    ClikaRT::Span<const ops::ScalarOrTensor> sizes,
    ClikaRT::Span<const ops::ScalarOrTensor> scale_factors,
    bool align_corners
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 796

upsample_bicubic2d()

Tensor upsample_bicubic2d(
    ClikaRT::Span<const ops::ScalarOrTensor> sizes,
    ClikaRT::Span<const ops::ScalarOrTensor> scale_factors,
    bool align_corners
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 798

argsort()

Tensor argsort(
    std::int64_t dim,
    bool descending,
    bool stable
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 800

sort()

std::array<Tensor 2> sort(
    std::int64_t dim,
    bool descending,
    bool stable
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 802

clamp()

Tensor clamp(
    std::optional<ops::ScalarOrTensor> min,
    std::optional<ops::ScalarOrTensor> max
) const

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 804

clamp_()

Tensor& clamp_(std::optional<ops::ScalarOrTensor> min, std::optional<ops::ScalarOrTensor> max)

Declared in ClikaRT/compute/detail/tensor_methods_decl.inc, line 806