Struct TensorPromise 

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

A lazy computation that runs when you call .materialize().

Building a TensorPromise chain allocates no intermediate tensors - the graph is constructed, not evaluated.

Examples

use candela::Tensor;

let t = Tensor::from_scalar(3.0_f64, &[4]);
let result = (t * 2.0 + 1.0).materialize();
assert_eq!(result.data(), &vec![7.0; 4]);

Implementations

impl<T, B> TensorPromise<T, B>

where T: Numeric, B: Backend,

pub fn view( &self, shape: &[usize], ) -> Result<<TensorPromise<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<<TensorPromise<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> TensorPromise<T, B>

where T: Numeric, B: Backend,

pub fn slice( &self, shape: &[SliceRange], ) -> Result<<TensorPromise<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> TensorPromise<T, B>

where T: Numeric, B: Backend,

pub fn transpose(&self) -> <TensorPromise<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> TensorPromise<T, B>

where T: Numeric, B: Backend,

pub fn transpose_axes( &self, axes: &[usize], ) -> Result<<TensorPromise<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> TensorPromise<T, B>

where T: Numeric, B: Backend,

pub fn as_contiguous( &self, ) -> <TensorPromise<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> TensorPromise<T, B>

where T: Numeric, B: Backend,

pub fn broadcast( &self, shape: &[usize], ) -> Result<<TensorPromise<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> TensorPromise<T, B>

where T: FloatLike, B: Backend,

pub fn exp(&self) -> <TensorPromise<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> TensorPromise<T, B>

where T: FloatLike, B: Backend,

pub fn ln(&self) -> <TensorPromise<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> TensorPromise<T, B>

where T: FloatLike, B: Backend,

pub fn log2(&self) -> <TensorPromise<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> TensorPromise<T, B>

where T: FloatLike, B: Backend,

pub fn relu(&self) -> <TensorPromise<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> TensorPromise<T, B>

where T: FloatLike, B: Backend,

pub fn tanh(&self) -> <TensorPromise<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> TensorPromise<T, B>

where T: CanMatMul, B: Backend,

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

where D: Operand<T, B>, TensorPromise<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> TensorPromise<T, B>

where T: NumericOp, B: Backend,

pub fn sum(&self) -> <TensorPromise<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> TensorPromise<T, B>

where T: NumericOp, B: Backend,

pub fn sum_axis( &self, axis: isize, keep_dims: bool, ) -> Result<<TensorPromise<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> TensorPromise<T, B>

where T: NumericOp, B: Backend,

pub fn max(&self) -> <TensorPromise<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> TensorPromise<T, B>

where T: NumericOp, B: Backend,

pub fn max_axis( &self, axis: isize, keep_dims: bool, ) -> Result<<TensorPromise<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> TensorPromise<T, B>

where T: FloatLike, B: Backend,

pub fn mean(&self) -> <TensorPromise<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> TensorPromise<T, B>

where T: FloatLike, B: Backend,

pub fn mean_axis( &self, axis: isize, keep_dims: bool, ) -> Result<<TensorPromise<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: Numeric, B: Backend> TensorPromise<T, B>

pub fn cache(self) -> CachedTensorPromise<T, B>

Convert this promise into a CachedTensorPromise that stores its result after the first evaluation.

Internally this wraps self in a NoOp cache node, so the original graph is unchanged - caching is layered on top, not baked in. The NoOp is used to stop the fusion layer from skipping the cache.

Examples

use candela::Tensor;

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

// Safe to use multiple times; result is computed only once.
let _ = (&cached * 2.0).materialize();
let _ = (&cached + 1.0).materialize();

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

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

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

This is where the work actually happens. The planner analyses the graph, assigns buffers, and then the executor runs each op in dependency order, freeing intermediate results as soon as they’re no longer needed.

Examples

use candela::Tensor;

let t = Tensor::from_scalar(4.0_f64, &[3]);
let result = (t - 1.0).materialize();
assert_eq!(result.data(), &vec![3.0; 3]);

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

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

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

Examples

use candela::Tensor;

let t = Tensor::from_scalar(4.0_f64, &[3]).to_promise();
let result1 = t.clone_and_materialize();
let result2 = t.materialize(); // consumes t
assert_eq!(result1.data(), result2.data());

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 TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 &TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 &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<&SkeletonPromise<T, B>> for &TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 &TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 &TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 &Tensor<T, B>

where T: NumericOp, B: Backend, Tensor<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 = <Tensor<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 Tensor<T, B>

where T: NumericOp, B: Backend, Tensor<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 = <Tensor<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 &TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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.

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<&TensorPromise<T, B>> for &BakedPromise<T, B>

where T: NumericOp, B: Backend, BakedPromise<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 = <BakedPromise<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 BakedPromise<T, B>

where T: NumericOp, B: Backend, BakedPromise<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 = <BakedPromise<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 &SkeletonSlot<T, B>

where T: NumericOp, B: Backend, SkeletonSlot<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 = <SkeletonSlot<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 SkeletonSlot<T, B>

where T: NumericOp, B: Backend, SkeletonSlot<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 = <SkeletonSlot<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 &SkeletonPromise<T, B>

where T: NumericOp, B: Backend, SkeletonPromise<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 = <SkeletonPromise<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 SkeletonPromise<T, B>

where T: NumericOp, B: Backend, SkeletonPromise<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 = <SkeletonPromise<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 &TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 &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<SkeletonPromise<T, B>> for &TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 &TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<T, B> as BinaryResult<SkeletonSlot<T, B>, T, B>>::Output

The resulting type after applying the + operator.

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

where T: NumericOp, B: Backend,

type Output = <TensorPromise<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 TensorPromise<T, B>

where T: NumericOp, B: Backend,

type Output = <TensorPromise<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 &TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 &Tensor<T, B>

where T: NumericOp, B: Backend, Tensor<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 = <Tensor<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 Tensor<T, B>

where T: NumericOp, B: Backend, Tensor<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 = <Tensor<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 &TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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<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 &BakedPromise<T, B>

where T: NumericOp, B: Backend, BakedPromise<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 = <BakedPromise<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 BakedPromise<T, B>

where T: NumericOp, B: Backend, BakedPromise<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 = <BakedPromise<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 &SkeletonSlot<T, B>

where T: NumericOp, B: Backend, SkeletonSlot<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 = <SkeletonSlot<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 SkeletonSlot<T, B>

where T: NumericOp, B: Backend, SkeletonSlot<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 = <SkeletonSlot<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 &SkeletonPromise<T, B>

where T: NumericOp, B: Backend, SkeletonPromise<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 = <SkeletonPromise<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 SkeletonPromise<T, B>

where T: NumericOp, B: Backend, SkeletonPromise<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 = <SkeletonPromise<T, B> as BinaryResult<TensorPromise<T, B>, T, B>>::Output

The resulting type after applying the + operator.

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

where T: NumericOp, B: Backend,

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

Performs the += operation.

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

where T: NumericOp, B: Backend,

fn add_assign(&mut self, rhs: &BakedPromise<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> AddAssign<&Tensor<T, B>> for TensorPromise<T, B>

where T: NumericOp, B: Backend,

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

Performs the += operation.

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

where T: NumericOp, B: Backend,

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

Performs the += operation.

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

where T: NumericOp, B: Backend,

fn add_assign(&mut self, rhs: BakedPromise<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> AddAssign<T> for TensorPromise<T, B>

where T: NumericOp, B: Backend,

fn add_assign(&mut self, rhs: T)

Performs the += operation.

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

where T: NumericOp, B: Backend,

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

Performs the += operation.

impl<T, B: Backend> Clone for TensorPromise<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 TensorPromise<T, B>

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

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

Formats the value using the given formatter.

impl<T, B: Backend> Dimension for TensorPromise<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 TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 &TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 &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<&SkeletonPromise<T, B>> for &TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 &TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 &TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 &Tensor<T, B>

where T: NumericOp, B: Backend, Tensor<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 = <Tensor<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 Tensor<T, B>

where T: NumericOp, B: Backend, Tensor<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 = <Tensor<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 &TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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.

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<&TensorPromise<T, B>> for &BakedPromise<T, B>

where T: NumericOp, B: Backend, BakedPromise<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 = <BakedPromise<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 BakedPromise<T, B>

where T: NumericOp, B: Backend, BakedPromise<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 = <BakedPromise<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 &SkeletonSlot<T, B>

where T: NumericOp, B: Backend, SkeletonSlot<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 = <SkeletonSlot<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 SkeletonSlot<T, B>

where T: NumericOp, B: Backend, SkeletonSlot<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 = <SkeletonSlot<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 &SkeletonPromise<T, B>

where T: NumericOp, B: Backend, SkeletonPromise<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 = <SkeletonPromise<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 SkeletonPromise<T, B>

where T: NumericOp, B: Backend, SkeletonPromise<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 = <SkeletonPromise<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 &TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 &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<SkeletonPromise<T, B>> for &TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 &TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<T, B> as BinaryResult<SkeletonSlot<T, B>, T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> Div<T> for &TensorPromise<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 = <TensorPromise<T, B> as UnaryResult<T, B>>::Output

The resulting type after applying the / operator.

impl<T, B> Div<T> for TensorPromise<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 = <TensorPromise<T, B> as UnaryResult<T, B>>::Output

The resulting type after applying the / operator.

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

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 &Tensor<T, B>

where T: NumericOp, B: Backend, Tensor<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 = <Tensor<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 Tensor<T, B>

where T: NumericOp, B: Backend, Tensor<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 = <Tensor<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 &TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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<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 &BakedPromise<T, B>

where T: NumericOp, B: Backend, BakedPromise<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 = <BakedPromise<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 BakedPromise<T, B>

where T: NumericOp, B: Backend, BakedPromise<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 = <BakedPromise<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 &SkeletonSlot<T, B>

where T: NumericOp, B: Backend, SkeletonSlot<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 = <SkeletonSlot<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 SkeletonSlot<T, B>

where T: NumericOp, B: Backend, SkeletonSlot<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 = <SkeletonSlot<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 &SkeletonPromise<T, B>

where T: NumericOp, B: Backend, SkeletonPromise<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 = <SkeletonPromise<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 SkeletonPromise<T, B>

where T: NumericOp, B: Backend, SkeletonPromise<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 = <SkeletonPromise<T, B> as BinaryResult<TensorPromise<T, B>, T, B>>::Output

The resulting type after applying the / operator.

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

where T: NumericOp, B: Backend,

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

Performs the /= operation.

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

where T: NumericOp, B: Backend,

fn div_assign(&mut self, rhs: &BakedPromise<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> DivAssign<&Tensor<T, B>> for TensorPromise<T, B>

where T: NumericOp, B: Backend,

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

Performs the /= operation.

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

where T: NumericOp, B: Backend,

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

Performs the /= operation.

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

where T: NumericOp, B: Backend,

fn div_assign(&mut self, rhs: BakedPromise<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> DivAssign<T> for TensorPromise<T, B>

where T: NumericOp, B: Backend,

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

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

where T: NumericOp, B: Backend,

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

Performs the /= operation.

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

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 &TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 &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<&SkeletonPromise<T, B>> for &TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 &TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 &TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 &Tensor<T, B>

where T: NumericOp, B: Backend, Tensor<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 = <Tensor<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 Tensor<T, B>

where T: NumericOp, B: Backend, Tensor<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 = <Tensor<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 &TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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.

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<&TensorPromise<T, B>> for &BakedPromise<T, B>

where T: NumericOp, B: Backend, BakedPromise<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 = <BakedPromise<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 BakedPromise<T, B>

where T: NumericOp, B: Backend, BakedPromise<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 = <BakedPromise<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 &SkeletonSlot<T, B>

where T: NumericOp, B: Backend, SkeletonSlot<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 = <SkeletonSlot<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 SkeletonSlot<T, B>

where T: NumericOp, B: Backend, SkeletonSlot<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 = <SkeletonSlot<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 &SkeletonPromise<T, B>

where T: NumericOp, B: Backend, SkeletonPromise<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 = <SkeletonPromise<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 SkeletonPromise<T, B>

where T: NumericOp, B: Backend, SkeletonPromise<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 = <SkeletonPromise<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 &TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 &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<SkeletonPromise<T, B>> for &TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 &TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<T, B> as BinaryResult<SkeletonSlot<T, B>, T, B>>::Output

The resulting type after applying the * operator.

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

where T: NumericOp, B: Backend,

type Output = <TensorPromise<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 TensorPromise<T, B>

where T: NumericOp, B: Backend,

type Output = <TensorPromise<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 &TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 &Tensor<T, B>

where T: NumericOp, B: Backend, Tensor<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 = <Tensor<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 Tensor<T, B>

where T: NumericOp, B: Backend, Tensor<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 = <Tensor<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 &TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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<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 &BakedPromise<T, B>

where T: NumericOp, B: Backend, BakedPromise<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 = <BakedPromise<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 BakedPromise<T, B>

where T: NumericOp, B: Backend, BakedPromise<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 = <BakedPromise<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 &SkeletonSlot<T, B>

where T: NumericOp, B: Backend, SkeletonSlot<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 = <SkeletonSlot<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 SkeletonSlot<T, B>

where T: NumericOp, B: Backend, SkeletonSlot<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 = <SkeletonSlot<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 &SkeletonPromise<T, B>

where T: NumericOp, B: Backend, SkeletonPromise<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 = <SkeletonPromise<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 SkeletonPromise<T, B>

where T: NumericOp, B: Backend, SkeletonPromise<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 = <SkeletonPromise<T, B> as BinaryResult<TensorPromise<T, B>, T, B>>::Output

The resulting type after applying the * operator.

impl<T, B> MulAssign for TensorPromise<T, B>

where T: NumericOp, B: Backend,

fn mul_assign(&mut self, rhs: TensorPromise<T, B>)

Performs the *= operation.

impl<T, B> MulAssign<&BakedPromise<T, B>> for TensorPromise<T, B>

where T: NumericOp, B: Backend,

fn mul_assign(&mut self, rhs: &BakedPromise<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> MulAssign<&Tensor<T, B>> for TensorPromise<T, B>

where T: NumericOp, B: Backend,

fn mul_assign(&mut self, rhs: &Tensor<T, B>)

Performs the *= operation.

impl<T, B> MulAssign<&TensorPromise<T, B>> for TensorPromise<T, B>

where T: NumericOp, B: Backend,

fn mul_assign(&mut self, rhs: &TensorPromise<T, B>)

Performs the *= operation.

impl<T, B> MulAssign<BakedPromise<T, B>> for TensorPromise<T, B>

where T: NumericOp, B: Backend,

fn mul_assign(&mut self, rhs: BakedPromise<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> MulAssign<T> for TensorPromise<T, B>

where T: NumericOp, B: Backend,

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<T, B> MulAssign<Tensor<T, B>> for TensorPromise<T, B>

where T: NumericOp, B: Backend,

fn mul_assign(&mut self, rhs: Tensor<T, B>)

Performs the *= operation.

impl<T, B> Sub for TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 &TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 &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<&SkeletonPromise<T, B>> for &TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 &TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 &TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 &Tensor<T, B>

where T: NumericOp, B: Backend, Tensor<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 = <Tensor<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 Tensor<T, B>

where T: NumericOp, B: Backend, Tensor<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 = <Tensor<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 &TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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.

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<&TensorPromise<T, B>> for &BakedPromise<T, B>

where T: NumericOp, B: Backend, BakedPromise<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 = <BakedPromise<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 BakedPromise<T, B>

where T: NumericOp, B: Backend, BakedPromise<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 = <BakedPromise<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 &SkeletonSlot<T, B>

where T: NumericOp, B: Backend, SkeletonSlot<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 = <SkeletonSlot<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 SkeletonSlot<T, B>

where T: NumericOp, B: Backend, SkeletonSlot<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 = <SkeletonSlot<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 &SkeletonPromise<T, B>

where T: NumericOp, B: Backend, SkeletonPromise<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 = <SkeletonPromise<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 SkeletonPromise<T, B>

where T: NumericOp, B: Backend, SkeletonPromise<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 = <SkeletonPromise<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 &TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 &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<SkeletonPromise<T, B>> for &TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 &TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<T, B> as BinaryResult<SkeletonSlot<T, B>, T, B>>::Output

The resulting type after applying the - operator.

impl<T, B> Sub<T> for &TensorPromise<T, B>

where T: NumericOp + Neg<Output = T>, B: Backend,

type Output = <TensorPromise<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 TensorPromise<T, B>

where T: NumericOp + Neg<Output = T>, B: Backend,

type Output = <TensorPromise<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 &TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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 &Tensor<T, B>

where T: NumericOp, B: Backend, Tensor<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 = <Tensor<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 Tensor<T, B>

where T: NumericOp, B: Backend, Tensor<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 = <Tensor<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 &TensorPromise<T, B>

where T: NumericOp, B: Backend, TensorPromise<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 = <TensorPromise<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<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 &BakedPromise<T, B>

where T: NumericOp, B: Backend, BakedPromise<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 = <BakedPromise<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 BakedPromise<T, B>

where T: NumericOp, B: Backend, BakedPromise<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 = <BakedPromise<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 &SkeletonSlot<T, B>

where T: NumericOp, B: Backend, SkeletonSlot<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 = <SkeletonSlot<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 SkeletonSlot<T, B>

where T: NumericOp, B: Backend, SkeletonSlot<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 = <SkeletonSlot<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 &SkeletonPromise<T, B>

where T: NumericOp, B: Backend, SkeletonPromise<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 = <SkeletonPromise<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 SkeletonPromise<T, B>

where T: NumericOp, B: Backend, SkeletonPromise<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 = <SkeletonPromise<T, B> as BinaryResult<TensorPromise<T, B>, T, B>>::Output

The resulting type after applying the - operator.

impl<T, B> SubAssign for TensorPromise<T, B>

where T: NumericOp, B: Backend,

fn sub_assign(&mut self, rhs: TensorPromise<T, B>)

Performs the -= operation.

impl<T, B> SubAssign<&BakedPromise<T, B>> for TensorPromise<T, B>

where T: NumericOp, B: Backend,

fn sub_assign(&mut self, rhs: &BakedPromise<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.

impl<T, B> SubAssign<&Tensor<T, B>> for TensorPromise<T, B>

where T: NumericOp, B: Backend,

fn sub_assign(&mut self, rhs: &Tensor<T, B>)

Performs the -= operation.

impl<T, B> SubAssign<&TensorPromise<T, B>> for TensorPromise<T, B>

where T: NumericOp, B: Backend,

fn sub_assign(&mut self, rhs: &TensorPromise<T, B>)

Performs the -= operation.

impl<T, B> SubAssign<BakedPromise<T, B>> for TensorPromise<T, B>

where T: NumericOp, B: Backend,

fn sub_assign(&mut self, rhs: BakedPromise<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.

impl<T, B> SubAssign<T> for TensorPromise<T, B>

where T: NumericOp + Neg<Output = T>, B: Backend,

fn sub_assign(&mut self, rhs: T)

Performs the -= operation.

impl<T, B> SubAssign<Tensor<T, B>> for TensorPromise<T, B>

where T: NumericOp, B: Backend,

fn sub_assign(&mut self, rhs: Tensor<T, B>)

Performs the -= operation.