Rust 计算每个根 - Rust

在 Rust 中，计算给定函数的每个根是一项重要的任务。根据函数和要解决的问题，可以使用不同的方法来计算每个根，如迭代法、牛顿法或二分法。本文将介绍 Rust 中使用牛顿法和二分法计算每个根的方法。

牛顿法

牛顿法（Newton's method）是一种迭代算法，可用于对函数进行数值逼近。该算法利用函数的导数来找到函数的根，即函数等于零的点。以下是在 Rust 中实现牛顿法计算函数的每个根的示例：

fn newton(f: fn(f64) -> f64, df: fn(f64) -> f64, x0: f64, eps: f64, max_iter: u32) -> f64 {
    let mut x = x0;
    let mut i = 0;
    while i < max_iter {
        let fx = f(x);
        let dfx = df(x);
        let delta = fx / dfx;
        x = x - delta;
        if delta.abs() < eps {
            return x;
        }
        i += 1;
    }
    x
}

fn f(x: f64) -> f64 {
    x.powi(3) - 2.0 * x - 5.0
}

fn df(x: f64) -> f64 {
    3.0 * x.powi(2) - 2.0
}

fn main() {
    let eps = 1e-9;
    let max_iter = 100;
    let x0 = 2.0;
    let root = newton(f, df, x0, eps, max_iter);
    println!("Root found at x = {}", root);
}

以上代码实现了一个 newton 函数，它接收一个函数 f 和它的导数函数 df，以及起始点 x0、允许的误差 eps 和最大迭代次数 max_iter。函数使用牛顿法在 f 中搜索根，并返回找到的根。

二分法

二分法（Bisection method）是另一种计算函数根的常用迭代算法。它通过反复将区间一分为二，找到函数根的位置。以下是在 Rust 中实现二分法计算函数的每个根的示例：

fn bisection(f: fn(f64) -> f64, a: f64, b: f64, eps: f64, max_iter: u32) -> f64 {
    let mut i = 0;
    let mut a = a;
    let mut b = b;
    while i < max_iter {
        let c = (a + b) / 2.0;
        if (b - a).abs() < eps {
            return c;
        }
        if f(c) == 0.0 {
            return c;
        } else if f(a) * f(c) < 0.0 {
            b = c;
        } else {
            a = c;
        }
        i += 1;
    }
    (a + b) / 2.0
}

fn f(x: f64) -> f64 {
    x.powi(3) - 2.0 * x - 5.0
}

fn main() {
    let eps = 1e-9;
    let max_iter = 100;
    let a = 1.0;
    let b = 2.0;
    let root = bisection(f, a, b, eps, max_iter);
    println!("Root found at x = {}", root);
}

以上代码实现了一个 bisection 函数，它接收一个函数 f、区间的左端点 a 和右端点 b、允许的误差 eps 和最大迭代次数 max_iter。函数使用二分法在 f 中搜索根，并返回找到的根。

总结

这篇文章介绍了在 Rust 中使用牛顿法和二分法计算每个根的方法。牛顿法需要函数的导数函数，但可以更快地收敛到根，而二分法不需要函数的导数，但通常需要更多的迭代次数才能收敛到根。在某些情况下，牛顿法可能会因牵涉到计算数值导数而变得不稳定，此时二分法可能是更好的选择。