LUDecomposition

package ludecompose;

import java.util.Scanner;

/**
 *
 * @author Nikodem
 */
public class LUDecompose {

   public static void main(String[] args) {

        //======================================
        // ** Define variables
        //======================================

        double[][] A;

        //======================================
        // ** Get data from user
        //======================================

        System.out.println("Enter matrix dimension: ");
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        // Initialize vars
        A = new double[n][n];

        System.out.println("Enter left-side matrix: ");
        for(int i=0; i<n; i++)
            for(int j=0; j<n; j++)
                A[i][j] = sc.nextDouble();
        //=============================================
        // ** Create l and u matrices
        //=============================================
        double [][]l = new double[n][n];
        double [][]u = new double[n][n];
        //=============================================
        // ** Calculate for n = 2
        //=============================================
        if(n==2){
            l[0][0] = l[1][1] = 1;
            l[0][1] = 0;
            u[1][0] = 0;
            u[0][0] = A[0][0];
            u[0][1] = A[0][1];
            l[1][0] = A[1][0]/A[0][0];
            u[1][1] = A[1][1] - (l[1][0]*u[0][1]);
        //=============================================
        // ** Calculate for n = 3
        //=============================================
        } else if(n==3){
            l[0][0] = l[1][1] = l[2][2] = 1;
            l[0][1] = l[0][2] = l[1][2] = 0;
            u[1][0] = u[2][0] = u[2][1] = 0;
            u[0][0] = A[0][0];
            u[0][1] = A[0][1];
            u[0][2] = A[0][2];
            l[1][0] = A[1][0]/A[0][0];
            u[1][1] = A[1][1] - (l[1][0]*u[0][1]);
            u[1][2] = A[1][2] - (l[1][0]*u[0][2]);
            l[2][0] = A[2][0]/u[0][0];
            l[2][1] = (A[2][1] - l[2][1]*u[0][1])/u[1][1];
            u[2][2] = A[2][2] - (l[2][0]*u[0][2]) - (l[2][1]*u[1][2]);
        } else {
            System.out.println("Only 2 and 3 dimensional matrices are supported");
        }
        System.out.println("L matrix: ");
            for(int i=0; i<n; i++){
                for(int j=0; j<n; j++){
                    System.out.print(" "+l[i][j]);
                }
                System.out.println();
            }
            System.out.println("U matrix: ");
            for(int i=0; i<n; i++){
                for(int j=0; j<n; j++){
                    System.out.print(" "+u[i][j]);
                }
                System.out.println();
            }
        sc.close();
    }

}