Struct Tensor 

pub struct Tensor { /* private fields */ }

A symbolic tensor in a traced graph.

Lazy by construction. Despite the eager-looking operator syntax, a Tensor is a deferred handle: &a + &b, .relu(), .matmul(..) etc. only append IR nodes — no host or device buffers are allocated and nothing executes. The graph is compiled (fused + memory-planned) and run only when you force it with to_vec / realize (both require the eval feature). This is what lets the whole expression fuse instead of materializing every intermediate.

Zero-copy clone & slice. clone() just bumps a refcount on the shared graph handle — no data is duplicated. slice/narrow/reshape/select add a view node into the same graph (referencing the parent by id), so they move zero payload bytes either. Use shares_graph to observe storage sharing and storage_bytes to confirm no data was copied. (Combining two independently-constructed tensors is the one case that copies — the right operand’s nodes are merged in once; see the handle module.)

Implementations

impl Tensor

pub fn from_vec(data: impl Into<Vec<f32>>, shape: impl AsRef<[usize]>) -> Self

Constant tensor from row-major host data (F32). The product of shape must equal data.len().

pub fn zeros(shape: impl AsRef<[usize]>) -> Self

All-zeros constant of the given shape (F32).

pub fn ones(shape: impl AsRef<[usize]>) -> Self

All-ones constant of the given shape (F32).

pub fn full(shape: impl AsRef<[usize]>, value: f32) -> Self

Constant of the given shape filled with value (F32).

pub fn eye(n: usize) -> Self

n × n identity matrix (F32).

pub fn arange(end: i64) -> Self

1-D constant [0, 1, …, end) (F32).

pub fn arange_step(start: i64, end: i64, step: i64) -> Self

1-D constant [start, start+step, …) up to (excluding) end (F32).

pub fn from_f64(data: impl AsRef<[f64]>, shape: impl AsRef<[usize]>) -> Self

F64 (double-precision) constant from host data.

pub fn from_i64(data: impl AsRef<[i64]>, shape: impl AsRef<[usize]>) -> Self

I64 constant from host data (general N-D).

pub fn index_vec(data: impl AsRef<[i64]>) -> Self

1-D I64 index vector for gather / index_select.

pub fn rand(shape: impl AsRef<[usize]>, seed: u64) -> Self

Uniform random in [0, 1) (F32), reproducible from seed.

pub fn rand_range( shape: impl AsRef<[usize]>, seed: u64, lo: f32, hi: f32, ) -> Self

Uniform random in [lo, hi) (F32), reproducible from seed.

pub fn randn(shape: impl AsRef<[usize]>, seed: u64) -> Self

Standard-normal random (mean 0, std 1), reproducible from seed.

pub fn randn_std( shape: impl AsRef<[usize]>, seed: u64, mean: f32, std: f32, ) -> Self

Normal random with the given mean/std, reproducible from seed. Useful for weight init, e.g. randn_std(shape, seed, 0.0, (2.0/fan_in).sqrt()).

impl Tensor

pub fn to_ndarray(&self) -> ArrayD<f32>

Realize (compile + run) and return an owned ndarray::ArrayD<f32>.

impl Tensor

pub fn id(&self) -> NodeId

IR node id (mix with raw rlx_ir::Graph builders via NodeId).

pub fn shape(&self) -> Shape

pub fn dtype(&self) -> DType

pub fn rank(&self) -> usize

pub fn dims(&self) -> Vec<usize>

Static dimensions as a Vec<usize> (panics on a dynamic axis).

pub fn numel(&self) -> usize

Total number of elements (panics on a dynamic axis).

pub fn is_static_shape(&self) -> bool

True when every dimension is statically known.

pub fn shares_graph(&self, other: &Tensor) -> bool

True if self and other are backed by the same graph — i.e. one is a clone or a view (slice/reshape/narrow/…) of the other, sharing storage with zero copy. Tensors from independent constructors return false until they’re combined in an op.

pub fn storage_bytes(&self) -> usize

Total bytes of constant (payload) data physically held in the backing graph. Cloning and slicing do not increase this — they share storage and only add zero-payload view nodes. Combining tensors from different graphs copies the right-hand operand’s data in (once).

pub fn slice(&self, spec: SliceSpec) -> Self

View slice — lowers to narrow (no copy at IR level).

pub fn mm(&self, rhs: &Tensor) -> Self

Matrix multiply (@ in Python / JAX).

pub fn matmul(&self, rhs: &Tensor) -> Self

pub fn scaled_matmul( &self, rhs: &Tensor, fmt: ScaledFormat, layout: ScaleLayout, ) -> Self

Native low-precision GEMM (TN: self [m,k] · rhs [n,k]ᵀ → [m,n]). Both operands are dynamically quantized to the minifloat fmt + layout; rhs must be K-last ([n, k]). fmt may be any ScaledFormat, including a parameterized Custom — e.g. t.scaled_matmul(&w, ScaledFormat::custom(3, 0), ScaleLayout::mx()) runs the matmul in f4e3m0.

pub fn softmax(&self, axis: i32) -> Self

pub fn reshape(&self, new_shape: impl Into<Vec<i64>>) -> Self

pub fn transpose(&self, perm: impl Into<Vec<usize>>) -> Self

pub fn t(&self) -> Self

pub fn cast(&self, to: DType) -> Self

pub fn narrow(&self, axis: usize, start: usize, len: usize) -> Self

pub fn broadcast_to(&self, shape: impl Into<Vec<i64>>) -> Self

Broadcast (expand) to an explicit target shape — NumPy broadcast_to. A 1 axis stretches; sizes must otherwise match. Use -1-free static targets.

pub fn flatten(&self) -> Self

Flatten to a 1-D tensor (row-major).

pub fn unsqueeze(&self, axis: usize) -> Self

Insert a size-1 axis at axis (NumPy expand_dims / PyTorch unsqueeze).

pub fn squeeze(&self, axis: usize) -> Self

Remove the size-1 axis at axis (panics if it is not size 1).

pub fn squeeze_all(&self) -> Self

Remove every size-1 axis.

pub fn split(&self, axis: usize, sizes: &[usize]) -> Vec<Tensor>

Split axis into contiguous pieces of the given sizes (must sum to the axis length). NumPy split / PyTorch split_with_sizes.

pub fn chunk(&self, axis: usize, n: usize) -> Vec<Tensor>

Split axis into n near-equal chunks (first len % n get one extra).

pub fn tile(&self, axis: usize, reps: usize) -> Tensor

Repeat the whole tensor reps times along axis (NumPy tile on one axis): output axis length becomes len * reps.

pub fn flip(&self, axis: usize) -> Tensor

Reverse the order of elements along axis (NumPy flip).

pub fn roll(&self, axis: usize, shift: usize) -> Tensor

Cyclically shift elements along axis by shift (NumPy roll).

pub fn pad( &self, axis: usize, before: usize, after: usize, value: f32, ) -> Tensor

Pad axis with before/after entries of value (constant pad).

pub fn gather(&self, indices: &Tensor, axis: usize) -> Self

pub fn index_select(&self, axis: usize, indices: &Tensor) -> Self

Gather along axis by an index tensor — NumPy take / PyTorch index_select. Alias for gather.

pub fn select(&self, axis: usize, index: i64) -> Self

Pick a single position along axis, dropping that axis (NumPy a[…, i, …]). Negative index counts from the end.

pub fn stop_gradient(&self) -> Self

pub fn argmax(&self, axis: usize, keep_dim: bool) -> Self

Index of the maximum along axis (f32-encoded indices). Drops the axis unless keep_dim.

pub fn argmin(&self, axis: usize, keep_dim: bool) -> Self

Index of the minimum along axis (f32-encoded indices).

pub fn inv(&self) -> Self

Matrix inverse of a square 2-D tensor. Composite over DenseSolve (inv(A) = solve(A, I)), so it needs a BLAS-backed eval build (LAPACK) to run, not the default splat backend.

pub fn solve(&self, b: &Tensor) -> Self

Solve the linear system self @ x = b for x (LAPACK via DenseSolve; needs a BLAS eval build). x takes b’s shape.

pub fn cumsum(&self, axis: i32, exclusive: bool) -> Self

Cumulative sum along axis. exclusive shifts so output[0] = 0.

pub fn var(&self, axes: impl Into<Vec<usize>>, keep_dim: bool) -> Self

Population variance over axes: mean((x - mean(x))²).

pub fn std(&self, axes: impl Into<Vec<usize>>, keep_dim: bool) -> Self

Population standard deviation over axes.

pub fn norm(&self, axes: impl Into<Vec<usize>>, keep_dim: bool) -> Self

L2 (Frobenius) norm over axes: sqrt(sum(x²)).

pub fn logsumexp(&self, axis: usize, keep_dim: bool) -> Self

Numerically-stable log(sum(exp(x))) along axis (max + log(sum(exp(x - max)))).

pub fn fft(&self) -> Self

1-D FFT along the last axis (unnormalized; ifft(fft(x)) = N·x). Complex data uses the [..., 2N] block layout (real plane then imag plane) for F32/F64, or a C64 last axis. Output matches input shape.

pub fn ifft(&self) -> Self

Inverse 1-D FFT along the last axis (unnormalized — pairs with Self::fft up to the N factor).

pub fn fft_axis(&self, axis: usize, inverse: bool) -> Self

1-D FFT along an arbitrary axis (transpose → fft → transpose).

pub fn layer_norm(&self, gamma: &Tensor, beta: &Tensor, eps: f32) -> Self

pub fn rms_norm(&self, gamma: &Tensor, beta: &Tensor, eps: f32) -> Self

pub fn cross_entropy(&self, targets: &Tensor) -> Self

Fused softmax + cross-entropy against a dense (soft / one-hot) target distribution — the standard classifier / language-model loss, in one differentiable op (native CPU & Metal kernels; lowered to primitives on other backends). self are logits [N, C], targets a probability distribution [N, C] (one-hot, or label-smoothed). Returns the per-row loss [N]: loss[n] = logsumexp(logits[n]) − Σ_c targets[n,c]·logits[n,c]. Reduce it to a scalar training loss with mean_all — mean(cross_entropy(logits, targets)) in the rlx! DSL. Gradients flow to both self and targets.

pub fn softmax_cross_entropy_with_logits(&self, labels: &Tensor) -> Self

Fused softmax + cross-entropy with integer class labels — PyTorch cross_entropy(logits, labels, reduction="none"). self are logits [N, C], labels the f32-encoded class ids [N]. Returns the per-row loss [N]; reduce with mean_all for a scalar loss.

pub fn mean_all(&self) -> Self

Mean over every axis → a scalar (rank-0). The idiomatic loss reduction — mean(cross_entropy(logits, targets)) in the rlx! DSL, or loss.mean_all() in Rust. A rank-0 input is returned unchanged.

pub fn sum_all(&self) -> Self

Sum over every axis → a scalar (rank-0). A rank-0 input is returned unchanged.

pub fn conv2d( &self, weight: &Tensor, kernel_size: [usize; 2], stride: [usize; 2], padding: [usize; 2], dilation: [usize; 2], groups: usize, ) -> Self

pub fn attention( &self, k: &Tensor, v: &Tensor, num_heads: usize, head_dim: usize, mask_kind: MaskKind, ) -> Self

pub fn synth_matmul( &self, indices: &Tensor, codebook: &Tensor, entry_dim: u32, num_entries: u32, ) -> Self

On-chip codebook weight-synthesis matmul (Op::SynthMatMul): y = x·Wᵀ where the weight [n, k] is reconstructed inside the matmul from indices [n, k/entry_dim] (u8, fixed quantization structure) + codebook [num_entries, entry_dim] (f32, trained). x is [m, k], output [m, n]. The codebook is a tiny trainable param; the full weight is never stored — “functions not data”. Backs rlx-tiny.

pub fn synth_reconstruct(&self, codebook: &Tensor, entry_dim: u32) -> Self

Reconstruct the dense weight W [k,n] from self = indices [n, k/entry_dim]

• codebook [num_entries, entry_dim] (the same gather the SynthMatMul decompose uses, WITHOUT the matmul). Lets a model fold multi-stage VQ + LoRA into ONE effective weight (W_eff = Σ reconstruct + A·Bᵀ) so x·W_eff is a single GEMM — dense-speed forward AND a 2-GEMM backward (the multi-stage / LoRA gradients collapse to codebook scatters + rank-r products with no batch dim). For training/prefill (large m); decode keeps synth_matmul in-kernel.

pub fn spline_activation( &self, coeff: &Tensor, num_basis: u32, grid_min: f32, grid_max: f32, ) -> Self

KAN learnable per-channel spline activation (Op::SplineActivation): each channel c of the last axis gets its own univariate function, a Gaussian-RBF expansion Σ_g coeff[c,g]·exp(-((x−center_g)·inv_h)²). coeff is [C, num_basis] (trained); output matches self. A learnable activation replacing a fixed GELU/ReLU. Backs rlx-tiny.

pub fn linear(&self, w: &Tensor, b: &Tensor) -> Self

HuggingFace-style linear x · Wᵀ + b where w is stored [out, in], as a single fused matmul+bias node (Op::FusedMatMulBiasAct). The weight transpose is emitted in-graph so callers bind the raw [out, in] checkpoint tensor directly (no host pre-transpose). Backs the rlx! linear(x, w, b) / x @t w sugar.

pub fn linear_act( &self, w: &Tensor, b: &Tensor, act: Option<Activation>, ) -> Self

linear with a fused elementwise activation applied to the result — act(x · Wᵀ + b) in one op. Backs gelu(linear(..)) etc.

pub fn matmul_t(&self, rhs: &Tensor) -> Self

Matrix multiply against a transposed right operand: self · rhsᵀ (x @t w in the DSL). Avoids a separate .t() at call sites; the transpose is emitted in-graph.

pub fn attention_masked( &self, k: &Tensor, v: &Tensor, mask: &Tensor, num_heads: usize, head_dim: usize, ) -> Self

Scaled dot-product attention with an explicit [batch, key_len] padding mask (1.0 = valid, <0.5 = ignored) — the 4-input MaskKind::Custom form that attention (kernel-synthesized masks) can’t express. Backs the rlx! attention(q, k, v, mask, heads, head_dim) sugar.

pub fn rope(&self, cos: &Tensor, sin: &Tensor, head_dim: usize) -> Self

pub fn where_<'t, 'f>( &self, on_true: impl Into<BinaryRhs<'t>>, on_false: impl Into<BinaryRhs<'f>>, ) -> Self

Select on_true where self (a mask) is true, else on_false. Each branch is a &Tensor or a scalar (mask.where_(&x, 0.0)), so the rlx! DSL’s select(mask, x, 0.0) lowers here directly. A scalar branch is promoted to the other branch’s dtype (else F32).

pub fn masked_fill(&self, mask: &Tensor, value: f64) -> Self

Replace entries of self where mask is true with value (NumPy masked_fill / the attention-mask primitive: scores.masked_fill(causal, f32::NEG_INFINITY) then softmax). Requires a static shape.

pub fn maximum<'r>(&self, rhs: impl Into<BinaryRhs<'r>>) -> Self

Elementwise maximum (accepts a &Tensor or a scalar).

pub fn minimum<'r>(&self, rhs: impl Into<BinaryRhs<'r>>) -> Self

Elementwise minimum (accepts a &Tensor or a scalar).

pub fn atan2<'r>(&self, rhs: impl Into<BinaryRhs<'r>>) -> Self

Elementwise atan2(self, rhs) — quadrant-aware arctangent.

pub fn rem<'r>(&self, rhs: impl Into<BinaryRhs<'r>>) -> Self

Elementwise self % rhs (C fmod; accepts a &Tensor or a scalar).

pub fn clamp(&self, min: f64, max: f64) -> Self

Clamp values to [min, max].

pub fn clamp_min(&self, min: f64) -> Self

Lower-bound values at min.

pub fn clamp_max(&self, max: f64) -> Self

Upper-bound values at max.

pub fn pow<'r>(&self, rhs: impl Into<BinaryRhs<'r>>) -> Self

Elementwise power self ^ rhs (accepts a &Tensor or a scalar).

pub fn pow_scalar(&self, exp: f64) -> Self

impl Tensor

pub fn relu(&self) -> Self

Rectified linear unit max(x, 0).

pub fn gelu(&self) -> Self

Gaussian error linear unit (exact).

pub fn gelu_approx(&self) -> Self

GELU, tanh approximation.

pub fn silu(&self) -> Self

Sigmoid-weighted linear unit x · σ(x) (a.k.a. SwiGLU gate).

pub fn tanh(&self) -> Self

Hyperbolic tangent.

pub fn exp(&self) -> Self

Natural exponential e^x.

pub fn sqrt(&self) -> Self

Square root.

pub fn sigmoid(&self) -> Self

Logistic sigmoid 1 / (1 + e^-x).

pub fn log(&self) -> Self

Natural logarithm.

pub fn rsqrt(&self) -> Self

Reciprocal square root 1 / sqrt(x).

pub fn abs(&self) -> Self

Absolute value.

pub fn sin(&self) -> Self

Sine.

pub fn cos(&self) -> Self

Cosine.

pub fn tan(&self) -> Self

Tangent.

pub fn atan(&self) -> Self

Arctangent.

pub fn round(&self) -> Self

Round to nearest (half-to-even); straight-through gradient.

pub fn recip(&self) -> Self

Reciprocal 1 / x.

pub fn floor(&self) -> Self

floor(x) (piecewise-constant gradient).

pub fn ceil(&self) -> Self

ceil(x).

pub fn sign(&self) -> Self

sign(x) = -1/0/+1.

pub fn softplus(&self) -> Self

Softplus ln(1 + eˣ).

pub fn elu(&self) -> Self

ELU (α=1): x if x>0 else eˣ-1.

pub fn erf(&self) -> Self

Gauss error function erf(x).

pub fn hard_swish(&self) -> Self

HardSwish x·clamp(x+3,0,6)/6.

pub fn hard_sigmoid(&self) -> Self

HardSigmoid clamp(x/6+0.5,0,1).

pub fn mish(&self) -> Self

Mish x·tanh(softplus(x)).

pub fn softsign(&self) -> Self

Softsign x/(1+|x|).

pub fn log_sigmoid(&self) -> Self

LogSigmoid log(σ(x)).

impl Tensor

pub fn eq<'r>(&self, rhs: impl Into<BinaryRhs<'r>>) -> Self

Elementwise ==.

pub fn ne<'r>(&self, rhs: impl Into<BinaryRhs<'r>>) -> Self

Elementwise !=.

pub fn lt<'r>(&self, rhs: impl Into<BinaryRhs<'r>>) -> Self

Elementwise <.

pub fn le<'r>(&self, rhs: impl Into<BinaryRhs<'r>>) -> Self

Elementwise <=.

pub fn gt<'r>(&self, rhs: impl Into<BinaryRhs<'r>>) -> Self

Elementwise >.

pub fn ge<'r>(&self, rhs: impl Into<BinaryRhs<'r>>) -> Self

Elementwise >=.

impl Tensor

pub fn sum(&self, axes: impl Into<Vec<usize>>, keep_dim: bool) -> Self

Sum over axes.

pub fn mean(&self, axes: impl Into<Vec<usize>>, keep_dim: bool) -> Self

Mean over axes.

pub fn max(&self, axes: impl Into<Vec<usize>>, keep_dim: bool) -> Self

Maximum over axes.

pub fn min(&self, axes: impl Into<Vec<usize>>, keep_dim: bool) -> Self

Minimum over axes.

pub fn prod(&self, axes: impl Into<Vec<usize>>, keep_dim: bool) -> Self

Product over axes.

impl Tensor

Materialization — compile this tensor’s graph through rlx_runtime and read the result back to host memory. The graph stays lazy until one of these is called, so the compiler fuses and memory-plans the whole expression first. Available with the eval feature.

pub fn to_vec(&self) -> Vec<f32>

Compile + run and copy the output to a Vec<f32>. The device is chosen automatically — the fastest backend compiled into this build that can run the graph (CPU when nothing faster is available).

pub fn to_vec_on(&self, device: Device) -> Vec<f32>

Compile + run on an explicit device.

pub fn realize(&self) -> Vec<f32>

Force evaluation — alias for to_vec. Building a Tensor allocates nothing and runs nothing; it only records IR. realize is the single point where the accumulated graph is compiled (fused + memory-planned) and executed. Use it to make the lazy model explicit at call sites.

pub fn realize_on(&self, device: Device) -> Vec<f32>

realize on an explicit device.

pub fn item(&self) -> f32

Realize a scalar (rank-0 or single-element) tensor to one f32.

pub fn to_vec_f64(&self) -> Vec<f64>

Realize and read back as f64 (tensor dtype must be F64).

pub fn to_vec_i64(&self) -> Vec<i64>

Realize and read back as i64 (tensor dtype must be I64).

pub fn to_vec_i32(&self) -> Vec<i32>

Realize and read back as i32 (tensor dtype must be I32).

pub fn to_vec_bool(&self) -> Vec<bool>

Realize and read back a Bool tensor. Robust to the backend storing bools 1-byte or f32-encoded (an element is true iff any of its bytes is non-zero).

pub fn show(&self) -> String

Realize and pretty-print with shape + dtype, NumPy/ndarray-style nesting. println!("{}", t) does the same (with the eval feature).

pub fn on(&self, device: Device) -> Materialize<'_>

Select a device fluently: t.on(Device::Metal).to_vec().

impl Tensor

Reverse-mode autodiff. Available with the grad feature; pair with eval to read the resulting gradient values.

pub fn grad(&self, wrt: &[&Tensor]) -> Vec<Tensor>

Gradients of this tensor (treated as the loss) w.r.t. each wrt, returned as symbolic Tensors in the same order as wrt.

The seed ∂self/∂self = 1 is baked in as a constant (ones, matching self’s shape — so a non-scalar self differentiates sum(self)), making each returned gradient a self-contained graph you can to_vec() or compose further.

let loss = (&a * &b).sum([0], false);
let g = loss.grad(&[&a, &b]);   // [∂/∂a, ∂/∂b]
assert_eq!(g[0].to_vec(), b.to_vec());

Trait Implementations

impl Add for Tensor

type Output = Tensor

The resulting type after applying the + operator.

fn add(self, rhs: Tensor) -> Tensor

Performs the + operation.

impl Add<&Tensor> for &Tensor

type Output = Tensor

The resulting type after applying the + operator.

fn add(self, rhs: &Tensor) -> Tensor

Performs the + operation.

impl Add<&Tensor> for Tensor

type Output = Tensor

The resulting type after applying the + operator.

fn add(self, rhs: &Tensor) -> Tensor

Performs the + operation.

impl Add<&Tensor> for f64

type Output = Tensor

The resulting type after applying the + operator.

fn add(self, rhs: &Tensor) -> Tensor

Performs the + operation.

impl Add<&Tensor> for f32

type Output = Tensor

The resulting type after applying the + operator.

fn add(self, rhs: &Tensor) -> Tensor

Performs the + operation.

impl Add<&Tensor> for i32

type Output = Tensor

The resulting type after applying the + operator.

fn add(self, rhs: &Tensor) -> Tensor

Performs the + operation.

impl Add<Tensor> for &Tensor

type Output = Tensor

The resulting type after applying the + operator.

fn add(self, rhs: Tensor) -> Tensor

Performs the + operation.

impl Add<f32> for &Tensor

type Output = Tensor

The resulting type after applying the + operator.

fn add(self, rhs: f32) -> Tensor

Performs the + operation.

impl Add<f32> for Tensor

type Output = Tensor

The resulting type after applying the + operator.

fn add(self, rhs: f32) -> Tensor

Performs the + operation.

impl Add<f64> for &Tensor

type Output = Tensor

The resulting type after applying the + operator.

fn add(self, rhs: f64) -> Tensor

Performs the + operation.

impl Add<f64> for Tensor

type Output = Tensor

The resulting type after applying the + operator.

fn add(self, rhs: f64) -> Tensor

Performs the + operation.

impl Add<i32> for &Tensor

type Output = Tensor

The resulting type after applying the + operator.

fn add(self, rhs: i32) -> Tensor

Performs the + operation.

impl Add<i32> for Tensor

type Output = Tensor

The resulting type after applying the + operator.

fn add(self, rhs: i32) -> Tensor

Performs the + operation.

impl Clone for Tensor

fn clone(&self) -> Tensor

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Tensor

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for Tensor

Available on crate feature eval only.

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Realizes the tensor (compile + run) and prints values — the lazy graph is forced here, like ndarray’s eager Display.

impl Div for Tensor

type Output = Tensor

The resulting type after applying the / operator.

fn div(self, rhs: Tensor) -> Tensor

Performs the / operation.

impl Div<&Tensor> for &Tensor

type Output = Tensor

The resulting type after applying the / operator.

fn div(self, rhs: &Tensor) -> Tensor

Performs the / operation.

impl Div<&Tensor> for Tensor

type Output = Tensor

The resulting type after applying the / operator.

fn div(self, rhs: &Tensor) -> Tensor

Performs the / operation.

impl Div<&Tensor> for f64

type Output = Tensor

The resulting type after applying the / operator.

fn div(self, rhs: &Tensor) -> Tensor

Performs the / operation.

impl Div<&Tensor> for f32

type Output = Tensor

The resulting type after applying the / operator.

fn div(self, rhs: &Tensor) -> Tensor

Performs the / operation.

impl Div<&Tensor> for i32

type Output = Tensor

The resulting type after applying the / operator.

fn div(self, rhs: &Tensor) -> Tensor

Performs the / operation.

impl Div<Tensor> for &Tensor

type Output = Tensor

The resulting type after applying the / operator.

fn div(self, rhs: Tensor) -> Tensor

Performs the / operation.

impl Div<f32> for &Tensor

type Output = Tensor

The resulting type after applying the / operator.

fn div(self, rhs: f32) -> Tensor

Performs the / operation.

impl Div<f32> for Tensor

type Output = Tensor

The resulting type after applying the / operator.

fn div(self, rhs: f32) -> Tensor

Performs the / operation.

impl Div<f64> for &Tensor

type Output = Tensor

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> Tensor

Performs the / operation.

impl Div<f64> for Tensor

type Output = Tensor

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> Tensor

Performs the / operation.

impl Div<i32> for &Tensor

type Output = Tensor

The resulting type after applying the / operator.

fn div(self, rhs: i32) -> Tensor

Performs the / operation.

impl Div<i32> for Tensor

type Output = Tensor

The resulting type after applying the / operator.

fn div(self, rhs: i32) -> Tensor

Performs the / operation.

impl<D: Dimension> From<&ArrayBase<OwnedRepr<f32>, D>> for Tensor

fn from(a: &Array<f32, D>) -> Self

Converts to this type from the input type.

impl From<&Tensor> for NodeId

fn from(v: &Tensor) -> Self

Converts to this type from the input type.

impl<D: Dimension> From<ArrayBase<OwnedRepr<f32>, D>> for Tensor

fn from(a: Array<f32, D>) -> Self

Converts to this type from the input type.

impl From<Tensor> for NodeId

fn from(v: Tensor) -> Self

Converts to this type from the input type.

impl Mul for Tensor

type Output = Tensor

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor) -> Tensor

Performs the * operation.

impl Mul<&Tensor> for &Tensor

type Output = Tensor

The resulting type after applying the * operator.

fn mul(self, rhs: &Tensor) -> Tensor

Performs the * operation.

impl Mul<&Tensor> for Tensor

type Output = Tensor

The resulting type after applying the * operator.

fn mul(self, rhs: &Tensor) -> Tensor

Performs the * operation.

impl Mul<&Tensor> for f64

type Output = Tensor

The resulting type after applying the * operator.

fn mul(self, rhs: &Tensor) -> Tensor

Performs the * operation.

impl Mul<&Tensor> for f32

type Output = Tensor

The resulting type after applying the * operator.

fn mul(self, rhs: &Tensor) -> Tensor

Performs the * operation.

impl Mul<&Tensor> for i32

type Output = Tensor

The resulting type after applying the * operator.

fn mul(self, rhs: &Tensor) -> Tensor

Performs the * operation.

impl Mul<Tensor> for &Tensor

type Output = Tensor

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor) -> Tensor

Performs the * operation.

impl Mul<f32> for &Tensor

type Output = Tensor

The resulting type after applying the * operator.

fn mul(self, rhs: f32) -> Tensor

Performs the * operation.

impl Mul<f32> for Tensor

type Output = Tensor

The resulting type after applying the * operator.

fn mul(self, rhs: f32) -> Tensor

Performs the * operation.

impl Mul<f64> for &Tensor

type Output = Tensor

The resulting type after applying the * operator.

fn mul(self, rhs: f64) -> Tensor

Performs the * operation.

impl Mul<f64> for Tensor

type Output = Tensor

The resulting type after applying the * operator.

fn mul(self, rhs: f64) -> Tensor

Performs the * operation.

impl Mul<i32> for &Tensor

type Output = Tensor

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> Tensor

Performs the * operation.

impl Mul<i32> for Tensor

type Output = Tensor

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> Tensor

Performs the * operation.

impl Neg for &Tensor

type Output = Tensor

The resulting type after applying the - operator.

fn neg(self) -> Tensor

Performs the unary - operation.

impl Neg for Tensor

type Output = Tensor

The resulting type after applying the - operator.

fn neg(self) -> Tensor

Performs the unary - operation.

impl Sub for Tensor

type Output = Tensor

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor) -> Tensor

Performs the - operation.

impl Sub<&Tensor> for &Tensor

type Output = Tensor

The resulting type after applying the - operator.

fn sub(self, rhs: &Tensor) -> Tensor

Performs the - operation.

impl Sub<&Tensor> for Tensor

type Output = Tensor

The resulting type after applying the - operator.

fn sub(self, rhs: &Tensor) -> Tensor

Performs the - operation.

impl Sub<&Tensor> for f64

type Output = Tensor

The resulting type after applying the - operator.

fn sub(self, rhs: &Tensor) -> Tensor

Performs the - operation.

impl Sub<&Tensor> for f32

type Output = Tensor

The resulting type after applying the - operator.

fn sub(self, rhs: &Tensor) -> Tensor

Performs the - operation.

impl Sub<&Tensor> for i32

type Output = Tensor

The resulting type after applying the - operator.

fn sub(self, rhs: &Tensor) -> Tensor

Performs the - operation.

impl Sub<Tensor> for &Tensor

type Output = Tensor

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor) -> Tensor

Performs the - operation.

impl Sub<f32> for &Tensor

type Output = Tensor

The resulting type after applying the - operator.

fn sub(self, rhs: f32) -> Tensor

Performs the - operation.

impl Sub<f32> for Tensor

type Output = Tensor

The resulting type after applying the - operator.

fn sub(self, rhs: f32) -> Tensor

Performs the - operation.

impl Sub<f64> for &Tensor

type Output = Tensor

The resulting type after applying the - operator.

fn sub(self, rhs: f64) -> Tensor

Performs the - operation.

impl Sub<f64> for Tensor

type Output = Tensor

The resulting type after applying the - operator.

fn sub(self, rhs: f64) -> Tensor

Performs the - operation.

impl Sub<i32> for &Tensor

type Output = Tensor

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> Tensor

Performs the - operation.

impl Sub<i32> for Tensor

type Output = Tensor

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> Tensor

Performs the - operation.