0% fanden dieses Dokument nützlich (0 Abstimmungen)

110 Ansichten323 Seiten

Physik Per Computer

Hochgeladen von

adam.miroslaw.wysocki

Wir nehmen die Rechte an Inhalten ernst. Wenn Sie vermuten, dass dies Ihr Inhalt ist, beanspruchen Sie ihn hier.

Verfügbare Formate

Als PDF, TXT herunterladen oder online auf Scribd lesen

0% fanden dieses Dokument nützlich (0 Abstimmungen)

110 Ansichten323 Seiten

Physik Per Computer

Hochgeladen von

adam.miroslaw.wysocki

Wir nehmen die Rechte an Inhalten ernst. Wenn Sie vermuten, dass dies Ihr Inhalt ist, beanspruchen Sie ihn hier.

Verfügbare Formate

Als PDF, TXT herunterladen oder online auf Scribd lesen

Sie sind auf Seite 1/ 323

Wolfgang Kinzel / Georg Reents

PHYSIK PER COMPUTER

Programmierung Physikalischer Probleme

mit Mathematica und C

c 1996 Spektrum Akademischer Verlag

Vorwort

Der Computer ist heutzutage ein wichtiges Werkzeug der Physik. Die Erfassung und
Auswertung umfangreicher Meßdaten und die Steuerung komplexer Experimente
sind ohne den Einsatz von elektronischen Rechnern kaum mehr vorstellbar. Auch in
der theoretischen Physik hat sich der Computer von einer reinen Rechenmaschine
zu einem umfassenden Hilfsmittel gewandelt. Graphische Darstellungen, numeri-
sche und algebraische Lösungen von Gleichungen und extensive Simulationen von
mikroskopischen Modellen sind wichtige Methoden zur Erforschung physikalischer
Gesetzmäßigkeiten geworden.
Aber der Computer ist nicht nur ein Werkzeug, sondern er liefert der Physik auch
neuartige Betrachtungsweisen, aus denen neue Fragestellungen resultieren. Früher
haben Physiker die Natur hauptsächlich mit Differentialgleichungen beschrieben,
heute werden dazu auch diskrete Algorithmen benutzt. Für manche, scheinbar ein-
fache physikalische Modelle gibt es bisher nur eine numerische Antwort. Wir ken-
nen universelle Gesetzmäßigkeiten, die ein Schüler auf dem Taschenrechner nach-
vollziehen kann, für die es aber (noch?) keine analytische Theorie gibt. Darüber
hinaus erschließt der Computer der Physik neue Disziplinen: Neuronale Netzwer-
ke, kombinatorische Optimierung, biologische Evolution, fraktale Strukturbildung
und Synergetik sind nur einige Schlagworte aus dem wachsenden Gebiet komplexer
Systeme.
Fast jeder Diplomand und Doktorand der Physik nutzt also irgendwann den Com-
puter. Dennoch ist der Einsatz des Rechners in der Lehre und die Ausbildung am
Rechner heute noch keinesfalls selbstverständlich, sondern eher die Ausnahme. Die
Literatur zu diesem Gebiet ist dementsprechend spärlich. Diese Lücke zu füllen,
dazu möchte unser Lehrbuch ein wenig beitragen.
Es entstand aus Vorlesungen an der Universität Würzburg für Studierende der
Physik ab dem 5. Semester, also nach den Grundvorlesungen der theoretischen Phy-
sik, und es soll der Ergänzung der herkömmlichen Physikvorlesungen dienen, in
denen die Möglichkeiten des Computereinsatzes bisher wenig genutzt werden. Wir
möchten die Leser dieses Buches anleiten, physikalische Fragestellungen mit dem
Rechner zu beantworten. Erfahrungen mit Computern und deren Sprachen sind er-
wünscht, aber nicht notwendig, denn wir wollen eine Einführung geben und erste
VI Vorwort

Schritte mit Rechnern und Algorithmen erklären. Dieses Buch enthält keine Details
über numerische Mathematik, es bietet keinen Kurs über Programmiersprachen und
es lehrt keine fortgeschrittenen Methoden der computerorientierten theoretischen
Physik. Aber es führt in eine Vielzahl zum Teil sehr aktueller physikalischer Pro-
bleme ein und versucht, diese mit einfachen Algorithmen zu lösen.
Ein Ziel unseres Buches ist, Anregungen zum eigenen Programmieren zu geben.
Obwohl fertige Programme beiliegen, sind diese nicht als benutzerfreundliche Ex-
perimentierumgebungen gedacht. Wir hoffen, daß man aus ihnen lernen kann, und
ermuntern unsere Leser, sie zu modifizieren, oder besser noch, sie neu und effizi-
enter zu schreiben. Manchmal ergeben sich beim Probieren und aus vermeintlichen
Fehlversuchen sogar neue Fragestellungen. Man sollte aber die Physik und die zu
untersuchenden Gesetzmäßigkeiten nicht aus dem Auge verlieren. Übungsaufgaben
zu jedem Abschnitt ergänzen diese Einführung.
Als Programmiersprachen haben wir Mathematica und C gewählt. Beides sind
moderne Sprachen, die besonders an heutige Arbeitsplatzrechner (z. B. RISC-Work-
stations unter UNIX) angepaßt sind. Diese Auswahl ist subjektiv und keinesfalls
notwendig zur Bearbeitung der Probleme dieses Lehrbuchs. Bei rechenzeitintensi-
ven Computersimulationen wird häufig die Sprache FORTRAN gewählt, deren neue
Version FORTRAN90 Elemente der Sprache C übernommen hat. Für die Compu-
teralgebra ist auch MAPLE recht beliebt. Eine Reihe anderer Programmiersprachen
wäre also ebenso geeignet. Alle unsere Programme laufen nicht nur auf schnellen
Workstations, sondern auch unter DOS oder LINUX auf einem PC.
Von vielen Kollegen und Studenten haben wir Anregungen erhalten, ihnen dan-
ken wir hiermit sehr herzlich. Wir möchten erwähnen: M. Biehl, H. Dietz, A. En-
gel, A. Freking, Th. Hahn, W. Hanke, G. Hildebrand, A. Jung, A. Karch, U. Krey,
J. Nestler, M. Opper, M. Schreckenberg und D. Stauffer. Ganz besonderen Dank
aber möchten wir drei Personen aussprechen: Martin Lüders hat das Programmpa-
ket Xgraphics entwickelt, Martin Schröder hat den Abschnitt über UNIX verfaßt
und Ursula Eitelwein hat dieses Buch in LATEXgeschrieben.

Würzburg, im März 1996

W. Kinzel
G. Reents
Inhaltsverzeichnis

Einleitung 1

1 Mathematica-Funktionen 3
1.1 Funktion versus Prozedur . . . . . . . . . . . . . . . . . . . . . . 4
1.2 Nichtlineares Pendel . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.3 Fouriertransformation . . . . . . . . . . . . . . . . . . . . . . . . 13
1.4 Daten glätten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
1.5 Nichtlinearer Fit . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
1.6 Multipol-Entwicklung . . . . . . . . . . . . . . . . . . . . . . . . 32
1.7 Wegintegrale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
1.8 Maxwell-Konstruktion . . . . . . . . . . . . . . . . . . . . . . . . 41
1.9 Beste Spielstrategie . . . . . . . . . . . . . . . . . . . . . . . . . 45

2 Lineare Gleichungen 51
2.1 Quantenoszillator . . . . . . . . . . . . . . . . . . . . . . . . . . 51
2.2 Elektrisches Netzwerk . . . . . . . . . . . . . . . . . . . . . . . . 56
2.3 Kettenschwingungen . . . . . . . . . . . . . . . . . . . . . . . . . 65
2.4 Hofstadter-Schmetterling . . . . . . . . . . . . . . . . . . . . . . 69
2.5 Hubbard-Modell . . . . . . . . . . . . . . . . . . . . . . . . . . . 77

3 Iterationen 89
3.1 Populationsdynamik . . . . . . . . . . . . . . . . . . . . . . . . . 89
3.2 Frenkel-Kontorova-Modell . . . . . . . . . . . . . . . . . . . . . 101
3.3 Fraktales Gitter . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
3.4 Neuronales Netzwerk . . . . . . . . . . . . . . . . . . . . . . . . 117

4 Differentialgleichungen 127
4.1 Runge-Kutta-Methode . . . . . . . . . . . . . . . . . . . . . . . . 127
4.2 Chaotisches Pendel . . . . . . . . . . . . . . . . . . . . . . . . . 134
4.3 Stationäre Zustände . . . . . . . . . . . . . . . . . . . . . . . . . 144
VIII Inhaltsverzeichnis

4.4 Solitonen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150

4.5 Zeitabhängige Schrödinger-Gleichung . . . . . . . . . . . . . . . . 159

5 Monte-Carlo-Simulationen 173
5.1 Zufallszahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
5.2 Fraktale Aggregate . . . . . . . . . . . . . . . . . . . . . . . . . . 180
5.3 Perkolation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
5.4 Polymer-Ketten . . . . . . . . . . . . . . . . . . . . . . . . . . . 200
5.5 Ising-Ferromagnet . . . . . . . . . . . . . . . . . . . . . . . . . . 210
5.6 Kürzeste Rundreise . . . . . . . . . . . . . . . . . . . . . . . . . 221

A Erste Schritte mit Mathematica 233

B Erste Schritte mit C 247

C Erste Schritte mit UNIX 258

D Erste Schritte mit Xgraphics 268

E Programme 272

Sach- und Namenverzeichnis 308

Einleitung

Dieses Lehrbuch soll den Leser an die Lösung physikalischer Fragestellungen mit
dem Computer heranführen. Die Beispiele sind möglichst einfach gehalten, um sie
mit wenig Aufwand algebraisch, numerisch und graphisch umzusetzen. Die Anwen-
dung von Computern lernt man hauptsächlich durch eigene Arbeit – ohne ständiges
Ausprobieren, ohne spielerische Neugier und ohne den Wunsch zu forschen ist die-
ses Buch nur von geringem Nutzen.
Fast jeder Abschnitt enthält drei Teile mit den folgenden Überschriften: Physik,
Algorithmus und Ergebnisse. Im Physik-Teil wird das Problem formuliert und das
Modell eingeführt. Im mittleren Abschnitt wird das Computerprogramm beschrie-
ben, das die Fragestellungen aus dem ersten Teil lösen soll. Dabei werden nur die
wesentlichen Befehle erklärt, damit der Leser selbst versuchen kann, das Programm
zu vervollständigen. Man kann aber auch den kompletten Computercode aus dem
Anhang entnehmen und damit weiterarbeiten; der Quell- und der ausführbare Code
sind auf der beiliegenden Diskette vorhanden. Im Ergebnisteil werden dann einige
Resultate der Computerrechnungen, meist in Graphikform, erläutert.
Wir haben bewußt eine große Zahl von Beispielen – z.T. auch aus der aktuellen
Forschung – behandelt. Die Darstellung der theoretischen Grundlagen kann deshalb
nur als erste Einführung angesehen werden. Viele Abschnitte könnten zu ganzen
Vorlesungen ausgearbeitet werden, wir müssen auf die weiterführende Literatur ver-
weisen. Dazu haben wir zu jedem Problem einige von uns ausgewählte Lehrbücher
oder Originalliteratur zitiert. Die Auswahl dieser Zitate ist naturgemäß sehr sub-
jektiv und erhebt keinerlei Anspruch auf Vollständigkeit. Am Schluß eines jeden
Abschnittes wird eine Übungsaufgabe gestellt.
Die PC-Programme sind auf 386-Rechnern mit Koprozessor und VGA-Karte ge-
laufen. Dies gilt auch für die Mathematica-Beispiele (Version 2. 1). Auf dem PC
wurde für die C-Programme Turbo C (2.0) von Borland verwendet. Damit kann
man bequem Programme entwickeln und Graphik erzeugen.
Von allen Programmen gibt es auch Versionen für Workstations, getestet sind sie
auf solchen vom Typ Hewlett Packard HP 9000 Serie 700. Leider ist es dort sehr
viel schwieriger als auf dem PC, Graphik zu erzeugen. Schon um nur eine Linie
oder einen Kreis auf den Bildschirm zu zeichnen, müssen Displays gesetzt, Fenster
2 Einleitung

erzeugt, Farbpaletten und gegebenenfalls Ereignisse (Maus- oder Tastaturbefehle)

definiert und der Inhalt des Bildspeichers auf den Monitor geschrieben werden. Da-
zu muß man komplizierte neue Sprachen wie X11, Motif oder PHIGS lernen. Um
dies zu erleichtern, hat Martin Lüders das Programmpaket Xgraphics auf der Basis
der X11-Bibliothek entwickelt, das mit relativ wenig Befehlen elementare Graphik
auf hoffentlich jedem Bildschirm einer Workstation erzeugt. Dieses Paket ist auf der
beiliegenden Diskette vorhanden. Darüber hinaus kann es sich jeder Interessent über
das weltweite Internet von unserem FTP-Server beschaffen und selbst kompilieren.
Die Versionen aller C-Programme, die diese Graphik benutzen, werden ebenfalls
mitgeliefert.
Alle C-Programme dieses Buches werden in der PC-Version beschrieben. Die
Abbildungen dagegen wurden mit Xgraphics erzeugt. Meist haben wir die Fenster
so gezeigt, wie sie auf dem Bildschirm erscheinen.
Die meisten C-Programme lassen sich während ihres Laufes interaktiv steuern.
Sowohl die Versionen für den PC als auch diejenigen für die Workstation erlauben
es, mit Tastatureingaben einige Parameter oder Algorithmen zu ändern oder das
Programm zu beenden. Auf der Workstation kann man zusätzlich mit der Maus den
Lauf steuern.
Wir möchten noch einmal betonen, daß unsere Hard- und Softwareausrüstung
keinesfalls für die Bearbeitung der physikalischen Probleme zwingend notwendig
ist. Jedes Problem kann auch mit verschiedenen anderen Programmiersprachen ge-
löst werden. Wir hoffen, daß die Leser dieses Lehrbuchs bald in der Lage sein wer-
den, die Modelle in ihrer Lieblingssprache selbst zu formulieren und zu bearbeiten.
Kapitel 1
Mathematica-Funktionen

Auf der untersten Ebene der Hierarchie der Programmiersprachen arbeitet der Com-
puter kleine Päckchen von An-Aus-Daten (= Bits) schrittweise ab. Jedes Datenpäck-
chen gibt Anweisungen an elektronische Schalter, wodurch die Ergebnisse von ele-
mentaren Rechenoperationen in Datenspeicher geschrieben und neue Daten gelesen
werden. Auf dieser Ebene des schrittweisen Abarbeitens elementarer Befehle in Bit-
form kann der Mensch allerdings kaum schwierigere Probleme formulieren.
Komplexe Algorithmen sollten daher strukturiert sein. Dementsprechend besteht
eine höhere Programmiersprache aus Funktionen oder Modulen. Um ein Programm
überschaubar zu halten, sollte man Module verwenden, die vom Groben zum Fei-
nen gegliedert sind. Ein guter Programmierstil wird in der Regel mehrere Ebenen
davon benutzen, mit dem Vorteil, daß solche Programme leichter modifiziert werden
können, weil eventuell nur einzelne Funktionen ausgetauscht werden müssen.
Mathematica ist eine Programmiersprache, die eine große Menge an Funktionen
enthält, deren Aufruf aber leichtfällt, da die meisten Parameter Voreinstellungen be-
sitzen und nicht unbedingt angegeben werden müssen. Selbst jede Zeile, die man
in Mathematica eingibt, kann als eine Funktion betrachtet werden, die sofort aus-
geführt wird und für alle folgenden und sogar vorherigen Befehle eine Rolle spielt.
In der Hierarchie der Computersprachen ist Mathematica daher in diesem Sinne
ganz oben anzusiedeln.
Dagegen sind C, FORTRAN, Pascal und Basic zwar ebenfalls höhere Program-
miersprachen mit numerischen und graphischen Funktionen, und schließlich ist Ma-
thematica in C geschrieben, aber der Aufwand, um sich z. B. schnell einmal den
Graphen einer Besselfunktion im Komplexen anzuschauen, ist bei diesen Sprachen
wesentlich größer als bei Mathematica.
Dieses Kapitel soll in die Nutzung von Mathematica-Funktionen einführen. An
einfachen Beispielen werden folgende Anwendungen vorgestellt: elliptische Inte-
grale, Reihenentwicklung, Fouriertransformation, 2 -Verteilung, 3D-Graphik, Vek-
tor-Multiplikation und -Integration, Bestimmung von Nullstellen nichtlinearer Glei-
chungen und lineares Optimieren.
4 1 Mathematica-Funktionen

1.1 Funktion versus Prozedur

Der Unterschied zwischen einem schrittweisen Abarbeiten von Befehlen, das wir
hier Prozedur nennen wollen, und einem Aufruf von vorhandenen Funktionen soll
an einem einfachen Beispiel erläutert werden: Der Mittelwert von 10000 gleichver-
teilten Zufallszahlen aus dem Intervall [0,1] ist zu bestimmen. Die Daten werden
in Mathematica wie folgt erzeugt:
dataset = Table[ Random[ ], 10000 ] f g
Das Ergebnis ist eine Liste von 10000 numerischen Werten.
Zur Bestimmung des Mittelwertes müssen nun alle Zahlen aufsummiert und die
Summe durch die Anzahl der Werte geteilt werden. Dies läßt sich schrittweise pro-
grammieren und als Funktion average schreiben. Die Iteration kann man als Do-
oder For-Schleife schreiben, dabei schirmt die Funktion Block die lokalen Va-
riablen sum und average gegen Definitionen der Außenwelt ab. Dies kann so
aussehen:
average[data_,length_]:=
Block[ {sum, average},
sum = 0. ;
Do[sum = sum + data[[i]], {i,length}];
average = sum/length ]
Hier wird also Schritt für Schritt eine Zahl aus dem Datensatz data zur Variablen
sum addiert, und dann wird das Ergebnis durch die anzugebende Länge von data
geteilt. Ganz anders bei der modularen Struktur derselben Aufgabe:
average[data ]:= Apply[ Plus, data]/Length[data]
Diesmal werden Funktionen verwendet, die die Struktur der Mathematica-Sprache
ausnutzen. data wird als Liste von Zahlen eingegeben. Apply ersetzt den Kopf
List der Liste data durch den Kopf Plus und summiert damit alle Koeffizienten
von data auf. Length bestimmt die Länge der Liste.
Beachten Sie, daß average dreimal vorkommt: als abgeschirmte Variable und
als Name zweier Funktionen, von denen die eine zwei, die andere dagegen nur ein
Argument hat. Mathematica erkennt die Unterschiede und verwendet in jedem Fall
den richtigen Ausdruck.
Der Leser findet eine Einführung in Mathematica im Anhang; trotzdem wollen
wir hier einige Besonderheiten dieser neuen Sprache wiederholen: data bedeutet,
daß jedes Symbol dafür eingesetzt werden und in die Definition der Funktion über-
tragen werden kann. Die Zuweisung mit := wertet die rechte Seite jedesmal neu
aus, wenn die Funktion aufgerufen wird, während = nur einmal auswertet. Zum
Beispiel gibt r := Random[] bei jedem Aufruf von r einen neuen Wert, während
wiederholte Aufrufe von r für r = Random[] denselben Wert liefern. Indizes von
1.1 Funktion versus Prozedur 5

Listen (Felder, Vektoren, Matrizen, Tensoren usw. ) werden durch Doppelklammern

[[i]] dargestellt.
Um den Unterschied von Mathematica zur Programmiersprache C zu erläutern,
geben wir hier die prozedurale Version unseres kleinen Beispieles noch einmal in
C an. Die Anzahl 10000 erhöhen wir auf eine Million, damit sich Laufzeiten im
Sekundenbereich ergeben:

#include <stdlib.h>
#include <time.h>

#define LIMIT 1000000

main()
{
double average(double *,long), dataset[LIMIT];
clock_t start,end;
long i;
for (i=0;i<LIMIT;i++) dataset[i]=(double)rand()/RAND_MAX;
start=clock();
printf(" average = %f\n",average(dataset,LIMIT));
end=clock();
printf("time= %lf\n",(double)(end–start)/CLOCKS_PER_SEC);
}

double average( double *data,long n )

{
double sum=0. ;
long i;
for(i=0;i<n;i++) sum=sum+data[i] ;
return sum/n;
}

Beachten Sie die Unterschiede zwischen Mathematica und C. In C muß alles de-
klariert werden: Bibliotheksroutinen in den Kopfdateien <name.h> und eigene
Variable und Funktionen mit int, char, float, double usw. C benötigt ei-
ne Folge von Anweisungen mit klar definiertem Hauptprogramm und Funktionen,
während Mathematica immer versucht, alle Symbole mit vorhandenen Definitionen
auszuwerten. C ist maschinennah, mit Vor- und Nachteilen. So wird an die Funktion
average die Maschinenadresse des Feldes dataset übergeben, insbesondere ist
dataset ein Zeiger (=Adresse) auf das Feld, und die einzelnen Werte des Feldes
werden mit dataset[0], ..., dataset[999999] angesprochen. Zeiger wer-
den mit * deklariert, also double *data bedeutet, daß data eine Adresse auf
eine double-Variable enthält. Vorsicht: dataset[1000000] ist irgend etwas
6 1 Mathematica-Funktionen

Undefiniertes, dessen Aufruf zwar keine Fehlermeldung hervorruft, aber meistens

völlig rätselhafte Ergebnisse produziert.
Leider bedeuten in C und Mathematica Komma, Semikolon und verschiedene
Klammersymbole jeweils etwas völlig anderes. Aber warum sollen es die Anwender
leicht haben?
Was ist nun das Ergebnis der drei Versionen unseres Mittelwert-Programmes?
Gibt man average[dataset] in Mathematica ein, so erhält man auf dem PC
nach etwa 10 Sekunden einen Wert in der Nähe von 0.5 . Die dem C-Programm
nachempfundene Version average[dataset, 10000] dauert dagegen drei-
bis viermal länger und liefert natürlich dasselbe Ergebnis. Die Workstation berech-
net diese Ergebnisse jeweils etwa zehnmal schneller als der PC.
Das C-Programm dagegen wird zunächst kompiliert, z. B. mit gcc –o summe
summe.c –lm und dann mit dem File-Namen summe aufgerufen. Jetzt dauert es
auf dem PC nur 8.5 Sekunden und auf der HP 0.56 Sekunden, bis das Ergebnis vor-
liegt, obwohl die Anzahl der Rechenschritte um den Faktor 100 erhöht wurde. Hier
zeigt sich ein wesentlicher Nachteil von Mathematica: Bei numerischen Rechnun-
gen ist es extrem langsam gegenüber C oder vergleichbaren Sprachen.

Literatur
B.W. Kernighan, D.M. Ritchie, Programmieren in C, Carl Hanser Verlag, 1990.
Stephen Wolfram, Mathematica: A System for Doing Mathematics by Computer,
Addison Wesley, 1991.

1.2 Nichtlineares Pendel

Das mathematische Pendel ist ein Standardbeispiel der Physikvorlesung über klas-
sische Mechanik. Schon in der Schule wird die lineare Näherung dieses Problems
besprochen. In der Vorlesung wird die exakte Lösung durch ein elliptisches Integral
ausgedrückt, aber erst der Computer bietet die Möglichkeit, sich diese nichtelemen-
taren Funktionen anzuschauen und genauer zu analysieren. Daher wollen wir dieses
Standardbeispiel der theoretischen Physik an den Anfang unseres Lehrbuches stel-
len.

Physik
Wir beginnen mit dem physikalischen Modell: Eine punktförmige Masse m an ei-
nem masselosen, starren Faden der Länge l schwingt im Schwerefeld. '(t) sei der
1.2 Nichtlineares Pendel 7

Winkel der Auslenkung aus der Ruhelage zur Zeit t, die Reibung sei vernachlässigt.
Nach den Gesetzen der Mechanik ist die Energie E des Pendels konstant, also gilt

E = m2 l2 '_ 2 m g l cos ' = m g l cos '0 ; (1.1)

wobei '0 der Maximalausschlag mit '_0 = 0 sein soll und '_ = d' dt die Winkel-
geschwindigkeit ist. Aus dieser Gleichung kann man '(t) mit einem kleinen Trick
gewinnen: Man separiert t und ', indem man (1.1) erst nach d'
2
dt und dann nach
dem Differential dt auflöst. Für eine Halbperiode, in der ' mit t zunimmt, erhält
man s
dt = 2lg pcos 'd' cos ' : (1.2)
0
Bei passender Wahl des Zeitnullpunktes ( '(0) = 0; '_ (0) > 0 ) ergibt sich hieraus
durch Integration:
s Z' 0
t(') = 2g l pcos 'd'
0 cos '0 : (1.3)
0
Die Schwingungsdauer T ist offensichtlich viermal die Zeit, die das Pendel bis zum
Maximalausschlag '0 braucht,

T = 4 t('0 ) : (1.4)

Da der Integrand von (1.3) für '0 ! '0 divergiert, ist es sinnvoll, die Substitution

sin = sin ' = sin '0

2 2 (1.5)

durchzuführen, mit der man folgendes Integral erhält:

s Z 0
s
t(') = g l q d = lF ; sin '20 :
1 sin2 '2 0
sin2 0 g (1.6)
0
Hier divergiert der Integrand nur noch beim Maximalausschlag '0 = . Die Funk-
tion F nennt man elliptisches Integral der ersten Art. Für ' = '0 ist nach (1.5)
= 2 ; die Schwingungsdauer T berechnet sich daher zu
s s
T = 4 gl F 2 ; sin '20 = 4 gl K sin '20 : (1.7)
8 1 Mathematica-Funktionen

Die Funktion K heißt vollständiges elliptisches Integral erster Art. Sowohl F als
auch K sind in Mathematica vorhanden.
Für kleine Auslenkungen ' ist die potentielle Energie näherungsweise quadra-
tisch. Bekanntlich ist dann die Kraft linear in ', und die Lösung der Bewegungs-
p
gleichung ist eine Sinusschwingung mit Schwingungsdauer T = 2 l=g . Mit
größerem Ausschlag '0 wird die Kraft eine nichtlineare Funktion von ', und T
hängt von '0 ab.
Wir wollen den Einfluß der Nichtlinearität studieren. Um verschiedene Kurven
'(t) vergleichen zu können, skalieren wir ' mit '0 und t mit T . Außerdem be-
trachten wir im Phasenraumdiagramm '_ gegen ' für verschiedene Energien E .
Die Entstehung höherer harmonischer Schwingungen mit wachsender Nichtlinea-
rität wird durch eine Fouriertransformation sichtbar. Schließlich wollen wir T nach
der Größe sin2 '20 entwickeln, die ein Maß für die Nichtlinearität ist.

Algorithmus
Die Funktionen K (k ) und F ( ; k) stehen in Mathematica zur Verfügung und wer-
den aufgerufen als
EllipticK[k2] und EllipticF[ ,k2]
Man muß auf die Argumente achtgeben, weil es diesbezüglich leider mehrere ge-
bräuchliche Konventionen gibt. Es gilt also K (k ) = EllipticK[k2] und ent-
sprechend für die anderen elliptischen Integrale. Die Umlaufzeit erhält man nach
(1.7) einfach mit

p
T[phi0 ] = 4 EllipticK[Sin[phi0/2]ˆ 2]
wobei wir l=g = 1 gesetzt haben. Der Befehl Plot zeichnet die Umlaufzeit als
Funktion von '0 :
Plot[ T[phi0], fphi0, g
0, Pi , PlotRange –> f0,30g ]
Da T für '0 ! divergiert, sollte man PlotRange setzen und sich nicht daran
stören, daß Mathematica vor T ( ) warnt.
t(') erhält man mit EllipticF nach (1.6). Wir wollen jedoch die Umkehr-
funktion '(t) berechnen. Aber auch diese Funktionen sind vorhanden; es gilt (wie-
p
der mit l=g = 1)
psi[t_,phi0_]=JacobiAmplitude[t, Sin[phi0]ˆ2] bzw.
sinuspsi[t_,phi0_]=JacobiSN[t, Sin[phi0]ˆ2]
Nun ersetzen wir mit (1.5) die Variable durch ', skalieren ' mit '0 und t mit T
(wir definieren x = t=T ) und erhalten schließlich die skalierte Funktion
1.2 Nichtlineares Pendel 9

phiscal[x_,phi0_]:=
2 ArcSin[Sin[phi0/2] sinuspsi[x T[phi0],phi0]]/phi0

Die Funktion JacobiSN[t, Sin[phi0]ˆ2] hat überdies die richtige Symme-

trie, so daß sie nicht nur für 0
x 14 , sondern für alle x die Lösung liefert.
Die Funktion '(t=T )='0 wollen wir uns für verschiedene Anfangsausschläge '0
ansehen. Dazu erzeugen wir uns ein Feld von fünf '0 -Werten, phi0[1]=N[0.1
Pi], . . . , phi0[5]= N[0.999 Pi] und bilden eine Liste von Funktionen
fliste = Table[ phiscal[x,phi0[i]], i,5 ] f g
Diese Liste kann man nun mit Plot zeichnen, allerdings muß man zuvor den Befehl
Evaluate darauf anwenden.
Um die Entstehung höherer harmonischer Schwingungsanteile mit wachsender
Nichtlinearität '0 zu beobachten, soll '(t) in eine Fourierreihe entwickelt werden.
Am einfachsten geht dies mit dem eingebauten Fourier-Befehl; man muß sich
dazu allerdings eine Liste von diskreten Werten '(ti ); i = 1; : : : ; N , anlegen (siehe
nächsten Abschnitt). Die Beträge der komplexen Fourierkoeffizienten erhält man
dann als Liste
fouliste = Abs[ Fourier[liste] ]
Setzt man in Gleichung (1.1) die Energie konstant, so erhält man Kurven in der
(';_ ')-Ebene, dem sogenannten Phasenraum. Diese Kurven können in Mathemati-
ca verblüffend einfach gezeichnet werden: Man ruft ContourPlot für die Funkti-
on E ('; f
_ ') auf. Dabei kann man mit der Option Contours –> E1 , E2 , ...,
g
En n Höhenlinien mit verschiedenen Werten von E zeichnen lassen.
Zuletzt noch einige Bemerkungen zur Reihenentwicklung von T ('0 ). Im Prinzip
könnte Gleichung (1.7) einfach in eine Taylorreihe nach m = sin2 '20 mit Series
entwickelt werden. Mathematica schreibt dann allerdings nur formale Ableitungen
von EllipticK hin, und auch ein N[...] Befehl ändert dies nicht.
Man muß daher beim Integral (1.6) für = 2 beginnen. Der Integrand ist
f = 1/Sqrt[1 – m Sin[psi]ˆ2]
f kann man nach m entwickeln, z. B. bis zur 10-ten Ordnung in m um den Wert 0,
g = Series [f, {m,0,10}]
und dann jeden einzelnen Ausdruck mit Integrate über integrieren. Danach
wird m wieder mit /. m –> Sin[phi0/2]ˆ2 auf den Wert sin2 '20 gesetzt.
10 1 Mathematica-Funktionen

Ergebnisse
Wir haben untersucht, wie sich die Nichtlinearität, gemessen durch den Maximal-
ausschlag '0 , auf die Bewegung des Pendels auswirkt. Bild 1.1 zeigt die Umlauf-
zeit T als Funktion des Maximalausschlages '0 . Das Pendel braucht eine unendlich
10Pi

8Pi

6Pi
T
4Pi

2Pi

0
1.1 Periodendauer T als Funktion des
0 Pi/4 Pi/2 3Pi/4 Pi
phi0 Maximalausschlages '0 .

lange Zeit, um genau am oberen Umschlagpunkt ('0 = ) zum Stillstand zu kom-

men. Man sieht, daß T mit wachsendem '0 zunächst nur wenig von seinem Wert
T = 2 der harmonischen Schwingung abweicht, erst oberhalb der Auslenkung
von 90 = 2 wird T merklich größer.
Der Einfluß von '0 auf die Kurve '(t) wird in Bild 1.2 deutlich. '='0 ist ge-
gen t=T aufgetragen, um verschiedene Kurven miteinander vergleichen zu können

0.5
phi/phi0

-0.5 1.2 Skalierte Amplitude des

Pendels '(t=T )='0 für ver-
-1 schiedene Maximalausschläge
'0 = 1 4 19 999
10 ; 5 ; 20 ; 1000
0 0.2 0.4 0.6 0.8 1
t/T (von innen nach außen).

(man beachte: T divergiert für '0 !

). Für kleine '0 -Werte erhält man eine Si-
nusschwingung. Mit wachsendem '0 wird die Zeit an den oberen Umkehrpunkten
'0 immer größer; daher wird '(t) immer flacher, bis man für '0 = eine Stu-
fenfunktion erhält.
Zerlegt man '(t) in harmonische Schwingungen der Form bs ei!s t , so gilt wegen
der Periodizität '(t) = '(t + T ), daß die Frequenzen !s ganzzahlige Vielfache von
1.2 Nichtlineares Pendel 11

2 sind. Die in Mathematica vorhandene diskrete Fouriertransformation benutzt bei

T
N Datenpunkten f'(tr ); r = 1; : : : ; N g die Frequenzen f!s = 2T (s 1); s =
1; : : : ; N g und berechnet die Koeffizienten nach der Formel
X
N
bs = p1 '(t ) e2i(s 1)(r 1)=N :
N r=1 r
Wegen der Symmetrie '(t) = '( t) verschwinden für alle ungeraden s die Ko-
effizienten bs . Der erste nichtverschwindende, nämlich b2 , ist die Amplitude der
Grundschwingung !2 = 2T . Die weiteren Koeffizienten b4 ; b6 ; b8 ; : : : geben die
Amplituden der Oberschwingungen 3 !2 ; 5 !2 ; 7 !2 , . . . Der Ausdruck fouliste
enthält für '0 = 0:999 die Beträge der Koeffizienten bs , die in Bild 1.3 mit
ListPlot dargestellt sind.

6
Abs[b(s)]

0 1.3 Betrag der Fourierkoeffizienten der an-

harmonischen Schwingung '(t) für den Ma-
ximalausschlag '0 = 0:999 :
2 4 6 8 10 12 14
s

Das Wechselspiel zwischen Auslenkung ' und Winkelgeschwindigkeit '_ kann man
im Phasenraum ('; '_ ) deutlich machen; dabei wird die Zeit t eliminiert. Bild 1.4
zeigt solche Kurven im Phasenraum für verschiedene Energien E . Für kleine '0
3

1
phidot

-1

-2

-3 1.4 Phasenraum-Plot '_ gegen ' für verschiedene

-Pi -Pi/2 0 Pi/2 Pi
Energien mEg l = 12 , 0, 12 , 1, 32 und 2 (von innen
phi nach außen).

erhält man einen Kreis, der sich mit wachsender Energie verformt. Für E > mgl
12 1 Mathematica-Funktionen

schlägt das Pendel über, es bewegt sich nur noch in eine Richtung und hat eine
6
Winkelgeschwindigkeit '_ = 0 auch am oberen Umschlagpunkt.
Mit dem Befehl
tseries = 4 Integrate[g,{psi,0,Pi/2}] /. m –> Sin[phi0/2]ˆ2
erhält man die symbolische Entwicklung von T nach sin2 ('0 =2). Mathematica pro-
duziert die folgende etwas unübersichtliche Bildschirmausgabe:
phi0 2 phi0 4 phi0 6
Pi Sin[––––] 9 Pi Sin[––––] 25 Pi Sin[––––]
2 2 2
2 Pi + ––––––––––––– + ––––––––––––––– + –––––––––––––––– +
2 32 128

phi0 8 phi0 10 phi0 12

1225 Pi Sin[––––] 3969 Pi Sin[––––] 53361 Pi Sin[––––]
2 2 2
> –––––––––––––––––– + ––––––––––––––––––– + –––––––––––––––––––– +
8192 32768 524288

phi0 14 phi0 16
184041 Pi Sin[––––] 41409225 Pi Sin[––––]
2 2
> ––––––––––––––––––––– + ––––––––––––––––––––––– +
2097152 536870912

phi0 18 phi0 20
147744025 Pi Sin[––––] 2133423721 Pi Sin[––––]
2 2 phi0 2 11
> –––––––––––––––––––––––– + ––––––––––––––––––––––––– + O[Sin[––––] ]
2147483648 34359738368 2

Wir werden deshalb in Zukunft bei solchen Ergebnissen die entsprechende TEX–
Form angeben, die man sich übrigens mit dem Befehl TeXForm von Mathematica
erzeugen und mit TEX oder LATEX übersetzen lassen kann:

sin2 '2
0
9 sin4 '2 25 sin6 '2 1225 sin8 '2
0 0 0

2 + 2 + 32 + 128 + 8192 +
3969 sin10 ' 53361 sin12 '2 184041 sin14 '2
0 0 0

+ 32768 2 + 524288 + 2097152

41409225 sin16 ' 147744025 sin18 '2
0 0

+ 536870912 2 + 2147483648
2133423721 sin20 '2
+ O(sin2 '20 ) :
0 11
+ 34359738368
1.3 Fouriertransformation 13

Ein Vergleich mit dem exakten T ('0 ) zeigt, daß der Fehler dieser Näherungslösung
höchstens im Prozentbereich liegt, solange '0 kleiner als 120 ist, dann aber deut-
lich ansteigt.

Übung

a) Berechnen Sie die Umlaufzeit T als Funktion von '0 einmal mit EllipticK
und zum anderen mit NIntegrate und vergleichen Sie die Rechenzeiten und
die Genauigkeiten.

b) Welchen Anteil haben die Oberschwingungen in '(t) als Funktion der maxima-
b
len Auslenkung '0 ( = wachsender Nichtlinearität )? Berechnen Sie die Fourier-
j jj j
koeffizienten bs = b2 als Funktion von '0 .

c) Programmieren Sie folgenden Algorithmus für das vollständige elliptische Inte-

gral K (sin ) und vergleichen Sie das Ergebnis mit EllipticK[sin2 ]:

Start: a0 = 1 ; b0 = cos ;
p
Iteration: ai+1 = 2 (ai + bi ) ; bi+1 = ai bi ;
1
Stop: ja n bn < " ; j
Prüfe: EllipticK[sin2 ] ' 2a .
n

Literatur
G. Baumann, Mathematica in der Theoretischen Physik, Springer Verlag, 1993.
R. E. Crandall, Mathematica for the Sciences, Addison Wesley, 1991.

1.3 Fouriertransformation
Erstaunlich oft kann man physikalische Probleme in guter Näherung durch lineare
Gleichungen beschreiben. In solchen Fällen steht dem Forscher ein mächtiges Werk-
zeug zur Verfügung: die Zerlegung eines Signals in eine Summe von harmonischen
Schwingungen. Dieses Werkzeug, das mathematisch gut erforscht ist, wird Fou-
riertransformation genannt. Mit komplexwertigen Funktionen kann man die Trans-
formation besonders kompakt formulieren. Fast jedes Signal, selbst ein unstetiges,
kann als Grenzwert einer Summe von stetigen Schwingungen dargestellt werden.
Eine wichtige Anwendung der Fouriertransformation ist die Lösung linearer Diffe-
rentialgleichungen. Nicht nur in der Physik, sondern auch in der Bildverarbeitung,
14 1 Mathematica-Funktionen

der Signalübertragung, der Elektronik und in vielen anderen Gebieten spielt die Zer-
legung einer Funktion in einfache Schwingungen eine große Rolle.
Häufig stehen Daten nur zu diskreten Zeit- oder Raumpunkten zur Verfügung. In
diesem Fall sind die numerischen Algorithmen der Fouriertransformation besonders
schnell. Wegen dieses Vorteils wollen wir hier die Fouriertransformation diskreter
Daten untersuchen. In den folgenden Abschnitten werden wir sie zur Glättung von
Daten, zur Berechnung elektrischer Schaltkreise und zur Analyse von Gitterschwin-
gungen benutzen.

Mathematik
Es sei ar ; r = 1; : : : ; N , eine Folge komplexer Zahlen. Dann ist deren Fourier-
transformierte die Folge bs ; s = 1; : : : ; N , mit

X
N
bs = p1 ar e2i(r 1)(s 1)=N : (1.8)
N r=1
Diese Formel hat den Vorteil, fast symmetrisch in ar und bs zu sein, denn die inverse
Transformation ist

X
N
ar = p1 bs e 2i(r 1)(s 1)=N : (1.9)
N s=1
Das Signal fa1; ::: ; aN g ist also in eine Summe von Schwingungen
cs (r) = pbs e i!s (r 1) (1.10)
N
mit den Frequenzen !s = 2 (s 1)=N zerlegt worden. bs = jbs jei's enthält
eine Amplitude und eine Phase. Beide Gleichungen (1.8) und (1.9) können auf alle
ganzen Zahlen r und s erweitert werden. Wegen exp(2ik ) = 1 für k Z sind 2
dann ar und bs periodisch in r bzw. s mit der Periode N :

ar = ar+k N ; bs = bs+k N ; (1.11)

so daß man in jeder Summe den Index r oder s über jedes Intervall der Länge N
laufen lassen kann. Die kleinste Frequenz der Schwingungen ist !2 = 2=N (= b
Wellenlänge“ N ), und alle anderen Frequenzen sind ganzzahlige Vielfache von
!2 . Die größte Frequenz ist !N = 2 NN 1 , denn cN +1 (r) hat wegen bN +1 = b1
”
dieselben Funktionswerte wie c1 (r ).
1.3 Fouriertransformation 15

Wenn alle Signalwerte ar reell sind, haben deren Fourierkoeffizienten bs die fol-
gende Symmetrie:
X
N
bs = p1 ar e 2i(r 1)(s 1)=N
N r=1
XN
= p1 ar e2i(r 1)( s+2 1)=N =b s+2 :
N r=1
Dabei bedeutet b das konjugiert Komplexe von b. Daraus folgt
bs = b s+2 = bN s+2 ; (1.12)
also sind nur die Werte b1 ; :::; bN=2+1 relevant, bN=2+2 bis bN sind redundant.
Eine nützliche Eigenschaft der Fouriertransformierten ergibt sich bei der Faltung
f g f g
zweier Folgen fr und gr . Bei dieser Operation werden die Folgenelemente fr
aufsummiert und dabei mit den gj gewichtet. Man kann dies als lokale Mittelung
interpretieren und auf diese Weise z. B. den Einfluß von Meßfehlern mathematisch
behandeln. Die Faltung ist folgendermaßen definiert:
X
N
hr = fr+1 j gj : (1.13)
j =1
~ s ; g~s und f~s . Fügt man
Die entsprechenden Fouriertransformierten seien die Folgen h
die Fourierentwicklungen
X
N
h~ s = p1 hr e2i(r 1)(s 1)=N ;
N r=1
X
N
gj = p1 g~ e 2i(m 1)(j 1)=N ;
N m=1 m
X
N
fr+1 j = p1 ~ fn e 2i(n 1)(r j )=N
N n=1
nach Gleichung (1.13) zusammen, ergibt sich
3 X
h~ = 1
s p g~ f~ e 2Ni [(r 1)(s 1) (m 1)(j 1) (n 1)(r j)] :
N r;j;m;n m n
Die Summen über r und j lassen sich mit
X
N
e2i lq=N = N q;kN ; k 2 Z ;
l=1
16 1 Mathematica-Funktionen

ausführen, und es verbleibt

p X p
h~ s = N g~m f~n e Ni (m
2
s)
s n;0 n m;0 = N g~s f~s : (1.14)
m;n
Die Faltung wird also nach der Transformation zum einfachen Produkt. Die Rück-
transformation gibt dann die gefaltete Funktion

X
N
hr = g~s f~s e 2i(s 1)(r 1)=N : (1.15)
s=1
Wir werden die Faltung im nächsten Abschnitt zur Glättung von Meßdaten benut-
zen.

Algorithmus
In Mathematica erhält man eine Liste der Fourierkoeffizienten b1 , f : : :, g
bN mit
Fourier[ a1 , f : : :, aN ]g
und deren Inverses mit
InverseFourier[ b1, f : : :, g
bN ]
Trotzdem ist es vielleicht interessant, sich einmal den Algorithmus der schnellen
Fouriertransformation (Fast Fourier Transform = FFT) anzuschauen. Um alle Fol-
genglieder bs aus Gleichung (1.8) zu berechnen, kann man sich vorstellen, daß eine
Matrix der Form
W (N ) = 1 e2i(r 1)(s 1)=N
s;r p
N
a
mit einem Vektor = (a1 ; :::; aN ) multipliziert wird; dies erfordert N 2 Rechen-
schritte. Die FFT kann dies aber in einer Anzahl von Schritten berechnen, die nur
wie N log N anwächst. Dazu wird die Summe (1.8) in ungerade und gerade r -Werte
aufgespalten:

X
N=2 X
N=2
bs (N ) = Ws;2t 1(N ) a2t 1 + Ws;2t (N ) a2t
t=1 t=1
X
N=2 X
N=2
= p1 Ws;t(N=2) a2t 1 + e2i(s 1)=N p1 Ws;t(N=2) a2t
t=1 2 t=1 2
= p1 bus (N=2) + e2i(s 1)=N bg (N=2) :
s (1.16)
2
1.3 Fouriertransformation 17

f
Dabei sind bus (N=2) und bgs (N=2) die Fouriertransformierten der Koeffizienten a1 ;
g f g
a3; : : : ; aN 1 bzw. a2 ; a4 ; : : : ; aN , zweier Folgen also mit N=2 Gliedern (g
und u stehen für gerade und ungerade). Wiederholt man die Aufspaltung für je-
den der beiden Teile, so erhält man buu s ; bs ; bs und bs . Diesen Prozeß wiederholt
ug gu gg
man solange, bis noch jeweils ein ar -Wert übrig bleibt, der dann irgendeinem Wert,
z. B. bgugguguu
s entspricht; die letzte Zuordnung kann angegeben werden. Mit ei-
nigen zusätzlichen Buchhaltungstricks läßt sich damit ein schneller Algorithmus
programmieren.
Weil dieser Algorithmus nur dann optimal funktioniert, wenn N eine Potenz von
2 ist, gehen wir im folgenden davon aus, daß N von der Form N = 2j ist. Was die
Anzahl F (N ) der Rechenschritte betrifft, die benötigt wird, um die Fouriertransfor-
mation einer N -gliedrigen Folge zu berechnen, so liest man von Gleichung (1.16)
die folgende Rekursionsbeziehung ab:

F (N ) = 2 F (N=2) + k N : (1.17)

Der Term 2 F (N=2) ist unmittelbar klar wegen bus (N=2) und bgs (N=2). Der Index
s in Gleichung (1.16) läuft von 1 bis N , wobei anzumerken ist, daß wegen der
Periodizität mit N=2 die Werte von bus (N=2) und bgs (N=2) dabei zweimal durch-
laufen werden. Ein zu N proportionaler Anteil kommt hinzu, weil N Phasenfak-
toren e2i(s 1)=N zu berechnen sind und außerdem N Multiplikationen und Ad-
f g
ditionen auszuführen sind. Auch das Sortieren der ar in gerade und ungerade
kann man hier unterbringen. Es ist eine leichte Übung zu zeigen, daß F (N ) =
N [F (1) + k log2 N ] die Lösung der Rekursionsgleichung (1.17) ist, mit F (1) =
0 als Startwert also F (N ) = k N log2 N .

Anwendung
Als Beispiel wollen wir uns die Fouriertransformation eines Rechteckimpulses der
Breite 2 anschauen,

f (t) = 21 (sign( + t) + sign( t)) : (1.18)

Die Funktion f sei zunächst im Intervall [ T2 ; T2 ] mit T2 > definiert und soll
periodisch mit der Periode T fortgesetzt werden. Deren Fourierentwicklung lautet

X
1
f (t ) = f~n ein!t (1.19)
n= 1
18 1 Mathematica-Funktionen

mit ! = 2T , wobei die f~n durch Integrale über f (t) bestimmt werden:
ZT=2
f~n = T1 f (t ) e in!t dt : (1.20)
T=2
Dieses Integral läßt sich für den Rechteckimpuls leicht ausführen, mit dem Ergebnis

n! ) :
f~n = T2 sin(n! (1.21)

Je nach Länge der Periode wird die Funktion sin(x)=x an verschiedenen Punkten
2n=T berücksichtigt, und die Koeffizienten f~n verschwinden, wenn 2n=T eine
ganze Zahl ist.
Nun tasten wir f (t) innerhalb einer Periode an N diskreten Werten tr = T=2+
f
r T=N ab, wenden Fourier auf die Folge der Zahlen ar = f (tr ) Nr=1 an und g
f g
erhalten deren Fouriertransformierte b1 ; b2 ; : : : ; bN . Wir wollen den Zusammen-
hang zwischen den exakten Fourierkoeffizienten f~n und den bs aus der diskreten
Fouriertransformation klären. Dazu ersetzen wir in Gleichung (1.8) die Funktions-
werte ar = f (tr ) durch die unendliche Fourierreihe (1.19) mit ! = 2T . Die r -
Summation ergibt Kronecker-Deltas, und für gerades N erhalten wir die folgende

X
Beziehung:
1
pbs = ei (N 2)(s 1)=N f~1 s+k N : (1.22)
N k= 1
Der Vergleich der Beträge liefert also:

X
1
pjbs j = f~1 s+k N : (1.23)
N k= 1
p
Weil f~n
j pj! 0 geht für n ! 1p j j
, ist bs = N f~1 s für s = 1; 2; : : : ; N2 .
j j
Ob bs = N < f~1 s oder bs = N > f~1 s gilt, wie sich also das sogenann-
j j j j j j j j
te aliasing auswirkt, läßt sich nicht generell beantworten. Es hängt von der Pha-
senbeziehung zwischen f~1 s und im wesentlichen f~1 sN ab. Gerade in dem hier
betrachteten Fall kann man durch Variation des Parameters =T in (1.18) sowohl
den einen als auch den anderen Fall realisieren. Bild 1.5 zeigt für N = 64 und
=T = 1=10 den Betrag von f~1 s als durchgezogene Linie und die Beträge der
p
bs = N als Punkte.
Die Rücktransformation von den bs -Koeffizienten zu den ursprünglichen Werten

ar = f (tr ) erfolgt mit Gleichung (1.9) und r = N tTr + 21 . Diese Gleichung gibt
die exakten Werte des Rechteckimpulses an den diskreten Stellen tr . Sie kann aber
1.3 Fouriertransformation 19

0.2

0.15

0.1
1.5 Kontinuierliche und dis-
krete Fouriertransformation
0.05 eines Rechteckimpulses.
Die durchgezogene Linie ist
0 jf~1 s als Funktion von s,
j
5 10 15 20 25 30 die Punkte sind die Werte
s j j 1
von bs N 2 :

auch als Näherung für die gesamte Funktion f (t) aufgefaßt werden, wenn tr durch
kontinuierliche t-Werte ersetzt wird. Bild 1.6 zeigt, daß dies kein gutes Ergebnis
liefert. Der Grund für die schlechte Qualität der Näherung ist der stark oszillatori-
sche Beitrag der hohen Frequenzen für s zwischen N=2 und N . Im mathematischen
Teil (1.11) wurde gezeigt, daß man die Summe über jedes beliebige Intervall der

1.25
1
1
0.8
0.75
0.5 0.6

0.25 0.4
0 0.2
-0.25 0
-0.5
-4 -2 0 2 4 -4 -2 0 2 4
1.6 Links die ungünstige und rechts die bessere Fortsetzung der diskreten Fourier-Rück-
transformation auf kontinuierliche t-Werte.

Länge N laufen lassen kann. Diese Freiheit nutzen wir, indem wir das Intervall
symmetrisch zum Ursprung legen und nur die kleinsten Frequenzen verwenden:

X
N=2
f (tr ) = p1 bs e 2i(r 1)(s 1)=N
N s= N=2+1
X
N=2
= p1 bs e 2i(r 1)(s 1)=N +
N s=1
20 1 Mathematica-Funktionen

X
N=2
+ p1 bs0 N=2 e
2i(r 1)(s0 N=2 1)=N
N s0=1
X
N=2
= p1 bs e 2i(r 1)(s 1)=N
N s=1
X
N=2
+ p1 bN=2 s0 +2 e
2i(r 1)(s0 N=2 1)=N :
N s0=1
Wird diese Version auf kontinuierliche t-Werte erweitert, so sieht man in Bild 1.6,
daß die Stufe wesentlich besser approximiert wird. Allerdings können die Sprung-
stellen des Rechteckimpulses f (t) nur durch starke Oszillationen auf beiden Seiten
dargestellt werden.

Übung

1. Spitzenspannung
Eine zeitabhängige Spannung wird an N = 64 diskreten Zeitpunkten abgeta-
stet und liefert die Werte U1 ; : : : ; UN . Die Fouriertransformierte davon sei die
f g j j
Folge b1 ; : : : ; bN mit dem Leistungsspektrum bs 2 = bN s+2 2 = 1 fürj j
f
s = 9; 10; : : : ; 17 und bs = 0 sonst. Damit das Spannungssignal U1; : : : ; UN g
reell ist, muß bN s+2 = bs gelten.

f g
a) Wie sieht das Spannungssignal U1 ; : : : ; UN aus, wenn die Fourierkoeffizi-
enten bs konstante Phasen haben, z. B. bs = 1; falls bs = 0 ? 6
b) Wählen Sie für die von Null verschiedenen bs zufällige Phasen, also bs = ei's
mit zufälligen 's . Wie sieht das Signal jetzt aus?
c) Wettbewerb: Gesucht sind die Phasen 's möglichst geringer Spitzenspan-
j j
nung, also min max Ur .
f's g r

2. Aperiodischer Kristall
Gegeben sei eine Kette von Atomen mit periodischer Anordnung

1 1 0 0 1 1 0 0 1 1 0 0 1 1 0 0:
Mit Röntgenstreuung erhält man den Betrag der Fourierkoeffizienten jbs j der
Funktion ar mit
1.4 Daten glätten 21

1 1 am Ort r
ar = 0
Atom
sonst

a) Zeichnen Sie das Fourierspektrum bs .

b) Erzeugen Sie nun eine zufällige Folge von 1 und 0 und zeichnen Sie deren
Fourierspektrum.
c) Erzeugen Sie mit folgendem Algorithmus einen aperiodischen Kristall und
vergleichen Sie sein Fourierspektrum mit den beiden anderen Kristallen.
1. Starten Sie mit: 0
1
10
2. Erzeugen Sie die nächste Zeile, indem Sie die vorletzte an die letzte anhän-
gen.
3. Iterieren Sie dies bis zur gewünschten Länge.
Die Zahl der Atome in der n-ten Zeile ist die Fibonacci-Zahl Fn .

Literatur
R. E. Crandall, Mathematica for the Sciences, Addison Wesley, 1991.
W.H. Press, S.A. Teukolsky, W.T. Vetterling, B.P. Flannery, Numerical Recipes in
C: The Art of Scientific Computing, Cambridge University Press, 1992.
Paul L. DeVries, Computerphysik: Grundlagen, Methoden, Übungen, Spektrum
Akademischer Verlag, 1995.
Stephen Wolfram, Mathematica: A System for Doing Mathematics by Computer,
Addison Wesley, 1991.

1.4 Daten glätten

Experimentelle Daten sind meistens mit einem deutlichen statistischen Fehler be-
haftet. Die Streuung der Meßwerte kann man bis zu einem gewissen Grad besei-
tigen, indem man über benachbarte Daten mittelt. Besonders bei der graphischen
Aufbereitung von Daten ist eine solche Glättung nützlich. Hier wollen wir das Ver-
fahren an Daten mit einer künstlich erzeugten Streuung demonstrieren. Diese Daten
werden geglättet, indem an jedem Punkt die Nachbarpunkte je nach Abstand ge-
wichtet und aufsummiert werden. Damit dabei keine neuen Strukturen entstehen,
22 1 Mathematica-Funktionen

wird als Gewicht eine Gaußglocke“ verwendet. Die Daten werden also mit einer
”
Gaußfunktion gefaltet, eine Glättungsoperation, bei der die Fouriertransformation
aus dem vorigen Abschnitt verwendet werden kann.

Physik
Es sei f (t) eine physikalische Größe, die an diskreten Zeitpunkten ti gemessen
wird. Die exakten Werte fi = f (ti ) sollen mit Zufallszahlen ri überlagert sein, so
daß die Meßdaten durch

gi = fi + ri ; i = 1; 2; 3; :::; N ; (1.24)

gegeben sind. Zu jedem i wollen wir neue Werte g i berechnen, die den Mittelwert
über eine Nachbarschaft von i bilden. Die Folge der g i ist dann viel glatter als
diejenige der gi -Werte und verdeutlicht besser die ursprüngliche Funktion f (t).
Zur Berechnung von g i könnte man nun einfach die gj -Werte in einem Inter-
vall um i aufsummieren. Aber es gibt eine bessere Methode, die keine zusätzlichen
unerwünschten Strukturen erzeugt. Dabei wird ein gewichtetes Mittel benutzt, das
j j
Nachbarn entsprechend ihrem Abstand j i vom Platz i berücksichtigt. Weit ent-
fernte Nachbarn werden nur schwach gewichtet. Als Gewichtsfunktion, auch Kern
genannt, wird eine Gaußglocke“ verwendet. Sei also kj eine solche Gewichtsfunk-
tion, die wie vorher auf die Werte j = 1; ::; N beschränkt wird. Die kj -Werte für
”
j < 1 werden durch die Symmetrie (1.11) ausgedrückt. Der Kern muß natürlich
X
normiert sein:
N
kj = 1 : (1.25)
j =1
Dann wird g r folgendermaßen konstruiert:

X
N
gr = gr j +1 kj ; (1.26)
j =1
g ist also die diskrete Faltung der Funktionen g und k, die schon in Abschnitt 1.3
besprochen wurde. Daher läßt sie sich einfach als Fouriertransformation darstellen,

X
N
gr = g~s k~s e 2i(s 1)(r 1)=N ; (1.27)
s=1
~ die Fouriertransformierten von g und k sind.
wobei g~ und k
1.4 Daten glätten 23

Algorithmus
Die Daten, die wir glätten wollen, erzeugen wir mit Mathematica als Liste data,
und zwar als Werte der Besselfunktion J1 (x), die durch Zufallszahlen verrauscht
wurden:

data=
Table[N[BesselJ[1,x]+0.2(Random[]–1/2)],{x,0,10,10/255}]

Für den Kern wählen wir eine Gaußkurve der Breite .

kern = Table[N[Exp[–xˆ2/(2*sigmaˆ2)]], {x,–5,5,10/255}]

Allerdings stehen jetzt die größten Funktionswerte in der Mitte der Liste kern. Wir
müssen deshalb diese Liste zyklisch rotieren, so daß das Maximum an den Beginn
der Liste, also nach kern[[1]] verschoben wird. Dies geschieht mit dem Befehl
kern = RotateLeft[kern,127]
Nach (1.25) muß dieser Kern noch normiert werden:
kern = kern/Apply[Plus, kern]
Die geglätteten Daten (1.27) erhält man dann mit (1.14) ganz einfach durch den
Ausdruck
Sqrt[256] InverseFourier[Fourier[data] Fourier[kern]]
Das Produkt zweier Listen gibt dabei die Liste der Produkte der Elemente, ganz wie
Gleichung (1.27) verlangt.

Ergebnisse
Bild 1.7 zeigt das Ergebnis der Rechnungen für = 0:4 . Die geglätteten Daten
werden mit den verrauschten Daten und mit der ursprünglichen Funktion vergli-
chen. Die Kurve g i ist tatsächlich glatt und hat eine etwas kleinere Amplitude als
die Originalkurve. Das muß natürlich so sein, da die geglättete Kurve über die Nach-
barschaft mittelt und damit immer kleiner als die Maximalwerte der Daten ist. Ins-
besondere die bei Anwendung der Fouriertransformation stillschweigend vorausge-
setzte Periodizität der Daten führt hier zu einer Verfälschung an den Rändern.
Wir möchten erwähnen, daß genau dieses Beispiel im Abschnitt 3.8.3 des Mathe-
p
matica-Handbuches vorgeführt wird. Allerdings werden dort gleich mehrere Fehler
gemacht: Der Kern wird nicht normiert, der Faktor N wird bei der Faltung verges-
sen und als Kern wird nur die rechte Hälfte der Gaußglocke“ genommen. Während
”
24 1 Mathematica-Funktionen

0.6

0.4

0.2

0
1.7 Ausgangsfunktion (dünne
-0.2 Linie) und verrauschte Da-
ten (Punkte). Die Punkte der
-0.4 geglätteten Daten erscheinen
0 2 4 6 8 10 als fette Linie.

sich die ersten beiden Fehler bei den gewählten Parametern gerade aufheben, ver-
schiebt der dritte die geglättete Kurve etwas nach rechts zu größeren x-Werten hin.
Abschließend wollen wir noch darauf hinweisen, daß man bei der Mittelung vor-
sichtig sein muß. Wählt man die Breite des Kerns zu klein, dann erhält man of-
fenbar die ursprünglichen Daten ohne Glättung. Läßt man dagegen eine zu breite
Gewichtsfunktion zu, dann wird nicht nur die Streuung weggemittelt, sondern es
werden auch kurzwellige Strukturen in der ungestörten Funktion zerstört. Im Ex-
tremfall eines unendlich breiten Kerns besteht die geglättete Funktion nur aus einer
einzigen Konstanten. Die Breite der Gewichtsfunktion muß daher sorgfältig an die
zu glättenden Daten angepaßt werden.
Falls die Statistik der Streuung bekannt ist, so gibt es theoretische Ansätze, mit
denen man den optimalen Kern berechnen kann. Alternativ kann man auch eine
möglichst glatte Kurve durch die Daten legen, die den korrekten Wert von 2 hat
(siehe nächsten Abschnitt). Zum Beispiel kann man durch benachbarte Stützpunkte
Polynome legen und minimale Krümmungen fordern. Dieses umfangreiche Gebiet
der statistischen Analyse von Daten können wir hier nicht behandeln, sondern wir
müssen auf die entsprechenden Lehrbücher verweisen.

Übung
Das Ergebnis des oben vorgestellten Algorithmus zum Datenglätten hängt von der
gewählten Breite des Kerns ab. Berechnen sie die geglätteten Daten für einen
großen Bereich von -Werten. Wenn die Breite des Kerns kleiner als der Abstand
der Datenpunkte ist, erhält man fast die ursprünglichen Daten. Wenn dagegen die
Breite größer als das ganze x-Intervall ist, sind die geglätteten Punkte fast konstant.
Bestimmen sie einen -Wert, der Ihnen geeignet erscheint.
1.5 Nichtlinearer Fit 25

Literatur
W.H. Press, S.A. Teukolsky, W.T. Vetterling, B.P. Flannery, Numerical Recipes in
C: The Art of Scientific Computing, Cambridge University Press, 1992.
Stephen Wolfram, Mathematica: A System for Doing Mathematics by Computer,
Addison Wesley, 1991.

1.5 Nichtlinearer Fit

Ein Ziel der Naturwissenschaft ist es, mathematische Gesetzmäßigkeiten in gemes-
senen Daten zu finden. Deshalb werden häufig Modellfunktionen mit freien Para-
metern an die Daten angepaßt. Die Modelle entstehen – hoffentlich – aus Theorien,
und der Computer wird benötigt, um die besten“ Parameter zu finden und ein Maß
”
für die Güte des Fits anzugeben. Dem Wissenschaftler stehen dazu umfangreiche
Werkzeuge aus der mathematischen Statistik zur Verfügung mit ebenso umfangrei-
chen Programmpaketen.
Gehen die Parameter linear in die Modelle ein, so ist die mathematische Theorie
dazu besonders gut entwickelt. Allerdings sind die Modelle der Physiker oft kom-
plexer, so daß häufig ein nichtlinearer Fit benötigt wird. Hier soll an einem einfachen
Beispiel das Prinzip der nichtlinearen Parametersuche erläutert werden. Wir wer-
den dabei die Qualität eines Fits mit dem 2 -Test abschätzen, wobei wir selbst ein
Maß für unser Vertrauen setzen müssen. Niemals werden wir beweisen können, daß
unser Modell die Wirklichkeit wiedergibt; aber wir werden damit falsche Model-
le mit großer Wahrscheinlichkeit ausschließen können. Für ein akzeptiertes Modell
können wir auch ein Maß für die Genauigkeit der verwendeten Parameter angeben.
Am Beispiel einer gedämpften Schwingung, die an nur elf Zeitpunkten gemes-
sen wird und deren Daten stark verrauscht werden, passen wir ein Modell mit vier
Parametern an die Daten an und bestimmen deren Fehler.

Theorie
f g a
Es seien N Datenpaare Yi ; ti gegeben, an die eine Modellfunktion g ( ; ti ) mit
a
unbekanntem Parametervektor mit M Komponenten angepaßt werden soll. Da-
bei soll bekannt sein, daß zu jedem ti die Daten Yi mit einem Fehler "i gemessen
werden, der im Mittel über viele Experimente verschwindet und eine Varianz i2
h i h i a
hat, also "i = 0 und "2i = i2 . Als besten“ Parametersatz definiert man
a
diejenigen Werte 0 , die die quadratische Abweichung 2 minimieren, wobei 2
”
26 1 Mathematica-Funktionen

wie folgt definiert ist:

N
2 (a) =
X Yi g(a; ti ) 2 :
i=1 i (1.28)

a
Wenn g ( 0 ; ti ) ein angemessenes Modell ist und wenn die Fehler "i = Yi
a
g( 0 ; ti) unkorreliert und gaußverteilt sind, dann ist die Verteilung von 2 ( 0 ) be- a
kannt. Wie man durch häufige Wiederholung des Experiments überprüfen könnte,
ist die Wahrscheinlichkeit dafür, daß 2 kleiner ist als 20 , durch

1 Z
20 =2
PN M (0 ) =
2
N M e t tN 2
M 1 dt (1.29)
2 0

gegeben. Das Integral ist in der mathematischen Literatur als unvollständige Gam-
a
mafunktion ((N M )=2 ; 20 =2) bekannt. 2 ( 0 ) hat nur N M unabhängige
Variable, da M Freiheitsgrade durch die Minimumbedingung fixiert sind. Für große
Werte von N M gilt der zentrale Grenzwertsatz: 2 ist gaußverteilt mit Mittelwert
h i
2 = N M und Varianz 2(N M ).
Was bedeutet nun die 2 -Verteilung (1.29) für die Genauigkeit des Fits? Neh-
a
men wir an, unser Experiment gibt den Wert 20 = 2 ( 0 ) für das Minimum von
Gleichung (1.28). Ferner sei der Wert P (20 ) = 0:99. Das heißt, wenn das Modell
richtig ist, würde in 99% aller Experimente der Wert 2 kleiner als 20 sein. Das
könnten wir noch als gültigen Fit akzeptieren, denn wir können nicht ausschließen,
daß unser Experiment zu den 1% der Fälle gehört, bei denen 2 größer als 20 ist.
Wäre aber P = 0:9999, dann wäre unser Fit nur dann richtig, wenn er zu den
0:01% der Experimente mit 2 > 20 gehören würde. In diesem Fall würde man
sicher schließen, daß 20 viel zu groß ist und daß deshalb unsere Voraussetzungen,
insbesondere unser Modell, nicht richtig sind. Andererseits darf der Wert von 20
nicht zu klein sein, denn unsere Daten haben einen statistischen Fehler. Die Wahr-
scheinlichkeit, daß ein Experiment einen kleineren Wert als unser 20 hat, ist wieder
durch die Verteilung (1.29) gegeben. Das Intervall für den Wert von 20 , den wir
akzeptieren wollen, nennt man Vertrauensintervall. Wo wir die Schranke setzen,
bei 1% oder bei 0:01%, hängt von uns selbst und unserer Erfahrung mit ähnlichen
Problemen ab.
Nehmen wir nun an, daß wir mit der Qualität unseres Fits zufrieden sind, d.h.
a a
2 ( ) hat ein Minimum bei den Parametern 0 , und der Wert von 2( 0) liegt a
in unserem Vertrauensintervall. Könnten wir das Experiment mehrmals wiederho-
len, so würden wir selbstverständlich andere Meßfehler "i und damit einen anderen
a
Parametervektor 0 erhalten. Wir machen aber nur ein Experiment und wollen den-
a
noch aus den Daten den Fehler von 0 abschätzen.
1.5 Nichtlinearer Fit 27

Hierbei hilft uns wieder die 2 -Verteilung (1.29), denn Konturen im M -dimen-
a a
sionalen -Raum mit konstantem Wert von 2 ( ) sind ein Maß für den Fehler von
a 0 . Bei kleinen Abweichungen ja a j0 sind diese Konturen Ellipsoide mit M
a
Hauptachsen, deren Länge ein Maß dafür ist, wie weit man 0 in dieser Richtung
ändern kann, bis der Fit nicht mehr akzeptabel ist.
Diese Aussage kann man sogar quantifizieren. Dazu erzeugen wir uns künstli-
a
che Daten Yi , indem wir zum Modell g ( 0 ; ti ) einen gaußverteilten Fehler "i mit
h i a
"2i = i2 addieren: Yi = g( 0; ti ) + "i. Mit diesen Daten lassen wir wiederum die
Fitprozedur laufen, suchen also mit den simulierten Daten erneut ein Minimum 1 a
a a a
von 2 ( ). Mehrmals wiederholt liefert dies die Parametervektoren 1 ; 2 ; : : :, und
a
aus der Breite der Verteilung der Komponenten der k gewinnen wir Fehlerbalken
a
für die Fitparameter 0 .
Falls die Abweichung ja a j a
0 so klein ist, daß man die Entwicklung von ( )
2
a
(aus den experimentellen Daten) um 0 nach den quadratischen Gliedern abbre-
a a
chen kann, so läßt sich zeigen, daß die Größe = 2 ( ) 2 ( 0 ) wieder mit
der Verteilungsfunktion P aus (1.29) verteilt ist, in diesem Fall mit M statt mit
N M Freiheitsgraden. Fordern wir daher wie vorher, daß unser Fit zu den 99%
aller möglichen Fits beim korrekten Modell gehören soll, dann bestimmt die Un-
gleichung
a
PM (2 ( ) 2( 0)) 0:99a (1.30)
a
ein Gebiet mit erlaubten Werten von . Im Parameterraum sind die Gebiete mit
konstantem Ellipsoide. Die Projektion dieser (M 1)-dimensionalen Fläche auf
die Achse i gibt dann das Fehlerintervall für den Parameter ai .

Algorithmus
Auch beim nichtlinearen Fit ist es am einfachsten, die vorhandenen Mathematica-
a
Funktionen zu nutzen. Zum Auffinden des Minimums von 2 ( ) verwenden wir
die Funktion NonlinearFit im Paket Statistics’NonlinearFit’. Es
gibt dort verschiedene Möglichkeiten, Daten und Startbedingungen einzugeben, au-
ßerdem kann man die Methode der Minimumsuche ändern und sich die Zwischen-
a
ergebnisse anzeigen lassen. Natürlich kann man auch 2 ( ) selbst definieren und
mit FindMinimum den Wert 0 finden.a
Zur Erzeugung der Daten und als Modell wählen wir eine gedämpfte Sinus-
schwingung
f[t ]:= a Sin[om t + phi] Exp[–b t]
a f g
mit 4 Parametern = a, om, phi, b . Diese Schwingung wird für den Pa-
a f g
rametersatz = 1,1,0,0.1 an 11 Zeitpunkten ti gemessen, und die Daten
werden durch gleichverteilte Zufallszahlen verrauscht:
28 1 Mathematica-Funktionen

daten =
Table[{t,Sin[t]Exp[–t/10.]+0.4*Random[]–0.2}//N,
{t,0,3Pi,0.3Pi}]
Für die (nicht gaußverteilten) Fehler "i gilt

1 Z0:2 2 :
h"i i = 0; 2
i = h" 2 i =
i 0:4 x2 dx = 150
0:2
Die Suche nach dem Minimum wird erleichtert, wenn wir einen ungefähren Wert
a
von 0 angeben können. Nach dem Laden der benötigten Statistik-Pakete mit
Needs["Statistics’Master’"]
rufen wir die Minimumsuche auf:
NonlinearFit[daten,f[t],t,
{{a,1.1},{om,1.1},{phi,.1},{b,.2}},
ShowProgress–>True]
Auch die 2 -Verteilung ist in Mathematica vorhanden, und zwar im Paket
Statistics’ContinuousDistributions’. Sie hat den selbsterklärenden
Namen ChiSquareDistribution[..]. Als Argument ist die Zahl der Frei-
heitsgrade einzusetzen, die hier mit N = 11 Daten und M = 4 Parametern durch
N M = 7 bestimmt ist. Mit PDF erhält man die Dichte der Verteilung, also den
Integranden von P7 (20 ), Gleichung (1.29), während CDF das Integral, also P7 (20 )
selbst, ergibt. Mit Quantile wird die Funktion P7 (20 ) invertiert.
Quantile[ChiSquareDistribution[7], 0.95]
gibt also dasjenige 20 , für das in 95% aller Experimente der Wert von 2 kleiner
als 20 ist. Fixiert man zwei Parameter, so kann man für die übrigen zwei die Fläche
a a
in der Parameterebene, für die 2 ( ) = 2 ( 0 ) + ist, durch ContourPlot
darstellen.

Ergebnisse
Bild 1.8 zeigt die Funktion f[t] für a=1, om=1, phi=0 und b=0.1 und die
11 Daten, die aus f[t] mit dem Zufallsfehler "i gewonnen wurden. Nach dem
Start mit a=1.1, om=1.1, phi=0.1 und b=0.2 findet NonlinearFit das
a a
Minimum 0 von 2 ( ) in etwa fünf Schritten. Das Ergebnis wird von Mathematica
in Form einer Regel ausgegeben.
fa –> 0.825, om –> 0.976, phi –> 0.024, b –> 0.069 g (1.31)
1.5 Nichtlinearer Fit 29

0.8
0.6
0.4
0.2
f[t]

0
-0.2
-0.4
-0.6
0 2 4 6 8 1.8 Gedämpfte Schwingung
t und verrauschte Meßdaten.

Die Dichte der 2 -Verteilung ist im Bild 1.9 gezeigt. Die Verteilung (1.29) gilt
zwar streng genommen nur für gaußverteilte Fehler "i , aber wir erwarten keinen
großen Unterschied für unsere gleichverteilten Streuungen "i . Für den richtigen

0.12

0.1

0.08
Dichte

0.06

0.04

0.02

0
0 5 10 15 20 1.9 Dichte der 2 -Verteilung
chi2 mit 7 Freiheitsgraden.

Parametersatz gibt diese Dichte die Verteilung von 20 für verschiedene Experimen-
te, d. h. für verschiedene Realisierungen der "i .
Das Vertrauensintervall für den Wert von 20 erhalten wir mit
grenze[x_] = Quantile[ChiSquareDistribution[7],x]
f
und das Ergebnis von grenze[0.05], grenze[0.95] ist 2:2; 14:1 . Das g f g
heißt, für sehr viele Experimente sollten (mit den korrekten Parametern) 5% davon

einen Wert 20 14:1 und 5% einen Wert 20 2:2 haben. In unserem Fall erhalten
wir mit 20 = 9:4 einen Wert weit im Innern des Vertrauensintervalls; wir haben
daher keinen Grund, an dem Ergebnis des Fits zu zweifeln.
30 1 Mathematica-Funktionen

a a
Konturen mit P4 (2 ( ) 20 ) = 0:68 und P4 (2 ( ) 20 ) = 0:90 sind in der
Abbildung 1.10 zu sehen. Es sind dreidimensionale Flächen im vierdimensionalen
Parameterraum, deshalb können wir nur Schnitte zeichnen. Der optimale Parame-
tersatz liegt natürlich genau im Zentrum aller Konturflächen. Der (a,b)-Schnitt

0.2
0.14

0.15 0.12

0.1
0.1
0.08

b
b

0.05 0.06

0.04
0 0.02

0
0.4 0.6 0.8 1 1.2 0.9 0.92 0.94 0.96 0.98 1 1.02 1.04
a om
1.10 Konturen mit konstantem 2 (a). Links: Schnitt mit der a-b-Parameter-Ebene. Rechts:
Schnitt mit der om-b-Ebene.

zeigt, daß Änderungen in der Amplitude a durch eine Änderung der Zeitkonstan-
ten b 1 der Dämpfung kompensiert werden können, ohne die Qualität des Fits zu
verschlechtern. Daher darf man als Fehler für a nicht den Schnitt beim optimalen
b angeben, sondern man muß die Projektion auf die a-Achse verwenden. Insbeson-
dere zeigt Bild 1.10 (links), daß es nicht möglich ist, eine obere Schranke für die
Zeitkonstante b 1 zu bestimmen, da die Kontur der äußeren Vertrauensfläche durch
den Punkt b=0 (also b 1 = ) geht. 1
Variiert man die Frequenz om anstatt der Amplitude a, so tritt die obige Kompen-
sation nicht auf, wie Bild 1.10 (rechts) zeigt. Der wahre Punkt om=1 und b=0.1
liegt dicht am Rand der inneren Vertrauensfläche; das Vertrauensintervall sollte
daher nicht zu eng gewählt werden. Zeichnet man f[t] für zwei Extrema aus
Bild 1.10, nämlich a=1.3, b=0.15 und a=0.5, b=0, so sieht man in Bild 1.11,
daß beide Kurven die Daten noch relativ gut wiedergeben. Die wenigen Daten
(N = 11) und der große Fehler erlauben keinen besseren Fit.
Wie im Theorie-Teil erläutert wurde, gibt es eine alternative Methode, um den
Fehler für die Parameter abzuschätzen. Man nimmt für ein Experiment den optima-
a
len Parametersatz 0 und erzeugt sich damit neue, künstliche Daten, die wiederum
a
gefittet werden. Wird dies mit demselben 0 wiederholt, so erhält man einen Satz
a
von Parametervektoren i . Bild 1.12 zeigt das Ergebnis für 100 Iterationen mit dem
a 0 aus Gleichung (1.31) zusammen mit den Konturlinien von Bild 1.10. Man sieht,
daß die Werte in der (a, b)-Projektion sogar zu mehr als 90% innerhalb des äußeren
1.5 Nichtlinearer Fit 31

1
0.75
0.5
0.25
f[t]

0
-0.25
-0.5
1.11 Zwei Fitkurven mit Para-
0 2 4 6 8 metern aus der äußeren Kontur
t von Bild 1.10 (links).

a
Konturschnitts liegen. Um die Fehlergrenzen von 0 angeben zu können, berechnen
f g
wir mit dem ursprünglichen Datensatz Yi zu jedem der 100 Parametervektoren i a
a a
das zugehörige 2 ( i ) und sortieren die i nach wachsendem 2 . Für ein Vertrau-

0.15

0.1
b

0.05

0
1.12 Parameterwerte a und b aus den Fits
0.5 0.6 0.7 0.8 0.9 1 1.1 1.2 zu den künstlichen Daten zusammen mit
a den Konturlinien von Bild 1.10 (links).

ensniveau von z. B. 68% betrachten wir dann nur noch die ersten 68 dieser Vektoren,
a
von denen der letzte eine 2 -Grenze 268 = 2 ( 68 ) festlegt. Alle noch verbleiben-
a a
den i liegen dann innerhalb des Quasi-Ellipsoids 2 ( ) 268 . Wir projizieren die
a
Punkte i auf die Achsen des Parameterraumes und erhalten so die äußeren Abmes-
sungen des Ellipsoids. Auf diese Weise können wir schließlich die Aussage treffen,
a
daß mit einer Sicherheit von 68% der wahre Vektor true in einem Quasi-Ellipsoid
liegt, das in dem Quader

a = 0:83 0:26 ; b = 0:07 0:06 ; om = 0:98 0:05 ; phi = 0 0:2

32 1 Mathematica-Funktionen

enthalten ist. Natürlich gehört wegen der erwähnten Korrelationen nicht jeder Punkt
a des Quaders zu dem 68%-Bereich. Ob er dazugehört, läßt sich an seinem 2 ( ) a
feststellen.

Übung
Die Daten fxi ; f (xi )g im File twinpeak.dat sind das Ergebnis der Funktion
f (x i ) = e x2i =2 + a e (xi b)2 =(22 ) + r
i;
wobei die ri normalverteilte Zufallszahlen mit Mittelwert 0 und Breite 0 = 0:05
sind. Die Daten können Sie mit

daten = << twinpeak.dat

während einer Mathematica-Sitzung einlesen und mit ListPlot[daten] anse-

hen. Finden Sie die Amplitude a, den Ort b und die Breite des Zusatzpeaks und
geben Sie die Fehler der drei gefitteten Parameter an.

Literatur
S. Brandt, Datenanalyse: Mit statistischen Methoden und Computerprogrammen,
BI Wissenschaftsverlag, 1992.
J. Honerkamp, Stochastische Dynamische Systeme: Konzepte, numerische Metho-
den, Datenanalysen, VCH Verlagsgesellschaft, 1990.
W.H. Press, S.A. Teukolsky, W.T. Vetterling, B.P. Flannery, Numerical Recipes in
C: The Art of Scientific Computing, Cambridge University Press, 1992.
Stephen Wolfram, Mathematica: A System for Doing Mathematics by Computer,
Addison Wesley, 1991.

1.6 Multipol-Entwicklung
Ein mächtiges analytisches Werkzeug des Theoretikers ist die Entwicklung einer
physikalischen Gleichung nach einer kleinen Größe. Dabei entstehen manchmal
Ausdrücke, die kompliziert und unanschaulich sind. Oft hat man kein Gefühl dafür,
wie stark die Entwicklung vom wahren Wert abweicht.
Die Multipol-Entwicklung eines elektrostatischen Potentials, ein beliebtes Kapi-
tel aus der Elektrodynamik-Vorlesung, ist ein einfaches Beispiel dafür. Von ferne
sieht eine Ladungsverteilung wie eine Punktladung aus. Kommt der Beobachter
1.6 Multipol-Entwicklung 33

näher, so bemerkt er das Dipolmoment, bei größerer Annäherung auch das Qua-
drupolmoment. Diese approximative Beschreibung läßt sich kompakt durch einen
Skalar, einen Vektor und einen Tensor mathematisch formulieren. Jetzt – mit Ma-
thematica – können wir dies ebenso kompakt programmieren, aber auch graphisch
darstellen und uns die Abweichung vom exakten Potential ansehen.

Physik
r
Für N punktförmige Ladungen ei an den Orten (i) ist das elektrostatische Potential
r
( ) gegeben durch
X
N
ei
(r) = jr r(i) j : (1.32)
i=1
Das elektrische Feld ist durch den Gradienten von bestimmt:
@ @ @
E= r(r) ; r =
@x ; @y ; @z : (1.33)

Betrachtet man nun dieses Potential von weiter Ferne, also für jr r(i) j ! 1, so
r
kann man ( ) entwickeln:

(r) = rq + pr3r + 12 r15 r Qb r + O r14 (1.34)

b der Quadru-
mit r = jr j. Dabei ist q die Gesamtladung, p das Dipolmoment und Q
poltensor:

X
N X
N X N
q= p
ei ; = ei r (i) ; Qbkl = ei 3rk(i) rl(i) kl r(i) 2 ; (1.35)
i=1 i=1 i=1
(i)
wobei rk die k -te Komponente von (i) ist.r

Algorithmus
Wir wollen diese Entwicklung am Beispiel von fünf positiven und fünf negativen
Einheitsladungen untersuchen, die wir in die x-y -Ebene legen, und zwar zufällig
verteilt innerhalb eines Quadrats mit Mittelpunkt im Ursprung. Wir erzeugen uns
also zehn Vektoren mit
rpunkt:={2 Random[]–1, 2 Random[]–1, 0}
Do[r[i] = rpunkt, {i,10}]
34 1 Mathematica-Funktionen

Jeder Vektor r[i] ist eine Liste von drei Zahlen. An den ersten fünf Punkten
sollen sich positive, an den letzten fünf negative Ladungen befinden. Wir wollen
nun die Ladungen graphisch darstellen. Dazu werden zunächst mit der Funktion
Line[: : :] an den entsprechenden Stellen Plus- und Minussymbole gezeichnet,
wobei man mit Drop[r[i],–1] die z -Koordinate beseitigt:

p1 = Graphics[Table[Line[{Drop[r[i],–1]–{0.08,0},
Drop[r[i],–1]+{0.08,0}}],{i,5}]]
p2 = Graphics[Table[Line[{Drop[r[i],–1]+{0,0.08},
Drop[r[i],–1]–{0,0.08}}],{i,5}]]
p3 = Graphics[Table[Line[{Drop[r[i+5],–1]–{0.08,0},
Drop[r[i+5],–1]+{0.08,0}}],{i,5}]]
Dann wird mit Circle[ ] jeweils ein Kreis um die Symbole gezeichnet,

p4 = Graphics[{Thickness[0.001],
Table[Circle[Drop[r[i], –1], 0.1],{i,10}]}]
und danach werden mit Show[p1,p2,p3,p4,Optionen] alle vier Graphikob-
jekte zusammen gezeichnet. Bild 1.13 zeigt das Ergebnis.

2
1.5
1
0.5
0
y

-0.5
-1
-1.5
-2
-2 -1.5 -1 -0.5 0 0.5 1 1.5 2 1.13 Positive und negative Ladungen zufällig
x verteilt in der x-y -Ebene.

Um das Potential angeben zu können, definieren wir zunächst den Abstand zwi-
schen zwei Vektoren,

dist[r ,s ]=Sqrt[(r–s).(r–s)]
Der Punkt zwischen zwei Listen von Zahlen – die volle Mathematica-Form davon
ist Dot[l1,l2] – bewirkt ein Skalarprodukt der beiden Vektoren, also die Summe
der Produkte der jeweiligen Komponenten der Vektoren. Ohne den Punkt hingegen
würden die Vektoren elementweise miteinander multipliziert werden mit einer Liste
r
als Ergebnis. Nun kann man ( ) aus Gl. (1.32) direkt eingeben (ei = 1):
1.6 Multipol-Entwicklung 35

pot[rh_]:=Sum[1/dist[rh,r[i]]–1/dist[rh,r[i+5]],{i,5}]
Wir präsentieren drei Möglichkeiten, wie man sich dieses Ergebnis veranschauli-
chen kann: Zunächst zeichnen wir mit Plot3D das Potentialgebirge über der x-y -
Ebene, dann mit ContourPlot die Höhenlinien dieses Gebirges, und schließlich
berechnen wir das elektrische Feld und zeichnen es mit PlotVectorField aus
dem Paket Graphics‘PlotField‘. Allerdings sieht man im letzten Fall nur
etwas, wenn man das Feld normiert, also nur die Richtung anzeigt.
Das Dipol- und Quadrupolmoment kann man ebenso einfach in Mathematica
formulieren. Nach Gl. (1.35) gilt
dipol = Sum[r[i] – r[i+5],{i,5}]
quadrupol[r_]:=
Table[3 r[[k]] r[[l]] – If[k==l,r.r,0],{k,3},{l,3}]
qsum = Sum[quadrupol[r[i]]–quadrupol[r[i+5]],{i,5}]
Dabei wurde das Delta-Symbol kl durch folgenden Ausdruck beschrieben
If[k==l,1,0]
r
Den Betrag eines Vektors , den wir zwar als dist[r,0] ausdrücken könnten,
berechnen wir mit der Funktion
betrag[r ]=Sqrt[r.r]
r
Damit läßt sich die Entwicklung (1.34) des Potentials ( ) direkt definieren. In
unserem Beispiel gibt es keine Gesamtladung (q = 0), daher ist der erste Beitrag
pot1 der Dipolterm, und pot2 enthält zusätzlich den Quadrupolbeitrag:
pot1[r_] = dipol.r / betrag[r]ˆ3
pot2[r_] = pot1[r]+1/2/betrag[r]ˆ5 r.qsum.r

qsum ist eine Liste von Listen, in diesem Fall also eine 3 3-Matrix. r ist eine Liste
von Zahlen, also ein Vektor. Die Funktion Dot[ , ] oder kurz mit dem Punkt
(.) bezeichnet, berechnet Kontraktionen von Tensoren mit beliebig vielen Indizes
(= geschachtelten Listen). Hier läßt sich daher die quadratische Form Vektor mal
”
Matrix mal Vektor“ sehr einfach als r.qsum.r schreiben. In einer herkömmlichen
Programmiersprache wie C müßte man dagegen zwei for-Schleifen ineinander-
schachteln:
sum = 0;
for(i=0; i<3; i++) {
for(j=0; j<3; j++) {
sum = sum + r[i]*qsum[i][j]*r[j] }}
Das elektrische Feld E erhält man nach Gleichung (1.33) wie folgt:
36 1 Mathematica-Funktionen

efeld =
–{D[pot[{x,y,z}],x],D[pot[{x,y,z}],y],D[pot[{x,y,z}],z]}
und seine Richtung erhält man durch Division durch jE j :
richtung = efeld/betrag[efeld]

5
2
Φ
0
1
-5
-2 0 y
-1

1.14 Potential der

0 -1

10 Einheitsladungen in
x
1
2 -2 der Ebene z = 0.

Ergebnisse
In unserem einfachen Beispiel sind fünf positive und fünf negative Ladungen ei = j j
1 zufällig in der x-y-Ebene verteilt (Bild 1.13). Sie erzeugen in dieser Ebene das
f g
Potential pot[ x,y,0 ], das in Bild 1.14 als Gebirge und in 1.15 durch seine
Höhenlinien ( = const.) dargestellt ist.

-1

-2 1.15 Wie Bild 1.14, aber als Kontur-Darstel-

-2 -1 0 1 2 lung.
1.6 Multipol-Entwicklung 37

Wir wollen nun die Dipol- und Quadrupolnäherung mit dem exakten Potential ver-
gleichen. Dazu betrachten wir in der x-y -Ebene (z = 0) einen Weg mit x = 0:6
parallel zur y-Achse, der dicht an zwei positiven Ladungen bei y '1, einer nega-
'
tiven Ladung und einem Dipol bei y 0 vorbeiläuft. Bild 1.16 zeigt das Ergebnis.
Die durchgezogene Kurve ist das exakte Potential. Der Dipolterm (kurz gestrichelt)

2
Potential

-2

1.16 Das exakte Potential

-4
(durchgezogen), der Dipol-
-2 -1 0 1 2
term (kurz gestrichelt) und die
{.6,y,0} Quadrupolnäherung.

kann wegen pr

nur einmal das Vorzeichen wechseln, er kann also nicht die zwei
positiven Maxima bei den positiven Ladungen richtig wiedergeben. Aber auch mit
der Quadrupolkorrektur (lang gestrichelt) beschreibt die Näherung nur grob quali-
tativ das Potential in der Nähe der Ladungen. Die Richtung des elektrischen Feldes
ist in Bild 1.17 zu sehen. Weit entfernt von den Ladungen dreht sich das Feld wie

-5

1.17 Die Richtung des elek-

trischen Feldes der zehn Ein-
-10 heitsladungen in der Ebene
-10 -5 0 5 10 z = 0.
38 1 Mathematica-Funktionen

beim Dipol um den Ursprung. In der Nähe der Ladungen zeigt sich dagegen eine
komplizierte Struktur.

Übung
I
Es soll das Magnetfeld berechnet werden, das eine vom Strom durchflossene
kreisförmige Leiterschleife erzeugt. Die Leiterschleife liege in der x-y -Ebene mit
A
Mittelpunkt im Ursprung und habe den Radius a. Das Vektorpotential , aus dem
man das Magnetfeld B =r A berechnet, hat in Kugelkoordinaten (r; ; )
e e e
mit den Einheitsvektoren r ; ; eine besonders einfache Form. Nur seine -
Komponente ist von null verschieden, und im Lehrbuch von J. D. Jackson findet
man dafür den Ausdruck

A(r; ) = 0 2 2I a
p (2 k2 )K (k) 2E (k)
k2
a + r + 2ar sin
mit
k2 = a2 + 4rar sin
2 + 2ar sin :
K (k) = EllipticK[k2] und E (k) = EllipticE[k2] sind die vollständigen
elliptischen Integrale erster und zweiter Art.
B
Berechnen Sie das Magnetfeld (x; y; z ) und zeichnen Sie in der x-z -Ebene mit
B
der Funktion PlotVectorField[: : :] die Richtung des -Feldes. Versuchen
Sie, durch Integration einer geeigneten Differentialgleichung das Feldlinienbild von
B in der x-z -Ebene zu zeichnen.
Hinweis: Die Schwierigkeit, daß Mathematica mit den Ableitungen EllipticK’
und EllipticE’ nichts anzufangen weiß, läßt sich beheben, weil die Ableitungen
der elliptischen Integrale wiederum durch elliptische Integrale ausgedrückt werden
können. Die zwei Zeilen
EllipticK’[x_]=1/(2x)*(EllipticE[x]/(1–x)–EllipticK[x])
EllipticE’[x_]=1/(2x)*(EllipticE[x]–EllipticK[x])
in Ihrem Programm lösen das Problem.

Literatur
I.S. Gradshteyn, I.M. Ryzhik, Table of Integrals, Series, and Products, Academic
Press, 1980.
J. D. Jackson, Classical Electrodynamics, John Wiley & Sons, 1975.
R. Schaper, Grafik mit Mathematica, Addison Wesley, 1994.
1.7 Wegintegrale 39

1.7 Wegintegrale
Physik

Arbeit = Kraft Weg. Diese scheinbar einfache Gleichung aus der Schulphysik
wird sofort schwieriger, wenn man sich klarmacht, daß die Kraft ein Vektorfeld
Kr r
( ) ist, also jedem Punkt im Raum einen Vektor zuordnet, und daß der Weg W
r
eine Kurve (t) im Raum ist, die durch eine Zeit t parametrisiert werden kann. Die
Arbeit A ist damit das Wegintegral
Z Zt
A = K dr = K (r(t)) ddtr dt :
e

(1.36)
W ta

Das Skalarprodukt Kraft Geschwindigkeit wird also über das Zeitintervall [ta ; te ]
Kr
integriert. Dieses Integral wird einfach, wenn ( ) der Gradient eines Potentials
r
( ) ist,
K
= r ; (1.37)
r r
dann gilt A = ( (te )) ( (ta )). Im allgemeinen kann die Auswertung des
Wegintegrals allerdings mühsam sein.
Mathematica bietet die Möglichkeit, Vektoranalysis bequem auszuführen, sogar
in symbolischer Form. Wir wollen dies an einem Wegintegral demonstrieren und
verweisen für weitergehende Rechnungen und Vektoroperationen in anderen Koor-
dinatensystemen auf das Package Calculus‘VectorAnalysis‘.

Algorithmus und Ergebnis

Zunächst definieren wir drei Wege r(t) im Raum, die alle von f1;0;0g nach f1;0;1g
führen sollen.
r1 = {Cos[2Pi t], Sin[2Pi t], t}
r2 = {1, 0, t}
r3 = {1 – Sin[Pi t]/2, 0 ,(1 – Cos[Pi t])/2}
Der erste Weg ist eine Spirale, der zweite die Verbindungsgerade und der dritte ein
Halbkreis in der x-z -Ebene. ParametricPlot3D zeigt diese Wege in Abbildung
1.18. Dann definieren wir ein Vektorfeld, und zwar
k[{x_,y_,z_}]={2x y + zˆ3, xˆ2, 3x zˆ2}
Die Geschwindigkeit, mit der der Weg durchlaufen wird, kann einfach mit der Ab-
leitungsoperator D[: : :] definiert werden; D[: : :] ist Listable, wirkt also auf
Listenelemente:
40 1 Mathematica-Funktionen

1
0.75
z 1
0.5
0.25 0.5
0
-1 0 y
-0.5
0 -0.5
x
0.5
-1
1
1.18 Drei verschiedene Integrationswege.

v[r ]:=D[r,t]
Das Wegintegral kann sogar als Funktion definiert werden, die auf Wege wirkt:
int[r ]:=Integrate[k[r].v[r], t,0,1 ] f g
Wir geben nun int[r1], int[r2] und int[r3] ein und erhalten für alle drei
Wege dasselbe Ergebnis, nämlich den Wert 1. Die Unabhängigkeit des Integrals
vom Weg läßt vermuten, daß K
der Gradient eines Potentials ist. Dann muß nach
Sätzen der Vektoranalysis die Rotation von K
verschwinden, die definiert ist als
f
rot[ kx , ky , kz g]:= f D[kz,y] – D[ky,z],
D[kx,z] – D[kz,x],
D[ky,x] – D[kx,y] g
f g
rot[k[ x,y,z ]] gibt tatsächlich den Nullvektor 0,0,0 . f g
r
Wie findet man das Potential ( ), das bis auf eine Konstante eindeutig bestimmt
ist? Nach Gl. (1.36) gilt
Zr Z1
(r) = K ds = K ddts dt ; (1.38)
0 0
f
wobei wir s(t) = r4 = t x,y,z als Weg von g 0 bis r wählen. int[r4] liefert
das Potential (x; y; z ) = x2 y + xz 3 .
1.8 Maxwell-Konstruktion 41

Wir können nun das Feld K (r) ein wenig verändern, z. B. durch
k[{x,y,z}] = {2x yˆ2 + zˆ3, xˆ3, 3x zˆ3}

und erhalten dann für jeden Weg ein anderes Ergebnis: Nach dem Anwenden von
Simplify liefert int[r1]

1 + 43 2 + 34 ;
int[r2] gibt 3=4 und int[r3] den Wert 3=4 + 9=256 . Berechnen wir jetzt
erneut die Rotation, so ergibt rot[k[{x,y,z}]] in Übereinstimmung mit der
0
Abhängigkeit des Integrals vom Integrationsweg einen von verschiedenen Wert.

Übung

1. Berechnen Sie die Längen der Kurven r1, r2 und r3.

2. Wählen Sie die Parametrisierung t = 2 für die Wege r1, r2, r3, berechnen Sie
die Wegintegrale und zeichnen Sie die Beträge der drei Beschleunigungen ddt2r
2

als Funktion von .

3. Testen Sie die Gleichheit der Wegintegrale für ein anderes Vektorfeld a(x; y; z)
a
mit = r und nach eigener Wahl.

Literatur
S. Großmann, Mathematischer Einführungskurs für die Physik, Teubner Studienbü-
cher Physik, 1991.

1.8 Maxwell-Konstruktion
In der Physik treten häufig implizite nichtlineare Gleichungen für die gegenseitige
Abhängigkeit von Größen auf, die nur noch numerisch gelöst werden können. Ein
Beispiel dafür sind die p(V; T )-Kurven des van-der-Waals-Gases mit der Tempera-
tur T als Parameter, die durch die sogenannte Maxwell-Konstruktion eine physika-
lische Bedeutung erlangen.
Die Isothermen der Zustandsgleichung, die als van-der-Waals-Gleichung bekannt
ist, haben bei tiefen Temperaturen Schleifen, die aus thermodynamischen Gründen
verboten sind. Sie müssen durch Geraden ersetzt werden, die die Schleifen in einem
42 1 Mathematica-Funktionen

bestimmten Sinn halbieren. Um diese sogenannten Maxwell-Geraden zu konstruie-

ren, muß man eine nichtlineare Gleichung, die noch ein Integral enthält, numerisch
lösen. Auf diese Weise erhält man eine Beschreibung des Phasenübergangs vom
Gas zur Flüssigkeit.

Physik
Die Theorie der Wärme gibt für ein ideales Gas aus N wechselwirkungsfreien, klas-
sischen Teilchen ohne innere Freiheitsgrade einen einfachen Zusammenhang zwi-
schen Volumen V , Druck p und Temperatur T :

p V = Nk T : B (1.39)

Dabei ist kB die Boltzmannkonstante. Unter Berücksichtigung der Wechselwirkung

zwischen den Teilchen erhält man in einer einfachen Näherung die van-der-Waals-
Gleichung
p + Va2 (V b) = Nk T B (1.40)

mit Parametern a und b.

Diese Gleichung gibt z. B. die Isothermen an, also den Druck p als Funktion
des Volumens V für konstante Temperaturen T . Für hohe Temperaturen fällt der
Druck mit wachsendem Volumen, während er bei tiefen Temperaturen p(V ) in ei-
nem gewissen Bereich wieder ansteigt (siehe Bild 1.19). Es gibt nun eine kritische
Temperatur Tc , unterhalb derer diese Schleife auftritt. Für T < Tc findet ein Pha-
senübergang zwischen Gas und Flüssigkeit statt; genau bei Tc verschwindet der
Unterschied zwischen flüssiger und gasförmiger Phase.
Tc und Vc sind dadurch bestimmt, daß die erste und zweite Ableitung von p(V; T )
nach V verschwinden,

@p (V; T ) = 0 @ 2 p (V; T ) = 0 ;
@V und
@V 2 (1.41)

mit dem Ergebnis:

Tc = 27Nk8a ; V = 3 b ; p = a :
b c
B
c
27 b2 (1.42)

Skaliert man nun jeweils p; V und T mit pc ; Vc und Tc , so erhält man eine Glei-
x = x=xc ):
chung, die keine Parameter mehr enthält (~

p~ + ~32 3V~ 1 = 8T~ : (1.43)
V
1.8 Maxwell-Konstruktion 43

Für T~ < 1 gibt die Gleichung also die unphysikalische Schleife, d. h. für einen
gewissen Bereich gibt es für jeden Druckwert p~ drei Volumina V~1 ; V~2 und V~3 . Der
Übergang vom Gas mit großem Volumen V~3 zur Flüssigkeit mit kleinem Volumen
V~1 findet aus thermodynamischen Gründen bei demjenigen Druck p~t statt, bei dem
gilt:
Z
V~3
p~(V~ )dV~ = p~t V~3 V~1 : (1.44)
V~1
Bei p~t sind Gas und Flüssigkeit für alle Volumina V~ mit V~1 V~ V~3 gleich-

zeitig vorhanden, man beobachtet ein Zweiphasengemisch. Geometrisch bedeutet
die obige Gleichung, daß die Fläche zwischen der p~(V~ )-Kurve und der Geraden
p~t = const. im Bereich von V~1 bis V~2 genauso groß ist wie die entsprechende
Fläche zwischen V~2 und V~3 (siehe Bild 1.19). Die Kurve p~t = const., die man
Maxwell-Gerade nennt, wollen wir mit Mathematica konstruieren.

Algorithmus und Ergebnis

Zunächst überprüfen wir die Gleichung (1.42) für den kritischen Punkt. Wir geben
die van-der-Waals-Gleichung (1.40) ein (NkB T = t),
p=t/(v–b) – a/vˆ 2
und definieren die beiden Gleichungen (1.41):
gl1=D[p,v]==0
f
gl2=D[p, v,2 ]==0 g
Dabei bedeutet das Zeichen = eine Zuordnung, während == die Gleichheit überprüft
und zuerst ausgeführt wird. Diese Gleichungen lösen wir nach t und v auf,
f
sol=Solve[ gl1,gl2 , t,v ] gf g
mit einer Regel als Ergebnis:
8 a
{{ t –> ––––, v –> 3b}}
27 b
Da die Lösung nicht immer eindeutig ist, liefert Solve eine Liste von Regeln. Da-
her stammen die doppelten geschweiften Klammern. Den kritischen Druck erhalten
wir, indem wir den inneren Teil der Regel auf p anwenden,
pc = p/.sol[[1]]
44 1 Mathematica-Funktionen

mit dem Ergebnis a/(27 b2 ).

Jetzt definieren wir die skalierte p~(V~ ) Gleichung (1.43):

p[v ]=8t/(3v–1)–3/vˆ 2
Für die Maxwell-Gerade benötigen wir zwei Gleichungen, um die beiden unbekann-

1.75

1.5

1.25

1
p

0.75

0.5

0.25

0
1 2 3 4 5
v
1.19 Maxwell-Konstruktion für die van-der-Waals-Gleichung. Isothermen zu den skalierten
Temperaturen T~ = 1:05; 1:0; 0:95; 0:92; 0:85 (von oben nach unten).

ten Volumina v1 und v3, zwischen denen Gas und Flüssigkeiten koexistieren, zu
bestimmen. Die erste Gleichung sagt, daß Koexistenz Gleichheit der Drücke ver-
langt:

gl3=p[v1]==p[v3]
Die zweite Gleichung setzt die beiden Flächen nach Gleichung (1.44) gleich:

gl4=p[v1]*(v3–v1)==Integrate[p[v], v,v1,v3 ] f g
Ein Versuch mit Solve zeigt an, daß Mathematica keine analytische Lösung fin-
det. Wir werden deshalb FindRoot benutzen, um eine numerische Lösung zu er-
halten. Allerdings müssen die Startwerte der (v1,v3)-Suche ziemlich genau an-
gegeben werden, damit ein vernünftiges Ergebnis gefunden wird. In der Funktion
plot[T_] werden deshalb für Temperaturen T < 1 zunächst diejenigen v-Werte
bestimmt, an denen p[v] ein relatives Minimum bzw. Maximum hat, und dar-
aus wird das arithmetische Mittel vtest gebildet. Mit dem Mathematica-Befehl
1.9 Beste Spielstrategie 45

Solve[p[v]==p[vtest],v] erhält man dann drei Lösungen, von denen die

beiden äußeren als Startwerte geeignet sind. Die endgültige Maxwell-Funktion ist
dann
pmax[v ]:= If[v < v1 || v > v3, p[v], p[v1]]
Falls v zwischen den Lösungen v1 und v3 liegt, wird also die Maxwell-Gerade
übergeben, sonst p[v]. Bild 1.19 zeigt das Ergebnis für verschiedene Werte der
skalierten Temperatur T~ zusammen mit den unphysikalischen p[v]-Funktionen.
Bei v ! 3 divergiert der Druck. Die obere Kurve beschreibt p(V ) in der Gas-
1
phase, und die darunterliegende gibt die Situation gerade bei der kritischen Tem-
peratur wieder. Die unteren drei p(V )-Kurven zeigen bei tiefen Temperaturen eine
Trennung in eine flüssige (kleines Volumen) und eine gasförmige Phase. Auf der
Maxwell-Geraden koexistieren Flüssigkeit und Gas im thermischen Gleichgewicht.

Übung
Betrachten Sie ein Quantenteilchen der Masse m in einem eindimensionalen Poten-
tialtopf
V (x) = 0V0 für sonst :
a x a;
Aus der Quantenmechanik-Vorlesung wissen Sie, daß die Energieniveaus E der ge-
bundenen Zustände durch folgende Gleichungen bestimmt sind:
p
= VE = xq 2 1 mit x = ~a 2mV0 und q Lösung der transzendenten Gleichung
2
0
px2 q2 px2 q2
tan q = q oder cot q = q :
Berechnen und zeichnen Sie alle Energieniveaus n als Funktion des Parameters x.

Literatur
T. Fließbach, Statistische Physik, Spektrum Akademischer Verlag, 1995.
E. W. Schmid, G. Spitz, W. Lösch, Theoretische Physik mit dem Personal Computer,
Springer, 1987.

1.9 Beste Spielstrategie

Als letztes Beispiel für die Anwendung vordefinierter Mathematica-Funktionen wol-
len wir uns eine Optimierungsaufgabe ansehen, die nicht direkt aus der Physik
46 1 Mathematica-Funktionen

stammt. Lineares Optimieren wird zwar hauptsächlich in den Wirtschaftswissen-

schaften (Operations Research) angewandt, trotzdem gibt es auch in der Physik
immer wieder Probleme, die diese Methoden – meist mit Benutzung fertiger Pro-
grammpakete – benötigen.
Hier wollen wir uns mit einem Spiel beschäftigen, das zwei Personen mit Hil-
fe einer Auszahlungstabelle spielen. Um die beste Spielstrategie zu finden, brau-
chen die beiden Kontrahenten einige Sätze der mathematischen Spieltheorie, die in
den zwanziger Jahren von J. von Neumann begründet wurde, und außerdem das
Mathematica-Programm LinearProgramming.

Mathematik
Es spielen zwei Personen gegeneinander. Nach jedem Zug muß ein Spieler dem
anderen einen Betrag bezahlen, der aus einer Tabelle abgelesen wird. Jeder Spieler
versucht, seine Züge so zu wählen, daß die Summe seiner Gewinne und Verluste
nach vielen Zügen eine positive Bilanz aufweist.
Für das Spiel wird eine Gewinntabelle K = (Kij ) benötigt, z. B.
0 0 1 3 1
1
K=@ 1 10 4 2 A:
7 2 3 7
Der Spieler Z kann bei jedem Zug eine der drei Zeilen i = 1; 2; 3 wählen, während
Spieler S vier Wahlmöglichkeiten für die Spalten j = 1; :::; 4 hat. Ein Zug besteht
darin, daß Spieler Z sich für eine Zeilennummer i und Spieler S sich für eine Spal-
tennummer j entscheidet, ohne daß der eine von der Wahl des anderen weiß. Dann
wird aufgedeckt, und danach erhält Spieler Z gemäß dem Paar (i; j ) den Betrag
j j
Kij vom Spieler S , bzw. zahlt Kij für Kij < 0. Da der Gewinn von Z der Verlust
von S ist und umgekehrt, nennt man dieses Spiel Zwei-Personen-Nullsummen-Spiel.
Diese Prozedur wird viele Male wiederholt. Am Ende hat Z im Mittel pro Zug den
Betrag K erhalten. Z sucht also eine Strategie, die einen möglichst großen mittleren
Gewinn K ergibt.
Natürlich möchte auf der anderen Seite S seine Verluste minimieren, er sucht al-
so das Minimum von K . Für jede Wahl i von Z sucht er also minj Kij . Da er aber
nicht weiß, welche Zeile Z wählen wird, könnte er auf die Idee kommen, diejenige
Spalte zu wählen, die im schlechtesten Fall den geringsten Verlust ergibt. Für jede
Wahl j verliert S im schlechtesten Fall den Wert maxi Kij . Er wählt also dasje-
nige j , das zu minj maxi Kij gehört, hier die Spalte j = 3. Bei entsprechender
Überlegung würde Z die Zeile zum Wert maxi minj Kij wählen, also i = 1. Bei
dieser Strategie würde nach jedem Zug an Spieler Z der Betrag K13 = 3 ausge-
zahlt werden. Die von den jeweiligen Spielern ins Auge gefaßten Grenzen haben
1.9 Beste Spielstrategie 47

unterschiedliche Werte:
0 = max
i
min
j
Kij 6= min
j
max
i
Kij = 4 : (1.45)

Was bedeutet nun ein Gewinn von 3 für Spieler Z , der bei dieser Strategie einen
Mindest- Gewinn“ von 0 erwarten konnte? Und sollte Spieler S , der im ungün-
stigsten Fall mit einem Verlust von 4 hatte rechnen müssen, mit der 3 zufrieden
”
sein? In der Tat hat Spieler Z allen Grund, seine Strategie zu überdenken. Eine ge-
nauere Inspektion der Gewinntabelle sagt ihm nämlich, daß für jede Wahl von S
sein Gewinn im Mittel mindestens 3 sein wird, wenn er die Zeilen 2 und 3 zufällig
wechselnd gleich häufig auswählt. Und wenn er Zeile 3 dabei ein wenig bevorzugt,
wird er den Gewinn von 3 sogar übertreffen. Man sieht an dieser Überlegung, daß
es zweckmäßig ist, die Zeilen und Spalten mit einer gewissen Wahrscheinlichkeit pi
bzw. qj zu wählen. Eine Strategie für den Spieler Z besteht also aus den 3 Häufig-
keiten p1 ; p2 und p3 (mit p1 + p2 + p3 = 1), mit denen er unkorreliert die Zeilen

X
wählt. Im Mittel erhält er den Betrag
K= pi qj Kij : (1.46)
i;j
Wenn Z nun eine Strategie p1 ; p2 , und p3 wählt, bekommt er im schlechtesten Fall
P
minq :::q i;j pi Kij qj . Z wird daher ein p1 ; p2 ; p3 wählen, das den Gewinn im
0 0 0
1 4

X
ungünstigsten Fall maximiert, er sucht also
max min
p :::p q :::q
pi Kij qj : (1.47)
1 3 1 4
i;j
S sucht analog eine Strategie q10:::q40 , die den Wert
X
min max
q :::q p :::p
pi Kij qj (1.48)
1 4 1 3
i;j
liefert. Entgegen dem deterministischen Spiel (1.45) geben die optimalen stochasti-

X X X
schen Strategien (1.47) und (1.48) denselben Wert:
max
p
min
q
pi Kij qj = min
q
max
p
pi Kij qj = p0i Kij qj0 = K0 :
ij ij ij
(1.49)
Dies ist das berühmte Minimax-Theorem, das J. von Neumann 1926 im Alter von
23 Jahren bewiesen hat. Wir wollen die Bedeutung von (1.49) noch in Worte fassen:
Wenn Spieler Z eine optimale Strategie p01 ; : : : ; p03 wählt, so ist sein Gewinn für jede
Strategie q1 ; : : : ; q4 des Spielers S nach sehr vielen Spielzügen mindestens K0 . Es

gilt also für jede Wahl q1 ; : : : ; q4 mit qi 0 und q1 + q2 + q3 + q4 = 1 :
X
p0i Kij qj K0 : (1.50)
i;j
48 1 Mathematica-Funktionen

P
Aus dieser Ungleichung kann man ein System von 4 Bedingungen ableiten, denn
mit q1 = 1 und q2 = q3 = q4 = 0 wird daraus i p0i Ki1 K0 und analog:
X
p0i Kij K0 für alle j : (1.51)
i
Nehmen wir an, daß K0 > 0 gilt, so wird dies mit x0i = p0i =K0 zu
X
x0i Kij 1 für alle j : (1.52)
i
Nach Sätzen der linearen Optimierung ist nun die optimale Strategie p01 ; p02 ; p03
durch den maximalen Wert K0 im Gleichungssystem (1.51) bestimmt, oder wegen
P P
i xi = 1=K0 durch das Minimum von i xi .
0 0
Dieser Sachverhalt läßt sich in Vektorschreibweise noch kompakter formulieren:
Es seien K die Matrix (Kij ) und KT die Transponierte von K, = (x1 ; x2 ; x3 )T x
mit xi c b
0; = (1; 1; 1)T ; = (1; 1; 1; 1)T . Dann ist die optimale Strategie
p x
0 = K0 0 und deren mittlerer Gewinn K0 durch ein Minimum von unter cx
der Nebenbedingung KT xb bestimmt, wobei letzte Vektorungleichung kompo-
nentenweise gemeint ist. Es gilt K0 = 1=( 0 ). cx
Nach dem Dualitätssatz der linearen Optimierung kann man K0 auch aus folgen-
dem Problem gewinnen:
Suche das Maximum von by
unter der Nebenbedingung K für den Vektoryc
y
= (y1 ; :::; y4 )T mit yj 0.
y
Die Lösung 0 dieser Aufgabe gibt aber gerade die optimale Strategie für den
q y
Spieler S . Denn mit 0 = K0 0 erhält man
X
Kij qj0 K0 für alle i (1.53)
j
und damit analog zu (1.50) und (1.51) für jede Strategie p von Z :
X
pi Kij qj0 K0 : (1.54)
i;j
Im schlechtesten Fall verliert also der optimal spielende S den Betrag K0 . Spielt S
q
nicht mit der Strategie 0 , kann er allerdings höher verlieren.
Ein nützlicher Satz soll noch erwähnt werden: Addiert man zu jedem Matrixele-
p q
ment die Konstante d, so bleiben 0 und 0 optimale Strategien mit dem Spielwert
K0 + d. Die obigen Aussagen zu (1.51) gelten streng nur für Matrizen mit positiven
Werten Kij . Wegen des Verschiebungssatzes kann aber jede Matrix K ins Positive
verschoben werden; danach wird das Optimierungsprogramm angewendet.
1.9 Beste Spielstrategie 49

Algorithmus und Ergebnis

Das Minimum einer linearen Funktion cx
unter den Nebenbedingungen KT x
b x
; 0 kann mit Mathematica leicht bestimmt werden. In unserem Beispiel ist
c = {1, 1, 1}
b = {1, 1, 1, 1}
k = {{0, 1, 3, 1},{–1, 10, 4, 2},{7, –2, 3, 7}}
und
LinearProgramming[c,Transpose[k],b]
x p p
gibt einen optimalen Vektor 0 , aus dem 0 durch 0 = 0 =( x cx 0 ) und K0 durch
cx
K0 = 1=( 0) bestimmt werden.
Anstatt das Maximum von by
können wir auch das Minimum von by
suchen. Aus K yc folgt K y c . Also lösen wir das duale Problem mit
LinearProgramming[–b,–k,–c]
y
Dies liefert den Vektor 0 und damit K0 = 1=( b y0) und q0 = K0 y0.
Für unser Beispiel ergibt die Rechnung

p0 = (0; 0:45; 0:55)T ; q0 = (0:6; 0:4; 0; 0)T ; K0 = 3:4 :

Damit spielt Z optimal, wenn er die Zeilen 2 und 3 mit den Häufigkeiten 0:45
bzw. 0:55 wählt, während S in jedem Fall nicht mehr als K0 = 3:4 verliert, wenn er
die Spalten 1 und 2 mit den Wahrscheinlichkeiten 0:6 bzw. 0:4 nennt. Beide müssen
aber dafür Sorge tragen, daß sie die Wahl wirklich zufällig treffen, denn sonst könnte
der Gegner auf die Korrelationen zu seinem Vorteil reagieren.
In unserem Beispiel funktioniert der Algorithmus auch für negative Kij -Werte.
Bei anderen Matrizen fanden wir aber erst eine Lösung, nachdem wir die Matrix K
ins Positive verschoben hatten.
Zur Unterhaltung haben wir schließlich das C-Programm spiel.c geschrieben,
mit dem die Leser unseres Buches sich im Zwei-Personen-Nullsummen-Spiel gegen
den Computer versuchen können. Der Rechner erzeugt am Anfang mit Zufallszah-

len eine 4 4-Auszahlungsmatrix mit K0 = 0 und berechnet dazu mit dem Pro-
gramm simplx aus den Numerical Recipes die optimalen Strategien. Der Spieler
wählt bei jedem Zug eine der vier Zeilen, gleichzeitig zieht der Computer eine der
Spalten mit den Wahrscheinlichkeiten qj0 . Nach der obigen Theorie könnte der Le-
ser daher durch eine optimale statistische Auswahl der Zeilen im Mittel verlustfrei
spielen. Allerdings wird jeder sofort merken, daß der Computer langfristig gewinnt,
es sei denn, der Gegenspieler berechnet seine beste Strategie p0i und handelt danach.
Am Ende des Spiels (Taste e) wird gezeigt, wie der Spieler hätte spielen müssen,
um im Mittel verlustfrei zu bleiben.
50 1 Mathematica-Funktionen

Übung

Das wohlbekannte Knobelspiel mit den drei Symbolen Schere, Stein, Papier wollen
wir auf die vier Symbole Schere, Stein, Papier und Brunnen erweitern. Zwei Spieler
setzen dabei jeweils auf eine dieser vier Möglichkeiten und gewinnen, bzw. verlieren
einen Punkt nach folgenden Regeln:
Brunnen verschluckt Stein, Brunnen verschluckt Schere,
Papier deckt Brunnen zu, Papier umhüllt Stein,
Schere zerschneidet Papier,
Stein zerschlägt Schere.
Formulieren Sie für dieses Spiel eine Auszahlungsmatrix und berechnen Sie damit
die optimale Strategie der beiden Spieler.

Literatur
John von Neumann, Collected Works, Volume VI : Zur Theorie der Gesellschafts-
spiele, Seite 1, Pergamon Press, 1963.
W.H. Press, S.A. Teukolsky, W.T. Vetterling, B.P. Flannery, Numerical Recipes in
C: The Art of Scientific Computing, Cambridge University Press, 1992.
W. Vogel, Lineares Optimieren, Akademische Verlagsgesellschaft, 1967.
Kapitel 2
Lineare Gleichungen

Viele Phänomene der Physik können durch lineare Gleichungen beschrieben wer-
den. Doppelte Ursache gibt doppelte Wirkung – dieser Sachverhalt erlaubt es, solche
Probleme mathematisch zu lösen. Häufig lassen sich lineare Systeme durch Vekto-
ren beschreiben, Vektoren mit manchmal wenigen, manchmal sehr vielen Kompo-
nenten. In den Bewegungsgleichungen tauchen dann Matrizen auf, deren Eigen-
werte und Eigenvektoren die Energien und die stationären Zustände des Systems
beschreiben. Jede andere Form der Bewegung ist eine Überlagerung dieser Eigen-
zustände.
Es gibt eine Vielzahl von numerischen Methoden, lineare Gleichungen zu lösen.
Diese weit entwickelten Standard-Algorithmen werden in den Lehrbüchern zur nu-
merischen Mathematik ausführlich erklärt. Wir haben in diesem Kapitel, abgesehen
vom Hofstadter-Schmetterling, die Beispiele so gewählt, daß sie sich mit vordefi-
nierten Funktionen untersuchen lassen. Beim elektrischen Netzwerk geht es darum,
ein lineares Gleichungssystem zu lösen, und außerdem können wir noch einmal die
Fouriertransformation anwenden. Andere Fragestellungen, die sowohl der Mecha-
nik als auch der Quantenphysik entstammen, führen uns auf Eigenwertgleichungen,
also auf das Problem, Eigenwerte und Eigenvektoren von eventuell großen Matrizen
zu bestimmen.

2.1 Quantenoszillator
Die Bewegungsgleichung der Quantenmechanik, die Schrödinger-Gleichung, ist li-
near: Jede Überlagerung von Lösungen ist wieder eine Lösung. Deshalb hat man Er-
folg mit dem Verfahren, die Gleichung in Raum und Zeit durch einen Produktansatz
zu separieren und später diese Produktlösungen zu überlagern. Der räumliche Anteil
ist die sogenannte stationäre Schrödinger-Gleichung – eine Eigenwertgleichung, die
in der Ortsdarstellung die Form einer linearen Differentialgleichung hat. Die Lösun-
r r
gen dieser Gleichung sind Wellenfunktionen ( ), die jedem Ort eine komplexe
Zahl zuordnen, und zwar beschreiben sie diejenigen Zustände des physikalischen
Systems, deren Aufenthaltswahrscheinlichkeit j rj
( ) 2 sich zeitlich nicht ändert.
Zur numerischen Lösung der Schrödinger-Gleichung kann man entweder die linea-
re Differentialgleichung näherungsweise diskretisieren und in Matrixform bringen,
52 2 Lineare Gleichungen

r
oder man kann ( ) nach einem vollständigen Satz von Wellenfunktionen 'n ( ) r
entwickeln und nur endlich viele davon betrachten. In beiden Fällen führt die stati-
onäre Schrödinger-Gleichung auf eine Eigenwertgleichung einer endlichen Matrix.
Wir wollen den zweiten Ansatz am Beispiel des anharmonischen Oszillators studie-
ren.

Physik
Wir behandeln ein eindimensionales Problem, nämlich ein Teilchen der Masse m
im quadratischen Potential V (q ) = 12 m! 2 q 2 . Dabei ist q die Ortskoordinate des
Teilchens. Der Hamiltonoperator dazu lautet in dimensionsloser Form

H0 = 12 p2 + q2 :
(2.1)
p
Dabei werden Energien in Einheiten von ~! , Impulse in Einheiten von ~m! und
p
Längen in Einheiten von ~=(m! ) gemessen. Die Eigenzustände j von H0 fin- ji
det man in jedem Lehrbuch der Quantenmechanik, sie lauten in der Ortsdarstellung:

'j (q) = 2j j !
p e 1
2
1 2
2 q Hj (q) ; (2.2)

wobei Hj (q ) die Hermitepolynome sind . Es gilt:

H0jj i = "0j jj i mit "0j = j + 21 und j = 0; 1; 2; : : : :

"0j sind die Energien der Eigenzustände von H0, und die Matrix hj jH0 jki ist diago-
nal, weil die Eigenwerte nicht entartet sind.
Wir fügen nun zu H0 ein anharmonisches Potential hinzu,

H = H0 + q4; (2.3)

hj ji
und suchen die Matrix j H k . Dazu ist es zweckmäßig, q als Summe von Erzeu-
gungs- und Vernichtungsoperatoren ay und a zu schreiben:

q = p1 (ay + a) ; (2.4)
2
wobei a und ay die folgenden Eigenschaften haben:
p
ay jj i = pj + 1 jj + 1i ;
aj0i = 0 und ajj i = j jj 1i fur j > 0 : (2.5)
2.1 Quantenoszillator 53

Die Matrixdarstellung von q im Raum der ungestörten Zustände jj i liefert also die
Tridiagonalmatrix
p p p
Qjk = hj jqjki = p1 k + 1 j;k+1 + p1 k j;k 1 = 21 j + k + 1 jk jj;1 :
2 2
(2.6)
Die Näherung, die wir jetzt vornehmen, besteht darin, diese unendlich-dimensionale
Matrix nur für j; k = 0; 1; :::; n 1 zu definieren. Der Hamiltonoperator H =

H0 + q4 , bzw. seine Matrixdarstellung, soll ebenfalls als n n-Matrix genähert
werden, wobei H0 durch die Diagonalmatrix mit den Elementen j + 12 und q 4 durch
das vierfache Matrixprodukt von Qjk mit sich selbst dargestellt wird. Den Fehler
der Approximation kann man abschätzen, indem man die Eigenwerte von H für
verschiedene n-Werte miteinander vergleicht.

Algorithmus
Die obigen Matrizen lassen sich in Mathematica besonders kompakt definieren.
hjji
j q k ist nach Gleichung (2.6)
q[j_,k_]:= Sqrt[(j+k+1)]/2 /; Abs[j–k]==1
q[j_,k_]:= 0 /; Abs[j–k] != 1
Die Konstruktion lhs := rhs /; test bedeutet, daß die Definition nur dann
benutzt wird, wenn der rechte Ausdruck wahr ist, also den Wert True hat. Die
Matrix q wird als Liste von Listen definiert
q[n ]:= Table[q[j,k], fj,0,n–1g, fk,0,n–1g]
und H0 ergibt sich gemäß Gleichung (2.2) zu
h0[n ]:= DiagonalMatrix[Table[j+1/2, fj,0,n–1g]]
Damit läßt sich H schreiben als
h[n ]:= h0[n] + lambda q[n].q[n].q[n].q[n]
Die Eigenwerte von H erhält man mit Eigenvalues[...], entweder algebra-
isch (nur für kleine n-Werte) oder numerisch mit Eigenvalues[N[h[n]]],
wobei lambda zuvor ein numerischer Wert zugewiesen werden muß.
54 2 Lineare Gleichungen

Ergebnisse
Der Aufruf h[4] // MatrixForm liefert die Hamiltonmatrix
0 1 + 43 0 p32 1
BB 2 q03 C
BB 0 3 + 15
2 4 0 3 2 C
C:
@ p32
q0 5 + 27
2 4 0 CA
(2.7)

0 3 32 0 7 15
2 + 4
Deren Eigenwerte lauten
p p p p
6 + 15 2 2 2 + 12 + 272 und 10 + 15 2 2 2 + 272 : (2.8)
4 4
Diese vier Eigenwerte sind in Abbildung 2.1 als Funktion von zu sehen. Ohne

9
8
7
6
Energie

5
4
3
2 2.1 Näherungswerte für die un-
1 tersten vier Energie-Eigenwerte
des Quantenoszillators mit
0 0.2 0.4 0.6 0.8 1 der Anharmonizität q 4 in
lambda Abhängigkeit von .

Störung ( = 0) erhalten wir die Energien 12 ; 23 ; 25 und 72 des harmonischen Os-

zillators. Mit wachsender Störung heben die oberen beiden Eigenwerte sehr stark
von den unteren ab. Dies ist ein Effekt der endlichen Größe der Matrizen. Der Ope-
ji ji
rator q 4 verknüpft den Zustand j mit j 4 , und daher sollten die Matrixelemente
hj j i
j q4 j 4 in der Hamiltonmatrix h[n] enthalten sein, wenn die Energie "j ei-
nigermaßen genau berechnet werden soll. Auf jeden Fall ist es nicht verwunderlich,
wenn die Eigenwerte "n ; "n 1 und "n 2 große Abweichungen vom exakten Resultat
haben.
Wie gut ist die Näherung? Dies zeigt Abbildung 2.2 am Beispiel der Grundzu-
standsenergie "0 . Für die Anharmonizität mit = 0:1 ist "0 als Funktion von 1=n
aufgetragen, und zwar für n = 7; :::; 20. Diese Funktion ist offenbar nicht mono-
ton. Obwohl wir ihr asymptotisches Verhalten nicht kennen, läßt sich der Wert für
n !1 sehr gut angeben. Mit den Befehlen
2.1 Quantenoszillator 55

0.55915

0.55914
E0(n)

0.55913
2.2 Näherungswerte für die
0.55912 Grundzustandsenergie des an-
harmonischen Oszillators als
0.55911
Funktion der Matrixdimension
0.06 0.08 0.1 0.12 0.14 n für n = 7; 8; : : : ; 20, aufge-
1/n tragen über 1=n.

mat = N[h[n] /. lambda –> 1/10, 20];

li = Sort[Eigenvalues[mat]]; li[[1]]

erhalten wir für n = 20 und n = 40 die Werte

"0 (20) = 0:559146327396 : : : ;

"0 (40) = 0:559146327183 : : : :
Für n = 20 haben wir also eine Genauigkeit von etwa neun relevanten Stellen.
Höhere Energien sind nur mit geringerer Genauigkeit bestimmt; wir erhalten

"10(20) = 17:333 : : : ;
"10(40) = 17:351 : : : ;
also nur eine Genauigkeit von drei Stellen.
Im Bild 2.1 haben wir nur vier Niveaus für unsere Näherung berücksichtigt. Da-

10
9
8
7
Energie

6
5
4
3
2
1 2.3 Die fünf niedrigsten
Energie-Eigenwerte als Funk-
0 0.2 0.4 0.6 0.8 1 tion des Vorfaktors der
lambda Anharmonizität.
56 2 Lineare Gleichungen

her sind die oberen zwei Energien völlig falsch dargestellt. Im Bild 2.3 dagegen ha-
ben wir zwanzig Niveaus mitgenommen. In diesem Fall gibt die numerische Lösung
der Eigenwertgleichung ein sehr genaues Ergebnis für die fünf niedrigsten Energi-
en. Sowohl die Energien als auch deren Abstände wachsen mit dem Vorfaktor der
Anharmonizität.

Übung
Wir betrachten ein Quanten-Teilchen in einer Dimension im Doppelmuldenpotenti-
al. Der Hamiltonoperator sei in dimensionsloser Form

H = p2 q :
2 4
2q2 + 10
1. Zeichnen Sie das Potential.
2. Berechnen Sie die vier tiefsten Energieniveaus.
3. Zeichnen Sie die Wellenfunktionen der vier tiefsten Niveaus zusammen mit dem
Potential.
4. Man kann auch die Matrixelemente von q 2 und q 4 direkt angeben, indem man die
Operatoren analog zu (2.4) durch a und ay ausdrückt. Verbessert das die Ergeb-
nisse?

Literatur
J. Schnakenberg, Algorithmen in der Quantentheorie und Statistischen Physik, Zim-
mermann-Neufang, 1995.
F. Schwabl, Quantenmechanik, Springer Verlag, 1988.

2.2 Elektrisches Netzwerk

Das Ohmsche Gesetz ist eine lineare Beziehung zwischen Strom und Spannung. Es
gilt sogar noch für monofrequente Wechselströme und Wechselspannungen, wenn
Kondensatoren und Spulen durch komplexe Widerstände dargestellt werden. Auch
für allgemeine passive elektrische Netzwerke bleiben die Gleichungen linear, wenn
man für Ströme und Spannungen eine geeignete Darstellung im Raum der kom-
plexen Zahlen wählt. Sie können bei vorgegebener Frequenz relativ leicht mit dem
Computer gelöst werden, und mit Hilfe der Fouriertransformation kann dann zu je-
dem Eingangssignal die Ausgangsspannung berechnet werden.
2.2 Elektrisches Netzwerk 57

Physik
Wir betrachten eine Wechselspannung V (t), den zugehörigen Wechselstrom I (t)
und schreiben beide als komplexwertige Funktionen:
V (t) = V0 ei!t ;
I (t) = I0 ei!t ; (2.9)
wobei V0 und I0 komplexe Größen sind, deren Phasendifferenz gerade angibt, wie
stark die Strom- der Spannungsschwingung vor- oder nacheilt. Eigentlich hat nur
der Realteil von (2.9) eine physikalische Bedeutung, aber die Phasenbeziehungen
sind in komplexer Schreibweise besonders leicht zu formulieren. Das Ohmsche Ge-
setz lautet damit
V0 = Z I0 (2.10)
mit einem komplexen Widerstand Z . Für einen ohmschen Widerstand R, für eine
Kapazität C und für eine Induktivität L gilt
1 ; Z = i!L ;
Z = R ; Z = i!C (2.11)

wobei R; C und L reelle Größen sind, z. B. in den Einheiten Ohm, Farad und Hen-
ry. Für ein elektrisches Netzwerk gelten die folgenden Erhaltungssätze, auch als
Kirchhoffsche Regeln bekannt:
1. Wegen der Ladungserhaltung ist an jedem Knoten die Summe der einlaufenden
Ströme ist gleich der Summe der auslaufenden Ströme.
2. Entlang eines jeden Weges addieren sich die Teilspannungen über jedem Bau-
element zu der Gesamtspannung über den Weg.
Diese beiden Bedingungen ergeben zusammen mit dem Ohmschen Gesetz ein Glei-
chungssystem, das alle unbekannten Ströme und Spannungen bestimmt.
Als einfaches Beispiel betrachten wir einen L-C -Schwingkreis, der mit einem
Widerstand R in Serie geschaltet ist (Bild 2.4). Ve und Va seien die komplexen
Amplituden der Eingangs- und Ausgangswechselspannung mit der Kreisfrequenz
!, und IR; IC und IL seien die Amplituden der Ströme, die nach dem Einschwin-
gen dieselbe Frequenz ! wie die Eingangsspannung haben. Damit gelten folgende
Gleichungen:
Spannungsaddition : VR + Va = Ve ;
Stromerhaltung : IR = IC + IL ;
Ohmsches Gesetz : VR = R IR ; (2.12)
1 I ;
Va = i!C C
Va = i!L IL :
58 2 Lineare Gleichungen

R IR

IC IL

Ve C L Va

2.4 Serienschaltung von ohmschem

Widerstand und L-C -Schwingkreis.

Für eine gegebene Eingangsspannung Ve bestimmen diese 5 Gleichungen die 5 Un-

bekannten VR ; Va ; IR ; IC und IL , die man in diesem einfachen Fall leicht ohne Com-
puter lösen kann. Der Betrag der Ausgangsspannung Va nimmt unabhängig von R
jeweils ein Maximum bei ! = pLC 1 an; bei dieser Frequenz ist der Widerstand des
Schwingkreises unendlich groß.
Im Bild 2.5 haben wir die Schaltung erweitert und einen Serienkreis hinzugefügt.
Wenn ein Kondensator C und eine Induktivität L in Reihe geschaltet sind, so ist
der Widerstand bei der Frequenz ! = pLC 1 minimal. Daher erwarten wir für diese
Schaltung bei dieser Frequenz eine maximale Ausgangsspannung. Dieses Netzwerk

C L
R

Ve C L Va

2.5 Serienschaltung von R-C -L-

Glied und L-C -Schwingkreis.

wird durch die folgenden zwei Gleichungen beschrieben.

1 + i!L + V = V ;
IR R + i!C

Spannungsaddition:
Stromerhaltung:
a
IR = i!C + i!L Va ;
1
e
(2.13)

wobei das Ohmsche Gesetz schon eingefügt wurde. Überraschenderweise ist das
Ergebnis für Va (! ) ganz anders als das, was wir (als Nichtelektroniker) erwar-
tet haben. Es entstehen nämlich zwei neue Resonanzen ober- und unterhalb von
! = pLC 1 , dort wird V bei kleinen Widerständen R sehr viel größer als V . Das
a e
kann man sich durch folgende Überlegung plausibel machen: Für kleine Frequen-
2.2 Elektrisches Netzwerk 59

zen wird das Verhalten des Parallelkreises durch die Induktivität dominiert. Ver-
nachlässigen wir die Kapazität im Parallelkreis einmal völlig, so haben wir es mit
einer Serienschaltung aus den Elementen R-C -L-L zu tun. Weil die gesamte Induk-
tivität jetzt 2L beträgt, erhalten wir eine Resonanz bei !1 = p21LC . Wird dagegen
für hohe Frequenzen im Parallelkreis nur die Kapazität betrachtet, so ergibt sich
eine R-C -L-C Serienschaltung mit einer Gesamtkapazität von C=2 und dement-
q
sprechend eine Resonanzfrequenz von !2 = 2
LC . Im Ergebnisteil werden wir
diese Näherung mit den exakten Resultaten vergleichen.
Bisher haben wir nur monofrequente sinusförmige Spannungen und Ströme be-
trachtet. Nun wollen wir ein beliebiges periodisches Eingangssignal Ve (t) an die
Schaltung anlegen. Das Netzwerk ist linear, also erhält man aus überlagerten Ein-
gangssignalen die entsprechend überlagerten Ausgangsspannungen. Insbesondere
kann man jede periodische Eingangsspannung Ve (t) mit der Periode T in eine Fou-
rierreihe entwickeln:
X
1
Ve(t) = Ve(n) e2 i n t=T : (2.14)
n= 1
Für jeden Summanden mit der Amplitude Ve(n) erhält man aus der Gleichung (2.13)
für die Frequenz !n = 2 n=T eine Ausgangsspannung Va (!n ) = Va(n) , so daß
das gesamte Ausgangssignal gegeben ist durch
X
1
Va (t) = Va(n) e2 i n t=T : (2.15)
n= 1

Algorithmus
In Mathematica können die Gleichungen (2.12) und (2.13) direkt eingegeben wer-
den. Obwohl man beide Systeme sofort per Hand lösen kann, wollen wir das Prinzip
doch an den einfachen Beispielen demonstrieren. Mit der Normierung Ve = 1 lauten
die Gleichungen (2.12) daher
gl1 = {vr + va == 1, ir == ic + il, vr == ir r,
va == ic/(I omega c), va == I omega L il}
Man beachte, daß das erste Gleichheitszeichen = eine Zuordnung bedeutet, während
== einen logischen Ausdruck ergibt. Der Variablen gl1 wird also eine Liste von
Gleichungen zugeordnet. Mit
Solve[gl1, {va, vr, ir, ic, il}]
60 2 Lineare Gleichungen

wird das Gleichungssystem nach den angegebenen Variablen aufgelöst. Weil Glei-
chungssysteme im allgemeinen mehrere Lösungen haben, liefert Solve eine Li-
ste mit Listen von Regeln. Da es hier aber nur eine Lösung gibt, greifen wir mit
Solve[...][[1]] davon die erste – und in diesem Fall die einzige – heraus.
Als Anwendung für eine nicht-sinusförmige Eingangsspannung Ve (t) wählen wir
eine Sägezahnspannung mit der Periode T , die wir an N äquidistanten Zeitpunkten
abtasten, um die diskrete Fouriertransformation benutzen zu können. Wir definieren
also diskrete Spannungswerte durch

ar = Ve (tr ) Ve ((r 1) T=N ) ; r = 1; :::; N;

und erhalten durch Anwendung der inversen Fouriertransformation die Koeffizien-
ten bs mit der Eigenschaft

X
N
ar = p1 bs e2i(s 1)(r 1)=N
N s=1

X
bzw.
N
V (t ) = p1
e r bs ei T (s
2
1)tr :
N s=1
Nicht die Fouriertransformation direkt sondern deren Inverses müssen wir hier be-
nutzen, damit das Vorzeichen im Exponenten der e-Funktion mit Gleichung (2.9)
übereinstimmt. Obwohl die Autoren von Mathematica erklären, sie wollten, was
diese Vorzeichenwahl bei der Fouriertransformation angeht, der Konvention der
p
Physiker folgen, haben sie doch genau das Gegenteil verwirklicht.
Die Amplitude bs = N gehört also zur Frequenz !s = 2T (s 1). Am Ausgang
wird jede Amplitude bs mit der Ausgangsspannung Va (!s ) multipliziert, die wir
vorher mit Solve[...] aus den obigen Gleichungen erhalten haben. Allerdings
gilt das nur für s = 1; :::; N=2. Höhere Frequenzen geben eine schlechte Näherung
für Ve (t), wie im Abschnitt 1.3 ausführlich gezeigt wurde. Man muß durch bs =
bs N die hohen Frequenzen in niedrige negative verschieben, bevor man mit Va(!s )
transformieren darf. Die transformierten Fourierkoeffizienten sind also

bts = bs Va(!s ) ; s = 1; :::; N2 ;

bts = bs Va(!s N ) ; s = N2 + 1; :::; N:
Die Rücktransformation, in diesem Fall also die Fouriertransformation, liefert damit
das Ausgangssignal.
2.2 Elektrisches Netzwerk 61

Ergebnisse
Die Lösung des Gleichungssystems (2.12), das die in der Abbildung 2.4 gezeig-
te Serienschaltung aus ohmschem Widerstand und L-C -Schwingkreis beschreibt,
steht im Mathematica-Programm in der Variablen vas ; in lesbarer Form lautet sie

Va (!) = i!L Ri!L + RCL!2 :

p
Offensichtlich hat das Netz eine Resonanz bei !r = 1= LC , wie man auch in der
Abbildung 2.6 für verschiedene R-Werte sieht.
Wir haben L = 1mH und C = 1F gewählt, was eine Resonanzfrequenz !r
von 31622:8 s 1 ergibt. Für R = 0 erhält man Va (! ) = 1, also keine Resonanz,
während für R ! 1 ein scharfes Spannungsmaximum an der Stelle der Resonanz-
frequenz entsteht. Bei !r geht die Phase der Ausgangsspannung von 2 nach 2 .

1 1.5
0.8 1
Phase(Va)

0.5
0.6
|Va|

0
0.4 -0.5
0.2 -1
-1.5
0 20000 30000 40000
20000 30000 40000
omega omega

2.6 Frequenzabhängigkeit von Betrag und Phase der Ausgangsspannung Va (! ) für das
Netzwerk aus Abbildung 2.4. Die Kurven entsprechen den Widerständen R = 100 ,
300 , 900 , und 2700 . Je größer der Widerstand, um so schärfer ist die Resonanz.

Legen wir nun die Sägezahnspannung Ve (t) an dieses Filter an, so wird das Er-
gebnis natürlich von der Schärfe der Resonanz bei !r und von dem Verhältnis der
Grundfrequenz der Sägezahnspannung zur Resonanzfrequenz abhängen. Wir para-
metrisieren die Periode T von Ve (t) deshalb in der Form 2T = f !r ; f gibt also
das Verhältnis von Eingangsgrundfrequenz zu Resonanzfrequenz an. Für f = 1
und einer entsprechend schmalen Resonanzkurve sollte aus der sägezahnförmigen
Schwingung gerade eine Sinusschwingung mit der Frequenz ! = !r herausgefiltert
werden.
Für f < 21 und z. B. R = 200 wird im wesentlichen nur das Vielfache von 2T in
der Nähe von !r herausgefiltert. Dagegen werden für f > 1 und breiter Resonanz
62 2 Lineare Gleichungen

1 0.6
0.4
0.5
0.2

Va(t)
Ve(t)

0 0
-0.2
-0.5
-0.4
-1 -0.6
0 0.5 1 1.5 2 2.5 3 0 0.5 1 1.5 2 2.5 3
t/T t/T

2.7 Links die ursprüngliche Sägezahnspannung Ve (t) und rechts die Spannung Va (t) am
Ausgang des Filters für f = 1 und R = 2700 .

alle Harmonischen von 2T mitgenommen, es entsteht ein verzerrtes Eingangssignal.

Diese Erwartung wird in den Abbildungen 2.7 und 2.8 bestätigt.

0.3 0.8
0.2 0.6
0.1 0.4
Va(t)
Va(t)

0 0.2
0
-0.1
-0.2
-0.2
-0.4
-0.3 -0.6
0 0.5 1 1.5 2 2.5 3 0 0.5 1 1.5 2 2.5 3
t/T t/T

2.8 Links die Ausgangsspannung für f = 1=3 und R = 200 , rechts das verzerrte Ein-
gangssignal, das sich mit f = 3 und R = 5 ergibt.

Für das zweite Beispiel, die Serienschaltung von R-C -L-Glied und L-C -Schwing-
kreis, liefert das Mathematica-Programm, wiederum mit Ve = 1, die Lösung:

R
CL! 2
L
C
Va =
CL! 2 + (CL! 2 1)(1 CL!2 + iCR!)
Ve C L Va

Für R = 0, wenn also der ohmsche Widerstand gleich null und damit die Schaltung
2.2 Elektrisches Netzwerk 63

s
verlustfrei ist, verschwindet der Nenner bei
p
! = 3 2LC 5 :
Mit den Werten L = 1mH , C = 1F divergiert Va also bei den Frequenzen ! =
19544 s 1 und ! = 51166:7 s 1 . Wir p
p sehen, daß unsere vorherige Abschätzung
der beiden Resonanzen bei !1 = 1= 2LC = 22360 s 1 bzw. !2 = 2=LC =
44720 s 1 nicht ganz falsch war.
3
2.5
2
|Va|

1.5 2.9 Betrag der Ausgangsspannung

1 für das Netzwerk aus Serien-
0.5
und Parallel-Kreis. Die zugehöri-
gen Widerstandswerte sind von
10000 30000 50000 70000 oben nach unten R = 10 , 30
omega und 90 .

Abbildung 2.9 zeigt Va (! ) für R = 10; 30 und 90 . Für jeden Wert des Widerstan-
des R ist bei der Frequenz ! = pLC 1 die Ausgangsspannung gleich dem Eingangs-
signal, Va = Ve . Erst bei kleinen Widerständen werden die beiden Resonanzen
sichtbar.
Abschließend wollen wir die Leistung berechnen, die bei der Frequenz ! vom
Widerstand R in Wärme umgesetzt wird. Auch hierbei erweist sich die komplexe
Darstellung von Strom und Spannung als sehr vorteilhaft. Die Rechnung – zunächst
für ein allgemeines Bauelement mit komplexem Widerstand Z , das vom Strom
I (t) = IZ ei!t durchflossen wird und an dem die Spannung V (t) = VZ ei!t abfällt
– verläuft folgendermaßen: Die Leistung P ist das Zeitmittel des Produktes aus den
Realteilen des Stroms und der Spannung, also P = Re I (t) Re V (t). Wegen der
rein harmonischen Zeitabhängigkeit gilt aber Re I (t) = Im I (t + 2! ) und analog
für V (t). Damit erhalten wir

P = 12 Re I (t) Re V (t) + Im I (t) Im V (t)

= 14 I (t) V (t) + I (t) V (t)
= 41 (IZ VZ + IZ VZ )
= 21 jIZ j2 Re Z ; (2.16)
64 2 Lineare Gleichungen

wobei wir am Schluß VZ = Z IZ eingesetzt haben. Für den ohmschen Widerstand

j j
R beträgt die Leistung demnach P (!) = IR (!) 2 R=2 . Wir vergleichen dies mit
der Leistung P0 , die sich ergibt, wenn alle Spulen und Kondensatoren in unserer
Schaltung überbrückt werden, wenn also die Eingangsspannung Ve direkt am Wi-
j j
derstand R anliegt, so daß man IR = Ve =R und damit P0 = Ve 2 =(2R) erhält.
Das Verhältnis der Leistungen P (! )=P0 ist für R = 10 in der Abbildung 2.10
gezeigt. Bei den beiden Resonanzfrequenzen scheinen Spulen und Kondensatoren
völlig durchlässig zu sein, während bei ! = pLC
1 der Parallelkreis einen unendli-
chen Widerstand bietet.

0.8

0.6
P/P0

2.10 Die Leistung P (! ), die am

0.4

0.2 ohmschen Widerstand R = 10

verbraucht wird, bezogen auf die-
0 jenige Leistung P0 , die umgesetzt
10000 30000 50000 70000
wird, wenn die Eingangsspannung
omega
direkt an R anliegt.

Übung
Fügen Sie im zweiten R-C -L-Netzwerk (Bild 2.5) einen ohmschen Widerstand R
zum parallelen L-C -Kreis hinzu, und zwar parallel zu Kondensator und Spule.

1. Berechnen und zeichnen Sie Va (! ).

2. Welche Form hat eine periodische Rechteckspannung nach dem Durchgang durch
dieses Filter?

3. Wie groß ist die Verlustleistung an den beiden Widerständen als Funktion von ! ?

Literatur
R. E. Crandall, Mathematica for the Sciences, Addison Wesley, 1991.
2.3 Kettenschwingungen 65

2.3 Kettenschwingungen
Die Bewegung eines Teilchens im quadratischen Potential wird bekanntlich durch
eine besonders einfache lineare Differentialgleichung beschrieben. Wenn mehre-
re Teilchen durch solche linearen Kräfte miteinander wechselwirken, kann deren
Bewegung ebenfalls aus linearen Bewegungsgleichungen berechnet werden. Aller-
dings erhält man dann mehrere solcher Gleichungen, die miteinander verkoppelt
sind. Dieses lineare Gleichungssystem läßt sich durch Diagonalisierung einer Ma-
trix lösen. Ein schönes Beispiel dafür ist die lineare Kette mit verschiedenen Mas-
sen. Sie ist ein einfaches Modell für die Berechnung von Gitterschwingungen in ei-
nem Kristall. Die Eigenwerte einer Matrix geben die Energiebänder der Phononen
an, während die Eigenvektoren Aussagen über die Schwingungsformen der Kri-
stallbausteine machen. Durch Überlagerung solcher Eigenschwingungen kann jede
mögliche Bewegung des Modell-Festkörpers dargestellt werden.

Physik
Wir betrachten eine Kette, bestehend aus punktförmigen Massen m1 und m2 , die
wir der Einfachheit halber als leichte bzw. schwere Atome bezeichnen. Die Teilchen
seien so angeordnet, daß auf jeweils drei leichte Atome ein schweres folgt. Die Ele-
mentarzelle der Länge a enthält also vier Atome. Es sollen nur nächste Nachbarn
miteinander wechselwirken. Wir beschränken unsere Betrachtung auf kleine Aus-
lenkungen, das heißt, die Kräfte sollen lineare Funktionen der Massenverschiebun-
gen sein wie in dem nachfolgend abgebildeten Federmodell.

a
m1 m1 m1 m2
..... .....

u n-1 rn sn tn un rn+1
2.11 Lineare Kette, bestehend aus zwei Atomsorten, die durch elastische Kräfte untereinan-
der verbunden sind.

Zur Beschreibung der longitudinalen Schwingungen numerieren wir die Einheits-

zellen fortlaufend und betrachten die Zelle mit der Nummer n. Innerhalb dieser
Zelle seien rn ; sn ; tn die Auslenkungen der leichten Atome aus der Ruhelage, und
un sei die Auslenkung des schweren Atoms aus der Ruhelage. Dann lauten die Be-
wegungsgleichungen

m1 rn = f (sn rn) f (rn un 1 )

66 2 Lineare Gleichungen

= f (sn + un 1 2rn ) ;
m1 sn = f (tn + rn 2sn) ; (2.17)
m1 tn = f (un + sn 2tn ) ;
m2 un = f (rn+1 + tn 2un ):
f ist die Federkonstante. In einer unendlich langen Kette gelten diese Gleichungen
2
für jede Elementarzelle n Z. Für die endlich lange Kette aus N Elementarzellen
nehmen wir periodische Randbedingungen an, d. h. wir stellen uns eine ringförmige
Anordnung aus N identischen Zellen vor. Da sich die Energie der Kette bei Ver-
schiebung um die Länge a nicht ändert und folglich die Bewegungsgleichungen
f
invariant sind gegenüber den Translationen rn ; sn ; tn ; un g!f
rn+k ; sn+k ; tn+k ;
g
un+k , k = 1; 2; : : : ; N , kann eine Lösung der Gleichung (2.17) durch Fourier-
transformation gefunden werden. Wir machen daher den Ansatz
0 rn(t) 1
@ stnn((tt)) C
xn(t) = B A = S(q) eiqani!t ; (2.18)
u n (t )
wobei wegen der periodischen Randbedingungen q nur die Werte q 2
N + 1; : : : ; N annehmen kann. Dann gilt
= Na ; =
2 2
x n = !2 xn; xn1 = eiqa xn : (2.19)

Dies in Gleichung (2.17) eingesetzt ergibt

0 2f f 0 fe 1 iqa 0 m1 0 0 0 1
B
@ 0f 2f f 0 C 2 B 0 m1 0 0 C
f 2f f A S (q) = ! @ 0 0 m1 0 A S (q);
feiqa 0 f 2f 0 0 0 m2
(2.20)
also eine verallgemeinerte Eigenwertgleichung vom Typ

FS = MS : (2.21)

Dabei ist M die Massenmatrix, und wir suchen bei vorgegebenem q die Eigenwerte
S
(q) = !2(q) und die zugehörigen Normalmoden (q). In unserem Fall läßt sich
die Massenmatrix leicht invertieren, und Gleichung (2.21) ist offensichtlich äquiva-
lent zu
M 1F = : S S (2.22)
Allerdings ist M 1 F keine hermitesche Matrix. Daß die Eigenwerte dennoch
reell und nichtnegativ sind, erkennt man durch folgende Umformung von Gleichung
2.3 Kettenschwingungen 67

(2.21). Wir multiplizieren sie von links mit M , der zu M 2 inversen Matrix, und
1 1
2

erhalten
M FM M S = M S :
1
2
1
2
1
2
1
2 (2.23)
Das ist eine gewöhnliche Eigenwertgleichung für die hermitesche und positiv semi-
definite Matrix M 2 F M 2 mit dem Eigenvektor M 2 .
1 1 1
S
x S
Die so gewonnenen Eigenschwingungen n (t) = ` (q ) eiq ani!` t sind spe-
zielle komplexwertige Lösungen der Bewegungsgleichungen (2.17). Analog zu den
elektrischen Filtern (Abschnitt 2.2) erhält man die allgemeine Lösung durch Über-
lagerung der Eigenschwingungen. Die zu (2.20) konjugiert komplexe Gleichung lie-
fert mit q! S S
q , daß mit (q) auch ( q) Eigenvektor zu demselben Eigenwert
ist. Die allgemeine reelle Lösung von (2.17) hat deshalb die Form
X :
xn (t) = S `(q ) eiq an c` ei! t + c ` e
` i!` t (2.24)
;`
Die noch freien Koeffizienten c` werden durch die Anfangsbedingungen festgelegt.

Algorithmus und Ergebnisse

Die 4 4-Matrix (2.22) stellt keine besondere Herausforderung an eine analyti-
sche Lösung der Eigenwertgleichung dar. Aber bei mehreren Atomsorten oder dem
entsprechenden zweidimensionalen Problem werden die Matrizen so groß, daß nur
noch eine numerische Bestimmung der Schwingungsmoden möglich ist. Letzteres
wollen wir an unserem einfachen Beispiel demonstrieren.
Zunächst schreiben wir die Matrizen F und M in Mathematica-Form, wobei a =
1 gewählt wurde,
mat1 = { { 2f , –f , 0 , –f*Exp[–I q]},
{ –f , 2f , –f , 0 },
{ 0 , –f , 2f , –f },
{ –f*Exp[I q], 0 , –f , 2f } }

massmat = DiagonalMatrix[{m1,m1,m1,m2}]
Damit bilden wir das Produkt mat2 = Inverse[massmat].mat1 . Mathe-
matica ist zwar in diesem Fall noch in der Lage, mit Eigenvalues[mat2] die
Eigenwerte allgemein anzugeben, die Rechnung ist aber langwierig und das Er-
gebnis besteht aus verschachtelten zweiten und dritten Wurzeln, so daß wir eine
numerische Berechnung vorgezogen haben.
eigenlist = Table[{x, Chop[Eigenvalues[
mat2 /.{f–>1.,m1–>0.4,m2–>1.0,q–>x}]]},
{x,–Pi,Pi,Pi/50}]
68 2 Lineare Gleichungen

Dieser Befehl liefert in kurzer Zeit eine Liste von q -Werten und den zugehörigen
vier Frequenzquadraten.
Flatten[ Table[
Map[{#[[1]],Sqrt[#[[2,k]]]}&, eigenlist],
{k,4}], 1]
macht daraus eine Liste von (q -! )-Paaren, die in Abbildung 2.12 mit ListPlot
gezeichnet wurden. Es entstehen also vier Bänder von erlaubten Frequenzen der Git-

3
2.5
2
omega

1.5
1
0.5
0 2.12 Wellenzahl q und die zugehörigen
-Pi -Pi/2 0 Pi/2 Pi vier Frequenzen der Eigenschwingungen
q der linearen Kette aus Bild (2.11).

terschwingungen. Der unterste Zweig stellt die sogenannten akustischen Phononen

dar, bei denen benachbarte Atome fast immer in die gleiche Richtung schwingen.
Für q = 0 wird die gesamte Kette nur als Ganzes verschoben, was keine Energie
kostet (! = 0). Bei den drei oberen Zweigen, den optischen Phononen, schwingen
viele Atome gegeneinander; das kostet auch bei q = 0 Energie.
Die einzelnen Auslenkungen kann man an den Eigenvektoren der Matrix M 1 F
ablesen. Abbildung 2.13 zeigt die vier Eigenschwingungen für q = 0. Überra-
schenderweise bleiben im dritten Zweig das schwere und ein leichtes Atom stehen,
während die beiden anderen Massen gegeneinander schwingen.

S4 (0)

S3 (0)

S2 (0)

S1 (0)

2.13 Eigenschwingungen der Kette für q = 0.

2.4 Hofstadter-Schmetterling 69

Übung
Betrachten Sie die zweidimensionalen Vibrationen Ihres Einfamilienhauses. Fünf
gleiche Massen m sind durch Spiralfedern gekoppelt, und das Potential zwischen

benachbarten Massen sei

V (ri ; rj ) = D2 (jri rj j ai j )2 ;
wobei aij der jeweilige Ruheabstand sein soll, also aij = l für die Kanten und das
p
Dach und aij = 2 l für die beiden Diagonalen.
Berechnen Sie für kleine Auslenkungen die Frequenzen der Vibrationen und zeich-
nen Sie die Eigenschwingungen. Besonders eindrucksvoll ist es, wenn Sie eine Ani-
mation der Eigenschwingungen herstellen.

Literatur
H. Goldstein, Classical Mechanics, Addison Wesley, 1980.
W. Ludwig, Festkörperphysik, Akademische Verlagsgesellschaft, 1978.

2.4 Hofstadter-Schmetterling
Lineare Gleichungen können faszinierende Lösungen haben. Das wird besonders
deutlich beim Kristall-Elektron im homogenen magnetischen Feld. Das Spektrum
der Energien des Elektrons hat als Funktion der Stärke des Magnetfeldes eine kom-
plizierte Struktur, die an einen Schmetterling erinnert. Es war Douglas Hofstadter,
der 1976 dieses Problem untersucht hat. Erstaunlicherweise werden in diesem Spek-
trum die Unterschiede zwischen rationalen und irrationalen Zahlen sichtbar. Wir
wollen die quantenmechanische Gleichung für die Energien des Elektrons herlei-
ten und numerisch lösen. Ein kleines Computerprogramm liefert den faszinierenden
Schmetterling.
70 2 Lineare Gleichungen

Physik
Wir modellieren ein Elektron auf einem quadratischen Gitter durch lokalisierte Wel-
lenfunktionen und Hüpfmatrixelemente zwischen nächsten Nachbarn. In solcher
tight-binding Näherung haben die Einteilchenenergien die Form

"(k) = "0(cos kxa + cos ky a) ; (2.25)

wobei a die Gitterkonstante, 2"0 die Breite des Energiebandes und k = (kx ; ky )
der Wellenvektor eines Elektrons ist. Das Magnetfeld wird durch den Peierls-Trick
k p A A
berücksichtigt: ~ wird durch + ec ersetzt, wobei das Vektorpotential und p
der Impulsoperator ist. Für ein Magnetfeld vom Betrag B , das senkrecht zur x-y -
A
Ebene steht, kann man = (0; B x; 0) wählen. Damit erhält man die Schrödinger-
Gleichung
apx ap
"0 cos ~ + "0 cos ~ + aeBx y
~c
'(x; y) = E '(x; y) : (2.26)
Wegen cos = 12 (ei + e i ) und weil eiapx =~ der Translationsoperator ist, der
um eine Gitterkonstante a verschiebt, findet man:
1 " ['(x + a; y) + '(x a; y)+
2 0
eiaeBx=~c '(x; y + a) + e iaeBx=~c '(x; y a) = E '(x; y) : (2.27)
Die kontinuierliche Wellengleichung wird also zur diskreten Gleichung, die '(x; y )
mit den Amplituden an den vier Nachbarplätzen koppelt. Für die y -Abhängigkeit
der Wellenfunktion setzen wir eine ebene Welle an:

'(x; y) = eiy=a (x=a) ; (2.28)

und mit den dimensionslosen Variablen m = x=a und = a2 eB=hc erhält man
schließlich für m (m) die Harper-Gleichung

m 1 + 2 cos(2m + ) m + m+1 = E m : (2.29)

Dabei wird die Energie E in Einheiten von "0 =2 gemessen. Diese diskrete Schrö-
dinger-Gleichung enthält nur noch die Parameter und . bestimmt den Impuls
in y -Richtung, während der Quotient aus magnetischem Fluß a2 B durch die Ein-
heitszelle und einem Flußquantum hc=e ist.
Ein zweidimensionales Gitterelektron im Magnetfeld wurde also auf ein Teilchen
abgebildet, das auf einer Kette im periodischen Cosinus-Potential springt. ist die
Phase des Potentials und spielt keine große Rolle, während das Verhältnis der
Periodenlänge zur Gitterkonstanten (= 1 in den m-Variablen) angibt. Hier sieht man
2.4 Hofstadter-Schmetterling 71

schon den Unterschied zwischen rationalem und irrationalem -Wert: Ist rational,
also = p=q mit ganzen Zahlen p und q , dann ist das Potential kommensurabel
zum Gitter mit der Periode q . Die Wellenfunktion hat in diesem Fall nach dem
Bloch-Theorem die Eigenschaft

m+q = eikq m: (2.30)

Die Eigenzustände und die zugehörigen Energien werden durch k und klassifi-
ziert. Schreibt man Gleichung (2.29) in folgender Weise in Matrixform:

m+1 = M1 (m; E ) m (2.31)
m m 1
mit
M1(m; E ) = E 2 cos(21m + ) 01 ; (2.32)

so zeigt die q -fach iterierte Gleichung zusammen mit (2.30), nämlich

Yq
M1(q r; E ) 0 = eikq 0 ; (2.33)
r=1 1 1
Qq
daß eikq Eigenwert der Matrix Mq (E ) = r=1 M1 (q r; E ) ist. Weil det(Mq ) =
1 ist, ergibt sich der zweite Eigenwert von Mq zu e ikq . Daraus folgt für die Spur
von Mq :
Spur Mq (E ) = 2 cos kq : (2.34)
Die Spur der Matrix Mq (E ) ist ein Polynom q -ten Grades in E . Dementspre-
chend hat die Gleichung (2.34) höchstens q reelle Lösungen E (k; ). Wir schließen
hieraus, daß es maximal q Energiebänder gibt, die man im Prinzip aus (2.34) für ra-
tionales = p=q berechnen kann. Neben jeder rationalen Zahl gibt es aber Zahlen
mit beliebig großem q und auch irrationale Zahlen (q !1
), so daß es als Funktion
von neben jedem Spektrum mit wenigen Bändern auch Spektren mit beliebig vie-
len Energiebändern gibt. Hier zeigt sich also physikalisch der Unterschied zwischen
rationalen und irrationalen Zahlen.

Algorithmus
Die numerische Auswertung der Spurbedingung (2.34), die auf eine Nullstellen-
bestimmung eines Polynoms q -ten Grades hinausläuft, erweist sich als ziemlich
schwierig. Wir wählen deshalb einen etwas anderen Weg, der dieses Problem um-
geht. Für einen festen Wert von k und , und zwar für k = 0 und = 0, wollen
wir die Harper-Gleichung (2.29) numerisch lösen und das Ergebnis graphisch als
72 2 Lineare Gleichungen

Funktion von rationalen Werten = p=q darstellen. Dazu wählen wir ein festes
q, das eine gerade Zahl sein soll, und lassen p von 1 bis q 1 laufen. Wir nutzen
aus, daß der Potentialterm Vm = 2 cos(2mp=q ) in m gerade ist, so daß man von
q 1
f g
den Eigenvektoren m m=0 der Harper-Gleichung voraussetzen kann, daß sie ent-
weder gerade oder ungerade in m sind. Die Periodizität m+q = m reduziert in
der Tat das Eigenwertproblem (2.29) auf q unabhängige Komponenten. Durch die
erwähnte gerade-ungerade Symmetrie läßt sich dieses Problem auf zwei etwa halb
so große Eigenwertaufgaben zurückführen.
f g
Die Voraussetzung, m sei z. B. ungerade in m, also m= m , liefert uns
zunächst 0 = 0 und zusammen mit der Periodizität

q 1:
q+
2 r = q
2 r = q
2 r für r = 0; 1; : : : ; 2 (2.35)

Insbesondere ist also auch q = 0, und für die verbleibenden q2 1 unabhängigen

Komponenten ( 1 ; 2 ; : : : ; q 1 )T
2

2 u lautet die Gleichung (2.29) in Matrix-

form:

0 V1 1 0 0 0 1
BB 1 V2 1 ... 0 C
C
BB C
C
mit Au = B C
..
BB 0.. .1.
.. .. ..
Au u=E u
. . . .
C
C (2.36)
BB . . ..
.
..
. 1 0 C
C
@0 . 1 Vq 2
..
1 A
0 0 0 1 Vq
2

2 1

Die möglichen Energien der Harper-Gleichung zu bestimmen bedeutet also in die-

sem Fall, die Eigenwerte der Tridiagonalmatrix Au zu berechnen. Bevor wir auf
ein spezielles numerisches Verfahren eingehen, das sich hier als besonders geeig-
net anbietet, wollen wir kurz zeigen, daß auch die Behandlung der in m geraden
Wellenfunktionen m auf ein ganz ähnliches Problem führt.
Es sei also m = m und m+q = m . Dies impliziert zunächst 1 = 1 ,
und analog zur Gleichung (2.35) erhalten wir jetzt

q 1:
q+
2 r = q
2 r = q
2 r für r = 1; 2; : : : ; 2 (2.37)

Inbesondere gilt also 2q +1 = q2 1 . Die Matrixform der Harper-Gleichung (2.29)

für die q2 + 1 unabhängigen Komponenten ( 0 ; 1 ; : : : ; q2 )T g sieht demnach
2.4 Hofstadter-Schmetterling 73

folgendermaßen aus:
0 V0 2 0 0 0 1
BB 1 V1 1 ... 0 C
C
BB C
C
mit Ag = B C
..
BB 0.. .1.
.. .. ..
Ag g=E g
. . . .
C
C (2.38)
BB . . ..
.
..
. 1 0 C
C
@0 . 1 Vq 1
..
1 A
0 0 0 2 Vq
2

Wie im Fall der ungeraden m bleibt als Aufgabe, die Eigenwerte einer tridiagona-
len Matrix, hier diejenigen von Ag zu bestimmen.
Die Berechnung des charakteristischen Polynoms einer tridiagonalen Matrix läßt
sich auf folgende Weise rekursiv formulieren. Wir betrachten z. B. die Matrix u A
1 A
E mit u aus Gleichung (2.36) und davon wiederum die linke obere Ecke, die
aus n Zeilen und Spalten bestehen möge. Bezeichnen wir deren Determinante mit
pn (E ), so erhalten wir durch Entwickeln nach der letzten Zeile
pn(E ) = (Vn E ) pn 1 (E ) pn 2 (E ) : (2.39)

Man vervollständigt diese zweigliedrige Rekursionsformel duch die Anfangswerte

p1 (E ) = V1 E und p0 (E ) = 1 (2.40)

und kann auf diese Weise det(Au E 1) = p q 1 (E ) rekursiv berechnen.

Die besondere Bedeutung der Polynome pn (E ) liegt aber darin, daß sie eine
2

sogenannte Sturmsche Kette bilden: Sturmsche Ketten enthalten Informationen über

die Nullstellen des Polynoms mit dem höchsten Grad. Wenn man die Anzahl der
Vorzeichenwechsel w(E ) betrachtet, die in der Folge

p0(E ); p1 (E ); p2(E ); : : : ; p q 1 (E )
2

an der Stelle E auftreten, dann gilt:

Die Anzahl der Nullstellen von p q2 1 (E )
im Intervall E1 E < E2 ist gleich w(E2 ) w(E1 ).
Weil es bei einer graphischen Darstellung immer eine endliche Auflösung gibt, auf
dem Bildschirm z. B. die Pixelbreite, werden wir eine geeignete Rasterung E0 <

E1 < E2 < EN des überhaupt möglichen Energiebereichs vornehmen. Die
Zahl der Vorzeichenwechsel w(Ei ), bzw. w(Ei+1 ) sagt uns dann, ob zwischen Ei
und Ei+1 Eigenwerte liegen. Der Bereich, in dem überhaupt Energie-Eigenwerte
74 2 Lineare Gleichungen

zu finden sind, läßt sich durch den Satz von Gerschgorin eingrenzen: Für jeden

Eigenwert E einer n n-Matrix A = (aij ) gibt es ein i, so daß gilt:
X
n
jE aii j jaij j : (2.41)
j =1; j 6=i
Pn
Weil in unserem Fall j =1; j 6=i aij j j j jj j
2 und aii Vi 2 gilt, schließen wir,
daß die Eigenwerte zwischen 4 und 4 liegen.
Für die Matrix Ag , die sich leicht von Au unterscheidet, lautet der den Gleichun-
gen (2.39, 2.40) entsprechende Algorithmus:

p0 (E ) = 1 ; p1(E ) = V0 E ; p2(E ) = (V1 E ) p1(E ) 2 p0 (E ) ;

pn (E ) = (Vn 1 E ) pn 1 (E ) pn 2 (E ) für n = 3; 4; : : : ; 2q ; (2.42)
p q +1(E ) = (V q E ) p q (E ) 2 p q 1(E ) :
2 2 2 2

Wir wollen noch darauf hinweisen, daß die Gleichungen (2.39) bzw. (2.42) für die
Sturmschen Ketten fast identisch zur Harper-Gleichung selbst sind. Denn aus (2.29)
folgt für die ungeraden Wellenfunktionen m= m mit den Startwerten 0 =
0; 1 = 1:
= (E V1 ) ; 3 = (E V2 ) 2 1 ; 4 = (E V3 ) 3 2 ; : : :
2
Die Wahl von 1 = 1 ist beliebig und ändert höchstens die Normierung der Wel-
lenfunktion, nicht aber deren Eigenwert. 0 = 0 folgt aus der Symmetrie. Der
Vergleich mit (2.39) und (2.40) ergibt

1 = p0 (E ) ; 2 = p 1 (E ) ; 3 = p 2 (E ) ;
= p3 (E ) ; : : : 4
Ändert sich nun die Anzahl der Vorzeichenwechsel in der Folge fpn (E )g, so ändert
sich die Anzahl der Vorzeichenwechsel in der Folge f g
n ebenfalls, und zwar
um denselben Betrag. Die Anzahl der Eigenwerte im Intervall [E1 ; E2 ] ist also
durch den Unterschied in der Anzahl der Vorzeichenwechsel von n (E1 ) und f g
f (
n 2 E g
) bestimmt. Dies erinnert an den Knotensatz der eindimensionalen Quan-
tenmechanik, den wir im Abschnitt 4.3 noch beim anharmonischen Oszillator be-
nutzen: Die Anzahl der Vorzeichenwechsel einer stationären Wellenfunktion (x)
bestimmt die Nummer des Energieniveaus über dem Grundzustand.
Der obige Algorithmus läßt sich in wenigen Programmzeilen schreiben. Wir ha-
ben in der Abbildung 2.14 eine Diskretisierung des kompletten Energieintervalls
j j
E 4 in 500 Intervalle gewählt. Nach rechts ist der Parameter = p=q für
q = 500 und p = 1; 2; : : : ; 499 aufgetragen. Die Gesamtzahl der Rechenschritte

läßt sich mit etwa 500 500 500 10 '
109 abschätzen, wobei wir zehn Re-
chenoperationen für die innerste Schleife angenommen haben. Weil Mathematica
dafür zu langsam wäre, haben wir das Programm in C geschrieben. Es besteht –
2.4 Hofstadter-Schmetterling 75

nach der üblichen Initialisierung – im wesentlichen aus drei ineinander geschach-

telten Schleifen: Der äußeren p-Schleife, in der (p) variiert wird, der mittleren ie-
Schleife, innerhalb derer die Energie von 4 bis 4 läuft, und der inneren Schleife
über m, in der bei vorgegebenem und E die Anzahl der Vorzeichenwechsel in der
Folge der Polynome p0 ; p1 ; : : : ; p q2 1 festgestellt wird. Dieser Teil des Programms
hat also folgende Form:

for(p = 1; p < q; p++)

{
sigma = 2.0*pi*p/q;
nalt = 0;

for(ie = 0; ie < q+2 ; ie++)

{
e = 8.0*ie/q – 4.0 – 4.0/q ;
n = 0;
polyalt = 1.0; poly = 2.0*cos(sigma)–e;
if( polyalt*poly < 0.0 ) n++ ;

for( m = 2; m < q/2; m++ )

{
polyneu = (2.0*cos(sigma*m)–e)*poly–polyalt;
if( poly*polyneu < 0.0) n++;
polyalt = poly; poly = polyneu;
}
..
.. Den entsprechenden Programmteil für die geraden
.. Eigenfunktionen haben wir hier ausgelassen.

if(n > nalt) aktion;

nalt = n;
}
}

Unter dem obigen aktion ist ein C-Befehl zu verstehen, mit dem z. B. ein Punkt
auf den Bildschirm gezeichnet wird oder die entsprechenden ( -E )-Werte in ein
Datenfile geschrieben werden.

Ergebnis
Das Resultat dieses Programmes ist in der Abbildung 2.14 zu sehen. Die vertikale
Achse markiert die Energie und die horizontale den Parameter , jeweils in 500 Pi-
xel unterteilt. Die Energie wird in Pixelschritten erhöht. Immer wenn es Eigenwerte
in diesem kleinen Intervall gibt, wird der Bildpunkt gezeichnet.
76 2 Lineare Gleichungen

2
Energie

-2

-4
0.0 0.2 0.4 0.6 0.8 1.0
Fluss pro Einheitszelle

2.14 Eigenwerte der Harpergleichung als Funktion von = Ba2 =( hc e ) , d. i. der magneti-
sche Fluß durch die Einheitszelle in Einheiten des elementaren Flußquantums.

Es ist überraschend und faszinierend, welch komplexe, feingezeichnete und anspre-

chende Struktur dieser Hofstadter-Schmetterling hat, der aus der einfachen diskre-
ten Schrödinger-Gleichung entsteht. Zunächst fallen die Symmetrien E !
E,
die hier übrigens nur näherungsweise erfüllt ist, und !
1 auf. Des weiteren
sieht der Schmetterling selbstähnlich aus: Teile der Abbildung treten etwas verzerrt
auch an vielen anderen Stellen auf und scheinen sich bis ins unendlich Kleine fort-
zusetzen. Für jeden Wert von gibt es 500 Eigenwerte. Allerdings sind diese Werte
nur am linken und rechten Rand gleichmäßig verteilt, sonst konzentrieren sie sich
auf wenige Bereiche. Bei = 1=2 gibt es offensichtlich zwei solche Bänder, bei
= 1=3 drei, bei = 1=4 vier, bei = 1=5 und = 2=5 fünf, bei = 1=10
und 3=10 zehn usw. Da dicht neben jeder rationalen Zahl = m=n (m und n
teilerfremd) mit einem kleinen Nenner n auch Zahlen mit großem Nenner zu fin-
den sind, liegen dicht neben den -Werten mit kleinen Nennern immer sehr viele
Bänder. Jede irrationale Zahl kann durch ein Folge rationaler Zahlen mit immer
2.5 Hubbard-Modell 77

größer werdendem Nenner approximiert werden. Also liegen dicht neben einem ir-
rationalen -Wert immer unendlich viele Energiebänder. Das ergibt die kunstvolle
Zeichnung, die sich bei unendlich feiner Auflösung unserer Vorstellung widersetzt.

Übung
Schreiben Sie ein Programm, das möglichst schnell einen Hofstadter-Schmetterling

auf einem 500 500 Fenster mit = p=500 (p = 1; :::; 500) zeichnet. Nutzen Sie
die Symmetrien des Schmetterlings aus und überlegen Sie sich einen Algorithmus,
der die vielen großen Löcher überspringt.

Literatur
D. R. Hofstadter, Energy levels and wave functions of Bloch electrons in rational
and irrational magnetic fields, Physical Review B14, 2239 (1976).
J. Stoer, Numerische Mathematik 1, Springer Verlag, 1994.
J. Stoer, R. Bulirsch, Numerische Mathematik 2, Springer Verlag, 1990.

2.5 Hubbard-Modell
Quantenmechanik gehört sicherlich nicht zu den leichten Gebieten der Physik. Ort
und Impuls, Welle und Teilchen verlieren ihre anschauliche Bedeutung. Einzelne
Meßergebnisse besagen in der Regel wenig, denn die Quantenmechanik ist im Kern
eine statistische Theorie, deren Aussagen als Wahrscheinlichkeitsaussagen formu-
liert sind. Dazu kommt ein erheblicher mathematischer Apparat, in dem Zustände
eingeführt und Operatoren erklärt werden müssen.
Noch schwieriger wird die mathematische Beschreibung, wenn man die Quanten-
mechanik wechselwirkender Teilchen untersuchen will, z. B. Supraleitung in einem
Festkörper durch wechselwirkende Elektronen. Da die einzelnen Elektronen prinzi-
piell nicht unterscheidbar sind, muß man den Vielteilchenzustand geeignet aus der
Überlagerung von Produkten von Einteilchenzuständen aufbauen. Für Elektronen
führt dies zum Pauli-Prinzip: Jeder Einteilchenzustand darf nur einmal besetzt sein.
In diesem Raum der Vielteilchenwellenfunktionen läßt sich der Hamiltonoperator
als Matrix darstellen, deren Eigenwerte die Energien der stationären Zustände an-
geben.
Nur in wenigen Fällen kann man diese Matrix mit analytischen Methoden dia-
gonalisieren. Aber auch eine numerische Lösung ist nicht leicht zu gewinnen. Die
Größe des Systems und das Anwachsen der Zahl der Freiheitsgrade erweisen sich
78 2 Lineare Gleichungen

dabei als das schwierigste Problem.

Als Beispiel für ein quantenmechanisches Vielteilchensystem betrachten wir ein
Elektronengas in einem Kristallgitter, bei dem sowohl die gegenseitige Coulomb-
abstoßung der Elektronen als auch deren Wechselwirkung mit den Ionenrümpfen
zu berücksichtigen ist. Eine vereinfachende Beschreibung dieser Situation, die den-
noch das Wesentliche enthält, wurde 1963 von J. Hubbard vorgeschlagen. Zur Zeit
wird dieses Modell im Zusammenhang mit der Hochtemperatur-Supraleitung dis-
kutiert. Es ist allerdings noch nicht sicher, ob das Modell überhaupt Supraleitung
zeigt.
Wir wollen hier demonstrieren, wie man die Hamiltonmatrix des eindimensiona-
len Hubbard-Modells mit dem Computer erzeugen und diagonalisieren kann. Aller-
dings müssen wir uns dabei auf wenige Teilchen beschränken.

Physik
Im Prinzip werden die Vielteilchenzustände aus Produkten von Einteilchenzustän-
den aufgebaut. Es gibt aber einen Formalismus, der es erlaubt, ohne die explizite
Darstellung der Produktwellenfunktionen auszukommen; es ist die sogenannte zwei-
te Quantisierung (eine etwas irreführende Bezeichnung). Sie benutzt Erzeugungs-
und Vernichtungsoperatoren, und die Zustände können durch Anwenden von Ope-
ratoren auf das Vakuum erzeugt werden. Dabei wird der Fermionen-Charakter durch
die Operatoralgebra berücksichtigt. Der Hamiltonoperator wird ebenfalls durch Er-
zeugungs- und Vernichtungsoperatoren dargestellt, so daß die Hamiltonmatrix sich
schließlich algebraisch konstruieren läßt.
Zunächst muß man die Einteilchenzustände numerieren und eine Reihenfolge
ji
festlegen. 0 sei das Vakuum. Ein Vielteilchenzustand mit N Teilchen hat dann die
Form
cyk1 cyk2 ::: cykN 0 ;
ji (2.43)
wobei (k1 ; k2 ; : : : ; kN ) ein geordnetes N -Tupel von Indizes und ki der Index der
entsprechenden Einteilchenwellenfunktion ist. Dieser Zustand läßt sich als Deter-
r
minante von Einteilchenwellenfunktionen 'k ( ) darstellen. So gilt beispielsweise
für zwei Teilchen

hr1 ; r2jcy1 cy2 j0i = (r1; r2 ) = p1 ['1(r1)'2 (r2 ) '2 (r1)'1 (r2)] : (2.44)
2
Wie schon erwähnt, ist diese explizite Darstellung gar nicht erforderlich. Bei ortho-
normalen Einteilchenzuständen ist allein die Antisymmetrie fermionischer Zustände
wichtig, die durch folgende Operatoralgebra dargestellt wird:

cyk cm + cm cyk = km ;

2.5 Hubbard-Modell 79

cyk cym + cym cyk = 0 ;

ck cm + cm ck = 0 : (2.45)
Der Operator cyk erzeugt eine Einteilchenwellenfunktion 'k (r ) im Vielteilchenzu-
stand, falls diese noch nicht vorhanden ist, sonst erhält man 0. Das dazu adjungierte
r
ck vernichtet 'k ( ), falls vorhanden, sonst gibt es 0. Das Pauli-Prinzip folgt aus
r
cyk cyk = 0; Doppelbesetzung von 'k ( ) ist also nicht erlaubt.
r
Beim Hubbard-Modell sind die Einteilchenzustände 'k ( ) lokalisierte Wellen-
funktionen von Elektronen an Gitterplätzen. Der Index k enthält die Nummer des
Platzes und die Quantenzahl der z -Komponente des Spins, dargestellt durch = "
#
oder = . Die kinetische Energie wird durch ein Hüpfen“ vom Platz k zum Nach-
barplatz m mit dem Operator
”
t cym ck (2.46)
berücksichtigt. Befinden sich zwei Elektronen an demselben Platz k , so sollen sie
die Coulombabstoßung
U k" k# n n (2.47)
spüren. Dabei gibt kn cy
k ck den Wert 1 falls sich ein Elektron mit dem Spin
n
am Platz k befindet, sonst gibt k den Wert 0. Die Parameter t und U modellieren
die Größe der kinetischen bzw. potentiellen Energie.
Im folgenden beschränken wir uns auf eine Kette mit M Plätzen und nehmen
periodische Randbedingungen an. Dann lautet der Hamiltonoperator
X
M X X
M
H= t (cyk ck+1; + cyk+1; ck ) + U nk" nk# (2.48)
k=1 k=1
mit cyM +1; = cy1; und cM +1; = c1 . Als Ordnung der Einteilchenzustände wählen
wir
f1 "; 2 "; : : : ; M "g; f1 #; 2 #; : : : ; M #g : (2.49)
Jeder Vielteilchenzustand kann also durch die Besetzungszahlen der Einteilchen-
zustände beschrieben werden. Dann gilt beispielsweise:
jf1; 1; 0; : : : ; 0g; f0; : : : ; 0; 1gi = cy1"cy2" cyM # j0i :
Wendet man den Operator cyk auf einen Zustand an, so muß man mit der Algebra
(2.45) diesen Operator solange mit den anderen cym0 vertauschen, bis die Reihen-
folge (2.49) stimmt. Dadurch erhält man auch das Vorzeichen des Zustandes. So
ergibt z. B.
cy1# jf1; 0; : : : ; 0g; f0; : : : ; 0; 1gi = cy1# cy1" cyM # j0i
= cy1" cy1# cyM # j0i
= jf1; 0; : : : ; 0g; f1; 0; : : : ; 0; 1gi
80 2 Lineare Gleichungen

und

cM # jf1; 0; : : : ; 0g; f0; : : : ; 0; 1gi = cM # cy1" cyM # j0i = cy1" cM # cyM # j0i
= cy1" j0i + cy1" cyM # cM # j0i
= cy1" j0i = jf1; 0; : : : ; 0g; f0; : : : ; 0gi :
Allgemein gilt bei Anwendung von cyk oder ck auf einen Zustand

jni = jfn1" ; : : : ; nM " g; fn1# ; : : : ; nM #gi ;

daß die Anzahl der Teilchen links von k das Vorzeichen bestimmt. Wir definieren
deshalb die folgende Signum-Funktion:
PMi Pkj
sign(k; n) = ( 1)# ni" ( 1) nj :
1
=1 =1
(2.50)

n
Sie produziert gerade so oft einen Faktor 1 wie es in von 0 verschiedene Ein-
träge vor der Position k gibt. Damit können wir die Wirkung der Erzeuger und
Vernichter folgendermaßen schreiben:

cyk jni = (1 nk ) sign(k; n) jfn1" ; : : : ; 1; : : : ; nM # gi : (2.51)

Die 1 steht an der Position k , und der Faktor (1 nk ) sorgt dafür, daß es keine
Doppelbesetzung desselben Zustands gibt. Analog gilt:

ck jni = nk sign(k; n) jfn1" ; : : : ; 0; : : : ; nM # gi ; (2.52)

wobei der Zustand k vernichtet wurde.

Jeder Platz in der Kette hat vier mögliche Zustände: leer, besetzt mit entwe-
" # " #
der oder oder zweifach besetzt mit und , so daß es insgesamt also 4M
Vielteilchenzustände gibt. Der Hamiltonoperator H ist daher in dieser Basis eine

4M 4M -Matrix. Diese Matrix ist aber erstens zum großen Teil mit Nullen be-
legt, und zweitens kann sie durch Symmetrien in Unterblöcke zerlegt werden. Das
Hubbard-Modell hat folgende Erhaltungsgrößen: Anzahl der Teilchen mit positiven
(N" ) und negativen (N# ) Spins, Gesamtspin-Quantenzahl und räumliche Symme-
trien. Dadurch reduziert sich die Größe der Blöcke von H erheblich. So kann für

3 Plätze die 64 64-Matrix auf Unterblöcke mit einer maximalen Größe von 3 3
reduziert werden.
Hier wollen wir nur N" und N# als Erhaltungsgrößen berücksichtigen und auch
nicht verschweigen, daß für das eindimensionale Modell eine Reihe von exakten
Resultaten bekannt ist, die man mit Bethe-Ansatz-Methoden gewinnen kann. Un-
ser Beispiel dient also nur als Einstieg zu numerischen Rechnungen für zwei- oder
dreidimensionale Modelle.
2.5 Hubbard-Modell 81

Algorithmus
Wir wollen wieder Mathematica benutzen, um die Darstellung der Operatoralgebra
(2.45) durch die Gleichungen (2.51) und (2.52) kompakt zu formulieren. Statt des
j i
Symbols : : : verwenden wir in Mathematica den Kopf z und notieren die Viel-
teilchenzustände in der Form

z[arg] mit arg = ffn1"; :::; nM " g; fn1# ; :::; nM # gg (2.53)

und nk 2f g0; 1 . Wir brauchen den Kopf z, da wir die Zustände addieren und mit
Zahlen multiplizieren müssen. Würden wir dies nur mit der Liste arg ausführen, so
würden wir falsche Ergebnisse erhalten. Die wesentlichen Manipulationen betreffen
aber das Argument von z. So erhält man z. B. nk aus arg[[sigma, k]] mit k
"
= k und sigma = 1 für = bzw. sigma = 2 für = . #
Nach Vorgabe der Zahlen M; N" und N# erzeugen wir mit den Funktionen Per–
mutations[..] und Table[..] die Liste index, die alle überhaupt mögli-
chen Zustände enthält. Der dabei benutzte Befehl Flatten[..] beseitigt eine
Klammerebene. Für M = 3; N" = 2 und N# = 1 erhalten wir z. B.
index = {{{1,1,0}, {1,0,0}}, {{1,1,0}, {0,1,0}}, {{1,1,0}, {0,0,1}},

{{1,0,1}, {1,0,0}}, {{1,0,1}, {0,1,0}}, {{1,0,1}, {0,0,1}},

{{0,1,1}, {1,0,0}}, {{0,1,1}, {0,1,0}}, {{0,1,1}, {0,0,1}}}

Der Operator cyk muß in dem Argument von z eine 1 an der richtigen Stelle erzeu-
gen. Dies geschieht durch die Funktion plus :

plus[k_,sigma_][arg_]:= ReplacePart[arg,1,{sigma,k}]
Entsprechend erzeugt minus eine 0. Unter Verwendung der oben eingeführten Vor-
zeichenfunktion (2.50) können wir jetzt analog zu (2.51) und (2.52) den Operator
cyk durch seine Wirkung auf Zustände definieren:
cdagger[k_,sigma_][factor_.*z[arg_]]:= factor*
(1 – arg[[sigma,k]])*
sign[k,sigma,arg]*
z[plus[k,sigma][arg]]
Der Parameter factor_. wird in Mathematica auf den Wert 1 gesetzt, falls der
Zustand keinen zusätzlichen Faktor hat. Da durch diese Operatoren auch immer der
Wert 0 erzeugt werden kann, z. B. ist cy1" 1; : : : ; : : : = 0, muß cdagger auch
jf g f gi
für die Zahl 0 definiert werden:

cdagger[k_,sigma_][0]:= 0
82 2 Lineare Gleichungen

Analog wird ck durch c[k_,sigma_] definiert. Außerdem brauchen wir noch
n
die Operatoren k :
n[k_,sigma_][0]:= 0
n[k_,sigma_][factor_.*z[arg_]]:= factor*
arg[[sigma,k]]*z[arg]
Der Hamiltonoperator (2.48) der Hubbard-Kette lautet dann einfach
H[vector_]=Expand[
–t*Sum[cdagger[k,sigma][c[k+1,sigma][vector]]+
cdagger[k+1,sigma][c[k,sigma][vector]],
{k,sites},{sigma,2} ]+
u*Sum[n[k,1][n[k,2][vector]] ,{k,sites}]
]
Die Länge M der Kette ist hier mit sites bezeichnet. Um die Hamiltonmatrix zu
hn j jn i
bekommen, brauchen wir die Skalarprodukte i H j zwischen i und H j .jn i jn i
Da unsere Vielteilchenzustände jni orthonormiert sind, müssen wir nur noch die
Linearität des Skalarproduktes definieren:
scalarproduct[a_,0]:= 0
scalarproduct[a_,b_ + c_]:= scalarproduct[a,b] +
scalarproduct[a,c]
scalarproduct[z[arg1_],factor_. z[arg2_]]:=
factor*If[arg1==arg2,1,0]
Die Antilinearität im ersten Argument wird hier nicht benötigt. Man beachte, daß
der Vergleich zweier Zustände, in diesem Fall also der Vergleich zweier geschachtel-
ter Listen, in Mathematica durch arg1==arg2 sehr kompakt geschrieben werden
kann.
hn j jn i
Die folgende Tabelle liefert die gesuchte Hamiltonmatrix i H j :
h = (hlist = Table[H[z[index[[j]]]], {j, end}];
Table[ scalarproduct[ z[index[[i]]], hlist[[j]]],
{i,end}, {j,end}])
Die obere Grenze der Laufindizes ist vorher durch end = Length[index] be-
stimmt worden.
Mit Eigenvalues[..] und Eigensystem[..] erhält man dann die Ener-
gien und die stationären Zustände des Vielteilchenproblems. Den Grundzustand fil-
tern wir heraus mit der Befehlskombination
g[uu_]:= Sort[Thread[ Eigensystem[
N[ h /. {t –> 1.0, u –> uu} ]]]][[1,2]]
2.5 Hubbard-Modell 83

Der Befehl Thread[..] ordnet das Ergebnis von Eigensystem[..] in der

Weise, daß Eigenwert und zugehöriger Eigenvektor zusammengefaßt werden. In
dem sortierten Resultat steht dann der Grundzustand als der Zustand mit der klein-
sten Energie an erster Stelle. Die erste Komponente davon ist die Energie des Grund-
zustandes, die zweite Komponente, eine Liste, enthält die Koeffizienten gn des
ji
Grundzustandes g bezüglich der Basis jni
. Wir interessieren uns z. B. für die mitt-
lere Doppelbesetzung im Grundzustand, also für

1 X
M X
M X
M hgjnk"nk# jgi = M1 jgnj2 nk"(n) nk# (n) : (2.54)
k=1 k=1 fng
Das Mathematica-Äquivalent von Gleichung (2.54) ist
Sum[Sum[Abs[g[u][[j]]]ˆ2*index[[j,1,k]]*index[[j,2,k]],
{j,end}], {k,sites}] / sites
Dies läßt sich, da die Summen vertauschbar sind und als Skalarprodukte angesehen
werden können, auf folgende Weise sehr kompakt formulieren:
(Abs[g[u]]ˆ2).Map[#[[1]].#[[2]]&, index] / sites

Ergebnisse
Für M = 3 Plätze und N" = 2; N# = 1 findet Mathematica die Energien noch
analytisch. Dazu schreiben wir mit
TeXForm[Eigenvalues[h]] >> hubbard.tex
das Ergebnis in TEX-Form in eine Datei, fügen die mathematische Umgebung und
einige Zeilenumbrüche hinzu und übersetzen sie mit TEX bzw. LATEX. Das Ergebnis
sehen Sie auf der nächsten Seite.
Abbildung 2.16 zeigt diese Energien als Funktion des Verhältnisses U=t von
Coulomb- und kinetischer Energie. Für U = 0 gibt es keine
8
6
Energie/t

4
2
0
-2
0 1 2 3 4 5 6
2.16 Energie-Eigenwerte des Hubbard-
Modells in Abhängigkeit von U=t für
U/t
M = 3; N" = 2 und N# = 1.
84 2 Lineare Gleichungen

f0; u; u; 1
23 27 t2 u2
2u +
3 r 3 2 ! 13
3 162 t2 u+16 u3 18 u 9 t2 +u2 + 4 27 t2 u2 + 162 t2 u+16 u3 18 u 9 t2 +u2

r 3 2 ! 31
162 t2 u+16 u3 18 u 9 t2 +u2 + 4 27 t2 u2 + 162 t2 u+16 u3 18 u 9 t2 +u2
1 ;
323

1
23 27 t2 u2
2u +
3 r 3 2 ! 13
3 162 t2 u+16 u3 18 u 9 t2 +u2 + 4 27 t2 u2 + 162 t2 u+16 u3 18 u 9 t2 +u2

r 3 2 ! 31
162 t2 u+16 u3 18 u 9 t2 +u2 + 4 27 t2 u2 + 162 t2 u+16 u3 18 u 9 t2 +u2
1 ;
323

1+i
p3 27 t2 u2

2u +
3
2 r 3 2 ! 31
323 162 t2 u+16 u3 18 u 9 t2 +u2 + 4 27 t2 u2 + 162 t2 u+16 u3 18 u 9 t2 +u2

p3 r 3 2 ! 31
1 i 162 t2 u+16 u3 18 u 9 t2 +u2 + 4 27 t2 u2 + 162 t2 u+16 u3 18 u 9 t2 +u2
1 ;
623

1+i
p3 27 t2 u2

2u +
3 2 r 3 2 ! 31
323 162 t2 u+16 u3 18 u 9 t2 +u2 + 4 27 t2 u2 + 162 t2 u+16 u3 18 u 9 t2 +u2

p3 r 3 2 ! 31
1 i 162 t2 u+16 u3 18 u 9 t2 +u2 + 4 27 t2 u2 + 162 t2 u+16 u3 18 u 9 t2 +u2
1 ;
623

i 3
1
p
27 t2 u2

2u +
3
2 r 3 2 ! 31
323 162 t2 u+16 u3 18 u 9 t2 +u2 + 4 27 t2 u2 + 162 t2 u+16 u3 18 u 9 t2 +u2

p3 r 3 2 ! 31
1+i 162 t2 u+16 u3 18 u 9 t 2 + u2 + 4 27 t2 u2 + 162 t2 u+16 u3 18 u 9 t2 +u2
1 ;
623

p
1 i 3 27 t2 u2

2u +
3
2 r 3 2 ! 31
323 162 t2 u+16 u3 18 u 9 t2 +u2 + 4 27 t2 u2 + 162 t2 u+16 u3 18 u 9 t2 +u2

p3 r 3 2 ! 31
1+i 162 t2 u+16 u3 18 u 9 t 2 + u2 + 4 27 t2 u2 + 162 t2 u+16 u3 18 u 9 t2 +u2
1 g
623

2.15 Eigenwerte einer 9 9-Hubbard-Matrix, die von Mathematica wegen der Symmetrie der
Matrix nicht nur numerisch, sondern allgemein als Funktion von U und t gefunden werden
können. Umwandlung in die obige Form mit der Funktion TeXForm[..].

Wechselwirkung zwischen den Elektronen, also können wir die Energieniveaus da-
durch berechnen, daß wir Einteilchenniveaus auffüllen. Bei periodischen Randbe-
2.5 Hubbard-Modell 85

dingungen lassen sich diese Einteilchenenergien für beliebiges M explizit angeben.

Wir definieren die Wellenvektoren k = 2M , = 0; 1; : : : ; M 1. Damit sind die
Einteilchen-Eigenzustände des Hubbard-Hamiltonians und deren Energien gegeben
durch

X
M
jk i = p1 e i k l cy j0i ;
l
M l=1
E = 2 t cos k :
Für M = 3 erhalten wir als Einteilchen-Energien 2 t; t und nochmal t. In diese
" #
Niveaus können 2 Spin - und 1 Spin - Teilchen gesetzt werden, wobei allerdings
"
die Doppelbesetzung zweier -Spins verboten ist. Dies ergibt folgende 9 Niveaus,
in Übereinstimmung mit Abbildung 2.16 :
zweifach entartet: "1 = 3 t ;
fünffach entartet: "2 = 0 ;
zweifach entartet: "3 = 3 t :
6
Daß auch für U = 0 außer dem einen Niveau mit " = 0 alle anderen zweifach
entartet sind, liegt an der Translations- und Spiegelsymmetrie dieses Modells. Die
mittlere Doppelbesetzung im Grundzustand für M = 4 Plätze und sogenannter
Halbfüllung, d. h. N" + N# = M , hier für N" = 2 und N# = 2, zeigt Ab-
bildung 2.17. Für U !1
ist Doppelbesetzung natürlich verboten. Die nächsten

0.18
0.16
Doppelbesetzung

0.14
0.12
0.1
0.08
0.06
0 1 2 3 4 5 6 2.17 Mittelwert der Doppelbesetzung im
Grundzustand in Abhängigkeit von U=t
für M = 4, N" = 2 und N# = 2.
U/t

zwei Abbildungen enthalten Resultate für einen Hubbardring mit M = 6 Plätzen,

N" = 3 und N# = 3. So moderat diese Zahlen erscheinen mögen, die Anzahl der
Zustände wächst mit M stark an und beträgt für dieses Beispiel immerhin schon

(63) (63) = 400. Die Energien der stationären Zustände zu berechnen bedeutet also,

die Eigenwerte einer 400 400-Matrix zu bestimmen. Gäbe es nicht die Symmetrie
und die vielfache Entartung, so würde das folgende Diagramm 400 verschiedene
N +N
Energieniveaus zeigen. Für den Fall des halbgefüllten Bandes, also "M # = 1,
86 2 Lineare Gleichungen

10
Energie/t

-5

0 1 2 3 4 5 6
U/t

2.18 Energie-Eigenwerte des Hubbardmodells in Abhängigkeit von U=t für M = 6; N" =

3 und N# = 3.

N N
läßt sich, wenn außerdem noch M" = M# = 12 gilt, im Limes M die Grund- !1
zustandsenergie pro Platz für beliebiges U=t in geschlossener Form angeben. Es
gilt:

"0 Z 1 J0(!) J1 (!) d!

M ! 4 t ![1 + exp( 1 !U=t)] fur M ! 1 ; (2.55)
0 2
wobei J0 und J1 Besselfunktionen sind. Wir werten das Integral numerisch aus und
vergleichen das Resultat mit den entsprechenden Werten für M = 6. Erstaunlicher-
weise liegen die beiden Kurven gar nicht so weit auseinander.

-0.4
Energie pro Platz/t

-0.6

-0.8

-1
2.19 Grundzustandsenergie pro Platz für
-1.2 das halbgefüllte Band. Die gestrichelte
Kurve ist das exakte Resultat für M !
0 1 2 3 4 5 6
1 , die durchgezogene Linie beschreibt
U/t die Werte für M = 6 .
2.5 Hubbard-Modell 87

Um größere Systeme zu berechnen, muß man erstens die Symmetrie berücksich-

tigen und zweitens eine schnelle Computersprache benutzen. So kann man heute
Modelle mit bis zu M = 25 Plätzen exakt diagonalisieren. Mit der Quanten-Monte-
Carlo-Methode, die das Hubbard-Modell bis auf statistische Fehler numerisch exakt
behandelt, kann man bis zu M = 1024 Gitterplätze untersuchen. Auch mit heuti-
gen Superrechnern sind also nur winzig kleine Quanten-Modelle berechenbar. Die
drastische Leistungssteigerung zukünftiger Computer wird die Systemgröße nur ge-
ringfügig erhöhen können – es sei denn, es gelingt, neue Algorithmen zu entwickeln.

Übung
Die z -Komponente des Spinoperators am Platz i läßt sich durch die Teilchenzahl-
n n
operatoren i " und i # ausdrücken: Siz = 1=2 ( i"n n
i# ). Berechnen Sie für den
P hj ji
Grundzustand g mit M = 4 Plätzen und N" = N# = 2 die Spinkorrelationen
P hj
M ji M ji
M i=1 g Si Si+1 g und M i=1 g Si Si+2 g in Abhängigkeit von U=t.
1 z z 1 z z

Literatur
J. E. Hirsch, Two-dimensional Hubbard model: Numerical simulation study, Physi-
cal Review B31, 4403 (1985).
H. Q. Lin, J. E. Gubernatis, Exact diagonalization methods for quantum systems,
Computers in Physics 7, 400 (1993).
A. Montorsi [ed.], The Hubbard model: A Reprint Volume, World Scientific, 1992.
Kapitel 3
Iterationen

Eine Funktion besteht aus einer Menge von Anweisungen, die gegebene Eingabe-
in Ausgabewerte umwandeln. Gehört nun die Ausgabe selbst zur Definitionsmen-
ge der betrachteten Funktion, so kann sie selbst wieder zur Eingabe werden, und
die Funktion liefert neue Ausgabewerte. Dies kann dann beliebig oft wiederholt
werden. Während es oft keine analytischen Möglichkeiten gibt, die strukturellen Ei-
genschaften solcher Iterationen von der Form xt+1 = f (xt ) zu berechnen, sind sie
im Computer leicht zu realisieren. Man muß offenbar nur dieselbe Funktion f (x)
immer wieder auf das Ergebnis anwenden. Wir wollen dies an einigen Beispielen
demonstrieren.

3.1 Populationsdynamik
Die wohl bekannteste Iteration einer nichtlinearen Funktion ist die sogenannte logi-
stische Abbildung. Sie ist eine einfache Parabel, die die reellen Zahlen des Einheits-
intervalls in sich selbst abbildet. Wir wollen sie hier vorstellen, weil jeder Wissen-
schaftler die Eigenschaften einer so elementaren Iteration kennen sollte.
Ein einfacher Mechanismus führt zu komplexem Verhalten – dies ist das Ergebnis
der wiederholten Anwendung einer quadratischen Abbildung. Obwohl es nur we-
nige analytische Ergebnisse dazu gibt, kann jeder die Iteration leicht auf einem Ta-
schenrechner nachvollziehen. Bei gewissen Parameterwerten der Parabel findet man
ein unregelmäßiges Umherspringen der iterierten Zahlen im Einheitsintervall. Die
Zahlenfolge ist dann extrem empfindlich auf Änderungen des Startwertes der Iterati-
on. Eine wohldefinierte Abbildungsvorschrift liefert eine Zahlenfolge, die schon bei
geringer Anfangsungenauigkeit praktisch unvorhersagbar ist. Ein solches Verhalten
nennt man deterministisches Chaos.
Einige Größen, die man mit dem Computer berechnet, sind nicht nur das Er-
gebnis einer mathematischen Spielerei, sondern man findet diese Zahlen in vielen
Experimenten beim Übergang vom regelmäßigen zum chaotischen Verhalten wie-
der. Solche Universalität quantitativer Größen ist ein weiterer faszinierender Aspekt
dieser Gleichung.
90 3 Iterationen

Physik
Wir betrachten die Iteration

xn+1 = 4 r xn(1 xn) = f (xn) ; n = 0; 1; 2; 3; : : : ; (3.1)

die erstmalig 1845 von dem belgischen Biomathematiker P. F. Verhulst in einer

Arbeit zur Populationsdynamik eingeführt wurde. Dabei wird xn im Intervall [0; 1]
iteriert, und r ist ein Parameter, der ebenfalls in [0; 1] variiert werden kann.
Die Funktion (3.1) ist für verschiedene Fragestellungen interessant:

1. Als einfaches Modell zur zeitlichen Entwicklung einer wachsenden Population.

xn ist proportional zur Bevölkerungsdichte einer Spezies zur Zeit n. Ihr Wachs-
tum wird beschrieben durch einen linearen Beitrag 4 r xn , der allein genommen
für r > 14 zum exponentiellen Wachstum, also zur Bevölkerungsexplosion führt.
Das Wachstum der Population wird allerdings durch den nichtlinearen Beitrag
4 r x2n (z. B. durch begrenzte Futtermenge) gedämpft.
2. Als einfaches Beispiel zur klassischen Mechanik mit Reibung.
Wir werden im Abschnitt 4.2 sehen, daß die Bewegung eines mechanischen Sy-
stems durch einen Poincaré-Schnitt im Phasenraum analysiert werden kann. Die-
ser Schnitt ergibt eine Iteration einer nichtlinearen Abbildung. Daher ist es nütz-
lich zu wissen, welche Eigenschaften solche Iterationen schon in einer Dimen-
sion haben, auch wenn in der Mechanik eindimensionale Poincaré-Schnitte kein
Chaos zeigen können.
3. Als Beispiel für eine (schlechte) numerische Lösung einer Differentialgleichung.
Wenn benachbarte xn -Werte sich nur wenig ändern, dann können n und xn kon-
tinuierlich fortgesetzt werden. Setzt man

dx ;
xn+1 xn ' dn
so wird Gleichung (3.1) zur Näherung der Differentialgleichung
dx = (4r 1)x 4r x2
dn
mit der Lösung
4r 1
x(n) = 4r + const :
e(1 4r)n
Für r < 14 ist x1 = 0 ein Attraktor, während für r > 41 alle Startwerte x(0) > 0
zum Wert x1 = 1 41r laufen. Wie in der diskreten Iteration hat diese Gleichung
3.1 Populationsdynamik 91

bei r0 = 14 einen Phasenübergang von einer aussterbenden zu einer konstanten

Population. Es wird sich aber zeigen, daß für größere r -Werte die Differential-
gleichung keine Ähnlichkeit mehr zu ihrer diskreten Approximation hat.

Für r > r0 = 14 hat die Gleichung (3.1) den Fixpunkt x = f (x ) mit x = 1 41r .
Wir betrachten nun eine kleine Abweichung x + "0 vom Fixpunkt und iterieren
'
diese. Wegen f (x + "0 ) f (x ) + f 0 (x )"0 = x + f 0 (x )"0 gilt für kleine "n :

"n ' f 0(x )"n 1 ' [f 0(x)]n "0 : (3.2)

Daher explodiert die Störung "0 für jf 0 (x )j > 1, was r > r1 = 34 entspricht. Wir
werden sehen, daß dann die xn nach einigen Schritten zwischen den Werten x1 und
x2 hin- und herspringen:
x1 = f (x2 ) ; x2 = f (x1 ) ;
(3.3)
also xi = f (f (xi )) für i = 1; 2 :

Die iterierte Abbildung f (2) (x) = f (f (x)) hat demnach für gewisse r -Werte zwei
stabile Fixpunkte. p
j j
Nun gilt f (2)0 (xi ) > 1 für r > r2 = (1 + 6)=4. Daher zeigt dasselbe
Argument wie oben, daß der Zweierzyklus für r > r2 instabil wird, die xn laufen in
einen Viererzyklus. Diese Verdoppelung der Perioden setzt sich bis ins Unendliche
'
bei r1 0:89 fort.
Eine Verdoppelung der Periodenlänge bedeutet eine Halbierung der Frequenz; es
entstehen also Subharmonische im Frequenzspektrum. Bei rl wird der 2l 1 -Zyklus
instabil und ein 2l - Zyklus entsteht. Für l!1 drängen sich die rl -Werte immer
dichter an r1 heran, und zwar mit folgender Gesetzmäßigkeit:

rl r1 cl : (3.4)

Daraus folgt
= llim rl rl 1 :
!1 rl+1 rl
(3.5)

Die Zahl heißt Feigenbaumkonstante und hat den Wert = 4:66920::: Sie ist des-
halb so wichtig, weil sie eine universelle Größe ist; sie wird für viele verschiedene
Funktionen f (x) beobachtet. Auch Experimente an realen nichtlinearen Systemen,
die durch Periodenverdoppelung ins Chaos übergehen, zeigen dieselbe Zahl.
Für größere r -Werte erhält man chaotische Bänder: xn scheint zufällig in einem
oder mehreren Intervallen ohne Periode hin- und herzuspringen. Dies gilt, obwohl
die xn -Werte nicht zufällig, sondern durch die wohldefinierte Parabel f (x) aus Glei-
chung (3.1) erzeugt werden. Ein solches Verhalten nennt man, wie schon erwähnt,
deterministisches Chaos.
92 3 Iterationen

Im chaotischen Bereich kann man an der einfachen Parabel eine wesentliche Ei-
genschaft des deterministischen Chaos studieren: die Empfindlichkeit auf Anfangs-
bedingungen. Zwei extrem dicht benachbarte Startwerte trennen sich schon nach
wenigen Iterationen und springen scheinbar unabhängig voneinander in den chao-
tischen Bändern umher. Zur quantitativen Charakterisierung kennzeichnen wir die
beiden Trajektorien durch xn und xn + "n . Dann gilt für "0 0 !
"n ' "0 e n : (3.6)
heißt Ljapunow-Exponent; er mißt die Empfindlichkeit auf den Anfangszustand.
Ein positiver Exponent > 0 bedeutet Chaos. Es gilt
j j'
f (n) (x0 + "0 ) f (n)(x0 ) "0 e n : (3.7)
Im Limes "0 ! 0 gibt dies gerade die Ableitung der n-fach Iterierten f (n)(x0 ) =

f (f ( f (x0)) ). Mit der Kettenregel erhält man sofort
1 n 1X
= nlim
!1 n i=0
ln f 0 (xi ) :
j j (3.8)

f g
Um zu bestimmen, muß also nur eine Bahn xi berechnet und dabei der Loga-
rithmus der Steigung von f an den Stellen xi aufsummiert werden.

Algorithmus
Mit Mathematica kann man die Funktion f[x ] = 4 r x (1–x) einfach mit
iterf[n ]:= Nest[f,x,n]
n-mal iterieren. Wesentlich schwieriger ist aber die genaue Bestimmung der Ver-
zweigungspunkte rl und damit der Feigenbaumkonstanten . r1 und r2 kann man
durch Lösen der beiden Gleichungen f (l) (x ) = x und j dfdx (x )j = 1 für
l ( )

die Unbekannten x und rl finden, entweder per Hand oder mit der Mathematica-
Funktion FindRoot. Aber höhere rl -Werte konnten wir damit nicht bestimmen.
Es genügt jedoch, sogenannte superstabile periodische Bahnen zu betrachten. Dies
sind Bahnen, die bei x0 = 21 starten und nach 2l Schritten dort wieder ankom-

men. Wegen f 0 21 = 0 konvergieren Abweichungen von x0 sehr schnell gegen
den 2l -Zyklus. In jedem Intervall [rl ; rl+1 ] gibt es nun eine superstabile Bahn der
Periode 2l bei einem Wert Rl . Die Rl -Werte skalieren dabei wie die rl -Werte mit
der Feigenbaumkonstanten gegen r1 (siehe Gleichung (3.5)).

1
Nun ist es wiederum nicht einfach, die Gleichung

f (2l ) 1
2 =2
3.1 Populationsdynamik 93

numerisch zu lösen. Da diese Gleichung noch weitere 2l 1 Fixpunkte hat, oszil-

liert die Funktion sehr schnell und FindRoot versagt. Aber es gibt einen Trick:
Man invertiert die obige Gleichung. Da die Inverse zu f zwei Zweige hat, muß man
bei der Iteration angeben, ob xn rechts (R) oder links (L) von x0 = 21 liegt. Je-
de periodische Bahn wird also durch eine Folge aus C; R und L bestimmt, wobei
C (= center) den Startwert x0 = 21 markiert und R; L angeben, ob xi rechts oder
links vom Maximum liegt. Die Iteration wird also durch eine symbolische Dynamik
beschrieben, die gewissen Regeln unterliegt.
Es gibt nun einen einfachen Algorithmus, um die Sequenz der R und L für eine
gegebene Periode 2l zu bestimmen. Wir geben ihn ohne Beweis an. Der Startwert
soll bei x0 = 21 liegen, also fängt die Sequenz immer mit C an. Für l = 1 erhalten
wir offensichtlich CR. Die Sequenz für l + 1 wird aus derjenigen für l konstruiert,
indem man die l-Sequenz verdoppelt und für das mittlere C entweder L setzt, falls
die Anzahl der R-Werte in der l-Sequenz ungerade ist, oder R, falls sie gerade ist.
Für l = 2 gibt die Verdoppelung also CRCR, und dies wird CRLR, da CR nur
ein R enthält. Für l = 3 erhält man CRLRRRLR.
Die inverse Iteration läßt sich am einfachsten in einem Koordinatensystem aus-
führen, dessen Ursprung bei (x; y ) = ( 12 ; 12 ) liegt und dessen beide Achsen ge-
meinsam so umskaliert werden, daß der Scheitel der Parabel im neuen System bei
(0; 1) liegt. In diesem Koordinatensystem hat die ursprüngliche Parabel f (x) =
4 r x(1 x) die Form
g( ) = 1 2 ;
wobei und r über
p
= r(4r 2) bzw: r = 41 1 + 1 + 4
miteinander zusammenhängen. Wir bezeichnen den linken Ast der Parabel mit gL( )
und den rechten mit gR ( ). Die superstabile Bahn für l = 2 genügt dann der Glei-
chung
gR (gL (gR (1))) = 0
bzw.
1 = gR 1 (gL 1 (gR 1 (0)))
mit r1 r1
gR 1 ( ) =
und gL 1 ( ) =
:
Damit erhält man schließlich folgende Bestimmungsgleichung für :
rq
= + p ; (3.9)
94 3 Iterationen

die man durch Iteration oder mit FindRoot lösen kann. Die Sequenz CRLR be-
stimmt die Vorzeichen der geschachtelten Wurzeln in Gleichung (3.9). Nach dem
anfänglichen CR, das nicht in der obigen Gleichung auftritt, gibt ein L ein positives
und ein R ein negatives Vorzeichen. Dies gilt für sämtliche superstabilen periodi-
schen Bahnen. Die Periode 5 mit der Sequenz CRLRR, die zwischen chaotischen
Bändern liegt, findet man also bei einem -Wert, der folgender Gleichung genügt:
s r q
= + p :
Die Erzeugung der Sequenz haben wir mit Mathematica folgendermaßen program-
miert: Für das Symbol R (L) schreiben wir die Zahlen 1 (0), die Sequenz der Länge
2n wird als Liste periode[n] gespeichert. Am Anfang wird für n = 1 die Li-
ste periode[1]= {c,1} gesetzt, und die Verdoppelung der Sequenz geschieht
durch
periode[n_]:= periode[n]=
Join[periode[n–1], correct[periode[n–1]]]
Dabei muß noch das Symbol c durch 0 oder 1 ersetzt werden, je nachdem, ob die
Häufigkeit, mit der die Zahl 1 auftaucht (= Summe der Listenelemente), ungerade
oder gerade ist.
correct[list_]:=Block[{sum=0,li=list,l=Length[list]},
Do[sum+=li[[i]],{i,2,l}];
If[OddQ[sum],li[[1]]=0,li[[1]]=1];
li]

Die vielfach verschachtelte Wurzel der Bestimmungsgleichung für erhält man mit
g[n_,mu_]:=Block[{x=Sqrt[mu],l=Length[periode[n]]},
Do[x=Sqrt[mu+(–1)ˆ(periode[n][[i]]) x],{i,l,3,–1}];
x]
Schließlich wird diese Gleichung numerisch gelöst, wobei die Genauigkeit, mit der
FindRoot die Lösung berechnet, heraufgesetzt werden muß:
genau=30
maxit=30
fr[n_]:=fr[n]=(find=FindRoot[g[n,mu]==mu,
{mu,{15/10,16/10}},
AccuracyGoal–>genau,
WorkingPrecision–>genau,
MaxIterations–>maxit];
mu/.find)
3.1 Populationsdynamik 95

Wenn man sich die Bahnen x0 ; x1 ; x2 ; x3 ::: für alle Parameter r (bzw. ) erzeugen
und graphisch darstellen will, so sollte man möglichst eine schnelle Programmier-
sprache verwenden, da für jeden r -Wert etwa 1000 Iterationen notwendig sind. Im
Prinzip ist dies aber sehr einfach: Als r -Wert wählt man z. B. die x-Koordinate der
Pixel auf dem Bildschirm. Zu jedem r -Wert berechnet man zunächst etwa 100 xn -
Werte, bis die xn dem Attraktor sehr nahe gekommen sind. Danach berechnet man
weitere 1000 xn -Werte, rechnet sie in y -Koordinaten der Pixel um und zeichnet
einen Bildpunkt am Pixel (x; y ). In der Sprache C lautet dies:
xit = 4.*r*xit*(1.–xit);
putpixel( r*MAXX, (1.–xit)*MAXY,WHITE);
Dabei wird der Parameter r über Tastendruck schrittweise erhöht oder erniedrigt.
Auch die Dichte der xn -Werte ist interessant. Um sie darzustellen, unterteilt man
die x-Achse in kleine Intervalle, z. B. von der Größe der Pixelabstände. Jedes Inter-
vall erhält eine y -Koordinate, die am Anfang auf den Wert y = 0 gesetzt wird. Bei
der Iteration der Parabel für einen festen r -Wert fällt jeder xn -Wert in ein solches
Intervall, wobei die jeweilige y -Koordinate um eine Pixeleinheit erhöht wird und
am entsprechenden (x; y )-Pixel ein Punkt gezeichnet wird. Somit erhält man ein
Histogramm der xn -Werte, das der Dichte der Punkte auf dem Attraktor entspricht.
Dies geschieht mit folgender Funktion:
void kanal( double r)
{
double xit=.5;
int x,y[600],i;
clearviewport();
for (i=0;i<MAXX;i++) y[i]=0;
rectangle(0,0,MAXX,300);
while(!kbhit())
{ xit=4.*r*xit*(1.–xit);
x=xit*MAXX;
y[x]++;
putpixel(x,300–y[x],WHITE);
}
getch();getch();clearviewport();return;
}

Ergebnisse
Abbildung 3.1 zeigt die Iteration von x0 = 0:65 für r = 0:87. Die xn -Werte laufen
in einen Attraktor mit der Periode 4, der durch die Fixpunkte der vierfach iterierten
96 3 Iterationen

Abbildung f (x) beschrieben wird. Diese sind in Abbildung 3.2 zu sehen. f (4) (x)
schneidet die Gerade y = x achtmal, nur vier davon aber sind stabile Fixpunkte.

0.8

0.7
x(n)

0.6

0.5 3.1 Iteration des Startwertes

x0 = 0:65 für den Parameter
0.4 r = 0:87.Die xn -Werte lau-
0 10 20 30 40 fen zum Attraktor mit der Pe-
n riode 4.

0.8

0.6

0.4

3.2 Die Funktion f (x) und

0.2

0
ihre Iterierten f (2) und f (4) .
0 0.2 0.4 0.6 0.8 1 Die vierfach iterierte Funktion
x hat acht Fixpunkte.

Erhöht man r , so entstehen Attraktoren mit den Perioden 8; 16; 32; :::; bis bei r1 =
0:89::: der Übergang ins Chaos stattfindet. Dies sieht man deutlich in den Abbil-
dungen 3.3 und 3.4, in der 1000 xn -Werte nach einer Übergangszeit von etwa 100
Schritten als Funktion von r aufgetragen sind. Attraktoren der Periode p sind also
als p Punkte zu sehen, während chaotische Bahnen mehrere Intervalle auf der Ver-
tikalen füllen. Da nur höchstens 1000 Punkte für jeden r -Wert gezeichnet wurden,
bekommt man auch einen Eindruck von der Dichte der xn -Werte. Diese ist aber
deutlicher in dem Histogramm in Abbildung 3.5 zu sehen. Periodische Bahnen mit
der Periode p erscheinen als Linienschar mit p Spitzen, während chaotische Bahnen
zwischen verschiedenen Bändern mit jeweils stetigen Dichten hin- und herspringen.
Die Abbildung 3.5 zeigt die chaotische Bewegung dicht unterhalb eines Fünferzy-
klus; dort gibt es zwar nur ein Band, man sieht aber noch die fünf Spitzen des be-
3.1 Populationsdynamik 97

3.3 Jede vertikale Linie enthält 1000

xn -Werte der iterierten Parabel, wo-
bei die ersten 100 Punkte nicht ge-
zeigt sind. Der Parameter r variiert
auf der Horizontalen von 0 bis 1.

3.4 Ein Ausschnitt aus der vorigen Abbildung für r = 0:88 bis r = 1.

nachbarten Zyklus. Es läßt sich zeigen, daß für r = 1 nur ein Band mit der Dichte
(x) = 1 p 1
x(1 x)
existiert. In Abbildung 3.4 sieht man im chaotischen Bereich viele Fenster mit
98 3 Iterationen

periodischen Bahnen. Das größte Fenster hat die Periode 3, das beim Parameter
p
r = ( 8 + 1)=4 beginnt. In diesem Fenster gibt es wieder Periodenverdoppelung:
Mit wachsendem r erhält man die Perioden 3; 6; 12; 24; :::, bis ein chaotischer Be-
reich erscheint. Tatsächlich kann man zeigen, daß alle Perioden vorkommen.

3.5 Häufigkeit der xn -Werte bei

der Iteration der Parabel für einen
Parameterwert r ' 0:934 dicht
unterhalb des Fensters mit der
Periode 5.

Einen weiteren Eindruck der logistischen Abbildung xn+1 = f (xn ) erhält man,
indem man in der x-y -Ebene die aufeinanderfolgenden Parabelpunkte (xn ; f (xn ));
(xn+1 ; f (xn+1 )); : : : geometrisch konstruiert. Man gewinnt den jeweils nächsten
Punkt dadurch, daß man vom aktuellen Punkt horizontal bis zur Winkelhalbierenden
y = x geht und von dort aus senkrecht bis zur Parabel y = 4 r x(1 x). Die
nächsten zwei Abbildungen zeigen diese Konstruktion, die sich mit Mathematica
relativ leicht ausführen läßt.
Die Skalengesetze (3.4) und (3.5) bestimmen die universelle Feigenbaumkonstante
. Dazu berechnen wir die Parameter Rl, bei denen es superstabile Bahnen mit der
Periode 2l gibt. Mit der Methode der symbolischen Dynamik und der inversen Ite-
ration finden wir mit 30 Stellen Genauigkeit, von denen wir hier nur 12 ausdrucken:
R10 = 0:892486338871
R11 = 0:892486401027
R12 = 0:892486414339
R13 = 0:892486417190
R14 = 0:892486417801
R15 = 0:892486417932
3.1 Populationsdynamik 99

0.8

0.6

0.4

0.2

3.6 Superstabiler Viererzyklus mit

0
0.2 0.4 0.6 0.8 1 r = 0:874640.

0.8

0.6

0.4

0.2
3.7 Drei chaotische Bänder für r =
0
0:9642 kurz oberhalb des großen Fen-
0.2 0.4 0.6 0.8 1 sters mit dem Dreierzyklus.

Bemerkenswert ist, daß der letzte Wert aus der Lösung einer Gleichung mit einer
32768 fach verschachtelten Wurzelfunktion gewonnen wird!
Mit
l = RRl 1 RRl 2
l l 1
finden wir folgende Näherungswerte für :

10 = 4:669201134601
11 = 4:669201509514
100 3 Iterationen

12 = 4:669201587522
13 = 4:669201604512
14 = 4:669201608116
15 = 4:669201608892
Daraus schätzen wir ab, daß wir bis auf 9 Stellen genau berechnet haben. Dem
Leser sei es als Übungsaufgabe überlassen, l für l !1
zu extrapolieren.
Zum Schluß wollen wir noch eine scheinbar einfache Frage untersuchen: Gege-
ben seien x0 = 1=3 und r = 97=100. Was ist der Wert von x100 ? Dies scheint sich
leicht beantworten zu lassen; mit
h[x ]:= 97/25 x(1–x)
gibt
Nest[h, N[1/3],100]
den Wert x100 = 0:144807. Dieser Wert aber ist falsch, der richtige Wert ist x100 =
0:410091.
Die Lösung des Widerspruchs liegt im chaotischen Verhalten der logistischen
Abbildung für den gegebenen Parameterwert. Der Ljapunow-Exponent, definiert in
den Gleichungen (3.6) bis (3.8), ist positiv. Also führen kleine Ungenauigkeiten in
der Rechnung schon nach wenigen Iterationen zu großen Fehlern. Wegen des Be-

40
Ergebnisgenauigkeit

20 3.8 Die Genauigkeit von x100

als Funktion der Rechengenau-
10 igkeit für r = 97=100. Die
vertikale Achse gibt die An-
0 zahl der Stellen an, mit der Ma-
0 20 40 60 80 100 thematica das Ergebnis der Ite-
Rechengenauigkeit ration berechnet.

fehls N[1/3] berechnet Mathematica alles in Maschinengenauigkeit, die in unse-

rem Beispiel 16 Stellen beträgt. Bei jedem Iterationsschritt wird gerundet, deshalb
kann die Abweichung vom wahren Wert, die bei jedem Schritt etwas größer wird,
nicht verfolgt werden. Mit N[1/3,genau] kann man dagegen mit genau die
Genauigkeit vorgeben. In jedem Rechenschritt reduziert nun Mathematica die er-
rechnete Genauigkeit, bis schließlich bei nur einer Stelle die xn -Variablen auf den
3.2 Frenkel-Kontorova-Modell 101

Wert 0 gesetzt werden. Der Befehl Precision[x] fragt die Genauigkeit von x
ab. Abbildung 3.8 zeigt das Ergebnis. Für genau=16 wird gerundet, also ändert
sich die Genauigkeit scheinbar nicht. Die richtige Berechnung zeigt aber, daß man
erst bei mehr als 60 Stellen Rechengenauigkeit das korrekte Ergebnis erhält. Der
Grund für den linearen Zusammenhang zwischen Rechen- und Ergebnisgenauigkeit
ist uns nicht bekannt.

Übung
1. Berechnen Sie für die logistische Abbildung (3.1) den Ljapunow-Exponenten als
Funktion des Parameters r .
2. Im chaotischen Bereich gibt es in jedem r -Intervall Fenster mit superstabilen pe-
riodischen Bahnen. Jede solche Bahn beginnt mit der symbolischen Dynamik CRL.
Für einen Fünferzyklus gibt es daher höchstens die vier Möglichkeiten CRLRR;
CRLRL; CRLLR und CRLLL. Eine dieser Möglichkeiten kommt aber nicht
vor. Berechnen Sie die Parameterwerte der drei verbleibenden Bahnen mit der Peri-
ode fünf.

Literatur
R. E. Crandall, Mathematica for the Sciences, Addison Wesley, 1991.
Hao Bai-Lin, Chaos, World Scientific, 1984.
H. J. Korsch, H.-J. Jodl, Chaos: A Program Collection for the PC, Springer Verlag,
1994.
E. Ott, Chaos in Dynamical Systems, Cambridge University Press, 1993.
H. O. Peitgen, D. Saupe, The Science of Fractal Images, Springer Verlag, 1988.
M. Schröder, Fraktale, Chaos und Selbstähnlichkeit, Spektrum Akademischer Ver-
lag, 1994.
H. G. Schuster, Deterministic Chaos, Physik Verlag, 1984.

3.2 Kette auf dem Wellblech: Frenkel-Kontorova-Modell

Konkurrieren zwei physikalische Kräfte miteinander, so kann der resultierende Zu-
stand faszinierende Eigenschaften haben. Schon beim Hofstadter-Schmetterling ha-
ben wir gesehen, wie zwei miteinander konkurrierende Längen – die vom Gitter und
die vom Magnetfeld erzeugte Länge – ein überraschend komplexes Energiespek-
trum ergaben. Hier wollen wir nun ein einfaches mechanisches Problem mit klas-
102 3 Iterationen

sischen Gleichgewichtsbedingungen betrachten: eine Kette aus Teilchen, die durch

lineare Kräfte miteinander wechselwirken und sich zusätzlich in einem periodischen
Potential aufhalten. Wir untersuchen nur die Ruhelagen der Kettenglieder. Sowohl
die Federkräfte als auch die äußeren Kräfte möchten den Teilchen einen eigenen,
aber unterschiedlichen Abstand zueinander aufzwingen. Es stellt sich heraus, daß
die stabilen Zustände der Kette durch Iterationen einer nichtlinearen zweidimensio-
nalen Abbildung beschrieben werden, deren Bahnen vielfältige Formen annehmen
können.

Physik
Unser System ist eine eindimensionale Anordnung von unendlich vielen Punktmas-
2
sen, deren Ruhelagen durch die Plätze xn (n Z) gekennzeichnet seien. Die Kräfte
auf die Teilchen sollen zum einen von einem äußeren periodischen Potential V (x)
und zum anderen von einem Wechselwirkungspotential W (xn xn 1 ) zwischen
benachbarten Teilchen herrühren, so daß die Energie eines langen Teilstückes der
Kette, das die Plätze xM +1 ; xM +2 ; : : : ; xN umfaßt, durch

X
N
HMN = [V (xn ) + W (xn xn 1 )] (3.10)
n=M +1
gegeben ist. Alle Längen x werden in Einheiten der Periode des äußeren Potentials
gemessen. Das bedeutet
V (x + 1) = V (x) : (3.11)
In der Ruhelage kompensieren sich alle Kräfte auf jedes Teilchen, es gilt also

0 = @H MN 0 0 0
@x = V (xn) + W (xn xn 1 ) W (xn+1 xn) : (3.12)
n
Mit der Definition
pn = W 0(xn xn 1 ) (3.13)
folgt hieraus

pn+1 = pn + V 0 (xn) ;
xn+1 = xn + (W 0) 1 (pn+1 ) ; (3.14)

oder als Rückwärtsrekursion aufgelöst,

xn 1 = xn (W 0 ) 1 (pn ) ;
pn 1 = pn V 0 (xn 1 ) : (3.15)
3.2 Frenkel-Kontorova-Modell 103

Aus (x0 ; p0 ) – äquivalent dazu ist die Vorgabe von (x 1 ; x0 ) – erhält man die Paare
(x1 ; p1 ) und (x 1 ; p 1 ), daraus die Werte (x2 ; p2 ) und (x 2 ; p 2 ) und so fort. Die
Gleichungen (3.14) beschreiben daher eine nichtlineare Iteration in der x-p-Ebene.
f
Jeder Startpunkt (x 1 ; x0 ) bestimmt eindeutig einen Zustand : : : ; x 2 ; x 1 ; x0 ;
g
x1 ; x2 ; : : : der gesamten Kette, bei dem sich jedes Teilchen in Ruhelage befindet.
Die Funktionaldeterminante der Abbildung (xn ; pn ) ! (xn+1 ; pn+1 ) hat den
@ (x n+1 ;pn+1 )
= 1; die Abbildung ist daher flächenerhaltend. Obwohl
Wert eins, @ (xn ;pn )
ein Ausschnitt aus der x-p-Ebene durch die Abbildung deformiert wird, hat sein
Bild denselben Flächeninhalt wie der ursprüngliche Ausschnitt. Flächenerhaltender
Fluß im Phasenraum ist aus der klassischen Mechanik bekannt (Satz von Liouville),
und tatsächlich kann man (3.14) als Momentaufnahmen (Poincaré-Schnitt, siehe
Abschnitt 4.2) einer kontinuierlichen Dynamik in einem dreidimensionalen Phasen-
raum auffassen.
Bisher wurden die Potentiale V und W noch nicht spezifiziert, doch nun sollen
sie auf ein äußeres Cosinus-Potential und lineare Federkräfte beschränkt werden:

V (x) = (2K)2 (1 cos(2x)) ;

W () = 21 ( )2 : (3.16)

K bestimmt die Stärke des periodischen Potentials, und ist der Abstand der Teil-
chen für K = 0 in Einheiten der Periodenlänge des Potentials. Wir modifizieren
Gleichung (3.13), die pn = xn xn 1 liefert, geringfügig und setzen
pn = xn xn 1 : (3.17)
Statt (3.14) erhalten wir dann

pn+1 = pn + 2K sin(2xn ) ;

xn+1 = xn + pn+1 : (3.18)
Diese Abbildung, die in der Literatur den Namen Standard- oder Chirikov-Abbil-
dung hat, ist in vielen Publikationen untersucht worden. Der Parameter kommt
nicht mehr in der Iteration, sondern nur noch in der Energie vor,
X
N
1 XN
1 (p )2 :
HMN = K (1 cos 2x n ) + n
n=M +1 (2 )
(3.19)
n=M +1 2
2

Für gegebene Parameter K und ist die mittlere Energie pro Teilchen

h = N lim 1 H :
M !1 N M MN
(3.20)
104 3 Iterationen

h ist eine Funktion von x0 und p0 , wobei der Grundzustand durch den Punkt (x0; p0 )
mit der kleinsten Energie h bestimmt ist.
Eine interessante Eigenschaft eines Zustandes wird durch die sogenannte Win-
dungszahl w beschrieben, die als mittlerer Abstand benachbarter Teilchen definiert
ist:
w = hxn+1 xn i = N lim xN xM :
M !1 N M
(3.21)

Falls ein Zustand relativ zum Gitter periodisch ist (ein kommensurabler Zustand),
so gibt es ganze teilerfremde Zahlen P und Q mit xn+Q = xn + P . Daraus folgt

P:
w = xn+QQ xn = Q (3.22)

Ein kommensurabler Zustand hat daher einen rationalen mittleren Teilchenabstand

w. Ein Zustand mit irrationalem w dagegen rastet nicht ins Gitter ein; dies zeigt sich
ebenfalls in einigen anderen physikalischen Eigenschaften. Wie beim Hofstadter-
Schmetterling unterscheidet die Physik auch hier zwischen rationalen und irrationa-
len Zahlen!

Algorithmus
Die Programmierung der Abbildung (3.18) ist sehr einfach. In Mathematica definie-
ren wir, weil es um numerische Manipulationen geht, pi=N[Pi] und die Funktion
t durch

t[{x_,p_}] = {x + p + k/(2 pi) Sin[2 pi x],

p + k/(2 pi) Sin[2 pi x]}

Iterationen können einfach durch Nest oder NestList ausgeführt werden:

list[x0_,p0_]:= NestList[t,{x0,p0},nmax]

Das Ergebnis von list[ ] ist eine Liste von nmax+1 Punkten in der x-p-Ebene
und beschreibt damit den physikalischen Zustand für die gegebenen Startwerte x0
und p0 = x0 x 1 . Nach Vorgabe der Lagen x0 und x 1 zweier benachbarter
Teilchen liefert list[] also die Positionen der weiteren Teilchen.
Ein anschauliches Bild der resultierenden Zustände erhalten wir, indem wir auf
f g
die Kurve V (x) die Teilchen mit den Koordinaten xn ; V (xn ) legen und diese
Punkte mit ListPlot zeichnen. Die Koordinaten xn werden aus dem Ergebnis
von list[..] mit dem Befehl

xlist[x0_,p0_]:= Map[First,list[x0,p0]]
3.2 Frenkel-Kontorova-Modell 105

herausgezogen.
Schon beim Pendel haben wir gesehen, daß es nützlich ist, anstatt der Funktion xn
das Phasenraumdiagramm in der x-p-Ebene zu betrachten (beim Pendel statt '(t)
das '_ (')-Diagramm). Wir brauchen dazu aber nur x und p jeweils im Intervall
[0; 1] darzustellen, denn die Abbildung (3.18) gibt dieselben Werte (modulo 1),
wenn zu xn oder pn jeweils der Wert 1 addiert wird.
Die Modulo-Abbildung kann man mit Map in eine Liste hineinziehen und auf die
einzelnen Koordinaten wirken lassen:
tilde[{x_,p_}]:= {Mod[x,1],Mod[p,1]}
listt[x0_,p0_]:= Map[tilde,list[x0,p0]]
Mit ListPlot wird das Phasenraumdiagramm erzeugt. Die Energie und die Win-
dungszahl sind leicht aus dem Zustand ll1 = list[x0,p0] zu berechnen:
de[{x_,p_}]:=k/(2 pi)ˆ2 (1–Cos[2 pi x])+(p–sigma)ˆ2/2

h[x0_:.0838,p0_]:=
( ll1=list[x0,p0];
ll2=Map[de,ll1];
Apply[Plus,ll2]/Length[ll2])

wind[x0_:.0838,p0_]:=
( w1=xlist[x0,p0]; (w1[[–1]] – w1[[1]])/nmax)
Allerdings dauert die Berechnung mit Mathematica wieder sehr lange. Deshalb wol-
len wir uns das Phasenraumdiagramm mit einem C-Programm noch einmal auf dem
Bildschirm direkt erzeugen. Außerdem sollen die Energie und die Windungszahl be-
rechnet werden. Der Startpunkt wird vom Programm zufällig ausgewählt.
Die Funktion (3.18) lautet in C:
pneu= p+K/2./pi*sin(2.*pi*x);
xneu= x+pneu;
Eigentlich sollten in dieser innersten Schleife, in der diese Befehle sehr oft aus-
geführt werden, die Ausdrücke K/2./pi und 2.*pi nicht jedesmal neu berech-
net, sondern durch Konstanten ersetzt werden. Bei unserem Programm benötigt die
Graphik aber so viel Computerzeit, daß wir auf die Optimierung des Algorithmus
verzichten. Die x-p-Werte werden nun in Bildkoordinaten umgerechnet:
xb=fmod(xneu,1.)*xmax+10;
yb=fmod(pneu,1.)*ymax+100;
und es wird ein Bildpunkt an die Stelle (xb,yb) gezeichnet; z. B. auf dem PC mit
106 3 Iterationen

putpixel(xb,yb,color);
Bei jedem Aufruf wird die Farbe neu gewählt:
color= random(getmaxcolor())+1;
So erhält man auf dem Bildschirm eine Graphik mit verschiedenen Trajektorien,
deren jede einen Zustand repräsentiert, in jeweils unterschiedlichen Farben.

Ergebnisse
Abbildung 3.9 zeigt die Ergebnisse der Iteration der Gleichung (3.18) für K = 1 .
Dabei wurden die Startwerte (x0 ; p0 ) zufällig im Einheitsquadrat gewählt, und es

3.9 Trajektorien in der x-p-Ebene. Auf der Workstation kann ein neuer Startwert mit der
Maus angeklickt werden, und die Trajektorie wird in einer neuen Farbe gezeichnet.

wurden jeweils 10000 Werte für (xn ; pn ) mit dem C-Programm berechnet und ge-
zeichnet. Dieses Bild ist unabhängig von dem Verhältnis der konkurrierenden
3.2 Frenkel-Kontorova-Modell 107

Längen, da dieser Parameter gar nicht in der iterierten Abbildung vorkommt. Zu

jeder Trajektorie gehört eine Windungszahl w, die vom Startpunkt und dem peri-
odischen Potential, nicht aber von abhängt. Erst in der Energie pro Teilchen
N
X
h = N1 K (1 cos(2x )) + 1 (p )2
(2) 2 n 2 n
n=1
taucht die Gleichgewichtskonstante auf.
Es gibt drei unterschiedliche Bahnen in der Abbildung 3.9: null-, ein- und zweidi-
mensionale. Die nulldimensionalen Trajektorien bestehen aus endlich vielen Punk-
ten, die z. B. in der Mitte der Inseln zu finden sind. Sie sind die kommensurablen
Zustände mit rationaler Windungszahl w = P=Q und der Periode Q. P zeigt an,
in welcher Reihenfolge die Q verschiedenen Punkte (xn ; pn ) durchlaufen werden.
Um diese kommensurablen Zustände herum sieht man geschlossene Bahnen, also
eindimensionale Trajektorien. Diese Zustände sehen fast so aus wie ihre kommen-
surablen Verwandten in der Mitte der Bahnen, allerdings schwankt jedes xn um den
entsprechenden kommensurablen Wert mit einer Frequenz, die inkommensurabel
zur Periode des Potentials ist.

0.5
0.475
0.45

p 0.425
0.4
0.375
3.10 Die Startwerte (x0 ; p0 )
= (0:08; 0:34) ergeben eine
0.35

0 0.2 0.4 0.6 0.8 fastperiodische Bahn im Pha-

x senraum (x; p) (modulo 1).

Wir wollen uns dies mit Mathematica für w = 2 ansehen. Zunächst lösen wir mit
5
FindRoot die Gleichung
Mod[t[t[t[t[t[{x0,p0}]]]]],1] == {x0,p0}
Allerdings muß man den Startwert ziemlich dicht bei der Lösung angeben, sonst fin-
det die Routine keine Lösung. Wir erhalten z. B. für (x0 ; p0 ) den Wert (0:0838255;
0:336171) als einen der Q = 5 Fixpunkte der fünffach iterierten Funktion t[x,p].
Abbildung 3.10 zeigt nun einen inkommensurablen Zustand mit (x0 ; p0 ) = (0:08;
0:34), also dicht beim periodischen Zustand in der Mitte der fünf Inseln. Er hat die-
selbe Windungszahl w = 0:4 und eine etwas höhere Energie als der periodische Zu-
stand. Abbildung 3.11 zeigt den fastperiodischen Zustand im Ortsraum. Man sieht
108 3 Iterationen

beim Teilchen in der Potentialmulde, daß die Tallage ein wenig um das Minimum
oszilliert. Etwa dieselbe Tallage wird nach Q = 5 Iterationen wieder erreicht. Man
sieht die Oszillation noch besser in Abbildung 3.12, in der die xn -Werte direkt ge-
gen n aufgetragen sind. Neben der Periode mit Q = 5 gibt es noch eine Welle mit
'
Q 30.

0.05

0.04

0.03

0.02
3.11 Dieselbe fastperiodische
0.01
Trajektorie wie in Abbildung
3.10, jedoch auf das Potential
V (x) gezeichnet.
0
0 1 2 3 4

0.8

0.6
x(n)

0.4

0.2
3.12 Wie in den Abbildungen
0 3.10 und 3.11, jedoch als Aus-
0 20 40 60 80 100 lenkung x (modulo 1) des n-ten
n Atoms gezeichnet.

Neben den null- und eindimensionalen Bahnen gibt es in Abbildung 3.9 noch Zu-
stände, die ganze Flächenstücke füllen. Solche Bahnen springen chaotisch auf dem
Bildschirm hin und her. Manche Bahnen durchmessen offenbar den ganzen x- und
p-Bereich. Letzteres gilt nicht für kleine K -Werte. Für K < Kc = 0:971635::: gibt
es eindimensionale Bahnen, die das gesamte Bild horizontal durchlaufen (sogenann-
te KAM-Trajektorien). Man kann zeigen, daß chaotische Bahnen die eindimensio-
nalen nicht überspringen können, sie sind also auf ein p-Intervall zwischen zwei
KAM-Trajektorien beschränkt. Bei Kc verschwindet die letzte KAM-Trajektorie,
p
und zwar diejenige mit der irrationalsten“ Windungszahl, dem inversen goldenen
Schnitt w = 2=(1 + 5) = 0:618: : .
”
Wir sind aber nicht allein an den Eigenschaften der Standard-Abbildung interes-
3.2 Frenkel-Kontorova-Modell 109

siert, sondern suchen denjenigen Zustand, der die tiefste Energie zu einem gegebe-
nen -Wert hat. Wir können das Minimum im Prinzip finden, indem wir h(x0 ; p0 )
für verschiedene (x0 ; p0 )-Werte berechnen. In der Praxis gibt es aber bessere Me-
thoden, die wir hier nicht vorstellen (siehe z. B. Griffiths). Abbildung 3.13 zeigt

0.029
0.028
Energie

0.027
0.026
0.025
0.024 3.13 Energie für = 0:4 ei-
nes kräftefreien Zustandes mit
Startwert x0 = 0:0838 als
0.2 0.25 0.3 0.35 0.4
p0 Funktion von p0 .

h(x0 ; p0) in einem Schnitt durch die x0 -p0 -Ebene für festes x0 = 0:0838 und
= 2=5. Die zugehörigen Windungszahlen w sind in Abbildung 3.14 zu se-
hen. Für p0 ' 0:35 nimmt h im betrachteten Intervall ein Minimum an. Wenn
wir das globale Minimum der Energie finden wollen, müssen wir die Funktion
h(x0 ; p0) in der gesamten x0 -p0 -Ebene absuchen. Am Minimum scheint w in den
Wert w = = 0:4 eingerastet“ zu sein. Wenn man für alle -Werte das genaue
”

0.5
0.475
0.45
Windungszahl

0.425
0.4
0.375
0.35
0.325
0.2 0.25 0.3 0.35 0.4
3.14 Mittlerer Nachbarabstand
w für die kräftefreien Zustände
p0 aus Abbildung 3.13 .

Minimum von h(x0 ; p0 ) mit der entsprechenden Windungszahl w bestimmt, so fin-

det man ein faszinierendes Verhalten der Funktion w( ), das auch als Teufelstreppe
bezeichnet wird: w rastet“ dabei in jede rationale Zahl P=Q in Stufen ein, deren
Breite mit wachsendem Q-Wert abnimmt. w( ) hat daher unendlich viele Stufen,
”
und zwischen je zwei Stufen liegen wieder unendlich viele. Dennoch ist w( ) stetig;
110 3 Iterationen

es gibt auch zu allen irrationalen Windungszahlen einen -Wert und einen zugehöri-
gen Grundzustand. Dieses Verhalten kann mathematisch bewiesen werden.
Die Funktion w( ), die sich aller Vorstellungskraft widersetzt, entsteht aus dem
Wettbewerb zweier Längen. Die zu den rationalen w-Werten gehörenden kommen-
surablen Grundzustände entsprechen einzelnen Punkten in der x-p-Ebene, während
man zeigen kann, daß die inkommensurablen Grundzustände keinen flächenfüllen-
den chaotischen Trajektorien sondern nur Linien entsprechen. Inkommensurable
Zustände können übrigens ohne Energieänderung über das Cosinus-Potential ge-
zogen werden.

Übung
Zeichnen Sie für verschiedene K -Werte von Gleichung (3.18) Trajektorien in der
x-p-Ebene. Für K = 0 sollten Sie die Bahnen mit der Hand zeichnen können. Beob-
achten Sie, wie die geschlossenen Bahnen, die sogenannten KAM-Trajektorien, mit
wachsendem Wert von K in Inseln oder chaotische Bahnen übergehen, und berech-
nen Sie die Windungszahlen der übriggebliebenen KAM-Trajektorien. Versuchen
Sie, kurz vor Kc die letzte geschlossene Bahn zu finden.

Literatur
H. J. Korsch, H.-J. Jodl, Chaos: A Program Collection for the PC, Springer Verlag,
1994.
E. Ott, Chaos in Dynamical Systems, Cambridge University Press, 1993.
H. G. Schuster, Deterministic Chaos, Physik Verlag, 1984.
R.B. Griffiths, Frenkel-Kontorova models of commensurate-incommensurate phase
transitions, Fundamental Problems in Statistical Mechanics VII, p. 69-110, H. van
Beijeren, Editor, Elsevier Science Publisher, 1990.
J.M. Greene, A method for determining a stochastic transition, J. Math. Phys. 20,
1183 (1979).

3.3 Fraktales Gitter

Ein einfaches Würfelspiel und eine simple geometrische Wiederholung: Beides führt
zu einem seltsamen Gebilde, das weniger als eine Fläche, aber mehr als eine Linie
ist, ein sogenanntes Fraktal mit einer Dimension von D = log 3= log 2 = 1:58 . . .
Überraschenderweise sind Fraktale sehr häufig in der Natur anzutreffen. Küsten-
linien, Gebirgszüge, Blutgefäße, Flußläufe, Schwankungen von Börsenkursen und
3.3 Fraktales Gitter 111

Flußpegel, alles dies kann durch eine gebrochene Dimension D beschrieben wer-
den. Neben dem geometrischen Spiel werden wir in den folgenden Abschnitten noch
Aggregate und Perkolationscluster als weitere Beispiele für diese merkwürdigen
selbstähnlichen Gebilde kennenlernen.
Hier wollen wir uns zunächst mit der Definition der fraktalen Dimension beschäf-
tigen. Danach stellen wir zwei Programme vor, die auf verschiedene Arten das
Sierpinski-Gerüst konstruieren, das oft als Standard-Beispiel für Fraktale beschrie-
ben wird.

Physik
Die räumliche Dimension D eines Objektes kann man durch die Beziehung zwi-
schen der Anzahl seiner Elemente, die seine Masse M ausmachen, und seiner Aus-
dehnung L angeben:
M LD :/ (3.23)
Wenn man also die Massen zweier gleichartiger homogener Würfel mit den Kan-
tenlängen L und 2L vergleicht, erhält man

M2 = 2L
D
M1 L = 2D (3.24)

mit D = 3. Bei Quadraten gibt dies offensichtlich D = 2 und bei Strecken D = 1.

L kann auch der Radius von Kugeln oder Scheiben sein oder jede andere charakte-
ristische Länge des betrachteten Objektes; die Masse ist natürlich proportional zur
Zahl der Teilchen. Auf jeden Fall gilt

D = Llim log M :
!1 log L
(3.25)

Es gibt auch einen anderen Weg, um die Dimension D zu bestimmen. Dazu über-
decken wir das Objekt vollständig mit kleinen Würfeln der Kantenlänge ". Es sei
/
N (") die kleinste Anzahl solcher Würfel. Dann gilt N (") " D bzw.
D = "lim log N (") :
!0 log "
(3.26)

3
Für einen Würfel benötigen wir (L=") überdeckende Kästchen, während die An-
2 1
zahl für ein Quadrat (L=") und für eine Linie (L=") beträgt.
Wenn wir also z. B. die Länge einer Grenze auf einer Landkarte bestimmen wol-
len, so können wir einen kleinen Maßstab mit der Länge " nehmen und die Zahl
112 3 Iterationen

N (") der Schritte bestimmen, die wir zum Abschreiten der Grenzlinie benötigen.
Dann sollte eigentlich
L = " N (") (3.27)
ein Maß für die Länge sein, denn wir erwarten als Grenze ein eindimensionales Ob-
jekt mit D = 1 . Auf diese Weise haben die Spanier die Länge ihrer Grenze zu
Portugal mit 987 km angegeben, während die Portugiesen aber dieselbe Grenze mit
1214 km bestimmt haben. Ein kleinerer Maßstab " benötigt offenbar mehr über-
deckende Schritte als L=", also kann nicht D = 1 gelten. Deshalb wird Gleichung
(3.27) eine Länge L ergeben, die von " abhängt. Eine genauere Analyse der Daten
zeigt folgendes: Eine Grenzlinie ist ein Fraktal mit 1 < D < 2, daher gibt Glei-
chung (3.27) L / "1 D , also eine scheinbar divergierende Länge für " 0. Die !
Grenze hat gar keine wohldefinierte Länge! Dies kann natürlich nur für Maßstäbe
" gelten, die größer als die kleinste (z. B. die Meßlatte der Vermessungsingenieure)
und kleiner als die größte Länge (z. B. die Ausdehnung von Portugal) sind.
Ein anderes einfaches Beispiel, bei dem die fraktale Dimension D nicht mit der
Einbettungsdimension d, also der Dimension des Raumes übereinstimmt, in dem
sich das Objekt befindet, ist eine Zufallsbewegung im d-dimensionalen Raum. Die-
ser Zufallsweg wird auch als einfaches Modell für ein Polymermolekül diskutiert,
das aus vielen Monomeren besteht. Dabei nehmen wir an, daß der Abstand benach-
barter Monomere konstant ist, die Winkel zwischen je drei aufeinanderfolgenden
aber unabhängig und zufällig verteilt sind. Die Verbindungsvektoren i benachbar- r
ter Monomere sind dann Zufallsvektoren mit leicht zu berechnenden Eigenschaften.
h i
Im Mittel ::: verschiedener Molekülkonfigurationen gilt:
hrii = 0; hri rj i hri i hrj i
= 6
= 0 fur i = j und 2 = a2 ; hri i
wobei a der Abstand benachbarter Monomere sein soll. Für den Vektor zwischen R
Anfang und Ende des Moleküls, das aus N + 1 Monomeren bestehen möge, gilt:
X
N
R= ri ;
i=1

X
und damit
N
hRi = hri i = 0 ;
i=1
N X
X N X N X
hR 2i = hri rj i = hri 2i + hri rj i = Na2 :
i=1 j =1 i=1 i6=j
Da die Masse M proportional zur Zahl N der Monomere und die lineare Ausdeh-
q
nung L proportional zu hR i
2 wächst, gilt also

M / L2
3.3 Fraktales Gitter 113

und mit Gleichung (3.23) folglich D = 2. Ein solcher Zufallsweg, im Fachjargon

random walk genannt, ist daher immer ein zweidimensionales Objekt, unabhängig
von der Dimension d des Raumes, in dem er erzeugt wird. Die fraktale Dimension
wird allerdings verkleinert, wenn man die Ausdehnung der einzelnen Monomere
mit berücksichtigt. Diesen Effekt werden wir im Abschnitt 5.4 besprechen.

Algorithmus und Ergebnis

Nun wollen wir uns die anfangs erwähnten Spiele genauer anschauen. Zunächst der
Algorithmus für das Würfelspiel:

Wähle drei Punkte p1; p2 und p3 und einen Startpunkt q0 beliebig in der Ebene.
Ausgehend vom Punkt qn, konstruiere den nächsten Punkt qn+1 auf folgende
p
Weise: Wähle zufällig (z. B. mit einem Würfel) einen der drei Punkte i . Dann
q p
berechne die Mitte der Verbindungslinie zwischen n und i , also

qn+1 = (qn + pi) =2 :

Iteriere die obige Gleichung unendlich oft.
Welches Muster erzeugen die Punkte fq 0 ; q 1 ; q 2 ; : : :g in der Ebene? Der Algorith-
mus, den wir wegen der höheren Rechengeschwindigkeit in C schreiben, ist leicht
zu programmieren. Jeden Punkt definieren wir als Struktur mit jeweils zwei ganz-
zahligen Variablen x und y , die die Pixelkoordinaten auf dem Bildschirm angeben.

struct{int x, int y} qn={20,20}, pw,

p[3]={{10,10},{MAXX–10,10},{MAXX/3,MAXY–10}} ;

Die Startwerte sind in der Typendeklaration direkt mit angegeben. In jedem Iterati-
onsschritt wird nun einer der drei Punkte p[i] durch das Ziehen einer Zufallszahl
2f g
i 0; 1; 2 ausgewählt,
pw = p[(3*rand())/RAND_MAX]

und ein neuer Punkt berechnet:

qn.x = (pw.x + qn.x)/2 ;

qn.y = (pw.y + qn.y)/2 ;

Dann wird an dieser Stelle ein Bildpunkt gezeichnet, z. B. auf dem PC mit

putpixel(qn.x, qn.y, WHITE) ;

114 3 Iterationen

3.15 Punkte in der Ebene, die durch

das im Text beschriebene Würfel-
spiel erzeugt wurden. Die Ecken des
Sierpinski-Dreiecks sind die Punkte
p[0],p[1] und p[2].

Das Ergebnis zeigt Abbildung 3.15. Erstaunlicherweise führt die Zufallsbewegung

des Punktes zu einer offenbar regelmäßigen Struktur, die aus ineinandergeschach-
telten Dreiecken besteht. Die Struktur ist selbstähnlich: Jedes Dreieck sieht gleich
aus, unabhängig von seiner Größe (natürlich nur für Dreicke, die wesentlich größer
als die Pixelabstände sind). Die Struktur ist aber fast leer, jedes Dreieck hat beliebig
viele Löcher auf jeder Längenskala. Jeder Startpunkt landet nach wenigen Iteratio-
nen auf diesem seltsamen Gitter; das Gerüst, das auch den Namen Sierpinski-gasket
hat, ist also ein Attraktor der Dynamik für die gesamte Ebene.
Das zweite geometrische Spiel lautet wie folgt:
Starte mit einem Dreieck,
entferne aus seiner Mitte ein Dreieck so, daß drei gleiche Dreiecke übrigbleiben,
iteriere dies unendlich oft für alle jeweils übrigbleibenden Dreiecke.
Wegen der einfachen Graphikbefehle wollen wir dies in Mathematica programmie-
ren. Jedes Dreieck wird durch eine Liste von drei Punkten in der Ebene beschrieben.
Das Startdreieck lautet:
list={{{0.,0.},{.5,N[Sqrt[3/4]]},{1.,0.}}}
Jedes Dreieck wird nun dadurch verdreifacht, daß man es erst mit einem Faktor 12
staucht und dann um eine Kantenlänge entlang zweier Kanten verschiebt:
3.3 Fraktales Gitter 115

verv[d_]:= Block[ {d1,d2,d3},

d1={d[[1]],(d[[2]]+d[[1]])*.5,
(d[[3]]+d[[1]])*.5};
d2=d1+Table[(d1[[3]]–d1[[1]]),{3}];
d3=d1+Table[(d1[[2]]–d1[[1]]),{3}];
{d1,d2,d3}
]

Diese Funktion wird mit dem Befehl Map auf die ganze Liste von Dreiecken wie-
derholt angewendet. Der Befehl Polygon produziert schließlich Dreiecke als Gra-
phikobjekte, die mit Show gezeichnet werden:
plot1:= Block[ {listzw,plotlist},
listzw=Map[verv,list];
list=Flatten[listzw,1];
plotlist=Map[Polygon,list];
Show[Graphics[plotlist],
AspectRatio –> Automatic]
]

3.16 Durch wiederholtes Herausschneiden von Dreiecken wird ein Fraktal mit der Dimensi-
'
on D 1:58 erzeugt.

Abbildung 3.16 zeigt das Ergebnis. Wir erhalten offenbar die gleiche Struktur wie
im vorherigen Würfelspiel. Jetzt können wir aber leicht einsehen, daß das selbstähn-
liche Gerüst im Limes unendlich vieler Iterationen ein Fraktal ist. Wenn wir eine
116 3 Iterationen

Kante der Länge L eines Dreiecks halbieren, so reduziert sich offenbar seine Masse
M um den Faktor 3. Nach t Schritten gilt
Mt = 3 t M ; Lt = 2 t L :
Daraus folgt

D = tlim ln Mt = lim ( t) ln 3 + ln M = ln 3 :
!1 ln Lt t!1 ( t) ln 2 + ln L ln 2
Das Sierpinski-Gerüst hat daher die gebrochene Dimension D = 1:58::: ; es füllt
zwar keine Fläche, ist aber mehr als eine Linie. Seine Dichte = M=L2 ist null,
und jedes noch so kleine Dreieck sieht genauso aus wie ein großes.
Es ist bemerkenswert, daß sich die Natur der Fraktale bedient, um z. B. jede Stel-
le eines Körpers effektiv mit Blut zu versorgen oder um platzsparende direkte Ver-
bindungen von 1011 kommunizierenden Nervenzellen in unserem Gehirn zu erzeu-
gen. Die Technik konnte die Fraktale bisher nur wenig nutzen. Das Buch von M.
Schröder allerdings beschreibt den Einsatz fraktaler Reflektoren in der Akustik.

Übung
Eine Koch-Kurve ist durch folgende Iteration definiert: Aus einer Strecke wird das
mittlere Drittel herausgetrennt und dafür eine Ausbuchtung mit gleicher Kantenlän-
ge wie im folgenden Bild hinzugefügt. Starten Sie mit einem gleichseitigen Dreieck

und iterieren Sie die obige Konstruktion für jede Kante möglichst oft. Sie erhalten
dann die Kochsche Schneeflocke.

Literatur
E. Ott, Chaos in Dynamical Systems, Cambridge University Press, 1993.
H. O. Peitgen, D. Saupe, The Science of Fractal Images, Springer Verlag, 1988.
M. Schröder, Fraktale, Chaos und Selbstähnlichkeit, Spektrum Akademischer Ver-
lag, 1994.
H. G. Schuster, Deterministic Chaos, Physik Verlag, 1984.
Stan Wagon, Mathematica in Aktion, Spektrum Akademischer Verlag, 1993.
3.4 Neuronales Netzwerk 117

3.4 Neuronales Netzwerk

Können Computer unser Gehirn simulieren? Jeder, der darüber nachdenkt, wird
wohl zu dem Schluß kommen, daß diese vermessene Frage für die heutigen Compu-
ter mit einem deutlichen Nein beantwortet werden muß. Zwar sind heutzutage eine
Menge von Fakten über die Arbeitsweise unseres Gehirns bekannt, trotzdem weiß
man noch nicht, wie aus dem Informationsaustausch von 1011 Nervenzellen (Neu-
ronen) und ihren 1014 Kontaktstellen (Synapsen) solche uns selbstverständlichen
Vorgänge wie Lernen, Erkennen und Denken entstehen können.
Wir wissen wenig, aber dennoch versuchen zur Zeit einige tausend Wissenschaft-
ler und Ingenieure, Computerprogramme zu entwickeln, die sowohl von der Archi-
tektur als auch von der Funktion des Gehirns lernen. Solche Algorithmen und deren
Hardware-Realisierung nennt man Neuronale Netzwerke bzw. Neurocomputer; in
der Tat haben sie Eigenschaften, die sich deutlich von den heutigen Computern un-
terscheiden.
Ein Neuronales Netz erhält kein Computerprogramm, sondern es lernt anhand
von Beispielen, indem es die Stärken seiner Synapsen daran anpaßt. Nach der Lern-
phase kann es verallgemeinern, d. h. es hat aus den Beispielen Regeln erkannt. Die
gelernte Information ist nicht wie im Computer in numerierten Schubladen gespei-
chert, sondern verteilt im gesamten Netz der Synapsen. Die Logik ist kein strenges
Ja oder Nein“ , sondern ein verschwommenes Mehr oder Weniger“ .
” ”
Viele eindrucksvolle Anwendungen der Neuronalen Netze sind in den letzten
Jahren demonstriert worden: englischen Text aussprechen, Ziffern erkennen, Back-
gammon spielen, Motordefekte an den Laufgeräuschen erkennen, Bankkunden nach
ihrer Kreditwürdigkeit beurteilen, Börsenkurse vorhersagen usw. Es hat sich her-
ausgestellt, daß Neuronale Netze oft mit anderen, viel komplizierteren Methoden
konkurrieren können. Dabei sind die Lernregeln verblüffend einfach und universell.
Das einfachste Neuronale Netz, das sogenannte Perzeptron, wurde schon in den
sechziger Jahren angewendet und mathematisch untersucht. Es soll hier vorgestellt
und programmiert werden. Unser Perzeptron lernt, die Tastatureingabe 1 und 0 vor-
herzusagen. Selbst wenn der Leser sich bemüht, die beiden Tasten völlig zufällig
zu wählen, wird das Netzwerk im Mittel besser als 50% richtig vorhersagen. Zwar
ist diese Fähigkeit noch recht bescheiden, doch immerhin kann ein Rechner mit ei-
nem Fünf-Zeilen-Algorithmus eines C-Programmes lernen, menschliches Verhalten
vorherzusagen; das sollte uns doch zu denken geben!

Physik
Das Perzeptron besteht aus einer Eingabeschicht von Neuronen“ Si , einer weiteren
Schicht von N synaptischen“ Gewichten wi (i = 1; :::; N ) und aus einem Aus-
”
”
118 3 Iterationen

gabeneuron S0 , das mit allen Eingabeneuronen direkt über Synapsen verkoppelt ist.
Wie bei realen Nervenzellen reagiert das Element S0 auf die Summe der Aktivitäten
derjenigen Neuronen, die über die synaptischen Verbindungen direkt auf S0 einwir-
ken können. Schon 1943 wurde dieser recht komplexe zeitabhängige Vorgang durch
eine einfache mathematische Gleichung beschrieben:

X
N !
S0 = sign Sj wj : (3.28)
j =1
Dabei kann jedes Neuron nur zwei Zustände annehmen: Es ruht (Si = 1) oder
2
es sendet Impulse (Si = 1). Die Koeffizienten wi R modellieren die Stärke, mit
der das ankommende Signal des Neurons Si durch die Synapse in ein elektrisches
Potential im Kern von S0 umgewandelt wird. Die reelle Zahl wi beschreibt komple-
xe biochemische Prozesse; eine Synapse kann beispielsweise hemmend (wi < 0)
oder erregend (wi > 0) sein. Wenn die Summe der Potentiale den Schwellenwert 0
überschreitet, dann feuert das Neuron (S0 = +1), sonst ruht es (S0 = 1).
Dies ist die biologische Motivation für die Gleichung (3.28). Mathematisch de-
f
finiert sie eine Boolesche Funktion +1; 1 N g !f g
+1; 1 , die jede der mögli-
S
chen Eingaben = (S1 ; S2 ; : : : ; SN ) nach +1 oder 1 klassifiziert. Es existieren
S
2N verschiedene Eingaben .N Im allgemeinen kann man jede davon mit +1 oder
1 markieren, also gibt es 2(2 ) Boolesche Funktionen; für N = 10 erhält man die
unvorstellbar große Zahl 10308 .
Das durch Gleichung (3.28) charakterisierte Perzeptron definiert aber nur speziel-
S w
le Boolesche Funktionen. Geometrisch gesehen sind und = (w1 ; w2 ; : : : ; wN )
Vektoren im N -dimensionalen Raum. Gleichung (3.28) trennt die Ausgaben S0 = 1
und S0 = 1 durch die (N 1)-dimensionale Hyperebene wS = 0. Daher nennt
man das Perzeptron auch eine linear separable Boolesche Funktion. Man kann zei-
gen, daß deren Anzahl kleiner als 2(N ) ist, für N = 10 aber immerhin noch 1030 .
2

Was bedeutet nun Lernen und Verallgemeinern für das durch Gleichung (3.28)
beschriebene Perzeptron? Ein Neuronales Netzwerk erhält weder Regeln noch Pro-
gramme, sondern Beispiele. In unserem Fall bestehen die Beispiele aus einer Men-
x x
ge von Eingabe/Ausgabe-Paaren, ( ; y ) mit = (x 1 ; x 2 ; : : : ; x N ), y 2
f g
+1; 1 und = 1; :::; M , die von einer unbekannten Abbildung geliefert wer-
den. Wie bei realen Nervenzellen lernt unser Netzwerk durch synaptische Plasti-
zität“ , d. h. es paßt die Stärke seiner Gewichte wi an die Beispiele an. Im günstig-
”
sten Fall kann das Perzeptron nach der Lernphase alle Eingaben richtig klassifizie-
ren:
wx
y = sign ( ) : (3.29)
Schon seit den sechziger Jahren sind effektive Lernregeln für das Perzeptron be-
kannt. Bereits 1949 hat D. Hebb postuliert, daß Synapsen sich an die Aktivität ihrer
3.4 Neuronales Netzwerk 119

beiden Ein- und Ausgangsneuronen anpassen. Mathematisch wurde diese Aussage

später so formuliert:
w = N1 y x : (3.30)

Bei der Präsentation des -ten Beispiels ändert sich jede Synapsenstärke wi ein we-
nig, und zwar proportional zum Produkt aus Eingabe- und Ausgabeaktivität. Wenn
x
nur ein Beispiel ( ; y ) gelernt werden soll, sieht man leicht, daß Synapsen aus Glei-
chung (3.30) die zu lernende Bedingung (3.29) perfekt erfüllen (xj 2f g
+1; 1 ) :
N
wx=
X y x x = y X
N
xj xj = y :
j =1 N j j N j =1
(3.31)

O
Allerdings geht das nicht mehr, wenn N Neuronen M = (N ) Beispiele lernen
sollen; in diesem Fall muß man Gleichung (3.30) ein wenig abändern. Jedes Beispiel
soll nur dann mit Gleichung (3.30) gelernt werden, wenn es noch nicht richtig durch
w
das momentane abgebildet wird:

w = N1 y x wenn (w x ) y 0; sonst w = 0 : (3.32)

Dies ist die bekannte Perzeptron-Lernregel, für die Rosenblatt 1960 einen mathema-
x
tischen Konvergenzbeweis gefunden hat: Wenn die M Beispiele ( ; y ) überhaupt
durch ein Perzeptron richtig abgebildet werden können, dann stoppt der Algorith-
mus (3.32). In diesem Fall findet die Lernregel (3.32) also immer einen Gewichts-
w
vektor , einen von vielen, der für alle Beispiele die Gleichung (3.29) erfüllt.
Da dieses Lehrbuch Algorithmen betont, wollen wir den Beweis hier vorstellen.
z x
Mit der Definition = y suchen wir also ein w
mit wz > 0 für =
w w z
1; :::; M . Nach Voraussetzung soll es ein solches mit c > 0 für alle
geben. Die Konstante c > 0 entspricht dem kleinsten Abstand der Punkte zu z
w
der durch definierten Hyperebene.
w 0
Wir starten nun den Algorithmus mit (t = 0) = . t soll diejenigen Lernschrit-
te zählen, bei denen die Gewichte geändert werden, bei denen also (t) w z 0
gilt. Bei jedem solchen Schritt t liefert die Lernregel

w(t + 1) = w(t) + N1 z ; (3.33)

Wenn wir Gleichung (3.33) vektoriell quadrieren, erhalten wir

(w(t + 1))2 = (w(t))2 + N2 w(t) z + N12 (z )2

(w(t))2 + 1 : N (3.34)
120 3 Iterationen

z 2 = Pj z2 = N ist.
Beachten Sie, daß ( ) j

Iteriert man Gleichung (3.34) von 0 bis t, so erhält man mit w(0) = 0:
(w(t))2 Nt : (3.35)

Eine Abschätzung für das Skalarprodukt w w(t + 1) ergibt

w w(t + 1) = w w(t) + N1 w z w w(t) + Nc ; (3.36)

die Iteration von 0 bis t also

w w(t) cNt : (3.37)

Nun setzen wir (3.35) und (3.37) in die Schwarzsche Ungleichung

(w(t))2 (w )2 (w(t) w )2 (3.38)

ein und erhalten

t (w )2 c2 t2 ;
N N2 (3.39)

oder

t N (wc2) = t :
2
(3.40)

Damit ist die Zahl t der durchgeführten Lernschritte beschränkt, der Algorithmus
stoppt nach höchstens t Schritten. Er endet aber nur, wenn alle Beispiele richtig
abgebildet werden. Die Perzeptron-Regel kann also alle lernbaren Probleme auch
wirklich perfekt lernen.
Wenn sehr viele Beispiele gelernt werden sollen, wird der Abstand c zur Hyper-
ebene klein und damit die Zahl t der Lernschritte sehr groß. Das bedeutet, daß man
eventuell jedes Beispiel sehr oft lernen muß, bis schließlich alle richtig klassifiziert
werden.
Wieviele Beispiele kann ein Perzeptron überhaupt lernen? Das hängt offenbar
von der unbekannten Abbildung ab, die die Beispiele erzeugt. Wenn diese von einem
anderen Perzeptron stammen, dann kann nach dem obigen Konvergenz-Theorem
jede Anzahl M gelernt werden. Wenn dagegen die Klassifikationsbits y zufällig
gewählt sind, dann gibt es wieder exakte Aussagen: Für M < N können alle Bei-
spiele perfekt gelernt werden, im Limes N !1 sogar (mit Wahrscheinlichkeit 1)
für M < 2N .
3.4 Neuronales Netzwerk 121

Nach der Lernphase kann das Perzeptron verallgemeinern. Das bedeutet, daß es
S
eine Eingabe , die es vorher nicht gelernt hat, genauso klassifiziert wie die unbe-
kannte Abbildung, von der es gelernt hat. Wenn die Lehrer“-Funktion für eine Ein-
S
gabe das Resultat S0 liefert, dann ist ein Maß g für die Verallgemeinerungsfähig-
”
keit folgendermaßen definiert

g = h (S0 w S )iS ; (3.41)

wobei über viele Eingaben S gemittelt wird. g = 1=2 ist das Ergebnis von zufälli-
gem Raten, das Perzeptron kann in diesem Fall nicht verallgemeinern. Bei g > 1=2
dagegen hat das Perzeptron in den gelernten Beispielen eine gewisse Regelmäßig-
keit erkannt und stimmt mit der Wahrscheinlichkeit g mit dem Lehrer“ überein.
”
Wir wollen nun das Perzeptron benutzen, um Zeitreihen zu analysieren und Vor-
hersagen für den nächsten Zeitschritt zu machen. Es sei eine Folge von Bits gegeben,
z. B.

F = (1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; :::) : (3.42)

Das Perzeptron tastet jeweils ein Fenster von N Bits ab

x = (F ; F+1 ; :::; F+N 1 ) (3.43)

und macht eine Vorhersage für das Bit F +N :

F~+N = sign (w x ) : (3.44)

Dann lernt das Perzeptron das Beispiel (x ; F +N ) mit der Rosenblatt-Regel (3.32)
bzw. (3.33), schiebt das Fenster um ein Bit nach rechts und macht eine neue Vor-
x
hersage für die Eingabe +1 . Dies wird iteriert und eine Trefferrate g bestimmt.
F
Wenn die Folge eine Periode M hat, dann gibt es offenbar M Beispiele und für
M < N kann das Perzeptron diesen ”Rhythmus“ perfekt lernen. Eine Zufallsfolge
dagegen wird immer eine Trefferrate von g = 50% liefern. Wir wollen selbst eine
Bitfolge eingeben und testen, ob und wie gut ein einfaches Perzeptron deutliche
bzw. unbewußte Regelmäßigkeiten daran erkennen kann.

Algorithmus
Dazu programmieren wir das Perzeptron in der Sprache C. Die Neuronenaktivität
wird im Feld neuron[N] und die synaptischen Gewichte in weight[N] gespei-
chert. Die Variable input erhält das nächste Bit. Es wird immer nur das letzte
Beispiel gelernt. Der Lern- und Vorhersage-Algorithmus (3.32) und (3.44) lautet
dann einfach:
122 3 Iterationen

while (1) f
1. Einlesen:
if (getch() == ’1’) input=1; else input = –1; runs++;
2. Potential berechnen:
for (h=0., i=0; i<N; i++) h += weight[i] * neuron[i];
3. Treffer der Vorhersage zählen:
if(h*input >0) correct++;
4. Lernen:
if(h*input < 0)
for (i=0; i<N; i++)
weight[i] += input*neuron[i]/(float)N;
5. Fenster verschieben:
for (i=N–1; i>0; i––) neuron[i] = neuron[i–1];
neuron [0]= input;
g /* end of while */
Der wesentliche Teil des Programmes nn.c besteht also wirklich nur aus fünf Zei-
len. Alles übrige ist Initialisierung und Bildschirmgraphik. Die Trefferrate in der
Form correct/ runs*100.0 wird jedes Mal ausgedruckt, ebenfalls die Stärke
der Gewichte und das Ergebnis der Vorhersage. Nach der Taste n wird neu gezählt,
und mit e verläßt man das Programm.
Die Version nnf name übernimmt die Eingaben 1 und 0 aus der Datei name.
Wir wollen hier kurz zeigen, wie man Argumente aus der Kommandozeile überneh-
men und eine Datei lesen kann. Die Funktion main enthält nun Argumente
main(int argc, char *argv[])
argc enthält die Anzahl der Eingabeworte, hier argc=2. Die beiden Feldkom-
ponenten argv[0] und argv[1] enthalten die Adressen des Programmnamens
(nnf) und des Arguments (name). Wird kein Name eingegeben, so soll er abge-
fragt und eingelesen werden. Mit diesem Namen wird dann die entsprechende Datei
zum Lesen geöffnet.
FILE *fp;
char str[100];
if(argc==1) { printf("Welche Eingabedatei?");
scanf("%s", str);
}
else strcpy(str, argv[1]);
if((fp=fopen(str,"r"))==NULL)
{ printf("Datei nicht vorhanden");
exit(1); }
3.4 Neuronales Netzwerk 123

Das Einlesen der Zeichen 1 und 0 lautet dann folgendermaßen:

while(feof(fp)==NULL)
{ switch(fgetc(fp))
{ case’1’: input=1; break;
case’0’: input=–1; break;
default: continue;
}
...
feof signalisiert das Dateiende und fgetc liest das nächste Zeichen aus der Da-
tei, die durch fopen den Zeiger fp erhalten hat. break springt aus dem switch-
Befehl heraus, und continue überspringt den Rest der while-Schleife, die wie
vorher die Schritte zwei bis fünf enthält. Das Programm nnf nimmt nur die Einga-
ben 1 und 0 als Bitsequenz, während nn die Eingabe 1 oder verschieden von 1“ in
”
+1 und –1 umwandelt.

Ergebnis
Der Aufruf nn stellt das Perzeptron auf dem Bildschirm graphisch dar (Bild 3.17).
Die Bitfolge aus der Tastatureingabe 1 oder 0, dargestell als roter bzw. grüner Punkt,

3.17 Neuronales Netz zur Vorher-

sage einer Zeitreihe.

ist zwar 20 Schritte weit zu sehen, das Perzeptron greift aber nur die letzten 10 Bits
ab und macht eine Vorhersage für die folgende Eingabe. Diese wird natürlich nicht
angezeigt, sondern das Ergebnis der Übereinstimmung wird erst nach der Eingabe
ausgedruckt. Den Lernvorgang sieht man an der Änderung der synaptischen Ge-
wichte, die als violette Balken gezeichnet werden. Die Trefferrate g ist das wesent-
liche Ergebnis; g > 50% bedeutet, daß das Perzeptron eine Struktur in der Bitfolge
erkannt hat.
124 3 Iterationen

Zunächst tippen wir einen Rhythmus ein, z. B.

1010101010:::
Nach wenigen Schritten hat das Netzwerk diese zwei Muster gelernt und liefert nur
noch richtige Vorhersagen. Wechselt man dann die Folge zu einer anderen Periode,
z. B.

111001110011100::: ;
so hat das Perzeptron ebenfalls nach wenigen Schritten diese Folge perfekt gelernt.
Eine Rückkehr zum vorherigen Rhythmus gelingt natürlich wieder perfekt. Da die
w
Stärke der Synapsen aber durch den gesamten Lernvorgang beeinflußt wird, hat
w andere Koeffizienten als vorher.
Nun versuchen wir, 1 und 0 zufällig einzutippen. Wir haben dies mit Studen-
ten unserer Vorlesung getestet, die jeweils etwa 1000 mal die beiden Zeichen in
möglichst zufälliger Folge in eine Datei geschrieben haben. Die Auswertung mit
nnf ergab eine mittlere Trefferrate von g = 60%, mit Werten von 50% g
80%. Offenbar ist es recht schwierig, Zufallsfolgen per Hand zu erzeugen. Oft gibt
schon die Vorhersage 1 ! !
0 bzw. 0 1 eine Trefferrate g > 50%. Das Perzeptron
erkennt recht schnell solche Rhythmen.
Fünf Zeilen eines Computerprogrammes sind also in der Lage, unsere Reaktio-
nen mit einer gewissen Wahrscheinlichkeit g vorherzusagen. Umgekehrt sollten wir
allerdings auch in der Lage sein, das Netzwerk zu überlisten, denn das Perzeptron
ist ein einfaches deterministisches System, das wir genau berechnen können. Wir
können daher im Prinzip ausrechnen, welche Vorhersage das Netzwerk machen wird
und dann genau das Gegenteil eintippen. So sollte es uns gelingen, die Trefferrate g
weit unter 50% zu drücken.
In der Tat lieferte ein Student eine Bitfolge ab, die g = 0 ergab. Später räumte
er allerdings ein, das Programm bereits zu kennen, so daß er sich das Gegenbit vom
Netzwerk selbst erzeugen lassen konnte. Eigene Versuche, auf die Vorhersagen des
Modells entsprechend zu reagieren, konnten g auf etwa 40% drücken. Wir laden
unsere Leser herzlich ein, beides auszuprobieren: die Erzeugung von Zufallsbits
und die Überlistung des Perzeptrons.

Übung
Schreiben Sie per Hand in eine Datei name.dat eine Folge von etwa 2000 Zei-
chen, und zwar 1 oder 0, die möglichst zufällig eingetippt werden sollen. Fremdzei-
chen werden vom Programm ignoriert. Lassen Sie diese Daten mit nnf name.dat
auswerten. Sind Sie ein guter Zufallszahlengenerator? Überprüfen Sie, ob Zufalls-
3.4 Neuronales Netzwerk 125

bits, die vom Computer erzeugt werden, eine Trefferrate von etwa 50% liefern. Wie
groß darf die Abweichung von 50% sein?

Literatur
J. Hertz, A. Krogh, R. G. Palmer, Introduction to the Theory of Neural Computation,
Addison-Wesley, 1991.
B. Müller, J. Reinhardt, M. T. Strickland, Neural Networks: An Introduction, Sprin-
ger Verlag, 1995.
Kapitel 4
Differentialgleichungen

Seit mehr als 300 Jahren beschreiben Physiker die Bewegung von Massen durch Ge-
setzmäßigkeiten im unendlich Kleinen: Massenelemente bewegen sich durch Kräfte
in einem winzigen Zeitschritt eine winzige Strecke vorwärts. Eine solche Beschrei-
bung führt auf Differentialgleichungen, die auch heute noch das wichtigste Werk-
zeug in der Physik sind. Wenn doppelt so starke Ursachen eine doppelt so große
Wirkung haben, kann man die Gleichungen meist lösen. Bei nichtlinearen Differen-
tialgleichungen dagegen ist man oft auf einige wenige lösbare Spezialfälle oder auf
numerische Lösungen angewiesen. In diesem Kapitel wollen wir eine Einführung in
einige der numerischen Methoden geben und dazu einfache physikalische Beispiele
lösen.
Es gibt viele fertige Programmpakete zur numerischen Lösung von Differential-
gleichungen. So kann man beispielsweise in Mathematica mit NDSolve gewöhn-
liche Differentialgleichungen lösen, ohne die Einzelheiten des Programms zu ken-
nen. Trotzdem wollen wir hier nicht ganz auf die Beschreibung der Algorithmen
verzichten, denn erstens muß man bei großen und schwierigen Problemen immer
selbst einen Kompromiß zwischen Rechenzeit und Rechengenauigkeit suchen, und
zweitens gibt es für viele Spezialfälle besondere Methoden, die auch heute noch
erforscht werden.

4.1 Runge-Kutta-Methode

Grundlagen
Zunächst wollen wir die Lösung einer gewöhnlichen Differentialgleichung disku-
tieren. Dazu betrachten wir eine Funktion y (x), deren n-te Ableitung y (n) (x) sich
als Funktion von x und allen vorherigen Ableitungen schreiben läßt,

y(n) = f (x; y; y0 ; y00 ; : : : ; y(n 1) ) ; (4.1)

also eine explizite Differentialgleichung n-ter Ordnung. Diese Gleichung ist äquiva-
lent zu n Gleichungen erster Ordnung, denn mit y1 = y; y2 = y 0 ; : : : ; yn = y (n 1)
128 4 Differentialgleichungen

erhält man das Gleichungssystem

y10 = y2
y20 = y3
..
. (4.2)
y0
n 1 = yn
yn0 = f (x; y1 ; :::; yn ) ;
oder in Vektorform mit y = (y1 ; y2 ; :::; yn ) ;

y 0 (x) = lim y(x + x) y(x) = f (x; y) :

x!0 x (4.3)

y
Kennt man den Vektor am Ort x, so kann man seinen Wert nach einem winzigen
Schritt x +x mit Gleichung (4.3) berechnen. Dies ist auch die numerische Metho-
de: Die Ortskoordinate x wird diskretisiert und mit Gleichung (4.3) versucht man,
y am Nachbarort x + x möglichst genau zu berechnen.
Zur Beschreibung der numerischen Methode beschränken wir uns auf die Dimen-
y f
sion n = 1, d. h. und haben nur je eine Komponente y und f . Der vorzustellende
Algorithmus läßt sich später leicht auf beliebige Dimensionen erweitern. Sei also

y0 = f (x; y) (4.4)

gegeben. Für den Start der Rechnung benötigen wir offenbar einen Anfangswert
y(x0) = y0. Zunächst diskretisieren wir die x-Achse:
xn = x0 + n h ; (4.5)

wobei n eine ganze Zahl und h die Schrittweite ist. Seien yn = y(xn ) und yn0 =
y0(xn). Dann gibt die Taylor-Entwicklung
yn1 = y(xn h) = yn h yn0 + h2 yn00 h6 yn000 + O(h4 ) :
2 3
(4.6)

yn0 erhält man aus Gleichung (4.4). In der einfachsten Näherung, dem sogenannten
Euler-Verfahren, erhält man damit:

yn+1 = yn + h f (xn; yn) : (4.7)

Der Fehler ist von der Größenordnung h2 . Diese Methode wird nicht für den prak-
tischen Einsatz empfohlen. Mit nur geringem Aufwand kann sie wesentlich verbes-
sert werden.
Gleichung (4.7) berücksichtigt nur die Steigung f am Punkt (xn ; yn ), obwohl
sie sich auf dem Weg zum nächsten Punkt (xn+1 ; yn+1 ) schon wieder geändert hat.
4.1 Runge-Kutta-Methode 129

Die Taylorreihe (4.6) zeigt, daß es günstiger ist, die Steigung auf dem halben Weg
zu diesem Punkt zu benutzen, denn dann gewinnt man eine Größenordnung in der
Schrittweite h. Doch dazu muß man zunächst eine geeignete Schätzung für yn+ 21 =

y xn + h2 finden. Dies ist die Idee des Runge-Kutta-Verfahrens, das schon im Jahr
1895 entwickelt wurde. Nimmt man die Entwicklung (4.6) an der Stelle xn + h2 mit
der Schrittweite h2 , so gilt:

h y0
h 2 1
00
yn = yn+ 2 yn+ + O(h ) ;
+ 2 3
1
2 n+ 21 1

h 2 1
2 2

yn+1 = yn+ + h2 yn0 +

1
2
1
2
+ 2 2 yn00+ + O(h3 ) :
1
2
(4.8)

Daraus folgt:
yn+1 = yn + h yn0 + + O(h3 ) : (4.9)
approximieren wir durch f x ; y + h f (x ; y ) +
1
2

yn0 + = f xn+ ; yn+

1 1 1
n+ n 2 1 n n
O(h2 ), so daß wir zu folgendem Algorithmus gelangen:
2 2 2 2

k1 = h f (xn ; yn) ;
h
k2 = h f xn + 2 ; yn + 2 ;k 1

yn+1 = yn + k2 : (4.10)

Dieses Runge-Kutta-Verfahren zweiter Ordnung macht also einen Fehler der Grö-
ßenordnung h3 bei nur zwei Berechnungen der Funktion f . Wenn man diesen Re-
chenschritt mehrmals iteriert, kann man noch höhere Ordnungen von h auslöschen.
Das in der Praxis bewährte Verfahren benötigt vier Rechnungen bei einem Fehler
von der Ordnung h5 . Wir geben nur das Ergebnis an:

k1 = h f
(xn ; yn ) ;
h k 1
k2 = h f xn + 2 ; yn + 2 ;
h k
2
k = h f x + ;y +
3 n 2 2 ;n
k4 = h f (xn + h; yn + k3 ) ;
yn+1 = yn + k61 + k32 + k33 + k64 : (4.11)

Es bleibt das Problem, die Größe der Schrittweite h zu wählen. Eine Möglichkeit,
einen geeigneten Wert für h zu finden, besteht darin, das Ergebnis für verschiedene
130 4 Differentialgleichungen

h-Werte zu prüfen. Bei schwacher Änderung von y kann man sich große Schrittwei-
ten leisten, während man im umgekehrten Fall viele kleine Rechenschritte braucht.
Wenn also die Steigung von y stark variiert, sollte das Programm selbsttätig die
Schrittweite h reduzieren.
Um den Fehler abzuschätzen, berechnet man parallel zu je zwei Runge-Kutta-
Schritten (4.11) mit der Schrittweite h (Ergebnis y21 ) einmal einen Runge-Kutta-
Schritt mit der Schrittweite 2h (Ergebnis y12 ). Dies kostet weniger als 50 % Mehr-
aufwand, da die Ableitung am Startpunkt ohnehin schon berechnet ist. Bezeichnen
wir die exakte Lösung für einen Schritt von x nach x +2h mit y (x +2h), so beträgt
die Abweichung der Näherungswerte y21 , bzw. y12 von y (x +2h) , da wir ja eine
Methode vierter Ordnung verwenden:

y(x + 2h) = y21 + 2 h5 + O(h6 ) ;

y(x + 2h) = y12 + (2h)5 + O(h6 ) : (4.12)

Die Konstante ist durch die fünfte Ableitung der Funktion y (x) bestimmt. Für den
Unterschied = y12 y21 folgt hieraus:

/ h5 : (4.13)

Wenn wir also zwei Schrittweiten h1 und h0 wählen, so gilt:

0 :2
h0 = h1

0
: (4.14)
1
Aus dem berechneten Fehler 1 zur Schrittweite h1 kann damit die Schrittweite h0
für die gewünschte Genauigkeit 0 berechnet werden. Bezieht man die gewünschte
Genauigkeit auf den globalen statt wie in (4.12) bis (4.14) auf den lokalen Fehler, so
muß in Gleichung (4.14) der Exponent 1=5 durch 1=4 ersetzt werden. In der Praxis
hat sich ein gemischtes Verfahren als verläßlich erwiesen, das bei einer möglichen
Vergrößerung von h vorsichtshalber den Exponenten 1=5 und bei einer nötigen Ver-
kleinerung den Exponenten 1=4 benutzt.
Oft gibt es in der Physik Bewegungsgleichungen der Form

dx = v(t) ;
dt
dv = f (x(t); t) :
dt (4.15)

v(t) ist die Geschwindigkeit eines Teilchens mit der Bahn x(t). In diesem Fall gibt
es einen Trick, um die Steigung zwischen zwei Punkten abzuschätzen: Man berech-
net x zu den Zeiten tn = t0 + n h mit n = 1; 2; 3::: und v zu den Zwischenzeiten
4.1 Runge-Kutta-Methode 131

tn+ 1
2
durch

vn+ = vn + h f (xn ; tn ) ;
1
2
1
2

xn+1 = xn + h vn+ : 1
2
(4.16)
Der Algorithmus springt also immer hin und her zwischen der Berechnung des Ortes
x und der Geschwindigkeit v an den Zwischenplätzen. Deshalb hat er den Namen
leapfrog (Bocksprung). Da die Ableitungen immer in der Mitte zwischen jeweils
zwei aufeinanderfolgenden Werten berechnet werden, ist der Fehler von der Ord-
nung h3 . Obwohl die Leapfrog-Methode denselben Rechenaufwand wie der Euler-
Schritt erfordert, ist sie genauer und in der Praxis viel robuster. Sie wird daher gern
bei der Molekulardynamik verwendet, also bei der Lösung der Bewegungsgleichun-
gen von vielen miteinander wechselwirkenden Teilchen.
Abschließend soll noch darauf hingewiesen werden, daß das Runge-Kutta-Ver-
fahren zwar einfach und robust ist, daß es aber je nach Problemstellung noch bes-
sere Methoden mit geringerer Rechenzeit geben kann. Beispielsweise kann man
das Ergebnis von mehreren einfachen Schritten für verschiedene h-Werte berech-
nen und für h !0 geeignet extrapolieren; dies ist die Idee der Richardson Extrapo-
lation und der Bulirsch-Stoer-Methode. Eine andere Möglichkeit ist, verschiedene
yi-Werte mit einem Polynom zu extrapolieren und damit eine Vorhersage für einen
yn-Wert zu erhalten, mit dem die Steigung yn0 berechnet wird. Durch Integration der
yi0 -Werte korrigiert man dann den Wert yn. Auch für solche sogenannten Predictor-
Corrector-Methoden gibt es in den Lehrbüchern geeignete Algorithmen.

Algorithmus
Gleichung (4.11) kann man einfach programmieren, selbst wenn y und f wieder
y f
durch Vektoren und ersetzt werden. In Mathematica sind dann und Listeny f
f y
von Zahlen bzw. Funktionen. Falls nur von und nicht von x abhängt, kann
Gleichung (4.11) geschrieben werden als
RKStep[f_, y_, yp_, h_]:=
Module[{k1, k2, k3, k4},
k1 = h N[f/.Thread[y –> yp]];
k2 = h N[f/.Thread[y –> yp+k1/2]];
k3 = h N[f/.Thread[y –> yp+k2/2]];
k4 = h N[f/.Thread[y –> yp+k3]];
yp + (k1 + 2*k2 + 2*k3 + k4)/6 ]
Die Funktion Thread weist jedem Element der Liste y den entsprechenden Wert
der Liste yp zu. Man beachte, daß k1, k2, k3 und k4 wieder Listen sind. Die
y y
i -Werte im Intervall [0; x] erhält man dann aus dem Anfangswert 0 durch
132 4 Differentialgleichungen

RungeKutta[f_List,y_List,y0_List,{x_, dx_}]:=
NestList[RKStep[f,y,#,N[dx]]&,N[y0],Round[N[x/dx]]]

Zum Vergleich programmieren wir auch das Euler-Verfahren:

EulerStep[f_,y_,yp_,h_]:= yp+h N[f/.Thread[y –> yp]]

Euler[f_,y_,y0_,{x_, dx_}]:=
NestList[EulerStep[f,y,#,N[dx]]&,N[y0],Round[N[x/dx]]]

Ergebnisse
Wir wollen die Differentialgleichung für ein Problem lösen, das wir schon im Ab-
schnitt 1.2 ausführlich untersucht haben: das mathematische Pendel. Die Hamilton-
funktion dazu lautet

hamilton = pˆ2/2 – Cos[q]

Dabei ist p die Winkelgeschwindigkeit '_ und q der Ausschlagswinkel ' des Pen-
p
dels. Energie und Zeit werden wie vorher in Einheiten von mgl und l=g gemes-
sen. Die Bewegungsgleichungen erhält man aus den partiellen Ableitungen der Ha-
miltonfunktion. In Mathematica lautet damit deren Lösung

RungeKutta[{D[hamilton,p], –D[hamilton,q]},
{q,p}, {phi0,p0}, {tmax,dt}]

1.5 1.5
1 1
0.5 0.5
p 0 p 0
-0.5 -0.5
-1 -1
-1.5 -1.5

-2 -1 0 1 2 -2 -1 0 1 2
q q

4.1 Schwingung des Pendels im Phasenraum q = '; p = '_ . Die Kurve links zeigt das
Ergebnis des Runge-Kutta-Verfahrens, während die Kurve der rechten Graphik mit der Euler-
Methode berechnet wurde und offenbar ein falsches Resultat liefert.
4.1 Runge-Kutta-Methode 133

Abbildung 4.1 zeigt das Ergebnis. Die Kurve der linken Graphik ist das richtige
Ergebnis für den Anfangswinkel '0 = 2 . Ohne Reibung ist die Energie erhalten und
die Kurve muß sich wieder schließen (siehe auch Abbildung 1.4). Zum Vergleich
enthält die Abbildung rechts auch das Ergebnis des Euler-Verfahrens mit derselben
Schrittweite h = 0:1 . Man sieht, daß diese Methode ein völlig falsches Ergebnis
liefert, da die Energie wächst und sich die Kurve nicht schließt.
Natürlich können wir auch sehr einfach eine Reibungskraft hinzufügen. Wir ad-
dieren zur Gravitationskraft einen Term der Form r p und erhalten die Lösung der
Bewegungsgleichung mit

RungeKutta[{p,–Sin[q]–r p},{q,p},{phi0,p0},{tmax,dt}]

In Abbildung 4.2 sieht man, daß das Pendel seine Energie verliert und in die Ruhe-
lage q = p = 0 relaxiert.

0.5

p 0

-0.5

-1

4.2 Wie Abbildung 4.1 links,

-1 -0.5 0 0.5 1 1.5 aber mit Reibung r = 0:05 .
q

Übung
Ein Teilchen der Masse m soll sich in einem eindimensionalen Doppelmuldenpo-
tential bewegen und außerdem eine Reibungskraft spüren, die proportional zur Ge-
schwindigkeit ist. Die Bewegungsgleichung für den Ort x(t) als Funktion der Zeit
t lautet also
m x = r x_ + a x b x3
mit positiven Konstanten r; a und b. Je nach Startzustand endet das Teilchen entwe-
der in der linken (x < 0) oder in der rechten Potentialmulde.
134 4 Differentialgleichungen

Für die Konstanten r=m = 0:1, a=m = b=m = 1 ( in geeigneten Einheiten) sol-
len Sie in der Ebene der Startzustände (x(0); x_ (0)) diejenigen Gebiete berechnen
1
und zeichnen, deren Punkte in der linken Mulde, also bei x( ) = 1 landen.

Literatur
R. E. Crandall, Mathematica for the Sciences, Addison Wesley, 1991.
S. E. Koonin, D. C. Meredith, Physik auf dem Computer, Band 1+2, R. Oldenbourg
Verlag, 1990.
H. J. Korsch, H.-J. Jodl, Chaos: A Program Collection for the PC, Springer Verlag,
1994.
W.H. Press, S.A. Teukolsky, W.T. Vetterling, B.P. Flannery, Numerical Recipes in
C: The Art of Scientific Computing, Cambridge University Press, 1992.
E. W. Schmid, G. Spitz, W. Lösch, Theoretische Physik mit dem Personal Computer,
Springer Verlag, 1987.
J. Schnakenberg, Algorithmen in der Quantentheorie und Statistischen Physik, Zim-
mermann-Neufang, 1995.
J. Stoer, R. Bulirsch, Numerische Mathematik 2, Springer Verlag, 1990.
Paul L. DeVries, Computerphysik: Grundlagen, Methoden, Übungen, Spektrum
Akademischer Verlag, 1995.

4.2 Chaotisches Pendel

Schon am Ende letzten Jahrhunderts hat der französische Mathematiker Henri Poin-
caré gezeigt, daß ein einfaches mechanisches System eine komplexe Bewegung
ausführen kann. Die Vorstellung, daß man nur die Anfangsbedingungen möglichst
genau angeben muß und daß man dann die Bewegung eines mechanischen Systems
im Prinzip durch seine Newtonschen Bewegungsgleichungen genau vorausberech-
nen kann, wird in der Praxis schon bei einfachen Modellen ad absurdum geführt. Im
allgemeinen reagiert ein System so empfindlich auf die Anfangsbedingungen, daß
eine winzige Ungenauigkeit der Startwerte schon nach kurzer Zeit zu einer großen
Ungenauigkeit der Vorhersage führt. Das gilt nicht nur für die Wettervorhersage,
sondern auch schon für ein einfaches Pendel mit äußerem Antrieb.
Obwohl diese Tatsache schon seit langem bekannt ist, hat es fast 100 Jahre ge-
dauert, bis ihre Bedeutung in der Wissenschaft erkannt und erforscht wurde. Erst
mit dem Computer konnte chaotische Bewegung im Detail untersucht und – was
vielleicht ebenso wichtig ist – graphisch dargestellt werden.
4.2 Chaotisches Pendel 135

In diesem Abschnitt wollen wir ein einfaches Beispiel numerisch berechnen: das
nichtlineare Pendel mit Reibung, das von einer äußeren periodischen Kraft angetrie-
ben wird.

Physik
Wir betrachten zunächst das Pendel aus Abschitt 1.2 mit einer zusätzlichen Rei-
bungskraft. Die Bewegungsgleichung für den Winkel '(t) der Auslenkung lautet in
dimensionsloser Form:

' + r '_ + sin ' = 0 (4.17)

mit einem Reibungsparameter r 0 . Diese Differentialgleichung zweiter Ord-
nung kann man durch die Einführung von ! (t) = '_ (t) in zwei Gleichungen erster
Ordnung umschreiben:
'_ = ! ;
!_ = r ! sin ' : (4.18)
Die Bewegung des Pendels läßt sich daher in einem zweidimensionalen Phasenraum
darstellen. Jeder Wert ('; ! ) bestimmt eindeutig seine Änderung (d'; d! ) im Zeit-
intervall dt. Daher kann sich eine Trajektorie ('(t); ! (t)) nicht selbst kreuzen.
Man kann zeigen, daß es aus diesem Grund keine chaotische Bewegung geben
kann. In zwei Dimensionen gibt es einfach keinen Platz für Trajektorien, die für lan-
ge Zeiten etwas anderes tun, als geschlossene Bahnen zu bilden oder sich solchen
anzunähern. In unserem Beispiel relaxiert für r > 0 das Pendel, eventuell nach eini-
gen Schwingungen und Überschlägen, zur Ruhelage (' = 0; ! = 0). Der Ursprung
des Phasenraumes ist ein Attraktor, der fast alle Anfangspunkte ('(0); ! (0)) an-
zieht. Jede Trajektorie läuft schließlich spiralförmig zur Ruhelage (siehe Abbildung
4.2).
Das ändert sich, wenn wir eine dritte Richtung im Phasenraum erlauben. Dazu
treiben wir das Pendel mit einem periodischen Drehmoment der Stärke a und der
Frequenz !D an,
' + r '_ + sin ' = a cos(!D t) : (4.19)
Mit = ! t erhält man
D

'_ = ! ;
!_ = r ! sin ' + a cos ;
_ = ! : D (4.20)
Die Bewegung des Pendels wird nun im dreidimensionalen Raum ('; !; ) be-
schrieben. Es gibt drei Parameter (r; a; !D ). Ohne Antrieb, ohne Reibung (a =
136 4 Differentialgleichungen

r = 0) und für kleine Winkel ' 1 erhalten wir eine harmonische Schwingung
mit der Frequenz ! = 1. Es gibt deshalb im allgemeinen Fall drei Zeitskalen,
0

die miteinander konkurrieren: die Antriebsperiode 2=! , die Eigenperiode 2=!

D 0

und die Relaxationszeit 1=r . Wie schon beim Hofstadter-Schmetterling und beim
Frenkel-Kontorova-Modell führt der Wettbewerb zwischen verschiedenen Längen
oder Zeiten auch hier zu interessanten physikalischen Phänomenen.
Die dreidimensionale Bewegung ('(t); ! (t); (t)) ist nur schwer zu analysieren,
auch wenn wie in unserem Fall nur linear mit der Zeit t wächst. Um die Vielfalt der
möglichen Bewegungsformen auf die wesentlichen Strukturen zu reduzieren, beob-
achtet man wie bei einer stroboskopischen Beleuchtung die Bewegung nur nach
jeweils festen Zeitintervallen. Das Ergebnis wird als Poincaré-Schnitt bezeichnet.
Als Zeitintervall benutzen wir die Antriebsperiode und betrachten

('(tj ); !(tj )) mit tj = 2!j und j = 0; 1; 2; : : : : (4.21)

Damit erhalten wir eine Folge von Punkten in der Ebene, wobei jeder Punkt durch
seine Vorgänger eindeutig bestimmt wird. Wie bei der Kette auf dem Wellblech
(Abschnitt 3.2) reduzieren wir das Problem auf eine zweidimensionale diskrete Ab-
bildung, allerdings mit dem Unterschied, daß für r > 0 die Abbildung nicht flä-
chenerhaltend ist. Analog zur eindimensionalen logistischen Abbildung (Abschnitt
3.1) wird ein Flächenstück bei der Iteration kleiner und es entstehen Attraktoren.
Wie sehen nun Trajektorien ('(tj ); ! (tj )) im Poincaré-Schnitt aus? Bei einer
periodischen Bewegung mit der Periodenlänge 2=!0 sieht man in der strobosko-
pischen Aufnahme entweder einzelne Punkte oder eine geschlossene Kurve. Für
!0 = !D gibt es nur einen einzigen Punkt in der ('; !)-Ebene. Für !0 = (p=q) !D
mit teilerfremden ganzen Zahlen p und q erhält man q verschiedene Punkte, und p
bestimmt die Reihenfolge, in der die q Punkte durchlaufen werden. Ist dagegen !0
ein irrationales Vielfaches von !D , so füllen unendlich viele Punkte ('(tj ); ! (tj ))
eine geschlossene Kurve. Aus periodischen Bewegungen resultieren im Poincaré-
Schnitt also entweder einzelne Punkte oder geschlossene Kurven. Solche Bahnen
können Attraktoren sein, d. h., startet man mit Punkten ('(0); ! (0)) in einem ge-
wissen Einzugsgebiet, so laufen alle diese Werte zu einem solchen periodischen
Attraktor. Es sind auch mehrere Attraktoren mit dazugehörigen Einzugsgebieten
möglich.
Es gibt aber noch andere Arten von Attraktoren, sogenannte seltsame Attraktoren.
Sie kann man sich als eine Art Blätterteig vorstellen, den man durch fortwährendes
Strecken und Falten erhält. Solche Attraktoren entsprechen chaotischen Bahnen, die
scheinbar unberechenbar durch den Phasenraum laufen. Die seltsamen Attraktoren
sind Fraktale (siehe Abschnitt 3.3), sie sind mehr als eine Linie aber weniger als ein
Flächenstück.
Die fraktale Dimension D kann man wie im Abschnitt 3.3 durch Überdeckung
4.2 Chaotisches Pendel 137

des Attraktors mit N Quadraten der Kantenlänge " bestimmen.

DU = lim log N (") :

"!0 log "
(4.22)

Numerisch effektiver aber ist eine Methode, die von Grassberger und Procaccia
x
vorgeschlagen wurde. Dazu erzeugen wir uns N Punkte i auf dem Attraktor, die
x
möglichst unkorreliert sein sollen. Dann zählen wir die Anzahl der Punkte j , die
x x
einen Abstand zu i haben, der kleiner ist als R. Diese Zahl mitteln wir über i .
Formal können wir diese Korrelation mit der Stufenfunktion (x) ausdrücken:

1 X
N
C (R) = Nlim
!1 N (N 1) i6=j
(R jxi xj j) : (4.23)

C (R) kann als die mittlere Masse eines Ausschnittes des Attraktors aufgefaßt wer-
den, und die Masse-Länge-Beziehung aus Abschnitt 3.3 definiert eine fraktale Di-
mension DC durch:
/
C (R) RDC : (4.24)
Der log-log-Plot dieser Gleichung sollte also eine Gerade mit der Steigung DC
geben. Das gilt aber nur für R-Werte, die größer als der mittlere Abstand der Da-
tenpunkte und kleiner als die Ausdehnung des Attraktors sind.
Eine andere Methode zur Definition der fraktalen Dimension nutzt den Begriff
der Informationsentropie. Dazu überdeckt man den Attraktor wieder mit Quadraten
der Kantenlänge ". Dann zählt man, wieviele Punkte der erzeugten Trajektorie in
jedem Kästchen liegen. Sei also pi die Wahrscheinlichkeit, daß ein Punkt ('; ! )
des Attraktors im Quadrat mit der Nummer i liegt. Die Entropie ist dann definiert
als X
I (") = pi ln pi ; (4.25)
i
und die Informationsdimension DI erhält man als
DI = "lim I (") :
!0 ln "
(4.26)

Man kann nun zeigen, daß folgende Beziehung zwischen den drei Dimensionen
besteht:

DU DI DC : (4.27)
In der Praxis stimmen die drei Dimensionen oft innerhalb des Beobachtungsfehlers
überein.
138 4 Differentialgleichungen

Algorithmus
Zur numerischen Lösung der Differentialgleichung (4.20) wählen wir das Runge-
Kutta-Verfahren vierter Ordnung aus dem vorherigen Abschnitt. Um die Bewegung
schon während der numerischen Rechnung auf dem Bildschirm sichtbar zu ma-
chen, verwenden wir die Sprache C mit der entsprechenden Graphikumgebung. In
unserem Programm kann während des Laufes durch Tastendruck die Stärke a des
Antriebes geändert und zwischen der kontinuierlichen Bewegung und dem Poin-
caré-Schnitt hin- und hergeschaltet werden.
Es ist nicht schwer, den Runge-Kutta-Schritt Gleichung (4.11) selbst zu program-
mieren, aber wir wollen hier demonstrieren, wie die Routine odeint aus den Nu-
merical Recipes in das eigene Programm eingebunden wird.
odeint integriert das Gleichungssystem (4.20) mit adaptiver Schrittweitenkon-
trolle. Die rechnerische Erzeugung der Trajektorie gibt deshalb nicht deren tatsächli-
chen zeitlichen Verlauf wieder. Wer diesen Zusammenhang erhalten möchte, sollte
direkt die Routine rk4 aus den Numerical Recipes benutzen.
Zunächst müssen alle Variablen der verwendeten Routinen deklariert und die
Routinen zum eigenen Programm hinzugefügt werden. Dabei muß beachtet wer-
den, daß odeint die Programme rk4 und rkqc benutzt und daß alle Routinen
gewisse Fehlerroutinen aufrufen, die in nrutil enthalten sind. Man kann alle
benötigten Programme direkt in den eigenen Programmtext hineinkopieren oder mit
#include hinzufügen, z. B. durch

#define float double

#include "\tc\recipes\nr.h"
#include "\tc\recipes\nrutil.h"
#include "\tc\recipes\nrutil.c"
#include "\tc\recipes\odeint.c"
#include "\tc\recipes\rkqc.c"
#include "\tc\recipes\rk4.c"

Der Pfadname hängt natürlich davon ab, wo der Benutzer die Programme gespei-
chert hat. Den ersten Befehl fügen wir hinzu, damit alle reellen Variablen im Pro-
gramm und in den Recipes vom selben Typ double sind. odeint wird in folgen-
der Form aufgerufen:

odeint(y,n,t1,t2,eps,dt,0.,&nok,&nbad,derivs,rkqc)

Dabei ist y ein Vektor mit den Variablen ('(t1 ); ! (t1 )). Es wird über das Intervall
[t1 ; t2 ] integriert und danach wird y durch die Endwerte ('(t2 ); !(t2 )) ersetzt. n
ist die Anzahl der Variablen. Da wir in Gleichung (4.20) wieder durch !D t erset-
zen, gibt es nur n = 2 Variablen. Mit eps geben wir die gewünschte Genauigkeit
und mit dt eine Abschätzung der benötigten Schrittweite an. Die Variablen nok
4.2 Chaotisches Pendel 139

und nbad enthalten bei der Ausgabe Informationen über die Anzahl der benötigten
Schritte. derivs ist der Name einer Funktion, mit der die rechte Seite von Glei-
chung (4.20) ausgewertet wird. Mit derivs(t,y,f) werden aus t und y die
Komponenten von f berechnet. Für unser Beispiel ist
y[1] = ',
y[2] = !,
und dementsprechend
f[1] = y[2],
f[2] =
–r y[2]–sin(y[1])+a cos(!D t).
Schließlich übergibt man der Routine odeint noch die Funktion rkqc, die wie-
derum den Runge-Kutta-Schritt rk4 aufruft. Man kann aber auch andere, eventuell
eigene Integrationsprozeduren übergeben.
Zusammenfassend besteht also der wesentliche Teil des Programmes pendel.c
aus den Befehlen:
main()
{
y[1]=pi/2.;
y[2]=0.;

while(done==0)
{
odeint(y,2,t,t+3.*pi,eps,dt,0.,&nok,&nbad,derivs,rkqc);
xalt=fmod(y[1]/2./pi +100.5,1.)*xbild;
yalt=y[2]/ysc*ybild/2+ybild/2;
rectangle(xalt,yalt,xalt+1,yalt+1);
t=t+3.*pi;
}
}

void derivs(double t,double y,double f)

{
f[1]=y[2];
f[2]=–r*y[2]–sin(y[1])+a*cos(2./3.*t);
}

Auch hier sollte ein guter Programmierer alle Konstanten vorher berechnen lassen.
Die Vektoren y und f wurden einen Platz größer als erforderlich deklariert, da die
Recipes die Indizes mit 1 anstatt mit 0 (wie in C) beginnen lassen.
Das obige Programm benutzt !D = 2=3 und zeichnet die Punkte ('(ti ); ! (ti ))
(als kleine Rechtecke) jeweils nach einer Antriebsperiode [t; t + 3 ]. Will man die
140 4 Differentialgleichungen

Bahn kontinuierlich laufen sehen, so muß man t + 3 durch t + dt ersetzen, wobei

die Bahn im Zeitraum dt möglichst nur wenige Pixel überspringen sollte. Im letzten
Fall wird natürlich kein Punkt sondern eine Linie vom Anfangs- zum Endpunkt
gezeichnet.

Ergebnisse
Als Beispiel betrachten wir auf dem Bildschirm das getriebene Pendel mit dem Rei-
bungskoeffizienten r = 0:25 und der Antriebsfrequenz !D = 2=3. Als Startwerte
wählen wir die 90-Auslenkung, '(0) = =2, und die Anfangswinkelgeschwindig-
keit ! (0) = 0. Mit der Taste h bzw. t können wir die Antriebskraft a um jeweils
0.01 verstärken bzw. verringern.
Ohne Antrieb (a = 0) führt das Pendel eine gedämpfte Schwingung aus und hält
schließlich in der Ruhelage ('; ! ) = (0; 0) an. Für kleine a-Werte erhalten wir
nach einer Einschwingphase eine periodische Bewegung mit der Periode 2=!D ,
also einen Punkt im Poincaré-Schnitt. Bei a = 0:68 ist der Antrieb so stark, daß sich
das Pendel überschlagen kann. Die Bahn verläßt den Bildschirm und tritt wegen der
Periodizität des Winkels ' (= horizontale Achse) auf der gegenüberliegenden Seite
wieder ein.

4.3 Bewegung des getriebenen Pendels im Phasenraum ('; ! ), Antriebsstärke a = 0:7 .

Für a = 0:7 beobachten wir einen chaotischen Attraktor (Abbildung 4.3). Im Poin-
caré-Schnitt deutet sich ein fraktaler Blätterteig“ an (Abbildung 4.4). Auch für
”
4.2 Chaotisches Pendel 141

4.4 Wie Abbildung 4.3, aber als Poincaré-Schnitt jeweils zu den Zeiten 2 j=!D .

4.5 Phasenraum-Plot für a = 0:85. Die Bewegung ist ein Zyklus der Periode 7 !2 . Der
D
zugehörige Poincaré-Schnitt zeigt genau 7 Punkte.

a = 0:85 sieht die Bahn immer noch regellos aus (Abbildung 4.5), aber der Poin-
caré-Schnitt zeigt deutlich einen Zyklus der Länge 7 2=! . Auch Periodenver-
D

doppelung kann man beobachten. Der einfache Zyklus mit Überschlag bei a = 0:97
142 4 Differentialgleichungen

4.6 Poincaré-Schnitt für a = 1:3. Die Bewegung wechselt zwischen drei chaotischen
Bändern.

hat sich für a = 0:98 und a = 0:99 verdoppelt und bei a = 1:0 vervierfacht. Bei
a = 1:01 sieht die Bahn schon wieder chaotisch aus. Bei a = 1:2 sieht man drei
Punkte und bei a = 1:3 eine chaotische Bahn mit drei Bändern, die in Abbildung
4.6 als Poincaré-Schnitt zu sehen ist.
Mit wachsender Antriebsstärke a beobachten wir also einen fortwährenden Wech-
sel von periodischer und chaotischer Bewegung.

Übung
Zwischen zwei Platten ist eine Flüssigkeit mit gegebener Viskosität , Wärmeleit-
fähigkeit und Dichte eingesperrt. Die untere Platte hat eine Temperatur T +T ,
die obere T . Ist der Temperaturunterschied klein, so findet ausschließlich Wärme-
leitung statt, die konvektive Bewegung wird durch die viskose Reibung gebremst.
Bei Anwachsen der Temperatur beginnt die heiße Flüssigkeit in einigen Bereichen
aufzusteigen und in anderen wieder abzusinken. Es entstehen sogenannte Konvek-
tionsrollen. Bei weiterer Temperaturerhöhung brechen diese statischen Rollen auf
und es entsteht eine chaotische Bewegung.
Unter der Annahme, daß die Konvektionsrollen in y -Richtung unendlich aus-
gedehnt sind, hat der Meteorologe Lorenz durch Fourierentwicklung in x- und z -
Richtung und Vernachlässigung höherer Glieder der Fourierreihe ein Modell ent-
4.2 Chaotisches Pendel 143

wickelt, das ein solches Bénard-Experiment am Übergang vom geordneten zum

chaotischen Verhalten gut beschreibt.
Das System wird in dieser Näherung durch folgende drei Gleichungen beschrie-
ben:
X_ = X + Y;
Y_ = X Z + r X Y;
Z_ = X Y b Z:
X stellt dabei die Geschwindigkeit der Zirkularbewegung, Y die Temperaturdiffe-
renz zwischen aufsteigender und fallender Flüssigkeit und Z die Abweichung des
resultierenden Temperaturprofils von seinem Gleichgewichtsverlauf dar. b und
werden allein durch die Materialparameter (; ; ) und durch die geometrischen
Abmessungen bestimmt und sind somit als Konstanten aufzufassen. r ist proportio-
nal zur angelegten Temperaturdifferenz und dient somit als äußerer Steuerparame-
ter, der das Verhalten des Systems bestimmt.
Dieses System ist für diverse Anwendungen interessant:
in der Meteorologie: Bewegung der Luft,
in der Astronomie: Sternaufbau bei konvektiven Sternen,
in der Energietechnik: Wärmeleitung von Dämmstoffen.
Integrieren Sie die Differentialgleichungen des Lorenzmodells mit dem Runge-Kut-
ta-Verfahren. Wählen Sie = 10 und b = 8=3. Der Parameter r soll im Programm
frei veränderbar sein. Stellen Sie das Ergebnis für X und Y graphisch dar, und zwar
als Projektion der kontinuierlichen Bewegung auf die X -Y -Ebene,
als Poincaré-Schnitt zu Z = const. = 20:0.
Um den Schnittpunkt mit der Ebene Z = const. = 20 genauer zu bestimmen, sollte
man linear zwischen dem letzten Wert über 20 und dem ersten unter 20 interpolie-
ren.
Ab wann setzt chaotisches Verhalten ein? Welche Dimension hat der seltsame
Attraktor im oben genannten Poincaré-Schnitt für r = 28?

Literatur
G. L. Baker, J. P. Gallup, Chaotic Dynamics: An Introduction, Cambridge University
Press, 1991.
H. J. Korsch, H.-J. Jodl, Chaos: A Program Collection for the PC, Springer Verlag,
1994.
E. Ott, Chaos in Dynamical Systems, Cambridge University Press, 1993.
W.H. Press, S.A. Teukolsky, W.T. Vetterling, B.P. Flannery, Numerical Recipes in
C: The Art of Scientific Computing, Cambridge University Press, 1992.
144 4 Differentialgleichungen

4.3 Stationäre Zustände

Die Newtonschen Bewegungsgleichungen, so erfolgreich sie unsere makroskopi-
sche Welt beschreiben, erweisen sich als nicht geeignet, wenn es um die Bewe-
gung von Elektronen in Atomen, Molekülen und Festkörpern geht. Im mikrosko-
pisch Kleinen sind nur Wahrscheinlichkeitsaussagen für den Ort und den Impuls
eines Teilchens möglich, deren zeitliche Änderungen durch die quantenmechani-
sche Schrödinger-Gleichung beschrieben wird. Unter bestimmten Bedingungen re-
duziert sich diese dynamische Gleichung auf die sogenannte stationäre Schrödinger-
Gleichung, eine Eigenwertgleichung für den Energieoperator, die in der Ortsdarstel-
lung die Form einer linearen Differentialgleichung hat. Im Prinzip kann sie mit den
Methoden der vorigen Abschnitte numerisch gelöst werden. Es gibt jedoch eine
effektivere Methode zur numerischen Lösung der Schrödinger-Gleichung, die wir
hier an einem einfachen Beispiel, dem anharmonischen Oszillator, erläutern wol-
len. Zusätzlich haben wir bei der Schrödinger-Gleichung noch das Problem, daß die
Energie nicht alle reellen, sondern nur bestimmte diskrete Werte annehmen kann,
die erst aus der Gleichung selbst bestimmt werden müssen.

Physik
Ein Quantenteilchen wird durch eine im allgemeinen komplexwertige Wellenfunk-
r
tion ( ; t) beschrieben, die einer partiellen Differentialgleichung zweiter Ordnung
j r j
genügt. ( ; t) 2 ist die Wahrscheinlichkeitsdichte, zur Zeit t das Teilchen am Ort
r zu messen.
Wenn die Mittelwerte aller Meßgrößen in diesem Zustand zeitunabhängig sind,
so gehorcht die Wellenfunktion der stationären Schrödinger-Gleichung, die in
einer Raumdimension folgendermaßen lautet:

~2 00
2m (x) + V (x) (x) = E (x) : (4.28)

Da das Potential V (x) reell ist, kann auch als reellwertige Funktion gewählt
werden. Gleichung (4.28) beschreibt den stationären Zustand eines Teilchens in ei-
ner Dimension mit der Masse m im Potential V (x), sie ist linear und enthält eine
zweite Ableitung. Aber es gibt eine Besonderheit gegenüber der Newtonschen Be-
wegungsgleichung: Die Energie E des Teilchens kann nicht alle Werte annehmen,
R j
sondern die Gleichung (4.28) bestimmt die möglichen Werte erst dadurch, daß die
j
Wellenfunktion normierbar sein muß, daß also dx (x) 2 einen endlichen Wert
annimmt. Es stellt sich heraus, daß schon bei einer winzigen Abweichung des Wer-
tes E von einem erlaubten Energiewert die Wellenfunktion für große x-Werte expo-
nentiell anwächst. Diese Tatsache muß bei der numerischen Lösungssuche berück-
4.3 Stationäre Zustände 145

sichtigt werden. Wie wir sehen werden, kann man sich andererseits gerade dieses
Verhalten zunutze machen, um die gesuchten Energie-Eigenwerte mit großer Ge-
nauigkeit numerisch zu bestimmen.
Bei symmetrischen Potentialen V (x) = V ( x) hat auch der stationäre Zustand
die Symmetrie (x) =
( x), wobei sich die Vorzeichen mit wachsenden Ener-
giewerten abwechseln. Der Grundzustand ist symmetrisch, 0 (x) = 0 ( x), und
j j
hat keine Nullstelle, 0 (x) > 0. Bei jedem höheren Energie-Eigenwert kommt
eine Nullstelle (= Knoten) der Wellenfunktion hinzu. Die Anzahl der Knoten von
(x) gibt daher die Nummer des Energieniveaus an.
In unserem Beispiel betrachten wir den anharmonischen Oszillator aus Abschnitt
2.1, dessen Schrödinger-Gleichung die folgende dimensionslose Form hat:
00 (x) + ( x2 x4 + 2E ) (x) = 0 : (4.29)
p
Die Energie E und der Ort x werden dabei in Einheiten von ~! bzw. ~=(m! )
gemessen. Im harmonischen Fall ( = 0) kennen wir die Eigenwerte und die Eigen-
zustände aus analytischen Rechnungen. E 0 kann relativ zur Ruheenergie E00 = 1=2
nur ganzzahlige nicht-negative Werte annehmen,

En0 = n + 21 mit n = 0; 1; 2; : : : (4.30)

Diese Energieniveaus werden durch einen anharmonischen Beitrag x4 mit > 0

nach oben verschoben. Für negative -Werte gibt es keine stationären Zustände,
jj
da dann für große Werte von x der negative x4 -Term dominiert und das Potential
V (x) immer stärker negativ wird. Aufgrund des Tunneleffektes wird jede Wellen-
funktion ins Unendliche zerfließen. Das bedeutet, daß En () nicht analytisch bei
= 0 sein kann.

Algorithmus
Mehrere Probleme müssen gelöst werden: Wie findet man die Eigenwerte E ? Wel-
chen Algorithmus benutzt man für die Integration der Schrödinger-Gleichung? Mit
welchen Anfangswerten (x0 ) und (x1 ) startet man die numerische Integration?
Das erste Problem lösen wir mit dem sogenannten Schießverfahren: Wir wählen
einen Energiewert E , von dem wir sicher wissen, daß er unterhalb der Grundzu-
standsenergie E0 liegt, z. B. E = 0:5, und integrieren die Schrödinger-Gleichung
j j
vom Startwert x0 bis zu einem x-Wert, bei dem (x) unrealistisch groß geworden
ist. Dann erhöhen wir die Energie schrittweise, bis (x) das Vorzeichen wechselt.
Jetzt haben wir aufgrund des Knotensatzes ein Energieintervall gefunden, in dem
E0 liegen muß. Nun integrieren wir mit einem E -Wert in der Mitte des Intervalls;
146 4 Differentialgleichungen

wenn (x) das Vorzeichen wechselt, liegt E0 in der unteren, sonst in der oberen
Hälfte des Intervalls. Auf diese Weise können wir E0 sehr schnell einschachteln.
Wir schießen“ sozusagen die Wellenfunktion (x) für verschiedene E -Werte
solange zu großen x-Werten hin, bis die Randbedingung (x)
”
j
0 für große j!
x-Werte einigermaßen erfüllt ist. Allerdings bleibt (x) nur in einem gewissen In-
tervall dicht beim Wert Null, dann explodiert es wieder ins Unendliche.
Obwohl das zweite Problem, die Integration der Schrödinger-Gleichung, im Prin-
zip mit dem Runge-Kutta-Verfahren aus Abschnitt 4.1 gelöst werden kann, ist es bei
dieser Art von Gleichung möglich, eine größere Genauigkeit mit einer einfacheren
Methode, dem Numerov-Verfahren, zu erzielen. Gleichung (4.29) hat die Form:
00 (x) + k(x) (x) = 0 (4.31)

mit k (x) = 2 (E V (x)). Wir diskretisieren mit der Schrittweite h die x-Achse in
der Form xn = (n 12 ) h für gerade, bzw. xn = n h für ungerade Wellenfunktionen
und kennzeichnen die Wellenfunktion und auch deren Ableitungen an den Stellen
xn mit einem unteren Index n, also n = (xn ) ; n0 = 0 (xn ) und analog für die
höheren Ableitungen. Aus der Taylor-Entwicklung

0 h 00 h h4
2 3
nh n+ 2
(3) + (4) : : :
n1 = n 6 n 24 n (4.32)

folgt:
2 00 + h
4
h (4) + O (h6 ) :
n+1 + n 1 = 2 n + n 12 n (4.33)
00
n können wir mit Gleichung (4.31) ersetzen,
00 = kn n:
n (4.34)

Nun kommt der entscheidende Trick, bei dem die vierte Ableitung durch die diskre-
tisierte zweite ersetzt wird:
d2 00 d2
n = dx2 (x) = dx2 (k (x) (x))
(4)
xn xn
= kn+1 n+1 2 kn
h2
n + kn 1 n 1 + O(h2 ) : (4.35)

Setzen wir dies in Gleichung (4.33) ein, so erhalten wir:

h2 5 h2 k

1+ k 12 n+1 n+1 2 1 12 n n
h2
+ 1 + 12 kn 1 n 1 = 0 + O (h
6) : (4.36)
4.3 Stationäre Zustände 147

Aus zwei benachbarten Startwerten können damit sämtliche n -Werte berechnet

werden.
Wie werden die beiden Startwerte gewählt? Wegen der Symmetrie des Potenti-
als sind, wie schon erwähnt, die Eigenfunktionen mit aufsteigenden Energiewerten
abwechselnd gerade und ungerade. Dementsprechend wählen wir 0 = 1 = 0 6
6
für die geraden und 0 = 0 ; 1 = 0 für die ungeraden Wellenfunktionen. Der
Wert von 1 kann beliebig gewählt werden, denn er ändert wegen der Linearität der
Schrödinger-Gleichung nicht die Energie Ek sondern nur den Wert der Normierung
Rj j
(x) 2 dx.
Damit ist der Algorithmus definiert, und wir können ihn leicht programmieren.
Als Programmiersprache wählen wir C, um die Wellenfunktion auf dem Bildschirm
direkt darstellen und die Energiewerte Ek interaktiv durch Tastendruck einschach-
teln zu können.
Der Integrationsschritt Gleichung (4.36) wird zur Funktion step(&x,dx,&y,
&ym1), die als Ergebnis yp1 ( = n+1 ) liefert. Dabei ist x der aktuelle Wert von
xn , dx die Schrittweite, und y, ym1 entsprechen n und n 1. Da wir in step
die Werte von x, y, ym1 verändern wollen, müssen wir die Adressen dieser Varia-
blen übergeben, die jeweils mit einem & markiert werden. Man beachte, daß eine
Funktion in C nur Werte übergibt und keine Werte an die Argumente zurückgibt.
Damit lautet die Berechnung von n+1 :

double step(double xa, double dx, double ya,

double *ym1a)
{
long i,n;
double k(double);
double yp1, x, y, ym1, xp1, xm1;
x=*xa; y=*ya; ym1=*ym1a;
n=ceil(10./dx/500.);
for(i=1;i<=n;i++)
{
xp1=x+dx; xm1=x–dx;
yp1=(2.*(1.–5./12.*dx*dx*k(x))*y
–(1.+dx*dx/12.*k(xm1))*ym1)/
(1.+dx*dx/12.*k(xp1));
xm1=x; x=xp1;
ym1=y; y=yp1;
}
*xa=x;*ya=y;*ym1a=ym1;
return yp1;
}
148 4 Differentialgleichungen

Die in dieser Schleife immer wiederkehrenden Rechnungen kann man dadurch be-
schleunigen, daß man Konstanten wie 5./12.*dx*dx vorher in eine Variable
schreibt. Die Iterationsschleife for (: : :) läuft soweit, daß gerade ein Pixel auf der
x-Achse des Bildschirms überbrückt wird. (xb, yb) sind die Koordinaten auf dem
Bildschirm. xb wird mit einer for-Schleife jeweils um den Wert 1 erhöht, während
ybneu aus yp1 berechnet wird. Als Startwert für 1 wählen wir 1:0. Die Haupt-
schleife für die geraden Wellenfunktionen lautet damit:

x=dx/2.; y=ym1=1.; ybalt=1;

for(xb=1; xb<XMAX; xb++)
{
yp1=step(&x,dx,&y,&ym1);
ybneu=(1.–yp1)*YMAX;
if(abs(ybneu)>10000) break;
line(xb–1,ybalt,xb,ybneu);
ybalt=ybneu;
}

Dabei wird als Explosionskriterium für n benutzt, daß die y -Koordinate den Wert
10000 überschreitet. Auf dem PC wird eine Linie von (xb–1,ybalt) nach (xb,
ybneu) gezeichnet. Nach dieser Schleife wird auf eine Tastatureingabe mit ch=
getch() gewartet, und je nach Eingabe werden der Wert von e (= E ), die Ener-
gieschrittweite de oder die Schrittweite der Integration dx (= h) geändert.

Ergebnis
Das Programm schroedinger berechnet und zeichnet die Wellenfunktion (x)
für die Stärke = 0:1 des anharmonischen Potentials. Bild 4.7 zeigt das Ergeb-
nis für E = 6:22030088. Wegen der Symmetrie (x) = ( x) (nur der Bereich

x 0 ist gezeichnet) hat die Wellenfunktion vier Nullstellen, wir suchen also das
vierte Energieniveau E4 über dem Grundzustand. Für = 0 gilt E40 = 4:5. Der
anharmonische Term mit = 0:1 verschiebt daher dieses Niveau erheblich nach
oben. Die Wellenfunktion (x) aus Bild 4.7 liegt schon sehr dicht an dem gebunde-
nen Zustand 4 (x). Das sieht man daran, daß sich (x) sehr lange an die x-Achse
1
anschmiegt, bevor es exponentiell stark nach + schießt. Erhöht man E um den
Wert 0:00000005, so divergiert das entsprechende (x) nach 1
. Die Energie E4
liegt also im Intervall
[ 6:22030088; 6:22030093 ]:
4.3 Stationäre Zustände 149

4.7 Wellenfunktion 4 (x) mit vier Knoten für den fünften Energie-Eigenwert.

Im Abschnitt 2.1 haben wir die Energieniveaus mit einer anderen Methode berech-
net. Die unendliche Matrix des Hamiltonoperators wurde dort durch eine N N -
Untermatrix genähert und diagonalisiert. Für N = 50 fanden wir den Wert

E4 = 6:220300900006516 ;
der mit dem obigen Resultat übereinstimmt. Der Vorteil der direkten Integration
liegt darin, daß wir eine obere und untere Schranke erhalten. Deren Genauigkeit
können wir prüfen, indem wir die Schrittweite dx der Integration halbieren.

Übung
Im Abschnitt 2.1 sollten die vier niedrigsten Energieniveaus des Doppelmulden-
potentials mit der Matrix-Methode berechnet werden. Hier soll dasselbe Problem
durch Integration der Schrödinger-Gleichung gelöst werden. Das Potential V sei
also in dimensionsloser Form

V (x) = 2x2 + x4=10 :

Berechnen sie mit dem Schießverfahren die niedrigsten Energien und die dazu-
gehörigen Wellenfunktionen, und vergleichen Sie Ihre Ergebnisse mit denen aus
dem Abschnitt 2.1.
150 4 Differentialgleichungen

Literatur
S. Brandt, H. D. Dahmen, Quantum Mechanics on the Personal Computer, Springer
Verlag, 1992.
S. E. Koonin, D. C. Meredith, Physik auf dem Computer, Band 1+2, R. Oldenbourg
Verlag, 1990.
E. W. Schmid, G. Spitz, W. Lösch, Theoretische Physik mit dem Personal Computer,
Springer Verlag, 1987.
J. Schnakenberg, Algorithmen in der Quantentheorie und Statistischen Physik, Zim-
mermann-Neufang, 1995.
J. Stoer, R. Bulirsch, Numerische Mathematik 2, Springer Verlag, 1990.

4.4 Solitonen
Bisher haben wir nur Differentialgleichungen von Funktionen betrachtet, die von ei-
ner Variablen (Zeit oder Ort) abhängen. Jetzt wollen wir eine Welle betrachten, die
sich mit der Zeit fortbewegt und eventuell ihre Form ändert. Die zeitliche Änderung
ist dabei mit der räumlichen gekoppelt, man erhält eine partielle Differentialglei-
chung.
Wir wollen uns in diesem Abschnitt mit der Korteweg-de-Vries-Gleichung (KdV-
Gleichung) beschäftigen und ausnahmsweise eine analytisch bekannte Lösung die-
ser Gleichung auch auf numerischem Wege gewinnen. Die KdV-Gleichung ist ei-
ne nichtlineare Differentialgleichung mit speziellen Lösungen, den sogenannten
Solitonen, die einige überraschende Eigenschaften zeigen. So können z. B. zwei
Solitonen aufeinander zulaufen, sich gegenseitig durchdringen und danach ohne
Formänderung mit der ursprünglichen Geschwindigkeit wieder getrennt weiterlau-
fen.

Physik
In der Theorie von Wasserwellen in seichten Kanälen wird die Auslenkung u(x; t)
über dem mittleren Wasserspiegel zur Zeit t am Ort x durch eine nichtlineare par-
tielle Differentialgleichung beschrieben. In dimensionsloser und geeignet skalierter
Form lautet die KdV-Gleichung

@u = 6 u @u @ 3 u :
@t @x @x3 (4.37)

Im Term u @u@x ergibt eine doppelte Auslenkung einen vierfachen Beitrag, die Glei-
chung ist also nichtlinear.
4.4 Solitonen 151

Unter den vielen Lösungen der KdV-Gleichung gibt es eine ganz charakteristi-
sche, nämlich
u(x; t) = 2 sech2 (x 4t) (4.38)
mit sech x = 1= cosh x. Diese Funktion u(x; t) beschreibt ein Wellental, das sich
mit der Geschwindigkeit v = 4 nach rechts bewegt und dabei seine Form nicht
ändert. Eine solche Lösung wird als Soliton bezeichnet.
Man kennt aber auch komplexere Lösungen. Die mathematische Theorie dazu ist
nicht einfach, so daß wir hier nur das Ergebnis angeben. Aus dem Anfangszustand

u(x; 0) = N (N + 1) sech2 (x) (4.39)

entstehen N Solitonen, die sich mit unterschiedlichen Geschwindigkeiten fortbewe-

gen. Für N = 2 findet man z. B.

4 cosh(2x 8t) + cosh(4x 64t) :

u(x; t) = 12 3[3+cosh( x 28t) + cosh(3x 36t)]2 (4.40)

-2
u(x,0.3)

-4
4.8 Zwei Solitonen entfernen
-6 sich voneinander. Die nume-
rische Lösung (durchgezogen)
-8 stimmt gut mit der exakten (ge-
-10 -5 0 5 10 punktet) überein (t = 0:3,
x dx = 0:18, dt = 0:002).
Bild 4.8 zeigt, daß diese Lösung zwei Solitonen enthält. Eine Welle mit großer Am-
plitude hat eine breitere Welle mit kleiner Amplitude überholt. Zur Zeit t = 0 über-
lagern sich beide zu dem Wellenpaket (4.39), während nach dem Überholvorgang
beide Solitonen wieder die gleiche Form wie vorher haben.
Es soll noch ein interessanter Zusammenhang mit der Quantenmechanik erwähnt
werden: Die Schrödinger-Gleichung mit dem Potential V (x)= N (N + 1) sech2 (x)
hat N gebundene Zustände, aus denen man mit den Methoden der inversen Streu-
theorie die Lösung der KdV-Gleichung konstruieren kann. Da dies nicht einfach zu
erklären ist, verweisen wir auf die Literatur zu Solitonen.
152 4 Differentialgleichungen

Algorithmus und Ergebnis

Um die KdV-Gleichung (4.37) numerisch zu lösen, müssen wir zunächst den Raum
x und die Zeit t diskretisieren,
ujn = u(j dx; n dt) : (4.41)
j und n sind ganze Zahlen, dx und dt die Schrittweiten in x- und t-Richtung. Wir
wollen zunächst demonstrieren, was passiert, wenn wir die Gleichung (4.37) zu naiv
in Differenzenform schreiben. Zum Beispiel können wir konsequent für jede Ab-
leitung f 0 (xk ) die sogenannte Vorwärts-2-Punkt-Formel verwenden, d. h. f 0 (xk )
durch (f (xk + h) f (xk ))=h approximieren. Aus den partiellen Ableitungen wird
dann:
@u ! 1 uj u

j ; @u ! 1 uj+1 uj ;
@t dt n +1 n @x dx n n (4.42)
Indem wir die Regel dreimal iterieren, erhalten wir
@3u ! 1 uj+3 3uj+2 + 3uj+1
ujn :
@x 3 (dx)3 n n n (4.43)

Mit diesen Ersetzungen lösen wir Gleichung (4.37) nach ujn+1 auf und erhalten:

ujn+1 = ujn + dt 6ujn un dx un ujn+3 3ujn+2 + 3ujn+1 ujn :
j +1 j
(dx)3 (4.44)

f g
Diese Gleichung ist leicht zu programmieren. In Mathematica stellen wir ujn max
j =0
als Liste mit max +1 Elementen dar. Zur Initialisierung verwenden wir Gleichung
(4.39) mit N = 2,
ustart:=Table[–6 Sech[(j–max/2)dx]ˆ2//N,{j,0,max}]
und nehmen periodische Randbedingungen an. Wir verschaffen uns mit uplus[k]
=RotateLeft[u,k] für k = 1; 2 und 3 die verschobenen Listen ujn+k und f g
f g !f
können dann den Integrationsschritt ujn ujn+1 folgendermaßen formulieren:
g
step[u_]:=(Do[uplus[k]=RotateLeft[u,k],{k,3}];
u+dt(6 u(uplus[1]–u)/dx –
(uplus[3]–3 uplus[2]+3 uplus[1]–u)/dxˆ3))
Mit plot2[i_:3] zeichnen wir für dx = 0:05 und dt = 0:02 das Ergebnis nach
i Integrationsschritten.
plot2[i_:3]:= (dx=0.05; dt=0.02; upast=ustart; zeit=0;
Do[upres=step[upast];
upast=upres;Print["Zeit ",zeit=zeit+dt],{i}] ;
xulist = Table[{(j–max/2)dx,upres[[j]]},{j,0,max}];
ListPlot[xulist, PlotJoined–>True, PlotRange–>All])
4.4 Solitonen 153

Abbildung 4.9 zeigt das Resultat. Schon nach drei Zeitschritten treten in u(x; t)
numerisch bedingte Oszillationen auf, die nach zwei weiteren Schritten explodie-
”
ren“ ; dies ist natürlich unphysikalisch und auf den schlechten Algorithmus zurück-
zuführen.

0
u(x,0.06)

-5

4.9 Integration mit step[u]

und Schrittweiten dx = 0:05,
-10

dt = 0:02. Schon nach drei

-15 Integrationsschritten erhält man
-10 -5 0 5 10 ein unphysikalisches Ergebnis.
x Man vergleiche mit Bild 4.8.

Was läuft falsch? Wir haben mehrere Fehler gemacht, die wir durch folgende Mo-
difikationen vermeiden können:

1. Durch besseres Diskretisieren der Ableitungen kann man den Fehler der Appro-
@ und @ n reduzieren,
ximation von @t @xn
2. Mittelwertbildung stabilisiert den Algorithmus,

3. dx muß immer relativ groß zu dt gewählt werden.

Punkt 1 kann man sich auf folgende Weise klarmachen: Wir betrachten die Taylor-
reihe von u(x; 0) um x = 0 mit u00 = @x
@ u(x; 0) x=0 usw. j
u1 = u0 dx u00 + (dx2 ) u000 (dx6 ) u0000 + :
2 3

Dann gilt:

u00 = u1 dx u0 dx 00
2 u0 + ;
u00 = u1 2 dxu 1 (dx6 ) u0000 + :
2
(4.45)

Man sieht, daß man im zweiten Fall u00 so berechnen kann, daß dx 00
2 u0 gerade kom-
pensiert wird. Dadurch wird der Fehler um eine Größenordnung reduziert. Auch
154 4 Differentialgleichungen

bei höheren Ableitungen kann man so durch geeignete Wahl der Koeffizienten den
Fehler reduzieren. Man erhält

u000 = u1 2dx
u0 + u 1 + O(dx2) ;
2
u0000 = u2 2u1 2+dx2u3 1 u 2 + O(dx2 ) : (4.46)

Bei dem in (4.44) verwandten Algorithmus wurde also hinsichtlich der Güte der
Approximation bei sämtlichen Ableitungen eine Größenordnung in dx und dt ver-
schenkt.
Punkt 2 und 3 wollen wir an einer einfachen linearen Differentialgleichung er-
läutern, und zwar wählen wir
@u = v @u
@t @x
mit einer konstanten Geschwindigkeit v . Wir diskretisieren diese Gleichung in der
Form
ujn+1 ujn = v ujn+1 ujn 1 ;
dt 2 dx (4.47)
@ schon die verbesserte Version (4.45) eingesetzt haben. Aufgelöst
wobei wir für @x
u
nach den Komponenten (u1n+1 ; u2n+1 ; : : :) , die wir zu n+1 zusammenfassen, läßt
sich (4.47) als Matrixgleichung

un+1 = M un
T T
(4.48)

mit der tridiagonalen Matrix M formulieren. Die Lösung von (4.48) ist offensicht-
u u
lich Tn = Mn T0 , an der wir erkennen, daß für die Stabilität des Algorithmus der
Betrag der Eigenwerte von M entscheidend ist. Die Eigenmoden wvon Matrizen
dieses Typs sind immer von der Form w = exp(i k j dx) mit einem Wellenvektor
j
k, dessen mögliche Werte mit den Randbedingungen zusammenhängen. Wählen wir
w w
eine Eigenmode = 0 als Anfangsauslenkung und bezeichnen den zugehörigen
Eigenwert mit a, so ergibt die n-fache Anwendung der Matrix M :

wnj = an ei k j dx (4.49)

Setzen wir dies in (4.47) ein, so erhalten wir eine Bestimmungsgleichung für die
Amplitude a:
an+1 an = v an eikdx e ikdx :
dt 2dx (4.50)

Die Lösung ist:

a = 1 i vdt
dx sin(k dx) : (4.51)
4.4 Solitonen 155

a ist also komplex, und der Betrag ist außer für k = 0 immer größer als eins.
Das heißt, daß jede Anfangsauslenkung, die nicht gerade konstant ist, mit der Zeit
exponentiell anwächst. Der Algorithmus ist unbrauchbar!
Eine scheinbar unwesentliche Änderung kann das Verfahren aber stabilisieren:
Wir ersetzen in Gleichung (4.47) ujn durch den Mittelwert:

ujn ! 21 ujn+1 + ujn 1 : (4.52)

Dann erhalten wir

ujn+1 = 12 ujn+1 + ujn 1 vdt uj+1 uj 1 ;

2dx n n (4.53)

und die Amplitudengleichung ergibt:

a = cos(kdx) i vdt
dx sin(kdx) : (4.54)

Nun ist jaj 1 für

jvjdt dx : (4.55)
Diese Ungleichung heißt Courant-Bedingung. Sie besagt, daß Störungen nur dann
jj
stabil bleiben, wenn der Zeitschritt dt kleiner als die Ausbreitungszeit dx= v ge-
wählt wird. Oder umgekehrt: Die räumliche Diskretisierung darf nicht zu klein
gewählt werden!
Nach Gleichung (4.46) ist es besser, auch die Zeitableitung symmetrisch zu dis-
kretisieren:
ujn+1 ujn 1 = vdt j +1 j 1
dx un un : (4.56)

Dies gibt die Amplitudengleichung

a a1 = 2 i vdt
dx sin kdx : (4.57)

Die Lösung s 2
a= i vdt
dx sin kdx 1
vdt
dx sin kdx (4.58)

jj
zeigt, daß a den Wert 1 hat, wenn die Courant-Bedingung (4.55) gilt. Auch hier
muß man dt relativ zu dx klein genug wählen.
Gleichung (4.56) enthält nun drei Zeitschritte, nämlich n + 1; n und n 1. Um
die Zukunft zu berechnen, müssen wir Gegenwart und Vergangenheit kennen. Im
ersten Schritt kennen wir nur die Gegenwart, die Zukunft muß also in einem Schritt,
156 4 Differentialgleichungen

z. B. mit Gleichung (4.53) berechnet werden. Alle weiteren Schritte können dann
mit Gleichung (4.56) durchgeführt werden.
Diese Erkenntnisse wollen wir nun für die numerische Lösung der KdV-Glei-
chung nutzen. Wir setzen:

j j
@u
@t ! un+12dtun 1 ;
@u ! un 2dxun ;
j +1 j 1
@x
u

! 13 ujn+1 + ujn + ujn 1 ;
@3u 1 uj+2 2uj+1 + 2uj 1 uj 2 :
! 2(dx

@x3 )3 n n n n

n 1 nennen wir Vergangenheit, n Gegenwart und n + 1 Zukunft. Dann lautet ein

Zeitschritt
step2[u_,w_]:=(up1=RotateLeft[u]; up2=RotateLeft[up1];
um1=RotateRight[u];um2=RotateRight[um1];
w+dt(2(um1+u+up1)*(up1–um1)/dx –
(up2–2 up1+2 um1–um2)/dxˆ3 ) )
Mit step2 erzeugen wir die Liste ufut der Zukunft, wenn wir die Gegenwart (Li-
ste upres) und die Vergangenheit (Liste upast) einsetzen. Mit plot3[i_:9]
wird dies iteriert und nach i Zeitschritten gezeichnet, wobei wir vorher mit
Interpolation[xulist] durch die x-u-Werte eine glatte Kurve hindurch-
gelegt haben.
plot3[i_:9]:=
(Do[ufut=step2[upres,upast];
upast=upres;upres=ufut; zeit = zeit+dt, {i}];
Print["Zeit ",zeit];
xulist=Table[{(j–max/2)*dx,ufut[[j+1]]},{j,0,max}];
uu=Interpolation[xulist];
Plot[uu[x],{x,–10.,10.},PlotRange–>All,
Frame –> True, Axes –> None ] )
Bild 4.8 zeigt das Ergebnis für den Anfangszustand u(x; 0) = 6 sech2 (x). Die
Übereinstimmung zwischen numerischer und exakter Lösung, die als punktierte
Kurve ebenfalls eingezeichnet ist, kann als gut bezeichnet werden. Aus dem Wellen-
tal u(x; 0) entstehen zwei Solitonen, die sich mit unterschiedlicher Geschwindigkeit
nach rechts bewegen. Dies wird besonders im 3D-Plot (Bild 4.10) von u(x; t) und
4.4 Solitonen 157

0
-2
-4
u -6
-8
-10
4 0.2
2
0.1
0
x 0
-2 t
-0.1
-4
-0.2

4.10 Zwei Solitonen wie in Bild 4.8, aber als 3D-Plot für verschiedene Zeiten. Ein großes,
schnelles Soliton überholt ein kleines breites.

x 0

-5 4.11 Wie Bild 4.10, aber als Contour-

Plot mit anderen Bereichen von Ort
und Zeit. Beim Überholvorgang erfährt
-10 das kleine und breite Soliton eine
-1 -0.5 0 0.5 1 Verzögerung, während das große be-
t schleunigt wird.

im dazugehörigen Contour-Plot (Bild 4.11) deutlich. Für negative Zeiten nähert sich
das schnelle Soliton mit großer Amplitude dem langsamen. Bei t = 0 überlagern
sich beide zu einem einzigen Wellental, und nach dem Überholvorgang haben beide
wieder die ursprüngliche Gestalt. Beim Überholen erfährt das kleine Soliton ei-
ne Verzögerung, während das große beschleunigt wird. Dies ist besonders gut im
Contour-Plot Bild 4.11 zu erkennen.
158 4 Differentialgleichungen

-1
u(x,0.3)

-2

-3 4.12 Wie Bild 4.8, aber

mit dem Startzustand
-4
u(x; 0) = 4 sech2 x. Zu-
sätzlich zum nach rechts
-10 -5 0 5 10 laufenden Soliton werden
x Wellen abgestrahlt.

Die eingangs erwähnten analytischen Lösungen haben als Anfangszustand N (N +

1) sech2 x, der in N Solitonen zerfällt. Die Amplituden 2 und 6 ergeben also die
Ein- bzw. Zwei-Soliton-Lösung. Was aber geschieht mit Anfangszuständen, deren
Amplitude dazwischen liegt? Bild 4.12 zeigt das numerische Ergebnis für den Start-
zustand u(x; 0) = 4 sech2 x. Zusätzlich zum Soliton, das sich nach rechts bewegt,
zerfließen nach links weitere Wellen.
Selbstverständlich läßt sich durch Verkleinern der Schrittweite dx die Güte der
numerischen Approximation verbessern. Der Aufwand steigt dabei aber beträcht-
lich. Klar ist, daß die Länge der Listen ujn max f g
j =0 wie 1=dx anwächst. Daß aber aus
Stabilitätsgründen zugleich das maximale dt proportional zu (dx)3 verkleinert wer-
den muß, wollen wir in der folgenden Übung behandeln.

Übung
Die Stabilität des in step2[u_,w_] programmierten Algorithmus wird entschei-
dend durch die diskretisierte dritte Ableitung begrenzt.

a) Streichen Sie in der vollen KdV-Gleichung den nichtlinearen Term. Untersuchen

Sie also die Gleichung

@u = @ 3u :
@t @x3 (4.59)

Die hier benutzte Diskretisierung ergibt

ujn+1 = ujn 1 dt (ujn+2 2ujn+1 + 2unj 1 unj 2 )=(dx)3 : (4.60)

Untersuchen Sie diesen Algorithmus auf seine Stabilität, indem Sie in (4.60) den
Ansatz (4.49) verwenden. Zeigen Sie, daß analog zu (4.57) hieraus die Amplitu-
4.5 Zeitabhängige Schrödinger-Gleichung 159

dengleichung

a = a1 2 i dt (sin(2kdx) 2 sin(kdx)) =(dx)3

j
folgt. Bestimmen Sie numerisch das Maximum von sin(2kdx) 2 sin(kdx) j
( ' j j
2:6) und zeigen Sie, daß sich hieraus und aus der Forderung a 1 die
folgende Stabilitätsbedingung ergibt:

dt 1 (dx)3 : (4.61)

b) Benutzen Sie den Algorithmus step2[u,w] zur Integration und die Anfangs-
bedingung u(x; 0) = 6 sech2 x. Variieren Sie dx zwischen 0:1 und 0:2 und
bestimmen Sie zu gegebenem dx die Stabilitätsgrenze hinsichtlich dt, d. h. be-
stimmen Sie ungefähr das maximale dt in Abhängigkeit von dx. Bestätigen Sie
in einem log-log-Plot die Gleichung (4.61).

Literatur
G. Baumann, Mathematica in der Theoretischen Physik, Springer Verlag, 1993.
R. E. Crandall, Mathematica for the Sciences, Addison Wesley, 1991.

4.5 Zeitabhängige Schrödinger-Gleichung

Wenn sich ein Teilchen in einem Kasten ohne Reibung und ohne sonstige Kräfte
bewegt, so ändert sich seine Bewegung nur dadurch, daß es an den Wänden re-
flektiert wird. In einer Dimension läuft es also gleichmäßig hin und her. Dieses
klassische Bild, das von der Vorstellung einer Punktmasse mit scharfem Ort und
Impuls ausgeht, trifft aber nicht mehr zu, wenn der Kasten mikroskopisch klein
ist. Dann müssen wir das Teilchen durch eine Wellenfunktion beschreiben. In der
Quantenmechanik-Vorlesung lernt man, daß die stationären Zustände in diesem Fall
stehende Wellen sind. Was aber passiert mit einem anfangs lokalisierten Wellenpa-
ket, das gegen die Wände des Kastens läuft?
Dieses Problem hat sowohl analytische als auch numerische Aspekte. Wir wer-
den die Entwicklung nach Eigenfunktionen benutzen, um Aussagen über Symmetri-
en, Wiederkehrzeiten und weitere charakteristische Längen- und Zeitskalen zu ge-
winnen. Andererseits wollen wir anhand der zeitabhängigen Schrödinger-Gleichung
demonstrieren, wie man partielle Differentialgleichungen numerisch mit einem im-
pliziten Schema löst. Dabei ist eine tridiagonale Matrix zu invertieren, wofür es
ein schnelles numerisches Verfahren gibt. Außerdem ist bei der Diskretisierung der
160 4 Differentialgleichungen

quantenmechanischen Zeitentwicklung darauf zu achten, daß die Norm der Wellen-

funktion sich zeitlich nicht ändert.
Wir werden sehen, daß das scheinbar einfache und wohlverstandene Lehrbuch-
Beispiel ein überraschend komplexes Verhalten zeigt. Das Wellenpaket zerfließt, es
entstehen wilde Interferenzmuster, die sich plötzlich wieder zu glatten Wellenpake-
ten rekonstruieren. Schließlich wiederholt sich der ganze Prozeß periodisch mit der
Zeit. Das Titelbild dieses Lehrbuchs zeigt, welche Komplexität und Schönheit aus
elementarer Quantenmechanik entstehen kann.

Physik
Es sei (x; t) die komplexwertige Wellenfunktion eines Teilchens mit der Masse m,
das sich in einer Dimension in einem Potential V~ (x) bewegt. (x; t) 2 dx ist dann
j j
die Wahrscheinlichkeit, das Teilchen zur Zeit t im Intervall [x; x + dx] anzutreffen.
Die zeitliche Änderung von (x; t) wird durch die Schrödinger-Gleichung in der
Ortsdardarstellung beschrieben:

i ~ @@t = 2~m @@x2 + V~ (x) :

2 2
(4.62)

Um diese Gleichung in eine dimensionslose Form zu bringen, skalieren wir die Zeit
mit t0 und den Ort mit x0 :

i t~ @ (@t=t ) = 2mx~2 @ 2 + V~ (x) :

2 @ (x=x0 )2 (4.63)
0 0 0
Nun wählen wir t0 und x0 so, daß folgende Gleichung erfüllt ist:

~ t0 = 2mx20 : (4.64)

Wenn wir nun V~ (x) t0 =~ = V (x=x0 ) setzen und Ort und Zeit in Einheiten von x0
und t0 messen, so erhalten wir die dimensionslose Gleichung
@
@2
i @t = H = @x2 + V (x) : (4.65)

H ist der skalierte Hamiltonoperator des Teilchens. Zur numerischen Lösung dieser
Gleichung gibt es zwei Wege: Erstens können wir die Eigenzustände und Eigenwer-
te der stationären Gleichung H = E berechnen, (x; 0) nach diesen Zuständen
entwickeln und dann für (x; t) eine Reihendarstellung angeben. Zweitens können
wir die zeitabhängige Gleichung wie im vorigen Abschnitt direkt integrieren. Der
zweite Weg ist auch für Probleme anwendbar, bei denen die erste Methode versagt,
so daß wir im Algorithmus-Teil diesen Weg beschreiben wollen. Wenn andererseits
4.5 Zeitabhängige Schrödinger-Gleichung 161

die Eigenzustände bekannt sind, so kann man mit dem analytischen Ansatz zumin-
dest einige Eigenschaften der Wellenfunktion (x; t) direkt herleiten.
Wir wollen ein Teilchen im unendlich hohen Kasten betrachten. Weil im folgen-
den Symmetrieüberlegungen eine beträchtliche Rolle spielen, legen wir das Koor-
dinatensystem so, daß sich diese Symmetrie einfach ausdrücken läßt. Das Potential
V (x) habe also die Form
0 1 x 12 ;
V (x) = 1
für
sonst :
2 (4.66)

Dabei wird die Länge x in Einheiten der Breite a des Kastens und die Energie
in Einheiten von ~2 =2ma2 gemessen. Die Energien En der stationären Zustände
n (x) sind aus der Quantenmechanik-Vorlesung bekannt:
En = (n2 2 mit n = 1; 2; 3; : : : ;
p
n (x) = p2 cos(nx) für n ungerade ; 1
2 x 12 : (4.67)
2 sin(nx) für n gerade
Diese Zustände sind stehende Wellen, deren Betrag sich zeitlich nicht ändert. Der
hi
mittlere Ort des Teilchens in diesen Zuständen x = 0 ändert sich ebenfalls nicht
mit der Zeit.
Wir wollen nun ein Wellenpaket (x; t) betrachten, das im Kasten hin- und
herläuft. (x; 0) kann nach den Eigenzuständen entwickelt werden, so daß wir für
(x; t) erhalten:
X
1
i 2 (2m 1)2 t
(x; t) = c^2m 1 e cos((2m 1)x) +
m=1
X
1
i 2 (2m)2 t
c^2m e sin(2mx) (4.68)
m=1
= g (x; t) + u (x; t) (4.69)

f g
mit Entwicklungskoeffizienten c^n . Wegen der Symmetrie der Basisfunktionen
(4.67) liefert diese Entwicklung zugleich die Zerlegung von (x; t) in den gera-
den ( g ) und ungeraden ( u ) Anteil.
Der allgemeine Zustand ist also eine unendliche Überlagerung aus stehenden
Wellen, bei jeder Welle aber entwickelt sich der Phasenfaktor mit einer anderen
Geschwindigkeit. Auf diese Weise werden komplexe Interferenzmuster erzeugt, die
sich zeitlich sehr schnell ändern können (siehe Ergebnisse). Allerdings gibt es im
Kasten eine Besonderheit, die mit der Struktur der Energien En zusammenhängt.
Jede Frequenz !n = n2 2 ist ein ganzzahliges Vielfaches der Grundfrequenz
162 4 Differentialgleichungen

!1 = 2 . Daraus folgt, daß (x; t) periodisch in der Zeit t ist mit der Periodendauer
T = 2=!1 = 2= . Nach der Zeit t = T verschwinden die wilden Interferenz-
muster und das Wellenpaket (x; t) kehrt vollständig in seinen Ausgangszustand
(x; 0) zurück.
Wir werden im Ergebnisteil sehen, daß auch schon vorher zu bestimmten Zei-
ten einfache Muster auftauchen. So entsteht z. B. nach der Zeit t = T=2 die an der
Mitte des Kastens gespiegelte Anfangsverteilung, die gerade in die entgegengesetzte
Richtung läuft. Dies wollen wir kurz analytisch zeigen. Zur Zeit t = T=2 = 1= er-
geben alle Phasenfaktoren in g (x; t) den Faktor 1, denn exp( i (2m 1)2 ) =
1, während die e-Faktoren in u (x; t) für t = 1= alle den Wert 1 haben. Also
erhalten wir

(x; T2 ) = g (x; 0) + u (x; 0)

= g ( x; 0) u ( x; 0) = ( x; 0) : (4.70)

Nach der Zeit T=2 entsteht also die Aufenthaltswahrscheinlichkeit (x; 0) 2 zur j j
Anfangszeit, nur an der Mittelachse des Kastens, x = 0, gespiegelt. Daß die Welle
zu diesem Zeitpunkt in die entgegengesetzte Richtung läuft, erkennt man am besten
an der Stromdichte

j (x; t) = i (x; t) @@x (x; t) (x; t) @
@x (x; t) : (4.71)

Setzen wir hier das Ergebnis von Gleichung (4.70) ein, so ergibt sich unmittelbar

j (x; T2 ) = j ( x; 0) : (4.72)

Wir haben gezeigt, daß sich zu den Zeiten T=2 und T aus den komplexen Interfe-
renzmustern die ursprüngliche Form zurückbildet. Der Ergebnisteil zeigt aber, daß
sich auch schon früher einfache Wellen bilden. So entstehen z. B. bei T=4 zwei
Wellenpakete, die gegeneinander laufen und später miteinander interferieren. Dies
ist eine Folge der von uns gewählten Anfangsbedingung
" 2 #
(x; 0) = eikx exp 1 x + 14 :
22 (4.73)

ist eine Gaußfunktion der Breite , die bei x = 1=4 konzentriert ist, mul-
tipliziert mit exp(ikx). Dieser Faktor bewirkt, daß das Teilchen am Anfang eine
mittlere Geschwindigkeit

hvi0 = h t=0 j mp j t=0 i= k k2 = ~mk = 2 k (4.74)

4.5 Zeitabhängige Schrödinger-Gleichung 163

hat. Die Breite muß genügend klein sein, damit die Randbedingung ( 12 ; 0) = 0
noch mit ausreichender Genauigkeit als erfüllt angesehen werden kann. In der nu-
merischen Simulation verwenden wir = 0:05, also ( 12 ; 0) j
exp( 12:5) j .
j
4 10 6 im Vergleich zu ( 1=4; 0) = 1 . j
Wir setzen t = T=4 = 1=(2 ) in Gleichung (4.68) ein – die Phasenfaktoren
ergeben jetzt exp( i 2 (2m 1)2 =(2 )) = i bzw. exp( i 2 (2m)2 =(2 )) = 1
– und erhalten
(x; T4 ) = i g (x; 0) + u (x; 0) : (4.75)
Das Betragsquadrat der Wellenfunktion für t = T=4 ist demnach

j (x; T4 )j2 = j g (x; 0)j2 + j u(x; 0)j2 + :

i
g (x; 0) u (x; 0) g (x; 0) u (x; 0) (4.76)

Der letzte Summand dieser Gleichung, der sich als 2 Im( g (x; 0) u (x; 0)) schrei-
ben läßt, ist verschwindend klein. Eine einfache Rechnung unter Benutzung von
(4.73) ergibt:
1
1
2 Im ( g (x; 0) (x; 0)) = 2 exp + 2x2 cos kx sin kx ;
u 22 8
(4.77)
einen Term also, der für = 0:05 von der Größenordnung exp( 25) ist. Der Rest

läßt sich in folgender Weise durch ( x; 0) ausdrücken:

j g (x; 0)j2 + j u(x; 0)j2

= 12 j g (x; 0) + u (x; 0)j2 + j g (x; 0)

u (x; 0)j
2

= 12 j g (x; 0) + u (x; 0)j2 + j g ( x; 0) + u ( x; 0)j2

= 12 j (x; 0)j2 + j ( x; 0)j2 :

Zusammengefaßt erhalten wir:

j (x; T4 )j2
= 21 (j (x; 0)j2 + j ( x; 0)j2 ) ; (4.78)

also gerade die symmetrisierte Anfangsverteilung. Eine entsprechende Rechnung

für die Stromdichte ergibt

j (x; T4 )
= 12 j (x; 0) 1 j(
2 x; 0) (4.79)

und zeigt uns, daß die beiden Wellenpakete (4.78) aufeinanderzulaufen.

164 4 Differentialgleichungen

Auch zu noch kürzeren Zeiten entstehen Wellen mit einer einfachen Struktur.
Setzen wir t = T p=q mit ganzen teilerfremden Zahlen p und q , dann kann die Pha-
se exp( 2i n2 p=q ) höchstens q verschiedene Werte annehmen. (x; t) ist daher
nach (4.68) eine Überlagerung von q Wellen, wobei jede Welle eine unendliche Teil-
summe aus (x; 0) ist. Nimmt man an, daß jede Teilwelle eine glatte Funktion ist,
so ist deren Überlagerung ebenfalls glatt, und (x; t) zeigt zu diesen Zeiten eine
einfache Struktur. Genau dies werden wir bei der numerischen Integration beobach-
ten.
Damit schließen wir die analytischen Betrachtungen ab und wenden uns der Be-
schreibung der numerischen Lösung der zeitabhängigen Schrödinger-Gleichung zu.

Algorithmus
Zunächst wird (x; t) diskretisiert:
j
n = (j dx; n dt) : (4.80)
j und n sind ganze Zahlen, dx und dt sind die Schrittweiten in Ort und Zeit. Wie
vorher schreiben wir die zweite Ableitung mit einem Fehler der Größenordnung
O (dx2 ) als
@2 !1 j +1 2 j + j 1 :
@x 2 (dx)2 n n n (4.81)

Nun könnten wir die zeitliche Ableitung geeignet diskretisieren, analog zu den So-

Gesamtwahrscheinlichkeit
Rj
litonen aus dem vorigen Abschnitt. Allerdings erhält dieser Algorithmus nicht die
j
(x; t) 2 dx = 1, die sich zeitlich nicht ändern darf.
Es ist in der Tat möglich, eine diskrete Näherung der partiellen Differentialglei-
chung zu finden, bei der die Gesamtwahrscheinlichkeit erhalten bleibt. Dazu muß
der diskretisierte Zeitentwicklungsoperator unitär gewählt werden.
Die Lösung der Schrödinger-Gleichung (4.65) kann man auch in der Form

(x; t + dt) = e iHdt (x; t) (4.82)

schreiben. Die Näherung

e iHdt ' (1 iHdt) + O(dt2 ) ; (4.83)

die dem einfachen Euler-Schritt entspricht, ist nicht mehr unitär. Dagegen erhält
man mit
1
e iHdt = eiHdt=2 1 e iHdt=2 1 + iH dt
' 2 1 iH dt + (dt3 )
2 O
(4.84)
einen unitären Operator für die diskrete Zeitentwicklung:
4.5 Zeitabhängige Schrödinger-Gleichung 165

1
j
n+1 = 1 + 2i H dt 1 2i H dt j
n: (4.85)
Pj j
Nun bleibt die Gesamtwahrscheinlichkeit j nj 2 als Funktion der Zeit n kon-
stant. Der inverse Operator kann auch auf die linke Seite der Gleichung gebracht
werden, i
1 + i H dt
2
j
n+1 = 1 2 H dt j
n: (4.86)

In dieser Form wird die Differenzengleichung implizit; das heißt, die Wellenfunkti-
on im folgenden Zeitschritt ist durch ein Gleichungssystem bestimmt, das man erst
lösen muß. Der entsprechende Algorithmus kostet zwar mehr Rechenzeit, führt aber
fast immer zu einem stabilen numerischen Verfahren. Setzen wir nun die spezielle
Form des Hamiltonoperators ein, so erhalten wir

(H )jn = (dx1 )2 j +1 2 nj + j 1 +Vj j :

n n n (4.87)

Damit erhält man aus Gleichung (4.86)
2 (dx)2 (dx)2 V j

j +1 j j 1
n+1 + i dt 2 n+1 + n+1 =
2 (dx)2
j +1 i j
+ (dx) V + 2
2 j j 1 j:
n + dt n n = n (4.88)

Die zweite Zeile, in der nur Größen des Zeitschritts n vorkommen, haben wir mit
j abgekürzt. Diese Gleichung hat die Form
n
T n+1 = n; (4.89)
wobei die Matrix T Tridiagonalgestalt hat. Wir müssen also zu jedem Zeitschritt ein
lineares Gleichungssystem lösen. Bei Tridiagonalmatrizen gibt es dafür ein speziel-
les Verfahren. Wir machen den Ansatz
j +1 j j j
n+1 = a n+1 + bn : (4.90)
Setzen wir dies in Gleichung (4.88) ein, so finden wir
1 :
j = 2 + (dx)2 V j i 2(dx)
2
a j j 1 j j
n+1 dt n+1 + bn n (4.91)

Der Vergleich mit (4.90) ergibt Gleichungen für aj 1 und bjn 1 , die wir nach aj und
bjn auflösen können. Das Ergebnis ist
aj = 2 + (dx)2 V j i 2(dx dt
)2 1 ;
a 1
j
j
b = j j
+ b =a :
1 j 1
n n n (4.92)
166 4 Differentialgleichungen

aj ist also, wie vom Ansatz (4.90) gefordert, von n unabhängig, während bjn aus der
Wellenfunktion nj berechnet wird. Zur Lösung dieser Gleichungen benötigen wir
den Anfangszustand 0j und Randbedingungen. Da wir das Teilchen in einen Kasten
mit unendlich hohen Wänden sperren wollen, muß am Rand verschwinden,
0 =0 J = 0;
n und n (4.93)

wobei wir jetzt, da es sich einfacher programmieren läßt, den Rand durch x = 0 und
x = 1 definiert haben. Die Anzahl J der Stützpunkte ist damit durch J = 1+1=dx
festgelegt. Gleichung (4.88) lautet bei j = 1:

2 (dx)2

n+1 + i dt (dx)2 V 1 2 n+1 = n :
2 1 1 (4.94)

Der Vergleich mit (4.90) ergibt:

dx)2 ; b1 = 1 :
a1 = 2 + (dx)2 V 1 i 2 (dt n n (4.95)

Mit diesen Startwerten und Gleichung (4.92) können alle aj und nach jedem Zeit-
schritt alle bjn berechnet werden. Die Wellenfunktion berechnet man dann durch
Rückwärts-Iteration aus Gleichung (4.90):
j = j +1
bjn =aj :
n+1 n+1 (4.96)

Da der rechte Randwert nJ+1 = 0 festliegt, kann so der gesamte Vektor j

n+1 zur
Zeit n + 1 berechnet werden.

Alle Ergebnisse werden nun zu einem Algorithmus zusammengefaßt:

1. Wähle einen Startzustand 0j und berechne damit j aus Gleichung (4.88).

0
2. Berechne den Vektor aj mit dem Startwert aus Gleichung (4.95) und der Rekur-
sion (4.92).

3. Berechne für alle Orte j die Variable bjn mit dem Startwert aus (4.95) und der
Rekursion (4.92).

4. Berechne aus Gleichung (4.96) die Werte der Wellenfunktion nj +1 mit dem
Startwert nJ+1 = 0 für den nächsten Zeitschritt n + 1. Damit erhält man auch
j aus Gleichung (4.88).
n+1
5. Iteriere die Schritte 3 und 4 für n = 0; 1; 2; :::
4.5 Zeitabhängige Schrödinger-Gleichung 167

Als Anfangszustand wählen wir, wie schon erwähnt, ein Gaußsches Wellenpaket,
das sich mit dem mittleren Impuls k bewegt:
(x x )2
0
(x; 0) = ei k x exp 2 2 : (4.97)

Die obigen Gleichungen können leicht in jeder Programmiersprache formuliert wer-

den. Dabei muß allerdings beachtet werden, daß die Größen f g
n ; a und bn
j j f gj
komplexe Zahlen sind. Während Mathematica und auch andere Sprachen wie FOR-
TRAN direkt mit solchen Zahlen rechnen können, muß man in C entweder die ent-
sprechenden Routinen, z. B. aus den Numerical Recipes, hinzufügen oder selbst eine
Struktur mit Real- und Imaginärteil definieren:

typedef struct{double real, imag; } complex;

Multiplikation und Division müssen damit selbst geschrieben werden. Die für kom-
plexe Zahlen a = Re a + i Im a und b = Re b + i Im b bekannten Formeln der
Multiplikation und Division

a b = Re a Re b Im a Im b + i (Im a Re b + Re a Im b) ; (4.98)
a = Re a Re b + Im a Im b + i (Im a Re b Re a Im b)
b (Re b)2 + (Im b)2 (4.99)

finden sich zum Beispiel in der als Funktion calculate_b geschriebenen Iterati-
on der Gleichung (4.92) wieder:
void calculate_b(complex *b, complex *omega, complex *a)
{
int j ; double a2;

b[1].real=omega[1].real;
b[1].imag=omega[1].imag;
for (j=2;j<J;j++)
{a2=a[j–1].real*a[j–1].real+a[j–1].imag*a[j–1].imag;
b[j].real=omega[j].real+
(b[j–1].real*a[j–1].real+b[j–1].imag*a[j–1].imag)/a2;
b[j].imag=omega[j].imag+
(b[j–1].imag*a[j–1].real–b[j–1].real*a[j–1].imag)/a2;
}
}

Alle anderen Schritte des obigen Algorithmus lassen sich ebenso einfach program-
mieren. Wir verweisen auf den Quellcode auf der beiliegenden Diskette.
168 4 Differentialgleichungen

Zur numerischen Integration der Schrödinger-Gleichung haben wir für den Ka-
sten das Intervall [0; 1] gewählt, unter anderem auch, weil sich damit die x-Koordi-
nate leichter in positive Bildkoordinaten umrechnen läßt. Die der Gleichung (4.68)
entsprechende Eigenfunktionsentwicklung lautet dann:
X
1
in2 2 t
(x; t) = cn e sin(nx) ; (4.100)
n=1
Z1
cn = 2 sin(nx) (x; 0) dx : (4.101)
0
Der Startzustand in unserer Simulation ist das gaußförmige Wellenpaket (4.97) mit
der Breite = 0:05 und dem mittleren Impuls k = 40, das bei x0 = 0:25 zentriert
ist. Wie wir schon gesehen haben, muß die Welle nach der Zeit T = 2= 0:6366 '
in ihren Anfangszustand zurückkehren. Dies gibt uns einen Test für die Genauigkeit,
mit der wir die Schrödinger-Gleichung integriert haben.
T ist natürlich auch die größte Zeitskala, die für dieses Problem relevant ist.
Zusätzlich aber gibt es drei weitere charakteristische Zeiten, die hier eine Rolle
spielen. Da ist zum einen die Zeit t1 , die das Teilchen benötigt, um aufgrund seines
mittleren Impulses den Kasten einmal zu durchlaufen. Mit k = 40 erhalten wir aus
Gleichung (4.74) t1 = 1=80 = 0:0125 . Darüber hinaus müssen wir den typisch
quantenmechanischen Effekt des Zerfließens eines Wellenpaketes berücksichtigen.
Eine freie gaußförmige Anfangsverteilung mit der Breite hat zur Zeit t die Breite
p
1 + t2 ~2 =(4 m2 4). Wenn wir fragen, wann diese Breite mit der Kastenbreite

übereinstimmt, so erhalten wir daraus die Zeit t2 = 1=20 = 0:05 .
Die vierte Zeitskala schließlich, die uns auch einen Anhaltspunkt für die Wahl der
Schrittweiten dx und dt gibt, ist durch die größte relevante Phasengeschwindigkeit
festgelegt, zu deren Bestimmung wir die Gleichungen (4.100) und (4.101) heranzie-
hen. Drücken wir den Sinus in diesen Gleichungen durch die Exponentialfunktion
aus, so sind die Summanden in (4.100) von der Form

cn e i n (n t x) ; (4.102)

so daß die Phasengeschwindigkeit vnph für diese Teilwelle den Wert

vnph = n (4.103)

hat. Um abzuschätzen, bis zu welchem n die Koeffizienten cn nennenswerte Bei-

träge liefern, erinnern wir daran, daß die Fouriertransformierte einer Gaußfunkti-
on wiederum eine Gaußfunktion ist, allerdings mit reziproker Breite. Der Faktor
exp(i k x) bedeutet im Fourierraum eine Verschiebung um k. Daraus folgt für die
n-Abhängigkeit von cn :
j j/
cn e 12 2 (n k)2 : (4.104)
4.5 Zeitabhängige Schrödinger-Gleichung 169

Auf dem dem Bildschirm können wir nur solche Amplituden sichtbar machen,
die mindestens 1=1000 der maximalen Amplitude betragen. Dies führt uns zur
Abschätzung
1 2 (n k)2 ln(1000) ) nmax ' 35 ; vmax
ph ' 100 : (4.105)
2
Wenn auf den kürzesten Sinusbogen noch etwa 20 bis 30 Teilpunkte entfallen sollen,
so ergibt diese Überlegung

dx . 10 3 und dt . 10 5 ; (4.106)

weil dt jedenfalls nicht größer als dx=vmax

ph sein sollte.
Will man auch den globalen Aspekt berücksichtigen, daß die Integration zumin-
dest bis zur Dauer einer Periode korrekt sein soll, so läßt sich die Schrittweite dt
durch folgende Überlegung genauer festlegen. Der von uns benutzte numerische Al-
gorithmus garantiert zwar, daß die Norm der Wellenfunktion erhalten bleibt, stellt
aber trotzdem eine Näherung dar. Während nämlich die exakte Zeitentwicklung der
Eigenmode n (x) nach ` Zeitschritten durch den Faktor exp( i n2 2 ` dt) gege-
ben ist, berechnen wir sie numerisch gemäß (4.85) als
1 i dt n22 ` dt
2 =e i ` d' mit d' = 2 arctan 2 n22 :
1 + i dt2 n2 2
(4.107)

Für den Betrag der Differenz dieser beiden Ausdrücke liefert die Taylor-Entwick-
lung von d'
1 `(dt n2 2 )3 :
' 12 (4.108)

Fordern wir < 1=2 für ` = T=dt und n = nmax , so folgt hieraus dt 2 10 6 . .
Es stellt sich heraus, daß unser Algorithmus in der Tat mit dx = 10 3 und dt = 5
10 6 passable Ergebnisse produziert, die allerdings mit wachsender Integrationszeit
auch Abweichungen von der exakten Zeitentwicklung aufweisen.

Ergebnisse
Am Anfang merkt die Welle noch nichts vom Kasten. Sie bewegt sich nach rechts
und zerfließt dabei. Sobald aber ein Teil der Welle von der Wand reflektiert wird,
interferiert er mit dem noch einlaufendem Teil zu einem Wellenmuster (Bild 4.13,
links). Auf der rechten Seite dieser Abbildung sieht man, daß sich schon nach kurzer
Zeit (t = T=40) ein unregelmäßiges Interferenzmuster über den ganzen Kasten
ausgebildet hat. Dieses Muster ist typisch für fast alle Zeiten.
170 4 Differentialgleichungen

Doch plötzlich entstehen aus den scheinbar chaotischen Bewegungen regelmäßi-

ge Figuren, wie in Bild 4.14 und 4.15 zu den Zeiten T=12 ; T=4 ; T=3 und T=2 zu
sehen ist. Wie schon gezeigt wurde, bilden sich zur Zeit t = T=4 zwei Wellenpake-
te, die gegeneinander laufen und dann miteinander interferieren (Bild 4.14, rechts),
und bei t = T=2 entsteht plötzlich wieder die ursprüngliche Welle, allerdings an
der Mitte des Kastens gespiegelt und nach links laufend (Bild 4.15, rechts). Diese
einfachen Muster zerfließen und interferieren aber schnell wieder zu wilden Bewe-
gungen.

j j
4.13 Links: Wellenpaket (x; t) 2 kurz nach dem ersten Aufprall auf die Wand (t =
j j
T=100). Rechts: Typisches Interferenzmuster, (x; t) 2 für t = T=40 .

4.14 j (x; t)j2 zu den Zeiten t = T=12 (links) und t = T=4 (rechts).
Die Einzelbilder zu verschiedenen Zeiten werden im Titelbild dieses Lehrbuches als
Gebirge über der Ort-Zeit-Ebene dargestellt. Die Ortskoordinate wurde horizontal
von rechts nach links und die Zeit von hinten nach vorn aufgetragen. Ganz hinten
sieht man, wie der Startzustand nach links läuft, dabei zunächst zerfließt und dann
4.5 Zeitabhängige Schrödinger-Gleichung 171

4.15 Wellenpaket j (x; t)j2 zu den Zeiten t = T=3 (links) und t = T=2 (rechts).

an der Wand reflektiert wird. Ganz vorn ist die Aufenthaltswahrscheinlichkeit kurz
vor der Zeit T=6 zu sehen; eine glatte Welle mit drei Bergen. Dazwischen entsteht
eine faszinierende Hügellandschaft von unerwarteter Vielfalt und Regelmäßigkeit.
Insbesondere die vielen Täler, die sich sternförmig ausbreiten, sind uns bei der Be-
obachtung der Welle direkt auf dem Bildschirm nicht aufgefallen. Wir haben bis
jetzt diese Täler noch nicht analytisch berechnen können.
j j
Bild 4.16 schließlich zeigt sowohl die Anfangsverteilung (x; 0) 2 (punktiert)
als auch das numerisch integrierte Wellenpaket nach der vollen Periode T . Wollten

4.16 Die Anfangsverteilung j j

(x; 0) 2
(punktiert) und das numerisch integrierte
j j
Wellenpaket (x; T ) 2 nach der vollen
Periode T .

wir die offensichtliche Diskrepanz zwischen numerischer Lösung und exakter Zeit-
entwicklung beseitigen, so müßten wir die Diskretisierung der Ortskoordinate noch
weiter verfeinern. Bei unseren Überlegungen zur Periodendauer sind wir bisher
nämlich von den Energiewerten En = n2 2 des exakten Hamiltonoperators H
ausgegangen, wohingegen für die numerische Integration die Matrixversion von H ,
Gleichung (4.87) mit V j = 0, relevant ist. Die Eigenwerte End dieses Operators
und die zugehörigen Eigenvektoren jn , die natürlich die Randbedingungen (4.93)
172 4 Differentialgleichungen

erfüllen müssen, sind aber auch bekannt:

jn = sin(n j dx) ; End = (dx4 )2 sin2 n

2 dx : (4.109)

n ist hier der Index der Eigenmode und nicht die Nummer des Zeitschrittes. Der
obigen Gleichung und der Entwicklung von End für dx 1,
1 n4 4 (dx)2 ;
End ' n22 12 (4.110)
entnehmen wir erstens, daß die Frequenzen nicht mehr exakt ganzzahlige Vielfa-
che einer Grundfrequenz sind, und zweitens, daß sie alle kleiner sind als die vorher
betrachteten En . Hierdurch erklärt sich sowohl die Verbreiterung als auch die zeit-
liche Verzögerung des Wellenpaketes in Bild 4.16. Die Berücksichtigung der mo-
difizierten Energiewerte End (4.109) in Gleichung (4.107) ergibt dx . 10 4 und
.
dt 10 , wenn diese Korrektur nach einer Periode noch nicht sichtbar sein soll.
6

Übung
a) Verwenden Sie die beschriebene Integrationsroutine, um die Mittelwerte x , hi
hi
p und deren Streuungen x, p in Abhängigkeit von der Zeit zu berechnen
und sichtbar zu machen.
b) Der obige Programmcode läßt sich leicht so abwandeln, daß damit der Tunnelef-
fekt demonstriert werden kann. Ändern Sie das Potential innerhalb des Kastens,
indem Sie in die Mitte des Kastens eine gaußförmige Barriere der Form
V0 e (x 12 )2 =(2d2 )
setzen. Versuchen Sie, ein numerisches Kriterium für die Tunnelzeit tT zu fin-
den. Zum Beispiel ist die Wahrscheinlichkeit wn , das Teilchen zur Zeit tn = n dt

P j j
rechts von der Barriere zu finden, durch
J j 2
j =J=2 n
P j j
wn = J j 2
j =1 0
berechenbar. Bestimmen Sie numerisch die Abhängigkeit der Tunnelzeit von V0
und der Barrierenbreite d.

Monte Carlo ! Spielbank ! Roulette! Zufallszahlen: Das sind die Assoziatio-

nen, die einer wichtigen Methode der Computersimulation den Namen gaben. Mit
Hilfe von Zufallszahlen kann man mit dem Computer z. B. die Bewegung eines
wechselwirkenden Vielteilchensystems, das sich im Wärmebad befindet, simulie-
ren. Wie im realen Experiment lassen sich Temperatur und andere Parameter vari-
ieren. Die Modellmaterialien können aufgeheizt oder abgekühlt werden, dabei kann
man bei hinreichend tiefen Temperaturen beobachten, wie Gase flüssig werden, wie
sich magnetische Atome ordnen oder wie Metalle ihren elektrischen Widerstand
verlieren.
Wir wollen hier an einfachen Beispielen studieren, wie sich mit Hilfe von Zu-
fallszahlen interessante physikalische Phänomene beschreiben lassen. Einige dieser
Modelle haben sogar universelle Eigenschaften: Die Werte der kritischen Exponen-
ten, die die Singularitäten an Phasenübergängen beschreiben, gelten für viele ver-
schiedene Modelle und werden sogar an realen Materialien gemessen. Daher ist die
Computersimulation besonders wichtig für das Verständnis der kooperativen Eigen-
schaften wechselwirkender Teilchen.

5.1 Zufallszahlen
Ein Computer kann keine Zufallszahlen erzeugen. Er arbeitet nach einem wohlde-
finierten Programm, nach Regeln also, die auf Eingabedaten angewendet werden
und Ausgabedaten erzeugen. Ein Computer funktioniert daher wie eine determini-
stische Abbildung, die dem Zufall keinen Raum läßt. Dennoch gibt es Algorithmen,
die Pseudozufallszahlen“ erzeugen. Bei vielen statistischen Tests führt eine solche
”
Folge von Zahlen zu ähnlichen Ergebnissen wie sie Zufallszahlen erzeugen würden,
die die mathematische Definition von zufällig“ erfüllen. Wir wollen hier solche
”
Algorithmen kurz vorstellen.

Algorithmus und Ergebnis

Im Rechner werden Zahlen durch eine Anzahl von Bits (0 oder 1) dargestellt. Stehen
z. B. pro Zahl 32 Bits zur Verfügung, so können damit maximal 232 verschiedene
174 5 Monte-Carlo-Simulationen

Zahlen dargestellt werden. Eine Abbildung f auf diesen Zahlen,

rn = f (rn 1 ) ; (5.1)
erzeugt demnach eine Folge r0 ; r1 ; r2 ; ::: , die sich nach höchstens 232 Schritten
wiederholen muß. Ein Computer kann daher nur periodische Sequenzen von Zahlen
erzeugen. Bei maximaler Periodenlänge kommt jede Zahl in einer sehr langen Folge
gleich oft vor, diese Zahlen sind demnach gleichverteilt. Wenn die computererzeug-
te Zahlenreihe viele Tests auf Zufälligkeit besteht, so nennt man sie Zufallszahlen.
Eine in diesem Zusammenhang häufig verwendete Abbildung f (r ) ist die Mo-
dulo-Funktion mit drei Parametern a; c und m:

rn = (a rn 1 + c) mod m : (5.2)

Ruft man die vom System bereitgestellten Zufallszahlen-Generatoren auf, z. B.

rand() in C oder Random[] in Mathematica, so werden fast immer diese soge-
nannten linear kongruenten Generatoren benutzt. Das Ergebnis der Modulo-Funk-
tion (= Rest bei Division durch m) ist auf höchstens m verschiedene Werte be-
schränkt; daher hat die maximale Periode die Länge m. Für manche Parameter a
und c wird dieses Maximum m auch erreicht. Einige Generatoren mit solchen Para-
metern haben bei den Tests auf Zufälligkeit relativ gut abgeschnitten. In den Nume-
rical Recipes sind einige Werte der günstigen Parameter (m; a; c) angegeben, z. B.
m = 6075; a = 106 und c = 1283. Mit diesem Generator haben wir Punkte auf der
dreidimensionalen Kugeloberfläche aus je drei aufeinanderfolgenden Zufallszahlen
erzeugt,
q
e n = (rn ; rn+1 ; rn+2 )= rn2 + rn2 +1 + rn2 +2 : (5.3)

Jeder Generator benötigt einen Startwert r0 , den wir hier auf r0 = 1234 gesetzt
haben. Ein kurzes Mathematica-Programm

r0 = 1234
a = 106
c = 1283
m = 6075
zufall[r_] = Mod[a r+c,m]
uniform = NestList[zufall,r0,m+1]/N[m]

verschafft uns zunächst sämtliche im Einheitsintervall liegenden Zufallszahlen, aus

denen wir mit

tripel = Table[Take[uniform,{n,n+2}],{n,m}]
unitvectors = Map[(#/Sqrt[#.#])&,tripel]
5.1 Zufallszahlen 175

e
die in Gleichung (5.3) beschriebenen Einheitsvektoren n gewinnen. Der folgende
Befehl macht daraus Graphikobjekte und stellt sie auf dem Bildschirm dar:

Show[Graphics3D[Map[Point,unitvectors]],
ViewPoint –> {2,3,2}]

Der Vektor {2,3,2} weist in die Richtung des Beobachters. Bild 5.1 (links) zeigt
e
das Ergebnis. Wären die Punkte n wirklich zufällig verteilt, so müßte bis auf

5.1 Tripel aus Pseudozufallszahlen. Links: Projektion auf die Kugeloberfläche. Rechts: Die-
selben Punkte im Einheitswürfel bei geeigneter Blickrichtung.

einen Geometriefaktor, der von der Projektion des Würfels auf die Kugel herrührt,
dieser Ausschnitt der Oberfläche gleichmäßig mit Punkten überdeckt sein. Man
sieht aber deutliche Strukturen, die aus der Korrelation zwischen drei aufeinan-
derfolgenden Zahlen rn entstehen. Tatsächlich läßt sich zeigen, daß die Punkte
u n = (rn ; rn+1 ; rn+2 )=m wie die Bausteine eines Kristalls auf einem regelmäßi-
gen Gitter liegen. Ausgehend von einem Gitterpunkt kann man die nächstgelegenen
Punkte aufsuchen und auf diese Weise die primitiven Gittervektoren bestimmen.
Blickt man aus genügend großer Entfernung und geeigneter Richtung auf die Zu-
fallspunkte, so wird diese Gitterstruktur sichtbar. Bild 5.1 (rechts) ist das Resultat
von

Show[Graphics3D[Map[Point, tripel]],
ViewPoint –> {–325., 2000., –525.}]

Es ist klar zu erkennen, daß insgesamt 14 Ebenen ausreichen, um alle Punkte unter-
zubringen. Dieser Wert ist noch als relativ gut anzusehen, denn er ist zu vergleichen
176 5 Monte-Carlo-Simulationen

mit der völlig regelmäßigen kubischen Struktur, die auf m1=3 = 60751=3 ' 18
Ebenen führt. Bei einer Periode von m = 6075 können die Vektoren also nicht
gleichförmiger als auf 18 Ebenen verteilt sein. Eine schlechte Wahl von a und c hat
zur Folge, daß weniger Ebenen ausreichen, um alle Punkte aufzunehmen.
In Abbildung 5.2 sind die Zufallszahlen in derselben Art aufgetragen wie in Bild
5.1 (links), nur wurden sie diesmal mit dem Mathematica-Generator Random[]

5.2 Wie Bild 5.1 (links), aber

die Vektoren wurden mit dem
Mathematica-Generator erzeugt.

erzeugt. Jetzt erkennt man keine Struktur mehr auf der Kugeloberfläche. Das be-
deutet aber nicht, daß es keine anderen Korrelationen zwischen den Zufallszahlen
gibt. Bei geeigneter Auftragung könnten auch höhere Korrelationen oder Abhängig-
keiten zwischen weit voneinander entfernten Zahlen dem Auge sichtbar werden.
Es gibt verschiedene Tricks, um möglichst große Perioden und gute Zufallszahlen
zu erhalten. Man kann mehrere verschiedene Generatoren ineinander verschachteln,
oder man kann andere Abbildungen f benutzen. Ebenso kann man sich Sequenzen
von einzelnen Bits erzeugen, indem man Bits in einem festem Abstand miteinander
logisch verknüpft. Nach dieser Vorschrift wird ein neues Bit erzeugt, und danach
wird das Verknüpfungsfenster um eine Stelle verschoben. Es ist aber bekannt, daß
auch solche Schieberegister-Generatoren Korrelationen in den Bitsequenzen liefern.
Wie kann man überhaupt mit einfachen Abbildungen aus m verschiedenen Zah-
len Perioden erzeugen, die länger sind als m? Um dies zu erreichen, kann man
Gleichung (5.1) z. B. dadurch erweitern, daß rn nicht nur aus einer, sondern aus
zwei oder mehreren schon erzeugten Zahlen rj berechnet wird:

rn = f (rn t ; rn s ) : (5.4)
5.1 Zufallszahlen 177

Dabei sind t und s geeignet gewählte natürliche Zahlen mit t > s. Jetzt wiederholt
f g
sich die Folge erst, wenn alle Zahlen rn t ; rn t+1 :::; rn 1 schon einmal vorge-
kommen sind. Benutzt man ganze Zahlen mit 32 Bits, so kann der Generator daher
maximal 232 t Zahlen erzeugen. Auf diese Weise lassen sich also Zahlenfolgen mit
riesigen Perioden erzeugen. Schon für t = 2 kann ein Programm, das pro Sekunde
eine Million Zufallszahlen erzeugt, 584942 Jahre laufen, bevor sich die Zahlenfolge
wiederholt.
Natürlich muß man in der Iteration (5.4) noch eine Funktion f finden, die auch
wirklich die maximale Periode 232 t erzeugt. Vor etwa 10 Jahren haben Marsaglia
und Zaman eine Klasse von einfachen Funktionen gefunden, die fast die maximale
Periode liefern. Sie nennen diese Funktionen subtract-with-borrow generators:

rn = (rn s rn tc) mod m : (5.5)

Dabei ist c ein Bit, das für den folgenden Schritt auf c = 1 oder c = 0 gesetzt wird,
je nachdem, ob rn s rn t negativ oder positiv ist. Mit zahlentheoretischen Argu-
menten geben die Autoren Werte von s; t und m an, bei denen die Periodenlänge
berechnet werden kann. So hat der Generator

rn = (rn 2 rn 3 c) mod (232 18) (5.6)

die Periodenlänge (m3 m2 )=3 ' 295 . Dieser Generator eignet sich außerdem
hervorragend für die Sprache C. In modernen Rechnern ist die Operation Modulo
232 automatisch bei der Arithmetik von ganzen Zahlen mit 32 Bit Länge eingebaut.
Da C vorzeichenlose Integerzahlen erlaubt (unsigned long int), kann man Gleichung
(5.6) sehr einfach programmieren.
Marsaglia und Zaman kombinieren diesen Generator mit

rn = (69069 rn 1 + 1013904243)mod 232 ; (5.7)

der die Periode 232 hat. Die Gleichungen (5.6) und (5.7) können leicht in der C-
Sprache formuliert werden.
#define N 1000000
typedef unsigned long int unlong;
unlong x=521288629, y=362436069, z=16163801,
c=1, n=1131199209;

unlong mzran()
{ unlong s;
if(y>x+c) {s=y–(x+c); c=0;}
else {s=y–(x+c)–18; c=1;}
x=y; y=z; z=s; n=69069*n+1013904243;
178 5 Monte-Carlo-Simulationen

return (z+n);
}

main()
{
double r=0.;
long i;
for (i=0;i<N; i++)
r+=mzran()/4294967296.;
printf ("r= %lf \n",r/(double)N);
}

x, y, z und n werden auf Anfangswerte gesetzt, die der Benutzer beliebig ändern
kann. Das Hilfsbit c muß auf c = y > z gesetzt werden, in C also auf 1 (wahr) oder
0 (falsch). Da dieses Programm für einen Rechner geschrieben ist, der die Modulo-
232 -Operation automatisch durchführt, muß bei mod (232 18) der Wert 18 noch
von der Differenz (rn 2 rn 3 c) abgezogen werden. Das geschieht natürlich nur,
wenn diese Differenz negativ ist, denn sonst kommt die Modulo-Operation nicht vor.
Der nächste rn -Wert ist die Summe der beiden Generatoren (5.6) und (5.7).
Weil diese beiden Generatoren teilerfremde Perioden haben, ist die Länge des
zusammengesetzten Generators das Produkt der beiden einzelnen Längen, also etwa
2127 . Dieser Generator kann etwa 1024 Jahre laufen, bevor sich die Zufallszahlen
wiederholen. Da die Zahlenfolge außerdem eine Menge statistischer Tests bestanden
hat, kann man bei vielen Anwendungen davon ausgehen, daß sich diese Zahlen so
verhalten wie echte“ Zufallszahlen.
”
Dennoch müssen wir den Leser warnen: auch die obigen Pseudozufallszahlen
entstehen aus einem deterministischen Algorithmus, der sogar zahlentheoretisch
analysiert werden kann. Man kann also nicht ausschließen, daß Korrelationen bei
statistischen Anwendungen stören. Jedes Problem reagiert anders auf unterschied-
liche Korrelationen. Daher können die Experten auch nach einigen Jahrzehnten Er-
fahrung mit Zufallszahlen nur den Rat geben, verschiedene Generatoren zu benut-
zen und die Ergebnisse zu vergleichen. Wenn möglich, sollte man sich ein ähnliches
Problem suchen, das exakt gelöst werden kann und die numerischen Ergebnisse
mit den exakt berechneten vergleichen. Dann hat man eine gewisse Sicherheit über
die Qualität der Zufallszahlen. Da die zukünftigen Computersimulationen immer
umfangreicher und genauer werden, darf die Qualität der Zufallszahlen nicht ver-
nachlässigt werden.
Die Beispiele in unserem Lehrbuch dienen nur zur Demonstration und nicht zur
genauen quantitativen Analyse. Deshalb werden wir im folgenden nur die in den
Programmiersprachen vorhandenen Generatoren rand() bzw. Random[] benut-
zen.
5.1 Zufallszahlen 179

Übung
a) Programmieren Sie die beiden Zufallszahlengeneratoren

(I ) rn = (rn 2 rn 5 ) mod 10 ;
(II ) rn = (rn 2 rn 5 c) mod 10 ;
wobei c = 1 oder c = 0 gesetzt wird, falls (rn 2 rn 5 ) < 0 bzw. > 0 ist.
Beide Generatoren erzeugen ganze Zahlen 0; 1; : : : ; 9 und wiederholen die Zah-
lenfolge, wenn die letzten fünf Zahlen schon einmal vorgekommen sind. Beide
müssen daher nach maximal 105 Schritten die erzeugte Zahlenfolge wiederho-
len.
Starten Sie mit verschiedenen Sätzen von fünf Anfangsziffern und berechnen Sie
die tatsächliche Periodenlänge der erzeugten Zahlenfolgen.
Tip: Die Periodenlänge der Generatoren läßt sich z. B. dadurch berechnen, daß
man zwei Folgen parallel erzeugt. Bei der zweiten Folge erzeugt man jeweils
zwei Schritte und beobachtet dann, wann die zweite die erste Folge überholt.
b) Erzeugen Sie sich die Summe s von N gleichverteilten Zufallszahlen r aus dem
Einheitsintervall. Der Mittelwert der Summe ist dann m = 0:5N und die mitt-
lere quadratische Abweichung, die Varianz, ist
21 0Z1 123
Z
2 = N hr2 i hri2 = N 64 r2dr @ rdrA 75 = 12
N:
0 0
Wiederholen Sie das Experiment sehr oft und zeichnen Sie die Häufigkeit der
Summen in ein Histogramm. Vergleichen Sie das Ergebnis mit einer Gaußver-
teilung mit Mittelwert m und Varianz 2 ,
(s m)2
P (s) = p 1 exp 2 2 :
2
Überprüfen Sie die Übereinstimmung für N = 10; 100 und 1000.

D. E. Knuth, The Art of Computer Programming, Vols. I, II, and III, Addison Wesley,
1973.
G. Marsaglia, A. Zaman, Some portable very-long period random number genera-
tors, Computer in Physics 8, 117 (1994).
W.H. Press, S.A. Teukolsky, W.T. Vetterling, B.P. Flannery, Numerical Recipes in
C: The Art of Scientific Computing, Cambridge University Press, 1992.

5.2 Fraktale Aggregate

Im Abschnitt 3.3 haben wir Gebilde konstruiert, die mehr als eine Linie aber weni-
ger als eine Fläche sind. Sie werden durch eine gebrochene Dimension charakteri-
siert und haben den Namen Fraktale. Sie sind selbstähnlich, ein Teil sieht ähnlich
aus wie das ganze Gebilde, und sie können durch eine einfache deterministische
Regel erzeugt werden.
Gibt es solche Gebilde in der Natur? In der Tat lassen sich viele Strukturen
in unserer Umgebung mit Hilfe von fraktalen Dimensionen quantitativ charakteri-
sieren. Küstenlinien, Gebirgszüge, Flußläufe, Blutgefäße, Nervenzellen, Blattober-
flächen, Schwankungen von Börsenkursen und viele andere Phänomene lassen sich
durch ein Potenzgesetz der Art die Masse M wächst wie die Länge L zur Potenz
D“ beschreiben. Allerdings sind” natürliche Strukturen nicht so streng regelmäßig
wie die Sierpinski-Packung aus Abschnitt 3.3, sondern sie sind auch durch zufällige
Mechanismen entstanden.
Ein einfaches Beispiel für solche durch Zufall und Regel entstandenen Fraktale
sind Aggregate. Wenn Teilchen an einen Kern herandiffundieren und dort haften
bleiben, so entsteht eine lockere, körnige Struktur mit einer gebrochenen Dimensi-
on zwischen 2 und 3. Mit einem einfachen Computermodell, das 1981 von Witten
und Sander vorgeschlagen und untersucht wurde, wollen wir demonstrieren, wie
mit wenig Aufwand solche fraktalen Gebilde mit dem Computer erzeugt werden
können.

Physik
Wir beschreiben im folgenden ein Modell eines Wachstumsprozesses, bei dem die
ungerichtete Diffusion von Teilchen, bevor sie angelagert werden, die entscheiden-
de Rolle spielt. Das Abscheiden von Material aus einer Elektrolytlösung bei sehr
geringer Spannung zwischen den Elektroden kann als Beispiel hierfür dienen. Man
muß nur dafür sorgen, daß die Zufallsbewegung der diffundierenden Ionen wichti-
ger ist als ihre Drift aufgrund des elektrischen Feldes. Die Materialablagerung an
5.2 Fraktale Aggregate 181

der Elektrode führt dann nicht zu einem kompakten Gebilde, sondern es entsteht
ein filigranartig verästelter Cluster, den wir wieder durch eine fraktale Dimension
D beschreiben können. D ist etwa 5=6 mal so groß wie die Raumdimension.
Den Prozeß nennt man Diffusion Limited Aggregation (DLA). Obwohl DLA ein-
fach auf dem Computer simuliert und analysiert werden kann, gibt es unseres Wis-
sens bis heute keine analytische Theorie dazu. Dagegen existiert für das Diffusions-
problem bzw. die Zufallsbewegung eines Teilchens eine gut entwickelte mathema-
tische Theorie. Einige Aussagen und Ergebnisse, auf die wir im Algorithmus-Teil
zurückkommen, wollen wir hier kurz erläutern.
Wir betrachten einen random walk auf einem quadratischen, oder auch allgemei-
ner, auf einem d-dimensionalen kubischen Gitter. Die Gittervektoren bezeichnen
x
wir mit , und die Verbindungsvektoren zu den 2 d nächsten Nachbarn nennen wir
x
i ; i = 1; 2; : : : ; 2 d. Die Bewegung unseres Zufallswanderers ist nun dadurch
x
bestimmt, daß er in jedem Zeitschritt t, wenn er zur Zeit t am Gitterplatz ist,
x x
von den nächsten Nachbarplätzen + i einen zufällig auswählt und dort hin-
springt. Setzen wir jetzt viele Teilchen auf das Gitter, die unabhängig voneinander
x
alle nach demselben Zufallsrezept hüpfen, und bezeichnen mit u( ; t) den Bruchteil
x
derer, die zur Zeit t am Platz sind, so erhalten wir folgende Bilanzgleichung:

X
2d
u(x; t + t) u(x; t) = 21d (u(x + xi ; t) u(x; t)) : (5.8)
i=1
x
Den Term u( ; t) haben wir auf beiden Seiten subtrahiert, damit man leichter sieht,
daß dies gerade die diskrete Version der Diffusionsgleichung ist. Dividieren wir
nämlich (5.8) sowohl durch ein geeignetes kleines Volumen, so daß eine Dichte
entsteht, als auch durch t und lassen alle kleinen Größen, insbesondere alle i
p x
proportional zu t, gegen 0 gehen, so erhalten wir für die Wahrscheinlichkeits-
dichte die Gleichung
@u = r2 u
@t (5.9)

mit einer Diffusionskonstanten .

Wir wollen zwei charakteristische Lösungen dieser Diffusionsgleichung diskutie-
ren, und zwar zum einen die Lösung eines Anfangswertproblems, die uns Auskunft
gibt über Art und Geschwindigkeit, mit der sich im Mittel ein Zufallsweg ausbreitet,
und zum anderen eine stationäre Lösung, aus der wir eine Abschätzung der fraktalen
Dimension D des DLA-Clusters, an den sich die diffundierenden Teilchen anlagern,
gewinnen können.
x
Gleichung (5.9) mit der Anfangsbedingung u( ; t0 ) = ( x x 0 ) und der Rand-
bedingung u ! 0 für jxj ! 1 läßt sich durch Fouriertransformation lösen. Man
182 5 Monte-Carlo-Simulationen

erhält für t t0 :
jx x j2
u(x; t) = (4(t t0)) 0
d
2
exp 4(t t0 ) : (5.10)

Wir sehen hieran, daß die Wahrscheinlichkeit, das hüpfende Teilchen, das zur Zeit
x x
t0 bei 0 war, zu einer späteren Zeit t bei anzutreffen, nur vom Abstand r =
jx x j 0 , nicht aber von der Richtung abhängt. Das ist nicht weiter verwunder-
lich und drückt nur die räumliche Isotropie des Diffusionsprozesses aus, die wir
hineingesteckt haben, indem wir alle Raumrichtungen gleichbehandelt haben. Der
Mittelwert ( hx x i
0 ) ergibt sich zu
2

(hx x i0 ) = 2 d (t t0 )
2 (5.11)
p
und besagt, daß die mittlere Ausdehnung des Zufallsweges wie t t0 anwächst.
Dieses Gesetz ist bis auf den Vorfaktor unabhängig von der Dimension d des Raum-
es, in den die Zufallsbewegung eingebettet ist.
Das Modell von Witten und Sander beschreibt ein diffusionsbestimmtes Wachs-
tum, das nach folgender Vorschrift abläuft. Man beginnt mit einem minimalen Clu-
ster, in der Regel mit einem einzelnen Teilchen im Ursprung des Koordinatensy-
stems. Dann läßt man in großer Entfernung und unter einer zufälligen Richtung ein
weiteres Teilchen starten, das solange frei diffundiert, bis es an den Kern im Ur-
sprung anstößt und dort haften bleibt. Daraufhin startet weit draußen, wiederum un-
ter einer zufällig ausgewürfelten Richtung das nächste Teilchen, und dann immer so
weiter. Im Mittel über viele Realisierungen wird der zentrale Cluster radialsymme-
trisch wachsen. Für eine konkrete Realisierung bezeichnen wir die maximale radiale
Ausdehnung des Clusters mit Rmax (t) und bestimmen seine fraktale Dimension D
durch den Zusammenhang zwischen Rmax (t) und seiner Masse M (t), der Zahl der
bis zum Zeitpunkt t angelagerten Teilchen:

M / Rmax
D : (5.12)

x
Wenn wir dieses Modell durch eine Wahrscheinlichkeitsdichte u( ; t) der diffun-
dierenden Teilchen beschreiben wollen, so müssen wir als Randbedingung berück-
sichtigen, daß die Dichte am gerade entstandenen Cluster verschwindet. Ein weite-
res Teilchen wird mit einer Wahrscheinlichkeit, die proportional zum Teilchenstrom
ist, am Cluster angelagert. Näherungsweise können wir aber auch annehmen, daß
alle Teilchen, die einen gewissen Einfangradius Rc unterschreiten, durch Absorpti-
on weggefangen werden. Nach Witten und Sander ist aber Rc proportional zu Rmax ,
und wir machen für die nachfolgende Dimensionsbetrachtung keinen Fehler, wenn
wir Rc durch Rmax ersetzen. Außerdem können wir davon ausgehen, daß die Zeit,
die den Diffusionsprozeß charakterisiert, z. B. die Zeit, die ein diffundierendes Teil-
chen benötigt, um die Strecke zum Nachbarplatz zurückzulegen, sehr viel kleiner ist
5.2 Fraktale Aggregate 183

als die Zeit, die das Anwachsen des Clusters charakterisiert. Mit anderen Worten,
wir suchen eine radialsymmetrische, zeitunabhängige Lösung der Diffusionsglei-
chung (5.9) mit der Randbedingung u(Rmax ) = 0. Die Gleichung

u = rd1 1 @r @ rd 1 @ u = 0
@r (5.13)

können wir aber leicht integrieren. Wir erhalten für d > 2 die Lösung
R d 2 !
max
u(r) = u0 1 r ; (5.14)

und für d = 2 ist u proportional zu ln(r=Rmax ). Die radiale Komponente der

Stromdichte, jr = @u=@r , ist in jedem Fall proportional zu Rmax d 2 =r d 1 , woraus
wir nach Integration über die Oberfläche erhalten, daß der Gesamtteilchenstrom J ,
der vom Cluster absorbiert wird, proportional zu Rmax d 2 ist. J ist proportional zur
Massenzunahme, so daß sich die folgende Gleichung ergibt:
d 2 / J = dM = dM dRmax / RD 1 v :
Rmax dt dRmax dt max (5.15)

Die Geschwindigkeit v , mit der die Clustergröße zunimmt, ist also proportional zu
Rmax
d 1 D . Stecken wir jetzt noch die plausible Annahme hinein, daß v jedenfalls
nicht mit der Clustergröße anwachsen kann, so darf der Exponent d 1 D nicht
positiv sein, es muß also d 1 D gelten. Andererseits ist der DLA-Cluster in den
d-dimensionalen Raum eingebettet, so daß wir die Relation
d 1Dd (5.16)
erhalten, die durch numerische Simulationen für d = 2; 3; : : : ; 8 bestätigt wurde.

Algorithmus
Wir wollen einen DLA-Cluster auf einem 2-dimensionalen quadratischen Gitter er-
zeugen. Dazu besetzen wir den Platz in der Mitte des Gitters, setzen ein weiteres
Teilchen im Abstand Rs auf das Gitter und lassen es diffundieren, bis es entweder
am besetzten Platz hängenbleibt oder einen Abstand Rk > Rs dazu überschritten
hat. Dies wird iteriert. Der Algorithmus lautet also:
1. Starte mit einem leeren Quadratgitter und besetze den mittleren Gitterplatz mit
einem Teilchen.
2. Die aktuelle Größe des Aggregates sei durch den Radius Rmax gegeben. Setze ein
&
Teilchen auf einen zufällig gewählten Platz, der einen Abstand Rs Rmax vom
Ursprung hat, und lasse es zu einem zufällig gewählten Nachbarplatz hüpfen.
184 5 Monte-Carlo-Simulationen

3. Wenn das Teilchen einen Nachbarplatz des Aggregates erreicht, so wird es hin-
zugefügt und Rmax wird eventuell erhöht. Wenn das Teilchen den Abstand Rk
(Rk > Rs > Rmax) überschreitet, dann wird es vernichtet.
4. Iteriere 2 und 3 und berechne D = ln N= ln Rmax , wobei N die Anzahl der
Aggregatteilchen ist.

Die Skizze 5.3 zeigt noch einmal den kleinsten Kreis mit dem Radius Rmax um
das Aggregat, den Startkreis und den Vernichtungskreis. Allerdings verfälscht die
Einführung eines Vernichtungskreises die Eigenschaften des Aggregates, denn das
diffundierende Teilchen kann auch für R > Rk wieder zum Aggregat zurückkeh-
ren. Unser Algorithmus beschreibt also erst im Limes Rk !1 das eigentliche
Problem. Große Rk -Werte bedeuten aber große Rechenzeiten, und wir erwarten kei-
ne wesentlichen Abweichungen für endliche Rk -Werte. Man kann die Wahrschein-
lichkeit, daß das Teilchen an eine bestimmte Stelle des Startkreises zurückkehrt,
analytisch berechnen und damit das Teilchen in einem Schritt zurücksetzen. Da-
mit vermeidet man den Vernichtungskreis. Bei großen Aggregaten lohnt sich dieser
Aufwand, doch wir wollen hier darauf verzichten.

Vernichte
Starte

5.3 Das diffundierende Teilchen

Rmax startet am mittleren Kreis. Wenn
es den äußeren Kreis überschreitet,
wird es vernichtet, und ein neues
Teilchen wird auf den Startkreis ge-
setzt.

Der Algorithmus läßt sich darüber hinaus noch wesentlich beschleunigen, wenn
man um das Teilchen, das sich vom Cluster wegbewegt hat, einen möglichst großen
Kreis konstruiert, der gerade den Rand des Aggregates berührt. Da das diffundieren-
de Teilchen nach Gleichung (5.10) mit gleicher Wahrscheinlichkeit an jedem Punkt
dieses Kreises ankommt, kann man es zufällig auf den Kreis setzen, ohne die zeit-
aufwendige Diffusion zu simulieren. Dies wird solange wiederholt, bis das Teilchen
einen Nachbarplatz des Aggregates erreicht hat oder den Vernichtungskreis über-
schreitet. Der Algorithmus dazu lautet also:
5.2 Fraktale Aggregate 185

1. Starte mit einem leeren Quadratgitter und besetze den mittleren Gitterplatz mit
einem Aggregatteilchen.
2. Die aktuelle Größe des Aggregates ist Rmax . Setze ein Teilchen auf einen zufällig
&
gewählten Platz auf den Kreis mit dem Radius Rs Rmax und lasse es zu einem
zufällig gewählten Nachbarplatz hüpfen.
3. Wenn das Teilchen einen Nachbarplatz des Aggregates erreicht, so wird es hin-
zugefügt und Rmax wird eventuell erhöht. Wenn das Teilchen den Abstand Rd >
&
Rs Rmax überschreitet – seine Entfernung vom Ursprung sei R – , so wird es
auf einen zufällig gewählten Platz auf einem Kreis um das Teilchen mit dem Ra-
dius (R Rs ) gesetzt. Wenn das Teilchen den Abstand Rk > Rd > Rs Rmax &
überschreitet, so wird es vernichtet.
4. Iteriere 2. und 3. und berechne D = ln N= ln Rmax , wobei N die Anzahl der
Aggregatteilchen ist.
Die Skizze 5.4 soll diesen Algorithmus noch einmal verdeutlichen. Zur schnellen

Starte Vernichte

Rd
Rmax
5.4 Wie Bild 5.3, doch außerhalb
des Kreises mit dem Radius Rd legt
das Teilchen mit einem Sprung die
Strecke R Rs zurück.

Simulation des DLA-Clusters wählen wir die Programmiersprache C. Das Quadrat-

gitter wird durch das zweidimensionale Feld xf[rx][ry] beschrieben, das die
Werte 1 und 0 annehmen kann. xf[rx][ry]=1 bedeutet, daß am Ort mit den
Koordinaten rx und ry ein Aggregatteilchen sitzt, während die Plätze mit xf=0
zur Diffusion zur Verfügung stehen. Bei sehr großen Aggregaten wäre es sicherlich
sinnvoll, nicht das ganze Gitter, sondern nur die Aggregat- und Randplätze zu spei-
chern, um aber die dazu erforderliche Buchhaltung zu vermeiden, wählen wir den
einfachen Weg.
Der Startplatz auf dem Kreis mit Radius Rs wird mit der Funktion besetze()
gewählt:
186 5 Monte-Carlo-Simulationen

void besetze()
{
double phi;
phi=(double)rand()/RAND_MAX*2.*pi;
rx=rs*sin(phi);
ry=rs*cos(phi);
}
Das Hüpfen auf einen der vier Nachbarplätze wird mit einer zufällig gewählten Zahl
0; 1; 2 oder 3 gesteuert:
void huepfe()
{
int r;
r=random(4);
switch(r)
{
case 0: rx+=1;break;
case 1: rx+=–1;break;
case 2: ry+=1;break;
case 3: ry+=–1;break;
}
}
Nach jedem Sprung muß geprüft werden, ob das Teilchen vernichtet wird (R >
Rk ), ob es einen Randplatz des Aggregates erreicht hat, ob ein Hüpfsprung (R <

Rd) oder ein Kreissprung (R Rd ) gemacht wird. Diese vier ”wenn“ im Schritt
Nr. 3 des obigen Algorithmus werden durch die Funktion pruefe() abgefragt:
char pruefe()
{
double r,x,y;
x=rx;
y=ry;
r=sqrt(x*x+y*y);
if (r > rkill) return ’v’;
if (r >= rd) return ’k’;
if (xf[rx + 1 + lmax/2][ry + lmax/2] +
xf[rx – 1 + lmax/2][ry + lmax/2] +
xf[rx + lmax/2][ry + 1 + lmax/2] +
xf[rx + lmax/2][ry – 1 + lmax/2] > 0)
return ’a’;
else
5.2 Fraktale Aggregate 187

return ’h’;
}
lmax ist die Größe des Zeichenfensters. Die folgende Funktion fügt das Teilchen
zum Aggregat hinzu:
void aggregate()
{
double x,y;
xf[rx+lmax/2][ry+lmax/2]=1;
x=rx;y=ry;
rmax= max(rmax,sqrt(x*x+y*y));
if(rmax>lmax/2.–5.) {printf("\7");stop=1;}
circle(4*rx+340,4*ry+240,2);
}
und beim Kreissprung wird ein Zufallsvektor mit dem Betrag R Rs zum Ort des
Teilchens addiert,
void kreissprung()
{
double r,x,y,phi;
phi=(double)rand()/RAND_MAX*2.*pi;
x=rx; y=ry; r=sqrt(x*x+y*y);
rx+=(r–rs)*sin(phi);
ry+=(r–rs)*cos(phi);
}
Die Koordinaten rx und ry des Teilchens und das Aggregatfeld xf[rx][ry]
werden vor dem Hauptteil main() global deklariert, so daß alle Funktionen auf sie
zugreifen können. Mit den obigen fünf Funktionen lautet dann der wesentliche Teil
des Hauptprogrammes
while(stop==0)
{
if(kbhit()) stop=1;
switch(pruefe())
{
case ’v’:besetze();huepfe();break;
case ’a’:aggregate();besetze();huepfe();break;
case ’h’:huepfe();break;
case ’k’:kreissprung();break;
}
}
188 5 Monte-Carlo-Simulationen

Ergebnis
In Bild 5.5 ist das Ergebnis der Simulation zu sehen. Auf der Workstation haben sich
innerhalb einer Minute 1540 Teilchen zu einem fraktalen Aggregat angelagert. Mit
der maximalen Ausdehnung von 63 Gitterabständen erhält man die Abschätzung
'
D = ln 1540= ln 63 1:77 für die fraktale Dimension.

5.5 DLA-Cluster auf dem Qua-

dratgitter.

Die Simulationen zeigen außerdem, daß durch die Einführung der großen Sprünge
für R > Rd die Rechenzeit sich nicht wesentlich erhöht, wenn man den Radius des
Vernichtungskreises vergrößert.

Übung
Verbesserte Dimensionsanalyse
Bei der Bestimmung der fraktalen Dimension haben wir bisher vernachlässigt, daß
der momentan erzeugte Cluster noch nicht fertig ist. Während sich die Arme“ des
”
Clusters weiter ausbilden, können immer noch weitere Teilchen in seine inneren Be-
reiche gelangen. Durch unser willkürliches Abbrechen beim Erreichen eines gewis-
sen maximalen Radius vernachlässigen wir diese Teilchen. Der tatsächliche Cluster
sollte etwas dichter, die fraktale Dimension etwas höher sein.
Berechnen Sie die Masse des Clusters unter Vernachlässigung aller Teilchen, die
einen Abstand größer als r haben. Tragen Sie in einem log-log-Diagramm die Mas-
se über r auf und versuchen Sie, das Verhalten zu interpretieren.
5.3 Perkolation 189

Variation der Modell-Parameter

Es ist interessant zu beobachten, inwieweit sich Form und fraktale Dimension des
Clusters verändern, wenn man das ursprüngliche DLA-Modell leicht variiert.
Führen Sie in das Programm dla.c einen zusätzlichen Parameter whaft ein, der
die Wahrscheinlichkeit darstellt, daß ein Teilchen, das auf einem dem Cluster be-
nachbarten Platz ankommt, auch tatsächlich haften bleibt.
Für den Fall, daß das Teilchen nicht befestigt wird, soll es weiter diffundieren bis
es erneut den Cluster trifft, wo es wieder mit der Wahrscheinlichkeit whaft haften
bleibt. Beim Weiterdiffundieren ist natürlich darauf zu achten, daß dem Teilchen
verboten wird, auf einen bereits besetzten Platz zu hüpfen.

Literatur
H. Gould, J. Tobochnik, An Introduction to Computer Simulation Methods:
Applications to Physical Systems, Parts I and II, Addison Wesley, 1988.
E. Sander, L. M. Sander, R. M. Ziff, Fractals and fractal correlations, Computers
in Physics 8, 420 (1994).

5.3 Perkolation
In einem idealen Kristall sind alle Atome regelmäßig auf einem Gitter angeordnet.
Für diesen Fall können wir die Fouriertransformation benutzen, um die periodischen
Strukturen und auch die Kristallanregungen, z. B. die Phononen, zu beschreiben.
Weil aber unsere Natur nur selten aus idealen Kristallen besteht, bemühen sich die
Festkörperphysiker seit Jahrzehnten, auch Materialien mit unregelmäßigen Struktu-
ren zu verstehen.
Es gibt eine einfache Beschreibung eines ungeordneten Materials, das Perko-
lationsmodell. Das englische Wort to percolate bedeutet durchsickern. Das Mo-
dell soll ein poröses Material beschreiben, durch das gewisse Teilchen hindurch-
diffundieren können, falls es durchgehende Wege durch die Poren gibt. Die Geo-
metrie der zufällig entstanden Poren wird durch die Perkolationstheorie beschrie-
ben. Das Modell kann jedem Schüler erklärt werden, es kann auf einem Computer
leicht programmiert werden, und dennoch enthält es interessante Physik, die mit
Phasenübergängen, kritischen Phänomenen, Universalität und selbstähnlichen Frak-
talen zusammenhängt.
In diesem Abschnitt wollen wir das Perkolationsmodell vorstellen und simulie-
ren.
190 5 Monte-Carlo-Simulationen

Physik
Nehmen wir an, wir haben eine Legierung, die aus zwei Atomsorten besteht, die
wir A- und B -Atome nennen wollen. Die Konzentration der A-Atome sei p, und
beide Teilchensorten sollen zufällig verteilt sein und zusammen ein regelmäßiges
Kristallgitter bilden. Wir wollen weiterhin annehmen, daß die A-Atome magnetisch
sind mit einer kurzreichweitigen magnetischen Wechselwirkung, die nur bei unmit-
telbarer Nachbarschaft zweier A-Atome zum Tragen kommt. Wenn es keine Kopp-
lung zu den unmagnetischen B -Atomen gibt, so kann der Kristall nur dann eine
magnetische Ordnung bilden, wenn ein unendlich großes Netz von zusammenhän-
genden A-Atomen existiert. Phasenübergänge gibt es zwar streng genommen nur in
unendlich großen Systemen mit hinreichend großer Vernetzung, in unseren Compu-
tersimulationen werden wir aber auch für endlich große Systeme bei einer kritischen
Konzentration der A-Atome deutliche Anzeichen eines Phasenübergangs erkennen
können. Die Größe der Strukturen von A-Atomen, die alle untereinander verbunden
sind, spielt dabei eine wichtige Rolle. Eine solche Menge von A-Atomen, die durch
ihre Kopplungen zusammenhängen, wird Cluster genannt.
Bei kleinen Konzentrationen p gibt es nur eine Menge kleiner Cluster ohne ma-
gnetische Ordnung. Mit wachsendem p wird die mittlere Größe der zusammenhän-
genden A-Atome ebenfalls wachsen, bis sich ab einem Schwellenwert pc ein Clu-
ster durch den ganzen Kristall ausdehnt. pc nennt man Perkolationsschwelle oder
kritische Konzentration. Für p > pc koexistiert der unendliche mit vielen kleinen
Clustern, erst bei p = 1 sind alle Plätze mit A-Atomen besetzt, und es gibt nur einen
(unendlichen) Cluster.
Für den unendlich großen Kristall gibt es nur einen wohldefinierten Wert für die
Perkolationsschwelle pc . Beispielsweise findet man auf dem quadratischen Gitter

mit vier nächsten Nachbarn den numerischen Wert pc = 0:59275 0:00003, auf
dem Dreiecksgitter mit sechs Nachbarplätzen ist pc = 1=2 exakt bekannt. pc hängt
zwar vom Gittertyp und der Reichweite der Kopplungen ab, nicht aber von der spe-
ziellen Realisierung der Probe, wenn man die Größe des Kristalls gegen Unendlich
gehen läßt. Im endlichen Kristall dagegen gibt es, abhängig von p, natürlich nur eine
gewisse Wahrscheinlichkeit dafür, daß ein Cluster existiert, der zwei gegenüberlie-
gende Seiten verbindet.
Man kann nun viele Fragen zu den Eigenschaften der Cluster stellen und da-
zu mathematische Gesetzmäßigkeiten erarbeiten. Wie groß ist pc für verschiedene
Gitterstrukturen und Clusterdefinitionen? Wie wächst die mittlere Ausdehnung der
endlichen Cluster, wenn man die Konzentration p bis zur Schwelle pc erhöht? Wie
wächst die Dichte des unendlichen Clusters oberhalb pc ? Wie sieht die Verteilung
der Clustergrößen aus? Hat der unendliche Cluster bei pc eine Struktur?
Besonders interessant sind die Gesetzmäßigkeiten in der Nähe der Perkolations-
schwelle pc . Wir definieren z.B. eine mittlere Ausdehung R(s) eines Clusters mit s
5.3 Perkolation 191

Teilchen durch
X
R2(s) = s(s 1 1) (r i r j )2 ; (5.17)
i6=j
wobei i und j die Teilchen des Clusters durchnumerieren und r i die Position des
i-ten Atoms auf dem Gitter ist. Die mittlere Ausdehnung der endlichen Cluster ist
dann definiert durch p
= hR2(s)is<1 (5.18)
h i
dabei bezeichnet ::: s<1 den Mittelwert über alle endlichen Cluster .
divergiert an der Perkolationsschwelle, und dicht bei pc gilt:
jp pcj : (5.19)

Dieses Gesetz erhält man für sämtliche Perkolationsmodelle. Überraschenderweise

ist der Exponent universell. Das heißt, er hat einen Wert, der nur von der Raumdi-
mension abhängt. In der Ebene ist für verschiedene Gittertypen und Reichweiten der
Kopplungen, auch für das entsprechende Problem ohne Gitter, und in realen zweidi-
mensionalen Legierungen der Wert = 4=3 exakt bekannt. Für drei Dimensionen
'
erhält man numerisch 0:88.
Die Wahrscheinlichkeit P (p), daß ein beliebig herausgegriffenes A-Atom zum
unendlichen Cluster gehört, ist null für p < pc und wächst stetig von P (pc ) = 0
bis P (1) = 1 an. Dicht bei pc wird der Anstieg wieder durch ein Potenzgesetz mit
einem universellen Exponenten beschrieben:

P (p) (p pc ) ; (p & pc ) : (5.20)

In zwei Dimensionen gilt = 5=36 ' 0:14 ; P (p) wächst also bei pc sehr steil an.
Direkt an der Perkolationsschwelle verschwindet zwar die Dichte des unendli-
chen Clusters, P (pc ) pc = 0, trotzdem existiert er, und er hat eine interessante
Struktur: Er ist ein Fraktal. Wenn wir einen quadratischen Ausschnitt des Gitters
mit der Kantenlänge L betrachten, und wenn M (L) die Anzahl der Teilchen des
unendlichen Clusters in diesem Ausschnitt ist, dann gilt bei pc :

hM (L)i / LD ; (5.21)

h i
wobei ::: den Mittelwert über verschiedene Ausschnitte bezeichnet. Die Masse
des Clusters wächst also mit einer Potenz der Länge, und nach Abschnitt 3.3 ist
'
D seine fraktale Dimension. In der Ebene gilt D = 91=48 1:89. Der kritische
Perkolationscluster ist also wesentlich kompakter als das durch Diffusion erzeugte
Aggregat aus dem vorherigen Abschnitt.
Bisher haben wir drei universelle kritische Exponenten ; und D kennenge-
lernt, aber noch viele andere Eigenschaften werden bei pc durch Potenzgesetze
192 5 Monte-Carlo-Simulationen

mit weiteren Exponenten beschrieben. Solche Singularitäten sind aber nicht un-
abhängig voneinander, sondern hängen durch Skalengesetze miteinander zusam-
men. Wir wollen hier nur die Idee skizzieren und für das tiefere Verständnis auf
die Lehrbücher zu den kritischen Phasenübergängen und der Renormierungsgrup-
pentheorie verweisen.
Sei M (p; L) die mittlere Anzahl der Teilchen eines Clusters, der ein Quadrat der
Länge L durchquert. Für jeden Wert von L erhält man die Anzahl M als Funktion
von p ; dies ergibt eine ganze Kurvenschar. Die Skalentheorie besagt nun, daß diese
Kurvenschar in der Nähe des kritischen Punktes nach geeigneter Skalierung durch
eine einzige universelle Funktion f beschrieben wird. Die Skalen für die Größen M
und L können durch Potenzen von entweder p pc oder mit Gleichung (5.19) von
ausgedrückt werden. L wird dabei in Einheiten von und M in Einheiten einer
Potenz von , z. B. x , gemessen. Das bedeutet:
L
M (p; L) x f ; (5.22)

wobei f eine zunächst unbekannte Funktion und x ein kritischer Exponent ist. Setzt
man L = k mit einer Konstanten k , so folgt aus Gleichung (5.21) x = D . L
wird also in Einheiten von und M in Einheiten von D gemessen, daher der Name
Skalentheorie.
Aus L = k folgt auch:
M (p; L) D d f (k) ;
Ld (5.23)

wobei Ld die Anzahl der Gitterpunkte im d-dimensionalen Würfel mit der Kan-
tenlänge L ist. M=Ld ist aber die Wahrscheinlichkeit, daß ein Gitterplatz zum per-
kolierenden Cluster gehört. Für große L-Werte gilt daher:
M (p; L) ' p P (p) (p p ) :
c
Ld (5.24)

Aus den Gleichungen (5.19), (5.23) und (5.24) folgt

(p pc) (p pc) (D d) : (5.25)

Daraus kann man schließen:

= (d D) : (5.26)

Die drei kritischen Exponenten sind damit durch ein Skalengesetz miteinander ver-
koppelt. Tatsächlich genügt die Kenntnis zweier Exponenten, um alle anderen zu
berechnen.
5.3 Perkolation 193

Zunächst sind die kritischen Exponenten nur für das unendlich große Gitter defi-
niert. Mit dem Computer können wir aber nur endliche Gitter mit Teilchen besetzen.
Im endlichen System gibt es jedoch keinen Phasenübergang, keine scharf definierte
Perkolationsschwelle und keine Divergenzen. Wie kann man von den Eigenschaf-
ten eines endlichen Systems auf die kritischen universellen Gesetze des unendlichen
Gitters schließen?
Die Theorie des finite size scaling beantwortet diese Frage. Sie basiert auf den
oben skizzierten Skalengesetzen, die auch etwas über die Abhängigkeit der Singula-
ritäten von der Gittergröße L aussagen. Benutzt man das durch Gleichung (5.19) be-
schriebene Verhalten der Korrelationslänge in der Skalenbeziehung (5.22), so erhält
man mit f (x) = f~(x1= ) :

M (p; L) jp pc j D f~ (p pc)L1= :
(5.27)

Die Konzentration p und die Systemlänge L sind also in der Nähe des kritischen
Punktes p = pc ; L = 1 miteinander verknüpft.
Die fraktale Dimension D erhält man schon aus Gleichung (5.21). Denn für
L sieht das endliche System wie das unendlich große aus. Deshalb folgt aus
Gleichung (5.21) M (pc ; L) LD . Aus dem Anstieg der Zahl M (pc ; L) der Teil-
chen im perkolierenden Cluster mit der Gittergröße L kann man also die fraktale
Dimension D numerisch berechnen. Wie aber bestimmt man pc und den Exponen-
ten ?
Dazu stellen wir ein Skalengesetz analog zu Gleichung (5.27) für die Wahrschein-
lichkeit (p; L) auf, daß es in einer Probe der Größe L einen Cluster gibt, der zwei
gegenüberliegende Seiten verbindet, der also perkoliert. Offenbar gilt
0 p < pc ;
(p; 1) = 1
für
für p > pc : (5.28)

Für endliche L-Werte wird diese Stufenfunktion in der Nähe von pc abgerundet. Da
im unendlichen System für p > pc eine Konstante ist, hat der entsprechende Ska-
lenexponent den Wert Null. Die Skalengleichung für (p; L), analog zu Gleichung
(5.27) für M (p; L), lautet also mit einer unbekannten Funktion g :

(p; L) = g (p pc) L1= :

(5.29)

Wenn wir nun die Plätze eines Gitters mit der Wahrscheinlichkeit p mit Atomen
besetzen und dann p erhöhen, so wachsen alle Cluster. Bei einem Schwellenwert
pc(L) wird ein perkolierender Cluster auftreten.
Die Wahrscheinlichkeit, daß pc (L) im Intervall [p; p + dp] liegt, ist durch die
Ableitung (d=dp) dp an der Stelle pc (L) gegeben. d=dp zeigt ein Maximum,
das für L ! 1 divergiert und zur Perkolationsschwelle pc des unendlichen Gitters
läuft. Wegen der großen statistischen Fluktuationen läßt sich das Maximum von
194 5 Monte-Carlo-Simulationen

d=dp nur schlecht numerisch bestimmen. Es ist besser, den Mittelwert und die
Fluktuationen von pc (L) zu berechnen. Der Mittelwert der Perkolationsschwelle ist
gegeben durch Z d
hpc(L)i = p dp dp : (5.30)

Aus Gleichung (5.29) erhält man dafür das Skalengesetz

Z
hpc(L)i = pL1= g0 (p pc)L1= dp : (5.31)

Mit der Substitution z = (p pc)L1= und mit

R d dp = (1; L) (0; L) = 1
dp
folgt daraus:
hpc(L)i pc L 1= : (5.32)
Wenn wir nun für viele Simulationen eines Systems der Länge L den Wert pc (L) be-
stimmen und dies für viele möglichst große L-Werte wiederholen, so kann man den
h i
Mittelwert pc (L) durch das Gesetz (5.32) fitten und dadurch pc und bestimmen.
Man kann auch gleichzeitig den Mittelwert des Quadrates von pc (L) berechnen und
erhält damit ein Maß für die Breite von d=dp. Führen wir nämlich für

2 = h(pc (L) hpc (L)i)2 i = hpc (L)2 i hpc (L)i2

(5.33)
= h(pc (L) pc )2 i hpc (L) pc i2
die zu (5.30) und (5.31) analoge Rechnung durch, so erhalten wir

L 1= : (5.34)

Aus der Standardabweichung von pc (L) läßt sich somit der Parameter direkt ge-
winnen.
Mit Hilfe der Skalengesetze gelingt es uns also, die kritischen Werte des unend-
lichen Gitters aus den Eigenschaften endlicher Systeme zu berechnen. Dieses finite
size scaling ist nicht nur auf das Perkolationsproblem beschränkt, sondern es gilt
auch für andere Arten von Phasenübergängen, z. B. für den magnetischen Übergang
des Ising-Ferromagneten, den wir in Abschnitt 5.5 behandeln werden. Wir haben da-
mit ein wichtiges Werkzeug kennengelernt, um universelle, also modellunabhängige
Größen zu berechnen.
Schließlich sollten wir erwähnen, daß es neben der hier besprochenen site per-
colation auch die sogenannte bond percolation gibt. Dabei werden nicht die Plätze
des Gitters, die sites, sondern die Verbindungslinien benachbarter Plätze, die bonds,
mit der Wahrscheinlichkeit p besetzt. Solche Systeme haben zwar eine andere Per-
kolationsschwelle, jedoch dieselben universellen kritischen Eigenschaften wie das
besprochene Modell.
5.3 Perkolation 195

Algorithmus
Auf einem Gitter läßt sich die Perkolationsstruktur numerisch leicht erzeugen. Wir
wählen ein Quadratgitter mit Gitterplätzen (i; j ); i = 0; : : : ; L 1 und j =
2
0; : : : ; L 1, und benutzen gleichverteilte Zufallszahlen r [0; 1]. Der Algo-
rithmus lautet damit:
1. Durchlaufe alle (i; j ).
2. Ziehe eine Zufallszahl r .
3. Falls r < p, zeichne einen Punkt am Platz (i; j ).
Das C-Programm dazu lautet:
double p = 0.59275;
int i, j, L = 500, pr;
pr = p*RAND_MAX;
for (i = 0; i < L; i++)
for (j = 0; j < L; j++)
if (rand() < pr) putpixel(i,j,WHITE);
Bild 5.6 zeigt das Ergebnis. Man sieht eine scheinbar regellose Struktur. Es ist des-
halb überraschend, daß man daraus durch geeignete Fragen und deren quantitative
Beantwortung so vielfältige mathematische Gesetzmäßigkeiten herausholen kann.
Allerdings ist die Auswertung der Perkolationsstruktur nicht mehr so einfach zu
programmieren wie deren Erzeugung. Die Frage z. B., ob die Struktur in Bild 5.6
perkoliert, ob es also einen Weg über besetzte Nachbarplätze gibt, der zwei ge-
genüberliegende Seiten verbindet, läßt sich nicht leicht beantworten. Auch unser
Auge ist mit dieser Frage überfordert.
Wir brauchen einen Algorithmus, der Cluster von zusammenhängenden Teilchen
identifizieren kann. Eine naive Methode wäre, von jedem besetzten Platz aus wach-
sende Kreise zu ziehen und alle verbundenen Plätze zu markieren. Dies kostet aber
sehr viel Rechenzeit. Ein schneller Algorithmus wurde 1976 von Hoshen und Ko-
pelman entwickelt. Dabei wird das Gitter nur einmal durchlaufen, und es werden
Clusternummern an alle besetzten Plätze vergeben. Jeder Platz, der nicht mit vorher
besuchten verbunden ist, erhält eine neue Nummer. Allerdings werden dabei manch-
mal auch Teile desselben Clusters mit unterschiedlichen Nummern belegt. Durch
einen Buchhaltungstrick können solche Kollisionen am Ende leicht aufgelöst wer-
den. Die Details dieses Algorithmus sind in den Lehrbüchern von Stauffer/Aharony
und Gould/Tobochnik gut beschrieben.
Hier wollen wir einen anderen Weg verfolgen, der von Leath ebenfalls im Jahr
1976 vorgeschlagen wurde. Cluster sollen direkt durch einen Wachstumsprozeß er-
zeugt werden. Dazu besetzen wir zunächst nur das Zentrum eines leeren Gitters
196 5 Monte-Carlo-Simulationen

und definieren alle Nachbarplätze als besetzt oder unbesetzt mit der Wahrschein-
lichkeit p bzw. 1 p. Dieser Prozeß wird iteriert, wobei jeweils alle undefinierten
Randplätze in besetzte oder unbesetzte umgewandelt werden. Wenn es keine unde-
finierten Randplätze des Clusters mehr gibt, dann wurde ein Perkolationscluster er-
zeugt. Viele Wiederholungen geben eine Verteilung von Clustern, die man mit den
Methoden des finite size scaling auswerten kann. Da jedes erzeugte Teilchen das
statistische Gewicht p und jeder Leerplatz das Gewicht (1 p) erhält, und da der
gesamte Cluster mit dem Produkt aller dieser Faktoren gewichtet wird, erzeugt der
Wachstumsprozeß die Cluster mit derselben Wahrscheinlichkeit wie der vorherige
Algorithmus.
Der Wachstumsalgorithmus für einen Cluster lautet damit:
1. Markiere alle Plätze eines Quadratgitters mit der Seitenlänge L als undefiniert
und besetze das Zentrum. Der Cluster besteht am Anfang also nur aus einem
Teilchen.
2. Wähle einen undefinierten Randplatz des Clusters aus.
3. Ziehe eine gleichverteilte Zufallszahl r 2[0; 1] und besetze diesen Platz, falls
r < p. Sonst markiere diesen Platz als unbesetzt.
4. Iteriere 2 und 3, bis es keine undefinierten Randplätze des Clusters mehr gibt.
Damit der Wachstumsprozeß am Rand des Gitters in definierter Weise beendet wird,
markieren wir die Gitterrandplätze mit unbesetzt“ . Zu Punkt 2 werden wir eine
”
Liste erzeugen, aus der wir die Positionen der noch undefinierten Randplätze des
Clusters entnehmen können. Natürlich muß diese Liste während des Wachtumspro-
zesses ständig aktualisiert werden.
Da wir wieder möglichst große Gitter simulieren und auf dem Bildschirm den
wachsenden Cluster direkt beobachten wollen, haben wir den Algorithmus in der
Sprache C geschrieben. Zunächst vereinbaren wir, daß die Markierung der drei ver-
schiedenen Fälle mit den Zahlen 0, 1 und 2 erfolgen soll:
#define UNDEFINIERT 0
#define BESETZT 1
#define UNBESETZT 2
Für das Gitter, das nur diese drei Werte anzunehmen braucht, benutzen wir einen
Datentyp, der wenig Speicherplatz benötigt, nämlich char feld[L][L], und
definieren außerdem mit
struct { int x; int y ;} liste[PD];
eine Liste, die die Positionen (i,j) der undefinierten Clusterrandplätze aufneh-
men soll. Diese Liste, die anfangs nur die vier Nachbarplätze des Zentrums enthält,
5.3 Perkolation 197

wird sukzessive abgearbeitet und erhält dabei neue Einträge. Weil die bearbeite-
ten Plätze nicht mehr benötigt werden, kann diese Liste periodisch beschrieben und
durchlaufen werden. Ihre Länge PD braucht deshalb nicht gleich L2 zu sein, sondern
es reicht aus, wenn wir PD = 4 L wählen. Die Initialisierung sieht folgendermaßen
aus:
for(i=0;i<L;i++)
feld[0][i]=feld[i][0]=feld[i][L–1]=
feld[L–1][i]=UNBESETZT;
for(i=1;i<L–1;i++)
for(j=1;j<L–1;j++)
feld[i][j]=UNDEFINIERT;
feld[L/2][L/2]=BESETZT;
liste[0].x=L/2+1; liste[0].y=L/2;
liste[1].x=L/2 ; liste[1].y=L/2+1;
liste[2].x=L/2–1; liste[2].y=L/2;
liste[3].x=L/2 ; liste[3].y=L/2–1;
count=3;
putpixel(L/2, L/2, WHITE);
Dabei ist count eine reine Zählvariable, deren Wert jeweils um 1 erhöht wird,
wenn ein neuer undefinierter Randplatz des Clusters entsteht. Die Hauptschleife,
Punkt 4, lautet:
while(! done )
{
event();
for(k=0; k<=count; k++)
{
i=liste[k%PD].x; j=liste[k%PD].y;
definiere(i,j);
} /* for */
} /* while */
Das Programm durchläuft und bearbeitet also die Liste der noch undefinierten Rand-
plätze des Clusters. Die Funktion definiere(i,j) prüft zuerst, ob der Platz
(i,j) schon definiert ist. Das ist nötig, weil derselbe Randplatz eventuell mehr-
fach in der Liste auftaucht. Wenn der Platz noch undefiniert ist, wird Schritt 3 durch-
geführt und der Platz (i,j) besetzt, falls die Zufallszahl r kleiner als die Konzen-
tration p ist. Wenn dieser jetzt besetzte Platz noch undefinierte Nachbarn hat, wer-
den deren Positionen in die obige Liste aufgenommen und der Wert der Variablen
count wird entsprechend erhöht.
Das sieht im Programm folgendermaßen aus:
198 5 Monte-Carlo-Simulationen

void definiere(int i, int j)

{
double r;
if( feld [i][j] != UNDEFINIERT ) return;
r = rand() / (double) RAND_MAX;
if( r < p )
{
feld[i][j] = BESETZT;
putpixel (i, j, WHITE);
if( feld[i][j+1]==UNDEFINIERT )
{count++;liste[count%PD].x=i;liste[count%PD].y=j+1;}
if( feld[i][j–1]==UNDEFINIERT )
{count++;liste[count%PD].x=i;liste[count%PD].y=j–1;}
if( feld[i+1][j]==UNDEFINIERT )
{count++;liste[count%PD].x=i+1;liste[count%PD].y=j;}
if( feld[i–1][j]==UNDEFINIERT )
{count++;liste[count%PD].x=i–1;liste[count%PD].y=j;}
}
else feld[i][j] = UNBESETZT;
}
Das Programm ist noch durch die Deklarationen, die graphischen Initialisierungen
und die Tastaturabfrage event() zu ergänzen.

Ergebnis
Zunächst wenden wir den ersten Algorithmus zur Erzeugung der gesamten Perko-

lationsstruktur an und besetzen ein Quadratgitter mit 500 500 Plätzen mit der
Konzentration p = 0:59275. Die besetzten Plätze (A-Atome) sind schwarz mar-
kiert, das Gitter und die unbesetzten Plätze werden nicht gezeigt. Bild 5.6 zeigt das
Ergebnis. Man sieht nur ein Rauschen, das noch nichts von den mathematischen
Gesetzen ahnen läßt, die man nach quantitativer Auswertung dieses Bildes erhalten
kann. Wir haben die Konzentration p gerade an der Perkolationsschwelle gewählt,
doch ein perkolierender Cluster und kritische Eigenschaften sind nicht zu erken-
nen. Nur ein geeignetes Computerprogramm kann aus dieser Struktur die Cluster
bestimmen und quantitativ auswerten.
Bild 5.7 zeigt einen Cluster, der durch den Wachstumsalgorithmus erzeugt wurde.
Die Konzentration p und die Gittergröße stimmen mit denen von Bild 5.6 überein.
Jetzt sieht man einen perkolierenden Cluster, der Strukturen auf allen Längenskalen
von der Gitterkonstanten bis zur Gesamtgröße des Gitters zeigt. Er ist ein fraktales
selbstähnliches Gebilde. Natürlich erzeugt das Programm nicht nur perkolierende
5.3 Perkolation 199

5.6 Perkolationsstruktur auf einem

Quadratgitter an der Perkolations-
schwelle.

5.7 Perkolierender Cluster an der

Perkolationsschwelle.

Cluster, sondern sehr oft stoppt der Wachstumsprozeß, bevor der Cluster den Rand
erreicht hat. Für p < pc tritt dieser Fall sehr häufig auf, während für p > pc fast nur
noch perkolierende Cluster erzeugt werden.
200 5 Monte-Carlo-Simulationen

Übung
Es sei s die Anzahl der Teilchen in einem Perkolationscluster. Die mittlere Clu-
hi
stermasse s der endlichen Cluster divergiert im unendlich großen System an der
Perkolationsschwelle mit dem Potenzgesetz

hsi jp pcj :
Berechnen Sie den Mittelwert hsi für alle numerisch erzeugten Cluster, die nicht den
Rand berühren. Tragen Sie diese Werte als Funktion der Konzentration p auf, und
versuchen Sie, damit die kritische Konzentration pc zu bestimmen. Berechnen Sie
das Maximum dieser Funktion für verschiedene Werte der Gitterlänge L. Versuchen
Sie, mit Hilfe von finite size scaling den kritischen Exponenten zu berechnen. Sie
dürfen dabei den oben angegebenen Wert von benutzen.

Literatur
H. Gould, J. Tobochnik, An Introduction to Computer Simulation Methods: Appli-
cations to Physical Systems, Part II, Addison Wesley, 1988.
J. Schnakenberg, Algorithmen in der Quantentheorie und Statistischen Physik, Zim-
mermann-Neufang, 1995.
D. Stauffer, A. Aharony, Perkolationstheorie: Eine Einführung, VCH Verlagsgesell-
schaft, 1995.

5.4 Polymer-Ketten
Polymere spielen eine große Rolle sowohl in der Chemie als auch in der Biologie
und der Medizin. Aber auch die Physik interessiert sich seit langem für allgemei-
ne mathematische Gesetzmäßigkeiten der Eigenschaften von Polymeren. Schon ein
einziges Molekül, das aus einer langen Kette von identischen Einheiten (Monome-
ren) aufgebaut ist, hat interessante Eigenschaften. Um solche Ketten von vielen tau-
send Monomeren mathematisch beschreiben zu können, muß man versuchen, die
wesentlichen Mechanismen und Strukturen möglichst einfach zu modellieren. Ein
bewährtes Modell dazu ist der zufällig erzeugte Weg, der in der Fachliteratur mit
random walk bezeichnet wird. Der Weg besteht aus vielen kleinen Strecken, die in
zufälligen Richtungen aneinandergereiht sind.
Im Abschnitt 3.3 haben wir schon festgestellt, daß ein Zufallsweg als Modell
für ein Polymermolekül angesehen werden kann, bei dem in einem Wärmebad al-
le Konfigurationen gleich wahrscheinlich sind. Die Masse der Kette wächst dabei
mit dem Quadrat ihrer mittleren Ausdehnung. Die mathematische Theorie dazu ist
5.4 Polymer-Ketten 201

sehr gut entwickelt. Allerdings wird bei diesem Modell ein wichtiger Mechanismus
vernachlässigt: Die Kette darf sich nicht selbst durchdringen. Zufallswege mit einer
solchen Einschränkung, die deshalb auch SAW’s (self-avoiding walks) heißen, kann
man nur näherungsweise analytisch berechnen. Sie lassen sich aber relativ leicht auf
einem Computer simulieren.

Physik
Am einfachsten kann ein Zufallsweg auf einem Gitter definiert werden. Da wir uns
nur für die globalen Eigenschaften sehr langer Polymere interessieren, insbesondere
für die fraktale Dimension, können wir annehmen, daß es keine Rolle spielt, ob wir
einen random walk mit kontinuierlichen Schrittweiten und Richtungen oder einen
solchen auf dem Gitter betrachten. Im Abschnitt 3.3 haben wir gezeigt, daß ein
Zufallsweg ohne Einschränkungen ein Knäuel eines Polymermoleküls beschreibt,
dessen Masse wie das Quadrat der mittleren Ausdehnung wächst. Sei nämlich N
die Anzahl der Schritte und RN der Abstand der beiden Enden des Weges, dann gilt

N = hRN2 i=a2 : (5.35)

h i
Dabei ist ::: ein Mittelwert über alle Zufallswege und a ist die Länge der Ketten-
ph i
glieder. Definiert man eine mittlere Länge durch L = RN2 , so erhält man
N / LD (5.36)

mit der Dimension D = 2. Dieses Ergebnis gilt nicht nur in der Ebene, sondern in
allen Raumdimensionen.
Nun betrachten wir Zufallswege, die sich nicht selbst schneiden dürfen. Bei rea-
len Polymeren ist es das Eigenvolumen der Ketten, das diese Durchdringung ver-
bietet. Ein solcher self-avoiding walk wird offenbar im Vergleich zum random walk
im Mittel nicht so stark verknäult sein, der mittlere End-zu-End-Abstand L wird
größer werden. Das bedeutet, die Struktur des entsprechenden Polymers ist nicht
mehr so kompakt und die Dimension D sollte kleiner sein. Tatsächlich findet man
beim SAW für große N -Werte wieder ein Gesetz der Form (5.36), nun aber mit ei-
ner fraktalen Dimension D , die von der Raumdimension d abhängt. Schon 1949 hat
Flory mit einer Art Molekularfeldnäherung eine Formel für D angegeben,

D = d +3 2 : (5.37)

Spätere Untersuchungen haben gezeigt, daß diese Formel in d = 1; 2 und 4 Raumdi-

mensionen exakt ist und daß die numerischen Ergebnisse für d = 3 einen nur wenig
höheren Wert für D geben. In d = 4 Raumdimensionen stimmt der Wert D = 2 mit
202 5 Monte-Carlo-Simulationen

demjenigen des random walk überein, dort spielt also das Verbot des Selbstkreuzens
keine Rolle mehr bei den globalen Eigenschaften. In allen höheren Raumdimensio-
nen bleibt der Wert D = 2. Wie bei vielen anderen Phasenübergängen werden ab
einer oberen kritischen Dimension d = 4 die kritischen Exponenten durch die Mo-
lekularfeldtheorie beschrieben.
Tatsächlich gibt es verdünnte Lösungen von Polymeren, bei denen bei hohen
Temperaturen ein SAW-Gesetz wie in den Gleichungen (5.36) und (5.37) beob-
achtet wurde. Bei realen Molekül-Ketten gibt es auch attraktive Wechselwirkun-
gen zwischen entfernten Monomeren eines einzelnen Polymermoleküls, so daß die
Kette bei tiefen Temperaturen zu einem kompakten Knäuel mit D = d kollabie-
ren kann. Noch komplexer wird es natürlich, wenn viele Molekülketten miteinander
wechselwirken. Gerade in den letzten Jahren haben extensive numerische Simulatio-
nen wesentlich zum Verständnis der Polymerdynamik in einer solchen Spaghetti-
”
Suppe“ beitragen können. Hier wollen wir uns dagegen mit der Simulation des re-
lativ einfachen SAW befassen.

Algorithmus
Einen Zufallsweg auf einem Gitter kann man mit dem Computer leicht erzeugen.
Bei jedem Schritt wählt man mit einer Zufallszahl einen der Nachbarplätze aus und
macht dorthin einen weiteren Schritt. Auch beim Zufallsweg, der sich nicht über-
kreuzen darf, scheint der Algorithmus offensichtlich zu sein: Man wählt zufällig
einen der bisher nicht besuchten Nachbarplätze aus und macht einen Schritt dort-
hin. Doch überraschenderweise gibt dieser Algorithmus falsche Resultate: Im Mittel
wird das Polymer kompakter als das korrekte statistische Mittel. Ketten, die sich an
mehreren Stellen berühren, werden öfter erzeugt als gestreckte Ketten mit wenigen
Berührungspunkten.
Der Grund dafür soll hier kurz erläutert werden. Sei Zi die Zahl der noch nicht
besuchten Nachbarplätze am Ende einer Kette. Dann ist 1=Zi die Wahrscheinlich-
keit, daß ein Monomer an einem dieser Plätze hinzugefügt wird. Die gesamte Wahr-
scheinlichkeit W , eine spezielle Kettenkonfiguration mit N Gliedern zu erzeugen,
ist damit
Y
N
1
WN = Z : (5.38)
i=1 i
Man sieht also, daß Ketten mit vielen Berührungspunkten (Zi klein) eine hohe
Wahrscheinlichkeit erhalten. Dies darf nicht sein, denn im korrekten statistischen
Mittel muß jede erlaubte Konfiguration mit derselben Wahrscheinlichkeit auftreten.
Gleichung (5.38) zeigt aber auch sofort, wie man die unerwünschte Bevorzugung
kompakter Ketten korrigieren kann. Man muß jeder Bindung das statistische Ge-
5.4 Polymer-Ketten 203

wicht Zi geben und die Eigenschaften des Polymers damit wichten. Dadurch erhält
jede Kette dasselbe statistische Gewicht

Y
N
WN Zi = 1 ; (5.39)
i=1
und der korrekte Wert des mittleren End-zu-End-Abstandes L ist bei dieser Simula-

P Q
tion also
N
RN;l
2 Zi;l
L = R =
2 h Ni
2 l i =1 ;
P QN Z (5.40)
i;l
l i=1
wobei l die erzeugten Konfigurationen durchnumeriert.
Es gibt aber auch eine effektive Methode, um direkt Polymerkonfigurationen mit
konstanter Wahrscheinlichkeit zu erzeugen. Während der vorherige Algorithmus
Ketten wachsen läßt, arbeitet diese Methode, die mit Reptation bezeichnet wird,
mit konstanter Kettenlänge N . Dabei schlängelt“ sich das Polymer über das Gitter
”
und ändert auf diese Weise ständig seine Form und Richtung.
Bevor wir diesen Reptationsalgorithmus und seine Eigenschaften beschreiben,
müssen wir kurz erläutern, was man unter einer Konfiguration des Polymers versteht
und wann zwei solche Konfigurationen auf dem ebenen Quadratgitter als verschie-
den gelten. Es ist beispielsweise sinnvoll, alle diejenigen Konfigurationen als gleich
anzusehen, die durch die möglichen Translationen einer gegebenen Form der Poly-
merkette entstehen. Zum Vergleich eventuell verschiedener Konfigurationen können
wir diese dann so verschieben, daß alle an demselben festen Gitterpunkt beginnen.
Dabei ist implizit schon die Festlegung getroffen worden, daß die Kette einen An-
fang hat und wir also von der ersten Monomereneinheit, der zweiten, der dritten
usw. reden können.
Eine weitere elementare Symmetrie des Quadratgitters sollten wir noch zur Ver-
einfachung nutzen, nämlich die 90 -Drehungen. Die Richtung des ersten Monomers
könnte nach Norden, nach Westen, nach Süden oder nach Osten zeigen.
Wenn wir von der Richtung des ersten Kettengliedes absehen, so ist zur ein-
deutigen Charakterisierung einer Konfiguration nur erforderlich zu wissen, ob nach
dem ersten Schritt der nächste nach links, geradeaus oder nach rechts erfolgt, und
dementsprechend für die folgenden Schritte. Wir können also eine Konfiguration ei-
nes Polymers, das aus N Gliedern besteht, durch eine Folge von N 1 Richtungs-
angaben beschreiben, wobei deren mögliche Werte links, geradeaus und rechts
sind. Wichtig in diesem Zusammenhang ist, daß diese Folge in einer bestimmten
Richtung durchlaufen wird. Wie oben schon gesagt, benötigt die Polymerkette ei-
ne Orientierung. Dazu markieren wir die Enden der Kette mit Kopf bzw. Schwanz
204 5 Monte-Carlo-Simulationen

und verabreden z. B., daß die Orientierung vom Schwanzende zum Kopfende hin
erfolgen soll.
Aber nicht jede Folge von N 1 Richtungsangaben stellt einen SAW dar, sondern
es sind nur diejenigen Folgen erlaubt, die keine Selbstüberschneidungen aufweisen,
eine Nebenbedingung, die sich nicht lokal formulieren läßt. Das ist auch der Grund
dafür, daß es zur Statistik der SAWs bisher nur so wenige analytische Resultate gibt
und man auf Computersimulationen angewiesen ist.
Der Algorithmus für die Reptation einer Polymerkette mit N Gliedern lautet fol-
gendermaßen:

1. Starte mit einer Konfiguration auf dem Gitter, wobei die Enden der Kette mit
Kopf bzw. Schwanz markiert sind.

2. Entferne das letzte Monomer am Schwanzende und wähle am Kopfende einen

der Nachbarplätze zufällig aus (drei Möglichkeiten auf dem Quadratgitter).

3. Falls dieser Platz unbesetzt ist, füge dort ein neues Kopfmonomer hinzu. Falls
dieser Platz besetzt ist, restauriere die alte Konfiguration, vertausche die Markie-
rungen Kopf und Schwanz und berücksichtige die ansonsten unveränderte Konfi-
guration als neue Konfiguration bei der Mittelwertbildung.

4. Iteriere 2 und 3.

Man kann zeigen, daß diese Methode alle Konfigurationen, die überhaupt aus der
Startkonfiguration entstehen können, mit der gleichen Wahrscheinlichkeit erzeugt.
Dazu numerieren wir die verschiedenen erreichbaren Zustände mit l = 1; 2; 3; : : : ;
N durch und bezeichnen mit pl (t) die Besetzungswahrscheinlichkeiten, die sich
nach entsprechend langer Zeit einstellen. Wenn wir zudem noch die Übergangs-
wahrscheinlichkeiten W (l !
k) kennen, mit der pro Zeitschritt Konfiguration l in
Konfiguration k transformiert wird, so können wir für die Zeitentwicklung der pl (t)
folgende Mastergleichung aufschreiben:

X
N
p_l = (W (k ! l) pk W (l ! k) pl ) : (5.41)
k=1
P
Wegen k W (l ! k) = 1 läßt sich die Summation im zweiten Term ausführen.
Weil wir an der stationären Verteilung interessiert sind, d. h. p_l = 0, suchen wir also
die Lösung des Gleichungssystems

X
N
W (k ! l) pk = pl : (5.42)
k=1
5.4 Polymer-Ketten 205

Bei manchen Problemen dieser Art sind die Übergangswahrscheinlichkeiten W (l

! k) mit Hilfe einer stationären Verteilung wk konstruiert, und zwar so, daß die
Gleichung
!
W (k l) wk = W (l k) wl ! (5.43)

gilt. Man spricht dann von detailliertem Gleichgewicht (detailed balance), und aus
Gleichung (5.41) ersieht man sofort, daß dann pk = wk eine Lösung der stationären
Mastergleichung ist.
Detailed balance gilt aber für unseren Fall nicht, wie man sich an folgendem
Beispiel klarmacht: Die völlig gestreckte Konfiguration hat mit Wahrscheinlichkeit
1=3 nach dem nächsten Zeitschritt am Kopfende einen Rechtsknick, während die
Wahrscheinlichkeit, daß dieser neue Zustand wieder in den gestreckten übergeht,
null ist.
Statt des detaillierten Gleichgewichts gilt aber für den Reptationsalgorithmus die
folgende Beziehung:
! !
W (k l) = W (linv kinv ) ; (5.44)

wobei wir mit linv den Zustand bezeichnen, den man aus l durch Vertauschung
von Kopf und Schwanz erhält. Für l = kinv ist die Gleichung (5.44) trivialerweise
erfüllt. Das betrifft alle die Fälle, in denen der Algorithmus eine Kopf-Schwanz-
Vertauschung verlangt. Für die anderen Übergänge gilt folgendes: Wenn es möglich
ist, am Schwanzende ein Monomer zu entfernen und dafür am Kopfende eines hin-
zuzufügen, so ist auch der umgekehrte Prozeß möglich, nämlich dieses neue Kopf-
monomer zu entfernen und es ans Schwanzende zurückzulegen. Daraus schließen
wir, daß beide Seiten von Gleichung (5.44) entweder gleich null sind oder ungleich
null sind. Wenn sie aber ungleich null sind, so sind sie beide gleich 1=3, denn
das Hinzufügen eines neuen Kopfmonomers einer bestimmten Richtung geschieht,
wenn es überhaupt möglich ist, immer mit der Wahrscheinlichkeit 1=3 . Verwenden
wir (5.44) in Gleichung (5.42), so erhalten wir ähnlich wie oben, daß pl = const. =
P
N !
1= eine Lösung ist, denn natürlich ist auch k W (linv kinv ) = 1 . D. h., die
erreichbaren Konfigurationen werden mit gleicher Wahrscheinlichkeit erzeugt.
Allerdings gibt es ganze Klassen von Konfigurationen, die mit dem Reptations-
algorithmus nicht erreichbar sind, wenn man als Startzustand den völlig gestreckten
oder einen äquivalenten benutzt. Das Bild 5.8 zeigt Beispiele aus zwei verschiede-
nen solcher Klassen. Wir können aber davon ausgehen, daß die Anzahl dieser Konfi-
gurationen klein ist im Vergleich zu den Zuständen in der Hauptklasse. Andererseits
hängt es natürlich von der Fragestellung ab, ob die anderen Konfigurationen relevant
sind oder nicht. Wenn wir mit dem Reptationsalgorithmus den mittleren End-zu-
End-Abstand berechnen, so werden wir einen geringfügig zu großen Wert erwarten,
weil wir die stärker eingerollten Zustände der anderen Klassen nicht berücksichtigt
haben.
206 5 Monte-Carlo-Simulationen

5.8 Polymerkonfigurationen, die nicht von der gestreckten Startkonfiguration aus erreichbar
sind. Der offene Kreis bezeichnet den Kopf.

Wir wollen uns das schlängelnde Polymer auf dem Computerbildschirm erzeu-
gen. Dazu programmieren wir den Reptationsalgorithmus auf dem Quadratgitter in
der Sprache C. Zunächst deklarieren wir den Variablentyp vector, der Strukturen
mit den Ortskoordinaten (x; y ) definiert.

typedef struct f
float x,y; vector; g
vector richtung[3], polymer[NMAX];

polymer[NMAX] ist ein Feld von Vektoren, das alle Ortskoordinaten des Poly-
mers enthält; polymer[5].y gibt z. B. die y -Koordinate des 5-ten Monomers an.
Am Anfang wird als Konfiguration für das Polymer die gestreckte Kette festgelegt
und mit der Funktion kreis gezeichnet.

for(i=0;i<N;i++)
{
polymer[i].x=i–N/2;
polymer[i].y=0;
kreis(polymer[i]);
}

Jede andere äquivalente Startkonfiguration ist genauso möglich. Die Markierungen

Kopf und Schwanz werden am Anfang auf die Plätze (N 1) bzw. 0 gelegt, und bei
jeder Bewegung werden diese Zeiger um den Wert 1 (modulo N ) erhöht.
Die Funktion wahl() wählt eine der drei möglichen Nachbarplätze des Kopf-
es zufällig aus (Punkt 2). Die Funktion kreuzung(w) prüft, ob der Nachbarplatz
durch die Kette besetzt ist. Falls ja, wird Kopf und Schwanz vertauscht, falls nein,
wird der neue Kopf akzeptiert und ein Schwanzelement überschrieben. Punkt 3 lau-
tet also im Programm:
5.4 Polymer-Ketten 207

while(!done)
{
event();
w=wahl();
if(kreuzung(w))
{ kopf=schwanz; incr=–incr;
schwanz=(kopf+incr+N)%N;
}
else akzeptiere(w);
}
Anstatt das Polymer auf seinem Speicherplatz zu verschieben, verwenden wir Indi-
zes für den Kopf und den Schwanz. Die Variable incr = 1 gibt die Richtung
des Polymers im Feld polymer[N] an. Um negative Indizes zu vermeiden, wird
bei der Modulo-Operation % noch die Zahl N addiert.
Die Funktion event() fragt wie in jedem unserer C-Programme Tasten- bzw.
Maus-Aktionen des Beobachters ab und gibt eventuell done=1 zurück, wodurch
die while-Schleife beendet wird.
Die Funktion wahl() gibt einen (x; y )-Vektor zurück, der vom Kopf auf einen
der drei Nachbarplätze zeigt. Zunächst werden die drei möglichen Richtungen er-
r
zeugt, indem die Differenz ( (Kopf) r (Hals)) gebildet wird (richtung[0])
und dann die beiden Vektoren senkrecht dazu berechnet werden. Wenn z. B. der
Vektor richtung[0]= (0; 1) ist, so enthalten die Variablen richtung[1]
und richtung[2] die Vektoren (1; 0) bzw. ( 1; 0). Mit einer gleichverteilten
Zufallszahl aus dem Intervall [0; 3) wird dann durch Umwandlung in eine ganze
Zahl r eine der drei Richtungen zufällig ausgewählt und zurückgegeben.
vector wahl()
{
int km,r;
km=(kopf–incr+N)%N;
richtung[0].x=polymer[kopf].x–polymer[km].x;
richtung[0].y=polymer[kopf].y–polymer[km].y;
richtung[1].x=richtung[0].y;
richtung[1].y=richtung[0].x;
richtung[2].x=–richtung[1].x;
richtung[2].y=–richtung[1].y;
r=random(3);
return richtung[r];
}
Die Funktion kreuzung(w) gibt den Wert 1 bzw. 0 zurück, falls der gewähl-
te Nachbarplatz auf den alten Kettengliedern liegt bzw. nicht liegt. Dies läßt sich
208 5 Monte-Carlo-Simulationen

folgendermaßen leicht überprüfen:

int kreuzung(vector w)
{
int i;
for(i=0;i<N;i++)
if(w.x+polymer[kopf].x==polymer[i].x &&
w.y+polymer[kopf].y==polymer[i].y &&
i != schwanz) return 1;
return 0;
}

Ohne Kreuzung wird der gewählte Platz als neuer Kopf akzeptiert und die Indizes
werden um den Wert incr verschoben. Auf dem Bildschirm wird der Kreis am Ort
des Schwanzes mit Hintergrundfarbe übermalt und der neue Kopf wird als Kreis hin-
zugezeichnet. So entsteht eine Schlangenbewegung auf dem Gitter. All dies macht
folgende Funktion:

void akzeptiere (vector w)

{
int kp;
void verschiebe();
setcolor(BLACK);
kreis(polymer[schwanz]);
kp=(kopf+incr+N)%N;
polymer[kp].x=w.x+polymer[kopf].x;
polymer[kp].y=w.y+polymer[kopf].y;
kopf=kp;
schwanz=(kopf+incr+N)%N;
setcolor(WHITE);
kreis(polymer[kopf]);
if(abs(polymer[kopf].x)>2*N ||
abs(polymer[kopf].y)>2*N) verschiebe()
}

Um den mittleren End-zu-End-Abstand L zu berechnen, müssen wir nach jedem

r
Schritt, auch nach der Richtungsumkehr, den Betrag des Differenzvektors (Kopf)
r (Schwanz) berücksichtigen, alle Beträge aufsummieren und schließlich durch
die Anzahl der Reptationsschritte dividieren. Zusätzlich haben wir noch eine Funk-
tion verschiebe() definiert, die das Polymer in die Mitte schiebt, wenn es das
Fenster verlassen will.
5.4 Polymer-Ketten 209

Ergebnisse
Der Aufruf unseres C-Programms erzeugt das Polymer auf dem Bildschirm (Bild
p
5.9). Gleichzeitig wird der mittlere End-zu-End-Abstand ausgedruckt, und zwar re-
lativ zum Ergebnis L = N des random walk ohne Einschränkungen. Man er-
kennt, daß das Polymer im Mittel gestreckter ist als der random walk und daß diese
relative mittlere Länge mit N anwächst, in Übereinstimmung mit der kleineren frak-
talen Dimension D = 4=3. Tatsächlich ergibt schon der Fit aus den beiden Werten
für N = 50 und N = 100 recht genau, daß das Verhältnis der Längen, wie es die
Theorie vorhersagt, proportional zu N 0:25 anwächst.

5.9 Polymerketten der Längen N = 50 und N = 100 auf dem Quadratgitter.

Übung
Programmieren Sie den anfangs erwähnten Algorithmus, indem Sie, wie in den
Gleichungen (5.39), (5.40) angegeben, die Anzahl Zi der bei jedem Schritt verfüg-
baren freien Plätze in korrekter Weise berücksichtigen. Vergleichen Sie diese Im-
plementierung mit dem Reptationsalgorithmus in bezug auf die Rechengeschwin-
digkeit und den Wert für den mittleren End-zu-End-Abstand.

5.5 Ising-Ferromagnet
Wenn sehr viele Teilchen zusammenwirken, können qualitativ neue Eigenschaften
entstehen. Zum Beispiel werden Gase bei tiefen Temperaturen oder hohem Druck
plötzlich flüssig, Flüssigkeiten werden zum Festkörper, magnetische Atome ordnen
sich zu einem magnetischen Material und Metalle verlieren plötzlich ihren elektri-
schen Widerstand. Es gibt sehr viele solcher Systeme, die im Wärmegleichgewicht
bei einer wohldefinierten Temperatur ihre makroskopischen Eigenschaften ändern.
In der mathematischen Modellierung treten diese Phasenübergänge nur im unend-
lich großen System auf.
Kann man mit dem Computer ein Wärmegleichgewicht simulieren und ein Sy-
stem langsam abkühlen? Kann die Simulation endlich großer Systeme Phasenum-
wandlungen beschreiben? Mit solchen Fragen wollen wir uns in diesem Abschnitt
befassen, exemplarisch wieder an einem einfachen Modell, dem Ising-Ferromagne-
ten auf dem Quadratgitter. Dieses Modell hat am Phasenübergang universelle kriti-
sche Eigenschaften, die auch bei vielen anderen Modellen und bei realen Materiali-
en gemessen werden. Wir lassen die mikroskopischen Magnete auf dem Bildschirm
flackern und heizen dabei mit einem Tastendruck den Magneten auf oder kühlen ihn
ab.

Physik
Schon seit Anfang dieses Jahrhunderts ist bekannt, wie man das Wärmegleichge-
wicht von wechselwirkenden Teilchen mathematisch beschreiben kann. In der kano-
nischen Formulierung führt die statistische Mechanik die thermischen Eigenschaf-
ten auf die Berechnung einer Zustandssumme Z zurück,
X H (S )=kB T :
Z= e (5.45)
S

Z ist die Summe über alle möglichen Vielteilchenzustände S , und jeder Zustand
wird entsprechend seiner Energie H (S ) gewichtet. T ist die Temperatur und kB die
Boltzmann-Konstante.
Wir wollen das Ising-Modell beschreiben, ein einfaches Modell für ein magne-
tisches System. Dazu betrachten wir ein Quadratgitter, auf dessen Gitterplätzen
Spins sitzen, die nur zwei Einstellmöglichkeiten haben. Außerdem gibt es zwi-
schen benachbarten Spins eine Wechselwirkung. Mathematisch läßt sich das fol-
gendermaßen formulieren: An jedem Gitterplatz i = 1; :::; N gibt es eine Variable
2f g
Si +1; 1 , so daß ein Vielteilchenzustand durch S = (S1; S2 ; :::; SN ) ge-
kennzeichnet ist. In die Berechnung der Gesamtenergie H (S ) geht eine Summation
5.5 Ising-Ferromagnet 211

sowohl über alle Nachbarpaare (i; j )nn als auch über alle Plätze i ein:
X X
H= J Si Sj h Si : (5.46)
(i;j )nn i
Dies bedeutet, parallele Nachbar-Spins haben die Paar-Wechselwirkungs-Energie
J < 0, während der Term proportional zu h ein äußeres Magnetfeld beschreibt,
in dem jeder zum Feld parallele Spin die Energie h < 0 hat.
Das Problem ist damit wohldefiniert: Wir brauchen nur“ die Summe (5.45) aus-
”
zurechnen. Wir wollen dies mit einem Computer versuchen. Nehmen wir an, wir
hätten 100 Stunden Rechenzeit auf einer Maschine zur Verfügung, die für einen

Rechenschritt etwa 10 6 s benötigt. Insgesamt können wir also 3:6 1011 Rechen-
schritte nutzen, wobei wir von einer schnellen Maschine ausgegangen sind, wenn
man beachtet, daß ein Rechenschritt, also z. B. die Auswertung der exp-Funktion,
viele Zeittakte benötigt.
Wieviele Rechnungen brauchen wir bei N Spins für die Auswertung der Glei-
chung (5.45) ? Da jeder Spin Si zwei Einstellmöglichkeiten hat, gibt es insgesamt
2N verschiedene Spinkonfigurationen. Bei jedem dieser Zustände muß die Energie
H aus Gleichung (5.46) berechnet werden. Dies kostet 2N Rechenschritte. Daraus
folgt
2N 2N = 3:6 1011 (5.47)
mit der Lösung N ' 32. Das Ergebnis ist entmutigend. Selbst mit heutigen Super-

computern können wir nur einen winzigen Magneten der Größe 3 3 3 berechnen,

dabei wollen wir ein reales Material mit 107 107 107 Spins beschreiben!
Mit Transfermatrix-Methoden gelingt es, die Zustandssumme Z für Stäbe der
1
Größe 4 4 exakt zu berechnen. Allerdings ist dies immer noch sehr wenig,
wenn wir Phasenübergänge beobachten wollen.
Man könnte nun auf die Idee kommen, nur einige wenige zufällig erzeugte Zu-
stände S = (S1 ; S2 ; S3 ; : : : ; SN ) in der Zustandssumme Gleichung (5.45) zu be-
rücksichtigen. Das funktioniert aber nicht. Denn zufällig erzeugte Zustände ha-
ben nach dem zentralen Grenzwertsatz für große N -Werte die Energie H
p ' 0+
O ( N ). Die physikalisch wichtigen Zustände haben aber eine Energie der Größen-
O
ordnung (N ), sie werden also bei der obigen Methode überhaupt nicht erzeugt.
Schon zu den Zeiten der ersten Computer haben sich Physiker überlegt, wie man
die physikalisch relevanten Zustände erzeugen kann. Dazu startet man mit einer
Konfiguration S (t = 0) und erzeugt daraus eine Folge S (1); S (2); :::; S (t), die
in das thermische Gleichgewicht relaxiert. Dazu wird eine Übergangswahrschein-
lichkeit W (S ! S 0) definiert, die – man vergleiche mit dem vorigen Abschnitt –
folgendem detaillierten Gleichgewicht genügt

W (S S 0 ) e H (S )=kB T = W (S0 S ) e H (S0 )=kB T :

! ! (5.48)
212 5 Monte-Carlo-Simulationen

Diese Gleichung kann man sich folgendermaßen klarmachen: Im Gleichgewicht ist

P (S ) = Z1 e H (S )=k T B
(5.49)

die Wahrscheinlichkeit, einen Zustand S vorzufinden. Die Forderung (5.48) nach

detaillierter Balance hat zur Folge, daß bei der durch W definierten Dynamik das
thermische Gleichgewicht P (S ) ein stationärer Zustand ist. Die Besetzungswahr-
scheinlichkeit P (S ) ändert sich nicht mit der Zeit. Wie im Abschnitt 5.4 kurz be-
schrieben, kann man dies mathematisch präzise mit einer Mastergleichung formu-
lieren und beweisen.
Im Algorithmus-Teil wird eine Funktion W (S !S 0 ) definiert, die der Glei-
chung (5.48) genügt und sehr einfach zu programmieren ist. Im Prinzip gibt uns
Gleichung (5.48) noch viele Freiheiten zur Wahl von W , wir müssen nur beach-
ten, daß W auch durch den ganzen Konfigurationsraum (= Menge der Zustände S )
führen kann. Zwei der gängigsten Algorithmen, die beide Bedingungen erfüllen,
sind als Metropolis-Algorithmus bzw. Heat-Bath-Algorithmus bekannt.
Der durch W definierte stochastische Prozeß führt zu einer Folge von physika-
lisch relevanten Konfigurationen S (0); S (1); :::; S (t), die z. B. bis auf Fluktuatio-
nen die richtige Energie und Magnetisierung ergeben. Mit diesen Zuständen S (t)
können Mittelwerte von Größen A(S ) berechnet werden.
X
t0 +t1
hAit ;t = t1
0 1
A(S (t)) : (5.50)
1 t=t 0

Im Grenzwert t0 ! 1 und t1 ! 1 stimmt dieses Zeitmittel mit dem statistischen

Mittel X
hAi = P (S ) A(S ) (5.51)
S
überein. In der Praxis kann man aber nur mit endlichen Werten für t0 und t1 rechnen.
t0 muß dabei so groß sein, daß das System aus dem eventuell unphysikalischen
Startzustand S (0) ins thermische Gleichgewicht relaxiert ist, und t1 muß so groß
sein, daß die statistischen Fluktuationen von hAit ;t klein sind. Beides hängt vom
0 1
Modell, seinen Parametern und der Systemgröße ab.
Mit den heutigen Computern kann man etwa folgende Werte erreichen:
' ' '
N 106 :::1012 ; t0 t1 (104 :::106 )N : (5.52)
Daher werden nur etwa 1010 bis 1015 Konfigurationen S (t) erzeugt, während das
Modell 2N , also 10300 000 bis 10300 000 000 000 verschiedene Zustände S hat. Welchen
Algorithmus man auch immer verwendet, er kann nur einen winzigen Bruchteil aller
möglichen Konfigurationen erzeugen. Aber er muß die richtigen“, die typischen
”
bzw. die physikalischen Zustände erzeugen.
5.5 Ising-Ferromagnet 213

Bevor wir zur Programmierung des durch Gleichung (5.48) beschriebenen sto-
chastischen Prozesses kommen, wollen wir kurz die Eigenschaften des Ising-Fer-
romagneten und deren Abhängigkeit von der Systemgröße N diskutieren. Das un-
endlich große System (N !1 ) hat ohne äußeres Magnetfeld (h = 0) einen
Phasenübergang in zwei und mehr Raumdimensionen. Unterhalb einer kritischen
Temperatur Tc ordnen sich im thermischen Mittel die Spins parallel zueinander und
bilden eine makroskopische Magnetisierung M ,
X
M (T ) = N1 hSii : (5.53)
i
M kann positiv oder negativ sein; das System wählt durch zufällige Fluktuationen
beim Abkühlen eine Richtung aus. Da für h = 0 die Energie symmetrisch in M
ist, H (S ) = H ( S ), nennt man diesen Vorgang spontane Symmetriebrechung.
Ein äußeres Magnetfeld h 6= 0 hebt diese Symmetrie auf und zerstört dadurch den
Phasenübergang.
Der Phasenübergang ist kritisch, d. h. die Magnetisierung M (T ) geht mit wach-
sender Temperatur stetig gegen den Wert M (T ) = 0 für T Tc . Wie bei der
Perkolation aus Abschnitt 5.3 gibt es eine divergierende Korrelationslänge (T ),
die durch den Zerfall der Spinkorrelationen für große Abstände r definiert ist:
hSi Sj i exp( r=) mit r = jri rj j : (5.54)
In der Nähe des Phasenübergangs T ' Tc ; h ' 0, gibt es wieder Skalengesetze und
Potenzsingularitäten mit universellen kritischen Exponenten. Bei Tc gelten folgende
Beziehungen für die Magnetisierung M , die Korrelationslänge , die magnetische
Suszeptibilität und die spezifische Wärme C :
M (T ) (Tc T ) (T % Tc )
(T ) jTc T j
(T ) jTc T j
C (T ) jTc T j : (5.55)
Die Begründung für diese universellen Eigenschaften gibt die mathematisch an-
spruchsvolle Theorie der Renormierungsgruppe aus den siebziger Jahren (Nobel-
preis für K. G. Wilson im Jahre 1982). Das zweidimensionale Modell (für h = 0)
wurde 1944 von Onsager gelöst. Die universellen Größen sind daher für d = 2
exakt bekannt, und zwar gibt die Onsager-Lösung

Tc = kJ p2 ' 2:269::: kJ ;
B ln 2 + 1 B
1 7
= 8 ; = 1; = 4 ; = 0 : (5.56)
214 5 Monte-Carlo-Simulationen

Die spezifische Wärme C divergiert wie ln T j j

Tc . Der Wert = 0 bedeutet
also nicht, daß die spezifische Wärme bei Tc endlich bliebe, sondern nur, daß sie
schwächer als jede Potenz von T j j
Tc divergiert. Der Wert für Tc gilt nur für
das Ising-Modell auf dem Quadratgitter, die Exponenten hingegen gelten für alle
zweidimensionalen Systeme, deren kritischer Phasenübergang dieselben Symmetri-
en wie das Ising-Modell hat.
Bei der Perkolation haben wir schon gesehen, daß man von einem endlich großen
auf das Verhalten des unendlichen Systems schließen kann. Dieses finite size sca-
ling, das ebenfalls mit der Renormierungstheorie begründet wird, gilt auch für den
Ising-Ferromagneten. Ein endliches System hat keinen Phasenübergang in eine ma-
gnetische Ordnung, aber aus der N -Abhängigkeit von und C kann man die kriti-
schen Exponenten berechnen.
Sei L die Kantenlänge eines Quadrates mit N = L2 Spins. Analog zur Gleichung
(5.27) gilt asymptotisch dicht bei Tc :

(T; L) = jT Tc j f jT TcjL1= :
(5.57)

Setzt man jT Tcj L1= = const:, so erhält man

(Tc ; L) L = : (5.58)

Aus der Divergenz der Suszeptibilität als Funktion der Systemgröße erhält man also
den Wert = . Entsprechend findet man aus der Divergenz der spezifischen Wärme
C (Tc; L) den Exponenten = . Aus diesen beiden Werten kann man mit Hilfe der
Skalengesetze alle anderen Exponenten berechnen. Es gilt (d = Raumdimension 2; 3
oder 4)
= d +2 = ; = d +2 = ; = dd + =
= : (5.59)

Algorithmus
Der stochastische Prozeß benötigt eine Übergangswahrscheinlichkeit W (S S 0 ),
!
die dem detaillierten Gleichgewicht (5.48) genügt. Wir wollen hier eine einfache
Methode verwenden, und zwar den Metropolis-Algorithmus. W soll nur Übergänge
erlauben, bei denen höchstens ein Spin geändert wird. Sei also

S = (S1; S2 ; :::; Si ; :::; SN ) ;

und
S 0 = (S1 ; S2; :::; Si ; :::; SN ) : (5.60)
5.5 Ising-Ferromagnet 215

Außerdem sollen Übergänge in energetisch günstigere Zustände immer stattfinden

(W = 1). Mit den Gleichungen (5.48) und (5.49) gilt damit
1 für H (S 0 ) < H (S )
W (S ! S 0 ) = 0
exp( H (S ) H (S ) ) sonst :
(5.61)
kB T
E = H (S ) H (S 0 ) läßt sich einfach berechnen. Es gilt nämlich:
X
H (S ) = JSi Sj h Si + Rest ; (5.62)
j 2N (i)
wobei die j -Summe nur über die Nachbarn von i läuft und Rest denjenigen Anteil
von H enthält, der nicht von Si abhängt. S 0 hat dieselben Spins Sj0 = Sj bis auf
Si0 = Si , also hat H (S 0 ) auch denselben Rest. Daraus folgt
0 1
X
E = 2Si @J Sj hA = 2Si hi : (5.63)
j 2N (i)
hi nennt man das innere Feld des Spins Si. Damit können wir den Metropolis-Al-
gorithmus schließlich formulieren:
1. Wähle einen Startzustand S (0) = (S1 ; :::; SN ).
2. Wähle ein i (zufällig oder sequentiell) und berechne E
= 2Si hi .
3. Wenn E 0, dann drehe den Spin Si ! Si . Wenn E < 0, dann ziehe
eine gleichverteilte Zufallszahl r 2[0; 1]. Wenn r < exp(E=kB T ), dann
Si ! Si , sonst berücksichtige die alte Konfiguration noch einmal.
4. Iteriere 2 und 3.
Dieser Algorithmus gilt nicht nur für das Ising-Modell, sondern ganz allgemein
für alle Modelle der statistischen Mechanik. Wir werden ihn auch bei schwierigen
Optimierungsproblemen im nächsten Abschnitt anwenden. Weil diese Methode Zu-
fallszahlen benutzt, nennt man sie Monte-Carlo-Simulation.
Der obige Algorithmus ist nicht die einzige Möglichkeit, detailliertes Gleich-
gewicht zu erfüllen und damit thermisches Gleichgewicht zu erreichen. Gerade in
den letzten Jahren gab es eine Vielzahl von neueren Entwicklungen zu der seit vier
Jahrzehnten bekannten Methode. So kann man große, geeignet ausgewählte Clu-
ster von Spins gleichzeitig drehen und dadurch, insbesondere bei Tc , die Simulation
erheblich beschleunigen. Diese Methode kann man noch mit einer hierarchischen
Überstruktur, die man aus den Mehrgitter-Verfahren (Multi Grid Method) der In-
formatik kennt, beschleunigen. Ein weiteres Verfahren nutzt die Informationen über
216 5 Monte-Carlo-Simulationen

die Fluktuation der Energie und der Magnetisierung aus, um mit einer Simulation
Eigenschaften eines ganzen Temperaturintervalls zu erhalten. Man kann auch Si-
mulationen bei konstanter Energie (mikrokanonisch) durchführen, oder mit einem
Trick hohe Energiebarrieren überwinden. Der Metropolis-Algorithmus dagegen ist
einfach und universell, ein Grund, weshalb wir ihn hier programmieren wollen.
Wir sind daran interessiert, die Systemgröße N , die Relaxationszeit t0 und die
Meßzeit t1 so groß wie nur möglich zu machen. Wir brauchen also eine schnel-
le Computersprache. In der aktuellen Forschung und für die Computersimulation
großer Systeme wird meistens die Sprache FORTRAN benutzt, da die FORTRAN-
Compiler der Superrechner den höchsten Optimierungsgrad haben. Aber auch C-
Programme laufen auf Höchstleistungsrechnern effektiv. Wir wollen im folgenden
die Monte-Carlo-Simulation des Ising-Ferromagneten in C programmieren.
Die Spins Si werden auf einem quadratischen Feld s[x][y], x = 1; : : : ; L,
y = 1; : : : ; L, gespeichert und mit den Werten Si = 1 initialisiert. Man könnte
jeden beliebigen Startzustand nehmen, da das System immer ins thermische Gleich-
gewicht relaxiert. Bei tiefen Temperaturen können andere Startzustände aber lange
Relaxationszeiten haben. Die Diffusion von Domänenwänden – im Ergebnisteil ist
ein Bild davon zu sehen – macht dies deutlich.
Randeffekte können einen starken Einfluß auf die Eigenschaften des Magne-
ten haben, insbesondere bei kleinen Systemen. Daher verwenden wir hier periodi-
sche Randbedingungen, d. h. jeder Randspin wechselwirkt mit dem Spin auf der
gegenüberliegenden Seite. Damit hat das System keinen Rand, sondern es ist to-
pologisch zu einem Torus (Autoreifen) aufgewickelt. Um in der innersten Schlei-
fe möglichst viel Rechenzeit einzusparen, verzichten wir darauf, mit if-Abfragen
oder Modulo-Rechnungen die Randindizes festzustellen. Statt dessen kopieren wir
die Werte der Randspins nach jedem Durchlauf in die vier Zusatzfelder s[0][i],
s[L+1][i], s[i][0] und s[i][L+1] mit i = 1; : : : ; L.
Der Algorithmus vergleicht Zufallszahlen mit exp( 2Si hi =kB T ), dem Boltz-
mann-Gewicht bei der Temperatur T . Mit einem kleinen Trick können wir die
ständige Berechnung der e-Funktion vermeiden. Wir führen ihn für h = 0 vor, er
6
funktioniert aber auch für h = 0. Auf dem Quadratgitter kann nämlich die Summe
P
Si j2N (i) Sj über die Nachbarn von Si nur die Werte 4; 2; 0; 2 und 4 anneh-
men. Bei den negativen Werten wird Si immer gedreht. Deshalb gibt es nur zwei
verschiedene Boltzmann-Gewichte exp( 4=T ) und exp( 8=T ), wobei die Tem-
peratur T in Einheiten der Wechselwirkungsenergie J=kB gemessen wird. Beide
Zahlen werden vor den Monte-Carlo-Schritten mit folgender Funktion berechnet:

void setT(double t)
{
temp=t;
bf[0]= 0.5*RAND_MAX;
5.5 Ising-Ferromagnet 217

bf[1]= exp(–4./temp)*RAND_MAX;
bf[2]= exp(–8./temp)*RAND_MAX;
}

Die Variable temp und das Feld bf[...] müssen natürlich vor dem Hauptprogramm
main() deklariert sein, sonst kennt die Funktion setT() diese Größen nicht.
Falls das innere Feld den Wert Null hat, verwenden wir die Übergangswahrschein-
lichkeit W (S ! S 0) = W (S 0 S ) = 1=2 (anstatt 1). Dies vermeidet Oszillatio-
!
nen, die bei der sequentiellen Wahl der besuchten Plätze auftreten können.
Mit den so definierten Boltzmann-Gewichten bf[...] lautet die innerste Schleife

for(x=1;x<L+1;x++) for(y=1;y<L+1;y++)
{
e=s[x][y]*(s[x–1][y]+s[x+1][y]+s[x][y–1]+s[x][y+1]);
if( e<0 || rand()<bf[e/2] )
{
s[x][y]=–s[x][y];
v=2*(x*80+2*(y–1)+2);
ch=(s[x][y]+1)*15;
poke(VSEG,v,0xf00|ch);
}
}
for(x=1;x<L+1;x++)
{
s[0][x] = s[L][x];
s[L+1][x] = s[1][x];
s[x][0] = s[x][L];
s[x][L+1] = s[x][1];
}

In der letzten for-Schleife werden die zusätzlichen Hilfsfelder mit den aktuel-
len Randspins besetzt, um die periodischen Randbedingungen zu erfüllen. Mit dem
poke-Befehl sprechen wir auf dem PC den Bildspeicher im Textmodus direkt an.
Dies ist sehr schnell, während ein Graphik- oder ein putch()-Befehl das Pro-
gramm etwa um einen Faktor 2 langsamer macht. Allerdings funktioniert dieser
Befehl nicht auf allen Maschinen.
Die Monte-Carlo-Simulation läßt sich mit wenig Aufwand programmieren. Mit
kleinen Programmen und schnellen Computern erhält man leicht Resultate. Aber es
ist nicht einfach, die Daten auszuwerten. Immerhin möchte man aus stark fluktu-
ierenden Ergebnissen für relativ kleine Systeme und – verglichen mit dem Experi-
ment – relativ kurzen Rechenzeiten allgemeine Gesetze für die Eigenschaften des
218 5 Monte-Carlo-Simulationen

b
unendlichen Gitters im thermischen Gleichgewicht (= unendliche Relaxationszei-
ten) ableiten. Auch mit der oben erläuterten Theorie des finite size scaling, die ja nur
asymptotisch für N !1 gilt, bleibt dies eine schwierige und mühsame Aufgabe.
Hinzu kommt, daß versteckte Korrelationen in scheinbar guten Zufallszahlengene-
ratoren schon oft zu einem systematischen Fehler geführt haben.

Ergebnisse

Das PC-Programm ISING simuliert einen 20 20-Ising-Ferromagneten auf dem
Quadratgitter und zeigt die Stellung der Spins auf dem Bildschirm an. Mit einem
Tastendruck läßt sich während des Laufes das System aufheizen bzw. abkühlen. Die
Anfangstemperatur T = 2:269J=kB ist nach Onsager die kritische Temperatur Tc
des unendlichen Magneten. Zusätzlich zur Temperatur T und zur Zahl der Monte-
Carlo-Schritte pro Spin (MCS) wird die Zeit ausgedruckt, die der Rechner für einen

Monte-Carlo-Schritt benötigt, auf unserem PC etwa 4 10 5 s. Also selbst auf ei-
nem PC ist ein Schritt so schnell, daß die Spins im simulierten Wärmebad flackern.

Bild 5.10 zeigt ein System der Größe 100 100, dessen Verhalten mit dem ent-

5.10 Zustand des Ferromagne-

ten im thermischen Gleichge-
wicht bei Tc .

sprechenden Programm auf der Workstation simuliert wurde. Bei Tc sieht das Bild
selbstähnlich aus, d. h. es treten Cluster von parallelen Spins auf allen Größenord-
nungen auf. Die Korrelationslänge ist am kritischen Punkt so groß wie die Gitter-
h i
ausdehnung L, und die Korrelationen Si Sj zerfallen für a
r= i j Ljr r j
wie eine Potenz von r (a = Gitterkonstante). Bei T = 0:8 Tc ist das System magne-
P 6
tisiert, ( Si )=N = 0. Durch spontane Fluktuationen hat sich der Magnet eine der
beiden möglichen Richtungen gewählt und die Spins Si sind bis auf wenige Aus-
nahmen parallel dazu ausgerichtet. Wir beobachten also eine von null verschiedene
5.5 Ising-Ferromagnet 219

P
spontane Magnetisierung, und selbst wenn wir Si über ein Zeitintervall t1 mitteln
hP i
würden, würde ( Si )=N t0 ;t1 nicht verschwinden. Widerspricht dies der exakten
Aussage, daß ein endliches System keinen Phasenübergang haben kann (M (T ) = 0
für T > 0)?
Hierzu müssen wir uns die Zeitskala klarmachen, in der das System die Magne-

Arrhenius-Gesetz abgeschätzt werden. Um das Vorzeichen von

P
tisierungsrichtung ändern kann. Bei tiefen Temperaturen kann diese Zeit mit dem
Si zu ändern,
muß eine Energiebarriere der Ordnung E = JL überwunden werden, denn es
muß sich eine Wand zwischen positiver und negativer Magnetisierung bilden, die
durch das gesamte Gitter diffundiert. Das braucht eine Zeit der Größenordnung
'
t0 exp(E=kB T ) wobei t0 die Relaxationszeit eines einzelnen Spins ist. In
unserem Fall (L = 100; kB T = J; t0 ' '
10 4 s) ist diese Zeit also etwa 1040
Sekunden, also wesentlich länger als das Universum existiert. Wir werden daher
bei T = J=kB keine Umkehr der Magnetisierung beobachten können, und es gilt
h i 6
M t0 ;t1 = 0.

5.11 Wandernde Domänen-

wände des Ferromagneten
nach sprunghaftem Abkühlen.

Bei T = 1:5 Tc scheinen die Spins fast zufällig ausgewürfelt zu sein, die Korre-
lationslänge hat fast den Wert a angenommen. Mit einem Tastendruck kann man
nun den Magneten sprungartig auf eine Temperatur deutlich unterhalb Tc abkühlen.
Nach einigen Versuchen sollte es gelingen, Bereiche mit positiver und negativer
Magnetisierung gleichzeitig zu erzeugen (Bild 5.11). Dann entstehen diffundieren-
de Domänenwände, die sich so lange gegenseitig vernichten oder zusammenziehen,
bis das thermische Gleichgewicht mit nur einer einzigen Domäne übrig bleibt. Die
Magnetisierung zeigt als Funktion der Zeit am kritischen Punkt starke Fluktuationen
(Programm ising g). Nach der statistischen Mechanik bestimmen diese Schwan-
kungen von M gerade die magnetische Suszeptibilität , die bei Tc nach Gleichung
220 5 Monte-Carlo-Simulationen

(5.58) mit L divergiert. Das gleiche gilt für die Fluktuationen der Energie, die die
spezifische Wärme C bestimmen.
Für T > Tc und für lange Zeiten t zerfallen die zeitlichen Korrelationen (ebenso
wie die räumlichen) exponentiell schnell
hSi(t0 ) Si (t0 + t)i e t= : (5.64)
Die Relaxationszeit (T ) divergiert bei Tc wie
jT Tc j z= ; (5.65)
wobei z ein neuer universeller kritischer Exponent ist, dessen Wert auch beim zwei-
'
dimensionalen Modell nur numerisch bekannt ist (z 2:1). Die Fluktuationen der
Magnetisierung werden bei Tc also nicht nur größer, sondern auch langsamer. Des-
halb nennt man diesen Effekt critical slowing down.

Übung
Es soll der Phasenübergang eines Gittergases mit der Monte-Carlo-Methode simu-

liert werden. Dazu betrachten wir ein Modell, bei dem auf einem N N -Gitter die
Teilchen nur auf den Gitterpunkten sitzen können. Dies wird durch die Variable ni
beschrieben, die die Werte ni = 1(0) annimmt, falls der Gitterplatz i besetzt (un-
besetzt) ist. Die Anzahl der Teilchen wird durch ein chemisches Potential kontrol-
liert. Die Dynamik besteht darin, daß Teilchen verschwinden und wieder auftauchen
können. Jeder Platz i wird mit der Wahrscheinlichkeit proportional zu z ni besetzt,
wobei z die Fugazität genannt wird. Benachbarte Teilchen sollen sich so stark ab-
stoßen, daß keine Nachbarplätze besetzt werden können. Das Modell enthält sonst
keine Wechselwirkungen und deshalb auch keine Temperatur, der einzige Kontroll-
parameter ist die Fugazität z , die die Teilchendichte des Gitters einstellt.
Wenn das Gitter maximal bedeckt ist, befinden sich N 2 =2 Teilchen auf einem
der beiden Untergitter, wie beim Schachbrett entweder auf den weißen oder auf
den schwarzen Plätzen. Aber auch bei unvollständiger Bedeckung bevorzugen die
Teilchen eines der beiden Untergitter; im thermischen Mittel ist die Differenz der
Anzahl der Teilchen zwischen den weißen und schwarzen Plätzen ungleich Null.
Diese Differenz ist der Ordungsparameter des Systems, er entspricht der Magne-
tisierung des Ising-Modells. Erst wenn die Bedeckung einen gewissen Wert unter-
schreitet, werden im thermischen Mittel beide Untergitter gleich stark belegt, und
der Ordnungsparameter hat den Wert Null. Wie beim Ising-Modell gibt es diesen
Phasenübergang streng genommen nur im unendlich großen System; in der Simu-
lation muß man finite size scaling anwenden, um die Eigenschaften des Übergangs
zu berechnen.
Programmieren Sie folgenden Monte-Carlo-Schritt für das Gittergas:
5.6 Kürzeste Rundreise 221

1. Suche zufällig einen Gitterplatz aus.

2. Ist der Gitterplatz leer, besetze ihn, wenn dies erlaubt ist, d. h., wenn alle nächsten
Nachbarplätze leer sind, ansonsten akzeptiere die alte Konfiguration.

2
3. Ist der Gitterplatz besetzt, ziehe eine Zufallszahl r [0; 1] und vergleiche sie
mit z 1 . Ist sie kleiner, entferne das Teilchen. Ist sie größer, akzeptiere die alte
Konfiguration.

Berechnen Sie den Mittelwert des Ordnungsparameters und dessen Varianz, die Sus-
zeptibilität, als Funktion der Fugazität z . Bestimmen Sie deren kritischen Wert zc
und die zugehörige Bedeckung c des Gitters.
Hinweis: In der Literatur findet man zc = 3:7959 und c = 0:36776.

Literatur
K. Binder, D. W. Heermann, Monte Carlo Simulation in Statistical Physics, Springer
Verlag, 1992.
H. Gould, J. Tobochnik, An Introduction to Computer Simulation Methods:
Applications to Physical Systems, Parts I and II, Addison Wesley, 1988.
J. Honerkamp, Stochastische Dynamische Systeme: Konzepte, numerische Metho-
den, Datenanalysen, VCH Verlagsgesellschaft, 1990.
S. E. Koonin, D. C. Meredith, Physik auf dem Computer, Band 1+2, R. Oldenbourg
Verlag, 1990.
J. Schnakenberg, Algorithmen in der Quantentheorie und Statistischen Physik, Zim-
mermann-Neufang, 1995.

5.6 Kürzeste Rundreise

Ein Handlungsreisender möchte eine große Anzahl von Städten in möglichst kurzer
Zeit besuchen. Dazu plant er eine Reiseroute, d. h. eine Reihenfolge der Städte mit
möglichst kurzem Reiseweg. Welches ist die kürzeste Rundreise, bei der jede Stadt
genau einmal besucht wird? Dieses scheinbar einfache Problem, das travelling sa-
lesman problem (TSP), ist das Standardbeispiel der schwierigen kombinatorischen
Optimierungsprobleme. Eine Generation von Mathematikern und Ingenieuren hat
es mathematisch analysiert und Algorithmen zu seiner Lösung entwickelt.
Überraschenderweise kann man die Minimierung der Rundreise auch als ein Pro-
blem der statistischen Mechanik auffassen. Die Weglänge der Reise entspricht der
Energie eines Vielteilchenproblems, und mit der Monte-Carlo-Methode aus dem
222 5 Monte-Carlo-Simulationen

vorherigen Abschnitt können wir im Prinzip die kürzeste und in der Praxis eine sehr
kurze Rundreise finden.

Physik
Verteile N Punkte – jeder Punkt entspricht einer Stadt – auf ein Quadrat mit der
Seitenlänge L und markiere einen Rundweg, der jeden Punkt genau einmal berührt.
Wieviele Rundwege gibt es? Eine bestimmte Route ist durch die Reihenfolge der
Punkte festgelegt, und offensichtlich gibt es N ! verschiedene Anordnungen, näm-
lich gerade alle Permutationen der N Punkte. Da jeweils N Startpunkte und zwei
Richtungen dieselbe Weglänge geben, müssen (N 1)!=2 verschiedene Wege be-
trachtet werden. Für N = 100 erhält man etwa 10155 Wege, also viel mehr, als man
jemals auf einem Computer wird durchprobieren können.
N ! wächst schneller als eN und sehr viel schneller als jede Potenz von N . Man
kann sich zwar leicht eine regelmäßige Anordnung der Städte überlegen, bei der die
kürzeste Reise angegeben werden kann, aber für den ungünstigsten Fall sind sich
die Mathematiker fast sicher, daß es keinen Algorithmus gibt, der den kürzesten
Rundweg in einer Anzahl von Schritten berechnet, die wie ein Polynom von N
wächst. N ! wächst wie N 2 (N=e)N . Mit den Methoden der Informatik kann man
1

jedoch das exakte Abzählen der Wege auf etwa N 2 2N Rechenschritte reduzieren,
für N = 100 also auf etwa 1034 Rechnungen. Das ist aber immer noch zuviel selbst
für einen heutigen Superrechner.
Obwohl die numerische Lösung des Problems fast aussichtslos scheint, hat die In-
formatik aber Methoden entwickelt, mit denen in einem konkreten Fall die kürzeste
Rundreise eines Handlungsreisenden, der etwa N = 2500 Städte besuchen soll,
exakt berechnet wurde. Mathematisch läßt sich das TSP so formulieren: cij sei der
Abstand der Punkte i und j , und es sei xij = 1 , falls die Rundreise die Städte i und
j direkt verbindet, xij = 0 sonst. Sowohl cij als auch xij sind also symmetrisch in
den Indizes i und j . Dann suchen wir die kleinste Länge
X
E0 = fmin
x g
cij xij (5.66)
ij
i<j
unter der Nebenbedingung

X
N
xij = 2 für alle i : (5.67)
j =1
Gleichung (5.67) besagt, daß die Reise jede Stadt genau einmal berücksichtigt, die
5.6 Kürzeste Rundreise 223

dementsprechend genau zwei unmittelbare Nachbarn hat. Um disjunkte Teilwege

auszuschließen, muß man noch fordern:
XX
xij 2 für alle S; (5.68)
i2S j 2= S
wobei S eine beliebige echte Teilmenge der Indizes (1; 2; : : : ; N ) ist, ausgenom-
men die leere Menge. Die erfolgreichste Idee zur Lösung des TSP erweitert dieses
diskrete Optimierungsproblem (xij 2f g 2
0; 1 ) auf ein kontinuierliches (xij R),
das mit Standardmethoden der linearen Optimierung gelöst wird, wie wir sie im Ab-
schnitt 1.9 besprochen haben. Durch ständiges Hinzufügen von Nebenbedingungen
kann man schließlich alle kontinuierlichen Variablen xij auf die erlaubten Werte 0
und 1 einschränken. Damit hat man das Problem exakt gelöst.
Der Algorithmus ist sehr kompliziert und erfordert umfangreiche Programmierar-
beit. Hier wollen wir eine andere Methode zur Lösung des TSP vorstellen, die 1982
aus der statistischen Mechanik ungeordneter Magnete (Spingläser) entstanden und
relativ einfach zu programmieren ist. Dazu fassen wir die Variablen xij 2f g
0; 1
als Freiheitsgrade eines Vielteilchensystems mit der Energie H (S ) auf:
X
H (S ) = cij xij : (5.69)
i<j
S = (x12; x13 ; :::xN 1;N ) kennzeichnet eine der (N 1)!=2 möglichen erlaubten
Rundreisen und H ist deren Länge. Wir suchen den Zustand mit der niedrigsten
Energie. Die Physik, insbesondere die Thermodynamik des Festkörpers sagt uns,
wie wir vorgehen sollten: Wir müssen das System aufheizen und es dann sehr lang-
sam abkühlen. Wenn sich das System immer im thermischen Gleichgewicht befin-
det, dann muß es für T ! 0 den Zustand tiefster Energie erreichen. Der vorige
Abschnitt sagt uns auch, wie wir bei diesem Problem das Aufheizen und Abkühlen
bewerkstelligen können, nämlich mit Hilfe der Monte-Carlo-Simulation. Dabei wird
ein stochastischer Prozeß mit einer Übergangswahrscheinlichkeit W (S ! S 0 ) kon-
struiert, die das detaillierte Gleichgewicht mit dem Boltzmann-Faktor P (S ) =
exp( H (S )=T )=Z erfüllt (Gleichung (5.49)). T ist eine formale ”Temperatur“ ,
die dieselbe Einheit wie H (S ), also die einer Länge haben muß.
Im vorigen Abschnitt haben wir gesehen, daß die so erzeugte Folge von Rund-
reisen S (0); S (1); :::; S (t) ins thermische Gleichgewicht relaxiert. Das heißt, die
Wahrscheinlichkeit, den Weg S (t) vorzufinden, ist P (S (t)), wenn t nur groß ge-
nug ist. Nun können wir das System so langsam abkühlen, daß es sich immer im
Gleichgewicht befindet. Bei T = 0 ist offenbar P (S ) nur dann von Null verschie-
den, wenn H (S ) die niedrigste Energie (= den kürzesten Weg) annimmt.
Wenn wir also nur langsam genug abkühlen, dann finden wir mit Sicherheit die
kürzeste Rundreise. Was aber ist langsam genug“ ? Das ist nur schwer zu beant-
”
224 5 Monte-Carlo-Simulationen

worten. Wenn wir durch den Raum aller Wege S wandern und H (S ) als Höhe anse-
hen, dann ist H (S ) ein komplexes Gebirge mit vielen Tälern, Seitentälern, Schluch-
ten und Schächten. Laufen wir also nur den Berg hinab, so werden wir mit hoher
Wahrscheinlichkeit in einem Nebental weit weg vom absoluten Minimum landen.
Die Monte-Carlo-Methode (bei T > 0) erlaubt hingegen auch mit einer gewissen
Wahrscheinlichkeit, die vom Höhenunterschied abhängt, Schritte bergauf. Wie lan-
ge aber dauert es, einen hohen Bergkamm zu überschreiten, um in ein tieferes Tal
zu kommen?
Diese Zeit kann wie im vorigen Abschnitt mit dem Arrhenius-Gesetz abgeschätzt
werden. Sei E > 0 die zu überwindende Höhendifferenz. Dann ist eine typische
Zeit
= 0 eE=T : (5.70)
Beim Abkühlen müssen wir dem Wanderer Zeit lassen, die Bergkämme zu über-
schreiten. Durch Umkehren der Gleichung (5.70) sehen wir, daß ein für die Simula-
tion entworfener Abkühlplan T (t) – dabei sei t die aktuelle Rechenzeit – möglichst
die Ungleichung
T (t) Et : (5.71)
ln 0
erfüllen sollte. Die Temperatur T darf daher als Funktion der Zeit t nur extrem
langsam sinken, um thermisches Gleichgewicht zu garantieren. In der Praxis wird
man nie so viel Rechenzeit aufwenden können, um das thermische Gleichgewicht
perfekt zu simulieren. Aber wenn wir nur dicht beim Gleichgewicht bleiben können,
werden wir dennoch eine Energie finden, die fast die Grundzustandsenergie erreicht.
Die Weglänge wird also fast optimal sein, während der tatsächliche Weg ganz anders
als der optimale aussehen kann.
Mit wenig Programmieraufwand und geringem Wissen über das Problem, aber
mit viel Rechenzeit, kann man daher mit dieser Methode des Simulierten Ausglü-
”
hens“ (simulated annealing) ein gutes lokales Minimum eines komplexen kombina-
torischen Optimierungsproblems finden. Die Methode kann leicht auf viele andere
Probleme dieser Art angewandt werden, sie konkurriert zur Zeit allerdings mit so-
genannten genetischen Optimierungsalgorithmen, die mit Populationen von Wegen
arbeiten.
Bevor wir die Einzelheiten des Algorithmus besprechen, wollen wir die kürzeste
Rundreise für den Fall abschätzen, daß N Städte zufällig und unkorreliert im Qua-
drat der Kantenlänge L verteilt sind. Wenn wir zu jeder Stadt i den Abstand ri zum
nächsten Nachbarn bestimmen, dann gilt offenbar für die kleinste Länge:

X
N
E0 ri : (5.72)
i=1
5.6 Kürzeste Rundreise 225

Für N !1 hi
kann die rechte Seite als N r geschrieben werden, wobei r der hi
hi
mittlere Nächste-Nachbar-Abstand ist. Wir wollen nun r berechnen, dabei aber
den Effekt des Randes vernachlässigen und dazu einen genügend großen Ausschnitt
der Ebene betrachten, auf der Städte mit der Dichte = N=L2 verteilt sind. Sei
w(r)dr die Wahrscheinlichkeit, daß die nächste Nachbarstadt einen Abstand zwi-
schen r und r + dr hat. w(r )dr ist also die Wahrscheinlichkeit, zwischen null und
r keinen nächsten Nachbarn zu finden, multipliziert mit der Wahrscheinlichkeit, in
dem Kreisring mit der Fläche 2r dr eine Stadt zu finden:
2 Zr 3
w(r) dr = 41 w(r0 ) dr0 5 2r dr : (5.73)
0
Diese Integralgleichung für w(r ) läßt sich unmittelbar in eine Differentialgleichung
für f (r) = 1
Rr w(r0 ) dr0 umwandeln, wenn man f 0(r) = w(r) benutzt,
0
nämlich
f 0 = 2 r f mit f (0) = 1 : (5.74)
Als Lösung erhalten wir

f (r ) = e r2 und
w(r) = 2r e r : 2
(5.75)

Der mittlere Abstand der nächsten Nachbarn ist durch w(r ) gegeben:
Z1 Z1 1 = 1 pL :
hri = r w(r) dr = 2 e r2 r 2 dr = p
2 2 N (5.76)
0 0
Damit gilt nach Gleichung (5.72) für die Länge E0 der kürzesten Rundreise (im
Limes N !1 )
p
E0 12 L N : (5.77)

Berücksichtigt man entsprechend die übernächsten Nachbarn, so ändert sich der p

Vorfaktor zu 0:599 : : : In jedem Fall erhält man aber das Skalenverhalten L N , so
daß man verschiedene Systemgrößen L und Städtezahlen N miteinander verglei-
chen kann. Den genauen Wert der skalierten Länge

l = Ep0 (5.78)
L N
kann man bis heute nur numerisch bestimmen, z. B. finden Percus und Martin l=
0:7120 0:0002 im Limes N ! 1.
226 5 Monte-Carlo-Simulationen

Algorithmus
Wie im vorigen Abschnitt müssen wir uns einfache Änderungen des Zustandes S
überlegen. Erlaubte Wege kann man durch ein Feld darstellen, das die Reihenfolge
enthält, mit der die Städte besucht werden,

S = (i1 ; i2 ; :::; iN ) ; (5.79)

wobei ik 2f g
1; :::; N die Nummer der Stadt ist. Es gibt viele Möglichkeiten, aus
einer Rundreise S eine etwas geänderte S 0 zu konstruieren. Hier wollen wir der
Einfachheit halber nur die folgende vorstellen: Wir wählen zufällig eine Position p
und eine Länge l N=2, trennen den Abschnitt ip :::ip+l aus dem Weg S heraus
und fügen ihn in umgekehrter Reihenfolge wieder ein,

S 0 = (i1 ; :::; ip 1 ; ip+l ; ip+l 1 ; :::; ip ; ip+l+1 ; :::; iN ) : (5.80)

Dabei ist p + l modulo N zu nehmen. Dieser Zug ist in Bild 5.12 dargestellt.
Mit N = 6 , p = 3 und l = 2 wird die Rundreise S = (1; 2; 3; 4; 5; 6) zu
S 0 = (1; 2; 5; 4; 3; 6). Wiederholte Anwendung dieses Zuges führt offenbar durch
die gesamte Menge aller möglichen Wege und kann alle Kreuzungen beseitigen.
Damit haben wir alles, was wir zur Anwendung der im vorigen Abschnitt beschrie-

2 2

1 1
3 3

6 6

4 4
5 5

5.12 Schrittweise Änderung der Rundreise bei der Monte-Carlo-Simulation.

benen Monte-Carlo-Simulation benötigen. Jeder versuchte Zug wird akzeptiert, falls
die neue Rundreise kürzer ist H (S 0 ) H (S ) oder eine Zufallszahl r [0; 1]
kleiner als der Boltzmann-Faktor exp

H (S 0 ) H (S ) =T ist.
2
Im letzteren Fall müssen wir jedes Mal sowohl eine Zufallszahl r als auch die
Funktion exp(:::) berechnen. Beides kann man vermeiden, indem man den Boltz-

mann-Faktor durch eine Stufenfunktion T H (S 0 ) H (S ) ersetzt. Der Zug
S S wird also immer akzeptiert, wenn die Energiedifferenz H (S 0 ) H (S) klei-
! 0
ner als T ist. Für diese Vereinfachung kennen wir keine theoretische Begründung,
5.6 Kürzeste Rundreise 227

sie wird aber seit kurzem bei der kombinatorischen Optimierung erfolgreich ange-
wandt.
Das C-Programm travel.c berücksichtigt beide Methoden. Im Quadrat der
Länge L werden N Städte zufällig verteilt. Die Koordinaten (x; y ) jeder Stadt sind
im Feld map mit der Struktur city deklariert:
typedef struct {int x,y;} city;
city map[MAXCITIES];
N ist auf den Wert 100 gesetzt, es kann aber auch als Parameter beim Aufruf von
travel übergeben werden. Dies geschieht mit
main(int argc,char *argv[])
{
...
if(argc>1) N=atoi(argv[1]);
...
Die Reihenfolge der Städte wird im Feld int path[N] festgelegt. Am Anfang
werden die Koordinaten (x; y ) der Städte zufällig und der Startweg als S = (0; 1;
: : : ; N 1) gewählt. Die Hauptschleife sieht dann folgendermaßen aus:
while (!done)
{
event();
anneal(path);
if(count++ > DRAW)
{
drawpath(path);
oldlength = length(path);
print(oldlength);
if(aut) temp = .999*temp;
count=0;
}
}
Die Funktion event() fragt den Tastaturpuffer ab. Bei laufendem Programm sind
folgende Aktionen möglich: Herauf- oder Heruntersetzen der Temperatur um 10%,
Wahl der Methode Boltzmann-Faktor oder Schwellenfunktion, Umschalten auf auto-
matische Temperaturerniedrigung und das Speichern der aktuellen Rundreisekonfi-
guration. Schließlich kann man noch die Temperatur auf den Wert temp=0 springen
lassen. Dann werden nur noch solche Züge akzeptiert, die die Weglänge verringern.
Die Funktion anneal(path) berechnet den nächsten Monte-Carlo-Schritt. Es
werden zufällig die Position pos und die Länge len gewählt, die benötigt werden,
228 5 Monte-Carlo-Simulationen

um mit change(newpath,oldpath,pos,len) die neue Rundreise erzeugen

zu können. Weiterhin definieren wir eine Funktion changed_length(...), um
die Länge des neuen Weges zu bestimmen. Am effektivsten programmiert man die-
se Funktion, indem man nur die Längenänderung gegenüber der alten Konfigura-
tion berechnet. Um der Anhäufung von Rundungsfehlern vorzubeugen, wird in re-
gelmäßigen Abständen mit length(path) die Weglänge von Grund auf neu be-
rechnet. Der ausgewürfelte Weg wird akzeptiert, wenn für den Unterschied de der
beiden Weglängen gilt:

(ann == 1 && (de < 0 || frand() < exp(–de/temp))) ||

(ann == 0 && de < temp)

Falls diese Größe wahr ist, also den Wert 1 hat, wird durch die Standardfunktion
memcpy der neue Weg in den alten kopiert, der Zug S ! S 0 wird akzeptiert.
Insgesamt lautet die Funktion

void anneal( int oldpath[] )

{
double newlength,de,lscal;
int pos,len,newpath[MAXCITIES];

pos=rand()*f1;
len=rand()*f2;
change(newpath,oldpath,pos,len);
newlength=changed_length(oldlength,oldpath,pos,len);
de=newlength–oldlength;
if(de==0.) return;
if((ann==1 && (de < 0 || frand() < exp(–de/temp))) ||
(ann==0 && de < temp))
{
memcpy(oldpath,newpath,N*sizeof(int));
oldlength=newlength;
flipcount++;
}
}

f1 und f2 sind vorher definierte Skalierungsfaktoren und frand() ist ein Zufalls-
zahlen-Generator, der gleichverteilte reelle Zahlen im Einheitsintervall erzeugt. Er
kann z. B. am Anfang des Programms mit

#define frand() (double)rand()/(RAND_MAX+1.)

definiert werden.
5.6 Kürzeste Rundreise 229

Die neue Rundreise wird erzeugt, indem zunächst die alte Rundreise (op) in die
neue (np) kopiert wird. Dann wird zwischen pos und pos+len die Reihenfolge
der Städte umgedreht. Das sieht so aus:
void change(int np[],int op[],int pos,int len)
{
int i,j;

memcpy(np,op,N*sizeof(int));
j=len;
for(i=0;i<=len;i++)
{
np[(pos+i) % N]=op[(pos+j) % N];
j––;
}
}
Die Berechnung der Weglänge ist offensichtlich:
double length(int path[] )
{
int i,j;
double l=0.,dx,dy;

for(i=0;i<N;i++)
{
j=(i+1)%N;
dx=map[path[i]].x–map[path[j]].x;
dy=map[path[i]].y–map[path[j]].y;
l+= sqrt(dx*dx+dy*dy);
}
return (l);
}
Weitere Funktionen drawpath und print zeichnen den Weg bzw. schreiben Text
in das Graphikfenster. Nach dem Kompilieren können wir mit dem Aufruf travel
die Suche nach der kürzesten Rundreise auf dem Bildschirm beobachten und dabei
die Temperatur hoch- und herunterfahren.

Ergebnisse
Wir haben die Daten aus travel.dat mit Mathematica eingelesen und gezeich-
net. Der zufällig erzeugte Startzustand von etwa 100 Städten ist in Bild 5.13 zu se-
230 5 Monte-Carlo-Simulationen

hen. Die skalierte Weglänge l, Gleichung (5.78), hat den Wert l ' 4:8. Wir starten

5.13 Zufällig gewählter Startzustand mit

der skalierten Länge l = 4:8

bei einer Temperatur von L/8. Schon bei dieser relativ hohen Temperatur relaxiert
das System schnell auf den Wert l ' 2:2, dabei werden etwa 20% der versuchten
Züge akzeptiert. Durch langsames automatisches Abkühlen, wobei die Temperatur
nach jeweils 100 Versuchen um 10=00 erniedrigt wird, gelangt das System nach et-
wa 30 Minuten Rechenzeit auf unserem PC in die Zustände Bild 5.14 bzw. Bild
5.15. Beide Rundreisen sind lokale Minima im Energiegebirge, d. h. alle unsere

5.14 Rundreise nach dem simulierten Ausglühen

mit dem Boltzmann-Algorithmus. Die skalierte
Länge ist nun l = 0:883.

Wegänderungen S ! S 0 geben immer nur längere Reisen, die bei T = 0 nicht

mehr akzeptiert werden. In diesem Fall – und in den meisten anderen – ergab der
schnelle Schwellenalgorithmus einen etwas niedrigeren Wert (l = 0:858) als die
langsamere Metropolis-Methode (l = 0:883). Geht man von Anfang an im kom-
plexen Energiegebirge H (S ) nur bergab (temp=0), so erhält man einen längeren
5.6 Kürzeste Rundreise 231

5.15 Wie Bild 5.14, aber mit dem Schwellen-

Algorithmus. Das Ergebnis ist eine etwas kürzere
Rundreise mit l = 0:858

Weg (l = 0:909), allerdings sehr viel schneller als mit den beiden Abkühlverfahren.
Bild 5.16 vergleicht die beiden Resultate der Abbildungen 5.14 und 5.15. Obwohl

5.16 Vergleich der beiden optimierten Rundrei-

sen aus den Abbildungen 5.14 (dünn) und 5.15
(dick). Obwohl die beiden Kurven fast gleich
lang sind, sind sie doch deutlich voneinander
verschieden.

die Längen der beiden Rundreisen fast gleich sind, sind die Reiserouten deutlich
voneinander verschieden. Wiederholt man die Simulation mit anderen Zufallszah-
len (bei denselben Städten), so erhält man fast die gleiche Weglänge aber wieder
eine ganz andere Reihenfolge der Städte.
Wir haben die Skalierung Gleichung (5.77) überprüft, indem wir eine Rundreise
p
mit 300 Städten simuliert und mit dem Schwellenalgorithmus langsam abgekühlt
haben. Das Ergebnis l = 0:826 bestätigt die Skalierung E0 / N.
Natürlich wissen wir nie, ob wir wirklich die kürzeste Rundreise gefunden haben.
Um diese Frage zu beantworten, benötigen wir die relativ aufwendigen Methoden
der Informatik. Um aber bei einem noch wenig verstandenen Optimierungsproblem
mit geringem Aufwand eine gute Lösung zu erhalten, kann man simulated annea-
ling wohl empfehlen.
232 5 Monte-Carlo-Simulationen

Übung
Hier soll versucht werden, das Optimierungsproblem aus Abschnitt 1.3 mit der Me-
thode des simulated annealing zu lösen. Es soll ein Signal mit gegebenem Lei-
stungsspektrum übertragen werden, und dabei soll die Spitzenspannung möglichst
klein gehalten werden.
Von der an N = 64 diskreten Zeitpunkten abgetasteten Spannung U1 ; : : : ; UN
f g
sei deren Fouriertransformierte b1 ; : : : ; bN , bzw. das Leistungsspektrum bekannt:
j j j j
bs 2 = bN s+2 2 = 1 für s = 9; 10; : : : ; 17 und bs = 0 sonst. Damit das Span-
f g
nungssignal U1 ; : : : ; UN reell ist, muß bN s+2 = bs gelten.
Gesucht sind die Phasen 's , die mit bs = ei's eine minimale Spitzenspannung
j j
geben, es soll also der Wert von minf's g (max r Ur ) bestimmt werden.
Der Zustand S aus Abschnitt 5.5 ist nun eine Konfiguration möglicher Pha-
sen ('9 ; : :; '17 ), und der Energie entspricht hier die Spitzenspannung H (S ) =
j j
max r Ur . In jedem Monte-Carlo-Schritt wird die Konfiguration der Phasen zufäl-
lig geändert, z. B. durch Variation einer einzelnen, beliebig herausgegriffenen Phase.
Dies liefert eine Energieänderung, und der Algorithmus aus Abschnitt 5.5 entschei-
det daraufhin, ob die neue Konfiguration akzeptiert wird.
Das bisher beste, von einem unserer Studenten erzielte Ergebnis liegt bei H =
0:739545 . Wer diesen Wert unterbietet, möge uns dies bitte mitteilen.

Literatur
A. G. Percus, O. C. Martin, Dimensional Dependence in the Euclidean Travelling
Salesman Problem, Physical Review Letters 76, 1188 (1996).
W.H. Press, S.A. Teukolsky, W.T. Vetterling, B.P. Flannery, Numerical Recipes in
C: The Art of Scientific Computing, Cambridge University Press, 1992.
J. Schnakenberg, Algorithmen in der Quantentheorie und Statistischen Physik, Zim-
mermann-Neufang, 1995.
Anhang A
Erste Schritte mit Mathematica

Auf fast allen Rechnern wird Mathematica mit dem Befehl math aufgerufen. Bei
Systemen mit einer graphischen Oberfläche geschieht dies manchmal indirekt durch
das Anklicken eines Symbols. Mathematica meldet sich danach mit In[1]:= und
erwartet eine Eingabe, die mit R ETURN abgeschickt wird. Die Notebook-Version
von Mathematica verhält sich insofern etwas anders, als hier einzelne oder meh-
rere Befehle mit S HIFT-R ETURN übergeben werden. Mathematica ist eine inter-
pretierende Programmiersprache, bearbeitet also sofort die Eingabe und präsentiert
das Ergebnis in der Form Out[..]= : : : auf dem Bildschirm. Dabei werden alle
Ausdrücke, die vorher in derselben Sitzung definiert wurden, berücksichtigt. Man
beendet eine Mathematica-Sitzung mit In[..]:= Quit. Der Befehl Exit bzw.
C ONTROL-D auf Unix-Systemen bewirkt dasselbe.

Das Kommando math startet eine Mathematica-Sitzung.

In[..]:= Quit beendet die Sitzung.

Simple Arithmetik
In[1]:= 4 + 7
Out[1]= 11
In[2]:= 3 4.2 Leerstelle = Multiplikation
Out[2]= 12.6 Dezimalzahlen mit Dezimalpunkt
In[3]:= 234 Auch = Multiplikation
Out[3]= 24
In[4]:= 24/8 / = Division
Out[4]= 3
In[5]:= 2 3 ^ ^ = Potenz
Out[5]= 8
234 Anhang A

^
In[6]:= (3+4) 2 2(3+1)
Out[6]= 41
In[7]:= %/5 % = das letzte ausgegebene Resultat
41
Out[7]=
5
In[8]:= N[%] N[x] = numerischer Wert von x
Out[8]= 8.2
In[9]:= 22.4/(6.023 10 23) ^
Out[9]= 3.71908 10–23
In[10]:= 3 ^ 236+4
”
Potenz“ vor Punkt“ vor Strich“
” ”
Out[10]= 8

Die wichtigsten Funktionen

In[11]:= Sqrt[16] Sqrt[x] =

px
Out[11]= 4
In[12]:= N[Pi/2] Pi = Mathematica-Form von
Out[12]= 1.5708
In[13]:= Sin[%] Sin[x] = sin x
Out[13]= 1. 1. = 1.0

Alle in Mathematica vorhandenen Funktionen, Prozeduren, Konstanten, ...

beginnen mit einem Großbuchstaben.
Funktionsargumente stehen jeweils in eckigen Klammern [ ] .

In[14]:= Cos[Pi/4] Cos[x] = cos x

Sqrt[2]
Out[14]= Exakter Wert
2
In[15]:= Exp[0.5] Exp[x] = Exponentialfunktion von x
Out[15]= 1.64872 Numerischer Wert
In[16]:= Log[%] Log[x] = ln x
Out[16]= 0.5
Erste Schritte mit Mathematica 235

In[17]:= ?Log
Log[z] gives the natural Logarithm of z (logarithm to
base E). Log[b, z] gives the logarithm to base b.
In[17]:= Log[E, %15] %15 ist dasselbe wie Out[15]. Alle wäh-
rend einer Sitzung erzeugten In[n] und
Out[n] sind wieder aufrufbar.
Out[17]= 0.5

Hilfen in Mathematica erhält man mit dem Fragezeichen (?)

In[..]:= ?Log !
Informationen zu Log[x].
In[..]:= ??Log !
Mehr Informationen zu Log[x].
In[..]:= ?L !
Alle Funktionen, die mit L beginnen.
In[..]:= ? !
”
Alles“ wird aufgelistet.

In[18]:= Sqrt[ 1]
Out[18]= I
In[19]:= ?I
I represents the imaginary unit Sqrt[–1].
In[19]:= Exp[IN[Pi/4]]
Out[19]= 0.707107 + 0.707107 I
In[20]:= Re[%]+IIm[%] Re[z] = Realteil von z
Im[z] = Imaginärteil von z
Out[20]= 0.707107 + 0.707107 I
In[21]:= ?Arc
ArcCos ArcCot ArcCsc ArcSec ArcSech ArcSin ArcSinh
ArcTan ArcTanh ArcCosh ArcCoth ArcCsch
In[21]:= ArcTan[1] ArcTan[x]= arctan x
Pi
Out[21]=
4

Graphik
Wir verzichten im folgenden auf die Kennzeichnung von Ein- und Ausgaben durch
das In[..] bzw. Out[..] am Zeilenanfang. Eingaben an den Rechner sind durch
Fettdruck kenntlich gemacht, alles andere sind Ausgaben vom Rechner oder unsere
Kommentare.
236 Anhang A

Plot[Sin[x], fx, 0, 2Pig] Zeichnung der Funktion sin x .

Plot[fBesselJ[0,x], BesselJ[1,x]g, fx, 0, 10g] Die Bessel-
funktionen J0 (x) und J1 (x) in einem Plot.
^ ^
Plot3D[Exp[ (x 2+y 2)], fx, 2, 2g, fy, 2, 2g] Dreidi-
mensionaler Plot der 2-dimensionalen Gaußfunktion exp[ (x2 + y2 )] .
ParametricPlot[fCos[t], Sin[t]g, ft, 0, 2Pig] Parameter-
Plot eines Kreises. Auf dem Bildschirm erscheint eine Ellipse, weil das Achsen-
verhältnis ungleich 1 ist.
Show[%, AspectRatio > Automatic] Jetzt ist es ein Kreis.
Show[..] zeigt Graphikobjekte mit den entsprechenden Optionen.
ParametricPlot3D[fCos[t],Sin[t],t/6g, ft,0,6Pig]
Eine Schraubenlinie in 3 Dimensionen.
ParametricPlot3D[fr Cos[t],r Sin[t],r 2g, ^
fr,0,2g,ft,0,2Pig]
Ein Rotationsparaboloid als Fläche in 3 Dimensionen.
^ ^
ContourPlot[Exp[ (x 1) 2 y 2]+ Exp[ (x+1) 2 y 2], ^ ^
fx, 3,3g,fy, 3,3g, PlotPoints > 60]
Höhenlinien. PlotPoints –> 60 ist eine optionale Angabe.
Options[Plot] Eine Liste der Optionen zu Plot[..].

Die wichtigsten Plot-Befehle:

Plot[f, fx, xmin, xmaxg]
Plot3D[f, fx, xmin, xmaxg, fy, ymin, ymaxg]
ParametricPlot[ffx, fyg, ft, tmin, tmaxg]
ParametricPlot3D[ffx,fy,fzg, ft, tmin, tmaxg]
ParametricPlot3D[ffx,fy,fzg, fs,s1,s2g, ft,t1,t2g]
ContourPlot[f, fx, xmin, xmaxg, fy, ymin, ymaxg]

Symbole und eigene Funktionen

n = 20! ! 2432902008176640000 , k!= Faktorial[k]= k-Fakultät.

N[n] ! 2.4329 1018 , die Variable n hat den Wert 20!
Erste Schritte mit Mathematica 237

a = Random[] !0.296851 , Random[] erzeugt Zufallszahlen zwischen

0 und 1. Der Variablen a wurde die Zahl 0.296851 zugewiesen.
N[a, 13] !0.2968512129099 , die Zahl a mit 13 Stellen. Falls nicht
anders angegeben, werden Dezimalzahlen intern mit 16 Stellen verarbeitet.
Clear[a,n] löscht die Belegung der Variablen a,n .
c = (a+b) 3 ^ !
(a + b)3
c = Expand[c] ! a3 + 3 a2 b + 3 a b 2 + b3
f[x ]:= Exp[ 0.25 x2 ] Cos[4.5 x] So definiert man Funktionen. x
ist ein Platzhalter‘ mit dem Namen x . Der Unterstreichungsstrich bei x ist wich-
’
tig. Er darf nur auf der linken Seite der Gleichung auftauchen. Statt des Zeichens
:= hätten wir hier auch das Zeichen = verwenden können.
f[1.5] ! 0.50882 , Funktionswert von f für x = 1:5 .
Plot[f[x],fx, Pi,Pig] Plot der oben definierten Funktion f. Statt x
kann man hier auch einen beliebigen anderen Variablennamen verwenden. Mit dem
f g
Befehl Plot[f[t], t,–Pi,Pi ] erreicht man dasselbe.
fermi[e ,b ]:= 1/(Exp[b(e 1)] + 1) Eine Funktion mit zwei Varia-
blen.
Plot[ffermi[e,10], fermi[e,Infinity]g, fe,0,1.7g] Plot zwei-
er Fermifunktionen. Infinity = + . 1

Der Unterschied von := und = an einem Beispiel:

a = Random[]
Die rechte Seite wird ausgewertet, und der Variablen a wird diese Zufallszahl
zugewiesen. Wiederholter Aufruf von a liefert jedesmal diese Zahl.
r:= Random[]
Die rechte Seite wird zunächst nicht ausgewertet, sondern erst dann, wenn die
Variable r erneut aufgerufen wird. Bei jedem Aufruf von r wird die rechte
Seite erneut ausgewertet. Es wird jedesmal eine neue Zufallszahl produziert.

Listen
numlist = f2,3,4g Eine Liste von drei Zahlen. Listen werde mit geschweif-
ten Klammern fg
geschrieben.
238 Anhang A

Head[numlist] ! List . Jedes Ding hat einen Kopf. numlist ist eine
Liste.
numlist 2 ^ ! f4,9,16g . Fast alle Funktionen sind Listable .
Log[numlist] // N ! Liste der Logarithmen
Table[2, f7g] ! f2,2,2,2,2,2,2g . Table[..] macht Listen.
Table[i^3, fi,5g] ! f1, 8, 27, 64, 125g
Table[1/j, fj,3,8g] ! f 13 , 14 , 15 , 16 , 17 , 18 g
Table[x, fx,0,2,0.25g] ! f0, 0.25, 0.5, ..., 2.g
Table[expr, f..g] erzeugt Listen. Die geschweifte Klammer mit
der allgemeinen Form fi, imin, imax, dig heißt ’iterator’.
Verkürzungen der allgemeinen Form sind möglich.

liste = Table[fx, Gamma[x]g, fx,2,4,0.05g];

Ein Semikolon (;) nach einem Ausdruck unterdrückt das nächste Out[..].
Trotzdem haben die Variablen die zugewiesenen Werte.

ListPlot[liste] ListPlot[..] plottet Daten.

letters = Table[FromCharacterCode[j], fj,122,97, 1g]
z,y,x,w, ... !f g
Sort[letters] !f a,b,c,d, ... g. Sort[..] sortiert, nicht nur
Buchstaben, sondern auch Zahlen.
letters[[3]] ! x , das 3. Element der Liste letters . Teile von Listen
oder von Ausdrücken bezeichnet man mit doppelten eckigen Klammern [[..]] .
Length[liste] ! 41 , die Länge der Liste liste .
liste[[20]] ! f2.95, 1.91077g
liste[[20,1]] ! 2.95
liste[[20,2]] ! 1.91077
abc = Reverse[letters] ! fa,b,c,d,...g
abc[[f2,4,6g]] ! fb,d,fg
Erste Schritte mit Mathematica 239

abc[[ 1]] ! z . Ein negativer Index entspricht der Zählung von hinten.
Permutations[f1,2,3g] ! f g
alle Permutationen von 1,2,3 .

Speichern, Einlesen, Fitten von Daten

Clear["Global‘"] Löscht alle selbstdefinierten Variablen und Funktionen.

f[x ] = 1.0 x 4 ^ ^
2.0 x 2 + 0.5 Ein Polynom vierten Grades.
?f ! die Definition von f[x].
p1 = Plot[f[x], fx, 1.5,1.5g]
r:= Random[Real, f 0.1,0.1g] Random[] (ohne Argument) liefert ei-
ne reelle Zufallszahl zwischen 0 und 1. Random[Type,Range] ist die allgemei-
nere Form.
daten = Table[fx, f[x]+rg, fx, 1.5,1.5,0.05g] // Chop
Verrauschte Daten. Chop ersetzt reelle Zahlen, die sich von 0 um weniger als 10 10
unterscheiden, durch 0.
p2 = ListPlot[daten]
Show[p1,p2] Show[..] kann Graphikobjekte kombinieren.
^ ^ ^
g[x ] = Fit[daten, f1,x,x 2,x 3,x 4g, x] Fit[..] liefert ei-
nen linearen least square Fit.
Plot[ff[x],g[x]g,fx, 1.5,1.5g,
PlotStyle > fRGBColor[0,0,0],RGBColor[1,0,0]g]
Originalkurve schwarz, Fitkurve rot.
daten >> liste.dat Mathematica-Objekte lassen sich mit >> filename
speichern.
!ls So schickt man von einer Mathematica-Sitzung aus Befehle ans Betriebssy-
stem.

!Befehl bewirkt, daß der Befehl ans Betriebssystem geht.

!!filename bringt den Inhalt von filename auf den Bildschirm.

!!liste.dat
daten2 = << liste.dat Das Gegenstück zu >> ist der Befehl << . Man
240 Anhang A

kann damit gespeicherte Mathematica-Objekte einlesen.

daten2 == daten ! True. == ist das logische Gleichheitszeichen.
OutputForm[TableForm[daten]] >> messdaten.dat
!!messdaten.dat messdaten.dat könnte ein Datenfile sein, das bei
einer Messung erzeugt wurde.
data = ReadList["messdaten.dat",fReal,Realg] ReadList[..]
macht aus Daten eine Mathematica-Liste, hier eine Liste von Zahlenpaaren.
^
model[x ] = a + b x + c x 2 + d x 3 + e x 4 ^ ^ Wir definieren
eine Modellfunktion, deren Parameter wir anpassen wollen.
Needs["Statistics‘NonlinearFit‘"] Auf diese Weise wird das packa-
ge NonlinearFit.m geladen.
regel = NonlinearFit[data,model[x],x,fa,b,c,d,eg] Die Pro-
zedur NonlinearFit[..] liefert eine Liste von Regeln, in der die optimalen
Parameterwerte stehen.
h[x ] = model[x] /. regel So wendet man Regeln an. Die Funktion
h[x]ist in diesem Fall nahezu identisch mit g[x].

Einfache Mathematica-Programme

Wir gehen davon aus, daß mit einem Texteditor eine Datei programm1.m mit
dem folgenden Inhalt erzeugt wurde:

( So schreibt man Kommentare in MATHEMATICA )

Clear["Global‘ "]
( Löscht alte Definitionen )
f[x ]:= Tan[x/4]–1
f
Plot[f[x], x,2,4g]
f
r = FindRoot[f[x]==0, x,3.1g] ( 3.1 = Startwert )
pi = x /. r

<< programm1.m !Plot von f[x] und 3.14159, eine Approximation

von . FindRoot[..] findet numerische Lösungen von Gleichungen.
N[pi Pi] !8.88178 10–16
Das nächste Programm, gespeichert als programm2.m , verwendet die Mathema-
tica-Funktion Block[..] und berechnet die ersten k Nullstellen der Besselfunk-
Erste Schritte mit Mathematica 241

tion Jn (x). Es benutzt die Tatsache, daß für n > 0 die erste Nullstelle von Jn (x)
etwa bei n + 1:9 n1=3 liegt und daß die folgenden Nullstellen alle ungefähr den
Abstand haben.

besselnull[n ,k ]:=
f
Block[ f,start,regel,nullstelle,liste , g
f[x ] = BesselJ[n,x];
start = If[n==0, 2.5, n + 1.9 nˆ(1/3)];
regel = FindRoot[f[x]==0, x,start ]; f g
nullstelle = x /. regel; liste =
fnullstelle ; g
While[Length[liste] < k,
start = liste[[–1]] + Pi;
regel = FindRoot[f[x]==0, x,start ]; f g
nullstelle = x /. regel;
AppendTo[liste,nullstelle] ];
If[n > 0, PrependTo[liste,0]];
f
Plot[f[x], x,0,liste[[–1]]+1 ]; g
liste ]

<< programm2.m
besselnull[3,4] ! Plot von J3 (x) und eine Liste der ersten vier Null-
stellen von J3 (x) .

Schleifen und if-Anweisungen

Do[Print["Hello World"],f20g] ! Schreibt 20 mal Hello World

auf den Bildschirm.

Schleifen:
Do[expr, f’iterator’g]
For[start, test, incr, body]
While[test, body]
Nest[f, expr, n]
NestList[f, expr, n]
FixedPoint[f, expr]
242 Anhang A

s1 = " "; s2 = " ASCII Code "; s1 und s2 sind Strings.

Do[Print[s1,FromCharacterCode[j],s2,j],fj,65,75g]
Schreibt die ersten 11 Großbuchstaben und deren ASCII-Code auf den Bildschirm.
For[i=1, i < 11, i++, Print[i," ^
",i 2]] ! Produziert die
Zahlen von 1 bis 10 und deren Quadrate.
test:= (a = Random[]; a < 0.8)
While[test, Print[a]] ! Im Mittel vier Zufallszahlen zwischen 0 und
0.8.
Nest[Sin, t, 3] ! Sin[Sin[Sin[t]]]
Nest[Sin, 1.5, 30] Wie oben, jedoch 30 mal iteriert und mit Startwert 1.5.
NestList[Sin, 1.5, 30] NestList[..] ergibt eine Liste aller bei der
Iteration berechneten Werte.
f[x ]:= N[Cos[x],18] Numerischer Wert von cos x mit 18 Stellen.
FixedPoint[f,1/10] ! 0.739085133215160642, dasjenige x, für
das mit hinreichender Genauigkeit cos x = x gilt.
If[Random[] < 0.5, Print["Zahl < 0.5"]]
^
beep:= Print["n G"]; beepbeep:=(beep;Pause[1];beep)
If[Random[] < .5, beep, beepbeep]
theta[x ]:= If[x <= 0, 0, 1] Definition der -Funktion.
Plot[theta[x],fx, 2,2g,AspectRatio > Automatic]

Differentiation, Integration, Taylorreihen

Clear["Gobal‘"]
^
D[Exp[x 2], x] ! die Ableitung von exp(x2 ) nach x.

^ ! 1
Integrate[1/(x 4 1), x]
x
das unbestimmte Integral von 4
1.
Simplify[D[%,x]] ! der Integrand des obigen Integrals. Simplify[..]
bringt auf den Hauptnenner, kürzt gemeinsame Faktoren und versucht, das Ergebnis
auf eine möglichst einfache Form zu bringen.
Integrate[Exp[cx],fx, a, bg] ! das bestimmte Integral von ec x
Erste Schritte mit Mathematica 243

bezüglich x in den Grenzen von a bis b .

Integrate[Sin[Sin[x]],fx, 0, 1g] Ohne Erfolg.
NIntegrate[Sin[Sin[x]],fx, 0, 1g] ! 0.430606 , numerische
Integration mit NIntegrate[..] .
^ ^
Integrate[xyExp[ (x 2 + y 2)],fx,0,2.0g,fy,0,xg] Ein
Doppelintegral mit dem Wert 0.120463 . Es wird zuerst über y integriert. Die
Grenzen dieser y -Integration dürfen die innere Integrationsvariable x enthalten.
reihe = Series[Tan[x], fx, 0, 10g] !
die Reihenentwicklung
von tan x um x = 0 bis zum Term der Ordnung x plus O[x]11 , das die weg-
10
gelassenen Terme höherer Ordnung repräsentiert.
Head[reihe] ! SeriesData , ein eigenes Mathematica-Objekt, kein Po-
lynom.
Normal[reihe] Normal[..] macht daraus ein Polynom.
Timing[Series[Exp[Sin[x]], fx,0,80g];] ! f11.54 Second,
Null g
Timing[Series[Exp[Sin[1.0x]],fx,0,80g];] 0.47 ! f
g
Second, Null , numerische Ergebnisse sind oft viel schneller berechenbar als
exakte.

Vektoren, Matrizen, Eigenwerte

Remove["Global‘"] Remove[..] ist noch radikaler als Clear[..] .

v = fx,y,zg Vektoren schreibt man als Listen.
r = Table[x[j],fj,3g] ! fx[1], x[2], x[3] g
b = Table[1/(i+j),fi,3g,fj,3g] Matrizen stellt man dar als Listen
von Listen.
MatrixForm[b] ! die Matrix b .
d = DiagonalMatrix[fd1,d2,d3g] ! eine Diagonalmatrix mit den
Diagonalelementen d1, d2, d3.
IdentityMatrix[3] ! die 3 3-Einheitsmatrix.
Transpose[b] == b ! True , weil b symmetrisch ist. Transpose[b]
244 Anhang A

ergibt die zu b transponierte Matrix.

Det[b] ! die Determinante von b .
v.r ! das Skalarprodukt von v mit r.
b.v ! die Matrix b angewandt auf den Vektor v .
b.d ! das Matrixprodukt b mal d .
b.Inverse[b] ! die Einheitsmatrix, Inverse[b] liefert die zu b inverse
Matrix.
Eigenvalues[b] ! die Eigenwerte der Matrix b . Es sind die Nullstellen
eines Polynoms 3. Grades, die Mathematica mit der Cardanischen Formel berech-
nen kann.
nb = N[b] ! die numerische Approximation der Matrix b . Die exakten
rationalen Zahlen sind durch reelle Zahlen mit einer Genauigkeit von 10 16 ersetzt
worden.
Eigenvalues[nb] ! f 0.875115, 0.0409049, 0.000646659 , g
eine Liste der Eigenwerte der Matrix nb .
u = Eigenvectors[nb] ! eine Liste der Eigenvektoren von nb .
Chop[u.Transpose[u]] ! die Einheitsmatrix, denn die Eigenvektoren
von nb sind orthonormal, bis auf numerische Ungenauigkeiten von der Größen-
ordnung 10 16 .
Sort[Thread[Eigensystem[nb]]] ! Eigenwerte und zugehörige Ei-
genvektoren, sortiert nach der Größe der Eigenwerte.

Lösen von Gleichungen

FindRoot[Cos[x]==x,fx,1g] ! f g
x –> 0.739085 , die Lösung
f g
der Gleichung cos x = x. Die Klammer x,1 bedeutet: suche eine Lösung be-
züglich x und starte die Suche bei x=1.
FindRoot[fCos[ax]==x, aSin[ax]== 1g, fx,1g, fa,1g]
Auch Gleichungssysteme lassen sich mit FindRoot[..] lösen.
^
Plot[Product[(1+x/j 2),fj,Infinityg],fx,1,4g] ! eine
glatte Funktion, die im betrachteten Bereich monoton ansteigt.
^
FindRoot[Product[(1+x/j 2),fj,Infinityg]==20,fx,3g] !
Erste Schritte mit Mathematica 245

eine Fehlermeldung, weil sich die Funktion nicht symbolisch differenzieren läßt.
^
FindRoot[Product[(1+x/j 2),fj,Infinityg]==20,fx,f2,3gg]
So geht’s. Wenn man statt eines Startwertes ein Startintervall angibt, wird das Se-
kantenverfahren benutzt.

FindRoot[lhs == rhs, fx, x0g] findet numerische Lösungen.

Solve[eqns, vars] versucht, exakte Lösungen zu finden.
NSolve[eqns, vars] Numerische Lösungen algebraischer Gleichun-
gen.
LinearSolve[m, b] löst das Gleichungssystem m.x == b
DSolve[eqn, y[x], x] löst Differentialgleichungen.
NDSolve[eqns, y, fx, xmin, xmaxg] findet numerische Lösun-
gen von Differentialgleichungen.

^
Solve[ax 2+bx+c==0,x] ! die 2 Lösungen der quadratischen Glei-
chung.
Solve[ArcSin[x]==a,x] ! ffx –> Sin[a] gg
^ ^
Solve[x 5 5x 2+1 == 0, x] Zu schwierig.
^ ^
NSolve[x 5 5x 2+1 == 0, x] ! 5 numerische Nullstellen.
DSolve[y’’[x]==y[x], y[x], x] ! die allgemeine Lösung dieser
Differentialgleichung.
DSolve[y’[x]==Cos[xy[x]], y[x], x] Fehlanzeige.
NDSolve[fy’[x]==Cos[xy[x]],y[0]==0g,y[x],fx, 5,5g] !
ein Mathematica-Objekt, das InterpolatingFunction heißt.
f[x ] = y[x] /. % So kann man aus dem Objekt InterpolatingFunction eine
f g
normale Funktion machen, die sich mit Plot[f[x], x,–5,5 ] plotten läßt.

Muster, Ordnen, Sortieren

Remove["Global‘"]
^
liste = f1, 2, f[a], g[b], x n, f[b], 3.4, Sin[p] 2g ^
Position[liste, f[ ]] ! ff3g,f6gg , nämlich eine Liste aller Plätze
mit f[irgendwas].
246 Anhang A

Cases[liste, ^2] ! fSin[p]2g , alle Fälle mit Potenz 2.

Count[liste, ^ ] ! 2 , die Anzahl aller Fälle mit irgendeiner Potenz.
DeleteCases[liste, [b]] ! f1,2,f[a],xn,3.4,Sin[p]2g , ir-
gendwas[b] fällt heraus.
Select[liste,IntegerQ] !f g
1,2 , die Fälle, für die IntegerQ[..]
den Wert True gibt. Es gibt weit über 30 Ausdrücke der Form Q , mit denen man
Fragen stellen kann.
?Q ! alle diese Fragen.
Select[liste,NumberQ] ! f1,2,3.4g . NumberQ[Zahl] ergibt
True .
Select[liste,!NumberQ[#]&] !
alles, außer den Zahlen. Das Ausru-
fezeichen (!) ist die logische Verneinung. Die Konstruktion expr[#]& macht aus
expr einen Operator, eine sogenannte pure function. Für # wird das Argu-
ment eingesetzt.
term = Expand[3(1+x) 3(1 y x) 2]^ ^ Expand[..] multipliziert
aus.
Factor[term] ! das Argument vom vorigen Expand[]. In gewisser Weise
ist Factor das Gegenstück zu Expand.
FactorTerms[term] klammert Zahlenfaktoren aus.
Collect[term,y] ordnet nach Potenzen von y.
Coefficient[term,x 2y 2] ^ ^ ! 2 , der Koeffizient von x2 y2 .
CoefficientList[term,x] ! die Liste der Koeffizienten der x-Potenzen.
^ ! 1
Apart[1/(x 4 1)]
x4
die Partialbruchzerlegung von
1.
Together[%] Together[..] bringt auf den Hauptnenner.
N[Sort[fSqrt[2],2,E,Pi,EulerGammag]] Ergebnis: !
f2., 1.41421, 2.71828, 0.577216, 3.14159 . Nach welchen Ge- g
sichtspunkten wird hier sortiert?
kleiner:= (N[#1] < N[#2])& ordnet nach dem numerischen Wert.
N[Sort[fSqrt[2],2,E,Pi,EulerGammag,kleiner]] Jetzt stimmt’s.
Anhang B
Erste Schritte mit C

C ist die Programmiersprache der UNIX-Rechner. Während FORTRAN hauptsäch-

lich für extensive numerische Rechnungen benutzt wird, erlaubt C einen übersichtli-
chen, kompakten und funktionsorientierten Programmierstil und die Benutzung ma-
schinennaher Graphikumgebungen. Ferner hat C (ebenso wie PASCAL) den Vorteil,
daß es für den PC eine bequeme Umgebung zur Programmentwicklung mit einge-
bauter Graphikbibliothek gibt.
C hat jedoch auch Nachteile: Zum einen ist es nicht für wissenschaftliches Rech-
nen entwickelt worden. Potenzen werden mit einer Funktion berechnet, die Mathe-
matik-Bibliothek muß beim Compilieren immer mit aufgerufen werden und kom-
plexe Zahlen, Vektor- und Matrixmultiplikationen muß man sich selbst definieren.
Zum anderen muß man oft Speicheradressen verwenden, und C kontrolliert nicht,
ob Indizes versehentlich den vorher definierten Bereich überschreiten. Insbesonde-
re der Anfänger muß sich sehr vor dem letzten Punkt in acht nehmen: C toleriert
sehr viele Fehler, und man hat daher große Mühe, die Ursache für offensichtlich
falsche Ergebnisse herauszufinden. Andererseits läßt C dem Programmierer viele
Freiheiten, die er zu seinem Vorteil nutzen kann.
Wir wollen hier, hautpsächlich mit einfachen Beispielen, eine erste Einführung in
C geben. Ein Programm muß immer die Funktion main( ) enthalten, deren An-
f g
weisungen in den darauffolgenden Klammern ... stehen. Der Typ aller Variablen
und Funktionen muß deklariert werden sein, z. B. mit

int i, antwort;
char ch;
float f, rationale_Zahl;
long Langes_i;
double Langes_f;

C unterscheidet zwischen Groß- und Kleinbuchstaben. Die Variablen hinter int,

char und long sind ganze Zahlen (Integer), diejenigen nach float und double
sind rationale Zahlen. Die verschiedenen Typen markieren verschiedene Genau-
igkeiten bzw. Größen des zugewiesenen Speicherplatzes, die von der Maschine
abhängen. Normalerweise sind für char ein Byte (= 8 Bits = Speicherbedarf für
ein ASCII-Zeichen), für int zwei und für long vier Bytes reserviert.
248 Anhang B

Als erstes Beispiel wollen wir die Zahlen 4, 5, .., 15 auf dem Bildschirm aus-
drucken: Wir schreiben in eine Datei druck.c die Zeilen
main( )
{
int i;
for( i=4; i<16; i=i+1) printf("i=%d \n",i);
}
Jeder Befehl muß durch ein Semikolon abgeschlossen werden. Die Iterationsschlei-
fe for enthält in runden Klammern die Struktur: (Start; Abbruchbedingung; Befehl
nach jedem Durchlauf). Hinter der runden Klammer erscheint der auszuführende
f g
Befehl; mehrere solcher Befehle müssen mit ... geklammert werden, wobei
hinter jedem Befehl das Semikolon stehen muß.
Dieses Programm wird mit
cc –o druck druck.c
compiliert, und der Befehl druck schreibt die Zahlen auf den Bildschirm. Die
Druckfunktion printf erwartet als erstes Argument eine Zeichenkette ": : :", die
sowohl den Text, als auch die Formatanweisung für die zu druckende Variable i
enthält. Je nach Typ der Variablen sind folgende Druckanweisungen gebräuchlich:

Variablentyp

%d int
%ld long
%c char
%f float (Fließkomma-Darstellung)
%e float (Exponential-Darstellung)
%lf double
%s string

Das Symbol \n ist ein Steuerzeichen, das einen Zeilenvorschub bewirkt. Es ent-
spricht der R ETURN-Taste.
Die obigen Druckanweisungen sind auch für das Einlesen zu verwenden, das die
Funktion scanf( ) übernimmt:
main( )
{ double i = 0.;
for(; i<100.;)
{ printf( "Bitte Zahl eingeben \n");
Erste Schritte mit C 249

scanf( "%lf", &i);

printf( "Sie haben %lf eingegeben",i);
}
}
Dieses Programm zeigt einige Besonderheiten: 1. In der Typ-Deklaration kann die
Variable auch gleich initialisiert werden. 2. In der for-Schleife können auch lee-
re Start- und Inkrementanweisungen stehen. 3. Übergibt man eine Variable an eine
Funktion, hier i an scanf, so wird nur der Wert übergeben. Also kann scanf kei-
ne neue Zahl auf den Speicherplatz von i schreiben. Das geht nur, wenn die Funk-
tion die Addresse (und nicht den Wert) der Variablen enthält: dann kann scanf auf
den Speicherplatz von i die eingetippte Zahl schreiben. Adressen erhält man durch
ein vorgestelltes &.
Das Programm liest so lange Zahlen ein und schreibt sie dann, bis eine Zahl
größer als 100 ist. Wenn scanf die eingegebenen Zeichen nicht in eine reelle Zahl
umwandeln kann, wartet die Funktion auf die folgende Eingabe.
Man kann natürlich auch Text einlesen und ausdrucken. Dazu muß man für jedes
Zeichen einen Speicherplatz vom Typ char reservieren, z. B. als Vektor.
main()
{ char str[100];
printf( "Wie heissen Sie?");
scanf( "%s", str);
printf( "Guten Tag, %s", str);
}
str[100] ist ein Vektor mit Platz für 100 Zeichen. str[0] ist das erste und
str[99] das letzte Zeichen. str ist die Adresse des Vektors (= Adresse des ersten
Platzes, also &str[0]), deshalb reicht es, in scanf den Namen des Vektors ohne
& zu übergeben. scanf liest alle Zeichen ein bis zu einem Leerzeichen oder einem
R ETURN, dann wird das Ende der Zeichenkette mit dem ASCII-Zeichen \0 (= Null)
markiert. printf druckt alle Zeichen bis zu dem Zeichen \0.
Nach diesen beiden ersten Versuchen wollen wir eine Liste von Befehlen und Be-
merkungen folgen lassen, mit denen erste kleine Programme machbar sein sollten.
#include <math.h>
#include "myfile"
#define N 1000
Diese Anweisungen werden vor dem Compilieren ausgeführt. #include fügt an

dieser Stelle die benannten Dateien hinzu, < > sucht in speziellen Pfaden, " "
sucht im momentanen Pfad, in dem sich das Programm befindet. Alle benutzten
Funktionen müssen deklariert sein, das geschieht in den entsprechenden Header-
Dateien math.h, stdlib.h, graphics.h, time.h usw. Durch die Zeile
250 Anhang B

#define N 1000 wird im gesamten Programm das Symbol N durch das Symbol
1000 ersetzt.
summe = a+b;
a = b = a/b * e;
mod = a % b;
Das Gleichheitszeichen ordnet der linken Variablen den rechten Wert zu. % ist die
Modulo-Operation, mod erhält also den Rest von a/b.
summe += a;
a++; b––;
C enthält einige Abkürzungen: Die obigen Befehle ersetzen summe = summe+a;
a = a+1; b = b–1;
a>b; größer als
a>=b; größer oder gleich
a==b; gleich
a!=b; ungleich
a<=b; kleiner oder gleich
a<b; kleiner als

Wenn die obigen Relationen wahr sind, erhält der Ausdruck den Wert 1, sonst den
Wert 0. Für logische Ausdrücke gibt es keinen speziellen Datentyp, C arbeitet ein-
fach mit ganzen Zahlen vom Typ int.
a<b || c!=a oder
a<b && c!=a und
!(a<b) nicht

Logische Operatoren verknüpfen logische Werte und erzeugen 1 (wahr) oder 0

(falsch). Die logische Negation ! macht aus 0 eine 1 und umgekehrt.
if(b==0) printf ("Division ist nicht definiert");
else printf ("Ergebnis = %lf", a/b);
if (b>1.e–06)
{ scanf("%lf",&a);
printf("a geteilt durch b=%lf", a/b);
}
Die Anweisung if führt den folgenden Befehl nur dann aus, wenn der Klammer-
ausdruck wahr ist (einen Wert ungleich 0 hat). Falls die Klammer den Wert 0 hat,
Erste Schritte mit C 251

wird der Befehl nach else ausgeführt. Der else-Zweig muß nicht angegeben
f g
werden, und mehrere Befehle muß man als Block ::: zusammenfassen, wie das
zweite Beispiel zeigt.
switch (ch=getch())
{
case’e’: exit(0);
case’f’: scanf("%lf",&a); break;
case’s’: scanf("%s",str); break;
default: printf("Sie haben %c eingegeben",ch);
break;
}
Mehrere, eventuell verschachtelte if...else...if...else... Anweisun-
gen kann man übersichtlicher durch einen switch Befehl ersetzen. Es wird das
nächste Tastaturzeichen durch die Funktion getch() aufgerufen, an die Variable
ch übergeben und diejenige case Anweisung ausgeführt, die den entsprechenden
Wert von ch enthält. Falls der Wert nicht vorhanden ist, wird die default Anwei-
sung ausgeführt. Jeweils der letzte Befehl sollte break; sein. Damit springt das
f g
Programm an das Ende des switch Blockes ::: .
for (summe=0., i=0; i<N; i++) summe +=feld[i]; for(;;);
Die for-Schleife haben wir schon kennengelernt. Die ersten zwei Anweisungen,
durch ein Komma getrennt, werden beim Start ausgeführt. Die Schleife bricht ab,
wenn der Wert nach dem ersten Semikolon Null (also falsch) ist. i++ wird nach je-
dem Schleifendurchgang ausgeführt. Das zweite Beispiel gibt eine unsinnige End-
losschleife, die nur durch den gewaltsamen Abbruch des Programmes mit Ctrl–c
(Control- und c-Taste gleichzeitig drücken) gestoppt werden kann.
while(ch!=’e’)
{ ch=getch();
printf ("Das Zeichen %c wurde eingetippt \n",ch);
}
Die while-Schleife ist eine weitere wichtige Iteration von Befehlen. Sie wird so-
lange ausgeführt, wie der Wert in der runden Klammer ungleich 0, also wahr ist.
Die Funktion getch() liest ein Zeichen von der Tastatur und gibt es an die Va-
riable ch. Dann wird es gedruckt. Falls das Zeichen ’e’ eingetippt wird, wird die
Schleife beendet.
double v[6];
double u[5]={1.0, 1.5, 0., 6, –1.};
v[5]=u[1] * u[0];
252 Anhang B

Bei der Deklaration von Vektoren muß der Typ und die Länge des Vektors ange-
geben werden. Die Indizes laufen von 0 bis (Länge 1) und werden mit eckigen
Klammern angesprochen. v[5] hat also den Wert 1:5, v[6] ist nicht definiert.
Vektoren können bei der Deklaration initialisiert werden.
double mat[6][5];
for(i=0;i<6;i++)
{
for(sum=0., j=0;j<5;j++)
sum+= mat[i][j]*u[j];
v[i]=sum;
}
Matrizen werden durch zwei Indizes deklariert und angesprochen. Für jeden Index
ist eine separate eckige Klammer erforderlich. Der erste Index gibt die Zeile, der
zweite die Spalte der Matrix an. Im obigen Beispiel ist der Vektor v das Ergeb-
nis der Multiplikation der Matrix mat mit dem Vektor u. Die Matrix hat 6 Zeilen
i = 0; :::; 5 und 5 Spalten j = 0; :::; 4. mat enthält die Adresse des ersten Ele-
mentes mat[0][0] und mat[i] diejenige der i-ten Zeile, also des Elementes
mat[i][0]. Das ist wichtig, wenn man Matrizen oder Zeilen davon an Funktio-
nen übergeben will.
double *a, wert, b;
a = &b;
scanf ("%lf", a);
wert = *a;
Es gibt in C Variablen, die die Adresse und nicht den Wert eines Speicherplat-
zes enthalten. Sie werden durch Typ * deklariert, d. h. die Variable a enthält die
Adresse eines Speicherplatzes vom angegebenen Typ, oder a zeigt auf einen Platz
vom Typ double. Solche Variablen werden auch Zeiger genannt, und ihr Wert
wird mit *a angesprochen. Im obigen Beispiel wird die Adresse von b an a über-
geben, dann wird auf diesen Platz eine reelle Zahl eingelesen, und der Wert von
a wird an wert übergeben. Dasselbe Ergebnis für wert hätte auch der Befehl
scanf("%lf", &wert) geliefert.
In der folgenden Tabelle sind x und y vom Typ double. Winkel werden bei
trigonometrischen Funktionen im Bogenmaß angegeben.
sin(x) Sinus von x
cos(x) Kosinus von x
tan(x) Tangens von x
asin(x) arcsin(x) im Bereich [ =2; =2], x 2[ 1; 1].
acos(x) arccos(x) im Bereich [0; ], x [ 2 1; 1].
Erste Schritte mit C 253

atan(x) arctan(x) im Bereich [ =2; =2].

atan2(y,x) arctan(y=x) im Bereich [ ; ].
sinh(x) Sinus Hyperbolicus von x
cosh(x) Cosinus Hyperbolicus von x
tanh(x) Tangens Hyperbolicus von x
exp(x) Exponentialfunktion ex
log(x) natürlicher Logarithmus ln(x) , x > 0 .
log10(x) Logarithmus zur Basis 10, log10 (x) , x > 0 .
pow(x,y) xpy
sqrt(x) x, x 0.
fabs(x) absoluter Wert jxj
fmod(x,y) Rest von x=y

Diese mathematischen Funktionen geben einen Funktionswert vom Typ double

zurück. Sie müssen vorher mit #include <math.h> deklariert werden. Falls
das Argument nicht vom Typ double ist, wird es automatisch umgewandelt.

double r;
r = rand() / (RAND_MAX +1.);

Die Funktion rand() liefert ganzzahlige gleichverteilte Pseudo-Zufallszahlen zwi-

schen 0 und RAND MAX. Braucht man reelle Zufallszahlen im Intervall [0,1], so
kann man rand() durch RAND MAX dividieren. Allerdings muß man dazu den
Nenner in eine reelle Zahl umwandeln, sonst ist das Ergebnis die ganze Zahl 0.
Die Addition von RAND MAX und der reellen Zahl 1. ergibt als Resultat eine Zahl
vom Typ float. Die Funktion rand() und die Konstante RAND MAX müssen
mit #include <stdlib.h> deklariert bzw. definiert werden.

#include <math.h>
main()
{
double f(double),x;
for(x=0.;x<10.;x+=.5)
printf("\n f(%3.1lf) = %4.2e ",x,f(x));
}

double f(double xxx)

{
double x2;
x2=xxx*xxx;
return (x2*exp(–x2/2));
}
254 Anhang B

Man kann eigene Funktionen definieren, hier f (x) = x2 e x =2 . Dazu muß die
2

Funktion in der aufrufenden Funktion (hier main()) deklariert und dann definiert
werden, jeweils mit den Typenangaben, auch für die Argumente. Die Befehle der
f g
Funktion f (x) stehen in einem Block ::: , und der Wert wird mit return an den
aufrufenden Funktionsnamen zurückgegeben. Wird kein Wert zurückgegeben oder
kein Argument übergeben, so wird der Typ void benutzt. Es wird nur der Wert des
Argumentes x übergeben, f kann hier also nicht den Wert der Variablen x ändern.
Wird dagegen die Adresse von x , also &x übergeben, dann kann f auch den Wert
von x ändern:
#include <math.h>
main()
{
double f(double *),x=0.;
while (x<100.) printf(" \n f(%lf)=%lf",x,f(&x));
}

double f(double *adresse)

{
double x2;
x2=(*adresse)*(*adresse);
*adresse+=.5;
return x2*exp(–x2/2.);
}
Hier bedeutet double* einen Zeiger auf eine Variable vom Typ double. Die
Übergabe der Adresse anstatt des Wertes ist notwendig, wenn Vektoren, Matrizen
oder sogar Funktionen an eine Funktion übergeben werden sollen.
main()
{
double u[100],v[100];
double ScalarProduct(double *, double *,int);
int n=20,i;

for(i=0;i<n;i++) u[i]=v[i]=i;
printf(" \n %lf \n",ScalarProduct(u,v,n));

}
Erste Schritte mit C 255

double ScalarProduct(double u[], double v[], int n)

{
int i;
double summe;
for(i=0,summe=0.;i<n;i++) summe += u[i]*v[i];
return summe;
}
Dieses Beispiel zeigt, wie Vektoren an Funktionen übergeben werden. double
u[] zeigt dem Compiler, daß die Funktion ScalarProduct eine Adresse auf
das erste Element eines Vektors vom Typ double erhält; double *u ist iden-
tisch damit. Es wird in der Funktion kein Speicherplatz für einen Vektor reserviert,
sondern nur mit der Adresse des ersten Platzes gearbeitet. u[3] zählt diese Adresse
drei Plätze weiter und gibt den Wert dieses Platzes zurück. Die Funktion weiß nicht,
wie groß der in main() reservierte Speicherplatz ist; man muß daher die Länge n
der Vektoren angeben.
double MatrixFunktion(double mat[][10],int zeilen,
int spalten)
{ ... }
Bei Matrizen wird zwar auch nur die Adresse des ersten Elementes übergeben, also
&mat [0][0], aber das Programm muß die Länge der Zeilen (hier 10) wissen,
um jedes Element ansprechen zu können. Denn das Element mat[i][j] steht
im Speicherplatz mit der Adresse &mat[0][0] + i*10 + j. Die Anzahl der
reservierten Zeilen muß nicht bekannt sein.
/* So
besser
nicht */
double u[100],v[100],ScalarProduct(void);int n=20,i=0;
main(){for( ; i<n; i++) u[i]=v[i]=i*i;
printf("%lf",ScalarProduct());}
double ScalarProduct(void){double sum=0.;
for(i=0;i<n;i++)sum+=u[i]*v[i];return sum;}
/* Das ist
ein Kommentar */
Variable können nur innerhalb der Funktion benutzt werden, innerhalb derer sie
definiert sind. Sollen sie in mehreren Funktionen gültig sein, so müssen sie vor
diesen Funktionen außerhalb der geschweiften Klammern deklariert worden sein.
u,v,n,i und ScalarProduct kann man also (auch mit Werten) in allen Funk-
tionen benutzen, sum dagegen nur in ScalarProduct. void bedeutet, daß kei-
ne Variablen übergeben werden. Natürlich kann die Funktion jetzt nicht auf andere
256 Anhang B

Vektoren x und y angewendet werden, sie steht also nur als Abkürzung für einen
Block von Befehlen.

Vorsicht: Fallen!

Wir wollen hier einige Standardfehler auflisten, die leider oft keine Fehlermeldung
produzieren.

b = mat[i,j];

Matrixelemente müssen durch zwei Indizes jeweils in eckigen Klammern angespro-

chen werden, also mat[i][j]. Der obige Befehl ruft i auf, dann j und weist das
Element mat[j] der Variablen b zu. mat[j] ist aber die Adresse der j -ten Zeile
(= &mat[j][0])!

if(a=b) dosomething();

Der Programmierer meinte sicherlich a==b. Der obige Befehl weist b der Variablen
a zu und prüft dann, ob der Wert von a gleich Null ist. Falls nicht, wird die Funktion
dosomething() aufgerufen.

ganze_zahl = 3 * rand() / RAND_MAX;

Alle Variablen und Konstanten sollen vom Typ Integer sein. Manche Compiler wer-
ten diesen Ausdruck von rechts nach links aus. In diesem Fall erhält der Quotient
und damit die gesamte Rechnung den Wert Null, da beim Ergebnis der Division
zweier ganzer Zahlen der Rest verloren geht. Also sollte man das Produkt in Klam-
mern setzen, dann erhält man auf jeden Fall die Zufallszahlen 0, 1 und 2.

int vector[10],i;
for (i=1; i<=10; i++) vector[i]=i*i;

Vektoren der Länge N werden mit i=0 bis i=N–1 indiziert, vector[10]=100;
weist ohne jede Warnung dem Speicherplatz nach dem für vector reservierten
Bereich den Wert 100 zu, und der Programmierer weiß nicht, was er da gerade
überschreibt!

main()
{
char *name;
printf("Wie heissen Sie? ");
scanf( "%s",name);
}
Erste Schritte mit C 257

name ist als Adresse (=Zeiger) auf eine Zeichenvariable deklariert, aber nirgends
wird der Zeiger initialisiert. Das heißt, in der Variablen name steht irgendeine un-
bekannte Zahl, die als Adresse interpretiert wird, und ab dieser Adresse wird ihre
Eingabe geschrieben und zerstört damit andere Daten. Vor diesem Fehler warnt der
Compiler, er führt ihn aber aus.
char msg[10];
msg ="Hallo";
Namen von Vektoren sind zwar Zeiger, aber keine Variablen. "Hallo" markiert die
Adresse der Zeichenkette, jedoch darf die Adresse des Vektors msg nicht geändert
werden. Der Compiler erzeugt eine Fehlermeldung. Folgendes Programm beseitigt
beide vorherigen Fehler
main()
{
char name[20],*msg;
printf(" \n Wie heissen Sie ?");
scanf("%s",name);
msg="Hello";
printf("\n %s %s \n", msg,name);
}
Der Unterschied zwischen "x" und ’x’
Der erste Ausdruck ist eine Zeichenkette, er besteht aus den beiden Zeichen ’x’
und \0. Der zweite Ausdruck ist ein einzelnes Zeichen.
int a=100;
scanf("%d",a);
scanf interpretiert a als Adresse Nr. 100 und überschreibt das, was dort gerade
steht. Richtig lautet der Einlesebefehl scanf("%d",&a);.

Literatur
B.W. Kernighan, D.M. Ritchie, Programmieren in C, Carl Hanser Verlag, 1990.
Anhang C
Erste Schritte mit UNIX

Einführung
Dieser Anhang soll dem Anfänger einen kurzen Überblick über die wichtigsten
UNIX-Befehle geben. Zusätzlich wird erklärt, wie man über das Internet an die
in diesem Buch beschriebenen Beispielprogramme kommt, wie man diese editieren
und kompilieren kann.
Unter UNIX gibt es mittlerweile viele public domain Programme, d.h. Program-
me, die man für nichtkommmerzielle Zwecke frei kopieren darf. Davon haben sich
etliche zu Standardprogrammen entwickelt. Einige werden auch hier beschrieben,
wie less, gzip und gcc, g++. Wenn diese Programme bei Ihnen nicht verfügbar
sind, können Sie den Systembetreuer bitten, diese zu installieren. Diese Programme
sind mit (*) gekennzeichnet.
UNIX ist ein Multiuser- und Multitasking-Betriebssystem. Es können mehrere
Benutzer unabhängig voneinander zur selben Zeit arbeiten und mehrere Programme
im Hintergrund gleichzeitig“ gerechnet werden. Gleichzeitig“ bedeutet, daß diese
” ”
Prozesse sich die Rechenzeit aufteilen.
Um an einem UNIX System arbeiten zu können, braucht man einen Benutzerna-
men Username und ein Kennwort Password. Diese bekommt man vom Systembe-
treuer. Jeder Benutzer hat ein eigenes Verzeichnis Home-Directory auf der Festplat-
te, in dem er seine Programme und Dateien speichern kann.
Nachdem man am Rechner den Benutzernamen und sein Passwort eingetippt hat,
befindet man sich entweder in einer shell – das heißt, der Rechner wartet auf Kom-
mandos – oder es wird eine Graphikoberfläche (üblicherweise X11) gestartet. Falls
im letzteren Fall nicht automatisch ein Eingabefenster geöffnet wurde, muß man
mit der Maus ein Fenster erzeugen. Dann können die UNIX-Befehle in das Fenster
eingetippt und mit R ETURN abgeschickt werden. Fenster können mit den Mausta-
sten verschoben, in alle Richtungen vergrößert und verkleinert und als icon in den
Hintergrund gebracht werden.
Folgende Befehlsgruppen werden in diesem Anhang beschrieben:

Manipulieren von Dateien

Kommunikation mit anderen Rechnern
Erste Schritte mit UNIX 259

Compiler (zur Übersetzung eigener Programme)

Nichtbeschriebene Befehlsgruppen sind:
Kommunikation mit der Peripherie (z. B. drucken)
Überwachung und Steuerung der im ”Hintergrund“ laufenden Programme
Kommunikation mit anderen Benutzern (z. B. Electronic Mail)
Es sei darauf hingewiesen, daß es bei den Graphikoberflächen oft auch Hilfspro-
gramme (sogenannte Filemanager) gibt, die die Dateiverwaltung leichter machen.

Dateien
Eine Datei ist eine Menge von Zeichen. Diese können Textdaten, Zahlenmengen
oder auch Programme bedeuten. Die Einheit, in der meistens die Länge von Dateien
gemessen wird, ist das Byte. Ein Byte ist eine Zahl zwischen 0 und 255. Üblicher-
weise benötigt ein Zeichen ein Byte und eine Zahl zwei bis vier Bytes Speicherplatz
in einer Datei.
Jede Datei hat einen Namen. Dieser kann unter UNIX auf fast allen Systemen
mehr als 8 Buchstaben Länge haben. Groß- und Kleinschrift wird unterschieden.
Dateien besitzen ferner Attribute wie: Name des Eigentümers, Name der Gruppe,
der sie zugewiesen ist und Rechte des Eigentümers, der Gruppe und aller anderen
Benutzer. Man kann zum Beispiel allen anderen Benutzern (abgesehen vom System-
betreuer) verbieten, die Datei zu lesen.
Die Dateien sind hierarchisch in Verzeichnisse (Directories) gegliedert. Diese
kann man mit Schubladen vergleichen. Die Wurzel (root) dieses Verzeichnisbaumes
hat das Symbol /. Unterverzeichnisse werden mit / getrennt.
Eine tyische Baumstruktur wäre zum Beispiel:
/ — /etc — /etc/motd
/etc/passwd
...
/users — /users/user1 — /user/user1/.cshrc
/user/user1/.login
...
...
...
/unix
Dabei merkt der Benutzer nicht, ob die Verzeichnisse eigene Platten oder gar Platten
an entfernten Rechnern sind. Die Shell merkt sich ein aktuelles Verzeichnis current
directory. Dieses ist am Anfang das eigene Verzeichnis. Dateinamen, die mit / be-
ginnen, werden absolut von der Wurzel aus bezeichnet. Beginnt ein Dateiname mit
260 Anhang C

˜/, so wird stattdessen das eigene Verzeichnis eingesetzt. Beginnt er mit ˜user/, wird
er relativ zu dem angegebenen Benutzer user gesehen. Alle anderen Dateinamen
werden relativ zu dem aktuellen Verzeichnis gesehen. Ein Punkt . bezeichnet das
aktuelle und zwei Punkte .. das übergeordnete Verzeichnis.

Die wichtigsten Befehle

Befehle in UNIX setzen sich aus Kommandos, Optionen und Parametern zusam-
men. Dabei wird den Optionen das Zeichen – vorangesetzt. Sollen mehrere Optio-
nen benutzt werden, können diese meistens hinter ein einziges Zeichen – geschrie-
ben werden. Die Optionen müssen vor den Parametern kommen. Zum Beispiel gibt
ls –a dir alle Dateien des Verzeichnisses dir aus.
Dateinamen können Joker enthalten. Diese werden von der shell ergänzt. Das
Zeichen * steht für beliebig viele beliebige Zeichen. So werden mit dem Befehl ls
m*.c alle Programme ausgegeben, die mit dem Buchstaben m beginnen und mit .c
aufhören.
Die Dateinamen werden oft so gewählt, daß man erkennt, um was es sich han-
delt: Dazu wird üblicherweise ein Punkt und ein Kürzel extension an den Namen
angefügt. Die wichtigsten Extensions sind:
.c C-Programmtext (source code)
.f Fortran-Programmtext
.p Pascal-Programmtext (manchmal auch .pas)
.o Objektdatei (übersetzter Programmtext, noch nicht aufrufbar)
.m Textdatei mit Mathematica-Befehlen
.tar ein Programm-Archiv mit tar erstellt
.gz eine mit gzip(*) gepackte Datei
.z eine mit compress gepackte Datei

Hilfen
Mit dem Befehl man kann man sich die Beschreibung eines Befehles seitenwei-
se auf dem Bildschirm anzeigen lassen. Dabei werden Syntax und auch Optionen
und Parameter erklärt. Zum Beispiel erhält man mit dem Kommando man man die
Beschreibung des man Kommandos.
Weiß man nur ein Stichwort, nicht aber den genauen Befehl, kann man mit man
–k stichwort eine Liste der Befehle erhalten, die in ihrer einzeiligen Beschrei-
bung das Wort stichwort enthalten.
Erste Schritte mit UNIX 261

Dateimanipulation
Eine Datei kann auf komfortable Weise mit einem sogenannten Editor erstellt, bzw.
geändert werden. Dieses wird später beschrieben. Textfiles können mit cat, more
oder less(*) auf dem Bildschirm angezeigt werden. Dabei wird bei more die Da-
tei seitenweise angezeigt, und bei less kann man sogar mit Tastendruck beliebig
in dem Dokument umherspringen.
Das Kopieren einer Datei kann mit dem Unix-Befehl copy geschehen. Die Syn-
tax ist: cp eingabe ausgabe. Hierbei wird die Datei eingabe in die Datei
ausgabe kopiert. Um Verzeichnisse zu kopieren muß die Option –R angegeben
werden. Dabei werden die tieferliegenden Dateien rekursiv kopiert.
Dieselbe Syntax hat der move Befehl, der es ermöglicht, Dateien umzubenennen,
bzw. innerhalb verschiedener Directories zu verschieben: mv alt neu benennt
die Datei alt in neu um. Dies kann auch mit Directories geschehen.
Eine Datei kann man mit dem rm Befehl löschen (remove). rm file löscht
die Datei file. Diese kann dann nicht mehr wiederhergestellt werden. rm *.txt
löscht im aktuellen Verzeichnis alle Dateien mit der Extension txt. Ganze Direc-
tories einschließlich der darin enthaltenen Dateien kann man mit dem Befehl rm
–R rekursiv löschen. Hierbei sollte man aber sehr aufpassen, daß nicht aus Verse-
hen wichtige Daten gelöscht werden. Anfangs sollte man zusätzlich die Option –i
benutzen. Hier wird interaktiv“ bei jeder Datei explizit nachgefragt, ob diese auch
”
wirklich gelöscht werden soll, also zum Beispiel: rm –Ri verzeichnis.

Information über Verzeichnisse, aktuelles Verzeichnis

Das aktuelle Verzeichnis kann man mit pwd (present working directory) anzeigen
lassen. Alle Dateinamen, die nicht mit / beginnen, werden wie schon beschrieben
relativ zu diesem gesehen. cd dir setzt das aktuelle Verzeichnis auf dir. Wird
der Parameter weggelassen, so wird das eigene Verzeichnis benutzt.
Verzeichnisse kann man mit mkdir (für make directory) erstellen und mit dem
Befehl rmdir (für remove directory) löschen. Der Befehl mkdir temp erstellt
also das Verzeichnis temp, der Befehl rmdir temp löscht das leere (!) Verzeich-
nis temp. Verzeichnisse, in denen sich Dateien befinden, können nur mit rm –R
gelöscht werden.
Um den Inhalt eines Verzeichnisses anzugeben, gibt es den List-Befehl ls. Mit
ls dir wird der Inhalt des Verzeichnisses dir ausgegeben. Durch die Option –a
werden auch Dateien angezeigt, deren Dateinamen mit einem Punkt beginnen, zum
Beispiel die Datei .cshrc, die beim Starten der Shell abgearbeitet wird. Bei Ver-
wendung von –l wird eine lange Liste mit Angaben über Zugriffsrechte, Benutzer,
Gruppe, Datum der letzten Modifikation und Größe ausgegeben.
262 Anhang C

Passwort
Das eigene Passwort kann mit dem Kommando passwd geändert werden. Hierzu
muß man das alte Passwort, das neue und (zur Sicherheit, daß man sich nicht ver-
tippt hat) noch einmal das neue eintippen. Die Passwörter erscheinen nicht auf dem
Bildschirm.
Arbeitet man auf mehreren miteinander vernetzten Rechnern, wird oft NIS (Net-
work Information Service) – früher Yellow Pages – verwendet. Dabei existiert nur
eine Passwortdatei für alle Rechner. Es gibt dann einen Server, der die Passwörter
verwaltet. In so einem Fall muß man das Kommando yppasswd verwenden.

Umleiten der Aus- und Eingabe

Die Shell, also der Kommandointerpreter, erlaubt auch das Umlenken von Ein- und
j
Ausgaben durch Einfügen des Zeichens < bzw. >. Durch das -Symbol (pipe) wird
die Ausgabe eines Programmes zur Eingabe eines weiteren Programmes. Zum Bei-
j
spiel gibt ls dir more den Inhalt des aktuellen Verzeichnisses seitenweise an.
ls dir > temp erstellt die Datei temp und beschreibt sie mit der Ausgabe des
ls-Befehls.

Der Standard Editor vi

Für das Erstellen und das Ändern von Dateien stehen einige sogenannte Editoren
zur Verfügung. vi (visual) ist der am weitesten verbreitete. Er besitzt sehr viele
Möglichkeiten, ist allerdings anfangs nicht leicht zu bedienen. Der Editor emacs
von GNU wird ebenfalls häufig benutzt. Hier soll nur kurz auf den vi eingegangen
werden, da er in jedem UNIX System mitgeliefert wird.
Aufgerufen wird der Editor mit vi file. Jetzt wird die Datei file (falls vor-
handen) geladen oder sonst neu erstellt. Beim Arbeiten mit dem vi werden drei
Modi unterschieden:
Der Kommando-Modus
Der Einfüge-Modus
Der Kommandozeilen-Modus
Nach dem Starten befindet man sich im Kommando-Modus. Das heißt, die getippten
Tasten werden als Befehle interpretiert. Wichtige vi-Befehle in diesem Modus sind:
A Springt an das Ende der Zeile und geht in den Einfüge-Modus (Append)
I Springt an den Anfang der Zeile und geht in den Einfüge-Modus (In-
sert)
Erste Schritte mit UNIX 263

i Geht in den Einfüge-Modus (Insert)

E SC schaltet vom Einfüge-Modus zurück in den Kommando-Modus

J fügt die nächste Zeile zur aktuellen hinzu (Join)

x löscht das Zeichen unter dem Cursor

dd löscht die aktuelle Zeile

D löscht ab der Cursorposition bis zum Ende der Zeile

dw löscht ein Wort

nG springt in Zeile n

G springt in die letzte Zeile

/pattern sucht nach pattern.

Mit einem Doppelpunkt : wird in den Kommandozeilen-Modus umgeschaltet. Die

wichtigsten Befehle sind:

:x Abspeichern des Dokumentes und verlassen des Editors (Exit)

:q Verlassen des Editors, falls nichts geändert wurde (Quit)

:q! Verlassen des Editors, Änderungen werden verworfen (Quit)

:w Abspeichern des Dokumentes (Write)

:wq Abspeichern des Dokumentes und verlassen des Editors

:r file Einlesen der Datei file (Read)

:set nu Zeilennumerierung einschalten (Set Numbers)

Es gibt noch wesentlich mehr Kommandos. So kann man natürlich Blöcke markie-
ren und kopieren oder auch ganze Blöcke einrücken.
264 Anhang C

Der C-Compiler
Das Übersetzen eines C-Programmes in einen ausführbaren Code geschieht in zwei
Schritten. In dem ersten wird das Programm in ein sogenanntes Objektfile über-
setzt (compiling). Dieses enthält dann das übersetzte Programm. Im zweiten Schritt
wird dieses Objekt mit Standardbibliotheken und eventuell anderen Objektdateien
zu einem ausführbaren Programm zusammengefügt (linking).
Der C-Compiler, der bei einem UNIX System mitgeliefert wird, heißt cc. Mit
dem Aufruf cc file.c wird das Programm file.c übersetzt und auch schon
gleich gebunden. Das fertige, ausführbare Programm heißt dann a.out. Sollen
Mathematikroutinen, z. B. trigonometrische Funktionen, verwendet werden, muß
die Mathematikbibliothek dazugebunden werden. Dieses geschieht mit der Option
–lm.
Wichtige Optionen sind:
–o name Das Ausgabefile heißt name statt a.out
–O optimiert den Code
–c erzeugt nur eine Objektdatei
–I dir Include-Dateien werden zusätzlich in dir gesucht
–lx Der Linker bindet die Bibliothek libx dazu
–L dir Der Linker sucht Programmbibliotheken zusätzlich in dir
Ein Standard C-Compiler, der frei verfügbar ist, ist der gcc(*) von GNU. Er liefert
oftmals schnelleren Code als der vom System mitgelieferte. Weiterhin unterstützt er
C++ mit dem Aufruf g++.

Make
Um größere Programmpakete zu übersetzen, benutzt man häufig das Hilfsprogramm
make. Es liest eine Datei namens Makefile und arbeitet die darin angegebenen
Anweisungen ab. Das Format soll hier nicht besprochen werden.

Netzwerke
Viele UNIX-Rechner sind über das Internet vernetzt. In diesem Abschnitt werden
die wichtigsten Befehle beschrieben.
Jeder am Internet angeschlossene Rechner hat eine Adresse. Diese besteht aus
vier Zahlen, die jeweils zwischen 0 und 255 liegen dürfen. Jeder Adresse ist ein Na-
me zugeordnet. So hat ftp.physik.uni–wuerzburg.de zur Zeit die Adresse
Erste Schritte mit UNIX 265

132.187.40.15. Die einzelnen Zahlengruppen lassen sich nicht eindeutig in Namen

umsetzen. So beginnt zwar jede Würzburger Uni-Adresse (.uni-wuerzburg.de) mit
132.187, die Physik hat aber noch andere Unternummern außer 40. Da bei Netz-
werkumstellungen die Nummern geändert werden können, sollte man möglichst die
Namen verwenden.

Verbindung zu anderen Rechnern

Man kann durch den Befehl telnet rechner eine Verbindung zu einem ande-
ren Rechner im Netz aufbauen. Dabei kann rechner entweder der Name oder die
Internet Adresse sein.
telnet ftp.physik.uni–wuerzburg.de gibt, falls eine physikalische
Verbindung besteht und unser Rechner arbeitet, als Ausgabe:

Trying...
Connected to wptx15.physik.uni–wuerzburg.de.
Escape character is ’ˆ]’.

HP–UX wptx15 A.09.03 A 9000/712 (ttys0)

An dieser Stelle muß der Benutzer seine Benutzerkennung und sein Passwort
eingeben.
Man sollte Telnet-Sitzungen immer korrekt schließen, d.h. den fremden Rechner
mit logout verlassen. Ist mal alles schief gegangen, kommt man mit dem ange-
gebenen Steuerzeichen Escape character in ein Telnet-Menü. Dabei bedeutet das
ˆ] Zeichen das gleichzeitige Drücken der Control- und der ] -Taste. In dem Telnet-
Menü erhält man mit dem Kommando ? eine kurze Hilfe. Mit close kann die
Verbindung beendet werden.
Eine Möglichkeit, auf einem anderen UNIX-Rechner zu arbeiten, bietet das Kom-
mando rlogin. Hierbei wird der gleiche Benutzername angenommen. Mit der
Option –l lässt sich dieser explizit ändern.

Programme von anderen Rechnern kopieren

Um Dateien zwischen Rechnern auszutauschen, gibt es ftp, ein File Transfer Pro-
tocol. Mit ftp Rechner wird eine Verbindung aufgebaut. Dabei kann Rechner
wieder entweder die Internetadresse oder der Name sein. Auch hier muß sich der
Benutzer identifizieren. Der Rechner fragt nach Benutzernamen und Passwort. Hat
das login geklappt, so können unter anderem folgende Befehle benutzt werden:
266 Anhang C

bi setzt den Übertragungsmodus auf binär, d.h. die Daten werden

ohne Änderung übertragen

as setzt den Übertragungsmodus auf ASCII (Textmodus). Hierbei

können Steuerzeichen unterdrückt werden. Es kann eine system-
abhängige Konvertierung der Textzeichen vorgenommen werden.

ls zeigt die Dateien in dem fremden Verzeichnis an (list)

cd dir setzt das fremde Verzeichnis auf dir

get file kopiert die Datei file vom fremden auf den lokalen Rechner

put file kopiert die Datei file vom lokalen auf den fremden Rechner

mget files wie get, nur dürfen Joker im Dateinamen verwendet werden

mput files wie put, nur dürfen Joker im Dateinamen verwendet werden

Internet-Dateitransfer
Viele Einrichtungen bieten Programme an, die sich jeder frei kopieren darf. Diese
kann man sich über das Internet mit Hilfe von ftp beschaffen. Spezielle ftp-server
bieten dazu die Möglichkeit, sich als Benutzer ftp oder anonymous einzuloggen.
Als Passwort verlangen sie die eigene E-Mail Adresse. So sind auch die in diesem
Buch angegebenen Programme auf dem ftp-Server

ftp.physik.uni–wuerzburg.de

(derzeitige IP-Adresse: 132.187.40.15) im Verzeichnis /pub/cphys erhältlich.

Datenkomprimierung
Zum Archivieren von Daten ist es nützlich, mehrere Programme unter einem Namen
zusammen zu speichern. Dieses wird oft mit dem Programm tar (tape archiver)
getan. Mit tar –cf file.tar dir archiviert man das Verzeichnis dir mit
all seinen Dateien und Unterverzeichnissen in die eine Datei file.tar. Mit dem
Befehl tar –tf file.tar erhält man ein Inhaltsverzeichnis des Archivs und
mit dem Befehl tar –xf file.tar wird das Verzeichnis wieder hergestellt.
Um dann noch Plattenplatz zu sparen, werden Komprimierungsprogramme ein-
gesetzt. Ein häufig verwendetes ist gzip(*) . gzip file komprimiert die Datei
file. Das Ausgabefile hat den Namen file.gz. Zum Expandieren dienen die
Befehle gzip –d file.gz oder gunzip file.gz.
Erste Schritte mit UNIX 267

X11 über ein Netzwerk

Es ist kein Problem, X11-Anwendungen über ein Netzwerk zu betreiben, also auf
einem Rechner zu rechnen und auf einem anderen die Ausgaben anzeigen zu las-
sen. Nehmen wir an, wir wollen auf der Maschine rechner ein X-Programm star-
ten, welches die Fenster auf dem X-Bildschirm unserer lokalen Maschine local
darstellen soll. Dann müssen wir als erstes unserer Maschine mitteilen, daß sie
Bilder von der anderen Maschine akzeptieren soll. Dies geschieht mit: xhost +
rechner. Auf der Maschine rechner müssen wir die Umgebungsvariable
DISPLAY setzen. Dieses geschieht in der csh, bzw. tcsh durch setenv
DISPLAY local:0. Das Symbol :0 steht für die erste X-Sitzung. Alle jetzt
aufgerufenen X-Programme senden ihre Graphikausgaben auf den Bildschirm von
local.

Literatur
UNIX: Eine Einführung, Regionales Rechenzentrum für Niedersachsen, Universität
Hannover, 1993.
J. Gulbins, Unix, Springer Verlag, 1988.
Anhang D
Erste Schritte mit Xgraphics

In unseren Beispielprogrammen werden oft Bewegungen berechnet, die unmittel-

bar nach dem Vorliegen der Daten auf dem Bildschirm sichtbar gemacht werden.
Eine solche graphische Darstellung von Resultaten, die im C-Programm berechnet
werden, ist auf der Workstation im UNIX-Betriebssystem nicht einfach. Es steht
zwar auf fast allen Rechnern die Benutzeroberfläche X-Windows zur Verfügung,
mit der elementare Graphikbefehle programmiert werden können, aber die Benut-
zung ist für Anfänger sehr kompliziert, weil selbst einfache Programme mehrere
Seiten Quellcode benötigen.
Um die Erstellung von Graphikprogrammen zu erleichtern, hat Martin Lüders
Xgraphics entwickelt. Es verwendet ausschließlich die Routinen von Xlib, der Stan-
dard-Bibliothek des X-Windows Systems, und stellt einfache Befehle zum Verwal-
ten von Fenstern und zum Zeichnen in Fenster bereit. Dabei werden die vielen Pa-
rameter, die für Aufrufe der Xlib-Befehle übergeben werden müssen, intern verwal-
tet, so daß beim Programmieren nur die wirklich notwendigen Parameter angegeben
werden müssen. Vor allem wird dem Programmierer aber ein Großteil der Verwal-
tung der Fenster abgenommen. So muß man sich beispielsweise in einfachen Fällen
nicht darum kümmern, ob ein Fenster vom Anwender vergrößert oder im anderen
Fall zum Icon verkleinert wird. Dadurch wird es möglich, tatsächlich die Physik
in den Mittelpunkt der Programme zu stellen. Dennoch sind die Datenstrukturen
der Xlib direkt zugänglich, so daß man jederzeit Xlib-Befehle oder auch auf Xlib
aufbauende Erweiterungen hinzufügen kann.
Ein wichtiger Grundbaustein von Xgraphics sind die Zeichenbereiche, Worlds
genannt, die es erlauben, ein lokales Koordinatensystem zu definieren, welches
dem zu programmierenden Problem angepaßt ist und sich nicht nach der jewei-
ligen Größe des aktuellen Fensters zu richten hat. Die wesentlichen Befehle von
Xgraphics sind: Erzeuge ein Fenster (CreateWindow), erzeuge einen Zeichen-
bereich mit selbstdefinierten Koordinaten im Fenster (CreateWorld), erzeuge
mit der Maus bedienbare Steuerungsknöpfe (InitButtons), reagiere auf Maus-
oder Tastenbewegungen (GetEvent), lies eine Zahl ein (GetNumber), zeichne
einen Punkt mit Pixelkoordinaten (DrawPoint) oder mit selbstdefinierten Koordi-
naten (WDrawPoint), zeichne einen Kreis (DrawCircle bzw. WDrawCircle),
schreibe Text (DrawString bzw. WDrawString) usw. Der Quellcode des C-
Erste Schritte mit Xgraphics 269

Programms Xgraphics.c muß zusammen mit dem eigenen Programm übersetzt

werden. Dabei müssen die X11-Bibliothek und die entsprechenden Pfade angege-
ben werden. Dies macht das Programm compile. Im eigenen Programm muß die
Header-Datei Xgraphics.h mit #include hinzugefügt werden. Eine ausführ-
liche Beschreibung gibt das Postscript-File Xgraphics.ps.
Dieses Programmpaket inklusive der Dokumentation, einiger Demonstrations-
programme und der X-Windows-Versionen der Beispielprogramme finden sich auf
der Diskette. Sie sind mit dem Unix-Befehl tar zu Gruppen zusammengefaßt. Die
Archive enthalten:
xgraphics.tar Das eigentliche Xgraphics Paket mit der Dokumentati-
on.
demo.tar Einige Demonstrationsprogramme.
physics.tar Die Beispiele aus dem Buch.
Das Entpacken erreicht man mit folgendem Befehl:
tar xf file.tar
Außerdem kann der Leser sie über das Computernetz auf seinen Rechner kopieren.
Das geschieht wie folgt:
ftp ftp.physik.uni–wuerzburg.de
Der Rechner fragt nach dem Namen:
ftp
Der Rechner fragt nach dem Passwort:
[email protected]–excellent.de
Das richtige Verzeichnis muß gewählt werden:
cd pub/Xgraphics
Jetzt werden sämtliche Files kopiert.
mget *
Dabei fragt der Rechner bei jedem File, ob er es kopieren soll (Antwort y oder n).
Abschließend wird die Verbindung beendet:
bye
Außerdem existieren im World Wide Web einige Seiten zu Xgraphics, mit der kom-
pletten Dokumentation und gegebenenfalls Hinweisen zu neuen Versionen. Die
Adresse im World Wide Web ist:
http://www.physik.uni–wuerzburg.de/TP3/Xgraphics.html
An einem einfachen Beispiel wollen wir demonstrieren, wie man schon mit ganz
wenigen Befehlen ein physikalisches Problem auf dem Bildschirm darstellen kann,
nämlich die Zufallsbewegung eines Teilchens (random walk), für die es eine weit-
entwickelte mathematische Beschreibung gibt. Im Modell hüpft ein Teilchen zufäl-
lig auf einen der vier Nachbarplätze im Quadratgitter. Dies wird durch das folgende
C-Programm dargestellt:
270 Anhang D

#include <stdlib.h>
#include <math.h>
#include "Xgraphics.h"

#define MAXX 640

#define MAXY 480
#define N 250000

main()
{
int x=MAXX/2,y=MAXY/2,r,i;

InitX();
mywindow=CreateWindow(MAXX,MAXY,"random walk");
ShowWindow(mywindow);

for(i=0;i<N;i++)
{ DrawPoint(mywindow,x,y,1);
r=rand()/(RAND_MAX+1.)*4.;
switch(r)
{ case 0: x++;break;
case 1: x––; break;
case 2: y++;break;
case 3: y––;break; }
}
getchar();
ExitX();
}

D.1 Zufallsweg mit 250 000 Schritten

auf dem Quadratgitter.
Erste Schritte mit Xgraphics 271

x und y sind die Pixel-Koordinaten des Teilchens im Fenster, dessen Größe durch
MAXX und MAXY festgelegt ist. Gemäß der Zufallszahl r 2 f0; 1; 2; 3g werden sie
jeweils um den Wert eins erhöht oder erniedrigt. Mit fünf Graphikbefehlen kann
man also schon interessante Bewegungen auf dem Bildschirm erzeugen. Das Pro-
gramm mit dem Namen walk.c wird mit compile walk übersetzt und mit
walk aufgerufen. Dabei müssen eventuell im File compile die entsprechenden
Pfade der eigenen Maschine eingetragen werden, und das File muß mit chmod
u+x compile ausführbar gemacht werden. Das Ergebnis sollte das Bild D.1 sein.
Wenn man dann im aufrufenden Fenster ein Zeichen eingibt, verschwindet das Bild
mit dem Zufallsweg.
Weitere Demonstrationsprogramme, die auch die anderen Fähigkeiten von Xgra-
phics zeigen, finden sich auf der Diskette.

Literatur
M. Lüders, Einführung in Xgraphics, Postscript File auf beiliegender Diskette, au-
ßerdem erhältlich über FTP unter ftp.physik.uni–wuerzburg.de als
Xgraphics.ps im Verzeichnis /pub/Xgraphics/ .
O. Jones, Einführung in das X-Window System, Hanser Verlag, 1991.
Anhang E
Programme

In diesem Abschnitt wird ein Teil der Computer-Programme abgedruckt, und zwar
fast alle Mathematica-Programme und einige der C-Programme für den PC. Aus
Platzgründen können wir leider nicht alle Quellcodes drucken, aber alle Program-
me sind auf der beiliegenden Diskette vorhanden und können selbst ausgedruckt
werden. Die Namen der Mathematica-Programme sind durchgehend von der Form
name.m. Die PC-Versionen der C-Programme wurden mit Turbo C von Borland
kompiliert und sind als name.exe auf der beiliegenden Diskette vorhanden.
Einige der C-Programme kann man mit Tasten steuern, die auf dem Bildschirm in
der Zeile Befehle angezeigt werden. Der erste Buchstabe in dem erklärenden Wort
steuert den Algorithmus; so bedeutet exit, daß die Taste e das Programm beendet.
Alle Beispiele werden auch als Programme für UNIX oder LINUX auf der Diskette
mitgeliefert. Zusätzlich können sie, dann vielleicht in verbesserter Version, vom
FTP-Server des Institutes für Theoretische Physik der Universität Würzburg über
das Internet kopiert werden (siehe Anhang C). Die Verzeichnisse dort sind:
/pub/buch/cphys/dos/
/pub/buch/cphys/mathematica/
/pub/buch/cphys/unix/
/pub/Xgraphics/
Zusätzlich gibt es im World Wide Web Informationen zu den Programmen unter der
Adresse
http://www.physik.uni–wuerzburg.de/TP3/cphys.html

1.1 Funktion gegen Prozedur: summe.m und summe.c

Print[" Funktion gegen Prozedur"]
dataset=Table[Random[],{10000}];
average[data_,length_]:= Block[{sum,average},
sum=0.;
Do[sum=sum+data[[i]],{i,length}];
average=sum/length
]
average[data_]:=Apply[Plus,data]/Length[data]
Programme 273

summe.c
#include <stdlib.h>
#include <time.h>

main()
{
float average(float *,int);
int i;
clock_t start,end;
float dataset[10000];
clrscr();
for (i=0;i<10000;i++) dataset[i]=random(1000)/1000.;
start=clock();
for(i=0;i<99;i++) average(dataset,10000);
printf( " average = %f\n",average(dataset,10000));

end=clock();
printf( " Zeit= %f sec %d ",(end–start)/CLK_TCK,CLK_TCK);
getch();
}

float average( float* data,int n )

{
float sum=0. ;
int i;
for(i=0;i<n;i++) sum=sum+data[i] ;
return sum/n;
}

1.2 Pendel: pendel.m

Print[ " Nichtlineares Pendel "]
T[phi0_]=4 EllipticK[Sin[phi0/2]ˆ2]
plot1:=Plot[T[phi0],{phi0,0,Pi},PlotRange–>{0,30},
Frame –> True, FrameLabel–>{"phi0","T"}]
sinuspsi[t_,phi0_]=JacobiSN[t,Sin[phi0/2]ˆ2]
phiscal[x_,phi0_]=2 ArcSin[Sin[phi0/2]*
sinuspsi[x T[phi0],phi0]]/phi0
phi0[1]=N[.1 Pi]
phi0[2]=N[.8 Pi]
phi0[3]=N[.95 Pi]
phi0[4]=N[.99 Pi]
phi0[5]=N[.999 Pi]
fliste=Table[phiscal[x,phi0[i]],{i,5}]
274 Anhang E

plot2:=Plot[Evaluate[fliste],{x,0.,1.},
Frame –> True,
FrameLabel–>{"t/T","phi/phi0"},
PlotStyle –> Thickness[0.001]]
liste=Table[phiscal[x,N[.999 Pi]],{x,0,.99,.01}]
fouliste:=Take[Abs[Fourier[liste]],15]
plot3:= (gr1 = ListPlot[fouliste,PlotRange–>{{0,15},{–1,8}},
Frame –> True,
PlotStyle –> PointSize[0.02],
FrameLabel–>{"s","Abs[b(s)]"},
DisplayFunction –> Identity] ;
Show[gr1, Graphics[Line[{{0,0},{0,15}}]],
DisplayFunction –> $DisplayFunction ] )
f=1/Sqrt[1–m Sin[psi]ˆ2]
g=Series[f,{m,0,10}]
tseries=4 Integrate[g,{psi,0,Pi/2}] /. m–>Sin[phi0/2]ˆ2
e=phidotˆ2/2–Cos[phi]
plot4:=ContourPlot[e,{phi,–Pi,Pi},{phidot,–3,3},
Contours–>{–.5,0,.5,1,1.5,2},
ContourShading–>False,PlotPoints–>100,
FrameLabel –> {"phi", "phidot"}]

1.3 Fouriertransformation: fourier.m

Print[" Fouriertransformation"]
f[t_]=(Sign[1–t]+Sign[1+t])/2
fs[w_] = Integrate[Exp[I*w*t], {t, –1, 1}]/T // ComplexExpand
T=10
plot1:=Plot[fs[w],{w,–5Pi,5Pi}, PlotRange –> All]
p2liste:= p2liste = Table[ Abs[ fs[ k*2 Pi/T] ],{k,64}]
plot2:=(g1=ListPlot[p2liste,PlotJoined–>True,PlotRange–>All,
PlotStyle –> Thickness[0.0],
DisplayFunction –> Identity];
g2=ListPlot[p2liste,PlotRange–>All,
PlotStyle –> PointSize[0.015],
DisplayFunction –> Identity];
Show[g1,g2,DisplayFunction –> $DisplayFunction] )
fliste := fliste = Table[N[f[–5+10 r/64]],{r,64}]
fsliste := fsliste = Fourier[fliste]/Sqrt[64]
p3liste:= p3liste = Abs[fsliste ]
plot3:=(g1=ListPlot[p3liste, PlotJoined–>True,PlotRange–>All,
PlotLabel–>"Diskrete Fouriertransformation",
PlotStyle –> Thickness[0.0],
DisplayFunction –> Identity];
g2=ListPlot[p3liste,PlotRange–>All,
Programme 275

PlotStyle –> PointSize[0.015],

DisplayFunction –> Identity];
Show[g1,g2, DisplayFunction –> $DisplayFunction] )
fapp1[t_]:=Sum[fsliste[[s]] Exp[–2 Pi I /64 (s–1)(64t/T+31)],
{s,64}]//N
plot4:=Plot[{Re[fapp1[t]],f[t]},{t,–5,5}]
fapp2[t_]:=Sum[N[fsliste[[s]]*
Exp[–2 Pi I /64 (s–1)(64t/T+31)]],{s,32}]+
Sum[N[Conjugate[fsliste[[34–s]]]*
Exp[–2 Pi I /64 (s–33)(64t/T+31)]],{s,32}]
plot5:=Plot[{Re[fapp2[t]],f[t]},{t,–5,5}]

1.4 Datenglätten: glaetten.m

Print[" Daten glaetten mit Faltung"]
data = Table[N[BesselJ[1,x]+.2 (Random[]–1/2)],
{x,0,10,10./255}]
xdata = Range[0,10,10./255]
plot1 := p1 = ListPlot[Thread[Join[{xdata},{data}]],
PlotStyle–>PointSize[.01]]
sigma= 0.4
kern = Table[ N[ Exp[–xˆ2/(2*sigmaˆ2)]],{x,–5,5,10./255} ]
kern = RotateLeft[kern,127]
kern = kern/Apply[Plus,kern]
plot2:=p2=ListPlot[Thread[Join[{xdata},{kern}]],
PlotRange–>All]
glatt=Sqrt[256]*
InverseFourier[Fourier[data]*Fourier[kern]] //Chop
plot3:=p3=ListPlot[Thread[Join[{xdata},{glatt}]]]
plot4:=p4=Plot[BesselJ[1,x],{x,0,10},
PlotStyle –>Thickness[0.001]]
plot5:=Show[p1,p3,p4]

1.5 Nichtlinearer Fit: chi2.m

Print[ " Nichtlinearer Fit"]
Needs["Statistics‘Master‘"]
SeedRandom[12345]
daten = Table[{t,Sin[t] Exp[–t/10.]+.4 Random[]–.2}//N,
{t,0,3Pi,.3 Pi}]
plot1:= (gr1 = ListPlot[daten,PlotStyle –> PointSize[0.02],
DisplayFunction –> Identity];
gr2 = Plot[Sin[t] Exp[–t/10.],{t,0,3Pi},
DisplayFunction –> Identity];
Show[gr1,gr2, DisplayFunction –> $DisplayFunction])
276 Anhang E

f[t_]=a Sin[om t + phi] Exp[–t b]

sigma2=NIntegrate[xˆ2,{x,–.2,.2}]/.4
sigma = Sqrt[sigma2]
quadrat[{t_,y_}]=(y–f[t])ˆ2/sigma2
chi2=Apply[Plus,Map[quadrat,daten]]
find:=FindMinimum[chi2,{a,0.9},{om,1.1},{phi,0.1},{b,.2}]
fit:=NonlinearFit[daten,f[t],t,
{{a,1.1},{om,1.1},{phi,.1},{b,.2}},
ShowProgress–>True]
pvalue[x_]=1.–CDF[ChiSquareDistribution[7],x]
intervall={Quantile[ChiSquareDistribution[7],.05],
Quantile[ChiSquareDistribution[7],.95]}
grenze[x_]=Quantile[ChiSquareDistribution[4],x]

plot2:=Plot[PDF[ChiSquareDistribution[7],x],{x,0,20}]
rule = NonlinearFit[daten,f[t],t,
{{a,1.1},{om,1.1},{phi,.1},{b,.2}}]
a0=a/.rule; b0=b/.rule; om0=om/.rule; phi0=phi/.rule;
chi2min = chi2/.rule

plot3:=ContourPlot[chi2/.{phi–>phi0,om–>om0},
{a,.4,1.3},{b,–.04,.2},
ContourShading–>False,
Contours–>{chi2min+grenze[.683],chi2min+grenze[.9]},
PlotPoints–>50,FrameLabel–>{"a","b"}]

plot4:=ContourPlot[chi2/.{phi–>phi0,a–>a0},
{om,.90,1.05},{b,0.0,.15},
ContourShading–>False,
Contours–>{chi2min+grenze[.683],chi2min+grenze[.9]},
PlotPoints–>50,FrameLabel–>{"om","b"}]
g[t_]= f[t]/.rule
step:=(daten2=N[Table[{t,g[t] + .4 Random[]–.2},
{t,0,3Pi,.3 Pi}]];
NonlinearFit[daten2,f[t],t,
{{a,a0},{om,om0},{phi,phi0},{b,b0}}] )
tab:= tab = Table[{chi2,a,b,om,phi}/.step,{100}]
abtab := Map[Take[#,{2,3}]&,tab]

plot5:= ListPlot[abtab,PlotRange–>{{.4,1.2},{–0.045,.2}},
AspectRatio –> 1, Frame –> True,
FrameLabel –>{"a","b"}, Axes –> None,
PlotStyle –> PointSize[0.01]]
Programme 277

1.6 Multipole: multipole.m

Print[" Multipole fuer ein statisches Potential "]
SeedRandom[123456789]
rpunkt:={2Random[]–1,2Random[]–1,0}
Do[r[i]=rpunkt,{i,10}]
p1=Graphics[Table[Line[{Drop[r[i],–1]–{0.08,0},
Drop[r[i],–1]+{0.08,0}}],{i,5}]]
p2=Graphics[Table[Line[{Drop[r[i],–1]+{0,0.08},
Drop[r[i],–1]–{0,0.08}}],{i,5}]]
p3=Graphics[Table[Line[{Drop[r[i+5],–1]–{0.08,0},
Drop[r[i+5],–1]+{0.08,0}}],{i,5}]]
p4=Graphics[{Thickness[0.001],
Table[Circle[Drop[r[i], –1], 0.1],{i,10}]}]
plot1:=Show[p1, p2, p3, p4, Frame –>True,
AspectRatio –> Automatic,
PlotRange –> {{–2, 2}, {–2, 2}},
FrameLabel –> {"x", "y"}]
dist[r_,s_]=Sqrt[(r–s).(r–s)]
pot[rh_]:=Sum[ 1/dist[rh,r[i]]–1/dist[rh,r[i+5]] ,{i,5}]
plot2:=Plot3D[pot[{x,y,0}] ,{x,–2,2},{y,–2,2},
AxesLabel–>{"x","y","Phi"},
PlotRange –> {–8,8},
PlotPoints–>40]
plot3:=ContourPlot[pot[{x,y,0}] ,{x,–2,2},{y,–2,2},
PlotPoints–>40,
ContourShading–>False,AxesLabel–>{"x","y"} ]
quadrupol[r_]:=Table[3 r[[k]] r[[l]] – If[k==l,r.r,0],
{k,3},{l,3}]
qsum=Sum[quadrupol[r[i]]–quadrupol[r[i+5]],{i,5}]
betrag[r_]=Sqrt[r.r]
dipol=Sum[r[i]–r[i+5],{i,5}]
pot1[r_] = dipol.r/betrag[r]ˆ3
pot2[r_] = pot1[r] + 1/2/betrag[r]ˆ5 * r.qsum.r
weg={.6,y,0}
plot4:=Plot[{ pot1[weg],pot2[weg],pot[weg]},{y,–2,2},
Frame –> True,
FrameLabel –> {"{.6,y,0}","Potential"},
PlotStyle –> {Dashing[{.01,.01}],
Dashing[{.03,.03}],Dashing[{1.0,0}]}]
Needs["Graphics‘PlotField‘"]
efeld=–{D[pot[{x,y,0}],x],D[pot[{x,y,0}],y]}
richtung=efeld/betrag[efeld]
plot5:=PlotVectorField[richtung,{x,–10,10},{y,–10,10},
PlotPoints–>30]
278 Anhang E

1.7 Wegintegrale: wegintegrale.m

Print[" Wegintegrale"]
r1={Cos[2Pi t],Sin[2Pi t],t}
r2={1,0,t}
r3={1–Sin[Pi t]/2,0,1/2(1–Cos[Pi t])}
p1:=ParametricPlot3D[Evaluate[r1],{t,0,1},
DisplayFunction–>Identity]
p2:=ParametricPlot3D[Evaluate[r2],{t,0,1},
DisplayFunction–>Identity]
p3:=ParametricPlot3D[Evaluate[r3],{t,0,1},
DisplayFunction–>Identity]
plot1:=Show[p1,p2,p3,PlotLabel–>" Wegintegrale",
AxesLabel–>{"x","y","z"},
DisplayFunction–>$DisplayFunction]
k[{x_,y_,z_}]={2 x y +zˆ3,xˆ2,3 x zˆ2}
v[r_]:=D[r,t]
int[r_]:=Integrate[k[r].v[r],{t,0,1}]
r4=t{x,y,z}
rot[{kx_,ky_,kz_}]:={ D[kz,y]–D[ky,z],
D[kx,z]–D[kz,x],
D[ky,x]–D[kx,y] }

1.8 Maxwell-Konstruktion: maxwell.m

Print [ " Maxwell–Konstruktion fuer das van der Waals–Gas "]
pp=t/(v–b)–a/vˆ2
gl1=D[pp,v]==0
gl2=D[pp,{v,2}]==0
sol=Solve[{gl1,gl2},{t,v}]
pc=pp/.sol[[1]]
p[v_] = 8 t/(3 v–1)–3/vˆ2
Off[Integrate::gener]
gl3 = p[v1]==p[v3]
gl4 = p[v1]*(v3–v1)==Integrate[p[v],{v,v1,v3}]
On[Integrate::gener]
pmax[v_]:=If[v < vleft || v > vright, p[v], p[vleft]]
plot[T_]:= Block[{}, t = T;
If[ t >= 1,
Plot[p[v], {v, .34, 5.},
PlotRange –> {{0,5},{0,2}},
Frame –> True,
FrameLabel –> {"v","p"}],
vmin = v /. FindMinimum[ p[v], {v,0.4}][[2]];
vmax = v /. FindMinimum[–p[v], {v,1.}][[2]];
Programme 279

vtest = (vmin + vmax)/2 ;

r = Solve[ p[v] == p[vtest], v];
v1start = v /. r[[1]];
v3start = v /. r[[3]];
frs = Chop[FindRoot[{gl3,gl4},{v1,v1start},
{v3,v3start}]];
vleft=v1/.frs; vright=v3/.frs;
Plot[{pmax[v],p[v]},{v,0.34,5.},
PlotRange–>{{0,5},{0,2}},
Frame –> True, FrameLabel –> {"v","p"} ]]]

1.9 Beste Spielstrategie: spiel.c

Nur auf Diskette vorhanden.

2.1 Quantenoszillator: quantenoszi.m

Print[" Quantenoszillator"]
q[j_,k_]:= Sqrt[(j+k+1)]/2 /; Abs[j–k]==1
q[j_,k_]:= 0 /; Abs[j–k]!= 1
q[n_]:= Table[q[j,k], {j,0,n–1}, {k,0,n–1}]
h0[n_]:= DiagonalMatrix[Table[i+1/2,{i,0,n–1}]]
h[n_]:= h0[n] + lambda q[n].q[n].q[n].q[n]
ev[n_]:= Eigenvalues[h[n]]
plot1:= Plot[Evaluate[ev[4]], {lambda, 0, 1},
Frame –> True,
FrameTicks –> {Automatic,
Table[{0.5*j,If[EvenQ[j],ToString[j/2],""]},{j,19}]},
FrameLabel –> {"lambda","Energie"},
PlotLabel –>"Eigenwerte von h[4]" ]
evnum[n_,la_]:= Sort[Eigenvalues[N[h[n]/. lambda–>la]]]
evdimlist[n_,la_]:= Table[{1/i, evnum[i,la][[1]]}, {i,7,n}]
plot2:=( gr1=ListPlot[evdimlist[20,.1],
Axes –> None, Frame –> True,
PlotRange –> All,
FrameLabel –> {"1/n","E0(n)"},
PlotStyle –> PointSize[0.02],
DisplayFunction –> Identity] ;
gr2 = Graphics[{Thickness[0.001],
Line[{{1/20,0.559146327},
{1/7 ,0.559146327}}]}];
Show[gr1,gr2,DisplayFunction –> $DisplayFunction] )
evlist:= evlist= Table[{la,evnum[20,la]},{la,0,1,.05}]
ev2[k_]:=Table[{evlist[[i,1]],evlist[[i,2,k]]},
{i,Length[evlist]}]
plot3:= ( Table[gr[k]=ListPlot[ev2[k],PlotJoined –>True,
280 Anhang E

DisplayFunction –> Identity,

Frame –> True,
FrameLabel –> {"lambda","Energie"},
FrameTicks –> {Automatic,
Table[{0.5*j,If[EvenQ[j],ToString[j/2],""]},
{j,21}]}],{k,5}];
Show[gr[1],gr[2],gr[3],gr[4],gr[5],
DisplayFunction –> $DisplayFunction] )

2.2 Elektrische Schwingkreise: netz.m

Print[" Elektrische Schaltkreise"]
gl1={vr+va==1,ir==ic+il,vr==ir r,
va==ic/(I omega c),va==I omega l il}
sol=Solve[gl1,{va,vr,ir,ic,il}][[1]]
vas=(va/.sol)//Simplify
numwert = {c –> N[10ˆ(–6)], l –> N[10ˆ(–3)]}
vasnum = vas /. numwert
fliste=Table[vasnum /.r–>100.0*3ˆs, {s,0,3}]
plot1:=Plot[Evaluate[Abs[fliste]],{omega,20000,43246},
PlotRange–>{0,1}, Frame –> True,
FrameLabel –> {"omega","Abs[va]"},
FrameTicks –> {{20000,30000,40000},Automatic} ]
plot2:=Plot[Evaluate[Arg[fliste]],{omega,20000,43246},
Frame –> True,
FrameLabel –> {"omega","Phase(va)"},
FrameTicks –> {{20000,30000,40000},Automatic} ]
vsaege[t_] := –1+2 t/T
omegares=1/Sqrt[l c] /. numwert //N
aliste=Table[N[vsaege[(n–1)/256 T]],{n,256}]
bliste=InverseFourier[aliste]
plot3[fac_,w_]:=Block[{valiste,vtrans,omegai,plotlist},
omegai = fac*omegares;
valiste=Join[
Table[vasnum/.{omega–>omegai*(s–1),r–>w},
{s,128}],{0.0},
Table[vasnum/.{omega–>omegai*(s–128),r–>w},
{s,1,127}] ];
vtrans=Fourier[bliste valiste]//Chop;
plotlist=Table[{k/256,vtrans[[Mod[k–1,256]+1]]},
{k,768}];
ListPlot[plotlist,
Frame –> True,
FrameLabel–>{"t/T","va(t)"},
PlotRange –> All]]
Programme 281

gl2={ir(r + 1/(I omega c) + I omega l) + va ==1,

ir == (I omega c + 1/(I omega l)) va }
sol2=Solve[gl2,{va,ir}][[1]]
vas2=(va/.sol2)//Simplify
irs = Simplify[ir /. sol2]
leistung = rˆ2 Abs[irs]ˆ2
fliste3=Table[Abs[vas2] /. numwert /. r–>10*3ˆs ,{s,0,2}]
plot4:=Plot[Evaluate[fliste3],{omega,10000,70000},
PlotRange–>All,Frame –> True,
PlotStyle–>{Thickness[0.006],Dashing[{.01,.008}],
Thickness[0.003]},
FrameTicks –> {{10000,30000,50000,70000},Automatic},
FrameLabel –>{"omega","|va|"}]
plot5:=Plot[(leistung/.numwert)/.r–>10.0,{omega,10000,70000},
PlotRange–>All,Frame –> True,
FrameTicks –> {{10000,30000,50000,70000},
Automatic},
FrameLabel –>{"omega","P/P0"}]

2.3 Kettenschwingungen: kette.m

Print[" Kettenschwingungen "]
mat1 = { { 2f , –f , 0 , –f*Exp[–I q] },
{ –f , 2f , –f , 0 },
{ 0 , –f , 2f , –f },
{ –f*Exp[I q] , 0 , –f , 2f } }
massmat=DiagonalMatrix[{m1,m1,m1,m2}]
mat2=Inverse[massmat].mat1
eigenlist=Table[{x,
Chop[Eigenvalues[
mat2/.{f –> 1., m1 –> 0.4, m2 –> 1.0, q–> x}]]},
{x,–Pi,Pi,Pi/50}]
plotlist=N[Flatten[Table[
Map[{#[[1]],Sqrt[#[[2,k]]]}&,
eigenlist],{k,4}],1]]
plot1 := ListPlot[plotlist,FrameLabel –> {"q","omega"},
Frame –> True,Axes –> None,
FrameTicks –>{{{–Pi,"–Pi"},{–Pi/2,"–Pi/2"},
{0,"0"},{Pi/2,"Pi/2"},{Pi,"Pi"}},
Automatic}]
eigensys := Thread[Chop[Eigensystem[mat2 /.
{f –> 1., m1 –> 0.4, m2 –> 1.0, q–>0.0}]]]
282 Anhang E

2.4 Hofstadter-Schmetterling: hofstadt.c

/* Hofstadter–Schmetterling */

#include <math.h>
#include <graphics.h>

#define q 200
#define maxy 200
#define SHIFT 150

main()
{
int ie, n, nalt, m, p;
double sigma, pi, e, polyalt, poly, polyneu;
int gdriver=DETECT,gmode;

initgraph(&gdriver,&gmode,"\\tc");
pi=acos(–1.);
outtextxy(250,400,"Befehl: exit");
for(p = 1; p < q; p++)
{
sigma = 2.0*pi*p/q;
nalt = 0;
for(ie = 0; ie < maxy+2 ; ie++)
{
e = 8.0*ie/maxy – 4.0 – 4.0/maxy ;
n = 0;
polyalt = 1.0; poly = 2.0*cos(sigma) – e;
if( polyalt*poly < 0.0 ) n++ ;

for( m = 2; m < q/2; m++ )

{
polyneu = ( 2.0*cos(sigma*m) – e )*poly – polyalt;
if( poly*polyneu < 0.0) n++;
polyalt = poly; poly = polyneu;
}
/* Die geraden Eigenfunktionen sind auskommentiert.
polyalt = 1.0; poly = 2.0 – e;
if( polyalt*poly < 0.0 ) n++ ;
polyneu = ( 2.0*cos(sigma) – e)*poly – 2.0*polyalt;
if( poly*polyneu < 0.0) n++;
polyalt = poly; poly = polyneu;
for( m = 2; m < q/2; m++ )
{ polyneu = ( 2.0*cos(sigma*m) – e)*poly – polyalt;
Programme 283

if( poly*polyneu < 0.0) n++;

polyalt = poly; poly = polyneu;}
polyneu = ( 2.0*cos(sigma*q/2)–e)*poly–2.0*polyalt;
if( poly*polyneu < 0.0) n++;
*/
if(n > nalt) putpixel(p+SHIFT,ie+SHIFT,WHITE);
nalt = n;

}; /* ie–Schleife */
if(kbhit()) {getch();break;}
}; /* p–Schleife */
getch(); closegraph();
}

2.5 Hubbard Modell: hubbard.m

Print[" Hubbard–Modell"]; Print[""]
sites = Input[" Anzahl der Plaetze: "] ; Print[""]
particles = Input[" Anzahl der Teilchen: "]; Print[""]
spinup = Input[" Davon SpinUp–Teilchen: "] ; Print[""]
spindown = particles – spinup
tkin = –2.*t*(Sum[N[Cos[2*Pi/sites k]],
{k,–Floor[(spinup–1)/2],Floor[spinup/2]}]+
Sum[N[Cos[2*Pi/sites k]],
{k,–Floor[(spindown–1)/2],Floor[spindown/2]}])
Print[""]
Print[" Die Grundzustandsenergie fuer U = 0 ist: " ,tkin]
left = Permutations[ Table[ If[ j <= spinup, 1, 0],
{j,sites}] ]
right = Permutations[ Table[ If[ j <= spindown, 1, 0],
{j,sites}] ]
index = Flatten[ Table[ {left[[i]],right[[j]]},
{i,Length[left]}, {j,Length[right]} ],1]
end = Length[index]
plus[k_,sigma_][arg_]:= ReplacePart[arg,1,{sigma,k}]
minus[k_,sigma_][arg_]:= ReplacePart[arg,0,{sigma,k}]
sign[k_,sigma_,arg_] := (–1)ˆ(spinup*(sigma–1))*
(–1)ˆ(Sum[ arg[[sigma,j]],{j,k–1}])
cdagger[sites+1,sigma_][any_] := cdagger[1,sigma][any]
c[sites+1,sigma_][any_] := c[1,sigma][any]
cdagger[k_,sigma_][0]:= 0
c[k_,sigma_][0]:= 0
cdagger[k_,sigma_][factor_. z[arg_]]:=
factor*(1 – arg[[sigma,k]])*
sign[k,sigma,arg]*z[plus[k,sigma][arg]]
284 Anhang E

c[k_,sigma_][factor_. z[arg_]]:=
factor*arg[[sigma,k]]*
sign[k,sigma,arg]*z[minus[k,sigma][arg]]
n[k_,sigma_][0]:= 0
n[k_,sigma_][factor_. z[arg_]]:= factor*arg[[sigma,k]]*z[arg]
scalarproduct[a_,0] := 0
scalarproduct[a_,b_ + c_]:=scalarproduct[a,b]+
scalarproduct[a,c]
scalarproduct[z[arg1_],factor_. z[arg2_]]:=
factor* If[arg1==arg2,1,0]
H[vector_] = Expand[
–t*Sum[cdagger[k,sigma][c[k+1,sigma][vector]] +
cdagger[k+1,sigma][c[k,sigma][vector]] ,
{k,sites},{sigma,2} ] +
u*Sum[n[k,1][n[k,2][vector]] ,{k,sites}] ]
Print[""];Print[" "]
Print[" Die Hamilton – Matrix wird berechnet. " ]
Print[""]
Print[" Die Dimension dieser Matrix ist ",end,
" x ",end,"."]
h = ( hlist = Table[H[z[index[[j]]]], {j, end}];
Table[ scalarproduct[ z[index[[i]]], hlist[[j]] ],
{i,end}, {j,end}] )
Print[""]
Print[" Die Energie – Eigenwerte",
" werden berechnet."]
zustand = Chop[Table[Flatten[
{x,Sort[Eigenvalues[h/.{t –> 1.,u –> x}]]}],
{x, 0., 6., .1}]]
Print[""];Print[" "]
Print[" Die folgenden Befehle sind moeglich: "]
Print[" "]
Print[" plot1 => Vielteilchen–Spektrum in",
" Abhaengigkeit von U/t "]
Print[" "]
Print[" plot2 => Doppelbesetzung im",
" Grundzustand als Funktion von U/t "]
Print[" "]
Print[" plot3 => Vergleich: exaktes Resultat",
" fuer N –> Unendlich"]
Print[" mit endlichem N, Energie pro",
" Platz im Grundzustand"]
plot1 := Show[
Table[ListPlot[Map[{#[[1]],#[[j]]}&,zustand],
Frame–>True,Axes–>None,
Programme 285

DisplayFunction –> Identity,

PlotStyle–>{PointSize[0], Thickness[0.0]},
PlotJoined–>True,
FrameLabel–>{"U/t","Energie/t"} ],
{j,2,end+1}], DisplayFunction –> $DisplayFunction]
g[uu_]:= Chop[Sort[Thread[
Eigensystem[N[ h/.{t –> 1.0,u –> uu}]]]][[1,2]]]
nnsum = Map[#[[1]].#[[2]]&,index]/sites
md[u_]:= (Abs[g[u]]ˆ2).nnsum
plot2:= (ll = Sort[Eigenvalues[ h /. {t –> 1.0, u –> 1.0}]];
If[ll[[1]]==ll[[2]],
text = "Achtung: Grundzustand ist entartet!",
text = ""];
Plot[md[u], {u,0.0,6},
Axes –> None, Frame –> True, FrameLabel–>
{"U/t","Doppelbesetzung",text,""}] )
plot3:= (grundzustand = Map[{#[[1]],#[[2]]/sites}&,zustand];
g1 = ListPlot[grundzustand,Frame–>True,Axes–>None,
PlotStyle–>PointSize[0],PlotJoined–>True,
FrameLabel–>{"U/t","Energie pro Platz/t"},
DisplayFunction –> Identity ];
f[u_,0] = 1/4 ;
f[u_,0.0] = 0.25 ;
f[u_,x_] = BesselJ[0,x]*BesselJ[1,x]/(x*(1+Exp[x u/2]));
plotlist = Table[{u,–4.0*
NIntegrate[f[u,x],{x,0,5.52}]},{u,0,6,.2}];
g2 = ListPlot[plotlist,
PlotJoined –> True,DisplayFunction –> Identity,
PlotStyle –> Dashing[{0.01,0.01}]];
Show[g1, g2, DisplayFunction –> $DisplayFunction] )

3.1 Populationsdynamik: logabb.c und logabb.m

/***** Populationsdynamik *****/

#include <stdlib.h>
#include <graphics.h>
#include <math.h>

int maxx,maxy;

main()
{
void kanal(double);
int gdriver=DETECT,gmode;
286 Anhang E

char ch,str[100];
double xit=0.4,rmin=.88,r;
int x,y=50,i,ir;
initgraph(&gdriver,&gmode,"\\tc");
maxx=getmaxx();
maxy=getmaxy();
setcolor(YELLOW);
settextstyle(1,0,1);
outtextxy(100,maxy–80,
" Logistische Abbildung x = 4 r x (1–x)");
settextstyle(0,0,1);
outtextxy(50,maxy–30,
" Befehle : tief,hoch,clearscreen,print r,kanal,exit ");
setviewport(1,1,maxx,maxy–100,1);
r=1.–(1.–rmin)*y/(maxy–100);
while(1)
{
xit=4.*r*xit*(1.–xit);
x=xit*maxx;
putpixel(x,y,WHITE);
if(kbhit())
{
switch(getch())
{ case ’t’: if(y<(maxy–100)) y+=1;break;
case ’h’: if(y>1) y–=1;break;
default : getch();break;
case ’e’: closegraph(); exit(1);
case ’k’: kanal(r);break;
case ’p’: sprintf(str," r= %lf",r);
outtextxy(1,y,str);
break;
case ’c’: clearviewport();break;
} /* switch */
r=1.–(1.–rmin)*y/(maxy–100);
for(i=0;i<100;i++) xit=4.*r*xit*(1.–xit);
} /* if */
}/* while */
}/* main */

void kanal( double r)

{
double xit=.4;
int x,y[1000],i;
clearviewport();
for (i=0;i<maxx;i++) y[i]=0;
Programme 287

line(0,maxy–100,maxx,maxy–100);
while(!kbhit())
{ xit=4.*r*xit*(1.–xit);
x=xit*maxx;
y[x]++;
putpixel(x,maxy–100–y[x],WHITE);
}
getch();getch();clearviewport();return;
}

logabb.m
Print [" Logistische Abbildung"]
f[x_]=4 r x(1–x)
iterf[n_]:=Nest[f,x,n]
plot1:=Plot[Evaluate[{x,f[x],iterf[2],iterf[4]}/.r–>.87],
{x,0,1}, Frame –> True,
PlotStyle –> {{Thickness[0.002],GrayLevel[0]},
{Thickness[0.002],
Dashing[{0.003,0.003}]},
{Thickness[0.002],GrayLevel[.6]},
{Thickness[0.002],GrayLevel[0]}},
FrameLabel –> {"x","f[f[f[f[x]]]]"} ]
nf[x_,r_]=N[f[x]]
list1[r_,n_]:=NestList[nf[#,r]&,.65,n]
plot2:= (liste=list1[.87,40];
g1=ListPlot[liste,PlotStyle –> PointSize[0.02],
DisplayFunction –> Identity ];
g2=ListPlot[liste,PlotJoined–>True,
PlotStyle –> {Thickness[0.002],GrayLevel[.7]},
FrameLabel –> {"n","x(n)"},
DisplayFunction –> Identity ];
Show[g2, g1, Frame –> True,
DisplayFunction –> $DisplayFunction] )
plot3[r_:0.87464]:=(g1=Plot[nf[x,r],{x,0,1},
DisplayFunction –> Identity];
xx=Nest[nf[#,r]&,0.3,500];
li1=NestList[{nf[#[[1]],r],nf[#[[2]],r]}&,
{xx,nf[xx,r]},1000];
li2 = Flatten[Map[{{#[[1]],#[[2]]},
{#[[2]],#[[2]]}}&,li1],1];
li3=Flatten[Map[{{#[[1]],#[[2]]}}&,li1],1];
g2=ListPlot[li3,PlotRange –> {{0,1},{0,1}},
PlotStyle –> PointSize[0.015],
DisplayFunction –> Identity ];
288 Anhang E

g3=ListPlot[li2,PlotRange –> {{0,1},{0,1}},

PlotJoined –> True,
PlotStyle –> Thickness[0],
DisplayFunction –> Identity ];
g4=Graphics[Text[
StringJoin["r = ",ToString[r]],{0.5,0.05}]];
g5=Graphics[Line[{{0,0},{1,1}}]];
Show[g1,g2,g3,g4,g5,PlotRange –> {{0,1},{0,1}},
AspectRatio –> Automatic,
Frame –> True,
DisplayFunction –> $DisplayFunction])
h[x_]=97/25 x(1–x)
hl[n_]:=NestList[h,N[1/3],n]
hl[n_,prec_]:=NestList[h,N[1/3,prec],n]
tab:=Table[{prec,Precision[Last[hl[100,prec]]]},
{prec,16,100}]
plot4:=ListPlot[tab, Frame –> True,
PlotStyle –> PointSize[0.01],
FrameLabel –>
{"Rechengenauigkeit","Ergebnisgenauigkeit"}]
periode[1]={c,1}
genau=30
maxit=30
periode[n_]:=periode[n]=Join[periode[n–1],
correct[periode[n–1]]]
correct[list_]:=Block[{sum=0,li=list,l=Length[list]},
Do[sum+=li[[i]],{i,2,l}];
If[OddQ[sum],li[[1]]=0,li[[1]]=1];
li]
g[n_,mu_]:=Block[{x=Sqrt[mu],l=Length[periode[n]]},
Do[x=Sqrt[mu+(–1)ˆ(periode[n][[i]]) x],
{i,l,3,–1}]; x]
fr[n_]:=fr[n]=(find=FindRoot[g[n,mu]==mu,{mu,{15/10,16/10}},
AccuracyGoal–>genau,
WorkingPrecision–>genau,
MaxIterations–>maxit];
mu/.find)
rr[n_]:= rr[n] = (1+Sqrt[1+4*fr[n]])/4
delta[1]:= Print[" Der Wert von n ist zu klein"]
delta[2]:= Print[" Der Wert von n ist zu klein"]
delta[n_]:= delta[n]=(Sqrt[1+4*fr[n–1]]–Sqrt[1+4*fr[n–2]])/
(Sqrt[1+4*fr[n]]–Sqrt[1+4*fr[n–1]])
feigenbaum :=
Do[Print[" n = ",n,
" Feigenbaum–Konstante = ",delta[n]],{n,3,20}]
Programme 289

3.2 Kette auf dem Wellblech: frenkel.c und frenkel.m

/* Frenkel–Kontorova–Modell */

#include <math.h>
#include <stdlib.h>
#include <graphics.h>

main()
{
int gdriver=DETECT,gmode;
int xb,yb,color=WHITE,maxx,maxy;
long nsum=0;
double k=1.,sig=.4,p=0.,x=0.,pi=M_PI,xneu,
pneu,h=0.,wind=0.,xalt,palt;
char ch,str[1000];

initgraph(&gdriver,&gmode,"\\tc");
maxx=getmaxx();
maxy=getmaxy();
outtextxy(100,maxy–70," Frenkel–Kontorova–Modell");
outtextxy(300,maxy–70," Befehle: neu, print, exit");
xalt=x; palt=p;
while(1)
{
pneu=p+k/2./pi*sin(2.*pi*x);
xneu=pneu+x;
xb=fmod(xneu+100.,1.)*maxx;
yb=(1.–fmod(pneu+100.,1.))*(maxy–100);
putpixel(xb,yb,color);
wind+=xneu–x;
x=xneu; p=pneu;
h+=k/4./pi/pi*(1.–cos(2.*pi*x))+(p–sig)*(p–sig)/2.;
nsum++;

if(kbhit())
{ switch(getch())
{case ’e’ : closegraph(); exit(1);
case ’n’ : x=xalt=(double) rand()/RAND_MAX;
p=palt=(double) rand()/RAND_MAX;
color=random(getmaxcolor())+1;
h=0.;wind=0;nsum=0;break;
case ’p’ :
sprintf(str,
" Energie= %lf Windungszahl= %lf (x,p)= %lf,%lf",
290 Anhang E

h/nsum,wind/nsum,xalt,palt);
setviewport(10,maxy–50,maxx,maxy,1);
clearviewport();
outtextxy(1,1,str);
setviewport(1,1,maxx,maxy,1); break;
default : getch();break;
}/* switch */
}/* if */
}/* while */
}/* main */

frenkel.m
Print[" Frenkel– Kontorova– Modell"]
pi = N[Pi]
k=1.
sigma=.4
nmax=1000
t[{x_,p_}] = {x + p + k/(2 pi) Sin[2 pi x],
p + k/(2 pi) Sin[2 pi x] }
list[x0_,p0_]:= NestList[t,{x0,p0},nmax]
xlist[x0_,p0_]:= Map[First,list[x0,p0]]
tilde[{x_,p_}]:= {Mod[x,1],Mod[p,1]}
listt[x0_,p0_]:= Map[tilde,list[x0,p0]]
plot1[x0_:.06,p0_:.34]:= ListPlot[listt[x0,p0],
Frame –> True, Axes –> None,
FrameLabel–>{"x","p"},
RotateLabel –> False,
PlotStyle –> PointSize[0.00]]
plot2[x0_:.06,p0_:.34]:=
(xl=Map[First, NestList[t,{x0,p0},10]];
tab=Table[{xl[[m]],k/(2 pi)ˆ2*(1–Cos[2 pi xl[[m]]])},
{m,11}];
p1=ListPlot[tab, PlotStyle –> PointSize[0.03],
DisplayFunction–>Identity];
p2=Plot[k/(2 pi)ˆ2*(1–Cos[2 pi x]),
{x,xl[[1]],xl[[11]]},
DisplayFunction–>Identity];
Show[p1,p2,DisplayFunction–>$DisplayFunction,
Frame –> True] )
plot3[x0_:.06,p0_:.34]:=
(xl=Map[First, NestList[t, {x0,p0}, 99]];
ListPlot[Mod[xl,1],
Frame –> True,FrameLabel–>{"n","x(n)"},
PlotStyle –> PointSize[0.013] ])
Programme 291

de[{x_,p_}]:=k/(2 pi)ˆ2(1–Cos[2 pi x])+0.5(p – sigma)ˆ2

h[x0_:.0838,p0_]:=(ll1=list[x0,p0]; ll2 = Map[de,ll1] ;
Apply[Plus,ll2]/Length[ll2])
wind[x0_:.0838,p0_]:=(w1=xlist[x0,p0];
(w1[[–1]]–w1[[1]])/nmax )
hp0:=Table[{p0,h[.0838,p0]},{p0, .2, .4, .01}]
plot4:= ListPlot[hp0, Frame –> True,
FrameLabel–>{"p0","Energie"},
PlotStyle –> PointSize[0.013]]
hx0:=Table[{x,h[x,.336]},{x,.15,.2,.001}]
plot5:=ListPlot[hx0,Frame –> True,Axes –> None,
FrameLabel–>{"x0","Energie"},
PlotStyle –> PointSize[0.013]]
windp0:=Table[{p0,wind[p0]},{p0,0.2,.4,.01}]
plot6:=ListPlot[windp0, Frame –> True,
FrameLabel–>{"p0","windungszahl"},
PlotStyle –> PointSize[0.013] ]

3.3 Fraktale Packung: sierp.c und sierp.m

/***** Fraktales Gitter *****/

#include <graphics.h>
#include <stdlib.h>
#include <math.h>

main()
{
int gdriver=DETECT,gmode;
struct {int x;int y;} pt={10,10},pw,
p[3]={{1,1},{500,30},{200,300}};
initgraph(&gdriver,&gmode,"\\tc");

while(!kbhit())
{
pw=p[random(3)];
pt.x=(pw.x+pt.x)/2;
pt.y=(pw.y+pt.y)/2;
putpixel(pt.x,pt.y,WHITE);
}
getch();getch();
closegraph();
}
292 Anhang E

sierp.m
Print[ "Erzeugt und plotted einen Sierpinsky gasket "]
list={{{0.,0.},{.5,N[Sqrt[3/4]]},{1.,0.}}}
verv[d_]:=Block[ {d1,d2,d3},
d1={d[[1]],(d[[2]]+d[[1]])*.5,(d[[3]]+d[[1]])*.5};
d2=d1+Table[(d1[[3]]–d1[[1]]),{3}];
d3=d1+Table[(d1[[2]]–d1[[1]]),{3}];
{d1,d2,d3} ]
plot1:= Block[{listzw,plotlist},
listzw=Map[verv,list];
list=Flatten[listzw,1];
plotlist=Map[Polygon,list];
Show[Graphics[plotlist],
AspectRatio –> Automatic]]

3.4 Neuronales Netzwerk: nnf.c und nn.c

nn.c ist nur auf Diskette vorhanden.

#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <stdio.h>

#define N 10
#define N2 20

float runs=0,correct=0;

main(int argc, char * argv[] )

{
int neuron[N2],input,i;
float weight[N2],h,wsum,kappa=1.;
char ch,str[100];
FILE * fp;

if(argc==1){
printf(" Welche Eingabedatei ? ");
scanf("%s",str);
}
else strcpy(str,argv[1]);

if((fp=fopen(str,"r"))==NULL)
{ printf(" Datei nicht vorhanden ! ");exit(1); }
Programme 293

printf(" Auswertung der Datei %s laeuft ",str);

for(i=0;i<N2;i++) { neuron[i]=1; weight[i]=(float)i/N;
}
while(feof(fp)==NULL)
{
switch(fgetc(fp))
{
case ’1’ : input=1; runs++;break;
case ’0’ : input=–1; runs++;break;
default : continue;
}
for(h=0.,i=0 ;i<N ;i++) h+=weight[i]*neuron[i];
for(wsum=0.,i=0; i<N; i++) wsum+=weight[i]*weight[i];
if(h*input>0.) correct++;
if( h*input < kappa*sqrt(wsum) )
for(i=0;i<N;i++) weight[i]+=input*neuron[i]/(float)N;
for(i=N2–1;i>0;i––) neuron[i]=neuron[i–1];
neuron[0]=input;
}
if(runs!=0) printf("\n Anzahl der Eingaben: %6.2f",runs);
printf(
"\n %6.2f %% richtige Vorhersagen",correct/runs*100.);
fclose(fp);
getch();
}

4.1 Runge-Kutta-Methode: rungek.m

Print[" RungeKutta: Pendel"]
RKStep[f_, y_, yp_, dt_]:=
Module[{ k1, k2, k3, k4 },
k1 = dt N[ f /. Thread[y –> yp] ];
k2 = dt N[ f /. Thread[y –> yp + k1/2] ];
k3 = dt N[ f /. Thread[y –> yp + k2/2] ];
k4 = dt N[ f /. Thread[y –> yp + k3] ];
yp + (k1 + 2 k2 + 2 k3 + k4)/6 ]
RungeKutta[f_List, y_List, y0_List, {x_, dx_}] :=
NestList[RKStep[f,y,#,N[dx]]&,N[y0],Round[N[x/dx]] ] /;
Length[f] == Length[y] == Length[y0]

EulerStep[f_,y_,yp_,h_]:= yp + h N[f /. Thread[y –> yp]]

Euler[f_,y_,y0_,{x_,dx_}]:=
NestList[EulerStep[f, y, #, N[dx]]&, N[y0], Round[N[x/dx]]
]
hamilton = pˆ2/2 – Cos[q]
294 Anhang E

tmax = 200
dt = 0.1
phi0 = Pi/2
p0 = 0
r = 0.05
phase:=RungeKutta[{D[hamilton,p],–D[hamilton,q]},
{q, p}, {phi0,p0}, {10,dt}]
plot1:=ListPlot[phase,PlotJoined–>True,Frame –> True,
AspectRatio–>Automatic,
FrameLabel –> {"q","p"},
RotateLabel –> False,
PlotRange –> {{–2.3,2.3},{–1.85,1.85}}]
phase2:=RungeKutta[{p,–Sin[q]–r p},
{q,p},{phi0,p0},{tmax,dt}]
plot2:= ListPlot[phase2,PlotJoined–>True, PlotRange –> All,
AspectRatio–>Automatic,Frame –> True,
FrameLabel –> {"q","p"},
RotateLabel –> False,
PlotStyle –> Thickness[0.003] ]
phase3:= Euler[{D[hamilton, p], –D[hamilton, q]},
{q, p}, {phi0, p0}, {10, dt}]
plot3:= ListPlot[phase3,PlotJoined –> True, Frame –> True,
AspectRatio –> Automatic,
FrameLabel –> {"q","p"},
RotateLabel –> False,
PlotRange –> {{–2.3,2.3},{–1.85,1.85}}]

4.2 Chaotisches Pendel: pendel.c

/***** Chaotisches Pendel *****/

#define float double

#include <graphics.h>
#include <stdlib.h>
#include <math.h>
#include <stdio.h>
#include "\tc\recipes\nr.h"
#include "\tc\recipes\nrutil.h"
#include "\tc\recipes\nrutil.c"
#include "\tc\recipes\odeint.c"
#include "\tc\recipes\rkqc.c"
#include "\tc\recipes\rk4.c"

double dt=.1,r=.25,a=.5,pi,ysc=5.;
int poincare=0,done=0;
Programme 295

int maxx,maxy,xbild,ybild;
void print(),derivs(double,double*,double*),event(double*);

main()
{
int gdriver=DETECT,gmode;
int i,nok,nbad,xalt,yalt,xneu,yneu;
double y[3],f[3],t=0.,eps=1e–08;

initgraph(&gdriver,&gmode,"\\tc");
maxx=getmaxx();
maxy=getmaxy();
xbild=maxx–20;
ybild=maxy–110;
pi=acos(–1.);

y[1]=pi/2.;
y[2]=0.;
print();
while(done==0)
{
if(kbhit()) event(y);
if(poincare==1)
{
odeint(y,2,t,t+3.*pi,eps,dt,0.,&nok,&nbad,derivs,rkqc);
xalt=fmod(y[1]/2./pi +100.5,1.)*xbild;
yalt=y[2]/ysc*ybild/2+ybild/2;
rectangle(xalt,yalt,xalt+1,yalt+1);
t=t+3.*pi;
}
else
{
xalt=fmod(y[1]/2./pi +100.5,1.)*xbild;
yalt=y[2]/ysc*ybild/2+ybild/2;
odeint(y,2,t,t+dt,eps,dt,0.,&nok,&nbad,derivs,rkqc);
xneu=fmod(y[1]/2./pi +100.5,1.)*xbild;
yneu=y[2]/ysc*ybild/2+ybild/2;
if(abs(xneu–xalt)<xbild/2) line(xalt,yalt,xneu,yneu);
t=t+dt;
}
}
closegraph();
}
296 Anhang E

void event(double y[])

{
switch (getch())
{case ’e’: done=1;break;
case ’c’: print();break;
default : getch();break;
case ’h’: a=a+.01;print();break;
case ’t’: a=a–.01;print();break;
case ’+’: ysc=ysc/2.;print();break;
case ’–’: ysc=ysc*2.;print();break;
case ’s’: y[1]=pi/2.;y[2]=0.;print();break;
case ’u’: poincare=!poincare;print();break;
case ’a’: outtextxy(50,50,"a=?");scanf("%lf",&a);
print();break;
}
}

void derivs (double t,double y ,double f)

{
f[1]=y[2];
f[2]=–r*y[2]–sin(y[1])+a*cos(2./3.*t);
}

void print(void)
{
char string[100];
setviewport(1,1,maxx,maxy,1);
clearviewport();
settextstyle(1,0,1);
outtextxy(20,ybild+20,"Getriebenes Pendel");
settextstyle(0,0,1);
outtextxy(10,ybild+70,
"Befehle:exit,hoch(a),tief(a),start,a einlesen"
",+,–,umschalten,clear,beliebig");
rectangle(9,9,xbild+11,ybild+11);
sprintf(string,"a=%lf, r=%lf" ,a,r);
if(poincare==1)
sprintf(&string[strlen(string)]," – Poincare");
outtextxy(220,ybild+40,string);
setviewport(10,10,xbild+10,ybild+10,1);
}
Programme 297

4.3 Stationäre Zustände: schroed.c

/* Schroedinger–Gleichung */

#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>

double e=.5,a=0.1;

main()
{
void bild(void), print( double,double,double );
double k(double),
step(double *x,double dx,double*y,double*ym1);
int gdriver=DETECT,gmode;
int xb,ybneu,ybalt;
double dx=10./500.,y,ym1,yp1,destart=.05,de=.05,x,xp1,xm1 ;
initgraph(&gdriver,&gmode,"\\tc");
bild();

while(1)
{
x=dx/2.;y=ym1=1.;ybalt=1;
for(xb=1;xb<500;xb++)
{
yp1=step(&x,dx,&y,&ym1);
ybneu=(1.–yp1)*120;
if(abs(ybneu)>10000) break;
line(xb–1,ybalt,xb,ybneu);
ybalt=ybneu;
}
switch (getch())
{case ’e’: closegraph();exit(1);
case ’c’: print(e,de,dx);break;
default : getch();break;
case ’+’: e=e+de;print(e,de,dx);break;
case ’–’: e=e–de;print(e,de,dx);break;
case ’s’: de=destart;print(e,de,dx);break;
case ’k’: de=de/10.;print(e,de,dx);break;
case ’d’: dx=dx/2.;print(e,de,dx);break;
}/* switch */
}/* while */
}/* main */
298 Anhang E

double step ( double xa, double dx,doubleya,double*ym1a)

{
long i,n;
double k(double);
double yp1,x,y,ym1,xp1,xm1;
x=*xa;y=*ya;ym1=*ym1a;
n=ceil(10./dx/500.);

for(i=1;i<=n;i++)
{
xp1=x+dx;xm1=x–dx;
yp1=(2.*(1.–5./12.*dx*dx*k(x))*y
–(1.+dx*dx/12.*k(xm1))*ym1)/
(1.+dx*dx/12.*k(xp1));
xm1=x;x=xp1;
ym1=y;y=yp1;
}
*xa=x;*ya=y;*ym1a=ym1;
return yp1;
}

void print (double e,double de,double dx)

{
char str[100];
clearviewport();
line(1,120,500,120);
sprintf(str," E= %12.8lf, de=%12.8lf, dx= %12.8lf ",
e,de,dx);
outtextxy(10,290,str);
return;
}

void bild()
{
settextstyle (1,0,1);
setlinestyle(0,0,3);
rectangle(9,9,511,311);
outtextxy(30,350," Schroedinger–Gleichung ");
settextstyle (0,0,1);
outtextxy(20,390,
"Befehle : exit,klein(de),+(e),–(e),start(de),dx/2,"
"clear screen");
setlinestyle(0,0,1);
setviewport(10,10,510,310,1);
}
Programme 299

double k(double x)
{ return (–pow(x,2)–2.*a*pow(x,4)+2.*e); }

4.4 Solitonen: soliton.m

Print[" Solitonen"]
soliton = –2 Sech[x–4t]ˆ2
plot1:= Plot3D[soliton,{x,–5,5},{t,–1,1},PlotPoints–>50]
gl=D[soliton,t]–6*soliton*D[soliton,x]+D[soliton,{x,3}]==0
max:= Ceiling[20/dx]
ustart:=Table[–6 Sech[(j–max/2)dx]ˆ2//N,{j,0,max}]
step[u_]:= (Do[uplus[k]=RotateLeft[u,k],{k,3}];
u+dt*(6u*(uplus[1]–u)/dx –
(uplus[3]–3uplus[2]+3uplus[1]–u)/dxˆ3))
plot2[i_:3]:=(dx=0.05; dt=0.02; upast=ustart; zeit=0;
Do[upres=step[upast];
upast=upres;
Print["Zeit ",zeit=zeit+dt],{i}];
xulist=Table[{(j–max/2)*dx,upres[[j]]},
{j,max}];
ListPlot[xulist,PlotJoined–>True,PlotRange–>All,
Frame –> True, Axes –> {True,False},
FrameLabel –>{"x","u(x,0.06)"} ] )
firststep[u_]:=(up1=RotateLeft[u]; up2=RotateLeft[up1];
um1=RotateRight[u]; um2=RotateRight[um1];
u+dt*(3*u*(up1–um1)/dx–
(up2–2up1+2um1–um2)/(2dxˆ3)) )
step2[u_,w_]:= (up1=RotateLeft[u]; up2=RotateLeft[up1];
um1=RotateRight[u]; um2=RotateRight[um1];
w+dt(2(um1+u+up1)*(up1–um1)/dx –
(up2–2up1+2um1–um2)/dxˆ3 ) )
init:=(dx = 0.18; dt=.002; upast=uPast=ustart; zeit = dt;
dt=dt/10; upres = firststep[upast]; dt = zeit–dt;
ufut=step2[upres,upast];upast=upres;upres=ufut;
upast=uPast; dt = zeit; )
plot3[i_:10]:=(If[ Not[NumberQ[dt]]||dt != .002, init];
If[zeit==.002,fin=i–1,fin=i];
Do[ ufut=step2[upres,upast];
upast=upres;upres=ufut;zeit=zeit+dt,{fin}];
Print["Zeit ",zeit];
xulist = Table[{(j–max/2)*dx,ufut[[j+1]]},
{j,0,max}];
zs = StringJoin["u(x,",ToString[zeit],")"];
uu = Interpolation[xulist];
300 Anhang E

Plot[uu[x],{x,–10.,10.},PlotRange–>All,
Frame –> True, Axes –> None,
PlotStyle –> Thickness[0.002],
FrameLabel –>{"x",zs}] )
u2[x_,t_]=–12(3+4Cosh[2x–8t]+Cosh[4x–64t])/
(3Cosh[x–28t]+Cosh[3x–36t])ˆ2
plot4:=Plot3D[u2[x,t],{t,–.2,.2},{x,–5,5},PlotPoints–>50,
PlotRange –> {–10,0},
Shading –> False,
MeshStyle –> Thickness[0],
AxesEdge –> {Automatic,Automatic,{–1,1}},
ViewPoint –> {–1.78095, –2.06202, 2.5},
DefaultFont –>{"Times–Roman",16},
AxesLabel –> {"t","x","u"}]
plot5:=ContourPlot[–u2[x,t],{t,–1,1},{x,–10,10},
PlotPoints–>100,
ContourShading–>False,
PlotRange –> All,
ContourSmoothing –> 4,
FrameLabel –> {"t","x"},
RotateLabel –> False,
Contours –> {0.1,0.6,1.1,1.6,2.6,4.0,5.6}]
plot6[tt_:0.3]:= (uprime[x_]=D[u2[x,tt],x]; x=–10.0;
exactlist={{x,u2[x,tt]}}; d=0.07; upl=uprime[x]ˆ2;
While[x<10., upr=uprime[x+d]ˆ2;
d = 0.07/Sqrt[1+Max[upl,upr]];
x = x+d; AppendTo[exactlist,{x,u2[x,tt]}];
upl=upr ];
ListPlot[exactlist, PlotRange –> All,
PlotStyle –> PointSize[0.002],
Frame –> True, Axes –> None] )

4.5 Zeitabhängige Schroedinger-Gleichung: welle.c

Nur auf Diskette vorhanden.

5.1 Zufallszahlen: zufall.m und mzran.c

x0 = 1234
a = 106
c = 1283
m = 6075
zufall[x_] = Mod[a*x + c,m]
uniform = NestList[zufall,x0,m+1]/N[m]
tripel = Table[Take[uniform,{n,n+2}],{n,1,m,3}]
unitvectors = Map[(#/Sqrt[#.#])&,tripel]
Programme 301

plot1:=Show[Graphics3D[{PointSize[0.004],
Map[Point,unitvectors]}],
ViewPoint –> {2,3,2}]
v0 = {276., 164., 442.}/m (* vector closest to {0,0,0} *)
(* b1,b2,b3 span primitive cell *)
b1 = {–113., 172., 7.}/m
b2 = {173., 113., –172.}/m
b3 = {345., 120., 570.}/m
vp = m*(9*b1+4*b2)+{0,0,100}

plot2 := Show[Graphics3D[{PointSize[0.004],
Map[Point,tripel]}],
ViewPoint –> vp]
uni = Table[Random[],{m+2}];
tri = Table[Take[uni,{n,n+2}],{n,m}]
univec = Map[(#/Sqrt[#.#])&,tri]

plot3:=Show[Graphics3D[{PointSize[0.004],
Map[Point,univec]}],
ViewPoint–>{2,3,2}]

mzran.c
/***** Zufallszahlen *****/

#define N 1000000
unsigned long x=521288629, y=362436069, z=16163801,
c=1, n=1131199209;
unsigned long mzran()
{ unsigned long s;
if(y>x+c) {s=y–(x+c); c=0;}
else {s=y–(x+c)–18; c=1;}
x=y; y=z; z=s; n=69069*n+1013904243;
return (z+n);
}

main()
{
double r=0.;
long i;
for (i=0;i<N; i++)
r+=mzran()/4294967296.;
printf ("r= %lf \n",r/(double)N);
}
302 Anhang E

5.2 Fraktale Aggregate: dla.c

/* Fraktale Aggregate */

#include <graphics.h>
#include <stdlib.h>
#include <math.h>

#define lmax 220

#define rs (rmax+2.)
#define rd (rmax+5.)
#define rkill (100.*rmax)

char xf[lmax][lmax] ;
int rx,ry,maxx,maxy;
double rmax=1.,pi;

void main ()
{
void besetze(),huepfe(),aggregate(),kreissprung();
char pruefe();
int driver=DETECT,mode;
int i,j;

initgraph (&driver, &mode, "\\tc");

maxx=getmaxx();
maxy=getmaxy();
randomize();
pi=acos(–1.);
outtextxy(50,maxy–30,"Befehl: exit");
for(i=0;i<lmax;i++)
for(j=0;j<lmax;j++) xf[i][j]=0;
xf[lmax/2][lmax/2]=1;

besetze();
huepfe();

while(1)
{
switch(pruefe())
{
case ’v’:besetze();huepfe();break;
case ’a’:aggregate();besetze();huepfe();break;
case ’h’:huepfe();break;
case ’k’:kreissprung();break;
Programme 303

}
if (kbhit())
switch(getch())
{ case ’e’: closegraph();exit(1);
default : getch();break;}
}/* while */
}/* main */

void huepfe()
{
switch(random(4))
{
case 0: rx+=1;break;
case 1: rx+=–1;break;
case 2: ry+=1;break;
case 3: ry+=–1;break;
}
}

void aggregate()
{
double x,y;
xf[rx+lmax/2][ry+lmax/2]=1;
x=rx;y=ry;
rmax= max(rmax,sqrt(x*x+y*y));
if(rmax>lmax/2.–5.) {printf("\7");getch();exit(1);}
circle(4*rx+maxx/2,4*ry+maxy/2,2);
}

void besetze()
{
double phi;
phi=(double)rand()/RAND_MAX*2.*pi;
rx=rs*sin(phi);
ry=rs*cos(phi);
}

void kreissprung()
{
double r,x,y,phi;
phi=(double)rand()/RAND_MAX*2.*pi;
x=rx; y=ry; r=sqrt(x*x+y*y);
rx+=(r–rs)*sin(phi);
ry+=(r–rs)*cos(phi);
}
304 Anhang E

char pruefe()
{
double r,x,y;
x=rx;
y=ry;
r=sqrt(x*x+y*y);
if(r>rkill) return ’v’;
if(r>=rd) return ’k’;
if(xf[rx+1+lmax/2][ry+lmax/2]
+xf[rx–1+lmax/2][ry+lmax/2]
+xf[rx+lmax/2][ry+1+lmax/2]
+xf[rx+lmax/2][ry–1+lmax/2]>0) return ’a’;
else return ’h’;
}

5.3 Perkolation: perc.c und percgr.c

percgr.c ist nur auf Diskette vorhanden.

/* Perkolation */

#include <graphics.h>
#include <conio.h>
#include <stdlib.h>
#include <math.h>

main()
{
int gdriver=DETECT,gmode;
double p=.59275;
int i,j,pr,L=700;

pr=p*RAND_MAX;
initgraph(&gdriver,&gmode,"\\tc");
for(i=0;i<L;i++)
for(j=0;j<L;j++)
if(rand()<pr) putpixel(i,j,WHITE);
getch();
closegraph();
}

5.4 Polymer-Ketten: reptation.c

Nur auf Diskette vorhanden.
Programme 305

5.5 Ising-Ferromagnet: ising.c

#include <time.h>
#include <conio.h>
#include <stdlib.h>
#include <math.h>
#include <stdio.h>
#define L 20
#define VSEG 0xb800

int s[L+2][L+2],bf[3],done=0;
double temp;

main()
{
void setT(double);
void event(void);
void rahmen(int , int);
char ch;
int mcs,x,y,e,v;
clock_t start,end;
clrscr();
randomize();
mcs=0;
gotoxy(50,1);
printf("ISING–Ferromagnet ");
gotoxy(50,2);
printf("Monte–Carlo–Simulation");
gotoxy(50,3);
printf("Systemgroesse %d * %d",L,L);
gotoxy(1,25);
printf(
" Befehle: t(iefer),h(oeher),s(prung),e(xit),beliebig");
rahmen(2*L+3,L+2);

for(x=0;x<L+2;x++) for(y=0;y<L+2;y++) s[x][y]=1;

for(x=1;x<L+1;x++) for(y=1;y<L+1;y++)
{
gotoxy(2*(x–1)+3,y+1);
putch(1);
}
getch();
setT(2.269);
start=clock();
306 Anhang E

while(!done)
{
event();
for(x=1;x<L+1;x++) for(y=1;y<L+1;y++)
{
e=s[x][y]*(s[x–1][y]+s[x+1][y]+s[x][y–1]+s[x][y+1]);
if( e<0 || rand()<bf[e/2] )
{
s[x][y]=–s[x][y];
v=2*(x*80+2*(y–1)+2);
ch=(s[x][y]+1)*15;
poke(VSEG,v,0xf00|ch);
}
}
for(x=1;x<L+1;x++)
{
s[0][x] =s[L][x];
s[L+1][x]=s[1][x];
s[x][0] =s[x][L];
s[x][L+1]=s[x][1];
}

mcs++;gotoxy(50,15);printf(" mcs/Spin : %d",mcs);

end=clock();
gotoxy(50,16);
printf(" CPU Zeit : %.3e",(end–start)/CLK_TCK/(L*L)/mcs);
}
}
void setT(double t)
{
temp=t;
bf[2]=RAND_MAX*exp(–8./temp);
bf[1]=RAND_MAX*exp(–4./temp);
bf[0]=RAND_MAX/2;
gotoxy(50,10);printf(" Temperatur: %.2f",temp);
}

void event()
{
char ch;
if(!kbhit()) return;
ch=getch();
switch(ch)
{ case ’h’:setT(temp+=.05);break;
case ’t’:setT(temp–=.05);break;
Programme 307

case ’s’:setT(1.) ;break;

default :getch();break;
case ’e’:done=1;break;
}
}

void rahmen(int xmax,int ymax)

{
int i=0;
gotoxy(1,1);
while(i++,i<xmax) putch(205);
for(i=1;i<ymax–1;i++)
{
gotoxy(1,i+1);
putch(186);
gotoxy(xmax,i+1);
putch(186);
}
i=0;
gotoxy(1,ymax);
while(i++,i<xmax) putch(205);
gotoxy(1,1);putch(201);
gotoxy(xmax,1);putch(187);
gotoxy(1,ymax);putch(200);
gotoxy(xmax,ymax);putch(188);
}

5.6 Kürzeste Rundreise: travel.c

Nur auf Diskette vorhanden.
Sach- und Namenverzeichnis

A Automatic 115, 236

Abbildung
logistische 89, 98
nichtlineare 102 B
Ableitung 42, 92 Bahn
diskretisierte 158 chaotische 96, 108, 110, 142
Ableitungsoperator 39 periodische 96, 98
Abs 9 superstabile 92, 94, 98
Abweichung, quadratische 25 Band 68, 71, 85, 99, 142
AccuracyGoal 94 chaotisches 91, 94
Aggregat 183 Barriere, gaußförmige 172
fraktales 188 Beleuchtung, stroboskopische 136
aliasing 18 Bénard-Experiment 143
Amplitudengleichung 155, 158 Besetzungswahrscheinlichkeit 204, 212
Anfangsbedingung 67, 92, 134, 181 Besetzungszahl 79
Anfangsverteilung 162 Besselfunktion 23
symmetrisierte 163 BesselJ 23, 236, 241
Anfangswert 128, 145 Bewegungsgleichung 65, 130, 133
Anfangswertproblem 181 lineare 65
Anfangszustand 92, 167 Bloch-Theorem 71
Anharmonizität 54 Block 4, 94, 241
Antisymmetrie 78 Boltzmann-Faktor 216, 223, 226
Antriebsperiode 136 Boltzmann-Konstante 42, 210
Apply 4 bond percolation 194
Approximation 53, 153 Boolesche Funktion 118
ArcSin 9, 235 break 123, 251
Arrhenius-Gesetz 219, 224 Bulirsch-Stoer-Methode 131
AspectRatio 115, 236
atoi 227
Attraktor 95, 114, 135 C
chaotischer 140 case 123
periodischer 136 CDF 27
seltsamer 136 ceil 147
Aufenthaltswahrscheinlichkeit 51, 162, 171 Chaos 91, 96
Ausdehnung, mittlere 182, 191 deterministisches 89, 91
Ausdruck, logischer 59 chaotisch 89, 108, 110, 135, 170
Auszahlungsmatrix 46, 49 char 5, 247
Sach- und Namenverzeichnis 309

2 -Test 25 Doppelbesetzung 83, 85

2 -Verteilung 26, 29 Doppelmuldenpotential 56, 133, 149
Chirikov-Abbildung 103 Dot 34, 244
ChiSquareDistribution 27 double 5, 247
Chop 67, 239 Drehmoment, periodisches 135
Circle 34 Dreiecksgitter 190
clock t 5 Drop 34
Cluster 182, 188, 190, 193, 195, 198 Dualitätssatz 48
ContourPlot 9, 28, 35, 236 Dynamik
Contour-Plot 157 kontinuierliche 103
Contours 9 symbolische 93, 98, 101
Courant-Bedingung 155
critical slowing down 220
E
Eigenfunktion 147
D Eigenfunktionsentwicklung 168
D 39, 43, 242 Eigenmode 154, 172
Daten Eigenschwingung 67, 69
geglättete 23 Eigensystem 82, 244
verrauschte 23 Eigenvalues 53, 67, 82, 244
default 123, 251 Eigenvektor 51, 65, 67, 72, 83
define 5, 249 Eigenwert 52, 54, 65, 67, 71, 73, 76, 83,
detailed balance 205 85, 145, 160
Determinante 73, 78 Eigenwertgleichung 51, 56, 67
DiagonalMatrix 53, 67, 243 verallgemeinerte 66
Diagonalmatrix 53 Eigenwertproblem 72
Differentialgleichung 90, 127, 225 Eigenzustand 51, 71, 85, 160
gewöhnliche 127, 225 Einbettungsdimension 112
lineare 51, 65 Einheitszelle 65, 70
nichtlineare 127 Einteilchenniveau 84
partielle 150, 159, 164 Einteilchenzustand 77
Differenzenform 152 Einzugsgebiet 136
Differenzengleichung 165 Elementarzelle 65
Diffusion 180, 216, 219 EllipticF 8
Diffusion Limited Aggregation (DLA) 181 EllipticE 38
Diffusionsgleichung 181 EllipticK 8, 38
radialsymmetrische 183 else 207, 250
Dimension, fraktale 112, 136, 181, 188, End-zu-End-Abstand 205
191, 193, 201, 209 Energie 210, 223
Dipolmoment 33, 35 Energieband 71
Dipolnäherung 37 Energiebarriere 219
Do 4, 94, 152, 156, 241 Energie-Eigenwert 54, 145
Domänenwand 216, 219 Energiegebirge 230
310 Sach- und Namenverzeichnis

Energieniveau 45, 56, 84, 148 magnetischer 70

Entartung 85 Flüssigkeit 43
Entwicklung, symbolische 12 Flußquantum 70
Entwicklungskoeffizienten 161 fopen 122
Erzeugungsoperator 52, 78, 80 For 4, 241, 242
Euler-Schritt 164 for 5, 35, 75, 147, 197, 217, 248, 251
Euler-Verfahren 128, 132 Form, quadratische 35
Evaluate 9 Fourier 9, 16
Expand 82, 237, 246 Fourierkoeffizienten 60
Explosionskriterium 148 Fourierreihe 9, 59
Exponent, kritischer 191, 200, 202, 213, Fouriertransformation 8, 11, 13, 22, 56, 60,
220 66, 181
inverse 60
Fouriertransformierte 14, 168, 232
F Fraktal 112, 115, 136, 188, 191
Faltung 15, 22 Frequenz, kommensurable 107
Fast Fourier Transform (FFT) 16 Frequenzspektrum 91
Fehler, lokaler 130 Fugazität 220
Fehlerintervall 27 Fünferzyklus 96, 101
Feigenbaumkonstante 91, 98
Feld 41
elektrisches 33, 35 G
magnetisches 69 Gammafunktion, unvollständige 26
zweidimensionales 185 Gas 43
Feldlinienbild 38 Gaußfunktion 22, 162
feof 123 Gaußverteilung 179
fgetc 123 gcc 6, 256
Fibonacci-Zahl 21 Generator, linear kongruenter 174
Filter 61 Gesamtladung 33
elektrisches 67 Gesamtwahrscheinlichkeit 164
FindMinimum 27 Geschwindigkeit 39
FindRoot 44, 92, 94, 107, 240, 245 Gewicht
finite size scaling 193, 196, 200, 214, 220 statistisches 203
First 104 synaptisches 117, 121, 123
Fit, nichtlinearer 25, 27 Gewichtsvektor 119
Fixpunkt 91, 95, Gewinn, mittlerer 46, 48
stabiler 96 Gewinntabelle 46
Flatten 68, 81 Gitter
float 5, 247 kubisches 181
Flory, P. J. 201 quadratisches 190
Fluktuation 193, 212, 216, 218, 220 Gittergas 220
Fluß Gitterschwingungen 65, 68
flächenerhaltender 103 Gittervektoren, primitive 175
Sach- und Namenverzeichnis 311

Glättung 21 implizit 165

Gleichgewicht 212 Impulsoperator 70
detailliertes 205, 211, 214, 223 include 5, 138, 249
thermisches 211, 216, 219, 223, 224 Informationsentropie 137
Gleichung Informationsdimension 137
lineare 51 Initialisierung 152
transzendente 45 int 5, 247
Gleichungssystem 51, 57, 60 Integerzahlen, vorzeichenlose 177
lineares 65 Integral
Gradient 33, 39 elliptisches 7
Graphics 34, 115 vollständiges elliptisches 8
Graphics3D 175 Integrate 9, 12, 40, 242
Graphik 216 Integration, numerische 145, 164
Graphikobjekt 34, 115, 175 Integrationsprozedur 139
Grassberger, P. und Procaccia, I. 137 Integrationsschritt 147
Gravitationskraft 133 Interferenz 161, 169
Grenzwertsatz, zentraler 211 Interpolation 156
Grundfrequenz 161 Inverse 67, 93, 244
Grundzustand 82, 85, 104, 110, 145 InverseFourier 23
Grundzustandsenergie 54, 86, 224 irrational 104, 108, 110
Ising-Ferromagnet 213, 218
Ising-Modell 210
H Isotherme 41
Hamiltonfunktion 132 Isotropie, räumliche 182
Hamiltonmatrix 54, 78, 82 Iteration 93
Hamiltonoperator 52, 56, 77, 79, 82, 165 inverse 93, 98
skalierter 160 nichtlineare 103
Handlungsreisender 222
Harper-Gleichung 70, 72, 76
Hermitepolynome 52 J
Histogramm 95 JacobiAmplitude 8
Hofstadter, D. 69 JacobiSN 8
Hofstadter-Schmetterling 76 Join 94
Höhenlinien 9, 35
Hoshen, J. und Kopelman, R. 195
Hubbard, J. 78 K
Hubbard-Modell 78 KAM-Trajektorie 108, 110
Hüpfmatrixelement 70 Kern 22
Hyperebene 118, 119 Kirchhoffsche Regeln 57
Knobelspiel 50
Knotensatz 74, 145
I Kochsche Kurve 116
If 45, 82, 241, 242 Koexistenz 44
312 Sach- und Namenverzeichnis

kommensurabel 71, 104, 107, 110 M

kompilieren 6 Magnetfeld 38
Konfiguration 203 Magnetisierung 213
Konfigurationsraum 212 spontane 219
Kontraktion 35 main 5, 247, 248
Kontrollparameter 220 Map 68, 104, 115, 174
Konturen 30 Marsaglia, G. und Zaman, A. 177
Konvergenzbeweis 119 Massenmatrix 66
Konvektionsrollen 142 Maßstab 111
Konzentration, kritische 190 Mastergleichung 204, 212
Korrelation 175 Matrix 5, 52, 71, 80, 84, 149, 252, 255
Korrelationslänge 193, 213, 218 diagonale 52
Korteweg-de-Vries-Gleichung 150 hermitesche 66
Kraft, periodische 135 tridiagonale 73, 154, 159
Kreisfrequenz 57 Matrixdarstellung 53
Kristall, aperiodischer 20 MatrixForm 54, 243
Matrixgleichung 154
MaxIterations 94
L Maxwell-Gerade 42, 44
Ladungsverteilung 32 Maxwell-Konstruktion 41
Leapfrog-Methode 131 memcpy 228
Leath, P. L. 195 Meßdaten 22
Leistung 63 Metropolis-Algorithmus 212, 214, 230
Leistungsspektrum 20 Minimax-Theorem 47
Leiterschleife, kreisförmige 38 Minimum, absolutes 224
Length 4, 82, 238 Mittel
Lernen 118, 120 gewichtetes 22
Lernregel 117, 119 statistisches 202, 212
Line 34 thermisches 220
LinearProgramming 46, 49 Mittelwertbildung 153
Listable 39, 238 Mod 105, 174
Listen 5, 237 Modellfunktion 25
ListPlot 11, 68, 104, 152, 238, 239 Module 131
Ljapunow-Exponent 92, 100 Modulo 105, 177, 206, 250
long 5, 247 Modulo-Abbildung 105
Lorenz, E. N. 142 Modulo-Funktion 174
Lorenzmodell 143 Modulo-Operation 177, 207
Lösung Molekulardynamik 131
analytische 44 Molekularfeldtheorie 202
numerische 44, 51, 56, 77, 127, 156 Monomer 112
Sach- und Namenverzeichnis 313

Monte-Carlo-Schritt 227, 232 Ordnung, magnetische 190

Monte-Carlo-Simulation 87, 215, 217, Ordnungsparameter 220
223, 226 Ortsdarstellung 51, 160
Multipol-Entwicklung 32 Oszillation, numerisch bedingte 153
Oszillator
anharmonischer 52, 145
N harmonischer 54
NDSolve 127, 245
Needs 28, 240
Nest 92, 100, 104, 241, 242 P
NestList 104, 132, 174, 241, 242 Parallelkreis 59, 64
Netzwerk Parameterraum 30
elektrisches 56, 57 Parametervektor 25, 30
lineares 59 ParametricPlot3D 39, 236
neuronales 117 Pauli-Prinzip 77, 79
Neumann, J. von 46 PDF 28
Neurocomputer 117 Peierls-Trick 70
Neuron 118 Pendel 6, 132
Neuronales Netzwerk 117 getriebenes 140
Neuronenaktivität 121 nichtlineares 135
Nichtlinearität 8 Periode, teilerfremde 178
NIntegrate 13, 243 Periodendauer 162
Niveau 55 Periodenlänge 174, 177
NonlinearFit 27, 240 Periodenverdoppelung 91, 98, 141
Normalmoden 66 Periodizität 72
Nullstellenbestimmung 71 Perkolation 189
Numerov-Verfahren 146 Perkolationscluster 191
Perkolationsschwelle 190, 193, 198
Permutationen 222
O Permutations 81, 239
OddQ 94 Perzeptron 117, 123
odeint 138, 139 Perzeptron-Lernregel 119
Ohmsches Gesetz 56, 58 Phänomen, kritisches 189
Onsager, L. 213, 218 Phase 61
Operator 78, 81 Phasendifferenz 57
unitärer 164 Phasenfaktor 161
Operatoralgebra 78, 81 Phasengeschwindigkeit 168
Optimierung 223 Phasenraum 9, 11, 103, 132, 135
lineare 46, 48, 223 Phasenraumdiagramm 105
Optimierungsaufgabe 45 Phasenübergang 42, 91, 190, 192, 202,
Optimierungsproblem 213, 219
diskretes 223 Phasenumwandlung 210
kombinatorisches 224 Phononen 65, 68
314 Sach- und Namenverzeichnis

Pixel 75, 95, 113, 148 Quadrupoltensor 33

Plastizität, synaptische 118 Quanten-Monte-Carlo-Methode 87
Plot 8, 156, 236 Quantile 28
Plot3D 35, 236 Quasi-Ellipsoid 31
PlotRange 8
PlotVectorField 35, 38
Plus 4 R
Poincaré, H. 134 rand 5, 113, 174, 187, 195, 228, 253
Poincaré-Schnitt 90, 103, 136, 140 Randbedingung 146, 163, 181, 216
Point 175 periodische 66, 79, 84, 216
Polygon 115 RAND MAX 5, 186, 253
Polymer 201, 206, 209 Random 4, 106, 174, 176, 237
Polymerdynamik 202 random walk 113, 181, 201, 209
Polymerkonfiguration 203 Rechteckimpuls 17
Polymermolekül 112, 201 Rechteckspannung 64
Polynom 71, 75 Regel 28, 43
charakteristisches 73 Reibungskraft 133
Populationsdynamik 90 Reihendarstellung 160
Potential 37, 39, 40, 144, 160 Reihenentwicklung 9
anharmonisches 52, 148 Rekursion 166
chemisches 220 Relaxationszeit 136, 216, 219
elektrisches 118 Renormierungsgruppentheorie 192, 213
elektrostatisches 32 ReplacePart 81
kommensurables 71 Reptation 203, 206
periodisches 102, 107 Reptationsalgorithmus 205
quadratisches 65 Resonanz 58, 61, 63
symmetrisches 145 Resonanzfrequenz 59, 61, 64
Potentialmulde 133 Resonanzkurve 61
Potentialtopf 45 return 5, 147, 254
Potenzsingularität 213 Richardson-Extrapolation 131
Precision 100 Rosenblatt, F. 119
Predictor-Corrector-Methode 131 Rosenblatt-Regel 121
Print 156, 241, 242 RotateLeft 23, 152, 156
printf 5, 248 RotateRight 156
Produktansatz 51 Rotation 40
Prozedur 4 Round 132
Prozeß, stochastischer 212, 214, 223 Rückwärts-Iteration 166
Pseudozufallszahl 173, 175, 177 Rückwärtsrekursion 102
Ruhelage 65, 102, 103, 133, 135, 140
Q Rundweg 222
Runge-Kutta-Verfahren 129, 138, 143, 146
Quadrupolmoment 33, 35
Quadrupolnäherung 37
Sach- und Namenverzeichnis 315

S site percolation 194

Sägezahnspannung 60 Skalar 33
Satz von Gerschgorin 74 Skalarprodukt 34, 39, 82
Satz von Liouville 103 Skalenexponent 193
scanf 249, 257 Skalengesetz 192, 213
Schema, implizites 159 Skalenverhalten 225
Schieberegister-Generatoren 176 Skalierung 231
Schießverfahren 145, 149 Soliton 151
Schmetterling 69 Solve 43, 45, 59
Schnitt, goldener 108 Sort 82, 238
Schrittweite 130, 133, 158, 169 Spektrum 69
Schrittweitenkontrolle, adaptive 138 Spielstrategie 45, 46
Schröder, M. 116 Spieltheorie 46
Schrödinger-Gleichung 51, 70, 144, 151, Spinglas 223
160, 164, 168 Spinkonfiguration 211
diskrete 70, 76 Spinkorrelationen 87
stationäre 52, 144 Spitzenspannung 20, 232
zeitabhängige 159 Spur 71
Schwarzsche Ungleichung 120 Sqrt 9, 53, 234
Schwellenwert 118, 190 Stabilität 158
Schwingkreis 57, 61 Stabilitätsbedingung 159
Schwingung Stabilitätsgrenze 159
gedämpfte 140 Standardabbildung 103
harmonische 10, 136 Standardabweichung 194
longitudinale 65 Steuerparameter 143
Schwingungsdauer 7 Störung 54, 91
Schwingungsform 65 Strategie 46, 47
Schwingungsmoden 67 optimale 48, 50
Sech 152 stochastische 47
selbstähnlich 114, 218 Stromdichte 162, 183
Selbstüberschneidung 204 struct 113, 196, 206, 227
self-avoiding walk 201 Sturmsche Kette 73
Sequenz, periodische 174 Subharmonische 91
Serienkreis 58 subtract-with-borrow generators 177
Serienschaltung 59, 61 Sum 35, 82
Series 9, 243 Supercomputer 211
Show 34, 236, 239 Suszeptibilität, magnetische 213, 219
ShowProgress 28 switch 123, 186, 251
Sierpinski-gasket 114 Symmetrie 15, 72, 74, 76, 80, 85, 87, 145,
Simplify 41, 242 147, 161, 203, 214
simulated annealing 224, 231 Symmetriebrechung, spontane 213
Simulation 178, 194, 202, 216, 223 Synapse 117
numerische 163 Synapsenstärke 119
316 Sach- und Namenverzeichnis

System unsigned long int 177

deterministisches 124
mechanisches 134
V
Vakuum 78
T van-der-Waals-Gas 41
Table 4, 82, 128, 152, 156, 238 van-der-Waals-Gleichung 41, 43
Take 174 Variable, abgeschirmte 4
Tastaturpuffer 227 Varianz 25, 179, 221
Taylor-Entwicklung 128, 146, 169 Vektor 5, 33, 252, 255
Taylorreihe 129, 153 Vektoranalysis 39
Temperatur Vektorfeld 39
kritische 42, 45 Vektoroperationen 39
skalierte 45 Vektorpotential 38, 70
Tensor 5, 33 Verallgemeinern 118, 121
Teufelstreppe 109 Verhulst, P. F. 90
TeXForm 12, 83 Verlustleistung 64
Thickness 34 Vernichtungsoperator 52, 78, 80
Thread 82, 131, 244 Verschiebungssatz 48
Torus 216 Verteilung, stationäre 204
Trajektorie 107, 135 Vertrauensintervall 26, 29
chaotische 110 Vertrauensniveau 31
Transfermatrix-Methode 211 Verzweigungspunkt 92
Transformation, inverse 14 Vibrationen 69
Translationen 66 Vielfaches, irrationales 136
Translationsoperator 70 Vielteilchensystem 78, 223
travelling salesman problem 221 Vielteilchenzustand 77, 81, 210
Trefferrate 121, 123 Viererzyklus 91, 99
Tridiagonalmatrix 53, 72, 165 ViewPoint 175
True 53, 240, 243 void 186, 254
Tunneleffekt 145, 172 Vorwärts-2-Punkt-Formel 152
typedef 177, 206, 227 Vorzeichenwechsel 73, 75
Typendeklaration 113

W
U Wachstumsalgorithmus 196, 198
Überdeckung 136 Wachstumsprozeß 180, 195
Übergangswahrscheinlichkeit 204, 211, Wahrscheinlichkeit 47, 160
214, 217, 223 Wahrscheinlichkeitsdichte 181
Überholvorgang 151, 157 Wärme, spezifische 213, 220
Überlagerung 51, 67, 164 Wärmegleichgewicht 210
unendliche 161 Wechselspannung 56
Universalität 89, 189, 191, 213 Wechselstrom 56
Sach- und Namenverzeichnis 317

Wechselwirkung Zuordnung 59
attraktive 202 Zustand 103
magnetische 190 fastperiodischer 107
Wechselwirkungspotential 102 inkommensurabler 107, 110
Wegintegral 39 kommensurabler 104, 107
Weglänge, skalierte 230 stabiler 102
Welle, stehende 161 stationärer 51, 144, 161, 212
Wellenfunktion 51, 70, 74, 78, 144, 148, Zustandsgleichung 41
160, 163, 166 Zustandssumme 210
Wellenpaket 151, 161, 168, 170 Zweierzyklus 91
Gaußsches 167 Zwei-Personen-Nullsummen-Spiel 46, 49
lokalisiertes 159 Zweiphasengemisch 43
numerisch integriertes 171 Zwei-Soliton-Lösung 158
Wert, irrationaler 71 Zyklus 97, 141
while 95, 123, 139, 251
Widerstand, komplexer 56, 57
Wiederkehrzeit 159
Wilson, K. G. 213
Windungszahl 104, 107, 109
rationale 107
Witten, T. A. und Sander, L. M. 182
WorkingPrecision 94

Z
Zahl, irrationale 71, 76, 104
Zeiger 5, 252, 257
Zeit, charakteristische 168
Zeitableitung 155
Zeitentwicklung 164, 169
quantenmechanische 160
Zeitentwicklungsoperator 164
Zeitmittel 63
Zeitreihe 121
Zeitskala 168, 219
Zufallsbewegung 112, 180
Zufallsvektor 112
Zufallsweg 182, 201, 202
Zufallszahl 4, 23, 49, 113, 124, 173, 207,
226
gleichverteilte 179, 207, 215
normalverteilte 32
Zufallszahlengenerator 179, 218

Das könnte Ihnen auch gefallen

Otto Föllinger Regelungstechnik
Noch keine Bewertungen
Otto Föllinger Regelungstechnik
5 Seiten
(Leitfaden Der Elektrotechnik) Prof. Dr.-Ing. Günther Hilgarth (Auth.) - Hochspannungstechnik-Vieweg+Teubner Verlag (1997) PDF
100% (2)
(Leitfaden Der Elektrotechnik) Prof. Dr.-Ing. Günther Hilgarth (Auth.) - Hochspannungstechnik-Vieweg+Teubner Verlag (1997) PDF
244 Seiten
Loesungen Zum Buch
Noch keine Bewertungen
Loesungen Zum Buch
20 Seiten
Bronst. - Taschenbuchs Der Mathematik
67% (3)
Bronst. - Taschenbuchs Der Mathematik
6.693 Seiten
Komb Aufgaben
100% (1)
Komb Aufgaben
6 Seiten
Grundlagen Der Physik I (Uni Ulm) Übung+Lösung09
Noch keine Bewertungen
Grundlagen Der Physik I (Uni Ulm) Übung+Lösung09
11 Seiten
III 1 2 e Ortskurven
Noch keine Bewertungen
III 1 2 e Ortskurven
5 Seiten
2.1.2 Lernunterlage Mechanik
Noch keine Bewertungen
2.1.2 Lernunterlage Mechanik
38 Seiten
ST Matlab Praktikum Skript
Noch keine Bewertungen
ST Matlab Praktikum Skript
77 Seiten
HANDOUT
Noch keine Bewertungen
HANDOUT
2 Seiten
Analysis Zusammenfassung
Noch keine Bewertungen
Analysis Zusammenfassung
12 Seiten
TM3 Uebungsaufgaben
Noch keine Bewertungen
TM3 Uebungsaufgaben
10 Seiten
Numerik Version 0.6
100% (2)
Numerik Version 0.6
77 Seiten
I Integralrechnung Öffnen
Noch keine Bewertungen
I Integralrechnung Öffnen
16 Seiten
Springer Lehrbuch
Noch keine Bewertungen
Springer Lehrbuch
522 Seiten
Lernen Aus Musterlösungen Zur Analysis Und Linearen Algebra
100% (2)
Lernen Aus Musterlösungen Zur Analysis Und Linearen Algebra
247 Seiten
Höhere Mathematik Kompakt: Georg Hoever
Noch keine Bewertungen
Höhere Mathematik Kompakt: Georg Hoever
272 Seiten
Einführung in MATLAB
Noch keine Bewertungen
Einführung in MATLAB
252 Seiten
TMIII Skript
Noch keine Bewertungen
TMIII Skript
70 Seiten
Numerische Strömungsmechanik
Noch keine Bewertungen
Numerische Strömungsmechanik
71 Seiten
Skript Differentialgleichungen PDF
Noch keine Bewertungen
Skript Differentialgleichungen PDF
65 Seiten
Skript Thermodynamik Und Quantenstatistik WS1718
Noch keine Bewertungen
Skript Thermodynamik Und Quantenstatistik WS1718
198 Seiten
ET1
Noch keine Bewertungen
ET1
109 Seiten
Physik Skriptum
Noch keine Bewertungen
Physik Skriptum
394 Seiten
Analysis 3 Komplett
100% (1)
Analysis 3 Komplett
103 Seiten
Mathematik Für Physiker II
100% (1)
Mathematik Für Physiker II
151 Seiten
Feldbusse
Noch keine Bewertungen
Feldbusse
40 Seiten
Formelsammlung - Festikeitslehre (Resistência Dos Materiais)
Noch keine Bewertungen
Formelsammlung - Festikeitslehre (Resistência Dos Materiais)
47 Seiten
Aufgabenheft Statik
Noch keine Bewertungen
Aufgabenheft Statik
46 Seiten
Grundƶüge Der Tensorrechnung in Analytischer Darstellung I. Teil Tensoralgebra
Noch keine Bewertungen
Grundƶüge Der Tensorrechnung in Analytischer Darstellung I. Teil Tensoralgebra
135 Seiten
Wipf Mechanik PDF
100% (2)
Wipf Mechanik PDF
264 Seiten
KIT Geophysik
Noch keine Bewertungen
KIT Geophysik
34 Seiten
Mathematik in Der Biologie
Noch keine Bewertungen
Mathematik in Der Biologie
161 Seiten
KMK Maschbau 2004 WiSe14-15 - Hannover
Noch keine Bewertungen
KMK Maschbau 2004 WiSe14-15 - Hannover
66 Seiten
Handbuch der Mechanischen Verfahrenstechnik
Von Everand
Handbuch der Mechanischen Verfahrenstechnik
Heinrich Schubert
Noch keine Bewertungen
Physik Lösungen
Noch keine Bewertungen
Physik Lösungen
34 Seiten
Cooling System For Distiller Machine
Noch keine Bewertungen
Cooling System For Distiller Machine
4 Seiten
Hydraulikskript
0% (1)
Hydraulikskript
363 Seiten
Mathematik Olympiade - Jahresband - 1961-62
100% (2)
Mathematik Olympiade - Jahresband - 1961-62
102 Seiten
Skript - Mechanik - II - SoSe2023 Theoretische Physik
Noch keine Bewertungen
Skript - Mechanik - II - SoSe2023 Theoretische Physik
189 Seiten
Autodesk Inventor | Schritt für Schritt: CAD Konstruktion und FEM Simulation mit Autodesk Inventor für Einsteiger
Von Everand
Autodesk Inventor | Schritt für Schritt: CAD Konstruktion und FEM Simulation mit Autodesk Inventor für Einsteiger
M.Eng. Johannes Wild
Noch keine Bewertungen
Fertig Ung S Mess Technik
Noch keine Bewertungen
Fertig Ung S Mess Technik
334 Seiten
Alte Klausuren Experimentalphysik
Noch keine Bewertungen
Alte Klausuren Experimentalphysik
6 Seiten
Software-Fehler Erkennen Und Vermeiden: Dieter Duschl
Noch keine Bewertungen
Software-Fehler Erkennen Und Vermeiden: Dieter Duschl
217 Seiten
Klipni Mehanizam Dinamika Dubbel (2007)
Noch keine Bewertungen
Klipni Mehanizam Dinamika Dubbel (2007)
40 Seiten
Formelsammlung Thermodynamik, Wärme- und Stoffübertragung und Strömungsmechanik: mit Stoffwertetabellen und -diagrammen
Von Everand
Formelsammlung Thermodynamik, Wärme- und Stoffübertragung und Strömungsmechanik: mit Stoffwertetabellen und -diagrammen
Bernhard Müller
Noch keine Bewertungen
Experimentalphysik IV - Optik
Noch keine Bewertungen
Experimentalphysik IV - Optik
74 Seiten
Adriane Gründers - Mathe Übersichtlich - Von Den Basics Bis Zur Analysis - Mehr Als 175 Themen Zum Nachlesen Und Verstehen-Springer Spektrum (2021)
Noch keine Bewertungen
Adriane Gründers - Mathe Übersichtlich - Von Den Basics Bis Zur Analysis - Mehr Als 175 Themen Zum Nachlesen Und Verstehen-Springer Spektrum (2021)
214 Seiten
2TechMech Festigkeitslehre
100% (1)
2TechMech Festigkeitslehre
37 Seiten
Windkraftanlage In Der Luft: Eine Turbine in der Luft ohne Turm
Von Everand
Windkraftanlage In Der Luft: Eine Turbine in der Luft ohne Turm
Fouad Sabry
Noch keine Bewertungen
Tipler Physik Sammlung
100% (1)
Tipler Physik Sammlung
74 Seiten
Regelungstechnik
Noch keine Bewertungen
Regelungstechnik
118 Seiten
Theoretische Physik I
Noch keine Bewertungen
Theoretische Physik I
100 Seiten
Anwendungen Integralrechnung
100% (1)
Anwendungen Integralrechnung
18 Seiten
Ue1 Ue2 Ue3 PDF
Noch keine Bewertungen
Ue1 Ue2 Ue3 PDF
255 Seiten
Schwarze Löcher
100% (1)
Schwarze Löcher
3 Seiten
Eine Hybride von Drehkolbenmotor und Turbine mit riesigem Synergieeffekt
Von Everand
Eine Hybride von Drehkolbenmotor und Turbine mit riesigem Synergieeffekt
Oleg Tchebunin
Noch keine Bewertungen
Gleichstromtechnik
Von Everand
Gleichstromtechnik
Joachim Patzke
Noch keine Bewertungen
Die CE Kennzeichnung
Von Everand
Die CE Kennzeichnung
Jürgen Niebling
Noch keine Bewertungen
Schiffbau heute: Wie ein Schiff entsteht
Von Everand
Schiffbau heute: Wie ein Schiff entsteht
Peter Andryszak
Noch keine Bewertungen