¡Descarga Métodos Numéricos: Resolución de Sistemas Lineales y Optimización y más Apuntes en PDF de Métodos Numéricos solo en Docsity!
Métodos Numéricos (Corrección
Actividad 3)
Considere el sistema lineal
resuelva el sistema usando el comando solve de numpy y el método de Jacobi y Gauss-Seidel con un vector inicial
Cambie la entrada de la matriz por el valor , observe que la matriz ya no es diagonal dominante. Resuelva por
Gauss-Seidel y explique el resultado.
Cambie la entrada de la matriz por el valor. Resuelva por Gauss-Seidel y explique el resultado.
Pregunta 1
( (^) −^92 − 83 ) (^ x x^1 ) = ( ) 2
6 − 4
x (^0 )^ = ( 0 , 0 )⊺ ( 1 , 1 ) 1
( 2 , 2 ) 1
Llamamos a las librerías básicas y de nimos el método de Jacobi y el de Gauss-Seidel.
import numpy as np import matplotlib.pyplot as plt
def Jacobi(A,b,x0,tol,maxit): delta = 1 xi = x D = np.diag(np.diag(A)) for i in range(maxit): r = b - A@xi delta = np.linalg.solve(D,r) xi = xi + delta if (np.linalg.norm(delta) < tol): break return xi,i
def GaussSeidel(A,b,x0,tol,maxit): delta = 1 xi = x Q = np.diag(np.diag(A))+np.tril(A,-1) for i in range(maxit): r = b - A@xi delta = np.linalg.solve(Q,r) xi = xi + delta if (np.linalg.norm(delta) < tol): break return xi,i
De nimos el sistema lineal del problema y lo resolvemos mediante el comando solve, el método de Jacobi y el Gauss-
Seidel. Observamos que producen prácticamente los mismos resultados (di eren en la séptima cifra decimal debido a la
precisión).
A = np.array([[ 9 ,-3],[-2, 8 ]]) b = np.array([ 6 ,-4]) x0 = np.array([ 0 , 0 ])
xsolve = np.linalg.solve(A, b) xJ, iJ = Jacobi(A, b, x0, 1E-6, 50 ) xGS, iGS = GaussSeidel(A, b, x0, 1E-6, 50 )
print(xsolve) print(xJ) print(xGS)
[ 0.54545455 -0.36363636] [ 0.54545436 -0.36363624] [ 0.54545459 -0.36363635]
Cambiamos la entrada 1,1 de la matriz (note que la matriz ya no es estrictamente diagonal dominante) y observamos que
si bien los métodos iterativos convergen a la misma solución que el comando solve el método de Jacobi no converge con
la precisión deseada. El resultado es exacto con el comando solve puesto que este no utiliza un método iterativo.
A = np.array([[ 1 ,-3],[-2, 8 ]]) b = np.array([ 6 ,-4]) x0 = np.array([ 0 , 0 ])
xsolve1 = np.linalg.solve(A, b) xJ1, iJ1 = Jacobi(A, b, x0, 1E-6, 50 ) xGS1, iGS1 = GaussSeidel(A, b, x0, 1E-6, 50 )
print(xsolve1) print(xJ1) print(xGS1)
[18. 4.] [17.98645422 3.99698983] [17.99999094 3.99999773]
Si cambiamos la entrada 2,2 de la matriz de coe cientes la matriz sigue sin ser diagonal dominante solo que ahora esta
cualidad se puede veri car en todas sus las. Observamos que tanto el método de Jacobi como el de Gauss-Seidel
divergen.
A = np.array([[ 1 ,-3],[-2, 1 ]]) b = np.array([ 6 ,-4]) x0 = np.array([ 0 , 0 ])
xsolve2 = np.linalg.solve(A, b) xJ2, iJ2 = Jacobi(A, b, x0, 1E-6, 50 ) xGS2, iGS2 = GaussSeidel(A, b, x0, 1E-6, 50 )
print(xsolve2) print(xJ2) print(xGS2)
[ 1.2 -1.6] [-3.41163456e+19 4.54884608e+19] [6.46625022e+38 1.29325004e+39]
Utilice el método de Jacobi, Gauss-Seidel y SOR ( ) para resolver el siguiente sistema lineal con una precisión de
cuatro cifras decimales.
Pregunta 2 ω = 1.
=
⎛
⎝
⎜ ⎜ ⎜
7 1 − 1 2
1 8 0 − 2
− 1 0 4 − 1
2 − 2 − 1 6
⎞
⎠
⎟ ⎟ ⎟
⎛
⎝
⎜ ⎜ ⎜
x 1 x 2 x 3 x 4
⎞
⎠
⎟ ⎟ ⎟
⎛
⎝
⎜ ⎜ ⎜
3 − 5 4 − 3
⎞
⎠
⎟ ⎟ ⎟
La solución por el método de Jacobi en 17 iteraciones, es: [ 0.99999739 -0.99999739 1.00000014 -0. La solución por el método de Gauss Seidel en 9 iteraciones, es: [ 0.99999838 -0.99999869 1.0000007 -0. La solución por el método de SOR, con omega=1.4, en 14 iteraciones, es: [ 1.00000236 -1.00000072 1.
Calculamos los errores.
print(f"Error método de Jacobi {np.linalg.norm(sol- solJacobi)/np.linalg.norm(sol)* 100 :.5f}%") print(f"Error método de Gauss Seidel {np.linalg.norm(sol- solGS)/np.linalg.norm(sol)* 100 :.5f}%") print(f"Error método de SOR {np.linalg.norm(sol- solSOR)/np.linalg.norm(sol)* 100 :.5f}%")
Error método de Jacobi 0.00029% Error método de Gauss Seidel 0.00012% Error método de SOR 0.00012%
Variamos el valor de ω e imprimimos las iteraciones.
w Iteraciones 1.0 9 1.1 6 1.2 8 1.3 11 1.4 14 1.5 19 1.6 25 1.7 36 1.8 57 1.9 121 2.0 299
iteraciones = [] for w in np.arange( 1 ,2.1,0.1): solSOR, iSOR = SOR(A, b, np.zeros_like(b), w, 1e-5, 300 ) iteraciones.append(iSOR)
import pandas as pd data = {"w" : np.arange( 1 ,2.1,0.1), "Iteraciones" : iteraciones}
df = pd.DataFrame(data) df df.style.format({'w': '{:,.1f}'.format}).hide_index()
Observamos que si ω = 2 el método no converge, por lo que no gra camos este valor.
iteraciones[-1] = np.nan plt.plot(np.arange( 1 ,2.1,0.1), iteraciones, 'bo-') plt.ylabel("Iteraciones") plt.xlabel(r"$\omega$") plt.xticks(np.arange( 1 ,2.1,0.1))
plt.show()
Como observamos el mínimo número de iteraciones se tiene para ω = 1.
w = 1. solSOR, iSOR = SOR(A, b, np.zeros_like(b), w, 1e-5, 100 ) print("La solución por el método de SOR, con omega =", w," en", iSOR, "iteraciones, es: ", solSOR, "\n") print(f"Error método de SOR {np.linalg.norm(sol- solSOR)/np.linalg.norm(sol)* 100 :.5f}%")
La solución por el método de SOR, con omega = 1.1 en 6 iteraciones, es: [ 0.99999967 -0.99999952 1. Error método de SOR 0.00003%
Megamaxi tiene un espacio limitado en sus perchas y debe utilizarlo con e cacia para incrementar las utilidades. Dos
marcas de cereal, Zucaritas y Chocapic, compiten por un total de espacio de 60 m en anaqueles. Una caja de Zucaritas
ocupa .2 m , y una caja de Chocapic requiere .4 m. Las demandas diarias máximas de Zucaritas y Chocapic son de 200
y 120 cajas, respectivamente. Una caja de Zucaritas provee una utilidad neta de $1.00 y la de una de Chocapic es de
$1.35. Megamaxi considera que como la utilidad neta de Chocapic es 35% mayor que la de Zucaritas, a Chocapic se le
debe asignar 35% más espacio que a Zucaritas, lo que equivale a asignar aproximadamente 57% a Chocapic y 43% a
Zucaritas. ¿Usted qué piensa?
Pregunta 3
2 2 2
Pregunta 4
