Merge pull request #1106 from geoeo/dev

enabled complex eigenvectors for lapack
This commit is contained in:
Sébastien Crozet 2022-10-30 17:34:50 +01:00 committed by GitHub
commit 0d9adec0ab
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
8 changed files with 299 additions and 221 deletions

View File

@ -44,3 +44,4 @@ proptest = { version = "1", default-features = false, features = ["std"] }
quickcheck = "1" quickcheck = "1"
approx = "0.5" approx = "0.5"
rand = "0.8" rand = "0.8"

View File

@ -7,13 +7,12 @@ use num_complex::Complex;
use simba::scalar::RealField; use simba::scalar::RealField;
use crate::ComplexHelper; use crate::ComplexHelper;
use na::allocator::Allocator;
use na::dimension::{Const, Dim}; use na::dimension::{Const, Dim};
use na::{DefaultAllocator, Matrix, OMatrix, OVector, Scalar}; use na::{allocator::Allocator, DefaultAllocator, Matrix, OMatrix, OVector, Scalar};
use lapack; use lapack;
/// Eigendecomposition of a real square matrix with real eigenvalues. /// Eigendecomposition of a real square matrix with real or complex eigenvalues.
#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))] #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
#[cfg_attr( #[cfg_attr(
feature = "serde-serialize", feature = "serde-serialize",
@ -36,8 +35,10 @@ pub struct Eigen<T: Scalar, D: Dim>
where where
DefaultAllocator: Allocator<T, D> + Allocator<T, D, D>, DefaultAllocator: Allocator<T, D> + Allocator<T, D, D>,
{ {
/// The eigenvalues of the decomposed matrix. /// The real parts of eigenvalues of the decomposed matrix.
pub eigenvalues: OVector<T, D>, pub eigenvalues_re: OVector<T, D>,
/// The imaginary parts of the eigenvalues of the decomposed matrix.
pub eigenvalues_im: OVector<T, D>,
/// The (right) eigenvectors of the decomposed matrix. /// The (right) eigenvectors of the decomposed matrix.
pub eigenvectors: Option<OMatrix<T, D, D>>, pub eigenvectors: Option<OMatrix<T, D, D>>,
/// The left eigenvectors of the decomposed matrix. /// The left eigenvectors of the decomposed matrix.
@ -69,8 +70,8 @@ where
"Unable to compute the eigenvalue decomposition of a non-square matrix." "Unable to compute the eigenvalue decomposition of a non-square matrix."
); );
let ljob = if left_eigenvectors { b'V' } else { b'T' }; let ljob = if left_eigenvectors { b'V' } else { b'N' };
let rjob = if eigenvectors { b'V' } else { b'T' }; let rjob = if eigenvectors { b'V' } else { b'N' };
let (nrows, ncols) = m.shape_generic(); let (nrows, ncols) = m.shape_generic();
let n = nrows.value(); let n = nrows.value();
@ -104,213 +105,232 @@ where
lapack_check!(info); lapack_check!(info);
let mut work = vec![T::zero(); lwork as usize]; let mut work = vec![T::zero(); lwork as usize];
let mut vl = if left_eigenvectors {
match (left_eigenvectors, eigenvectors) { Some(Matrix::zeros_generic(nrows, ncols))
(true, true) => { } else {
// TODO: avoid the initializations?
let mut vl = Matrix::zeros_generic(nrows, ncols);
let mut vr = Matrix::zeros_generic(nrows, ncols);
T::xgeev(
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,
);
lapack_check!(info);
if wi.iter().all(|e| e.is_zero()) {
return Some(Self {
eigenvalues: wr,
left_eigenvectors: Some(vl),
eigenvectors: Some(vr),
});
}
}
(true, false) => {
// TODO: avoid the initialization?
let mut vl = Matrix::zeros_generic(nrows, ncols);
T::xgeev(
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,
);
lapack_check!(info);
if wi.iter().all(|e| e.is_zero()) {
return Some(Self {
eigenvalues: wr,
left_eigenvectors: Some(vl),
eigenvectors: None,
});
}
}
(false, true) => {
// TODO: avoid the initialization?
let mut vr = Matrix::zeros_generic(nrows, ncols);
T::xgeev(
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,
);
lapack_check!(info);
if wi.iter().all(|e| e.is_zero()) {
return Some(Self {
eigenvalues: wr,
left_eigenvectors: None,
eigenvectors: Some(vr),
});
}
}
(false, false) => {
T::xgeev(
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,
);
lapack_check!(info);
if wi.iter().all(|e| e.is_zero()) {
return Some(Self {
eigenvalues: wr,
left_eigenvectors: None,
eigenvectors: None,
});
}
}
}
None None
} };
let mut vr = if eigenvectors {
Some(Matrix::zeros_generic(nrows, ncols))
} else {
None
};
/// The complex eigenvalues of the given matrix. let vl_ref = vl
/// .as_mut()
/// Panics if the eigenvalue computation does not converge. .map(|m| m.as_mut_slice())
pub fn complex_eigenvalues(mut m: OMatrix<T, D, D>) -> OVector<Complex<T>, D> .unwrap_or(&mut placeholder1);
where let vr_ref = vr
DefaultAllocator: Allocator<Complex<T>, D>, .as_mut()
{ .map(|m| m.as_mut_slice())
assert!( .unwrap_or(&mut placeholder2);
m.is_square(),
"Unable to compute the eigenvalue decomposition of a non-square matrix."
);
let nrows = m.shape_generic().0;
let n = nrows.value();
let lda = n as i32;
// TODO: avoid the initialization?
let mut wr = Matrix::zeros_generic(nrows, Const::<1>);
let mut wi = Matrix::zeros_generic(nrows, Const::<1>);
let mut info = 0;
let mut placeholder1 = [T::zero()];
let mut placeholder2 = [T::zero()];
let lwork = T::xgeev_work_size(
b'T',
b'T',
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,
);
lapack_panic!(info);
let mut work = vec![T::zero(); lwork as usize];
T::xgeev( T::xgeev(
b'T', ljob,
b'T', rjob,
n as i32, n as i32,
m.as_mut_slice(), m.as_mut_slice(),
lda, lda,
wr.as_mut_slice(), wr.as_mut_slice(),
wi.as_mut_slice(), wi.as_mut_slice(),
&mut placeholder1, vl_ref,
1 as i32, if left_eigenvectors { n as i32 } else { 1 },
&mut placeholder2, vr_ref,
1 as i32, if eigenvectors { n as i32 } else { 1 },
&mut work, &mut work,
lwork, lwork,
&mut info, &mut info,
); );
lapack_panic!(info); lapack_check!(info);
let mut res = Matrix::zeros_generic(nrows, Const::<1>); Some(Self {
eigenvalues_re: wr,
for i in 0..res.len() { eigenvalues_im: wi,
res[i] = Complex::new(wr[i].clone(), wi[i].clone()); left_eigenvectors: vl,
eigenvectors: vr,
})
} }
res /// Returns `true` if all the eigenvalues are real.
pub fn eigenvalues_are_real(&self) -> bool {
self.eigenvalues_im.iter().all(|e| e.is_zero())
} }
/// The determinant of the decomposed matrix. /// The determinant of the decomposed matrix.
#[inline] #[inline]
#[must_use] #[must_use]
pub fn determinant(&self) -> T { pub fn determinant(&self) -> Complex<T> {
let mut det = T::one(); let mut det: Complex<T> = na::one();
for e in self.eigenvalues.iter() { for (re, im) in self.eigenvalues_re.iter().zip(self.eigenvalues_im.iter()) {
det *= e.clone(); det *= Complex::new(re.clone(), im.clone());
} }
det det
} }
/// Returns a tuple of vectors. The elements of the tuple are the real parts of the eigenvalues, left eigenvectors and right eigenvectors respectively.
pub fn get_real_elements(
&self,
) -> (
Vec<T>,
Option<Vec<OVector<T, D>>>,
Option<Vec<OVector<T, D>>>,
)
where
DefaultAllocator: Allocator<T, D>,
{
let (number_of_elements, _) = self.eigenvalues_re.shape_generic();
let number_of_elements_value = number_of_elements.value();
let mut eigenvalues = Vec::<T>::with_capacity(number_of_elements_value);
let mut eigenvectors = match self.eigenvectors.is_some() {
true => Some(Vec::<OVector<T, D>>::with_capacity(
number_of_elements_value,
)),
false => None,
};
let mut left_eigenvectors = match self.left_eigenvectors.is_some() {
true => Some(Vec::<OVector<T, D>>::with_capacity(
number_of_elements_value,
)),
false => None,
};
let mut c = 0;
while c < number_of_elements_value {
eigenvalues.push(self.eigenvalues_re[c].clone());
if eigenvectors.is_some() {
eigenvectors.as_mut().unwrap().push(
(&self.eigenvectors.as_ref())
.unwrap()
.column(c)
.into_owned(),
);
}
if left_eigenvectors.is_some() {
left_eigenvectors.as_mut().unwrap().push(
(&self.left_eigenvectors.as_ref())
.unwrap()
.column(c)
.into_owned(),
);
}
if self.eigenvalues_im[c] != T::zero() {
//skip next entry
c += 1;
}
c += 1;
}
(eigenvalues, left_eigenvectors, eigenvectors)
}
/// Returns a tuple of vectors. The elements of the tuple are the complex eigenvalues, complex left eigenvectors and complex right eigenvectors respectively.
/// The elements appear as conjugate pairs within each vector, with the positive of the pair always being first.
pub fn get_complex_elements(
&self,
) -> (
Option<Vec<Complex<T>>>,
Option<Vec<OVector<Complex<T>, D>>>,
Option<Vec<OVector<Complex<T>, D>>>,
)
where
DefaultAllocator: Allocator<Complex<T>, D>,
{
match self.eigenvalues_are_real() {
true => (None, None, None),
false => {
let (number_of_elements, _) = self.eigenvalues_re.shape_generic();
let number_of_elements_value = number_of_elements.value();
let number_of_complex_entries =
self.eigenvalues_im
.iter()
.fold(0, |acc, e| if !e.is_zero() { acc + 1 } else { acc });
let mut eigenvalues = Vec::<Complex<T>>::with_capacity(number_of_complex_entries);
let mut eigenvectors = match self.eigenvectors.is_some() {
true => Some(Vec::<OVector<Complex<T>, D>>::with_capacity(
number_of_complex_entries,
)),
false => None,
};
let mut left_eigenvectors = match self.left_eigenvectors.is_some() {
true => Some(Vec::<OVector<Complex<T>, D>>::with_capacity(
number_of_complex_entries,
)),
false => None,
};
let mut c = 0;
while c < number_of_elements_value {
if self.eigenvalues_im[c] != T::zero() {
//Complex conjugate pairs of eigenvalues appear consecutively with the eigenvalue having the positive imaginary part first.
eigenvalues.push(Complex::<T>::new(
self.eigenvalues_re[c].clone(),
self.eigenvalues_im[c].clone(),
));
eigenvalues.push(Complex::<T>::new(
self.eigenvalues_re[c + 1].clone(),
self.eigenvalues_im[c + 1].clone(),
));
if eigenvectors.is_some() {
let mut vec = OVector::<Complex<T>, D>::zeros_generic(
number_of_elements,
Const::<1>,
);
let mut vec_conj = OVector::<Complex<T>, D>::zeros_generic(
number_of_elements,
Const::<1>,
);
for r in 0..number_of_elements_value {
vec[r] = Complex::<T>::new(
(&self.eigenvectors.as_ref()).unwrap()[(r, c)].clone(),
(&self.eigenvectors.as_ref()).unwrap()[(r, c + 1)].clone(),
);
vec_conj[r] = Complex::<T>::new(
(&self.eigenvectors.as_ref()).unwrap()[(r, c)].clone(),
(&self.eigenvectors.as_ref()).unwrap()[(r, c + 1)].clone(),
);
}
eigenvectors.as_mut().unwrap().push(vec);
eigenvectors.as_mut().unwrap().push(vec_conj);
}
if left_eigenvectors.is_some() {
let mut vec = OVector::<Complex<T>, D>::zeros_generic(
number_of_elements,
Const::<1>,
);
let mut vec_conj = OVector::<Complex<T>, D>::zeros_generic(
number_of_elements,
Const::<1>,
);
for r in 0..number_of_elements_value {
vec[r] = Complex::<T>::new(
(&self.left_eigenvectors.as_ref()).unwrap()[(r, c)].clone(),
(&self.left_eigenvectors.as_ref()).unwrap()[(r, c + 1)].clone(),
);
vec_conj[r] = Complex::<T>::new(
(&self.left_eigenvectors.as_ref()).unwrap()[(r, c)].clone(),
(&self.left_eigenvectors.as_ref()).unwrap()[(r, c + 1)].clone(),
);
}
left_eigenvectors.as_mut().unwrap().push(vec);
left_eigenvectors.as_mut().unwrap().push(vec_conj);
}
//skip next entry
c += 1;
}
c += 1;
}
(Some(eigenvalues), left_eigenvectors, eigenvectors)
}
}
}
} }
/* /*

View File

@ -58,8 +58,8 @@ proptest! {
let sol1 = chol.solve(&b1).unwrap(); let sol1 = chol.solve(&b1).unwrap();
let sol2 = chol.solve(&b2).unwrap(); let sol2 = chol.solve(&b2).unwrap();
prop_assert!(relative_eq!(m * sol1, b1, epsilon = 1.0e-7)); prop_assert!(relative_eq!(m * sol1, b1, epsilon = 1.0e-4));
prop_assert!(relative_eq!(m * sol2, b2, epsilon = 1.0e-7)); prop_assert!(relative_eq!(m * sol2, b2, epsilon = 1.0e-4));
} }
} }
@ -84,7 +84,7 @@ proptest! {
let id1 = &m * &m1; let id1 = &m * &m1;
let id2 = &m1 * &m; let id2 = &m1 * &m;
prop_assert!(id1.is_identity(1.0e-5) && id2.is_identity(1.0e-5)) prop_assert!(id1.is_identity(1.0e-4) && id2.is_identity(1.0e-4))
} }
} }
} }

View File

@ -0,0 +1,47 @@
use na::Matrix3;
use nalgebra_lapack::Eigen;
use num_complex::Complex;
#[test]
fn complex_eigen() {
let m = Matrix3::<f64>::new(
4.0 / 5.0,
-3.0 / 5.0,
0.0,
3.0 / 5.0,
4.0 / 5.0,
0.0,
1.0,
2.0,
2.0,
);
let eigen = Eigen::new(m, true, true).expect("Eigen Creation Failed!");
let (some_eigenvalues, some_left_vec, some_right_vec) = eigen.get_complex_elements();
let eigenvalues = some_eigenvalues.expect("Eigenvalues Failed");
let _left_eigenvectors = some_left_vec.expect("Left Eigenvectors Failed");
let eigenvectors = some_right_vec.expect("Right Eigenvectors Failed");
assert_relative_eq!(
eigenvalues[0].re,
Complex::<f64>::new(4.0 / 5.0, 3.0 / 5.0).re
);
assert_relative_eq!(
eigenvalues[0].im,
Complex::<f64>::new(4.0 / 5.0, 3.0 / 5.0).im
);
assert_relative_eq!(
eigenvalues[1].re,
Complex::<f64>::new(4.0 / 5.0, -3.0 / 5.0).re
);
assert_relative_eq!(
eigenvalues[1].im,
Complex::<f64>::new(4.0 / 5.0, -3.0 / 5.0).im
);
assert_relative_eq!(eigenvectors[0][0].re, -12.0 / 32.7871926215100059134410999);
assert_relative_eq!(eigenvectors[0][0].im, -9.0 / 32.7871926215100059134410999);
assert_relative_eq!(eigenvectors[0][1].re, -9.0 / 32.7871926215100059134410999);
assert_relative_eq!(eigenvectors[0][1].im, 12.0 / 32.7871926215100059134410999);
assert_relative_eq!(eigenvectors[0][2].re, 25.0 / 32.7871926215100059134410999);
assert_relative_eq!(eigenvectors[0][2].im, 0.0);
}

View File

@ -51,10 +51,10 @@ proptest! {
let tr_sol1 = lup.solve_transpose(&b1).unwrap(); let tr_sol1 = lup.solve_transpose(&b1).unwrap();
let tr_sol2 = lup.solve_transpose(&b2).unwrap(); let tr_sol2 = lup.solve_transpose(&b2).unwrap();
prop_assert!(relative_eq!(&m * sol1, b1, epsilon = 1.0e-7)); prop_assert!(relative_eq!(&m * sol1, b1, epsilon = 1.0e-5));
prop_assert!(relative_eq!(&m * sol2, b2, epsilon = 1.0e-7)); prop_assert!(relative_eq!(&m * sol2, b2, epsilon = 1.0e-5));
prop_assert!(relative_eq!(m.transpose() * tr_sol1, b1, epsilon = 1.0e-7)); prop_assert!(relative_eq!(m.transpose() * tr_sol1, b1, epsilon = 1.0e-5));
prop_assert!(relative_eq!(m.transpose() * tr_sol2, b2, epsilon = 1.0e-7)); prop_assert!(relative_eq!(m.transpose() * tr_sol2, b2, epsilon = 1.0e-5));
} }
#[test] #[test]
@ -68,10 +68,10 @@ proptest! {
let tr_sol1 = lup.solve_transpose(&b1).unwrap(); let tr_sol1 = lup.solve_transpose(&b1).unwrap();
let tr_sol2 = lup.solve_transpose(&b2).unwrap(); let tr_sol2 = lup.solve_transpose(&b2).unwrap();
prop_assert!(relative_eq!(m * sol1, b1, epsilon = 1.0e-7)); prop_assert!(relative_eq!(m * sol1, b1, epsilon = 1.0e-5));
prop_assert!(relative_eq!(m * sol2, b2, epsilon = 1.0e-7)); prop_assert!(relative_eq!(m * sol2, b2, epsilon = 1.0e-5));
prop_assert!(relative_eq!(m.transpose() * tr_sol1, b1, epsilon = 1.0e-7)); prop_assert!(relative_eq!(m.transpose() * tr_sol1, b1, epsilon = 1.0e-5));
prop_assert!(relative_eq!(m.transpose() * tr_sol2, b2, epsilon = 1.0e-7)); prop_assert!(relative_eq!(m.transpose() * tr_sol2, b2, epsilon = 1.0e-5));
} }
#[test] #[test]

View File

@ -1,4 +1,5 @@
mod cholesky; mod cholesky;
mod complex_eigen;
mod generalized_eigenvalues; mod generalized_eigenvalues;
mod lu; mod lu;
mod qr; mod qr;

View File

@ -13,30 +13,36 @@ proptest! {
let m = DMatrix::<f64>::new_random(n, n); let m = DMatrix::<f64>::new_random(n, n);
if let Some(eig) = Eigen::new(m.clone(), true, true) { if let Some(eig) = Eigen::new(m.clone(), true, true) {
let eigvals = DMatrix::from_diagonal(&eig.eigenvalues); // TODO: test the complex case too.
if eig.eigenvalues_are_real() {
let eigvals = DMatrix::from_diagonal(&eig.eigenvalues_re);
let transformed_eigvectors = &m * eig.eigenvectors.as_ref().unwrap(); let transformed_eigvectors = &m * eig.eigenvectors.as_ref().unwrap();
let scaled_eigvectors = eig.eigenvectors.as_ref().unwrap() * &eigvals; let scaled_eigvectors = eig.eigenvectors.as_ref().unwrap() * &eigvals;
let transformed_left_eigvectors = m.transpose() * eig.left_eigenvectors.as_ref().unwrap(); let transformed_left_eigvectors = m.transpose() * eig.left_eigenvectors.as_ref().unwrap();
let scaled_left_eigvectors = eig.left_eigenvectors.as_ref().unwrap() * &eigvals; let scaled_left_eigvectors = eig.left_eigenvectors.as_ref().unwrap() * &eigvals;
prop_assert!(relative_eq!(transformed_eigvectors, scaled_eigvectors, epsilon = 1.0e-7)); prop_assert!(relative_eq!(transformed_eigvectors, scaled_eigvectors, epsilon = 1.0e-5));
prop_assert!(relative_eq!(transformed_left_eigvectors, scaled_left_eigvectors, epsilon = 1.0e-7)); prop_assert!(relative_eq!(transformed_left_eigvectors, scaled_left_eigvectors, epsilon = 1.0e-5));
}
} }
} }
#[test] #[test]
fn eigensystem_static(m in matrix4()) { fn eigensystem_static(m in matrix4()) {
if let Some(eig) = Eigen::new(m, true, true) { if let Some(eig) = Eigen::new(m, true, true) {
let eigvals = Matrix4::from_diagonal(&eig.eigenvalues); // TODO: test the complex case too.
if eig.eigenvalues_are_real() {
let eigvals = Matrix4::from_diagonal(&eig.eigenvalues_re);
let transformed_eigvectors = m * eig.eigenvectors.unwrap(); let transformed_eigvectors = m * eig.eigenvectors.unwrap();
let scaled_eigvectors = eig.eigenvectors.unwrap() * eigvals; let scaled_eigvectors = eig.eigenvectors.unwrap() * eigvals;
let transformed_left_eigvectors = m.transpose() * eig.left_eigenvectors.unwrap(); let transformed_left_eigvectors = m.transpose() * eig.left_eigenvectors.unwrap();
let scaled_left_eigvectors = eig.left_eigenvectors.unwrap() * eigvals; let scaled_left_eigvectors = eig.left_eigenvectors.unwrap() * eigvals;
prop_assert!(relative_eq!(transformed_eigvectors, scaled_eigvectors, epsilon = 1.0e-7)); prop_assert!(relative_eq!(transformed_eigvectors, scaled_eigvectors, epsilon = 1.0e-5));
prop_assert!(relative_eq!(transformed_left_eigvectors, scaled_left_eigvectors, epsilon = 1.0e-7)); prop_assert!(relative_eq!(transformed_left_eigvectors, scaled_left_eigvectors, epsilon = 1.0e-5));
}
} }
} }
} }

View File

@ -11,14 +11,17 @@ proptest! {
let n = cmp::max(1, cmp::min(n, 10)); let n = cmp::max(1, cmp::min(n, 10));
let m = DMatrix::<f64>::new_random(n, n); let m = DMatrix::<f64>::new_random(n, n);
let (vecs, vals) = Schur::new(m.clone()).unpack(); if let Some(schur) = Schur::try_new(m.clone()) {
let (vecs, vals) = schur.unpack();
prop_assert!(relative_eq!(&vecs * vals * vecs.transpose(), m, epsilon = 1.0e-7)) prop_assert!(relative_eq!(&vecs * vals * vecs.transpose(), m, epsilon = 1.0e-5))
}
} }
#[test] #[test]
fn schur_static(m in matrix4()) { fn schur_static(m in matrix4()) {
let (vecs, vals) = Schur::new(m.clone()).unpack(); if let Some(schur) = Schur::try_new(m.clone()) {
prop_assert!(relative_eq!(vecs * vals * vecs.transpose(), m, epsilon = 1.0e-7)) let (vecs, vals) = schur.unpack();
prop_assert!(relative_eq!(vecs * vals * vecs.transpose(), m, epsilon = 1.0e-5))
}
} }
} }