基于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：向量值函数导数