Struct zyx::tensor::Tensor

pub struct Tensor<S, GradFn> { /* private fields */ }

Tensor

Tensor holds data and grad_fn to calculate gradients of Variables. Tensor is only created as a result of some operations on at least one Variable. Tensor does not store it’s gradient, but the gradient can be accessed during backward pass by using GradHookT.

Implementations

impl<S, F> Tensor<S, F>where
    S: Ones + GetShape,
    F: Backward<S>,

pub fn backward(self)

Tensor backward

Calls backward function on Tensor. Computes gradient of all Variables that were used as inputs to operations that resulted in creation of this Tensor. This function accumulates gradients in those Variables. If you want to clear Variable’s gradients, call Parameters::zero_grad() on that Variable.

Example

let x = cpu::Buffer::cfrom([2., 3., 1.]).with_grad();
let y = x.exp();

y is now Tensor, so we can call backward on it.

y.backward();

and the gradient of Variable x will now get populated:

assert_eq!(x.grad().to_vec(), x.data().clone().exp().to_vec());

impl<S, GradFn> Tensor<S, GradFn>

pub fn data(&self) -> &S

Access Tensor’s data buffer

impl<S, GradFn> Tensor<S, GradFn>

pub fn register_hook<HOOK>(
    self,
    hook: HOOK
) -> Tensor<S, GradHookT<GradFn, HOOK>>where
    HOOK: FnOnce(S),

Add custom FnOnce closure that will receive Buffer’s gradient during backward pass The hook is stored in the result, so make sure to do all operations on this result, otherwise your hook will not be called.

Trait Implementations

impl<'g, XS, YS, XF> Add<&'g Variable<YS>> for Tensor<XS, XF>where
    XS: Add<YS> + DType,
    YS: Clone + DType,

type Output = Tensor<<XS as Add<YS>>::Output, AddBackwardTV<'g, YS, XF>>

The resulting type after applying the + operator.

fn add(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the + operation.

impl<S, F> Add<Tensor<S, F>> for Buffer<bool>where
    Self: Add<S>,
    S: DType,

type Output = Tensor<<Buffer<bool> as Add<S>>::Output, F>

The resulting type after applying the + operator.

fn add(self, rhs: Tensor<S, F>) -> Self::Output

Performs the + operation.

impl<S, F> Add<Tensor<S, F>> for Buffer<f32>where
    Self: Add<S>,
    S: DType,

type Output = Tensor<<Buffer<f32> as Add<S>>::Output, F>

The resulting type after applying the + operator.

fn add(self, rhs: Tensor<S, F>) -> Self::Output

Performs the + operation.

impl<S, F> Add<Tensor<S, F>> for Buffer<f64>where
    Self: Add<S>,
    S: DType,

type Output = Tensor<<Buffer<f64> as Add<S>>::Output, F>

The resulting type after applying the + operator.

fn add(self, rhs: Tensor<S, F>) -> Self::Output

Performs the + operation.

impl<S, F> Add<Tensor<S, F>> for Buffer<i128>where
    Self: Add<S>,
    S: DType,

type Output = Tensor<<Buffer<i128> as Add<S>>::Output, F>

The resulting type after applying the + operator.

fn add(self, rhs: Tensor<S, F>) -> Self::Output

Performs the + operation.

impl<S, F> Add<Tensor<S, F>> for Buffer<i32>where
    Self: Add<S>,
    S: DType,

type Output = Tensor<<Buffer<i32> as Add<S>>::Output, F>

The resulting type after applying the + operator.

fn add(self, rhs: Tensor<S, F>) -> Self::Output

Performs the + operation.

impl<S, F> Add<Tensor<S, F>> for Buffer<i64>where
    Self: Add<S>,
    S: DType,

type Output = Tensor<<Buffer<i64> as Add<S>>::Output, F>

The resulting type after applying the + operator.

fn add(self, rhs: Tensor<S, F>) -> Self::Output

Performs the + operation.

impl<S, F> Add<Tensor<S, F>> for Buffer<u128>where
    Self: Add<S>,
    S: DType,

type Output = Tensor<<Buffer<u128> as Add<S>>::Output, F>

The resulting type after applying the + operator.

fn add(self, rhs: Tensor<S, F>) -> Self::Output

Performs the + operation.

impl<S, F> Add<Tensor<S, F>> for Buffer<u16>where
    Self: Add<S>,
    S: DType,

type Output = Tensor<<Buffer<u16> as Add<S>>::Output, F>

The resulting type after applying the + operator.

fn add(self, rhs: Tensor<S, F>) -> Self::Output

Performs the + operation.

impl<S, F> Add<Tensor<S, F>> for Buffer<u32>where
    Self: Add<S>,
    S: DType,

type Output = Tensor<<Buffer<u32> as Add<S>>::Output, F>

The resulting type after applying the + operator.

fn add(self, rhs: Tensor<S, F>) -> Self::Output

Performs the + operation.

impl<S, F> Add<Tensor<S, F>> for Buffer<u64>where
    Self: Add<S>,
    S: DType,

type Output = Tensor<<Buffer<u64> as Add<S>>::Output, F>

The resulting type after applying the + operator.

fn add(self, rhs: Tensor<S, F>) -> Self::Output

Performs the + operation.

impl<S, F> Add<Tensor<S, F>> for Buffer<u8>where
    Self: Add<S>,
    S: DType,

type Output = Tensor<<Buffer<u8> as Add<S>>::Output, F>

The resulting type after applying the + operator.

fn add(self, rhs: Tensor<S, F>) -> Self::Output

Performs the + operation.

impl<S, F> Add<Tensor<S, F>> for boolwhere
    Self: Add<S>,
    S: DType,

type Output = Tensor<<bool as Add<S>>::Output, F>

The resulting type after applying the + operator.

fn add(self, rhs: Tensor<S, F>) -> Self::Output

Performs the + operation.

impl<S, F> Add<Tensor<S, F>> for f32where
    Self: Add<S>,
    S: DType,

type Output = Tensor<<f32 as Add<S>>::Output, F>

The resulting type after applying the + operator.

fn add(self, rhs: Tensor<S, F>) -> Self::Output

Performs the + operation.

impl<S, F> Add<Tensor<S, F>> for f64where
    Self: Add<S>,
    S: DType,

type Output = Tensor<<f64 as Add<S>>::Output, F>

The resulting type after applying the + operator.

fn add(self, rhs: Tensor<S, F>) -> Self::Output

Performs the + operation.

impl<S, F> Add<Tensor<S, F>> for i128where
    Self: Add<S>,
    S: DType,

type Output = Tensor<<i128 as Add<S>>::Output, F>

The resulting type after applying the + operator.

fn add(self, rhs: Tensor<S, F>) -> Self::Output

Performs the + operation.

impl<S, F> Add<Tensor<S, F>> for i16where
    Self: Add<S>,
    S: DType,

type Output = Tensor<<i16 as Add<S>>::Output, F>

The resulting type after applying the + operator.

fn add(self, rhs: Tensor<S, F>) -> Self::Output

Performs the + operation.

impl<S, F> Add<Tensor<S, F>> for i32where
    Self: Add<S>,
    S: DType,

type Output = Tensor<<i32 as Add<S>>::Output, F>

The resulting type after applying the + operator.

fn add(self, rhs: Tensor<S, F>) -> Self::Output

Performs the + operation.

impl<S, F> Add<Tensor<S, F>> for i64where
    Self: Add<S>,
    S: DType,

type Output = Tensor<<i64 as Add<S>>::Output, F>

The resulting type after applying the + operator.

fn add(self, rhs: Tensor<S, F>) -> Self::Output

Performs the + operation.

impl<S, F> Add<Tensor<S, F>> for i8where
    Self: Add<S>,
    S: DType,

type Output = Tensor<<i8 as Add<S>>::Output, F>

The resulting type after applying the + operator.

fn add(self, rhs: Tensor<S, F>) -> Self::Output

Performs the + operation.

impl<S, F> Add<Tensor<S, F>> for isizewhere
    Self: Add<S>,
    S: DType,

type Output = Tensor<<isize as Add<S>>::Output, F>

The resulting type after applying the + operator.

fn add(self, rhs: Tensor<S, F>) -> Self::Output

Performs the + operation.

impl<S, F> Add<Tensor<S, F>> for u128where
    Self: Add<S>,
    S: DType,

type Output = Tensor<<u128 as Add<S>>::Output, F>

The resulting type after applying the + operator.

fn add(self, rhs: Tensor<S, F>) -> Self::Output

Performs the + operation.

impl<S, F> Add<Tensor<S, F>> for u16where
    Self: Add<S>,
    S: DType,

type Output = Tensor<<u16 as Add<S>>::Output, F>

The resulting type after applying the + operator.

fn add(self, rhs: Tensor<S, F>) -> Self::Output

Performs the + operation.

impl<S, F> Add<Tensor<S, F>> for u32where
    Self: Add<S>,
    S: DType,

type Output = Tensor<<u32 as Add<S>>::Output, F>

The resulting type after applying the + operator.

fn add(self, rhs: Tensor<S, F>) -> Self::Output

Performs the + operation.

impl<S, F> Add<Tensor<S, F>> for u64where
    Self: Add<S>,
    S: DType,

type Output = Tensor<<u64 as Add<S>>::Output, F>

The resulting type after applying the + operator.

fn add(self, rhs: Tensor<S, F>) -> Self::Output

Performs the + operation.

impl<S, F> Add<Tensor<S, F>> for u8where
    Self: Add<S>,
    S: DType,

type Output = Tensor<<u8 as Add<S>>::Output, F>

The resulting type after applying the + operator.

fn add(self, rhs: Tensor<S, F>) -> Self::Output

Performs the + operation.

impl<S, F> Add<Tensor<S, F>> for usizewhere
    Self: Add<S>,
    S: DType,

type Output = Tensor<<usize as Add<S>>::Output, F>

The resulting type after applying the + operator.

fn add(self, rhs: Tensor<S, F>) -> Self::Output

Performs the + operation.

impl<'g, XS, YS, YF> Add<Tensor<YS, YF>> for &'g Variable<XS>where
    XS: Clone + Add<YS>,
    YS: 'g,

type Output = Tensor<<XS as Add<YS>>::Output, AddBackwardVT<'g, XS, YF>>

The resulting type after applying the + operator.

fn add(self, rhs: Tensor<YS, YF>) -> Self::Output

Performs the + operation.

impl<XS, YS, XF, YF> Add<Tensor<YS, YF>> for Tensor<XS, XF>where
    XS: Add<YS> + DType,
    YS: DType,

type Output = Tensor<<XS as Add<YS>>::Output, AddBackwardTT<XF, YF>>

The resulting type after applying the + operator.

fn add(self, rhs: Tensor<YS, YF>) -> Self::Output

Performs the + operation.

impl<XS, YS, F> Add<YS> for Tensor<XS, F>where
    XS: Add<YS> + DType,
    YS: DType,

type Output = Tensor<<XS as Add<YS>>::Output, F>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<S: Clone, GradFn: Clone> Clone for Tensor<S, GradFn>

fn clone(&self) -> Tensor<S, GradFn>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S, S2, GradFn> ConvertFrom<Tensor<S2, GradFn>> for Tensor<S, GradFn>where
    S: ConvertFrom<S2>,

Conversions between devices and types

fn cfrom(x: Tensor<S2, GradFn>) -> Self

Converts input into output type

impl<S: Debug, GradFn: Debug> Debug for Tensor<S, GradFn>

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

Formats the value using the given formatter.

impl<S: Default, GradFn: Default> Default for Tensor<S, GradFn>

fn default() -> Tensor<S, GradFn>

Returns the “default value” for a type.

impl<S, GradFn> Display for Tensor<S, GradFn>where
    S: Display,
    GradFn: Debug,

Display Tensor

Shows Tensor and it’s grad_fn.

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

Formats the value using the given formatter.

impl<'g, XS, YS, XF> Div<&'g Variable<YS>> for Tensor<XS, XF>where
    XS: Div<YS> + DType,
    YS: Clone + DType,
    <XS as Div<YS>>::Output: Clone,

type Output = Tensor<<XS as Div<YS>>::Output, DivBackwardTV<'g, <XS as Div<YS>>::Output, YS, YS, XF>>

The resulting type after applying the / operator.

fn div(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the / operation.

impl<S, S2, F> Div<S2> for Tensor<S, F>where
    S2: DType + Clone,
    S: Clone + Div<S2>,

type Output = Tensor<<S as Div<S2>>::Output, DivBackwardTS<S2, F>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<F> Div<Tensor<Buffer<f32>, F>> for i32

type Output = Tensor<<i32 as Div<Buffer<f32>>>::Output, DivBackwardST<<i32 as Div<Buffer<f32>>>::Output, Buffer<f32>, F>>

The resulting type after applying the / operator.

fn div(self, rhs: Tensor<Buffer<f32>, F>) -> Self::Output

Performs the / operation.

impl<'g, XS, YS, YF> Div<Tensor<YS, YF>> for &'g Variable<XS>where
    XS: Clone + Div<YS>,
    YS: Clone,
    <XS as Div<YS>>::Output: Clone,

type Output = Tensor<<XS as Div<YS>>::Output, DivBackwardVT<'g, <XS as Div<YS>>::Output, XS, YS, YF>>

The resulting type after applying the / operator.

fn div(self, rhs: Tensor<YS, YF>) -> Self::Output

Performs the / operation.

impl<XS, YS, XF, YF> Div<Tensor<YS, YF>> for Tensor<XS, XF>where
    XS: Div<YS>,
    YS: Clone,
    <XS as Div<YS>>::Output: Clone,

type Output = Tensor<<XS as Div<YS>>::Output, DivBackwardTT<YS, <XS as Div<YS>>::Output, XF, YF>>

The resulting type after applying the / operator.

fn div(self, rhs: Tensor<YS, YF>) -> Self::Output

Performs the / operation.

impl<S, S2, F> Exp for Tensor<S, F>where
    S: Exp<Output = S2>,
    S2: Clone,

type Output = Tensor<S2, ExpBackwardT<S2, F>>

Output of the Exp operation.

fn exp(self) -> Self::Output

Apply Exp operation on given input.

impl<S, F> Expand for Tensor<S, F>where
    S: Expand + GetShape,
    F: Backward<S>,

type Output = Tensor<<S as Expand>::Output, ExpandBackwardT<F>>

Output of the Expand operation.

fn expand(self, shape: impl IntoShape) -> Self::Output

Apply Expand operation on given input.

impl<S, F> GetShape for Tensor<S, F>where
    S: GetShape,

fn shape(&self) -> Shape

Get shape of input tensor.

impl<S, F, T> IntoVec<T> for Tensor<S, F>where
    S: IntoVec<T>,

fn to_vec(&self) -> Vec<T>

Returns values from tensor as a Vec with row-major order.

impl<S, F> Ln for Tensor<S, F>where
    S: Clone + Ln,

type Output = Tensor<<S as Ln>::Output, LnBackwardT<S, F>>

Output of the Ln operation.

fn ln(self) -> Self::Output

Apply Ln operation on given input.

impl<'g, XS, XF, YS> MatMul<&'g Variable<YS>> for Tensor<XS, XF>where
    XS: Clone + MatMul<YS>,
    YS: Clone,

type Output = Tensor<<XS as MatMul<YS>>::Output, MatMulBackwardTV<'g, YS, XS, YS, XF>>

Output of the MatMul operation.

fn matmul(self, rhs: &'g Variable<YS>) -> Self::Output

Apply MatMul operation on given input.

impl<'g, XS, YS, YF> MatMul<Tensor<YS, YF>> for &'g Variable<XS>where
    XS: Clone + MatMul<YS>,
    YS: Clone,

type Output = Tensor<<XS as MatMul<YS>>::Output, MatMulBackwardVT<'g, XS, XS, YS, YF>>

Output of the MatMul operation.

fn matmul(self, rhs: Tensor<YS, YF>) -> Self::Output

Apply MatMul operation on given input.

impl<XS, YS, XF, YF> MatMul<Tensor<YS, YF>> for Tensor<XS, XF>where
    XS: Clone + MatMul<YS>,
    YS: Clone,

type Output = Tensor<<XS as MatMul<YS>>::Output, MatMulBackwardTT<XS, YS, XF, YF>>

Output of the MatMul operation.

fn matmul(self, rhs: Tensor<YS, YF>) -> Self::Output

Apply MatMul operation on given input.

impl<XS, YS, XF> MatMul<YS> for Tensor<XS, XF>where
    XS: MatMul<YS>,
    YS: Clone + DType,

type Output = Tensor<<XS as MatMul<YS>>::Output, MatMulBackwardTS<YS, XF>>

Output of the MatMul operation.

fn matmul(self, rhs: YS) -> Self::Output

Apply MatMul operation on given input.

impl<S, F> Max for Tensor<S, F>where
    S: Max + GetShape,

type Output = Tensor<<S as Max>::Output, MaxBackwardT<F>>

Output of the Max operation.

fn max(self, dims: impl IntoDims) -> Self::Output

Apply Max operation on given input.

impl<S, F> Min for Tensor<S, F>where
    S: Min + GetShape,
    F: Backward<S>,

type Output = Tensor<<S as Min>::Output, MinBackwardT<F>>

Output of the Min operation.

fn min(self, dims: impl IntoDims) -> Self::Output

Apply Min operation on given input.

impl<'g, XS, YS, XF> Mul<&'g Variable<YS>> for Tensor<XS, XF>where
    XS: Clone + Mul<YS>,
    YS: Clone,

type Output = Tensor<<XS as Mul<YS>>::Output, MulBackwardTV<'g, XS, YS, YS, XF>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the * operation.

impl<S, F> Mul<Tensor<S, F>> for Buffer<bool>where
    Self: Mul<S>,

type Output = Tensor<<Buffer<bool> as Mul<S>>::Output, MulBackwardST<Buffer<bool>, F>>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<S, F>) -> Self::Output

Performs the * operation.

impl<S, F> Mul<Tensor<S, F>> for Buffer<f32>where
    Self: Mul<S>,

type Output = Tensor<<Buffer<f32> as Mul<S>>::Output, MulBackwardST<Buffer<f32>, F>>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<S, F>) -> Self::Output

Performs the * operation.

impl<S, F> Mul<Tensor<S, F>> for Buffer<f64>where
    Self: Mul<S>,

type Output = Tensor<<Buffer<f64> as Mul<S>>::Output, MulBackwardST<Buffer<f64>, F>>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<S, F>) -> Self::Output

Performs the * operation.

impl<S, F> Mul<Tensor<S, F>> for Buffer<i128>where
    Self: Mul<S>,

type Output = Tensor<<Buffer<i128> as Mul<S>>::Output, MulBackwardST<Buffer<i128>, F>>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<S, F>) -> Self::Output

Performs the * operation.

impl<S, F> Mul<Tensor<S, F>> for Buffer<i32>where
    Self: Mul<S>,

type Output = Tensor<<Buffer<i32> as Mul<S>>::Output, MulBackwardST<Buffer<i32>, F>>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<S, F>) -> Self::Output

Performs the * operation.

impl<S, F> Mul<Tensor<S, F>> for Buffer<i64>where
    Self: Mul<S>,

type Output = Tensor<<Buffer<i64> as Mul<S>>::Output, MulBackwardST<Buffer<i64>, F>>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<S, F>) -> Self::Output

Performs the * operation.

impl<S, F> Mul<Tensor<S, F>> for Buffer<u128>where
    Self: Mul<S>,

type Output = Tensor<<Buffer<u128> as Mul<S>>::Output, MulBackwardST<Buffer<u128>, F>>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<S, F>) -> Self::Output

Performs the * operation.

impl<S, F> Mul<Tensor<S, F>> for Buffer<u16>where
    Self: Mul<S>,

type Output = Tensor<<Buffer<u16> as Mul<S>>::Output, MulBackwardST<Buffer<u16>, F>>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<S, F>) -> Self::Output

Performs the * operation.

impl<S, F> Mul<Tensor<S, F>> for Buffer<u32>where
    Self: Mul<S>,

type Output = Tensor<<Buffer<u32> as Mul<S>>::Output, MulBackwardST<Buffer<u32>, F>>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<S, F>) -> Self::Output

Performs the * operation.

impl<S, F> Mul<Tensor<S, F>> for Buffer<u64>where
    Self: Mul<S>,

type Output = Tensor<<Buffer<u64> as Mul<S>>::Output, MulBackwardST<Buffer<u64>, F>>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<S, F>) -> Self::Output

Performs the * operation.

impl<S, F> Mul<Tensor<S, F>> for Buffer<u8>where
    Self: Mul<S>,

type Output = Tensor<<Buffer<u8> as Mul<S>>::Output, MulBackwardST<Buffer<u8>, F>>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<S, F>) -> Self::Output

Performs the * operation.

impl<'g, XS, YS, F> Mul<Tensor<YS, F>> for &'g Variable<XS>where
    XS: Clone + Mul<YS>,
    YS: Clone,

type Output = Tensor<<XS as Mul<YS>>::Output, MulBackwardVT<'g, XS, XS, YS, F>>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<YS, F>) -> Self::Output

Performs the * operation.

impl<XS, YS, XF, YF> Mul<Tensor<YS, YF>> for Tensor<XS, XF>where
    XS: Clone + Mul<YS>,
    YS: Clone,

type Output = Tensor<<XS as Mul<YS>>::Output, MulBackwardTT<XS, YS, XF, YF>>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<YS, YF>) -> Self::Output

Performs the * operation.

impl<YS, YF> Mul<Tensor<YS, YF>> for boolwhere
    Self: Mul<YS>,

type Output = Tensor<<bool as Mul<YS>>::Output, MulBackwardST<bool, YF>>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<YS, YF>) -> Self::Output

Performs the * operation.

impl<YS, YF> Mul<Tensor<YS, YF>> for f32where
    Self: Mul<YS>,

type Output = Tensor<<f32 as Mul<YS>>::Output, MulBackwardST<f32, YF>>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<YS, YF>) -> Self::Output

Performs the * operation.

impl<YS, YF> Mul<Tensor<YS, YF>> for f64where
    Self: Mul<YS>,

type Output = Tensor<<f64 as Mul<YS>>::Output, MulBackwardST<f64, YF>>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<YS, YF>) -> Self::Output

Performs the * operation.

impl<YS, YF> Mul<Tensor<YS, YF>> for i128where
    Self: Mul<YS>,

type Output = Tensor<<i128 as Mul<YS>>::Output, MulBackwardST<i128, YF>>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<YS, YF>) -> Self::Output

Performs the * operation.

impl<YS, YF> Mul<Tensor<YS, YF>> for i16where
    Self: Mul<YS>,

type Output = Tensor<<i16 as Mul<YS>>::Output, MulBackwardST<i16, YF>>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<YS, YF>) -> Self::Output

Performs the * operation.

impl<YS, YF> Mul<Tensor<YS, YF>> for i32where
    Self: Mul<YS>,

type Output = Tensor<<i32 as Mul<YS>>::Output, MulBackwardST<i32, YF>>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<YS, YF>) -> Self::Output

Performs the * operation.

impl<YS, YF> Mul<Tensor<YS, YF>> for i64where
    Self: Mul<YS>,

type Output = Tensor<<i64 as Mul<YS>>::Output, MulBackwardST<i64, YF>>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<YS, YF>) -> Self::Output

Performs the * operation.

impl<YS, YF> Mul<Tensor<YS, YF>> for i8where
    Self: Mul<YS>,

type Output = Tensor<<i8 as Mul<YS>>::Output, MulBackwardST<i8, YF>>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<YS, YF>) -> Self::Output

Performs the * operation.

impl<YS, YF> Mul<Tensor<YS, YF>> for isizewhere
    Self: Mul<YS>,

type Output = Tensor<<isize as Mul<YS>>::Output, MulBackwardST<isize, YF>>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<YS, YF>) -> Self::Output

Performs the * operation.

impl<YS, YF> Mul<Tensor<YS, YF>> for u128where
    Self: Mul<YS>,

type Output = Tensor<<u128 as Mul<YS>>::Output, MulBackwardST<u128, YF>>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<YS, YF>) -> Self::Output

Performs the * operation.

impl<YS, YF> Mul<Tensor<YS, YF>> for u16where
    Self: Mul<YS>,

type Output = Tensor<<u16 as Mul<YS>>::Output, MulBackwardST<u16, YF>>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<YS, YF>) -> Self::Output

Performs the * operation.

impl<YS, YF> Mul<Tensor<YS, YF>> for u32where
    Self: Mul<YS>,

type Output = Tensor<<u32 as Mul<YS>>::Output, MulBackwardST<u32, YF>>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<YS, YF>) -> Self::Output

Performs the * operation.

impl<YS, YF> Mul<Tensor<YS, YF>> for u64where
    Self: Mul<YS>,

type Output = Tensor<<u64 as Mul<YS>>::Output, MulBackwardST<u64, YF>>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<YS, YF>) -> Self::Output

Performs the * operation.

impl<YS, YF> Mul<Tensor<YS, YF>> for u8where
    Self: Mul<YS>,

type Output = Tensor<<u8 as Mul<YS>>::Output, MulBackwardST<u8, YF>>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<YS, YF>) -> Self::Output

Performs the * operation.

impl<YS, YF> Mul<Tensor<YS, YF>> for usizewhere
    Self: Mul<YS>,

type Output = Tensor<<usize as Mul<YS>>::Output, MulBackwardST<usize, YF>>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<YS, YF>) -> Self::Output

Performs the * operation.

impl<XS, YS, F> Mul<YS> for Tensor<XS, F>where
    XS: Mul<YS>,
    YS: DType + Clone,

type Output = Tensor<<XS as Mul<YS>>::Output, MulBackwardTS<YS, F>>

The resulting type after applying the * operator.

fn mul(self, rhs: YS) -> Self::Output

Performs the * operation.

impl<S, F> Neg for Tensor<S, F>where
    S: Neg,

type Output = Tensor<<S as Neg>::Output, NegBackwardT<F>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<S: Ord, GradFn: Ord> Ord for Tensor<S, GradFn>

fn cmp(&self, other: &Tensor<S, GradFn>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl<S: PartialEq, GradFn: PartialEq> PartialEq<Tensor<S, GradFn>> for Tensor<S, GradFn>

fn eq(&self, other: &Tensor<S, GradFn>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<S: PartialOrd, GradFn: PartialOrd> PartialOrd<Tensor<S, GradFn>> for Tensor<S, GradFn>

fn partial_cmp(&self, other: &Tensor<S, GradFn>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<S, F> Permute for Tensor<S, F>where
    S: Permute,

type Output = Tensor<<S as Permute>::Output, PermuteBackwardT<F>>

Output of the Permute operation.

fn permute(self, dims: impl IntoDims) -> Self::Output

Apply Permute operation on given input.

impl<'g, XS, YS, XF> Pow<&'g Variable<YS>> for Tensor<XS, XF>where
    XS: Clone + Pow<YS> + Ln,
    YS: Clone + Mul<<XS as Pow<YS>>::Output>,
    <XS as Pow<YS>>::Output: Clone,
    <YS as Mul<<XS as Pow<YS>>::Output>>::Output: Div<XS>,
    <XS as Pow<YS>>::Output: Mul<<XS as Ln>::Output>,

type Output = Tensor<<XS as Pow<YS>>::Output, PowBackwardTV<'g, YS, <<YS as Mul<<XS as Pow<YS>>::Output>>::Output as Div<XS>>::Output, <<XS as Pow<YS>>::Output as Mul<<XS as Ln>::Output>>::Output, XF>>

Output of the Pow operation.

fn pow(self, rhs: &'g Variable<YS>) -> Self::Output

Apply Pow operation on given input.

impl<S, S2, F> Pow<S2> for Tensor<S, F>where
    S: Clone + Pow<S2>,
    S2: DType + Clone + Mul<<S as Pow<S2>>::Output>,
    <S as Pow<S2>>::Output: Clone,
    <S2 as Mul<<S as Pow<S2>>::Output>>::Output: Div<S>,

type Output = Tensor<<S as Pow<S2>>::Output, PowBackwardTS<<<S2 as Mul<<S as Pow<S2>>::Output>>::Output as Div<S>>::Output, F>>

Output of the Pow operation.

fn pow(self, rhs: S2) -> Self::Output

Apply Pow operation on given input.

impl<S, XF, YF> Pow<Tensor<S, YF>> for Tensor<S, XF>where
    S: Clone + Mul<Output = S> + Div<Output = S> + Pow<Output = S> + Ln<Output = S>,

type Output = Tensor<S, PowBackwardTT<S, XF, YF>>

Output of the Pow operation.

fn pow(self, rhs: Tensor<S, YF>) -> Self::Output

Apply Pow operation on given input.

impl<'g, XS, YS, YF> Pow<Tensor<YS, YF>> for &'g Variable<XS>where
    XS: Clone + Pow<YS> + Ln,
    YS: Clone + Mul<<XS as Pow<YS>>::Output>,
    <XS as Pow<YS>>::Output: Clone,
    <YS as Mul<<XS as Pow<YS>>::Output>>::Output: Div<XS>,
    <XS as Pow<YS>>::Output: Mul<<XS as Ln>::Output>,

type Output = Tensor<<XS as Pow<YS>>::Output, PowBackwardVT<'g, XS, <<YS as Mul<<XS as Pow<YS>>::Output>>::Output as Div<XS>>::Output, <<XS as Pow<YS>>::Output as Mul<<XS as Ln>::Output>>::Output, YF>>

Output of the Pow operation.

fn pow(self, rhs: Tensor<YS, YF>) -> Self::Output

Apply Pow operation on given input.

impl<S, F> ReLU for Tensor<S, F>where
    S: Clone + ReLU,

type Output = Tensor<<S as ReLU>::Output, ReLUBackwardT<S, F>>

Output of the ReLU operation.

fn relu(self) -> Self::Output

Apply ReLU operation on given input.

impl<S, F> Reshape for Tensor<S, F>where
    S: Reshape + GetShape,

type Output = Tensor<<S as Reshape>::Output, ReshapeBackwardT<F>>

Output of the Reshape operation.

fn reshape(self, res_shape: impl IntoShape) -> Self::Output

Apply Reshape operation on given input.

impl<'g, XS, YS, XF> Sub<&'g Variable<YS>> for Tensor<XS, XF>where
    XS: Clone + Sub<YS>,
    YS: Clone,

type Output = Tensor<<XS as Sub<YS>>::Output, SubBackwardTV<'g, YS, XF>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the - operation.

impl<S, F> Sub<Tensor<S, F>> for Buffer<bool>where
    Self: Sub<S>,
    S: DType,

type Output = Tensor<<Buffer<bool> as Sub<S>>::Output, F>

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor<S, F>) -> Self::Output

Performs the - operation.

impl<S, F> Sub<Tensor<S, F>> for Buffer<f32>where
    Self: Sub<S>,
    S: DType,

type Output = Tensor<<Buffer<f32> as Sub<S>>::Output, F>

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor<S, F>) -> Self::Output

Performs the - operation.

impl<S, F> Sub<Tensor<S, F>> for Buffer<f64>where
    Self: Sub<S>,
    S: DType,

type Output = Tensor<<Buffer<f64> as Sub<S>>::Output, F>

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor<S, F>) -> Self::Output

Performs the - operation.

impl<S, F> Sub<Tensor<S, F>> for Buffer<i128>where
    Self: Sub<S>,
    S: DType,

type Output = Tensor<<Buffer<i128> as Sub<S>>::Output, F>

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor<S, F>) -> Self::Output

Performs the - operation.

impl<S, F> Sub<Tensor<S, F>> for Buffer<i32>where
    Self: Sub<S>,
    S: DType,

type Output = Tensor<<Buffer<i32> as Sub<S>>::Output, F>

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor<S, F>) -> Self::Output

Performs the - operation.

impl<S, F> Sub<Tensor<S, F>> for Buffer<i64>where
    Self: Sub<S>,
    S: DType,

type Output = Tensor<<Buffer<i64> as Sub<S>>::Output, F>

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor<S, F>) -> Self::Output

Performs the - operation.

impl<S, F> Sub<Tensor<S, F>> for Buffer<u128>where
    Self: Sub<S>,
    S: DType,

type Output = Tensor<<Buffer<u128> as Sub<S>>::Output, F>

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor<S, F>) -> Self::Output

Performs the - operation.

impl<S, F> Sub<Tensor<S, F>> for Buffer<u16>where
    Self: Sub<S>,
    S: DType,

type Output = Tensor<<Buffer<u16> as Sub<S>>::Output, F>

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor<S, F>) -> Self::Output

Performs the - operation.

impl<S, F> Sub<Tensor<S, F>> for Buffer<u32>where
    Self: Sub<S>,
    S: DType,

type Output = Tensor<<Buffer<u32> as Sub<S>>::Output, F>

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor<S, F>) -> Self::Output

Performs the - operation.

impl<S, F> Sub<Tensor<S, F>> for Buffer<u64>where
    Self: Sub<S>,
    S: DType,

type Output = Tensor<<Buffer<u64> as Sub<S>>::Output, F>

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor<S, F>) -> Self::Output

Performs the - operation.

impl<S, F> Sub<Tensor<S, F>> for Buffer<u8>where
    Self: Sub<S>,
    S: DType,

type Output = Tensor<<Buffer<u8> as Sub<S>>::Output, F>

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor<S, F>) -> Self::Output

Performs the - operation.

impl<S, F> Sub<Tensor<S, F>> for boolwhere
    Self: Sub<S>,
    S: DType,

type Output = Tensor<<bool as Sub<S>>::Output, F>

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor<S, F>) -> Self::Output

Performs the - operation.

impl<S, F> Sub<Tensor<S, F>> for f32where
    Self: Sub<S>,
    S: DType,

type Output = Tensor<<f32 as Sub<S>>::Output, F>

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor<S, F>) -> Self::Output

Performs the - operation.

impl<S, F> Sub<Tensor<S, F>> for f64where
    Self: Sub<S>,
    S: DType,

type Output = Tensor<<f64 as Sub<S>>::Output, F>

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor<S, F>) -> Self::Output

Performs the - operation.

impl<S, F> Sub<Tensor<S, F>> for i128where
    Self: Sub<S>,
    S: DType,

type Output = Tensor<<i128 as Sub<S>>::Output, F>

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor<S, F>) -> Self::Output

Performs the - operation.

impl<S, F> Sub<Tensor<S, F>> for i16where
    Self: Sub<S>,
    S: DType,

type Output = Tensor<<i16 as Sub<S>>::Output, F>

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor<S, F>) -> Self::Output

Performs the - operation.

impl<S, F> Sub<Tensor<S, F>> for i32where
    Self: Sub<S>,
    S: DType,

type Output = Tensor<<i32 as Sub<S>>::Output, F>

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor<S, F>) -> Self::Output

Performs the - operation.

impl<S, F> Sub<Tensor<S, F>> for i64where
    Self: Sub<S>,
    S: DType,

type Output = Tensor<<i64 as Sub<S>>::Output, F>

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor<S, F>) -> Self::Output

Performs the - operation.

impl<S, F> Sub<Tensor<S, F>> for i8where
    Self: Sub<S>,
    S: DType,

type Output = Tensor<<i8 as Sub<S>>::Output, F>

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor<S, F>) -> Self::Output

Performs the - operation.

impl<S, F> Sub<Tensor<S, F>> for isizewhere
    Self: Sub<S>,
    S: DType,

type Output = Tensor<<isize as Sub<S>>::Output, F>

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor<S, F>) -> Self::Output

Performs the - operation.

impl<S, F> Sub<Tensor<S, F>> for u128where
    Self: Sub<S>,
    S: DType,

type Output = Tensor<<u128 as Sub<S>>::Output, F>

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor<S, F>) -> Self::Output

Performs the - operation.

impl<S, F> Sub<Tensor<S, F>> for u16where
    Self: Sub<S>,
    S: DType,

type Output = Tensor<<u16 as Sub<S>>::Output, F>

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor<S, F>) -> Self::Output

Performs the - operation.

impl<S, F> Sub<Tensor<S, F>> for u32where
    Self: Sub<S>,
    S: DType,

type Output = Tensor<<u32 as Sub<S>>::Output, F>

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor<S, F>) -> Self::Output

Performs the - operation.

impl<S, F> Sub<Tensor<S, F>> for u64where
    Self: Sub<S>,
    S: DType,

type Output = Tensor<<u64 as Sub<S>>::Output, F>

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor<S, F>) -> Self::Output

Performs the - operation.

impl<S, F> Sub<Tensor<S, F>> for u8where
    Self: Sub<S>,
    S: DType,

type Output = Tensor<<u8 as Sub<S>>::Output, F>

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor<S, F>) -> Self::Output

Performs the - operation.

impl<S, F> Sub<Tensor<S, F>> for usizewhere
    Self: Sub<S>,
    S: DType,

type Output = Tensor<<usize as Sub<S>>::Output, F>

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor<S, F>) -> Self::Output

Performs the - operation.

impl<'g, XS, YS, YF> Sub<Tensor<YS, YF>> for &'g Variable<XS>where
    XS: Clone + Sub<YS>,

type Output = Tensor<<XS as Sub<YS>>::Output, SubBackwardVT<'g, XS, YF>>

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor<YS, YF>) -> Self::Output

Performs the - operation.

impl<XS, YS, XF, YF> Sub<Tensor<YS, YF>> for Tensor<XS, XF>where
    XS: Sub<YS>,

type Output = Tensor<<XS as Sub<YS>>::Output, SubBackwardTT<XF, YF>>

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor<YS, YF>) -> Self::Output

Performs the - operation.

impl<XS, YS, XF> Sub<YS> for Tensor<XS, XF>where
    XS: Sub<YS>,
    YS: DType,

type Output = Tensor<<XS as Sub<YS>>::Output, XF>

The resulting type after applying the - operator.

fn sub(self, rhs: YS) -> Self::Output

Performs the - operation.

impl<S, F> Sum for Tensor<S, F>where
    S: Clone + Sum + GetShape,

type Output = Tensor<<S as Sum>::Output, SumBackwardT<F>>

Output of the Sum operation.

fn sum(self, dims: impl IntoDims) -> Self::Output

Apply Sum operation on given input.

impl<S, F> Tanh for Tensor<S, F>where
    S: Tanh,
    <S as Tanh>::Output: Clone,

type Output = Tensor<<S as Tanh>::Output, TanhBackwardT<<S as Tanh>::Output, F>>

Output of the Tanh operation.

fn tanh(self) -> Self::Output

Apply Tanh operation on given input.

impl<S: Eq, GradFn: Eq> Eq for Tensor<S, GradFn>

impl<S, GradFn> StructuralEq for Tensor<S, GradFn>

impl<S, GradFn> StructuralPartialEq for Tensor<S, GradFn>