用户指南 | 文档

线性代数库 适用于Rust编程语言。

lib.rs:

为nalgebra提供稀疏矩阵格式和稀疏矩阵上的算法。

此crate通过稀疏矩阵格式和稀疏矩阵上的操作扩展了nalgebra。

目标

此crate的长期目标如下。

• 提供易于使用和符合Rust风格的API，以易于使用和自然地与nalgebra集成的方式来提供经过验证的稀疏矩阵格式。
• 提供额外的专家级API，以实现对操作的细粒度控制。
• 与外部稀疏矩阵库良好集成。
• 提供原生Rust高性能例程，包括并行矩阵运算。

突出当前功能

• CSR、CSC和COO格式，以及它们之间的转换。
• 实现了常见的算术运算。请参阅[ops]模块。
• CSC和CSR矩阵中的稀疏模式通过SparsityPattern类型显式表示，该类型编码关联索引数据结构的不变性。
• 当启用io功能时，支持Matrix market格式。
• 当启用功能proptest-support时，支持稀疏矩阵的proptest策略。
• 支持matrixcompare，以便在测试代码中轻松（近似）比较矩阵（需要启用compare功能）。

当前状态

该库处于早期但可用的状态。API 已设计为可扩展的，但为了实现一些计划中的功能，可能需要进行破坏性更改。虽然它背后有一个庞大的测试套件，但它还没有在真实应用中得到彻底的实战测试。此外，到目前为止，重点一直放在正确性和 API 设计上，而对性能的关注较少。未来的改进将包括渐进式性能提升。

当前限制

• 稀疏系统求解器可用性有限或不可用。
• 对复数支持有限。目前仅支持不依赖于复数特定属性的算术运算，例如共轭等。
• 没有与外部库的集成。

使用方法

将以下内容添加到您的 Cargo.toml 文件中

[dependencies]
nalgebra_sparse = "0.1"

支持的矩阵格式

最佳使用格式取决于应用。在科学中，稀疏矩阵最常见的使用案例是解决稀疏线性系统。这里我们可以区分两种常见情况

• 直接求解器。通常，直接求解器以 CSR 或 CSC 格式接收输入。
• 迭代求解器。许多迭代求解器只需要矩阵-向量乘积，CSR 或 CSC 格式非常适合。

COO 格式主要用于矩阵构建。一种常见模式是在构建时使用 COO，然后将其转换为 CSR 或 CSC 格式，以用于直接求解器或用于迭代求解器中的矩阵-向量乘积。一些高性能应用程序也可能直接操作 CSR 和/或 CSC 格式。

示例：COO -> CSR -> 矩阵-向量乘积

use nalgebra_sparse::{coo::CooMatrix, csr::CsrMatrix};
use nalgebra::{DMatrix, DVector};
use matrixcompare::assert_matrix_eq;

// The dense representation of the matrix
let dense = DMatrix::from_row_slice(3, 3,
    &[1.0, 0.0, 3.0,
      2.0, 0.0, 1.3,
      0.0, 0.0, 4.1]);

// Build the equivalent COO representation. We only add the non-zero values
let mut coo = CooMatrix::new(3, 3);
// We can add elements in any order. For clarity, we do so in row-major order here.
coo.push(0, 0, 1.0);
coo.push(0, 2, 3.0);
coo.push(1, 0, 2.0);
coo.push(1, 2, 1.3);
coo.push(2, 2, 4.1);

// ... or add entire dense matrices like so:
// coo.push_matrix(0, 0, &dense);

// The simplest way to construct a CSR matrix is to first construct a COO matrix, and
// then convert it to CSR. The `From` trait is implemented for conversions between different
// sparse matrix types.
// Alternatively, we can construct a matrix directly from the CSR data.
// See the docs for CsrMatrix for how to do that.
let csr = CsrMatrix::from(&coo);

// Let's check that the CSR matrix and the dense matrix represent the same matrix.
// We can use macros from the `matrixcompare` crate to easily do this, despite the fact that
// we're comparing across two different matrix formats. Note that these macros are only really
// appropriate for writing tests, however.
assert_matrix_eq!(csr, dense);

let x = DVector::from_column_slice(&[1.3, -4.0, 3.5]);

// Compute the matrix-vector product y = A * x. We don't need to specify the type here,
// but let's just do it to make sure we get what we expect
let y: DVector<_> = &csr * &x;

// Verify the result with a small element-wise absolute tolerance
let y_expected = DVector::from_column_slice(&[11.8, 7.15, 14.35]);
assert_matrix_eq!(y, y_expected, comp = abs, tol = 1e-9);

// The above expression is simple, and gives easy to read code, but if we're doing this in a
// loop, we'll have to keep allocating new vectors. If we determine that this is a bottleneck,
// then we can resort to the lower level APIs for more control over the operations
{
    use nalgebra_sparse::ops::{Op, serial::spmm_csr_dense};
    let mut y = y;
    // Compute y <- 0.0 * y + 1.0 * csr * dense. We store the result directly in `y`, without
    // any intermediate allocations
    spmm_csr_dense(0.0, &mut y, 1.0, Op::NoOp(&csr), Op::NoOp(&x));
    assert_matrix_eq!(y, y_expected, comp = abs, tol = 1e-9);
}