2021-07-18 09:19:20 +08:00
|
|
|
use std::fmt;
|
|
|
|
|
2017-08-14 01:53:04 +08:00
|
|
|
#[cfg(feature = "serde-serialize")]
|
2018-10-22 13:00:10 +08:00
|
|
|
use serde::{Deserialize, Serialize};
|
2017-08-14 01:53:04 +08:00
|
|
|
|
2017-08-03 01:38:28 +08:00
|
|
|
use num::Zero;
|
2017-08-07 01:41:33 +08:00
|
|
|
use num_complex::Complex;
|
2017-08-03 01:38:28 +08:00
|
|
|
|
2020-03-21 19:16:46 +08:00
|
|
|
use simba::scalar::RealField;
|
2017-08-03 01:38:28 +08:00
|
|
|
|
2020-03-21 19:16:46 +08:00
|
|
|
use crate::ComplexHelper;
|
2018-05-25 05:51:57 +08:00
|
|
|
use na::allocator::Allocator;
|
2021-04-12 16:34:44 +08:00
|
|
|
use na::dimension::{Const, Dim};
|
2017-08-03 01:38:28 +08:00
|
|
|
use na::storage::Storage;
|
2021-04-11 17:00:38 +08:00
|
|
|
use na::{DefaultAllocator, Matrix, OMatrix, OVector, Scalar};
|
2017-08-03 01:38:28 +08:00
|
|
|
|
2018-05-25 05:51:57 +08:00
|
|
|
use lapack;
|
2017-08-03 01:38:28 +08:00
|
|
|
|
|
|
|
/// Eigendecomposition of a real square matrix with real eigenvalues.
|
2017-08-14 01:53:04 +08:00
|
|
|
#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
|
2018-05-25 05:51:57 +08:00
|
|
|
#[cfg_attr(
|
|
|
|
feature = "serde-serialize",
|
2020-03-21 19:16:46 +08:00
|
|
|
serde(
|
2021-04-11 17:00:38 +08:00
|
|
|
bound(serialize = "DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
|
|
|
|
OVector<T, D>: Serialize,
|
|
|
|
OMatrix<T, D, D>: Serialize")
|
2020-03-21 19:16:46 +08:00
|
|
|
)
|
2018-05-25 05:51:57 +08:00
|
|
|
)]
|
|
|
|
#[cfg_attr(
|
|
|
|
feature = "serde-serialize",
|
2020-03-21 19:16:46 +08:00
|
|
|
serde(
|
2021-04-11 17:00:38 +08:00
|
|
|
bound(deserialize = "DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
|
|
|
|
OVector<T, D>: Serialize,
|
|
|
|
OMatrix<T, D, D>: Deserialize<'de>")
|
2020-03-21 19:16:46 +08:00
|
|
|
)
|
2018-05-25 05:51:57 +08:00
|
|
|
)]
|
2021-07-18 09:19:20 +08:00
|
|
|
pub struct Eigen<T, D: Dim>
|
2020-04-06 00:49:48 +08:00
|
|
|
where
|
2021-04-11 17:00:38 +08:00
|
|
|
DefaultAllocator: Allocator<T, D> + Allocator<T, D, D>,
|
2018-02-02 19:26:35 +08:00
|
|
|
{
|
2017-08-14 01:52:58 +08:00
|
|
|
/// The eigenvalues of the decomposed matrix.
|
2021-04-11 17:00:38 +08:00
|
|
|
pub eigenvalues: OVector<T, D>,
|
2017-08-14 01:52:58 +08:00
|
|
|
/// The (right) eigenvectors of the decomposed matrix.
|
2021-04-11 17:00:38 +08:00
|
|
|
pub eigenvectors: Option<OMatrix<T, D, D>>,
|
2017-08-14 01:52:58 +08:00
|
|
|
/// The left eigenvectors of the decomposed matrix.
|
2021-04-11 17:00:38 +08:00
|
|
|
pub left_eigenvectors: Option<OMatrix<T, D, D>>,
|
2017-08-03 01:38:28 +08:00
|
|
|
}
|
|
|
|
|
2021-07-18 09:19:20 +08:00
|
|
|
impl<T: Copy, D: Dim> Copy for Eigen<T, D>
|
2018-02-02 19:26:35 +08:00
|
|
|
where
|
2021-04-11 17:00:38 +08:00
|
|
|
DefaultAllocator: Allocator<T, D> + Allocator<T, D, D>,
|
|
|
|
OVector<T, D>: Copy,
|
|
|
|
OMatrix<T, D, D>: Copy,
|
2020-03-21 19:16:46 +08:00
|
|
|
{
|
|
|
|
}
|
2017-08-03 01:38:28 +08:00
|
|
|
|
2021-07-18 09:19:20 +08:00
|
|
|
impl<T: Clone, D: Dim> Clone for Eigen<T, D>
|
|
|
|
where
|
|
|
|
DefaultAllocator: Allocator<T, D> + Allocator<T, D, D>,
|
|
|
|
OVector<T, D>: Clone,
|
|
|
|
OMatrix<T, D, D>: Clone,
|
|
|
|
{
|
|
|
|
fn clone(&self) -> Self {
|
|
|
|
Self {
|
|
|
|
eigenvalues: self.eigenvalues.clone(),
|
|
|
|
eigenvectors: self.eigenvectors.clone(),
|
|
|
|
left_eigenvectors: self.left_eigenvectors.clone(),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<T: fmt::Debug, D: Dim> fmt::Debug for Eigen<T, D>
|
|
|
|
where
|
|
|
|
DefaultAllocator: Allocator<T, D> + Allocator<T, D, D>,
|
|
|
|
OVector<T, D>: fmt::Debug,
|
|
|
|
OMatrix<T, D, D>: fmt::Debug,
|
|
|
|
{
|
|
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
|
|
f.debug_struct("Eigen")
|
|
|
|
.field("eigenvalues", &self.eigenvalues)
|
|
|
|
.field("eigenvectors", &self.eigenvectors)
|
|
|
|
.field("left_eigenvectors", &self.left_eigenvectors)
|
|
|
|
.finish()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-11 17:00:38 +08:00
|
|
|
impl<T: EigenScalar + RealField, D: Dim> Eigen<T, D>
|
2020-04-06 00:49:48 +08:00
|
|
|
where
|
2021-04-11 17:00:38 +08:00
|
|
|
DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
|
2018-02-02 19:26:35 +08:00
|
|
|
{
|
2017-08-03 01:38:28 +08:00
|
|
|
/// Computes the eigenvalues and eigenvectors of the square matrix `m`.
|
|
|
|
///
|
|
|
|
/// If `eigenvectors` is `false` then, the eigenvectors are not computed explicitly.
|
2018-02-02 19:26:35 +08:00
|
|
|
pub fn new(
|
2021-04-11 17:00:38 +08:00
|
|
|
mut m: OMatrix<T, D, D>,
|
2018-02-02 19:26:35 +08:00
|
|
|
left_eigenvectors: bool,
|
|
|
|
eigenvectors: bool,
|
2021-04-11 17:00:38 +08:00
|
|
|
) -> Option<Eigen<T, D>> {
|
2018-02-02 19:26:35 +08:00
|
|
|
assert!(
|
|
|
|
m.is_square(),
|
|
|
|
"Unable to compute the eigenvalue decomposition of a non-square matrix."
|
|
|
|
);
|
|
|
|
|
2021-04-11 17:00:38 +08:00
|
|
|
let ljob = if left_eigenvectors { b'V' } else { b'T' };
|
|
|
|
let rjob = if eigenvectors { b'V' } else { b'T' };
|
2017-08-03 01:38:28 +08:00
|
|
|
|
|
|
|
let (nrows, ncols) = m.data.shape();
|
|
|
|
let n = nrows.value();
|
|
|
|
|
|
|
|
let lda = n as i32;
|
|
|
|
|
2021-07-18 02:58:34 +08:00
|
|
|
// IMPORTANT TODO: this is still UB.
|
|
|
|
|
|
|
|
let mut wr = unsafe { Matrix::new_uninitialized_generic(nrows, Const::<1>).assume_init() };
|
2020-11-15 23:57:49 +08:00
|
|
|
// TODO: Tap into the workspace.
|
2021-07-18 02:58:34 +08:00
|
|
|
let mut wi = unsafe { Matrix::new_uninitialized_generic(nrows, Const::<1>).assume_init() };
|
2017-08-03 01:38:28 +08:00
|
|
|
|
|
|
|
let mut info = 0;
|
2021-04-11 17:00:38 +08:00
|
|
|
let mut placeholder1 = [T::zero()];
|
|
|
|
let mut placeholder2 = [T::zero()];
|
2018-02-02 19:26:35 +08:00
|
|
|
|
2021-04-11 17:00:38 +08:00
|
|
|
let lwork = T::xgeev_work_size(
|
2018-02-02 19:26:35 +08:00
|
|
|
ljob,
|
|
|
|
rjob,
|
|
|
|
n as i32,
|
|
|
|
m.as_mut_slice(),
|
|
|
|
lda,
|
|
|
|
wr.as_mut_slice(),
|
|
|
|
wi.as_mut_slice(),
|
|
|
|
&mut placeholder1,
|
|
|
|
n as i32,
|
|
|
|
&mut placeholder2,
|
|
|
|
n as i32,
|
|
|
|
&mut info,
|
|
|
|
);
|
2017-08-03 01:38:28 +08:00
|
|
|
|
|
|
|
lapack_check!(info);
|
|
|
|
|
2019-03-23 21:29:07 +08:00
|
|
|
let mut work = unsafe { crate::uninitialized_vec(lwork as usize) };
|
2017-08-03 01:38:28 +08:00
|
|
|
|
|
|
|
match (left_eigenvectors, eigenvectors) {
|
|
|
|
(true, true) => {
|
2021-02-25 22:07:15 +08:00
|
|
|
let mut vl =
|
|
|
|
unsafe { Matrix::new_uninitialized_generic(nrows, ncols).assume_init() };
|
|
|
|
let mut vr =
|
|
|
|
unsafe { Matrix::new_uninitialized_generic(nrows, ncols).assume_init() };
|
2017-08-03 01:38:28 +08:00
|
|
|
|
2021-04-11 17:00:38 +08:00
|
|
|
T::xgeev(
|
2018-02-02 19:26:35 +08:00
|
|
|
ljob,
|
|
|
|
rjob,
|
|
|
|
n as i32,
|
|
|
|
m.as_mut_slice(),
|
|
|
|
lda,
|
|
|
|
wr.as_mut_slice(),
|
|
|
|
wi.as_mut_slice(),
|
|
|
|
&mut vl.as_mut_slice(),
|
|
|
|
n as i32,
|
|
|
|
&mut vr.as_mut_slice(),
|
|
|
|
n as i32,
|
|
|
|
&mut work,
|
|
|
|
lwork,
|
|
|
|
&mut info,
|
|
|
|
);
|
2017-08-03 01:38:28 +08:00
|
|
|
lapack_check!(info);
|
|
|
|
|
|
|
|
if wi.iter().all(|e| e.is_zero()) {
|
2019-02-17 05:29:41 +08:00
|
|
|
return Some(Self {
|
2018-02-02 19:26:35 +08:00
|
|
|
eigenvalues: wr,
|
|
|
|
left_eigenvectors: Some(vl),
|
|
|
|
eigenvectors: Some(vr),
|
|
|
|
});
|
2017-08-03 01:38:28 +08:00
|
|
|
}
|
2018-02-02 19:26:35 +08:00
|
|
|
}
|
2017-08-03 01:38:28 +08:00
|
|
|
(true, false) => {
|
2021-02-25 22:07:15 +08:00
|
|
|
let mut vl =
|
|
|
|
unsafe { Matrix::new_uninitialized_generic(nrows, ncols).assume_init() };
|
2017-08-03 01:38:28 +08:00
|
|
|
|
2021-04-11 17:00:38 +08:00
|
|
|
T::xgeev(
|
2018-02-02 19:26:35 +08:00
|
|
|
ljob,
|
|
|
|
rjob,
|
|
|
|
n as i32,
|
|
|
|
m.as_mut_slice(),
|
|
|
|
lda,
|
|
|
|
wr.as_mut_slice(),
|
|
|
|
wi.as_mut_slice(),
|
|
|
|
&mut vl.as_mut_slice(),
|
|
|
|
n as i32,
|
|
|
|
&mut placeholder2,
|
|
|
|
1 as i32,
|
|
|
|
&mut work,
|
|
|
|
lwork,
|
|
|
|
&mut info,
|
|
|
|
);
|
2017-08-03 01:38:28 +08:00
|
|
|
lapack_check!(info);
|
|
|
|
|
|
|
|
if wi.iter().all(|e| e.is_zero()) {
|
2019-02-17 05:29:41 +08:00
|
|
|
return Some(Self {
|
2018-02-02 19:26:35 +08:00
|
|
|
eigenvalues: wr,
|
|
|
|
left_eigenvectors: Some(vl),
|
|
|
|
eigenvectors: None,
|
2017-08-03 01:38:28 +08:00
|
|
|
});
|
|
|
|
}
|
2018-02-02 19:26:35 +08:00
|
|
|
}
|
2017-08-03 01:38:28 +08:00
|
|
|
(false, true) => {
|
2021-02-25 22:07:15 +08:00
|
|
|
let mut vr =
|
|
|
|
unsafe { Matrix::new_uninitialized_generic(nrows, ncols).assume_init() };
|
2017-08-03 01:38:28 +08:00
|
|
|
|
2021-04-11 17:00:38 +08:00
|
|
|
T::xgeev(
|
2018-02-02 19:26:35 +08:00
|
|
|
ljob,
|
|
|
|
rjob,
|
|
|
|
n as i32,
|
|
|
|
m.as_mut_slice(),
|
|
|
|
lda,
|
|
|
|
wr.as_mut_slice(),
|
|
|
|
wi.as_mut_slice(),
|
|
|
|
&mut placeholder1,
|
|
|
|
1 as i32,
|
|
|
|
&mut vr.as_mut_slice(),
|
|
|
|
n as i32,
|
|
|
|
&mut work,
|
|
|
|
lwork,
|
|
|
|
&mut info,
|
|
|
|
);
|
2017-08-03 01:38:28 +08:00
|
|
|
lapack_check!(info);
|
|
|
|
|
|
|
|
if wi.iter().all(|e| e.is_zero()) {
|
2019-02-17 05:29:41 +08:00
|
|
|
return Some(Self {
|
2018-02-02 19:26:35 +08:00
|
|
|
eigenvalues: wr,
|
|
|
|
left_eigenvectors: None,
|
|
|
|
eigenvectors: Some(vr),
|
2017-08-03 01:38:28 +08:00
|
|
|
});
|
|
|
|
}
|
2018-02-02 19:26:35 +08:00
|
|
|
}
|
2017-08-03 01:38:28 +08:00
|
|
|
(false, false) => {
|
2021-04-11 17:00:38 +08:00
|
|
|
T::xgeev(
|
2018-02-02 19:26:35 +08:00
|
|
|
ljob,
|
|
|
|
rjob,
|
|
|
|
n as i32,
|
|
|
|
m.as_mut_slice(),
|
|
|
|
lda,
|
|
|
|
wr.as_mut_slice(),
|
|
|
|
wi.as_mut_slice(),
|
|
|
|
&mut placeholder1,
|
|
|
|
1 as i32,
|
|
|
|
&mut placeholder2,
|
|
|
|
1 as i32,
|
|
|
|
&mut work,
|
|
|
|
lwork,
|
|
|
|
&mut info,
|
|
|
|
);
|
2017-08-03 01:38:28 +08:00
|
|
|
lapack_check!(info);
|
|
|
|
|
|
|
|
if wi.iter().all(|e| e.is_zero()) {
|
2019-02-17 05:29:41 +08:00
|
|
|
return Some(Self {
|
2018-02-02 19:26:35 +08:00
|
|
|
eigenvalues: wr,
|
|
|
|
left_eigenvectors: None,
|
|
|
|
eigenvectors: None,
|
2017-08-03 01:38:28 +08:00
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
None
|
|
|
|
}
|
|
|
|
|
2017-08-07 01:41:33 +08:00
|
|
|
/// The complex eigenvalues of the given matrix.
|
|
|
|
///
|
|
|
|
/// Panics if the eigenvalue computation does not converge.
|
2021-04-11 17:00:38 +08:00
|
|
|
pub fn complex_eigenvalues(mut m: OMatrix<T, D, D>) -> OVector<Complex<T>, D>
|
2020-04-06 00:49:48 +08:00
|
|
|
where
|
2021-04-11 17:00:38 +08:00
|
|
|
DefaultAllocator: Allocator<Complex<T>, D>,
|
2020-04-06 00:49:48 +08:00
|
|
|
{
|
2018-02-02 19:26:35 +08:00
|
|
|
assert!(
|
|
|
|
m.is_square(),
|
|
|
|
"Unable to compute the eigenvalue decomposition of a non-square matrix."
|
|
|
|
);
|
2017-08-07 01:41:33 +08:00
|
|
|
|
2017-08-14 01:52:58 +08:00
|
|
|
let nrows = m.data.shape().0;
|
2017-08-07 01:41:33 +08:00
|
|
|
let n = nrows.value();
|
|
|
|
|
|
|
|
let lda = n as i32;
|
|
|
|
|
2021-07-18 02:58:34 +08:00
|
|
|
let mut wr = unsafe { Matrix::new_uninitialized_generic(nrows, Const::<1>).assume_init() };
|
|
|
|
let mut wi = unsafe { Matrix::new_uninitialized_generic(nrows, Const::<1>).assume_init() };
|
2017-08-07 01:41:33 +08:00
|
|
|
|
|
|
|
let mut info = 0;
|
2021-04-11 17:00:38 +08:00
|
|
|
let mut placeholder1 = [T::zero()];
|
|
|
|
let mut placeholder2 = [T::zero()];
|
2018-02-02 19:26:35 +08:00
|
|
|
|
2021-04-11 17:00:38 +08:00
|
|
|
let lwork = T::xgeev_work_size(
|
|
|
|
b'T',
|
|
|
|
b'T',
|
2018-02-02 19:26:35 +08:00
|
|
|
n as i32,
|
|
|
|
m.as_mut_slice(),
|
|
|
|
lda,
|
|
|
|
wr.as_mut_slice(),
|
|
|
|
wi.as_mut_slice(),
|
|
|
|
&mut placeholder1,
|
|
|
|
n as i32,
|
|
|
|
&mut placeholder2,
|
|
|
|
n as i32,
|
|
|
|
&mut info,
|
|
|
|
);
|
2017-08-07 01:41:33 +08:00
|
|
|
|
|
|
|
lapack_panic!(info);
|
|
|
|
|
2019-03-23 21:29:07 +08:00
|
|
|
let mut work = unsafe { crate::uninitialized_vec(lwork as usize) };
|
2017-08-07 01:41:33 +08:00
|
|
|
|
2021-04-11 17:00:38 +08:00
|
|
|
T::xgeev(
|
|
|
|
b'T',
|
|
|
|
b'T',
|
2018-02-02 19:26:35 +08:00
|
|
|
n as i32,
|
|
|
|
m.as_mut_slice(),
|
|
|
|
lda,
|
|
|
|
wr.as_mut_slice(),
|
|
|
|
wi.as_mut_slice(),
|
|
|
|
&mut placeholder1,
|
|
|
|
1 as i32,
|
|
|
|
&mut placeholder2,
|
|
|
|
1 as i32,
|
|
|
|
&mut work,
|
|
|
|
lwork,
|
|
|
|
&mut info,
|
|
|
|
);
|
2017-08-07 01:41:33 +08:00
|
|
|
lapack_panic!(info);
|
|
|
|
|
2021-07-18 02:58:34 +08:00
|
|
|
let mut res = unsafe { Matrix::new_uninitialized_generic(nrows, Const::<1>).assume_init() };
|
2017-08-07 01:41:33 +08:00
|
|
|
|
2018-02-02 19:26:35 +08:00
|
|
|
for i in 0..res.len() {
|
2017-08-07 01:41:33 +08:00
|
|
|
res[i] = Complex::new(wr[i], wi[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
res
|
|
|
|
}
|
|
|
|
|
2017-08-03 01:38:28 +08:00
|
|
|
/// The determinant of the decomposed matrix.
|
|
|
|
#[inline]
|
2021-06-07 22:34:03 +08:00
|
|
|
#[must_use]
|
2021-04-11 17:00:38 +08:00
|
|
|
pub fn determinant(&self) -> T {
|
|
|
|
let mut det = T::one();
|
2017-08-03 01:38:28 +08:00
|
|
|
for e in self.eigenvalues.iter() {
|
|
|
|
det *= *e;
|
|
|
|
}
|
|
|
|
|
|
|
|
det
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
*
|
|
|
|
* Lapack functions dispatch.
|
|
|
|
*
|
|
|
|
*/
|
2018-09-24 12:48:42 +08:00
|
|
|
/// Trait implemented by scalar type for which Lapack function exist to compute the
|
2017-08-14 01:52:58 +08:00
|
|
|
/// eigendecomposition.
|
2019-12-17 07:09:14 +08:00
|
|
|
pub trait EigenScalar: Scalar {
|
2017-08-14 01:52:58 +08:00
|
|
|
#[allow(missing_docs)]
|
2018-02-02 19:26:35 +08:00
|
|
|
fn xgeev(
|
|
|
|
jobvl: u8,
|
|
|
|
jobvr: u8,
|
|
|
|
n: i32,
|
|
|
|
a: &mut [Self],
|
|
|
|
lda: i32,
|
|
|
|
wr: &mut [Self],
|
|
|
|
wi: &mut [Self],
|
|
|
|
vl: &mut [Self],
|
|
|
|
ldvl: i32,
|
|
|
|
vr: &mut [Self],
|
|
|
|
ldvr: i32,
|
|
|
|
work: &mut [Self],
|
|
|
|
lwork: i32,
|
|
|
|
info: &mut i32,
|
|
|
|
);
|
2017-08-14 01:52:58 +08:00
|
|
|
#[allow(missing_docs)]
|
2018-02-02 19:26:35 +08:00
|
|
|
fn xgeev_work_size(
|
|
|
|
jobvl: u8,
|
|
|
|
jobvr: u8,
|
|
|
|
n: i32,
|
|
|
|
a: &mut [Self],
|
|
|
|
lda: i32,
|
|
|
|
wr: &mut [Self],
|
|
|
|
wi: &mut [Self],
|
|
|
|
vl: &mut [Self],
|
|
|
|
ldvl: i32,
|
|
|
|
vr: &mut [Self],
|
|
|
|
ldvr: i32,
|
|
|
|
info: &mut i32,
|
|
|
|
) -> i32;
|
2017-08-03 01:38:28 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
macro_rules! real_eigensystem_scalar_impl (
|
|
|
|
($N: ty, $xgeev: path) => (
|
2017-08-07 01:41:33 +08:00
|
|
|
impl EigenScalar for $N {
|
2017-08-03 01:38:28 +08:00
|
|
|
#[inline]
|
|
|
|
fn xgeev(jobvl: u8, jobvr: u8, n: i32, a: &mut [Self], lda: i32,
|
|
|
|
wr: &mut [Self], wi: &mut [Self],
|
|
|
|
vl: &mut [Self], ldvl: i32, vr: &mut [Self], ldvr: i32,
|
|
|
|
work: &mut [Self], lwork: i32, info: &mut i32) {
|
2018-05-25 05:51:57 +08:00
|
|
|
unsafe { $xgeev(jobvl, jobvr, n, a, lda, wr, wi, vl, ldvl, vr, ldvr, work, lwork, info) }
|
2017-08-03 01:38:28 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
fn xgeev_work_size(jobvl: u8, jobvr: u8, n: i32, a: &mut [Self], lda: i32,
|
|
|
|
wr: &mut [Self], wi: &mut [Self], vl: &mut [Self], ldvl: i32,
|
|
|
|
vr: &mut [Self], ldvr: i32, info: &mut i32) -> i32 {
|
|
|
|
let mut work = [ Zero::zero() ];
|
|
|
|
let lwork = -1 as i32;
|
|
|
|
|
2018-05-25 05:51:57 +08:00
|
|
|
unsafe { $xgeev(jobvl, jobvr, n, a, lda, wr, wi, vl, ldvl, vr, ldvr, &mut work, lwork, info) };
|
2017-08-03 01:38:28 +08:00
|
|
|
ComplexHelper::real_part(work[0]) as i32
|
|
|
|
}
|
|
|
|
}
|
|
|
|
)
|
|
|
|
);
|
|
|
|
|
2018-05-25 05:51:57 +08:00
|
|
|
real_eigensystem_scalar_impl!(f32, lapack::sgeev);
|
|
|
|
real_eigensystem_scalar_impl!(f64, lapack::dgeev);
|
2017-08-03 01:38:28 +08:00
|
|
|
|
2020-11-15 23:57:49 +08:00
|
|
|
//// TODO: decomposition of complex matrix and matrices with complex eigenvalues.
|
2018-05-25 05:51:57 +08:00
|
|
|
// eigensystem_complex_impl!(f32, lapack::cgeev);
|
|
|
|
// eigensystem_complex_impl!(f64, lapack::zgeev);
|