Struct Bisection

pub struct Bisection<F> { /* private fields */ }

Simple bisection method.

See https://en.wikipedia.org/wiki/Bisection_method for details on the algorithm.

The x returned is an array [f64;2] which bounds the root. The midpoint of the range is the best estimate of the root, and x_mid and f_mid (the function evalution at the midpoint) are also available on the algo

Examples

from https://en.wikipedia.org/wiki/Bisection_method#Example:_Finding_the_root_of_a_polynomial

use stepwise::{Driver as _, fixed_iters, algos::Bisection, assert_approx_eq};

let f = |x: f64| x.powi(3) - x - 2.0;

let algo = Bisection::from_fn(f, [1.0, 2.0]).expect("range didn't bound the solution");
let mut driver = fixed_iters(algo, 15);

println!("iter       x0        x1         x-mid         f");

let (solved, step) = driver
    .on_step(|algo, step| {
       let [x0, x1] = algo.x();
       println!(
          "{i:>4}  [{x0:.7}, {x1:.7}]  {xmid:.7}  {f:+.7}",
          i = step.iteration(),
          xmid = (x0 + x1) / 2.0,
          f = algo.f_mid()
       );
    })
    .solve()
    .unwrap();

assert_approx_eq!(solved.x().as_slice(), &[1.5213, 1.5213], 0.0001);

Implementations

impl Bisection<()>

pub fn from_fn<G>( g: G, range: [f64; 2], ) -> Result<Bisection<impl FnMut(f64) -> Result<f64, Infallible>>, DriverError>

where G: FnMut(f64) -> f64,

Create a new bisection algo from an infalliable function f: f64 -> f64

impl Bisection<()>

pub fn from_falliable_fn<F, E>( f: F, [lo, hi]: [f64; 2], ) -> Result<Bisection<F>, DriverError>

where F: FnMut(f64) -> Result<f64, E>, E: 'static + Send + Sync + Error,

Create a new bisection algo from an falliable function f: f64 -> Result<f64,E>

Errors

• DriverError::AlgoError if the calls to the function f fail.
• DriverError::InitialCondition if [lo,hi] doesn’t bound the root.

impl<F> Bisection<F>

pub fn x(&self) -> [f64; 2]

pub fn x_mid(&self) -> f64

The midpoint of the current range.

pub fn x_spread(&self) -> f64

The width or spread of the current range.

pub fn f_mid(&self) -> f64

The function, f, evaluated at the midpoint of the current range.

Trait Implementations

impl<E, F> Algo for Bisection<F>

where F: FnMut(f64) -> Result<f64, E>, E: 'static + Send + Sync + Error,

type Error = E

fn step(&mut self) -> (ControlFlow<()>, Result<(), E>)

fn read_file(&mut self, fmt: &FileFormat, r: &mut dyn Read) -> Result<(), Error>

Implement this method to support recovery from a checkpoint file

fn write_file(&self, fmt: &FileFormat, w: &mut dyn Write) -> Result<(), Error>

Implement this trait to support writing checkpoint files

impl<F: Clone> Clone for Bisection<F>

fn clone(&self) -> Bisection<F>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F> Debug for Bisection<F>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<F: PartialEq> PartialEq for Bisection<F>

fn eq(&self, other: &Bisection<F>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<F> StructuralPartialEq for Bisection<F>