diff --git a/CHANGELOG.md b/CHANGELOG.md index f094fbd..a5eb9ca 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -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 diff --git a/doc/design/ext-linalg.md b/doc/design/ext-linalg.md index 2f539ad..207bdc9 100644 --- a/doc/design/ext-linalg.md +++ b/doc/design/ext-linalg.md @@ -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) | diff --git a/doc/roadmap/ext-linalg.md b/doc/roadmap/ext-linalg.md index 52158d8..aaaa33a 100644 --- a/doc/roadmap/ext-linalg.md +++ b/doc/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 diff --git a/ext/linalg/linalg.mq.md b/ext/linalg/linalg.mq.md index 88e6d59..260af9d 100644 --- a/ext/linalg/linalg.mq.md +++ b/ext/linalg/linalg.mq.md @@ -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` diff --git a/ext/linalg/线性代数.mq.md b/ext/linalg/线性代数.mq.md index ab80153..1bd3d1b 100644 --- a/ext/linalg/线性代数.mq.md +++ b/ext/linalg/线性代数.mq.md @@ -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=`右`** + ## 符号 + `名` + `行` diff --git a/plugins/linalg/src/dense.rs b/plugins/linalg/src/dense.rs new file mode 100644 index 0000000..f61244b --- /dev/null +++ b/plugins/linalg/src/dense.rs @@ -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>; + +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 { + 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 = m + .iter() + .map(|row| { + let cells: Vec = row.iter().map(|x| format_num(*x)).collect(); + format!("[{}]", cells.join(",")) + }) + .collect(); + format!("[{}]", rows.join(",")) +} + +fn format_latex(m: &Mat) -> String { + let body: Vec = m + .iter() + .map(|row| { + row.iter() + .map(|x| format_num(*x)) + .collect::>() + .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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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()); + } +} diff --git a/plugins/linalg/src/lib.rs b/plugins/linalg/src/lib.rs index 2c9c733..ef99647 100644 --- a/plugins/linalg/src/lib.rs +++ b/plugins/linalg/src/lib.rs @@ -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 { + 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 { + 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(); diff --git a/tests/ext/linalg-basic-smoke.mq.md b/tests/ext/linalg-basic-smoke.mq.md new file mode 100644 index 0000000..83b2583 --- /dev/null +++ b/tests/ext/linalg-basic-smoke.mq.md @@ -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 diff --git a/tests/gold.rs b/tests/gold.rs index 2339dd7..ef3bd85 100644 --- a/tests/gold.rs +++ b/tests/gold.rs @@ -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")