Doolittle Algorithm : LU Decomposition

In numerical analysis and linear algebra, LU decomposition (where ‘LU’ stands for ‘lower upper’, and also called LU factorization) factors a matrix as the product of a lower triangular matrix and an upper triangular matrix. Computers usually solve square systems of linear equations using the LU decomposition, and it is also a key step when inverting a matrix, or computing the determinant of a matrix. The LU decomposition was introduced by mathematician Tadeusz Banachiewicz in 1938.

Let A be a square matrix. An LU factorization refers to the factorization of A, with proper row and/or column orderings or permutations, into two factors, a lower triangular matrix L and an upper triangular matrix U, A=LU.

Doolittle Algorithm:

It is always possible to factor a square matrix into a lower triangular matrix and an upper triangular matrix. That is, [A] = [L][U]
Doolittle’s method provides an alternative way to factor A into an LU decomposition without going through the hassle of Gaussian Elimination.
For a general n×n matrix A, we assume that an LU decomposition exists, and write the form of L and U explicitly. We then systematically solve for the entries in L and U from the equations that result from the multiplications necessary for A=LU.

Terms of U matrix are given by:

And the terms for L matrix:

Example : 

Input : 

Output :

Implementation:

Java

// Java Program to decompose a matrix into
// lower and upper triangular matrix
class GFG {

    static int MAX = 100;
    static String s = "";
    static void luDecomposition(int[][] mat, int n)
    {
        int[][] lower = new int[n][n];
        int[][] upper = new int[n][n];

        // Decomposing matrix into Upper and Lower
        // triangular matrix
        for (int i = 0; i < n; i++)
        {
            // Upper Triangular
            for (int k = i; k < n; k++)
            {
                // Summation of L(i, j) * U(j, k)
                int sum = 0;
                for (int j = 0; j < i; j++)
                    sum += (lower[i][j] * upper[j][k]);

                // Evaluating U(i, k)
                upper[i][k] = mat[i][k] - sum;
            }

            // Lower Triangular
            for (int k = i; k < n; k++)
            {
                if (i == k)
                    lower[i][i] = 1; // Diagonal as 1
                else
                {
                    // Summation of L(k, j) * U(j, i)
                    int sum = 0;
                    for (int j = 0; j < i; j++)
                        sum += (lower[k][j] * upper[j][i]);

                    // Evaluating L(k, i)
                    lower[k][i]
                        = (mat[k][i] - sum) / upper[i][i];
                }
            }
        }

        // setw is for displaying nicely
        System.out.println(setw(2) + "     Lower Triangular"
                           + setw(10) + "Upper Triangular");

        // Displaying the result :
        for (int i = 0; i < n; i++)
        {
            // Lower
            for (int j = 0; j < n; j++)
                System.out.print(setw(4) + lower[i][j]
                                 + "\t");
            System.out.print("\t");

            // Upper
            for (int j = 0; j < n; j++)
                System.out.print(setw(4) + upper[i][j]
                                 + "\t");
            System.out.print("\n");
        }
    }
    static String setw(int noOfSpace)
    {
        s = "";
        for (int i = 0; i < noOfSpace; i++)
            s += " ";
        return s;
    }

    // Driver code
    public static void main(String arr[])
    {
        int mat[][] = { { 2, -1, -2 },
                        { -4, 6, 3 },
                        { -4, -2, 8 } };

        luDecomposition(mat, 3);
    }
}

/* This code contributed by PrinciRaj1992 */

Python3

# Python3 Program to decompose
# a matrix into lower and
# upper triangular matrix
MAX = 100


def luDecomposition(mat, n):

    lower = [[0 for x in range(n)]
             for y in range(n)]
    upper = [[0 for x in range(n)]
             for y in range(n)]

    # Decomposing matrix into Upper
    # and Lower triangular matrix
    for i in range(n):

        # Upper Triangular
        for k in range(i, n):

            # Summation of L(i, j) * U(j, k)
            sum = 0
            for j in range(i):
                sum += (lower[i][j] * upper[j][k])

            # Evaluating U(i, k)
            upper[i][k] = mat[i][k] - sum

        # Lower Triangular
        for k in range(i, n):
            if (i == k):
                lower[i][i] = 1  # Diagonal as 1
            else:

                # Summation of L(k, j) * U(j, i)
                sum = 0
                for j in range(i):
                    sum += (lower[k][j] * upper[j][i])

                # Evaluating L(k, i)
                lower[k][i] = int((mat[k][i] - sum) /
                                  upper[i][i])

    # setw is for displaying nicely
    print("Lower Triangular\t\tUpper Triangular")

    # Displaying the result :
    for i in range(n):

        # Lower
        for j in range(n):
            print(lower[i][j], end="\t")
        print("", end="\t")

        # Upper
        for j in range(n):
            print(upper[i][j], end="\t")
        print("")


# Driver code
mat = [[2, -1, -2],
       [-4, 6, 3],
       [-4, -2, 8]]

luDecomposition(mat, 3)

# This code is contributed by mits

C#

// C# Program to decompose a matrix into
// lower and upper triangular matrix
using System;

class GFG {

    static int MAX = 100;
    static String s = "";
    static void luDecomposition(int[, ] mat, int n)
    {
        int[, ] lower = new int[n, n];
        int[, ] upper = new int[n, n];

        // Decomposing matrix into Upper and Lower
        // triangular matrix
        for (int i = 0; i < n; i++)
        {
            // Upper Triangular
            for (int k = i; k < n; k++)
            {
                // Summation of L(i, j) * U(j, k)
                int sum = 0;
                for (int j = 0; j < i; j++)
                    sum += (lower[i, j] * upper[j, k]);

                // Evaluating U(i, k)
                upper[i, k] = mat[i, k] - sum;
            }

            // Lower Triangular
            for (int k = i; k < n; k++)
            {
                if (i == k)
                    lower[i, i] = 1; // Diagonal as 1
                else
                {
                    // Summation of L(k, j) * U(j, i)
                    int sum = 0;
                    for (int j = 0; j < i; j++)
                        sum += (lower[k, j] * upper[j, i]);

                    // Evaluating L(k, i)
                    lower[k, i]
                        = (mat[k, i] - sum) / upper[i, i];
                }
            }
        }

        // setw is for displaying nicely
        Console.WriteLine(setw(2) + "     Lower Triangular"
                          + setw(10) + "Upper Triangular");

        // Displaying the result :
        for (int i = 0; i < n; i++)
        {
            // Lower
            for (int j = 0; j < n; j++)
                Console.Write(setw(4) + lower[i, j] + "\t");
            Console.Write("\t");

            // Upper
            for (int j = 0; j < n; j++)
                Console.Write(setw(4) + upper[i, j] + "\t");
            Console.Write("\n");
        }
    }
    static String setw(int noOfSpace)
    {
        s = "";
        for (int i = 0; i < noOfSpace; i++)
            s += " ";
        return s;
    }

    // Driver code
    public static void Main(String[] arr)
    {
        int[, ] mat = { { 2, -1, -2 },
                        { -4, 6, 3 },
                        { -4, -2, 8 } };

        luDecomposition(mat, 3);
    }
}

// This code is contributed by Princi Singh

PHP

<?php
// PHP Program to decompose
// a matrix into lower and
// upper triangular matrix
$MAX = 100;

function luDecomposition($mat, $n)
{
    $lower;
    $upper;
    for($i = 0; $i < $n; $i++)
    for($j = 0; $j < $n; $j++)
    {
        $lower[$i][$j]= 0;
        $upper[$i][$j]= 0;
    }
    // Decomposing matrix
    // into Upper and Lower
    // triangular matrix
    for ($i = 0; $i < $n; $i++)
    {

        // Upper Triangular
        for ($k = $i; $k < $n; $k++)
        {

            // Summation of
            // L(i, j) * U(j, k)
            $sum = 0;
            for ($j = 0; $j < $i; $j++)
                $sum += ($lower[$i][$j] *
                         $upper[$j][$k]);

            // Evaluating U(i, k)
            $upper[$i][$k] = $mat[$i][$k] - $sum;
        }

        // Lower Triangular
        for ($k = $i; $k < $n; $k++)
        {
            if ($i == $k)
                $lower[$i][$i] = 1; // Diagonal as 1
            else
            {

                // Summation of L(k, j) * U(j, i)
                $sum = 0;
                for ($j = 0; $j < $i; $j++)
                    $sum += ($lower[$k][$j] *
                             $upper[$j][$i]);

                // Evaluating L(k, i)
                $lower[$k][$i] = (int)(($mat[$k][$i] -
                                $sum) / $upper[$i][$i]);
            }
        }
    }

    // setw is for
    // displaying nicely
    echo "\t\tLower Triangular";
    echo "\t\t\tUpper Triangular\n";

    // Displaying the result :
    for ($i = 0; $i < $n; $i++)
    {
        // Lower
        for ($j = 0; $j < $n; $j++)
            echo "\t" . $lower[$i][$j] . "\t";
        echo "\t";

        // Upper
        for ($j = 0; $j < $n; $j++)
        echo $upper[$i][$j] . "\t";
        echo "\n";
    }
}

// Driver code
$mat = array(array(2, -1, -2),
             array(-4, 6, 3),
             array(-4, -2, 8));

luDecomposition($mat, 3);

// This code is contributed by mits
?>

Javascript

<script>

// Javascript Program to decompose a matrix
// into lower and upper triangular matrix
// function MAX = 100;
var s = "";

function luDecomposition(mat, n)
{
    var lower = Array(n).fill(0).map(
           x => Array(n).fill(0));
    var upper = Array(n).fill(0).map(
           x => Array(n).fill(0));

    // Decomposing matrix into Upper and
    // Lower triangular matrix
    for(var i = 0; i < n; i++)
    {

        // Upper Triangular
        for(var k = i; k < n; k++)
        {

            // Summation of L(i, j) * U(j, k)
            var sum = 0;
            for(var j = 0; j < i; j++)
                sum += (lower[i][j] * upper[j][k]);

            // Evaluating U(i, k)
            upper[i][k] = mat[i][k] - sum;
        }

        // Lower Triangular
        for(var k = i; k < n; k++)
        {
            if (i == k)

                // Diagonal as 1
                lower[i][i] = 1;
            else
            {

                // Summation of L(k, j) * U(j, i)
                var sum = 0;
                for(var j = 0; j < i; j++)
                    sum += (lower[k][j] * upper[j][i]);

                // Evaluating L(k, i)
                lower[k][i] = parseInt((mat[k][i] - sum) /
                                      upper[i][i]);
            }
        }
    }

    // Setw is for displaying nicely
    document.write(setw(2) + "Lower Triangular" +
                   setw(10) + "Upper Triangular<br>");

    // Displaying the result :
    for(var i = 0; i < n; i++)
    {

        // Lower
        for(var j = 0; j < n; j++)
            document.write(setw(4) +
                           lower[i][j] + "\t");

        document.write(setw(10));

        // Upper
        for(var j = 0; j < n; j++)
            document.write(setw(4) +
                           upper[i][j] + "\t");

        document.write("<br>");
    }
}

function setw(noOfSpace)
{
    var s = "";
    for(i = 0; i < noOfSpace; i++)
        s += " ";

    return s;
}

// Driver code
var mat = [ [ 2, -1, -2 ],
            [ -4, 6, 3 ],
            [ -4, -2, 8 ] ];

luDecomposition(mat, 3);

// This code is contributed by Amit Katiyar

</script>

Output

      Lower Triangular                Upper Triangular
     1         0         0             2        -1        -2    
    -2         1         0             0         4        -1    
    -2        -1         1             0         0         3