Zusatzaufgabe 1 für Informatiker

Werbung
Mathematisches Praktikum — Sommersemester 2016
Prof. Dr. Wolfgang Dahmen — Felix Gruber, Michael Rom
Zusatzaufgabe 1 für Informatiker
Bearbeitungszeit: zwei Wochen (bis Freitag, 13. Mai 2016)
Mathematischer Hintergrund: Eindimensionale adaptive Quadratur, Quadraturformeln
Elemente von C++: Rekursion, Einbinden einer Grafikbibliothek, Makefiles
Aufgabenstellung
Gegeben seien 𝑎, 𝑏 ∈ R, 𝑎 < 𝑏 und eine stetige Funktion 𝑓 : [𝑎, 𝑏] → R. Schreiben Sie ein Programm, welches
∫︀ 𝑏
das Integral 𝐼(𝑥) = 𝑎 𝑓 (𝑥) d𝑥 bis auf einen vorgegebenen Fehler 𝜀 > 0 berechnet. Verwenden Sie dafür eine
adaptive Unterteilung des Intervalls [𝑎, 𝑏] und vergleichen Sie den benötigten Aufwand mit dem Aufwand im
Falle einer äquidistanten Unterteilung von [𝑎, 𝑏].
Quadraturformeln
Da Integrale nur in den wenigsten Fällen analytisch geschlossen berechenbar sind, bemüht man numerische
Methoden zur Berechnung von Integralen (Quadratur ). Die resultierenden Näherungsformeln werden als
Quadraturformeln bezeichnet. Hierfür legt man 𝑁 Stützstellen 𝑥𝑖 ∈ [𝑎, 𝑏], 1 ≤ 𝑖 ≤ 𝑁 fest, an denen die
Funktion 𝑓 ausgewertet wird.
In Abbildung 1 sind die drei einfachsten Quadraturformeln Mittelpunktsregel, Trapezregel und Simpson-Regel
dargestellt. Diese drei Quadraturformeln sind allesamt sogenannte Newton-Cotes-Formeln, welche man erhält,
indem man die Funktion 𝑓 an den Stützstellen 𝑥𝑖 durch ein Polynom interpoliert und dieses anschließend
exakt integriert. [2]
y
y
y
f (x)
a
a+b
2
f (x)
b x
a
(a) Mittelpunktsregel
f (x)
b x
(b) Trapezregel
a
a+b
2
b x
(c) Simpson-Regel
Abbildung 1: Einfache Newton-Cotes-Quadraturformeln
Die entstehenden Newton-Cotes-Formeln kann man in allgemeiner Form als
∫︁
𝑏
𝑓 (𝑥) d𝑥 ≈ (𝑏 − 𝑎)
𝑎
𝑁
∑︁
𝛾𝑖 𝑓 (𝑥𝑖 )
𝑖=1
schreiben, wobei die 𝛾𝑖 ∈ R auch als Gewichte der Stützstellen bezeichnet werden. In Tabelle 1 stehen die
Stützstellen und Gewichte der ersten Newton-Cotes-Quadraturformeln auf dem Intervall [𝑎, 𝑏].
1
Quadraturformel
Mittelpunktsregel
Trapezregel
Simpson-Regel
Stützstellen 𝑥𝑖
𝑎+𝑏
2
𝑎, 𝑏
𝑎, 𝑎+𝑏
2 ,𝑏
Gewichte 𝛾𝑖
1
1 1
2, 2
1 4 1
6, 6, 6
Tabelle 1: Newton-Cotes-Quadraturformeln auf dem Intervall [𝑎, 𝑏]
Exaktheitsgrad und Ordnung
Man klassifiziert Quadraturformeln danach, bis zu welchem Grad sie Polynome exakt integrieren, d.h. bis zu
welchem 𝑚 ∈ N gilt
∫︁ 𝑏
𝑁
∑︁
𝑝(𝑥) d𝑥 = (𝑏 − 𝑎)
𝛾𝑖 𝑝(𝑥𝑖 ) für alle 𝑝 ∈ 𝑃𝑚 ,
𝑎
𝑖=1
wobei 𝑃𝑚 die Menge der Polynome vom Grad kleinergleich 𝑚 ∈ N bezeichne. Man sagt in diesem Fall auch,
die Quadraturformel ist exakt vom Grade 𝑚.
Die Mittelpunktsregel und die Trapezregel sind exakt vom Grade 1. Die Simpson-Regel ist sogar exakt vom
Grade 3. [2]
Ist eine Quadraturformel exakt vom Grade 𝑚 und ist 𝑓 eine (𝑚 + 1)-mal stetig differenzierbare Funktion, so
kann man die Funktion 𝑓 bei der Quadratur durch ihre Taylor-Entwicklung
𝑓 (𝑥) =
𝑚
∑︁
𝑓 (𝑘) (𝑥0 )
𝑘=0
𝑘!
(𝑥 − 𝑥0 )𝑘 + 𝒪((𝑥 − 𝑥0 )𝑚+1 ).
ersetzen. Die Quadraturformel integriert dann das Taylor-Polynom 𝑚-ten Grades exakt. Der Fehler bei der
Quadratur hängt dann von der Länge des Integrationsintervalls in (𝑚+1)-ter Potenz ab, ist also von Ordnung
𝑚 + 1.
Summierte Quadraturformeln
Zur Steigerung der Genauigkeit wendet man eine Quadraturformel meist nicht direkt auf das Intervall [𝑎, 𝑏] an,
sondern unterteilt [𝑎, 𝑏] zunächst in Teilintervalle und wendet die Quadraturformel dann auf die Teilintervalle
an. Auf diese Weise erhält man sogenannte summierte Quadraturformeln.
Unterteilt man das Intervall [𝑎, 𝑏] äquidistant in 𝑛 Teilintervalle der Länge ℎ := 𝑏−𝑎
𝑛 , so erhält man die
Stützstellen 𝜉𝑗 = 𝑎 + 𝑗ℎ für 0 ≤ 𝑗 ≤ 𝑛, d.h. 𝜉0 = 𝑎 und 𝜉𝑛 = 𝑏. Wendet man auf jedem Teilintervall [𝜉𝑗 , 𝜉𝑗+1 ]
die Trapezregel
𝐼𝑇 (𝑓, [𝜉𝑗 , 𝜉𝑗+1 ]) :=
ℎ
1
(𝜉𝑗+1 − 𝜉𝑗 ) [𝑓 (𝜉𝑗 ) + 𝑓 (𝜉𝑗+1 )] = [𝑓 (𝜉𝑗 ) + 𝑓 (𝜉𝑗+1 )]
2
2
an, so erhält man die summierte Trapezregel
𝑆𝑇,𝑛 (𝑓, [𝑎, 𝑏]) :=
𝑛
∑︁
𝐼𝑇 (𝑓, [𝑎 + 𝑗ℎ, 𝑎 + (𝑗 + 1)ℎ])
𝑗=0
=
𝑛 [︂
∑︁
ℎ
𝑗=0
]︂
𝑛−1
∑︁
ℎ
ℎ
ℎ
𝑓 (𝜉𝑗 ) + 𝑓 (𝜉𝑗+1 ) = 𝑓 (𝑎) + ℎ
𝑓 (𝑎 + 𝑗ℎ) + 𝑓 (𝑏).
2
2
2
2
𝑗=1
2
Adaptivität
In vielen Fällen ist es zum Erreichen der gewünschten Genauigkeit des Integrals nicht notwendig, das gesamte
Intervall in kleine Teilintervalle zu zerlegen. Verhält sich die Funktion 𝑓 z.B. auf einem großen Teilintervall
wie eine Gerade, so wird sie hier bereits durch die Mittelpunktsregel exakt integriert. In einem anderen
Abschnitt kann es jedoch nötig sein, das Intervall in viele Teilintervalle zu unterteilen.
Liegt eine Möglichkeit vor, den Fehler der aktuellen Näherung auf einem Teilintervall zu schätzen, so kann
man die weitere Unterteilung in Abhängigkeit dieser Fehlerschätzung steuern. Diese Fähigkeit eines Verfahrens, sich selbst an das gegebene Problem anzupassen, wird als Adaptivität bezeichnet.
Einschluss der Lösung bei konvexen oder konkaven Funktionen
Ist die gegebene Funktion 𝑓 auf dem Intervall [𝑎, 𝑏] differenzierbar und zudem konvex oder konkav, so schließen
die durch die Mittelpunktsregel und Trapezregel
numerisch bestimmten Näherungen des Integrals 𝐼𝑀 und
∫︀ 𝑏
𝐼𝑇 den Wert des exakten Integrals 𝐼 = 𝑎 𝑓 (𝑥) d𝑥 ein, d.h. es ist
min {𝐼𝑀 , 𝐼𝑇 } ≤ 𝐼 ≤ max {𝐼𝑀 , 𝐼𝑇 } .
(1)
Beweis: O.E. sei 𝑓 konkav auf dem Intervall [𝑎, 𝑏] (ansonsten ist 𝑓 konvex und somit −𝑓 konkav und man
betrachte −𝑓 , −𝐼𝑀 und −𝐼𝑇 ).
Für die Sekante ∫︀𝑠 von 𝑓 über∫︀ dem Intervall [𝑎, 𝑏] gilt aufgrund der Konkavität 𝑠(𝑥) ≤ 𝑓 (𝑥) für alle 𝑥 ∈ [𝑎, 𝑏].
Folglich ist 𝐼 = 𝑓 (𝑥) d𝑥 ≥ 𝑠(𝑥) d𝑥 = 𝐼𝑇 .
y
y
A
B
f (x)
f (x)
a
b x
a
(a) Trapezregel
a+b
2
b x
(b) Mittelpunktsregel
Abbildung 2: Einschluss der Lösung bei konkaver Funktion 𝑓
Es sei 𝑡 die Tangente an den Funktionsgraphen von 𝑓 im Punkt 𝑥 = 𝑎+𝑏
2 (siehe Abbildung 2(b)). Dann
entspricht die Fläche unter 𝑡 über dem Intervall [𝑎, 𝑏] der von der Mittelpunktsregel berechneten Fläche, da
die Dreiecke 𝐴 und 𝐵 in Abbildung ∫︀2(b) gleich groß
sind. Aufgrund der Konkavität kann 𝑓 jedoch nicht
∫︀
oberhalb von 𝑡 liegen und es gilt 𝐼 = 𝑓 (𝑥) d𝑥 ≤ 𝑡(𝑥) d𝑥 = 𝐼𝑀 .
Die Abschätzung (1) kann man bei konvexen oder konkaven Funktionen nutzen und |𝐼𝑀 − 𝐼𝑇 | als Schätzung
des Quadraturfehlers verwenden. In der Praxis fällt diese Schätzung allerdings eher pessimistisch aus.
Wurde die Funktion 𝑓 bereits an den Stützstellen der Mittelpunkts- und der Trapezregel ausgewertet, so
kann mithilfe der Simpson-Regel leicht die Approximation höheren Exaktheitsgrades bestimmt werden, da
die Stützstellen der Simpson-Regel gerade die Stützstellen der Mittelpunkts- und der Trapezregel sind.
3
Umsetzung im Programm
Für das Programm verfolgen wir folgende Strategie: Soll das Integral der Funktion 𝑓 im Intervall [𝑎, 𝑏] mit
einem absoluten Fehler von höchstens 𝜀 berechnet werden, so wenden wir zunächst die Mittelpunkts- und
die Trapezregel an und berechnen den Fehlerschätzer |𝐼𝑀 − 𝐼𝑇 |. Ist die gewünschte Genauigkeit erreicht, so
geben wir das mit der Simpson-Regel berechnete Ergebnis zurück.
Wurde die Genauigkeit 𝜀 verfehlt, so wird das Intervall in zwei Teilintervalle gleicher Länge zerlegt und das
Verfahren auf jedem Teilintervall wiederholt, wobei nun jeweils die Genauigkeit 2𝜀 verlangt wird.
Der Aufwand einer Quadratur wird oft über die Anzahl der Funktionsauswertungen gemessen. Da eine
Funktionsauswertung sehr aufwändig sein kann1 , sollten Sie vermeiden, die Funktion 𝑓 mehrmals an der
gleichen Stützstelle auszuwerten.
Um die Vorzüge der adaptiven Rechnung beobachten zu können, vergleichen Sie die Anzahl der benötigten
Funktionsauswertungen mit jener bei der summierten Trapezregel mit äquidistanter Schrittweite. Gehen Sie
bei der summierten Trapezregel von der minimalen Schrittweite, welche im adaptiven Algorithmus nötig ist,
aus.
Rekursive Programmierung
Benutzen Sie zur Implementierung Ihres Programms die Technik der rekursiven Programmierung. Diese soll
anhand des folgenden Beispiels erläutert werden.
Beispiel: Berechnung der Fakultät
Im Zusammenhang mit kombinatorischen Überlegungen benötigt man gelegentlich die Fakultät 𝑛! := Π𝑛𝑘=1 𝑘
einer natürlichen Zahl 𝑛 ∈ N. Diese lässt sich leicht über eine for-Schleife berechnen:
1
unsigned int f a k u l t a e t ( unsigned int n ) {
2
unsigned int f =1;
3
4
i f ( n>1)
5
f o r ( unsigned int i =2 ; i<=n ; ++i )
f *= i ;
6
7
8
return f ;
9
10
}
Andererseits gilt für die Fakultät aber auch die Beziehung (𝑛 + 1)! = 𝑛!(𝑛 + 1). Dies legt eine weitere
Möglichkeit der Umsetzung in ein Programm nahe:
1
unsigned int f a k u l t a e t ( unsigned int n ) {
2
i f ( n<=1) {
return 1 ;
} else {
return n* f a k u l t a e t ( n−1) ;
}
3
4
5
6
7
8
1
}
Ist der gesuchte Funktionswert beispielsweise der Auftrieb einer Flugzeugtragfläche in Abhängigkeit eines Parameters, so kann
zur Berechnung eine sehr komplexe Strömungssimulation notwendig sein.
4
Diese Programmiertechnik, bei der eine Funktion sich selbst rekursiv aufruft, heißt rekursive Programmierung. Die Rekursionstiefe gibt dabei an, wie oft sich die Funktion selbst aufgerufen hat. Bei rekursiver
Programmierung muss vom Programmierer sichergestellt werden, dass die Rekursionstiefe beschränkt bleibt,
d.h., dass die Funktion nach endlicher Anzahl von Selbstaufrufen endet, ohne sich selbst wieder aufzurufen.
Anderenfalls liegt eine unterminierte Rekursion vor, welche solange fortgesetzt wird, bis alle zur Verfügung
stehenden Ressourcen (z.B. Speicher) belegt sind.
Funktionsauswertungen und Zielgenauigkeit
Fragen Sie zu Beginn Ihres Programmes ab, welches Beispiel gerechnet werden soll. Fangen Sie mögliche
Fehler bei der Eingabe ab. Rufen Sie anschließend die Routine
void S t a r t ( int Bsp , double &a , double &b , double &e p s i l o n ,
bool G r a f i k=true , int Pause =300) ;
auf, welche Ihnen die Grenzen des Intervalls [𝑎, 𝑏] sowie die gewünschte Zielgenauigkeit des Ergebnisses
epsilon zurückgibt. Die optionale Grafikausgabe können Sie mit Grafik aktivieren. Der Parameter Pause
steuert die Ausgabegeschwindigkeit.
Die zu integrierende Funktion können Sie anschließend durch einen Aufruf der Funktion
double f ( double x ) ;
auswerten.
Geben Sie am Ende ihres Programmes das Resultat Ihrer numerischen Quadratur durch einen Aufruf von
bool E r g e b n i s ( double I ) ;
zurück. Es wird dann mit dem Wert des exakten Integrals verglichen und Ihr Ergebnis wird bewertet.
Verwendung von Makefiles
Programme, die aus mehreren Dateien bestehen, werden meist nicht „per Hand“ kompiliert. Stattdessen wird
üblicherweise der Befehl make verwendet. Die Ausführung dieses Befehls wird durch die Datei Makefile
(bzw. makefile) gesteuert. In ihr stehen sowohl die „Regeln“ (Befehlssequenzen), wie man beispielsweise
quadratur.o aus quadratur.cpp erhält, als auch die Abhängigkeiten der verschiedenen Dateien. Die Befehlssequenz zur Erzeugung einer bestimmten Datei wird immer dann ausgeführt, wenn wenigstens eine der
Dateien, von denen sie abhängt, jünger ist als sie selbst. Dies befreit den Programmierer von der Aufgabe,
sich über die Reihenfolge der Kompilierung Gedanken zu machen, und vermeidet überflüssiges Kompilieren
von Dateien, welche bereits auf dem neuesten Stand sind.
Das Makefile zur Erzeugung des Programms quadratur der vorliegenden Aufgabe könnte zum Beispiel wie
folgt aussehen (<Tab> steht für das Tab(ulator)-Zeichen):
1
2
CXXFLAGS = −O2 −Wall
LIBS
= −lGL −l p t h r e a d −lX11
3
4
5
quadratur : quadratur . o
<Tab> $ (CXX) −o q u a d r a t u r q u a d r a t u r . o u n i t . o IGL . o $ ( LIBS )
6
7
8
q u a d r a t u r . o : q u a d r a t u r . cpp
<Tab> $ (CXX) $ (CXXFLAGS) −c q u a d r a t u r . cpp
9
10
11
clean :
<Tab> rm −f q u a d r a t u r . o q u a d r a t u r
12
13
.PHONY: c l e a n
Erstellen Sie ein Makefile, welches Ihnen Ihr Programm erzeugt. [1]
5
Literatur
[1] Dokumentation zu GNU Make. http://www.gnu.org/software/make/.
[2] Dahmen, W. und A. Reusken: Numerische Mathematik für Ingenieure und Naturwissenschaftler. Springer Verlag, Heidelberg, 2. Auflage, 2008.
6
Herunterladen
Explore flashcards