Struct ForwardADMulti 

pub struct ForwardADMulti<A: AD + ForwardADTrait> { /* private fields */ }

Computes derivatives using Forward-mode Automatic Differentiation (Multi-Tangent).

This method allows for computing multiple columns of the Jacobian in a single pass by propagating a vector of tangents. This can significantly speed up computation by taking advantage of SIMD and reducing function overhead.

Implementations

impl<A: AD + ForwardADTrait> ForwardADMulti<A>

pub fn new() -> Self

Examples found in repository

examples/example1.rs (line 63)

fn main() {
    let inputs = vec![1., 2.];

    // Reverse AD //////////////////////////////////////////////////////////////////////////////////
    let function_standard = Test { coeff: 2.0 };
    let function_derivative = function_standard.to_other_ad_type::<adr>();
    let differentiable_block = FunctionEngine::new(function_standard, function_derivative, ReverseAD::new());

    let (f_res, derivative_res) = differentiable_block.derivative(&inputs);
    println!("Reverse AD: ");
    println!("  f_res: {}", f_res[0]);
    println!("  derivative: {}", derivative_res);
    println!("//////////////");
    println!();

    // Forward AD //////////////////////////////////////////////////////////////////////////////////
    let function_standard = Test { coeff: 2.0 };
    let function_derivative = function_standard.to_other_ad_type::<adfn<1>>();
    let differentiable_block = FunctionEngine::new(function_standard, function_derivative, ForwardAD::new());

    let (f_res, derivative_res) = differentiable_block.derivative(&inputs);
    println!("Forward AD: ");
    println!("  f_res: {}", f_res[0]);
    println!("  derivative: {}", derivative_res);
    println!("//////////////");
    println!();

    // Forward AD Multi ////////////////////////////////////////////////////////////////////////////
    let function_standard = Test { coeff: 2.0 };
    let function_derivative = function_standard.to_other_ad_type::<adfn<2>>();
    let differentiable_block = FunctionEngine::new(function_standard, function_derivative, ForwardADMulti::new());

    let (f_res, derivative_res) = differentiable_block.derivative(&inputs);
    println!("Forward AD Multi: ");
    println!("  f_res: {}", f_res[0]);
    println!("  derivative: {}", derivative_res);
    println!("//////////////");
    println!();

    // Finite Differencing /////////////////////////////////////////////////////////////////////////
    let function_standard = Test { coeff: 2.0 };
    let function_derivative = function_standard.clone();
    let differentiable_block = FunctionEngine::new(function_standard, function_derivative, FiniteDifferencing::new());

    let (f_res, derivative_res) = differentiable_block.derivative(&inputs);
    println!("Finite Differencing: ");
    println!("  f_res: {}", f_res[0]);
    println!("  derivative: {}", derivative_res);
    println!("//////////////");
    println!();

}

Trait Implementations

impl<A: Clone + AD + ForwardADTrait> Clone for ForwardADMulti<A>

fn clone(&self) -> ForwardADMulti<A>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: AD + ForwardADTrait> DerivativeMethodTrait for ForwardADMulti<A>

type T = A

The AD type used by this method (e.g., f64, adr, adfn).

fn derivative<D: DifferentiableFunctionTrait<Self::T> + ?Sized>( &self, inputs: &[f64], function: &D, ) -> (Vec<f64>, DMatrix<f64>)

Computes the function’s value and its Jacobian matrix at the given input point.