Struct SkeletonPromise 

pub struct SkeletonPromise<T, B: Backend>(/* private fields */);

A computation with at least one SkeletonSlot in its lineage.

This is the “tainted” sibling of TensorPromise: every op that touches a slot yields one of these instead of a TensorPromise, and it deliberately has no materialize - the only way out is into_skeleton, which binds the slots and compiles the plan.

Implementations

impl<T: ComputeFor<B>, B: Backend> SkeletonPromise<T, B>

pub fn into_skeleton( self, slots: &[SkeletonSlot<T, B>], ) -> Result<Skeleton<T, B>, OpError>

Bakes the recorded computation into a reusable Skeleton.

slots must be the list of slots used during the construction of this graph. Their order is the order Skeleton::run and Skeleton::compose expect their inputs.

Planning happens once, during the construction of the skeleton.

Examples

use candela::skeleton::SkeletonSlot;
use candela::Tensor;

let slot = SkeletonSlot::from_shape(&[4]);
// Building over the slot yields a SkeletonPromise; into_skeleton compiles it.
let skeleton = (&slot + 10.0).into_skeleton(&[slot])?;

let out = skeleton.run(&[&Tensor::from_slice(&[0.0, 1.0, 2.0, 3.0], &[4])])?;
assert_eq!(out.data(), &[10.0, 11.0, 12.0, 13.0]);

Errors

Returns OpError::IncorrectSlotAmount if the number of slots differs from the number the computation depends on, or OpError::NotSameSlot if a provided slot was never used while building it.

impl<T, B> SkeletonPromise<T, B>

where T: Numeric, B: Backend,

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

where T: Numeric, B: Backend,

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

where T: Numeric, B: Backend,

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

where T: Numeric, B: Backend,

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

where T: Numeric, B: Backend,

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

where T: Numeric, B: Backend,

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

where T: FloatLike, B: Backend,

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

where T: FloatLike, B: Backend,

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

where T: FloatLike, B: Backend,

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

where T: FloatLike, B: Backend,

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

where T: FloatLike, B: Backend,

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

where T: CanMatMul, B: Backend,

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

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

where T: NumericOp, B: Backend,

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

where T: NumericOp, B: Backend,

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

where T: NumericOp, B: Backend,

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

where T: NumericOp, B: Backend,

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

where T: FloatLike, B: Backend,

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

where T: FloatLike, B: Backend,

pub fn mean_axis( &self, axis: isize, keep_dims: bool, ) -> Result<<SkeletonPromise<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.

Trait Implementations

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

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

The resulting type after applying the + operator.

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

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

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

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

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

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

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

Panics

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

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

The resulting type after applying the + operator.

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

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

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

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

Panics

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

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

The resulting type after applying the + operator.

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

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

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

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<&SkeletonPromise<T, B>> for &CachedTensorPromise<T, B>

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

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

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

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

Panics

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

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

The resulting type after applying the + operator.

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

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

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

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

Panics

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

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

The resulting type after applying the + operator.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Panics

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

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

The resulting type after applying the + operator.

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

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

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

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

Panics

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

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

The resulting type after applying the + operator.

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

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

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

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

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

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

Panics

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

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

The resulting type after applying the + operator.

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

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

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

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

Panics

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

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

The resulting type after applying the + operator.

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

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

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

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

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

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

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

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

The resulting type after applying the + operator.

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

where T: NumericOp, B: Backend,

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

where T: NumericOp, B: Backend,

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

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

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

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

Formats the value using the given formatter.

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

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

The resulting type after applying the / operator.

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

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

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

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

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

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

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

Panics

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

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

The resulting type after applying the / operator.

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

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

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

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

Panics

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

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

The resulting type after applying the / operator.

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

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

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

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<&SkeletonPromise<T, B>> for &CachedTensorPromise<T, B>

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

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

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

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

Panics

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

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

The resulting type after applying the / operator.

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

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

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

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

Panics

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

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

The resulting type after applying the / operator.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Panics

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

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

The resulting type after applying the / operator.

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

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

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

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

Panics

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

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

The resulting type after applying the / operator.

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

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

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

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

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

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

Panics

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

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

The resulting type after applying the / operator.

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

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

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

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

Panics

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

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

The resulting type after applying the / operator.

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

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

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

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

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

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

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

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

The resulting type after applying the / operator.

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

The resulting type after applying the / operator.

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

The resulting type after applying the / operator.

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

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

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

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

The resulting type after applying the * operator.

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

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

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

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

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

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

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

Panics

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

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

The resulting type after applying the * operator.

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

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

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

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

Panics

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

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

The resulting type after applying the * operator.

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

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

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

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<&SkeletonPromise<T, B>> for &CachedTensorPromise<T, B>

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

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

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

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

Panics

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

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

The resulting type after applying the * operator.

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

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

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

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

Panics

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

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

The resulting type after applying the * operator.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Panics

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

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

The resulting type after applying the * operator.

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

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

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

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

Panics

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

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

The resulting type after applying the * operator.

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

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

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

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

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

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

Panics

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

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

The resulting type after applying the * operator.

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

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

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

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

Panics

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

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

The resulting type after applying the * operator.

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

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

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

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

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

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

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

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

The resulting type after applying the * operator.

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

where T: NumericOp, B: Backend,

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

where T: NumericOp, B: Backend,

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

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

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

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

The resulting type after applying the - operator.

impl<T, B> Sub<&BakedPromise<T, B>> for &SkeletonPromise<T, B>

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

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

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

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

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

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

Panics

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

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

The resulting type after applying the - operator.

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

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

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

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

Panics

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

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

The resulting type after applying the - operator.

impl<T, B> Sub<&SkeletonPromise<T, B>> for &Tensor<T, B>

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

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

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<&SkeletonPromise<T, B>> for &CachedTensorPromise<T, B>

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

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

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

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

Panics

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

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

The resulting type after applying the - operator.

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

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

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

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

Panics

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

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

The resulting type after applying the - operator.

impl<T, B> Sub<&SkeletonPromise<T, B>> for &BakedPromise<T, B>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Panics

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

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

The resulting type after applying the - operator.

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

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

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

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

Panics

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

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

The resulting type after applying the - operator.

impl<T, B> Sub<SkeletonPromise<T, B>> for &Tensor<T, B>

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

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

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

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

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

Panics

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

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

The resulting type after applying the - operator.

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

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

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

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

Panics

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

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

The resulting type after applying the - operator.

impl<T, B> Sub<SkeletonPromise<T, B>> for &BakedPromise<T, B>

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

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

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

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

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

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

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

The resulting type after applying the - operator.

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

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

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

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

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

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

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