Einführung in Maple: 1. Arbeitsblatt

Priv. Doz. Dr. Bernhard Schmidt 22.4.2004 

http://www.math.uni-augsburg.de/˜schmidtb 

Einführung in Maple: 1. Arbeitsblatt 

Nach dem Start von Maple befinden Sie sich in einem Maple-Arbeitsblatt (worksheet). Innerhalb 

des Arbeitsblatts reagiert Maple auf die Eingabe von Befehlen mit einer Ausgabe. 

Eingaben und Ausgaben von Maple sind hier immer im Fettdruck geschrieben. Wichtige 

Punkte: 

• Maple-Befehle müssen immer mit einem Semikolon oder einem Doppelpunkt abgeschlossen 

werden. 

• Dabei unterdrückt ein Doppelpunkt die Ausgabe des Ergebnisses. 

• Maple unterscheidet zwischen Klein- und Großschreibung. 

• Nur runde Klammern sind Klammern im mathematischen Sinn. Geschweifte Klammern 

umschlie¨sen Mengen, eckige Klammern umschließen Listen. 

• Maple-Variablen brauchen nicht deklariert zu werden. 

• Eine Zuweisung erfolgt mit :=, nicht einfach mit =. Richtung wäre z.B. pi:=3.14;, 

falsch dagegen pi=3.14. 

• Kommazahlen werden wie im Englischen mit einem Dezimalpunkt geschrieben, z.B. 

3.1415926 

• Man sollte von vorneherein allen Zwischenergebnissen durch Zuweisungen Namen 

geben, um später leicht auf sie zugreifen zu können. 

1

1 Arithmetische Operationen, mathematische Funktionen 

Operation 

Befehlsbeispiel 

Addition 5+444; 

Subtraktion 324-234; 

Multiplikation 234*2432; 

Division 234324/3; 

Potenzierung 2ˆ23434; 

Divisionsrest 33 mod 13; 

Fakultät 10!; 

Kreiszahl π 

Pi; 

Dezimaldarstellung 

evalf(Pi); 

Exponetialfunktion e x 

exp(10); 

Eulersche Zahl 

exp(1); 

Natürlicher Logarithmus 

log(23); 

Sinus 

sin(Pi/2); 

Mehrgliedrige Summe 

sum(i,i=1..10); 

Mehrgliedriges Produkt 

product(1+1/x, x=1..10); 

Runden zur nächsten ganzen Zahl round(2.6); 

Zuweisungen 

A:=200034; B:=evalf(sin(10)); 

Aufgabe 1.1 a) Berechnen Sie die Dezimaldarstellung von 

π 8 + π 2 + 3π 

e 4 + 1 

(e = Eulersche Zahl). Achtung: Eine Multiplikation erfordert einen * (z.B. 3*Pi). Runden 

Sie dann zur näcsten ganzen Zahl z und berechen Sie z 10 modulo 13. 

Notwendige Befehle: exp, evalf, round, mod. 

b) Berechnen Sie die Dezimaldarstellung von 

für n = 10000. 

2 Die Hilfefunktion 

log n − 

Maple verfügt über eine hervorragende Hilfefunktion. Nach Eingabe von ?B; wird eine 

ausführliche Beschreibung des Befehls B angezeigt und auf weitere verwandte Befehle 

verwiesen. Die Hilfefunktion ist so gut, dass man durchaus große Teile von Maple allein 

mit ihrer Hilfe erlernen kann. Wichtig: 

• Die Beispiele am Ende der Hilfe-Anzeige sind meist am hilfreichsten. 

Befehl 

?matrix; 

???matrix; 

n∑ 

i=1 

Kommentar 

Hilfe zu Matrizen wird angezeigt 

Beispiele zu Matrizen werden angezeigt 

Aufgabe 2.1 Finden Sie durch ?randmatrix; heraus, wie man eine Zufallsmatrix erzeugt. 

Erzeugen Sie als Beispiel eine 30x30-Zufallsmatrix. 

2 

1 

i

3 Die Maple-Pakete 

Maple-Pakete sind Pakete von nützlichen Befehlen jeweils zu einem bestimmten mathematischen 

Gebiet. 

Wichtig: Bevor man einen Befehl (z.B. matrix) eines Pakets (hier linalg) verwenden 

kann, muss das Paket geladen werden (hier mit with(linalg);). 

Alle verfügbaren Pakete kann man sich mit ?package; anzeigen lassen. Da man zu den 

einzelnen Paketen durch die Hilfefunktion sehr gute Informationen erhält, kann man sich 

so interaktiv schnell einen Überblick verschaffen. 

Überblick einiger Pakete 

• linalg Rechnen mit Matrizen und Vektoren, von der Matrizenmultiplikation bis zu 

Eigenwertbestimmung und Normalformen 

• numtheory Befehle für elementare Zahlentheorie, z.B. Primzahltest, Bestimmung 

der n-ten Primzahl, Faktorisierung ganzer Zahlen. 

• plots Hilfsmittel zum Erzeugen von zwei- und dreidimensionalen Graphiken. 

• stats Das Statistik-Paket. 

Aufgabe 3.1 Finden Sie mit Hilfe von ?linalg; den Befehl zum Lösen linearer Gleichungssysteme 

und lösen Sie 

x 1 + x 2 + x 3 = 5 

2x 1 − x 2 − x 3 = 10 

5x 1 − 3x 2 + x 3 = 0 

Hinweis: Dazu muss man die Koeffizienten der linken Seiten mit 

A:=matrix([[1,1,1],[2,-1,-1],[5,-3,1]]); in eine Matrix und die rechten Seiten mit 

b:=vector([5,10,0]); in einen Vektor schreiben. 

4 Ausdrücke, Typen und Funktionen 

Ein Ausdruck ist in Maple eine beliebige Folge von Zeichen, die die Syntaxregeln nicht 

verletzt. Zum Beispiel sind sin(x) und jdfksk234 gültige Ausdrücke, aber nicht aˆˆx, da 

ˆˆ ein Syntaxfehler ist. 

Jeder Ausdruck X besitzt in Maple einen Typ, den man sich mit whattype(X); anzeigen 

lassen kann. Zum Beispiel liefert a:=10: whattype(a); die Ausgabe integer. Mit 

type(X,T); kann man prüfen, ob der Ausdruck X vom Typ T ist. Ein Ausdruck kann 

durchaus mehrere Typen haben. Zum Beispiel ist der Ausdruck 10 sowohl vom Typ integer 

als auch vom Typ polynom. Ein Ausdruck X kann (falls erlaubt) mit Hilfe des 

Befehls convert(X,T); in einen Ausdruck vom Typ T umgewandelt werden. Mit op(X); 

erhält man die “Operanden” des Ausdrucks X. Mit subs(x=t,A); kamm man die Variable 

x im Ausdruck A durch t ersetzen. 

Wichtig: Machen Sie sich mit den unentbehrlichen Befehlen op, subs, map, convert 

vertraut. Beispiele sind unten zu finden. 

3

Aufgabe 

Bestimmung des Typs 

Test, ob Ausdruck vom Typ rational 

Umwandlung in Typ float 

Operanden bestimmen 

Anzahl der Operanden 

Sinusfunktion auf Einträge einer Liste anwenden 

Variablen-Substitution in Ausdruck 

Erzeugung einer Funktion 


whattype(1.44); 

type(5433,rational); 

covert(1/2,float); 

op([1,2,3]); 

nops([1,2,3]); 

map(sin,[0.1,1.4]); 

subs(x=2,sin(x)ˆ2); 

f:=x ->x*sin(x); 

Maple-Typen Bedeutung 

integer ganze Zahl 

float 

Kommazahl 

rational Bruch 

complex komplexe Zahl (imaginäre Einheit ist I) 

exprseq Aufzählung von Ausdrücken, Trennung durch Kommas 

list 

Auszählung von Ausdrücken in eckigen Klammern 

set 

Auszählung von Ausdrücken in geschweiften Klammern 

Aufgabe 4.1 a) Geben Sie Z:=1.4; ein. Bestimmen Sie mit whattype den Typ von Z. 

Wandeln Sie Z mit convert in eine Zahl Z1 vom Typ rational um. 

b) Erzeugen Sie mit f:=x ->convert(x,float); eine Funktion und wenden Sie sie auf Z1 

an. 

Aufgabe 4.2 a) Geben Sie den Befehl L:=[1.3, 3.44, 0.34, 5.0, 30.03]; ein. Das erzeugt 

eine Liste L, die fünf Kommazahlen enthält. 

b) Verwandeln Sie die Einträge von L mit g:=x ->convert(x,rational); L1:=map(g,L); 

in Brüche. 

c) Überprüfen Sie mit type(L1[2],rational);, ob der zweite Eintrag von L1 tatsächlich 

vom Typ rational ist. 

d) Wenden Sie mit Hilfe von map die Sinusfunktion auf alle Einträge von L an. 

e) Bestimmen Sie mit nops die Anzahl der Einträge von L und L1. 

5 Die Typen exprseq, list, set 

Folgen, Listen und Mengen sind grundlegend für fast alle Maple-Anwendungen. Eine 

durch Kommas getrennte Folge von Ausdrücken hat in Maple den Typ exprseq (für 

expression sequence). Längere Folgen von Ausdrücken kann mit mit seq erzeugen, z.B. 

ergibt S:=seq(aˆ2, a=1..100); die Folge der ersten 100 Quadratzahlen. Eckige bzw. 

geschweifte Klammern um eine exprseq machen sie zu einer list bzw. set. 

Befehl 

s:=4,5,6,a,b,c; 

whattype(s); 

L:=[s]; 

whattype(s); 

m:=op(L); 

M:={m}; 

whattype(M); 

Erläuterung 

Erzeugung einer Folge 

Typbestimmung (ergibt exprseq) 

Umwandlung in eine Liste 

Typbestimmung (ergibt list) 

Entfernung der eckigen Klammern 

Umwandlung in eine Menge 

Typbestimmung (ergibt set) 

4

Auf das i-te Element einer Folge oder Liste L kann man mit L[i] zugreifen. Eine set 

ist eine Menge von ungeordneten Elementen, also eine Menge im mathematischen Sinn. 

Mengen kann man schneiden, vereinigen und voneinander abziehen: 

Befehl Erläuterung 

s:=1,2,3,a,b,c; Erzeugung einer Folge 

s[5]; Auswertung des 5. Elements der Folge (ergibt b) 

m:={s}; Umwandlung in eine Menge 

n:={1,2,3,4}; Erzeugung einer Menge 

m intersect n; Schnittmenge 

m union n; Vereinigungsmenge 

m minus n; Differenzmenge 

Aufgabe 5.1 a) Erzeugen Sie mit Hilfe von seq eine Folge, die die ersten 100 Primzahlen 

enthält (notwendiger Befehl: ithprime). Geben Sie dieser Folge den Namen PrimFolge. 

b) Wandelen Sie PrimFolge mit PrimList:=[PrimFolge]; in eine Liste um. Probieren 

Sie aus, was der Befehl op(PrimList); liefert. Wandeln Sie dann PrimList mit Hilfe von 

op und geschweiften Klammern in eine Menge PrimSet um. Überprüfen Sie die Typen 

von PrimList und PrimSet mit whattype. 

c) Erzeugen Sie eine Menge M, die die zweite, vierte,...,hundertste Primzahl enthält. 

Lassen Sie sich die Differenzmenge von PrimSet und M anzeigen. 

6 Die Befehle vector und matrix 

Die Befehle vector und matrix gehören zum Paket linalg. Man muss dieses Paket also 

mit with(linalg): laden, bevor man mit diesen Befehlen arbeitet (oder man benutzt die 

lange Befehlsform a la linalg[vector], was aber umständlich ist). 

6.1 Initialisierung von Vektoren und Matrizen 

Befehl 

v:=vector([1,2,3]); 

v[2]; 

v[1]:=100; 

M:=matrix([[1,2,3],[4,5,6]]); 

M:=matrix(2,3,[1,2,3,4,5,6]); 

M[1,1]:=234; 

Erläuterung 

Erzeugen eines Vektors 

Auswerten des 2. Eintrags 

Setzen des 1. Eintrags 

Erzeugung einer 2x3-Matrix 

Erzeugt die gleiche Matrix 

Setzen des (1,1)-Eintrags 

Aufgabe 6.1 Initialisieren Sie eine 10x10-Matrix M = (m ij ), wobei m ij = ij 2 . 

Hinweise: Laden Sie zunächst das Paket linalg. Deklarieren Sie die Matrix mit M:=matrix(10,10); 

Weisen Sie die Einträge mit einer doppelten for-Schleife zu: 

for i from 1 to 10 do 

for j from 1 to 10 do 

M[i,j]:=i*jˆ2: od: od: 

Das Ergebnis kann man mit evalm(M); überprüfen. 

5

6.2 Rechnen mit Matrizen und Vektoren 

Zunächst ein Experiment, das zeigt, wie es nicht geht: 

Befehl 

Kommentar 

v:=vector([1,1]); w:=vector([2,2]); Erzeugung von Vektoren 

v; Versuch einer Auswertung, schlägt fehl 

v+w; 

Versuch einer Addition, schlägt fehl 

Vektoren und Matrizen streuben sich gegen Auswertungen, und daher muss man den speziellen 

Auswertungsbefehl evalm einsetzen. 

Wichtig: Der Operator für Matrizenmultiplikation und Matrix-Vektor-Multiplikation ist 

&* und nicht einfach *. 

Befehl 

M:=matrix([[1,2],[2,3]]); 

N:=matrix([[1,2],[0,0]]); 

evalm(M); 

A:=evalm(M+N); 

B:=evalm(3*M); 

C:=M*N; 

C:=evalm(M&*N); 

D:=evalm(Mˆ5); 

v:=vector([1,9]); 

w:=evalm(M&*v); 

E:=transpose(M); 

F:=inverse(M); 

Erläuterung 

Erzeugen von Matrizen 

Auswerten einer Matrix 

Summe von Matrizen 

Matrix mal Skalar 

Falsch! 

Matrizenprodukt 

Matrizenpotenzierung 

Erzeugung eines Vektors 

Matrix-Vektor-Produkt 

transponierte Matrix 

Inverse 

Aufgabe 6.2 Die Cholesky-Faktorisierung einer quadratischen Matrix A ist eine Darstellung 

A = RR t , wobei R eine untere Dreiecksmatrix ist. 

a) Erzeugen Sie die Matrix 

⎛ 

4 −6 68 

⎞ 

M := ⎝−6 8658 −1032⎠ 

68 −1032 1265 

b) Berechnen Sie mit R:=cholesky(M); die Cholesky-Faktorisierung von M. 

c) Überprüfen Sie, ob tatsächlich RR t = M gilt. 

6



Einführung in Maple: 2. Arbeitsblatt 

Die Maple-Programmiersprache und 

Prozeduren 

1 Kontrollstrukturen 

Die wichtigsten Kontrollstrukturen in Maple sind for- und while-Schleifen sowie if-else- 

Verzweigungen. 

1.1 for-Schleifen 



print(iˆ2); 

od; 

for i from 1 to 10 by 2 do 


od; 

for i from 1 to 10 

while iˆ3 < 500 do 


od; 

M:={1,5,8,10,12}; 

for x in M do 

print(2*x-4); 

od; 

Erläuterung 

Die Variable i wird von 1 bis 10 hochgezählt 

und für jeden Wert wird das Quadrat ausgegeben. 

Wichtig: Die Schleifenanweisungen müssen durch 

do ... od; eingeschlossen werden. 

Wie oben, wegen by 2 wird jetzt jedoch in Zweierstatt 

in Einerschritten hochgezählt. 

Wie oben, allerdings mit einer Abbruchbedingung. 

Die Schleife wird vollständig abgebrochen, sobald 

die Bedingung nicht mehr erfüllt ist. 

Die for-Schleife iteriert hier über eine Menge. Für 

jedes Element x der Menge wird 2x-4 ausgegeben. 

Aufgabe 1.1 a) Berechnen Sie mit einer for-Schleife die Dezimaldarstellung von ∫ 1 

0 sin(x)i dx 

für i = 1, 2, ..., 10. 

Notwendige Befehle: int, evalf. Mit ?int; können Sie die Hilfe zur Integrals-Funktion 

aufrufen. 

b) Schreiben Sie eine for-Schleife, die für i = 1, ..., 10 die Zahl 2 2i + 1 ausgibt und sofort 

abbricht, falls diese Zahl keine Primzahl ist. 

Notwendige Befehle: while, isprime. 

1

c) Schreiben Sie eine for-Schleife unter Verwendung von by, die jede 20. Primzahl < 1000 

ausggibt. 

Notwendige Befehle: while, ithprime. 

d) Erzeugen Sie eine Menge M, die 10 ganzzahlige Zufallszahlen aus dem Intervall [2, 101] 

enthält. Testen Sie mit einer for-Schleife über M, welche Elemente von M Primzahlen 

sind. 

Notwendige Befehle: seq, rand(2..101)() 

1.2 while-Schleifen 

while-Schleifen führen Anweisungen aus bis eine Abbruchbedingung erfüllt ist. Innerhalb 

der Anweisungen muss man sicherstellen, dass die Abbruchbedingung wirklich irgendwann 

erfüllt wird, ansonsten hat man eine Endlosschleife. 


i:=10; 

while i< 20 do 

i:=i+2; 

print(i); 

od; 

Erläuterung 

i wird solange um 2 hochgezählt und ausgegeben 

bis der Wert 20 erreicht ist. 

Aufgabe 1.2 Schreiben Sie eine while-Schleife, die i beginnend mit 1 in jedem Schritt 

um eins hochzählt und abbricht, falls 7*i+1 eine Primzahl ist. 

1.3 if-else-Verzweigungen 

if-else-Verzweigungen dienen dazu, den Programmverlauf durch Bedingungen zu steuern. 


p:=ithprime(100); 

if p< 1000 then 

print(”p ist klein”); 

fi; 

p:=ithprime(100); 

if p< 1000 then 

print(”p ist klein”); 

else 

print(”p ist gross”); 

fi; 

Erläuterung 

Es wird getest, ob die hundertste Primzahl kleiner 

als 1000 ist und eine Ausgabe-Anweisung wird genau 

dann ausgeführt, wenn dies der Fall ist. Die 

if-Verzweigung wird durch if ... then ... fi; umschlossen, 

wobei kein Teil weggelassen werden darf. 

Wie oben, nur mit else-Alternative. Die Anweisung 

nach else wird genau dann ausgeführt, wenn 

die if-Bedingung nicht erfüllt ist. 

Aufgabe 1.3 Schreiben Sie eine for-Schleife über i=990,991,...,1010, die i ausgibt, 

falls i eine Primzahl ist und andernfalls die Teilermenge von i ausgibt. 

Notwendige Befehle: isprime, numtheory[divisors] 

2

2 Logische Ausdrücke 

In while- und if-Bedingungen werden logische Ausdrücke getestet. Logische Ausdrücke 

erzeugt man mit Funktionen oder Operatoren mit Rückgabetyp bool. Beispiele: 

isprime (Funktion), =, < , >, < =, >= (Vergleichsoperatoren) 

Verknüpfung logischer Ausdrücke 

Die Verknüpfung logischer Ausdrücke erfolgt mit den Operatoren and, or, not sowie 

runden Klammern zum Zusammenfassen. Beispiel: 

a:5; b:=6; c:=7; 

if ((a< b) and (b< c)) or (not isprime(a)) then 

print(a,b,c); 

fi; 

Aufgabe 2.1 Schreiben Sie eine for-Schleife über i=1,2,...,100, die i genau dann ausgibt, 

wenn 

(a) i keine Primzahl oder iˆ2 größer als 500 ist und 

(b) i mod 20 gleich 3, 5 oder 18 ist. 

3 Prozeduren 

Für wiederkehrende Aufgaben kann man in Maple Prozeduren schreiben. Bei Bedarf kann 

man Prozeduren als Textdateien speichern und in anderen Maple-Sitzungen wiederverwenden. 

Eine Prozedur P wird erzeugt in der Form 

Erläuterungen: 

P:=proc(Parameter) Anweisungen end; 

• Die Parameter bestehen aus einer Folge von Variablen, deren Werte beim Aufruf 

an die Prozedur übergeben werden müssen. Prozeduren mit keinen Parametern sind 

erlaubt. 

• Die Anweisungen sind eine beliebige Folge von Maple-Befehlen, meist unter Verwendung 

von Kontrollstrukturen. 


P:=proc(a,b) 

return a+b; 

end; 

P(5,20); 

Erläuterung 

Prozedur mit zwei Parametern, die die Summe der 

Parameter zurückgibt. 

Aufruf der Prozedur. Für a wird der Wert 5 und 

für b wird der Wert 20 übergeben. Rückgabe ist 

25. 

3

Aufgabe 3.1 Schreiben Sie eine Prozedur Concat:=proc(L1,L2), die zwei Listen L1 

und L1 aneinanderhängt. Bei A:=[1,2]: B:=[3,4]: soll Concat(A,B); zum Beispiel die 

Ausgabe [1,2,3,4] ergeben. 

Notwendige Befehle: proc...end; op. Zwei Folgen F1, F2 kann man einfach mit F1,F2; 

aneinanderhängen. 

Aufgabe 3.2 Schreiben Sie eine Prozedur Zufall:=proc(n), die n Zufallszahlen im Bereich 

0,1,...,100 erzeugt und deren Mittelwert und Varianz berechnet. Die Rückgabe soll 

die Liste [M,V] sein, wobei M und V als Kommazahlen ausgegeben werden sollen. 

Notwendige Befehle: 

rand(0..100)(), seq, stats[describe,mean], stats[describe,variance] 

Aufgabe 3.3 Schreiben Sie eine Prozedur SumAll:=proc(A), die die Summe aller Einträge 

einer Matrix A zurückgibt. 

Notwendige Befehle: with(linalg); rowdim, coldim, sum 

Aufgabe 3.4 Bestimmung der Fäche des Einheitskreises ohne Kenntnis von π 

Das in den Einheitskreis eingeschriebene regelmäßige n-Eck hat die Fläche 

Es gilt sin(π/2) = 1 und 

F (n) = (n/2) sin(2π/n). 

für 0 ≤ x ≤ π/2 (Winkelhalbierungsformel). 

sin(x/2) = 

√ 

1 

2 (1 − √ 1 − sin(x) 2 ) 

a) Berechnen Sie in einer for-Schleife die Dezimaldarstellungen von p i := sin(π/2 i ) für 

i = 1, ..., 20. 

Hinweis: Es gilt p 1 = sin(π/2) = 1. Den Wert von p 2 erhält man als Ausdruck in p 1 mit 

Hilfe der Winkelhalbierungsformel. Allgemein erhält man p i+1 als Ausdruck in p i mit Hilfe 

dieser Formel. 

b) Erhöhen Sie die Rechengenauigkeit mit Digits:=20; und wiederholen Sie die Berechung 

aus Teil a. 

c) Das in den Einheitskreis eingeschriebene regelmäßige 2 i -Eck hat die Fläche F (2 i ) = 

2 i−1 p i−1 . Schreiben Sie eine Prozedur Flaeche:=proc(i), die die Fläche F (2 i ) berechnet. 

d) F (2 i ) konvergiert gegen π für i → ∞. Überprüfen Sie dies durch Berechung von F (2 i ) 

für i = 3, ..., 20. 

4




1 Lösung von Gleichungssystemen 

Der Grundbefehl zur Lösung von Gleichungssystemen ist solve. Syntax: 

solve(Gln, Var); 

Dabei ist Gln eine Menge von Gleichungen, und Var ist eine Menge von Variablen, 

nach denen aufgelöst werden soll (optional). Standardardmäßig wird nach allen Variablen 

aufgelöst. Die Ausgabe ist eine Folge von Mengen, von denen jede eine Lösung enthält. 

Bei Eingabe von L:=solve(Gln, Var); kann man auf die i-te Lösung mit L[i] zugreifen. 

Eine Probe der i-ten Lösung ist mit subs(L[i],Gln); möglich. Beispiele: 

Befehl 

Gln:= {xˆ2=4}; 

L:=solve(Gln); 

subs(L[1],Gln); subs(L[2],Gln); 

solve({x+y=4}, {x}); 

Kommentar 

Definition der Gleichungen 

Lösungen werden berechnet 

Probe 

Gleichung wird nach x aufgelöst 

Es stellt sich sofort die Frage, wie man auf die einzelnen Werte der Lösungen zugreifen 

kann, da diese ja zum Beispiel in der Form {x=5, y=7, z=10} ausgegeben werden. Das 

geht wieder am besten mit dem Befehl subs: 

Eingabe 

Ausgabe 

L := solve({x + y = 4, x − y = 2}); L := {x = 3, y = 1} 

L1 := subs(L, [x, y]); L1 := [3, 1] 

K := solve({xˆ2 = 4}); K := {x = 2}, {x = −2} 

K1 := subs(K[1], [x]); K1 := [2] 

Oft zeigt Maple Lösungen unter Verwendung von RootOf an, so dass diese Lösungen 

zunächst unausgewertet bleiben. Die explizite Ausgabe der Lösungen erzwingt man mit 

dem Befehl allvalues: 

Befehl 

Gln:= {xˆ2+y=0, x-2∗y=2}; 

L:=solve(Gln); 

allvalues(L); 

Kommentar 

Lösungen enthalten RootOf 

Explizite Ausgabe 

1

Aufgabe 1.1 Lösen Sie das Gleichungssystem 

x 2 + 2y + z = 4 

x + y + z = 2 

x + y = 0. 

Lassen Sie sich mit allvalues die zwei Lösungen explizit ausgeben. Führen Sie eine Probe 

der Lösungen durch. Extrahieren Sie die Werte von x,y,z mit dem Befehl subs aus den 

einzelnen Lösungen und schreiben Sie diese in Listen der Form [x,y,z]. 

2 Numerisches Lösen von Gleichungssystemen 

Mit dem Befehl solve will man in der Regel exakte Lösungen erhalten. Für komplizierte 

Gleichungssysteme ist das jedoch oft unmöglich und man muss auf numerische Lösungen 

zurückgreifen. Dafür steht der Befehl fsolve zur Verfügung. Die Syntax von fsolve ist wie 

die von solve, nur dass man noch Optionen hat wie x=0..1 (Einschränkung der Variablen 

x auf das Intervall [0,1]) oder complex (erzwingt Ausgabe nicht-reller Lösungen). 

Beispiele: fsolve(xˆ4+1=0, {x}, complex); 

fsolve(tan(x)=0, {x}, x=0..10); 

Wichtig: fsolve findet i.a. keineswegs alle Lösungen, sondern liefert nur irgendeine Lösung. 

Wenn fsolve keine Lösung findet, kann man noch nicht sicher sein, dass keine Lösung 

existiert. Ob man alle Lösungen gefunden hat, kann man manchmal durch Plotten der 

involvierten Funktionen überprüfen. 

Aufgabe 2.1 Finden Sie mit Hilfe von fsolve und plot alle Nullstellen von sin x und 

von e cos x − log(2 + sin x) im Intervall [0,10]. 

Aufgabe 2.2 Bestimmen Sie mit fsolve alle (auch komplexe) Nullstellen von f = x 64 + 

39x 49 + 20x 20 + 14x 5 + 2304 und bestimmen Sie die Anzahl dieser Nullstellen mit Hilfe 

von nops. Hinweis: nops lässt sich auf Listen anwenden, nicht aber auf Folgen. 

3 isolve, msolve, rsolve 

Aufgabe 3.1 Informieren Sie sich über die Befehle isolve, msolve, rsolve und lösen 

Sie folgende Probleme: 

a) Bestimmen Sie sie alle ganzzahligen Lösungen von x 2 + y 2 = t für t = 100, 1000, 10000. 

b) Betimmen Sie alle Lösungen mod m von x 2 + y 2 + z 2 = 7 für m = 50, ..., 60. 

c) Die Fibonacci-Folge (f i ) ist definiert durch f 1 = 1, f 2 = 1 und f i+1 = f i + f i−1 für 

i ≥ 2. Finden Sie mit rsolve eine explizite Formel für f i . Berechnen Sie mit Hilfe dieser 

Formel f 1000 . 

2

4 Lineare Gleichungssysteme 

Wir betrachten ein lineares Gleichungssystem Ax = b, wobei A eine m × n-Matrix und 

b ∈ R m ist. Zur Lösung eines solchen Gleichungssystems steht im Paket linalg der Befehl 

linsolve(A,b) zur Verfügung. Dabei sollte A vom Typ matrix und b vom Typ vector 

sein. Die Ausgabe ist ein ein Lösungsvektor oder nichts (NULL), falls keine Lösung 

existiert. Ist die Lösungsmenge ein affiner Unterraum mit einer Dimension ≥ 1, so enthält 

der Lösungsvektor freie Parameter t i . Beispiel: 

Befehl 

with(linalg): 

A:=matrix(2,2,[1,1,1,-1]); b:=vector([3,5]); 

linsolve(A,b); 

Kommentar 

Laden des Pakets linalg 

Initialisieren von A und b 

Ax=b wird gelöst 

Aufgabe 4.1 Lösen Sie Ax = b, wobei A = (A[i, j]) i,j=1,...,10 mit A[i, j] = j i−1 und 

b[i] = i 2 , i = 1, ..., 10. 

Hinweis: Initialisieren Sie A mit A:=matrix(10,10) und weisen die Werte A[i,j] mit 

Hilfe einer for-Schleife zu. 

Aufgabe 4.2 

a) Erzeugen Sie mit dem Befehl randmatrix eine 30x30-Zufallsmatrix A und einen Zufallsvektor 

b mit 30 Komponenten und lösen Sie Ax = b. 

b) Beachten Sie, dass die Lösung in a) in Form von Brüchen exakt ausgegeben wird. 

Vielleicht kann man die Rechenzeit verkürzen, wenn man vor dem Aufruf von linsolve 

alle Einträge von A in Kommazahlen umwandelt und Maple somit zum Rechnen mit 

Kommazahlen zwingt?! Tun Sie das und vergleichen Sie die Rechenzeiten. 

Notwendige Befehle: f:= x->convert(x,float); map(f,A); time(); 

(Aufruf von time(); gibt die bis zu diesem Zeitpunkt verbrauchte CPU-Zeit an) 

Zum Lösen eines homogenen linearen Gleichungssystems Ax = 0 ist der Befehl kernel(A); 

besser geeignet als linsolve. Die Ausgabe von kernel(A); ist eine Basis für den 

Kern von A (das ist der Unterraum aller x mit Ax = 0). 

Aufgabe 4.3 Bestimmen Sie den Kern der Matrix 

⎛ 

⎞ 

1 2 −4 2 −1 

0 1 −2 1 0 

⎜ 3 −5 6 −5 1 

⎟ 

⎝ −2 4 −3 4 −3 ⎠ 

−5 2 0 2 1 

3

5 Determinanten und Eigenwerte 

Zur Berechnung von Determinaten steht im Paket linalg der Befehl det zur Verfügung. 

Aufgabe 5.1 Determinanten von 40x40-Matrizen mit ganzzahligen Einträgen sind für 

Maple kein Problem. Überprüfen Sie das an einer Zufallsmatrix. 

Die Eigenwerte einer quadratischen Matrix A kann man mit dem Befehl eigenvals(A); 

berechnen. Hierbei muss man auf die Typen der Einträge achten: 

• Ist ein Eintrag von A vom Typ float, so müssen alle Einträge vom Typ float sein. 

In diesem Fall werden die Eigenwerte in Dezimalnäherung ausgegeben. 

• Sind alle Einträge von A ganze Zahlen, Brüche oder Variablen (der symbolische 

Fall), so werden die Eigenwerte exakt berechnet und gegebenenfalls unter Verwendung 

von RootOf ausgegeben. Die einzelnen Eigenwerte erhält man dann mit Hilfe 

von allvalues. 

Aufgabe 5.2 

a) Berechnen Sie die Eigenwerte einer 10x10 Zufallsmatrix mit ganzzahligen Einträgen. 

Lassen Sie sich mit evalf die numerischen Werte der Eigenwerte ausgeben. 

b) Überprüfen Sie, ob das Produkt der in a) berechneten Eigenwerte gleich der Determinante 

der Matrix ist. Dafür muss man wahrscheinlich die Rechengenauigkeit mit Digits:=t; 

für geeignetes t erhöhen. 

4



Organisatorischer Hinweis: 

Der Maple-Kurs findet ab dem 27. Mai im Mac-CIP-Pool, Raum 1012/1013 statt 


Erzeugen und Exportieren von Graphiken 

1 Der Befehl plot 

Der Grundbefehl zur Erzeugung einer graphischen Darstellung einer Funktion f(x) ist 

plot. Dabei kann f ein Ausdruck in x, eine mit x->f(x) definierte Funktion oder auch 

eine Prozedur sein. Als Optionen können der darzustellende x- bzw. y-Bereich angegeben 

werden. Beispiele: 

Befehl 

Kommentar 

plot(sin); 

Plot der Sinusfunktion, x-y-Bereiche Standard 

plot(sin(x),x=0..2,y=0..1); Plot mit Vorgabe der Bereiche 

plot(sin(x)/x,x=0..infinity); Plot über “unendlichen Bereich” 

f:=x->sin(x)ˆ3∗xˆ4; 

Erzeugung einer Funktion f 

plot(f, 0..1); Plotten der Funktion f(x) für x ∈ [0, 1] 

P:=proc(x) return xˆ3; end; Erzeugung einer Prozedur P 

plot(P,0..3); Plotten von P(x) für x ∈ [0, 3] 

Plots kann man auch Namen geben und sie dann mit dem Befehl display einzeln oder 

gemeinsam anzeigen lassen: 

Befehl 

p1:=plot(sin): p2:=plot(sin(x),x=0..2,y=0..1): 

with(plots): display([p1,p2]); 

Kommentar 

Plots p1, p2 in einer Graphik 

Aufgabe 1.1 

a) Plotten sie tan x so, dass man die Nullstellen im Bereich [0, 10] einigermassen genau 

erkennen kann. Hinweis: Wählen Sie den y-Bereich geeignet. 

b) Plotten Sie den Einheitskreis, indem Sie ihn mit display aus je einem Teil für den 

unteren und oberen Halbkreis zusammensetzen. Hinweise: Die nötigen Funktionen sind 

± √ 1 − x 2 . Mit der Option scaling=constrained in plot kann man die Verzerrung beseitigen. 

c) Erzeugen Sie eine Prozedur P, so dass P(x) den Wert -1 liefert für x ≤ 0 und 

sin(x) für x > 0. Plotten Sie die Prozedur im Bereich x ∈ [−5, 5]. Notwendige Befehle: 

proc(x)...end; if...then...else...fi; return x; Hinweis: Das Plotten funktioniert 

nur mit plot(P,-5..5);, nicht mit plot(P(x),x=-5..5);

2 Exportieren von Graphiken 

Oft ist es nützlich, Maple-Graphiken in andere Dokumente einbinden zu können, z.B. in 

Seminarausarbeitungen oder Diplomarbeiten. Da mathematische Texte fast ausschließlich 

mit dem Textverbeitungsprogramm latex geschrieben werden, konzentrieren wir uns auf 

die Einbindung in latex-Dokumente. 

Aufgabe 2.1 a) Plotten Sie den Betrag der Riemannschen Zetafunktion im Bereich {1/2+ 

it : 0 ≤ t ≤ 100} mit plot(abs(Zeta(1/2+t*I)),t=0..100);. 

b) Rechter Mausklick auf Plot der Zetafunktion, → ExportAs → EncapsulatedPostscript, 

Speichern als zeta.eps. 

c) Downloaden Sie die Datei zeta.tex von der Homepage dieses Kurses. Die Datei zeta.tex 

enthält eine kurze Beschreibung der Riemann-Hypothese im latex-Format. Sehen Sie sich 

an, wie dort die Datei zeta.eps eingebunden wird. Das Ergebnis der latex-Kompilierung 

finden Sie in der Datei latex.pdf. 

Hinweis: Mit dem Programm latex sollte man sich so früh wie möglich vertraut machen. 

Ein hervorragendes Buch dazu ist Latex, Eine Einführung von Helmut Kopka. 

3 Parametrische Plots 

Statt den Einheitskreis aus zwei Stücken zusammenzusetzen, kann man ihn einfacher als 

parametrischen Plot erzeugen. Die Syntax für parametrische 2D-Plots lautet 

plot([A(t),B(t),t=a..b]); 

Dabei sind A(t) und B(t) Ausdrücke in t. Geplottet wird die Kurve [A(t), B(t)], t ∈ [a, b]. 

Den Einheitskreis erhält man folgendermaßen: 

plot([cos(t),sin(t),t=0..2*Pi]); 

Aufgabe 3.1 Plotten Sie eine Spirale im R 2 um den Nullpunkt mit 5 Windungen. 

Hinweis: Man kann zum Beispiel den Einheitkreis mehrmals durchlaufen und die Punkte 

mit einem monoton wachsenden Streckungsfaktor (z.B. t) multiplizieren. 

4 Dreidimensionale Graphiken mit plot3d 

Eine Funktion f(x, y) lässt sich als Fläche im R 3 darstellen. Der entsprechende Plot wird 

mit 

plot3d(f(x,y), x=a..b,y=c..d); 

erzeugt, wobei a,b,c,d zu spezifizierende Bereichsgrenzen sind. Beispiel: 

plot3d(sin(x*y), x=0..4,y=0..4); 

Durch klicken mit der linken Maustaste auf das Bild kann man die Zeichnung nach belieben 

rotieren. Verfeinern oder vergröbern kann man die Darstellung mit Hilfe der Option 

grid=[m,n], die den x- bzw. y-Bereich in m bzw. n Teile rastert. Beispiel: 

plot3d(sin(x*y), x=0..4,y=0..4, grid=[50,50]); 

Auch parametrische 3D-Plots sind möglich. Beispiel: 

plot3d([sin(s), cos(s)*sin(t),sin(t)], s=-Pi..Pi, t=-Pi..Pi);

Aufgabe 4.1 Erzeugen Sie einen parametrischen Plot der Einheitskugel im R 3 . Hinweis: 

Ist R = (x, y, z) ein Punkt auf der Einheitskugel, so gilt x = sin t cos s, y = sin t sin s und 

z = cos t. Dabei ist s der Winkel zwischen der x-Achse und der Projektion von R auf die 

x-y-Ebene und t ist der Winkel zwischen z-Achse und R. 

5 Darstellung der Mandelbrotmenge 

Mit Maple kann man fraktale Mengen ansprechend graphisch darstellen. Eine fraktale 

Menge M hat die Eigenschaft, dass unendlich viele beliebig kleine Teile von M der Gesamtmenge 

ähnlich sehen (Selbstähnlichkeit). Eine der bekanntesten fraktalen Mengen ist 

die Mandelbrotmenge in der komplexen Zahlenebene. 

Definition der Mandelbrotmenge 

Zu jedem c ∈ C wird eine Folge (a n (c)) definiert durch a 1 (c) = c und a n+1 (c) = a n (c) 2 + c 

für n ≥ 1. Die Mandelbrotmenge ist definiert als 

M := {c ∈ C : |a n (c)| ≤ 2 ∀ n ∈ N}. 

Um mit Maple zu prüfen, ob c ∈ M ist, kann man natürlich nicht die unendlich vielen 

Bedingungen |a n (c)| ≤ 2 testen. Statt dessen testet man diese Bedingung z.B. nur für alle 

n ≤ 20. Bei positiven Ausgang wird c in die Menge aufgenommen, ansonsten nicht. Das 

liefert eine sehr gute Approximation der Mandelbrotmenge. 

Aufgabe 5.1 

a) Schreiben Sie eine Prozedur P:=proc(x,y), so dass P(x,y) den Wert 1 liefert, falls 

|a n (x + I ∗ y)| ≤ 2 für alle n ≤ 20. Ansonsten soll die Prozedur 0 liefern. 

b) Plotten Sie die Mandelbrotmenge mit dem Befehl 

plot3d(P, -2..2, -2.. 2, grid=[50, 50]); 

Dabei ist P die Prozedur aus Teil a. Sehen Sie sich durch Änderung der grid-Werte 

verschiedene Verfeinerungsstufen an. 

c) Sehen Sie sich immer kleinere Bereiche der Mandelbrotmenge an und versuchen Sie, ihre 

Selbstähnlichkeit zu bestätigen. Ein interessanter Bereich ist zum Beispiel -0.06..-0.03, 

-1.. -0.98.

6 Graphische Animationen 

Zur Animation von Graphiken stehen im Paket plots die Befehle animate und animate3d 

zur Verfügung. Syntax: 

animate(F(x,t),x=a..b,t=c..d,frames=n); 

Dabei ist F(x,t) die darzustellende Funktion oder eine Menge solcher Funktionen. x=a..b 

gibt den x-Bereich an. Der für die Animation zuständige Parameter ist t (kann man sich 

als Zeitparameter vorstellen). Maple erzeugt für n Werte von t im angegeben Bereich je 

ein Bild. Die Ausgabe ist eine Folge von n Bildern, die man sich wie einen Film ansehen 

kann. Beispiel: 

animate(exp(-t∗x)∗sin(x),x=0..5,t=0..5); 

Um die Animation zu starten, klickt man erst auf die Graphik und dann auf den Rechtspfeil 

in der neu erscheinenden zweiten Werkzeugleiste oben. Analog funktioniert animate3d: 

animate3d(F(x,y,t), x=a..b, y=c..d,t=e..f); 

Hier ist F die darzustellende Funktion oder eine Menge solcher Funktionen. F kann 

reellwertig sein, kann aber auch Werte im R 3 annehmen. Will man Verzerrungen aufgrund 

automatischer Skalierungen der Achsen vermeiden, muss man als Option scaling=constrained 

eingeben. Beispiel einer Kugel vom Radius 1, die sich um 10 Einheiten 

entlang der x-Achse bewegt: 

Kugel:=[sin(t)∗cos(s)+u, sin(t)∗sin(s),cos(t)]: 

animate3d(Kugel,s=0..2∗Pi,t=0..Pi,u=0..10,scaling=constrained); 

Aufgabe 6.1 Erzeugen Sie eine Animation zweier Kugeln vom Radius 1 im R 3 , von denen 

die erste im Ursprung ruht und die zweite sie im Abstand von 5 Einheiten in der x- 

y-Ebene umkreist. Hinweise: Die ruhende Kugel kann man aus obigem Beispiel ablesen 

(+u weglassen!). Die andere Kugel bringt man zum rotieren, indem man 5∗cos(u) zur x- 

Koordinate und 5∗sin(u) zur y-Koordinate addiert. Vergessen Sie nicht, das Paket plots 

mit with(plots): zu laden.




Analysis mit Maple 

1 Grenzwerte von Funktionen 

Für Berechnungen von Grenzwerten von Funktionen steht der Befehl limit zur Verfügung. 

Syntax: 

limit(f,x=a); 

Dabei ist f ein analytischer Ausdruck in der Variablen x. Es wird lim x→a f(x) berechnet. 

Ist f eine Funktion, so muss man f(x) statt f eingeben. Die Berechnung von linksseitigen/rechtsseitigen 

Grenzwerten erreicht man mit Hilfe der Optionen left/right. Beispiele: 

Befehl 

limit(xˆx,x=0); 

limit(abs(x)/x,x=0); 

limit(abs(x)/x,x=0,right); 

limit((2*xˆ3+4*xˆ2)/(7*xˆ3+12),x=infinity); 

f:=x->sin(x)/x; 

limit(f,x=0); 

limit(f(x),x=0); 

Aufgabe 1.1 Folgende Grenzwerte sollen bestimmt werden: 

lim 

x→0 

Kommentar 

Berechung von lim x→0 x x 

Ausgabe undefined, da 

lim x→0 |x|/x nicht existiert 

Rechtsseitiger Grenzwert 

Berechung von lim x→∞ 

Definition einer Funktion 

funktioniert nicht, f wird als 

Konstante interpretiert 

funktioniert 

|x|(e x − 1) sin 2 x 

(1 − cos x) 3/2 tan x , lim tan −3 (x − π/2) 

x→0+ |x|(e sin2 x − 1) , lim |x| cot −3 (1/x) 

x→∞ e sin2 1/x − 1 

2 Reihen und unendliche Produkte 

Vorbemerkung zu sum und product 

Bei der Verwendung des Befehls sum zur Summenbildung gibt es oft ärgerliche Fehler, 

wenn die Summationsvariable vorher schon einen Wert hatte. Beispiel: 

n:=1; sum(n,n=1..10); ⇒ Fehler! 

Diesen Fehlern geht man ein für alle mal aus dem Weg, indem man die Summationvariable 

und den zu summierenden Ausdruck in einfache Anführungszeichen setzt: 

n:=1; sum(’n’,’n’=1..10); ⇒ OK! 

Gleiches gilt für den Befehl product. 

Berechnung von Reihen und Produkten 

Zur Berechung einer Reihe ∑ ∞ 

n=1 

f(n) kann man folgendermaßen vorgehen: Man definiert 

sich mit p:=sum(’f(n)’,’n’=1..k); einen Ausdruck, der die Partialsummen beschreibt

und rechnet dann mit limit(p,k=infinity); den Grenzwert der Partialsummen, d.h. den 

Wert der Reihe aus. Beispiel: 

p:=sum(’1/nˆ2’,’n’=1..k); limit(p,k=infinity); 

In diesem Beispiel liefert Maple den exakten Wert π 2 /6. Analog kann man unendliche 

Produkte berechnen. Ist man nur an Dezimalnäherungen interessiert, so kann man die 

Befehle sum(’f(n)’,’n’=1..infinity); bzw. product(’f(n)’,’n’=1..infinity); verwenden 

und die Auswertung mit evalf erzwingen. Beispiel: 

p:=product(’(1+1/nˆ2)’,’n’=1..infinity); evalf(p); 

Häufig kann Maple jedoch keine vernünftige Dezimalnäherung berechnen und es wird kein 

Wert ausgegeben. Dann kann man Werte von Partialsummen bzw. Partialprodukten für 

möglichst große k als Näherungen nehmen. 

Aufgabe 2.1 Berechnen Sie Dezimalnäherungen für folgende Reihen und Produkte. Finden 

Sie auch die exakten Werte, falls möglich. 

∞∑ 

n=1 

1 + √ n 

n 2 , 

∞∑ 

n=1 

sin 2 n 

n 2 , 

∞∏ 

(1 − 1 

4n 2 ), 

n=1 

∞ ∏ 

n=1 

(1 − 9 

4n 2 ) 

Maple kann auch Reihen berechnen, die von Parametern abhängen: 

Aufgabe 2.2 Berechnen Sie S = ∑ ∞ 2z 

n=1 

. Überprüfen Sie durch Plots, dass für z ∉ Z 

z 2 −n 2 

1 

+ S − π cot πz = 0 

z 

gilt (das ist die sogenannte Partialbruchentwicklung des Kotangens). 

3 Differenzieren von Funktionen einer Variablen 

Ein Ausdruck f in x wird mit diff(f,x); differenziert. Um eine Funktion g zu differenzieren, 

muss man diff(g(x),x); eingeben. Man kann auch differenzieren, ohne die Funktionen zu 

spezifizieren. Gibt man zum Beispiel diff(f(x)/g(x),x); ein, ohne dass f und g vorher 

definiert wurden, erhält man als Ausgabe die Quotientenregel. Die n-te Ableitung von 

f erhält man durch diff(f(x),x$n);. Will man die Ableitung als Funktion und nicht als 

Ausdruck erhalten, kann man den Ableitungsoperator D benutzen. 

Für eine Funktion f: x->f(x) liefert D(f) die Funktion x->f’(x). Mit (D@@n)(f); berechnet 

man die n-te Ableitung von f als Funktion. Beispiele: 

Befehl 

f:=xˆ5; diff(f,x); 

f:=x->xˆ2; diff(f(x),x); 

diff(f,x$3); 

diff((h@g(x)),x); 

f:=x->sin(x); D(f); (D@@3)(f); 

Kommentar 

Differenzieren eines Ausdrucks 

Differenzieren einer Funktion 

3. Ableitung 

Kettenregel wird ausgeben (@ ist der 

Operator für die Verkettung) 

1. und 3. Ableitung werden als Funktionen 

ausgegeben

Aufgabe 3.1 Sei f = sin x 3 . Mit f (i) bezeichnen wir die i-te Ableitung von f. Berechnen 

sie 

10∑ f (j) (0)x j 

g := f(0) + 

j! 

j=1 

(Taylorentwicklung 10. Ordnung um 0). Plotten Sie f und g im Intervall [0, 3/2] in einer 

gemeinsamen Graphik. 

Hinweise: Man definiert am besten f als Funktion f:=x->sin(xˆ3);. Auch g sollte man als 

Funktion definieren. Den Wert f (j) (0) erhält man mit (D@@j)(f)(0). Den gemeinsamen 

Plot erhält man z.B. mit plot({f,g},0..3/2); 

4 Differenzieren von Funktionen mehrerer Variablen 

Beim Differenzieren von Funktionen mehrerer Variablen muss man mit Vektoren und Matrizen 

arbeiten und daher vorher das Paket linalg laden. Wichtige Befehle sind grad, 

jacobian, hessian. Beispiele: 

Befehl 


f:=xˆ2*sin(x*y)+x*exp(y+z); 

g:=grad(f,[x,y,z]); 

Kommentar 

Laden des Pakets linalg 

Definition eines Ausdrucks 

Gradient wird berechnet; die Variablen, nach denen 

differenziert wird, werden als Liste eingegeben 

Differenziert nur nach x und y 

Berechnung der Hesse-Matrix 

h:=grad(f,[x,y]); 

hessian(f,[x,y,z]); 

v:=vector([xˆ2*yˆ2,sin(x+y)]); Definition einer Funktion v : R 2 → R 2 

jacobian(v,[x,y]); 

Berechnung der Jacobi-Matrix 

Mit Hilfe von Gradienten und Hesse-Matrizen kann man nach lokalen Extrema von Funktionen 

suchen. Mit ∇f(x) bzw. H f (x) bezeichnet man den Gradienten bzw. die Hesse- 

Matrix von f am Punkt x. In der Analysis oder Optimierung beweist man folgenden Satz: 

Satz Sei f : R n → R zweimal differenzierbar. 

a) Ist x ein lokales Extremum von f, so gilt ∇f(x) = 0. 

b) Ist ∇f(x) = 0 und hat H f (x) nur positive (nur negative) Eigenwerte, so ist x ein lokales 

Minimum (Maximum) von f. 

Anwendungsbeispiel: 

Befehl 

Kommentar 

f:=xˆ4+xˆ2+yˆ2+6*y; 

Definition eines Ausdrucks 

g:=grad(f,[x,y]); 

Gradientenberechnung 

s:=solve({g[1]=0,g[2]=0}); Lösungen von ∇f = 0 

allvalues(s[2]); 

Auflösen von RootOf 

t:=subs(s[1],[x,y]); 

Zugreifen auf die (einzige reelle) Lösung 

H:=hessian(f,[x,y]); 

Berechnung der Hesse-Matrix von f 

Ht:=map(a->subs(x=t[1],y=t[2],a),H); Einsetzen des Lösungspunkts in Hesse-Matrix 

eigenvals(Ht); 

Alle Eigenwerte >0, lokales Minimum

Aufgabe 4.1 Suchen Sie nach lokalen Extrema folgender Funktionen. Hinweise: Bleiben 

unausgewertete Ausdrücke zwischendurch stehen, so wendet man evalf an. 

5 Integration 

f = x 2 + 2 xz + 2 x + y 2 − 2 yz − 2 y + 2 z 2 + 2 z + e (x+y−z)2 

h = −2 x 2 − 2 y 2 − 4 yz − 8 y − 3 z 2 − 2 z 

Bestimmte und unbestimmte Integrale berechnet man mit dem Befehl int. Auch uneigentliche 

Integrale kann man so auswerten. Zur Berechnung mehrdimensionaler Integrale 

iteriert man den Befehl int. Beispiele: 

Befehl 

int(xˆ5,x=0..1); 

int(sin(x)ˆ2*exp(x),x); 

int(1/xˆ2,x=1..infinity); 

int(int(int(x+y+z,x=0..1),y=0..1),z=0..1); 

Kommentar 

Bestimmtes Integral 

Unbestimmtes Integral 

Uneigentliches Integral 

Iteriertes Integral 

Aufgabe 5.1 Die Fläche von S ⊂ R 2 ist ∫ S 

1 dxdy. Berechnen Sie die Fläche der Ellipse 

E := {(x, y) : 3x 2 + y 2 ≤ 1}. 

Hinweise: Wählen Sie im äußeren Integral den y-Bereich y=-1..1. Der x-Bereich muss 

dann gemäß der Bedingung 3x 2 + y 2 ≤ 1 gewählt werden (Bedingung nach x auflösen, 

ergibt Bereich 

[− √ (1 − y 2 )/3, √ (1 − y 2 )/3]). Die Ellipse kann man übrigens am einfachsten plotten mit 

implicitplot(3*xˆ2+yˆ2=1,x=-1..1,y=-1..1,scaling=constrained); 

6 Koordinatentransformationen, Jacobideterminanten 

Zur Vereinfachung von Integralen sind Koordinatentransformationen oft unerläßlich. Betrachten 

wir als Beispiel ein Integral über die Einheitskugel K im R 3 : 

∫ 

V := f(x, y, z)dxdydz 

K 

Um V zu berechnen, muss das Integral in ein iteriertes Integral umgewandelt werden. Das 

macht aber wegen der komplizierten Integrationsgrenzen bei einer Kugel im x-y-z-System 

Mühe. Daher substituiert man die Kugelkoordinaten x(r, s, t) = r sin t cos s, y(r, s, t) = 

r sin t sin s, z(r, s, t) = r cos t und berechnet das Integral gemäß der Formel 

∫ 

∫ π ∫ 2π ∫ 1 

f(x, y, z)dxdydz = 

f(x(r, s, t), y(r, s, t), z(r, s, t))|J(r, s, t)|drdsdt (1) 

K 

0 

0 

0 

Dabei ist |J(r, s, t)| der Betrag der Jacobideterminante der Transformation 

(r, s, t) ↦→ (x(r, s, t), y(r, s, t), z(r, s, t)). 

Diese Determinante lässt sich mit dem Befehl jacobian berechnen: 

Befehl 

xyz:=vector([r*sin(t)*cos(s),r*sin(t)*sin(s),r*cos(t)]); 

J:=det(jacobian(xyz,[r,s,t])); 

J1:=simplify(abs(J)); 

Kommentar 

Transformation 

Jacobideterminante 

Ergebnis: sin(t)rˆ2

Das Volumen der Einheitskugel ist also nach der Formal (1) zum Beispiel 

∫ 

K 

1 dxdydz = 

∫ π ∫ 2π ∫ 1 

0 

0 

0 

sin(t)r 2 drdsdt = 4π 3 . 

Aufgabe 6.1 Zylinderkoordinaten im R 3 sind gegeben durch x = r cos s, y = r sin s, 

z = z. Berechnen Sie die Jacobideterminante dieser Transformation. 

Aufgabe 6.2 Das Trägheitsmoment von S ⊂ R 3 bzgl. der z-Achse ist 

∫ 

(x 2 + y 2 )ρ(x, y, z)dxdydz, 

S 

wobei ρ(x, y, z) die Dichte des Körpers S in (x, y, z) ist. Berechnen Sie mit Hilfe von (1) 

das Trägheitsmoment der Einheitskugel mit Dichte 1.




1 Schreiben in Dateien 

Input und Output 

Nach umfangreichen Rechnungen hat man unter Umständen ein ellenlanges Maple-Arbeitsblatt 

mit größtenteils irrelevanten Informationen vor sich. Dann kann man sich helfen, 

indem man die interessanten Daten extrahiert und in eine Datei schreibt. 

Wichtig: Ein Pfadname für eine Datei sieht in Maple zum Beipiel folgendermaßen aus: 

”C:\\test.txt”. Der Pfadname ist also in Anführungszeichen zu setzen. 

Die wichtigsten Befehle für das Schreiben in Dateien sind open, writeline, writedata, 

close. Der Befehl writedata ist besonders für numerische Werte geeignet, da man damit 

durch einen einzigen Befehl eine ganze Matrix mit Integer- oder Float-Einträgen in eine 

Datei schreiben kann. 

Achtung: Existiert eine Datei schon, wird sie durch diese Befehle überschrieben. 

Befehl 

open(”test.txt”,WRITE); 

writeline(”test.txt”,”1028340”); 

writeline(”test.txt”, 

convert(ithprime(30),string)); 

close(”test.txt”); 

writedata(”test.txt”, 

[[1,2,3],[1,3,5]]); 


A:=matrix([[1,2,3],[1,3,5]]); 

writedata(”test.txt”,A); 

Kommentar 

Datei test.txt wird zum Schreiben geöffnet, 

und zwar in dem Verzeichnis, von 

dem aus Maple gestartet wurde. Will man 

test.txt in einem anderen Verzeichnis 

speichern, so muss man den Pfadnamen 

angeben, z.B. 

open(”C:\\test.txt”,WRITE); 

Schreiben von Strings in die Datei 

test.txt. Da writeline nur Strings schreiben 

kann, müssen Zahlen vor dem Schreiben 

in Strings umgewandelt werden. 

Schließen der Datei test.txt. Ohne das 

Schließen kann es zu Fehlern kommen. 

Liste von Listen wird in test.txt geschrieben. 

Dabei werden nur die Einträge geschrieben, 

nicht die Kommas und Klammern. 

Dies kann man durch Öffnen von 

test.txt in einem Texteditor überprüfen. 

Definition einer Matrix 

Matrix wird in test.txt geschrieben

Aufgabe 1.1 a) Schreiben Sie mit writeline die ersten 100 Primzahlen zeilenweise in 

eine Datei primzahlen.txt. Öffnen Sie die Datei zur Kontrolle in einem Texteditor. Notwendige 

Befehle: for-Schleife, ithprime, open, close, convert(..,string) 

b) Erzeugen Sie eine 30x30-Zufallsmatrix und schreiben Sie ihre Einträge mit writedata 

eine Datei matrix.txt. Überprüfen Sie das Ergebnis mit einem Texteditor. Notwendige 

Befehle: with(linalg); randmatrix. 

2 Lesen aus Dateien 

Will man einen größeren Datensatz mit Maple bearbeiten, muss man die Daten aus Dateien 

lesen können. Dafür stehen vor allem die Befehle fscanf und readdata zur Verfügung. 

Der Befehl fscanf ist fast identisch mit dem gleichnamigen Befehl in der Programmiersprache 

C und auf beliebige Datenypen anwendbar. Der Befehl readdata ist anwendbar 

auf Textdateien, die Kommazahlen oder ganze Zahlen als Einträge haben. 

Rückgabe von readdata: 

readdata(”Datei”,n); liefert eine Liste von Listen, wobei die j-te Liste jeweils die ersten 

n Einträge der j-ten Zeile der Datei enthält. Will man alle Zeilen vollständig einlesen, so 

muss man also n groß genug wählen. 

Befehl 

Kommentar 

writedata(”test.txt”,[1,2,3]); Erzeugt Datei test.txt mit Einträgen 1 2 

3. 

a:=fscanf(”test.txt”, ”%d%d%d”); Lesen der drei Einträge von test.txt 

als Integers (%d). Zum Lesen von 

Strings/Floats schreibt man %s bzw. %f 

statt %d. Die Rückgabe ist eine Liste der 

zwei gelesenen Werte. 

readdata(”matrix.txt”,10); 

Zeilen der Datei matrix.txt (aus Aufgabe 

1.1.b) werden bis zum 10. Eintrag als 

Kommazahlen (Standard) eingelesen 

A:=readdata(”matrix.txt”,integer,30); Gesamtmatrix wird ganzzahlig eingelesen 

with(linalg): B:=matrix(A); 

Stellt die Ausgangsmatrix wieder her 

Aufgabe 2.1 a) Lesen Sie mit Hilfe von fscanf die 100 Primzahlen aus der Datei primzahlen.txt 

aus Aufgabe 1.1 in einem Vektor p ein. Verwenden Sie dazu eine for-Schleife 

und beachten Sie, dass die Rückgabe von fscanf eine Liste der gelesen Werte ist (Werte 

extrahieren mit op oder eckigen Klammern). Überprüfen Sie das Resultat mit evalm(p);. 

b) Downloaden Sie von der Homepage dieses Kurses die Datei floats.txt und lesen Sie 

die darin enthalten 100 float-Werte mit fscanf in einen Vektor f ein. 

Aufgabe 2.2 a) Downloaden Sie von der Homepage dieses Kurses die Dateien matrixA.txt 

und vektorb.txt. 

b) Lesen Sie die beiden Dateien mit readdata ganzzahlig in Maple ein. Hinweis: matrixA 

hat 10 Zeilen und 30 Spalten, vektorb hat 10 Zeilen und eine Spalte. 

c) Machen Sie aus matrixA eine Matrix A und aus vektorb einen Vektor b.

3 Ausflug in die lineare Optimierung 

Gerade haben wir eine Matrix A und einen Vektor b in Maple eingelesen. Jetzt soll das 

lineare Optimierungsproblem 

(LP ) 

max − 

30∑ 

i=1 

x i unter Ax = b, x ≥ 0 

mit Maple gelöst werden. In dem Paket simplex steht dafür der Befehl maximize zur 

Verfügung. Syntax: 

maximize(f,M,Option); 

Dabei ist f eine lineare Zielfunktion, hat also die Form f = ∑ n 

i=1 c ix i , wobei c i ∈ R 

Konstanten sind. M ist eine Menge von linearen Ungleichungen und Gleichungen, die die 

Restriktionen darstellen. Für ein Problem mit Nichtnegativitätsbedingung x ≥ 0 wählt 

man die Option NONNEGATIVE. Existiert keine Optimallösung, so gibt Maple nichts 

oder die leere Menge zurück. Beispiel für die Lösung eines Problems max f unter Ax = 

b, x ≥ 0: 

Befehl 

with(simplex): 

f:=-3*x[1]-x[2]; 

M:={x[1]-x[2] < = 5, x[1]+x[2]=2}; 

L:=maximize(f,M,NONNEGATIVE); 

Kommentar 

Laden des Pakets simplex 

Definition der Zielfunktion 

Definition der Restriktionen 

Lösung des Problems 

Aufgabe 3.1 Lösen Sie das Problem 

(LP ) 

max − 

30∑ 

i=1 

x i unter Ax = b, x ≥ 0 

für die Matrix A und den Vektor b, die Sie in Aufgabe 2.2 eingelesen haben. Schreiben 

Sie den Lösungsvektor mit writedata in eine Datei loesung.txt. Diese Datei soll außer 

den Einträgen des Lösungsvektors nichts weiter enthalten. 

Hinweise: Ist L die durch maximize gelieferte Lösung, so greift man auf die Komponenten 

der Lösung zum Beispiel mit subs(L,[seq(x[t],t=1..30)]); zu. Um die Menge der 

Gleichungen Ax = b zu erzeugen, können Sie folgende Prozedur verwenden. 

P:=proc(A,b) 

M:={}; 

m:=nops(convert(b,list)); 

n:=nops(convert(row(A,1),list)); 

for i from 1 to m do M:=M union {sum(’A[i,r]*x[r]’,’r’=1..n)=b[i]}; od; 

M; 

end;

4 Speichern und Lesen von Variablen und Prozeduren 

Ist X eine eine Folge von Variablen (insbesondere Prozeduren), so kann man X mit save 

X,”Datei”; in einer Datei speichern. So kann man sich mit der Zeit eine eigene “Bibliothek” 

von nützlichen Prozeduren anlegen, die man schnell in jedes Maple-Worksheet laden 

kann. 

Erhält der Dateiname die Endung .m, so wird X im internen Maple-Format gespeichert 

(ermöglicht schnelleres Laden als im Textformat). Das Laden und automatische Aufrufen 

(!) von X erfolgt mit read ”Datei”;. Achtung: save und read werden ohne runde 

Klammern verwendet. Beispiele: 

Befehl 

P:=proc(a,b) a*b; end; 

save P,”prozedur.m”; 

restart; 

read ”prozedur.m”; 

Kommentar 

Definition einer Prozedur 

Speichern im internen Maple-Format 

Löschen aller Variablenwerte (also auch der Prozedur 

P). 

Prozedur wird eingelesen und ist wieder unter 

dem Namen P verfügbar. 

Aufgabe 4.1 Speichern Sie die Prozedur aus Aufgabe 3.1 im internen Maple-Format (mit 

Dateiendung .m). Führen Sie restart; aus, laden Sie die Prozedur wieder mit read und 

überprüfen Sie, ob sie danach wieder verfügbar ist. 

Oft es bequemer, Prozeduren außerhalb von Maple in einem Texteditor zu schreiben (nicht 

zuletzt wegen gelegentlichen Abstürzens von Maple ...) und dann mit read in Maple zu 

laden. 

Aufgabe 4.2 Schreiben Sie in einem Texteditor eine Maple-Prozedur P:=proc(n), die 

die Menge der ersten n Primzahlen zurückliefert. Speichern Sie die Datei als primset.txt. 

Laden Sie die Prozedur mit read in Maple und testen Sie sie an einem Beispiel.




Maplets 

Maplets sind Java-basierte graphische Benutzeroberflächen für mit Maple erzeugte Programme. Maplets 

sind vor allem von Maple-Arbeitsblättern unabhängig und können daher auch von Maple-Unkundigen 

bedient werden. Ein Maplet besteht aus Elementen und Aktionen. Elemente sind Bestandteile der 

graphischen Oberfäche und Aktionen sind Prozeduren, die bei Anklicken oder Auswählen bestimmter 

Elemente ausgelöst werden. 

1 Windows 

Das Fundament eines Maplets ist meist ein Window. Syntax: 

Window(Optionen, [[Elemente 1],...,[Elemente n]]); 

Dabei bestehen Elemente i aus vordefinierten Bestandteilen der graphischen Oberfäche, z.B. 

- Button (Schaltfläche), 

- TextField (Ein- und Ausgabe von Text) oder 

- Plotter (zur Ausgabe von Maple-Plots). 

- ein einfacher String, z.B. ”Hallo” 

Die [Elemente 1],...,[Elemente n] werden untereinander angezeigt. Elemente enthalten meist Prozeduren 

als Argumente, die bestimmte Aktionen auslösen, z.B. Shutdown() zum Schließen des Maplets. 

Jeder Eintrag Elemente i kann ein einzelnes Element oder eine Folge von Elementen sein. Ist ein 

Eintrag eine Folge, so werden die Elemente der Folge nebeneinander angezeigt. Besteht Elemente 1 

z.B. aus Elt1, Elt2, Elt3, so werden Elt1, Elt2, Elt3 nebeneinander angezeigt. 

Anzeigen eines Windows W: 

restart; #zur Sicherheit 

with(Maplets[Elements]): 

M:=Maplet(W): 

Maplets[Display](M); 

Aufgabe 1 Erzeugen Sie ein Maplet, das folgendes anzeigt (verwenden Sie Strings ”Feld1”,... als 

Elemente): 

Feld1 Feld2 Feld3 

Feld4 Feld5 Feld6 

2 TextField, Button, SetOption, Evaluate 

Das folgende Window zeigt, wie man mit Hilfe eines TextFields eine Benutzereingabe einlesen kann. 

W:=Window( ’title’="Text einlesen", 

[ "Geben Sie etwas ein:", 

TextField[’text’](), #der Inhalt des Feldes bekommt den Namen ’text’ 

[ Button("Schliessen", Shutdown()) , #Button, der das Maplet schliesst 

Button("Loeschen", SetOption(’text’= "")) #Button, der Text loescht 

] 

] 

):

Die in diesem Window verwendete Aktion SetOption ist sehr nützlich, um Werte von Variablen zu 

setzen. 

Aufgabe 2 Schreiben Sie ein Maplet, das zusätzlich den eingegebenen Text in einem anderen Text- 

Field ausgibt, falls ein Button ”Anzeigen ”gedrückt wird. Das neue Textfeld soll ganz unten angezeigt 

werden. 

Hinweis: Zum Kopieren des Texts verwendet man 

Aufgabe 4 SetOption(’target’=’anzeige’,Argument(’text’)), wobei ’anzeige’, die Variable 

ist, die den Text des Feldes ”Anzeigen”enthält. 

Die Aktion Evaluate 

Einen Maple-Befehl kann man in einem Maplet aufrufen mit 

Evaluate(’name’ = ’Befehl(Parameter)’) 

Dadurch wird der Variable ’name’ der Rückgabewert des Befehls zugewiesen. 

Aufgabe 3 Schreiben Sie ein Maplet zur Durchführung von Primzahltests, das ein Textfeld zur 

Eingabe einer ganzen Zahl und eines zur Ausgabe des Ergebnisses (true oder false) enthält. Buttons: 

- “Schliessen” : Maplet wird mit Shutdown() geschlossen. 

- “Loeschen” : Eingegebene Zahl wird gelöscht. 

- “Primzahltest”: Primzahltest wird durchgeführt und Ergebnis im Ausgabefeld angezeigt. 

Hinweise: Einlesen kann man mit 

"Geben Sie eine ganze Zahl ein:",TextField[’zahl’]() 

Den Primzahltest führt man aus mit 

Button("Primzahltest", Evaluate(’resultat’ = ’isprime(zahl)’)) 

Aufgabe 4 Speichern Sie das Maplet aus Aufgabe 3, indem Sie bei “Speichern unter” den Dateityp 

Maplet wählen. Rufen Sie das Maplet aus dem Windows-Explorer durch Doppelklick auf und testen 

Sie es. 

3 Das Element Plotter 

Mit dem Plotter-Element kann man innerhalb von Maplets plotten. Syntax: 

Plotter[’name’]() 

Dadurch wird ein Feld zum Plotten erzeugt, das unter ’name’ angesprochen werden kann. Einen 

Plotbefehl ausführen kann man dann mit 

Evaluate(’name’=’plot(funktion,var=a..b)’); 

dabei ist var die verwendete Variable, [a,b] der Plotbereich und funktion ist ein Ausdruck in der 

Variablen var, der geplottet wird. 

Aufgabe 5 Schreiben Sie ein Maplet mit 4 Eingabefeldern für 

- einen zu plottenden Ausdruck (in einer Variablen), 

- die verwendete Variable, 

- linken Randpunkt des Plotbereichs, 

- rechten Randpunkt des Plotbereich. 

Fügen Sie ein Plotter-Element hinzu und einen Button “Plot”, bei dessen Anwahl der Ausdruck auf 

dem ausgewählten Bereich geplottet wird.




Differentialgleichungen 

Eine Paradeanwendung von Maple ist die Bearbeitung von Problemen aus der Kinematik mit Hilfe des 

Solvers dsolve für Differentialgleichungen und die Animation der erhaltenen Lösungen. Obwohl dieses 

Vorhaben keineswegs leicht zu verwirklichen ist, werden wir es hier behandeln, denn die Resultate sind 

sehr ansprechend. Die Schritte von der Problemstellung bis zur Animation sehen folgendermassen aus. 

1. Aufstellen der Bewegungsgleichungen. 

2. Lösen der Bewegungsgleichungen mit Hilfe von dsolve. 

3. Animieren der Lösungen mit Hilfe von plot oder plot3d und plots[display] oder plots[animate]. 

1 Der Befehl dsolve 

Für das Lösen von Systemen von gewöhnlichen Differentialgleichungen (DGLn) ist der Befehl dsolve 

zuständig. Syntax: 

dsolve(M,F,Optionen); 

Dabei ist M eine Menge gewöhnlicher DGLn und (optional) Anfangsbedingungen. Zum Beispiel stellt 

M:={diff(x(t),t$2)=-x(t), x(0)=1, D(x)(0)=0}; 

die DGL x ′′ (t) = −x(t) mit Anfangsbedingungen x(0) = 1 und x ′ (0) = 0 dar. Weiter ist F die 

Menge der Funktionen, nach denen das System aufgelöst werden soll, zum Beispiel F:= {x(t)}. Die 

wichtigste Option von dsolve ist numeric, die einem bei nicht exakt lösbaren Systemen oft weiterhilft. 

Die Lösungen werden in der Form von Gleichungen ausgegeben, etwa L:=x(t)=tan(t). Mit rhs(L); 

erhält man dann die Lösung, d.h. die rechte Seite (right hand side) der Gleichung x(t)=tan(t). 

Beispiel: 

Befehl 

M:={diff(x(t),t$2)=-x(t), x(0)=1, D(x)(0)=0}; 

L:=dsolve(M,x(t)); 

plot(rhs(L),t=-10..10); 

Kommentar 

DGL mit Anfangsbedingungen 

DGL wird gelöst 

Plotten der Lösung 

Aufgabe 1.1 Lösen Sie mit dsolve die Differentialgleichung x ′′ (t) = −tx(t) mit den Anfangsbedingungen 

x(0) = 0, x ′ (0) = 1. Plotten Sie die Lösung. Hinweise: Die Maple-Schreibweise für x ′′ (t) bzw. 

x ′ (0) ist diff(x(t),t$2) bzw. D(x)(0). 

2 Ein bisschen Physik 

Bewegungsgleichungen kann man nach Schema F aufstellen, falls das zugrundeliegende Problem nicht 

zu kompliziert ist. Dieses Schema F heißt in der Physik Lagrangeformalismus. Wir betrachten eine 

Punktmasse m in einem System (z.B. Kreislinie, Kugeloberfläche, Ebene) in einem Kraftfeld (z.B. 

konstantes Gravitationsfeld). Die Koordinaten der Punktmasse zur Zeit t seien (x(t), y(t), z(t)). 

1.Schritt 

Beschreibung des Systems durch geeignete Hilfskoordinaten θ(t) = (θ 1 (t), ..., θ f (t)), wobei f die Anzahl 

der Freiheitsgrade ist. Das bedeutet: Die möglichen Aufenthaltsorte der Punktmasse sind 

(x(θ), y(θ), z(θ)), θ ∈ R f .

Nicht jedes System kann so beschrieben werden, wir setzen aber eine solche Beschreibung voraus. Zum 

Beispiel: 

Einheitskreislinie: x(t) = cos θ(t), y(t) = sin θ(t), z(t) = 0 (ein Freiheitsgrad). 

Kugeloberfläche: x(t) = sin θ 2 (t) cos θ 1 (t), y(t) = sin θ 2 (t) sin θ 1 (t), z(t) = cos θ 2 (t) (zwei Freiheitsgrade). 

2. Schritt 

a) Berechnung der kinetischen Energie 

[ ( 

T = m ) d 2 ( ) d 2 ( ) ] 

d 

2 

2 dt x(t) + 

dt y(t) + 

dt z(t) 

(m = Masse). Dabei müssen x, y, z durch die θ i (t) ausgedrückt werden dann mit Hilfe der Kettenregel 

differenziert werden. Maple wendet die Kettenregel automatisch an. 

b) Berechnung der potentiellen Energie V . Im konstanten Gravitationsfeld in negativer z-Richtung ist 

(m=Masse, g=Gravitationsbeschleunigung). 

c) Berechung der Lagrangefunktion L = T − V . 

3.Schritt 

Die Bewegungsgleichungen lauten 

d 

dt 

(1) 

V = mgz (2) 

( ) ∂L 

∂θ ˙ − ∂L = 0, i = 1, ..., f. (3) 

i 

∂θ i 

Dabei ist θ ˙ i = dθ i /dt. Jede Koordinate θ i liefert also eine DGL. Der Ausdruck ∂L 

∂θ ˙ bedeutet: Ersetze 

i 

θ˙ 

i = dθ i /dt in L durch eine Variable, etwa a, differenziere den entstehenden Ausdruck nach a, und 

ersetze danach a wieder durch dθ i /dt. Analog berechnet man ∂L 

∂θ i 

. 

3 Beispiel: Der schiefe Wurf 

Eine Punktmasse m = 1 habe zur Zeit 0 die Geschwindigkeit v = 20 in horizontaler Richtung, 

Geschwindigkeit 0 in vertikaler Richtung und die Höhe h = 10. Die Gravitationsbeschleunigung sei 

konstant 10. Ziel: Berechung der Bahnkurve, Animation. 

Koordinaten: x(t): Horizontale Position zur Zeit t, y(t): Höhe zur Zeit t. 

Hier ist also θ 1 = x und θ 2 = y. 

Anfangsbedingungen: x(0) = 0, ẋ(0) = v, y(0) = h, ẏ(0) = 0. 

Aufstellen der Lagrangegleichungen mit Maple 

Befehl 

Kommentar 

m:=1; v:=20; h:=10; g:=10; 

Masse, Ausgangsgeschwindigkeit, 

Höhe, Gravitationsbeschleunigung 

T:=1/2*m*(diff(x(t),t)ˆ2+diff(y(t),t)ˆ2); Kinetische Energie nach (1) 

V:=m*g*y(t); Potentielle Energie nach (2) 

L:=T-V; 

Lagrangefunktion 

L1:=subs(diff(x(t),t)=a, 

Wichtiger Trick: Ausdrücke, nach 

diff(y(t),t)=b,x(t)=c,y(t)=d,L); 

abgeleitet werden soll, werden durch 

neue Variablen ersetzt 

R1:=diff(L1,a); R2:=diff(L1,b); 

Berechung von ∂L/∂ẋ, ∂L/∂ẏ, 

R3:=diff(L1,c); R4:=diff(L1,d); 

∂L/∂x, ∂L/∂y 

a:=diff(x(t),t); b:=diff(y(t),t); 

c:=x(t); d:=y(t); 

Rücksubstituierung 

G1:=diff(R1,t)-R3=0; Gleichung (3) für i = 1 

G2:=diff(R2,t)-R4=0; Gleichung (3) für i = 2

Lösen der Bewegungsgleichungen 

Wir wenden dsolve jetzt auf das oben für den schiefen Wurf aufgestellte Differentialgleichungssystem 

an. 

Befehl 

M:={G1,G2,x(0)=0, 

D(x)(0)=v,y(0)=h,D(y)(0)=0 }; 

L:=dsolve(M,{x(t),y(t)}); 

Kommentar 

System mit Anfangsbedingungen 

Lösen des Problems 

Animation der Lösungen 

Für die Animation der Lösung zum schiefen Wurf werden wir die Befehle plot und plots[display] 

verwenden. Statt dessen könnte man auch mit animate arbeiten. 

Befehl 

f:=rhs(op(L)[1]); g:=rhs(op(L)[2]); 


P[i]:=plot([subs(t=i/20,f)+cos(u)/5, 

subs(t=i/20,g)+sin(u)/5,u=0..2*Pi]); od: 

with(plots): 

display([seq(P[k],k=0..50)],insequence=true); 

Kommentar 

Zugreifen auf die Lösung 

Erzeugen von 51 Momentaufnahmen. sin 

und cos erzeugen kleinen Kreis zur Darstellung 

des Punktes 

Liefert Animation. Zum Starten auf Bild 

klicken und in der Menüleiste auf Rechtspfeil 

klicken. 

4 Pendel mit großen Ausschlägen 

Ein masseloser Stab der Länge l=1 sei so an einem Punkt aufgehängt, dass er reibungsfrei in einer 

festen Ebene pendeln kann (Einheiten lassen wir hier weg). Am unteren Ende des Stabs sei eine Punktmasse 

m = 1 befestigt. Dann liegt die Bahn der Punktmasse auf einem Kreis. Für die Koordinaten 

(x(t), y(t), z(t)) der Punktmasse können wir also schreiben: 

x(t) = cos a(t), y(t) = sin a(t), z(t) = 0. 

(∗) 

Hier ist also θ 1 = a. Da die z-Koordinate immer Null ist, kann sie in den folgenden Rechnungen 

weggelassen werden. 

Aufgabe 4.1 

a) Berechnen Sie mit Maple die Lagrangefunktion des Pendels (Schritt 2, letzte Seite). Die potentielle 

Energie sei V = y(t)g, wobei g = 10 die Erdbeschleunigung ist. 

b) Stellen Sie die Bewegungsgleichung G für das Pendel auf (Schritt 3, letzte Seite). Gehen Sie dabei 

analog zur Tabelle auf der letzten Seite vor. Vereinfachen Sie die Gleichung dann mit G1:=simplify(G);. 

c) Lösen Sie die Bewegungsgleichung G1 mit den Anfangsbedingungen a(0)=0 und D(a)(0)=0 und 

der Option numeric als drittem Argument von dsolve. 

Als Lösung erhalten wir in Aufgabe 4.1 c) eine Prozedur, die wir L nennen. Ruft man zum Beispiel 

L(2) auf, so erhält man in der zweiten Komponente der Ausgabe den Wert a(2). 

Aufgabe 4.2 

a) Definieren Sie mit Hilfe der Prozedur L von oben die Lösungsfunktion 

f:=t ->rhs(L(t)[2]); und plotten Sie f. 

b) Erzeugen Sie mit 

for i from 0 to 50 do P[i]:=plot( [ [0,0],[cos(f(i/10)),sin(f(i/10))] ], style=line): od: 

51 Momentaufnahmen der Pendelbewegung und animieren Sie diese mit 

plots[display]( [seq(P[k],k=0..50)], insequence=true);

5 Punktmasse auf einer Spirale 

Wir betrachten eine Punktmasse m = 1, die sich reibungsfrei auf der Spirale 

x(t) = a(t) cos 5a(t), y(t) = a(t) sin 5a(t), z(t) = 0. 

bewegt. Wie zuvor kann die z-Koordinate hier bei den folgenden Rechnungen weggelassen werden. 

Aufgabe 5.1 

a) Berechnen Sie mit Maple die Lagrangefunktion der Punktmasse auf der Spirale. Die potentielle 

Energie sei überall 0. 

b) Stellen Sie die Bewegungsgleichung G für die Punktmasse auf. Vereinfachen Sie die Gleichung dann 

mit G1:=simplify(G);. 

c) Lösen Sie die Bewegungsgleichung G1 mit den Anfangsbedingungen a(0)=0 und D(a)(0)=10 mit 

Hilfe von dsolve ohne Option. 

Als Lösung erhalten wir in Aufgabe 5.1 c) einen Ausdruck (Gleichung), den wir L nennen. 

Aufgabe 5.2 

a) Definieren Sie mit Hilfe der Lösung L von oben die Lösungsfunktion 

f:=x ->evalf(subs(t=x,rhs(L)));. 

b) Erzeugen Sie mit 


P[i]:= plot([f(i/10)*cos(5*f(i/10))+cos(u)/10, f(i/10)*sin(5*f(i/10))+sin(u)/10,u=0..2*Pi]); 

od: 

51 Momentaufnahmen der Spiralbewegung und animieren Sie diese mit 

plots[display]( [seq(P[k],k=0..50)], insequence=true); 

(∗∗)

Einführung in Maple: 1. Arbeitsblatt

Verwandeln Sie Ihre PDFs in ePaper und steigern Sie Ihre Umsätze!

Template löschen?

Als Template speichern ?