Files
marqdo/plugins/linalg/src/factor.rs
T
cflmy 9331af78e2 release(2.8.0): 合入 CHANGELOG/README/发版说明/skills prove 任务;CI 链接指向 doc/releases
- CHANGELOG.md:v2.8.0 条目(中英双语);
- README.md:版本行 2.7.1→2.8.0 + 愿景第 6 条(知识可证明);
- doc/releases/v2.8.0.md:双语发版说明(亮点/用法/已知限制);
- skills/marqdo-dev/index.mq.md:新增 prove 任务(路径/目录模式/
  require_lean/json;参数用 + 行声明升参,check 与 narrative-ratio 通过);
- 设计文档 §12.5 标记已合入;发版链接统一指向 doc/releases/v2.8.0.md。
2026-11-18 10:29:26 +08:00

452 lines
13 KiB
Rust
Executable File
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);
}
}