FACTORIZACIÓN DIRECTA DE MATRICES

Se considera el sistema 𝐴𝑥 = 𝐵 donde mediante la factorización directa de las matrices, se

busca descomponer la matriz A siendo el resultado del producto de dos matrices triangulares
L y U. Estas matrices son triangular inferior (L) y triangular superior (U).
Cabe mencionar que, para la solución de estos sistemas mediante factorización, la matriz A
debe ser de tamaño 𝑛𝑥𝑚, siendo esta una matriz cuadrada. A partir de esto, se considera el
sistema de ecuaciones

Para este caso, se considera una matriz 4 𝑥 4.

Con la imagen anterior, se muestra las respectivas matrices L y U que son igualadas a la
matriz principal A. La finalidad de la factorización directa de matrices, es resolver este
sistema encontrando las respectivas 𝑙𝑖𝑗 𝑦 𝑢𝑖𝑗 , esto se logra mediante tres posibles soluciones.
Dichas soluciones se conocen como factorización de Doolittle, factorización de Crout y
factorización de Cholesky.

 La factorización de Doolittle se diferencia ya que los elementos de la diagonal de la

matriz L son iguales a 1 así: 𝑙𝑖𝑖 = 1
 La factorización de Crout, se reconoce mediante su diagonal, ya que los elementos
de la matriz U son iguales a 1 así: 𝑢𝑖𝑖 = 1
 Ahora la factorización de Cholesky, los elementos de la diagonal de L son iguales a
los elementos de la diagonal de U así: 𝑙𝑖𝑖 = 𝑢𝑖𝑖
 METODO DE CHOLESKY
En caso que el sistema de matriz sea simétrica, positiva definida, un algoritmo de
solución muy eficiente es proporcionado por el Método de Cholesky, a veces
denominado Método de Banachiewicz.
Este método usa el hecho de que una matriz simétrica puede expresarse como un
producto de dos matrices triangulares, así:
A=LTL

A partir de estas expresiones anteriores y considerando las reglas para multiplicación

de matrices, obtenemos que:
a1j = L1iL1j + L2iL2j +…+ LiiLjj i<j
aii = L21i + L22i +…+ L2ii i=j
Sin embargo, se determinan los coeficientes de la primera fila de L por:
𝑎
L11 = √𝑎11 y L1j = 𝑎1𝑗
11

En forma general:

Además, se puede puede verificar que la solución del sistema:

Ax=B
Reducido para encontrar la solución de los dos sistemas equivalentes:
STC = B y Sx = C
 Los elementos de C son determinados por las formulas:

Conociendo a C
encontramos a x:

Propiedades:
 Sirve para saber si una matriz simétrica es definida positiva.
 Es estable.
Algoritmo:
Datos de Entrada: La Matriz
Datos de Salida: La Matriz Triangular Inferior, Superior
La factorización y el vector solución
Paso 1:
Para k = 1: n
Paso2:
Para i = 1: k-1
𝑗=1
𝑎𝑖𝑗 − ∑𝑙=1 𝐿𝑖𝑖 𝐿𝑙𝑗
Lij = 𝐿𝑖𝑖

Paso3:
Para j = 1: k-1

Lij = √𝑎𝑖𝑖 − ∑𝑖−1 2

𝑙=1 𝐿 𝑙𝑖

Paso4:
Hacer:
M.T.I = matriz
M.T.S = (M.T.I)’
Mostrar M.T.I y M.T.S
Paso5:
Para i>1
𝑏𝑖 −∑𝑖−1
𝑙=1 𝐿𝑖 𝐶𝑙
Ci = 𝐿𝑖𝑖

Mostrar “c” (Factorización)

Paso6:
x=C
𝐶 𝐶𝑖 −∑𝑛
𝑙=𝑖+1 𝐿𝑖𝑙 𝑥𝑙
xn = 𝐿 𝑛 y xi =
𝑛𝑛 𝐿𝑖𝑖

Mostrar “x” (El vector solución).

Paso7:
FIN
Programación:
disp('Universidad Nacional Pedro Ruiz Gallo );
disp('Física Computacional II');
disp('Sandoval ventura jesus');
matriz=input('Ingresar la matriz aumentada del sistema
de ecuaciones:');
tam=size(matriz);
n=tam(1);
for i=1:n
b(i)=matriz(i,n+1);
for j=1:n
A(i,j)=matriz(i,j);
end
end
b1=b';
%ALGORITMO DE CHOLESKY
for k=1:n
for i=1:k-1
sum=0;
for j=1:i-1
sum=sum+A(i,j)*A(k,j);
end
A(k,i)=(A(k,i)-sum)/A(i,i);
end
sum=0;
for j=1:k-1
sum=sum+A(k,j)*A(k,j);
end
A(k,k)=sqrt(A(k,k)-sum);
end
for i=1:n-1
for j=1:n
if j>i
A(i,j)=0;
end
end
end
L=A;
U=L';
c=b1;
c(1)=b1(1)/L(1,1);
for i=2:n
S=0;
for j=1:n-1
if i~=j && i>j
S=S+L(i,j)*c(j);
end
 c(i)=(b1(i)-S)/L(i,i);
end
x=c;
x(n)=c(n)/U(n,n);
for i=n-1:-1:1
Z=0;
for j=n:-1:2
if i~=j && i<j
Z=Z+U(i,j)*x(j);
end
end
x(i)=(c(i)-Z)/U(i,i);
end
end
disp('Muestra la Matriz Triangular Inferior de
Cholesky');
L
disp('Muestra la Matriz Triangular Superior de
Cholesky');
U
disp('Muestra la Factorizacion de Cholesky');
Matriz_A=L*U
disp('El vector solución del sistema');
x
 METODOS ITERATIVOS CON MATRICES
Los métodos iterativos para la solución de sistemas de ecuaciones lineales de la forma Ax=B,
son muy útiles para la aproximación de los valores de las variables, pero se debe tener en
cuenta que la matriz A es una matriz no singular de orden nxn con elementos en la diagonal
principal no nulos.
Los métodos iterativos con matrices son:
 Método de Jacobi.
 Método de Gauss Seidel.
 Método de Gauss Seidel con Relajación.

METODO DE JACOBI:
La primera técnica iterativa se conoce como el Método de Jacobi, también conocido
como “método de desplazamiento simultaneo”.
Este método hace dos suposiciones:

1) El siguiente sistema dado, tiene una única solución:

2) La matriz A de coeficientes no tiene ceros en su diagonal principal. Si alguna de las

entradas de la diagonal a11, a22, …, ann son cero, entonces las filas o las columnas se
intercambian para obtener una matriz de coeficientes que tienen entradas no cero en la
diagonal principal.
Para empezar con el método de jacobi, resolvemos la primera ecuación para x1, para
la segunda ecuación x2 y para la tercera ecuación x3.

Suponga valores iniciales para x1, x2 y x3,…, xn y sustituya estos valores de xi en el

lado derecho de la primera ecuación para obtener la primera aproximación. Después
de haber terminado este procedimiento, se ha realizado una iteración. De igual
manera, la segunda aproximación se realiza sustituyendo la primera aproximación
del valor de x en el lado derecho de la segunda ecuación, para obtener la segunda
aproximación y asi sucesivamente.
Las iteraciones se repiten hasta formar una secuencia de aproximación que converge
a la solución real. Estas ecuaciones se pueden escribir en forma sumatoria, como:
Para cualquier fila i:

Y al final de cada iteración, se calcula el error absoluto relativo aproximado para

cada xi como:

Donde (xi)nuevo es el valor reciente obtenido de xi y (xi)viejo es el valor anterior de xi.

Cuando el error absoluto relativo aproximado para cada xi es menor que la
tolerancia pre especificada, las iteraciones se terminan.

Algoritmo:
D.E: La matriz A /La matriz B /# de iteraciones (N).
D.S: Los valores de la aproximación.
P.1: Obtener el # de filas y columnas de A.
P.2: Crear un vector S de ceros en función del # de filas y columnas de A.
Hacer: S(i,i) = A(i,i)
P.3: Hacer: T= S-A
P.4: Crear un vector x de zeros en función del # de filas y columnas de B.
P.5: Crear otro vector xnuevo en función del # de filas y columnas de B.
P.6: Para: it=1:N
Para: i=1: #Columnas de B.
Hacer: xnuevo(i) = B(i)
P.7: Para: j=1: #Filas de B.
Hacer: xnuevo(i) = xnuevo(i) + T(i,j)*x(j)
 xnuevo(i) = xnuevo(i)/S(i,i)
P.8: Hacer un cambio de variable:
X = xnuevo
P.9: Mostrar x1,x2 y x3.
P.10: Fin
Programación:
Clc
disp('Universidad Nacional Pedro Ruiz Gallo );
disp('Física Computacional II');
disp('Sandoval ventura JESUS ');
A= input('Ingrese la Matriz A:');
B= input('Ingrese la Matriz B:');
N= input('Número de Iteraciones:');
s=size(A);
rows=s(1);
cols=s(2);
S=zeros(size(A));
for i=1:cols;
S(i,i)=A(i,i);
end
T=S-A;
x=zeros(size(B));
xnew=zeros(size(B));
for it=1:N
for i=1:cols
xnew(i)=B(i);
for j=1:rows
xnew(i)=xnew(i)+T(i,j)*x(j);
end
xnew(i)=xnew(i)/S(i,i);
end
x=xnew;
end
disp('**********************************************');
disp('SOLUCION DEL SISTEMA DE ECUACIONES LINEALES');
fprintf(' iteraciones final número %i\n
Solución:',it);
fprintf('\n x1=%2.5f\n',x(1));
fprintf('\n x2=%2.5f\n',x(2));
fprintf('\n x3=%2.5f\n',x(3));