Resuelva el siguiente sistema de ecuaciones lineales con todos los métodos presentados en esta
guía. Utilice una tolerancia en el residuo de 10-5 para la convergencia. En cada caso, estime el
costo del método en función del tiempo reloj de ejecución (comandos tic y toc de Scilab / Octave),
el número de iteraciones, tasa de convergencia (realizar gráficas semi-logarítmicas norma del
residuo vs. número de iteraciones), etc. Compare los resultados con el método directo de Gauss,
justificando si es necesario o no utilizar alguna estrategia de pivoteo. Analizar los resultados
obtenidos e indicar cual método piensa Ud. que es el más conveniente? Como justifica que los
métodos iterativos logren o no convergencia? Qué expectativa puede tener sobre la precisión de
los resultados obtenidos? Las entradas de la matriz de coeficientes del sistema lineal son,
Con i = 1…N y N = 250; 500; 1000. Las entradas del vector de términos independientes son b(i) = pi.
Utilice la norma infinito.
Resolución:
En primer lugar, utilizamos una función escrita en Scilab para generar las matrices y vectores de
términos independientes correspondientes: (1)
function [A, b]=cargarMatriz(n)
A = zeros(n, n);
i=1;
while(i<=n)
j=1;
b(i) = %pi;
while(j<=n)
if(j==i)
A(i,j) = 2*i;
else if(j == i+2 | j == i-2)
A(i,j) = 0.5*i;
else if(j == i+4 | j == i-4)
A(i,j) = 0.25*i;
else
A(i,j) = 0;
end
end
end
j = j+1;
end
i = i+1;
end
endfunction
La cual sigue las pautas estipuladas por el enunciado para generar la matriz y los vectores
independientes. Se ingresa N como dato, y se obtiene A y b como salida.
Todos los métodos iterativos que utilizaremos a continuación resuelven el sistema lineal Ax=b
comienzan con una aproximación inicial x0 a la solución x y generan una sucesión de vectores
la cual converge a x. Los métodos iterativos convierten el sistema Ax=b en otro
equivalente de la forma para alguna matriz T y un vector c. Luego de seleccionar
x0, la sucesión de vectores solución aproximada se generar utilizando para
cada k = 1,2..
El primer método que utilizaremos, el de Jacobi, genera cada a partir de los componentes de
. El método se escribe de la forma desarmando A en sus partes
diagonal y fuera de la diagonal, tal que A = D – L – U, siendo:
Para Jacobi, tenemos que y
Para N = 250, utilizando el método de Jacobi, cuyo código se muestra a continuación: (2)
function [x, it, r_h, t]=Jacobi(A, b, x0, maxit, tol)
tic();
nit = 0;
[m,n] = size(A);
r = 1;
r_h = [];
x = x0;
while (r>tol & nit<maxit)
xold = x;
for i=1:n
x(i)= (b(i)-A(i,1:i-1)*xold(1:i-1) - A(i,i+1:n)*xold(i+1:n))/A(i,i);
end
r = norm(b-(A*x),"inf");
r_h = [r_h,r];
nit = nit+1;
end
it = nit;
t = toc();
endfunction
Donde el criterio de convergencia utilizado es la comparación de una tolerancia con la norma
infinito del residuo, donde el residuo i-ésimo está dado por r(i) = b – A*x(i).
Invocando a la función con la siguiente línea, [x,it,r_h,t] = Jacobi(A,b,x0,100,10^-5) Donde x0 es el
vector nulo como aproximación inicial (En todos los métodos que siguen a continuación, usaremos
el vector nulo como aproximación inicial). Adicionalmente estableceremos un máximo de
iteraciones para no caer en un bucle infinito que impida la finalización del programa. Se obtienen
los siguientes resultados:
T = 0.726 segundos.
It (Número de iteraciones) = 46.
Gráfica Semi-Logarítmica: Norma del residuo Vs. Número de iteraciones.
Fig. 1: Gráfica de Norma del residuo Vs. Número de iteraciones para método de Jacobi con N=250.
Haciendo un análisis del método de Jacobi, vemos que a éste se le puede implementar una
mejora. Si queremos calcular , como para ya se calcularon las componentes
y probablemente estén más cerca de la solución buscada, parece razonable
reutilizarlas. Esto es lo que hace el método de Gauss-Seidel, donde: y
.
Ahora bien, utilizando el método de Gauss-Seidel: (3)
function [x, it, r_h, t]=Gauss_Seidel(A, b, x0, maxit, tol)
tic();
nit = 0;
[m,n] = size(A);
r = 1;
r_h = [];
x = x0;
while (r>tol & nit<maxit)
xold = x;
for i=1:n
x(i)= (b(i)-A(i,1:i-1)*x(1:i-1) - A(i,i+1:n)*xold(i+1:n))/A(i,i);
end
r = norm(b-(A*x),"inf");
r_h = [r_h,r];
nit = nit+1;
end
it = nit;
t = toc();
endfunction
Donde el criterio de convergencia utilizado es la norma infinito del residuo, donde el residuo i-
ésimo está dado por r(i) = b – A*x(i).
Obtenemos los siguientes resultados:
T = 0.144 segundos.
It = 10.
Gráfica semi-logarítmica:
Fig. 2: Gráfica de Norma del residuo Vs. Número de iteraciones para método de Gauss-Seidel con N=250.
El método de Gauss-Seidel puede caracterizarse escogiendo tal que:
Al modificar este procedimiento tal que:
Para ciertas opciones de w positivo la norma del vector residual se reduce y se logra una
convergencia mucho más rápida. Este procedimiento, que recibirá diferentes denominaciones
según el rango del w elegido, se designa con la abreviatura SOR (SuccesiveOver-Relaxation).
Dónde: y
Pasemos ahora a utilizar el método SOR, cuyo algoritmo se presenta a continuación: (4)
function [x, it, r_h, t]=SOR(W, A, b, x0, maxit, tol)
tic();
nit = 0;
[m,n] = size(A);
r = 1;
r_h = [];
x = x0;
while (r>tol & nit<maxit)
xold = x;
for i=1:n
x(i)= (1-W)*xold(i) + (W*(b(i)-A(i,1:i-1)*x(1:i-1) - A(i,i+1:n)*xold(i+1:n)))/A(i,i);
end
r = norm(b-(A*x),"inf");
r_h = [r_h,r];
nit = nit+1;
end
it = nit;
t = toc();
endfunction
Donde el criterio de convergencia utilizado es la norma infinito del residuo, donde el residuo i-
ésimo está dado por r(i) = b – A*x(i).
Con una elección de W = 1.05, nos arroja los siguientes resultados:
T = 0.174 segundos.
It = 11.
Gráfica semi-logarítmica:
Fig. 3: Gráfica de Norma del residuo Vs. Número de iteraciones para método de SOR con N=250 y W = 1.05.
El método del gradiente conjugado es un caso particular de método de descenso. Los métodos de
descenso están especialmente indicados para la resolución de sistemas huecos (Sistemas lineales
cuya matriz de coeficientes tiene un número importante de ceros). Si la matriz cuadrada A de
orden n es simétrica y definida positiva, entonces el gradiente de la función cuadrática:
g alcanza un mínimo en la solución de Ax = b.
Finalmente, con el último método iterativo visto, el del Gradiente Conjugado: (5)
function [x_k, k, rh, t]=gc(A, b, x0, tol, maxiter)
tic();
k = 0;
x_k = x0;
rh = [];
r_k = b-(A*x_k);
ninf = max(abs(r_k)); //ninf = norm(r_k,"inf")
v_kp1 = r_k //primera direccion descenso mas rapido (primer residuo)
while (k <= maxiter & ninf > tol)
dot1 = sum(r_k.^2);
vaux = A*v_kp1;
dot2 = v_kp1'*vaux;
t_kp1 = dot1/dot2;
x_kp1 = x_k + t_kp1*v_kp1;
r_kp1 = r_k - t_kp1*vaux;
//comienzo calculo de proxima direccion x gradiente conjugado
s_kp1 = sum(r_kp1.^2)/dot1;
v_kp1 = r_kp1 + s_kp1*v_kp1;
r_k = r_kp1;
ninf = max(abs(r_k));
rh = [rh,ninf];
x_k = x_kp1;
k = k+1;
end
t = toc();
endfunction
Donde el criterio de convergencia utilizado es la norma infinito del residuo, donde el residuo i-
ésimo está dado por r(i) = b – A*x(i).
El cual arroja los siguientes resultados, con un máximo de iteraciones = 1000:
T = 0.108 segundos.
It= 238.
Gráfica Semi-Logartímica:
Fig. 4: Gráfica de Norma del residuo Vs. Número de iteraciones para método del Gradiente Conjugado con N=250.
Ahora utilizaremos el método directo de Gauss y compararemos los resultados obtenidos. ¿Es
necesario realizar alguna especie de pivoteo? La respuesta es no, ya que en este caso los
elementos con mayor valor absoluto ya se encuentran en la diagonal de la matriz.
A continuación se detallan los algoritmos de Gauss y BackSub (Sustitución hacia a atrás): (6) (7)
function[x, t]=Gauss(A, b)
tic();
[m,n]=size(A);
x=zeros(n);
fork=[Link]n-1
A(k+1:n,k)=A(k+1:n,k)/A(k,k);
forj=k+[Link]n
A(k+1:n,j)=A(k+1:n,j)-(A(k+1:n,k)*A(k,j));
end
b(k+1:n)=b(k+1:n)-(A(k+1:n,k)*b(k));
end
x=backsub(A,b)
t=toc();
endfunction
functionx=backsub(U, b)
n=length(U(:,1));
tol=10^-5;
x=zeros(n,1);
if(abs(U(n,n))<tol)then
disp("Explotion warning");
return;
end
x(n)=b(n)/U(n,n);
fori=n-1:-1:1,
if(abs(U(i,i))<tol)then
disp("Explotion warning");
return;
end
x(i)=(b(i)-sum((U(i,i+1:n)*x(i+1:n))))/U(i,i);
end
endfunction
Los cuales arrojan los siguientes resultados:
T = 1.206 segundos.
Como vemos, este tiempo es notablemente mayor a cualquiera de los algoritmos utilizados
anteriormente.
Esto se puede justificar, ya que sabemos por teoría que el número de multiplicaciones/divisiones
para este algoritmo corresponde a la forma:
Y con N=250, son un total de 5270750 operaciones, sumadas a las
Sumas y restas, que dan un resultado de 5239375 operaciones.
Con este número exorbitante de operaciones, es justificable que este método directo tarde
considerablemente más que los demás métodos iterativos.
Analizando los métodos iterativos, sucede que, el método del gradiente conjugado, a pesar de ser
el que más iteraciones realiza, es el que converge en un tiempo más rápido, seguido por Gauss-
Seidel, luego SOR (Que puede justificarse su falta de optimización debido a una pobre elección del
W) y finalmente Jacobi.
Fig. 5: Gráfica de Norma del residuo Vs. Número de iteraciones para método de Jacobi (Negro) Gauss-Seidel (Azul), SOR (Rojo) y GC
(Verde) con N = 250.
Pasemos a analizar la matriz con N = 500.
Para Jacobi, tenemos:
T = 1.652 segundos.
It = 46.
Gráfica Semi-Logarítmica:
Fig. 6: Gráfica de Norma del residuo Vs. Número de iteraciones para método de Jacobi con N=500.
Para Gauss-Seidel, tenemos:
T = 0.42 segundos.
It = 10.
Gráfica Semi-Logarítmica:
Fig. 7: Gráfica de Norma del residuo Vs. Número de iteraciones para método de Gauss-Seidel con N=500.
Para SOR, con W = 1.05 tenemos:
T = 0.471 segundos.
It = 11.
Gráfica Semi-Logarítmica:
Fig. 8: Gráfica de Norma del residuo Vs. Número de iteraciones para método de SOR, W=1.05 con N=500.
Para GC, tenemos:
T = 0.42 segundos.
It = 325.
Gráfica Semi-Logarítmica:
Fig. 9: Gráfica de Norma del residuo Vs. Número de iteraciones para método del GC, N=500.
Para el método directo de Gauss, ahora tenemos:
T = 6.963 segundos.
Divisiones/Multiplicaciones: 41916599.
Sumas/Restas: 41791250.
Resultados similares que con la matriz con N=250 hemos obtenido aquí. El método del Gradiente
Conjugado igual al de Gauss-Seidel en cuestiones de tiempo, luego SOR (Con una diferencia menos
amplia) y último Jacobi.
Fig. 10: Gráfica de Norma del residuo Vs. Número de iteraciones para método de Jacobi (Negro) Gauss-Seidel (Azul), SOR (Rojo) y GC
(Verde) con N = 500.
Finalmente, para N = 1000, obtenemos los siguientes resultados:
Jacobi:
T = 4.083 segundos.
It = 46.
Gráfica Semi-Logarítmica:
Fig. 11: Gráfica de Norma del residuo Vs. Número de iteraciones para método de Jacobi, N=1000.
Gauss - Seidel:
T = 1.373 segundos.
It = 10.
Gráfica Semi-Logarítmica:
Fig. 12: Gráfica de Norma del residuo Vs. Número de iteraciones para método de Gauss-Seidel, N=1000.
SOR, W = 1.05:
T = 1.625 segundos.
It = 12.
Gráfica Semi-Logarítmica:
Fig. 13: Gráfica de Norma del residuo Vs. Número de iteraciones para método SOR, W=1.05, N=1000.
Gradiente Conjugado:
T = 1.835 segundos.
It = 438.
Gráfica Semi-Logarítmica:
Fig. 14: Gráfica de Norma del residuo Vs. Número de iteraciones para método de GC, N=1000.
Para el método directo de Gauss, ahora tenemos:
T = 48.591 segundos.
Divisiones/Multiplicaciones: 334333000.
Sumas/Restas: 333832500.
Resultados similares que con la matriz con N=250 y N=500. El método del Gradiente Conjugado,
notablemente superior, seguido de Gauss-Seidel, luego SOR y último Jacobi.
Fig. 15 Gráfica de Norma del residuo Vs. Número de iteraciones para método de Jacobi (Negro) Gauss-Seidel (Azul), SOR (Rojo) y GC
(Verde) con N = 1000.
Analizando los resultados obtenidos, nos aseguramos en decir que en particular, para el sistema
que estamos resolviendo, tanto con N= 250, 500, el método del Gradiente Conjugado, a pesar de
ser el que más iteraciones realiza, es el que en menos tiempo llega a un resultado con la
estimación precisada. Gauss-Seidel y SOR se mantienen parejos en todos los casos, aunque el
método de SOR depende esencialmente de la W utilizada. Jacobi es el menos eficiente de todos
los métodos. El último caso con N=1000 muestra una diferencia todos los demás, ya que GC deja
de ser el más eficiente. Podríamos decir que a medida que N aumenta, GC pierde eficiencia, ya
que con N=250 es superior a GS, pero con N = 500 son iguales en tiempo y con N = 1000, GS lo
supera. En los 3 casos, el método directo de Gauss demostró ser completamente ineficiente en
tiempo y cantidad de operaciones en comparación a los métodos iterativos. Analizando los
resultados obtenidos, nos aseguramos en decir que el método del Gradiente Conjugado es el
mejor cuando N es pequeña, seguido por GS.
¿Por qué Jacobi, Gauss-Seidel y SOR realizan siempre la misma cantidad de iteraciones sin
importar el tamaño de las matrices?
Existe un corolario que relaciona la rapidez de convergencia y el radio espectral de una matriz de
iteración T:
Por lo tanto, cuanto menor sea el radio espectral de la matriz T más rápido convergerá el método.
Para demostrar con un ejemplo, calcularemos el radio espectral de la matriz de iteración T de
Jacobi para N = 250, 500 y 1000.
En primer lugar usaremos una función que desmenuce la matriz A en L, D y U:
function [L, D, U]=SepararMatriz(A)
[m,n] = size(A);
L = zeros(n,n);
D = zeros(n,n);
U = zeros(n,n);
i=1;
while(i<=n)
j=1;
while(j<=n)
if(j==i)
D(i,j) = A(i,j);
else if(j > i)
U(i,j) = -A(i,j);
else
L(i,j) = -A(i,j);
end
end
j = j+1;
end
i = i+1;
end
endfunction
Una vez obtenidas estas matrices, calculamos la T con el comando T = inv(D)*(L+U) , luego
obtenemos los eigenvalores a través del comando p = spec(T) y finalmente el radio espectral está
dado por max(abs(p)) el cual para N = 250 es 0.7495369.
Haciendo el mismo procedimiento para N = 500, obtenemos p(T) = 0.7498829 y para N = 1000,
obtenemos p(T) = 0.7499706.
Observamos aquí que el radio espectral en estos tres casos analizados es similar hasta en 3 cifras
significativas, por ende, la fórmula presentada anteriormente que relaciona el radio espectral y la
velocidad de convergencia justificaría que los 3 métodos realicen la misma cantidad de
iteraciones.
¿Cómo justificamos que estos métodos de Jacobi, Gauss-Seidel y SOR logren la convergencia?
Básicamente, mediante el teorema que dice lo siguiente:
Para cualquier x0 perteneciente a la sucesión definida por:
Para cada , converge a la solución única de si y sólo sí .
Donde es el radio espectral de la matriz.
Por otro lado, para GC, citando al artículo “An Introduction to the Conjugate Gradient Method
without the Agonizing Pain” de Jonathan Richard Shewchuk, nos dice que una forma cuadrática es
una función cuadrática de un vector con la forma:
Se puede demostrar que si A es simétrica y definida positiva, la función es f es minimizada con la
solución de Ax = b. La función f derivada nos da
Y si A es simétrica,
Si A es definida positiva, la superficie definida por la función f es un paraboloide en el espacio N-
dimensional, donde N es el tamaño de la matriz. El valor mínimo de este paraboloide, donde el
gradiente es cero, es la solución de nuestro sistema. Analizando nuestra matriz A, tanto para
N=250, 500 o 1000, vemos que aunque no sea simétrica, sí es definida positiva, y el artículo
menciona que si A no es simétrica el método GC buscará una solución para el sistema
siendo este último simétrico. Así que la convergencia de nuestras matrices
bajo este método está definida, aunque estas no sean simétricas.
El método de gradiente conjugado puede ser mirado como un método directo, ya que en un
número finito de pasos conduce a la solución exacta (Si la matriz cumple las condiciones expuestas
anteriormente) aunque en la práctica se utiliza como un método iterativo. Es por ello que no
debemos considerar el hecho de que PUEDA o NO PUEDA lograr convergencia, sino que debemos
analizar en cuanto TIEMPO logra la convergencia, que ya está determinada.
Dada una precisión exacta, el número de iteraciones requeridas para lograr una solución exacta es
como máximo el número de diferentes eigenvalores de la matriz A. Como aquí no trabajamos con
precisión exacta, podemos decir que GC converge más rápido cuando los eigenvalores están más
agrupados entre sí, que cuando están irregularmente distribuidos entre el máximo y mínimo
eigenvalor.
Por otro lado, se verifica que:
Donde e(i) es el error de la i-ésima iteración. Esta inecuación tiene una alta relación con el número
de condición K de la matriz A. Por ende, podemos decir que un mal condicionamiento de la matriz
justifica la elevada cantidad de iteraciones que realiza GC hasta que converge. Para para N = 250.
Tenemos K(A) = 509.8574, luego, 238 iteraciones son necesarias.
¿Qué expectativa puede tener sobre la precisión de los resultados obtenidos? Para esta pregunta
aplicaremos otro teorema, el cual dice:
Supongamos que x* es una aproximación a la solución de Ax=b, que A es una matriz no singular y
que r es el vector residual de x*. Entonces, para toda natural, si x=/0 y b=/0
Donde se denomina número de condición de la matriz A.
Una matriz está bien condicionada si K está cerca de 1 y mal condicionada si K es mucho mayor a
1. El término de condición se refiere a la seguridad relativa de que un vector residual pequeño
implica una solución aproximada exacta correspondiente.
Por ejemplo, para N = 250. Tenemos K(A) = 509.8574, lo que significa que esta matriz está
demasiado mal condicionada, por lo tanto la precisión de los resultados obtenidos será muy mala.
Enunciado 2: Resuelva los siguientes sistemas lineales con el método de Gauss-Seidel y analice lo
que sucede en cada caso. Luego intente resolverlos mediante el método directo de eliminación de
Gauss. Es necesario aplicar alguna estrategia de pivoteo? Si lo fuera, justifique por qué.
Resolución:
Para el cálculo de los sistemas solicitados en primera instancia procedemos a cargar la matriz A y
el vector b correspondiente a cada uno en Scilab. Para el primer sistema se tiene:
Para el segundo sistema tenemos:
El método a utilizar para la resolución de sistemas es el de Gauss-Seidel. Este método es iterativo y
se diferencia de los métodos directos como el de Gauss por no buscar una solución exacta del
sistema, sino ir calculando progresivamente sucesivas aproximaciones de la solución buscada a
partir de una aproximación dada por el usuario, como se explicó en el enunciado anterior.
Procedemos mediante el software a ejecutar el algoritmo de Gauss-Seidel (3) con nuestras
matrices A1 y A2 y sus correspondientes vectores b1 y b2.
Para la ejecución necesitaremos establecer la calidad de la aproximación que buscamos y
determinar una aproximación inicial para que el algoritmo comience su ejecución.
Como no conocemos nada acerca de la solución daremos una aproximación inicial con el vector
nulo. Además estableceremos una tolerancia de error de 10e-2 y un máximo de 10 iteraciones.
Usando todo lo declarado hasta aquí ponemos el funcionamiento el algoritmo:
Aquí podemos ver que la solución aproximada que nos retorna el método es x= [0.9940741,
0.99555556, 0.9955556]. Además podemos ver que el método convergió en 4 iteraciones a esta
solución. La convergencia fue muy rápida como se puede ver en el vector r_h, los errores
residuales entre iteraciones sucesivas.
Para el segundo problema cambiamos los parámetros correspondientes y aplicamos la misma
sentencia:
De este grupo de resultados podemos observar que el método llego al máximo de iteraciones
antes de finalizar. Del vector r_h podemos ver que el método realmente no convergió a una
solución debido a que el error en cada iteración es creciente. El resultado que arrojo el algoritmo
como mencionamos no es una solución, pero, además de eso se puede observar que el método se
fue alejando progresivamente de la solución real, por lo que podemos concluir que el algoritmo no
tiene convergencia para el sistema planteado.
Alternativamente a la aplicación del método iterativo vamos a proceder a aplicar el método
directo más simple, el de Gauss, para establecer diferencias de convergencia y exactitud. Para los
sistemas usamos el algoritmo (6) del método de Gauss. Comenzaremos aplicando el algoritmo al
primer sistema:
El resultado obtenido es exacto, sin embargo la velocidad con la que se ejecuta es ligeramente
mayor al método iterativo.
Ahora procedemos a aplicar el mismo algoritmo para el segundo sistema:
Aquí observamos que al aplicar el algoritmo tenemos un error con la matriz en el proceso de
sustitución hacia atrás. Para solucionar este problema vamos a tener que realizar ciertos
intercambios de filas a fin de no quedarnos con ceros en la diagonal principal luego de realizar la
eliminación gaussiana, ya que recordemos que para calcular los elementos del vector solución se
divide por estos números. El método que aplicaremos es el de pivoteo parcial cuyo algoritmo se
muestra a continuación, en conjunto con la sustitución hacia atrás con índice: (8) (9)
function x = GausskijPivoteo(A, b)
[m,n] = size(A);
indx = [1:n];
tol = 1e-9;
x = zeros(n);
for k=[Link]n-1
aux = [k:n];
[max_pivot,indxmax]= max(abs(A(indx(aux),k)));
if (max_pivot<tol) then
disp("no");
return;
end
if (indx(k) ~= indx(aux(indxmax))) then
m = indx(k);
indx(k) = indx(aux(indxmax));
indx(aux(indxmax)) = m;
end
A(indx(k+1:n),k) = A(indx(k+1:n),k)/A(indx(k),k);
for j=k+1:n
A(indx(k+1:n),j) = A(indx(k+1:n),j) - (A(indx(k+1:n),k)*A(indx(k),j));
end
b(indx(k+1:n)) = b(indx(k+1:n)) - (A(indx(k+1:n),k)*b(indx(k)));
end
x = backsubI(A,b,indx)
endfunction
function x=backsubI(U, b, index)
n = length(U(:,1));
tol = 1e-9;
x = zeros(n,1);
if (abs(U(n,n))<tol) then
disp("Explotion warning");
return;
end
x(n) = b(index(n))/U(index(n),n);
for i=n-1:1
if (abs(U(index(i),i)<tol)) then
disp("Explotion warning");
return;
end
x(i) = (b(index(i)) - sum((U(index(i),i+1:n)*x(i+1:n))))/U(index(i),i);
end
endfunction
Una vez cargado el algoritmo en el entorno de Scilab procedemos a aplicar nuevamente el proceso
de Gauss a la matriz y vector del sistema 2:
Como se ve en esta ocasión se pudo llegar a la solución exacta mediante la alteración parcial del
problema original.
En conclusión, a pesar de la que los métodos directos son exactos para todas las soluciones y
pudieran parecer más “robustos” en algunos casos, tienen problemas elementales como los que
han surgido en el desarrollo de este ejercicio, sumado a la velocidad de resolución demasiado
inferior comparado a la de los métodos iterativos, como se comprobó en el ejercicio anterior. Por
otro lado, los métodos iterativos también presentan sus complicaciones, por ejemplo con el
segundo sistema planteado, el cual no converge para el x0 dado. Podríamos decir que lo que al
método de Gauss directo le falta de optimización temporal, lo suple con exactitud en los
resultados, en cambio el método iterativo de Gauss-Seidel “sacrifica” la exactitud total del
resultado, obteniendo un porcentaje mínimo de error pero reemplazándolo por una convergencia
en menor cantidad de tiempo.
