Java Program to Perform LU Decomposition of a Matrix

2025 年 3 月 26 日 | 阅读 5 分钟

LU 分解

LU 分解，也称为 LU 因式分解。它是数值线性代数中的一项基本技术，其中将方阵分解为一个下三角矩阵 L 和一个上三角矩阵 U。

对于 n×n 矩阵 A，目标是将其表示为方程

其中

L 是一个对角线上有 1 的下三角矩阵。
U 是一个上三角矩阵。

关键概念

下三角矩阵 (L)
- 一个主对角线上方的所有元素都为零的矩阵。
- L 的对角线元素通常设置为 1（尽管 LU 分解的一些变体可能没有此限制）。
上三角矩阵 (U)
- 一个主对角线下方的所有元素都为零的矩阵。
- 对角线及对角线以上的元素可以非零。

Doolittle 算法

Doolittle 方法用于对一个方阵进行 LU 分解。LU 分解是一种在计算线性代数中用于将矩阵 A 分解为两个更容易处理的矩阵的方法：下三角矩阵 L 和上三角矩阵 U。这种分解表示为

其中

L 是一个对角线上为 1 的下三角矩阵。
U 是一个上三角矩阵。

算法

步骤 1：初始化矩阵，将 L 设置为单位矩阵，将 U 设置为零矩阵。

步骤 2：通过从 A[i][k] 中减去 L 和 U 乘积的总和，计算每个列 k 的 U[i][k]。

步骤 3：通过将 A[i][k] 与 L 和 U 乘积的总和之间的差除以 U[k][k]，计算每个列 k 的 L[i][k]。

步骤 4：重复计算所有列以完成 L 和 U。

步骤 5：打印最终的下三角矩阵 L 和上三角矩阵 U。

让我们在一个 Java 程序中实现上述算法。

示例

public class DoolittleLUDecomposition {
    // Function to perform LU decomposition using Doolittle's Method
    public static void doolittleDecomposition(double[][] A, int n, double[][] L, double[][] U) {
        // Initialize L as an identity matrix and U as a zero matrix
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                // Set diagonal elements of L to 1 (identity matrix)
                L[i][j] = (i == j) ? 1 : 0;
                // Set all elements of U to 0 initially
                U[i][j] = 0;
            }
        }
        // Perform LU decomposition
        for (int k = 0; k < n; k++) {
            // Decompose U
            for (int i = k; i < n; i++) {
                double sum = 0;
           // Calculate the sum of L[i][j] multiplied by U[j][k] where j varies from 0 to k-1
                for (int j = 0; j < k; j++) {
                    sum += L[i][j] * U[j][k];
                }
                // Compute U[i][k] using the formula A[i][k] - sum
                U[i][k] = A[i][k] - sum;
            }
            // Decompose L
            for (int i = k + 1; i < n; i++) {
                double sum = 0;
                // Find the total by multiplying L[i][j] with U[j][k] for j ranging from 0 to k-1
                for (int j = 0; j < k; j++) {
                    sum += L[i][j] * U[j][k];
                }
                // Compute L[i][k] using the formula (A[i][k] - sum) / U[k][k]
                L[i][k] = (A[i][k] - sum) / U[k][k];
            }
        }
    }
    // Function to print matrices
    public static void printMatrix(double[][] matrix, int n) {
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                // Print each element with a specific width and formatting
                System.out.printf("%8.4f ", matrix[i][j]);
            }
            // Move to the next line after printing all elements in a row
            System.out.println();
        }
    }
    public static void main(String[] args) {
        // Define a sample matrix A
        double[][] A = { 
            { 2, -1, -2 },
            { -4, 6, 3 },
            { -4, -2, 8 }
        };
        // Get the size of the matrix
        int n = A.length;
        // Initialize matrices L and U
        double[][] L = new double[n][n];
        double[][] U = new double[n][n];
        // Perform LU decomposition
        doolittleDecomposition(A, n, L, U);
        // Print the Lower Triangular Matrix
        System.out.println("Lower Triangular Matrix (L):");
        printMatrix(L, n);
        // Print the Upper Triangular Matrix
        System.out.println("\nUpper Triangular Matrix (U):");
        printMatrix(U, n);
    }
}   

输出

 
Lower Triangular Matrix (L):
  1.0000   0.0000   0.0000 
 -2.0000   1.0000   0.0000 
 -2.0000  -0.3333   1.0000 

Upper Triangular Matrix (U):
  2.0000   0.0000   0.0000 
 -4.0000   6.0000   0.0000 
 -4.0000  -2.0000   8.0000

实施

示例

 
public class LUDecomposition {
    // Method to perform LU Decomposition
    public static void luDecomposition(double[][] matrix, double[][] L, double[][] U) {
        int n = matrix.length; // Determine the total count of rows present in the matrix
        int m = matrix[0].length; // Retrieve the total amount of columns within the matrix
        // Loop over each row of the matrix
        for (int i = 0; i < n; i++) {
            // Compute the U matrix values for the current row
            for (int k = i; k < m; k++) {
                U[i][k] = matrix[i][k]; // Assign the value of matrix U to the position [i][k]
                // Subtract the total of L[i][j] * U[j][k] for all j where j is smaller than i
                for (int j = 0; j < i; j++) {
                    U[i][k] -= L[i][j] * U[j][k];
                }
            }
            // Compute the L matrix values for the current row
            for (int k = i; k < n; k++) {
                if (i == k) {
                    L[i][i] = 1; // Set the diagonal elements of L to 1
                } else {
                    L[k][i] = matrix[k][i]; // Set the matrix value as L[k][i]
                    // Calculate the outcome by summing L[k][j] times U[j][i] for all j values that are smaller than i
                    for (int j = 0; j < i; j++) {
                        L[k][i] -= L[k][j] * U[j][i];
                    }
                    // Divide by U[i][i] to get the final value of L[k][i]
                    L[k][i] /= U[i][i];
                }
            }
        }
    }
    public static void printMatrix(double[][] matrix) {
        // Loop over each row of the matrix
        for (double[] row : matrix) {
            // Loop over each element of the row
            for (double val : row) {
                // Print the value with 2 decimal places, right-aligned
                System.out.printf("%8.2f ", val);
            }
            // Print a new line after each row
            System.out.println();
        }
    }
    public static void main(String[] args) {
        // Define a sample matrix for testing
        double[][] matrix = {
            {2, -1, 1},
            {3, 3, 9},
            {3, 3, 5}
        };
        int n = matrix.length; // Specify the number of rows (and columns) in the matrix
        double[][] L = new double[n][n]; // Establish the L matrix during the initial stages
        double[][] U = new double[n][n]; //Establish the U matrix during the initial stages
        // Perform LU Decomposition
        luDecomposition(matrix, L, U);
        // Print the L matrix
        System.out.println("Matrix L:");
        printMatrix(L);
        // Print the U matrix
        System.out.println("\nMatrix U:");
        printMatrix(U);
    }
}   

输出

 
Matrix L:
    1.00     0.00     0.00 
    1.50     1.00     0.00 
    1.50     1.00     1.00 

Matrix U:
    2.00    -1.00     1.00 
    0.00     4.50     7.50 
    0.00     0.00    -4.00

下一主题Java 的用途

Java Program to Perform LU Decomposition of a Matrix

LU 分解

Doolittle 算法

算法

示例

实施

示例

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Java Conversion

Java Misc

Java Program to Perform LU Decomposition of a Matrix

LU 分解

Doolittle 算法

算法

示例

实施

示例

相关帖子

Java 中使用多线程进行快速排序

Java 中静态函数的阴影

Find Primitive Root of a Prime Number Modulo n in Java

Java 中锯齿形星形和数字图案

Java 中的 Package getPackages() 方法及示例

Java 程序演示非线程安全的懒惰初始化

Java 中的歧义

Java 中捕获基类和派生类作为异常

Java 中的文件权限

Java setPriority() 方法

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器