Rust数学计算库re_math使用指南

re_math是一个高性能的Rust数学计算库，专注于数值处理和数学运算。它提供了丰富的数学函数和工具，特别适合科学计算、数据分析和工程应用场景。

主要特性

• 高性能数学运算实现
• 优化的数值处理函数
• 向量和矩阵运算支持
• 常用数学常数和特殊函数
• 类型安全的API设计

安装方法

在Cargo.toml中添加依赖：

[dependencies]
re_math = "0.1"  # 请使用最新版本号

基本使用方法

1. 基本数学运算

use re_math::prelude::*;

fn main() {
    // 平方根
    let x = 16.0;
    println!("√{} = {}", x, x.sqrt());
    
    // 幂运算
    let base = 2.0;
    let exponent = 3.0;
    println!("{} ^ {} = {}", base, exponent, base.powf(exponent));
    
    // 三角函数
    let angle = 45.0_f64.to_radians();
    println!("sin(45°) = {}", angle.sin());
    println!("cos(45°) = {}", angle.cos());
}

2. 向量运算

use re_math::vector::{Vec2, Vec3};

fn main() {
    // 创建二维向量
    let v1 = Vec2::new(1.0, 2.0);
    let v2 = Vec2::new(3.0, 4.0);
    
    // 向量加法
    let sum = v1 + v2;
    println!("向量和: {:?}", sum);
    
    // 点积
    let dot_product = v1.dot(v2);
    println!("点积: {}", dot_product);
    
    // 三维向量
    let v3 = Vec3::new(1.0, 0.0, 0.0);
    let v4 = Vec3::new(0.0, 1.0, 0.0);
    
    // 叉积
    let cross = v3.cross(v4);
    println!("叉积: {:?}", cross);
}

3. 矩阵运算

use re_math::matrix::Mat4;

fn main() {
    // 创建4x4单位矩阵
    let identity = Mat4::identity();
    println!("单位矩阵:\n{}", identity);
    
    // 创建平移矩阵
    let translation = Mat4::from_translation([1.0, 2.0, 3.0]);
    println!("平移矩阵:\n{}", translation);
    
    // 矩阵乘法
    let product = identity * translation;
    println!("矩阵乘积:\n{}", product);
}

4. 数值处理

use re_math::numeric;

fn main() {
    // 线性插值
    let a = 0.0;
    let b = 10.0;
    let t = 0.5;
    println!("Lerp: {}", numeric::lerp(a, b, t));
    
    // 数值约束
    let value = 15.0;
    let constrained = numeric::clamp(value, 0.0, 10.0);
    println!("约束后的值: {}", constrained);
    
    // 近似相等比较
    let x = 0.1 + 0.2;
    let y = 0.3;
    println!("近似相等: {}", numeric::approx_eq(x, y));
}

高级功能

1. 随机数生成

use re_math::random;

fn main() {
    // 创建随机数生成器
    let mut rng = random::Rng::new();
    
    // 生成随机浮点数
    let rand_float = rng.range(0.0..1.0);
    println!("随机浮点数: {}", rand_float);
    
    // 生成随机整数
    let rand_int = rng.range(0..100);
    println!("随机整数: {}", rand_int);
}

2. 统计函数

use re_math::statistics;

fn main() {
    let data = [1.0, 2.0, 3.0, 4.0, 5.0];
    
    // 计算均值
    let mean = statistics::mean(&data);
    println!("均值: {}", mean);
    
    // 计算标准差
    let std_dev = statistics::std_dev(&data);
    println!("标准差: {}", std_dev);
    
    // 计算中位数
    let median = statistics::median(&data);
    println!("中位数: {}", median);
}

完整示例demo

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

use re_math::prelude::*;
use re_math::vector::{Vec2, Vec3};
use re_math::matrix::Mat4;
use re_math::numeric;
use re_math::random;
use re_math::statistics;

fn main() {
    println!("=== 基本数学运算示例 ===");
    basic_math_demo();
    
    println!("\n=== 向量运算示例 ===");
    vector_demo();
    
    println!("\n=== 矩阵运算示例 ===");
    matrix_demo();
    
    println!("\n=== 数值处理示例 ===");
    numeric_demo();
    
    println!("\n=== 随机数生成示例 ===");
    random_demo();
    
    println!("\n=== 统计函数示例 ===");
    statistics_demo();
}

fn basic_math_demo() {
    // 平方根计算
    let num = 25.0;
    println!("{}的平方根: {}", num, num.sqrt());
    
    // 指数计算
    println!("e的2次方: {}", std::f64::consts::E.powf(2.0));
    
    // 对数计算
    println!("100的以10为底对数: {}", 100.0.log10());
}

fn vector_demo() {
    // 2D向量运算
    let vec_a = Vec2::new(1.0, 2.0);
    let vec_b = Vec2::new(3.0, 4.0);
    println!("向量A: {:?}", vec_a);
    println!("向量B: {:?}", vec_b);
    println!("向量相加: {:?}", vec_a + vec_b);
    println!("向量点积: {}", vec_a.dot(vec_b));
    
    // 3D向量运算
    let vec_c = Vec3::new(1.0, 0.0, 0.0);
    let vec_d = Vec3::new(0.0, 1.0, 0.0);
    println!("3D向量叉积: {:?}", vec_c.cross(vec_d));
}

fn matrix_demo() {
    // 创建变换矩阵
    let translation = Mat4::from_translation([1.0, 2.0, 3.0]);
    let rotation = Mat4::from_rotation_x(45.0_f64.to_radians());
    let scale = Mat4::from_scale([2.0, 2.0, 2.0]);
    
    // 矩阵组合
    let transform = translation * rotation * scale;
    println!("组合变换矩阵:\n{}", transform);
}

fn numeric_demo() {
    // 插值示例
    let start = 0.0;
    let end = 100.0;
    println!("50%插值: {}", numeric::lerp(start, end, 0.5));
    
    // 约束示例
    println!("约束值到0-10范围: {}", numeric::clamp(15.0, 0.0, 10.0));
}

fn random_demo() {
    let mut rng = random::Rng::new();
    
    // 生成随机数组
    let mut random_data = [0.0; 10];
    for i in 0..10 {
        random_data[i] = rng.range(0.0..100.0);
    }
    println!("随机数组: {:?}", random_data);
}

fn statistics_demo() {
    let data = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0];
    
    println!("数据集: {:?}", data);
    println!("平均值: {}", statistics::mean(&data));
    println!("方差: {}", statistics::variance(&data));
    println!("中位数: {}", statistics::median(&data));
}

性能提示

1. 尽量使用f32而不是f64，如果精度要求不是特别高
2. 对于大量数据，考虑使用批量处理函数
3. 矩阵运算时，尽量复用矩阵对象而不是频繁创建新矩阵

re_math库通过精心优化的算法和Rust的零成本抽象，提供了高性能的数学计算能力，是科学计算和工程应用的理想选择。