METODO DE CHOLESKY

Es un método de factorización de matrices que consiste en hacer los

elementos de la diagonal de la matriz triangular inferior L a los de la
matriz triangular superior U.
Pero, si [𝐴] es una matriz de n x n positiva difinid, entonces[𝐴] tiene
una factorización de la forma A=L*LT, donde L es un matriz triangular
inferior.
Para que la matriz se positiva definida, debe ser simétrica y
diagonalmente dominante.
Este método usa el hecho de que una matriz simétrica puede
expresarse como un producto de dos matrices triangulares, así:

𝑎11 𝑎12 𝑎13 ⋯ 𝑎1𝑛 𝑙11 0 0 ⋯ 0 𝑙11 𝑙12 𝑙13 ⋯ 𝑙1𝑛

𝑎21 𝑎22 𝑎23 ⋯ 𝑎2𝑛 𝑙21 𝑙22 0 ⋯ 0 0 𝑙22 𝑙23 ⋯ 𝑙2𝑛
𝑎31 𝑎32 𝑎33 ⋯ 𝑎3𝑛 = 𝑙31 𝑙32 𝑙33 ⋯ 0 ∗ 0 0 𝑙33 ⋯ 𝑙3𝑛
⋮ ⋮ ⋮ ⋱ ⋮ ⋮ ⋮ ⋮ ⋱ ⋮ ⋮ ⋮ ⋮ ⋱ ⋮
[𝑎𝑛1 𝑎𝑛2 𝑎𝑛3 ⋯ 𝑎𝑛𝑛 ] [ 𝑙𝑛1 𝑙𝑛2 𝑙𝑛3 ⋯ 𝑙𝑛𝑛 ] [0 0 0 ⋯ 𝑙𝑛𝑛 ]

Por definición de producto de matrices obtenemos los valores de L.

𝑎11 = (𝑙11 )2 → 𝑙11 = √𝑎11

𝑎21
𝑎21 = 𝑙21 ∗ 𝑙11 → 𝑙21 =
𝑙11

𝑎22 = (𝑙21 )2 + (𝑙22 )2 → 𝑙22 = √𝑎22 − (𝑙21 )2

𝑎32 − 𝑙31 ∗ 𝑙21
𝑎32 = 𝑙31 ∗ 𝑙21 + 𝑙32 ∗ 𝑙22 → 𝑙32 =
𝑙22

𝑎33 = (𝑙31 )2 + (𝑙32 )2 + (𝑙33 )2 → 𝑙33 = √𝑎33 − (𝑙31 )2 − (𝑙32 )2

𝑎43 − 𝑙41 ∗ 𝑙31 − 𝑙42 ∗ 𝑙32
𝑎43 = 𝑙41 ∗ 𝑙31 + 𝑙42 ∗ 𝑙32 + 𝑙43 ∗ 𝑙33 → 𝑙43 =
𝑙33

⋮
 𝑎𝑖𝑖 = 𝑙𝑖1 2 + 𝑙𝑖2 2 + ⋯ + 𝑙𝑖𝑖 2 → 𝑙𝑖𝑖 = √𝑎𝑖𝑖 − 𝑙𝑖1 2 − 𝑙𝑖2 2 ⋯

𝑎𝑗𝑖 − 𝑙𝑗1 ∗ 𝑙𝑖1 − 𝑙𝑗2 ∗ 𝑙𝑖2 − ⋯

𝑎𝑗𝑖 = 𝑙𝑗1 ∗ 𝑙𝑖1 + 𝑙𝑗2 ∗ 𝑙𝑖2 + ⋯ + 𝑙𝑗𝑖 ∗ 𝑙𝑖𝑖 → 𝑙𝑗𝑖 =
𝑙𝑖𝑖
Donde: i < j
En forma general:

𝑖−1

𝑙(𝑖,𝑖) = √𝑎(𝑖,𝑖) − ∑ 𝑙(𝑖,𝑘) 2 ; 𝑖 = 2: 𝑛

𝑘=1

𝑎(𝑗,𝑖) − ∑𝑖−1
𝑘=1 𝑙(𝑖,𝑘) ∗ 𝑙(𝑗,𝑘)
𝑙(𝑗,𝑖) = ; 𝑗 = 𝑖 + 1: 𝑛 ; 𝑖 = 2: 𝑛
𝑙(𝑖,𝑖)
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:

𝑏𝑖 −∑𝑖−1
𝑘=1 𝐿𝑖 𝐶𝑘
; Ci = 𝐿𝑖𝑖

Conociendo a C encontramos a x:

Propiedades:
 Sirve para saber si una matriz simétrica es definida positiva.
 Es estable.
Algoritmo:
D.E: La Matriz
D.S: La Matriz Triangular Inferior y la Superior
La factorización y el vector solución
P1: Para N = 1: n
P2: Para i = 1: N-1

𝒊−𝟏

𝒍(𝒊,𝒊) = √𝒂(𝒊,𝒊) − ∑ 𝒍(𝒊,𝒌) 𝟐

𝒌=𝟏

P3: Para j = 1: N-1

𝒂(𝒋,𝒊) − ∑𝒊−𝟏
𝒌=𝟏 𝒍(𝒊,𝒌) ∗ 𝒍(𝒋,𝒌)
𝒍(𝒋,𝒊) =
𝒍(𝒊,𝒊)
P4: Hacer:
M.T.I = matriz triangular inferior
M.T.S = matriz triangular superior = (M.T.I)’
Mostrar M.T.I y M.T.S
P5: Para i>1

𝑏𝑖 −∑𝑖−1
𝑘=1 𝐿𝑖 𝐶𝑘
Ci =
𝐿𝑖𝑖
Mostrar “c” (Factorización)
P6: x=C
𝐶𝑛 𝐶𝑖 −∑𝑛
𝑙=𝑖+1 𝐿𝑖𝑙 𝑥𝑙
xn = y xi =
𝐿𝑛𝑛 𝐿𝑖𝑖

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

P7: FIN
Programación:
disp('Moises Barrios Cespedes');
disp('Física Computacional II');
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
Ejemplo:

Respuesta:
 METODO DE JACOBI: método iterativo con
matrices
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('Fisica Computacional II');
disp('Moises Barrios Cespedes');
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));
Ejemplo:
Resuelva el siguiente sistema de ecuaciones usando el Método de
Jacobi.

Cuya matriz es diagonalmente dominante.

Respuesta:
 Universidad Nacional Pedro Ruiz Gallo
FACULTAD DE CIENCIAS FISICAS Y MATEMATICA
ESCUELA PROFECIONAL DE FISICA

“METODO DE CHOLESKY Y DE JACOBI”

ALUMNOS:
MOISES BARRIOS CESPEDES

Curso:
FISICA COMPUTACIONAL II

Docente:
SOTERO SOLIS JAIME

LAMBAYEQUE 26 DE JUNIO, PERU

2017