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:
cflmyandCursor committed 2026-09-07 14:16:16 +08:00
1 parent 96da88e168
commit 03aca7cdac
9 files changed
+742 -8

No files matched your search

+1 -1
View File
@@ -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
+1 -1
View File
@@ -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) |
+5 -5
View File
@@ -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
+46
View File
@@ -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`
+44
View File
@@ -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=`右`**
## 符号
+ `名`
+ `行`
+492
View File
@@ -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());
}
}
+76 -1
View File
@@ -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();
+63
View File
@@ -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
+14
View File
@@ -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")