faer-cholesky 0.5.0

Basic linear algebra routines
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

use assert2::assert as fancy_assert;
use dyn_stack::{DynStack, SizeOverflow, StackReq};
use faer_core::{
    mul::triangular::{self, BlockStructure},
    temp_mat_req, temp_mat_uninit, ComplexField, Conj, MatMut, MatRef, Parallelism,
};
use reborrow::*;

/// Computes the size and alignment of required workspace for reconstructing the lower triangular
/// part of the a matrix out of place, given its Cholesky decomposition.
pub fn reconstruct_lower_req<T: 'static>(dimension: usize) -> Result<StackReq, SizeOverflow> {
    let _ = dimension;
    Ok(StackReq::default())
}

/// Computes the size and alignment of required workspace for reconstructing the lower triangular
/// part of the a matrix in place, given its Cholesky decomposition.
pub fn reconstruct_lower_in_place_req<T: 'static>(
    dimension: usize,
) -> Result<StackReq, SizeOverflow> {
    temp_mat_req::<T>(dimension, dimension)
}

/// Computes the lower triangular part of the reconstructed matrix, given its Cholesky
/// decomposition, and stores the result in `dst`.
///
/// # Panics
///
/// - Panics if `cholesky_factor` is not a square matrix.
/// - Panics if the destination shape doesn't match the shape of the matrix.
#[track_caller]
pub fn reconstruct_lower<T: ComplexField>(
    dst: MatMut<'_, T>,
    cholesky_factor: MatRef<'_, T>,
    parallelism: Parallelism,
    stack: DynStack<'_>,
) {
    fancy_assert!(cholesky_factor.nrows() == cholesky_factor.ncols());
    fancy_assert!((dst.nrows(), dst.ncols()) == (cholesky_factor.nrows(), cholesky_factor.ncols()));

    let _ = &stack;
    triangular::matmul(
        dst,
        BlockStructure::TriangularLower,
        Conj::No,
        cholesky_factor,
        BlockStructure::TriangularLower,
        Conj::No,
        cholesky_factor.transpose(),
        BlockStructure::TriangularUpper,
        Conj::Yes,
        None,
        T::one(),
        parallelism,
    );
}

/// Computes the lower triangular part of the reconstructed matrix, given its Cholesky
/// decomposition, and stores the result in `cholesky_factor`.
///
/// # Panics
///
/// - Panics if `cholesky_factor` is not a square matrix.
#[track_caller]
pub fn reconstruct_lower_in_place<T: ComplexField>(
    cholesky_factor: MatMut<'_, T>,
    parallelism: Parallelism,
    stack: DynStack<'_>,
) {
    let n = cholesky_factor.nrows();
    temp_mat_uninit! {
        let (mut tmp, stack) = unsafe { temp_mat_uninit::<T>(n, n, stack) };
    }
    reconstruct_lower(tmp.rb_mut(), cholesky_factor.rb(), parallelism, stack);
    cholesky_factor
        .cwise()
        .zip(tmp.rb())
        .for_each_triangular_lower(faer_core::zip::Diag::Include, |dst, src| *dst = *src);
}