Analysis mit MuPAD - mspielmann.de

Materialien und Werkzeuge für computerunterstütztes Lernen

Mathematik 1 × andersBand 4

Analysis mit PADMu

Kai GehrsVera Verspohl

Kai Gehrs

Vera Verspohl

Analysis mit MuPAD

Mathematik 1 x anders: Materialien und Werk-zeuge für computerunterstütztes Lernen

SciFace Software

Kai Gehrs, Vera Verspohl Universität Paderborn

MuPAD Schule-Team

Fachbereich Mathematik

[email protected]

Analysis mit MuPAD/ von Kai Gehrs und Vera Verspohl. Mathematik 1 x anders: Materialien und Werkzeuge

für computerunterstütztes Lernen, Band 4. Paderborn: SciFace Software GmbH & Co. KG, 2003.

2. Auflage: März 2004, überarbeitete und erweiterte Auflage für MuPAD Pro 3.0

SciFace Software GmbH & Co. KG Paderborn

www.mupad.de/schule/literatur/

Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Verwertung außerhalb der engen Gren-

zen des Urheberrechtsgesetzes ist ohne Zustimmung der Firma SciFace Software GmbH & Co. KG unzulässig

und strafbar.

© 2003 SciFace Software GmbH & Co. KG, Paderborn

Die Wiedergabe von Gebrauchsnamen, Handelsnamen, Warenbezeichnungen usw. in diesem Werk berechtigt

auch ohne besondere Kennzeichnung nicht zu der Annahme, dass solche Namen im Sinne der Warenzeichen-

und Markenschutz-Gesetzgebung als frei zu betrachten wären und daher von jedermann benutzt werden dür-

fen.

Printed in Germany

Druck und Binden: SciFace Software GmbH & Co. KG, Paderborn

Einbandgestaltung: SciFace Software GmbH & Co. KG, Paderborn

Vorwort

Die Entwicklung von MuPAD begann 1990 als Forschungsprojekt an der

Universität Paderborn. MuPAD wurde schnell zu einem universellen Werk-

zeug zum symbolisch-algebraischen exakten sowie numerischen Rechnen

ausgebaut. Zudem können mathematische Sachverhalte zwei- und drei-

dimensional visualisiert und interaktiv manipuliert werden. Die Entwick-

lung von MuPAD wurde bereits 1993 von der Forschungsgemeinschaft mit

dem Deutsch-Österreichischen Hochschul-Software Preis und 1994 mit

dem European Academic Software Award honoriert.

Im Februar 1997 wurde aus der MuPAD-Forschungsgruppe heraus das

Unternehmen SciFace Software GmbH & Co. KG gegründet, um MuPAD in

einer sehr engen Kooperation weiterzuentwickeln und den zunehmenden

Anforderungen der Benutzer u.a. hinsichtlich vielfältiger Dokumentationen

und modernen Benutzerschnittstellen gerecht zu werden. Die Forschungs-

ergebnisse aus der Universität werden von SciFace Software aufgegriffen,

marktreif weiterentwickelt und in MuPAD integriert. Aufgrund dieser er-

folgreichen Zusammenarbeit wurde das Unternehmen 1998 mit dem För-

derpreis des Technologie Forum Paderborn e.V. für hervorragende Leis-

tungen auf dem Gebiet der Zusammenarbeit zwischen Wirtschaft und Wis-

senschaft ausgezeichnet.

MuPAD wird neben der Forschung und Lehre an Universitäten verstärkt

im Mathematikunterricht der Sekundarstufe II eingesetzt. MuPAD trägt

dabei ergänzend und unterstützend zur Lehre von Mathematik bei.

Schreiben Sie uns, wenn Sie Fragen oder Anregungen zum Thema „Mu-

PAD in der Lehre“ haben. Nehmen Sie Teil an der Entwicklung einer

modernen Mathematiksoftware und senden Sie uns Ihre Vorschläge, Kriti-

ken und Fragen an [email protected].

Paderborn im Mai 2003

Dr. Andreas Sorgatz,

SciFace Software

Über dieses Buch Dieser Band zeigt anhand ausgewählter Beispiele, wie durch den Ein-

satz des Computeralgebra-Systems MuPAD Aufgabenstellungen aus der

Analysis berechnet und visualisiert werden können. Dafür werden grund-

legende Kenntnisse im Umgang mit MuPAD vorausgesetzt. Wir empfehlen

als Nachschlagewerk Band I dieser Reihe „MuPAD – Eine praktische Ein-

führung" von Kai Gehrs und Frank Postel. Dieser vermittelt in Kürze die

notwendigen, hier vorausgesetzten Kenntnisse.

Zu Beginn dieses Buches werden einige einfache Iterationsverfahren

vorgestellt und mit Hilfe des Computeralgebrasystems MuPAD erarbeitet

und visualisiert. Hierzu zählen z.B. das Heron-Verfahren, also ein Verfah-

ren, das in der Schule durchaus bereits in der Sekundarstufe I behandelt

werden kann, und das Newton-Verfahren. Die weiteren Kapitel widmen

sich den Gebieten Differenzialrechnung, Interpolation und Integration.

In Kapitel 4 wird zur Visualisierung von Rotationskörpern mehrfach der

3D-Viewer eingesetzt. Dieser steht ab der Version MuPAD Pro 2.5 zur Ver-

fügung.

Kapitel 5 bietet abschließend eine kontextübergreifende Aufgabe, in

der die wesentlichen inhaltlichen Aspekte der vorhergehenden vier Kapitel

(Lösen von Gleichungen und Gleichungssystemen, Differenziation, Integ-

ration, Volumen und Darstellung von Rotationskörpern etc.) nochmals

aufgegriffen werden und zur Bearbeitung einer einzelnen, größeren Auf-

gabenstellung herangezogen werden.

Am Ende jedes Kapitels befinden sich Aufgaben, die dazu dienen, ent-

weder das Gelernte zu festigen oder aber den Stoff zu vertiefen.

Die Methoden, die zur Bearbeitung und Visualisierung der hier disku-

tierten Aufgaben und Fragestellungen mit MuPAD eingesetzt werden, sind

weitgehend auf ähnliche mathematische Anwendungen übertragbar. Die

hier beschriebene Vorgehensweise kann daher auch als Anregungen gese-

hen werden, wie MuPAD zum Zweck der Demonstration und Präsentation,

zur Berechnung und zur Dokumentation des Rechenweges sowie insbe-

sondere zur Unterstützung des Ansatzes „Forschendes Lernen“ im Unter-

richt eingesetzt werden kann.

An einigen Stellen dieses Buches wird ergänzend auf die „analysis

Bibliothek“ hingewiesen. Dabei handelt es sich um ein optionales MuPAD-

Paket, dass kostenlos vom Web-Portal „MuPAD in Schule und Studium“

unter der Internet-Adresse www.mupad.de/schule+studium heruntergela-

den werden kann. Unter dieser Adresse finden Sie auch eine Vielzahl wei-

terer Zusatz-Pakete für den Einsatz von MuPAD in der Schule. Darunter

Pakete zur „ebenen Geometrie“ (Konstruktion von Kreisen, Dreiecken, ge-

ometrische Beweise etc.).

Zur Nutzung des Paketes muss es zunächst in MuPAD eingeladen wer-

den. Details und nähere Informationen zum Einbinden und Einlesen von

Zusatz-Paketen in MuPAD finden sich ebenfalls unter der oben genannten

Adresse im Web.

Bei Fragen und Anregungen zu MuPAD und den angebotenen Materia-

lien wenden Sie sich bitte per Email an das MuPAD Schule-Team unter

[email protected].

Kai Gehrs und Vera Verspohl

Paderborn, Juni 2003

Inhaltsverzeichnis

Vorwort .........................................................................................3

1. Iterationsverfahren ..................................................................9

1.1 Das Heron-Verfahren..............................................................9

1.2 Das Newton-Verfahren .........................................................14

1.3 Das Bisektions-Verfahren......................................................28

2. Differenzialrechnung ..............................................................34

2.1 Durchschnitts- und Momentangeschwindigkeit .........................34

2.2 Sekanten- und Tangenten an Funktionsgraphen.......................41

2.3 Funktionsscharen in MuPAD...................................................44

3. Interpolation .........................................................................49

3.1 Steckbriefaufgaben ..............................................................49

3.2 Eine Anwendungsaufgabe zu Steckbriefaufgaben......................51

4. Integration............................................................................56

4.1 Annäherung des Integrals durch Rechtecke .............................56

4.2 Das Trapezverfahren ............................................................66

4.3 Rotationskörper...................................................................71

5. „Mensch-ärgere-Dich-nicht“ – eine spielerische Anwendung .........80

Das Heron-Verfahren 9

1. Iterationsverfahren

1.1 Das Heron-Verfahren

Als Einstieg beginnen wir mit einem Iterationsverfahren, das im Allge-

meinen Unterrichtsstoff der Sekundarstufe I ist. Wir implementieren die-

ses Verfahren in MuPAD und nutzen die grafischen Möglichkeiten, um die

zugrunde liegende geometrische Idee zu veranschaulichen.

Oft wird das Verfahren den Griechen (genauer: dem Griechen Heron,

ca. 10-75 n. Chr.) zugesprochen. Es wird jedoch angenommen, dass es

wesentlich älter ist und bereits den Sumerern bekannt war.

Es dient dazu, Quadratwurzeln zu berechnen. Griechische Mathematik

ist in erster Linie Geometrie, so dass es nicht verwundert, dass dieses

Verfahren geometrischer Natur ist.

Das Produkt zweier Zahlen veranschaulichten die Griechen durch den

Flächeninhalt eines Rechtecks, das im Spezialfall natürlich auch ein Quad-

rat sein kann. Um die Quadratwurzel einer Zahl zu ermitteln, kann man

davon ausgehen, dass von einem Quadrat der Flächeninhalt bekannt ist,

aber die Seitenlänge gesucht wird.

Diese ermitteln wir „schrittweise“ (iterativ): Wir beginnen mit einem

flächengleichen Rechteck, welches wir nach und nach an ein Quadrat an-

nähern. Da wir Wurzeln möglichst genau berechnen möchten, ist es sinn-

voll, die Rechengenauigkeit heraufzusetzen. Hier wollen wir daher mit 25

Gleitkommastellen arbeiten:

• DIGITS:=25:

Als Beispiel wollen wir die Wurzel aus 2 berechnen. Dazu betrachten

wir einmal ein Rechteck und ein Quadrat mit dem Flächeninhalt 2 Flächen-

einheiten (FE). Das Rechteck mit den Seitenlängen 2 Längeneinheiten (LE)

Länge und 1 LE Höhe erfüllt diese Voraussetzung, denn: FELELE 212 =⋅ .

10 Iterationsverfahren

Rechtecke zeichnen wir in MuPAD mit Hilfe von plot::Rectangle. Da-

bei erhält die Funktion standardmäßig drei Argumente: Die ersten beiden

Argumente sind Bereiche, die angeben, wo die Seitenlinien des Rechtecks

im Koordinatensystem liegen sollen und wie lang sie sein sollen. Das dritte

Argument bestimmt die Farbe, in der das Rechteck gezeichnet werden

soll:

• Rechteck:= plot::Rectangle(0..2, 0..1, Color = RGB::Blue): Quadrat:= plot::Rectangle(0..sqrt(2), 0..sqrt(2), Color = RGB::Orange): plot(Rechteck, Quadrat, Scaling = Constrained)

0.0 0.2 0.4 0.6 0.8 1.0 1.2 1.4 1.6 1.8 2.00.0

0.2

0.4

0.6

0.8

1.0

1.2

1.4

x

y

Wenn wir das Rechteck in das Quadrat überführen möchten, müssen

wir die Länge verringern und die Breite vergrößern. Eine gute Annäherung

bietet der Mittelwert der Länge und der Breite. Wir bezeichnen die Breite

des ersten Rechtecks mit 0x und die zugehörige Länge mit 0y , d.h. 10=x

und 20 =y . Für die neue Länge 1x gilt: 2

001

yxx += , also:

• x[0]:= 1: y[0]:= 2: x[1]:= (x[0] + y[0]) / 2

32


Da das Produkt aus 1x und 1y wieder den Flächeninhalt ergeben soll,

lässt sich 1y leicht ermitteln:

• y[1]:= 2 / x[1]

43

Zur Probe:

• x[1] * y[1]

2

D.h. der Flächeninhalt hat sich nicht verändert. Wir definieren nun das

neue Rechteck zu den Werten 1x und 1y und zeichnen es mit dem oben

definierten Quadrat in ein gemeinsames Koordinatensystem:

• Rechteck1:= plot::Rectangle(0..x[1], 0..y[1], Color = RGB::Blue): plot(Rechteck1, Quadrat, Scaling = Constrained)

0.0 0.2 0.4 0.6 0.8 1.0 1.2 1.40.0

0.2

0.4

0.6

0.8

1.0

1.2

1.4

x

y

Diese Näherung ist bedeutend besser. Setzen wir das Verfahren fort:

Um 2x zu bestimmen benötigen wir den Mittelwert aus 1x und 1y . 2y er-

mitteln wir wie zuvor:


• x[2]:= float((x[1] + y[1])/2)

1.416666666666666666666667

• y[2]:= 2/x[2]

1.411764705882352941176471

Betrachten wir also unsere neue Näherung.

• Rechteck2:= plot::Rectangle(0..x[2], 0..y[2], Color = RGB::Blue): plot(Rechteck2, Quadrat, Scaling = Constrained)

0.0 0.2 0.4 0.6 0.8 1.0 1.2 1.40.0

0.2

0.4

0.6

0.8

1.0

1.2

1.4

x

y

Zwischen dem Rechteck und dem Quadrat lässt sich optisch kein Un-

terschied mehr erkennen. Das liegt daran, dass die Werte 2x und 2y sehr

ähnlich sind. Wir sehen, dass ihre Differenz sehr klein wird:

• x[2] - y[2]

0.004901960784313725490196078

Es gilt: 22 2 xy << . Wir haben also bereits in 2 Iterationsschritten die

Quadratwurzel auf 2 Stellen nach dem Komma genau berechnet! Mit ei-

nem Doppelklick auf die Grafik aktivieren wir das MuPAD-Grafik-Tool


VCam und können so in unsere Grafik hineinzoomen. Man benötigt viele

Schritte, um zwischen den Rechteckseiten und den Seiten des Quadrats

Unterschiede erkennen zu können. Da man „mit bloßem Auge“ zwischen

Quadrat und Rechteck keinen Unterschied mehr sehen kann, bietet es sich

an, weitere Schritte nur noch zu berechnen und nicht mehr mit MuPAD

zeichnen zu lassen. Möchte man jedoch mehrere Iterationsschritte auf

einmal berechnen, besteht die Möglichkeit, dies mit Hilfe einer Prozedur zu

tun, bei der die Zahl n, deren Wurzel man berechnen möchte, der Start-

wert x0 sowie die Anzahl der Iterationsschritte Schritte als Parameter

angegeben werden.

• Heron:= proc(n, x0, Schritte) local a, x, Tabelle; begin DIGITS:= 25: x:= x0: Tabelle:= array(0..Schritte, 1..2): for a from 0 to Schritte do y:= float(n/x): x:= float(1/2 * (x + y)): Tabelle[a,1]:= x: Tabelle[a,2]:= y: end_for: return(Tabelle) end_proc:

Wir wenden die Prozedur an, um 15 mit dem Startwert 50 =x und 5

Iterationen näherungsweise zu berechnen:

• Heron(15,5,5) 4.0 3.0

3.875 3.753.872983870967741935483871 3.8709677419354838709677423.87298334620745243572736 3.872982821447162935970849

3.872983346207416885179265 3.8729833462073813346311713.872983346207416885179265 3.872983346207416885179265

Die Ausgabe lesen wir wie folgt: Die erste Spalte gibt die berechneten

x-Werte (Breiten der Rechtecke) und die zweite Spalte die berechneten y-

Werte (Längen der Rechtecke) an. Wir sehen anhand der letzten Zeile: 5x


und 5y stimmen überein, die Genauigkeit liegt also bei mindestens 25

Nachkommastellen.

Übungen

Berechnen Sie schrittweise eine Näherung für 26 und 18 . Wählen

Sie selbst geeignete Startwerte, sowie eine geeignete Genauigkeit.

Zeichnen Sie außerdem die Rechtecke und Quadrate für die Fälle, in

denen noch mit „bloßem Auge“ Unterschiede zwischen Quadrat und

Rechteck zu erkennen sind.

Erweitern Sie die Prozedur Heron, so dass zusätzlich zur Berechnung

der x[i], y[i] die zugehörigen Rechtecke gezeichnet werden.

1.2 Das Newton-Verfahren

Nicht nur in der Schule, sondern auch in technischen Anwendungen, ist

es häufig notwendig, die Nullstellen einer stetigen Funktion näherungswei-

se zu bestimmen. Hierbei handelt es sich um ein sehr altes Problem, mit

welchem sich bereits die Babylonier um 3000 v. Chr. beschäftigten.

Das hier vorgestellte Verfahren ist jedoch deutlich „jünger“, denn es

geht auf Sir Isaac Newton (1643 - 1727) zurück. Voraussetzung ist, dass

die betrachtete Funktion mindestens zweimal stetig differenzierbar ist, das

heißt, wir dürfen die Funktion zweimal differenzieren und ihre zweite Ab-

leitung ist wieder eine stetige (d.h. für uns „glatte“) Funktion.

Man beginnt mit dem Verfahren, indem man in der Umgebung der

Nullstelle eine Tangente an den Graphen anlegt.

Das Newton-Verfahren 15

x

y

x

y

Wir beginnen mit einem Startwert 0x aus der Umgebung der gesuchten

Nullstelle. Zu diesem bestimmen wir den Funktionswert )( 0xf . Dann legen

wir eine Tangente an den Graphen durch den Punkt ))(,( 00 xfx und

bestimmen den Schnittpunkt dieser Tangente mit der x-Achse. Diesen

Wert nennen wir 1x . Wir setzen den neuen Wert 1x in die Funktion ein und

bestimmen den Punkt ))(,( 11 xfx , durch den wir erneut eine Tangente an

den Graphen legen. Wiederum bestimmen wir den Schnittpunkt mit der x-

Achse und fahren so fort. Dieses Verfahren konvergiert im Allgemeinen

sehr schnell gegen eine gesuchte Nullstelle. Mit Hilfe eines geeigneten

Startwertes 0x lassen sich die übrigen Werte Nx leicht errechnen. Es gilt:

)()(

1N

NNN xf

xfxx′

−=+ also z.B. )()(

0

001 xf

xfxx′

−= .

Betrachten wir ein konkretes Beispiel mit MuPAD. Wieder ist es sinnvoll

mit höherer Rechengenauigkeit zu arbeiten:

• DIGITS:= 25: f:= x^3 - x^2 – 5

−x2 + x3 − 5

Die Nullstellen dieser Funktion zu berechnen bereitet uns offenbar mit

den schriftlichen Verfahren (der Analysis) einige Probleme. Auch die Mu-

PAD-Funktion solve ist uns hier zunächst keine Hilfe:


• solve(f = 0, x)

RootOfX13 − X12 − 5, X1

Root of bedeutet Wurzel von. Mit Wurzel bezeichnete man früher die

Nullstelle einer Funktion (in Wirklichkeit können wir MuPAD mit Hilfe des

Befehls solve(f = 0, x, MaxDegree=3) „zwingen“, die Nullstellen zu be-

rechnen – jedoch ist die geschlossene, exakte Form der Nullstellen sehr

kompliziert und wenig hilfreich, weshalb wir hier auf ihre Berechnung ver-

zichten). Stattdessen betrachten wir den Graphen, um dann eine Nullstelle

abschätzen können.

• p:= plot::Function2d(f, x = -1..3, Color = RGB::Red, YViewingBoxRange = -7..13): plot(p)

-1.0 -0.5 0.5 1.0 1.5 2.0 2.5 3.0

-6

-4

-2

2

4

6

8

10

12

x

y

Am Graphen können wir ablesen, dass sich die Nullstelle im Intervall

[2; 3] befindet. Beginnen wir also bewusst etwas grob mit dem Startwert

30 =x . Im Punkt ))3(;3( f legen wir die Tangente an den Graphen von f:

• x0:= 3: f1:= diff(f, x): tangente:= subs (f1, x = x0) * (x - x0) + subs(f, x = x0): t1:= plot::Function2d(tangente, x = -1..3.5, YViewingBoxRange = -7..15, Color = RGB::Blue):


P:= plot::Point2d(x0, subs(f, x = x0) , PointSize = 2): plot(p, t1, P)

-1.0 -0.5 0.5 1.0 1.5 2.0 2.5 3.0 3.5

-70

-60

-50

-40

-30

-20

-10

10

20

x

y

Der Schnittpunkt der Tangente mit der x-Achse ist ein besserer Nähe-

rungswert für die Nullstelle als der ursprünglich gewählte Startwert. Ermit-

teln wir also einen weiteren Wert:

• x1:= float(x0 -(subs(f, x = x0))/(subs(f1, x = x0)))

2.380952380952380952380952

Überprüfen wir kurz, ob )( 1xf wirklich näher an der Nullstelle liegt als

wir annehmen:

• subs(f, x = x0); subs(f, x = x1)

13

2.828528236691501997624447

In der Tat: Der Schnittpunkt der Tangente mit der x-Achse liegt näher

an der Nullstelle unserer Funktion als der ursprünglich gewählte Startwert

für unser Verfahren.

• tangente2:= subs(f1, x = x1) * (x - x1) + subs(f, x = x1): t2:= plot::Function2d(tangente2, x = -1..3, YViewingBoxRange = -7..13, Color = RGB::Blue):


P2:= plot::Point2d(x1, subs(f, x = x1), PointSize = 2): plot(p, t2, P2)

-1.0 -0.5 0.5 1.0 1.5 2.0 2.5 3.0

-30

-20

-10

10

x

y

Man sieht auch grafisch ganz deutlich, dass der Schnittpunkt der Tan-

gente mit der x-Achse eine bedeutend bessere Näherung für die gesuchte

Nullstelle ist. Fahren wir also fort: Als nächstes bestimmen wir 2x mittels:

• x2:= x1 -(subs(f, x = x1))/(subs(f1, x = x1)):

dann legen wir erneut die Tangente an:

• tangente3:= subs(f1, x = x2) * (x - x2) + subs(f, x = x2): t3:= plot::Function2d(tangente3, x = -1..3, YViewingBoxRange = -7..13, Color = RGB::Blue): P3:= plot::Point2d(x2, subs(f, x = x2), PointSize = 2): plot(p, t3, P3)

-1.0 -0.5 0.5 1.0 1.5 2.0 2.5 3.0

-30

-20

-10

10

x

y


Es sieht fast so aus, als hätten wir unser Ziel erreicht. Die weiteren

Näherungswerte berechnen wir nur noch und zeichnen die entsprechenden

Graphen nicht mehr zusätzlich:

• x3:= x2 -(subs(f, x = x2))/(subs(f1, x = x2))

2.116982925821104587195101


2.116343536270696347546315


2.116343298624244481398617


2.116343298624211659838366

Betrachten wir einmal den Funktionswert zu 6x :

• subs(f, x = x6)

5.856503360360791643376673 ⋅ 10− 27

Dieser Wert ist sehr klein und ist also sehr nah an der gesuchten Null-

stelle. Manchmal möchte man aber nicht die Näherungswerte 1x bis 5x

bestimmen, um 6x zu ermitteln. In diesem Fall bietet sich in MuPAD der

@@-Operator an. Das folgende Beispiel zeigt seine Verwendung:

• f:= x^5-x^4+x^3-x^2-4

x3 − x2 − x4 + x5 − 4

Für das Newton-Verfahren benötigen wir die Ableitung von f. Diese de-

finieren wir als f1. Außerdem geben wir nun bereits den Schritt der New-

toniteration It vor:


• f1:= diff(f, x); It:= x - f/f1

3 ⋅ x2 − 2 ⋅ x − 4 ⋅ x3 + 5 ⋅ x4

x + x2 − x3 + x4 − x5 + 43 ⋅ x2 − 2 ⋅ x − 4 ⋅ x3 + 5 ⋅ x4

Als Newton-Iteration definieren wir nun die Zuordnung von x nach It.

Dafür verwenden wir den Befehl fp::unapply, damit wir eine Funktion

auf einen Ausdruck anwenden können:

• Newton:= fp::unapply(It, x)

x → x + x2 − x3 + x4 − x5 + 43 ⋅ x2 − 2 ⋅ x − 4 ⋅ x3 + 5 ⋅ x4

Als Startwert wählen wir 20 =x :

• Newton(2)

127

Um Newton(2) wieder auf Newton anzuwenden, haben wir nun die fol-

gende Möglichkeit:

• Newton(%)

186763119406

Diesen Wert lassen wir uns nochmals als Dezimalbruch von MuPAD

ausgeben:

• float(%)

1.564100631459055658844614

Wie erwähnt, ist es mühsam, nun immer wieder erneut einzusetzen.

Newton@@i bezeichnet die i-malige, iterative Anwendung des Verfahrens:

• float((Newton@@2)(2))

1.564100631459055658844614


ist also die zweimalige Hintereinanderausführung von Newton mit dem

Startwert 20 =x und

• float((Newton@@5)(2))

1.521379706949406198396021

die fünfmalige Hintereinanderausführung bei gleichem Startwert.

Alternativ können wir uns mehrere Iterationsschritte hintereinander

ausgeben lassen:

• n:= 6: for i from 1 to n do x[i]:= float((Newton@@i)(2)); print (Unquoted,"x".expr2text(i)."= ".expr2text (x[i])); end_for;

x1= 1.714285714285714285714286

x2= 1.564100631459055658844614

x3= 1.523945289000055724461365

x4= 1.521389535907963758400679

x5= 1.521379706949406198396021

x6= 1.521379706804567569635532

Es besteht aber auch die Möglichkeit mit der folgenden Prozedur die

einzelnen Tangenten nacheinander in verschiedene Schaubilder zu zeich-

nen:

• delete x: newt:= proc(xStart, f, xBereich, yBereich, n) local p1, p2, p3, p4, pSzene, i, f1, tang, phi, fx, w; begin w:= xStart; for i from 1 to n do f1:= diff(f, x); phi:= fp::unapply(x - f/f1, x): fx:= subs(f, x = w): tang:= (subs(f1, x = w))*(x - w) + fx: p1:= plot::Function2d(f,x = xBereich,


YViewingBoxRange = yBereich, Color = RGB::Blue): p2:= plot::Point2d([w,fx],Color=RGB::Red, PointSize=2): p3:= plot::Function2d(tang, x = xBereich, YViewingBoxRange = yBereich, Color = RGB::Violet): p4:= plot::Line2d([w, fx],[w, 0],Color = RGB::Green): plot(p1, p2, p3, p4, Header = "Schritt ".expr2text(i)); w:= float((phi@@i)(xStart)): end_for; end:

Wir möchten mit dem Startwert 20 =x für 4)( 2345 −−+−= xxxxxf be-

ginnen und 5 Iterationsschritte durchführen: Unserer Prozedur newt über-

geben wir den Startwert, die Funktion, den Definitions- und den Wertebe-

reich der Funktion sowie die Anzahl an gewünschten Iterationsschritten:

• newt(2, x^5 - x^4 + x^3 - x^2 - 4, -1..2.3, -5..20, 5)

-1.0 -0.8 -0.6 -0.4 -0.2 0.2 0.4 0.6 0.8 1.0 1.2 1.4 1.6 1.8 2.0 2.2

-140

-120

-100

-80

-60

-40

-20

20

40

x

y

Schritt 1

-1.0 -0.8 -0.6 -0.4 -0.2 0.2 0.4 0.6 0.8 1.0 1.2 1.4 1.6 1.8 2.0 2.2

-60

-40

-20

20

40

x

y

Schritt 2


-1.0 -0.8 -0.6 -0.4 -0.2 0.2 0.4 0.6 0.8 1.0 1.2 1.4 1.6 1.8 2.0 2.2

-40

-30

-20

-10

10

20

30

40

x

y

Schritt 3

-1.0 -0.8 -0.6 -0.4 -0.2 0.2 0.4 0.6 0.8 1.0 1.2 1.4 1.6 1.8 2.0 2.2

-40

-30

-20

-10

10

20

30

40

x

y

Schritt 4

-1.0 -0.8 -0.6 -0.4 -0.2 0.2 0.4 0.6 0.8 1.0 1.2 1.4 1.6 1.8 2.0 2.2

-40

-30

-20

-10

10

20

30

40

x

y

Schritt 5

1.521379706949406198396021

Hier sieht man sehr schön, wie die Nullstellen der einzelnen Tangenten

gegen die Nullstelle unserer Funktion konvergieren.

Betrachten wir ein weiteres Beispiel: 5)( 23 −−= xxxf . Wir setzen jetzt

00 =x und wenden wiederum die Prozedur newt an:


• newt(0, x^3 - x^2 -5, -1..3, -6..10, 2)

-1.0 -0.5 0.5 1.0 1.5 2.0 2.5 3.0

-6

-4

-2

2

4

6

8

10

12

x

y

Schritt 1

Error: Division by zero [_power];

during evaluation of 'phi'

Wir erhalten eine Fehlermeldung. Was geschieht bei einer minimalen

Verschiebung des Startwertes? Dazu wählen wir einen neuen Startwert,

der dicht bei Null liegt, z.B. 001,00 −=x :

• newt(-0.001, x^3 - x^2 -5, -1..5, -6..80, 22)

-1.0 -0.8 -0.6 -0.4 -0.2 0.2 0.4 0.6 0.8 1.0 1.2 1.4 1.6 1.8 2.0 2.2

-140

-120

-100

-80

-60

-40

-20

20

40

x

y

Schritt 1


-1.0 -0.8 -0.6 -0.4 -0.2 0.2 0.4 0.6 0.8 1.0 1.2 1.4 1.6 1.8 2.0 2.2

-60

-40

-20

20

40

x

y

Schritt 2

-1 1 2 3 4 5

-20

20

40

60

80

x

y

Schritt 22

2.116343808969266706834496

Wir haben in der obigen Sequenz der drei Grafiken aus Platzgründen

nur den ersten, den zweiten und schließlich den zweiundzwanzigsten Ite-

rationsschritt dargestellt.

Warum also funktioniert das Verfahren mit dem Startwert 00 =x gar

nicht und warum werden beim Startwert 001,00 −=x so viele Schritte benö-

tigt, um in die Nähe einer Nullstelle zu gelangen? Auffallend ist außerdem,

dass -0,001 wesentlich näher an unserer gesuchten Nullstelle liegt als ca.

2500, der Wert, der im 2.Schritt gefunden wird. Um diese Fragen zu be-

antworten, betrachten wir den Graphen der Funktion.


Zur Erinnerung: Wir legen bei diesem Verfahren eine Tangente durch

den Startwert an den Graphen und suchen den Schnittpunkt von Tangente

und x-Achse, also die Nullstelle der Tangente. Die Tangente durch den

Punkt ))0(;0( f ist jedoch bei unserer Funktion waagerecht, also parallel zur

x-Achse. Ihre Steigung beträgt Null. Die Parallele wird die x-Achse nie

schneiden, so dass das Verfahren scheitern muss. Bei der Berechnung

müssen wir durch Null dividieren, was uns MuPAD mit seiner Fehlermel-

dung mitgeteilt hat. Verschieben wir den Punkt minimal, so gelangen wir

an einen Punkt, in dem auch die Steigung von Null verschieden ist. Die

Tangente ist zwar nicht mehr parallel, aber annähernd. Dadurch entfernen

wir uns zunächst so weit von unserer Nullstelle.

Natürlich hätten wir die Nullstelle sofort finden können, wenn wir statt

der MuPAD-Prozedur solve die Prozedur numeric::solve verwendet hät-

ten. Dann hätten wir allerdings gar nichts gelernt und das wäre doch

schade. numeric::solve findet auf numerischem Weg alle Nullstellen, al-

so auch die komplexen. Um unseren Wertebereich auf die reellen Zahlen

einzuschränken, müssen wir mit Hilfe der Prozedur intersect die Lösung

mit der Menge der reellen Zahlen schneiden. Betrachten wir hierfür ein

Beispiel:

• f:= x^3 - x^2 -5;

x3 − x2 − 5

• numeric::solve(f=0, x) intersect R_;

{2.116343298624211659838366}

Weitere Möglichkeiten bietet die analysis-Bibliothek. Sie stellt die Pro-

zeduren nsNewton zur numerischen Berechnung von Nullstellen, und, zur

graphischen Veranschaulichung des Newton-Verfahrens, graphNewton zur

Verfügung. Das Paket muss zuerst geladen werden. Beachten Sie dazu

bitte auch die Hinweise im Vorwort.


• package("analysis"): analysis::init(): export(analysis): delete DIGITS: nsNewton(x^3 - x^2 -5, 2.5, 10^-10);

[2.5, 2.181818182, 2.118712121, 2.116346554, 2.116343299]

Hier wurde die Nullstelle der Funktion 5)( 23 −−= xxxf mit dem Start-

wert 5,20 =x mit einer Genauigkeit von 1010− bestimmt.

• graphIt:= graphNewton(x^3 - x^2 -5, 2.5, -1..4, 0.001): plot(graphIt)

-1 1 2 3 4

-40

-30

-20

-10

10

20

30

40

x

y

Numerisch: 2.116346554

Übungen

Wenden Sie das Newton-Verfahren auf die Funktionen )cos(x (Start-

werte 00 =x und 10 =x ) und 1)ln( −+− xx (Startwert selbst wählen!) an.

Versuchen Sie ein eventuelles Scheitern zu erklären.

Betrachten Sie die Funktion xxsignxf ⋅= )()( und sowie die Iteration

newt(1, f, -3..3, -2..2, 6). Versuchen Sie, das Verhalten mit

Hilfe des Graphen zu erklären. Hinweis: In MuPAD wird diese Funkti-

on als f:= sign(x) * sqrt(abs(x)) definiert.


1.3 Das Bisektions-Verfahren

Zur Bestimmung von Nullstellen gibt es neben dem Newton-Verfahren

noch eine Vielzahl anderer Verfahren. An dieser Stelle werden wir uns al-

lerdings nur noch mit einem weiteren beschäftigen, nämlich mit dem Bi-

sektions- bzw. Intervallhalbierungs-Verfahren. Obwohl diese Methode im

Allgemeinen deutlich langsamer konvergiert als das Newton-Verfahren,

weist sie dennoch einen bedeutenden Vorteil auf: Wir haben gesehen,

dass es Fälle gibt, in denen das Newtonsche Nährungsverfahren scheitert.

Dies kann beim Bisektions-Verfahren nicht geschehen. Das Verfahren ist

recht leicht zu verstehen. Wir wissen, dass sich in einem Intervall ];[ 00 ba

eine Nullstelle befindet, wenn das Vorzeichen zwischen den Funktionswer-

ten )( 0af und )( 0bf wechselt. Daher berechnen wir den Mittelpunkt des

Intervalls und bestimmen dessen Funktionswert. Nun können wir mit Hilfe

des Vorzeichenwechselkriteriums entscheiden, in welchem neuen Intervall

die gesuchte Nullstelle liegen muss: ]2

;[ 000

baa + oder ];

2[ 0

00 bba +. Dann hal-

bieren wir das Intervall erneut, usw. Betrachten wir nochmals die Funktion

5)( 23 −−= xxxf :

• DIGITS:= 25: f:= x^3 - x^2 - 5:

Unsere erste Erkenntnis war, dass die Nullstelle im Intervall [2, 3] lie-

gen muss. Überprüfen wir nochmals, ob dort auch wirklich ein Vorzei-

chenwechsel bei den Funktionswerten zu finden ist:

• subs(f, x = 2); subs(f, x = 3)

− 1

13

Diese Voraussetzung ist also erfüllt. Die Intervallmitte liegt bei 2,5;

daher benötigen wir als nächstes den zugehörigen Funktionswert.

Das Bisektions-Verfahren 29

• subs(f, x = 2.5)

4.375

Da wir eine positives Vorzeichen haben, müssen wir als nächstes das

Intervall [2; 2,5] betrachten. Dessen Mitte liegt bei 2,25:

• subs(f, x = 2.25)

1.328125

Und wieder liegt ein positives Vorzeichen vor. Für die gesuchte Nullstel-

le Nx gilt daher: 25,22 ≤≤ Nx . Bestimmen wir erneut den Mittelpunkt dieses

Intervalls

• M3:=(2 + 2.25)/2

2.125

und den zugehörigen Funktionswert )3(Mf :

• subs(f, x = M3)

0.080078125

[2; 2,125] ist unser neues Intervall.

• M4:=(2+M3)/2

2.0625

• subs(f, x = M4)

− 0.480224609375

Der Funktionswert der „neuen Mitte“ hat ein negatives Vorzeichen. Un-

ser neues Intervall ist also [2,0625 ; 2,125]. Wir setzten das Verfahren

fort:

• M5:= (M4 + M3)/2

2.09375


• subs(f, x = M5)

− 0.205230712890625

Nach 5 Schritten wissen wir also, dass unsere Nullstelle im Intervall

[2,0935; 2,125] liegen muss. Das ist noch nicht sehr genau. Außerdem ist

dieses Vorgehen äußerst ermüdend. Wesentlich einfacher ist es, das Ver-

fahren in MuPAD zu implementieren. Wir schreiben also eine Prozedur, die

mehrere Schritte hintereinander auswertet:

• Bisektion:= proc(f, a0, b0, Schritte) local M, a, b, Wert; begin DIGITS:= 25: a[0]:=a0; b[0]:=b0; if sign(subs(f, x = a[0])) = sign(subs(f, x = b[0])) then print (Unquoted, "ungeeignetes Intervall") else for i from 1 to Schritte do M[i]:= (a[i-1] + b[i-1])/2; if sign(subs(f, x = M[i])) <> sign(subs(f, x = b[i-1])) then a[i]:= M[i]; b[i]:=b[i-1]; else a[i]:=a[i-1]; b[i]:=M[i]; end_if; Wert:= float(abs(a[i] - b[i])): print(Unquoted,"[".expr2text(float(a[i]), float(b[i]))."] \n Abstand=".expr2text(Wert)) end_for; end_if; end:

Die Eingabeparameter sind unsere Funktion, die Intervallgrenzen 0a

und 0b und die Anzahl von Iterationsschritten, die durchgeführt werden

sollen. Da das Verfahren recht langsam konvergiert, betrachten wir also

direkt 20 Schritte:

• Bisektion(x^3 - x^2 -5, 2, 3, 20)

[2.0, 2.5] Abstand=0.5

[2.0, 2.25] Abstand=0.25


[2.0, 2.125] Abstand=0.125

[2.0625, 2.125] Abstand=0.0625

[2.09375, 2.125] Abstand=0.03125

[2.109375, 2.125] Abstand=0.015625

[2.109375, 2.1171875]

Abstand=0.0078125

[2.11328125, 2.1171875] Abstand=0.00390625

[2.115234375, 2.1171875]

Abstand=0.001953125

[2.1162109375, 2.1171875] Abstand=0.0009765625

[2.1162109375, 2.11669921875]

Abstand=0.00048828125

[2.1162109375, 2.116455078125] Abstand=0.000244140625

[2.1163330078125, 2.116455078125]

Abstand=0.0001220703125

Im 15. Iterationsschritt stimmen bei den beiden Intervallgrenzen 3

Nachkommastellen überein. Die Genauigkeit ist also verglichen mit der

Anzahl der Schritte noch nicht sehr hoch. Um zu sehen, wie sich die Inter-

valle beim Bisektions-Verfahren verändern, können wir eine Prozedur

schreiben, die das Verfahren visualisiert:

• IntervalleBisek:= proc(f, a0, b0, Schritte, xBereich) local M, a, b, Intervalle, p, ges, gr; begin DIGITS:= 25: a[0]:= a0; b[0]:= b0; if sign(subs(f, x = a[0]))= sign(subs(f, x = b[0])) then print (Unquoted, "ungeeignetes Intervall") else for i from 1 to Schritte do M[i]:= (a[i-1] + b[i-1])/2; if sign(subs(f, x = M[i])) <> sign(subs(f, x = b[i-1])) then


a[i]:= M[i]; b[i]:= b[i-1]; else a[i]:= a[i-1]; b[i]:= M[i]; end_if; end_for; Intervalle:=[]; for j from 0 to Schritte do Intervalle:= append(Intervalle, plot::Line2d([a[j], Schritte-j], [b[j], Schritte-j], Color = RGB::Red)); end_for; q:= plot::Function2d(f, x = xBereich, Color = RGB::Green): gr:= plot::Group2d(op(Intervalle)): plot(q, gr); end_if end_proc:

Bei dieser Prozedur werden die Funktion f, die Intervallgrenzen a0 und

b0, die Anzahl der Schritte und der Bereich, auf dem die Funktion ge-

zeichnet werden soll (xBereich), vorgegeben. Die Prozedur berechnet

neue Intervallgrenzen und zeichnet sie dann zusammen mit der Funktion

in ein Koordinatensystem. Im folgenden betrachten wir die Funktion

523 −− xx und die Intervalle, in denen die Nullstelle gesucht wird. Beson-

ders gut ist das Halbieren der Intervalle zu erkennen:

• IntervalleBisek(x^3-x^2 - 5, 1, 3, 5, -1..3.5);

-1.0 -0.5 0.5 1.0 1.5 2.0 2.5 3.0 3.5

-6-4-2

2468

1012141618202224

x

y


• IntervalleBisek(x^3-x^2 - 5, -1, 3.5, 5, -1..3.5)

-1.0 -0.5 0.5 1.0 1.5 2.0 2.5 3.0 3.5

-6-4-2

2468

1012141618202224

x

y

• IntervalleBisek(x^3-x^2 - 5, -1, 3.5, 10, -1..3.5)

-1.0 -0.5 0.5 1.0 1.5 2.0 2.5 3.0 3.5

-6-4-2

2468

1012141618202224

x

y

Übungen

Die Nullstelle der Funktion xxsignxf ⋅= )()( konnte mit dem Newton-

Verfahren nicht bestimmt werden (vgl. Übungsaufgabe zum Newton-

Verfahren). Wenden Sie jetzt das Bisektions-Verfahren an und

bestimmen Sie die Nullstelle auf 4 Nachkommastellen genau.

34 Differenzialrechnung

2. Differenzialrechnung

Dieses Kapitel ist Tangentenproblemen und Ableitungen gewidmet.

2.1 Durchschnitts- und Momentangeschwindigkeit

Die sportliche Familie Zabel-Ullrich macht eine vierstündige Sonntags-

radtour und, weil sie so sportlich ist, kommt sie ohne Pausen aus. Die

Funktion tttts ⋅+⋅−⋅−= 55,202,115,0)( 23 gibt annähernd an, wie weit die Fa-

milie bis zu einem bestimmten Zeitpunkt gefahren ist. Bevor wir eine tat-

sächliche mathematische Fragestellung betrachten, lassen wir uns den

Graphen der Funktion zeichnen:

• s:= -0.15 * t^3 - 1.2 * t^2 + 20.55 * t: plotfunc2d(s, t = 0..4, GridVisible, XAxisTitle = "Zeit (t) in h", YAxisTitle = "Strecke(s) in km")

0 1 2 3 40

10

20

30

40

50

Zeit (t) in h

Strecke(s) in km

Zunächst berechnen wir, wie weit (in km) die Familie nach einer halben

Stunde, nach einer Stunde, usw. gefahren ist. Dafür müssen wir in unsere

Funktion s das jeweilige t (in Stunden) einsetzen:

• nach30Min:= subs(s, t = 0.5); nach1h:= subs(s, t = 1); nach90Min:= subs(s, t = 1.5); nach2h:= subs(s, t = 2);

Durchschnitts- und Momentangeschwindigkeit 35

nach150Min:= subs(s, t = 2.5); nach3h:= subs(s, t = 3); nach210Min:= subs(s, t = 3.5); nach4h:= subs(s, t = 4)

9.95625

19.2

27.61875

35.1

41.53125

46.8

50.79375

53.4

Nach einer halben Stunde hat die Familie 9,95625 km zurückgelegt,

nach einer Stunde 19,2km, usw. Die Gesamtstrecke beträgt 53,4km:

• f:= plot::Function2d(s, t = 0..4, Color = RGB::Red): p1:= plot::Point2d(0.5, nach30Min, Color = RGB::Blue): p2:= plot::Point2d(1, nach1h, Color = RGB::Blue): p3:= plot::Point2d(1.5, nach90Min, Color = RGB::Blue): p4:= plot::Point2d(2, nach2h, Color = RGB::Blue): p5:= plot::Point2d(2.5, nach150Min, Color = RGB::Blue): p6:= plot::Point2d(3, nach3h, Color = RGB::Blue): p7:= plot::Point2d(3.5, nach210Min, Color = RGB::Blue): p8:= plot::Point2d(4, nach4h, Color = RGB::Blue): plot(f, p1, p2, p3, p4, p5, p6, p7, p8, GridVisible, XAxisTitle = "t in h", YAxisTitle = "s in km")

0.0 0.5 1.0 1.5 2.0 2.5 3.0 3.5 4.00

10

20

30

40

50

t in h

s in km


Als nächstes möchten wir die Durchschnittsgeschwindigkeiten der Fa-

milie ermitteln. Wir möchten wissen, wie schnell die Zabel-Ullrichs wäh-

rend der 4 Stunden waren, wie schnell während der letzten 2 Stunden,

wie schnell während der letzten 1,5 Stunden usw. Die Durchschnittsge-

schwindigkeit für den gesamten Ausflug zu berechnen ist sehr einfach. Wir

benötigen nur die Formel tsv = , wobei s=53,4 km (nach4h, die Ge-

samtstrecke) und t=4 h.

• vges:= nach4h/4

13.35

Wie aber können wir die Durchschnittsgeschwindigkeit für die letzten 2

Stunden ermitteln?

Die Formel tsv = gilt auch weiterhin! Um den Weg s zu erhalten, müs-

sen wir die Differenz zwischen der nach 4 Stunden und der nach 2 Stun-

den zurückgelegten Strecke bilden. t beträgt 2 Stunden, nämlich 4h – 2h.

• vletzte2:= (nach4h - nach2h)/(4 - 2)

9.15

Während der letzten beiden Stunden ist die Familie also mit einer

durchschnittlichen Geschwindigkeit von 9,15 km/h geradelt. Wir visualisie-

ren unsere Berechnungen mit MuPAD:

• Sek1:= plot::Line2d([4, nach4h], [2, nach2h], Color = RGB::Blue): ger:= plot:: Line2d([4, nach4h], [4, nach2h], Color = RGB::Blue): ger2:= plot:: Line2d([2, nach2h], [4, nach2h], Color = RGB::Blue): plot(f, Sek1, ger, ger2, p4, p8, GridVisible, XAxisTitle = "t in h", YAxisTitle = "s in km")


0.0 0.5 1.0 1.5 2.0 2.5 3.0 3.5 4.00

10

20

30

40

50

t in h

s in km

Wir haben ein Steigungsdreieck eingezeichnet, da sich die Geschwin-

digkeit über 12

12 )()(tt

tstsv−−

= berechnet. Die Höhe des Dreiecks ist der Zähler

und die Grundseite der Nenner des Quotienten. Die Steigung entspricht

unserer Geschwindigkeit. Wir wollen noch einige weitere Steigungsdrei-

ecke darstellen. Um nicht jedes Mal erneut die einzelnen Linien des Drei-

ecks definieren zu müssen, schreiben wir uns eine kleine Prozedur, die

diese Aufgabe im folgenden automatisch für uns erledigt:

• Steigungsdreieck:= proc(x1, x2, y1, y2, Farbe) local a, b, c, p1, p2; begin

a:= plot::Line2d([x2, y2], [x1, y1], Color = Farbe): b:= plot::Line2d([x2, y2], [x2, y1], Color = Farbe): c:= plot::Line2d([x1, y1], [x2, y1], Color = Farbe):

p1:= plot::Point2d(x1, y1, Color = Farbe, PointSize = 2):

p2:= plot::Point2d(x2, y2, Color = Farbe, PointSize = 2):

return(a, b, c, p1, p2); end_proc:

Unser obiges Steigungsdreieck können wir mit Hilfe dieser kleinen Pro-

zedur dann wie folgt erzeugen:


• Dreieck1:= Steigungsdreieck(2, 4, nach2h, nach4h, RGB::Blue):

Zusätzlich speichern wir die folgenden, immer wieder verwendeten

Grafik-Optionen, in einer Variablen:

• Optionen:= GridVisible, XAxisTitle = "t in h", YAxisTitle = "s in km":

Analog zu unseren obigen Berechnungen visualisieren wir die Durch-

schnittsgeschwindigkeit für die letzten 1,5 Stunden:

• vletzte90:= (nach4h - nach150Min)/(4 - 2.5)

7.9125

• Dreieck2:= Steigungsdreieck(2.5, 4, nach150Min, nach4h, RGB::Blue): plot(f, Dreieck1, Dreieck2, Optionen)

0.0 0.5 1.0 1.5 2.0 2.5 3.0 3.5 4.00

10

20

30

40

50

t in h

s in km

Für die letzte Stunde verfahren wir analog:

• vletzte1:= (nach4h - nach3h)/(4 - 3)

6.6


• Dreieck3:= Steigungsdreieck(3, 4, nach3h, nach4h, RGB::Blue): plot(f, Dreieck1, Dreieck2, Dreieck3, Optionen)

0.0 0.5 1.0 1.5 2.0 2.5 3.0 3.5 4.00

10

20

30

40

50

t in h

s in km

In der letzten halben Stunde ergibt sich folgendes:

• vletzte30:= (nach4h - nach210Min)/(4 - 3.5)

5.2125

• Dreieck4:= Steigungsdreieck(3.5, 4, nach210Min, nach4h, RGB::Blue): plot(f, Dreieck1, Dreieck2, Dreieck3, Dreieck4, Optionen)

0.0 0.5 1.0 1.5 2.0 2.5 3.0 3.5 4.00

10

20

30

40

50

t in h

s in km

Wir können auch in die Grafik hineinzoomen und damit relevante Be-

reiche der Grafik genauer in Augenschein nehmen:


2.0 2.2 2.4 2.6 2.8 3.0 3.2 3.4 3.6 3.8 4.0 4.2

30

35

40

45

50

55

t in h

s in km

Die Durchschnittsgeschwindigkeiten zu ermitteln ist also recht einfach.

Wie sieht es jedoch mit der Momentangeschwindigkeit aus? Wie können

wir diese mathematisch fassen?

Zur Erinnerung: Um die Durchschnittsgeschwindigkeiten zu berechnen,

haben wir den Quotienten („Differenzenquotient“) 12

12 )()(tt

tstsv ttDurchschni −−

= aus

der Differenz zweier Wege und zweier Zeiten gebildet. Jetzt haben wir je-

doch nur noch einen Zeitpunkt, d.h. 1t und 2t haben beide den gleichen

Wert und wir müssten im obigen Quotienten durch Null dividieren. Ein

Ausweg ist, dass wir die Momentangeschwindigkeit über Durchschnittsge-

schwindigkeiten annähern, wobei wir unser 2t immer näher an 1t heranrü-

cken. Mathematisch wird dies durch einen Grenzübergang formalisiert:

limh→ 0

s(t + h) − s(t)t + h − t

= limh→ 0

s(t + h) − s(t)h

In unserem Fall bedeutet das:

• limit((subs(s, t = 2.25 + h) - subs(s, t = 2.25)) / h, h = 0)

12.871875

Sekanten- und Tangenten an Funktionsgraphen 41

2 Stunden und 15 Minuten nach ihrer Abfahrt fährt die Familie also mit

einer Geschwindigkeit von 12,871875 km/h. Die Geschwindigkeit zu ei-

nem Zeitpunkt können wir somit mit einem Grenzwert bestimmen, wenn

wir die Weg-Zeit-Funktion kennen.

2.2 Sekanten- und Tangenten an Funktionsgraphen

In diesem Abschnitt stellen wir eine kleine Prozedur vor, mit deren Hil-

fe man sehr schön den Übergang von Sekanten in Tangenten visualisieren

kann. Hier zunächst der Quelltext der Prozedur SekTan (eine Beschreibung

der zu übergebenden Parameterwerte sowie die Diskussion eines kurzen

Beispiels findet sich unten):

• SekTan:= proc(f, xBereich, x0, P1, Schritte) local F, p1, p2, sek, Szene, a, Q, S, Sz, Tan, m, bb, Ge, y1, y2; begin y1:= subs(f, x = x0): y2:= subs(f, x = P1): F:= plot::Function2d(f, x = xBereich, Color = RGB::Red): p1:= plot::Point2d(x0, subs(f,x = x0), Color = RGB::Blue, PointSize = 2): p2:= plot::Point2d(P1, subs(f,x = P1), Color = RGB::Blue, PointSize = 2): sek:= plot::Function2d((y2 - y1)/(P1 - x0)*(x - x0) + y1, x = xBereich, Color = RGB::Black): plot(F, p1, p2, sek, GridVisible): a:= (P1 - x0)/Schritte: for i from 1 to Schritte-1 do Q:= plot::Point2d(P1 - i*a, subs(f, x = P1-i*a), Color = RGB::Blue, PointSize = 2): S:= plot::Function2d((subs(f, x = P1 - i*a) - y1) / (P1 - i*a - x0) * (x - x0) + y1, x = xBereich, Color = RGB::Black): plot(F, p1, Q, S, GridVisible): end_for; m:= limit ((subs(f, x = x0 + h) - y1) / h, h = 0): bb:= solve(y1 = m * x0 + b, b): Ge:= m * x + b: Tan:= plot::Function2d(subs(Ge, b = bb[1]), x = xBereich, Color = RGB:: Black): plot(F, Tan, p1, GridVisible): end_proc:


Um die Prozedur zu starten, müssen wir ihr die folgenden Parameter

übergeben:

• eine Funktion f,

• das Intervall auf der x-Achse, in dem die Funktion gezeichnet wer-

den soll (xBereich),

• der Punkt x0, an den die Tangente angelegt werden soll,

• ein Punkt P1, durch den die erste Sekante verläuft sowie

• die Anzahl von Schritten (Schritte), in denen der Übergang von

der Sekante zur Tangente stattfinden soll.

Berechnen wir ein Beispiel:

• SekTan(x^2, -1..3, 2, 0, 4)

-1.0 -0.5 0.5 1.0 1.5 2.0 2.5 3.0

-2

-1

1

2

3

4

5

6

7

8

9

x

y

-1.0 -0.5 0.5 1.0 1.5 2.0 2.5 3.0

-2

2

4

6

8

x

y

Sekanten- und Tangenten an Funktionsgraphen 43

-1.0 -0.5 0.5 1.0 1.5 2.0 2.5 3.0

-4

-2

2

4

6

8

x

y

-1.0 -0.5 0.5 1.0 1.5 2.0 2.5 3.0

-6

-4

-2

2

4

6

8

x

y

-1.0 -0.5 0.5 1.0 1.5 2.0 2.5 3.0

-8

-6

-4

-2

2

4

6

8

x

y

Mit einer nahezu beliebigen Funktion lässt sich also mit Hilfe der Proze-

dur SekTan sehr leicht eine Sequenz von Bildern erzeugen, die den übli-


chen Grenzübergang des Differenzenquotienten „für h gegen Null“ intuitiv

veranschaulicht.

2.3 Funktionsscharen in MuPAD

Zum Abschluss dieses Kapitels wollen wir MuPAD nutzen, um eine

Standardaufgabe aus der Schulmathematik zu bearbeiten: Das Diskutie-

ren einer Funktionsschar. Der Funktionsterm einer solchen wird in der

Form )(xfk angegeben, wobei k als Parameter bezeichnet wird und zu je-

dem zugelassenen Wert von k eine Funktion kf existiert. Ein Beispiel für

drei Funktionen einer Funktionsschar sehen wir hier:

x*exp(-x^2)2*x*exp(-2*x^2)3*x*exp(-3*x^2)

-5 -4 -3 -2 -1 1 2 3 4 5

-0.6

-0.4

-0.2

0.2

0.4

0.6

x

y

Funktionsschar

Es handelt sich um die Funktion 2

)( kxk kxexf −= , für 3,2,1=k . Wir wollen hier

eine Kurvendiskussion für die Funktionsschar xk ekxxf −+= )()( durchführen.

Bevor wir die Funktionsschar jedoch definieren, teilen wir MuPAD explizit

mit, dass x und k nur reelle Werte annehmen dürfen:

• assume (x, Type::Real): assume(k, Type::Real): f_k:= (x + k) * exp(-x)

e− x ⋅ (k + x) Zuerst untersuchen wir das Verhalten der Funktion für ∞→x und

−∞→x .

Funktionsscharen in MuPAD 45

• limit (f_k, x = -infinity); limit(f_k, x = infinity)

− ∞

0 Als nächstes betrachten wir die Schnittpunkte der Funktion mit den

Achsen:

• solve(f_k = 0, x)

{− k} Die Nullstellen der Funktionsschar liegen also bei kx −= .

• subs(f_k, x = 0)

e0 ⋅ k

Dieses Ergebnis können wir mit dem expand-Befehl in die übliche Form

überführen

• expand(%)

k

so dass der Schnittpunkt mit der x-Achse bei (0, k) liegt. Als nächstes

bestimmen wir Extrem- und Wendestellen. Dafür benötigen wir die erste,

zweite und dritte Ableitung:

• f1_k:=diff(f_k, x); f2_k:=diff(f1_k, x); f3_k:=diff(f2_k, x)

e− x − e− x ⋅ (k + x)

e− x ⋅ (k + x) − 2 ⋅ e− x

3 ⋅ e− x − e− x ⋅ (k + x) Gemäß dem notwendigen Kriterium für Hoch- und Tiefpunkte müssen

wir zunächst 0)( =′ xfk lösen:


• S:= solve(f1_k = 0, x)

{1 − k} Das Ergebnis müssen wir in die 2. Ableitung einsetzen, um das hinrei-

chende Kriterium zu überprüfen:

• subs(f2_k, x = S[1])

− ek − 1

Dieser Wert ist stets verschieden von Null, d.h. es liegt ein Extremum

vor. Wir bestimmen die Koordinaten der Extremstelle:

• subs(f_k, x = S[1])

ek −1

Die gesuchte Extremstelle liegt bei ),1( 1−− kek . Potentielle Wendestellen

erhalten wir, indem wir analog mit der zweiten Ableitung verfahren:

• W:= solve(f2_k = 0, x)

{2 − k} Das Ergebnis setzen wir in die 3. Ableitung ein:

• subs(f3_k, x = W[1])

ek −2

Auch dieser Wert ist für alle Werte von k verschieden von Null. Es liegt

eine Wendestelle vor und wir können ihre Koordinaten durch Einsetzen in

die Ausgangsgleichung unserer Funktionsschar berechnen:

• subs(f_k, x = W[1])

2 ⋅ ek − 2

Der Wendepunkt hat also die Koordinaten )2,2( 2−− kek . Zum Abschluss

wollen wir einige Graphen der Funktionsschar darstellen lassen:

Exemplarisch lassen wir 2−f , 1−f , 1f und 2f zeichnen.

Funktionsscharen in MuPAD 47

• kWerte:= [-2, -1, 1, 2]:

• plotfunc2d(subs(f_k, k = kWerte[i]) $ i = 1..4, x = -2..3, YRange = -25..6, GridVisible)

exp(-x)*(x - 2)exp(-x)*(x - 1)exp(-x)*(x + 1)exp(-x)*(x + 2)

-2.0 -1.5 -1.0 -0.5 0.5 1.0 1.5 2.0 2.5 3.0

-25

-20

-15

-10

-5

5

x

y

Übungen

Die sportliche Familie Zabel-Ullrich macht einen Ausflug mit Inline-

Skates. Mit denen ist sie etwas langsamer als mit dem Fahrrad. „Zu-

fällig“ entspricht die Funktion tttts 64,1812,208,0)( 23 +−= für ]3,0[∈t der

Strecke, welche die Familie im Zeitraum zwischen der ersten und drit-

ten Stunde zurücklegt.

• Zeichnen Sie die Funktion im vorgegebenen Bereich.

• Berechnen Sie, wie schnell die Familie nach einer Stunde, nach

zwei und nach drei Stunden gefahren ist.

• Ermitteln Sie dann die Durchschnittsgeschwindigkeit für die

Fahrzeit von drei Stunden sowie die Durchschnittsgeschwindig-

keit zwischen der ersten und zweiten Stunde und visualisieren

Sie ihr Vorgehen.

• Berechnen Sie dann die Momentangeschwindigkeit für den Zeit-

punkt der 65. Minute sowie zu einem Zeitpunkt Ihrer Wahl.


Gegeben sei die Funktion xxf sin)( = . Zeichnen Sie die Funktion im

Intervall ]2,0[ π sowie zwei beliebige Sekanten und die Tangente durch

Punkt ))(,( ππ f . Bestimmen Sie jeweils zuerst die Steigung der Sekan-

te bzw. Tangente.

Sei 0,2)( >− ∈

+= Rk

eekxf kxkxk eine Schar von Funktionen. Definieren Sie

die Funktion. 0>∈ Rk können Sie mit assume(k, Type::Positive)

vorgeben.

• Bestimmen Sie das Verhalten der Funktion für ∞→x bzw.

−∞→x .

• Bestimmen Sie eventuelle Hoch-, Tief- und Wendepunkte, wo-

bei Sie jeweils sowohl das notwendige als auch das hinreichen-

de Kriterium überprüfen und die Funktionswerte der Punkte

bestimmen. Zeichnen Sie die Funktion in einem geeigneten In-

tervall für k=1, 2 ,3 ,4.

Steckbriefaufgaben 49

3. Interpolation

3.1 Steckbriefaufgaben

Meistens untersucht man die Eigenschaften einer gegebenen Funktion.

In vielen Anwendungen ist es jedoch so, dass zu bestimmten Vorgaben

(Eigenschaften der Funktion) eine Funktion gefunden werden soll, die ge-

nau diese erfüllt. Wir werden im Folgenden versuchen, den Funktionsterm

der folgenden Funktion fünften Grades zu ermitteln.

-1.4 -1.2 -1.0 -0.8 -0.6 -0.4 -0.2 0.2 0.4 0.6 0.8 1.0 1.2 1.4

-6

-4

-2

2

4

6

x

y

Die gesuchte Funktion

Wir lesen am Graphen der gegebenen Funktion zunächst die wesentli-

chen Eigenschaften ab:

• Zuerst stellen wir fest, dass der Graph der Funktion f durch den Koordi-natenursprung verläuft.

• Offensichtlich liegt Punktsymmetrie zum Koordinatenursprung vor.

• Außerdem hat die Funktion ein Maximum bei (1; 4) und, schon wegen der Punktsymmetrie, folglich auch ein Minimum bei (-1; -4).

• Der Graph verläuft durch den Punkt (21

; 1) (und dementsprechend

auch durch (-21

; -1)).

Um die oben eingezeichnete Funktion anhand der gegebenen Merkmale

bestimmen zu können, müssen wir zuerst den allgemeinen Funktionsterm

aufstellen. Für eine ganzrationale Funktion fünften Grades ist die allge-

50 Interpolation

meine Funktionsgleichung gegeben durch hgxdxcxbxaxxf +++++= 2345)(

mit 0,,,,,, ≠∈ aRhgdcba . Da aber Punktsymmetrie zum Koordinatenur-

sprung vorliegt, können nur ungerade Exponenten von x vorkommen, so

dass der allgemeine Funktionsterm cxbxaxxf ++= 35)( ist. Diesen definie-

ren wir in MuPAD und zeichnen die Parameter a, b und c explizit als reell

aus:

• assume({a, b, c}, Type::Real): f:= a * x^5 + b * x^3 + c * x

a ⋅ x5 + b ⋅ x3 + c ⋅ x Die erste Ableitung der Funktion ist gegeben durch:

• f1:= diff(f, x)

Nun werden wir die beschriebenen Eigenschaften der Funktion in

Funktionsbedingungen umformulieren. Der Graph verläuft durch den Ko-

ordinatenursprung, d.h. es muss 0)0( =f gelten. Die Punktsymmetrie ha-

ben wir bereits berücksichtigt, indem wir die geraden Exponenten ver-

nachlässigt haben. Ein Hochpunkt an der Stelle x = 1 bedeutet, dass die

Ableitung an dieser Stelle den Wert Null annehmen muss, also 0)1( =′f .

Gleiches gilt für den Tiefpunkt ( 0)1( =−′f ).

Ferner verläuft der Graph der gesuchten Funktion natürlich durch die

Punkte, an denen Extrema vorliegen, weshalb wir die Bedingungen 4)1( =f

und 4)1( −=−f erhalten. Der Funktionswert bei 21

=x ist 1, daher 121

=

f

und analog 121

−=

−f .

Hinter all diesen Funktionsbedingungen stecken lineare Gleichungen,

die zusammen ein Gleichungssystem mit 3 Unbekannten bilden. Die Fleiß-

arbeit, die mit dem Lösen solcher Gleichungssysteme verbunden ist, las-

sen wir MuPAD erledigen:

c + 5 ⋅ a ⋅ x4 + 3 ⋅ b ⋅ x2

Eine Anwendungsaufgabe zu Steckbriefaufgaben 51

• solve({subs(f, x = 0) = 0, subs(f1, x = 1) = 0, subs(f, x = 1) = 4, subs(f, x = 1/2) = 1}, {a, b, c})

a = − 569, b = 94

9, c = − 2

9

Somit erfüllt die Funktion xxxxf92

994

956)( 35 −+−= die geforderten Ei-

genschaften. Zum Abschluss noch eine Zeichnung des Graphen, die den

direkten Vergleich mit der am Anfang dieses Abschnitts vorgegebenen

Funktion erlaubt:

• plotfunc2d(-56/9 *x^5 +94/9*x^3 -2/9*x, x=-1.5..1.5, YRange=-7..7)

-1.4 -1.2 -1.0 -0.8 -0.6 -0.4 -0.2 0.2 0.4 0.6 0.8 1.0 1.2 1.4

-6

-4

-2

2

4

6

x

y

3.2 Eine Anwendungsaufgabe zu Steckbriefaufgaben

Zwischen den Orten Ahausen, Bedorf und Ceheim soll eine Eisenbahn-

strecke gebaut werden. Wir nehmen an, der Ort Ahausen habe die Koordi-

naten (-2,-10), Bedorf (0,0) und Ceheim (1,3). Zwischen Ahausen und

Bedorf sowie zwischen Bedorf und Ceheim soll die Strecke durch eine

ganzrationale Funktion dritten Grades p(x) bzw. q(x) beschrieben werden.

Damit der Zug „sanft“ durch Bedorf rollen kann, gestalten wir einen sanf-

ten Übergang: Dafür müssen die ersten beiden Ableitungen der Polynome

52 Interpolation

p(x) und q(x) bei x = 0 übereinstimmen. Wegen der geografischen Gegeben-

heiten muss der Zug Ahausen in einem speziellen Winkel verlassen und in

Ceheim in einem bestimmten Winkel einfahren. Bedingungen an den „Ein-

fahrts-„ bzw. „Ausfahrtwinkel“ entsprechen speziellen Steigungswerten

der Strecke beim Eintritt bzw. Austritt aus einem Ort (Steigung ist hier im

mathematischen Sinne zu verstehen, d.h. als Wert der Ableitung einer

Funktion, und nicht im geographischen Sinne z.B. als Steigung eines Ber-

ges). Wir wollen uns hier nicht näher damit beschäftigen, wie man speziel-

le Winkelangaben in Angaben über die Steigung einer Funktion umrech-

net. Wir nehmen daher schlicht an, dass p(x) aus Ahausen mit einer Stei-

gung von 12 Einheiten austritt und q(x) in Ceheim mit einer Steigung von 8

Einheiten eintritt.

Mit Hilfe dieser Vorgaben wollen wir die Koeffizienten beider Polynome

p(x) und q(x) bestimmen und dann eine Zeichnung der Bahnstrecke erstel-

len. Wie zuvor formulieren wir die beschriebenen Eigenschaften der Funk-

tion in Funktionsbedingungen um.

Wir haben laut Vorgabe die Polynome p(x) und q(x), deren allgemeine

Funktionsgleichungen dcxbxaxxp +++= 23)( und jhxgxfxxq +++= 23)( lau-

ten, wobei Rjhgfdcba ∈,,,,,,, und 0, ≠fa gilt. Die Ortsangaben liefern:

• 10)2( −=−p und 0)0( =p .

• 3)1( =q und .0)0( =q

Außerdem sollen die ersten beiden Ableitungen der Polynome bei x = 0

übereinstimmen, d.h. )()( xqxp ′=′ und )()( xqxp ′′=′′ . Wegen der vorgegebe-

nen Winkel muss des Weiteren 12)2( =−′p und 8)1( =′q erfüllt sein. Nach-

dem wir die Modellierungsphase absolviert haben, lassen wir MuPAD die

Rechenarbeit erledigen:

• assume({a, b, c, d, f, g, h, j}, Type::Real): p:= a*x^3 + b*x^2 + c*x + d; q:= f*x^3 + g*x^2 + h*x + j

d + a ⋅ x3 + b ⋅ x2 + c ⋅ x

j + f ⋅ x3 + g ⋅ x2 + h ⋅ x


Dann bilden wir die ersten und zweiten Ableitungen der Polynome,

formulieren unsere Bedingungen als Gleichungssystem und lassen es von

MuPAD lösen:

• p1:= diff(p, x); q1:= diff(q, x); p2:= diff(p1, x); q2:= diff(q1, x)

c + 3 ⋅ a ⋅ x2 + 2 ⋅ b ⋅ x

h + 3 ⋅ f ⋅ x2 + 2 ⋅ g ⋅ x

2 ⋅ b + 6 ⋅ a ⋅ x

2 ⋅ g + 6 ⋅ f ⋅ x

• S:= solve( {subs(p, x = -2) = -10, subs(p, x = 0) = 0, subs(q, x = 1) = 3, subs(q, x = 0) = 0, subs(p1, x = 0) = subs(q1, x = 0), subs(p2, x = 0) = subs(q2, x = 0), subs(p1, x = -2) = 13, subs(q1, x = 1) = 8}, {a, b, c, d, f, g, h, j})

a = 1112, b = − 1

3, c = 2

3, d = 0, f = 8

3, g = − 1

3, h = 2

3, j = 0

Durch Einsetzen der berechneten Werte in die allgemeinen Funktions-

gleichungen unserer beiden ganzrationalen Funktionen p(x) bzw. q(x) erhal-

ten wir die tatsächlichen Funktionsgleichungen für unsere Bahnstrecke

zwischen den drei Orten:

• P:= subs(p, op(S)); Q:= subs(q, op(S))

2 ⋅ x3

− x2

3 + 11 ⋅ x3

12

2 ⋅ x3

− x2

3 + 8 ⋅ x3

3

54 Interpolation

Zum Abschluss lassen wir uns die „Bahnlinie“, die durch die beiden

Funktionen p(x) bzw. q(x) gegeben ist, sowie die Bahnhöfe von Ahausen,

Bedorf und Ceheim (als Punkte dargestellt) zeichnen:

• P1:= plot::Function2d(P, x = -2.2..0, Color = RGB::Black): Q1:= plot::Function2d(Q, x = 0..1.2, Color = RGB::Grey): Ahausen:= plot::Point2d([-2, -10], Color = RGB::Blue): Bedorf:= plot::Point2d([0, 0], Color = RGB::Green): Ceheim:= plot::Point2d([1, 3], Color = RGB::Orange): plot(P1, Q1, Ahausen, Bedorf, Ceheim)

-2.2 -2.0 -1.8 -1.6 -1.4 -1.2 -1.0 -0.8 -0.6 -0.4 -0.2 0.2 0.4 0.6 0.8 1.0 1.2

-12

-10

-8

-6

-4

-2

2

4

x

y

Übungen

Finden Sie ein Polynom fünften Grades, das die folgenden Eigenschaf-

ten hat:

• Der Graph der Funktion geht durch den Ursprung.

• Er ist punktsymmetrisch.

• Der Punkt (5|10,3) ist ein Extremum.

• Ein weiteres Extremum befindet sich an der Stelle x=2.

Versuchen Sie zwei geradlinige, parallelverlaufende Schienenstücke

zu verbinden.


x

y

Die zu verbindenden Teilstücke

Hierbei sollten Sie zunächst ein geeignetes Koordinatensystem festle-

gen. Wählen Sie den Grad des Polynoms möglichst gering. Bezeich-

nen Sie den horizontalen Abstand zwischen den Teilstücken als b und

den vertikalen als h. Nutzen Sie die Punktsymmetrie und legen Sie

den Spiegelpunkt in den Ursprung, so dass Sie eine Polynomfunktion

mit ausschließlich ungeraden Exponenten benötigen. Betrachten Sie

ihre Lösung für geeignete Werte b und h mit MuPAD. (Bedingungen:

P1= (-2b

; 2h

) und P2= (2b

; -2h

) als Abschlusspunkte der Teilstücke

gehören zur Funktion, 0)2

( =−′bf und außerdem ein Wendepunkt, also

0)2

( =−′′bf .)

56 Integration

4. Integration

In diesem Kapitel wollen wir mit Hilfe von Integration zunächst Flä-

cheninhalte und im Anschluss daran Volumina von Rotationskörpern be-

rechnen.

4.1 Annäherung des Integrals durch Rechtecke

Wir wollen nun mit Unterstützung von MuPAD die Grundidee der Rie-

mann-Integration (nach Bernhard Riemann (1826-1866)) erarbeiten und

visualisieren. Als einführendes Beispiel betrachten wir die Normalparabel 2)( xxf = :

• f:= x^2:

Wir möchten den Flächeninhalt derjenigen Fläche bestimmen, die von

der Funktion 2)( xxf = und der x-Achse im Intervall [0; 1] eingeschlossen

wird. Dafür betrachten wir zunächst den Graphen:

• plotfunc2d(f, x = 0..1, YRange = 0..1, GridVisible)

0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.00.0

0.1

0.2

0.3

0.4

0.5

0.6

0.7

0.8

0.9

1.0

x

y

Eine, zugegebenermaßen schlechte, Näherung für den gesuchten Flä-

cheninhalt ist die Maßzahl der Fläche des „Einheitsquadrates“.

Annäherung des Integrals durch Rechtecke 57

• plotfunc2d(f, x = 0..1, YRange = 0..1, GridVisible, Axes = Boxed)

0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.00.0

0.1

0.2

0.3

0.4

0.5

0.6

0.7

0.8

0.9

1.0

x

y

Wir haben die Maßzahl für den Flächeninhalt mit Hilfe des Quadrats

sehr grob angenähert.

Eine bessere Näherung erhalten wir, wenn wir das Intervall [0; 1] zer-

legen und die Fläche unter dem Graphen durch Rechtecke annähern: Zu-

nächst zerlegen wir das Intervall [0; 1] in die Teilintervalle [0; 0,5] und

[0,5; 1].

Nun können wir Rechtecke bilden, deren Länge durch den Funktions-

wert der linken oder aber der rechten Intervallgrenze vorgegeben wird.

Die Höhe der Rechtecke soll die Länge der Teilintervalle sein.

Je nachdem, ob wir die linke oder die rechte Intervallgrenze wählen,

entstehen entweder Näherungen von unten oder von oben, so genannte

„Unter“- oder „Obersummen“.

Das Zeichnen solcher Rechtecke ermöglicht MuPAD mit der Prozedur

plotRiemann: Sie erhält als Argumente eine Funktion, ein Intervall und

die Anzahl der geforderten Rechtecke:

• plot(student::plotRiemann(f, x = 0..1, 2, Left), GridVisible)

58 Integration

0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0

0.0

0.1

0.2

0.3

0.4

0.5

0.6

0.7

0.8

0.9

1.0

x

y

Riemann: 0.125real: 0.333

Im Fall von Obersummen ergibt sich die folgende Grafik:

• plot(student::plotRiemann(f, x = 0..1, 2, Right), GridVisible)

0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0

0.0

0.1

0.2

0.3

0.4

0.5

0.6

0.7

0.8

0.9

1.0

x

y Riemann: 0.625real: 0.333

Der Flächeninhalt der zwei Rechtecke ist offensichtlich in beiden Fällen

eine weitaus bessere Näherung als der Flächeninhalt des Einheitsquadrats.

Den Flächeninhalt der Rechtecke müssen wir jedoch noch bestimmen, wo-

gegen wir beim Einheitsquadrat trivialer Weise wussten, dass der Flächen-

inhalt die Maßzahl 1 hat. Zur Berechnung der Flächeninhalte der Recht-

ecke verwenden wir die wohlbekannte Formel HöheGrundseiteA ⋅= .


Wir beginnen mit den Untersummen: Die Höhe (hier: an der x-Achse)

beträgt 0,5 Längeneinheiten (LE), da wir das Intervall [0; 1] in zwei (glei-

che) Teile geteilt haben ([0; 0,5] und [0,5; 1]). Wie erwähnt, ist die

Grundseite durch die Funktionswerte der linken Intervallgrenze vorgege-

ben, also )0(f und )5,0(f :

• Rechtecke_2Links:= 0.5 * subs(f, x = 0) + 0.5 * subs(f, x = 0.5)

0.125

Die Zahl 0,125 als Maßzahl für den Flächeninhalt unter der Parabel ist

schon eine recht gute Näherung (wie wir später sehen werden). Bei den

Obersummen haben die Rechtecke die gleiche Breite, denn die zugrunde

liegende Unterteilung des Intervalls [0; 1] hat sich schließlich nicht geän-

dert. Die Höhen der Rechtecke sind gegeben durch )5,0(f und )1(f .

• Rechtecke_2Rechts:= 0.5 * subs(f, x = 0.5) + 0.5 * subs(f, x = 1)

0.625 Für den tatsächlichen Flächeninhalt unter der Normalparabel erhalten

wir die Abschätzung: chtschteckeFunktionLinkschtecke AAA Re2_Re2_Re << . Nun zerlegen wir

unser Intervall in mehrere Segmente, und zwar zunächst in vier:


0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0

0.0

0.1

0.2

0.3

0.4

0.5

0.6

0.7

0.8

0.9

1.0

x

y


60 Integration


0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0

0.0

0.1

0.2

0.3

0.4

0.5

0.6

0.7

0.8

0.9

1.0

x


Das Intervall [0; 1] wurde in die vier Intervalle [0; 0,25], [0,25; 0,5],

[0,5; 0,75] und [0,75; 1] unterteilt, welche jeweils eine Länge von 0,25

LE haben, die demnach auch die Breite der Rechtecke ist. Wir setzen er-

neut die linken bzw. rechten Intervallgrenzen ein, um den Flächeninhalt

der Rechtecke zu ermitteln:

• Rechtecke_4Links:= 0.25 * subs(f, x = 0) + 0.25 * subs(f, x = 0.25) + 0.25 * subs(f, x = 0.5) + 0.25 * subs(f, x = 0.75)

0.21875

• Rechtecke_4Rechts:= 0.25 * subs(f, x = 0.25) + 0.25 * subs(f, x = 0.5) + 0.25 * subs(f, x = 0.75) + 0.25 * subs(f, x = 1)

0.46875 Um die Genauigkeit unsere Näherungen weiter zu erhöhen, müssen wir

die Anzahl der Intervalle erhöhen. Wir betrachten daher die Annäherung

des Flächeninhalts durch Ober bzw. Untersummen mit Hilfe von 8 Recht-

ecken:



0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0

0.0

0.1

0.2

0.3

0.4

0.5

0.6

0.7

0.8

0.9

1.0

x

y



0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0

0.0

0.1

0.2

0.3

0.4

0.5

0.6

0.7

0.8

0.9

1.0

x


Man sieht bereits mit bloßem Auge, dass die Fläche immer besser an-

genähert wird. Aber jetzt möchten wir eine allgemeine Formel finden: Da-

für schreiben wir die Eingabezeile für 4 Rechtecke ein wenig um. Der Fak-

tor 0,25 entspricht dem Kehrwert der Anzahl der Rechtecke, also 41

. Die

Funktionswerte können wir dann auch durch Vielfache von 41

darstellen:

• Rechtecke_4Links:= 1/4 * subs(f, x = 0/4) + 1/4 * subs(f, x = 1/4) +

62 Integration

1/4 * subs(f, x = 2/4) + 1/4 * subs(f, x = 3/4)

732

• float(%)

0.21875

oder für die Obersumme

• Rechtecke_4Rechts:= 1/4 * subs(f, x = 1/4) + 1/4 * subs(f, x = 2/4) + 1/4 * subs(f, x = 3/4) + 1/4 * subs(f, x = 4/4)

1532

• float(%)

0.46875

Mit float haben wir uns die Dezimalbruchdarstellung der Werte ange-

ben lassen, um das Ergebnis mit dem zuvor erhaltenen vergleichen zu

können. Als nächstes klammern wir den Faktor 41

aus.

• Rechtecke_4Links:= 1/4 * (subs(f, x = 0/4) + subs(f, x = 1/4) + subs(f, x = 2/4) + subs(f, x = 3/4))

732

• Rechtecke_4Rechts:= 1/4 * (subs(f, x = 1/4) + subs(f, x = 2/4) + subs(f, x = 3/4) + subs(f, x = 4/4))

1532

Den Teil in der Klammer können wir natürlich auch mit Hilfe der Funk-

tion sum, der MuPAD-Funktion zur Summation, noch kompakter schreiben:


• Rechtecke_4Links:= 1/4 * sum(subs(f, x = (i-1)/4), i = 1..4)

732

Die Summendarstellung für die Obersummen ergibt sich analog:

• Rechtecke_4Rechts:= 1/4 * sum(subs(f, x = i/4), i = 1..4)

1532

Wenn wir diese Formeln nun für die Anzahl von n Rechtecken verall-

gemeinern wollen, müssen wir noch einmal überlegen, wie sie zustande

gekommen sind: Der Faktor 41

ist der Kehrwert der Anzahl der Rechtecke,

da wir das Intervall in 4 gleich große Teile unterteilt haben. Außerdem

werden die Funktionswerte der linken bzw. rechten Intervallgrenzen benö-

tigt. Wenn wir nun in den obigen beiden Berechnungsvorschriften jede 4

durch ein n ersetzen, erhalten wir:

• Rechtecke_nLinks:= 1/n * sum(subs(f, x = (i-1)/n), i = 1..n)

2 ⋅ n2 − 3 ⋅ n + 16 ⋅ n2

• Rechtecke_nRechts:= 1/n * sum(subs(f, x = i/n), i = 1..n)

(2 ⋅ n + 1) ⋅ (n + 1)6 ⋅ n2

Für große n wird der Flächeninhalt der Funktion immer besser durch

den Flächeninhalt der Rechtecke angenähert. Um aber die Maßzahl für den

Flächeninhalt ablesen zu können, müssen wir die Ausdrücke umstellen:

• expand(Rechtecke_nLinks), expand(Rechtecke_nRechts)

16 ⋅ n2 − 1

2 ⋅ n + 1

3, 1

2 ⋅ n + 1

6 ⋅ n2 + 1

3

64 Integration

Jetzt haben wir jeweils drei Summanden: Der dritte, 31

, ist unabhängig

von n. Nun experimentieren wir ein wenig mit den beiden anderen, d.h.

mit nn 2

16

12 − und

nn 21

61

2 + , um zu sehen, was für große n geschieht. Dafür

definieren wir diese als Funktion in n.

• Links:= 1/(6*n^2) - 1/(2*n): Rechts:= 1/(2*n) + 1/(6*n^2):

Nun setzen wir große Werte für n ein.

• float(subs(Links, n = 100)); float(subs(Links, n = 1000)); float(subs(Links, n = 10000)); float(subs(Rechts, n = 100)); float(subs(Rechts, n = 1000)); float(subs(Rechts, n = 10000))

− 0.004983333333

− 0.0004998333333

− 0.00004999833333

0.005016666667

0.0005001666667

0.00005000166667

Wir vermuten, dass beide für sehr große n gegen den Wert Null stre-

ben. Zur Kontrolle bestimmen wir den Grenzwert für n gegen Unendlich:

• limit(Links, n = infinity); limit(Rechts, n = infinity)

0

0


Da der Grenzwert beider Funktionen für n gegen Unendlich Null ist, ist

31

die Maßzahl der Fläche, die die Normalparabel mit der x-Achse im In-

tervall [0; 1] einschließt, denn die Funktionen Rechtecke_nLinks und

Rechtecke_nRechts streben für n gegen Unendlich gegen 31

:

• limit(Rechtecke_nLinks, n = infinity); limit(Rechtecke_nRechts, n = infinity)

13

13

Im Übrigen berechnet auch die MuPAD-Funktion int den Flächeninhalt:

• int(f, x = 0..1)

13

Neben der Betrachtung von Unter- bzw. Obersummen können wir auch

„zentrierte“ Summen betrachten, die im allgemeinen den Flächeninhalt

unter einer Funktion besser annähern (hier z.B. für 4 Rechtecke):

• plot(student::plotRiemann(f, x = 0..1, 4), GridVisible)

0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0

0.0

0.1

0.2

0.3

0.4

0.5

0.6

0.7

0.8

0.9

1.0

x

y


66 Integration

Auch hier wird unser Intervall in vier Teile zerlegt. Die Grundseite ist

nun nicht mehr der Funktionswert der linken oder rechten Intervallgrenze,

sondern der der Intervallmitte. Diese Näherung ist genauer als die durch

Ober- oder Untersummen. Auch für diesen Fall kann man über eine ent-

sprechende Summenformel den Flächeninhalt unter der Funktion über ei-

nen Grenzwert bestimmen. Wir geben die Formel hier ohne Herleitung an:

• Rechtecke_n:= 1/n * sum(subs(f, x = ((i-1)/n + i/n)/2), i = 1..n)

4 ⋅ n2 − 112 ⋅ n2

• limit(Rechtecke_n, n = infinity)

13

Ferner bietet MuPAD die Möglichkeit mit Hilfe der Funktion stu-

dent::riemann den Flächeninhalt der Näherungen auch direkt berechnen

zu lassen. Auf diese Weise kann vermieden werden, dass zunächst eine

Summationsformel für die Flächeninhalte der Rechtecke von Hand herge-

leitet werden muss. Wir hatten zu Beginn dieses Abschnitts den Flächen-

inhalt der Untersumme bei einer Unterteilung des Integrationsintervalls

[0; 1] in zwei Teile zu 0.125 berechnet. Diesen Wert können wir auf die

folgende Weise auch direkt bestimmen lassen:

• float(student::riemann(f, x = 0..1, 2, Left))

0.125

4.2 Das Trapezverfahren

Im Gegensatz zu Rechtecken kann man auch Trapeze zur näherungs-

weise Berechnung von Flächeninhalten unter einer gegebenen Funktion

verwenden. Im allgemeinen nähern Trapeze – wie die Grafik unten sicher-

lich bereits suggeriert – solche Flächeninhalte besser an als Rechtecke.

Das Trapezverfahren 67

Die MuPAD-Funktion student::plotTrapezoid zeichnet solche Nähe-

rungen über Trapeze und wird ganz analog zu student::plotRiemann

verwendet. Auch hier wollen wir als Beispielfunktion die Normalparabel 2)( xxf = betrachten:

• f:= x^2: plot(student::plotTrapezoid(f, x = 0..1, 2), GridVisible)

0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0

0.0

0.1

0.2

0.3

0.4

0.5

0.6

0.7

0.8

0.9

1.0

x

y Trapezoidal: 0.375real: 0.333

Um die Fläche des Trapezes zu berechnen, müssen wir die Formel für

den Flächeninhalt eines Trapezes kennen. Der Flächeninhalt eines Trape-

zes ist gleich der Hälfte des Produkts aus der Höhe h und der Summe der

Längen der Grundseiten, wobei die Grundseiten a und c parallel sind. Es

gilt also: )(21 cahA += .

Unsere Höhe ist für beide Trapeze 0,5, denn das Intervall [0; 1] wird

unterteilt in die Intervalle [0; 0,5] und [0,5; 1]. a und c ergeben sich aus

den Funktionswerten bei 0 und 0,5 bzw. 0,5 und 1:

• Trapez_2:= 1/2 * 0.5 * (subs(f, x = 0) + subs(f, x = 0.5)) + 1/2 * 0.5 * (subs(f, x = 0.5) + subs(f, x = 1))

0.375

Wir haben bereits bei dem vorhergehenden Verfahren gesehen, dass

die Genauigkeit mit der Anzahl der Rechtecke stieg. Beim Trapezverfahren

68 Integration

nimmt die Genauigkeit mit der Anzahl der Trapeze zu. Daher betrachten

wir als nächstens 4 Trapeze:

• plot(student::plotTrapezoid(f, x = 0..1, 4), GridVisible)

0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0

0.0

0.1

0.2

0.3

0.4

0.5

0.6

0.7

0.8

0.9

1.0

x


Diese Näherung ist deutlich besser. Wir berechnen den Flächeninhalt,

der durch die 4 Trapeze gegeben ist: Die Höhe, welche jeweils durch die

Länge der Teilintervalle [0; 0,25], [0,25; 0,5], [0,5; 0,75], [0,75; 1] vor-

gegeben ist, beträgt 0,25 LE. Die Länge der Grundseiten ermitteln wir

wieder durch die Funktionswerte an den Intervallgrenzen:

• Trapez_4:= 1/2 * 0.25 * (subs(f, x = 0) + subs(f, x = 0.25)) + 1/2 * 0.25 * (subs(f, x = 0.25) + subs(f, x = 0.5)) + 1/2 * 0.25 * (subs(f, x = 0.5) + subs(f, x = 0.75)) + 1/2 * 0.25 * (subs(f, x = 0.75) + subs(f, x = 1))

0.34375

Wir erhöhen die Anzahl der Trapeze auf 8:

• plot(student::plotTrapezoid(f, x = 0..1, 8), GridVisible)

Das Trapezverfahren 69

0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0

0.0

0.1

0.2

0.3

0.4

0.5

0.6

0.7

0.8

0.9

1.0

x


Man sieht optisch keinen Unterschied zwischen der Funktion und der

Annäherung der Fläche durch die Trapeze. Die Höhe entspricht wieder den

Intervalllängen der Intervalle [0; 0,125], [0,125; 0,25], [0,25; 0,375],

[0,375; 0,5], [0,5; 0,625], [0,625; 0,75], [0,75; 0,875], [0,875; 1].

• Trapez_8:= 1/2 * 0.125 * (subs(f, x = 0) + subs(f, x = 0.125)) + 1/2 * 0.125 * (subs(f, x = 0.125) + subs(f, x = 0.25)) + 1/2 * 0.125 * (subs(f, x = 0.25) + subs(f, x = 0.375)) + 1/2 * 0.125 * (subs(f, x = 0.375) + subs(f, x = 0.5)) + 1/2 * 0.125 * (subs(f, x = 0.5) + subs(f, x = 0.625)) + 1/2 * 0.125 * (subs(f, x = 0.625) + subs(f, x = 0.75)) + 1/2 * 0.125 * (subs(f, x = 0.75) + subs(f, x = 0.875)) + 1/2 * 0.125 * (subs(f, x = 0.875) + subs(f, x = 1))

0.3359375

Wie im letzten Abschnitt möchten wir natürlich auch eine allgemeine

Formel in Abhängigkeit der Anzahl der Rechtecke als Näherung für den

gesuchten Flächeninhalt angeben. Der zweite Faktor ist offensichtlich der

Kehrwert der Anzahl der Trapeze, in diesem Fall also 81

. Danach folgen die

70 Integration

jeweiligen Intervallgrenzen. Wenn wir von acht Trapezen ausgehen, sind

das die Intervalle von 0 bis 81

, von 81

bis 82

, etc. Mit Hilfe dieser Beobach-

tung lässt sich dann die durch 8 Trapeze eingeschlossene Fläche unter der

Normalparabel wie folgt berechnen:

• Trapez_8:= 1/2 * 1/8 * sum (subs(f, x = (i-1)/8) + subs(f, x = i/8), i = 1..8)

43128

Hierbei handelt es sich um das gleiche Ergebnis, das wir oben nähe-

rungsweise in Dezimaldarstellung geschrieben hatten. Um die Formel für n

Trapeze zu erstellen, müssen wir – wie schon bei den Summenformeln aus

dem letzten Abschnitt – nur noch jede 8 durch ein n ersetzen:

• Trapez_n:= 1/2 * 1/n * sum(subs(f, x = (i-1)/n) + subs(f, x = i/n), i = 1..n)

2 ⋅ n2 + 16 ⋅ n2

Für n gegen Unendlich sollten wir das gleiche Ergebnis erhalten, das

wir schon im letzten Abschnitt dieses Kapitels berechnet hatten (also 1/3

als Maßzahl für die gesuchte Fläche). Wie wir sehen, ist dies tatsächlich

der Fall:

• limit(Trapez_n, n = infinity)

13

Wie schon die Funktion student::riemann, die es uns erlaubte, die

Flächeninhalte der Näherungen über Rechtecke direkt zu berechnen, findet

sich in MuPAD auch eine Prozedur student::trapezoid, mit deren Hilfe

sich die Flächenhalte der Trapeze direkt berechnen lassen. Im Fall von 8

Trapezen erhält man die gewünschte Näherung auch wie folgt:

Rotationskörper 71

• float(student::trapezoid(f, x = 0..1, 8))

0.3359375

Tipps

Neben der Annäherung durch Rechtecke und Trapeze (im Grunde

stellen diese geometrischen Objekte lineare Funktionen dar) gibt es

noch die Möglichkeit durch quadratische Funktionen anzunähern.

Hierbei handelt es sich um das Simpson-Verfahren (nach Thomas

Simpson, 1710-1761). Mit Hilfe der MuPAD-Funktion stu-

dent::plotSimpson können wir diese darstellen sowie mit stu-

dent::simpson die Maßzahlen der Flächen der entsprechenden direkt

von MuPAD berechnen lassen.

4.3 Rotationskörper

Neben der Berechnung von Flächeninhalten kann das Integral auch zur

Berechnung des Volumens von Rotationskörpern verwendet werden. Diese

entstehen durch Rotation des Graphen einer Funktion um die x-Achse.

Wenn wir eine konstante Funktion cxf =)( um die x-Achse rotieren las-

sen, entsteht ein Zylinder, bei einer linearen Funktion mxxf =)( ein Ke-

gel.

In MuPAD ermöglicht die Funktion plot::XRotate diese Rotation zu vi-

sualisieren. Als Beispiel betrachten wir die lineare Funktion, die durch

xxf21)( = gegeben ist:

• f:= 1/2 * x

x2

Im Intervall [0; 5] lassen wir sie um die x-Achse rotieren:

72 Integration

• plot(plot::XRotate( f, x = 0..5))

Wir können diese Grafik zusätzlich bearbeiten und manipulieren: In

dem MuPAD eigenen Grafik-Programm VCam. Dafür müssen wir die Grafik

zunächst mit einem Doppelklick aktivieren – die Benutzungsoberfläche

verändert sich leicht und stellt uns u.a. Buttons zur Verfügung, mit deren

Hilfe sich der Rotationskörper drehen lässt:

Rotationskörper 73

(der obige Screenshot zeigt die englische Version von MuPAD 3.0 – die

Oberfläche des Grafik-Viewers VCam ist in der deutschen Version natürlich

in deutscher Sprache gehalten). Am rechten Rand finden sich alle Einzel-

bestandteile der jeweils geöffneten Grafik: das Canvas (technischer Begriff

für die Zeichenfläche, auf der MuPAD eine Grafik erstellt), Scene3d (wir

haben eine 3D-Szene erzeugt – einen Rotationskörper im Raum), Coordi-

nateSystem3d (das Koordinatensystem im Raum) und schließlich XRotate

(der Rotationskörper selbst). Klickt man z.B. auf das Objekt XRotate, so

erscheinen im mittleren Fenster auf der rechten Seite die Eigenschaften

des grafischen Objekts. Hier lässt sich z.B. unter der Rubrik Surface der

Darstellungsstil über den Eintrag Filled mit einem einzelnen Mausklick in

ein einfaches Drahtgittermodell umstellen. Auch die Farben des Körpers

und Transparenzen in 3D lassen sich hier einstellen:

Als nächstes möchten wir das Volumen dieses Körpers berechnen. Die

Formel, die bei gegebener Höhe h und gegebenem Radius r zur Berechung

des Volumens eines Kegels verwendet werden kann, lautet bekanntlich

hrV 2

3π

= . Wir haben unsere Funktion im Intervall [0; 5] rotieren lassen,

74 Integration

so dass die Höhe des Körpers 5 Längeneinheiten (LE) ist. Der Radius ist

gerade der Funktionswert an der Stelle x = 5:

• V:= 1/3 * PI * r^2 * h

π ⋅ h ⋅ r2

3

• subs(V, h = 5, r = subs(f, x = 5))

125 ⋅ π12

Wie immer rechnet MuPAD mit den exakten Werten. Wir ziehen hier ei-

ne Dezimalbruchdarstellung vor:

• float(%)

32.72492347 Wenn wir statt einer linearen Funktion eine konstante Funktion vom

Typ cxf =)( um die x-Achse rotieren lassen, entsteht ein Zylinder:

• f:= 3: plot(plot::XRotate(f, x = 0..2))

Auch diese Grafik kann wieder mit einem Doppelklick aktiviert und im

Grafik-Viewer VCam interaktiv erforscht werden.

In der Schule geht man üblicherweise so vor, dass man das Volumen

eines Rotationskörpers bestimmt, indem man ihn zunächst durch Zylinder,

Rotationskörper 75

also durch rotierende konstante Funktionen, annähert. Betrachten wir bei-

spielsweise die Funktion 1)( −= xxf .

• f:= (x-1)^(1/2) x − 1

Zuerst lassen wir diese im Intervall [1; 7] zeichnen.

• plotfunc2d(f, x = 1..7)

1 2 3 4 5 6 70.0

0.5

1.0

1.5

2.0

2.5

x

y

Als Rotationskörper ergibt sich die folgende Darstellung:

• plot(plot::XRotate(f, x = 1..7))

76 Integration

Oder aus einer anderen Perspektive:

Nun kann man das Intervall [1; 7] – ähnlich wie bei der Riemann-

Integration in den vorhergehenden Abschnitten – in mehrere gleichgroße

Teilintervalle unterteilen, z.B. in [1; 3], [3; 5], [5; 7]. Die Funktionswerte

der rechten Intervallgrenzen sind nun die Funktionswerte der konstanten

Funktionen, die wir verwenden wollen, um den Rotationskörper anzunä-

hern. Wir veranschaulichen die Situation

• p:= plot::xrotate(f, x = 1..7): q:= plot::xrotate(subs(f, x = 3), x = 1..3): r:= plot::xrotate(subs(f, x = 5), x = 3..5): s:= plot::xrotate(subs(f, x = 7), x = 5..7): plot(p, q, r, s)

Rotationskörper 77

Wie das Bild sicherlich suggeriert, ist die Summe der Volumina der drei

Zylinder ist deutlich größer als das Volumen des Rotationskörpers. Daher

nähern wir zusätzlich durch kleinere Zylinder an. Diese entstehen da-

durch, dass wir die Funktionswerte der linken Intervallgrenzen als kon-

stante Funktionen nehmen:

• t:= plot::XRotate(subs(f, x = 1), x = 1..3): u:= plot::XRotate(subs(f, x = 3), x = 3..5): v:= plot::XRotate(subs(f, x = 5), x = 5..7): plot(p, t, u, v)

Hier haben wir Transparenzen bei der Darstellung des Rotationskörpers

unserer Wurzelfunktion gewählt, damit man die einbeschriebenen Zylinder

sehen kann.

An dieser Stelle ist anzumerken, dass Printmedien leider nicht alle Vor-

züge der 3D-Grafik wiedergeben können. Mit MuPAD am Rechner (und in

Farbe) lassen sich die Rotationskörper bedeutend besser erkennen und

von einander unterscheiden als auf Schwarz-Weiß-Darstellungen.

Das Volumen eines Zylinders errechnet sich mit Hilfe der Formel

hrV ⋅⋅= 2π . Unsere Höhe h ist die jeweilige Intervalllänge und der Radius

entspricht gerade dem Wert unserer konstanten Funktion, also dem Funk-

tionswert an den Intervallgrenzen. Wir bezeichnen mit 1V die Summe der

78 Integration

Volumina der umgeschriebenen Zylinder, mit 2V die Summe der Volumina

der einbeschriebenen Zylinder und mit V das gesuchte Volumen. Dann

muss gelten: 12 VVV ≤≤ .

• V1:= PI * (subs(f, x = 3))^2 * (3 - 1) + PI * (subs(f, x = 5))^2 * (5 - 3) + PI * (subs(f, x = 7))^2 * (7 - 5)

24 ⋅ π

• V2:= PI * (subs(f, x = 1))^2 * (3 - 1) + PI * (subs(f, x = 3))^2 * (5 - 3) + PI * (subs(f, x = 5))^2 * (7 - 5)

12 ⋅ π Wir erhalten also: ππ 2412 ≤≤V . Nun könnten wir die Anzahl der Inter-

valle und somit die der Zylinder erhöhen, um uns immer weiter an das Vo-

lumen anzunähern. Das Ergebnis wäre dann,

dxxfVb

a∫⋅= 2)(π

also in unserem Fall

dxxdxxV 1)1(7

1

7

1

2 ∫∫ −⋅=−⋅= ππ .

Das tatsächliche Volumen berechnet sich damit zu:

• V:= PI * int(f^2, x = 1..7)

18 ⋅ π

was interessanter Weise genau mit dem Mittelwert der beiden obigen

Näherungen übereinstimmt.

Übungen

Zeichnen Sie die Funktion x

xf 1)( = im Intervall [1; 2]. Zeichnen Sie

die Annäherung des Flächeninhalts, der von der Funktion und der x-

Achse eingeschlossen wird, mit 8 Untersummen, Obersummen, Rie-

mann-Summen und Trapezen und berechnen Sie jeweils den angenä-

Rotationskörper 79

herten Flächeninhalt. Bestimmen Sie den exakten Wert des Integrals

∫2

1

1 dxx

.

Gehen Sie analog für ∫ +

1

021

4 dxx

vor.

Zeichnen Sie die Funktion 214x+

im Intervall [0; 2] und im Intervall

[0; 4]. Lassen Sie beide Graphen nacheinander um die x-Achse rotie-

ren. Öffnen Sie jeweils die Grafik im 3D-Grafik-Viewer VCam. Expe-

rimentieren Sie dort mit der Transparenz, der Farbe und der Perspek-

tive. Zoomen Sie in die Grafik hinein.

Erstellen Sie mit Hilfe der MuPAD-Funktion plot::xrotate Graphen

von Alltagsgegenständen Ihrer Wahl. In der Materialsammlung unter

www.mupad.de/schule+studium finden Sie z.B. die Modellierung ei-

nes „Strahlers“ und eines „Kelches“ mit Hilfe eines Rotationskörpers –

besonders schöne Grafiken werden vom MuPAD-Schule-Team gern in

die Grafik-Galerie im Web übernommen.

80 „Mensch-ärgere-Dich-nicht“ – eine spielerische Anwendung

5. „Mensch-ärgere-Dich-nicht“ – eine spie-lerische Anwendung

Diese Unterrichtseinheit basiert auf der gleichbetitelten Unterrichtsrei-

he von Frau Bärbel Barzel, Marie-Curie-Gymnasium, Düsseldorf, die im

Web unter der Url http://www.learnline.de/angebote/cas/barzel1.htm zum

freien Download bereitsteht.

Die Schülerinnen und Schüler erhalten eine Spielfigur und eine Schieb-

lehre. Ihre Aufgabe besteht dann darin, experimentell das Volumen der

Spielfigur über einen geeigneten Rotationskörper zu visualisieren bzw. zu

berechnen. Diese Aufgabe könnte in kleinen Gruppen bearbeitet werden.

Im Rahmen dieses Kapitels wird eine mögliche Bearbeitung der Aufgabe

durch Schülerinnen und Schüler diskutiert.

Unterrichtliche Voraussetzungen für die Bearbeitung der Aufgabe sind

im Wesentlichen genau die mathematischen Themenkomplexe, die auch in

diesem Buch in den vorhergehenden Kapiteln diskutiert wurden. Die

Schülerinnen und Schüler erhalten neben der Schieblehre und dem

Mensch-ärgere-Dich-nicht-Männchen die folgende Ausgabenstellung in

schriftlicher Form:

Aufgabenstellung:

(i) Angabe des von ihnen gewählten Verfahrens zur Bestimmung

des Volumens (Vorüberlegungen)

(ii) Ermittlung einige Messdaten mit der Schieblehre und Visuali-

sierung der Daten als Folge von Punkten im Koordinatensys-

tem

(iii) Bestimmung einer passenden (interpolierenden) Funktion, die

die Konturlinie der Figur modelliert

(iv) Berechnung des Volumens und Darstellung des Rotationskör-

pers

Rotationskörper 81

Eine mögliche Bearbeitung der Aufgabe ist dann die folgende:

Zu (i): Das Volumen des Männchens soll am Ende durch ein Integral

bestimmt werden. Dazu müssen wir zuerst eine Funktion / Funktionen

bestimmen, die die tatsächliche Form des Männchens möglichst gut annä-

hern. Da das Männchen als Rotationsfigur dargestellt werden kann, haben

wir eine sehr einfache Möglichkeit das Volumen zu bestimmen, denn wir

müssen nur noch die Kurve auf der Schnittebene der Rotationsachse an-

nähern.

Zu (ii): Mit der Schieblehre konnten folgende Messewerte bestimmt

werden, die gleich in Koordinatenform (für die entsprechenden Punkte im

Koordinatensystem) angegeben werden:

• P1:= [0, 61/100]: P2:= [1/2, 61/100]: P3:= [1, 79/200]: P4:= [29/20, 97/400]: P5:= [17/10, 7/20]: P6:= [41/20, 5/10]: P7:= [239/100, 0]:

Die Punkte werden zu einer Liste von Punkten zusammengeschlossen:

• PunkteListe:= [P1, P2, P3, P4, P5, P6, P7]:

Im Koordinatensystem ergibt sich die Folge von Punkten zu:

• plot( plot::Point2d(PunkteListe[i]) $ i = 1..7, Scaling = Constrained ):

0.0 0.2 0.4 0.6 0.8 1.0 1.2 1.4 1.6 1.8 2.0 2.20.0

0.2

0.4

0.6

x

y


Zu (iii): Damit existieren sieben Bedingungen, woraus man eine ganz-

rationale Funktion sechsten Grades der Gestalt

f (x) = a ⋅ x6 + b ⋅ x5 + c ⋅ x4 + d ⋅ x3 + e ⋅ x2 + g ⋅ x + h

bestimmen kann. Wir definieren die Funktion zunächst in dieser allgemei-

nen Form:

• f:= a*x^6 + b*x^5 + c*x^4 + d*x^3 + e*x^2 + g*x + h

h + g ⋅ x + a ⋅ x6 + b ⋅ x5 + c ⋅ x4 + d ⋅ x3 + e ⋅ x2

Die entsprechenden Gleichungen ergeben sich jetzt durch Einsetzen

der x- bzw. y-Koordinaten der Punkte P1 bis P7 in die Gleichung von f:

• GL1:= subs(f, x = P1[1]) = P1[2]; GL2:= subs(f, x = P2[1]) = P2[2]; GL3:= subs(f, x = P3[1]) = P3[2]; GL4:= subs(f, x = P4[1]) = P4[2]; GL5:= subs(f, x = P5[1]) = P5[2]; GL6:= subs(f, x = P6[1]) = P6[2]; GL7:= subs(f, x = P7[1]) = P7[2]

h = 61100

a

64 + b

32 + c

16 + d

8 + e

4 + g

2 + h = 61

100

a + b + c + d + e + g + h = 79200

594823321 ⋅ a

64000000 + 20511149 ⋅ b

3200000 + 707281 ⋅ c

160000 + 24389 ⋅ d

8000 + 841 ⋅ e

400 + 29 ⋅ g

20 + h = 97

400

24137569 ⋅ a

1000000 + 1419857 ⋅ b

100000 + 83521 ⋅ c

10000 + 4913 ⋅ d

1000 + 289 ⋅ e

100 + 17 ⋅ g

10 + h = 7

20

4750104241 ⋅ a64000000

+ 115856201 ⋅ b3200000

+ 2825761 ⋅ c160000

+ 68921 ⋅ d8000

+ 1681 ⋅ e400

+ 41 ⋅ g20

+ h = 12

186374892382561 ⋅ a1000000000000

+ 779811265199 ⋅ b10000000000

+ 3262808641 ⋅ c100000000

+ 13651919 ⋅ d1000000

+ 57121 ⋅ e10000 + 239 ⋅ g

100 + h = 0

Das Gleichungssystem kann nun auf die übliche Weise mit Hilfe der

Funktion solve sehr leicht gelöst werden:

Rotationskörper 83

• L:= solve({GL1, GL2, GL3, GL4, GL5, GL6, GL7}, {a, b, c, d, e, g, h}):

Wir haben die Ausgabe aufgrund der recht beträchtlichen Größe an die-

ser Stelle unterdrückt:

• f:= subs(f, op(L[1])):

Wir zeichnen den Graphen der Funktion f mit den gemessenen Punkten

in ein gemeinsames Koordinatensystem:

• plot( plot::Point2d(PunkteListe[i]) $ i = 1..7, plot::Function2d(f, x = 0..239/100, Color = RGB::Blue), Scaling = Constrained ):

0.0 0.2 0.4 0.6 0.8 1.0 1.2 1.4 1.6 1.8 2.0 2.20.0

0.2

0.4

0.6

x

y

Zu (iv): Das Volumen der Spielfigur berechnet sich mittels der aus

dem Unterricht bekannten Formel:

• V:= PI * int(f^2, x = 0..239/100)

1358538490033145468452726642503978906053604355231558559 ⋅ π2838519826675425763521857257451906756250000000000000000

Auf 10 Dezimalstellen gerundet ergibt das:

• float(V)

1.50359159


Eine anschauliche Darstellung des Rotationskörper liefert die Funktion

plot::XRotate:

• plot(plot::XRotate(f, x = 0..239/100),Scaling = Constrained)

Im 3D-Grafik-Viewer VCam kann die die Spielfigur dann wieder von

außen und von innen erforscht und für Präsentationen aufbereitet werden

(mit Transparenzen der Seitenflächen, als Drahtgittermodell u.v.m.):

Rotationskörper 85

Schließlich lassen sich alle Messpunkte, die Kurve durch die Messpunkte

und der Rotationskörper in ein gemeinsames Koordinatensystem zeichnen,

so dass eine Grafik entsteht, die gesamten Lösungsweg dokumentiert. Mit


den folgenden Befehlen wird sogar eine Animation erzeugt, in der man

zusehen kann, wie sich die obere Hälfte des Rotationskörpers aufbaut.

• plot(plot::XRotate(f, x = 0..239/100, AngleRange = PI..2*PI), plot::XRotate(f, x = 0..239/100, AngleRange = 0..a, a = 0..PI, Filled = FALSE), plot::Tube([t, subs(f, x = t), 0], 0.02,

t = 0..239/100, ULinesVisible = FALSE,

VLinesVisible = FALSE, Color = RGB::Grey), plot::Sphere(0.05, [op(PunkteListe[i]),0], Color = RGB::Blue) $ i = 1..7, Scaling = Constrained ):

Wir zeigen hier nur vier Einzelbilder der Animation:

Index 87

Index 3D-Viewer .............................84

analysis-Bibliothek .................26

Differenzenquotient .......... 40, 44

Einheitsquadrat......................56

Funktionsschar.......................44

Heron .....................................9

MuPAD-Befehle

% ......................................20

@@....................................20

append...............................32

array..................................13

assume ..............................44

delete.................................27

diff.....................................16

DIGITS ......................9, 13, 27

expand ...............................45

expr2text............................21

float ...................................13

for .....................................13

fp::unapply .........................20

intersect .............................26

limit ...................................45

numeric::solve ....................26

package..............................27

plot::Function2d ..................16

plot::Point2d .......................17

plot::Rectangle....................10

plot::XRotate ......................71

plotfunc2d...........................34

print...................................21

proc ...................................13

return.................................13

sign....................................30

solve ............................ 15, 26

student::plotRiemann ...........57

student::plotSimpson ...........71

student::plotTrapezoid..........67

student::riemann .................70

student::simpson.................71

student::trapezoid ...............70

subs...................................16

sum ...................................70

MuPAD-Optionen

GridVisible...........................34

MaxDegree..........................16

Scaling ...............................12

Unquoted............................21

X/YAxisTitle.........................34

Nachkommastellen .................14

Newton, Sir Isaac ...................14

Normalparabel .......................56

Nullstellen ....................... 14, 16

Prozedur ......................... 13, 21

Quadratwurzel ........................ 9

Riemann, Bernhard.................56

Riemann-Integration...............56

RootOf ..................................16

Rotation ................................71

Rotationskörper................ 71, 72

Sekante ................................41

Tangente ............. 14, 15, 21, 41 Wurzel ..................................16

Mathematik 1 × andersBand 4

MuPAD ist ein Computeralgebra-System, mit dem Problemstellungender Mathematik sowie der Natur- und Ingenieurwissenschaften behandeltwerden können. Es ist ein wertvolles Hilfsmittel für Schüler und Studenten,Lehrer und Wissenschaftler.

Dieser Band greift schulische Themen der Analysis (Iterationsverfahren,Differentialrechnung, Interpolation und Integration) auf und diskutiert underarbeitet sie mit MuPAD.

Dem Leser sollen einerseits Anregungen für den Einsatz von MuPAD imMathematikunterricht gegeben werden und andererseits anhand konkreterAufgabenstellungen der Umgang mit MuPAD und seinen Befehlen zum nahezu beliebig genauen numerischen Rechnen sowie zum algebraischexakten und symbolischen Rechnen demonstriert werden.

SciFace Software • Paderborn Sci Face

MuPAD in Schule und Studium

www.mupad.de/[email protected]

Documents

Analysis mit MuPAD - mspielmann.de