Struct Differentiable 

pub struct Differentiable<V, G> {
    pub value: V,
    pub derivative: G,
}

A function and its derivative, from two closures. As an Objective, value gives the value and derivative writes the gradient. As a Mapping, value writes the values and derivative takes (u, x, out) and writes the vector–Jacobian product.

Fields

value: V

derivative: G

Trait Implementations

impl<F, E, V: FnMut(&[F], &mut [F]) -> Result<(), E>, G: FnMut(&[F], &[F], &mut [F]) -> Result<(), E>> Mapping<F> for Differentiable<V, G>

type Error = E

What stops an evaluation, as for Objective.

fn value(&mut self, x: &[F], out: &mut [F]) -> Result<(), E>

The values at x, into out.

fn has_vjp(&self) -> bool

Whether vjp gives vector–Jacobian products. Least squares in solve_linear needs them.

fn vjp(&mut self, u: &[F], x: &[F], out: &mut [F]) -> Result<(), E>

uᵀJ, the product of u with the Jacobian at x, into out. For a linear mapping it’s the product of the transpose with u, at any x. Methods call it only where has_vjp is true.

fn has_jvp(&self) -> bool

Whether jvp gives Jacobian–vector products.

fn jvp(&mut self, v: &[F], x: &[F], out: &mut [F]) -> Result<bool, Self::Error>

Jv, the product of the Jacobian at x with v, into out. For a linear mapping it’s the product of the matrix with v, at any x. It gives false where it declines, as for a function it can’t differentiate at x, and the caller then takes differences instead. Methods call it only where has_jvp is true.

fn jacobian(&mut self, x: &[F], j: &mut [F]) -> Result<bool, Self::Error>

where F: Native,

The Jacobian at x, with a row of x.len() items for each value, into j, or false where Levenberg–Marquardt should take forward differences instead. By default, a mapping builds it from vjp, one row per product, when it has no more values than variables or no jvp. Otherwise it builds it from jvp, one column per product. Each takes no more calls than differences do. It gives false for a mapping with neither, or where jvp declines.

fn has_preconditioner(&self) -> bool

Whether precondition gives a preconditioner’s products. solve_linear runs without one otherwise.

fn precondition(&mut self, v: &[F], out: &mut [F]) -> Result<(), Self::Error>

The product with v of a preconditioner for solve_linear, into out: M, an approximation to the inverse of the matrix, or of AᵀA for least squares. CG and MINRES need M symmetric positive definite. Methods call it only where has_preconditioner is true.

impl<F, E, V: FnMut(&[F]) -> Result<F, E>, G: FnMut(&[F], &mut [F]) -> Result<(), E>> Objective<F> for Differentiable<V, G>

type Error = E

What stops an evaluation, such as an error in the caller’s function or an interrupt.

fn value(&mut self, x: &[F]) -> Result<F, E>

The value at x.

fn has_gradient(&self) -> bool

Whether gradient gives the gradient. L-BFGS needs one, and Method::choose picks L-BFGS for an objective that has one.

fn gradient(&mut self, x: &[F], g: &mut [F]) -> Result<(), E>

The gradient at x, into g. Methods call it only where has_gradient is true.

fn batch(&self) -> bool

Whether values evaluates a batch of points in one call. Nelder–Mead evaluates its first simplex and each shrink as a batch, and differential evolution each generation. Without batch, a search calls value on each point.

fn values(&mut self, xs: &[F], out: &mut [F]) -> Result<(), Self::Error>

The value at each row of xs, into out, with xs.len() / out.len() items to a row. Methods call it only where batch is true.