rustebra 0.4.0

A hybrid no_std/alloc linear algebra crate for Rust, scaling from embedded targets to dynamic Krylov subspace solvers.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

use alloc::vec;
use alloc::vec::Vec;

use crate::scalar::Scalar;

use super::add::DimensionMismatch;
use super::{CscMatrix, CsrMatrix};

/// Multiplies a CSR sparse matrix by a dense column vector, returning the result as a
/// `Vec<T>` of length `m.rows()`.
///
/// The CSR format allows efficient row-by-row traversal: for each row `r`, the stored
/// entries span `row_ptr[r]..row_ptr[r + 1]`, and each contributes `value * x[col]` to
/// `out[r]`.
///
/// # Errors
///
/// Returns `Err(DimensionMismatch::Shape)` when `x.len() != m.cols()`.
///
/// # Examples
///
/// ```
/// use rustebra::sparse::{CsrMatrix, matvec_csr};
///
/// // [ 2  0 ]   [ 1 ]   [  2 ]
/// // [ 0  5 ] × [ 3 ] = [ 15 ]
/// let m = CsrMatrix::new(2, 2, vec![0, 1, 2], vec![0, 1], vec![2.0_f64, 5.0]).unwrap();
/// let y = matvec_csr(&m, &[1.0, 3.0]).unwrap();
/// assert_eq!(y, vec![2.0, 15.0]);
/// ```
pub fn matvec_csr<T: Scalar>(m: &CsrMatrix<T>, x: &[T]) -> Result<Vec<T>, DimensionMismatch> {
    if x.len() != m.cols() {
        return Err(DimensionMismatch::Shape);
    }
    let mut out = vec![T::zero(); m.rows()];
    let row_ptr = m.row_ptr();
    let col_idx = m.col_indices();
    let vals = m.values();
    for r in 0..m.rows() {
        for k in row_ptr[r] as usize..row_ptr[r + 1] as usize {
            let prev = out[r];
            out[r] = prev.add(vals[k].mul(x[col_idx[k] as usize]));
        }
    }
    Ok(out)
}

/// Multiplies a CSC sparse matrix by a dense column vector, returning the result as a
/// `Vec<T>` of length `m.rows()`.
///
/// CSC's column-oriented layout naturally accumulates output rows: for each column `c`,
/// every stored entry `(r, v)` contributes `v * x[c]` to `out[r]`.
///
/// # Errors
///
/// Returns `Err(DimensionMismatch::Shape)` when `x.len() != m.cols()`.
///
/// # Examples
///
/// ```
/// use rustebra::sparse::{CscMatrix, matvec_csc};
///
/// // [ 1  0 ]   [ 2 ]   [  2 ]
/// // [ 0  3 ] × [ 4 ] = [ 12 ]
/// let m = CscMatrix::new(2, 2, vec![0, 1, 2], vec![0, 1], vec![1.0_f64, 3.0]).unwrap();
/// let y = matvec_csc(&m, &[2.0, 4.0]).unwrap();
/// assert_eq!(y, vec![2.0, 12.0]);
/// ```
pub fn matvec_csc<T: Scalar>(m: &CscMatrix<T>, x: &[T]) -> Result<Vec<T>, DimensionMismatch> {
    if x.len() != m.cols() {
        return Err(DimensionMismatch::Shape);
    }
    let mut out = vec![T::zero(); m.rows()];
    let col_ptr = m.col_ptr();
    let row_idx = m.row_indices();
    let vals = m.values();
    for c in 0..m.cols() {
        for k in col_ptr[c] as usize..col_ptr[c + 1] as usize {
            let r = row_idx[k] as usize;
            let prev = out[r];
            out[r] = prev.add(vals[k].mul(x[c]));
        }
    }
    Ok(out)
}