mathru 0.16.2

Fundamental algorithms for scientific computing in Rust
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

use crate::{
    algebra::{
        abstr::{Field, Scalar},
        linear::matrix::{Diagonal, EigenDec, EigenDecomposition, General},
    },
    elementary::Power,
};

impl<T> EigenDecomposition<T> for General<T>
where
    T: Field + Scalar + Power,
{
    /// Computes the eigenvalues of a real matrix
    ///
    /// # Arguments
    ///
    /// # Example
    ///
    /// ```
    /// use mathru::algebra::linear::matrix::{EigenDec, EigenDecomposition, General};
    /// use mathru::matrix;
    ///
    /// let a: General<f64> = matrix![  1.0, -3.0, 3.0;
    ///                                 3.0, -5.0, 3.0;
    ///                                 6.0, -6.0, 4.0];
    ///
    /// let eigen: EigenDec<f64> = a.dec_eigen().unwrap();
    /// ```
    fn dec_eigen(&self) -> Result<EigenDec<T>, String> {
        let (m, n): (usize, usize) = self.dim();
        debug_assert_eq!(
            m, n,
            "Unable to compute the eigen value of a non-square matrix"
        );
        debug_assert_ne!(
            m, 0,
            "Unable to compute the eigen value of an empty matrix."
        );

        let (_, n): (usize, usize) = self.dim();

        let mut self_data: Vec<T> = self.clone().data;
        let n_i32: i32 = n as i32;

        let mut info: i32 = 0;

        let mut w: Vec<T> = vec![T::zero(); n];

        let mut temp1 = [T::zero()];
        let mut temp2 = vec![T::zero(); n * n];

        let lwork = T::xgeev_work_size(
            'N' as u8,
            'V' as u8,
            n_i32,
            &mut self_data[..],
            n_i32,
            w.as_mut_slice(),
            &mut temp1,
            n_i32,
            &mut temp2,
            n_i32,
            &mut info,
        );

        let mut work: Vec<T> = vec![T::zero(); lwork as usize];

        T::xgeev(
            'N' as u8,
            'V' as u8,
            n_i32,
            &mut self_data[..],
            n_i32,
            w.as_mut_slice(),
            &mut temp1,
            1 as i32,
            &mut temp2,
            n_i32,
            &mut work,
            lwork,
            &mut info,
        );

        if info != 0 {
            return Err("".to_string());
        }

        Ok(EigenDec::new(Diagonal::new(&w), General::new(n, n, temp2)))
    }
}