Struct Var 

pub struct Var<T> { /* private fields */ }

A differentiable variable for reverse-mode automatic differentiation.

Examples

Using reverse_diff for reusable functions:

use autodiff::{reverse_diff, Var};

// Define f(x) = (x+1)(x-1) = x² - 1
let f = |x: Var<f64>| (x.clone() + 1.0) * (x - 1.0);

let (val, deriv) = reverse_diff(f, 3.0);
assert_eq!(val, 8.0);    // f(3) = 8
assert_eq!(deriv, 6.0);  // f'(3) = 2x = 6

use autodiff::{reverse_diff, Var};

// Define f(x) = x² + x
let f = |x: Var<f64>| x.clone() * x.clone() + x;

let (val, deriv) = reverse_diff(f, 3.0);
assert_eq!(val, 12.0);   // f(3) = 12
assert_eq!(deriv, 7.0);  // f'(3) = 2x + 1 = 7

Implementations

impl<T: Copy> Var<T>

pub fn value(&self) -> T

Returns the value of this variable.

impl<T: Float> Var<T>

pub fn backward(&self) -> Gradients<T>

Computes gradients by backpropagation from this variable.

Returns a Gradients object that can be queried for the gradient with respect to any variable.

Examples

use autodiff::Tape;

let tape = Tape::new();
let x = tape.var(3.0);
let y = x.clone() * x.clone();  // y = x²

let grads = y.backward();
assert_eq!(grads.get(&x), 6.0);  // dy/dx = 2x = 6

pub fn recip(self) -> Self

Computes the reciprocal 1/self.

pub fn exp(self) -> Self

Computes e^self.

pub fn sin(self) -> Self

Computes sin(self).

pub fn cos(self) -> Self

Computes cos(self).

pub fn ln(self) -> Self

Computes ln(self).

pub fn sqrt(self) -> Self

Computes sqrt(self).

Trait Implementations

impl<T: Float> Add<T> for Var<T>

type Output = Var<T>

The resulting type after applying the + operator.

fn add(self, c: T) -> Self::Output

Performs the + operation.

impl<T: Float> Add for Var<T>

type Output = Var<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: Clone> Clone for Var<T>

fn clone(&self) -> Var<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Float> Div<T> for Var<T>

type Output = Var<T>

The resulting type after applying the / operator.

fn div(self, c: T) -> Self::Output

Performs the / operation.

impl<T: Float> Div for Var<T>

type Output = Var<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: Float> Mul<T> for Var<T>

type Output = Var<T>

The resulting type after applying the * operator.

fn mul(self, c: T) -> Self::Output

Performs the * operation.

impl<T: Float> Mul for Var<T>

type Output = Var<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Float> Neg for Var<T>

type Output = Var<T>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T: Float> Sub<T> for Var<T>

type Output = Var<T>

The resulting type after applying the - operator.

fn sub(self, c: T) -> Self::Output

Performs the - operation.

impl<T: Float> Sub for Var<T>

type Output = Var<T>

The resulting type after applying the - operator.

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

Performs the - operation.