Struct MultiVariableSolver 

pub struct MultiVariableSolver { /* private fields */ }

Implements the finite difference method for numerical differentation for multi-variable functions

Implementations

impl MultiVariableSolver

pub fn get_step_size(&self) -> f64

Returns the step size

pub fn set_step_size(&mut self, step_size: f64)

Sets the step size

pub fn get_method(&self) -> FiniteDifferenceMode

Returns the chosen method of differentiation Possible choices are: Forward step, backward step and central step

pub fn set_method(&mut self, method: FiniteDifferenceMode)

Sets the method of differentiation Possible choices are: Forward step, backward step and central step

pub fn get_step_size_multiplier(&self) -> f64

Returns the chosen step size multiplier.

pub fn set_step_size_multiplier(&mut self, multiplier: f64)

Sets the chosen step size multiplier. The step size will be multiplied by this factor after every iteration This parameter only matters if you are interested in triple derivatives or higher

pub fn from_parameters( step: f64, method: FiniteDifferenceMode, multiplier: f64, ) -> Self

custom constructor, choose this for tweaking parameters if computing solutions for complex equations step: the desired step size for each iteration method: the desired method of differentiation: forward step, backward step or central step multiplier: default is 10.0, this is the factor by which we multiply the step size with on each iteration. Only matters for triple derivatives or higher

Trait Implementations

impl Clone for MultiVariableSolver

fn clone(&self) -> MultiVariableSolver

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for MultiVariableSolver

impl Default for MultiVariableSolver

fn default() -> Self

default constructor, choose this for optimal results for most generic equations

impl DerivatorMultiVariable for MultiVariableSolver

fn get<T: ComplexFloat, const NUM_VARS: usize, const NUM_ORDER: usize>( &self, order: usize, func: &dyn Fn(&[T; NUM_VARS]) -> T, idx_to_derivate: &[usize; NUM_ORDER], point: &[T; NUM_VARS], ) -> Result<T, &'static str>

Returns the numerical differentiation value for a multi variable function order: number of times the equation should be differentiated func: the multi variable function idx_to_derivate: The variable index/indices whose respect to we want to differentiate point: the point of interest around which we want to differentiate

NOTE: Returns a Result<T, &’static str> Possible &’static str are: NUMBER_OF_DERIVATIVE_STEPS_CANNOT_BE_ZERO -> if the step size value is zero DERIVATE_ORDER_CANNOT_BE_ZERO -> if the ‘order’ argument is zero INDEX_TO_DERIVATE_ILL_FORMED -> if size of ‘idx_to_derivate’ argument is not equal to the ‘order’ argument

assume we want to differentiate f(x,y,z) = ysin(x) + xcos(y) + xye^z. the function would be:

   let my_func = | args: &[f64; 3] | -> f64 
   { 
       return args[1]*args[0].sin() + args[0]*args[1].cos() + args[0]*args[1]*args[2].exp();
   };

let point = [1.0, 2.0, 3.0]; //the point at which we want to differentiate


use multicalc::numerical_derivative::derivator::*;
use multicalc::numerical_derivative::finite_difference::*;

let derivator = MultiVariableSolver::default();

let idx: [usize; 2] = [0, 1]; //mixed partial double derivate d(df/dx)/dy
let val = derivator.get(2, &my_func, &idx, &point).unwrap();
let expected_value = f64::cos(1.0) - f64::sin(2.0) + f64::exp(3.0);
assert!(f64::abs(val - expected_value) < 0.001);

let idx: [usize; 2] = [1, 1]; //partial double derivative d(df/dy)/dy 
let val = derivator.get(2, &my_func, &idx, &point).unwrap();
let expected_value = -1.0*f64::cos(2.0);
assert!(f64::abs(val - expected_value) < 0.0001);

fn get_single_partial<T: ComplexFloat, const NUM_VARS: usize>( &self, func: &dyn Fn(&[T; NUM_VARS]) -> T, idx_to_derivate: usize, point: &[T; NUM_VARS], ) -> Result<T, &'static str>

convenience wrapper for a single partial derivative of a multivariable function

fn get_double_partial<T: ComplexFloat, const NUM_VARS: usize>( &self, func: &dyn Fn(&[T; NUM_VARS]) -> T, idx_to_derivate: &[usize; 2], point: &[T; NUM_VARS], ) -> Result<T, &'static str>

convenience wrapper for a double partial derivative of a multivariable function