Struct CachedTensorPromise 

pub struct CachedTensorPromise<T, B: Backend = DefaultBackend> { /* private fields */ }

A lazy computation whose result is kept alive after the first evaluation.

Once .materialize() has been called (directly or through a derived promise), the result is cached. Every subsequent call returns the stored value without re-running the graph.

Use this when the same promise feeds into multiple independent downstream graphs that materialise at different times. You pay the memory cost of keeping the tensor alive, which is why caching is opt-in.

Examples

use candela::Tensor;

let t = Tensor::from_scalar(1.0_f64, &[4]);
let cached = (t + 2.0).cache();

// Two separate materializations - the inner graph runs only once.
let r1 = (&cached * 2.0).materialize();
let r2 = (&cached + 10.0).materialize();
assert_eq!(r1.data(), &vec![6.0; 4]);
assert_eq!(r2.data(), &vec![13.0; 4]);

Implementations

impl<T, B> CachedTensorPromise<T, B>

where T: Numeric, B: Backend,

pub fn view( &self, shape: &[usize], ) -> Result<<CachedTensorPromise<T, B> as UnaryResult<T, B>>::Output, OpError>

Reinterprets the tensor’s data as having shape shape without allocating.

The tensor must be contiguous and must have the same length as the original tensor. Use .reshape() if the tensor may not be contiguous.

Examples

use candela::{Tensor, Dimension};

let t = Tensor::from_slice(&[4.0, 3.0, 2.0, 1.0], &[4]);
// Shares the same underlying data as t
let v = t.view(&[2, 2]).unwrap().materialize();

assert_eq!(v.shape(), &[2, 2]);

Errors

Returns OpError::NonContiguousView if the tensor is not contiguous or OpError::InvalidViewShape if the shape is invalid.

pub fn reshape( &self, shape: &[usize], ) -> Result<<CachedTensorPromise<T, B> as UnaryResult<T, B>>::Output, OpError>

Reinterprets the tensor’s data as having shape shape, allocating if the tensor is not contiguous.

Unlike .view(), this never fails on a non-contiguous tensor — it only requires that the new shape has the same total number of elements as the original.

Examples

use candela::{Tensor, Dimension};

let t = Tensor::from_slice(&[1.0, 2.0, 3.0, 4.0], &[2, 2]);
let r = t.transpose().reshape(&[4]).unwrap().materialize();

assert_eq!(r.shape(), &[4]);
// r is contiguous as it was allocated in a new buffer.
assert!(r.is_contiguous());

Errors

Returns OpError::InvalidViewShape if shape does not have the same total number of elements as the original.

impl<T, B> CachedTensorPromise<T, B>

where T: Numeric, B: Backend,

pub fn slice( &self, shape: &[SliceRange], ) -> Result<<CachedTensorPromise<T, B> as UnaryResult<T, B>>::Output, OpError>

Selects a rectangular subregion of the tensor, without allocating.

Each SliceRange picks a range along one axis, applied from the outermost axis inward; axes you leave out are kept whole. Build the ranges with the s! macro using ordinary range syntax — negative bounds count from the end. The result is a view into the original buffer.

Examples

use candela::{Tensor, Dimension, s};

let t = Tensor::from_slice(&[0.0, 1.0, 2.0, 3.0, 4.0, 5.0], &[2, 3]);
let sub = t.slice(s![1..2, 0..2]).unwrap().materialize(); // row 1, cols 0..2

assert_eq!(sub.shape(), &[1, 2]);

Errors

Returns OpError::AxesOutOfBounds if more ranges are given than the tensor has axes, or OpError::SliceOutOfBounds if a range is empty.

impl<T, B> CachedTensorPromise<T, B>

where T: Numeric, B: Backend,

pub fn transpose( &self, ) -> <CachedTensorPromise<T, B> as UnaryResult<T, B>>::Output

Reverses the order of every axis, without allocating.

For a 2-D tensor this is the familiar matrix transpose; for higher ranks it flips all axes at once (axis i becomes axis rank - 1 - i). Only the layout changes — the data stays put until something forces a copy, so reach for .as_contiguous() when you need the transposed values in their own buffer. For an arbitrary permutation, see .transpose_axes().

Examples

use candela::{Tensor, Dimension};

let t = Tensor::from_slice(&[1.0, 2.0, 3.0, 4.0, 5.0, 6.0], &[2, 3]);
let tt = t.transpose().materialize();

assert_eq!(tt.shape(), &[3, 2]);

impl<T, B> CachedTensorPromise<T, B>

where T: Numeric, B: Backend,

pub fn transpose_axes( &self, axes: &[usize], ) -> Result<<CachedTensorPromise<T, B> as UnaryResult<T, B>>::Output, OpError>

Reorders the axes by an explicit permutation, without allocating.

axes must list every axis index exactly once: transpose_axes(&[1, 0]) is the plain 2-D .transpose(), while &[0, 2, 1] swaps only the last two axes of a rank-3 tensor and leaves the first alone. Like .transpose() it only relabels the layout — see .as_contiguous() to materialize the reordered values.

Examples

use candela::{Tensor, Dimension};

let t = Tensor::from_slice(&[0.0, 1.0, 2.0, 3.0, 4.0, 5.0], &[1, 2, 3]);
let s = t.transpose_axes(&[0, 2, 1]).unwrap().materialize();

assert_eq!(s.shape(), &[1, 3, 2]);

Errors

Returns OpError::NotEnoughAxes if axes doesn’t have one entry per axis, or OpError::AxesOutOfBounds if an index is out of range or repeated (so the list isn’t a valid permutation).

impl<T, B> CachedTensorPromise<T, B>

where T: Numeric, B: Backend,

pub fn as_contiguous( &self, ) -> <CachedTensorPromise<T, B> as UnaryResult<T, B>>::Output

Packs the tensor into a fresh contiguous buffer in row-major order.

Layout-only ops like .transpose() and .slice() leave the data where it is and only change how it’s addressed. as_contiguous turns such a view back into a densely laid-out tensor. If the input is already contiguous it costs nothing — the call collapses to a no-op. Candela also inserts it automatically wherever an op needs contiguous memory (a BLAS matmul, a .reshape()), so you rarely call it by hand.

Examples

use candela::{Tensor, Dimension};

let t = Tensor::from_slice(&[1.0, 2.0, 3.0, 4.0], &[2, 2]);
// transpose is a view; as_contiguous lays the transposed values out for real.
let c = t.transpose().as_contiguous().materialize();

assert!(c.is_contiguous());
assert_eq!(c.data(), &[1.0, 3.0, 2.0, 4.0]);

impl<T, B> CachedTensorPromise<T, B>

where T: Numeric, B: Backend,

pub fn broadcast( &self, shape: &[usize], ) -> Result<<CachedTensorPromise<T, B> as UnaryResult<T, B>>::Output, OpError>

Expands the tensor to a larger shape by repeating elements along new or size-1 axes, without allocating.

Broadcasting follows NumPy’s right-aligned rules: a target axis must either match the source or expand from size 1, and extra leading axes are added on the left. No data is copied — the repeated axes are faked with zero strides. The arithmetic operators broadcast on their own, so you mostly need this only to force a specific shape up front.

Examples

use candela::{Tensor, Dimension};

let row = Tensor::from_slice(&[1.0, 2.0, 3.0], &[1, 3]);
let b = row.broadcast(&[2, 3]).unwrap().materialize();

assert_eq!(b.shape(), &[2, 3]);

Errors

Returns OpError::CannotBroadcast if the target shape has fewer axes than the source, or an axis is neither equal to the source nor expandable from 1.

impl<T, B> CachedTensorPromise<T, B>

where T: FloatLike, B: Backend,

pub fn exp(&self) -> <CachedTensorPromise<T, B> as UnaryResult<T, B>>::Output

Computes e^x for each element.

Examples

use candela::Tensor;

let t = Tensor::from_slice(&[0.0_f64], &[1]);
assert_eq!(t.exp().materialize().data(), &[1.0]); // e^0 == 1

impl<T, B> CachedTensorPromise<T, B>

where T: FloatLike, B: Backend,

pub fn ln(&self) -> <CachedTensorPromise<T, B> as UnaryResult<T, B>>::Output

Computes the natural logarithm of each element.

Elements <= 0 follow the platform ln behavior: -inf at zero, NaN below.

Examples

use candela::Tensor;

let t = Tensor::from_slice(&[1.0_f64], &[1]);
assert_eq!(t.ln().materialize().data(), &[0.0]); // ln(1) == 0

impl<T, B> CachedTensorPromise<T, B>

where T: FloatLike, B: Backend,

pub fn log2(&self) -> <CachedTensorPromise<T, B> as UnaryResult<T, B>>::Output

Computes the base-2 logarithm of each element.

Elements <= 0 follow the platform log2 behavior: -inf at zero, NaN below.

Examples

use candela::Tensor;

let t = Tensor::from_slice(&[8.0_f64], &[1]);
assert_eq!(t.log2().materialize().data(), &[3.0]); // log2(8) == 3

impl<T, B> CachedTensorPromise<T, B>

where T: FloatLike, B: Backend,

pub fn relu(&self) -> <CachedTensorPromise<T, B> as UnaryResult<T, B>>::Output

Applies the rectified linear unit (relu): max(x, 0.0) for each element.

Examples

use candela::Tensor;

// Negative values clamp to zero; non-negative values pass through.
let t = Tensor::from_slice(&[-2.0_f64, -0.5, 0.0, 1.5], &[4]);
assert_eq!(t.relu().materialize().data(), &[0.0, 0.0, 0.0, 1.5]);

impl<T, B> CachedTensorPromise<T, B>

where T: FloatLike, B: Backend,

pub fn tanh(&self) -> <CachedTensorPromise<T, B> as UnaryResult<T, B>>::Output

Applies the hyperbolic tangent to each element, mapping values into (-1, 1).

Examples

use candela::Tensor;

let t = Tensor::from_scalar(0.0_f64, &[1]);
assert_eq!(*t.tanh().materialize().item(), 0.0); // tanh(0) == 0

impl<T, B> CachedTensorPromise<T, B>

where T: CanMatMul, B: Backend,

pub fn matmul<D>( &self, rhs: &D, ) -> Result<<CachedTensorPromise<T, B> as BinaryResult<D, T, B>>::Output, OpError>

where D: Operand<T, B>, CachedTensorPromise<T, B>: BinaryResult<D, T, B>,

Matrix-multiplies, following NumPy’s matmul conventions.

For two 2-D tensors, it’s as one would expect: [m, k] @ [k, n] gives [m, n], and the inner dimension k of both must agree.

Higher ranks (3-D, 4-D, and so on) are treated as batches of 2-D matrices, broadcasting the leading axes where needed. So [b, m, k] @ [k, n] gives [b, m, n], because it’s the same as doing [b, m, k] @ [b, k, n].

A 1-D operand is promoted to 2-D for the operation, then the added axis is dropped from the result:

• [k] @ [k] contracts to a one-element tensor (a dot product).
• [k] @ [.., k, n] gives [.., n] (vector times matrix).
• [.., m, k] @ [k] gives [.., m] (matrix times vector).

Examples

use candela::{Tensor, Dimension};

let a = Tensor::from_slice(&[1.0, 2.0, 3.0, 4.0, 5.0, 6.0], &[2, 3]);
let b = Tensor::from_slice(&[1.0, 0.0, 0.0, 1.0, 1.0, 0.0], &[3, 2]);
let c = a.matmul(&b).unwrap().materialize();

assert_eq!(c.shape(), &[2, 2]);
assert_eq!(c.data(), &[4.0, 2.0, 10.0, 5.0]);

A 1-D right-hand side contracts the last axis away:

use candela::{Tensor, Dimension};

let m = Tensor::from_slice(&[1.0, 2.0, 3.0, 4.0], &[2, 2]);
let v = Tensor::from_slice(&[1.0, 1.0], &[2]);
let r = m.matmul(&v).unwrap().materialize();

assert_eq!(r.shape(), &[2]);
assert_eq!(r.data(), &[3.0, 7.0]);

Errors

Returns OpError::CannotMatMul if the inner dimensions don’t agree, or OpError::CannotBroadcast if the batch axes aren’t broadcast-compatible.

impl<T, B> CachedTensorPromise<T, B>

where T: NumericOp, B: Backend,

pub fn sum(&self) -> <CachedTensorPromise<T, B> as UnaryResult<T, B>>::Output

Sums every element, producing a one-element tensor.

To reduce along a single axis instead, see .sum_axis().

Examples

use candela::Tensor;

let t = Tensor::from_slice(&[1.0, 2.0, 3.0, 4.0], &[2, 2]);
assert_eq!(t.sum().materialize().data(), &[10.0]);

impl<T, B> CachedTensorPromise<T, B>

where T: NumericOp, B: Backend,

pub fn sum_axis( &self, axis: isize, keep_dims: bool, ) -> Result<<CachedTensorPromise<T, B> as UnaryResult<T, B>>::Output, OpError>

Sums along a single axis.

axis selects the axis to collapse and may be negative to count from the end. With keep_dims = false that axis is removed from the shape; with keep_dims = true it is kept as a size-1 axis, which leaves the result broadcastable against the input. To reduce the whole tensor, see .sum().

Examples

use candela::{Tensor, Dimension};

let t = Tensor::from_slice(&[1.0, 2.0, 3.0, 4.0, 5.0, 6.0], &[2, 3]);

let dropped = t.sum_axis(0, false).unwrap().materialize();
assert_eq!(dropped.shape(), &[3]);
assert_eq!(dropped.data(), &[5.0, 7.0, 9.0]);

// keep_dims = true leaves a size-1 axis in place.
let kept = t.sum_axis(0, true).unwrap().materialize();
assert_eq!(kept.shape(), &[1, 3]);

Errors

Returns OpError::AxesOutOfBounds if axis is outside the tensor’s rank.

impl<T, B> CachedTensorPromise<T, B>

where T: NumericOp, B: Backend,

pub fn max(&self) -> <CachedTensorPromise<T, B> as UnaryResult<T, B>>::Output

Returns the largest element, as a one-element tensor.

To take the maximum along a single axis instead, see .max_axis().

Examples

use candela::Tensor;

let t = Tensor::from_slice(&[3.0, 1.0, 4.0, 1.0, 5.0, 2.0], &[2, 3]);
assert_eq!(t.max().materialize().data(), &[5.0]);

impl<T, B> CachedTensorPromise<T, B>

where T: NumericOp, B: Backend,

pub fn max_axis( &self, axis: isize, keep_dims: bool, ) -> Result<<CachedTensorPromise<T, B> as UnaryResult<T, B>>::Output, OpError>

Takes the maximum along a single axis.

axis and keep_dims behave exactly as in .sum_axis(). To reduce the whole tensor, see .max().

Examples

use candela::{Tensor, Dimension};

let t = Tensor::from_slice(&[3.0, 1.0, 4.0, 1.0, 5.0, 2.0], &[2, 3]);
let m = t.max_axis(1, false).unwrap().materialize();

assert_eq!(m.shape(), &[2]);
assert_eq!(m.data(), &[4.0, 5.0]);

Errors

Returns OpError::AxesOutOfBounds if axis is outside the tensor’s rank.

impl<T, B> CachedTensorPromise<T, B>

where T: FloatLike, B: Backend,

pub fn mean(&self) -> <CachedTensorPromise<T, B> as UnaryResult<T, B>>::Output

Averages every element, producing a one-element tensor.

To average along a single axis instead, see .mean_axis().

Examples

use candela::Tensor;

let t = Tensor::from_slice(&[1.0, 2.0, 3.0, 4.0], &[2, 2]);
assert_eq!(t.mean().materialize().data(), &[2.5]);

impl<T, B> CachedTensorPromise<T, B>

where T: FloatLike, B: Backend,

pub fn mean_axis( &self, axis: isize, keep_dims: bool, ) -> Result<<CachedTensorPromise<T, B> as UnaryResult<T, B>>::Output, OpError>

Averages along a single axis.

axis and keep_dims behave exactly as in .sum_axis(). To average the whole tensor, see .mean().

Examples

use candela::{Tensor, Dimension};

let t = Tensor::from_slice(&[1.0, 2.0, 3.0, 4.0, 5.0, 6.0], &[2, 3]);
let m = t.mean_axis(1, false).unwrap().materialize();

assert_eq!(m.shape(), &[2]);
assert_eq!(m.data(), &[2.0, 5.0]);

Errors

Returns OpError::AxesOutOfBounds if axis is outside the tensor’s rank.

impl<T: NumberLike + ComputeFor<B>, B: Backend> CachedTensorPromise<T, B>

pub fn get_cache(&self) -> Option<Tensor<T>>

Return the cached result if it has already been computed, or None if .materialize() has not been called yet.

Examples

use candela::Tensor;

let t = Tensor::from_scalar(1.0_f64, &[2]);
let cached = t.to_promise().cache();

assert!(cached.get_cache().is_none());
let _ = (&cached + 0.0).materialize();
assert!(cached.get_cache().is_some());

pub fn snapshot(&self) -> Tensor<T>

Return the cached result if it has already been computed, or calls .materialize() and then returns the cached tensor if it was not.

Examples

use candela::Tensor;

let t = Tensor::from_scalar(1.0_f64, &[2]);
let cached = t.to_promise().cache();

assert!(cached.get_cache().is_none());
assert_eq!(t.data(), cached.snapshot().data());
assert!(cached.get_cache().is_some());

pub fn materialize(self) -> Tensor<T>

Execute the computation graph and return the result as a Tensor.

See TensorPromise::materialize for details.

pub fn clone_and_materialize(&self) -> Tensor<T>

Same as .materialize() but does not consume self.

pub fn to_slot(&self) -> SkeletonSlot<T, B>

Creates a SkeletonSlot shaped like this promise’s output.

The slot is an input placeholder for a Skeleton. It has the promise’s Layout but holds no data.

Trait Implementations

impl<T, B> Add for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn add(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the + operator.

impl<T, B> Add<&BakedPromise<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<BakedPromise<T, B>, T, B>,

fn add(self, rhs: &BakedPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

A SkeletonSlot anywhere in either operand makes the result a SkeletonPromise instead of a TensorPromise.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<BakedPromise<T, B>, T, B>>::Output

The resulting type after applying the + operator.

impl<T, B> Add<&BakedPromise<T, B>> for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<BakedPromise<T, B>, T, B>,

fn add(self, rhs: &BakedPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<BakedPromise<T, B>, T, B>>::Output

The resulting type after applying the + operator.

impl<T, B> Add<&CachedTensorPromise<T, B>> for &Tensor<T, B>

where T: NumericOp, B: Backend, Tensor<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn add(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

A SkeletonSlot anywhere in either operand makes the result a SkeletonPromise instead of a TensorPromise.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <Tensor<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the + operator.

impl<T, B> Add<&CachedTensorPromise<T, B>> for Tensor<T, B>

where T: NumericOp, B: Backend, Tensor<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn add(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <Tensor<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the + operator.

impl<T, B> Add<&CachedTensorPromise<T, B>> for &TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn add(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

A SkeletonSlot anywhere in either operand makes the result a SkeletonPromise instead of a TensorPromise.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <TensorPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the + operator.

impl<T, B> Add<&CachedTensorPromise<T, B>> for TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn add(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <TensorPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the + operator.

impl<T, B> Add<&CachedTensorPromise<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn add(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

A SkeletonSlot anywhere in either operand makes the result a SkeletonPromise instead of a TensorPromise.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the + operator.

impl<T, B> Add<&CachedTensorPromise<T, B>> for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn add(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the + operator.

impl<T, B> Add<&CachedTensorPromise<T, B>> for &BakedPromise<T, B>

where T: NumericOp, B: Backend, BakedPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn add(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

A SkeletonSlot anywhere in either operand makes the result a SkeletonPromise instead of a TensorPromise.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <BakedPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the + operator.

impl<T, B> Add<&CachedTensorPromise<T, B>> for BakedPromise<T, B>

where T: NumericOp, B: Backend, BakedPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn add(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <BakedPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the + operator.

impl<T, B> Add<&CachedTensorPromise<T, B>> for &SkeletonSlot<T, B>

where T: NumericOp, B: Backend, SkeletonSlot<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn add(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

A SkeletonSlot anywhere in either operand makes the result a SkeletonPromise instead of a TensorPromise.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <SkeletonSlot<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the + operator.

impl<T, B> Add<&CachedTensorPromise<T, B>> for SkeletonSlot<T, B>

where T: NumericOp, B: Backend, SkeletonSlot<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn add(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <SkeletonSlot<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the + operator.

impl<T, B> Add<&CachedTensorPromise<T, B>> for &SkeletonPromise<T, B>

where T: NumericOp, B: Backend, SkeletonPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn add(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

A SkeletonSlot anywhere in either operand makes the result a SkeletonPromise instead of a TensorPromise.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <SkeletonPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the + operator.

impl<T, B> Add<&CachedTensorPromise<T, B>> for SkeletonPromise<T, B>

where T: NumericOp, B: Backend, SkeletonPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn add(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <SkeletonPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the + operator.

impl<T, B> Add<&SkeletonPromise<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<SkeletonPromise<T, B>, T, B>,

fn add(self, rhs: &SkeletonPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

A SkeletonSlot anywhere in either operand makes the result a SkeletonPromise instead of a TensorPromise.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<SkeletonPromise<T, B>, T, B>>::Output

The resulting type after applying the + operator.

impl<T, B> Add<&SkeletonPromise<T, B>> for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<SkeletonPromise<T, B>, T, B>,

fn add(self, rhs: &SkeletonPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<SkeletonPromise<T, B>, T, B>>::Output

The resulting type after applying the + operator.

impl<T, B> Add<&SkeletonSlot<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<SkeletonSlot<T, B>, T, B>,

fn add(self, rhs: &SkeletonSlot<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

A SkeletonSlot anywhere in either operand makes the result a SkeletonPromise instead of a TensorPromise.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<SkeletonSlot<T, B>, T, B>>::Output

The resulting type after applying the + operator.

impl<T, B> Add<&SkeletonSlot<T, B>> for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<SkeletonSlot<T, B>, T, B>,

fn add(self, rhs: &SkeletonSlot<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<SkeletonSlot<T, B>, T, B>>::Output

The resulting type after applying the + operator.

impl<T, B> Add<&Tensor<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<Tensor<T, B>, T, B>,

fn add(self, rhs: &Tensor<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

A SkeletonSlot anywhere in either operand makes the result a SkeletonPromise instead of a TensorPromise.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<Tensor<T, B>, T, B>>::Output

The resulting type after applying the + operator.

impl<T, B> Add<&Tensor<T, B>> for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<Tensor<T, B>, T, B>,

fn add(self, rhs: &Tensor<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<Tensor<T, B>, T, B>>::Output

The resulting type after applying the + operator.

impl<T, B> Add<&TensorPromise<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<TensorPromise<T, B>, T, B>,

fn add(self, rhs: &TensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

A SkeletonSlot anywhere in either operand makes the result a SkeletonPromise instead of a TensorPromise.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<TensorPromise<T, B>, T, B>>::Output

The resulting type after applying the + operator.

impl<T, B> Add<&TensorPromise<T, B>> for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<TensorPromise<T, B>, T, B>,

fn add(self, rhs: &TensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<TensorPromise<T, B>, T, B>>::Output

The resulting type after applying the + operator.

impl<T, B> Add<BakedPromise<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<BakedPromise<T, B>, T, B>,

fn add(self, rhs: BakedPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<BakedPromise<T, B>, T, B>>::Output

The resulting type after applying the + operator.

impl<T, B> Add<BakedPromise<T, B>> for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<BakedPromise<T, B>, T, B>,

fn add(self, rhs: BakedPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<BakedPromise<T, B>, T, B>>::Output

The resulting type after applying the + operator.

impl<T, B> Add<CachedTensorPromise<T, B>> for &Tensor<T, B>

where T: NumericOp, B: Backend, Tensor<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn add(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <Tensor<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the + operator.

impl<T, B> Add<CachedTensorPromise<T, B>> for Tensor<T, B>

where T: NumericOp, B: Backend, Tensor<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn add(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <Tensor<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the + operator.

impl<T, B> Add<CachedTensorPromise<T, B>> for &TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn add(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <TensorPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the + operator.

impl<T, B> Add<CachedTensorPromise<T, B>> for TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn add(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <TensorPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the + operator.

impl<T, B> Add<CachedTensorPromise<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn add(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the + operator.

impl<T, B> Add<CachedTensorPromise<T, B>> for &BakedPromise<T, B>

where T: NumericOp, B: Backend, BakedPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn add(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <BakedPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the + operator.

impl<T, B> Add<CachedTensorPromise<T, B>> for BakedPromise<T, B>

where T: NumericOp, B: Backend, BakedPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn add(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <BakedPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the + operator.

impl<T, B> Add<CachedTensorPromise<T, B>> for &SkeletonSlot<T, B>

where T: NumericOp, B: Backend, SkeletonSlot<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn add(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <SkeletonSlot<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the + operator.

impl<T, B> Add<CachedTensorPromise<T, B>> for SkeletonSlot<T, B>

where T: NumericOp, B: Backend, SkeletonSlot<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn add(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <SkeletonSlot<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the + operator.

impl<T, B> Add<CachedTensorPromise<T, B>> for &SkeletonPromise<T, B>

where T: NumericOp, B: Backend, SkeletonPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn add(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <SkeletonPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the + operator.

impl<T, B> Add<CachedTensorPromise<T, B>> for SkeletonPromise<T, B>

where T: NumericOp, B: Backend, SkeletonPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn add(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <SkeletonPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the + operator.

impl<T, B> Add<SkeletonPromise<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<SkeletonPromise<T, B>, T, B>,

fn add(self, rhs: SkeletonPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<SkeletonPromise<T, B>, T, B>>::Output

The resulting type after applying the + operator.

impl<T, B> Add<SkeletonPromise<T, B>> for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<SkeletonPromise<T, B>, T, B>,

fn add(self, rhs: SkeletonPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<SkeletonPromise<T, B>, T, B>>::Output

The resulting type after applying the + operator.

impl<T, B> Add<SkeletonSlot<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<SkeletonSlot<T, B>, T, B>,

fn add(self, rhs: SkeletonSlot<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<SkeletonSlot<T, B>, T, B>>::Output

The resulting type after applying the + operator.

impl<T, B> Add<SkeletonSlot<T, B>> for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<SkeletonSlot<T, B>, T, B>,

fn add(self, rhs: SkeletonSlot<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<SkeletonSlot<T, B>, T, B>>::Output

The resulting type after applying the + operator.

impl<T, B> Add<T> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend,

type Output = <CachedTensorPromise<T, B> as UnaryResult<T, B>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: T) -> Self::Output

Performs the + operation.

impl<T, B> Add<T> for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend,

type Output = <CachedTensorPromise<T, B> as UnaryResult<T, B>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: T) -> Self::Output

Performs the + operation.

impl<T, B> Add<Tensor<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<Tensor<T, B>, T, B>,

fn add(self, rhs: Tensor<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<Tensor<T, B>, T, B>>::Output

The resulting type after applying the + operator.

impl<T, B> Add<Tensor<T, B>> for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<Tensor<T, B>, T, B>,

fn add(self, rhs: Tensor<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<Tensor<T, B>, T, B>>::Output

The resulting type after applying the + operator.

impl<T, B> Add<TensorPromise<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<TensorPromise<T, B>, T, B>,

fn add(self, rhs: TensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<TensorPromise<T, B>, T, B>>::Output

The resulting type after applying the + operator.

impl<T, B> Add<TensorPromise<T, B>> for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<TensorPromise<T, B>, T, B>,

fn add(self, rhs: TensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<TensorPromise<T, B>, T, B>>::Output

The resulting type after applying the + operator.

impl<T, B> AddAssign<&CachedTensorPromise<T, B>> for TensorPromise<T, B>

where T: NumericOp, B: Backend,

fn add_assign(&mut self, rhs: &CachedTensorPromise<T, B>)

Performs the += operation.

impl<T, B> AddAssign<CachedTensorPromise<T, B>> for TensorPromise<T, B>

where T: NumericOp, B: Backend,

fn add_assign(&mut self, rhs: CachedTensorPromise<T, B>)

Performs the += operation.

impl<T, B: Backend> Clone for CachedTensorPromise<T, B>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, B: Backend> Composable<T, B> for CachedTensorPromise<T, B>

impl<T: Debug, B: Backend> Debug for CachedTensorPromise<T, B>

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

Formats the value using the given formatter.

impl<T, B: Backend> Dimension for CachedTensorPromise<T, B>

fn layout(&self) -> &Layout

fn shape(&self) -> &[usize]

fn stride(&self) -> &[i32]

fn adj_stride(&self) -> &[i32]

fn len(&self) -> usize

fn is_empty(&self) -> bool

fn offset(&self) -> usize

fn is_contiguous(&self) -> bool

fn is_contiguous_at_axis(&self, axis: usize) -> bool

fn is_transposed(&self) -> bool

fn is_transposed_at_axis(&self, axis: usize) -> bool

impl<T, B> Div for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn div(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> Div<&BakedPromise<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<BakedPromise<T, B>, T, B>,

fn div(self, rhs: &BakedPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

A SkeletonSlot anywhere in either operand makes the result a SkeletonPromise instead of a TensorPromise.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<BakedPromise<T, B>, T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> Div<&BakedPromise<T, B>> for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<BakedPromise<T, B>, T, B>,

fn div(self, rhs: &BakedPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<BakedPromise<T, B>, T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> Div<&CachedTensorPromise<T, B>> for &Tensor<T, B>

where T: NumericOp, B: Backend, Tensor<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn div(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

A SkeletonSlot anywhere in either operand makes the result a SkeletonPromise instead of a TensorPromise.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <Tensor<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> Div<&CachedTensorPromise<T, B>> for Tensor<T, B>

where T: NumericOp, B: Backend, Tensor<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn div(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <Tensor<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> Div<&CachedTensorPromise<T, B>> for &TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn div(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

A SkeletonSlot anywhere in either operand makes the result a SkeletonPromise instead of a TensorPromise.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <TensorPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> Div<&CachedTensorPromise<T, B>> for TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn div(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <TensorPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> Div<&CachedTensorPromise<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn div(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

A SkeletonSlot anywhere in either operand makes the result a SkeletonPromise instead of a TensorPromise.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> Div<&CachedTensorPromise<T, B>> for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn div(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> Div<&CachedTensorPromise<T, B>> for &BakedPromise<T, B>

where T: NumericOp, B: Backend, BakedPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn div(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

A SkeletonSlot anywhere in either operand makes the result a SkeletonPromise instead of a TensorPromise.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <BakedPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> Div<&CachedTensorPromise<T, B>> for BakedPromise<T, B>

where T: NumericOp, B: Backend, BakedPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn div(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <BakedPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> Div<&CachedTensorPromise<T, B>> for &SkeletonSlot<T, B>

where T: NumericOp, B: Backend, SkeletonSlot<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn div(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

A SkeletonSlot anywhere in either operand makes the result a SkeletonPromise instead of a TensorPromise.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <SkeletonSlot<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> Div<&CachedTensorPromise<T, B>> for SkeletonSlot<T, B>

where T: NumericOp, B: Backend, SkeletonSlot<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn div(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <SkeletonSlot<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> Div<&CachedTensorPromise<T, B>> for &SkeletonPromise<T, B>

where T: NumericOp, B: Backend, SkeletonPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn div(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

A SkeletonSlot anywhere in either operand makes the result a SkeletonPromise instead of a TensorPromise.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <SkeletonPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> Div<&CachedTensorPromise<T, B>> for SkeletonPromise<T, B>

where T: NumericOp, B: Backend, SkeletonPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn div(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <SkeletonPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> Div<&SkeletonPromise<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<SkeletonPromise<T, B>, T, B>,

fn div(self, rhs: &SkeletonPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

A SkeletonSlot anywhere in either operand makes the result a SkeletonPromise instead of a TensorPromise.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<SkeletonPromise<T, B>, T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> Div<&SkeletonPromise<T, B>> for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<SkeletonPromise<T, B>, T, B>,

fn div(self, rhs: &SkeletonPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<SkeletonPromise<T, B>, T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> Div<&SkeletonSlot<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<SkeletonSlot<T, B>, T, B>,

fn div(self, rhs: &SkeletonSlot<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

A SkeletonSlot anywhere in either operand makes the result a SkeletonPromise instead of a TensorPromise.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<SkeletonSlot<T, B>, T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> Div<&SkeletonSlot<T, B>> for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<SkeletonSlot<T, B>, T, B>,

fn div(self, rhs: &SkeletonSlot<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<SkeletonSlot<T, B>, T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> Div<&Tensor<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<Tensor<T, B>, T, B>,

fn div(self, rhs: &Tensor<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

A SkeletonSlot anywhere in either operand makes the result a SkeletonPromise instead of a TensorPromise.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<Tensor<T, B>, T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> Div<&Tensor<T, B>> for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<Tensor<T, B>, T, B>,

fn div(self, rhs: &Tensor<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<Tensor<T, B>, T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> Div<&TensorPromise<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<TensorPromise<T, B>, T, B>,

fn div(self, rhs: &TensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

A SkeletonSlot anywhere in either operand makes the result a SkeletonPromise instead of a TensorPromise.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<TensorPromise<T, B>, T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> Div<&TensorPromise<T, B>> for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<TensorPromise<T, B>, T, B>,

fn div(self, rhs: &TensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<TensorPromise<T, B>, T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> Div<BakedPromise<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<BakedPromise<T, B>, T, B>,

fn div(self, rhs: BakedPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<BakedPromise<T, B>, T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> Div<BakedPromise<T, B>> for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<BakedPromise<T, B>, T, B>,

fn div(self, rhs: BakedPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<BakedPromise<T, B>, T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> Div<CachedTensorPromise<T, B>> for &Tensor<T, B>

where T: NumericOp, B: Backend, Tensor<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn div(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <Tensor<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> Div<CachedTensorPromise<T, B>> for Tensor<T, B>

where T: NumericOp, B: Backend, Tensor<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn div(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <Tensor<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> Div<CachedTensorPromise<T, B>> for &TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn div(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <TensorPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> Div<CachedTensorPromise<T, B>> for TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn div(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <TensorPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> Div<CachedTensorPromise<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn div(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> Div<CachedTensorPromise<T, B>> for &BakedPromise<T, B>

where T: NumericOp, B: Backend, BakedPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn div(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <BakedPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> Div<CachedTensorPromise<T, B>> for BakedPromise<T, B>

where T: NumericOp, B: Backend, BakedPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn div(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <BakedPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> Div<CachedTensorPromise<T, B>> for &SkeletonSlot<T, B>

where T: NumericOp, B: Backend, SkeletonSlot<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn div(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <SkeletonSlot<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> Div<CachedTensorPromise<T, B>> for SkeletonSlot<T, B>

where T: NumericOp, B: Backend, SkeletonSlot<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn div(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <SkeletonSlot<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> Div<CachedTensorPromise<T, B>> for &SkeletonPromise<T, B>

where T: NumericOp, B: Backend, SkeletonPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn div(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <SkeletonPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> Div<CachedTensorPromise<T, B>> for SkeletonPromise<T, B>

where T: NumericOp, B: Backend, SkeletonPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn div(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <SkeletonPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> Div<SkeletonPromise<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<SkeletonPromise<T, B>, T, B>,

fn div(self, rhs: SkeletonPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<SkeletonPromise<T, B>, T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> Div<SkeletonPromise<T, B>> for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<SkeletonPromise<T, B>, T, B>,

fn div(self, rhs: SkeletonPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<SkeletonPromise<T, B>, T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> Div<SkeletonSlot<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<SkeletonSlot<T, B>, T, B>,

fn div(self, rhs: SkeletonSlot<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<SkeletonSlot<T, B>, T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> Div<SkeletonSlot<T, B>> for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<SkeletonSlot<T, B>, T, B>,

fn div(self, rhs: SkeletonSlot<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<SkeletonSlot<T, B>, T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> Div<T> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend,

fn div(self, rhs: T) -> Self::Output

Panics

Panics when the operator is applied — not at .materialize() — if rhs is zero.

type Output = <CachedTensorPromise<T, B> as UnaryResult<T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> Div<T> for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend,

fn div(self, rhs: T) -> Self::Output

Panics

Panics when the operator is applied — not at .materialize() — if rhs is zero.

type Output = <CachedTensorPromise<T, B> as UnaryResult<T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> Div<Tensor<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<Tensor<T, B>, T, B>,

fn div(self, rhs: Tensor<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<Tensor<T, B>, T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> Div<Tensor<T, B>> for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<Tensor<T, B>, T, B>,

fn div(self, rhs: Tensor<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<Tensor<T, B>, T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> Div<TensorPromise<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<TensorPromise<T, B>, T, B>,

fn div(self, rhs: TensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<TensorPromise<T, B>, T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> Div<TensorPromise<T, B>> for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<TensorPromise<T, B>, T, B>,

fn div(self, rhs: TensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<TensorPromise<T, B>, T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> DivAssign<&CachedTensorPromise<T, B>> for TensorPromise<T, B>

where T: NumericOp, B: Backend,

fn div_assign(&mut self, rhs: &CachedTensorPromise<T, B>)

Performs the /= operation.

impl<T, B> DivAssign<CachedTensorPromise<T, B>> for TensorPromise<T, B>

where T: NumericOp, B: Backend,

fn div_assign(&mut self, rhs: CachedTensorPromise<T, B>)

Performs the /= operation.

impl<T, B> Mul for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn mul(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the * operator.

impl<T, B> Mul<&BakedPromise<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<BakedPromise<T, B>, T, B>,

fn mul(self, rhs: &BakedPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

A SkeletonSlot anywhere in either operand makes the result a SkeletonPromise instead of a TensorPromise.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<BakedPromise<T, B>, T, B>>::Output

The resulting type after applying the * operator.

impl<T, B> Mul<&BakedPromise<T, B>> for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<BakedPromise<T, B>, T, B>,

fn mul(self, rhs: &BakedPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<BakedPromise<T, B>, T, B>>::Output

The resulting type after applying the * operator.

impl<T, B> Mul<&CachedTensorPromise<T, B>> for &Tensor<T, B>

where T: NumericOp, B: Backend, Tensor<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn mul(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

A SkeletonSlot anywhere in either operand makes the result a SkeletonPromise instead of a TensorPromise.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <Tensor<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the * operator.

impl<T, B> Mul<&CachedTensorPromise<T, B>> for Tensor<T, B>

where T: NumericOp, B: Backend, Tensor<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn mul(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <Tensor<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the * operator.

impl<T, B> Mul<&CachedTensorPromise<T, B>> for &TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn mul(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

A SkeletonSlot anywhere in either operand makes the result a SkeletonPromise instead of a TensorPromise.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <TensorPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the * operator.

impl<T, B> Mul<&CachedTensorPromise<T, B>> for TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn mul(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <TensorPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the * operator.

impl<T, B> Mul<&CachedTensorPromise<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn mul(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

A SkeletonSlot anywhere in either operand makes the result a SkeletonPromise instead of a TensorPromise.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the * operator.

impl<T, B> Mul<&CachedTensorPromise<T, B>> for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn mul(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the * operator.

impl<T, B> Mul<&CachedTensorPromise<T, B>> for &BakedPromise<T, B>

where T: NumericOp, B: Backend, BakedPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn mul(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

A SkeletonSlot anywhere in either operand makes the result a SkeletonPromise instead of a TensorPromise.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <BakedPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the * operator.

impl<T, B> Mul<&CachedTensorPromise<T, B>> for BakedPromise<T, B>

where T: NumericOp, B: Backend, BakedPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn mul(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <BakedPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the * operator.

impl<T, B> Mul<&CachedTensorPromise<T, B>> for &SkeletonSlot<T, B>

where T: NumericOp, B: Backend, SkeletonSlot<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn mul(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

A SkeletonSlot anywhere in either operand makes the result a SkeletonPromise instead of a TensorPromise.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <SkeletonSlot<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the * operator.

impl<T, B> Mul<&CachedTensorPromise<T, B>> for SkeletonSlot<T, B>

where T: NumericOp, B: Backend, SkeletonSlot<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn mul(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <SkeletonSlot<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the * operator.

impl<T, B> Mul<&CachedTensorPromise<T, B>> for &SkeletonPromise<T, B>

where T: NumericOp, B: Backend, SkeletonPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn mul(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

A SkeletonSlot anywhere in either operand makes the result a SkeletonPromise instead of a TensorPromise.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <SkeletonPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the * operator.

impl<T, B> Mul<&CachedTensorPromise<T, B>> for SkeletonPromise<T, B>

where T: NumericOp, B: Backend, SkeletonPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn mul(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <SkeletonPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the * operator.

impl<T, B> Mul<&SkeletonPromise<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<SkeletonPromise<T, B>, T, B>,

fn mul(self, rhs: &SkeletonPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

A SkeletonSlot anywhere in either operand makes the result a SkeletonPromise instead of a TensorPromise.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<SkeletonPromise<T, B>, T, B>>::Output

The resulting type after applying the * operator.

impl<T, B> Mul<&SkeletonPromise<T, B>> for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<SkeletonPromise<T, B>, T, B>,

fn mul(self, rhs: &SkeletonPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<SkeletonPromise<T, B>, T, B>>::Output

The resulting type after applying the * operator.

impl<T, B> Mul<&SkeletonSlot<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<SkeletonSlot<T, B>, T, B>,

fn mul(self, rhs: &SkeletonSlot<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

A SkeletonSlot anywhere in either operand makes the result a SkeletonPromise instead of a TensorPromise.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<SkeletonSlot<T, B>, T, B>>::Output

The resulting type after applying the * operator.

impl<T, B> Mul<&SkeletonSlot<T, B>> for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<SkeletonSlot<T, B>, T, B>,

fn mul(self, rhs: &SkeletonSlot<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<SkeletonSlot<T, B>, T, B>>::Output

The resulting type after applying the * operator.

impl<T, B> Mul<&Tensor<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<Tensor<T, B>, T, B>,

fn mul(self, rhs: &Tensor<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

A SkeletonSlot anywhere in either operand makes the result a SkeletonPromise instead of a TensorPromise.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<Tensor<T, B>, T, B>>::Output

The resulting type after applying the * operator.

impl<T, B> Mul<&Tensor<T, B>> for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<Tensor<T, B>, T, B>,

fn mul(self, rhs: &Tensor<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<Tensor<T, B>, T, B>>::Output

The resulting type after applying the * operator.

impl<T, B> Mul<&TensorPromise<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<TensorPromise<T, B>, T, B>,

fn mul(self, rhs: &TensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

A SkeletonSlot anywhere in either operand makes the result a SkeletonPromise instead of a TensorPromise.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<TensorPromise<T, B>, T, B>>::Output

The resulting type after applying the * operator.

impl<T, B> Mul<&TensorPromise<T, B>> for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<TensorPromise<T, B>, T, B>,

fn mul(self, rhs: &TensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<TensorPromise<T, B>, T, B>>::Output

The resulting type after applying the * operator.

impl<T, B> Mul<BakedPromise<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<BakedPromise<T, B>, T, B>,

fn mul(self, rhs: BakedPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<BakedPromise<T, B>, T, B>>::Output

The resulting type after applying the * operator.

impl<T, B> Mul<BakedPromise<T, B>> for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<BakedPromise<T, B>, T, B>,

fn mul(self, rhs: BakedPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<BakedPromise<T, B>, T, B>>::Output

The resulting type after applying the * operator.

impl<T, B> Mul<CachedTensorPromise<T, B>> for &Tensor<T, B>

where T: NumericOp, B: Backend, Tensor<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn mul(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <Tensor<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the * operator.

impl<T, B> Mul<CachedTensorPromise<T, B>> for Tensor<T, B>

where T: NumericOp, B: Backend, Tensor<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn mul(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <Tensor<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the * operator.

impl<T, B> Mul<CachedTensorPromise<T, B>> for &TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn mul(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <TensorPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the * operator.

impl<T, B> Mul<CachedTensorPromise<T, B>> for TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn mul(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <TensorPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the * operator.

impl<T, B> Mul<CachedTensorPromise<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn mul(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the * operator.

impl<T, B> Mul<CachedTensorPromise<T, B>> for &BakedPromise<T, B>

where T: NumericOp, B: Backend, BakedPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn mul(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <BakedPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the * operator.

impl<T, B> Mul<CachedTensorPromise<T, B>> for BakedPromise<T, B>

where T: NumericOp, B: Backend, BakedPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn mul(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <BakedPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the * operator.

impl<T, B> Mul<CachedTensorPromise<T, B>> for &SkeletonSlot<T, B>

where T: NumericOp, B: Backend, SkeletonSlot<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn mul(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <SkeletonSlot<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the * operator.

impl<T, B> Mul<CachedTensorPromise<T, B>> for SkeletonSlot<T, B>

where T: NumericOp, B: Backend, SkeletonSlot<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn mul(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <SkeletonSlot<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the * operator.

impl<T, B> Mul<CachedTensorPromise<T, B>> for &SkeletonPromise<T, B>

where T: NumericOp, B: Backend, SkeletonPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn mul(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <SkeletonPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the * operator.

impl<T, B> Mul<CachedTensorPromise<T, B>> for SkeletonPromise<T, B>

where T: NumericOp, B: Backend, SkeletonPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn mul(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <SkeletonPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the * operator.

impl<T, B> Mul<SkeletonPromise<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<SkeletonPromise<T, B>, T, B>,

fn mul(self, rhs: SkeletonPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<SkeletonPromise<T, B>, T, B>>::Output

The resulting type after applying the * operator.

impl<T, B> Mul<SkeletonPromise<T, B>> for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<SkeletonPromise<T, B>, T, B>,

fn mul(self, rhs: SkeletonPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<SkeletonPromise<T, B>, T, B>>::Output

The resulting type after applying the * operator.

impl<T, B> Mul<SkeletonSlot<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<SkeletonSlot<T, B>, T, B>,

fn mul(self, rhs: SkeletonSlot<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<SkeletonSlot<T, B>, T, B>>::Output

The resulting type after applying the * operator.

impl<T, B> Mul<SkeletonSlot<T, B>> for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<SkeletonSlot<T, B>, T, B>,

fn mul(self, rhs: SkeletonSlot<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<SkeletonSlot<T, B>, T, B>>::Output

The resulting type after applying the * operator.

impl<T, B> Mul<T> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend,

type Output = <CachedTensorPromise<T, B> as UnaryResult<T, B>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Self::Output

Performs the * operation.

impl<T, B> Mul<T> for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend,

type Output = <CachedTensorPromise<T, B> as UnaryResult<T, B>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Self::Output

Performs the * operation.

impl<T, B> Mul<Tensor<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<Tensor<T, B>, T, B>,

fn mul(self, rhs: Tensor<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<Tensor<T, B>, T, B>>::Output

The resulting type after applying the * operator.

impl<T, B> Mul<Tensor<T, B>> for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<Tensor<T, B>, T, B>,

fn mul(self, rhs: Tensor<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<Tensor<T, B>, T, B>>::Output

The resulting type after applying the * operator.

impl<T, B> Mul<TensorPromise<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<TensorPromise<T, B>, T, B>,

fn mul(self, rhs: TensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<TensorPromise<T, B>, T, B>>::Output

The resulting type after applying the * operator.

impl<T, B> Mul<TensorPromise<T, B>> for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<TensorPromise<T, B>, T, B>,

fn mul(self, rhs: TensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<TensorPromise<T, B>, T, B>>::Output

The resulting type after applying the * operator.

impl<T, B> MulAssign<&CachedTensorPromise<T, B>> for TensorPromise<T, B>

where T: NumericOp, B: Backend,

fn mul_assign(&mut self, rhs: &CachedTensorPromise<T, B>)

Performs the *= operation.

impl<T, B> MulAssign<CachedTensorPromise<T, B>> for TensorPromise<T, B>

where T: NumericOp, B: Backend,

fn mul_assign(&mut self, rhs: CachedTensorPromise<T, B>)

Performs the *= operation.

impl<T, B> Sub for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn sub(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the - operator.

impl<T, B> Sub<&BakedPromise<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<BakedPromise<T, B>, T, B>,

fn sub(self, rhs: &BakedPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

A SkeletonSlot anywhere in either operand makes the result a SkeletonPromise instead of a TensorPromise.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<BakedPromise<T, B>, T, B>>::Output

The resulting type after applying the - operator.

impl<T, B> Sub<&BakedPromise<T, B>> for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<BakedPromise<T, B>, T, B>,

fn sub(self, rhs: &BakedPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<BakedPromise<T, B>, T, B>>::Output

The resulting type after applying the - operator.

impl<T, B> Sub<&CachedTensorPromise<T, B>> for &Tensor<T, B>

where T: NumericOp, B: Backend, Tensor<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn sub(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

A SkeletonSlot anywhere in either operand makes the result a SkeletonPromise instead of a TensorPromise.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <Tensor<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the - operator.

impl<T, B> Sub<&CachedTensorPromise<T, B>> for Tensor<T, B>

where T: NumericOp, B: Backend, Tensor<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn sub(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <Tensor<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the - operator.

impl<T, B> Sub<&CachedTensorPromise<T, B>> for &TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn sub(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

A SkeletonSlot anywhere in either operand makes the result a SkeletonPromise instead of a TensorPromise.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <TensorPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the - operator.

impl<T, B> Sub<&CachedTensorPromise<T, B>> for TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn sub(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <TensorPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the - operator.

impl<T, B> Sub<&CachedTensorPromise<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn sub(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

A SkeletonSlot anywhere in either operand makes the result a SkeletonPromise instead of a TensorPromise.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the - operator.

impl<T, B> Sub<&CachedTensorPromise<T, B>> for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn sub(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the - operator.

impl<T, B> Sub<&CachedTensorPromise<T, B>> for &BakedPromise<T, B>

where T: NumericOp, B: Backend, BakedPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn sub(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

A SkeletonSlot anywhere in either operand makes the result a SkeletonPromise instead of a TensorPromise.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <BakedPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the - operator.

impl<T, B> Sub<&CachedTensorPromise<T, B>> for BakedPromise<T, B>

where T: NumericOp, B: Backend, BakedPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn sub(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <BakedPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the - operator.

impl<T, B> Sub<&CachedTensorPromise<T, B>> for &SkeletonSlot<T, B>

where T: NumericOp, B: Backend, SkeletonSlot<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn sub(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

A SkeletonSlot anywhere in either operand makes the result a SkeletonPromise instead of a TensorPromise.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <SkeletonSlot<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the - operator.

impl<T, B> Sub<&CachedTensorPromise<T, B>> for SkeletonSlot<T, B>

where T: NumericOp, B: Backend, SkeletonSlot<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn sub(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <SkeletonSlot<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the - operator.

impl<T, B> Sub<&CachedTensorPromise<T, B>> for &SkeletonPromise<T, B>

where T: NumericOp, B: Backend, SkeletonPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn sub(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

A SkeletonSlot anywhere in either operand makes the result a SkeletonPromise instead of a TensorPromise.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <SkeletonPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the - operator.

impl<T, B> Sub<&CachedTensorPromise<T, B>> for SkeletonPromise<T, B>

where T: NumericOp, B: Backend, SkeletonPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn sub(self, rhs: &CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <SkeletonPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the - operator.

impl<T, B> Sub<&SkeletonPromise<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<SkeletonPromise<T, B>, T, B>,

fn sub(self, rhs: &SkeletonPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

A SkeletonSlot anywhere in either operand makes the result a SkeletonPromise instead of a TensorPromise.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<SkeletonPromise<T, B>, T, B>>::Output

The resulting type after applying the - operator.

impl<T, B> Sub<&SkeletonPromise<T, B>> for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<SkeletonPromise<T, B>, T, B>,

fn sub(self, rhs: &SkeletonPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<SkeletonPromise<T, B>, T, B>>::Output

The resulting type after applying the - operator.

impl<T, B> Sub<&SkeletonSlot<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<SkeletonSlot<T, B>, T, B>,

fn sub(self, rhs: &SkeletonSlot<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

A SkeletonSlot anywhere in either operand makes the result a SkeletonPromise instead of a TensorPromise.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<SkeletonSlot<T, B>, T, B>>::Output

The resulting type after applying the - operator.

impl<T, B> Sub<&SkeletonSlot<T, B>> for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<SkeletonSlot<T, B>, T, B>,

fn sub(self, rhs: &SkeletonSlot<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<SkeletonSlot<T, B>, T, B>>::Output

The resulting type after applying the - operator.

impl<T, B> Sub<&Tensor<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<Tensor<T, B>, T, B>,

fn sub(self, rhs: &Tensor<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

A SkeletonSlot anywhere in either operand makes the result a SkeletonPromise instead of a TensorPromise.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<Tensor<T, B>, T, B>>::Output

The resulting type after applying the - operator.

impl<T, B> Sub<&Tensor<T, B>> for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<Tensor<T, B>, T, B>,

fn sub(self, rhs: &Tensor<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<Tensor<T, B>, T, B>>::Output

The resulting type after applying the - operator.

impl<T, B> Sub<&TensorPromise<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<TensorPromise<T, B>, T, B>,

fn sub(self, rhs: &TensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

A SkeletonSlot anywhere in either operand makes the result a SkeletonPromise instead of a TensorPromise.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<TensorPromise<T, B>, T, B>>::Output

The resulting type after applying the - operator.

impl<T, B> Sub<&TensorPromise<T, B>> for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<TensorPromise<T, B>, T, B>,

fn sub(self, rhs: &TensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<TensorPromise<T, B>, T, B>>::Output

The resulting type after applying the - operator.

impl<T, B> Sub<BakedPromise<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<BakedPromise<T, B>, T, B>,

fn sub(self, rhs: BakedPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<BakedPromise<T, B>, T, B>>::Output

The resulting type after applying the - operator.

impl<T, B> Sub<BakedPromise<T, B>> for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<BakedPromise<T, B>, T, B>,

fn sub(self, rhs: BakedPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<BakedPromise<T, B>, T, B>>::Output

The resulting type after applying the - operator.

impl<T, B> Sub<CachedTensorPromise<T, B>> for &Tensor<T, B>

where T: NumericOp, B: Backend, Tensor<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn sub(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <Tensor<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the - operator.

impl<T, B> Sub<CachedTensorPromise<T, B>> for Tensor<T, B>

where T: NumericOp, B: Backend, Tensor<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn sub(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <Tensor<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the - operator.

impl<T, B> Sub<CachedTensorPromise<T, B>> for &TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn sub(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <TensorPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the - operator.

impl<T, B> Sub<CachedTensorPromise<T, B>> for TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn sub(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <TensorPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the - operator.

impl<T, B> Sub<CachedTensorPromise<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn sub(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the - operator.

impl<T, B> Sub<CachedTensorPromise<T, B>> for &BakedPromise<T, B>

where T: NumericOp, B: Backend, BakedPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn sub(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <BakedPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the - operator.

impl<T, B> Sub<CachedTensorPromise<T, B>> for BakedPromise<T, B>

where T: NumericOp, B: Backend, BakedPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn sub(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <BakedPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the - operator.

impl<T, B> Sub<CachedTensorPromise<T, B>> for &SkeletonSlot<T, B>

where T: NumericOp, B: Backend, SkeletonSlot<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn sub(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <SkeletonSlot<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the - operator.

impl<T, B> Sub<CachedTensorPromise<T, B>> for SkeletonSlot<T, B>

where T: NumericOp, B: Backend, SkeletonSlot<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn sub(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <SkeletonSlot<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the - operator.

impl<T, B> Sub<CachedTensorPromise<T, B>> for &SkeletonPromise<T, B>

where T: NumericOp, B: Backend, SkeletonPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn sub(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <SkeletonPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the - operator.

impl<T, B> Sub<CachedTensorPromise<T, B>> for SkeletonPromise<T, B>

where T: NumericOp, B: Backend, SkeletonPromise<T, B>: BinaryResult<CachedTensorPromise<T, B>, T, B>,

fn sub(self, rhs: CachedTensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <SkeletonPromise<T, B> as BinaryResult<CachedTensorPromise<T, B>, T, B>>::Output

The resulting type after applying the - operator.

impl<T, B> Sub<SkeletonPromise<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<SkeletonPromise<T, B>, T, B>,

fn sub(self, rhs: SkeletonPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<SkeletonPromise<T, B>, T, B>>::Output

The resulting type after applying the - operator.

impl<T, B> Sub<SkeletonPromise<T, B>> for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<SkeletonPromise<T, B>, T, B>,

fn sub(self, rhs: SkeletonPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<SkeletonPromise<T, B>, T, B>>::Output

The resulting type after applying the - operator.

impl<T, B> Sub<SkeletonSlot<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<SkeletonSlot<T, B>, T, B>,

fn sub(self, rhs: SkeletonSlot<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<SkeletonSlot<T, B>, T, B>>::Output

The resulting type after applying the - operator.

impl<T, B> Sub<SkeletonSlot<T, B>> for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<SkeletonSlot<T, B>, T, B>,

fn sub(self, rhs: SkeletonSlot<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<SkeletonSlot<T, B>, T, B>>::Output

The resulting type after applying the - operator.

impl<T, B> Sub<T> for &CachedTensorPromise<T, B>

where T: NumericOp + Neg<Output = T>, B: Backend,

type Output = <CachedTensorPromise<T, B> as UnaryResult<T, B>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> Self::Output

Performs the - operation.

impl<T, B> Sub<T> for CachedTensorPromise<T, B>

where T: NumericOp + Neg<Output = T>, B: Backend,

type Output = <CachedTensorPromise<T, B> as UnaryResult<T, B>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> Self::Output

Performs the - operation.

impl<T, B> Sub<Tensor<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<Tensor<T, B>, T, B>,

fn sub(self, rhs: Tensor<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<Tensor<T, B>, T, B>>::Output

The resulting type after applying the - operator.

impl<T, B> Sub<Tensor<T, B>> for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<Tensor<T, B>, T, B>,

fn sub(self, rhs: Tensor<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<Tensor<T, B>, T, B>>::Output

The resulting type after applying the - operator.

impl<T, B> Sub<TensorPromise<T, B>> for &CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<TensorPromise<T, B>, T, B>,

fn sub(self, rhs: TensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<TensorPromise<T, B>, T, B>>::Output

The resulting type after applying the - operator.

impl<T, B> Sub<TensorPromise<T, B>> for CachedTensorPromise<T, B>

where T: NumericOp, B: Backend, CachedTensorPromise<T, B>: BinaryResult<TensorPromise<T, B>, T, B>,

fn sub(self, rhs: TensorPromise<T, B>) -> Self::Output

Applies the operation element-wise, broadcasting if the shapes are compatible.

Panics

Panics when the operator is applied — not at .materialize() — if the shapes are not broadcast-compatible.

type Output = <CachedTensorPromise<T, B> as BinaryResult<TensorPromise<T, B>, T, B>>::Output

The resulting type after applying the - operator.

impl<T, B> SubAssign<&CachedTensorPromise<T, B>> for TensorPromise<T, B>

where T: NumericOp, B: Backend,

fn sub_assign(&mut self, rhs: &CachedTensorPromise<T, B>)

Performs the -= operation.

impl<T, B> SubAssign<CachedTensorPromise<T, B>> for TensorPromise<T, B>

where T: NumericOp, B: Backend,

fn sub_assign(&mut self, rhs: CachedTensorPromise<T, B>)

Performs the -= operation.