rlumod 1.0.0

Safe, no_std matrix updates and linear solves using the LUmod algorithm
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
119
120
121

// SPDX-FileCopyrightText: 2026 Daisuke Nagao
// SPDX-License-Identifier: MIT

use super::*;

#[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
use wasm_bindgen_test::wasm_bindgen_test as test;

struct TestMatrix([[f64; 2]; 2]);

impl MatrixRead<f64> for TestMatrix {
    fn get(&self, row: usize, column: usize) -> f64 {
        self.0[row][column]
    }
}

impl Matrix<f64> for TestMatrix {
    fn set(&mut self, row: usize, column: usize, value: f64) {
        self.0[row][column] = value;
    }
}

#[test]
fn default_row_transform_updates_the_requested_range() {
    let mut matrix = TestMatrix([[1.0, 2.0], [3.0, 4.0]]);
    matrix.transform_rows(
        0,
        1,
        0,
        2,
        Transform {
            swap: true,
            multiplier: 0.5,
        },
    );
    assert_eq!(matrix.0, [[3.0, 4.0], [2.5, 4.0]]);
}

fn exercise_sweep_boundaries<T: Real>() {
    let numerics = Numerics {
        epsilon: T::EPSILON,
        update_tiny: T::UPDATE_TINY,
    };
    let mut l_storage = [T::ONE, T::ZERO, T::ZERO, T::ONE];
    let mut u_storage = [T::ONE, T::ZERO, T::ONE];
    let mut l = DenseL::new(&mut l_storage, 2);
    let mut u = PackedU::new(&mut u_storage, 2);
    assert_eq!(
        backward(
            0,
            0,
            false,
            0,
            0,
            &mut l,
            &mut u,
            &mut [],
            &mut [],
            numerics,
        ),
        0
    );

    let mut y = [T::ZERO; 2];
    let mut z = [T::ONE, T::ZERO];
    assert_eq!(
        backward(0, 1, true, 2, 2, &mut l, &mut u, &mut y, &mut z, numerics),
        0
    );

    forward(0, 1, 1, 1, &mut l, &mut u, &mut [T::ZERO], numerics);
    replace_row(
        0,
        1,
        &mut l,
        &mut u,
        &mut [T::ONE],
        &mut [T::ZERO],
        &mut [T::ZERO],
        numerics,
    );
}

#[test]
fn sweep_boundaries_handle_zero_dimension_trailing_zeros_and_the_terminal_row() {
    exercise_sweep_boundaries::<f32>();
    exercise_sweep_boundaries::<f64>();
}

fn exercise_zero_transforms<T: Real>() {
    let numerics = Numerics {
        epsilon: T::ONE,
        update_tiny: T::ONE,
    };
    let (mut x, mut y) = (T::ZERO, T::ZERO);
    let transform = elementary(&mut x, &mut y, numerics);
    assert!(!transform.swap);
    assert!(transform.multiplier == T::ZERO);

    y = T::ONE;
    let transform = elementary(&mut x, &mut y, numerics);
    assert!(!transform.swap);
    assert!(transform.multiplier == T::ZERO);

    let (mut x, mut y) = (T::ONE, T::ONE);
    apply_pair(
        &mut x,
        &mut y,
        Transform {
            swap: false,
            multiplier: T::ZERO,
        },
    );
    assert!(x == T::ONE && y == T::ONE);
}

#[test]
fn zero_elementary_transforms_and_zero_multiplier_are_no_ops() {
    exercise_zero_transforms::<f32>();
    exercise_zero_transforms::<f64>();
}