fix: Resolve checkstyle violations in LUDecomposition

Author: Raghu0703

src/main/java/com/thealgorithms/matrix/LUDecomposition.java

@@ -1,40 +1,13 @@
 package com.thealgorithms.matrix;
 
 /**
- * LU Decomposition algorithm
- * --------------------------
- * Decomposes a square matrix a into a product of two matrices:
- * a = l * u
- * where:
- * - l is a lower triangular matrix with 1s on its diagonal
- * - u is an upper triangular matrix
- *
- * Reference:
- * https://en.wikipedia.org/wiki/lu_decomposition
- */
-public final class LUDecomposition {
-
-    private LUDecomposition() {
-    }
-
-    /**
-     * A helper class to store both l and u matrices
-     */
-    public static class LU {
-        double[][] l;
-        double[][] u;
-
-        LU(double[][] l, double[][] u) {
-package com.thealgorithms.matrix;
-
-/**
- * LU Decomposition algorithm for square matrices
+ * LU Decomposition algorithm for square matrices.
  * Decomposes a matrix A into L (lower triangular) and U (upper triangular)
  * such that A = L * U
- * 
- * Time Complexity: O(n^3)
- * Space Complexity: O(n^2)
- * 
+ *
+ * <p>Time Complexity: O(n^3)
+ * <p>Space Complexity: O(n^2)
+ *
  * @author Raghu0703
  * @see <a href="https://en.wikipedia.org/wiki/LU_decomposition">LU Decomposition</a>
  */
@@ -43,15 +16,15 @@ private LUDecomposition() {
     }
 
     /**
-     * Performs LU decomposition on a square matrix using Doolittle's method
-     * 
+     * Performs LU decomposition on a square matrix using Doolittle's method.
+     *
      * @param matrix The input square matrix
      * @return A Result object containing L and U matrices
      * @throws IllegalArgumentException if matrix is not square or singular
      */
     public static Result decompose(double[][] matrix) {
         int n = matrix.length;
-        
+
         // Validate input
         if (n == 0) {
             throw new IllegalArgumentException("Matrix cannot be empty");
@@ -61,15 +34,15 @@ public static Result decompose(double[][] matrix) {
                 throw new IllegalArgumentException("Matrix must be square");
             }
         }
-        
+
         double[][] l = new double[n][n];
         double[][] u = new double[n][n];
-        
+
         // Initialize L with identity matrix
         for (int i = 0; i < n; i++) {
             l[i][i] = 1.0;
         }
-        
+
         // Perform LU decomposition using Doolittle's method
         for (int j = 0; j < n; j++) {
             // Calculate U matrix elements
@@ -80,41 +53,59 @@ public static Result decompose(double[][] matrix) {
                 }
                 u[i][j] = matrix[i][j] - sum;
             }
-            
+
             // Calculate L matrix elements
             for (int i = j + 1; i < n; i++) {
                 double sum = 0.0;
                 for (int k = 0; k < j; k++) {
                     sum += l[i][k] * u[k][j];
                 }
-                
+
                 if (Math.abs(u[j][j]) < 1e-10) {
-                    throw new IllegalArgumentException("Matrix is singular or nearly singular");
+                    throw new IllegalArgumentException(
+                        "Matrix is singular or nearly singular"
+                    );
                 }
-                
+
                 l[i][j] = (matrix[i][j] - sum) / u[j][j];
             }
         }
-        
+
         return new Result(l, u);
     }
-    
+
     /**
-     * Result class to hold L and U matrices from decomposition
+     * Result class to hold L and U matrices from decomposition.
      */
     public static class Result {
         private final double[][] lMatrix;
         private final double[][] uMatrix;
-        
+
+        /**
+         * Constructor for Result.
+         *
+         * @param l Lower triangular matrix
+         * @param u Upper triangular matrix
+         */
         public Result(double[][] l, double[][] u) {
             this.lMatrix = l;
             this.uMatrix = u;
         }
-        
+
+        /**
+         * Gets the lower triangular matrix.
+         *
+         * @return L matrix
+         */
         public double[][] getL() {
             return lMatrix;
         }
-        
+
+        /**
+         * Gets the upper triangular matrix.
+         *
+         * @return U matrix
+         */
         public double[][] getU() {
             return uMatrix;
         }