Berechnung von Kurvenintegralen im Rahmen der ......Vorbemerkung. Unter dem Titel Berechnung von Kurvenintegralen im Rahmen der zweidimensionalen Randelementmethode legte ich am 28

Universitat Ulm

Fakultat fur Mathematik und

Wirtschaftswissenschaften

Berechnung von Kurvenintegralen

im Rahmen der zweidimensionalen

Randelementmethode

Weitere Ausfuhrungen zur Bachelorarbeit von

Jochen Gluck

Vorbemerkung. Unter dem Titel Berechnung von Kurvenintegralen im Rahmender zweidimensionalen Randelementmethode legte ich am 28. Mai 2011 meine Bache-lorarbeit im Fach Wirtschaftsmathematik vor, in der ich eine numerische Methodezur effizienten Berechnung von Kurvenintegralen uber rationalen Kurven vorstellte.Der hier unter demselben Titel vorliegende Text enthalt bis auf wenige Anderungenalle Ausfuhrungen und Matlab-Implementierungen aus meiner Bachelorarbeit. Demhabe ich im vorliegenden Text zahlreiche numerische Testbeispiele hinzugefugt, umdie eher theoretisch ausgerichteten Erortungen in meiner Bachelorarbeit anhandverschiedener Beispiele zu veranschaulichen und deren Anwendbarkeit in verschie-denen Siutationen numerisch zu testen. Der Großteil dieser Testbeispiele und de-ren Interpretation befindet in Kapitel 5; einige Tests wurden auch in Abschnitt6.2 hinzugefugt. Der Matlab-Quellcode zu den Testbeispielen wird in diesen beidenAbschnitten erlautert und findet sich der Vollstandigkeit halber auch nochmals inAnhang B.

Stand. Ulm, August 2011.

Inhaltsverzeichnis

1 Einleitung 1

2 Grundlegendes zur Randelement-Methode 32.1 Darstellung harmonischer Funktionen durch Oberflachenpotentiale 32.2 Die Randelementmethode zur Losung der Laplace-Gleichung 42.3 Auswahl eines Unterraumes 62.4 Die Randintegrale im Einzelnen 6

3 Schwierigkeiten und Spezialfalle bei der Berechnung des Einfach-

schichtpotentials 93.1 Schierigkeiten bei der Berechnung des Integrals 93.2 Losungsmoglichkeiten auf linearen Kurven 10

4 Das Einfachschichtpotential auf rationalen Kurven 134.1 Rationale Kurven und eine Darstellung in Matlab 134.2 Eine multiplikative Darstellung des Einfachschichtpotentials 154.3 Berechnung der singularen Integrale mit Hilfe einer Drei-Term-

Rekursion 184.4 Berechnung des Multiplikationsoperators 224.5 Berechnung des Einfachschichtpotentials 25

5 Numerische Tests zur Berechnung des Einfachschichtpotentials 295.1 Vorgehensweise und Erzeugung von Testbeispielen 295.2 Der Polynomgrad in der Funktion fCoefLog 365.3 Ein Ergebnisvergleich mit der Matlab-Funktion quad 415.4 Zur Konvergenzgeschwindigkeit der Funktion singLayPot 495.5 Theoretische und numerische Ergebnisse auf dem Einheitskreis 595.6 Lineare Approximation einer Halbellipse 66

6 Die Berechnung der Galerkinmatrix 696.1 Darstellung der Galerkinblocke mit Hilfe einer Fourierentwicklung 696.2 Numerische Testergebnisse 72

7 Schlusswort 79

A Verwendete Matlab-Funktionen 81A.1 Matlab-Funktionen zum Umgang mit Polynomen 81A.2 Matlab-Funktionen zum Umgang mit rationalen Kurven 89A.3 Matlab-Funktionen zur Integration in der Randelementmethode 107

B Testfunktionen und -skripte 123

Literaturverzeichnis 161

Kapitel 1

Einleitung

Bei der Simulation physikalischer Systeme spielt die Laplace-Gleichung eine wichtigeRolle. Ist ein Gebiet Ω ⊂ Rd und eine Funktion u0 : Γ := ∂Ω → R gegeben, sobeschreibt die Losung der Laplace-Gleichung

−4u = 0, u|∂Ω = u0

ein Potentialfeld in Ω zu vorgegebenen Randwerten u0. Im Dreidimensionalenkonnen wir uns u zum Beispiel als das Potential eines elektrostatischen Feldes vor-stellen, oder in der Ebene als stationar gewordene Temperaturverteilung einer anden Randern beheizten Platte.Wahrend fur sehr einfache Geometrien von Ω und eine einfache Wahl der Rand-funktion u0 analytische Losungen der Laplace-Gleichung bekannt sind, erfordernkomplizierte geometrische Konstellationen oder nicht triviale Vorgaben von u0 einenumerische Losung.Weil die Funktionswerte einer harmonischen Funktion in Ω bereits durch die Werteauf Γ festgelegt sind, lasst sich die Losung u der Laplace-Gleichung allein durchIntegration uber Γ berechnen. Wenn wir nur einen endlichdimensionalen Unterraumdes Losungsraums betrachten und den Rand stuckweise parametrisieren, kann dieLosung u durch ein lineares Gleichungssystem ausgedruckt werden, und die nu-merische Herausforderung besteht in der effizienten Integration uber die einzelnenRandstucke.Der numerische Aufwand hangt dabei stark vom betrachteten Unterraum und dergewahlten Approximation des Randes von Ω ab. Ein Losungsansatz besteht dar-in, den Rand durch lineare Flachen- bzw. Streckenstucke zu approximieren und alsFunktionenraum auf ∂Ω den Aufspann endlich vieler orthogonaler Polynome zu ver-wenden, die Funktionen also naherungsweise in eine abbrechende Fourierreihe zuentwickeln. In [1] und [2] und werden die Integrale uber die einzelnen Randstuckedann mit Hilfe einer Drei-Term-Rekursion berechnet, die aus der rekursiven Dar-stellung der Legendre-Polynome abgeleitet werden kann. So konnte eine stabile undeffiziente Integration uber die linearen Randstucke erreicht werden.Wunschenswert ist nun eine Erweiterung dieses Algorithmus, der auch die Inte-gration uber nichtlineare Randstucke ermoglicht. Wenn auch eine Integration uberpolynomial oder rational interpolierte Kurven moglich ist, erhalten wir eine hohereFlexibilitat bei der Modellierung gekrummter Randgeometrien; einerseits konnendann starke Krummungen beschrieben werden, ohne das Gitter auf dem Rand starkverfeinern zu mussen. Andereseits konnen viele Geometrien - wie beispielsweise El-lipsen - durch rationale Kurven sogar exakt beschrieben werden.Das Ziel dieser Arbeit ist es einen Algorithmus herzuleiten, der im zweidimensio-nalen Fall die beschriebene Verallgemeinerung auf rational parametrisierte Rand-kurven ermoglicht. Wir werden dabei auf die zuvor erwahnte Drei-Term-Rekursion

2 Kapitel 1: Einleitung

zuruckgreifen und sie mit einigen einfachen Konzepten aus der Operatorentheo-rie kombinieren, um die erhohte Komplexitat der auftretenden Integranden zubewaltigen.Der zweite Abschnitt dieser Arbeit gibt zunachst eine kurze Einfuhrung in dieRandelementmethode und stellt die auftretenden Integrale vor. Im dritten Kapi-tel erlautern wir typische Schwierigkeiten bei der numerischen Berechnung dieserIntegrale und gehen knapp auf eine Methode aus [2] ein, die in der Lage ist, dasEinfachschichtpotential auf linearen Randstucken zu berechnen. Im anschließendenvierten Kapitel erweitern wir diesen Algorithmus auch auf Kurven, die durch ratio-nale Funktionen parametrisiert werden konnen. Nach seiner Herleitung testen wirdiesen verallgemeinerten Algorithmus in Kapitel Funf anhand mehrerer Beispiele.Zuletzt beschaftigen wir uns in Kapitel Sechs kurz mit einer moglichen Berechnungder Galerkinmatrix.

Kapitel 2

Grundlegendes zur

Randelement-Methode

In diesem Abschnitt werden wir einen Uberblick uber die Randelementmethodegeben und die auftrenden Randintegrale naher beschreiben.

2.1 Darstellung harmonischer Funktionen durch

Oberflachenpotentiale

Im folgenden sei Ω ⊂ Rd ein einfach zusammenhangendes Gebiet mit dem RandΓ := ∂Ω. Weiter sei u0 : Γ→ R eine stetige Funktion. Wir suchen dann eine stetigeFunktion u : Ω → R, die im Inneren von Ω zweimal stetig differenzierbar undharmonisch ist und auf dem Rand mit u0 ubereinstimmt, das heißt wir suchen eineLosung des Dirichlet-Problems

−4u = 0, φ|Γ = u0. (2.1)

Unter verschiedenen Voraussetzungen sind fur das Dirichlet-Problem Existenz- undEindeutigkeits-Aussagen bekannt, auf die wir hier nicht naher eingehen wollen (vgl.z.B. [3], Kapitel 6).Zur Darstellung der Losung u konnen wir auf Oberflachenpotentiale zuruckgreifen.Der Anschauung halber erinnern wir zunachst an eine Anwendung aus der Phy-sik: Das elektrische Potential einer Punktladung an der Position x ∈ R3 ist (beientsprechender Normierung der Ladung) gegeben durch die Funktion

1

4π

1

|y − x|.

Sie wird als Fundamentallosung der Laplace-Gleichung bezeichnet und lasst sichleicht auf andere Dimensionen verallgemeinern. Ist die Dimension nicht festgelegt,schreiben wir ab sofort k(x, y) fur die Fundamentalosung, wobei x die singulareQuelle des Potentialfelds festlegt und y 6= x dann die Stelle beschreibt, an der dasPotentialfeld um x ausgewertet werden soll. Fur d = 2, 3 gilt die Formel

k(x, y) =

1

2πlog |x− y| d = 2,

14π

1|x−y| d = 3.

Vgl. hierzu [3], Seite 68. Man kann naturlich nicht nur Punktquellen, sondern auchLadungsdichten uber eine Oberflache im Rd betrachten, und das von dieser La-dungsdichte erzeugte Potentialfeld untersuchen. Wir definieren hierzu die folgenden

4 Kapitel 2: Grundlegendes zur Randelement-Methode

Integraloperatoren: Ist ϕ eine Funktion auf Γ, so sei

(V ϕ)(x) :=

∫Γ

ϕ(y)k(x, y) dsy.

Wenn ϕ zusatzlich stetig ist, definieren wir außerdem

(Kϕ)(x) :=

∫Γ

ϕ(y)d

dnk(x, y) dsy.

Dabei bezeichnet ddn

die Normalenableitung auf Γ, die ins Außere von Ω zeigt. DieFunktion V ϕ heißt Einfachschichtpotential von ϕ; im R3 konnen wir sie uns an-schaulich als Potentialfeld einer Monopolverteilung auf Γ mit Flachenladungsdichteϕ vorstellen. Die Funktion Kϕ heißt Doppelschichtpotential von ϕ; wir konnen sieals Potentialfeld einer Dipolverteilung auf Γ interpretieren (vgl. [3], Seite 78).Eine wichtige Konsequenz des Greenschen Satzes ist der Zusammenhang zwi-schen dem Potential im Inneren eines quellenfreien Gebietes und den beiden Ober-flachenpotentialen. Ist namlich u eine Losung des Dirichlet-Problems (2.1), so giltfur jedes x ∈ Ω die Identitat

u(x) = (V φ)(x)− (Ku0)(x), (2.2)

wobei φ := ddnu ist (vgl. zum Beispiel [1], Kapitel 2).

Die Potentiale (V φ)(x) und (Ku0)(x) sind auch dann wohldefiniert, wenn x sichauf dem Rand von Ω befindet. Wahrend allerdings das Einfachschichtpotential aufganz Ω stetig ist, springt das Doppelschichtpotential beim Ubergang von Ω auf Γ(vgl. [1], Kapitel 2). Die Identitat (2.2) gilt deshalb auf dem Rand von Ω in etwasabgewandelter Form:

u(x) = (V φ)(x)− ((K − 1

2)u0)(x) ∀x ∈ Γ.

Vgl. hierzu ebenfalls [1], Kapitel 2. Bedenkt man, dass wir auf Γ gerade u = u0

gefordert hatten, so erhalten wir daraus die auf Γ gultige Gleichheit

(K +1

2)u0 = V φ. (2.3)

Wir konnen diese Gleichung nutzen, um aus der festgelegten Randfunktion u0 dieNormalenableitung φ von u zu berechnen. Sind dann sowohl u0 als auch φ bekannt,ermoglicht die Darstellung (2.2) eine Berechnung von u im Inneren von Ω.Die Aufgabe bei der Losung der Laplace-Gleichung besteht also in der Losung derGleichung (2.3) und in der anschließenden Auswertung der Formel (2.2). Im folgen-den Abschnitt gehen wir darauf ein, wie dies bei der Randelementmethode realisiertwird.

2.2 Die Randelementmethode zur Losung der

Laplace-Gleichung

Der erste Schritt bei der Randelementmethode besteht darin, fur die Normalenablei-tung φ nur Funktionen aus einem festen, endlichdimensionalen Raum S zuzulassen.

Abschnitt 2.2: Die Randelementmethode zur Losung der Laplace-Gleichung 5

Sei N die Dimension von S. Im Allgemeinen wird φ naturlich nicht aus dem vorgege-benen Raum S stammen, aber bei geschickter Wahl und genugend großer Dimensionvon S lasst sich φ gut durch eine Funktion φN ∈ S approximieren. Die Wahl vonS hat naturlich Einfluss auf die Effizienz der Berechnung und die Prazision des Er-gebnisses, und wir gehen im nachfolgenden Abschnitt darauf ein, welche Raume sichfur S anbieten.Zunachst wollen wir jedoch annehmen, dass ein beliebieger Raum S vorgegeben undeine Basis ϕ1, ..., ϕN ∈ S fixiert ist. Wenn eine Approximation φN an φ in S liegt,dann konnen wir φN als Linearkombination

φN =N∑k=1

ckϕk

darstellen, und die Identitat (2.3) lasst sich dann (mit φN an der Stelle von φ)schreiben als

N∑j=1

cj V ϕk = (K +1

2)u0.

Unser Ziel φ zu bestimmen reduziert sich dann auf die Berechnung des Koeffizien-tenvektors c = (c1, ..., cN)T .Zur Losung dieser Gleichung wahlen wir den Galerkin-Ansatz, das heißt wir tes-ten die Identitat fur beliebige Koeffizientenvektoren c, in dem wir sie - gewichtetmit den Basisfunktionen ϕk - integrieren. Dadurch gelangen wir zu einem linearenGleichungssystem. Fur alle Indizes k, j = 1, ..., N muss dann namlich die Bedingung

N∑j=1

cj

∫Γ

ϕk(x)(V ϕj)(x)dΓx =

∫Γ

ϕk(x)((K +1

2)u0)(x)dΓx

gelten. Wir konnen die Gleichung auch in Matrixform als Ac = b schreiben, wobeidie Matrix A und der Vektor b die Eintrage

Akj =

∫Γ

ϕk(x)(V ϕj)(x)dΓx,

bk =

∫Γ

ϕk(x)((K +1

2)u0)(x)dΓx

besitzen. Die Matrix A wird als Galerkin-Matrix bezeichnet. Durch Losen des linea-ren Gleichungssystems erhalten wir jetzt den gesuchten Koeffizientenvektor c undkennen somit φN .Damit sind sowohl u0 als auch (naherungsweise) φ bekannt; um an einem beliebigenPunkt x ∈ Ω das Potential u(x) zu bestimmen, welches die Laplace-Gleichung lost,werden φN und u0 in die Formel (2.2) eingesetzt.Wir mussen in dieser Formel (V φN)(x) und (Ku0)(x) berechnen. Zur Bestimmungdes ersten Ausdruck stellen wir φN wieder als Linearkombination der ϕk mit Hilfeder nun bekannten Koeffizienten ck dar. Es ist

V φN =N∑j=1

cjV ϕj,


das heißt, es bleiben die Werte (V ϕj)(x) zu bestimmen. Auf die Berechnung desDoppelschichtpotentials (Ku0)(x) werden wir in dieser Arbeit nicht naher eingehen.Wir merken aber an, dass der Algorithmus, den wir zur Berechnung des Einfach-schichtpotentials und der Galerkin-Matrix herleiten werden, nicht ohne weiteres aufdas Doppelschichtpotential ubertragen werden kann.

2.3 Auswahl eines Unterraumes

Wir interessieren uns in dieser Arbeit, wie anfangs erwahnt, fur den zwei-dimensionalen Fall. Fur den Rest der Arbeit gelte Ω ⊂ R2.Wir gehen nun kurz darauf ein, welchen Raum S wir zur Approximation von φverwenden. Wichtig ist einerseits, dass φ in S genugend gut approximierbar ist;andererseits mussen das Einfachschichtpotential V und die Eintrage der Galerkin-Matrix A schnell und stabil berechnet werden konnen.Fur gewohnlich unterteilt man den Rand von Ω, auf dem die Funktion φ betrachtetwird, in mehrere Teilstucke Γ1, ...,Γm und wahlt auf jedem Randstuck Γj Basisfunk-tionen ϕj0, ..., ϕjn : Γ → R aus, die nur auf Γj leben. Als gesamten Unteraum Serhalt man dann den Aufspann der Basis ϕ10, ..., ϕmn.Die Unterteilung des Randes motiviert zugleich eine blockweise Darstellung derGalerkin-Matrix A. Fur jedes feste Paar k0, j0 ∈ 1, ...,m fassen wir dann namlichdie zugehorigen Eintrage∫

Γ

ϕk0k(x)(V ϕj0j)(x) dsx, k, j = 0, ..., n

der Galerkinmatrix zu einer Matrix Ak0j0 zusammen. Dann lasst sich die gesamteGalerkin-Matrix A blockweise schreiben als

A =

A11 · · · A1m

......

Am1 · · · Amm

.

Die Matrizen Ak0j0 bezeichnen wir als Galerkin-Blocke der Galerkin-Matrix A. AlsBasisfunktionen ϕkj bieten sich im R2 orthogonale Polynome auf den Parameterin-tervallen der einzelnen Randstucken an. Fur k = 1, ...,m sei γk : [−1, 1] → R2 eineparametrisierte Kurve, die das Randstuck Γk beschreibt. Wir bezeichnen mit Pj,j = 0, ..., n das j-te Legendre-Polynom auf [−1, 1] und setzen ϕkj = Pj γ−1

k . Manbeachte aber, dass der Ansatzraum S bei dieser Wahl der Basisvektoren im Allge-meinen von der Paramterisierung der Kurven γk abhangt. Wir werden im nachstenUnterabschnitt zeigen, welche Gestalt das Einfachschichtpotential V ϕkj und die Ein-trage der Galerkin-Blocke Ak0j0 annehmen, wenn wir die Basisfunktionen derartwahlen.

2.4 Die Randintegrale im Einzelnen

Wir setzen an dieser Stelle voraus, dass die Basisfunktionen ϕ10, ..., ϕmn so gewahltwurden, wie am Ende des vorangehenden Abschnitts beschrieben. Im folgenden

Abschnitt 2.4: Die Randintegrale im Einzelnen 7

betrachten wir beliebige, aber feste Indizes k0, j0 ∈ 1, ..,m, das heißt, wir fi-xieren zwei (eventuell identische) Randstucke Γk0 und Γj0 , und untersuchen diezugehorigen Eintrage von Ak0j0 und das Einfachschichtpotential der Basisfunktio-nen ϕj0j. Der einfacheren Schreibweise halber bezeichnen wir den Galerkin-Blocknur mit A := Ak0j0 , solange die Indizes k0 und j0 fixiert sind. Fur Polynomgradek, j ∈ 0, ..., n erhalten wir unmittelbar aus der Definition von V ϕj0j von A dieFormeln

(V ϕj0j)(x) =1

2π

1∫−1

Pj(t)|γj0(t)| log |x− γj0(t)| dt (2.4)

und

Akj =

1∫−1

Pk(s)|γk0(s)|(V ϕj0j)(γk0(s)) ds. (2.5)

Wenn j0 und x fest sind, fassen wir die Einfachschichtpotentiale (V ϕj0j)(x) der ein-facheren Schreibweise halber zu einem Vektor v ∈ `2 mit vj = (V ϕj0j)(x) zusammen.Das Ziel dieser Arbeit konnen wir nun anhand der obigen Formeln zusammenfassen:Wir mochten einen Algorithmus implementieren, der eine effiziente Berechnung derIntegrale in den Formeln (2.5) und (2.4) ermoglicht, falls γ1, ..., γm rationale Kurvensind.


Kapitel 3

Schwierigkeiten und Spezialfalle

bei der Berechnung des

Einfachschichtpotentials

In diesem Abschnitt werden wir auf Schwierigkeiten bei der Berechnung des Einfach-schichpotentials eingehen und aufzeigen, wie die Aufgabe auf linearen Kurvenstuckengelost werden kann. Der erste Unterabschnit fasst zusammen, welche Probleme beider Bestimmung des Einfachschichtpotentials auftreten. Der zweite Unterabschnittstellt eine Losungsmoglichkeit fur denjenigen Spezialfall vor, in dem die Kurve γj0linear ist.

3.1 Schierigkeiten bei der Berechnung des Inte-

grals

Fur das Einfachschichtpotential haben wir in Formel (2.4) die Darstellung

(V ϕj0j)(x) =1

2π

1∫−1

Pj(t)|γj0(t)| log |γj0(t)− x| dt.

gegeben. Eine analytische Losung dieses Integrals ist naturlich nur fur wenige Kurvenγ moglich. Aus diesem Grund sind wir an einer numerische Berechnung der Integraleinteressiert. Wenn der Punkt x weit von der Kurve γ entfernt liegt, bieten sichfolgende Moglichkeiten zur numerischen Berechnung an:

• Wenn j - das heißt der Polynomgrad des Basispolynoms Pj - niedrig und dieKurve γj0 hinreichend glatt ist, kann das Integral mit hoher Prazision durchQuadratur bestimmt werden. Wir gehen an dieser Stelle nicht naher auf dieGute von Quadratur-Algorithmen und deren Abhangigkeit von den Ableitun-gen des Integranden ein, sondern verweisen auf die umfangreiche Fachliteratur.

• Mochte man das Einfachschichtpotential fur einen hohen Polynomgrad j be-rechnen, so wird eine Quadratur sehr aufwendig, da die Legendre-PolynomePj fur große j stark schwanken und deshalb ein sehr feines Gitter fur dieQuadratur gewahlt werden muss. Stattdessen konnten wir versuchen, nur dieFunktion |γj0(t)| durch ein Taylor-Polynom Q(t) zu approximieren und furdas Produkt Pj(t)Q(t) log |γj0(t) − x| eine analytische Stammfunktion zu fin-den. Selbst wenn wir in der Lage sind, eine solche Stammfunktion herzuleiten,

10 Kapitel 3: Schwierigkeiten und Spezialfalle bei der Berechnung des Einfachschichtpotentials

bringt dieses Verfahren aber auch einige Nachteile mit sich: Erstens hangtdie Qualitat der Taylor-Approximation stark von der Kurve γ ab. Zweitenskann die Berechnung der Taylor-Koeffizienten hoherer Ordnung sehr aufwen-dig werden, wenn wir fur γ beispielsweise eine rationale Kurve zulassen. Drit-tens muss das Polynom Pj(t)Q(t) vor der Integration ausmultipliziert werden.Der Aufwand fur diese Faltung steigt bei kanonischer Berechnung linear mitdem Produkt grad(Pj) grad(Q).

Trotz dieser Nachteile bieten uns die genannten Verfahren fur Falle, in denen derPunkt x weit von der Kurve γj0 entfernt liegt und die Kurve γj0 gute Glattheitseigen-schaften aufweist, die prinzipielle Moglichkeit das Einfachschichtpotential stabil zuberechnen. Ungleich schwieriger wird die Aufgabe hingegen, wenn der Punkt x sehrnah bei der Kurve oder gar auf ihr liegt. Das Einfachschichtpoential existiert auchin diesem Fall als uneigentliches Integral. Bei der numerischen Berechnung stellt dieSingularitat des Integranden aber eine erhebliche Schwierigkeit dar, da eine stabileBerechnung per Quadratur fur singulare Integranden nur mit sehr hohem Aufwandmoglich ist. Diese Schwierigkeiten kann man zu umgehen versuchen, indem man denRand des Gebietes Ω in der Randelementmethode nur mit einfachen Kurven γj0 ap-proximiert, fur die eine einfachere Berechnung moglich ist. Beispielhaft werden wirim nachsten Unterabschnitt einen Methode aus [2] vorstellen, die eine Berechnungfur den Spezialfall linearer Kurven ermoglicht.

3.2 Losungsmoglichkeiten auf linearen Kurven

Das Einfachschichtpotential (2.4) ist leichter zu berechnen, wenn die Kurve γj0 linearist, das bedeutet, wenn es zwei Punkte y = (y1, y2)T , z = (z1, z2)T ∈ R2 gibt, so dass

γj0(t) = y + t(z − y), t ∈ [0, 1]

gilt. In diesem Fall verbindet die Kurve γj0 die Puntke y und z mit einem Stre-ckenstuck. Weil wir als Basisfunktion die Legendre-Polynome ausgewahlt haben, istes aber sinnvoll, als Parameterintervall das Intervall [−1, 1] anstelle von [0, 1] zubetrachten. Wir transformieren den Parameter t ∈ [0, 1] deshalb in einen Parametert = 2t− 1 ∈ [−1, 1] und erhalten somit die Kurve

γj0(t) = y +t+ 1

2(z − y) =

1

2(z + y) + t

1

2(z − y), t ∈ [−1, 1].

In diesem Fall hangt die Kurvenableitung γj0 = 12(z − y) nicht von t ab. Aus der

Formel (2.4) erhalten wir deshalb die folgende Darstellung fur das Einfachschicht-potential:

(V ϕj0j)(x) =1

4π|z − y|

1∫−1

Pj(t)1

2log |t1

2(z − y) +

1

2(z + y)− x|2 dt.

Die Funktion |t12(z − y) + 1

2(z + y) − x|2 ist ein Polynom zweiten Grades in t und

deshalb gibt es reelle Zahlen a, b, c, so dass

(V ϕj0j)(x) =1

4π|z − y|

1∫−1

Pj(t)1

2log(at2 + bt + c) dt,

Abschnitt 3.2: Losungsmoglichkeiten auf linearen Kurven 11

gilt. Wir verzichten an dieser Stelle auf eine explizite Angabe der Koeffizienten a, bund c, da sie sich leicht aus den beiden vorangehenden Formeln bestimmen lassen.Wenn λ1, λ2 ∈ C die Nullstellen von at2 + bt+ c sind, dann erhalten wir also zuletztdie Darstellung

(V ϕj0j)(x) =1

4π|z − y|

( 1∫−1

Pj(t) log(a) dt+

1∫−1

Pj(t) log(t− λ1) dt

+

1∫−1

Pj(t) log(t− λ2) dt

). (3.1)

Fur die Polynomgrade j = 0, 1 lassen sich diese Integrale analytisch losen. DurchAbleiten verifiziert man leicht, dass∫

log(t− λ) dt = (t− λ) log(t− λ)− t,∫t log(t− λ) dt =

1

2(t2 − λ2) log(t− λ)− 1

4(t− λ)2

fur λ ∈ C gilt. Wir konnen also das Einfachschichtpotential (V ϕj0j)(x) fur die Po-lynomgrade j = 0, j = 1 analytisch ausrechnen, in dem wir diese Stammfunktionenin die Formel (3.1) einsetzen. Auch fur hohere Polynomgrade lassen sich analyti-sche Darstellungen der Integrale finden. Mochte man (V ϕj0j)(x) fur j = 0, ...., n mitgroßem n bestimmen, so ist dieses Vorgehen aber etwas umstandlich. Einerseits neh-men die Stammfunktionen von tn log(t− λ) mit großem n stark an Komplexitat zu.Andererseits nutzen wir bei dieser Vorgehensweise die speziellen Eigenschaften derLegendre-Polynome nicht aus. Wir erinnern daran, dass fur die Legendre-Polynomeeine Drei-Term-Rekursion der Form

Pj+1(t) = αj+1Pj(t) + βj+1Pj−1(t), (j ∈ N) (3.2)

gilt. Ublicherweise normiert man die Legendre-Polynome derart, dass die Startpo-lynome durch P0 = 1, P1 = 1 und die Rekursionkoeffizienten durch

αj+1 =2j + 1

j + 1, βj+1 =

−jj + 1

, (j ∈ N)

gegeben sind. Mit Hilfe der Rekursionsgleichung (3.2) und der oben angege-benen Stammfunktionen lasst sich eine Drei-Term-Rekursion fur die Integrale∫ 1

−1Pj(t) log(t − λ) dt uber den Polynomgrad j herleiten; eine analytische Be-

rechnung des Integrals ist dann nur fur den Polynomgrad 0 und 1 notwendig unddie Stammfunktionen von Pj(t) log(t − λ) fur j = 0, 1 haben wir bereits gesehen.Fur eine Darstellung und Herleitung dieser Rekursion sei der Leser auf [2] verwie-sen. Bei der Implementierung von Drei-Term-Rekursionen muss beachtet werden,dass eine Vorwarts-Berechnung in vielen Fallen nicht numerisch stabil ist. Durchdie Verwendung einer geeigneten Ruckwartsrekursion gelingt es aber, die Werte∫ 1

−1Pj(t) log(t− λt) dt effizient und stabil zu berechnen. Auch hierfur verweisen wir

auf [2].Es steht somit auch fur hohe Basispolynomgrade j ein effizienter und stabiler Al-gorithmus zur Berechnung der Einfachschichtpotentiale auf linearen Kurven γj0 zurVerfugung. Das Ziel des nachsten Kapitels ist es, diesen Algorithmus auf rationaleKurven zu verallgemeinern.

12 Kapitel 3: Schwierigkeiten und Spezialfalle bei der Berechnung des Einfachschichtpotentials

Kapitel 4

Das Einfachschichtpotential auf

rationalen Kurven

In diesem Kapitel werden wir ein numerisches Verfahren zur Berechnung des Ein-fachschichtpotentials fur beliebige rationale Kurven herleiten. In Abschnitt 3.1 ha-ben wir bereits deutlich gemacht, welche Probleme einer Quadratur oder einer Tay-lorentwicklung im Wege stehen: Wenn der Punkt x, an dem das Einfachschicht-potential (V ϕj0j)(x) berechnet werden soll, sehr nahe bei der Kurve γj0 liegt, isteine Quadratur wegen der Singularitat des Integranden nicht sinnvoll. Gegen eineTaylor-Entwicklung spricht zum Beispiel die komplizierte Berechnung der Taylor-Koeffizienten von |γj0|, wenn die Kurve γj0 eine beliebige rationale Funktion seinkann. Wir wahlen stattdessen einen anderen Ansatz zur Berchnung der Integrale,bei dem wir die Orthognalitatseigenschaften der Legendre-Polynome Pj ausnutzenund sie als Basispolynome einer Fourierentwicklung verwenden. Diesen Ansatz wer-den wir in diesem Kapitel ab dem zweiten Unterabschnitts verfolgen. Wir werdeneine Implementierung in Matlab vorstellen und im anschließenden funften Kapitelmehrere numerische Tests durchfuhren.Zunachst aber gehen wir im folgenden Unterabschnitt knapp auf den Begriff der ra-tionalen Kurve ein und stellen eine Datenstruktur vor, mit der wir rationale Kurvenin Matlab abbilden konnen.

4.1 Rationale Kurven und eine Darstellung in

Matlab

Unter einer rationalen Kurve im R2 versteht man im Allgemeinen eine Abbildung

γ : [a, b]→ R2, t 7→(γ1(t)γ2(t)

),

wobei die beiden Komponenten γ1 und γ2 rationale Funktionen sind, die auf [a, b]keine Singularitat besitzen. Im Rahmen dieser Arbeit verwenden wir als Parameter-intervall [a, b] außschließlich das Intervall [−1, 1], da die Legendre-Polynome Pj, diewir als Basis unseres Ansatzraumes gewahlt haben, auf diesem Intervall definiertsind.Ein Spezialfall von rationalen Kurven sind polynomiale Kurven, bei denen dieKomponenten-Funktionen γ1 und γ2 Polynome sind (das bedeutet der Nenner derrationalen Funktionen ist in diesem Fall ein konstantes Polynom). Ein Beispiel furpolynomiale Kurven haben wir bereits in Abschnitt 3.2 gesehen: Lineare Kurvenverbinden zwei Punkte durch ein Streckenstuck miteinander. Ein rationale Kurve

14 Kapitel 4: Das Einfachschichtpotential auf rationalen Kurven

mit nicht-trivialem Nenner ist zum Beispiel die Kurve

γ : [−1, 1]→ R2, t 7→(

1−t2t2+1

2tt2+1

),

die die rechte Halfte des Einheitskreises beschreibt. Weil wir das Parameterintervallfest als [−1, 1] wahlen, ist jede Kurve eindeutig durch die Polynome im Zahler undNenner von γ1 und γ2 bestimmt. Wollen wir eine rationale Kurve in Matlab darstel-len, mussen wir uns also auf eine Darstellung von Polynomen einigen und dann jevier Polynome zu einer Kurve zusammenfassen.In Matlab werden wir ein Polynom durch einen Zeilenvektor darstellen, der dieKoeffizienten des Polynoms enthalt. Es steht dann der Vektor

(a1, . . . , an+1)

fur das Polynom

a1tn + . . .+ ant+ an+1

Diese Anordnung der Koeffizienten wird auch von nativen Matlab-Funktionen ver-wendet, die Polynome als Eingabe erwarten. Um nicht nur einzelne Polynome, son-dern auch mehrere Polynome zugleich betrachten zu konnen, werden wir mehreresolcher Koeffizienten-Zeilen zu einer Matrix zusammenfassen. Es steht dann bei-spielsweise die Matrix 1 −1 0 2

0 3 −1 02 0 4 −1

fur den Spaltenvektor, der die Polynome t3 − t2 + 2

3t2 − t2t3 + 4t− 1

enthalt. Weitere Erlauterungen zur Darstellung von Polynomen finden sich in An-hang A.1. Dort konnen auch alle Matlab-Funktionen nachgeschlagen werden, die wirzum Umgang mit Polynomen implementiert haben.

Nachdem wir eine Darstellung fur Polynome in Matlab festgelegt haben, mussenwir klaren, wie wir eine rationale Kurve in Matlab abbilden wollen. Fur die Darstel-lung einer rationalen Kurve γ = (γ1, γ2)T fassen wir die Koeffizientenvektoren derZahler- und Nenner-Polynome von γ1 und γ2 in einem 2-by-2-Cell-Array gamma sozusammen, dass gilt

gamma =

(Zaehler(γ1) Zaehler(γ2)Nenner(γ1) Nenner(γ2)

).

Wir haben oben das Beispiel einer rationalen Kurve γ = (1−t2t2+1

, 2tt2+1

)T gegeben, diedie rechte Halfte des Einheitskreises parametrisiert. Die Matlab-Darstellung fur dieseKurven hat also die Form

gamma =

([−1, 0, 1] [2, 0])[1, 0, 1] [1, 0, 1]

).

Abschnitt 4.2: Eine multiplikative Darstellung des Einfachschichtpotentials 15

Fur weitere Beispiele zur Darstellung rationaler Kurven in Matlab verweisen wirauf Anhang A.2. Zuletzt mussen wir noch festlegen, wie wir mehrere Kurven ge-meinsam in einer Datenstruktur verwalten wollen. Zum Beispiel konnen wir einenEinheitkreis in seine linke und seine rechte Halfte unterteilen und die beiden Halftendurch Kurven γR und γL beschreiben. Hierbei gilt

γR : [−1, 1]→ R2, t 7→(

1−t2t2+1

2tt2+1

), gammaR =

([−1, 0, 1] [2, 0])[1, 0, 1] [1, 0, 1]

)und

γL : [−1, 1]→ R2, t 7→(t2−1t2+1−2tt2+1

), gammaL =

([1, 0, −1] [−2, 0])[1, 0, 1] [1, 0, 1]

).

Um die Kurven γR und γL in Matlab gemeinsam verwalten zu konnen, legen wir sienebeneinander in einem 2-by-1-Cell-Array ab, beispielweise mit dem Namen curves.Es ist dann

curves = gammaL; gammaR;

Genauso konnen wir naturlich großere Anzahlen von Kurven in einem n-by-1-Cell-Array nebeneinander ablegen. Fur zusatzliche Beispiele zur Darstellung rationalerKurven in Matlab verweisen wir auf Anhang A.2. Dort sind auch alle Funktionenaufgelistet, die wir zum Umgang mit rationalen Kurven implementiert haben.

4.2 Eine multiplikative Darstellung des Einfach-

schichtpotentials

Nachdem im vorangehenden Unterabschnitt geklart wurde, wie wir rationale Kurvenin Matlab abbilden konnen, beginnen wir nun mit der Herleitung eines Algorithmus,um das Einfachschichtpotential V ϕj0j(x) an einem Punkt x ∈ R2 uber einer ratio-nalen Kurve γj0 zu berechnen. Wir setzen also ab sofort voraus, dass γj0 rationalparametrisiert ist. Zunachst erinnern wir nochmals an die Darstellung des Einfach-schichtpotentials aus Formel (2.4). Es gilt

(V ϕj0j)(x) =1

2π

1∫−1

Pj(t)|γj0(t)| log |x− γj0(t)| dt.

Die Schwierigkeiten bei der Berechnung dieses Integrals haben wir schon mehrfachangesprochen. Wir werden im folgenden eine Darstellung dieser Integrale angeben,in dem wir sie auf die einfachere Integrale der Form

wj :=1

2π

1∫−1

Pj(t) log |γj0(t)− x| dt, j ∈ N0 (4.1)

zuruckfuhren. Der kurzeren Schreibweise halber fassen wir die Werte wj zu einemVektor w := (wj)j∈N0 ∈ `2 zusammen. Ebenso wollen wir die Einfachschichtpoten-tiale (V ϕj0j)(x) zu einem Vektor v := ((V ϕj0j)(x))j∈N0 ∈ `2 zusammenfassen. In


Unterabschnitt 4.3 werden wir sehen, dass wir die Werte wj mit Hilfe der Drei-Term-Rekursion aus [2] berechnen konnen. Aus diesem Grund mochten wir denVektor v = ((V ϕj0j)(x))j∈N0 , durch den Vektor w = (wj)j∈N0 ausdrucken.Hierzu ist es im folgenden nutzlich fur die Legendre-Polynome Pj eine andere Nor-mierung als in Abschnitt 3.2 zu wahlen: Wir wollen im folgenden voraussetzen, dassalle Legendre-Polynome Pj so normiert sind, dass

1∫−1

P 2j (t) dt = 1

gilt. Nachwievor erfullen die Legendre-Polynome naturlich eine Drei-Term-Rekursionder Form

Pj+1(t) = αj+1Pj(t) + βj+1Pj−1(t), (j ∈ N). (4.2)

Die Startpolynome sind dann P0(t) =√

12, P1(t) =

√32

und die Rekursionkoeffizi-

enten sind nun gegeben durch

αj+1 =

√4(j + 1)2 − 1

j + 1, βj+1 =

−jj + 1

√2j + 3

2j − 1, (j ∈ N).

Setzen wir formal α1 =√

3, β1 = 0 und P−1 = 0, so gilt die Rekursion (4.2) sogarfur den Fall j = 0.Wir bezeichnen mit L2 den Raum der komplexwertigen, quadratisch integrierba-ren Funktionen auf [−1, 1]. Die Legendre-Polynome (Pj)j∈N0 sind eine Orthogonal-Basis von L2 und die nun gewahlte Normierung hat zur Folge, dass sie sogar eineOrthonormal-Basis bilden. Deshalb konnen wir die Werte

vj = (V ϕj0j)(x) =1

2π

1∫−1

Pj(t)|γj0(t)| log |x− γj0(t)| dt,

wj =1

2π

1∫−1

Pj(t) log |γj0(t)− x| dt, j ∈ N0

als Fourierkoeffizienten der Funktionen |γj0(t)| log |x− γj0(t)| ∈ L2 und log |γj0(t)−x| ∈ L2 auffassen. Wir wollen einen Weg finden, die Einfachschichtpotentiale, dieim Vektor v gegeben sind, durch den Vektor w auszudrucken. Die Einfachschicht-potentiale unterscheiden sich von den Integralen wj durch den zusatzlichen Faktor|γj0 | unter dem Integral. Der nachfolgende, fur allgemeinere Funktionen fomulierteSatz zeigt uns, wie wir diesen Faktor auch nach der Berechnung der Integrale wjberucksichtigen konnen.

Satz 4.2.1. Sei g : [−1, 1] → C quadratisch integrierbar und sei f : [−1, 1] → Cmessbar und bechrankt. Wir bezeichnen mit g ∈ `2 die Folge der Fourierkoeffizi-

enten von von g, also die Folge (∫ 1

−1Pj(t)g(t) dt)j∈N0 und mit (fg) die Folge der

Fourierkoeffizienten von fg, also die Folge (∫ 1

−1Pj(t)f(t)g(t) dt)j∈N0.

Abschnitt 4.2: Eine multiplikative Darstellung des Einfachschichtpotentials 17

Dann gibt es eine stetige, lineare Abbildung Tf : `2 → `2, so dass

Tf g = (fg)

gilt. Die unendliche Matrixdarstellung von Tf besitzt die Eintrage

(Tf )kj =

1∫−1

Pk(t)Pj(t)f(t) dt.

Beweis. Sei f : [−1, 1] → C messbar und beschrankt. Um die Existenz von Tf

nachzuweisen, betrachten wir die lineare Abbildung U : L2 → `2, die jeder Funktion

g ∈ L2 die Folge ihrer Fourierkoeffizienten g ∈ `2 zuordnet. Die Abbildung U ist

eine isometrischer Hilbertraum-Isomorphismus. Nun definieren wir eine Abbildung

Tf : L2 → L2, g 7→ fg.

Aus der Beschranktheit von f folgt, dass Tf tatsachlich nach L2 abbildet und zudem

stetig ist. Offensichtlich ist Tf außerdem linear. Wir setzen Tf := UTfU−1. Somit

ist Tf : `2 → `2 ebenfalls stetig und linear und es gilt

Tf g = UTfU−1Ug = UTfg = U(fg) = (fg).

Weil die Abbildung Tf : `2 → `2 linear und stetig ist, konnen wir sie als Matrix mit

unendlich vielen Zeilen und Spalten darstellen. Wir bezeichnen mit (·|·) sowohl das

Skalarprodukt auf L2, als auch dasjenige auf `2; sind nun j, k ∈ N0, so gilt fur den

Eintrag in der k-ten Zeile und j-ten Spalte von Tf :

(Tf )kj = (Tfek|ej) = (TfUU−1ek|ej)

= (U−1TfUU−1ek|U−1ej) = (TfPk|Pj),

wobei die Gleichheit zwischen erster und zweiter Zeile gilt, weil U−1 ein iso-

metrischer Hilbertraum-Isomorphismus ist. Somit haben wir auch (Tf )kj =∫ 1

−1Pk(t)Pj(t)f(t) dt gezeigt.

Wenn wir diesen Satz auf den Fall g = log |γk0(t)−x| und f = |γj0 | anwenden, dannfolgt

T|γj0 |w = v. (4.3)

Wenn wir also den Vektor w und die Operatormatrix T|γj0 | berechnen konnen, sindwir auch in der Lage die gesuchten Einfachschichtpotentiale v zu berechnen. EineBerechnungsmoglichkeit fur w stellen wir im nachsten Unterabschnitt 4.3 vor. Aufdie Berechnung von T|γj0 | gehen wir im darauffolgenden Abschnitt 4.4 ein.


4.3 Berechnung der singularen Integrale mit Hilfe

einer Drei-Term-Rekursion

Wie bereits erwahnt, konnen wir die Drei-Term-Rekursion aus [2] zur Berechnungder Integrale (4.1) verwenden. Die in in [2] implementierte Matlab-Funktion qtm1ist in der Lage, Integrale der Form

1∫−1

Pj(t) log(t− λ) dt

fur eine beliebige komlexe Zahl λ zu berechnen. Wir interessieren uns fur Integraleder Form

wj :=1

2π

1∫−1

Pj(t) log |γj0(t)− x| dt,

weil wir diese Integrale fur die Berechnung des Einfachschichtpotentials verwendenkonnen. In unserem Fall ist γj0 eine rationale Kurve und somit ist die Funktion|γj0(t) − x|2 eine rationale Funktion. Darum konnen wir Zahler und Nenner dieserFunktion in komplexe Linearfaktoren zerlegen, so dass gilt

|γj0(t)− x|2 =µ∏d

i=1(t− λi)µ∏d

i=1(t− λi).

Setzen wir diese Darstellung in die Definition von wj (4.1) ein, dann folgt

wj =1

2π

1∫−1

1

2Pj(t) log |γj0(t)− x|2 dt =

=1

4π

( 1∫−1

Pj(t) log(µ

µ) dt+

d∑i=1

1∫−1

Pj(t) log(t− λi) dt

−d∑i=1

1∫−1

Pj(t) log(t− λi) dt)

.

Die Matlab-Funktion fCoefLog in Listing 4.3.1 ist eine unmittelbare Implementie-rung dieser Formel. Sie berechnet die Zahlen w0, ..., wn bis zu einem frei wahlbarenIndex n und fur beliebige Punkte x ∈ R2.

Listing 4.3.1: MatlabMatlabMatlab-Funktion fCoefLog.m

1 function coef = fCoefLog(gamma , x, n)

2 % FCOEFLOG Compute fourier coefficients for the

Abschnitt 4.3: Berechnung der singularen Integrale mit Hilfe einer Drei-Term-Rekursion 19

3 % logarithm of a distance function.

4 % Computes the fourier coefficients of the function

5 % log(norm(gamma(t) - x)) / (2*pi), where gamma(t) is

6 % a rational curve and x a two dimensional point. The

7 % function makes use of a three term recurrence that

8 % is implemented by the function QTM1NEW.

9 %

10 % Usage: coef = fCoefLog(gamma , x, n)

11 %

12 % Inputs:

13 % gamma - 2-by -2 cell array that represents a

14 % rational curve. See the function

15 % CREATECURVE for explanation.

16 % x - m-by -2 matrix containing a two dimensional

17 % vector in each row. For each of these

18 % points the fourier coefficients of

19 % log(norm(gamma(t) - x)) / (2*pi) will be

20 % computed.

21 % n - An integer that defines the length of the

22 % computed fourier expansion. The output

23 % fourier coefficients will be computed

24 % for the Legendre -Polynomials P_0 , ...,

25 % P_n.

26 %

27 % Outputs:

28 % coef - m-by -(n+1) matrix; each row coef(k, :)

29 % contains the fourier coefficients that

30 % belong to the point x(k).

31 %

32 % Example:

33 % ellipse = createEllipse (2, 1, 1);

34 % x = [1,3; 1,1; 1,0];

35 % coef = fCoefLog(ellipse 2, x, 100);

36

37 [nom , den] = distCurve(gamma , x);

38 m = size(nom , 1);

39

40 fac = lCoef(den);

41 den = den / fac;

42 nom = nom / fac;

43

44 nom = adjustLCoef(nom , 10^ -12);

45


46 fac = lCoef(nom);

47 r = polyroots(nom);

48

49 coef = zeros(m, n+1);

50 d = size(r, 2);

51 for k=1:2:d

52 coef = coef + 2 * real(qtm1New(r(:, k), n));

53 end

54

55 r = polyroots(den);

56 d = size(r, 2);

57 for k=1:2:d

58 val = real(qtm1New(r(k), n));

59 for l=1:m

60 coef(l, :) = coef(l, :) - 2 * val;

61 end

62 end

63

64 for k=1:n+1

65 coef(:, k) = coef(:, k) * sqrt ((2*k - 1) / 2);

66 end

67

68 coef(:, 1) = coef(:, 1) + log(fac) * sqrt (2);

69 coef = coef / 2;

70 coef = coef / (2*pi);

Zeile 37: Die Funktion distCurve berechnet zur Kurve gamma und denVektoren in x die Zahler- und Nenner-Koeffizienten der rationa-len Funktion |γ(t) − x|2 und speichert sie in nom und den. DieMatrix nom enthalt fur jeden Vektor in x eine Zeile, die den je-weiligen Zahler dieser Funktion beschreibt. Hingegen besteht dennur aus einer Zeile, die den Nenner der Funktion beschreibt, denndieser hangt nur von gamma, nicht aber von x ab. Die FunktiondistCurve ist im Anhang A.2 in Listing A.2.9 aufgefuhrt.

Zeile 40-42: Der Nenner der rationalen Funktionen wird normiert, in-dem Zahler und Nenner der rationalen Funktionen durch denfuhrenden Koeffizienten des Nenners geteilt werden. Zur Berech-nung des fuhrenden Koeffizienten wird die Funktion lCoef ver-wendet, die in Listing ?? in Anhang A.1 aufgefuhrt ist.

Abschnitt 4.3: Berechnung der singularen Integrale mit Hilfe einer Drei-Term-Rekursion 21

Zeile 44: Die Funktion adjustLCoef eliminiert fur jedes Polynom in nomfuhrende Koeffizienten, deren Betrag nahe bei Null liegt. Andern-falls entstehen numerische Instabilitaten, wenn der Grad der Po-lynome in nom fur ein singulares x kleiner ist als in dessen Um-gebung. Die ist zum Beispiel der Fall, wenn die Kurve gammadie linke Halfte des Einheitskreises rational interpoliert und derPunkt x uber die rechte Halfte des Einheitkreises lauft. Dann istder Zahlerpolynomgrad stets gleich 8 und fallt nur fur x = (1, 0)T

auf 6. Fur eine genauere Beschreibung dieses Effekts, siehe denAbschnitt 5.2. Die Funktion adjustLCoef ist im Anhang A.1 inListing A.1.6 aufgefuhrt.

Zeile 46: Die Funktion lCoef gibt fur jede Zeile von nom den fuhrendenKoeffizienten des Polynoms in dieser Zeile zuruck. Sie ist im An-hang A.1 in Listing A.1.5 aufgefuhrt.

Zeile 47: Die Funktion polyroots berechnet fur jedes dieser Polynomedie komplexen Nullstellen und speichert sie zeilenweise in r.Konjugiert-komplexe Nullstellen eines Polynoms werden unmit-telbar hintereinander gespeichert. Hat ein Polynom in nom nied-rigeren Grad, als die anderen Polynome in nom, so werden die ver-bleibenden Eintrage in r fur dieses Polynom mit Inf aufgefullt.Die Funktion polyroots ist im Anhang A.1 in Listing A.1.4 auf-gefuhrt.

Zeile 51-53: Die Funktion qtm1New ruft die Drei-Term-Rekursion aus [2] furdie einzelnen Nullstellen auf und berechnet fur jede Nullstelle λdie Fourierkoeffizienten

∫ 1

−1Pj(t) log(t−λ)dt, j = 0, ..., n. So wur-

de geringfugig verandert, um fur die Eingabe λ =∞ den Wert 0zuruckzugeben. Die Funktion qtm1New ist in Anhang A.3 in Lis-ting A.3.3 aufgefuhrt. Die Ausgaben der Funktion qtm1New wer-den uber die einzelnen Nullstellen aufaddiert, um das Integral furden gesamten Zahler zu berechnen. Weil sich die Imagniarteile derIntegrale zu konjugiert komplexen Nullstellen aufheben, genugendes, die Funktion nur an jeder zweiten Nullstelle auszuwerten undden doppelten Realteil des Ergebnisses zu verwenden.

Zeile 55-62: Hier wird dieselbe Vorgehensweise fur den Nenner von |γ(t)− x|2wiederholt. Man beachte hierbei, dass der Nenner nicht von xabhangt.

Zeile 64-66: Die Funktion qtm1New berechnet die Drei-Term-Rekursion furnicht-normierte Legendre-Polynome; deswegen werden die Ergeb-nisse noch durch die L2-Norm der entsprechenden Polynome ge-teilt.

Zeile 68: Jetzt wird noch der Vorfaktor von Zahler und Nenner, den wirbisher bei der Integration mit qtm1New ignoriert hatten, hinzu-gezahlt. Man beachte, dass wir ihn jeweils nur zum ersten Fourier-koeffizienten addieren; fur alle Legendre-Polynome Pj mit Grad

j ≥ 1 verschwindet namlich das Integral∫ 1

−1Pj(t)dt.

Zeile 69: Wir hatten bisher die Funktion |γ(t) − x|2 unter dem Logarith-mus verwendet; um das Quadrat zu eliminieren mussen wir unserErgebnis also noch mit 1

2multiplizieren.


Wir sind jetzt also in der Lage, die ersten n Eintrage des Vektors w zu berechnen.Damit wir die Formel v = Tfw, die wir in Satz 4.2.1 gezeigt hatten, zur Berechnung

von v anwenden konnen, mussen wir noch eine Moglichkeit finden um die Matrix Tfzur berechnen. Damit befassen wir uns im folgenden Abschnitt.

4.4 Berechnung des Multiplikationsoperators

Als zweiten Schritt fur die Berechnung der Einfachschichtpotentiale 4.2 mussen wirdie Operatormatrix Tf aus Satz 4.2.1 fur f = |γj0| berechnen. Naturlich konnen wir

nur eine Untermatrix von Tf im Rechner darstellen, die nach endlich vielen Zeilenund Spalten abbricht.Wir schlagen im folgenden ein Vorgehen vor, welches die approximative Berechnungeiner endlichen Untermatrix von Tf ermoglicht, wenn f eine stetige Funktion ist.

Der Satz 4.2.1 gibt eine Darstellung aller Eintrage von Tf in Integralform an. Es istzunachst nicht klar, wie wir diese Integrale berechnen konnen. Wir konnten eine nu-merische Integration der einzelnen Eintrage per Quadratur versuchen, hatten dannjedoch zu bedenken, dass die Legendre-Polynome Pj fur hohen Polynomgrad j starkalternieren. An dieser Stelle wollen wir aber einen anderen Vorschlag zu Berech-nung der Werte machen, der auf dem stetigen Funktionalkalkul unitarer Operatorenaufbaut. Grundlage fur diesen Algorithmus ist der folgende Satz:

Satz 4.4.1. Sei f : [−1, 1]→ C stetig und sei z : [−1, 1] :→ C, t 7→ t die kanonische

Einbettung. Der Operator Tz : `2 → `2 ist unitar und fur das stetige Funktionalkalkul

von f auf Tz gilt f(Tz) = Tf .

Beweis. Zum Beweis verweisen wir auf Fachliteratur zur Operatorentheorie. Zum

Beispiel ergibt sich die Aussage als Korrolar aus Theorem 2.5.6, Theorem 2.5.7 und

Beispiel 2.5.1 in [4].

Wir also konnen also die Operatormatrix Tf fur jede stetige Funktion f darstellen,

indem wir den Funktionalkalkul zu f auf die Operatormatrix Tz anwenden. Damitwir diesen Satz anwenden konnen, mussen wir herausfinden, wie die Matrix Tz aus-sieht. Um die Eintrage von Tz auszurechnen, konnen wir die Drei-Term-Rekursionder Legendre-Polynome Pj benutzen, die wir in Formel (4.2) bereits angegeben ha-ben. Wir erinnern nocheinmal daran, dass

Pj+1 = αj+1zPk + βj+1Pj−1 j ∈ N0.

gilt. Fur die Rekursionskoeffizienten hatten wir die Darstellung αj+1 =

√4(j+1)2−1

j+1

und βj+1 = −jj+1

√2j+32j−1

, angegeben, und die Anfangspolynome der Rekursion sind

P0 = 1√2

und P−1 = 0. Mit Hilfe dieser Darstellung berechnen wir im folgenden Satz

die Matrix Tz.

Abschnitt 4.4: Berechnung des Multiplikationsoperators 23

Satz 4.4.2. Seien αj, j ∈ N0 die Koeffizienten aus der Drei-Term-Rekursion (4.2).

Fur die kanonische Einbettung z : [−1, 1]→ C gilt:

Tz =

0 1α1

0 0 · · ·1α1

0 1α2

0 0

0 1α2

0 1α3

0

0 0 1α3

0. . .

... 0 0. . . . . .

.

Beweis. Seien k, j ∈ N0. Aus der Darstellung der Eintrage von Tz, die wir in Satz

4.2.1 bewiesen haben, folgt, dass Tf symmetrisch ist. Deshalb genugt es, die Be-

hauptung fur den Fall k ≥ j zu beweisen. Wir erinnern daran, dass der Rekur-

sionskoeffizient αj fur jedes j ∈ N von Null verschieden ist und setzen dann die

Drei-Term-Rekursion (4.2) in die Darstellung von Tz aus Satz 4.2.1 ein:

(Tz)kj =

1∫−1

t Pj(t)Pk(t)dt =1

αj+1

1∫−1

Pj+1Pk − βj+1PkPj−1dt.

Fur k ≥ j folgt nun aus der Orthogonalitat der Legendre-Polynome:

(Tz)kj =1

αj+1

1∫−1

Pj+1Pkdt = δj+1,k1

αj+1

.

Wir kennen jetzt alle Eintrage von Tz und mochten die Matrix Tf mit Hilfe des

Satzes 4.4.1 berechnen. Da wir nur endlich viele Zeilen und Spalten der Matrizen Tzund Tf im Rechner darstellen konnen, fuhren wir die folgende Notation ein:

Notation 4.4.3. Fur n ∈ N0 sei πn : `2 → `2 die orthogonale Projektion auf

span(e0, ..., en). Fur jede Operatormatrix M : `2 → `2 setzen wir M (n) := πnMπn.

Wir mochten also die Matrix T(n)f = πnTfπn = πnf(Tz)πn berechnen. Aber auch fur

die Matrix Tz konnen wir nur eine endliche Teilmatrix verwenden, weshalb wir unszu folgender Naherung veranlasst sehen:

Naherung 4.4.4. Fur eine stetige Funktion f : [−1, 1] → C setzen wir T(n)f :=

f(πnTzπn) = f(T(n)z ) und verwenden die endliche Matrix T

(n)f als Naherung fur die

endliche Matrix T(n)f .

Die beiden Matrizen T(n)f und T

(n)f sind im Allgemeinen verschieden, weil die Anwen-

dung des Funktionalkalkuls zu f nicht mit der Projektion πn vertauschbar ist. Wir er-warten, dass der Fehler fur große Dimensionen n+1 des Unterraumes span(e0, ..., en)klein wird. Auf eine theoretische Fehleranalyse verzichten wir im Rahmen dieser Ar-beit aber und begnugen uns stattdessen damit, anhand der numerischen Tests inKapitel 5 zu beurteilen, wie praktikabel unser Vorgehen ist.


Zuletzt mussen wir noch darlegen, wie wir den Funktionalkalkul T(n)z = f(T

(n)z )

auswerten konnen. Es bietet sich an, T nz zu diagonalisieren und den Spektralsatzanzuwenden. Dann erhalten wir die folgende Darstellung.

Satz 4.4.5. Die endlichdimensionale Matrix T(n)z ist symmetrisch. Es sei V eine

unitare Matrix und D eine Diagonalmatrix mit T(n)z = V DV T . Dann gilt fur jede

stetige Funktion f die Gleichung T(n)f = V f(D)V T .

Beweis. Aus Satz 4.2.1 folgt, dass Tz symmetrisch ist und somit ist auch T(n)z =

πnTzπn symmetrisch. Insbesondere ist T(n)z unitar diagonlisierbar und besitzt des-

halb die angegebene Darstellung T(n)z = V DV T . Aus dem Spektralsatz folgt die

Behauptung.

Entscheidend ist bei diesem Vorgehen, dass die Matrix T(n)z nicht von der Funktion

f abhangt. Deshalb mussen wird die Diagonalisierung von T(n)z bei fester Dimension

n+ 1 nur einmal berechnen und konnen sie dann beliebig oft verwenden.Die nachfolgende Matlab-Funktion berechnet die Matrix T

(n)f mit Hilfe der Darstel-

lung aus Satz 4.4.5. Die Matrix V und die Diagonaleintrage von D werden hierbeivon der Funktion diagTz berechnet, die im Anhang in Listing A.3.1 zu finden ist.

Listing 4.4.1: MatlabMatlabMatlab-Funktion approxTf.m

1 function Tf = approxTf(f, n)

2 % APPROXTF Compute a multiplier operator matrix

3 % Computes a finit dimensional approximation for the

4 % multiplier operator matrix Tf belonging to the

5 % continous function f. The matrix is computed by

6 % applying a function calculus to the output of

7 % DIAGTZ.

8 %

9 % Usage: Tf = approxTf(f, n)

10 %

11 % Inputs:

12 % f - function handle representing a contious

13 % function on [-1, 1].

14 % n - an integer that defines the size of the

15 % (n+1)-by -(n+1) output matrix Tf.

16 %

17 % Outputs:

18 % Tf - (n+1)-by(n+1) matrix

19 %

20 % Examples:

21 % f = @(t) (exp(t) .* t);

Abschnitt 4.5: Berechnung des Einfachschichtpotentials 25

22 % Tf = approxTf(f, 300);

23 %


25 % deriv = normOfDeriv(ellipse 1);

26 % TDeriv = approxTf(deriv , 300);

27

28 [V, d] = diagTz(n);

29

30 d = f(d);

31 Tf = V;

32 for k = 1:n+1

33 Tf(:, k) = Tf(:, k) * d(k);

34 end

35 Tf = Tf * V’;

Zeile 28: Die Funktion diagTf diagonalisiert die Matrix T(n)z und gibt die

orthogonale Transformationsmatrix V sowie die Diagonale derDiagonalmatrix D zuruck. Die Funktion diagTz wird im Anhangin Listing A.3.1 aufgefuhrt.

Zeile 30-35: Die Formel T(n)f = V f(D)V T aus Satz 4.4.5 wird angewendet. Die

erste Multiplikation wird spaltenweise ausgefuhrt, um die Diago-nalstruktur von f(D) auszunutzen.

4.5 Berechnung des Einfachschichtpotentials

In Abschnitt 4.2 haben wir die Berechnung des Einfachschichpotentials (2.4) auf dieBerechnung des Vektors w aus Formel (4.1) und der Operatormatrix T|γj0 | aus Satz4.2.1 zuruckgefuhrt: Wenn der Vektor w ∈ `2 die Fourierkoeffizienten von log |γj0(t)−x| und der Vektor v ∈ `2 die Einfachschichtpotentiale (V ϕj0j)(x), j ∈ N0 enthalt,dann gilt die Formel (4.3):

v = T|γj0 |w.

In Abschnitt 4.3 haben wir die Matlab-Funktion fCoefLog vorgestellt, die die erstenn + 1 Eintrage von w mit Hilfe der Drei-Term-Rekursion aus [2] berechnet und dieOperatormatrix T|γj0 | konnen wir mit Hilfe der Funktion approxTf aus Abschnitt

4.4 naherungsweise berechnen. Wir mussen nun lediglich die Gleichung v = T|γj0 |win eine Matlab-Funktion schreiben, um die Einfachschichtpotentiale vj = (V ϕj0j)(x)zu erhalten. Wenn wir auf diese Weise die Einfachschichtpotentiale fur die Legendre-Polynome P0, ..., Pp berechnen wollen, ist es allerdings sinnvoll, die Berechnung fureine großere Dimension n > p des Polynomraums durchzufuhren und nur die erstenp+1 Werte zu verwenden, um eine bessere Approximation zu erhalten. Die FunktionsingLayPot in Listing 4.5.1 implementiert die Formel v = T|γj0 |w und ermoglicht es


dem Nutzer, diese Formel in einer hoheren Dimension n > p durchzufuhren, um dieEinfachschichtpotentiale von P0, ..., Pp mit hoher Genauigkeit zu errechnen.

Listing 4.5.1: MatlabMatlabMatlab-Funktion singLayPot.m

1 function pot = singLayPot(gamma , x, p, n)

2 % SINGLAYPOT Compute the single layer potential for

3 % Legendre -Polynomials on a rational curve.

4 % Computes the single layer potential of a point x for

5 % Legendre Polynomials P_0 , ..., P_p. The integrals are

6 % computed by use of the functions FCOEFLOG and

7 % APPROXTF.

8 %

9 % Usage: pot = singLayPot(gamma , x, p, n).

10 %

11 % Inputs:


13 % rational curve , see the function



16 % point in each row. The single layer

17 % potentials are computed for each of

18 % these points.

19 % p - an integer that defines the degrees of

20 % P_j; the single layer potential will be

21 % computed for the Legendre Polynmoials

22 % P_0 , ..., P_p.

23 % n - An integer that defines the size of the

24 % operator submatrix used by the functions

25 % FCOEFLOG and APPROXTF. It is required

26 % that n >= p. Increasing the ratio n / p

27 % will improve the approximation of the

28 % computed potential.

29 %

30 % Outputs:

31 % pot - (m)-by -(p+1)-matrix containing in row

32 % matrix(k, :) the single layer potentials

33 % of x(k) for the Legendre Polynomials

34 % P_0 , ... P_p.

35 %

36 % Example:


Abschnitt 4.5: Berechnung des Einfachschichtpotentials 27

38 % x = [1,3; 1,1; 1,0];

39 % pot = singLayPot(ellipse 2, x, 30, 50);

40

41 f = normOfDeriv(gamma);

42 pot = transpose(fCoefLog(gamma , x, n));

43 Tf = approxTf(f, n);

44 pot = Tf * pot;

45 pot = transpose(pot);

46 pot = pot(:, 1:p+1);

Zeile 1: Neben der gewunschten Ausgabegroße p + 1 kann als Parametern eine großere Zahl als p angegeben werden, damit die Berech-nung in einer großeren Dimension als der gewunschten Ausgabe-Dimension berechnet wird. So kann die Genauigkeit der Berech-nung erhoht werden.

Zeile 41: Die Funktion normOfDeriv gibt die euklidische Norm der Ablei-tung der Kurve gamma als Function-Handle zuruck. Die Funktionist im Anhang in Listing A.2.8 aufgefuhrt.

Zeile 42-46: Fur jeden Eingabevektor x wird die Formel v = T|γj0 |w ange-wendet. Der Vektor w wird mit der Funktion fCoefLog aus Ab-schnitt 4.3 berechnet, die Matrix T|γj0 | mit der Funktion approxTfaus Abschnitt 4.4. Man beachte, dass die Berechnung fur alleubergebenen Punkte x simultan durchgefuhrt wird.

Man beachte noch die folgende Anmerkung zur Effizienz der Funktion singLayPot:Wenn die Anzahl m der ubergebenen Punkte x wesentlich kleiner als die bei derBerechnung verwendete Dimension n+ 1 ist, ist unsere Implementierung der Funk-tionen singLayPot und approxTf sehr ineffizient: In der Funktion singLayPotwird namlich die Matrix T

(n)f an m Vektoren mit jeweisl n + 1 Eintragen multi-

pliziert. Die Laufzeitkomplexitat dieser Operation betragt O(mn2). Um die Ma-

trix T(n)f zu berechnen, wird aber zuvor in der Funktion ≈ eine Matrix-Matrix-

Multiplikation ausgefuhrt, die - bei kanonischer Implementierung - die Laufzeitkom-plexitat O(n3) besitzt. Fur den Fall m < n ware es deshalb geschickter, die Matrix-Matrix-Multiplikation in Zeile 35 von approxTf nicht durchzufuhren, sondern beideMatrizen an die Funktion singLayPot weiterzugeben und sie dort sukzessive an dieVektoren zu multiplizieren. Die Laufzeitkomplexitat der Funktion singLayPot ließesich so fur den Fall m < n von O(n3) auf O(mn2) senken (fur den Fall m ≥ nbetragt sie stets O(mn2)).Aus didaktischen Grunden haben wir uns in der vorliegenden Implementierung ge-gen diese Optimierung entschieden - durch die Ausfuhrung Multiplikation innerhalbder Funktion approxTf fallt es leichter, die Aufgabe der einzelnen Funktionen zuuberblicken. Bei einer spateren Implementierung des Algorithmus in einer Anwen-dung sollte die Optimierung aber selbstverstandlich mit implementiert werden.


Kapitel 5

Numerische Tests zur Berechnung

des Einfachschichtpotentials

Im vorangehenden Kapitel 4 haben wir einen Algorithmus zur Berechnung desEinfachschichtpotentials uber rationalen Kurven hergeleitet und ihn in Form derMatlab-Funktion singLayPot und mehrerer Hilfsfunktionen implementiert. In die-sem Kapitel werden wir verschiedene Matlab-Funktionen schreiben, um die numeri-schen Eigenschaften dieses Algorithmus zu testen.

In Abschnitt 5.1 erortern wir zunachst, welche Erkenntnisse wir uns aus den numeri-schen Tests erhoffen. Darauf aufbauend erlautern wir kurz, wie wir die Gute der be-rechneten Werte messen konnen und welche Tests wir zu welchem Zweck durchfuhrenwerden. Insbesondere geben wir am Ende des ersten Abschnitts mehrere Beispiel-situationen vor, auf die wir einige der nachfolgenden Tests anwenden werden. Dieanderen Abschnitte von Kapitel 5 sind dann der Implementierung, Durchfuhrungund Interpretation der Tests gewidmet.

5.1 Vorgehensweise und Erzeugung von Testbei-

spielen

Die in Abschnitt 4.5 vorgestellte Matlab-Funktion singLayPot (Listing 4.5.1) solldas Einfachschichtpotential uber eine Kurve γ an Punkten x ∈ R2 numerisch berech-nen. Aus mehreren Grunden kann die Abweichung des mit singLayPot berechnetenWertes vom tatsachlichen Einfachschichtpotential großer als die Maschinengenauig-keit sein. Mogliche Grunde sind:

• Bei jeder Rechenoperation, die mit Gleitkommazahlen ausgefuhrt wird, kannes zu Rundungsfehlern kommen.

• Die verwendeten Matrix-Funktionen konnten bei schlecht konditionierten Ma-trizen numerisch instabil sein.

• Die Berechnung der Integrale (4.1), fur die wir in Abschnitt 4.3 die FunktionfCoefLog implementiert haben, konnte numerisch instabil sein.

• Die Funktion approxTf , die wir in Abschnitt 4.4 implementiert haben, berech-net - selbst wenn sie mit exakter Arithmetik implementiert werden konnte -nur eine Naherung an die Operatormatrix Tf - zur Herleitung des Algorithmushaben wir namlich die Naherung 4.4.4 verwendet. Fur diese Naherung habenwir keine Fehlerabschatzung hergeleitet.

30 Kapitel 5: Numerische Tests zur Berechnung des Einfachschichtpotentials

• Wir brechen die Folge von Fourierkoeffizienten, die wir in der multiplikativenDarstellung des Einfachschichtpotentials in Formel (4.3) verwenden, stets nachendlichen vielen Gliedern ab.

Wir wollen die soeben aufgezahlten Punkte kurz besprechen:

Von den ersten beiden Punkten ist vor allem der zweite an einer Stelle relevant: DieFunktion diagTz (vgl. Listing 4.4.4 im Anhang), die von der Funktion approxTfaufgerufen wird, fuhrt eine QR-Zerlegung einer Matrix durch; dieser Algorithmuskann bei schlecht konditionierten Matrizen numerisch instabil sein. Mit Blick aufeine mogliche Implementierung in einer Anwendung ist dies jedoch kein Grund zurSorge, denn:

• Zum einen braucht die QR-Zerlegung bei einer vorgebenen Dimension n+1 nurein einziges Mal berechnet werden und kann dann - unabhangig von der Kurve,uber die das Einfachschichtpotential berechnet werden soll - immer wiederverwendet werden. Ein hoherer Rechenanfwand zur Kompensation moglichernumerischer Instabilitaten ließe sich hier also leicht rechtfertigen, weil es sich inder Tat um einen einmaligen Aufwand handelt - sofern das Ergebnis langfristiggespeichert wird.

• Andererseits berucksichtigen wir in unserer Implementierung der FunktiondiagTz noch nicht die besonders einfache Struktur der Input-Matrix. In Satz4.4.2 haben wir gesehen, dass es sich um eine symmetrische Bandmatrix mitBandbreite Eins handelt. Die Berechnung der Eigenwerte lasst sich also zumBeispiel durch die Verwendung von sturmschen Ketten verbessern.

Im Rahmen dieser Arbeit verzichten wir auf die letztgenannte Optimierung, da sievollig unabhangig von den hier vorgestellten Konzepten umgesetzt werden kann.

Die Berechnung der Integrale (4.1) besteht aus zwei Teilen: Zunachst wird die ra-tionale Funktion im Argument des Logarithmus faktorisiert; das Integral (4.1) kannso additiv zerlegt werden. Anschließend wir fur jeden Summanden die Funktionqtm1New aufgerufen. Beide Schritte sind in der Funktion fCoefLog (Lsiting 4.3.1)implementiert. Eine stabile Berechnung der Drei-Term-Rekursion ist durch die Funk-tion qtm1New gewahrleistet. Es handelt um eine leichte Abwandlung der Funktionqtm1 aus [2]. Siehe dort fur eine Diskussion der numerischen Stabilitat von qtm1.Die Faktorisierung der rationalen Funktion im Argument des Logarithmus kann hin-gegen zu uberraschenden Problemen fuhren. Darauf werden wir im nachfolgendenAbchnitt 5.2 naher eingehen.

Von den Funktionen approxTf (Listing 4.4.1) und singLayPot (Listing 4.5.1) habenwir auf jeden Fall zwei Fehler zu erwarten, die nicht numerisch, sondern analytischbegrundet sind. Wir rufen uns hierzu in Erinnerung, dass singLayPot die gesuch-ten Einfachschichtpotentiale mit Hilfe der Formel (4.3) berechnen soll. Laut dieserFormel lasst sich das Einfachschichtpotential multiplikativ in der Form

T|γ|w = v.

darstellen. Dabei enthalt der Vektor v die Einfachschichtpotentiale vj = (V Pj)(x)und der Vektor w die singularen Integrale

wj =1

2π

1∫−1

Pj(t) log |γ(t)− x| dt.

Abschnitt 5.1: Vorgehensweise und Erzeugung von Testbeispielen 31

Die Funktion fCoefLog berechnet die ersten n + 1 Komponenten des Vektors w.Wenn wir mit πn : `2 → `2 die orthogonale Projektion auf die 0-te bis n-te Kompo-nente bezeichnen, dann gibt die Funktion fCoefLog also den Vektor πnw zuruck.Die Funktion approxTf wiederum berechnet eine Naherung T

(n)|γ| an die Matrix

T(n)|γ| = πnT|γ|πn; vgl. hierzu Abschnitt 4.4. Schließlich setzt die Funktion singLayPot

diese Ergebnisse zu einer Naherung an die ersten p + 1 Eintrage von v zusammen.Sie berechnet namlich den Vektor

v := πpT(n)|γ| πnw.

Den Unterschied zum eigentlich gesuchten Ergebnisvektor πpv konnen wir jetzt fol-gendermaßen darstellen:

Satz 5.1.1. Es sei π>n := id−πn : `2 → `2 die orthogonale Projektion auf alle außer

den ersten n+1 Komponenten. Dann lasst sich der Unterschied des Ruckgabevektors

v der Funktion singLayPot vom gesuchten Vektor πpv schreiben als:

v − πpv = πp(T(n)|γ| − T

(n)|γ| )w − πpT|γ|π>nw.

Beweis. Es gilt

v − πpv = πpT(n)|γ| πnw − πpT|γ|w = πp(T

(n)|γ| − T

(n)|γ| )w + πpT

(n)|γ| w − πpT|γ|w =

=πp(T(n)|γ| − T

(n)|γ| )w + πpT|γ|πnw − πpT|γ|w = πp(T

(n)|γ| − T

(n)|γ| )w − πpT|γ|π>nw.

Satz 5.1.1 zeigt uns - unter Vernachlassigung moglicher numerischer Fehler - zweiQuellen fur einen anayltischen Approximationsfehler auf: Zum einen die Naherung4.4.4, deren Gute sich in der Norm |T (n)

|γ| − T(n)|γ| | wiederspiegelt und zum anderen

die Konvergenzrate der Eintrage von w, welche wir in der Norm des Vektors π>nwwiederfindet.Zur Verkleinerung beider Fehler konnen wir bei der Verwendung der FunktionsingLayPot die Zahl n großer wahlen als den maximalen Polynomgrad p Hiervonerhoffen wir uns eine bessere Approximationsgute im Tausch gegen einen hoherenRechenaufwand. Den Parameter n bezeichnen wir auch als Anzahl der Freiheitsgra-de, die der Funktion singLayPot zur Verfugung stehen. Ein wichtiges Ziel unsererTests wird es also sein, zu untersuchen, wie schnell die berechneten Werte konvergie-ren, wenn wir die Anzahl der Freiheitsgrade erhohen. Wir werden dies in Abschnitt5.4 tun.

Zusatzlich wollen wir auch noch weitere Fragen im Blick behalten:

• Die Faktorisierung einer rationalen Funktion, auf der die Funktion fCoefLogberuht, kann unter Umstanden zu einer numerischen Instabilitat fuhren. Diesewerden wir in Abschnitt 5.2 untersuchen.

• Da bei der Implementierung von Algorithmen stets Fluchtigkeitsfehler lauern,sind wir an einem Test interessiert, der unser Ergebnis grob mit dem Ergeb-nis eines anderen Algorithmus vergleicht. So wollen wir feststellen, ob bei derImplementierung grobe Programmierfehler entstanden sind, welche das Ergeb-nis komplett verfalschen wurden. Der Abschnitt 5.3 wird unter anderem einersolchen qualitativ orientierte Analyse dienen.


• Es ist ebenfalls interessant zu wissen, wie die Genauigkeit des berechneten Ein-fachschichtpotentials von der Lage des Punktes x abhangt, an dem wir das Po-tential auswerten. Wir vermuten, dass die Genaugigkeit in der Nahe der Kurveabnimmt und in großerer Entfernung zur Kurve zunimmt. Eine beispielhafteUntersuchung zu dieser Frage werden wir in Abschnitt 5.5 durchfuhren.

• Zuletzt interessieren wir uns auch dafur, welchen Vorteil uns die Verwendungvon rationalen Kurven im Vergleich zu einer Naherung durch Polygonzugebringt. In Abschnitt 5.6 betrachten wir diese Frage anhand einer Halbellipse.

Bevor wir in den beiden Abschnitten 5.3 und 5.4 versuchen die Genauigkeit und dieKovergenzrate der Funktion singLayPot zu untersuchen, mussen wir noch zwei Fra-gen beanworten: Erstens mussen wir festlegen, welches Maß wir fur den Unterschiedzweier verschieden genauer Ergebnisse verwenden wollen. Wenn wir der FunktionsingLayPot eine Kurve γ, Punkte x1, ..., xm ∈ R2, einen maximalen Polynomgrad pund einen Parameter n fur die Anzahl der Freiheitsgrade ubergeben, dann erhaltenwir fur jeden Punkt xi, i = 1, ...,m einen Ergebnis-Vektor

v(i) := (V Pkxi)k=0,...,p.

Im k-ten Eintrag erhalt dieser Vektor eine Naherung fur das Einfachschichtpotentialdes Legendre-Polynoms Pk an der Stelle xi. Angenommen, eine andere Berechnungs-methode liefert uns fur dieselbe Aufgabe andere Ergebnisvektoren

v(0i) := (V (0)Pkxi)k=0,...,p.

Dann benotigen wir eine Funktion, die wir als Maß fur den Unterschied der beidenErgebnisse verwenden konnen. Wir entscheiden uns hier fur folgendes Vorgehen: Furjeden Punkt xi berechnen wir zunachst den Unterschied der Vektoren v(i) und v(0i)

in der euklidischen Norm:

εi := |v(i) − v(0i)|2 (5.1)

Die Verwendung der euklidischen Norm ist dadurch motiviert, dass wir die Ein-fachschichtpotentiale, die durch die Eintrage der Vektoren v(i) approximiert werdensollen, als Fourierkoeffizienten geeigneter Funktionen auffassen konnen (vgl. dazuAbschnitt 4.2). Anschließend mussen wir den Fehler uber alle Punkte x1, ..., xm ag-gregieren. Eine Addition der Fehlerwerte εi bietet sich nicht an, da dann eine hohereAnzahl an Auswertungspunkten stets eine Vervielfachung des gemessenen Fehlersbewirken wurde. Je nach Erkenntnisinteresse konnen wir stattdessen zum Beispieldas Maximum aller Fehler ε1, ..., εm bilden, oder den Mittelwert derselben berech-nen. In unserer Implementierung der Funktion cmpSlpToRef , die wir in Listing 5.1.1vorstellen, entscheiden wir uns fur die Bildung des Mittelwertes, aber die Funktionlasst sich durch die Anderung eines einzigen Befehles in der letzten Zeile so andern,dass stattdessen der maximale Fehler berechnet wird.Die Funktion cmpSlpToRef funktioniert folgendermaßen: Wir ubergeben ihr eineKurve γ, eine Menge von Punkten x1, ..., xn, die wir als Ubergabeparameter zu einemVektor zusammenfassen, einen maximalen Polynomgrad p und einen Parameter n,der die Anzahl der Freiheitsgrade fur einen Aufruf der Funktion singLayPot festlegt.Die Funktion cmpSlpToRef soll dann die Vektoren v(1), ..., v(m) mit Hilfe der Funk-tion singLayPot berechnen und mit den Vektoren v(01), ..., v(0m) vergleichen. Diese


Vektoren ubergeben wir der Funktion - in einer Matrix ref zusammengefasst - eben-falls als Parameter. Die Funktion cmpSlpToRef berechnet dann die Abweichungzwischen dem Output von singLayPot und dem ubergebenen Referenzergebnis inder gerade beschriebenen Weise und gibt diese Abweichung an den Aufrufer zuruck.Listing 5.1.1 zeigt unsere Matlab-Implementierung der Funktion cmpSlpToRef .

Listing 5.1.1: MatlabMatlabMatlab-Skript cmpSlpToRef.m

1 function err = cmpSlpToRef(gamma , x, p, n, ref)

2 % CMPSLPTOREF Compare the output of SINGLAYPOT to a

3 % reference value

4 % Compute the output of singLayPot(gamma , x, p, n). For

5 % eache point of x, the output vector is compared to

6 % the associated vector in the matrix ref. For each

7 % point in x, CMPSLPTOREF will compute the euclidean

8 % norm of the difference of both vectors und return the

9 % mean value of all these norms.

10 %

11 % Usage: err = cmpSlpToRef(gamma , x, p, n, ref)

12 %

13 % Inputs:







20 % these points.




24 % P_0 , ..., P_p.







31 % ref - (m)-by -(p+1)-matrix containing in row

32 % ref(k, :) the single layer potentials


34 % P_0 , ... P_p , which were computed by use


35 % of any other numerical function , which

36 % is expected to compute the values very

37 % precisely , e.g. the function singLayPot ,

38 % if used with a very high degree of

39 % freedoms

40 %

41 % Outputs:

42 % err - a double which is the mean value of all

43 % errors that belong each to one of the

44 % input points represented by a row

45 % x(k,:). Each of these errors is the

46 % euclidean norm of the difference between

47 % the single layer potentials at x(k,:)

48 % computed with n degrees of freedom and

49 % the reference values contained in the

50 % matrix ref

51 %

52 % Examples:

53 % parabola = createCurve ([1,0], 1, [1,0,0], 1);

54 % x = [0,-1; 1,0; 2,1];

55 % p = 10;

56 % nRef = 500;

57 % ref = singLayPot(gamma , x, p, nRef);

58 % for n=p:2*p

59 % err = cmpSlpToRef(gamma , x, p, n, ref);

60 % display(err)

61 % end

62 %

63

64 slp = singLayPot(gamma , x, p, n);

65 difference = ref(:, 1:p+1) - slp(:, 1:p+1);

66

67 allErrors = zeros(size(x,1), 1);

68 for k=1: size(x,1)

69 allErrors(k) = norm(difference(k,:), 2);

70 end

71

72 err = mean(allErrors);

Als zweites wollen wir uns an dieser Stelle noch auf einige Testbeispiele einigen,die wir in den beiden Abschnitten 5.3 und 5.4 verwenden konnen. Die Verwendungderselben Testbeispiele fur mehrere Tests hat den Vorteil, dass die Testergebnisse


besser vergleichbar sind. Wir wollen fur unsere Tests drei verschiedene Beispielkur-ven betrachten: Ein Streckenstuck, eine Parabel und eine Halbellipse. Wahrend sichdie Gerade linear parametrisieren lasst, handelt es sich bei der Parabel um einepolynomielle und bei der Halbellipse sogar um eine rationale Kurve. Fur alle dreiKurven wollen wir zum einen eine Menge von Auswertungspunkten betrachten, dieweit von der Kurve entfernt liegen; zum anderen wollen wir auch jedes Mal eineMenge von Punkten betrachten, die nahe an der Kurve liegen.Um die Punkte nicht jedes mal per Hand eingeben zu mussen, schreiben wir nocheine Hilfsfunktion chooseTestPoints. Sie erwartet als Ubergabe eine Kurve gammain der Darstellung (4.1), ein mit meshgrid erzeugtes Gitter [xx, yy], eine positivereelle Zahl dist und und ein Flag close mit folgender Bedeutung:

• Wenn das Flag close auf 0 gesetzt ist, gibt die Funktion alle Punkte auf demGitter zuruck, die von der Kurve gamma weiter als dist entfernt liegt.

• Wenn das Flag close auf einen anderen Wert als 0 gesetzt wird, gibt die Funk-tion alle Punkte auf dem Gitter zuruck, die hochstens den Abstand dist vonder Kurve gamma besitzen.

Die Funktion chooseTestPoints ist fur unseren eigentlichen Test nicht wichtig, son-dern erleichtert lediglich die Auswahl geeigneter Testpunkte. Aus diesem Grundfuhren wir sie lediglich im Anhang in Listing B.1.2 auf.Das Matlab-Skript ExamplePointsLine in Listing 5.1.2 zeigt beispielhaft, wie sichmit Hilfe der Funktion chooseTestPoints Punkte aus einem Gitter aus wahlen las-sen, die den Mindestabstand 0.3 von einem Streckenstuck auf der ersten Winkelhal-bierenden haben. Dasselbe Vorgehen konnen wir zum Beispiel auch fur eine Halbel-lipse oder eine Parabel wahlen. Wenn wir das Flag close im Funktionenaufruf vonchooseTestPoints von 0 auf 1 andern, werden stattdessen nur Punkte ausgegeben,die nahe an der Kurve liegen.

Listing 5.1.2: MatlabMatlabMatlab-Beispiel ExamplePointsLine.m

1 clear all

2

3 curve = createLine ([-1,-1], [1,1], 1);

4 gamma = curve 1;

5 linX = linspace (-1.5, 1.5, 4);

6 linY = linX;

7 [xx, yy] = meshgrid(linX , linY);

8 points = chooseTestPoints(gamma , xx , yy , ...

9 0.3, 0);

10

11 drawCurves (gamma, 100);

12 hold on

13 plot(points (:,1), points (:,2), ’.’);

14 axis([-2,2,-2,2]);


15 hold off

Im Anhang befindet sich in Listing B.1.4 das Matlabskript SomeExamplePoints.Das Beispiel aus Listing 5.1.2 wird in diesem Skript auch fur eine Parabel und eineHalbellipse durchgefuhrt - einmal fur Punkte in der Nahe der Kurve und einmalfur Punkte in weiterer Entfernung der Kurve. Wenn das Skript aufgerufen wird,erzeugt es den Plot, der in Abbildung 5.1.1 zu sehen ist. Wir werden alle Tests inden beiden Abschnitten 5.3 und 5.4 mit den in Abbildung 5.1.1 dargestellten Kurvenund Punkten durchfuhren.

Abb. 5.1.1: Verschiedene Testsituationen fur die Funktion singLayPot

5.2 Der Polynomgrad in der Funktion fCoefLog

Bevor wir uns mit diversen Konvergenzeigenschaften unseres Algorithmusbschaftigen, wollen wir auf ein eher ungewohnliches Problem mit der numerischenStabilitat hinweisen, dass bei der Verwendung der Funktion fCoefLog auftretenkann. Wir hatten diese Funktion in Abschnitt 4.3 eingefuhrt, um die singularenIntegrale wj aus Formel (4.1) zu berechnen. Die Funktion kann in Listing 4.3.1nachgeschlagen werden. Sie beruht auf zwei zentralen Rechenschritten:

• Zunachst wird die rationale Funktion im Argument des Logarithmus faktori-siert. Wegen der Homomorphie-Eigenschaft des Logarithmus erhalten wir soeine additive Zerlegung des Integrals wj.

Abschnitt 5.2: Der Polynomgrad in der Funktion fCoefLog 37

• Die einzelnen Summanden konnen nun mit Hilfe der Drei-Term-Rekursion aus[2] berechnet werden. Diese Drei-Term-Rekursion ist in der Funktion qtm1Newimplementiert. Sie kann in Listing A.3.3 im Anhang nachgeschlagen werden.

Durch die Kombination einer Vorwarts- und einer Ruckwarts-Rekursion gelang in[2] eine stabile Berechnung der erwahnten Drei-Term-Rekursion. In der Funktionqtm1New haben wir die in [2] vorgestellte Funktion qtm1 ubernommen und an dieVerwendung in unserem Algorithmus angepasst. Wahrend wir bei der Verwendungvon qtm1New also nicht mit numerischen Schwierigkeiten rechnen, kann der ersteBerechnungsschritt in fCoefLog - also die Faktorisierung der rationalen Funktion|γ(t)−x|2 - problematisch sein. Dies mag zunachst uberraschen, kann aber an einemBeispiel leicht demonstriert werden. Wir schreiben dazu ein Matlab-Skript mit demNamen PolynomialDegree, dass einige einfache Anweisungen enthalt:

• Es wird eine rationale Kurve γ erzeugt, die die linke Halfte des Einheitskreisesparametrisiert.

• Es werden drei Punkte in der Ebene festgelegt: x = (1, 0)T , y = (1, 10−14)T ,z = (1, 0.01)T .

• Nun wird die Funktion singLayPot fur die drei Punkte und die Kurve γaufgerufen. Als maximalen Polynomgrad wahlen wir zum Beispiel p = 2 undals Anzahl der Freiheitgrade n = 10. Das Ergebnis lassen wir auf die Konsoleausgeben.

• Zuletzt rufen wir fur alle drei Punkte x, y, z und die Kurve γ die FunktiondistCurve auf. Diese Funktion ist in Listing A.2.9 im Anhang aufgefuhrt.Sie wird von der Funktion fCoefLog verwendet, um die rationale Funkti-on |γ(t) − x|2 zu berechnen; sie gibt die Koeffizienten des Zahler- und Nen-nerpolynoms dieser Funktion zuruck. Wenn wir sie mit nur einem Output-wert (oder ohne Outputwert) aufrufen, liefert sie nur die Koeffizienten desZahlerpolynoms zuruck.

Unsere Implementierung des Skriptes PolynomialDegree ist in Listing 5.2.1 auf-gefuhrt.

Listing 5.2.1: MatlabMatlabMatlab-Skript PolynomialDegree.m

1 clear all

2

3 % create a semi -circle left to the x2-axis

4 curve = createEllipse (1,1,1);

5 gamma = curve 1;

6

7 % some points n the mirrored semi -circel:

8 x = [1, 0];

9 y = [1, 10^ -10];


10 z = [1, 0.01];

11

12 format compact

13 format long

14

15 singLayPot(gamma , x, 2, 10)

16 singLayPot(gamma , y, 2, 10)

17 singLayPot(gamma , z, 2, 10)

18

19 display(’ ’);

20

21 format short e

22

23 distCurve(gamma , x)

24 distCurve(gamma , y)

25 distCurve(gamma , z)

Wenn wir das Skript ausfuhren, erhalten wir die folgende Ausgabe auf der Matlab-Konsole:

ans =

0.206164695986360 − 0.000000000000000 − 0.074691036950259

ans =

0.206164695986359 0.000000000000001 − 0.074691036950259

ans =

0.206167907871199 0.000836604738535 − 0.074692818444059

ans =

0 0 4 0 12 0 12 0 4

ans =

1.0000e− 028 4.0000e− 014 4.0000e+ 000 1.2000e− 013 1.2000e+ 001

1.2000e− 013 1.2000e+ 001 4.0000e− 014 4.0000e+ 000

ans =

1.0000e− 004 4.0000e− 002 4.0004e+ 000 1.2000e− 001 1.2001e+ 001

1.2000e− 001 1.2000e+ 001 4.0000e− 002 4.0001e+ 000

Wenn wir nun in der Funktion fCoefLog in Zeile 44 den Aufruf der Funkti-on adjustLCoef auskommentieren, und das Skript PolynomialDegree nochmals

Abschnitt 5.2: Der Polynomgrad in der Funktion fCoefLog 39

ausfuhren, erhalten wir stattdessen die folgende Ausgabe:

ans =

0.206164695986360 − 0.000000000000000 − 0.074691036950259

ans =

1.0e+ 010 ∗0.000000000020580 4.012029353869633 − 0.000000000007465

ans =

0.206167907871199 0.000836604738535 − 0.074692818444059

ans =

0 0 4 0 12 0 12 0 4

ans =

1.0000e− 028 4.0000e− 014 4.0000e+ 000 1.2000e− 013 1.2000e+ 001

1.2000e− 013 1.2000e+ 001 4.0000e− 014 4.0000e+ 000

ans =

1.0000e− 004 4.0000e− 002 4.0004e+ 000 1.2000e− 001 1.2001e+ 001

1.2000e− 001 1.2000e+ 001 4.0000e− 002 4.0001e+ 000

Offenbar nimmt das Ergebnis der Funktion singLayPot am Punkt y einen extremhohen Wert an. Um den Grund fur diese numerische Instabilitat zu finden, habenwir auch die Koeffizienten der Zahlerpolynome der Funktionen |γ(t) − x|2 ausge-ben lassen. Hier konnen wir feststellen, dass der Polynomgrad des Zalherpolynomsam Punkt y einen Sprung macht. Analytisch lasst sich leicht nachrechnen, dassder Punkt x = (1, 0)T tatsachlich der einzige in seiner Umgebung ist, bei dem derZahlerpolynomgrad von |γ(t) − x|2 nicht 8, sondern 6 betragt. Das Entstehen derenormen Abweichung in der zweiten Ausgabe konnen wir dann folgendermaßen er-klaren:

• In der Umgebung um x nahern sich die beiden fuhrenden Koeffizienten desZahlerpolynoms der Zahl 0 an.

• Dies fuhrt zu einem starken Anstieg des Betrags zweier Nullstellen des Poly-noms.

• Daraufhin rechnet die Funktion fCoefLog mit zwei Nullstellen weiter, derenBetrag deutlich großer ist, als der Betrag der anderen Nullstellen. NumerischeFehler bei der Verwendung dieser Nullstellen konnen mehrere Zehnerpotenzengroßer sein, als das eigentliche Ergebnis der Funktion fCoefLog und fuhrendeshalb zu einem vollig falschen Ergebnis.

Eine Moglichkeit dieses Problem zu umgehen haben wir mit Hilfe der FunktionadjustLCoef implementiert, die im Anhang in Listing A.1.6 zu finden ist. Sie setztdie fuhrenden Koeffizienten eines Polynoms auf Null, wenn sie einen Toleranzwertunterschreiten. Unsere Funktion polyroots (Listing A.1.4 im Anhang), die anschlie-ßend die Nullstellen der Polynome berechnet, fullt die fehlenden Nullstellen mit demWert ∞ auf, und die Funkton qtm1New, welche die Nullstellen weiterverarbeitet,ist so angepasst, dass sie fur das gesuchte Integral den Wert 0 zuruckgibt, wenn ihrstatt einer komplexen Nullstelle der Wert ∞ ubergeben wurde.


Obwohl diese Anpassung im obigen Beispiel zu einem wesentlich besseren Ergebnisfuhrt, sollten wir sie aus mindestens zwei Grunden nur als Notbehelf betrachten:

• Erstens ist keineswegs klar, welcher Toleranzwert fur die fuhrenden Koeffizi-enten am besten geeinget ist um ein numerisch stabiles Ergebnis zu erreichen.

• Zweitens berucksichtigt dieses Vorgehen nicht, dass der fuhrende Koeffizientund der nachfolgende Koeffizient zwar beide gegen Null streben, aber im All-gemeinen nicht gleich schnell abnehmen mussen.

Den letztgenannten Effekt kann man beispielsweise sehen, wenn man den Punkt y imSkript PolynomialDegree nicht gleich (1, 10−14), sonder gleich (1, 10−10) wahlt (undzugleich den Aufruf der Funktion adjustLCoef in Zeile 44 von fCoefLog wiedereinkommentiert). In diesem Fall wird der fuhrende Koeffizient des Polynoms vonder Funktion adjustLCoef geloscht; der nachfolgende Koeffizient ist jedoch etwasgroßer als die Fehlerschranke 10−12, die wir momentan an adjustLCoef ubergeben.Wenn wir das Testskript mit dem geanderten Punkt y ausfuhren, erhalten wir diefolgende Ausgabe:

ans =

0.206164695986360 − 0.000000000000000 − 0.074691036950259

ans =

− 3.864269163004249 − 0.000000000000072 0.745748546141290

ans =

0.206167907871199 0.000836604738535 − 0.074692818444059

ans =

0 0 4 0 12 0 12 0 4

ans =

1.0000e− 020 4.0000e− 010 4.0000e+ 000 1.2000e− 009 1.2000e+ 001

1.2000e− 009 1.2000e+ 001 4.0000e− 010 4.0000e+ 000

ans =

1.0000e− 004 4.0000e− 002 4.0004e+ 000 1.2000e− 001 1.2001e+ 001

1.2000e− 001 1.2000e+ 001 4.0000e− 002 4.0001e+ 000

Offenbar ist der Fehler - trotz der Verwendung der Funktion adjustLCoef - immernoch so groß, dass wir keine Ahnlichkeit des Ergebnisses mit dem korrekten Werterkennen konnen. Aus diesem Grund konnen wir festhalten, dass die Verwendungder Funktion adjustLCoef den auftretenden Fehler zwar einschrankt, aber keines-wegs behebt. Im folgenden werden wir stets die Funktion adjustLCoef verwen-den, um zu verhindern, dass die beschriebene Instabilitat zu Fehlern fuhrt, die dieGroßenordnung der Ergebnisse selbst deutlich ubersteigen. Nichtsdesto trotz bleibtim Moment die Frage offen, wie wir die auftretende Instabilitat im Allgemeinenkompensieren konnen.Im ubrigen sei aber angemerkt, dass beschrieben Instabilitat bei einer rationalenKurve (

p1(t)q1(t)p2(t)q2(t)

)

Abschnitt 5.3: Ein Ergebnisvergleich mit der Matlab-Funktion quad 41

nur dann auftreten kann, wenn grad(p1) = grad(q1) oder grad(p2) = grad(q2) gilt.Man erkennt dies unmittelbar, wenn man die Kurve in die Funktion |γ(t)− x| ein-setzt.

5.3 Ein Ergebnisvergleich mit der Matlab-

Funktion quad

Nach dem wir uns im vorangehenden Abschnitt mit einer sehr speziellen numeri-schen Instabilitat befasst haben, konnen wir uns nun anderen Eigenschaften unsererFunktionen zuwenden.Unser erstes Ziel ist es, unsere Implementierungen aus dem vorangehenden Kapi-tel 4 auf qualitative Fehler zu untersuchen, welche ein komplett falsches Ergebnisbewirken wurden. Beispiele fur solche Fehler konnten vergessene Konstanten, derZugriff auf falsche Array-Elemente oder Ahnliches sein.Um einen einfachen Test zu entwickeln, erinnern wir an die Formel (2.4); das Ein-fachschichtpotential einer Funktion ϕ auf einer Kurve γ an einem Punkt x ist lautdieser Formel gegeben durch

(V ϕj0j)(x) =1

2π

1∫−1

Pj(t)|γj0(t)| log |x− γj0(t)| dt.

Im Folgenden werden wir dieses Integral in einigen Beispielen mit Hilfe der Matlab-Funktion quad berechnen und das Ergebnis mit den Werten vergleichen, die uns dieFunktion singLayPot liefert. Die Funktion quad fuhrt eine Quadratur durch. Wirkonnen ihr als Parameter einen Wert tol ubergeben, der festlegt, wie genau die Qua-dratur den Integralwert berechnen soll. Wie wir bereits mehrmals angemerkt haben,ist eine Quadratur zur Berechnung des Einfachschichtpotentials aber sehr aufwen-dig, wenn x nahe an der Kurve γ liegt. Entsprechend benotigt die Funktion quadrecht lange, um die gewunschten Werte zu berechnen. In einigen Fallen wird quadnicht in der Lage sein, ein Ergebnis mit der gewunschten Genauigkeit zu berechnen.In diesen Fallen gibt Matlab meist eine Warnung aus.

Zur Berechnung des Einfachschichtpotentials mit Hilfe von quad implementieren wireine Matlab-Funktion slpQuad. Wir ubergeben dieser Funktion eine rationale Kur-ve in der Darstellung (4.1). Wie auch die Funktion singLayPot soll slpQuad dasEinfachschichtpotential auf γ nicht fur eine beliebige Funktion ϕ, sondern fur dieLegendre-Polynome P0, ..., Pp auf dem Parameterintervall [−1, 1] berechnen. Ausdiesem Grund ubergeben wir ihr auch den maximalen Polynomgrad p. Zudemubergeben wir an die Funktion mehrere Punkte x ∈ R2, an denen die Einfach-schichtpotentiale von P0, ..., Pp berechnet werden sollen. Zuletzt benotigt die Funk-tion noch einen Parameter tol, der festlegt, mit welcher Genauigkeit die Funktionquad aufgerufen werden soll. Anschließend kann die Funktion die gerade zitierteFormel (2.4) fur jeden ubergebenen Punkt x und jedes Legendre-Polynom P0, ..., Ppauswerten und die Ergebnisse in einer Matrix zuruckgeben. Listing 5.3.1 zeigt unsereImplementierung der Funktion slpQuad.


Listing 5.3.1: MatlabMatlabMatlab-Funktion slpQuad.m

1 function pots = slpQuad(gamma , x, p, tol)

2 % SLPQUAD Computes the single layer potential via the

3 % matlab function QUAD

4 % Compute the single layer potential of the legendre

5 % polynomials P_0 , ..., P_p on the curve gamma at two

6 % dimensional points that are represented by the

7 % rows x(k,:) of x. That numerical integration is

8 % performed by the matlab function QUAD

9 %

10 % Usage: pots = slpQuad(gamma , x, p, tol)

11 %

12 % Inputs:







19 % these points.




23 % P_0 , ..., P_p

24 % tol - a double that defines the error tolerance

25 % which is passed to the matlab function

26 % QUAD

27 %

28 % Outputs:




32 % P_0 , ... P_p.

33 %

34 % Examples:


36 % x = [1,3; 1,1; 1,0];

37 % pot = slpQuad(ellipse 2, x, 5, 10^-7);

38

39

40 % create Function -Handles for the Legendre Polynomials

41 % P_0 , ..., P_p , using the matlab -function legendre


42 legendrePols = cell(p+1,1);

43 for j=0:p

44 tmp = zeros(1,j+1);

45 tmp(1) = 1;

46 legendrePolsj+1 = @(t) (tmp*legendre(j, t, ...

47 ’norm’));

48 end

49

50 % initialize a matrix to store the output data

51 pots = zeros(size(x,1), p+1);

52

53 % compute the single layer potentials via the function

54 % matlab -function QUAD


56

57 % initialize the laplace kernel as function

58 % handle

59 [nom , den] = distCurve(gamma , x(k,:));

60 gammaLogDist = @(t) log( polyval(nom , t) ./ ...

61 polyval(den , t) ) / (4*pi);

62

63 gammaDerivNorm = normOfDeriv(gamma);

64

65 for j=1:p+1

66 % initalize the integrand as function handle

67 integrand = @(t) (legendrePolsj(t) ...

68 .* gammaDerivNorm(t) .* gammaLogDist(t));

69

70 % compute the single layer potential via QUAD

71 pots(k,j) = quad(integrand , -1, 1, tol);

72 end

73 end

Nun wollen wir die Ergebnisse, die slpQuad zuruckliefert, mit denen vergleichen,die die Funktion singLayPot berechnet. Wir fuhren diesen Vergleich fur alle Bei-spielsituationen durch, die wir in Abschnitt 5.1 in Abbildung 5.1.1 vorgestellthaben. Dazu schreiben wir eine Funktion plotFuncCalcV sQuad. Sie erhalt alsUbergabeparameter die Kurve γ, einen Vektor mit zweidimensionalen Punkten x,einen maximalen Polynomgrad p, und einen Vektor n, der mehrere verschiedene An-zahlen von Freiheitsgraden fur den Aufruf der Funktion singLayPot festlegt. Zudemwird der Funktion eine Zahl tol ubergeben, die als Fehlertoleranz an der FunktionslpQuad weitergeleitet wird. Die Funktion plotFuncCalcV sQuad soll dann die fol-genden Schritte durchfuhren:


• Fur jedes Basis-Polynom P0, ..., Pp wird an jedem ubergebenen Punkt x ∈ R2

das Einfachschichtpotential (2.4) mit Hilfe der gerade vorgestellten FunktionslpQuad per Quadratur berechnet.

• Fur jeden Eintrag k des ubergebenen Vektors n werden dieselben Einfach-schichtpotentiale auch mit der Funktion singLayPot mit k Freiheitsgradenberechnet. Wie im vorangehenden Abschnitt 5.1 beschrieben wird von derFunktion cmpSlpToRef (Listing 5.1.1) der Unterschied zwischen beiden Er-gebnissen berechnet.

• Zuletzt wird ein Plot ausgegeben, der fur jeden Eintrag k aus dem Vektor nden berechneten Fehler anzeigt.

Das Listing 5.3.2 zeigt, wie wir die Funktion plotFuncCalcV sQuad in Matlab im-plementieren konnen.

Listing 5.3.2: MatlabMatlabMatlab-Funktion plotFuncCalcVsQuad.m

1 function plotFuncCalcVsQuad(gamma , x, p, n, tol)

2 % PLOTFUNCCALCVSQUAD Computes the single layer potential

3 % via the matlab function QUAD and via the

4 % function SINGLAYPOT und plots the difference




8 % rows x(k,:) of x. First , the numerical integration is

9 % performed by the matlab function QUAD , afterwards it

10 % is performed by the function singLayPot. The results

11 % are compared by the function cmpSlpToRef

12 %

13 % Usage: plotFuncCalcVsQuad(gamma , x, p, n, tol)

14 %

15 % Inputs:







22 % these points.




26 % P_0 , ..., P_p


27 % n - an array of increasing integers that define

28 % the degrees of freedom which are used by

29 % the function singLayPot. The function

30 % singLayPot is called once for each entry

31 % of n; thus , each entry of n must be at

32 % least as big as p.

33 % For each entry of n the output of

34 % singLayPot is compared the output of

35 % slpQuad which is not depending on n.

36 % Afterwards , the the error computed by

37 % cmpSlpToRef is plotted as of function of

38 % n.



41 % QUAD

42 %

43 % Outputs:

44 % no outputs

45 %

46 % Examples:


48 % gamma = ellipse 1;

49 % x = [1,3; 1,1; 1,0];

50 % p = 3;

51 % n = 5:40;

52 % tol = 10^-9;

53 % plotFuncCalcVsQuad(gamma , x, p, n, tol)

54

55

56 % initilaize a vector to store the error for each n

57 err = zeros(length(n) ,1);

58

59 % compute the single layer potential for the

60 % Legendre -polynomials P_0 , ..., P_p and all points x via

61 % the matlab -function quad

62 potQuad = slpQuad(gamma , x, p, tol);

63

64 % compare the result to the result of singLayPot for all

65 % degrees of freedom in the vector n

66 for k=1: length(n)

67 err(k) = cmpSlpToRef(gamma , x, p, n(k), potQuad);

68 end

69


70 % plot the error as a function of the degress of freedom

71 hold off

72 semilogy(n + 1, err , ’-s’, ’MarkerSize ’, 3);

73 ylabel(’Fehler ’)

74 xlabel(’Freiheitsgrade ’)

In Abschnitt 5.1 haben wir in Abbildung 5.1.1 verschiedene Beispielsituationen ge-zeigt, fur die wir unsere Tests durchfuhren wollen. Die Beispielsituationen aus Ab-bildung 5.1.1 wurden vom Matlab-Skript SomeExamplePoints (Listing B.1.4 imAnhang) erzeugt. Um unsere Testfunktion plotFuncCalcV sQuad auf die Beispieleanzuwenden, erganzen wir das Skript um einen Aufruf von plotFuncCalcV sQuad furjede Beispielsituation. Das abgeanderte Skript gibt die von plotFuncCalcV sQuaderzeugten Fehlerkurven in derselben Reihenfolge aus, in der die Beispielsituationenin Abbildung 5.1.1 angeordnet waren. Das Skript befindet sich unter dem NamenFuncCalcV sQuad in Listing B.1.8 im Anhang. Wenn wir das Skript ausfuhren,erhalten wir die sechs Fehlerkurven, die in Abbildung 5.3.1 dargestellt sind.

0 20 40 60

10−8.77877

10−8.77877

10−8.77877

Feh

ler

Freiheitsgrade0 20 40 60

10−10

10−5

100

Feh

ler


10−10

10−5

100

Feh

ler

Freiheitsgrade

0 20 40 60

10−7.19735

10−7.19735

Feh

ler


10−10

10−5

100

Feh

ler


10−10

10−5

100

Feh

ler

Freiheitsgrade

Abb. 5.3.1: Ergebnisse aus dem Vergleich von singLayPot und slpQuad

Betrachten wir die Abbildung 5.3.1, so fallt zunachst auf, dass der Fehler in allenFallen gegen einen Wert nahe der Null strebt. Wir werten dies als Indiz, dass unsbei der Implementierung unserer Funktionen keine solchen Fehler unterlaufen sind,die das Ergebnis komplett verfalschen wurden. Nun wollen wir den Fehlerverlauf furdie einzelnen Beispielsituationen naher betrachten und erste genauere Uberlegungenzum Konvergenzverhalten anstellen.An den beiden linken Graphen in Abbildung 5.3.1 erkennen wir, dass der Fehler fur


lineare Kurven, unabhangig von der Anzahl n der Freiheitsgrade, klein ist. Mit derFehlerdarstellung aus Satz 5.1.1 lasst sich dieser Effekt leicht erklaren. Wir hattendort den Output der Funktion singLayPot mit v bezeichnet und nachgerechnet,dass die Differenz zum korrekten Ergebnis πpv durch die folgende Formel gegebenist:

v − πpv = πp(T(n)|γ(·)| − T

(n)|γ(·)|)w − πpT|γ(·)|π>nw.

Nun ist fur lineare Kurven γ die Ableitung γ konstant und die Matrix T|γ(·)| somiteine Diagonalmatrix, in der alle Diagonaleintrage gleich dem konstanten Wert von|γ(·)| sind. Damit erhalten wir einerseits, die Gleichheit πpT|γ(·)|π>n = 0. Andererseits

gilt aber in diesem Spezialfall auch T(n)|γ(·)| = T

(n)|γ(·)|, das heißt die Naherung 4.4.4 ist

exakt. Insgesamt folgt

v − πpv = 0, (5.2)

wobei wir aber daran erinnern, dass numerische Fehler in Satz 5.1.1 außen vor ge-lassen wurden.Der Fehlerverlauf im oberen linken Plot von Abbildung B.1.8 haben wir mit derGleichung (5.2) erklart, denn der Fehler erreicht dort in etwa die Großenordnungdes Toleranzwertes, mit dem wir die Funktion quad aufgerufen haben.Uberraschend wirkt auf den ersten Blick hingegen der darunterliegende Plot, derzu einer linearen Kurve und nahe an der Kurve liegenden Punkten x gehort. DieOperatormatrix T

(n)|γ(·)| hangt nicht von der Lage des Auswertungspunktes x ab und

die Funktion fCoefLog sollte auch dann stabile Ergebnisse liefern, wenn x aufder Kurve liegt. Wir konnen den Fehlerverlauf aber erklaren, wenn wir denselbenPlot nochmals ausgeben und dabei die Fehlertoleranz der Funktion quad absenken.Setzen wir sie auf 10−11 anstelle von 10−9, so gibt Matlab eine Warnung aufgrundvon Singularitaten bei der Quadratur aus. Diese Singularitaten sind auf die Lage derPunkte x unmittelbar bei der Kurve zuruckzufuhren und wir konnen annehmen, dassder Fehlerverlauf deutlich uberhalb der ubergebenen Grenze durch eine Instabilitatder Funktion quad aufgrund des singularen Integranden begrundet ist.

Nun betrachten wir das Fehlerverhalten der Parabel und der Halbellipse. In denPlots in Abbildung 5.3.1 sehen wir einen annahernd linearen Verlauf. Bedenken wir,dass die Fehlerachsen logarithmisch skaliert sind, so konnen wir schließen, dass derFehler in unseren Beispielen bei steigender Anzahl von Freiheitsgraden exponentiellabnimmt. Es verlauft die Fehlerkurve der Halbellipse etwas flacher als diejenige derParabel.

Zuletzt vergleichen wir noch die beiden Fehlerkurven fur die Halbellipse. Liegen dieAuswertungspunkte nah an der Kurve (dies ist in allen unteren Plots der Fall, vgl.Abbildung 5.1.1), so fallt die Kurve deutlich langsamer, als wenn die Auswertungs-punkte weiter von ihr entfernt liegen. Zudem scheint die Fehlerkurve im erstgenann-ten, unteren Fall deutlich starker zu schwanken. Um uns hiervon zu uberzeugen,drucken wir die beiden zur Halbellipse gehorigen Plots noch einmal großer ab. Ab-bildung 5.3.2 zeigt links den Fehlerverlauf fur diejenigen Punkte, die weit von derKurve entfernt liegen. Rechts ist der Fehlerverlauf fur diejenigen Punkte abgebildet,die nah an der Kurve liegen.Nun erkennen wir deutlich die Schwankungen in der Fehlerkurve, falls sich die Aus-wertungspunkte nahe an der Kurve befinden. Sowohl fur diese Schwankungen als


Abb. 5.3.2: Ergebnisse aus dem Vergleich von singLayPot und slpQuad - vergroßert

fur die Halbellipse

auch fur das langsamere Abfallen des Fehlers nahe der Kurve mochte wir moglicheErklarungen finden. Zu diesem Zweck betrachten wir die singularen Integrale wj ausFormel (4.1), welche die Funktion fCoefLog (Listing 4.3.1) fur uns berechnet. Wirgeben die Werte beispielhaft fur einen Punkt nahe der Kurve und fur einen Punktin großerer Entfernung zur Kurve aus. Ist gamma die Halbellipse aus dem vorange-henden Test, so liefert fCoefLog fur den von der Kurve entfernt gelegenen Punktx = (−2.5, 1)T den folgenden Vektor π10w = (w0, ..., w10)T :

0.1202 0.0389 0.0697 − 0.0263 − 0.0173 0.0145

0.0025 − 0.0070 0.0011 0.0029 − 0.0015

Zu dem auf der Kurve gelegenen Punkt x = (0, 1)T erhalten wir hingegen die Werte

0.0687 0.1385 − 0.1164 0.0580 − 0.0285 0.0242

− 0.0202 0.0155 − 0.0128 0.0109 − 0.0094

In diesem Beispiel fallen die Werte deutlich langsamer ab, wenn x nahe an derKurve liegt. Wir wollen uns an dieser Stelle nicht naher mit dem Zusammenhangzwischen der Singularitat des Integranden und der Konvergenzgeschwindigkeit derFourierreihe beschaftigen, halten aber fest, dass dieser hier nur beispielhaft beobach-tete Zusammenhang dazu dienen kann, sowohl den unregelmaßigen Fehlerverlauf alsauch die langsamere Konvergenz fur Auswertungspunkte nahe der Kurve zu erklarenDazu brauchen wir lediglich die Fehlerformel in Satz 5.1.1 zu betrachten. Werfenwir zunachst einen Blick auf den ersten Fehlerterm

πp(T(n)|γ(·)| − T

(n)|γ(·)|)w.

Abschnitt 5.4: Zur Konvergenzgeschwindigkeit der Funktion singLayPot 49

Wir gehen davon aus, dass die berechnete Matrix Tf den richtigen Operator be-sonders in den Eintragen mit kleinem Zeilen- und Spaltenindex gut approximiert.Wenn der Fehler T

(n)|γ(·)|− T

(n)|γ(·)| sich also besonders in den hohen Zeilen- und Spalten-

indizes niederschlagt, dann wirkt sich dieser Fehler umso starker auf das Ergebnisvon singLayPot aus, je großer die unteren Eintrage des Vektors w sind.Betrachten wir nun den zweiten Fehlerterm

πpT|γ(·)|π>nw.

Offensichtlich ist dieser Vektor fur eine feste Zahl n umso großer, je langsamerdie Eintrage von w konvergieren. Somit fuhrrt die langsamere Konvergenz derWerte wj in der Nahe der Kurve auch zur einer schlechteren Konvergenz unsererNaherungslosung v.

5.4 Zur Konvergenzgeschwindigkeit der Funktion

singLayPot

Im vorangehenden Abschnitt haben wir die Funktion singLayPot (Listing 4.5.1)nur fur wenige Polynome P0, ..., Pp ausgewertet. Unser Hauptaugenmerk lag darauf,ob die Funktion fur steigende Freiheitsgrade Werte liefert, die mit den Ergebnisseneiner Quadratur ubereinstimmt.In diesem Abschnitt werden wir nun genauer auf die Konvergenzgeschwindigkeit dervon singLayPot berechneten Werte eingehen, wenn wir die Anzahl n der Freiheits-grade groß werden lassen. Wir erinnern noch einmal daran, dass es sinnvoll ist, dieVektorraum-Dimension n+ 1, mit der die Funktion singLayPot arbeitet, großer zuwahlen, als den maximalen Polynomgrad p, da sich die Prazision der berechneten Er-gebnisse dadurch verbessern lasst. Andererseits fuhrt eine Erhohung von n naturlichzu einem hoheren Rechenaufwand. Aus diesem Grund wollen wir nun betrachten,wie schnell die Ruckgabewerte von singLayPot mit steigendem n (bei festem p)konvergieren. Hatten wir fur eine Beispielsituation einen exakten Wert fur das Ein-fachschichtpotential zur Verfugung, so konnten wir das Ergebnis von singLayPotfur verschiedene Freiheitsgrade n einfach durch die Funktion cmpSlpToRef mit die-sem exakten Wert vergleichen lassen. Da wir im Allgemeinen aber nicht uber einexaktes Ergebnis verfugen (und die Funktion slpQuad, die wir im vorangehendenAbschnitt in Listing 5.3.1 implementiert haben, zu langsam ist, um sie fur großereWerte von p zu verwenden), werden wir stattdessen die Ergebnisse, die die FunktionsingLayPot mit verschiedenen Freiheitsgraden erzielt, unter einander vergleichen.Wir wahlen dazu das folgende Vorgehen:

• Zunachst fuhren wir die Funktion singLayPot fur eine sehr hohe Anzahl vonFreiheitsgraden nRef >> p aus, um einen moglichst genauen Vergleichswertfur die spateren Berechnungen zu erhalten.

• Anschließend fuhren wir die Funktion singLayPot fur Freiheitsgrade p ≤ n <nRef aus und beobachten das Konvergenzverhalten der Ruckgabewerte vonsingLayPot. Um die Abweichung zu messen, verwenden wir die FunktioncmpSlpToRef , die wir in Abschnitt 5.1 in Listing 5.1.1 vorgestellt haben.


In Listing 5.4.1 ist die Matlab-Funktion plotDecreasingError dargestellt, die die-ses Vorgehen implementiert. Als Ubergabeparameter erwartet sie eine Kurve γ, ei-ne Matrix, die zweidimensionale Punkte x enthalt, den maximalen Polynomgradp, einen Vektor n, der verschiedene Belegungen fur die Anzahl der Freiheitsgradeenthalt, und eine Zahl nRef , welche die Freiheitsgrade bei der Berechnung der Refe-renzlosung festlegt. Anschließend werden die gerade beschriebenen Fehlermessungendurchgefuhrt und der Fehler in Abhangigkeit der Freiheitsgrade geplottet. Zudemimplementieren wir die Funktion so, dass fur p auch ein Vektor ubergeben werdenkann, der verschiedene Belegungen fur den maximalen Polynomgrad enthalt. Diegesamte Fehlermessung wird dann fur jede dieser Belegungen einmal durchgefuhrtund alle Fehlerkurven im selben Plot dargestellt. Um die einzelnen Kurven von-einander unterscheiden zu konnen, mussen wir der Funktion plotDecreasingErrorzusatzlich zwei Cell-Arrays zur Formattierung der Fehlerkurven ubergeben (vgl. da-zu den help-Kommentar der Funktion).

Listing 5.4.1: MatlabMatlabMatlab-Funktion plotDecreasingError.m

1 function plotDecreasingError(gamma , x, p, n, nRef , ...

2 markers , markerSizes)

3 % PLOTDECREASINGERROR Computes the single layer

4 % potential via the function singLayPot and

5 % compares the output to a reference solution





10 % performed by the function singLayPot for a high

11 % degree of freedom in order to compute a reference

12 % solution; afterwards it’s computed for various

13 % degrees of freedom and the result is compared to the

14 % reference solution by the function cmpSlpTpRef. The

15 % error is plottet as a function of the degrees of

16 % freedom.

17 %

18 % Usage: plotDecreasingError(gamma , x, p, n, nRef , ...

19 % markers , markerSizes)

20 %

21 % Inputs:








28 % these points.

29 % p - an array containing several integers k,

30 % that defines the degrees of P_j; the

31 % single layer potential will be


33 % P_0 , ..., P_k , and the whole function

34 % will be executed for all integers k that

35 % are contained in the array k





40 % of n and the output of singLayPot is

41 % compared to a reference solution that

42 % does not depend on n.



45 % n.

46 % nRef - an integer that defines the degrees of

47 % freedom that are used by the funtion

48 % singLayPot in order to compute the

49 % reference solution

50 % markers - a cell array containing formatting

51 % strings. As the function might be

52 % called not only for one integer p,

53 % but for an array of integers as

54 % well , the error plot might contain

55 % different graphs. In

56 % order to distinguish these graphs ,

57 % the cell array markers has to

58 % contain formatting strings to

59 % specify the markers for the plot;

60 % for each value contained in p,

61 % markers must contain a string

62 % markerSizes - a cell array containing integers to

63 % specifiy the markers that are used

64 % in the error plot; markerSizes

65 % must contain one integer for each

66 % value of p.

67 %

68 % Outputs:

69 % no outputs


70 %

71 % Examples:



74 % x = [1,3; 1,1; 1,0];

75 % p = [3,6,9];

76 % markers = ’-o’, ’-x’, ’-s’;

77 % markerSizes = 2,6,3;

78 % n = 3:30;

79 % nRef = 200;

80 % plotDecreasingError(gamma , x, p, n, nRef , ...


82

83

84 % compute a reference solution to compare the other

85 % solutions with

86 slpRef = singLayPot(gamma , x, max(p), nRef);

87

88 % initialize a vector to store the errors

89 err = zeros(length(p), length(n));

90

91 start = ones(length(p) ,1);

92 for l = 1: length(n);

93 for k = 1: length(p)

94 % note that n(l) must be greater than p(k) to use

95 % the function singLayPot

96 if(n(l) >= p(k))

97 % compute and store the error

98 err(k, l) = cmpSlpToRef(gamma , ...

99 x, p(k), n(l), slpRef);

100 else

101 start(k) = l + 1;

102 end

103 end

104 end

105

106 % plot the results

107 hold off


109 semilogy(n(start(k):end), err(k, start(k):end), ...

110 markersk, ’MarkerSize ’, markerSizesk);

111 %text(n(start(k)), err(k, start(k)), ...

112 % [’ p=’, int2str(p(k))]);


113 if(k == 1)



116 end

117 hold on

118 end

119 % plot legend

120 info = cell(length(p) ,1);

121 for k=1: length(p)

122 infok = strcat(’p=’, int2str(p(k)));

123 end

124 plotLegend = legend(info , length(p));

125 set(plotLegend ,’Interpreter ’,’none’)

Wiederum fuhren wir die Testfunktion fur alle Beispielsituationen auf, die wir in Ab-bildung 5.1.1 gesehen hatten. Dazu erinnern wir daran, dass die Beispiele in Abbil-dung 5.1.1 vom Matlab-Skript SomeExamplePoints (Listing 5.1.1 im Anhang) er-zeugt wurden. Wir andern dieses Skript ein wenig ab: Fur jedes der sechs Beispiele er-setzen wir die Befehle zum Plotten der Kurve und der Punkte durch einen Aufruf derFunktion plotDecreasingError. Das geanderte Skript gibt dann - in der selben Rei-henfolge wie in Abbildung 5.1.1 - die Fehlerkurven aus, die von plotDecreasingErrorberechnet wurden. Das Skript ist unter dem Namen DecreasingError in ListingB.1.10 im Anhang zu finden. In Abbildung 5.4.1 sehen wir das Ergebnis, dass wirerhalten, wenn wir die Fehlerkurven in derselben Reihenfolge wie in Abbildung 5.1.1plotten.Wir machen die folgenden Beobachtungen:

• Erwartungsgemaß liegt das Ergebnis fur lineare Kurven bereits ab n = p imBereich der Maschinengenauigkeit.

• Fur die Parabel und die Halbellipse besitzt die Fehlerkurve in der in Abbildung5.4.1 dargestellten Skalierung naherungsweise einen linearen Verlauf. Da dieFehler-Achse logarithmisch skaliert ist, konnen wir feststellen, dass das vonsingLayPot berechnete Ergebnis mit steigendem Freiheitsgrad exponentiellkonvergiert.

• Die Abweichung scheint im Falle der Parabel schneller abzunehmen, als bei derHalbellipse. Wie auch in Abschnitt 5.3 stellen wir fest, dass die Fehlerkurvenweniger gleichmaßig verlaufen, wenn wir Punkte nahe der Kurve betrachten.Auch die Konvergenzgeschwindigkeit ist in diesem Fall sowohl bei der Parabelals auch bei der Ellipse langsamer.

• Weiterhin fallt auf, dass die Steigung der Fehlerkurve in jedem der betrachte-ten Falle nicht wesentlich vom maximalen Basis-Polynomgrad p abzuhangenscheint. Die Wahl eines großeren p verschiebt die Fehlerkurve zwar weiter nachrechts, scheint deren Steigung jedoch nicht zu beeinflussen.


Abb. 5.4.1: Abnahme der Abweichung zwischen dem Ergebnis von singLayPot und

einer Referenzmatrix bei steigender Anzahl von Freiheitsgraden

Die letztgenannte Beobachtung veranlasst uns dazu, nun einen zweiten Blickwinkeleinzunehmen: Wir wollen uns den maximalen Polynomgrad p und eine Fehlerschran-ke tol vorgeben. Wir stellen dann die Frage, wieviele Freiheitsgrade n wir benotigen,damit der Unterschied zwischen dem Ergebnis mit n Freiheitsgraden und dem Er-gebnis mit nRef Freiheitsgraden kleiner als tol wird. Den Fehler messen wir erneutmit der Funktion cmpSlpToRef , die wir in Listing 5.1.1 aufgefuhrt hatten. Wir im-plementieren diesen Test in der Matlab-Funktion plotRequiredDim. Sie ist analogzur Funktion plotDecreasingError (Listing 5.4.1) aufgebaut, erhalt allerdings alsweiteren Ubergabeparameter den Wert tol. Fur jede Belegung fur den maximalenPolynomgrad p wird die Funktion singLayPot sukzessive mit den Eintragen desVektors n als Zahl der Freiheitsgrade aufgerufen - so lange bis der Unterschied zumReferenzwert kleiner als tol wird. Zuletzt wird ein Plot ausgegeben, der fur jedes pdie Anzahl der Freiheitsgrade zeigt, die benotigt wurden, um die Fehlerschranke tolzu unterschreiten. Weil jeweils nur ein Graph ausgegeben wird, mussen der Funkti-on keine Parameter zur Formatierung der Ausgabe ubergeben werden. Die FunktionplotRequiredDim ist in Listing 5.4.2 aufgefuhrt.

Listing 5.4.2: MatlabMatlabMatlab-Funktion plotRequiredDim.m

1 function plotRequiredDim(gamma , x, p, n, nRef , tol)

2 % PLOTFREQUIREDDIM Computes the number of degrees of


3 % freedom that are required by the function

4 % SINGLAYPOT to reach a precision defined by tol

5 % Compute the single layer potential of a curve gamma

6 % at two -dimensional points x by use of the function

7 % SINGLAYPOT with various degrees of freedom. The

8 % function SINGLAYPOT is also used to compute a

9 % reference solution , using a much higher degree of

10 % freedoms. The results for various degrees of freedom

11 % are compared to this reference solution by the

12 % function cmpSlpToRef. The degrees of freedom will be

13 % increased until the difference to the reference

14 % solution is lower than tol.

15 % This procedure is repeated for different values p

16 % that defines the maximal polynomial degree for which

17 % the single layer potential is computed. Afterwards ,

18 % the required degree of freedom is plottet as a

19 % function of p.

20 %

21 % Usage: plotRequiredDim(gamma , x, p, n, nRef , tol)

22 %

23 % Inputs:







30 % these points.

31 % p - an array of increasing integers that

32 % define the degrees of

33 % P_j; if k is an integer contained in the

34 % array p, the single layer potential will

35 % be computed for the Legendre Polynmoials



38 % are contained in the array p.





43 % of n in order to compare the output to

44 % the reference solution that is computed

45 % with nRef degrees of freedom. For each


46 % integer k contained in p, the function

47 % will find the lowest number N in n, such

48 % that the difference of the single layer

49 % potential (computed with N degrees of

50 % freedom) and the reference solution is

51 % lower than tol

52 % nRef - an integer defining the degrees of freedom

53 % that are used by the function singLayPot

54 % to computed the reference solution

55 % tol - a double representing an error tolerance;

56 % this tolerances defines the required

57 % precision that must be reached by the

58 % wanted degrees of freedom

59 %

60 % Outputs:

61 % no outputs

62 %

63 % Examples:



66 % x = [1,3; 1,1; 1,0];

67 % p = 5:5:25;

68 % n = 10:2:100;

69 % nRef = 300;

70 % tol = 10^-9;

71 % plotRequiredDim(gamma , x, p, n, nRef , tol)

72

73


75 % solutions with


77 maxN = max(n);

78 requiredN = maxN * ones (length(p) ,1);

79

80 % now , for each p the lowest n is computed such that the

81 % difference to the reference solution is lower than tol;

82

83 % note that it is not relevant for the computation how the

84 % loops over n and p are arranged; yet it is more

85 % efficient to iterate over n in the outer loop in order

86 % to avoid unnessecary re-computations of diagTz(n)




89 if(n(l) >= p(k) && n(l) < requiredN(k))

90 err = cmpSlpToRef(gamma , x, ...

91 p(k), n(l), slpRef);

92 if(err <= tol)

93 requiredN(k) = n(l);

94 end

95 end

96 end

97 end

98

99 % plot hte results

100 hold off

101 plot(p, requiredN , ’-s’, ’MarkerSize ’, 3);

102 ylabel(’Erforderliche Freiheitsgrade ’)

103 xlabel(’Laenge der Fourierentwicklung ’)

Auch diesen Test fuhren wir nicht nur fur eine Kurve, sondern fur alle in Abbil-dung 5.1.1 dargestellten Beispielsituationen durch. Wie in den vorangehenden Testsmussen wir hierzu lediglich das Skript SomeExamplePoints, das in Listing B.1.4 imAnhang angefuhrt ist, so abandern, dass fur jede erzeugte Beispielsituation die Funk-tion plotRequiredDim aufgerufen wird. Dieses abgeanderte Matlab-Skript kann un-ter dem Namen RequiredDim in Listing B.1.12 im Anhang nachgeschlagen werden.Als Ausgabe erzeugt es diejenigen Plots, die in Abbildung 5.4.2 dargestellt sind.Bei der Interpretation der Ergebnisse muss zunachst die folgende Ungenauigkeit be-achtet werden: In den Abbildungen 5.3.1 und 5.4.1 hatte sich bereits angedeutet, dassdie Konvergenz des Ergebnisses von singLayPot mit steigendem Freiheitsgrad nichtganz gleichmaßig verlauft; stattdessen treten immer wieder kleine Abweichungen inden Fehlerkurven auf und teilweise kann es sogar vorkommen, dass der Fehler fureinen geringfugig hoheren Freiheitsgrad kurzzeitig ansteigt, bevor er weiter abfallt.Bei der Implementierung der Funktion plotRequiredDim in Listing 5.4.2 haben wirdiesen Effekt vernachlassigt und die Suche nach einem genugend großen n beendet,sobald die vorgegebene Fehlerschranke zum ersten Mal unterschritten wurde. DieseUngenauigkeit lasst sich rechtfertigen, da die Abbildungen 5.3.1 und 5.4.1 zeigten,dass ein zwischenzeitiger Anstiegs des Fehlers nur uber sehr wenige Freiheitsgradehinweg stattfindet, bevor der Fehler weiterfallt.

Nun wollen wir die Ergebnisse in Abbildung 5.4.2 interpretieren. Der einfachstenFall bildet erneut die lineare Kurve. Wie wir schon zuvor gesehen hatten, ist dieGenauigkeit der Berechnung hier schon ab n = p im Bereich der Maschinengenaugi-keit. Deshalb erhalten wir in Abbildung 5.4.2 (unabhangig von der Lage der Punktex) zwei Ursprungsgeraden.

Auch fur die Parabel und die Halbellipse erhalten wir eine Gerade, jedoch mit positi-vem Achsenabschnitt a. Beachten wir die jeweilige lineare Skalierung der Achsen, sostellen wir fest, dass alle diese Geraden naherungsweise die Steigung 1 besitzen. Furdie Berechnung des Einfachschichtpotentials mit einer vorgegebenen Genauigkeitbedeutet dies: Es genugt, die Anzahl der Freiheitsgrade um eine Konstante a großer


0 50 1000

20

40

60

80

100

Erf

orde

rlich

e F

reih

eits

grad

e

Laenge der Fourierentwicklung0 50 100

20

40

60

80

100

Erf

orde

rlich

e F

reih

eits

grad

e


40

60

80

100

120

Erf

orde

rlich

e F

reih

eits

grad

e

Laenge der Fourierentwicklung

0 50 1000

20

40

60

80

100

Erf

orde

rlich

e F

reih

eits

grad

e


0

50

100

150E

rfor

derli

che

Fre

ihei

tsgr

ade


60

80

100

120

140

160

Erf

orde

rlich

e F

reih

eits

grad

e

Laenge der Fourierentwicklung

Abb. 5.4.2: Notwendige Anzahl an Freiheitsgraden, damit singLayPot die Abwei-

chung von 10−12 zu einem Vergleichergebnis unterschreitet

zu wahlen, als den gewunschten maximalen Basispolynomgrad p. Diese Konstantea ist der Achsenabschnitt in den jeweiligen Fehlerdiagrammen. Sie hangt offenbarvon der Wahl der Kurve γ und der Auswertungspunkte x ab; in unseren Tests istsie jedoch unabhangig von p selbst.Wir zu erwarten ist der Achsenabschnitt a bei der Halbellipse hoher als bei derParabel; ebenso nimmt a einen hoheren Wert an, wenn wir Auswertungspunkte xbetrachten, die nahe an der Kurve γ liegen.

In Anbetracht dieses Zusammenhangs zwischen dem maximalen Polynomgrad p undden erforderlichen Freiheitsgraden n ware eine automatisierte Berechnung de Ach-senabschnitts a wunschenswert. Selbst wenn wir fur feste Kurven einen einfachenZusammenhang zwischen der vorgegebenen Fehlertoleranz tol und dem Achsenab-schnitt a finden sollten, kommen wir diesem Ziel aber nicht wirklich naher: Augrundder großen Klasse an rationalen Kurven erscheint es kaum moglich, empirisch einenquantitativen Zusammenhang zwischen dem jeweiligen Kurvenverlauf und dem Ach-senabschnitt a zu erkennen. Fur eine zukunftige Automatisierung kommen deshalbzwei Vorgehensweisen in Frage:

• Jeweils fur kleine Klassen von rationalen Kurven konnte es moglich sein, einenZusammenhang zwischen dem Kurvenverlauf und Achsenabschnitt a auch aufempirischem Wege zu entdecken. Ein Beispiel fur einen solchen Sepzialfallkonnten quadratisch interpolierte Kurven sein.

• Moglicherweise kann eine theoretische Fehleranalyse einen allgemeinen Zusam-menhang zwischen dem Kurvenverlauf, der Lage der Auswertungspunkte und

Abschnitt 5.5: Theoretische und numerische Ergebnisse auf dem Einheitskreis 59

der Konvergenz unseres Algorithmus offenlegen. Dazu mussten die beiden Feh-lerterm, die in Satz 5.1.1 auftreten, theoretisch untersucht werden.

5.5 Theoretische und numerische Ergebnisse auf

dem Einheitskreis

In den beiden vorangehenden Abschnitten haben wir das Einfachschichtpotentialeiner Kurve jeweils nur an wenigen beispielhaften Punkten ausgewertet. Dabei ha-ben wir unter anderem festgestellt, dass die Ergebnisse in der Nahe der Kurve stetsetwas schlechter ausfallen, als in großerer Entfernung von der Kurve. Nun wollenwir an einem Beispiel nochmals genauer untersuchen, wie sich der Fehler bei derBerechnung des Einfachschichtpotentials in Abhangigkeit von der Lage des Auswer-tungspunktes verhalt. Als Kurve verwenden wir hierfur den Einheitskreis und wirbetrachten lediglich das nullte Legendre-Polynom, da sich das Einfachschichtpoten-tial einer konstanten Funktion auf dem Einheitskreis leicht angeben lasst. Es giltnamlich

(V 1)(x) =

0 |x| ≤ 1,1

2πlog |x| |x| > 1.

(5.3)

Die Funktion slpOnDiskExact, die in Listing 5.5.1 aufgefuhrt ist, implementiertdiese Formel. Wir ubergeben ihr als Parameter zwei Matrizen xx, yy, die mit derMatlab-Funktion meshgrid erzeugt wurden; fur alle Punkte auf diesem Gitter be-rechnet slpOnDisk das Einfachschichtpotential der konstanten 1-Funktion auf demEinheitskreis und speichert die Werte in einer Ruckgabematrix zz.

Listing 5.5.1: MatlabMatlabMatlab-Skript slpOnDiskExact.m

1 function zz = slpOnDiskExact(xx, yy)

2 % SLPONDISKEXACT Computes the exact single layer

3 % potential of a constant function on

4 % the unit disk

5 % Evaluate the analytical result for the single layer

6 % potential of the constant 1-Function on the unit disk

7 % which is 0 inside the disk an a log -Function outside

8 % the disk. The values are evaluated on a meshgrid

9 %

10 % Usage: zz = slpOnDiskExact(xx, yy)

11 %

12 % Inputs:

13 % xx - a matrix representing the x-components of a

14 % meshgrid

15 % yy - a matrix representing the y-components of a


16 % meshgrid

17 %

18 % Outputs:

19 % zz - a matrix containing the single layer

20 % potentials on the input -meshgrid

21 %

22 % Example:

23 % sx = linspace(-2, 2, 101);

24 % sy = linspace(-2, 2, 101);

25 % [xx , yy] = meshgrid(sx, sy);

26 % zz = slpOnDiskExact(xx , yy);

27 % surf(xx , yy , zz);

28 %

29

30 N1 = size(xx, 1);

31 N2 = size(xx, 2);

32 zz = zeros(size(xx));

33

34 for k=1:N1

35 for l=1:N2

36 sqNrm = xx(k,l)^2 + yy(k,l)^2;

37 if(sqNrm > 1)

38 zz(k,l) = log( sqNrm ) / (4*pi);

39 else

40 zz(k,l) = 0;

41 end

42 end

43 end

Die Funktion slpOnDisk, die in Listing 5.5.2 aufgefuhrt ist, fuhrt diesselbe Berech-nung mit Hilfe der Funktion singLayPot aus. Allerdings kann ihr noch ein Parametern ubergeben werden; dieser legt die Freiheitsgrade fest, mit denen slpOnDisk dieFunktion singLayPot aufruft.

Listing 5.5.2: MatlabMatlabMatlab-Skript slpOnDisk.m

1 function zz = slpOnDisk(xx, yy, n)

2 % SLPONDISK Computes the single layer potential of a

3 % constant function on the unit disk

4 % numerically

5 % Compute the single layer potential of the constant


6 % 1-Function on the unit disk by use of the function

7 % SINGLAYPOT

8 %

9 % Usage: zz = slpOnDisk(xx, yy, n)

10 %

11 % Inputs:


13 % meshgrid


15 % meshgrid


17 % operator submatrix used by the function

18 % SINGLAYPOT. Increasing the n will improve

19 % the approximation of the computed

20 % potential.

21 %

22 % Outputs:



25 %

26 % Example:

27 % sx = linspace(-2, 2, 101);

28 % sy = linspace(-2, 2, 101);

29 % [xx, yy] = meshgrid(sx, sy);

30 % zz = slpOnDisk(xx, yy, 15);

31 % surf(xx, yy, zz);

32 %

33

34 N = size(xx, 2);


36

37 disk = createEllipse (1,1,1);

38

39 for k=1:N

40 zz(:, k) = singLayPot(disk1, ...

41 [xx(:,k), yy(:, k)], 0, n);

42 zz(:, k) = zz(:,k) + singLayPot(disk2, ...

43 [xx(:,k), yy(:, k)], 0, n);

44 end

45

46 zz = sqrt (2) * zz / (2*pi);


Zur Veranschaulichung zeigen wir einen Plot dieses Einfachschichtpotentials. Da-zu erzeugen wir mit der Matlab-Funktion meshgrid ein Gitter, berechnen auf die-sem Gitter das Einfachschichtpotential mit Hilfe der Funktion slpOnDiskExactund zeichnen das Ergebnis auf dem Gitter mit Hilfe der Matlab-Funktion surf .Wir haben dieses Vorgehen im Matlab-Skript PlotSlpOnDisk implementiert. DasSkript kann im Anhang in Listing B.1.15 nachgeschlagen werden. Der vom SkriptPlotSlpOnDisk erzeugte Plot ist in Abbildung 5.5.1 abgedruckt.

Abb. 5.5.1: Einfachschichtpotential der konstanten 1-Funktion auf dem Einheitskreis

Wenn wir stattdessen den numerichen Wert fur das Einfachschichtpotential abbil-den wollen, den die Funktion singLayPot berechnet, brauchen wir lediglich denAufurf der Funktion slPOnDiskExact zu einem Aufruf der Funktion slpOnDiskabzuandern und eine Zahl n ∈ N0 als Parameter zu ubergeben, die die Anzahl derFreiheitsgrade bei der numerischen Berechnung festlegt (vgl. Listing 5.5.2, in demdie Funktion slpOnDisk aufgefuhrt ist). Fur großere Zahlen n lasst sich das Ergeb-nis jedoch optisch nicht vom Ergebnis der exakten Berechnung unterscheiden. Wirverzichten deshalb auf einen Abdruck und plotten stattdessen die Differenz zwischendem exakten Wert und den Ergebnissen, die singLayPot uns zuruckgibt.

Listing 5.5.3 zeigt die Matlab-Funktion plotErrorOnDisk. Sie erwartet einmit der Matlab-Funktion meshgrid erzeugtes Gitter und eine Zahl n alsUbergabeparameter. Auf diesem ubergebenen Gitter berechnet sie einmal die ex-akten Werte des Einfachschichtpotenials mit Hilfe der Funktion slpOnDiskExactund einmal die numerischen Ergebnisse von singLayPot mit Hilfe der FunktionslpOnDisk. Dabei legt der Parameter n die Anzahl der Freiheitsgrade beim Aufruf


von singLayPot fest. Anschließend wird die Differenz der Werte gebildet und derAbsolutbetrag der Differenz in einem Plot ausgegeben.

Listing 5.5.3: MatlabMatlabMatlab-Funktion plotErrorOnDisk.m

1 function plotErrorOnDisk(xx, yy, n)

2 % PLOTERRORONDISK Computes the single layer potential of

3 % a constant function on the unit disk

4 % numerically by use of the SINGLAYPOT and

5 % plots the error



8 % SINGLAYPOT. The exact solution is computed by the

9 % function SLPONDISKEXACT. Afterwards , the error is

10 % plottet in a 3D surface plot

11 %

12 % Usage: plotErrorOnDisk(xx, yy, n)

13 %

14 % Inputs:


16 % meshgrid


18 % meshgrid





23 % potential.

24 %

25 % Outputs:

26 % no outputs

27 %

28 % Example:

29 % sx = linspace(-2, 2, 101);

30 % sy = linspace(-2, 2, 101);


32 % plotErrorOnDisk(xx, yy, 15)

33

34

35 % compute the single layer potential on the grid

36 % analytically

37 zzA = slpOnDisk(xx , yy , n);


38


40 % numerically

41 zzB = slpOnDiskExact(xx , yy);

42

43 % plot the error

44 surf(xx , yy , abs(zzA - zzB));

45

46 % compute and display the maximum error on the grid

47 maxErr = max(max(abs(zzA -zzB)));

48 display(maxErr)

Abbildung 5.5.2 zeigt den Fehlerplot fur verschiedene Freiheitsgrade n, die der Funk-tion singLayPot von der Funktion slpOnDisk ubergeben wurden. Die Abbildungkann mit Hilfe des Skriptes ErrorOnDisk erzeugt werden, dass im Anhang in Lis-ting B.1.17 aufgefuhrt ist. In diesem Skript wird die Funktion plotErrorOnDiskmehrmals mit unterschiedlichen Belegungen fur n aufgerufen und die Fehlergraphi-ken mit Hilfe der Matlab-Funktion subplot gemeinsam dargestellt.

Abb. 5.5.2: Fehler bei der numerischen Berechnung des Einfachschichtpotentials der

konstanten 1-Funktion auf dem Einheitskreis

Auch in diesem Beispiel bestatigen sich unsere vorherigen Beobachtungen. Das Er-gebnis von singLayPot konvergiert auf dem gesamten abgebildeten Gitter; in derNahe der Kreislinie ist die Konvergenz jedoch deutlich langsamer als weiter innerhalb


oder außerhalb des Kreises. Wir erkennen dies am Fehlergebirge, dass sich entlangder Kreislinie deutlich erhebt.

Dennoch erkennen wir an der Skalierung der Fehlerachse, dass der maximale Fehlerauf dem gesamten von uns gewahlten Gitter mit steigendem n gegen die Maschi-nengenauigkeit fallt. Fur n = 40 ist der maximale Fehler kleiner als 10−14 - auch inder Nahe des Kreises. Die Gitterpunkte in Abbildung B.1.17 besitzen untereinanderden Abstand 0.04. Ein interessanter Effekt tritt auf, wenn wir weitere Verfeine-rungen fur das Gitter testen. In Abbildung 5.5.3 sehen wir den Fehler auf einemkleinen Ausschnitt des Kreises mit wesentlich feinerem Gitter. Die Abbildung kannmit dem Matlab-Skript ErrorOnDiskRefined erzeugt werden; dieses Skript kannim Anhang in Listing B.1.18 nachgeschlagen h

Abb. 5.5.3: Fehler bei der numerischen Berechnung des Einfachschichtpotentials der

konstanten 1-Funktion auf dem Einheitskreis

Wir stellen fest, dass der Fehler in der Nahe des Kreises nicht unter den Wert 10−8

sinkt; selbst wenn wir die ubergebene Anzahl an Freiheitsgraden stark erhohen, trittderselbe Effekt auf. Andererseits hangt der maximale Fehler sehr stark vom Gitterab. Lasst man das Testskript ErrorOnDiskRefined mit mehreren unerschiedlichfeinen Gittern laufen, so erkennt man schnell starke Schwankungen im maximalenFehler nahe der Kurve, die aber alle in der Großenordnung 10−8 oder kleiner liegen.


5.6 Lineare Approximation einer Halbellipse

Zum Abschluss dieses Kapitels wollen wir noch an einem Beispiel untersuchen, wel-chen Vorteil uns die Moglichkeit bringt, das Einfachschichtpotential auch fur ratio-nale Kurven zu berechnen. Hierfur berechnen wir das Einfachschichtpotential einerHalbellipse auf zwei verschiedene Methoden: Einmal beschreiben wir die Kurve exaktdurch rationale Funktionen und berechnen das Einfachschichtpotential anschließendmit einer hohen Anzahl an Freiheitsgraden, um ein moglichst exaktes Ergebnis zuerhalten; zum Vergleich approximieren wir die Kurve durch einen Polygonzug undberechnen das Einfachschichtpotential dieser Naherungskurve. Wir verfeinern denPolygonzug mehrmals, um eine bessere Approximation zu erhalten und beobachten,wie sich der Wert des Einfachschichtpotentials dem Wert fur die rationalen Kurveannahert.Das Matlab-Skript PolygonV sSmooth in Listing 5.6.1 fuhrt alle Berechnungen mitder Funktion singLayPot fur n = 50 Freiheitsgrade durch. Es erzeugt eine Halbel-lipse und wahlt ein Gitter mit mehreren Punkten x ∈ R2 aus. In einem ersten Schrittwird dann das Einfachschichtpotential uber der gegebenen Kurve mit der Funkti-on singLayPot berechnet. In einem zweiten Schritt wird die Funktion sepCurvesaufgerufen. Sie ist im Anhang in Listing A.2.7 aufgefuhrt und approximiert dieubergebene Kurve durch ein Polygon mit der ubergebenen Anzahl an Ecken.Man beachte hierbei, dass sepCurves das Parameterinterval der ubergebenen Kurvegleichmaßig unterteilt. Ist die Ableitung der Kurve nicht konstant normiert, so wirddie Bogenlange also nicht gleichmaßig aufgeteilt. Fur einen rational interpoliertenHalbkreis bedeutet das zum Beispiel, dass die Unterteilung am Anfang und Endedes Halbkreise wesentlich feiner ist, als in seiner Mitte.Nun berechnet die Funktion PolygonV sSmooth fur jedes Streckenstuck innerhalbdes Polygonzuges das Einfachschichtpotential und addiert die Werte auf. Man be-achte, dass diese einfache Methode nur fur das Einfachschichtpotential des nulltenLegendre-Polynoms P0 funktionieren kann, da unsere Basis-Polynome nicht auf derKurve, sondern auf deren Parameterinterval definiert sind. Durch eine Unterteilungder Kurve wurden wir somit vollig andere Funktionen auf den Parameterintervallender Teilkurven erhalten.Der Einfachkeithalber beschranken wir uns im Skript PolygonV sSmooth deshalbdarauf, das Einfachschichtpotential des nullten Legendre-Polynoms P0 zu betrachtenund ubergeben der Funktion singLayPot als Parameter fur den maximalen Poly-nomgrad nur p = 0. Wir berechnen dann den maximalen Unterschied zwischen demnumerischen Ergebnis fur die rational interpolierte Kurve und dem aggregierten nu-merischen Ergebnis fur den Polygonzug. Dieses Vorgehen wiederholen wir fur einesteigende Anzahl von Polygon-Ecken und speichern jedes mal den maximalen Fehler.

Listing 5.6.1: MatlabMatlabMatlab-Skript PolygonVsSmooth.m

1 clear all

2

3 % create some curve

4 ellipse = createEllipse (1, 2, 1);

Abschnitt 5.6: Lineare Approximation einer Halbellipse 67

5 gamma = ellipse 1;

6

7 % choose size of the grid to create a polygon that

8 % approximates gamma

9 N = [2 ,4 ,8 ,16 ,32 ,64 ,128 ,256 ,512];

10 % choose n to specify the precision of the functional

11 % calculus approximation

12 n = 50;

13

14 % create a grid of points to evaluate the single layer

15 % potential of P_0 on these points

16 sx = linspace (-0.3, 1.3, 20);

17 sy = linspace (-0.3, 1.3, 20);

18 [xx, yy] = meshgrid(sx, sy);

19 zzGamma = zeros(size(xx));

20 n2 = size(xx , 2);

21

22 % create a vector to store zu maximum difference on the

23 % grid for each N

24 diff = zeros(length(N), 1);

25

26 for k=1: length(N)

27 % approximate gamma by a polygon

28 polygon = sepCurves ( gamma, N(k));

29

30 % compute single layer potential on the polygon and on

31 % gamma

32 zzPolygon = zeros(size(xx));

33 for j=1:n2

34 zzGamma(:, j) = singLayPot(gamma , [xx(:,j), ...

35 yy(:, j)], 0, n);

36 % sum up single layer potenials on the polygon

37 for l=1:N(k)

38 zzPolygon(:, j) = zzPolygon (:, j) + ...

39 singLayPot(polygonl, [xx(:,j), ...

40 yy(:, j)], 0, 1);

41 end

42 end

43

44 % compute the maximum distance of the single layer

45 % potentials of gamma and the polygon

46 diff(k) = max(max(abs(zzGamma - zzPolygon)));

47 end


48

49 % plot errors

50 hold off

51 loglog(N, diff , ’-s’, ’MarkerSize ’, 3);


53 xlabel(’Ecken des Polygons ’)

Zuletzt tragen wir in einer Graphik die maximale Abweichung auf dem Gitter gegendie Anzahl der Polygonecken auf. Als Ausgabe erhalten wir die in Abbildung 5.6.1dargestellt Graphik.

Abb. 5.6.1: Annaherung des Einfachschichtpoten-

tials eines Polygonzugs an das Einfachschichtpo-

tential einer durch ihn approximierten Ellipse

In Abbildung 5.6.1 sind bei-de Achsen logarithmisch ska-liert und wir erhalten als Feh-lerkurve eine fallende Gerade.Einerseits folgt somit, dass derFehler nicht exponentiell, son-dern lediglich polynomiell fallt.Andererseits konnen wir an-hand der Achsenbeschriftungabschatzen, dass er zumindestuberlinear abnimmt. Intuitivließ sich zumindest die unter-exponentielle Fehlerverlauf ver-muten: Die Bogenlange des Po-lygons nahert sich unterexpo-nentiell an die der Ellipse an.Intepretieren wir die Situati-on zum Beispiel im Sinne derEletkrostatik, so bedeutet dies,dass die Gesamtladung der Mo-nopolschicht auf dem Polygonsich unterexponentiell an dieGesamtladung auf der Ellipse

annahert.

Kapitel 6

Die Berechnung der

Galerkinmatrix

Nach dem wir im vorangehenden Kapitel 4 einen Algorithmus zur Berechnung desEinfachschichtpotentials hergeleitet und implementiert haben, wollen wir nun einenSchritt weiter gehen und die Eintrage der Galerkinblocke berechnen. Die Eintrageeines Galerkinblocks A := Ak0j0 haben nach Formel (2.5) die Form

Akj =

1∫−1

Pk(s)|γk0(s)|(V ϕj0j)(γk0(s)) ds.

Mit der Matlab-Funktion singLayPot, die wir in Abschnitt 4.5 vorgestellt haben,sind wir in der Lage, das Einfachschichtpotential V ϕj0j an beliebigen Punkten γk0(s)zu berechnen. Wir mussen nun die Basispolynome Pk(s) an das Einfachschichtpo-tential multiplizieren und anschließend das Kurvenintegral bilden. Da der Integrandstetig und beschrankt ist, konnten wir beispielsweise versuchen, die Integrale perQuadratur zu berechnen. Problematisch konnte hier wiederum das starke Alternie-ren der Legendre-Polynome Pj fur einen hohen Polynomgrad j sein.An dieser Stelle wollen wir aber einen anderen Algorithmus zur Berechnung der Ga-lerkinblocke vorschlagen, der erneut die Operatormatrix aus Satz 4.2.1 verwendet.Im ersten Unterabschnitt dieses Kapitels werden wir den Algorithmus herleiten undimplementieren; im zweiten Unterabschnitt werden wir dann zwei einfache Testbei-spiele geben.

6.1 Darstellung der Galerkinblocke mit Hilfe ei-

ner Fourierentwicklung

Wir leiten in diesem Abschnitt ein Verfahren zur Berechnung der Galerkineintrageher, welches ohne Quadratur auskommt und stattdessen die Ergebnisse aus denAbschnitten 4.2 und 4.4 ausnutzt.Wir erinnern noch einmal daran, dass die Eintrage des Galerkinblocks A = Ak0j0

durch die Formel

Akj =

1∫−1

Pk(s)|γk0(s)|(V ϕj0j)(γk0(s)) ds

gegeben sind. Weil wir die Legendre-Polynome Pk so normiert hatten, dass sie ei-ne Orthonormalbasis des L2 bilden (vgl Abschnitt 4.2), sind die Zahlen (Akj)k∈N0

70 Kapitel 6: Die Berechnung der Galerkinmatrix

gerade die Fouirerkoeffizienten der Funktion |γk0(s)|(V ϕj0j)(γk0(s)) bezuglich dieserOrthonormalbasis. Wir suchen deshalb nach einer Moglichkeit, die Fourierkoeffizi-enten einer stetigen Funktion effizient zu berechnen.Interessanterweise erhalten wir einen Ansatz zur Berechnung der Fourierkoeffizien-ten, wenn wir nochmals den Satz 4.2.1 aus Abschnitt 4.2 betrachten. Wir habendort eine Darstellung der Operatormatrix Tf fur eine messbare, beschrankte Funk-tion f gegeben. Als einfaches Korrolar dieses Satzes erhalten wir eine Darstellungder Fourierkoeffizienten von f :

Satz 6.1.1. Sei f : [−1, 1] → C messbar und beschrankt. Wie in Satz 4.2.1 be-

zeichnen wir mit f die Folge der Fourierkoeffizienten von f ; weiter sei e0 der nullte

Einheitsvektor in `2. Dann gilt f =√

2 Tfe0, dass heißt, die Folge der Fourierkoeffi-

zienten von f ist, bis auf den Faktor√

2, gerade die nullte Spalte der Operatormatrix

Tf .

Beweis. Wir erinnern daran, dass P0 = 1√2

gilt. Aus der Darstellung von Tf in Satz

4.2.1 folgt dann unmittelbar, dass die nullte Spalte von Tf gleich 1√2f ist.

Falls wir in der Lage sind, die erste Spalte von Tf effizient zu berechnen, dann liefertuns dieser Satz eine Alternative zur Quadratur, um die Zahlen Akj zu berechnen.Wir haben in Abschnitt 4.4 eine Moglichkeit angegeben, um fur die endliche MatrixT

(n)f = πnTfπn eine Naherungsmatrix T

(n)f zu berechnen. Die zugrundeliegende Idee

konnen wir auch nutzen um nur die erste Spalte der Matrix Tf naherungsweise zubestimmen. Zunachst fuhren wir hierfur eine Notation ein, die sich an die Notationaus Abschnitt 4.4 anlehnt.

Notation 6.1.2. Fur n ∈ N sei πn : `2 → `2 die orthogonale Projektion auf den

endlichen Unterraum span(e0, ..., en). Ist f : [−1, 1] → C eine stetige Funktion und

f ∈ `2 die Folge ihrer Fourierkoeffizienten, dann setzen wir f (n) := πnf , das heißt,

der Vektor f (n) enthalt die ersten n+ 1 Fourierkoeffizienten von f .

Wir wissen aus Satz 6.1.1, dass f =√

2Tfe0 gilt. Somit folgt

f (n) = πnf =√

2πnTfe0 =√

2πnTfπne0 =√

2T(n)f e0. (6.1)

In Abschnitt 4.4 haben wir gesehen, dass wir anstelle von T(n)f eine Naherung T

(n)f

berechnen konnen. Motiviert durch die Formel (6.1) verwenden wir diese Naherungauch hier:

Naherung 6.1.3. Wir setzen f (n) :=√

2T(n)f e0 und verwenden f (n) als Naherung

fur f (n).

Somit enthalt der Vektor f (n) eine Naherung der ersten n + 1 Fourierkoeffizientenvon f . Naturlich ist der Fehler bei der Approximation von f (n) durch den Fehler beider Approximation von T

(n)f beschrankt:

Satz 6.1.4. Es sei f : [−1, 1]→ C stetig. Dann ist |f (n) − f (n)| ≤√

2|T (n)f − T (n)

f |.

Abschnitt 6.1: Darstellung der Galerkinblocke mit Hilfe einer Fourierentwicklung 71

Beweis. Wir subtrahieren die Definition von f (n) von der Formel (6.1) und erhalten

|f (n) − f (n)| = |√

2T(n)f e0 −

√2T

(n)f e0| ≤

√2|T (n)

f − T (n)f |.

In Abschnitt 4.4 haben wir in Satz 4.4.5 eine Darstellung fur T(n)f angegeben, die

uns eine Berechnung dieser Matrix ermoglicht. Wir konnen aus diesem Satz aucheine ahnliche Darstellung fur f (n) ableiten:

Satz 6.1.5. Sei f : [−1, 1] → C stetig. Es seien V,D wie in Satz 4.4.5, so dass

T(n)f = V DV T gilt. Dann ist f (n) =

√2V f(D)vT(0), wobei v(0) die erste Zeile von V

ist.

Beweis. Nach Konstruktion ist f (n) =√

2T(n)f e0, und aus Satz 4.4.5 folgt somit

f (n) =√

2V f(D)V T e0 =√

2V f(D)vT(0).

Die folgende Funktion berechnet den Galerkinblock zu den Kurven γk0 und γj0 ,in dem sie den gerade gezeigten Satz 6.1.5 gleichzeitig fur die Funktionen f =|γk0(s)|(V ϕj0j)(γk0(s)), j = 0, ..., p anwendet.

Listing 6.1.1: MatlabMatlabMatlab-Funktion galerkinBlock.m

1 function A = galerkinBlock(gammak0 , gammaj0 , p, n)

2 % GALERKINBLOCK Compute the galerkin block for two parts

3 % of the boundary

4 % Computes an approximation of the galerkin block of a

5 % required size for two parts of the boundary that are

6 % paremterized by rational curves. The galerkin block

7 % as computed by applying a functional calculus to the

8 % output of the function DIAGTZ.

9 %

10 % Usage: A = galerkinBlock(gammak0 , gammaj0 , p, n)

11 %

12 % Inputs:

13 % gammak0 - 2-by -2 cell array that represents a

14 % rational curve , see ... for

15 % explanation.

16 % gammaj0 - 2-by -2 cell array that represents a


18 % explanation.


20 % P_j; the integrals will be computed for

21 % the Legendre Polynmoials P_0 , ..., P_p.




24 % APPROXC and APPROXTF. It is required



27 % computed integrals.

28 %

29 % Outputs:

30 % coef - (p+1)-by -(p+1)-matrix that approximates

31 % the galerkin block

32 %

33 % Example:


35 % A11 = galerkinBlock(ellipse 1, ellipse 1, ...

36 % 50, 100);


38 % 50, 100);

39

40 A = zeros(n+1,p+1);

41 normk0 = normOfDeriv(gammak0);

42


44 slp = singLayPot(gammaj0 , evalPoints(gammak0 , d), p, n);

45

46 for j=1:p+1

47 tmp = normk0(d) .* slp(:,j);

48 A(:,j) = sqrt (2) * V * (tmp .* V(1,:) ’);

49 end

50 A = A(1:p+1,:);

An dieser Stelle sei darauf hingewiesen, dass wir auch eine Funktion galerkinMatriximplementiert haben, um die einzelnen Galerkin-Blocke zu einer Galerkinmatrixzusammenzufassen. Diese Funktion fuhrt jedoch nur Kopiervorgange aus, weshalbwir sie an dieser Stelle nicht naher erlautern und den Leser stattdessen auf ListingA.3.7 im Anhang A.3 verweisen.

6.2 Numerische Testergebnisse

Im Vergleich zu Kapitel 4 haben wir uns in Abschnitt 6.1 recht kurz gehalten undknapp aufgezeigt, dass sich die in Kapitel 4 entwickelten Methoden auch zur Be-rechnung der Galerkinmatrix auf rationalen Kurven einsetzen lassen. Entsprechend

Abschnitt 6.2: Numerische Testergebnisse 73

werden wir auch die numerischen Tests zu Abschnitt 6.1 kurzer fassen und uns dar-auf beschranken, die Konvergenz der Ergebnisse in Abhangigkeit von der Anzahl derFreiheitsgrade n anhand einiger Beispiele zu untersuchen. Wir verwenden hierzu imwesentlichen die selbe Vorgehensweise, mit der wir in Abschnitt 5.4 die Konvergenzder Ergebnisse von singLayPot untersucht hatten: Zunachst entscheiden wir uns fureinige Testkurven und wahlen den maximalen Basis-Polynomgrad p des Ansatzrau-mes aus. Anscchließend mussen wir uns auf eine Moglichkeit einigen, um den Unter-schied zwischen zwei Matrizen zu bestimmen, die wir mit unterschiedlicher Anzahlan Freiheitsgraden und somit mit unterschiedlicher Genaugikeit berechnet haben.Es ist naheliegend, hierfur die von der euklidischen Norm induzierte Operatornormzu verwenden; in Matlab kann sie mit der Funktion norm berechnet werden.Genau wie in Abschnitt 5.4 berechnen wir dann mit einer sehr hohen Anzahl anFreiheitsgraden nRef >> p ein Referenz-Ergebnis fur die Galerkin-Matrix, mitdem wir die Ergebnisse fur kleinere Freiheitsgrade p ≤ n < nRef vergleichen. Auchan dieser Stelle wahlen wir zwei verschiedene Ausgangspunkte fur unsere Tests:Im ersten Test legen wir den maximalen Basis-Polynomgrad p fest (bzw. lassen ihnuber eine sehr geringe Anzahl an Belegungen iterieren); wir erhohen dann sukzessivedie Anzahl der Freiheitsgrade n und betrachten, wie die berechneten Naherungender Galerkinmatrix gegen den Referenzwert konvergieren. Dieser Test ist im Matlab-Skript DecreasingErrorGalerkin in Listing 6.2.1 implementiert. Er ist vollig Ana-log zur Funktion plotDecreasingError in Listing 5.4.1 aufgebaut; aus diesem Grundverzichten wir auf weitergehende Erlauterungen zur Implementierung.

Listing 6.2.1: MatlabMatlabMatlab-Skript DecreasingErrorGalerkin.m

1 %clear all

2

3 % create a curve

4 gammas = createEllipse (2,1,1);

5

6 % choose the polynomial degrees to test the convergence

7 p = [0, 10, 30, 70]’;

8

9 % define a vector that contains an increasing number of

10 % degrees of freedom; for all the degrees of freedem the

11 % galerkin matrix will be computed and compared to a


13 n = [5 ,10 ,20 ,40 ,80 ,160 ,320];

14


16 % solutions with

17 nRef = 600;

18 nRef = max(nRef , max(p));

19 galerkinRefs = cell(length(p), 1);



21 galerkinRefsk = galerkinMatrix(gammas , p(k), nRef);

22 end

23



26





31 % the function galerkinMatrix

32 if(n(l) >= p(k))

33 % compute the galerkin matrix with n(l)

34 % degrees of freedom

35 galMatrix = galerkinMatrix(gammas , ...

36 p(k), n(l));

37 % compute the operator -norm of the difference

38 % to measure the error

39 err(k, l) = norm(galMatrix - galerkinRefsk);

40 else

41 start(k) = l + 1;

42 end

43 end

44

45 display(n(l));

46 end

47


49 hold off


51 loglog(n(start(k):end), err(k, start(k):end), ...

52 ’-s’, ’MarkerSize ’, 3);

53 text(n(start(k)), err(k, start(k)), ...

54 [’ p = ’, int2str(p(k))]);

55 if(k == 1)



58 end

59 hold on

60 end


Abbildung 6.2.1 zeigt den Fehlerplot, den das Skript DecreasingErrorGalerkinausgibt.

Abb. 6.2.1: Abnahme der Abweichung der Galke-

rinmatrix von einer Referenzmatrix bei steigendem

Freiheitsgrad der Berechnung

Vergleichen wir das Ergeb-nis in Abbildung 6.2.1 mitder Konvergenzanalyse vonsingLayPot in Abbildung5.4.1, so fallen zwei wesentli-che Unterschiede auf: Erstensverlaufen die Fehlerkurven zurGalerkinmatrix unregelmaßigerals die Kurven zur FunktionsingLayPot. Zweitens kon-vergiert das Ergebnis vongalerkinMatrix nicht mehrexponentiell mit steigendenFreiheitsgraden, sondern poly-nomiell (man beachte, dassin Abbildung 6.2.1 beideAchsen logarithmisch ska-liert sind). Dementsprechendkonnen wir auch fur Freiheits-grade im Bereich n >> 100noch Fehler in einer relevantenGroßenordnung erkennen. DieUrsachen dieser langsameren

Konvergenz wollen wir im Rahmen unserer recht kurz gehaltenen Behandlung vonGalerkinmatrizen nicht naher untersuchen.

Wie in Abschnitt 5.4 fuhren wir auch einen zweiten Test durch: Wir fixieren die tole-rierte Abweichung der Naherungs-Matrizen von der Referenz-Matrix auf einen Werttol; dann erhohen wir sukzessive den maximalen Basis-Polynomgrad p und fur jedesp untersuchen wir, welche Anzahl n an Freiheitsgraden benotigt wird, damit die Ab-weichung zwischen der Losung mit den n Freiheitsgraden und der Referenzlosung mitnRef Freiheitsgraden kleiner als tol wird. Das Matlabskript RequiredDimGalerkinin Listing 6.2.2 implementiert diesen Test. Er ist vollig analog zur TestfunktionplotRequiredDim in Listing 5.4.2 aufgebaut, weshalb wir an dieser Stelle auf weiter-gehende Erlauterungen verzichten. Das Testskript RequiredDimGalerkin zeichnetseine Resultate in eine Graphik, die in Abbildung 6.2.2 dargestellt ist.

Listing 6.2.2: MatlabMatlabMatlab-Funktion RequiredDimGalerkin.m

1 %clear all

2

3 % create a curve


5


6

7 % choose the polynomial degrees up to which the galerkin

8 % matrix will be computed

9 p = (0:5:50) ’;

10

11 % for each p the galerkin matrix will be computed

12 % for an increasing number of degrees of freedom , until

13 % the difference to a reference result is lower than a

14 % tolerance value; the increasing degrees of freedom are

15 % stored in a vector n

16 n = 1:15:360;

17


19 % solutions with

20 nRef = 600;




24 display(k);

25 end

26

27 maxN = max(n);


29

30 % choose a tolerance value

31 tol = 10^-6;

32

33 % for each p the lowest n is computed such that the


35









44 p(k), n(l));

45 err = norm(galMatrix - galerkinRefsk);

46 if(err <= tol)


48 end


49 end

50 end

51 display(l);

52 end

53


55 hold off



58 xlabel(’Groesse der Galerkinmatrix ’)

Abb. 6.2.2: Benotigte Freiheitsgrade, damit die be-

rechnete Galerkinmatrix um hochstens 10−6 von

einer Referenzmatrix abweicht

Zunachst weisen wir auch hierauf dieselbe Ungenauigkeit hin,die wir bereits in Abschnitt5.4 in Kauf genommen hat-ten: In Listing 6.2.2 beendenwir die Suche nach einer aus-reichenden Anzahl an Freiheits-graden stets, sobald die vor-gegebenen Fehlerschranke ein-mal unterschritten wurde. Da-druch vernachlassigen wir dieMoglichkeit, dass der Fehlerkurzzeitig noch einmal anstei-gen konnte.Im Vergleich mit dem TestRequiredDim in Abschnitt 5.4ist zudem darauf hinzuweisen,dass wir die erlaubte Fehler-schranke tol dieses Mal auf 10−6

gesetzt haben. Sie ist somit we-sentlich grober, als die Schran-ke zum Testen von singLayPot.Diese Anderung ist durch den

vorangehenden Test DecreasingErrorsGalerkin motiviert, der uns zeigte, dass dieGalerkinmatrix wesentlich langsamer konvergiert als das Einfachschichtpotential;wir mussten deshalb sehr lange warten, bis eine Schranke in der Großenordnung10−12 (wie sie im Test von singLayPot gewahlt wurde), unterschritten wird.Wahrend wir beim Testen von singLayPot in Abbildung ?? klar einen linearenVerlauf feststellen konnten, lasst sich ein solcher Zusammenhang im Test der Galer-kimmatrix nur erahnen. Die Kurve verhalt sich recht unregelmaßig und weist nurgrob den Verlauf einer Geraden auf. Denken wir uns eine Regressionsgerade durchden Kurvenverlauf, so fallt zudem auf, dass die Geradensteigung um Gegensatz zuAbbildung 5.4.2 deutlich großer als 1 ist. Wir konnen schließen, dass die Anzahlder benotigten Freiheitsgrade, um eine Galerkinmatrix bis zu einer vorgegebenenGenauigkeit zu berechenen, im Allgemeinen (mindestens) mit einem Vielfachen des


maximalen Basis-Polynomgrades p steigt.

Kapitel 7

Schlusswort

Ziel dieser Arbeit war es, eine Moglichkeit zur effizienten Berechnung von Einfach-schichtpotentialen und der Galerkinmatrix im Rahmen der zweidimensionalen Rand-elementmethode zu finden. Nach einem Uberblick uber die zu berechnenden Integralein Kapitel 2 und einigen Erlauterungen zur Berechnung des Einfachschichtpotentialsauf linearen Kurven in Kapitel 3 haben wir in Kapitel 4 eine allgemeine Moglichkeitzur Berechnung des Einfachschichtpotentials auf rationalen Kurven entwickelt unddiese in Kapitel 5 getestet. Darauf aufbauend haben wir in Kapitel 6 eine Methodezur Berechnung der Galerkinmatrix vorgeschlagen, die ohne Quadratur auskommt.Mit Blick auf die bisherigen Testergebnisse ware im Weiteren vor allem eine genaueBeschaftigung mit den folgenden Punkten sinnvoll:Die Tests in den Abschnitten 5.3 und 5.4 haben gezeigt, dass die Konvergenzge-schwindigkeit unserers Algorithmus zur Berechnung des Einfachsichtpotentials starkvon der Randkurve abhangt, uber die integriert wird. Fur eine feste Randkurvelasst sich zwar abschatzen, wie die benotigte Anzahl an Freiheitsgraden von dergewunschten Genauigkeit abhangt; mochte man die Fehlerabschatzung fur beliebigerationale Kurven automatisieren, so ware hingegen eine theoretische Fehleranalysehilfreich. Eine solche Analyse musste sich mit beiden Fehlertermen aus Satz 5.1.1auseinandersetzen.Die Ausfuhrungen zur Berechnung der Galerkin-Matrix in Kapitel 6 haben wir re-lativ knapp gehalten. Es bietet sich an, das Fehlerverhalten bei der Berechnung derGalerkinmatrix anhand weiterer Beispiele genauer zu studieren. Wenn eine analyti-sche Fehlerabschatzung fur die Berechnung des Einfachschichtpotentials gelingt, solasst sich dieses Ergebnis eventuell verwenden, um auch fur die Konvergenz bei derBerechnung der Galerkinmatrix analytische Aussagen zu treffen.Neben solchen Untersuchungen zur Fehleranschatzung ware auch eine genaue Ana-lyse der in Abschnitt 5.2 beschriebenen numerischen Instabilitat von Interesse. Fureine automatisierte Anwendung der hier vorgestellten Algorithmen mussten derar-tige Instabilitaten abgefangen werden.

80 Kapitel 7: Schlusswort

Anhang A

Verwendete Matlab-Funktionen

An dieser Stelle listen wir alle Matlab-Funktionen auf, die im Rahmen dieser Arbeitimplementiert wurden. Alle Hilfsfunktionen, die in Code-Segmenten im vorangehen-den Hauptteil benutzt wurden, sind hier aufgefuhrt und konnen bei Bedarf nachge-schlagen werden. Des besseren Uberblicks halber sind auch diejenigen Funktionennochmals enthalten, die bereits im Hauptteil vorgestellt und erlautert wurden. DieFunktionen sind nach ihrer inhaltlichen Zugehorigkeit in drei Unterabschnitte sor-tiert: In Abschnitt A.1 sind diejenigen Funktionen aufgefuhrt, die dem Umgang mitPolynomen dienen. Zu Beginn dieses Abschnitts wird außerdem nochmals die Daten-struktur erlautert, die wir zur Darstellung von Polynomen in Matlab verwenden. Wirbenotigen die Funktionen zum Umgang mit Polynomen, um Berechnungen mit denEintragen von rationalen Kurven durchzufuhren. Im darauffolgenden Abschnitt A.2sind alle Funktionen aufgefuhrt, die wir zum Umgang mit rationalen Kurven verwen-den. Zu Beginn dieses Abschnitts wird nochmals die Datenstruktur erlautert, mitder wir rationale Kurven in Matlab darstellen. In Abschnitt A.3 schließlich sind alleFunktionen enthalten, die unmittelbar dem Ziel dieser Arbeit dienen, also der Be-rechnung von Integralen im Rahmen der Randelement-Methode. Hier werden haufigHilfsfunktion aus den beiden anderen Abschnitten verwendet.Da die meisten Hilfsfunktionen leicht zu verstehen sind und die umfangreicherenFunktionen bereits im Hauptteil der Arbeit besprochen wurden, halten wir dieErlauterungen außerhalb der Listings sehr knapp. Wie auch im Hauptteil der Ar-beit sind in allen Listings die einleitenden Kommentar-Zeilen enthalten, welche einenUberblick uber die Funktion geben und die Input- und Outputdaten erlautern.

A.1 Matlab-Funktionen zum Umgang mit Poly-

nomen

Zur Beschreibung eines Polynoms verwenden wir in Matlab einen Zeilenvektor, derdie Koeffizienten des Polynoms enthalt. Der Vektor

[a1, . . . an+1]

steht fur das Polynom

a1tn + . . . + ant+ an+1.

Diese Darstellung wird auch in nativen Matlab-Funktionen verwendet. Um mit Po-lynomen zu rechnen, stellt Matlab beispielsweise die Funktion conv zur Multiplika-tion und die Funktion polyder zur Berechnung der Ableitung zur Verfugung. DieseFunktionen haben aber den Nachteil, dass sie nur fur einzeilige Koeffizientenvektoren

82 Anhang A: Verwendete Matlab-Funktionen

angewendet werden konnen. Weil wir haufig mehrere Polynome simultan betrachten,mochten wir jedoch die Koeffizientenvektoren mehrerer Polynome in einer Matrixzusammenfassen, das heißt, wir wollen beispielsweise die Matrix1 −1 0 2

0 3 −1 02 0 4 −1

als Spaltenvektor auffassen, der die Polynome t3 − t2 + 2

3t2 − t2t3 + 4t− 1

enthalt. Auf diese Weise konnen wir die schnellen Vektoroperationen von Matlab aufdie Koeffizientenspalten anwenden, um beispielsweise das Produkt von vielen Poly-nomen zugleich zu berechnen. Ohne dieses Vorgehen waren zudem in vielen Funk-tionen zusatzliche Schleifen notig, um die gewunschten Berechnungen Polynom furPolynom durchzufuhren. Das Vermeiden dieser Schleifen erhoht die Ubersichtlichkeitdes Quellcodes.Wie das gerade genannte Beispiel zeigt, wollen wir auch zulassen, dass Polynomeunterschiedlichen Grades in einer Matrix zusammengefasst werden. Die Breite derMatrix richtet sich dann nach dem hochsten vorkommenden Polynomgrad, und dieKoeffizientenvektoren von Polynomen niedrigeren Grades werden mit Nullen auf-gefullt.Im folgenden sind alle Funktionen aufgefuhrt, die wir zum Rechnen mit Polynomenverwenden:

• Die Funktion polysum addiert zwei Polynome. Sie ist in Listing A.1.1 auf-gefuhrt.

• Die Funktion polyprod multipliziert zwei Polynome.

• Die Funktion polyderiv leitet ein Polynom ab.

• Die Funktion polyroots berechnet die Nullstellen eines Polynoms.

• Die Funktion lCoef gibt den fuhrenden Koeffizienten eines Polynoms zuruck.

• Die Funktion adjustLCoef setzt die fuhrenden Koeffizienten eines Polynomsauf 0, falls diese einen Toleranzwert unterschreiten.

Alle soeben aufgezahlten Funktionen befinden sich auch auf der beigelegten CDim Verzeichnis matlab/polynomials. Jede dieser Funktionen akzeptiert als Eingabeauch Matrizen. Es wird dann, wie soeben erlautert, jede Zeile der Matrix als Poly-nom aufgefasst und die Funktion wird fur jede Zeile ausgefuhrt. Bei den Funktionenpolysum und polyprod, die je zwei Polynome als Eingabe erwarten, muss darauf ge-achtet werden, dass die beiden Eingabe-Matrizen dieselbe Anzahl an Zeilen besitzen.

Zu jeder Funktion folgt nun ein kurzer, beschreibender Text und der komplette,kommentierte Quellcode. Input- und Output-Argumente jeder Funktion sind im

Abschnitt A.1: Matlab-Funktionen zum Umgang mit Polynomen 83

Matlab-help-Kommentar unmittelbar nach der Funktionendeklaration im Quellcodegenau beschrieben. Außerdem befindet sich dort auch stets ein einfaches Beispiel furdie Benutzung der Funktion.

Die folgende Funktion polysum summiert zwei Matrizen, die wir zeilenweise alsPolynome interpretieren. Es ist lediglich zu beachten, dass die beiden Matrizen auf-grund unterschiedlicher Polynomgrade verschiedene Breite haben konnen, weshalbeine einfache Addition der Matrizen nicht genugt.

Listing A.1.1: MatlabMatlabMatlab-Funktion polysum.m

1 function p = polysum(pol1 , pol2)

2 % POLYSUM compute the sum of two polynomials.

3 % Computes the sum of two polynomials by adding their´

4 % coefficient vectors.

5 %

6 % Usage: p = polysum(pol1 , pol2)

7 %

8 % Inputs:

9 % pol1 - n-by-d1 matrix containing the coefficient

10 % vector of a polynomial in each row; the

11 % degree of each of the polynomials is

12 % equal to or lower than d1 + 1

13 % pol2 - n-by-d2 matrix containing the coefficient


15 % maxmimum degree d2 of these may be

16 % distinct form d1

17 %

18 % Outputs:

19 % p - n-by-max(d1, d2) matrix containing the sum

20 % of the vectors pol1(k, :) and pol2(k, :)

21 % in the the k-th row

22 %

23 % Example:

24 % pol1 = [1, -1, 0.25; 0, -1, 3];

25 % pol2 = [0, -3; 0.5, 0];

26 % p = polysum(pol1 , pol2);

27

28 [n, d1] = size(pol1);

29 d2 = size(pol2 , 2);

30

31 p = [ zeros(n,d2-d1), pol1 ] + [ zeros(n,d1-d2), pol2 ];


Die folgende Funktion polyprod faltet die Zeilen der ersten Input-Matrix mit denZeilen der zweiten Input-Matrix; sie berechnet also zeilenweise das Produkt derPolynome, die durch die Zeilen reprasentiert werden.

Listing A.1.2: MatlabMatlabMatlab-Funktion polyprod.m

1 function p = polyprod(pol1 , pol2)

2 % POLYPROD compute the product of two polynomials.

3 % Computes the product of two polynomials by

4 % convoluting their coefficient vectors.

5 %

6 % Usage: p = polyprod(pol1 , pol2)

7 %

8 % Inputs:

9 % pol1 - n-by -d1 matrix containing the coefficient



12 % equal to or lower than d1 + 1

13 % pol2 - n-by -d2 matrix containing the coefficient


15 % maxmimum degree d2 of these may be

16 % distinct form d1

17 %

18 % Outputs:

19 % p - n-by -(d1+d2 -1) matrix containing the

20 % convolution of the vectors pol1(k, :) and

21 % pol2(k, :) in the the k-th row

22 %

23 % Example:

24 % pol1 = [1, -1, 0.25; 0, -1, 3];

25 % pol2 = [0, -3; 0.5, 0];

26 % p = polyprod(pol1 , pol2);

27

28 [n, d1] = size(pol1);

29 d2 = size(pol2 , 2);

30

31 d = d1 + d2 - 1;

32 p = zeros(n, d);

33

34 for k = 1:d1

35 for l = 1:d2

36 p(:, k+l-1) = p(:, k+l-1) ...


37 + (pol1(:, k) .* pol2(:, l));

38 end

39 end

Die folgende Funktion polyderiv berechnet fur jede Zeile der Input-Matrix die Ab-leitung des zugehorigen Polynoms.

Listing A.1.3: MatlabMatlabMatlab-Funktion polyderiv.m

1 function p = polyderiv(pol)

2 % POLYSUM compute the derivative of polynomials.

3 % Computes the derivative of a polynomial by decreasing

4 % the length of its coefficient vector and multiplying

5 % the coefficients with the degrees of their

6 % corresponding monomials.

7 %

8 % Usage: p = polyderiv(pol)

9 %

10 % Inputs:

11 % pol - n-by-d matrix containing the coefficient


13 % degree of each of the polynomials is equal

14 % to or lower than d + 1

15 %

16 % Outputs:

17 % p - n-by -(d-1) matrix containing the coefficient

18 % vector of the derivative of pol(k, :)

19 % in the k-th row

20 %

21 % Example:

22 % pol = [1, -1, 0.25; 0, -1, 3; 0, 0 , -3; ...

23 % 0, 0.5, 0; 0, 0, 0];

24 % p = polyderiv(pol);

25

26 [n, d] = size(pol);

27 p = zeros(n, d-1);

28 for k = 1:d-1

29 p(:, k) = (d - k) * pol(:, k);

30 end


Die folgende Funktion polyroots berechnet fur jede Zeile der Eingabe-Matrix dieNullstellen des zugehorigen Polynoms. Wir iterieren in dieser Funktion ausnahms-weise mit einer Schleife uber die Zeilen und verwenden in jeder Zeile die nativeMatlab-Funktion roots. Dies erspart uns eine aufwendige eigene Implementierungder Nullstellen-Berechnung. Zudem wird die Funktion in unserem Algorithmus nuran einer Stelle fur eine großere Matrix verwendet, weshalb die langsame Matlab-for-Schleife nicht ins Gewicht fallt. Wir kapseln die Berechnung trotzdem in eine eigeneFunktion, anstatt die Schleife direkt im aufrufenden Quellcode zu verwenden, weildie folgende Funktion zudem die Verwendung der Nullstellen von Polynomen unter-schiedlichen Grades erleichtert: Ist die Anzahl der Nullstellen in einer Zeile geringerals die Breite der Ausgabematrix, so werden die verbleibenden Eintrage in der Zeilemit dem Wert Inf aufgefullt.

Listing A.1.4: MatlabMatlabMatlab-Funktion polyroots.m

1 function r = polyroots(pol)

2 % POLYROOTS compute the roots of a polynomial.

3 % Computes the roots of a polynomial using the

4 % Matlab -Function ROOTS

5 %

6 % Usage: r = polyroots(pol)

7 %

8 % Inputs:

9 % pol - n-by -d matrix containing the coefficient


11 % degree of each of the polynomials is equal

12 % to or lower than d + 1

13 %

14 % Outputs:

15 % r - n-by -(d-1) matrix; the row r(k, :) contains

16 % the roots of the polynomial pol(k, :).

17 % Complex roots of real polynomials are

18 % placed next to their conjugate complexe

19 % roots. If the degree of pol(k, :) is lower

20 % than d-1, the first entries of r(k, :) are

21 % filled with the value Inf.

22 %

23 % Example:

24 % pol = [1, -1, 0.25; 1, 0, 1; 0, 0 , -3; ...

25 % 0, 0.5, 0];

26 % r = polyroots(pol);

27

28 [n, d] = size(pol);


29 r = zeros(n, d-1);

30 for k = 1:n

31 rk = roots(pol(k, :))’;

32 r(k, :) = [Inf * ones(1, d-1-length(rk)), rk];

33 end

Die folgende Funktion lCoef gibt einen Spaltenvektor zuruck, der die fuhrendenKoeffizienten der Polynome aus der Eingabematrix enthalt. Man beachte, dass esnicht genugt, die erste Spalte der Eingabematrix zuruckzugeben, weil die Matrix inmanchen Zeilen womoglich Polynome niedrigeren Grades enthalt.

Listing A.1.5: MatlabMatlabMatlab-Funktion lCoef.m

1 function coef = lCoef(pol)

2 % LCOEF compute the leading coefficient of a polynomial.

3 % Computes the leading coefficient of a polynomial by

4 % returning the first entry of its coefficient vector

5 % which ist not equal to zero.

6 %

7 % Usage: coef = lCoef(pol)

8 %

9 % Inputs:

10 % pol - n-by-d matrix containing the coefficient



13 % equal to or lower than d + 1

14 %

15 % Outputs:

16 % coef - n-by -1 vector; the entry coef(k) is the

17 % leading coefficient of the polynomial

18 % pol(k, :)

19 %

20 % Example:

21 % pol = [1, -1, 0.25; 0, -1, 3; 0, 0 , -3; ...

22 % 0, 0.5, 0; 0, 0, 0];

23 % coef = lCoef(pol);

24

25 coef = pol(:, 1);

26

27 subscr = (abs(coef) <= 0);

28 zeroPol = pol(subscr , :);


29 [n, m] = size(zeroPol);

30 zeroCoef = zeros(n, 1);

31

32 for k = 1:n

33 for l = 2:m

34

35 if( abs(zeroPol(k, l)) > eps )

36 zeroCoef(k) = zeroPol(k, l);

37 break;

38 end

39

40 end

41 end

42 coef(subscr) = zeroCoef;

Die folgende Funktion adjustLCoef gibt die Polynome der Eingabematrix zuruck,setzt aber alle fuhrenden Koeffizienten, deren Absolutbetrag einen Toleranzwertunterschreitet auf Null. Die Funktion wird von der Funktion fCoefLog aufgerufen.Der Grund fur ihre Verwendung wird in Abschnitt 5.2 erlautert.

Listing A.1.6: MatlabMatlabMatlab-Funktion adjustLCoef.m

1 function polOut = adjustLCoef(polIn , tol)

2 % ADJUSTLCOEF zero small leading coefficient of a

3 % polynomial.

4 % Zeros the leading coefficients of a polynomial and

5 % stops at the first coefficent with an absolute value

6 % larger then a given tolerance.

7 %

8 % Usage: polOut = adjustLCoef(polIn , tol)

9 %

10 % Inputs:

11 % polIn - n-by -d matrix containing the coefficient



14 % equal to or lower than d + 1

15 %

16 % Outputs:

17 % polOut - n-by -d matrix; the k-th row of polOut is

18 % obtained by copying the k-the row of

19 % polIn and zeroing the entries

Abschnitt A.2: Matlab-Funktionen zum Umgang mit rationalen Kurven 89

20 % polOut(k, 1), ..., polOut(k, j-1),

21 % where polOut(k, j) is the first entry

22 % of the row polOut(k, :) that satisfies

23 % the condition abs(polOut(k, j)) >= tol.

24 %

25 % Example:

26 % polIn = [-2e-10, 0, 3e-10, 2; ....

27 % -2e-10, 0.1, 3e-10, 2; -2e-8, 0, 3e-10, 2];

28 % polOut = adjustLCoef(polIn , 1e-9);

29

30 polOut = polIn;

31 subscr = find(abs(polOut(:, 1)) < tol);

32 m = length(subscr);

33 d = size(polOut , 2);

34 for k=1:m

35 for l=1:d

36 if(abs(polOut(subscr(k), l)) < tol)

37 polOut(subscr(k), l) = 0;

38 else

39 break;

40 end

41 end

42 end

A.2 Matlab-Funktionen zum Umgang mit ratio-

nalen Kurven

Wir verwenden in allen Implementierungen eine einheitliche Datenstruktur, um ra-tionale Kurven in der Ebene darzustellen. Im Allgemeinen versteht man unter einerrationalen Kurve eine Abbildung

γ : [a, b]→ R2, t 7→(γ1(t)γ2(t)

),

wobei die beiden Komponenten γ1 und γ2 rationale Funktionen sind, die auf [a, b]keine Singularitat besitzen. Im Rahmen dieser Arbeit verwenden wir als Parameter-intervall [a, b] außschließlich das Intervall [−1, 1].Weil wir die Intervallgrenzen a = −1 und b = 1 fest wahlen, ist jede rationale Kurveγ eindeutig durch ihre beiden Komponenten γ1 und γ2 bestimmt. In Matlab konnenwir rationale Kurven deshalb durch die folgende Datenstruktur beschreiben:

• Jede rationale Kurve γ wird durch ein 2-by-2-Cell-Array gamma dargestellt.Jeder der vier Zellen enthalt den Koeffizientenvektor eines Polynoms, namlich:


• Im Zeilenvektor gamma1, 1 stehen die Koeffizienten des Zahlerpolynoms vonγ1.

• Im Zeilenvektor gamma2, 1 stehen die Koeffizienten des Nennerpolynomsvon γ1.

• Im Zeilenvektor gamma1, 2 stehen die Koeffizienten des Zahlerpolynoms vonγ2.

• Im Zeilenvektor gamma2, 2 stehen die Koeffizienten des Nennerpolynomsvon γ2.

Wir veranschaulichen diese Datenstruktur noch einmal, in dem wir das Cell-Arraygamma als Matrix darstellen:

gamma =

(Zaehler(γ1) Zaehler(γ2)Nenner(γ1) Nenner(γ2)

)Anschaulich konnen wir uns merken: Die Komponenten γ1 und γ2 stehen nebenein-ander, Zahler und Nenner stehen ubereinander.Als Beispiel konnen wir die rechte Seite des Einheitskreises rational parametrisieren.Sie wird durch die Kurve

γ : [−1, 1]→ R2, t 7→(

1−t2t2+1

2tt2+1

),

beschrieben. Wir stellen sie in Matlab durch das Cell-Array

gamma =

([−1, 0, 1] [2, 0])[1, 0, 1] [1, 0, 1]

)dar. Man beachte, dass wir eine Kurve γ naturlich auch dann durch die soebenerlauterte Datenstruktur beschreiben konnen, wenn γ1 und γ2 Polynome sind. Wirsetzen dann die beiden Nenner der Kurve auf 1. Zum Beispiel parametrisiert dieKurve

γ : [−1, 1]→ R2, t 7→(tt2

),

eine nach oben geoffnete Parabel zwischen −1 und 1. In Matlab stellen wir sie durchdas Cell-Array

gamma =

([1, 0] [1, 0, 0])

[1] [1]

)dar. Ein weiteres, sehr einfaches Beispiel fur polynomial beschriebene Kurven sindStreckenstucke. Beispielsweise parametrisiert die Kurve

γ : [−1, 1]→ R2, t 7→(t−t

), gamma =

([1, 0] [−1, 0])

[1] [1]

)die Verbindungsstrecke von (−1, 1)T nach (1,−1)T .

Bei der Randelementmethode wollen wir den ganzen Rand eines Gebietes durchKurven beschreiben. Dabei ist es haufig sinnvoll, denn Rand in mehrere Teilstuckezu unterteilen und jedes Teilstuck durch eine eigene Kurve zu beschreiben. Um zum


Beispiel den Einheitskreis zu parametrisieren, unterteilen wir ihn in zwei Halbkreise.Dann konnen wir den rechten und den linken Halbkreis jeweils durch eine Kurve γRund γL beschreiben; es gilt

γR : [−1, 1]→ R2, t 7→(

1−t2t2+1

2tt2+1

), gammaR =

([−1, 0, 1] [2, 0])[1, 0, 1] [1, 0, 1]

)und

γL : [−1, 1]→ R2, t 7→(t2−1t2+1−2tt2+1

), gammaL =

([1, 0, −1] [−2, 0])[1, 0, 1] [1, 0, 1]

).

Wenn wir mehrere dieser Kurven zusammen betrachten wollen um beispielsweiseden ganzen Rand eines Gebietes zu beschreiben, dann speichern wir die zugehorigenCell-Arrays in Matlab stets in einem linearen Cell-Array hintereinander ab. DieCell-Arrays gammaR und gammaL, die die beiden Halften des Einheitskreises be-schreiben, legen wir also beispielsweise in einem 2-by-1 Cell-Array circle ab:

circle = gammaR; gammaL;

Manche der Funktionen, die wir zum Umgang mit solchen Kurvendarstellungen im-plementiert haben, erwarten als Input einen 2-by-2-Cell-Array, der eine einzelneKurve beschreibt. Manche andere Funktionen erwarten stattdessen ein n-by-1-Cell-Array als Input, das mehrere Kurven - wie im letztgenannten Beispiel - zusam-menfasst. Welche der beiden Input-Arten von einer Funktion erwartet wird, hangtnaturlich von der Aufgabe ab, fur die wir die jeweilige Funktion geschrieben haben.Man achte aber bei der Verwendung der Funktionen darauf, dass das Verwechselnder beiden Datentypen eine Fehlerquelle sein kann.

Im folgenden sind alle Funktionen aufgefuhrt, die wir zum Umgang mit rationalenKurven verwenden:

• Die Funktion createCurve fasst zwei ubergebene Zahler- und zwei ubergebeneNennerpolynome einer rationalen Kurve in Form eines 2-by-2-Cell-Arrays zu-sammen.

• Die Funktion createLine verbindet zwei Punkte mit einem oder mehrerenStreckenstucken.

• Die Funktion createPolygon verbindet mehrere Punkte zu einem Polygonzug.

• Die Funktion createEllipse erzeugt mehrere Kurven, die gemeinsam eine El-lipse interpolieren.

• Die Funktion createSemiEllipse erzeugt mehrere Kurven, die gemeinsam einegeschlossene Halbellipse interpolieren

• Die Funktion evalPoints berechnet die Kurvenpunkte auf einem im Parame-terintervall [−1, 1] gelegenen Gitter.

• Die Funktion sepCurves nahert mehrere ubergebene Kurven durch einen Po-lygonzug an.


• Die Funktion normOfDeriv berechnet fur eine Kurve γ die Funktion |γ(t)|und gibt sie als Function-Handle zuruck.

• Die Funktion distCurve berechnet fur einen Punkt x und eine Kurve γ dierationale Funktion |γ(t)− x|2. Sie gibt das Zahlerpolynom und das Nennepo-lynom dieser Funktion als Koeffizientenvektor zuruck.

• Die Funktion drawCurves plottet die ubergebenen Kurven.

All diese Funktionen befinden sich auch auf der beigelegten CD im Verzeichnis mat-lab/curves. Zu jeder Funktion folgt nun ein kurzer, beschreibender Text und derkomplette, kommentierte Quellcode. Input- und Output-Argumente jeder Funktionsind im Matlab-help-Kommentar unmittelbar nach der Funktionendeklaration imQuellcode genau beschrieben. Außerdem befindet sich dort auch stets ein einfachesBeispiel fur die Benutzung der Funktion.

Die folgende Funktion createCurve erzeugt aus vier ubergebenen Zeilenvektorenein 2-by-2-Cell-Array, das eine rationale Kurve γ = (γ1, γ2)T reprasentiert. Dieubergebenen Zeilenvektoren sind die Koeffizienten der Zahler- und Nennerpolynomevon γ1 und γ2.

Listing A.2.1: MatlabMatlabMatlab-Funktion createCurve.m

1 function gamma = createCurve(nom1 , den1 , nom2 , den2)

2 % CREATECURVE Represent a rational curve.

3 % Computes a rational curve which is parameterized on

4 % the interval [-1, 1]. The curve is represented by a

5 % 2-by -2 cell array gamma. Each cell of gamma contains

6 % a coefficient vector of a polynomial:

7 % - gamma1, 1 is the nominator of the first vector

8 % component

9 % - gamma2, 1 is the denominator of the first

10 % vector component

11 % - gamma1, 2 is the nominator of the second vector

12 % component

13 % - gamma2, 2 is the denominator of the second

14 % vector component

15 %

16 % Usage: gamma = createCurve(nom1 , den1 , nom2 , den2)

17 %

18 % Inputs:

19 % nom1 - row vector containing the coefficients

20 % of the nominator polynomial of the

21 % first vector component.

22 % denom1 - row vector containing the coefficients


23 % of the denominator polynomial of the

24 % first vector component.

25 % nom2 - row vector containing the coefficients

26 % of the nominator polynomial of the

27 % second vector component.

28 % denom2 - row vector containing the coefficients

29 % of the denominator polynomial of the

30 % second vector component.

31 %

32 % Outputs:

33 % gamma - 2-by -2 cell array with the entries

34 % described above.

35 %

36 % Example:

37 % % create a curve that describes a parabola:

38 % den = 1;

39 % nom1 = [1, 0];

40 % nom2 = [1, 0, 0];

41 % parabola = createCurve(nom1 , den , nom2 , den);

42 %

43 % % draw the curve by using the function DRAWCURVES:

44 % drawCurves( parabola , 200);

45

46

47 gamma = cell (2,2);

48 gamma1, 1 = nom1;

49 gamma2, 1 = den1;

50 gamma1, 2 = nom2;

51 gamma2, 2 = den2;

Die folgende Funktion createLine verbindet zwei Punkte mit einem oder mehrerenaneinander gereihten Streckenstucken. Jedes dieser Streckenstucke wird von einerrationalen Kurven interpoliert, und all diese Kurven werden zu einem n-by-1-Cell-Array zusammengefasst.

Listing A.2.2: MatlabMatlabMatlab-Funktion createLine.m

1 function curves = createLine(x, y, m)

2 % CREATELINE Compute linear curves that interpolate the

3 % line between two points.

4 % Parameterizes the connecting line from x to y by m


5 % linear curves which are all defined on the interval

6 % [-1,1] and which have equidistant starting and end

7 % points.

8 %

9 % Usage: curves = createLine(x, y, m)

10 %

11 % Inputs:

12 % x - 1-by -2 vector that represents a point in

13 % the two dimensional space

14 % y - 1-by -2 vector that represents another

15 % point in the two dimensional space

16 % m - An integer equal to or greater than 1

17 % that defines the number of curves , the

18 % line between x and y is decomposed to.

19 %

20 % Outputs:

21 % curves - m-by -1 cell array containing m output

22 % curves. Each curve is represented by a

23 % 2-by -2 cell array , see the function


25 %

26 % Example:

27 % x = [-1, -2];

28 % y = [1, 2];

29 % curves = createLine(x, y, 4);

30

31 curves = cell(m,1);

32 grid = 2 * (0:m) / m - 1;

33

34 den = 1;

35

36 for k=1:m

37

38 a = grid(k);

39 b = grid(k+1);

40

41 c = (x + y) / 2 + (b+a)/2 * (y - x) / 2;

42 d = (b-a)/2 * (y - x) / 2;

43

44 curve = cell(2, 2);

45 curve1, 1 = [d(1), c(1)];

46 curve2, 1 = den;

47 curve1, 2 = [d(2), c(2)];


48 curve2, 2 = den;

49

50 curvesk = curve;

51

52 end

Die folgende Funktion createPolygon verbindet die ubergebenen Punkte durch einenPolygonzug. Jedes Streckenstuck wird durch eine rationale Kurve interpoliert undall diese Kurven werden zu einem n-by-1-Cell-Array zusammengefasst.

Listing A.2.3: MatlabMatlabMatlab-Funktion createPolygon.m

1 function curves = createPolygon(p, m)

2 % CREATEPOLYGON Compute linear curves that interpolate a

3 % polygon between sevveral points.

4 % Parameterizes the connecting line from each point

5 % p(k, :) to the following point p(k+1, :). Each of

6 % these lines is decomposed to m curves which are all

7 % parameterized on the interval [-1,1]. In general the

8 % polygonal line is not closed. In order to close the

9 % line , the first and the last vector contained in p

10 % must be the same.

11 %

12 % Usage: curves = createPolygon(p, m)

13 %

14 % Inputs:

15 % p - n-by -2 matrix containing the coordinate

16 % of a two dimensional vector in each

17 % row.


19 % that defines the number of curves , each

20 % line between p(k, :) and p(k+1, :) is

21 % decomposed to.

22 %

23 % Outputs:

24 % curves - (m*(n-1))-by -1 cell array containing

25 % m*(n-1) output curves. Each curve is

26 % represented by a 2-by -2 cell array , see

27 % the function CREATECURVE for

28 % explanation.

29 %


30 % Example:

31 % pOpen = [1, 1; -1, 1; -1, -1; 1, -1];

32 % openPolygon = createPolygon(pOpen , 3);

33 % pClosed = [1, 1; -1, 1; -1, -1; 1, -1; 1, 1];

34 % closedPolygon = createPolygon(pClosed , 3);

35

36 n = size(p, 1);

37 curves = cell((n-1)*m, 1);

38

39 for k=1:n-1

40 curves ((k-1)*m + 1 : k*m) = ...

41 createLine(p(k, :), p(k+1, :), m);

42 end

Die folgende Funktion createEllipse interpoliert eine Ellipse durch mehrere rationaleKurven. All diese Kurven werden zu einem n-by-1-Cell-Array zusammengefasst.

Listing A.2.4: MatlabMatlabMatlab-Funktion createEllipse.m

1 function curves = createEllipse(a, b, m)

2 % CREATEELLIPSE Compute rational parameterized curves

3 % that interpolate an ellipse.

4 % Parameterizes an ellipse by rational curves that are

5 % defined on the interval [-1,1]. Position and rotation

6 % of the elipse are fixed such that both axes of the

7 % ellipse are located on the coordinate axes of the two

8 % dimensional space. Both the right and the left

9 % handside are parameterized by m distinct curves.

10 %

11 % Usage: curves = createEllipse(a, b, m)

12 %

13 % Inputs:

14 % a - a positive number that defines the length

15 % of the half axis orientated in

16 % direction of the first coordinate

17 % b - a positive number that defines the length

18 % of the half axis orientated in

19 % direction of the second coordinate


21 % that defines the number of curves , both

22 % semi ellipses on the left and on the


23 % rigth are decomposed to.

24 %

25 % Outputs:

26 % curves - (2*m)-by -1 cell array containing 2*m

27 % output curves. Each curve is



30 % explanation.

31 %

32 % Example:

33 % curves = createEllipse (2, 1, 3);

34

35 curves = cell (2*m,1);

36 grid = 2* (0:m) / m - 1;

37

38 for k=1:m

39

40 u = grid(k);

41 o = grid(k+1);

42

43 c2 = (o-u)^2/4;

44 c1 = (o-u)^2/2 + (o-u)*u;

45 c0 = (o-u)^2/4 + (o-u)*u + u^2;

46

47 pol0 = [c2, c1, c0 + 1];

48 pol1 = a*[c2, c1, c0 - 1];

49 pol2 = b*[o - u, o + u];

50

51 curve1 = cell(2, 2);

52 curve11, 1 = pol1;

53 curve12, 1 = pol0;

54 curve11, 2 = - pol2;

55 curve12, 2 = pol0;

56

57 curve2 = cell(2, 2);

58 curve21, 1 = - pol1;

59 curve22, 1 = pol0;

60 curve21, 2 = pol2;

61 curve22, 2 = pol0;

62

63 curvesk = curve1;

64 curvesm + k = curve2;

65


66 end

Die folgende Funktion createSemiEllipse interpoliert eine Halbellipse und die Stre-cke, welche die Halbellipse schließt, duch mehrer rationale Kurven. All diese Kurvenwerden zu einem n-by-1-Cell-Array zusammengefasst.

Listing A.2.5: MatlabMatlabMatlab-Funktion createSemiEllipse.m

1 function curves = createSemiEllipse(a, b, m)

2 % CREATEELLIPSE Compute rational parameterized curves

3 % that interpolate a semi ellipse.

4 % Parameterizes a semi ellipse by rational curves that

5 % are defined on the interval [-1,1]. Position and

6 % rotation of the semi elipse are fixed such that the

7 % main axis , where the ellipse is cut , is located on

8 % the second coordinate axis , whereas the other main

9 % axis is located on the first coordinate axis.

10 % The right part of the ellipse is cut and the

11 % remaining curves describes a semi ellipse on the

12 % right which is closed by a line.

13 % Both the remaining semi ellipse and the closing line

14 % are decomposed into m curves each.

15 %

16 % Usage: curves = createSemiEllipse(a, b, m)

17 %

18 % Inputs:

19 % a - a postive number that defines the length

20 % of the semi axis orientated in

21 % direction of the first coordinate

22 % b - a positive number that defines the

23 % length of the semi axis respectively

24 % the half of the closing line that is

25 % orientated in direction of the second

26 % coordinate


28 % that defines the number of curves , both

29 % the semi ellipse and the closing line

30 % are decomposed to.

31 %

32 % Outputs:

33 % curves - (2*m)-by -1 cell array containing 2*m





37 % explanation.

38 %

39 % Example:

40 % curves = createSemiEllipse (2, 1, 3);

41

42 curves = cell (2*m,1);

43 grid = 2* (0:m) / m - 1;

44

45 for k=1:m

46

47 u = grid(k);

48 o = grid(k+1);

49

50 c2 = (o-u)^2/4;

51 c1 = (o-u)^2/2 + (o-u)*u;

52 c0 = (o-u)^2/4 + (o-u)*u + u^2;

53

54 pol0 = [c2, c1, c0 + 1];

55 pol1 = a*[c2, c1, c0 - 1];

56 pol2 = -b*[o - u, o + u];

57 pol3 = 0;

58 pol4 = b*[o/2 - u/2, o/2 + u/2];

59 pol5 = 1;

60

61 curve1 = cell(2, 2);

62 curve11, 1 = pol1;

63 curve12, 1 = pol0;

64 curve11, 2 = pol2;

65 curve12, 2 = pol0;

66

67 curve2 = cell(2, 2);

68 curve21, 1 = pol3;

69 curve22, 1 = pol5;

70 curve21, 2 = pol4;

71 curve22, 2 = pol5;

72

73 curvesk = curve1;

74 curvesm + k = curve2;

75

76 end


Die folgende Funktion evalPoints berechnet die Kurvenpunkte einer rationalen Kur-ven γ an freiwahlbaren Punkten im Intervall [−1, 1]. Die berechneten zweidimensio-nalen Punkte werden als Zeilen der Output-Matrix zuruckgegeben.


Listing A.2.6: MatlabMatlabMatlab-Funktion evalPoints.m

1 function points = evalPoints(gamma , t)

2 % EVALPOINTS Evaluate a curve.

3 % Computes the values of a rational curve for

4 % parameters t.

5 %

6 % Usage: f = evalPoints(gamma , t)

7 %

8 % Inputs:




12 % t - n-by -1 vector containing numbers of the

13 % interval [-1,1]; gamma will be

14 % evaluated for the these argument

15 % numbers.

16 %

17 % Outputs:

18 % points - n-by -2 matrix; the two dimensional vector

19 % in the row points(k, :) is the value of

20 % gamma at the point t(k);

21 %

22 % Examples:

23 % grid = ( -10:10)’ / 10;


25 % pointsEllipse = evalPoints(ellipse 1, grid);

26 %

27 % line = createLine ([-1, -1], [1,1], 1);

28 % pointsLine = evalPoints(line1, grid);

29

30 points = zeros(length(t), 2);

31 points(:, 1) = polyval(gamma1,1, t);

32 points(:, 1) = points(:, 1) ./ polyval(gamma2,1, t);

33

34 points(:, 2) = polyval(gamma1,2, t);

35 points(:, 2) = points(:, 2) ./ polyval(gamma2,2, t);

Die folgende Funktion sepCurves approximiert mehrere ubergebene Kurven durcheinen Polygonzug. Die Anzahl der Streckenstucke, in die jede der ubergebenen Kur-


ven zerlegt wird, kann frei gewahlt werden.

Listing A.2.7: MatlabMatlabMatlab-Funktion sepCurves.m

1 function newCurves = sepCurves(curves , n)

2 % SEPCURVES Compute linear curves that approximate a

3 % given curve.

4 % Each curve contained in gammas is evaluated on a

5 % equidistant grid of n+1 points in [-1, 1]. The

6 % resulting , two dimensional points are interpolated by

7 % linear curves.

8 % Only the number of points for each curve in gammas

9 % can be defined by the parameter n. Two successive

10 % points will be connected by only one line which will

11 % not be decomposed into some smaller lines by this

12 % Function.

13 %

14 % Usage: curves = sepCurves(curves , n)

15 %

16 % Inputs:

17 % curves - a m-by -1 cell array containing m input

18 % curves. Each

19 % curve ist represented by a 2-by -2

20 % cell arry , see the function


22 % n - An integer equal to or greater than 1

23 % that defines the number of linear

24 % curves , each input curve will be

25 % approximated by.

26 %

27 % Outputs:

28 % newCurves - (m*n)-by -1 cell array containing m*n


30 % represented by a 2-by -2 cell

31 % array , see the function CREATECURVE

32 % for explanation.

33 %

34 % Example:

35 % curves = createEllipse (1, 1, 1);

36 % newCurves = sepCurves(curves , 10);

37

38 m = length(curves);


39 newCurves = cell(n*m, 1);

40 for k=1:m

41 newCurves ((k-1)*n+1 : k*n) = sepCurve(curvesk, n);

42 end

43

44

45 function newCurve = sepCurve(curve , n)

46

47 grid = (0:n) ’;

48 grid = 2*grid/n - 1;

49 points = evalPoints(curve , grid);

50 newCurve = createPolygon(points , 1);

Die folgende Funktion normOfDeriv berechnet fur eine Kurve γ die Funktion |γ(t)|,also die Norm der Kurvenableitung. Sie wird als Function-Handle zuruckgegeben.

Listing A.2.8: MatlabMatlabMatlab-Funktion normOfDeriv.m

1 function f = normOfDeriv(gamma)

2 % NORMOFDERIV Compute the euclidean norm of the

3 % derivative of a curve.

4 % Derives a rational curve and returns the vector norm

5 % of the derivative as a function handle. To compute

6 % the derivative and its norm the coefficient vector of

7 % the nominators and denominators of both coordinates

8 % of the curve are used.

9 %

10 % Usage: f = normOfDeriv(gamma)

11 %

12 % Inputs:

13 % gamma - a 2-by -2 cell array that represents a



16 %

17 % Outputs:

18 % f - a function handle to evaluat the norm of

19 % the derivative of gamma on the parameter

20 % intervall [-1, 1];

21 %

22 % Examples:



24 % fEllipse = normOfDeriv(ellipse 1);

25 %

26 % line = createLine ([-1, -1], [1,1], 1);

27 % fLine = normOfDeriv(line 1);

28

29 z1 = gamma1, 1;

30 z2 = gamma1, 2;

31 n1 = gamma2, 1;

32 n2 = gamma2, 2;

33

34 n = polyprod( polyprod(n1, n1), polyprod(n2, n2) );

35 p1 = polysum( polyprod(n1 , polyderiv(z1)), ...

36 -polyprod(z1, polyderiv(n1)) );

37 p2 = polysum( polyprod(n2 , polyderiv(z2)), ...

38 -polyprod(z2, polyderiv(n2)) );

39 p1 = polyprod(p1, polyprod(n2 , n2));

40 p2 = polyprod(p2, polyprod(n1 , n1));

41 p1 = polyprod(p1, p1);


43 z = polysum(p1 , p2);

44

45 f = @(t)( sqrt(polyval(z, t)) ./ polyval(n, t) );

Die folgende Funktion distCurve berechnet fur eine rationale Kurve γ und fur zwei-dimensionale Punkte x die quadratische Abstandsfunktion |γ(t)−x|2. Diese Funktionist rational; deshalb gibt distCurve die Koeffizientenvektoren fur das Zahler- undNennerpolynom von |γ(t)−x|2 zuruck. Wenn mehrere Punkte x ubergeben werden,wird fur den Zahler von |γ(t) − x|2 eine Matrix zuruckgegeben. Jede Zeile der Ma-trix steht dann fur das Zahlerpolynom von |γ(t) − x|2 fur einen der ubergebenenPunkte x. Als Nenner wird trotzdem nur eine Zeile zuruckgegeben, weil der Nennerder rationalen Funtkion |γ(t)− x|2 nicht von x abhangt.

Listing A.2.9: MatlabMatlabMatlab-Funktion distCurve.m

1 function [nom , den] = distCurve(gamma , x)

2 % DISTCURVE Compute the squared distance of a points and

3 % a curve.

4 % Computes the squared of the euclidean distance of a

5 % point and a rational curve. The squared distance is a

6 % rational function of the parameter variable of the

7 % curve; DISTCURVE returns the nominator and the

8 % denominator of this function.


9 %

10 % Usage: [nom , den] = distcurve(gamma , x)

11 %

12 % Inputs:




16 % x - n-by -2 vector containing a two dimensional

17 % point in each row

18 %

19 % Outputs:

20 % nom - n-by-d1 matrix; the row nom(k, :) contains

21 % the coefficients for the nominator

22 % polynomial of the squared distance

23 % function between gamma and x(k).

24 %

25 % den - 1-by-d2 vector containing the coefficients

26 % for the denominator polynomial of the

27 % squared distance function between gamma

28 % and x(k) for any index k auf x. As the

29 % denominator of the squared distance ist

30 % independent of x, den consists of only

31 % one row.

32 %

33 % Examples:

34 % x = [1, 3; 0, 0; -1, -1];


36 % [nomDistEll , denDistEll] = ...

37 % distCurve(ellipse 1, x);

38 %

39 % line = createLine ([-1, -1], [1,1], 1);

40 % [nomDistLine , denDistLine] = ...

41 % distCurve(line1, x);

42

43 z1 = ones(size(x,1), ...

44 length(gamma 1,1)) * diag(gamma 1,1);

45 z2 = ones(size(x,1), ...


47 n1 = ones(size(x,1), ...


49 n2 = ones(size(x,1), ...


51


52 p1 = polysum(z1, - polyprod(x(:,1), n1));

53 p2 = polysum(z2, - polyprod(x(:,2), n2));

54 p1 = polyprod(p1, n2);

55 p2 = polyprod(p2, n1);



58

59 nom = polysum(p1 , p2);

60

61 n1 = gamma2, 1;

62 n2 = gamma2, 2;

63

64 den = polyprod( polyprod(n1 , n1), polyprod(n2 , n2) );

Die folgende Funktion drawCurves zeichnet alle Kurven, die in einem n-by-1-Cell-Array ubergeben werden. Um die einzelnen Kurven im Plot unterscheiden zu konnen,werden sie abwechselnd blau und rot gezeichnet.

Listing A.2.10: MatlabMatlabMatlab-Funktion drawCurves.m

1 function drawCurves(curves , n)

2 % DRAWCURVES Plot rational curves.

3 % Draws all passed rational curves onto a plot. In

4 % order to distinguish the passed curves , their are

5 % drawn alternately in blue and in red.

6 %

7 % Usage: drawCurves(curves , n)

8 %

9 % Inputs:

10 % curves - m-by -1 cell array containing a curve in

11 % each cell. Each curve is represented by

12 % a 2-by -2 cell array , see the function


14 % n - An integer equal to or greater than 1

15 % that defines the size of the grid , each

16 % curve is evaluated on

17 %

18 % Outputs:

19 % No Output

20 %

21 % Example:

Abschnitt A.3: Matlab-Funktionen zur Integration in der Randelementmethode 107

22 % semiEllipse = createSemiEllipse (2, 1.5, 2);

23 % drawCurves(semiEllipse , 100);

24

25 m = length(curves);

26 grid = 0:n;

27 grid = 2*grid/n - 1;

28 grid = grid ’;

29

30 hold off

31

32 for k=1:m

33 points = evalPoints(curvesk, grid);

34 if (mod(k,2) == 0)

35 plot(points (:,1) ’, points (:,2) ’, ’BLUE’);

36 else

37 plot(points (:,1) ’, points (:,2) ’, ’RED’);

38 end

39 hold on

40 end

41

42 hold off

A.3 Matlab-Funktionen zur Integration in der

Randelementmethode

In diesem Abschnitt fuhren wir der Vollstandigkeit halber nochmals alle Funktionenauf, die unmittelbar mit der Berechnung von Randintegralen im Zusammenhangstehen. Die meisten dieser Funktionen wurden bereits im Hauptteil vorgestellt underlautert. Es wurden die folgenden Funktionen implementiert

• Die Funktion diagTz berechnet die Diagonalisierung der Matrix T(n)z aus Ab-

schnitt 4.4.

• Die Funktion approxTf berechnet die Matrix T(n)f aus Abschnitt 4.4.

• Die Funktion qtm1New ist eine leicht modizifizierte Version des Algorithmusaus [2], der die Integrale

∫ 1

−1Pj(t) log(t − λ) dt, j = 0, ..., n mit Hilfe einer

Drei-Term-Rekursion berechnet.

• Die Funktion fCoefLog berechnet die In-tegrale der Form 1

2π

∫ 1

−1Pj(t) log(|γ(t) − x|) dt fur j = 0, ..., n, wenn γ eine

rationale Kurve ist.

• Die Funktion singLayPot berechnet die Einfachschichtpotentiale derLegendre-Polynome Pj, j = 0, ..., n.


• Die Funktion galerkinBlock berechnet den Galerkinblock Ak0j0 fur zwei Kur-ven γj0 und γk0 .

• Die Funktion galerkinMatrix setzt die einzelnen Galerkinblocke zur gesamtenGalerkinmatrix zusammen.

All diese Funktionen befinden sich auch auf der beigelegten CD im Verzeichnis mat-lab/integrals. Zu jeder Funktion folgt nun ein kurzer, beschreibender Text und derkomplette, kommentierte Quellcode. Input- und Output-Argumente jeder Funktionsind im Matlab-help-Kommentar unmittelbar nach der Funktionendeklaration imQuellcode genau beschrieben. Außerdem befindet sich dort auch stets ein einfachesBeispiel fur die Benutzung der Funktion.

Die folgende Funktion diagTz berechnet die Diagonalisierung der OperatormatrixT

(n)z aus Abschnitt 4.4. Sie gibt die orthogonale Transformationsmatrix V und die

Eigenwerte der Matrix T(n)z im Vektor d zuruck, sodass T

(n)z = V diag(d)V ∗ gilt. Die

Funktion verwendet persistente Variablen, damit die Diagonalisierung immer nurdann neu berechnet werden muss, wenn der ubergebene Parameter n zur Bestim-mung der Große von T

(n)z sich andert.

Listing A.3.1: MatlabMatlabMatlab-Funktion diagTz.m

1 function [V, d] = diagTz(n)

2 % DIAGTZ Compute the diagonalized matrix of the

3 % multiplier operator belonging to z

4 % Computes the diagonalization of the operator matrix

5 % that belongs to the multiplier operator of the

6 % injection z: [-1,1] -> C. DIAGTZ uses persistent

7 % variables for the result of the diagonalization; a

8 % new computation of the diagonalization is only

9 % performed if the input paramter n, that defines the

10 % size of the output data , changes.

11 %

12 % Usage: [V, d] = diagTz(n)

13 %

14 % Inputs:

15 % n - an Integer that defines the size of the finit

16 % dimensional (n+1)-by -(n+1)-submatrix which

17 % is used by the function instead of the

18 % infinit dimensional operator matrix.

19 %

20 % Outputs:

21 % V - an orthogonal (n+1)-by -(n+1)-matrix containing

22 % the eigenvectors of the operator submatrix.

23 %


24 % d - (n+1)-by -1 vector containing the eigenvalues

25 % of the operator submatrix; thus the operator

26 % submatrix is V * diag(d) * V’.

27 %

28 % Example:

29 % [V, d] = diagTz (1000);

30 % % a second call with the same parameter passed is

31 % % much faster:

32 % [V, d] = diagTz (1000);

33 % % a change of the parameter requires a new

34 % % computation of the diagonalization and hence the

35 % % function will take about as much time as the

36 % % first call in this exmaple:

37 % [V, d] = diagTz (1001);

38

39 persistent persV;

40 persistent persd;

41 persistent persn;

42

43 if(isempty(persn))

44 persn = n;

45 else

46 if(persn ~= n)

47 persn = n;

48 persV = [];

49 persd = [];

50 end

51 end

52

53 if(isempty(persV))

54

55 matrix = zeros(n+1,n+1);

56 for i =1:n

57 matrix(i+1,i) = i / sqrt (4*i^2 - 1);

58 matrix(i,i+1) = matrix(i+1,i);

59 end

60

61 [persV ,D] = eig(matrix);

62 persd = diag(D);

63

64 end

65

66 V = persV;


67 d = persd;

Die folgende Funktion approxTf berechnet die Naherungsmatrix T(n)f an die Matrix

T(n)f mit Hilfe der Darstellung aus Satz 4.4.5. Vgl. Abschnitt 4.4 fur eine Herleitung

und Erlauterung der Funktion.

Listing A.3.2: MatlabMatlabMatlab-Funktion approxTf.m

1 function Tf = approxTf(f, n)

2 % APPROXTF Compute a multiplier operator matrix

3 % Computes a finit dimensional approximation for the

4 % multiplier operator matrix Tf belonging to the

5 % continous function f. The matrix is computed by

6 % applying a function calculus to the output of

7 % DIAGTZ.

8 %

9 % Usage: Tf = approxTf(f, n)

10 %

11 % Inputs:

12 % f - function handle representing a contious

13 % function on [-1, 1].


15 % (n+1)-by -(n+1) output matrix Tf.

16 %

17 % Outputs:

18 % Tf - (n+1)-by(n+1) matrix

19 %

20 % Examples:

21 % f = @(t) (exp(t) .* t);

22 % Tf = approxTf(f, 300);

23 %


25 % deriv = normOfDeriv(ellipse 1);

26 % TDeriv = approxTf(deriv , 300);

27


29

30 d = f(d);

31 Tf = V;

32 for k = 1:n+1

33 Tf(:, k) = Tf(:, k) * d(k);


34 end

35 Tf = Tf * V’;

Die folgende Funktion qtm1New implementiert die Drei-Term-Rekursion aus [2] zur

Berechnung der Integrale∫ 1

−1Pj(t) log(t− λ) dt, j = 0, ..., n, wobei λ eine beliebige

komplexe Zahl ist. Siehe [2] fur eine Herleitung und ausfuhrliche Erlauterung. Wirhaben einige Modifikationen an der Funktion vorgenommen, die im Kommentartextdes Quellcodes erlautert sind.

Listing A.3.3: MatlabMatlabMatlab-Funktion qtm1New.m

1 function matrix = qtm1New(x, k)

2 % QTM1NEW Compute fourier coefficients of log(t - x)


4 % log(t - x) where x is a complexe number , using a

5 % backward or a forward recurrence depending on x.

6 % There are the following modifications compared with

7 % the function QTM1:

8 % - QMT1NEW does not have a parameter fac be

9 % multiplied with the output integrals , as all

10 % multiplications with scalars are performed

11 % after the call of QTM1NEW in our algorithm

12 % - the matlab code was adjusted in order to perform

13 % vector operations on the input argument x

14 % instead of using a loop. The distinction

15 % between arguments inside and outside the

16 % ellipse is now implemented by the using vector

17 % subscriptions.

18 % - if any input argument x(k) is Inf , QTM1New will

19 % return zero for all fourier coefficients of

20 % log(t - x(k)). This modification simplifies the

21 % use of QTM1New in the function FCOEFLOG , where

22 % QTM1NEW is applied to vectors that contain

23 % roots of polymoials; now the roots of

24 % polynomials of different degree can be stored

25 % in one matrix , by filling the missing roots of

26 % lower -degree polynomials with the value Inf.

27 % Usage: matrix = qtm1New(x, k)

28 %

29 % Inputs:

30 % x - n-by -1 vector containing complex numbers


31 % p - an integer that defines the degrees if



34 %

35 % Outputs:

36 % matrix - n-by -(p+1)-matrix; the row matrix(k, :)

37 % contains the fourier coefficients of

38 % log(t - x(k)).

39 %

40 % Example:

41 % x = [0; 0.5; 1; 1.5; 0.5*i; 1*i; ...

42 % 0.5 + 0.5*i; 1 + 1*i];

43 % matrix = qtm1New(x, 15);

44

45 n = length(x);

46 matrix = zeros(n, k+1);

47

48

49 % compute integrals for polynomial degrees zeroand one:

50

51 % non -real arguments:

52 subscr = (abs(imag(x)./real(x)) >= 10^ -12);

53 if(sum(subscr) ~= 0)

54 xKlein = x(subscr);

55 % polynomial degree zero:

56 vec1 = 1 - xKlein;

57 vec2 = -1 - xKlein;

58 vec3 = log(vec1);

59 vec4 = log(vec2);

60 matrix(subscr , 1) = vec1 .* vec3 - vec2 .* vec4 - 2;

61 % polynomial degree one:

62 if(k >= 1)

63 matrix(subscr , 2) = (vec1 .* vec1 .* vec3 ...

64 - vec2 .* vec2 .* vec4) / 2 + xKlein ...

65 .* (1 + matrix(subscr , 1));

66 end

67 end

68

69 % real arguments that are distinct to 1 and -1:

70 %subscr2 = (and(~subscr ,(abs(real(x)) ~= 1)));

71

72 %debug

73 subscr2 = (and(~subscr ,abs(abs(real(x)) -1) >=10^-12));


74

75 if(sum(subscr2) ~= 0)

76

77 xKlein = real(x(subscr2));

78 % polynomial degree zero:

79 matrix(subscr2 , 1) = log(abs( (-xKlein .* xKlein ...

80 + 1) )) + xKlein .* log(abs( (xKlein + 1) ...

81 ./(- xKlein + 1) )) - 2;

82 % polynomial degree one:

83 if(k >= 1)

84 matrix(subscr2 , 2) = (xKlein .^2 - 1) ...

85 .* log(abs( (xKlein + 1)./(- xKlein ...

86 + 1) )) / 2 - xKlein;

87 end

88 end

89

90 % arguments 1 and -1:

91 %subscr2 = (and(~subscr , (abs(real(x)) == 1)));

92

93 % debug

94 subscr2 = (and(~subscr , abs(abs(real(x)) -1) < 10^ -12));

95

96 if(sum(subscr2) ~= 0)

97

98 matrix(subscr2 , 1) = (2* log (2) - 2) ...

99 * ones(sum(subscr2) ,1);

100 if(k >= 1)

101 matrix(subscr2 , 2) = -real(x(subscr2));

102 end

103 end

104

105 % compute integrals for higher polynomial degree by three

106 % term recurrence

107 if(k >= 2)

108 % distinguish arguments inside and outside of the

109 % ellipse in order to choose forward or backward

110 % recurrence for each element

111 b = min (1 ,4.5/(k+1) ^1.17);

112 a = 1+b^2;

113 subscr = (real(x).^2 / a + (imag(x)/b).^2 < 1);

114

115 % use forward recurrence for arguments inside the

116 % ellipse


117 if(sum(subscr) >= 1)


119 matrix(subscr , 3) = 2/3 + xKlein ...

120 .* matrix(subscr , 2);

121 for l = 2:k-1

122 matrix(subscr ,l+2) = ((2*l+1)*xKlein ...

123 .* matrix(subscr ,l+1) ...

124 - (l-1)*matrix(subscr ,l)) / (l+2);

125 end

126

127 end % end of forward recurrence

128

129 % use backward recurrence for arguments outside the

130 % ellipse

131 subscr = ~subscr;

132 if(sum(subscr) >= 1)


134

135 % define tolerance for gautschi -algorithm and

136 % calculate how many iterations are needed

137 tol = 1e-14;

138

139 z2 = abs(real(xKlein))+1i*abs(imag(xKlein));

140 vec1 = abs(z2+sqrt(z2.^2 -1));

141

142 myMin = min(vec1);

143 nuMax = k + max(ceil( -log(tol) ...

144 / (2*log(myMin)) ), 0);

145

146 nKlein = length(xKlein);

147 r = ones(nKlein , nuMax);

148

149 for l = nuMax :-1:2

150 s = nuMax + 2 - l;

151 bl = (l*l - 1) / (4*l*l - 1);

152 r(:,s) = bl * r(:,s) ./ (xKlein - r(:, s-1));

153 end

154

155 for l = 2:k

156 s = nuMax + 2 - l;

157 matrix(subscr ,l+1) = (2*l-1)/(l+1) ...

158 * r(:,s) .* matrix(subscr , l);

159 end


160 end % end of backward recurrence

161 end

162

163 % if any input value was Inf , than the corresponding

164 % integrals are set to zero

165 subscr = (x==Inf);

166 if(sum(subscr) > 0)

167 for k = 1:size(matrix ,2)

168 matrix(subscr ,k) = zeros(sum(subscr) ,1);

169 end

170 end

Die folgende Funktion fCoefLog berechnet die Integraleder Form 1

2π

∫ 1

−1Pj(t) log(|γ(t) − x|) dt, j = 0, ..., n wobei γ eine rationale Kurve

und x ein Punkt im R2 ist. Sie tut dies, indem sie Nenner und Zahler der Funktion|γ(t) − x|2 faktorisiert und anschließend die Funktion qtm1New anwendet. SieheAbschnitt 4.3 fur eine ausfuhrliche Erlauterung.

Listing A.3.4: MatlabMatlabMatlab-Funktion fCoefLog.m

1 function coef = fCoefLog(gamma , x, n)

2 % FCOEFLOG Compute fourier coefficients for the

3 % logarithm of a distance function.


5 % log(norm(gamma(t) - x)) / (2*pi), where gamma(t) is

6 % a rational curve and x a two dimensional point. The

7 % function makes use of a three term recurrence that

8 % is implemented by the function QTM1NEW.

9 %

10 % Usage: coef = fCoefLog(gamma , x, n)

11 %

12 % Inputs:





17 % vector in each row. For each of these

18 % points the fourier coefficients of

19 % log(norm(gamma(t) - x)) / (2*pi) will be

20 % computed.

21 % n - An integer that defines the length of the


22 % computed fourier expansion. The output

23 % fourier coefficients will be computed

24 % for the Legendre -Polynomials P_0 , ...,

25 % P_n.

26 %

27 % Outputs:

28 % coef - m-by -(n+1) matrix; each row coef(k, :)

29 % contains the fourier coefficients that

30 % belong to the point x(k).

31 %

32 % Example:


34 % x = [1,3; 1,1; 1,0];

35 % coef = fCoefLog(ellipse 2, x, 100);

36

37 [nom , den] = distCurve(gamma , x);

38 m = size(nom , 1);

39

40 fac = lCoef(den);

41 den = den / fac;

42 nom = nom / fac;

43

44 nom = adjustLCoef(nom , 10^ -12);

45

46 fac = lCoef(nom);

47 r = polyroots(nom);

48

49 coef = zeros(m, n+1);

50 d = size(r, 2);

51 for k=1:2:d

52 coef = coef + 2 * real(qtm1New(r(:, k), n));

53 end

54

55 r = polyroots(den);

56 d = size(r, 2);

57 for k=1:2:d

58 val = real(qtm1New(r(k), n));

59 for l=1:m

60 coef(l, :) = coef(l, :) - 2 * val;

61 end

62 end

63

64 for k=1:n+1


65 coef(:, k) = coef(:, k) * sqrt ((2*k - 1) / 2);

66 end

67

68 coef(:, 1) = coef(:, 1) + log(fac) * sqrt (2);

69 coef = coef / 2;

70 coef = coef / (2*pi);

Die folgende Funktion singLayPot berechnet die Einfachschichtpotentiale derLegendre-Polynome Pj, j = 0, ..., n uber einer Kurve γ an einem Punkt x ∈ R2,

das heißt sie berechnet die Integrale∫ 1

−1Pj(t)|γ(t)| log |γ(t)− x| dt, j = 0, ..., n. Fur

eine Herleitung und Erklarung des verwendeten Algorithmus siehe die Abschnitte4.2 bis 4.5.

Listing A.3.5: MatlabMatlabMatlab-Funktion singLayPot.m

1 function pot = singLayPot(gamma , x, p, n)

2 % SINGLAYPOT Compute the single layer potential for

3 % Legendre -Polynomials on a rational curve.

4 % Computes the single layer potential of a point x for

5 % Legendre Polynomials P_0 , ..., P_p. The integrals are

6 % computed by use of the functions FCOEFLOG and

7 % APPROXTF.

8 %

9 % Usage: pot = singLayPot(gamma , x, p, n).

10 %

11 % Inputs:







18 % these points.




22 % P_0 , ..., P_p.








29 %

30 % Outputs:




34 % P_0 , ... P_p.

35 %

36 % Example:


38 % x = [1,3; 1,1; 1,0];

39 % pot = singLayPot(ellipse 2, x, 30, 50);

40

41 f = normOfDeriv(gamma);

42 pot = transpose(fCoefLog(gamma , x, n));

43 Tf = approxTf(f, n);

44 pot = Tf * pot;

45 pot = transpose(pot);

46 pot = pot(:, 1:p+1);

Die folgende Funktion galerkinBlock berechnet den Galerkinblock Ak0j0 fur zweiubergebene Kurven γj0 und γk0 . Sie berechnet hierzu eine Fourierentwicklung derFunktion |γk0(s)|(V ϕj0j)(γk0(s)). Siehe Abschnitt 6.1 fur eine Erlauterung.

Listing A.3.6: MatlabMatlabMatlab-Funktion galerkinBlock.m

1 function A = galerkinBlock(gammak0 , gammaj0 , p, n)

2 % GALERKINBLOCK Compute the galerkin block for two parts

3 % of the boundary

4 % Computes an approximation of the galerkin block of a

5 % required size for two parts of the boundary that are

6 % paremterized by rational curves. The galerkin block

7 % as computed by applying a functional calculus to the

8 % output of the function DIAGTZ.

9 %

10 % Usage: A = galerkinBlock(gammak0 , gammaj0 , p, n)

11 %

12 % Inputs:

13 % gammak0 - 2-by -2 cell array that represents a


15 % explanation.


16 % gammaj0 - 2-by -2 cell array that represents a


18 % explanation.






24 % APPROXC and APPROXTF. It is required



27 % computed integrals.

28 %

29 % Outputs:

30 % coef - (p+1)-by -(p+1)-matrix that approximates

31 % the galerkin block

32 %

33 % Example:



36 % 50, 100);


38 % 50, 100);

39

40 A = zeros(n+1,p+1);

41 normk0 = normOfDeriv(gammak0);

42


44 slp = singLayPot(gammaj0 , evalPoints(gammak0 , d), p, n);

45

46 for j=1:p+1

47 tmp = normk0(d) .* slp(:,j);

48 A(:,j) = sqrt (2) * V * (tmp .* V(1,:) ’);

49 end

50 A = A(1:p+1,:);

Die folgende Funktion galerkinMatrix berechnet die Galerkinmatrix uber einemRand, der durch Kurven γ1, ..., γm beschrieben wird. Sie verwendet zur Berechnungder Galerkinblocke die Funktion galerkinBlock und kopiert lediglich die einzelnenBlocke in eine Gesamtmatrix.

Listing A.3.7: MatlabMatlabMatlab-Funktion galerkinMatrix.m


1 function matrix = galerkinMatrix(gammas , p, n)

2 % GALERKINMATRIX Compute the galerkin matrix

3 % Computes an approximation of the galerkin matrix of a

4 % required size , if the boundary is parameterized by

5 % rational curves. The function GALERKINBLOCK is used

6 % to compute the blocks the galerkin matrix consists

7 % of.

8 %

9 % Usage: A = galerkinMatrix(gammas , p, n)

10 %

11 % Inputs:

12 % gammas - m-by -1 cell array containing a rational

13 % curve in each cell. Each curve is

14 % presented by a 2-by -2 cell array. See


16 % explanation.

17 % p - an integer that defines the size of the

18 % galerkin blocks; each block is a

19 % (p+1)-by -(p+1)-matrix and thus the

20 % galerkin matrix has the dimension

21 % m*(p+1)-by -m*(p+1).



24 % GALERKINBLOCK respectively by the

25 % functions that are called by

26 % GALERKINBLOCK . It is required that

27 % n >= p. Increasing the ratio n / p will

28 % improve the approximation of the

29 % galerkin matrix.

30 %

31 % Outputs:

32 % coef - m*(p+1)-by -m*(p+1)-matrix that

33 % approximates the galerkin matrix.

34 %

35 % Example:


37 % A = galerkinMatrix(ellipse , 50, 100);

38

39 m = length(gammas);

40 matrix = zeros((p+1)*m, (p+1)*m);

41

42 for k = 1:m

43 for j=1:m


44 matrix ((k-1)*(p+1) +1:k*(p+1), ...

45 (j-1)*(p+1)+1:j*(p+1)) = ...

46 galerkinBlock(gammask, gammasj, p, n);

47 end

48 end


Anhang B

Testfunktionen und -skripte

Der Vollstandigkeit halber fuhren wir in diesem Kapitel des Anhangs nochmals alleMatlab-Funktionen und -Skripte auf, die wir implementiert haben, um numerischeTests durchzufuhren. Die meisten dieser Funktionen und Skripte wurde bereits inKapitel 5 und Abschnitt 6.2 vorgestellt. Wir verzichten deshalb im Anhang aufausfuhrliche Erlauterungen und geben lediglich den Quellcode mit jeweils einer kur-zen Bemerkung wieder.Im folgenden sind alle Funktionen und Skripte aufgefuhrt, die wir zur Durchfuhrungnumerischer Tests verwendet haben:

• Die Funktion cmpSlpToRef berechnet mit n Freiheitsgraden das Einfach-schichtpotential der ersten p Legendre-Polynome uber einer rationalen Kurveund vergleicht das Ergebnis mit einem ubergebenen Referenzwert. Sie ist inListing 5.1.1 / B.1.1 aufgefuhrt.

• Die Funktion chooseTestPoints wahlt zu einer ubergebenen Kurve und einemubergebenen Abstand diejenigen Punkte eines Gitters aus, die naher an derKurve liegen, als der vorgegebene Abstand. Durch Setzen eines Flags konnenstattdessen auch die Punkte ausgegeben werden, die weiter entfernt liegen. DieFunktion ist in Listing B.1.2 aufgefuhrt.

• Das Skript ExamplePointsLine ist ein Beispielskript, das die Verwendungder Funktion chooseTestPoints demonstriert. Es ist in Listing 5.1.2 / B.1.3aufgefuhrt.

• Das Skript SomeExamplePoints fuhrt die Funktion chooseTestPoints furmehrere Beispiele aus. Diese Beispiele werden in mehreren Tests in den Ab-schnitten 5.3 und 5.4 verwendet. Das Skript ist in Listing B.1.4 aufgefuhrt.

• Die Funktion slpQuad berechnet das Einfachschichtpotential der ersten pLegendre-Polynome uber einer rationalen Kurve per Quadratur. Sie ist in Lis-ting 5.3.1 / B.1.6 aufgefuhrt.

• Das Skript PolynomialDegree berechnet das Einfachschichtpotentials der lin-ken Halfte des Einheitskreises an drei gegenuberliegenden Punkten. Es veran-schaulicht, dass der Zahlerpolynomgrad der rationalen Funktion |γ(t)−x|2 ander Stelle x = (1, 0)T eine Sprungstelle besitzt. Das Skript PolynomialDegreeist in Listing 5.2.1 / B.1.5 aufgefuhrt.

• Die Funktion plotFuncCalcV sQuad vergleicht das Einfachschichtpotential,welches von der Funktion singLayPot (Listing 4.5.1 / A.3.5) berechnet wirdmit dem Ergebnis der Matlab-Quadratur in der Funktion slpQuad. Die Funk-tion plotFuncCalcV sQuad ist in Listing 5.3.2 / B.1.7 aufgefuhrt.

124 Anhang B: Testfunktionen und -skripte

• Das Skript FuncCalcV sQuad fuhrt die Funktion plotFuncCalcV sQuad furalle Testbeispiele aus, die vom Skript SomeExamplePoints erzeugt werden.Das Skript FuncCalcV sQuad ist in Listing B.1.8 aufgefuhrt.

• Die Funktion plotDecreasingError berechnet das Einfachschichtpotential derersten p Legendre-Polynome und gibt aus, wie der Unterschied zu einem Re-ferenzergebnis abnimmt, wenn die Anzahl der Freiheitsgerade bei der Berech-nung steigt. Die Funktion plotDecreasingError ist in Listing 5.4.1 / B.1.9aufgefuhrt.

• Das Skript DecreasingError fuhrt die Funktion plotDecreasingError fur alleTestbeispiele aus, die vom Skript SomeExamplePoints erzeugt werden. DasSkript DecreasingError ist in Listing B.1.10 aufgefuhrt.

• Die Funktion plotRequiredDim gibt verschiedene maximale Basis-Polynomgrade p vor und berechnet fur steigende Freiheitsgrade jeweils dasEinfachschichtpotential der Legendre-Polynome P0, ..., Pp. Fur jedes vorgege-bene p gibt das Skript aus, wieviele Freiheitsgrade die Funktion singLayPot(Listing 4.5.1 / A.3.5) benotigt, damit die Einfachschichtpotentiale hochstensum eine vorgegebene Schranke tol von einem Referenzwert abweichen. DieFunktion plotRequiredDim ist in Listing 5.4.2 / B.1.11 aufgefuhrt.

• Das Skript RequiredDim fuhrt die Funktion plotRequiredDim fur alle Test-beispiele aus, die vom Skript SomeExamplePoints erzeugt werden. Das SkriptRequiredDim ist in Listing B.1.12 aufgefuhrt.

• Die Funktion slpOnDiskExact berechnet das Einfachschichtpotential der kon-stanten 1-Funktion auf dem Einheitskreis analytisch. Die Funktion ist in Lis-ting 5.5.1 / B.1.13 aufgefuhrt.

• Die Funktion slpOnDisk berechnet das Einfachschichtpotential der konstan-ten 1-Funktion auf dem Einheitskreis numerisch mit Hilfe der FunktionsingLayPot (Listing 4.5.1 / A.3.5). Die Funktion slpOnDisk ist in Listing5.5.2 / B.1.14 aufgefuhrt.

• Das Skript PlotSlpOnDisk zeichnet das Einfachschichtpotential der konstan-ten 1-Funktion auf dem Einheitskreis. Das Skript ist in Listing B.1.15 auf-gefuhrt.

• Die Funktion plotErrorOnDisk berechnet das Einfachschichtpotential derkonstanten 1-Funktion auf dem Einheitskreis einmal analytisch mit Hilfe derFunktion slpOnDiskExact und einmal numerisch mit Hilfe der FunktionslpOnDisk. Anschließend wird der Fehler in einem Gebiet um den Einheitkreisgeplottet. Das Skript plotErrorOnDisk ist in Listing 5.5.3 / B.1.16 aufgefuhrt.

• Das Skript ErrorOnDisk fuhrt die Funktion plotErrorOnDisk fur verschie-dene Anzahlen von Freiheitsgraden aus. Es ist in Listing B.1.17 aufgefuhrt.

• Das Skript ErrorOnDiskRefined fuhrt die Funktion plotErrorOnDisk aufeinem sehr feinen Gitter aus. Es ist in Listing B.1.18 aufgefuhrt.

125

• Das Skript PolygonV sSmooth berechnet das Einfachschichtpotential des null-ten Legendre-Polynoms P0 auf einer Ellipse. Die Berechnung wird zuerst ubereiner rational interpolierten Kurve durchgefuhrt, welche die Ellipse exakt be-schreibt; anschließend wir die Ellipse durch einen Polygonzug approximiertund das Einfachschichtpotential uber die einzelnen Streckenzuge aufsummiert.Das Skript gibt die Abweichung der Ergebnisse im exakten und im linear in-terpolierten Fall fur verschiedene Eckenzahlen das Polygons aus. Das SkriptPolygonV sSmooth ist in Listing 5.6.1 / B.1.19 aufgefuhrt.

• Das Skript DecreasingErrorGalerkin fuhrt denselben Test wieDecreasingError fur die Funktion galerkinMatrix (Listing A.3.7) anstelleder Funktion singLayPot durch. Es ist in Listing B.1.20 aufgefuhrt.

• Das Skript RequiredDimGalerkin fuhrt denselben Test wie RequiredDimfur die Funktion galerkinMatrix (Listing A.3.7) anstelle der FunktionsingLayPot durch. Es ist in Listing B.1.21 aufgefuhrt.

All diese Funktionen befinden sich auch auf der beigelegten CD im Verzeichnis mat-lab/examples. Zu jeder Funktion und jedem Skript folgt nun der komplette, kom-mentierte Quellcode. Fur Funktionen sind alle Input- und Output-Argumente imMatlab-help-Kommentar unmittelbar nach der Funktionendeklaration im Quellco-de genau beschrieben. Außerdem befindet sich dort auch stets ein einfaches Beispielfur die Benutzung der Funktion.

Die Funktion cmpSlpToRef vergleicht das Ergebnis der Funktion singLayPot miteinem Referenz-Ergebnis.

Listing B.1.1: MatlabMatlabMatlab-Funktion cmpSlpToRef.m

1 function err = cmpSlpToRef(gamma , x, p, n, ref)

2 % CMPSLPTOREF Compare the output of SINGLAYPOT to a

3 % reference value

4 % Compute the output of singLayPot(gamma , x, p, n). For

5 % eache point of x, the output vector is compared to

6 % the associated vector in the matrix ref. For each

7 % point in x, CMPSLPTOREF will compute the euclidean

8 % norm of the difference of both vectors und return the

9 % mean value of all these norms.

10 %

11 % Usage: err = cmpSlpToRef(gamma , x, p, n, ref)

12 %

13 % Inputs:








20 % these points.




24 % P_0 , ..., P_p.







31 % ref - (m)-by -(p+1)-matrix containing in row

32 % ref(k, :) the single layer potentials


34 % P_0 , ... P_p , which were computed by use

35 % of any other numerical function , which

36 % is expected to compute the values very

37 % precisely , e.g. the function singLayPot ,

38 % if used with a very high degree of

39 % freedoms

40 %

41 % Outputs:

42 % err - a double which is the mean value of all

43 % errors that belong each to one of the

44 % input points represented by a row

45 % x(k,:). Each of these errors is the

46 % euclidean norm of the difference between

47 % the single layer potentials at x(k,:)

48 % computed with n degrees of freedom and

49 % the reference values contained in the

50 % matrix ref

51 %

52 % Examples:

53 % parabola = createCurve ([1,0], 1, [1,0,0], 1);

54 % x = [0,-1; 1,0; 2,1];

55 % p = 10;

56 % nRef = 500;

57 % ref = singLayPot(gamma , x, p, nRef);

58 % for n=p:2*p

59 % err = cmpSlpToRef(gamma , x, p, n, ref);

60 % display(err)

127

61 % end

62 %

63

64 slp = singLayPot(gamma , x, p, n);

65 difference = ref(:, 1:p+1) - slp(:, 1:p+1);

66

67 allErrors = zeros(size(x,1), 1);


69 allErrors(k) = norm(difference(k,:), 2);

70 end

71

72 err = mean(allErrors);

Die Funktion chooseTestPoints wahlt zu einer Kurve und einem ubergegebene Ab-stand entweder diejenigen Punkte eines Gitters aus, die naher als der vorgegebeneAbstand an der Kurve liegen, oder (bei entsprechend ubergebenem Flag) diejenigenPunkte, die weiter entfernt von der Kurve liegen.

Listing B.1.2: MatlabMatlabMatlab-Funktion chooseTestPoints.m

1 function points = chooseTestPoints(gamma , xx, yy, ...

2 dist , close)

3 % CHOOSEPOINTS Chooses points inside or outside a

4 % neighborhood of a curve

5 % Compute the distance to the curve gamma for each of

6 % the points on the meshgrid [xx, yy]. If close == 0

7 % all points with a distance from gamma that is

8 % bigger than dist will be returned. Otherwise all

9 % points that are closer than dist to gamma will be

10 % returned.

11 %

12 % Usage: points = chooseTestPoints(gamma , xx, yy, ...

13 % dist , close)

14 %

15 % Inputs:








22 % these points.

23 % xx - a matrix representing the x-components of

24 % a meshgrid

25 % yy - a matrix representing the y-components of

26 % a meshgrid

27 % dist - a double that divides the two dimensional

28 % space into an area of points that are

29 % closer than dist to gamma , and all other

30 % points that are more distant from gamma.

31 % close - a flag. If it is set ~=0, all points

32 % that are closer than dist to gamma ,

33 % will be returned. In order to return all

34 % points closer than dist to gamma , it

35 % must be set to 0.

36 %

37 % Outputs:

38 % pot - n-by -2-matrix containing all two

39 % dimensional points on the meshgrid [xx,

40 % yy] that are close or distant two gamma ,

41 % depending on the flag close.

42 %

43 % Examples:



46 % linX = linspace(-2, 0, 50);

47 % linY = linspace(0, 1, 50);

48 % [xx , yy] = meshgrid(linX , linY);

49 %

50 % % choose pooints close to gamma:

51 % pointsCl = chooseTestPoints(gamma , xx, yy, ...,

52 % 0.01, 1);

53 %

54 % % choose points away from gamma:

55 % pointsAw = chooseTestPoints(gamma , xx, yy, ...,

56 % 0.01, 0);

57 %

58 % % draw points:

59 % hold off

60 % drawCurves ( gamma, 100);

61 % hold on

62 % plot(pointsCl (:,1), pointsCl (:,2), ’.’, ...

63 % ’Color ’, ’BLUE ’);

64 % plot(pointsAw (:,1), pointsAw (:,2), ’.’, ...

129

65 % ’Color ’, ’YELLOW ’);

66

67 t = ( -1:0.002:1) ’;

68 allPoints = evalPoints(gamma , t);

69

70 points = [];

71 for k=1: size(xx ,1);

72 for j=1: size(xx ,2)

73 d = min((xx(k,j) - allPoints (:,1)).^2 + ...

74 (yy(k,j) - allPoints (:,2)).^2);

75 if(close ~= 0 && d <= dist^2 || ...

76 close == 0 && d > dist ^2)

77 points = [points; xx(k,j), yy(k,j)];

78 end

79 end

80 end

Das Skript ExamplePointsLine ist ein Beispielskript fur die FunktionchooseTestPoints.

Listing B.1.3: MatlabMatlabMatlab-Skript ExamplePointsLine.m

1 clear all

2


4 gamma = curve 1;

5 linX = linspace (-1.5, 1.5, 4);

6 linY = linX;



9 0.3, 0);

10


12 hold on


14 axis([-2,2,-2,2]);

15 hold off

Das Skript SomeExamplePoints erzeugt mit Hilfe der Funktion chooseTestPointsmehrere Test-Beispiele, die in den Abschnitten 5.3 und 5.4 fur mehrere Tests ver-wendet werden.


Listing B.1.4: MatlabMatlabMatlab-Skript SomeExamplePoints.m

1 clear all

2

3 % plot points far from a line


5 gamma = curve 1;

6 linX = linspace (-1.5, 1.5, 4);

7 linY = linX;

8 [xx , yy] = meshgrid(linX , linY);


10 0.3, 0);

11

12 subplot (2,3,1);


14 hold on


16 hold off

17

18 % plot points far from a parabola

19 gamma = createCurve ([1,0], 1, [1,0,0], 1);

20 linX = linspace(0, 1.5, 4);

21 linY = linspace (-0.2, 1, 4);


23 points = chooseTestPoints(gamma , ...

24 xx , yy , 0.3, 0);

25

26 subplot (2,3,2);


28 hold on


30 hold off

31

32 % plot points far from a semi -ellipse

33 curve = createEllipse (2, 1, 1);

34 gamma = curve 1;

35 linX = linspace (-2.5, 0, 4);

36 linY = linspace(0, 1, 4);



39 xx , yy , 0.3, 0);

131

40

41 subplot (2,3,3);


43 hold on


45 hold off

46

47 % plot points close to a line


49 gamma = curve 1;

50 linX = linspace (-1.5, 1.5, 10);

51 linY = linX;



54 0.04, 1);

55

56 subplot (2,3,4);


58 hold on


60 hold off

61

62 % plot points close to a parabola


64 linX = linspace (0.001 , 1.5, 10);

65 linY = linspace (-0.2, 1, 10);



68 xx , yy, 0.04, 1);

69

70 subplot (2,3,5);


72 hold on


74 hold off

75

76 % plot points close to a semi -ellipse


78 gamma = curve 1;

79 linX = linspace (-2.5, 0, 10);





83 xx , yy , 0.04, 1);

84

85 subplot (2,3,6);


87 hold on


89 hold off

Das Skript PolynomialDegree wird verwendet, um eine Sprungstelle desZahlerpolynomgrades der rationalen Funktion |γ(t)− x|2 aufzuzeigen.

Listing B.1.5: MatlabMatlabMatlab-Skript PolynomialDegree.m

1 clear all

2

3 % create a semi -circle left to the x2-axis

4 curve = createEllipse (1,1,1);

5 gamma = curve 1;

6

7 % some points n the mirrored semi -circel:

8 x = [1, 0];

9 y = [1, 10^ -10];

10 z = [1, 0.01];

11

12 format compact

13 format long

14

15 singLayPot(gamma , x, 2, 10)

16 singLayPot(gamma , y, 2, 10)

17 singLayPot(gamma , z, 2, 10)

18

19 display(’ ’);

20

21 format short e

22

23 distCurve(gamma , x)

24 distCurve(gamma , y)

25 distCurve(gamma , z)

Die Funktion slpQuad berechnet Einfachschichtpotentiale mit Hilfe der Matlab-

133

Quadratur-Funktion quad.

Listing B.1.6: MatlabMatlabMatlab-Funktion slpQuad.m

1 function pots = slpQuad(gamma , x, p, tol)

2 % SLPQUAD Computes the single layer potential via the

3 % matlab function QUAD




7 % rows x(k,:) of x. That numerical integration is

8 % performed by the matlab function QUAD

9 %

10 % Usage: pots = slpQuad(gamma , x, p, tol)

11 %

12 % Inputs:







19 % these points.




23 % P_0 , ..., P_p



26 % QUAD

27 %

28 % Outputs:




32 % P_0 , ... P_p.

33 %

34 % Examples:


36 % x = [1,3; 1,1; 1,0];

37 % pot = slpQuad(ellipse 2, x, 5, 10^-7);

38


39

40 % create Function -Handles for the Legendre Polynomials

41 % P_0 , ..., P_p , using the matlab -function legendre

42 legendrePols = cell(p+1,1);

43 for j=0:p

44 tmp = zeros(1,j+1);

45 tmp(1) = 1;

46 legendrePolsj+1 = @(t) (tmp*legendre(j, t, ...

47 ’norm’));

48 end

49

50 % initialize a matrix to store the output data

51 pots = zeros(size(x,1), p+1);

52

53 % compute the single layer potentials via the function

54 % matlab -function QUAD


56

57 % initialize the laplace kernel as function

58 % handle

59 [nom , den] = distCurve(gamma , x(k,:));

60 gammaLogDist = @(t) log( polyval(nom , t) ./ ...

61 polyval(den , t) ) / (4*pi);

62

63 gammaDerivNorm = normOfDeriv(gamma);

64

65 for j=1:p+1

66 % initalize the integrand as function handle

67 integrand = @(t) (legendrePolsj(t) ...

68 .* gammaDerivNorm(t) .* gammaLogDist(t));

69

70 % compute the single layer potential via QUAD

71 pots(k,j) = quad(integrand , -1, 1, tol);

72 end

73 end

Die Funktion plotFuncCalcV sQuad vergleicht die Ergebnisse der Funktion slpQuadmit den Ergebnissen der Funktion singLayPot.

Listing B.1.7: MatlabMatlabMatlab-Funktion plotFuncCalcVsQuad.m

135

1 function plotFuncCalcVsQuad(gamma , x, p, n, tol)

2 % PLOTFUNCCALCVSQUAD Computes the single layer potential

3 % via the matlab function QUAD and via the

4 % function SINGLAYPOT und plots the difference





9 % performed by the matlab function QUAD , afterwards it

10 % is performed by the function singLayPot. The results

11 % are compared by the function cmpSlpToRef

12 %

13 % Usage: plotFuncCalcVsQuad(gamma , x, p, n, tol)

14 %

15 % Inputs:







22 % these points.




26 % P_0 , ..., P_p





31 % of n; thus , each entry of n must be at

32 % least as big as p.

33 % For each entry of n the output of

34 % singLayPot is compared the output of

35 % slpQuad which is not depending on n.



38 % n.



41 % QUAD

42 %

43 % Outputs:


44 % no outputs

45 %

46 % Examples:



49 % x = [1,3; 1,1; 1,0];

50 % p = 3;

51 % n = 5:40;

52 % tol = 10^-9;

53 % plotFuncCalcVsQuad(gamma , x, p, n, tol)

54

55

56 % initilaize a vector to store the error for each n

57 err = zeros(length(n) ,1);

58

59 % compute the single layer potential for the

60 % Legendre -polynomials P_0 , ..., P_p and all points x via

61 % the matlab -function quad

62 potQuad = slpQuad(gamma , x, p, tol);

63

64 % compare the result to the result of singLayPot for all

65 % degrees of freedom in the vector n

66 for k=1: length(n)

67 err(k) = cmpSlpToRef(gamma , x, p, n(k), potQuad);

68 end

69

70 % plot the error as a function of the degress of freedom

71 hold off

72 semilogy(n + 1, err , ’-s’, ’MarkerSize ’, 3);



Das Skript FuncCalcV sQuad fuhrt die Funktion plotFuncCalcV sQuad fur mehrereBeispielsituationen aus.

Listing B.1.8: MatlabMatlabMatlab-Skript FuncCalcVsQuad.m

1 clear all

2

3 % choose maximum polynomial degree p

4 p = 6;

137

5 % choose degrees of freedom to test the function

6 % singLayPot with

7 n = p:45;

8 % define a tolerance for the matlab -function quad

9 tol = 10^ -9;

10

11

12 % points far from a line


14 gamma = curve 1;

15 linX = linspace (-1.5, 1.5, 4);

16 linY = linX;


18 x = chooseTestPoints(gamma , xx, yy, ...

19 0.3, 0);

20

21 hold off

22 subplot (2,3,1);

23 plotFuncCalcVsQuad(gamma , x, p, n, tol);

24 hold off

25

26 % points far from a parabola



29 linY = linspace (-0.2, 1, 4);


31 x = chooseTestPoints(gamma , ...

32 xx , yy, 0.3, 0);

33

34 subplot (2,3,2);


36 hold off

37

38 % points far from a semi -ellipse


40 gamma = curve 1;

41 linX = linspace (-2.5, 0, 4);




45 xx , yy , 0.3, 0);

46

47 subplot (2,3,3);



49 hold off

50

51 % points close to a line


53 gamma = curve 1;

54 linX = linspace (-1.5, 1.5, 10);

55 linY = linX;



58 0.04, 1);

59

60 subplot (2,3,4);


62 hold off

63

64 % points close to a parabola


66 linX = linspace (0.001 , 1.5, 10);

67 linY = linspace (-0.2, 1, 10);



70 xx , yy , 0.04, 1);

71

72 subplot (2,3,5);


74 hold off

75

76 % points close to a semi -ellipse


78 gamma = curve 1;

79 linX = linspace (-2.5, 0, 10);




83 xx , yy , 0.04, 1);

84

85 subplot (2,3,6);


87 hold off

Die Funktion plotDecreasingError gibt aus, wie der Fehler der Funktion

139

singLayPot im Vergleich zu einem Referenzwert sinkt, wenn die Anzahl der Frei-heitsgrade erhoht wird.

Listing B.1.9: MatlabMatlabMatlab-Funktion plotDecreasingError.m

1 function plotDecreasingError(gamma , x, p, n, nRef , ...

2 markers , markerSizes)

3 % PLOTDECREASINGERROR Computes the single layer

4 % potential via the function singLayPot and

5 % compares the output to a reference solution





10 % performed by the function singLayPot for a high

11 % degree of freedom in order to compute a reference

12 % solution; afterwards it’s computed for various

13 % degrees of freedom and the result is compared to the

14 % reference solution by the function cmpSlpTpRef. The

15 % error is plottet as a function of the degrees of

16 % freedom.

17 %

18 % Usage: plotDecreasingError(gamma , x, p, n, nRef , ...


20 %

21 % Inputs:







28 % these points.

29 % p - an array containing several integers k,

30 % that defines the degrees of P_j; the

31 % single layer potential will be




35 % are contained in the array k






40 % of n and the output of singLayPot is

41 % compared to a reference solution that

42 % does not depend on n.



45 % n.

46 % nRef - an integer that defines the degrees of

47 % freedom that are used by the funtion

48 % singLayPot in order to compute the


50 % markers - a cell array containing formatting

51 % strings. As the function might be

52 % called not only for one integer p,

53 % but for an array of integers as

54 % well , the error plot might contain

55 % different graphs. In

56 % order to distinguish these graphs ,

57 % the cell array markers has to

58 % contain formatting strings to

59 % specify the markers for the plot;

60 % for each value contained in p,

61 % markers must contain a string

62 % markerSizes - a cell array containing integers to

63 % specifiy the markers that are used

64 % in the error plot; markerSizes

65 % must contain one integer for each

66 % value of p.

67 %

68 % Outputs:

69 % no outputs

70 %

71 % Examples:



74 % x = [1,3; 1,1; 1,0];

75 % p = [3,6,9];

76 % markers = ’-o’, ’-x’, ’-s’;

77 % markerSizes = 2,6,3;

78 % n = 3:30;

79 % nRef = 200;

80 % plotDecreasingError(gamma , x, p, n, nRef , ...

141


82

83


85 % solutions with


87



90





95 % the function singLayPot

96 if(n(l) >= p(k))

97 % compute and store the error

98 err(k, l) = cmpSlpToRef(gamma , ...

99 x, p(k), n(l), slpRef);

100 else

101 start(k) = l + 1;

102 end

103 end

104 end

105


107 hold off


109 semilogy(n(start(k):end), err(k, start(k):end), ...

110 markersk, ’MarkerSize ’, markerSizesk);

111 %text(n(start(k)), err(k, start(k)), ...

112 % [’ p=’, int2str(p(k))]);

113 if(k == 1)



116 end

117 hold on

118 end

119 % plot legend

120 info = cell(length(p) ,1);


122 infok = strcat(’p=’, int2str(p(k)));

123 end


124 plotLegend = legend(info , length(p));

125 set(plotLegend ,’Interpreter ’,’none’)

Das Skript DecreasingError fuhrt die Funktion plotDecreasingError fur mehrereBeispielsituationen aus.

Listing B.1.10: MatlabMatlabMatlab-Skript DecreasingError.m

1 clear all

2

3 % choose the polynomial degrees to test the convergence:

4 p = [0, 10, 30, 100] ’;

5 % choose the marker types to plot the results for each p:

6 markers = ’->’, ’-*’, ’-o’, ’-s’;

7 % also choose the markers sizes:

8 markerSizes = 4,4,4,4;

9



12 % single layer potentials will be computed and compared to

13 % a reference solution

14 n = 5:5:150;

15


17 % solutions with

18 nRef = 500;

19

20



23 gamma = curve 1;

24 linX = linspace (-1.5, 1.5, 4);

25 linY = linX;



28 0.3, 0);

29

30 hold off

31 subplot (2,3,1);

32 plotDecreasingError(gamma , x, p, n, nRef , markers , ...

33 markerSizes)

143

34 hold off

35




39 linY = linspace (-0.2, 1, 4);



42 xx, yy, 0.3, 0);

43

44 subplot (2,3,2);


46 markerSizes)

47 hold off

48



51 gamma = curve 1;

52 linX = linspace (-2.5, 0, 4);




56 xx , yy, 0.3, 0);

57

58 subplot (2,3,3);


60 markerSizes)

61 hold off

62



65 gamma = curve 1;

66 linX = linspace (-1.5, 1.5, 10);

67 linY = linX;



70 0.04, 1);

71

72 subplot (2,3,4);


74 markerSizes)

75 hold off

76




79 linX = linspace (0.001 , 1.5, 10);

80 linY = linspace (-0.2, 1, 10);



83 xx , yy , 0.04, 1);

84

85 subplot (2,3,5);


87 markerSizes)

88 hold off

89



92 gamma = curve 1;

93 linX = linspace (-2.5, 0, 10);




97 xx , yy , 0.04, 1);

98

99 subplot (2,3,6);


101 markerSizes)

102 hold off

Die Funktion plotRequiredDim gibt aus, wieviele Freiheitsgrade benotigt werden,um den Fehler der Funktion singLayPot im Vergleich zu einem Referenzwert kleinerals eine Fehlerschranke werden zu lassen. Die Funktion plotRequiredDim berechnetdies fur verschiedene maximale Basispolynomgrade.

Listing B.1.11: MatlabMatlabMatlab-Funktion plotRequiredDim.m

1 function plotRequiredDim(gamma , x, p, n, nRef , tol)

2 % PLOTFREQUIREDDIM Computes the number of degrees of

3 % freedom that are required by the function

4 % SINGLAYPOT to reach a precision defined by tol

5 % Compute the single layer potential of a curve gamma

6 % at two -dimensional points x by use of the function

7 % SINGLAYPOT with various degrees of freedom. The

145

8 % function SINGLAYPOT is also used to compute a

9 % reference solution , using a much higher degree of

10 % freedoms. The results for various degrees of freedom

11 % are compared to this reference solution by the

12 % function cmpSlpToRef. The degrees of freedom will be

13 % increased until the difference to the reference

14 % solution is lower than tol.

15 % This procedure is repeated for different values p

16 % that defines the maximal polynomial degree for which

17 % the single layer potential is computed. Afterwards ,

18 % the required degree of freedom is plottet as a

19 % function of p.

20 %

21 % Usage: plotRequiredDim(gamma , x, p, n, nRef , tol)

22 %

23 % Inputs:







30 % these points.

31 % p - an array of increasing integers that

32 % define the degrees of

33 % P_j; if k is an integer contained in the

34 % array p, the single layer potential will

35 % be computed for the Legendre Polynmoials



38 % are contained in the array p.





43 % of n in order to compare the output to

44 % the reference solution that is computed

45 % with nRef degrees of freedom. For each

46 % integer k contained in p, the function

47 % will find the lowest number N in n, such

48 % that the difference of the single layer

49 % potential (computed with N degrees of

50 % freedom) and the reference solution is


51 % lower than tol

52 % nRef - an integer defining the degrees of freedom

53 % that are used by the function singLayPot

54 % to computed the reference solution

55 % tol - a double representing an error tolerance;

56 % this tolerances defines the required

57 % precision that must be reached by the

58 % wanted degrees of freedom

59 %

60 % Outputs:

61 % no outputs

62 %

63 % Examples:



66 % x = [1,3; 1,1; 1,0];

67 % p = 5:5:25;

68 % n = 10:2:100;

69 % nRef = 300;

70 % tol = 10^-9;

71 % plotRequiredDim(gamma , x, p, n, nRef , tol)

72

73


75 % solutions with


77 maxN = max(n);


79

80 % now , for each p the lowest n is computed such that the


82








90 err = cmpSlpToRef(gamma , x, ...

91 p(k), n(l), slpRef);

92 if(err <= tol)


147

94 end

95 end

96 end

97 end

98


100 hold off



103 xlabel(’Laenge der Fourierentwicklung ’)

Das Skript RequiredDim fuhrt die Funktion plotRequiredDim fur mehrere Bei-spielsituationen aus.

Listing B.1.12: MatlabMatlabMatlab-Skript RequiredDim.m

1 clear all

2

3 % choose the polynomial degrees up to which the single

4 % layer potential will be computed

5 p = (0:5:100) ’;

6

7 % for each p the single layer potential will be computed



10 % tolerance value; the increasing degrees of freedem are


12 n = 1:1:200;

13


15 % solutions with

16 nRef = 500;

17

18 % choose an error tolerance value

19 tol = 10^ -12;

20



23 gamma = curve 1;

24 linX = linspace (-1.5, 1.5, 4);

25 linY = linX;




28 0.3, 0);

29

30 subplot (2,3,1);

31 plotRequiredDim(gamma , x, p, n, nRef , tol)

32 hold off

33




37 linY = linspace (-0.2, 1, 4);



40 xx , yy , 0.3, 0);

41

42 subplot (2,3,2);


44 hold off

45



48 gamma = curve 1;

49 linX = linspace (-2.5, 0, 4);




53 xx , yy , 0.3, 0);

54

55 subplot (2,3,3);


57 hold off

58



61 gamma = curve 1;

62 linX = linspace (-1.5, 1.5, 10);

63 linY = linX;



66 0.04, 1);

67

68 subplot (2,3,4);

149


70 hold off

71



74 linX = linspace (0.001 , 1.5, 10);

75 linY = linspace (-0.2, 1, 10);



78 xx, yy, 0.04, 1);

79

80 subplot (2,3,5);


82 hold off

83



86 gamma = curve 1;

87 linX = linspace (-2.5, 0, 10);




91 xx , yy, 0.04, 1);

92

93 subplot (2,3,6);


95 hold off

Die Funktion slpOnDiskExact berechnet das Einfachschichtpotential der konstan-ten 1-Funktion auf dem Einheitskreis analytisch.

Listing B.1.13: MatlabMatlabMatlab-Funktion slpOnDiskExact.m

1 function zz = slpOnDiskExact(xx, yy)

2 % SLPONDISKEXACT Computes the exact single layer

3 % potential of a constant function on

4 % the unit disk

5 % Evaluate the analytical result for the single layer

6 % potential of the constant 1-Function on the unit disk

7 % which is 0 inside the disk an a log -Function outside

8 % the disk. The values are evaluated on a meshgrid


9 %

10 % Usage: zz = slpOnDiskExact(xx, yy)

11 %

12 % Inputs:


14 % meshgrid


16 % meshgrid

17 %

18 % Outputs:



21 %

22 % Example:

23 % sx = linspace(-2, 2, 101);

24 % sy = linspace(-2, 2, 101);

25 % [xx , yy] = meshgrid(sx, sy);

26 % zz = slpOnDiskExact(xx , yy);

27 % surf(xx , yy , zz);

28 %

29

30 N1 = size(xx, 1);

31 N2 = size(xx, 2);


33

34 for k=1:N1

35 for l=1:N2

36 sqNrm = xx(k,l)^2 + yy(k,l)^2;

37 if(sqNrm > 1)

38 zz(k,l) = log( sqNrm ) / (4*pi);

39 else

40 zz(k,l) = 0;

41 end

42 end

43 end

Die Funktion slpOnDisk berechnet das Einfachschichtpotential der konstanten 1-Funktion auf dem Einheitskreis numerisch mit Hilfe der Funktion singLayPot.

Listing B.1.14: MatlabMatlabMatlab-Funktion slpOnDisk.m

151

1 function zz = slpOnDisk(xx, yy, n)

2 % SLPONDISK Computes the single layer potential of a

3 % constant function on the unit disk

4 % numerically



7 % SINGLAYPOT

8 %

9 % Usage: zz = slpOnDisk(xx, yy, n)

10 %

11 % Inputs:


13 % meshgrid


15 % meshgrid





20 % potential.

21 %

22 % Outputs:



25 %

26 % Example:

27 % sx = linspace(-2, 2, 101);

28 % sy = linspace(-2, 2, 101);


30 % zz = slpOnDisk(xx, yy, 15);

31 % surf(xx, yy, zz);

32 %

33

34 N = size(xx, 2);


36

37 disk = createEllipse (1,1,1);

38

39 for k=1:N

40 zz(:, k) = singLayPot(disk1, ...

41 [xx(:,k), yy(:, k)], 0, n);

42 zz(:, k) = zz(:,k) + singLayPot(disk2, ...

43 [xx(:,k), yy(:, k)], 0, n);


44 end

45

46 zz = sqrt (2) * zz / (2*pi);

Das Skript PlotSlpOnDisk plottet das Einfachschichtpotential der konstanten 1-Funktion auf dem Einheitskreis.

Listing B.1.15: MatlabMatlabMatlab-Skript PlotSlpOnDisk.m

1 clear all

2

3 % initialize a meshgrid

4 sx = linspace(-2, 2, 50);

5 sy = linspace(-2, 2, 50);

6 [xx , yy] = meshgrid(sx, sy);

7


9 % analytically

10 zz = slpOnDiskExact(xx , yy);

11

12 % plot the single layer potential

13 surf(xx , yy , zz);

Die Funktion plotErrorOnDisk plotter den Fehler der numerischen Berechnung desEinfachschichtpotentials der konstanten 1-Funktion auf dem Einheitskreis.

Listing B.1.16: MatlabMatlabMatlab-Funktion plotErrorOnDisk.m

1 function plotErrorOnDisk(xx, yy, n)

2 % PLOTERRORONDISK Computes the single layer potential of

3 % a constant function on the unit disk

4 % numerically by use of the SINGLAYPOT and

5 % plots the error



8 % SINGLAYPOT. The exact solution is computed by the

9 % function SLPONDISKEXACT. Afterwards , the error is

10 % plottet in a 3D surface plot

11 %

153

12 % Usage: plotErrorOnDisk(xx, yy, n)

13 %

14 % Inputs:


16 % meshgrid


18 % meshgrid





23 % potential.

24 %

25 % Outputs:

26 % no outputs

27 %

28 % Example:

29 % sx = linspace(-2, 2, 101);

30 % sy = linspace(-2, 2, 101);


32 % plotErrorOnDisk(xx, yy, 15)

33

34


36 % analytically

37 zzA = slpOnDisk(xx , yy , n);

38


40 % numerically

41 zzB = slpOnDiskExact(xx , yy);

42

43 % plot the error

44 surf(xx, yy, abs(zzA - zzB));

45

46 % compute and display the maximum error on the grid

47 maxErr = max(max(abs(zzA -zzB)));

48 display(maxErr)

Das Skript ErrorOnDisk fuhrt die Funktion plotErrorOnDisk fur verschiedeneAnzahlen von Freiheitsgraden aus.

Listing B.1.17: MatlabMatlabMatlab-Skript ErrorOnDisk.m


1 clear all

2


4 sx = linspace(-2, 2, 50);

5 sy = linspace(-2, 2, 50);

6 [xx , yy] = meshgrid(sx, sy);

7

8 % plot error for n=5

9 subplot (2,2,1)

10 n = 5;

11 plotErrorOnDisk(xx, yy, n);

12 title(’5 degrees of freedom ’);

13


15 subplot (2,2,2)

16 n = 10;



19


21 subplot (2,2,3)

22 n = 20;



25


27 subplot (2,2,4)

28 n = 40;



Das Skript ErrorOnDiskRefined fuhrt die Funktion plotErrorOnDisk auf einemsehr feinen Gitter aus.

Listing B.1.18: MatlabMatlabMatlab-Skript ErrorOnDiskRefined.m

1 clear all

2


4 sx = linspace (-0.0005, 0.0005 , 101);

5 sy = linspace (0.9995 , 1.0005 , 101);

155


7


9 subplot (1,1,1)

10 n = 40;



Das Skript PolygonV sSmooth vergleicht das numerisch berechnete Einfachschicht-potential einer rational interpolierten Ellipse mit dem numerisch berechneten Ein-fachschichtpotential eines Polygonzugs, der die Ellipse approximiert.

Listing B.1.19: MatlabMatlabMatlab-Skript PolygonVsSmooth.m

1 clear all

2

3 % create some curve

4 ellipse = createEllipse (1, 2, 1);

5 gamma = ellipse 1;

6

7 % choose size of the grid to create a polygon that

8 % approximates gamma

9 N = [2 ,4 ,8 ,16 ,32 ,64 ,128 ,256 ,512];

10 % choose n to specify the precision of the functional

11 % calculus approximation

12 n = 50;

13

14 % create a grid of points to evaluate the single layer

15 % potential of P_0 on these points

16 sx = linspace (-0.3, 1.3, 20);

17 sy = linspace (-0.3, 1.3, 20);


19 zzGamma = zeros(size(xx));

20 n2 = size(xx , 2);

21

22 % create a vector to store zu maximum difference on the

23 % grid for each N

24 diff = zeros(length(N), 1);

25

26 for k=1: length(N)

27 % approximate gamma by a polygon


28 polygon = sepCurves ( gamma, N(k));

29

30 % compute single layer potential on the polygon and on

31 % gamma

32 zzPolygon = zeros(size(xx));

33 for j=1:n2

34 zzGamma(:, j) = singLayPot(gamma , [xx(:,j), ...

35 yy(:, j)], 0, n);

36 % sum up single layer potenials on the polygon

37 for l=1:N(k)

38 zzPolygon(:, j) = zzPolygon (:, j) + ...

39 singLayPot(polygonl, [xx(:,j), ...

40 yy(:, j)], 0, 1);

41 end

42 end

43

44 % compute the maximum distance of the single layer

45 % potentials of gamma and the polygon

46 diff(k) = max(max(abs(zzGamma - zzPolygon)));

47 end

48

49 % plot errors

50 hold off

51 loglog(N, diff , ’-s’, ’MarkerSize ’, 3);


53 xlabel(’Ecken des Polygons ’)

Das Skript DecreasingErrorGalerkin gibt aus, wie der Fehler der FunktiongalerkinMatrix im Vergleich zu einem Referenzwert sinkt, wenn die Anzahl derFreiheitsgrade erhoht wird.

Listing B.1.20: MatlabMatlabMatlab-Skript DecreasingErroralerkin.m

1 %clear all

2

3 % create a curve


5

6 % choose the polynomial degrees to test the convergence

7 p = [0, 10, 30, 70]’;

8

157



11 % galerkin matrix will be computed and compared to a


13 n = [5 ,10 ,20 ,40 ,80 ,160 ,320];

14


16 % solutions with

17 nRef = 600;

18 nRef = max(nRef , max(p));




22 end

23



26





31 % the function galerkinMatrix

32 if(n(l) >= p(k))

33 % compute the galerkin matrix with n(l)

34 % degrees of freedom


36 p(k), n(l));

37 % compute the operator -norm of the difference

38 % to measure the error

39 err(k, l) = norm(galMatrix - galerkinRefsk);

40 else

41 start(k) = l + 1;

42 end

43 end

44

45 display(n(l));

46 end

47


49 hold off


51 loglog(n(start(k):end), err(k, start(k):end), ...


52 ’-s’, ’MarkerSize ’, 3);

53 text(n(start(k)), err(k, start(k)), ...

54 [’ p = ’, int2str(p(k))]);

55 if(k == 1)



58 end

59 hold on

60 end

Das Skript RequiredDimGalerkin gibt aus, wieviele Freiheitsgrade benotigtwerden, um den Fehler der Funktion galerkinMatrix im Vergleich zu ei-nem Referenzwert kleiner als eine Fehlerschranke werden zu lassen. Das SkriptRequiredDimGalerkin berechnet dies fur verschiedene maximale Basispolynom-grade.

Listing B.1.21: MatlabMatlabMatlab-Skript RequiredDimGalerkin.m

1 %clear all

2

3 % create a curve


5

6

7 % choose the polynomial degrees up to which the galerkin

8 % matrix will be computed

9 p = (0:5:50) ’;

10

11 % for each p the galerkin matrix will be computed



14 % tolerance value; the increasing degrees of freedom are


16 n = 1:15:360;

17


19 % solutions with

20 nRef = 600;




24 display(k);

159

25 end

26

27 maxN = max(n);


29

30 % choose a tolerance value

31 tol = 10^ -6;

32

33 % for each p the lowest n is computed such that the


35









44 p(k), n(l));

45 err = norm(galMatrix - galerkinRefsk);

46 if(err <= tol)


48 end

49 end

50 end

51 display(l);

52 end

53


55 hold off



58 xlabel(’Groesse der Galerkinmatrix ’)


Literaturverzeichnis

[1] M. Bantle, Efficient Implementation of Collocation and Boundary ElementMethods for Integral Equations. Diplomarbeit, Universitat Ulm, Mai 2010.

[2] P. Heiter, Stable Implementation of Three-Term Recurrence Relations. Ba-chelorarbeit, Universitat Ulm, Juni 2010.

[3] R. Kress, Linear Integral Equations, Springer, Berlin, 1999.

[4] G. J. Murphy, C*-Algebras and Operator Theory, Academic Press, San Diego,London 1990.

Documents

Berechnung von Kurvenintegralen im Rahmen der ......Vorbemerkung. Unter dem Titel Berechnung von Kurvenintegralen im Rahmen der zweidimensionalen Randelementmethode legte ich am 28