Update LUDecompositionTest.java

Author: Raghu0703

src/test/java/com/thealgorithms/matrix/LUDecompositionTest.java

@@ -1,67 +1,80 @@
 package com.thealgorithms.matrix;
 
-import static org.junit.jupiter.api.Assertions.assertArrayEquals;
-import static org.junit.jupiter.api.Assertions.assertThrows;
-
-import org.junit.jupiter.api.Test;
+/**
+ * LU Decomposition is a matrix factorization technique that decomposes a matrix A
+ * into the product of a lower triangular matrix L and an upper triangular matrix U.
+ * This is useful for solving systems of linear equations, computing determinants,
+ * and inverting matrices.
+ *
+ * @author Hardvan
+ */
+public final class LUDecomposition {
+    private LUDecomposition() {
+    }
 
-class LUDecompositionTest {
-    private static final double EPSILON = 1e-10;
+    public static class Result {
+        private final double[][] l;
+        private final double[][] u;
 
-    @Test
-    void testBasicLUDecomposition() {
-        double[][] matrix = {{2, -1, -2}, {-4, 6, 3}, {-4, -2, 8}};
-        LUDecomposition.Result result = LUDecomposition.decompose(matrix);
+        public Result(double[][] l, double[][] u) {
+            this.l = l;
+            this.u = u;
+        }
 
-        double[][] expectedL = {{1.0, 0.0, 0.0}, {-2.0, 1.0, 0.0}, {-2.0, -1.0, 1.0}};
-        double[][] expectedU = {{2.0, -1.0, -2.0}, {0.0, 4.0, -1.0}, {0.0, 0.0, 3.0}};
+        public double[][] getL() {
+            return l;
+        }
 
-        assertMatrixEquals(expectedL, result.getL());
-        assertMatrixEquals(expectedU, result.getU());
+        public double[][] getU() {
+            return u;
+        }
     }
 
-    @Test
-    void testIdentityMatrix() {
-        double[][] matrix = {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}};
-        LUDecomposition.Result result = LUDecomposition.decompose(matrix);
-
-        assertMatrixEquals(matrix, result.getL());
-        assertMatrixEquals(matrix, result.getU());
-    }
+    /**
+     * Performs LU decomposition on the given matrix.
+     *
+     * @param matrix The input matrix to decompose
+     * @return Result object containing L and U matrices
+     * @throws IllegalArgumentException if matrix is not square, empty, or singular
+     */
+    public static Result decompose(double[][] matrix) {
+        if (matrix == null || matrix.length == 0) {
+            throw new IllegalArgumentException("Matrix cannot be null or empty");
+        }
 
-    @Test
-    void testSingularMatrix() {
-        double[][] matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
-        assertThrows(IllegalArgumentException.class, () -> LUDecomposition.decompose(matrix));
-    }
+        int n = matrix.length;
+        if (matrix[0].length != n) {
+            throw new IllegalArgumentException("Matrix must be square");
+        }
 
-    @Test
-    void testEmptyMatrix() {
-        double[][] matrix = {};
-        assertThrows(IllegalArgumentException.class, () -> LUDecomposition.decompose(matrix));
-    }
+        double[][] l = new double[n][n];
+        double[][] u = new double[n][n];
 
-    @Test
-    void testNonSquareMatrix() {
-        double[][] matrix = {{1, 2, 3}, {4, 5, 6}};
-        assertThrows(IllegalArgumentException.class, () -> LUDecomposition.decompose(matrix));
-    }
+        for (int i = 0; i < n; i++) {
+            l[i][i] = 1.0;
 
-    @Test
-    void testTwoByTwoMatrix() {
-        double[][] matrix = {{4, 3}, {6, 3}};
-        LUDecomposition.Result result = LUDecomposition.decompose(matrix);
+            for (int j = i; j < n; j++) {
+                double sum = 0.0;
+                for (int k = 0; k < i; k++) {
+                    sum += l[i][k] * u[k][j];
+                }
+                u[i][j] = matrix[i][j] - sum;
+            }
 
-        double[][] expectedL = {{1.0, 0.0}, {1.5, 1.0}};
-        double[][] expectedU = {{4.0, 3.0}, {0.0, -1.5}};
+            for (int j = i + 1; j < n; j++) {
+                double sum = 0.0;
+                for (int k = 0; k < i; k++) {
+                    sum += l[j][k] * u[k][i];
+                }
 
-        assertMatrixEquals(expectedL, result.getL());
-        assertMatrixEquals(expectedU, result.getU());
-    }
+                if (Math.abs(u[i][i]) < 1e-10) {
+                    throw new IllegalArgumentException("Matrix is singular or nearly singular");
+                }
 
-    private void assertMatrixEquals(double[][] expected, double[][] actual) {
-        for (int i = 0; i < expected.length; i++) {
-            assertArrayEquals(expected[i], actual[i], EPSILON);
+                l[j][i] = (matrix[j][i] - sum) / u[i][i];
+            }
         }
+
+        return new Result(l, u);
     }
 }