Transkript

1 Aufgabe 4: a) Schreiben Sie in Python ein Programm, um die Approximationseigenschaften der Interpolationspolynome am Beispiel der Runge-Funktion mit den Funktionswerten im Intervall und zu überprüfen. Berechnen Sie dazu den absoluten Fehler der Interpolationspolynome vom Grad jeweils mit äquidistanten Stützstellen bzw. Tschebyschewabszissen an äqudistanten Stellen in. Plotten Sie die Funktionen und absoluten Fehler! Was beobachten Sie? b) Berechnen Sie numerisch die Lebesgue-Konstanten jeweils für äquidistante und Tschebyscheff-Abszissen. Beobachtung? Zunächst definieren wir Funktionen, die für ein Intervall zu gegebenem Listen von äquidistanten bzw. Tschebyscheff-Stützstellen bereitstellen. In [1]: def make_stuetz_aeq(n, a, b): return [a+i*(b-a)/n for i in range(n+1)] def make_stuetz_t(n, a, b): from math import cos, pi return [a*(1-cos((2*i+1)*pi/2/(n+1)))/2+b*(1+cos((2*i+1)*pi/2/(n+1)))/2 for i in range(n+1)] Aus diesen Listen generieren wir nun mit Unterprogrammen, die wir so ähnlich bereits in den Aufgaben 3.3 und 4.2 verwendet haben, Listen der Koeffizienten der Interpolationspolynome. In [2]: def runge_kutta(x): return 1.0/( *x*x) def Newton_Polynom(grad, stuetz, f): import numpy as np # Felder initialisieren a=np.zeros([grad+1,2]) koeffs=[] for i in range(grad+1): a[i,0]=stuetz[i] a[i,1]=f(a[i,0]) # Schema füllen for j in range(2,grad+2): for i in range(grad-j+2): a[grad-i,1]=(a[grad-i,1]-a[grad-i-1,1])/(a[grad-i,0]-a[grad-i-j+1,0] ) for j in range(grad+1): koeffs.append(a[j,1]) return koeffs Schließlich benötigen wir noch das Unterprogramm, dass zu einer gegebenen Abszisse den Funktionswert des entsprechenden Newtonpolynoms berechnet. Dieses haben wir bereits in den Aufgaben 3.3 und 4.2 verwendet. 1 von :20

2 2 von :20 In [3]: def Newton_Polynom_Wert(x, grad, stuetz, koeffs): import numpy as np # Felder initialisieren a=np.zeros([2,grad+1]) for i in range(grad+1): a[0,i]=x-stuetz[grad-i] a[1,i]=koeffs[grad-i] # Wert berechnen wert=a[1,0] for i in range(1,grad+1): wert = a[0,i]*wert+a[1,i] return wert Jetzt kann es losgehen. Vorher sichern wir noch ab, dass innerhalb des Notebooks geplottet werden kann. In [4]: import matplotlib.pyplot as plt %matplotlib notebook Lösung zu Aufgabe 4.4.a) Wir tabellieren in jedem der beiden Intervalle und für jedes die Runge-Kutta- Funktion und deren Interpolationpolynome mit äquidistanten und Tschebyscheff-Stützstellen sowie die Fehler und plotten dann alle 5 Funktionen in ein Bild.

3 3 von :20 In [5]: from math import fabs for m in [1,2]: a, b = 0.0, 0.5*m for n in [2,5,10,20,40,60]: #n=2*(k+1) stuetz_a = make_stuetz_aeq(n,a,b) stuetz_t = make_stuetz_t(n,a,b) koeffs_a = Newton_Polynom(n,stuetz_a,runge_kutta) koeffs_t = Newton_Polynom(n,stuetz_t,runge_kutta) my_absz = make_stuetz_aeq(10*n,a,b) my_ords = [runge_kutta(x) for x in my_absz] my_ords_a = [Newton_Polynom_Wert(x,n,stuetz_a,koeffs_a) for x in my_absz ] my_ords_t = [Newton_Polynom_Wert(x,n,stuetz_t,koeffs_t) for x in my_absz ] my_errs_a =[fabs(my_ords[i]-my_ords_a[i]) for i in range(len(my_absz))] my_errs_t =[fabs(my_ords[i]-my_ords_t[i]) for i in range(len(my_absz))] fig1 = plt.figure() subplot1 = fig1.add_subplot(211) subplot2 = fig1.add_subplot(212) subplot1.plot(my_absz, my_ords, label = "Runge-Kutta-Funktion") #subplot2.plot(my_absz, my_ords, label = "Runge-Kutta-Funktion") subplot1.plot(my_absz, my_ords_a, label = 'Newton äquidistant') subplot1.plot(my_absz, my_ords_t, label = 'Newton Tschebyscheff') subplot2.plot(my_absz, my_errs_a, label = 'Fehler äquidistant') subplot2.plot(my_absz, my_errs_t, label = 'Fehler Tschebyscheff') subplot1.legend(loc = 'upper right') subplot2.legend(loc = 'upper right') subplot1.set_title("interpolationsfunktionen für n = {:2d}".format(n)) subplot2.set_title("interpolationsfehler für n = {:2d}".format(n)) fig1.show()

4 4 von :20

5 5 von :20

6 6 von :20

7 7 von :20

8 8 von :20

9 9 von :20 Wir beobachten, dass bei den äquidistanten Stützstellen die Fehler in den einmzelnen Teilintervallen unterschiedlich groß sind, insbesondere am Rand. Bei Tschebyscheff-Abszissen sind die Fehler über dem gesamten Intervall nahezu gleich groß, insgesamt aber deutlich kleiner als die maximalen Fehler bei äquididtanten Stützstellen.

10 10 von :20 Lösung zu 4.4 b): Es ist wobei die gerade die Lagrange-Basis zu den gegebenen Stützstellen darstellt. Wir schreiben also zunächst ein Unterprogramm, dass die Funktionswerte der berechnen kann und eines, dass an einer Stelle berechnet. In [6]: def lagrange(x,n,k,stuetz): l=1.0 ilist=list(range(n+1)) ilist.remove(k) xk=stuetz[k] for i in ilist: l=l*(x-stuetz[i])/(xk-stuetz[i]) return l def lambda_n(x,n,stuetz): from math import fabs s=0.0 for m in range(n+1): s += fabs(lagrange(x,n,m,stuetz)) return s Schließlich schreiben wir zwei Programme, die für ein gegebenes Intervall und eine gegebene Anzahl von Stützstellen das oben genannte Maximum für äquidistante bzw. Tschebyscheff-Stützstellen berechnet. Dabei wählen wir wieder die zehnfache Anzahl von Testpunkten. In [7]: def maxlambda_a(a,b,n): stuetz_a = make_stuetz_aeq(n,a,b) tests = make_stuetz_aeq(10*n,a,b) mymax=0 for x in tests: wert=lambda_n(x,n,stuetz_a) if wert>mymax: mymax=wert return mymax def maxlambda_t(a,b,n): stuetz_t = make_stuetz_t(n,a,b) tests = make_stuetz_aeq(10*n,a,b) mymax=0 for x in tests: wert=lambda_n(x,n,stuetz_t) if wert>mymax: mymax=wert return mymax Jetzt haben wir alle notwendigen Werkzeuge beisammen, um die Lebesque-Konstanten für die angebenen Stützstellenmangen zu tabellieren. Wir benutzen das Intervall.

11 11 von :20 In [8]: print("n L_n_a L_n_t") ns, las, lts = [], [],[] for n in range(1,11): ns.append(5*n) las.append(maxlambda_a(0,1,5*n)) lts.append(maxlambda_t(0,1,5*n)) print("{:2d}".format(ns[n-1]), "{:25.5f}".format(las[n-1]), "{:15.5f}".forma t(lts[n-1])) fig2 = plt.figure() subplot1 = fig2.add_subplot(211) subplot2 = fig2.add_subplot(212) subplot1.plot(ns, las, label = "Lebesque Konstanten bei äquidistanten Stürtzstel len") subplot2.plot(ns, lts, label = "Lebesque Konstanten bei Tschebyscheff-Stürtzstel len") subplot1.legend(loc = 'upper right') subplot2.legend(loc = 'upper right') fig2.show() n L_n_a L_n_t Wir beobachten exponetielles-wachstum der Lesbesque-Konstanten bei äquididstanten Stützstellen gegenüber logarithmischem Wachstum bei Tschebyscheff-Stützstellen.