linxal 0.6.0

Linear Algebra package with rust-ndarray interface
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
122
123
124
125
126
127
128
129
130
131

//! Define matrix traits for performing linear algebra operations.

use eigenvalues::{self, Eigen, SymEigen};
use solve_linear::{SolveLinear, SymmetricSolveLinear};
use super::error::*;
use super::scalar::LinxalScalar;
use impl_prelude::*;
use svd::{SVD, SVDSolution, SVDComputeVectors};

/// All-encompassing matrix trait, supporting all of the linear
/// algebra operations defined for any `LinxalScalar`.
pub trait LinxalMatrixInto<F: LinxalScalar> {
    /// Compute the eigenvalues of a matrix.
    fn eigenvalues_into(self)
                        -> Result<Array<F::Complex, Ix1>, EigenError>;

    /// Compute the eigenvalues and the right and/or left eigenvectors
    /// of a generic matrix.
    fn eigenvalues_vectors_into(self,
                        compute_left: bool,
                        compute_right: bool)
                        -> Result<eigenvalues::types::Solution<F, F::Complex>, EigenError>;

    /// Compute the eigenvalues of a symmetric matrix.
    fn symmetric_eigenvalues_into(self,
                                  uplo: Symmetric)
                                  -> Result<Array<F::RealPart, Ix1>, EigenError>;

    /// Solve a single system of linear equations.
    fn solve_linear_into<D1: DataMut<Elem = F> + DataOwned<Elem = F>>
        (self, b: ArrayBase<D1, Ix1>)
         -> Result<ArrayBase<D1, Ix1>, SolveError>;

    /// Solve a single system of linear equations with a symmetrix coefficient matrix.
    fn solve_symmetric_linear_into<D1: DataMut<Elem = F> + DataOwned<Elem = F>>
        (self, b: ArrayBase<D1, Ix1>, uplo: Symmetric)
         -> Result<ArrayBase<D1, Ix1>, SolveError>;


    /// Solve a system of linear equations with multiple RHS vectors.
    fn solve_multi_linear_into<D1: DataMut<Elem = F> + DataOwned<Elem = F>>
        (self, b: ArrayBase<D1, Ix2>)
         -> Result<ArrayBase<D1, Ix2>, SolveError>;

    /// Solve a system of linear equations with a symmetrix
    /// coefficient matrix for multiple RHS vectors.
    ///
    /// Each column of `b` is a RHS vector to be solved for.
    fn solve_symmetric_multi_linear_into<D1: DataMut<Elem = F> + DataOwned<Elem = F>>
        (self, b: ArrayBase<D1, Ix2>, uplo: Symmetric)
         -> Result<ArrayBase<D1, Ix2>, SolveError>;

    /// Return the full singular value decomposition of the matrix.
    ///
    /// The `SVDSolution` contains full size matrices `u` (m x m) and `vt` (n x n).
    fn svd_full_into(self) -> Result<SVDSolution<F>, SVDError>;

    /// Return the economic singular value decomposition of the matrix.
    ///
    /// The `SVDSolution` contains sufficient matrices `u` (m x p) and
    /// `vt` (p x n), where `p` is the minimum of `m` and `n`.
    fn svd_econ_into(self) -> Result<SVDSolution<F>, SVDError>;

    /// Return the full singular value decomposition of the matrix.
    ///
    /// The `SVDSolution` contains full size matrices `u` (m x m) and `vt` (n x n).
    fn singular_values_into(self) -> Result<Array<F::RealPart, Ix1>, SVDError>;

    /// Return the conjugate of the matrix.
    fn conj_into(self) -> Self;
}

impl<F: LinxalScalar, D: DataMut<Elem = F> + DataOwned<Elem = F>> LinxalMatrixInto<F> for ArrayBase<D, Ix2> {
    fn eigenvalues_into(self) -> Result<Array<F::Complex, Ix1>, EigenError> {
        Eigen::compute_into(self, false, false).map(|sol| sol.values)
    }

    fn eigenvalues_vectors_into(self,
                        compute_left: bool,
                        compute_right: bool)
                        -> Result<eigenvalues::types::Solution<F, F::Complex>, EigenError> {
        Eigen::compute_into(self, compute_left, compute_right)
    }


    fn symmetric_eigenvalues_into(self,
                                  uplo: Symmetric) -> Result<Array<F::RealPart, Ix1>, EigenError> {
        SymEigen::compute_into(self, uplo)
    }

    fn solve_linear_into<D1: DataMut<Elem = F> + DataOwned<Elem = F>>
        (self, b: ArrayBase<D1, Ix1>)
         -> Result<ArrayBase<D1, Ix1>, SolveError> {
            SolveLinear::compute_into(self, b)
        }

    fn solve_symmetric_linear_into<D1: DataMut<Elem = F> + DataOwned<Elem = F>>
        (self, b: ArrayBase<D1, Ix1>, uplo: Symmetric)
         -> Result<ArrayBase<D1, Ix1>, SolveError> {
            SymmetricSolveLinear::compute_into(self, uplo, b)
        }


    fn solve_multi_linear_into<D1: DataMut<Elem = F> + DataOwned<Elem = F>>
        (self, b: ArrayBase<D1, Ix2>)
         -> Result<ArrayBase<D1, Ix2>, SolveError> {
            SolveLinear::compute_multi_into(self, b)
        }

    fn solve_symmetric_multi_linear_into<D1: DataMut<Elem = F> + DataOwned<Elem = F>>
        (self, b: ArrayBase<D1, Ix2>, uplo: Symmetric)
         -> Result<ArrayBase<D1, Ix2>, SolveError> {
            SymmetricSolveLinear::compute_multi_into(self, uplo, b)
        }

    fn svd_full_into(self) -> Result<SVDSolution<F>, SVDError> {
        SVD::compute_into(self, SVDComputeVectors::Full)
    }

    fn svd_econ_into(self) -> Result<SVDSolution<F>, SVDError> {
        SVD::compute_into(self, SVDComputeVectors::Economic)
    }

    fn singular_values_into(self) -> Result<Array<F::RealPart, Ix1>, SVDError> {
        SVD::compute_into(self, SVDComputeVectors::None).map(|x| x.values)
    }

    fn conj_into(self) -> Self {
        self.mapv_into(|x| x.cj())
    }
}