Go Gonum mat 怎样解线性方程组而不显式求逆

在 Go 里用 Gonum 解线性方程组，通常不需要先求矩阵 A 的逆。更直接的写法是把方程整理成 A·X=B，让 mat.Dense.Solve 负责求解，并根据返回的错误判断矩阵是否满足条件。这样既少保存一个逆矩阵，也更符合数值计算库的使用方式。

官方文档：https://pkg.go.dev/gonum.org/v1/gonum/mat

如果目标只是得到 X，优先调用 Dense.Solve(A, B)，不要写成“先 Inverse(A)，再计算 Inverse(A)·B”。Gonum 文档明确提醒矩阵求逆在数值上不稳定；Solve 还会在输入不满足满秩条件时返回 Condition 错误。

先判断问题是不是 A·X=B

先把业务公式写成矩阵形式。A 是系数矩阵，B 是右端项矩阵，X 是待求解矩阵。对于最常见的方阵系统，A 是 n×n，单个右端项可以看成 n×1 的 B，最终得到 n×1 的 X。

这里的重点不是把 A 变成一个可打印的逆矩阵，而是让求解器直接利用矩阵分解得到结果。若系数矩阵是 m×n，Gonum 的 Dense.Solve 还可以处理满秩条件下的最小二乘问题；当 m 时，它求的是范数最小的解。

用 Dense.Solve 直接求解

安装依赖后，可以把矩阵数据和右端项封装成一个小函数。示例使用一个右端项，返回的 *mat.Dense 就是解矩阵。

package main

import (
    "fmt"

    "gonum.org/v1/gonum/mat"
)

// solveLinearSystem 把 n×n 系数矩阵和 n×1 右端项交给 Gonum 求解。
func solveLinearSystem(aData, bData []float64, n int) (*mat.Dense, error) {
    // NewDense 按行保存数据；调用方需要保证切片长度和矩阵形状一致。
    a := mat.NewDense(n, n, aData)
    b := mat.NewDense(n, 1, bData)

    var x mat.Dense
    // Solve 直接写入 x，不需要先构造 a 的逆矩阵。
    if err := x.Solve(a, b); err != nil {
        // Condition 等错误说明当前系数矩阵不适合得到可靠的满秩解。
        return nil, fmt.Errorf("求解线性系统失败: %w", err)
    }
    return &x, nil
}

func main() {
    // 这里只准备输入数据；输出展示交给调用方决定。
    aData := []float64{3, 1, 1, 2}
    bData := []float64{9, 8}
    x, err := solveLinearSystem(aData, bData, 2)
    if err != nil {
        // 生产代码应记录错误并保留原始输入，便于定位秩或维度问题。
        panic(err)
    }
    fmt.Println(mat.Formatted(x, mat.Prefix("    "), mat.Squeeze()))
}

这个调用的关键点有三个：第一，b 的行数必须和 a 的行数对应；第二，接收结果的 x 可以是空的 Dense，由 Solve 按结果尺寸写入；第三，错误不能被忽略，否则非满秩输入可能被当成正常结果继续传播。

多个右端项要放进 B 的列

如果同一组系数矩阵 A 要对应多个右端项，不必循环多次求逆或重复组织矩阵。把每个右端向量放进 B 的一列，得到的 X 也会按列对应每个解向量。官方文档把这种形式描述为一次处理多个右端项。

// solveManyRHS 一次处理多个右端项，B 的每一列对应 X 的一列。
func solveManyRHS() (*mat.Dense, error) {
    // A 是 2×2 系数矩阵，下面 B 的两列代表两个右端项。
    a := mat.NewDense(2, 2, []float64{
        4, 1,
        2, 3,
    })
    b := mat.NewDense(2, 2, []float64{
        9, 6,
        13, 10,
    })

    var x mat.Dense
    // Solve 会把两个解向量按列写入 x，避免重复处理同一个 A。
    if err := x.Solve(a, b); err != nil {
        // 多右端项共享同一个满秩前提，任一输入不满足时都要返回错误。
        return nil, err
    }
    return &x, nil
}

因此，B 的形状不仅是内存布局问题，也决定了你如何解释结果：B 有几列，X 就有几列。若业务数据天然是一组批量约束，把它们组织成矩阵通常比在外层反复调用更清晰。

出现错误时按三层检查

第一层是维度。先打印或记录 Dims() 返回的行列数，确认 A 的行数等于 B 的行数，且右端项数据没有把“按列排列”误写成“按行排列”。矩阵形状错通常应在创建输入时修复，而不是在错误返回后猜测。

第二层是满秩条件。Dense.Solve 假设 A 满秩；如果不满足，文档说明会返回 Condition 错误。这个错误不是“把逆矩阵再算一次”就能解决的，应回到特征重复、约束不足或数据尺度差异等业务原因。

第三层是结果解释。即使函数没有返回错误，也要确认结果是否符合业务容差。浮点数不适合用逐元素相等判断，应该计算残差 R=A·X-B，再根据输入尺度选择阈值。

// residualNorm 计算 A·X-B 的矩阵范数，用于业务层的误差判断。
func residualNorm(a, x, b *mat.Dense) float64 {
    var ax mat.Dense
    // Mul 先得到 A·X，保持原始输入矩阵不被覆盖。
    ax.Mul(a, x)

    var residual mat.Dense
    // Sub 得到残差矩阵；Norm(2) 给出一个整体误差指标。
    residual.Sub(&ax, b)
    return residual.Norm(2)
}

为什么不把 Inverse 当成默认方案

Dense.Inverse 适合确实需要逆矩阵本身的场景，但如果只是为了得到 X，先算逆矩阵再相乘会增加中间对象，也把数值稳定性问题放到了业务代码里。Gonum 的官方文档直接建议在可能时使用 Solve routines。

可以把选择规则记成下面这张速查表：

最后的排查清单

• 是否把方程整理成了 A·X=B，而不是误把待求向量塞进了 A。
• A.Dims() 与 B.Dims() 是否满足行数对应。
• 多个右端项是否按列放进 B，并按列读取 X。
• 是否处理了 Solve 返回的 Condition 或其他错误。
• 是否用 A·X-B 的残差和业务容差做了反向确认。

一句话总结：Gonum mat 的正确入口是“把 A 和 B 交给 Dense.Solve，处理错误，再检查残差”。只有当业务真的需要逆矩阵本身时，才考虑 Inverse。

相关问题

Dense.Solve 只能处理方阵吗？

不只方阵。官方文档把它定义为线性最小二乘问题，并要求 A 满秩；行数不少于列数时得到超定系统的唯一最小二乘解，行数少于列数时得到范数最小的解。

为什么 Solve 返回 Condition 错误？

通常意味着 A 没有满足满秩假设，或者数据让问题变得病态。先确认输入列是否重复、约束是否不足，再决定是否需要重新建模或调整数据尺度。

多个右端项是否要重复调用 Solve？

不必。把多个右端向量作为 B 的多列传入，X 会返回对应的多列解；这样更符合 Gonum 对多个右端项的接口约定。