Doolittle Algorithm : LU Decomposition - GeeksforGeeks

12 Jun, 2021
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 :
C++
Java
Python3
C#
PHP
Javascript
// C++ Program to decompose a matrix into// lower and upper triangular matrix#include <bits/stdc++.h>using namespace std; const int MAX = 100; void luDecomposition(int mat[][MAX], int n){    int lower[n][n], upper[n][n];    memset(lower, 0, sizeof(lower));    memset(upper, 0, sizeof(upper));     // 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    cout << setw(6)         << "      Lower Triangular"         << setw(32)         << "Upper Triangular" << endl;     // Displaying the result :    for (int i = 0; i < n; i++)    {        // Lower        for (int j = 0; j < n; j++)            cout << setw(6) << lower[i][j] << "\t";        cout << "\t";         // Upper        for (int j = 0; j < n; j++)            cout << setw(6) << upper[i][j] << "\t";        cout << endl;    }} // Driver codeint main(){    int mat[][MAX]        = { { 2, -1, -2 }, { -4, 6, 3 }, { -4, -2, 8 } };     luDecomposition(mat, 3);    return 0;}
// Java Program to decompose a matrix into// lower and upper triangular matrixclass 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 Program to decompose# a matrix into lower and# upper triangular matrixMAX = 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 codemat = [[2, -1, -2],       [-4, 6, 3],       [-4, -2, 8]] luDecomposition(mat, 3) # This code is contributed by mits
// C# Program to decompose a matrix into// lower and upper triangular matrixusing 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 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?>
<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 codevar 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    
This article is contributed by Shubham Rana. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
Mithun Kumar
princiraj1992
princi singh
jesaldkotak
agchiper45
amit143katiyar
simranarora5sos
Engineering Mathematics
Mathematical
Matrix
Mathematical
Matrix
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Inequalities in LaTeX
Newton's Divided Difference Interpolation Formula
Arrow Symbols in LaTeX
Set Notations in LaTeX
Activation Functions
Program for Fibonacci numbers
C++ Data Types
Write a program to print all permutations of a given string
Set in C++ Standard Template Library (STL)
Coin Change | DP-7