# 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.

Example :

```Input :

Output :

```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

```// CPP Program to decompose a matrix into
// lower and upper traingular 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 code
int main()
{
int mat[][MAX] = { { 2, -1, -2 },
{ -4, 6, 3 },
{ -4, -2, 8 } };

luDecomposition(mat, 3);
return 0;
}
```

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 contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

# GATE CS Corner    Company Wise Coding Practice

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.
2 Average Difficulty : 2/5.0
Based on 2 vote(s)