Update LUDecompositionTest.java

Author: Raghu0703

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

@@ -2,101 +2,70 @@
 
 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
+
 import org.junit.jupiter.api.Test;
 
 class LUDecompositionTest {
 
-    private static final double EPSILON = 1e-6;
+    private static final double EPSILON = 1e-10;
 
     @Test
     void testBasicLUDecomposition() {
-        double[][] matrix = {
-            {2, -1, -2},
-            {-4, 6, 3},
-            {-4, -2, 8}
-        };
+        double[][] matrix = {{2, -1, -2}, {-4, 6, 3}, {-4, -2, 8}};
 
         LUDecomposition.Result result = LUDecomposition.decompose(matrix);
 
-        double[][] expectedL = {
-            {1.0, 0.0, 0.0},
-            {-2.0, 1.0, 0.0},
-            {-2.0, -1.0, 1.0}
-        };
+        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}
-        };
+        double[][] expectedU = {{2.0, -1.0, -2.0}, {0.0, 4.0, -1.0}, {0.0, 0.0, 3.0}};
 
         assertMatrixEquals(expectedL, result.getL());
         assertMatrixEquals(expectedU, result.getU());
     }
 
     @Test
     void testIdentityMatrix() {
-        double[][] identity = {
-            {1, 0, 0},
-            {0, 1, 0},
-            {0, 0, 1}
-        };
+        double[][] matrix = {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}};
 
-        LUDecomposition.Result result = LUDecomposition.decompose(identity);
+        LUDecomposition.Result result = LUDecomposition.decompose(matrix);
 
-        assertMatrixEquals(identity, result.getL());
-        assertMatrixEquals(identity, result.getU());
+        assertMatrixEquals(matrix, result.getL());
+        assertMatrixEquals(matrix, result.getU());
     }
 
     @Test
-    void testTwoByTwoMatrix() {
-        double[][] matrix = {
-            {4, 3},
-            {6, 3}
-        };
-
-        LUDecomposition.Result result = LUDecomposition.decompose(matrix);
+    void testSingularMatrix() {
+        double[][] matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
 
-        double[][] expectedL = {
-            {1.0, 0.0},
-            {1.5, 1.0}
-        };
+        assertThrows(IllegalArgumentException.class, () -> LUDecomposition.decompose(matrix));
+    }
 
-        double[][] expectedU = {
-            {4.0, 3.0},
-            {0.0, -1.5}
-        };
+    @Test
+    void testEmptyMatrix() {
+        double[][] matrix = {};
 
-        assertMatrixEquals(expectedL, result.getL());
-        assertMatrixEquals(expectedU, result.getU());
+        assertThrows(IllegalArgumentException.class, () -> LUDecomposition.decompose(matrix));
     }
 
     @Test
     void testNonSquareMatrix() {
-        double[][] nonSquare = {
-            {1, 2, 3},
-            {4, 5, 6}
-        };
+        double[][] matrix = {{1, 2, 3}, {4, 5, 6}};
 
-        assertThrows(IllegalArgumentException.class, () -> LUDecomposition.decompose(nonSquare));
+        assertThrows(IllegalArgumentException.class, () -> LUDecomposition.decompose(matrix));
     }
 
     @Test
-    void testEmptyMatrix() {
-        double[][] empty = {};
+    void testTwoByTwoMatrix() {
+        double[][] matrix = {{4, 3}, {6, 3}};
 
-        assertThrows(IllegalArgumentException.class, () -> LUDecomposition.decompose(empty));
-    }
+        LUDecomposition.Result result = LUDecomposition.decompose(matrix);
 
-    @Test
-    void testSingularMatrix() {
-        double[][] singular = {
-            {1, 2, 3},
-            {2, 4, 6},
-            {3, 6, 9}
-        };
+        double[][] expectedL = {{1.0, 0.0}, {1.5, 1.0}};
+
+        double[][] expectedU = {{4.0, 3.0}, {0.0, -1.5}};
 
-        assertThrows(IllegalArgumentException.class, () -> LUDecomposition.decompose(singular));
+        assertMatrixEquals(expectedL, result.getL());
+        assertMatrixEquals(expectedU, result.getU());
     }
 
     private void assertMatrixEquals(double[][] expected, double[][] actual) {