feat(linalg): L2 dense explicit, det, trace, and solve
Add dense kernels with element limits, from_formula for $$ matrices, and linalg-basic-smoke covering 2×2 det/trace/solve/explicit. Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
1 parent
96da88e168
commit
03aca7cdac
9 files changed
+742
-8
No files matched your search
+1
-1
@@ -3,7 +3,7 @@
|
||||
## Unreleased
|
||||
|
||||
### Added
|
||||
- **`ext/linalg` L0–L1(公式优先)**:`MatrixSymbol` / 乘加转置逆、R1–R5 `simplify`、`ascii`/`latex`/`show`;`marqdo ext add linalg`;金样 `linalg-formula-smoke` · `linalg-zh-smoke`。设计:[ext-linalg.md](doc/design/ext-linalg.md)。
|
||||
- **`ext/linalg` L0–L2**:公式 MatExpr(R1–R5)+ 稠密 `explicit`/`det`/`trace`/`solve`/`from_formula`;`marqdo ext add linalg`;金样 `linalg-formula-smoke` · `linalg-zh-smoke` · `linalg-basic-smoke`。设计:[ext-linalg.md](doc/design/ext-linalg.md)。
|
||||
|
||||
### Fixed
|
||||
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
|
||||
| | |
|
||||
|---|---|
|
||||
| 状态 | **Draft · L0–L1 已落地** |
|
||||
| 状态 | **Draft · L0–L2 已落地** |
|
||||
| 日期 | 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–L1 已落地 · L2+ 待做** |
|
||||
| 状态 | **L0–L2 已落地 · L3+ 待做** |
|
||||
| 日期 | 2026-09-07 |
|
||||
| **锁定设计** | [design/ext-linalg.md](../design/ext-linalg.md) |
|
||||
| 调研 | [research/ext-linalg-formula.md](../research/ext-linalg-formula.md) |
|
||||
@@ -25,7 +25,7 @@
|
||||
|------|------|------|
|
||||
| **L0** | CATALOG + `plugins/linalg` ping + L1 `ensure_plugin`;`ext add` 条目 | **done** |
|
||||
| **L1** | MatExpr:`symbol` / 稠密叶子 / `mul`·`add`·`T`·`inv`;`simplify` R1–R5;`latex`·`ascii`·`show` | **done** |
|
||||
| **L2** | `explicit` / 小阵 gemm·解系·`det`·`trace`;维数护栏;金样 `linalg-basic-smoke` | **pending** |
|
||||
| **L2** | `explicit` / 小阵 gemm·解系·`det`·`trace`;维数护栏;金样 `linalg-basic-smoke` | **done** |
|
||||
| **L3** | `block` + `collapse`;`kron` 惰性 + R7;金样 `linalg-block-kron` | **pending** |
|
||||
| **L4** | `factorize` LU/QR/SVD/eig(+ 可选 chol);结构 SVG `svd|qr|ge|eig`;金样 `linalg-factor-smoke` | **pending** |
|
||||
| **L5** | `heatmap`/`hinton`;examples(最小二乘 / SVD 示意);public + skill 摘要 | **pending** |
|
||||
@@ -53,9 +53,9 @@
|
||||
|
||||
### L2
|
||||
|
||||
- [ ] `from_formula` 吸收 `$$` 数值阵
|
||||
- [ ] `solve` 与手算 2×2 一致
|
||||
- [ ] 超维 `explicit` 硬错误
|
||||
- [x] `from_formula` 吸收 `$$` 数值阵
|
||||
- [x] `solve` 与手算 2×2 一致
|
||||
- [x] 超维 `explicit` 硬错误(单元测护栏)
|
||||
|
||||
### L3
|
||||
|
||||
|
||||
@@ -115,6 +115,52 @@ Dense leaf from nested list.
|
||||
> ensure_plugin
|
||||
**> linalg_from_list data=`data`**
|
||||
|
||||
## from_formula
|
||||
+ `formula`
|
||||
|
||||
Absorb a `$$` numeric matrix formula (or nested list / dense map) as a dense leaf.
|
||||
|
||||
> ensure_plugin
|
||||
**> linalg_from_formula formula=`formula`**
|
||||
|
||||
## explicit
|
||||
+ `expr`
|
||||
|
||||
Evaluate a MatExpr tree of dense/eye/zero ops to `linalg_dense` (symbols rejected).
|
||||
|
||||
> ensure_plugin
|
||||
**> linalg_explicit expr=`expr`**
|
||||
|
||||
## det
|
||||
+ `expr`
|
||||
|
||||
> ensure_plugin
|
||||
**> linalg_det expr=`expr`**
|
||||
|
||||
## trace
|
||||
+ `expr`
|
||||
|
||||
> ensure_plugin
|
||||
**> linalg_trace expr=`expr`**
|
||||
|
||||
## solve
|
||||
+ `a`
|
||||
+ `b`
|
||||
|
||||
Solve `a x = b` (Gaussian elimination). Returns `linalg_solve`.
|
||||
|
||||
> ensure_plugin
|
||||
**> linalg_solve a=`a` b=`b`**
|
||||
|
||||
## matmul
|
||||
+ `a`
|
||||
+ `b`
|
||||
|
||||
Dense matrix product → `linalg_dense`.
|
||||
|
||||
> ensure_plugin
|
||||
**> linalg_matmul a=`a` b=`b`**
|
||||
|
||||
## symbol
|
||||
+ `name`
|
||||
+ `rows`
|
||||
|
||||
@@ -109,6 +109,50 @@ import sys:lib/sys.mq.md
|
||||
> 确保插件
|
||||
**> linalg_from_list data=`数据`**
|
||||
|
||||
## 自公式
|
||||
+ `公式`
|
||||
|
||||
吸收 `$$` 数值矩阵公式为稠密叶。
|
||||
|
||||
> 确保插件
|
||||
**> linalg_from_formula formula=`公式`**
|
||||
|
||||
## 求值
|
||||
+ `式`
|
||||
|
||||
将仅含稠密/单位/零阵运算的表达式求成 `linalg_dense`。
|
||||
|
||||
> 确保插件
|
||||
**> linalg_explicit expr=`式`**
|
||||
|
||||
## 行列式
|
||||
+ `式`
|
||||
|
||||
> 确保插件
|
||||
**> linalg_det expr=`式`**
|
||||
|
||||
## 迹
|
||||
+ `式`
|
||||
|
||||
> 确保插件
|
||||
**> linalg_trace expr=`式`**
|
||||
|
||||
## 求解
|
||||
+ `左`
|
||||
+ `右`
|
||||
|
||||
解 `左 · x = 右`,返回 `linalg_solve`。
|
||||
|
||||
> 确保插件
|
||||
**> linalg_solve a=`左` b=`右`**
|
||||
|
||||
## 稠密乘
|
||||
+ `左`
|
||||
+ `右`
|
||||
|
||||
> 确保插件
|
||||
**> linalg_matmul a=`左` b=`右`**
|
||||
|
||||
## 符号
|
||||
+ `名`
|
||||
+ `行`
|
||||
|
||||
@@ -0,0 +1,492 @@
|
||||
//! Dense real matrix kernels for L2 (`explicit` / solve / det / trace).
|
||||
|
||||
use serde_json::{json, Value};
|
||||
|
||||
use crate::matexpr::{Dim, Expr};
|
||||
|
||||
/// Max elements for `explicit` / dense ops (design default 10^4).
|
||||
pub const MAX_ELEMENTS: usize = 10_000;
|
||||
|
||||
pub type Mat = Vec<Vec<f64>>;
|
||||
|
||||
pub fn check_elems(rows: usize, cols: usize) -> Result<(), String> {
|
||||
let n = rows.saturating_mul(cols);
|
||||
if n > MAX_ELEMENTS {
|
||||
return Err(format!(
|
||||
"dense matrix {rows}×{cols} has {n} elements > limit {MAX_ELEMENTS}; keep symbolic or reduce size"
|
||||
));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn eye(n: usize) -> Mat {
|
||||
let mut m = vec![vec![0.0; n]; n];
|
||||
for i in 0..n {
|
||||
m[i][i] = 1.0;
|
||||
}
|
||||
m
|
||||
}
|
||||
|
||||
pub fn zeros(rows: usize, cols: usize) -> Mat {
|
||||
vec![vec![0.0; cols]; rows]
|
||||
}
|
||||
|
||||
pub fn shape(m: &Mat) -> Result<(usize, usize), String> {
|
||||
if m.is_empty() {
|
||||
return Err("empty dense matrix".into());
|
||||
}
|
||||
let r = m.len();
|
||||
let c = m[0].len();
|
||||
if c == 0 || m.iter().any(|row| row.len() != c) {
|
||||
return Err("dense matrix rows must have equal non-zero length".into());
|
||||
}
|
||||
Ok((r, c))
|
||||
}
|
||||
|
||||
pub fn to_dense_value(m: &Mat) -> Result<Value, String> {
|
||||
let (rows, cols) = shape(m)?;
|
||||
check_elems(rows, cols)?;
|
||||
Ok(json!({
|
||||
"_type": "linalg_dense",
|
||||
"rows": rows,
|
||||
"cols": cols,
|
||||
"data": m,
|
||||
"dtype": "real",
|
||||
"ascii": format_ascii(m),
|
||||
"latex": format_latex(m),
|
||||
}))
|
||||
}
|
||||
|
||||
fn format_ascii(m: &Mat) -> String {
|
||||
let rows: Vec<String> = m
|
||||
.iter()
|
||||
.map(|row| {
|
||||
let cells: Vec<String> = row.iter().map(|x| format_num(*x)).collect();
|
||||
format!("[{}]", cells.join(","))
|
||||
})
|
||||
.collect();
|
||||
format!("[{}]", rows.join(","))
|
||||
}
|
||||
|
||||
fn format_latex(m: &Mat) -> String {
|
||||
let body: Vec<String> = m
|
||||
.iter()
|
||||
.map(|row| {
|
||||
row.iter()
|
||||
.map(|x| format_num(*x))
|
||||
.collect::<Vec<_>>()
|
||||
.join(" & ")
|
||||
})
|
||||
.collect();
|
||||
format!(
|
||||
"\\begin{{bmatrix}}{}\\end{{bmatrix}}",
|
||||
body.join(" \\\\ ")
|
||||
)
|
||||
}
|
||||
|
||||
fn format_num(n: f64) -> String {
|
||||
if n.fract() == 0.0 && n.abs() < 1e15 {
|
||||
format!("{}", n as i64)
|
||||
} else {
|
||||
format!("{n}")
|
||||
}
|
||||
}
|
||||
|
||||
pub fn from_value(v: &Value) -> Result<Mat, String> {
|
||||
if let Some(obj) = v.as_object() {
|
||||
if let Some(data) = obj.get("data") {
|
||||
return parse_data(data);
|
||||
}
|
||||
// linalg_expr kind=dense
|
||||
if obj.get("kind").and_then(|k| k.as_str()) == Some("dense") {
|
||||
if let Some(data) = obj.get("data") {
|
||||
return parse_data(data);
|
||||
}
|
||||
}
|
||||
}
|
||||
// Formula Matrix / raw nested list
|
||||
if v.is_array() {
|
||||
return parse_data(v);
|
||||
}
|
||||
Err("expected linalg_dense, dense expr, or nested list".into())
|
||||
}
|
||||
|
||||
fn parse_data(v: &Value) -> Result<Mat, String> {
|
||||
let rows = v
|
||||
.as_array()
|
||||
.ok_or_else(|| "dense data must be list of rows".to_string())?;
|
||||
let mut out = Vec::new();
|
||||
let mut width = None;
|
||||
for row in rows {
|
||||
let cells = row
|
||||
.as_array()
|
||||
.ok_or_else(|| "dense row must be a list".to_string())?;
|
||||
let mut r = Vec::new();
|
||||
for c in cells {
|
||||
let n = c
|
||||
.as_f64()
|
||||
.or_else(|| c.as_i64().map(|i| i as f64))
|
||||
.or_else(|| c.as_u64().map(|u| u as f64))
|
||||
.or_else(|| c.as_str().and_then(|s| s.trim().parse().ok()))
|
||||
.ok_or_else(|| "dense cell must be a number".to_string())?;
|
||||
r.push(n);
|
||||
}
|
||||
if let Some(w) = width {
|
||||
if r.len() != w {
|
||||
return Err("dense matrix rows must have equal length".into());
|
||||
}
|
||||
} else {
|
||||
width = Some(r.len());
|
||||
}
|
||||
out.push(r);
|
||||
}
|
||||
let (rows, cols) = shape(&out)?;
|
||||
check_elems(rows, cols)?;
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
fn dim_usize(d: &Dim) -> Result<usize, String> {
|
||||
match d {
|
||||
Dim::Int(n) => Ok(*n),
|
||||
Dim::Sym(s) => Err(format!(
|
||||
"cannot explicit symbolic dim `{s}`; bind concrete sizes or use dense leaves only"
|
||||
)),
|
||||
}
|
||||
}
|
||||
|
||||
/// Evaluate MatExpr to dense; symbols are not allowed unless already dense leaves.
|
||||
pub fn explicit(expr: &Expr) -> Result<Mat, String> {
|
||||
match expr {
|
||||
Expr::Dense { data } => {
|
||||
let (r, c) = shape(data)?;
|
||||
check_elems(r, c)?;
|
||||
Ok(data.clone())
|
||||
}
|
||||
Expr::Eye { n } => {
|
||||
let n = dim_usize(n)?;
|
||||
check_elems(n, n)?;
|
||||
Ok(eye(n))
|
||||
}
|
||||
Expr::Zero { rows, cols } => {
|
||||
let r = dim_usize(rows)?;
|
||||
let c = dim_usize(cols)?;
|
||||
check_elems(r, c)?;
|
||||
Ok(zeros(r, c))
|
||||
}
|
||||
Expr::Symbol { name, .. } => Err(format!(
|
||||
"cannot explicit unbound symbol `{name}`; substitute a dense matrix first"
|
||||
)),
|
||||
Expr::Mul { factors } => {
|
||||
if factors.is_empty() {
|
||||
return Err("empty MatMul".into());
|
||||
}
|
||||
let mut acc = explicit(&factors[0])?;
|
||||
for f in &factors[1..] {
|
||||
acc = matmul(&acc, &explicit(f)?)?;
|
||||
}
|
||||
Ok(acc)
|
||||
}
|
||||
Expr::Add { terms } => {
|
||||
if terms.is_empty() {
|
||||
return Err("empty MatAdd".into());
|
||||
}
|
||||
let mut acc = explicit(&terms[0])?;
|
||||
for t in &terms[1..] {
|
||||
acc = mat_add(&acc, &explicit(t)?)?;
|
||||
}
|
||||
Ok(acc)
|
||||
}
|
||||
Expr::Sub { left, right } => mat_sub(&explicit(left)?, &explicit(right)?),
|
||||
Expr::Transpose { arg } => Ok(transpose(&explicit(arg)?)),
|
||||
Expr::Inv { arg } => invert(&explicit(arg)?),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn matmul(a: &Mat, b: &Mat) -> Result<Mat, String> {
|
||||
let (ar, ac) = shape(a)?;
|
||||
let (br, bc) = shape(b)?;
|
||||
if ac != br {
|
||||
return Err(format!(
|
||||
"matmul shape mismatch: {ar}×{ac} · {br}×{bc}"
|
||||
));
|
||||
}
|
||||
check_elems(ar, bc)?;
|
||||
let mut out = zeros(ar, bc);
|
||||
for i in 0..ar {
|
||||
for k in 0..ac {
|
||||
let aik = a[i][k];
|
||||
if aik == 0.0 {
|
||||
continue;
|
||||
}
|
||||
for j in 0..bc {
|
||||
out[i][j] += aik * b[k][j];
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
pub fn mat_add(a: &Mat, b: &Mat) -> Result<Mat, String> {
|
||||
let (ar, ac) = shape(a)?;
|
||||
let (br, bc) = shape(b)?;
|
||||
if ar != br || ac != bc {
|
||||
return Err(format!("add shape mismatch: {ar}×{ac} vs {br}×{bc}"));
|
||||
}
|
||||
let mut out = zeros(ar, ac);
|
||||
for i in 0..ar {
|
||||
for j in 0..ac {
|
||||
out[i][j] = a[i][j] + b[i][j];
|
||||
}
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
pub fn mat_sub(a: &Mat, b: &Mat) -> Result<Mat, String> {
|
||||
let (ar, ac) = shape(a)?;
|
||||
let (br, bc) = shape(b)?;
|
||||
if ar != br || ac != bc {
|
||||
return Err(format!("sub shape mismatch: {ar}×{ac} vs {br}×{bc}"));
|
||||
}
|
||||
let mut out = zeros(ar, ac);
|
||||
for i in 0..ar {
|
||||
for j in 0..ac {
|
||||
out[i][j] = a[i][j] - b[i][j];
|
||||
}
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
pub fn transpose(m: &Mat) -> Mat {
|
||||
let (r, c) = shape(m).unwrap_or((0, 0));
|
||||
let mut out = zeros(c, r);
|
||||
for i in 0..r {
|
||||
for j in 0..c {
|
||||
out[j][i] = m[i][j];
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
pub fn trace(m: &Mat) -> Result<f64, String> {
|
||||
let (r, c) = shape(m)?;
|
||||
if r != c {
|
||||
return Err(format!("trace needs square matrix, got {r}×{c}"));
|
||||
}
|
||||
Ok((0..r).map(|i| m[i][i]).sum())
|
||||
}
|
||||
|
||||
pub fn det(m: &Mat) -> Result<f64, String> {
|
||||
let (n, c) = shape(m)?;
|
||||
if n != c {
|
||||
return Err(format!("det needs square matrix, got {n}×{c}"));
|
||||
}
|
||||
if n == 0 {
|
||||
return Ok(1.0);
|
||||
}
|
||||
if n == 1 {
|
||||
return Ok(m[0][0]);
|
||||
}
|
||||
if n == 2 {
|
||||
return Ok(m[0][0] * m[1][1] - m[0][1] * m[1][0]);
|
||||
}
|
||||
// Gaussian elimination with partial pivoting
|
||||
let mut a = m.clone();
|
||||
let mut det = 1.0;
|
||||
for k in 0..n {
|
||||
let mut piv = k;
|
||||
let mut best = a[k][k].abs();
|
||||
for i in (k + 1)..n {
|
||||
let v = a[i][k].abs();
|
||||
if v > best {
|
||||
best = v;
|
||||
piv = i;
|
||||
}
|
||||
}
|
||||
if best < 1e-15 {
|
||||
return Ok(0.0);
|
||||
}
|
||||
if piv != k {
|
||||
a.swap(k, piv);
|
||||
det = -det;
|
||||
}
|
||||
let akk = a[k][k];
|
||||
det *= akk;
|
||||
for i in (k + 1)..n {
|
||||
let f = a[i][k] / akk;
|
||||
for j in k..n {
|
||||
a[i][j] -= f * a[k][j];
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(det)
|
||||
}
|
||||
|
||||
pub fn invert(m: &Mat) -> Result<Mat, String> {
|
||||
let (n, c) = shape(m)?;
|
||||
if n != c {
|
||||
return Err(format!("inverse needs square matrix, got {n}×{c}"));
|
||||
}
|
||||
check_elems(n, n)?;
|
||||
// Augment [A|I]
|
||||
let mut a = zeros(n, 2 * n);
|
||||
for i in 0..n {
|
||||
for j in 0..n {
|
||||
a[i][j] = m[i][j];
|
||||
}
|
||||
a[i][n + i] = 1.0;
|
||||
}
|
||||
for k in 0..n {
|
||||
let mut piv = k;
|
||||
let mut best = a[k][k].abs();
|
||||
for i in (k + 1)..n {
|
||||
let v = a[i][k].abs();
|
||||
if v > best {
|
||||
best = v;
|
||||
piv = i;
|
||||
}
|
||||
}
|
||||
if best < 1e-15 {
|
||||
return Err("matrix is singular (not invertible)".into());
|
||||
}
|
||||
if piv != k {
|
||||
a.swap(k, piv);
|
||||
}
|
||||
let akk = a[k][k];
|
||||
for j in 0..(2 * n) {
|
||||
a[k][j] /= akk;
|
||||
}
|
||||
for i in 0..n {
|
||||
if i == k {
|
||||
continue;
|
||||
}
|
||||
let f = a[i][k];
|
||||
for j in 0..(2 * n) {
|
||||
a[i][j] -= f * a[k][j];
|
||||
}
|
||||
}
|
||||
}
|
||||
let mut out = zeros(n, n);
|
||||
for i in 0..n {
|
||||
for j in 0..n {
|
||||
out[i][j] = a[i][n + j];
|
||||
}
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
/// Solve A x = b. `b` may be n×1 or n×k; returns n×k.
|
||||
pub fn solve(a: &Mat, b: &Mat) -> Result<Mat, String> {
|
||||
let (n, ac) = shape(a)?;
|
||||
if n != ac {
|
||||
return Err(format!("solve needs square A, got {n}×{ac}"));
|
||||
}
|
||||
let (br, bc) = shape(b)?;
|
||||
if br != n {
|
||||
return Err(format!("solve rhs rows {br} != A rows {n}"));
|
||||
}
|
||||
// Augment [A|B]
|
||||
let mut m = zeros(n, n + bc);
|
||||
for i in 0..n {
|
||||
for j in 0..n {
|
||||
m[i][j] = a[i][j];
|
||||
}
|
||||
for j in 0..bc {
|
||||
m[i][n + j] = b[i][j];
|
||||
}
|
||||
}
|
||||
for k in 0..n {
|
||||
let mut piv = 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 = i;
|
||||
}
|
||||
}
|
||||
if best < 1e-15 {
|
||||
return Err("singular matrix in solve".into());
|
||||
}
|
||||
if piv != k {
|
||||
m.swap(k, piv);
|
||||
}
|
||||
let akk = m[k][k];
|
||||
for j in k..(n + bc) {
|
||||
m[k][j] /= akk;
|
||||
}
|
||||
for i in 0..n {
|
||||
if i == k {
|
||||
continue;
|
||||
}
|
||||
let f = m[i][k];
|
||||
for j in k..(n + bc) {
|
||||
m[i][j] -= f * m[k][j];
|
||||
}
|
||||
}
|
||||
}
|
||||
let mut x = zeros(n, bc);
|
||||
for i in 0..n {
|
||||
for j in 0..bc {
|
||||
x[i][j] = m[i][n + j];
|
||||
}
|
||||
}
|
||||
Ok(x)
|
||||
}
|
||||
|
||||
pub fn solve_result(a: &Mat, b: &Mat) -> Result<Value, String> {
|
||||
let x = solve(a, b)?;
|
||||
let ax = matmul(a, &x)?;
|
||||
let resid = mat_sub(&ax, b)?;
|
||||
let mut max_r = 0.0_f64;
|
||||
for row in &resid {
|
||||
for &v in row {
|
||||
max_r = max_r.max(v.abs());
|
||||
}
|
||||
}
|
||||
Ok(json!({
|
||||
"_type": "linalg_solve",
|
||||
"method": "gauss",
|
||||
"x": to_dense_value(&x)?,
|
||||
"residual_max": max_r,
|
||||
}))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn solve_2x2() {
|
||||
let a = vec![vec![2.0, 1.0], vec![1.0, 3.0]];
|
||||
let b = vec![vec![5.0], vec![5.0]];
|
||||
let x = solve(&a, &b).unwrap();
|
||||
assert!((x[0][0] - 2.0).abs() < 1e-9);
|
||||
assert!((x[1][0] - 1.0).abs() < 1e-9);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn det_2x2() {
|
||||
let m = vec![vec![1.0, 2.0], vec![3.0, 4.0]];
|
||||
assert!((det(&m).unwrap() + 2.0).abs() < 1e-9);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn explicit_mul() {
|
||||
let a = Expr::Dense {
|
||||
data: vec![vec![1.0, 2.0], vec![0.0, 1.0]],
|
||||
};
|
||||
let b = Expr::Dense {
|
||||
data: vec![vec![1.0, 0.0], vec![1.0, 1.0]],
|
||||
};
|
||||
let p = Expr::Mul {
|
||||
factors: vec![a, b],
|
||||
};
|
||||
let m = explicit(&p).unwrap();
|
||||
assert_eq!(m, vec![vec![3.0, 2.0], vec![1.0, 1.0]]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn oversize_guard() {
|
||||
assert!(check_elems(101, 100).is_err());
|
||||
}
|
||||
}
|
||||
@@ -1,5 +1,6 @@
|
||||
//! Marqdo linalg plugin (C ABI v2): formula-first matrix expressions.
|
||||
|
||||
mod dense;
|
||||
mod matexpr;
|
||||
|
||||
use std::ffi::{CStr, CString};
|
||||
@@ -205,7 +206,7 @@ la_ffi!(linalg_ping, |_args: &Value| {
|
||||
"ok": true,
|
||||
"name": "linalg",
|
||||
"abi": ABI_VERSION,
|
||||
"features": ["matexpr", "simplify"],
|
||||
"features": ["matexpr", "simplify", "dense", "solve"],
|
||||
}))
|
||||
});
|
||||
|
||||
@@ -337,6 +338,74 @@ la_ffi!(linalg_show, |args: &Value| {
|
||||
Ok(out)
|
||||
});
|
||||
|
||||
fn coerce_expr(v: &Value) -> Result<Expr, String> {
|
||||
if let Ok(e) = Expr::from_value(v) {
|
||||
return Ok(e);
|
||||
}
|
||||
// Formula Matrix / nested list / linalg_dense → dense leaf
|
||||
let data = dense::from_value(v)?;
|
||||
Ok(Expr::Dense { data })
|
||||
}
|
||||
|
||||
la_ffi!(linalg_from_formula, |args: &Value| {
|
||||
let f = args
|
||||
.get("formula")
|
||||
.or_else(|| args.get("公式"))
|
||||
.or_else(|| args.get("expr"))
|
||||
.or_else(|| args.get("式"))
|
||||
.ok_or_else(|| "missing `formula`".to_string())?;
|
||||
wrap(coerce_expr(f)?)
|
||||
});
|
||||
|
||||
la_ffi!(linalg_explicit, |args: &Value| {
|
||||
let e = arg_expr_opt(args, &["expr", "a", "式"]).or_else(|_| {
|
||||
let f = args
|
||||
.get("formula")
|
||||
.or_else(|| args.get("公式"))
|
||||
.ok_or_else(|| "missing `expr`".to_string())?;
|
||||
coerce_expr(f)
|
||||
})?;
|
||||
let m = dense::explicit(&e)?;
|
||||
dense::to_dense_value(&m)
|
||||
});
|
||||
|
||||
la_ffi!(linalg_det, |args: &Value| {
|
||||
let m = dense_arg(args, &["expr", "a", "matrix", "式", "矩阵"])?;
|
||||
Ok(json!(dense::det(&m)?))
|
||||
});
|
||||
|
||||
la_ffi!(linalg_trace, |args: &Value| {
|
||||
let m = dense_arg(args, &["expr", "a", "matrix", "式", "矩阵"])?;
|
||||
Ok(json!(dense::trace(&m)?))
|
||||
});
|
||||
|
||||
la_ffi!(linalg_solve, |args: &Value| {
|
||||
let a = dense_arg(args, &["a", "A", "matrix", "矩阵", "左"])?;
|
||||
let b = dense_arg(args, &["b", "B", "rhs", "右"])?;
|
||||
dense::solve_result(&a, &b)
|
||||
});
|
||||
|
||||
la_ffi!(linalg_matmul, |args: &Value| {
|
||||
let a = dense_arg(args, &["a", "左"])?;
|
||||
let b = dense_arg(args, &["b", "右"])?;
|
||||
dense::to_dense_value(&dense::matmul(&a, &b)?)
|
||||
});
|
||||
|
||||
fn dense_arg(args: &Value, keys: &[&str]) -> Result<dense::Mat, String> {
|
||||
for k in keys {
|
||||
if let Some(v) = args.get(*k) {
|
||||
if v.is_null() {
|
||||
continue;
|
||||
}
|
||||
if let Ok(e) = Expr::from_value(v) {
|
||||
return dense::explicit(&e);
|
||||
}
|
||||
return dense::from_value(v);
|
||||
}
|
||||
}
|
||||
Err(format!("missing dense matrix among {:?}", keys))
|
||||
}
|
||||
|
||||
#[no_mangle]
|
||||
pub unsafe extern "C" fn marqdo_plugin_abi_version() -> u32 {
|
||||
ABI_VERSION
|
||||
@@ -365,6 +434,7 @@ pub unsafe extern "C" fn marqdo_plugin_init(host: *const MarqdoHostApi) -> c_int
|
||||
("linalg_eye", "n", linalg_eye as PluginFn),
|
||||
("linalg_zeros", "rows,cols", linalg_zeros as PluginFn),
|
||||
("linalg_from_list", "data", linalg_from_list as PluginFn),
|
||||
("linalg_from_formula", "formula", linalg_from_formula as PluginFn),
|
||||
("linalg_mul", "a,b", linalg_mul as PluginFn),
|
||||
("linalg_add", "a,b", linalg_add as PluginFn),
|
||||
("linalg_sub", "a,b", linalg_sub as PluginFn),
|
||||
@@ -375,6 +445,11 @@ pub unsafe extern "C" fn marqdo_plugin_init(host: *const MarqdoHostApi) -> c_int
|
||||
("linalg_latex", "expr", linalg_latex as PluginFn),
|
||||
("linalg_shape", "expr", linalg_shape as PluginFn),
|
||||
("linalg_show", "expr,path", linalg_show as PluginFn),
|
||||
("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_matmul", "a,b", linalg_matmul as PluginFn),
|
||||
];
|
||||
for (name, params, f) in regs {
|
||||
let c_name = CString::new(name).unwrap();
|
||||
|
||||
@@ -0,0 +1,63 @@
|
||||
---
|
||||
title: linalg basic smoke (L2)
|
||||
description: from_formula, det, solve 2×2, explicit mul.
|
||||
import la:ext/linalg/linalg.mq.md
|
||||
import math:lib/math.mq.md
|
||||
---
|
||||
|
||||
# main
|
||||
|
||||
`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`*
|
||||
*`eps` = > math.div a=1 b=1000*
|
||||
|
||||
*`d` = > la.det expr=`A`*
|
||||
*`d0` = > math.sub a=`d` b=5*
|
||||
*`d0` = > math.abs value=`d0`*
|
||||
1. `d0` < `eps`
|
||||
> print text=det-ok
|
||||
2. *
|
||||
> print text=det-fail
|
||||
|
||||
*`tr` = > la.trace expr=`A`*
|
||||
*`t0` = > math.sub a=`tr` b=5*
|
||||
*`t0` = > math.abs value=`t0`*
|
||||
1. `t0` < `eps`
|
||||
> print text=trace-ok
|
||||
2. *
|
||||
> print text=trace-fail
|
||||
|
||||
*`sol` = > la.solve a=`A` b=`b`*
|
||||
*`x` = sol[^x]*
|
||||
*`data` = x[^data]*
|
||||
*`row0` = > at value=`data` index=0*
|
||||
*`x0` = > at value=`row0` index=0*
|
||||
*`e0` = > math.sub a=`x0` b=2*
|
||||
*`e0` = > math.abs value=`e0`*
|
||||
1. `e0` < `eps`
|
||||
> print text=solve-ok
|
||||
2. *
|
||||
> print text=solve-fail
|
||||
|
||||
*`I` = > la.eye n=2*
|
||||
*`P` = > la.mul a=`A` b=`I`*
|
||||
*`E` = > la.explicit expr=`P`*
|
||||
*`ed` = E[^data]*
|
||||
*`ed0` = > at value=`ed` index=0*
|
||||
*`ed00` = > at value=`ed0` index=0*
|
||||
*`ee` = > math.sub a=`ed00` b=2*
|
||||
*`ee` = > math.abs value=`ee`*
|
||||
1. `ee` < `eps`
|
||||
> print text=explicit-ok
|
||||
2. *
|
||||
> print text=explicit-fail
|
||||
@@ -2464,6 +2464,20 @@ txn-rollback-ok",
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ext_linalg_basic_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-basic-smoke.mq.md",
|
||||
"det-ok\ntrace-ok\nsolve-ok\nexplicit-ok",
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ext_linalg_formula_smoke() {
|
||||
let status = Command::new("cargo")
|
||||
|
||||
Reference in new issue
Block a user