vorlesung physik auf dem computer - icpwikiicp/mediawiki/images/archive/b/bb/... · dies ist das...

Skript zur Vorlesung“Physik auf dem Computer”

JP Dr. A. ArnoldUniversität Stuttgart

Institut für Computerphysik

unter Mithilfe von

Dr. O. Lenz

Sommersemester 2014

Dies ist das Skript zur Vorlesung „Physik auf dem Computer“, die von Axel Arnold inden Sommersemestern 2012 und 2013 an der Universität Stuttgart gehalten wurde.

Ich danke H. Menke, M. Kuron, J. Landsgesell, K. Szuttor und A. Weyman für zahlreicheKorrekturen.

Dieses Skript und alle Quelldateien sind unter einer Creative Commons-Lizenz vom TypNamensnennung-Weitergabe unter gleichen Bedingungen 3.0 Deutschland zugänglich.Um eine Kopie dieser Lizenz einzusehen, konsultieren Sie http://creativecommons.org/licenses/by-sa/3.0/de/ oder wenden Sie sich schriftlich an Creative Com-mons, 444 Castro Street, Suite 900, Mountain View, California, 94041, USA.

CC© BY:© C©

http://creativecommons.org/licenses/by-sa/3.0/de/

http://creativecommons.org/licenses/by-sa/3.0/de/

Inhaltsverzeichnis

1 Einleitung 71.1 Über dieses Skript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81.2 Beispiel: Fadenpendel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

1.2.1 Modell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101.2.2 Näherung: der harmonische Oszillator . . . . . . . . . . . . . . . . 111.2.3 Numerische Lösung . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

2 Lineare Algebra I 172.1 Dreiecksmatrizen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172.2 Gaußelimination . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182.3 Matrixinversion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202.4 LU-Zerlegung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212.5 Cholesky-Zerlegung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222.6 Bandmatrizen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

3 Darstellung von Funktionen 253.1 Horner-Schema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253.2 Taylorreihen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263.3 Polynom- oder Lagrangeinterpolation . . . . . . . . . . . . . . . . . . . . . 27

3.3.1 Lagrangepolynome . . . . . . . . . . . . . . . . . . . . . . . . . . . 293.3.2 Baryzentrische Darstellung . . . . . . . . . . . . . . . . . . . . . . 303.3.3 Neville-Aitken-Schema . . . . . . . . . . . . . . . . . . . . . . . . . 303.3.4 Newtonsche Darstellung . . . . . . . . . . . . . . . . . . . . . . . . 313.3.5 Chebyshev-Stützstellen . . . . . . . . . . . . . . . . . . . . . . . . . 32

3.4 Splines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323.5 Fourierreihen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

3.5.1 Komplexe Fourierreihen . . . . . . . . . . . . . . . . . . . . . . . . 353.5.2 Reelle Fourierreihen . . . . . . . . . . . . . . . . . . . . . . . . . . 373.5.3 Diskrete Fouriertransformation . . . . . . . . . . . . . . . . . . . . 393.5.4 Schnelle Fouriertransformation . . . . . . . . . . . . . . . . . . . . 42

3.6 Wavelets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

4 Datenanalyse und Signalverarbeitung 474.1 Kontinuierliche Fouriertransformation . . . . . . . . . . . . . . . . . . . . 47

4.1.1 Numerische kontinuierliche Fouriertransformation . . . . . . . . . . 504.1.2 Abtasttheorem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52

3

Inhaltsverzeichnis

4.2 Faltungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 524.2.1 Antwort zeitinvarianter linearer Systeme . . . . . . . . . . . . . . . 55

4.3 Kreuz- und Autokorrelation . . . . . . . . . . . . . . . . . . . . . . . . . . 554.3.1 Kreuzkorrelationsfunktion . . . . . . . . . . . . . . . . . . . . . . . 564.3.2 Autokorrelationsfunktion . . . . . . . . . . . . . . . . . . . . . . . 59

4.4 Messfehlerabschätzung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 614.4.1 Fehler bei der Messung korrelierter Daten . . . . . . . . . . . . . . 634.4.2 Binning-Analyse . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64

4.5 Ausgleichsrechnung, Methode der kleinsten Quadrate . . . . . . . . . . . . 66

5 Nichtlineare Gleichungssysteme 715.1 Sukzessive Substitution . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71

5.1.1 Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 735.2 Newtonverfahren in einer Dimension . . . . . . . . . . . . . . . . . . . . . 74

5.2.1 Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 755.2.2 Wurzelziehen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 765.2.3 Nullstellen von Polynomen . . . . . . . . . . . . . . . . . . . . . . . 76

5.3 Sekantenmethode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 775.4 Bisektion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78

5.4.1 Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 795.5 Regula falsi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 795.6 Newtonverfahren in mehreren Dimensionen . . . . . . . . . . . . . . . . . 81

5.6.1 Gedämpftes Newtonverfahren . . . . . . . . . . . . . . . . . . . . . 82

6 Numerisches Differenzieren und Integrieren 836.1 Numerisches Differenzieren . . . . . . . . . . . . . . . . . . . . . . . . . . . 83

6.1.1 Näherungen höherer Ordnung und höhere Ableitungen . . . . . . . 846.1.2 Genauigkeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 856.1.3 Beispiel: Besselsche Differentialgleichung . . . . . . . . . . . . . . . 86

6.2 Quadratur: numerische Integration . . . . . . . . . . . . . . . . . . . . . . 886.2.1 Newton-Cotes-Formeln . . . . . . . . . . . . . . . . . . . . . . . . . 916.2.2 Zusammengesetzte Newton-Cotes-Formeln . . . . . . . . . . . . . . 936.2.3 Beispiel: Besselfunktion . . . . . . . . . . . . . . . . . . . . . . . . 956.2.4 Romberg-Integration . . . . . . . . . . . . . . . . . . . . . . . . . . 966.2.5 Beispiel: Fehlerintegral . . . . . . . . . . . . . . . . . . . . . . . . . 976.2.6 Gauß-Quadratur . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1006.2.7 Unendliche Integrale und Singularitäten . . . . . . . . . . . . . . . 1026.2.8 Mehrdimensionale Integration, Monte-Carlo-Integration . . . . . . 1046.2.9 Beispiel: Monte-Carlo-Integration von π . . . . . . . . . . . . . . . 1056.2.10 Quasi-Monte-Carlo-Integration . . . . . . . . . . . . . . . . . . . . 1066.2.11 Beispiel: Quasi-Monte-Carlo-Integration von π . . . . . . . . . . . 108

4

Inhaltsverzeichnis

7 Zufallszahlen 1117.1 Pseudozufallszahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111

7.1.1 Linearer Kongruenzgenerator . . . . . . . . . . . . . . . . . . . . . 1127.1.2 Verzögerter Fibonaccigenerator . . . . . . . . . . . . . . . . . . . . 114

7.2 Andere Verteilungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1157.2.1 Verwerfungsmethode . . . . . . . . . . . . . . . . . . . . . . . . . . 1167.2.2 Inversionsmethode . . . . . . . . . . . . . . . . . . . . . . . . . . . 1187.2.3 Zufällige Punkte auf Kugel und Kugeloberfläche . . . . . . . . . . . 120

7.3 Qualitätsanalyse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1217.3.1 Statistiktests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1227.3.2 Poincaré-Schnitte . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1247.3.3 Fouriertest . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1257.3.4 Autokorrelationstest . . . . . . . . . . . . . . . . . . . . . . . . . . 126

7.4 Beispiel: Random walk . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1267.5 Beispiel: Perkolation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132

8 Lineare Algebra II 1378.1 Iterative Gleichungslöser . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138

8.1.1 Jacobiverfahren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1398.1.2 Gauß-Seidel-Verfahren . . . . . . . . . . . . . . . . . . . . . . . . . 1418.1.3 Relaxationsverfahren . . . . . . . . . . . . . . . . . . . . . . . . . . 142

8.2 QR-Zerlegung und Orthogonalisierung . . . . . . . . . . . . . . . . . . . . 1448.2.1 Gram-Schmidt-Verfahren . . . . . . . . . . . . . . . . . . . . . . . 1448.2.2 Householder-Verfahren . . . . . . . . . . . . . . . . . . . . . . . . . 1488.2.3 Givens-Rotationen . . . . . . . . . . . . . . . . . . . . . . . . . . . 152

8.3 Eigenwerte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1558.3.1 Vektoriteration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1558.3.2 QR-Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1578.3.3 Inverse Iteration . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159

9 Optimierung 1619.1 Ausgleichsrechnung und Pseudoinverse . . . . . . . . . . . . . . . . . . . . 1629.2 Nichtlineare Optimierung . . . . . . . . . . . . . . . . . . . . . . . . . . . 164

9.2.1 Verfahren des steilsten Abstiegs . . . . . . . . . . . . . . . . . . . . 1659.2.2 Schrittweitensteuerung . . . . . . . . . . . . . . . . . . . . . . . . . 1659.2.3 CG-Verfahren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1679.2.4 Nebenbedingungen und Straffunktionen . . . . . . . . . . . . . . . 170

9.3 Lineare Programme und Simplexalgorithmus . . . . . . . . . . . . . . . . . 1739.4 Globale Optimierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178

9.4.1 Simulated annealing . . . . . . . . . . . . . . . . . . . . . . . . . . 1839.4.2 Genetische Algorithmen . . . . . . . . . . . . . . . . . . . . . . . . 186

5

Inhaltsverzeichnis

10 Differentialgleichungen 18910.1 Gewöhnliche Differentialgleichungen . . . . . . . . . . . . . . . . . . . . . 189

10.1.1 Runge-Kutta-Verfahren . . . . . . . . . . . . . . . . . . . . . . . . 19010.1.2 Beispiel: Lotka-Volterra-Gleichungen . . . . . . . . . . . . . . . . . 19410.1.3 Velocity-Verlet-Verfahren . . . . . . . . . . . . . . . . . . . . . . . 19610.1.4 Beispiel: 3-Körperproblem . . . . . . . . . . . . . . . . . . . . . . . 198

10.2 Partielle Differentialgleichungen . . . . . . . . . . . . . . . . . . . . . . . . 20010.2.1 Finite-Differenzen-Methode — Wärmeleitungsgleichung . . . . . . 20010.2.2 Finite-Elemente-Methode . . . . . . . . . . . . . . . . . . . . . . . 20410.2.3 Lösung mittels Fouriertransformation — Poisson-Gleichung . . . . 20710.2.4 Lösung der Poisson-Boltzmann-Gleichung . . . . . . . . . . . . . . 210

6

1 Einleitung

In dieser Vorlesung geht es darum, wie der Computer in der modernen Physik eingesetztwird, um neue Erkenntnisse zu gewinnen. Klassisch war die Physik ein Zusammenspiel ausExperiment und Theorie. Die Theorie macht Vorhersagen, die im Experiment überprüftwerden. Umgekehrt kann im Experiment ein neuer Effekt beobachtet werden, für dendie Theorie eine Erklärung liefert. Durch den Einsatz von Computern ist dieses Bildkomplizierter geworden. In der folgenden Graphik sind die Bereiche farblich hinterlegt,in denen heutzutage Computer zum Einsatz kommen, die hellroten Bereiche werden indieser Vorlesung behandelt:

Simulation

Theorie ExperimentSymbolische Mathematik

Numerische Lösung

Steuerung

Auswertung

Vorhersage

ÜberprüfungEichung VorhersageVorhersageÜberprüfung

Zu den klassischen Säulen Theorie und Experiment ist die Simulation als Mittelding zwi-schen Theorie und Experiment gekommen. Computersimulationen stellen Experimenteim Computer nach, ausgehend von bekannten theoretischen Grundlagen. Alles, für dases Wechselwirkungstheorien gibt, kann simuliert werden, von Galaxien bis hin zu Elek-tronen und Quarks. Dazu gibt es eine Vielzahl an unterschiedlichen Methoden, derenGrundlagen in dieser Vorlesung vorgestellt werden.Simulationen erfüllen zwei Hauptaufgaben: Simulationen können einerseits genutzt

werden, um Experimente möglichst genau zu reproduzieren, andererseits kann man auchabstrakte theoretische Modelle in ihrer vollen Komplexität untersuchen.Simulationen, die an ein Experiment angepasst (geeicht) sind, können zusätzliche In-

formationen liefern, die experimentell nicht zugänglich sind. Zum Beispiel kann mandort Energiebeiträge getrennt messen oder sehr kurzlebige Zwischenprodukte beobach-ten. Außerdem erlauben Simulationen, Wechselwirkungen und andere Parameter gezieltzu verändern, und damit Vorhersagen über zukünftige Experimente zu machen.Simulationen, die auf theoretischen Modellen basieren, sind oft ein gutes Mittel, um

notwendige Näherungen auf Plausibilität zu überprüfen oder um einen ersten Eindruckvom Verhalten dieses Modells zu erhalten. Damit können Simulationen auch helfen, zu

7

1 Einleitung

entscheiden, ob notwendige Näherungen oder das Modell unvollständig ist, wenn Theorieund Experiment nicht zu einander passen. Schließlich lassen sich, anders als im Experi-ment, Wechselwirkungen einfach ausschalten, um deren Einfluss abschätzen zu können.In der klassischen theoretischen Physik werden Papier und Bleistift zunehmend vom

Computer verdrängt, denn Computeralgebra ist mittlerweile sehr leistungsfähig und kannzum Beispiel in wenigen Sekunden komplexe Integrale analytisch lösen. Und falls eineGleichung doch einmal zu kompliziert ist für eine analytische Lösung, so kann der Com-puter mit numerischen Verfahren oft sehr gute Näherungen finden. Letztlich passiert diesauch in einer Computersimulation, allerdings hat sich dieses Feld soweit entwickelt, dasses mit Recht als eigenständig bezeichnet wird.In der experimentellen Physik fallen immer größere Datenmengen an. Der LHC erzeugt

zum Beispiel pro Jahr etwa 10 Petabyte an Daten, also etwa 200 Millionen DVDs, wasüber mehrere Rechenzentren verteilt gespeichert und ausgewertet werden muss. Klar ist,dass nur Computer diese gigantischen Datenmengen durchforsten können. Aber auch beieinfacheren Experimenten helfen Computer bei der Auswertung und Aufbereitung derDaten, zum Beispiel durch Filtern oder statistische Analysen. Viele Experimente, nichtnur der LHC, sind aber auch so komplex, dass Computer zur Steuerung der Experimentebenötigt werden, was wir in dieser Vorlesung aber nicht behandeln können. Die Auswer-tung und Aufbereitung der Daten hingegen wird besprochen, auch weil dies genauso auchfür Computersimulationen benutzt wird.Neben diesen direkten Anwendungen in der Physik ist der Computer mittlerweile na-

türlich auch ein wichtiges Mittel für den Wissensaustausch unter Physikern, sei es beimSchreiben wissenschaftlicher Arbeiten oder beim internationalen Austausch über E-mailund Videokonferenz. Auch stehen mittlerweile die meisten wissenschaftlichen Arbeitenweltweit in elektronischen Bibliotheken zur Verfügung. Leider hat das einfachere Pu-blizieren mit Hilfe des Computers auch zu einem starken Anstieg immer spezialisierterArbeiten geführt, so dass man zur Recherche in diesen riesigen Datenmengen mittlerweileebenfalls Computer benötigt.Um den Computer für Simulationen, Auswertung von Daten oder auch Lösung kom-

plexer Differenzialgleichungen nutzen zu können, sind neben physikalischen Kenntnissenauch solche in Programmierung, numerischer Mathematik und Informatik gefragt. In die-sem Skript geht es vor allem um die grundlegenden Methoden und wie diese angewandtwerden, daher dominiert die numerische Mathematik etwas. Anders als in einer richtigenVorlesung zur Numerik stehen hier aber die Methoden und Anwendungen anstatt derHerleitungen im Vordergrund.

1.1 Über dieses Skript

Im Folgenden wird eine in der numerischen Mathematik übliche Notation benutzt. Wieauch in den meisten Programmiersprachen werden skalare und vektorielle Variablen nichtdurch ihre Schreibweise unterschieden, allerdings werden üblicherweise die Namen i–lfür (ganzzahlige) Schleifenindizes benutzt, n und m für Dimensionen. Da Schleifen sehrhäufig auftreten, wird hierfür die Kurznotation Anfang(Inkrement)Ende benutzt. Zum

8

1.1 Über dieses Skript

Beispiel bedeuten

1(1)n = 1,2, . . . , n

n(−2)1 = n, n− 2, . . . , 3, 1.

Alle anderen Variablen sind reellwertige Skalare oder Vektoren, Rn bezeichnet dabeiden n-dimensionalen Vektorraum reller Zahlen. Mit ei wird dabei der Einheitsvektor deri-ten Spalte bezeichnet, mit eTi seine Transponierte, also der Einheitsvektor der i-tenZeile. Bei komplexen Vektoren steht entsprechend der obere Index H für die Hermitescheeines Vektors, also die Transponierte des Vektors, bei der alle Komponenten komplexkonjugiert sind. Für reelle Vektoren sind also H und T gleichbedeutend.Integrale werden mit dem Volumenelement am Ende geschrieben, dessen Dimensiona-

lität sich aus dem Integrationsbereich erschließt. Sehr häufig werden Abschätzungen mitHilfe der Landau-Symbole verkürzt. Wie üblich heißt für zwei Funktionen f und g

f = Ox→a(g) ⇐⇒ limx→a

|f(x)||g(x)|

<∞.

In den meisten Fällen ist a = 0 oder a =∞ und aus dem Kontext klar, welcher Grenzwertgemeint ist. Dann wird die Angabe weggelassen. Oft wird auch die Notation f = g+O(h)benutzt, um f + g = O(h) auszudrücken. f(x)=g(x) schließlich bedeutet, dass f und gum Null herum in linearer Ordnung gleich sind, also f(x)− g(x) = Ox→0(x).Numerische Algorithmen werden in diesem Skript in der Sprache Python 1 dargestellt.

Dabei werden die leistungsfähigen numerischen Erweiterungen NumPy und SciPy2 inten-siv eingesetzt, und zur Visualisierung dient die hervorragende matplotlib 3. Alle Graphenin dieser Vorlesung sind mit matplotlib erstellt worden. Zum Erlernen von Python sei aufdie Materialien der Veranstaltung „Computergrundlagen“ verwiesen, die im FachbereichPhysik der Universität Stuttgart jährlich angeboten wird.Im Bereich des Hochleistungsrechnens werden vor allem die Sprachen Fortran und

C/C++ eingesetzt, weil diese in Verbindung mit guten Compilern sehr effizienten Codeergeben. Allerdings verlangen diese Sprachen die explizite Typisierung von Variablen,was Beispiele unnötig verkompliziert. Zudem sind Speicherzugriffe nur ungenügend ge-schützt, was die Fehlersuche sehr erschwert. Daher werden in dieser Vorlesung und denzugehörigen Übungen C/C++ nicht eingesetzt.Die meisten der in diesem Skript vorgestellten numerischen Methoden werden von Sci-

Py direkt unterstützt. Die Qualität dieser Implementationen ist mit eigenem Code nurschwierig zu überbieten. Wo immer möglich, wird daher auf die entsprechend SciPy-Befehle verwiesen. Zum Beispiel wird auf die Funktion „method“ im SciPy-Modul „libra-ry“ in der Form scipy.library.method(arg1, arg2,...) verwiesen. Trotzdemsind viele Methoden auch als expliziter Code gezeigt, da man natürlich eine Vorstellungdavon haben sollte, was diese Methoden tun.

1http://python.org2http://www.scipy.org3http://matplotlib.org

9

http://python.org

http://www.scipy.org

http://matplotlib.org

1 Einleitung

α

l

Ftan = FG sin(α)Frad

FG = −mg

Abbildung 1.1: Schematisches Fadenpendel der Masse m, das an einem masselosen, stei-fen Faden der Länge l hängt.

1.2 Beispiel: Fadenpendel

Wir betrachten ein einfaches Beispielsystem, nämlich ein Fadenpendel. Wird dieses Pen-del nun ausgelenkt, vollführt es eine periodische Schwingung um die Ruhelage, d. h. ,den tiefsten Punkt. Unser Ziel als Physiker ist nun, die Position der Kugel als Funktionder Zeit vorherzusagen. Das allerdings ist eine unmögliche Aufgabe — man stelle sichzum Beispiel eine stark inhomogene Masse vor (oder ein Fadenpendel als Masse) oderdass der Faden elastisch ist. Daher müssen wir zunächst ein geeignet vereinfachtes Modellerstellen, auf das wir dann die bekannten physikalischen Gesetze anwenden können.

1.2.1 Modell

Als Modell wählen wir eine homogene Kugel der Masse m, die an einem masselosen,steifen Faden der Länge l hängt (vergleiche Figur 1.1). Auf diese Kugel wirkt nur eineGewichtskraft der Größe mg senkrecht nach unten, alle anderen Kräfte vernachlässigenwir komplett, insbesondere auch die Reibung.Da der Faden unendlich steif sein soll, kann sich die Kugel lediglich auf einem Kreis

mit Radius l um die Aufhängung bewegen, d. h. die Position der Kugel ist durch dieAuslenkung α aus dem tiefsten Punkt vollständig beschrieben. Weiter wird die Kompo-nente der Kraft parallel zum Faden komplett von diesem kompensiert, daher bleibt beiAuslenkung α von der Gewichtskraft nur ihre Komponente

Ftan = FG sin(α) = −mg sin(α) (1.1)

senkrecht zum Faden übrig. Das Newtonsche Gesetz besagt nun, dass die Tangentialbe-schleunigung, also die Beschleunigung entlang α

lα = Ftan/m = −g sin(α) (1.2)

10


0.0 0.5 1.0 1.5 2.0T

0.10

0.05

0.00

0.05

0.10

0.0 0.5 1.0 1.5 2.0T

1.5

1.0

0.5

0.0

0.5

1.0

1.5

Abbildung 1.2: Lösungen für ein Fadenpendel der Länge l = 1m. Im linken Graphen istdie Ausgangslage α = 1,5, im rechten α = 0,1; in beiden Fällen ist die Ausgangsgeschwin-digkeit 0. Die durchgezogene grüne Linie markiert die analytische Näherungslösung (1.4)für kleine Winkel. Blaue + markieren die Schritte einer Integration mit dem einfachenVorwärtsschrittverfahren (1.10) mit Zeitschritt 0,1s, die gestrichelte rote Linie mit Zeit-schritt 0,01s. Blaue × markieren die Lösung mit Hilfe des Velocity-Verlet-Algorithmusund Zeitschritt 0,1s.

beträgt. Dies ist jetzt eine Differentialgleichung für die Auslenkung α(t) des Pendels alsFunktion der Zeit. Diese wiederum liefert uns die gewünschte Position (cos(α)l, sin(α)l)der Kugel relativ zur Aufhängung als Funktion der Zeit. Leider hat selbst diese einfacheDifferentialgleichung keine geschlossene Lösung, und wir müssen weitere Näherungeneinführen, um eine geschlossene analytische Lösung zu erhalten.

1.2.2 Näherung: der harmonische Oszillator

Für kleine Winkel gilt sin(α) ≈ α, und damit

α ≈ −glα. (1.3)

Diese Differentialgleichung beschreibt einen harmonischen Oszillator mit Eigenfrequenzω =

√g/l und hat die allgemeine Lösung

α(t) = Acos(ωt) +Bsin(ωt) (1.4)

wie man leicht durch Einsetzen überprüft. Die Größen A und B ergeben sich aus denAnfangsbedingungen, nämlich der Anfangsposition

α(0) = A cos(0) +B sin(0) =⇒ A = α(0) (1.5)

11

1 Einleitung

und -geschwindigkeit

α(0) = −Aω sin(0) +Bω cos(0) =⇒ B = α(0)/ω. (1.6)

Wir haben nun eine geschlossene Lösung für die Position des Pendels, sofern die Aus-gangslage nicht zu sehr ausgelenkt und die Ausgangsgeschwindigkeit nicht sehr hoch ist.Ist das nicht der Fall, erreicht die Lösung α(t) Werte, bei denen die Näherung sin(α) ≈ αstark verletzt ist. Die Lösung ist also nicht konsistent mit unserer vereinfachenden An-nahme und daher physikalisch sinnlos. Um diese Lösung zu visualisieren, nutzt man heuteüblicherweise den Computer, siehe Graph 1.2.

1.2.3 Numerische Lösung

Was passiert nun, wenn das System stärker ausgelenkt ist? Mit sehr viel mehr Aufwandlässt sich auch für diesen Fall eine analytische, allerdings nicht geschlossene Lösung inForm einer unendlichen Reihe finden. Eine Alternative ist, die Differentialgleichung (1.2)mit Hilfe des Computers zu lösen. Wir sagen, wir „simulieren“ das Pendel. Dazu fixierenwir ein Einheitensystem, zum Beispiel eine Sekunde als Zeiteinheit und einen Meter alsLängeneinheit. Wir betrachten ein einen Meter langes Pendel, daher ist l = 1, g ≈ 9,81und ω ≈ 3,13.Diese Wahl des Einheitensystems kommt nicht von ungefähr. Natürlich hätten wir

genauso gut die Länge in Nanometern und die Zeit in Stunden messen können. Dannwäre allerdings l = 109, g ≈ 1,27 · 1017 und ω ≈ 11.270. Damit lässt sich zwar im Prinzipgenausogut rechnen, allerdings ist es meist besser, das Einheitensystem so zu wählen,dass alle wesentlichen Größen nicht um mehr als ein bis zwei Größenordnungen von einabweichen. Denn wenn wir dann in unserer Simulation eine Winkelgeschwindigkeit von1030 oder mehr beobachten, können wir ziemlich sicher sein, dass unser Programm nochfehlerhaft ist. Daher werden zum Beispiel molekulare Simulationen üblicherweise nichtin SI-Einheiten formuliert, sondern in Nanometern und Femtosekunden — nicht anders,als auch die Ergebnisse üblicherweise berichtet werden.Zunächst müssen wir das Problem aber für den Computer anpassen, der ja nur mit

(endlich vielen) Zahlen rechnen kann, wir müssen das Problem diskretisieren. Wir be-trachten nur die Zeitpunkte

tn = nδt, n = 0(1)N, (1.7)

wobei der Zeitschritt δt frei wählbar ist. Je kleiner δt, desto genauer können wir α(t)bestimmen, allerdings steigt natürlich die Anzahl der Schritte, die nötig sind, um einefeste Gesamtzeit zu erreichen. Unsere Lösung, die Funktion α(t) wird also durch ihreWerte α(tn) an den diskreten Zeitpunkten dargestellt.Um Gleichung (1.2) auf den Computer zu bringen, müssen wir uns allerdings noch

überlegen, wie wir mit der Ableitung verfahren. Da wir die Ausgangsposition und -ge-schwindigkeit gegeben haben, liegt es nahe, die Gleichung zu integrieren:

v(t+ δt) = α(t+ δt) = v(t) +

∫ t+δt

t−ω2 sinα(τ) dτ. (1.8)

12


0.0 0.5 1.0 1.5 2.0T

0.040

0.045

0.050

0.055

0.060

E

0.0 0.5 1.0 1.5 2.0T

7.0

7.5

8.0

8.5

9.0

9.5

10.0

10.5

11.0

Abbildung 1.3: Energie als Funktion der Zeit, wieder für l = 1m, und Ausgangslageα = 1,5 (links) und α = 0,1 (rechts) in Ruhe. Blaue + markieren die Ergebnisse einerIntegration mit dem einfachen Vorwärtsschritt (1.10) mit Zeitschritt 0,1s, die gestrichelterote Linie mit Zeitschritt 0,01s. Blaue × markieren die Lösung mit Hilfe des Velocity-Verlet-Algorithmus und Zeitschritt 0,1s, und die gestrichelte schwarze Linie mit 0,01s.Grün ist die erwartete Energie dargestellt, die nicht von der feinen Verlet-Integration zuunterscheiden ist.

Da δt aber unser Zeitschritt ist, wir also nichts weiter über α(τ) wissen, bietet sich diefolgende lineare Näherung an:

v(t+ δt) ≈ v(t)− ω2 sinα(t)δt. (1.9)

Analog ergibt sich dann durch nochmalige Integration:

α(t+ δt) ≈ α(t) + v(t)δt. (1.10)

Ausgehend vonα(0) = α0 und v(0) = v0 (1.11)

lässt sich damit also α(t) numerisch bestimmen. Der Quellcode 1.1 zeigt bei Wahl der„simple“-Methode, wie eine einfache Implementation in Python aussehen könnte.Wie kann man nun überprüfen, ob diese Lösung tatsächlich korrekt ist? Da das System

abgeschlossen ist, muss seine Energie

E =1

2l2v(t)2 + gl(1− cosα(t)) (1.12)

erhalten sein. Lässt man sich diese allerdings ausgeben, stellt man fest, dass E(t) erheblichschwankt, vergleiche Graph 1.3. Dies lässt sich durch Verringern des Zeitschritts beheben,das kostet aber entsprechend mehr Rechenzeit.

13

1 Einleitung

Eine bessere Alternative ist, den Algorithmus zu verbessern, was wiederum etwas ana-lytische Arbeit erfordert. Wir werden im Laufe der Vorlesung verstehen, wie mit Hilfevon Taylorentwicklungen ein besseres Verfahren gefunden werden kann, der sogenannteVelocity-Verlet-Algorithmus:

v

(t+

δt

2

)= v(t) +

δt

2F (t) (1.13)

α(t+ δt) = α(t) + δt v

(t+

δt

2

)(1.14)

v(t+ δt) = v

(t+

δt

2

)+δt

2F (t+ δt), (1.15)

der anders als die zuerst angegebene Vorgehensweise numerisch stabil ist und quasi keineEnergieschwankungen aufzeigt, vergleiche Graph 1.3. Interessant ist, dass formal die Ge-schwindigkeiten zu halben Zeitschritten eingehen. Im Quellcode 1.1 ist alternativ auchdieser Integrator implementiert. Obwohl er nur unwesentlich komplizierter ist als der ein-fache Integrator zuvor, erreicht etwa dieselbe Genauigkeit wie dieser mit einem Zehntelder Zeitschritte.Als weiterer Test bietet sich an, bei kleinen Auslenkungen mit der analytisch bekann-

ten Lösung zu vergleichen, die gut reproduziert wird, siehe Graph 1.2. Bei größerenAnfangsauslenkungen oder -geschwindigkeiten ist die Abweichung allerdings sehr groß,weil hier die analytische Näherung versagt. Im Rahmen ihrer Genauigkeit erlaubt alsodie numerische Lösung, das vorgegebene Modell in einem größeren Parameterraum aufsein Verhalten hin zu untersuchen, als analytisch möglich wäre.

14


# Simulation der Bahn eines Fadenpendels############################################import scipy as spimport matplotlib.pyplot as pyplot

# Laenge des Pendelarmsl=1# Erdbeschleunigungg = 9.81# Zeitschrittdt = 0.01# ZeitspanneT = 2# Methode, "simple" oder "velocity-verlet"integrator="velocity−verlet"# (Start-)Positiona = 0.1# (Start-)Winkelgeschwindigkeitda = 0# Zeitt = 0

# Tabellen fuer die Ausgabetn, an, En = [], [], []

# Kraft, die auf die Kugel wirktdef F(a):

return -g/l*sp.sin(a)

while t < T:if integrator == "simple":

da += F(a)*dta += da*dt

elif integrator == "velocity−verlet":da += 0.5*F(a)*dta += da*dtda += 0.5*F(a)*dt

t += dttn.append(t)an.append(a)En.append(0.5*(l*da)**2 + g*(l - l*sp.cos(a)))

# Ausgabe von Graphenausgabe = pyplot.figure(figsize=(8,4))

loesung = ausgabe.add_subplot(121)loesung.set_xlabel("T")loesung.set_ylabel("Winkel")loesung.plot(tn, an)

energie = ausgabe.add_subplot(122)energie.set_xlabel("Zeit")energie.set_ylabel("Energie")energie.plot(tn, En)

pyplot.show()

Listing 1.1: Python-Code zum Fadenpendel mit graphisch aufbereiteter Ausgabe mit Hil-fe der matplotlib.

15

2 Lineare Algebra I

Lineare Gleichungssysteme sind die einfachste Art von Gleichungssystemen, für die sichzum Beispiel leicht bestimmen lässt, ob und wie viele Lösungen es gibt. Daher führtman auch die Lösung komplexerer Probleme, wie zum Beispiel Differentialgleichungen,oft auf die Lösung eines Satzes von linearen Gleichungssystemen zurück. Lineare Glei-chungssysteme sind in diesem Sinne eine der wesentlichen Grundlagen der numerischenMathematik. Der händischen Lösung der Systeme steht dabei vor allem ihre Größe imWeg — Finite-Elemente-Rechnungen können leicht die Lösung von Gleichungssystemenmit Millionen von Variablen erfordern. Mit modernen Algorithmen und Computern lassensich solche Gleichungssysteme allerdings schnell und zuverlässig lösen. In diesem Kapi-tel lernen wir die grundlegende Methode zum Lösen von Gleichungssystemen kennen,nämlich die allgemeine, aber langsame Gaußelimination. Daneben lernen wir noch dieLU-Zerlegung und die Choleskyzerlegung kennen, die mit etwas Vorarbeit eine effizien-tere Lösung erlauben und im Folgenden oft zum Einsatz kommen werden.Wir betrachten also folgendes Problem: Sei A = (aik) ∈ Rm×n, b ∈ Rm. Gesucht ist

die Lösung x ∈ Rn des Gleichungssystems

a11x1 + a12x2 + . . . + a1nxn = b1a21x1 + a22x2 + . . . + a2nxn = b2

......

......

am1x1 + am2x2 + . . . + amnxn = bm

(2.1)

oder kurz Ax = b. In dieser allgemeinen Form ist weder garantiert, dass es eine Lösunggibt (z. B. A = 0, b 6= 0), noch, dass diese eindeutig ist (A = 0, b = 0).

2.1 Dreiecksmatrizen

Eine Matrix A ∈ Rn×n heißt eine rechte obere Dreiecksmatrix, wenn sie quadratisch istund aij = 0 für i > j. Analog kann man auch die linken unteren Dreiecksmatrizendefinieren, mit aij = 0 für i < j. In jedem Fall bilden rechte obere und linke untereDreiecksmatrizen jeweils Unteralgebren der Matrixalgebra, d. h. , sie sind abgeschlossenunter Addition und Multiplikation. Die Schnittmenge dieser Algebren ist wiederum dieAlgebra der Diagonalmatrizen.Ist A eine rechte obere Dreiecksmatrix, so hat das Gleichungssystem die Form

a11x1 + a12x2 + . . . + a1nxn = b1a22x2 + . . . + a2nxn = b2

. . ....

...annxn = bn.

(2.2)

17

2 Lineare Algebra I

Dieses Gleichungssystem hat genau dann eine Lösung, wenn A regulär ist, also detA =∏ni=1 aii 6= 0. Die Lösung kann dann durch Rücksubstitution direkt bestimmt werden:

xi =1

aii

(bi −

n∑k=i+1

aikxk

)für i = n(−1)1. (2.3)

Für reguläre linke untere Dreiecksmatrizen ergibt sich die Lösung entsprechend durchVorwärtssubstitution:

xi =1

aii

(bi −

i−1∑k=1

aikxk

)für i = 1(1)n. (2.4)

Für Diagonalmatrizen ist die Situation natürlich einfacher, es gilt

xi =1

aiibi für i = 1(1)n. (2.5)

SciPy stellt für Dreiecksmatrizen spezielle Löserroutinen zur Verfügung, scipy.linalg.solve_triangular(A, b, lower=False), wobei lower angibt, ob Aeine linke untere statt rechte obere Dreiecksmatrix ist.

2.2 Gaußelimination

Die Gaußelimination ist ein Verfahren, um eine beliebiges Gleichungssystem Ax = b, mitA ∈ Rm×n, auf die äquivalente Form(

R K0 0

)x′ = b′ (2.6)

k n− kk

m− k

zu bringen, wobei R ∈ Rk,k eine reguläre rechte obere Dreiecksmatrix, K ∈ Rk×n−kbeliebig und x′ eine Permutation (Umordnung) von x ist. Dieses Gleichungssystem hatoffenbar nur dann eine Lösung, wenn b′i = 0 für i = k + 1(1)m.Diese ist im Allgemeinen auch nicht eindeutig, vielmehr können die freien Variablen

xK = (x′i)ni=k+1 frei gewählt werden. Ist xR = (x′i)

ki=1 der Satz der verbleibenden Lö-

sungsvariablen, so gilt alsoxR = R−1b′ −R−1KxK.

Die Lösungen ergeben sich daraus als

x′ =

(R−1b′

0

)+

⟨(−R−1Ki

ei

)⟩, (2.7)

wobei Ki die i-te Spalte von K und 〈〉 den aufgespannten Vektorraum bezeichnet. DieAusdrücke, die R−1 enthalten, können durch Rücksubstitution bestimmt werden.Um das System Ax = b, das wir im Folgenden als A|b zusammenfassen, auf diese Form

zu bringen, stehen folgende Elementaroperationen zur Verfügung, die offensichtlich dieLösung nicht verändern:

1. Vertauschen zweier Gleichungen (Zeilentausch in A|b)

18

2.2 Gaußelimination

2. Vertauschen zweier Spalten in x und A (Variablenaustausch)

3. Addieren eines Vielfachen einer Zeile zu einer anderen

4. Multiplikation einer Zeile mit einer Konstanten ungleich 0

Die Gaußelimination nutzt nun diese Operationen, um die Matrix spaltenweise auf diegewünschte Dreiecksform zu bringen. Dazu werden Vielfache der ersten Zeile von allenanderen abgezogen, so dass die Gleichung die Form

a(0)11 a

(0)12 . . . a

(0)1n b

(0)1

0 a(1)22 . . . a

(1)2n b

(1)2

......

......

0 a(1)m2 . . . a

(1)mn b

(1)m

=: A(1)|b(1) (2.8)

annimmt, wobei

a(1)ik = a

(0)ik − l

(1)i a

(0)1k für i = 2(1)n, k = 1(1)m

b(1)i = b

(0)i − l

(1)i b

(0)1 für i = 2(1)n

a(1)1k = a

(0)1k , b

(1)1 = b

(0)1 sonst

mit l(1)i =

a(0)i1

a(0)11

. (2.9)

Mit dem verbleibenden Resttableau wird nun genauso weiter verfahren:

a(r)ik = a

(r−1)ik − l(r)i a

(r−1)r,k für i = r + 1(1)n, k = r(1)m

b(r)i = b

(r−1)i − l(r)i b

(r−1)r für i = r + 1(1)n

a(r)ik = a

(r−1)ik , b

(r)i = b

(r−1)i sonst

mit l(r)i =a

(r−1)ir

a(r−1)rr

.

(2.10)Das Verfahren ist beendet, wenn das Resttableau nur noch eine Zeile hat.Ist während eines Schrittes a(r−1)

rr = 0 und

1. nicht alle a(r−1)ir = 0, i = r + 1(1)m. Dann tauscht man Zeile r gegen eine Zeile i

mit a(r−1)ir 6= 0, und fährt fort.

2. alle a(r−1)ir = 0, i = r(1)m, aber es gibt ein a

(r−1)ik 6= 0 mit i ≥ r, k > r. Dann

vertauscht man zunächst Zeile r mit Zeile i, tauscht anschließend Spalte k mitSpalte r, und fährt fort.

3. alle a(r−1)ik = 0 für i,k ≥ r. Dann hat A(r−1)|b(r−1) die gewünschte Form (2.6)

erreicht, und das Verfahren terminiert.

Das Element a(r−1)rr heißt auch Pivotelement, da es sozusagen der Dreh- und Angel-

punkt des iterativen Verfahrens ist. In der Praxis ist es numerisch günstiger, wenn diesesElement möglichst groß ist. Das lässt sich erreichen, indem wie in den singulären Fällenverfahren wird, also Zeilen oder Spalten getauscht werden, um das betragsmäßig maxi-male a(r−1)

ik nach vorne zu bringen. Folgende Verfahren werden unterschieden

19

2 Lineare Algebra I

• kanonische Pivotwahl: es wird stets a(r−1)rr gewählt und abgebrochen, falls dieses

betragsmäßig zu klein wird. Diese Verfahren scheitert schon bei einfachen Matrizen(z. B.

(0 11 0

)), und kann daher nur eingesetzt werden, wenn die Struktur der Matrix

sicherstellt, das a(r−1)rr stets hinreichend groß ist.

• Spaltenpivotwahl : es wird wie oben im 1. Fall nur in der Spalte maximiert, d. h. wirwählen als Pivotelement

i0 = argmaxi≥r|a(r−1)ir | (2.11)

und tauschen Zeilen i0 und r; die Variablenreihenfolge bleibt unverändert. Ist dieMatrix A quadratisch, bricht das Verfahren genau dann ab, wenn A singulär ist.

• Totalpivotwahl : wie oben im 2. Fall wird stets das betragsmäßig maximale Matri-xelement im gesamten Resttableau gesucht, also

i0,k0 = argmaxi,k≥r|a(r−1)ik |. (2.12)

Dann vertauscht man zunächst Zeile r mit Zeile i0, und tauscht anschließend Spal-te k0 mit Spalte r, wobei man sich noch die Permutation der Variablen geeignetmerken muss, zum Beispiel als Vektor von Indizes.

Unabhängig von der Pivotwahl benötigt die Gaußelimination bei quadratischen Matri-zen im wesentlichen O(n3) Fließkommaoperationen. Das ist relativ langsam, daher wer-den wir später bessere approximative Verfahren kennenlernen. Für Matrizen bestimmterStruktur, zum Beispiel Bandmatrizen, ist die Gaußelimination aber gut geeignet. Num-Py bzw. SciPy stellen daher auch keine Gaußelimination direkt zur Verfügung. scipy.linalg.solve(A, b) ist ein Löser für Gleichungssysteme Ax = b, der immerhin aufder LU-Zerlegung durch Gaußelimination basiert. Dieser Löser setzt allerdings voraus,dass die Matrix nicht singulär ist, also eindeutig lösbar.

2.3 Matrixinversion

Ist A ∈ Rn×n regulär, so liefert die Rücksubstitution implizit die Inverse von A, dafür beliebige b das Gleichungssystem Ax = b gelöst werden kann. Allerdings muss dasfür jedes b von neuem geschehen. Alternativ kann mit Hilfe der Gaußelimination auchdie Inverse von A bestimmt werden. Dazu wird das Tableau A|I in das Tableau I|A−1

transformiert, wobei I die n×n-Einheitsmatrix bezeichnet. Die Vorgehensweise entsprichtzunächst der Gaußelimination mit Spaltenpivotwahl. Allerdings werden nicht nur dieElemente unterhalb der Diagonalen, sondern auch oberhalb eliminiert. Zusätzlich wirddie Pivotzeile noch mit 1/a

(i−1)ii multipliziert, so dass das A schrittweise die Form

1 0 a(2)12 . . . a

(2)1n

0 1 a(2)22 . . . a

(2)2n

... 0 a(2)32 . . . a

(2)3n

......

......

0 0 a(2)n2 . . . a

(2)nn

(2.13)

20

2.4 LU-Zerlegung

annimmt. Das Verfahren ist allerdings numerisch nicht sehr stabil, und generell sollte dieexplizite Berechnung der Inversen wann immer möglich vermieden werden. SciPy stelltdie Matrixinversion als Funktion scipy.linalg.inv(A) zur Verfügung.Eine Ausnahme bilden Matrizen der Form I +A mit ‖A‖ = max‖Ax‖/‖x‖ < 1. Dann

ist(I +A)−1 = I −A+A2 −A3 + · · · (2.14)

eine gut konvergierende Näherung der Inversen.

2.4 LU-Zerlegung

Eine weitere Anwendung der Gaußelimination ist die LU-Zerlegung von bestimmten qua-dratischen Matrizen. Dabei wird eine Matrix A ∈ Rn×n so in eine linke untere Dreiecks-matrix L und eine rechte obere Dreiecksmatrix U zerlegt, dass A = L · U . Um die LU-Zerlegung eindeutig zu machen, vereinbart man üblicherweise, dass lii = 1 für i = 1(1)n.Das U steht übrigens für das englische „upper right“ und L für „lower left“. Im Deutschenfindet sich vereinzelt noch der Begriff LR-Zerlegung, wobei hier L für eine linke untereund R für eine rechte obere Matrix steht.Ist eine solche Zerlegung einmal gefunden, lässt sich das Gleichungssystem Ax = b für

beliebige b effizient durch Vorwärts- und Rücksubstitution lösen:

Ly = b, Ux = y =⇒ Ax = LUx = Ly = b. (2.15)

Zunächst wird also y durch Vorwärtssubstitution berechnet, anschließend x durch Rück-wärtssubstitution. Die Inverse lässt sich so auch bestimmen:

Lyi = ei, Uxi = yi für i = 1(1)n =⇒ A−1 = (x1, . . . , xn) . (2.16)

Die Determinante von A = L · U ist ebenfalls einfach zu bestimmen:

detA = detL detU =n∏i=1

uii (2.17)

Um die LU-Zerlegung zu berechnen, nutzen wir wieder die Gaußelimination. Kann beiA ∈ Rn×n die Gaußelimination in kanonischer Pivotwahl durchgeführt werden, so ist dieLU-Zerlegung von A durch U = A(n−1), also die finale, auf rechte obere Dreiecksformtransformierte Matrix, und durch die Matrix

L =

1 0

l(0)1 1

l(0)2 l

(1)2 1

.... . . . . .

l(0)n . . . . . . l

(n−1)n 1

(2.18)

der Updatekoeffizienten aus (2.10) gegeben.

21

2 Lineare Algebra I

Wie bereits gesagt, ist die Voraussetzung, dass die Gaußelimination mit kanonischerPivotwahl durchgeführt werden kann, sehr restriktiv, und schließt selbst einfache Matri-zen wie

(0 11 0

)aus. Wie man sich leicht überlegt, besitzt diese Matrix allerdings keine

LU-Zerlegung.Für manche Anwendungen ist es günstiger, wenn L und U normiert sind. Dann benutzt

man die LDU-Zerlegung A = LDU , mit L linker unterer Dreiecksmatrix, D Diagonal-matrix und U rechter oberer Dreiecksmatrix. Jetzt müssen lii = 1 und rii = 1 sein. DieLDU-Zerlegung ergibt sich aus der LU-Zerlegung durch dii = uii und u′ik = uik/uii.In SciPy ist die LU-Zerlegung als scipy.linalg.lu_factor(A) oder scipy.

linalg.lu(A) (zur Zerlegung der Matrix A) und scipy.linalg.lu_solve((lu,piv), b) (zum Lösen des LGS) implementiert.

2.5 Cholesky-Zerlegung

Wir betrachten im Folgenden nur symmetrische, positiv definite Matrizen, wie sie geradein der Physik oft vorkommen. Auch in der Optimierung spielen diese eine wichtige Rolle.Sei A = LDU eine LDU-Zerlegung einer symmetrischen Matrix, dann gilt

LDU = A = AT = (LDU)T = UTDLT , (2.19)

wobei T wie eingangs erwähnt die Transponierte von A bezeichnet. Da die LDU-Zerlegungaber eindeutig ist und UT eine normierte, linke untere Dreiecksmatrix und LT eine nor-mierte, rechte obere Dreiecksmatrix, so gilt U = UT , und damit

A = UTDU = RTR mit R = diag(√dii)U. (2.20)

Dies ist die Cholesky-Zerlegung. Anstatt die Gaußelimination durchzuführen, lässt sichdie Zerlegung aber auch direkt mit Hilfe des Cholesky-Verfahrens bestimmen: Sei A =RTR eine Cholesky-Zerlegung. Da R unterhalb der Diagonalen nur 0 enthält, gilt

aik =

i∑l=1

rlirlk für i = 1(1)n, k = 1(1)n. (2.21)

Daraus lässt sich die erste Zeile von R direkt ablesen:

r11 =√a11 und r1k =

a1k

r11für k = 2(1)n. (2.22)

Die nächsten Zeilen lassen sich analog bestimmen, da für jedes i

aii =i∑l=1

r2li =⇒ rii =

√√√√aii −i−1∑l=1

r2li. (2.23)

Für die restlichen Elemente der Zeile gilt

rik =1

rii

(aik −

i−1∑l=1

rlirlk

)für k = i+ 1(1)n (2.24)

22

2.6 Bandmatrizen

Das Cholesky-Verfahren ist wie die Gaußelimination von der Ordnung O(n3), brauchtaber nur halb so viele Operationen. In SciPy ist die Cholesky-Zerlegung als scipy.linalg.cholesky(A) implementiert.

2.6 Bandmatrizen

Im Folgenden werden wir oft mit k-Bandmatrizen zu tun haben, also Matrizen, bei denennur die Diagonale und einige Nebendiagonalen besetzt sind. Diagonalmatrizen sind also1-Bandmatrizen, eine Dreibandmatrix hat die Form

d1 t1 0b1 d2 t2

. . . . . . . . .bn−2 dn−1 tn−1

0 bn−1 dn

. (2.25)

Für Matrizen dieser Form ist die Gaußelimination mit kanonischer Pivotwahl sehr ef-fizient, da pro Iteration jeweils nur die erste Zeile des Resttableaus verändert werdenmuss. Dadurch ist der Rechenaufwand nur noch linear in der Matrixgröße bzw. Längeder Bänder. Die Dreiecksmatrizen L und U der LU-Zerlegung sind zusätzlich (Drei-)Bandmatrizen, wobei L nur auf der Haupt und der unteren Nebendiagonalen von Nullverschiedene Einträge hat, U nur auf der Diagonalen und der Nebendiagonalen oberhalb.SciPy stellt für Bandmatrizen ebenfalls spezielle Löserroutinen zur Verfügung, scipy

.linalg.solve_banded((l,u), A, b), wobei l und u die Anzahl der Nebendia-gonalen oberhalb und unterhalb angeben, und A die Matrix in Bandform angibt.

23

3 Darstellung von Funktionen

Auch moderne Prozessoren beherrschen nur die Grundrechenarten. Wie kann man alsoauf einem Computer kompliziertere Funktionen berechnen, wie z. B. die Sinusfunktion?Beispielsweise könnte man die Funktionen als Vektor von Funktionswerten speichern.

Für die graphische Darstellung reicht das aus, aber um Funktionen mit wenigstens sechsStellen Genauigkeit im Computer bereitzustellen, wären Millionen von Stützstellen nötig.Daher müssen bessere Darstellungen für Funktionen genutzt werden. Um beliebige

Funktionen auf dem Computer berechnen zu können, führt man diese meist auf (stück-weise definierte) Polynome zurück, die nur mit Hilfe der Grundrechenarten berechnetwerden können. Dies ist selbst dann der Fall, wenn ein Prozessor gewisse Funktionenscheinbar in Hardware implementiert hat; tatsächlich führt dieser intern die notwendigenelementaren Operationen durch.

3.1 Horner-Schema

Die naive Auswertung eines Polynoms∑n

i=0 cixi mit n + 1 Termen bzw. vom Grad

n benötigt n Additionen und 2n Multiplikationen sowie einen Zwischenspeicher für diePotenzen xi des Arguments x. Besser ist die Auswertung des Polynoms nach dem Horner-Schema:

n∑i=0

cixi = c0 + x(c1 + x(c2 + x(. . . (cn−1 + xcn)))). (3.1)

Wird dieser Ausdruck von rechts nach links ausgewertet, so muss das Ergebnis in jedemSchritt nur mit x multipliziert und der nächste Koeffizient addiert werden, was nur nMultiplikationen und Additionen benötigt. Auch muss kein Zwischenwert gespeichertwerden, was Prozessorregister spart. In Python sieht die Auswertung des Hornerschemasso aus:

def horner(series, x):r = series[-1]for c in reversed(series[:-1]):

r = r*x + creturn r

Die Polynomauswertung stellt NumPy als numpy.polyval(c, x) zur Verfügung.c bezeichnet die Koeffizienten des Polynoms und x das Argument, für das das Polynomausgewertet werden soll. Achtung! Anders als das obige Beispiel folgt polyval nichtder mathematischen Schreibweise und verarbeitet die Koeffizienten in der umgekehrtenReihenfolge, berechnet also

∑ni=0 cix

n−i.

25


Eine weitere Anwendung des Hornerschemas ist die Polynomdivision durch linearePolynome der Form x − x0, die zum Beispiel wichtig für die iterative Bestimmung vonNullstellen ist. Es gilt nämlich

P (x) =n∑i=0

cixi =

(n−1∑i=0

di+1xi

)(x− x0) + d0, (3.2)

wobei di = ci+x0(ci+1 +x0(. . . (cn−1 +xocn))) die Zwischenterme des Hornerschemas beiAuswertung an der Stelle x0 sind. d0 ist dabei der Divisionsrest; ist P (x) durch x − x0

teilbar, so ist d0 = 0.Dies zeigt man durch Induktion: für P (x) = c1x+ c0 ist offenbar P (x) = c1(x− x0) +

c0 + x0c1 = d1(x− x0) + d0. Für Grad n ist also

P (x) = x

(n−1∑i=0

ci+1xi

)+ c0 = x

(n−2∑i=0

d′i+1xi(x− x0) + d′0

)+ c0 (3.3)

wobei sich die d′i = ci+1 +x0(ci+2 +x0(. . . (cn−1 +xocn))) = di+1 bei der Polynomdivisionvon

∑n−1i=0 ci+1x

i durch x− x0 nach Voraussetzung ergeben. Daher ist

P (x) =n−2∑i=0

di+2xi+1(x− x0) + d1x+ c0 =

(n−1∑i=0

di+1xi

)(x− x0) + d1x0 + c0︸︷︷︸

d0

, (3.4)

was zu zeigen war.

3.2 Taylorreihen

Nachdem wir nun wissen, wie Polynome effizient ausgewertet werden können, stellt sichdie Frage, wie man ein gutes Näherungspolynom für eine Funktion bekommt. Dazu gibtes viele verschiedene Ansätze, deren Vor- und Nachteile im Folgenden kurz besprochenwerden. Der älteste Ansatz, der auch in der Analytik weiten Einsatz findet, ist die Tay-lorentwicklung. Ist eine Funktion f um einen Punkt xo hinreichend gut differenzierbar,lässt sie sich als bekannterweise lokal als Taylorreihe darstellen:

f(x) =∞∑i=0

f (i)(x0)

i!(x− x0)i, (3.5)

wobei f (i)(x) die i-te Ableitung von f an der Stelle x bezeichnet. Falls die Ableitungenexistieren und x−x0 klein genug ist, so konvergiert diese Darstellung schnell, und einigeTerme genügen, um zufriedenstellende Genauigkeit zu erreichen. Lokal um den Entwick-lungspunkt x0 is eine abgeschnittene Taylorreihe also eine gute polynomielle Näherung.Leider gibt es für die meisten Funktionen einen Konvergenzradius, außerhalb dessen dieReihe nicht einmal konvergiert. Daher eignen sich Taylorreihen nur, wenn kleine Umge-bungen genähert werden sollen. Um weitere Intervalle so nähern zu können, ist es aber

26

3.3 Polynom- oder Lagrangeinterpolation

3 2 1 0 1 2 31.5

1.0

0.5

0.0

0.5

1.0

1.5

Abbildung 3.1: Näherung der Sinusfunktion durch die abgeschnittene Taylorreihe. Alsschwarze durchgezogene Linie ist die tatsächliche Sinusfunktion dargestellt, blau gepunk-tet ist die Näherung erster Ordnung um Null, x, grün durchgezogen ist die kubische Nä-herung x−x3/6, und rot gestrichelt x−x3/6+x5/120. Die Kurven nutzen die Symmetrieder Sinuskurve, sind also an ±π/2 gespiegelt.

natürlich möglich, mehrere Entwicklungspunkte zu benutzen, so dass deren Umgebungen,in denen die Konvergenz ausreicht, den gesamten geforderten Bereich abdecken.Um zum Beispiel die oben angeführte Sinusfunktion mit 7 Stellen Genauigkeit im

Intervall [0 : π/2] auszuwerten, genügen die ersten 7 Terme der Taylorreihe. Mit Hilfe derSymmetrien der Funktion lässt sie sich damit bereits für alle Argumente auswerten. Da

sin′(x) = cos(x) und cos′(x) = − sin(x),

ergibt sich die bekannte Reihe

sin(x) =∞∑i=0

sin(i)(0)

i!xi =

∞∑i=0

(−1)i

(2i+ 1)!x2i+1. (3.6)

Wie gut diese Darstellung mit entsprechender Rückfaltung funktioniert, zeigt Abbil-dung 3.1. Für viele andere komplexe Funktionen ist es ebenfalls möglich, Taylorreihenanalytisch oder numerisch zu bestimmen, die dann zur Auswertung auf dem Computergenutzt werden können.


Wie besprochen ist eine abgeschnittene Taylorreihe nur im Entwicklungspunkt exakt(dann allerdings auch die Ableitungen), innerhalb des Konvergenzradius nur eine Annä-herung, und außerhalb des Konvergenzradius sogar divergent. Oft möchte man aber eher

27


für einen größeren Wertebereich eine gute (oder wenn möglich exakte) Darstellung derFunktion haben.Eine Möglichkeit dazu bietet die Polynom- oder Lagrangeinterpolation. Dazu legt man

eine Anzahl von Punkten im gewünschten Wertebereich fest (die sogenannten Stützstel-len). Wie sich zeigt, gibt es dann genau ein Polynom, dass die Funktion an diesen Punktenexakt interpoliert. Genauer: seien Punkte (xi, yi), i = 0(1)n−1 gegeben mit xi paarweiseverschieden. Dann gibt es genau ein Polynom P (x) =

∑n−1k=0 akx

k vom Grad n − 1, sodass P (xi) = yi, da die Gleichung

y1 = P (x0) = a0 + a1x0 + · · ·+ an−1xn−10

...

yn = P (xn−1) = a0 + a1xn−1 + · · ·+ an−1xn−1n−1

(3.7)

genau eine Lösung hat. In SciPy liefert die Funktion scipy.interpolate.lagrange(x, y) das interpolierende Polynom durch die Stützstellen (x[i], y[i]).Leider ist aber nicht gewährleistet, dass mit steigender Anzahl von Punkten die Funk-

tion auch zwischen den Stützstellen immer besser angenähert wird. Tatsächlich hat Run-ge ein einfaches Beispiel angegeben, nämlich die Rungefunktion 1/(1 + x2), für die dieNäherung mit steigender Anzahl an äquidistanten Punkten immer schlechter wird. Ab-bildung 3.2 zeigt Polynome wachsenden Grades, die diese Funktion interpolieren. Beiäquidistanten Stützstellen wird der Interpolationsfehler zum Rand des Intervalls hin sehrgroß.Bei der etwas allgemeineren Hermite-Interpolation können an den Stützstellen neben

den Funktionswerten auch Ableitungen vorgegeben werden. Das eindeutige interpolie-rende Polynom hat dann einen Grad, der der Gesamtanzahl an vorgegebenen Funktions-werten und Ableitungen entspricht. Ist zum Beispiel nur eine Stützstelle x0 gegeben undneben dem Funktionswert n Ableitungen, so entspricht das Hermite-Polynom genau denersten n+ 1 Termen der Taylorreihe.Das interpolierende Polynom kann nicht nur zur Interpolation verwendet werden, also

der Bestimmung an Punkten zwischen den Stützstellen, sondern — mit Vorsicht — auchzur Extrapolation, also um Werte außerhalb des Bereichs der Stützstellen zu bestimmen.Da bei der Hermite-Interpolation auch die Ableitungen insbesondere am Rand kontrol-liert werden können, ist diese hier tendenziell vorteilhafter. Bei einem Taylorpolynom wirdsogar fast immer extrapoliert, da es ja nur eine Stützstelle gibt. Extrapolation ist immerdann wichtig, wenn die Auswertung der Zielfunktion an der Zielstelle numerisch zu teueroder unmöglich wird. So werden wir später das Romberg-Integrationsverfahren kennenler-nen, bei dem zu Schrittweite 0 extrapoliert wird, also „unendlich vielen“ Stützstellen. BeiComputersimulationen nutzt man dies insbesondere in der Nähe von kritischen Punkten.Die Koeffizienten ai können im Prinzip als Lösung von Gleichung (3.7) mit geeigneten

Lösern für lineare Gleichungssysteme gefunden werden, was im Allgemeinen allerdingsrecht langsam ist. Daher lernen wir nun effizientere Darstellungen des interpolierendenPolynoms, die unter geeigneten Umständen die Berechnung und Auswertung des inter-polierenden Polynoms mit linearen Aufwand ermöglichen.

28


4 2 0 2 40.5

0.0

0.5

1.0

1.5

4 2 0 2 40.5

0.0

0.5

1.0

1.5

Abbildung 3.2: Lagrange-Interpolation der Rungefunktion 1/(1+x2) (schwarze Linie). Imlinken Graph sind die Stützstellen äquidistant gewählt (markierte Punkte), die farbigenLinien sind die interpolierenden Polynome durch 3 (rot), 5 (lila), 7 (blau) und 11 (grün)Stützstellen. Mit steigender Ordnung wird die Interpolation am Rand immer schlechter,das Polynom 10. Ordnung erreicht Werte bis nahe an zwei. Im rechten Graph sind für diegleichen Ordnungen Chebyshev-Stützstellen gewählt worden, die den Interpolationsfehlerminimieren.

3.3.1 Lagrangepolynome

Die einfachste Darstellung benutzt die Lagrangepolynome, die wie folgt definiert sind:

Li(x) =∏k 6=i

x− xkxi − xk

. (3.8)

Die Polynominterpolation wird daher auch Lagrange-Interpolation genannt. Wie manleicht sieht, gilt Li(xk) = δik, so dass das Polynom

P (x) =n−1∑i=0

yi Li(x) (3.9)

das eindeutige interpolierende Polynom durch (xi, yi) ist. Die Auswertung der Lagran-gedarstellung erfordert O(n) Operationen für jedes der Li(x), also ingesamt O(n2) Ope-rationen. Das ist zwar besser also der Aufwand für die Lösung des Gleichungssystems(3.7), dafür muss er aber bei jeder Auswertung erbracht werden. Die Lagrangedarstellungist daher nur dann effizient, wenn die Stützstellen und der Punkt, an dem ausgewertetwerden soll, fest sind, da dann lediglich die äußere Summe neu bestimmt werden muss.

29


3.3.2 Baryzentrische Darstellung

Eine alternative Darstellung ist die baryzentrische Darstellung

P (x) =n−1∑i=0

yi µi(x)/ n−1∑

i=0

µi(x) mit µi(x) :=1

x− xiωi und ωi =

∏k 6=i

1

xi − xk(3.10)

Sind die Stützstellen xi fest, so können die Werte ωi vorausberechnet werden. Dann kanndas Polynom an beliebigen Stellen mit Aufwand O(n) ausgewertet werden. Allerdingskann der Ausdruck an den Stützstellen selber nicht ausgewertet werden.

3.3.3 Neville-Aitken-Schema

Die effizienteste Möglichkeit,das interpolierende Polynom auszuwerten, ohne es zu be-rechnen, ist das rekursive Neville-Schema. Das ist nützlich, wenn nur wenige Auswer-tungen nötig sind, wie zum Beispiel beim Romberg-Integrationsverfahren, bei dem zurSchrittweite 0 extrapoliert wird.Wir definieren Pi,k als das interpolierende Polynom der Ordnung k − 1 durch die

Stützstellen xj , j = i(1)i+k−1. Gesucht ist der Wert P (x) = P0,n(x) des interpolierendenPolynoms an der Stelle x. Dann ist

Pi,1(x) = yi für i = 0(1)n− 1 (3.11)

und

Pi,k(x) =Pi,k−1(x)(xi+k−1 − x) + Pi+1,k−1(x)(x− xi)

xi+k−1 − xifür k = 2(1)n, i = 0(1)n− k,

(3.12)

da ja an den inneren Stützstellen xl, l = i+ 1(1)i+ k− 2, Pi,k−1(xl) = Pi+1,k−1(xl) = ylgilt, und per Konstruktion Pi,k(xi) = yi und Pi,k(xi+k−1) = yi+k−1. Durch sukzessivesBerechnen zunächst der Pi,2(x), dann der Pi,3(x), usw. lässt sich das interpolierendePolynom bequem an einer fixen Stelle auswerten. Als (Neville-)Schema sieht das so aus:

y0

y1

y2

y3

...

P0,2(x)

P1,2(x)

P2,2(x)...

P0,3(x)

P1,3(x)...

P0,3(x)...

wobei die Pfeilpaare dividierte Differenzen gemäß (3.12) bedeuten.

30


3.3.4 Newtonsche Darstellung

Wir betrachten nun die Polynome P0,k des Nevilleschemas. Es gilt offenbar

P0,k(x)− P0,k−1(x) = γk(x− x0) · · · (x− xk−2), (3.13)

da die beiden Polynome in den Stützstellen x0, . . . ,xk−2 übereinstimmen und die Differenzein Polynom vom Grad k − 1 ist, also höchstens k − 1 Nullstellen hat. Weiter ist γk derführende Koeffizient des Polynoms P0,k(t), da P0,k−1(t) ja einen niedrigeren Grad hat.Daraus ergibt sich die folgende Newtonsche Darstellung des interpolierenden Polynoms:

P0,n(x) = y0 +

n∑k=2

P0,k(x)− P0,k−1(x)

= y0 + γ2(x− x0) + γ3(x− x0)(x− x1) + · · ·+ γn(x− x0) · · · (x− xn−2)

= y0 + (x− x0)

(γ2 + (x− x1)

(γ3 + · · ·

(γn−1 + (x− xn−2)γn

)· · ·))

.

(3.14)

Die letztere Umformung zeigt, dass sich die Newtonsche Darstellung effizient mit einemleicht abgewandelten Hornerschema auswerten lässt:def horner(x, xsupport, gamma):

r = 0for k in range(len(xsupport)-1, -1, -1):

r = r*(x-xsupport[k]) + gamma[k];return r

Die Koeffizienten γi, i = 2(1)n lassen sich dabei bequem mit dem Nevilleschema be-stimmen. γk ist ja der höchste Koeffizient von P0,k ist, der sich leicht aus (3.12) berechnenlässt. Wenn γi,k den führenden Koeffizienten des Polynoms Pi,k bezeichnet, so erhaltenwir das Nevilleschema

γi,1 = yi für i = 0(1)n− 1 und (3.15)

γi,k =γi+1,k−1 − γi,k−1

xi+k−1 − xifür k = 2(1)n, i = 0(1)n− k. (3.16)

Da letztlich nur die γ0,k interessant sind, also die obere Diagonale des Nevilleschemas,benötigt man für die Berechnung nur einen Vektor

γ′ = (γ0,1,γ0,2, . . . ,γ0,k−1, γ0,k,γ1,k, . . . ,γn−k,k) , (3.17)

der wie folgt berechnet wird:def neville(x, y):

n = len(x)gamma = y.copy()for k in range(1, n):

for i in range(n-k-1, -1, -1):gamma[i+k] = (gamma[i+k] - gamma[i+k-1])/(x[i+k] - x[i])

return gamma

Die Schleife über i zählt abwärts, um benötigte Werte nicht zu überschreiben.

31


3.3.5 Chebyshev-Stützstellen

Bis jetzt haben wir wenig zur Wahl der Stützstellen gesagt. Oft liegt es auch nahe,äquidistante Stützstellen zu verwenden wie im Fadenpendel-Beispiel. Man kann allerdingszeigen, dass die Chebyshev-Stützstellen den Fehler der Polynominterpolation minimieren.Diese sind definiert als die Nullstellen der Polynome (!)

Tn(cosφ) = cos(nφ), (3.18)

die offensichtlich zwischen -1 und 1 liegen und daher geeignet skaliert werden müssen fürdie Interpolation in einem allgemeinen Intervall. Die Chebyshev-Polynome Tn, n ≥ 0,bilden eine orthogonale Basis der Funktionen über [−1,1] bezüglich des mit 1/

√1− x2

gewichteten Skalarprodukts. Daher kann jede genügend glatte Funktion auf [−1,1] alseine Reihe

f(x) =

∞∑n=0

anTn(x) (3.19)

dargestellt werden, die sogenannte Chebyshev-Reihe (siehe auch z. B. Abramowitz undStegun [AS70]).Explizit sind diese Nullstellen gegeben durch

xk,n = cos

(2k + 1

2nπ

), k = 0(1)n− 1. (3.20)

Wird die Rungefunktion mit Chebyshevstützstellen interpoliert, so konvergiert das inter-polierende Polynom, im Gegensatz zu äquidistanten Stützstellen. Sollen die Stützstellenstatt [−1,1] das Intervall [a,b] abdecken, skaliert man einfach entsprechend um:

xk,n =a+ b

2+a− b

2cos

(2k + 1

2nπ

), k = 0(1)n− 1. (3.21)

3.4 Splines

Wie wir gesehen haben, kann unter ungünstigen Umständen die Güte der Polynominter-polation mit steigender Anzahl an Stützstellen sinken, vor allem, wenn diese äquidistantverteilt sind. Oft ist das aber nicht zu vermeiden, zum Beispiel, wenn die Daten in ei-nem Experiment regelmäßig gemessen werden. Das Problem ist, das die Koeffizienten desPolynoms global gelten, sich glatte Funktionen aber nur lokal wie ein Polynom verhal-ten (Taylorentwicklung!). Daher ist es günstiger, statt der gesamten Funktion nur kleineAbschnitte durch Polynome zu nähern.Der einfachste Fall einer solchen Näherung ist die lineare Interpolation, bei der die

Stützstellen durch Geraden, also Polynome vom Grad 1, verbunden werden. Sind dieStützstellen (xi, yi), i = 0(1)n− 1 gegeben, so ist der lineare interpolierende Spline

P1(x) =(xi+1 − x)yi + (x− xi)yi+1

xi+1 − xifür xi ≤ x < xi+1. (3.22)

32

3.4 Splines

Diese Funktionen sind aber an den Stützstellen im Allgemeinen nicht differenzierbar.Soll die Interpolierende differenzierbar sein, müssen Polynome höherer Ordnung genutztwerden. Solche stückweise definierten Polynome heißen Splines — das englische WortSplines bezeichnete dünne Latten, die vor dem Computerzeitalter benutzt wurden, umglatte, gebogene Oberflächen vor allem für Schiffsrümpfe zu entwickeln.Der wichtigste Spline ist der kubische Spline, der aus Polynomen dritten Grades zu-

sammengesetzt und zweifach stetig differenzierbar ist. Seine allgemeine Form ist

P3(x) = yi +mi(x− xi) +1

2Mi(x− xi)2 +

1

6αi(x− xi)3 für xi ≤ x < xi+1. (3.23)

auf n − 1 Intervallen [xi, xi+1], i = 0(1)n − 2. Da die zwei rechten und linken zweitenAbleitungen an den Stützstellen übereinstimmen müssen, gilt

αi =Mi+1 −Mi

xi+1 − xifür i = 0(1)n− 2, (3.24)

wobeiMn−1 die Ableitung des Splines an seinem rechten Ende bezeichnet. Aus der Gleich-heit der Funktionswerte an den Stützstellen ergibt sich

mi =yi+1 − yixi+1 − xi

− 1

6(xi+1 − xi)(2Mi +Mi+1) für i = 0(1)n− 2. (3.25)

Aus der Gleichheit der ersten Ableitungen ergibt sich schließlich ein Gleichungssystemmit n− 3 Gleichungen für die Mi, nämlichµ1 2 λ1

. . . . . . . . .µn−3 2 λn−3

M0

...Mn−2

=

6S1...

6Sn−3

, (3.26)

mit

λi =xi+1 − xixi+1 − xi−1

, µi =xi − xi−1

xi+1 − xi−1und Si =

yi+1−yixi+1−xi −

yi−yi−1

xi−xi−1

xi+1 − xi−1. (3.27)

Sind die Mi bestimmt, so ergeben sich die mi und αi aus (3.24) bzw. (3.25). Allerdingsgibt es fehlen dazu noch zwei Gleichungen, nämlich die Randbedingungen.Soll der Spline am Rand festgelegte 2. Ableitungen P ′′3 (x0) = M0 und P ′′3 (xn−1) =

Mn−1 haben, so hat das Gleichungssystem die Form1 0 0µ1 2 λ1

. . . . . . . . .µn−2 2 λn−2

0 0 1

M0

M1...

Mn−2

Mn−1

=

P ′′3 (x0)

6S1...

6Sn−2

P ′′3 (xn−1)

. (3.28)

Mn−1 wird zur Interpolation nicht benötigt, da es nur die zweite Ableitung am rechtenRand darstellt. Diese Form des Splines wird auch als natürlicher Spline bezeichnet.

33


4 2 0 2 40.0

0.2

0.4

0.6

0.8

1.0

4 2 0 2 4

0.6

0.4

0.2

0.0

0.2

0.4

0.6

Abbildung 3.3: Links: Spline-Interpolation der Rungefunktion (durchgezogene schwarzeLinie). Die gestrichelte blaue Linie ist die lineare Spline-Interpolierende mit 7 Stützstel-len, die anderen Kurven sind kubische Splines mit 7 (grün gepunktet) und 11 Stützstellen(rot gestrichelt). Mit 11 Stützstellen ist der Spline von der Rungefunktion praktisch nichtmehr zu unterscheiden. Rechts: erste (rot gepunktet) und zweite Ableitung (blau) desinterpolierenden Splines elfter Ordnung, sowie die zweite Ableitung der eigentlichen Run-gefunktion (dünn schwarz). Hier zeigen sich deutliche Unterschiede, da der Spline ja einPolygonzug niedriger Ordnung ist.

Auch periodische Funktionen können kubisch interpoliert werden, wobei dann die zu-sätzlichen Bedingungen durch die stetige Differenzierbarkeit über die periodische Grenzehinweg gegeben sind. Dadurch besteht der Spline aus n statt n − 1 Abschnitten, wobeider letzte Abschnitt den periodischen Zirkelschluss formt. Die Gleichungen für αi undmi gelten dann unverändert für i = 0(1)n − 1, wobei xn = x0, yn = y0 und Mn = M0

indentifiziert werden. Das Gleichungssystem nimmt dadurch die Form2 λ0 µ0

µ1 2 λ1 0. . . . . . . . .

0 µn−2 2 λn−2

λn−1 µn−1 2

M0

M1...

Mn−2

Mn−1

=

6S1

6S2...

6Sn−2

6Sn−1

, (3.29)

wobei in λi, µi und Si wieder xn = x0 und x−1 = xn−1 identifiziert werden.Abbildung 3.3 zeigt die Spline-Interpolation der Rungefunktion. Anders als die La-

grangeinterpolation hat die Splineinterpolation keine Probleme mit der Rungefunktion.Die Spline-Interpolierende elften Grades lässt sich kaum von eigentlichen Funktion un-terscheiden. Allerdings gilt das nur für die Funktion selber. Die Ableitung und vor allemzweite Ableitung unterscheiden sich deutlich, da die letztere ja ein Linienzug ist.

34

3.5 Fourierreihen

Die Gleichungssysteme (3.28) und (3.29) sind sehr gut konditioniert und mit einemeinfachen Gleichungslöser zu behandeln. Zum Beispiel ist die Gauß-Elimination ist fürdie hier auftretenden einfachen Bandstrukturen sehr effizient. In SciPy gibt es selbst-verständlich bereits eine fertige Routine für die Spline-Interpolation, nämlich scipy.interpolate.interp1d(x, y, kind). (x, y) sind dabei die Stützstellen, undkind eine Zeichenkette, die den Typ des Splines bestimmt. Mögliche Werte sind zumBeispiel „linear“ und „cubic“ für lineare bzw. kubische interpolierende Splines. Allerdingserlaubt diese Form nicht, die Randbedingung zu wählen. SciPy implementiert eine wei-tere Methode, bei der die Quadratnorm der zweiten Ableitung minimiert wird, es suchtalso den „glattesten“ Spline.

3.5 Fourierreihen

Bis jetzt waren unsere Näherungsfunktionen auf Polynomen basierend, da diese einer-seits vom Computer verarbeitet werden können und andererseits aufgrund der Taylorent-wicklung glatte Funktionen meist gut approximieren. Für periodische Funktionen sindPolynome aber an sich erst einmal wenig geeignet, da sie selbst nicht periodisch sind.Splines können zwar auch periodisch gemacht werden, aber trotzdem sind trigonometri-sche Funktionen besser geeignet, um periodische Funktionen darzustellen. Fourierreihenund -transformationen stellen Funktionen als trigonometrische Reihen dar, die meist gutkonvergieren und darüber hinaus einige nützliche Eigenschaften haben.Es gibt zwei Hauptanwendungen der Fourierdarstellung: die Analyse und Aufbereitung

periodischer Signale und die Lösung von Differentialgleichungen. Bei periodischen Signa-len dient die Fourierdarstellung zur Analyse des Spektrums des Signals. Diese gibt nützli-che Informationen über die charakteristischen Zeitskalen von Strukturen im Signal, zumBeispiel die Tonhöhe und die Obertonreihe eines Instruments. In dieser Frequenzdarstel-lung lassen sich auch gezielt einzelne Frequenzen dämpfen, was Rauschen unterdrückenkann und im ursprünglichen Funktionsraum teure Faltungen erfordert. Bei Differenti-algleichungen nutzt man aus, dass die Ableitung im Frequenzraum eine algebraischeOperation ist, und die Differentialgleichung somit in eine gewöhnliche algebraische (undoft sogar lineare) übergeht.

3.5.1 Komplexe Fourierreihen

Wir betrachten eine periodische Funktion f(t) mit f(t+ T ) = f(t) für alle t ∈ R, d. h. fhat Periode T . Dann ist die eindeutige Fourierdarstellung von f gegeben durch

f(t) =∑n∈Z

fneinωt (3.30)

mit ω = 2π/T . Die Koeffizienten fn lassen sich berechnen als

fn =1

T

∫ T

0f(t)e−inωt dt

35


und sind im Allgemeinen komplex, auch wenn f reellwertig ist. Die Beiträge f±n habendieselbe Frequenz ±n/T , unterscheiden sich aber in ihrer Phase. Die Leistung zu dieserFrequenz ist |fnf−n|.(3.30) lässt sich auch so lesen, dass

e−inωt = cos(nωt) + i sin(nωt) (3.31)

eine orthonormale Basis bezüglich des Skalarprodukts

(f, g) =1

T

∫ T

0f(t)g(t) dt (3.32)

bilden. Ähnlich wie ein Vektor im Rn wird die Funktion f also durch die Fouriertrans-formation in ihre Schwingungskomponenten zerlegt. Insbesondere sind die Fourierkoeffi-zienten linear in der Funktion, d. h.

(f + λg)n = fn + λgn. (3.33)

Die Voraussetzungen für die Konvergenz der Fourierreihe sind sehr schwach - solangedie Funktion wenigstens quadratintegrabel ist, konvergiert die Fourierreihe fast überall,d. h. ∥∥∥∥∥f(t)−

N∑n=−N

fneinωt

∥∥∥∥∥ N→∞−−−−→ 0. (3.34)

Daneben ist die Transformation f → f eine Isometrie, genauer gilt das Parsevaltheorem∑n∈Z|fn|2 =

1

ω

∫ T

0|f(t)|2 dt. (3.35)

Das Parsevaltheorem besagt auch, dass die Restbeiträge von großen n immer kleiner wer-den, so dass also eine abgeschnittene Fourierreihe eine Approximation an die gesuchteFunktion darstellt. Anders als abgeschnittene Taylorreihen, die nur in einer schmalenUmgebung um den Aufpunkt exakt sind, konvergiert die Fourierreihe gleichmäßig. Al-lerdings muss die abgeschnittene Fourierreihe im allgemeinen keinen einzigen Punkt mitder Zielfunktion gemeinsam haben, anders als Taylorreihen oder Splines.Weiter gilt:

• Die Fourierreihe über einem Intervall [0,T ) kann aus der Fourierreihe für das Inter-vall [0,2π) durch Streckung mit ω berechnet werden:

f(t)n =1

T

∫ T

0f(t)e−inωt dt =

1

2π

∫ 2π

0f(t′/ω)e−int

′dt′, (3.36)

• Es giltf(t+ t0)n = einωt0 f(t)n (3.37)

die Phase kann also nach Belieben verschoben werden. Die Leistung fnf−n bleibtdabei natürlich erhalten.

36

3.5 Fourierreihen

• Für die komplexe Konjugation gilt stets fn = fn, da die Fouriertransformation jalinear ist.

• Ist Funktion f symmetrisch, also f(t) = f(−t) = f(T − t), so ist f−n = fn, also fsymmetrisch.

• Ist Funktion f ungerade, also f(t) = −f(−t) = −f(T − t), so ist f−n = −fn, alsof ungerade.

• Ist Funktion f reellwertig, also f(t) = f(t), so ist f−n = fn. Allerdings sind dieFourierkoeffizienten im Allgemeinen komplex!

• Ist die komplexwertige Funktion f(t) = g(t) + ih(t) mit g, h reellwertig, gilt also

fn + fn = 2gn und fn − fn = 2ihn. (3.38)

Dies bedeutet, dass sich die Fourierreihen zweier reellwertiger Funktionen zusam-men berechnen und anschließend wieder trennen lassen. Da die Berechnung derFourierkoeffizienten sowieso komplex erfolgen muss, erspart dies bei numerischerAuswertung eine Transformation.

• Die Ableitung der Fourierreihe ist sehr einfach:

d

dtf(t) =

∑n∈Z

fninωeinωt =

∑n∈Z

(df

dt

)n

einωt =⇒(df

dt

)n

= inωfn. (3.39)

3.5.2 Reelle Fourierreihen

Da die Fourieranalyse besonders zur Analyse und Bearbeitung von Messdaten genutztwird, sind die Fourierreihen reellwertiger Funktionen besonders wichtig. Ist die Funktionf rellwertig, so ist

fneinωt + f−ne

−inωt = fneinωt + f−neinωt = 2Re(fne

inωt)

= 2Re(fn) cos(nωt)− 2Im(fn) sin(nωt). (3.40)

Daraus folgt, dass sich die Fourierreihe auch komplett reellwertig schreiben lässt:

f(t) =a0

2+

∞∑n=1

an cos(nωt) + bn sin(nωt) (3.41)

mit

an = 2Re(fn) =2

T

∫ T

0f(t) cos(nωt) dt (3.42)

37


0 1 2 3 4 5 61.5

1.0

0.5

0.0

0.5

1.0

1.5

0 1 2 3 4 5 60.5

0.0

0.5

1.0

1.5

2.0

2.5

3.0

3.5

Abbildung 3.4: Abgeschnittene Fourierreihen der Rechteckfunktion (links) und einesDreieckpulses (rechts). Die Funktionen sind jeweils als schwarze durchgezogene Linieneingezeichnet, die Näherungen mit einem Term blau gestrichelt, mit zwei Termen rotgepunktet, und mit 20 Termen grün durchgezogen. Für den Dreieckpuls ist letztere Nä-herung nicht mehr von der Funktion zu unterscheiden, während der Rechteckpuls nochdeutliche Artefakte an den Unstetigkeiten zeigt.

und

bn = −2Im(fn) =2

T

∫ T

0f(t) sin(nωt) dt. (3.43)

Für symmetrische Funktionen ist offenbar bn = 0, für ungerade Funktionen an = 0.Einige reelle Fourierreihen sind zum Beispiel:

• Konstante f(t) = f0:a0 = 2f0, an, bn = 0 sonst (3.44)

• Rechteckfunktion

f(t) =

1 für 0 ≤ t < T

2

−1 für T2 ≤ t < T

=4

π

∞∑n=1

1

2n− 1sin ((2n− 1)ωt) (3.45)

• kurzer Rechteckpuls. Wir betrachten nun die auf konstanten Flächeninhalt nor-mierte Funktion

fS(t) =

1/S für 0 ≤ t < S

0 für S ≤ t < T, (3.46)

38

3.5 Fourierreihen

deren Fourierreihe

fs(t) =1

T+

2

T

∞∑n=1

sin(nωS)

nωScos(nωt) +

1− cos(nωS)

nωSsin(nωt) (3.47)

ist. Je kleiner S wird und damit der Träger von fS , desto langsamer konvergiertihre Fourierreihe, da die Funktion sin(x)/x immer dichter an der Null ausgewertetwird. Für jede feste Frequenz n gilt schließlich

(fS)nS→0−−−→ 1

T= δn für alle n ∈ Z (3.48)

bzw. an → 2/T und bn → 0. Die δ-Funktion, die ja der formale Grenzwert derfS ist, und den kleinstmöglichen Träger hat, hat also in gewisser Weise die amschlechtesten (tatsächlich gar nicht!) konvergierende Fourierreihe.

• Dreiecksfunktion

f(t) =

t für 0 ≤ t < T

2

T − t für T2 ≤ t < T

=π

2− 4

π

∞∑n=1

1

(2n− 1)2cos ((2n− 1)ωt)

(3.49)

Genau wie die komplexe Fourierreihe lässt sich natürlich auch die reelle Fourierreiheabschneiden, um Näherungen für Funktionen zu bekommen, vergleiche Abbildung 3.4.Es fällt auf, das die Fourierreihe besonders schlecht dort konvergieren, wo die Funktionnicht differenzierbar ist bzw. einen Sprung aufweist.

3.5.3 Diskrete Fouriertransformation

Bei praktischen Anwendungen sind die Integrale zur Bestimmung der Koeffizienten oftnicht analytisch lösbar, oder die Funktion ist von vornherein nur an diskreten Punktengegeben, etwa weil es sich um Messdaten handelt. In diesem Fall müssen die Integralenumerisch approximiert werden. Wir betrachten nun also nicht mehr eine kontinuierlicheFunktion f , sondern Daten fk = f(tk) mit tk = k∆, k = 0(1)N − 1 und Schrittweite∆ = T

N . Dann ist

fn =1

T

∫ T

0f(t)e−inωt dt ≈ ∆

T

N−1∑k=0

f(k∆)e−inωk∆ =1

N

N−1∑k=0

fke−i 2π

Nnk =:

gnN. (3.50)

Die Koeffizienten

DFT(fk)n = gn =N−1∑k=0

fke−i 2π

Nnk (3.51)

werden als die diskrete Fouriertransformierte bezeichnet, die sehr effizient berechnet wer-den kann, wie wir im Folgenden sehen werden. Analog wird die inverse diskrete Fourier-transformation

iDFT(gn)k = f(tk) =N−1∑n=0

gnNei

2πNnk (3.52)

39


0 1 2 3 4 5 6

1.0

0.5

0.0

0.5

1.0

0 20 40 60 80 10010-5

10-4

10-3

10-2

10-1

Abbildung 3.5: Diskrete Fouriertransformation von 200 diskreten Datenpunkten, die zwi-schen 0 und 2π als sin(x) + 0,1 sin(10x) + ξ erzeugt wurden, wobei ξ eine Gauß-verteiltePseudozufallsvariable mit Varianz 0,01 war. Auch wenn es den Ausgangsdaten im linkenGraphen nicht mehr anzusehen ist, erlaubt die DFT, auch die kleine zusätzliche Schwin-gung gut vom Rauschen zu unterscheiden. Im Graphen rechts ist das Leistungsspektrum|DFT (k)|2 gezeigt. Man erkennt die Amplitudenquadrate 0,25 bei 1 und 0,01 bei 10,auch wenn letztere Frequenz durch das Rauschen etwas an Intensität verloren hat.

definiert, die aus den Koeffizienten wieder die Funktion f an den diskreten Eingangs-punkten tk berechnet. Abbildung 3.5 zeigt die DFT der Summe zweier verrauschterSinusfunktionen. Die Frequenzen und Amplituden der beiden Sinusfunktionen könnenin der Fouriertransformierten klar vom Rauschen unterschieden werden, während dieschwächere Frequenz in den eigentlichen Daten nicht mehr zu erkennen ist.Die Koeffizienten sind offenbar periodisch, da

gn+N =N−1∑k=0

fke−i 2π

N(n+N)k =

N−1∑k=0

fke−i 2π

Nnk e−2πik︸︷︷︸

=1

= gn. (3.53)

Insbesondere ist g−k = gN−k, und es gibt nur N echt verschiedene Koef-fizienten zu Frequenzen n/T . DFT-Bibliotheken speichern die Koeffizienten da-her meist als Vektor (g0, . . . ,gN−1). Für gerades N kann man dies wegen derPeriodizität auch als (g0, . . . ,gN/2−1,g−N/2, . . . ,g−1) lesen, für ungerades N als(g0, . . . ,g(N−1)/2,g−(N−1)/2, . . . ,g−1).Ist f reell, so gilt noch dazu g−n = gn, sodass lediglich dN/2e Koeffizienten wirklich

verschieden sind. Dabei ist offenbar g0 stets reell und für gerades N auch g−N/2 = gN/2 =g−N/2. Für ungerades N gibt es also (N −1)/2 komplexe und einen reellen Koeffizienten,g0, für gerades N sind es N/2−1 komplexe und zwei reelle Koeffizienten, nämlich g0 und

40

3.5 Fourierreihen

0 1 2 3 4 5 6

1.0

0.5

0.0

0.5

1.0

0 1 2 3 4 5 6 70.0

0.1

0.2

0.3

0.4

0.5

Abbildung 3.6: Diskrete Fouriertransformation von 14 äquidistanten diskreten Daten-punkten (rote Punkte links) der Funktion sin(13t) (rote Kurve links) im Interval [0 : 2π].Die Frequenz der Funktion 13/2π ist höher als die Nyquist-Frequenz fNyquist = 7/2π,daher kommt es zu Aliasing-Artefakten. Die rekonstruierte Kurve ist links schwarz ge-punktet eingezeichnet, ihr Spektrum rechts. Die abgetastete Funktion ist also scheinbarsin(t), was einer Frequenz von 2fNyquist − 13/2π entspricht.

g−N/2. Das kann durch jeweils genau N reelle Zahlen beschrieben werden, die Anzahl derFreiheitsgrade der Eingangsdaten bleibt also erhalten. Die Auswertung vereinfacht sichzu

iDFT(gn)k =

g0N +

(N−1)/2−1∑n=1

Re[gnN e

i 2πNnk]

für N ungerade

g0N +

N/2−1∑n=1

Re[gnN e

i 2πNnk]

+g−N/2N (−1)k für N gerade.

(3.54)

Die endliche Anzahl der diskreten Fourierkoeffizienten bedeutet, dass bei einem reellenSignal mit Schrittweite ∆ die maximal darstellbare Frequenz fNyquist = 1

2∆ beträgt, diesogenannte Nyquist-Frequenz . Signale mit höherer Frequenz f werden zu scheinbarenSignalen niedrigerer Frequenz

fscheinbar =

f mod 2fNyquist falls f mod 2fNyquist < fNyquist

2fNyquist − f mod 2fNyquist falls f mod 2fNyquist ≥ fNyquist,(3.55)

was auch als Aliasing bezeichnet wird. Diese Phänomen ist nicht spezifisch für die Fourier-transformation, da das Aliasing auch im Datenraum sichtbar wird, ähnlich einer Schwe-bung. Sollen analoge Signale digital weiter verarbeitet werden, kann es daher notwendig

41


sein, höhere Frequenzen durch analoge Tiefpassfilter zu unterdrücken, bevor diese di-gitalisiert werden. Abbildung 3.6 illustriert dieses Problem anhand einer sehr raschenSchwingung, die im scheinbar zu einer langsamen Schwingung wird.

3.5.4 Schnelle Fouriertransformation

Die Berechnung der Fouriertransformierten nach (3.51) ist zwar möglich, aber ziemlichlangsam — jeder der N Koeffizienten benötigt offenbar O(N) Operationen, so dass dieDFT insgesamt O(N2) Operationen braucht. Das limitiert für praktische AnwendungenN auf einige tausend, was für viele Anwendungen zu wenig ist. Die DFT konnte dahernur durch die schnelle Fouriertransformation (FFT) von Cooley und Tukey zu breiterAnwendung finden. Diese basiert auf der Beobachtung, dass für N = 2M

DFT(fk)n =

M−1∑k=0

f2ke−i 2π

2Mn 2k +

M−1∑k=0

f2k+1e−i 2π

2Mn (2k+1) (3.56)

= DFT(f2k)n + e−iπMnDFT(f2k+1)n, (3.57)

wobei DFT(f2k)n den n-ten Koeffizienten einer DFT auf den Datenpunkten f2k, k =0(1)M − 1, bezeichnet. Gemäß (3.53) ist dabei DFT(f2k)n = DFT(f2k)n−M für n > M .Die Fouriertransformierte der N Datenpunkte ergibt sich also als einfache Summe von

zwei Fouriertransformierten mit lediglich der halben Menge M an Datenpunkten, wobeidie ungerade Hälfte mit der Einheitswurzel

wn := e−i2π2M

n (3.58)

multipliziert wird. Ist nun M wieder durch zwei teilbar, so lassen sich diese Fouriertrans-formierten ebenfalls als Summe zweier nochmals halb so langer Fouriertransformationendarstellen. Wenn nunN eine Zweierpotenz ist, kann man so fortfahren, bisM = 1 erreichtist, also DFT(f0)0 = f0. Dabei gibt es offenbar log2(N) viele Unterteilungsschritte, diejeder O(N) Operationen kosten. Insgesamt benötigt die FFT also lediglich O(N logN)Operationen.Schematisch funktioniert ein FFT-Schritt wie folgt:

f(0)

f(∆)

f(2∆)

f(3∆)

HalbeFFT

HalbeFFT

g0

g1

g2

g3

·1

·w0

·1

·w1

·1·w2

·1·w3

Aufgrund ihres Aussehens wird dieses Datenpfadschema auch als Butterfly-Schema ge-nannt. Damit die beiden Unter-FFTs auf einem zusammenhängenden Satz von Daten

42

3.6 Wavelets

operieren können, müssen also auch die Eingabedaten fk umsortiert werden, ebenso wieauch für die Unter-FFTs. Man kann sich leicht überlegen, dass dabei fk auf fk′ sortiertwird, wobei die Bits k′ in Binärdarstellung dieselben wie von k sind, nur in umgedrehterReihenfolge.Die FFT erlaubt also die effiziente Zerlegung einer Funktion in ihre Schwingungs-

komponenten, was viele wichtige Anwendungen nicht nur in der Physik hat. Daher gibtes eine Reihe sehr guter Implementierungen der FFT, allen voran die „Fastest FourierTransform in the West“ (FFTW, http://www.fftw.org). Selbstverständlich bietetauch NumPy eine FFT, numpy.fft.fft(f_k), mit der inversen FFT numpy.fft.ifft(g_n). Die Routinen sind so implementiert, dass bis auf MaschinengenauigkeitiFFT(FFT(fk)) = fk.Wichtige Anwendungsbeispiele der diskreten Fouriertransformation sind zum Beispiel

die Datenformate JPEG, MPEG und MP3, die alle drei auf einer Abwandlung der DFTberuhen, der diskreten Cosinustransformation (DCT) für reelle Daten. Bei dieser wird derDatensatz in der Zeitdomäne so verdoppelt, dass er eine gerade Funktion repräsentiert.Dadurch wird die Fourierreihe eine reine Cosinusreihe mit nur reellen Koeffizienten. DieDCT ist also eine Umwandlung reeller in reelle Zahlen. Wegen Ihrer Wichtigkeit gibt esnicht nur extrem effiziente Implementierungen für die meisten Prozessortypen, sondernauch spezielle Hardware.

3.6 Wavelets

Die Fouriertransformation wird vor allem deshalb für die Kompression von Audio- oderBilddaten genutzt, weil sie hochfrequente von niederfrequenten Signalen trennt und diemenschlichen Sinne die hochfrequenten Anteil meist nicht gut wahrnehmen können. Dasist allerdings nicht ganz korrekt, tatsächlich können wir nur stark lokale Änderungen nichtgut wahrnehmen. Dafür sind Fourierreihen an sich gar nicht so gut geeignet, da ja auchdie hochfrequenten Schwingungen alles andere als lokal sind. Als Alternative hat sichdie Multiskalenanalyse (MSA) oder diskrete Wavelettransformation etabliert, die auchim transformierten Raum lokal ist.Anders als bei der Fouriertransformation, die eine Zerlegung in trigonometrische Funk-

tionen darstellt, gibt es für die MSA verschiedene Sätze von Basisfunktionen mit verschie-denen Eigenschaften wie Differenzierbarkeit und Lokalität. Im Folgenden soll die MSAmit Hilfe des Haar-Wavelets dargestellt werden, dass das einfachste und älteste bekannteWavelet ist. Zunächst betrachten wir die Skalierungsfunktion

φ(x) = χ(0,1] =

1 für 0 < x ≤ 1

0 sonst(3.59)

sowie das Haar-Wavelet

ψ(x) =

−1 für 0 < x ≤ 1

2

1 für 12 < x ≤ 1

0 sonst,(3.60)

43

http://www.fftw.org


0 1 2 3 4 5 61.0

0.5

0.0

0.5

1.0

0 1 2 3 4 5 61.0

0.5

0.0

0.5

1.0

0 1 2 3 4 5 61.0

0.5

0.0

0.5

1.0

0 1 2 3 4 5 61.0

0.5

0.0

0.5

1.0

Abbildung 3.7: Diskrete Wavelettransformation von 200 diskreten Datenpunkten, dieanalog zu Abbildung 3.5 zwischen 0 und 2π als sin(x) + 0,1 sin(10x) + ξ erzeugt wurden.Für die Transformation wurden die Wavelets von (0,1] auf den Bereich (0,2π] gestreckt.Der linke obere Graph zeigt nochmals das Ausgangssignal, von rechts oben nach rechtsunten folgen die Anteile der Stufen 0–3, also (f,φ0)φ0 +

∑3j=0

∑2j−1k=0 (f,ψjk)ψjk, dann

Stufen 4 und 5 (∑5

j=4

∑2j−1k=0 (f,ψjk)ψjk) und schließlich Stufen 6–8, womit die Auflösung

der Ausgangsdaten erreicht ist.

aus denen wir die Basisfunktionen φk(x) := φ(x − k) der nullten Stufe und ψjk(x) :=2j/2ψ(2jx − k) der j-ten Stufe konstruieren. Durch die Skalierung mit 2j werden dieψj,k also immer schmaler, sind aber wegen des Vorfaktors alle normiert, d. h. ‖ψjk‖ = 1.Ebenso sind auch die φk normiert. Zusätzlich sind sämtliche Basisfunktionen zu einanderorthogonal, wie man sich leicht überlegt. Daher lässt sich jede quadratintegrable Funktionf wie folgt zerlegen:

f(x) =∑k∈Z

(f,φk)φk +∑j∈N0

∑k∈Z

(f,ψjk)ψjk (3.61)

Dies ist die Multiskalenanalyse von f . Die Koeffizienten der Stufe j werden auch De-tails der Stufe j genannt. In der Praxis ist das Signal durch endlich viele äquidistanteDatenpunkte gegeben, analog zur diskreten Fouriertransformation. In diesem Fall sinddie Summen endlich, da einerseits der Träger endlich ist und damit nur endlich viele(f,φk) 6= 0, und es andererseits keine Details unterhalb der Auflösung des Signals gibt.Man skaliert dann die Wavelets und Skalierungsfunktion so, dass der Abstand der Daten-punkte gerade der halben Breite des Wavelets auf der feinsten Auflösung entspricht, undφ = φ0 bereits das gesamte Interval überdeckt. Für eine nur auf [0,1] nichtverschwinden-de Funktion, deren Werte an 2N Punkten äquidistanten Punkten bekannt ist, reduziert

44

3.6 Wavelets

sich die Multiskalenanalyse zur diskreten Wavelettransformation

f(x) = (f,φ)φ+N−1∑j=0

2j−1∑k=0

(f,ψjk)ψjk. (3.62)

Die Anzahl der Koeffizienten ist dann 1 + 1 + 2 + · · ·+ 2N−1 = 2N , also genau die Anzahlder Eingabedaten. Genau wie die diskrete Fouriertransformation bildet die Wavelettrans-formation 2N Werte f(k/2N ) auf 2N Werte (f,φ) und (f,ψjk) ab und besitzt eine exakteRücktransformation, (3.62).Analog zur schnellen Fouriertransformation gibt es auch eine schnelle Wavelettrans-

formation (FWT), die sogar linearen Aufwand hat, also O(N) Schritte bei N Daten-punkten benötigt. Eine einfache Implementation der FWT und der inversen FWT fürdas Haar-Wavelet zeigt Codebeispiel 3.1. Der Kern dieser Transformation liegt darin,die Transformierte von der höchsten Detailauflösung herab aufzubauen, und dadurch diedie Integrale approximierenden Summen schrittweise aufzubauen (Downsampling). Fürgenauere Informationen siehe zum Beispiel Daubechies [Dau92].Abbildung 3.7 zeigt einige Detailstufen der Wavelet-Zerlegung der verrauschten Si-

nusfunktionen analog Abbildung 3.5. Auch hier lässt sich das Rauschen auf den höhe-ren Detailstufen gut vom Nutzsignal trennen, allerdings kann die Oberschwingung nichtdetektiert werden. Das hängt allerdings vor allem daran, dass das Haar-Wavelet nichtsehr geeignet ist, da es nicht glatt ist, im Gegensatz zum Nutzsignal. Daher sind inden meisten Fällen glatte Wavelets besser geeignet. Das bekannteste Beispiel von glat-ten Wavelets sind die Daubechies-Wavelets, die daneben auch einen kompakten Trägerhaben, also stark lokalisiert sind. Mit solchen Wavelets lassen sich sogar reale Musikda-ten in Akkorde zurücktransformieren. Auch der JPEG-Nachfolger JPEG2000 basiert aufeiner Wavelettransformation statt einer Cosinustransformation, allerdings mit Cohen-Daubechies-Feauveau-Wavelets.

45


# Haar-Wavelet-Transformation#############################from scipy import *

def haar_trafo(data):"Diskrete Wavelettransformation mit Hilfe des Haar−Wavelets."# Daten mit kleinstem Integrationsschritt multiplizierenc = data.copy() / len(data)# Temporaerer Puffer, um benoetigte Werte nicht zu ueberschreibenctmp = zeros(c.shape)width = len(c)/2while width >= 1:

for n in range(width):tmp1 = c[2*n]tmp2 = c[2*n+1]# Detailctmp[width + n] = tmp1 - tmp2# Downsamplingctmp[n] = tmp1 + tmp2

# Puffer zurueckschreibenc[:2*width] = ctmp[:2*width]width = width / 2

return c

def inverse_haar_trafo(c):"Inverse Diskrete Wavelettransformation mit Hilfe des Haar−Wavelets"# Rueckgabewertedata = zeros(len(c))# phi mitnehmen auf der niedrigsten Stufedata[0] = c[0]width = 1cstart = 1while width <= len(c)/2:

for n in range(width-1, -1, -1):tmp = data[n]data[2*n] = tmp + width*c[cstart + n]data[2*n + 1] = tmp - width*c[cstart + n]

cstart += widthwidth = width * 2

return data

# Anwendungsbeispiel

x = linspace(0,1,256)y = cos(x)coeff = haar_trafo(y)yrueck = inverse_haar_trafo(coeff)print max(abs(yrueck - y))

Listing 3.1: Diskrete Wavelettransformation und ihre Inverse als Python-Code. Die Län-ge der Eingabedaten muss eine Zweierpotenz 2N sein. Die Details sind in einem Vek-tor c gespeichert, in der Form c = ((f,φ0), (f, ψ00), (f, ψ10), (f, ψ11), (f, ψ20), (f, ψ21),(f, ψ22), . . . , (f, ψN−1,2N−1−1)).

46

4 Datenanalyse und Signalverarbeitung

In diesem Kapitel geht es darum, was man mit einem gemessenen Signal machen kannund muss. Ein gemessenes Signal kann dabei entweder tatsächlich von einem Messgerätkommen oder aber das Ergebnis einer Computersimulation sein. Zwei Fragen sind dabeivor allem wichtig: Welche Eigenschaften hat das Signal, und wie vertrauenswürdig sinddie Werte?Um die Eigenschaften von Signalen zu untersuchen, ist die kontinuierliche Fourierana-

lyse ein gutes Werkzeug, die das Signal vom Zeit- in den Frequenzraum überträgt. Solassen sich zum Bespiel charakteristische Frequenzen und damit Zeitskalen bestimmen.Außerdem bietet der Übergang in den Frequenzraum analytisch viele Vorteile, die sichauch auf dem Computer nutzen lassen. So werden zum Beispiel langreichweitige Wech-selwirkungen in Molekulardynamiksimulationen meist im Frequenzraum berechnet.Als weiteres Werkzeug werden wir Faltungen kennen lernen, die erlauben, Signale nach

bestimmten Frequenzen zu filtern oder aber aus der (gemessenen) Antwort eines linearenSystems auf ein einfaches Eingangssignal die Antwort auf beliebige Signale zu berechnen.Sollen Signale mit dem Computer weiterverarbeitet werden, müssen diese digitalisiert

werden, also in eine Reihe von Zahlen übersetzt. Üblicherweise passiert dies dadurch,dass das Signal nur zu äquidistanten Zeitpunkten ausgewertet, abgetastet wird. Das wirftdie Frage auf, welche Funktionen dadurch überhaupt gut gemessen werden können. Wiewir sehen werden, beschränkt diese Abtastung die Frequenzen, die von einer digitalenAuswertung erfasst werden können.Die meisten Signale sind außerdem, durch Messungenauigkeiten und prinzipielle sto-

chastische Prozesse, selbst stochastisch, d. h. die Verteilung der Ergebnisse vieler Mes-sungen ist vorherbestimmbar, die einzelne Messung hingegen nicht. Trotzdem sind Mes-sungen oft korreliert, zum Beispiel weil eine Observable sich nur kontinuierlich ändert.Durch Korrelationsanalysen lässt sich bestimmen, wann Messungen wirklich unabhängigsind. Dies gibt wiederum Aufschluss über die Zeitskalen wichtiger Prozesse im System,ist aber auch wichtig für eine korrekte Abschätzung des Messfehlers, womit sich der letzteAbschnitt beschäftigt.

4.1 Kontinuierliche Fouriertransformation

Für die Analyse zeitlich veränderlicher Signale besonders nützlich ist die Fouriertrans-formation, die ein kontinuierliches Signal in den Frequenzraum übersetzt. Dies gilt nichtnur für periodische Signale, sondern zum Beispiel auch dann, wenn die Antwort einesSystems auf ein komplexes Eingangssignal gefragt ist. Der tiefere Grund dafür ist, dassdie Fouriertransformation Differential- und Integraloperatoren in einfache algebraischeOperationen übersetzt.

47


Betrachten wir nochmals die Fourierreihe im Interval [−T/2,T/2)

f(t) =∑n∈Z

(∆ω

2π

∫ T/2

−T/2f(t)e−in∆ωt dt

)ein∆ωt

=1√2π

∑n∈Z

(1√2π

∫ T/2

−T/2f(t)e−iωt dt

)eiωt ∆ω (4.1)

mit der Grundfrequenz ∆ω = 2π/T und ω = n∆ω. Im Grenzwert T →∞ ergibt sich

f(t) =1√2π

∫ ∞−∞F(f)(ω)eiωt dω (4.2)

mit

F(f)(ω) =1√2π

∫ ∞−∞

f(t)e−iωt dt. (4.3)

Die kontinuierliche Fouriertransformation F ist das Analogon der periodischen Fourier-reihe, ist allerdings keine Transformation in eine Reihe mehr, sondern eine Abbildungzwischen Funktionen. Für F gelten eine Menge sehr starker Aussagen, die wir zum großenTeil in ähnlicher Art schon von der Fourierreihe kennen:

• F(f) existiert, falls f quadratintegrabel ist, und bildet f auf eine quadratinte-grable Funktion ab. Für solche Funktionen mit der zugehörigen Norm ‖f‖2 =∫∞−∞|f(t)|2 dt gilt dann sogar die Isometrie (Parsevaltheorem):

‖F(f)‖2 = ‖f‖2 (4.4)

• F ist linear, d. h. F(f + λg) = Ff + λFg.

• F ist reziprok gegen Streckungen, d. h.

F [f(αt)](ω) =1

|α|F(f)

(ωα

). (4.5)

Wird also eine Funktion α immer stärker gestaucht, so wird ihre Transformier-te immer weiter gestreckt. Entsprechend wird aus Zeitumkehr Frequenzumkehr:F(f(−t))(ω) = F(f)(−ω).

• F ist invertierbar, die Umkehrfunktion F−1 ist durch (4.2) explizit gegeben. Of-fenbar ist auch die Umkehrung eine Isometrie, es gilt ‖F−1(f)‖2 = ‖f‖2.

• Weiter gilt F(F(f(t))) = f(−t), und damit F4(f) = f . Insbesondere ist auchF−1 = F3. Die Fouriertransformation ist damit eine vierte Einheitswurzel auf demRaum der quadratintegrablen Funktionen, ähnlich wie i bei den komplexen Zahlen.

48


• Eine zeitliche Verschiebung wird zu einer Frequenzmodulation und umgekehrt:

F(f(t− t0))(ω) = e−iωt0F(f(t))(ω) (4.6)F(eiω0tf(t))(ω) = F(f(t))(ω − ω0). (4.7)

Wird also ein niederfrequentes Signal (Radioprogramm) auf ein hochfrequentesTrägersignal aufmoduliert, verschiebt sich nur dessen Spektrum.

• Aus der Linearität folgt, dass stets gilt: F(f)(ω) = F(f)(ω).

• Ist Funktion f gerade (symmetrisch), also f(t) = f(−t), so ist F(f)(−ω) =F(f)(ω), also gerade (symmetrisch).

• Ist Funktion f ungerade (antisymmetrisch), also f(t) = −f(−t), so ist F(f)(−ω) =−F(f)(ω), ungerade (antisymmetrisch).

• Ist Funktion f reellwertig, also f(t) = f(t), so ist F(f)(−ω) = F(f)(ω), aber imallgemeinen komplexwertig!

• Für die Fouriertransformierte der Ableitung gilt

F(d

dtf(t)

)(ω) =

1√2π

∫ ∞−∞

[df

dt(t)

]e−iωt dt

=part. Int.−

1√2π

∫ ∞−∞

f(t)d

dte−iωt dt = iωF(f(t))(ω).

(4.8)

Dies spielt eine wichtige Rolle beim Lösen von Differenzialgleichungen, weil diesein gewöhnliche algebraische Gleichungen übergehen.

• Es gilt die Poissonsche Summenformel∑k∈Z

f(t0 + k δ) =

√2π

|δ|∑n∈ZF(f)

(2πn

δ

)exp

(i2πn

δt0

). (4.9)

Diese Gleichung beruht darauf, dass∑

t∈Z f(·+ t δ) eine δ-periodische Funktion ist,die durch eine Fourierreihe dargestellt werden kann. Wegen (4.6) reicht es dabeio.B.d.A. δ = 1 zu betrachten:∑

k∈Zf(t0 + k) =

∑n∈Z

∫ 1

0

∑k∈Z

f(τ + k)e−2πinτ dτ e2πint0 =

∑n∈Z

∫ ∞−∞

f(τ)e−2πinτ dτ e2πint0 =√

2π∑n∈ZF(f)(2πn) e2πint0 . (4.10)

Eine wichtige Anwendung der Poissonschen Summenformel ist die Summationschlecht konvergenter Reihen. Fällt die Funktion f sehr langsam gegen unendlichab, so fällt ihre Fouriertransformierte wegen der Reziprozität (4.5) im Allgemeinenschneller, so das aus einer langsam eine rasch konvergierende Reihe wird.

49


8 6 4 2 0 2 4 6 8t

0.0

0.1

0.2

0.3

0.4

0.5

6 4 2 0 2 4 6ω

0.4

0.2

0.0

0.2

0.4

Abbildung 4.1: Numerische kontinuierliche Fouriertransformation am Beispiel einerGaußglocke g(t) = e−t

2/2, die wie links gezeigt äquidistant an den Stützstellen tk =−8+k/2, k = 0(1)31 diskretisiert wird. Werden die gewonnenen Daten g(tk) diskret fou-riertransformiert, ergibt sich als Transformierte eine Gaußglocke mit wechselnden Vorzei-chen, wie rechts mit roten Rauten gezeigt. Nur mit dem notwendigen Phasenshiftfaktore−2πi8/16 = −1 erhält man die erwartete Gaußglocke (blaue Kreise).

Als Beispiel betrachten wir die Fouriertransformierte einer Gaußglocke:

F(

1√2πe−t

2/2

)=

1

2πe−ω

2/2

∫ ∞−∞

e−(t−iω)2/2 dt =1√2πe−ω

2/2. (4.11)

Die Gaussglocke ist also eine Eigenfunktion der Fouriertransformation zum Eigenwert 1.Die Fouriertransformation hat tatsächlich sehr viel mehr echt verschiedene Eigenfunktio-nen, die Familie der Hermitefunktionen [Pin02]. Wegen F4 = 1 kann die Fouriertrans-formation nur die vier Eigenwerte ±1 und ±i haben. Jeder dieser Eigenwerte ist starkdegeneriert, also der Eigenraum zu jedem Eigenwert unendlichdimensional.Die (formale) Fouriertransformierte der δ-Funktion ist

F(δ(t))(ω) =1√2π

∫ ∞−∞

δ(t)e−iωt dt =1√2π, (4.12)

also einfach die konstante Funktion 1/√

2π, die ebensowenig wie die δ-Funktion einequadratintegrable Funktion ist. Alternativ lässt sich die Beziehung aus der Fouriertrans-formierten der Gaußglocke mit sinkender Varianz herleiten.

4.1.1 Numerische kontinuierliche Fouriertransformation

Um die Eigenschaften der kontinuierlichen Fouriertransformation numerisch zu nutzen,machen wir den Grenzübergang T → ∞ rückgängig und ziehen uns auf ein für die

50


betrachtetete Funktion hinreichend großes T zurück, so dass∫|t|>T |f(t)|2 dt hinreichend

klein ist. Das geht insbesondere, wenn das Signal endlichen Träger hat, wie das bei echtengemessenen Signalen stets der Fall ist.Wir betrachten nun als Signal eine Funktion f , die wir nur an auf einem äquidistanten

Gitter tk = t0 + k TN , k = 0(1)N − 1 kennen, also im Intervall [t0, t0 + T ). Dann setzenwir ω0 := 2π

T und ∆ := TN , und erhalten für ganzzahliges n

F(f)(ω0n) ≈ 1√2π

∫ t0+T

t0

f(t)e−inω0t dt ≈ 1√2π

N−1∑k=0

∆f(tk)e−inω0(t0+k∆)

= ∆e−inω0t0√

2π

N−1∑k=0

f(tk)e−2πink/N =

T

N

(e−iω0t0

)n√

2πDFT(f(tk))n , (4.13)

wobei DFT die diskrete Fouriertransformation aus (3.51) bezeichnet. Meist werden Mes-sungen bei t = 0 begonnen, die Funktion ist dann nur im positiven Halbinterval von Nullverschieden. In diesem Fall wählt man natürlicherweise t0 = 0, so dass der Phasenfak-tor e−iω0t0 = 1 entfällt. Wir werden allerdings später noch Faltungen kennenlernen, beidenen es häufig natürlicher ist, eine symmetrische Lage der Filterfunktion um die Nullanzunehmen. In diesem Fall wählt man t0 = −T/2, so dass e−iω0t0 = −1.Um die Rolle des Phasenfaktors zu illustrieren, betrachten wir eine Gaußglocke, die

wir an um die Null symmetrisch liegenden Stützstellen diskretisieren. Wie wir gesehenhatten, ist die Fouriertransformierte der Gaußglocke die Gaußglocke selber. Abbildung 4.1zeigt, das wir diese Transformierte nur mit dem Phasenfaktor erhalten. Da dieser gerade(−1)n beträgt, wechselt die Transformierte sonst andauernd das Vorzeichen. Insbesonderewürde mit steigender Anzahl Stützstellen das Vorzeichen immer rascher wechseln, dieTransformierte also nicht einmal konvergieren.

Die Koeffizienten der DFT sind periodisch, daher auch diese Näherung für F(f). Tat-sächlich sollten die Koeffizienten aber nur als Frequenzen im Interval [−ω0N/2,ω0N/2]interpretiert werden, alle Frequenzen außerhalb dieses Intervals sollten als Null angesehenwerden. Der Grund dafür ist das Abtasttheorem, dass im folgenden Abschnitt bespro-chen wird. Dieses besagt, dass bei einem Zeitschritt ∆ = T/N nur Kreisfrequenzen bisω0N/2 = π/∆ eindeutig gemessen werden können. Daher ist die Beschränkung auf dasinnerste Intervall die natürliche Interpretation. Bei rein reellen Signalen sollte man da-her die reellen Varianten der FFT-Implementationen benutzen, die nur die relevantenpositiven Koeffizienten bis N/2 zurückgeben.

Die Einschränkung der Frequenzen ist besonders wichtig, wenn N ungerade ist und dieum Null symmetrische Lage von −T/2 bis T/2 gewählt wird. Dann ist

(e−iω0t0

)N−n=

(−1)N−n = −(−1)−n = −(e−iω0t0

)−n. Mit anderen Worten, wird einfach die gesamtediskrete Fouriertransformierte mit (−1)n multipliziert, so bekommen die negativen Fre-quenzen das falsche Vorzeichen. Das hat drastische Konsequenzen: wenn die Ursprungs-funktion reell ist, gilt DFT (fk)−n = DFT (fk)n, für die genäherte kontinuierliche Fou-riertransformierte also F(f)(−ω) = −F(f)(ω). Das entspricht der Tranformierten einerrein imaginären Funktion!

51


Analog wie die Fouriertransformation selber lässt sich auch ihre Rücktransformationnähern:

F−1(f)(tk) ≈ iDFT(√

2πN

T

(eiω0t0

)nfn

)k

(4.14)

Der Faktor(eiω0t0

)n invertiert genau den Faktor(e−iω0t0

)n der Vorwärtstransformation.Für t0 = 0 ist er wieder 1 und muss nicht berücksichtigt werden, bei t0 = −T/2 ist er(−1)n.Die bekannten schnellen FFT-Routinen lassen sich also auch für die numerische Be-

arbeitung der kontinuierlichen Fouriertransformation nutzen. Auf diese Weise ist z. B.Abbildung 4.2 entstanden.

4.1.2 Abtasttheorem

In der Praxis sind Signale meist als diskrete Werte an (endlich vielen) äquidistantenStellen beziehungsweise Zeitpunkten gegeben, zum Beispiel, weil ein Messgerät Daten inregelmäßigen Abständen liefert. Eine wichtige Frage ist, wie gut man das reale Signalund sein Frequenzspektrum aus den diskreten Datenpunkten rekonstruieren kann.Hierzu betrachten wir zunächst ein bandbreitenbeschränktes Signal f , d. h. ein Signal,

dessen Fouriertransformierte einen kompakten Träger [−ωmax,ωmax] hat. Dann besagtdie Poissonsche Summenformel (4.9), dass für ω ∈ [−ωmax,ωmax]

F(f)(ω) =∑k∈ZF(e−iω·f) (2kωmax) =

1√2π

∑n∈Z

e−iωn∆f (n∆) (4.15)

mit ∆ = π/ωmax. Die Fouriertransformierte eines bandbreitenbeschränkten Signals lässtsich also exakt nur aus den Funktionswerten an den äquidistanten diskreten Stellen mitAbtastrate ∆ berechnen. Dadurch kann natürlich auch die Funktion exakt aus ihrerFouriertransformierten rekonstruiert werden:

f(t) =∆

2π

∑n∈Z

f (n∆)

∫ ωmax

−ωmax

e−iω(t−n∆) dω =∆

π

∑n∈Z

f (n∆)sin(ωmax(t− n∆))

t− n∆. (4.16)

Ist nun umgekehrt ein Signal f an äquidistanten diskreten Stellen n∆ gegeben, solässt sich diesem gemäß (4.16) ein kontinuierliches Signal zuordnen, dessen Fouriertrans-formierte nur in [−ωmax,ωmax] nicht verschwindet, wobei ωmax = π/∆. Das bedeutet,dass bei Abtastrate ∆ nur Frequenzen bis zur Nyquist-Frequenz fNyquist = 1

2∆ = ωmax2π

eindeutig abgetastet werden können, ähnlich wie im periodischen Fall.

4.2 Faltungen

Die Faltung der quadratintegrablen Funktionen f und g ist definiert als

(f ? g)(t) :=

∫ ∞−∞

f(t′)g(t− t′) dt′. (4.17)

52

4.2 Faltungen

Das negative Vorzeichen von t′ in der zweiten Funktion sorgt dafür, dass die Faltungkommutativ ist. Weitere Eigenschaften der Faltung sind Linearität in den Komponentenund sogar Assoziativität. Die Faltung verhält sich also so ähnlich wie die klassische Mul-tiplikation und wird daher mit dem Zeichen ? bezeichnet. Vereinfacht gesagt, deponiertdie Faltung an jedem Punkt t die Funktion f , skaliert mit g(· − t). Daher ist z. B.

(δ(· − t0) ? g)(t) = g(t− t0). (4.18)

Wird nun statt der unendlich dünnen δ-Funktion zum Beispiel eine Gaußglocke gewählt,so wird die Funktion g verschmiert bzw. geglättet, siehe Abbildung 4.2.

Die Fouriertransformierte der Faltung zweier Funktionen ist

F(f ? g)(ω) =1√2π

∫ ∞−∞

∫ ∞−∞

f(t′)g(t− t′) dt′e−iωt dt

=1√2π

∫ ∞−∞

∫ ∞−∞

f(t′)g(t)e−iω(t+t′) dt dt′

=1√2π

∫ ∞−∞

f(t′)e−iωt′dt′∫ ∞−∞

g(t)e−iωt dt =√

2πF(f)(ω)F(g)(ω).

(4.19)

Die Faltung geht also in eine punktweise Multiplikation über. Im Fourierraum lässt sichalso sehr viel schneller falten, als im Realraum, wo ja für jeden Punkt ein Integral zulösen ist.

Außerdem zeigt (4.19), dass die Faltung der Funktion f mit der Funktion g auch als Fil-tern von f verstanden werden kann: sind g und damit F(g) reellwertig und symmetrisch,so werden die einzelnen Frequenzkomponenten der Funktion f mit den Frequenzantei-len von g gestreckt bzw. gestaucht. Man beachte, dass f für die Definition (4.19) nichtquadratintegrabel sein muss, sofern der Filter g schnell genug abfällt. Insbesondere kanng eine nur beschränkte, aber nicht abklingende Funktion sein, wie etwa ein periodischesMesssignal.

Durch Wahl einer symmetrischen und reellwertigen Fouriertransformierten und Rück-transformation lassen sich beliebige Frequenzfilter realisieren. Abbildung 4.2 illustrierteinen (gaußschen) Tiefpassfilter und einen Bandfilter, die nur bestimmte Frequenzen pas-sieren lassen. Daher wird beim Tiefpassfilter die aufgeprägte hochfrequente Schwingungunterdrückt, beim Hochpassfilter hingegen die an sich dominante langsame Schwingung.

In der Praxis wird natürlich direkt im Fourierraum gefiltert, mit Hilfe einer numeri-schen diskreten Fouriertransformation gemäß (4.13). Seien dazu zwei Sätze mit N Da-tenpunkten fk = f(tk) mit tk = t0 + k TN und gk = g(t′k) mit t′k = t′0 + k TN gegeben.Mit anderen Worten, die beiden Funktionen müssen mit der selben Frequenz abgetastetworden sein, der Anfangszeitpunkt kann aber verschieden sein. Das ist etwa beim Glättenwichtig, bei dem die Filterfunktion meist symmetrisch um die Null definiert ist, die zu

53


3 2 1 0 1 2 3

1.0

0.5

0.0

0.5

1.0

0 2 4 6 8 100.0

0.5

1.0

1.5

2.0

3 2 1 0 1 2 3

1.0

0.5

0.0

0.5

1.0

0 2 4 6 8 101.0

0.5

0.0

0.5

1.0

Abbildung 4.2: Oben links: Summe zweier Schwingungen cos(x)+0,25 sin(7,5x) (schwarzeLinie), die mit einer Gaußglocke (blau gestrichelt) gefaltet wird. Das Ergebnis (rotegepunktete Linie) ist die quasi ungestörte langsame Schwingung ohne die höherfrequenteSchwingung, die weggeglättet wurde. Oben rechts: Fouriertransformierte der Funktionen.Klar sichtbar ist die hochfrequente Störung mit einer Frequenz von 7,5, die im gefiltertenSignal fehlt. In der unteren Reihe wurde eine frequenzverschobene Gaußglocke benutzt,um statt der langsamen die schnelle Schwingung zu filtern; die Farbcodierung ist wieoben. Gemäß (4.7) bewirkt die Frequenzverschiebung eine Modulation der Gaußfunktion.

54

4.3 Kreuz- und Autokorrelation

glättende Funktion aber beliebig liegen kann. Es gilt

(f ? g)(tk) =√

2πF−1 (F(f)(ω)F(g)(ω)) (tk)

≈ iDFT(

2πN

T

(eiω0t0

)n [ T 2

2πN2

(e−iω0t0

)nDFT(fk)n

(e−iω0t′0

)nDFT(gk)n

])k

=T

NiDFT

[(e−iω0t′0

)nDFT (fk)nDFT (gk)n

]k. (4.20)

Wie im Abschnitt 4.1.1 besprochen, muss n als Frequenz im Bereich −N/2 bis N/2interpretiert werden. Man beachte, dass der Faktor

(e−iω0t′0

)nnur durch den Aufpunkt

t′0 der Abtastung der Funktion g bestimmt ist, da wir an den Stellen tk auswerten.Dadurch ist die Funktion g die Filterfunktion, die auf f angewendet wird. Ist g wie üblichsymmetrisch um Null abgetastet, so ist

(e−iω0t′0

)n= (−1)n. Vergisst man diesen Term,

entspricht das einem impliziten Verschieben der Filterfunktion zur Null hin. Die Lage t0der Abtastung der Funktion f kann hingegen beliebig verschoben sein. Die Faltung wirdin jedem Fall natürlich nur im Abtastbereich der Funktion f berechnet.

4.2.1 Antwort zeitinvarianter linearer Systeme

Eine weitere wichtige Anwendung der Faltung ist die Bestimmung der Antwort eineszeitinvarianten linearen Systems auf ein beliebiges Eingangssignal. Einfach zu messenist typischerweise die Antwort Aθ(t) des Systems auf einen Einschaltvorgang, also einEingangssignal der Form

θ(t) =

0 für t < 0

1 für t ≥ 0.(4.21)

Um daraus die Antwort auf ein beliebiges Eingangssignal zu bestimmen, schreiben wir dasEingangssignal f als f = f ?δ. Wegen der Linearität der Faltung und der Systemantwortist die Antwort auf das Signal f gegeben durch die Faltung Af (t) = f ? Aδ mit derAntwort auf einen δ-Impuls. Diese Antwort wiederum lässt sich aus der Sprungantwortdurch einfach Ableitung erhalten, was mit Hilfe der Fouriertransformierten sehr bequemzu berechnen ist:

Af (t) = f ? Aδ = f ?d

dtAθ =

√2πF−1

(iωF(f)F(Aθ)

). (4.22)


Bis jetzt haben wir uns mit der Verarbeitung idealer Signale beschäftigt, die zu einemgegebenen Zeitpunkt einen prinzipiell eindeutig vorherbestimmten Wert haben. RealeSignale sind aber oft verrauscht, entweder durch Messungenauigkeiten, Bauteiltoleran-zen oder prinzipielle stochastische Prozesse. Trotzdem möchte man oft wissen, ob zweigemessene Signale von einander abhängig, korreliert, sind. Zum Beispiel könnte man diePosition eines Elektrons und seinen Spin, die Menge der verkauften Eis- und Sonnencre-me, oder auch die Position eines Pendels zu zwei verschiedenen Zeitpunkten betrachten.

55


In den beiden letzteren Fällen werden diese im Allgemeinen korreliert, also abhängig,sein. Allerdings gibt dies keinen Aufschluss über den dahinterstehenden kausalen Me-chanismus. Im Fall des Pendels rührt die Korrelation daher, dass es sich in kurzer Zeitnicht beliebig weit von seiner Ausgangsposition bewegen kann, es ist also tatsächlichein kausaler Mechanismus. Bei der Eis- und Sonnencreme wird es vermutlich auch eineKorrelation geben, aber weder erzeugt Eiscreme Sonnenbrand, noch macht SonnencremeLust auf Eis. Allerdings haben wir Menschen nunmal bei strahlendem Sonnenschein mehrLust auf Eis, brauchen aber auch Sonnencreme.

4.3.1 Kreuzkorrelationsfunktion

Wir betrachten zwei Observablen A und B. Diese beiden heißen genau dann unkorre-liert, falls die Mittelwerte 〈A ·B〉 = 〈A〉〈B〉 bzw. 〈(A− 〈A〉)(B − 〈B〉)〉 = 0 erfüllen.Im Allgemeinen wird man aber nicht erwarten, dass sich die Änderung einer Observa-blen unmittelbar in einer anderen niederschlägt, sondern erst nach einer Zeit τ . Manbetrachtet daher die Korrelation zwischen A und B mit einem zeitlichen Versatz von τ ,die Kreuzkorrelationsfunktion:

C(A,B)(τ) := 〈(A(0)− 〈A〉)(B(τ)− 〈B〉)〉 = 〈(A(0)B(τ)〉 − 〈A〉〈B〉 , (4.23)

wobei die Signale A und B zeitinvariant sein sollen, so dass der Zeitpunkt t = 0 beliebiggewählt werden kann. Für große τ dekorrelieren die Signale, daher gilt C(A,B) → 0 fürτ →∞.Abbildung 4.3 illustriert die Kreuzkorrelation am Beispiel verschiedener Sinusschwin-

gungen. Aufgrund ihrer Periodizität sind sin(t) und sin(t + 2π) stark korreliert. Daherhat C(sin , sin) ein Maximum bei 2π, 4π, . . .. sin(t+π) hat hingegen immer das entgegen-gesetzte Vorzeichen, daher hat C(sin , sin) bei π, 3π, . . . ein negatives Minimum. Wirdstattdessen sin(t) mit cos(t) korreliert, verschieben sich die Maxima und Minima umπ/2, dem Versatz zwischen Sinus und Kosinus entsprechend. Verschieben der Funktionennach oben oder unten ändert daran nichts, da ja der Mittelwert abgezogen wird. Wirdallerdings eine der beiden Funktionen nur leicht verstimmt, zum Beispiel zu sin(1,1t),dann haben sin(1,1t) und sin(t) über ein großes Intervall in t betrachtet unabhängigeVorzeichen, sind also unkorreliert, wie auch die Kreuzkorrelation zeigt. Für analytischeFunktionen wie in diesem Beispiel ist die Kreuzkorrelation natürlich einfach vorherzu-sagen. Bei verrauschten Messdaten ist das aber unter Umständen schwieriger, wie wirspäter noch sehen werden.〈·〉 bezeichnet in der Physik üblicherweise den Ensemblemittelwert, also den Mittelwert

über alle möglichen Realisationen des Experiments. Sind nun A = A(t) und B = B(t)zeitliche Messreihen eines zeitinvarianten Systems, so ermittelt man die Mittelwert übli-cherweise als Zeitmittelwert, also Integrale über die Zeit:

C(A,B)(τ)!

= limT→∞

1

T

∫ T

0(A(t)− 〈A〉) (B(t+ τ)− 〈B〉) dt. (4.24)

Das Ausrufezeichen soll andeuteten, dass dies eine Annahme ist, denn die Gleichheit giltnur genau dann, wenn das System ergodisch ist, d. h. , dass der Prozess bei einer unend-lich langen zeitlichen Messung alle möglichen Realisationen einmal besuchen wird. Diese

56


0 5 10 151.0

0.5

0.0

0.5

1.0

1.5

2.0

2.5 f1 (t) =sin(t)

f2 (t) =sin(1,1t)

f3 (t) =cos(t) +0,5

0 1 2 3 4 5 61.0

0.5

0.0

0.5

1.0 C(f1 ,f1 )(t)

C(f1 ,f2 )(t)

C(f1 ,f3 )(t)

Abbildung 4.3: Verschiedene Funktionen (links) und einige Kreuzkorrelationen (rechts).Die Kreuzkorrelation C(f1, f1) besagt, dass f1 sich selber mit Versatz 0 oder 2π vor-hersagt, wie man erwarten würde. Bei π hat die Korrelation eine negatives Minimum,da sin(x + π) = − sin(x). Analog erklärt sich auch C(f1, f3), da die Verschiebung um0,5 keinen Einfluss hat. f1 kann die verstimmte Funktion f2 zu keiner Zeit vorhersagen,daher ist die Kreuzkorrelation C(f1, f2) identisch Null.

Annahme wird meist gemacht, obwohl die Ergodizität für die meisten Systeme nicht be-wiesen werden kann. Hinzu kommt, dass ja in der Praxis niemals über beliebig langeZeiträume gemittelt werden kann. Daher können auch endliche, aber hohe Energiebar-rieren zu einem systematischen Fehler führen, weil das System im Zeitraum der Messungnur den Teil des Phasenraums besucht, der von der Energiebarriere eingeschlossen ist,selbst wenn auch andere Bereiche zulässig wären.〈A〉 bzw. 〈B〉 sind oft auch nicht vorneherein bekannt, und müssen numerisch durch

Mittelung der Daten bestimmt werden. In ergodischen Systemen genügt ebenfalls dasZeitmittel

〈A〉 != lim

T→∞

1

T

∫ T

0A(t) dt. (4.25)

In der Praxis sind A und B natürlich nicht als Funktionen bekannt, sondern nur alsdiskrete Messungen. Wir nehmen wie üblich an, dass diese an endlich vielen, äquidistan-ten Zeitpunkten k∆, k = 0(1)N − 1 stattgefunden haben. Die Gesamtmesszeit beträgtalso T = N∆. Dann erhalten wir als Näherung für das Integral (4.24)

C(A,B)(k∆) ≈ 1

N − k

N−k∑l=0

(A(l∆)− 〈A〉)(B ((l + k −∆)− 〈B〉) für k = 0(1)N − 1.

(4.26)

57


Die unterschiedliche Gewichtung 1/(N −k) ergibt sich durch die unterschiedliche Anzahlan Messungen für den Versatz k. Für große Versätze ist die Anzahl der Messungen sehrklein (für k = N − 1 nur noch eine), daher muss k N sein. Bei der Diskretisierung desIntegrals kürzt sich der Vorfaktor 1/T gegen die Schrittweite, so dass nur die Anzahl derMessungen eingeht, nicht aber die Länge des Messintervalls T .Sind die Mittelwerte nicht bekannt, können diese durch

〈A〉 ≈ 1

N

N−1∑l=0

A(l∆) (4.27)

abgeschätzt werden. Da hier aber normalerweise dieselben Daten zugrunde gelegt werden,die zur Berechnung der Kreuzkorrelation selber genutzt werden, sind diese notwendiger-weise korreliert. Auch wenn A zum Beispiel eine Observable mit Mittelwert 0 ist, ist dernumerische Mittelwert im Allgemeinen von Null verschieden und noch dazu in Richtungder Mehrheit der Daten verschoben. Dadurch ist die scheinbare Kreuzkorrelation stetszu klein. Ist also der Mittelwert aus physikalischen Gründen bekannt, zum Beispiel Nullaus Symmetriegründen, sollte der numerische gemessene Mittelwert auf keinen Fall ab-gezogen werden, „um das Ergebnis zu verbessern“. Diese übliche Praxis ist wie gesehenfalsch, da sie zu einer Unterschätzung der Langzeitkorrelationen führt!Gleichung (4.26) ist numerisch nicht sehr effizient auszuwerten, da im allgemeinen 2N2

viele Operationen benötigt werden. Auf der anderen Seite ist die Kreuzkorrelation (4.24)strukturell einer Faltung sehr ähnlich. Daher liegt es nahe, auch hier die FFT gemäß (4.20)zur Beschleunigung einzusetzen. Dazu nehmen wir ohne Beschränkung der Allgemeinheitan, dass die Observablen 〈A〉 = 〈B〉 = 0 erfüllen und außerhalb [0,T ] Null seien. Dannist

C(A,B)(τ) =1

T

∫ ∞−∞

A(t)B(t+ τ) dt =1

T

(A?B(−·)

)(−τ) =

1

T

(A(−·) ?B

)(τ) , (4.28)

was gemäß (4.19) effizient im Frequenzraum bestimmt werden kann:

C(A,B)(t) =

√2π

TF−1

(F(A)(−ω)F(B)(ω)

)=

√2π

TF−1F−1

(F(A)F(B)

). (4.29)

Diskretisiert ergibt sich schließlich analog (4.20)

C(A,B)(k∆) ≈ 1

NiDFT

(DFT(A)DFT(B)

)(k) . (4.30)

Wie oben kürzt sich der Vorfaktor 1T gegen die Schrittweite des Integrals, so dass nur

die Anzahl der Messungen N , aber nicht die Länge des Messintervalls eingehen. Auchder Vorfaktor

(e−iω0t0

)n in (4.20) entfällt, da beide Messungen nach Voraussetzung beit0 = 0 beginnen.Die Berechnung der 2 DFTs sowie der inversen DFT braucht etwa 6N logN Operatio-

nen, was normalerweise wesentlich weniger als die 2N2 der direkten Berechnung ist. Aller-dings werden das Signal und damit auch C(A,B) durch die Benutzung der DFT implizit

58


0 200 400 600 800 10004

2

0

2

4

6

8

10

12

14

0 20 40 60 80 100

0.0

0.2

0.4

0.6

0.8

1.0

Abbildung 4.4: Drei Messungen (links) und zugehörige Autokorrelationen (rechts). Diemit grünen Punkten dargestellte Messung dekorreliert bereits nach weniger als 10 Daten-punkten. Dabei spielt es keine Rolle, dass der Mittelwert nicht Null ist. Die rote Kurvehingegen schwankt deutlich langsamer, daher fällt die zugehörige Autokorrelation erstnach 80 Punkten auf Null ab. Die blau gepunktete Kurve hingegen fällt sehr langsam ab,entsprechend fällt die Autokorrelation auch nach 100 Datenpunkten fast nicht ab.

mit Periode N∆ periodisiert. Daher sollte C(A,B)(k∆) nur für k N/2 interpretiertwerden. Wie besprochen gilt dies allerdings genauso auch für die direkte Auswertungnach (4.26), da für größere k die Anzahl der Messwerte nicht ausreichend ist.In Python sieht die Berechnung der Kreuzkorrelation so aus:

import numpyimport numpy.fft as fft

def kreuzkorrelation(A, B):ftA = fft.fft(A).conj()ftB = fft.fft(B)return numpy.real(fft.ifft(ftA*ftB))/A.shape[0]

4.3.2 Autokorrelationsfunktion

Im Spezialfall A = B spricht man von der Autokorrelationsfunktion. Diese ist offenbarsymmetrisch, daher sind nur Zeitversätze τ ≥ 0 von Interesse. Die Autokorrelationsfunk-tion misst gewissermaßen, wie lange es dauert, bis die Observable nicht mehr von ihremvorherigen Wert abhängt, wann es diesen sozusagen „vergisst“. In dem häufigen Fall, dassdie Autokorrelationsfunktion zunächst exponentiell abfällt, lässt sich dem Gedächtniseine Zeitkonstante τc, die Korrelationszeit, zuordnen. Diese kann man entweder durch

59


0.0 0.2 0.4 0.6 0.8 1.0t

50

0

50

100

150

200

C(v

,v)

Abbildung 4.5: Geschwindigkeitsautokorrelationsfunktion einer temperierten Lennard-Jones-Flüssigkeit mit niedriger Dichte (rot gepunktet) und hoher Dichte (blau durch-gezogen). Für die niedrige Dichte ist die Autokorrelationsfunktion im wesentlichen expo-nentiell abfallend, mit einer Korrelationszeit τc = 0.17, die durch die Kopplungszeit desThermostaten bestimmt ist.

einen geeigneten Funktionsfit bestimmen, oder aber durch Integration aus∫ ∞0

C(A,A)(τ) dτ =

∫ ∞0

C(A,A)(0)e−τ/τc dτ = τcC(A,A)(0). (4.31)

Es gilt C(A,A)(0) =⟨A(0)2

⟩−〈A〉2 = σ2(A), wobei σ2(A) die Varianz der Observablen

A ist, auf die wir später noch genauer eingehen. Zur Normierung wird die Autokorre-lationsfunktion häufig einfach durch σ2(A) geteilt, so dass sie bei Null den Wert Einsannimmt. Dies hat natürlich keinen Einfluss auf die Korrelationszeit.Abbildung 4.4 zeigt die Autokorrelationsfunktion dreier typischer Verläufe, wie man

sie aus Messungen erhalten könnte. Diese zeigen, dass ein von Null verschiedener Mittel-wert für die Autokorrelation keine Rolle spielt, wohl aber eine systematische Drift wiebei der blau gepunkteten Kurve. An diesem Beispiel wird auch unmittelbar klar, dasseine numerische Mitteilung der Daten keine sinnvolle Aussage liefert — der gemessenMittelwert hängt ja stark von der Länge des Experiments ab. Später werden wir sehen,dass die Korrelationszeit eine wichtige Rolle bei der Messfehlerabschätzung spielt, weilsie angibt, wie sehr benachbarte Messwerte von einander abhängen, sich also praktischwiederholen.Abbildung 4.5 zeigt die Geschwindigkeitsautokorrelation C(v,v) einer temperierten

Lennard-Jones-Flüssigkeit bei zwei verschiedenen Dichten, eines typischen Modellsystemsin der statistischen Physik. Die Temperierung wird dabei mit Hilfe eines Thermostaten

60

4.4 Messfehlerabschätzung

erreicht, der die Teilchen stochastisch an ein Wärmebad koppelt. Dadurch dekorreliertdie Geschwindigkeit eines Teilchens in einer Korrelationszeit von etwa 1/6.C(v,v) wird häufig dazu benutzt, um die Diffusionskonstante D =

∫∞0 C(v,v)(τ) dτ

des Systems zu bestimmen, die eng mit der Korrelationszeit des Thermostaten verwandtist. Bei niedriger Dichte ist das System annähernd ein ideales Gas, und die Teilchen de-korrelieren im wesentlichen nur durch den Einfluss des Thermostaten. Daher ist C(v,v)tatsächlich einfach exponentiell abfallend. Formel (4.31) bestimmt die Korrelationszeitmit guter Genauigkeit zu etwa τc = 0.17, wie durch den Thermostaten zu erwarten. ImFalle der dichteren Flüssigkeit hingegen kann diese Formel nicht angewendet werden, dadie Autokorrelation kein einfacher exponentieller Abfall mehr ist, da auch Stoßprozesseeine wichtige Rolle spielen. Diese führen zum Durchschwingen der Autokorrelationsfunk-tion.


In diesem letzten Abschnitt zur Datenanalyse geht es darum, wie der Messfehler bei derMessung des Erwartungswerts einer stochastischen Observable abgeschätzt werden kann.Wir betrachten also eine Messreihe xi, i = 1(1)N , die verschiedene Messungen einerstochastischen Observablen x darstellen, deren Verteilung zeitlich unveränderlich seinsoll (wie zum Beispiel die Temperatur eines abgeschlossenen Systems im Gleichgewicht).Die gesuchte Größe ist dann meist der Erwartungswert 〈x〉 der Observablen, also dermittlere zu erwartende Wert der Observablen. Eine einzelne Messung wird im allgemeineneinen davon abweichenden Wert liefern. Die Größe dieser Abweichung wird durch die zuerwartende quadratische Abweichung, die Varianz

σ2(x) =⟨(x− 〈x〉

)2⟩=⟨x2⟩− 2 〈〈x〉x〉+ 〈x〉2 =

⟨x2⟩− 〈x〉2 , (4.32)

beschrieben. Sie ist wie der Erwartungswert eine Eigenschaft der zu messenden Observa-blen x und im Gegensatz zum Messfehler nicht von der Anzahl oder Art der Messungenabhängig. Allerdings lassen sich weder 〈x〉 noch σ2(x) direkt messen, sondern können nuranhand der Messreihe geschätzt werden.Der der Erwartungswert lässt sich aus der Messreihe als

〈x〉 ≈ x :=1

N

N∑i=1

xi (4.33)

abschätzen, da offenbar 〈x〉 = 〈x〉. Doch was ist nun der Fehler, den wir mit dieser Schät-zung machen? Dieser ist die zu erwartende quadratische Abweichung des numerischenMittelwerts vom tatsächlichen Erwartungswert:

⟨(x− 〈x〉)2

⟩=

1

N2

N∑i,j=1

〈xixj〉−2

N

N∑i=1

〈xi〉〈x〉+ 〈x〉2 =2

N2

∑i>j

〈xixj〉+1

N

⟨x2⟩−〈x〉2 .

(4.34)

61


An dieser Stelle nimmt man nun an, dass die Messungen paarweise unabhängig sind,also, dass 〈xixj〉 = 〈xi〉〈xj〉 für i 6= j. In der Praxis lässt sich das zum Beispiel durchBetrachten der Autokorrelationsfunktion sicherstellen, indem nur Messwerte mit einemzeitlichen Abstand berücksichtigt werden, der sehr viel größer als die Korrelationszeitist. Diese Einschränkung werden wir im folgenden noch genauer untersuchen, für denMoment nehmen wir die Unabhängigkeit an und erhalten⟨

(x− 〈x〉)2⟩

=N(N − 1)

N2〈x〉2 +

1

N

⟨x2⟩− 〈x〉2 =

1

N

(⟨x2⟩− 〈x〉2

)=

1

Nσ2(x). (4.35)

Als Fehlerbalken wird üblicherweise die Standardabweichung der Messung x angegeben.Diese ist durch √

〈(x− 〈x〉)2〉 =1√Nσ(x) (4.36)

gegeben. Mit anderen Worten: die Streubreite der Observablen x wird durch die Mit-telung um einen Faktor 1/

√N gedämpft. Je stärker x streut, desto mehr Messwerte

benötige ich, um den Erwartungswert zuverlässig abzuschätzen. Für eine Halbierung desFehlerbalken müssen bereits viermal soviele Messungen durchgeführt werden, und füreine Größenordnung an Genauigkeit hundert Mal soviele. Besonders für Computersimu-lationen ist das ein Problem, da die Rechenzeit im allgemeinen proportional zur Anzahlder Messungen ist. Dauert also eine Simulation eine Woche, was nicht ungewöhnlich ist,so würde eine Messung mit einer Größenordnung mehr Genauigkeit fast zwei Jahre inAnspruch nehmen!Zur Berechnung des Fehlers benötigen wir noch eine Schätzung der Varianz, die im All-

gemeinen ebensowenig wie der Erwartungswert bekannt ist und geschätzt werden muss.Dazu ersetzt man die Erwartungswerte in

⟨x2⟩− 〈x〉2 durch den Schätzer (4.33). Für

diesen Ausdruck gilt:⟨x2 − x2

⟩=⟨x2⟩− 1

N2

n∑i=1

⟨x2i

⟩− 1

N2

∑i 6=j〈xixj〉 =

N − 1

N

(⟨x2⟩− 〈x〉2

), (4.37)

wobei wir wieder annehmen, dass die Messungen unabhängig voneinander sind. Der Aus-druck auf der linken Seite ist selber also kein guter Schätzer für die Varianz, obwohl ergenau wie der Schätzer für den Erwartungswert konstruiert ist. Das liegt daran, dass fürdie Schätzung von 〈x〉 zweimal x und damit zweimal derselbe Datensatz benutzt wurde.Ein guter Schätzer für σ2(x) ergibt sich aus der Umkehrung von (4.37):

σ2(x) ≈ N

N − 1

(x2 − x2

)=

N

N − 1

((x− x)2

). (4.38)

Damit kann für unkorrelierte Daten der quadratische Fehler durch⟨(x− 〈x〉)2

⟩≈ 1

Nσ2(x) =

1

N − 1

(x2 − x2

)(4.39)

abgeschätzt werden.Auf dem Computer lassen sich 〈x〉 und σ2(x) mit Hilfe von (4.38) bequem in einem

Durchlauf der Daten abschätzen:

62


sum = 0sum2 = 0for v in x:

sum += vsum2 += v*v

mittel = sum/len(x)sigma2 = (sum2/len(x) - mittel**2)*len(x)/(len(x)-1)fehler = sqrt(sigma2/N)

Der zweite Weg in (4.38) via (x− x)2 ist zwar numerisch etwas stabiler, aber erfordertzwei Schleifen über alle Daten, da der Mittelwert zunächst bestimmt werden muss, wasunter Umständen zu einer Verdoppelung der Laufzeit führen kann.Selbstverständlich sind diese elementaren Schätzer aber auch direkt in NumPy imple-

mentiert. numpy.mean(x) berechnet den Schätzer für den Erwartungswert eines Arraysx, numpy.var(x, ddof=1) den Schätzer für seine Varianz. ddof bezeichnet dabei dieAnzahl der abhängigen Freiheitsgrade, die von N im Nenner von (4.38) abgezogen wer-den. Wie wir eben gesehen haben, ist dies bei unabhängigen Daten ddof = 1.

4.4.1 Fehler bei der Messung korrelierter Daten

In der Praxis wird oft einfach angenommen, dass die Messungen unabhängig sind. Waspassiert nun, wenn dies nicht der Fall ist? Betrachten wir also eine Observable die o.B.d.A.Erwartungswert 〈x〉 = 0 habe. Dann ist wie oben gezeigt

⟨(x− 〈x〉)2

⟩=

2

N2

∑i>j

〈xixj〉+1

Nσ2(x) =

2

N2

N∑j=1

N−j∑n=1

〈xjxj+n〉+1

Nσ2(x). (4.40)

Für eine Observable x, die in gleichmäßigen Zeitabständen ∆ gemessen wird, lässt sich dieinnere Summe des linken Terms mit Hilfe der Autokorrelationsfunktion C(τ) = C(x,x)(τ)abschätzen:

N−j∑n=1

〈xjxj+n〉 ≈∫ ∞n=0

C(n∆) =τint∆C(0) =

τint∆σ2(x), (4.41)

wobei

τint :=1

C(A,A)(0)

∫ ∞0

C(A,A)(τ) dτ (4.42)

die sogenannte integrierte Korrelationszeit ist. Bei einfachen exponentiellen Prozessenentspricht diese gemäß (4.31) genau der klassischen Korrelationszeit τc. Außerdem mussτint N∆ sein, so dass die Erweiterung des Integrals bis unendlich keinen nennenswertenBeitrag mehr liefert. Eingesetzt in (4.40) ergibt sich

⟨(x− 〈x〉)2

⟩≈ 2

N2

N∑j=1

τint∆σ2(x) +

1

Nσ2(x) =

(1 + 2

τint∆

) σ2(x)

N. (4.43)

63


Der Fehler ist also um einen Faktor 1 + 2τint/∆ größer, als man aufgrund der Varianzund Anzahl Messungen erwarten würde, wenn man einfach annimmt, dass die Messungenunabhängig sind. Setzt man Neff = N∆/(2τint), dann ergibt sich

⟨(x− 〈x〉)2

⟩≈(

1 + 2τint∆

) σ2(x)

N. ≈ σ2(x)

Neff. (4.44)

Mit anderen Worten, Neff kann als die Anzahl der tatsächlich unabhängigen Messungeninterpretiert werden. Nur Messungen, die etwa zwei Korrelationszeiten auseinanderliegen,sind hinreichend unabhängig.Auch der Schätzer (4.38) für die Varianz setzt die Unabhängigkeit der Messungen

voraus. Für abhängige Daten ergibt sich

N

N − 1

⟨x2 − x2

⟩=

1

N − 1

N ⟨x2⟩−⟨x2⟩− 1

N

∑i 6=j〈xixj〉

= σ2(x)− 2

N(N − 1)

∑i>j

〈xixj〉 ≈(

1− 2τint∆N

)σ2(x). (4.45)

Die Varianz wird also zusätzlich um einen Faktor 1− 2 τint∆N unterschätzt. Immerhin lässt

sich dieser Fehler durch ausreichend viele Messungen minimieren. Allerdings bringt esnichts, einfach häufiger zu messen, sondern man muss tatsächlich länger messen, da jadie Gesamtmesszeit ∆N eingeht.Abbildung 4.6 zeigt die scheinbare Varianz der Verteilung der einzelnen Komponen-

ten der Geschwindigkeit als Funktion der gewählten Messschrittweite im weniger dich-ten thermalisierten Lennard-Jones-System. Diese Geschwindigkeiten sind im thermischenGleichgewicht normalverteilt um die Null mit einer Varianz proportional zur Temperaturdes Systems. Im Falle der hier benutzten Simulationen stellt ein Thermostat sicher, dassdie Temperatur exakt 1 ist. Wie man in Abbildung 4.6 allerdings deutlich sieht, wirdmit korrelierten Messungen die Varianz, und damit die Temperatur, um bis zu 25% un-terschätzt, sofern zwischen den Messungen deutlich weniger Zeit als die Korrelationszeitdes Systems, ≈ 0,17, liegt. Im Beispiel wurden alle 0,01 Schritte insgesamt 50.000 Datenerhoben. Der quadratische Fehler der beobachteten mittleren Geschwindigkeitskompo-nenten ist also 1 · 34/50.000 ≈ 7 · 10−4 anstatt 2 · 10−5, wie man ohne Berücksichtigungder Korrelationen erhalten würde.

4.4.2 Binning-Analyse

Die Messung der integrierten Korrelationszeit τint ist relativ aufwändig, weil diese dienumerische Integration der oft stark verrauschten Autokorrelationsfunktion erfordert.Eine Möglichkeit, diese zu umgehen und den Fehler direkt abzuschätzen, ist die Binning-Analyse [Jan02]. Diese Methode liefert direkt den Messfehler, kann aber auch benutztwerden, um τint abzuschätzen.Der Ansatz ist naheliegend. Da korrelierte Daten sich auf kurzen (Zeit-)Abständen

nur wenig ändern, ist das Ziel, die Anzahl der Daten soweit zu reduzieren, dass die

64


0.00 0.05 0.10 0.15 0.20 0.25 0.300.5

0.6

0.7

0.8

0.9

1.0

1.1

²-Sch

ätze

r

Abbildung 4.6: Geschätzte, scheinbare Varianz der Komponenten der Geschwindigkeits-verteilung in einem dünnen temperierten Lennard-Jones-Systems als Funktion der ge-wählten Schrittweite ∆. Analytisch erwartet man bei der gewählten Temperatur eineVarianz von 1. Die blauen Balken geben das 1σ-Intervall der beobachteten Varianzenan. Die schwarze Linie zeigt die Abschätzung der scheinbaren Varianz gemäß (4.43) als(1− 2τint/(∆N))σ2(x), was gut zu den gemessenen Daten passt.

verbleibenden Werte gut als unabhängig angesehen werden können. Dazu seien die Datenx in B Blöcke („Bins“) der Länge k eingeteilt. Ist N nicht durch k teilbar, muss dazuder Datensatz etwas gekürzt werden, so dass alle Blöcke voll sind. Anstatt der einzelnenDaten in den Blöcken, betrachten wir nun nur ihre jeweiligen Mittelwerte

Xk,l =1

k

k∑j=1

x(l−1)k+j l = 1(1)B. (4.46)

Offenbar hängen der Erwartungswert und die Varianz der einzelnen Xk,l nicht vom Auf-punkt l ab. Wir schreiben daher kurz Xk für die Observable der Blockmittelwerte derLänge k. Der Erwartungswert von Xk ist unverändert der von x, also 〈Xk〉 = 〈x〉, undauch für den Mittelwert aller Xk gilt X = x. Allerdings ist die Varianz σ2(Xk) im all-gemeinen von σ2(x) verschieden, und zwar abhängig von k. Sofern k sehr viel größerals die typischen Korrelationslängen ist, gilt nach (4.44) σ2(Xk) ≈ σ2(x)/keff, wobeikeff = k∆/(2τint) die effektive Anzahl der unabhängigen Messungen ist. Für sehr kleinek hingegen spielt die Mittelung keine Rolle, daher ist σ2(Xk) ≈ σ2(x).Diese Verhalten nutzen wir nun, um den Fehler korrelierter Daten abzuschätzen. Da-

zu berechnen wir den quadratischen Fehlerschätzer (4.39) für die Blockmittelwerte bei

65


verschiedenen Blockgrößen k:

ε2(k) :=1

B − 1

(X2k −Xk

2)≈ k

Nσ2(Xk). (4.47)

Ist k klein, so ist σ2(Xk) ≈ σ2(x), und ε2(k) wächst linear in k. Für große k hingegen istσ2(Xk) ≈ σ2(x)/keff, so dass ε2(k) konstant wird, und zwar

ε2(k) =k

N

σ2(x)

keff=σ2(x)

Neff. (4.48)

Der konstante Wert bei großen k ist also der gesuchte tatsächliche Fehler! Allerdingsstehen bei großen k für die Mittelung immer weniger Blöcke zur Verfügung, so dassε2(k) stark verrauscht. Daher funktioniert diese Analyse nur, sofern man genügend Datengesammelt hat. Auch die Umkehrung gilt: trägt man ε2(k) gegen k auf und sieht keinPlateau bei großen k, hat man noch nicht genügend Daten gesammelt, um eine Aussageüber die Güte der Messung zu machen, man benötigt also mehr Daten.Neben des Fehlers lässt sich für große k auch die integrierte Korrelationszeit gemäß

k∆σ2(Xk)

σ2(x)≈ k∆

keff= 2τint (4.49)

bestimmen, wobei die Messung von σ2(x) ausreichend unabhängige Daten voraussetzt.Dies überprüft man zunächst anhand von ε2(k).Abbildung 4.7 demonstriert die Abschätzung des quadratischen Fehlers und der in-

tegrierten Korrelationszeit für die Messung der Geschwindigkeitskomponenten in derLennard-Jones-Flüssigkeit. Wie erwartet werden beide Größen für große k konstant,aber sind verrauscht, während sie für kleine k linear anwachsen. Für die Bestimmungder integrierten Korrelationszeit wurde das analytische Ergebnis σ2(x) = 1 benutzt, diegemessene ist mit 1,03 etwas größer. Aus der Binning-Analyse ergibt sich ein quadrati-scher Fehler von etwa 0,001 und eine integrierte Korrelationszeit von 0,25, was gut zuunserer Korrelationszeit 0,17 und der Fehlerschätzung von 7 · 10−4 passt.

4.5 Ausgleichsrechnung, Methode der kleinsten Quadrate

Interpolierende Polynome, Taylorreihen und Splines haben gemeinsam, das diese mög-lichst nahe an alle gegebenen Stützstellen verlaufen. Die Anzahl der Terme in der Ap-proximation ist nur durch die Anzahl der Stützstellen begrenzt, und meist wählt manso viele Stützstellen wie möglich, um eine möglichst genaue Näherung der unbekanntenFunktionsform zu erhalten.Wenn die Daten an den Stützstellen aus Experimenten oder Computersimulationen

gewonnen werden, ist das aber gar nicht gewünscht, da die Daten selbst nicht exakt sind.Wie wir gesehen haben, kann deren Qualität zwar durch Mittelung verbessert werden,trotzdem bleibt eine gewisse Unsicherheit. Andererseits hat man in diesem Fall üblicher-weise eine Vorstellung aus der Theorie, welche funktionelle Form die Daten annehmen,und möchte nun wissen, bei welcher Parameterwahl diese Funktion am besten mit den

66


100 101 102 103

k

10-5

10-4

10-3

10-2ε2

(k)

100 101 102 103

k

10-3

10-2

10-1

100

τ int

Abbildung 4.7: Links: geschätzter quadratischer Fehler ε2(k) in der Messung der Kom-ponenten der Geschwindigkeitsverteilung in einem dünnen temperierten Lennard-Jones-Systems als Funktion der Blockgröße k. Der Fehler erreicht sein Plateau bei etwa 0,001,was gut mit der Abschätzung über die Korrelationszeit übereinstimmt. Die gestrichelteschwarze Linie demonstriert das lineare Wachstum für kleine k. Rechts: Geschätzte inte-grierte Korrelationszeit τint für dasselbe System. Diese erreicht ihr Plateau bei τint ≈ 0,25,was etwas größer als das einfach exponentielle τc ≈ 0,17 ist.

Daten verträglich ist. Man möchte also den Parametersatz bestimmen, der den Abstandder Daten von der Funktion minimiert. Dabei ist bei sinnvollen Experimenten die Anzahlder Datenpunkte sehr viel größer als die Anzahl der Parameter.Seien also wieder Daten (xi, yi), i = 0(1)n − 1 und eine Funktion fv(x) gegeben.

Gesucht ist dann derjenige Parametervektor v, der die Abweichung

∆(v) =∑i

(fv(xi)− yi)2 (4.50)

minimiert. Dieses Verfahren wird auch Methode der kleinste Quadrate genannt, da jadie quadrierten Abweichungen minimiert werden sollen. Ist fa,b(x) = ax+ b eine Gerade,spricht man auch von linearer Regression. In diesem Fall lässt sich das Optimum einfachbestimmen, da

0 =d

da∆(a,b) =

∑i

2(axi + b− yi)xi = 2n(ax2

i + bxi − yixi)

(4.51)

und0 =

d

db∆(a,b) =

∑i

2(axi + b− yi) = 2n (axi + b− yi) , (4.52)

67


0 1 2 3 4 5 6

1.0

0.5

0.0

0.5

1.0

Abbildung 4.8: Methode der kleinsten Quadrate zum Fitten der Sinusfunktion y =sin(x). 200 Datenpunkte zwischen 0 und 2π wurden als sin(x) + 0,1 sin(10x) + ξ erzeugt,wobei ξ eine Gauß-verteilte Pseudozufallsvariable mit Varianz 0,01 war. Die resultierendeSinusfunktion (rot gestrichelt) hat die Form a sin(bx+ c), wobei die Koeffizienten auf gut2% Genauigkeit a = b = 1 und c = 0 entsprechen. Die kleine höherfrequente Schwingungkann durch einen Fit allerdings nicht zuverlässig erkannt werden, anders als durch eineFouriertransformation, vergleiche Abbildung 3.6

wobei x = 1n

∑n−1i=0 xi den Mittelwert über alle Datenpunkte bedeutet. Daraus ergibt sich

a =yixi − yi · xix2i − xi2

und b = yi − axi, (4.53)

was sich einfach auf dem Computer berechnen lässt.Auch für quadratische und andere einfache Funktionen lassen sich die Koeffizienten

geschlossen darstellen, aber bei allgemeinen Funktionen ist dies nicht immer der Fall.Dann muss die nichtlineare Optimierungsaufgabe (4.50) numerisch gelöst werden, was wirspäter behandeln werden. Für den Moment genügt uns, dass SciPy die Funktion scipy.optimize.leastsq(delta, v0, (x, y)) dafür bereitstellt. (x, y) sind dabeidie Ausgangsdaten, die hier zu einem Tupel zusammengefasst sind. v0 ist der Startwertfür die Berechnung, der nicht zu weit vom (unbekannten) Optimum entfernt liegen darf.delta ist eine Python-Funktion, die als Argumente v, xi und yi nimmt und fv(xi)− yizurückliefert. Da fv(x) eine beliebig komplizierte Form annehmen kann, ist diese Auf-gaben im Allgemeinen nicht lösbar, allerdings funktioniert ein solcher Fit für einfacheFunktionen meistens recht gut. Abbildung 4.8 zeigt einen solchen Funktionsfit an eineverrauschte Sinusfunktion, die mit 200 Datenpunkten auf etwa 2% genau gefittet wer-den kann. Man beachte, das der Ausgangswert für den Fit mit Hilfe der SciPy-Funktionleastsq a = 0, b = 1, c = 0 war; beim Startwert a = 0, b = 0, c = 0 bricht das Verfahren

68


ab. Das zeigt, dass man tatsächlich nicht zu weit vom Optimum starten kann, was eingewisses Verständnis der Zielfunktion voraussetzt.Ist die Funktionsform, die den Daten zugrundeliegt, unbekannt, ist es normalerweise

keine gute Idee, die Form zu raten. Generell sollte auch die Anzahl der Parameter sehrklein sein, da sich sonst fast alles „gut“ fitten lässt („With four parameters I can fit anelephant and with five I can make him wiggle his trunk.“ — J. von Neumann).Soll aber zum Beispiel für Visualisierungszwecke eine ansprechende Kurve entlang der

Daten gelegt werden, deren tatsächliche Abhängigkeit unbekannt ist, dann sind Padé-Funktionen oft eine gute Wahl. Diese haben die Gestalt P (x)/Q(x), wobei P und Qzwei Polynome mit paarweise verschiedenen Nullstellen sind. Üblicherweise lassen sichschon für niedrige Polynomgrade ansprechende Fits finden, sofern die Grade der beidenPolynome in etwa gleich gewählt werden.

69

5 Nichtlineare Gleichungssysteme

Im zweiten Kapitel hatten wir uns mit der Lösung linearer Gleichungssysteme beschäftigt,die ja eine wesentliche Grundlage der numerischen Mathematik darstellen. Allerdingstauchen in der Praxis, besonders in der Physik, leicht auch nichtlineare Gleichungssystemeauf. In diesem Fall kann man meist keine allgemeine Aussage über Existenz und Anzahlder Lösungen machen und auch keine exakten Verfahren zur Lösung angeben.Nichtlineare Gleichungssysteme werden typischerweise in zwei Formen betrachtet. Sei

eine Funktion f : M ⊆ Rn → Rn gegeben. Dann suchen wir die Nullstellen

x, so dass f(x) = 0, (5.1)

also die Lösungen zur Gleichung f(x) = 0. Man beachte, dass anders als im Fall derlinearen Gleichungssysteme gefordert wird, dass der Bildraum wie auch der Ursprungs-raum M zu einem Vektorraum derselben Dimension n gehören. Ohne diese Vorausset-zung ist eine eindeutige Lösung im Allgemeinen unmöglich. Anders als im Falle derlinearen Gleichungssysteme ist es hier auch nicht ohne Weiteres möglich, den Lösungs-raum anzugeben, falls die Lösung nicht eindeutig ist. Tatsächlich kann der Lösungsraumja eine beliebig komplexe Mannigfaltigkeit innerhalb M darstellen, die dann gar nichtgeschlossen parametrisiert werden kann. Das macht die numerische Bestimmung dieserLösungsmannigfaltigkeit sehr schwierig.Alternativ können wir für eine Funktion g : M ⊆ Rn → Rn die Fixpunkte suchen.

Diese sindx, so dass g(x) = x, (5.2)

also die Lösungen der Gleichung g(x) = x. Eine Fixpunktgleichung lässt sich natürlichstets auch als Nullstellenproblem mit f(x) = g(x)− x formulieren und umgekehrt.Die beiden Formulierungen unterscheiden sich allerdings im natürlichen Lösungsan-

satz. Die Nullstellengleichung (5.1) ähnelt dem linearen Gleichungssystem (2.1). DasNewtonverfahren beruht auf einer lokalen Linearisierung und dem Lösen dieses linea-ren Gleichungssystems. Die Fixpunktgleichung hingegen legt nahe, den Fixpunkt durchsukzessive Substitution zu suchen: x0 → g(x0)→ g(g(x0))→ . . ..

5.1 Sukzessive Substitution

Eine Abbildung g : M → M mit M ⊂ Rn heißt Lipschitz-stetig (L-stetig), falls es einL ∈ R gibt, so dass

‖g(x)− g(y)‖ ≤ L ‖x− y‖ ∀x,y ∈M. (5.3)

71


Alle auf M differenzierbaren Funktionen mit beschränkter Ableitung sind L-stetig, wennihre Ableitung beschränkt ist. Die Lipschitzkonstante ergibt sich aus dem Mittelwertsatzzu L = maxx∈M ‖g′(x)‖. Es gibt allerdings noch mehr L-stetige Funktionen, zum Beispieldie in 0 nicht differenzierbare Betragsfunktion, die auf ganz R L-stetig mit L = 1 ist.Auf der anderen Seite ist offenbar jede L-stetige Funktion auch stetig, d. h. , die L-stetigen Funktionen sind eine eigene Klasse zwischen den stetigen und differenzierbarenFunktionen. Dabei ist es nicht wesentlich, welche Norm ‖·‖ genutzt wird. Sie kann fürdas Problem geeignet gewählt werden, sofern sie die üblichen Bedingungen an eine Norm,wie etwa die Dreiecksungleichung, erfüllt.Hat eine Funktion g : M → M eine Lipschitz-Konstante L < 1, so heißt g kontra-

hierend, weil zwei verschiedene Punkte durch die Abbildung stets näher aneinander ge-schoben werden. Wir betrachten nun einen beliebigen Startpunkt x0 ∈M und definierendamit die Folge der sukzessiven Substitution:

xn := g(xn−1) für n ≥ 1. (5.4)

Dann gilt für alle n,m ∈ N der Banachsche Fixpunktsatz

‖xn+m − xn‖ =

∥∥∥∥∥m−1∑k=0

xn+k+1 − xn+k

∥∥∥∥∥ ≤m−1∑k=0

‖xn+k+1 − xn+k‖

= ‖g(g(. . . g(xn+1)))− g(g(. . . g(xn)))‖+ · · ·+ ‖g(g(xn+1))− g(g(xn))‖+ ‖g(xn+1)− g(xn)‖+ ‖xn+1 − xn‖

≤m−1∑k=0

Lk ‖xn+1 − xn‖ ≤1

1− L‖xn+1 − xn‖ ≤

Ln

1− L‖g(x0)− x0‖ .

(5.5)

Die sukzessive Substitution definiert also eine Cauchyfolge, die in M konvergiert, sofernM abgeschlossen ist (z. B. M = Rn oder M Einheitskugel). Für den Grenzwert x dieserFolge gilt

x = limn→∞

xn+1 = limn→∞

g(xn) = g(x), (5.6)

er ist also ein Fixpunkt.Wir betrachten nun zwei Fixpunkte x und y. Dann gilt

‖x− y‖ = ‖g(x)− g(y)‖ ≤ L ‖x− y‖ =⇒ x = y. (5.7)

Das bedeutet, dass es nur genau einen Fixpunkt x von g inM gibt, und dass die sukzessiveSubstitution für jeden Startwert global gegen x konvergiert. (5.5) gibt auch eine a priori-Abschätzung des Fehlers:

‖x− xn‖ ≤Ln

1− L‖g(x0)− x0‖ (5.8)

sowie eine Abschätzung der Konvergenzrate:

‖xn+1 − x‖‖xn − x‖

=‖g(xn)− g(x)‖‖xn − x‖

≤ L < 1. (5.9)

72

5.1 Sukzessive Substitution

0.0 0.1 0.2 0.3 0.4 0.50.0

0.1

0.2

0.3

0.4

0.5

x0 x1x2

0.0 0.5 1.0 1.5 2.0 2.5 3.0 3.5 4.00.0

0.5

1.0

1.5

2.0

2.5

3.0

3.5

4.0

x0 x9x10

Abbildung 5.1: Sukzessive Substitution mit Funktion g(r) = e−r/φ0 mit φ0 = 2 (links)und φ0 = 1/4 (rechts). Blau durchgezogen ist die Funktion g, die Winkelhalbierendeist schwarz dargestellt. Die Punkte auf der Winkelhalbierenden markieren die Punkte(x1,x1), (x2,x2) usw. , durch die das Lot auf g gefällt wird, um den nächsten Punktder sukzessiven Substitution zu erhalten. Im linken Graph sind die ersten sieben Gliederdargestellt, und die lineare Konvergenz ist gut zu sehen. Im rechten Graph konvergiertdas Verfahren nicht, da die Lipschitzkonstante L größer als 1 ist.

Die sukzessive Substitution konvergiert also linear. Das Verfahren wird abgebrochen,wenn ‖xn+1 − xn‖ hinreichend klein ist, da dann nach (5.5) auch

‖x− xn‖ ≤1

1− L‖xn+1 − xn‖ . (5.10)

Offenbar konvergiert die sukzessive Substitution um so schneller, je kleiner die Lipschitz-konstante L ist.Neben der globalen Konvergenzeigenschaft konvergiert die sukzessive Substituion auch

lokal: ist g : Rn → Rn eine differenzierbare Funktion und hat einen Fixpunkt x mit‖g′(x)‖ < 1, so gibt es eine Umgebung des Fixpunktes, in dem die sukzessive Substitutiongegen diesen Fixpunkt konvergiert.

5.1.1 Beispiel

Als Beispiel für eine Anwendung des Banachschen Fixpunktsatzes betrachten wir die di-mensionslose Form des Yukawa- oder Debye-Hückel-Potentials φ(r) = e−r/r. Wir fragenuns, wann für welches r dieses Potential einen gegeben Wert φ0 annimmt. Das führt zuder Fixpunktgleichung

g(r) =e−r

φ0= r (5.11)

73


Die linke Seite ist eine auf [0,∞) L-stetige Funktion mit L = 1/φ0, wie man durchAbleiten leicht sieht.Abbildung 5.1 zeigt die sukzessive Substitution für g(r). Graphisch lässt sich das Ver-

fahren visualisieren, indem in jeder Iteration der Funktionswert xn+1 = y = g(xn) ander Winkelhalbierenden y = x auf die x-Achse zurückgespiegelt wird. Im linken Graphist φ0 = 2 und damit L = 1/2, so dass die sukzessive Substitution linear konvergiert.Für das letzte abgebildete Glied, x7, gilt |x7 − x| ≤ 1/28 = 1/256. Im rechten Graph istφ0 = 1/4 und damit L = 4. Insbesondere ist auch im Fixpunkt g′(x) > 1. Abgebildetsind die ersten zehn Glieder der sukzessiven Substitution, die hier nicht mehr konvergiert,obwohl wir nahe am Fixpunkt gestartet haben.

5.2 Newtonverfahren in einer Dimension

Nachdem wir bis jetzt die sukzessive Substitution zur Bestimmung von Fixpunkten be-trachtet haben, geht es nun um die Nullstellensuche. Sei also zunächst eine stetig diffe-renzierbare Funktion f : [a,b] → R gegeben und deren Nullstellen x, f(x) = 0, gesucht.Ähnlich wie bei der sukzessiven Iteration starten wir mit einem Startwert x0. Um unsnun der Nullstelle der Funktion zu nähern, linearisieren wir in der aktuellen Näherungxn und lösen nach der Nullstelle xn+1 auf:

xn+1 = g(xn) := xn −f(xn)

f ′(xn)für n ≥ 0, (5.12)

wobei wir annehmen, dass f ′(x) 6= 0 auf [a,b]. Für eine Nullstelle x von f gilt offenbarg(x) = x, d. h. wir suchen einen Fixpunkt von g, den wir wieder durch sukzessive Substi-tution annähern können. Man bricht das Verfahren wie auch die sukzessive Substitutionab, wenn |xn − xn−1| bzw. |f(xn)| hinreichend klein sind.Ist nun f sogar zweifach stetig differenzierbar, so gilt

g′(x) = 1− f ′(x)2 − f(x)f ′′(x)

f ′(x)2=f(x)f ′′(x)

f ′(x)2=⇒ g′(x) = 0. (5.13)

Das Newtonverfahren konvergiert also zumindest lokal gegen einen Fixpunkt x von gbeziehungsweise eine Nullstelle von f . Tatsächlich konvergiert das Verfahren wenigstensquadratisch, wenn f zweifach differenzierbar ist, da

xn+1 − x =(xn − x)f ′(xn)− f(xn)

f ′(xn)=

(xn − x)

f ′(xn)

(f ′(xn)− f(xn)− f(x)

xn − x

)=

(xn − x)

f ′(xn)

(f ′(xn)− f ′(ξ′)

)=

(xn − x)(xn − ξ′)f ′(xn)

f ′′(ξ) (5.14)

und somit|xn+1 − x||xn − x|2

≤maxξ∈[a,b] |f ′′(ξ)|minξ∈[a,b] |f ′(ξ)|

(5.15)

Ist f nur differenzierbar, so lässt sich ähnlich zeigen, dass das Newtonverfahren super-linear konvergiert. Das Newtonverfahren konvergiert also in jedem Fall schneller als die

74

5.2 Newtonverfahren in einer Dimension

0.0 0.1 0.2 0.3 0.4 0.5

0

5

10

15

20

x0 x1 x2 x3 x4x5

0.50 0.75 1.00 1.25 1.50 1.75 2.00

0.2

0.1

0.0

0.1

0.2

0.3

0.4

0.5

x0x1 x2 x3

Abbildung 5.2: Newtonverfahren für die Funktion f(r) = e−r/r − φ0. Wie schon beimGraphen zur sukzessiven Substitution ist links φ0 = 2, rechts φ0 = 1/4, allerdings kon-vergiert das Newtonverfahren für beide Werte. Blau dargestellt ist f , die roten, dickenLinien stellen die Tangenten dar, deren Nullstellen die neuen Näherungen für die gesuchteNullstelle von f sind.

sukzessive Substitution, erfordert allerdings eine mindestens stetig differenzierbare Funk-tion.Bis jetzt haben wir nur die lokale Konvergenz des Newton-Verfahrens. Ist die Ziel-

funktion f ∈ C1([a,b]) allerdings konvex bzw. konkav, also f ′ monoton wachsend bzw.fallend und beschränkt, und hat f eine Nullstelle in [a,b], so kann man zeigen, dass dasNewtonverfahren global gegen eine Nullstelle x von f in [a,b] konvergiert. Dabei ist dasVerfahren nach dem ersten Schritt monoton, d. h. entweder x1 ≤ x2 ≤ . . . ≤ x oderx1 ≥ x2 ≥ . . . ≥ x.In SciPy gibt es natürlich auch das Newtonverfahren sowie einige verbesserte Algo-

rithmen. Das Newtonverfahren ist als scipy.optimize.newton(f, x0, df) im-plementiert, wobei f und df die Funktion f und ihre Ableitung df/dx angeben, und x0der Startwert des Newtonverfahrens.

5.2.1 Beispiel

Wir betrachten wieder die Aufgabe e−r/r = φ0, bzw. f(r) = e−r/r − φ0 = 0. DieAbleitung dieser Funktion ist −e−r(1+r)/r2, f fällt also monoton. Daher konvergiert dasNewtonverfahren global und monoton, wie in Abbildung 5.2 zu sehen. Im linken Graphenist r0 < r, daher startet das Verfahren sofort monoton. Im rechten Graphen ist r0 < r.Hier wird im ersten Schritt r1 < r, und erst dann wächst die Näherung wieder monoton.In jedem Fall konvergiert das Newtonverfahren, anders als die sukzessive Substitution,

75


für beide Werte von φ0 innerhalb weniger Schritte zuverlässig gegen die Nullstelle.

5.2.2 Wurzelziehen

Wir betrachten die Gleichung f(x) = xk − a auf der positiven Halbachse. Dann konver-giert für jeden Startwert x0 > 0 das Newtonverfahren

xn+1 = xn −f(xn)

f ′(xn)=

(1− 1

k

)xn +

1

k

a

xk−1n

(5.16)

gegen die einzige Nullstelle von f , nämlich die k-te Wurzel aus a. Sinnvollerweise wähltman daher x0 = a als Startwert. Für k = 2 ergibt sich das Heron-Verfahren xn+1 =12

(xn + a

xn

), das bereits im 2. Jhdt. vor Christus zum Wurzelziehen benutzt wurde.

Für die Wurzel aus a = 2 sind die ersten 5 Schritte des Heronverfahrens:

Schritt n xn Anzahl korrekter Stellen0 1.000000000000000 11 1.500000000000000 12 1.416666666666667 23 1.414215686274510 54 1.414213562374690 115 1.414213562373095 15

Mit der auf Rechnern üblichen doppelten Genauigkeit ist das Verfahren damit auskon-vergiert.Die Anzahl der Rechenoperationen für n Schritte entspricht der Auswertung eines Poly-

noms mit 3n/2 Koeffizienten. Wäre man zum Beispiel nur an der Wurzel im Bereich [0,5]interessiert und würde hierzu ein interpolierendes Polynom mit 7 Chebyshev-Stützstellennutzen, wäre

√2 ≈ 1.40966 mit gerade einmal einer korrekten Stelle. Mit einer Taylor-

entwicklung um 1 würde es etwas besser. Bei 7 Termen liefert diese√

2 ≈ 1.4214 mit 2korrekten Stellen.Für k = −1 wird aus der Wurzelaufgabe eine Division, da wir die Nullstelle der Funk-

tion f(x) = 1x − a suchen. Die Lösung kann nur mit Hilfe der Grundrechenarten durch

die Iterationxn+1 = xn −

f(xn)

f ′(xn)= 2xn − ax2

n (5.17)

bestimmt werden. Allerdings ist die Ableitung von a/x unbeschränkt, daher konvergiertdas Verfahren nur für Startwerte, die hinreichend nah an der Lösung sind. Wie mansich in diesem Fall leicht überlegt, konvergiert das Verfahren nur für xo ∈ (0, 2/a), wasschwierig zu erfüllen ist, ohne a−1 bereits zu kennen.

5.2.3 Nullstellen von Polynomen

Ist p ein Polynom, so lassen sich dessen Nullstellen (approximativ) mit Hilfe des New-tonverfahrens bestimmen:

xn+1 = xn −p(xn)

p′(xn), (5.18)

76

5.3 Sekantenmethode

0.0 0.1 0.2 0.3 0.4 0.5

0

5

10

15

20

x1 x2 x3 x4 x5

0.50 0.75 1.00 1.25 1.50 1.75 2.00

0.2

0.0

0.2

0.4

0.6

x1x2 x3x4

Abbildung 5.3: Sekantenmethode für die Funktion f(r) = e−r/r−φ0. Wie zuvor ist linksφ0 = 2, rechts φ0 = 1/4. Blau dargestellt ist wieder f , die roten, gestrichelten dickenLinien stellen die Sekanten dar, deren Nullstellen die neuen Näherungen für die gesuchteNullstelle von f sind. Durchgezogen ist der Abschnitt der Sekante durch xn−1 und xn,der von xn zu xn+1 führt.

wobei p(xn) und p′(xn) durch ein modifiziertes Hornerschema bestimmt werden können.Die folgende Routine berechnet effizient xn+1 aus xn:

def poly_newton_step(series, xn):n = len(series) - 1p = series[n]dp = n*series[n]for i in range(n - 1,0,-1):

p = p*xn + series[i]dp = dp*xn + i*series[i]

p = p*xn + series[0]return xn - p/dp

Das Newtonverfahren liefert natürlich nur eine Nullstelle des Polynoms. Durch die Po-lynomdivision, wieder mit Hilfe des Hornerschemas wie in Abschnitt 3.1, lässt sich dieseaber abspalten und das Newtonverfahren erneut starten, bis alle Nullstellen gefundensind.

5.3 Sekantenmethode

In vielen Fällen ist es nicht einfach oder unmöglich, die Ableitung einer Funktion zubestimmen. In diesem Fall kann man die Ableitung durch die dividierte Differenz annä-

77


hern, wobei nun zwei Startpunkte x0 und x1 gebraucht werden. Dies führt dazu, dassdie Näherungsfunktion keine Tangente mehr ist, wie beim Newtonverfahren, sondern imAllgemeinen eine Sekante. Daher rührt der Name der Sekantenmethode

xn+1 = xn − f(xn)xn − xn−1

f(xn)− f(xn−1), (5.19)

die nicht mehr quadratisch, aber wenigstens superlinear konvergiert.Das Bestimmen der Ableitung von f ist immer dann unmöglich, wenn f sehr kom-

plex ist. Ein Extremfall wäre eine Molekulardynamik-Computersimulation, bei der zumBeispiel in Abhängigkeit vom aktuellen Volumen V der mittlere Druck P (V ) in einemgegebenen System bestimmt wird. Den mittleren Druck nach V abzuleiten, ist vollkom-men aussichtslos, wenn die Wechselwirkungen zwischen den Teilchen hinreichend komplexsind. Dabei ist es von großem Interesse, dasjenige Volumen zu bestimmen, für das P (V )gleich einem vorgegebenen Außendruck P0 ist, denn dies ist die natürliche Bedingung imisobarischen Ensemble. Dies führt aber zur Nullstellengleichung P (V )− P0 = 0.Als Beispiel für die Sekantenmethode soll ein weiteres Mal die Funktion f(r) = e−r/r−

φ0 dienen. Für diese zeigt Abbildung 5.3 die ersten paar Schritte der Sekantenmethode.Unter geeigneten Umständen, nämlich, wenn die angenäherte Tangente hinreichend gutmit der tatsächlichen über einstimmt, konvergiert die Sekantenmethode praktisch genausogut wie das normale Newtonverfahren. Sind die Startpunkte allerdings ungünstig gewählt,wie im rechten Beispiel, so kann es passieren, dass diese abwechselnd um die Nullstelleliegen, und damit nicht mehr monoton konvergieren.In SciPy implementiert scipy.optimize.newton(f, x0) (also bei Nichtangabe

der Ableitung) die Sekantenmethode. f ist wieder die Funktion, deren Nullstelle gesuchtwird, und x0 ein Startwert. Der zweite wird hardcodiert in einer Umgebung von x0gewählt, kann also vom Benutzer nicht gesetzt werden.

5.4 Bisektion

Wie wir gesehen haben, konvergiert das Newtonverfahren und seine Varianten sehrschnell, allerdings oft nur unter der Voraussetzung, dass der Startwert hinreichend nahan einer Nullstelle liegt. Wie aber kann man einen solchen Startwert finden? Hierfür wirdein langsameres, robusteres Verfahren gebraucht, zum Beispiel das Bisektionsverfahrenin einer Dimension.Sei also wieder f ∈ C([a,b]) eine stetige Funktion, und f(a)f(b) < 0. Dann hat f

gemäß Mittelwertsatz wenigstens eine Nullstelle im Intervall [a,b], die wir suchen. Dazusetzen wir zunächst a0 = a und b0 = b. Dann betrachten wir den Intervallmittelpunkt

mn =an + bn

2. (5.20)

Ist f(mn) = 0, so ist mn die gesuchte Nullstelle, und das Verfahren bricht ab. Istf(mn)f(an) < 0, hat die Funktion also bei mn und an unterschiedliche Vorzeichen, somuss eine Nullstelle im halb so großen Intervall a1 = a0, b1 = m0 liegen, mit dem wir nun

78

5.5 Regula falsi

weiter verfahren. Andernfalls ist notwendigerweise f(mn)f(bn) < 0, und die Nullstelle istim neuen Intervall a1 = m0, b1 = b0. Ist bn − an kleiner als die gewünschte Genauigkeitfür die Nullstelle, bricht man ebenfalls ab. mn ist dann eine Näherung für die Nullstellemit der gewünschten Genauigkeit.Das Verfahren halbiert in jedem Schritt die Intervallgröße und damit auch den maxi-

malen Abstand der Näherung zur tatsächlichen Nullstelle x. Es gilt also

|mn+1 − x||mn − x|

≤ 1

2, (5.21)

das Verfahren konvergiert also nur linear, dafür aber global.Der Vorteil der Bisektion ist, dass diese Methode im Allgemeinen auch noch einiger-

maßen zufriedenstellend funktioniert, falls nicht nur die Ableitungen unbekannt sind,sondern sogar die Funktionswerte gar nicht genau bekannt sind. Dies wäre zum Beispielbei der bereits angesprochenen Messung des Drucks in einer Simulation der Fall, da die-ser starken Schwankungen unterliegt. Dadurch kann man meist den Druck in akzeptablerRechenzeit nicht so gut mitteln, dass dessen Messfehler vernachlässigt werden kann. DieBisektion muss in diesem Fall schon abgebrochen werden, sobald der Funktionswert aneiner der Grenzen innerhalb des Fehlerbalkens Null ist.In der Praxis kombiniert man die Bisektion mit dem Newtonverfahren, indem zunächst

einige Schritte des Bisektionsverfahrens durchgeführt werden, und dann vom Intervall-mittelpunkt aus das Newtonverfahren. Konvergiert dieses, so ist man fertig. Läuft dasNewtonverfahren aus dem Bisektionsinterval heraus, verkleinert man dieses durch weitereBisektionsschritte, und versucht dann erneut, das Newtonverfahren anzuwenden.In SciPy implementiert scipy.optimize.bisect(f, a, b) mit der Funktion f

und Intervallgrenzen a und b die Bisektion. scipy.optimize.brentq(f, a, b)implementiert die Brentsche Methode, die unter den selben Bedingung wie die Bisektionkonvergiert, aber meist wesentlich schneller.

5.4.1 Beispiel

In Abbildung 5.4 dient uns ein letztes Mal die Funktion f(x) = e−r/r−2 als Beispiel fürdie Bisektion. Mit sieben Schritten schließt diese bei Startinterval [0,1, 1] die Nullstellebis auf [0,3391, 0,3461], als etwa 10−2 genau ein. Zum Vergleich: das Newtonverfahrenmit Startwert 0,05 erreicht in sieben Schritten eine Genauigkeit von etwa 10−5, und selbstdie Sekantenmethode 10−3.

5.5 Regula falsi

Sowohl die Bisektion wie auch die Sekantenmethode benötigen zwei Startwerte. Daherliegt es nahe, die Verfahren zu kombinieren. Bei der Regula falsi wird wie bei der Bisektionein Intervall [a,b] schrittweise verkleinert so dass dieses stets wenigstens eine Nullstelleenthält. Anders als bei der Bisektion wird der neue Randpunkt m allerdings nicht einfachals Intervallmitte bestimmt, sondern mit Hilfe der Sekantenmethode, mit den beiden

79


0.0 0.2 0.4 0.6 0.8 1.01.5

1.0

0.5

0.0

0.5

1.0

0.0 0.2 0.4 0.6 0.8 1.01.5

1.0

0.5

0.0

0.5

1.0

Abbildung 5.4: Links: Bisektion für die Funktion f(r) = e−r/r−φ0, hier nur mit φ0 = 2,da die genaue Form der Funktion für diese Methode unerheblich ist. Blau dargestellt istwieder f , die grünen Balken markieren die nacheinander generierten, kleiner werdendenIntervalle [an, bn]. Die gestrichelten, schwarzen Linien markieren die Intervallmitten mn,die im nächsten Schritt eine der beiden Intervallgrenzen werden. Rechts: Regula falsifür dieselbe Funktion. Die Funktion ist streng konvex, daher reagiert die Regula falsilethargisch und ist der Bisektion unterlegen; die Intervalle verkürzen sich praktisch nichtmehr, da die untere Anfangsgrenze 1/4 nie versetzt wird, nur die obere Grenze.

Intervallrandpunkten a und b als Stützstellen:

m = b− f(b)b− a

f(b)− f(a)=f(b)a− f(a)b

f(b)− f(a). (5.22)

Da f(a)f(b) < 0, schneidet die Sekante die Nulllinie immer im Intervall. Dadurch ver-kleinert sich das Intervall schneller als beim Bisektionsverfahren, sofern die Nullstelle derSekante dicht an der echten Nullstelle liegt.Leider gilt dies aber nur, wenn die Funktion im Intervall eine Wendepunkt hat. Ist dies

nicht der Fall, wenn die Funktion im Intervall also konkav oder konvex ist, dann wirddie Regula falsi sehr langsam, was auch als Lethargie bezeichnet wird. Der Grund ist,dass eine der beiden Intervallgrenzen sehr dicht an die Nullstelle rückt und im folgendennur noch diese Grenze minimal verbessert wird, während die zweite Grenze unverändertbleibt. Dies ist zum Beispiel in Abbildung 5.4 rechts gezeigt.Unglücklicherweise gibt es jedoch – außer wenn die Funktion genau an der Nullstelle

einen Wendepunkt hat – immer eine Umgebung um die Nullstelle, in der die Funktionstreng konkav oder konvex ist, so dass die Regula falsi immer ab einer gewissen Genauig-keit lethargisch konvergiert, daher ist die einfache Bisektion in der Regel schneller als dieRegula falsi. Die Regula falsi ist nur dann die schnellste und stabilste Nullstellensuche,

80

5.6 Newtonverfahren in mehreren Dimensionen

falls die Ableitung der Funktion nicht bekannt ist, man aber weiß, dass die Funktioneinen Wendepunkt in der Nullstelle hat.Die Regula falsi ist ein gutes Beispiel dafür, dass die Kombination zweier schneller und

robuster Verfahren keineswegs immer ein schnelleres oder robusteres Verfahren liefert.

5.6 Newtonverfahren in mehreren Dimensionen

Bis jetzt haben wir das Newtonverfahren nur für eindimensionale Funktionen betrachtet.Im Mehrdimensionalen funktioniert das Verfahren aber sehr ähnlich, wobei die Ableitungzur Jacobimatrix wird.Sei also f ∈ C1(M,Rn) eine stetig differenzierbare Abbildung von M ∈ Rn in den Rn.

Wir suchen nun eine Nullstelle x ∈ D, d. h. eine Lösung des nichtlinearen Gleichungssys-tems f(x) = 0.Wie schon im Eindimensionalen starten wir mit einer Näherung x(0) ∈ M , und be-

rechnen die nächste Näherung x(1) durch Linearisieren von f in x(0). Die Linearisierungergibt sich aus der Taylorentwicklung:

F (x(1)) =F (x(0)) + F ′(x(0))(x(1) − x(0)

), (5.23)

wobei

F ′(x) =

(d

dxjFk(x)

)k,j

=

ddx1

F1(x) . . . ddxn

F1(x)...

...ddx1

Fn(x) . . . ddxn

Fn(x)

(5.24)

die Jacobimatrix von f an der Stelle x bezeichnet. Die neue Näherung x(1) suchen wir alsNullstelle der Linearisierung (5.23), also aus der Bedingung F (x(1))

!= 0. Da wir ja damit

nur die linearisierte Gleichung gelöst haben, linearisieren wir erneut im neuen Punkt x(1),und so weiter. Ein Schritt des Newtonverfahrens ist dann also

x(i+1) = x(i) + d(i) mit F ′(x(i)) d(i) = −F (x(i)). (5.25)

Die Newtonkorrektur d(i) wird aus der Lösung eines linearen Gleichungssystems gewon-nen, zum Beispiel mit Hilfe der Gaußelimination. Allerdings ist f ′ im Allgemeinen vollbe-setzt, daher verwendet man normalerweise schnellere, approximative Verfahren, die wirspäter kennenlernen werden. Ist F ′(x(i)) in einem Schritt singulär, so bricht das Verfahrenab. Ansonsten wird weiter iteriert, bis

∥∥d(i)∥∥ hinreichend klein ist.

Auch im Mehrdimensionalen konvergiert dieses Verfahren lokal mindestens quadra-tisch, sofern in einer abgeschlossenen Umgebung der Nullstelle

∥∥F ′(x)−1∥∥ beschränkt

ist und f zweifach stetig differenzierbar. Allerdings gibt es kein langsames Verfahrenähnlich der Bisektion, dass man dem Vefahren vorausschicken könnte, um die Nullstelleeinzugrenzen. Die globale Suche nach Nullstellen in mehreren Dimensionen ist also eineschwierige Aufgabe. Eine Möglichkeit ist, zunächst mit Hilfe von Optimierungsverfahrenein x(0) zu finden mit möglichst kleiner Norm

∥∥f(x(0))∥∥, und von dort das (gedämpfte)

Newtonverfahren zu starten. Die globale Optimierung in vielen Dimensionen ist selbereine sehr schwierige Aufgabe, allerdings existieren hierfür Ansätze wie genetische Algo-rithmen oder Simulated Annealing, die wir später kennenlernen werden.

81


# Gedaempftes Newtonverfahren#############################

def gedaempfter_newton(f, fprime, x0, epsilon):xi = x0konvergiert = Falsewhile not konvergiert:

# Newton-Korrekturdi = solve(fprime(xi), f(xi))if norm(di) < epsilon:

konvergiert = Trueelse:

# Schrittweitendaempfunglambda = 1.0abstieg = Falsewhile not abstieg:

# neue Naeherungxneu = xi + lambda*diif norm(f(xneu)) < norm(f(xi)):

abstieg = Trueelse:

lambda = lambda / 2.0xi = xneu

return xi

Listing 5.1: Gedämpftes Newtonverfahren in mehreren Dimensionen. f(x) muß eine vek-torwertige Funktion sein, fprime(x) ihre Ableitung, d.h. eine matrixwertige Funktion.

5.6.1 Gedämpftes Newtonverfahren

Leider ist im Mehrdimensionalen die Umgebung um die Nullstelle, in der das Verfahrenkonvergiert, oftmals deutlich kleiner. Das Verfahren springt dann leicht über die Nullstellehinweg, wie es im Eindimensionalen nur am Anfang des Verfahrens vorkommt (z. B. Ab-bildung 5.2 rechts, im ersten Schritt). Um dies zu verhindern, kann man die Schrittweitereduzieren, also den Schritt d(i) verkürzen. Die Iteration lautet dann

x(i+1) = x(i) + λd(i) mit F ′(x(i)) d(i) = −F (x(i)), (5.26)

wobei die Dämpfung λ ∈ (0,1] so gewählt wird, dass∥∥F (x(i+1))

∥∥ ≤ ∥∥F (x(i))∥∥. Dazu wird

zum Bespiel mit λ = 1 begonnen, und λ solange verringert, bis die Bedingung erreichtist. Der Rechenaufwand für die Iteration ist klein, da nur die Norm der Funktionswerteberechnet werden muss, was mit linearem Zeitaufwand möglich ist. Eine Neuberechnungdes Schritts d(i) hingegen erfordert die Lösung eines Gleichungssystems, was mit der Gau-ßelimination O(N3) Rechenschritte erfordert. Für vieldimensionale Probleme dominiertdieser Aufwand klar. Eine Beispielimplementation des gedämpten Newtonverfahrens zeigtListing 5.1.

82

6 Numerisches Differenzieren undIntegrieren

In diesem Kapitel geht es darum, wie eine Funktion, die an diskreten Stützstellen gege-ben ist, numerisch differenziert und integriert werden kann. Die Grundlagen dazu wurdenbereits mit dem Kapitel “Darstellung von Funktionen” gelegt: für die numerische Ablei-tung liegt es nahe, aus der Taylorentwicklung geeignete Ausdrücke für die Ableitungenzu gewinnen, und für die Integration bieten sich das interpolierende Polynom oder auchein Spline an, die sich mit dem Computer leicht analytisch integrieren lassen.Numerisches Integrieren und Differenzieren kann dabei nicht nur dazu dienen, Inte-

grale oder Ableitungen abzuschätzen, sondern erlaubt auch, einfache Differential- oderIntegralgleichungen numerisch zu lösen. Dazu muss die Gleichung mit Hilfe der hier vor-gestellten Verfahren diskretisiert und das resultierende lineare Gleichungssystem gelöstwerden.

6.1 Numerisches Differenzieren

Die erste Ableitung einer Funktion f ∈ C1([a,b]) ist definiert als

limh→0

f(x+ h)− f(x)

h. (6.1)

Um den Grenzwert abzuschätzen, liegt es nahe, die Ableitung durch die dividierte Diffe-renz

f ′(ξ) ≈ f [x,y] :=f(x)− f(y)

x− y(6.2)

anzunähern, wobei x und y beide nahe bei ξ liegen sollten.Doch an welchem Punkt ξ ist diese Näherung optimal? Gemäß Mittelwertsatz gilt auf

jeden Fall f [x,y] = f ′(ξ) für ein ξ ∈ [x,y]. Man erwartet daher, dass f [x,y] am bestenin der Intervallmitte m = x+y

2 approximiert. Das ist tatsächlich so, wie wir nun perTaylorentwicklung sehen werden. Mit Entwicklung um m und h = x− y gilt

f(x)− f(y)

x− y=

1

h

(f(m) +

h

2f ′(m) +

h2

8f ′′(m) +O(h3)

− f(m) +h

2f ′(m)− h2

8f ′′(m) +O(h3)

)= f ′(m) +O(h2). (6.3)

83

6 Numerisches Differenzieren und Integrieren

Bei Ansatzpunkt x gilt hingegen nur

f(x)− f(y)

x− y=

1

h

(f(x) + hf ′(x) +

h2

8f ′′(x) +O(h3)− f(x)

)= f ′(x) +O(h). (6.4)

In der Praxis ist die Funktion meist an an äquidistanten Stützstellen xi mit xi+1−xi =h gegeben. Dann ist, wie oben gezeigt, die beste Zweipunkt-Näherung für die Ableitungdie zentrale Differenz

f(xi+1)− f(xi−1)

2h= f [xi−1,xi+1] = f ′(xi) +O(h2), (6.5)

während für die linken und rechten dividierten Differenzen gilt:

f(xi+1)− f(xi)

h= f [xi,xi+1] = f ′(xi) +O(h) (6.6)

bzw.f(xi)− f(xi−1)

h= f [xi,xi−1] = f ′(xi) +O(h). (6.7)

6.1.1 Näherungen höherer Ordnung und höhere Ableitungen

Mit Hilfe von Taylorentwicklungen lassen sich auch Näherungen mit mehr Stützpunktenund für höhere Ableitungen entwickeln. Wir betrachten zum Beispiel die Punkte fürk = −2(1)2, d. h. die 5 benachbarten Punkte, und suchen Koeffizienten ck derart, dass

c2f(xi+2) + c1f(xi+1) + c0f(xi) + c−1f(xi−1) + c−2f(xi−2) = f ′(xi) +O(h5), (6.8)

unabhängig von der Form von f und seiner Ableitungen. Durch Einsetzen der Taylorent-wicklung

f(x+ kh) = f(x) + k hf ′(x) + k2 h2

2f ′′(xi) + k3 h

3

6f (3)(x) + k4 h

4

24f (4)(x) +O(h5) (6.9)

können wir nun die obige Gleichung auf beiden Seiten als Vielfache von f(x), f ′(x),f ′′(x) usw. schreiben. Da unsere Koeffizienten unabhängig von diesen sein sollen, müssendie Vorfaktoren vor diesen auf beiden Seiten übereinstimmen. Diese sind, beginnend beif(x):

c2 + c−2 + c−1 + c1 + c0 = 0

h [2(c2 − c−2) + c1 − c−1] = 1

h2

2[4(c2 + c−2) + c1 + c−1] = 0

h3

6[8(c2 − c−2) + c1 − c−1] = 0

h4

24[16(c2 + c−2) + c1 + c−1] = 0. (6.10)

84


Durch Lösen des Gleichungssystems folgt

− 1

12hf(xi+2) +

2

3hf(xi+1)− 2

3hf(xi−1) +

1

12hf(xi−2) = f ′(xi) +O(h4). (6.11)

Auf diese Weise lässt sich auch die höhere Güte der zentralen Differenz verstehen: tat-sächlich entspricht diese der optimalen Näherung durch xi−1, xi und xi+1, nur dass ausSymmetriegründen der Koeffizient zu xi verschwindet.

Um nun zum Beispiel die zweite Ableitung zu berechnen, lösen wir (6.10), allerdingsmit einer 1 nicht in der zweiten, sondern dritten Zeile. Das ergibt

1

h2

(− 1

12f(xi+2) +

4

3f(xi+1) +

5

2f(xi) +

4

3f(xi−1)− 1

12f(xi−2)

)= f ′′(xi) +O(h4).

(6.12)Die Fehlerordnung ist hier um eins höher als man erwarten würde, da für den Termdritter Ordnung der Vorfaktor ebenfalls verschwindet:

1

12· 8− 4

3+

4

3− 1

12· 8 = 0. (6.13)

Mit drei Stützpunkten ergibt sich die Näherung für die zweite Ableitung analog als

1

h2

(f(xi+1) − 2f(xi) + f(xi−1)

)=

f(xi+1)−f(xi)h − f(xi)−f(xi−1)

h

h= f ′′(xi) + O(h2).

(6.14)

Die mittlere Form zeigt, dass sich diese einfachste Form der zweiten Ableitung auch alsdividierte Differenz der dividierten Differenzen verstehen lässt. Technisch wird also diezweite Ableitung also einfach in erster Ordnung aus der ersten Ableitung in erster Ord-nung bestimmt. Analog lässt sich jede n-te Ableitung aus n+1 benachbarten Stützstellenin erster Ordnung durch dividierte Differenzen approximieren.

6.1.2 Genauigkeit

Generell sind alle diese Näherungen numerisch instabil, da bei kleinen Abständen h auchf(x) und f(x + h) sehr ähnlich sind. Sind diese betragsmäßig groß, kommt es zu Aus-löschung, d. h. , f(x + h) − f(x) hat deutlich weniger signifikante Stellen als Maschi-nengenauigkeit. Daher gibt es stets ein optimales h, das allerdings von der unbekanntenzweiten Ableitung der betrachteten Funktion abhängt.Auch Verfahren höherer Ordnung sind nicht notwendigerweise genauer, da bei manchen

Funktionen die Ableitungen sehr rasch wachsen. Dann ist zwar h4 sehr viel kleiner als h2,aber der Vorfaktor kompensiert das zunächst. Abbildung 6.1 illustriert dieses Verhaltenam Beispiel der Funktion sin(100x2). Erst, wenn die Schrittweite h unter die charakte-ristische Breite von etwa 600 sinkt, spielt die Ordnung des Verfahrens eine Rolle. Wirdallerdings h zu klein, zeigt sich die endliche Auflösung, mit der der Rechner arbeitet, undder Fehler steigt wieder an.

85


10-12 10-10 10-8 10-6 10-4 10-2 100

h

10-8

10-7

10-6

10-5

10-4

10-3

10-2

10-1

100

101

102

103

Abbildung 6.1: Maximale Abweichung maxx∈[−π,π] |f ′(x)− a(h;x)| für verschiedene Nä-herungen a(h;x), als Funktion der Schrittweite h. Die Funktion ist f(x) = sin(100x2).Rot durchgezogen ist die linksseitige Differenz a(h;x) = (f(x) − f(x − h))/h, die zen-trale Differenz a(h;x) = (f(x+ h)− f(x− h))/2h ist grün gepunktet und die Näherung4. Ordnung (6.11) blau gestrichelt. Der rechtsseitige Abfall der Kurven entspricht denOrdnungen O(h) für die linksseitige Differenz, O(h2) für die rechtsseitige und O(h4) fürdie Gleichung 4. Ordnung. Das linksseitige Verhalten ist methodenunabhängig und durchdie endliche Rechenauflösung bestimmt.

6.1.3 Beispiel: Besselsche Differentialgleichung

Wir betrachten die Besselsche Differentialgleichung, eine gewöhnliche lineare Differenti-algleichung zweiter Ordnung:

x2d2f

dx2+ x

df

dx+ (x2 − ν)f = 0 (6.15)

für f ∈ C∞([0,∞)). Die Besselsche Differentialgleichung spielt eine wichtige Rolle inder Physik, weil sie den radialen Anteil der Laplacegleichung in Zylinderkoordinaten be-schreibt. Für die Lösungen dieser Gleichung lassen sich schnell konvergierende Reihenoder Integraldarstellungen angeben [AS70; Jac99], wir wollen aber zu Demonstrations-zwecken diese Differentialgleichung für ν = 0 numerisch lösen. Hierzu definieren wirfk := f(kh), k ≥ 0, und diskretisieren (6.15) mit Hilfe der finiten Differenzen (6.5) und(6.14) in linearer Ordnung:

0 = k2 (fk−1 − 2fk + fk+1) + k

(1

2fk+1 −

1

2fk−1

)+ k2h2fk

=

(k2 − 1

2k

)fk−1 + k2(h2 − 2)fk +

(k2 +

1

2k

)fk+1. (6.16)

86


0 2 4 6 8 10 12 140.5

0.0

0.5

1.0

Abbildung 6.2: Numerische Lösungen der Besselschen Differentialgleichung auf [0,15] mitSchrittweite h = 0,5 und N = 31 Stützpunkten. Die durchgezogene schwarze Liniemarkiert die analytische Lösung. Mit grünen Rauten ist die Lösung mit Hilfe von (6.16)und Dirichletrandbedingungen dargestellt, für die roten Sterne wurden Funktionswertund Ableitung bei 0 festgelegt. Blaue Punkte schließlich markieren den Löser dritterOrdnung mit Dirichletrandbedingungen, der von der analytischen Lösung praktisch nichtzu unterscheiden ist.

Für die Lösung f auf dem endlichen Intervall [0, (N − 1)h] sind das N − 2 Gleichungen,da zumindest für die Randpunkte die zweite Ableitung so nicht abgeschätzt werdenkann. Dies ist aber auch nicht weiter verwunderlich, da wir ja die Randbedingungennoch nicht festgelegt haben. Die natürlichen Randbedingungen der Diskretisierung sindalso Dirichlet-Randbedingungen, bei denen die fehlenden Randwerte vorgegeben werden:f0 = f(0) = F0 und fN−1 = f((N − 1)h) = FN−1.Wir erhalten das folgende lineare Gleichungssystem:

1 0 0 . . . . . . 01/2 −λ 3/2 0 . . . 00 3 −4λ 5 0 . . . 0

. . . . . . . . .0 . . . 0 k2 − k

2 −k2λ k2 + k2

0 . . . 0 1

f0

...fN−1

=

F0

00...0

FN−1

, (6.17)

wobei λ = (2−h2). Die beiden äußeren Zeilen implementieren die Dirichletbedingungen,die restlichen Zeilen Gleichung (6.16) für k = 1(1)N − 1. Da die Matrix Bandstrukturhat, können wir dieses lineare Gleichungssystem effizient mit dem Gaußverfahren lösen.Beispielcode 6.1 zeigt ein Pythonskript zur Lösung dieses Gleichungssystems. Dessen

87


Lösung für h = 0,5 ist in Abbildung 6.2 mit grünen Rauten gezeigt und weicht noch signi-fikant ab, was allerdings durch die hohe Schrittweite bedingt ist. Mit einer Schrittweiteh < 0,1 gäbe es keine sichtbaren Abweichungen mehr.Alternativ können wir statt der Dirichlet-Randbedingungen auch Funktion f(0) = F0

und Ableitung f ′(0) = F ′0 am linken Rand festlegen. Das ergibt:

1 0 0 . . . . . . 0−1/h 1/h 0 . . . . . . 01/2 −λ 3/2 0 . . . 00 3 −4λ 5 0 . . . 0

. . . . . . . . .0 . . . 0 k2 − k

2 −k2λ k2 + k2

f0

...fN−1

=

F0

F ′00...0

. (6.18)

Dabei wird für die Ableitung am linken Rand statt der (nicht möglichen) zentralen Dif-ferenz der rechtsseitige Differenzenquotient benutzt. Allerdings zeigt Abbildung 6.2, dassdies die Lösung am linken Rand nicht verbessert. Schuld ist die geringe Genauigkeit desrechtsseitigen Differenzenquotienten. Da f ′(0) = 0 sein soll, führt er dazu, dass f0 = f1

gefordert wird, wie man auch gut in der Abbildung sieht, was aber mit der tatsächlichenLösung nichts zu tun hat. Wird statt dessen f1 korrekt vorgegeben, ist die Lösung linkstatsächlich genauer, allerdings ist bei praktischen Problemen meist f(h) nicht bekannt— sonst müsste man die Differentialgleichung ja nicht mehr lösen.Generell zeigen allerdings sowohl Dirichlet- wie auch gemischte Randbedingungen noch

leichte Artefakte. Diese lassen sich natürlich durch kleinere Schrittweite verringern, da dieLösung aber C∞ ist, kann man aber stattdessen auch auf Ableitungsnäherungen höhererOrdnung zurückgreifen, etwa (6.12) und (6.11). Dann ist die Hauptgleichung

0 =1

12(−k2 + k)fk−2 +

2

3(2k2 − k)fk−1 + k2

(h2 − 5

2

)fk

+2

3(2k2 − k)fk+1 +

1

12(−k2 + k)fk+2. (6.19)

Bei N Punkten lassen sich hierdurch nur N − 4 Gleichungen formulieren, weil ja amlinken und rechten Rand jeweils noch zwei Nachbarpunkte benötigt werden. Von diesenbenutzen wir zwei zum Beispiel als Dirichletbedingungen f0 = F0 und fN−1 = FN−1,und generieren daraus über Gleichung (6.16) Näherungen für f1 und fN−2. Die Lösungdieses Gleichungssystems ist in Abbildung 6.2 blau gepunktet eingezeichnet und fastnicht mehr von der analytischen Lösung zu unterscheiden. Dies zeigt den Nutzen vonAbleitungsnäherungen höherer Ordnung.

6.2 Quadratur: numerische Integration

Bei der numerischen Integration geht es, analog zum Differenzieren, darum, aus endlichvielen Stützwerten das Integral einer Funktion in einem endlichen Intervall abzuschätzen.

88


Listing 6.1: Numerische Lösung der Besselschen Differentialgleichung mit Hilfe von fini-ten Differenzen linearer und kubischer Ordnung. Dieser Code erzeugt Abbildung 6.2

# Bessel-Naeherung durch Loesen der# diskretisierten Differentialgleichung############################################from scipy import *from scipy.linalg import *from scipy.special import *import matplotlib.pyplot as pyplot

# Ordnung der Besselfunktionnu = 0# Rechter Randxmax = 15.0# Anzahl Punkte DifferentialN = 31# Schrittweite Differentialh = xmax/(N-1)# Stuetzpunktex = arange(0,N)*h

# 3-Punkt-Stencil, Dirichlet-Randbedingung############################################

b = zeros(N)A = zeros((N, N))

# Startwerte an den RaendernA[0, 0] = 1b[0] = jn(nu, 0)A[1, N - 1] = 1b[1] = jn(nu, (N-1)*h)

# N-2 innere Punkte von 1 bis N-2 hinter den Startwertenfor n in range(1, N-1):

# x^2 d^2f/dx^2 + x df/dx + (x^2 - nu^2)fA[n + 1, n - 1] = n**2 - 0.5*nA[n + 1, n ] = -2*n**2 + n**2*h**2 - nu**2A[n + 1, n + 1] = n**2 + 0.5*n

fx3 = solve(A, b)

# 3-Punkt-Stencil, nur linker Rand############################################

b = zeros(N)A = zeros((N, N))

# Startwert am RandA[0, 0] = 1b[0] = jn(nu, 0)# Ableitung vorgebenA[1, 0] = -1.0/hA[1, 2] = 1.0/h# Formel fuer die Ableitung der Besselfunktionenif nu == 0:

b[1] = -jn(1, 0)else:

b[1] = 0.5*(jn(nu-1, 0)-jn(nu+1, 0))

89


# N-2 innere Punkte von 1 bis N-2for n in range(1, N-1):

# x^2 d^2f/dx^2 + x df/dx + (x^2 - nu^2)fA[n + 1, n - 1] = n**2 - 0.5*nA[n + 1, n ] = -2*n**2 + n**2*h**2 - nu**2A[n + 1, n + 1] = n**2 + 0.5*n

fx3l = solve(A, b)

# 5-Punkt-Stencil, Dirichlet-Randbedingung############################################

# alles wieder auf Nullb = numpy.zeros(N)A = numpy.zeros((N, N))

# Startwerte an den Raendern, wie zuvorA[0, 0] = 1b[0] = jn(nu, 0)A[1, N - 1] = 1b[1] = jn(nu, (N-1)*h)

# innere naechste 2 Punkte durch einfache Naeherungfor z,n in ((2, 1), (3, N-2)):

# x^2 d^2f/dx^2 + x df/dx + (x^2 - nu^2)fA[z, n - 1] = n**2 - 0.5*nA[z, n ] = -2*n**2 + n**2*h**2 - nu**2A[z, n + 1] = n**2 + 0.5*n

# N-4 innere Punkte von 2 bis N-3 hinter den Startwerten, alle auf Nullfor n in range(2, N-2):

z = n + 2# x^2 d^2f/dx^2 + x df/dx + (x^2 - nu^2)fA[z, n - 2] = -1./12*n**2 + 1./12*nA[z, n - 1] = 4./3 *n**2 - 2./3 *nA[z, n ] = -5./2 *n**2 + n**2*h**2 - nu**2A[z, n + 1] = 4./3 *n**2 + 2./3 *nA[z, n + 2] = -1./12*n**2 - 1./12*n

fx5 = solve(A, b)

# Ausgabe############################################

xfine = linspace(0, xmax, 200)

pyplot.plot(xfine, jn(nu, xfine), "k−",linewidth=0.5)pyplot.plot(x, fx3, "gD")pyplot.plot(x, fx3l, "r^")pyplot.plot(x, fx5, "bo")pyplot.show()

90


Wir suchen also Gewichte αi ∈ R, so dass möglichst genau

∫ b

af(x) dx ≈

n−1∑i=0

αif(xi), (6.20)

wobei die αi von der Lage der Stützpunkte („Knoten“) xi abhängen, aber nicht vonf . Dadurch, dass die Funktion über dem ganzen Intervall [a,b] in das Integral eingeht,wird man für die numerische Integration natürlich mehr Punkte als beim Differenziereneinbeziehen wollen, und hat dementsprechend auch mehr Möglichkeiten, die Gewichte zuwählen. Im Folgenden werden wir einige der gebräuchlichsten Verfahren kennenlernen.

6.2.1 Newton-Cotes-Formeln

Um eine an diskreten Stützstellen xi, i = 0(1)n− 1 gegebene Funktion f zu integrieren,liegt es nahe, die Funktion mit Hilfe eines Polynoms zu interpolieren und dieses dannanalytisch zu integrieren:

∫ b

af(x) dx ≈

∫ b

a

n−1∑i=0

f(xi)Li(x) dx =

n−1∑i=0

∫ b

aLi(x)dx︸︷︷︸αi

f(xi). (6.21)

Diese Newton-Cotes-Formeln integrieren offenbar alle Polynome bis Ordnung n exakt.Allerdings verstärkt sich bei allgemeinen Funktion das Rungephänomen bei der Integra-tion, und ab Ordnung n = 9 treten negative Koeffizienten αi auf, was die Näherungverschlechtert. Daher sind nur kleine n sinnvoll, und in der Praxis werden nur Formelnbis Ordnung n = 8 benutzt. Die gebräuchlichsten werden im Folgenden kurz diskutiert.

Trapezregel

a b

Trapezregel

Die Trapezregel benutzt als Stützstellen x0 = a und x1 = b, diedementsprechend durch eine Gerade verbunden werden:∫ b

af(x) dx ≈

∫ b

a

[f(a)

x− ba− b

+ f(b)x− ab− a

]dx

= f(a)

∫ b

a

x− ba− b

dx + f(b)

∫ b

a

x− ab− a

dx

=b− a

2

(f(a) + f(b)

). (6.22)

91


Weiter gilt für den Fehler der Trapezregel

∫ b

af(x) dx− b− a

2

(f(a) + f(b)

)=

∫ b

af(x)− f(a)

x− ba− b

+ f(b)x− aa− b

dx

=

∫ b

a

(f(x)− f(a)

)x− ba− b

+(f(b)− f(x)

)x− aa− b

dx

=

∫ b

a

1

a− b

(f(x)− f(a)

x− a+f(b)− f(x)

x− b

)(x− b)(x− a)︸︷︷︸

<0 in [a,b]

dx

=f ′′(ξ)

2

∫ b

a(x− b)(x− a) dx = −(b− a)3

12f ′′(ξ) (6.23)

für ein ξ ∈ [a,b]. Gibt es also eine Abschätzung für die zweite Ableitung von f , so lässtsich auch der Fehler der Trapezregel abschätzen. Ist f konvex auf [a,b], also f ′′(ξ) > 0,so unterschätzt also die Trapezregel das Integral, ist f konkav, überschätzt sie es.

Simpsonregel

a m b

Simpsonregel

Analog wird die Simpsonregel für die drei Stützpunkte x0 = a,x1 = m = a+b

2 und x2 = b definiert, die durch eine Parabelverbunden werden:∫ b

af(x) dx =

b− a6

(f(a) + 4f (m) + f(b))

− (b− a)5

2880f (4)(ξ) (6.24)

für ein ξ ∈ [a,b], wobei der letzte Term wieder der Fehlerterm ist.Die Simpsonregel und die Trapezregel sind die meistgenutzten geschlossenen Newton-

Cotes-Formeln. Geschlossen heißen solche Formeln, die a und b als Stützpunkte beinhal-ten. Offene Formeln dagegen enthalten wenigstens einen der Punkte nicht. Naturgemäßsind die beiden folgenden Einpunktformeln offen.

Rechteckregel

a b

Rechteckregel

Wir benutzen x0 = a als Stützpunkt, und erhalten:∫ b

af(x) dx = (b− a)f(a) +

(b− a)

2f ′(ξ) (6.25)

für ein ξ ∈ [a,b], wobei der letzte Term wieder der Fehlerterm ist.

92


Mittelpunktsregel

a m b

Mittelpunktsregel

Wir benutzen x0 = m = a+b2 als Stützpunkt, und erhalten:∫ b

af(x) dx = (b− a)f(m) +

(b− a)3

24f ′′(ξ) (6.26)

für ein ξ ∈ [a,b], wobei der letzte Term wieder der Fehlerterm ist.Ähnlich wie schon beim Differenzieren ist also der Intervallmittelpunkt ausgezeichnet,

da dieser bei gleicher Stützstellenzahl eine bessere Ordnung als etwa bei der Rechteckregelermöglicht.

6.2.2 Zusammengesetzte Newton-Cotes-Formeln

Wie weiter oben erwähnt, sind Newton-Cotes-Formeln höherer Ordnung numerisch nochungünstiger als die Polynominterpolation, auf der sie basieren. Im Allgemeinen konver-giert bei steigender Anzahl der Stützstellen die Näherung für das Integral nicht einmal.Genauso wie bei der Interpolation liegt es nahe, auf stückweise Polynome, also Splines,überzugehen, wenn die Funktion f an sehr vielen Stützstellen a = x0 < x1 < . . . < xN =b gegeben ist.Für die bei der Interpolation üblicherweise verwendeten kubischen Splines wird die

Stetigkeit der zweiten Ableitung zweier Teilstücke an den gemeinsamen Stützstellen ge-fordert. Diese Forderung ist bei der Integration unnötig. Zudem erfordert die Auswertungder Splines die ziemlich aufwändige Lösung eines linearen Gleichungssystems. Daher greiftman bei der numerischen Integration üblicherweise auf stückweise Polynome niedrigererOrdnung ohne Anschlussbedingungen an den Stützstellen zurück.Da die reinen, nicht zusammengesetzten Newton-Cotes-Formeln in der Praxis kaum

auftauchen, sind oft die jeweiligen zusammengesetzten Formeln gemeint, wenn man vonder Trapezregel oder der Simpsonregel spricht, insbesondere in englischsprachiger Litera-tur.

Zusammengesetzte Trapezregel

a x1 x2 x3 b

ZusammengesetzteTrapezregel

Die zusammengesetzte Trapezregel für beliebig viele Stützstellenxi, i = 0(1)N ist gegeben durch

∫ b

af(x) dx ≈

N−1∑i=0

xi+1 − xi2

(f(xi) + f(xi+1)

)=x1 − x0

2f(x0) +

N−1∑i=1

xi+1 − xi−1

2f(xi) +

xN − xN−1

2f(xN ) (6.27)

93


Auf einem äquidistanten Gitter a+kh, k = 0(1)N mit h = (b−a)/N , verkürzt sich dieseFormel zu ∫ b

af(x) dx = h

(f(x0)

2+N−1∑i=1

f(xi) +f(xN )

2

)− (b− a)3

12N2f ′′(ξ)︸︷︷︸

=O(h2)

(6.28)

für ein ξ ∈ [a,b], wobei der letzte Term wieder den Fehler angibt und üblicherweisenicht berechnet werden kann. Hier konnten wir den Fehler der einfachen Trapezregelübernehmen, da stets 1

N

∑N−1i=0 f ′′(ξi) = f ′′(ξ) für ein ξ ∈ [a,b].

Eine einfache Implementation der Trapezregel in Python könnte so aussehen:

def trapez(f, a, b, N):h = (b-a)/float(N)summe = 0.5*(f(a) + f(b))for x in a + numpy.arange(1, N)*h:

summe += f(x)return h*summe

Die zusammengesetzte Trapezregel ist in Scipy als scipy.integrate.trapz(y,x) implementiert. Man beachte dabei die umgedrehte Reihenfolge der Funktionswerte yund Knoten x! Die Angabe der Knoten ist dabei optional, alternativ kann bei äquidi-stanten Daten nur die Schrittweite dx= h spezifiziert werden.

Zusammengesetzte Mittelpunktsregel

Analog zur Trapezregel lässt sich auch die zusammengesetzte Mittelpunktsregel für äqui-distante Gitter formulieren:∫ b

af(x) dx = h

N−1∑i=0

f(xi) +(b− a)3

24N2f ′′(ξ)︸︷︷︸

=O(h2)

(6.29)

wobei h = (b − a)/N , xi = a + h(i + 1/2), i = 0(1)N − 1, und ξ ∈ [a,b]. Die Stützpunk-te xi sind also um h/2 gegenüber den Intervallenden versetzt. Abgesehen davon sindMittelpunktsregel und Trapezregel offenbar äquivalent, was sich auch in den ähnlichenFehlerformeln ausdrückt. Mittelpunkts- oder Trapezregel sollten danach ausgewählt wer-den, wie sich die vorhandenen Stützstellen in Bezug auf die Randpunkte verhalten. Meistwerden die Intervallenden einbezogen sein; dann setzt man die Trapezregel ein.

Zusammengesetzte Simpsonregel

Sei das Intervall [a,b] in geradzahlig viele Abschnitte unterteilt, also xi = a + hi,i = 0(1)N , mit h = (b− a)/N und N gerade. Dann kann man je zwei Abschnitte zusam-menfassen, und den mittleren Knoten als Intervallmitte des doppelt breiten Abschnitts

94


benutzen, und so die Simpsonregel benutzen. Das führt zur Formel

∫ b

af(x) dx =

h

3

f(x0) +

N/2−2∑i=1

(2f(x2i) + 4f(x2i+1)

)+ f(xN )

− (b− a)5

180N4f (4)(ξ)︸︷︷︸

=O(h4)

(6.30)für ein ξ ∈ [a,b]. Durch die höhere Potenz von N konvergiert dieses Verfahren schnellerals die zusammengesetzte Trapezregel, sofern f vierfach stetig differenzierbar ist.Die zusammengesetzte Simpsonregel ist nicht identisch zur Integration mit kubischen

Splines, da hier nicht die Gleichheit der Ableitungen an der Stützstellen gefordert wird.In Scipy ist die Regel als scipy.integrate.simps(y, x) implementiert. Wieder

ist die Reihenfolge der Funktionswerte y und Knoten x vertauscht und die Angabe derKnoten optional, alternativ kann bei äquidistanten Daten nur die Schrittweite dx= hspezifiziert werden. Ist die Anzahl der Stützstellen ungerade, so wird an den Rändernmit der Trapezregel ergänzt.

6.2.3 Beispiel: Besselfunktion

Als Beispiel für die numerische Integration soll uns noch einmal die Besselfunktion ersterOrdnung Jν(x) dienen, also die Lösung der Besselschen Differentialgleichung. Wie mandurch Einsetzen in die Differentialgleichung „leicht“ sieht, ist J0(x) gegeben durch dasbestimmte Integral

J0(x) =1

π

∫ π

0cos(x sin(τ)) dτ, (6.31)

das wir numerisch mit Hilfe der zusammengesetzten Trapez- und Simpsonregel berechnenwollen. Wie Abbildung 6.3 links zeigt, gelingt dies mit nur 20 Stützpunkten recht zu-friedenstellend, sechs Stützpunkte allerdings ist für beide Regeln nicht ausreichend. ZumVergleich: die numerische Lösung der Differentialgleichung mit dem Verfahren dritterOrdnung benötigt 30 Stützpunkte, liefert aber gleich die Funktion an jedem Stützpunkt,während das Integral für jeden Punkt neu gelöst werden muss.Der Grund, dass sechs Stützstellen nicht ausreichen, ist im Prinzip derselbe, wie wir

ihn schon bei Abbildung 6.1 gesehen haben: mit nur sechs Stützstellen lassen sich beihöheren x die Schwingungen nicht mehr auflösen, siehe Abbildung 6.3 rechts. Dies lässtsich auch durch das Verfahren höherer Ordnung nicht korrigieren, sondern nur durch einehinreichend kleine Schrittweite. In diesem Fall sollte h 2π/x bzw. N x/2 sein, sodass

|x (sin(τ + h)− sin(τ))| ≈ xh |cos(τ)| 2π, (6.32)

damit der äußere Cosinus ausreichend aufgelöst wird. Für größere x als im Graphengezeigt wird also auch N = 20 nicht ausreichend sein.

95


0 2 4 6 8 10 12 14

0.4

0.2

0.0

0.2

0.4

0.6

0.8

1.0

0.0 0.5 1.0 1.5 2.0 2.5 3.01.0

0.5

0.0

0.5

1.0

1.5

Abbildung 6.3: Links: numerische Lösungen für das Besselintegral (6.31). Die durchge-zogene schwarze Linie markiert die analytische Lösung. Blaue Plus-Symbole und gelbeRauten markieren Trapez- bzw. Simpsonregel mit jeweils 20 Stützstellen. Rote Punkteund grüne Kreuze markieren dieselben Quadraturformeln, aber mit nur 6 Stützstellen.Rechts: in schwarz ist der Integrand von (6.31) für x = 12 dargestellt. Die schwarzenPunkte markieren darauf die 6 Stützstellen, durch die das Integral abgeschätzt werdensoll. Rot gepunktet sind die linearen Näherungen, die in der Trapezregel integriert werden,grün gestrichelt die quadratischen Näherungen der zusammengesetzten Simpsonregel. Esist klar, dass diese keine zufriedenstellende Auflösung des Integrals liefern können.

6.2.4 Romberg-Integration

Ist f ∈ C2k+2([a,b]) und

Tf (h) = h

f(a)

2+

(b−a)/h−1∑i=1

f(a+ ih) +f(b)

2

(6.33)

die (zusammengesetzte) Trapezformel zur Schrittweite h, so gilt die Euler-McLaurin-Summenformel

Tf (h) =

∫ b

af(x) dx+

k∑i=1

h2iαi +O(h2k−2) (6.34)

mitαi =

b2i(2i)!

(f (2i−1)(b)− f (2i−1)(a)

). (6.35)

b2i bezeichnet dabei die Bernoullizahlen, die αi hängen also nicht von h ab.In anderen Worten bedeutet das, dass sich die Trapezregel in einer Umgebung der 0 wie

ein Polynom in h2 verhält! Damit können wir – sofern wir die Werte αi bestimmen können

96


– durch Auswerten des Polynoms bei h = 0, also bei unendlich kleiner Schrittweite, dasgesuchte Integral bis auf einen Fehler der Ordnung O(h2k−2) ausrechnen.Für b− a-periodische C∞-Funktionen sind offenbar alle αi = 0, daher strebt die Tra-

pezformel Tf (h) für diese schneller als jede Potenz von h gegen das gesuchte Integral.Für nichtperiodische Funktionen kann man die αi im Allgemeinen nicht leicht analy-

tisch bestimmen, weil das die Kenntnis hoher Ableitungen erfordert. Wir können aber dieTatsache nutzen, dass sich der Fehler in guter Näherung wie ein Polynom verhält. Dazuwerten wir zunächst die Trapezregel Tf (hi) an Stützpunkten hi, i = 0(1)k und bestimmendas interpolierende Polynom Tf (h2) als Polynom in h2. Da wir tatsächlich nur daran inter-essiert sind, das Polynom bei h = 0 auszuwerten, benutzen wir das Neville-Aitken-Schema(3.12). Sei also Ti,j das interpolierende Polynom durch die j Stützstellen hi, . . . ,hi+j−1,ausgewertet in h = 0. Offenbar gilt für die konstanten Polynome Ti,1 = Tf (hi), die Ti,jmit j > 1 bestimmt man gemäß (3.12):

Ti,j =Ti,j−1h

2i+j−1 − Ti+1,j−1h

2i

h2i+j−1 − h2

i

für j = 2(1)k + 1, i = 0(1)k + 1− j. (6.36)

Dann gilt T0,k+1 = Tf (0) + O(h2k+2) =∫ ba f(x) dx + O(h2k+2). Eine solche Extrapola-

tion von Schrittweiten h > 0 auf die Schrittweite Null wird in der Numerik allgemeinRichardson-Extrapolation genannt.Wählt man nun hi = b−a

2i, so vereinfacht sich (6.36) zu

Tij =4j−1Ti+1,j−1 − Ti,j−1

4j−1 − 1, (6.37)

was als Romberg-Integration bezeichnet wird. Diese Wahl der Schrittweiten hat auch denVorteil, dass die Summe für hi bei der Berechnung von hi+1 wiederverwendet werdenkann:

Tf (hi+1) =1

2Tf (hi) + hi+1

2i−1∑l=0

f

(a+ hi

(l +

1

2

))(6.38)

Da sich der Aufwand für die Berechnung aller Tf (hi) mit jeder Stufe verdoppelt, ist derGesamtaufwand nicht wesentlich größer als der Aufwand zur Berechnung der niedrigstenStufe Tf (hk) alleine, bei deutlicher Verbesserung der Fehlerabschätzung. Codebeispiel 6.2am Ende des Kapitels zeigt eine einfache, aber effiziente Implementation des Romberg-verfahrens mit Hilfe von SciPy. Alternativ bietet auch SciPy selber eine Implementationdes Verfahrens, scipy.integrate.romberg(f, a, b).

6.2.5 Beispiel: Fehlerintegral

Als Beispiel für die Romberg-Integration ist das Besselintegral aus dem vorherigen Ab-schnitt wenig geeignet, da die zu integrierende Funktion b − a-periodisch und C∞ ist.Dadurch konvergiert bereits die einfache Trapezregel schneller als jedes Polynom, undbereits mit nicht sehr kleinen Schrittweiten erreicht die Trapezregel Maschinengenauig-keit. Da andererseits die Schrittweite wie beschrieben hinreichend klein sein muss, bleibtnicht genügend Raum, um durch Extrapolation noch etwas zu verbessern.

97


0.5 1.0 1.5 2.0 2.5h 1e 1

0.5

1.0

1.5

2.0

2.5

3.0

3.5

4.0

∆Tf(h

)

1e 3

10-3 10-2 10-1 10010-8

10-6

10-4

10-2

Abbildung 6.4: Romberg-Integration am Beispiel von∫ 1

0 e−x2 dx =

√π erf(1)/2 =: T0.

Aufgetragen ist der Fehler ∆Tf (h) = Tf (h)−T0 als Funktion der Schrittweite h (im Ein-schub in doppelt logarithmischer Skala). Sowohl Kreuze also auch blaue Kreise markierenBerechnungen mit der Trapezregel. Durch die mit blauen Kreisen markierten Datenpunk-te wurde dann das interpolierende Polynom bestimmt und rot gestrichelt eingezeichnet.Während der beste benutzte Datenpunkt eine Genauigkeit von etwa 6 ·10−5 erreicht, hatder extrapolierte Wert eine Genauigkeit von 3 · 10−16.

98


# Romberg-Integration############################################from scipy import *from scipy.special import *from scipy.interpolate import *import matplotlib.pyplot as pyplot

def romberg(f, a, b, kmax):"""Romberg-Integration der Funktion f von a bis b.Die Schrittweiten reichen von (b-a) bis (b-a)*2**-kmax."""

# Romberg-Stuetzpunkte erzeugen############################################

# aktuelle Schrittweiteh = b - a# aktuelle Naeherung (fuer den Anfang Trapezregel auf 2 Punkten)tf = h*(0.5*f(a) + 0.5*f(b))

# Stuetzpunkte fuer die Interpolation, verwendete Schrittweiten# und abgeschaetzte Integraleh_list = [ h ]tf_list = [ tf ]

for i in range(0, kmax):# Schaetzung mit der halben Schrittweitetf = 0.5*tf + 0.5*h*sum(f(a + (arange(0,2**i) + 0.5)*h))# Schrittweite nachziehenh *= 0.5# und alles speicherntf_list.append(tf)h_list.append(h)

tf = array(tf_list)h = array(h_list)

# Auswerten des interpolierenden Polynoms im Nullpunkt######################################################

return lagrange(h**2, tf)(0)

print "pi = %.16f" % (4*romberg(lambda x: 1.0/(1.0 + x**2), 0.0, 1.0, 8))

Listing 6.2: Romberg-Integration von 4(1 + x2)−1. Das Programm berechnet π auf 16Stellen genau.

99


Stattdessen wollen wir hier das Fehlerintegral∫ 1

0 e−x2 dx =

√π erf(1)/2 verwenden

(siehe Abbildung 6.4). Dabei sind die Randwerte bereits der ersten Ableitung stark ver-schieden, so dass Tf (h) tatsächlich polynomielle Form hat und um die Null herum ineiner weiten Umgebung nahezu quadratisch ist. Daher kann die Extrapolation den Feh-ler signifikant senken. Im Beispiel werden Schrittweiten der Trapezregel von 1 bis 1/16betrachtet. Bei Schrittweite 1/16 beträgt der Fehler der Trapezregel noch etwa 6,0 ·10−5,während das Integral durch die Extrapolation von 5 Datenpunkten das Integral bis auf3,3 · 10−16 korrekt bestimmt, also Maschinengenauigkeit.

6.2.6 Gauß-Quadratur

Bis jetzt hatten wir uns vor allem mit äquidistanten oder aber ganz freien Gittern be-schäftigt. Wenn aber die zu integrierende Funktion analytisch gegeben ist, so könnenwir die Stützpunkte frei wählen. Welche Stützpunkte sind dann optimal? Bei der Gauß-Quadratur suchen wir Stützstellen xi und dazugehörige Gewichte αi, so dass für Polyno-me f mit möglichst hohem Grad noch∫ 1

−1f(x) dx = Inf :=

n∑i=1

αif(xi) (6.39)

gilt, also diese Polynome exakt integriert werden. Die feste Wahl der Integralgrenzena = −1 und b = 1 ist dabei keine Einschränkung, weil jedes endliche Integral auf diesenBereich transformiert werden kann:∫ b

af(x) dx =

(b− a)

2

∫ 1

−1f

(a+ b

2+ x′

b− a2

)dx′. (6.40)

Welchen Polynomgrad können wir so erreichen? Auf der einen Seite integrieren schondie Newton-Cotes-Formeln mit n Stützstellen Polynome bis Grad n − 1 exakt. Auf deranderen Seite ist für das Polynom p(x) =

∏ni=1(x−xi)2 jede Näherung Inp = 0, während

offenbar∫ ba p(x) dx > 0. Daher kann es also kein Verfahren geben, dass alle Polynome bis

Grad 2n exakt integriert. Ein Grad darunter, also 2n−1 ist allerdings möglich, und wirddurch die Gauß-Quadratur erreicht.Um ein Polynom 2n− 1 Grades eindeutig zu bestimmen, benötigen wir 2n Stützstel-

len. Da wir aber nur n Stützstellen benutzen wollen, liegt es nahe, an diesen auch dieAbleitungen einzubeziehen, was ein Spezialfall der Hermite-Interpolation ist. Wie manleicht sieht, ist

p(x) =n∑i=1

L2i (x)

f(xi)

[1− 2L′i(xi)(x− xi)

]+ f ′(xi)(x− xi)

(6.41)

das gesuchte Polynom 2n−1-Grades durch die Stützstellen (xi, f(xi), f′(xi)). Li bezeich-

net die Lagrangepolynome aus Gleichung (3.8). Daraus ergibt sich die Hermite-Quadratur∫ 1

−1f(x) dx ≈

∫ 1

−1p(x) dx =

n∑i=1

αif(xi) +

n∑i=1

βif′(xi) (6.42)

100


mit

αi =

∫ 1

−1L2i (x)

[1− 2L′i(xi)(x− xi)

]dx und βi =

∫ 1

−1L2i (x)(x− xi) dx. (6.43)

Ziel ist nun, die Lage der Knoten xi so zu wählen, dass die Ableitungen, die wir ja imAllgemeinen gar nicht kennen, aus der Näherungen entfallen:

0!

= βi =∏k 6=i

1

xi − xk

∫ 1

−1Li(x)ω(x) dx, (6.44)

mit ωn(x) :=∏ni=1(x− xi). Da die Li eine Basis der Polynome vom Grad n− 1 bilden,

bedeutet dies, dass ωn bezüglich des üblichen Skalarprodukts (f, g) =∫ 1−1 f(x)g(x) dx

senkrecht auf dem Raum der Polynome vom Grad n− 1 stehen muss. Mit βi = 0 verein-facht sich außerdem

αi =

∫ 1

−1L2i (x) dx− 2L′i(xi)βi =

∫ 1

−1L2i (x) dx. (6.45)

Wir suchen also ein Polynom ωn mit Höchstkoeffizient 1 und Grad n, dass senkrechtauf allen Polynomen vom Grad n−1 steht. Die Nullstellen dieses Polynoms sind dann diegesuchten Stützstellen xi. Die Existenz und Eindeutigkeit von ωn kann man mit Hilfe desGram-Schmidt-Orthogonalisierungsverfahrens konstruktiv zeigen, dass wir später genau-er kennenlernen werden. Die Idee ist dabei, die Basisvektoren 1, x, x2, . . . schrittweiseso zu transformieren, dass sie senkrecht aufeinander stehen.Dies ergibt, bis auf einen Vorfaktor, die Legendrepolynome, die rekursiv zum Beispiel

so berechnet werden können:

P0(x) = 1

P1(x) = x

Pn(x) =1

n

[(2n− 1)xPn−1(x)− (n− 1)Pn−2(x)

]. (6.46)

Die Nullstellen der ersten dieser Polynome und die zugehörigen Gewichte sind

Grad Nullstelle Gewicht

1 x0 = 0 α0 = 2

2 x0,1 = ±√

1/3 α0,1 = 1

3 x0,2 = ±√

3/5 α0,2 = 5/9

x1 = 0 α1 = 8/9

In SciPy implementiert scipy.integrate.fixed_quad(f, a, b, n=5) dieGauß-Quadratur mit den Nullstellen der Legendrepolynome. n gibt dabei die Anzahlder Stützstellen an, die benutzt werden sollen.

101


Um andere Gauß-Quadraturen zu entwickeln, kann man gewichtete Skalarproduktebetrachten. Wir definieren

(f,g)w :=

∫ 1

−1f(x)g(x)w(x) dx (6.47)

als das zur Gewichtsfunktion w(x) > 0 gehörige Skalarprodukt. Dies ändert unsere Or-thogonalitätsbeziehung (6.44) in

0!

= (Li,ω)w =

∫ 1

−1Li(x)ω(x)w(x) dx. (6.48)

Wenn wir die ursprüngliche Hermite-Interpolation beibehalten wollen, bedeutet dies, dasswir auch das Zielintegral entsprechend anpassen müssen, also nun∫ 1

−1f(x)w(x) dx ≈

∫ 1

−1p(x)w(x) dx

n∑i=1

αif(xi) +

n∑i=1

βif′(xi) (6.49)

berechnen mit

αi =

∫ 1

−1L2i (x)w(x) dx. (6.50)

Die Legendrepolynome bzw. deren Nullstellen gehören also zur Gewichtsfunktionw(x) = 1. Die Gewichtsfunktion w(x) = 1/

√1−x2 hingegen liefert als Stützstellen die

Nullstellen der Chebyshev-Polynome Tn(x), vergleiche (3.18). Die Gewichte sind in die-sem Fall sehr einfach, nämlich π/n. Um das offene Intervall (−∞,∞) zu betrachten,kann die Gewichtsfunktion e−x2 benutzt werden, zu der die orthogonalen Polynome dieHermitepolynome sind.Als letztes soll noch erwähnt werden, dass die Gauß-Quadratur für alle Gewichtsfunk-

tionen mit steigender Anzahl von Stützstellen gegen das tatsächliche Integral konvergiert,im Gegensatz zu den Newton-Cotes-Formeln.

6.2.7 Unendliche Integrale und Singularitäten

Alle genannten numerischen Integrationsverfahren lösen Integrale mit Singularitäten nurschlecht. Unendliche Integrationsgrenzen sind, bis auf die Gauß-Quadratur mit Hermi-tepolynomen, gar nicht möglich. In ersterem Falle müssen sehr viele Stützpunkte in derNähe der Singularität liegen, im zweiten Fall muss das unendliche Integral durch einmöglichst großes, endliches Intervall approximiert werden. Allerdings ist es oft möglich,solche Probleme durch Variablensubstitution zu umgehen. So ist zum Beispiel∫ ∞

1

f(x)

x2dx

z= 1x= −

∫ 1

0f

(1

z

)dz. (6.51)

Fällt f ′(x) für große x gegen 0 ab, so dass f gegen eine Konstante strebt, dann istdie Ableitung von f(1/z) gegen 0 beschränkt, und die Funktion gut integrierbar. Im

102


200 400 600 800 1000b

1.2

1.4

1.6

1.8

2.0

Abbildung 6.5: Romberg-Verfahren für das Integral∫ b

01

1+x2dx, als Funktion von b. Die

blau gepunktete Linie markiert die Ergebnisse des Verfahrens mit 128 Stützstellen, dierote durchgezogene Linie mit 32 Stützstellen. Die schwarz gestrichelte Linie markiert π/2,also den Grenzwert des Integrals gegen unendlich. Eine Kombination von b und AnzahlStützstellen zu finden, die diesen Grenzwert gut approximiert, ist also sehr schwierig.

Unterschied zum ursprünglichen Integral ist das neue Integral aber eigentlich und damitmit den genannten Verfahren einfach zu lösen.Als Beispiel soll die Berechnung von π/2 gemäß der Formel

π

2=

∫ ∞0

1

1 + x2dx (6.52)

dienen. Mit obiger Transformation folgt∫ ∞0

1

1 + x2dx =

∫ 1

0

1

1 + x2dx+

∫ 1

0

1

1 + z−2z−2 dz = 2

∫ 1

0

1

1 + x2dx. (6.53)

Durch Romberg-Integration auf nur 32 Stützstellen kann der Ausdruck auf der rechtenSeite bis auf 14 Stellen genau ausgewertet werden.Abbildung 6.5 zeigt hingegen, was bei 32 bzw. 128 Stützstellen geschieht, wenn man

stattdessen∫ b

01

1+x2dx für große b mit Hilfe des Rombergverfahrens bestimmt. Das Er-

gebnis hängt stark von der Integrationsgrenze b ab, und so ist es praktisch unmöglich,zu sagen, was der tatsächliche Wert des Integrals für b → ∞ ist. Durch Anpassen derAnzahl der Stützpunkte an b und damit Konstanthalten der Schrittweite lässt sich zwardas Integral stabilisieren, trotzdem müsste man mehrere Werte von b mit hohen Anzahlenan Stützstellen ausprobieren, um eine gute Näherung sicherzustellen. Im Beispiel erreichtkeines der beiden Extrema vorne mehr als 3 Stellen Genauigkeit. Daher sollte man stetslieber versuchen, das Integral durch Substitutionen auf eine endliche Form zu bringen.

103


6.2.8 Mehrdimensionale Integration, Monte-Carlo-Integration

Bis jetzt haben wir uns nur mit eindimensionalen Integralen beschäftigt. Im Prinzip istes nicht schwer, die obigen Verfahren auch auf höhere Dimensionen zu erweitern, etwadie zusammengesetzte Mittelpunktsregel auf zwei Dimensionen:∫ b

a

∫ d

cf(x, y) dx dy ≈ (b− a)(d− c)

NM

N−1∑i=0

M−1∑j=0

f(a+ (b− a)

i

N, c+ (d− c) j

N

). (6.54)

Hatte man allerdings bei einer hinreichend glatten Funktion bereits mit hundert Stütz-stellen gute Ergebnisse erzielen können, benötigt man nun etwa 1002 = 10,000 Stützstel-len. Mit steigender Anzahl der Dimensionen wird dies schnell unmöglich zu handhaben.Für die sogenannte Zustandssumme eines Vielteilchensystems zum Beispiel, einer zentra-len Größe in der statistischen Physik, muss etwa über allen Koordinaten des Phasenraumsintegriert werden. Bei nur hundert Teilchen entspräche das bereits 600 Dimensionen (3Ortskoordinaten plus 3 Geschwindigkeiten pro Teilchen). Sollten in jeder dieser Koordi-naten nur 2 Stützpunkte benutzt werden, wären insgesamt trotzdem über 2600 = 4 ·10180

Stützpunkte zu berücksichtigen! Für diesen exponentiellen Anstieg, der bei praktischenallen hochdimensionalen Problemen auftritt, hat R. Bellman den Begriff „Curse of di-mensionality“ geprägt.Um solche hochdimensionalen Integrale trotzdem annähern zu können, kann man die

Monte-Carlo-Integration einsetzen. Diese benutzt, dass⟨1

N

N∑i=1

f(ξi)

⟩= 〈f〉V =

1

|V |

∫x∈V

f(x) dx , (6.55)

wobei ξi verschiedene Ziehungen einer Zufallsvariablen sind, die gleichverteilt in V ist.V ist dabei ein endliches Untervolumen des Rn, |V | sein Volumen. Daher lässt sich dasIntegral von f als ∫

x∈Vf(x) dx ≈ |V |

N

N∑i=1

f(ξi) (6.56)

nähern, wobei ξi hinreichend gute (Pseudo-)Zufallsvektoren aus V sein müssen. Wie diesegeneriert werden, ist Thema des nächsten Kapitels. Was ist nun der Fehler dieser Nähe-rung? Da die ξi gemäß Konstruktion unabhängig sind, lässt sich der Fehler gut mit Hilfeder Standardabweichung σ(f) abschätzen, und beträgt |V |σ(f)/

√N . Die Standardab-

weichung kennen wir im allgemeinen nicht, können sie aber gemäß (4.38) als

σ2(f) ≈ 1

N − 1

N∑i=1

f(ξi)2 −N

(N∑i=1

f(ξi)

)2 (6.57)

zusammen mit der Integration abschätzen.Als SciPy-Code sieht eine Monte-Carlo-Integration noch einfacher als die Trapezregel

aus. Hier ein Code, der zweidimensional über [a,b]× [c,d] integriert:

104


from numpy.random import uniform

def montecarlo(f, a, b, c, d, N):volumen = (b-a)*(d-c)return volumen*sum(f(uniform(a,b,N), uniform(c,d,N)))/N

Da die Standardabweichung eine Konstante ist, fällt der Fehler der Monte-Carlo-Integration im Allgemeinen wie O(N−1/2). Im Vergleich dazu fällt der Fehler der Tra-pezregel im eindimensionalen wie O(N−2), sofern f genügend glatt ist. Wenn man beider Trapezregel die Anzahl der Stützpunkte verdoppelt, dann muss man bei der Monte-Carlo-Integration mehr als eine Größenordnung mehr Punkte aufwenden, um dieselbeVerbesserung in der Genauigkeit zu erreichen!Bei mehrdimensionalen Integralen sieht die Situation allerdings anders aus. Bei der

Trapezregel mit insgesamt N Stützstellen entfallen pro Dimension N1/n viele Stütz-stellen, wenn diese auf einem Würfel gleichmäßig in allen Dimensionen verteilt wer-den. Die Genauigkeit ist damit O(N−2/n). Ab fünf Dimensionen ist damit die Monte-Carlo-Integration der Trapezregel überlegen. Ein anderer Fall, in dem die Monte-Carlo-Integration der Trapezregel überlegen sein kann, ist wenn die Funktion f nicht genügendglatt oder nicht einmal stetig ist.

6.2.9 Beispiel: Monte-Carlo-Integration von π

Als Beispiel soll diesmal eine andere Methode zur Bestimmung von π dienen, nämlichdie Integration der charakteristischen Funktion

χD2(x, y) =

1 falls x2 + y2 < 1

0 sonst(6.58)

im Bereich [−1,1]2. Das ergibt dann gerade den Kreisinhalt, also∫x∈[−1,1]

∫y∈[−1,1]

χD2(x, y) dx dy = π. (6.59)

Abbildung 6.6 skizziert links die Monte-Carlo-Integration von χD2 , rechts zeigt siegemessene Fehler bei Monte-Carlo-Integration und Mittelpunktsregel. Dabei wurde ne-ben χD2 auch χD5 integriert, also das Volumen der fünfdimensionalen Kugel (8π2/15).Der Fehler der Monte-Carlo-Integration ist als mittlerer Fehler von zwanzig Aufrufengemessen, wobei durch die große Anzahl von Abtastungen die Schwankungen klein sind.Für das ursprüngliche, zweidimensionale Problem (blaue Punkte und rote Kreuze)

ist die Trapezregel überlegen, auch wenn sie in zwei Dimensionen nicht die optimaleSkalierung mit 1/N erreicht. Das ist zu erwarten, da die zu integrierende Funktion ΞnDja nicht stetig ist. Auch der nichtmonotone Abstieg der Fehler ist durch die Unstetigkeitund die Auflösung des Kreisrands bedingt. Beim fünfdimensionalen Problem aber siehtes wie angekündigt anders aus, hier ist die Monte-Carlo-Integration besser. Tatsächlichsind nicht nur die mittleren Abweichungen kleiner als bei der Trapezregel, sondern es

105


1.0 0.5 0.0 0.5 1.01.0

0.5

0.0

0.5

1.0

101 102 103 104 105 106

N

10-4

10-3

10-2

10-1

100

101

Abbildung 6.6: Links: Illustration der Monte-Carlo-Integration. Die Funktion χD2 wirdüber 200 zufällige Punkte (rote Kreise und grüne Kreuze) aus [−1,1]2 gemittelt. An dengrünen Kreuzen ist χD2 = 1, an den roten Punkten Null. Rechts: Genauigkeit der Inte-gralnäherungen als Funktion der Anzahl der Stützstellen N . Blaue Punkte markieren diemittlere Genauigkeit der zweidimensionalen Monte-Carlo-Integration, die roten Kreuzedie entsprechende Mittelpunktsregel. Gelbe Rauten und grüne Kreuze zeigen die Ge-nauigkeiten von Monte-Carlo-Integration und Mittelpunktsregel für die 5-Kugel, bei derdie Monte-Carlo-Integration schon klar überlegen ist. Die durchgezogene Linie entsprichteiner Skalierung von N−1/2, wie man sie für die Monte-Carlo-Integration erwartet.

ist sogar sehr unwahrscheinlich, ein ebenso schlechtes Ergebnis zu erzielen. Für solcheIntegrale ist also die Monte-Carlo-Methode in jedem Falle vorzuziehen.

6.2.10 Quasi-Monte-Carlo-Integration

Bei der Monte-Carlo-Integration nutzen wir (Pseudo-)Zufallszahlen, um durch zufälligeAbtastung möglichst gut den mittleren Wert der zu integrierenden Funktion zu bestim-men. Wie wir gesehen haben, sind im Mehrdimensionalen Zufallszahlen zu diesem Zweckbesser geeignet als ein regelmäßiges Gitter — das entspräche ja der Trapezregel. Abersind Zufallszahlen optimal?Tatsächlich nicht, denn etwa Abbildung 6.6 links zeigt, dass Zufallszahlen nicht so

homogen verteilt sind, wie man annehmen würde. Dies ist kein Fehler des betrachtetenZufallszahlengenerators, sondern ein prinzipielles Problem echter Zufallssequenzen, diesogenannte Diskrepanz. Unsere Erwartung an eine Reihe von N gleichverteilten Zufalls-zahlen ist, dass jedes Intervall [a,b] ⊆ [0,1] von etwa (b−a)N Zufallszahlen getroffen wird.Dies ist aber bei echten Zufallszahlen erst bei sehr großen N der Fall. Das bedeutet, dasses bei der Monte-Carlo-Integration immer Bereiche gibt, die von einer echten Zufallsreihe

106


über- oder unterrepräsentiert werden. Hat aber einer dieser Bereiche einen großen Anteilam betrachteten Integral, führt dies zu entsprechenden Fehlern.

Quasizufallszahlen

Anstelle von Zufallszahlen benutzt man daher für die Monte-Carlo-Integration besserQuasizufallszahlen, die nicht mehr wirklich zufällig sind, sondern eine möglichst geringeDiskrepanz bieten. Ziel ist es also, möglichst alle Bereiche mit genau so vielen Zahlenabzudecken, wie man nach Gleichverteilung erwarten würde. Ein Beispiel ist die Halton-Folge, die eine Reihe mit niedriger Diskrepanz im Wertebereich [0,1] ist.Um die Halton-Folge zu definieren, wählen wir für jede Dimension eine andere Prim-

zahl p als Basis und schreiben die natürlichen Zahlen in Basis p. Um daraus die ge-wünschte Zerlegung des Intervalls [0,1] zu erhalten, benutzen wir einfach die Stellen derp-Darstellung als Nachkommastellen, in umgekehrter Reihenfolge. Für p = 2 und p = 3sind die so definierten ersten 8 Folgenglieder:

n binär Stellenumkehr Ergebnis ternär Stellenumkehr Ergebnis1 1 ,1 1/2 1 ,1 1/32 10 ,01 1/4 2 ,2 2/33 11 ,11 3/4 10 ,01 1/94 100 ,001 1/8 11 ,11 4/95 101 ,101 5/8 12 ,21 7/96 110 ,011 3/8 20 ,02 2/97 111 ,111 7/8 21 ,12 5/98 1000 ,0001 1/16 22 ,22 8/9

Die Umkehrung der Stellen hat den Vorteil, dass die pn-tel nacheinander möglichst gleich-mäßig das Intervall füllen, was ja gerade einer niedrigen Diskrepanz entspricht. DieseFolge für ein festes p heißt eine van der Corput-Folge zu p.Die folgende Routine berechnet die ersten N Glieder der van der Corput-Folge zur

Basis p. Dazu wird solange von den natürlichen Zahlen 1,2, . . . ,N die unterste Stelleabgezogen und mit der reziproken Potenz auf das Ergebnis addiert, bis alle Stellen vonauch der höchsten Zahl, N , bearbeitet wurden:

from numpy import *def vanderCorput(N, p):

# zu wandelnde Zahlennumbers = arange(1,int(N)+1)# bitumgekehrtes Ergebnisresult = zeros(N)# Wert der aktuellen, inversen Stellefrac = 1.0 / p

# solange die groesste Zahl noch Stellen hatwhile numbers[-1] > 0:

# unterste Stelle abschneidendigit = numbers % p

107


1.0 0.5 0.0 0.5 1.01.0

0.5

0.0

0.5

1.0

101 102 103 104 105 106

N

10-5

10-4

10-3

10-2

10-1

100

Abbildung 6.7: Quasi-Monte-Carlo-Integration von π. Wie in Abbildung 6.6 sind linksdie aus der Halton-Folge gezogenen Punkte dargestellt, wobei die ersten zehn Punkte rotgefärbt sind, die nächsten hundert Punkte blau und die restlichen grün. Auf der rechtenSeite sind die Ergebnisse der Integration zu sehen, wobei blaue Kreise die Monte-Carlo-Integration mit Pseudozufallszahlen angeben, grüne Kreuze die Trapezregel und roteRauten die Quasi-Monte-Carlo-Integration.

numbers /= p# ... und zum Ergebnis hinzufuegenresult += frac*digitfrac /= p

return array(result)

Die mehrdimensionale Halton-Folge ist die Folge, die aus der Verschränkung einer vanCorput-Folge für jede Dimension entsteht, üblicherweise mit verschiedenen Primzahlen.Bei zwei Dimensionen mit Basen 2 und 3 ergibt sich etwa

(1/2, 1/3) , (1/4, 2/3) , (3/4, 1/9) , (1/8, 4/9) , (5/8, 7/9) , (3/8, 2/9) , (7/8, 5/9) , . . . (6.60)

Um eine Monte-Carlo-Integration mit Quasizufallszahlen durchzuführen, müssen imBeispielcode zum Abschnitt 6.2.8 lediglich die Aufrufe von uniform(a,b,N) durcha + (b-a)*vanderCorput(N, p) mit verschiedenen p ersetzt werden. Zum Beispielwählt man p = 2 für die erste Dimension, p = 3 für die zweite, und so weiter.

6.2.11 Beispiel: Quasi-Monte-Carlo-Integration von π

Abbildung 6.7 zeigt nochmals die Integration von π mit Hilfe der Monte-Carlo-Integration, allerdings diesmal nicht mit Pseudozufallszahlen, sondern der Halton-Folge,

108


also Quasizufallszahlen. Wie man gut sieht, sind die Quasizufallszahlen scheinbar zu-fällig, aber sehr viel homogener als echte oder Pseudozufallszahlen über das Quadratverteilt, insbesondere auch schon bei niedrigen Anzahlen von Punkten. Die Integrationmit Quasizufallszahlen wird kurz als Quasi-Monte-Carlo-Integration bezeichnet, und istfür die unstetige Indikatorfunktion nicht nur der Monte-Carlo-Integration mit Zufalls-zahlen überlegen, sondern auch der Trapezregel.

109

7 Zufallszahlen

Im letzten Kapitel wurden für die Monte-Carlo-Integration Zufallszahlen benötigt. Indiesem Kapitel wird besprochen, wie diese auf dem Computer generiert werden, welcheArten es gibt, und wie die Qualität einer Zufallsreihe bestimmt werden kann. Außerdemlernen wir weitere Anwendungen von Zufallszahlen kennen.Zunächst aber klären wir, was Zufallszahlen im strengen Sinn sind. Wir betrachten ein

Experiment, das wiederholt voneinander unabhängige Ergebnisse x ∈ M liefert. Dannheißt ein Ergebnis einer solchen Messung eine Zufallszahl. Aufgrund der Konstruktionist für jede Zufallszahl x der Erwartungswert gleich und unabhängig von allen anderenMessungen. Betrachten wir eine unendliche Menge von Zufallszahlen, so sind die Zufalls-zahlen in dieser Menge stets gleich verteilt, und zwar mit einer Verteilung P (x), die durchdie Art des Experiments bestimmt ist.Ein solches Experiment wäre zum Beispiel der Wurf eines Würfels, der Ergebnisse aus

M = 1, . . . ,6 liefert. Ist dieser Würfel ideal, so gilt P (x) = 1/6 für alle x ∈ M . Einekonkrete Folge von Zufallszahlen wäre dann zum Beispiel

633142563552446623663665614512446522561664446144244634522555

523121622535453613443366636251342661262345213346341313326554

221663665263462152654312621424115144626242451444653655341323 . . .

und mit wachsender Folgenlänge würde der Anteil an Einsen, Zweien und so weiter gegenjeweils 1/6 der Gesamtmenge konvergieren.Um echte Zufallszahlen bereitzustellen, müsste der Computer vergleichbar ein (mi-

niaturisiertes) Experiment mit bekannter, stochastischer Verteilung der Messergebnissedurchführen. Wie Linux zeigt, ist so etwas durchaus möglich, indem viele verschiedeneHardwaredaten kombiniert werden, wie etwa Bits aus dem Netzwerkverkehr oder derMausposition. Diese Daten werden noch so transformiert, dass sie gleichverteilte Bytesergeben, die unter /dev/random ausgelesen werden können. Wenn nichts weiter ange-geben ist, wird auf dem Computer übrigens üblicherweise von einer Gleichverteilung derZufallszahlen ausgegangen, also P (x) = 1/|M |.

7.1 Pseudozufallszahlen

Für physikalische Anwendungen benutzt man allerdings keine echten Zufallszahlen, son-dern sogenannte Pseudozufallszahlen. Dies sind deterministische Zahlenfolgen, die aber„hinreichend“ zufällig aussehen; wir werden später sehen, was genau das heißt. Pseudozu-fallszahlen haben zwei Vorteile. Zum einen lassen sich solche Zahlen erheblich schnellerberechnen als etwa die echten Zufallszahlen des Linux-Kernels (um gut einen Faktor 80

111

7 Zufallszahlen

auf modernen Prozessoren), zum zweiten macht dies Computerexperimente exakt repro-duzierbar. Beobachtet man also bei einem Durchlauf ein ungewöhnliches Verhalten, dasman genauer analysieren möchte, kann man das Experiment exakt wiederholen und dabeizum Beispiel zusätzliche Messungen vornehmen.Wie werden solche Pseudozufallszahlen generiert? Für diese Aufgabe gibt es verschie-

dene Algorithmen, sogenannte Zufallszahlengeneratoren (engl. random number generatoroder RNG). Diese liefern bei jedem Aufruf eine Zufallszahl, meist eine gleichverteilteGanzzahl. Die Bandbreite reicht vom sehr guten, aber aufwändigen Mersenne-Twisterbis zu den einfachen linearen Kongruenzgeneratoren, die wir nun kennenlernen werden.Das Hauptmaß für die Güte eines solchen Zufallszahlengenerators ist seine Periode.

Denn da jeder Zufallsgenerator einen internen Zustand hat, der durch N viele Bits dar-gestellt wird, muss sich nach höchstens 2N Aufrufen der interne Zustand wiederholen.Da es sich aber um einen deterministischen Algorithmus handelt, wiederholt sich diefolgende Reihe ab dann exakt. Daher sind alle Generatoren periodisch. Durch geeigneteWahl des Algorithmus ist die Periode meist nahe dem theoretischen Maximum, also etwa232 ≈ 4 Milliarden bei 32 Bit.Das hört sich recht viel an, aber bei einer typischen Molekulardynamiksimulation wer-

den pro Zeitschritt und Teilchen 3 Zufallszahlen benötigt. Bei zehntausend Teilchen wer-den damit pro Schritt 30,000 Zufallszahlen gezogen, und der Generator wiederholt sichnach weniger als 200,000 Zeitschritten. Da sich die Teilchenpositionen in dieser Zeitwahrscheinlich schon stark geändert haben, spielt dies in in der Praxis keine Rolle. BeiIsingmodellen, bei denen zufällig Spins auf einem Gitter invertiert werden, betrachtetman allerdings nicht selten Gitter von einigen Millionen Spins. In diesem Fall sind bes-sere Generatoren wesentlich. Der Mersenne-Twister-Generator hat zum Beispiel eineninternen Zustand von 2,5 Kilobyte und eine Periode von ≈ 106000, was für die meistenAnwendungen ausreichend sein dürfte.In Python stellt das Modul random verschiedene effiziente und hochwertige Methoden

zur Zufallszahlenberechnung bereit. Die Methode random.randint(a,b) etwa lieferteine gleichverteilte Zufallszahl aus dem Intervall [a,b]; anders als bei range etwa ist alsoauch die obere Grenze einbegriffen. random.unifom(a,b) liefert analog eine gleich-verteilte Fließkommazahl im Intervall [a,b]. random.gauss(mu, sigma) schließlichliefert eine normalverteilte Fließkommazahl mit Erwartungswert mu und Standardabwei-chung sigma.NumPy hat ein eigenes random-Modul, das zusätzlich Vektoren von Zufallszahlen

generieren kann, indem einfach neben den Parametern eine weitere ganze Zahl, die ge-wünschte Anzahl N von Zufallszahlen, angeben wird, also zum Beispiel numpy.random.normal(mu, sigma, N). Achtung: anders beim random-Modul von Python ist beinumpy.random.randint(a, b, N) b nicht eingeschlossen!

7.1.1 Linearer Kongruenzgenerator

Der (lineare) Kongruenzgenerator (LCG) ist der einfachste Typ eines Zufallszahlengene-rators. Der interne Zustand ist dabei lediglich eine ganze Zahl xi von 0 bis m − 1, die

112

7.1 Pseudozufallszahlen

gemäßxi+1 = (axi + b) mod m (7.1)

in den neuen inneren Zustand xi+1 transformiert wird. Die eigentliche Zufallszahl sindeinige (oder alle) der Bits des Zustands xi. m, a und b sowie die Menge der für dieZufallszahl benutzten Bits sind die Konstanten, die den Algorithmus festlegen, x0 derStartwert oder Seed. Die Konstantenm, a und b sollten keinesfalls einfach zufällig gewähltwerden, da Knuth gezeigt hat, dass nur unter gewissen Bedingungen die Periode einessolchen Generators tatsächlich m ist [Knu81]. Bei zufälliger Wahl der Konstanten wirddie Periode meist sehr viel kürzer sein.Der Zufallsgenerator rand48 der POSIX-C-Bibliothek ist ein Beispiel eines LCGs. Er

benutzt einen Modul von m = 248, a = 25,214,903,917 und b = 11. Als Zufallszahlenwerden dann die obersten 31 Bits von xi benutzt, also die Bits 17 bis 47. Ältere Versionender Standard-C-Bibliothek benutzten für die Funktion rand m = 231, a = 1,103,515,245und b = 12,345, wobei alle 31 Bit als Zufallszahl genutzt werden.Die Wahl von m = 248 bzw. m = 232 hat den einfachen Grund, dass sich sehr einfach

modulo m = 2b rechnen lässt – man berücksichtigt einfach nur die ersten b− 1 Bits undignoriert alle höheren. Denn( ∞∑

i=0

bi2i

)mod 2b =

∞∑i=0

bi

(2i mod 2b

)︸︷︷︸

=0 für i≥b

mod2b =b−1∑i=0

bi2i. (7.2)

Damit ersetzt man bei maschinennahen Sprachen eine Modulo-Operation durch einewesentlich schnellere bitweise Maskierung. Als Python-Klasse sieht der klassische randetwa wie folgt aus:

class Rand:a = 1103515245b = 12345m = 2**31

def __init__(self, seed):self.state = seed

def __call__(self):self.state = (self.state*self.a + self.b) % self.mreturn self.state

Der Konstruktor __init__ setzt nur den anfänglichen internen Zustand, also x0,__call__ liefert dann bei jedem Aufruf eine neue Zufallszahl.Dass die Modulo-Operation für eine Zweierpotenz als Modul ein einfaches Abschneiden

der hohen Bits ist, hat allerdings auch einen gewissen Nachteil. Denn betrachtet man nurdie ersten k Bits der Zufallszahl, dann entspricht dies einem Modulo. Das bedeutet, dassdiese anscheinend von einem Generator mit kürzerer Periode als 2k+1 generiert werden.Insbesondere wechselt das unterste Bit mit jedem Schritt seinen Wert oder ist konstant.Dies ist der Grund, warum rand48 die untersten 17 Bit verwirft.

113

7 Zufallszahlen

Dieses Problem lässt sich umgehen, indem der Modul als Primzahl gewählt wird. Indiesem Fall kann b = 0 gewählt werden, so dass

xi+1 = axi = aix0 mod m, (7.3)

wobei offenbar x0 6= 0 sein muss. Wenn a als eine primitive Einheitswurzel des endlichenKörpers Fm gewählt wird, dann durchläuft diese Reihe einmal alle Elemente außer derNull. Daher hat ein solcher Generator eine Periode von m− 1.m wird meist als Mersennesche Primzahl, also von der Form m = 2b − 1, gewählt,

wobei b etwa so groß wie die Bitlänge des internen Zustands ist. Dadurch ist die Periodedes Generators nahezu maximal. Die Implementation ist allerdings etwas schwieriger,weil jetzt die oberen Bits nicht einfach abgeschnitten werden können. Nach Park undMiller ist ein Beispiel eines solchen Generators m = 231 − 1 und a = 16807, der auch alsMINSTD bezeichnet wird und analog dem rand implementiert werden kann.

7.1.2 Verzögerter Fibonaccigenerator

Um eine längere Periode zu erzielen, könnte man im Prinzip zu immer größeren Modulnm übergehen. Allerdings wird es immer schwieriger, entsprechende Konstanten zu bestim-men, und auch das Rechnen mit Zahlen großer Bitlänge ist aufwändiger. Eine einfacheAlternative sind verzögerte Fibonaccigeneratoren, die ähnlich wie ein LCG funktionieren,aber mehrere vorherige Werte benutzen:

xn = (xn−a + xn−b) mod m, (7.4)

wobei diesmal m beliebig ist und im Allgemeinen einfach als die Bittiefe des Rechnersgewählt wird. Anstelle der Addition kann auch die bitweise Addition modulo 2 benutztwerden. Diese Exklusiv-Oder-Operation war früher schneller als eine Addition und wurdedaher gern benutzt, bringt sonst allerdings eher Nachteile. Der interne Status des Zu-fallszahlengenerators besteht in diesem Fall aus max(a,b) vielen xi. Um diesen zu Anfangzu füllen, benutzt man üblicherweise einen LCG, der nur einen Startwert braucht.Im Fall a = b = 1 spricht man von einem Fibonaccigenerator, a und b sind ansonsten

die Verzögerungen. Der Name stammt von den Fibonaccizahlen, die ja der analogenRekursion xn = xn−1 + xn−2 genügen. Der Fibonaccigenerator selber, also a = b = 1, istnicht sehr geeignet, gerade für den in der Physik häufigen Fall von Dreierblöcken zeigter unerwünschte Korrelationen.Anders sieht es bei den verzögerten Fibonaccigeneratoren aus. Sofern

xa + xb + 1 (7.5)

ein primitives Polynom modulo zwei ist, also nicht faktorisierbar, hat der verzögerteFibonaccigenerator eine Periodenlänge von mindestens 2a − 1. Um einen 32-Bit-LCGan Periodenlänge zu übertreffen, sind also wenigstens 32 Registerplätze im Ringspeichernötig. Stoll und Kirkpatrick geben als Parameter a = 250, b = 103 an, eine anderemögliche Kombination ist a = 521, b = 168.In Code sieht ein einfacher verzögerter Fibonaccigenerator so aus:

114

7.2 Andere Verteilungen

class R250:m = 2**31 - 1

def __init__(self, init_rng):# Zustand mit anderem Generator initialisierenself.state = []for i in range(250):

self.state.append(init_rng())

def __call__(self):newval = (self.state[0] + self.state[250 - 103]) % self.m# neuen Wert anhaengenself.state.append(newval)# ... und aeltesten rauswerfendel self.state[0]return self.state[-1]

Der Konstruktor nimmt dieses Mal einen anderen Zufallszahlengenerator als Argument,der benutzt wird, um den Zustand zu füllen. Hierfür könnte man zum Beispiel eineInstanz der Rand-Klasse oder MinStd-Klasse benutzen, die dann wiederum einen Seedzur Initialisierung benötigt.


Die bisher besprochenen Zufallszahlengeneratoren liefern stets ganze Zahlen in einemgewissen Intervall, rand48 zum Beispiel im Intervall [0,231 − 1], MINSTD im Intervall[1,231 − 1]. Um daraus gleichverteilte Ganzzahlverteilungen in beliebigen Intervallen zuerzeugen, kann man die Zufallszahl einfach skalieren. Ist also u eine Zufallszahl, diegleichverteilt aus [a,b] gezogen wird, so ist

u′ =u− ab− a

(7.6)

gleichverteilt in [0,1] und umgekehrt

u′′ = a′ +(b′ − a′)(u− a)

b− a(7.7)

gleichverteilt in [a′,b′]. Dabei muß bei Ganzzahlarithmetik zuerst multipliziert und danndividiert werden, da u′ ≤ 1. Zusätzlich ist b meist knapp an der Bitlänge der Architektur,daher muss das Produkt mit doppelter Bitzahl berechnet werden. Da die Prozessoren, diezum wissenschaftlichen Rechen benutzt werden, meist auch sehr schnell Fließkommazah-len verarbeiten, kann alternativ auch u′ in Fließkommadarstellung berechnet werden unddaraus u′′. Soll u′′ ganzzahlig sein, kann einfach gerundet werden. Diesen Weg benutztzum Beispiel Python. Auf diese Weise können natürlich auch (pseudo-)zufällige gleichver-teilte Fließkommazahlen erzeugt werden, insbesondere Standardzufallszahlen, also Fließ-kommazahlen im Bereich [0,1].

115

7 Zufallszahlen

Wie aber können nun etwa normalverteilte Zufallszahlen erzeugt werden? Hierfür ler-nen wir nun mehrere Verfahren kennen, die Standardzufallszahlen in im Prinzip beliebigeandere Verteilungen umwandeln.

7.2.1 Verwerfungsmethode

Angenommen, wir wollen Zufallsvektoren gleichverteilt aus einer Kreisscheibe vom Ra-dius 1 ziehen, d. h. , wir wollen Zufallsvektoren p = (x,y) ziehen, die gemäß der Dichte

ρ(x, y) =

1/π für x2 + y2 ≤ 1

0 sonst(7.8)

verteilt sind. Abbildung 6.6 links zeigt, wie man dies bewerkstelligen könnte: man ziehtzunächst zwei unabhängig gleichverteilte Zufallszahlen auf [−1,1] und interpretiert dieseals Koordinaten p = (x, y). Liegt p in der Kreisscheibe, akzeptieren wir dies als unse-ren Zufallsvektor, ansonsten versuchen wir es einfach erneut. Da die Wahrscheinlichkeit,gezogen zu werden, für alle Kreisscheibenpunkte gleich ist, sind die zurückgelieferten pgleichverteilt. Als Code sieht dies so aus:


def kreisscheibe():while True:

x = uniform(-1, 1)y = uniform(-1, 1)if x**2 + y**2 <= 1:

return (x, y)

Da wir im Mittel nur 1− π/4 der gezogenen Punkte benutzen, brauchen wir 4/(4−π) malmehr Zufallszahlen, als wir als Koordinaten der Punkte zurückliefern. Im Falle des Kreisesist der Verlust nicht sehr hoch, aber ist die zulässige Struktur kleiner, können sehr vieleZufallszahlen zurückgewiesen werden, und die Verwerfungsmethode wird ineffizient.Im Falle der Kreisscheibe war die Dichte ρ(x, y) der gesuchten Verteilung sehr ein-

fach, nämlich entweder 0 oder 1/π. Die Verwerfungsmethode lässt sich aber auch beikomplizierteren ρ anwenden. Wir betrachten nun eine Dichte ρ : Rn → [0,1], so dass ρaußerhalb [0,1]n Null ist. Dann müssen die Punkte p mit relativen Wahrscheinlichkeitenρ(p) gezogen werden. Das lässt sich einfach bewerkstelligen, indem wir zunächst einenPunkt p durch Ziehen von n Standardzufallsvariablen gleichverteilt in [0,1]n bestimmen.Wir ziehen nun eine weitere Standardzufallszahl u und akzeptieren p nur dann, wennu ≤ ρ(p). Die Wahrscheinlichkeit, p tatsächlich zu ziehen, ist dann

P (u ≤ ρ(p)) = ρ(p). (7.9)

Die korrekte Wahrscheinlichkeit für einen Punkt p im Würfel ist die infinitesimaleDichte ρ(p) dp. Da der Normierungsfaktor dp für alle p gleich ist, sind die relativenWahrscheinlichkeiten auf [0,1]n trotzdem korrekt, und wir können den Normierungsfaktorvernachlässigen. Das bedeutet auch, dass die Eingabe-„Dichte“ ρ(p) gar nicht normiert

116


0.0 0.2 0.4 0.6 0.8 1.00.0

0.2

0.4

0.6

0.8

1.0

0.0 0.2 0.4 0.6 0.8 1.0x

0.0

0.5

1.0

1.5

2.0

2.5

3.0

ρ(x

)

Abbildung 7.1: Verwerfungsmethode zur unnormierten Verteilung ρ(x) = x2 für 0 ≤x ≤ 1. Links sind einige gezogene Punkte eingezeichnet, von denen die grünen Sterneakzeptiert wurden, die roten Kreise abgelehnt. Der schwarze Strich stellt ρ(x) dar. Rechtssind die beobachteten Häufigkeiten der Punkte als Balken dargestellt. Diese stimmen gutmit der normierten Dichte 3x2 überein, die rot gestrichelt eingezeichnet ist. Hier werdenim Schnitt etwa drei Zufallszahlen pro Aufruf der Verwerfungsmethode benötigt.

sein muss — die Verwerfungsmethode liefert stets Ergebnisse, die gemäß der normiertenDichte

ρ(p) := ρ(p)/

∫[0,1]n

ρ(q) dq (7.10)

verteilt sind. Damit können auch Dichten behandelt werden, die nicht in [0,1] liegen, solange sie beschränkt sind, denn man kann in diesem Fall

ρ′(p) =ρ(p) + minp∈[0,1]n ρ(p)

maxp∈[0,1]n ρ(p)−minp∈[0,1]n ρ(p)∈ [0,1] (7.11)

betrachten. Die Normierungseigenschaft ist auch sehr günstig, wenn die Normierungskon-stante nicht einfach bestimmt werden kann, etwa bei sehr hochdimensionalen Räumen.Dies ist die Grundlage des Metropolissampling, dass eine zentrale Rolle in der numeri-schen statistischen Physik spielt. Abbildung 7.1 illustriert die Verwerfungsmethode undihre Normierungseigenschaft.Im Falle der Kreisscheibe hatten wir übrigens auch von der Normierungseigenschaft

Gebrauch gemacht, denn eigentlich ist ρ(p) Null außerhalb der Kreisscheibe und 1/π inner-halb. Da wir aber die Punkte innerhalb automatisch akzeptiert haben, haben wir formalein ρ′ betrachtet mit ρ′(p) = 1 auf der Kreisscheibe. Dank der Normierungseigenschafthaben wir damit trotzdem die korrekte Verteilung erzeugt.

117

7 Zufallszahlen

Als Python-Code sieht die allgemeinere Verwerfungsmethode nicht wesentlich schwie-riger aus:


def verwerfungsmethode(rho, n):while True:

p = uniform(0, 1, n)u = uniform(0, 1)if u < rho(p):

return p

rho muss dabei eine Pythonfunktion sein, die als einziges Argument ein n-dimensionalesNumpy-Array akzeptiert.Die Verwerfungsmethode kann so erweitert werden, dass die benutzten Zufallszahlen

nicht gleichverteilt sind, sondern etwa normalverteilt. Das erlaubt, die Verwerfungsme-thode auch bei über dem gesamten Rn nichtverschwindenden Dichten zu benutzen. Siehehierzu zum Beispiel Knuth [Knu81]. Wie man solche normalverteilten Zufallszahlen er-zeugt, lernen wir nun kennen.

7.2.2 Inversionsmethode

Wegen der Beschränkung auf einen Würfel können wir die Verwerfungsmethode nichtbenutzen, um zum Beispiel normalverteilte Zufallszahlen aus gleichverteilten zu generie-ren. Wir benötigen also noch eine andere Methode, um auch unbeschränkte Verteilungenerzeugen zu können. Hier bietet sich die Inversionsmethode an.Sei ρ : R → R eine normierte Wahrscheinlichkeitsdichte, zu der wir passend Zufalls-

zahlen ziehen wollen. Dann definieren wir die Verteilungsfunktion zu ρ als

Fρ(x) := P (ξρ ≤ x) =

∫ x

−∞ρ(x′) dx′, (7.12)

wobei ξρ eine ρ-verteilte Zufallszahl ist. Fρ(x) gibt also die Wahrscheinlichkeit an, einenWert kleiner als x zu beobachten, und bildet daher die reelle Achse monoton wachsendin das Intervall [0,1] ab. Das p-Quantil ist nun die Umkehrung F−1

ρ (p), also diejenigeGrenze x, bei der ein gezogener Wert mit Wahrscheinlichkeit p kleiner als x ist. Es giltalso

Fρ(F−1ρ (p)

)= p. (7.13)

Wir betrachten nun F−1ρ (u), wobei u eine Standardzufallszahl ist, also gleichverteilt

auf [0,1]. Dann ist F−1ρ (u) eine ρ-verteilte Zufallsvariable, da

P (F−1ρ (u) ≤ x) = P (u ≤ Fρ(x)) = Fρ(x). (7.14)

Sofern also die Quantilfunktion einfach zu invertieren ist, lassen sich so sehr bequemZufallszahlen erzeugen, indem F−1

ρ auf Standardzufallszahlen angewendet wird.

118


0.0 0.2 0.4 0.6 0.8 1.0u

0.0

0.2

0.4

0.6

0.8

1.0

u′

3 2 1 0 1 2 3x

3

2

1

0

1

2

3

y

0.0 0.5 1.0 1.5 2.0 2.5 3.0 3.5 4.0r

0

1

2

3

4

5

6

φ

3 2 1 0 1 2 3z

0.0

0.2

0.4

0.6

0.8

1.0

P(z

)

Abbildung 7.2: Illustration des Box-Muller-Verfahrens zur Erzeugung von normalverteil-ten Zufallszahlen. Die Punkte werden zunächst gleichverteilt auf [0,1]2 erzeugt (linksoben), dann gemäß (7.17) auf das Gebiet [0,∞) × [0,2π] transformiert (links unten),und schließlich in kartesische Koordinaten (rechts oben). Die Punkte sind in allen dreiGraphen stets gleich gefärbt, und zwar mit wechselnder Farbe im Winkel und sinkenderIntensität nach außen. Rechts unten sind die gemessenen Verteilungen von x und y sowiedie erwartete Gaußverteilung gezeigt.

119

7 Zufallszahlen

Box-Muller-Verfahren

Mit Hilfe der Inversionsmethode können wir nun auch normalverteilte Zufallszahlen er-zeugen. Allerdings nicht auf direktemWege, da das Integral der Gaußfunktion, die Fehler-funktion, nicht einfach analytisch zu invertieren ist. Box und Muller gehen daher ähnlichwie bei der Bestimmung des uneigentlichen Integrals von e−x2 vor und weichen auf zweiDimensionen aus.Wir betrachten einen normalverteilten Zufallsvektor (x, y) mit Dichte ρ(x, y) =

12πe− 1

2(x2+y2). In Polarkoordinaten (φ,r) transformiert diese Dichte zu

ρ(φ, r) =1

2πe−

12r2r. (7.15)

Wir benötigen also einen gleichverteilten Zufallswinkel φ ∈ [0,2π], sowie einen Abstandr ∈ [0,∞) mit Dichte ρr(r) = e−

12r2r. Die zugehörige Verteilungsfunktion ist

Fρr(r) =

∫ r

0e−

12s2s ds = 1− e−

12r2 , (7.16)

deren Umkehrung, also das p-Quantil,

F−1ρr (p) =

√−2 log(1− p). (7.17)

Da mit p auch p − 1 gleichverteilt auf [0,1] ist, genügt im Logarithmus p. Durch Rück-transformation in kartesische Koordinaten folgt das Box-Muller-Verfahren als

z =√−2 log(u) cos(2πu′) (7.18)

z′ =√−2 log(u) sin(2πu′) (7.19)

mit zwei Standardzufallszahlen u, u′. Diese werden in zwei unabhängige, normalverteilteZufallszahlen z und z′ transformiert. Anders als bei der Verwerfungsmethode erhält manalso genauso viele normalverteilte Zufallszahlen wie gleichverteilte verbraucht werden,allerdings müssen diese immer paarweise erzeugt werden. Abbildung 7.2 illustriert dieAnwendung der Inversionsmethode zur Erzeugung normalverteilter Zufallszahlen.

7.2.3 Zufällige Punkte auf Kugel und Kugeloberfläche

Wie wir bereits gesehen haben, lassen sich mit Hilfe der Verwerfungsmethode gleichver-teilt Positionen in der Kreisscheibe ziehen, und analog natürlich auch Positionen ausjeder Kugel im Rn. Allerdings nimmt die Akzeptanzrate mit steigendem n rasch ab, dadie n-Kugel nur noch einen kleinen Teil von [−1,1]n belegt. Bis etwa n = 4 ist die Verwer-fungsmethode allerdings sehr effizient, was für die meisten physikalischen Anwendungenreicht.Sollen Punkte auf der Kugeloberfläche gezogen werden, so können diese im Prinzip

aus über der Kugel gleichverteilten Punkten p gewonnen werden, indem diese auf dieOberfläche projiziert werden, also p/ ‖p‖ betrachtet. Allerdings benötigt man auf diese

120

7.3 Qualitätsanalyse

Weise n Zufallszahlen, um einen Zufallsvektor auf der nur n−1-dimensionalen Oberflächezu generieren, zusätzlich zu den Verlusten durch die Verwerfungsmethode. Daher ist esim Einzelfall besser, eine geschickte Parametrisierung der Oberfläche zu nutzen.Für die Oberfläche der zweidimensionalen Kugel, also den Kreis, ist dies sehr einfach,

da dieser über einen Winkel φ ∈ [0,2π] gleichmäßig parametrisiert wird. Wird also eineStandardzufallszahl u gezogen, so sind die Punkte

x = r sin(2πu)

y = r cos(2πu)(7.20)

gleichverteilt auf einem Kreis vom Radius r um Null.Für die Oberfläche der dreidimensionalen Kugel, also die 2-Sphäre, ist nicht etwa die

gebräuchliche Parametrisierung über zwei Winkel am besten, sondern die Parametrisie-rung in Zylinderkoordinaten φ und z. Der Winkel φ ist offenbar gleichverteilt und kannals 2πu bestimmt werden, wobei u eine Standardzufallsvariable ist. z ist erstaunlicher-weise ebenso gleichverteilt, da ρ(z) proportional zum Flächeninhalt des jeweiligen Ringsist, dividiert durch den gesamten Flächeninhalt, also

ρ(z) =1

4πr22π√r2 − z2

√1 +

(d

dz

√r2 − z2

)2

=1

2r(7.21)

für −r ≤ z ≤ r.Um eine gleichverteilte Position auf der Kugeloberfläche zu ziehen, genügt es daher,

zwei Standardzufallszahlen u und u′ zu berechnen, und diese gemäß

z = r(2u′ − 1)

y =√r2 − z2 cos(2πu)

x =√r2 − z2 sin(2πu)

(7.22)

zu transformieren.


Um die Qualität eines Zufallszahlengenerators zu testen, gibt es eine Vielzahl von Stan-dardtests. Der Grund dafür ist, dass es leider keinen einzelnen Test gibt, der sicherstellt,dass es keinerlei Korrelationen in der generierten Folge gibt. Ein solcher Test müsste jedemögliche Teilmenge bilden und mit allen Zahlen korrelieren, was praktisch nicht möglichist. Daher sollte ein guter Zufallszahlengenerator möglichst viele der folgenden Tests er-füllen, auch wenn dies keine Garantie ist, dass er im Einzelfall nicht doch zu kritischenKorrelationen führt, die im schlimmsten Fall das Ergebnis beeinflussen.Für eine bestimmte Anwendung genügt es natürlich, wenn er nur die Tests erfüllt, deren

getestete Korrelationen Einfluss auf das System haben. Zum Beispiel werden bei einerMolekulardynamiksimulation in drei Dimensionen Paarkorrelationen unwichtig sein, aberTripletkorrelationen problematisch. Bei einem zweidimensionalen Isingmodell hingegen

121

7 Zufallszahlen

wird es genau umgekehrt sein. In jedem Fall aber sollte die Periode des Generators wiebesprochen groß genug sein.Für die im Folgenden beschriebenen Tests nehmen wir an, dass der zu testende Zufalls-

zahlengenerator Standardzufallszahlen liefert, also gleichverteilt im Intervall [0,1]. SolcheZufallszahlen werden wie beschrieben standardmäßig auf dem Computer erzeugt und imBedarfsfall auf andere Verteilungen transformiert.

7.3.1 Statistiktests

Am naheliegendsten ist, zu überprüfen, dass die Verteilung der Zufallszahlen tatsächlichgleichförmig ist. Dazu legen wir Grenzen 0 = b0 < b1 < . . . < bM = 1 fest und zählen, wieoft Mittelwerte in den Intervallen [bi,bi+1) auftreten. Wir bilden also das Histogramm dergezogenen Zufallszahlen. Die Wahrscheinlichkeit, eine Zufallszahl im Intervall [bi,bi+1) zuziehen, ist

Pi = P (bi ≤ x < bi+1) = bi+1 − bi . (7.23)

Für die Anzahl der Treffer in diesem Intervall gilt

〈Ni〉 = N Pi = N(bi+1 − bi) , (7.24)

wobei N die Gesamtanzahl der gezogenen Zufallszahlen ist. Wählt man die bi äquidistantmit Intervallbreite h, sollte also das gewonnene Histogramm der Ni möglichst konstantN/h sein. Dies kann man leicht in einer Visualisierung des Histogramms überprüfen.Quantifiziert wird die Abweichung durch die Größe

χ2 =M∑i=1

(Ni −NPi)2

NPi, (7.25)

die die quadratische Abweichung über die Intervalle mittelt. Der Name χ2 rührt daher,dass diese Größe für große Ni der sogenannten χ2-Verteilung mitM Freiheitsgraden folgt.Wann ist nun χ2 klein genug, so dass man davon ausgehen kann, dass die Reihe tat-

sächlich gleichverteilt ist? Dazu betrachten wir das 1− p-Quantil der Verteilung. Diesesgibt an, welchen maximalen Wert χ2 in 1 − p aller Fälle annimmt. Ist der beobachteteWert größer, tritt dies in weniger als p aller Fälle auf. Das 1−p-Quantil der χ2-Verteilungist leider nicht sehr einfach zu berechnen, allerdings gibt es im Internet zahlreiche Tabel-len, siehe zum Beispiel http://de.wikipedia.org/wiki/Chi-Quadrat-Test.Bei M = 10 Intervallen ist das 99%-Quantil etwa 22. Falls wir also χ2 > 22 beobachten,bedeutet das, dass unsere Zufallsreihe mit 99%-iger Wahrscheinlichkeit nicht gleichver-teilt ist.χ2 folgt übrigens stets dieser Verteilung, auch wenn die Ausgangsdaten nicht gleich-

verteilt sind. In der Statistik wird der oben beschriebene Test unter dem Namen χ2-Testhäufig benutzt, um zu überprüfen, ob eine Stichprobe von Daten einer angenommenenVerteilung entspricht.

122

http://de.wikipedia.org/wiki/Chi-Quadrat-Test


0.35 0.40 0.45 0.50 0.55 0.60 0.650

2

4

6

8

10

12

14

0.35 0.40 0.45 0.50 0.55 0.60 0.650

2

4

6

8

10

12

14

Abbildung 7.3: Verteilung von x = 1100

∑100i=1 xi, ermittelt aus 10.000×100 Werten der

Zufallsgeneratoren rand (links) und randu (rechts). Rot gestrichelt ist jeweils die er-wartete Normalverteilung mit Varianz 1/

√1200 eingezeichnet.

Blocking

Um mögliche Korrelationen auszuschließen, teilen wir die gezogenen Zufallszahlen wiebei der Binning-Methode in Blöcke der Größe k ein. Sind die erzeugten Zufallszahlen xitatsächlich gleichverteilt und auf [0,1] und unabhängig, so sind die Blockmittelwerte

Xi =1

k

k∑j=1

xj+(i−1)k , (7.26)

nach dem Gesetz der großen Zahlen für hinreichend großes k nahezu normalverteilt. Inder Praxis genügt dazu etwa k = 100. Der Mittelwert ist 〈Xi〉 = 1/2 und die Varianz

σ(Xi) =1√kσ(x) =

1√12k

. (7.27)

Abbildung 7.3 zeigt die Verteilung der Xi mit Blockgröße k = 100 am Beispiel vonMINSTD und rand im Vergleich zur erwarteten Normalverteilung, die tatsächlich mitguter Genauigkeit reproduziert wird.Die Blockvarianz können wir leicht mit Hilfe des Varianzschätzers

B

B − 1

((x− x)2

)!≈ 1√

12k(7.28)

überprüfen, wobei B = N/k die Anzahl der Blöcke ist. Besser ist es aber, die gesamteVerteilung der Zufallszahlen zu testen. Hierzu können wir wieder den χ2-Test benutzen.

123

7 Zufallszahlen

0.0 0.2 0.4 0.6 0.8 1.00.0

0.2

0.4

0.6

0.8

1.0

0.0 0.2 0.4 0.6 0.8 1.00.0

0.2

0.4

0.6

0.8

1.0

0.20.40.60.8 0.20.4

0.60.8

0.20.40.60.8

Abbildung 7.4: Quadrat- und Würfeltest mit 2,000 Auswertung am Beispiel des berüch-tigten randu-Zufallszahlengenerators. Der zweidimensionale Poincaré-Schnitt ist homo-gen und unauffällig, aber in drei Dimensionen fallen die nur sehr wenigen Hyperebenendes Generators deutlich auf.

Die erwartete Anzahl der Treffer im Interval [bi,bi+1) ist diesmal

〈Ni〉 = B P (bi ≤ x < bi+1) = B

∫ bi+1

bi

1√24πk

exp

[1

24k

(x− 1

2

)2]dx . (7.29)

Für die in Abbildung 7.3 gegebenen Daten ergibt sich ein χ2-Wert von 30 (rand) bzw.39 (MINSTD). Bei M = 50 Freiheitsgraden ist das 99%-Quantil der χ2-Verteilung etwa76, beide Generatoren erzeugen also hinreichen unkorrelierte Blöcke der Länge 100.

7.3.2 Poincaré-Schnitte

Lineare Kongruenzgeneratoren haben nach einem Satz von Marsaglia die Eigenschaft,dass im Rn n aufeinanderfolgende Zufallszahlen, als Vektor aufgefasst, auf Hyperebenenliegen. Problematisch wird dies, wenn die Anzahl der Hyperebenen sehr klein ist. Fürn = 2 und 3 kann man das sehr bequem überprüfen, indem man den Poincaré-Schnitt(xk, xk+1), k = 0,1, . . . bzw. sein dreidimensionales Äquivalent (xk, xk+1, xk+2), k =0,1, . . . betrachtet. Da alle Punkte in [0,1]2 bzw [0,1]3 liegen, heißen dieses Tests auchQuadrat- oder Würfeltests. Diese Punktwolken sollten das Quadrat bzw. den Würfelhomogen füllen und keine Strukturen aufweisen. In zwei Dimensionen können wir dassehr rasch erfassen, in drei Dimensionen muss man die Punktewolke rotieren, um nachHyperebenen zu suchen.Abbildung 7.4 demonstriert dies für den berüchtigten randu-LCG (m = 231, a =

65,539, b = 0). Dieser ist wegen des 231-Moduls sehr schnell auf 32-Bit-Rechnern zu

124


0 5 10 15 20 25 3010-5

10-4

10-3

10-2

10-1

100

0 5 10 15 20 25 30

0.00

0.02

0.04

0.06

0.08

Abbildung 7.5: Spektraltest (links) und Autokorrelationsfunktion (rechts) für die Zufalls-zahlengeneratoren rand und randu. rand ist als blaue Fläche bzw. gepunktet einge-zeichnet, randu rot gestrichelt. Im linken Graph sind die DFT-Amplituden normiertdargestellt, also dividiert durch die Anzahl der Zufallszahlen, so dass die 0-te Mode1/2 beträgt. Leider reichen diese Tests nicht aus, um die 3-Periodizität von randu zudetektieren.

implementieren und war daher früher sogar auf einigen Großrechnern zu finden. In derzweidimensionalen Darstellung sind keine Auffälligkeiten zu sehen, aber ausgerechnet inden physikalisch wichtigen drei Dimensionen zeigt sich, dass es lediglich eine Handvollverschiedener Hyperebenen gibt, so dass mit diesem Generator erzeugte 3d-Vektorenkaum als zufällig gelten können.

7.3.3 Fouriertest

Wird eine lange Reihe von Standardzufallszahlen diskret Fourier-transformiert, so solltedie 0-te Mode eine Amplitude vonN/2 aufweisen, da diese ja die Summe der Zufallszahlenangibt. Alle anderen Moden sollten vernachlässigbar kleine, gleichmäßige Amplitudenhaben, entsprechend einem weißen Rauschen. Die Amplituden aller Frequenzen ungleich0 sollte außerdem mit der Länge der transformierten Zufallszahlenreihe sinken. DieserTest wird auch als Spektraltest bezeichnet. Abbildung 7.5 zeigt die DFT am Beispiel vonrand und randu. Leider reichen diese Tests nicht aus, um die Probleme von randu zuerkennen.

125

7 Zufallszahlen

0 20 40 60 80 100t

15

10

5

0

5

10

15

20

xt 0 20 40 60 80 100

t

0

20

40

60

80

100

<x

2 t>

20 15 10 5 0 5 10 15 20xt

0.000.020.040.060.080.100.120.140.160.18

P(x

t)

Abbildung 7.6: Links: 3 mögliche Random walks gemäß (7.32), als Funktion der Zeit t.Rechts oben ist das mittlere Verschiebungsquadrat als Funktion der Zeit gezeigt, gemitteltüber 1000 Random walks. Die gestrichelte Linie markiert dabei das analytisch erwarteteErgebnis

⟨x2T

⟩= T . Rechts unten die Verteilungen der Positionen zu den Zeitpunkten

t = 5 (rote, gefüllte Balken) und t = 80 (blaue, offene Balken). Gestrichelt sind wiederdie jeweils erwarteten Normalverteilungen eingezeichnet.

7.3.4 Autokorrelationstest

Neben der diskreten Fouriertransformierten kann man auch die Autokorrelationsfunktionder Zufallsreihe u bestimmen, also

C(u,u)(k) =1

NiDFT

(DFT(u)(n)DFT(u)(n)

)(k). (7.30)

Für eine Zufallsreihe sind alle paarweise verschiedenen Werte unkorreliert, also muss

C(u,u)(k) = σ2(u)δk =1

12δk (7.31)

gelten. Dies ist in Abbildung 7.5 rechts demonstriert.

7.4 Beispiel: Random walk

Als Beispiel für die Anwendung von Zufallszahlen in der physikalischen Simulation sollder Randomwalk („Irrfahrt“) dienen, der in vielen Problemen der statistischen Physikeine Rolle spielt. Das klassische Beispiel ist die Brownsche Bewegung von Partikeln inWasser oder anderen Flüssigkeiten. Diese wird durch die unzähligen Stöße der Lösungs-mittelmoleküle auf das betrachtete Teilchen erklärt.

126


Hat das betrachtete Teilchen einen Durchmesser von nur 1µm, so befinden sich anseiner Oberfläche zu jedem Zeitpunkt ca. eine halbe Milliarde Lösungsmittelmoleküle.Deren Bewegung explizit simulieren zu wollen, ist aussichtslos. Auf der anderen Seitepassieren selbst in kurzer Zeit genügend Zusammenstöße, so dass die zeitdiskretisierteKraft auf das Teilchen gut als zufällig und, wegen des Gesetzes der großen Zahlen, alsnormalverteilt angenommen werden kann. Der Mittelwert ist dabei offenbar Null, dadie Zufallsstöße keine Vorzugsrichtung haben sollten, die Varianz werden wir mit derDiffusionskonstanten in Verbindung bringen.Um diesen Prozess zu simulieren, können wir uns zunächst auf ein eindimensionales

Modell beschränken, da die Stöße in den einzelnen Koordinaten unabhängig sind. Indemwir das Gesetz der großen Zahl andersherum anwenden, können wir außerdem eine belie-bige, aber symmetrische Verteilung der Stöße annehmen. Die einfachste Möglichkeit ist,einfach mit gleicher Wahrscheinlichkeit dieselbe Distanz vor- oder zurückzugehen.Wir betrachten also ein Teilchen mit Position xt zum Zeitpunkt t = 1, 2, . . ., so dass

xt+1 = xt +

−1 mit Wahrscheinlichkeit 1/2+1 mit Wahrscheinlichkeit 1/2.

(7.32)

Ein Random walk ist eine Folge xt, die durch eine solche einfache stochastische Bewe-gungsgleichung beschrieben wird. Abbildung 7.6 zeigt links drei mögliche Random walks.Sie wurden durch eine Routine ähnlich der folgenden generiert:

def rw(N):x = 0xt = [ x ]for move in randint(0,2,N):

if move == 0: x += -1elif move == 1: x += 1xt.append(x)

return xt

Dieses Modell ist so einfach, dass wir seine statistischen Eigenschaften fast vollständiganalytisch berechnen können. So ist zum Beispiel

〈xt〉 =

⟨t∑

s=1

us

⟩= 0, (7.33)

wobei us = xs − xs−1 den s-ten Schritt des Random walks bezeichnet, und daher 〈us〉 =0 gilt. Die mittlere Position des Random walks bleibt also stets am Ausgangspunkt.Allerdings wird die Verteilung der Punkte xt mit t immer breiter, denn für das mittlereVerschiebungsquadrat gilt

⟨x2t

⟩=

⟨t∑

s,r=1

usur

⟩=

t∑s=1

⟨u2s

⟩= tσ2(us) = t. (7.34)

Für hinreichend große t kennen wir damit auch die Wahrscheinlichkeitsdichte der Po-sitionen, die gemäß dem Gesetz der großen Zahlen praktisch Gaußsch ist, mit Varianz

127

7 Zufallszahlen

σ2(xt) =⟨x2t

⟩= t. Es ergibt sich

ρ(x, t) = ρ(xt) ≈1√2πt

exp

(−x

2

2t

). (7.35)

Abbildung 7.6 zeigt rechts oben das mittlere Verschiebungsquadrat σ2(xt), gemitteltüber 1,000 Random walks. σ2(xt) ist tatsächlich mit guter Genauigkeit ungefähr t, wobeidie Abweichung für große t größer sind, da dort die Verteilung von xt breiter ist, unddamit auch der Fehlerbalken der Varianz. Rechts unten werden für t = 5 und t = 80 dieVerteilungen der Positionen gezeigt. Selbst für t = 5 werden diese gut durch die Gauß-glocke beschreiben. Trotzdem sollte man sich erinnern, dass die Verteilung nicht wirklichGaußsch ist, da offenbar |xt| ≤ t gilt. Denn der maximale Abstand ist erreicht, wennwir t-mal nur nach links oder rechts gehen. Während also die Gaußverteilung prinzipi-ell beliebig hohe Werte mit sehr kleiner Wahrscheinlichkeit zulässt, ist die tatsächlicheVerteilung beschränkt.Das Modell lässt sich leicht auf mehrere Dimensionen erweitern, denn die Zufallsbe-

wegungen in den einzelnen Koordinaten sind ja unabhängig. Die mittlere Position desRandom walks in n Dimensionen ist damit immer noch konstant gleich der Ausgangs-position, das mittlere Verschiebungsquadrat die Summe der Verschiebungsquadrate derKoordinaten, also

⟨x2t

⟩= ntσ2(u), wobei σ2(u) das Verschiebungsquadrat der einzelnen

Dimensionen bezeichnet.

Diffusion

Was ist nun die Bedeutung der Konstanten σ2(u) = σ2(xt)/t? Wir verallgemeinern denRandom walk, der bisher in Zeit um ∆t = 1 und Raum um ±∆x = ±1 gesprungen ist,auf beliebige Werte ∆x und ∆t. Dann gilt offenbar σ2(u) = ∆x2/∆t. Wir betrachtennun die Master-Gleichung der diskreten Wahrscheinlichkeitspopulationen

∆p(x, t+ ∆t) = p(x, t+ ∆t)− p(x, t) =1

2p(x−∆x, t) +

1

2p(x+ ∆x, t)− p(x, t). (7.36)

Die erste Term der rechten Seite besagt, dass das Teilchen beim Sprung t → t + ∆ mitWahrscheinlichkeit 1

2 an der Stelle x landet, wenn es sich zum Zeitpunkt t an der Stellex − ∆x befand. Der darauffolgende Term bedeutet dasselbe für x + ∆, und der letzteTerm, dass das Teilchen nicht an der aktuellen Stelle bleiben kann.Wir multiplizieren nun linker Hand mit ∆t−1 und rechter Hand mit ∆x−2:

∆p(x, t+ ∆t)

∆t=σ2(u)

2∆x2(p(x−∆x, t) + p(x+ ∆x, t)− 2p(x, t)) . (7.37)

Lassen wir nun ∆t → 0 und ∆x → 0 gehen, wird aus dieser Gleichung die Differential-gleichung

δ

δtp(x, t) = D

δ2

δx2p(x, t) (7.38)

mit D = σ2(u)/2. Dies ist nichts anderes als die Diffusionsgleichung mit Diffusionskon-stante D. Die Varianz σ2(u) unseres Zufallsschritts ist also genau die doppelte Diffu-sionskonstante unserer makroskopischen Teilchen, und durch geeignete Wahl von σ2(u)können wir die Diffusionskonstante unserer Random walk-Teilchen einstellen.

128


Abbildung 7.7: Kontinuierlicher Random walk als einfaches Polymermodell mit n = 100Monomeren. Das Polymer wurde mit der Simulationssoftware ESPResSo [Esp] erzeugtund dem Visualisierungstool VMD [Vmd] gezeichnet.

Random walks als Polymermodell

Man kann für den mehrdimensionalen Random walk leicht zeigen, dass es keinen we-sentlichen Unterschied macht, wenn die nächsten Positionen nicht diskret ±1 in allenDimensionen gewählt werden, sondern zum Beispiel kontinuierlich oder auf einer Sphäre,d. h. ,

xt+1 = xt + u mit ‖u‖ = 1, u gleichverteilt. (7.39)

Ein solcher kontinuierlicher Random walk kann mit Hilfe von (7.22) leicht numerischerzeugt werden, ein Beispiel ist in Abbildung 7.7 gezeigt.Die letztere Wahl ist ein einfaches Modell für Polymere unter bestimmten Voraus-

setzungen (in einem sogenannten θ-Lösungsmittel). In diesem Fall ist t allerdings keineZeitachse, sondern zählt einfach die Monomere entlang der Polymerkette durch.In guten Lösungsmitteln streckt sich das Polymer etwas mehr. Auch dies lässt sich

durch einen Random walk modellieren, bei dem die Monomere eine endliche Ausdehnunghaben und nicht überlappen können. Ein solcher Random walk heißt auch Self avoidingwalk, weil er sich selbst nicht kreuzen kann. In unserem einfachen Random walk-Modell(7.32) entspricht das der Bedingung xt 6= xs für alle s 6= t und ist auf dem Computerrelativ einfach zu erstellen.Um einen Self avoiding walk zu generieren, erzeugt man einfach einen Random walk,

und überprüft mit jedem neuen Punkt, ob dieser einem anderen Monomer näher kommtals die Größe der Monomere zulässt. In diesem Fall muss man allerdings ganz von vornebeginnen, da sonst extrem ungünstige Konfigurationen bevorzugt werden. Bei diesen wür-de ja quasi beliebig lange probiert, den nächsten Punkt zu setzen, selbst wenn es nur eineverschwindend geringe Wahrscheinlichkeit gibt, diesen Punkt zufällig zu treffen. Daherwerden taschenartige Konfigurationen sehr viel wahrscheinlicher, als sie zufällig auftretenwürden. Ab etwa 100 Monomeren ist die Wahrscheinlichkeit, einen Random walk abzu-lehnen, schon sehr hoch, und die Erzeugung eines Self avoiding walks dementsprechendaufwändig.Auch von der Theorie her ist der Self avoiding walk sehr viel komplizierter. So gilt

129

7 Zufallszahlen

30 40 50 60 70 80

30

40

50

60

70

80

60 80 100 120 140 160

60

80

100

120

140

160

Abbildung 7.8: Cluster aus diffusionslimitierter Aggregation mit N = 500 (links) undN = 2000 (rechts) Teilchen. Die Teilchen sind in der Reihenfolge der Anlagerung farblichcodiert.

etwa⟨x2N

⟩∼ N2ν mit ν ≈ 0.588, so dass das Polymer im Mittel tatsächlich etwas mehr

gestreckt ist als der Random walk mit ν = 1/2. Der Wert von ν für den Self avoidingwalk kann, anders als beim Random walk, nicht analytisch berechnet werden, sondernnur aufwändig numerisch genähert.Der Self avoiding walk wie auch der einfache Random walk spielen nach wie vor eine

wichtige Rolle in der Polymerphysik, insbesondere beim Aufsetzen von Polymersimulatio-nen. Daher besitzt die Simulationssoftware ESPResSo [Esp] zum Beispiel einen eigenenBefehl, um solche Zufallsketten zu erzeugen.

Diffusionslimitierte Aggregation

Eine weitere Anwendung des Random walks ist die diffusionslimitierte Aggregation, dieetwa die Bildung von Rußaggregaten modelliert. Dabei wird davon ausgegangen, dasssich diese aus einem Keim durch Anlagerung von weiteren Teilchen bilden, die aus demUnendlichen heran diffundieren.Für die Modellierung werden Random walks genutzt, die zufällig auf einer Kugelsphäre

um den Keim gestartet werden, bis sie entweder am Cluster anlagern oder sich zu weitvom Kreis entfernt haben. Abbildung 7.8 zeigt zwei solche DLA-Cluster mit 500 und 2000Teilchen auf einem zweidimensionalen Gitter. Die beiden Cluster haben eine sehr ähnlicheStruktur, auch wenn die Maßstäbe deutlich anders sind. Das hängt damit zusammen, dasssolche diffusionslimitierte Aggregate selbstähnliche Fraktale sind. Quelltext 7.1 zeigt denPython-Code zur Erzeugung solcher zweidimensionaler DLAs.Die zentrale Frage beim Studium von DLA-Clustern ist die nach ihrer fraktalen Di-

130


mension. In drei Dimensionen legen wir zu ihrer Bestimmung konzentrische Kugeln mitRadius R um den Keim eines sehr großen Clusters, und zählen die Anzahl der TeilchenN(R) in dieser Kugel. Die fraktale Dimension ist dann

d = limR→∞

logN(R)

logR. (7.40)

In der Praxis betrachtet man natürlich einfach mehrere große Cluster verschiedenerGröße, um d abzuschätzen. Wäre der Cluster solide mit Teilchendichte ρ, so wäreN(R) = ρ4π

3 R3 und

logN(R)

logR=

log(ρ4π

3 R3)

logR= 3 +

log(ρ4π

3

)logR

, (7.41)

die fraktale Dimension also wie erwartet 3. Der DLA-Cluster in drei Dimensionen hatübrigens eine fraktale Dimension von ≈ 1,6, ist also bei weitem kein solides Objekt. Daherwerden solche Cluster gerne als Katalysatoren verwendet, da sie eine entsprechend großeOberfläche haben.

Listing 7.1: Code zur Erzeugung eines DLA-Clusters auf einem zweidimensionalen Gitterworld. Die Eingabeparameter sind die Größe M des Gitters, sowie die Anzahl der Punktedes zu erzeugenden Aggregats N. Das Aggregat entsteht durch sukzessive Anlagerungmit Hilfe von Random walks, die auf einem langsam wachsenden Kreis um das aktuelleAggregat starten. Der Radius R diese Kreises ist stets um 5 Gittereinheiten größer alsder Umkreis des Clusters.

# Diffusionslimitierte Aggregation (DLA) in 2D##############################################from scipy import *from numpy.random import *import matplotlib.pyplot as pyplot

seed(123)

# Laenge einer GitterseiteM = 201# Anzahl der anzulagernden TeilchenN = 1500

# Zentrum, wo der Keim sitztctr = (M+1)/2# 2D-Simulationsgitter, 1 bedeutet besetztworld = zeros((M,M))# Der Keim ist schon daworld[ctr,ctr] = 1

# Anlagerung##########################################

# angelagerte Punkte fuer die Ausgabept_history = []# Startradius, waechst mit der ZeitR = 5

131

7 Zufallszahlen

def center_dist(x, y):return sqrt((x - ctr)**2 + (y - ctr)**2)

for n in range(N):print "Anfuegen von Teilchen", nattached = Falsewhile not attached:

# Startpunkt auf Kreis um das Zentrumphi = uniform(0, 2*pi)x = int(round(ctr + R*cos(phi)))y = int(round(ctr + R*sin(phi) + 0.5))

running = Truewhile running:

xalt, yalt = x, ymove = randint(0,4)if move == 0: x += -1elif move == 1: x += 1elif move == 2: y += -1elif move == 3: y += 1

if center_dist(x, y) >= 2*R or \x < 0 or x >= M or y < 0 or y >= M:

# zu weit draussen, abbrechen und neu startenrunning = False

elif world[x, y] == 1:# Angelagert!world[xalt, yalt] = 1# Angelargertes Teilchen merkenpt_history.append((xalt, yalt))# Radius anpassenR = max(R, center_dist(xalt, yalt) + 5)if R >= 0.4*M:

raise Exception("Radius bzw. N zu gross!")running = Falseattached = True

# Ausgabe##########################################

# Liste von Paaren in Paar von Listen verwandelnxx, yy = zip(*pt_history)

pyplot.hsv()pyplot.scatter(xx, yy, c=range(len(xx)))pyplot.axis((ctr-R,ctr+R,ctr-R,ctr+R))pyplot.show()

7.5 Beispiel: Perkolation

Ein anderes Beispiel eines Zufallsalgorithmus ist die Perkolation, also die Frage, wann einZufallsmedium einen durchgehenden Kanal zulässt oder nicht. Anwendungsbeispiele sindetwa poröse Medien, die Flüssigkeiten nur passieren lassen, falls es einen durchgehendenHohlraum gibt, oder eine Mischung von Isolator und Leiter, die nur leitet, wenn es eineleitende Verbindung gibt.

132


0 10 20 30 400

10

20

30

40

0.5 0.6 0.7p

0.0

0.2

0.4

0.6

0.8

1.0

Perk

olat

ions

w-k

eit

Abbildung 7.9: Ein perkolierender Cluster auf einem 502-Gitter mit p = 0,6. Blaue Punk-te markieren den Cluster, Kreuze andere, mit diesem Cluster nicht verbundene, aberbesetzte Gitterpunkte. Im rechten Graph ist für L = 5 (grüne Sterne), L = 20 (blaueRauten) und L = 100 mit welcher Wahrscheinlichkeit bei Besetzung p ein perkolierenderCluster gefunden wurde. Für L = 100 ist dies ein bereits sehr scharfer 0–1-Übergang inNähe von 0,6.

Modellieren lässt sich dies als ein Gitter, dessen Zellen mit einer gewissen Wahrschein-lichkeit p besetzt sind. Die Frage ist dann, ab welcher kritischen Wahrscheinlichkeit pces im Regelfall einen Cluster von benachbarten, besetzten Feldern gibt, der das gesamteSystem in einer Richtung durchzieht, man sagt, perkoliert. Diese Grenze lässt sich durchUntersuchen sehr vieler zufälliger Besetzungen untersuchen.Die Besetzungen sind dabei natürlich durch stochastisches Belegen des Gitters sehr

einfach zu erzeugen, algorithmisch etwas schwieriger ist nur, zu bestimmen, ob es einenperkolierenden Cluster gibt, also einen, der eine Seite mit der gegenüberliegenden ver-bindet.Eine Möglichkeit ist, die Struktur von einer Seite aus gewissermaßen zu „fluten“, und

zu sehen, ob man dabei die gegenüberliegende Seite erreicht. Erreichen heißt hier, dass eseinen zusammenhängenden Pfad von paarweise benachbarten, besetzten Punkten gibt.Um dies zu überprüfen, erzeugen wir zunächst eine Liste der besetzten Punkte am Start-rand. Dann fügen wir zu dieser Liste alle benachbarten Punkte hinzu, und wiederholendies solange, bis keine neuen Elemente mehr zur Liste hinzugefügt wurden. Die Listeenthält dann alle Punkte, die Verbindung zum Startrand haben. Wir müssen nur nochüberprüfen, ob in dieser Liste Punkte am gegenüberliegenden Rand auftauchen.In dieser Form wäre der Algorithmus recht langsam, weil man ständig wieder Punkte

hinzufügen würde, die bereits in der Liste sind, und diese erneut untersucht. Um dies zuvermeiden, führt man einfach eine zweite Liste der Punkte, deren Nachbarn noch nicht

133

7 Zufallszahlen

untersucht wurden. Ein Punkt, der noch nicht in der Liste der verbunden Punkte steht,wird dann nicht nur zu dieser, sondern auch zur Liste der zu bearbeitenden Punkte hin-zugefügt. Dann müssen nur die Nachbarn der Punkte in dieser Liste betrachtet werden,und sobald die Nachbarn eines Punkts einmal untersucht wurden, kann dieser aus derListe der zu bearbeitenden Punkte gestrichen werden. Da er aber immer noch als ver-bunden markiert ist, wird er auch nie ein zweites Mal in die Liste der zu bearbeitendenPunkte eingefügt werden. Der Algorithmus terminiert also, da die abzuarbeitende Listeirgendwann leer ist. Ein entsprechendes Python-Skript ist in Listing 7.2 zu sehen.Abbildung 7.9 zeigt links einen perkolierenden Cluster für ein Gitter mit Besetzungs-

wahrscheinlichkeit p = 0,6, es sind also etwas mehr als die Hälfte der Punkte besetzt.Rechts ist für verschiedene Besetzungswahrscheinlichkeiten aufgetragen, wie wahrschein-lich es ist, einen perkolierenden Cluster zu beobachten. Wie man sieht, ist p = 0,6 nichtohne Grund gewählt, denn dies ist sehr dicht am kritischen Perkolationsschwellwert. Dertatsächliche Wert des Schwellwerts ist pc ≈ 0,593 im Limit unendlicher Gittergröße, wieman zeigen kann. Mit steigender Kantenlänge wird der Übergang bereits bei endlichenGittern relativ scharf, bei L = 100 ist der Grenzbereich weniger als 0,06 in p breit. Bei ei-ner Besetzung von 0,56 ist Perkolation äußerst unwahrscheinlich, bei 0,6 gibt es hingegenschon für die Mehrheit der Gitter einen perkolierenden Cluster.Ähnlich wie beim Random walk kann auch die Perkolation in unzähligen Variationen

betrachtet werden, etwa andere zugrundeliegende Gitter, höhere Dimensionen oder auchkontinuierliche Modelle.

134


Listing 7.2: Code zur Schätzung des Perkolationsschwellwerts auf einem zweidimensiona-len quadratischen Gitter world. Die Liste connected enthält die alle Punkte, die mitdem oberen Rand verbunden sind, die Liste connected_undone diejenigen verbunde-nen Punkte, deren Nachbarn noch untersucht werden müssen.

# Perkolation##############################################from scipy import *from numpy.random import *import matplotlib.pyplot as pyplot

seed(123)

# Laenge einer GitterseiteM = 50# Wahrscheinlichkeit einer Gitterzelle, besetzt zu seinp = 0.55# wie oft wir messen, um die W-keit zu bestimmensamples = 100

def try_percolation(M, p):# 2D-Simulationsgitter, 1 bedeutet besetztworld = zeros((M,M))

# Besetzung########################################### Liste der besetzen Punkte, fuer die Ausgabestructure = []

for x in range(M):for y in range(M):

u = uniform(0, 1)world[x,y] = (u < p)if world[x,y]:

structure.append((x,y))

# Flutung von oben nach unten########################################### Liste der unbearbeiteten Punkteconnected_undone = []# ... und der bearbeiteten wie unbearbeitetenconnected = []

# Initialisierung von obenfor x in range(M):

if world[x, M-1]:connected_undone.append((x, M-1))connected.append((x, M-1))

# Durchflutenwhile connected_undone:

# zu bearbeitendes Element holen und als getan markierencx, cy = connected_undone.pop()for (nx, ny) in (cx - 1, cy), (cx + 1, cy), \

(cx, cy - 1), (cx, cy + 1):# 1. Index gueltig (wichtig gerade am Anfang!)# 2. besetzt# 3. noch nicht gesehenif nx >= 0 and nx < M and ny >= 0 and ny < M and \

135

world[nx, ny] and \(nx, ny) not in connected:

connected.append((nx, ny))connected_undone.append((nx, ny))

# Ausgang unten suchenpercolating = Falsefor x in range(M):

if (x, 0) in connected:percolating = True

return percolating, structure, connected

# Ausgabe##########################################

successful = 0for cnt in range(samples):

print "Test ", cntpercolating, structure, connected = try_percolation(M, p)if percolating:

successful += 1# Erfolg merken fuer die Ausgabesucc_structure = structuresucc_connected = connected

print "Perkolations−W−keit", float(successful)/samples

if successful > 0:# Liste von Paaren in Paar von Listen verwandelnxs, ys = zip(*succ_structure)xc, yc = zip(*succ_connected)

pyplot.plot(xs, ys, "k+")pyplot.plot(xc, yc, "bo")

pyplot.show()

8 Lineare Algebra II

Wie wir bereits an der Besselgleichung gesehen haben, lassen sich gewöhnliche Differen-tialgleichungen in einer Dimension recht einfach auf lineare Gleichungssysteme abbilden.Diese haben Bandstruktur und sind effizient zu lösen. In mehr als einer Dimension istdas allerdings im Allgemeinen nicht mehr der Fall. Betrachten wir zum Beispiel die Pois-songleichung in zwei Dimensionen:

∆φ =∂2φ

∂x2+∂2φ

∂y2= ρ. (8.1)

Wir diskretisieren nun wie gewohnt φ(x,y) in beiden Dimensionen zu φk,l = φ(kh, lh),k,l = (1)N . Den Laplace-Operator erhalten wir dann in erster Ordnung als

∆φ(kh, lh) ≈ 1

h2

(φk+1,l − 2φk,l + φk−1,l

)+

1

h2

(φk,l+1 − 2φk,l + φk,l−1

)=

1

h2

(φk,l+1 + φk+1,l − 4φk,l + φk−1,l + φk,l−1

). (8.2)

Der Einfachheit halber nehmen wir periodische Randbedingungen an, so dass wir dieseGleichung für jeden Gitterpunkt aufstellen können. Allerdings wäre die resultierende Ma-trix singulär; um die Differenzialgleichung mit periodischen Randbedingungen eindeutiglösen zu können, müssen wir einen Funktionswert vorgeben.Diese Gleichungen sind im Moment noch auf der Matrix φk,l definiert, die wir nun

linearisieren müssen, um die Gleichung in der gewohnten Matrixform etwa an Python zuübergeben. Hierzu speichern wir die Elemente von φk,l wie folgt:

Φk+Nl = φk,l für k,l = 1(1)N. (8.3)

Wie man sich leicht überlegt, ist diese Zuordnung eindeutig, wir können also beliebigzwischen Φn und φk,l wechseln und so etwa (8.2) auf den Vektor Φn übertragen. Diesergibt dann N2 Gleichungen für alle Datenpunkte, die in Matrixform für N = 5 zumBeispiel wie folgt aussehen:

0 5 10 15 20

0

5

10

15

20

·

Φ0 = φ(0,0)Φ1 = φ(h,0)

...Φ4 = φ(4h,0)Φ5 = φ(0,h)

...Φ24 = φ(4h,4h)

=

Φ0

ρ(h,0)...

ρ(h,0)ρ(0,h)

...ρ(4h,4h)

. (8.4)

137


In der Matrix markieren grüne Punkte Einträge mit Wert 1/h2, schwarze Punkte Einträgemit Wert −4/h2 und das rote Kreuz den Normierungseintrag mit Wert 1. Alle anderenEinträge sind Null.Durch die periodischen Randbedingungen in x und y sind zwei Nebendiagonalen weiter

außen teilweise besetzt. Damit hat die entstehende Matrix zwar immer noch Bandstrukturund ist dünn besetzt, d. h. fast alle Einträge Null, allerdings ist sie nicht mehr tridiagonal.Auch durch Umsortieren lässt sich dies nicht wesentlich ändern, daher muss die volleGaußelimination durchgeführt werden. Für Gitter von 5× 5 Punkten ist das zwar nochunproblematisch, bei einem Gitter von 100×100 Punkten hat die volle Matrix allerdingsbereits 100,000,000 Einträge, und die Gaußelimination wird zu langsam. Noch schwierigerwird es in den meist benutzten drei Dimensionen, da die volle Matrix schnell mehrereMilliarden Einträge hat.Neben der Ineffizienz des Gaußverfahrens bringt das Arbeiten mit der vollen Matrix al-

lerdings auch Speicherprobleme mit sich, denn eine volle Matrix aus dem R100,000×100,000

benötigt bei einfacher Genauigkeit über 37GB Speicher. Dünn besetzte Matrizen die-ser Größe sind allerdings durchaus handhabbar, denn nur wenige Matrixelemente sindüberhaupt ungleich Null. Indem man nur diese Elemente geschickt speichert, lassen sichsogar noch weitaus größere Matrizen bewältigen. Auf derartigen Datenstrukturen kanndie Gaußelimination allerdings nicht effizient eingesetzt werden, da diese die Matrixstruk-tur durch die Zeilenadditionen rasch zerstört.Im Folgenden lernen wir nun schnellere, iterative Gleichungslöser kennen, mit denen

auch solche und größere Gleichungssysteme handhabbar werden. Außerdem können dieseVerfahren auch auf große, dünn besetzte Matrizen angewandt werden. Weiter lernen wirdie QR-Zerlegung als weitere Matrixzerlegung kennen, die eine wichtige Rolle bei derBestimmung von orthogonalen Basen und der Optimierung spielt. Sie kann auch zur Be-rechnung von Eigenwerten und -vektoren benutzt werden, was dieses Kapitel abschließt.

8.1 Iterative Gleichungslöser

Wir betrachten eine reguläre Matrix A ∈ Rn,n und einen Vektor b ∈ Rn. Gesucht istdann die Lösung x ∈ Rn mit

Ax = b. (8.5)

Die Gaußelimination liefert diese bei unendlicher Genauigkeit exakt, allerdings mit demhohen Aufwand O(n3). Wir haben allerdings bereits gesehen, dass iterative Verfahrenwie etwa das Newtonverfahren zur Lösung nichtlinearer Gleichungssysteme quadratischkonvergieren. Hierzu gibt es mehrere mögliche Ansätze, etwa das CG-Verfahren, das aufeinem Optimierungsproblem beruht und das wir später kennenlernen werden. Zunächstsuchen wir aber iterative Verfahren der Form

x(i+1) = G(x(i)) = Tx(i) + r (8.6)

mit r ∈ Rn und T ∈ Rn,n, ‖T‖ < 1. Der Banachsche Fixpunktsatz gewährleistet, dass die-se sukzessive Substitution für jeden Startwert konvergiert, wobei die Norm ‖·‖ wiederumgeeignet gewählt werden kann.

138


Wie müssen wir nun T wählen, damit einerseits x(i) → x für i → ∞, andererseitsaber T und r einfach zu berechnen sind? Da ‖T‖ < 1 sein soll, muss r bereits eineNäherungslösung sein. Es sollte also r = B−1b sein, wobei B eine geeignete, einfach zuinvertierende Näherung von A ist. Dann gilt

x = T x+B−1b!

= T x+B−1Ax =(T +B−1A

)x, (8.7)

was sich offenbar durch Wahl von T = I −B−1A erfüllen lässt. Solange also B−1 einfachzu bestimmen ist, lassen sich sowohl T als auch r einfach berechnen.

8.1.1 Jacobiverfahren

Das erste Verfahren nach diesem Schema, dass wir kennenlernen, ist das Jacobiverfahren.Die Matrix A wird dazu als Summe einer Diagonalmatrix sowie einer linken, unterenund einer rechten oberen Dreiecksmatrix mit verschwindender Diagonale zerlegt, alsoA = L+D + U mit

lik =

aik für i < k

0 sonst, dik =

aik für i = k

0 sonstund uik =

aik für i > k

0 sonst. (8.8)

Die Diagonalmatrix D soll dabei die Rolle der leicht zu invertierenden Matrix überneh-men. Dazu müssen die Diagonalelemente alle von Null verschieden sein, was sich beieiner regulären Matrix A durch Vertauschen von Zeilen und/oder Spalten immer errei-chen lässt.Setzen wir also T = I −D−1A und r = D−1b in (8.6) ein, so erhalten wir das Jacobi-

verfahren

x(i+1) =(I −D−1A

)x(i) +D−1b

= −D−1 (L+ U)x(i) +D−1b (8.9)

mit der Diagonalmatrix D, so dass d−1jj = 1

ajj. Komponentenweise bedeutet dies, dass

x(i+1)j =

1

ajj

bj −∑k 6=j

ajkx(i)k

. (8.10)

Mit anderen Worten, dass Jacobiverfahren löst jede Zeile nach der Variablen auf derDiagonale auf.Wann konvergiert dieses Verfahren? Eine gängige Voraussetzung ist, dass die Matrix

A strikt diagonaldominant ist, also∑k 6=i|aik| < |aii| für i = 1(1)n. (8.11)

Diese Bedingung ist sehr stark, zum Beispiel erfüllen weder die Matrix aus dem Eingangs-beispiel noch etwa die für die Spline-Interpolation benötigten Matrizen diese Bedingung,

139


da in beiden Fällen das Diagonalelement betragsmäßig die Summe der Nebenelementeist. Strikt diagonaldominante Matrizen treten zum Beispiel bei der sogenannten Finite-Elemente-Modellierung zur Diskretisierung von Differentialgleichungen auf.Ist A strikt diagonaldominant, so nutzen wir die Maximumsnorm

‖A‖∞ :=n

maxi=1

n∑k=1

|aik| , (8.12)

die eine Matrixnorm definiert. Dann gilt

‖T‖∞ =∥∥I −D−1A

∥∥∞ =

nmaxi=1

∑k 6=i

|aik||aii|

< 1, (8.13)

die sukzessive Substitution und damit das Jacobiverfahren konvergieren also. Außerdemist die Konvergenz linear, genauer gilt

‖xn+1 − x‖∞‖xn − x‖∞

≤∑k 6=i

|aik||aii|

, (8.14)

wobei ‖x‖∞ := maxni=1 |xi| die Vektormaximumsnorm bezeichnet. Je größer also dieDiagonaleinträge gegenüber den Nebeneinträgen sind, desto schneller konvergiert dasVerfahren, zum Beispiel wenn die Matrix eine kleine Störung der Einheitsmatrix ist.Diagonaldominanz ist keine notwendige Bedingung für Konvergenz; auch für Matrizen,

die nicht diagonaldominant sind, kann das Verfahren durchaus konvergieren (vergleicheauch Abbildung 8.1). In diesem Fall ist die Konvergenz aber oft sehr langsam. Ist um-gekehrt die Matrix zwar strikt diagonaldominant, aber das Diagonalelement in einigenZeilen betragsmäßig nur wenig größer als die Betragssumme der restlichen Elemente, soist ‖T‖∞ ≈ 1, und die Konvergenz kann trotzdem sehr langsam sein. In solchen Fällenmuss zum effizienteren SOR-Verfahren gegriffen werden, das wir weiter unten besprechenwerden.

Indizierte Matrixspeicherung

Wie man an der komponentenweisen Darstellung (8.10) gut sieht, kann das Jacobiverfah-ren auch auf dünnbesetzten Matrizen implementiert werden. Zum einen wird die MatrixA beim Verfahren nicht verändert, sondern nur der erheblich kleinere Lösungsvektor, zumanderen wird nur zeilenweise summiert, was eine indizierte Speicherung ermöglicht. Dazuwird für jede Zeile j lediglich der Diagonaleintrag ajj explizit gespeichert, sowie eine Listemit Einträgen (k, ajk), die die restlichen Elemente 6= 0 enthält. Eine Implementation desJacobiverfahrens muss dann lediglich für jede Zeile die Summe

∑k 6=j ajkx

(i)k mit Hilfe

der zur Zeile gehörigen Liste bilden, von bj abziehen und durch ajj teilen.In unserem einführenden Beispiel wären pro Zeile neben der Diagonalen maximal vier

weitere Einträge nötig, unabhängig davon, wie fein die Schrittweite gewählt wird. Die

140


Matrix (8.4) würde damit so dargestellt:

1, = (1, 0, . . . , 0)

− 4

h2,

(3,

1

h2

),

(1,

1

h2

),

(7,

1

h2

),

(22,

1

h2

)=

(1

h2,− 4

h2,

1

h2, 0, 0, 0, 1, 0, . . . , 0, 1, 0, 0, 0

)− 4

h2,

(4,

1

h2

),

(2,

1

h2

),

(8,

1

h2

),

(23,

1

h2

)=

(0,

1

h2,− 4

h2,

1

h2, 0, 0, 0, 1, 0, . . . , 0, 1, 0, 0

)... (8.15)

ajj , (k1, ajk1),(k2, ajk2), . . . (8.16)

8.1.2 Gauß-Seidel-Verfahren

Wird (8.10) zeilenweise abgearbeitet, so müssen die bereits berechneten Werte x(i+1)j

zwischengespeichert werden, da für die restlichen Zeilen ja noch die alten Werte x(i)k be-

nötigt werden. Beim Gauß-Seidel-Verfahren werden stattdessen die bereits berechneten,neueren Werte benutzt:

x(i+1)j =

1

ajj

bj − j−1∑k=1

ajkx(i+1)k −

n∑k=j+1

ajkx(i)k

. (8.17)

Dies erspart einerseits die getrennte Speicherung der neuen Näherungslösung xk, ande-rerseits ist die neue Näherungslösung näher an der Lösung, so dass es durchaus sinnvollerscheint, diese neuen, besseren Werte für die verbleibenden Zeilen zu nutzen.Mit der Zerlegung A = L + D + U wie beim Jacobiverfahren ergibt sich in Matrix-

schreibweise

x(i+1) = −D−1Lx(i+1) −D−1Ux(i) +D−1b =⇒ (D + L)x(i+1) = −Ux(i) + b (8.18)

und damitx(i+1) = −(D + L)−1Ux(i) − (D + L)−1b. (8.19)

Das Gauß-Seidel-Verfahren ist also auch vom Typ (8.6), mit der etwas komplexerenMatrix B = D + L. Tatsächlich ist auch

T = I − (D + L)−1A = (D + L)−1(D + L−A) = −(D + L)−1U. (8.20)

Man kann zeigen, dass ‖T‖∞ beim Gauß-Seidel-Verfahren kleiner ist als beim Jacobi-Verfahren. Das bedeutet oft, aber nicht immer, dass das Gauß-Seidel-Verfahren schnellerist, obwohl teilweise mit prinzipiell besseren Näherungen gerechnet wird. Man spart al-lerdings den Speicherplatz, um x(i+1) zwischenzuspeichern.Genauso wie das Jacobiverfahren kann auch das Gauß-Seidel-Verfahren auf indizierten

Matrixformaten benutzt werden, wobei die beiden Summen in (8.17) entweder gleichzeitigaufaddiert oder die Listen der Nichtdiagonalelemente in Elemente links und rechts derDiagonalen aufgeteilt werden.

141


Insbesondere für die parallele Verarbeitung, die mit der heutigen weiten Verbreitungvon Mehrkern-Prozessoren ein wichtiger Faktor ist, ist das Gauß-Seidel-Verfahren aller-dings ungeeignet, da die Berechnung jeder Zeile die Ergebnisse der vorherigen erfordert.Das Jacobi-Verfahren kann hingegen auf so viele Prozessoren verteilt werden, wie dieMatrix Zeilen hat, was eine effiziente Verarbeitung selbst auf modernen Grafikkartenermöglicht.

8.1.3 Relaxationsverfahren

Beim Relaxationsverfahren (Successive over-relaxation, SOR) wird statt B = D + L dieMatrix B = D/ω + L mit einem Relaxationsfaktor ω betrachtet. Durch geeignete Wahlvon ω können dann auch nicht strikt diagonaldominante Matrizen behandelt werden.Allerdings kann man nur zeigen, dass 0 < ω < 2 gelten muss, aber ein Wert ω, der zuschneller Konvergenz führt, muss durch Ausprobieren gefunden werden.In Matrixschreibweise gilt analog zu (8.20)

T = I − ω(D + ωL)−1A =

(D + ωL)−1(D + ωL− ωA) = −(D + ωL)−1 [ωU + (ω − 1)D] (8.21)

und damit

x(i+1) = −(D + ωL)−1 [ωU + (ω − 1)D]x(i) + ω(D + ωL)−1b (8.22)

beziehungsweise, analog zum Gauß-Seidel-Verfahren,

x(i+1) = −ωD−1Lx(i+1) −[ωD−1U + (ω − 1)I

]x(i) + ωD−1b. (8.23)

In Komponentenschreibweise schließlich ergibt sich

x(i+1)j =

ω

ajj

bj − j−1∑k=1

ajkx(i+1)k −

n∑k=j+1

ajkx(i)k

+ (1− ω)x(i)j . (8.24)

Das SOR-Verfahren mit ω = 1 entspricht also genau dem Gauß-Seidel-Verfahren. AndereWerte von ω gewichten zwischen der vorherigen Näherung und der nächsten Gauß-Seidel-Iterierten. Insofern ist es erstaunlich, dass auch Werte ω > 1 sinnvoll sein können, diedie vorherige Näherung quasi bestrafen.In Python sieht das SOR-Verfahren so aus:

import numpydef sor_step(A, b, omega, x):

n = A.shape[0]for j in range(n):

s = b[j]# diese Werte sind schon neus -= numpy.dot(A[j,:j], x[:j])# und diese Werte sind noch alts -= numpy.dot(A[j,j+1:], x[j+1:])# Ueberschreiben von x[j]!x[j] = omega*s/A[j,j] + (1-omega)*x[j]

142


0 20 40 60 80 100Schritte

10-16

10-14

10-12

10-10

10-8

10-6

10-4

10-2

100

102

Fehle

r

0.0 0.5 1.0 1.5 2.010-1

100

101

102

103

Abbildung 8.1: Konvergenz von Jacobi-, Gauß-Seidel- und Relaxationsverfahren bei ei-ner nicht strikt diagonaldominanten Matrix A und einer diagonaldominanten MatrixB. Links sind die Fehler ‖Bx− b‖2 von Jacobi- und Gauß-Seidel-Verfahren für die Ma-trix B mit großen blauen Kreisen bzw. roten Rauten eingezeichnet. Die entsprechendenFehler für die Matrix A sind als blaue Punkte (Jacobi) und rote Kreuze (Gauß-Seidel)eingezeichnet. Obwohl A nicht strikt diagonaldominant ist, konvergieren die Verfahren,allerdings extrem langsam. Hier benötigt man das SOR-Verfahren (grüne Sterne), dasmit ω = 1,66 auch bei Matrix A gut konvergiert. Der rechte Graph zeigt den Fehlerdes SOR-Verfahrens in Abhängigkeit von ω nach 20 Schritten, der sehr sensitiv von ωabhängt. Der optimale Wert lässt sich nur durch solches Ausprobieren ermitteln.

Die Routine erwartet als Eingabe eine quadratische n×n-Matrix A und einen n-Vektor b,den Relaxationsfaktor omega und die aktuelle Näherung x. Diese wird in dieser Routinewie beschrieben von der neuen Näherung überschrieben, die übergebene Variable x alsogeändert.Abbildung 8.1 zeigt das Fehlerverhalten von Jacobi-, Gauß-Seidel- und SOR-Verfahren

für die nicht strikt diagonaldominante Matrix A aus (8.4) im Eingangsbeispiel und einezufällige besetzte, strikt diagonaldominante Matrix B. Diese wurde erzeugt, indem dieNichtdiagonaleinträge zunächst normalverteilt zufällig gewählt und daraus die Diagonal-elemente als bi,i =

∑k 6=i |bik| /0,9 berechnet wurden, so dass ‖T‖∞ ≈ 0.9 < 1. Wie man

sieht, konvergieren sowohl Jacobi- wie auch Gauß-Seidel-Verfahren sehr schnell für diesestrikt diagonaldominante Matrix. Für die Matrix A hingegen sind beide Verfahren äu-ßerst langsam, während das SOR-Verfahren mit passend gewähltem ω fast so schnell wiebei einer gutartigen Matrix konvergiert.Im rechten Graphen sieht man allerdings auch, dass die Wahl von ω die Konvergenz

stark beeinflusst. Die Matrix A ist ein Beispiel, bei dem ω in jedem Fall größer als 1gewählt werden muss, um Konvergenz zu erzielen, die optimale Rate erreicht man in

143


diesem Fall mit ω = 1,63. Dabei ist die Konvergenz sehr sensitiv von ω abhängig –bereits mit ω = 1,5 oder 1,75 ist der Fehler nach 20 Schritten um eine Größenordnungschlechter.

8.2 QR-Zerlegung und Orthogonalisierung

Neben der LU-Zerlegung spielt in der Numerik noch eine zweite Zerlegung eine wichtigeRolle, die QR-Zerlegung. Dabei wird eine Matrix A ∈ Cm,n in eine orthonormale MatrixQ und eine rechte obere Dreiecksmatrix R zerlegt, so dass A = QR. Orthonormal be-deutet hier, dass die Spaltenvektoren von Q bezüglich des Skalarprodukts (u,v) := uHvpaarweise orthogonal und normiert sind. Das ist äquivalent zu QHQ = I, wobei der obereIndex H jeweils die Hermitesche bezeichnet.Anders als bei der LU-Zerlegung existiert eine solche Zerlegung immer, ist aber dafür

nicht eindeutig. So gibt es Zerlegungen sowohl mit Q ∈ Cm,n und R ∈ Cn,n, als auchmit Q ∈ Cm,m und R ∈ Cm,n. Wir werden Verfahren kennenlernen, die beide Formenerzeugen. Die erstere Form kann dabei auch so verstanden werden, dass eine orthogonaleBasis gesucht wird, die denselben Raum aufspannt wie die Spaltenvektoren von A.Ist A quadratisch, und regulär, so ist auch Q quadratisch und QH = Q−1. Außer-

dem gilt |detQ| = 1. Eine solche Matrix heißt unitär. Praktisch kann man sich unitäreMatrizen als Drehungen und Spiegelungen vorstellen. Daher sind alle wesentlichen Eigen-schaften der Matrix A in R enthalten. Insbesondere kann die QR-Zerlegung auch benutztwerden, um bequem Ax = b zu lösen, da ja

Ax = QRx!

= b =⇒ Rx = QHb, (8.25)

was durch einfach Rücksubstitution gelöst werden kann. Wir werden später sehen, dassdie QR-Zerlegung auch bei nichtquadratischen Matrizen bei der „Lösung“ von Ax = bwichtig ist, weil sie bestimmte verwandte Optimierungsaufgaben löst.

8.2.1 Gram-Schmidt-Verfahren

Das Gram-Schmidt-Verfahren ist das älteste Verfahren zur QR-Zerlegung. Auf der ande-ren Seite ist es das allgemeinste Verfahren und kann in beliebigen Hilberträumen einge-setzt werden. Das Verfahren ist eigentlich nur eine Orthogonalisierung der Spaltenvekto-ren von A, die als Nebenprodukt eine QR-Zerlegung liefert. Daher ist das Verfahren auchals Gram-Schmidt-Orthogonalisierung bekannt. Wir werden als Beispiel sehen, dass dasVerfahren etwa auch zur Konstruktion von orthogonalen Polynomen eingesetzt werdenkann.Seien zunächst m linear unabhängige Vektoren aj , j = 1(1)m aus einem beliebigen

Hilbertraum H gegeben. Ziel ist es nun, diese in eine orthonormale Basis qj , j = 1(1)mzu transformieren. Wir beginnen mit a1, das wir lediglich normieren müssen:

q1 =a1

‖a1‖. (8.26)

144


a2

q1

q2

q′2

Abbildung 8.2: Gram-Schmidt-Orthogonalisierung. a2 wird in den Vektor q′2 transfor-miert, der zu q1 senkrecht steht, indem die Projektion von q1 auf a2 (blau gepunktet)von a2 abgezogen wird. q′2 wird schließlich noch normiert, um den nächsten Basisvektorq2 zu erhalten.

Den nächsten Vektor, a2, dürfen wir nun nicht einfach normieren und hinzufügen, da erja nicht notwendigerweise orthogonal zu q1 ist. Das können wir aber erreichen, indem wireinfach die Anteile parallel zu q1 abziehen (vergleiche Abbildung 8.2):

q′2 = a2 − (a2, q1) q1

q2 =q′2‖q′2‖

,

wobei (·,·) das Skalarprodukt des Hilbertraums H bezeichnet. Da a2 und a1 nach Vor-aussetzung linear unabhängig sein sollen, gilt dies auch für a2 und q1, so dass q′2 6= 0.Mit den weiteren Vektoren verfahren wir genauso, ziehen also zunächst die Anteile derbereits berechneten Basisvektoren ab und normieren den Rest:

q′k = ak −k−1∑i=1

(ak, qi) qi (8.27)

qk =q′k∥∥q′k∥∥ . (8.28)

Da wir lineare Unabhängigkeit der ai vorausgesetzt haben, ist dabei gesichert, dass q′k 6= 0für alle k. Außerdem gilt

(q′k,ql) =

(ak −

k−1∑i=1

(ak, qi)qi, ql

)= (ak, ql)−

k−1∑i=1

(ak, qi) (qi, ql)︸︷︷︸=δil

= 0. (8.29)

Die zu q′k parallelen qk sind damit paarweise orthogonal.Gleichung (8.27) zeigt auch, dass die orthonormale Basis nicht eindeutig ist, denn wir

können genauso gut qk = −q′k/‖q′k‖ wählen oder, im Falle eines komplexen Hilbertraums,jeden beliebigen anderen anderen Faktor vom Betrag 1.Das Gram-Schmidt-Verfahren benötigt zur Funktion lediglich das Skalarprodukt des

zugrundeliegenden Hilbertraums, und kann daher auch zur Orthonormalisierung etwa

145


von Polynomen eingesetzt werden, wie wir gleich sehen werden. Doch zunächst wollenwir uns den Fall ansehen, dass A = (aj) ∈ Cm,n eine Matrix mit linear unabhängigenSpalten ist, und die Vektoren aj deren Spaltenvektoren. Offenbar muss m ≥ n gelten,sonst sind die Spalten linear abhängig. Wir setzen Q = (qj) ∈ Cm,n die Matrix der mitdem Gram-Schmidt-Verfahren orthonormierten Spaltenvektoren, und R = (rik) ∈ Cn,nmit

rik =

(ak, qi) falls i < k

‖q′k‖ falls i = k

0 sonst(8.30)

Dann gilt wegen (8.27)

ak = qk∥∥q′k∥∥+

k−1∑i=1

(ak, qi)qi =n∑i=1

qirik (8.31)

und damit A = QR mit QHQ = I. Ist m = n, so ist dann Q die gesuchte unitäre Matrixund R die rechte obere Dreiecksmatrix der QR-Zerlegung.Das Verfahren benötigt bei quadratischen Matrizen genauso wie die Gauß-EliminationO(n3) Schritte, da für jeden Vektor O(n) Skalarprodukte berechnet werden müssen. Au-ßerdem arbeitet das Verfahren auf vollen Matrizen, was, wie schon gesagt, bei dünn be-setzten Matrizen ungünstig ist und die Anwendbarkeit bei großen Matrizen einschränkt.Auch hier gibt es daher alternative Verfahren, von denen wir gleich die Householder-Spiegelungen und Givensrotationen kennenlernen werden.

Beispiel: Legendrepolynome

Da sich das Gram-Schmidt-Verfahren auf beliebige Hilberträume anwenden lässt, könnenwir zum Beispiel den Hilbertraum der Polynome betrachten, mit dem Skalarprodukt

(f, g) :=

∫ 1

−1f(x)g(x) dx. (8.32)

Dann sind die Polynome 1,x,x2, . . . linear unabhängig, da die Koeffizientendarstellungeines Polynoms ja eindeutig ist. Andererseits sind diese Polynome aber nicht orthonormalbezüglich (·,·), da zum Beispiel

(1, x) =

∫ 1

−1x dx =

1

2. (8.33)

Wir benutzen nun das Gram-Schmidt-Verfahren, um eine orthogonale Basis zu erzeu-gen. Da (1, 1) = 2 ist

q1 =1√2

(8.34)

Weiter istq′2 = x−

(x,

1√2

)· 1√

2= x (8.35)

146


und damit wegen (x,x) = 2/3

q2 =

√3

2q′1 =

√3

2x. (8.36)

Analog erhalten wir

q′3 = x2 − 3

2(x2, x) · x− 1

2(x2, 1) · 1 = x2 − 1

3(8.37)

undq3 =

√458

(x2 − 1

3

). (8.38)

Bis auf Vorfaktoren sind dies die ersten drei Legendrepolynome, die sich auf diese Weiseberechnen lassen. Analog ergeben sich die Chebyshev-Polynome Tn, wenn für dieselbeBasis bezüglich

(f, g)T :=

∫ 1

−1

f(x)g(x)√1− x2

dx (8.39)

das Gram-Schmidt-Verfahren durchgeführt wird.

Modifiziertes Gram-Schmidt-Verfahren

Numerisch ist das Gram-Schmidt-Verfahren nicht sehr stabil, denn falls zwei Vektorenaj beinahe parallel sind, kommt es durch Auslöschung bei der Berechnung der Projektio-nen zu großen Rundungsfehlern. Numerisch besser ist das modifizierte Gram-Schmidt-Verfahren, bei dem die Projektion eines jeden neu erzeugten Vektors sofort von allenanderen abgezogen wird. Wir setzen also Q(0) = A und weiter für k = 1(1)n:

q(k)k = q

(k−1)k /rkk

q(k)l = q

(k−1)l − rkl q

(k)k für l > k (8.40)

q(k)l = q

(k−1)l für l < k,

mit

rkk =∥∥∥q(k−1)k

∥∥∥rkl =

(q

(k−1)l , q

(k)k

)=(al, q

(k)k

). (8.41)

Der folgende Python-Code führt das modifizierte Gram-Schmidt-Verfahren auf derMatrix A aus, die schrittweise in die orthonormale Matrix Q transformiert wird, währendR mit berechnet wird. Dadurch, dass in jedem Schritt der neu berechnete Basisvektorvon allen weiteren abgezogen wird, ist der nächste zu berechnende Vektor qk bereitsorthogonal zu den bisherigen Basisvektoren und muss lediglich normalisiert werden:

147


from scipy import *

def gramschmidt(a):"Modifizierte Gram−Schmidt−QR−Zerlegung fuer eine n x m−Matrix a"q = a.copy()n = a.shape[1]r = zeros((n, n))# Schleife ueber alle Spalten von a bzw. qfor k in range(n):

# Berechnen von rkk = ‖q′k‖# und Normalisierung des neuen Basisvektorsr[k,k] = sqrt(dot(q[:,k], q[:,k]))q[:,k] = q[:,k] / r[k,k]

# Berechnen der rki = (qi, qk) = (ai, qk)# und Abziehen der Projektionen von den verbleibenden Vektorenfor i in range(k+1, n):

r[k,i] = dot(q[:,i], q[:,k])q[:,i] = q[:,i] - r[k,i] * q[:, k]

return q, r

8.2.2 Householder-Verfahren

Wie bereits gesagt, sind unitäre Matrizen nichts anderes als verallgemeinerte Drehungenund Spiegelungen. Insbesondere ist das Produkt von unitären Matrizen wieder unitär.Die beiden folgenden Verfahren zur QR-Zerlegung konstruieren Q daher als Produkt vonl einfachen elementaren unitären Matrizen Qi, wobei l vom Verfahren abhängt, wie auchder Typ der Matrizen Qi. Diese transformieren A schrittweise in rechte obere Dreiecks-form:

Ql · · ·Q2Q1A = R =⇒ A = QH1 · · ·QHl−1QHl︸︷︷︸

Q

R. (8.42)

Bei der QR-Zerlegung mittels Householder-Spiegelungen werden nun m Spiegelun-gen konstruiert, so dass nacheinander die Spalten von A unterhalb der Diagonalen Nullwerden, und A auf rechte obere Dreiecksgestalt transformiert wird. Während also dasGram-Schmidt-Verfahren die Matrix A in Q transformiert und dabei R als Nebenpro-dukt anfällt, wird hier A in R transformiert, und Q fällt als Nebenprodukt ab. Oft wirdQ gar nicht explizit benötigt, und es ist geschickter, nur die Householder-Spiegelungenzu speichern, die wir nun zunächst definieren wollen.Sei also v ∈ Rm ein Vektor mit ‖v‖22 = vHv = 1. Dann ist die zugehörige Householder-

Spiegelung definiert alsSv = I − 2vvH (8.43)

Ist w = λv, so gilt Svw = w − 2vvHw = −w, w wird also an der Null gespiegelt. Isthingegen w ⊥ v, also vHw = 0, dann ist Svw = w. Sv lässt also die zu v senkrechte

148


a1

‖a1‖ e1−‖a1‖ e1

v

v′

Abbildung 8.3: Illustration der Householder-Konstruktion. Der Vektor a1 soll mittels ei-ner Spiegelung auf einen der Vektoren ±‖a1‖ e1 abgebildet werden. Die zugehörigen Hou-seholdervektoren sind dann gerade die beiden Winkelhalbierenden v = a + ‖a1‖ e1 undv′ = a−‖a1‖ e1. Bei der Spiegelung von v wird a1 auf ‖a1‖ e1 abgebildet (durchgezogeneLinien), bei Spiegelung von v′ auf −‖a1‖ e1 (gestrichelte Linien).

Hyperebene invariant, während Vektoren parallel zu v gespiegelt werden. Außerdem giltSHv = Sv und SHv Sv = I − 4vvH + 4vvHvvH = I, damit auch S2

v = I, und Sv ist unitär.Wie können wir nun eine Householder-Spiegelung konstruieren, so dass diese die erste

Spalte a1 von A auf die erste Koordinatenachse abbildet? Wie man sich leicht überlegt,muss dann v eine der beiden Winkelhalbierenden sein (vergleiche Abbildung 8.3). Diesesind von der Form

v =a1 + λe1

‖a1 + λe1‖(8.44)

mitλ = ±‖a1‖ . (8.45)

Für die numerische Stabilität ist es günstiger, Auslöschungen zu vermeiden, daher wähltman

λ = sgn(a11) ‖a1‖ , (8.46)

wobei sgn(a11) das Vorzeichen von a11 bezeichnet. Durch die Wahl dieses Vorzeichens istder unnormierte Spiegelvektor

vj =

sgn(a11)(|a11|+ ‖a1‖2) für j = 1

aj für j > 1,(8.47)

so dass es zu keiner Auslöschung kommen kann. Der eigentliche Spiegelvektor ist dernormierte Vektor v = v/ ‖v‖2.Bei der Implementation ist es natürlich wichtig, Sv nicht explizit zu berechnen. Es gilt

aberSvA = A− 2vvHA = A− 2v(vHA) (8.48)

Man berechnet also lediglich einmal den Vektor t = vHA, und zieht dann das tj-fachevon vj von der Spalte aj ab. Um weitere Spalten von A auf rechte obere Dreiecksform

149


zu bringen, fixieren wir die bereits bearbeiteten Koordinaten, und betrachten nur nocheine Spiegelung in den verbleibenden Koordinaten. Dann sieht für die k-te Spalte derunnormierte Spiegelvektor so aus:

v(k)j =

0 fürj < k

sgn(akk)(|akk|+√∑m

l=k a2l ) für j = k

aj für j > k,

(8.49)

und der normierte Spiegelvektor ist v(k) = v(k)/∥∥v(k)

∥∥2. Die Wurzel entspricht der Norm

des Restvektors (akk, . . . ,amk). Nach min(m,n)−1 Schritten ist dann A auf Dreiecksformtransformiert.Um die Matrix Q zu erhalten, müssen wir gemäß (8.42) das Produkt der Spiegelun-

gen in umgekehrte Reihenfolge berechnen, da ja Sv = SHv . Wurden nacheinander dieSpiegelungen mit Vektor v1, v2, . . . ,vl angewandt, suchen wir also die Matrix

Q = SHv(1)

SHv(2)· · ·SH

v(l)== I Sv(1)Sv(2) · · ·Sv(l) . (8.50)

Um diese zu berechnen, müssen wir nur die Identität von rechts mit den Spiegelungenmultiplizieren, was analog (8.48) geht:

ASv = A− 2AvvH = A− 2(Av)vH . (8.51)

Vielfach ist es aber gar nicht nötig, Q explizit zu kennen, dann kann man einfach dieVektoren v(k) speichern und bei Bedarf Qw für einen beliebigen Vektor w ausrechnen,indem die Spiegelungen in umgekehrter Reihenfolge auf w angewandt werden.In Python könnte eine QR-Zerlegung mittels Householder-Spiegelungen so aussehen:

from scipy import *from scipy.linalg import *

def householder(a):"Householder−QR−Zerlegung fuer eine n x m−Matrix a"

def multiplyleft(a, v):"a mit Householder−Spiegelung S_v von links multiplizieren"v_H_a = dot(v.transpose().conj(), a)for k in range(a.shape[1]):

a[:,k] -= 2*v_H_a[k] * v

def multiplyright(a, v):"a mit Householder−Spiegelung S_v von rechts multiplizieren"a_v = dot(a, v)for k in range(a.shape[1]):

a[:,k] -= 2*v[k].conj() * a_v

r = a.copy()q = identity(r.shape[0])

150


# Schleife ueber alle Spalten von a bzw. r,# die wenigstens ein Subdiagonalelement habenfor k in range(min(r.shape[0] - 1, r.shape[1])):

# Kopie von a_k, um Spiegelvektor zu bauenv = r[:,k].copy()# schon bearbeitete Komponenten auf Nullv[:k] = 0# Spiegelvektor a+ sgn(a1) ‖a‖ e1 berechnen# Probleme durch sign(0) = 0 vermeidenif sign(v[k]) > 0:

v[k] += norm(v)else:

v[k] -= norm(v)# normierenv = v / norm(v)

# Matrix r updatenmultiplyleft(r, v)# und unitaeren Teil qmultiplyright(q, v)

return q, r

Die Funktionen multiplyleft und multiplyright implementieren (8.48) bzw. (8.51),die Hauptschleife muss also nur den Spiegelvektor v(k) berechnen und auf R und Qentsprechend anwenden.Ist A nicht quadratisch oder singulär, dann müssen unter Umständen Spalten ge-

tauscht werden, wenn die gesamte führende Spalte der aktuellen Restmatrix Null ist. Spal-tentauschmatrizen sind ebenfalls unitäre, selbstinverse Matrizen, werden allerdings vonrechts anmultipliziert. Anders als das Gram-Schmidt-Verfahren kann das Householder-Verfahren also auf beliebige Matrizen angewandt werden. Man erhält dann eine allgemei-ne Zerlegung

A = Q ·(R′ K0 0

)· S, (8.52)

wobei R′ eine reguläre rechte obere Dreiecksmatrix ist, Q das unitäre Produkt derHouseholder-Spiegelungen und S die unitäre Matrix der eventuell nötigen Spaltenver-tauschungen.Jedes Matrix-Update gemäß (8.48) benötigt im wesentlichen O(nm) Operationen, die

Methode insgesamt daher O(mn2) Operationen, bei quadratischen Matrizen also wieauch das Gram-Schmidt-Verfahren O(n3) Schritte.Die QR-Zerlegung mit Hilfe von Householder-Spiegelungen ist in SciPy als scipy.

linalg.qr(A) implementiert und liefert die Zerlegung Q und R zurück. Wird dasSchlüsselwortargument pivoting auf True gesetzt, werden zusätzlich noch Spaltengetauscht und die neuen Spaltenindizes zusätzlich zurückgegeben.

151


r cos(φ)

r

(x,y)

r sin(φ) (r, 0)

φ

Abbildung 8.4: Illustration der Givens-Konstruktion. Der Vektor (x,y) soll um den Win-kel φ auf die x-Achse gedreht werden. Dann gilt cos(φ) = x/r und sin(φ) = x/r mitr =

√x2 + y2.

8.2.3 Givens-Rotationen

Spiegelungen sind prinzipiell Operationen, die die gesamte Matrix betreffen, wie (8.48)zeigt. Wie das Gram-Schmidt-Verfahren ist daher auch das Householder-Verfahren nichtfür dünn besetzte Matrizen geeignet und schlecht zu parallelisieren. Daher setzt man inder Praxis gerne Givens-Rotationen ein.Eine Givensrotation ist eine Drehung in zwei Koordinaten, also eine Matrix der Gestalt:

Gi,k,φ =i→

k →

I 0 . . . 0 00 c 0 s 0... 0 I 0

...0 −s 0 c 00 0 . . . 0 I

(8.53)

mit c = cos(φ) und s = sin(φ) und einem beliebigen Winkel φ. Die beiden Cosinuster-me befinden sich stets auf der Diagonalen. Offenbar ist Gi,k,φ eine unitäre Matrix, alsGHi,k,φGi,k,φ = I.Wir können nun eine solche Drehung benutzen, um das linke untere Element an,1 einer

Matrix A auf 0 zu bekommen. Dazu drehen wir die beiden untersten Zeilen der Matrixentsprechend: I 0 0

0 c s0 −s c

· ...

. . .x . . .y . . .

!=

.... . .

r ?0 ?

(8.54)

mit x = an−1,1 und y = an,1 sowie r =√x2 + y2. Die Sterne deuten dabei an, dass sich

die gesamten beiden letzten Zeilen potentiell ändern. Den Drehwinkel muss man dabeigar nicht explizit bestimmen, da c = cos(φ) = x/r und s = cos(φ) = y/r (vergleicheAbbildung 8.4).

152


Ist r allerdings klein, ist diese Formel numerisch nicht stabil. Im Falle, dass |x| ≥ |y|,berechnet man daher besser

r′ =

√1 + (y/x)2

c = sgn(x)1

r′(8.55)

s =y

|x| r′,

und analog im umgekehrten Falle.Nachdem wir nun das linke unterste Element an,1 auf Null gedreht haben, können

wir mit dem nächsthöheren Element an−1,1 fortfahren und dieses auf an−2,1 drehen. Wirfahren fort, bis die erste Spalte mit Ausnahme des ersten Elements auf Nullen gedrehtist. Analog können wir nun in den folgenden Spalten unten anfangend alle Elemente bisauf das Diagonalelement auf Null drehen.Auch die Givens-Rotationen werden dabei nicht als Matrix-Multiplikation berechnet,

da sich bei Multiplikation von links tatsächlich ja nur zwei Zeilen lesen und neu schrei-ben. Für die Berechnung von Q müssen wir nach (8.42) die Hermiteschen der Rotatio-nen von rechts anmultiplizieren, was einer Modifikation zweier Spalten entspricht. DieHermitesche bzw. Transponierte der Drehung ergibt sich einfach durch Drehung in derumgekehrten Richtung, also Vorzeichenwechsel des Sinusterms.

153


In Python sieht das Givens-Verfahren so aus:


def givens(a):"Givens−QR−Zerlegung fuer eine n x m−Matrix a"

def multiplyleft(a, i, j, c, s):"Matrix a mit Givens−Rotation von links multiplizieren"# eigentlich nur zwei Zeilen verdrehenai_gedreht = c*a[i,:] + s*a[j,:]aj_gedreht = -s*a[i,:] + c*a[j,:]a[i,:] = ai_gedrehta[j,:] = aj_gedreht

def multiplyright(a, i, j, c, s):"Matrix a mit Givens−Rotation von rechts multiplizieren"# eigentlich nur zwei Spalten verdrehenai_gedreht = c*a[:,i] + s*a[:,j]aj_gedreht = -s*a[:,i] + c*a[:,j]a[:,i] = ai_gedrehta[:,j] = aj_gedreht

def calccs(x, y):if abs(x) >= abs(y):

r = sqrt(1 + (y/x)**2)c = sign(x)/rs = y/(abs(x)*r)

else:r = sqrt(1 + (x/y)**2)c = x/(abs(y)*r)s = sign(y)/r

return c, s

r = a.copy()q = identity(r.shape[0])# Doppelschleife ueber alle Subdiagonalelemente von a bzw. rfor k in range(min(r.shape[0] - 1, r.shape[1])):

for i in range(r.shape[0] - 1, k, -1):c, s = calccs(r[i-1,k], r[i,k])# Matrix r updatenmultiplyleft(r, i-1, i, c, s)# und unitaeren Teil q, hermitesch durch Vz-wechsel im Sinusmultiplyright(q, i-1, i, c, s)

return q, r

Die Routinen multiplyleft und multiplyright implementieren wieder die Multipli-kation mit einer Givensmatrix von links bzw. rechts. Die Routine calccs implementiert

154

8.3 Eigenwerte

die stabilisierte Berechnung der Sinus- und Cosinusterme gemäß (8.55).Bei einer vollbesetzten Matrix benötigt das Verfahren damit insgesamtO(mn) Drehun-

gen, die allerdings jeweils nur zwei Zeilen der Matrix verändern, alsoO(n) Rechenaufwandhaben. Daher benötigt das Verfahren insgesamt wieder O(mn2).Anders als das Householder-Verfahren eignen sich Givensrotationen aber auch für par-

allele Verarbeitung und dünn besetzte Gitter. Denn für das Verfahren ist es im Prinzipegal, auf welche Zeile die zu entfernende gedreht wird, es müssen ja nicht notwendiger-weise benachbarte Zeilen sein. Daher reicht es, nur die besetzten Elemente unterhalbder Diagonalen jeweils nacheinander auf die Diagonale drehen. Bei der 5× 5-Matrix desEingangsbeispiels (8.2) sind daher lediglich 50 statt 300 Drehungen nötig.

8.3 Eigenwerte

In der Quantenmechanik spielt die Berechnung von Eigenwerten- und vektoren, also vonEigenenergien und -zuständen, eine zentrale Rolle.Gegeben ist wieder eine Matrix A ∈ Cn,n. Wir suchen nichttriviale Vektoren v ∈ Cn

und Skalare λ ∈ C, so dass

Av = λv ⇐⇒ (A− λI)v = 0. (8.56)

Die Formulierung auf der rechten Seite zeigt, dass für alle Eigenwerte λ die Matrix A−λIsingulär sein muss, also

det(A− λI) = 0. (8.57)

Die Determinante ist aber letztlich nichts weiter als ein Polynom n-ten Grades in λ,das charakteristische Polynom. Dessen Nullstellen sind gerade die Eigenwerte. Das New-tonverfahren konvergiert für Polynome, so dass wir mit seiner Hilfe die Eigenwerte imPrinzip bestimmen können.Das Problem dabei ist, dass wir das charakteristische Polynom nur durch direkte Ent-

wicklung etwa nach der erste Spalte bestimmen können. Wir müssen dann n Unterdeter-minanten bzw. charakteristische Polynome der Größe n − 1 berechnen. Diese wiederumerfordern n− 1 Unterdeterminanten der Größe n− 2, und so weiter. Ingesamt also sindn! viele Unterteilungsschritte nötig, was selbst bei moderat großen Matrizen nicht hand-habbar ist und außerdem schnell zur Anhäufung von Fehlern führt. Daher wird dieseseinfache Variante nur bei Matrizen in bis zu vier Dimensionen genutzt, für größere Ma-trizen hingegen Näherungsverfahren, die wir nun kennen lernen werden.

8.3.1 Vektoriteration

Sei die Matrix A zunächst diagonalisierbar, also A = Q diag(λ1, . . . ,λn)QH mit einerunitären Matrix Q. Dann gilt für eine beliebigen Vektor x(0) 6= 0

x(i) := Aix(0) = Q diag(λ1, . . . ,λn)iQHx(0) =n∑k=1

(qk, x(0))λikqk. (8.58)

155


Ist nun |λ1| > |λk| für alle k > 1, also der betragsmäßig größte Eigenwert λ1 nichtentartet, so ist λi1 λik für große i. Daher wird xi mit wachsender Anzahl Iterationenzunehmend parallel zu einem Eigenvektor zu λ1. Allerdings wird dabei xi gleichzeitigimmer größer bzw. kleiner, wenn |λ1| größer bzw. kleiner 1 ist. Um numerische Problemezu vermeiden, muss xi noch normiert werden.Dies führt zum Verfahren der Vektoriteration oder von-Mises-Iteration. Man wählt

einen Startvektor x(0) 6= 0, und berechnet dann iterativ

x(i+1) =Ax(i)∥∥Ax(i)

∥∥2

. (8.59)

Hat die Matrix A einen nicht entarteten betragsmäßig größten Eigenwert, so konvergiertx(i) gegen einen dazugehörigen Einheitseigenvektor, falls x(0) nicht gerade exakt senkrechtauf dem Eigenraum steht. In der Praxis ist dies aufgrund numerischer Ungenauigkeitenwenigstens für eine der Iterierten immer der Fall. Außerdem konvergiert

(x(i))H

Ax(i)

gegen diesen Eigenwert.Ist der betragsmäßig größte Eigenwert entartet, aber es gibt keine weiteren Eigenwerte

mit gleichem Betrag, so konvergiert(x(i))H

Ax(i) immer noch gegen den betragsmäßiggrößten Eigenwert. Gibt es mehrere betragsgleiche, aber unterschiedliche größte Eigen-werte (etwa ±1), konvergiert dieses Verfahren nicht.Das Verfahren konvergiert vergleichsweise langsam, und findet nur den betragsmäßig

größten Eigenwert. Man könnte zwar versuchen, den neuen Startwert durch Orthogona-lisierung senkrecht zum Eigenraum des größten Eigenvektors zu wählen, aber im Allge-meinen verhindern wieder numerische Ungenauigkeiten, dass das Verfahren gegen einenanderen Eigenwert konvergiert.Zumindest einen weiteren Eigenwert kann man finden, indem man die geshiftete Matrix

A− λ1I betrachtet, für die λ1 notwendigerweise dem betragsmäßig kleinsten Eigenwert,nämlich 0, entspricht. Der gefundene Eigenwert µ1 entspricht einen Eigenwert λ1 + µ1

der Ursprungsmatrix A.

Beispiel: Fibonaccizahlen

Die Fibonaccizahlen sind definiert als F0 = 0, F1 = 1 und Fi+2 = Fi+1 + Fi für i ≥ 0.Dies lässt sich auch als Vektoriteration schreiben:(

F0

F1

)=

(01

)und

(Fi+1

Fi+2

)=

(0 11 1

)︸︷︷︸

A

·(FiFi+1

). (8.60)

In diesem Fall ist es natürlich möglich, die Eigenwerte und -vektoren von A analytischzu bestimmen. Die Eigenwerte sind die Nullstellen

det(A− λI) = −λ(1− λ)− 1 =

(λ− 1

2

)2

− 5

4, (8.61)

156

8.3 Eigenwerte

also λ± = 12

(1±√

5). Davon ist λ+ > 1 der größere Eigenwert, und λ− < 1. Die

dazugehörigen Eigenvektoren sind

x± =

(1

12

(1±√

5)) . (8.62)

Der Startwert (0,1)T der Fibonaccireihe ergibt sich in der Basis der Eigenvektoren als

x0 =

(01

)=

1√5x+ −

1√5x−. (8.63)

Betrachten nun die x-Komponente von Aix0, können wir die Fibonaccizahlen auch als

Fi =1√5λi+ +

1√5λi− =

1√5

(1 +√

5

2

)i− 1√

5

(1−√

5

2

)i∈ N (8.64)

schreiben. Insbesondere ist Fi = Oi→∞((

1+√

52

)i), unabhängig davon, welche Start-

werte benutzt werden, solange diese nicht gerade parallel zu x− sind. Für ganzzahligeStartwerte ist dies nur möglich, wenn F0 = F1 = 0.

8.3.2 QR-Algorithmus

Da die Vektoriteration nicht alle Eigenwerte und -vektoren liefert, brauchen wir noch einanderes Verfahren, das alle Eigenwerte berechnen kann. Dieser Abschnitt führt hierzuden QR-Algorithmus von Francis und Kublanovskaya ein.Grundlage dieses iterativen Algorithmus ist, wie der Name schon sagt, die QR-

Zerlegung. Wir starten mit A(0) = A ∈ Cn,n. In jedem Iterationsschritt berechnen wireine QR-Zerlegung A(k) = Q(k)R(k), und setzen

A(k+1) = R(k)Q(k) =(Q(k)

)HA(k)Q(k). (8.65)

Die letztere Umformung zeigt, dass A(k+1) dieselben Eigenwerte wie A(k) und damit auchA hat. Konvergiert dieses Verfahren, bedeutet dies, dass Q(k) ≈ I für große k, und damitist A(k+1) nahezu rechte obere Dreiecksmatrix, deren Eigenwerte wir von der Diagonalenablesen können. Hat A keine entarteten Eigenwerte, so konvergieren die A(k) sogar gegeneine Diagonalmatrix. Dies gilt allerdings nur, solange der Algorithmus über komplexenMatrizen durchgeführt wird, die stets eine Schursche Normalform haben. Der reellwertigeAlgorithmus hingegen führt nur zu einer Matrix mit 2 × 2-Blöcken auf der Diagonalen,die jeweils zwei komplex konjugierten Eigenwerten über C entsprechen.Eine einfache Erweiterung des Verfahrens zerlegt nicht A(k), sondern A(k) − µkI =

Q(k)R(k), wobei µk eine Näherung für einen Eigenwert ist. Oft wird einfach µk = a(k)n,n

gewählt. Die nächste Iterierte ist dann

A(k+1) = R(k)Q(k) + µkI, (8.66)

157


der Shift wird also einfach wieder rückgängig gemacht.Der Algorithmus benötigt sehr viele, teure QR-Zerlegungen. Um den Rechenaufwand

zu vermindern, kann man die Matrix zunächst durch Householder-Spiegelungen aufHessenberg-Form bringen, die dann mit Hilfe von Givens-Rotationen sehr schnell QR-zerlegt werden kann.Eine einfache Implementation des QR-Algorithmus mit Shift für eine Matrix mit reellen

Eigenwerten kann wie folgt aussehen:


def qr_eigenwerte(A, tolerance):n = A.shape[0]I = identity(n)Ak = A.copy()converged = Falsewhile not converged:

shift = Ak[-1,-1]Q, R = qr(Ak - shift*I)Ak = dot(R, Q) + shift*I

if max([abs(Ak[i,k]) for i in range(n) \for k in range(i)]) < tolerance:

converged = Truereturn array([Ak[i,i] for i in range(n)])

Die Routine liefert einen Vektor aus Eigenwerten mit Hilfe des Householder-Verfahrensvon SciPy. tolerance gibt dabei den maximalen Betrag eines Subdiagonalelements an,der noch akzeptiert wird. Hat A komplexe Eigenwerte, können auch nichtverschwindendeElemente auf der unteren Subdiagonale verbleiben. Dann muss zum einen das Kriteriumentsprechend angepasst werden, zum zweiten kann dann natürlich nicht einfach die Dia-gonale zurückgeliefert werden. Echte, also reelle Eigenwerte sind dann solche, die wederlinks noch unterhalb auf der Subdiagonalen Nachbarn haben, die anderen entsprechenkomplexen Eigenwerten.

Beispiel: Fibonaccieigenwerte numerisch

Der QR-Algorithmus mit Shift a(k)n,n soll nun anhand des Fibonaccibeispiels illustriert

werden. Die folgende Tabelle demonstriert die sehr schnelle Konvergenz:

Iteration A(k) Stellen λ+ Stellen λ−

0

(0.00000000 1.00000000

1.00000000 1.00000000

)0 0

1

(−0.50000000 0.50000000

0.50000000 1.50000000

)0 0

158

8.3 Eigenwerte

Iteration A(k) Stellen λ+ Stellen λ−

2

(−0.61764706 0.02941176

0.02941176 1.61764706

)3 3

3

(−0.61803399 0.00000509

0.00000509 1.61803399

)10 10

4

(−0.61803399 −0.00000000

0.00000000 1.61803399

)15 17

Die letzten beiden Spalten geben die Anzahl der korrekt bestimmten Nachkommastel-len des größten bzw. kleinsten Eigenwerts an. Nach dem vierten Schritt verbessert sichdaran nichts mehr, da beide Eigenwerte bis auf Maschinengenauigkeit bestimmt sind.Wie sieht es mit größeren Matrizen aus? Ist eine Matrix A ∈ R10,10 symmetrisch

mit Standardzufallszahlen gefüllt, konvergiert das Verfahren in etwa 200 Schritten so,dass unterhalb der Diagonalen keine Werte betragsmäßig größer als 10−5 stehen. DieGenauigkeit der Eigenwerte ist dann von derselben Größenordnung.

8.3.3 Inverse Iteration

Anders als die Vektoriteration liefert der QR-Algorithmus nicht direkt die Eigenvektoren.Diese ergeben sich zwar im Prinzip aus dem Produkt aller Q(k), dieses mitzuberechnenwäre allerdings recht aufwändig. Einfacher ist die sogenannte inverse Iteration.Sei λ eine gute Approximation eines Eigenwerts λ0 der Matrix A ∈ Cn,n und v ein

Eigenvektor von A zu λ0. Dann ist µ = λ0 − λ ein Eigenwert von A− λI, da

(A− λI)v = (A− λ0I)v︸︷︷︸=0

+ (λ0 − λ)︸︷︷︸=µ

v = µv. (8.67)

Damit ist auch µ−1 ein Eigenwert von (A− λI)−1 zum Eigenvektor v.Da wir annehmen, dass λ eine gute Näherung von λ0 ist, ist µ sehr klein und ent-

sprechend µ−1 sehr groß. Ist zum Beispiel λ eine auf 5 Stellen genaue Näherung, so ist∣∣µ−1∣∣ ≈ 100.000. Daher konvergiert die Vektoriteration für (A−λI)−1 sehr schnell gegen

den Eigenvektor zu λ0. Dabei wird natürlich nicht die Inverse berechnet, sondern manstartet wie gewohnt mit einem Startwert x(0) 6= 0 und löst

(A− λI)x(i+1) = x(i) (8.68)

durch Gaußelimination mit Pivotisierung. Die neue Iterierte wird noch normiert:

x(i+1) =x(i+1)∥∥x(i+1)

∥∥2

. (8.69)

Bei einer sehr guten Eigenwertnäherung oder auch durch kleine numerische Fehler kannes passieren, dass das Pivotelement der Gaußelimination numerisch exakt Null ist. In

159


diesem Fall wird es einfach durch eine sehr kleine Zahl ersetzt. Da letztlich nur dieRichtung ausschlaggebend ist, konvergiert dieses Verfahren extrem schnell gegen den zuλ gehörigen Eigenvektor.Die inverse Iteration, die zu einem gegebenen nicht-entarteten Eigenwert den Eigen-

vektor bestimmt, sieht in Python wie folgt aus:


def inverse_iteration(A, l, tolerance):n = A.shape[0]x = ones(n)Ashift = A - l*identity(n)converged = Falsewhile not converged:

x = solve(Ashift, x)x = x / norm(x)if norm(l*x - dot(A, x)) < tolerance:

converged = Truereturn x

l ist hier die Näherung λ des Eigenwerts, zu dem der Eigenvektor gesucht wird. Hiergibt die Toleranz an, wie sehr Ax von λx abweichen darf.

Beispiel: Fibonaccivektoren numerisch

Die Eigenvektoren x± zu unseren Näherungen λ± der Fibonaccimatrix bestimmen wirnumerisch mit Hilfe der inversen Iteration, die in nur einer Iteration gegen eine Näherungdes jeweiligen Eigenvektors mit 15 Stellen Genauigkeit konvergiert:

Iteration x(i)+ x

(i)− Stellen

0 (1.00000000, 1.00000000)T (1.00000000, 1.00000000)T 0

1 (0.85065081, − 0.52573111)T (0.52573111, 0.85065081)T 15

Auch bei der symmetrischen Zufallsmatrix konvergiert die inverse Iteration in nureinem Schritt bis auf Maschinengenauigkeit gegen die gesuchten Eigenvektoren.

160

9 Optimierung

Bei der Optimierung betrachtet man eine Funktion f : M → R, die Zielfunktion, miteiner beliebigen zulässigen Menge M . Gesucht ist x ∈ M , so dass f(x) ≤ f(x′) für allex′ ∈M . Man schreibt kurz

minx∈M

f(x). (9.1)

Die Menge M ist dabei oft eine Teilmenge des Rn, die zum Beispiel durch Nebenbedin-gungen der Form g(x) ≥ 0 beschrieben wird.Ein Beispiel einer solchen Aufgabe haben wir bereits im Zusammenhang mit Funkti-

onsfits kennengelernt. Bei diesem Problem sind Daten (xi, yi) ∈ Rm×R, i = 1(1)n sowieeine parametrisierte Funktion fv(x) gegeben, wobei v freie Parameter sind. Gesucht wird

minv

n∑i=1

(fv(xi)− yi)2. (9.2)

Im Spezialfall, dass fv linear ist, also von der Form fvx,vc(x) = vxTx + vc, ist dies in

Vektorschreibweise äquivalent zur Aufgabe

min(vx,vc)∈Rm+1

n∑i=1

(vTx xi − vc − yi)2 = minv∈Rm+1

‖Av − b‖2 . (9.3)

mit

b =

y1

...

yn

und A =

(x1)1 . . . (x1)m 1...

......

(xn)1 . . . (xn)m 1

.

Die klassische lineare Regression benutzt die 2-Norm und versucht damit, die mitt-lere Abweichung zu minimieren. Bei bestimmten Aufgaben ist aber nicht der mittlere,sondern der maximale Fehler ausschlaggebend. Dies ist zum Beispiel der Fall bei derKraftfeldoptimierung für Molekulardynamiksimulationen, bei der eine Parametrisierungeines Potentials gesucht wird, die bekannte experimentelle Daten möglichst gut wieder-gibt. Offenbar ist die Güte einer solchen Näherung durch den maximalen Fehler in einerEigenschaft bestimmt und nicht durch den durchschnittlichen Fehler. Aus (9.3) wird dann

minv∈Rm+1

‖Av − b‖∞ = minv∈Rm+1

nmaxi=1|(Av)i − yi| . (9.4)

Obwohl sich scheinbar nicht viel geändert hat, hat dieses Problem eine ganz andereStruktur, für die andere Lösungsmethoden benutzt werden. Um dies zu verstehen, fügenwir eine weitere Variable vm+2 zum Parameterraum hinzu. Diese soll vm+2 = ‖Av − b‖∞

161

9 Optimierung

erfüllen, also vm+2 minimal mit −vm+2 ≤ (Av)i − yi ≤ vm+2 für i = 1(1)n. Damit wirdaus (9.4) eine Minimierungsaufgabe mit linearer Zielfunktion und Nebenbedingungen:

minv

(0, . . . , 0, 1)T v unter der Bedingung

(A e

−A e

)v ≥

(b

−b

), (9.5)

wobei e = (1, . . . ,1)T . Eine solche Aufgabe heißt auch lineares Programm und wird mitVerfahren wie den Simplexalgorithmus behandelt. Lineare Programme spielen auch inder Spiele- und Wirtschaftstheorie eine große Rolle.Die ursprünglich gestellte Aufgabe (9.1) oder auch (9.2) sehen in ihrer allgemeinen

Form natürlich auch nichtlineare Funktionen vor, etwa wenn eine Exponentialfunktionan Daten angeglichen werden soll oder wenn das Minimum einer komplexeren Energie-funktion gesucht ist. In diesem Fall spricht man von nichtlinearer Optimierung. Soferndie Zielfunktion zweifach stetig differenzierbar ist, ist aus der Analysis bekannt, dass imMinimum die Ableitung verschwindet. Die Nullstellen der Ableitung lassen sich im Prin-zip mit Hilfe des Newtonverfahrens finden, wir lernen aber bessere, auf die Optimierungzugeschnittene Varianten kennen.Eine nichtlineare Funktion kann mehrere Minima aufweisen. Ähnlich wie das New-

tonverfahren konvergieren die Verfahren zur nichtlinearen Optimierung im Allgemeinennur lokal gegen das nächstgelegene Minimum. Solche Optimierungsverfahren heißen da-her lokal. Falls eine Zielfunktion sehr viele lokale Minima hat, ist es für diese Verfahrenunter Umständen schwierig bis unmöglich, das globale Minimum (9.1) zu finden. Diesgilt insbesondere, wenn Nebenbedingungen gegeben sind, weil sich dann das Minimumauch irgendwo auf dem Rand der zulässigen Menge befinden kann. Trotzdem spielen lo-kale Optimierungsmethoden eine wichtige Rolle, etwa bei der Energieminimierung. Beidiesem ersten Schritt typischer Molekulardynamiksimulationen werden die Teilchen zu-nächst so verschoben, dass die Energie lokal minimiert wird. Dadurch kann die eigentlicheSimulation mit größeren Zeitschritten begonnen werden. Eine globale Optimierung ist da-bei unnötig, da das System während der Simulation sowieso nicht im Energieminimumverharrt, sondern einen hoffentlich ausreichend großen Teil des Phasenraums besucht.Die globale Optimierung, also die Suche nach dem kleinsten lokalen Minimum, ist

hingegen vor allem bei der Suche nach Grundzuständen wichtig. Auch viele praktischeProbleme, etwa die Fahrplanoptimierung, sind globale Optimierungsprobleme. LokaleVerfahren setzen außerdem die Differenzierbarkeit der Zielfunktion voraus. Ist dies nichtder Fall oder die zulässige Menge diskret, scheiden lokale Verfahren ebenfalls aus. Leidergibt es für die allgemeine globale Optimierung mit nichtlinearen Zielfunktionen oder überdiskreten zulässigen Mengen keine Verfahren mit gesicherten Konvergenzaussagen, wirwerden aber zwei physikalisch bzw. biologisch motivierte Verfahren kennenlernen.

9.1 Ausgleichsrechnung und Pseudoinverse

Wir betrachten zunächst lineare Optimierungsprobleme der Form

minx∈Rn

‖Ax− b‖2 , (9.6)

162

9.1 Ausgleichsrechnung und Pseudoinverse

d. h. , wir suchen den Vektor x, so dass Ax möglichst nahe an b liegt, wobei A ∈ Rm,n undb ∈ Rm. Solche Probleme ergeben sich zum Beispiel bei der Ausgleichsrechnung (9.3).Ist m = n und A regulär, so ist die Lösung unmittelbar klar, nämlich A−1b. Ist aber

m > n, dann ist das Gleichungssystem Ax = b im Allgemeinen nicht lösbar; (9.6) besagtdann, dass wir dasjenige x suchen, dass das Gleichungssystem möglichst gut löst. Umdiese Aufgabe zu lösen, formen wir sie zunächst etwas um:

‖Ax− b‖22 = (Ax− b)T (Ax− b) = xTATAx− 2bTAx+ bT b. (9.7)

Es handelt sich also um eine quadratische Optimierungsaufgabe, deren Minimum x

∇‖Ax− b‖22 =

(∂

∂xi‖Ax− b‖22

)i

= 2xTATA− 2bTA = 0 (9.8)

erfüllt. Hat A linear unabhängige Spalten, so ist ATA invertierbar, und wir finden dieLösung als

x = (ATA)−1AT b. (9.9)

Ist in (9.6) m < n, so ist das Gleichungssystem im allgemeinen nicht eindeutig zulösen. Wir können aber die Lösung minimaler Norm ‖x‖ suchen. Dies führt zu der Op-timierungsaufgabe mit Nebenbedingungen

minx∈Rn

‖x‖2 unter der Bedingung Ax = b. (9.10)

Diese Aufgabe können wir ganz ähnlich wie im Falle m > n lösen. Hat A wenigstenslinear unabhängige Zeilen, so ist AAT invertierbar, und wir können

x = AT (AAT )−1b (9.11)

definieren. Dann erfüllt x offenbar die Nebenbedingung Ax = b, und alle anderen zu-lässigen x′ liegen in x + Kern(A) = x + Bild(AT )⊥. Da x ∈ Bild(AT ), gilt ‖x′‖ =‖x‖+ ‖x− x′‖ ≥ ‖x‖. Mit anderen Worten, x löst die Optimierungsaufgabe (9.10).Die auftretenden Matrizen (ATA)−1AT und AT (AAT )−1 sind Spezialfälle der Pseu-

doinversen oder Moore-Penrose-Inversen für allgemeine Matrizen. Der Name Pseudoin-verse rührt daher, dass diese unter den gegebenen Nebenbedingungen die Gleichungeninvertieren, so gut es geht. Die Pseudoinverse findet also das x mit minimaler Norm unterallen x, für die ‖Ax− b‖2 minimal ist. Moore und Penrose haben abstrakte Bedingun-gen für die Pseudoinverse definiert, die von den obigen Ausdrücken erfüllt werden. DiePseudoinverse für beliebige Matrizen kann durch eine sogenannte Singulärwertzerlegungbestimmt werden. Diese kann in dieser Vorlesung leider nicht behandelt werden, aber wirwerden zumindest sehen, wie bei Matrizen mit maximalem Zeilen- oder Spaltenrang diePseudoinverse mit Hilfe der QR-Zerlegung bestimmt werden kann, ohne ATA oder AAT

berechnen und invertieren zu müssen. In SciPy berechnet scipy.linalg.pinv(A)bequem die Moore-Penrose-Pseudoinverse für eine beliebige Matrix A.

163

9 Optimierung

Sei also A ∈ Rm,n eine Matrix mit maximalem Spaltenrang, insbesondere m ≥ n. Ausdem Householder- oder Givensverfahren erhalten wir

A =(Q1 Q2

)·

(R1

0

), (9.12)

wobei R1 eine reguläre rechte obere n× n-Dreiecksmatrix ist, und Q1 die zugehörigen nersten Spalten der unitären Matrix Q. Dann ist

(ATA)−1AT b = (RT1 QT1 Q1R1)−1AT b = R−1

1

(RT1)−1

AT b, (9.13)

was durch bequemes Vorwärts- und Rückwärtseinsetzen ohne Matrixinversion gelöst wer-den kann. Wie man sieht, wird in diesem Fall die Matrix Q nicht benötigt.Hat umgekehrt A maximalen Zeilenrang, insbesondere also m ≤ n, dann zerlegen wir

AT mit Hilfe von Householder- oder Givensverfahren wie oben in eine reguläre rechte obe-re m×m-Dreiecksmatrix R1 und orthonormale Matrizen Q1 ∈ Rn,m und Q2 ∈ Rn,n−m.Dann gilt entsprechend

AT (AAT )−1b = AT (RT1 QT1 Q1R1)−1b = ATR−1

1

(RT1)−1

b. (9.14)

Für Zielfunktionen von der Form ‖Ax− b‖2, also gewissermaßen das Optimierungs-Äquivalent von linearen Gleichungssystemen, lässt sich also das Optimierungsproblemmit Hilfe der Pseudoinversen geschlossen lösen.

9.2 Nichtlineare Optimierung

Für nichtlineare, aber wenigstens zweifach stetig differenzierbare Zielfunktionen f : Rn →R gilt in freien Minima x

∇f(x) = 0. (9.15)

Dies garantiert allerdings nicht, dass eine gefundene Nullstelle auch ein Minimum ist, da-zu muss zusätzlich noch die Hessesche Matrix f ′′(x) positiv definit sein. Selbst in diesemFall ist der gefundene Punkt nur ein lokales Minimum, also nur in einer kleinen Umge-bung sind alle anderen Punkte höher. Eine Funktion kann aber natürlich ohne weiteresmehrere Minima haben, die sich nur durch erneute Suche finden lassen. Insbesondere istes praktisch unmöglich, das globale Minimum zu finden; damit werden wir uns späternoch einmal beschäftigen.Für (9.15) können wir das mehrdimensionale Newtonverfahren formulieren. Wir wählen

also einen Startpunkt x(0) in der Nähe des Minimums und setzen

x(k+1) = x(k) − f ′′(x(k)

)−1∇f

(x(k)

), (9.16)

wobei

f ′′(x) =

(∂2

∂xj∂xkf(x)

)k,j

=

∂2

∂x21f(x) . . . ∂

∂x1∂xnf(x)

......

∂∂x1∂xn

f(x) . . . ∂2

∂x2nf(x)

. (9.17)

164


Bei großen Dimensionen n kann es rasch sehr aufwendig werden, f ′′(x) zu berechnen, diesist aber auch nötig, um zu überprüfen, ob das gefundene Extremum auch tatsächlichein Minimum ist. Daher ist dieses Verfahren nicht optimal. Besser sind die folgendenVerfahren, die ohne f ′′(x) auskommen.

9.2.1 Verfahren des steilsten Abstiegs

Da das Newtonverfahren, das wir oben auf die Ableitung angewendet haben, auf einerTaylorentwicklung erster Ordnung basiert, basiert die Optimierung mit Hilfe des Newton-verfahrens in gewisser Weise auf einer Taylorentwicklung zweiter Ordnung. Was könnenwir nun mit der praktikableren Taylorentwicklung erster Ordnung erreichen? Diese istzunächst einmal

f(x+ λd) = f(x) + λ∇f(x)Td+O(λ2) (9.18)

für eine Richtung d und Schrittweite λ > 0. Anders als beim Newtonverfahren könnenwir nun nicht das Minimum dieser Näherung als neue Iterierte benutzen, da die Nähe-rung linear ist und daher kein Minimum hat. Daher können wir lediglich versuchen, f zuverringern. Da λ > 0 ist und wir für kleine λ die quadratischen Anteile vernachlässigenkönnen, muss ∇f(x)Td < 0 gelten. Eine Richtung d, die dies erfüllt, heißt Abstiegsrich-tung.Den maximalen Abstieg erreichen wir, wenn d = −∇f(x); diese Richtung heißt daher

auch steilster Abstieg. Für das Verfahren des steilsten Abstiegs (auch Gradientenabstiegs-verfahren wählt man zunächst einen Startwert x(0) und setzt dann

x(k+1) = x(k) − λ∇f(x(k)

)(9.19)

mit einer geeigneten Schrittweite λ > 0. Im einfachsten Falle ist λ eine kleine Konstante,zum Beispiel 0,01.

9.2.2 Schrittweitensteuerung

Besser ist aber, die Schrittweite so zu wählen, dass das Verfahren sicher absteigt. Da-für gibt es verschiedene Verfahren, von denen hier nur die recht effizienten Armijo-Schrittweiten besprochen werden.Entlang der festgelegten Richtung d ist die Optimierung nur noch ein eindimensionales

Problem, und wegen (9.18) gibt es für alle α < 1/2 eine kleine Umgebung von x, in der

f(x+ λd) ≤ f(x) + αλ∇f(x)Td (9.20)

gilt. Wir wählen λ so, dass diese Bedingung erfüllt ist, und natürlich möglichst groß.α ∈ (0, 1/2) bestimmt dabei den Mindestabstieg, den wir erreichen wollen. Um λ zubestimmen, beginnen wir einfach mit λ0 = 1, und setzen anschließend λk+1 = ρλk,solange (9.20) nicht erfüllt ist. ρ ∈ (0,1) ist dabei eine weiter Verfahrenskonstante, diebestimmt, wie rasch wir λ verkleinern. Um die Bedingung zu überprüfen, benötigen wirlediglich die beiden reellen Konstanten ∇f(x)Td und f(x) und müssen in jedem Schrittf(x+λd) neu auswerten. α wird meist eher klein gewählt, etwa 0,1, denn je strikter diese

165

9 Optimierung

Bedingung, desto kleiner wird die Schrittweite. Umgekehrt sollte man ρ nicht zu kleinwählen, weil sonst unnötig kleine Schrittweiten benutzt werden.Die Schrittweitensteuerung setzt nur eine Abstiegsrichtung d voraus, und kann da-

her zum Beispiel auch auf das Newton-Verfahren angewandt werden, dessen Richtungd = −f ′′

(x(k)

)−1∇f(x(k)

)ist. Diese Richtung ist dann eine Abstiegsrichtung, wenn

∇f(x(k)

)f ′′(x(k)

)−1∇f(x(k)

), also, wenn f ′′

(x(k)

)−1 positiv definit ist. Dies ist zumin-dest in einer Umgebung eines Minimums der Fall.

Beispiel: Gradientenabstiegsverfahren mit Schrittweitensteuerung

In Python sieht das Verfahren des steilsten Abstiegs mit Armijo-Schrittweiten so aus:


def armijo_steepest_descent(f, gradf, x0, alpha=0.1, rho=0.5,tol=1e-5, maxiter = 1000):

x = x0.copy()fx = f(x)grad = gradf(x)step = 0while norm(grad) > tol:

d = -grad# Armjio-Schrittweite berechnenlmbda = 1xneu = x + dgrad2 = dot(grad, d)while f(xneu) > fx + alpha*lmbda*grad2:

lmbda = rho*lmbdaxneu = x + lmbda*dstep += 1if step > maxiter:

# Abbruch, letzte Naeherung zurueckgegebenreturn x

# mit dem gefundenen Schritt vorwaertsx = xneufx = f(x)grad = gradf(x)

return x

Die Funktion armijo_steepest_descent benötigt dabei als Eingabeparameter Python-funktionen f und gradf, die die zu minimierende Funktion und ihren Gradienten zu-rückliefern. Die Konstanten alpha und rho entsprechen den Konstanten α und ρ desArmijo-Verfahrens. Die Vorgaben α = 0,1 und ρ = 0,5 sind übliche Werte, die meist zuguter Konvergenz führen. Das Verfahren bricht ab, wenn

∥∥∇f(x(k))∥∥ < tol, also die

Tangente hinreichend flach und damit ein Minimum hinreichend gut gefunden ist, oderwenn eine maximale Anzahl an Schritten, maxiter, überschritten wird. Dies vermeidet

166


ein Einfrieren durch zu kleine Schrittweiten. Dies passiert insbesondere, wenn der Funkti-onswert im Minimum sehr groß oder klein ist, so dass nur wenige Stellen zur Optimierungverbleiben.Als Beispiel betrachten wir das Verfahren des steilsten Abstiegs für zwei auf der Ebene

definierte Funktionen. Die erste Funktion ist eine quadratische Funktion

f(x, y) = 40x2 + 30(x+ y)2 + 20y2, (9.21)

die ihr Minimum bei (0,0) hat, die zweite Funktion ist die Rosenbrockfunktion

fRosenbrock(x, y) = (1− x)2 + 100(y − x2)2. (9.22)

Diese hat ihr Minimum offenbar bei (1,1), ist aber das Optimierungsäquivalent zur Run-gefunktion. Denn während das Minimum in einem sehr steilen Tal liegt, ist der Gradiententlang der Talsohle sehr flach. Die meist gierigen Optimierungsverfahren finden dahersehr schnell in die Talsohle, kommen dort aber nur noch langsam ins Ziel, da die Haupt-abstiegsrichtung vorwiegend in die Talsohle statt entlang dieser zeigt.Abbildung 9.1 zeigt die Anwendung des Verfahrens des steilsten Abstiegs mit und

ohne Schrittweitensteuerung auf die beiden Funktionen und illustriert dabei die beidenHauptschwächen des Gradientenabstiegsverfahrens. Einerseits neigt es dazu, über dasMinimum hinauszuschießen, und sich dadurch langsam in das Minimum einzupendeln.Dies lässt sich durch die Schrittweitensteuerung begrenzen. Andererseits muss der steilsteAbstieg nicht in Richtung des Minimums zeigen, in diesem Fall neigt das Verfahrendes steilsten Abstiegs dazu, sich dem Minimum in Zick-Zack-Kurven mit sehr geringerSchrittweite zu nähern.Bei zu großer Schrittweite kann das Verfahren sogar gar nicht konvergieren. Da von

vornherein die maximale Ableitung meist nicht bekannt ist, ist also eine Schrittweiten-steuerung unerlässlich.

9.2.3 CG-Verfahren

Wir betrachten nun einen wichtigen Spezialfall, nämlich quadratische Funktionen derForm

f(x) =1

2xTAx− xT b (9.23)

mit positiv definiter Matrix A ∈ Rn,n. Dies bedeutet, dass A symmetrisch ist und xTAx >0 für alle Vektoren x 6= 0 erfüllt, etwa, weil alle Eigenwerte positiv sind. Positiv definiteMatrizen treten zum Beispiel bei quantenmechanischen Rechnungen auf.Für Funktionen der Form (9.23) gibt es ein iteratives Verfahren, dass bei unbegrenzter

Genauigkeit in spätestens n Schritten gegen die exakte Lösung konvergiert. Dieses Ver-fahren ist das konjugierte Gradienten-Verfahren (englisch conjugate gradient, daher kurzauch CG-Verfahren). Das Optimierungsproblem min f(x) kann dabei auch als Gleichungaufgefasst werden, da

Ax = b ⇐⇒ x minimiert f(x) =1

2xTAx− xT b. (9.24)

167

9 Optimierung

1.0 0.5 0.0 0.5 1.01.0

0.5

0.0

0.5

1.0

1

10

30

50

50

100

1001.0 0.5 0.0 0.5 1.01.0

0.5

0.0

0.5

1.0

1

1030

50

50

100

100

0.0 0.2 0.4 0.6 0.8 1.00.2

0.0

0.2

0.4

0.6

0.8

1.0

0.2

1

5

5

10

10

15

15

20

20

0.0 0.2 0.4 0.6 0.8 1.00.2

0.0

0.2

0.4

0.6

0.8

1.0

0.2

1

5

5

10

10

15

15

20

20

Abbildung 9.1: Verfahren des steilsten Abstiegs für eine quadratische Funktion (oben)und die Rosenbrockfunktion (unten). Links werden Armijo-Schrittweiten mit α = 0,1und ρ = 0,5, rechts eine konstante Schrittweite von 0,01 verwendet. Die roten Punktemarkieren die Iterierten x(k), die Höhenlinien illustrieren die zu optimierende Funkti-on. Für die quadratische Funktion konvergieren beide Verfahren gegen das Minimum bei(0, 0), und auch das Armijo-Verfahren wählt eine konstante Schrittweite von etwa 0,0078.Durch diesen etwas kleineren Wert zielt das das schrittweitengesteuerte Verfahren wenigerüber das Minimum hinaus und braucht nur 11 statt 35 Schritte für 10 Stellen Genau-igkeit. Bei der Rosenbrockfunktion benötigt das schrittweitengesteuerte Verfahren etwa1700 Iterationen dafür. Jeder 200. Punkt ist im Graphen grau gefärbt, um die extremlangsame Konvergenz zu visualisieren. Für die konstante Schrittweite 0,01 konvergiertdas Verfahren gar nicht, wie die eingezeichneten ersten zehn Punkte zeigen.

168


1.0 0.5 0.0 0.5 1.01.0

0.5

0.0

0.5

1.0

1

10

30

30

50

50

Abbildung 9.2: CG-Verfahren für die quadratische Funktion aus (9.21). Die Höhenlinienstellen die zu optimierende quadratische Funktion dar, die roten Punkte markieren dieIterierten des CG-Verfahrens, das in nur 2 Schritten konvergiert.

Daher wird das CG-Verfahren auch als effizienter Gleichungslöser für positiv definiteMatrizen behandelt.Um das Minimum iterativ zu suchen, starten wir mit einem beliebigen Startwert x(0)

(zum Beispiel 0), und verfeinern die aktuelle Näherung gemäß x(k+1) = x(k) + λ(k)d(k)

so, dass wir uns dem Minimum nähern. Wie wir gesehen haben, ist der steilste Abstieg,also in Richtung des negierten Gradienten r(k) = b − Ax(k), nicht ideal. Die Idee desCG-Verfahrens ist nun, die Richtungen d(k) in gewisser Weise stets senkrecht zu einan-der zu wählen, so dass Hin- und Herpendeln oder Zick-Zack-Kurse ausgeschlossen sind.Tatsächlich wählt man die Abstiegsrichtungen senkrecht in dem durch A induzierten Ska-larprodukt, also so, dass (d(i), d(k))A :=

(d(i))TAd(k) = 0 für i 6= k. Man sagt auch, dass

d(i) und d(k) A-konjugiert sind, daher der Name des Verfahrens.Die d(k) werden konstruiert, indem die Gradientenabstiegsrichtungen r(k) mit Hilfe des

Gram-Schmidt-Verfahrens zueinander senkrecht bezüglich (·,·)A gemacht werden. Dabeimuss aufgrund der Wahl der Richtungen d(k+1) nur senkrecht zu d(k) gemacht werden,zu den anderen bisherigen Richtungen steht d(k+1) dann automatisch senkrecht. DerVorfaktor kann dabei vereinfacht werden:

(r(k+1), d(k))A(d(k), d(k))A

= −(r(k+1)

)Tr(k+1)(

r(k))Tr(k)

. (9.25)

Die Schrittweite kann bei einer quadratischen Funktion so bestimmt werden, das λ dieFunktion entlang der Richtung d, also

1

2(x+ λd)TA(x+ λd)− bT (x+ λd) =

1

2xTAx− bTx+ λdT (Ax− b) +

1

2λ2dTAd, (9.26)

169

9 Optimierung

minimiert. Es ergibt sich

λ(k) =

(d(k)

)Tr(k)(

d(k))TAd(k)

. (9.27)

Zusammengefasst ergibt sich das CG-Verfahren in Python alsfrom scipy import *from scipy.linalg import *

def conjugate_gradient(A, b, x0, tol=1e-10):x = x0.copy()r = b - dot(A, x)rr = dot(r,r)d = r.copy()while sqrt(rr) > tol:

lmbda = dot(d, r) / dot(d, dot(A, d))x += lmbda*dr -= lmbda*dot(A,d)oldrr = rrrr = dot(r,r)# orthogonalisierend = r + rr/oldrr * d

return x

Das Verfahren bricht ab, wenn∥∥r(k)

∥∥ < tol, anstatt stur n Schritte zu berechnen, dadurch numerische Ungenauigkeiten unter Umständen 1-2 zusätzlich Schritte nötig werdenkönnen. Umgekehrt können natürlich auch weniger Schritte notwendig sein, wenn derStartwert günstig liegt.Abbildung 9.2 illustriert das CG-Verfahren an der selben quadratischen Funktion, für

die das schrittweitengesteuerte Gradientenabstiegsverfahren 11 Schritte brauchte, um 10Stellen Genauigkeit zu erreichen. Das CG-Verfahren hingegen konvergiert in nur zweiSchritten auf Maschinengenauigkeit, also etwa 17 Stellen.Da das Verfahren auch als Gleichungslöser sehr gute Eigenschaften hat und wegen der

überwiegenden Skalar- und Matrix-Vektorprodukte auch sehr einfach auf dünnbesetztenMatrizen eingesetzt werden kann, ist es eines der meist genutzten Verfahren. Daher gibtes natürlich auch eine SciPy-Implementation, scipy.sparse.linalg.cg(A, b).

9.2.4 Nebenbedingungen und Straffunktionen

Mit dem Verfahren des steilsten Abstiegs und den Armijo-Schrittweiten haben wir einstabiles und meist schnell konvergierendes Verfahren, um lokal freie Minima zu suchen.Was aber kann man tun, wenn zusätzlich noch Nebenbedingungen gegeben sind? Wirsuchen nun also minx∈M f(x), wobei die zulässige Menge

M = x|gi(x) ≥ 0, i = 1(1)m (9.28)

ist. Bekannte Verfahren sind etwa die sequenzielle quadratische Programmierung (SQP)oder das Verfahren von Gill und Murray [GM78]. Hier lernen wir einen anderen, physi-kalisch motivierten Ansatz kennen.

170


Dazu setzen wir voraus, dass nicht nur die zu minimierende Funktion f : Rn → R stetigdifferenzierbar ist, sondern auch die Funktionen gi : Rn → R, die die Nebenbedingungendefinieren. Wäre nun gi(x) = −∞ für alle x /∈M oder zumindest kleiner als das gesuchteMinimum von f in M , so wäre

minx∈M

f(x) = minx∈Rn

f(x) +m∑i=1

min(0, gi(x))2. (9.29)

In der Praxis ist einerseits gi(x) im Allgemeinen endlich, andererseits kennen wir aberauch kein Verfahren, um eine höchst unstetige Funktion zu minimieren. Wenn wir unsdie Nebenbedingungen aber als Banden vorstellen, über die ein iterativer Algorithmusnicht hinausschreiten darf, könnte man diese zunächst weicher gestalten, so dass derAlgorithmus den zulässigen Bereich etwas verlassen kann, und dann die Banden mit derZeit immer härter gestalten, so dass der Algorithmus schließlich in den zulässigen Bereichgedrückt wird. Befindet sich das Minimum über M am Rand von M , wird die gefundeneNäherungslösung daher immer minimal außerhalb von M liegen. Ist dies ein Problem,etwa weil f außerhalb M nicht ausgewertet werden kann, kann man stattdessen aufBarrieremethoden ausweichen, bei denen die Banden bereits innerhalb von M beginnenund am Rand von M singulär sind.Beim Straffunktionsverfahren minimieren wir also die modifizierte Funktion

qσ(x) = f(x) +m∑i=1

min(0, σgi(x))2. (9.30)

Der hintere Teil pσ(x) =∑m

i=1 min(0, σgi(x))2 wird dabei Straffunktion (Penalty functi-on) genannt, weil er Punkte außerhalb des zulässigen Bereichs mit höheren Funktions-werten bestraft.Um das Minimum zu finden, starten wir mit recht kleinem σ0 > 0. Auf qσ0 wenden wir

dann ein Optimierungsverfahren für freie Optimierung an, etwa das Verfahren des steils-ten Abstiegs mit Schrittweitensteuerung. Aufgrund der Konstruktion ist der Gradientvon qσ recht einfach zu berechnen:

∇qσ(x) = ∇f(x) +

m∑i=1

2σ2 min(0, gi(x))∇gi(x). (9.31)

Sinnvollerweise wählt man einen Startpunkt im Inneren von M . Ist im gefundenen,freien Minimum von q bereits gi(x) ≥ −τ mit gewünschter Toleranz τ erfüllt, ist dasMinimum gefunden, und liegt sehr wahrscheinlich im Inneren vom M . Ansonsten wirdσk erhöht und erneut die Minimierung gestartet, allerdings naheliegenderweise mit dembereits gefundenen Minimum als Startwert. Die Lage des Minimums ändert sich dabei,da ja wegen der Abbruchbedingung wenigstens eine Nebenbedingung noch nicht erfülltwar, und sich diese durch die Änderung von σk ändert. Solange danach gi(x) ≥ −τnicht erreicht ist, passen wir σk an und iterieren weiter. σk kann auf verschiedene Weisengewählt werden, es muss nur σk → ∞ für k → ∞ gelten. Eine Möglichkeit ist etwaσk = ka , wobei man a > 1 nicht zu groß wählen sollte, zum Beispiel a = 2.

171

9 Optimierung

2 1 0 1 22.5

2.0

1.5

1.0

0.5

0.0

0.5

1.0

1.5

3 2 1 0 1 20

2

4

6

8

10

Abbildung 9.3: Straffunktionsverfahren für einen Halbkreis. Die durchgezogenen, gestri-chelten, und gepunkteten Linien markieren die Isolinien pσ(x) = 1/2 in den Schritten1,2 und 5. Minimiert wird jeweils der Abstand zu den mit offenen Symbolen markiertendrei Punkten. Der rote Kreis liegt im Inneren, das Verfahren braucht nur einen Aufrufdes freien Optimierers. Für die grünen und blauen Dreiecke sind jeweils mehrere Aufrufenötig, wobei das blaue, nach unten zeigende Dreieck so gewählt ist, dass das Minimumin der Ecke liegt. Im rechten Graphen sind die Straffunktionen entlang der y-Achse, alsopσ(0,y), für dieselben Schritte gezeigt. Dünner grün sind die korrespondierenden Ziel-funktionen qσ(0,y) eingezeichnet.

Abbildung 9.3 illustriert das Verfahren am Beispiel einer Abstandsminimierung zueinem Halbkreis. Wir suchen also

minx∈M‖x− p‖2 mitM = (x,y) | gi(x,y) ≥ 0, i = 1,2 (9.32)

mitg1(x, y) = 4− x2 − y2 und g2(x,y) = −10y.

Dies entspricht offenbar ‖(x,y)‖2 ≤ 2 und y < 0, also dem Halbkreis. Im Beispiel wer-den drei verschiedene Punkte betrachtet und mit Hilfe des Straffunktionsverfahrens undeinem schrittweitengesteuerten Gradientenverfahren der nächste Punkt im Halbkreis ge-sucht. Der Straffaktor σ wurde als 0,1 k2 gewählt, mit k = 1,2, . . . der Iterationsschritt.p = (−1,−1) liegt selber im Inneren des Halbkreises und wird daher gleich im ersten Opti-mierungsschritt als nächster Punkt gefunden. Für die beiden anderen Punkte, p = (−1, 1)und p = (2,5, 1), sind nur die Gerade beziehungsweise beide Ungleichungen gleichzeitigaktiv; auch hier werden die nächsten Punkte am Rand des Halbkreises innerhalb wenigerIterationen gefunden. Auf der rechten Seite sieht man, dass die Straffunktionen sehr steilwerden. Daher ist eine Schrittweitensteuerung hier besonders wichtig.

172

9.3 Lineare Programme und Simplexalgorithmus

x

y

z

Abbildung 9.4: Links: Illustration eines linearen Programms. Die Nebenbedingungen sindx ≥ 0, y ≥ 0 und 1 − x ≥ y; die Schraffuren markieren den ausgeschlossenen Bereich.Der Pfeil deutet den Gradienten der Zielfunktion an, die Linien im zulässigen Bereichsind Isolinien des Potentials. Hier findet sich das Minimum in der mit einem Punktmarkierten rechten unteren Ecke. Rechts: Dreidimensionaler zulässiger Bereich x ≥ 0mit weiterer Nebenbedingung. Ist eine Nebenbedingung aTx = b gegeben, so sind nurPunkte mit Koordinaten ≥ 0 aus dieser Ebene zulässig, also aus dem grünen Dreieck.Die Projektion dieses Dreiecks in die xy-Ebene entspricht dem zulässigen Bereich in derlinken Illustration. Die Ecken lassen sich durch die Menge der Koordinaten, die nichtNull sind, vollständig beschreiben. Die unterste Ecke etwa hat nur y aktiv, die oberez. Sind zwei Nebenbedingungen gegeben, so ist die resultierende zulässige Menge eineGerade (hier rot eingezeichnet). Die Ecken werden nun durch zwei aktive Koordinatenbeschrieben, hier y und z für die vordere Ecke, und x und z für die hintere.


Wie wir in der Einleitung gesehen hatten, führt die lineare Regression mit Maximums-norm zu einem ganz anderen Typ von Problem, bei dem die Zielfunktion linear ist.Dadurch liegt das Minimum notwendigerweise auf dem Rand der zulässigen Menge. Sindzusätzlich noch die Nebenbedingungs(un-)gleichungen linear (vgl. Abbildung 9.4), sprichtman von einem linearen Programm. Programm hat hier also erst einmal nichts mit Com-putern zu tun. Solche linearen Programme spielen auch in der Optimierung von Wirt-schaftsprozessen eine wichtige Rolle („Operations research“), da Gewinn und produzierteMengen bei unverändertem Preis linear von einander abhängen.Lineare Programme können in einer Vielzahl von Formen definiert werden, wir be-

trachten hier die Normalform

min cTx unter den Nebenbedingungen x ≥ 0, Ax = b (9.33)

mit c ∈ Rn, A ∈ Rm,n und b ∈ Rm. Die Anzahl m der Gleichungsbedingungen ist dabeinicht festgelegt. Da x ein Vektor ist, bedeutet x ≥ 0 einfach, dass alle Komponentengrößer als Null sein sollen. Alle linearen Nebenbedingungen lassen sich so formulieren,eventuell unter Zuhilfenahme von weiteren Variablen.Betrachten wir zwei Beispiele. Die in der Abbildung 9.4 gegebene Nebenbedingung

1 − x ≥ y ist nicht von der obigen Form. Wir führen deswegen eine neue Variable z =

173

9 Optimierung

1−x−y ein, die dann z ≥ 0 erfüllen muss. Wir erhalten die Normalform mit c′ = (c0, c1, 0),da z ja nicht zur Zielfunktion beiträgt, sowie A = (1, 1, 1) und b = 1. Abbildung 9.4 rechtszeigt den resultierenden zulässigen Bereich im dreidimensionalen Raum.Auch das Problem

minv

(0, . . . , 0, 1)T v unter der Bedingung

(A e

−A e

)v ≥

(b

−b

), (9.34)

das sich bei der linearen Regression mit Maximumsnorm ergibt (vgl. (9.5)), ist nicht inNormalform. Zum einen müssen wir die Nebenbedingungsungleichungen in Gleichungentransformieren. Dazu führen wir einfach eine Schattenvariable zi = (ai, 1)T v − bi proUngleichung (ai, 1)T v ≥ bi ein. Dann ist zi ≥ 0 offenbar äquivalent zur ursprünglichenUngleichung. Analog verfahren wir mit den unteren Ungleichungen (−ai, 1)T v ≥ −bi.Zum anderen sind aber die Variablen v frei, während wir voraussetzen, dass v ≥ 0. Umdies zu beheben, teilen wir jede Variable in v = v+ − v− mit v± ≥ 0 auf und ergänzen Aund c entsprechend. Das ergibt die äquivalente Aufgabe

minx

(0, . . . , 0, 1, 0, . . . , 0, − 1, 0, . . . , 0)Tx (9.35)v+ v− z

mit der neuen Variablen x = (v+,v−,z) und den Nebenbedingungen x ≥ 0 und(A e −A −e − I 0

−A e A −e 0 −I

)x =

(b

−b

).

v+ v− z

Wie können wir Aufgabe (9.33) lösen? Sofern die zulässige Menge beschränkt ist, be-schreiben die Nebenbedingungen immer einen Polyeder. Man kann nun zeigen, dass sichein Optimum immer in einer der Ecken dieses Polyeders befindet. Der Simplexalgorith-mus besucht nacheinander die Ecken des Polyeders, wobei die Zielfunktion ständig kleinerwird. Da es nur endliche viele Ecken gibt, findet der Algorithmus das Minimum irgend-wann. Es gibt pathologische Beispiele, in denen der Algorithmus alle Ecken absuchenmuss. Im Allgemeinen konvergiert der Simplexalgorithmus aber schnell.Die Methode zerfällt dabei in zwei Phasen. In der ersten Phase muss eine gültige Ecke

bestimmt werden, in der zweiten Phase müssen wir dann von einer gültigen Ecke auseine neue, benachbarte Ecke mit niedrigerer Zielfunktion finden. Wir beginnen mit derBeschreibung der zweiten Phase, da die erste Phase die zweite Phase benutzt, um einerweitertes Problem zu lösen, das erlaubt, eine erste Ecke zu finden.

Phase II

Wir nehmen an, dass die Matrix A maximalen Zeilenrang hat, also alle doppelten Glei-chungen eliminiert wurden; dies wird später die erste Phase übernehmen. Außerdem seix eine Ecke des Polyeders.Wie stellen wir diese Ecke dar? Abbildung 9.4 illustriert, dass eine Ecke einfach durch

die Menge der aktiven, also von Null verschiedenen Koordinaten beschrieben werden

174


kann. Da wir angenommen haben, dass A ∈ Rm,n linear unabhängige Zeilen hat, be-schreibt Ax = b einen n −m-dimensionalen Unterraum, dessen Ecken jeweils m aktiveKoordinaten haben.Sei B = j1, . . . ,km die Menge der in der aktuellen Ecke aktiven Koordinaten, die

sogenannten Basiskoordinaten, und N = 1, . . . ,n\B die Menge der Nichtbasiskoordi-naten. AB = (aj1 , . . . ,ajm) ∈ Rm,m sei die zu den Basisvariablen xB = (xji)i ∈ Rmgehörende Teilmatrix, sowie AN analog die zu den Nichtbasisvariablen gehörende Teil-matrix. Dann gilt xN = 0 und damit ABxb = b. Der Zielfunktionswert in x ist deshalb

cTx = cTBxB = cBA−1B b. (9.36)

Wir betrachten nun eine beliebigen anderen Punkt u ∈ M , also u ≥ 0 und Au =ABuB +ANuN = b. Dann ist

ub = A−1B (b−ANuN ) = xB −A−1

B ANuN (9.37)

und damit

cTu = cTB(xB −A−1B ANuN ) + cTNuN = cTx+

(cN −ATN

(A−1B

)TcB

)T︸︷︷︸

r

un. (9.38)

Da uN ≥ 0 ist, kann die Zielfunktion nur verkleinert werden, wenn eine Komponenters < 0 ist. Ist dies nicht der Fall, haben wir also unser Optimum gefunden.Sei nun also s so gewählt, dass rs < 0 minimal. Dann können wir unser Ergebnis

verbessern, indem wir us > 0 wählen, aber alle anderen Elemente von uN weiterhinbei 0 belassen. Wir nehmen also s in die Basiskoordinaten B auf. Damit diese eine Basisbleiben, müssen wir nun noch sehen, welche Gleichung dafür herausfällt. Aus (9.37) folgt,dass uB = xB −usA−1

B as. Auch im neuen Punkt muss aber uB ≥ 0 gelten, daher könnenwir uN nur so groß wählen, bis für die erste Basisvariable xt = us(A

−1B as)t gilt. Dann gilt

ut = 0, d. h. diese Basisvariable geht in die Nichtbasis über. Wir suchen also

us = min

xjk

(A−1B as)k

|k ∈ B, (A−1B as)k > 0

=:

xjt(A−1

B as)t(9.39)

Sind dabei alle (A−1B as)k < 0, so dass das Minimum gar nicht existiert, können wir uB

unbegrenzt groß machen. Also ist der zulässige Bereich unbeschränkt, und wir müssenabbrechen, da die Funktion beliebig klein werden kann und also kein Minimum hat.Wir tauschen nun in der Basis B die gefundene beschränkende Basisvariable jt durch

s aus und erhalten die neue Basis B′. In AB wird dabei einfach die Spalte t durch asersetzt, also

AB′ = AB + (as − ajt)eTt (9.40)

Für die Rechnungen benötigen wir aber A−1B , dass wir allerdings auch mit einer Rang-1-

Formel anpassen können. Die Sherman-Morrison-Formel liefert

A−1B′ = A−1

B −A−1B as − et

(A−1B as)t

(eTt A

−1B

). (9.41)

175

9 Optimierung

Phase I

Wie können wir nun eine zulässige erste Lösung mit zugehörigem Basissatz und A−1B

finden? Die Idee ist, zunächst die Matrix noch einmal stark zu erweitern, sodass einegültige Ecke einfach zu finden ist, aber nur die Ecken des ursprünglichen zulässigenBereichs optimal sind. Phase II kann dann genutzt werden, um eine solche Ecke zufinden.Dazu betrachten wir das neue Problem

minz

(0, . . . , 0, 1, . . . , 1)T z (9.42)x y

mit der Variablen z = (x, y) ∈ Rn+m und den Nebenbedingungen z ≥ 0 und(A I

)z = b

Dabei sind die i-ten Zeilen von A und b identisch mit denen von A und b, nur werdendie Vorzeichen getauscht, falls bi < 0. Dies ändert die Lösungen des Gleichungssystemsnicht, aber es gilt b ≥ 0. Durch die Identität in den hinteren Spalten hat diese Matrixunabhängig vom ursprünglichen A maximalen Zeilenrang.Sofern die ursprüngliche zulässige Menge nicht leer war, ist das Minimum dieser Ziel-

funktion offenbar Null, nämlich dann, wenn alle y = 0 sind. Außerdem kennen wir einenzulässigen Punkt des neuen Problems, nämlich (0, b), und die zugehörige Matrix AB = I.Daher kennen wir auch A−1

B = I, das im Folgenden dann nur angepasst werden muss. Wirkönnen also die Phase I des Simplexalgorithmus unmittelbar auf diese Matrix anwenden.Findet der Simplex-Algorithmus nun ein Minimum, dass von Null verschieden ist, ist

offenbar die ursprüngliche zulässige Menge leer gewesen, und wir müssen abbrechen. Istdas Minimum hingegen Null und alle y = 0, also in der Nichtbasis, so haben wir unserenStartwert für die Phase II gefunden. Es kann allerdings auch passieren, dass noch zu ygehörige Indizes jt > n in der Basis vorkommen. Dann müssen wir eine echte Koordinates < n finden, die mit jt getauscht werden kann. Dazu suchen wir ein s mit A−1

B as)t 6= 0,so dass wir wieder unsere Austauschformel (9.41) auf die Spalten s und jt anwendenkönnen. Finden wir kein solches s, dann kann man zeigen,dass die ursprüngliche Matrixlinear abhängige Zeilen hatte. In diesem Fall wird die jt − n-te Zeile gestrichen. In A−1

B

müssen entsprechend die jt − n-te Spalte und t-te Spalte eliminiert werden.Quellcode 9.1 zeigt eine Implementation des Simplexverfahrens in Python.

Beispiel: Polynomapproximation

Als Beispiel für den Simplexalgorithmus und gleichzeitig noch einmal die Pseudoinversensoll das Beispiel der Polynomapproximation dienen. Gegeben Stützstellen xi, yi, i =1(1)m, suchen wir ein Polynom p(x) =

∑n−1i=0 cix

i, so dass

‖p(xi)− yi‖ = ‖Ac− b‖ (9.43)

176


1.0 0.5 0.0 0.5 1.00.0

0.5

1.0

1.5

2.0

2.5

3.0

1.0 0.5 0.0 0.5 1.00.00

0.01

0.02

0.03

0.04

0.05

0.06

Abbildung 9.5: Polynomapproximation von exp(x) (durchgezogene Kurve links) im Be-reich [−1,1]. Die Punkte markieren die 10 Stützstellen. Anders als bei der Interpolationist hier nur ein Polynom zweiten Grades gesucht, dass exp(x) an den gegebenen Stütz-stellen möglichst gut annähern soll. Die rot gestrichelte Lösung ist dabei die Lösungder kleinsten Quadrate, die grün gepunktete Lösung die mit minimaler maximaler Ab-weichung. Im rechten Graphen sind die absoluten Abweichungen zwischen den beidenPolynomnäherungen und exp(x) gezeigt. Die zweite Lösung erkauft sich eine niedrigereAbweichung am rechten Rand durch deutliche höhere Abweichung zwischen −0,8 und 0.Die maximalen Fehler sind dadurch gleichmäßig über das Intervall verteilt.

minimal ist. Die Matrix A ist dabei analog (3.7) definiert:

A =

1 x1 x2

1 . . . xn−11

......

...

1 xm x2m . . . xn−1

m

(9.44)

und b = (yi)i. Istm = n und die x-Koordinaten der Stützstellen xi paarweise verschieden,fällt die Polynomapproximation mit der Interpolation zusammen, da der minimale Fehler0 offenbar durch das eindeutige interpolierende Polynom erreicht wird.Anders als bei der Interpolation wählt man aber im Allgemeinen m n, das Polynom

kann also nicht alle Stützstellen passieren, und wird im Allgemeinen keine Stützstelleexakt treffen. Dafür vermeidet die Polynomapproximation das Rungeproblem, da diezusätzlichen Stützpunkte verhindern, dass das Polynom zu weit von der Zielfunktion ab-weicht. Das Minimum und der Algorithmus, mit dessen Hilfe dieses berechnet werdenkann, hängen von der verwendeten Norm ab. Ist ‖·‖ die aus dem üblichen Skalarpro-dukt abgeleitete 2-Norm ‖·‖2, so kann man das Minimum mit Hilfe der Pseudoinversen

177

9 Optimierung

0.0 0.5 1.0 1.5 2.0 2.5r/σ

1.5

1.0

0.5

0.0

0.5

1.0

1.5

2.0φLJ(r

)/ε

ε

σ

0 2 4 6 8 100

2

4

6

8

10

0500100015002000250030003500400045005000

Abbildung 9.6: Links: das Lennard-Jones-Potential mit dem typischen Radius σ und derTiefe des attraktiven Tals von ε. Rechts: Energielandschaft für ein LJ-Teilchen in einerzweidimensionalen LJ-Flüssigkeit. Rote Punkte markieren die Positionen anderer Teil-chen, die Graustufen repräsentieren das Potential. Die gelben Kreuze markieren lokaleMinima. Um diese zu finden, wurde zunächst das Potential an 100 × 100 Punkten aus-gewertet, und von allen Punkten mit einem Potential kleiner als 1000 aus eine lokaleMinimierung gestartet.

berechnen. Ist die Norm hingegen die Maximumsnorm, berechnet sich das Ergebnis mitHilfe von (9.5) bzw. (9.35) und dem Simplexalgorithmus.Abbildung 9.5 zeigt die Ergebnisse für die Approximation von exp(x) in diesen Normen.

Beide Näherungen approximieren die Funktion hinreichend gut. Unterschiede zeigen sichallerdings in den Absolutdifferenzen |p(x)− exp(x)|. Das in der 2-Norm approximierendePolynom minimiert den mittleren Fehler, indem es einen kleineren Fehler im Intervall< 0 durch einen höheren Fehler bei 1 erkauft. Da dies nur ein Punkt ist, wiegt der verrin-gerte Fehler bei negativen Zahlen schwerer. Die Minimierung der maximalen Abweichunghingegen führt dazu, dass sich der maximale Fehler sehr gleichmäßig über das Intervallverteilt, auch wenn dafür die Fehler bei negativen x deutlich größer sind.

9.4 Globale Optimierung

Die Ausgleichsrechnung, also min ‖Ax− b‖2, und die linearen Programme sind zwei Spe-zialfälle von Optimierung, bei denen ein gefundenes Optimum stets auch ein globalesMinimum ist. Das hängt damit zusammen, dass die Zielfunktionen im Allgemeinen nurein (Ausgleichsrechnung) oder gar kein lokales Minimum (lineare Programmierung) ha-ben. Im Gegensatz dazu finden das Newtonverfahren oder das Verfahren des steilsten

178


Listing 9.1: Simplexalgorithmus zur Lösung des linearen Programms min cTx unter denNebenbedingungen Ax = b, x ≥ 0. Es werden keine besonderen Eigenschaften von Avorausgesetzt, der Algorithmus eliminiert selbstständige redundante Zeilen.


def rank1update(Abinv, t, y):"""Update von Ab^-1, wenn in Ab Spalte t durch Ab*y ersetzt wird"""v = y.copy()pivot = v[t]v[t] -= 1v /= pivotu = Abinv[t]for i in range(Abinv.shape[0]):

Abinv[:,i] -= v*u[i]

def minelement(x):"""sucht die kleinste Komponente von x und deren Index"""s = 0minimum = x[0]for i in range(1,len(x)):

if x[i] < minimum:s, minimum = i, x[i]

return minimum, s

def maxelement(x):"""sucht die groesste Komponente von x und deren Index"""s = 0maximum = x[0]for i in range(1,len(x)):

if x[i] > maximum:s, maximum = i, x[i]

return maximum, s

def minposelement(x, y, eps):"""sucht den Index der kleinsten Komponente von x_i/y_i,wobei y_i > 0 sein soll."""s = -1for i in range(0,len(x)):

if y[i] > eps:v = x[i] / y[i]if s == -1 or v < minimum:

# erstes passendes Element# oder spaeter ein kleineress, minimum = i, v

if s >= 0: return selse: return None

#

179

9 Optimierung

def phase2(c, A, b, basis, Abinv, eps=1e-10):"""Phase 2 des Simplexverfahrens. c ist der Kostenvektor derZielfunktion c^Tx, die Nebenbedingungen Ax=b, A habe maximalenZeilenrang. basis ist die Menge der Basiskoordinaten der aktuellenEcke, und Abinv die Inverse von A eingeschraenkt auf dieBasiskoordinaten. Liefert das Optimum x zurueck und passt dieBasis sowie Abinv an. eps ist die Toleranz des Algorithmus."""

# Anzahl Variablenn = A.shape[1]# und Gleichungenm = A.shape[0]

# Nichtbasis berechnennichtbasis = []for i in range(n):

if not i in basis:nichtbasis.append(i)

while True:An = A[:, nichtbasis]cn = c[:, nichtbasis]cb = c[:, basis]xb = dot(Abinv, b)

# reduzierte Kostenr = cn - dot(An.transpose(), dot(Abinv.transpose(), cb))# beste Abstiegskoordinate s suchenminc, spos = minelement(r)if minc > -eps:

# keine Abstiegsrichtung, Minimum gefunden!x = zeros(n)x[basis] = xbreturn x

s = nichtbasis[spos]

# rauszuwerfende Variable suchenAbinvas = dot(Abinv, A[:,s])t = minposelement(xb, Abinvas, eps)

if t == None:# zulaessige Menge unbegrenzt!raise Exception("zulaessige Menge unbeschraenkt!")

# Austausch von j_t und snichtbasis[spos] = basis[t]basis[t] = s

# Update von Abinvrank1update(Abinv, t, Abinvas)

#

180


def phase1(c, A, b, eps=1e-10):"""Phase 1 des Simplexverfahrens. c ist der Kostenvektor derZielfunktion c^Tx, die Nebenbedingungen Ax=b. Liefert einezulaessige Basis, die zugehoerige Inverse sowie A und b zurueck,wobei A und b nun maximalen Zeilenrange haben. eps istdie Toleranz des Algorithmus."""

# Anzahl Variablen und Gleichungenm, n = A.shape

# Problem erweitern, damit wir eine Loesung kennenb = b.copy()A = concatenate((A, identity(m)),axis=1)c = concatenate((zeros(n), ones(m)))# Ax = b positiv machenfor i in range(m):

if b[i] < 0:b[i] = -b[i]A[i,:n] = -A[i,:n]

# sichere Eckebasis = range(n, n+m)# InverseAbinv = identity(m)

# Loesung mit Hilfe von Phase 2 suchenx = phase2(c, A, b, basis, Abinv, eps)if dot(c, x) > eps:

raise Exception("zulaessige Menge ist leer!")

while True:# pruefen, ob Basis noch Schattenvariablen enthaeltmaxb, t = maxelement(basis)if maxb <= n: break

# echte Ersatzvariable suchen, die nicht in der Basis istfor s in range(n):

if s in basis: continueAbinvas = dot(Abinv, A[:,s])if Abinvas[t] < 0:

# Ein Tauschpartner!basis[t] = srank1update(Abinv, t, Abinvas)break

else:# Schleife durchgelaufen, ohne Ersatzvariable zu finden# -> Matrix linear abhaengig, q-te Zeile streichendel basis[t]q = maxb - nA = delete(A, q, 0)b = delete(b, q, 0)Abinv = delete(Abinv, q, 1)Abinv = delete(Abinv, t, 0)

return basis, Abinv, A[:,:n], b#

181

9 Optimierung

def simplex(c, A, b, eps=1e-10):"""Simplexverfahren zur Minimierung von c^Tx unter derNebenbedingungen Ax=b und x >= 0. Liefert das Optimum xzurueck. eps ist die Toleranz des Algorithmus."""

basis, Abinv, A, b = phase1(c, A, b, eps)return phase2(c, A, b, basis, Abinv, eps)

182


Abstiegs stets nur lokale Minima, also Punkte mit verschwindendem Gradienten, dafüraber bei fast beliebiger Zielfunktion.In der Praxis, und besonders in physikalischen Anwendungen, sind die Zielfunktionen

meist stark nichtlinear und besitzen zahlreiche lokale Minima. Suchen wir etwa Grund-zustände eines komplexen Systems, müssen wir Minima der Energiefunktion finden, diemeist so viele lokale Nebenminima aufweist, dass es auch für einen Computer unmöglichist, alle zu untersuchen.Als Beispiel betrachten wir ein in der statistischen Physik sehr beliebtes Modell, das

Lennard-Jonesium (LJ). Dabei handelt es sich um Teilchen, die gemäß einem Potential

φLJ(r) = 4ε

[(σr

)12−(σr

)6]

(9.45)

wechselwirken (vgl. Abbildung 9.6 links). Das Potential hat ein Minimum der Tiefe −ε bei6√

2σ und wird unterhalb σ rasch sehr groß. φLJ ist ein einfaches Modell für Edelgasatomemit einem Durchmesser von etwa σ, die sich auf längere Abstände dispersiv (∼ r−6)anziehen.In einer solchen zweidimensionalen Lennard-Jones-Flüssigkeit aus 100 Teilchen in einer

10σ×10σ-Box wählen wir nun ein Teilchen aus und halten die Koordinaten aller anderenTeilchen fest. Abbildung 9.6 rechts zeigt die potentielle Energie in Abhängigkeit von derPosition des ausgewählten Teilchens. Dies ist aber nichts anderes als ein zweidimensiona-ler Schnitt durch die potentielle Energie als Funktion aller Teilchenkoordinaten. Um dielokalen Minima zu bestimmen, wurde zunächst auf einem 100×100-Raster das Potentialausgewertet, und von allen hinreichend niedrigen Punkten aus eine lokale Minimierunggestartet. Da bereits dieser Schnitt über 20 lokale Minima aufweist, kann man sich vor-stellen, wie viele lokale Minima die Energie als Funktion aller 200 Teilchenkoordinatenaufweist. Wegen des “Curse of dimensionality” ist es in diesem Fall nicht mehr möglich,eine Rasterung vorzunehmen. Es ist also aussichtslos, sämtliche lokale Minima mit Hilfeeines lokalen Minimierungsverfahrens zu suchen.Im Folgenden lernen wir zwei heuristische Methoden kennen, die auch unter solchen

Bedingungen meist akzeptable Näherungen für das globale Minimum finden.

9.4.1 Simulated annealing

Simulated Annealing (Simulierte Abkühlung) basiert auf der Beobachtung, dass durchgesteuerte, langsame Abkühlung das Wachstum besonders gleichmäßiger Kristalle ge-fördert wird. Dies macht man sich zum Beispiel bei der Härtung von Stahl zu Nutze.Letztendlich ist Kristallisation aber nichts anderes als ein Optimierungsprozess, da derEinkristall die energetisch minimale Struktur ist.Um dies auf ein Optimierungsproblem zu übertragen, legt man die Boltzmann-Statistik

der statistischen Physik zugrunde, die besagt, dass bei Temperatur T alle Zustände gemäß

PT (x) ∼ e−βE(x) (9.46)

verteilt sind, wobei E die potentielle Energie des Systems im Zustand x ist und 1/β =kBT mit der Boltzmannkonstanten kB.

183

9 Optimierung

Sei nun x0 das globale Minimum der Energiefunktion E. Dann ist für alle x

PT (x) ∼ e−βE(x) = e−βE(xo)eβ[E(x0)−E(x)] ∼ e−β[E(x)−E(x0)] ≤ 1, (9.47)

da E(x)−E(x0) ≥ 0. Bei niedrigen Temperaturen ist β sehr groß, so dass alle Zuständemit einer größeren Energie als E(x0) rasch sehr unwahrscheinlich werden. Durch Ab-kühlen wird es also tatsächlich sehr wahrscheinlich, das globale Minimum zu finden. Umdamit ein Optimierungsproblem minxE(x) global zu lösen, fassen wir die Elemente derzulässigen Menge als Zustände auf, und die zu minimierende Funktion E als Energiedieser Zustände.Im Prinzip könnte man nun mit Hilfe der Verwerfungsmethode versuchen, PT -verteilte

zufällige Zustände zu erzeugen. Wie wir im Eingangsbeispiel gesehen haben, schwanktdie Energielandschaft allerdings oft stark, so dass die meisten Punkte extrem kleine Ak-zeptanzraten hätten. Dies sorgt für astronomisch hohe Verwerfungsraten, so dass es mitdieser Methode unmöglich ist, die Boltzmann-Verteilung abzutasten. In der statistischenPhysik benutzt man als Ausweg das Monte-Carlo-Sampling von N. Metropolis.Ziel dieser Methode ist es, nacheinander Punkte xi zu erzeugen, die PT -verteilt sind,

so dass die Folge xi unsere Verteilung repräsentiert. Nehmen wir nun an, dass unseraktueller Punkt bereits PT -verteilt gezogen wurde, müssen wir also den nächsten Punktso wählen, dass wir die Verteilung nicht ändern. Dazu wählen wir zufällige Übergängexi → xi+1 so, dass für zwei beliebige Punkte x und y die Übergänge x → y und y → xmit gleicher Wahrscheinlichkeit ausgewählt werden. Eine Möglichkeit ist der klassischeMetropolis-Schritt

y = xi + d, mit d gleichverteilt auf einer Kugel vom Radius r. (9.48)

r ist dabei in gewisser Weise die maximale Schrittweite dieses Algorithmus. Dies erzeugteine Gleichverteilung der Punkte; um die korrekte Verteilung zu erzeugen, setzen wirxi+1 = y mit Wahrscheinlichkeit proportional zu

p(y) = min(e−β[E(y)−E(xi)], 1) = min(P (y)/P (xi), 1). (9.49)

Ist also E(y) ≤ E(xi), akzeptieren wir den Schritt immer, ist E(y) > E(xi), dann mitWahrscheinlichkeit e−β[E(y)−E(xi)]. Die Verwerfungsmethode liefert uns einen einfachenAlgorithmus, diese Verteilung zu erzeugen — wir ziehen eine Standardzufallszahl u undsetzen xi+1 = y, falls u < p(y) und xi+1 = xi sonst.Beim Simulated Annealing werden die Punkte mit Hilfe der Metropolis-Methode PT -

verteilt erzeugt, und gleichzeitig die Temperatur langsam abgesenkt. Dadurch sollte dieVerteilung langsam gegen P0 konvergieren, in der nur noch das oder die globalen Mi-nima eine nichtverschwindende Wahrscheinlichkeit haben. Dementsprechend konvergiertdie Folge xi gegen ein globales Minimum. Problematisch kann sein, dass die korrekte Ver-teilung der xi natürlich nur sichergestellt werden kann, wenn auch hinreichend viele xigeneriert werden. Das bedeutet, dass die Temperatur langsam abgesenkt werden sollte,wobei “langsam” vom Problem abhängt.Die funktionale Form der Temperaturkurve ist frei wählbar. Typischerweise wählt man

eine exponentielle FormTi+1 = (1− δ)T (9.50)

184


103 104 105 106

Simulationsschritt

70

60

50

40

30

20

10

0

δ=0.1 δ=0.05

δ=0.01 δ=0.001

Abbildung 9.7: Simulated Annealing eines zweidimensionalen Salzschmelzemodells. Linkssind die gefundenen Grundzustände für verschiedene Abkühlraten δ gezeigt, rechts diedazugehörigen potentiellen Energien als Funktion der Zeit (schwarz gepunktet δ = 0,1,grün durchgezogen δ = 0,05, blau gestrichelt δ = 0,01 und magentafarbene Strichpunkteδ = 0,005). Der eigentlich Grundzustand wäre ein NaCl-artiges Gitter, das aber nichtgefunden wird, auch wenn die Simulationen immer größere Gitterflächen zeigen. DieUnterschiede in den finalen Energien sind sehr klein, was nochmals zeigt, dass auchdieses Problem sehr viele Nebenminima aufweist.

mit kleinem δ > 0 (etwa 10−6). Dann wird natürlich T = 0 nie erreicht, allerdings sindkleine T meist ausreichend. Alternativ kann man eine lineare Form wählen

Ti+1 = Ti − δ, solange Ti > δ. (9.51)

Simulated Annealing funktioniert nicht nur mit dem Metropolis-Schritt, sondern auchmit allen anderen möglichen Monte-Carlo-Schritten, wie sie in der Vorlesung „Simula-tionsmethoden“ behandelt werden. Auch Molekulardynamik kann genutzt werden, umZustände im kanonischen Ensemble, also bei konstanter Temperatur, zu erzeugen.

Beispiel: zweidimensionale Salzschmelze

Als Beispiel zeigt Abbildung 9.7 Daten zur Kristallisation eines einfachen NaCl-Modells.Hier wechselwirken die Teilchen mit einem Potential

φij = qiqj4σε

r+

4ε(σr

12 − σr

6)

+ ε für r := ‖xi − xj‖ < 6√

2σ

0 sonst.(9.52)

Die Hälfte der Teilchen haben dabei Ladung qi = 1, die andere Hälfte qi = −1. Der ersteTeil des Potentials ist das Coulombpotential aufgrund der elektrostatischen Anziehung

185

9 Optimierung

bzw. Abstoßung, der zweite besteht aus dem repulsiven Teil des LJ-Potentials und simu-liert die Volumenausschlußwechselwirkung. Die Teilchen arrangieren sich aufgrund desVolumenausschlusses recht schnell in einem Gitter, es kostet allerdings sehr viel Energie,dann Plätze zu tauschen. Daher gibt es zahlreiche Nebenminima.Im Beispiel wurde statt des Metropolisalgorithmus eine Molekulardynamiksimulation

mit Hilfe von ESPResSo [Esp] benutzt. Auch hier kann die Temperatur gesteuert werden.Links zeigt Abbildung 9.7 die gefundenen Annäherungen für Grundzustände, rechts sindderen Energien gezeigt. Trotz der recht langen Simulationszeiten sind die gefundenenGrundzustände noch nicht optimal — das wäre ein quadratisches Gitter mit alternie-render Besetzung. Eine Monte-Carlo-Simulation könnte hier übrigens deutlich effizientersein, allerdings nur, wenn auch sogenannte Identitätstauschschritte benutzt werden, beidenen zwei beliebige Teilchen ihre Ladungen austauschen und so die Energiebarrierenumgehen.

9.4.2 Genetische Algorithmen

Für die Untersuchung noch komplexerer Kristallstrukturen, etwa mit -3- und 5-wertigenIonen, ist der obige Ansatz immer noch nicht effizient genug, da er dazu neigt, in lokalenMinima stecken zu bleiben. Besser wäre es, Elementarzellen des Kristalls durchzuprobie-ren, und nach derjenigen mit minimaler Energie zu suchen. Leider ist auch diese Opti-mierung noch sehr umfangreich, und die Menge der möglichen Kristallstrukturen lässtsich nicht einfach als Vektorraum beschreiben.In solchen Fällen sind genetische Algorithmen ein biologisch inspirierter Ansatz, um

trotzdem eine globale Minimierung durchführen zu können. Dabei ist das Genom nichtmehr ein DNS-Molekül, sondern eine Zeichenkette aus reellen Zahlen, Bits oder ähnli-chem, die jeweils ein Element der ursprünglichen zulässigen Menge codieren (also zumBeispiel eine mögliche Elementarzelle). Wir erzeugen zu Beginn der genetischen Algo-rithmus zufällig eine große Menge von Individuen (etwa einige 1000), indem wir zufälligeentsprechende Zeichenketten generieren.Wie bei der natürlichen Evolution sollen sich im Verlauf die „fittesten“ Individuen

sich vermehren und ungeeignetere aussterben. Dazu definieren wir eine Fitnessfunktion,die die Güte eines Genoms bzw. des dadurch codierten Individuums misst. Im Falle derKristallgitteroptimierung wäre dies zum Beispiel die Energie eines Gitters, dass aus derElementarzelle entsteht, die vom Genom codiert wird.Wie werden nun Individuen vermehrt? Einfach, indem zufällige, kleine Änderungen

am Genom des sich vermehrenden Individuums vorgenommen werden und dieses neueGenom in den Pool der vorhanden Individuen aufgenommen wird. Dabei werden fittereIndividuen häufiger vermehrt. Das kann man auf verschiedene Weisen erreichen, zumBeispiel, indem stets eine kleine Anzahl von Individuen zufällig ausgewählt wird, undvon diesen das fitteste vermehrt. Dabei gibt es zwei Typen von Änderungen am Genom:Mutationen, also kleine zufällige Änderungen im Genom, und Kreuzungen zweier guterIndividuen. Dabei werden zufällig Abschnitte der beiden ausgewählten Individuen zueinem neuen Genom kombiniert.Um die Menge der Genome konstant zu halten, können bei diesem Prozess auch Ge-

186


nome entfernt werden. Werden etwa die fittesten Individuen einer zufällig gewähltenGruppe zur Vermehrung herangezogen, kann gleichzeitig das am wenigste fitte Elementdieser Gruppe gelöscht werden.L. Filion und M. Dijkstra [FD09] haben einen solchen Algorithmus benutzt, um die

möglichen Kristallstrukturen in binären kolloidalen Kristallen mit verschiedenen Grö-ßen und Ladungen vorherzusagen. Dabei werden die Elementarzellen durch eine festeAnzahl von Vektoren dargestellt. Hat die Elementarzelle n Elemente, stellen n− 1 Vek-toren Bi die Relativpositionen der Elemente in der Zelle dar, und 3 Vektoren Li legendie Relativpositionen der räumlichen Kopien der Elementarzelle fest. In den meistenzufällig so erzeugten Gittern überlappen Teilchen, so dass auch in diesem Fall ein wei-ches Lennard-Jones-Potential die Volumenausschlusswechselwirkung modelliert. Dadurchwerden undefinierte Energiewerte vermieden.Zur Vermehrung werden zufällig zwei Individuen gewählt, deren Vektoren Bi zufällig

um maximal ±10% gestreckt werden. Dann wird zufällig B1, . . . , Bk vom ersten Individu-um mit Bk+1, . . . , Bn vom zweiten kombiniert, und analog die Li. Zusätzlich wird sichergestellt, dass die Li linear unabhängig sind, also tatsächlich ein Gitter aufspannen. Umdie Chancen des neuen Genoms zu erhöhen, wird für dieses die Energie lokal minimiert,indem die Darstellung geeignet verdreht wird. Es ist durchaus üblich, physikalisches Wis-sen in genetischen Algorithmen zu benutzen, um bessere Genome zu erzeugen.

187

10 Differentialgleichungen

Fast alle physikalischen Vorgänge können durch Differentialgleichungen (DGLs) beschrie-ben werden, von der Schrödingergleichung für Quantensysteme, über die NewtonschenBewegungsgleichungen bis hin zu den Navier-Stokes-Gleichungen für Strömungen. Auchdas einleitende Problem des Fadenpendels wurde durch die Differentialgleichung

α = −gl

sin(α) (10.1)

beschrieben. Die analytische Lösung dieser und der meisten Differentialgleichungen istschwierig oder unmöglich, und daher sind numerische Verfahren zum Lösen von DGLswichtige Hilfsmittel, um diese trotzdem untersuchen zu können.Im Folgenden werden wir numerische Löser für verschiedene Klassen von Differential-

gleichungen kennenlernen. Für gewöhnliche Differentialgleichungen mit skalarer Variablesind das die Runge-Kutta-Verfahren, sowie das bereits in der Einleitung besprochene,sehr gebräuchliche Velocity-Verlet-Verfahren.Schwieriger ist die Lösung partieller Differentialgleichungen, die mehrdimensionale Va-

riablen und deren Ableitungen enthalten. Diese spielen in der Physik eine besonderswichtige Rolle, weil sie bei zeit- und ortsabhängigen Prozessen quasi automatisch auf-treten. Sie werden meist mit Hilfe finiter Element-Methoden behandelt, die wir in dieserVorlesung aber nur anreissen können. Wir lernen stattdessen einige Beispiele von partiel-len DGLs kennen und wie diese mit Hilfe finiter Differenzen oder Fouriertransformationennumerisch gelöst werden können.

10.1 Gewöhnliche Differentialgleichungen

Wir betrachten Differentialgleichungen der Form

y(m)(t) = F (t, y(t), y(t), . . . , y(m−1)(t)) (10.2)

mit der gesuchten Lösung y : R→ Rn. Diese heißen gewöhnlich, da sie nur von einer ska-laren Variablen, t, abhängen. Wie der Name t schon vermuten lässt, wird diese Variablemeist mit der Zeit assoziiert. Die spezielle Form (10.2) wird auch explizite gewöhnlicheDifferentialgleichung m-ter Ordnung genannt, da wir voraussetzen, dass sich die Glei-chung global nach y(m)(t) auflösen lässt, und m Ableitungen involviert sind. ImpliziteGleichungen der Form F (t, y(t), y(t), . . . , y(m)(t)) = 0 sind numerisch sehr viel schwieri-ger zu lösen, tauchen aber in der Physik auch seltener auf und werden daher hier nichtweiter besprochen.

189


Für die numerische Lösung beschränken wir uns weiter auf gewöhnliche Differential-gleichungen erster Ordnung, also von der Form

y(t) = F (t, y(t)), y(0) gegeben. (10.3)

Dies ist keine wirkliche Einschränkung, da sich jede explizite Differentialgleichung m-terOrdnung in eine höherdimensionale Gleichung erster Ordnung transformieren lässt:

d

dt

y(t)

y(t)...

y(m−1)(t)

=

y(t)

y(t)...

y(m)(t) = F (t, y(t), y(t), . . . , y(m−1)(t))

(10.4)

Die Differentialgleichung des einleitenden Beispiels

α(t) = −gl

sinα(t), (10.5)

wird so zum Beispiel zu

d

dt

(α(t)

α(t)

)=

(α(t)

−gl sinα(t),

). (10.6)

Der Startwert ist genau wie im Eingangskapitel (α(0), α(0)), also Anfangsposition und-geschwindigkeit.

10.1.1 Runge-Kutta-Verfahren

Wir suchen eine diskretisierte Näherung yn ≈ y(tn) für das Problem (10.3) mit äquidi-stanten Zeitpunkten tn = nh, n = 0, 1, . . ., also Schrittweite h. Es gilt

y(tn+1) = y(tn + h) = y(tn) +

∫ tn+h

tn

y(t) dt = y(tn) +

∫ tn+h

tn

F [t, y(t)] dt. (10.7)

Da y0 = y(0) gegeben ist, liegt es nahe, y1 ≈ y(h) durch numerische Integration zubestimmen, dann y2 ≈ y(2h) durch numerische Integration aus y1 und so weiter. DasProblem dabei ist, dass der Integrand F [t, y(t)] die zu findende Funktion y enthält. Umalso y(t) an Stellen t ∈ [tn, tn+h] annähern zu können, müssen wir einige Werte von y indiesem Intervall wiederum durch Integration gewinnen. Dies führt zur allgemeinen Formeines s-stufigen Runge-Kutta-Verfahrens

yn+1 = yn + h

s∑j=1

bjkj (10.8)

mit den Näherungen für F [tn + hcj , y(tn + hcj)]

kj = F

(tn + hcj , yn + h

s∑k=1

ajkkk

). (10.9)

190


b, c ∈ Rs und A = (ajk) ∈ Rs,s sind dabei Konstanten, die das Verfahren beschreiben.c gibt die Zeitpunkte an, an denen F [t, y(t)] im Intervall [t, t + h] angenähert wird, inVielfachen der Schrittweite h. ci = 0 besagt also, dass ki ≈ F [tn, y(tn)], ci = 1, dasski ≈ F [tn + h, y(tn + h)]. A gibt die Quadraturgewichte für die Zwischennäherungen an,b die Quadraturgewichte der Endnäherung. Diese Konstanten sind dabei nicht nur vonF unabhängig, sondern auch von der Schrittweite h, so dass ein Runge-Kutta-Schemadurch Verkleinern der Schrittweite im Prinzip beliebig genau gemacht werden kann. DieZwischenwerte kj erscheinen auf beiden Seiten von (10.9), es handelt sich also um eingekoppeltes, implizites Gleichungssystem. Ist F (t, y) eine nichtlineare Funktion, ist einesolche Gleichung nur aufwändig zu lösen.Daher werden meist explizite Runge-Kutta-Verfahren verwendet, bei denen A eine lin-

ke untere Dreiecksmatrix mit Nulldiagonale ist, also ajk = 0 für k ≥ j. Dann werden zurBerechnung von kj nur kk, k = 1(1)j−1 benötigt, die bereits berechnet sind. Eine Imple-mentierung eines Runge-Kutta-Verfahrens ähnelt dann sehr dem Gauß-Seidel-Verfahren,das ebenfalls die Zeilen der zu lösenden Matrix sequentiell abarbeitet.Dass man trotzdem auch implizite Verfahren, also mit allgemeiner Matrix, in Betracht

zieht, hängt damit zusammen, dass diese stabiler sind, und auch sogenannte steife DGLslösen können. Ist A linke untere Dreiecksmatrix, aber die Diagonale nicht Null, sprichtman von DIRKs, diagonal-impliziten Runge-Kutta-Verfahren. Diese lassen sich noch mitverhältnismäßig begrenztem Aufwand lösen, da pro kj lediglich eine eindimensionaleGleichung gelöst werden muss.Der Fehler von Runge-Kutta-Verfahren wird üblicherweise durch die Konvergenz- und

Konsistenzordnung beschrieben. Die Konvergenzordnung p besagt, dass die Näherunggleichmäßig gegen f(tn) konvergiert, also max ‖yn − y(tn)‖ = O(hp). Die Konvergenz istmeist schwer zu beweisen, einfacher ist die Konsistenzordnung p, die nur fordert, dass‖yn+1 − y(tn+1)‖ = O(hp), falls yn = y(tn). Konsistenz besagt also lediglich, dass einSchritt prinzipiell konvergiert. Ist die Funktion F Lipschitz-stetig, also etwa genügendglatt, dann gilt allerdings Konsistenzordnung = Konvergenzordnung.Im Folgenden werden einige der gebräuchlicheren Runge-Kutta-Verfahren angegeben.

Dabei hat sich das Butcher-Tableau

c A

bT

als kurze Darstellung etabliert. Die j-te Zeile gibt dabei an, zu welchen Zeitpunkt tn+hcjdie Näherung kj berechnet wird und welchen Quadraturgewichte benutzt werden. bj sinddie Quadraturgewichte der für die finale Integration zu yn+1.Die Konstanten ergeben sich im Prinzip aus den benutzten Quadraturformeln. Aller-

dings gibt es neben der Bedingung, dass die Formeln möglichst explizit sein sollten, nochweitere Stabilitätsbedingungen, die hier aber nicht beschrieben werden können. Daherkann man nicht einfach beliebige Quadraturformeln kombinieren, sondern sollte bei denim Folgenden beschriebenen, gebräuchlichen Formeln bleiben.

191


Explizites Eulerverfahren

0

1

Dieses Butcher-Tableau besagt nichts anderes, als dass

yn+1 = yn + hF (tn, yn) ≈ y(tn) + hy(tn). (10.10)

Es handelt sich also um die direkte Integration per Rechteckregel, und damit um einVerfahren der Ordnung 1, d. h. mit globalem Fehler O(h). Dieses Verfahren entsprichtder einfachen Integration (1.10) im einleitenden Beispiel. Das explizite Eulerverfahren istnicht sehr genau und nur für global Lipschitz-stetige F stabil. Daher sollte man es beipraktischen Anwendungen im Allgemeinen vermeiden.

Implizites Eulerverfahren

1 1

1

Wie der Name schon sagt, ist dies ein implizites Verfahren, genauer, ein DIRK, bei demin jedem Schritt die Gleichung

k1 = F (tn+1, yn + hk1) (10.11)

gelöst werden muss, um die neue Näherung yn+1 = yn + hk1 zu berechnen. Durch Ein-setzen ergibt sich

yn+1 = yn + hF (tn+1, yn+1), (10.12)

das implizite Eulerverfahren ist also ebenfalls eine Rechteckregel, aber mit dem neu zubestimmenden Punkt yn+1 als Aufpunkt. Die Ordnung dieses Verfahrens ist daher eben-falls 1. Anders als das explizite Eulerverfahren ist das implizite Eulerverfahren allerdingsziemlich stabil, auch wenn F nicht Lipschitz-stetig ist. Der Nachteil ist, dass in jedemSchritt eine nichtlineare Gleichung gelöst werden muss, was das Verfahren recht aufwän-dig macht.

Das Runge-Kutta-Verfahren

01/2 1/2

1/2 0 1/2

1 0 0 11/6 1/3 1/3 1/6

192


Dies ist das klassische Runge-Kutta-Verfahren, das zuerst 1901 von Kutta beschriebenwurde. Wird in der Literatur von „dem Runge-Kutta-Verfahren“ ohne weitere Angabengesprochen, ist daher dieses Verfahren gemeint. Bei genügend glattem f hat es Konver-genzordnung 4, ist also deutlich besser als die Eulerverfahren.Wie können wir das Tableau verstehen? Wir setzen τ = h/2. Die zweite und dritte Zeile

bestimmen zwei Näherungen für F [tn + τ, y(tn + τ)], zunächst mit Hilfe der linken (k2),und dann der rechten Ableitung (k3). k4 ist dann eine Näherung für F [tn + h, y(tn + h)].Diese Näherungen werden in die Simpsonregel eingebracht, wobei k2 und k3 mit gleichenGewichten eingehen.

Beispielimplementation

Eine Python-Implementation des allgemeinen Runge-Kutta-Schemas für y(t) =F[t, y(t)],y(0) = y0 könnte wie folgt aussehen:

from numpy import *

def rk_explicit(verfahren, F, y0, tmax, h):def step(hc, hA, hb, F, yn, tn):

"ein einzelner Schritt"k = []for i in range(len(hc)):

k.append(F(tn + hc[i], yn + dot(hA[i,:i], k[:i])))return yn + dot(hb, k)

# Zur Beschleunigung skalierte Parameter vorberechnenhA = h*verfahren[’A’]hc = h*verfahren[’c’]hb = h*verfahren[’b’]

# Startwert und -zeittn = 0.0yn = y0.copy()# Ergebnisvektor mit Zeit und Punktenresult = [ concatenate(((tn,), yn.copy())) ]while tn < tmax:

yn = step(hc, hA, hb, F, yn, tn)tn += hresult.append(concatenate(((tn,), yn.copy())))


Die Lösung y(t) kann dabei auch vektorwertig sein, dann müssen y0 und der Rückga-bewert der Funktion F gleich große NumPy-Arrays sein. Die Integration findet stets vont = 0 bis tmax statt, in Schritten der Weite h. Die Routine liefert das Ergebnis als Ma-trix aus den Zeit- und Lösungspunkten zurück. Die erste Spalte enthält den Zeitpunkttn, die zweite die erste Komponente von yn, die dritte die zweite Komponente usw.Die Funktion rk_explicit kann beliebige, explizite Runge-Kutta-Verfahren durch-

führen. Dazu erwartet sie als ersten Parameter ein Wörterbuch, dass das Butchertableau

193


0 2 4 6 8 10050

100150200250300

Popu

latio

nen

0 2 4 6 8 10Zeit in Jahren

050

100150200250300

Popu

latio

nen

0 50 100 150 200 250 300 350 400Beute

0

100

200

300

400

500

Räub

er

Abbildung 10.1: Lösungen der Lotka-Volterra-Gleichungen mit dem einfachen Eulerver-fahren (oben links) und dem Runge-Kutta-Verfahren (unten links). Blau gepunktet istdie Beutepopulation, rot gestrichelt die Räuberpopulation. Rechts das Räuber-Beute-Diagramm für das Eulerverfahren (blau gestrichelt) und das Runge-Kutta-Verfahren (rotdurchgezogen). Während das Verfahren vierter Ordnung die erwartete periodische Tra-jektorie ergibt, wächst mit dem Eulerverfahren die Spitzenpopulation immer weiter. Dieszeigt die Instabilität des Eulerverfahrens.

für das zu benutzende Runge-Kutta-Verfahren beschreibt. Für das Eulerverfahren unddas klassische Runge-Kutta-Verfahren sehen solche Wörterbücher so aus:

# Butchertableau fuer das explizite Eulerverfahreneuler = ’c’: array((0,)),

’A’: array(((0,),)),’b’: array((1,))

# Butchertableau fuer das klassische Runge-Kutta-Verfahrenrk_klassisch = ’c’: array((0,0.5,0.5,1)),

’A’: array(((0 , 0, 0),(0.5, 0, 0),(0 ,0.5, 0),(0 , 0, 1),)),

’b’: array((1./6,1./3,1./3,1./6))

10.1.2 Beispiel: Lotka-Volterra-Gleichungen

Die Lotka-Volterra-Gleichungen sind nach A. J. Lotka und V. Volterra benannt, die diese1925 als einfaches Modell für die Populationsdynamik eines Räuber-Beute-Systems ange-

194


geben hatten, also, wie sich die Populationsgrößen von Räubern und Beute im zeitlichenVerlauf ändern. Die Gleichungen beruhen auf stark vereinfachenden Annahmen, nämlich,dass den Beutetieren unbegrenzte Resourcen zur Verfügung stehen, während die Räuberausschließlich auf die Beutetiere angewiesen sind. Trotzdem lassen sich die qualitativenVorhersagen dieses Modells in der Natur verifizieren, an so unterschiedlichen Systemenwie zum Beispiel Haie und Fische oder Wölfe und Hasen. Es gibt Erweiterungen mit be-grenzten Resourcen, oder mehrstufigen Systemen (also etwa Haie, Fische und Plankton),die aber nicht wesentlich mehr zum Verständnis beitragen.Die klassischen Lotka-Volterra-Gleichungen sind zwei gekoppelte Differentialgleichun-

gen für die Populationen NR der Räuber und NB der Beutetiere:

d

dt

(NB

NR

)= F (NB, NR) =

(ANB −BNBNR

−CNR +DNBNR

). (10.13)

Dabei gibt A die Vermehrungsrate der Beutetiere an, die nur von der aktuellen Popula-tionsgröße abhängt und B die Rate, mit der ein Räuber ein Beutetier auffrisst. C gibtdie Sterberate der Räuber an, und D die Rate, mit der sich ein Räuber vermehrt, wenner ein Beutetier gefangen hat. Die Räuber müssen also Beutetiere fangen, um sich zuvermehren, während die Beutetiere sich von selber vermehren. Sind also keine Räubervorhanden, vermehren sich die Beutetiere exponentiell, sind keine Beutetiere vorhanden,sterben die Jäger exponentiell aus.Im Folgenden betrachten wir ein solches System aus Hasen und Wölfen. Es sei A = 2

Hasen pro Jahr, d. h. ein Hasenpaar hat vier Nachkommen im Jahr, und B = 0,1, ein Wolffängt also im Schnitt alle 10 Jahre einen bestimmten Hasen. Die tatsächliche Fangratehängt natürlich von der Menge der Wölfe und Hasen ab. Gibt es viele Hasen oder Wölfe,ist die Chance, dass irgendein Wolf irgendeinen Hasen fängt, gut. Die Wölfe hingegensind recht hungrig, wir setzen daher C = 12. Ein Wolf stirbt also in etwa einem Monat,wenn er keinen Hasen fängt. Umgekehrt reicht ein Hase kaum, um sich zu vermehren,daher setzen wir D = 0,1, so dass etwa 10 Hasen zur erfolgreichen Vermehrung gefressenwerden müssen.Nachdem wir nun die Raten festgelegt haben, können wir zum Beispiel ein Runge-

Kutta-Verfahren benutzen, um (10.13) zu lösen. Dazu müssen wir noch einen Startwertfestlegen, hier hundert Hasen und einen Wolf, und eine Schrittweite, die wir auf einenTag, also 1/365-tel, setzen. Abbildung 10.1 zeigt die resultierenden Populationen, einmalals Funktion der Zeit und einmal als Räuber-Beute-Diagramm.Charakteristisch für die Lotka-Volterra-Gleichungen ist ein periodisches Verhalten, wie

man analytisch zeigen kann. Dabei gibt es lediglich zwei Gleichgewichtszustände, den manleicht bestimmen kann:

0!

=

(NB(A−BNR)

NR(−C +DNB)

)=⇒ NB = NR = 0 oder NB =

C

Dund NR =

A

B. (10.14)

In unserem Fall wären die Populationen also bei NB = 120 und NR = 20 stabil. Unserdavon leicht abweichender Startwert sollte zu einer Trajektorie führen, die um diesen

195


Fixpunkt periodisch kreist. Dies ist auch tatsächlich der Fall, wenn das Runge-Kutta-Verfahren, das vierte Ordnung hat, benutzt wird. Dabei ist gut zu beobachten, dass dieWolfspopulation der Hasenpopulation folgt. Zunächst wächst die Hasenpopulation na-hezu ungebremst exponentiell, bis die Wolfspopulation nachzieht. Daraufhin dezimierendie Wölfe die Hasenpopulation rasch und sterben in der Folge selber nahezu aus. Da-durch nimmt die Hasenpopulation wieder exponentiell zu, und der Zyklus beginnt vonneuem. Das Nachlaufen der Räuberpopulation ist charakteristisch für die Lotka-Volterra-Gleichungen und kann auch in der Natur beobachtet werden.Wird zur Integration statt des Runge-Kutta-Verfahrens das Eulerverfahren benutzt,

nehmen beide Populationen mit der Zeit immer weiter zu. Wie vorher gesagt, sind dieLösungen der Lotka-Volterra-Gleichungen aber periodisch, sofern es Räuber gibt. Die Zu-nahme ist also nur ein numerisches Artefakt. Selbst wenn der Zeitschritt um einen Faktor10 gesenkt wird, driften die mit dem Eulerverfahren berechneten Populationen währendder gezeigten 10 Jahre um etwa 10 Individuen. Dies zeigt eindrücklich die Instabilitätdes Eulerverfahrens.

10.1.3 Velocity-Verlet-Verfahren

In der Einleitung hatten wir bereits besprochen, dass die Fadenpendelgleichung (10.5)mit Hilfe des Velocity-Verlet-Verfahrens numerisch gelöst werden kann. Dieses dient zurLösung von Differentialgleichungen der Form

x(t) = F [t, x(t)], (10.15)

also gewöhnlichen Differentialgleichungen zweiter Ordnung, die nicht von der Geschwin-digkeit x(t) = v(t) abhängen. Diese Form ist typisch für Bewegungsgleichungen mit kon-servativen Kräften, daher ist das Velocity-Verlet-Verfahren zum Beispiel das Standard-Verfahren für die Propagation von klassischen Vielteilchensystemen und spielt eine wich-tige Rolle in gängigen Programmen zur Molekulardynamik. Diese integrieren mit Hilfeeben dieses Verfahrens die Bewegungsgleichungen für unter Umständen mehrere Milliar-den Atome!Auch bei dieser Methode wird die Lösung xn ≈ x(tn) äquidistant mit Schrittweite h

diskretisiert und wie folgt berechnet:

vn+1/2 = vn +h

2F (tn, xn)

xn+1 = xn + hvn+1/2 (10.16)

vn+1 = vn+1/2 +h

2F (tn+1, xn+1).

Ähnlich wie bei den Runge-Kutta-Verfahren wird also ein Zwischenschritt bei h/2 ein-gelegt, allerdings nur für die Berechnung von vn+1/2 ≈ x′(tn + h/2). Dabei wird dieselbeBeschleunigung F (tn, xn) in aufeinanderfolgenden Zeitschritten zweimal benötigt. In Mo-lekulardynamiksimulationen mit vielen Atomen ist die Berechnung der Kräfte meist rechtteuer, daher speichert man die Kräfte üblicherweise zwischen.

196


Um die Ordnung dieses Verfahrens zu bestimmen, eliminieren wir die Geschwindigkei-ten:

xn+1 = xn + hvn +h2

2F (tn, xn)

= xn + hvn−1/2 + h2F (tn, xn)

= xn + xn − xn−1 + h2F (tn, xn) = 2xn − xn−1 + h2F (tn, xn) (10.17)

Die ist eine finite Differenz gemäß (6.14), für die

xn+1 − 2xn + xn−1

h2= F (tn, xn) +O(h2) (10.18)

gilt. Der Fehler in xn+1 ist also von der Größenordnung O(h4), sofern xn und xn−1 odervn exakt waren. Die Geschwindigkeiten haben offenbar einen Fehler der Ordnung O(h2).Das Velocity-Verlet-Verfahren ist von der Implementation her vergleichbar einfach wie

das Eulerverfahren, aber anders als dieses recht stabil und hat, wie gezeigt, eine sehrgute Konsistenzordnung, vergleichbar mit dem Runge-Kutta-Verfahren. Es hat aber nocheine andere wichtige Eigenschaft: anders als die Runge-Kutta-Verfahren ist das Verfahrensymplektisch, was bedeutet, dass es keine Energiedrift zulässt, und zum anderen besondersgut geeignet ist, in Molekulardynamiksimulationen Observablen über den Phasenraumzu mitteln. Auch das Simulationspaket ESPResSo, mit dem zum Beispiel im vorigenKapitel die Simulationen zum Simulated Annealing durchgeführt wurden, oder das inder Biophysik populäre NAMD [Nam] benutzen daher einen Velocity-Verlet-Integrator.

Beispielimplementation

Eine Python-Implementation des Velocity-Verlet-Verfahrens für x(t) =F[t, x(t)] mitx(0) = x0 und v(0) = v0 könnte wie folgt aussehen:

from numpy import *

def velocity_verlet(acc, x0, v0, tmax, h):def step(acc, tn, xn, vn, h):

vn += 0.5*h*acc(tn, xn)xn += h*vnvn += 0.5*h*acc(tn, xn)

# Startwert und -zeittn = 0.0xn = x0.copy()vn = v0.copy()# Ergebnisvektorresult = [ concatenate(((tn,), xn.copy(), vn.copy())) ]while tn < tmax:

step(acc, tn, xn, vn, h)tn += hresult.append(concatenate(((tn,), xn.copy(), vn.copy())))


197


Genau wie beim Runge-Kutta-Beispiel kann die Lösung x(t) auch vektorwertig sein, wennx0, v0 und der Rückgabewert der Beschleunigungsfunktion F gleichgroße NumPy-Arrayssind. Integriert wird von t = 0 bis tmax in Schritten der Weite h. Die Routine liefertdas Ergebnis als Matrix aus den Zeit- und Lösungspunkten sowie den Geschwindigkeitenzurück. Ein Eintrag hat also die Form

(t(k), x

(k)1 , . . . ,x

(k)n , v

(k)1 , . . . ,v

(k)n

).

Die obige Implementation ist nicht sehr effizient, da die Kraftfunktion in zwei auf-einanderfolgenden Zeitschritten zweimal an der selben Stelle ausgewertet wird, statt dieWerte zwischenzuspeichern.

10.1.4 Beispiel: 3-Körperproblem

Wir betrachten die klassischen Bahnen von Sonne, Erde und Mond unter Vernachläs-sigung anderer Himmelskörper und der nicht ganz korrekten Annahme, dass alle dreiKörper in einer Ebene kreisen. Dieses System hat den Vorteil, dass die Kreisbahn desMondes um die Erde sehr klein gegenüber der Kreisbahn des Erde-Mond-Systems umdie Sonne ist, so dass das Problem sehr unterschiedliche Längenskalen aufweist, die derIntegrator stabil integrieren muss.Zwischen den Objekten mit Positionen ri und Massen mi wirkt die nichtrelativistische

GravitationskraftFij = − Gm1m2

‖ri − rj‖3(ri − rj) (10.19)

mit der Gravitationskonstanten G. Die gesamte Kraft auf ein Objekt berechnet sich als

Fi =∑j 6=i

Fij . (10.20)

Letztere Gleichung gilt natürlich für ein beliebiges Mehrkörperproblem, nur die Paarwech-selwirkungen Fij ändern sich je nach den wirkenden Kräften. Auf molekularer Ebene istdie Gravitation vernachlässigbar, dafür wirken zum Beispiel elektrostatische und van derWaals-Kräfte.Wie eingangs besprochen, ist es sinnvoll, die Einheiten so zu wählen, dass die relevanten

Variablen in der Größenordnung von eins liegen, so dass man von einem Implementations-fehler ausgehen kann, wenn plötzlich sehr große Werte auftreten. In diesem Fall wählenwir als Längeneinheit die astronomische Einheit, die dem mittleren Abstand zwischenSonne und Erde entspricht, und messen Zeiten in Jahren, was in etwa der Umdrehungs-zeit der Erde um die Sonne entspricht. Massen messen wir entsprechend in ErdenmassenmE . In diesem System ist zum Beispiel G = 1,1858 · 10−4AU3m−1

E a−2. Die Sonne hat333.000 Erdenmassen, der Mond wiegt hingegen nur 0,0123mE und befindet sich et-wa 0,00257AU von der Erde entfernt. Das verdeutlicht nochmals die unterschiedlichenSkalen, mit denen der Integrator zurechtkommen muss.Abbildung 10.2 oben zeigt die resultierenden Bahnen der Erde um die Sonne und des

Monds um die Erde für die Dauer von 10 Jahren. Die Schrittweite beträgt ein 1/365-telJahr, also etwa einem Tag, integriert wird mit dem Velocity-Verlet-Verfahren und demRunge-Kutta-Verfahren, die beide vierter Ordnung sind. Beide Verfahren reproduzieren

198


1.0 0.5 0.0 0.5 1.01.0

0.5

0.0

0.5

1.0

0.002 0.000 0.0020.003

0.002

0.001

0.000

0.001

0.002

0.003

0 20 40 60 80 100Jahre

64

62

60

58

56

Ges

amte

nerg

ie

Abbildung 10.2: Oben: Simulierte Bahn der Erde um die Sonne während 10 Jahren (links)und des Monds um die Erde während eines halben Jahres (rechts). Rot gestrichelt sinddie vom Velocity-Verlet-Verfahren berechneten Bahnen, blau gepunktet die des Runge-Kutta-Verfahrens. Rote Sterne bzw. blaue Rauten auf den Erdbahnen bezeichnen Punkteim Abstand von 365 Tagen, also etwa einem Jahr. Aufgrund der kleinen Abstände sinddie Schwankungen in der Mondbahn größer, aber bei beiden Verfahren akzeptabel. Unten:Energien bei einer Rechnung mit größerer Simulationslänge und Zeitschritt. Hier zeigtsich die Symplektizität des Velocity-Verlet-Verfahrens, das die Energie im Mittel erhält,während das Runge-Kutta-Verfahren driftet.

199


die Erd- und auch Mondbahnen recht gut, auch wenn die Mondbahn aufgrund der kleinenAbstände stärkere Schwankungen zeigt. Auf der Erdbahn wurden Punkte im Abstand ei-nes Jahres markiert, die, wie man erwarten würde, dicht beieinander liegen. Für die Qua-lität dieser Kurzzeitbahnen ist der Velocity-Verlet also mit dem Runge-Kutta-Verfahrender gleichen Ordnung vergleichbar.Im unteren Teil ist gezeigt, wie sich die beiden Verfahren verhalten, wenn nicht nur

deutlich länger, sondern auch mit größeren Zeitschritt simuliert wird. Für einen Zeit-schritt von 20 Tagen und einer Länge von 100 Jahren ist der Velocity-Verlet-Integratorüberlegen, denn er zeigt zwar größere Energieschwankungen, erhält aber langfristig diemittlere Energie. Das Runge-Kutta-Verfahren hingegen zeigt eine deutliche Energiedrift,die das System langfristig kollabieren lässt.Man sollte allerdings beachten, dass für beide Integratoren die Mondbahnen vollkom-

men falsch sind, der Mond verlässt sogar seine Erdumlaufbahn! Für astrophysische Simu-lationen ist so etwas natürlich nicht akzeptabel, aber in der Molekulardynamik spielen dieexakten Trajektorien der Moleküle keine Rolle, da sie sowieso nicht gemessen werden kön-nen. Zudem sind molekulare Systeme hochchaotisch, d. h. selbst bei winzigen Störungenweichen Trajektorien nach kurzer Zeit stark ab. In diesem Fall ist die Energieerhaltungdes Velocity-Verlet-Algorithmus sehr wichtig, denn sie garantiert, dass trotzdem das kor-rekte statistische Ensemble simuliert wird und die Messungen sinnvoll sind, selbst wenndie Trajektoren selber nur auf sehr kurzen Zeitabschnitten sinnvoll sind.

10.2 Partielle Differentialgleichungen

Die numerische Lösung von partiellen Differentialgleichungen, also Differentialgleichun-gen in mehreren Variablen, ist erheblich komplexer. Meist werden diese Art von Diffe-rentialgleichungen über Finite-Elemente-Methoden (FEM) gelöst, andere Methoden sindFinite-Volumen-Methoden (FVM) oder die Finite-Differenzen-Methode (FDM). In ei-nigen Fällen können Differentialgleichungen auch durch schnelle Fouriertransformationnumerisch gelöst werden.Das Ziel bei diesen Ansätzen ist immer gleich: die Differentialgleichung soll in eine al-

gebraische Gleichung überführt werden, für die wir ja bereits effiziente Lösungsmethodenkennen.

10.2.1 Finite-Differenzen-Methode — Wärmeleitungsgleichung

Ist das interessante Gebiet Ω hinreichend einfach, reichen die einfachen finite Differenzen,wie wir sie bereits kennengelernt haben, um partielle Differentialgleichungen zu diskreti-sieren. Wir betrachten als Beispiel die Differentialgleichung

δ

δtp(x, t) = D

δ2

δx2p(x, t). (10.21)

Gesucht ist p : Rn × R → R, D ist ein freier Parameter, die Diffusionskonstante. DieseDifferentialgleichung hatten wir in Abschnitt 7.4 als Diffusionsgleichung kennengelernt.Meist wird diese Gleichung aber als Wärmeleitungsgleichung bezeichnet, weil sie auch die

200


10 5 0 5 10x

0.00

0.05

0.10

0.15

0.20p(x,t)

0 10 20 30 40 50 60 70 80t

0.0

0.5

1.0

1.5

2.0

m(t

)

dt=0.010

dt=0.013

dt=0.014

10 5 0 5 10x

0

5

10

15

20

p(x,t)

t=5

t=20

t=80

t=500

0 100 200 300 400 500t

0

20

40

60

80

100

120

140

m(t

)

Abbildung 10.3: Näherungen für die Diffusionsgleichung. Oben die Lösungen zu unter-schiedlichen Zeitpunkten t für eine δ-verteilte Anfangsverteilung (links) und zwei Quellenkonstanter Rate 1 bei 0 und 1/2 bei -5 (rechts). Unten sind die korrespondieren Gesamt-massen angegeben. Für die δ-Verteilung sind die Gesamtmassen auch bei geringfügighöheren Zeitschritten δt angegeben, wobei für δt = 0,014 die Näherung versagt.

Wärmeleitung beschreibt. Auch die zeitabhängige Schrödingergleichung hat diese Form,ist allerdings komplexwertig.Um die Differentialgleichung zu lösen, diskretisieren wir wie gewohnt die Raumkoor-

dinaten äquidistant mit Abstand h, d. h. wir setzen xk = kh und pk(t) = p(xk, t) fürk = 1(1)N . Für die zweite Ableitung kennen wir bereits eine einfache Strategie: wirersetzen sie durch eine finite Differenz auf dem Gitter, etwa (6.14). Das ergibt in einerDimension die ortsdiskretisierte Differentialgleichung

δ

δtpk(t) =

D

h2[pk−1(t)− 2pk(t) + pk+1(t)] . (10.22)

Aus der partiellen Differentialgleichung ist eine gewöhnliche Differentialgleichung in t mitN Variablen p1(t), . . . ,pN (t) geworden, wobei N die Anzahl der Ortspunkte ist. DieseDGL lösen wir nun mit dem Runge-Kutta-Verfahren. Das hat den großen Vorteil, dass

201


wir die Verteilungen pk(t) = p(xk, t), die bei großem N oder mehreren Dimensionen sehrgroß werden können, nur für wenige Zeitschritte speichern müssen.Quellcode 10.1 zeigt den resultierenden Code, der die Runge-Kutta-Implementierung

aus diesem Kapitel nutzt. Wir betrachten dabei nur das Intervall [−10,10], dass wir mitN = 201 Punkten im Abstand h = 0,1 diskretisieren. Der Zeitschritt ist als δt = 0,01gewählt. Am Rand des Ortsintervalls benutzen wir diesmal keine periodischen Randbe-dingungen, sondern setzen die Funktion an den Intervallrändern auf p(−10) = p(10) = 0.Abbildung 10.3 zeigt links die Diffusionsgleichung für D = 1/2 und eine δ-Verteilung

zum Zeitpunkt t = 0, was dem einfachen Random walk aus Abschnitt 7.4 entspricht.In der Diskretisierung wird die δ-Funktion an der Stelle xn dadurch dargestellt, dassp(xn) = 1/h und p(xj) = 0 sonst. Die beobachteten Verteilungen bei t = 5 und t = 80entsprechen gut den entsprechenden Verteilungen in Abbildung 7.6.In der unteren Reihe ist die zugehörige Gesamtmasse∫ 10

−10p(x, t) dx ≈

∑h p(xn, t) (10.23)

aufgetragen. Bei unendlichem Intervall ist die Masse offenbar erhalten. In unserem Fallist die Masse ebenfalls zunächst erhalten und gleich 1, da wir ja mit einer δ-Verteilungbegonnen haben. Sobald die Verteilung am Rand des Intervalls ankommt, verlieren wirdort wegen der Null-Randbedingung Masse.Die Abbildung zeigt auch die (In-)Stabilität dieses Ansatzes. Durch geringfügige Ver-

größerung des Zeitschritts von 0,01 auf 0,014 bei gleichem Gitterabstand wird die Lö-sung nach nicht einmal hundert Schritten instabil und errechnet sogar negative Massen.Welcher Zeitschritt möglich ist, hängt von der Lipschitz-Konstanten des diskretisiertenDifferentialoperators in t ab, die nach (10.22) wie O(1/h2) wächst. Bei Verfeinerung desRaumgitters muss der Zeitschritt also ebenfalls verkleinert werden.Auf der rechten Seite ist die Lösung der Gleichung

δ

δtp(x, t) = D

δ2

δx2p(x, t) +

1

2δ (x+ 6) + δ(x) (10.24)

mit zwei konstanten Teilchenquellen bzw. Heizungen dargestellt. Wir haben also eineQuelle mit einem halben Teilchen pro Zeiteinheit bei −6 und eine zweite bei 0 mit einemTeilchen pro Zeiteinheit. Wie man erwarten würde, nehmen die Verteilungen dabei zu,bis eine stationäre Verteilung erreicht wird.Diese lässt sich sogar analytisch bestimmen. Die stationäre Lösung erfüllt die Poisson-

Gleichung

0 = Dδ2

δx2p(x) +

1

2δ (x+ 6) + δ(x). (10.25)

Die zugehörige homogene Gleichung, die Laplacegleichung, hat im Eindimensionalen Ge-raden als Lösung, die in unserem Fall die δ-Quellen verbinden. Die Steigungen ändernsich wegen der δ-Terme bei −6 um 0,5 und bei 0 um 1. Mit den 0-Randbedingungenbei ±10 lassen sich die Steigungen bestimmen, und damit auch die Masse 137,5 desGleichgewichtszustandes, die in der Simulation gut reproduziert wird.

202


# Waermeleitungsgleichung mittels finiter Differenzen und RK4#############################################################from scipy import *import matplotlib.pyplot as pyplotfrom rk import rk_explicit, rk_klassisch

D = 0.5 # DiffusionskonstanteL = 20.0 # Kantenlaenge SimulationsboxN = 200 # Punkte der Raumdiskretisierungtmax = 80 # Zeitraumdt = 0.01 # Zeitschritt

# Raumdiskretisierung, Laplace mit 0-Randbedingungh = L/NLaplace = zeros((N,N))for i in range(N):

if i > 0: Laplace[i, i-1] = 1.0/h**2Laplace[i, i] = -2.0/h**2if i < N-1: Laplace[i, i+1] = 1.0/h**2

# Startdichte: ein Teilchen in der Mittep0 = zeros(N)p0[N/2] = 1.0/h

# p’ = f(t, p) = D*Laplace pdef f(t, p): return D*dot(Laplace, p)tnpns = rk_explicit(rk_klassisch, f, p0, tmax, dt)

# Umpacken in getrennte Arrays fuer pyplot# Nettomasse gleich mit berechnents, ps, mass = [], [], []for pt in tnpns:

ts.append(pt[0])ps.append(pt[1:])mass.append(sum(pt[1:]))

# Ausgabe#############################################figure = pyplot.figure(figsize=(8,6))x = linspace(-L/2.0, L/2.0, N, endpoint=False)

# links: Verlaufgraph = figure.add_subplot(121)for step in (int(5.0/dt), int(20.0/dt), int(tmax/dt)):

graph.plot(x, ps[step], label=("t=%0.1f" % ts[step]))graph.legend()

# rechts: Massegraph = figure.add_subplot(122)graph.plot(ts, h*array(mass))

pyplot.show()

Listing 10.1: Python-Code zur Wärmeleitungsgleichung. Räumlich ist die Lösung mittelsfiniter Differenzen erster Ordnung diskretisiert, zeitlich wird das Runge-Kutta-Verfahrenbenutzt. Zusätzlich wird der Massenverlust durch die Randbedingungen dargestellt.

203


10.2.2 Finite-Elemente-Methode

Die Finite-Element-Methode (FEM) ist ein Verfahren zur Lösung partieller Differential-gleichungen der Form L ·u = f , wobei L ein linearer Differentialoperator ist, f : Ω→ Rneine feste Funktion und u : Ω→ Rn die gesuchte Lösung.Die FEM beruht auf einer schwachen Formulierung der zu lösenden Differentialglei-

chung. Diese beschreibt u als diejenige, eindeutig bestimmte Funktion, die∫ΩLu · v =

∫Ωf · v ∀v ∈ C∞(Ω,Rn) (10.26)

erfüllt. Schwach nennt man diese Formulierung, weil nur das zu Lu assoziierte Funktionalgleich dem zu f assoziierten Funktional sein soll, so dass die ursprüngliche Gleichung nurnoch fast überall erfüllt ist.Nun wählt man statt der unendlich vielen Testfunktionen aus C∞(Ω,Rn) einen end-

lichdimensionalen Unterraum V , zum Beispiel für n = 1 alle linearen Splines mit gege-benen, endlich vielen Stützpunkten. Sind die Funktionen vp, p = 1(1)N eine Basis diesesUnterraums, dann lässt sich eine Näherungslösung u als Linearkombination in dieser Ba-sis schreiben, u =

∑Np=1 upvp. Da L ein linearer Differentialoperator sein soll, wird aus

(10.26) ein gewöhnliches lineares Gleichungssystem:

∫ΩL

N∑q=1

uqvq

· vP =

N∑q=1

uqApq!

=

∫Ωf · vp = bp ∀p = 1(1)N. (10.27)

Die Koeffizientenapq =

∫ΩLvq · vP (10.28)

undbp =

∫Ωf · vp (10.29)

können wir zum Beispiel durch numerische Integration berechnen und das Gleichungs-system Au = b etwa mit dem SOR-Verfahren lösen.Woher kommt der Name „finite Elemente“? Die FEM wird oft in Ingenieursanwendun-

gen eingesetzt, also im 3-dimensionalen Raum. Dadurch enthält die Basis üblicherweiseviele tausende Testfunktionen. Das bedeutet, dass wir das Koeffizientenintegral (10.28)mehrere Millionen mal auswerten müssten. Um diesen Aufwand drastisch zu reduzieren,macht man sich zu Nutze, dass apq offenbar nur dann nicht verschwindet, wenn sichdie Träger von vp und vq, also die Bereiche, in denen die Funktionen nicht Null sind,überschneiden. Daher wählt man die Basisfunktionen so, dass sie nur sehr kleine Trägerhaben.Eine typische für die Testfunktionen sind lineare Splines. Dabei wird ein beliebiges

Dreiecksgitter über den Bereich Ω gelegt (Triangulierung), und die Testfunktionen alslinear auf diesen Dreiecken angenommen. Als Basis wählt man dann diejenigen Splines,die nur an einem einzigen Stützpunkt ungleich Null sind, kleine Pyramiden sozusagen.

204


10 5 0 5 10x

0

5

10

15

20p(x

)

4 2 0 2 4x

0.00.20.40.60.81.0

v p(x

)

4 2 0 2 4x

1.0

0.5

0.0

0.5

1.0

v′p(x

)Abbildung 10.4: Links: Lösung des stationären Wärmeleitungsproblems mittels derFEM-Methode mit linearen Splines für δ-artige (blaue Rauten) und hütchenförmigeQuellen (rote Kreise). Rechts oben: die verwendeten Splines vp(x) für p = 0 (schwarzdurchgezogen), p = −1 (blau gestrichelt) und p = 1 (rot gestrichelt). Rechts unten: diezugehörigen Ableitungen der Splines.

Dann gibt es nur dann Wechselwirkungen zwischen zwei Basisfunktionen, wenn diese einegemeinsame Kante haben, so dass fast alle Integrale apq = 0 sind, also A dünn besetzt.Als Beispiel wollen wir die stationäre Lösung der eindimensionalen Wärmeleitungsglei-

chung direkt bestimmen, also die Differentialgleichung

Dδ2

δx2p(x) = −q(x) (10.30)

lösen, wobei q(x) = 12 δ (x+ 6) + δ(x) die Wärmequellen aus dem vorherigen Beispiel

sein sollen. Gesucht ist die Lösung im Interval Ω = [−10,10] mit der Randbedingungp(−10) = p(10) = 0. Wir approximieren die Lösung als Summe von linearen Splinesauf einem regulären Gitter der Weite h = 2, d. h. unsere Basisfunktionen sind (vgl.Abbildung 10.4):

vp(x) =

x/h− p− 1 für p− 1 ≤ x/h ≤ pp+ 1− x/h für p ≤ x/h ≤ p+ 1

0 sonst, p = −4(1)4. (10.31)

Dies mag zunächst seltsam erscheinen, da ja die zweite Ableitung einer solchen Funktionfast überall Null ist. Die Antwort ist eine partielle Integration bei der Berechnung derlinksseitigen Koeffizientenmatrix A, durch die die zweite Ableitung verschwindet:

apq =

∫Ωv′′q (x) · vP (x)dx = −

∫Ωv′q(x) · v′p(x) =

−2h für p = q

1h für |p− q| = 1

0 sonst.(10.32)

205


Die Matrix A ist also tridiagonal mit −2/h auf der Diagonalen und 1/h auf den Sub-und Superdiagonalen. Dies ist bis auf einen Faktor h genau die Matrix, die (10.22) fürdas Finite-Differenzen-Verfahren beschreibt.Für die rechte Seite ergibt sich durch Auswerten der beiden δ-Integrale

bp =

∫Ωq(x) · vp(x)dx =

12 für p = −3

1 für p = 0

0 sonst= q(xp), (10.33)

also bis auf einen Faktor h ebenfalls die rechte Seite, die sich auch beim Finite-Differenzen-Verfahren ergeben würde. Daher entspricht die Lösung, wie sie Abbil-dung 10.4 zeigt, auch genau dem Langzeitlimes der FDM-Lösung aus dem letzten Kapitel.Nehmen wir nun an, dass die rechte Seite nicht mehr δ-Quellen sind, sondern zwei

unserer Hutfunktionen der Breite 2h, also q(x) = 12h v−3(x) + 1

hv0(x). Für die FDM-Lösung macht dies keinen Unterschied, da nur die Werte an den Spitze eingehen. Fürden FEM-Löser hingegen müssen wir nun bp neu bestimmen:

bp =

∫Ωq(x) · vp(x)dx =

1

2h

∫Ωvp(x)v−3(x) +

1

h

∫Ωvp(x)v0(x)dx. (10.34)

Eine Hutfunktion trägt dabei nicht nur zu dem Punkt bei, an dem sie liegt, sondern auchzu den benachbarten Punkten, da

∫Ωvq(x) · vp(x) =

23h für p = q16h für |p− q| = 1

0 sonst,(10.35)

die rechte Seite wird also mittels der Hutfunktion geglättet. In unserem Fall ergibt sich

(b−4, . . . ,b4) = (1

12,1

3,

1

12,1

6,2

3,1

6, 0, 0, 0). (10.36)

Die Lösung mit dieser rechten Seite ist an den beiden Quellen tatsächlich etwas „runder“als die Lösung für die δ-Spitzen. Eine FDM hätte diese Feinheit nur mit deutlich feineremGitter reproduzieren können, da sie anders als FEM keine Annahmen über das Verhaltender Funktion zwischen den Stützstellen verarbeiten kann.Um die Genauigkeit einer FEM weiter zu verbessern, können dort zusätzliche Gitter-

punkte eingefügt werden, wo die Funktion vermutlich stark variiert (zum Beispiel in derNähe der Wärmequellen in unserem Beispiel). Auch höhere Splines, zum Beispiel kubi-sche, erhöhen die Genauigkeit, sind allerdings mehrdimensional auf allgemeinen Gitterschwer überhaupt zu definieren. Die Erzeugung solcher komplexer Gitter selber erfor-dert spezielle Software, die oft nicht weniger kompliziert als der eigentliche FEM-Löserist. In der Ingenieurspraxis kommen daher meist sehr leistungsfähige, kommerzielle Soft-warepakete zum Einsatz. Eine freie Alternative ist das Softwarepaket DUNE [Ded+10;Ded+].

206


10.2.3 Lösung mittels Fouriertransformation — Poisson-Gleichung

Die Poisson-Gleichung

∆Φ(x) = ∇ · ∇Φ(x) =ρ(x)

ε(10.37)

spielt auch in der Elektrostatik eine zentrale Rolle, wobei Φ in diesem Fall das Potential,ρ die Ladungsverteilung und ε die dielektrische Konstante ist. Im Kapitel 8 wurde bereitserläutert, dass sich diese Gleichung gut mit Hilfe von finiten Differenzen lösen lässt, unddie Wiedergabe der stationären Lösung aus dem vorigen Abschnitt unterstreicht dies.Wie alle lineare partiellen Differentialgleichungen mit konstanten Koeffizienten, kann

Gleichung (10.37) unter periodischen Randbedingungen einfach in den Fourierraum über-tragen werden, da ja ∇Φ = inωΦ. Zweimalige Anwendung ergibt

−n2ω2Φn =ρnε

(10.38)

wobei Φn und ρn die Fouriertransformierten von Φ und ρ gemäß (3.5.1) sind. Ist x mehr-dimensional, wird entlang jeder Dimension nacheinander transformiert, und n2 entsprichtn ·n = ‖n‖2. Danach muss notwendigerweise ρ0 = 0 gelten, das System also ladungsneu-tral sein. Für die übrigen Frequenzen lässt sich die Poissongleichung nun ganz einfachdurch Φn = −ρn/ε(nω)2 lösen. Um also Φ(x) zu berechnen, transformieren wir eine dis-krete Ladungsverteilung ρ mit Hilfe der FFT in den Fourierraum, lösen dort trivial diePoissongleichung, und transformieren Φ zurück.Dieses Vorgehen spielt eine wichtige Rolle bei den sogenannten Particle-Mesh-Ewald-

Methoden zur Berechnung der Schwerkraft oder elektrostatischer Wechselwirkungen. Die-se werden in Molekulardynamiksimulationen geladener Systeme am häufigsten eingesetzt.Kern dieser Methoden ist, die δ-Spitzen diskreter Punktladungen durch verschmierte,normalverteilte Ladungen zu ersetzen, deren Wechselwirkung mit Hilfe von schnellenFouriertransformationen wie beschrieben im Fourierraum berechnet wird. Mit einer wei-teren, kleinen Korrektur für die Ladungsverschmierung lassen sich so die elektrostatischenWechselwirkungen von Millionen von Teilchen in Bruchteilen von Sekunden auf einemGroßrechner berechnen.Codebeispiel 10.2 zeigt die Lösung im Fourierraum für eine beliebige, zweidimensionale

Ladungsverteilung. In der Praxis ist die Umsetzung des Terms n−2 etwas komplizierter,weil bei der diskreten Fouriertransformation die negativen Koeffizienten ja oberhalb derpositiven gespeichert sind (ρN−n = ρ−n), und zwar in jeder Dimension. Falls N geradeist, ist außerdem ρN/2 = ρ−N/2, so dass man Vorsorge treffen muss, dass dieser Wert nureinmal durch n2 geteilt wird. Dies bedingt die Fallunterscheidungen in der Implementa-tion des Laplace-Operators.Die Ergebnisse stimmen bis auf eine additive Konstante gut mit den Berechnungen

mittels finiter Differenzen überein, wie Abbildung 10.5 zeigt. Die Konstante rührt daher,dass die Lösung im Fourierraum stets eine verschwindende Null-Frequenz hat, also imMittel Null ist. Bei der Finite-Differenzen-Lösung wird hingegen der Wert von Φ an ei-ner Stelle vorgegeben. Abgesehen davon beträgt der maximale Unterschied zwischen den

207


# 2d-Poisson mittels Fourier##############################################from scipy import *from numpy.fft import *import matplotlib.pyplot as pyplot

L=1.0 # Kantenlaenge des QuadratsN=50 # Punkte der Diskretisierung, gerade fuer FFT

h = L/N# rho aufsetzenrho = zeros((N, N))s2 = 0.01 # Quadrat des Radius der Ladung im Zentrumfor i in range(N):

for k in range(N):x, y = k*h, i*hd2 = (x-0.5*L)**2 + (y-0.5*L)**2rho[i, k] += 1/sqrt(2*pi*s2)*exp(-0.5*d2/s2)

# neutralisierenrho -= sum(rho)/N**2

# Loesung per Fouriertransformation##############################################

rho_fft = fft2(rho)# Laplace-Operator (2 pi/n L)^2for nx in range(N/2 + 1):

for ny in range(N/2+1):if nx == 0 and ny == 0:

rho_fft[nx,ny] = 0else:

n2 = (nx**2 + ny**2)*(2*pi/L)**2rho_fft[ nx, ny] /= n2if nx > 0 and nx < N/2:

rho_fft[N-nx, ny] /= n2if ny > 0 and ny < N/2:

rho_fft[ nx, N-ny] /= n2if nx > 0 and ny > 0 and nx < N/2 and ny < N/2:

rho_fft[N-nx, N-ny] /= n2psi_fft = ifft2(rho_fft)psi_fft = real(psi_fft)

# Ausgabe#############################################

im = pyplot.imshow(psi_fft, interpolation="bilinear", origin="lower",extent=(0,L,0,L))

pyplot.colorbar(im)pyplot.show()

Listing 10.2: Lösung der Poisson-Gleichung im Fourierraum für ε = 1.

208


0.0 0.2 0.4 0.6 0.8 1.00.0

0.2

0.4

0.6

0.8

1.0

3.22.41.60.8

0.00.81.62.43.2

0.0 0.2 0.4 0.6 0.8 1.00.0

0.2

0.4

0.6

0.8

1.0

0.0 0.2 0.4 0.6 0.8 1.00.0

0.2

0.4

0.6

0.8

1.0

0.0 0.2 0.4 0.6 0.8 1.00.0

0.2

0.4

0.6

0.8

1.0

0.000000.000250.000500.000750.001000.001250.001500.001750.00200

Abbildung 10.5: Näherungslösung mit 50 × 50 Gitterpunkten für die Poissongleichung∆Φ = ρ in freien Einheiten. Die Ladungsdichte ρ ist rechts oben gezeigt und beinhaltetzwei normalverteilte Ladungen. Die Lösungen ΦFD mit finiten Differenzen (links oben)und ΦFFT im Fourierraum mittels FFT (links unten) sind praktisch identisch. Dies zeigtauch der relative Fehler |ΦFD − ΦFFT| / |ΦFFT| (rechts unten), der weniger als 2 Promillebeträgt.

209


Lösungen weniger als 2 Promille, und zwar genau auf den Ladungen. Ist die Ladungs-verteilung nicht glatt, so ist der Fehler größer, da die Fouriertransformation unstetigerFunktionen ja nur langsam konvergiert.

10.2.4 Lösung der Poisson-Boltzmann-Gleichung

Als letztes Beispiel wollen wir eine wichtige Erweiterung der Poisson-Gleichung lösen,die Poisson-Boltzmann-Gleichung. Für die Herleitung dieser Gleichung nehmen wir an,dass neben der fixen Ladungsverteilung ρfix(x) noch ein gelöstes Salz aus einwertigen,punktförmigen Ionen im System ist. Das Salz kann sich frei in einem Bereich Ω bewegen.Dieser wird durch die charakteristische Funktion χ(x) charakterisiert, die für x ∈ Ω denWert 1 annimmt, und sonst 0 ist. Die räumliche Verteilung dieser Ionen im Gleichgewichtist durch die Boltzmannverteilung gegeben, also proportional zu e−qβΦ(x), wobei β = kBTmit der Boltzmann-Konstanten kB und Temperatur T . q ist dabei die Ladung der Ionen,hier eine negative oder positive Elementarladung. Die Einschränkung auf monovalenteIonen hat einen guten Grund: für mehrwertige Salze kann man zeigen, dass die Poisson-Boltzmann-Gleichung keine gute Näherung ist.Das Potential erscheint also auch in der Verteilung der Ionen, so dass wir eine nichtli-

neare Differentialgleichung erhalten:

ε∆Φ(x) = −ρfix − c∞

qe e−βqeΦ(x)︸︷︷︸positive Ionen

−qe eβqeΦ(x)︸︷︷︸negative Ionen

χ(x)

= −ρfix − 2c∞ sinh[−βqΦ(x)]χ(x). (10.39)

c∞ ist dabei die Konzentration der Ionen weit von allen Ladungen entfernt, also dort, woΦ = 0. qe bezeichnet hier die Elementarladung, um einer Verwechslung mit der EulerschenKonstanten vorzubeugen. Durch die Multiplikation mit χ(x) befinden sich die Ionen nurim zulässigen Bereich, unabhängig vom Potential.Die Gleichung lässt sich etwas einfacher darstellen, wenn man die sogenannte Bjerr-

umlänge

lB =q2e

4πεkBT(10.40)

einführt, und die dimensionslose Funktion ψ = βqeΦ sucht, für die dann

1

4πlB∆ψ(x) = −qfix − 2c∞ sinh[−ψ(x)]χ(x) (10.41)

gilt, wobei qfix = ρfix/qe die feste Ladungsverteilung in Elementarladungen angibt. lB isteine Konstante, die das umgebende Medium beschreibt. Üblicherweise ist dieses Wasser,für dass die Bjerrumlänge 0,7nm beträgt.Die Poisson-Boltzmann-Gleichung wird zum Beispiel benutzt, um die Ladungsvertei-

lung um makroskopische Ionen wie kolloidale Teilchen zu modellieren. Dadurch muss diesehr große Menge an Salzionen nicht explizit modelliert werden, was die Zahl der Teilchenin Grenzen hält. In der Biophysik wird die Poisson-Boltzmann-Verteilung auch gerne zurVisualisierung der Ladungsverteilung von Proteinen benutzt.

210


0.0 0.5 1.0 1.5 2.00.0

0.5

1.0

1.5

2.0

2-

++0.00.10.20.30.40.50.60.70.80.91.0

0.0 0.5 1.0 1.5 2.00.0

0.5

1.0

1.5

2.0

2-

++0.00.10.20.30.40.50.60.70.80.91.0

0.0 0.5 1.0 1.5 2.00.0

0.5

1.0

1.5

2.0

1.51.00.5

0.00.51.01.52.02.5

0.0 0.5 1.0 1.5 2.05432101

0.0 0.5 1.0 1.5 2.00.00.20.40.60.81.01.21.41.61.8

Abbildung 10.6: Näherungslösung der Poisson-Boltzmann-Gleichung (10.41) mittels ite-rativer Lösung des diskretisierten Gleichungssystems. Die Ladungsdichte konvergiert in-nerhalb von zwanzig Schritten zu einer Genauigkeit von 10−2. Links oben ist die resul-tierende Verteilung der negativen Ionen gezeigt, rechts oben der positiven Ionen. Da dieIonen in die Bereiche der fixen Ladungen nicht eindringen können, ist dort die Ladungs-dichte 0. Der ausgefranste Rand dieser Bereiche ist eine Folge der groben Diskretisierung.Unten links ist das resultierende Potential dargestellt, rechts unten die Potentialverläufedes Poisson-Boltzmann-Potentials (rot gestrichelt) und des reinen elektrostatischen Po-tentials (durchgezogen). Der obere der beiden Graphen zeigt ψ(1,y), der untere ψ(x, 1/2).

211


Ist das Potential relativ flach, lässt sich die Poisson-Boltzmann-Gleichung mittelssinh(ψ) ≈ ψ linearisieren und in manchen Geometrien analytisch lösen. Die volle, nicht-lineare Poisson-Boltzmann-Gleichung muss aber numerisch gelöst werden. Dazu diskre-tisieren wir ψ wieder äquidistant in beiden Raumrichtungen, und ersetzen den Laplace-Operator durch eine finite Differenz. Im Prinzip könnten wir nun das Gleichungssystemmit Hilfe des Newtonverfahrens lösen, einfach ist aber die iterative Lösung mittels

ψ(n+1)(x) = −∆−1

4πlBqfix + 2c∞ sinh[−ψ(n)(x)]χ(x). (10.42)

Dabei wird natürlich nicht die Inverse des diskretisierten Laplace-Operators berechnet,sondern das Gleichungssystem gelöst. Da dies in jeder Iteration geschehen muss, berech-net man sinnvollerweise eine LR-Berechnung voraus, und benutzt in den Iterationen nureine schnelle Vorwärts- und Rückwärtssubstitution.Listing 10.3 zeigt eine Implementation dieses iterativen Poisson-Boltzmann-Lösers, Ab-

bildung 10.6 die Lösung für ein sehr einfaches System aus drei homogenen Ladungsschei-ben in zwei Dimensionen (bzw. drei geladenen, unendlich langen Stäben). Die Scheibeoben hat eine Gesamtladung von 2 Elementarladungen, die beiden unteren jeweils eineElementarladung. Das Salz ist 0,2-molar, die Längeneinheit entspricht einen Nanometer,die Bjerrumlänge ist für Wasser gewählt, also 0,7nm. Wie erwartet finden sich die nega-tiven Ionen bevorzugt in der Umgebung der beiden positiven Kugeln unten, die positivenIonen hingegen bei der größeren, negativen Kugel oben. In diesem Beispiel konvergiertdie Iteration in etwa zwanzig Schritten auf 10−2 Genauigkeit in der Ladungsverteilung.Rechts unten zeigt Abbildung 10.6 schließlich zwei Schnitte durch das elektrostatische

Potential. Dies wurde einmal nur für die fixen Ladungen berechnet, und einmal für diePoisson-Boltzmann-Lösung. Deutlich sichtbar ist, dass diese flacher ist als die das reineelektrostatische Potential. Dies ist einfach zu verstehen, da die Ionen sich ja bevorzugtum die entgegengesetzt geladenen Bereiche anlagern, und diese dadurch gegeneinanderabschirmen.Obwohl im Beispiel die Auswirkungen auf das Potential scheinbar nur gering sind,

ist das Poisson-Boltzmann-Potential sehr verschieden vom klassischen elektrostatischenPotential. Um dies zu zeigen, betrachten wir eine einzelne Punktladung. Dann ist dasPotential ψ radialsymmetrisch und erfüllt fern von der Ladung

∆ψ(r) =∂2

∂r2ψ(r) +

2

r

∂

∂rψ(r) = −8πlBc∞ sinh[−ψ(r)] ≈ 8πlBc∞ψ(r), (10.43)

wobei wir für die letzte Näherung annehmen müssen, dass ψ bereits hinreichend starkabgefallen ist. Diese Gleichung, die sogenannte Debye-Hückel-Näherung, ist schließlichanalytisch lösbar und hat die Lösung ψ(r) = e−κr/r mit κ =

√8πlBc∞, wie man sich

leicht überzeugt. Das Coulomb-Potential ist also exponentiell gedämpft, wobei die cha-rakteristische Länge der Dämpfung κ−1 ist. Für eine 0,1-molare Salzlösung (was in etwadem Zellplasma entspricht) beträgt sie nur etwa 1nm, d. h. es gibt praktisch keine elek-trostatischen Wechselwirkungen über Distanzen größer als ein Nanometer.

212


# Einfacher iterativer Poisson-Boltzmann-Loeser##############################################from scipy import *from scipy.linalg import *import matplotlib.pyplot as pyplot

L = 5.0 # Kantenlaenge des QuadratsN = 50 # Punkte der Diskretisierunglb = 0.7 # Bjerrumlaengecinf = 1e-3 # Salzkonzentration am Rand, 1-mmolartol = 1e-2 # maximales Residuumh = L/N # Schrittweite

# Fortran/NumPy-artige Indizierungdef linindex(x, y): return y + N*x# Fixes rho und zugaenglichen Bereich aufsetzen.# Ueberall dort, wo feste Ladung sitzt, geht es nicht hinrho_fix, chi = zeros(N*N), zeros(N*N)r = 0.1 # Radius der fixen Ladung im Zentrumfor i in range(N):

for k in range(N):x, y = k*h, i*hd = sqrt((x-0.5*L)**2 + (y-0.5*L)**2)if d <= r: rho_fix[linindex(i, k)] += 2/pi/r**2chi[linindex(i,k)] = (rho_fix[linindex(i,k)] == 0.0)

# 2d-Laplace, 0-Rand (Neutral am Rand)Laplace=zeros((N*N, N*N))for y in range(N):

for x in range(N):eqn = linindex(x,y)Laplace[eqn, linindex(x,y)] = -4/h**2if x < N-1: Laplace[eqn, linindex(x+1,y)] = 1/h**2if x > 0: Laplace[eqn, linindex(x-1,y)] = 1/h**2if y < N-1: Laplace[eqn, linindex(x,y+1)] = 1/h**2if y > 0: Laplace[eqn, linindex(x,y-1)] = 1/h**2

# Iterativer Loeser##############################################psi = zeros(N*N) # Potentiallu = lu_factor(Laplace)while True:

# aktuelle vollstaendige Ladungsdichterho = rho_fix + cinf*2*sinh(-psi)*chiresidual = dot(Laplace, psi)/(4*pi*lb) + rhoprint "Residuum ist", norm(residual)if norm(residual) < tol: breakpsi = lu_solve(lu, -4*pi*lb*rho)

# Ausgabe der resultierende positiven Ionendichten = (cinf*exp(-psi)*chi).reshape((N,N))im = pyplot.imshow(n, origin="lower", extent=(0,L,0,L))pyplot.colorbar(im)pyplot.show()

Listing 10.3: Python-Code zur Poisson-Boltzmann-Gleichung. Die Lösung wird räumlichmittels finiter Differenzen erster Ordnung diskretisiert und anschließend durch Bestim-men des Potentials aus der aktuellen Ladungsdichte iterativ bestimmt.

213

Literatur

[AS70] M. Abramowitz und I. Stegun. Handbook of mathematical functions. NewYork: Dover Publications Inc., 1970.

[Dau92] Ingrid Daubechies. Ten lectures on wavelets. Bd. 61. Society for IndustrialMathematics, 1992.

[Ded+] A. Dedner u. a. DUNE-FEM homepage.http://dune.mathematik.uni-freiburg.de.

[Ded+10] A. Dedner u. a. „A Generic Interface for Parallel and Adaptive ScientificComputing: Abstraction Principles and the DUNE-FEM Module“. In:Computing 90.3–4 (2010), S. 165–196.

[Esp] ESPResSo homepage. url: http://espressomd.org.

[FD09] L. Filion und M. Dijkstra. „Prediction of binary hard-sphere crystalstructures“. In: Physical Review E 79.4 (2009), S. 046714.

[GM78] P.E. Gill und W. Murray. „Numerically stable methods for quadraticprogramming“. In: Mathematical Programming 14.1 (1978), S. 349–372.

[Jac99] J. D. Jackson. Classical Electrodynamics. Wiley, New York, 3rd edition,1999.

[Jan02] Wolfhard Janke. „Statistical Analysis of Simulations: Data Correlations andError Estimation“. In: Quantum Simulations of Complex Many-BodySystems: From Theory to Algorithms. Hrsg. von J. Grotendorst, D. Marxund A. Muramatsu. Bd. 10. NIC series. John von Neumann Institute forComputing, Jülich, 2002, S. 423–445. url: http://www.fz-juelich.de/nic-series/volume10/volume10.html.

[Knu81] D.E. Knuth. The Art of Programming, vol. 2, Semi-Numerical Algorithms.Addison Wesley, Reading, MA, 1981.

[Nam] NAMD homepage. url: http://www.ks.uiuc.edu/Research/namd.

[Pin02] Mark Pinsky. Introduction to Fourier Analysis and Wavelets. Brooks/Cole,2002.

[Vmd] VMD homepage. url: http://www.ks.uiuc.edu/Research/vmd.

215

http://espressomd.org

http://www.fz-juelich.de/nic-series/volume10/volume10.html

http://www.fz-juelich.de/nic-series/volume10/volume10.html

http://www.ks.uiuc.edu/Research/namd

http://www.ks.uiuc.edu/Research/vmd

Index

Symbolsχ2-Test . . . . . . . . . . . . . . . . . . . . . . . . . . . 122

AAbtasttheorem . . . . . . . . . . . . . . . . . . . . . 52Armijo-Schrittweite . . . . . . . . . . . . . . . 165Ausgleichsrechnung . . . . . . . . . . . . . . . . 66Autokorrelationsfunktion . . . . . . . . . . . 59Autokorrelationstest . . . . . . . . . . . . . . 126

BBanachscher Fixpunktsatz . . . . . . . . . 72Bandmatrizen . . . . . . . . . . . . . . . . . . . . . . 23Binning . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64Bisektion . . . . . . . . . . . . . . . . . . . . . . . . . . 78Bisektionsverfahren . . . . . . . . . . . . . . . . 78Box-Muller-Verfahren . . . . . . . . . . . . . 120Butcher-Tableau . . . . . . . . . . . . . . . . . . 191

CCG-Verfahren . . . . . . . . . . . . . . . . . . . . . 167Chebyshev-Stützstellen . . . . . . . . . . . . . 32Cholesky

-Verfahren . . . . . . . . . . . . . . . . . . . . . 22-Zerlegung . . . . . . . . . . . . . . . . . . . . . 22

DDFT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39Diagonalmatrizen . . . . . . . . . . . . . . . . . . 17Differentialgleichung . . . . . . . . . . . . . . 189

explizite . . . . . . . . . . . . . . . . . . . . . . 189gewöhnliche . . . . . . . . . . . . . . . . . . . 189partielle . . . . . . . . . . . . . . . . . . . . . . 200

Differenzieren . . . . . . . . . . . . . . . . . . . . . . 83Diffusionsgleichung . . . . . . . . . . . . . . . . 200Diskrepanz . . . . . . . . . . . . . . . . . . . . . . . . 106

Dreibandmatrizen . . . . . . . . . . . . . . . . . . 23Dreiecksmatrizen . . . . . . . . . . . . . . . . . . . 17

EEigenvektor . . . . . . . . . . . . . . . . . . . . . . . 155Eigenwert . . . . . . . . . . . . . . . . . . . . . . . . . 155Euler-McLaurin-Summenformel . . . . 96Eulerverfahren

explizites . . . . . . . . . . . . . . . . . . . . . 192implizites . . . . . . . . . . . . . . . . . . . . . 192

Extrapolation . . . . . . . . . . . . . . . . . . . . . . 28

FFadenpendel . . . . . . . . . . . . . . . . . . . . . . . 10Faltung . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52FDM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200FEM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204FFT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42Fibonaccigenerator . . . . . . . . . . . . . . . . 114

verzögerter . . . . . . . . . . . . . . . . . . . 114Filter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53Finite-Differenzen-Methode . . . . . . . 200Finite-Elemente-Methode . . . . . . . . . 204Fitting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66Fixpunktsuche . . . . . . . . . . . . . . . . . . . . . 71Fourierreihen

komplexe . . . . . . . . . . . . . . . . . . . . . . 35reelle . . . . . . . . . . . . . . . . . . . . . . . . . . 37

Fouriertest . . . . . . . . . . . . . . . . . . . . . . . . 125Fouriertransformation

diskrete . . . . . . . . . . . . . . . . . . . . . . . . 39komplexe . . . . . . . . . . . . . . . . . . . . . . 35kontinuierliche . . . . . . . . . . . . . . . . . 47reelle . . . . . . . . . . . . . . . . . . . . . . . . . . 37schnelle . . . . . . . . . . . . . . . . . . . . . . . . 42

217

Index

GGauß-Quadratur . . . . . . . . . . . . . . . . . . 100Gauß-Seidel-Verfahren . . . . . . . . . . . . 141Gaußelimination . . . . . . . . . . . . . . . . . . . 18Givens-Rotation . . . . . . . . . . . . . . . . . . 152Glättung . . . . . . . . . . . . . . . . . . . . . . . . . . . 53Gleichungssysteme

lineare . . . . . . . . . . . . . . . . . . . . 17, 137nichtlineare . . . . . . . . . . . . . . . . . . . . 81

Gradientenabstiegsverfahren . . . . . . 165Gram-Schmidt-Verfahren . . . . . . . . . . 144

modifiziertes . . . . . . . . . . . . . . . . . . 147

HHalton-Folge . . . . . . . . . . . . . . . . . . . . . . 107Horner-Schema . . . . . . . . . . . . . . . . . . . . . 25Householder-Spiegelung . . . . . . . . . . . 148Householder-Verfahren . . . . . . . . . . . . 148

IIndexformat . . . . . . . . . . . . . . . . . . . . . . 140indizierte Matrixspeicherung . . . . . . 140Integration

Gauß-Quadratur . . . . . . . . . . . . . . 100Mittelpunktsregel . . . . . . . . . . 93, 94Monte-Carlo- . . . . . . . . . . . . . . . . . 104Newton-Cotes-Formeln . . . . . 91, 93numerische . . . . . . . . . . . . . . . . . . . . . 88Quasi-Monte-Carlo- . . . . . . . . . . . 106Rechteckregel . . . . . . . . . . . . . . . . . . 92Romberg- . . . . . . . . . . . . . . . . . . . . . . 96Simpsonregel . . . . . . . . . . . . . . . 92, 94Trapezregel . . . . . . . . . . . . . . . . 91, 93

Interpolation . . . . . . . . . . . . . . . . . . . . . . . 27Lagrange- . . . . . . . . . . . . . . . . . . . . . . 27lineare . . . . . . . . . . . . . . . . . . . . . . . . . 32Polynom- . . . . . . . . . . . . . . . . . . . . . . 27Spline- . . . . . . . . . . . . . . . . . . . . . . . . . 32

interpolierendes Polynombaryzentrische Darstellung . . . . . 30Lagrangedarstellung . . . . . . . . . . . 29Newtonsche Darstellung . . . . . . . . 31

inverse Iteration . . . . . . . . . . . . . . . . . . 159Inversionsmethode . . . . . . . . . . . . . . . . 118

JJacobimatrix . . . . . . . . . . . . . . . . . . . . . . . 81Jacobiverfahren . . . . . . . . . . . . . . . . . . . 139

KKongruenzgenerator

linearer . . . . . . . . . . . . . . . . . . . . . . . 112konjugierter Gradient . . . . . . . . . . . . . 167Korrelationsanalyse . . . . . . . . . . . . . . . . 55Korrelationszeit . . . . . . . . . . . . . . . . . . . . 59

integrierte . . . . . . . . . . . . . . . . . . . . . 63Kreuzkorrelationsfunktion . . . . . . . . . . 56

LLösung partieller DGLs

FDM . . . . . . . . . . . . . . . . . . . . . . . . . 200FEM . . . . . . . . . . . . . . . . . . . . . . . . . 204mittels Fouriertransformation . 207

Lagrangepolynome . . . . . . . . . . . . . . . . . 29LDU-Zerlegung . . . . . . . . . . . . . . . . . . . . 22Legendrepolynome . . . . . . . . . . . . . . . . 101lineare Regression . . . . . . . . . . . . . . . . . . 67lineares Programm . . . . . . . . . . . 162, 173Lotka-Volterra-Gleichungen . . . . . . . 194LR-Zerlegung . . . . . . . . . . . . . . . . . . . . . . 21LU-Zerlegung . . . . . . . . . . . . . . . . . . . . . . 21

MMatrixinversion . . . . . . . . . . . . . . . . . . . . 20Mehrkörperproblem . . . . . . . . . . . . . . . 198Messfehler . . . . . . . . . . . . . . . . . . . . . . . . . 61Methode der kleinsten Quadrate . . . 66Metropolis-Methode . . . . . . . . . . . . . . 184Mittelpunktsregel . . . . . . . . . . . . . . . . . . 93

zusammengesetzte . . . . . . . . . . . . . 94Monte-Carlo-Integration . . . . . . . . . . 104Monte-Carlo-Sampling . . . . . . . . . . . . 184Moore-Penrose-Inverse . . . . . . . . . . . . 162Multiskalenanalyse . . . . . . . . . . . . . . . . . 43

NNeville-Aitken-Schema . . . . . . . . . . . . . 30Newton-Cotes-Formeln . . . . . . . . . . . . . 91

geschlossene . . . . . . . . . . . . . . . . . . . 92offene . . . . . . . . . . . . . . . . . . . . . . . . . . 92

218

Index

zusammengesetzte . . . . . . . . . . . . . 93Newtonverfahren . . . . . . . . . . . . . . . . . . . 74

gedämpftes . . . . . . . . . . . . . . . . . . . . 82in mehreren Dimensionen . . . . . . 81

Nullstellensuche . . . . . . . . . . . . . . . . 71, 74numerische Integration . . . . . . . . . . . . . 88Nyquist-Frequenz . . . . . . . . . . . . . . . . . . 41

OOptimierung . . . . . . . . . . . . . . . . . . . . . . 161

globale . . . . . . . . . . . . . . . . . . . . . . . 178lokale . . . . . . . . . . . . . . . . . . . . . . . . . 164nichtlineare . . . . . . . . . . . . . . . . . . . 164

Orthogonalisierung . . . . . . . . . . . . . . . . 144

PParsevaltheorem . . . . . . . . . . . . . . . . . . . 36

kontinuierliches . . . . . . . . . . . . . . . . 48Penalty function . . . . . . . . . . . . . . . . . . 170Perkolation . . . . . . . . . . . . . . . . . . . . . . . 132Pivotwahl . . . . . . . . . . . . . . . . . . . . . . . . . . 20Poisson-Boltzmann-Gleichung . . . . . 210Poisson-Gleichung . . . . . . . . . . . . . . . . . 207Polynomapproximation . . . . . . . . . . . 176Pseudoinverse . . . . . . . . . . . . . . . . . . . . . 162Pseudozufallszahlen . . . . . . . . . . . . . . . 111

Qualitätsanalyse . . . . . . . . . . . . . . 121

QQR-Algorithmus . . . . . . . . . . . . . . . . . . 157QR-Zerlegung . . . . . . . . . . . . . . . . . . . . . 144Quadrattest . . . . . . . . . . . . . . . . . . . . . . . 124Quadratur . . . . . . . . . . . . . . . . . . . . . . . . . 88Quasi-Monte-Carlo-Integration . . . . 106Quasizufallszahlen . . . . . . . . . . . . . . . . 107

RRandom walk . . . . . . . . . . . . . . . . . . . . . 126

kontinuierlicher . . . . . . . . . . . . . . . 129Rechteckregel . . . . . . . . . . . . . . . . . . . . . . 92Regula falsi . . . . . . . . . . . . . . . . . . . . . . . . 79Rejection sampling . . . . . . . . . . . . . . . . 116Relaxationsverfahren . . . . . . . . . . . . . . 142Richardson-Extrapolation . . . . . . . . . . 97Romberg-Integration . . . . . . . . . . . . . . . 96

Rosenbrockfunktion . . . . . . . . . . . . . . . 167Runge-Kutta-Verfahren . . . . . . . . . . . 190

4. Ordnung . . . . . . . . . . . . . . . . . . . 192explizite . . . . . . . . . . . . . . . . . . . . . . 191

SSchrödingergleichung . . . . . . . . . . . . . . 200Schrittweitensteuerung . . . . . . . . . . . . 165schwache Formulierung . . . . . . . . . . . . 204Seed . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113Sekantenmethode . . . . . . . . . . . . . . . . . . 77Simplexalgorithmus . . . . . . . . . . . . . . . 173Simpsonregel . . . . . . . . . . . . . . . . . . . . . . . 92

zusammengesetzte . . . . . . . . . . . . . 94Simulated annealing . . . . . . . . . . . . . . 183SOR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142Spektraltest . . . . . . . . . . . . . . . . . . . . . . . 125Spline . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

kubisch . . . . . . . . . . . . . . . . . . . . . . . . 33natürlich . . . . . . . . . . . . . . . . . . . . . . . 33

Standardzufallszahl . . . . . . . . . . . . . . . 115Straffunktion . . . . . . . . . . . . . . . . . . . . . 170strikt diagonaldominant . . . . . . . . . . . 139Successive over-relaxation . . . . . . . . . 142sukzessive Substitution . . . . . . . . . . . . . 71

TTaylorreihe . . . . . . . . . . . . . . . . . . . . . . . . . 26Trapezregel . . . . . . . . . . . . . . . . . . . . . . . . 91

zusammengesetzte . . . . . . . . . . . . . 93

VVektoriteration . . . . . . . . . . . . . . . . . . . 155Velocity-Verlet-Verfahren . . . . . . . . . 196Verfahren des steilsten Abstiegs . . . 165Verwerfungsmethode . . . . . . . . . . . . . . 116

WWärmeleitungsgleichung . . . . . . . . . . 200Würfeltest . . . . . . . . . . . . . . . . . . . . . . . . 124Wavelets . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

-transformation . . . . . . . . . . . . . . . . 45

Zzeitinvariante lineare Systeme . . . . . . 55

219

Index

Zufallszahlen . . . . . . . . . . . . . . . . . . . . . . 111echte . . . . . . . . . . . . . . . . . . . . . . . . . 111Pseudo- . . . . . . . . . . . . . . . . . . . . . . . 111

Zufallszahlengeneratoren . . . . . . . . . . 112

220

vorlesung physik auf dem computer - icpwikiicp/mediawiki/images/archive/b/bb/... · dies ist das...

Documents