Java优化的Cramers规则函数

最近了解了初级微积分中的 Cramers 规则，并决定用 Java 制作一个算法来帮助我更好地理解它。

以下代码 100% 正确运行，但是它不使用任何类型的 for 循环来以更简单的方式执行其操作。

问题：Java 中是否有更优雅的 Cramers Rule 实现？

我正在考虑制定一个基本的行列式方法，然后在需要获取 Dx、Dy 和 Dz 的行列式时进行一些列交换。 （对于 Dx，将原始矩阵的第 4 列与第 1 列交换，然后取行列式并除以原始行列式。） 这听起来不错吗？

    public static void main(String[] args) {
    int[][] matrix = new int[3][3];
    matrix[0] = new int[] { 3, 5, -1, -2 };
    matrix[1] = new int[] { 1, -4, 2, 13 };
    matrix[2] = new int[] { 2, 4, 3, 1 };
    int[] r = crame(matrix);    
    info("x: " + r[0] + ", y: " + r[1] + ", z: " + r[2]);
    for(int i = 0; i < matrix.length; i++) {
        int[] base = matrix[i];
        if(check(base, r, base[3])) {
            info("System " + (i+1) + " checks!");
        } else {
            info("System " + (i+1) + " fails check!");
        }
    }
}

public static int[] crame(int[][] m) {
    int[] result;
    if (m.length == 2) {
        result = new int[2];
        int D = (m[0][0] * m[1][1]) - (m[1][0] * m[0][1]);
        int Dx = (m[0][2] * m[1][1]) - (m[1][2] * m[0][1]);
        int Dy = (m[0][0] * m[1][2]) - (m[1][0] * m[0][2]);
        result[0] = (int) (Dx / D);
        result[1] = (int) (Dy / D);
    } else if (m.length == 3) {
        result = new int[3];

        int D = (((m[0][2] * m[1][1] * m[0][2]) + (m[2][1] * m[1][2] * m[0][0]) + (m[2][2]
                * m[1][0] * m[0][2])) - ((m[0][0] * m[1][1] * m[2][2])
                + (m[0][1] * m[1][2] * m[0][2]) + (m[0][2] * m[1][0] * m[2][1])));

        int Dx = (((m[2][3] * m[1][1] * m[0][2]) + (m[2][1] * m[1][2] * m[0][3]) + (m[2][2]
                * m[1][3] * m[0][1])) - ((m[0][3] * m[1][1] * m[2][2])
                + (m[0][1] * m[1][2] * m[2][3]) + (m[0][2] * m[1][3] * m[2][1])));

        int Dy = (((m[2][0] * m[1][3] * m[0][2]) + (m[2][3] * m[1][2] * m[0][3]) + (m[2][2]
                * m[1][0] * m[0][3])) - ((m[0][0] * m[1][3] * m[2][2])
                + (m[0][3] * m[1][2] * m[2][0]) + (m[0][2] * m[1][0] * m[2][3])));

        int Dz = (((m[2][0] * m[1][1] * m[0][3]) + (m[2][1] * m[1][3] * m[0][0]) + (m[2][3]
                * m[1][0] * m[0][1])) - ((m[0][0] * m[1][1] * m[2][3])
                + (m[0][1] * m[1][3] * m[2][0]) + (m[0][3] * m[1][0] * m[2][1])));

        result[0] = (int) (Dx / D);
        result[1] = (int) (Dy / D);
        result[2] = (int) (Dz / D);
    } else {
        return new int[] {};
    }
    return result;
}

public static int product(int[] a, int[] b) {
    int p = 0;
    int[] fin = new int[(a.length -1)];
    for(int x = 0; x < fin.length; x++) {
        fin[x] = a[x] * b[x];
    }
    for (int f : fin) {
            p += f;
    }
    return p;
}

public static boolean check(int[] a, int[] b, int z) {
    return product(a, b) == z;
}

public static void info(String log) {
    System.out.println(log);
}

我的问题涉及仅使用克拉默规则求解方程组的特定算法，是否有更优雅的算法？该函数仅针对方阵设计。

这不是家庭作业，高中毕业后我将学习计算机科学，并且我一直致力于开发算法作为初步实践。

感谢您查看此内容

首先，克拉默规则在一个方面是完美的：它将线性系统的代数解作为其系数的有理函数给出。

然而，实际上，它有其局限性。虽然对于 2x2 系统来说是最完美的公式，并且对于 3x3 系统来说仍然很好，但如果以简单的方式实现，其性能会随着每增加一个维度而恶化。

An almost literal implementation of Cramers rule can be achieved with the Leverrier-Faddeev algorithm ^{a http://www.mathworks.com/matlabcentral/fileexchange/15974-faddeev-leverrier-algorithm/content/html/fadlevexample.html b https://de.wikipedia.org/wiki/Algorithmus_von_Faddejew-Leverrier}. It only requires the computation of matrix products and matrix traces, and manipulations of the matrix diagonal. Not only does it compute the determinant of the matrix A (along with the other coefficients of the characteristic polynomial), it also has the adjugate https://en.wikipedia.org/wiki/Adjugate_matrix or co-factor matrix A^# in its iteration matrix. The interesting fact about this matrix is that it allows to write the solution of A*x=b as (A^#*b)/det(A), that is, the entries of A^#*b already are the other determinants required by Cramers rule.

Leverrier-Faddeev requires n⁴+O(n³) operations. The same results can be obtained by the more complicated Samuelson-Berkowitz https://de.wikipedia.org/wiki/Algorithmus_von_Samuelson-Berkowitz algorith, which has one third of that complexity, that is n⁴/3+O(n³).

如果首先将系统 (A|b) 转换为三角形形式，则克拉默规则所需的行列式计算将变得非常微不足道。这可以通过 Gauß 消去法，又名 LU 分解（通过旋转实现数值稳定性）或 QR 分解（最容易调试的应该是吉文斯旋转的变体）来实现。克拉默规则的有效应用就是三角系统中的后向替换。