pub mod decompose;
pub mod solve;
pub use decompose::qr_decompose;
pub use solve::solve_least_squares;
use crate::domain::real::RealScalar;
use leto::Array2;
#[derive(Debug, Clone)]
pub struct QrDecomposition<T> {
pub(super) packed: Vec<T>,
pub(super) heads: Vec<T>,
pub(super) betas: Vec<T>,
pub(super) rows: usize,
pub(super) cols: usize,
}
impl<T: RealScalar> QrDecomposition<T> {
#[must_use]
#[inline]
pub fn from_raw_parts(
packed: Vec<T>,
heads: Vec<T>,
betas: Vec<T>,
rows: usize,
cols: usize,
) -> Self {
Self {
packed,
heads,
betas,
rows,
cols,
}
}
#[must_use]
#[inline]
pub fn shape(&self) -> (usize, usize) {
(self.rows, self.cols)
}
#[must_use]
#[inline]
pub fn packed(&self) -> &[T] {
&self.packed
}
#[must_use]
#[inline]
pub fn heads(&self) -> &[T] {
&self.heads
}
#[must_use]
#[inline]
pub fn betas(&self) -> &[T] {
&self.betas
}
#[must_use]
pub fn q(&self) -> Array2<T> {
let (m, n) = (self.rows, self.cols);
let mut q = vec![T::ZERO; m * m];
for i in 0..m {
q[i * m + i] = T::ONE;
}
let limit = n.min(m);
for k in (0..limit).rev() {
let beta = self.betas[k];
if beta == T::ZERO {
continue;
}
for col_idx in 0..m {
let mut dot = self.heads[k].mul(q[k * m + col_idx]);
for offset in 1..(m - k) {
let r = k + offset;
let v_val = self.packed[r * n + k];
dot = dot.add(v_val.mul(q[r * m + col_idx]));
}
let bs = beta.mul(dot);
q[k * m + col_idx] = q[k * m + col_idx].sub(bs.mul(self.heads[k]));
for offset in 1..(m - k) {
let r = k + offset;
let v_val = self.packed[r * n + k];
q[r * m + col_idx] = q[r * m + col_idx].sub(bs.mul(v_val));
}
}
}
Array2::from_shape_vec([m, m], q).expect("Q shape matches storage")
}
#[must_use]
pub fn r(&self) -> Array2<T> {
let (m, n) = (self.rows, self.cols);
let mut r = vec![T::ZERO; m * n];
for i in 0..m {
for j in i..n {
r[i * n + j] = self.packed[i * n + j];
}
}
Array2::from_shape_vec([m, n], r).expect("R shape matches storage")
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn reflector_accessors_reproduce_q() {
let a = Array2::from_vec(
[4, 3],
vec![
1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 10.0, 11.0, 13.0, 17.0,
],
)
.expect("4x3 literal matches the declared shape");
let qr = qr_decompose(&a.view()).expect("full-rank 4x3 matrix factors");
let (m, n) = qr.shape();
let packed = qr.packed();
let heads = qr.heads();
let betas = qr.betas();
let mut q = vec![0.0_f64; m * m];
for i in 0..m {
q[i * m + i] = 1.0;
}
let limit = n.min(m);
for k in (0..limit).rev() {
let beta = betas[k];
if beta == 0.0 {
continue;
}
for col in 0..m {
let mut dot = heads[k] * q[k * m + col];
for r in (k + 1)..m {
dot += packed[r * n + k] * q[r * m + col];
}
let scaled = beta * dot;
q[k * m + col] -= scaled * heads[k];
for r in (k + 1)..m {
q[r * m + col] -= scaled * packed[r * n + k];
}
}
}
let expected = qr.q();
assert_eq!(
q.as_slice(),
expected
.as_slice()
.expect("q() returns dense row-major storage")
);
}
}