# Crate autodiff

Expand description

This crate provides a library for performing automatic differentiation.

## Examples

The following example differentiates a 1D function defined by a closure.

``````use autodiff::*;
// Define a function `f(x) = e^{-0.5*x^2}`
let f = |x: FT<f64>| (-x * x / F::cst(2.0)).exp();

// Differentiate `f` at zero.
println!("{}", diff(f, 0.0)); // prints `0```````

To compute the gradient of a function, use the function `grad` as follows:

``````use autodiff::*;
// Define a function `f(x,y) = x*y^2`
let f = |x: &[FT<f64>]| x * x * x;

// Differentiate `f` at `(1,2)`.
let g = grad(f, &vec![1.0, 2.0]);
println!("({}, {})", g, g); // prints `(4, 4)```````

Compute a specific derivative of a multi-variable function:

``````use autodiff::*;
// Define a function `f(x,y) = x*y^2`.
let f = |v: &[FT<f64>]| v * v * v;

// Differentiate `f` at `(1,2)` with respect to `x` (the first unknown) only.
let v = vec![
F::var(1.0), // Create a variable.
F::cst(2.0), // Create a constant.
];
println!("{}", f(&v).deriv()); // prints `4```````

The following example shows how to compute a Jacobian product and evaluate the function at the same time.

``````use autodiff::*;
// Define a function `f(x,y) = (x*y^2, x/y)`.
let f = |v: &[FT<f64>]| vec![v * v * v, v/v];

// Compute the Jacobian of `f` at `x = (1,2)` multiplied by a vector `p = (3,4)`.
let xp = vec![
F1::new(1.0, 3.0),
F1::new(2.0, 4.0),
];
let jp = f(&xp);
println!("({}, {})", jp.value(), jp.value()); // prints `(4.0, 0.5)`
println!("({}, {})", jp.deriv(), jp.deriv()); // prints `(28.0, 0.5)```````

## Re-exports

`pub use forward_autodiff::*;`

## Modules

This module defines forward automatic differentiation. This mode of `autodiff` is most efficient when computing derivatives with more inputs than outputs. It is also useful for computing Jacobian products (see crate root docs for examples).

## Traits

Generic trait for floating point numbers

An interface for casting between machine scalars.

Defines a multiplicative identity element for `Self`.

A generic trait for converting a value to a number.

Defines an additive identity element for `Self`.