EINFÜHRUNG

Aneinandergereihte Zahlen faszinieren die Menschen seit langer Zeit. Bereits in der Antike um 200 v. Chr. hat Achimedes die Zahl Pi durch eine Zahlenfolge angenähert, indem er den Umfang der in den Kreis eingezeichneten regelmässigen Vielecke mit zunehmender Eckenzahl betrachtete. Bereits für ihn war offenbar klar, dass der Kreis als Grenzfall eines regelmässigen Vielecks mit immer grösser werdender Eckenzahl aufgefasst werden kann und damit auch der Umfang der Vielecke gegen den Umfang des Kreises streben musste.

Eine Zahlenfolge besteht aus den Zahlen a₀, a₁, a₂, usw., also aus den Gliedern a_n mit dem Index n = 0, 1, 2, usw. (Manchmal beginnt man auch mit n = 1.) Ein Bildungsgesetz bestimmt eindeutig, wie gross jede der Zahlen ist. Ist a_k für alle noch so grossen natürlichen Zahlen definiert, so spricht man von einer unendlichen Zahlenfolge. Das Gesetz kann als expliziter Ausdruck von n angegeben sein. Ein Glied kann sich aber auch aus vorhergehenden Gliedern berechnen lassen (rekursives Gesetz). In diesem Fall müssen auch noch Startwerte bekannt sein.

Eine konvergente Zahlenfolge hat eine sehr anschauliche Eigenschaft: Es gibt für sie eine eindeutige Zahl g, genannt Grenzwert, an die sich die Glieder immer mehr annähern, was so zu verstehen ist, dass du ein beliebig kleines Umgebungsintervall von g wählen kannst und alle Glieder von einem gewissen n nicht mehr aus diesem Intervall herausfallen. Die Umgebung kannst du dir wie ein Haus um den Grenzwert vorstellen: Die Folge kann vorerst eventuell wilde Sprünge machen, aber von einem bestimmten n an befinden sich alle Glieder im noch so kleinen Haus.

Zahlenfolgen können mit dem Computer experimentell untersucht werden. Zur Veranschaulichung verwendest du verschiedene grafische Darstellungen: Du kannst beispielsweise wie im oberen Bild auf einer Achse die Glieder als Striche oder Punkte eintragen und untersuchen, ob sich ein Häufungspunkt ergibt. Du kannst aber auch in einem x-y-Diagramm die n auf der x-Achse und a_n auf der y-Achse als Punkte eintragen und untersuchen, wie sich der Graf für grosse Werte von n verhält

DER JÄGER UND SEIN HUND

Ein Jäger spaziert mit der Geschwindigkeit u = 1 m/s mit seinem Hund zur d = 1000 m entfernten Jagdhütte. Weil der Jäger für den Hund allerdings deutlich zu langsam läuft, verfährt der Hund wie folgt: Er läuft allein mit der Geschwindigkeit u = 20 m/s bis zur Jagdhütte, kehrt dort unverzüglich um und läuft seinem Herrn entgegen. Sobald er diesen erreicht, dreht er wieder um, läuft  bis zur Jagdhütte und so weiter.

Du möchtest mit einem Programm diesen Vorgang simulieren. In deinem Programm zeichnest du bei jedem Tastendruck die Lage des Jägers beim Zusammentreffen mit dem Hund als schwarzen Punkt ein und schreibst daneben die Position aus. Die aufeinander folgenden Werte von a bilden eine Zahlenfolge, deren Verhalten du studieren willst. Da für Jäger und Hund zwischen zwei Zusammentreffen die gleiche Zeit verstreicht, gilt für die Zunahme der Position des Jägers:   (da)/ u = (2 * (d - a) - da)/          v

woraus du mit wenig Algebra die folgende Beziehung nachweisen kannst:

Wie zu erwarten ist, häufen sich die Zahlen a_n gegen die Grenzzahl 1000.

from gpanel import *

u = 1 # m/s
v = 20 # m/s
d = 1000  # m
a = 0     # hunter
h = 0     # dog
c = 2 * u / (u + v)
it = 0

makeGPanel(-50, 50, -100, 1100)
title("Hunter-Dog problem")
line(0, 0, 0, 1000)
line(-5, 1000, 5, 1000)
line(-5, 1050, 5, 1050)
line(-5, 1000, -5, 1050)
line(5, 1000, 5, 1050)

while not isDisposed():
    move(0, a)
    fillCircle(1)
    text(5, a, str(int(a)))
    getKeyWait()
    da = c * (d - a)
    dh = 2 * (d  - a) - da
    h += dh
    a += da 
    it += 1
    title("it = " + str(it) + "; hunter = " + str(a) +
          " m; dog = " + str(h) + " m")

MEMO

DAS FEIGENBAUM-DIAGRAMM

Im Zusammenhang mit der Populationsdynamik hast du das logistische Wachstum kennengelernt. Dabei wird die Populationsgrösse xnew in der nächsten Generation aus der aktuellen Grösse x aus einer quadratischen Beziehung berechnet. Im Folgenden wird der Zusammenhang vereinfacht:

xnew = r * x * (1 - x)

an+1 = r * an * (1 - an) mit a0 = 0.5 konvergiert und welches in diesem Fall ihr Grenzwert ist. Du untersuchst das Verhalten mit einem extrem einfachen Programm, wo du für 1000 äquidistante Werte von r im Bereich 0 bis 4 die ersten 1000 Glieder der Folge als Punkte aufzeichnest. Du beginnst bei einem festen r immer mit dem gleichen Startwert a0 = 0.5 und zeichnest die Glieder erst von der n = 500 an, da du dich nur dafür interessierst, ob die Folge konvergent oder divergent ist.

from gpanel import *

def f(x, r):
     return r * x * (1 - x)

makeGPanel(-0.6, 4.4, -0.1, 1.1)
title("Tree Diagram")
drawGrid(0, 4.0, 0, 1.0, "gray")
for z in range(1001):
    r = 4 * z / 1000
    a = 0.5
    for i in range(1001):
        a = f(a, r)
        if i > 500:
            point(r, a)

MEMO

DIE EULERSCHE ZAHL

MEMO

SCHNELL KONVERGIERENDE FOLGEN ZUR BERECHNUNG VON PI

Die Berechnung von π auf möglichst viele Stellen stellt seit dem Altertum eine Herausforderung dar. Erst 1995 entdeckten die Mathematiker Bailey, Borwein und Plouffe eine Summenformel, die BBP-Formel. Sie bewiesen, dass man π exakt als Grenzwert einer Folge erhält, deren n-tes Glied die Summe von

Dein Programm verwendet das Python-Modul decimal, die Dezimalzahlen mit hoher Genauigkeit zur Verfügung stellt. Aus einem Integer oder Float erzeugt der Konstruktor eine solche Zahl, wobei die üblichen mathematischen Operationszeichen direkt verwendbar sind.

Mit getcontext().prec legt man die Genauigkeit fest. Diese entspricht ungefähr der Stellenzahl der verwendeten Dezimalzahlen.

Dein Programm berechnet bei jedem Tastendruck das nächste Folgeglied und stellt den Wert in einem EntryDialog dar.

from entrydialog import *
from decimal import *
getcontext().prec = 50

def a(k):
    return 1/16**Decimal(k) * (4 / (8 * Decimal(k) + 1) - 2 
    / (8 * Decimal(k) + 4) - 1
    / (8 * Decimal(k) + 5) - 1 / (8 * Decimal(k) + 6))

inp = IntEntry("n", 0)
out = StringEntry("Pi")
pane0 = EntryPane(inp, out)
btn = ButtonEntry("Next")
pane1 = EntryPane(btn)
dlg = EntryDialog(pane0, pane1) 
dlg.setTitle("BBP Series - Click Next")
n = 0
s = a(0)
out.setValue(str(s))
while not dlg.isDisposed():
    if btn.isTouched():
       n = inp.getValue()
       if n == None:
           out.setValue("Illegal entry")
       else:
           n += 1
           s += a(n)
           inp.setValue(n)
           out.setValue(str(s))

MEMO

AUFGABEN

ZUSATZSTOFF

ITERATIVE LÖSUNG EINER GLEICHUNG

MEMO