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 <cursoragent@cursor.com>
This commit is contained in:
cflmyandCursor committed 2026-09-07 14:31:44 +08:00
1 parent b6f116108c
commit 70fb2fbfb2
11 files changed
+903 -16

No files matched your search

+1
View File
@@ -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
+1 -1
View File
@@ -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
+1 -1
View File
@@ -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) |
+5 -5
View File
@@ -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
+23 -3
View File
@@ -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`
+23 -3
View File
@@ -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=`路径`**
## 符号
+ `名`
+ `行`
+235
View File
@@ -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<String, String> {
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('&', "&amp;")
.replace('<', "&lt;")
.replace('>', "&gt;")
}
fn box_svg(x: f64, y: f64, w: f64, h: f64, label: &str, fill: &str) -> String {
format!(
"<rect x=\"{x}\" y=\"{y}\" width=\"{w}\" height=\"{h}\" fill=\"{fill}\" stroke=\"#333\" stroke-width=\"1.5\" rx=\"4\"/>\
<text x=\"{}\" y=\"{}\" text-anchor=\"middle\" dominant-baseline=\"middle\" font-size=\"16\" font-family=\"serif\">{}</text>",
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::<Vec<_>>()
.join(", ")
})
.unwrap_or_default();
format!(
"<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"520\" height=\"140\" data-linalg=\"eig\">\
<text x=\"16\" y=\"28\" font-size=\"18\" font-family=\"serif\">{}</text>\
{}\
{}\
{}\
<text x=\"16\" y=\"120\" font-size=\"13\" font-family=\"sans-serif\" fill=\"#444\">λ = [{}]</text>\
</svg>",
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::<Vec<_>>()
.join(", ")
})
.unwrap_or_default();
format!(
"<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"560\" height=\"140\" data-linalg=\"svd\">\
<text x=\"16\" y=\"28\" font-size=\"18\" font-family=\"serif\">A = U Σ V⊤</text>\
{}\
{}\
{}\
<text x=\"16\" y=\"120\" font-size=\"13\" font-family=\"sans-serif\" fill=\"#444\">σ = [{}]</text>\
</svg>",
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!(
"<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"420\" height=\"120\" data-linalg=\"qr\">\
<text x=\"16\" y=\"28\" font-size=\"18\" font-family=\"serif\">A = Q R</text>\
{}\
{}\
</svg>",
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!(
"<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"420\" height=\"120\" data-linalg=\"lu\">\
<text x=\"16\" y=\"28\" font-size=\"18\" font-family=\"serif\">A = L U</text>\
{}\
{}\
</svg>",
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!(
"<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"420\" height=\"120\" data-linalg=\"chol\">\
<text x=\"16\" y=\"28\" font-size=\"18\" font-family=\"serif\">A = L L⊤</text>\
{}\
{}\
</svg>",
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!(
"<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"280\" height=\"120\" data-linalg=\"structure\">\
{}\
</svg>",
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!(
"<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"{w}\" height=\"{h}\" data-linalg=\"{}\">",
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!(
"<rect x=\"{}\" y=\"{}\" width=\"{s}\" height=\"{s}\" fill=\"{fill}\"/>",
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!(
"<rect x=\"{x}\" y=\"{y}\" width=\"{cell}\" height=\"{cell}\" fill=\"rgb({r},80,{b})\" stroke=\"#fff\" stroke-width=\"0.5\"/>"
));
}
}
}
parts.push("</svg>".into());
parts.join("")
}
+447
View File
@@ -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<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);
}
}
+69 -3
View File
@@ -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<dense::Mat, String> {
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();
+79
View File
@@ -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
+19
View File
@@ -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("<svg") && svg.contains(r#"data-linalg="eig""#),
"expected eig structure svg"
);
}
#[test]
fn ext_linalg_block_kron() {
let status = Command::new("cargo")