Rust数值计算与科学计算库peroxide使用指南

peroxide是一个Rust语言的高性能数值计算与科学计算库，提供了矩阵运算、自动微分和优化算法等功能。下面介绍其主要功能和使用方法。

安装

在Cargo.toml中添加依赖：

[dependencies]
peroxide = "0.24"

主要功能

1. 矩阵运算

peroxide提供了高性能的矩阵运算功能：

use peroxide::fuga::*;

fn main() {
    // 创建矩阵
    let a = matrix(vec![1., 2., 3., 4.], 2, 2, Row);
    let b = matrix(vec![5., 6., 7., 8.], 2, 2, Row);
    
    // 矩阵加法
    let c = &a + &b;
    c.print(); // [6, 8; 10, 12]
    
    // 矩阵乘法
    let d = &a * &b;
    d.print(); // [19, 22; 43, 50]
    
    // 转置
    let a_t = a.transpose();
    a_t.print(); // [1, 3; 2, 4]
}

2. 自动微分

peroxide支持前向自动微分：

use peroxide::fuga::*;

fn main() {
    // 定义变量并启用自动微分
    let x = AD1(2.0, 1.0); // 值为2.0，初始导数为1.0
    
    // 计算函数及其导数
    let y = x.powi(3) + 2f64 * x;
    println!("f(2) = {}", y.x());  // 函数值: 12
    println!("f'(2) = {}", y.dx()); // 导数值: 14
}

3. 优化算法

peroxide提供了多种优化算法，如梯度下降：

use peroxide::fuga::*;

fn main() {
    // 定义要优化的函数
    let f = |x: Vec<f64>| x[0].powi(2) + x[1].powi(2);
    
    // 初始点
    let init = vec![10.0, 10.0];
    
    // 使用梯度下降法优化
    let opt = Optimizer::new(f, init)
        .set_method(LevenbergMarquardt)
        .set_max_iter(100)
        .optimize();
    
    println!("Optimal point: {:?}", opt.get_x()); // 接近 [0, 0]
    println!("Optimal value: {}", opt.get_y()); // 接近 0
}

高级功能

线性代数运算

use peroxide::fuga::*;

fn main() {
    let m = matrix(vec![1., 2., 3., 4.], 2, 2, Row);
    
    // 行列式
    let det = m.det();
    println!("Determinant: {}", det); // -2.0
    
    // 逆矩阵
    let inv = m.inv();
    inv.print(); // [-2, 1; 1.5, -0.5]
    
    // 特征值分解
    let eig = m.eigen();
    eig.values.print(); // 特征值
    eig.vectors.print(); // 特征向量
}

数值积分

use peroxide::fuga::*;

fn main() {
    // 定义要积分的函数
    let f = |x: f64| x.sin();
    
    // 在区间[0, PI]上积分
    let integral = integrate(f, (0f64, PI));
    println!("Integral of sin from 0 to PI: {}", integral); // 约2.0
}

统计计算

use peroxide::fuga::*;

fn main() {
    let data = vec![1.0, 2.0, 3.0, 4.0, 5.0];
    
    // 基本统计量
    println!("Mean: {}", data.mean());
    println!("Variance: {}", data.variance());
    println!("Standard deviation: {}", data.sd());
    
    // 线性回归
    let x = vec![1.0, 2.0, 3.0, 4.0, 5.0];
    let y = vec![2.0, 3.0, 5.0, 4.0, 6.0];
    let lr = LinearRegression::new(&x, &y);
    println!("Slope: {}", lr.slope());
    println!("Intercept: {}", lr.intercept());
}

性能提示

1. 对于大规模矩阵运算，使用&引用避免不必要的复制
2. 设置OMP_NUM_THREADS环境变量可以控制并行计算线程数
3. 对于固定大小的矩阵，考虑使用Matrix::from_shape提高性能

peroxide结合了Rust的性能优势与科学计算所需的丰富功能，是Rust生态中数值计算的重要选择。

完整示例代码

下面是一个结合多个功能的完整示例：

use peroxide::fuga::*;

fn main() {
    // 1. 矩阵运算示例
    println!("=== 矩阵运算示例 ===");
    matrix_operations();
    
    // 2. 自动微分示例
    println!("\n=== 自动微分示例 ===");
    automatic_differentiation();
    
    // 3. 优化算法示例
    println!("\n=== 优化算法示例 ===");
    optimization();
    
    // 4. 线性代数运算示例
    println!("\n=== 线性代数运算示例 ===");
    linear_algebra();
    
    // 5. 数值积分示例
    println!("\n=== 数值积分示例 ===");
    numerical_integration();
    
    // 6. 统计计算示例
    println!("\n=== 统计计算示例 ===");
    statistics();
}

fn matrix_operations() {
    // 创建两个2x2矩阵
    let a = matrix(vec![1., 2., 3., 4.], 2, 2, Row);
    let b = matrix(vec![5., 6., 7., 8.], 2, 2, Row);
    
    // 矩阵加法
    let sum = &a + &b;
    println!("矩阵加法结果:");
    sum.print();
    
    // 矩阵乘法
    let product = &a * &b;
    println!("矩阵乘法结果:");
    product.print();
    
    // 矩阵转置
    let transpose = a.transpose();
    println!("矩阵转置结果:");
    transpose.print();
}

fn automatic_differentiation() {
    // 创建自动微分变量 (值=3.0, 初始导数=1.0)
    let x = AD1(3.0, 1.0);
    
    // 计算函数 y = x^2 + 3x
    let y = x.powi(2) + 3f64 * x;
    
    println!("在x=3处:");
    println!("函数值: {}", y.x());    // 应该输出18 (3^2 + 3*3 = 9 + 9 = 18)
    println!("导数值: {}", y.dx());   // 应该输出9 (2*3 + 3 = 9)
}

fn optimization() {
    // 定义要优化的Rosenbrock函数
    let f = |x: Vec<f64>| (1.0 - x[0]).powi(2) + 100.0 * (x[1] - x[0].powi(2)).powi(2);
    
    // 初始点
    let init = vec![-1.2, 1.0];
    
    // 使用Levenberg-Marquardt算法优化
    let opt = Optimizer::new(f, init)
        .set_method(LevenbergMarquardt)
        .set_max_iter(100)
        .optimize();
    
    println!("最优解点: {:?}", opt.get_x()); // 接近 [1, 1]
    println!("最优解值: {}", opt.get_y());   // 接近 0
}

fn linear_algebra() {
    // 创建一个3x3矩阵
    let m = matrix(vec![2., -1., 0., -1., 2., -1., 0., -1., 2.], 3, 3, Row);
    
    // 计算行列式
    println!("矩阵行列式: {}", m.det());
    
    // 计算逆矩阵
    println!("逆矩阵:");
    m.inv().print();
    
    // 特征值分解
    let eig = m.eigen();
    println!("特征值:");
    eig.values.print();
    println!("特征向量:");
    eig.vectors.print();
}

fn numerical_integration() {
    // 定义要积分的函数
    let f = |x: f64| x.exp(); // e^x
    
    // 在区间[0, 1]上积分
    let integral = integrate(f, (0f64, 1f64));
    println!("e^x在[0,1]上的积分: {}", integral); // 应该接近 e - 1 ≈ 1.71828
    
    // 另一个积分示例
    let g = |x: f64| x.powi(2); // x^2
    let integral_g = integrate(g, (0f64, 2f64));
    println!("x^2在[0,2]上的积分: {}", integral_g); // 应该接近8/3≈2.6667
}

fn statistics() {
    // 创建数据集
    let data = vec![23.4, 12.5, 34.2, 17.8, 29.1];
    
    // 基本统计量
    println!("平均值: {}", data.mean());
    println!("方差: {}", data.variance());
    println!("标准差: {}", data.sd());
    
    // 线性回归示例
    let x = vec![1.0, 2.0, 3.0, 4.0, 5.0];
    let y = vec![1.5, 3.8, 6.7, 9.1, 11.2];
    let lr = LinearRegression::new(&x, &y);
    
    println!("回归斜率: {}", lr.slope());
    println!("回归截距: {}", lr.intercept());
    
    // 预测新值
    let new_x = 6.0;
    println!("x={}时的预测值: {}", new_x, lr.predict(new_x));
}

这个完整示例展示了peroxide库的主要功能，包括矩阵运算、自动微分、优化算法、线性代数运算、数值积分和统计计算。每个功能都被封装在一个单独的函数中，方便理解和测试。