def Fig1():
# Figure #1 in the Lab: The solution of y'=y-2x+4, y(0)=0, is
# y(x) = -2 + 2x + (ya + 2)e^x. This code plots the solution for 0<x<2,
# and then plots the approximation given by Euler's method
# Text Example
a, b, ya = 0.0, 2.0, 0.0
def f(x,ya=0.):
return -2. + 2.*x + (ya + 2.)*np.exp(x)
def ode_f(x,y):
return np.array([1.*y -2.*x + 4.])
plt.plot(np.linspace(a,b,11), euler(ode_f,ya,a,b,11) , 'b-',label="h = 0.2")
plt.plot(np.linspace(a,b,21), euler(ode_f,ya,a,b,21) , 'g-',label="h = 0.1")
plt.plot(np.linspace(a,b,41), euler(ode_f,ya,a,b,41) , 'r-',label="h = 0.05")
x = np.linspace(0,2,200); k =int(200/40)
plt.plot(x[::k], f(x[::k]), 'k*-',label="Solution") # The solution
plt.plot(x[k-1::k], f(x[k-1::k]), 'k-') # The solution
plt.legend(loc='best')
plt.xlabel('x'); plt.ylabel('y')
# plt.savefig('Fig1.pdf')
plt.show()
plt.clf()
return
def problem_euler():
# Figure #2 in the Lab: The solution of y'=y-2x+4, y(0)=0, is
# y(x) = -2 + 2x + (ya + 2)e^x. This code plots the solution for 0<x<2,
# and then plots the approximation given by Euler's method
# Text Example
a, b, ya = 0.0, 2.0, 0.0
def f(x, ya=0.0):
return -2.0 + 2.0 * x + (ya + 2.0) * np.exp(x)
def ode_f(x, y):
return np.array([1.0 * y - 2.0 * x + 4.0])
plt.plot(np.linspace(a, b, 11), euler(ode_f, ya, a, b, 11), "b-", label="h = 0.2")
plt.plot(np.linspace(a, b, 21), euler(ode_f, ya, a, b, 21), "g-", label="h = 0.1")
plt.plot(np.linspace(a, b, 41), euler(ode_f, ya, a, b, 41), "r-", label="h = 0.05")
x = np.linspace(0, 2, 200)
k = int(200 / 40)
plt.plot(x[::k], f(x[::k]), "k*-", label="Solution") # The solution
plt.plot(x[k - 1 :: k], f(x[k - 1 :: k]), "k-") # The solution
plt.legend(loc="best")
plt.xlabel("x")
plt.ylabel("y")
# plt.savefig('prob1.pdf')
plt.show()
plt.clf()
return
def Exercise1():
a, b, ya = 0.0, 2.0, 0.0
def f(x, ya=0.):
return 4. - 2. * x + (ya - 4.) * np.exp(-x)
def ode_f(x, y):
return np.array([-1. * y - 2. * x + 2.])
plt.plot(np.linspace(a, b, 11),
euler(ode_f, ya, a, b, 11),
'b-',
label="h = 0.2")
plt.plot(np.linspace(a, b, 21),
euler(ode_f, ya, a, b, 21),
'g-',
label="h = 0.1")
plt.plot(np.linspace(a, b, 41),
euler(ode_f, ya, a, b, 41),
'r-',
label="h = 0.05")
x = np.linspace(0, 2, 200)
k = int(200 / 40)
plt.plot(x[::k], f(x[::k]), 'k*-', label="Solution") # The solution
plt.plot(x[k - 1::k], f(x[k - 1::k]), 'k-') # The solution
plt.legend(loc='best')
plt.xlabel('x')
plt.ylabel('y')
# plt.savefig('Exercise1.pdf')
plt.show()
plt.clf()
def problem_relative_error():
# Figure 3 in the lab.
a, b, ya = 0.0, 2.0, 0.0
def f(x, ya):
return -2.0 + 2.0 * x + 2.0 * np.exp(x)
def ode_f(x, y):
return np.array([1.0 * y - 2.0 * x + 4.0])
N = np.array([10, 20, 40, 80, 160]) # Number of subintervals
Euler_sol, Mid_sol, RK4_sol = np.zeros(len(N)), np.zeros(len(N)), np.zeros(len(N))
for j in range(len(N)):
Euler_sol[j] = euler(ode_f, ya, a, b, N[j])[-1]
Mid_sol[j] = midpoint(ode_f, ya, a, b, N[j])[-1]
RK4_sol[j] = RK4(ode_f, ya, a, b, N[j])[-1]
h = 2.0 / N
plt.loglog(h, abs((Euler_sol - f(2.0, 0.0)) / f(2.0, 0.0)), "-b", label="Euler method", linewidth=2.0)
plt.loglog(h, abs((Mid_sol - f(2.0, 0.0)) / f(2.0, 0.0)), "-g", label="Midpoint method", linewidth=2.0)
plt.loglog(h, abs((RK4_sol - f(2.0, 0.0)) / f(2.0, 0.0)), "-k", label="Runge Kutta 4", linewidth=2.0)
plt.xlabel("$h$", fontsize=16)
plt.ylabel("Relative Error", fontsize=16)
# plt.title("loglog plot of relative error in approximation of $y(2)$.")
plt.legend(loc="best")
# plt.savefig('relative_error.pdf')
plt.show()
plt.clf()
def Fig3():
a, b, ya = 0., 2., 0.
def f(x,ya):
return -2. + 2.*x + 2.*np.exp(x)
def ode_f(x,y):
return np.array([1.*y -2.*x + 4.])
N = np.array([10,20,40,80,160]) # Number of subintervals
Euler_sol, Mid_sol, RK4_sol = np.zeros(len(N)), np.zeros(len(N)), np.zeros(len(N))
for j in range(len(N)):
Euler_sol[j] = euler(ode_f,ya,a,b,N[j])[-1]
Mid_sol[j] = midpoint(ode_f,ya,a,b,N[j])[-1]
RK4_sol[j] = RK4(ode_f,ya,a,b,N[j])[-1]
h = 2./N
plt.loglog(h, abs(( Euler_sol - f(2.,0.))/f(2.,0.) ), '-b', label="Euler method" , linewidth=2.)
plt.loglog(h, abs(( Mid_sol - f(2.,0.))/f(2.,0.) ), '-g', label="Midpoint method", linewidth=2. )
plt.loglog(h, abs(( RK4_sol - f(2.,0.))/f(2.,0.) ), '-k', label="Runge Kutta 4" , linewidth=2. )
plt.xlabel("$h$", fontsize=16)
plt.ylabel("Relative Error", fontsize = 16)
# plt.title("loglog plot of relative error in approximation of $y(2)$.")
plt.legend(loc='best')
# plt.savefig('Fig3.pdf')
plt.show()
plt.clf()
def Fig4():
a, b, ya = 0., 8., 1.
from math import exp, sin, cos
def f(x):
return exp(sin(x))
def ode_f(x, y):
return np.array([y * cos(x)])
# Number of subintervals
N1 = np.array([
10, 20, 40, 80, 160, 320, 640, 1280, 2560, 5120, 10240, 20480, 40960,
81920, 163840, 327680, 655360, 1310720
])
N2, N3 = N1[:12], N1[:10]
Euler_sol, Mid_sol, RK4_sol = np.zeros(len(N1)), np.zeros(
len(N2)), np.zeros(len(N3))
for j in range(len(N1)):
Euler_sol[j] = euler(ode_f, ya, a, b, N1[j])[-1]
for j in range(len(N2)):
Mid_sol[j] = midpoint(ode_f, ya, a, b, N2[j])[-1]
for j in range(len(N3)):
RK4_sol[j] = RK4(ode_f, ya, a, b, N3[j])[-1]
# Data for a Table?
euler_error = np.concatenate((abs(
(Euler_sol - f(b)) / f(b))[:, np.newaxis], N1[:, np.newaxis]),
axis=1)
rk4_error = np.concatenate((abs(
(RK4_sol - f(b)) / f(b))[:, np.newaxis], 4 * N3[:, np.newaxis]),
axis=1)
# Plot number of function evaluations versus relative error
fig = plt.figure()
plt.loglog(N1,
abs((Euler_sol - f(b)) / f(b)),
'-b',
label="Euler method",
linewidth=2.)
plt.loglog(2 * N2,
abs((Mid_sol - f(b)) / f(b)),
'-g',
label="Midpoint method",
linewidth=2.)
plt.loglog(4 * N3,
abs((RK4_sol - f(b)) / f(b)),
'-k',
label="Runge Kutta 4",
linewidth=2.)
ax = fig.add_subplot(111)
plt.ylabel("Error", fontsize=16)
plt.xlabel("Functional Evaluations", fontsize=16)
ax.legend(loc='best')
# ax.invert_xaxis()
# plt.savefig('Fig4.pdf')
plt.show()
plt.clf()
def example_relative_error():
# Figure 3 in the lab.
a, b, ya = 0., 2., 0.
def ode_f(x, y):
return np.array([1. * y - 2. * x + 4.])
best_grid = 320 # number of subintervals in most refined grid
best_val = euler(ode_f, ya, a, b, best_grid)[-1]
smaller_grids = [10, 20, 40, 80] # number of subintervals in smaller grids
h = [2. / N for N in smaller_grids]
Euler_sol = [euler(ode_f, ya, a, b, N)[-1] for N in smaller_grids]
Euler_error = [abs((val - best_val) / best_val) for val in Euler_sol]
plt.loglog(h, Euler_error, '-b', label="Euler method", linewidth=2.)
# plt.xlabel("$h$", fontsize=16)
# plt.ylabel("Relative Error", fontsize = 16)
# plt.legend(loc='best')
plt.show()
plt.clf()
def example_relative_error():
# Figure 3 in the lab.
a, b, ya = 0.0, 2.0, 0.0
def ode_f(x, y):
return np.array([1.0 * y - 2.0 * x + 4.0])
best_grid = 320 # number of subintervals in most refined grid
best_val = euler(ode_f, ya, a, b, best_grid)[-1]
smaller_grids = [10, 20, 40, 80] # number of subintervals in smaller grids
h = [2.0 / N for N in smaller_grids]
Euler_sol = [euler(ode_f, ya, a, b, N)[-1] for N in smaller_grids]
Euler_error = [abs((val - best_val) / best_val) for val in Euler_sol]
plt.loglog(h, Euler_error, "-b", label="Euler method", linewidth=2.0)
# plt.xlabel("$h$", fontsize=16)
# plt.ylabel("Relative Error", fontsize = 16)
# plt.legend(loc='best')
plt.show()
plt.clf()
def Exercise1():
a, b, ya = 0.0, 2.0, 0.0
def f(x,ya=0.):
return 4. - 2.*x + (ya - 4.)*np.exp(-x)
def ode_f(x,y):
return np.array([-1.*y -2.*x + 2.])
plt.plot(np.linspace(a,b,11), euler(ode_f,ya,a,b,11) , 'b-',label="h = 0.2")
plt.plot(np.linspace(a,b,21), euler(ode_f,ya,a,b,21) , 'g-',label="h = 0.1")
plt.plot(np.linspace(a,b,41), euler(ode_f,ya,a,b,41) , 'r-',label="h = 0.05")
x = np.linspace(0,2,200); k =int(200/40)
plt.plot(x[::k], f(x[::k]), 'k*-',label="Solution") # The solution
plt.plot(x[k-1::k], f(x[k-1::k]), 'k-') # The solution
plt.legend(loc='best')
plt.xlabel('x'); plt.ylabel('y')
# plt.savefig('Exercise1.pdf')
plt.show()
plt.clf()
def problem_euler():
# Figure #2 in the Lab: The solution of y'=y-2x+4, y(0)=0, is
# y(x) = -2 + 2x + (ya + 2)e^x. This code plots the solution for 0<x<2,
# and then plots the approximation given by Euler's method
# Text Example
a, b, ya = 0.0, 2.0, 0.0
def f(x, ya=0.):
return -2. + 2. * x + (ya + 2.) * np.exp(x)
def ode_f(x, y):
return np.array([1. * y - 2. * x + 4.])
plt.plot(np.linspace(a, b, 11),
euler(ode_f, ya, a, b, 11),
'b-',
label="h = 0.2")
plt.plot(np.linspace(a, b, 21),
euler(ode_f, ya, a, b, 21),
'g-',
label="h = 0.1")
plt.plot(np.linspace(a, b, 41),
euler(ode_f, ya, a, b, 41),
'r-',
label="h = 0.05")
x = np.linspace(0, 2, 200)
k = int(200 / 40)
plt.plot(x[::k], f(x[::k]), 'k*-', label="Solution") # The solution
plt.plot(x[k - 1::k], f(x[k - 1::k]), 'k-') # The solution
plt.legend(loc='best')
plt.xlabel('x')
plt.ylabel('y')
# plt.savefig('prob1.pdf')
plt.show()
plt.clf()
return
def Exercise3():
a, b, ya = 0., 2., 0.
def f(x, ya):
return 4. - 2. * x + (ya - 4.) * np.exp(-x)
def ode_f(x, y):
return np.array([-1. * y - 2. * x + 2.])
N = np.array([10, 20, 40, 80, 160]) # Number of subintervals
Euler_sol, Mid_sol, RK4_sol = np.zeros(len(N)), np.zeros(len(N)), np.zeros(
len(N))
for j in range(len(N)):
Euler_sol[j] = euler(ode_f, ya, a, b, N[j])[-1]
Mid_sol[j] = midpoint(ode_f, ya, a, b, N[j])[-1]
RK4_sol[j] = RK4(ode_f, ya, a, b, N[j])[-1]
# print Euler_sol, Mid_sol, RK4_sol
# print "Answer = ", f(2.,0.)
h = 2. / N
plt.loglog(h,
abs((Euler_sol - f(2., 0.)) / f(2., 0.)),
'-b',
label="Euler method",
linewidth=2.)
plt.loglog(h,
abs((Mid_sol - f(2., 0.)) / f(2., 0.)),
'-g',
label="Midpoint method",
linewidth=2.)
plt.loglog(h,
abs((RK4_sol - f(2., 0.)) / f(2., 0.)),
'-k',
label="Runge Kutta 4",
linewidth=2.)
plt.xlabel("$h$", fontsize=16)
plt.ylabel("Relative Error", fontsize=16)
plt.title("loglog plot of relative error in approximation of $y(2)$.")
plt.legend(loc='best')
# plt.savefig("Exercise3.pdf")
# plt.show()
plt.clf()
def problem_relative_error():
# Figure 3 in the lab.
a, b, ya = 0., 2., 0.
def f(x, ya):
return -2. + 2. * x + 2. * np.exp(x)
def ode_f(x, y):
return np.array([1. * y - 2. * x + 4.])
N = np.array([10, 20, 40, 80, 160]) # Number of subintervals
Euler_sol, Mid_sol, RK4_sol = np.zeros(len(N)), np.zeros(len(N)), np.zeros(
len(N))
for j in range(len(N)):
Euler_sol[j] = euler(ode_f, ya, a, b, N[j])[-1]
Mid_sol[j] = midpoint(ode_f, ya, a, b, N[j])[-1]
RK4_sol[j] = RK4(ode_f, ya, a, b, N[j])[-1]
h = 2. / N
plt.loglog(h,
abs((Euler_sol - f(2., 0.)) / f(2., 0.)),
'-b',
label="Euler method",
linewidth=2.)
plt.loglog(h,
abs((Mid_sol - f(2., 0.)) / f(2., 0.)),
'-g',
label="Midpoint method",
linewidth=2.)
plt.loglog(h,
abs((RK4_sol - f(2., 0.)) / f(2., 0.)),
'-k',
label="Runge Kutta 4",
linewidth=2.)
plt.xlabel("$h$", fontsize=16)
plt.ylabel("Relative Error", fontsize=16)
# plt.title("loglog plot of relative error in approximation of $y(2)$.")
plt.legend(loc='best')
# plt.savefig('relative_error.pdf')
plt.show()
plt.clf()
def Fig4():
a, b, ya = 0., 8., 1.
from math import exp, sin, cos
def f(x):
return exp(sin(x))
def ode_f(x,y):
return np.array([y*cos(x)])
# Number of subintervals
N1 = np.array([10,20,40,80,160,320,640,1280,2560,5120,
10240,20480,40960,81920,163840,327680,655360,1310720])
N2, N3 = N1[:12],N1[:10]
Euler_sol, Mid_sol, RK4_sol = np.zeros(len(N1)), np.zeros(len(N2)), np.zeros(len(N3))
for j in range(len(N1)):
Euler_sol[j] = euler(ode_f,ya,a,b,N1[j])[-1]
for j in range(len(N2)):
Mid_sol[j] = midpoint(ode_f,ya,a,b,N2[j])[-1]
for j in range(len(N3)):
RK4_sol[j] = RK4(ode_f,ya,a,b,N3[j])[-1]
# Data for a Table?
euler_error = np.concatenate((abs(( Euler_sol - f(b))/f(b) )[:,np.newaxis], N1[:,np.newaxis]),axis=1)
rk4_error = np.concatenate((abs(( RK4_sol - f(b))/f(b) )[:,np.newaxis], 4*N3[:,np.newaxis]),axis=1)
# Plot number of function evaluations versus relative error
fig = plt.figure()
plt.loglog(N1, abs(( Euler_sol - f(b))/f(b) ),'-b', label="Euler method" , linewidth=2.)
plt.loglog(2*N2, abs(( Mid_sol - f(b))/f(b) ), '-g', label="Midpoint method", linewidth=2. )
plt.loglog(4*N3, abs(( RK4_sol - f(b))/f(b) ), '-k', label="Runge Kutta 4" , linewidth=2. )
ax = fig.add_subplot(111)
plt.ylabel("Error", fontsize=16)
plt.xlabel("Functional Evaluations", fontsize = 16)
ax.legend(loc='best')
# ax.invert_xaxis()
# plt.savefig('Fig4.pdf')
plt.show()
plt.clf()
