计算方法线性方程组的直接法

高斯消元法

算法

代码实现

    public class 高斯消元法 {
    public static double[][] Gaussian(double[][] matrix) {
        // 消元。
        for (int k = 0; k < matrix[0].length - 2; k++) {// 遍历列。
            System.out.println(Arrays.deepToString(matrix));
            for (int j = k + 1; j < matrix.length; j++) {// 遍历行。
                double temp = -matrix[j][k] / matrix[k][k];
                for (int i = 0; i < matrix[0].length; i++) {// 置0
                    matrix[j][i] += matrix[k][i] * temp;
                }
            }
        }
        System.out.println(Arrays.deepToString(matrix));
        // 回代。
        for (int k = matrix.length - 1; k >= 0; k--) {// 遍历行。
            for (int j = k + 1; j <= matrix[0].length - 2; j++) {// 将主元与常数放到方程两边。
                matrix[k][matrix[0].length - 1] = matrix[k][matrix[0].length - 1] - matrix[k][j] * matrix[j][j];
            }
            matrix[k][k] = matrix[k][matrix[0].length - 1] / matrix[k][k];// 方程右侧的常数除以主元的系数，求的未知数。
        }
        return matrix;
    }

    public static void main(String[] args) {
        double[][] matrix = {{2, 1, -0.1, 1, 2.7}, {0.4, 0.5, 4, -8.5, 21.9}, {0.3, -1, 1, 5.2, -3.9}, {1, 0.2, 2.5, -1, 9.9}};
        System.out.println(Arrays.deepToString(matrix));
        matrix = Gaussian(matrix);
        for (int k = 0; k < matrix.length; k++) {// 打印结果。
            System.out.format("x%d = %.2f\n", k + 1, matrix[k][k]);
        }
    }
}

全主元消元法

算法

列主元消元法

算法

代码实现

public class 列主元消元法 {
    public static double[][] ListPrincipal(double[][] matrix) {
        // 消元。
        for (int k = 0; k < matrix[0].length - 2; k++) {// 遍历列。
            matrix = changeMatrixOrder(matrix, k);// 找出最大主元的一行并交换位置。
            System.out.println(Arrays.deepToString(matrix));
            for (int j = k + 1; j < matrix.length; j++) {// 遍历行。
                double temp = -matrix[j][k] / matrix[k][k];
                for (int i = 0; i < matrix[0].length; i++) {// 置0
                    matrix[j][i] += matrix[k][i] * temp;
                }
            }
        }
        System.out.println(Arrays.deepToString(matrix));
        // 回代。
        for (int k = matrix.length - 1; k >= 0; k--) {// 遍历行。
            for (int j = k + 1; j <= matrix[0].length - 2; j++) {// 将主元与常数放到方程两边。
                matrix[k][matrix[0].length - 1] = matrix[k][matrix[0].length - 1] - matrix[k][j] * matrix[j][j];
            }
            matrix[k][k] = matrix[k][matrix[0].length - 1] / matrix[k][k];// 方程右侧的常数除以主元的系数，求的未知数。
        }
        return matrix;
    }

    static double[][] changeMatrixOrder(double[][] matrix, int k) {// 找出最大主元的一行并交换位置。
        int originalIndex = k;
        int maxIndex = k;
        double[] temp;
        double Max = Math.abs(matrix[k][k]);
        for (int i = k + 1; i < matrix.length; i++) {// 找出主元最大的一行。
            if (Math.abs(matrix[i][k]) > Max) {
                maxIndex = i;
            }
        }
        // 交换行。
        temp = matrix[originalIndex];
        matrix[originalIndex] = matrix[maxIndex];
        matrix[maxIndex] = temp;

        return matrix;
    }

    public static void main(String[] args) {
        double[][] matrix = {{2, 1, -0.1, 1, 2.7}, {0.4, 0.5, 4, -8.5, 21.9}, {0.3, -1, 1, 5.2, -3.9}, {1, 0.2, 2.5, -1, 9.9}};
        System.out.println(Arrays.deepToString(matrix));
        matrix = ListPrincipal(matrix);
        for (int k = 0; k < matrix.length; k++) {// 打印结果。
            System.out.format("x%d = %.2f\n", k + 1, matrix[k][k]);
        }
    }
}

标度化列主元消元法

算法

高斯-若尔当消元法

算法

代码实现

public class 高斯若尔当消元法 {
    public static double[][] GaussJordang(double[][] matrix) {
        // 消元。
        for (int k = 0; k < matrix[0].length - 1; k++) {// 遍历列。
            System.out.println(Arrays.deepToString(matrix));
            for (int i = 0; i < matrix[0].length; i++) {// 标准化。
                if (i != k) {
                    matrix[k][i] = matrix[k][i] / matrix[k][k];// 除以该行主元的系数。
                }
            }
            matrix[k][k] = 1;// 主元置1
            for (int j = 0; j < matrix.length; j++) {// 遍历行。
                if (j != k) {
                    double temp = -matrix[j][k] / matrix[k][k];
                    for (int i = 0; i < matrix[0].length; i++) {// 置0
                        matrix[j][i] += matrix[k][i] * temp;
                    }
                }
            }
        }
        return matrix;
    }

    public static void main(String[] args) {
        double[][] matrix = {{2, 1, -0.1, 1, 2.7}, {0.4, 0.5, 4, -8.5, 21.9}, {0.3, -1, 1, 5.2, -3.9}, {1, 0.2, 2.5, -1, 9.9}};
        System.out.println(Arrays.deepToString(matrix));
        matrix = GaussJordang(matrix);
        for (int k = 0; k < matrix.length; k++) {// 打印结果。
            System.out.format("x%d = %.2f\n", k + 1, matrix[k][matrix[0].length - 1]);
        }
    }
}

例题

Doolittle分解法

算法

代码实现

public class Doolittle分解法 {
    public static double[] Doolittle(double[][] matrix) {
        double[][] a = new double[matrix[0].length - 1][matrix[0].length - 1];
        double[] b = new double[matrix[0].length - 1];
        for (int i = 0; i < matrix.length; i++) {// 分离出B矩阵。
            b[i] = matrix[i][matrix[i].length - 1];
        }
        for (int j = 0; j < matrix.length; j++) {// 分离出A矩阵。
            for (int i = 0; i < matrix[0].length - 1; i++) {
                a[j][i] = matrix[j][i];
            }
        }
        double[][] u = new double[matrix[0].length - 1][matrix[0].length - 1];
        double[][] l = new double[matrix[0].length - 1][matrix[0].length - 1];
        int k = 0;
        double temp = 0;
        for (int j = 0; j < u[0].length; j++)// 首先计算U矩阵第一行各元素。
            u[k][j] = a[k][j];
        for (int i = 0; i < l.length; i++)// 计算L矩阵第一列各元素。
            l[i][k] = a[i][k] / u[k][k];
        for (k = 1; k < u.length; k++) {
            for (int j = k; j < u[0].length; j++) {// 计算U矩阵第k行元素。
                temp = 0;
                for (int r = 0; r < k; r++) {
                    temp += l[k][r] * u[r][j];
                }
                u[k][j] = a[k][j] - temp;
            }
            for (int i = k; i < l.length; i++) // 计算L矩阵第k列元素。
            {
                temp = 0;
                for (int r = 0; r < k; r++) {
                    temp += l[i][r] * u[r][k];
                }
                l[i][k] = (a[i][k] - temp) / u[k][k];
            }
        }
//        System.out.println(Arrays.deepToString(matrix));
//        System.out.println(Arrays.deepToString(a));
//        System.out.println(Arrays.toString(b));
//        System.out.println(Arrays.deepToString(l));
//        System.out.println(Arrays.deepToString(u));

        //Ly=b
        for (int i = 0; i < l.length; i++) {// 遍历行。
            temp = 0;
            for (int j = 0; j < i; j++) {
                temp += l[i][j] * b[j];
            }
            b[i] -= temp;
        }
//        System.out.println(Arrays.toString(b));// 此时b数组为存放y
        //Ux=y
        for (int i = u.length - 1; i >= 0; i--) {// 遍历行。
            temp = 0;
            for (int j = i + 1; j <= u[0].length - 1; j++) {
                temp += u[i][j] * b[j];
            }
            b[i] -= temp;
            b[i] = b[i] / u[i][i];
        }
        return b;
    }

    public static void main(String[] args) {
        double[][] matrix = {{2, 1, 1, 4}, {1, 3, 2, 6}, {1, 2, 2, 5}};
        double[] b = Doolittle(matrix);
        for (int i = 0; i < b.length; i++) {// 打印结果。
            System.out.format("x%d = %.2f\n", i + 1, b[i]);
        }
    }
}

例题