Métodos numéricos

Enviado por esvenmobit

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