Struct SkeletonSlot 

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

The input slots of a Skeleton.

Represents the inputs of a Skeleton and prevents constructing graphs that cannot be safely materialized. A slot supports all the operations of a Tensor, but produces a SkeletonPromise instead of a TensorPromise; that promise is then baked - akin to .materialize() - through into_skeleton.

Examples

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

// A slot stands in for a [4] input; the graph is planned once here...
let slot = SkeletonSlot::from_shape(&[4]);
let skeleton = (&slot * 2.0 + 1.0).into_skeleton(&[slot])?;

// ...then run against as many real tensors as you like.
let out = skeleton.run(&[&Tensor::from_slice(&[0.0, 1.0, 2.0, 3.0], &[4])])?;
assert_eq!(out.data(), &[1.0, 3.0, 5.0, 7.0]);

Implementations

impl<T, B: Backend> SkeletonSlot<T, B>

pub fn new(layout: Layout) -> Self

Creates a new input slot with the given Layout.

Examples

use candela::skeleton::SkeletonSlot;
use candela::{Dimension, Layout};

let slot: SkeletonSlot<f64> = SkeletonSlot::new(Layout::new(&[2, 3]));
assert_eq!(slot.shape(), &[2, 3]);

pub fn deep_clone(&self) -> Self

A deep clone of a Slot

Equivalent to creating a new slot with the same layout as the old one. If you just need to reuse the slot use clone instead.

Examples

use candela::skeleton::SkeletonSlot;
use candela::Dimension;

let a: SkeletonSlot<f64> = SkeletonSlot::from_shape(&[4]);
let b = a.deep_clone(); // independent slot, same layout
assert_eq!(a.shape(), b.shape());

impl<T> SkeletonSlot<T, DefaultBackend>

pub fn from_shape(shape: &[usize]) -> Self

Creates a new contiguous input slot with the given shape.

A shorthand for SkeletonSlot::new(Layout::new(shape)).

Examples

use candela::skeleton::SkeletonSlot;
use candela::Dimension;

let slot: SkeletonSlot<f64> = SkeletonSlot::from_shape(&[2, 3]);
assert_eq!(slot.shape(), &[2, 3]);
assert!(slot.is_contiguous());

impl<T, B> SkeletonSlot<T, B>

where T: Numeric, B: Backend,

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

where T: Numeric, B: Backend,

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

where T: Numeric, B: Backend,

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

where T: Numeric, B: Backend,

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

where T: Numeric, B: Backend,

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

where T: Numeric, B: Backend,

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

where T: FloatLike, B: Backend,

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

where T: FloatLike, B: Backend,

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

where T: FloatLike, B: Backend,

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

where T: FloatLike, B: Backend,

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

where T: FloatLike, B: Backend,

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

where T: CanMatMul, B: Backend,

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

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

where T: NumericOp, B: Backend,

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

where T: NumericOp, B: Backend,

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

where T: NumericOp, B: Backend,

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

where T: NumericOp, B: Backend,

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

where T: FloatLike, B: Backend,

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

where T: FloatLike, B: Backend,

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

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

The resulting type after applying the + operator.

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

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

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

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

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

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

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

Panics

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

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

The resulting type after applying the + operator.

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

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

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

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

Panics

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

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

The resulting type after applying the + operator.

impl<T, B> Add<&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<&SkeletonSlot<T, B>> for &Tensor<T, B>

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

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

The resulting type after applying the + operator.

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

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

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

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

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

Panics

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

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

The resulting type after applying the + operator.

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

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

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

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

Panics

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

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

The resulting type after applying the + operator.

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

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

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

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

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

Panics

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

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

The resulting type after applying the + operator.

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

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

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

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

Panics

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

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

The resulting type after applying the + operator.

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

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

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

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

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

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 &SkeletonSlot<T, B>

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

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

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

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

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

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

Panics

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

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

The resulting type after applying the + operator.

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

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

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

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

Panics

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

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

The resulting type after applying the + operator.

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

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

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

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

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

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

Panics

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

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

The resulting type after applying the + operator.

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

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

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

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

Panics

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

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

The resulting type after applying the + operator.

impl<T, B> Add<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<SkeletonSlot<T, B>> for &Tensor<T, B>

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

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

The resulting type after applying the + operator.

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

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

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

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

Panics

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

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

The resulting type after applying the + operator.

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

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

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

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

Panics

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

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

The resulting type after applying the + operator.

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

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

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

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

Panics

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

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

The resulting type after applying the + operator.

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

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

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

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

Panics

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

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

The resulting type after applying the + operator.

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

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

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

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

where T: NumericOp, B: Backend,

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

where T: NumericOp, B: Backend,

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

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

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

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

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

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

Panics

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

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

The resulting type after applying the + operator.

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

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

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

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

Panics

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

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

The resulting type after applying the + operator.

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

fn clone(&self) -> Self

A shallow clone of a Slot

The copy is equivalent to the slot it was copied from. If you want a new slot with the same layout, use deep_clone instead.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

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

The resulting type after applying the / operator.

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

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

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

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

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

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

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

Panics

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

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

The resulting type after applying the / operator.

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

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

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

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

Panics

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

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

The resulting type after applying the / operator.

impl<T, B> Div<&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<&SkeletonSlot<T, B>> for &Tensor<T, B>

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

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

The resulting type after applying the / operator.

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

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

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

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

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

Panics

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

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

The resulting type after applying the / operator.

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

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

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

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

Panics

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

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

The resulting type after applying the / operator.

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

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

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

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

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

Panics

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

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

The resulting type after applying the / operator.

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

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

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

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

Panics

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

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

The resulting type after applying the / operator.

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

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

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

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

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

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 &SkeletonSlot<T, B>

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

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

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

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

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

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

Panics

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

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

The resulting type after applying the / operator.

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

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

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

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

Panics

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

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

The resulting type after applying the / operator.

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

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

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

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

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

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

Panics

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

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

The resulting type after applying the / operator.

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

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

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

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

Panics

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

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

The resulting type after applying the / operator.

impl<T, B> Div<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<SkeletonSlot<T, B>> for &Tensor<T, B>

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

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

The resulting type after applying the / operator.

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

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

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

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

Panics

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

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

The resulting type after applying the / operator.

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

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

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

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

Panics

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

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

The resulting type after applying the / operator.

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

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

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

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

Panics

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

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

The resulting type after applying the / operator.

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

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

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

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

Panics

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

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

The resulting type after applying the / operator.

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

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

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

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

The resulting type after applying the / operator.

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

The resulting type after applying the / operator.

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

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

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

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

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

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

Panics

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

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

The resulting type after applying the / operator.

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

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

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

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

Panics

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

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

The resulting type after applying the / operator.

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

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

The resulting type after applying the * operator.

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

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

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

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

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

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

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

Panics

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

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

The resulting type after applying the * operator.

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

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

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

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

Panics

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

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

The resulting type after applying the * operator.

impl<T, B> Mul<&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<&SkeletonSlot<T, B>> for &Tensor<T, B>

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

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

The resulting type after applying the * operator.

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

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

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

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

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

Panics

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

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

The resulting type after applying the * operator.

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

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

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

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

Panics

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

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

The resulting type after applying the * operator.

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

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

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

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

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

Panics

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

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

The resulting type after applying the * operator.

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

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

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

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

Panics

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

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

The resulting type after applying the * operator.

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

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

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

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

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

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 &SkeletonSlot<T, B>

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

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

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

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

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

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

Panics

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

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

The resulting type after applying the * operator.

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

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

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

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

Panics

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

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

The resulting type after applying the * operator.

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

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

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

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

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

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

Panics

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

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

The resulting type after applying the * operator.

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

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

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

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

Panics

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

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

The resulting type after applying the * operator.

impl<T, B> Mul<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<SkeletonSlot<T, B>> for &Tensor<T, B>

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

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

The resulting type after applying the * operator.

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

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

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

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

Panics

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

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

The resulting type after applying the * operator.

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

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

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

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

Panics

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

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

The resulting type after applying the * operator.

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

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

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

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

Panics

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

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

The resulting type after applying the * operator.

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

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

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

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

Panics

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

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

The resulting type after applying the * operator.

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

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

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

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

where T: NumericOp, B: Backend,

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

where T: NumericOp, B: Backend,

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

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

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

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

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

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

Panics

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

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

The resulting type after applying the * operator.

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

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

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

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

Panics

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

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

The resulting type after applying the * operator.

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

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

The resulting type after applying the - operator.

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

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

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

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

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

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

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

Panics

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

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

The resulting type after applying the - operator.

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

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

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

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

Panics

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

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

The resulting type after applying the - operator.

impl<T, B> Sub<&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<&SkeletonSlot<T, B>> for &Tensor<T, B>

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

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

The resulting type after applying the - operator.

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

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

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

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

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

Panics

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

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

The resulting type after applying the - operator.

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

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

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

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

Panics

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

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

The resulting type after applying the - operator.

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

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

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

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

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

Panics

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

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

The resulting type after applying the - operator.

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

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

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

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

Panics

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

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

The resulting type after applying the - operator.

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

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

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

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

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

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 &SkeletonSlot<T, B>

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

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

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

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

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

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

Panics

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

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

The resulting type after applying the - operator.

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

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

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

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

Panics

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

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

The resulting type after applying the - operator.

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

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

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

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

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

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

Panics

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

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

The resulting type after applying the - operator.

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

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

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

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

Panics

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

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

The resulting type after applying the - operator.

impl<T, B> Sub<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<SkeletonSlot<T, B>> for &Tensor<T, B>

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

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

The resulting type after applying the - operator.

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

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

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

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

Panics

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

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

The resulting type after applying the - operator.

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

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

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

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

Panics

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

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

The resulting type after applying the - operator.

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

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

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

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

Panics

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

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

The resulting type after applying the - operator.

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

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

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

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

Panics

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

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

The resulting type after applying the - operator.

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

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

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

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

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

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

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

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

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

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

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

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

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

Panics

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

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

The resulting type after applying the - operator.

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

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

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

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

Panics

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

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

The resulting type after applying the - operator.