Wissenschaftliches Rechnen mit MATLAB 3540250050, 9783540250050

Citation preview

Springer-Lehrbuch

Alfio Quarteroni · Fausto Saleri

Wissenschaftliches Rechnen mit MATLAB Übersetzt von Klaus Sapelza

Mit 69 Abbildungen

123

Alfio Quarteroni

Fausto Saleri

École Polytechnique Fédérale Lausanne 1015 Lausanne, Schweiz und Politecnico di Milano, MOX 20133 Milano, Italien e-mail: alfio.quarteroni@epfl.ch

Politecnico di Milano, MOX Via Bonardi 9 20133 Milano, Italien e-mail: [email protected]

Übersetzer: Klaus Sapelza e-mail: klaus.sapelza@epfl.ch

Umschlagabbildung von Marzio Sala Die italienische Originalausgabe erschien 2004 im Springer-Verlag Italia, Milano, unter dem Titel „Introduzione al Calcolo Scientifico“, 2a edizione (ISBN 88-470-0256-7).

Bibliografische Information der Deutschen Bibliothek Die Deutsche Bibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über http://dnb.ddb.de abrufbar.

Mathematics Subject Classification (2000): 65-01, 68U01, 68N15

ISBN-10 3-540-25005-0 Springer Berlin Heidelberg New York ISBN-13 978-3-540-25005-0 Springer Berlin Heidelberg New York Dieses Werk ist urheberrechtlich geschützt. Die dadurch begründeten Rechte, insbesondere die der Übersetzung, des Nachdrucks, des Vortrags, der Entnahme von Abbildungen und Tabellen, der Funksendung, der Mikroverfilmung oder der Vervielfältigung auf anderen Wegen und der Speicherung in Datenverarbeitungsanlagen, bleiben, auch bei nur auszugsweiser Verwertung, vorbehalten. Eine Vervielfältigung dieses Werkes oder von Teilen dieses Werkes ist auch im Einzelfall nur in den Grenzen der gesetzlichen Bestimmungen des Urheberrechtsgesetzes der Bundesrepublik Deutschland vom 9. September 1965 in der jeweils geltenden Fassung zulässig. Sie ist grundsätzlich vergütungspflichtig. Zuwiderhandlungen unterliegen den Strafbestimmungen des Urheberrechtsgesetzes. Springer ist ein Unternehmen von Springer Science+Business Media springer.de © Springer-Verlag Berlin Heidelberg 2006 Printed in Germany Die Wiedergabe von Gebrauchsnamen, Handelsnamen, Warenbezeichnungen usw. in diesem Werk berechtigt auch ohne besondere Kennzeichnung nicht zu der Annahme, daß solche Namen im Sinne der Warenzeichen- und Markenschutz-Gesetzgebung als frei zu betrachten wären und daher von jedermann benutzt werden dürften. Satz: Datenerstellung durch den Übersetzer unter Verwendung eines Springer TEX-Makropakets Herstellung: LE-TEX Jelonek, Schmidt & Vöckler GbR, Leipzig Einbandgestaltung: design & production GmbH, Heidelberg Gedruckt auf säurefreiem Papier

46/3142YL - 5 4 3 2 1 0

Vorwort

Dieses Buch ist eine Einf¨ uhrung ins Wissenschaftliche Rechnen. Wir werden verschiedene numerische Methoden f¨ ur die rechnergest¨ utzte L¨osung bestimmter mathematischer Probleme, die nicht mit Papier und Bleistift gel¨ost werden k¨onnen, vorstellen. Wir werden zeigen, wie man mit Hilfe des Computers Nullstellen und Integrale stetiger Funktionen berechnet, lineare Gleichungssysteme l¨ ost, Funktionen durch Polynome approximiert, aber auch genaue Ann¨ aherungen an die L¨osung von gew¨ohnlichen Differentialgleichungen und Grenzwertproblemen findet. Zu diesem Zweck werden wir in Kapitel 1 die wichtigsten Spielregeln vorstellen, nach denen Computer reelle und komplexe Zahlen, Vektoren und Matrizen speichern und wie sie mit ihnen operieren. Um unsere Darstellung attraktiv und praxisnah zu gestalten, wird uns die Programmiersprache MATLAB
1 stets ein treuer Begleiter sein. Schrittweise werden wir deren wichtigste Befehle und Konstrukte kennenlernen. Wir werden zeigen, wie man die in den verschiedenen Kapiteln vorgestellten Algorithmen am Rechner umsetzt. Dadurch k¨onnen wir sofort eine quantitative“ Aussage zu deren theoretischen Eigen” schaften wie etwa Stabilit¨ at, Genauigkeit und Komplexit¨at treffen. Wir werden außerdem in der Lage sein, am Computer zahlreiche Probleme ¨ aus Beispielen und Ubungsaufgaben zu l¨ osen, oft mit Ursprung in einer konkreten Anwendung. Um das Lesen zu erleichtern, verwenden wir einige graphische Hilfsmittel.2 In jener Zeile etwa, wo uns ein MATLAB-Befehl zum ersten Mal begegnet, geben wir ihn am Rand noch einmal an. Weiters verwenden wir das Symbol 1

2

¨ , um Ubungsaufgaben zu kennzeichnen, das Symbol

MATLAB ist ein eingetragenes Warenzeichen von The MathWorks, Inc., 3 Apple Hill Drive, Natick, MA 01760, Tel: +1-508-647-7000, Fax: +1-508647-7001. F¨ ur die verwendeten Symbole siehe http://www.iconarchive.com/.

VI

Vorwort

, um ein MATLAB-Progamm anzuk¨ undigen, und das Symbol , um die Aufmerksamkeit auf ein kritisches oder u ¨berraschendes Verhalten eines Algorithmus oder einer Vorgehensweise zu lenken. Besonders wichtige Formeln sind eingerahmt. Schließlich kennzeichnet das Symbol eine Zusammenfassung der wichtigsten, im vorangegangenen Abschnitt vorgestellten Konzepte und Schlußfolgerungen. Am Ende jedes Kapitels ist ein Abschnitt stets jenen Themen gewidmet, die nicht behandelt werden konnten. Darin finden sich Hinweise auf ¨ weiterf¨ uhrende Literatur. Die L¨ osungen zu allen Ubungsaufgaben finden sich im letzten Kapitel. Zur weiteren Vertiefung werden wir oft auf die Lehrb¨ ucher [QSS02] verweisen, wo viele Themen dieses Buches ausf¨ uhrlicher behandelt und theoretische Resultate bewiesen werden. F¨ ur eine ausf¨ uhrliche Beschreibung von MATLAB verweisen wir auf [HH00]. Alle in diesem Buch vorgestellten Programme sind unter der Adresse http://mox.polimi.it/Springer/ verf¨ ugbar. Es werden keine speziellen Vorkenntnisse vom Leser verlangt, außer nat¨ urlich ein Grundkurs in Analysis. Im ersten Kapitel wiederholen wir die wichtigsten Resultate aus Analysis und Geometrie, die uns in diesem Text st¨andig begegnen werden. Die f¨ ur eine Einf¨ uhrung weniger elementaren Themen sind mit dem Symgekennzeichnet. ¨ Wir danken Herrn Klaus Sapelza f¨ ur die Ubersetzung, das sorgf¨altige Lesen und seine Hinweise zur Verbesserung der Qualit¨at des Buches.

bol

Mailand und Lausanne, August 2005

Alfio Quarteroni Fausto Saleri

Inhaltsverzeichnis

1

Was man wissen sollte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.1 Reelle Zahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.1.1 Wie wir sie darstellen . . . . . . . . . . . . . . . . . . . . . . . . . 1.1.2 Wie wir mit Floating-Point-Zahlen rechnen . . . . . . 1.2 Komplexe Zahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.3 Matrizen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.3.1 Vektoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.4 Reelle Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.4.1 Nullstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.4.2 Polynome . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.4.3 Integration und Differentiation . . . . . . . . . . . . . . . . . 1.5 Irren ist nicht nur menschlich . . . . . . . . . . . . . . . . . . . . . . . . 1.5.1 Sprechen wir u ¨ber Kosten . . . . . . . . . . . . . . . . . . . . . 1.6 Einige Worte zu MATLAB . . . . . . . . . . . . . . . . . . . . . . . . . . 1.6.1 MATLAB-Statements . . . . . . . . . . . . . . . . . . . . . . . . . 1.6.2 Programmieren in MATLAB . . . . . . . . . . . . . . . . . . . 1.7 Was wir nicht erw¨ ahnt haben . . . . . . . . . . . . . . . . . . . . . . . . 1.8 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1 1 2 4 6 8 12 14 15 17 19 21 24 27 29 31 35 35

2

Nichtlineare Gleichungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.1 Das Bisektionsverfahren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.2 Das Newton-Verfahren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.2.1 Abbruchkriterien f¨ ur das Newton-Verfahren . . . . . . 2.3 Fixpunktiterationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.3.1 Wie wir die Fixpunktiteration abbrechen . . . . . . . . 2.4 Beschleunigung mit dem Aitken-Verfahren . . . . . . . . . . . . . 2.5 Algebraische Polynome . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.5.1 Das Horner-Schema . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.5.2 Das Newton-Horner-Verfahren . . . . . . . . . . . . . . . . . 2.6 Was wir nicht erw¨ ahnt haben . . . . . . . . . . . . . . . . . . . . . . . . 2.7 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

37 39 42 44 47 50 51 55 56 58 61 62

VIII

Inhaltsverzeichnis

3

Approximation von Funktionen und Daten . . . . . . . . . . . 3.1 Interpolation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.1.1 Polynomiale Lagrange-Interpolation . . . . . . . . . . . . 3.1.2 Chebyshev-Interpolation . . . . . . . . . . . . . . . . . . . . . . 3.1.3 Trigonometrische Interpolation und FFT . . . . . . . . 3.2 St¨ uckweise lineare Interpolation . . . . . . . . . . . . . . . . . . . . . . 3.3 Approximation durch Spline-Funktionen . . . . . . . . . . . . . . . 3.4 Das Verfahren der kleinsten Quadrate . . . . . . . . . . . . . . . . . 3.5 Was wir nicht erw¨ ahnt haben . . . . . . . . . . . . . . . . . . . . . . . . 3.6 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

65 67 68 74 75 80 81 84 89 90

4

Numerische Differentiation und Integration . . . . . . . . . . . 4.1 Approximation der Ableitung . . . . . . . . . . . . . . . . . . . . . . . . 4.2 Numerische Integration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.2.1 Die Mittelpunktsformel . . . . . . . . . . . . . . . . . . . . . . . 4.2.2 Die Trapezformel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.2.3 Die Simpson-Formel . . . . . . . . . . . . . . . . . . . . . . . . . . 4.3 Die adaptive Simpson-Formel . . . . . . . . . . . . . . . . . . . . . . . . 4.4 Was wir nicht erw¨ ahnt haben . . . . . . . . . . . . . . . . . . . . . . . . 4.5 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

93 94 96 97 99 102 105 109 110

5

Lineare Systeme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.1 Die LU-Faktorisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.2 Pivoting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.3 Wie genau ist die LU-Faktorisierung? . . . . . . . . . . . . . . . . . 5.4 Wie man ein tridiagonales System l¨ost . . . . . . . . . . . . . . . . 5.5 Iterative Verfahren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.5.1 Wie man ein iteratives Verfahren konstruiert . . . . . 5.6 Wann soll ein iteratives Verfahren abgebrochen werden? . 5.7 Das Richardson-Verfahren . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.8 Was wir nicht erw¨ ahnt haben . . . . . . . . . . . . . . . . . . . . . . . . 5.9 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

113 116 123 125 130 132 133 137 140 143 144

6

Eigenwerte und Eigenvektoren . . . . . . . . . . . . . . . . . . . . . . . . 6.1 Das Potenzverfahren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.1.1 Konvergenzanalyse . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.2 Verallgemeinerung des Potenzverfahrens . . . . . . . . . . . . . . . 6.3 Wie man den Shift berechnet . . . . . . . . . . . . . . . . . . . . . . . . 6.4 Die Berechnung aller Eigenwerte . . . . . . . . . . . . . . . . . . . . . 6.5 Was wir nicht erw¨ ahnt haben . . . . . . . . . . . . . . . . . . . . . . . . 6.6 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

147 150 152 153 156 158 159 160

Inhaltsverzeichnis

IX

7

Gew¨ ohnliche Differentialgleichungen . . . . . . . . . . . . . . . . . . 7.1 Das Cauchy-Problem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.2 Das Euler-Verfahren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.2.1 Konvergenzanalyse . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.3 Das Crank-Nicolson-Verfahren . . . . . . . . . . . . . . . . . . . . . . . 7.4 Nullstabilit¨ at . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.5 Stabilit¨at auf unbeschr¨ ankten Intervallen . . . . . . . . . . . . . . 7.5.1 Bereiche absoluter Stabilit¨ at . . . . . . . . . . . . . . . . . . . 7.5.2 Absolute Stabilit¨ at kontrolliert St¨orungen . . . . . . . 7.6 Verfahren h¨ oherer Ordnung . . . . . . . . . . . . . . . . . . . . . . . . . . 7.7 Pr¨adiktor-Korrektor-Verfahren . . . . . . . . . . . . . . . . . . . . . . . 7.8 Systeme von Differentialgleichungen . . . . . . . . . . . . . . . . . . . 7.9 Was wir nicht erw¨ ahnt haben . . . . . . . . . . . . . . . . . . . . . . . . 7.10 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

163 165 166 168 172 173 175 178 179 186 188 190 195 196

8

Numerische Verfahren f¨ ur Randwertprobleme . . . . . . . . 8.1 Approximation von Randwertproblemen . . . . . . . . . . . . . . . 8.1.1 Approximation mit finiten Differenzen . . . . . . . . . . 8.1.2 Approximation mit finiten Elementen . . . . . . . . . . . 8.2 Finite Differenzen in zwei Dimensionen . . . . . . . . . . . . . . . . 8.2.1 Konsistenz und Konvergenz . . . . . . . . . . . . . . . . . . . . 8.3 Was wir nicht erw¨ ahnt haben . . . . . . . . . . . . . . . . . . . . . . . . 8.4 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

199 202 202 204 207 214 216 216

9

L¨ osung der Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.1 Kapitel 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.2 Kapitel 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.3 Kapitel 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.4 Kapitel 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.5 Kapitel 5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.6 Kapitel 6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.7 Kapitel 7 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.8 Kapitel 8 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

219 219 221 227 231 236 241 245 253

Literaturverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259 Index der MATLAB-Programme . . . . . . . . . . . . . . . . . . . . . . . . . 263 Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265

1 Was man wissen sollte

In diesem Buch werden wir st¨ andig elementaren mathematischen Konzepten begegnen, die der Leser bereits kennen sollte, die ihm aber m¨oglicherweise nicht mehr sofort pr¨ asent sind. In diesem einf¨ uhrenden Kapitel wollen wir diese Kenntnisse auffrischen und neue, f¨ ur das Wissenschaftliche Rechnen wichtige Konzepte einf¨ uhren. Wir werden die Bedeutung und die N¨ utzlichkeit dieser mit Hilfe des Programmes MATLAB (Matrix Laboratory) entdecken. In Abschnitt 1.6 werden wir eine kurze Einf¨ uhrung in MATLAB geben, f¨ ur eine vollst¨andige Beschreibung wollen wir auf die Handb¨ ucher [HH00] und [Mat04] verweisen. In diesem Kapitel fassen wir also die wichtigsten Resultate aus Analysis, Algebra und Geometrie zusammen, aufbereitet f¨ ur deren Anwendung im Wissenschaftlichen Rechnen.

1.1 Reelle Zahlen W¨ahrend allen bekannt sein d¨ urfte, was die Menge der reellen Zahlen R ist, ist es vielleicht weniger klar, auf welche Art und Weise Computer mit ihnen umgehen. Einerseits ist es unm¨ oglich, auf einer Maschine (mit endlichen Ressourcen) die Unendlichkeit der reellen Zahlen darzustellen, und man wird sich damit zufrieden geben m¨ ussen, nur eine Untermenge F von R mit endlicher Dimension darstellen zu k¨onnen, die wir die Menge der Floating-Point-Zahlen nennen. Andererseits hat F andere Eigenschaften als die Menge R, wie wir in Abschnitt 1.1.2 sehen werden. Der Grund hierf¨ ur ist, daß jede reelle Zahl x von der Maschine durch eine gerundete Zahl dargestellt wird, die wir mit f l(x) bezeichnen und Maschinenzahl nennen. Diese stimmt nicht notwendigerweise mit dem Ausgangswert x u ¨berein.

2

1 Was man wissen sollte

1.1.1 Wie wir sie darstellen

>>

Um uns des Unterschieds zwischen R und F bewußt zu werden, wollen wir anhand einiger Experimente in MATLAB zeigen, wie ein Computer (zum Beispiel ein PC) mit reellen Zahlen umgeht. Wir verwenden MATLAB anstelle einer anderen Programmiersprache (wie etwa Fortran oder C) nur der Einfachheit halber; das Ergebnis h¨angt n¨amlich in erster Linie von der Arbeitsweise des Computers ab und nur zu einem sehr kleinen Teil von der verwendeten Programmiersprache. Betrachten wir die rationale Zahl x = 1/7, deren Dezimaldarstellung 0.142857 ist. Beachte, daß der Punkt den Dezimalteil vom ganzen Teil trennt und statt eines Kommas steht. Diese Darstellung ist unendlich, denn nach dem Punkt stehen unendlich viele Ziffern ungleich null. Um auf einer Maschine diese Zahl darzustellen, setzen wir nach dem Prompt (dem Symbol >>) den Bruch 1/7 und erhalten >> 1/7 ans = 0.1429

format

als Ergebnis, also eine Zahl, die offenbar nur aus vier Dezimalziffern besteht, die letzte sogar falsch im Vergleich zur vierten Ziffer der reellen Zahl. Geben wir nun 1/3 ein, erhalten wir 0.3333, wo auch die vierte Ziffer exakt ist. Dieses Verhalten ist dadurch zu erkl¨aren, daß die reellen Zahlen am Computer gerundet werden, es wird also nur eine feste Anzahl von Dezimalziffern gespeichert und die letzte aufgerundet, falls die darauffolgende Ziffer gr¨ oßer oder gleich 5 ist. Nat¨ urlich k¨ onnen wir uns fragen, wie sinnvoll es ist, nur vier Dezimalziffern f¨ ur die Darstellung der reellen Zahlen zu verwenden. Wir k¨onnen aber beruhigt sein, die Zahl die wir gesehen“ haben, ist nur ei” nes der m¨oglichen Output-Formate des Systems, und dieses stimmt nicht mit seiner internen Darstellung u ¨berein. Diese verwendet 16 Dezimalziffern (und weitere korrigierende, aber das wollen wir hier nicht weiter ausf¨ uhren). Dieselbe Zahl nimmt je nach Formatangabe diverse Formen an; zum Beispiel sind f¨ ur 1/7 einige m¨ ogliche Output-Formate: format format format format format

long ergibt 0.14285714285714, short e ” 1.4286e − 01, long e ” 1.428571428571428e − 01, short g ” 0.14286, long g ” 0.142857142857143.

Einige dieser Darstellungen, etwa das Format long e, stimmen besser mit der internen Darstellung u ¨berein. Im allgemeinen speichert ein Computer eine reelle Zahl auf folgende Weise: x = (−1)s · (0.a1 a2 . . . at ) · β e = (−1)s · m · β e−t ,

a1
= 0,

(1.1)

1.1 Reelle Zahlen

3

wobei s entweder 0 oder 1 ist, die positive ganze Zahl β gr¨oßer gleich 2 die Basis, m eine ganze Zahl, die Mantisse, deren L¨ange t der maximalen Anzahl an speicherbaren Ziffern ai (zwischen 0 und β − 1) entspricht, und e eine ganze Zahl, der Exponent. Das Format long e ¨ahnelt dieser Darstellung am meisten (e steht f¨ ur Exponent und dessen Ziffern samt Vorzeichen stehen gleich rechts des Zeichens e). Die Maschinenzahlen in Format (1.1) heißen Floating-Point-Zahlen, weil die Position des Dezimalpunktes variabel ist. Die Bedingung a1
= 0 verhindert, daß dieselbe Zahl mehrere Darstellungen besitzt. Ohne diese Bedingung k¨ onnte 1/10 zur Basis 10 n¨amlich auch durch 0.1 · 100 oder 0.01 · 101 dargestellt werden. Die Menge F ist also vollst¨ andig durch die Basis β, die Anzahl signifikanter Stellen t und durch das Intervall (L, U ) (mit L < 0 und U > 0), in dem der Exponent e variieren kann, bestimmt. Diese Menge wird auch mit F(β, t, L, U ) bezeichnet: MATLAB verwendet F(2, 53, −1021, 1024) (tats¨achlich entsprechen die 53 signifikanten Stellen zur Basis 2 den 15 von MATLAB im format long angezeigten signifikanten Stellen zur Basis 10). Gl¨ ucklicherweise ist der unvermeidbare Roundoff-Fehler , der entsteht, wenn man eine reelle Zahl x
= 0 durch ihren Vertreter f l(x) in F ersetzt, im allgemeinen klein, da 1 |x − f l(x)| ≤ M , 2 |x|

(1.2)

wobei M = β 1−t dem Abstand zwischen 1 und der n¨achsten FloatingPoint-Zahl ungleich 1 entspricht. Beachte, daß M von β und t abh¨angt. In MATLAB erh¨ alt man M mit dem Befehl eps und es ist M = 2−52  2.22 · 10−16 . Beachte, daß wir in (1.2) den relativen Fehler von x abgesch¨atzt haben, der sicher aussagekr¨ aftiger als der absolute Fehler |x − f l(x)| ist, denn dieser zieht ja die Gr¨ oßenordnung von x nicht mit in Betracht. Die Zahl 0 geh¨ ort nicht zu F, da zur Darstellung dieser in (1.1) a1 = 0 ist: sie wird also extra behandelt. Da u ¨berdies L und U endlich sind, lassen sich keine Zahlen mit beliebig großem oder kleinem Absolutbetrag darstellen. So ist die gr¨ oßte bzw. kleinste Zahl von F

eps

xmin = β L−1 , xmax = β U (1 − β −t ). Mit den Befehlen realmin und realmax ist es in MATLAB m¨oglich, diese Werte festzustellen: xmin = 2.225073858507201 · 10−308 , xmax = 1.7976931348623158 · 10+308 . Eine Zahl kleiner als xmin erzeugt einen sogenannten Underflow und wird entweder wie 0 oder auf besondere Weise (siehe [QSS02], Kapitel

realmin realmax

4

Inf

1 Was man wissen sollte

2) behandelt. Eine positive Zahl gr¨ oßer als xmax erzeugt hingegen einen Overflow und wird in der Variablen Inf (am Computer die Darstellung des positiv Unendlichen) gespeichert. Die Tatsache, daß xmin und xmax die Extrema eines sehr breiten Intervalls der reellen Zahlengeraden sind, soll uns nicht t¨auschen: die Zahlen von F sind sehr dicht gestreut in der N¨ahe von xmin , und immer d¨ unner gestreut in der N¨ ahe von xmax . Dies k¨onnen wir sofort u ¨berpr¨ ufen, indem wir xmax−1 und xmin+1 in F betrachten: xmax−1 = 1.7976931348623157 · 10+308 xmin+1 = 2.225073858507202 · 10−308 , ahrend xmax − xmax−1  10292 es ist also xmin+1 − xmin  10−323 , w¨ (!). Der relative Abstand bleibt jedenfalls klein, wie wir aus (1.2) sehen k¨onnen. 1.1.2 Wie wir mit Floating-Point-Zahlen rechnen Kommen wir nun zu den elementaren Operationen in F: da F nur eine Teilmenge von R ist, besitzen diese nicht alle Eigenschaften der in R definierten Operationen. Genauer gesagt bleibt die Kommutativit¨at der Addition (also f l(x + y) = f l(y + x) ∀x, y ∈ F) und der Multiplikation (f l(xy) = f l(yx) ∀x, y ∈ F) erhalten, aber die Eigenschaften Assoziativit¨at und Distributivit¨ at sowie die Eindeutigkeit der Zahl 0 gehen verloren. Um zu sehen, daß die Zahl 0 nicht mehr eindeutig ist, ordnen wir einer Variablen a einen beliebigen Wert, etwa 1, zu und f¨ uhren folgendes Programm aus: >> a = 1; b=1; while a+b ˜= a; b=b/2; end In diesem wird die Variable b in jedem Schritt halbiert, solange die Summe von a und b ungleich (˜ =) a ist. W¨ urden wir mit reellen Zahlen rechnen, dann w¨ urde das Programm niemals abbrechen; in unserem Fall hingegen bricht es nach einer endlichen Anzahl von Schritten ab und liefert f¨ ur b folgenden Wert: 1.1102e-16= M /2. Es existiert also mindestens eine Zahl b ungleich 0, so daß a+b=a. Das ist deswegen m¨oglich, da die Menge F aus voneinander isolierten Elementen besteht. Summieren wir also zwei Zahlen a und b mit b> x = 1.e − 15; ((1 + x) − 1)/x ans = 1.1102 Wie wir sehen, ist das Ergebnis sehr ungenau, der absolute Fehler sehr groß. Ein weiteres Beispiel f¨ ur die Ausl¨ oschung signifikanter Stellen liefert die Auswertung der Funktion f (x) = x7 − 7x6 + 21x5 − 35x4 + 35x3 − 21x2 + 7x − 1

(1.3)

in 401 ¨aquidistanten Punkten des Intervalls [1−2·10−8 , 1+2·10−8 ]. Wir erhalten den in 1.1 abgebildeten chaotischen Graphen (der wahre Verlauf ist der von (x − 1)7 , also einer auf diesem kleinen Intervall um x = 1 ann¨ahernd konstanten Funktion gleich null). In Abschnitt 1.4 werden wir die Befehle kennenlernen, mit denen wir den Graphen erzeugt haben. −14

1.5

x 10

1

0.5

0

−0.5

−1

Abb. 1.1. Oszillierender Verlauf der Funktion (1.3), bedingt durch die Ausl¨ oschung signifikanter Stellen

Beachte schließlich, daß in F sogenannte unbestimmte Formen wie etwa 0/0 oder ∞/∞ nicht vorkommen: in Berechnungen ergeben sie eine sogenannte Not-a-Number (NaN in MATLAB), f¨ ur die die u ¨blichen Rechenregeln nicht gelten. Bemerkung 1.1 Es ist richtig, daß die Rundungsfehler im allgemeinen klein sind, werden sie aber innerhalb von langen und komplexen Algorithmen wiederholt, k¨ onnen sie katastrophale Auswirkungen haben. Zwei außergew¨ ohnli-

NaN

6

1 Was man wissen sollte

che Ereignisse waren die Explosion der Ariane-Rakete am 4. Juni 1996, verursacht durch einen Overflow im Bordcomputer, und der Absturz einer amerikanischen Patriot-Rakete w¨ ahrend des ersten Golfkrieges im Jahr 1991 auf eine amerikanische Kaserne aufgrund eines Rundungsfehlers in der Berechnung ihrer Schußbahn. Ein weniger folgenschweres, aber dennoch erschreckendes Beispiel ergibt sich aus der Berechnung der Folge √ (1.4) z2 = 2, zn+1 = 2n−1/2 1 − 1 − 41−n zn2 , n = 2, 3, . . . , die f¨ ur n gegen unendlich gegen π konvergiert. Verwenden wir MATLAB f¨ ur die Berechnung von zn , stellen wir fest, wie der relative Fehler zwischen π und ur die ersten 16 Iterationen sinkt, dann aber aufgrund von Rundungsfehlern zn f¨ wieder steigt (siehe Abbildung 1.2).

0

10

−2

10

−4

10

−6

10

−8

10

−10

10

5

10

15

20

25

30

Abb. 1.2. Logarithmus des relativen Fehlers |π − zn |/|π| in Abh¨ angigkeit der Iterationsanzahl n

Siehe Aufgaben 1.1–1.2.

1.2 Komplexe Zahlen

complex

Die komplexen Zahlen, deren Menge mit dem√Symbol C bezeichnet wird, sind von der Form z = x + iy, wobei i = −1 die komplexe Einheit (also i2 = −1) ist, w¨ahrend x = Re(z) bzw. y = Im(z) Realteil bzw. Imagin¨arteil von z sind. Im allgemeinen werden diese am Computer als Paare reeller Zahlen dargestellt. Falls nicht anders definiert, bezeichnen beide MATLAB-Variablen i und j die imagin¨are Einheit. Um eine komplexe Zahl mit Realteil x und Imagin¨arteil y einzuf¨ uhren, gen¨ ugt es, einfach x+i*y zu schreiben; alternativ kann man auch den Befehl complex(x,y) verwenden. Wir erinnern auch an die trigonometrische Darstellung einer komplexen Zahl z, f¨ ur die

z = ρeiθ = ρ(cos θ + i sin θ)

(1.5)

1.2 Komplexe Zahlen

7




gilt, wobei ρ = x2 + y 2 der Betrag der komplexen Zahl ist (den man alt) und θ das Argument, also der Winkel mit dem Befehl abs(z) erh¨ zwischen dem Vektor z mit den Komponenten (x, y) und der x-Achse. θ erh¨alt man mit dem Befehl angle(z). Die Darstellung (1.5) ist also

abs angle

abs(z) ∗ (cos(angle(z)) + i ∗ sin(angle(z))). Die Polardarstellung (also in Funktion von ρ und θ) einer oder mehrerer komplexer Zahlen erh¨ alt man mit dem Befehl compass(z), wobei z eine komplexe Zahl oder ein Vektor komplexer Zahlen sein kann. So erh¨alt man zum Beispiel durch Eingabe von

compass

>> z = 3+i*3; compass(z); den in Abbildung 1.3 dargestellten Graphen.

90 5 120

60 4 3

150

30 2 1

180

0

210

330

240

300 270

Abb. 1.3. Output des MATLAB-Befehls compass

Ist eine komplexe Zahl z gegeben, kann man deren Realteil (bzw. Imagin¨arteil) mit dem Befehl real(z) (bzw. imag(z)) extrahieren. Schließ- real lich erh¨alt man die komplex konjugierte Zahl z¯ = x − iy von z mit dem imag conj Befehl conj(z). In MATLAB werden alle Operationen unter der impliziten Annahme, daß Ergebnis und Operatoren komplex sind, ausgef¨ uhrt. So ist es nicht verwunderlich, daß MATLAB f¨ ur die Kubikwurzel von −5 mit dem Befehl (-5)(1/3) statt der reellen Zahl −1.7099 . . . die komplexe Zahl 0.8550 + 1.4809i liefert. achlich sind alle Zahlen der  Das Symbol  bedeutet Potenzieren. Tats¨ Form √ ρei(θ+2kπ) mit ganzem k nicht von z unterscheidbar. Berechnen wir √ jetzt 3 z, erhalten wir 3 ρei(θ/3+2kπ/3) , das heißt die drei verschiedenen Wurzeln

8

1 Was man wissen sollte Im(z) z2 ρ π 3

z3

Re(z)

z1

Abb. 1.4. Darstellung der Kubikwurzeln der reellen Zahl −5 in der GaußEbene

z1 =

√ 3

ρeiθ/3 , z2 =

√ 3

ρei(θ/3+2π/3) , z3 =

√ 3

ρei(θ/3+4π/3) .

MATLAB w¨ahlt dann jene aus, der als erstes begegnet wird, falls die komplexe Ebene, ausgehend von der reellen Achse, im Gegegenuhrzeigersinn aufgespannt wird. Da die Polardarstellung von z = −5 gleich ρeiθ mit ρ = 5 und θ = −π ist, sind die drei Wurzeln √ z1 = 3 5(cos(−π/3) + i sin(−π/3))  0.8550 − 1.4809i, √ z2 = 3 5(cos(π/3) + i sin(π/3))  0.8550 + 1.4809i, √ z3 = 3 5(cos(−π) + i sin(−π))  −1.71.

ahlt wird (siehe Die zweite Wurzel ist jene, die von MATLAB ausgew¨ Abbildung 1.4 f¨ ur die Darstellung von z1 , z2 und z3 in der Gauß-Ebene). Schließlich erhalten wir aus (1.5) die Euler-Formel cos(θ) =

  1  iθ 1  iθ e − e−iθ . e + e−iθ , sin(θ) = 2i 2

(1.6)

1.3 Matrizen Seien n und m zwei positive ganze Zahlen. Eine Matrix A mit m Zeilen und n Spalten ist eine Menge von m × n Elementen aij mit i = 1, . . . , m, j = 1, . . . , n, dargestellt durch folgende Tabelle ⎡ ⎤ a11 a12 . . . a1n ⎢ a21 a22 . . . a2n ⎥ ⎢ ⎥ A=⎢ . (1.7) .. .. ⎥ . ⎣ .. . . ⎦ am1 am2 . . . amn

1.3 Matrizen

9

In kompakter Form schreiben wir A = (aij ). Sind die Elemente von A reelle Zahlen, schreiben wir A ∈ Rm×n ; A ∈ Cm×n , falls sie komplex sind. Ist n = m, nennt man die Matrix quadratisch der Dimension n. Eine Matrix mit nur einer Spalte ist ein Spaltenvektor, w¨ahrend eine Matrix mit nur einer Zeile ein Zeilenvektor ist. Um in MATLAB eine Matrix einzugeben, m¨ ussen wir nur die Elemente von der ersten bis zur letzten Zeile eingegeben und das Ende jeder Zeile mit ; markieren. So erzeugt etwa der Befehl >> A = [ 1 2 3; 4 5 6] die Matrix A= 1 4

2 5

3 6

mit zwei Zeilen und drei Spalten. Auf den Matrizen sind einige elementare Operationen definiert. Falls A = (aij ) und B = (bij ) zwei (m × n)-Matrizen sind, dann ist: 1. die Summe zweier Matrizen A und B die Matrix A + B = (aij + bij ). Die Nullmatrix der Dimension m × n (bezeichnet mit 0 und erzeugt durch zeros(m,n)) ist die Matrix mit ausschließlich Nulleintr¨agen; 2. das Produkt einer Matrix A und einer (reellen oder komplexen) Zahl λ die Matrix λA = (λaij ).

zeros

Etwas Beachtung m¨ ussen wir dem Matrixprodukt schenken. Dieses kann nur gebildet werden, falls A und B die Dimension m × p bzw. p × n haben, mit einer beliebigen ganzen Zahl p. Das Produkt ist dann eine Matrix C der Dimension m × n mit den Elementen cij =

p 

aik bkj , f¨ ur i = 1, . . . , m, j = 1, . . . , n.

k=1

Das neutrale Element der Multiplikation ist eine quadratische Matrix, die Einheitsmatrix, und wird mit I bezeichnet; sie hat entlang der Diagonalen Eintr¨ age gleich 1 und Elemente gleich 0 sonst (in MATLAB wird die Matrix mit dem Befehl eye(n) konstruiert, n ist dabei die Dimension). Summen- und Produktbildung f¨ ur Matrizen erfolgt in MATLAB mit denselben Operationen wie f¨ ur reelle Zahlen. Es ist zum Beispiel >> A=[1 2 3; 4 5 6]; B=[7 8 9; 10 11 12]; C=[13 14; 15 16; 17 18]; >> A+B ans = 8 10 12 14 16 18 >> A*C

eye

10

1 Was man wissen sollte

ans = 94 100 229 244 Der Versuch, die Summe von A und C zu bilden, f¨ uhrt zu folgender Diagnosemeldung >> A+C ??? Error using ==> + Matrix dimensions must agree.

inv det

Ein analoges Resultat w¨ urde man beim Versuch erhalten, A mit B zu multiplizieren. Die Inverse einer quadratischen Matrix der Dimension n, also die eindeutige Matrix X = A−1 , so daß AX = XA = I, existiert nur, falls die Determinante von A ungleich null ist, also die Zeilenvektoren der Matrix A linear unabh¨ angig sind. Die Berechnung der Inversen erfolgt ahrend der Befehl f¨ ur die Berechnung der mit dem Befehl inv(A), w¨ Determinante det(A) lautet. An dieser Stelle wollen wir daran erinnern, daß die Determinante einer quadratischen Matrix eine durch folgende Rekursion (Laplace-Regel) definierte Zahl ist ⎧ falls n = 1, a11 ⎪ ⎪ ⎪ ⎨ n (1.8) det(A) =  ⎪ ⎪ ∆ij aij f u ¨r n > 1, ∀i = 1, . . . , n, ⎪ ⎩ j=1

wobei ∆ij = (−1)i+j det(Aij ) und Aij die Matrix ist, die man durch Streichung der i-ten Zeile und j-ten Spalte aus der Matrix A erh¨alt. (Das Ergebnis h¨ angt nicht von der gew¨ ahlten Zeile i ab.) Falls A ∈ R1×1 , setzen wir det(A) = a11 , falls A ∈ R2×2 , erh¨alt man det(A) = a11 a22 − a12 a21 , w¨ahrend f¨ ur A ∈ R3×3 det(A) = a11 a22 a33 + a31 a12 a23 + a21 a13 a32 −a11 a23 a32 − a21 a12 a33 − a31 a13 a22 . Falls hingegen A = BC, dann ist det(A) = det(B) · det(C). Sehen wir uns ein Beispiel f¨ ur die Berechnung der Inversen einer (2 × 2)-Matrix und ihrer Determinante an: >> A=[1 2; 3 4]; >> inv(A) ans = -2.0000 1.0000

1.3 Matrizen

11

1.5000 -0.5000 >> det(A) ans = -2 Ist die Matrix singul¨ ar, meldet uns MATLAB das Problem und gibt eine Diagnosemeldung zur¨ uck, gefolgt von einer Matrix mit Eintr¨agen Inf: >> A=[1 2; 0 0]; >> inv(A) Warning: Matrix is singular to working precision. ans = Inf Inf Inf Inf Die Berechnung der Inversen und der Determinante ist f¨ ur bestimmte Klassen von quadratischen Matrizen besonders einfach. So etwa bei den Diagonalmatrizen, f¨ ur die die akk mit k = 1, . . . , n die einzigen Elemente ungleich null sind. Diese Elemente bilden die sogenannte Hauptdiagonale der Matrix und es ist det(A) = a11 a22 · · · ann . ur alle k. In Die Diagonalmatrizen sind nicht singul¨ ar, falls akk
= 0 f¨ diesem Fall ist die Inverse eine Diagonalmatrix mit den Elementen a−1 kk . In MATLAB ist die Konstruktion einer Diagonalmatrix der Dimension n einfach, es gen¨ ugt der Befehl diag(v), wobei v ein Vektor der Dimension n ist, der nur die Diagonalelemente enth¨alt. Mit dem Befehl diag(v,m) hingegen wird eine quadratische Matrix der Dimension n+abs(m) erzeugt, die in der m-ten oberen Nebendiagonalen (oder unteren Nebendiagonalen, falls m negativ ist) die Elemente des Vektors v enth¨alt. Ist etwa v = [1 2 3], so ist >> A=diag(v,-1) A= 0 0 0 1 0 0 0 2 0 0 0 3

0 0 0 0

Andere Matrizen, f¨ ur die die Berechnung der Determinante einfach ist, sind die obere Dreiecksmatrix und die untere Dreiecksmatrix ; eine quadratische Matrix der Dimension n heißt untere Dreiecksmatrix (bzw. obere Dreiecksmatrix), falls alle Elemente oberhalb (bzw. unterhalb) der Hauptdiagonalen null sind. Die Determinante ist dann einfach das Produkt der Diagonalelemente.

diag

12

tril triu

1 Was man wissen sollte

Mit den MATLAB-Befehlen tril(A) und triu(A) ist es m¨oglich, aus der Matrix A der Dimension n deren untere bzw. obere Dreiecksmatrix zu extrahieren. In der erweiterten Form tril(A,m) bzw. triu(A,m), mit m zwischen -n und n, lassen sich Dreiecksmatrizen unterhalb bzw. oberhalb der einschließlich m-ten Nebendiagonalen extrahieren. Betrachten wir zum Beispiel die Matrix A =[3 1 2; -1 3 4; -2 -1 3], dann erhalten wir mit dem Befehl L1=tril(A) die untere Dreiecksmatrix L1 = 3 -1 -2

0 3 -1

0 0 3

Geben wir hingegen L2=tril(A,1) ein, erhalten wir folgende Matrix L2 = 3 -1 -2

A’

1 3 -1

0 4 3

Eine spezielle Matrixoperation ist das Transponieren: ist eine Matrix A ∈ Rn×m gegeben, bezeichnen wir mit AT ∈ Rm×n ihre transponierte Matrix, die man durch Vertauschen der Zeilen und Spalten von A erh¨alt. Falls in MATLAB A eine reelle Matrix ist, bezeichnet A’ ihre Transponierte. Falls A = AT , dann heißt A symmetrisch. 1.3.1 Vektoren

ones

Wir bezeichnen Vektoren mit Fettbuchstaben. So bezeichnet v stets einen Spaltenvektor, dessen i-te Komponente wir mit vi bezeichnen. Falls ein Vektor n reelle Komponenten hat, schreiben wir v ∈ Rn . MATLAB behandelt Vektoren wie spezielle Matrizen. Um einen Spaltenvektor zu definieren, m¨ ussen wir in eckigen Klammern nur die Werte der einzelnen Komponenten des Vektors, getrennt durch Strichpunkte, eingeben, w¨ ahrend wir f¨ ur einen Zeilenvektor nur die Werte, getrennt durch Leerzeichen oder Beistriche, eingeben m¨ ussen. So definieren zum Beispiel die Befehle v = [1;2;3] und w = [1 2 3] einen Spalten- bzw. Zeilenvektor der Dimension 3. Der Befehl zeros(n,1) (bzw.zeros(1,n)) erzeugt einen Spaltenvektor (bzw. Zeilenvektor) der Dimension n mit nur Nullelementen; diesen bezeichnen wir mit 0. In analoger Weise erzeugt der Befehl ones(n,1) einen Spaltenvektor mit Einselementen, mit 1 bezeichnet. Unter den Vektoren sind besonders die voneinander linear unabh¨ angigen wichtig; ein System von Vektoren {y1 , . . . , ym } heißt linear unabh¨angig, falls die Beziehung

1.3 Matrizen

13

α1 y1 + . . . + αm ym = 0 gilt. Diese kann nur erf¨ ullt werden, falls alle Koeffizienten α1 , . . . , αm null sind. Eine Menge n linear unabh¨ angiger Vektoren B = {y1 , . . . , yn } in Rn (oder Cn ) bildet eine Basis von Rn (bzw. Cn ) und besitzt die Eigenschaft, daß jeder Vektor w von Rn in eindeutiger Weise als w=

n 

wk yk

k=1

geschrieben werden kann. Die Zahlen wk heißen Komponenten von w bez¨ uglich der Basis B. Zum Beispiel besteht die kanonische Basis des Rn aus den Vektoren {e1 , . . . , en }, wobei die i-te Komponente von ei gleich 1 ist und die u ¨brigen Komponenten gleich 0 sind. Das ist nicht die einzige Basis des Rn , aber jene, die wir im allgemeinen verwenden werden. Was die Operationen zwischen Vektoren gleicher Dimension betrifft, wollen wir hier besonders auf das Skalarprodukt und das Vektorprodukt hinweisen. Ersteres ist definiert als n  vk wk , v, w ∈ Rn , (v, w) = wT v = k=1

wobei {vk } und {wk } die Komponenten von v bzw. w sind. In MATLAB kann diese Operation zwischen Vektoren mit dem Befehl w’*v (oder mit uhrt werden, wobei der Apodem eigenen Befehl dot(v,w)) durchgef¨ stroph den Vektor w transponiert. Die L¨ ange (oder der Betrag) eines Vektors v ist dann gegeben durch   n
 v = (v, v) =  vk2

dot

k=1

und kann mit dem Befehl norm(v) berechnet werden. Das Vektorprodukt zweier Vektoren v, w ∈ Rn ist hingegen gegeben durch den Vektor u ∈ Rn (bezeichnet mit u = v × w oder u = v ∧ w), der sowohl zu v als auch zu w orthogonal steht und dessen L¨ ange |u| = |v| |w| sin(α) ist, wobei α der Winkel zwischen v und w ist. In MATLAB wird das Vektorprodukt mit dem Befehl cross(v,w) berechnet. Die Visualisierung von Vektoren in MATLAB erfolgt in R2 mit dem Befehl quiver und in R3 mit quiver3. Oft kommen in den vorgestellten MATLAB-Programmen Operationen zwischen Vektoren vor, die von einem Punkt angef¨ uhrt werden, wie zum Beispiel in x.*y oder x.ˆ2. Diese Schreibweise bedeutet, daß die Operation nicht im herk¨ ommlichen Sinn durchgef¨ uhrt wird, sondern komponentenweise. So ergibt x.*y nicht das Skalarprodukt zweier Vektoren x und y, sondern einen Vektor, dessen i-te Komponente gleich xi yi ist. Definieren wir zum Beispiel die Vektoren

norm

cross quiver quiver3 .* .ˆ

14

1 Was man wissen sollte

>> v = [1; 2; 3]; w = [4; 5; 6]; so sind das Skalarprodukt und das komponentenweise Produkt >> w’*v ans = 32 >> w.*v ans = 4 10

18

Beachte, daß das Produkt w*v nicht definiert ist, falls die Vektoren die falsche Dimension haben. Ein Vektor v ∈ Rn mit v
= 0 ist der zur komplexen Zahl λ geh¨orige Eigenvektor der Matrix A ∈ Rn×n , falls Av = λv. Die Zahl λ heißt Eigenwert von A. Die Berechnung der Eigenwerte einer Matrix ist im allgemeinen recht kompliziert; nur f¨ ur Diagonalmatrizen und Dreiecksmatrizen entsprechen die Eigenwerte den Diagonalelementen. Siehe Aufgaben 1.3–1.5.

1.4 Reelle Funktionen

fplot

Reelle Funktionen werden Hauptgegenstand einiger Kapitel dieses Buches sein. Im speziellen wollen wir f¨ ur eine auf einem Intervall (a, b) definierte Funktion f deren Nullstellen, ihr Integral und ihre Ableitung berechnen und ann¨ ahernd ihren Verlauf kennen. Der Befehl fplot(fun,lims) zeichnet in einem Intervall, dessen Grenzen die beiden Komponenten des Vektors lims sind, den Graphen der Funktion fun (in einer Zeichenkette gespeichert). Wollen wir zum Beispiel f (x) = 1/(1 + x2 ) auf (−5, 5) darstellen, schreiben wir >> fun =’1/(1+xˆ2)’; lims=[-5,5]; fplot(fun,lims); Alternativ k¨ onnen wir direkt >> fplot(’1/(1+xˆ2)’,[-5 5]); eingeben. Die erhaltene Darstellung ist eine Ann¨aherung des Graphen von f (mit einer Toleranz von 0.2%), die sich aus der Auswertung der Funktion auf einer Menge von nicht ¨ aquidistanten Abszissenwerten ergibt. Um die Genauigkeit der Darstellung zu erh¨ohen, k¨onnen wir fplot folgendermaßen aufrufen:

1.4 Reelle Funktionen

15

>> fplot(fun,lims,tol,n,LineSpec) wobei tol die gew¨ unschte relative Toleranz ist. Der Parameter n (≥ 1) garantiert, daß der Graph der Funktion mit mindestens n+1 Punkten gezeichnet wird; LineSpec gibt hingegen die Art (oder die Farbe) der gezeichneten Linie an (zum Beispiel LineSpec=’--’ f¨ ur eine unterbrochene Linie, LineSpec=’r-.’ f¨ ur eine rote Strichpunktlinie). Sollen die voreingestellten (Default-) Werte f¨ ur jede dieser Variablen verwendet werden, kann man eine leere Matrix (in MATLAB [ ]) u ¨bergeben. Den Wert f (x) in einem Punkt x (oder auf einer Menge von Punkten, wieder gespeichert in einem Vektor x) erh¨ alt man nach Eingabe von x mit dem Befehl y=eval(fun). In y werden die zugeh¨origen Ordinaten gespeichert. Um diesen Befehl zu verwenden, muß die Zeichenkette fun (die den Ausdruck f bestimmt) ein Ausdruck in der Variablen x sein. Anderenfalls m¨ ussen wir den Befehl eval durch den Befehl feval ersetzen. Um schließlich wie in Abbildung 1.1 ein Referenzgitter einzuzeichnen, m¨ ussen wir nach dem Befehl fplot den Befehl grid on eingeben. 1.4.1 Nullstellen Aus dem Graphen einer Funktion k¨ onnen wir, wenn auch nur ann¨ahernd, deren Nullstellen ablesen; wir erinnern daran, daß α eine Nullstelle von f ist, falls f (α) = 0. Eine Nullstelle wird außerdem einfach genannt, falls f
(α)
= 0, anderenfalls mehrfach . Oft ist die Berechnung von Nullstellen kein Problem. Falls die Funktion ein Polynom mit reellen Koeffizienten vom Grad n ist, also von der Form pn (x) = a0 + a1 x + a2 x2 + . . . + an xn =

n 

ak xk ,

ak ∈ R, an
= 0,

k=0

kann man f¨ ur n = 1 (der Graph von p1 ist eine Gerade) die einzige Nullstelle α = −a0 /a1 leicht berechnen, genauso wie die zwei Nullstellen ur n = 2 (der Graph von p2 ist eine Parabel) α+ und α− f¨
−a1 ± a21 − 4a0 a2 . α± = 2a2 Es ist auch bekannt, daß es f¨ ur n ≥ 5 keine allgemeinen Formeln gibt, mit denen man in endlich vielen Schritten die Wurzeln eines beliebigen Polynoms pn berechnen kann. Auch die Anzahl der Nullstellen einer Funktion ist auf elementare Weise a priori nicht feststellbar; die Ausnahme sind dabei wieder die Polynome, f¨ ur die die Anzahl von (reellen oder komplexen) Nullstellen gleich dem Grad des Polynoms ist. Außerdem weiß man, daß, falls ein

eval

feval grid

16

fzero

1 Was man wissen sollte

Polynom mit reellen Koeffizienten eine komplexe Wurzel α = x + iy hat, auch die komplex konjugierte α ¯ = x−iy von α eine Wurzel des Polynoms ist. Die Berechnung einer (nicht aller) Nullstelle einer Funktion f , in fun gespeichert, in der N¨ ahe eines reellen oder komplexen Wertes x0 kann in MATLAB mit dem Befehl fzero(fun,x0) erfolgen. Neben dem Wert der approximierten Nullstelle wird auch das Intervall ausgegeben, in dem die Funktion die Nullstelle gesucht hat. Rufen wir den Befehl hingegen mit fzero(fun,[x0 x1]) auf, wird die Nullstelle von fun im Intervall mit den Grenzen x0,x1 gesucht, vorausgesetzt, f wechselt zwischen x0 und x1 das Vorzeichen. Betrachten wir zum Beispiel die Funktion f (x) = x2 − 1 + ex ; aus einer graphischen Untersuchung sehen wir, daß sie zwei Nullstellen im Intervall (−1, 1) hat. Um diese zu berechnen, f¨ uhren wir folgende Befehle aus: >> fun=’xˆ2 - 1 + exp(x)’; >> fzero(fun,1) Zero found in the interval: [-0.28, 1.9051]. ans = 6.0953e-18 >> fzero(fun,-1) Zero found in the interval: [-1.2263, -0.68]. ans = -0.7146 Da wir am Graphen gesehen haben, daß sich eine Nullstelle in [−1, −0.2], die andere in [−0.2, 1] befindet, k¨onnen wir auch schreiben: >> fzero(fun,[-0.2 1]) Zero found in the interval: [-0.2, 1]. ans = -4.2658e-17 >> fzero(fun,[-1 -0.2]) Zero found in the interval: [-1, -0.2]. ans = -0.7146 Wie wir sehen, ist das f¨ ur die erste Wurzel erhaltene Ergebnis nicht gleich dem vorher berechneten (obwohl beide ann¨ahernd gleich null sind). Der Grund hierf¨ ur ist, daß der in fzero implementierte Algorithmus in beiden F¨allen jeweils verschieden funktioniert. In Kapitel 2 werden wir einige Verfahren zur Berechnung der Nullstellen einer Funktion kennenlernen.

1.4 Reelle Funktionen

17

1.4.2 Polynome Wie wir schon gesehen haben, sind Polynome recht spezielle Funktionen. Im folgenden bezeichnen wir mit Pn die Menge der Polynome vom Grad n. F¨ ur diese gibt es in MATLAB eine Reihe spezieller Befehle, die in der Toolbox polyfun zusammengefaßt sind. Wenden wir uns den wichtigsten zu. Der erste Befehl, polyval, dient zur Auswertung eines Polynoms in einem oder mehreren Punkten und bedarf zweier Vektoren p und x als Eingabeparameter. In p sind die Koeffizienten des Polynoms in der Reihenfolge von an bis a0 gespeichert, in x hingegen die Abszissenwerte, in denen wir das Polynom auswerten wollen. Das Ergebnis kann in einem Vektor y gespeichert werden, indem wir

polyval

>> y = polyval(p,x) schreiben. Zum Beispiel k¨ onnen wir f¨ ur das Polynom p(x) = x7 + 3x2 − 1 dessen Werte in den ¨ aquidistanten Knoten xk = −1 + k/4, k = 0, . . . , 8 mit folgenden Befehlen berechnen: >> p = [1 0 0 0 0 3 0 -1]; x = [-1:0.25:1]; >> y = polyval(p,x) y= Columns 1 through 7 1.0000 0.5540 -0.2578 -0.8126 -1.0000 Columns 8 through 9 0.8210 3.0000

-0.8124

-0.2422

Nat¨ urlich k¨onnte man f¨ ur die Auswertung eines Polynoms auch den Befehl fplot verwenden; dieser ist aber im allgemeinen recht unbequem zu verwenden, weil wir in der Zeichenkette, die die zu zeichnende Funktion definiert, den analytischen Ausdruck des Polynoms und nicht nur seine Koeffizienten angeben m¨ ussen. Das Programm roots dient hingegen zur angen¨aherten Berechnung der Nullstellen eines Polynoms und verlangt als Eingabeparameter nur den Vektor p. Wir m¨ ochten noch einmal daran erinnern, daß α Nullstelle von p genannt wird, falls p(α) = 0 ist, oder, a ¨quivalent dazu, Wurzel der Gleichung p(x) = 0. Zum Beispiel k¨ onnen wir f¨ ur das Polynom p(x) = x3 − 6x2 + 11x − 6 die Nullstellen folgendermaßen berechnen: >> p = [1 -6 11 -6]; format long; >> roots(p) ans = 3.00000000000000 2.00000000000000 1.00000000000000 In diesem Fall erhalten wir die exakten Nullstellen.

roots

18

1 Was man wissen sollte

Aber nicht immer ist das Ergebnis so genau: so erhalten wir etwa f¨ ur das Polynom p(x) = (x−1)7 , dessen einzige Nullstelle α = 1 ist, folgende Nullstellen (einige davon sind sogar komplex) >> p = [1 -7 21 -35 35 -21 7 -1]; >> roots(p) ans = 1.0088 1.0055 + 0.0069i 1.0055 - 0.0069i 0.9980 + 0.0085i 0.9980 - 0.0085i 0.9921 + 0.0038i 0.9921 - 0.0038i

conv deconv

Eine m¨ ogliche Erkl¨ arung dieses Verhaltens ist die Fortpflanzung der Rundungsfehler bei der Berechnung der Nullstellen des Polynoms. Die Koeffizienten von p k¨ onnen n¨ amlich alternierende Vorzeichen haben, was zu großen Fehlern f¨ uhren kann, da signifikante Stellen ausgel¨oscht werden. Weiters k¨ onnen wir mit dem Befehl p=conv(p1,p2) die Koeffizienten des aus dem Produkt der beiden Polynome mit den Koeffizienten p1 und p2 erhaltenen Polynoms berechnen. Der Befehl [q,r]=deconv(p1,p2) hingegen berechnet die Koeffizienten q und den Rest r nach Division von p1 durch p2, so daß p1 = conv(p2,q) + r ist. Betrachten wir zum Beispiel die Polynome p1 (x) = x4 −1 und p2 (x) = 3 x − 1 und berechnen Produkt und Quotienten: >> p1 = [1 0 0 0 -1]; >> p2 = [1 0 0 -1]; >> p=conv(p1,p2) p = 1 0 0 -1 -1 >> [q,r]=deconv(p1,p2) q= 1 0 r= 0 0 0 1 -1

polyint polyder

0

0

1

Wir erhalten die Polynome p(x) = p1 (x)p2 (x) = x7 −x4 −x3 +1, q(x) = x und r(x) = x − 1, so daß p1 (x) = q(x)p2 (x) + r(x). Schließlich liefern die Befehle polyint(p) und polyder(p) die Koeffizienten der Stammfunktion (die in x = 0 verschwindet) bzw. die Koeffizienten der Ableitung des Polynoms, dessen Koeffizienten wiederum durch die Komponenten des Vektors p gegeben sind. Wir fassen die oben kennengelernten Befehle in Tabelle 1.1 noch einmal zusammen: in dieser bezeichnet x einen Vektor mit Abszissenwerten,

1.4 Reelle Funktionen

19

w¨ahrend p, p1 und p2 Vektoren sind, die die Koeffizienten der Polynome P , P1 und P2 enthalten. Tabelle 1.1. Die wichtigsten MATLAB-Befehle zu Polynomen

y=polyder(p)

Ergebnis y = Werte von P (x) z = Wurzeln von P , so daß P (z) = 0 p = Koeffizienten des Polynoms P1 P2 q = Koeffizienten von Q, r = Koeffizienten von R so daß P1 = QP2 + R y = Koeffizienten von P
(x)

y=polyint(p)

y = Koeffizienten von

Befehl y=polyval(p,x) z=roots(p) p=conv(p1 ,p2 ) [q,r]=deconv(p1 ,p2 )

x

P (t) dt 0

Der Befehl polyfit erm¨oglicht die Berechnung der n + 1 Koeffizienten eines Polynoms p vom Grad n, wenn man die Werte des Polynoms p in n + 1 verschiedenen Punkten kennt (siehe Abschnitt 3.1.1). 1.4.3 Integration und Differentiation Die zwei folgenden Resultate sind fundamental f¨ ur die Integral- und Differentialrechnung, wir werden sie in diesem Buch noch ¨ ofters gebrauchen: 1. der Hauptsatz der Differential- und Integralrechnung: falls f eine stetige Funktion im Intervall [a, b) ist, dann ist x f (t) dt

F (x) = a

eine differenzierbare Funktion, Stammfunktion von f genannt, und erf¨ ullt ∀x ∈ [a, b): F
(x) = f (x); 2. der erste Mittelwertsatz der Integralrechnung: falls f eine stetige Funktion im Intervall [a, b) ist und x1 , x2 ∈ [a, b), dann ∃ξ ∈ (x1 , x2 ), so daß 1 f (ξ) = x2 − x1

x2 f (t) dt. x1

polyfit

20

1 Was man wissen sollte

Auch wenn eine Stammfunktion existiert, kann es oft schwierig oder unm¨oglich sein, sie zu berechnen. So spielt es zum Beispiel keine Rolle, ob wir wissen, daß die Stammfunktion von 1/x gleich ln |x| ist, wenn wir den Logarithmus dann nicht effektiv berechnen k¨onnen. In Kapitel 4 werden wir Approximationsverfahren kennenlernen, mit denen wir das Integral einer stetigen Funktion mit gew¨ unschter Genauigkeit berechnen k¨onnen, ohne ihre Stammfunktion zu kennen. Wir wollen daran erinnern, daß eine Funktion f , definiert auf einem Intervall [a, b], im Punkt x ¯ ∈ (a, b) ableitbar oder differenzierbar ist, falls der folgende Grenzwert existiert und endlich ist: f (¯ x + h) − f (¯ x) . h→0 h

x) = lim f
(¯

(1.9)

Die geometrische Interpretation der Ableitung als Steigung der Tangente der Funktion f in x ¯ spielt eine wichtige Rolle in der Herleitung des Newton-Verfahrens zur Approximation der Wurzeln von f . Wir sagen, daß eine auf dem ganzen Intervall [a, b] stetig differenzierbare Funktion ort. Im allgemeinen sagt man, eine bis zur Ordzum Raum C 1 ([a, b]) geh¨ nung p (ein positives Ganzes) stetig differenzierbare Funktion geh¨ort zu ort eine nur stetige Funktion zu C 0 ([a, b]). C p ([a, b]). Im speziellen geh¨ Ein weiteres Ergebnis aus der Analysis, das wir oft verwenden werden, ist der Mittelwertsatz , der besagt: falls f ∈ C 1 ([a, b]), dann existiert ein Punkt ξ ∈ (a, b), so daß f
(ξ) =

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

Schließlich wollen wir daran erinnern, daß eine Funktion mit bis zur Ordnung n + 1 stetigen Ableitungen in x0 in einer Umgebung von x0 durch das sogenannte Taylor-Polynom vom Grad n im Punkt x0 approximiert werden kann: Tn (x) = f (x0 ) + (x − x0 )f
(x0 ) + . . . +

=

n  (x − x0 )k k=0

diff int taylor

syms

k!

1 (x − x0 )n f (n) (x0 ) n!

f (k) (x0 ).

In MATLAB kann man mit den Befehlen diff,int und taylor aus der Toolbox symbolic analytisch die Ableitung, das unbestimmte Integral (also die Stammfunktion) und das Taylor-Polynom von einfachen Funktionen berechnen. Haben wir den Ausdruck der Funktion, die man manipulieren will, in der Zeichenkette f gespeichert, dann berechnet diff(f,n) die n-te Ableitung, int(f) das Integral und taylor(f,x,n+1) das Taylor-Polynom vom Grad n in einer Umgebung von x0 = 0. Die Variable x muß mit dem Befehl syms x symbolisch

1.5 Irren ist nicht nur menschlich

21

Abb. 1.5. Graphische Ober߬ ache von funtool

deklariert werden. Auf diese Weise kann sie algebraisch manipuliert werden, ohne ausgewertet zu werden. Nehmen wir zum Beispiel an, wir wollen die Ableitung, das unbestimmte Integral und das Taylor-Polynom f¨ unfter Ordnung der Funktion f (x) = (x2 + 2x + 2)/(x2 − 1) berechnen. Dazu gen¨ ugen folgende Befehle: >> f = ’(xˆ2+2*x+2)/(xˆ2-1)’; >> syms x >> diff(f) (2*x+2)/(xˆ2-1)-2*(xˆ2+2*x+2)/(xˆ2-1)ˆ2*x >> int(f) x+5/2*log(x-1)-1/2*log(1+x) >> taylor(f,x,6) -2-2*x-3*xˆ2-2*xˆ3-3*xˆ4-2*xˆ5 Mit dem Befehl simple kann man die von diff, int und taylor erzeugten Ausdr¨ ucke vereinfachen. Mit dem Befehl funtool kann man schließlich u ¨ber die in Abbildung 1.5 dargestellte graphische Oberfl¨ache Funktionen symbolisch manipulieren und deren wichtigste Eigenschaften untersuchen. Siehe Aufgaben 1.6–1.7.

1.5 Irren ist nicht nur menschlich W¨ahrend es im Lateinischen heißt errare humanum est“, m¨ ussen wir f¨ ur ” das Wissenschaftliche Rechnen eingestehen, daß Irren unvermeidbar ist.

simple funtool

22

1 Was man wissen sollte

Wie wir n¨amlich gesehen haben, verursacht die bloße Darstellung reeller Zahlen am Computer bereits Fehler. Wir m¨ ussen also versuchen, nicht Fehler zu vermeiden, sondern mit ihnen zu leben und sie unter Kontrolle zu halten. Im allgemeinen k¨ onnen wir bei der Approximation und L¨osung eines physikalischen Problems verschiedene Stufen von Fehlern unterscheiden (siehe Abbildung 1.6). xp h em PP x

T

MP

x=

ec

φ(t)dt 0

NP et

ea xn =

φ(tk )αk k

Abb. 1.6. Verschiedene Arten von Fehlern im Laufe einer Berechnung

Auf h¨ochster Stufe stehen die Fehler em , die man begeht, wenn man die physikalische Realit¨ at (PP steht f¨ ur physikalisches Problem und xp h ist dessen L¨osung) durch ein mathematisches Modell (MP, dessen L¨osung x ist) ersetzt. Die Anwendbarkeit des mathematischen Modells wird durch diese Fehler begrenzt, diese entziehen sich n¨amlich der Kontrolle des Wissenschaftlichen Rechnens. Das mathematische Modell (zum Beispiel ausgedr¨ uckt durch ein Integral wie in Abbildung 1.6, durch eine algebraische Gleichung, eine Differentialgleichung oder ein lineares oder nichtlineares System) ist im allgemeinen nicht analytisch l¨ osbar. Dessen L¨osung mittels Computeralgorithmen f¨ uhrt dann zu Rundungsfehlern, die sich fortpflanzen k¨onnen. Diese Fehler bezeichnen wir mit ea . Zu diesen kommen noch weitere Fehler dazu, denn jede Operation im mathematischen Modell, die einen Grenz¨ ubergang erfordert, kann ja am Computer nicht exakt durchgef¨ uhrt werden, sondern nur angen¨ ahert werden. Denken wir etwa an die Berechnung der Summe einer Reihe. Diese k¨onnen wir nur ann¨ahern, indem wir die unendliche Reihe nach bereits endlich vielen Gliedern abbrechen. Wir m¨ ussen also ein numerisches Problem N P einf¨ uhren, dessen L¨osung xn sich um einen Fehler et von x unterscheidet, der Abbruchfehler

1.5 Irren ist nicht nur menschlich

23

(truncation error) genannt wird. Diese Fehler treten in mathematischen Problemen endlicher Dimension (wie zum Beispiel der L¨osung eines linearen Systems) nicht auf. Die Fehler ea und et ergeben zusammen den Berechnungsfehler (computational error) ec , der in unserem Interesse steht. Wenn wir mit x die exakte L¨ osung des mathematischen Modells und mit x  die numerische L¨ osung bezeichnen, ergibt sich der absolute Rechenfehler aus eabs = |x − x |, c w¨ahrend der relative (falls x
= 0) erel |/|x| c = |x − x ist, wobei | · | der Absolutbetrag (oder ein anderes Maß je nach der Bedeutung von x) ist. Ein numerischer Prozeß besteht im allgemeinen in der Approximation eines mathematischen Modells in Funktion eines positiven Diskretisierungsparameters h. Falls nun der numerische Prozeß die L¨osung des mathematischen Modells liefert, wenn h gegen 0 strebt, dann sagen wir, daß der numerische Prozeß konvergent ist. Falls der absolute oder relative Fehler in Funktion von h durch ec ≤ Chp

(1.10)

beschr¨ankt ist, wobei C eine von h und p unabh¨angige (im allgemeinen ganze) Zahl ist, dann sagen wir, daß das Verfahren konvergent von der Ordnung p ist. Oft kann man das Symbol ≤ sogar durch das Symbol  ersetzen, und zwar falls neben der oberen Schranke (1.10) auch eine untere Schranke C
hp ≤ ec existiert, wobei C
eine andere Konstante (≤ C) unabh¨angig von h und p ist. Beispiel 1.1 Approximieren wir die Ableitung einer Funktion f in einem Punkt x ¯ mit dem Inkrement (1.9). Falls f in x ¯ differenzierbar ist, strebt x) durch das Inkrement gemacht der Fehler, den wir durch Ersetzen von f
(¯ haben, gegen 0, falls h gegen 0 geht. Wie wir in Abschnitt 4.1 sehen werden, kann dieser nur dann durch Ch nach oben abgesch¨ atzt werden, falls f ∈ C 2 in einer Umgebung von x ¯.

In unseren Konvergenzuntersuchungen werden wir oft Graphen lesen m¨ ussen, die den Fehler als Funktion von h auf logarithmischer Skala wiedergeben, auf der Abszissenachse log(h) und auf der Ordinatenachse log(ec ). Der Vorteil dieser Darstellung ist leicht einzusehen: falls ec  Chp , dann ist log ec  log C + p log h. Folglich ist p in logarithmischer Skala gleich der Steigung der Geraden log ec , und falls wir nun zwei Verfahren vergleichen wollen, hat jenes mit der Geraden mit gr¨oßerer Steigung die h¨ ohere Ordnung. Um in MATLAB Graphen in logarithmischer Skala zu zeichnen, gen¨ ugt der Befehl loglog(x,y), wobei

24

loglog

1 Was man wissen sollte

x und y die Vektoren sind, die die Abszissen- bzw. Ordinatenwerte der darzustellenden Daten enthalten. In Abbildung 1.7 sind die zu zwei verschiedenen Verfahren geh¨orenden Graphen des Fehlerverlaufs dargestellt. Jenes in durchgezogener Linie ist erster, jenes in unterbrochener Linie zweiter Ordnung. 4

10 2

10 0

10 −2

10

−4

10

1 −6

10

1 −8

10 10

−10

−12

10 10

2 −14

−16

1

10 10

10

10

−4

−6

−8

−10

−12

10

10

0

−2

10

10

Abb. 1.7. Graphen in logarithmischer Skala

Eine andere M¨ oglichkeit zur Bestimmung der Konvergenzordnung ur gewisse Werte hi , mit eines Verfahrens, f¨ ur das man den Fehler ei f¨ i = 1, . . . , N , des Diskretisierungsparameters kennt, beruht auf der Anangig von i. Dann kann man p u nahme ei  Chpi mit C unabh¨ ¨ber die Werte pi = log(ei /ei−1 )/ log(hi /hi−1 ), i = 2, . . . , N

(1.11)

absch¨atzen. Eigentlich ist der Fehler ja eine nicht berechenbare Gr¨oße, die von der Unbekannten des Problems selbst abh¨angt. Deshalb m¨ ussen wir berechenbare Gr¨ oßen einf¨ uhren, die zur Absch¨atzung des Fehlers verwendet werden k¨ onnen, sogenannte Fehlersch¨atzer. In den Abschnitten 2.2, 2.3 und 4.3 werden wir Beispiele f¨ ur diese kennenlernen. 1.5.1 Sprechen wir u ¨ ber Kosten Im allgemeinen wird ein Problem am Computer u ¨ber einen Algorithmus gel¨ost, also einer Vorschrift in Form eines endlichen Textes, die in eindeutiger Weise alle zur L¨ osung des Problems notwendigen Schritte pr¨azisiert.

1.5 Irren ist nicht nur menschlich

25

Unter dem Rechenaufwand (computational costs) eines Algorithmus verstehen wir normalerweise die Anzahl an arithmetischen Operationen, die f¨ ur dessen Ausf¨ uhrung notwendig sind. Oft wird die Geschwindigkeit eines Computers u ¨ber die maximale Anzahl von Floating-PointOperationen, die er in einer Sekunde ausf¨ uhren kann, in Flops und seinen Vielfachen (Megaflops gleich 106 f lops, Gigaflops gleich 109 F lops, Teraflops gleich 1012 F lops) gemessen. Die zur Zeit schnellsten Computer k¨onnen mehr als 136 Teraflops verarbeiten. In MATLAB war es bis Version 5.3 m¨oglich, mit dem Befehl flops die ungef¨ahre Zahl der von einem Programm durchgef¨ uhrten Floating-Point-Operationen zu erfahren. Seit Version 6 ist dies nicht mehr m¨ oglich. Im allgemeinen muß man die Anzahl arithmetischer Operationen nicht kennen, es gen¨ ugt, die Gr¨ oßenordnung in Funktion eines Parameters d, der an die Dimension des zu l¨ osenden Problems gebunden ist, zu quantifizieren. So sagen wir, daß ein Algorithmus konstante Komplexit¨at hat, falls er eine von d unabh¨ angige, also O(1) Anzahl von Operationen erfordert, lineare, falls er O(d) Operationen und allgemein polynomiale Komplexit¨at hat, falls er O(dm ) Operationen erfordert, mit positivem Ganzen m. Einige Algorithmen haben exponentielle (O(cd ) Operationen) oder faktorielle Komplexit¨ at (O(d!) Operationen). Wir erinnern daran, daß das Symbol O(dm ) (das gelesen wird als groß O von dm“) f¨ ur verh¨ alt sich f¨ ur große d wie eine Konstante mal ” ” dm“ steht. Beispiel 1.2 (das Matrix-Vektor Produkt) Sei A eine quadratische Matrix der Dimension n; wir wollen den rechnerischen Aufwand eines gew¨ ohnlichen Algorithmus zur Berechnung des Produkts Av mit v ∈ Rn bestimmen. Die Berechnung der j-ten Komponente des Produktes ist gegeben durch aj1 v1 + aj2 v2 + . . . + ajn vn und erfordert die Bildung von n Produkten und n−1 Summen. Man ben¨ otigt also n(2n − 1) Operationen zur Berechnung aller n Komponenten. Dieser Algorithmus ben¨ otigt also O(n2 ) Operationen und hat somit quadratische Komplexit¨ at bez¨ uglich des Parameters n. Mit derselben Vorgangsweise sind O(n3 ) Operationen zur Berechnung des Produkts zweier Matrizen der Ordnung n n¨ otig. Es gibt allerdings einen Algorithmus, Algorithmus von Strassen otigt, und einen anderen, der genannt, der nur“ O(nlog2 7 ) Operationen ben¨ ” auf Winograd und Coppersmith zur¨ uckgeht und nur O(n2.376 ) Operationen ben¨ otigt. Beispiel 1.3 (die Berechnung der Determinante) Wie wir bereits gesehen haben, kann die Determinante einer Matrix der Dimension n mit der Rekursionsformel (1.8) berechnet werden.

flops

26

1 Was man wissen sollte

Man kann zeigen, daß der zugeh¨ orige Algorithmus faktorielle Komplexit¨ at bez¨ uglich n hat, also O(n!) Operationen ben¨ otigt. Man bedenke, daß derart komplexe Algorithmen selbst auf den zur Zeit schnellsten Computern nur f¨ ur kleine n ausgef¨ uhrt werden k¨ onnen. Ist zum Beispiel n = 24, so w¨ urde ein Rechner, der ein Petaflop (also 1015 Operationen in der Sekunde) durchf¨ uhren k¨ onnte, etwa 20 Jahre f¨ ur diese Berechnung ben¨ otigen. Wir sehen also, daß die alleinige Steigerung der Rechenleistung noch nicht bedeutet, daß jedes Problem gel¨ ost werden kann; effizientere numerische Verfahren m¨ ussen untersucht und angewandt werden. Zum Beispiel gibt es einen rekursiven Algorithmus, der die Berechnung der Determinante auf die Berechnung von Matrizenprodukten zur¨ uckf¨ uhrt, der nur mehr eine Komplexit¨ at ahnten Algorithmus von O(nlog2 7 ) Operationen hat, falls man den eben erw¨ von Strassen anwendet (siehe [BB96]).

cputime etime

Die Anzahl der von einem Algorithmus ben¨otigten Operationen ist also ein wichtiger Parameter bei dessen theoretischer Untersuchung. Sobald aber ein Algorithmus in einem Programm implementiert ist, k¨onnen andere Faktoren mit eine Rolle spielen, die die Effektivit¨at beeinflussen k¨onnen (wie zum Beispiel der Zugriff auf den Speicher). Ein Maß f¨ ur die Geschwindigkeit eines Programmes ist die Zeit, die f¨ ur dessen Ausf¨ uhrung ben¨ otigt wird, also die CPU-Zeit (CPU steht f¨ ur central processing unit). Es geht also um die Zeit, die vom Prozessor des Rechners ben¨otigt wird, um ein bestimmtes Programm auszuf¨ uhren, ohne die Wartezeit zu ber¨ ucksichtigen, die f¨ ur das Laden von Daten (die sogenannte Input-Phase) oder zum Speichern der erhaltenen Resultate (Output-Phase) vergeht. Die Zeit hingegen, die vom Beginn der Ausf¨ uhrung bis zum Ende des Programms vergeht, wird Elapsed-Time genannt. In MATLAB wird die CPU-Zeit mit dem Befehl cputime gemessen, die Elapsed-Time (stets in Sekunden) mit dem Befehl etime. Beispiel 1.4 Messen wir die Ausf¨ uhrzeit (elapsed time) f¨ ur die Berechnung des Produktes einer quadratischen Matrix mit einem Vektor. Dazu f¨ uhren wir folgende Befehle aus: >> n = 4000; step = 50; A = rand(n,n); v = rand(n); T = [ ]; sizeA = [ ]; count = 1; >> for k = 50:step:n AA = A(1:k,1:k); vv = v(1:k)’; t = cputime; b = AA*vv; tt = cputime - t; T = [T, tt]; sizeA = [sizeA,k]; count = count + 1; end

1.6 Einige Worte zu MATLAB

27

Mit dem Befehl a:step:b, der in der for-Schleife auftritt, werden alle Zahlen der Form a+step*k mit ganzem k von 0 bis kmax, f¨ ur die a+step*kmax kleiner gleich b, erzeugt (in unserem Fall a=50, b=4000 und step=50). Der Befehl rand(n,m) initialisiert eine Matrix n×m, deren Elemente Zufallszahlen sind. Schließlich werden in den Komponenten des Vektors T die CPU-Zeiten zur Ausf¨ uhrung eines jeden Matrix-Vektor-Produkts gespeichert. cputime gibt die von MATLAB zur Ausf¨ uhrung jedes einzelnen Prozesses ben¨ otigte Gesamtzeit zur¨ uck. Die zur Ausf¨ uhrung eines einzelnen Prozesses ben¨ otigte Zeit ist also die Differenz zwischen der aktuellen CPU-Zeit und jener vor Start des gerade betrachteten Prozesses und wird in unserem Fall in der Variablen t gespeichert. Der Graph in Abbildung 1.8 (erhalten mit dem Befehl plot(sizeA,T,’o’)) zeigt, wie die CPU-Zeit etwa proportional zum Quadrat der Dimension n der Matrix steigt.

0.5

0.4

0.3

0.2

0.1

0 0

500

1000

1500

2000

2500

3000

3500

4000

Abb. 1.8. Zur Ausf¨ uhrung eines Matrix-Vektor-Produkts ben¨ otigte CPU-Zeit (in Sekunden) in Funktion der Dimension n der Matrix auf einem PC mit 2.53 GHz

1.6 Einige Worte zu MATLAB MATLAB ist eine Programmumgebung f¨ ur Wissenschaftliches Rechnen und Visualisierung, geschrieben in der Programmiersprache C und vertrieben von The MathWorks (siehe www.mathworks.com). Der Name steht f¨ ur MATrix LABoratory, denn urspr¨ unglich wurde das Programm dazu entwickelt, sofort auf speziell f¨ ur die Matrizenrechnung entwickelte Softwarepakete zugreifen zu k¨ onnen. Ist MATLAB installiert (die ausf¨ uhrende Programmdatei befindet sich im allgemeinen im Unterverzeichnis bin des Hauptverzeichnisses matlab), hat man nach dessen Ausf¨ uhrung Zugang zu einer Arbeitsumuhren wir nun also gebung, die vom Prompt >> charakterisiert wird. F¨ MATLAB aus, erscheint

>>

28

1 Was man wissen sollte

Copyright 1984-2004 The MathWorks, Inc. Version 7.0.1.24704 (R14) Service Pack 1 September 13, 2004 Using Toolbox Path Cache. Type ”help toolbox path cache” for more info. To get started, select ”MATLAB Help” from the Help menu. >>

quit exit

ans

Alles, was wir nach dem Prompt schreiben, wird nach Dr¨ ucken der Eingabetaste Enter (oder Return) sofort von MATLAB interpretiert.1 MATLAB u uft nun, ob unsere Eingabe einer definierten Va¨berpr¨ riablen oder einem MATLAB-Programm oder -Befehl entspricht. Schei¨ tert diese Uberpr¨ ufung, gibt MATLAB eine Fehlermeldung aus. Anderenfalls wird der Befehl ausgef¨ uhrt, der unter Umst¨anden einen Output erzeugt. In beiden F¨ allen bietet uns das System am Ende wieder den Prompt an und wartet auf eine neue Eingabe. Das Programm wird mit dem Befehl quit (oder exit) und Enter beendet. Von nun an verstehen wir unter dem Ausf¨ uhren eines Befehls immer auch dessen Best¨atigung mit der Enter -Taste und verwenden die Ausdr¨ ucke Befehl, Funktion oder Programm in ¨ aquivalenter Weise. Ein spezieller Fall ergibt sich, falls der eingegebene Befehl eine in MATLAB elementar definierte Struktur ist (etwa Zahlen oder durch einfache Anf¨ uhrungszeichen definierte Zeichenketten). Diese werden sour Answer ) fort erkannt und im Output in der Default-Variablen ans (f¨ ausgegeben. Geben wir zum Beispiel die Zeichenkette ’Haus’ ein, erhalten wir >> ’Haus’ ans = Haus

=

Geben wir jetzt eine andere Zeichenkette oder Zahl ein, nimmt ans diesen neuen Wert an. Um diesen Output zu unterdr¨ ucken, gen¨ ugt es, nach der Variablen oder dem Befehl einen Strichpunkt zu setzen. So erscheint nach der Ausf¨ uhrung von ’Haus’; lediglich der Prompt, der Wert der Variablen wird aber wieder der Variablen ans zugewiesen. Im allgemeinen werden in MATLAB Variablen mit dem Befehl = zugewiesen. Wollen wir zum Beispiel die Zeichenkette ’Haus’ der Variablen a zuweisen, schreiben wir einfach 1

Folglich muß ein MATLAB-Programm nicht wie in anderen Programmiersprachen, etwa Fortran oder C, kompiliert werden, auch wenn MATLAB den Compiler mcc enth¨ alt, um Programme schneller ausf¨ uhren zu k¨ onnen.

1.6 Einige Worte zu MATLAB

29

>> a=’Haus’; Wie wir sehen, muß der Typ der Variablen a im Gegensatz zu anderen Programmiersprachen nicht deklariert werden, MATLAB erledigt das f¨ ur uns automatisch und dynamisch. Dadurch k¨onnen derselben Variablen nach der Reihe Werte verschiedenen Typs zugewiesen werden. Wollen wir etwa der vorhin initialisierten Variablen a jetzt die Zahl 5 zuweisen, m¨ ussen wir nichts anderes schreiben als a=5. Diese extrem einfache Bedienbarkeit hat aber ihren Preis. Wir wollen zum Beispiel eine Variable quit nennen und sie gleich 5 setzen. Wir haben also eine Variable erzeugt, die genauso heißt wie der MATLAB-Befehl quit; dadurch k¨onnen wir den Befehl quit nicht mehr ausf¨ uhren, da MATLAB f¨ ur dessen Interpretation zun¨ achst u uft, ob es sich dabei um eine Va¨berpr¨ riable handelt, und erst dann, ob es sich um einen vordefinierten Befehl handelt. Wir m¨ ussen es also unbedingt vermeiden, Variablen oder Programmen bereits in MATLAB vordefinierte Variablen oder Programme zuzuweisen. Um wieder auf den Befehl quit zugreifen zu k¨onnen, kann man mit clear, gefolgt vom Namen der Variablen (in diesem Fall quit), die aktuelle Definition der Variablen wieder l¨ oschen. Mit dem Befehl save werden alle Variablen der aktuellen Sitzung (der sogenannte Base-Workspace) in der bin¨ aren Datei matlab.mat gespeichert. Analog dazu k¨ onnen wir mit dem Befehl load alle in der bin¨aren Datei matlab.mat gespeicherten Variablen wiederherstellen. Der Dateiname, unter dem wir die Variablen speichern (aus dem wir sie laden), kann auch vom Benutzer definiert werden, indem man nach dem Befehl save (load) den Dateinamen bestimmt. Wollen wir schließlich nur einige Variablen, etwa v1, v2 und v3 in eine Datei mit Namen area.mat speichern, gen¨ ugt der Befehl save area v1 v2 v3. onnen wir alle verf¨ ugbaren Befehle und vorMit dem Befehl help k¨ definierten Variablen, auch die der sogenannten Toolboxes, Sammlungen speziellerer Befehle, ansehen. Unter diesen wollen wir an die elementaren Funktionen Sinus (sin(a)), Cosinus (cos(a)), Quadratwurzel (sqrt(a)) sowie die Exponentialfunktion (exp(a)) erinnern. Es gibt außerdem spezielle Zeichen, die nicht im Namen einer Variablen oder eines Befehls vorkommen d¨ urfen, etwa die elementaren Operatoren f¨ ur Addition, Subtraktion, Multiplikation und Division (+, -, * und /), die logischen Operatoren and (&), or (|), not (˜), die Verh¨altnisoperatoren gr¨oßer (>), gr¨ oßer oder gleich (>=), kleiner (= < > if a~= 0 sq = sqrt(b ∗ b − 4 ∗ a ∗ c); x(1) = 0.5 ∗ (−b + sq)/a; x(2) = 0.5 ∗ (−b − sq)/a; elseif b~= 0 x(1) = −c/b; (1.12) elseif c~= 0 ogliche Gleichung
); disp(
Unm¨ else at
) disp(
Die eingegebene Gleichung ist eine Identit¨ end

for while

Beachte, daß MATLAB die Gesamtkonstruktion erst ausf¨ uhrt, sobald sie mit dem Statement end abgeschlossen wird. In MATLAB stehen uns zwei Arten von Schleifen zur Verf¨ ugung: for (¨ahnlich dem do in Fortran oder dem for in C) und while. Eine for-Schleife wiederholt eine Anweisung f¨ ur alle in einem Zeilenvektor

1.6 Einige Worte zu MATLAB

31

enthalten Indizes. Um etwa die ersten sechs Elemente einer FibonacciFolge {fi = fi−1 + fi−2 , i ≥ 2} mit f1 = 0 und f2 = 1 zu berechnen, kann man folgende Befehle verwenden >> f(1) = 0; f(2) = 1; >> for i = [3 4 5 6] f(i) = f(i-1) + f(i-2); end Der Strichpunkt wird auch dazu verwendet, mehrere MATLAB-Befehle in einer Zeile voneinander zu trennen. Beachte, daß die for-Anweisung auch durch die ¨aquivalente Anweisung >> for i = 3:6 ersetzt werden kann. Die while-Schleife hingegen wird solange ausgef¨ uhrt, bis eine logische Anweisung erf¨ ullt ist. So sind zum Beispiel auch folgende Anweisungen f¨ ur obiges Problem m¨ oglich >> f(1) = 0; f(2) = 1; k = 3; >> while k > einfach den Befehl equation einzugeben. Im folgenden geben wir zwei Anwendungsbeispiele: >> a = 1; b = 1; c = 1; >> equation ans = -0.5000 + 0.8660i -0.5000 - 0.8660i

path

32

1 Was man wissen sollte

>> a = 0; b = 1; c = 1; >> equation ans = -1 Da wir keine Input/Output-Schnittstelle haben, sind alle im Script verwendeten Unbekannten Teil der aktuellen Arbeitssitzung und werden daher auch erst nach der expliziten Anweisung clear gel¨oscht. Diese Eigenschaft ist nicht sehr befriedigend, sobald man komplizierte Programme mit vielen tempor¨ aren Variablen und wenigen Inputund Output-Variablen erstellen m¨ ochte. Nach Programmende sind die Output-Variablen auch die einzigen, die man noch behalten oder abspeichern m¨ ochte. Aus diesem Grund greift man auf eine viel flexiblere Programmform zur¨ uck, auf die sogenannte Function. Eine Function ist wieder in einem m-File definiert, zum Beispiel mit Namen name.m, besitzt aber eine genau festgelegte Input-/Output-Schnittstelle, eingef¨ uhrt mit dem Befehl function function [out1,...,outn]=name(in1,...,inm) wobei out1,...,outn die Output-Variablen und in1,...,inm die InputVariablen sind. Die folgende Datei det23.m ist ein Beispiel f¨ ur eine Function; in ihr wird eine neue Function, n¨ amlich det23, definiert, die die Determinante einer Matrix der Dimension 2 oder 3 nach der Formel aus Abschnitt 1.3 berechnet: function [det]=det23(A) %DET23 berechnet die Determinante einer quadratischen Matrix % der Dimension 2 oder 3 [n,m]=size(A); if n==m if n==2 det = A(1,1)*A(2,2)-A(2,1)*A(1,2); elseif n == 3 det = A(1,1)*det23(A[2,3],[2,3]))-A(1,2)*det23(A([2,3],[1,3]))+... A(1,3)*det23(A[2,3],[1,2])); else disp(’ Nur (2x2)- oder (3x3)-Matrizen!’); end else disp(’ Nur quadratische Matrizen! ’); end return ... %

Die Zeichen ... bedeuten, daß eine Anweisung in der n¨achsten Zeile fortgesetzt wird, das Zeichen % kommentiert eine Zeile aus. Die Anweisung A([i,j],[k,l]) erlaubt die Konstruktion einer (2 × 2)-Matrix,

1.6 Einige Worte zu MATLAB

33

deren Elemente im Schnitt der i-ten und j-ten Zeilen mit den k-ten und l-ten Spalten der Ausgangsmatrix A liegen. Sobald man eine Function aufruft, erzeugt MATLAB einen lokalen Arbeitsbereich (den Function’s Workspace), in dem alle innerhalb der Function aufgerufenen Variablen angelegt werden. Folglich k¨onnen sich die in einer Function enthaltenen Anweisungen nicht auf eine im BaseWorkspace deklarierte Variable beziehen, außer sie werden der Funktion als Input u ¨bergeben.2 Alle in einer Function verwendeten Variablen sind verloren, sobald die Funktion beendet ist, außer sie geh¨oren zu den Output-Parametern. Normalerweise ist eine Function beendet, sobald die letzte Anweisung abgearbeitet wurde. Mit einem return Statement kann man die Funktion schon fr¨ uher verlassen. Um etwa den Wert α = 1.6180339887 . . . , den Grenzwert f¨ ur k → ∞ des Verh¨ altnisses fk /fk−1 von Fibonacci-Folgen zu approximieren, und zwar indem wir solange iterieren, bis sich zwei aufeinanderfolgende Br¨ uche um weniger als 10−4 unterscheiden, k¨onnen wir folgende Function konstruieren function [golden,k]=fibonacci f(1) = 0; f(2) = 1; goldenold = 0; kmax = 100; tol = 1.e-04; for k = 3:kmax f(k) = f(k-1) + f(k-2); golden = f(k)/f(k-1); if abs(golden - goldenold) > [alpha,niter]=fibonacci alpha = 1.61805555555556 niter = 14 Nach 14 Iterationen gibt die Function also einen Wert zur¨ uck, der mit dem exakten α die f¨ unf ersten signifikanten Stellen gemeinsam hat. 2

Es gibt noch eine dritte Art von Workspace, den Global Workspace, in dem alle global definierten Variablen gespeichert werden. Diese Variablen k¨ onnen auch dann in einer Function verwendet werden, wenn sie nicht Input-Parameter sind.

return

34

1 Was man wissen sollte

Die Anzahl der Ein- und Ausgabeparameter einer MATLAB-Function ist beliebig. Die Function fibonacci k¨ onnen wir zum Beispiel folgendermaßen ab¨andern function [golden,k]=fibonacci(tol,kmax) if nargin == 0 kmax = 100; tol = 1.e-04; % default Werte elseif nargin == 1 kmax = 100; % default Wert fuer kmax end f(1) = 0; f(2) = 1; goldenold = 0; for k = 3:kmax f(k) = f(k-1) + f(k-2); golden = f(k)/f(k-1); if abs(golden - goldenold) > [alpha,niter]=fibonacci(1.e-6,200) alpha = 1.61803381340013 niter = 19 Durch die Wahl einer kleineren Toleranz f¨ ur das Abbruchkriterium haben wir eine neue Approximation berechnet, die mit dem exakten α gar acht signifikante Ziffern gemeinsam hat. Die Function nargin kann auch außerhalb einer Function verwendet werden, um die maximale Anzahl von Input-Parametern einer Function abzufragen. Hier ein Beispiel: >> nargin(’fibonacci’) ans = 2

inline

Bemerkung 1.2 (inline functions) Der Befehl inline, dessen einfachste Syntax g=inline(expr,arg1,arg2,...,argn) ist, deklariert eine Function g, die von den Zeichenketten arg1,arg2,...,argn abh¨ angt. Die Zeichenkette

1.8 Aufgaben

35

expr enth¨ alt den Ausdruck von g. So deklariert g=inline(’sin(r)’,’r’) die Funktion g(r) = sin(r). In der abgek¨ urzten Schreibweise g=inline(expr) wird implizit angenommen, daß der Ausdruck expr nur von der Variablen x abh¨ angt. Ist eine Inline-Function einmal deklariert, so l¨ aßt sie sich auf jeder beliebigen Menge von Variablen mittels des Befehls feval auswerten. Um zum Beispiel g in den Punkten z=[0 1] auszuwerten, k¨ onnen wir schreiben. >> feval(’g’,z); Wie wir sehen, muß im Gegensatz zum Befehl eval mit feval der Variablenname (z) nicht notwendigerweise mit dem mit inline zugewiesenen symbolischen Namen (r) u ¨bereinstimmen.

Nach dieser kurzen Einleitung m¨ ochten wir dazu einladen, MATLAB mit Unterst¨ utzung des Help weiter zu erkunden. So erh¨alt man etwa mit dem Befehl help for nicht nur eine ausf¨ uhrliche Beschreibung dieser Anweisung, am Ende wird auch auf ¨ ahnliche Befehle (im Fall von for auf if, while, switch, break, end) verwiesen. Mit Help k¨onnen wir also fortw¨ahrend unsere MATLAB-Kenntnisse erweitern. Siehe Aufgaben 1.8–1.11.

1.7 Was wir nicht erw¨ ahnt haben Eine systematischere Behandlung der Floating-Point-Zahlen findet sich in [QSS02] oder in [Ueb97]. F¨ ur die Behandlung der rechnerischen Komplexit¨at und von Algorithmen im allgemeinen verweisen wir zum Beispiel auf [Pan92]. F¨ ur eine systematische Einf¨ uhrung in MATLAB verweisen wir den interessierten Leser auf das Handbuch von MATLAB [HH00] oder [Mat04], aber auch auf Spezialliteratur wie etwa [HLR01] oder [EKH02].

1.8 Aufgaben Aufgabe 1.1 Aus wie vielen Zahlen besteht die Menge F(2, 2, −2, 2)? Wie ur diese Menge? groß ist M f¨ Aufgabe 1.2 Zeige, daß die Menge F(β, t, L, U ) genau 2(β −1)β t−1 (U −L+1) Zahlen enth¨ alt. Aufgabe 1.3 Konstruiere in MATLAB eine obere und eine untere Dreiecksmatrix der Dimension 10 mit Eintr¨ agen 2 auf der Hauptdiagonalen und -3 auf der zweiten oberen und unteren Nebendiagonalen. Aufgabe 1.4 Welche MATLAB-Anweisungen sind notwendig, um die dritte und siebte Zeile bzw. die vierte und achte Spalte der in Aufgabe 1.3 konstruierten Matrix zu vertauschen?

36

1 Was man wissen sollte

Aufgabe 1.5 Zeige, daß folgende Vektoren in R4 linear unabh¨ angig sind: v1 = [0 1 0 1], v2 = [1 2 3 4], v3 = [1 0 1 0], v4 = [0 0 1 1]. Aufgabe 1.6 Gib folgende Funktionen in MATLAB ein und berechne mit der Toolbox f¨ ur symbolisches Rechnen deren erste und zweite Ableitungen und das unbestimmte Integral: √ g(x) = x2 + 1, f (x) = sin(x3 ) + cosh(x).

poly

Aufgabe 1.7 Sei ein Vektor v der Dimension n gegeben. Mit der Anweisung onnen wir die n + 1 Koeffizienten eines Polynoms vom Grad n c=poly(v) k¨ berechnen, dessen Koeffizient xn gleich 1 ist und dessen Nullstellen genau die in v gespeicherten Werte haben. Man wird erwarten, daß v = roots(poly(c)) ist. Versuche, roots(poly([1:n])) zu berechnen, wobei n von 2 bis 25 geht, und kommentiere die erhaltenen Ergebnisse. Aufgabe 1.8 Schreibe ein Programm, das folgende Folge berechnet I0 = In+1

1 (e − 1), e = 1 − (n + 1)In , f¨ ur n = 0, 1, . . . , 21.

ur n → ∞, kommentiere die erhaltenen Ergebnisse. Da wir wissen, daß In → 0 f¨ Aufgabe 1.9 Erkl¨ are das Verhalten der in MATLAB berechneten Folge (1.4). Aufgabe 1.10 Betrachten wir folgenden Algorithmus zur Berechnung von π: erzeuge n Paare (xk , yk ) von Zufallszahlen zwischen 0 und 1. Von diesen berechne die Anzahl m jener Punkte, die ins erste Viertel des Kreises mit Mittelpunkt im Ursprung und Radius 1 fallen. Offensichtlich ist π der Grenzwert der Folge πn = 4m/n. Schreibe ein Programm, das diese Folge berechnet und u ufe den Fehler f¨ ur steigende n. ¨berpr¨ Aufgabe 1.11 Schreibe ein Programm, das den Binomialkoeffizienten ( nk ) = n!/(k!(n − k)!) berechnet, wobei n und k nat¨ urliche Zahlen mit k ≤ n sind.

2 Nichtlineare Gleichungen

Ein sehr h¨aufig vorkommendes Problem im Wissenschaftlichen Rechnen ist die Berechnung der Nullstellen einer Funktion f oder der Wurzeln der Gleichung f (x) = 0. Im allgemeinen gibt es kein numerisches Verfahren, das die Nullstellen einer beliebigen Funktion in endlich vielen Schritten berechnet. In Abschnitt 1.4.1 haben wir etwa an einen Satz aus der Algebra erinnert, der ausschließt, daß die Nullstellen eines beliebigen Polynoms vom Grad h¨ oher als vier in endlich vielen Schritten berechnet werden k¨onnen. Die numerischen Verfahren zur L¨ osung dieses Problems sind also notwendigerweise iterativ. Ausgehend von einem oder mehreren geschickt gew¨ahlten Startwerten erzeugen diese Verfahren eine Folge von Werten x(k) , die unter geeigneten Annahmen gegen eine Nullstelle α der untersuchten Funktion f konvergieren. Problem 2.1 (Investmentfonds) Wir wollen die mittlere Zinsrate I eines Investmentfonds u ¨ber mehrere Jahre hinweg berechnen. Investieren wir zu Beginn jedes Jahres v Euro und nehmen wir an, am Ende des n-ten Jahres habe sich ein Betrag von M Euro angesammelt. Da M von I gem¨ aß folgender Relation abh¨ angt, n

1+I [(1 + I)n − 1] , I k=1 k¨ onnen wir schließen, daß I die Wurzel der nichtlinearen Gleichung 1+I [(1 + I)n − 1] f (I) = 0, wobei f (I) = M − v I M =v

(1 + I)k = v

ist. Zur L¨ osung dieses Problems siehe Beispiel 2.1.

Problem 2.2 (Zustandsgleichung eines Gases) Wir wollen das von einem Gas eingenommene Volumen V bei einer gegebenen Temperatur T und einem Druck p bestimmen. Die Zustandsgleichung, also die Gleichung, die p, V und T miteinander in Verh¨ altnis setzt, ist

38

2 Nichtlineare Gleichungen p + a(N/V )2 (V − N b) = kN T,

(2.1)

wobei a und b gasspezifische Koeffizienten sind, N ist die Anzahl der im Volumen V enthaltenen Molek¨ ule und k die sogenannte Boltzmann-Konstante. Wir m¨ ussen also eine nichtlineare Gleichung l¨ osen, deren Wurzel V ist. F¨ ur die L¨ osung dieses Problems siehe Aufgabe 2.2. Problem 2.3 (Statik) Betrachten wir das aus vier festen Achsen ai bestehende mechanische System in Abbildung 2.1; wir wollen in Abh¨ angigkeit des festen Winkels β den Winkel α zwischen den Achsen a1 und a2 berechnen. Indem wir von der Vektorgleichung a 1 − a 2 − a 3 − a4 = 0 ausgehen und feststellen, daß die Achse a1 stets auf der Abszissenachse liegen bleibt, k¨ onnen wir folgendes Verh¨ altnis zwischen β und α herleiten a2 + a22 − a23 + a24 a1 a1 , (2.2) cos(α) − cos(β − α) = − 1 cos(β) − 2a2 a4 a4 a2

ange der i-ten Achse bezeichnen. Diese Gleichung heißt wobei wir mit ai die L¨ Freudenstein-Gleichung und kann folgendermaßen umgeschrieben werden: f (α) = 0, wobei f (x) = (a1 /a2 ) cos(β) − (a1 /a4 ) cos(x) − cos(β − x) +(a21 + a22 − a23 + a24 )/(2a2 a4 ). Diese Gleichung kann analytisch nur f¨ ur bestimmte Werte von β gel¨ ost werden. Beachte außerdem, daß nicht f¨ ur alle Werte β eine L¨ osung existiert und, falls existent, eindeutig ist. F¨ ur deren L¨ osung im allgemeinen Fall, in dem β einen beliebigen Wert zwischen 0 und π annimmt, m¨ ussen wir ein numerisches Verfahren anwenden (siehe Aufgabe 2.9).

y a3

a2

a4 β

α

x a1 Abb. 2.1. Das System der vier Achsen aus Problem 2.3

2.1 Das Bisektionsverfahren

39

2.1 Das Bisektionsverfahren Sei f eine stetige Funktion in [a, b], die f (a)f (b) < 0 erf¨ ullt. Unter dieser Annahme hat f mindestens eine Nullstelle in (a, b). Nehmen wir der Einfachheit halber an, sie besitzt in diesem Intervall nur eine, die wir mit α bezeichnen. Anderenfalls ist es zum Beispiel anhand einer graphischen Untersuchung mit dem Befehl fplot immer m¨oglich, ein Intervall zu finden, in dem f nur eine Nullstelle besitzt. Die Strategie des Bisektionsverfahrens besteht darin, das gegebene Intervall zu teilen und jenes Teilintervall zu w¨ahlen, in dem f wiederum das Vorzeichen wechselt. Ist I (0) = (a, b) und I (k) das Teilintervall im k-ten Schritt, w¨ ahlen wir f¨ ur I (k+1) jenes Teilintervall von I (k) aus, an dessen Grenzen f das Vorzeichen wechselt. Durch diese Vorgangsweise geht man sicher, daß f¨ ur jedes auf diese Weise gefundene I (k) die Nullstelle α darin enthalten ist. Die Folge {x(k) } der Mittelpunkte dieser Teilintervalle I (k) wird unvermeidbar gegen α konvergieren, da die L¨ange der Teilintervalle f¨ ur k gegen unendlich gegen null strebt. y

I (0) f I (1)

a(0)

x(0)

x(1) x(2) b(0) x I (3) I (2)

Abb. 2.2. Einige Iterationen des Bisektonsverfahrens

Formalisieren wir diese Ideen, indem wir a(0) = a, b(0) = b, I (0) = (a(0) , b(0) ), x(0) = (a(0) + b(0) )/2 setzen. In einem beliebigen Schritt k ≥ 1 berechnet das Bisektionsverfahren das Teilintervall I (k) = (a(k) , b(k) ) des Intervalls I (k−1) = (a(k−1) , b(k−1) ) auf folgende Weise: Sei x(k−1) = (a(k−1) + b(k−1) )/2 gegeben, falls f (x(k−1) ) = 0, dann ist α = x(k−1) und das Verfahren bricht ab; anderenfalls

40

2 Nichtlineare Gleichungen

falls f (a(k−1) )f (x(k−1) ) < 0, setze a(k) = a(k−1) , b(k) = x(k−1) ; falls f (x(k−1) )f (b(k−1) ) < 0, setze a(k) = x(k−1) , b(k) = b(k−1) . In beiden F¨ allen definiert man x(k) = (a(k) + b(k) )/2 und erh¨oht k um eins. So erhalten wir zum Beispiel im in Abbildung 2.2 gezeigten Fall f (x) = x2 − 1, ausgehend von a(0) = −0.25 und b(0) = 1.25 I (0) I (1) I (2) I (3)

= (−0.25, 1.25), = (0.5, 1.25), = (0.875, 1.25), = (0.875, 1.0625),

x(0) x(1) x(2) x(3)

= 0.5, = 0.875, = 1.0625, = 0.96875.

Beachte, daß jedes der Intervalle I (k) die Nullstelle α = 1 enth¨alt. ¨ Uberdies konvergiert die Folge {x(k) } notwendigerweise gegen die Nullstelle α, da sich in jedem Schritt die Breite |I (k) | = b(k) − a(k) des Intervalls I (k) halbiert. Da also |I (k) | = (1/2)k |I (0) |, ist der Fehler im Schritt k gleich |e(k) | = |x(k) − α|
log2 ε

find sign

erf¨ ullt. Nat¨ urlich h¨angt diese Ungleichung nicht von f ab. Das Bisektionsverfahren ist im Programm 1 implementiert: fun ist eine Zeichenkette (oder eine Inline-Function), die die Funktion f bestimmt, a und b sind die Grenzen des Intervalls, in dem wir nach der Nullstelle suchen, tol ist die Toleranz ε und nmax ist die maximal erlaubte Anzahl an Iterationen. Falls fun eine Inline-Function (oder eine in einem m-file definierte Funktion) ist, erlaubt diese neben dem ersten Argument, das der unabh¨angigen Variablen entspricht, auch die Eingabe weiterer optionaler Argumente f¨ ur die Definition von f . Output-Parameter sind zero, die berechnete Nullstelle res, das Residuum bzw. der von f in zero angenommene Wert, und niter, die Anzahl der durchgef¨ uhrten Iterationen. Die Befehle find(fx==0) bzw. sign(fx) dienen zum Auffinden jener Indizes des Vektors fx, die Elementen gleich null entsprechen, bzw. zur Auswertung des Vorzeichens von fx.

2.1 Das Bisektionsverfahren

41

Programm 1 - bisection : Bisektionsverfahren function [zero,res,niter]=bisection(fun,a,b,tol,nmax,varargin) %BISECTION Findet die Nullstelle einer Funktion. % ZERO=BISECTION(FUN,A,B,TOL,NMAX) approximiert die Nullstelle der % Funktion FUN im Intervall [A,B] mit dem Bisektionsverfahren. FUN akzeptiert % als Input einen reellen Skalar x und gibt einen reellen Skalar zurueck. Falls % die Suche nach der Nullstelle von FUN fehlschlaegt, gibt das Programm eine % Fehlermeldung aus. FUN kann auch eine Inline-Function sein. % ZERO=BISECTION(FUN,A,B,TOL,NMAX,P1,P2,...) uebergibt die % Paramenter P1, P2,... der Funktion FUN(X,P1,P2,...). % [ZERO,RES,NITER]= BISECTION(FUN,...) gibt den Wert des Residuums % RES in ZERO und die Anzahl der zur Berechnung von ZERO benoetigten % Iterationen zurueck. x = [a, (a+b)*0.5, b]; fx = feval(fun,x,varargin{:}); if fx(1)*fx(3)>0 error(’ Kein Vorzeichenwechsel an den Intervallgrenzen [A,B]!’); elseif fx(1) == 0 zero = a; res = 0; niter = 0; return elseif fx(3) == 0 zero = b; res = 0; niter = 0; return end niter = 0; I = (b - a)*0.5; while I >= tol & niter nmax fprintf([’Das Bisektionsverfahren wurde abgebrochen, ohne’ ... ’die gewuenschte Toleranz zu erfuellen, weil die maximale Anzahl’ ... ’an Iterationen erreicht wurde\n’]); end zero = x(2); x = x(2); res = feval(fun,x,varargin{:}); return

42

2 Nichtlineare Gleichungen

Beispiel 2.1 L¨ osen wir mit dem Bisektionsverfahren Problem 2.1 unter der Annahme, daß v gleich 1000 Euro und nach 5 Jahren M gleich 6000 Euro ist. Aus dem Graph der Funktion f k¨ onnen wir mit den Anweisungen >> f=inline(’M-v*(1+I).*((1+I).ˆ5 - 1)./I’,’I’,’M’,’v’); >> fplot(f,[0.01,0.3],[],[],[],6000,1000) ablesen, daß f eine einzige Wurzel im Intervall (0.01, 0.1) hat, ungef¨ ahr gleich 0.06. F¨ uhren wir dann also Programm 1 mit tol= 10−12 , a= 0.01 und b= 0.1 mit dem Befehl >> [zero,res,niter]=bisection(f,0.01,0.1,1.e-12,1000,6000,1000); aus. Das Verfahren konvergiert nach 36 Iterationen gegen den Wert 0.061402, ¨ in guter Ubereinstimmung mit Absch¨ atzung (2.3), nach der kmin = 36. Wir k¨ onnen daraus also schließen, daß der Zinssatz I gleich 6.14% ist.

Das Bisektionsverfahren garantiert nicht einen monotone fallenden Fehler, sondern nur eine Halbierung des Intervalls, in dessen Innerem nach der Nullstelle gesucht wird. Aus diesem Grund k¨onnen unerwartet gute Approximationen an α auch verworfen werden, falls man als einziges Abbruchkriterium die L¨ ange des Intervalls I (k) verwendet. Dieses Verfahren ber¨ ucksichtigt den wirklichen Verlauf von f nicht und konvergiert auch nicht in einer Iteration, wenn f linear ist (außer die Nullstelle ist Mittelpunkt des ersten Suchintervalls). Siehe Aufgaben 2.1–2.5.

2.2 Das Newton-Verfahren Das Bisektionsverfahren beschr¨ ankt sich darauf, den Vorzeichenwechsel der Funktion f an den Grenzen der Teilintervalle auszun¨ utzen. Wir wollen jetzt ein Verfahren einf¨ uhren, das weitere Informationen u ¨ber f verwendet, genauer gesagt dessen Funktionswerte und die Werte deren Ableitung (unter der Annahme, daß diese auch existiert). Dazu stellen wir fest, daß y(x) = f (x(k) ) + f
(x(k) )(x − x(k) ) die Gleichung der Tangente an die Kurve (x, f (x)) im Punkt x(k) ist. Falls wir x(k+1) suchen, so daß y(x(k+1) ) = 0, erhalten wir folgende Formel x(k+1) = x(k) −

f (x(k) ) , vorausgesetzt f
(x(k) )
= 0, k ≥ 0 f
(x(k) )

(2.4)

2.2 Das Newton-Verfahren

43

8

6

f

4

2

0

x(2)

α

x(3) x(0)

x(1)

−2

−4

−6 −2

−1.5

−1

−0.5

0

0.5

1

1.5

2

Abb. 2.3. Die ersten aus dem Newton-Verfahren erhaltenen Iterierten, ausgeur die Funktion f (x) = x + ex + 10/(1 + x2 ) − 5 hend vom Anfangswert x(0) , f¨

Mit Gleichung (2.4) erhalten wir ausgehend von einem Startwert x(0) eine Folge mit Werten x(k) . Das so erhaltene Verfahren heißt NewtonVerfahren und entspricht der Berechnung der Nullstelle von f durch lokales Ersetzen von f durch seine Tangente (siehe Abbildung 2.3). Tats¨achlich erhalten wir durch Taylor-Reihenentwicklung von f um einen beliebigen Punkt x(k) f (x(k+1) ) = f (x(k) ) + δ (k) f
(x(k) ) + O((δ (k) )2 ),

(2.5)

wobei δ (k) = x(k+1) − x(k) . Setzen wir f (x(k+1) ) gleich null und vernachl¨assigen den Term O((δ (k) )2 ), erhalten wir x(k+1) als Funktion von x(k) wie in (2.4). In diesem Sinn kann (2.4) als Approximation von (2.5) gesehen werden. Klarerweise konvergiert (2.4) in nur einem Schritt gegen die Nullstelle, falls f linear, also von der Form f (x) = a1 x + a0 ist. Beispiel 2.2 L¨ osen wir jetzt Beispiel 2.1 mit denselben Ausgangsdaten und einem Startwert x(0) = 0.3. Das Verfahren konvergiert in nur sechs Iterationen gegen die gesuchte Nullstelle, wobei wir zwischen zwei aufeinanderfolgenden Iterationen eine Differenz kleiner gleich 10−12 verlangt haben.

Die Konvergenz des Newton-Verfahrens ist aber nicht f¨ ur jede Wahl ur jene x(0) , die gen¨ ugend nahe bei α von x(0) garantiert, sondern nur f¨ sind. Diese Forderung erscheint auf den ersten Blick nicht sehr sinnvoll: ugend nahe bei um die Unbekannte α zu finden, m¨ ussen wir x(0) gen¨ α w¨ahlen, wo doch α der unbekannte Wert ist! Tats¨achlich k¨onnen wir diese Werte aber durch einige Iterationen des Bisektionsverfahrens oder eine graphische Analyse von f erhalten. Falls also x(0) geeignet gew¨ahlt wurde und α eine einfache Nullstelle ist, d.h. f
(α)
= 0, dann konvergiert das Newton-Verfahren. Falls außerdem f zweimal stetig differenzierbar ist, erhalten wir folgendes Konvergenzresultat (siehe Aufgabe 2.8)

44

2 Nichtlineare Gleichungen

f

(α) x(k+1) − α =
(k) 2 k→∞ (x 2f (α) − α) lim

(2.6)

Folglich sagt man, das Newton-Verfahren konvergiert quadratisch oder mit Ordnung 2, da sich f¨ ur gen¨ ugend große k der Fehler im (k + 1)-ten Schritt wie das Quadrat des Fehlers im k-ten Schritt, multipliziert mit einer Konstanten unabh¨angig von k, verh¨ alt. Hat die Nullstelle hingegen eine Vielfachheit m gr¨ oßer als 1, dann konvergiert das Verfahren mit Ordnung 1 (siehe Aufgabe 2.15). In diesem Fall k¨onnen wir aber trotzdem wieder Konvergenzordnung 2 erreichen, indem wir (2.4) durch x(k+1) = x(k) − m

f (x(k) ) , vorausgesetzt f
(x(k) )
= 0, f
(x(k) )

(2.7)

ersetzen. F¨ ur dieses modifizierte Newton-Verfahren m¨ ussen wir m a priori kennen. Anderenfalls k¨onnen wir ein adaptives Newton-Verfahren verwenden, das wieder von Ordnung 2 ist und in [QSS02], Abschnitt 6.6.2, beschrieben wird. Beispiel 2.3 Die Funktion f (x) = (x−1) log(x) hat nur eine Nullstelle, α = 1 mit der Vielfachheit m = 2. Wir wollen sie mit dem Newton-Verfahren (2.4) und dem modifizierten Newton-Verfahren (2.7) berechnen. In Abbildung 2.4 ist der Fehler aus den zwei Verfahren in Funktion der Anzahl an Iterationen dargestellt. Wie wir sehen k¨ onnen, konvergiert das klassische Verfahren (2.4) nur linear.

2

10

0

10

−2

10

−4

10

−6

10

−8

10

−10

10

0

5

10

15

20

25

30

Abb. 2.4. Fehler in Funktion der Iterationszahl aus Beispiel 2.3. Die unterbrochen Linie entspricht dem Newton-Verfahren (2.4), die durchgezogen dem modifizierten Newton-Verfahren (2.7) mit m = 2

2.2.1 Abbruchkriterien f¨ ur das Newton-Verfahren Falls das Newton-Verfahren konvergiert, gibt es den exakten Wert f¨ ur α nur nach unendlich vielen Iterationen zur¨ uck. Andererseits kann man

2.2 Das Newton-Verfahren

45

sich im allgemeinen aber auch damit begn¨ ugen, α bis auf eine festgelegte Toleranz ε zu kennen, wir k¨ onnen also den Algorithmus nach kmin Iterationen abbrechen, f¨ ur die |e(kmin ) | = |α − x(kmin ) | < ε ist. Da wir aber den Fehler nicht kennen, m¨ ussen wir diesen anhand vorhandener oder leicht zu berechnender Werte geeignet absch¨atzen. Wie wir am Ende von Abschnitt 2.3 sehen werden, k¨ onnen wir als Fehlersch¨atzer f¨ ur das Newton-Verfahren die Differenz zweier aufeinanderfolgender Iterierter verwenden. Wir k¨ onnen das Verfahren also in Abh¨angigkeit vom ur das gilt: kleinsten Ganzen kmin abbrechen, f¨ |x(kmin ) − x(kmin −1) | < ε.

(2.8)

Wie wir in Abschnitt 2.3.1 sehen werden, ist das ein gutes Kriterium, falls die gesuchte Nullstelle einfach ist. Ein Fehlersch¨atzer, der sich auch f¨ ur andere iterative Verfahren zur Nullstellenberechnung einer Funktion f eignet, ist durch das Residuum r(k) = f (x(k) ) gegeben. Dieses verschwindet, falls x(k) Nullstelle von f ist. Das Verfahren wird in diesem Fall nach der ersten Iterierten kmin abgebrochen, f¨ ur die |f (x(kmin ) )| < ε ist. Das Residuum liefert allerdings nur dann eine genaue Fehlersch¨atzung, falls sich f in einer Umgebung Iα der gesuchten Nullstelle α ann¨ahernd linear verh¨alt (siehe Abbildung 2.5). Anderenfalls wird der Fehler zu groß ur x ∈ Iα , und zu klein, falls |f
(x)|  1 gesch¨atzt, falls |f
(x)|  1 f¨ (siehe auch Aufgabe 2.6).

f

y

y

f (x(k) ) f α

x(k) e(k)

x(k)

α x

f (x(k) ) x

e(k)

Abb. 2.5. Zwei Situationen, in denen das Residuum kein guter Fehlersch¨ atzer ist: |f
(x)|  1 links, |f
(x)|  1 rechts, mit x in einer Umgebung von α

Im Programm 2 haben wir das Newton-Verfahren in der Form (2.4) implementiert (f¨ ur das modifizierte Verfahren gen¨ ugt es, f
durch die

46

2 Nichtlineare Gleichungen

Funktion f
/m zu ersetzen). In den Zeichenketten f und df sind die Funktion f und deren erste Ableitung enthalten, w¨ahrend x0 der Startwert ist. Das Verfahren wird abgebrochen, sobald der Absolutbetrag der Differenz zweier aufeinanderfolgender Iterierter kleiner als eine Toleranz tol ist, oder falls die maximal erlaubte Anzahl nmax an Iterationen u ¨berschritten wird. Programm 2 - newton : Newton-Verfahren function [zero,res,niter]=newton(f,df,x0,tol,nmax,varargin) %NEWTON Findet die Nullstelle einer Funktion. % ZERO=NEWTON(FUN,DFUN,X0,TOL,NMAX) approximiert mit dem % Newton-Verfahren jene Nullstelle ZERO der in der Function FUN % definierten, stetigen und differenzierbaren Funktion, die X0 % am naechsten liegt. FUN und dessen Ableitung DFUN erwarten % als Eingabe einen Skalar x und geben einen Skalar aus. % Falls die Suche nach der Nullstelle fehlschlaegt, gibt das % Programm eine Fehlermeldung zurueck. FUN und DFUN % koennen auch Inline-Functions sein. % ZERO=NEWTON(FUN,DFUN,X0,TOL,NMAX,P1,P2,...) uebergibt die % den Funktionen FUN(X,P1,P2,...) und DFUN(X,P1,P2,...) % die Parameter P1,P2,... . % [ZERO,RES,NITER]= NEWTON(FUN,...) gibt den Wert des Residuums % RES in ZERO sowie die Anzahl der zur Berechnung von ZERO % benoetigten Iterationen NITER zurueck. x = x0; fx = feval(f,x,varargin{:}); dfx = feval(df,x,varargin{:}); niter =0; diff = tol+1; while diff >= tol & niter nmax fprintf([’Newton wurde nach Erreichen der’ ... ’maximalen Anzahl an Iterationen abgebrochen, ohne’ ... ’die gewuenschte Genauigkeit erreicht zu haben\n’]); end zero = x; res = fx; return

2.3 Fixpunktiterationen

47

Zusammenfassend 1. Die Berechnung der Nullstellen einer Funktion f erfolgt im allgemeinen mit iterativen Verfahren; 2. Das Bisektionsverfahren ist ein einfaches Verfahren, mit dem man eine Nullstelle einer Funktion berechnen kann, indem man eine Folge von Intervallen erzeugt, deren L¨ ange nach jeder Iteration halbiert wird. Das Verfahren konvergiert, falls f im Ausgangsintervall stetig ist und an dessen Grenzen verschiedene Vorzeichen hat; 3. Das Newton-Verfahren ist ein effizienteres Verfahren, in dem zur Approximation der Nullstelle auch die Funktionswerte von f und der ersten Ableitung von f verwendet werden. Das Verfahren konvergiert im allgemeinen nur f¨ ur Startwerte, die gen¨ ugend nahe bei der gesuchten Nullstelle liegen; 4. Das Newton-Verfahren konvergiert quadratisch, falls die Nullstelle einfach ist, anderenfalls linear. Siehe Aufgaben 2.6–2.14.

2.3 Fixpunktiterationen Oft haben wir vielleicht schon mit einem Taschenrechner herumgespielt, indem wir eine beliebige Zahl eingegeben und auf diese fortw¨ahrend dieselbe Operation angewendet haben. Dabei haben wir entdeckt, daß die so erzeugte Folge von Zahlen gegen ein bestimmtes Ergebnis konvergiert. Wenden wir etwa auf 1 wiederholt die Funktion Cosinus an, erhalten wir folgende Folge von Werten x(1) x(2) x(10) x(20)

= cos(1) = 0.54030230586814, = cos(x(1) ) = 0.85755321584639, = cos(x(9) ) = 0.74423735490056, = cos(x(19) ) = 0.73918439977149,

die gegen den Wert α = 0.73908513 . . . strebt. Da durch Konstruktion x(k+1) = cos(x(k) ) f¨ ur k = 0, 1, . . . (mit x(0) = 1) gilt, erf¨ ullt der Grenzwert α die Gleichung cos(α) = α. Aus diesem Grund wird dieser Punkt Fixpunkt der Cosinusfunktion genannt. Das Interesse f¨ ur ein Verfahren, das Iterationen dieser Art ausn¨ utzt, ist klar: falls α ein Fixpunkt des Cosinus ist, dann ist dieser eine Nullstelle der Funktion f (x) = x − cos(x) und wir haben ein Verfahren erhalten, das die Berechnung der Nullstellen von f erm¨oglicht. Andererseits haben nat¨ urlich nicht alle Funktionen Fixpunkte, wiederholt man zum Beispiel obiges Experiment mit der Exponentialfunktion ausgehend vom Startwert x(0) = 1, haben wir nach

48

2 Nichtlineare Gleichungen

nur vier Schritten bereits einen Overflow erzeugt (siehe Abbildung 2.6). Verdeutlichen wir unsere intuitive Idee an folgendem Beispiel: sei eine 2

2

y

y

1.5

1.5

y=x

y=x

1 1

φ

0.5

φ

0.5

0

−0.5 −0.5

0

x

α

x

−0.5

−1 0

0.5

1

1.5

2

−1

−0.5

0

0.5

1

1.5

2

Abb. 2.6. Die Funktion φ(x) = cos x besitzt einen Fixpunkt (links), w¨ ahrend die Funktion φ(x) = ex keinen hat (rechts)

Funktion φ : [a, b] → R gegeben und finde α ∈ [a, b], so daß α = φ(α). Falls ein derartiges α existiert, wird es Fixpunkt von φ genannt und ist Grenzwert der Folge x(k+1) = φ(x(k) ), k ≥ 0

(2.9)

wobei x(0) ein Startwert ist. Dieser Algorithmus wird Fixpunktiteration genannt, φ Iterationsfunktion. Das Eingangsbeispiel ist also eine Fixpunktiteration, in dem φ(x) = cos(x). Eine geometrische Interpretation von (2.9) gibt Abbildung 2.7 links: falls φ eine stetige Funktion ist und der Grenzwert der Folge {x(k) } existiert, dann ist dieser Grenzwert ein Fixpunkt von φ. Wir werden diese Aussage in den S¨atzen 2.1 und 2.2 pr¨ azisieren. Beispiel 2.4 Das Newton-Verfahren (2.4) kann als Fixpunktiteration mit Iterationsfunktion der f (x) (2.10) φ(x) = x −
f (x) angesehen werden. Von nun an werden wir diese Funktion mit dem Symbol ur Newton) bezeichnen. Das Bisektionsverfahren hingegen ist keine φN (N f¨ Fixpunktiteration, da die Iterierte x(k+1) nicht nur von x(k) , sondern auch angt. von x(k−1) abh¨

Wie wir in Abbildung 2.7 rechts sehen, k¨ onnen Fixpunktiteration auch nicht konvergieren. Es gilt n¨amlich:

2.3 Fixpunktiterationen 2

2

y

y 1.5

y=x

1

1.5

φ

x(2)

1

φ

0.5

0

−0.5 −0.5

49

x

x(0)x(2)α x(1) 0

0.5

1

x x(1) α x(0)

0.5

0

y=x 1.5

2

−0.5 −0.5

0

0.5

1

1.5

2

Abb. 2.7. Einige Fixpunktiterationen f¨ ur zwei verschiedene Iterationsfunktionen. Links konvergieren die Iterationen gegen den Fixpunkt α, rechts erzeugen die Iterationen eine divergente Folge

Satz 2.1 Die Iterationsfunktion in (2.9) erf¨ ulle folgende Eigenschaften: 1. φ(x) ∈ [a, b] f¨ ur alle x ∈ [a, b]; 2. φ ist in [a, b] differenzierbar; ur alle x ∈ [a, b]. 3. ∃K < 1, so daß |φ
(x)| ≤ K f¨ Dann besitzt φ genau einen Fixpunkt α ∈ [a, b] und die in (2.9) definierte Folge konvergiert gegen α, unabh¨ angig von der Wahl des ¨ Startwertes x(0) aus [a, b]. Uberdies gilt x(k+1) − α = φ
(α). k→∞ x(k) − α lim

(2.11)

Aus (2.11) k¨ onnen wir folgern, daß die Fixpunktiterationen mindestens linear konvergieren, daß sich also der Fehler f¨ ur ein gen¨ ugend großes k im Schritt k + 1 wie der Fehler im Schritt k mal einer Konstanten vom Betrag kleiner eins (φ
(α)) unabh¨angig von k verh¨ alt. Beispiel 2.5 Die Funktion φ(x) = cos(x) erf¨ ullt die Annahmen des Satzes 2.1, da |φ
(α)| = | sin(α)|  0.67 < 1, wegen der Stetigkeit existiert eine ur x ∈ Iα . Die Funktion φ(x) = x2 −1 Umgebung Iα von α, in der |φ
(x)| < 1 f¨ hingegen erf¨ ullt die Voraussetzungen ur ihre beiden Fixpunkte α± = (1 ± √ f¨ √ orige Fixpunktiteration 5)/2 nicht, da |φ
(α± )| = |1 ± 5| > 1. Die zugeh¨ ist also nicht konvergent.

Das Newton-Verfahren ist nicht das einzige iterative Verfahren, das quadratisch konvergiert. Es gilt n¨ amlich folgende Eigenschaft:

50

2 Nichtlineare Gleichungen

Satz 2.2 Es gelten die Voraussetzungen aus Satz 2.1. Falls φ außerdem zweimal differenzierbar und φ
(α) = 0, φ

(α)
= 0, ist, dann konvergiert das Fixpunktverfahren (2.9) mit Ordnung 2 und es ist 1 x(k+1) − α = φ

(α). k→∞ (x(k) − α)2 2 lim

(2.12)

Beispiel 2.4 zeigt, daß mit Fixpunktiteration (2.9) auch die Nullstellen von Funktionen berechnet werden k¨ onnen. Nat¨ urlich ist f¨ ur eine gegebene Funktion f die in (2.10) definierte Iterationsfunktion φ nicht die einzig m¨ogliche. Zum Beispiel w¨ urde (2.10) f¨ ur die L¨ osung von Gleichung log(x) = γ zu folgender Iterationsfunktion f¨ uhren, falls wir f (x) = log(x) − γ setzen: φN (x) = x(1 − log(x) + γ). Ein anderes Fixpunktverfahren erhalten wir, falls wir x zu beiden Seiten von Gleichung f (x) = 0 addieren. Die zugeh¨ orige Iterationsfunktion oglichkeit erhalten wir, falls ist dann φ1 (x) = x+log(x)−γ. Eine dritte M¨ wir die Gleichung mit x multiplizieren und φ2 (x) = x log(x)/γ w¨ ahlen. Nicht alle diese Verfahren sind konvergent; falls zum Beispiel γ = −2 ist, sind die Verfahren mit der Iterationsfunktion φN und φ2 konvergent, w¨ahrend jenes mit der Iterationsfunktion φ1 nicht konvergiert, da in einer Umgebung des Fixpunktes |φ
1 (x)| > 1 ist. 2.3.1 Wie wir die Fixpunktiteration abbrechen Im allgemeinen wird die Fixpunktiteration abgebrochen, sobald der Absolutbetrag der Differenz zweier Iterierter kleiner als eine festgelegte Toleranz ε ist. Da α = φ(α) und x(k+1) = φ(x(k) ), erhalten wir mit dem Mittelwertsatz (vorgestellt in Abschnitt 1.4.3): α − x(k+1) = φ(α) − φ(x(k) ) = φ
(ξ (k) ) (α − x(k) ) mit ξ (k) ∈ Iα,x(k) , wobei Iα,x(k) das Intervall mit Grenzen α und x(k) ist. Mit der Identit¨ at α − x(k) = (α − x(k+1) ) + (x(k+1) − x(k) ) k¨onnen wir dann schließen α − x(k) = (x(k+1) − x(k) )/(1 − φ
(ξ (k) )).

(2.13)

2.4 Beschleunigung mit dem Aitken-Verfahren

51

0

−5

(2)

−10

(1)

−15

−20

−25 0

50

100

150

200

250

300

350

400

450

Abb. 2.8. Logarithmus der Absolutbetr¨ age der Fehler (durchgehende Linie) und Logarithmus der Absolutbetr¨ age der Differenz zweier aufeinanderfolgender Iterierter (unterbrochene Linie) in Funktion der Iterationsanzahl im Fall von Beispiel 2.6. Die Graphen (1) beziehen sich auf m = 11, die Graphen (2) auf m = 21

Falls also in einer Umgebung von α φ
(x)  0 ist, wird der Fehler durch die Differenz zweier aufeinanderfolgender Iterierter richtig abgesch¨atzt. Dies gilt f¨ ur alle Verfahren zweiter Ordnung, also auch f¨ ur das NewtonVerfahren. Diese Absch¨ atzung wird umso ungenauer, je n¨aher φ
bei 1 liegt. Beispiel 2.6 Berechnen wir mit dem Newton-Verfahren die Nullstelle α = 1 ur m = 11 und m = 21. Diese der Funktion f (x) = (x − 1)m−1 log(x) f¨ Nullstelle hat die Vielfachheit m. In diesem Fall konvergiert das NewtonVerfahren mit Ordnung 1 und wir k¨ onnen zeigen (siehe Aufgabe 2.15), daß φ
N (α) = 1 − 1/m, wobei φN die Iterationsfunktion des Verfahrens, als Fixpunktiteration gesehen, ist. Mit zunehmendem m wird also der Fehlersch¨ atzer aus der Differenz der Iterierten immer ungenauer. Das best¨ atigt sich auch im Experiment: in den Graphen in Abbildung 2.8 werden Fehler und Absolutbetrag der Differenz zweier aufeinanderfolgender Iterierter f¨ ur m = 11 und m = 21 verglichen. Wie wir sehen, wird der Unterschied zwischen den beiden Werten mit wachsendem m gr¨ oßer.

2.4 Beschleunigung mit dem Aitken-Verfahren In diesem Abschnitt stellen wir eine Technik vor, mit der wir die Konvergenz einer Folge, erhalten durch Fixpunktiteration, beschleunigen k¨ onnen. Nehmen wir an, daß x(k) = φ(x(k−1) ), k ≥ 1. Falls die Folge {x(k) } linear gegen einen Fixpunkt α von φ konvergiert, k¨onnen wir aus (2.11) schließen, daß f¨ ur festes k ein (zu findendes) λ existiert, so daß φ(x(k) ) − α = λ(x(k) − α)

(2.14)

gilt, wobei wir absichtlich φ(x(k) ) nicht mit x(k+1) identifiziert haben. Die Idee des Aitken-Verfahrens besteht nun darin, einen neuen Wert f¨ ur

52

2 Nichtlineare Gleichungen

x(k+1) und damit eine neue Folge zu bestimmen, die α besser approximiert als die gegebene. Tats¨ achlich erhalten wir aus (2.14) α=

φ(x(k) ) − λx(k) + x(k) − x(k) φ(x(k) ) − λx(k) = 1−λ 1−λ

beziehungsweise

α = x(k) + (φ(x(k) ) − x(k) )/(1 − λ)

(2.15)

An dieser Stelle m¨ ussen wir nun λ berechnen. Dazu f¨ uhren wir die Folge λ(k) =

φ(φ(x(k) )) − φ(x(k) ) φ(x(k) ) − x(k)

(2.16)

ein und u ufen folgende Eigenschaft: ¨berpr¨ Lemma 2.1 Falls die Folge von Elementen x(k+1) = φ(x(k) ) gegen α konvergiert, dann ist lim λ(k) = φ
(α). k→∞

Beweis 2.1 Falls x(k+1) = φ(x(k) ) ist, dann ist x(k+2) = φ(φ(x(k) )) und mit (2.16) erh¨ alt man λ(k) = (x(k+2) − x(k+1) )/(x(k+1) − x(k) ) beziehungsweise

λ(k)

x(k+2) − α −1 (k+1) − α − α − (x − α) x , = x = (k) (k+1) (k) x − α − (x − α) x −α 1 − (k+1) x −α (k+2)

(k+1)

durch Grenz¨ ubergang und mit (2.11) folgt dann die Behauptung, weil lim λ(k) =

k→∞

φ
(α) − 1 = φ
(α). 1 − 1/φ
(α)

Dank Lemma 2.1 k¨ onnen wir nun λ(k) f¨ ur festes k als Approximation an λ ansehen. Nun k¨ onnen wir (2.16) in (2.15) einsetzen und ein neues x(k+1) = x(k) −

(φ(x(k) ) − x(k) )2 , k ≥ 0, φ(φ(x(k) )) − 2φ(x(k) ) + x(k)

(2.17)

definieren. Ausdruck (2.17) wird Extrapolationsformel von Aitken genannt ist eine neue Fixpunktiteration mit der Iterationsfunktion φ∆ (x) :=

xφ(φ(x)) − [φ(x)]2 . φ(φ(x)) − 2φ(x) + x

2.4 Beschleunigung mit dem Aitken-Verfahren

53

Dieses Verfahren wird manchmal auch Steffensen-Verfahren genannt. ur x = α nicht definiert, in diesem Klarerweise ist die Funktion φ∆ f¨ Fall verschwinden sowohl Z¨ ahler als auch Nenner. Mit der Regel von de l’Hˆ opital und der Annahme, daß φ zweimal differenzierbar ist mit φ
(α)
= 1, erhalten wir φ(φ(α)) + αφ
(φ(α))φ
(α) − 2φ(α)φ
(α) φ
(φ(α))φ
(α) − 2φ
(α) + 1 α + α[φ
(α)]2 − 2αφ
(α) = α. = [φ
(α)]2 − 2φ
(α) + 1

lim φ∆ (x) =

x→α

Wenn φ(x) = x − f (x) ist, entspricht der Fall φ
(α) = 1 einer Wurzel von f mit einer Vielfachheit von mindestens 2 (da φ
(α) = 1 − f
(α)). Auch in dieser Situation kann man zeigen, daß durch Grenz¨ ubergang φ∆ (α) = α gilt. Außerdem kann man zeigen, daß die Fixpunkte von φ∆ dieselben von φ sind. Das Aitken-Verfahren kann deshalb auf jedes beliebige Fixpunktverfahren angewandt werden. Es gilt folgender Satz:

Theorem 2.1 Sei x(k) = φ(x(k−1) ) eine Fixpunktiteration mit φ(x) = x − f (x) zur Approximation der Wurzeln von f . Falls f gen¨ ugend glatt ist, gilt: - falls die Fixpunktiteration linear gegen eine einfache Wurzel von f konvergiert, dann konvergiert das Aitken-Verfahren quadratisch gegen dieselbe Nullstelle; - falls die Fixpunktiteration mit Ordnung p ≥ 2 gegen eine einfache Wurzel von f konvergiert, dann konvergiert das AitkenVerfahren mit Ordnung 2p − 1 gegen dieselbe Nullstelle; - falls die Fixpunktiteration linear gegen eine Wurzel von f mit einer Vielfachheit m ≥ 2 konvergiert, dann konvergiert das Aitken-Verfahren linear gegen dieselbe Nullstelle, und zwar mit einem asymptotischen Konvergenzfaktor C = 1 − 1/m. Falls p = 1 und die Wurzel von f einfach ist, konvergiert das Extrapolationsverfahren von Aitken im allgemeinen auch, wenn die zugeh¨ origen Fixpunktiteration divergiert. Im Programm 3 ist das Aitken-Verfahren implementiert. In diesem ist phi eine Function (oder Inline-Function), die den Ausdruck der Iterationsfunktion des Fixpunktverfahrens enth¨ alt, auf das die AitkenExtrapolation angewandt wird. Der Startwert ist in der Variablen x0 festgelegt, w¨ahrend tol bzw. kmax die Toleranz des Abbruchkriteriums (der Absolutbetrag der Differenz zweier aufeinanderfolgender Iterierter) bzw. die maximal erlaubte Anzahl an Iterationsschritten bezeich-

54

2 Nichtlineare Gleichungen

net. Falls diese Werte nicht festgelegt werden, werden die Default-Werte kmax=100 und tol=1.e-04 angenommen.

Programm 3 - aitken : Aitken-Verfahren function [x,niter]=aitken(phi,x0,tol,kmax) %AITKEN Aitken-Extrapolation % [ALPHA,NITER]=AITKEN(PHI,X0) berechnet die Approximation eines % Fixpunktes ALPHA der Funktion PHI, ausgehend vom Startwert X0, % mit dem Extrapolationsverfahren von Aitken. Das Verfahren bricht nach % 100 Iterationen ab oder falls der Absolutbetrag der Differenz zweier % aufeinanderfolgender Iterierten kleiner 1.e-04 ist. PHI muss als % Function oder Inline-Function definiert werden. % [ALPHA,NITER]=AITKEN(PHI,X0,TOL,KMAX) erlaubt das Festlegen % einer Toleranz auf das Abbruchkriterium und einer Hoechstzahl % an Iterationen. if nargin == 2 tol = 1.e-04; kmax = 100; elseif nargin == 3 kmax = 100; end x = x0; diff = tol + 1; niter = 0; while niter = tol gx = feval(phi,x); ggx = feval(phi,gx); xnew = (x*ggx-gxˆ2)/(ggx-2*gx+x); niter = niter + 1 end return Beispiel 2.7 Zur Berechnung der einfachen Nullstelle α = 1 der Funktion f (x) = ex (x−1) wenden wir das Aitken-Verfahren, ausgehend von folgenden zwei Fixpunktverfahren, an: ex + x . φ0 (x) = log(xex ), φ1 (x) = x e +1 Wir verwenden Programm 3 mit tol=1.e-10, kmax=100, x0=2 und definieren die beiden Iterationsfunktionen wie folgt

>> phi0 = inline(’log(x*exp(x))’,’x’); >> phi1 = inline(’(exp(x)+x)/(exp(x)+1)’,’x’); Dann f¨ uhren wir Programm 3 folgendermaßen aus:

2.5 Algebraische Polynome

55

>> [alpha,niter]=aitken(phi0,x0,tol,kmax) alpha = 1.0000 + 0.0000i niter = 10 >> [alpha,niter]=aitken(phi1,x0,tol,kmax) alpha = 1 niter = 4 Wie wir sehen, konvergiert das Verfahren extrem schnell, das Fixpunktverfahren mit einer Iterationsfunktion φ1 und demselben Abbruchkriterium ben¨ otigt hingegen 18 Iterationen, das Fixpunktverfahren mit einer Iterationsfunktion φ0 konvergiert u ¨berhaupt nicht, da |φ
0 (1)| = 2 ist.

Zusammenfassend 1. Ein Zahl α, f¨ ur die φ(α) = α, heißt Fixpunkt der Funktion φ. Zu dessen Berechnung wendet man iterative Verfahren der Art x(k+1) = φ(x(k) ) an, die Fixpunktiterationen genannt werden; 2. Die Fixpunktiterationen konvergieren unter bestimmten Bedingungen an φ und dessen erste Ableitung. Normalerweise ist die Konvergenz linear, quadratisch, falls φ
(α) = 0; 3. Mit Fixpunktiterationen kann man auch die Nullstellen einer Funktion f berechnen; 4. Ist eine Fixpunktiteration x(k+1) = φ(x(k) ), eventuell auch eine nicht konvergente, gegeben, dann kann man mit dem Aitken-Verfahren stets eine neue Fixpunktiteration konstruieren. Siehe Aufgaben 2.15–2.18.

2.5 Algebraische Polynome In diesem Abschnitt ist f ein Polynom vom Grad n ≥ 0 von der Form pn (x) =

n 

ak xk ,

(2.18)

k=0

wobei ak ∈ R die Koeffizienten des Polynoms sind. Da die ak reell sind, ist mit der Wurzel α von pn auch deren komplex Konjugierte α ¯ eine Wurzel von pn .

56

2 Nichtlineare Gleichungen

Der Satz von Abel besagt, daß es f¨ ur n ≥ 5 keine explizite Formel zur Berechnung aller Nullstellen eines beliebigen Polynoms pn gibt. Dies motiviert nat¨ urlich die Verwendung numerischer Verfahren zur Berechnung der Nullstellen von pn . Wie wir oben gesehen haben, ist es wichtig, einen guten Startwert x(0) oder ein geeignetes Suchintervall [a, b] zu w¨ahlen, um eine Nullstelle zu finden. Im Fall von Polynomen ist dies aufgrund folgender Resultate m¨oglich: Theorem 2.2 (Vorzeichenregel von Descartes) Sei pn ∈ Pn . Bezeichnen wir mit ν die Anzahl der Vorzeichenwechsel in der Menge der Koeffizienten {aj } und mit k die Anzahl der reellen positiven Wurzeln von pn , jede mit ihrer Vielfachheit gez¨ahlt. Dann ist k ≤ ν und ν − k gerade. Beispiel 2.8 Das Polynom p6 (x) = x6 − 2x5 + 5x4 − 6x3 + 2x2 + 8x − 8 hat Nullstellen {±1, ±2i, 1 ± i} und eine reelle positive Wurzel (k = 1). Die Anzahl der Vorzeichenwechsel ν in der Menge der Koeffizienten ist 5 und tats¨ achlich ist k ≤ ν und ν − k = 4 gerade.

Theorem 2.3 (von Cauchy) Alle Nullstellen von pn sind im Kreis Γ der komplexen Ebene Γ = {z ∈ C : |z| ≤ 1 + η} enthalten, wobei η=

max |ak /an |.

0≤k≤n−1

(2.19)

Diese Eigenschaft ist nicht sehr n¨ utzlich, falls η  1 (f¨ ur Polynom p6 aus Beispiel 2.8 ist η = 8, w¨ahrend sich alle Wurzeln im Inneren von Kreisen mit eindeutig kleineren Radien befinden). 2.5.1 Das Horner-Schema In diesem Abschnitt stellen wir ein Verfahren zur effizienten Auswertung eines Polynoms und seiner Ableitungen in einem gegebenen Punkt z vor. Ein automatisches Verfahren, Reduktionsverfahren genannt, erm¨ oglicht die sukzessive Approximation aller Wurzeln des Polynoms. Aus algebraischer Sicht ist (2.18) ¨aquivalent zu folgender Darstellung pn (x) = a0 + x(a1 + x(a2 + . . . + x(an−1 + an x) . . . )).

(2.20)

2.5 Algebraische Polynome

57

W¨ ahrend jedoch (2.18) f¨ ur festes x n Summen und 2n − 1 Multiplikationen zur Auswertung von pn (x) erfordert, reichen in (2.20) n Additionen und n Multiplikationen. Ausdruck (2.20), auch geschachtelte Multiplikation genannt, ist grundlegender Bestandteil des Horner-Schemas. Das Verfahren wertet das Polynom pn im Punkt z durch folgenden synthetischen Divisionsalgorithmus bn = an , bk = ak + bk+1 z, k = n − 1, n − 2, ..., 0

(2.21)

aus. In (2.21) h¨ angen alle Koeffizienten bk von z ab und wir k¨onnen zeigen, daß b0 = pn (z) ist. Das Polynom n−1

qn−1 (x; z) = b1 + b2 x + ... + bn x

=

n 

bk xk−1

(2.22)

k=1

vom Grad n − 1 in der Variablen x h¨ angt u ¨ber die Koeffizienten bk vom Parameter z ab und wird zu pn assoziiertes Polynom genannt. Algorithmus (2.21) ist im Programm 4 implementiert. Die Koeffizienten aj des Polynoms werden im Vektor a, von an bis a0 geordnet, gespeichert.

Programm 4 - horner : synthetischer Divisionsalgorithmus function [y,b] = horner(a,z) %HORNER das Horner-Verfahren % Y=HORNER(A,Z) berechnet % Y = A(1)*ZˆN + A(2)*Zˆ(N-1) + ... + A(N)*Z + A(N+1) % mit dem synthetischen Divisionsalgorithmus von Horner. n = length(a)-1; b = zeros(n+1,1); b(1) = a(1); for j=2:n+1 b(j) = a(j)+b(j-1)*z; end y = b(n+1); b = b(1:end-1); return

Wir wollen jetzt einen effizienten Algorithmus vorstellen, der sukzessive eine bereits bekannte (oder approximierte) Wurzel des Polynoms eliminiert und dann die n¨achste berechnet, bis schließlich alle berechnet sind. Dazu wollen wir an folgende Eigenschaft der Polynomdivision erinnern:

58

2 Nichtlineare Gleichungen

Satz 2.3 Zu zwei gegebenen Polynomen hn ∈ Pn und gm ∈ Pm mit m ≤ n gibt es ein eindeutiges Polynom δ ∈ Pn−m und ein eindeutiges Polynom ρ ∈ Pm−1 , so daß hn (x) = gm (x)δ(x) + ρ(x).

(2.23)

Dann folgt aus (2.23) durch Division von pn ∈ Pn durch x − z pn (x) = b0 + (x − z)qn−1 (x; z), wobei qn−1 den Quotienten und b0 den Rest der Division bezeichnet. Ist z eine Nullstelle von pn , so gilt b0 = pn (z) = 0 und folglich ist pn (x) = (x − z)qn−1 (x; z). In diesem Fall liefert die algebraische Gleichung qn−1 (x; z) = 0 die n − 1 verbleibenden Wurzeln von pn (x). Diese Beobachtung legt folgendes Reduktionsverfahren zur Bestimmung aller Wurzeln von pn nahe. F¨ ur m = n, n − 1, . . . , 1: 1. finde mit einer geeigneten Appoximationsmethode eine Wurzel rm von pm ; 2. berechne qm−1 (x; rm ) mit (2.21)-(2.22) (setze z = rm ); 3. setze pm−1 = qm−1 . Im folgenden Abschnitt stellen wir das bekannteste Verfahren aus dieser Familie vor, es verwendet zur Approximation der Wurzeln das Newton-Verfahren. 2.5.2 Das Newton-Horner-Verfahren Wie der Name nahelegt, implementiert das Newton-Horner-Verfahren das eben beschriebene Reduktionsverfahren, indem es zur Berechnung der Nullstellen rm das Newton-Verfahren verwendet. Der Vorteil des Verfahrens besteht darin, daß das Newton-Verfahren selbst den HornerAlgorithmus (2.21) effektiv ausn¨ utzt. Ist n¨amlich qn−1 das in (2.22) deorende Polynom, gilt wegen finierte, zu pn geh¨
p
n (x) = qn−1 (x; z) + (x − z)qn−1 (x; z),

daß p
n (z) = qn−1 (z; z). Aufgrund dieser Eigenschaft nimmt das Newton-Horner-Verfahren zur Approximation einer (reellen oder komplexen) Wurzel rj von pn (j = 1, . . . , n) folgende Form an: (0) berechne f¨ ur eine gegebene Anfangssch¨ atzung rj der Wurzel f¨ ur jedes k ≥ 0 bis zur Konvergenz:

2.5 Algebraische Polynome

(k+1)

rj

(k)

= rj

(k)

−

pn (rj ) (k)

p
n (rj )

(k)

= rj

59

(k)

−

pn (rj ) (k)

(k)

(2.24)

qn−1 (rj ; rj )

Jetzt verwenden wir die Reduktionstechnik und n¨ utzen dabei aus, daß pn (x) = (x − rj )pn−1 (x) ist. Jetzt k¨onnen wir eine Nullstelle von pn−1 approximieren und wiederholen diese Punkte solange, bis alle Wurzeln von pn gefunden sind. Ist rj ∈ C, so m¨ ussen wir in komplexer Arithmetik arbeiten und (0) urde rj mit einem Imagin¨arteil ungleich null nehmen. Anderenfalls w¨ (k)

das Newton-Horner-Verfahren eine Folge von {rj } von reellen Zahlen erzeugen. Das Newton-Horner-Verfahren ist im Programm 5 implementiert. Die Koeffizienten aj des Polynoms, von dem wir die Wurzeln berechnen wollen, sind im Vektor a in der Reihenfolge an bis a0 gespeichert. Die Eingabeparameter tol und kmax bezeichnen die Toleranz bzw. das Abbruchkriterium (auf den Absolutbetrag der Differenz zweier aufeinanderfolgender Iterierter) und der Maximalzahl zul¨ assiger Iterationen. Falls nicht anders angegeben, werden die Default-Werte gleich kmax=100 und tol=1.e-04 gesetzt. Als Output gibt das Programm in den Vektoren wurzeln und iter die berechneten Wurzeln und die zur Berechnung jedes Wertes ben¨otigten Iterationen zur¨ uck.

Programm 5 - newtonhorner : Newton-Horner-Verfahren function [wurzeln,iter]=newtonhorner(a,x0,tol,kmax) %NEWTONHORNER Das Newton-Horner-Verfahren % [WURZELN,ITER]=NEWTONHORNER(A,X0) berechnet die % Wurzeln des Polynoms % P(X) = A(1)*XˆN + A(2)*Xˆ(N-1) + ... + A(N)*X + A(N+1) % mit dem Verfahren von Newton-Horner, ausgehend von einem Startwert X0. % Das Verfahren bricht fuer jede Wurzel nach 100 Iterationen ab, oder % nachdem der Absolutbetrag der Differenz zweier aufeinanderfolgender % Iterierter kleiner 1.e-04 ist. % [WURZELN,ITER]=NEWTONHORNER(A,X0,TOL,KMAX) erlaubt die % Definition einer Toleranz fuer das Abbruchkriterium und der maximal % zulaessigen Anzahl an Iterationen. if nargin == 2 tol = 1.e-04; kmax = 100; elseif nargin == 3 kmax = 100; end n=length(a)-1; wurzeln = zeros(n,1); iter = zeros(n,1); for k = 1:n % Newton-Iterationen niter = 0; x = x0; diff = tol + 1;

60

2 Nichtlineare Gleichungen

while niter = tol [pz,b] = horner(a,x); [dpz,b] = horner(b,x); xnew = x - pz/dpz; diff = abs(xnew-x); niter = niter + 1; x = xnew; end % Reduktion [pz,a] = horner(a,x); wurzeln(k) = x; iter(k) = niter; end return Bemerkung 2.1 Um die Fortpflanzung der Rundungsfehler so klein wie m¨ oglich zu halten, ist es g¨ unstiger, im Reduktionsschritt zuerst die Wurzel r1 mit dem kleinsten Rest und dann die weiteren r2 , r3 , . . . zu berechnen, und zuletzt jene mit dem gr¨ oßten Rest (zur Vertiefung siehe etwa [QSS02]). Beispiel 2.9 Verwenden wir Programm 5 zur Berechnung der Wurzeln {1, 2, 3} des Polynoms p3 (x) = x3 − 6x2 + 11x − 6 und geben folgende Anweisungen >> a=[1 -6 11 -6]; [x,niter]=newtonhorner(a,0,1.e-15,100) x= 1 2 3 niter = 8 8 2 Wie wir sehen, berechnet das Verfahren alle drei Wurzeln genau und in wenigen Schritten. Wie wir in Bemerkung 2.1 gesehen haben, ist das Verfahren nicht immer so effizient. Wollen wir die Nullstellen des Polynoms p4 (x) = x4 − 7x3 + 15x2 − 13x + 4 (das eine Nullstelle gleich 1 mit der Vielfachheit 3 und eine einfache gleich 3 hat) berechnen, erhalten wir folgende Ergebnisse >> a=[1 -7 15 -13 4]; format long; [x,niter]=newtonhorner(a,0,1.e-15,100) x= 1.00000693533737 0.99998524147571 1.00000782324144 3.99999999994548 niter = 61 101 6 2

2.6 Was wir nicht erw¨ ahnt haben

61

2.6 Was wir nicht erw¨ ahnt haben Es gibt Algorithmen, die durch geeignete Kombination verschiedener Verfahren die genaue Berechnung der Nullstellen jeder beliebigen Funktion erlauben. Wir erinnern in diesem Zusammenhang an den Befehl fzero (bereits in Abschnitt 1.4.1 eingef¨ uhrt), der in seiner einfachsten Form fzero(fun,x0) ausgehend von einem Startwert x0 die diesem am n¨achsten liegende Nullstelle der Funktion fun (als Zeichenkette oder Inline-Function gegeben) berechnet. Diese Function basiert auf dem Dekker-Brent-Verfahren (siehe [QSS02], Kapitel 6). L¨osen wir zum Beispiel das Problem aus Beispiel 2.1 mit der Funktion fzero und nehmen als Startwert x0=0.3 (denselben, den wir f¨ ur das Newton-Verfahren verwendet haben). Es gen¨ ugen folgende Anweisungen >> f=inline(’6000 - 1000*(1+I)/I*((1+I)ˆ5 - 1)’,’I’); x0=0.3; >> [alpha,res,flag,iter]=fzero(f,x0); um alpha=0.06140241153653 mit einem Residuum res=9.0949e-13 nach iter=29 Iterationen zu erhalten. Falls der Ausgabeparameter flag einen negativen Wert annimmt, bedeutet dies, daß die Suche nach der Nullstelle mit fzero fehlgeschlagen ist. Zum Vergleich: das NewtonVerfahren ist in sechs Iterationen gegen den Wert 0.06140241153652 mit einem Residuum gleich 2.3646e-11 konvergiert, allerdings bei Kenntnis der ersten Ableitung von f . Zur Berechnung der Nullstellen eines Polynoms mit einem anderen als dem Newton-Horner-Verfahren wollen wir auf Verfahren verweisen, die auf Sturm-Folgen basieren, und zwar das Muller-Verfahren (siehe [Atk89] oder [QSS02]) und das Bairstow-Verfahren ([RR85], S.371 ff). Ein anderer Ansatz besteht darin, die Nullstellen eines Polynoms als die Eigenwerte einer speziellen Matrix, der Begleitmatrix, zu charakterisieren und diese mit einer geeigneten Technik zu berechnen. Dieses Verfahren wird in der MATLAB-Funktion roots angewandt, die wir in Abschnitt 1.4.2 eingef¨ uhrt haben. Das Newton-Verfahren und die Fixpunktiteration k¨onnen leicht auf den Fall erweitert werden, in dem man ein System nichtlinearer Gleichungen (siehe zum Beispiel [QSS02], Kapitel 7) folgender Form l¨osen muß: ⎧ f1 (x1 , x2 , . . . , xn ) = 0, ⎪ ⎪ ⎪ ⎪ ⎪ ⎪ ⎨ f2 (x1 , x2 , . . . , xn ) = 0, ⎪ ⎪ ⎪ ⎪ ⎪ ⎪ ⎩

.. . fn (x1 , x2 , . . . , xn ) = 0,

ur diese Art von Prowobei f1 , . . . , fn nichtlineare Funktionen sind. F¨ blemen wollen wir weiters auf das Broyden- und die Quasi-Newton-

fzero

62

fsolve

2 Nichtlineare Gleichungen

Verfahren verweisen, die als Verallgemeinerungen des Newton-Verfahrens angesehen werden k¨ onnen (siehe [DS83]). In MATLAB k¨ onnen wir die Funktion fsolve anwenden, indem wir zero = fsolve(
fun
, x0) eingeben, wobei x0 der Vektor des Anfangswertes ist und fun der Name der vom Benutzer konstruierten Funktion, in der die Gleichungen des Systems angegeben sind. Dieser wird als Eingabeparameter der Vektoren ¯2 , . . . , x ¯n u alt einen Vektor zur¨ uck, der die x ¯1 , x ¨bergeben und man erh¨ x1 , x ¯2 , . . . , x ¯n ) f¨ ur k = 1, . . . , n enth¨alt. zugeh¨origen Werte fk (¯ L¨osen wir zum Beispiel das nichtlineare System  2 x + y 2 = 1, (2.25) sin(πx/2) + y 3 = 0, dessen L¨osungen (0.4761, −0.8794) und (−0.4761, 0.8794) sind. Die zugeh¨orige MATLAB-Funktion, die wir nlsystem.m nennen wollen, ist ein File mit folgender Struktur function fx=nlsystem(x) fx(1) = x(1)ˆ2+x(2)ˆ2-1; fx(2) = sin(pi*0.5*x(1))+x(2)ˆ3; return Die MATLAB-Anweisungen zur L¨ osung des Systems sind dann >> x0 = [1 1]; >> alpha=fsolve(’systemnl’,x0) alpha = 0.4761 -0.8794 Daraus erhalten wir nur eine der zwei Wurzeln. Die andere kann berechnet werden, indem wir als Startwert -x0 w¨ahlen.

2.7 Aufgaben Aufgabe 2.1 Sei die Funktion f (x) = cosh x + cos x − γ gegeben. Finde f¨ ur γ = 1, 2, 3 ein Intervall, das eine Nullstelle enth¨ alt (falls sie existiert) und berechne sie mit dem Bisektionsverfahren und einer Genauigkeit von 10−10 . Aufgabe 2.2 F¨ ur Kohlendioxyd (CO2 ) sind die Koeffizienten a und b der ur Gleichung (2.1) a = 0.401Pa m6 bzw. b = 42.7 · 10−6 m3 (Pa steht f¨ Pascal) gegeben. Finde das Volumen, das von 1000 Kohlendioxydmolek¨ ulen eingenommen wird, die einer Temperatur von T = 300K und einem Druck von p = 3.5 · 107 Pa ausgesetzt sind. Verwende dazu das Bisektionsverfahren mit einer Genauigkeit von 10−12 (die Boltzmann-Konstante ist k = 1.3806503 · 10−23 Joule K−1 ).

2.7 Aufgaben

63

Aufgabe 2.3 Ein Gegenstand liegt ruhig auf einer Ebene, deren Neigung sich mit konstanter Geschwindigkeit ω ¨ andert. Nach t Sekunden ist die Position des Gegenstandes g [sinh(ωt) − sin(ωt)], s(t, ω) = 2ω 2 wobei g = 9.8m/s2 die Erdbeschleunigung ist. Nehmen wir an, der Gegenstand hat sich in einer Sekunde einen Meter bewegt. Finde den entsprechenden Wert ω mit einer Genauigkeit der Gr¨ oßenordnung 10−5 . Aufgabe 2.4 Beweise Ungleichung (2.3). Aufgabe 2.5 Im Programm 1 haben wir zur Berechnung des Mittelpunktes folgende Anweisung verwendet: x(2) = x(1)+(x(3)-x(1))*0.5, anstatt die offensichtlichere x(2) = (x(1)+x(3))*0.5. Weshalb? Aufgabe 2.6 L¨ ose Aufgabe 2.1 mit dem Newton-Verfahren. Warum ist das Verfahren f¨ ur γ = 2 ungenau? Aufgabe 2.7 Verwende das Newton-Verfahren zur Berechnung der Quadratwurzel einer positiven Zahl a. Analog f¨ ur die Berechnung der Kubikwurzel von a. Aufgabe 2.8 Zeige Gleichung (2.6) unter der Annahme, daß das NewtonVerfahren konvergent sei, daß α eine einfache Nullstelle von f (x) = 0 und f in einer Umgebung von α zweimal stetig differenzierbar ist. Aufgabe 2.9 L¨ ose Problem 2.3 mit sich ver¨ anderndem β ∈ [0, π] f¨ ur folgende Achsenl¨ angen: a1 = 10 cm, a2 = 13 cm, a3 = 8 cm und a4 = 10 cm mit dem ur jeden Wert β Newton-Verfahren und einer Toleranz von 10−5 . Verwende f¨ zwei verschiedene Startwerte −0.1 bzw. 2π/3. Aufgabe 2.10 Die Funktion f (x) = ex − 2x2 hat drei Nullstellen, α1 < 0, ur welche Werte x(0) konvergiert das Newton-Verfahren α2 und α3 positiv. F¨ gegen α1 ? Aufgabe 2.11 Verwende das Newton-Verfahren zur Berechnung der Nullstelle von f (x) = x3 −3x2 2−x +3x4−x −8−x in [0, 1] und untersuche experimentell die Konvergenzordnung. Diese ist von Ordnung 2. Warum? Aufgabe 2.12 Ein Projektil wird mit einer Geschwindigkeit von v0 unter einer Neigung α in einen Raum der H¨ ohe h geschossen und erreicht die h¨ ochste Weite, wenn α gleich sin(α) = 2gh/v02 ist, wobei g = 9.8m/s2 die Erdbeschleunigung ist. Berechne α mit dem Newton-Verfahren, wenn v0 = 10m/s und h = 1m ist. Aufgabe 2.13 L¨ ose Problem 2.1 mit dem Newton-Verfahren und einer Toleranz tol=1.e-10 mit M = 6000 Euro, v = 1000 Euro, n = 5. Verwende als Startwert das nach f¨ unf Iterationen des Bisektionsverfahrens im Intervall (0.01, 0.1) erhaltene Ergebnis.

64

2 Nichtlineare Gleichungen

Aufgabe 2.14 Der Plan eines Flurs ist in 2.9 abgebildet. Die maximale L¨ ange L eines Balkens, der am Boden entlang um die Ecke paßt, ist durch L = l2 /(sin(π − γ − α)) + l1 / sin(α), gegeben, wobei α die L¨ osung folgender nichtlinearer Gleichung l2

cos(α) cos(π − γ − α) =0 − l1 2 2 sin (α) sin (π − γ − α)

(2.26)

ist. Berechne α mit dem Newton-Verfahren, wobei l2 = 10, l1 = 8 und γ = 3π/5 ist.

L

α

l1

γ

l2 Abb. 2.9. Das Problem des Balkens, der um eine Ecke passen muß, in 2D

Aufgabe 2.15 Sei φN die Iterationsfunktion des als Fixpunktverfahren betrachteten Newton-Verfahrens. Zeige, daß φ
N (α) = 1 − 1/m ist, wobei α eine Nullstelle mit der Vielfachheit m ist. Zeige, daß das Newton-Verfahren quadratisch konvergiert, falls α eine einfache Nullstelle von f (x) = 0 ist, und linear anderenfalls. Aufgabe 2.16 Zeige graphisch, daß die Funktion f (x) = x3 + 4x2 − 10 eine reelle Nullstelle α besitzt. Verwende zu deren Berechnung folgende Fixpunktiteration: sei x(0) gegeben, finde x(k+1) , so daß x(k+1) =

2(x(k) )3 + 4(x(k) )2 + 10 , 3(x(k) )2 + 8x(k)

k ≥ 0.

Untersuche die Konvergenz gegen α. Aufgabe 2.17 Untersuche die Konvergenz folgender Fixpunktiteration x(k+1) =

x(k) [(x(k) )2 + 3a] , 3(x(k) )2 + a

k ≥ 0,

zur Berechnung der Quadratwurzel der positiven Zahl a. Aufgabe 2.18 Wiederhole die Berechnungen aus Aufgabe 2.11, diesmal aber unter Verwendung des Residuums als Abbruchkriterium. Welches Kriterium liefert das genauere Ergebnis?

3 Approximation von Funktionen und Daten

Eine Funktion f zu approximieren bedeutet, eine einfachere Funktion f˜ zu finden, die wir stattdessen verwenden wollen. Diese Strategie wird b oft in der numerischen Integration angewendet, wo wir statt a f (x)dx b das Integral a f˜(x)dx berechnen, wobei f˜ eine einfach zu integrierende Funktion ist, zum Beispiel ein Polynom. Das werden wir im n¨achsten Kapitel sehen. In einem anderen Fall k¨ onnte die Funktion f nur teilweise u ¨ber die Werte in bestimmten Punkten bekannt sein. In diesem Fall wollen wir eine stetige Funktion f˜ konstruieren, die ein empirisch bestimmtes Naturgesetz beschreibt. Die zwei folgenden Beispiele geben uns eine Idee dieser Vorgehensweise. Problem 3.1 (Klimatologie) Die Lufttemperatur in Bodenn¨ ahe h¨ angt von der Kohlendioxydkonzentration K in der Umgebung ab. In Tabelle 3.1 (aus dem Philosophical Magazine 41, 237 (1896)) geben wir f¨ ur drei verschiedene Werte von K und verschiedene geographische Breiten die Temperaturschwankungen gegen¨ uber der momentanen mittleren Erdtemperatur (auf den Referenzwert K = 1 genormt) an. In diesem Fall k¨ onnen wir eine Funktion konstruieren, die anhand der verf¨ ugbaren Daten eine Approximation der mittleren Temperatur f¨ ur jede m¨ ogliche geographische Breite liefert (siehe Beispiel 3.1).

Problem 3.2 (Finanzwirtschaft) In Abbildung 3.1 geben wir den Preisverlauf eines Wertpapiers an der Frankfurter B¨ orse u ¨ber zwei Jahre wieder. Die Kurve haben wir erhalten, indem wir einfach die Schlußpreise jedes Tages mit einer geraden Linie verbunden haben. Mit dieser einfachen Darstellung haben wir implizit angenommen, daß sich der Preis w¨ ahrend des Tages nur linear ver¨ andert (wir nehmen hier vorweg, daß diese Approximation st¨ uckweise lineare Interpolation genannt wird). Wir k¨ onnen uns nun fragen, ob wir vielleicht aus diesem Graphen auch eine Vorhersage f¨ ur den kurzfristigen Verlauf des Aktienkurses treffen k¨ onnen. Wie wir in Abschnitt 3.4 sehen werden, k¨ onnen wir Informationen dieser Art mit der Methode der kleinsten Quadrate gewinnen (siehe Beispiel 3.8).

66

3 Approximation von Funktionen und Daten

Tabelle 3.1. Schwankung der mittleren Jahrestemperatur in Abh¨ angigkeit von der Kohlendioxydkonzentration K und der geographischen Breite geogr. Breite K = 0.67 K = 1.5 K = 2.0 K = 3.0 9.3 6.05 3.52 -3.1 65 9.3 6.02 3.62 -3.22 55 9.17 5.92 3.65 -3.3 45 8.82 5.7 3.52 -3.32 35 8.1 5.3 3.47 -3.17 25 7.52 5.02 3.25 -3.07 15 7.3 4.95 3.15 -3.02 5 7.35 4.97 3.15 -3.02 -5 7.62 5.07 3.2 -3.12 -15 8.22 5.35 3.27 -3.2 -25 8.8 5.62 3.52 -3.35 -35 9.25 5.95 3.7 -3.37 -45 9.5 6.1 3.7 -3.25 -55 16 14 12 10 8 6 4 2 0 nov00

mai01

nov01

mai02

Abb. 3.1. Schwankungen eines Wertpapierpreises im Verlauf von zwei Jahren

taylortool

Wie wir wissen, kann eine Funktion f in einem gegebenen Intervall durch deren Taylor-Polynom vom Grad n, eingef¨ uhrt in Abschnitt 1.4.3, approximiert werden. Diese Vorgehensweise ist allerdings sehr kostspielig, weil sie die Kenntnis von f und deren Ableitungen bis zur Ordnung n in einem gegebenen Punkt x0 verlangt. Außerdem approximiert das Taylor-Polynom f nicht mehr gut, falls wir uns von x0 entfernen. In Abbildung 3.2 vergleichen wir den Verlauf der Funktion f (x) = 1/x mit dem Verlauf ihres Taylor-Polynoms vom Grad 10 im Punkt x0 = 1. Dieses Bild erhalten wir auch mit der graphischen Oberfl¨ache des MATLABProgramms taylortool, mit dessen Hilfe wir das Taylor-Polynom beliebigen Grades einer jeden gegebenen Funktion f berechnen k¨onnen. Wie wir sehen k¨ onnen, entfernt sich das Taylor-Polynom immer weiter ur andere Funkvon der Funktion, je mehr wir uns von x0 entfernen. F¨ tionen, wie etwa die Exponentialfunktion, ist das gl¨ ucklicherweise nicht

3.1 Interpolation

67

der Fall. F¨ ur diese ist das Taylor-Polynom im Punkt x0 = 0 eine gute Approximation f¨ ur jeden Wert x ∈ R, falls der Grad n gen¨ ugend groß ist. 3

2

1

0 1

1.2

1.6

1.4

1.8

2

2.2

2.4

2.6

2.8

3

2 3 4 5 6 7 10 T (x) = 2−x+(x−1) −(x−1) +(x−1) −(x−1) +(x−1) −(x−1) +...+(x−1) 10

Abb. 3.2. Vergleich zwischen der Funktion f (x) = 1/x (feste Linie) und deren Taylor-Polynom vom Grad 10 bez¨ uglich des Entwicklungspunktes x0 = 1 (unterbrochene Linie). Der Ausdruck des Taylor-Polynoms ist in der Abbildung wiedergegeben

Im allgemeinen sind also andere Approximationsverfahren n¨otig, diese werden wir in den folgenden Abschnitten vorstellen.

3.1 Interpolation Wie wir in den Problemen 3.1 und 3.2 gesehen haben, kennt man eine Funktion in konkreten Anwendungen nur u ¨ber deren Werte in bestimmten Punkten. Nehmen wir daher an, n + 1 Wertepaare {xi , f (xi )}, i = 0, . . . , n, zu kennen, wobei die Werte xi , alle voneinander verschieden, Knoten genannt werden. Zum Beispiel ist im Fall von Tabelle 3.1 n gleich 12 und die Knour die geographische Breite aus der ersten Spalten xi sind die Werte f¨ origen (der Temperatur entsprechenden) te, w¨ahrend die f (xi ) die zugeh¨ Werte in den u ¨brigen Spalten sind. In diesem Fall scheint es nat¨ urlich, von der approximierenden Funktion f˜ zu verlangen, daß sie folgende Ungleichungen erf¨ ullt: f˜(xi ) = f (xi ), i = 0, 1, . . . , n

(3.1)

68

3 Approximation von Funktionen und Daten

Eine solche Funktion f˜ heißt Interpolator von f und die Gleichungen (3.1) sind die Interpolationsbedingungen. Es gibt verschiedene Arten von Interpolatoren, zum Beispiel -

den polynomialen Interpolator : f˜(x) = a0 + a1 x + a2 x2 + . . . + an xn ;

-

den trigonometrischen Interpolator : f˜(x) = a−M e−iM x + . . . + a0 + . . . + aM eiM x ,

-

wobei M eine ganze Zahl gleich n/2 (hier ist n stets gerade), und i die imagin¨ are Einheit ist; den rationalen Interpolator : f˜(x) =

a0 + a1 x + . . . + ak xk , ak+1 + ak+2 x + . . . an xn−(k+1)

0 ≤ k ≤ n − 2, n ≥ 2.

Wir wollen hier nur Interpolatoren betrachten, die linear von den n + 1 unbekannten Koeffizienten ai abh¨angen. Die polynomiale und die trigonometrische Interpolation geh¨ oren zu dieser Kategorie, die rationale nicht. 3.1.1 Polynomiale Lagrange-Interpolation Wir wollen uns nun auf die polynomiale Interpolation konzentrieren. Es gilt folgendes Resultat: Satz 3.1 F¨ ur jede Menge an Paaren {xi , yi }, i = 0, . . . , n, mit voneinander verschiedenen Knoten xi existiert ein eindeutiges Polynom vom Grad kleiner gleich n, das wir mit Πn bezeichnen und das die Werte yi in den Knoten xi interpoliert, so daß Πn (xi ) = yi , i = 0, . . . , n

(3.2)

gilt. Werden die Werte {yi , i = 0, . . . , n} von einer stetigen Funktion f (yi = f (xi )) angenommen, wird Πn Interpolationspolynom von f (kurz: Interpolator von f ) genannt und mit Πn f bezeichnet.

Wir wollen nun die Eindeutigkeit durch Widerspruch zeigen, indem wir annehmen, daß zwei Interpolationspolynome vom Grad n, Πn und ullen. Deren Differenz, Πn − Πn
, Πn
existieren, welche beide (3.2) erf¨ ist wieder ein Polynom vom Grad n, das in den n + 1 verschiedenen Punkten verschwindet. Aus einem bekannten Satz aus der Algebra folgt, daß dieses identisch null sein muß, also muß Πn
gleich Πn sein.

3.1 Interpolation

69

Um einen Ausdruck f¨ ur Πn zu erhalten, wollen wir zun¨achst mit einer sehr speziellen Funktion beginnen, deren yi alle null sind, außer in jenem Punkt, in dem i = k (f¨ ur gegebenes k) ist, und in dem yk = 1 ist. Setzen wir dann ϕk (x) = Πn (x), ist (siehe Abbildung 3.3)  1 falls j = k, ϕk ∈ Pn , ϕk (xj ) = δjk = 0 sonst (δjk ist das Kronecker-Symbol). 1 0.8 0.6 0.4 0.2 0 −0.2 −0.4 −0.6 0

0.5

0.25

0.75

1.25

1

1.5

1.75

2

Abb. 3.3. Das Polynom ϕ2 ∈ P4 , das zu den f¨ unf ¨ aquidistanten Knoten 0, 0.5, 1, 1.5 und 2 geh¨ ort

Die Funktionen ϕk k¨ onnen geschrieben werden als ϕk (x) =

n  x − xj , k = 0, . . . , n. x k − xj j=0 j
=k

Betrachten wir nun den allgemeinen Fall, in dem {yi , i = 0, . . . , n} eine Menge beliebiger Werte ist. Wegen des Superpositionsprinzips erhalten wir folgenden Ausdruck f¨ ur Πn Πn (x) =

n 

yk ϕk (x)

(3.3)

k=0

Tats¨achlich erf¨ ullt dieses Polynom die Interpolationsbedingungen (3.2), da Πn (xi ) =

n 

yk ϕk (xi ) =

k=0

n 

yk δik = yi ,

k=0

i = 0, . . . , n.

70

polyfit

3 Approximation von Funktionen und Daten

Aufgrund der bedeutenden Rolle, die die Funktionen {ϕk } spielen, werden diese charakteristische Polynome genannt und (3.3) heißt Lagrangesche Darstellung des Interpolationspolynoms. In MATLAB k¨ onnen wir die n+1 Paare {(xi , yi )} in zwei Vektoren abspeichern, zum Beispiel x und y, und mit der Anweisung c=polyfit(x,y,n) die Koeffizienten des Interpolationspolynoms erzeugen. Im speziellen enth¨ alt c(1) den Koeffizienten von xn , c(2) jenen von n−1 , . . . , und c(n+1) den Wert von Πn (0). N¨ahere Details zu diesem x Befehl finden sich in Abschnitt 3.4. Wie wir in Kapitel 1 gesehen haben, k¨onnen wir, sobald die Koeffizienten des Interpolationspolynoms bekannt sind, mit dem Befehl p=polyval(c,z) dessen Werte p(j) in m beliebigen Punkten z(j), j=1,...,m, berechnen. Falls die zu interpolierende Funktion bekannt ist und etwa in einer Zeichenkette f in Funktion von x abgespeichert ist, m¨ ussen wir nur die Knoten, in denen die Funktion f interpoliert werden soll, erzeugen, abspeichern und y=eval(f) setzen. Jetzt k¨onnen wir wieder wie im obigen Fall vorgehen, da die Vektoren x und y wieder gegeben sind. Beispiel 3.1 Wir berechnen das interpolierende Polynom vom Grad 4 f¨ ur jene Daten aus Problem 3.1, die einer Kohlendioxydkonzentration K gleich 0.67 (erste Spalte) entsprechen und verwenden jene Temperaturwerte, die den geographischen Breiten 65, 35, 5, -25, -55 entsprechen. Wir k¨ onnen folgende MATLAB-Befehle verwenden: >> x = [-55 -25 5 35 65]; y = [-3.25 -3.2 -3.02 -3.32 -3.1]; >> format short e; c=polyfit(x,y,4) c= 8.2819e-08 -4.5267e-07 -3.4684e-04 3.7757e-04 -3.0132e+00 Der Graph des Interpolationspolynoms kann dann folgendermaßen erzeugt werden: >> z=linspace(x(1),x(end),100); >> p=polyval(c,z); plot(z,p,x,y,’o’); Um eine glatte“ Darstellung des Polynoms zu erhalten, haben wir das Poly” nom in 101 a ¨quidistanten Punkten im Intervall [−55, 65] ausgewertet (wenn MATLAB eine Kurve zeichnet, werden einfach zwei aufeinanderfolgende Punkte durch eine Gerade verbunden). Mit der Anweisung x(end) k¨ onnen wir direkt auf die letzte Komponente des Vektors x zugreifen, ohne dessen L¨ ange zu kennen. In Abbildung 3.4 sind mit den (vollen und leeren) Kreisen alle verf¨ ugbaren Daten markiert, die vollen haben wir dabei f¨ ur die Konstruktion des Interpolationspolynoms verwendet. Wie wir sehen, werden auch die nichtverwendeten Daten (entsprechen den leeren Kreisen) in zufriedenstellender Weise rekonstruiert.

Dank des folgenden Resultates k¨ onnen wir auch den Fehler quantifizieren, wenn wir eine Funktion f durch deren Interpolationspolynom Πn f ersetzen:

3.1 Interpolation

71

−2.95

−3.05

−3.15

−3.25

−3.35

−3.45 −60

−40

−20

20

0

40

60

80

Abb. 3.4. Das Interpolationspolynom vom Grad 4 aus Beispiel 3.1

Satz 3.2 Sei I ein beschr¨ anktes Intervall und betrachten wir n + 1 verschiedene Interpolationsknoten {xi , i = 0, . . . , n} in I. Sei f bis zur Ordnung n + 1 in I stetig differenzierbar. Dann ∀x ∈ I ∃ξ ∈ I, so daß n f (n+1) (ξ)  (x − xi ) En f (x) = f (x) − Πn f (x) = (n + 1)! i=0

(3.4)

Klarerweise ist En f (xi ) = 0, i = 0, . . . , n. Das Resultat (3.4) kann noch genauer spezifiziert werden, falls die ur i = 1, . . . , n Knoten gleichm¨aßig verteilt sind, falls also xi = xi−1 + h f¨ f¨ ur gegebenes h > 0 und x0 . In diesem Fall (siehe Aufgabe 3.1) kann man ∀x ∈ (x0 , xn ) zeigen, daß   n   hn+1   (3.5)  (x − xi ) ≤ n!   4 i=0 und daher max|En f (x)| ≤ x∈I

max|f (n+1) (x)| x∈I

4(n + 1)

hn+1 .

(3.6)

Leider k¨ onnen wir aus (3.6) nicht schließen, daß der Fehler f¨ ur n → ∞ achlich gibt gegen 0 geht, obwohl hn+1 /[4(n + 1)] gegen 0 strebt. Tats¨ es Funktionen f , f¨ ur die der Grenzwert unendlich sein kann, also lim max|En f (x)| = ∞,

n→∞ x∈I

wie Beispiel 3.2 zeigt.

72

3 Approximation von Funktionen und Daten

Dieses Resultat zeigt, daß wir durch eine Erh¨ohung des Grades n des Interpolationspolynoms nicht notwendigerweise eine bessere Rekonstruktion der Funktion f erhalten. Wollten wir zum Beispiel alle Daten aus Tabelle 3.1, Spalte K = 0.67, interpolieren, w¨ urden wir das Polynom Π12 erhalten, das in Abbildung 3.5 dargestellt ist. Dessen Verhalten ist in einer Umgebung der linken Intervallgrenze weit weniger zufriedenstellend als das Verhalten des in Abbildung 3.4 dargestellten Polynoms, wo wir weniger Knoten verwendet hatten. Ein noch schlechteres Ergebnis erhalten wir f¨ ur eine andere Klasse von Funktionen, wie wir im n¨achsten Beispiel sehen. Beispiel 3.2 (Runge) Wenn wir die Funktion f (x) = 1/(1 + x2 ) (RungeFunktion genannt) auf einer Menge ¨ aquidistanter Knoten im Intervall I = (−5, 5) interpolieren, geht der Fehler maxx∈I |En f (x)| gegen unendlich, falls n → ∞. Der Grund hierf¨ ur ist, daß f¨ ur n → ∞ die Gr¨ oßenordnung von maxx∈I |f (n+1) (x)| die infinitesimale Ordnung von hn+1 /[4(n+1)] u ¨bertrifft. Dies k¨ onnen wir u ufen, indem wir das Maximum der Ableitungen von ¨berpr¨ f bis zur Ordnung 21 berechnen: >> syms x; n=20; f=’1/(1+xˆ2)’; df=diff(f,1); >> cdf = char(df); >> for i = 1:n+1, df = diff(df,1); cdfn = char(df); x = fzero(cdfn,0); M(i) = abs(eval(cdf)); cdf = cdfn; end Die Maxima der Absolutbetr¨ age der Funktionen f (n) , n = 1, . . . , 21, sind im Vektor M abgespeichert. Der Befehl char wandelt die symbolische Variable df in eine Zeichenkette um, die dann von der Funktion fzero ausgewertet werur n = 3, 9, 15, 21: den kann. Im speziellen sind die Absolutwerte von f (n) f¨ >> M([3,9,15,21]) = ans = 4.6686e+00 3.2426e+05

1.2160e+12

4.8421e+19 n

(x − xi )/(n + 1)!

w¨ ahrend die zugeh¨ origen Absolutwerte von i=0

>> z = linspace(-5,5,10000); >> for n=0:20; h=10/(n+1); x=[-5:h:5]; c=poly(x); r(n+1)=max(polyval(c,z));r(n+1)=r(n+1)/prod([1:n+2]); end >> r([3,9,15,21]) ans = 2.8935e+00 5.1813e-03 8.5854e-07 2.1461e-11 sind, wobei c=poly(x) ein Vektor ist, dessen Elemente die Koeffizienten jenes Polynoms sind, das als Nullstellen genau die Elemente des Vektors x hat. Daraus folgt, daß maxx∈I |En f (x)| folgende Werte >> format short e; 1.3509e+01 1.6801e+03

1.0442e+06

f¨ ur n = 3, 9, 15, 21 annimmt.

1.0399e+09

3.1 Interpolation

73

Die heftigen Oszillationen des Interpolationspolynoms, die sich in der N¨ ahe der Intervallgrenzen noch verst¨ arken, sind ebenfalls ein Zeichen f¨ ur die mangelnde Konvergenz (siehe Abbildung 3.5 rechts). Dieses Verhalten ist als Runge-Ph¨ anomen bekannt.

2

−2.7 −2.8

1 −2.9

0 −3

−1

−3.1 −3.2

−2 −3.3

−3 −3.4 −3.5 −60

−40

−20

60

40

20

0

80

−4 −5

1

−1

−3

3

5

Abb. 3.5. Zwei Beispiele f¨ ur das Runge-Ph¨ anomen: links Π12 f , berechnet f¨ ur die Daten aus Tabelle 3.1, Spalte K = 0.67; rechts Π12 f (in durchgehender Linie), berechnet auf 13 ¨ aquidistanten Knoten f¨ ur die Runge-Funktion f (x) = 1/(1 + x2 ) (in unterbrochener Linie)

1

0.8

π/n

0.6

0.4

0.2

0 −5

−3

−1

1

3

5

−1 = x0

xi

0

xn = 1

2

unner, durchAbb. 3.6. Links die Runge-Funktion f (x) = 1/(1 + x ) (in d¨ gehender Linie) im Vergleich mit dem Chebyshev-Interpolationspolynom vom Grad 8 (unterbrochene Linie) und 12 (in festerer, durchgezogener Linie). Beachte, wie die Oszillationen mit zunehmendem Grad ged¨ ampft werden und die Approximation immer genauer wird. Rechts geben wir die Verteilung der Chebyshev-Knoten im Intervall [−1, 1] wieder

Bemerkung 3.1 Man kann zeigen, daß folgende Ungleichung max|f
(x) − (Πn f )
(x)| ≤ Chn max|f (n+1) (x)| x∈I

x∈I

gilt, wobei C eine von h unabh¨ angige Konstante ist. Approximieren wir also die ussen wir erwarerste Ableitung von f durch die erste Ableitung von Πn f , m¨

74

polyder

3 Approximation von Funktionen und Daten

ten, eine Konvergenzordnung bez¨ uglich h zu verlieren. Beachte, daß (Πn f )
mit dem MATLAB-Befehl [d]=polyder(c) berechnet werden kann, wobei der Input-Parameter c ein Vektor ist, in dem die Koeffizienten des Interpolationspolynoms gespeichert sind, w¨ ahrend d der Vektor der Koeffizienten seiner Ableitung ist (siehe Abschnitt 1.4.2).

Siehe Aufgaben 3.1–3.4. 3.1.2 Chebyshev-Interpolation Das Runge-Ph¨ anomen kann vermieden werden, wenn man eine geeignete Verteilung der Knoten w¨ ahlt. Betrachten wir dazu die sogenannten Chebyshev-Knoten auf einem beliebigen Intervall [a, b] xi =

a+b b−a x i , wobei x i = − cos(πi/n), i = 0, . . . , n. + 2 2

(Nat¨ urlich ist xi = x i , i = 0, . . . , n, falls [a, b] = [−1, 1].) Man kann zeigen, daß, falls f eine stetige und stetig differenzierbare Funktion in [a, b] ist, das zu dieser speziellen Verteilung von Knoten geh¨orige Interpolatiur alle x ∈ [a, b] gegen f konvergiert f¨ ur n → ∞. onspolynom Πn f f¨ Die Chebyshev-Knoten, die den Abszissenwerten von ¨aquidistanten Knoten auf dem Einheitskreis entsprechen, geh¨oren zum Intervall [a, b] und verdichten sich in der N¨ ahe der Intervallgrenzen (siehe Abbildung 3.6 rechts). Eine andere Verteilung von Knoten auf dem Intervall [a, b], f¨ ur die dieselben Konvergenzeigenschaften gelten, ist gegeben durch   2i + 1 π a+b b−a , i = 0, . . . , n. cos − xi = n+1 2 2 2 Beispiel 3.3 Kommen wir noch einmal auf die Runge-Funktion zur¨ uck und interpolieren wir sie, indem wir die n + 1 Chebyshev-Knoten im Intervall [−5, 5] verwenden. Um sie zu erzeugen, verwenden wir folgende Befehle >> xc = -cos(pi*[0:n]/n); x = (a+b)*0.5+(b-a)*xc*0.5; wobei a und b die Grenzen des Interpolationsintervalls (in unserem Fall ist a=-5 und b=5) sind. Das Interpolationspolynom erzeugen wir dann mit folgenden Anweisungen: >> f= ’1./(1+x.ˆ2)’; y = eval(f); c = polyfit(x,y,n); Jetzt werten wir den Absolutbetrag der Differenzen von f und seinem Chebyshev-Interpolationspolynom in 1001 ¨ aquidistanten Punkten auf dem Intervall [−5, 5] aus und nehmen das Maximum der Fehler >> x = linspace(-5,5,1000); p=polyval(c,x); fx = eval(f); err = max(abs(p-fx)); Wie wir in Tabelle 3.2 sehen, nimmt der Fehler ab, wenn n zunimmt.

3.1 Interpolation

75

Tabelle 3.2. Der Interpolationsfehler f¨ ur die Runge-Funktion 5 0.6386

n En

10 0.1322

20 0.0177

40 0.0003

3.1.3 Trigonometrische Interpolation und FFT Wir m¨ ochten die periodische Funktion f : [0, 2π] → R mit f (0) = f (2π) mit einem trigonometrischen Polynom f˜ approximieren, das f in den n + 1 Knoten xj = 2πj/(n + 1), j = 0, . . . , n, interpoliert, das heißt f˜(xj ) = f (xj ), f¨ ur j = 0, . . . , n.

(3.7)

Den trigonometrischen Interpolator f˜ erh¨alt man durch eine Linearkombination von Sinus- und Cosinus-Funktionen. Im speziellen kann f˜ folgende Formen annehmen: falls n gerade ist, ist a0  + [ak cos(kx) + bk sin(kx)] , f˜(x) = 2 M

(3.8)

k=1

wobei M = n/2, w¨ahrend f¨ ur n ungerade a0  + [ak cos(kx) + bk sin(kx)] + aM +1 cos((M + 1)x)(3.9) f˜(x) = 2 M

k=1

ist, wobei M = (n − 1)/2. Wir k¨onnen (3.8) auch folgendermaßen schreiben f˜(x) =

M 

ck eikx ,

(3.10)

k=−M

wobei i die imagin¨are Einheit ist. Die Koeffizienten ck sind folgendermaßen an die Koeffizienten ak und bk gekn¨ upft: ak = ck + c−k , bk = i(ck − c−k ), k = 0, . . . , M.

(3.11)

Tats¨ achlich folgt aus (1.5), daß eikx = cos(kx) + i sin(kx) und M 

ikx

ck e

k=−M M 

=

k=1

=

M 

ck (cos(kx) + i sin(kx))

k=−M

[ck (cos(kx) + i sin(kx)) + c−k (cos(kx) − i sin(kx))] + c0 ,

76

3 Approximation von Funktionen und Daten

woraus (3.8) wegen (3.11) folgt. Anolog nimmt (3.9) folgende Form an, falls n ungerade ist: M +1 

f˜(x) =

ck eikx ,

(3.12)

k=−(M +1)

ur k = 0, . . . , M wie vorhin bestimmt werden, wobei die Koeffizienten ck f¨ w¨ahrend cM +1 = c−(M +1) = aM +1 /2. In beiden F¨allen k¨onnen wir M +µ 

f˜(x) =

ck eikx

(3.13)

k=−(M +µ)

schreiben, wobei µ = 0 ist, falls n gerade ist, und µ = 1, falls n ungerade ist. Wegen der Analogie zur Fourier-Reihenentwicklung wird f˜ auch (reelle) diskrete Fourier-Transformierte genannt. Setzen wir die Interpolationsbedingungen in den Knoten xj = jh mit h = 2π/(n + 1) ein, erhalten wir M +µ 

ck eikjh = f (xj ), j = 0, . . . , n.

(3.14)

k=−(M +µ)

Zur Berechnung der Koeffizienten {ck } multiplizieren wir beide Seiten von (3.14) mit e−imxj = e−imjh , wobei m eine ganze Zahl zwischen 0 und n ist, und summieren dann u ¨ber j n 

M +µ 

ikjh −imjh

ck e

e

j=0 k=−(M +µ)

=

n 

f (xj )e−imjh .

(3.15)

j=0

Betrachten wir jetzt folgende Gleichung n  eijh(k−m) = (n + 1)δkm , j=0

wobei δkm das Kronecker-Symbol ist. Diese ist klar, falls k = m. Falls k
= m, haben wir n  j=0

eijh(k−m) =

1 − (ei(k−m)h )n+1 , 1 − ei(k−m)h

der Z¨ahler auf der rechten Seite ist allerdings null, da 1 − ei(k−m)h(n+1) = 1 − ei(k−m)2π = 1 − cos((k − m)2π) − i sin((k − m)2π).

3.1 Interpolation

77

Folglich erhalten wir aus (3.15) einen expliziten Ausdruck f¨ ur die Koeffizienten von f˜

cm =

n 1  f (xj )e−imjh , m = −(M + µ), . . . , M + µ n + 1 j=0

(3.16)

Die Berechnung aller Koeffizienten {cm } kann mit einem rechnerischen Aufwand der Ordnung n log2 n Operationen durchgef¨ uhrt werden, indem wir die schnelle Fourier-Transformation (FFT) verwenden, die im MATLAB-Programm fft (siehe Beispiel 3.4) implementiert ist. Einen analogen Aufwand hat die R¨ ucktransformation, mit der man die Werte {f (xj )}, ausgehend von den Koeffizienten {ck }, findet. Die inverse schnelle Fourier-Transformation ist im Programm ifft implementiert.

fft ifft

Beispiel 3.4 Betrachten wir die Funktion f (x) = x(x − 2π)e−x f¨ ur x ∈ [0, 2π]. Um den MATLAB-Befehl fft verwenden zu k¨ onnen, werten wir die ur j = 0, . . . , 9 aus. Dann erhalten Funktion f in den Knoten xj = jπ/5 f¨ wir mit den Befehlen (wir erinnern daran, daß .* das komponentenweise Produkt zwischen Vektoren ist) >> x=pi/5*[0:9]; y=x.*(x-2*pi).*exp(-x); Y=fft(y); folgende Werte >> Y = Columns 1 through 3 -6.5203e+00 -4.6728e-01 + 4.2001e+00i 1.2681e+00 + 1.6211e+00i Columns 4 through 6 1.0985e+00 + 6.0080e-01i 9.2585e-01 + 2.1398e-01i 8.7010e-01 - 1.3887e16i Columns 7 through 9 9.2585e-01 - 2.1398e-01i 1.0985e+00 - 6.0080e-01i 1.2681e+00 - 1.6211e+00i Column 10 -4.6728e-01 - 4.2001e+00i

Die Koeffizienten {ck } sind dann einfach durch Y/length(Y) gegeben, wobei der Befehl length die Dimension eines Vektors (hier 10) berechnet. Falls n eine Potenz von 2 ist, ist das Programm ifft am effizientesten, es funktioniert aber f¨ ur alle Werte n.

Der Befehl interpft berechnet den trigonometrischen Interpolator einer Datenmenge. Er verlangt als Eingabeparameter eine ganze Zahl N und einen Vektor, dessen Komponenten die von der Funktion (periodisch mit Periode p) in den Punkten xi = ip/M , i = 1, . . . , M − 1 angenommenen Werte sind. Das Programm interpft gibt die N mit der Fourier-Transformation berechneten Werte des trigonometrischen Interuck. Betrachten polators in den Knoten ti = ip/N , i = 0, . . . , N − 1, zur¨ wir zum Beispiel die Funktion aus Beispiel 3.4 in [0, 2π], und werten wir sie in zehn ¨ aquidistanten Knoten xi = iπ/5, i = 0, . . . , 9, aus. Die Werte

interpft

78

3 Approximation von Funktionen und Daten

des trigonometrischen Interpolators, zum Beispiel in den 100 ¨aquidistanten Knoten ti = iπ/100, i = 0, . . . , 99, kann man auf folgende Weise berechnen (siehe Abbildung 3.7): >> x=pi/5*[0:9]; y=x.*(x-2*pi).*exp(-x); z=interpft(y,100);

0.5

0

−0.5

−1

−1.5

−2

−2.5 0

1

2

3

4

5

6

Abb. 3.7. Die Funktion f (x) = x(x − 2π)e−x (in unterbrochener Linie) und ihr trigonometrischer Interpolator (in durchgezogener Linie) bez¨ uglich zehn aquidistanter Knoten ¨

Die trigonometrische Interpolation kann in manchen F¨allen sehr ungenau sein, wie folgendes Beispiel zeigt: Beispiel 3.5 Approximieren wir die Funktion f (x) = f1 (x) + f2 (x), wobei aquidistante Knoten f1 (x) = sin(x) und f2 (x) = sin(5x) ist, indem wir neun ¨ im Intervall [0, 2π] verwenden. Das Ergebnis ist in Abbildung 3.8 dargestellt. Die trigonometrische Approximierende ist in gewissen Intervallen sogar die Phasenverkehrte von f .

Man kann dieses Verhalten dadurch erkl¨aren, daß sich die Funktion f2 in den betrachteten Knoten nicht von der Funktion f3 (x) = − sin(3x) unterscheidet, die eine niedrigere Frequenz hat (siehe Abbildung 3.9). Die Funktion, die approximiert wird, ist also F (x) = f1 (x) + f3 (x) und nicht f (x) (tats¨achlich ist der Graph in unterbrochener Linie in Abbildung 3.8 jener von F ). Dieses Ph¨ anomen heißt Aliasing und tritt immer dann auf, wenn in derselben Funktion Komponenten unterschiedlicher Frequenz vorkommen: solange die Anzahl der Knoten nicht ausreichend hoch ist, um die h¨ochsten Frequenzen aufzul¨ osen, k¨ onnen diese mit den niedrigeren Frequenzen interferieren und bewirken ungenaue Approximationen. Funktionen h¨oherer Frequenz k¨ onnen nur dann korrekt approximiert werden, wenn man die Anzahl der Knoten erh¨ oht.

3.1 Interpolation

79

2 1.5 1 0.5 0 −0.5 −1 −1.5 −2 1

2

3

4

6

5

Abb. 3.8. Die Effekte des Aliasing: Vergleich zwischen der Funktion f (x) = sin(x) + sin(5x) (durchgehende Linie) und ihrem trigonometrischen Interpolator (3.8) mit M = 3 (unterbrochene Linie)

Ein konkretes Beispiel f¨ ur Aliasing ist die scheinbare Umkehrung des Drehsinns eines Speichenrades: ab einer gewissen Geschwindigkeit ist unser Gehirn nicht mehr in der Lage, die bewegten Bilder gen¨ ugend genau zu verarbeiten und erzeugt in der Folge verkehrte Bilder.

2 1.5 1 0.5 0 −0.5 −1 −1.5 −2 1

2

3

4

5

6

Abb. 3.9. Das Ph¨ anomen des Aliasing: die Funktionen sin(5x) (in unterbrochener Linie) und − sin(3x) (in durchgehender Linie) nehmen in den Interpolationsknoten dieselben Werte an. Das erkl¨ art die große Ungenauigkeit in Abbildung 3.8

Zusammenfassend 1. Eine Menge an Daten oder eine Funktion f in [a, b] zu approximieren heißt, eine Funktion f˜ zu finden, die diese gen¨ ugend genau darstellt;

80

3 Approximation von Funktionen und Daten

2. Der Interpolationsprozeß besteht darin, eine Funktion f˜ zu finden, so daß f˜(xi ) = yi , wobei die {xi } die gegebenen Knoten und die {yi } entweder die Werte zu {f (xi )} oder eine Menge gegebener Werte sind; 3. Falls die n + 1 Knoten {xi } voneinander verschieden sind, dann existiert ein eindeutiges Polynom vom Grad kleiner gleich n, das die Menge der gegebenen Werte {yi } in den Knoten {xi } interpoliert; 4. F¨ ur eine ¨ aquidistante Verteilung der Knoten [a, b] strebt der Interpolationsfehler in jedem Punkt von [a, b] nicht notwendigerweise gegen 0, wenn n gegen unendlich geht. Es gibt allerdings besondere Verteilungen der Knoten, wie zum Beispiel jene von Chebyshev, f¨ ur die diese Konvergenzeigenschaft f¨ ur alle stetigen und differenzierbaren Funktionen gilt; 5. Die trigonometrische Interpolation ist am besten zur Interpolation periodischer Funktionen geeignet, indem f˜ als Linearkombination von Sinus- und Cosinusfunktionen gew¨ahlt wird. Die FFT ist ein besonders effizienter Algorithmus zur Berechnung der FourierKoeffizienten des trigonometrischen Interpolators, ausgehend von seinen Knoten. Der Umkehralgorithmus, die IFFT, ist genauso effizient.

3.2 Stu ¨ ckweise lineare Interpolation Falls f eine Funktion ist, deren analytische Form bekannt ist, liefert die Chebyshev-Interpolation eine recht zufriedenstellende Approximation. F¨ ur den Fall, daß f nur u ¨ber seine Werte auf einer beliebigen Menge von Punkten (die nicht mit den Chebyshev-Knoten zusammenfallen) bekannt ist, k¨ onnen wir auf ein anderes Interpolationsverfahren zur¨ uckgreifen, die zusammengesetzte lineare Interpolation. Ist eine Verteilung von Knoten x0 < x1 < . . . < xn−1 < xn gegeben, bezeichnen wir mit Ii das Intervall [xi , xi+1 ]. Approximieren wir f durch eine global stetige Funktion, die auf jedem Intervall durch das Segment gegeben ist, das die Punkte (xi , f (xi )) und (xi+1 , f (xi+1 )) verbindet (siehe Abbildung 3.10). Diese Funktion, mit Π1H f bezeichnet, heißt st¨ uckweise lineares Interpolationspolynom und wird folgendermaßen ausgedr¨ uckt: Π1H f (x) = f (xi ) +

f (xi+1 ) − f (xi ) (x − xi ) fr x ∈ Ii . xi+1 − xi

Der hochgestellte Index H bezeichnet die maximale L¨ange der Intervalle Ii . Folgendes Resultat kann von (3.6) abgeleitet werden, indem wir n = 1 und h = H setzen:

3.3 Approximation durch Spline-Funktionen

81

80 70 60 50 40 30 20 10 0 −2

0

2

4

6

8

Abb. 3.10. Die Funktion f (x) = x2 + 10/(sin(x) + 1.2) (in durchgehender Linie) und ihr st¨ uckweise lineares Interpolationspolynom Π1H f (in unterbrochener Linie)

Satz 3.3 Falls f ∈ C 2 (I) mit I = [x0 , xn ] ist, dann gilt max|f (x) − Π1H f (x)| ≤ x∈I

H2 max|f

(x)|. 8 x∈I

Folglich strebt f¨ ur jedes x im Interpolationsintervall Π1H f (x) gegen f (x), falls H → 0 und f gen¨ ugend glatt ist. onnen wir die Werte Mit Hilfe des Befehls s1=interp1(x,y,z) k¨ in beliebigen Punkten, gespeichert in einem Vektor z, des st¨ uckweise linearen Polynoms, das die Werte y(i) in den Knoten x(i), f¨ ur i = 1,...,n+1, interpoliert, berechnen. Sind die Interpolationsknoten in wachsender Reihenfolge gegeben, (d.h. x(i+1) > x(i), f¨ ur i=1,...,n) dann k¨onnen wir die rechnerisch effizientere Version interp1q (q steht f¨ ur quickly) verwenden. Wir m¨ochten hier anmerken, daß der Befehl fplot zum Zeichnen eines Graphen einer Funktion f auf einem gegebenen Intervall [a, b] tats¨achlich den Graph des st¨ uckweise linearen Interpolanten von f zeichnet. Die Menge der Interpolationsknoten wird automatisch von MATLAB erzeugt, und zwar indem an den Stellen, wo f stark variiert, die Knoten dichter gestreut werden. Diese Vorgehensweise wird Adaptivit¨ at genannt.

3.3 Approximation durch Spline-Funktionen Nat¨ urlich k¨onnen wir auch eine st¨ uckweise Interpolation h¨ oheren, etwa quadratischen Grades (die wir mit Π2H f bezeichnen) definieren, also eine

interp1

interp1q

82

3 Approximation von Funktionen und Daten

stetige Funktion, die, eingeschr¨ ankt auf jedes Teilintervall Ii , ein Polynom vom Grad 2 ist. Falls f ∈ C 3 (I), ist der Fehler von Ordnung 3 bez¨ uglich H. Der gr¨ oßte Nachteil der st¨ uckweisen Interpolation (linear oder vom Grad k ≥ 1) ist, daß die Funktion ΠkH f nur in den Punkten {xi } stetig ist. Andererseits sind in vielen Anwendungen, etwa in der Computergraphik, approximierende Funktionen notwendig, die wenigstens stetig differenzierbar sind. Zu diesem Zweck konstruieren wir eine Funktion s3 , die folgende Eigenschaften hat: 1. auf jedem Intervall Ii = [xi , xi+1 ], f¨ ur i = 0, . . . , n − 1, sei s3 ein ur j = Polynom dritten Grades, das die Wertepaare (xj , f (xj )), f¨ i, i + 1, interpoliert; 2. die erste und zweite Ableitung von s3 seien in jedem Punkt xi , i = 1, . . . , n − 1, stetig. Zu deren vollst¨ andiger Bestimmung m¨ ussen wir auf jedem Intervall vier Bedingungen zuweisen, insgesamt also folgende 4n Gleichungen: - n + 1 Bedingungen aus der Vorschrift, s3 interpoliere die Daten in den Knoten xi , i = 0, . . . , n; - n − 1 Bedingungen aus der Vorschrift, s3 sei in den inneren Knoten x1 , . . . , xn−1 stetig; - indem wir auch verlangen, daß die erste und zweite Ableitung in denselben Knoten stetig seien, erhalten wir zus¨atzliche 2(n − 1) Gleichungen. Es fehlen schließlich noch zwei Gleichungen, die wir zum Beispiel durch s

3 (x0 ) = 0, s

3 (xn ) = 0

spline

(3.17)

urliches vorgeben k¨ onnen. Die so charakterisierte Funktion s3 wird nat¨ interpolierendes kubisches Spline genannt. Wenn wir die Unbekannten zur Darstellung von s3 geeignet w¨ahlen (siehe [QSS02], Abschnitt 8.6), k¨ onnen wir s3 bestimmen, indem wir ein lineares System der Dimension (n + 1) × (n + 1) mit tridiagonaler Matrix l¨osen. Die L¨ osung eines tridiagonalen Systems erh¨alt man durch eine zu n proportionale Anzahl von Operationen (wie wir in Abschnitt 5.4 sehen werden). Die Wahl (3.17) ist nicht die einzig m¨ogliche, um das Gleichungssystem zu vervollst¨ andigen. Eine Alternative zu (3.17) besteht darin, zu verlangen, daß die dritte Ableitung von s3 in den Knoten x1 und xn−1 stetig sei. Diese Bedingung (die mit dem seltsamen Namen not-aKnot-Condition bezeichnet wird) ist im MATLAB-Befehl spline (siehe auch die Toolbox splines) implementiert. Die Eingabeparameter sind die Vektoren x und y der zu interpolierenden Daten und der Vektor z der Punkte, in denen wir s3 auswerten wollen.

3.3 Approximation durch Spline-Funktionen

83

Beispiel 3.6 Betrachten wir die Daten aus Tabelle 3.1, die zur Spalte K = 0.67 geh¨ oren und berechnen das dazugeh¨ orige interpolierende kubische Spline s3 . Falls wir s3 (zi ) auswerten wollen, wobei zi = −55 + i, i = 0, . . . , 120, k¨ onnen wir folgendermaßen vorgehen >> x = [-55:10:65]; >> y = [-3.25 -3.37 -3.35 -3.2 -3.12 -3.02 -3.07 -3.17 -3.32 -3.3 -3.22 -3.1]; >> z = [-55:1:65]; >> s = spline(x,y,z);

-3.02 ...

Der Graph von s3 , dargestellt in Abbildung 3.11, scheint plausibler als der vom Lagrange-Interpolator in denselben Knoten erzeugte.

−2.7 −2.8 −2.9 −3 −3.1 −3.2 −3.3 −3.4 −3.5 −60

−40

−20

0

20

40

60

Abb. 3.11. Vergleich zwischen kubischem Spline und interpolierendem Lagrange-Polynom f¨ ur den in Beispiel 3.6 diskutierten Fall

Der Fehler, den man begeht, wenn man eine Funktion f (stetig differenzierbar bis zur vierten Ordnung) mit dem nat¨ urlichen interpolierenden Spline s3 approximiert, erf¨ ullt folgende Ungleichungen (r)

max|f (r) (x) − s3 (x)| ≤ Cr H 4−r max|f (4) (x)|, r = 0, 1, 2, 3, x∈I

x∈I

wobei I = [x0 , xn ] und H = maxi=0,... ,n−1 (xi+1 − xi ) ist, w¨ahrend Cr eine geeignete Konstante abh¨ angig von r, aber unabh¨angig von H, ist. Es ist also klar, daß nicht nur die Funktion f , sondern auch deren erste, zweite und dritte Ableitung gut von der Funktion s3 approximiert werden, falls H gegen 0 strebt. Bemerkung 3.2 Die kubischen Splines erhalten im allgemeinen die Monotonie zwischen benachbarten Knoten nicht. Wollen wir etwa den Einheitskreis ur im ersten Quadranten in den Punkten {(xk = sin(kπ/6), yk = cos(kπ/6)), f¨ k = 0, . . . , 3}, approximieren, erhalten wir das oszillierende Spline aus Abbildung 3.12. In diesen F¨ allen sind andere Approximationstechniken besser geeig-

84

pchip

3 Approximation von Funktionen und Daten

net. Zum Beispiel erzeugt der MATLAB-Befehl pchip einen zusammengesetzten kubischen Interpolator Π3H f , der die lokale Monotonie des Interpolators garantiert (siehe Abbildung 3.12). Diesen Interpolator, Interpolator von Hermite genannt, erhalten wir u ¨ber folgende Befehle >> >> >> >>

t = linspace(0,pi/2,4) x = cos(t); y = sin(t); xx = linspace(0,1,40); plot(x,y,’s’,xx,[pchip(x,y,xx);spline(x,y,xx)])

1

0.8

0.6

0.4

0.2

0 0

0.2

0.4

0.6

0.8

1

Abb. 3.12. Approximation des ersten Viertels der Einheitskreislinie unter Verwendung von nur vier Knoten. Die unterbrochene Linie ist der Graph des interpolierenden kubischen Splines, w¨ ahrend die durchgehende Linie der zugeh¨ orige st¨ uckweise kubische Hermitesche Interpolator ist

Siehe Aufgaben 3.5–3.8.

3.4 Das Verfahren der kleinsten Quadrate Wir haben schon festgestellt, daß die polynomiale Lagrange-Interpolation mit steigendem Polynomgrad nicht eine h¨ohere Genauigkeit der Approximation einer Funktion garantiert. Dieses Problem haben wir mit der st¨ uckweise polynomialen Interpolation (wie zum Beispiel der st¨ uckweise linearen oder den Splines) gel¨ ost. Diese ist allerdings nicht zur Extrapolation von Informationen aus bekannten Daten geeignet, also zur Auswertung von neuen Punkten außerhalb des Interpolationsintervalls.

3.4 Das Verfahren der kleinsten Quadrate

85

Beispiel 3.7 Aufgrund der in Abbildung 3.1 angegebenen Daten m¨ ochten wir voraussagen, ob der Aktienpreis in den kommenden Tagen steigen oder fallen wird. Die polynomiale Lagrange-Interpolation ist in der Praxis ungeeignet, da ein (¨ außerst stark) oszillierendes Polynom vom Grad 719 ben¨ otigt w¨ urde, das aber eine v¨ ollig unbrauchbare Vorhersage liefert. Andererseits berechnet das st¨ uckweise lineare Polynom, dessen Graph in Abbildung 3.1 wiedergegeben ist, einen extrapolierten Wert nur unter der Verwendung der letzten zwei verf¨ ugbaren Werte und vernachl¨ assigt alle anderen. Um ein besseres Resultat zu erhalten, wollen wir die Interpolation vermeiden und verfahren wie folgt.

Angenommen, wir verf¨ ugen u ¨ber eine Menge von Daten {(xi , yi ), i = 0, . . . , n} (wobei die yi die Werte f (xi ) sein k¨onnen, die eine Funktion in den Knoten xi annimmt). Wir suchen ein Polynom f˜ von mindestens Grad m ≥ 1 (im allgemeinen ist m  n), das folgende Ungleichung n 

[yi − f˜(xi )]2 ≤

i=0

n 

[yi − pm (xi )]2

(3.18)

i=0

f¨ ur jedes Polynom pm von mindestens Grad m erf¨ ullt. Wir sagen, daß f˜ (falls existent) die Datenmenge im Sinn der kleinsten Quadrate approximiert. Falls m < n, ist es nun nicht mehr m¨ oglich zu garantieren, daß ur i = 0, . . . , n. f˜(xi ) = yi f¨ Setzen wir f˜(x) = a0 + a1 x + . . . + am xm ,

(3.19)

onnen wir Problem wobei die Koeffizienten a0 , . . . , am unbekannt sind, k¨ (3.18) folgendermaßen umformulieren Φ(a0 , a1 , . . . , am ) =

min

Φ(b0 , b1 , . . . , bm ),

{bi , i=0,... ,m}

wobei Φ(b0 , b1 , . . . , bm ) =

n 

2

[yi − (b0 + b1 xi + . . . + bm xm i )] .

i=0

L¨osen wir dieses Problem f¨ ur m = 1. Da n   2  yi + b20 + b21 x2i + 2b0 b1 xi − 2b0 yi − 2b1 xi yi , Φ(b0 , b1 ) = i=0

ist der Graph der Funktion Φ ein konvexes Paraboloid, dessen Minimum (a0 , a1 ) wir finden, indem wir die Bedingungen ∂Φ ∂Φ (a0 , a1 ) = 0 (a0 , a1 ) = 0, ∂b1 ∂b0

86

3 Approximation von Funktionen und Daten

stellen, wobei das Symbol ∂Φ/∂bj die partielle Ableitung von Φ bez¨ uglich bj (siehe Definition 8.3) bezeichnet. Berechnen wir explizit die beiden partiellen Ableitungen, erhalten wir folgende zwei Gleichungen in den zwei Unbekannten a0 und a1 n 

[a0 + a1 xi − yi ] = 0,

i=0

n 

[a0 xi + a1 x2i − xi yi ] = 0

i=0

bzw. a0 (n + 1) + a1 a0

n  xi + i=0

n 

xi =

i=0 n  a1 x2i i=0

=

n 

yi ,

i=0 n 

(3.20)

yi xi .

i=0

n

n x2i − ( i=0 xi )2 , ist die L¨osung ⎡ ⎤ n n n n 1 ⎣  2   yi x − xj xi yi ⎦ , a0 = D i=0 j=0 j j=0 i=0 ⎡ ⎤ n n n    1 ⎣ xj yi ⎦ . (n + 1) xi yi − a1 = D i=0 j=0 i=0

Setzen wir D = (n + 1)

i=0

Das zugeh¨ orige Polynom f˜(x) = a0 + a1 x ist bekannt als Gerade der kleinsten Quadrate oder Regressionsgerade. Obiger Ansatz kann auf den Fall eines beliebigen ganzen m (mit m < n) verallgemeinert werden. Das zugeh¨orige symmetrische lineare (m + 1) × (m + 1)-System hat folgende Form a0 (n + 1) +a1 a0

n 

xi

+a1

i=0

a0

i=0

polyfit

i=0 n 

xi x2i

+ . . . + am + . . . + am

i=0

.. .

n 

n 

xm i

+a1

.. . n  i=0

n  i=0 n 

xm i

xm+1 = i

i=0

xm+1 i

+ . . . + am

.. . n  i=0

=

.. . x2m i

=

n  i=0 n 

yi , xi yi ,

i=0 n 

xm i yi .

i=0

Falls m = n, f¨ allt das Polynom der kleinsten Quadrate f˜ mit dem durch Lagrangesche Interpolation Πn f erhaltenen zusammen (siehe Aufgabe 3.9). Der MATLAB-Befehl c=polyfit(x,y,m) berechnet standardm¨aßig die Koeffizienten des Polynoms vom Grad m, das die n+1 Datenpaare

3.4 Das Verfahren der kleinsten Quadrate

87

(x(i),y(i)) im Sinn der kleinsten Quadrate approximiert. Wie wir schon in Abschnitt 3.1.1 gesehen haben, wird im Fall m gleich n das Interpolationspolynom berechnet. Beispiel 3.8 In Abbildung 3.13 sind die Graphen der Polynome vom Grad 1, 2 und 4 dargestellt, die die Daten aus Abbildung 3.1 approximieren. Das Polynom der kleinsten Quadrate vom Grad 4 stellt den Kursverlauf der Aktie im betrachteten Zeitraum gut dar und l¨ aßt vermuten, daß die Aktie in n¨ achster Zukunft steigen k¨ onnte.

15

10

5

0 nov00

nov01

mai01

mai02

Abb. 3.13. Approximation von Problem 3.2 im Sinn der kleinsten Quadrate; das Polynom f˜ vom Grad 1 ist in Strich-Punkt-Linie (lineare Regressionsgerade), jenes vom Grad 2 in unterbrochener Linie und jenes vom Grad 4 in dicker durchgezogener Linie dargestellt. Die exakten Daten des Problems sind in d¨ unner Linie dargestellt

Eine weitere Verallgemeinerung besteht darin, in (3.18) Funktionen zu verwenden, die nicht algebraische Polynome sind. Wir ersetzen also Minimierungsproblem (3.18) durch folgendes: finde f˜ ∈ Vm , so daß n  i=0

[yi − f˜(xi )]2 ≤

n 

[yi − qm (xi )]2

(3.21)

i=0

f¨ ur alle qm ∈ Vm , wobei Vm jenen Funktionenraum bezeichnet, den wir aus der Linearkombination m verschiedener, linear unabh¨angiger Funktionen {ψj , j = 0, . . . , m} erhalten. Beispiele solcher Funktionen sind ur einen geetwa die trigonometrischen Funktionen ψj (x) = cos(γjx) (f¨ ur gebenen Parameter γ
= 0), die Exponentialfunktionen ψj = eδjx (f¨ ein δ > 0) oder eine geeignete Menge von Spline-Funktionen.

88

3 Approximation von Funktionen und Daten

Die Wahl der Funktionen {ψj } wird im allgemeinen durch das zu erwartende Gesetz, dem die gegebenen Daten folgen, bestimmt. So ist in Abbildung 3.14 der Graph der Approximation der kleinsten Quadrate der Daten aus Beispiel 3.1 dargestellt, wir haben diesen berechnet, indem wir die trigonometrischen Funktionen ψj (x) = cos(jt(x)), j = 0, . . . , 4 mit t(x) = 60π(x + 55) als Basis verwendet haben. Wir nehmen an, die Daten sind periodisch mit Periode 60π. −3 −3.05 −3.1 −3.15 −3.2 −3.25 −3.3 −3.35 −3.4 −60

−40

−20

0

20

40

60

80

Abb. 3.14. Approximation der kleinsten Quadrate der Daten aus Beispiel 3.1 unter Verwendung einer Cosinus-Basis. Die exakten Daten sind durch kleine Kreise dargestellt

Wir u ufen, daß die unbekannten ¨berlassen es dem Leser zu u ¨berpr¨ Koeffizienten der L¨ osung f˜(x) =

m 

ai ψi (x)

i=0

von Problem (3.21) berechnet werden k¨ onnen, indem wir Gleichungssystem B T Ba = B T y l¨osen. B ist hier die (n + 1) × (m + 1)-Matrix mit den Eintr¨agen bij = ψj (xi ), a der Vektor der m + 1 unbekannten Koeffizienten und y der Vektor der n + 1 Daten.

3.5 Was wir nicht erw¨ ahnt haben

89

Zusammenfassend 1. Der st¨ uckweise lineare Interpolator einer Funktion f ist eine st¨ uckweise stetige, lineare Funktion f˜, die f in einer gegebenen Menge von Punkten {xi } interpoliert. Auf diese Weise werden die RungeOszillationen vermieden, die entstehen, sobald die Anzahl von Punkten steigt; 2. Aus der Interpolation mit kubischen Spline-Funktionen erh¨alt man eine interpolierende Funktion f˜, die einem st¨ uckweisen Polynom dritten Grades entspricht, das stetig ist, genauso wie dessen erste und zweite Ableitung; 3. Bei der Approximation im Sinne der kleinsten Quadrate sucht man ˜ nach einem Polynom fn vom Grad m < n, das die Summe der mittleurlich kann man ren Fehlerquadrate i=0 [yi − f˜(xi )]2 minimiert. Nat¨ dasselbe Kriterium auch auf eine Klasse von Funktionen f˜ anwenden, die nicht notwendigerweise Polynome sind. Siehe Aufgaben 3.9–3.13.

3.5 Was wir nicht erw¨ ahnt haben F¨ ur eine allgemeinere Einf¨ uhrung in die Theorie der Interpolation und Approximation verweisen wir auf [Dav63], [Mei67] und [Gau97]. Die polynomiale Interpolation kann auf den Fall von Funktionen oder Daten in mehreren Dimensionen erweitert werden. Im speziellen eignen sich die st¨ uckweise lineare Interpolation und die Spline-Interpolation gut f¨ ur diese Aufgabe, wenn das Gebiet Ω in Polygone (Dreiecke oder Vierecke in zwei, Tetraeder oder Prismen in drei Dimensionen) unterteilt wird. Eine besonders leichte Situation ergibt sich, falls Ω ein Rechteck oder Parallelepiped ist. In diesem Fall k¨ onnen wir einfach die Befehle zi=interp2(x, y,z,xi,yi) oder vi=interp3(x,y,z,v,xi,yi,zi), verwenden, wobei x, ..., v die zu interpolierenden Werte sind und xi, ..., zi die Knoten, in denen das interpolierende Polynom ausgewertet werden soll. Um etwa die Werte der Funktion f (x, y) = sin(2πx) cos(2πy) mit einem kubischen Spline auf einem Gitter von 36 ¨ aquidistanten Knoten auf dem Quadrat [0, 1]2 zu approximieren, verwenden wir folgende Befehle >> [x,y]=meshgrid(0:0.2:1,0:0.2:1); z=sin(2*pi*x).*cos(2*pi*y); Das interpolierende kubische Spline, ausgewertet auf einem dichteren Gitter von 441 Knoten (21 ¨ aquidistante in jeder Richtung), erhalten wir auf folgende Weise: >> xi = [0:0.05:1]; yi=[0:0.05:1]; >> [xf,yf]=meshgrid(xi,yi); pi3=interp2(x,y,z,xf,yf,’spline’);

interp2 interp3

90

meshgrid

griddata

pdetool

spdemos rpmak rsmak

wavelet

3 Approximation von Funktionen und Daten

Der Befehl meshgrid verwandelt die Menge aller Punkte der Form (xi(k),yi(j)) in zwei Matrizen xf und yf, die dazu verwendet werden k¨onnen, die Funktionen in zwei Variablen auszuwerten und Graphen von dreidimensionalen Oberfl¨ achen in MATLAB zu zeichnen. Die Zeilen der Matrix xf sind Kopien des Vektors xi, w¨ahrend die Spalten der Matrix yf Kopien des Vektors yi sind. Alternativ k¨onnen wir ur dreidimensionale Dadie Funktion griddata verwenden, die auch f¨ tens¨atze (griddata3) oder f¨ ur die Approximation von n-dimensionalen ugbar ist. Oberfl¨achen (griddatan) verf¨ Falls Ω ein beliebiges zweidimensionales Gebiet ist, k¨onnen wir die graphische Oberfl¨ ache pdetool verwenden, um das Gebiet in Dreiecke zu zerlegen. F¨ ur eine allgemeine Darstellung der Spline-Funktionen siehe etwa [Die93] und [PBP02]. Mit der MATLAB-Toolbox splines k¨onnen verschiedene weitere Anwendungen von Splines untersucht werden. Spezionnen die Eigenschaften der wichtigsten ell mit dem Befehl spdemos k¨ Spline-Familien veranschaulicht werden. Mit den Befehlen rpmak und rsmak k¨onnen zudem rationale Spline-Funktionen aufgerufen werden, die durch den Quotienten zweier Splines gegeben sind. Ein beeindruckendes Beispiel f¨ ur rationale Splines sind die sogenannten NURBS, h¨aufig im CAGD (Computer Assisted Geometric Design) verwendet. Im Kontext der Fourier-Approximation m¨ochten wir auf die Approximation mittels Wavelets hinweisen, die sehr h¨aufig in der Bild- und Signalverarbeitung angewandt werden (f¨ ur eine Einf¨ uhrung siehe etwa [DL92], [Urb02]). Eine große Sammlung von Wavelets (sowie Beispiele und Anwendungen) findet sich in der MATLAB-Toolbox wavelet.

3.6 Aufgaben Aufgabe 3.1 Zeige Ungleichung (3.5). Aufgabe 3.2 Gib eine obere Schranke f¨ ur den Lagrange-Interpolationsfehler f¨ ur folgende Funktionen an: f1 (x) = cosh(x), f2 (x) = sinh(x), xk = −1 + 0.5k, k = 0, . . . , 4, xk = −π/2 + πk/4, k = 0, . . . , 4. f3 (x) = cos(x) + sin(x), Aufgabe 3.3 Die Daten in der folgenden Tabelle beziehen sich auf die Lebenserwartung (in Jahren) der Einwohner in zwei verschiedenen Regionen Europas: 1975 1980 1985 1990 Westeuropa 72.8 74.2 75.2 76.4 Osteuropa 70.2 70.2 70.3 71.2

3.6 Aufgaben

91

Verwende das Polynom dritten Grades, um die Lebenserwartung in den Jahren 1970, 1983 und 1988 zu bestimmen. Extrapoliere den Wert f¨ ur das Jahr 1995. Man weiß, daß 1970 die Lebenserwartung in Westeuropa 71.8 Jahre und in Osteuropa 69.6 Jahre betrug. Unter Verwendung dieser Daten sch¨ atze die Genauigkeit der Vorhersage f¨ ur 1995 ab. Aufgabe 3.4 Der Preis in Euro f¨ ur eine Zeitschrift hat folgenden Verlauf: N ov.87 Dez.88 N ov.90 Jan.93 Jan.95 Jan.96 N ov.96 N ov.00 4.5 5.0 6.0 6.5 7.0 7.5 8.0 8.0

Sch¨ atze anhand dieser Daten den Preis f¨ ur 2001. Aufgabe 3.5 Wiederhole die Berechnungen aus Aufgabe 3.3 und verwende das interpolierende kubische Spline, erzeugt mit dem Befehl spline. Vergleiche die mit den zwei Ans¨ atzen erhaltenen Resultate. Aufgabe 3.6 In folgender Tabelle ist die Dichte ρ (in kg/m3 ) von Meereswasser in Abh¨ angigkeit von der Temperatur T (in Grad Celsius) wiedergegeben

8o 12o 16o 20o T 4o ρ 1000.7794 1000.6427 1000.2805 999.7165 998.9700

Berechne das interpolierende kubische Spline auf vier Teilintervallen des Temperaturintervalls [4, 20]. Vergleiche das Ergebnis mit folgenden Daten (die weiteren Messungen von T entsprechen):

10o 14o 18o T 6o ρ 1000.74088 1000.4882 1000.0224 999.3650

Aufgabe 3.7 Italiens Produktion von Zitrusfr¨ uchten hat sich folgendermaßen entwickelt:

1965 1970 1980 1985 1990 1991 Jahr Produktion (×105 kg) 17769 24001 25961 34336 29036 33417

Verwende ein interpolierendes kubisches Spline, um die Produktion in den Jahren 1962, 1977 und 1992 zu sch¨ atzen und vergleiche mit der realen Produktion, die jeweils 12380, 27403 und 32059 ×105 kg betragen hat. Man vergleiche dieses Resultat mit jenem, das man mit einem Lagrange-Interpolationspolynom erhalten w¨ urde. Aufgabe 3.8 Werte die Funktion f (x) = sin(2πx) in 21 ¨ aquidistanten Knoten im Intervall [−1, 1] aus. Berechne das Lagrange-Interpolationspolynom und das interpolierende kubische Spline und vergleiche im gegebenen Intervall die Graphen jener Kurven mit dem Graph von f . Wiederhole die Berechnungen f¨ ur folgende Menge von gest¨ orten Daten {f (xi ) + (−1)i+1 10−4 } und beobachte, wie das interpolierende Lagrange-Polynom sensibler auf kleine St¨ orungen der Daten reagiert als das kubische Spline.

92

3 Approximation von Funktionen und Daten

Aufgabe 3.9 Zeige f¨ ur den Fall m = n und yi = f (xi ) (f¨ ur eine beliebige Funktion f ), daß das Polynom der kleinsten Quadrate in den Knoten allt. x0 , . . . , xn mit Πn f zusammenf¨ Aufgabe 3.10 Berechne das Polynom vierten Grades, das die Daten der zweiten, dritten und vierten Spalte von Tabelle 3.1 im Sinn der kleinsten Quadrate approximiert. Aufgabe 3.11 Wiederhole die Berechnungen aus Aufgabe 3.7 unter Verwendung des Polynoms der kleinsten Quadrate vom Grad 3. Aufgabe 3.12 Dr¨ ucke die Koeffizienten des Systems (3.20) in Funktion des n 2 1 Mittelwertes M = (N1+1) n i=0 (xi − M ) i=0 xi und der Varianz v = (N +1) der Datenmenge {xi , i = 0, . . . , n} aus. ¨ Aufgabe 3.13 Uberpr¨ ufe, daß die Regressionsgerade den Punkt (¯ x, y¯) schneidet, mit n

x ¯=

n

1 1 yi . xi , y¯ = n + 1 i=0 n + 1 i=0

4 Numerische Differentiation und Integration

In diesem Kapitel stellen wir Verfahren zur numerischen Approximation von Ableitungen und Integralen von Funktionen vor. F¨ ur die Integration etwa l¨aßt sich nicht immer eine explizite Stammfunktion einer Funktion finden. Auch f¨ ur den Fall, daß man sie kennt, k¨ onnte es schwierig sein, sie auszuwerten. Im Fall von f (x) = cos(4x) cos(3 sin(x)) etwa erh¨alt man π 0

 4  ∞ (−9/4)k 3 . f (x) dx = π k!(k + 4)! 2 k=0

Das Problem, ein Integral zu berechnen, hat sich also in ein ebenso schwieriges Problem, die Berechnung der Summe einer Reihe, verwandelt. Weiters kann es oft vorkommen, daß die Funktion, die man integrieren oder ableiten m¨ochte, nur in einigen Punkten bekannt ist (etwa als Ergebnis einer Messung), genau wie wir es in Kapitel 3 u ¨ber die Approximation von Funktionen besprochen haben. In all diesen Situationen ist es daher notwendig, numerische Verfahren anzuwenden, die eine N¨aherung des Wertes liefern, an dem wir interessiert sind, ganz unabh¨angig davon, wie komplex die zu integrierende oder differenzierende Funktion auch sein m¨oge. Problem 4.1 (Hydraulik) Der Fl¨ ussigkeitsstand q(t) (in Metern) in einem Rohr mit dem Durchmesser r = 10 cm wird zu verschiedenen Zeitpunkten t gemessen:

5 10 15 20 t 0.0 q(t) 1.0 0.8811 0.7366 0.5430 0.1698

Wir wissen, daß die Fl¨ ussigkeitsh¨ ohe zu Beginn 1m betr¨ agt. Wir wollen die Ausflußgeschwindigkeit q
(t) approximieren und mit der theoretisch zu erwartenden Ausflußgeschwindigkeit vergleichen. Diese ist gegeben durch q
(t) = −0.6πr2 19.6q(t)/A(t), wobei r der Radius des Rohres und A(t) der Querschnitt des Rohres bei einer H¨ ohe q(t) ist. F¨ ur die L¨ osung dieses Problems siehe Beispiel 4.1.

94

4 Numerische Differentiation und Integration

Problem 4.2 (Optik) F¨ ur die Planung eines Labors f¨ ur Infrarotstrahlung m¨ ussen wir die von einem schwarzen K¨ orper ins (infrarote) Spektrum ausgesandte Energie im Bereich der Wellenl¨ angen von 3µm bis 14µm berechnen. Die L¨ osung dieses Problems erhalten wir, indem wir folgendes Integral (erhalten aus der Planck-Gleichung) berechnen: 14·10−4

E(T ) = 2.39 · 10

−11 3·10−4

dx , x5 (e1.432/(T x) − 1)

(4.1)

wobei x die Wellenl¨ ange (in cm) und T die Temperatur (in Grad Kelvin) des schwarzen K¨ orpers bezeichnet. F¨ ur die L¨ osung dieses Problems siehe Aufgabe 4.17.

Problem 4.3 (Elektromagnetismus) Betrachten wir eine elektrisch leitf¨ ahige Sph¨ are mit dem unbestimmtem Radius r und der Leitf¨ ahigkeit σ. Wir wollen den Verlauf der Stromdichte j in Abh¨ angigkeit von r und der Zeit t bestimmen, wobei wir zum Anfangszeitpunkt die Verteilung der Stromdichte ρ(r) kennen. Das Problem kann gel¨ ost werden, indem wir die Gleichungen verwenden, die die Stromdichte, das elektrische Feld und die Ladungsdichte in Verbindung setzen und indem wir beobachten, daß aufgrund der Symmetrie des Problems j(r, t) = j(r, t)r/|r| gilt, wobei j = |j|. Wir erhalten −σt/ε0

j(r, t) = j(r)e

r

σ , j(r) = ε0 r2

ρ(ξ)ξ 2 dξ,

(4.2)

0

wobei ε0 = 8.859 · 10−12 Farad/m die dielektrische Konstante im Vakuum ist. F¨ ur die Berechnung von j(r) siehe Aufgabe 4.16.

4.1 Approximation der Ableitung Betrachten wir die Funktion f : [a, b] → R, die in [a, b] stetig differenzierbar sei. Wir wollen ihre erste Ableitung in einem beliebigen Punkt x¯ in (a, b) approximieren. Wegen Definition (1.9) k¨onnen wir annehmen, daß f¨ ur h gen¨ ugend klein und positiv

(δ+ f )(¯ x) =

f (¯ x + h) − f (¯ x) h

(4.3)

eine Approximation von f
(¯ x) ist, man nennt sie finite Vorw¨ artsdifferenz. Um den Fehler abzusch¨atzen, betrachten wir die Taylor-Entwicklung zweiter Ordnung von f in einer Umgebung der Breite h > 0 rechts von x ¯. Wir erhalten x) + f (¯ x + h) = f (¯ x) + hf
(¯

h2

f (ξ), 2

wobei ξ ein beliebiger Punkt in (¯ x, x ¯ + h) ist. Daher ist

(4.4)

4.1 Approximation der Ableitung

(δ+ f )(¯ x) = f
(¯ x) +

h

f (ξ) 2

95

(4.5)

und folglich ist (δ+ f )(¯ x) eine Approximation erster Ordnung von f
(¯ x) bez¨ uglich h. Auf analoge Weise erhalten wir aus der Entwicklung f (¯ x − h) = f (¯ x) − hf
(¯ x) +

h2

f (η), 2

(4.6)

mit η ∈ (¯ x − h, x ¯), folgende Formel, genannt finite R¨ uckw¨artsdifferenz :

(δ− f )(¯ x) =

f (¯ x) − f (¯ x − h) h

(4.7)

Das ist ebenfalls eine Approximation erster Ordnung von f
(¯ x). Beachte, daß die Formeln (4.3) und (4.7) auch erhalten werden k¨ onnen, indem wir das lineare Interpolationspolynom von f in den Knoten {¯ x, x ¯ + h} bzw. {¯ x − h, x ¯} ableiten. Tats¨achlich n¨ahern die eingef¨ uhrten Approximatiox) durch die Steigung der Geraden durch die Punkte (¯ x, f (¯ x)) nen f
(¯ und (¯ x + h, f (¯ x + h)), bzw. (¯ x − h, f (¯ x − h)) und (¯ x, f (¯ x)) an (siehe Abbildung 4.1). x) m1 = (δ− f )(¯

m2 = (δ+ f )(¯ x)

m3 = (δf )(¯ x)

x ¯−h

x ¯

f

x ¯+h

Abb. 4.1. Finite-Differenzen-Approximation von f
(¯ x): mit R¨ uckw¨ artsdifferenzen (durchgehende Linie), Vorw¨ artsdifferenzen (punktierte Linie) und zentralen Differenzen (unterbrochene Linie). m1 , m2 und m3 sind die Steigungen der eingezeichneten Geraden

Schließlich f¨ uhren wir noch die Formel der zentralen finiten Differenzen (δf )(¯ x) =

f (¯ x + h) − f (¯ x − h) 2h

(4.8)

ein, die f
(¯ x) mit zweiter Ordnung bez¨ uglich h approximiert. Tats¨ achlich ist

96

4 Numerische Differentiation und Integration

f
(¯ x) − (δf )(¯ x) =

h2


[f (ξ) + f


(η)], 12

(4.9)

wobei η und ξ beliebige Punkte in den Intervallen (¯ x−h, x ¯) bzw. (¯ x, x ¯ +h) sind (siehe Aufgabe 4.2). Wenn wir (4.8) verwenden, wird f
(¯ x) durch die Steigung der Geraden durch (¯ x − h, f (¯ x − h)) und (¯ x + h, f (¯ x + h)) approximiert. Beispiel 4.1 L¨ osen wir Problem 4.1, indem wir die Formeln (4.3), (4.7) und unf verschiedenen Zeitpunkten zu (4.8) mit h = 5 verwenden, um q
(t) zu f¨ approximieren. Wir erhalten

0.0 5 10 15 20 t q
(t) −0.0220 −0.0259 −0.0326 −0.0473 −0.1504 −− δ+ q −0.0238 −0.0289 −0.0387 −0.0746 −− −0.0238 −0.0289 −0.0387 −0.0746 δ− q −− −0.0263 −0.0338 −0.0567 −− δq

Wie wir sehen, stimmt die exakte und die mit den Differenzenformeln mit h = 5 berechnete Ableitung f¨ ur (4.8) besser u ¨berein als mit (4.7) oder (4.3).

Im allgemeinen k¨ onnen wir annehmen, daß die Werte einer Funktion ugbar sind. f in n + 1 ¨aquidistanten Punkten xi = x0 + ih mit h > 0 verf¨ In diesem Fall kann die numerische Ableitung von f
(xi ) durch eine ihrer Approximationen (4.3), (4.7) oder (4.8) mit x¯ = xi ersetzt werden. Die zentrale Differenz (4.8) kann nur in den Punkten x1 , . . . , xn−1 und nicht an den R¨ andern x0 und xn angewandt werden. In diesen Punkten k¨onnen wir die Werte 1 [−3f (x0 ) + 4f (x1 ) − f (x2 )] in x0 , 2h 1 [3f (xn ) − 4f (xn−1 ) + f (xn−2 )] in xn 2h

(4.10)

verwenden, die ebenfalls eine Genauigkeit zweiter Ordnung bez¨ uglich h haben. Wir haben diese erhalten, indem wir im Punkt x0 (bzw. xn ) die erste Ableitung des f in x0 , x1 , x2 (bzw. xn−2 , xn−1 , xn ) interpolierenden Polynoms vom Grad 2 berechnen. Siehe Aufgaben 4.1–4.4.

4.2 Numerische Integration In diesem Abschnitt wollen wir geeignete numerische Verfahren zur Approximation des Integrals b I(f ) =

f (x) dx a

4.2 Numerische Integration

97

vorstellen, wobei f eine beliebige stetige Funktion in [a, b] ist. Wir wollen mit einigen einfachen Formeln beginnen; sp¨ ater wird sich herausstellen, daß diese Formeln Teil der gr¨ oßeren Familie der sogenannten NewtonCotes-Formeln sind. 4.2.1 Die Mittelpunktsformel Ein einfaches Verfahren zur Approximation von I(f ) besteht darin, das Intervall [a, b] in Teilintervalle Ik = [xk−1 , xk ], k = 1, . . . , M , mit xk = a + kH, k = 0, . . . , M , H = (b − a)/M , zu teilen. Da I(f ) =

M  

f (x) dx,

(4.11)

k=1I k

k¨onnen wir auf jedem Teilintervall Ik das Integral f durch das Integral eines Polynoms f¯, das f in Ik approximiert, ersetzen. Die einfachste L¨osung besteht darin, f¯ als konstantes Polynom zu w¨ahlen, das f im Mittelpunkt des Intervalls Ik interpoliert: x ¯k =

xk−1 + xk . 2

Auf diese Weise erhalten wir die zusammengesetzte Mittelpunktsformel

z Imp (f ) = H

M 

f (¯ xk )

(4.12)

k=1

Der tiefgestellte Index mp steht f¨ ur Mittelpunkt, w¨ ahrend der hochgestellte Index z f¨ ur zusammengesetzt steht. Diese Formel besitzt die Genauigkeitsordnung 2 bez¨ uglich H. Falls f zweimal stetig differenzierbar ist, dann ist z (f ) = I(f ) − Imp

b − a 2

H f (ξ) 24

(4.13)

f¨ ur einen Punkt ξ in (a, b) (siehe Aufgabe 4.6). Die Formel (4.12) ist wegen ihrer geometrischen Interpretation auch als zusammengesetzte Rechtecksregel bekannt, wie wir in Abbildung 4.2 leicht sehen k¨onnen. Die klassische Mittelpunktsformel (auch bekannt als Rechtecksformel ) erh¨alt man, indem man in (4.12) M = 1 w¨ahlt, d.h. die Mittelpunktsformel direkt auf dem Intervall (a, b) anwendet:

Imp (f ) = (b − a)f [(a + b)/2]

(4.14)

98

4 Numerische Differentiation und Integration

f

f

x

x x ¯0

x ¯k

x ¯M

a

(a + b)/2

b

Abb. 4.2. Die zusammengesetzte Mittelpunktsformel (links) und die Mittelpunktsformel (rechts)

Der Fehler ist hier gegeben durch I(f ) − Imp (f ) =

(b − a)3

f (ξ) 24

(4.15)

f¨ ur einen geeigneten Punkt ξ in (a, b). Gleichung (4.15) folgt als Spezialfall aus (4.13), kann aber auch direkt gezeigt werden, da man mit x ¯ = (a + b)/2 b [f (x) − f (¯ x)] dx

I(f ) − Imp (f ) = a

b =

1 f (¯ x)(x − x ¯) dx + 2


b

f

(η(x))(x − x ¯)2 dx

a

a

erh¨alt, wobei η(x) ein geeigneter Punkt zwischen x und x ¯ ist. b ¯) dx = 0 und wegen des Gleichung (4.15) folgt dann wegen a (x − x Mittelwertsatzes ∃ξ ∈ (a, b), so daß 1 2

b a

1 f (η(x))(x − x ¯) dx = f

(ξ) 2



2

b

(x − x ¯)2 dx =

(b − a)3

f (ξ). 24

a

Der Exaktheitsgrad einer Quadraturformel ist die gr¨oßte ganze Zahl r ≥ 0, f¨ ur die das approximierte Integral (erhalten mit der Quadraturformel) eines beliebigen Polynoms vom Grad r gleich dem exakten Integral ist. Die Mittelpunktsformel hat den Exaktheitsgrad 1, da sie alle Polynome vom Grad kleiner gleich 1 exakt integriert. Die zusammengesetzte Mittelpunktsformel ist in Programm 6 implementiert. Die Eingabeparameter sind die Grenzen des Integrationsintervalls a und b, die Anzahl der Teilintervalle M und die Function f, die den Ausdruck des Integranden f enth¨alt.

4.2 Numerische Integration

99

Programm 6 - midpointc : zusammengesetzte Mittelpunktsformel function Imp=midpointc(a,b,M,f,varargin) %MIDPOINTC Zusammengesetzte Mittelpunktsformel. % IMP = MIDPOINTC(A,B,M,FUN) berechnet eine Approximation des % Integrals der Funktion FUN mit der zusammengesetzten % Mittelpunktsformel (auf M aequidistanten Intervallen). % FUN ist eine Function, die als Eingangsparameter % einen Vektor x erhaelt und einen reellen Vektor zurueckgibt. % FUN kann eine Inline-Function sein. % IMP = MIDPOINT(A,B,M,FUN,P1,P2,...) uebergibt der function FUN % die optionalen Parameter P1,P2,... als FUN(X,P1,P2,...). H=(b-a)/M; x = linspace(a+H/2,b-H/2,M); fmp=feval(f,x,varargin{:}).*ones(1,M); Imp=H*sum(fmp); return

Siehe Aufgaben 4.5–4.8. 4.2.2 Die Trapezformel Falls wir zur Approximation des Integrals von f auf dem Intervall (a, b) das zusammengesetzte Interpolationspolynom Π1H f , eingef¨ uhrt in Abschnitt 3.2, verwenden (wir ersetzen also auf jedem Teilintervall Ik = (xk−1 , xk ) die Funktion f durch die f an den Grenzen xk−1 und xk interpolierende Gerade), erhalten wir die sogenannte zusammengesetzte Trapezformel H [f (xk−1 ) + f (xk )] 2 k=1 M −1  H f (xk ) = [f (a) + f (b)] + H 2 M

Itc (f ) =

(4.16)

k=1

Diese Formel besitzt die Genauigkeitsordnung 2 bez¨ uglich H. Tats¨ achlich erhalten wir den Ausdruck I(f ) − Itc (f ) = −

b − a 2

H f (ξ) 12

(4.17)

f¨ ur ein geeignetes ξ ∈ (a, b), falls f ∈ C 2 (a, b). Verwenden wir (4.16) mit M = 1, erhalten wir die Formel

100

4 Numerische Differentiation und Integration

It (f ) =

b−a [f (a) + f (b)] 2

(4.18)

die wegen ihrer geometrischen Interpretation Trapezformel genannt wird (siehe Abbildung 4.3). Der Fehler dieser Formel ist I(f ) − It (f ) = −

(b − a)3

f (ξ) 12

(4.19)

mit geeignetem ξ in (a, b); daraus sehen wir sofort, daß (4.18) wie die Mittelpunktsformel den Exaktheitsgrad 1 hat. Mit einer einfachen Modifikation k¨onnen wir bereits viel genauere Ergebnisse erreichen. Ersetzen wir n¨amlich auf jedem Intervall Ik die Funktion f durch ihr interpolierendes Polynom vom Grad 1, allerdings in den sogenannten Gauß-Knoten     H 1 xk − xk−1 1 xk−1 + xk √ √ , = xk−1 + 1 − − γk−1 = 2 2 2 3 3     H 1 xk − xk−1 1 xk−1 + xk = xk−1 + 1 + √ +√ γk = 2 2 3 2 3

berechnet, erhalten wir anstelle von (4.16) folgende Gaußsche Quadraturformel

H [f (γk−1 ) + f (γk )] 2 M

c IGauss (f ) =

(4.20)

k=1

Diese hat Genauigkeitsordnung 4 (bez¨ uglich H), da f¨ ur jedes f ∈ C 4 (a, b) c (f ) = I(f ) − IGauss

b − a 4 (4) H f (ξ) 4320

gilt, wobei ξ ein geeigneter Punkt in (a, b) ist (siehe [RR85]). Angewandt auf nur ein Intervall wird (4.20) zu f

x0 = a

xk

f

x xM = b

x0 = a

x x1 = b

Abb. 4.3. Zusammengesetzte Trapezformel (links) und einfache Trapezformel (rechts)

4.2 Numerische Integration

IGauss (f ) =

wobei

1 a+b −√ γ0 = 2 3



(b − a) [f (γ0 ) + f (γ1 )] 2

b−a 2



1 a+b +√ , γ1 = 2 3



101

(4.21)

b−a 2

 .

Der zugeh¨orige Fehler betr¨ agt I(f ) − IGauss (f ) =

(b − a)5 (4) f (η) 4320

f¨ ur ein geeignetes η ∈ (a, b). Diese Formel hat den Exaktheitsgrad 3, sie integriert also alle Polynome bis zum Grad kleiner gleich 3 exakt. In Programm 7 sind die Formeln (4.16) und (4.20) implementiert: zu deren Auswahl setze man choice=1 f¨ ur die erste und choice=2 f¨ ur die zweite. Die einfache Trapezformel (4.18) ist auch im MATLABProgramm trapz implementiert, w¨ ahrend die zusammengesetzte Trapezformel (4.16) in cumtrapz implementiert ist.

Programm 7 - trapc : zusammengesetzte Trapezformel und Gaußsche Quadraturformel function [Itpc]=trapc(a,b,M,f,choice,varargin) %TRAPC Zusammengesetzte Trapezformel und Gausssche Quadraturformel. % ITPC = TRAPC(A,B,M,FUN,CHOICE) berechnet eine Approximation % des Integrals von FUN mit der zusammengesetzten Trapezformel % (auf M aequidistanten Intervallen), falls CHOICE=1, und mit % der Gaussschen Quadraturformel, falls CHOICE=2. FUN ist eine % Function, die als Eingabeparameter einen Vektor x erhaelt und einen % reellen Vektor zurueckgibt. FUN kann auch eine Inline-Function sein. % ITPC = TRAPC(A,B,M,FUN,CHOICE,P1,P2,...) uebergibt der % Function FUN die optionalen Parameter P1,P2,... als FUN(X,P1,P2,...). H=(b-a)/M; switch choice case 1, x=linspace(a,b,M+1); fpm=feval(f,x,varargin{:}).*ones(1,M+1); fpm(2:end-1)=2*fpm(2:end-1); Itpc=0.5*H*sum(fpm); case 2, z=linspace(a,b,M+1); x=z(1:end-1)+H/2*(1-1/sqrt(3)); x=[x, x+H/sqrt(3)]; fpm=feval(f,x,varargin{:}).*ones(1,2*M); Itpc=0.5*H*sum(fpm); otherwise disp(’Unbekannte Formel’); end return

trapz cumtrapz

102

4 Numerische Differentiation und Integration 2π

Beispiel 4.2 Berechnen wir I(f ) = 0 xe−x cos(2x) dx (dessen exakter Wert bis zur sechzehnten Stelle −0.122122604618968 ist), indem wir die Programme 6 und 7 aufrufen. Dazu definieren wir den Integranden in einer Inline-Function >> f=inline(’x.*exp(-x).*cos(2*x)’,’x’); und rufen dann die oben erw¨ ahnten Programme auf, indem wir fortw¨ ahrend die Integrationsschrittweite H verkleinern. Beachte die Verwendung des Punktes in den Operationen zur Definition des Integranden (MATLAB wertet diesen Ausdruck n¨ amlich in einem Vektor von Punkten aus, weshalb die Operationen elementweise durchgef¨ uhrt werden m¨ ussen). In Abbildung 4.4 werden (in logarithmischer Skala) die Fehler der zusammengesetzten Mittelpunktsformel, Trapezformel und Gauß-Formel in Funktion des Logarithmus der Schrittweite H dargestellt. Wie wir bereits in Abschnitt 1.5 gesehen haben, entsprechen den Geraden mit gr¨ oßerer Steigung Formeln h¨ oherer Ordnung. W¨ ahrend die Trapezformel und die Mittelpunktsformel die Konvergenzordnung 2 haben, hat die Gaußsche Quadraturformel die Konvergenzordnung 4.

0

10

−2

10

−4

10

−6

2

10

1

−8

10

−10

10

4

−12

10

1 −14

10

−3

10

−2

10

−1

10

0

10

1

10

Abb. 4.4. Logarithmus der Fehler aus der zusammengesetzten Gauß-Formel (in durchgezogener Linie mit Kreisen), der Mittelpunktsformel (in durchgezogener Linie) und der Trapezformel (in unterbrochener Linie) unter variierendem H

Siehe Aufgaben 4.9–4.11. 4.2.3 Die Simpson-Formel Die Simpson-Formel erhalten wir, indem wir das Integral von f auf jedem Ik durch das Integral seines Interpolationspolynoms vom Grad 2 in den ¯k = (xk−1 + xk )/2 und xk ersetzen. Die resultierende Knoten xk−1 , x Formel lautet

4.2 Numerische Integration

103

4(xk−1 − x)(x − xk ) 2(x − x ¯k )(x − xk ) f (¯ xk ) f (xk−1 ) + H2 H2 2(x − x ¯k )(x − xk−1 ) f (xk ). + H2

Die daraus erhaltene Formel wird zusammengesetzte Simpson-Quadraturformel genannt und ist durch H [f (xk−1 ) + 4f (¯ xk ) + f (xk )] 6 M

Isc (f ) =

(4.22)

k=1

gegeben. Man kann zeigen, daß f¨ ur den Quadraturfehler I(f ) − Isc (f ) = −

b − a H 4 (4) f (ξ) 180 16

(4.23)

gilt, wobei ξ ein geeigneter Punkt in (a, b) ist, und falls f ∈ C 4 (a, b). Die Formel besitzt die Genauigkeitsordnung 4 bez¨ uglich H. Falls wir (4.22) auf nur ein Intervall (a, b) anwenden, erhalten wir die einfache Simpson-Quadraturformel Is (f ) =

b−a [f (a) + 4f ((a + b)/2) + f (b)] 6

(4.24)

Der Fehler ist jetzt I(f ) − Is (f ) = −

1 (b − a)5 (4) f (ξ) 16 180

(4.25)

f¨ ur ein geeignetes ξ ∈ (a, b). Der Exaktheitsgrad ist also gleich 3. Die zusammengesetzte Simpson-Formel ist in Programm 8 implementiert. Programm 8 - simpsonc : zusammengesetzte Simpson-Formel function [Isic]=simpsonc(a,b,M,f,varargin) %SIMPSONC Zusammengesetzte Simpson-Formel % ISIC = SIMPSONC(A,B,M,FUN) berechnet eine Approximation des % Integrals der Funktion FUN mit der zusammengesetzten Simpson-Formel % (auf M aequidistanten Intervallen). FUN ist eine Function, die als % Eingabeparameter einen Vektor x erhaelt und einen reellen % Vektoren zurueckgibt. FUN kann auch eine Inline-Function sein. % ISIC = SIMPSONC(A,B,M,FUN,P1,P2,...) uebergibt der Function FUN % die optionalen Parameter P1,P2,... als FUN(X,P1,P2,...). H=(b-a)/M; x=linspace(a,b,M+1); fpm=feval(f,x,varargin{:}).*ones(1,M+1);

104

4 Numerische Differentiation und Integration

fpm(2:end-1) = 2*fpm(2:end-1); Isic=H*sum(fpm)/6; x=linspace(a+H/2,b-H/2,M); fpm=feval(f,x,varargin{:}).*ones(1,M); Isic = Isic+2*H*sum(fpm)/3; return Bemerkung 4.1 (Interpolationsformeln) Alle Quadraturformeln, die wir bisher gesehen haben, sind Spezialf¨ alle allgemeinerer Formeln der Form J

Iappr (f ) =

αj f (yj )

(4.26)

j=1

quadl quad8

Die reellen Zahlen αj heißen Quadraturgewichte, w¨ ahrend die Punkte yj Quadraturknoten genannt werden. Im allgemeinen wird verlangt, daß (4.26) wenigstens f¨ ur konstante Funktionen exakt ist; das ist genau dann der Fall, wenn Jj=1 αj = (b − a). Werden Knoten und Gewichte geeignet gew¨ ahlt, kann die Genauigkeitsordnung der Formeln (4.26) beliebig gesteigert werden. In MATLAB kann auchlichen man mit dem Befehl quadl(fun,a,b) (oder dem nicht mehr gebr¨ quad8), die Integrale mit einer Gauß-Lobatto-Formel h¨ oherer Ordnung berechnen. Die Funktion fun kann auch eine Inline Function sein. Um zum Beispiel f (x) = 1/x in [1, 2] zu integrieren, definieren wir zuerst die Funktion fun fun=inline(’1./x’,’x’); und rufen dann quadl(fun,1,2) auf. Es ist nicht notwendig, die Anzahl der Teilintervalle anzugeben, da diese automatisch vom Programm festgelegt wird, um zu garantieren, daß der Quadraturfehler sicher kleiner als die voreingestellte Toleranz von 10−3 ist. Um eine andere Toleranz tol festzulegen, gen¨ ugt das erweiterte quadl(fun,a,b,tol). In Abschnitt 4.3 werden wir eine Technik einf¨ uhren, die es erlaubt, den Quadraturfehler abzusch¨ atzen und in der Folge die Integrationsschrittweite anzupassen.

Zusammenfassend 1. Eine Quadraturformel approximiert das Integral einer stetigen Funktion f auf einem Intervall (a, b); 2. Sie besteht im allgemeinen aus einer Linearkombination der Werte von f in bestimmten Punkten (Quadraturknoten), multipliziert mit geeigneten Koeffizienten (Quadraturgewichte); 3. Der Exaktheitsgrad einer Quadraturformel ist der h¨ochste Grad jener Polynome, die von der Formel exakt integriert werden. Dieser Grad ist f¨ ur die Mittelpunkts- und die Trapezformel gleich 1 und f¨ ur die Simpson- und Gauß-Formel gleich 3;

4.3 Die adaptive Simpson-Formel

105

4. Eine zusammengesetzte Quadraturformel hat eine Genauigkeitsordnung p, falls der Fehler wie H p gegen 0 strebt, wenn H gegen 0 strebt, wobei H die Breite der Teilintervalle ist. Die Genauigkeitsordnung ist f¨ ur die zusammengesetzte Mittelpunkts- und Trapezformel gleich 2, f¨ ur die zusammengesetzten Simpson- und Gauß-Formeln gleich 4. L¨ose Aufgaben 4.12–4.18.

4.3 Die adaptive Simpson-Formel Die Integrationsschrittweite H einer zusammengesetzten Quadraturformel kann so gew¨ ahlt werden, daß der Fehler kleiner ist als eine gewisse vorher festgelegte Toleranz ε > 0. Falls wir zum Beispiel die zusammengesetzte Simpson-Formel (4.22) anwenden, gen¨ ugt es aufgrund von (4.23), b − a H4 max |f (4) (x)| < ε 180 16 x∈[a,b]

(4.27)

zu w¨ahlen, wobei f (4) die vierte Ableitung von f bezeichnet. Falls allerdings der Absolutbetrag von f (4) nur in einem kleinen Abschnitt des Integrationsintervalls groß ist, dann kann der gr¨oßte Wert H, f¨ ur den (4.27) erf¨ ullt ist, sehr klein sein. Das Ziel der adaptiven Simpson-Formel ist, eine Approximation von I(f ) innerhalb einer festgelegten Toleranz ε zu berechnen, und zwar mit einer ungleichm¨ aßigen Verteilung der Teilintervalle im Intervall [a, b]. Auf diese Weise wird dieselbe Genauigkeit wie die der zusammengesetzten Formel garantiert, allerdings mit einer geringeren Anzahl von Intervallen (und folglich weniger Auswertungen von f ). Zu diesem Zweck m¨ ussen wir also einen Fehlersch¨atzer und einen Automatismus finden, der bei Erf¨ ullen der geforderten Toleranz die Integrationsschrittweite H modifiziert. Widmen wir uns zun¨achst dem zweiten Punkt, der unabh¨ angig von der verwendeten Quadraturformel ist. Im ersten Schritt unserer adaptiven Prozedur berechnen wir eine Apb proximation Is (f ) von I(f ) = a f (x) dx. Wir setzen H = b − a und versuchen, den Quadraturfehler abzusch¨ atzen. Falls der Fehler kleiner als die gew¨ unschte Toleranz ist, wird die adaptive Prozedur angehalten, andernfalls wird die Integrationsschrittweite H so lange halbiert, bis das  a+H f (x) dx mit der gew¨ unschten Genauigkeit berechnet wird. Integral a Dann wird das Intervall (a + H, b) betrachtet und die Prozedur wiederholt, indem f¨ ur den ersten Integrationsschritt die L¨ange des Intervalls b − (a + H) verwendet wird. Wir wollen folgende Bezeichnungen einf¨ uhren:

106

4 Numerische Differentiation und Integration

1. A: das aktive Integrationsintervall, also jenes Intervall, auf dem wir das Integral approximieren; 2. S: das bereits untersuchte Intervall, von dem wir wissen, daß der Fehler unter der gew¨ unschten Toleranz liegt; 3. N : das noch zu untersuchende Integrationsintervall. Am Anfang unseres Integrationsprozesses ist N = [a, b], A = N und S = ∅, w¨ahrend wir in einem beliebigen Schritt eine Situation vorfinden, wie wir sie in Abbildung 4.5 dargestellt haben. Bezeichnen wir mit α JS (f ) die berechnete Approximation von a f (x) dx (mit JS (f ) = 0 am Anfang des Prozesses). Falls der Algorithmus mit Erfolg beendet wird, liefert JS (f ) die gesuchte Approximation von I(f ). Bezeichnen wir weiters mit J(α,β) (f ) das approximierte Integral von f auf dem aktiven Intervall [α, β], in Abbildung 4.5 weiß dargestellt. Ein beliebiger Schritt des Integrationsverfahrens wird dann folgendermaßen organisiert: 1. falls der Fehlersch¨ atzer garantiert, daß der Fehler die gew¨ unschte Toleranz unterschreitet, dann: oßert, das heißt, JS (f ) ← JS (f ) + (i) wird JS (f ) um J(α,β) (f ) vergr¨ J(α,β) (f ); (ii) S ← S ∪ A, A = N gesetzt (entspricht Schritt (I) in Abbildung 4.5) und α ← β, β ← b; 2. falls der Fehlersch¨ atzer nicht die gew¨ unschte Genauigkeit erf¨ ullt, dann: (j) wird A halbiert und das neue aktive Intervall wird gleich A = [α, α
] mit α
= (α + β)/2 gesetzt (entspricht Schritt (II) in Abbildung 4.5); (jj) N ← N ∪ [α
, β], β ← α
gesetzt; (jjj) der Fehler nochmals gesch¨ atzt.

(I)

a S

α A β

N

b

a

S

α

A

b (II)

a




S αA α

N

b

Abb. 4.5. Verteilung der Integrationsintervalle in einem beliebigen Schritt des adaptiven Integrationsverfahrens

Um zu verhindern, daß der Algorithmus zu kleine Integrationsschritte erzeugt, ist es g¨ unstig, die L¨ ange von A zu kontrollieren und den Benutzer zu verst¨ andigen, falls diese Gr¨ oße unter einen gewissen Schwellwert

4.3 Die adaptive Simpson-Formel

107

f¨allt (das k¨onnte zum Beispiel in der Umgebung einer Singularit¨at des Integranden der Fall sein). Jetzt gilt es nur mehr, einen geeigneten Fehlersch¨atzer zu finden. Dazu konzentrieren wir uns auf ein beliebiges Teilintervall [α, β] und berechnen IS (f ) auf [α, β]. Falls auf diesem beliebigen Intervall der Fehler kleiner als ε(β − α)/(b − a) ist, dann ist der Fehler auf ganz [a, b] klarerweise kleiner als die gew¨ unschte Toleranz ε. Da wir aus (4.25) die Gleichung β f (x) dx − Is (f ) = −

(β − α)5 (4) f (ξ) = Es (f ; α, β) 2880

α

erhalten, gen¨ ugt es f¨ ur die Einhaltung der gew¨ unschten Toleranz, wenn man ES (f ; α, β) < ε(β − α)/(b − a) verlangt. In der Praxis ist es nicht einfach, diese Forderung zu erf¨ ullen, da sie a priori die Kenntnis des Punktes ξ von [α, β] voraussetzt. Um diese Abh¨ angigkeit zu entfernen, gehen wir folgendermaßen vor: β Nehmen wir an, wir wiederholen die Berechnung von α f (x) dx, indem wir wieder die zusammengesetzte Simpson-Formel verwenden, aber mit der Schrittweite (β − α)/2. Aus (4.23) mit a = α und b = β erhalten wir β f (x) dx − Isc (f ) = −

(β − α)5 (4) f (η) 46080

(4.28)

α

f¨ ur ein geeignetes η ungleich ξ. Ziehen wir die beiden letzten Gleichungen voneinander ab, erhalten wir ∆I = Isc (f ) − Is (f ) = −

(β − α)5 (4) (β − α)5 (4) f (η). (4.29) f (ξ) + 46080 2880

ahernd Nehmen wir jetzt an, daß f (4) (x) auf dem Intervall [α, β] ann¨ onnen wir aus (4.29) konstant ist. Dann ist f (4) (ξ)  f (4) (η). f (4) (η) k¨ berechnen, und so erhalten wir, eingesetzt in (4.28), folgende Fehlerabsch¨atzung: β f (x) dx − Isc (f ) 

1 ∆I. 15

α

Der Integrationsschritt (β − α)/2 (zur Berechnung von Isc (f )) wird nur akzeptiert, falls |∆I|/15 < ε(β − α)/[2(b − a)]. Die Formel, die diese Bedingung an die Schrittweite in obiger Prozedur stellt, wird adaptive Simpson-Formel genannt. Diese ist im Programm 9 implementiert. f ist jene Function, die den Integranden festlegt, a und b sind die Grenzen des

108

4 Numerische Differentiation und Integration

Integrationsintervalls, tol ist die gew¨ unschte Fehlertoleranz und hmin ist die kleinste erlaubte Schrittweite (um zu vermeiden, daß die Schrittweite unendlich oft halbiert wird).

Programm 9 - simpadpt : adaptive Simpson-Formel function [JSf,nodes]=simpadpt(f,a,b,tol,hmin,varargin) %SIMPADPT Adaptive Simpson-Formel. % JSF = SIMPADPT(A,B,FUN,TOL,HMIN) approximiert das Integral % von FUN im Intervall (A,B) mit einem Fehler, dessen Absolutbetrag % kleiner als TOL ist. FUN ist eine Function, der als Eingabeparameter % ein Vektor x uebergeben wird und die einen reellen Vektor % zurueckgibt. FUN kann eine Inline-Function sein. % JSF = SIMPADPT(A,B,FUN,TOL,HMIN,P1,P2,...) uebergibt der % Function FUN die optionalen Parameter P1,P2,... als FUN(X,P1,P2,...). % [JSF,NODES] = SIMPADPT(...) gibt die Verteilung der zur Integration % verwendeten Knoten zurueck. A=[a,b]; N=[]; S=[]; JSf = 0; ba = b - a; nodes=[]; while ˜isempty(A), [deltaI,ISc]=caldeltai(A,f,varargin{:}); if abs(deltaI) > fun=inline(’exp(-10*(x-1).ˆ2)’); tol = 1.e-04; hmin = 1.e-03; ahrend aus, erhalten wir den approximierten Wert ISA = 0.28024765884708, w¨ der exakte Wert gleich 0.28024956081990 ist. Der Fehler ist kleiner als die ur dieses Resulgew¨ unschte Toleranz, da |I(f ) − ISA |  10−5 . Beachte, daß f¨ tat zehn nicht uniforme Teilintervalle gen¨ ugen. Im Gegensatz dazu ben¨ otigt die zusammengesetzte Simpson-Formel mit uniformer Schrittweite etwa 22 Teilintervalle f¨ ur dieselbe Genauigkeit.

4.4 Was wir nicht erw¨ ahnt haben Die Mittelpunktsformel, die Trapezformel und die Simpson-Formel sind Spezialf¨alle einer gr¨ oßeren Familie von Quadraturformeln, den sogenannten Newton-Cotes-Formeln. F¨ ur eine Darstellung verweisen wir auf [QSS02], Kapitel 10. In analoger Weise ist die Gauß-Formel (4.21) ein Spezialfall der wichtigen Familie der Gaußschen Quadraturformeln. Diese sind optimal in dem Sinn, daß sie f¨ ur eine gegebene Anzahl von Quadrierungsknoten den h¨ ochsten Exaktheitsgrad besitzen. In MATur eine LAB 7 implementiert die Funktion quadl eine dieser Formeln. F¨ ausf¨ uhrlichere Behandlung verweisen wir auf [QSS02], Kapitel 10 oder auf [RR85]. F¨ ur eine weitere Vertiefung der numerischen Integration verweisen wir auch auf [DR75] und [PdDKUK83]. Die numerische Integration kann auch f¨ ur Integrale auf unbeschr¨ ank∞ ten Intervallen durchgef¨ uhrt werden, zum Beispiel etwa f¨ ur 0 f (x) dx. Eine M¨oglichkeit besteht darin, einenPunkt α zu finden, so daß der ∞ α Wert von α f (x)dx im Vergleich zu 0 f (x)dx vernachl¨assigt werden kann; man beschr¨ ankt sich dann auf die Berechnung letzteren Integrals mit einer bekannten Quadraturformel. Alternativ kann man auch eine Gaußsche Quadraturformel f¨ ur unbeschr¨ ankte Intervalle anwenden (siehe [QSS02], Kapitel 10). Schließlich kann die numerische Integration auch auf Integrale auf mehrdimensionalen Gebieten erweitert werden. Der MATLAB-Befehl dblquad(’f’,xmin,xmax, ymin,ymax) erlaubt etwa die Approximation des Integrals einer gegebenen Funktion, definiert in f, auf dem rechteckigen Gebiet [xmin,xmax] × [ymin,ymax]. f ist eine Funktion, die als Eingabeparameter mindestens zwei Variablen x und y hat, bez¨ uglich der das Integral berechnet wird.

quadl

dblquad

110

4 Numerische Differentiation und Integration

4.5 Aufgaben ¨ Aufgabe 4.1 Uberpr¨ ufe, daß, falls f ∈ C 3 in einer Umgebung I0 von x0 (bzw. In von xn ), der Fehler in Formel (4.10) gleich − 13 f


(ξ0 )h2 (bzw. − 13 f


(ξn )h2 ) ist, wobei ξ0 bzw. ξn zwei beliebige Punkte in I0 bzw. In sind. ¨ Aufgabe 4.2 Uberpr¨ ufe, daß, falls f ∈ C 3 in einer Umgebung von x ¯, der Fehler in Formel (4.8) durch (4.9) gegeben ist. Aufgabe 4.3 Berechne die Genauigkeitsordnung bez¨ uglich h folgender numerischer Differentiationsformeln zur Approximation von f
(xi ): a.

b. c.

−11f (xi ) + 18f (xi+1 ) − 9f (xi+2 ) + 2f (xi+3 ) , 6h f (xi−2 ) − 6f (xi−1 ) + 3f (xi ) + 2f (xi+1 ) , 6h f (xi−2 ) − 8f (xi ) + 8f (xi+1 ) − f (xi+2 ) . 12h

Aufgabe 4.4 Folgende Werte geben die zeitliche Entwicklung der Anzahl von Lebewesen n(t) einer gegebenen Population an, welche durch eine konstante Geburtenrate b = 2 und eine Sterberate d(t) = 0.01n(t) charakterisiert ist: 0 0.5 1 1.5 2 2.5 3 t (Monate) . 100 147 178 192 197 199 200 n

Verwende diese Daten, um die Variationsrate der Population m¨ oglichst genau zu bestimmen. Vergleiche die erhaltenen Resultate mit der theoretisch gegebenen Rate n
(t) = 2n(t) − 0.01n2 (t). Aufgabe 4.5 Berechne die minimale Anzahl M notwendiger Intervalle zur Approximation der Integrale folgender Funktionen in den angegebenen Intervallen, und zwar unter Verwendung der zusammengesetzten Mittelpunktsformel und mit einer Toleranz von 10−4 : 1 in (0, 5), 1 + (x − π)2 f2 (x) = ex cos(x) in (0, π),

f1 (x) =

f3 (x) =

1 x(1 − x)

in (0, 1).

¨ Uberpr¨ ufe die erhaltenen Ergebnisse experimentell mit Programm 6. Aufgabe 4.6 Zeige (4.13) ausgehend von (4.15). Aufgabe 4.7 Begr¨ unde den Verlust einer Konvergenzordnung, falls man von der Mittelpunktsformel zur zusammengesetzten Mittelpunktsformel u ¨bergeht. Aufgabe 4.8 Zeige, daß, falls f ein Polynom vom Grad kleiner gleich 1 ist, Imp (f ) = I(f ) gilt, die Mittelpunktsformel also den Exaktheitsgrad 1 hat.

4.5 Aufgaben

111

Aufgabe 4.9 Berechne f¨ ur die Funktion f1 aus Aufgabe 4.5 jene Werte M , die einen Quadrierungsfehler kleiner als 10−4 garantieren, falls die zusammengesetzte Trapezformel und Gauß-Formel verwendet werden. Aufgabe 4.10 Seien I1 und I2 zwei Approximationen, die wir durch die zusammengesetzte Trapezformel, aber mit zwei verschiedenen Integrationsb schrittweiten H1 und H2 von I(f ) = a f (x)dx berechnet haben. Zeige, daß, (2) falls f nicht stark in (a, b) variiert, der Wert IR = I1 + (I1 − I2 )/(H22 /H12 − 1)

(4.30)

eine bessere Approximation von I(f ) darstellt als jene von I1 und I2 . Dieses Verfahren ist als Richardson-Extrapolation bekannt. x) + Aufgabe 4.11 Zeige, daß unter den Formeln der Art Iappx (f ) = αf (¯ βf (¯ z ), wobei x ¯, z¯ ∈ [a, b] die unbekannten Knoten und α und β die zu bestimmenden Koeffizienten sind, (4.21) jene mit dem h¨ ochstem Exaktheitsgrad ist. Aufgabe 4.12 Berechne f¨ ur die beiden ersten Funktionen aus Aufgabe 4.5 die kleinste Anzahl an Intervallen, die ben¨ otigt wird,um den Fehler der SimpsonFormel kleiner als 10−4 zu halten. 2

2

Aufgabe 4.13 Berechne 0 e−x /2 dx mit der einfachen Simpson-Formel (4.24) und der Gauß-Formel (4.21) und vergleiche die Ergebnisse. 1

ur k = Aufgabe 4.14 Zur Berechnung der Integrale Ik = 0 xk ex−1 dx f¨ 1, 2, . . . kann man folgende rekursive Formel verwenden: Ik = 1 − kIk−1 mit I1 = 1/e. Berechne I20 mit der zusammengesetzten Simpson-Formel mit einer Toleranz von 10−3 . Vergleiche das erhaltene Ergebnis mit dem aus obiger Rekursionsformel. Aufgabe 4.15 Verwende die Richardson-Extrapolation (4.30) zur Approxi2 2 mation des Integrals 0 e−x /2 dx mit H1 = 1 und H2 = 0.5, zuerst mit der einfachen Simpson-Formel (4.24) und dann mit der Gauß-Formel (4.21). ¨ Uberpr¨ ufe in beiden F¨ allen, daß IR stets genauer ist als I1 und I2 . Aufgabe 4.16 Approximiere mit der zusammengesetzten Simpson-Formel die Funktion j(r), definiert in (4.2), f¨ ur r = k/10 m mit k = 1, . . . , 10, ρ(r) = exp(r) und σ = 0.36 W/(mK). Garantiere, daß der Fehler kleiner als 10−10 ist (wir erinnern daran, daß m=Meter, W=Watt, K=Grad Kelvin). Aufgabe 4.17 Berechne die Funktion E(T ), definiert in (4.1), f¨ ur T gleich 213 K (also −60 Grad Celsius) mit mindestens zehn genauen signifikanten Stellen unter Verwendung der zusammengesetzten Simpson- und Gauß-Formel. 0

Aufgabe 4.18 Schlage eine Strategie zur Berechnung von I(f ) = 1 |x2 − 0.25| dx mit der zusammengesetzten Simpson-Formel vor, die garantiert, daß der Fehler kleiner als 10−2 ist.

5 Lineare Systeme

In den angewandten Wissenschaften wird die L¨osung von Problemen oft auf die L¨osung eines oder mehrerer linearer Systeme der Form Ax = b

(5.1)

zur¨ uckgef¨ uhrt. A ist dabei eine quadratische Matrix der Dimension n×n mit reellen oder komplexen Elementen aij , x bzw. b sind Spaltenvektoren der Dimension n, die den L¨ osungsvektor bzw. den gegebenen Vektor bezeichnen. Komponentenweise kann das System (5.1) folgendermaßen geschrieben werden: a11 x1 + a12 x2 + . . . + a1n xn = b1 , a21 x1 + a22 x2 + . . . + a2n xn = b2 , .. .

.. .

.. .

an1 x1 + an2 x2 + . . . + ann xn = bn . Wir stellen nun drei Probleme vor, die zu linearen Systemen f¨ uhren. Problem 5.1 (Hydraulik) Betrachten wir ein hydraulisches System, das aus zehn Leitungen besteht, die wie in Abbildung 5.1 angeordnet sind, und das von einer Quelle mit konstantem Druck pr = 10 bar versorgt wird. In diesem Problem entsprechen die Druckwerte der Differenz zwischen effektivem und atmosph¨ arischem Druck. An den Enden der j-ten Leitung gilt folgendes Verh¨ altnis zwischen Durchflußmenge Qj (in m3 /s) und Druckdifferenz ∆pj : (5.2) Qj = kL∆pj , wobei k den hydraulischen Widerstand (gemessen in m2 /(bar·s)) und L die L¨ ange (in m) der Leitung bezeichnen. Nehmen wir an, das Wasser tritt an den Ausfl¨ ussen (mit schwarzen Punkten bezeichnet) mit atmosph¨ arischem Druck aus, den wir aufgrund obiger Vereinbarung gleich 0 bar setzen.

114

5 Lineare Systeme

Eine typische Fragestellung besteht nun darin, die Druckwerte an den inneren Knoten 1, 2, 3 und 4 des Systems zu bestimmen. Dazu k¨ onnen wir f¨ ur jedes j = 1, 2, 3, 4 Gleichung (5.2) durch die Aussage erg¨ anzen, daß die algebraische Summe der Durchflußmengen im j-ten Knoten gleich null sein muß (eine negative Durchflußmenge bedeutet, daß das Wasser vom Knoten in die Leitung fließt). Bezeichnen wir mit p = (p1 , p2 , p3 , p4 )T den Vektor mit den Druckwerten in den inneren Knoten, dann erhalten wir ein System mit vier Gleichungen und vier Unbekannten der Form Ap = b. In der folgenden Tabelle fassen wir die wichtigsten Eigenschaften der verschiedenen Leitungen zusammen. Leitung 1 4 7 10

k 0.01 0.005 0.002 0.002

L L Leitung k L Leitung k 0.005 14 3 0.005 10 2 20 0.002 8 6 0.005 10 5 10 0.005 10 9 0.002 8 8 8 8

Dementsprechend sind A und b (wir haben nur die ersten vier signifikanten Stellen wiedergegeben): A=

−0.370 0.050 0.050 0.070 0.050 −0.116 0 0.050 0.050 0 −0.116 0.050 0.070 0.050 0.050 −0.202

−2 0 0 0

,b=

.

Die L¨ osung dieses Systems wird in Beispiel 5.4 gegeben.

p=0

Q1

p=0

Q2 1

Q10 2 Q9 Q8 4 Q3

p=0

Q5 Q7

p=0

Q4 Q6

3

Abb. 5.1. Das Leitungsnetz aus Problem 5.1

Problem 5.2 (Spektrometrie) Betrachten wir ein Gasgemisch, das aus n unbekannten Komponenten besteht, die nicht miteinander reagieren. Mit einem Massenspektrometer kann die Zusammensetzung des Gases analysiert werden, indem es mit Elektronen von niedriger Energie beschossen wird. Die erhaltene Mischung aus Ionen kann mit einem Galvanometer analysiert werden, das an einem Apparat angeschlossen ist, der die Ausschl¨ age f¨ ur gewisse Masse/Ladungsverh¨ altnisse anzeigt. Wir wollen nur die n wichtigsten Ausschl¨ age betrachten.

5 Lineare Systeme

115

Man kann vermuten, daß die H¨ ohe hi des i-ten Ausschlages eine Linearkombination von {pj , j = 1, . . . , n} ist, wobei pj der partielle Druck der j-ten Komponente ist (also der Druck eines einzelnen Gases, das Teil einer Mischung ist): n

sij pj = hi , i = 1, . . . , n, j=1

wobei die sij die sogenannten Sensitivit¨ atskoeffizienten sind. Die Bestimmung der partiellen Druckwerte erfordert also die L¨ osung eines linearen Systems. Problem 5.3 (Wirtschaft: Input-Output-Analyse) Wir m¨ ochten das Gleichgewicht zwischen Angebot und Nachfrage eines bestimmten Gutes bestimmen. Im speziellen wollen wir n Fabriken betrachten, die n verschiedene Produkte herstellen. Sie m¨ ussen eine interne Nachfrage (also die Menge, die von den Fabriken selbst ben¨ otigt werden) und eine externe Nachfrage (der Verbraucher) befriedigen. Bezeichnen wir mit xi , i = 1, . . . , n, die Einheiten des i-ten Gutes, das von der i-ten Fabrik erzeugt wird, und mit bi , i = 1, . . . , n, jene Einheiten, die vom i-ten Gut am Markt verbraucht werden. Schließlich bezeichnen wir mit cij den Bruchteil von xi , der von der j-ten Fabrik zur Produktion des j-ten Produkts ben¨ otigt wird (siehe Abbildung 5.2). Aufgrund des Leontief-Modells k¨ onnen wir annehmen, daß die Transformationen, die die verschiedenen Produkte verkn¨ upfen, linear sind. In diesem Fall wird ein Gleichgewicht erreicht, falls der Vektor x der Gesamtproduktion gleich der Summe der einzelnen Nachfragen ist, also x = Cx + b, ullt in diesem Modell die wobei C = (cij ) und b = (bi ) sind. Folglich erf¨ Gesamtproduktion folgendes lineare System Ax = b, wobei A = I − C. F¨ ur dessen L¨ osung siehe Aufgabe 5.17.

(5.3)

c11 1

c12

b1

c22 b2

2 c31 3

b3 c33

Abb. 5.2. Die Interaktion zwischen den drei Fabriken und dem Markt, beschrieben in Problem 5.3

Eine eindeutige L¨osung des Systems (5.1) existiert genau dann, wenn die Matrix A nicht singul¨ar ist.

116

5 Lineare Systeme

Prinzipiell k¨ onnten wir sie mit der Cramerschen Regel xi =

det(Ai ) , det(A)

i = 1, . . . , n

berechnen, wobei Ai jene Matrix ist, die wir aus A erhalten, wenn wir die i-te Spalte durch b ersetzen, und det(A) die Determinante von A ist. Die Berechnung der n + 1 Determinanten mit der Laplace-Entwicklung (siehe Aufgabe 5.1) erfordert 2(n+1)! Operationen, wobei wir wie u ¨blich mit Operation eine Addition, Subtraktion, Multiplikation oder Division meinen. So w¨ urde ein Rechner, der eine Rechenleistung von 109 flops (d.h. 1 Gigaflop) hat, etwa zw¨ olf Stunden ben¨otigen, um ein System der Dimension n = 15 zu l¨ osen, 3240 Jahre, falls n = 20 und 10143 Jahre, falls n = 100. Der rechnerische Aufwand kann drastisch auf eine Ordnung von n3.8 Operationen reduziert werden, indem die n + 1 Determinanten mit dem Algorithmus aus Beispiel 1.3 berechnet werden. In jedem Fall ist der Rechenaufwand f¨ ur praktische Anwendungen immer noch viel zu hoch. Wir ben¨ otigen also alternative Verfahren. Dazu wollen wir bemerken, daß ein lineares System im allgemeinen nicht mit weniger als n2 Operationen gel¨ ost werden kann. Denn falls die Gleichungen tats¨achlich gekoppelt sind, k¨ onnen wir erwarten, daß jedes der n2 Elemente der Matrix mindestens einmal in eine Operation einbezogen wird.

5.1 Die LU-Faktorisierung Sei A eine quadratische Matrix der Ordnung n. Nehmen wir an, es existieren eine untere Dreiecksmatrix L und eine obere Dreiecksmatrix U, so daß A = LU.

(5.4)

(5.4) wird LU-Faktorisierung (oder LU-Zerlegung) von A genannt. Wir wissen, daß, falls A nicht singul¨ ar ist, auch L und U nicht singul¨ar sind, und im speziellen bedeutet dies, daß deren Diagonalelemente nicht null sind (wie wir in Abschnitt 1.3 gesehen haben). In diesem Fall f¨ uhrt die L¨osung von Ax = b zur L¨ osung folgender zwei Dreieckssysteme: Ly = b, Ux = y

(5.5)

Beide Systeme sind einfach zu l¨osen. Da L eine untere Dreiecksmatrix ist, hat die erste Zeile des Systems Ly = b die Form l11 y1 = b1 ,

5.1 Die LU-Faktorisierung

117

woraus man sofort den Wert von y1 ablesen kann, da l11
= 0 ist. Setzen wir den erhaltenen Wert y1 in die n − 1 Gleichungen ein, dann erhalur dieses ten wir ein System, dessen Unbekannte y2 , . . . , yn sind, und f¨ k¨onnen wir nun wieder gleich verfahren. Gehen wir so Gleichung f¨ ur Gleichung vor, dann k¨ onnen wir alle Unbekannten mit folgendem Algorithmus berechnen, der Vorw¨artseinsetzung genannt wird: 1

b1 , l11 ⎛ ⎞ i−1  1 ⎝ lij yj ⎠ , i = 2, . . . , n bi − yi = lii j=1

y1 =

(5.6)

Z¨ahlen wir nun die Anzahl der f¨ ur (5.6) ben¨ otigten Operationen. ussen i − 1 Summen, i − 1 Produkte und ein F¨ ur die Unbekannten yi m¨ Quotient berechnet werden, insgesamt sind das n 

n n   1 + 2 (i − 1) = 2 i − n = n2 Operationen.

i=1

i=1

i=1

In analoger Weise kann das System Ux = y gel¨ ost werden: in diesem Fall ist die erste Unbekannte, die wir berechnen, xn , und dann r¨ uckw¨ arts ur i von n − 1 bis 1 alle u ¨brigen Unbekannten xi f¨

1 yn , unn ⎛ ⎞ n  1 ⎝ uij xj ⎠ , i = n − 1, . . . , 1 yi − xi = uii j=i+1

xn =

(5.7)

Dieser Algorithmus wird R¨ uckw¨ artseinsetzung genannt und ben¨ otigt ebenfalls n2 Operationen. Jetzt ben¨ otigen wir einen Algorithmus, der ausgehend von A die Matrizen L und U effektiv berechnet. Anhand einiger Beispiele wollen wir die allgemeine Prozedur vorstellen. Beispiel 5.1 Wir schreiben die Relation (5.4) f¨ ur eine beliebige Matrix A ∈ R2×2 l11 0 u11 u12 a11 a12 = . 0 u22 a21 a22 l21 l22 Die sechs unbekannten Elemente von L und U m¨ ussen also folgende (nichtlineare) Gleichungen erf¨ ullen (e1 ) l11 u11 = a11 , (e2 ) l11 u12 = a12 , (e3 ) l21 u11 = a21 , (e4 ) l21 u12 + l22 u22 = a22 .

(5.8)

118

5 Lineare Systeme

Dieses System ist unterbestimmt, da es mehr Unbekannte als Gleichungen hat. Wir k¨ onnen es vervollst¨ andigen, indem wir willk¨ urlich die Diagonalelemente von L gleich 1 setzen, das heißt, wir setzen l11 = 1 und l22 = 1. Jetzt kann System (5.8) auf folgende Weise gel¨ ost werden: aus (e1 ) und (e2 ) berechnen wir die Elemente der ersten Zeile von U, das sind u11 und u12 . Falls u11 ungleich null ist, erhalten wir dann aus (e3 ) die Unbekannte l21 (also die erste Spalte von L, da ja l11 schon gleich 1 gesetzt ist) und dann aus (e4 ) die Unbekannte u22 (das einzige Element der zweiten Zeile von U ungleich null). Beispiel 5.2 Wir wiederholen nun dieselben Berechnungen f¨ ur eine (3 × 3)Matrix. F¨ ur die zw¨ olf unbekannten Koeffizienten von L und U haben wir die folgende neun Gleichungen: (e3 ) l11 u13 = a13 , (e1 ) l11 u11 = a11 , (e2 ) l11 u12 = a12 , (e4 ) l21 u11 = a21 , (e5 ) l21 u12 + l22 u22 = a22 , (e6 ) l21 u13 + l22 u23 = a23 , (e7 ) l31 u11 = a31 , (e8 ) l31 u12 + l32 u22 = a32 , (e9 ) l31 u13 + l32 u23 +l33 u33 = a33 . ur i = 1, 2, 3. Wir vollst¨ andigen das System mit den Gleichungen lii = 1 f¨ Wieder kann das erhaltene System leicht gel¨ ost werden, indem wir u ¨ber (e1 ), (e2 ) und (e3 ) die Koeffizienten der ersten Zeile von U berechnen; mit (e4 ) onnen wir dann die Koeffizienten l21 und l31 der ersten Spalte und (e7 ) k¨ von L berechnen. Sind diese bekannt, k¨ onnen wir aus (e5 ) und (e6 ) die Koeffizienten u22 und u23 der zweiten Zeile von U berechnen und dann u ¨ber onnen wir (e8 ) den Koeffizienten l32 der zweiten Spalte von L. Schließlich k¨ die letzte Zeile von U (auf ein einziges Element u33 reduziert) bestimmen, osen. indem wir (e9 ) l¨

F¨ ur eine Matrix beliebiger Dimension n k¨onnen wir folgendermaßen vorgehen: 1. die Elemente von L und U erf¨ ullen das nichtlineare Gleichungssystem min(i,j)



lir urj = aij , i, j = 1, . . . , n;

(5.9)

r=1

2. das System (5.9) ist unterbestimmt, da es n2 Gleichungen f¨ ur n2 + n Unbekannte gibt; folglich kann die LU-Faktorisierung nicht eindeutig sein; 3. setzen wir die n Diagonalelemente von L gleich 1, wird (5.9) zu einem bestimmten System und kann mit folgendem Gauß-Algorithmus gel¨ost werden: (1) ur i, j = 1, . . . , n, f¨ ur k = 1, . . . , n−1, setze A(1) = A, d.h. aij = aij f¨ berechne

5.1 Die LU-Faktorisierung

f¨ ur i = k + 1, . . . , n (k) a , lik = ik (k) akk f¨ ur j = k + 1, . . . , n (k+1) (k) (k) = aij − lik akj aij

119

(5.10)

(k)

Die Elemente akk m¨ ussen alle von null verschieden sein und werden Pivotelemente genannt. F¨ ur jedes k = 1, . . . , n − 1 hat die Matrix (k+1) (k+1) = (aij ) genau n − k Zeilen und Spalten. A Am Ende dieses Prozesses sind die Elemente der oberen Dreiecks(i) ur i = 1, . . . , n und j = i, . . . , n, matrix U gegeben durch uij = aij , f¨ w¨ahrend jene von L die vom Algorithmus erzeugten Koeffizienten lij sind. In (4.21) werden die Diagonalelemente von L nicht explizit berechnet, da wir ja bereits wissen, daß sie gleich 1 sind. Diese Faktorisierung wird Gauß-Faktorisierung genannt; die Berechnung der Koeffizienten der Faktoren L und U erfordert etwa 2n3 /3 Operationen (siehe Aufgabe 5.4). Beispiel 5.3 Betrachten wir folgende Vandermonde-Matrix A = (aij ) mit aij = xn−j , i, j = 1, . . . , n, i

(5.11)

wobei alle n Werte xi verschieden sind. Diese Matrix kann mit dem MATLABBefehl vander erzeugt werden. In Abbildung 5.3 geben wir die Anzahl der ben¨ otigten Operationen zur Berechnung der Gauß-Faktorisierung von A f¨ ur verschiedene Dimensionen n der Matrix, genauer gesagt f¨ ur n = 10, 20, . . . , 100, an. Dazu haben wir folgende Befehle verwendet: >> ops = [ ]; for n = [10:10:100] A = vander(linspace(1,2,n)); flops(0), A = lu Gauss(A); ops=[ops,flops]; end Die in 5.3 abgebildete Kurve ist ein Polynom dritten Grades in n, das die obigen Daten mit der Methode der kleinsten Quadrate approximiert. Diese haben wir mit folgenden Befehlen erzeugt

>> c3=polyfit([10:10:100],ops,3) 0.6667 -0.0000 0.3333 -0.0000 achlich 2/3. Der Koeffizient des Monoms n3 ist tats¨

Nat¨ urlich m¨ ussen wir nicht alle Matrizen A(k) speichern. Tats¨ achlich orik¨ onnen wir die (n − k) × (n − k) Elemente von A(k+1) mit den zugeh¨ gen (n − k) × (n − k) letzten Elemente der urspr¨ unglichen Matrix A u ¨berlappen. Da u ¨berdies im k-ten Schritt die Elemente der k-ten Spalte von A, welche unterhalb der Diagonalen liegen, die fertige Matrix U

120

5 Lineare Systeme 5

7

x 10

6 5 4 3 2 1 0 0

20

40

60

100

80

Abb. 5.3. Die Anzahl von Operationen, in Funktion von n, die zur LUFaktorisierung nach Gauß der Vandermonde-Matrix ben¨ otigt wird. Approximieren wir die zu n = 10, 20, . . . , 100 geh¨ origen Funktionswerte (durch die Kreise dargestellt) mit der Methode der kleinsten Quadrate, so erhalten wir eine kubische Funktion

nicht beeinflussen, k¨ onnen diese durch die Elemente der k-ten Spalte von L ersetzt werden, wie wir es in Programm 10 gemacht haben. Folglich sind im k-ten Schritt des Prozesses anstelle der urspr¨ unglichen Elemente von A folgende gespeichert ⎡ (1) (1) (1) ⎤ a11 a12 . . . . . . . . . a1n (2) ⎢ l a(2) a2n ⎥ ⎥ ⎢ 21 22 ⎥ ⎢ . . . .. ⎥ ⎢ . . . . . . ⎥ ⎢ . ⎥ ⎢ (k) (k) ⎥ , ⎢ l ... l k,k−1 akk . . . akn ⎥ ⎢ k1 ⎢ . .. .. ⎥ .. ⎥ ⎢ . . . ⎦ . ⎣ . ln1 . . . ln,k−1 a(k) . . . a(k) nn nk wobei die eingerahmte Matrix A(k) ist. Die Gauß-Faktorisierung ist Basis folgender MATLAB-Befehle: lu inv \

- [L,U]=lu(A), dessen Anwendung in Abschnitt 5.2 diskutiert wird; - inv berechnet die Inverse einer Matrix; - \ womit ein lineares System mit der Matrix A und der rechten Seite b gel¨ost wird, und zwar einfach mit dem Befehl A \ b. Bemerkung 5.1 (Berechnung der Determinante) Mit der LU-Faktorisierung k¨ onnen wir die Determinante einer Matrix A mit einem Rechenaufwand von O(n3 ) Operationen berechnen, und zwar wegen (siehe Abschnitt 1.3) n

det(A) = det(L) det(U) =

ukk . k=1

det

Diese Prozedur liegt auch dem MATLAB-Befehl det zugrunde.

5.1 Die LU-Faktorisierung

121

In Programm 10 haben wir den Algorithmus (4.21) implementiert. Um keinen Speicher zu verschwenden, wird die Matrix L (ohne die Diagonale, von der wir ohnedies wissen, daß sie aus Einselementen besteht) im Teil unterhalb der Diagonalen von A gespeichert, w¨ahrend die Matrix U (einschließlich der Diagonalen) im oberen Teil gespeichert wird. Nach Ausf¨ uhrung des Programms k¨ onnen die beiden Faktoren leicht rekonstruiert werden: L = eye(n) + tril(A,-1) und U = triu(A), wobei n die Dimension von A ist. Programm 10 - lu Gauß : Gauß-Faktorisierung function A=lu Gauss(A) %LU GAUSS LU-Faktorisierung ohne Pivoting % A = LU GAUSS(A) berechnet die LU Faktorisierung von Gauss % der Matrix A und speichert im Teil strikt unter der Diagonalen von % A die Matrix L (die Diagonalelemente von L sind alle gleich 1) % und im oberen Teil den Faktor U [n,m]=size(A); if n˜= m; error(’A ist keine quadratische Matrix’); else for k = 1:n-1 for i = k+1:n A(i,k) = A(i,k)/A(k,k); if A(k,k) == 0, error(’Ein Pivotelement ist gleich null’); end for j = k+1:n A(i,j) = A(i,j) - A(i,k)*A(k,j); end end end end

Beispiel 5.4 Um das in 5.1 erhaltene System zu l¨ osen, verwenden wir die LU-Faktorisierung und Vorw¨ arts- bzw. R¨ uckw¨ artseinsetzung >> A=lu Gauss(A); >> y(1)=b(1); for i =2:4; y = [y; b(i)-A(i,1:i-1)*y(1:i-1)]; end >> x(4)=y(4)/A(4,4); >> for i = 3:-1:1; x(i)= (y(i)-A(i,i+1:4)*x(i+1:4))/A(i,i); end Das Ergebnis ist p = (8.1172, 5.9893, 5.9893, 5.7779)T .

122

5 Lineare Systeme

Beispiel 5.5 Die L¨ osung von Ax = b mit 1 1−ε 3 5−ε A=

2

2

2

6

,b=

3 6 4 ist x = (1, 1, 1)T (unabh¨ angig von ε). F¨ ur ε = 1 ist die Gauß-Faktorisierung von 100 L= 210 ,U= 331

, ε ∈ R,

(5.12)

13 A, erhalten mit Programm 10, 10 3 0 2 −4 . 00 7

Setzen wir hingegen ε = 0, kann die Gauß-Faktorisierung nicht berechnet werden (beachte, A ist nicht singul¨ ar), da der Algorithmus (4.21) hier eine Division durch 0 erfordert.

Das vorangegangene Beispiel zeigt, daß die Gauß-Faktorisierung leider nicht f¨ ur jede nichtsingul¨ are Matrix existiert. In diesem Sinne kann man folgendes Resultat zeigen: Satz 5.1 F¨ ur eine gegebene Matrix A ∈ Rn×n existiert seine GaußFaktorisierung genau dann, wenn alle Hauptuntermatrizen Ai von A der Ordnung i = 1, . . . , n − 1 (also A eingeschr¨ ankt auf die i ersten Zeilen und Spalten) nichtsingul¨ ar sind.

Wenn wir zu Beispiel 5.5 zur¨ uckkehren, dann k¨ onnen wir tats¨ achlich ar ist. feststellen, daß f¨ ur ε = 0 die zweite Untermatrix A2 von A singul¨ Wir k¨onnen einige Klassen von Matrizen identifizieren, f¨ ur die die Voraussetzungen von Satz 5.1 erf¨ ullt sind. Im speziellen wollen wir erw¨ahnen: 1. Symmetrische positiv definite Matrizen. Eine Matrix A ∈ Rn×n ist positiv definit, falls ∀x ∈ Rn mit x
= 0,

xT Ax > 0;

2. Diagonaldominante Matrizen. Eine Matrix ist zeilendiagonaldominant, falls |aii | ≥

n 

|aij |,

i = 1, . . . , n,

j=1 j
=i

spaltendiagonaldominant, falls |aii | ≥

n  j=1 j
=i

|aji |,

i = 1, . . . , n.

5.2 Pivoting

123

Ersetzen wir in den obigen Ungleichungen das Zeichen ≥ durch >, heißt A strikt zeilen- oder spaltendiagonaldominant. Falls A eine symmetrische, positiv definite Matrix ist, k¨onnen wir dar¨ uberhinaus die spezielle Faktorisierung A = HHT

(5.13)

finden, wobei H eine untere Dreiecksmatrix mit positiven Diagonalelementen ist. (5.13) ist die sogenannte Cholesky-Faktorisierung. Zur Berechnung von H sind etwa n3 /3 Operationen notwendig (der rechnerische Aufwand halbiert sich also im Vergleich zur Berechnung der LU-Faktorisierung). Beachte, daß aufgrund der Symmetrie von A nur deren unterer Dreiecksteil gespeichert wird und H in denselben Speicherbereich geschrieben werden kann. Die Elemente von H k¨ onnen mit folgendem Algorithmus berechnet werden: √ ur i = 2, . . . , n h11 = a11 und f¨

" # j−1  1 aij − hik hjk , j = 1, . . . , i − 1 hij = hjj k=1   i−1   h2ik hii = aii −

(5.14)

k=1

Die Cholesky-Faktorisierung kann in MATLAB mit H=chol(A) aufgerufen werden. Siehe Aufgaben 5.1–5.5.

5.2 Pivoting Wir wollen nun ein Verfahren einf¨ uhren, das die LU-Faktorisierung f¨ ur jede nichtsingul¨ are Matrix A durchf¨ uhren kann – auch f¨ ur den Fall, daß die Voraussetzungen aus Satz 5.1 nicht erf¨ ullt sind. Kommen wir dazu zur¨ uck auf die Matrix aus Beispiel 5.5 mit ε = 0. uhren nur den ersten Schritt (k = 1) Setzen wir wie immer A(1) = A und f¨ dieses Verfahrens aus; die neuen Koeffizienten von A sind ⎤ ⎡ 1 1 3 ⎣ 2 0 -4 ⎦ . (5.15) 3 3 -5

chol

124

5 Lineare Systeme

Da das Pivotelement a22 gleich null ist, k¨onnen wir das Verfahren nicht fortsetzen. H¨ atten wir aber vorher die zweite Zeile von A mit der dritten vertauscht, h¨ atten wir die Matrix ⎤ ⎡ 1 1 3 ⎣3 3 -5 ⎦ 0 -4 2

erhalten, und wir h¨atten die Faktorisierung durchf¨ uhren k¨ onnen, ohne einer Division durch 0 zu begegnen. Es ist also m¨oglich, den Prozess der Faktorisierung zu Ende zu f¨ uhren, auch wenn die Voraussetzungen aus Satz 5.1 nicht erf¨ ullt sind, und zwar indem wir die Zeilen der Ausgangsmatrix A geeignet permutieren (also vertauschen). Leider k¨onnen wir a priori aber nicht wissen, welche Zeilen wir vertauschen m¨ ussen. Allerdings k¨onnen wir diese Entscheidung in (k) jedem Schritt k treffen, in dem sich akk gleich null ergibt. Kommen wir zur Matrix (5.15) zur¨ uck, die ein Pivotelement gleich null an der Stelle (2, 2) hat. Da das zugeh¨ orige Element in der dritten Zeile ungleich null ist, k¨onnen wir diese Zeile mit der zweiten vertauschen und mit dem Faktorisierungsprozeß fortfahren. Auf diese Weise erhalten wir genau jene Matrix, die wir erhalten h¨atten, falls wir gleich zu Beginn diese beiden Zeilen der Matrix A vertauscht h¨ atten. Wir k¨ onnen so also, wann immer es im Prozeß notwendig ist, Zeilen vertauschen, ohne sie bereits am Beginn vertauscht zu haben (und den Prozeß ohne Zeilenvertauschung ablaufen zu lassen). Da mit der Vertauschung der Zeilen auch die Pivots vertauscht werden, wird diese Technik auch Zeilenpivoting genannt. Die erhaltene Faktorisierung gibt bis auf eine Zeilenpermutation die Ausgangsmatrix A zur¨ uck. Genauer gesagt gilt PA = LU, wobei P eine geeignete Permutatonsmatrix ist. Am Anfang des Prozesses wird sie gleich der Einheitsmatrix gesetzt: falls dann im Laufe der Faktorisierung die Zeilen r und s von A vertauscht werden, m¨ ussen dazu analog die entsprechenden Spalten von P vertauscht werden. Entsprechend m¨ ussen wir folgende Dreieckssysteme l¨ osen: Ly = Pb, Ux = y.

(5.16)

In der zweiten Gleichung von (4.21) sehen wir auch, daß die Ele(k) uhren mente akk sehr klein sind und zu einem Verlust an Genauigkeit f¨ (k) k¨ onnen, da eventuelle Rundungsfehler in den Koeffizienten akj wesentlich verst¨ arkt werden k¨onnen.

5.3 Wie genau ist die LU-Faktorisierung?

125

Beispiel 5.6 Betrachten wir folgende nichtsingul¨ are Matrix: −15 1 1 + 0.5 · 10 3 2 20 . A= 2 3 6 4 W¨ ahrend der Berechnung der Faktorisierung mit Programm 10 werden keine Pivotelemente gleich null erzeugt. Trotzdem sind die berechneten Faktoren L und U ziemlich ungenau, wie wir durch A − LU u ufen k¨ onnen (in ¨berpr¨ exakter Arithmetik w¨ are die Differenz gleich null) A − LU =

000 000 004

.

Es ist also empfehlenswert, in jedem Schritt der Faktorisierung Pi(k) voting durchzuf¨ uhren und unter allen verf¨ ugbaren Pivots aik mit i = k, . . . , n jenes mit dem gr¨ oßten Betrag auszuw¨ahlen. Algorithmus (4.21) mit Zeilenpivoting in jedem Schritt ist also: f¨ ur k = 1, . . . , n − 1, f¨ ur i = k + 1, . . . , n (k) (k) f¨ ur r¯, so daß |ar¯k | = max |ark |, r=k,... ,n

vertausche Zeile k mit Zeile r¯, (k)

aik

(5.17)

, (k) akk f¨ ur j = k + 1, . . . , n (k+1) (k) (k) = aij − lik akj aij

lik =

Die MATLAB-Funktion lu, die wir vorhin bereits erw¨ ahnt haben, berechnet die Gauß-Faktorisierung mit Zeilenpivoting. Die vollst¨ andige Syntax des Befehls ist [L,U,P]=lu(A), wobei P die Permutationsmatrix ist. Falls der Befehl mit der kurzen Syntax [L,U]=lu(A) aufgerufen wird, wird eine Matrix L erzeugt, die gleich P*M ist, wobei M eine untere Dreiecksmatrix und P die Permutationsmatrix aus dem Zeilenpivoting ist. Der Befehl lu aktiviert automatisch das Zeilenpivoting, wenn ein Pivotelement, das sehr klein oder gleich null ist, erzeugt wird. Siehe Aufgaben 5.6–5.8.

5.3 Wie genau ist die LU-Faktorisierung? Wie wir bereits in Beispiel 5.6 sehen konnten, gibt das Produkt LU aufgrund von Rundungsfehlern nicht die Matrix A zur¨ uck. Obwohl mit Hilfe des Pivoting diese Fehler ged¨ampft werden, k¨ onnen wir von dieser

126

5 Lineare Systeme

Technik trotzdem nicht immer eine genaue L¨osung des Systems erwarten, wie folgendes Beispiel zeigt. Beispiel 5.7 Betrachten wir folgendes lineare System An xn = bn , wobei An ∈ Rn×n die sogenannte Hilbert-Matrix mit den Elementen i, j = 1, . . . , n, aij = 1/(i + j − 1), ist, w¨ ahrend b so gew¨ ahlt wird, daß die exakte L¨ osung des Systems x = (1, 1, . . . , 1)T sei. Die Matrix An ist klarerweise symmetrisch und man kann zeigen, daß sie auch positiv definit ist. F¨ ur verschiedene Werte von n verwenden wir in MATLAB die Funktion lu, um die Gauß-Faktorisierung von An mit Zeilenpivoting zu berechnen. Dann berechnen wir die zugeh¨ origen lineaosung. In ren Systeme sowie (5.16) und bezeichnen mit x die berechnete L¨ Abbildung 5.4 haben wir den Logarithmus des relativen Fehlers in Abh¨ angigkeit von n dargestellt En = xn − xn / xn ,

(5.18)

wobei wir mit · die euklidische Norm, eingef¨ uhrt in Abschnitt 1.3.1, beoßer als zeichnen. Es ist En ≥ 10, falls n ≥ 13 (also ein relativer Fehler gr¨ 1000%!), w¨ ahrend Rn = Ln Un − Pn An die Nullmatrix (in Bezug auf die Maschinengenauigkeit) f¨ ur jeden beliebigen Wert n ist.

5

10

0

10

−5

10

−10

10

−15

10

−20

10

0

20

40

60

80

100

Abb. 5.4. Verlauf des Logarithmus En (durchgehende Linie) gegen n und ur das Hilbert-System aus Beigegen maxi,j=1,... ,n |rij | (unterbrochene Linie) f¨ spiel 5.7. Die Zahlen (rij ) sind die Koeffizienten der Matrix R

Aufgrund obiger Beobachtung k¨ onnen wir also vermuten, daß wir in der Praxis bei der numerischen L¨ osung des linearen Systems Ax = b die  eines gest¨ exakte L¨osung x orten Systems der Form (A + δA) x = b + δb

(5.19)

erhalten, wobei δA bzw. δb eine Matrix bzw. ein Vektor sind, die vom speziellen numerischen Verfahren zur L¨ osung des Systems abh¨angen. Beginnen wir damit, den Fall δA = 0 und δb
= 0 zu untersuchen, da er

5.3 Wie genau ist die LU-Faktorisierung?

127

etwas einfacher ist als der allgemeine Fall. Nehmen wir weiters der Einfachheit halber an, daß A symmetrisch und positiv definit ist.  = −A−1 δb Vergleichen wir (5.1) und (5.19), so erhalten wir x − x und daher  = A−1 δb . x − x

(5.20)

Um eine obere Schranke f¨ ur die rechte Seite von (5.20) zu finden, gehen wir folgendermaßen vor: Da A symmetrisch und positiv definit ist, existiert eine Orthonormalbasis {vi }ni=1 von Rn , die aus den Eigenvektoren vi von A (siehe zum Beispiel [QSS02], Kapitel 5) gebildet wird. Dies bedeutet, daß Avi = λi vi , i = 1, . . . , n, viT vj = δij , i, j = 1, . . . , n, wobei λi der zu vi geh¨ orige Eigenwert von A ist und δij das KroneckerSymbol. Folglich kann ein beliebiger Vektor w ∈ Rn geschrieben werden als w=

n 

wi vi

i=1

f¨ ur eine beliebige (und eindeutige) Menge von Koeffizienten wi ∈ R. Es ist Aw 2 = (Aw)T (Aw) = [w1 (Av1 )T + . . . + wn (Avn )T ][w1 Av1 + . . . + wn Avn ] = (λ1 w1 v1T + . . . + λn wn vnT )(λ1 w1 v1 + . . . + λn wn vn ) n  λ2i wi2 . = i=1

oßten Eigenwert von A. Da w 2 = Bezeichnen wir mit λmax den gr¨ n 2 onnen wir folgern, daß i=1 wi , k¨ Aw ≤ λmax w , ∀w ∈ Rn .

(5.21)

Auf ¨ahnliche Weise erhalten wir A−1 w ≤

1 w , λmin

wobei wir wissen, daß die Eigenwerte von A−1 die Kehrwerte der Eigenwerte von A sind. Mit Hilfe dieser Ungleichung k¨onnen wir aus (5.20) schließen, daß  1 δb x − x . ≤ λmin x x

(5.22)

128

5 Lineare Systeme

Nun verwenden wir nochmals (5.21) und erinnern uns, daß Ax = b. Dann erhalten wir  λmax δb x − x ≤ λmin b x

(5.23)

Der relative Fehler in der L¨osung h¨angt also u ¨ber folgende Konstante (≥ 1) vom relativen Fehler in den Daten ab: K(A) =

cond

rcond condest

λmax λmin

(5.24)

Diese Konstante wird (spektrale) Konditionszahl der Matrix A genannt. K(A) kann in MATLAB mit dem Befehl cond(A) berechnet werden. Andere Definitionen f¨ ur die Konditionszahl gibt es f¨ ur nichtsymmetrische Matrizen, siehe dazu etwa [QSS02], Kapitel 3. Bemerkung 5.2 Der Befehl cond(A) erlaubt die (approximierte) Berechnung der Konditionszahl einer beliebigen Matrix A, auch wenn sie nicht symmetrisch oder positiv definit ist. Ein anderer verf¨ ugbarer Befehl ist rcond(A), der eine Approximation der Inversen der Konditionszahl liefert. Der Befehl condest(A) hingegen erlaubt die Berechnung einer Approximation mit geringem rechnerischen Aufwand, falls A eine d¨ unnbesetzte Matrix ist. Falls die Matrix A schlecht konditioniert ist (d.h. K(A)  1), kann auch die Berechnung der Konditionszahl ungenau sein. Betrachten wir zum Beispiel die tridiagonalen Matrizen An = tridiag(−1, 2, −1) mit n Zeilen und Spalten mit variablem n. An ist symmetrisch und positiv definit und hat die Eigenwerur j = 1, . . . , n, mit θ = π/(n + 1): folglich kann te λj = 2 − 2 cos(jθ), f¨ K(An ) exakt berechnet werden. In Abbildung 5.5 ist der Betrag des Fehlers EK (n) = |K(An ) − cond(An )|/K(An ) dargestellt. Beachte, daß EK (n) mit wachsendem n steigt.

Ein ausf¨ uhrlicherer Beweis h¨ atte zu einem allgemeineren Resultat im Fall δA
= 0 gef¨ uhrt. Denn angenommen, δA sei symmetrisch und positiv atten wir definit, so daß λmax (δA) < λmin (A), dann h¨    λmax (δA) δb K(A) x − x . + ≤ b λmax 1 − λmax (δA)/λmin x

Falls K(A) klein“ ist, also in der Gr¨oßenordnung der Eins, wird ” die Matrix A gut konditioniert genannt, und kleine Fehler in den Daten entsprechen Fehlern in derselben Gr¨ oßenordnung in der L¨osung. Dies ist hingegen nicht der Fall, wenn K(A) groß ist, und die Matrix A schlecht konditioniert ist. Beispiel 5.8 F¨ ur die Hilbert-Matrix, eingef¨ uhrt in Beispiel 5.7, ist K(An ) ahrend eine schnell wachsende Funktion von n. Es ist K(A4 ) > 15000, w¨ f¨ ur n > 13 MATLAB bereits davon ausgeht, daß die Matrix singul¨ ar ist. Wir sollten uns aber nicht von den schlechten Ergebnissen aus Beispiel 5.7 erschrecken lassen.

5.3 Wie genau ist die LU-Faktorisierung?

129

−10

10

−11

10

−12

10

−13

10

−14

10

−15

10

−16

10

0

500

1000

1500

2000

2500

Abb. 5.5. Verlauf von log EK (n) in Funktion von n

Ungleichung (5.23) kann umformuliert werden, indem wir das Residuum r einf¨ uhren: r = b − A x.

(5.25)

 die exakte L¨ Falls x osung w¨ are, w¨ are das Residuum klarerweise null.  angesehen werden. Wie Folglich kann r als Sch¨ atzer f¨ ur den Fehler x − x gut dieser Sch¨atzer ist, h¨ angt von der Gr¨ oße der Konditionszahl von A ab. Wenden wir n¨ amlich (5.23) an und wissen, daß δb = A( x − x) = A x − b = −r ist, erhalten wir tats¨ achlich  r x − x ≤ K(A) b x

(5.26)

Falls also K(A) klein“ ist, haben wir die Sicherheit, daß der Feh” ler klein ist, wenn auch das Residuum klein ist, wohingegen dies nicht notwendigerweise richtig ist, wenn K(A) groß“ ist. ” Beispiel 5.9 Berechnen wir die Norm des Residuums f¨ ur die Systeme aus Beispiel 5.7, erhalten wir Ergebnisse zwischen 10−16 und 10−11 . Die berechneten L¨ osungen unterscheiden sich hingegen betr¨ achtlich von der exakten L¨ osung des Systems.

Siehe Aufgaben 5.9–5.10.

130

5 Lineare Systeme

5.4 Wie man ein tridiagonales System l¨ ost In vielen Anwendungen (siehe etwa Kapitel 8) m¨ ussen wir ein Matrixsystem der Form ⎡ ⎤ 0 a1 c1 ⎢ ⎥ ⎢ e2 a2 . . . ⎥ ⎢ ⎥ A=⎢ ⎥ . .. ⎣ cn−1 ⎦ 0 en an l¨osen. Diese Matrix wird tridiagonal genannt, da die einzigen Elemente, die ungleich null sind, zur Hauptdiagonalen und zur ersten oberen und unteren Nebendiagonalen geh¨ oren. Nehmen wir an, die Koeffizienten der Matrix seien reelle Zahlen. Falls dann die Gauß-Faktorisierung von A existiert, sind die Faktoren L und U zwei bidiagonale Matrizen (untere bzw. obere) der Form ⎤ ⎡ ⎡ ⎤ 0 α1 c1 1 0 ⎥ ⎢ . ⎢ β2 1 ⎥ ⎥ ⎢ α2 . . ⎢ ⎥ ⎥. ⎢ L=⎢ , U = ⎥ . . ⎥ ⎢ .. .. ⎦ .. ⎣ ⎣ . cn−1 ⎦ 0 βn 1 0 αn Die unbekannten Koeffizienten αi und βi k¨onnen u ¨ber die Ungleichung LU = A bestimmt werden. Auf diese Weise erhalten wir die folgenden rekursiven Beziehungen: ei , αi = ai − βi ci−1 , i = 2, . . . , n. α1 = a1 , βi = αi−1 Aufgrund dieser k¨ onnen wir die beiden bidiagonalen Systeme Ly = b und Ux = y l¨ osen und erhalten folgende Formeln: (Ly = b) y1 = b1 , yi = bi − βi yi−1 , i = 2, . . . , n, (Ux = y) xn =

spdiags

(5.27)

yn , xi = (yi − ci xi+1 ) /αi , i = n − 1, . . . , 1. (5.28) αn

Diese Prozedur ist bekannt als Thomas-Algorithmus und erlaubt die Aufl¨osung eines tridiagonalen Systems mit einem Rechenaufwand der Ordnung n Operationen. Mit dem MATLAB-Befehl spdiags k¨onnen wir einfach eine tridiagonale Matrix konstruieren, indem wir nur die drei nichtverschwindenden Diagonalen abspeichern. Zum Beispiel erhalten wir mit den Befehlen >> >> >> >>

b=ones(10,1); a=2*b; c=3*b; T=spdiags([b a c],-1:1,10,10);

5.4 Wie man ein tridiagonales System l¨ ost

131

die tridiagonale Matrix T ∈ R10×10 mit Koeffizienten gleich 2 auf der Hauptdiagonalen, gleich 1 auf der ersten unteren Nebendiagonalen und 3 auf der ersten oberen Nebendiagonalen. Beachte, daß T in einem d¨ unnbesetzten Format gespeichert wird: dieses speichert nur die von 0 verschiedenen Elemente. Falls MATLAB auf ein System trifft, das in diesem Format abgespeichert ist, werden automatisch L¨osungsverfahren angewandt, die die Rechenzeit und den Speicherbedarf optimieren (etwa der Algorithmus von Thomas, falls es sich um eine tridiagonale Matrix handelt). Beispiel 5.10 L¨ osen wir das lineare System Tx = b, wobei T eine tridiagonale Matrix der Dimension n ist, die wie vorhin definiert ist, und b so gew¨ ahlt wird, daß die exakte L¨ osung x = (1, . . . , 1)T ist. Mit folgenden Befehlen l¨ osen wir dieses System (durch Aufruf des Befehls \) f¨ ur verschiedene Werte von n und berechnen dann das Verh¨ altnis zwischen der Anzahl an Operationen und n. F¨ ur große n strebt dieses gegen eine Konstante und best¨ atigt, daß die Anzahl der Operationen proportional zu n ist. >> ratio = [ ]; >> for n = 50:25:200 b=ones(n,1); a=2*b; c=3*b; T=spdiags([b a c],-1:1,n,n); rhs = T*ones(n,1); flops(0); x=T\rhs; ratio = [ratio, flops/n]; end >> ratio = Columns 1 through 7 24.5000 24.6133 24.7300 24.7520 24.8067

24.7771

24.8150

Zusammenfassend 1. Die LU-Faktorisierung von A besteht in der Berechnung einer unteren Dreiecksmatrix L und einer oberen Dreiecksmatrix U, so daß A = LU; 2. Die LU-Faktorisierung ist, falls sie existiert, nicht eindeutig und wird bestimmt, indem zus¨ atzlich n Koeffizienten von L oder von U fixiert werden. Setzt man etwa alle Diagonalkoeffizienten von L gleich 1, erh¨alt man die sogenannte Gauß-Faktorisierung; 3. Die Gauß-Faktorisierung kann nur dann berechnet werden, falls die Hauptuntermatrizen der Ordnung 1 bis n − 1 nichtsingul¨ar sind; andernfalls ist mindestens ein Pivot gleich null; sie ist u ¨berdies eindeutig, falls det(A)
= 0; 4. Falls ein Pivot gleich null erzeugt wird, k¨ onnen wir ein neues Pivot erhalten, indem wir in geeigneter Weise zwei Zeilen oder Spalten miteinander vertauschen (diese Strategie wird Pivoting genannt);

132

5 Lineare Systeme

5. Zur Berechnung der Faktoren L und U sind etwa 2n3 /3 Operationen notwendig. Im Fall tridiagonaler Matrizen ist der Rechenaufwand hingegen nur mehr von der Ordnung n Operationen; 6. Auf symmetrische, positiv definite Matrizen k¨onnen wir die CholeskyFaktorisierung A = HHT anwenden, wobei H eine untere Dreiecksmatrix ist. Der Rechenaufwand ist von der Ordnung n3 /3 Operationen; 7. Die Empfindlichkeit der L¨ osung eines linearen Gleichungssystems gegen¨ uber St¨ orungen in den Daten h¨ angt von der Konditionszahl der Matrix ab. Falls diese groß ist, k¨ onnen kleine St¨orungen in den Koeffizienten der Matrix und der rechten Seite sehr ungenaue L¨osungen bewirken.

5.5 Iterative Verfahren Ein iteratives Verfahren zur L¨ osung des linearen Systems (5.1) besteht in der Konstruktion einer Folge von Vektoren {x(k) , k ≥ 0} in Rn , die gegen die exakte L¨ osung x konvergiert, das heißt lim x(k) = x.

(5.29)

k→∞

Eine m¨ogliche Strategie f¨ ur einen derartigen Prozeß besteht darin, rekursiv x(k+1) = Bx(k) + g,

k ≥ 0,

(5.30)

zu definieren, wobei B eine geeignete Matrix (abh¨angig von A) und g ein geeigneter Vektor (abh¨ angig von A und b) so gew¨ahlt sind, daß sie die Konsistenzbedingung x = Bx + g

(5.31)

erf¨ ullen. Da x = A−1 b ist, ist klarerweise g = (I − B)A−1 b. Sei e(k) = x − x(k) der Fehler im k-ten Schritt. Subtrahieren wir (5.30) von (5.31), erhalten wir e(k+1) = Be(k) . Aus diesem Grund heißt B Iterationsmatrix von Verfahren (5.30). Falls B symmetrisch und positiv definit ist, gilt wegen (5.21) e(k+1) = Be(k) ≤ ρ(B) e(k) ,

∀k ≥ 0.

Wir erinnern daran, daß ρ(B) der Spektralradius von B ist, das ist der maximale Betrag der Eigenwerte von B. Iterieren wir diese Ungleichung zur¨ uck bis zum Anfang, erhalten wir

5.5 Iterative Verfahren

e(k) ≤ [ρ(B)]k e(0) ,

k ≥ 0.

133

(5.32)

ur k → ∞ f¨ ur alle e(0) (und folglich Falls ρ(B) < 1, dann ist e(k) → 0 f¨ (0) f¨ ur alle x ). Man kann außerdem zeigen, daß diese Voraussetzung auch notwendig f¨ ur die Konvergenz ist. Sollten wir unter Umst¨ anden ρ(B) kennen, dann k¨onnten wir aus (5.32) die minimale Anzahl kmin an Iterationen berechnen, die notwendig sind, um den Anfangsfehler um einen Faktor ε zu d¨ampfen. Tats¨achlich w¨are kmin die kleinste ganze Zahl, f¨ ur die [ρ(B)]kmin ≤ ε. Daraus erhalten wir folgende Eigenschaft: Satz 5.2 Notwendige und hinreichende Bedingung zur Konvergenz eines iterativen Verfahrens der Form (5.30) f¨ ur jedes x(0) ist, daß ¨ ρ(B) < 1, vorausgesetzt (5.31) ist erf¨ ullt. Uberdies, je kleiner ρ(B), desto geringer ist die Anzahl notwendiger Iterationen, damit sich der Anfangsfehler um einen gegebenen Faktor verkleinert.

5.5.1 Wie man ein iteratives Verfahren konstruiert Eine allgemeine Technik zur Konstruktion eines iterativen Verfahrens basiert auf einer additiven Zerlegung (oder Splitting) der Matrix A in A = P − (P − A), wobei P eine beliebige nichtsingul¨are Matrix ist, die wir vorkonditionierende Matrix (oder Vorkonditionierer ) von A nennen. Dann ist Px = (P − A)x + b, also von der Form (5.31), vorausgesetzt B = P−1 (P − A) = I − P−1 A und g = P−1 b. Diese Identit¨ at legt nahe, folgendes iterative Verfahren zu definieren: P(x(k+1) − x(k) ) = r(k) ,

k ≥ 0,

wobei r(k) = b − Ax(k) das Residuum in der k-ten Iteration bezeichnet. Eine Verallgemeinerung dieses Iterationsverfahrens ist

P(x(k+1) − x(k) ) = αk r(k) ,

k≥0

(5.33)

wobei αk
= 0 ein Parameter ist, der in jedem Iterationsschritt k verschieden sein kann, und der dazu dient, die Konvergenzeigenschaften der Folge {x(k) } zu verbessern. In Verfahren (5.33) muß in jedem Schritt ein lineares System Pz(k) = r(k)

(5.34)

134

5 Lineare Systeme

gel¨ost werden, und folglich ist die neue Iterierte definiert durch x(k+1) = x(k) + αk z(k) . Deshalb muß die Matrix P so gew¨ahlt werden, daß der Rechenaufwand zur L¨ osung von (5.34) m¨ oglichst gering ist (f¨ ur jede diagonale, tridiagonale oder Dreiecksmatrix P w¨are das der Fall). Wir wollen jetzt einige Beispiele f¨ ur iterative Verfahren der Form (5.33) vorstellen. Das Jacobi-Verfahren Falls die Diagonaleintr¨ age von A ungleich null sind, k¨onnen wir P = ahlen. Das Jacobi-Verfahren entspricht D = diag{a11 , a22 , . . . , ann } w¨ dieser Wahl unter der Annahme αk = 1 f¨ ur alle k. Folglich erhalten wir aus (5.33) Dx(k+1) = b − (A − D)x(k) ,

k ≥ 0,

oder komponentenweise

(k+1) xi

⎛ ⎞ n  1 ⎝ (k) ⎠ aij xj bi − , i = 1, . . . , n = aii

(5.35)

j=1,j=i

(0)

(0)

(0)

wobei k ≥ 0 und x(0) = (x1 , x2 , . . . , xn )T der Startvektor ist. Die Iterationsmatrix ist dann ⎤ ⎡ 0 −a12 /a11 . . . −a1n /a11 ⎥ ⎢ ⎢ −a /a 0 −a2n /a22 ⎥ 21 22 ⎥ ⎢ ⎥ ⎢ B = D−1 (D − A) = ⎢ ⎥ . (5.36) .. .. .. ⎥ ⎢ . ⎥ ⎢ . . ⎦ ⎣ −an1 /ann −an2 /ann . . .

0

F¨ ur das Jacobi-Verfahren gilt ein Resultat, mit dem wir Satz 5.2 u ufen k¨onnen, ohne ρ(B) explizit zu berechnen: ¨berpr¨ Satz 5.3 Falls die Matrix A des Systems (5.1) streng zeilendiagonaldominant ist, konvergiert das Jacobi-Verfahren.

Tats¨ achlich k¨onnen wir u ufen, daß in diesem Fall ρ(B) < 1 ¨berpr¨ gilt, wobei B durch (5.36) gegeben ist. Wir k¨ onnen sofort feststellen, daß die Diagonale von A keine Elemente gleich null hat, da ja A streng diagonaldominant ist. Sei λ zusammen mit x ein Eigenwert-EigenvektorPaar von B. Dann ist n  j=1

bij xj = λxi , i = 1, . . . , n.

5.5 Iterative Verfahren

135

Nehmen wir der Einfachheit halber an, maxk=1,... ,n |xk | = 1 (diese Annahme ist nicht restriktiv, da ja jeder Eigenvektor bis auf eine multiplikative Konstante definiert ist) und sei xi jene Komponente, deren Betrag gleich 1 ist. Dann gilt      n       n    aij    n    ,    |λ| =  bij xj  =  bij xj  ≤  aii  j=1    j=1,j=i

j=1,j=i

wobei alle Diagonalelemente von B gleich null sind. Aufgrund der Bedingungen an A gilt also |λ| < 1. Das Jacobi-Verfahren ist in Programm 11 implementiert und kann durch Setzen des Parameters P=’J’ aufgerufen werden. Die u ¨brigen Eingabeparameter sind: die Systemmatrix A, die rechte Seite b, der Startvektor x0 und die maximal zugelassene Anzahl nmax an Iterationen. Die iterative Prozedur bricht ab, falls das Verh¨ altnis zwischen der Norm des aktuellen Residuums und des ersten Residuums kleiner einer festgelegten Toleranz tol ist (siehe dazu Abschnitt 5.6). Programm 11 - itermeth : allgemeines iteratives Verfahren function [x, iter]= itermeth(A,b,x0,nmax,tol,P) %ITERMETH Ein allgemeines iteratives Verfahren % X = ITERMETH(A,B,X0,NMAX,TOL,P), welches versucht, % das lineare Gleichungssystem A*X=B iterativ nach X % aufzuloesen. Die Matrix A mit N-mal-N Koeffizienten muss % nichtsingulaer sein und die rechte Seite B die Laenge N haben. % Falls P=’J’ wird das Jacobi-Verfahren angewandt, falls % P=’G’ wird das Gauss-Seidel-Verfahren gewaehlt. Andernfalls ist P % eine nichtsingulaere (N-mal-N)-Matrix, die die Rolle des Vorkonditionierers % spielt. Das Verfahren bricht ab, sobald das Verhaeltnis zwischen der % Norm des aktuellen Residuums und des ersten Residuums kleiner als % TOL. NMAX bestimmt die maximal zulaessige Anzahl an Iterationen. [n,n]=size(A); if nargin == 6 if ischar(P)==1 if P==’J’ L = diag(diag(A)); U = eye(n); beta = 1; alpha = 1; elseif P == ’G’ L = tril(A); U = eye(n); beta = 1; alpha = 1; end else [L,U]=lu(P); beta = 0; end else L = eye(n); U = L; beta = 0;

136

5 Lineare Systeme

end iter = 0; r = b - A * x0; r0 = norm(r); err = norm (r); x = x0; while err > tol & iter < nmax iter = iter + 1; z = L\r; z = U\z; if beta == 0 alpha = z’*r/(z’*A*z); end x = x + alpha*z; r = b - A * x; err = norm (r) / r0; end

Das Gauß-Seidel-Verfahren Im Jacobi-Verfahren werden die Komponenten des Vektors x(k+1) unabh¨angig voneinander berechnet. Das l¨aßt uns vermuten, daß wir die Konvergenzgeschwindigkeit erh¨ ohen k¨ onnten, falls wir f¨ ur die Berech(k+1) (k+1) die neuen, bereits verf¨ ugbaren Komponenten xj , nung von xi (k)

j = 1, . . . , i − 1 zusammen mit den alten xj , j ≥ i verwenden. Wir modifizieren also Verfahren (5.35) folgendermaßen: f¨ ur k ≥ 0 (weiterhin ur i = 1, . . . , n) gilt angenommen, daß aii
= 0 f¨ (k+1)

xi

⎛ ⎞ i−1 n   1 ⎝ (k+1) (k) aij xj − aij xj ⎠ , i = 1, .., n bi − = aii j=1 j=i+1

(5.37)

Die Aktualisierung der Komponenten muß also sequentiell erfolgen, w¨ahrend sie im urspr¨ unglichen Jacobi-Verfahren simultan (oder parallel) erfolgt. Das neue Verfahren, Gauß-Seidel-Verfahren genannt, entspricht der Wahl P = D − E und αk = 1, k ≥ 0 in (5.33), wobei E eine untere Dreiecksmatrix ist, deren einzige Elemente ungleich null die Elemente orige Iterationseij = −aij , i = 2, . . . , n, j = 1, . . . , i − 1 sind. Die zugeh¨ matrix hat die Form B = (D − E)−1 (P − A). Eine Verallgemeinerung dieses Verfahrens ist das sogenannte Relaxationsverfahren, f¨ ur das P = ω1 D − E ist, wobei ω
= 0 ein Relaxationsparameter ist und αk = 1, k ≥ 0 (siehe Aufgabe 5.13). Auch f¨ ur das Gauß-Seidel-Verfahren existieren Klassen von Matrizen, f¨ ur die Satz 5.2 sicher erf¨ ullt ist. Das sind unter anderem:

5.6 Wann soll ein iteratives Verfahren abgebrochen werden?

137

1. streng zeilendiagonaldominante Matrizen; 2. symmetrische, positiv definite Matrizen. Das Gauß-Seidel-Verfahren kann mit Programm 11 aufgerufen werden, indem der Eingabeparameter P gleich ’G’ gesetzt wird. Es gibt keine allgemeinen Resultate, die best¨atigen w¨ urden, daß das Gauß-Seidel-Verfahren stets schneller als das Jacobi-Verfahren konvergiert, außer in einigen Spezialf¨ allen, wie in folgendem Satz: Satz 5.4 Falls A eine nichtsingul¨ are, tridiagonale Matrix der Dimension n ist mit aii
= 0, i = 1, . . . , n, dann sind Jacobi- und GaußSeidel-Verfahren entweder beide divergent oder beide konvergent. In letzterem Fall konvergiert das Gauß-Seidel-Verfahren schneller als das Jacobi-Verfahren. Genauer gesagt ist der Spektralradius der Iterationsmatrix des Gauß-Seidel-Verfahrens gleich dem Quadrat des Spektralradius der Iterationsmatrix des Jacobi-Verfahrens. Beispiel 5.11 Betrachten wir das lineare System Ax = b, wobei A die tridiagonale Matrix der Dimension n = 10 mit Elementen gleich 3 auf der Hauptdiagonalen, gleich −2 auf der oberen Nebendiagonalen und −1 auf der unteren Nebendiagonalen ist, w¨ ahrend b so gew¨ ahlt ist, daß die L¨ osung der Einheitsvektor (1, 1, . . . , 1)T ist. Sowohl Jacobi- als auch Gauß-SeidelVerfahren konvergieren, da die Spektralradien beider Iterationsmatrizen kleiner als 1 sind. Im speziellen konvergiert das Jacobi-Verfahren in 277 Iterationen, das Gauß-Seidel-Verfahren in 143 (wir haben tol =10−12 , nmax=400 und den Nullvektor als Startwert gesetzt). Die Anweisungen dazu lauten folgendermaßen: >> n=10; A = 3*eye(n) - 2*diag(ones(n-1,1),1) - diag(ones(n-1,1),-1); >> b=A*ones(n,1); >> [x,iter]=itermeth(A,b,zeros(n,1),400,1.e-12,’J’); iter iter = 277

>> [x,iter]=itermeth(A,b,zeros(n,1),400,1.e-12,’G’); iter iter = 143

Siehe Aufgaben 5.11–5.14.

5.6 Wann soll ein iteratives Verfahren abgebrochen werden? Theoretisch sind f¨ ur iterative Verfahren unendlich viele Iterationen notwendig, damit sie gegen die exakte L¨osung konvergieren. In der Praxis

138

5 Lineare Systeme

ist das weder sinnvoll noch n¨ otig. Tats¨ achlich ist es im allgemeinen nicht notwendig, die exakte L¨ osung zu kennen, es gen¨ ugt meistens eine Apur die wir garantieren k¨onnen, daß der Fehler kleiner proximation x(k) , f¨ als eine gew¨ unschte Toleranz ε ist. Da andererseits der Fehler eine unbekannte Gr¨oße (abh¨ angig von der exakten L¨osung) ist, ben¨otigen wir einen geeigneten a-posteriori-Fehlersch¨ atzer, der sich aus bereits bestimmten Gr¨oßen bestimmen l¨ aßt. Ein erster Sch¨ atzer ist das Residuum in jeder Iteration r(k) = b − Ax(k) , wobei x(k) die approximierte L¨ osung in der k-ten Iteration bezeichnet. Wir k¨onnten also unser iteratives Verfahren zum ersten Schritt kmin abbrechen, zu dem r(kmin ) ≤ ε b .  = x(kmin ) und r = r(kmin ) in (5.26), so erhalten wir Setzen wir x e(kmin ) ≤ εK(A), x also eine Absch¨ atzung f¨ ur den relativen Fehler. Die Kontrolle des Residuums ist allerdings nur dann sinnvoll, wenn die Konditionszahl der Systemmatrix A klein ist. Beispiel 5.12 Betrachten wir das lineare System (5.1), in dem A=A20 die Hilbert-Matrix der Dimension 20 ist, die wir in Beispiel 5.7 eingef¨ uhrt haben, und in dem b so konstruiert wird, daß die exakte L¨ osung x = (1, 1, . . . , 1)T ist. Da A symmetrisch und positiv definit ist, konvergiert das Gauß-SeidelVerfahren sicher. Wir verwenden Programm 11 mit dem Nullvektor x0 als Startwert und einer Toleranz tol von 10−5 . Das Verfahren konvergiert nach 472 Iterationen, aber der relative Fehler ist gleich 0.26. Dieses Verhalten ist durch die extrem schlecht konditionierte Matrix bedingt, es ist n¨ amlich K(A)  1017 . In Abbildung 5.6 ist der Verlauf der Residuumsnorm (dividiert durch das Anfangsresiduum) und des Fehlers in Abh¨ angigkeit von der Iterationsanzahl dargestellt.

Ein alternatives Kriterium basiert auf der Verwendung eines anderen Sch¨atzers, dem sogenannten Inkrement δ (k) = x(k+1) −x(k) . Das iterative Verfahren wird also zum ersten Schritt kmin abgebrochen, zu dem δ (kmin ) ≤ ε b . F¨ ur den Fall, daß B symmetrisch und positiv definit ist, gilt e(k) = e(k+1) − δ (k) ≤ ρ(B) e(k) + δ (k) . Da ρ(B) < 1 sein muß, damit das Verfahren konvergiert, k¨onnen wir schließen, daß

5.6 Wann soll ein iteratives Verfahren abgebrochen werden?

139

1

10

0

10

−1

10

−2

r(k) / r(0)

10

−3

10

x − x(k)

−4

10

−5

10

−6

10

0

100

200

300

400

500

Abb. 5.6. Der Verlauf der Residuumsnorm (in unterbrochener Linie) und des Fehlers (in durchgehender Linie) f¨ ur das Gauß-Seidel-Verfahren, angewandt auf das System aus Beispiel 5.12

e(k) ≤

1 δ (k) 1 − ρ(B)

(5.38)

Wir sehen also, daß die Kontrolle des Inkrements nur dann sinnvoll ist, wenn ρ(B) sehr viel kleiner als eins ist, da nur in diesem Fall der Fehler dieselbe Gr¨oßenordnung wie das Inkrement hat. Derselbe Schluß gilt auch im Fall, daß B nicht symmetrisch und positiv definit ist (wie etwa im Jacobi- und Gauß-Seidel-Verfahren), auch wenn in diesem Fall (5.38) nicht mehr gilt. Beispiel 5.13 Betrachten wir ein System mit symmetrischer tridiagonaler Matrix A∈ R50×50 , deren Diagonalelemente gleich 2.001 und in den Nebendiagonalen gleich 1 sind; wie immer w¨ ahlen wir die rechte Seite derart, daß osung bezeichnet. Da A tridiagonal und der Vektor (1, . . . , 1)T die exakte L¨ streng diagonaldominant ist, konvergiert das Gauß-Seidel-Verfahren doppelt so schnell wie das Jacobi-Verfahren (wie wir in Satz 5.4 gesehen haben). Wir verwenden zur L¨ osung des Systems Programm 11, ersetzen aber das Abbruchkriterium, das auf dem Residuum basiert, durch jenes, das auf dem Inkrement basiert. Mit dem Nullvektor als Startwert und einer Toleranz osung von tol= 10−5 liefert das Programm nach 1604 Iterationen eine L¨ mit einem recht großen Fehler von 0.0029. Der Grund hierf¨ ur ist, daß der Spektralradius der Iterationsmatrix gleich 0.9952 ist, also sehr nahe bei 1. W¨ aren die Diagonalelemente hingegen gleich 3, h¨ atten wir bereits nach 17 Iterationen ein Ergebnis mit einem Fehler der Gr¨ oßenordnung 10−5 erhalten, tats¨ achlich ist in diesem Fall der Spektralradius der Iterationsmatrix gleich 0.4428.

140

5 Lineare Systeme

5.7 Das Richardson-Verfahren In diesem Abschnitt wollen wir Verfahren der Form (5.33) mit Beschleunigungsparametern αk ungleich null untersuchen. Wir nennen den Fall, in dem αk = α (eine gegebene Konstante) f¨ ur jedes k ≥ 0, station¨ar , den Fall, in dem αk in jeder Iteration verschieden sein kann, dynamisch. Auch hier wird die nichtsingul¨ are Matrix P Vorkonditionierer von A genannt. Das gr¨oßte Problem ist nat¨ urlich die Wahl der Parameter. Dazu gilt folgendes Resultat (siehe etwa [QV97, Kap.2], [Axe94]). Satz 5.5 Falls P und A beide symmetrisch und positiv definit sind, konvergiert das station¨are Richardson-Verfahren f¨ ur jede m¨ ogliche Wahl x(0) genau dann, wenn 0 < α < 2/λmax , wobei λmax (> 0) der ¨ nimmt der Spektralradius gr¨ oßte Eigenwert von P−1 A ist. Uberdies ρ(Bα ) der Iterationsmatrix Bα = I − αP−1 A sein Minimum an, falls ur α = αopt , f¨ αopt =

2 λmin + λmax

(5.39)

wobei λmin der kleinste Eigenwert von P−1 A ist. Unter denselben Voraussetzungen an P und A konvergiert das dynaahlt wird: mische Richardson-Verfahren, falls αk folgendermaßen gew¨

αk =

(z(k) )T r(k) (z(k) )T Az(k)

∀k ≥ 0

(5.40)

wobei z(k) = P−1 r(k) das sogenannte vorkonditionierte Residuum ist. Mit dieser Wahl wird Verfahren (5.33) vorkonditioniertes Gradientenverfahren oder, falls P die Einheitsmatrix ist, Gradientenverfahren genannt. In beiden F¨allen gilt folgende Konvergenzabsch¨ atzung:

e(k) A ≤



K(P−1 A) − 1 K(P−1 A) + 1

k

e(0) A ,

k≥0

(5.41)

√ wobei v A = vT Av, ∀v ∈ Rn die sogenannte zur Matrix A geh¨ orige Energienorm ist.

Das dynamische Verfahren ist dem station¨aren vorzuziehen, da wir f¨ ur dieses den gr¨ oßten und kleinsten Eigenwert von P−1 A nicht kennen

5.7 Das Richardson-Verfahren

141

m¨ ussen und den Parameter αk aus bereits im Schritt k bekannten Gr¨oßen berechnen k¨onnen. Das Verfahren des vorkonditionierten Gradienten kann auf effiziente ¨ Weise in folgendem Algorithmus (dessen Herleitung dem Leser als Ubung ur jedes k ≥ 0 u ¨berlassen wird) formuliert werden: Sei x(0) gegeben, f¨ berechne man Pz(k) = r(k) αk = x

(z(k) )T r(k) (z(k) )T Az(k)

(k+1)

=x

(k)

+ αk z

(5.42) (k)

r(k+1) = r(k) − αk Az(k)

Derselbe Algorithmus kann dazu verwendet werden, das station¨ are Richardson-Verfahren zu implementieren, indem wir αk durch den konstanten Wert α ersetzen. Aus (5.5) k¨onnen wir schließen, daß, falls P−1 A schlecht konditioniert ist, die Konvergenzgeschwindigkeit sehr gering ist, auch wenn α = αopt gew¨ahlt wird (da ρ(Bαopt )  1). Es ist also wichtig, die vorkonditionierende Matrix geeignet zu w¨ahlen. F¨ ur eine beliebige Matrix A kann es sehr schwierig sein, einen Vorkonditionierer zu finden, der einen optimalen Kompromiß zwischen D¨ ampfung der Konditionszahl und rechnerischem Aufwand zur L¨ osung der Systeme (5.34) darstellt. Die Wahl muß von Fall zu Fall neu getroffen werden, in Abh¨angigkeit von der gegebenen Matrix A. Das dynamische Richardson-Verfahren ist in Programm 11 implementiert, in dem der Eingabeparameter P die vorkonditionierende Matrix ist (falls dieser fehlt, implementiert das Programm das nicht vorkonditionierte Verfahren, indem P=I gesetzt wird). Beispiel 5.14 Dieses Beispiel von rein theoretischem Interesse hat den Zweck, das Konvergenzverhalten des Jacobi-, Gauß-Seidel- und Gradientenverfahrens, angewandt zur L¨ osung folgenden (mini-)linearen Systems, zu vergleichen: 2x1 + x2 = 1, x1 + 3x2 = 0 (5.43) mit Startvektor x(0) = (1, 1/2)T . Beachte, daß die Matrix dieses Systems symmetrisch und positiv definit ist und daß die exakte L¨ osung x = (3/5, −1/5)T ist. In Abbildung 5.7 geben wir den Verlauf des relatiur die drei genannten Verfahren wieven Residuums E (k) = r(k) / r(0) f¨ ur der. Die Iterationen werden bei der ersten Iteration kmin abgebrochen, f¨ die E (kmin ) ≤ 10−14 . Das Gradientenverfahren ist jenes Verfahren, das am schnellsten konvergiert.

142

5 Lineare Systeme 0

10

−2

10

−4

10

Jacobi Gauss−Seidel Gradiente

−6

10

−8

10

−10

10

−12

10

−14

10

−16

10

0

5

10

15

20

25

30

35

40

Abb. 5.7. Konvergenzverlauf des Jacobi-, Gauß-Seidel- und Gradientenverfahrens, angewandt auf System (5.43) Beispiel 5.15 Betrachten wir das System Ax = b mit pentadiagonaler Matrix A ∈ R100×100 . Die Elemente der Hauptdiagonalen von A seien gleich 4, die Elemente der ersten und der dritten Nebendiagonale von A seien gleich −1 und alle anderen Elemente von A seien gleich 0. Wie bisher ist b so gew¨ ahlt, daß die exakte L¨ osung des Systems gleich x = (1, . . . , 1)T ist. Wir verwenden Programm 11, das das vorkonditionierte Richardson-Verfahren implementiert. Wir fixieren tol=1.e-05, nmax=1000, x0=zeros(100,1) und w¨ ahlen als vorkonditionierende Matrix f¨ ur das Richardson-Verfahren die tridiagonale Matrix P mit Diagonalelementen gleich 2 und den Elementen in der oberen und unteren Nebendiagonalen gleich −1. Sowohl A als auch P sind symmetrisch und positiv definit. Das Verfahren konvergiert in 18 Iterationen, w¨ ahrend Programm 11 (unter Verwendung des Gauß-Seidel-Verfahrens) 2421 Iterationen zur Erf¨ ullung desselben Abbruchkriteriums ben¨ otigt. Beispiel 5.16 (direkte und iterative Verfahren) Kommen wir zur¨ uck zu Beispiel 5.7, also zur Hilbert-Matrix, und l¨ osen das System mit dem Gradientenverfahren, vorkonditioniert mit einer Diagonalmatrix D, deren Diagonale mit jener der Hilbert-Matrix u ¨bereinstimmt. Wir geben auch die Resultate wieder, die wir mit einem noch effizienteren Verfahren erhalten w¨ urden, und zwar dem Verfahren der konjugierten Gradienten (CG), das wir in Abschnitt 5.8 behandeln werden. Wir w¨ ahlen x(0) = 0T und brechen das Verfahren ab, sobald das relative Residuum kleiner 10−6 ist. In Tabelle 5.1 geben wir die Werte jener absoluten Fehler (bez¨ uglich der exakten L¨ osung) wieder, die wir mit den obgenannten iterativen Verfahren und mit der Gaußschen LU-Faktorisierung erhalten haben. In letzterem Fall verschlechtert sich der Fehler mit zunehmendem n. Andererseits sehen wir die positiven Auswirkungen eines geeignet gew¨ ahlten iterativen Verfahrens auf die Anzahl von Iterationen, wie hier etwa das vorkonditionierte konjugierte Gradientenverfahren PCG.

Siehe Aufgaben 5.15–5.17.

5.8 Was wir nicht erw¨ ahnt haben

143

Tabelle 5.1. Die Fehler bei der L¨ osung des Hilbert-Systems, erhalten aus der Gaußschen LU-Faktorisierung, dem vorkonditionierten Gradientenverfahren (PG) und dem Verfahren der konjugierten Gradienten (PCG) Als Vorkonditionierer wurde die Diagonalmatrix mit der Diagonalen der Hilbert-Matrix verwendet

n 4 6 8 10 12 14

K(A) 1.55e+04 1.50e+07 1.53e+10 1.60e+13 1.67e+16 3.04e+17

LU Fehler 3.90e-13 2.62e-10 1.34e-07 7.60e-04 4.97e-01 6.65e+00

PG Fehler Iter. 1.74-02 995 8.80e-03 1813 1.78e-02 1089 2.52e-03 875 1.76e-02 1355 1.46e-02 1379

PCG Fehler Iter. 2.24e-02 3 9.50e-03 9 2.13e-02 4 6.98e-03 5 1.12e-02 5 1.61e-02 5

Zusammenfassend 1. Ein iteratives Verfahren zur L¨osung eines linearen Systems konstruiert, ausgehend von einem Startvektor x(0) , eine Folge von Vektoren x(k) , von denen man verlangt, daß sie gegen die exakte L¨ osung f¨ ur k → ∞ konvergieren; 2. Hinreichende und notwendige Bedingung f¨ ur die Konvergenz eines iterativen Verfahrens f¨ ur jedes beliebig gew¨ ahlte x(0) ist, daß der Spektralradius der Iterationsmatrix kleiner als 1 ist; 3. Die klassischen Iterationsverfahren sind das Jacobi- und das GaußSeidel-Verfahren. Hinreichend f¨ ur die Konvergenz dieser Verfahren ist, daß die Matrix des zu l¨osenden Systems streng diagonaldominant ist (im Fall des Gauß-Seidel-Verfahrens auch symmetrisch und positiv definit); 4. Im Richardson-Verfahren wird die Konvergenz beschleunigt, indem in jedem Iterationsschritt ein Parameter und (eventuell) eine geeignete vorkonditionierende Matrix eingef¨ uhrt wird; 5. Es gibt zwei m¨ogliche Abbruchkriterien f¨ ur ein iteratives Verfahren: die Kontrolle des Residuums und die Kontrolle des Inkrements. Ersteres ist aussagekr¨aftig, falls die Matrix des Systems gut konditioniert ist, das zweite, falls der Spektralradius der Iterationsmatrix strikt kleiner als 1 ist.

5.8 Was wir nicht erw¨ ahnt haben F¨ ur großdimensionierte lineare Systeme gibt es effiziente Varianten der Gaußschen LU-Faktorisierung. Unter den bekanntesten m¨ ochten wir das sogenannte Frontall¨ osungsverfahren nennen, das auf einer Umordnung

144

pcg gmres

luinc

5 Lineare Systeme

der Unbekannten des Systems beruht, derart, daß die Faktoren L und U so d¨ unnbesetzt wie m¨ oglich sind. F¨ ur eine Vertiefung siehe [GL89] und [DD95]. Was die iterativen Verfahren betrifft, unter diesen existiert eine große Familie moderner Verfahren, bekannt als Krylov-Verfahren, die eindeutig effizienter sind als die hier besprochenen Verfahren. Unter diesen stechen das Verfahren der konjugierten Gradienten (das nur auf Systeme mit symmetrisch positiver Matrix angewandt werden kann) und das GMRES -Verfahren (Generalized Minimum RESidual) hervor, weil sie in exakter Arithmetik in endlich vielen Schritten gegen die exakte L¨osung konvergieren. F¨ ur deren Beschreibung siehe etwa [Axe94], [Saa96] und [dV03]. Beide Verfahren (und noch viele mehr) sind in der MATLABToolbox sparfun implementiert und k¨ onnen mit den Befehlen pcg und gmres aufgerufen werden. Wie wir gesehen haben, konvergiert ein iteratives Verfahren langsam, falls die Matrix des Systems schlecht konditioniert ist. Aus diesem Grund sind viele Strategien zur Vorkonditionierung entwickelt worden (siehe etwa [dV89] und [dV03]). Unter diesen erw¨ahnen wir die rein algebraischen, die im wesentlichen auf der unvollst¨andigen (oder inexakten) LU-Faktorisierung beruhen, welche in MATLAB in der Funktion luinc implementiert ist. Andere Strategien werden ad hoc entwickelt und n¨ utzen bestimmte Eigenschaften des dem linearen System zugrundeliegenden physikalischen Problems aus. Schließlich m¨ ochten wir noch die Multigrid-Algorithmen erw¨ahnen, die auf der Verwendung einer Hierarchie von Systemen variabler Dimension beruhen, die ¨ ahnlich dem Ausgangssystem sind und so gew¨ahlt werden, daß der Fehler fortw¨ ahrend kleiner wird (siehe zum Beispiel [Hac85], [Wes91] und [Hac94]).

5.9 Aufgaben Aufgabe 5.1 Bestimme f¨ ur eine gegebene Matrix A ∈ Rn×n in Abh¨ angigkeit von n die zur Berechnung der Determinante mit der Rekursionsformel (1.8) n¨ otigen Operationen.

magic

Aufgabe 5.2 Verwende den MATLAB-Befehl magic(n), n=3, 4, . . . , 500, um die magischen Quadrate der Ordnung n zu konstruieren, also Matrizen, deren Zeilen-, Spalten- und Diagonalsumme konstant ist. Berechne die Determinanten mit dem Befehl det, eingef¨ uhrt in Abschnitt 1.3, und die CPU-Zeit f¨ ur diese Operationen mit dem Befehl cputime. Approximiere die so erhaltenen Daten mit dem Verfahren der kleinsten Quadrate und zeige, daß die Rechenzeiten etwa wie n3 steigen.

5.9 Aufgaben

145

Aufgabe 5.3 F¨ ur welche Werte ε erf¨ ullt die in (5.12) definierte Matrix die Voraussetzungen von Satz 5.1 nicht? F¨ ur welche Werte ist sie singul¨ ar? Ist es in diesem Fall trotzdem m¨ oglich, die LU-Faktorisierung zu berechnen? Aufgabe 5.4 Zeige, daß zur Berechnung der LU-Faktorisierung einer quadraotig sind. tischen Matrix A der Dimension n etwa 2n3 /3 Operationen n¨ Aufgabe 5.5 Zeige, daß die LU-Faktorisierung einer Matrix A zur Berechnung ihrer Inversen verwendet werden kann (beachte, daß der j-te Spaltenvekullt, wobei ej jener Vektor ist, tor yj von A−1 das lineare System Ayj = ej erf¨ dessen Komponenten alle gleich null sind, außer die j-te, welche gleich 1 ist). Aufgabe 5.6 Berechne mit Programm 10 die Faktoren L und U f¨ ur die Matrix aus Beispiel 5.6 und u ufe, daß die erhaltene LU-Faktorisierung un¨berpr¨ genau ist. Aufgabe 5.7 Erkl¨ are, aus welchem Grund Zeilenpivoting im Fall symmetrischer Matrizen nicht sinnvoll ist. Aufgabe 5.8 Betrachte das System Ax = b mit −2 2 −1

2 ε−2 0

A=

0 0 3

und b derart, daß die exakte L¨ osung gleich x = (1, 1, 1)T . ε ist eine reelle positive Zahl. Berechne die Gauß-Faktorisierung von A und zeige, daß l32 → ¨ ∞, falls ε → 0. Uberpr¨ ufe am Computer, daß die numerische L¨ osung des linearen Systems trotzdem genau ist. Aufgabe 5.9 Betrachte die linearen Systeme Ai xi = bi , i = 1, 2, 3, mit

A1 =

15 6 8 11

6 6 5 3

8 5 7 6

11 3 6 9

, Ai = (A1 )i , i = 2, 3,

und bi derart, daß die L¨ osung xi = (1, 1, 1, 1)T ist. L¨ ose diese Systeme mit Hilfe der Gauß-Faktorisierung mit Zeilenpivoting und begr¨ unde die erhaltenen Resultate. Aufgabe 5.10 Zeige, daß f¨ ur eine symmetrische und positiv definite Matrix A gilt: K(A2 ) = (K(A))2 . Aufgabe 5.11 Analysiere die Konvergenzeigenschaften von Jacobi- und GaußSeidel-Verfahren zur L¨ osung eines linearen Systems mit der Matrix A=

α 0 1 0 α 0 1 0 α

,

α ∈ R.

146

5 Lineare Systeme

Aufgabe 5.12 Stelle eine hinreichende Bedingung an die reelle Zahl β, so daß das Jacobi- und das Gauß-Seidel-Verfahren beide konvergieren, wenn sie zur L¨ osung eines Systems mit folgender Matrix angewandt werden: A=

−10 2 . β 5

(5.44)

Aufgabe 5.13 Betrachte zur L¨ osung des linearen Systems Ax = b mit A ∈ (0) (0) ur Rn×n folgendes Relaxationsverfahren: Gegeben x(0) = (x1 , . . . , xn )T , f¨ k = 0, 1, . . . , berechne (k)

ri

i−1

= bi −

(k+1)

aij xj j=1

n

−

(k)

(k+1)

aij xj , xi

(k)

= (1 − ω)xi

(k)

+ω

j=i

ri , aii

f¨ ur i = 1, . . . , n, wobei ω ein reeller Parameter ist. Gib die Iterationsmatrix an und zeige, daß die Bedingung 0 < ω < 2 f¨ ur die Konvergenz dieses Verfahrens notwendig ist. Beachte, daß das Verfahren f¨ ur ω = 1 das Gauß-Seidel-Verfahren ergibt. Falls 1 < ω < 2, ist das Verfahren als SOR-Verfahren (successive overrelaxation) bekannt. 32 und 26 u ufe, ohne den Spektralradius der Iterationsmatrix zu berechnen, ob das ¨berpr¨ Gauß-Seidel-Verfahren konvergiert. Aufgabe 5.14 Betrachte das lineare System Ax = b mit A =

Aufgabe 5.15 Berechne die erste Iteration des Jacobi- und des Gauß-SeidelVerfahrens sowie die erste Iteration des mit der Diagonalen von A vorkonditionierten Gradientenverfahrens, angewandt zur L¨ osung des Systems (5.43). Aufgabe 5.16 Zeige (5.39) und ρ(Bαopt ) =

K(P−1 A) − 1 λmax − λmin . = K(P−1 A) + 1 λmax + λmin

(5.45)

Aufgabe 5.17 Betrachten wir ein System von n = 20 Fabriken, die 20 verschiedene G¨ uter produzieren. Aufgrund des Leontief-Modells, eingef¨ uhrt in Problem 5.3, k¨ onnen wir annehmen, daß die Matrix C Koeffizienten cij = ur i = 1, . . . , 20. Kann i + j − 1 f¨ ur i, j = 1, . . . , n, hat, w¨ ahrend bi = i f¨ das System mit dem Gradientenverfahren gel¨ ost werden? Falls A eine nichtsingul¨ are Matrix ist, wissen wir, daß die Matrix AT A symmetrisch und positiv definit ist. Schlage aufgrund dieser Beobachtung eine Methode vor, die auf dem Gradientenverfahren basiert.

6 Eigenwerte und Eigenvektoren

Betrachten wir folgendes Problem: Sei eine quadratische Matrix A ∈ Rn×n gegeben, finde einen (reellen oder komplexen) Skalar λ und einen Vektor x ungleich null, so daß Ax = λx.

(6.1)

Jedes λ, das (6.1) erf¨ ullt, wird Eigenwert von A genannt, w¨ahrend x ein zugeh¨origer Eigenvektor ist. Klarerweise ist x nicht eindeutig, denn falls x ein Eigenvektor ist, dann ist es auch αx, unabh¨angig von einem reellen oder komplexen α
= 0. Falls x bekannt ist, kann λ mit Hilfe des Rayleigh-Quotienten x∗ Ax/ x 2 berechnet werden, wobei x∗ jener Vektor ist, dessen i-te Komponente gleich x ¯i ist. Eine Zahl λ ist Eigenwert von A, falls sie eine Wurzel des folgenden Polynoms n-ten Grades (charakteristisches Polynom von A genannt) ist: pA (λ) = det(A − λI). Folglich hat eine quadratische Matrix A der Dimension n maximal n verschiedene reelle oder komplexe Eigenwerte. Beachte, daß das Polynom pA (λ) im Fall reeller Matrixeintr¨ age reelle Koeffizienten hat, komplexe Eigenwerte treten daher immer als komplex konjugierte Paare auf. Problem 6.1 (Dynamik) Betrachten wir das System in Abbildung 6.1, das aus zwei punktf¨ ormigen K¨ orpern P1 und P2 , beide der Masse m, besteht, die durch zwei Federn verbunden sind und sich frei entlang ihrer Verbindungsgeraden bewegen k¨ onnen. Bezeichnen wir mit xi (t) die Position von ur i = 1, 2. Dann gilt aufgrund des zweiten dynamischen Pi zum Zeitpunkt t f¨ Gesetzes ..

..

m x1 = K(x2 − x1 ) − Kx1 , m x2 = K(x1 − x2 ). Wir sind an den periodischen Oszillationen interessiert, deren zugeh¨ orige L¨ osung gleich xi = ai sin(ωt + φ), i = 1, 2 ist, wobei ai = 0. In diesem Fall erhalten wir folgende Beziehungen: −ma1 ω 2 = K(a2 − a1 ) − Ka1 , −ma2 ω 2 = K(a1 − a2 ),

(6.2)

148

6 Eigenwerte und Eigenvektoren

also ein homogenes (2 × 2)-System, das genau dann nichttriviale L¨ osungen a1 , a2 besitzt, wenn λ = mω 2 /K ein Eigenwert der Matrix 2 −1 −1 1 ist. Mit dieser Definition von λ wird (6.2) zu Aa = λa. Da pA (λ) = (2 − λ)(1 − λ) − 1 ist, sind die beiden Eigenwerte λ1  2.618 und λ2  0.382, die den Oszillationsfrequenzen ωi = Kλi /m des Systems entsprechen. A=

x1 (t) x2 (t) x

P2

P1

Abb. 6.1. Ein System von zwei Punktmassen, durch Federn verbunden

Problem 6.2 (Demographie) Mehrere mathematische Modelle wurden vorgeschlagen, um die Entwicklung einer bestimmten (menschlichen oder tierischen) Population vorherzusagen. Das einfachste Populationsmodell, 1920 von Lotka vorgeschlagen und zwanzig Jahre sp¨ ater von Leslie formalisiert, basiert auf der Sterbe- und Geburtenrate in verschiedenen Altersabschnitten (t) i = 0, . . . , n. Bezeichnen wir mit xi die Anzahl weiblicher Vertreter der Po(0) pulation, deren Alter zur Zeit t in das i-te Intervall f¨ allt. Die Werte xi sind ¨ der weiblichen bekannt. Bezeichnen wir weiters mit si die Uberlebensrate Vertreter, deren Alter ins i-te Intervall f¨ allt, und mit mi die mittlere Anzahl an weiblichen Vertretern der Population, die von einem weiblichen Vertreter im i-ten Altersintervall geboren werden. Das Lotka- und Leslie-Modell wird durch folgende Gleichungen beschrieben: (t+1)

xi+1

(t+1)

x0

(t)

= xi si , n

=

i = 0, . . . , n − 1,

(t)

xi mi . i=0

Die ersten n Gleichungen beschreiben das Alter der Population, die letzte beschreibt deren Vermehrung. In Matrixform geschrieben heißt dies: (t)

wobei x

=

(t) (x0 , . . .

(t) , xn )T

A=

x(t+1) = Ax(t) , und A die Leslie-Matrix ist: m 0 m1 . . . s0 0 . . . . 0 s1 . . .. . . . . . . . 0 0 0

... ... ..

. sn−1

mn 0 .. . .. . 0

.

6 Eigenwerte und Eigenvektoren

149

In Abschnitt 6.1 werden wir sehen, daß die Populationsdynamik vollst¨ andig ahrend man die vom betragsgr¨ oßten Eigenwert λ1 von A bestimmt wird, w¨ Verteilung der Vertreter der Population u ¨ber die verschiedenen Altersintervalle (bez¨ uglich der Gesamtpopulation genormt) als Grenzwert x von x(t) f¨ ur t → ∞ erh¨ alt. Der Grenzwert erf¨ ullt Ax = λ1 x. Dieses Problem werden wir in Aufgabe 6.2 l¨ osen. Problem 6.3 (Interurbaner Verkehr) Betrachten wir n St¨ adte und sei A eine Matrix, deren Koeffizienten aij gleich 1 sind, falls die Stadt i mit der Stadt j verbunden ist, gleich 0 anderenfalls. Man kann zeigen, daß die Komponenten des Eigenvektors x (von Einheitsl¨ ange, das heißt, mit dem betragsm¨ aßig gr¨ oßten Eintrag auf 1 normiert), der zum betragsm¨ aßig gr¨ oßten Eigenwert geh¨ ort, ein Maß f¨ ur die Erreichbarkeit der verschiedenen St¨ adte liefern. Betrachten wir zum Beispiel das Eisenbahnnetz, das die elf gr¨ oßten St¨ adte der Lombardei (Norditalien) verbindet und in Abbildung 6.2 dargestellt ist. Die Betr¨ age der Komponenten von x sind in diesem Fall 0.5271 (Mailand) 0.1590 (Pavia) 0.3579 (Brescia) 0.2165 (Lodi) 0.4690 (Bergamo) 0.3861 (Como) 0.1590 (Varese) 0.2837 (Lecco) 0.0856 (Sondrio) 0.1906 (Cremona) 0.0575 (Mantova) Wie wir sehen, sind die am besten erreichbaren St¨ adte (in absteigender Reihenfolge) Mailand, Bergamo, Como und Brescia. Wie wir anhand dieser Analyse weiters feststellen k¨ onnen, haben die St¨ adte Pavia, Varese, Mantova und Sondrio, die jeweils einen Anschluß haben, verschiedene Erreichbarkeiten. Diese Analyse ber¨ ucksichtigt die Frequenz der Verbindungen nicht, sondern nur, ob eine Verbindung vorhanden ist oder nicht.

9 8 7

6 5 4

1 3 2

10

11

1 Mailand 2 Pavia 3 Lodi 4 Brescia 5 Bergamo 6 Como 7 Varese 8 Lecco 9 Sondrio 10 Cremona 11 Mantova

Abb. 6.2. Eine schematische Darstellung der Bahnverbindungen zwischen den gr¨ oßten St¨ adten der Lombardei

150

6 Eigenwerte und Eigenvektoren

Im speziellen Fall, daß A eine Diagonal- oder Tridiagonalmatrix ist, sind die Eigenwerte direkt durch die Diagonalelemente gegeben. Ist A hingegen eine allgemeine Matrix mit großer Dimension n, ist es nicht sinnvoll, die Eigenwerte (und zugeh¨ origen Eigenvektoren) als Nullstellen von pA (λ) zu approximieren. Aus diesem Grund greift man auf spezielle numerische Algorithmen zur¨ uck, die wir in den folgenden Abschnitten vorstellen werden.

6.1 Das Potenzverfahren Wie wir in den Problemen 6.2 und 6.3 gesehen haben, ist es nicht immer notwendig, das gesamte Spektrum von A (also die Menge aller seiner Eigenwerte) zu kennen. Oft reicht es aus, die extremen Eigenwerte, also jene mit gr¨ oßtem und kleinstem Absolutbetrag, zu kennen. Berechnen wir zum Beispiel den betragsm¨aßig gr¨oßten Eigenwert einer reellen quadratischen Matrix A der Dimension n. Wir bezeichnen diesen mit λ1 und ordnen die u ¨brigen Eigenwerte von A wie folgt an: |λ1 | > |λ2 | ≥ |λ3 | ≥ . . . ≥ |λn |.

(6.3)

Nehmen wir weiters an, λ1 sei verschieden von den u ¨brigen Eigenwerten von A. Bezeichnen wir weiters mit x1 den zu λ1 geh¨origen Eigenvektor (von Einheitsl¨ ange). Falls die Eigenvektoren von A linear unabh¨angig sind, k¨onnen λ1 und x1 mit folgendem Verfahren, Potenzverfahren genannt, berechnet werden: Sei ein beliebiger Startvektor x(0) gegeben und sei y(0) = x(0) / x(0) . F¨ ur k ≥ 1 berechne x(k) = Ay(k−1) , y(k) =

x(k) , λ(k) = (y(k) )T Ay(k) x(k)

(6.4)

Dabei ist y(k) = β (k) Ak y(0) , wobei k x(i) )−1 f¨ ur k ≥ 1. β (k) = (Πi=1

Das Auftreten von Potenzen von A rechtfertigt den Namen dieses Verfahrens. Wie wir im n¨achsten Abschnitt sehen werden, erzeugt dieses Verfahange, die f¨ ur k → ∞ ren eine Folge von Vektoren {y(k) } von Einheitsl¨ in Richtung des Eigenvektors x1 tendieren. Der Fehler y(k) − x1 ist proportional zum Verh¨altnis |λ2 /λ1 |, falls A eine beliebige Matrix ist, und proportional zu |λ2 /λ1 |2 , falls A symmetrisch ist. Schließlich kann man zeigen, daß λ(k) → λ1 f¨ ur k → ∞. Das Potenzverfahren ist im Programm 12 implementiert. Der iterative Algorithmus bricht bei der ersten Iteration k ab, f¨ ur die

6.1 Das Potenzverfahren

151

|λ(k) − λ(k−1) | < ε|λ(k) | ist, wobei ε eine festgelegte Toleranz ist. Die Eingabeparameter sind die Matrix A, der Startvektor x0, die Toleranz tol f¨ ur das Abbruchkriterium und die maximale Anzahl an erlaubten Iterationen nmax. Die Ausgabeparameter sind der Eigenwert lambda mit maximalem Absolutbetrag, der zugeh¨orige Eigenvektor und die Anzahl der durchgef¨ uhrten Iterationen. Programm 12 - eigpower : Potenzverfahren function [lambda,x,iter]=eigpower(A,tol,nmax,x0) %EIGPOWER Approximiert den betragsmaessig groessten % Eigenwert einer Matrix. % LAMBDA = EIGPOWER(A) berechnet mit dem Potenzverfahren % den Eigenwert einer Matrix A mit groesstem Absolutbetrag, % ausgehend von einem Startvektor, voreingestellt ist der Einheitsvektor. % LAMBDA = EIGPOWER(A,TOL,NMAX,X0) bricht das Verfahren ab, % sobald die Differenz zweier aufeinanderfolgender Iterierter % kleiner ist als TOL (voreingestellt ist 1.E-06), oder sobald % die maximal erlaubte Anzahl an Iterationen NMAX % (voreingestellt ist 100) erreicht wird. % [LAMBDA,V,ITER] = EIGPOWER(A,TOL,NMAX,X0) gibt auch den % normierten Eigenvektor V so, dass A*V=LAMBDA*V ist, und % die Anzahl der dazu benoetigten Iterationen zurueck. [n,m] = size(A); if n ˜= m, error(’Nur quadratische Matrizen zulaessig’); end if nargin == 1 tol = 1.e-06; x0 = ones(n,1); nmax = 100; end x0 = x0/norm(x0); pro = A*x0; lambda = x0’*pro; err = tol*abs(lambda) + 1; iter = 0 while err > tol*abs(lambda) & abs(lambda) ˜= 0 & iter