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:
1 parent
b6f116108c
commit
70fb2fbfb2
11 files changed
+903
-16
No files matched your search
@@ -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
@@ -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
|
||||
|
||||
|
||||
@@ -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) |
|
||||
|
||||
@@ -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
@@ -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
@@ -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=`路径`**
|
||||
|
||||
## 符号
|
||||
+ `名`
|
||||
+ `行`
|
||||
|
||||
@@ -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('&', "&")
|
||||
.replace('<', "<")
|
||||
.replace('>', ">")
|
||||
}
|
||||
|
||||
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("")
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -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();
|
||||
|
||||
@@ -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
|
||||
@@ -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")
|
||||
|
||||
Reference in new issue
Block a user