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

use rustebra::matrix::DynamicMatrix;
use rustebra::vector::DynamicVector;

pub(crate) fn run() {
    println!("\n== DynamicMatrix ==");
    let a = DynamicMatrix::new(2, 2, vec![1.0, 2.0, 3.0, 4.0]).expect("2x2 data");
    let b = DynamicMatrix::new(2, 2, vec![5.0, 6.0, 7.0, 8.0]).expect("2x2 data");
    let v = DynamicVector::new(vec![1.0, 1.0]);

    println!("a = {a:?}");
    println!("b = {b:?}");

    let sum = a.add(&b).expect("a and b have the same shape");
    println!("a + b = {sum:?}");

    let diff = a.sub(&b).expect("a and b have the same shape");
    println!("a - b = {diff:?}");

    println!("a scaled by 2 = {:?}", a.mul_scalar(2.0));

    let product_v = a
        .mul_vector(&v)
        .expect("v's length matches a's column count");
    println!("a * v = {product_v:?}");

    let product_m = a
        .mul_matrix(&b)
        .expect("a's column count matches b's row count");
    println!("a * b = {product_m:?}");

    println!("a^T = {:?}", a.transpose());

    let det = a.determinant().expect("a is square");
    println!("det(a) = {det:?}");

    println!("rank(a) = {:?}", a.rank());

    let (l, u, swap_count) = a.lu().expect("a is square");
    println!("lu(a) = (l = {l:?}, u = {u:?}, swap_count = {swap_count})");

    let (q, r) = a.qr().expect("a has at least as many rows as columns");
    println!("qr(a) = (q = {q:?}, r = {r:?})");

    let spd = DynamicMatrix::new(2, 2, vec![4.0, 2.0, 2.0, 2.0]).expect("2x2 data");
    println!("cholesky(spd) = {:?}", spd.cholesky());

    let (svd_u, sigma, v) = a.svd().expect("a is well-formed");
    println!("svd(a) = (u = {svd_u:?}, sigma = {sigma:?}, v = {v:?})");

    println!("condition_number(a) = {:?}", a.condition_number());
}