use crate::algorithms::kernels;
use crate::errors::linear_error::LinearError;
use crate::traits::matrix_view::MatrixView;
use crate::types::dense_matrix::DenseMatrix;
use crate::types::dense_vector::DenseVector;
use alloc::vec::Vec;
use deep_causality_algebra::ConjugateScalar;
use deep_causality_num::Zero;
pub(crate) fn flatten<M: MatrixView>(m: &M) -> Result<Vec<M::Scalar>, LinearError> {
m.to_row_major()
}
pub type SvdFactors<T> = (DenseMatrix<T>, DenseVector<T>, DenseMatrix<T>);
pub type QrFactors<T> = (DenseMatrix<T>, DenseMatrix<T>);
pub type EigenPair<T> = (DenseVector<T>, DenseMatrix<T>);
pub type SvdReal<T> = (
DenseMatrix<T>,
Vec<<T as ConjugateScalar>::Real>,
DenseMatrix<T>,
);
pub fn svd<M>(m: &M) -> Result<SvdFactors<M::Scalar>, LinearError>
where
M: MatrixView,
M::Scalar: ConjugateScalar,
{
let (u, sigma, vt) = svd_sorted(m)?;
let s = sigma
.into_iter()
.map(<M::Scalar as ConjugateScalar>::from_real)
.collect();
Ok((u, DenseVector::from_vec(s), vt))
}
pub fn svd_sorted<M>(m: &M) -> Result<SvdReal<M::Scalar>, LinearError>
where
M: MatrixView,
M::Scalar: ConjugateScalar,
{
let (rows, cols) = (m.rows(), m.cols());
if rows == 0 || cols == 0 {
return Ok((
DenseMatrix::from_vec(Vec::new(), rows, 0).expect("empty"),
Vec::new(),
DenseMatrix::from_vec(Vec::new(), 0, cols).expect("empty"),
));
}
let flat = flatten(m)?;
let transposed = rows < cols;
let (wr, wc, work) = if transposed {
(cols, rows, kernels::conj_transpose(&flat, rows, cols))
} else {
(rows, cols, flat)
};
let (u_full, sigma, v_full) = kernels::jacobi_svd::<M::Scalar>(work, wr, wc);
let mut order: Vec<usize> = (0..wc).collect();
order.sort_by(|&a, &b| {
sigma[b]
.partial_cmp(&sigma[a])
.unwrap_or(core::cmp::Ordering::Equal)
});
let k = wc; let (left, right, left_rows, right_rows) = if transposed {
(&v_full, &u_full, wc, wr)
} else {
(&u_full, &v_full, wr, wc)
};
let mut u_out = alloc::vec![M::Scalar::zero(); left_rows * k];
for (col, &j) in order.iter().take(k).enumerate() {
for row in 0..left_rows {
u_out[row * k + col] = left[row * wc + j];
}
}
let mut vt_out = alloc::vec![M::Scalar::zero(); k * right_rows];
for (r, &j) in order.iter().take(k).enumerate() {
for c in 0..right_rows {
vt_out[r * right_rows + c] = right[c * wc + j].conjugate();
}
}
let s_out: Vec<<M::Scalar as ConjugateScalar>::Real> =
order.iter().take(k).map(|&j| sigma[j]).collect();
Ok((
DenseMatrix::from_vec(u_out, left_rows, k).expect("built from the shape"),
s_out,
DenseMatrix::from_vec(vt_out, k, right_rows).expect("built from the shape"),
))
}
pub fn singular_values<M>(m: &M) -> Result<DenseVector<M::Scalar>, LinearError>
where
M: MatrixView,
M::Scalar: ConjugateScalar,
{
Ok(svd(m)?.1)
}
pub fn svd_truncated<M>(
m: &M,
spec: &Truncation<<M::Scalar as ConjugateScalar>::Real>,
) -> Result<SvdFactors<M::Scalar>, LinearError>
where
M: MatrixView,
M::Scalar: ConjugateScalar,
{
let (u, sigma, vt) = svd_sorted(m)?;
let keep = match spec {
Truncation::Rank(k) => (*k).min(sigma.len()),
Truncation::Tolerance(t) => sigma.iter().filter(|s| *s > t).count(),
Truncation::RankAndTolerance { rank, tolerance } => {
sigma.iter().filter(|s| *s > tolerance).count().min(*rank)
}
};
let (rows, k_full) = u.shape();
let (_, cols) = vt.shape();
let mut u_out = alloc::vec![M::Scalar::zero(); rows * keep];
for i in 0..rows {
for j in 0..keep {
u_out[i * keep + j] = u.as_slice()[i * k_full + j];
}
}
let vt_out = vt.as_slice()[..keep * cols].to_vec();
let s_out = sigma
.into_iter()
.take(keep)
.map(<M::Scalar as ConjugateScalar>::from_real)
.collect();
Ok((
DenseMatrix::from_vec(u_out, rows, keep).expect("built from the shape"),
DenseVector::from_vec(s_out),
DenseMatrix::from_vec(vt_out, keep, cols).expect("built from the shape"),
))
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum Truncation<R> {
Rank(usize),
Tolerance(R),
RankAndTolerance { rank: usize, tolerance: R },
}
pub fn qr<M>(m: &M) -> Result<QrFactors<M::Scalar>, LinearError>
where
M: MatrixView,
M::Scalar: ConjugateScalar,
{
let (rows, cols) = (m.rows(), m.cols());
let a = flatten(m)?;
let (q, r, k) = kernels::householder_qr(&a, rows, cols);
Ok((
DenseMatrix::from_vec(q, rows, k).expect("built from the shape"),
DenseMatrix::from_vec(r, k, cols).expect("built from the shape"),
))
}
pub fn eigen_hermitian<M>(m: &M) -> Result<EigenPair<M::Scalar>, LinearError>
where
M: MatrixView,
M::Scalar: ConjugateScalar,
{
let (rows, cols) = (m.rows(), m.cols());
if rows != cols {
return Err(LinearError::NotSquare((rows, cols)));
}
let a = flatten(m)?;
let (values, v) = kernels::sym_eig(&a, rows);
Ok((
DenseVector::from_vec(values),
DenseMatrix::from_vec(v, rows, rows).expect("built from the shape"),
))
}