我正在尝试用 Java 计算逆矩阵。

我遵循伴随法(首先计算伴随矩阵，然后转置该矩阵，最后将其乘以行列式值的倒数)。

当矩阵不是太大时它起作用。我已经检查过，对于大小不超过 12x12 的矩阵，可以快速提供结果。然而，当矩阵大于 12x12 时，完成计算所需的时间呈指数增长。

我需要反转的矩阵是 19x19，这需要太多时间。花费更多时间的方法是用于计算行列式的方法。

我使用的代码是:

public static double determinant(double[][] input) {
  int rows = nRows(input);        //number of rows in the matrix
  int columns = nColumns(input); //number of columns in the matrix
  double determinant = 0;

  if ((rows== 1) && (columns == 1)) return input[0][0];

  int sign = 1;     
  for (int column = 0; column < columns; column++) {
    double[][] submatrix = getSubmatrix(input, rows, columns,column);
    determinant = determinant + sign*input[0][column]*determinant(submatrix);
    sign*=-1;
  }
  return determinant;
}   

有人知道如何更有效地计算大型矩阵的行列式吗？如果没有，有谁知道如何使用其他算法计算大矩阵的逆？

谢谢

最佳答案

呈指数级增长？不，我相信矩阵求逆是 O(N^3)。

我建议使用 LU decomposition求解矩阵方程。使用它时，您不必求解行列式。

更好的是，查看一个包来帮助你。 JAMA想到了。

12x12 或 19x19 不是大矩阵。解决具有数万或数百个数千 自由度的问题是很常见的。

这是一个如何使用 JAMA 的工作示例。编译和运行时，您必须在 CLASSPATH 中包含 JAMA JAR:

package linearalgebra;

import Jama.LUDecomposition;
import Jama.Matrix;

public class JamaDemo
{
    public static void main(String[] args)
    {
        double [][] values = {{1, 1, 2}, {2, 4, -3}, {3, 6, -5}};  // each array is a row in the matrix
        double [] rhs = { 9, 1, 0 }; // rhs vector
        double [] answer = { 1, 2, 3 }; // this is the answer that you should get.

        Matrix a = new Matrix(values);
        a.print(10, 2);
        LUDecomposition luDecomposition = new LUDecomposition(a);
        luDecomposition.getL().print(10, 2); // lower matrix
        luDecomposition.getU().print(10, 2); // upper matrix

        Matrix b = new Matrix(rhs, rhs.length);
        Matrix x = luDecomposition.solve(b); // solve Ax = b for the unknown vector x
        x.print(10, 2); // print the solution
        Matrix residual = a.times(x).minus(b); // calculate the residual error
        double rnorm = residual.normInf(); // get the max error (yes, it's very small)
        System.out.println("residual: " + rnorm);
    }
}

根据 quant_dev 的建议，这是使用 Apache Commons Math 解决的相同问题:

package linearalgebra;

import org.apache.commons.math.linear.Array2DRowRealMatrix;
import org.apache.commons.math.linear.ArrayRealVector;
import org.apache.commons.math.linear.DecompositionSolver;
import org.apache.commons.math.linear.LUDecompositionImpl;
import org.apache.commons.math.linear.RealMatrix;
import org.apache.commons.math.linear.RealVector;

public class LinearAlgebraDemo
{
    public static void main(String[] args)
    {
        double [][] values = {{1, 1, 2}, {2, 4, -3}, {3, 6, -5}};
        double [] rhs = { 9, 1, 0 };

        RealMatrix a = new Array2DRowRealMatrix(values);
        System.out.println("a matrix: " + a);
        DecompositionSolver solver = new LUDecompositionImpl(a).getSolver();

        RealVector b = new ArrayRealVector(rhs);
        RealVector x = solver.solve(b);
        System.out.println("solution x: " + x);;
        RealVector residual = a.operate(x).subtract(b);
        double rnorm = residual.getLInfNorm();
        System.out.println("residual: " + rnorm);
    }
}

根据您的情况调整这些。

关于Java逆矩阵计算，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/1992638/