#Diagrama de flujo
T = np.linspace(-1, 1, 25)
Y = np.linspace(-1, 3, 25)
F = np.array([[f(t, y) for t in T] for y in Y])
F = np.arctan(F)
U = np.cos(F)
V = np.sin(F)
plt.quiver(T, Y, U, V)
plt.show()
# Ahora apliquemos el metodo de Euler implicito con paso $h=0.5$ a nuestra función
I = (0, 20)
y0 = 0.5
T, W = odesolver.solve(f, y0, I, 40, method="Implicit Euler")
print('y(20) con EI, 40 pasos: ' + str(W[0, 40]))
#EE con 40,80,100 y 120 pasos
T2, W2 = odesolver.solve(f, y0, I, 120, method="Explicit euler")
T3, W3 = odesolver.solve(f, y0, I, 100, method="Explicit Euler")
T4, W4 = odesolver.solve(f, y0, I, 80, method="Explicit Euler")
T5, W5 = odesolver.solve(f, y0, I, 40, method="Explicit Euler")
print('y(20) con EE, 40 pasos: ' + str(W5[0, 40]))
print('y(20) con EE, 80 pasos: ' + str(W4[0, 80]))
print('y(20) con EE, 100 pasos: ' + str(W3[0, 100]))
print('y(20) con EE, 120 pasos: ' + str(W2[0, 120]))
#RK2/3 con tol 0.1 y 0.01
T6, W6 = odesolver.solve(f, y0, I, method="RK23", tol=0.1, initialStep=0.5)
# Tomemos el siguiente PVI:
# y_1' = - y_1 + y_2
# y_2' =- y_1 - y_2
# con
# y_1(0)=0
# y_2(0)=1, en [0,1]
# Este tiene solucion exacta:
# y_1(t) = e^{-t}\sin(t)
# y_2(t) = e^{-t}\cos(t)
f = lambda t, y: np.array([-y[0] + y[1], -y[0] - y[1]])
soln = lambda t: np.array([np.exp(-T) * np.sin(T), np.exp(-T) * np.cos(T)])
y0 = np.array([0, 1])
#Ahora calculemos con punto medio implicito y paso h=1/10
T, W = odesolver.solve(f, y0, (0, 1), 10, method='Implicit Midpoint')
globalError1 = linear.norm(W[:, 10] - soln(T)[:, 10])
dif = abs(W[:, 10] - soln(T)[:, 10]) #error global por entrada en t=1
print('Punto Medio Implicito h=1/10')
print('Approximaciones: ' + str(W[:, 10]))
print('Diferencias Absolutas: ' + str(dif))
print('Error Global: ' + str(globalError1))
#Ahora con h = 1/100
T, W = odesolver.solve(f, y0, (0, 1), 100, method='Implicit Midpoint')
globalError2 = linear.norm(W[:, 100] - soln(1)[:, 100])
dif = abs(W[:, 100] - soln(T)[:, 100]) #error global por entrada en t=1
print('Punto Medio Implicito h=1/100')
print('Approximaciones: ' + str(W[:, 10]))
print('Diferencias Absolutas: ' + str(dif))
print('Error Global: ' + str(globalError2))
import matplotlib.pyplot as plt
from math import *
from IPython.display import Latex
import odesolver
# # Ejercicio 2
#Tomando el PVI del ejercicio 1
f = lambda t, y : y+2*np.exp(-t)
exact = lambda t, t0, y0 : np.exp(t)*(y0*np.exp(-t0)+np.exp(-2*t0)-np.exp(-2*t))
I = (0, 1)
y0 = 1
y1 = exact(1,0,1)
#Resolvemos con trapecio explicito y pasos h=1/10
T, W = odesolver.solve(f,y0,I,10,method="Explicit Trapezoid")
globalError = abs(W[0,10]-y1)
print("Error Trapecio Explicito h = 1/10: "+str(globalError))
#Veamos lo que sucede cuando usamos el paso h/2=0.05
T, W = odesolver.solve(f,y0,I,20,method="Explicit Trapezoid")
globalError = abs(W[0,20]-y1)
print("Error Trapecio Explicito h = 1/20: "+str(globalError))
#Ahora calcuemos el error global en t=1 usando el método Runge-Kutta 4 usando h1:
T, W = odesolver.solve(f,y0,I,10,method="RK4")
globalError = abs(W[0,10]-y1)
print("Error RK4 h = 1/10: "+str(globalError))
print('exact(1) == 1-pi/20: ' + str(exact(1) == 1 - pi / 20))
print(
'\n\nPara aplicar Shooting Method, tomamos una aproximación inicial de y_2 = 0'
)
print('y_1(t) = 1')
print('y_2(t) = 0')
print(
"\ny utilizaremos el método de Runge Kutta 4 con 1000 pasos para aproximar la función en y_1(1)"
)
y0 = [1, 0]
_, W = odesolver.solve(f, y0, (0, 1), 1000, method='rk4')
# In[7]:
ans = W[0][-1]
print('W(1) = ' + str(ans))
print('\nVeamos que tan acertada fue nuestra elección')
print('abs(W(1) - (1 - pi/20)) = ' + str(abs(ans - (1 - pi / 20))))
print(
'\nParece ser que nuestra aproximación inicial sobreestimó la solución. Usaremos el método de Newton para seguir generando aproximaciones.'
)
print(
# Ejercicio 1
#Definimos nuestra funcion f, el lado derecho del PVI y la solucion exacta
f = lambda t, y: y + 2 * np.exp(-t)
exact = lambda t, t0, y0: np.exp(t) * (y0 * np.exp(-t0) + np.exp(-2 * t0) - np.
exp(-2 * t))
#Guardamos y0 asi como los extremos de nuestro intervalo I
I = (0, 1)
y0 = 1
#Calculamos el valor exacto al tiempo 1
y1 = exact(1, 0, 1)
#Hacemos Euler Explicito con 10 pasos
T, W = odesolver.solve(f, y0, I, 10, method="Explicit Euler")
#Calculamos errores globales y locales e imprimimos resultados
globalError = abs(W[0, 10] - y1)
localErrors = [
abs(W[0, i + 1] - exact(T[i + 1], T[i], W[0, i])) for i in range(10)
]
maxLocalError = max(localErrors)
print("Aproximaciones: ")
print(W[0])
print("Error Global: " + str(globalError))
print("Maximo Error Local: " + str(maxLocalError))
#Grafica de la solucion
plt.plot(T, exact(T, 0, 1))
# Consideremos el PVI (\ref{eq:1}), cuya solucion (\ref{eq:2}) ha sido justificada previamente. Utilizemos los métodos:
# \begin{itemize}
# \item Euler Explícito
# \item Trapecio Explícito
# \item Punto Medio Explícito
# \item RK4
# \end{itemize}
# Con pasos $h\in\{1/50,1/100,1/200\}$ para calcular y comparar el error global en t=1
EG=[[0,0,0],[0,0,0],[0,0,0],[0,0,0]]
f = lambda t, y : y+2*np.exp(-t)
exact = lambda t, t0, y0 : np.exp(t)*(y0*np.exp(-t0)+np.exp(-2*t0)-np.exp(-2*t))
I = (0, 1)
y0 = 1
y1 = exact(1,0,1)
TEE, WEE = odesolver.solve(f,y0,I,50,method="Explicit Euler")
EG[0][0] = abs(WEE[0,50]-y1)
TEE1, WEE1 = odesolver.solve(f,y0,I,100,method="Explicit Euler")
EG[0][1] = abs(WEE1[0,100]-y1)
TEE2, WEE2 = odesolver.solve(f,y0,I,200,method="Explicit Euler")
EG[0][2] = abs(WEE2[0,200]-y1)
TTE, WTE = odesolver.solve(f,y0,I,50,method="Explicit Trapezoid")
EG[1][0]= abs(WTE[0,50]-y1)
TTE1, WTE1 = odesolver.solve(f,y0,I,100,method="Explicit Trapezoid")
EG[1][1] = abs(WTE1[0,100]-y1)
TTE2, WTE2 = odesolver.solve(f,y0,I,200,method="Explicit Trapezoid")
EG[1][2] = abs(WTE2[0,200]-y1)
TPE, WPE = odesolver.solve(f,y0,I,50,method="Explicit Midpoint")
EG[2][0]= abs(WPE[0,50]-y1)