use thiserror::Error;
#[derive(Debug, Clone, PartialEq, Error)]
pub enum SolverError {
#[error("Roots are not bracketed: f({min})={f_min}, f({max})={f_max}")]
NotBracketed {
min: f64,
max: f64,
f_min: f64,
f_max: f64,
},
#[error("Maximum iterations ({0}) exceeded")]
MaxIterationsExceeded(usize),
#[error("Derivative became zero during iteration at x={0}")]
ZeroDerivative(f64),
}
pub struct Bisection;
impl Bisection {
pub fn solve<F: Fn(f64) -> f64>(
f: F,
mut min: f64,
mut max: f64,
tolerance: f64,
max_iter: usize,
) -> Result<f64, SolverError> {
let mut f_min = f(min);
let f_max = f(max);
if f_min.abs() <= tolerance {
return Ok(min);
}
if f_max.abs() <= tolerance {
return Ok(max);
}
if f_min * f_max > 0.0 {
return Err(SolverError::NotBracketed {
min,
max,
f_min,
f_max,
});
}
for iter in 0..max_iter {
let mid = 0.5 * (min + max);
let f_mid = f(mid);
if f_mid.abs() <= tolerance || (max - min) <= tolerance {
return Ok(mid);
}
if f_min * f_mid <= 0.0 {
max = mid;
} else {
min = mid;
f_min = f_mid;
}
if iter == max_iter - 1 {
return Err(SolverError::MaxIterationsExceeded(max_iter));
}
}
Err(SolverError::MaxIterationsExceeded(max_iter))
}
}
pub struct NewtonRaphson;
impl NewtonRaphson {
pub fn solve<F, DF>(
f: F,
df: DF,
mut min: f64,
mut max: f64,
guess: f64,
tolerance: f64,
max_iter: usize,
) -> Result<f64, SolverError>
where
F: Fn(f64) -> f64,
DF: Fn(f64) -> f64,
{
let mut f_min = f(min);
let f_max = f(max);
if f_min.abs() <= tolerance {
return Ok(min);
}
if f_max.abs() <= tolerance {
return Ok(max);
}
if f_min * f_max > 0.0 {
return Err(SolverError::NotBracketed {
min,
max,
f_min,
f_max,
});
}
let mut x = guess.clamp(min, max);
let mut dx_old = (max - min).abs();
let mut dx = dx_old;
for _ in 0..max_iter {
let fx = f(x);
let dfx = df(x);
if fx.abs() <= tolerance {
return Ok(x);
}
let step_out_of_bounds = ((x - min) * dfx - fx) * ((x - max) * dfx - fx) > 0.0;
let step_not_converging = (2.0 * fx).abs() > (dx_old * dfx).abs();
if step_out_of_bounds || step_not_converging || dfx.abs() < 1e-15 {
dx_old = dx;
dx = 0.5 * (max - min);
x = min + dx;
} else {
dx_old = dx;
dx = fx / dfx;
x -= dx;
}
if dx.abs() <= tolerance {
return Ok(x);
}
let fx_new = f(x);
if fx_new * f_min < 0.0 {
max = x;
} else {
min = x;
f_min = fx_new;
}
}
Err(SolverError::MaxIterationsExceeded(max_iter))
}
}