Rust 的数值计算：深入了解类似 NumPy 的库 – wiki基地

深入 Rust 数值计算：探索与 NumPy 媲美的库

数值计算是科学研究、工程实践、数据分析、机器学习等众多领域的基石。在过去的几十年里，Python 凭借其简洁的语法和庞大而成熟的生态系统，尤其是 NumPy 库，成为了数值计算领域的事实标准。NumPy 提供了强大的 N 维数组对象以及广播（Broadcasting）、切片（Slicing）、矢量化操作等功能，极大地简化了数值算法的实现。

然而，随着计算需求的不断增长和软件系统复杂性的提升，Python/NumPy 的一些局限性也逐渐显现，例如：

性能瓶颈： 尽管 NumPy 的底层实现通常是 C、C++ 或 Fortran，但 Python 本身是解释型语言，且存在全局解释器锁（GIL），这在处理纯 Python 逻辑或需要细粒度并行时可能成为性能瓶颈。
内存安全： Python 依赖垃圾回收，虽然方便，但在对内存布局有精细控制需求或在安全性要求高的场景下，可能不如手动内存管理或 Rust 的所有权系统可靠。
部署复杂性： Python 应用通常需要依赖解释器和大量库，部署有时不够便捷，尤其是在构建高性能、独立的二进制文件时。

正是在这样的背景下，Rust 语言作为一种强调性能、内存安全和并发性的系统级编程语言，开始引起数值计算领域的关注。Rust 拥有接近 C/C++ 的执行速度，同时通过其创新的所有权系统和借用检查器，在编译时保证内存安全，避免了空指针引用、数据竞争等问题，且没有垃圾回收的开销。这些特性使得 Rust 成为构建高性能数值计算库和应用的有力候选者。

本文将深入探讨 Rust 在数值计算领域的现状，重点介绍与 NumPy 功能类似的库，分析它们的特性、优势与不足，并展望 Rust 在这一领域的未来发展。

Rust 数值计算的生态概览

与 Python 经过数十年积累形成的庞大数值计算和科学计算生态（NumPy, SciPy, Pandas, Matplotlib, scikit-learn, TensorFlow, PyTorch等）相比，Rust 的生态尚处于发展阶段。但这并不意味着 Rust 在这一领域缺乏能力。恰恰相反，Rust 社区正在积极构建高性能、安全的数值计算基础设施。

Rust 的数值计算生态主要围绕以下几个核心需求构建：

N 维数组操作： 提供类似于 NumPy 的 N 维数组对象，支持高效的索引、切片、重塑、元素级操作和广播。
线性代数： 支持向量、矩阵的创建、操作，以及各种线性代数运算（如矩阵乘法、求逆、特征值分解等）。
统计与优化： 提供基本的统计函数、随机数生成、优化算法等。
科学计算通用工具： 插值、积分、常微分方程求解等。
与外部库的集成： 能够方便地调用高性能的底层库，如 BLAS（基础线性代数子程序）、LAPACK（线性代数包），以及与其他语言（如 Python）进行高效互操作。

在这些需求中，与 NumPy 的核心功能（N 维数组和基本操作）最为直接对应的 Rust 库主要有两个：ndarray 和 nalgebra。

ndarray: Rust 的 N 维数组利器

ndarray 是 Rust 生态中最接近 NumPy 的 N 维数组库。它的设计哲学和 API 在很大程度上受到了 NumPy 的启发，旨在提供一个灵活、高效且符合 Rust 范式（如所有权、借用）的多维数组结构。

核心特性：

N 维数组 (Array)： 提供通用的 Array<A, D> 结构，其中 A 是元素类型，D 是维度类型（如 Ix1, Ix2, Ix3, IxDyn 表示 1D, 2D, 3D, 动态维度）。
多种数组视图 (ArrayView, ArrayViewMut)： 支持对数组数据的不可变借用 (ArrayView) 和可变借用 (ArrayViewMut)，避免数据拷贝，提高效率，同时符合 Rust 的借用规则。
切片和索引： 提供丰富的切片（Slice）和索引（Index）功能，类似于 NumPy 的语法，但通过宏和方法实现，确保类型安全。
广播 (Broadcast)： 支持 NumPy 式的广播机制，允许不同形状的数组在某些操作中兼容，无需手动复制或重塑数据。
元素级操作： 支持常见的算术、逻辑、比较等元素级操作，通过特征（Traits）和操作符重载实现。
轴操作： 支持沿指定轴进行求和、平均、最大值、最小值等操作。
与 BLAS/LAPACK 集成： 通过可选的 Cargo 特性（features），可以与底层高性能库如 OpenBLAS, Netlib BLAS/LAPACK 集成，显著加速线性代数运算。
并行计算： 可以方便地结合 rayon 库实现数组操作的并行化。

使用示例：

“`rust
use ndarray::{array, Array, ArrayD, IxDyn};
use ndarray::prelude::*;
use ndarray::Slice;

fn main() {
// 创建一维数组 (Vector)
let v1: Array1 = array![1.0, 2.0, 3.0, 4.0];
println!(“一维数组 v1:\n{:?}”, v1);

// 创建二维数组 (Matrix)
let m1: Array2<f64> = array![[1.0, 2.0, 3.0],
                             [4.0, 5.0, 6.0]];
println!("二维数组 m1 (形状 {:?}):\n{:?}", m1.shape(), m1);

// 创建动态维度数组
let data = vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0];
let mut arr_dyn: ArrayD<f64> = Array::from_shape_vec(IxDyn(&[2, 3]), data).unwrap();
println!("动态维度数组 (形状 {:?}):\n{:?}", arr_dyn.shape(), arr_dyn);

// 索引和切片
println!("m1 的元素 (0, 1): {}", m1[[0, 1]]); // 索引
println!("m1 的第一行切片: {:?}", m1.slice(s![0, ..])); // 切片
println!("m1 的第一列切片: {:?}", m1.slice(s![.., 0]));

// 元素级操作
let m2 = &m1 * 2.0 + 1.0;
println!("元素级操作 (&m1 * 2.0 + 1.0):\n{:?}", m2);

// 广播 (将一维数组广播到二维数组的每一行)
let row_vec: Array1<f64> = array![10.0, 20.0, 30.0];
let m3 = &m1 + &row_vec; // row_vec 被广播到每一行
println!("广播操作 (&m1 + &row_vec):\n{:?}", m3);

// 矩阵乘法 (需要启用 linop trait 或 BLAS 特性)
// 假设我们有一个 2x3 的矩阵 m1 和一个 3x2 的矩阵 m4
let m4: Array2<f64> = array![[1.0, 2.0],
                             [3.0, 4.0],
                             [5.0, 6.0]];
// 需要 use ndarray::linalg::general_mat_mul; 或者启用blas feature
// let m_mul = m1.dot(&m4); // 如果启用了 BLAS
// println!("矩阵乘法 (m1 * m4):\n{:?}", m_mul); // 结果是 2x2 矩阵

// 轴操作
println!("m1 沿轴 0 求和: {:?}", m1.sum_axis(Axis(0))); // [5.0, 7.0, 9.0]
println!("m1 沿轴 1 求和: {:?}", m1.sum_axis(Axis(1))); // [6.0, 15.0]

// 并行求和 (需要启用 rayon 特性)
// use rayon::prelude::*;
// let sum_parallel = m1.par_iter().sum::<f64>();
// println!("并行求和: {}", sum_parallel);

}
“`

ndarray 提供了 NumPy 用户熟悉的大部分基本数组操作，并且通过 Rust 的所有权和借用系统，能够高效地管理内存和并发。它的灵活性在于支持任意维度和动态维度，适用于需要处理各种形状数据的场景。

nalgebra: 专注于线性代数和几何计算

nalgebra 是 Rust 中另一个重要的数值计算库，但它的侧重点与 ndarray 有所不同。nalgebra 更专注于向量、矩阵以及与之相关的线性代数和几何计算，尤其适用于需要处理固定大小向量和矩阵（例如 2D/3D 图形、物理模拟、机器人学）的场景。

核心特性：

向量 (Vector) 和矩阵 (Matrix)： 提供 Vector<T, D> 和 Matrix<T, R, C> 等结构。
静态维度和动态维度： 支持在编译时确定大小（静态维度，通过类型系统表示，如 Vector3<f32>, Matrix2x3<f64>）和运行时确定大小（动态维度，如 DVector<f64>, DMatrix<f64>）。静态维度在编译时进行尺寸检查，并通常能生成更优化的代码。
丰富的线性代数运算： 提供矩阵乘法、求逆、分解（LU, QR, Cholesky, SVD 等）、特征值计算、线性方程组求解等功能。
几何变换： 支持旋转、平移、缩放等几何变换，以及四元数（Quaternion）等。
SIMD 加速： 利用 Rust 的 SIMD 指令集支持，对常见操作进行向量化加速。
与 BLAS/LAPACK 集成： 同样支持通过可选特性与高性能底层库集成，实现高性能的线性代数计算。

使用示例：

“`rust
use nalgebra::{Vector3, Matrix2x3, Matrix3x2, DVector, DMatrix};
use nalgebra::linalg::SVD;

fn main() {
// 创建静态大小向量和矩阵
let v1 = Vector3::new(1.0, 2.0, 3.0);
println!(“静态向量 v1:\n{:?}”, v1);

let m1 = Matrix2x3::new(1.0, 2.0, 3.0,
                         4.0, 5.0, 6.0);
println!("静态矩阵 m1 (形状 {:?}x{:?}):\n{:?}", m1.nrows(), m1.ncols(), m1);

// 创建动态大小向量和矩阵
let dv1 = DVector::from_row_slice(3, &[1.0, 2.0, 3.0]);
println!("动态向量 dv1:\n{:?}", dv1);

let dm1 = DMatrix::from_vec(2, 3, vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0]);
println!("动态矩阵 dm1 (形状 {:?}x{:?}):\n{:?}", dm1.nrows(), dm1.ncols(), dm1);

// 矩阵乘法
let m2 = Matrix3x2::new(1.0, 2.0,
                         3.0, 4.0,
                         5.0, 6.0);
let m_mul = m1 * m2; // 静态矩阵乘法，编译时检查维度兼容性
println!("静态矩阵乘法 (m1 * m2):\n{:?}", m_mul); // 结果是 2x2 矩阵

// 动态矩阵乘法
let dm2 = DMatrix::from_vec(3, 2, vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0]);
let dm_mul = dm1 * dm2; // 动态矩阵乘法，运行时检查维度兼容性
println!("动态矩阵乘法 (dm1 * dm2):\n{:?}", dm_mul); // 结果是 2x2 矩阵

// 线性代数操作 - 求逆 (需要方阵)
let m_square = DMatrix::new(2, 2, vec![1.0, 2.0, 3.0, 4.0]);
if let Some(m_inv) = m_square.try_inverse() {
    println!("方阵的逆:\n{:?}", m_inv);
} else {
    println!("方阵不可逆");
}

// 线性代数操作 - SVD 分解
let dm3 = DMatrix::new(3, 2, vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0]);
let svd = SVD::new(dm3.clone(), true, true);
if let Some(svd) = svd {
    println!("SVD 分解 U:\n{:?}", svd.u);
    println!("SVD 分解 S:\n{:?}", svd.singular_values); // 奇异值向量
    println!("SVD 分解 V_t:\n{:?}", svd.v_t);
} else {
     println!("SVD 分解失败");
}

// 几何变换 (通常使用静态大小向量/矩阵)
use nalgebra::{Rotation3, Point3};
let point = Point3::new(1.0, 2.0, 3.0);
let axis = Vector3::new(0.0, 0.0, 1.0); // Z 轴
let angle = std::f32::consts::PI / 2.0; // 旋转 90 度
let rotation = Rotation3::from_axis_angle(&axis, angle);
let rotated_point = rotation * point;
println!("原始点: {:?}, 绕 Z 轴旋转 90 度后的点: {:?}", point, rotated_point); // 应该接近 [-2.0, 1.0, 3.0]

}
“`

nalgebra 的优势在于其强大的线性代数功能以及对静态维度的支持，这使得它在编译时就能捕获许多尺寸不匹配的错误，并通常能生成非常高效的代码，尤其适合对性能要求极高的几何计算和线性代数核心。

ndarray vs nalgebra: 如何选择？

使用 ndarray 当：
- 你需要处理具有任意或动态维度的 N 维数组。
- 你的核心任务是数组的创建、操作（切片、索引、重塑）、元素级运算和广播。
- 你的问题更侧重于数据数组的处理，而不是纯粹的线性代数概念。
- 你需要与 NumPy 的数组概念进行最直接的映射。
使用 nalgebra 当：
- 你的问题集中在线性代数和几何计算（向量、矩阵、变换）。
- 你可以或更愿意使用固定大小的向量和矩阵，以便在编译时进行维度检查和优化。
- 你需要访问高级的线性代数分解和求解算法。
- 你的应用场景涉及图形学、物理引擎、机器人学等。

值得注意的是，这两个库并非完全互斥。在某些复杂的应用中，你可能需要同时使用它们，例如使用 ndarray 加载和预处理多维数据，然后将其转换为 nalgebra 的矩阵进行高性能的线性代数计算。它们之间也提供了一些互相转换的功能。

其他相关库

除了 ndarray 和 nalgebra，Rust 生态中还有一些其他与数值计算相关的库：

Faer: 一个较新的库，专注于提供纯 Rust 实现的高性能线性代数例程，旨在与 OpenBLAS 等媲美，不依赖外部 C 库，且利用 Rust 的特性实现零开销抽象。
rustfft: 一个高性能的纯 Rust 实现的快速傅里叶变换库。
statrs: 提供统计分布、假设检验等功能的库。
rand: 强大的随机数生成库，对于模拟和采样至关重要。
plotters: 一个绘图库，可以将计算结果可视化，尽管功能上不如 Matplotlib 成熟，但正在快速发展。
argmin: 一个用于优化算法的库。

这些库共同构成了 Rust 数值计算生态的基础，虽然整体规模和成熟度不及 Python，但核心组件的高性能和安全性是其显著优势。

核心概念在 Rust 中的实现

将 NumPy 的强大功能映射到 Rust 中，并同时利用 Rust 的特性，需要对一些核心概念进行深入理解：

1. N 维数组与数据布局

NumPy 的 ndarray 通常将数据存储在连续的内存块中，通过步长（strides）来描述维度和元素间的偏移。ndarray 库也采用了类似的设计。一个 ndarray::Array 结构包含数据指针（或视图）、形状（shape）和步长（strides）。

所有权 (Array) vs. 借用 (ArrayView, ArrayViewMut)： 这是与 NumPy 的一个重要区别。在 Rust 中，数组可以是拥有的 (Array)，这意味着数据归数组结构本身所有；也可以是借用的视图 (ArrayView, ArrayViewMut)，它们不拥有数据，只是提供了访问原始数组（或其他视图）部分或全部数据的窗口。这种设计避免了不必要的数据拷贝，并强制执行 Rust 的借用规则，防止数据竞争。NumPy 的切片默认创建的是视图，这与 ndarray 的 slice() 方法行为类似。
连续性 (Contiguous)： 连续数组（C-order 或 F-order）是内存布局最紧凑、对缓存最友好的。ndarray 可以检查数组或视图是否连续，并对连续数组执行更优化的操作。非连续视图（例如转置、非单位步长的切片）的操作可能涉及更多间接访问。

2. 矢量化操作和广播

NumPy 的核心优势之一是矢量化操作和广播，它允许在整个数组上高效地执行操作，而无需编写显式的循环。Rust 库通过操作符重载和特定的方法来实现类似功能。

操作符重载： ndarray 和 nalgebra 都为数组/矩阵类型实现了 std::ops 中的各种特征，如 Add, Mul, Sub, Div 等。这使得你可以使用 +, -, *, / 等操作符直接对整个数组或矩阵进行元素级或线性代数运算（取决于库和上下文）。
广播： ndarray 库实现了 NumPy 式的广播逻辑。当两个形状不兼容的数组进行二元操作时（如 +），如果它们的形状满足广播规则，其中一个或两个数组会被“虚拟地”扩展以匹配另一个的形状，而无需实际复制数据。这通过在内部调整视图的步长来实现。在 ndarray 中，广播是自动发生的，当操作符应用于 Array、ArrayView 或 ArrayViewMut 时。
方法链： Rust 的方法链式调用（如 array.sum_axis(Axis(0)).mapv(|x| x.sqrt())）提供了类似于函数式编程的流畅性，可以构建复杂的矢量化操作序列。

3. 线性代数

线性代数是数值计算的核心。nalgebra 和 ndarray 都提供了线性代数功能，但实现和侧重点不同。

nalgebra 的线性代数： nalgebra 内置了许多线性代数算法的纯 Rust 实现，同时也支持通过特性启用 BLAS/LAPACK 绑定。它的 API 设计更贴近线性代数概念，例如 matrix * vector 乘法是直接的矩阵向量乘积，而 ndarray 的 * 是元素级乘法，矩阵乘法需要使用 .dot() 方法（如果启用 BLAS feature）或 ndarray::linalg 中的函数。nalgebra 的静态维度矩阵在编译时就知道大小，这使得它可以利用更多编译时优化，例如对小矩阵进行硬编码的展开乘法，效率极高。
ndarray 的线性代数： ndarray 本身提供了一些基本的线性代数操作，但对于高性能的矩阵乘法、分解等，强烈依赖于与外部 BLAS/LAPACK 库的集成。启用 blas 特性后，ndarray 的 .dot() 方法会调用 BLAS 的 gemm 函数，这是实现高性能矩阵乘法的关键。

选择 BLAS/LAPACK 绑定： 在 Rust 中使用 BLAS/LAPACK 通常通过 *-sys crate 实现，例如 openblas-sys, netlib-sys, intel-mkl-sys。这些 crate 负责链接到系统上安装的 BLAS/LAPACK 库。为了获得最佳性能，通常推荐安装一个高性能的 BLAS 实现（如 OpenBLAS, Intel MKL）并在 Rust 项目中启用相应的特性。Faer 则提供了纯 Rust 的高性能替代方案。

4. 并行计算

Rust 的所有权和借用系统天然支持并发，因为它在编译时就防止了数据竞争。利用这一点，可以方便地将数值计算任务并行化。

Rayon 集成： ndarray 可以与 rayon 库无缝集成。rayon 是一个数据并行库，可以轻松地将迭代器转换为并行迭代器 (par_iter())。通过启用 ndarray 的 rayon 特性，你可以对数组的元素、轴等进行并行迭代和操作，从而利用多核处理器的能力加速计算。

“`rust
// 示例：并行计算数组元素的平方和 (需要启用 ndarray 的 “rayon” 特性)
use ndarray::array;
use rayon::prelude::*;

let arr = array![1.0, 2.0, 3.0, 4.0, 5.0];
let sum_sq: f64 = arr.axis_iter(Axis(0)) // 迭代每一行 (这里是一维数组，所以是元素)
.into_par_iter() // 转为并行迭代器
.map(|row| row[0].powi(2)) // 对每个元素计算平方
.sum(); // 求和
println!(“并行平方和: {}”, sum_sq);
“`

Rust 与 Python/NumPy 的对比与权衡

将 Rust 用于数值计算，尤其是替代部分 Python/NumPy 工作流时，需要仔细权衡两者优劣：

Rust 的优势：

极致性能： Rust 代码，尤其是结合 BLAS/LAPACK 或 SIMD 优化的部分，通常能达到与 C/C++ 媲美的性能，远超纯 Python。
内存安全与控制： Rust 在编译时保证内存安全，消除了空指针、数据竞争等常见 bug。同时，开发者对内存布局有更精细的控制。
并发安全： Rust 的所有权系统使得编写线程安全的并行代码变得更加容易和可靠。
独立部署： Rust 可以编译成独立的二进制文件，部署简单，无需依赖外部运行时（如 Python 解释器）或大量库。
构建库： Rust 非常适合编写高性能库供其他语言调用（通过 FFI），可以将性能瓶颈部分用 Rust 实现，而应用层仍使用 Python 等更易用的语言。

Rust 的不足：

生态成熟度： 与 Python 丰富的数值计算和科学计算库相比，Rust 的生态系统尚不完善。虽然核心库（如 ndarray, nalgebra）功能强大，但在统计分析、机器学习、可视化、优化算法、特定领域工具等方面，Python 拥有更多成熟、易用的选项。
学习曲线： Rust 的所有权系统、借用检查器等概念对初学者有一定挑战性，学习曲线相对陡峭。
开发效率： 对于快速原型开发和探索性数据分析，Python 及其交互式环境（如 Jupyter Notebook）通常更高效。Rust 的编译过程和类型系统在开发初期可能感觉更繁琐。
交互性与可视化： Python 在交互式数据探索和结果可视化方面有明显的优势（Jupyter, Matplotlib）。Rust 的交互式环境和绘图库仍在发展中。

权衡点：

纯 Rust vs. Python + Rust FFI： 如果追求极致的性能和安全性，且愿意投入学习成本，构建纯 Rust 应用是可行的。但更常见且实用的模式可能是“混合架构”，即使用 Python 作为胶水语言进行数据加载、预处理、可视化和模型管理，而将性能最关键的计算密集型部分用 Rust 实现为库，通过 FFI（如 PyO3, rust-cpython）供 Python 调用。这能结合两者的优势。
项目需求： 如果项目对性能、内存安全或独立部署有严格要求，或者要构建一个高性能的基础库，Rust 是一个非常好的选择。如果项目更侧重于快速迭代、数据探索、利用现有的大量科学计算工具，那么 Python 可能仍然是更合适的起点。

未来展望

Rust 在数值计算领域的未来是充满希望的。社区正在积极填补生态系统的空白，例如：

高性能纯 Rust 线性代数库（Faer）： 减少对外部 C 库的依赖，提高跨平台兼容性和易用性。
统计和优化库的完善： 逐步构建更全面的统计分析和优化工具集。
机器学习框架： Aunque Rust 尚没有像 TensorFlow 或 PyTorch 那样统治级的通用 ML 框架，但已经有一些工作在进行，例如 burn。或者通过绑定现有框架来使用 Rust 进行模型训练或推理。
可视化工具的进步： plotters 等绘图库的持续发展。
与 Python 等语言的互操作性增强： PyO3 等库的不断改进，使得 Rust 和 Python 的集成更加顺畅。

随着 Rust 语言的成熟和社区规模的扩大，相信 Rust 在数值计算领域将扮演越来越重要的角色，特别是在需要高性能、高可靠性的场景。

结论

Rust 凭借其卓越的性能、内存安全和并发能力，为数值计算领域提供了一个强大的替代方案。虽然其生态系统与 Python 相比仍显年轻，但 ndarray 和 nalgebra 等核心库已经提供了媲美 NumPy 的 N 维数组操作和线性代数功能，并且在性能和安全性方面具有显著优势。

选择 Rust 进行数值计算，意味着接受 steeper 的学习曲线和尚在成长中的生态，但换来的是对计算过程更底层的控制、更高的执行效率以及在编译时就能捕获许多潜在错误的安全性。对于对性能有极致要求、需要构建可靠的基础设施或希望将计算核心与应用层解耦（例如通过 FFI）的项目，Rust 是一个非常值得考虑的选项。

Rust 正在逐步构建自己的科学计算堡垒。虽然短期内难以完全取代 Python/NumPy 在数据分析和快速原型领域的地位，但它无疑正在成为构建高性能、安全数值计算组件和应用的有力竞争者。深入了解并掌握 ndarray、nalgebra 等库，将为你在需要这些关键特性的项目中开启新的可能性。