D-MATH Numerische Methoden FS 2017 Dr. Vasile Gradinaru Luc Grosheintz. Serie 5

Transkript

1 D-MATH Numerische Methoden FS 2017 Dr. Vasile Gradinaru Luc Grosheintz Serie 5 Best Before: Di./ Mi. 28.3/29.3, in den Übungsgruppen oder im J 68 Koordinatoren: Luc Grosheintz, luc.grosheintz@sam.math.ethz.ch Webpage: 1. Gauss-Legendre Quadratur und Golub-Welsch Algorithmus a) Leiten Sie die Drei-Term-Rekursion her, welche die Legendre Polynome P n (x) beschreibt. Das Skalarprodukt ist in diesem Fall gegeben als: p, q := und es gilt P 0 (x) = 1 und P 1 (x) = x. 1 1 p(x)q(x)dx Solution: Aus der Vorlesung wissen wir, dass die Legendre Polynome einerseits durch Orthogonalisierung mittels Gram-Schmidt gefunden werden können und andererseits einer 3-Term Rekursion: P n+1 (x) = (x β n+1 ) P n (x) γ 2 n+1p n 1 (x) genügen. Es ist zu zeigen, dass die 3-Term Rekursion aus dem Gram-Schmidt Verfahren folgt. Wir definieren rekursif Q n+1 (x) = xp n (x) und P n+1 (x) = Q n+1 (x) n k=0 Q n+1, P k P k, P k P k. Dies ist genau das Gram-Schmidt Verfahren (angewandt auf Q n+1 ), daher sind {P k } n+1 k=0 orthogonal zueinander. Wir definieren Für k < n gilt a n+1,k = Q n+1, P k P k, P k. Q n+1, P k = xp n, P k = P n, xp k = P n, Q k+1 = P n, P k+1 + l k a k+1,l P l = P n, P k+1 + l k a k+1,l P n, P l. Bitte wenden!

2 Wir nutzen nun Orthogonalität aus: Q n+1, P k = { 0 k + 1 < n P n, P n k = n 1, und erhalten eine Drei-Term Rekursion: ( P n+1 (x) = x xp ) n, P n P n (x) P n, P n P n, P n P n 1, P n 1 P n 1(x). Wir vergleichen dies mit der Bonnet Rekursion P n+1 (x) = 2n + 1 n + 1 xp n(x) n n + 1 P n 1(x). und bemerken, dass die nur mit unserer 3-Term Rekursion überein stimmen kann, falls xp n, P n = 0. Noch ist unklar weshalb dies gelten sollte. Deswegen schreiben wir die ersten drei Polynome auf: ( ) x1, 1 P 1 (x) = x 1 = x 1, 1 ( ) xx, x x, x P 2 (x) = x x x, x 1, 1 1 = x2 1 3 P 3 (x) = ( x xp 2, P 2 P 2, P 2 ) P 2 P 2, P 2 P 1, P 1 P 1 = x x Die Vermutung ist, dass P 2n nur gerade und P 2n+1 nur ungerade Exponenten hat. Wir beweisen dies per Induktion und nehmen an, dass die Aussage bereits für 2n 1 beweisen wurde. xp 2n 1, P 2n 1 = 1 2n 1 1 k=0 α k x 2k+1 = 0. Also hat P 2n nur gerade Exponenten. Genau gleich beweist man den ungeraden Fall. Also gilt xp n, P n = 0 für alle n. Hier sind α k die Koeffizienten des Polynoms (P 2n 1 ) 2. Die 3-Term Rekursion ist also P n+1 (x) = xp n (x) P n, P n P n 1, P n 1 P n 1(x). Diese Rekursion liefert monische Polynome, der Koeffizient des Monoms x k von P k ist 1. Die Integrale enthalten alle nur Polynome und sind somit problemlos exakt lösbar. Schlussendlich stellt man fest, dass gilt β k+1 = 0 { γk k = 0 = 1 4 k k 1 2 Siehe nächstes Blatt!

3 Normiert man nun diese Polynome so, dass P m, P n = 1 1 P m (x)p n (x)dx = dann erhält man die übliche Rekursion { 2 2 2n + 1 δ m,n = 2n+1 m = n 0 m n P n+1 (x) = 2n + 1 n + 1 xp n(x) n n + 1 P n 1(x). b) Begründen Sie die Wahl der Einträge in der Jacobi-Matrix J im Algorithmus von Golub- Welsch. (Siehe Code im Skript.) Solution: Für eine Drei-Term-Rekursion P k (x) = (a k x + b k )P k 1 (x) c k P k 2 (x) mit P 0 = 1 und P 1 = x stellen wir im Golub-Welsch Algorithmus folgende Matrix M auf: b1 1 a 1 a c 2. a M = 2 b2.. a a n Diese Matrix ist nicht symmetrisch. Durch eine Ähnlichkeitstransformation kann man eine symmetrische Tridiagonalmatrix J bekommen α 1 β J = β 1 α βn β n 1 α n wobei c n a n bn a n α k := b k ck+1 β k :=. a k a k a k+1 Die Eigenwerte dieser Matrix lassen sich effizient und numerisch stabil berechnen. Im Fall der Legendre Polynome P n (x) gilt und daher und somit P k (x) = 2k 1 k a k = 2k 1 k α k = 0 β k = xp k 1 (x) k 1 k P k 2(x) b k = 0 c k = k 1 k 2k 1 k was genau den Faktoren im Code entspricht. c) Verwenden Sie folgende Quadraturregeln k+1 1 k+1 2(k+1) 1 k+1 = k 4k2 1 Bitte wenden!

4 (bereits erledigt in Serie 4) zusammengesetzte Trapezregel (bereits erledigt in Serie 4) zusammengesetzte Simpsonregel Gauss-Legendre Quadratur zusammengesetzte Gauss-Legendre Quadratur um das Integral I = 1 0 f i (x)dx von f i (x) auf N Teilintervallen oder mit n Funktionsauswertungen zu berechnen. (Die genauen Werte von N und n stehen im Template.) Die beiden Funktionen sind gebeben durch 1 f 1 (x) := 1 + 5x 2 f 2 (x) := x. Berechnen Sie den Fehler und plotten Sie die Konvergenzraten. Welche Methode verwendet man sinnvollerweise? Hinweis: Verwenden Sie das Template quadrature.py. Solution: Die Gauss-Legendre Quadratur hat die beste Konvergenz. Allerdings kann 1 die Berechnung der Knoten und Gewichte aufwendig sein für hohe Ordnung. Die zusammengesetzte Version kann als Kompromiss verstanden werden. Quadraturfehler für f1(x) = x Absoluter Fehler Trapez Simpson Gauss-Legendre Zusammengesetzte Gauss Legende n 1.5 n 2 n Anzahl Auswertungen von f Abbildung 1 Konvergenzen der Methoden für die Funktion f 1 gemessen gegen die Anzahl Auswertungen. Solution: # -*- coding: utf-8 -*- import numpy as np 1 Für hohe Ordnung ist der Golub-Welsch Ansatz nicht effizient, es gibt aber geeignete Algorithmen zur Berechnung der Knoten und Gewichte auch für sehr grosse n. Siehe nächstes Blatt!

5 Quadraturfehler für f2(x) = x Absoluter Fehler Trapez Simpson Gauss-Legendre Zusammengesetzte Gauss Legende n 1.5 n 2 n Anzahl Auswertungen von f Abbildung 2 Konvergenzen der Methoden für die Funktion f 2 gemessen gegen die Anzahl Auswertungen. import matplotlib.pyplot as plt def trapezoid(f, a, b, N): Approximiert das Integral von `f` mit der Trapezregel. Input: f : Funktion f(x) welche integiert werden soll. a, b : untere/obere Grenze des Integrals. N : Anzahl Teilintervalle in der zusammengesetzten Trapezregel. x, h = np.linspace(a, b, N+1, retstep=true) # Für geschlossene Quadraturformeln kann man mit einem # Trick die Anzahlfunktionsaufrufe reduzieren. # Die Beobachtung ist, dass zwei benachbarte Teilintervalle einen # gemeinsamen Knoten haben. Anstatt, `f` zweimal für diesen Knoten # auszurechnen, summiert man einfach die Gewichte: I = h * (np.sum(f(x[1:-1])) * (f(x[0]) + f(x[-1]))) return I def simpson(f, a, b, N): Approximiert das Integral von `f` mit der Simpsonregel. Input: f : Funktion f(x) welche integiert werden soll. a, b : untere/obere Grenze des Integrals. N : Anzahl Teilintervalle in der zusammengesetzten Simpsonregel. Bitte wenden!

6 x, h = np.linspace(a, b, N+1, retstep=true) xm = 0.5*(x[1:] + x[:-1]) I = h/6.0 * (4.0*np.sum(f(xm)) + 2.0*np.sum(f(x[1:-1])) + f(x[0]) + f(x[-1])) return I def golub_welsch(n): Berechnet die Knoten und Gewichte für Gauss-Legendre Quadratur. i = np.arange(n-1) b = (i+1.0) / np.sqrt(4.0*(i+1)**2-1.0) J = np.diag(b, -1) + np.diag(b, 1) x, ev = np.linalg.eigh(j) w = 2 * ev[0,:]**2 return x, w def gauss_legendre(f, a, b, n): Gauss-Legendre Quadratur (nicht zusammengesetzt). f: Funktion f(x) a, b: Obere und untere Grenze des Intervalls. n: Anzahl Quadraturpunkte. x_ref, w_ref = golub_welsch(n) x = a + (x_ref + 1.0)*(b - a)*0.5 w = 0.5*(b - a)*w_ref return np.sum(w*f(x)) def composite_legendre(f, a, b, N, n): Zusammengesetzte Gauss-Legendre Quadratur. f: Funktion f(x) a, b: Obere und untere Grenze des Intervalls. N: Anzahl Teilintervalle. n: Anzahl Quadraturpunkte pro Teilintervall. I = 0.0 dx = (b - a)/n for i in range(n): I += gauss_legendre(f, a + i*dx, a + (i+1)*dx, n) return I def quadrature_error(quadrature_rule, f, exact): Berechnet den Fehler und die Konvergenzrate. Siehe nächstes Blatt!

7 Input: quadrature_rule : Quadraturformel für welche verwendet werden soll. Die Funktion hat die gleiche Signature wie `simpson` und `trapezoid`. f : Funktion welche integriert werden soll. In der Aufgabe heissen sie `f1` und `f2`. exact : Exakte Referenzlösung des Integrals. Output: errors : Fehler der Quadraturformel mit `n_chunks` Teilintervallen. n_chunks : Anzahl Teilintervalle. n_chunks = np.arange(1, 100) errors = np.empty(n_chunks.shape) # Vorsicht, n_chunks.dtype ist ein Array # voller `int`. Deswegen kein `empty_like`. for i, N in enumerate(n_chunks): approx = quadrature_rule(f, 0.0, 1.0, N) errors[i] = np.abs(approx - exact) return errors, n_chunks def legendre_error(f, exact): return quadrature_error(gauss_legendre, f, exact) def composite_legendre_error(f, exact): n = 4 rule = lambda f, a, b, N: composite_legendre(f, a, b, N, n) errors, n_chunks = quadrature_error(rule, f, exact) return errors, n*n_chunks def plot_convergence(n_evals, errors, labels, title): Plottet einen Konvergenzplot in einem neuen Fenster. Der Vergleich zwischen Simpson- und Trapezregel soll 'fair' sein. Die Simpsonregel wertet `f` fast 2x öfter aus. Plotten Sie deswegen den Fehler gegen die Anzahl Funktionsaufrufe. Trendlinien der Ordnung 1.5, 2 und 4 werden ebenfalls geplottet. Input: n_evals : list of array Anzahl Funktionsaufrufe pro Regel pro Auflösung. errors : list of array Fehler pro Quadraturregel pro Auflösung. Bitte wenden!

8 labels : list. Text der in der Legende erscheint. title : Titel des Plots. plt.figure(figsize=(12,8)) for k, n_eval in enumerate(n_evals): plt.loglog(n_eval, errors[k], "-o", label=labels[k]) # Trendlinien plt.loglog(n_evals[0], (1.0*n_evals[0])**-1.5, ":k", label=r"$n^{-1.5}$") plt.loglog(n_evals[0], (1.0*n_evals[0])**-2, "-k", label=r"$n^{-2}$") plt.loglog(n_evals[0], (1.0*n_evals[0])**-4, "-.k", label=r"$n^{-4}$") plt.grid(true) plt.xlabel("anzahl Auswertungen von $f$") plt.ylabel("absoluter Fehler") plt.legend(loc="lower left") plt.title(title) def f1(x): return 1.0 / ( *x**2) def f2(x): return np.sqrt(x) def convergence_experiment(f, exact, title, filename): errors_tr, n_chunks = quadrature_error(trapezoid, f, exact) n_tr = n_chunks + 1 errors_si, n_chunks = quadrature_error(simpson, f, exact) n_si = 2*n_chunks + 1 errors_gl, n_gl = legendre_error(f, exact) errors_cg, n_cg = composite_legendre_error(f, exact) n_evals = [n_tr, n_si, n_gl, n_cg] errors = [errors_tr, errors_si, errors_gl, errors_cg] labels = ["Trapez", "Simpson", "Gauss-Legendre", "Zusammengesetzte Gauss Legende"] plot_convergence(n_evals, errors, labels, title) plt.savefig(filename + ".png") plt.savefig(filename + ".pdf") def ex1_c(): # Konvergenzplot für `f1`. I1ex = np.arctan(np.sqrt(5.0)) / np.sqrt(5.0) title = r"quadraturfehler für $f_1(x) = \frac{1}{1 + 5x^2}$" convergence_experiment(f1, I1ex, title, "img/convergence_f1") Siehe nächstes Blatt!

9 # Konvergenzplot für `f2`. I2ex = 2.0 / 3.0 title = r"quadraturfehler für $f_2(x) = \sqrt{x}$" convergence_experiment(f2, I2ex, title, "img/convergence_f2") if name == " main ": ex1_c() plt.show() Bitte wenden!

10 2. Kernaufgabe: Die Airy-Gleichung Es soll die so genannte Airy Gleichung ü(t) t u(t) = 0 numerisch gelöst werden wobei folgende Anfangswerte zum Zeitpunkt T start = 0 gegeben sind u(0) = Γ( 2 3 ) u(0) = Γ( 1 3 ) und rückwärts in der Zeit integriert wird bis zu T end = 40. Dieses Anfangswertproblem definiert die Airy-Funktion Ai(t) welche in der Physik eine grosse Bedeutung hat. 1. Schreiben Sie die Gleichung um in ein System erster Ordnung für y(t) und leiten Sie daraus die rechte Seite her. Implementieren Sie die rechte Seite in der Funktion rhs welche t und y(t) als Argumente hat. Hinweis: Verwenden Sie das Template airy.py Solution: Geschrieben als ein System lautet die Airy Gleichung ẏ 0 (t) = y 1 (t) ẏ 1 (t) = t y 0 (t) mit der rechten Seite f(t, y(t)) = [ ] y1 (t). t y 0 (t) 2. Implementieren Sie das explizite und das implizite Eulerverfahren, die explizite und die implizite Mittelpunktsregel. Die Argumente dieser Funktionen sind: der Anfangswert y(0), Anfangszeit T start, Endzeit T end und die Anzahl Schritte N. Lösen Sie das Anfangswertproblem und plotten Sie die Lösung. Hinweis: Benutzen Sie die Funktion fsolve aus scipy.optimize. Solution: 3. Implementieren Sie die 4 entsprechenden Runge-Kutta Methoden mit allgemeinem Butcher Schema in der Funktion RK. Bekommen Sie dieselbe Ergebnisse wie beim Punkt 2? Solution: Mit dem Butcher Schema lässt sich das s stufige explizite Verfahren einfach implementieren. Für A, b, c ergibt sich mit (t τ, u τ ) und i = 1,..., s k i := f t τ + c i h, u τ + h s A i,j k j (1) j=1 und dann s u τ+dτ = u τ + h b i k i (2) i=1 Siehe nächstes Blatt!

11 Abbildung 3 Airy Gleichung mit explizitem Euler Verfahren gelöst. 4. Lösen Sie das gegebene Anfangswertproblem mit einer Runge-Kutta 3/8 Zeitintegration. Implementieren Sie dafür die Funktion RK 38 und plotten Sie die Lösung. Hinweis: Das Butcher Schema der Runge-Kutta 3/8 Regel lautet 0 1/3 1/3 2/3 1/ /8 3/8 3/8 1/8 Das 3/8 Butcher Schema in dem Programm ist repräsentiert wie eine Matrix /3 1/ B = 2/3 1/ /8 3/8 3/8 1/8 Solution: Solution: #!/usr/bin/env python from numpy import * Bitte wenden!

12 Abbildung 4 Airy Gleichung mit implizitem Euler Verfahren gelöst. from scipy.special import airy from scipy.optimize import fsolve from matplotlib.pyplot import * # Anfangswerte iv = array([ , ]) # Exakte Loesung exact = lambda t: row_stack(airy(t)[:2]) # Intervall T = ################### # Teilaufgabe 1 # ################### # Airy rechte Seite rhs = lambda t, y: array([ y[1], t*y[0]]) #################### # Teilaufgabe 2 # Siehe nächstes Blatt!

13 Abbildung 5 Airy Gleichung mit explizitem Mittelpunkt Verfahren gelöst. #################### def integrate_ee(y0, tstart, tend, N): rintegrate ODE with explicit Euler method Input: y0... initial condition tstart... start t tend... end t N... number of steps Output: t... variable y... solution y = zeros((2,n+1)) t = zeros((n+1,)) t[0] = tstart y[:,0] = y0 h = (tend - tstart) / float(n) for n in range(n): t[n+1] = t[n] + h y[:,n+1] = y[:,n] + h*rhs(t[n], y[:,n]) return t, y def integrate_ie(y0, tstart, tend, N): Bitte wenden!

14 Abbildung 6 Airy Gleichung mit implizitem Mittelpunkt Verfahren gelöst. rintegrate ODE with implicit Euler method Input: y0... initial condition tstart... start t tend... end t N... number of steps Output: t... variable y... solution y = zeros((2,n+1)) t = zeros((n+1,)) t[0] = tstart y[:,0] = y0 h = (tend - tstart) / float(n) for n in range(n): t[n+1] = t[n] + h F = lambda yt: yt - y[:,n] - h*rhs(t[n+1], yt) guess = y[:,n] + h*rhs(t[n], y[:,n]) y[:,n+1] = fsolve(f, guess) return t, y def integrate_em(y0, tstart, tend, N): rintegrate ODE with explicit midpoint method Siehe nächstes Blatt!

15 Abbildung 7 Airy Gleichung mit der Runge-Kutta 3/8 Regel gelöst. Input: y0... initial condition tstart... start t tend... end t N... number of steps Output: t... variable y... solution y = zeros((2,n+1)) t = zeros((n+1,)) t[0] = tstart y[:,0] = y0 h = (tend - tstart) / float(n) for n in range(n): t[n+1] = t[n] + h y[:,n+1] = y[:,n] + h*rhs( t[n] +.5*h, y[:,n] +.5*h*rhs(t[n], y[:,n])) return t, y def integrate_im(y0, tstart, tend, N): rintegrate ODE with implicit midpoint method Input: y0... initial condition Bitte wenden!

16 tstart... start t tend... end t N... number of steps Output: t... variable y... solution y = zeros((2,n+1)) t = zeros((n+1,)) t[0] = tstart y[:,0] = y0 h = (tend - tstart) / float(n) for n in range(n): t[n+1] = t[n] + h F = lambda yt: yt - y[:,n] - h*rhs(t[n] +.5*h,.5*(yt + y[:,n])) guess = y[:,n] + h*rhs(t[n], y[:,n]) y[:,n+1] = fsolve(f, guess) return t, y N = 10**3 t, y = integrate_ee(iv, 0.0, T, N) figure() plot(t, exact(t)[0], "r") plot(t, y[0,:], "b") #plot(t, y[1,:], "g") grid(true) xlabel("t") ylabel("ai(t)") savefig("img/ai_expl_euler.png") t, y = integrate_ie(iv, 0.0, T, N) figure() plot(t, exact(t)[0], "r") plot(t, y[0,:], "b") #plot(t, y[1,:], "g") grid(true) xlabel("t") ylabel("ai(t)") savefig("img/ai_impl_euler.png") t, y = integrate_em(iv, 0.0, T, N) figure() plot(t, exact(t)[0], "r") plot(t, y[0,:], "b") #plot(t, y[1,:], "g") grid(true) xlabel("t") ylabel("ai(t)") Siehe nächstes Blatt!

17 savefig("img/ai_expl_midpoint.png") t, y = integrate_im(iv, 0.0, T, N) figure() plot(t, exact(t)[0], "r") plot(t, y[0,:], "b") #plot(t, y[1,:], "g") grid(true) xlabel("t") ylabel("ai(t)") savefig("img/ai_impl_midpoint.png") #################### # Teilaufgabe 3 # #################### def RK_step(B, t, y, h): r Makes a single Runge-Kutta step of size h. B: Butcher Schema t: Current time t_i y: Current solution y_i h: Timestep size tnew = t ynew = y s = B.shape[0] - 1 b = B[s][1:] c = B[:,0][:-1] A = B[:-1,1:] k = zeros((2, s)) if allclose(triu(a), zeros_like(a)): # explicit method for i in range(s): k[:,i] = rhs(t + c[i]*h, y + h*dot(a[i,:].t, k.t)) else: # implicit method def F(x): # we will have to flatten and reshape many times our # arrays, complicating the code for a rather simple # algorithm; this is caused by fsolve, which accepts only # scalars or 1-dim arrays z = x.reshape((2, s)) temp = zeros((2, s)) for i in range(s): temp[:,i] = rhs(t + c[i]*h, y + h * dot(a[i,:].t, z.t)) return temp.ravel() k = fsolve(lambda x : x-f(x), zeros(2*s)).reshape((2, s)) tnew = t + h Bitte wenden!

18 ynew = y + h*squeeze(dot(k, b)) return tnew, ynew def RK(B, y0, tstart, tend, N): r Integrate the equation with a Runge-Kutta rule. Input: B... Butcher Schema y0... initial condition tstart... start t tend... end t N... number of steps Output: t... variable y... solution y = zeros((2,n+1)) t = zeros((n+1,)) t[0] = tstart y[:,0] = y0 h = (tend - tstart) / float(n) for n in range(n): t[n+1], y[:,n+1] = RK_step(B, t[n], y[:,n], h) return t, y B = array([[0, 0], [0, 1]]) t, y = RK(B, iv, 0.0, T, N) figure() plot(t, exact(t)[0], "r") plot(t, y[0,:], "b") #plot(t, y[1,:], "g") grid(true) xlabel("t") ylabel("ai(t)") savefig("img/ai_rk_expl_euler.png") B = array([[1, 1], [0, 1]]) t, y = RK(B, iv, 0.0, T, N) figure() plot(t, exact(t)[0], "r") plot(t, y[0,:], "b") #plot(t, y[1,:], "g") grid(true) xlabel("t") Siehe nächstes Blatt!

19 ylabel("ai(t)") savefig("img/ai_rk_impl_euler.png") B = array([[ 0, 0, 0], [.5,.5, 0], [ 0, 0, 1]]) t, y = RK(B, iv, 0.0, T, N) figure() plot(t, exact(t)[0], "r") plot(t, y[0,:], "b") #plot(t, y[1,:], "g") grid(true) xlabel("t") ylabel("ai(t)") savefig("img/ai_rk_expl_midpoint.png") B = array([[.5,.5], [ 0, 1]]) t, y = RK(B, iv, 0.0, T, N) figure() plot(t, exact(t)[0], "r") plot(t, y[0,:], "b") #plot(t, y[1,:], "g") grid(true) xlabel("t") ylabel("ai(t)") savefig("img/ai_rk_impl_midpoint.png") #################### # Teilaufgabe 4 # #################### def RK_38(y0, tstart, tend, N): r Integrate the equation with the 3/8 Runge-Kutta rule. Input: y0... initial condition tstart... start t tend... end t N... number of steps Output: t... variable y... solution B = array( [array([0, 0, 0, 0, 0]), array([1, 1, 0, 0, 0])/3., Bitte wenden!

20 array([2,-1, 3, 0, 0])/3., array([1, 1,-1, 1, 0]), array([0, 1, 3, 3, 1])/8.]) return RK(B, y0, tstart, tend, N) t, y = RK_38(iv, 0.0, T, N) figure() plot(t, exact(t)[0], "r") plot(t, y[0,:], "b") #plot(t, y[1,:], "g") grid(true) xlabel("t") ylabel("ai(t)") savefig("img/ai_rk_38.png")