Struct peroxide::numerical::root::BroydenMethod

pub struct BroydenMethod {
    pub max_iter: usize,
    pub tol: f64,
    pub rtol: f64,
}

Broyden method

Type for RootFinder

• I: free
• O: free
• T: Intv<I> (=([f64; I], [f64; I]))

Arguments

• max_iter: Maximum number of iterations
• tol: Absolute tolerance

Caution

• The function should be differentiable

Example

use peroxide::fuga::*;
use peroxide::numerical::root::{Pt, Intv};
 
fn main() -> Result<(), Box<dyn std::error::Error>> {
    let problem = CircleTangentLine;
    let broyden = BroydenMethod { max_iter: 100, tol: 1e-6, rtol: 1e-6 };

    let root = broyden.find(&problem)?;
    let result = problem.function(root)?;

    let norm = result.to_vec().norm(Norm::L2);
    assert!(norm < 1e-6);

    Ok(())
}
 
struct CircleTangentLine;
 
impl RootFindingProblem<2, 2, Intv<2>> for CircleTangentLine {
    fn function(&self, x: Pt<2>) -> anyhow::Result<Pt<2>> {
        Ok([
            x[0] * x[0] + x[1] * x[1] - 1.0,
            x[0] + x[1] - 2f64.sqrt()
        ])
    }
 
    fn initial_guess(&self) -> Intv<2> {
        ([0.0, 0.1], [-0.1, 0.2])
    }
}

Fields

max_iter: usize

tol: f64

rtol: f64

Trait Implementations

impl<const I: usize, const O: usize> RootFinder<I, O, ([f64; I], [f64; I])> for BroydenMethod

fn max_iter(&self) -> usize

fn tol(&self) -> f64

fn find<P: RootFindingProblem<I, O, Intv<I>>>( &self, problem: &P, ) -> Result<Pt<I>>