10.3 Geometrische Reihen
In Kapitel 7 wurde die geometrische Folge qn behandelt. Die Bezeichnung geometrisch beruht auf der Tatsache, dass ein Folgenglied aus dem geometrischen Mittel seines Vorgängers und seines Nachfolgers berechnet werden kann. Eine geometrische Reihe entsteht, wenn die Glieder einer geometrischen Zahlenfolge addiert werden.
Betrachten wir als einführendes Beispiel folgende Reihe:
Der Ausdruck q = 1/2 ist für alle Folgenglieder konstant. Für das geometrische Mittel des 4. Gliedes 1/8 gilt beispielsweise:
Ein weiteres Merkmal einer geometrischen Reihe besteht darin, dass der Quotient q aus einem Nachfolger und seinem Vorgänger konstant ist. Es gilt z. B.:
Für die 6. Partialsumme kann allgemein formuliert werden:
Wenn man die Addition endlos weiter ausführen würde, dann würde man vermutlich den Wert 2 erhalten. Abbildung 10.4 visualisiert den Grenzwertprozess.
Abbildung 10.4 Visualisierung des Grenzwertprozesses einer geometrischen Reihe
Die geometrische Reihe hat die allgemeine Form:
Sie konvergiert für |q| < 1 und divergiert für |q| > 1.
Für die Berechnung der Partialsummen von k = 0 bis n gilt die allgemeine Summenformel:
Wenn der Betrag von |q| < 1 ist und n gegen unendlich geht, gilt für den Grenzwert s der geometrischen Reihe:
Zur Erinnerung: Der Grenzwert einer Reihe ist die Summe der Folgenglieder, wenn n gegen unendlich geht.
Listing 10.11 berechnet Wertetabellen für die n-ten Partialsummen mit dem Summenalgorithmus und der Summenformel sn:
01 #11_tab_geo_reihe.py
02 from fractions import Fraction
03 m=10
04 a=1
05 zaehler=1
06 nenner=2
07 q=Fraction(zaehler,nenner) #q<1
08 summe=0
09 print("n\t∑\t∑ \t a*(q**(n+1)-1)/(q-1)")
10 for n in range(m+1):
11 summe=summe + a*q**n
12 sn=a*(q**(n+1)-1)/(q-1)
13 print("%2i %10s %2.10f %2.10f" %(n,summe,float(summe),float(sn)))
Listing 10.11 Berechnung der n-ten Partialsummen
Ausgabe
n ∑ ∑ a*(q**(n+1)-1)/(q-1)
0 1 1.0000000000 1.0000000000
1 3/2 1.5000000000 1.5000000000
2 7/4 1.7500000000 1.7500000000
3 15/8 1.8750000000 1.8750000000
4 31/16 1.9375000000 1.9375000000
5 63/32 1.9687500000 1.9687500000
6 127/64 1.9843750000 1.9843750000
7 255/128 1.9921875000 1.9921875000
8 511/256 1.9960937500 1.9960937500
9 1023/512 1.9980468750 1.9980468750
10 2047/1024 1.9990234375 1.9990234375
Analyse
In Zeile 02 wird die Methode Fraction aus dem Modul fractions importiert. Mit dieser Methode lassen sich Zahlen als Brüche darstellen. In Zeile 07 wird q als Bruch (rationale Zahl) definiert. In Zeile 11 erfolgt die Summenbildung der Brüche mit dem Summenalgorithmus. Diese Brüche werden in der zweiten Spalte ausgegeben.
Zeile 12 berechnet die Partialsummen der geometrischen Reihe mit der Summenformel. Gezeigt werden sollte, dass die Ergebnisse aus dem Summenalgorithmus (3. Spalte) und der Summenformel (4. Spalte) übereinstimmen.
Simulation einer geometrischen Reihe
Für ein besseres Verständnis einer geometrischen Reihe ist es sinnvoll, den Parameter a und den Wert q des Reihengliedes dynamisch zu ändern.
Abbildung 10.5 Simulation einer geometrischen Reihe
Abbildung 10.5 zeigt die Programmoberfläche für die Simulation einer geometrischen Reihe. Die Werte von a und q können Sie mit dem Slider-Steuerelement ändern, indem Sie die Slider-Knöpfe verschieben.
Mit Listing 10.12 kann eine geometrische Reihe simuliert werden:
01 #12_sld_geo_reihe.py
02 import numpy as np
03 import matplotlib.pyplot as plt
04 from matplotlib.widgets import Slider
05 #geometrische Reihe
06 def f(n,a,q):
07 if q==1:
08 q=1e-6
09 return a*(q**(n+1)-1)/(q-1)
10 #Slider-Werte auslesen
11 def update(val):
12 a = sldA.val
13 q = sldB.val
14 y.set_data(n,f(n,a,q))
15 ax.relim()
16 ax.autoscale_view()
17 fig.canvas.draw_idle()
18 #Grafikbereich
19 fig, ax = plt.subplots()
20 fig.subplots_adjust(left=0.12, bottom=0.25)
21 ax.set_title(r'$s_{n}=a\frac{q^{n+1}-1}{q-1}$')
22 ax.set_xlim(0,11)
23 ax.set(xlabel='n',ylabel='$s_{n}$')
24 n = np.arange(0,11,1)
25 y, = ax.plot(n,f(n,1,0.5),'rx')
26 #x-, y-Position, Laenge, Hoehe
27 xyA = fig.add_axes([0.1, 0.10, 0.8, 0.03])
28 xyB = fig.add_axes([0.1, 0.05, 0.8, 0.03])
29 #Slider-Objekte erzeugen
30 sldA=Slider(xyA,'a',0.5,4.0,valinit=1,valstep=0.1)
31 sldB=Slider(xyB,'q',-0.8,1.1,valinit= 0.5,valstep=0.01)
32 #Aenderungen abfragen
33 sldA.on_changed(update)
34 sldB.on_changed(update)
35 ax.grid(True)
36 plt.show()
Listing 10.12 Simulation einer geometrischen Reihe
Analyse
Die Funktionsdefinition der geometrischen Reihe erfolgt in den Zeilen 06 bis 09. Für den Fall, dass q==1 wird, wird innerhalb der if-Abfrage q der Wert 1e-6 zugewiesen (Zeile 08).
In den Zeilen 12 und 13 werden die aktuellen Werte der Slider-Einstellungen a=sldA.val und q=sldB.val erfasst und der Funktion f(n,a,q) in Zeile 14 übergeben. Neu ist die Aktualisierung der Skalierung der y-Achse in Zeile 15 mit der Matplotlib-Methode von relim(). Wenn die Funktionswerte der geometrischen Reihe den vorgegebenen Wertebereich überschreiten, wird die Skalierung auf der y-Achse angepasst. Man erkennt, dass die Reihe umso schneller konvergiert, je kleiner q ist.
In Zeile 24 legt das NumPy-Array den Definitionsbereich der geometrischen Reihe von 0 bis 11 fest. Die Schrittweite beträgt 1.
Zeile 25 speichert die Anfangswerte in der Objektvariablen y. Die Glieder der geometrischen Reihe werden als rote Kreuze dargestellt. Mit der Eigenschaft markersize können Sie die Größe der Kreuze ändern.
In den Zeilen 27 und 28 legt die Matplotlib-Methode add_axes() die Positionen der Slider-Objekte auf dem Zeichenbereich fest, und in den Zeilen 30 und 31 werden sie erzeugt. Ihre Eigenschaften werden in den Objekten sldA und sldB gespeichert.
In den Zeilen 33 und 34 rufen die Methoden sldA.on_changed(update) und sldB.on_changed(update) die Funktion update(val) auf und veranlassen für jede Änderung der Slider-Einstellung sldA und sldB das Neuzeichnen des Funktionsplots.