From 70fb2fbfb287fafc15bfa6a670c202bae488760c Mon Sep 17 00:00:00 2001 From: cflmy Date: Mon, 7 Sep 2026 14:31:44 +0800 Subject: [PATCH] feat(linalg): L4 factorize and structure SVG draw Add LU/QR/SVD/eig/chol dense factorizations, teaching structure SVGs, LU reuse via solve(factor=), and linalg-factor-smoke gold. Co-authored-by: Cursor --- .gitignore | 1 + CHANGELOG.md | 2 +- doc/design/ext-linalg.md | 2 +- doc/roadmap/ext-linalg.md | 10 +- ext/linalg/linalg.mq.md | 26 +- ext/linalg/线性代数.mq.md | 26 +- plugins/linalg/src/draw.rs | 235 +++++++++++++++ plugins/linalg/src/factor.rs | 447 ++++++++++++++++++++++++++++ plugins/linalg/src/lib.rs | 72 ++++- tests/ext/linalg-factor-smoke.mq.md | 79 +++++ tests/gold.rs | 19 ++ 11 files changed, 903 insertions(+), 16 deletions(-) create mode 100644 plugins/linalg/src/draw.rs create mode 100644 plugins/linalg/src/factor.rs create mode 100644 tests/ext/linalg-factor-smoke.mq.md diff --git a/.gitignore b/.gitignore index b451b56..7df2593 100644 --- a/.gitignore +++ b/.gitignore @@ -63,6 +63,7 @@ plugins/*/tmp/ # Quantum draw/SVG runtime outputs (sources & gold .mq.md stay tracked) /tests/ext/quantum-*.svg +/tests/ext/linalg-*.svg /examples/quantum-*/**/*.svg /examples/quantum-*/*.svg diff --git a/CHANGELOG.md b/CHANGELOG.md index 3b708bd..952ca65 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -3,7 +3,7 @@ ## Unreleased ### Added -- **`ext/linalg` L0–L3**:公式 MatExpr(含分块/`kron`)+ 稠密 `explicit`/`det`/`trace`/`solve`;`collapse` 分块乘;金样 `linalg-formula-smoke` · `linalg-zh-smoke` · `linalg-basic-smoke` · `linalg-block-kron`。设计:[ext-linalg.md](doc/design/ext-linalg.md)。 +- **`ext/linalg` L0–L4**:公式 MatExpr(含分块/`kron`)+ 稠密 `explicit`/`det`/`trace`/`solve`;`collapse` 分块乘;`factorize`(LU/QR/SVD/eig/chol)+ 结构 SVG `draw`;金样 `linalg-formula-smoke` · `linalg-zh-smoke` · `linalg-basic-smoke` · `linalg-block-kron` · `linalg-factor-smoke`。设计:[ext-linalg.md](doc/design/ext-linalg.md)。 ### Fixed diff --git a/doc/design/ext-linalg.md b/doc/design/ext-linalg.md index 5cac46e..e0adae2 100644 --- a/doc/design/ext-linalg.md +++ b/doc/design/ext-linalg.md @@ -2,7 +2,7 @@ | | | |---|---| -| 状态 | **Draft · L0–L3 已落地** | +| 状态 | **Draft · L0–L4 已落地** | | 日期 | 2026-09-07 | | 调研 | [research/ext-linalg-formula.md](../research/ext-linalg-formula.md) | | 路线图 | [roadmap/ext-linalg.md](../roadmap/ext-linalg.md) | diff --git a/doc/roadmap/ext-linalg.md b/doc/roadmap/ext-linalg.md index 5511c55..5cda1ee 100644 --- a/doc/roadmap/ext-linalg.md +++ b/doc/roadmap/ext-linalg.md @@ -2,7 +2,7 @@ | | | |---|---| -| 状态 | **L0–L3 已落地 · L4+ 待做** | +| 状态 | **L0–L4 已落地 · L5+ 待做** | | 日期 | 2026-09-07 | | **锁定设计** | [design/ext-linalg.md](../design/ext-linalg.md) | | 调研 | [research/ext-linalg-formula.md](../research/ext-linalg-formula.md) | @@ -27,7 +27,7 @@ | **L1** | MatExpr:`symbol` / 稠密叶子 / `mul`·`add`·`T`·`inv`;`simplify` R1–R5;`latex`·`ascii`·`show` | **done** | | **L2** | `explicit` / 小阵 gemm·解系·`det`·`trace`;维数护栏;金样 `linalg-basic-smoke` | **done** | | **L3** | `block` + `collapse`;`kron` 惰性 + R7;金样 `linalg-block-kron` | **done** | -| **L4** | `factorize` LU/QR/SVD/eig(+ 可选 chol);结构 SVG `svd|qr|ge|eig`;金样 `linalg-factor-smoke` | **pending** | +| **L4** | `factorize` LU/QR/SVD/eig(+ 可选 chol);结构 SVG `svd|qr|ge|eig`;金样 `linalg-factor-smoke` | **done** | | **L5** | `heatmap`/`hinton`;examples(最小二乘 / SVD 示意);public + skill 摘要 | **pending** | | **L6** | 复数 dtype;`lstsq`;`norm`/`cond`;主题令牌对齐 | **pending** | | **L7+** | 矩阵微积分 / 更大 BLAS 依赖(仅当用户明确要求) | **deferred** | @@ -64,9 +64,9 @@ ### L4 -- [ ] SVD/特征结果对象字段稳定 -- [ ] SVG 含可断言标记(如 `linalg-svd`) -- [ ] `factorize` + 二次 `solve` 复用(若 LU) +- [x] SVD/特征结果对象字段稳定 +- [x] SVG 含可断言标记(如 `data-linalg="eig"`) +- [x] `factorize` + 二次 `solve` 复用(LU) ### L5 diff --git a/ext/linalg/linalg.mq.md b/ext/linalg/linalg.mq.md index 4a5df37..9edc03d 100644 --- a/ext/linalg/linalg.mq.md +++ b/ext/linalg/linalg.mq.md @@ -144,13 +144,14 @@ Evaluate a MatExpr tree of dense/eye/zero ops to `linalg_dense` (symbols rejecte **> linalg_trace expr=`expr`** ## solve - + `a` + + `a`=None + `b` + + `factor`=None -Solve `a x = b` (Gaussian elimination). Returns `linalg_solve`. +Solve `a x = b` (Gaussian elimination), or reuse `factorize kind=lu` via `factor` + `b`. > ensure_plugin -**> linalg_solve a=`a` b=`b`** +**> linalg_solve a=`a` b=`b` factor=`factor`** ## matmul + `a` @@ -186,6 +187,25 @@ Block-level collapse (`Block*Block` → block of products). > ensure_plugin **> linalg_collapse expr=`expr`** +## factorize + + `matrix` + + `kind`="lu" + +Dense factorization → `linalg_factor` (`kind` = `lu` | `qr` | `svd` | `eig` | `chol`). + +> ensure_plugin +**> linalg_factorize matrix=`matrix` kind=`kind`** + +## draw + + `factor` + + `kind`=None + + `path`=None + +Structure SVG for a factor or dense matrix (`eig` | `svd` | `qr` | `lu` | `ge` | `chol` | `structure` | `heatmap` | `hinton`). + +> ensure_plugin +**> linalg_draw factor=`factor` kind=`kind` path=`path`** + ## symbol + `name` + `rows` diff --git a/ext/linalg/线性代数.mq.md b/ext/linalg/线性代数.mq.md index e796bbd..79c3475 100644 --- a/ext/linalg/线性代数.mq.md +++ b/ext/linalg/线性代数.mq.md @@ -138,13 +138,14 @@ import sys:lib/sys.mq.md **> linalg_trace expr=`式`** ## 求解 - + `左` + + `左`=None + `右` + + `分解`=None -解 `左 · x = 右`,返回 `linalg_solve`。 +解 `左 · x = 右`,或复用 `分解`(`kind=lu`)+ `右`。 > 确保插件 -**> linalg_solve a=`左` b=`右`** +**> linalg_solve a=`左` b=`右` factor=`分解`** ## 稠密乘 + `左` @@ -178,6 +179,25 @@ import sys:lib/sys.mq.md > 确保插件 **> linalg_collapse expr=`式`** +## 分解 + + `矩阵` + + `类型`="lu" + +稠密分解 → `linalg_factor`(`类型` = `lu` | `qr` | `svd` | `eig` | `chol`)。 + +> 确保插件 +**> linalg_factorize matrix=`矩阵` kind=`类型`** + +## 绘图 + + `分解` + + `类型`=None + + `路径`=None + +分解/稠密结构 SVG(`eig` | `svd` | `qr` | `lu` | `ge` | `chol` | `structure` | `heatmap` | `hinton`)。 + +> 确保插件 +**> linalg_draw factor=`分解` kind=`类型` path=`路径`** + ## 符号 + `名` + `行` diff --git a/plugins/linalg/src/draw.rs b/plugins/linalg/src/draw.rs new file mode 100644 index 0000000..4c8f9f4 --- /dev/null +++ b/plugins/linalg/src/draw.rs @@ -0,0 +1,235 @@ +//! Structure SVG for factorizations (teaching layouts). + +use serde_json::Value; + +/// Draw a factor object or matrix as structure SVG. +pub fn draw_factor(factor: &Value, kind: Option<&str>, path: Option<&str>) -> Result { + let kind = kind + .or_else(|| factor.get("kind").and_then(|k| k.as_str())) + .unwrap_or("structure"); + let svg = match kind { + "eig" => draw_eig(factor), + "svd" => draw_svd(factor), + "qr" => draw_qr(factor), + "lu" | "ge" => draw_lu(factor), + "chol" => draw_chol(factor), + "structure" => draw_structure(factor), + "heatmap" | "hinton" => draw_heatmap(factor, kind == "hinton"), + other => { + return Err(format!( + "unknown draw kind `{other}` (want eig|svd|qr|lu|ge|chol|structure|heatmap|hinton)" + )) + } + }; + let _ = path; + Ok(svg) +} + +fn escape(s: &str) -> String { + s.replace('&', "&") + .replace('<', "<") + .replace('>', ">") +} + +fn box_svg(x: f64, y: f64, w: f64, h: f64, label: &str, fill: &str) -> String { + format!( + "\ +{}", + x + w / 2.0, + y + h / 2.0, + escape(label) + ) +} + +fn draw_eig(factor: &Value) -> String { + let latex = factor + .get("latex") + .and_then(|x| x.as_str()) + .unwrap_or("A = P D P^{-1}"); + let evals = factor + .get("eigenvalues") + .and_then(|x| x.as_array()) + .map(|a| { + a.iter() + .filter_map(|v| v.as_f64()) + .map(|v| format!("{v:.4}")) + .collect::>() + .join(", ") + }) + .unwrap_or_default(); + format!( + "\ +{}\ +{}\ +{}\ +{}\ +λ = [{}]\ +", + escape(latex), + box_svg(40.0, 48.0, 70.0, 50.0, "P", "#e8f1ff"), + box_svg(130.0, 48.0, 70.0, 50.0, "D", "#fff3d6"), + box_svg(220.0, 48.0, 90.0, 50.0, "P⁻¹", "#e8f1ff"), + escape(&evals) + ) +} + +fn draw_svd(factor: &Value) -> String { + let s = factor + .get("S") + .and_then(|x| x.as_array()) + .map(|a| { + a.iter() + .filter_map(|v| v.as_f64()) + .map(|v| format!("{v:.4}")) + .collect::>() + .join(", ") + }) + .unwrap_or_default(); + format!( + "\ +A = U Σ V⊤\ +{}\ +{}\ +{}\ +σ = [{}]\ +", + box_svg(40.0, 48.0, 70.0, 50.0, "U", "#e8f1ff"), + box_svg(130.0, 48.0, 70.0, 50.0, "Σ", "#fff3d6"), + box_svg(220.0, 48.0, 80.0, 50.0, "V⊤", "#e8f1ff"), + escape(&s) + ) +} + +fn draw_qr(factor: &Value) -> String { + let _ = factor; + format!( + "\ +A = Q R\ +{}\ +{}\ +", + box_svg(40.0, 48.0, 70.0, 50.0, "Q", "#e8f1ff"), + box_svg(130.0, 48.0, 70.0, 50.0, "R", "#ffe8e8"), + ) +} + +fn draw_lu(factor: &Value) -> String { + let _ = factor; + format!( + "\ +A = L U\ +{}\ +{}\ +", + box_svg(40.0, 48.0, 70.0, 50.0, "L", "#e8ffe8"), + box_svg(130.0, 48.0, 70.0, 50.0, "U", "#ffe8e8"), + ) +} + +fn draw_chol(factor: &Value) -> String { + let _ = factor; + format!( + "\ +A = L L⊤\ +{}\ +{}\ +", + box_svg(40.0, 48.0, 70.0, 50.0, "L", "#e8ffe8"), + box_svg(130.0, 48.0, 80.0, 50.0, "L⊤", "#e8ffe8"), + ) +} + +fn draw_structure(factor: &Value) -> String { + let label = if let (Some(r), Some(c)) = (factor.get("rows"), factor.get("cols")) { + format!("{}×{}", r, c) + } else if let Some(Value::Array(a)) = factor.get("shape") { + if a.len() >= 2 { + format!("{}×{}", a[0], a[1]) + } else { + factor + .get("kind") + .and_then(|k| k.as_str()) + .unwrap_or("matrix") + .to_string() + } + } else { + factor + .get("kind") + .and_then(|k| k.as_str()) + .unwrap_or("matrix") + .to_string() + }; + format!( + "\ +{}\ +", + box_svg(40.0, 30.0, 160.0, 60.0, &label, "#f4f4f4") + ) +} + +fn draw_heatmap(factor: &Value, hinton: bool) -> String { + let data = factor + .get("data") + .or_else(|| { + factor + .get("eigenvectors") + .and_then(|v| v.get("data")) + }) + .and_then(|d| d.as_array()); + let Some(rows) = data else { + return draw_structure(factor); + }; + let n = rows.len().min(16); + let m = rows + .first() + .and_then(|r| r.as_array()) + .map(|r| r.len()) + .unwrap_or(0) + .min(16); + if n == 0 || m == 0 { + return draw_structure(factor); + } + let mut max_abs: f64 = 1e-12; + for row in rows.iter().take(n) { + if let Some(cells) = row.as_array() { + for c in cells.iter().take(m) { + if let Some(v) = c.as_f64() { + max_abs = max_abs.max(v.abs()); + } + } + } + } + let cell = 18.0; + let w = 40.0 + m as f64 * cell; + let h = 40.0 + n as f64 * cell; + let mut parts = vec![format!( + "", + if hinton { "hinton" } else { "heatmap" } + )]; + for (i, row) in rows.iter().take(n).enumerate() { + let Some(cells) = row.as_array() else { continue }; + for (j, c) in cells.iter().take(m).enumerate() { + let v = c.as_f64().unwrap_or(0.0); + let x = 20.0 + j as f64 * cell; + let y = 20.0 + i as f64 * cell; + if hinton { + let s = (v.abs() / max_abs).sqrt() * (cell - 4.0); + let fill = if v >= 0.0 { "#2266aa" } else { "#cc3333" }; + parts.push(format!( + "", + x + (cell - s) / 2.0, + y + (cell - s) / 2.0 + )); + } else { + let t = ((v / max_abs) + 1.0) * 0.5; + let r = (255.0 * (1.0 - t)) as u8; + let b = (255.0 * t) as u8; + parts.push(format!( + "" + )); + } + } + } + parts.push("".into()); + parts.join("") +} diff --git a/plugins/linalg/src/factor.rs b/plugins/linalg/src/factor.rs new file mode 100644 index 0000000..2e41109 --- /dev/null +++ b/plugins/linalg/src/factor.rs @@ -0,0 +1,447 @@ +//! 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(()) +} + +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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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), String> { + let (n, _) = dense::shape(a)?; + let mut m = a.clone(); + let mut piv: Vec = (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, 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, 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 { + 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 { + 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); + } +} diff --git a/plugins/linalg/src/lib.rs b/plugins/linalg/src/lib.rs index d544a8d..337e711 100644 --- a/plugins/linalg/src/lib.rs +++ b/plugins/linalg/src/lib.rs @@ -1,6 +1,8 @@ //! Marqdo linalg plugin (C ABI v2): formula-first matrix expressions. mod dense; +mod draw; +mod factor; mod matexpr; use std::ffi::{CStr, CString}; @@ -206,7 +208,16 @@ la_ffi!(linalg_ping, |_args: &Value| { "ok": true, "name": "linalg", "abi": ABI_VERSION, - "features": ["matexpr", "simplify", "dense", "solve", "block", "kron"], + "features": [ + "matexpr", + "simplify", + "dense", + "solve", + "block", + "kron", + "factorize", + "draw", + ], })) }); @@ -380,8 +391,22 @@ la_ffi!(linalg_trace, |args: &Value| { }); la_ffi!(linalg_solve, |args: &Value| { - let a = dense_arg(args, &["a", "A", "matrix", "矩阵", "左"])?; let b = dense_arg(args, &["b", "B", "rhs", "右"])?; + if let Some(f) = args + .get("factor") + .or_else(|| args.get("分解")) + .filter(|v| !v.is_null()) + { + let x = factor::solve_lu_factor(f, &b)?; + return dense::to_dense_value(&x).map(|xv| { + json!({ + "_type": "linalg_solve", + "method": "lu", + "x": xv, + }) + }); + } + let a = dense_arg(args, &["a", "A", "matrix", "矩阵", "左"])?; dense::solve_result(&a, &b) }); @@ -424,6 +449,45 @@ la_ffi!(linalg_collapse, |args: &Value| { wrap(matexpr::collapse(e)?) }); +la_ffi!(linalg_factorize, |args: &Value| { + let m = dense_arg(args, &["matrix", "expr", "a", "矩阵", "式"])?; + let kind = args + .get("kind") + .or_else(|| args.get("类型")) + .and_then(|x| x.as_str()) + .unwrap_or("lu"); + factor::factorize(&m, kind) +}); + +la_ffi!(linalg_draw, |args: &Value| { + let factor_v = args + .get("factor") + .or_else(|| args.get("分解")) + .or_else(|| args.get("expr")) + .or_else(|| args.get("matrix")) + .or_else(|| args.get("式")) + .or_else(|| args.get("矩阵")) + .ok_or_else(|| "missing `factor`".to_string())?; + let kind = args + .get("kind") + .or_else(|| args.get("类型")) + .and_then(|x| x.as_str()); + let path = args + .get("path") + .or_else(|| args.get("路径")) + .and_then(|x| x.as_str()) + .filter(|s| !s.is_empty()); + let svg = draw::draw_factor(factor_v, kind, path)?; + let _ = record_plot(&svg, path); + Ok(json!({ + "_type": "linalg_svg", + "kind": kind + .or_else(|| factor_v.get("kind").and_then(|k| k.as_str())) + .unwrap_or("structure"), + "svg": svg, + })) +}); + fn dense_arg(args: &Value, keys: &[&str]) -> Result { for k in keys { if let Some(v) = args.get(*k) { @@ -481,11 +545,13 @@ pub unsafe extern "C" fn marqdo_plugin_init(host: *const MarqdoHostApi) -> c_int ("linalg_explicit", "expr", linalg_explicit as PluginFn), ("linalg_det", "expr", linalg_det as PluginFn), ("linalg_trace", "expr", linalg_trace as PluginFn), - ("linalg_solve", "a,b", linalg_solve as PluginFn), + ("linalg_solve", "a,b,factor", linalg_solve as PluginFn), ("linalg_matmul", "a,b", linalg_matmul as PluginFn), ("linalg_kron", "a,b", linalg_kron as PluginFn), ("linalg_block", "blocks", linalg_block as PluginFn), ("linalg_collapse", "expr", linalg_collapse as PluginFn), + ("linalg_factorize", "matrix,kind", linalg_factorize as PluginFn), + ("linalg_draw", "factor,kind,path", linalg_draw as PluginFn), ]; for (name, params, f) in regs { let c_name = CString::new(name).unwrap(); diff --git a/tests/ext/linalg-factor-smoke.mq.md b/tests/ext/linalg-factor-smoke.mq.md new file mode 100644 index 0000000..e4559a8 --- /dev/null +++ b/tests/ext/linalg-factor-smoke.mq.md @@ -0,0 +1,79 @@ +--- +title: linalg factor smoke (L4) +description: eig factorize, structure SVG, LU reuse solve. +import la:ext/linalg/linalg.mq.md +import math:lib/math.mq.md +--- + +# main + +`M` = +$$ +\begin{bmatrix}2&0\\0&3\end{bmatrix} +$$ + +*`M` = > la.from_formula formula=`M`* +*`eps` = > math.div a=1 b=1000* + +*`f` = > la.factorize matrix=`M` kind="eig"* +*`kind` = f[^kind]* +1. `kind` == eig + > print text=eig-kind-ok +2. * + > print text=eig-kind-fail + +*`evals` = f[^eigenvalues]* +*`ev0` = > at value=`evals` index=0* +*`e0` = > math.sub a=`ev0` b=3* +*`e0` = > math.abs value=`e0`* +1. `e0` < `eps` + > print text=eig-val-ok +2. * + > print text=eig-val-fail + +*`img` = > la.draw factor=`f` kind="eig" path="linalg-factor-eig.svg"* +*`ik` = img[^kind]* +1. `ik` == eig + > print text=draw-kind-ok +2. * + > print text=draw-kind-fail + +*`svg` = img[^svg]* +*`parts` = > split value=`svg` sep="data-linalg=\"eig\""* +*`pn` = > len value=`parts`* +1. `pn` > 1 + > print text=draw-mark-ok +2. * + > print text=draw-mark-fail + +`A` = +$$ +\begin{bmatrix}2&1\\1&3\end{bmatrix} +$$ + +`b` = +$$ +\begin{pmatrix}5\\5\end{pmatrix} +$$ + +*`A` = > la.from_formula formula=`A`* +*`b` = > la.from_formula formula=`b`* +*`lu` = > la.factorize matrix=`A` kind="lu"* +*`sol` = > la.solve factor=`lu` b=`b`* +*`x` = sol[^x]* +*`data` = x[^data]* +*`row0` = > at value=`data` index=0* +*`x0` = > at value=`row0` index=0* +*`xe` = > math.sub a=`x0` b=2* +*`xe` = > math.abs value=`xe`* +1. `xe` < `eps` + > print text=lu-solve-ok +2. * + > print text=lu-solve-fail + +*`svd` = > la.factorize matrix=`M` kind="svd"* +*`sk` = svd[^ascii]* +1. `sk` == SVD + > print text=svd-ok +2. * + > print text=svd-fail diff --git a/tests/gold.rs b/tests/gold.rs index 41986a7..9d25e4a 100644 --- a/tests/gold.rs +++ b/tests/gold.rs @@ -2464,6 +2464,25 @@ txn-rollback-ok", ); } +#[test] +fn ext_linalg_factor_smoke() { + let status = Command::new("cargo") + .args(["build", "-p", "marqdo_plugin_linalg"]) + .current_dir(env!("CARGO_MANIFEST_DIR")) + .status() + .expect("build linalg plugin"); + assert!(status.success(), "failed to build marqdo_plugin_linalg"); + assert_out( + "tests/ext/linalg-factor-smoke.mq.md", + "eig-kind-ok\neig-val-ok\ndraw-kind-ok\ndraw-mark-ok\nlu-solve-ok\nsvd-ok", + ); + let svg = std::fs::read_to_string("tests/ext/linalg-factor-eig.svg").unwrap_or_default(); + assert!( + svg.contains("