pub fn differentiate_holomorphic_numerically<F, N, M, O>(
problem: &mut O
) -> Option<OMatrix<F, M, N>> where
F: RealField + Copy,
N: Dim,
M: Dim,
O: LeastSquaresProblem<Complex<F>, M, N>,
DefaultAllocator: Allocator<Complex<F>, N, Buffer = O::ParameterStorage> + Allocator<F, N> + Allocator<F, M, N>,
Expand description
Compute a numerical approximation of the Jacobian for holomorphic residuals.
This method is much more precise than
differentiate_numerically
but
it requires that your residuals are holomorphic on a neighborhood of the real line.
You also must provide an implementation of
LeastSquaresProblem
for complex numbers.
This method is mainly intended for testing your derivative implementation.
Panics
The function panics if the parameters which are set when the function is called are not real.
Example
use nalgebra::{ComplexField, convert};
struct ExampleProblem<F: ComplexField> {
params: Vector2<F>,
}
// Implement LeastSquaresProblem to be usable with complex numbers
impl<F: ComplexField + Copy> LeastSquaresProblem<F, U2, U2> for ExampleProblem<F> {
// ... omitted ...
}
// parameters for which you want to test your derivative
let x = Vector2::new(0.03877264483558185, -0.7734472300384164);
// instantiate f64 variant to compute the derivative we want to check
let jacobian_from_trait = (ExampleProblem::<f64> { params: x }).jacobian().unwrap();
// then use Complex<f64> and compute the numerical derivative
let jacobian_numerically = {
let mut problem = ExampleProblem::<Complex<f64>> {
params: convert(x),
};
differentiate_holomorphic_numerically(&mut problem).unwrap()
};
assert_relative_eq!(jacobian_from_trait, jacobian_numerically, epsilon = 1e-15);