Descomposición LU

e inversión de
matrices
ESTUDIANTES:
Ruth Luna
Christian Velarde
 INTRODUCCIÓN
la descomposición LU, en el paso de la eliminación que toma mucho tiempo,
se implementa del método de eliminación de Gauss y permite formular sólo
operaciones con la matriz de coeficientes [A]. Por esto, es adecuado para
situaciones donde se evalúan muchos vectores {B} del lado derecho para un
solo valor de [A].
Además, la introducción de la descomposición LU proporciona un medio
eficiente para calcular la matriz inversa. La inversa tiene muchas
aplicaciones valiosas en la práctica de la ingeniería. Ésta ofrece también un
medio para evaluar la condición de un sistema.
En un sistema de ecuaciones lineales:

𝑎11 𝑎12 𝑎13 𝑥1 𝑏1

Matriz Matriz 𝑎21 𝑎22 𝑎23 𝑥2 = 𝑏2
[A]{X} = {B}
cuadrada columna 𝑎31 𝑎32 𝑎33 𝑥3 𝑏3
Matriz
incógnita
Variable de
desicion

𝑎11 𝑎12 𝑎13

Matriz triangular ′ ′
superior 𝑈 = 0 𝑎22 𝑎23
′′
0 0 𝑎33
Matriz [A] → [L][U]
cuadrada 1 0 0
Matriz triangular 𝐿 = 𝑓21 1 0
inferior 𝑓31 𝑓32 1
 VARIANTES
DOOLITTLE CROUT
• L tiene la • U tiene la
diagonal de 1 diagonal de 1
 Ejemplo: Un ingeniero civil que trabaja en la construcción requiere 180𝑚 , 115𝑚 , y 86𝑚 , de arena, grava
3 3 3

fina, y grava gruesa, respectivamente, para muestras. Hay tres canteras de las que puede obtenerse dichos
materiales. La composición de dichas canteras es la siguiente tabla:

CANTERA ARENA GRAVA GRAVA

FINA GRUESA
C1 60 30 20
C2 30 20 15
C3 20 15 12

¿Cuántos metros cúbicos deben extraerse de cada cantera a fin de satisfacer las necesidades del ingeniero?

REPRESENTACIÓN COMO MATRIZ

AX=B
Grava 60𝑥1 + 30𝑥2 + 20𝑥3 = 180
. 60 30 20 𝑥1 180
Arena 30𝑥1 + 20𝑥2 + 15𝑥3 = 115 30 20 15 𝑥2 = 115
. 20 15 12 𝑥3 86
Agua 20𝑥1 + 15𝑥2 + 12𝑥3 = 86

https://es.scribd.com/document/382024593/Ejercicio-de-Matrices-Aplicada-a-La-Ingenieria-Civil#
→1° PASO DE LA DESCOMPOSICIÓN La matriz A se puede factorizar como:

(Para hallar U y de ahí L)

1
• 𝐸1 = 𝐹2 → 𝐹2 − 2 𝐹1

60 30 20 1 0 0
1 60 30 20
0 5 5 60 30 20
20 15 12
1 0 0 5 5
30 20 15 = 2 1
1 20 15 12 1 0 0
• 𝐸2 = 𝐹3 → 𝐹3 − 3 𝐹1 1 1 3
3
60 30 20
0 5 5
16
0 5
3

• 𝐸3 = 𝐹3 → 𝐹3 − 𝐹2

60 30 20
0 5 5
1
0 0
3
→2° PASO DE LA SUSTITUCIÓN • El segundo paso es resolver UX=D

• El primer paso es resolver LD=B

1 0 0 60 30 20 𝑥
1 𝑑1 180 1 180
1 0 0 5 5 𝑥
2 𝑑2 = 115 1 2 = 25
1 𝑑3 86 0 0 𝑥3 1
1 1 3
3
Utilizando la sustitución hacia atrás, se tiene:
Utilizando la sustitución hacia adelante
𝑥1 = 1 𝑥2 = 2 𝑥3 = 3
𝑑1 = 180 𝑑2 = 25 𝑑3 = 1
⸫Los metros cúbicos que se deben extraer de
Luego: cada cantera a fin de satisfacer las
180
necesidades del ingeniero son dados por la
𝐷= 25 1
1 siguiente matriz: 𝑥 = 2
3
PROGRAMA DE LA DESCOMPOSICIÓN LU (CROUT) EN C++
#include <stdio.h> A=(float**)malloc((n)*sizeof(float));
#include <stdlib.h> for(i=0;i<n+1;i++){
#include <memory.h> A[i]=(float*)malloc(sizeof(float));
}
/* /*Creamos la Matriz L*/
By ZtuX 2012 if((L=(float**)malloc(n*sizeof(float*)))==NULL){
Metodo LU printf("[!] Insuficiente espacio en la
tuxo.root@gmail.com Memoria\n");
http://ztux.blogspot.mx/ return -1;
*/ }
L=(float**)malloc(n*sizeof(float));
void ShowMatrix(float **Matrix, int n); for(i=0;i<n;i++){
void CreateMatrix(float **Matrix, int n); L[i]=(float*)malloc(n*sizeof(float));
void Llenar(float **Matrix, int n); }
float **SolveGaussJordan(int n, float **MatrixA, float /*CREAR LA MATRIZ U*/
**MatrixB); if((U=(float**)malloc(n*sizeof(float*)))==NULL){
printf("[!] Insuficiente espacio en la
int main(){ Memoria\n");
int n,i,j,s,k; return -1;
float }
**L=NULL,**U=NULL,**A=NULL,Suma=0,Op=0,*Ap,Numer= U=(float**)malloc(n*sizeof(float));
0,Denom=0; for(i=0;i<n;i++){
printf("Resolver por mtodo de Factorizacion LU\nIngrese el U[i]=(float*)malloc(n*sizeof(float));
numero de Variables: "); }
scanf("%i",&n); //Introducimos Valores a A
//Crear la Matriz A for(i=0;i<n;i++){
if((A=(float**)malloc(n*sizeof(float*)))==NULL){ for(j=0;j<n+1;j++){
printf("[!] Insuficiente espacio en la Memoria\n"); printf("Introduce el valor [%i][%i]: ",i,j);
return -1; scanf("%f",&A[i][j]);
} }
}
 //FIN
//MOSTRAMOS SISTEMA ECUACIONES //DESDE j=(k+1) HASTA n
printf("MATRIZ QUE REPRESENTA A EL SISTEMA DE ECUACIONES\n"); for(j=(k+1);j<n;j++){
for(i=0;i<n;i++){ //SUMATORIA
printf("["); for(s=0;s<=(k-1);s++){
for(j=0;j<n+1;j++){ Op=L[k][s]*U[s][j];
printf("\t%0.2f\t",A[i][j]); Suma+=Op;
if (j==n-1) printf("|"); }
} //FIN SUMATORIA
printf("]\n"); Numer=A[k][j]-Suma;
} Denom=L[k][k];
//LENAR MATRICES DE CEROS U[k][j]=Numer/Denom;
Llenar(U,n); *Ap=0;
Llenar(L,n); }
Ap=&Suma;//Apuntamos a Suma //FIN
//[!]AQUI EMPIEZA EL CALCULO DE LAS MATRICES L y U }//FIN
//DESDE k=1 HASTA n //[!]AQUI TERMINA EL CALCULO DE LAS MATRICES L y U
for(k=0;k<n;k++){ printf("\nMatriz L:\n");
U[k][k]=1; ShowMatrix(L,n);
//SUMATORIA printf("\nMatriz U:\n");
for(s=0;s<=(k-1);s++){ ShowMatrix(U,n);
Op=L[k][s]*U[s][k]; //[!]RESOLVEREMOS LOS SISTEMAS DE ECUACIONES CON GAUSS-JORDAN
Suma+=Op; //Ly=B y depues PARA Ux=y y Se mostraran los valores de las incognitas =)
} printf("\n[+]Resolviendo Ly=b:\n");
//FIN SUMATORIA A=SolveGaussJordan(n,L,A); //Apuntamos la matriz que nos regresa a la Matriz A Nueva =)
L[k][k]=A[k][k]-Suma; printf("\n[+]Resolviendo Ux=y:\n");
*Ap=0; SolveGaussJordan(n,U,A); // Se mostrara la matriz solucion al Sistema de Ecuaciones =)
//DESDE i=(k+1) HASTA n //LIBERAR MEMORIA
for(i=(k+1);i<n;i++){ for(i=0;i<n;i++){
//SUMATORIA free(A[i]);
for(s=0;s<=(k-1);s++){ free(L[i]);
Op=L[i][s]*U[s][k]; free(U[i]);
Suma+=Op; }
} free(A);
//FIN SUMATORIA free(L);
L[i][k]=A[i][k]-Suma; free(U);
*Ap=0; return 0;
} }
void ShowMatrix(float **Matrix, int n){ printf("\t[-]Matriz ques representa el printf("\n");
int i,j; sistema:\n"); for(j=0;j<n;j++){
for(i=0;i<n;i++){ for(i=0;i<n;i++){ printf("[ ");
printf("["); printf("[ "); for(k=0; k<n+1; k++){
for(j=0;j<n;j++) printf(" %0.2f ",Matrix[i][j]); for(j=0; j<n+1; j++){ printf("\t%.2f\t", A[j][k]);
printf("]\n"); printf("\t%.2f\t", A[i][j]); }
} } printf(" ]\n");
} printf(" ]\n"); }
} }
void CreateMatrix(float **Matrix, int n){ return A;
int i,j; for(i=0;i<n;i++){ }
for(i=0;i<n;i++){ k=1;
for(j=0;j<n;j++){ do{
printf("Introduce el valor [%i][%i]: ",i,j); apoyo=A[i][i];
scanf("%f",&Matrix[i][j]); if(apoyo==0){
} for(j=0; j<n+1; j++){
} matapoyo[j]=A[i][j];
} }
for(j=0; j<n+1; j++){
void Llenar(float **Matrix, int n){ A[i][j]=A[i+k][j];
int i; for(i=0;i<n;i++) memset(Matrix[i],0,n*sizeof(float)); }
} for(j=0; j<n+1; j++){
A[i+k][j]=matapoyo[j];
float **SolveGaussJordan(int n, float **MatrixA, float **MatrixB){ }
float **A, apoyo; }
int i, j, k; k++;
float matapoyo[n+1]; }while(apoyo==0);
A=(float**)malloc(sizeof(float*)*n);
for(i=0;i<n+1;i++){ for(j=0;j<n+1;j++) A[i][j]=A[i][j]/apoyo;
A[i]=(float*)malloc(sizeof(float)*n);
} for(j=0;j<n+1;j++){
for(i=0;i<n;i++){ if(i!=j){
for(j=0; j<n+1; j++){ apoyo=-1*A[j][i];
if(j<=n-1) A[i][j]=MatrixA[i][j]; for(k=0; k<n+1; k++){
else A[i][j]=MatrixB[i][j]; A[j][k]=A[j][k]+(apoyo*A[i][k]);
} }
} }
}
 −1
[𝐴][𝐴]−1 = [𝐴] [𝐴] = [𝐼]
Ejemplo (empleando anteriormente)

1 0 0 Para la ecuación UX=D

1 60 30 20 1
60 30 20 60 30 20 𝑥 1
1 0 0 5 5 1
𝐴 = 30 20 15 = 2 1 0 5 5 𝑥 −
1 1 2 = 2
20 15 12 0 0
1 1 3 0 0 𝑥3 1
3 3
6
• Con la ecuación LD=B Entonces
1 0 0 1 Por sustitución hacia atrás
1 𝑑1 1 3
1 −
1 0 20
2 𝑑2 = 0 𝐷= 2
1 𝑑3 0 1 3
1 1 𝑋= −
3 6 5
1
2

que es la primera columna de

la matriz
Ejemplo (empleando anteriormente)

1 0 0 Para la ecuación UX=D

1 60 30 20 60 30 20 𝑥
60 30 20 1 0
1 0 0 5 5 0 5 5 𝑥
𝐴 = 30 20 15 = 2 1 2 = 1
1
20 15 12 1 0 0 0 0 𝑥3 −1
1 1 3 3
3

• Con la ecuación LD=B Entonces

1 0 0 0 Por sustitución hacia atrás
1 𝑑1 𝐷= 1 3
0 −
1 0 5
2 𝑑2 = 1 −1
1 𝑑3 𝑋 = 16
0
1 1 5
3
−3

que es la segunda columna de

la matriz
Ejemplo (empleando anteriormente)

1 0 0 Para la ecuación UX=D

1 60 30 20 60 30 20 𝑥
60 30 20 1 0
1 0 0 5 5 0 5 5 𝑥
𝐴 = 30 20 15 = 2 1 2 = 0
1
20 15 12 1 0 0 0 0 𝑥3 1
1 1 3 3
3

• Con la ecuación LD=B Entonces

1 0 0 0 Por sustitución hacia atrás
1 𝑑1 𝐷= 0 1
0
1 0
2 𝑑2 = 0 1 𝑋= 2
1 𝑑3 1 −3
1 1 3
3

que es la tercera columna de la

matriz
 Obteniendo así:

3 3 1
−
20 5 2
−1 3 16
𝐴 = − −3
5 5
1
−3 3
2
 3 3 1 3 3 1
− −
20 5 2 20 5 2
3 16 60 30 20 60 30 20 3 16
− −3 30 20 15 = 30 20 15 − −3
5 5 20 15 12 20 15 12 5 5
1 1
−3 3 −3 3
2 2

1 0 0
= 0 1 0
0 0 1
 PROGRAMA DE LA MATRIZ INVERSA EN C++
cin>>a02;
#include <iostream> //diva

using namespace std; cout<<"a10: ";

int main(){ cin>>a10;

double a00,a01,a02,a10,a11,a12,a20,a21,a22,total; cout<<"a11: ";

cout<<"Ingrese los valores:"<<endl;
cin>>a11;
cout<<"|a00 a01 a02|" <<endl;
cout<<"a12: ";
cout<<"|a10 a11 a12|" <<endl;
cin>>a12;
cout<<"|a20 a21 a22|" <<endl;
cout<<"a20: ";
cout<<"a00: ";
cin>>a20;
cin>>a00;
cout<<"a21: ";
cout<<"a01: ";
cin>>a21;
cin>>a01;
cout<<"a22: ";
cout<<"a02: ";
cin>>a22;
 /
/*
total<<' '<<((a00*a12-a10*a02)*-1)/total<<endl;
!a00 a10 a20! l2a00 l2a10

!a01 a11 a21! l2a01 l2a11 cout<<((a10*a21-a20*a11))/total<<' '<<((a00*a21-a20*a01)*-1)

!a02 a12 a22! l2a02 l2a12 /

*/ total<<' '<<(a00*a11-a10*a01)/total<<endl;

total=a00*a11*a22 + a10*a21*a02 +a20*a01*a12; cout<<"Determinante 3x3: "<<total;

total=total+(a02*a11*a20)*-1 + (a12*a21*a00)*-1 + (a22*a01*a10)*-1;

if(total!=0) else{

{ cout<<"Error el det. da 0";

cout<<(a11*a22-a21*a12)/total<<' '<<((a01*a22-a21*a02)*-1) }

/ }

total<<' '<<(a01*a12-a11*a02)/total<<endl;

cout<<((a10*a22-a20*a12)*-1)/total<<' '<<((a00*a22-a20*a02))
• Se emplea para el análisis de un balance de masa para modelar un
sistema de reactores, conservación de la masa. (Ingeniería química)

• Se emplea haciendo uso de la matriz inversa para determinar las

complicadas interacciones causa – efecto entre las fuerzas en los
elementos de una armadura. Es un problema importante en la
ingeniería estructural, hallar las fuerzas y reacciones asociadas con
una armadura estáticamente determinada. (Ingeniería civil).

• Se emplea en el uso de las leyes de Kirchhoff para calcular las

corrientes y voltajes en un circuito con resistores (Ingeniería
eléctrica).

• Se emplean las ecuaciones lineales para determinar la

configuración en estado estacionario de un sistema masa –
resorte. (Ingeniería mecánica / aeronáutica).
 CONCLUSIONES

Cualquier matriz
no singular se
puede descomponer
en la forma LU.
La matriz U es
idéntica al arreglo de
coeficientes que
aparece en la
eliminación de Gauss
Si un conjunto de ecuaciones cuando finaliza la
lineales debe resolverse en eliminación hacia
forma repetida con distintos adelante.
términos no homogéneos, es
recomendable la
descomposición LU.