Metodo de cholesky

1.- INTRODUCCIÓN.-
En matemáticas, la factorización o descomposición de Cholesky toma su nombre
del matemático André-Louis Cholesky, quien encontró que una matriz simétrica
definida positiva puede ser descompuesta como el producto de una matriz
triangular inferior y la traspuesta de la matriz triangular inferior. La matriz triangular
inferior es el triángulo de Cholesky de la matriz original positiva definida. El
resultado de Cholesky ha sido extendido a matrices con entradas complejas. Es
una manera de resolver sistemas de ecuaciones matriciales y se deriva de la
factorización LU con una pequeña variación.
Cualquier matriz cuadrada A con pivotes no nulos puede ser escrita como el
producto de una matriz triangular inferior L y una matriz triangular superior U; esto
recibe el nombre de factorización LU. Sin embargo, si A es simétrica y definida
positiva, se pueden escoger los factores tales que U es la transpuesta de L, y esto
se llama la descomposición o factorización de Cholesky. Tanto la descomposición
LU como la descomposición de Cholesky son usadas para resolver sistemas de
ecuaciones lineales. Cuando es aplicable, la descomposición de Cholesky es dos
veces más eficiente que la descomposición LU.
Tenemos la matriz de coeficientes de un sistema de ecuaciones, la llamamos A,
comprobamos que esta matriz sea simétrica, porque de lo contrario no es
factorizable por Cholesky. Cuando A es simétrica podemos tratar de factorizarla en
la forma A = L*L(t), L(t) quiere decir la matriz L traspuesta, cuando la tenemos
factorizada ya podemos resolver el sistema de ecuaciones.
Una condición necesaria y suficiente para que una matriz A admita factorización
de Cholesky es que sea simétrica y definida positiva.

2.- DEFINICIÓN.-
En general, si A es Ermitaña y definida positiva, entonces A puede ser
descompuesta como
donde L es una matriz triangular inferior con entradas diagonales estrictamente
positivas y L* representa la conjugada traspuesta de L. Esta es la descomposición
de Cholesky.
La descomposición de Cholesky es única: dada una matriz Ermitaña positiva
definida A, hay una única matriz triangular inferior L con entradas diagonales
estrictamente positivas tales que A = LL*. El recíproco se tiene trivialmente: si A se
puede escribir como LL* para alguna matriz invertible L, triangular inferior o no,
entonces A es Ermitaña y definida positiva.
El requisito de que L tenga entradas diagonales estrictamente positivas puede
extenderse para el caso de la descomposición en el caso de ser semidefinida
positiva. La proposición se lee ahora: una matriz cuadrada A tiene una
descomposición de Cholesky si y sólo si A es Ermitaña y semidefinida positiva.
Las factorizaciones de Cholesky para matrices semidefinidas positivas no son
únicas en general.
En el caso especial que A es una matriz positiva definida simétrica con entradas
reales, L se puede asumir también con entradas reales. Una Matriz D diagonal con
entradas positivas en la diagonal (valores propios de A), es factorizable como
, donde es matriz cuya diagonal consiste en la raíz cuadrada
de cada elemento de D, que tomamos como positivos. Así:

La factorización puede ser calculada directamente a través de las siguientes
fórmulas (en este caso realizamos la factorizacón superior ):
para los elementos de la diagonal principal, y:
para el resto de los elementos. Donde son los
elementos de la matriz U.
3.- APLICACIÓN.-
La descomposición de Cholesky se usa principalmente para hallar la solución
numérica de ecuaciones lineales Ax = b. Si A es simétrica y positiva definida,
entonces se puede solucionar Ax = b calculando primero la descomposición de
Cholesky A = LLT, luego resolviendo Ly = b para y, y finalmente resolviendo LTx =
y pa.
4.- Mínimos cuadrados lineales
Sistemas de la forma Ax = b con A simétrica y definida positiva aparecen a
menudo en la práctica. Por ejemplo, las ecuaciones normales en problemas de
mínimos cuadrados lineales son problemas de esta forma. Podría ocurrir que la
matriz A proviene de un funcional de energía el cual debe ser positivo bajo
consideraciones físicas; esto ocurre frecuentemente en la solución numérica de
ecuaciones diferenciales parciales.

a) Obtenga la descomposición de Cholesky , imponiendo restricciones apropiadas
sobre a de modo que exista la descomposición anterior.
b) Resuelva el sistema dado.
Solución:
a) Para que podamos calcular la descomposición de Cholesky es necesario que A sea simétrica y
definida positiva.
Se ve claramente que A es simétrica.
Para que A sea definida positiva debemos tener:
es decir,
Calculemos la
matriz L.

b) Resolvamos el sistema dado.
Primero se resuelve el sistema triangular inferior
En segundo lugar se resuelve el sistema triangular superior

B.- CODIFICACIÓN.-
unit UFCholesky;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls, UCMatriz;
type
Matriz=array[1..20,1..20]of Integer;
Matriz2=array[1..20,1..20]of Real;
Vector=array[1..20]of real;
TForm1 = class(TForm)
Button1: TButton;
Button2: TButton;
Button3: TButton;
procedure FormCreate(Sender: TObject);
procedure Button1Click(Sender: TObject);
private
X:CMatriz;{ Private declarations }
public
{ Public declarations }
end;
var
Form1: TForm1;
MA:Matriz;
MB:Matriz2;
MC:Matriz2;
i,j,k,l,a,b,m,p,y:Integer;
V:Vector;
implementation
{$R *.dfm}
procedure TForm1.FormCreate(Sender: TObject);
begin
X:=CMatriz.Crear(1,1);
repeat
l:=strtoint(InputBox('Cholesky', '¿Cuantas incognitas tiene?','1'));
if (l<0) or (l>20) then
ShowMessage('Solo numeros enteros menores a 20');

until (l>0) and (l<20);
k:=l+1;
i:=1;
X.Redimensionar(l,k);
While i<=l do
begin
j:=1;
While j<=k do
begin
MA[i,j]:=strtoint(inputbox('Cargando la matriz','Escriba el elemento
'+ inttostr(i)+' , '+ inttostr(j),'0'));
j:=j+1;
end;
i:=i+1;
end;
for i:=1 to l do
begin
for j:=1 to k do
X.Poner(i,j,MA[i,j]);
end;
end;
procedure TForm1.Button1Click(Sender: TObject);
var
o:integer;
begin
i:=1;
j:=1;
While i<=l do
begin
MB[i,j]:=MA[i,j];
i:=i+1;
end;
i:=1;
While i<=l do
begin
MC[i,i]:=1;
i:=i+1;
end;
i:=1;
j:=2;
While j<=(k+1) do
begin
MC[i,j]:=((1/(MB[1,1]))*(MA[i,j]));
j:=j+1;

end;
a:=2;
b:=2;
While b<=k do
begin
i:=a;
j:=b;
While i<=l do
begin
MB[i,j]:=(MA[i,j]);
m:=1;
While m<j do
begin
MB[i,j]:=MB[i,j]-((MB[i,m])*(MC[m,j]));
m:=m+1;
end;
i:=i+1;
end;
i:=j;
j:=j+1;
While j<=k do
begin
m:=1;
MC[i,j]:=MA[i,j];
While m<i do
begin
MC[i,j]:=MC[i,j]-((MB[i,m])*(MC[m,j]));
m:=m+1;
end;
MC[i,j]:=((1/(MB[i,i]))*((MC[i,j])));
j:=j+1;
end;
b:=b+1;
end;
b:=(b-1);
i:=(b-1);
While i>0 do
begin
V[i]:=MC[i,b];
m:=(i+1);
While m<b do
begin
V[i]:=V[i]-(MC[i,m]*V[m]);
m:=m+1;

end;
i:=i-1;
end;
p:=500; y:=100;
for o:=1 to l do
begin
Canvas.TextOut(p,y,'x'+ inttostr(o)+' es igual a:'+ floattostr( V[o]));
y:=y+20;
end;
end;
begin
X.Dibujar(100,100,canvas);
end;
begin
Close;
end;
end.
unit UCMatriz;
interface
uses
SysUtils, Dialogs, Graphics;
Const
max=100;
type
CEMMatriz=Class(Exception);
CMatriz=Class
private
M:Array [1..max, 1..max] of integer;
nf:integer;
nc:integer;
public
Constructor Crear(Df,dc:integer);
Function Elemento(f,c:integer):integer;
Function DimensionFila:integer;
Function DimensionColumna:integer;
Procedure Redimensionar(df,dc:integer);
Procedure Poner(f,c, que:integer);

Procedure Mostrar;
Procedure Dibujar(x,y:integer; C:TCanvas);
end;
CEMMatrizC = Class (Exception);
CMatrizC =Class
private
M:Array [1..max, 1..max] of String;
nf:integer;
nc:integer;
public
Constructor Crear(Df,dc:integer);
Function Elemento(f,c:integer):String;
Function DimensionFila:integer;
Function DimensionColumna:integer;
Procedure Redimensionar(df,dc:integer);
Procedure Poner(f,c:integer; que:String);
Procedure Mostrar;
Procedure Dibujar(x,y:integer; C:TCanvas);
end;
implementation
{ CMatriz }
constructor CMatriz.Crear(df,dc: integer);
begin
if (df>0) and (df<=max) then
nf:=df
else
Raise CEMMatriz.Create('CMatriz.Crear: Error fuera de RANGO...');
if (dc>0) and (dc<=max) then
nc:=dc
else
Raise CEMMatriz.Create('CMatriz.Crear: Error fuera de RANGO...');
end;
function CMatriz.DimensionFila: integer;
begin
Result:=nf;
end;
function CMatriz.DimensionColumna: integer;
begin
Result:=nc;
end;

function CMatriz.Elemento(f,c: integer): integer;
begin
if (f>0) and (f<=nf) and (c>0) and (c<=nc) then
Result:=M[f,c]
else
Raise CEMMatriz.Create('CMatriz.Elemento: Error fuera de RANGO...');
end;
procedure CMatriz.Poner(f,c, que: integer);
begin
M[f,c]:=que
else
Raise CEMMatriz.Create('CMatriz,Poner: Error fuera de RANGO...');
end;
procedure CMatriz.Redimensionar(df,dc: integer);
begin
nf:=df
else
Raise CEMMatriz.Create('CMatriz.Redimensionar: Error fuera de RANGO...');
nc:=dc
else
Raise CEMMatriz.Create('CMatriz.Redimensionar: Error fuera de RANGO...');
end;
procedure CMatriz.Mostrar;
var i,j:integer;
begin
i:=1;
while i<= nc do
begin
j:=1;
while j<= nf do
begin
if j< nf then
begin
if M[i,j]<=9 then
write (M[i,j],' ')
else
write (M[i,j],' ');
end
else
begin

writeln (M[i,j]);
writeln;
end;
j:=j+1;
end;
i:=i+1;
end;
end;
procedure CMatriz.Dibujar(x,y:integer; C:TCanvas);
var
aux,i,j:integer;
begin
aux:=x;
for i:=1 to nf do
begin
for j:=1 to nc do
begin
C.MoveTo(x,y);
C.Rectangle(x,y,x+35,y+35);
C.TextOut(x+5,y+5,inttostr(M[i,j]));
X:=x+34;
end;
x:=aux;
y:=y+34;
end;
end;
{ CMatrizC }
constructor CMatrizC.Crear(Df, dc: integer);
begin
nf:=df
else
Raise CEMMatrizC.Create('CMatrizC.Crear: Error fuera de RANGO...');
nc:=dc
else
Raise CEMMatrizC.Create('CMatrizC.Crear: Error fuera de RANGO...');
end;
procedure CMatrizC.Dibujar(x, y: integer; C: TCanvas);
var
aux,i,j:integer;
begin

aux:=x;
for i:=1 to nf do
begin
for j:=1 to nc do
begin
C.MoveTo(x,y);
C.Rectangle(x,y,x+35,y+35);
C.TextOut(x+5,y+5,M[i,j]);
X:=x+34;
end;
x:=aux;
y:=y+34;
end;
end;
function CMatrizC.DimensionColumna: integer;
begin
Result:=nc;
end;
function CMatrizC.DimensionFila: integer;
begin
Result:=nf;
end;
function CMatrizC.Elemento(f, c: integer): String;
begin
Result:=M[f,c]
else
Raise CEMMatrizC.Create('CMatrizC.Elemento: Error fuera de RANGO...');
end;
procedure CMatrizC.Mostrar;
var i,j:integer;
begin
i:=1;
while i<= nc do
begin
j:=1;
while j<= nf do
begin
if j< nf then
begin
write (M[i,j],' ');
end
else

begin
writeln (M[i,j]);
writeln;
end;
j:=j+1;
end;
i:=i+1;
end;
end;
procedure CMatrizC.Poner(f, c: integer; que: String);
begin
M[f,c]:=que
else
Raise CEMMatrizC.Create('CMatrizC.Poner: Error fuera de RANGO...');
end;
procedure CMatrizC.Redimensionar(df, dc: integer);
begin
nf:=df
else
Raise CEMMatrizC.Create('CMatrizC.Redimensionar: Error fuera de RANGO...');
nc:=dc
else
Raise CEMMatrizC.Create('CMatrizC.Redimensionar: Error fuera de RANGO...');
end;
end.

MANUAL DEL PROGRAMA
1.- Damos doble clic para abrir el programa.
2.- Damos un clic en botón dimensionar.

3.- Luego ponemos un número para que dimensione la matriz.
4.- Ahora llenamos la matriz con los números que queramos adicionar.
5.- Le damos un clic en cargar matriz para hallar los resultados de la A’ y B’.

6.- Y por último le damos un clic en el botón resolver por el Método de Cholesky y no va a
mostrar los
resultados de la matriz
7.- Y para salir del programa le damos en la X

CONCLUSIÓN.-
 Con este método se puede demostrar que se pueden resolver matrices de
orden nxn, es decir matrices cuadradas o simétricas, siempre y cuando
sean positivas, caso contrario es imposible usar este método, ya que en la
resolución se debe usar la matriz original multiplicado por la matriz
transpuesta de A

Metodo de cholesky

Más contenido relacionado

La actualidad más candente (20)

Similar a Metodo de cholesky (20)

Último (20)

Metodo de cholesky