Está en la página 1de 8

FACTORIZACIÓN LU

Esta factorización consiste en descomponer una matriz A en la forma A=LU, donde, L es


una matriz triangular inferior y U es una matriz triangular superior.
Para realizar esta factorización nos basaremos en el algoritmo 6.4 propuesto en el libro
“Análisis numérico” de Burden. Dicho algoritmo lo programaremos en Matlab y es el
siguiente:

syms('AA', 'NAME', 'INP', 'OK', 'N', 'I', 'J', 'A');


syms('FLAG', 'ISW', 'XL', 'M', 'KK', 'S', 'K', 'JJ');
syms('SS', 'OUP', 's');
TRUE = 1;
FALSE = 0;
fprintf(1,'Este es el método general de factorización LU.\n');
fprintf(1,'El arreglo será ingressado de un archivo de texto com su
respectivo orden:\n');
fprintf(1,'A(1,1), A(1,2), ..., A(1,N), \n')
fprintf(1,'A(2,1), A(2,2), ..., A(2,N),\n');
fprintf(1,'..., A(N,1), A(N,2), ..., A(N,N)\n\n');
fprintf(1,'Coloque tantas entradas como desee, pero separadas\n');
fprintf(1,'com al menos um espacio em blanco.\n\n\n');
fprintf(1,'Ha sido creado el archivo? - ingresa Y o N.\n');
AA = input(' ','s');
if AA == 'Y' | AA == 'y'
fprintf(1,'Ingrese el nombre del archivo en la forma -
drive:\\nombre.ext\n');
fprintf(1,'Por ejemplo: A:\\DATOS.DTA\n');
NAME = input(' ','s');
INP = fopen(NAME,'rt');
OK = FALSE;
while OK == FALSE
fprintf(1,'Ingrese el orden de la matriz (n) – debe ser un entero.\n');
N = input(' ');
if N > 0
A = zeros(N,N);
XL = zeros(1,N);
for I = 1 : N
for J = 1 : N
A(I,J) = fscanf(INP, '%f',1);
end;
end;
OK = TRUE;
fclose(INP);
else fprintf(1,'El número debe ser un entero positivo.\n');
end;
end;
fprintf(1,'Elige las diagonales:\n');
fprintf(1,'1. Diagonal de L consiste de unos\n');
fprintf(1,'2. Diagonal de U consiste de unos\n');
fprintf(1,' Ingresa 1 o 2.\n');
FLAG = input(' ');
if FLAG == 1
ISW = 0;
else
ISW = 1;
end
else
fprintf(1,'El programa se cerrará, cree el archivo de texto.\n');
OK = FALSE;
end;
if OK == TRUE
for I = 1 : N
XL(I) = 1;
end;
% PASO 1
if abs(A(1,1)) <= 1.0e-20
OK = FALSE;
else
A(1,1) = A(1,1)/XL(1);
% PASO 2
for J = 2 : N
if ISW == 0
% primera fila de U
A(1,J) = A(1,J)/XL(1);
% primera columna de L
A(J,1) = A(J,1)/A(1,1);
else
% primera columna de U
A(1,J) = A(1,J)/A(1,1);
% primera columna de L
A(J,1) = A(J,1)/XL(1);
end;
end;
% PASO 3
M = N-1;
I = 2;
while I <= M & OK == TRUE
% PASO 4
KK = I-1;
S = 0;
for K = 1 : KK
S = S-A(I,K)*A(K,I);
end;
A(I,I) = (A(I,I)+S)/XL(I);
if abs(A(I,I)) <= 1.0e-20
OK = FALSE;
else
% PASO 5
JJ = I+1;
for J = JJ : N
SS = 0;
S = 0;
for K = 1 : KK
SS = SS-A(I,K)*A(K,J);
S = S-A(J,K)*A(K,I);
end;
if ISW == 0
% Iésima fila de U
A(I,J) = (A(I,J)+SS)/XL(I);
% Iésima columna de L
A(J,I) = (A(J,I)+S)/A(I,I);
else
% Iésima fila de U
A(I,J) = (A(I,J)+SS)/A(I,I);
% Iésima columna de L
A(J,I) = (A(J,I)+S)/XL(I);
end;
end;
end;
I = I+1;
end;
if OK == TRUE
% PASO 6
S = 0;
for K = 1 : M
S = S-A(N,K)*A(K,N);
end;
A(N,N) = (A(N,N)+S)/XL(N);
% sI A(N,N) = 0, entonces A = LU pero la matriz es singular.
% el processo es completo, todas las entradas de A han sido determinadas.
% STEP 7
fprintf(1,'Elige la forma de salida:\n');
fprintf(1,'1. Salida en pantalla\n');
fprintf(1,'2. Salida en archivo de texto\n');
fprintf(1,'Ingresar 1 o 2\n');
FLAG = input(' ');
if FLAG == 2
fprintf(1,'Ingrese el nombre del archivo em la forma -
drive:\\nombre.ext\n');
fprintf(1,'Por ejemplo A:\\OUTPUT.DTA\n');
NAME = input(' ','s');
OUP = fopen(NAME,'wt');
else
OUP = 1;
end;
fprintf(OUP, 'Factorización general LU\n\n');
if ISW == 0
fprintf(OUP, 'La diagonal de L consiste de todas las entradas = 1.0\n');
else
fprintf(OUP, 'La diagonal de U consiste de todas las entradas = 1.0\n');
end;
fprintf(OUP, '\n Entradas de L debajo de la diagonal y entradas de U
arriba de la diagonal, incluido la diagonal');
fprintf(OUP, '/on diagonal\n');
fprintf(OUP, '- Salida por filas en formato sobreescrito:\n');
for I = 1 : N
for J = 1 : N
fprintf(OUP, ' %11.8f', A(I,J));
end;
fprintf(OUP, '\n');
end;
if OUP ~= 1
fclose(OUP);
fprintf(1,'Archivo de salida %s creado exitosamente \n',NAME);
end;
end;
end;
if OK == FALSE
fprintf(1,'La matriz no tiene una factorización LU.\n');
end;
end;

Ejemplo:
Determinar la factorización LU de la siguiente matriz:

1 1 0 3
 2 1 1 1 
A 
 3 1 1 2 
 
 1 2 3 1
Al ejecutar el algoritmo en Matlab obtenemos la factorización:

1 1 0 3
2 -1 -1 -5 

3 4 3 13
 
-1 -3 0 -13 

Que esta en formato sobreescrito, es decir, las entradas de L están debajo de la diagonal y
las entradas de U están sobre la diagonal, incluido la diagonal, separando la matriz L y U
tenemos:

1 0 0 0  1 1 0 3
2 1 0 0   0 -1 -1 -5 
L U 
3 4 1 0  0 0 3 13 
   
-1 -3 0 1  0 0 0 -13

Lo cual se puede verificar en el libro de Burden que es lo mismo.

Nota: El algoritmo mostrado anteriormente nos factoriza una matriz en la cual no se realiza
intercambio de filas, en el caso que sea necesario realizar un intercambio de filas, nos
emitirá un mensaje diciendo que la matriz no se puede factorizar.
MÉTODO ITERATIVO DE JACOBI

Este método se usa para resolver sistemas lineales de la forma Ax=b, por lo general para
sistemas de dimensión grande, dado que en este caso son muy eficientes.
Para resolver sistemas lineales usando el método de Jacobi, nos basamos en el algoritmo
7.1 de Burden y lo implementamos en Matlab. La implementación es la siguiente:
syms('AA', 'OK', 'NAME', 'INP', 'N', 'I', 'J', 'A', 'X1');
syms('TOL', 'NN', 'K', 'ERR', 'S', 'X2', 'FLAG', 'OUP');
TRUE = 1;
FALSE = 0;
fprintf(1,'Este es el método de Jacobi para sistemas lineales.\n');
fprintf(1,'El arreglo será ingressado de um archivo de texto\n');
fprintf(1,'A(1,1), A(1,2), ..., A(1,n+1), \n');
fprintf(1,'A(2,1), A(2,2), ..., A(2,n+1), \n');
fprintf(1,'..., A(n,1), A(n,2), ..., A(n,n+1)\n');
fprintf(1,'Coloque las entradas de la matriz separadas por almenos\n');
fprintf(1,'um espacio en blanco.\n\n\n');
fprintf(1,'La aproximación inicial debe seguir el mismo formato.\n');
fprintf(1,'Se ha creado el archivo de entrada? - ingresa Y o N.\n');
AA = input(' ','s');
OK = FALSE;
if AA == 'Y' | AA == 'y'
fprintf(1,'Ingresa el nombre del archivo en la forma
drive:\\nombre.ext\n');
fprintf(1,'por ejemplo: A:\\DATA.DTA\n');
NAME = input(' ','s');
INP = fopen(NAME,'rt');
OK = FALSE;
while OK == FALSE
fprintf(1,'Ingrese el numero de ecuaciones – un entero.\n');
N = input(' ');
if N > 0
A = zeros(N,N+1);
X1 = zeros(N);
X2 = zeros(N);
for I = 1 : N
for J = 1 : N+1
A(I,J) = fscanf(INP, '%f',1);
end;
end;
for I = 1 : N
X1(I) = fscanf(INP, '%f',1);
end;
OK = TRUE;
fclose(INP);
else
fprintf(1,'El número debe ser un entero positivo\n');
end;
end;
OK = FALSE;
while OK == FALSE
fprintf(1,'Ingrese la tolerancia.\n');
TOL = input(' ');
if TOL > 0
OK = TRUE;
else
fprintf(1,'La tolerancia debe ser positiva.\n');
end;
end;
OK = FALSE;
while OK == FALSE
fprintf(1,'Ingrese el máximo número de iteraciones.\n');
NN = input(' ');
if NN > 0
OK = TRUE;
else
fprintf(1,'El numero debe ser un entero positivo.\n');
end;
end;
else
fprintf(1,'El programa terminara, crear el archivo de entrada.\n');
end;
if OK == TRUE
% PASO 1
K = 1;
OK = FALSE;
% PASO 2
while OK == FALSE & K <= NN
% err is used to test accuracy - it measures the infinity-norm
ERR = 0;
% PASO 3
for I = 1 : N
S = 0;
for J = 1 : N
S = S-A(I,J)*X1(J);
end;
S = (S+A(I,N+1))/A(I,I);
if abs(S) > ERR
ERR = abs(S);
end;
% usar X2 por X
X2(I) = X1(I)+S;
end;
% PASO 4
if ERR <= TOL
% El processo es completo
OK = TRUE;
else
% PASO 5
K = K+1;
% PASO 6
for I = 1 : N
X1(I) = X2(I);
end;
end;
end;
if OK == FALSE
fprintf(1,'El máximo numero de iteraciones es excedido.\n');
% PASO 7
% Procedimiento es completado exitosamente
else
fprintf(1,'Elegir el método de salida d:\n');
fprintf(1,'1. Salida en pantalla\n');
fprintf(1,'2. Salida em archivo de texto\n');
fprintf(1,'por favor, ingresar 1 o 2.\n');
FLAG = input(' ');
if FLAG == 2
fprintf(1,'Ingrese el nombre del archivo - drive:\\name.ext\n');
fprintf(1,'Por ejemplo: A:\\OUTPUT.DTA\n');
NAME = input(' ','s');
OUP = fopen(NAME,'wt');
else
OUP = 1;
end;
fprintf(OUP, 'MÉTODO ITERATIVO DE JACOBI PARA SISTEMAS LINEALES\n\n');
fprintf(OUP, 'El vector solución es :\n');
for I = 1 : N
fprintf(OUP, ' %11.8f', X2(I));
end;
fprintf(OUP, '\n usando %d iteraciones\n', K);
fprintf(OUP, 'con tolerancia %.10e em norma infinita\n', TOL);
if OUP ~= 1
fclose(OUP);
fprintf(1,'Archivo de salida %s creado exitosamente \n',NAME);
end;
end;
end;

Ejemplo 1:
Utilice el método iterativo de Jacobi para encontrar la solución del sistema lineal Ax=b,
dado por:
10 x1  x2  2 x3  6
 x1  11x2  x3  3x4  25
2 x1  x2  10 x3  x4  11
3x2  x3  8 x4  15

utilice como punto inicial a (0,0,0,0) y un error de aproximación de 10-3.


La matriz asociada al sistema es:

 10.0 -1.0 2.0 0.0 6.0 


 -1.0 11.0 -1.0 3.0 25.0 

 2.0 -1.0 10.0 -1.0 -11.0 
 
 0.0 3.0 -1.0 8.0 15.0 

Al ejecutar el algoritmo, obtenemos el vector solución:


 1.00011860 1.99976795 -0.99982814 0.99978598

El cual se obtuvo realizando 10 iteraciones. Se puede verificar que el vector solución


obtenido es bastante próximo a la solución exacta, la cual es: (1, 2, -1 , 1)
Ejemplo 2:
Resolver el sistema lineal:
2 x1  x2  x3  1
2 x1  2 x2  2 x3  4
 x1  x2  2 x3  5

Con punto inicial (0,0,0) y error de aproximación de 10-3.


Al ejecutar el algoritmo en Matlab nos emite un mensaje que el número máximo de
iteraciones es excedido, donde consideramos como número máximo de iteraciones igual a
100.

Esto sucede dado que T  1 y por teorema se tiene que para que el método converja se
debe cumplir que T  1 , por esta razón es que para este sistema lineal no se puede aplicar
el método de Jacobi.
Con esto concluimos que una ventaja del método de Jacobi es que es muy eficiente para
resolver sistemas de dimensión grande, pero una desventaja es que si T  1 , el método no
converge; y en dichos casos se debe optar por resolver por otros métodos.