10.4    Potenzreihen und die Taylor-Entwicklung

Bisher wurden nur die mathematischen Konstanten π und e mithilfe von Reihen approximiert. Nun stellt sich die Frage, ob es auch möglich ist, Funktionen durch Reihen zu approximieren. Diese Frage kann positiv beantwortet werden, wenn man Potenzreihen verwendet. Potenzreihen haben die allgemeine Form:

Mit dem Satz von Taylor können die Koeffizienten a_n berechnet werden.

Potenzreihen sind nützlich, denn mit ihnen können

• Funktionswerte mit der geforderten Genauigkeit numerisch berechnet werden.

• die ersten Glieder einer Potenzreihe als Näherung verwendet werden.

• Funktionen gliedweise integriert werden, wenn sie nicht geschlossen integrierbar sind.

10.4.1    Potenzreihen

Betrachten wir zunächst eine Potenzreihe, deren Koeffizienten bereits bekannt sind. Die geometrische Reihe

ist ein Spezialfall einer Potenzreihe. Die Koeffizienten a_n haben alle den Wert 1. Die Summenformel gilt nur für den Definitionsbereich –1 < x < 1. Auf der linken Seite der Gleichung stehen unendlich viele Glieder, auf der rechten Seite steht dagegen nur ein Term: die Summenformel der unendlichen geometrischen Reihe. Alle Glieder auf der linken Seite sind Potenzen von x. Deshalb bezeichnet man eine solche Reihe auch als Potenzreihe.

Abbildung 10.6 zeigt dazu den Verlauf der Funktionsgraphen für die Summenformel 1/(1 – x) und den linksseitigen Term der Gleichung.

Abbildung 10.6     Funktionsplot einer Potenzreihe im Entwicklungspunkt x₀ = 0

Für jeden Wert auf der x-Achse kann die Summe der Potenzreihe auf der y-Achse abgelesen werden. Durch das Hinzufügen weiterer Glieder kann man die Approximation optimieren. Mit Listing 10.13 können Sie den Funktionsplot für die unendliche Potenzreihe und die Approximation erstellen:

01  #13_plot_potenzreihe.py
02  import numpy as np
03  import matplotlib.pyplot as plt
04  x=np.linspace(-1,0.999,100)
05  y=1/(1-x)
06  ya=1+x+x**2+x**3+x**4+x**5
07  fig, ax =plt.subplots()
08  ax.set_ylim(0,5)
09  ax.plot(x,y,'b',lw=2,label='genau')
10  ax.plot(x,ya,'r--',lw=2,label='approximiert')
11  ax.set(xlabel='x',ylabel='y')
12  ax.legend(loc='best')
13  plt.show()

Listing 10.13     Funktionsplot einer Potenzreihe

Analyse

Da x nicht den Wert 1 annehmen darf, wird in Zeile 04 als obere Grenze der Wert 0.999 festgelegt. In Zeile 05 steht die Formel für die unendliche Summe der Potenzreihe. In Zeile 06 steht die Näherungsformel für eine unendliche Summe. Durch Hinzufügen oder Auskommentieren von Reihengliedern kann die Genauigkeit der Approximation demonstriert werden.

Berechnung eines Funktionswertes mit einer Potenzreihe

Listing 10.14 berechnet näherungsweise den Funktionswert der Exponentialfunktion für das Argument x = 2

mit m = 20 Schleifendurchläufen.

01  #14_potenzreihe.py
02  from math import *
03  x=2   #Entwicklungspunkt
04  m=#Anzahl der Summanden
05 
06  def a(n):
07      return 1/factorial(n) #e-Funktion
08 
09  summe=0
10  for n in range(m):
11      summe=summe + a(n)*x**n
12  print(summe)
13  print(exp(x),"genau")

Listing 10.14     Potenzreihenentwicklung für die eulersche Zahl e an der Stelle x = 2

Ausgabe

7.3890560989301735
7.38905609893065 genau

Analyse

Die Folge für die eulersche Zahl e wird in den Zeilen 06 und 07 definiert. In Zeile 11 wird mit dem Summenalgorithmus der Wert für exp(2) mit der Potenzreihe berechnet. Das Ergebnis erreicht eine Genauigkeit von 12 Nachkommastellen.

Konvergenzradius

Der Konvergenzradius einer Potenzreihe macht eine Aussage darüber, für welche x‐Werte eine Potenzreihe konvergiert. Potenzreihen werden um einen Punkt x₀ entwickelt. Die Approximation einer Funktion ist nur in der Nähe dieser Entwicklungsstelle genau. Je weiter man sich von dieser Stelle entfernt, desto ungenauer wird die Approximation. Diese Ungenauigkeit kann auch nicht durch eine Vergrößerung von n kompensiert werden. Die Approximation einer Funktion ist also nur in einer bestimmten Umgebung von x₀ genau, die durch den Konvergenzradius bestimmt wird.

Um eine Formel für den Konvergenzradius zu erhalten, betrachten wir das vorletzte Glied a_n und das letzte Glied a_n+1 einer allgemeinen Potenzreihe:

Damit eine Potenzreihe konvergiert, muss das letzte Glied betragsmäßig immer kleiner sein als das vorletzte. Wenn man a_n durch a_n+1 dividiert und den Grenzwert aus dem Betrag dieses Quotienten bildet, dann erhält man die Definition für den Konvergenzradius:

Nur wenn alle x-Werte der Reihenglieder innerhalb von –R und +R liegen, konvergiert die Reihe. Je größer dieser Bereich ist, desto besser ist das Konvergenzverhalten. Ein Konvergenzradius von ∞ wäre demnach das Optimum.

Konvergenzradius

Der Konvergenzradius gibt den Konvergenzbereich an, in dem die Potenzreihe konvergiert. Die Werte der unabhängigen Variablen x dürfen nur in diesem Bereich liegen, damit die Reihe konvergiert.

Dieses Konvergenzkriterium ist nicht sicher. Es gibt auch Ausnahmen, für die es nicht gilt.

An den Rändern des Konvergenzradius ist keine sichere Aussage möglich.

Die Bezeichnung Radius beruht auf der Tatsache, dass auch für die Reihenentwicklung komplexe Zahlen zugelassen werden. Für diesen Fall liegt der Konvergenzradius in der gaußschen Zahlenebene.

Abbildung 10.7 veranschaulicht den Begriff des Konvergenzradius.

Abbildung 10.7     Veranschaulichung des Konvergenzradius

Listing 10.15 berechnet den Konvergenzradius für verschiedene Potenzreihenentwicklungen mit SymPy:

01  #15_konvergenzradius.py
02  from sympy import *
03  n=symbols('n')
04 
05  def a(n):
06      return 1/factorial(n)            #e-Funktion
07      #return (-1)**n/factorial(2*n+1) #Sinus
08      #return (-1)**n/factorial(2*n)   #Kosinus
09      #return 1/factorial(2*n+1) #Sinus hyperbolicus
10      #return 1/factorial(2*n)   #Cosinus hyperbolicus
11      #return (-1)**n/(2*n+1)    #Arkustangens |x|<1
12 
13  R=limit(abs(a(n)/a(n+1)),n,oo)
14  print("Konvergenzradius:",R)

Listing 10.15     Konvergenzradien für verschiedene Potenzreihen

Ausgabe

Konvergenzradius: oo

Analyse

Ab Zeile 05 werden verschiedene Folgen definiert. In Zeile 13 wird der Konvergenzradius mit limit(abs(a(n)/a(n+1)),n,oo) berechnet. Für die Reihe der e-Funktion wird ein Konvergenzradius von ∞ ausgegeben. Das bedeutet, dass für alle x-Werte die Reihe in dem Bereich von –∞ bis +∞ konvergiert. Diese Reihe zeigt also ein sicheres Konvergenzverhalten.

Für weitere Testzwecke können Sie die Kommentare entfernen und die Konvergenzradien für die anderen Reihen berechnen lassen.

10.4.2    Taylor-Entwicklung

Für eine beliebig oft differenzierbare Funktion ƒ(x) können die Koeffizienten a_n der Folgenglieder einer Potenzreihe

mit dem Satz von Taylor bestimmt werden.

In [Weltner: 165ff.] finden Sie die Herleitung der Koeffizienten a_n für den Entwicklungspunkt x₀ = 0:

Damit erhält man die Taylor-Reihe für den Entwicklungspunkt x₀ = 0:

Wird eine Funktion an der Stelle x = 0 entwickelt, dann wird die obige Reihenentwicklung in der Fachliteratur auch als die maclaurinsche Form der Taylor-Reihe bezeichnet.

Soll eine Funktion an der Stelle x = x₀ entwickelt werden, gilt die Berechnungsvorschrift:

Listing 10.16 berechnet mit der SymPy-Methode series() für verschiedene trigonometrische und hyperbolische Funktionen die Taylor-Entwicklung für die Entwicklungsstelle x₀ = 0:

01  #16_sympy_taylor.py
02  from sympy import *
03  x=symbols('x')
04  f1=cos(x)
05  f2=sin(x)
06  f3=exp(x)
07  f4=sinh(x)
08  f5=cosh(x)
09  f6=atan(x)
10  print("cos(x) =",series(f1,x,n=10))
11  print("sin(x) =",series(f2,x,n=10))
12  print("exp(x) =",series(f3,x,n=6))
13  print("sinh(x)=",series(f4,x,n=6))
14  print("cosh(x)=",series(f5,x,n=10))
15  print("atan(x)=",series(f6,x,n=11))

Listing 10.16     Taylor-Entwicklung für verschiedene Funktionen

Ausgabe

cos(x) = 1 - x**2/2 + x**4/24 - x**6/720 + x**8/40320 + O(x**10)
sin(x) = x-x**3/6 + x**5/120 - x**7/5040 + x**9/362880 + O(x**10)
exp(x) = 1 + x + x**2/2 + x**3/6 + x**4/24 + x**5/120 + O(x**6)
sinh(x)= x + x**3/6 + x**5/120 + O(x**6)
cosh(x)= 1 + x**2/2 + x**4/24 + x**6/720 + x**8/40320 + O(x**10)
atan(x)= x - x**3/3 + x**5/5 - x**7/7 + x**9/9 + O(x**11)

Analyse

Als ersten Parameter erwartet die Methode series(f,x,n) eine mathematische Funktion f, für die die Reihe berechnet werden soll. Der zweite Parameter x steht für die unabhängige Variable, und der dritte Parameter n legt die Anzahl der Reihenglieder fest. Alle Reihen werden im Entwicklungspunkt x₀ = 0 berechnet. Die Angabe O() (engl. order, dt.: Reihenfolge oder Ordnung) steht für die Potenz des als Nächstes zu erwartenden Reihengliedes.

Die Richtigkeit der Ausgaben lässt sich anhand der Fachliteratur verifizieren.

Anwendungsbeispiel

Die Taylor-Entwicklung kann auch dazu benutzt werden, die Gültigkeit der eulerschen Formel

zu demonstrieren. Listing 10.17 zeigt die Umsetzung:

01  #17_sympy_taylor.py
02  from sympy import *
03  x=symbols('x')
04  r1=series(cos(x),n=8)
05  r2=series(I*sin(x),n=8)
06  r3=series(exp(I*x),n=6)
07  r4=series(cos(x)+I*sin(x),n=6)
08  #r4=r1+r2
09  print("eulersche Formel")
10  print("cos(x)\t\t=",r1)
11  print("i*sin(x)\t=",r2)
12  print("exp(i*x)\t=",r3)
13  print("cos(x)+i*sin(x) =",r4)

Listing 10.17     Beweis der eulerschen Formel

Ausgabe

eulersche Formel
cos(x)   = 1 - x**2/2 + x**4/24 - x**6/720 + O(x**8)
i*sin(x) = I*x-I*x**3/6 + I*x**5/120 - I*x**7/5040 + O(x**8)
exp(i*x)       =1+I*x-x**2/2-I*x**3/6+x**4/24+I*x**5/120+O(x**6)
cos(x)+i*sin(x)=1+I*x-x**2/2-I*x**3/6+x**4/24+I*x**5/120+O(x**6)

Analyse

In Zeile 04 wird die Kosinusreihe entwickelt. Das Ergebnis wird in der Objektvariablen r1 gespeichert. In Zeile 05 wird die komplexe Sinusreihe entwickelt. Das I steht für die imaginäre Einheit. Das Ergebnis wird in der Objektvariablen r2 gespeichert. In Zeile 06 wird die komplexe Exponentialreihe exp(I*x) entwickelt. Das Ergebnis wird in der Objektvariablen r3 gespeichert. In Zeile 07 wird die Summe aus der Kosinus- und der komplexen Sinusreihe gebildet und in der Objektvariablen r4 gespeichert.

Die Ausgabe der Reihenglieder für die Kosinus- und die komplexe Sinusreihe erfolgt in den Zeilen 10 und 11. In Zeile 12 wird die komplexe Exponentialreihe ausgegeben. In Zeile 13 wird die Summe aus der Kosinus- und der komplexen Sinusreihe ausgegeben. Die Ausgaben der letzten beiden Zeilen sind gleich, auch wenn man beliebig andere Werte für n einsetzt. Was gezeigt werden sollte!

Approximation einer Sinusfunktion

In dem nächsten Programm soll die Approximation einer Sinusfunktion mit einer Taylor-Entwicklung anhand eines Funktionsgraphen veranschaulicht werden. Abbildung 10.8 zeigt die Approximation dieser Funktion an der Entwicklungsstelle x₀ = π/2 für zwei Glieder.

Abbildung 10.8     Approximation um den Entwicklungspunkt π/2

Listing 10.18 zeigt, wie eine Taylor-Reihe an einem bestimmten Entwicklungspunkt mit der SymPy-Methode series() berechnet und mit der SymPy-Methode plot() grafisch dargestellt werden kann. Mit dem Programm können Sie die Genauigkeit der Approximation simulieren, indem Sie in Zeile 04 die Anzahl der Glieder n verändern. In Zeile 05 können Sie auch den Entwicklungspunkt x0 variieren. Außerdem können Sie in Zeile 06 andere beliebig oft differenzierbare Funktionen eintragen, z. B. cos(x), exp(x), sinh(x), cosh(x), atan(x) und ln(x+1).

01  #18_entwicklungspunkt.py
02  from sympy import *
03  x=symbols('x')
04  n=3     #Anzahl der Glieder
05  x0=pi/2 #Entwicklungspunkt
06  f1=sin(x)
07  r=series(f1,x,x0,n)
08  f2=r.removeO()
09  print("sin(x) =",r)
10  print("sin(x) =",f2) 
11  p1=plot(f1,(x,0,pi),show=False,line_color='blue')
12  p2=plot(f2,(x,0,pi),show=False,line_color='red')
13  p1.extend(p2)
14  p1.show()

Listing 10.18     Entwicklung der Taylor-Reihe für x₀ = π/2

Ausgabe

sin(x) = 1 - (x - pi/2)**2/2 + O((x - pi/2)**3, (x, pi/2))
sin(x) = 1 - (x - pi/2)**2/2

Analyse

Die Zeilen 04 und 05 legen die Anzahl n der Reihenglieder und den Entwicklungspunkt x0 der Reihe fest. In Zeile 06 steht die mathematische Funktion f1, für die die Reihe entwickelt werden soll. In Zeile 07 wird die Reihe mit der SymPy-Methode series(f1,x,x0,n) erzeugt. Der dritte Parameter legt den Entwicklungspunkt x0 fest. Alle Daten der Reihenentwicklung werden in dem Objekt r gespeichert.

Damit der Funktionsgraph der Reihenglieder gezeichnet werden kann, muss die Methode r.removeO() das letzte Glied O((x - pi/2)**3, (x, pi/2)) aus der Reihe entfernen (Zeile 08).

Die Daten für die Funktionsgraphen werden in den Objekten p1 und p2 gespeichert (Zeilen 11 und 12). Die Methode p1.extend(p2) fügt beide Objekte zusammen. Die Methode p1.show() sorgt für die Bildschirmausgabe.