Struct neuronika::Var

pub struct Var<T: Data + 'static> { /* fields omitted */ }

A non-differentiable variable.

This, together with its differentiable counterpart VarDiff, is the main building block of every computation.

Conceptually, it can be thought of as a ndarray::Array for which the computations are automatically kept track of.

Implementations

impl<D: Dimension> Var<Input<D>>

pub fn requires_grad(self) -> VarDiff<Input<D>, InputBackward<D>>

Promotes self to a differentiable variable. A subsequent call to .backward() will compute its gradient.

Examples

This is the preferred usage.

 use neuronika;

 let x = neuronika::ones(5).requires_grad();

This is also permitted, however, one should be aware of the difference between x_diff and x.

 use neuronika;

 let x = neuronika::ones(5);
 let y = x.clone() + neuronika::ones(1);

 let x_diff = x.requires_grad();

pub fn assign<S: Data<Elem = f32>>(&self, array: &ArrayBase<S, D>)

Assigns array to the variable’s data.

Arguments

array - new content.

impl<T: Data + Forward + 'static> Var<T>

pub fn forward(&self)

Propagates the computations forwards and populates all the variables from the leaves of the graph to self.

pub fn train(&self)

This has effect only on certain ancestor variables of self. It sets such variables in training mode.

See also .dropout().

Examples

The following snippet pictures the effect of several calls placed at different locations inside the program. The last call switches all the dropout variables in training mode.

pub fn eval(&self)

This has effect only on certain ancestor variables of self. It sets such variables in evaluation mode.

See also .dropout().

impl<T: Data<Dim = Ix1> + 'static> Var<T>

pub fn vm<Rhs>(self, rhs: Rhs) -> <Self as VecMatMul<Rhs>>::Output where
    Self: VecMatMul<Rhs>, 

Performs a vector-matrix multiplication between the vector variable self and the matrix variable rhs.

If self is n and rhs is (n, m) the output will be m.

pub fn vv<Rhs>(self, rhs: Rhs) -> <Self as VecVecMul<Rhs>>::Output where
    Self: VecVecMul<Rhs>, 

Vector-vector product, a.k.a. scalar product or inner product.

Performs the scalar product between the two vector variables self and rhs.

impl<T: Data<Dim = Ix2> + 'static> Var<T>

pub fn mm<Rhs>(self, rhs: Rhs) -> <Self as MatMatMul<Rhs>>::Output where
    Self: MatMatMul<Rhs>, 

Performs a matrix multiplication between the matrix variables self and rhs. If self is (n, m) and rhs is (m, o) the output will be (n, o).

pub fn mm_t<Rhs>(self, rhs: Rhs) -> <Self as MatMatMulT<Rhs>>::Output where
    Self: MatMatMulT<Rhs>, 

Performs a matrix multiplication between the matrix variables self and rhs. This is a fused operation as rhs is implicitly transposed. Fusing the two operations it’s marginally faster than computing the matrix multiplication and the transposition separately.

If self is (n, m) and rhs is (o, m) the output will be (n, o).

pub fn mv<Rhs>(self, rhs: Rhs) -> <Self as MatVecMul<Rhs>>::Output where
    Self: MatVecMul<Rhs>, 

Performs a matrix-vector multiplication between the matrix variable self and the vector variable rhs.

If self is (n, m) and rhs is m the output will be n.

impl<T: Data + 'static> Var<T>

pub fn data(&self) -> Ref<'_, Array<f32, T::Dim>>

Returns an immutable reference to the data inside self.

At the variable’s creation the data is filled with zeros. You can populate it with a call to .forward().

pub fn data_mut(&self) -> RefMut<'_, Array<f32, T::Dim>>

Returns a mutable reference to the data inside self.

At the variable’s creation the data is filled with zeros. You can populate it with a call to .forward().

pub fn sum(self) -> Var<Sum<T>>

Returns the sum of all elements in self.

pub fn mean(self) -> Var<Mean<T>>

Returns the mean of all elements in self.

pub fn pow(self, exp: i32) -> Var<Power<T>>

Takes the power of each element in self with exponent exp and returns a variable with the result.

pub fn sqrt(self) -> Var<Sqrt<T>>

Takes the square root element-wise and returns a variable with the result.

pub fn relu(self) -> Var<ReLU<T>>

Applies the rectified linear unit element-wise and returns a variable with the result.

ReLU(x) = max(0, x)

pub fn leaky_relu(self) -> Var<LeakyReLU<T>>

Applies the leaky rectified linear unit element-wise and returns a variable with the result.

LeakyReLU(x) = max(0, x) + 0.01 * min(0, x)

pub fn softplus(self) -> Var<SoftPlus<T>>

Applies the softplus element-wise and returns a variable with the result.

Softplus(x) = log(1 + exp(x))

pub fn sigmoid(self) -> Var<Sigmoid<T>>

Applies the sigmoid element-wise and returns a variable with the result.

pub fn tanh(self) -> Var<TanH<T>>

Applies the tanh element-wise and returns a variable with the result.

pub fn ln(self) -> Var<Logn<T>>

Applies the natural logarithm element-wise and returns a variable with the result.

pub fn exp(self) -> Var<Exp<T>>

Applies the exponential element-wise and returns a variable with the result.

pub fn softmax(self, axis: usize) -> Var<Softmax<T>>

Applies the softmax to self and returns a variable with the result.

The softmax is applied to all slices along axis, and will re-scale them so that the elements lie in the range [0, 1] and sum to 1.0.

pub fn log_softmax(self, axis: usize) -> Var<LogSoftmax<T>>

Applies the log-softmax to self and returns a variable with the result.

Applies a softmax followed by a logarithm. While mathematically equivalent to log(softmax(x)), doing these two operations separately is slower, and numerically unstable. This function uses an alternative formulation to compute the output and gradient correctly.

See also .softmax().

pub fn t(self) -> Var<Transpose<T>>

Returns a variable equivalent to self with its dimensions reversed.

pub fn dropout(self, p: f64) -> Var<Dropout<T>>

Applies dropout to self and returns a variable with the result.

It is strongly suggested to use nn::Dropout instead of this method when working with neural networks.

During training, randomly zeroes some of the elements of self with probability p using samples from a Bernoulli distribution. Each channel will be zeroed out independently on every forward call.

This has proven to be an effective technique for regularization and preventing the co-adaptation of neurons as described in the paper Improving neural networks by preventing co-adaptation of feature detectors.

Furthermore, the outputs are scaled by a factor of 1/(1 - p) during training. This means that during evaluation the resulting variable simply computes an identity function.

pub fn chunks<E: IntoDimension<Dim = T::Dim>>(
    self,
    chunk_size: E
) -> Vec<Var<Chunk<T>>>

Splits self into a certain number of chunks of size chunk_size skipping the remainder along each dimension that doesn’t fit evenly.

pub fn unsqueeze(self, axis: usize) -> Var<Unsqueeze<T>>

Returns a new variable with a dimension of size one inserted at the position specified by axis.

impl<T> Var<T> where
    T: Data + 'static,
    T::Dim: RemoveAxis, 

pub fn cat(
    self,
    variables: &[Box<dyn Variable<T::Dim>>],
    axis: usize
) -> Var<MultiConcatenate<T::Dim>>

Concatenates the given sequence of non-differentiable variables variables, including self, along the given axis, and returns a non-differentiable variable with the results.

Arguments

• variables - sequence of non-differentiable variables.

• axis - axis to concatenate along to.

Panics

If the variables have mismatching shapes, apart from along axis, if the variables are empty, if axis is out of bounds or if the result is larger than is possible to represent.

Examples

use std::boxed::Box;
use neuronika;
use ndarray;


let a = neuronika::ones((3, 2));
let b = neuronika::full((3, 2), 4.);
let c = neuronika::full((3, 2), 3.);

let mut d = a.cat(&[Box::new(b), Box::new(c)], 1);
d.forward();

assert_eq!(*d.data(), ndarray::array![[1., 1., 4., 4., 3., 3.],
                                      [1., 1., 4., 4., 3., 3.],
                                      [1., 1., 4., 4., 3., 3.]]);

pub fn stack(
    self,
    variables: &[Box<dyn Variable<T::Dim>>],
    axis: usize
) -> Var<MultiStack<T::Dim>>

Stacks the given sequence of non-differentiable variables variables, including self, along the given axis, and returns a non-differentiable variable with the results.

All variables must have the same shape.

Arguments

• variables - sequence of non-differentiable variables.

• axis - axis to stack along to.

Panics

If the variables have mismatching shapes, apart from along axis, if the variables are empty, if axis is out of bounds or if the result is larger than is possible to represent.

Examples

use std::boxed::Box;
use neuronika;
use ndarray;


let a = neuronika::ones((2, 2));
let b = neuronika::ones((2, 2));
let c = neuronika::ones((2, 2));

let mut d = a.stack(&[Box::new(b), Box::new(c)], 0);
d.forward();

assert_eq!(*d.data(), ndarray::array![[[1., 1.],
                                       [1., 1.]],
                                      [[1., 1.],
                                       [1., 1.]],
                                      [[1., 1.],
                                       [1., 1.]]]);

Trait Implementations

impl<F1, B1, F2> Add<Var<F2>> for VarDiff<F1, B1> where
    F1: Data + 'static,
    F2: Data + 'static,
    B1: Gradient + Overwrite + 'static,
    F1::Dim: Dimension + DimMax<F2::Dim>,
    B1::Dim: Dimension + DimMax<F2::Dim>, 

type Output = VarDiff<Addition<F1, F2>, AdditionBackwardUnary<B1, F2>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<F2>) -> Self::Output

Performs the + operation.

impl<Lhs, Rhs> Add<Var<Rhs>> for Var<Lhs> where
    Lhs: Data + 'static,
    Rhs: Data + 'static,
    Lhs::Dim: Dimension + DimMax<Rhs::Dim>, 

type Output = Var<Addition<Lhs, Rhs>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<Rhs>) -> Self::Output

Performs the + operation.

impl<T> Add<Var<T>> for f32 where
    T: Data + Forward + 'static,
    Ix1: DimMax<T::Dim>, 

type Output = Var<Addition<Input<Ix1>, T>>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<F1, F2, B2> Add<VarDiff<F2, B2>> for Var<F1> where
    F1: Data + 'static,
    F2: Data + 'static,
    B2: Gradient + Overwrite + 'static,
    F1::Dim: Dimension + DimMax<F2::Dim>,
    B2::Dim: Dimension + DimMax<F1::Dim>, 

type Output = VarDiff<Addition<F1, F2>, AdditionBackwardUnary<B2, F1>>

The resulting type after applying the + operator.

fn add(self, rhs: VarDiff<F2, B2>) -> Self::Output

Performs the + operation.

impl<T> Add<f32> for Var<T> where
    T: Data + Forward + 'static,
    T::Dim: DimMax<Ix1>, 

type Output = Var<Addition<T, Input<Ix1>>>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<F1, F2> Cat<Var<F2>> for Var<F1> where
    F1: Data + 'static,
    F2: Data<Dim = F1::Dim> + 'static,
    F1::Dim: RemoveAxis, 

type Output = Var<Concatenate<F1, F2>>

The type of the concatenation’s result. See the differentiability arithmetic for more details.

fn cat(self, rhs: Var<F2>, axis: usize) -> Self::Output

Concatenates variables along the given axis.

impl<F1, B1, F2> Cat<Var<F2>> for VarDiff<F1, B1> where
    F1: Data<Dim = B1::Dim> + 'static,
    F2: Data<Dim = F1::Dim> + 'static,
    B1: Gradient + Overwrite + 'static,
    F1::Dim: RemoveAxis,
    B1::Dim: RemoveAxis, 

type Output = VarDiff<Concatenate<F1, F2>, ConcatenateBackwardLeft<B1>>

The type of the concatenation’s result. See the differentiability arithmetic for more details.

fn cat(self, rhs: Var<F2>, axis: usize) -> Self::Output

Concatenates variables along the given axis.

impl<F1, F2, B2> Cat<VarDiff<F2, B2>> for Var<F1> where
    F1: Data<Dim = B2::Dim> + 'static,
    F2: Data<Dim = F1::Dim> + 'static,
    B2: Gradient + Overwrite + 'static,
    F1::Dim: RemoveAxis,
    B2::Dim: RemoveAxis, 

type Output = VarDiff<Concatenate<F1, F2>, ConcatenateBackwardRight<B2>>

The type of the concatenation’s result. See the differentiability arithmetic for more details.

fn cat(self, rhs: VarDiff<F2, B2>, axis: usize) -> Self::Output

Concatenates variables along the given axis.

impl<T: Data + 'static> Clone for Var<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F1, F2, Pad> Convolve<Var<F1>, Var<F2>, Pad> for Var<F1> where
    F1: NData + 'static,
    F1::Dim: RemoveAxis,
    <F1::Dim as Dimension>::Smaller: RemoveAxis,
    <<F1::Dim as Dimension>::Smaller as Dimension>::Smaller: ReflPad + ReplPad,
    F2: NData<Dim = F1::Dim> + 'static,
    Pad: PaddingMode + 'static, 

type Output = Var<Convolution<F1, F2, Pad>>

The type of the convolution’s result. See the differentiability arithmetic for more details.

fn convolve(
    input: Self,
    kernel: Var<F2>,
    stride: &[usize],
    dilation: &[usize],
    padding: &[usize],
    padding_mode: Pad
) -> Self::Output

Applies a n-dimensional convolution with the given parameters. n can be either 1, 2 or 3.

impl<F1, F2, B2, Pad> Convolve<Var<F1>, VarDiff<F2, B2>, Pad> for Var<F1> where
    F1: NData + 'static,
    F1::Dim: RemoveAxis,
    <F1::Dim as Dimension>::Smaller: RemoveAxis,
    <<F1::Dim as Dimension>::Smaller as Dimension>::Smaller: ReflPad + ReplPad,
    F2: NData<Dim = F1::Dim> + 'static,
    B2: Gradient<Dim = F2::Dim> + Overwrite + Display + Debug,
    Pad: PaddingMode + 'static, 

type Output = VarDiff<Convolution<F1, F2, Pad>, ConvolutionBackwardUnary<F1, B2, Pad>>

The type of the convolution’s result. See the differentiability arithmetic for more details.

fn convolve(
    input: Self,
    kernel: VarDiff<F2, B2>,
    stride: &[usize],
    dilation: &[usize],
    padding: &[usize],
    padding_mode: Pad
) -> Self::Output

Applies a n-dimensional convolution with the given parameters. n can be either 1, 2 or 3.

impl<F1, F2, Pad> ConvolveWithGroups<Var<F1>, Var<F2>, Pad> for Var<F1> where
    F1: NData + 'static,
    F1::Dim: RemoveAxis,
    <F1::Dim as Dimension>::Smaller: RemoveAxis,
    <<F1::Dim as Dimension>::Smaller as Dimension>::Smaller: ReflPad + ReplPad,
    F2: NData<Dim = F1::Dim> + 'static,
    Pad: PaddingMode + 'static, 

type Output = Var<GroupedConvolution<F1, F2, Pad>>

The type of the grouped convolution’s result. See the differentiability arithmetic for more details.

fn convolve_with_groups(
    input: Self,
    kernel: Var<F2>,
    stride: &[usize],
    dilation: &[usize],
    padding: &[usize],
    padding_mode: Pad,
    groups: usize
) -> Self::Output

Applies a n-dimensional grouped convolution with the given parameters. n can be either 1, 2 or 3.

impl<F1, F2, B2, Pad> ConvolveWithGroups<Var<F1>, VarDiff<F2, B2>, Pad> for Var<F1> where
    F1: NData + 'static,
    F1::Dim: RemoveAxis,
    <F1::Dim as Dimension>::Smaller: RemoveAxis,
    <<F1::Dim as Dimension>::Smaller as Dimension>::Smaller: ReflPad + ReplPad,
    F2: NData<Dim = F1::Dim> + 'static,
    B2: Gradient<Dim = F2::Dim> + Overwrite,
    Pad: PaddingMode + 'static, 

type Output = VarDiff<GroupedConvolution<F1, F2, Pad>, GroupedConvolutionBackwardUnary<F1, B2, Pad>>

The type of the grouped convolution’s result. See the differentiability arithmetic for more details.

fn convolve_with_groups(
    input: Self,
    kernel: VarDiff<F2, B2>,
    stride: &[usize],
    dilation: &[usize],
    padding: &[usize],
    padding_mode: Pad,
    groups: usize
) -> Self::Output

Applies a n-dimensional grouped convolution with the given parameters. n can be either 1, 2 or 3.

impl<T: Data + Debug> Debug for Var<T>

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

Formats the value using the given formatter.

impl<T: Data + Display> Display for Var<T>

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

Formats the value using the given formatter.

impl<F1, B1, F2> Div<Var<F2>> for VarDiff<F1, B1> where
    F1: Data + 'static,
    F2: Data + 'static,
    B1: Gradient + Overwrite + 'static,
    F1::Dim: Dimension + DimMax<F2::Dim>,
    B1::Dim: Dimension + DimMax<F2::Dim>, 

type Output = VarDiff<Division<F1, F2>, DivisionBackwardLeft<B1, F2>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<F2>) -> Self::Output

Performs the / operation.

impl<Lhs, Rhs> Div<Var<Rhs>> for Var<Lhs> where
    Lhs: Data + 'static,
    Rhs: Data + 'static,
    Lhs::Dim: Dimension + DimMax<Rhs::Dim>, 

type Output = Var<Division<Lhs, Rhs>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<Rhs>) -> Self::Output

Performs the / operation.

impl<T> Div<Var<T>> for f32 where
    T: Data + Forward + 'static,
    Ix1: DimMax<T::Dim>, 

type Output = Var<Division<Input<Ix1>, T>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<F1, F2, B2> Div<VarDiff<F2, B2>> for Var<F1> where
    F1: Data + 'static,
    F2: Data + 'static,
    B2: Gradient + Overwrite + 'static,
    F1::Dim: Dimension + DimMax<F2::Dim>,
    F1::Dim: Dimension + DimMax<B2::Dim>, 

type Output = VarDiff<Division<F1, F2>, DivisionBackwardRight<F1, F2, B2>>

The resulting type after applying the / operator.

fn div(self, rhs: VarDiff<F2, B2>) -> Self::Output

Performs the / operation.

impl<T> Div<f32> for Var<T> where
    T: Data + Forward + 'static,
    T::Dim: DimMax<Ix1>, 

type Output = Var<Division<T, Input<Ix1>>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T> DropoutInput for Var<T> where
    T: Data + Forward, 

type Output = Var<DropoutNode<T>>

fn dropout(self, p: f64, status: Rc<Cell<bool>>) -> Self::Output

impl<F1, F2> MatMatMul<Var<F2>> for Var<F1> where
    F1: Data<Dim = Ix2> + 'static,
    F2: Data<Dim = Ix2> + 'static, 

type Output = Var<MatrixMatrixMul<F1, F2>>

The type of the matrix-matrix multiplication’s result. See the differentiability arithmetic for more details.

fn mm(self, rhs: Var<F2>) -> Self::Output

Computes the matrix-matrix multiplication between self and other.

impl<F1, B1, F2> MatMatMul<Var<F2>> for VarDiff<F1, B1> where
    F1: Data<Dim = Ix2> + 'static,
    B1: Gradient<Dim = Ix2> + Overwrite + 'static,
    F2: Data<Dim = Ix2> + 'static, 

type Output = VarDiff<MatrixMatrixMul<F1, F2>, MatrixMatrixMulBackwardLeft<B1, F2>>

The type of the matrix-matrix multiplication’s result. See the differentiability arithmetic for more details.

fn mm(self, rhs: Var<F2>) -> Self::Output

Computes the matrix-matrix multiplication between self and other.

impl<F1, F2, B2> MatMatMul<VarDiff<F2, B2>> for Var<F1> where
    F1: Data<Dim = Ix2> + 'static,
    F2: Data<Dim = Ix2> + 'static,
    B2: Gradient<Dim = Ix2> + Overwrite + 'static, 

type Output = VarDiff<MatrixMatrixMul<F1, F2>, MatrixMatrixMulBackwardRight<F1, B2>>

The type of the matrix-matrix multiplication’s result. See the differentiability arithmetic for more details.

fn mm(self, rhs: VarDiff<F2, B2>) -> Self::Output

Computes the matrix-matrix multiplication between self and other.

impl<F1, F2> MatMatMulT<Var<F2>> for Var<F1> where
    F1: Data<Dim = Ix2> + 'static,
    F2: Data<Dim = Ix2> + 'static, 

type Output = Var<MatrixMatrixMulT<F1, F2>>

The type of the matrix-matrix multiplication with transposed right hand side operand’s result. See the differentiability arithmetic for more details.

fn mm_t(self, rhs: Var<F2>) -> Self::Output

Computes the matrix-matrix multiplication between self and transposed other.

impl<F1, B1, F2> MatMatMulT<Var<F2>> for VarDiff<F1, B1> where
    F1: Data<Dim = Ix2> + 'static,
    B1: Gradient<Dim = Ix2> + Overwrite + 'static,
    F2: Data<Dim = Ix2> + 'static, 

type Output = VarDiff<MatrixMatrixMulT<F1, F2>, MatrixMatrixMulTBackwardLeft<B1, F2>>

The type of the matrix-matrix multiplication with transposed right hand side operand’s result. See the differentiability arithmetic for more details.

fn mm_t(self, rhs: Var<F2>) -> Self::Output

Computes the matrix-matrix multiplication between self and transposed other.

impl<F1, F2, B2> MatMatMulT<VarDiff<F2, B2>> for Var<F1> where
    F1: Data<Dim = Ix2> + 'static,
    F2: Data<Dim = Ix2> + 'static,
    B2: Gradient<Dim = Ix2> + Overwrite + 'static, 

type Output = VarDiff<MatrixMatrixMulT<F1, F2>, MatrixMatrixMulTBackwardRight<F1, B2>>

The type of the matrix-matrix multiplication with transposed right hand side operand’s result. See the differentiability arithmetic for more details.

fn mm_t(self, rhs: VarDiff<F2, B2>) -> Self::Output

Computes the matrix-matrix multiplication between self and transposed other.

impl<F1, B1, F2> Mul<Var<F2>> for VarDiff<F1, B1> where
    F1: Data + 'static,
    F2: Data + 'static,
    B1: Gradient + Overwrite + 'static,
    F1::Dim: Dimension + DimMax<F2::Dim>,
    B1::Dim: Dimension + DimMax<F2::Dim>, 

type Output = VarDiff<Multiplication<F1, F2>, MultiplicationBackwardUnary<B1, F2>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<F2>) -> Self::Output

Performs the * operation.

impl<Lhs, Rhs> Mul<Var<Rhs>> for Var<Lhs> where
    Lhs: Data + 'static,
    Rhs: Data + 'static,
    Lhs::Dim: Dimension + DimMax<Rhs::Dim>, 

type Output = Var<Multiplication<Lhs, Rhs>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<Rhs>) -> Self::Output

Performs the * operation.

impl<T> Mul<Var<T>> for f32 where
    T: Data + Forward + 'static,
    Ix1: DimMax<T::Dim>, 

type Output = Var<Multiplication<Input<Ix1>, T>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<F1, F2, B2> Mul<VarDiff<F2, B2>> for Var<F1> where
    F1: Data + 'static,
    F2: Data + 'static,
    B2: Gradient + Overwrite + 'static,
    F1::Dim: Dimension + DimMax<F2::Dim>,
    B2::Dim: Dimension + DimMax<F1::Dim>, 

type Output = VarDiff<Multiplication<F1, F2>, MultiplicationBackwardUnary<B2, F1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VarDiff<F2, B2>) -> Self::Output

Performs the * operation.

impl<T> Mul<f32> for Var<T> where
    T: Data + Forward + 'static,
    T::Dim: DimMax<Ix1>, 

type Output = Var<Multiplication<T, Input<Ix1>>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Data + 'static> Neg for Var<T>

type Output = Var<Negation<T>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<F1, F2> Stack<Var<F2>> for Var<F1> where
    F1: Data + 'static,
    F2: Data<Dim = F1::Dim> + 'static,
    F1::Dim: RemoveAxis, 

type Output = Var<Stack<F1, F2>>

The type of the stacking’s result. See the differentiability arithmetic for more details.

fn stack(self, rhs: Var<F2>, axis: usize) -> Self::Output

Stacks variables along the given axis.

impl<F1, B1, F2> Stack<Var<F2>> for VarDiff<F1, B1> where
    F1: Data<Dim = B1::Dim> + 'static,
    F2: Data<Dim = F1::Dim> + 'static,
    B1: Gradient + Overwrite + 'static,
    F1::Dim: RemoveAxis,
    B1::Dim: RemoveAxis, 

type Output = VarDiff<Stack<F1, F2>, StackBackwardLeft<B1>>

The type of the stacking’s result. See the differentiability arithmetic for more details.

fn stack(self, rhs: Var<F2>, axis: usize) -> Self::Output

Stacks variables along the given axis.

impl<F1, F2, B2> Stack<VarDiff<F2, B2>> for Var<F1> where
    F1: Data + 'static,
    F2: Data<Dim = F1::Dim> + 'static,
    B2: Gradient<Dim = F1::Dim> + Overwrite + 'static,
    B2::Dim: RemoveAxis,
    F1::Dim: RemoveAxis, 

type Output = VarDiff<Stack<F1, F2>, StackBackwardRight<B2>>

The type of the stacking’s result. See the differentiability arithmetic for more details.

fn stack(self, rhs: VarDiff<F2, B2>, axis: usize) -> Self::Output

Stacks variables along the given axis.

impl<F1, B1, F2> Sub<Var<F2>> for VarDiff<F1, B1> where
    F1: Data + 'static,
    F2: Data + 'static,
    B1: Gradient + Overwrite + 'static,
    F1::Dim: Dimension + DimMax<F2::Dim>,
    B1::Dim: Dimension + DimMax<F2::Dim>, 

type Output = VarDiff<Subtraction<F1, F2>, SubtractionBackwardLeft<B1, F2>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<F2>) -> Self::Output

Performs the - operation.

impl<Lhs, Rhs> Sub<Var<Rhs>> for Var<Lhs> where
    Lhs: Data + 'static,
    Rhs: Data + 'static,
    Lhs::Dim: Dimension + DimMax<Rhs::Dim>, 

type Output = Var<Subtraction<Lhs, Rhs>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<Rhs>) -> Self::Output

Performs the - operation.

impl<T> Sub<Var<T>> for f32 where
    T: Data + Forward + 'static,
    Ix1: DimMax<T::Dim>, 

type Output = Var<Subtraction<Input<Ix1>, T>>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<F1, F2, B2> Sub<VarDiff<F2, B2>> for Var<F1> where
    F1: Data + 'static,
    F2: Data + 'static,
    B2: Gradient + Overwrite + 'static,
    F1::Dim: Dimension + DimMax<F2::Dim>,
    B2::Dim: Dimension + DimMax<F1::Dim>, 

type Output = VarDiff<Subtraction<F1, F2>, SubtractionBackwardRight<B2, F1>>

The resulting type after applying the - operator.

fn sub(self, rhs: VarDiff<F2, B2>) -> Self::Output

Performs the - operation.

impl<T> Sub<f32> for Var<T> where
    T: Data + Forward + 'static,
    T::Dim: DimMax<Ix1>, 

type Output = Var<Subtraction<T, Input<Ix1>>>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<F1, F2> VecMatMul<Var<F2>> for Var<F1> where
    F1: Data<Dim = Ix1> + 'static,
    F2: Data<Dim = Ix2> + 'static, 

type Output = Var<VectorMatrixMul<F1, F2>>

The type of the vector-matrix multiplication’s result. See the differentiability arithmetic for more details.

fn vm(self, rhs: Var<F2>) -> Self::Output

Computes the vector-matrix multiplication between self and other.

impl<F1, B1, F2> VecMatMul<Var<F2>> for VarDiff<F1, B1> where
    F1: Data<Dim = Ix1> + 'static,
    B1: Gradient<Dim = Ix1> + Overwrite + 'static,
    F2: Data<Dim = Ix2> + 'static, 

type Output = VarDiff<VectorMatrixMul<F1, F2>, VectorMatrixMulBackwardLeft<B1, F2>>

The type of the vector-matrix multiplication’s result. See the differentiability arithmetic for more details.

fn vm(self, rhs: Var<F2>) -> Self::Output

Computes the vector-matrix multiplication between self and other.

impl<F1, F2, B2> VecMatMul<VarDiff<F2, B2>> for Var<F1> where
    F1: Data<Dim = Ix1> + 'static,
    F2: Data<Dim = Ix2> + 'static,
    B2: Gradient<Dim = Ix2> + Overwrite + 'static, 

type Output = VarDiff<VectorMatrixMul<F1, F2>, VectorMatrixMulBackwardRight<F1, B2>>

The type of the vector-matrix multiplication’s result. See the differentiability arithmetic for more details.

fn vm(self, rhs: VarDiff<F2, B2>) -> Self::Output

Computes the vector-matrix multiplication between self and other.

impl<F1, F2> VecVecMul<Var<F2>> for Var<F1> where
    F1: Data<Dim = Ix1> + 'static,
    F2: Data<Dim = Ix1> + 'static, 

type Output = Var<VectorVectorMul<F1, F2>>

The type of the dot product’s result. See the differentiability arithmetic for more details.

fn vv(self, rhs: Var<F2>) -> Self::Output

Computes the dot product between self and other.

impl<F1, B1, F2> VecVecMul<Var<F2>> for VarDiff<F1, B1> where
    F1: Data<Dim = Ix1> + 'static,
    B1: Gradient<Dim = Ix1> + Overwrite + 'static,
    F2: Data<Dim = Ix1> + 'static, 

type Output = VarDiff<VectorVectorMul<F1, F2>, VectorVectorMulBackwardUnary<B1, F2>>

The type of the dot product’s result. See the differentiability arithmetic for more details.

fn vv(self, rhs: Var<F2>) -> Self::Output

Computes the dot product between self and other.

impl<F1, F2, B2> VecVecMul<VarDiff<F2, B2>> for Var<F1> where
    F1: Data<Dim = Ix1> + 'static,
    F2: Data<Dim = Ix1> + 'static,
    B2: Gradient<Dim = Ix1> + Overwrite + 'static, 

type Output = VarDiff<VectorVectorMul<F1, F2>, VectorVectorMulBackwardUnary<B2, F1>>

The type of the dot product’s result. See the differentiability arithmetic for more details.

fn vv(self, rhs: VarDiff<F2, B2>) -> Self::Output

Computes the dot product between self and other.