fn find<P: RootFindingProblem<1, 1, (f64, f64)>>(&self, problem: &P) -> Result<[f64; 1]> {
        let state = problem.initial_guess();
        let (mut a, mut b) = state;
        let mut fa = single_function!(problem, a);
        let mut fb = single_function!(problem, b);

        if fa.abs() < self.tol {
            return Ok([a]);
        } else if fb.abs() < self.tol {
            return Ok([b]);
        } else if fa * fb > 0.0 {
            bail!(RootError::<1>::NoRoot);
        }

        for _ in 0..self.max_iter {
            let c = (a * fb - b * fa) / (fb - fa);
            let fc = single_function!(problem, c);

            if fc.abs() < self.tol {
                return Ok([c]);
            } else if fa * fc < 0.0 {
                b = c;
                fb = fc;
            } else if fb * fc < 0.0 {
                a = c;
                fa = fc;
            } else {
                bail!(RootError::<1>::NoRoot);
            }
        }
        let c = (a * fb - b * fa) / (fb - fa);
        bail!(RootError::NotConverge([c]));
    }
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

```rust
use peroxide::fuga::*;
use peroxide::numerical::root::{Pt, Intv};

fn main() -> Result<(),
src/numerical/root.rs