use crate::error::{BarracudaError, Result};
#[derive(Debug, Clone)]
pub struct NewtonResult {
pub root: f64,
pub iterations: usize,
pub residual: f64,
pub converged: bool,
}
pub fn newton<F, DF>(f: F, df: DF, x0: f64, tol: f64, max_iter: usize) -> Result<NewtonResult>
where
F: Fn(f64) -> f64,
DF: Fn(f64) -> f64,
{
let mut x = x0;
for iter in 0..max_iter {
let fx = f(x);
let dfx = df(x);
if fx.abs() < tol {
return Ok(NewtonResult {
root: x,
iterations: iter,
residual: fx.abs(),
converged: true,
});
}
if dfx.abs() < 1e-14 {
return Err(BarracudaError::Numerical {
message: format!(
"Newton-Raphson: derivative is near zero at x = {x}, f'(x) = {dfx}"
),
});
}
x -= fx / dfx;
if !x.is_finite() {
return Err(BarracudaError::Numerical {
message: format!(
"Newton-Raphson diverged: x became non-finite after {} iterations",
iter + 1
),
});
}
}
let fx = f(x);
Ok(NewtonResult {
root: x,
iterations: max_iter,
residual: fx.abs(),
converged: fx.abs() < tol,
})
}
pub fn newton_numerical<F>(f: F, x0: f64, tol: f64, max_iter: usize, h: f64) -> Result<NewtonResult>
where
F: Fn(f64) -> f64,
{
let mut x = x0;
for iter in 0..max_iter {
let fx = f(x);
if fx.abs() < tol {
return Ok(NewtonResult {
root: x,
iterations: iter,
residual: fx.abs(),
converged: true,
});
}
let dfx = (f(x + h) - f(x - h)) / (2.0 * h);
if dfx.abs() < 1e-14 {
return Err(BarracudaError::Numerical {
message: format!(
"Newton-Raphson: numerical derivative is near zero at x = {x}, f'(x) ≈ {dfx}"
),
});
}
x -= fx / dfx;
if !x.is_finite() {
return Err(BarracudaError::Numerical {
message: format!(
"Newton-Raphson diverged: x became non-finite after {} iterations",
iter + 1
),
});
}
}
let fx = f(x);
Ok(NewtonResult {
root: x,
iterations: max_iter,
residual: fx.abs(),
converged: fx.abs() < tol,
})
}
pub fn secant<F>(f: F, mut x0: f64, mut x1: f64, tol: f64, max_iter: usize) -> Result<NewtonResult>
where
F: Fn(f64) -> f64,
{
let mut f0 = f(x0);
let mut f1 = f(x1);
for iter in 0..max_iter {
if f1.abs() < tol {
return Ok(NewtonResult {
root: x1,
iterations: iter,
residual: f1.abs(),
converged: true,
});
}
if (f1 - f0).abs() < 1e-14 {
return Err(BarracudaError::Numerical {
message: format!(
"Secant method: f(x0) ≈ f(x1), cannot compute approximation. \
x0 = {x0}, x1 = {x1}, f0 = {f0}, f1 = {f1}"
),
});
}
let x2 = x1 - f1 * (x1 - x0) / (f1 - f0);
x0 = x1;
f0 = f1;
x1 = x2;
f1 = f(x1);
if !x1.is_finite() || !f1.is_finite() {
return Err(BarracudaError::Numerical {
message: format!(
"Secant method diverged: x or f(x) became non-finite after {} iterations",
iter + 1
),
});
}
}
Ok(NewtonResult {
root: x1,
iterations: max_iter,
residual: f1.abs(),
converged: f1.abs() < tol,
})
}
#[cfg(test)]
mod tests {
use super::*;
use std::f64::consts::{PI, SQRT_2};
#[test]
fn test_newton_sqrt2() {
let f = |x: f64| x.mul_add(x, -2.0);
let df = |x: f64| 2.0 * x;
let result = newton(f, df, 1.0, 1e-10, 100).unwrap();
assert!(result.converged);
assert!((result.root - SQRT_2).abs() < 1e-10);
assert!(result.iterations < 10); }
#[test]
fn test_newton_cubic() {
let f = |x: f64| 2.0f64.mul_add(-x, x.powi(3)) - 5.0;
let df = |x: f64| 3.0f64.mul_add(x.powi(2), -2.0);
let result = newton(f, df, 2.0, 1e-10, 100).unwrap();
assert!(result.converged);
assert!(f(result.root).abs() < 1e-10);
}
#[test]
fn test_newton_numerical_sqrt2() {
let f = |x: f64| x.mul_add(x, -2.0);
let result = newton_numerical(f, 1.0, 1e-10, 100, 1e-8).unwrap();
assert!(result.converged);
assert!((result.root - SQRT_2).abs() < 1e-9);
}
#[test]
fn test_newton_numerical_cube_root() {
let f = |x: f64| (x * x).mul_add(x, -27.0);
let result = newton_numerical(f, 3.5, 1e-10, 100, 1e-8).unwrap();
assert!(result.converged);
assert!((result.root - 3.0).abs() < 1e-9);
}
#[test]
fn test_secant_sqrt2() {
let f = |x: f64| x.mul_add(x, -2.0);
let result = secant(f, 1.0, 2.0, 1e-10, 100).unwrap();
assert!(result.converged);
assert!((result.root - SQRT_2).abs() < 1e-10);
}
#[test]
fn test_secant_sin_pi() {
let f = |x: f64| x.sin();
let result = secant(f, 3.0, 3.5, 1e-10, 100).unwrap();
assert!(result.converged);
assert!((result.root - PI).abs() < 1e-10);
}
#[test]
fn test_newton_zero_derivative() {
let f = |x: f64| x * x * x;
let df = |x: f64| 3.0 * x * x;
let result = newton(f, df, 0.0, 1e-10, 100);
if let Err(e) = result {
assert!(e.to_string().contains("zero"));
}
}
#[test]
fn test_newton_result_fields() {
let f = |x: f64| x - 1.0;
let df = |_: f64| 1.0;
let result = newton(f, df, 0.0, 1e-10, 100).unwrap();
assert!(result.converged);
assert!((result.root - 1.0).abs() < 1e-10);
assert!(result.residual < 1e-10);
assert!(result.iterations < 100);
}
}