Rust线性代数库nano-gemm-f64使用指南

简介

nano-gemm-f64是一个专注于高性能f64矩阵乘法和通用矩阵运算的Rust库。它针对64位浮点矩阵运算进行了优化，特别适合需要高性能线性代数计算的场景。

主要特性

• 高性能f64矩阵乘法实现
• 支持通用矩阵运算(GEMM)
• 针对现代CPU架构优化
• 简洁的API设计
• 无外部依赖(除标准库外)

安装

在Cargo.toml中添加依赖：

[dependencies]
nano-gemm-f64 = "0.1"

基本使用

矩阵乘法

use nano_gemm_f64::Matrix;

fn main() {
    // 创建两个3x3矩阵
    let a = Matrix::from_vec(3, 3, vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]);
    let b = Matrix::from_vec(3, 3, vec![9.0, 8.0, 7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0]);
    
    // 矩阵乘法
    let c = a.gemm(&b);
    
    println!("Matrix multiplication result:\n{}", c);
}

通用矩阵运算(GEMM)

use nano_gemm_f64::{Matrix, Gemm};

fn main() {
    let a = Matrix::from_vec(2, 3, vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0]);
    let b = Matrix::from_vec(3, 2, vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0]);
    
    // 执行通用矩阵运算: C = α*A*B + β*C
    let alpha = 2.0;
    let beta = 0.5;
    let mut c = Matrix::new(2, 2);
    
    c.gemm(alpha, &a, &b, beta);
    
    println!("GEMM result:\n{}", c);
}

高级用法

并行矩阵乘法

use nano_gemm_f64::Matrix;
use rayon::prelude::*;

fn parallel_matrix_multiply(a: &Matrix, b: &Matrix) -> Matrix {
    assert_eq!(a.cols(), b.rows(), "Matrix dimensions mismatch");
    
    let mut result = Matrix::new(a.rows(), b.cols());
    
    // 使用Rayon并行计算
    result.data_mut().par_chunks_mut(b.cols())
        .enumerate()
        .for_each(|(i, row)| {
            for j in 0..b.cols() {
                let mut sum = 0.0;
                for k in 0..a.cols() {
                    sum += a[(i, k)] * b[(k, j)];
                }
                row[j] = sum;
            }
        });
    
    result
}

性能优化示例

use nano_gemm_f64::Matrix;
use std::time::Instant;

fn main() {
    // 创建大型矩阵
    let size = 512;
    let a = Matrix::random(size, size);
    let b = Matrix::random(size, size);
    
    // 测量计算时间
    let start = Instant::now();
    let _ = a.gemm(&b);
    let duration = start.elapsed();
    
    println!("512x512 matrix multiplication took: {:?}", duration);
}

完整示例代码

use nano_gemm_f64::{Matrix, Gemm};
use rayon::prelude::*;
use std::time::Instant;

fn main() {
    // 1. 基本矩阵乘法示例
    println!("=== 基本矩阵乘法 ===");
    let a = Matrix::from_vec(2, 2, vec![1.0, 2.0, 3.0, 4.0]);
    let b = Matrix::from_vec(2, 2, vec![4.0, 3.0, 2.0, 1.0]);
    let result = a.gemm(&b);
    println!("基本乘法结果:\n{}", result);

    // 2. GEMM运算示例
    println!("\n=== GEMM运算 ===");
    let m1 = Matrix::from_vec(2, 3, vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0]);
    let m2 = Matrix::from_vec(3, 2, vec![1.0, 0.5, 2.0, 1.5, 3.0, 2.5]);
    let alpha = 1.5;
    let beta = 0.5;
    let mut c = Matrix::new(2, 2);
    c.gemm(alpha, &m1, &m2, beta);
    println!("GEMM结果:\n{}", c);

    // 3. 并行矩阵乘法示例
    println!("\n=== 并行矩阵乘法 ===");
    let start = Instant::now();
    let p_result = parallel_matrix_multiply(&a, &b);
    println!("并行乘法结果:\n{}", p_result);
    println!("计算耗时: {:?}", start.elapsed());

    // 4. 性能测试
    println!("\n=== 性能测试 ===");
    let large_size = 256;
    let large_a = Matrix::random(large_size, large_size);
    let large_b = Matrix::random(large_size, large_size);
    
    let start = Instant::now();
    let _ = large_a.gemm(&large_b);
    println!("{}x{}矩阵乘法耗时: {:?}", large_size, large_size, start.elapsed());
}

fn parallel_matrix_multiply(a: &Matrix, b: &Matrix) -> Matrix {
    assert_eq!(a.cols(), b.rows(), "矩阵维度不匹配");
    
    let mut result = Matrix::new(a.rows(), b.cols());
    
    // 使用Rayon并行计算
    result.data_mut().par_chunks_mut(b.cols())
        .enumerate()
        .for_each(|(i, row)| {
            for j in 0..b.cols() {
                let mut sum = 0.0;
                for k in 0..a.cols() {
                    sum += a[(i, k)] * b[(k, j)];
                }
                row[j] = sum;
            }
        });
    
    result
}

注意事项

1. 矩阵维度必须匹配，否则会panic
2. 对于非常大的矩阵，考虑内存使用情况
3. 库主要针对f64类型优化，其他类型可能性能不佳

性能建议

1. 尽量复用矩阵对象而不是频繁创建新矩阵
2. 对于重复计算，预分配结果矩阵
3. 考虑使用并行计算处理大型矩阵

nano-gemm-f64为Rust提供了高性能的矩阵运算能力，特别适合科学计算、机器学习和图形处理等需要高效线性代数运算的场景。