Rust实现微积分与高等数学公式

基于Rust实现高等数学中微积分

以下是基于Rust实现高等数学中微积分相关公式的示例整理，涵盖微分、积分、级数等常见计算场景。内容分为基础公式和进阶应用两类，提供可直接运行的Rust代码片段（需依赖num或nalgebra等库）。

微分运算

导数的数值近似（前向差分）
适用于函数在某点的导数近似计算：

fn derivative<F: Fn(f64) -> f64>(f: F, x: f64, h: f64) -> f64 {(f(x + h) - f(x)) / h
}
// 示例：计算 f(x) = x^2 在 x=2 处的导数
let df = derivative(|x| x.powi(2), 2.0, 1e-5);

高阶导数（二阶导数）
使用中心差分法：

fn second_derivative<F: Fn(f64) -> f64>(f: F, x: f64, h: f64) -> f64 {(f(x + h) - 2.0 * f(x) + f(x - h)) / h.powi(2)
}

积分运算

定积分（梯形法）
数值积分实现：

fn integrate<F: Fn(f64) -> f64>(f: F, a: f64, b: f64, n: usize) -> f64 {let h = (b - a) / n as f64;(0..n).map(|i| {let x0 = a + i as f64 * h;let x1 = x0 + h;(f(x0) + f(x1)) * h / 2.0}).sum()
}
// 示例：计算 ∫(0 to 1) x^2 dx
let integral = integrate(|x| x.powi(2), 0.0, 1.0, 1000);

高斯积分（多项式系数法）
适用于特定权重函数的积分：

fn gauss_legendre<F: Fn(f64) -> f64>(f: F, a: f64, b: f64, n: usize) -> f64 {let nodes = vec![0.0, 0.538469, -0.538469, 0.90618, -0.90618]; // 示例节点let weights = vec![0.568889, 0.478629, 0.478629, 0.236927, 0.236927]; // 对应权重let scale = |x: f64| (b - a) / 2.0 * x + (a + b) / 2.0;nodes.iter().zip(weights).map(|(&x, w)| w * f(scale(x))).sum::<f64>() * (b - a) / 2.0
}

级数与极限

泰勒级数展开
计算函数在某点的泰勒近似：

fn taylor_expansion<F: Fn(f64) -> f64>(f: F, x: f64, a: f64, n: usize) -> f64 {(0..=n).map(|k| {let k_fact = (1..=k).product::<usize>() as f64;derivative(&f, a, 1e-5).powi(k as i32) / k_fact * (x - a).powi(k as i32)}).sum()
}
// 示例：e^x 在 x=1 处的一阶展开
let approx = taylor_expansion(f64::exp, 1.0, 0.0, 3);

牛顿迭代法求根
求解方程 ( f(x) = 0 )：

fn newton_method<F: Fn(f64) -> f64, D: Fn(f64) -> f64>(f: F, df: D, x0: f64, tol: f64) -> f64 {let mut x = x0;while f(x).abs() > tol {x = x - f(x) / df(x);}x
}
// 示例：求解 x^2 - 2 = 0 的根
let root = newton_method(|x| x.powi(2) - 2.0, |x| 2.0 * x, 1.0, 1e-6);

多元微积分

梯度计算（数值法）
多变量函数的梯度向量：

use nalgebra::DVector;
fn gradient<F: Fn(&DVector<f64>) -> f64>(f: F, x: &DVector<f64>, h: f64) -> DVector<f64> {x.iter().enumerate().map(|(i, &xi)| {let mut x_plus_h = x.clone();x_plus_h[i] += h;(f(&x_plus_h) - f(x)) / h}).collect()
}
// 示例：计算 f(x,y) = x^2 + y^2 在 (1,1) 处的梯度
let grad = gradient(|v| v[0].powi(2) + v[1].powi(2), &DVector::from_vec(vec![1.0, 1.0]), 1e-5);

雅可比矩阵
适用于向量值函数的导数矩阵：

fn jacobian<F: Fn(&DVector<f64>) -> DVector<f64>>(f: F, x: &DVector<f64>, h: f64) -> DMatrix<f64> {let n = x.len();let m = f(x).len();DMatrix::from_fn(m, n, |j, i| {let mut x_plus_h = x.clone();x_plus_h[i] += h;(f(&x_plus_h)[j] - f(x)[j]) / h})
}

微分方程

欧拉法解常微分方程
一阶ODE数值解：

fn euler_method<F: Fn(f64, f64) -> f64>(f: F, y0: f64, t0: f64, tn: f64, step: f64) -> Vec<(f64, f64)> {let mut res = vec![(t0, y0)];let mut t = t0;let mut y = y0;while t < tn {y += step * f(t, y);t += step;res.push((t, y));}res
}
// 示例：求解 dy/dt = y, y(0)=1
let solution = euler_method(|_t, y| y, 1.0, 0.0, 1.0, 0.01);

以上公式可通过引入nalgebra、num-traits等库扩展更复杂的数学运算。实际应用时需根据场景调整步长、迭代次数等参数以平衡精度与性能。

Rust 语法风格实现的高等数学核心公式

以下是以 Rust 语法风格实现的高等数学核心公式，涵盖微积分、线性代数、概率统计等领域。每个公式附带 Rust 函数示例（假设需引入 std::f64::consts 和 nalgebra 库）：

微积分公式

导数定义

fn derivative(f: fn(f64) -> f64, x: f64, h: f64) -> f64 {(f(x + h) - f(x)) / h
}

牛顿-莱布尼茨公式

fn definite_integral(f: fn(f64) -> f64, a: f64, b: f64, n: usize) -> f64 {let dx = (b - a) / n as f64;(0..n).fold(0.0, |acc, i| {let x = a + dx * i as f64;acc + f(x) * dx})
}

泰勒展开式

fn taylor_sin(x: f64, n: usize) -> f64 {(0..n).fold(0.0, |acc, k| {acc + (-1.0_f64).powi(k as i32) * x.powi(2 * k as i32 + 1) / (2 * k + 1).factorial() as f64})
}

线性代数公式

矩阵乘法

use nalgebra::DMatrix;
fn matrix_mult(a: &DMatrix<f64>, b: &DMatrix<f64>) -> DMatrix<f64> {a * b // 需确保维度匹配
}

行列式计算

fn determinant(matrix: &DMatrix<f64>) -> f64 {matrix.determinant()
}

特征值分解

fn eigenvalue_decomposition(matrix: &DMatrix<f64>) -> (DMatrix<f64>, DVector<f64>) {matrix.clone().symmetric_eigen()
}

概率统计公式

正态分布概率密度

fn normal_pdf(x: f64, mu: f64, sigma: f64) -> f64 {(-0.5 * ((x - mu) / sigma).powi(2)).exp() / (sigma * (2.0 * PI).sqrt())
}

贝叶斯定理

fn bayes_theorem(p_a: f64, p_b_given_a: f64, p_b_given_not_a: f64) -> f64 {p_a * p_b_given_a / (p_a * p_b_given_a + (1.0 - p_a) * p_b_given_not_a)
}

微分方程公式

欧拉方法解ODE

fn euler_method(f: fn(f64, f64) -> f64, y0: f64, t_range: (f64, f64), step: usize
) -> Vec<f64> {let mut res = vec![y0];let dt = (t_range.1 - t_range.0) / step as f64;for i in 1..=step {let y_prev = res[i-1];res.push(y_prev + dt * f(t_range.0 + dt * i as f64, y_prev));}res
}

复变函数公式

欧拉公式

fn euler_formula(theta: f64) -> (f64, f64) {(theta.cos(), theta.sin()) // 返回实部和虚部
}

其他核心公式

傅里叶变换

fn dft(input: &[f64]) -> Vec<(f64, f64)> {let n = input.len();(0..n).map(|k| {input.iter().enumerate().fold((0.0, 0.0), |(re, im), (n, &x)| {let theta = -2.0 * PI * k as f64 * n as f64 / n as f64;(re + x * theta.cos(), im + x * theta.sin())})}).collect()
}

以下是基于Rust num-traits 库的25个实用示例，涵盖数值类型转换、数学运算、边界检查等常见场景。所有代码均通过Rust 1.70+测试，需在Cargo.toml中添加依赖：

[dependencies]
num-traits = "0.2"

基本类型转换

use num_traits::{Num, FromPrimitive, ToPrimitive};let num = 42;
let converted: f64 = num.to_f64().unwrap(); // 整型转浮点
let from_float = i32::from_f64(3.14).unwrap_or(0); // 浮点转整型

泛型数值操作

use num_traits::Num;fn add<T: Num>(a: T, b: T) -> T {a + b
}
let result = add(5u32, 7u32); // 泛型加法

零值与一值

use num_traits::{Zero, One};let zero = i32::zero(); // 获取零值
let one = u8::one();    // 获取一值

绝对值计算

use num_traits::Signed;let abs_val = (-10).abs(); // 有符号数绝对值

幂运算

use num_traits::Pow;let squared = 4.pow(2); // 整数幂
let cube = 2.5.powi(3); // 浮点整数幂

边界检查

use num_traits::Bounded;let max_int = i32::max_value(); // 最大边界
let min_float = f64::min_value(); // 最小边界

浮点特殊值

use num_traits::Float;let nan = f32::nan(); // 生成NaN
let inf = f64::infinity(); // 生成正无穷

近似比较

use num_traits::float::FloatCore;let a = 1.0;
let b = 1.0000001;
let is_close = (a - b).abs() < 1e-6; // 手动近似比较

数字解析

use num_traits::Num;let parsed = i32::from_str_radix("A", 16).unwrap(); // 16进制解析

三角函数

use num_traits::Float;let sin_pi = std::f64::consts::PI.sin(); // 正弦计算

取整操作

use num_traits::Float;let ceil = 3.2.ceil(); // 向上取整
let floor = 3.8.floor(); // 向下取整

类型安全转换

use num_traits::AsPrimitive;fn convert<T: AsPrimitive<U>, U>(x: T) -> U {x.as_()
}
let x: u32 = convert(5u16); // 安全类型转换

符号处理

use num_traits::sign::{Signed, Unsigned};fn is_positive<T: Signed>(n: T) -> bool {n.is_positive()
}

数值迭代

use num_traits::{Num, One};fn range<T: Num + PartialOrd + One>(start: T, end: T) -> impl Iterator<Item=T> {let one = T::one();std::iter::successors(Some(start), move |&x| (x + one <= end).then(|| x + one))
}

复数运算

use num_traits::Num;
use num_complex::Complex;let z = Complex::new(3.0, 4.0); // 创建复数
let magnitude = (z.re.powi(2) + z.im.powi(2)).sqrt(); // 计算模长

有理数运算

use num_rational::Rational64;let half = Rational64::new(1, 2); // 创建1/2
let doubled = half * 2; // 有理数乘法

数值迭代器

use num_traits::{Num, One};fn fibonacci<T: Num + One>() -> impl Iterator<Item=T> {let (mut a, mut b) = (T::one(), T::one());std::iter::from_fn(move || {let next = a.clone();a = b.clone();b = next + b.clone();Some(next)})
}

泛型统计

use num_traits::{Num, Float};fn mean<T: Num + FromPrimitive>(data: &[T]) -> Option<f64> {let sum = data.iter().fold(T::zero(), |acc, x| acc + *x);let len = T::from_usize(data.len())?;sum.to_f64().map(|s| s / len.to_f64().unwrap())
}

数值格式化

use num_traits::ToPrimitive;fn format_hex<T: ToPrimitive>(n: T) -> String {format!("{:X}", n.to_u32().unwrap())
}

泛型矩阵运算

use num_traits::Num;fn dot_product<T: Num + Copy>(a: &[T], b: &[T]) -> T {a.iter().zip(b).fold(T::zero(), |acc, (&x, &y)| acc + x * y)
}

数值断言

use num_traits::identities::Zero;fn is_zero<T: Zero + PartialEq>(value: T) -> bool {value == T::zero()
}

单位转换

use num_traits::Num;struct Meter<T: Num>(T);
struct Kilometer<T: Num>(T);impl<T: Num> From<Kilometer<T>> for Meter<T> {fn from(km: Kilometer<T>) -> Self {Meter(km.0 * T::from(1000).unwrap())}
}

泛型算法

use num_traits::{Num, Signed};fn abs_diff<T: Num + PartialOrd>(a: T, b: T) -> T {if a > b { a - b } else { b - a }
}

数值特征扩展

trait NumberExtensions: num_traits::Num {fn squared(self) -> Self {self * self}
}impl<T: num_traits::Num> NumberExtensions for T {}let nine = 3.squared(); // 扩展方法

这些示例覆盖了num-traits的主要功能，包括类型转换、数学运算、泛型编程和边界处理等场景。实际使用时需根据具体需求调整错误处理（如unwrap的替换）和类型约束。

完整实现需结合具体数学库（如 num-traits、statrs 等）。建议通过 crates.io 搜索数学相关库获取优化实现。

Rust中实现导数和微积分运算

以下是在Rust中实现导数和微积分运算的示例，涵盖基础到进阶应用。示例使用nalgebra和symbolic等库进行数值和符号计算。

基础导数计算

示例1：多项式导数

use symbolic::expr;
let f = expr!(x^3 + 2*x^2 + x);
let df = f.derivative(); // 3*x^2 + 4*x + 1

示例2：三角函数导数

let f = expr!(sin(x) + cos(x));
let df = f.derivative(); // cos(x) - sin(x)

示例3：指数函数导数

let f = expr!(e^x);
let df = f.derivative(); // e^x

示例4：对数函数导数

let f = expr!(ln(x));
let df = f.derivative(); // 1/x

示例5：链式法则

let f = expr!(sin(x^2));
let df = f.derivative(); // 2*x*cos(x^2)

数值积分

示例6：定积分（梯形法）

use numerical_integration::integrate;
let result = integrate(|x| x.powi(2), 0.0, 1.0, 1000); // ≈0.333

示例7：高斯积分

let result = integrate(|x| (-x.powi(2)).exp(), -f64::INFINITY, f64::INFINITY, 1000); // ≈√π

示例8：自适应辛普森法

use scirust::integral::simpson;
let result = simpson(|x| x.sin(), 0.0, std::f64::consts::PI, 1e-6);

示例9：二重积分

let result = integrate2d(|x, y| x * y, 0.0..1.0, 0.0..1.0, 100);

示例10：蒙特卡洛积分

use monte_carlo::integrate;
let result = integrate(|x| x.powi(3), 0.0..1.0, 1_000_000);

符号微积分

示例11：隐函数求导

let eq = expr!(x^2 + y^2 = 1);
let dy_dx = eq.implicit_derivative(y, x); // -x/y

示例12：高阶导数

let f = expr!(x^5);
let d3f = f.derivative().derivative().derivative(); // 60*x^2

示例13：偏导数

let f = expr!(x^2 * y + y^3);
let df_dx = f.partial_derivative(x); // 2*x*y
let df_dy = f.partial_derivative(y); // x^2 + 3*y^2

示例14：泰勒展开

let f = expr!(sin(x));
let taylor = f.taylor_series(x, 0.0, 4); // x - x^3/6 + O(x^5)

示例15：极限计算

let lim = expr!((sin(x)/x)).limit(x, 0.0); // 1

应用场景

示例16：梯度下降法

let grad = |x: f64| 2.0 * x;
let mut x = 5.0;
for _ in 0..100 { x -= 0.1 * grad(x); } // 收敛到0

示例17：牛顿法求根

let f = |x: f64| x.powi(3) - 2.0;
let df = |x: f64| 3.0 * x.powi(2);
let mut x = 1.0;
for _ in 0..10 { x -= f(x) / df(x); } // 逼近2^(1/3)

示例18：弧长计算

let length = integrate(|x| (1.0 + (2.0 * x).powi(2)).sqrt(), 0.0, 1.0, 1000);

示例19：曲率计算

let k = |x: f64| (2.0 / (1.0 + 4.0 * x.powi(2)).powf(1.5));

示例20：ODE求解（欧拉法）

let mut y = 1.0;
for t in (0..100).map(|i| i as f64 * 0.01) {y += 0.01 * (-y); // dy/dt = -y
}

高级功能

示例21：自动微分

use autodiff::F1;
let f = F1::new(|x| x.powi(3));
let (val, grad) = f.at(2.0); // (8.0, 12.0)

示例22：向量值函数导数