Files
marqdo/plugins/linalg/src/factor.rs
T
cflmyandCursor c0fbe9b182 feat(linalg): L6 lstsq, norms, complex dtype, draw themes
Add QR/SVD least squares, norm/cond/rank, complex dense Frobenius
baseline, and light/dark/bw draw themes aligned with quantum Q8.

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-09-07 14:47:30 +08:00

452 lines
13 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! Dense factorizations for L4: LU, QR, eig (symmetric Jacobi), SVD, Cholesky.
use serde_json::{json, Value};
use crate::dense::{self, Mat, MAX_ELEMENTS};
pub const FACTOR_MAX_SIDE: usize = 64;
fn check_side(n: usize, label: &str) -> Result<(), String> {
if n > FACTOR_MAX_SIDE {
return Err(format!(
"{label} limited to side ≤ {FACTOR_MAX_SIDE} (got {n})"
));
}
Ok(())
}
pub fn check_side_limit(n: usize, label: &str) -> Result<(), String> {
check_side(n, label)
}
fn check_mat(m: &Mat) -> Result<(usize, usize), String> {
let (r, c) = dense::shape(m)?;
dense::check_elems(r, c)?;
Ok((r, c))
}
/// Factorize `kind` ∈ lu|qr|svd|eig|chol.
pub fn factorize(m: &Mat, kind: &str) -> Result<Value, String> {
let kind = kind.trim().to_ascii_lowercase();
match kind.as_str() {
"lu" => lu_value(m),
"qr" => qr_value(m),
"eig" => eig_value(m),
"svd" => svd_value(m),
"chol" | "cholesky" => chol_value(m),
other => Err(format!(
"unknown factorize kind `{other}` (want lu|qr|svd|eig|chol)"
)),
}
}
fn lu_value(m: &Mat) -> Result<Value, String> {
let (n, c) = check_mat(m)?;
if n != c {
return Err(format!("LU needs square matrix, got {n}×{c}"));
}
check_side(n, "LU")?;
let (l, u, piv) = lu_decomp(m)?;
Ok(json!({
"_type": "linalg_factor",
"kind": "lu",
"L": dense::to_dense_value(&l)?,
"U": dense::to_dense_value(&u)?,
"pivots": piv,
"latex": "A = LU",
"ascii": "LU",
}))
}
fn qr_value(m: &Mat) -> Result<Value, String> {
let (rows, cols) = check_mat(m)?;
check_side(rows.max(cols), "QR")?;
let (q, r) = qr_decomp(m)?;
Ok(json!({
"_type": "linalg_factor",
"kind": "qr",
"Q": dense::to_dense_value(&q)?,
"R": dense::to_dense_value(&r)?,
"latex": "A = QR",
"ascii": "QR",
}))
}
fn eig_value(m: &Mat) -> Result<Value, String> {
let (n, c) = check_mat(m)?;
if n != c {
return Err(format!("eig needs square matrix, got {n}×{c}"));
}
check_side(n, "eig")?;
// Jacobi assumes symmetric; if nearly symmetric, symmetrize.
let (evals, evecs) = jacobi_symm(m)?;
let d = dense::zeros(n, n);
let mut d = d;
for i in 0..n {
d[i][i] = evals[i];
}
Ok(json!({
"_type": "linalg_factor",
"kind": "eig",
"eigenvalues": evals,
"eigenvectors": dense::to_dense_value(&evecs)?,
"D": dense::to_dense_value(&d)?,
"latex": "A = P D P^{-1}",
"ascii": "eig",
}))
}
fn svd_value(m: &Mat) -> Result<Value, String> {
let (rows, cols) = check_mat(m)?;
check_side(rows.max(cols), "SVD")?;
let (u, s, vt) = svd_decomp(m)?;
Ok(json!({
"_type": "linalg_factor",
"kind": "svd",
"U": dense::to_dense_value(&u)?,
"S": s,
"Vt": dense::to_dense_value(&vt)?,
"latex": "A = U \\Sigma V^{\\top}",
"ascii": "SVD",
}))
}
fn chol_value(m: &Mat) -> Result<Value, String> {
let (n, c) = check_mat(m)?;
if n != c {
return Err(format!("Cholesky needs square matrix, got {n}×{c}"));
}
check_side(n, "Cholesky")?;
let l = cholesky(m)?;
Ok(json!({
"_type": "linalg_factor",
"kind": "chol",
"L": dense::to_dense_value(&l)?,
"latex": "A = L L^{\\top}",
"ascii": "chol",
}))
}
/// PA = LU with partial pivoting; returns (L, U, pivot row order).
pub fn lu_decomp(a: &Mat) -> Result<(Mat, Mat, Vec<usize>), String> {
let (n, _) = dense::shape(a)?;
let mut m = a.clone();
let mut piv: Vec<usize> = (0..n).collect();
let mut l = dense::eye(n);
for k in 0..n {
let mut piv_row = k;
let mut best = m[k][k].abs();
for i in (k + 1)..n {
let v = m[i][k].abs();
if v > best {
best = v;
piv_row = i;
}
}
if best < 1e-15 {
return Err("LU failed: singular or near-singular matrix".into());
}
if piv_row != k {
m.swap(k, piv_row);
piv.swap(k, piv_row);
for j in 0..k {
let t = l[k][j];
l[k][j] = l[piv_row][j];
l[piv_row][j] = t;
}
}
for i in (k + 1)..n {
let f = m[i][k] / m[k][k];
l[i][k] = f;
m[i][k] = 0.0;
for j in (k + 1)..n {
m[i][j] -= f * m[k][j];
}
}
}
Ok((l, m, piv))
}
/// Thin QR via modified Gram-Schmidt. A is m×n with m≥n preferred.
pub fn qr_decomp(a: &Mat) -> Result<(Mat, Mat), String> {
let (m, n) = dense::shape(a)?;
let mut v = a.clone();
let mut q = dense::zeros(m, n);
let mut r = dense::zeros(n, n);
for j in 0..n {
// orthogonalize against previous
for i in 0..j {
let mut dot = 0.0;
for k in 0..m {
dot += q[k][i] * v[k][j];
}
r[i][j] = dot;
for k in 0..m {
v[k][j] -= dot * q[k][i];
}
}
let mut norm = 0.0;
for k in 0..m {
norm += v[k][j] * v[k][j];
}
norm = norm.sqrt();
if norm < 1e-15 {
return Err("QR failed: linearly dependent columns".into());
}
r[j][j] = norm;
for k in 0..m {
q[k][j] = v[k][j] / norm;
}
}
Ok((q, r))
}
/// Jacobi eigenvalue for symmetric (or symmetrized) real matrix.
/// Returns eigenvalues (descending) and eigenvector matrix (columns).
pub fn jacobi_symm(a: &Mat) -> Result<(Vec<f64>, Mat), String> {
let (n, _) = dense::shape(a)?;
// Symmetrize
let mut s = dense::zeros(n, n);
for i in 0..n {
for j in 0..n {
s[i][j] = 0.5 * (a[i][j] + a[j][i]);
}
}
let mut v = dense::eye(n);
for _ in 0..(n * n * 40).max(40) {
// Find largest off-diagonal
let mut p = 0usize;
let mut q = 1usize;
let mut best = 0.0;
for i in 0..n {
for j in (i + 1)..n {
let v = s[i][j].abs();
if v > best {
best = v;
p = i;
q = j;
}
}
}
if best < 1e-12 {
break;
}
let app = s[p][p];
let aqq = s[q][q];
let apq = s[p][q];
let tau = (aqq - app) / (2.0 * apq);
let t = if tau >= 0.0 {
1.0 / (tau + (1.0 + tau * tau).sqrt())
} else {
-1.0 / (-tau + (1.0 + tau * tau).sqrt())
};
let c = 1.0 / (1.0 + t * t).sqrt();
let sn = t * c;
// Rotate S
s[p][p] = app - t * apq;
s[q][q] = aqq + t * apq;
s[p][q] = 0.0;
s[q][p] = 0.0;
for i in 0..n {
if i == p || i == q {
continue;
}
let sip = s[i][p];
let siq = s[i][q];
s[i][p] = c * sip - sn * siq;
s[p][i] = s[i][p];
s[i][q] = c * siq + sn * sip;
s[q][i] = s[i][q];
}
// Accumulate V
for i in 0..n {
let vip = v[i][p];
let viq = v[i][q];
v[i][p] = c * vip - sn * viq;
v[i][q] = c * viq + sn * vip;
}
}
let mut pairs: Vec<(f64, usize)> = (0..n).map(|i| (s[i][i], i)).collect();
pairs.sort_by(|a, b| b.0.partial_cmp(&a.0).unwrap_or(std::cmp::Ordering::Equal));
let mut evals = Vec::with_capacity(n);
let mut evecs = dense::zeros(n, n);
for (col, &(ev, idx)) in pairs.iter().enumerate() {
evals.push(ev);
for row in 0..n {
evecs[row][col] = v[row][idx];
}
}
Ok((evals, evecs))
}
/// Economy SVD via eig of AᵀA (n small).
pub fn svd_decomp(a: &Mat) -> Result<(Mat, Vec<f64>, Mat), String> {
let (m, n) = dense::shape(a)?;
// Gram = Aᵀ A (n×n)
let at = dense::transpose(a);
let gram = dense::matmul(&at, a)?;
let (evals, v) = jacobi_symm(&gram)?;
let mut svals = Vec::with_capacity(n.min(m));
let rank = n.min(m);
for i in 0..rank {
let s = if evals[i] > 0.0 { evals[i].sqrt() } else { 0.0 };
svals.push(s);
}
// Vt = Vᵀ
let vt = dense::transpose(&v);
// U = A V S^{+}
let mut u = dense::zeros(m, rank);
for j in 0..rank {
if svals[j] < 1e-15 {
continue;
}
// u_j = A v_j / s_j
for i in 0..m {
let mut sum = 0.0;
for k in 0..n {
sum += a[i][k] * v[k][j];
}
u[i][j] = sum / svals[j];
}
}
// Truncate Vt to rank rows
let mut vt_r = dense::zeros(rank, n);
for i in 0..rank {
for j in 0..n {
vt_r[i][j] = vt[i][j];
}
}
let _ = MAX_ELEMENTS;
Ok((u, svals, vt_r))
}
pub fn cholesky(a: &Mat) -> Result<Mat, String> {
let (n, _) = dense::shape(a)?;
let mut l = dense::zeros(n, n);
for i in 0..n {
for j in 0..=i {
let mut sum = 0.0;
for k in 0..j {
sum += l[i][k] * l[j][k];
}
if i == j {
let v = a[i][i] - sum;
if v <= 1e-15 {
return Err("Cholesky failed: matrix not positive definite".into());
}
l[i][j] = v.sqrt();
} else {
if l[j][j].abs() < 1e-15 {
return Err("Cholesky failed: zero pivot".into());
}
l[i][j] = (a[i][j] - sum) / l[j][j];
}
}
}
Ok(l)
}
/// Forward/back-sub with LU from `factorize kind=lu` (pivots applied to rhs).
pub fn solve_lu_factor(factor: &Value, b: &Mat) -> Result<Mat, String> {
if factor.get("kind").and_then(|k| k.as_str()) != Some("lu") {
return Err("solve(factor=…) needs kind=lu factor".into());
}
let l = dense::from_value(factor.get("L").ok_or_else(|| "factor missing L".to_string())?)?;
let u = dense::from_value(factor.get("U").ok_or_else(|| "factor missing U".to_string())?)?;
let piv = factor
.get("pivots")
.and_then(|p| p.as_array())
.ok_or_else(|| "factor missing pivots".to_string())?;
let (n, _) = dense::shape(&l)?;
let (br, bc) = dense::shape(b)?;
if br != n {
return Err(format!("rhs rows {br} != factor size {n}"));
}
let mut pb = dense::zeros(n, bc);
for (i, p) in piv.iter().enumerate() {
let src = p
.as_u64()
.or_else(|| p.as_i64().map(|x| x as u64))
.ok_or_else(|| "bad pivot".to_string())? as usize;
if src >= n {
return Err("pivot out of range".into());
}
for j in 0..bc {
pb[i][j] = b[src][j];
}
}
// Ly = Pb
let mut y = dense::zeros(n, bc);
for i in 0..n {
for j in 0..bc {
let mut s = pb[i][j];
for k in 0..i {
s -= l[i][k] * y[k][j];
}
y[i][j] = s / l[i][i];
}
}
// Ux = y
let mut x = dense::zeros(n, bc);
for i in (0..n).rev() {
for j in 0..bc {
let mut s = y[i][j];
for k in (i + 1)..n {
s -= u[i][k] * x[k][j];
}
if u[i][i].abs() < 1e-15 {
return Err("singular U in LU solve".into());
}
x[i][j] = s / u[i][i];
}
}
Ok(x)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn eig_diag() {
let m = vec![vec![2.0, 0.0], vec![0.0, 3.0]];
let (ev, _) = jacobi_symm(&m).unwrap();
assert!((ev[0] - 3.0).abs() < 1e-9);
assert!((ev[1] - 2.0).abs() < 1e-9);
}
#[test]
fn qr_roundtrip() {
let a = vec![vec![1.0, 1.0], vec![0.0, 1.0], vec![1.0, 0.0]];
let (q, r) = qr_decomp(&a).unwrap();
let recon = dense::matmul(&q, &r).unwrap();
for i in 0..3 {
for j in 0..2 {
assert!((recon[i][j] - a[i][j]).abs() < 1e-9);
}
}
}
#[test]
fn lu_roundtrip_no_pivot_needed() {
let a = vec![vec![2.0, 1.0], vec![1.0, 3.0]];
let (l, u, _) = lu_decomp(&a).unwrap();
let recon = dense::matmul(&l, &u).unwrap();
for i in 0..2 {
for j in 0..2 {
assert!((recon[i][j] - a[i][j]).abs() < 1e-9);
}
}
}
#[test]
fn lu_solve_reuse() {
let a = vec![vec![2.0, 1.0], vec![1.0, 3.0]];
let b = vec![vec![5.0], vec![5.0]];
let f = factorize(&a, "lu").unwrap();
let x = solve_lu_factor(&f, &b).unwrap();
assert!((x[0][0] - 2.0).abs() < 1e-9);
assert!((x[1][0] - 1.0).abs() < 1e-9);
}
}