pub fn new(init: RootState, method: RootFind, f: F) -> Result<Self, RootError> {
        match method {
            RootFind::Bisection => match init {
                P(_) => Err(RootError::MismatchedState),
                _ => Ok(RootFinder {
                    init,
                    curr: init,
                    method,
                    f: Box::new(f),
                    find: RootBool::NotYet,
                    times: 100,
                    tol: 1e-10,
                    root: 0f64,
                }),
            },
            RootFind::Newton => match init {
                P(_) => Ok(RootFinder {
                    init,
                    curr: init,
                    method,
                    f: Box::new(f),
                    find: RootBool::NotYet,
                    times: 100,
                    tol: 1e-10,
                    root: 0f64,
                }),
                _ => Err(RootError::MismatchedState),
            },
            RootFind::Secant => match init {
                P(_) => Err(RootError::MismatchedState),
                _ => Ok(RootFinder {
                    init,
                    curr: init,
                    method,
                    f: Box::new(f),
                    find: RootBool::NotYet,
                    times: 100,
                    tol: 1e-10,
                    root: 0f64,
                }),
            },
            RootFind::FalsePosition => match init {
                I(_, _) => Ok(RootFinder {
                    init,
                    curr: init,
                    method,
                    f: Box::new(f),
                    find: RootBool::NotYet,
                    times: 100,
                    tol: 1e-10,
                    root: 0f64,
                }),
                _ => Err(RootError::MismatchedState),
            },
        }
    }
Create RootFinder

# Default Options

* Times: 100
* Tolerance: 1e-10

# Usage
```
extern crate peroxide;
use peroxide::fuga::*;

fn main() -> Result<(), RootError> {
let init = RootState::I(1f64, 3f64);
let mut a = RootFinder::new(init, Bisection, f)?;
let x = a.find_root()?;
x.print();
Ok(())
}

fn f(x: AD) -> AD {
x.powi(2) - 4f64
}
```
src/grave/root.rs