Trait argmin::core::Jacobian

source · [−]
pub trait Jacobian {
    type Param;
    type Jacobian;

    fn jacobian(&self, param: &Self::Param) -> Result<Self::Jacobian, Error>;

    fn bulk_jacobian<'a, P>(
        &self,
        params: &'a [P]
    ) -> Result<Vec<Self::Jacobian>, Error>
    where
        P: Borrow<Self::Param> + SyncAlias,
        Self::Jacobian: SendAlias,
        Self: SyncAlias,
    { ... }
    fn parallelize(&self) -> bool { ... }
}
Expand description

Defines the computation of the Jacobian.

Example

use argmin::core::{Jacobian, Error};

struct Problem {}

impl Jacobian for Problem {
    type Param = Vec<f64>;
    type Jacobian = Vec<Vec<f64>>;

    fn jacobian(&self, p: &Self::Param) -> Result<Self::Jacobian, Error> {
        Ok(problem_jacobian(p))
    }
}

Required Associated Types

Type of the parameter vector

Type of the Jacobian

Required Methods

Compute Jacobian

Provided Methods

Compute jacobian in bulk. If the rayon feature is enabled, multiple calls to jacobian will be run in parallel using rayon, otherwise they will execute sequentially. If the rayon feature is enabled, parallelization can still be turned off by overwriting parallelize to return false. This can be useful in cases where it is preferable to parallelize only certain parts. Note that even if parallelize is set to false, the parameter vectors and the problem are still required to be Send and Sync. Those bounds are linked to the rayon feature. This method can be overwritten.

Indicates whether to parallelize calls to jacobian when using bulk_jacobian. By default returns true, but can be set manually to false if needed. This allows users to turn off parallelization for certain traits implemented on their problem. Note that parallelization requires the rayon feature to be enabled, otherwise calls to jacobian will be executed sequentially independent of how parallelize is set.

Implementors