Files
marqdo/plugins/linalg/src/dense.rs
T
cflmy 9331af78e2 release(2.8.0): 合入 CHANGELOG/README/发版说明/skills prove 任务;CI 链接指向 doc/releases
- CHANGELOG.md:v2.8.0 条目(中英双语);
- README.md:版本行 2.7.1→2.8.0 + 愿景第 6 条(知识可证明);
- doc/releases/v2.8.0.md:双语发版说明(亮点/用法/已知限制);
- skills/marqdo-dev/index.mq.md:新增 prove 任务(路径/目录模式/
  require_lean/json;参数用 + 行声明升参,check 与 narrative-ratio 通过);
- 设计文档 §12.5 标记已合入;发版链接统一指向 doc/releases/v2.8.0.md。
2026-11-18 10:29:26 +08:00

584 lines
15 KiB
Rust
Executable File
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! 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": "matrix",
"kind": "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 matrix 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)?),
Expr::Kron { factors } => {
if factors.is_empty() {
return Err("empty Kronecker product".into());
}
let mut acc = explicit(&factors[0])?;
for f in &factors[1..] {
acc = kronecker(&acc, &explicit(f)?)?;
}
Ok(acc)
}
Expr::Block { blocks } => explicit_block(blocks),
}
}
fn explicit_block(blocks: &[Vec<Expr>]) -> Result<Mat, String> {
if blocks.is_empty() || blocks[0].is_empty() {
return Err("empty block matrix".into());
}
let br = blocks.len();
let bc = blocks[0].len();
let mut tiles: Vec<Vec<Mat>> = Vec::with_capacity(br);
for i in 0..br {
let mut row = Vec::with_capacity(bc);
for j in 0..bc {
row.push(explicit(&blocks[i][j])?);
}
tiles.push(row);
}
// Validate and assemble
let mut row_heights = Vec::with_capacity(br);
for i in 0..br {
let (h, _) = shape(&tiles[i][0])?;
for j in 1..bc {
let (h2, _) = shape(&tiles[i][j])?;
if h != h2 {
return Err("block row height mismatch when explicit".into());
}
}
row_heights.push(h);
}
let mut col_widths = Vec::with_capacity(bc);
for j in 0..bc {
let (_, w) = shape(&tiles[0][j])?;
for i in 1..br {
let (_, w2) = shape(&tiles[i][j])?;
if w != w2 {
return Err("block col width mismatch when explicit".into());
}
}
col_widths.push(w);
}
let total_r: usize = row_heights.iter().sum();
let total_c: usize = col_widths.iter().sum();
check_elems(total_r, total_c)?;
let mut out = zeros(total_r, total_c);
let mut r0 = 0;
for i in 0..br {
let mut c0 = 0;
for j in 0..bc {
let tile = &tiles[i][j];
let (h, w) = shape(tile)?;
for ii in 0..h {
for jj in 0..w {
out[r0 + ii][c0 + jj] = tile[ii][jj];
}
}
c0 += w;
}
r0 += row_heights[i];
}
Ok(out)
}
pub fn kronecker(a: &Mat, b: &Mat) -> Result<Mat, String> {
let (ar, ac) = shape(a)?;
let (br, bc) = shape(b)?;
let rows = ar.saturating_mul(br);
let cols = ac.saturating_mul(bc);
check_elems(rows, cols)?;
let mut out = zeros(rows, cols);
for i in 0..ar {
for j in 0..ac {
let aij = a[i][j];
for ii in 0..br {
for jj in 0..bc {
out[i * br + ii][j * bc + jj] = aij * b[ii][jj];
}
}
}
}
Ok(out)
}
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());
}
}