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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

use rustebra::sparse::{CscMatrix, CsrMatrix, scale_csc, scale_csr};

// ── scale_csr ────────────────────────────────────────────────────────────────

#[test]
fn scale_csr_basic() {
    let m = CsrMatrix::new(2, 2, vec![0, 1, 2], vec![0, 1], vec![4.0_f64, 6.0]).unwrap();
    let scaled = scale_csr(m, 0.5);
    assert_eq!(scaled.values(), &[2.0, 3.0]);
}

#[test]
fn scale_csr_preserves_structure() {
    let m = CsrMatrix::new(
        3,
        3,
        vec![0, 1, 1, 3],
        vec![0, 1, 2],
        vec![1.0_f64, 2.0, 3.0],
    )
    .unwrap();
    let scaled = scale_csr(m, 10.0);
    assert_eq!(scaled.rows(), 3);
    assert_eq!(scaled.cols(), 3);
    assert_eq!(scaled.nnz(), 3);
    assert_eq!(scaled.row_ptr(), &[0, 1, 1, 3]);
    assert_eq!(scaled.col_indices(), &[0, 1, 2]);
    assert_eq!(scaled.values(), &[10.0, 20.0, 30.0]);
}

#[test]
fn scale_csr_by_one_is_identity() {
    let m = CsrMatrix::new(2, 2, vec![0, 1, 2], vec![1, 0], vec![5.0_f64, 8.0]).unwrap();
    let scaled = scale_csr(m, 1.0);
    assert_eq!(scaled.values(), &[5.0, 8.0]);
    assert_eq!(scaled.row_ptr(), &[0, 1, 2]);
    assert_eq!(scaled.col_indices(), &[1, 0]);
}

#[test]
fn scale_csr_empty_matrix() {
    let m = CsrMatrix::<f64>::new(3, 4, vec![0, 0, 0, 0], vec![], vec![]).unwrap();
    let scaled = scale_csr(m, 99.0);
    assert_eq!(scaled.rows(), 3);
    assert_eq!(scaled.cols(), 4);
    assert_eq!(scaled.nnz(), 0);
    assert_eq!(scaled.row_ptr(), &[0, 0, 0, 0]);
}

#[test]
fn scale_csr_by_zero_yields_zero_values() {
    let m = CsrMatrix::new(2, 2, vec![0, 1, 2], vec![0, 1], vec![3.0_f64, 7.0]).unwrap();
    let scaled = scale_csr(m, 0.0);
    assert_eq!(scaled.nnz(), 0);
    assert_eq!(scaled.values(), &[]);
}

// ── scale_csc ────────────────────────────────────────────────────────────────

#[test]
fn scale_csc_basic() {
    let m = CscMatrix::new(2, 2, vec![0, 1, 2], vec![0, 1], vec![4.0_f64, 6.0]).unwrap();
    let scaled = scale_csc(m, 0.5);
    assert_eq!(scaled.values(), &[2.0, 3.0]);
}

#[test]
fn scale_csc_preserves_structure() {
    let m = CscMatrix::new(
        3,
        3,
        vec![0, 1, 1, 3],
        vec![0, 1, 2],
        vec![1.0_f64, 2.0, 3.0],
    )
    .unwrap();
    let scaled = scale_csc(m, 10.0);
    assert_eq!(scaled.rows(), 3);
    assert_eq!(scaled.cols(), 3);
    assert_eq!(scaled.nnz(), 3);
    assert_eq!(scaled.col_ptr(), &[0, 1, 1, 3]);
    assert_eq!(scaled.row_indices(), &[0, 1, 2]);
    assert_eq!(scaled.values(), &[10.0, 20.0, 30.0]);
}

#[test]
fn scale_csc_by_one_is_identity() {
    let m = CscMatrix::new(2, 2, vec![0, 1, 2], vec![1, 0], vec![5.0_f64, 8.0]).unwrap();
    let scaled = scale_csc(m, 1.0);
    assert_eq!(scaled.values(), &[5.0, 8.0]);
    assert_eq!(scaled.col_ptr(), &[0, 1, 2]);
    assert_eq!(scaled.row_indices(), &[1, 0]);
}

#[test]
fn scale_csc_empty_matrix() {
    let m = CscMatrix::<f64>::new(4, 5, vec![0, 0, 0, 0, 0, 0], vec![], vec![]).unwrap();
    let scaled = scale_csc(m, 3.0);
    assert_eq!(scaled.rows(), 4);
    assert_eq!(scaled.cols(), 5);
    assert_eq!(scaled.nnz(), 0);
    assert_eq!(scaled.col_ptr(), &[0, 0, 0, 0, 0, 0]);
}

#[test]
fn scale_csc_by_zero_yields_zero_values() {
    let m = CscMatrix::new(2, 2, vec![0, 1, 2], vec![0, 1], vec![3.0_f64, 7.0]).unwrap();
    let scaled = scale_csc(m, 0.0);
    assert_eq!(scaled.nnz(), 0);
    assert_eq!(scaled.values(), &[]);
}

#[test]
fn scale_csc_negative_scalar() {
    let m = CscMatrix::new(1, 2, vec![0, 1, 2], vec![0, 0], vec![2.0_f64, -3.0]).unwrap();
    let scaled = scale_csc(m, -1.0);
    assert_eq!(scaled.values(), &[-2.0, 3.0]);
}