2017-08-14 01:53:04 +08:00
|
|
|
#[cfg(feature = "serde-serialize")]
|
2018-09-13 12:55:58 +08:00
|
|
|
use serde::{Serialize, Deserialize};
|
2017-08-14 01:53:04 +08:00
|
|
|
|
2017-08-03 01:38:28 +08:00
|
|
|
use num::Zero;
|
2018-05-25 05:51:57 +08:00
|
|
|
use num_complex::Complex;
|
2017-08-03 01:38:28 +08:00
|
|
|
|
2018-05-25 05:51:57 +08:00
|
|
|
use na::allocator::Allocator;
|
2017-08-03 01:38:28 +08:00
|
|
|
use na::dimension::{Dim, DimMin, DimMinimum, U1};
|
|
|
|
use na::storage::Storage;
|
2018-05-25 05:51:57 +08:00
|
|
|
use na::{DefaultAllocator, Matrix, MatrixMN, Scalar, VectorN};
|
|
|
|
use ComplexHelper;
|
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
|
|
|
|
|
|
|
/// The QR decomposition of a general matrix.
|
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",
|
|
|
|
serde(
|
|
|
|
bound(
|
|
|
|
serialize = "DefaultAllocator: Allocator<N, R, C> +
|
2017-08-14 01:53:04 +08:00
|
|
|
Allocator<N, DimMinimum<R, C>>,
|
2018-09-13 12:55:58 +08:00
|
|
|
MatrixMN<N, R, C>: Serialize,
|
|
|
|
VectorN<N, DimMinimum<R, C>>: Serialize"
|
2018-05-25 05:51:57 +08:00
|
|
|
)
|
|
|
|
)
|
|
|
|
)]
|
|
|
|
#[cfg_attr(
|
|
|
|
feature = "serde-serialize",
|
|
|
|
serde(
|
|
|
|
bound(
|
|
|
|
deserialize = "DefaultAllocator: Allocator<N, R, C> +
|
2017-08-14 01:53:04 +08:00
|
|
|
Allocator<N, DimMinimum<R, C>>,
|
2018-09-13 12:55:58 +08:00
|
|
|
MatrixMN<N, R, C>: Deserialize<'de>,
|
|
|
|
VectorN<N, DimMinimum<R, C>>: Deserialize<'de>"
|
2018-05-25 05:51:57 +08:00
|
|
|
)
|
|
|
|
)
|
|
|
|
)]
|
2017-08-14 01:53:04 +08:00
|
|
|
#[derive(Clone, Debug)]
|
2017-08-03 01:38:28 +08:00
|
|
|
pub struct QR<N: Scalar, R: DimMin<C>, C: Dim>
|
2018-02-02 19:26:35 +08:00
|
|
|
where
|
|
|
|
DefaultAllocator: Allocator<N, R, C> + Allocator<N, DimMinimum<R, C>>,
|
|
|
|
{
|
|
|
|
qr: MatrixMN<N, R, C>,
|
|
|
|
tau: VectorN<N, DimMinimum<R, C>>,
|
2017-08-03 01:38:28 +08:00
|
|
|
}
|
|
|
|
|
2017-08-14 01:53:04 +08:00
|
|
|
impl<N: Scalar, R: DimMin<C>, C: Dim> Copy for QR<N, R, C>
|
2018-02-02 19:26:35 +08:00
|
|
|
where
|
|
|
|
DefaultAllocator: Allocator<N, R, C> + Allocator<N, DimMinimum<R, C>>,
|
|
|
|
MatrixMN<N, R, C>: Copy,
|
|
|
|
VectorN<N, DimMinimum<R, C>>: Copy,
|
|
|
|
{
|
|
|
|
}
|
2017-08-14 01:53:04 +08:00
|
|
|
|
2017-08-03 01:38:28 +08:00
|
|
|
impl<N: QRScalar + Zero, R: DimMin<C>, C: Dim> QR<N, R, C>
|
2018-02-02 19:26:35 +08:00
|
|
|
where
|
|
|
|
DefaultAllocator: Allocator<N, R, C>
|
|
|
|
+ Allocator<N, R, DimMinimum<R, C>>
|
|
|
|
+ Allocator<N, DimMinimum<R, C>, C>
|
|
|
|
+ Allocator<N, DimMinimum<R, C>>,
|
|
|
|
{
|
2017-08-03 01:38:28 +08:00
|
|
|
/// Computes the QR decomposition of the matrix `m`.
|
|
|
|
pub fn new(mut m: MatrixMN<N, R, C>) -> QR<N, R, C> {
|
|
|
|
let (nrows, ncols) = m.data.shape();
|
|
|
|
|
2018-02-02 19:26:35 +08:00
|
|
|
let mut info = 0;
|
2017-08-03 01:38:28 +08:00
|
|
|
let mut tau = unsafe { Matrix::new_uninitialized_generic(nrows.min(ncols), U1) };
|
|
|
|
|
|
|
|
if nrows.value() == 0 || ncols.value() == 0 {
|
|
|
|
return QR { qr: m, tau: tau };
|
|
|
|
}
|
|
|
|
|
2018-02-02 19:26:35 +08:00
|
|
|
let lwork = N::xgeqrf_work_size(
|
|
|
|
nrows.value() as i32,
|
|
|
|
ncols.value() as i32,
|
|
|
|
m.as_mut_slice(),
|
|
|
|
nrows.value() as i32,
|
|
|
|
tau.as_mut_slice(),
|
|
|
|
&mut info,
|
|
|
|
);
|
2017-08-03 01:38:28 +08:00
|
|
|
|
|
|
|
let mut work = unsafe { ::uninitialized_vec(lwork as usize) };
|
|
|
|
|
2018-02-02 19:26:35 +08:00
|
|
|
N::xgeqrf(
|
|
|
|
nrows.value() as i32,
|
|
|
|
ncols.value() as i32,
|
|
|
|
m.as_mut_slice(),
|
|
|
|
nrows.value() as i32,
|
|
|
|
tau.as_mut_slice(),
|
|
|
|
&mut work,
|
|
|
|
lwork,
|
|
|
|
&mut info,
|
|
|
|
);
|
2017-08-03 01:38:28 +08:00
|
|
|
|
|
|
|
QR { qr: m, tau: tau }
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Retrieves the upper trapezoidal submatrix `R` of this decomposition.
|
|
|
|
#[inline]
|
|
|
|
pub fn r(&self) -> MatrixMN<N, DimMinimum<R, C>, C> {
|
|
|
|
let (nrows, ncols) = self.qr.data.shape();
|
|
|
|
self.qr.rows_generic(0, nrows.min(ncols)).upper_triangle()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<N: QRReal + Zero, R: DimMin<C>, C: Dim> QR<N, R, C>
|
2018-02-02 19:26:35 +08:00
|
|
|
where
|
|
|
|
DefaultAllocator: Allocator<N, R, C>
|
|
|
|
+ Allocator<N, R, DimMinimum<R, C>>
|
|
|
|
+ Allocator<N, DimMinimum<R, C>, C>
|
|
|
|
+ Allocator<N, DimMinimum<R, C>>,
|
|
|
|
{
|
2017-08-03 01:38:28 +08:00
|
|
|
/// Retrieves the matrices `(Q, R)` of this decompositions.
|
2018-02-02 19:26:35 +08:00
|
|
|
pub fn unpack(
|
|
|
|
self,
|
|
|
|
) -> (
|
|
|
|
MatrixMN<N, R, DimMinimum<R, C>>,
|
|
|
|
MatrixMN<N, DimMinimum<R, C>, C>,
|
|
|
|
) {
|
2017-08-03 01:38:28 +08:00
|
|
|
(self.q(), self.r())
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Computes the orthogonal matrix `Q` of this decomposition.
|
|
|
|
#[inline]
|
|
|
|
pub fn q(&self) -> MatrixMN<N, R, DimMinimum<R, C>> {
|
2018-02-02 19:26:35 +08:00
|
|
|
let (nrows, ncols) = self.qr.data.shape();
|
2017-08-03 01:38:28 +08:00
|
|
|
let min_nrows_ncols = nrows.min(ncols);
|
|
|
|
|
|
|
|
if min_nrows_ncols.value() == 0 {
|
|
|
|
return MatrixMN::from_element_generic(nrows, min_nrows_ncols, N::zero());
|
|
|
|
}
|
|
|
|
|
2018-02-02 19:26:35 +08:00
|
|
|
let mut q = self.qr
|
|
|
|
.generic_slice((0, 0), (nrows, min_nrows_ncols))
|
|
|
|
.into_owned();
|
2017-08-03 01:38:28 +08:00
|
|
|
|
2018-02-02 19:26:35 +08:00
|
|
|
let mut info = 0;
|
2017-08-03 01:38:28 +08:00
|
|
|
let nrows = nrows.value() as i32;
|
|
|
|
|
2018-02-02 19:26:35 +08:00
|
|
|
let lwork = N::xorgqr_work_size(
|
|
|
|
nrows,
|
|
|
|
min_nrows_ncols.value() as i32,
|
|
|
|
self.tau.len() as i32,
|
|
|
|
q.as_mut_slice(),
|
|
|
|
nrows,
|
|
|
|
self.tau.as_slice(),
|
|
|
|
&mut info,
|
|
|
|
);
|
|
|
|
|
|
|
|
let mut work = vec![N::zero(); lwork as usize];
|
|
|
|
|
|
|
|
N::xorgqr(
|
|
|
|
nrows,
|
|
|
|
min_nrows_ncols.value() as i32,
|
|
|
|
self.tau.len() as i32,
|
|
|
|
q.as_mut_slice(),
|
|
|
|
nrows,
|
|
|
|
self.tau.as_slice(),
|
|
|
|
&mut work,
|
|
|
|
lwork,
|
|
|
|
&mut info,
|
|
|
|
);
|
2017-08-03 01:38:28 +08:00
|
|
|
|
|
|
|
q
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
*
|
|
|
|
* Lapack functions dispatch.
|
|
|
|
*
|
|
|
|
*/
|
2017-08-14 01:52:58 +08:00
|
|
|
/// Trait implemented by scalar types for which Lapack funtion exist to compute the
|
|
|
|
/// QR decomposition.
|
2017-08-03 01:38:28 +08:00
|
|
|
pub trait QRScalar: Scalar {
|
2018-02-02 19:26:35 +08:00
|
|
|
fn xgeqrf(
|
|
|
|
m: i32,
|
|
|
|
n: i32,
|
|
|
|
a: &mut [Self],
|
|
|
|
lda: i32,
|
|
|
|
tau: &mut [Self],
|
|
|
|
work: &mut [Self],
|
|
|
|
lwork: i32,
|
|
|
|
info: &mut i32,
|
|
|
|
);
|
|
|
|
|
|
|
|
fn xgeqrf_work_size(
|
|
|
|
m: i32,
|
|
|
|
n: i32,
|
|
|
|
a: &mut [Self],
|
|
|
|
lda: i32,
|
|
|
|
tau: &mut [Self],
|
|
|
|
info: &mut i32,
|
|
|
|
) -> i32;
|
2017-08-03 01:38:28 +08:00
|
|
|
}
|
|
|
|
|
2017-08-14 01:52:58 +08:00
|
|
|
/// Trait implemented by reals for which Lapack funtion exist to compute the
|
|
|
|
/// QR decomposition.
|
2017-08-03 01:38:28 +08:00
|
|
|
pub trait QRReal: QRScalar {
|
2017-08-14 01:52:58 +08:00
|
|
|
#[allow(missing_docs)]
|
2018-02-02 19:26:35 +08:00
|
|
|
fn xorgqr(
|
|
|
|
m: i32,
|
|
|
|
n: i32,
|
|
|
|
k: i32,
|
|
|
|
a: &mut [Self],
|
|
|
|
lda: i32,
|
|
|
|
tau: &[Self],
|
|
|
|
work: &mut [Self],
|
|
|
|
lwork: i32,
|
|
|
|
info: &mut i32,
|
|
|
|
);
|
2017-08-03 01:38:28 +08:00
|
|
|
|
2017-08-14 01:52:58 +08:00
|
|
|
#[allow(missing_docs)]
|
2018-02-02 19:26:35 +08:00
|
|
|
fn xorgqr_work_size(
|
|
|
|
m: i32,
|
|
|
|
n: i32,
|
|
|
|
k: i32,
|
|
|
|
a: &mut [Self],
|
|
|
|
lda: i32,
|
|
|
|
tau: &[Self],
|
|
|
|
info: &mut i32,
|
|
|
|
) -> i32;
|
2017-08-03 01:38:28 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
macro_rules! qr_scalar_impl(
|
|
|
|
($N: ty, $xgeqrf: path) => (
|
|
|
|
impl QRScalar for $N {
|
|
|
|
#[inline]
|
|
|
|
fn xgeqrf(m: i32, n: i32, a: &mut [Self], lda: i32, tau: &mut [Self],
|
|
|
|
work: &mut [Self], lwork: i32, info: &mut i32) {
|
2018-05-25 05:51:57 +08:00
|
|
|
unsafe { $xgeqrf(m, n, a, lda, tau, work, lwork, info) }
|
2017-08-03 01:38:28 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
fn xgeqrf_work_size(m: i32, n: i32, a: &mut [Self], lda: i32, tau: &mut [Self],
|
|
|
|
info: &mut i32) -> i32 {
|
|
|
|
let mut work = [ Zero::zero() ];
|
|
|
|
let lwork = -1 as i32;
|
|
|
|
|
2018-05-25 05:51:57 +08:00
|
|
|
unsafe { $xgeqrf(m, n, a, lda, tau, &mut work, lwork, info); }
|
2017-08-03 01:38:28 +08:00
|
|
|
ComplexHelper::real_part(work[0]) as i32
|
|
|
|
}
|
|
|
|
}
|
|
|
|
)
|
|
|
|
);
|
|
|
|
|
|
|
|
macro_rules! qr_real_impl(
|
|
|
|
($N: ty, $xorgqr: path) => (
|
|
|
|
impl QRReal for $N {
|
|
|
|
#[inline]
|
|
|
|
fn xorgqr(m: i32, n: i32, k: i32, a: &mut [Self], lda: i32, tau: &[Self],
|
|
|
|
work: &mut [Self], lwork: i32, info: &mut i32) {
|
2018-05-25 05:51:57 +08:00
|
|
|
unsafe { $xorgqr(m, n, k, a, lda, tau, work, lwork, info) }
|
2017-08-03 01:38:28 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
fn xorgqr_work_size(m: i32, n: i32, k: i32, a: &mut [Self], lda: i32, tau: &[Self],
|
|
|
|
info: &mut i32) -> i32 {
|
|
|
|
let mut work = [ Zero::zero() ];
|
|
|
|
let lwork = -1 as i32;
|
|
|
|
|
2018-05-25 05:51:57 +08:00
|
|
|
unsafe { $xorgqr(m, n, k, a, lda, tau, &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
|
|
|
qr_scalar_impl!(f32, lapack::sgeqrf);
|
|
|
|
qr_scalar_impl!(f64, lapack::dgeqrf);
|
|
|
|
qr_scalar_impl!(Complex<f32>, lapack::cgeqrf);
|
|
|
|
qr_scalar_impl!(Complex<f64>, lapack::zgeqrf);
|
2017-08-03 01:38:28 +08:00
|
|
|
|
2018-05-25 05:51:57 +08:00
|
|
|
qr_real_impl!(f32, lapack::sorgqr);
|
|
|
|
qr_real_impl!(f64, lapack::dorgqr);
|