Métodos numéricos

Enviado por esvenmobit

Sistemas lineales de
ecuaciones
Métodos
directos
Doolittle
Código fuente de
Doolittle
Código fuente de
Crout
Código fuente de
Cholesky
Resultados con los
métodos directos
Conclusiones
Bibliografía

INTRODUCCIÓN

En la práctica de la ingeniería y ciencias es
frecuente tener la necesidad de resolver un sistema de
ecuaciones
lineales. Estos sistemas aparecen
en muy diversos problemas, ya
sea como la solución completa de un problema ó al
menos como parte de ella. Dada esta necesidad frecuente, se
requiere resolverlos en forma eficiente.

Los métodos
numéricos que resuelven los sistemas se pueden
clasificar en directos e indirectos.

Los métodos
directos son aquellos que determinan la solución en un
numero determinado de pasos.

Los métodos iterativos son aquellos que obtienen
la solución aproximándose a ella en un numero
finito, pero no definido de pasos.

La siguiente entrega pretende encontrar la
solución de un sistema

de ecuaciones lineales por los métodos
anteriormente mencionados.

Como los algoritmos de
los métodos ya están disponibles en la
mayoría de los libros de
texto sobre la
materia, se
explicara en la medida de lo posible, detalles de
implementación(personales)de los métodos
directos(que son mas difíciles de programar).

El lenguaje de
programación idóneo para tal fin será
matlab 6.0

SISTEMAS LINEALES DE ECUACIONES

Antes de empezar con los detalles de
implementación de los métodos directos resulta
conveniente determinar con que sistema

o sistemas vamos a trabajar.

Para los métodos directos se preferirá un
sistema cuya matriz
de

coeficientes sea simétrica y definida positiva;
la razón de tal decisión radica es que con este
tipo de matrices
trabaja el método
directo de "Cholesky", a diferencia de Doolittle y
Crout.

Puesto que se utilizará un W(factor de
relajación) dado :

W = (raíz cuadrada(5)+1)/2 =
1.61803398874989aprox.

No será necesario tener un sistema tridiagonal
para hallar dicho valor.

Como consecuencia de lo anteriormente expuesto, se
utilizará el mismo sistema para los métodos
directos e iterativos.

Una matriz A es simétrica si su transpuesta es
igual a A.

Es decir: A = [a(i,j)] es simétrica si y solo si
[a(i,j)]=[a(j,i)].

Una matriz simétrica A es positiva definida si y
solo si los eigenvalores(valores
propios) de A son positivos.

Toda matriz simétrica se puede descomponer
como:

A = L*Lt (transpuesta)

Para construir de manera fácil la matriz en
cuestión, basta con utilizar las siguientes instrucciones
en matlab:

>>L=tril(ones(10)); %construye L

>>A=L*L'; %construye L*Lt

>>A%matriz simétrica

A =

1 1 1 1 1 1 1 1 1 1

1 2 2 2 2 2 2 2 2 2

1 2 3 3 3 3 3 3 3 3

1 2 3 4 4 4 4 4 4 4

1 2 3 4 5 5 5 5 5 5

1 2 3 4 5 6 6 6 6 6

1 2 3 4 5 6 7 7 7 7

1 2 3 4 5 6 7 8 8 8

1 2 3 4 5 6 7 8 9 9

1 2 3 4 5 6 7 8 9 10

Si se quiere comprobar que efectivamente se trata de una
matriz positiva definida, basta con teclear:

>>eig(A)%calcula los valores
propios de A

Que obtendrá:

ans =

0.2557

0.2738

0.3080

0.3662

0.4652

0.6431

1.0000

1.8730

5.0489

44.7661

Y todos los valores propios de A son
positivos

Para evitar problemas de convergencia en los
métodos iterativos es necesario que el esquema convergente
quede determinado.

Para el método de Jacobi basta
teclear:

>> S=diag(diag(A));%crea la matriz
diagonal

>> T=S-A;

>>B=inv(S)*T;

>>eig(B)

Que arroja:

ans =

-6.2572

-0.3709

0.4470

0.7060

0.8199

0.8800

0.9156

0.9386

0.9545

0.9666

Como cada uno de los valores propios es menor que
("<1"),entonces el esquema de convergencia "A", sirve para
obtener las ecuaciones iterativas del método de
Jacobi.

Para el método de Gauss-Seidel:

>> L=tril(A,-1);

>>D=diag(diag(A));

>> S=D+L;

>> T=S-A;

>>B=inv(S)*T;

>> eig(B)

Que arroja:

ans =

0.5000

0.6667

0.7500

0.8000

0.8333

0.8571

0.8750

0.8889

0.9000

Como cada uno de los valores propios es menor que
("<1"),entonces el esquema de convergencia "A", sirve para
obtener las ecuaciones iterativas del método de
Gauss-Seidel.

Como ya se ha determinado la matriz de coeficientes del
sistema, ahora sólo resta elegir el vector de
términos independientes y determinar la solución
del sistema(para ayudarnos a ver mejor el comportamiento
de los métodos).

Como todo sistema se puede escribir como Ax=b,
utilizaremos

a matlab para resolverlo por x = (inversa de
A)*b.(solución por la inversa)

Entonces se teclea:

>>b=[11;2;9;20;5;6;7;0;1;3];%vector de
términos independientes

>> x=inv(A)*b;%solución por la
inversa

El resultado obtenido será:

x =

-16

-4

-16

-8

-1

Que es el vector solución que se presumirá
obtener por los métodos a evaluar.

Nuestro sistema quedará entonces de la siguiente
manera:

Que es la forma matricial Ax=b.

METODOS DIRECTOS

Puesto que ya se determinó el sistema con el cual
se trabajará, ahora se centrará la atención en la programación de los métodos
directos.

La lógica
de los algoritmos(procedimientos no
ambiguos que resuelven problemas),sugieren que el cuerpo de la
implementación sea:

1)Captura de los datos de
entrada.

2)Implementación de un método
directo.

3)Implementación de los procedimientos
progresivos y regresivos que llevan a la
solución.

4)Salida y presentación de los
resultados.

Se explicara solo los detalles del método de
Doolittle, cuya lógica

es aplicable a los restantes métodos directos
respecto a los itenes

y 3).

DOOLITTLE

(Captura de los datos de
entrada)

¿Que es lo que necesita un método directo
para poder
empezar?

Resulta lógico pensar que necesita A y b (Ax=b),
pero si esto se hace pidiéndole al usuario que digite A y
luego b, se corre el riesgo que digite
mal los datos, además resulta muy cansado
hacerlo.

Podría además digitar un tamaño de
matriz que no corresponde a la matriz.

Para aminorar un poco el riesgo, se le pedirá al
usuario que ingrese la matriz aumentada del sistema, de la cual
se sacará la información necesaria para que el
método funcione.

Como el tamaño de A es n*n, el tamaño de
la matriz aumentada es n*n+1, puesto que se incluye a "b"(una
columna mas).

El algoritmo de
captura quedaría como:

Lea matriz
Tam=tamaño(matriz)
Para i=1, n haga

b(i)=matriz(i,n+1) (determinar "b")

Para j=1, n haga

A(i,j)=matriz(i,j) (determinar "A")

Finpara

4- b1=transpuesta(b) ("b" es un vector
columna)

DOOLITTLE

(Implementación de los procedimientos
progresivos y regresivos que llevan a la
solución.)

Se utilizará un sistema de 3*3 y 4*4 para ver
el comportamiento

de "c" en L*c=b, y de "x" en Ux=c.

L*c=b

c(1)=b(1)

c(2)=b(2)-[l(2,1)*c(1)]

c(3)=b(3)-[l(3,1)*c(1)+l(3,2)*c(2)]

c(1)=b(1)

c(2)=b(2)-[l(2,1)*c(1)]

c(3)=b(3)-[l(3,1)*c(1)+l(3,2)*c(2)]

c(4)=b(4)-[l(4,1)*c(1)+l(4,2)*c(2)+l(4,3)*c(3)]

Es facil observar, que lo que se esta efectuando entre
corchetes([]), es una sumatoria.

También se observa que en L(i,j) , i<>j y
i>j

Además, de c(2) a c(n) se tiene que para L(i,j),
i=2,n y j=1,n-1

Entonces el esquema para c quedaria como:

c(1)=b(1)

c(i)=b(i)-Sumatoria(L(i,j)*c(i)), i<>j y i>j
para todo L(i,j)

con i=2,n y j=1,n-1

El procedimiento que
resume este comportamiento es:

c(1)=b(1)

Para i=2,n haga

z=0

Para j=1,n-1 haga

Si i<>j y i>j entonces

z=z+L(i,j)*c(j)

Finsi

Finpara

c(i)=b(i)-z

Finpara

Ux=c

x(3)=c(3)/u(3,3)

x(2)={c(1)-[u(2,3)*x(3)]}/u(2,2)

x(1)={c(1)-[ u(1,3)*x(3)+u(1,2)*x(2)
]}/u(1,1)

x(4)=c(4)/u(4,4)

x(3)={c(3)-[u(3,4)*x(4)]}/u(3,3)

x(2)={c(2)-[u(2,4)*x(4)+u(2,3)*x(3)]}/u(2,2)

x(1)={c(1)-[u(1,4)*x(4)+u(1,3)*x(3)+u(1,2)*x(2)]}/u(1,1)

Es facil observar, que lo que se esta efectuando entre
corchetes([]), es una sumatoria.

También se observa que en U(i,j) , i<>j y
i<j

Además, de x(n-1) a x(1) se tiene que para
U(i,j), i=n-1,1 y j=n,2

Entonces el esquema para x quedaria como:

x(n)=c(n)/u(n,n)

x(i)=c(i)-Sumatoria(U(i,j)*x(j)), i<>j y i<j
para todo U(i,j)

con i=n-1,1 y j=n,2

El procedimiento que resume este comportamiento
es:

x(n)=c(n)/u(n,n)

Para i=n-1,1 haga

Para j=n:-1:2 haga

Si I<>j y i<j entonces

z=z+U(i,j)*x(j)

Finsi

Finpara

x(i)=(c(i)-z)/U(i,i)

Finpara

A continuación se da el código
fuente con algunos comentarios sobre las instrucciones donde es
conveniente.

CODIGO FUENTE DE DOOLITTLE

matriz=input ('TECLEE LA MATRIZ AUMENTADA DEL SISTEMA,
por ejemplo: [5 -4 2 20;2 -3 4 19;1 1 3 10]n');

tam=size(matriz);%sacar el tamaño de la matriz
para determinar:

%A(matris de coeficientes) y b(vector de terminos
independientes)

n=tam(1);%saca el numero de filas de la
matriz(tamaño de A)

for i=1:n

b(i)=matriz(i,n+1);%determinar "b"

for j=1:n

A(i,j)=matriz(i,j);%determinar "A"

end

b1=b';% "b" es un vector columna

L=eye(n);%inicializa la "L" de doolittle(le da el
tamaño de A),y evita crear sus unos y ceros

for k=1:n-1 %factorizacion de
doolittle'''''''''''''''''''''''''''''

for i=k+1:n
%'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

L(i,k)=A(i,k)/A(k,k); %(se determina la
"L")'''''''''''''''''''''' '''''''''''

for j=1:n
%''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

A(i,j)=A(i,j)-A(k,j)*L(i,k);%(se determina la "U"(A se
transforma en U))

end
%'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

U=A;%cambio de
variable

c=b1;%se inicializa el vector "c", que tiene el mismo
tamaño de "b"(se determina c(1))

for i=2:n %procedimiento para hallar
"c"(progresivamente)

z=0;
%''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

for j=1:n-1
%''''''''L*c=b'''''''''''''''''''''''''''''''''''''''''''''''''''''''''

if i~=j & i>j
%''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

z=z+L(i,j)*c(j);%''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

end
%''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

c(i)=b1(i)-z;
%''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

end
%''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

x=c;%se inicializa el vector "x", que tiene el mismo
tamaño de "c"

x(n)=c(n)/U(n,n);%se determina x(n)(ultima solucion del
sistema)

for i=n-1:-1:1 %procedimiento para hallar
"x"(regresivamente)

z=0;
%'''''''''''''''''''''''''''''''''''''''''''''

for j=n:-1:2
%''''''U*x=c''''''''''''''''''''''''''''''''''

if i~=j & i<j
%'''''''''''''''''''''''''''''''''''''''''''''

z=z+U(i,j)*x(j);%'''''''''''''''''''''''''''''''''''''''''''''

end
%'''''''''''''''''''''''''''''''''''''''''''''

x(i)=(c(i)-z)/U(i,i);
%'''''''''''''''''''''''''''''''''''''''''''''

end
%'''''''''''''''''''''''''''''''''''''''''''''

L%muestra la matriz
triangular inferior de doolittle

U%muestra ''''''''''''''''''''''superior
''''''''''''

LU=L*U%muestra la factorizacion de doolittle

x%vector solucion del sistema

clear all%elimina las variables del
espacio de trabajo(evita
que el programa se
cargue de basura)

%ESVEN MORALES

CODIGO FUENTE DE CROUT

matriz=input ('TECLEE LA MATRIZ AUMENTADA DEL SISTEMA,
por ejemplo: [5 -4 2 20;2 -3 4 19;1 1 3 10]n');

tam=size(matriz);%sacar el tamaño de la matriz
para determinar

%A(matris de coeficientes)y b(vector de terminos
independientes)

n=tam(1);%saca el numero de filas de la
matriz

for i=1:n

b(i)=matriz(i,n+1);%determinar "b"

for j=1:n

A(i,j)=matriz(i,j);%determinar "A"

end

b1=b';% "b" es un vector columna

U=eye(n);%inicializa la "U" de crout(le da el
tamaño de A),y evita crear sus unos y ceros

for k=1:n-1 %factorizacion de
crout'''''''''''''''''''''

for j=k+1:n
%'''''''''''''''''''''''''''''''''''''''''''

U(k,j)=A(k,j)/A(k,k); %(se determina la
"U")''''''''''''''''''''''

for i=1:n
%'''''''''''''''''''''''''''''''''''''''''''

A(i,j)=A(i,j)-A(i,k)*U(k,j);%(se determina la "L"(A se
transforma en L))

end
%'''''''''''''''''''''''''''''''''''''''''''

L=A;%cambio de variable

c=b1;%se inicializa el vector "c", que tiene el mismo
tamaño de "b"

c(1)=b1(1)/L(1,1);%se determina el primer elemento de
c

for i=2:n %procedimiento para hallar
"c"(progresivamente)

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;%se inicializa el vector "x", que tiene el mismo
tamaño de "c"

for i=n-1:-1:1 %procedimiento para hallar
"x"(regresivamente)

s=0;
%'''''''''''''''''''''''''''''''''''''''''''''

for j=n:-1:2
%'''''''''''''''''''''''''''''''''''''''''''''

if i~=j & i<j
%'''''''''''''''''''''''''''''''''''''''''''''

s=s+U(i,j)*x(j);%'''''''''''''''''''''''''''''''''''''''''''''

end
%'''''''''''''''''''''''''''''''''''''''''''''

x(i)=c(i)-s;
%'''''''''''''''''''''''''''''''''''''''''''''

end
%'''''''''''''''''''''''''''''''''''''''''''''

L%muestra la matriz triangular inferior de
crout

U%muestra ''''''''''''''''''''''superior
''''''''

LU=L*U%muestra la factorizacion de crout

x%vector solucion del sistema

clear all%elimina las variables del espacio de
trabajo(evita que el programa se cargue de basura)

%ESVEN MORALES

CODIGO FUENTE DE CHOLESKY

matriz=input ('TECLEE LA MATRIZ AUMENTADA DEL SISTEMA,
por ejemplo: [5 -4 2 20;2 -3 4 19;1 1 3 10]n');

tam=size(matriz);%sacar el tamaño de la matriz
para determinar A(matris de coeficientes)

% y b(vector de terminos independientes)

n=tam(1);%saca el numero de filas de la
matriz

for i=1:n

b(i)=matriz(i,n+1);%determinar "b"

for j=1:n

A(i,j)=matriz(i,j);%determinar "A"

end

b1=b';% "b" es un vector columna

for k=1:n %Algoritmo de cholesky

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 %Añade los ceros de la L de
cholesky

for j=1:n %''(puesto que el algoritmo solo
'''

if j>i %'''altera los elementos
de'''''''''

A(i,j)=0; %'''la diagonal principal de
A''''''

end %''''y por debajo de esta)''''''''''

end %'''''''''''''''''''''''''''''''''''

L=A;%cambio de variable

Lt=L';%Lt sera la U de cholesky(transpuesta de
L)

c=b1;%se inicializa el vector "c", que tiene el mismo
tamaño de "b"

c(1)=b1(1)/L(1,1);%se determina el primer elemento de
c

for i=2:n %procedimiento para hallar
"c"(progresivamente)

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;%se inicializa el vector "x", que tiene el mismo
tamaño de "c"

x(n)=c(n)/Lt(n,n);%se determina x(n)(ultima solucion del
sistema)

for i=n-1:-1:1 %procedimiento para hallar
"x"(regresivamente)

z=0;
%'''''''''''''''''''''''''''''''''''''''''''''

for j=n:-1:2
%''''''Lt*x=c''''''''''''''''''''''''''''''''''

if i~=j & i<j
%'''''''''''''''''''''''''''''''''''''''''''''

z=z+Lt(i,j)*x(j);%'''''''''''''''''''''''''''''''''''''''''''''

end
%'''''''''''''''''''''''''''''''''''''''''''''

x(i)=(c(i)-z)/Lt(i,i);
%'''''''''''''''''''''''''''''''''''''''''''''

end
%'''''''''''''''''''''''''''''''''''''''''''''

L%muestra la matriz triangular inferior de
cholesky

Lt%muestra ''''''''''''''''''''''superior
''''''''

LLt=L*Lt%muestra la factorizacion de cholesky

x%vector solucion del sistema

clear all%elimina las variables del espacio de
trabajo(evita que el programa se cargue de basura)

%ESVEN MORALES

RESULTADOS CON
LOS METODOS DIRECTOS

DOOLITTLE

L =

1 0 0 0 0 0 0 0 0 0

1 1 0 0 0 0 0 0 0 0

1 1 1 0 0 0 0 0 0 0

1 1 1 1 0 0 0 0 0 0

1 1 1 1 1 0 0 0 0 0

1 1 1 1 1 1 0 0 0 0

1 1 1 1 1 1 1 0 0 0

1 1 1 1 1 1 1 1 0 0

1 1 1 1 1 1 1 1 1 0

1 1 1 1 1 1 1 1 1 1

U =

1 1 1 1 1 1 1 1 1 1

0 1 1 1 1 1 1 1 1 1

0 0 1 1 1 1 1 1 1 1

0 0 0 1 1 1 1 1 1 1

0 0 0 0 1 1 1 1 1 1

0 0 0 0 0 1 1 1 1 1

0 0 0 0 0 0 1 1 1 1

0 0 0 0 0 0 0 1 1 1

0 0 0 0 0 0 0 0 1 1

0 0 0 0 0 0 0 0 0 1

LU =

1 1 1 1 1 1 1 1 1 1

1 2 2 2 2 2 2 2 2 2

1 2 3 3 3 3 3 3 3 3

1 2 3 4 4 4 4 4 4 4

1 2 3 4 5 5 5 5 5 5

1 2 3 4 5 6 6 6 6 6

1 2 3 4 5 6 7 7 7 7

1 2 3 4 5 6 7 8 8 8

1 2 3 4 5 6 7 8 9 9

1 2 3 4 5 6 7 8 9 10

x =

-16

-4

-16

-8

-1

CROUT

L =

1 0 0 0 0 0 0 0 0 0

1 1 0 0 0 0 0 0 0 0

1 1 1 0 0 0 0 0 0 0

1 1 1 1 0 0 0 0 0 0

1 1 1 1 1 0 0 0 0 0

1 1 1 1 1 1 0 0 0 0

1 1 1 1 1 1 1 0 0 0

1 1 1 1 1 1 1 1 0 0

1 1 1 1 1 1 1 1 1 0

1 1 1 1 1 1 1 1 1 1

U =

1 1 1 1 1 1 1 1 1 1

0 1 1 1 1 1 1 1 1 1

0 0 1 1 1 1 1 1 1 1

0 0 0 1 1 1 1 1 1 1

0 0 0 0 1 1 1 1 1 1

0 0 0 0 0 1 1 1 1 1

0 0 0 0 0 0 1 1 1 1

0 0 0 0 0 0 0 1 1 1

0 0 0 0 0 0 0 0 1 1

0 0 0 0 0 0 0 0 0 1

LU =

1 1 1 1 1 1 1 1 1 1

1 2 2 2 2 2 2 2 2 2

1 2 3 3 3 3 3 3 3 3

1 2 3 4 4 4 4 4 4 4

1 2 3 4 5 5 5 5 5 5

1 2 3 4 5 6 6 6 6 6

1 2 3 4 5 6 7 7 7 7

1 2 3 4 5 6 7 8 8 8

1 2 3 4 5 6 7 8 9 9

1 2 3 4 5 6 7 8 9 10

x =

-16

-4

-16

-8

-1

cholesky

L =

1 0 0 0 0 0 0 0 0 0

1 1 0 0 0 0 0 0 0 0

1 1 1 0 0 0 0 0 0 0

1 1 1 1 0 0 0 0 0 0

1 1 1 1 1 0 0 0 0 0

1 1 1 1 1 1 0 0 0 0

1 1 1 1 1 1 1 0 0 0

1 1 1 1 1 1 1 1 0 0

1 1 1 1 1 1 1 1 1 0

1 1 1 1 1 1 1 1 1 1

Lt =

1 1 1 1 1 1 1 1 1 1

0 1 1 1 1 1 1 1 1 1

0 0 1 1 1 1 1 1 1 1

0 0 0 1 1 1 1 1 1 1

0 0 0 0 1 1 1 1 1 1

0 0 0 0 0 1 1 1 1 1

0 0 0 0 0 0 1 1 1 1

0 0 0 0 0 0 0 1 1 1

0 0 0 0 0 0 0 0 1 1

0 0 0 0 0 0 0 0 0 1

LLt =

1 1 1 1 1 1 1 1 1 1

1 2 2 2 2 2 2 2 2 2

1 2 3 3 3 3 3 3 3 3

1 2 3 4 4 4 4 4 4 4

1 2 3 4 5 5 5 5 5 5

1 2 3 4 5 6 6 6 6 6

1 2 3 4 5 6 7 7 7 7

1 2 3 4 5 6 7 8 8 8

1 2 3 4 5 6 7 8 9 9

1 2 3 4 5 6 7 8 9 10

x =

-16

-4

-16

-8

-1

Nota: como éste trabajo solo fue realizado
por una sola persona, no tuvo
tiempo para
implementar los métodos iterativos(a pesar de que son mas
fáciles de implementar).

No obstante el trabajo de
escritorio que si realizó, y las investigaciones
personales que hizo, dieron pie para poder

Sacar las próximas conclusiones.

CONCLUSIONES

Ventajas y desventajas de los métodos
iterativos comparados con los métodos
directos.

Ventajas

*Probablemente más eficientes que los directos
para sistemas de orden muy alto.

*Mas simples de programar.

*Puede aprovecharse una aproximación a la
solución ,si tal aproximación existe.

*Se obtienen fácilmente aproximando burdas de la
solución.

*Son menos sensibles a los errores de redondeo(valioso
en sistemas

mal condicionados).

*Se requiere menos memoria de
máquina.Generalmente, las necesidades de memoria son
proporcionales al orden de la matriz.

Desventajas

*Si se tienen varios sistemas que comparten la matriz
coeficiente, esto no representará ahorro de
cálculos ni tiempo de máquina, ya que por cada
vector a la derecha de A tendrá que aplicarse el
método

seleccionado.

*Aún cuando la convergencia este asegurada, puede
ser lenta y ,por lo tanto, los cálculos requeridos para
obtener una solución particular

no son predecibles.

*El tiempo de máquina y la exactitud del
resultado dependen del

criterio de convergencia.

*Si la convergencia es lenta, los resultados deben
interpretarse con cautela.

*No se tiene ventaja particular alguna(tiempo de
máquina por iteración) si la matriz coeficiente es
simétrica.

*No se obtiene la inversa de A ni el determinante de
A.

BIBLIOGRAFÍA

-INTRODUCCION AL ÁLGEBRA LINEAL. Antón
Howard. 2da Ed

-METODOS
NUMERICOS PARA INGENIEROS. Chapra/Canale

Mc-Graw Hill. 4a Ed

ESVEN SALOMON MORALES BITAR

UNIVERSIDAD AUTONOMA DEL CARIBE

INGENIERIA DE SISTEMAS

BARRANQUILLA / ATLANTICO