Maplekurs

Einfhrung in Maple (2SWSt, 3 LPs)
Scheinanforderungen:
aktiver Besuch der nachmittglichen bungen, Bearbeitung der bungsauf gaben
Abschlussarbeit am letzten Kurstag
Maple ist ein mathematisches Programmsystem. Es bietet die Mglichkeit algebraischer
Vereinf achung mathematischer Ausdrcke bis hin zur analytischen Dif f erentiation oder
Integration von Funktionen. Zudem erlaubt es die Darstellung von Funktionen oder Daten in
zw ei- bzw . dreidimensionalen Graphen. Durch zustzliche Pakete lassen sich mit Maple
auch Probleme aus dem Bereich der linearen Algebra (lineare Gleichungssysteme,
Eigenw ertproblem, ...), nichtlineare Gleichungssysteme oder Dif f erentialgleichungen lsen.
Selbstverstndlich knnen alle Rechnungen von Maple auch numerisch mit beliebiger
Genauigkeit (bei beliebig langer Rechenzeit) durchf hrt w erden.
Komplexere Probleme lassen sich mit der in Maple vorhandenen Programmierumgebung, die
neben den blichen Kontrollstrukturen auch die Def inition eigener Prozeduren und Funktionen
ermglicht, angehen.
Maple bietet unter Microsof t-Window s und Linux/Unix eine graphische Oberf lche, mit der
sich schnell und bersichtlich mathematische Probleme eingeben und bearbeiten lassen.
Def initionen, Formeln, Ergebnisse, Kommentare und Graf iken w erden direkt in das so
genannte Worksheet mit eingebunden.
Einfhrung in Maple
Stand 7.12.2009 (Version 2.1) - F.Wnsch
Dieses Skript basiert auf Kursen von Thomas Pruschke, Joachim Keller, Harald Dobler, Florian
Chmela und Roland Winkler.
Kap. 1: Grundlagen
Kap. 2: Graphik mit Maple
Kap. 3: Lsung von Differentialgleichungen mit Maple
Kap. 4: Programmierung und Prozeduren
Kap. 5: Lineare Algebra
Grundlagen
Was ist Maple?
Maple ist ein weit verbreitetes mathematisches Softwarepaket (hnlich dazu:
Mathematica); akuell ist z.Z. die Version 13. Die Universitt besitzt eine Campuslizenz
von Maple fr Windows, Unix/Linux, Mac. Die Version 13 ist schick, kann sehr viel, ist
aber furchtbar trge. Die ltere Version VR5 ist schlank und kann alles, was wir fr den
Kurs bentigen. Sie ist (unter Windows) finden in F:\MAPLE\V5\BIN32\wmaple.exe.
(neuere Versionen lassen sich mit RZSetup installieren). Im Kurs arbeiten wir daher
i.d.R. mit Maple V Release 5. Unter Unix/Linux startet der Befehl xmaple
normalerweise die aktuellste Version, ltere sind per enable verfgbar.
Der Hersteller (Maple Waterloo Inc.) beschreibt sein Produkt so:
Maple is a comprehensive computer system for advanced mathematics. It includes
facilities for interactive algebra, calculus, discrete mathematics, graphics, numerical
computation, and many other areas of mathematics. It also provides a unique
environment for rapid development of mathematical programs using its vast library of
built-in functions and operations.
Besondere Strke: symbolische Mathematik, also Finden von allgemeinen
Lsungsformeln
simples Beispiel: quadratische Gleichung:
> restart; # immer sinnvoll am Anfang jedes Abschnitts
> equ:=a*x^2+b*x+c=0;
:= equ = + + a x
2
b x c 0
> solve(equ,x);
,
1
2
+ b b
2
4 a c
a
1
2
b b
2
4 a c
a
Page 1
>
Maple kann auch numerisch rechnen, allerdings nicht so effizient wie andere
Programmpakete wie z.B. Matlab (es wird daran gearbeitet...), dafr aber mit beliebig
einstellbarer Genauigkeit (Feststellung/Vermeidung von Rundungsfehlern, die oft
vllig falsche Ergebnisse verursachen, ideal fr die Entwickler von numerischen
Algorithmen). Schnittstellen von Maple zu Programmiersprachen wie C oder Fortran
sind vorhanden.
Maple hat hervorragende Graphik-Fhigkeiten, z.B. Visualisierung von
Funktionen(scharen), groen Datenmengen, auch mit Animation
Maple ist fr Mathematiker, Chemiker, Physiker, Ingenieure, Wirtschaftler bzw.
Student(inn)en dieser Fcher von Anfang an ein unentbehrlicher Werkzeugkasten.
Lernziele des Kurses
Ein komplexes Pakte wie Maple kann man nicht im klassischen Sinne komplett "lernen".
Wir zeigen Ihnen die grundstzlichen Konzepte, die Sie an Hand der bungsaufgaben
trainieren. Anschlieend prsentieren wir Ihnen aus dem groen Maple-"Werkzeugkasten"
einige wenige Tools aus den Paketen fr erweiterte Graphik, fr Differentialgleichungen
und zur Linearen Algebra. Wir wollen Sie soweit bringen, dass Sie in der Lage sind, sich
in die Komponenten von Maple, die Sie gerade bentigen, selbststndig einzuarbeiten, und
Maple als selbstverstndliches Werkzeug fr Ihre tgliche Arbeit einsetzen knnen.
Maple kann viel mehr als das, was wir im Kurs ansprechen, z.B. Statistik, Optimierung
usw.. Mit ?packages sehen Sie, welche groe Menge an Paketen Bestandteil der
jeweiligen Maple-Version ist. Darberhinaus lohnt es sich, die Webpage
www.maplesoft.com zu besuchen. U.a. sind hier Maple-Lsungen fr zahlreiche
Problemstellungen aus allen mglichen Wissensgebieten zusammengetragen.
>
Die Arbeitsumgebung
Die Anmerkungen hier beziehen sich konkret auf Maple V Release 5 (englisch), neuere
Versionen haben noch mehr Knpfe ... Die Menu- und Symbolleisten entsprechen
Windows-Standard (z.B. File, Edit, View). Es gibt aber viel spezifische Erweiterungen, die
i.d.R. kontext-abhngig sind.
Worksheet-Konzept
Alles passiert auf einem Arbeitsblatt im Computer. Man unterscheidet:
Text-Regionen wie hier gerade; viele Elemente einer normalen Textverarbeitung
verfgbar (siehe 3. Fensterleiste)
Input-Regionen (gekennzeichnet mit [> ). Hier wird mathematische Eingabe erwartet
(Umschalten mit / T)
Output-Regionen: hier gibt Maple seine Ergebnisse aus (bzw. die Eingabe schn
dargestellt).
Page 2
> 2+3 # da fehlt ein ; als Befehls-Abschlu
Warning, premature end of input
> 3*sqrt(2); # sqrt(2) wird NICHT genhert!
3 2
> evalf(%); # berechne die letzte Zeile numerisch
4.242640686
>
Beachte: die Berechnungen werden Zeile fr Zeile in zeitlicher (nicht rtlicher
Reihenfolge) abgearbeitet.
Algebraische Ausdrcke werden zunchst nicht numerisch ausgewertet, sondern in
der exakten Form gespeichert.
Die blichen Editor-Befehle wie Markieren, Ausschneiden, Kopieren usw. gehen (meist)
wie unter Windows gewohnt. Manches ist allerdings etwas skurill - einfach ausprobieren,
und immer wieder Gebrauch von der Undo-Funktion machen.
Um bei greren Projekten nicht die bersicht zu verlieren, sollte man die Arbeitsbltter
strukturieren (so wie dieses hier). Unter Edit bzw. Format kann man markierte Bereiche zu
Sections zusammenfassen, die auf- und zugeklappt werden knnen (auch manchmal
skurill ...)

Execution Groups sind mit einer Klammer versehene Eingabebereiche (oder auch
Textbereiche) (am Zeilenende Shift Return drcken!). Solche Eingabebereiche werden
gemeinsam ausgefhrt:
> x:=sqrt(2);
> evalf(x);
:= x 2
1.414213562
Maple VR5 luft eigentlich sehr stabil und strzt nur ganz selten ab. Nichtsdestotrotz sollte
man Save often, save early beherzigen (unter File in der Kopfleiste oder Button mit der
Diskette in der Menleite oder Tastenkombination <Strg>+<s>).
Ab und zu mchte man auch vermeiden, dass Maple einem alle Zwischenergebnisse
mitteilt:
> a:=3+7;b:=4-2;a*b;
:= a 10
:= b 2
20
Dazu kann man einen Maplebefehl alternativ auch mit : abschlieen:
> a:=3+7:b:=4-2:a*b;
20
>
Page 3
Die Hilfsfunktionen
Die eingebaute Online-Hilfe ist sehr gut, muss aber auch immer wieder kontaktiert werden.
Was gibt's alles an Hilfe?
Balloon Help: wenn man mit der Maus ber einen Knopf in der Menleiste fhrt, wird die
Bedeutung erklrt
Maus auf ein Schlsselwort, dort Strg F1 oder einfach F1 drcken. Alternativ kann man
im Eingabefeld z.B. ?solve eingeben. Beidesmal kommt die ausfhrliche Hilfeseite mit
Beispielen:
> ?solve
ber den Hilfe-Knopf in der Menleiste kann man ber die gesamte Doku Volltextsuche
machen.
Die komplette Online-Doku kann man natrlich auch durchblttern, sie ist gegliedert in
die Kapitel Introduction, New User's Tour, Mathematics usw.
Wir gehen mit der Maus auf ein blaues Ausgabefeld. Die rechte Maustaste macht uns
Vorschlge, welche Operationen vielleicht noch sinnvoll wren.
> restart;
> g:=a*x^2+b*x+c;
:= g + + a x
2
b x c
Vorgeschlagen wird differenzieren, integrieren, faktorisieren usw.
>
Die ersten Graphiken
Die elementaren Graphik-Befehle heien plot und plot3d. Probieren wir's mal:
> restart;
> plot(sin);
Page 4
Ohne weitere Angaben wird eine Funktion in einem automatisch gewhlten Bereich
dargestellt. Es gibt viele Online-Optionen (Click auf die Graphik! dann rechte Maustaste
bzw. Menuleiste). Hunderte Optionen und sehr viele schne Beispiele (Holen mit
Cut&Paste) gibt's ber die Online-Hilfe bzw. die Eingabe ?plot;
Mal ein ganz einfacher 3D-Plot (Darstellung einer Funktion, die von x und y abhngig ist,
mit explizit angegebenen Bereichen):
> plot3d(sin(x)*cos(y),x=-3..3, y=-3..3);
Page 5
Bitte unbedingt mal damit herumspielen, drehen, die Perspektive, das Lichtmodell usw.
ndern!

Jetzt noch eine 3D-Animation. Was heit das? Ich will eine Funktion darstellen, die von x
und y und darber hinaus auch noch von der Zeit abhngt. Also probieren wir:
> animate3d(sin(x*t)*cos(y*t),x=-3..3,y=-3..3,t=1..2);
( ) animate3d , , , ( ) sin x t ( ) cos y t = x .. -3 3 = y .. -3 3 = t .. 1 2
Wenn Maple nicht versteht, was man will, wird einfach die Eingabe wieder ausgegeben.
Warum tut sich nicht? Viele weitergehende Funktionalitten von Maple sind in
Paketen zusammengefasst, die erst hereingeladen werden mssen, so auch erweiterte
Plot-Funktionen
> with(plots);
animate animate3d animatecurve changecoords complexplot complexplot3d , , , , , , [
conformal contourplot contourplot3d coordplot coordplot3d cylinderplot , , , , , ,
densityplot display display3d fieldplot fieldplot3d gradplot gradplot3d , , , , , , ,
implicitplot implicitplot3d inequal listcontplot listcontplot3d listdensityplot listplot , , , , , , ,
listplot3d loglogplot logplot matrixplot odeplot pareto pointplot pointplot3d , , , , , , , ,
polarplot polygonplot polygonplot3d polyhedra_supported polyhedraplot replot , , , , , ,
rootlocus semilogplot setoptions setoptions3d spacecurve sparsematrixplot , , , , , ,
sphereplot surfdata textplot textplot3d tubeplot , , , , ]
Da gibt es also zahlreiche neue Befehle, u.a. auch animate3d :
> animate3d(sin(x*t)*cos(y*t),x=-3..3,y=-3..3,t=1..2);
Page 6
>
Initialisierung, Restart
Eine (von diversen) Fallen von Maple:
> x:=3; # weisen wir mal x die Zahl 3 zu ( := NICHT =)
:= x 3
> plot(sin(x)*exp(-x/5),x=0..20);
Error, (in plot) invalid arguments
x ist fest 3 und kann nicht auf einmal von 0 bis 20 laufen! Auer wir vergessen alles:
> restart;
> plot(sin(x)*exp(-x/5),x=0..20);
Page 7
> Der wichtigste Befehl am Beginn einer jeden Maple-Sitzung oder neuen Rechnung
heit also
> restart;
Er lscht alle Zuordnungen und beseitigt eventuellen Datenmll der vorhergehenden
Berechnungen. Sollte mal etwas nicht so klappen, wie man sich das denkt und liegt
augenscheinlich auch kein Fehler in den Befehlen vor, so ist es oft hilfreich, ganz von vorne
mit einem restart anzufangen. restart kann man auch an spterer Stelle beliebig oft einfgen.

Bei jedem restart (und beim Starten von Maple) wird die Datei .mapleinit abgearbeitet, falls
sie im Arbeitsverzeichnis / Homedirectory vorhanden ist. Sie darf beliebige Maple-Befehle
enthalten. Z.B. knnte man damit das Hinzuladen von Paketen automatisieren.
Eine kleine Randanmerkung: in diesem Trivialbeispiel htte auch gereicht:
> x:='x';
:= x x
Damit erhlt x wieder seine ursprngliche Bedeutung als (freie) Variable.
>
Konstanten in Maple
Elementare Konstanten
Integer
> restart;
23, 37, -104;
, , 23 37 -104
Fraction (Brche)
Page 8
Brche werden automatisch soweit als mglich gekrzt, aber nicht numerisch
ausgewertet:
> 23 / 37, -109/8;
,
23
37
-109
8
> 27/18, -57/19;
,
3
2
-3
> 7/9+3/11;
104
99
>
Complex
Die imaginre Einheit heit I (groes I!)
> I^2;
-1
> u := 3 + 4*I;
:= u + 3 4 I
> u^2;
+ 7 24 I
>
Float (Fliekomma-Zahlen)
Fliekomma-Zahlen werden durch einen Dezimalpunkt oder durch die
Exponentialschreibweise als solche gekennzeichnet:
> 0.3333, - 1.2345, 1e-3;
, , .3333 -1.2345 .001
Achtung
Wenn man mit Maple exakt (analytisch) rechnen mchte, sollte man es soweit als
mglich vermeiden, Fliekommazahlen zu verwenden, also
> phi := 1/4 * Pi;
:=
1
4
statt
> phi := 0.25 *Pi;
:= .25
Sonst bekommt man Schwierigkeiten beim weiterrechnen:
> sin (1/4 * Pi), sin (0.25 * Pi);
,
1
2
2 ( ) sin .25
>
Kreiszahl Pi (groes 'P' !! Maple ist case-sensitiv)
> P := Pi; sin (P);
:= P
Page 9
0
> p := pi; sin (p); # pi ist nicht definiert
:= p
( ) sin
Die Eulersche Zahl steht in Maple als 'exp(1)' zur Verfgung:.
> exp(1);
e
>
Algebraische Konstanten
Algebraische Konstanten bestehen aus den vordefinierten mathematischen
Funktionen, angewandt auf elementare Konstante:
> sqrt (1 + sqrt (2));
+ 1 2
Irrationale und transzendente Zahlen werden also nicht numerisch ausgewertet, wie
wir schon sahen, sondern so weit wie mglich exakt behandelt.
Maple zeichnet sich dadurch aus, das solche Ausdrcke `Ernst' genommen werden:
> s := sqrt (1 + sqrt (2)) * sqrt (1 - sqrt (2));
:= s + 1 2 1 2
> combine (s);
I
mit combine: Combine terms into a single term. Solche Vereinfachungen werden nicht
standardmig durchgefhrt. Sie mssen jeweils erzwungen werden. Spter dazu
mehr.
>
Strings
Maple kann auch mit Textstrings arbeiten. Ein Textstring darf beliebige Zeichen
enthalten, die von ".... " (doppelte Anfhrungsstriche) eingeschlossen werden.
> str := "Hello world":
> str;
"Hello world"
>
Variable
Achtung:
Maple kennt keine Typ-Deklarationen fr die Werte, die eine Variable annehmen darf.
Jeder Variable drfen beliebige Werte zugewiesen werden.
Variablennamen drfen in Maple praktisch beliebig lang sein (maximal 2^19-1 Zeichen):
> 2^19-1;
524287
Man sollte daher soweit als mglich selbsterklrende Variablennamen verwenden:
> Geschwindigkeit = Weg / Zeit;
Page 10
= Geschwindigkeit
Weg
Zeit
Zusammengesetzte Daten-Typen
Es ist essentiell, sich einzuprgen, was Bereiche, Folgen, Listen und Mengen sind.
Diese Konstrukte finden permanent in Maple Verwendung. Algebraische Ausdrcke,
Gleichungen und Arrays sind ziemlich selbsterluternd.
Algebraische Ausdrcke
> restart;
Variable und Konstanten lassen sich zu beliebigen neuen Ausdrcken kombinieren
> exp (sqrt ((sin (x) + Pi)/7 + x));
e
( ) / 1 7 + + 7 ( ) sin x 7 49 x
>
Gleichungen
Gleichungen verbinden zwei algebraische Ausdrcke mit =
> x=y+z;
= x + y z
Das Maple-Objekt Gleichung kann auch einen Namen haben:
> eq := x=y+z;
:= eq = x + y z
> eq;
= x + y z
Man beachte wieder die Verwendung von := und = !!!
>
Range (Bereich)
Viele Operationen (Summen, Integrale) erfordern einen (Summations-/Integrations-)
Bereich. Bei ersteren handelt es sich um eine Menge ganzer Zahlen, bei zweiten Fall
um einen kontinuierlichen Bereich. Immer haben Bereiche haben die Form
'Untergrenze .. Obergrenze'
> intervall := 0..Pi;
:= intervall .. 0
Damit lt sich dann arbeiten:
> int (sin (x), x = 0 .. Pi); # Integriere
2
Oder aber auch:
> int (sin (x), x = intervall);
2
Oder auch:
> fkt := sin (x);
:= fkt ( ) sin x
> x_range := x = intervall;
:= x_range = x .. 0
> int (fkt, x_range);
Page 11
2
Zur Erinnerung:
Bei diesen Rechnungen kommt es darauf an, dass wir mit der Variable 'x' als
unbestimmte Variable arbeiten. Deshalb geht obiges Spiel in die Hose, wenn der
Variable 'x' bereits ein Wert zugewiesen worden ist.

Auch der Plot-Befehl arbeitet mit Ranges, wie wir schon gesehen haben. Hier noch ein
Beispiel mit einer Summe:
> sum(1/n^2,n=1..5);
5269
3600
>
Sequence (Folgen)
Eine Sequence ist eine mit Kommas getrennte Folge von Maple-Objekten
(Ausdrcken usw.):
> 1,2,3;
, , 1 2 3
> sqrt (2), sin (3/2);
, 2
|
\
|
.
|
|
sin
3
2
Was auch geht:
> int_arg := fkt, x_range;
:= int_arg , ( ) sin x = x .. 0
> int (int_arg);
2
Dieses Beispiel zeigt: eine Funktion, die mehrere Argumente annimmt, bekommt
eigentlich nur ein Argument vom Typ Sequence.
Die Glieder der Folge sind geordnet. Mithilfe des Auswahloperators [ ] kann man
gezielt ein Glied der Folge auswhlen, Numerierung ab 1:
> s:=x,y,z; s[2];
:= s , , x y z
y
Beispielsweise erhlt man beim Lsen von Gleichungen mit Hilfe von solve eine
Folge von Lsungen, die im Falle einer eindeutigen Lsung die Lnge eins hat.
> erg:=solve(x^2-x+1=0 , x);
:= erg ,
1
2
1
2
I 3 +
1
2
1
2
I 3
> erg[2];
+
1
2
1
2
I 3
Page 12
Die Funktion seq erzeugt eine Folge aus einer vorzugebenden Vorschrift und wird
sehr oft verwendet:
> seq(n^2,n=1..5);
, , , , 1 4 9 16 25
>
List (Liste)
Eine Liste ist eine mit eckigen Klammern eingeschlossene Folge. Sie kann wieder
als ein Ausdruck verwendet werden. Die Elemente der Liste haben eine feste
Reihenfolge, womit identische Elemente an verschiedenen Stellen immer wieder
auftauchen knnen.
> list1 := [ 1, exp(1) , exp(0), sqrt(2), 0, sqrt(2)];
:= list1 [ ] , , , , , 1 e 1 2 0 2
Ein einzelnes Element kann wieder mit dem Auswahloperator [ ] herausgegriffen
werden.
> list1[2];
e
Oder auch
> my_seq := 1,2,3,2,1,6;
:= my_seq , , , , , 1 2 3 2 1 6
> [my_seq];
[ ] , , , , , 1 2 3 2 1 6
Listen werden wir z.B. beim Plotten von Datenfeldern benutzen. Dort tauchen dann
sogar listlists auf:
> plot([[1,2],[3,4]]); # zeichne simple Gerade
Page 13
>
Set (Menge)
Eine Menge ist eine mit geschweiften Klammern eingeschlossene Folge. In einer
Menge kommt jedes Element genau einmal vor:
> my_set := {1,2,3,2,1,6};
:= my_set { } , , , 1 2 3 6
Oder auch
> {my_seq};
{ } , , , 1 2 3 6
> set1 := {1, exp(1) , exp(0), sqrt(2), 0, sqrt(2)};
:= set1 { } , , , 0 1 2 e
>
Man kann zwar auch wieder ein beliebiges Element auswhlen, aber: die Reihenfolge
der Elemente in einer Menge ist nicht festgelegt (Maple optimiert sie hinsichtlich
Zugriffszeit). Sie kann sich fr die gleiche Menge von einem Aufruf zum nchsten
(auch innerhalb des gleichen Worksheets) ndern!
> set1[2];
1
>
Es gibt Mengen-Operationen, mit denen man Schnittmengen (intersect),
Vereinigungen (union) und Differenzen (minus) bestimmen kann.
> set2 := {seq(n,n=0..4)};
:= set2 { } , , , , 0 1 2 3 4
> set1 intersect set2;
{ } , 0 1
> set1 union set2;
{ } , , , , , , 0 1 2 3 4 2 e
> set1 minus set2;
{ } , 2 e
Mithilfe der Funktion member kann man berprfen, ob ein Ausdruck Element einer
Menge ist.
> member(sqrt(2),set1);
true
> member(sqrt(2),set2);
false
>
Lsungen von Gleichungssystemen werden z.B. als Menge zurckgegeben.
>
Array
Ein Array ist ein Feld mit einem oder mehreren Indizes. Fr jeden Index mu ein
Werte-Bereich als Range 'Untergrenze .. Obergrenze' festgelegt werden. Jedes
Feld-Element kann beliebige Maple-Objekte enthalten, die nichts miteinander
gemeinsam haben mssen:
Page 14
> restart;
> arr1 := array (-2 .. 3, ["he", "ll", "o", "world", 42,
sin (alpha)]);
arr1 .. -2 3 array( , [ :=
= ( ) -2 "he"
= ( ) -1 "ll"
= ( ) 0 "o"
= ( ) 1 "world"
= ( ) 2 42
= ( ) 3 ( ) sin
])
> arr1 [-1];
"ll"
>
> arr2 := array (1..4, 1..2, [[1,2],[3,4],[5,6],[7,8]]);
:= arr2
(
(
(
(
(
(
1 2
3 4
5 6
7 8
> arr2 [2,2];
4
>
Bei der Linearen Algebra werden wir uns noch genauer mit Arrays beschftigen. Dort
werden wir hauptschlich mit Spezialfllen von Arrays arbeiten, nmlich mit Vektoren
und Matrizen. Bei diesen beginnt das Feld automatisch immer mit dem Index 1.
Noch eine ntzliche Anmerkung: Maple behandelt intern Arrays als Listen.
Folgendes ist quivalent:
> a:=[seq(i,i=1..10)];
:= a [ ] , , , , , , , , , 1 2 3 4 5 6 7 8 9 10
> a[3];
3
> a[3]:=17;
:= a
3
17
> a[3];
17
> b:=array(1..10,[1,2,3,4,5,6,7,8,9,10]);
:= b [ ] , , , , , , , , , 1 2 3 4 5 6 7 8 9 10
> b[3]; b[3]:=17; b[3];
3
:= b
3
17
Page 15
17
Operatoren
Die Standard-Operatoren zum Rechnen sind * / + - ^ !
> restart;
(7 * X + 3)^3 / (4 * Y + 2);
( ) + 7 X 3
3
+ 4 Y 2
> 4!;
24
>
Vergleichsoperatoren sind < <= => = >
Je nach Zusammenhang muss die Auswertung einer solchen Vergleichsoperation
gegebenfalls mit evalb (eval boolean) erzwungen werden (analog zu evalf fr eine
Floatingpoint-Berechnung):
> 7>3;
< 3 7
> evalb (7 < 3);
false
Logische Operatoren sind not, and und or
> not 7<3;
true
>
Rangordnung
- Fakultt !
- *, /, mod
- +, -
- Vergleichsoperatoren: < <= = >= > <> (ungleich)
- not
- and
- or
- der Sequence-Operator ','
- der Zuordnungsoperator ':='

Elementare Rechenfunktionen: abs, exp, ln, sqrt, sin, cos, etc. Maple kennt ihre
Eigenschaften:
> sin (Pi/3);
1
2
3
Eine komplette Liste aller Maple beim Start bekannten Funktionen (ein paar allgemeine
und vor allem viel Mathematik) erhlt man unter Help mit dem Begriff inifcns (Initially
known mathematical functions) oder durch:
> ?inifcns
>
Page 16
Funktionen zur Vereinfachung eines Ausdrucks
Hier sind nur jeweils ein paar Beispiele aufgefhrt. Empfehlenswert: mal die Hilfe fr die
nachfolgenden Funktionen anschauen!
simplify: "Allgemeine" (unspezifische / unkontrollierte) Vereinfachungen
> restart;
(a+b)^2+(a-b)^2;
+ ( ) + a b
2
( ) a b
2
Hier findet keine weitere Auswertung statt, obwohl man diesen Ausdruck sicher
einfacher schreiben kann.
> simplify(%);
+ 2 a
2
2 b
2
Das Zeichen % bezieht sich, wie schon gesehen, auf die letzte Ausgabe von Maple,
%% auf die vorletzte und %%% auf die drittletzte.
simplify ist eine sehr mchtige Funktion, die allerdings ihre Tcken hat! Noch ein
Beispiel:
> exp_simp := exp(a + ln (b * exp (c)));
:= exp_simp e
( ) + a ( ) ln b e
c
> simplify (exp_simp);
b e
( ) + a c
>
factor : Faktorisierung eines Ausdrucks
> exp_fac := 6*x^2 + 18*x - 24;
:= exp_fac + 6 x
2
18 x 24
> factor (exp_fac);
6 ( ) + x 4 ( ) x 1
> factor (x^4-2,sqrt(2)); # nur bei ganzen zahlen geht's
automatisch
( ) x
2
2 ( ) + x
2
2
>
collect: Zusammenfassen der Terme mit der gleichen Potenz einer Variablen
> f := x*(x+1)+y*(x+1);
:= f + x ( ) + x 1 y ( ) + x 1
> collect (f, x);
+ + x
2
( ) + 1 y x y
> collect (f, y);
+ x ( ) + x 1 y ( ) + x 1
>
combine: Zusammenfassen von Termen "unter Ausnutzung von Rechenregeln"
Page 17
Ein Beispiel fr combine hatten wir ja schon kennengelernt. Hier ein weiteres:
> exp_com := exp (sin (x) * cos (y)) *
exp (cos (x) * sin (y));
:= exp_com e
( ) ( ) sin x ( ) cos y
e
( ) ( ) cos x ( ) sin y
> exp_c2 := combine (exp_com);
:= exp_c2 e
( ) sin + x y
combine und expand fhren die Umformungen jeweils in umgekehrter Richtung
durch:
> expand (exp_c2);
e
( ) ( ) sin x ( ) cos y
e
( ) ( ) cos x ( ) sin y
Noch ein Beispiel zu combine:
> combine (sin(alpha)^3,trig);
+
1
4
( ) sin 3
3
4
( ) sin
>
expand: "Expandiere" einen Ausdruck ("to distribute products over sums")
> exp_exp [1] := (x+1)*(x+2);
:= exp_exp
1
( ) + x 1 ( ) + x 2
> expand (exp_exp [1]);
+ + x
2
3 x 2
> exp_exp [2] := sin (x+y);
:= exp_exp
2
( ) sin + x y
> exp_exp [3] := expand (exp_exp [2]);
:= exp_exp
3
+ ( ) sin x ( ) cos y ( ) cos x ( ) sin y
> combine (exp_exp[3]);
( ) sin + x y
>
convert: Bringe Ausdruck in eine andere Form
> convert(exp(z),trig);
+ ( ) cosh z ( ) sinh z
> convert(exp(I*z),trig);
+ ( ) cos z I ( ) sin z
> convert(sin(x),exp);
1
2
I
|
\
|
.
|
|
e
( ) I x
1
e
( ) I x
Im nchsten Abschnitt bei den Reihen kommt noch ein Beispiel zu convert.
>
Reihenentwicklung
Page 18
> reihe:=series( exp(x), x=0, 4 ); # entwickle um x=0 4
Glieder
:= reihe + + + + 1 x
1
2
x
2
1
6
x
3
( ) O x
4
> convert( reihe, polynom ); # jetzt ist der O - Term
weg
+ + + 1 x
1
2
x
2
1
6
x
3
> series( 1/x, x=1, 3 ); # entwickle um x=1
+ + 1 ( ) x 1 ( ) x 1
2
( ) O ( ) x 1
3
>
Numerische Berechnungen

In vielen Fllen bentigt man letztlich doch eine nherungsweise numerische Auswertung
eines Ergebnisses. Dies bewerkstelligt die Funktion evalf:
> restart;
> sq2:=sqrt(2);
:= sq2 2
> evalf(sq2);
1.414213562
oder man berechnet
> sqrt(2.0);
1.414213562
Die Zahl der Stellen, die Maple berechnen soll, ist ein weiteres optionales Argument zu
evalf:
> evalf(sq2,50);
1.4142135623730950488016887242096980785696718753769
Aber Vorsicht: Numerische Rechnungen sind immer mit Rundungsfehlern behaftet:
> sqrt(2)*sqrt(8)-4;
0
> evalf(sqrt(2))*evalf(sqrt(8))-4;
-.2 10
-8
Vielleicht hilft es ja, die Zahl der Stellen hochzusetzen. Dazu gibt es eine Maple-Variable
namens Digits. Setzt man diese auf einen Integerwert, so rechnet Maple numerisch mit der
angegeben Zahl von Stellen, bis Digits neu zugewiesen wird. So kann man die erweiterte
numerische Genauigkeit fr den gesamten Ausdruck gltig machen (standardmig ist fr
Digits der Wert 10 eingestellt):
> Digits;
Digits:=50; evalf(sqrt(2))*evalf(sqrt(8))-4;
Digits:=10;
10
Page 19
:= Digits 50
-.3 10
-48
:= Digits 10
Achtung: Wie schon erwhnt: Maple wird alle Ausdrcke numerisch auswerten, in
denen man explizit float-Zahlen benutzt:
> sqrt(0.1)*sqrt(8)-4;
.6324555320 2 4
Auf jeden Fall sollte man also Argumente von Funktionen immer als rationale Zahlen
schreiben, wenn man damit noch weiter rechnen will:
> sqrt(1/10)*sqrt(8)-4;

1
5
10 2 4
> simplify(%);

2
5
5 4
Noch ein Beispiel:
> 100!;
933262154439441526816992388562667004907159682643816214685929638952175\
999932299156089414639761565182862536979208272237582511852109168640000\
00000000000000000000
> evalf(%);
.9332621544 10
158
>
Lsen von Gleichungen
Einfache Gleichungen (und Ungleichungen)
> restart;
Eine besondere Strke von Maple ist das Lsen von Gleichungen:
> solve(x^2+x-1=0,x);
, +
1
2
1
2
5
1
2
1
2
5
Beachte: Maple gibt wieder die exakte Lsung (so vorhanden) aus. Natrlich geht
auch
> eq:=x^2+x-1=0;
:= eq = + x
2
x 1 0
> sol:=solve(eq,x);
:= sol , +
1
2
1
2
5
1
2
1
2
5
Die einzelnen Lsungen erscheinen hier als Folge (also geordnet). Wenn man auf
die verschiedenen Lsungen zugreifen will, kann man das so machen:
> a:=sol[1];b:=sol[2];
Page 20
:= a +
1
2
1
2
5
:= b
1
2
1
2
5
Man kann auch Nebenbedingungen angeben (d.h. Gleichungen und Ungleichungen
simultan lsen):
> solve(x^2-1=0,x);
, 1 -1
> solve({x^2-1=0,x>0},x);
{ } = x 1
Man beachte die Mengenklammer sowohl beim Argument von solve als auch beim
Ergebnis. Wie man dieses Ergebnis dann weiterverwendet, werden wir gleich sehen.
>
Lineare Gleichungssysteme
Mit demselben Befehl solve lassen sich auch Gleichungssysteme (lineare und
nichtlineare) behandeln. Hier erst mal ein lineares:
> sol:=solve({x+2*y-2*z=5,3*x-y+z=-2,
-4*x+y-7*z=0},{x,y,z});
:= sol { } , , = x
1
7
= y
115
42
= z
13
42
Man beachte, dass das System von Gleichungen wieder in geschweiften Klammern als
Menge bergeben wird. Ebenso mssen die Unbekannten als Menge bergeben
werden. Die Reihenfolge der Lsungen ist hier willkrlich, sie werden als als
Menge zurckgegeben!
Um auf die einzelnen Lsungen zurckzugreifen, knnte man im Prinzip Folgendes
machen:
> sol[1];sol[2];sol[3];
= x
1
7
= y
115
42
= z
13
42
Beim nchsten Durchlauf knnte aber die Zuordnung anders sein. Ausserdem hat man
noch keine Zuordnung der Lsungen zu den Variablen bekommen, die Variablen
x,y,z sind nicht belegt:
> z;
z
Fr solche Zwecke gibt es die Befehle subs und assign. subs ersetzt in einem
Ausdruck eine Variable durch einen Wert (makes the substitution specified by the first
argument in the last argument). In diesem Fall bedeutet das konkret:
Page 21
> subs(sol,z); z; # nur temporr!
13
42
z
> z:=subs(sol,z); # so ist's dauerhaft
:= z
13
42
> z:='z'; assign(sol); x;y;z; # auch dauerhaft
:= z z
1
7
115
42
13
42
assign ist doch ganz praktisch: If the argument is a list or set of equations, then assign
is applied to each equation in the list or set.
>
Nicht-Lineare Gleichungssysteme
> restart;
eq:={x^2+2/y^2=2,y^2-x^2=1},{x,y};
:= eq , { } , = + x
2
2
1
y
2
2 = y
2
x
2
1 { } , y x
> sol:=solve(eq);
sol { } , = y 1 = x 0 { } , = x 0 = y -1 { } , = y ( ) RootOf _Z
2
2 = x 1 , , , :=
{ } , = y ( ) RootOf _Z
2
2 = x -1
Die Lsung nichtlinearer Gleichungen oder Gleichungssysteme wird, speziell bei
Polynomen, hufig in der impliziten RootOf-Notation angegeben ("any root of").
Maple erspart sich damit die explizite Berechnung, die bei Polynomen hheren Grades
entweder nicht geschlossen mglich ist bzw. auf ziemlich unbersichtliche Ausdrcke
fhrt. Ist man dennoch an den Lsungen interessiert, dann hilft der Befehl allvalues
weiter:
>
> p3:=allvalues(sol[3]);
:= p3 , { } , = x 1 = y 2 { } , = x 1 = y 2
Jetzt kann man noch die Lsungen den Variablen zuordnen:
> x:=subs(p3[2],x); y:=subs(p3[2],y);
:= x 1
:= y 2

Natrlich kann man das Problem auch numerisch lsen:
Page 22
> restart;
> # solve using floating point arithmetic
fsolve({x^2+2/y^2=2,y^2-x^2=1},{x,y});
{ } , = x 1.000000000 = y -1.414213562
Offensichtlich fehlen hier einige Lsungen. Hier muss man experimentieren, indem
man in den Variablen einen Startwert angibt:
> fsolve({x^2+2/y^2=2,y^2-x^2=1},{x=0,y=0.1});
{ } , = y 1.000000000 = x 0
>
Die verschiedenen Lsungen findet man am besten, wenn man das System erst mal
grafisch lst. Nheres spter, aber hier schon ein Eindruck:
> with(plots):
> implicitplot({x^2+2/y^2=2,y^2-x^2=1},x=-2..2, y=-2..2);
>
Summen und Produkte; Eigenschaften von Variablen
Berechnung endlicher Summen:
> sum(n,n=1..100);
5050
> sum(n,n=1..N);

1
2
( ) + N 1
2
1
2
N
1
2
> simplify(%);
Page 23
+
1
2
N
2
1
2
N
> sum( (2*n-5)/(3*n^2+4*n-10) , n=0..10);
14069068625
7790320431
> evalf(%);
1.805967899
Berechnung unendlicher Summen (unendlich heit in Maple infinity):
> sum(1/n,n=1..infinity);
> sum(x^n,n=0..infinity);
1
x 1
>
Das Ergebnis macht natrlich nur Sinn (Konvergenz der geometrischen Reihe!), wenn
|x|<1 ist. Wenn man nichts angibt, nimmt Maple oft gnstige Bedingungen an.
Manchmal mu Maple solche Bedingungen wissen. Mitteilen kann man sie mittels assume
:
> assume(x<1);additionally(x>-1);
sum(x^n,n=0..infinity);
1
x~ 1
Die Schlange hinter der Variablen deutet an, dass sie mit einer Bedingung verknpft ist.
Hier: x ist reell und zwischen -1 und +1. Wenn man mehrere Bedingungen an dieselbe
Variable stellen will, muss man das mit additionally machen.
Natrlich kann man Maple auch andere Dinge ber eine Variable mitteilen:
> Re(a+I*b);Im(a+I*b);
( ) + a I b
( ) + a I b
> assume(b,real,a,real);
> Re(a+I*b);Im(a+I*b);
a~
b~
> assume(p,integer);additionally(p,positive); about(p);
Originally p, renamed p~:
is assumed to be: AndProp(integer,RealRange(1,infinity))
> assume(z,complex):about(z); # was ist ber z bekannt?
Originally z, renamed z~:
is assumed to be: complex
Und so weiter. Die ganze Liste mglicher Eigenschaften findet man mittels ?property
> ?property
Page 24
Die Berechung von Produkten erfolgt analog mit dem Befehl product. Beispielsweise
kann man auch so Fakultten berechnen:
> restart;
product(n , n=1..20); 20!;
2432902008176640000
2432902008176640000
Oder etwas komplizierter:
> product((n^2-2)/(n^2+4) , n=0..10);
6356332969
1413056320000
Auch hier kann man unendliche Produkte berechnen:
> product(n , n=1..infinity);
> prod2:=product((n^2-2)/(n^2+4) , n=0..infinity);

:= prod2
= n 0
n
2
2
+ n
2
4
Hier ist die Ausgabe eines geschlossenen analytischen Ergebnisses offenbar nicht mglich.
Probieren wir's numerisch:
> evalf(prod2); # geht leider auch nicht
Error, (in evalf/product1) cannot evaluate boolean
> product((n^2-2.0)/(n^2+4.0) , n=0..infinity);
.002545639645
>
Differenzieren, Integrieren und Grenzwerte
Differenzieren
> restart;
> diff(x^2,x);
2 x
> diff(exp(x),x);
e
x
> diff(sin(x),x);
( ) cos x
> diff(sin(x),x$2); # 2. Ableitung
( ) sin x
Natrlich beherrscht Maple auch Produkt-, Quotienten- und Kettenregel:
> diff(sin(x)*exp(x),x);
+ ( ) cos x e
x
( ) sin x e
x
> diff(x^2/sin(x),x);
Page 25
2
x
( ) sin x
x
2
( ) cos x
( ) sin x
2
> diff(sin(exp(x)),x);
( ) cos e
x
e
x
Statt des Befehls diff gibt es auch eine alternative Schreibweise mit dem D-Operator:
> D(sin)(x);
( ) cos x
> (D@@2)(sin)(x);
( ) sin x
oder allgemeiner formuliert:
> (D@@2)(sin);
sin
> D(sin*cos);
cos
2
sin
2
Sie ist oft sehr praktisch (und manchmal auch unentbehrlich), allerdings klappt's nicht
immer so wie gewnscht:
> D(x^2)(x);
2 ( ) ( ) D x x ( ) x x
Die korrekte Schreibweise wre (mehr dazu weiter unten bei Funktionen) :
> D(x->x^2)(x);
2 x
>
Integrieren
Integrieren geht analog. Unbestimmte Integrale (wieder mit "impliziter Wahl gnstiger
Verhltnisse"):
> int(x^n,x);
x
( ) + n 1
+ n 1
> int(sin(x),x);
( ) cos x
> int(sin(x)^2,x);
+
1
2
( ) cos x ( ) sin x
1
2
x
Bestimmte Integrale
> int(x^n,x=a..b);
b
n
b a a
n
+ n 1
>
> int(sin(x),x=0..2*Pi);
0
> int(sin(x)^2,x=0..2*Pi);
Page 26
> int(exp(-x),x=0..infinity);
1
Beim Integrieren kann auch die assume-Funktion sehr hilfreich sein:
> a:='a':int(exp(-a*x),x=0..infinity);
Definite integration: Can't determine if the integral is convergent.
Need to know the sign of --> a
Will now try indefinite integration and then take limits.
lim
x
e
( ) a x
1
a
Ausweg:
> assume(a>0):int(exp(-a*x),x=0..infinity);
1
a~
Sollte Maple ein bestimmtes Integral nicht knacken knnen, so kann es dieses immer
noch numerisch berechnen:
> int(sin(sqrt(x^3+1)+1),x=0..2*Pi);
d
(
]
(
(
0
2
( ) sin + + x
3
1 1 x
> evalf(%);
.6453563251
Kleine abschlieende Bemerkung: es gibt auch Diff und Int (gross geschrieben); sie
rechnen nicht, sondern geben den Input nur schn aus:
> Diff(exp(x),x);
x
e
x
> Int(sin(x)/x,x=0..1);
d
(
]
(
(
(
(
0
1
( ) sin x
x
x
>
Grenzwerte
Auch Grenzwerte von Funktionen oder Folgen lassen sich mit Maple berechnen:
> limit(sin(x)/x,x=0);
1
> limit((n+1/n)/(4*n-1),n=infinity);
1
4
Auch hier ist es oft hilfreich, Maple mittels assume ber die Eigenschaften von
Variablen zu informieren:
> limit(exp(-b*x) , x=infinity);
Page 27
lim
x
e
( ) b x
> assume(b>0);limit(exp(-b*x) , x=infinity);
0
Auch rechts und linksseitige Grenzwerte knnen bestimmt werden:
> limit(1/x , x=0);
undefined
Aber:
> limit(1/x , x=0 , left);
limit(1/x , x=0 , right);
>
Funktionen
Definition von Funktionen
Die Definition von Funktionen geht mit dem -> Operator:
> restart;
> f:=x->x^5;
:= f x x
5
x ist nur eine formale Variable und nach auen hin nicht sichtbar!
> x;
x
> f(3);
243
> f(y);
y
5
> f(sin(z));
( ) sin z
5
Achtung: Die Variable auf der linken Seite darf kein Argument aufweisen! So nicht!
> g(x):=x->x^5; # so ist's ungut!
:= ( ) g x x x
5
> g(3);
( ) g 3
> g(x)(3);
243
Man hat hier also die Funktion ( ) g x und nicht g genannt.
>
Eine weitere ntzliche Funktionskonstruktion ist piecewise, mit der man Funktionen
zusammenstckeln kann:
> f:=x->piecewise(x<0,0,x>0,x^2);
:= f x ( ) piecewise , , , < x 0 0 < 0 x x
2
Page 28
> f(-1);f(1);
0
1
Differenzieren von Funktionen, Integrieren
Mit der neuen Funktion f kann man jetzt alle bekannten Manipulationen ausfhren:
> restart;
> f:=x->x^5;
:= f x x
5
> diff(f(x),x);
5 x
4
Jetzt verwenden statt diff den Operator D. In der Online-Hilfe steht dazu:
Calling Sequence: D(f)
Parameters f: expression which can be applied as a function
> D(f); # erste Ableitung, Ergebnis wieder als
Funktion
x 5 x
4
> D(f(x)); # so nicht!
5 ( ) D x x
4
> D(f)(x); # erste Ableitung, Ergebnis als
Ausdruck
5 x
4
> D(D(f)); # zweite Ableitung
x 20 x
3
> (D@@2)(f); # auch zweite Ableitung
x 20 x
3
> (D@@3)(f); # dritte Ableitung
x 60 x
2
> D(f@sin); # Ableitung von f(sin(x))
# nicht gerade gnstig
@ ( ) x 5 x
4
sin cos
> D(f@sin)(x); # als Ausdruck ist's hier praktischer
5 ( ) sin x
4
( ) cos x
> D(sin@f)(x); # Ableitung von sin(f(x))
5 ( ) cos x
5
x
4
>
Wie man sieht, lassen sich hhere Ableitungen durch (D@@m)(f)(x) mit natrlichen
Page 29
Zahlen m und Ableitungen von Verknpfungen von Funktionen wie z.B.f(sin(x)) bzw.
sin(f(x)) als D(f@sin)(x) und D(sin@f)(x) abkrzen. Der Operator @ bezeichnet also
die Verknpfung zweier Funktionen:
> (f@sin)(x);
( ) sin x
5
> (sin@f)(x);
( ) sin x
5
>
Auch Integrationen von Funktionen lassen sich wie gewohnt durchfhren.
> int(f(x),x);
1
6
x
6
> int(f(x),x=-1..1);
0
> int(sin(sqrt(f(x)+1)+1),x=0..Pi);
d
(
]
(
(
0
( ) sin + + x
5
1 1 x
> evalf(%);
.6630648383
Funktionen mehrerer Variabler
Natrlich lassen sich in Maple auch Funktionen mehrerer Vernderlicher
definieren. Hier als Beispiel die Bahnkurve beim schrgen Wurf mit
Anfangsgeschwindigkeit v und Abwurfwinkel :
> y:=(x,alpha,v)->tan(alpha)*x-1/2*g/(v*cos(alpha))^2*x^2
;
:= y ( ) , , x v ( ) tan x
1
2
g x
2
v
2
( ) cos
2
Ableitungen gehen so:
> D[1](y); # Ableitung nach erstem Parameter x
( ) , , x v ( ) tan
g x
v
2
( ) cos
2
> (D[1]@@2)(y); # und nochmal nach x abgeleitet
( ) , , x v
g
v
2
( ) cos
2
> diff(y(x,alpha,v),x); # wieder Ableitung nach x
( ) tan
g x
v
2
( ) cos
2
> D[2](y); # Ableitung nach zweitem Parameter
alpha
Page 30
( ) , , x v ( ) + 1 ( ) tan
2
x
g x
2
( ) sin
v
2
( ) cos
3
>
Funktionen und Ausdrcke
Weiter oben hatten wir schon Ausdrcke kennengelernt. Ausdrcke und Funktionen
sind miteinander verwandt, aber nicht identisch; bei manchen Anwendungen
funktioniert aber nur die Darstellung als Funktion, woanders gehen nur Ausdrcke.
Man kann aber leicht hin und her wandeln.
> restart;
a:=x^2+2*x+1;
:= a + + x
2
2 x 1
> solve(a,x);
, -1 -1
> a(17); # das ist Unsinn - geht nur mit
Funktionen
+ + ( ) x 17
2
2 ( ) x 17 1
> subs(x=17,a); # das ist wohl gemeint
324
subs hatten wir ja schon kennengelernt in einer etwas anderen Form - dies hier ist die
'klassische' Variante.
> eval(a,x=17); # so geht's auch:
# evaluate an expression e at a given
point
324
Funktionen wie oben sind eine Abbildungsvorschrift, man kann sie nicht "lsen":
> f:=x->x^2+2*x+1;
solve(f,x);
:= f x + + x
2
2 x 1
f(x) ist aber wieder ein Ausdruck, den man lsen kann:
> solve(f(x),x);
, -1 -1
Umgekehrt kann man mit unapply aus Ausdrcken auch Funktionen machen:
> h:=sin(x)*5;
:= h 5 ( ) sin x
> fh:=unapply(h,x);
:= fh x 5 ( ) sin x
> fh(x);
5 ( ) sin x
Page 31
> fh(2); evalf(fh(2));
5 ( ) sin 2
4.546487134
> j:=sin(x)*cos(y)+z^3;
:= j + ( ) sin x ( ) cos y z
3
> unapply(j,x,y,z);
( ) , , x y z + ( ) sin x ( ) cos y z
3
Noch 'ne kleine Falle:
> restart;
f:=x->x^5;
:= f x x
5
> f1:=x->diff(f(x),x);
:= f1 x ( ) diff , ( ) f x x
> f1(x);
5 x
4
> f1(1);
Error, (in f1) wrong number (or type) of parameters in function diff
Kann so nicht ausgewertet werden. Es wird erst = x 1 gesetzt und dann differenziert,
was dann nicht mehr geht. Ausweg:
> f1:=unapply(diff(f(x),x),x);
:= f1 x 5 x
4
> f1(1);
5
Arbeitet man gleich mit dem D-Operator, gibt's dieses Problem nicht:
> f2:=D(f);
:= f2 x 5 x
4
> f2(1);
5
>
Page 32
Einfhrung in Maple
Dieses Skript basiert auf Kursen von Thomas Pruschke, Joachim Keller und Harald Dobler,
Florian Chmela und Roland Winkler.
Kap. 1: Grundlagen
Graphik mit Maple
Noch paar einfache Plots
Ein paar Plots hatten wir ja schon. Maple ist sehr reich an Darstellungsmglichkeiten. Hier
zunchst noch ein paar einfache, in den anschlieenden Abschnitten zeigen wir auch
ziemlich komplizierte.
Plotten kann man eine Funktion f in der Form f(x), x=a..b. Verschiedene
Darstellungsstile und Auflsungen sind beim Plot-Befehl mglich:
> restart;
> plot(sin(x),x=0..4*Pi,style=point,
symbol=circle,color=red,numpoints=100);
Page 1
Auch mehrere Funktionen pro Plot sind mglich. Dazu muss man als Argument eine
Menge {f1,f2,...} oder eine Liste [f1,f2,...] mit den Funktionen bergeben:
> plot([exp(-x),sin(x),cos(x),1/(1+x)],x=0..4*Pi);
Page 2
Auch Parameterdarstellungen lassen sich plotten: 1. Funktion Abszisse (horizontal). 2.
Funktion Ordinate (vertikal), auch der Bereich muss mit in den eckigen Klammern stehen:
> plot([sin(2*t),cos(t),t=0..2*Pi],scaling=constrained);
Page 3
'constrained' bedeutet, dass fr x und y die gleiche Skala genommen wird. Und nun noch
ein 3D-Bild
> plot3d(x^2-y^2,x=-1..1,y=-1..1,axes=boxed,
scaling=constrained);
Page 4
Dadurch werden Funktionen von zwei Variablen 3-dimensional dargestellt. Wir kennen es
ja schon: durch Anklicken der Figur erscheint eine Menue-Leiste, mit der man die Figur
drehen und mit Achsen versehen kann. Bei manchen Rechnern kann man die Graphik
wrend des Drehens nicht erkennen. Man sieht nur eine Box um den jeweilen Bereich.
Dies hngt mit der Leistung und Speicherausstattung des Computers zusammen.
>
Darstellung von (externen) Daten
Eine Linie hatten wir ja schon gezeichnet. Wie kann man nun Daten (z.B. von einer
externen Berechnung, Experiment etc.) graphisch darstellen? Dazu muss man dem
plot-Befehl eine geeignete Liste bergeben. Die Form dieser Liste ist
[[x1,y1],[x2,y2],...,[xN,yN]] (also ein listlist - Objekt). Man beachte die eckigen
Klammern um die Wertepaare. Beispiel:
> restart;
> a:=[0,0],[1,1],[2,1],[3,0];
:= a , , , [ ] , 0 0 [ ] , 1 1 [ ] , 2 1 [ ] , 3 0
Page 5
> plot([a]);
>
Durch die zustzliche Klammer [a] entsteht aus der Folge [x1,y1], [x2,y2] ... von Punkten
mit je zwei Koordinaten eine Liste, die Plot dann durch gerade Linien verbindet.
Wem die Herstellung solch einer Liste von Hand zu dumm ist, kann das auch durch ein
Programm erledigen. Eine einfache Form davon ist wieder der seq-Befehl, eine Art
do-Schleife. Die einfachste From ist seq(f(i),i=n..m):
> seq(x*i,i=1..10);
, , , , , , , , , x 2 x 3 x 4 x 5 x 6 x 7 x 8 x 9 x 10 x
oder
> a:=seq([evalf(Pi*i/50.0),sin(evalf(Pi*i/50.0))],i=0..100):
> a[1];a[2];
[ ] , 0 0
[ ] , .06283185308 .06279051954
Man beachte die eckigen Klammern innerhalb der seq-Anweisung, wodurch jeweils
korrekt ein Wertepaar definiert wird. Diese Liste von Wertepaaren lsst sich jetzt plotten:
Page 6
> plot([a]);
Oder erzeuge eine Folge von Zufallszahlen:
> data:=seq([n,rand(100)()],n=1..100);
data [ ] , 1 81 [ ] , 2 70 [ ] , 3 97 [ ] , 4 63 [ ] , 5 76 [ ] , 6 38 [ ] , 7 85 [ ] , 8 68 [ ] , 9 21 , , , , , , , , , :=
[ ] , 10 9 [ ] , 11 55 [ ] , 12 63 [ ] , 13 57 [ ] , 14 60 [ ] , 15 74 [ ] , 16 85 [ ] , 17 16 [ ] , 18 61 , , , , , , , , ,
[ ] , 19 7 [ ] , 20 49 [ ] , 21 86 [ ] , 22 98 [ ] , 23 66 [ ] , 24 9 [ ] , 25 73 [ ] , 26 81 [ ] , 27 74 , , , , , , , , ,
[ ] , 28 66 [ ] , 29 73 [ ] , 30 42 [ ] , 31 91 [ ] , 32 93 [ ] , 33 0 [ ] , 34 11 [ ] , 35 38 [ ] , 36 13 , , , , , , , , ,
[ ] , 37 20 [ ] , 38 44 [ ] , 39 65 [ ] , 40 91 [ ] , 41 95 [ ] , 42 74 [ ] , 43 9 [ ] , 44 60 [ ] , 45 82 , , , , , , , , ,
[ ] , 46 92 [ ] , 47 13 [ ] , 48 77 [ ] , 49 49 [ ] , 50 35 [ ] , 51 61 [ ] , 52 48 [ ] , 53 3 [ ] , 54 23 , , , , , , , , ,
[ ] , 55 95 [ ] , 56 73 [ ] , 57 89 [ ] , 58 37 [ ] , 59 57 [ ] , 60 99 [ ] , 61 94 [ ] , 62 28 , , , , , , , ,
[ ] , 63 15 [ ] , 64 55 [ ] , 65 7 [ ] , 66 51 [ ] , 67 62 [ ] , 68 97 [ ] , 69 88 [ ] , 70 42 [ ] , 71 97 , , , , , , , , ,
[ ] , 72 98 [ ] , 73 27 [ ] , 74 27 [ ] , 75 74 [ ] , 76 25 [ ] , 77 7 [ ] , 78 82 [ ] , 79 29 [ ] , 80 52 , , , , , , , , ,
[ ] , 81 4 [ ] , 82 85 [ ] , 83 45 [ ] , 84 98 [ ] , 85 38 [ ] , 86 76 [ ] , 87 75 [ ] , 88 74 [ ] , 89 23 , , , , , , , , ,
[ ] , 90 0 [ ] , 91 19 [ ] , 92 1 [ ] , 93 49 [ ] , 94 47 [ ] , 95 13 [ ] , 96 65 [ ] , 97 44 [ ] , 98 11 , , , , , , , , ,
[ ] , 99 36 [ ] , 100 59 ,
Page 7
> plot([data],style=point,symbol=circle);
Jetzt wollen wir mal echte Messdaten plotten. Die Daten stehen in einer ASCII-Datei in
der Form
0
32
41
29
28
29
37
...........
Die x-Werte sind quidistant und nicht mit abgespeichert. Am besten geht man so vor:
> restart;
> fd:=fopen("g:\\mymaplekurs\\RM405.ASC",READ);
# Datei ffnen; Vorsicht! Maskierung des Pfades
:= fd 0
Page 8
> data:=readdata(fd,integer);
# lese Integerzahlen in Feld
data 0 32 41 29 28 29 37 39 48 32 43 0 2367 3067 3493 3955 4119 , , , , , , , , , , , , , , , , , [ :=
4321 4531 4690 4997 5017 5287 5432 5503 5429 5665 5690 5920 5943 6047 , , , , , , , , , , , , , ,
6200 6319 6222 6419 6383 6486 6592 6585 6645 6593 6634 6786 6695 6592 , , , , , , , , , , , , , ,
6850 6800 6923 6839 6795 7280 7016 , , , , , , ]
> kurve:=seq([i,data[i]],i=1..50);
# baue xy-Paare
kurve [ ] , 1 0 [ ] , 2 32 [ ] , 3 41 [ ] , 4 29 [ ] , 5 28 [ ] , 6 29 [ ] , 7 37 [ ] , 8 39 [ ] , 9 48 , , , , , , , , , :=
[ ] , 10 32 [ ] , 11 43 [ ] , 12 0 [ ] , 13 2367 [ ] , 14 3067 [ ] , 15 3493 [ ] , 16 3955 , , , , , , ,
[ ] , 17 4119 [ ] , 18 4321 [ ] , 19 4531 [ ] , 20 4690 [ ] , 21 4997 [ ] , 22 5017 [ ] , 23 5287 , , , , , , ,
[ ] , 24 5432 [ ] , 25 5503 [ ] , 26 5429 [ ] , 27 5665 [ ] , 28 5690 [ ] , 29 5920 [ ] , 30 5943 , , , , , , ,
[ ] , 31 6047 [ ] , 32 6200 [ ] , 33 6319 [ ] , 34 6222 [ ] , 35 6419 [ ] , 36 6383 [ ] , 37 6486 , , , , , , ,
[ ] , 38 6592 [ ] , 39 6585 [ ] , 40 6645 [ ] , 41 6593 [ ] , 42 6634 [ ] , 43 6786 [ ] , 44 6695 , , , , , , ,
[ ] , 45 6592 [ ] , 46 6850 [ ] , 47 6800 [ ] , 48 6923 [ ] , 49 6839 [ ] , 50 6795 , , , , ,
> plot([kurve]);
# Plot der Liste
Page 9

Es gibt zahlreiche weitere Ein-/Ausgabebefehle in Maple. Maple kann mit save und
read Maple-Text in Dateien auslagern, z.B. Funktionsdefinitionen. Man kann mit
entsprechenden Befehlen Daten und Texte in unterschiedlichen Formaten schreiben und
lesen. Nicht zuletzt kann man Maple-Output (Formeln!) als LaTeX oder in C- oder
Fortran-Syntax abspeichern.
>
Animationen und implizite Abbildungen
animate (create an animation of 2d plots of functions)
Wir hatten schon gesehen: besonders hbsch ist animate(3d), mit der man bewegte
Grafiken herstellen kann. Hiier ein einfaches Beispiel:
> restart;
> with(plots):
> animate(sin(x-t),x=0..20,t=0..8*Pi,
numpoints=100,frames=50); # 50 Einzelbilder
Page 10
Es werden eine Reihe von Bildern (frames) durch den zweiten Parameter t hergestellt,
die dann nacheinander gezeigt werden. Wenn die Zahl gro genug ist, entsteht ein
kontinuierlicher Ablauf. Bild anwhlen nicht vergessen, dann Animation starten in der
Menuleiste. Ein weiteres Beispiel ist:
> animate(x^2*cos(t) , x=-1..1 , t=0..8*Pi ,
color=blue, frames=50);
Page 11
>
animatecurve (create an animation of the drawing of 2d plots)
Man kann auch eine Kurve durchlaufen lassen (ntzlich fr die zeitgerechte
Darstellung einer Bahnkurve):
> animatecurve(sin(x), x=-Pi..Pi,frames=50,color=red);
Page 12
>
implicitplot (two dimensional implicit plotting)
Eine ebenfalls recht ntzliche Prozedur stellt implicitplot dar, wir hatten sie ja schon
einmal. Hier nochmal an Hand einer simplen Kreisgleichung:
> implicitplot(x^2+y^2=1,x=-10..10,y=-10..10,
Page 13
So ist's wohl nicht sinnvoll! Maple nimmt automatisch immer eine begrenzte Anzahl
von Sttzstellen im angegebenen Definitionsbereich. Entweder erhht man die (mit
der Option numpoints=xxx z.B.), oder nimmt besser einen sinnvollen
Definitionsbereich, hier -1..1:
Die Option view definiert brigens, wie gro der dargestellte Bereich ist (unabhngig
Page 14
vom Rechnen):
scaling=constrained, view=[-5..5,-5..5]);
Im Folgenden seien nun zwei Kurven durch implizite Gleichungen gegeben.
> f:=x^2+2/y^2=9; g:=x^2-y^2=1;
:= f = + x
2
2
1
y
2
9
:= g = x
2
y
2
1
In diesem Beispiel lassen sich zwar die Gleichungen nach y auflsen. Zum Zeichnen
ist das aber nicht notwendig. Im Beispiel weiter oben hatten wir beide Kurven zu einer
Menge zusammengefasst und auf einmal gezeichnet. Jetzt erzeugen wir zwei
Plot-Strukturen und legen sie in Variablen ab. Am Ende verwenden wir dann den
Befehl display - Display a list of plot structures:
> b:=implicitplot(g,x=-4..4,y=-4..4,color=blue):
> a:=implicitplot(f,x=-4..4,y=-4..4,color=red):
> display(a,b,scaling=constrained);
Page 15
Mit display lassen sich die vorher generierten Plot-Strukturen (zusammen) darstellen,
durchaus aus unterschiedliche wie z.B. einen impliziten und einen normalen Plot. Die
Option scaling=constrained steht am besten im Display-Befehl, man knnte sie auch
in jeden Plot-Befehl hineinschreiben. Jetzt wissen wir ungefhr, wo die Schnittpunkte
liegen, und knnen sie exakt berechnen lassen:
> fsolve({f,g},{x=-1,y=-0.5});
{ } , = x -1.121758714 = y -.5082741516
Ein anderes Beispiel: Nehmen wir einmal an, eine Rechnung htte uns das Ergebnis
> lsg:=cos(Pi*x)+cos(Pi*y)-1/2*cos(Pi*x)*cos(Pi*y)=c;
:= lsg = + ( ) cos x ( ) cos y
1
2
( ) cos x ( ) cos y c
mit einem reellen Parameter c beschert. Was wir wissen wollen, ist aber das Verhalten
von ( ) y x . Nun ist es zwar hier im Prinzip mglich, nach ( ) y x aufzulsen, aber
vielfach geht das nicht. Mit implicitplot kann man sich dennoch recht schnell einen
berblick ber die Lsung verschaffen, z.B. fr = c 0:
> implicitplot(subs(c=0,lsg),x =-1..1,y =-1..1,
Page 16
Will man das fr mehrere Werte von c machen und in einem gemeinsamen plot
darstellen, dann kann man das zwar im Prinzip ber die bekannte Methode erreichen
(mehrere Funktionsaufrufe in geschweiften Klammern), aber oftmals ist auch das zu
mhselig. Einen Ausweg bietet hier wieder die Funktion display, und zwar
folgendermaen: Zunchst verschafft man sich eine Sequenz von Plots (diesen Befehl
sollte man unbedingt mit einem Doppelpunkt abschlieen, sonst schreibt einem
Maple den ewig langen Inhalt der Plotstrukturen auf den Bildschirm):
> a:=seq(implicitplot(subs(c=i/10,lsg),
x =-1..1, y =-1..1,
scaling=constrained, view=[-1..1,-1..1])
,i=-10..10):
> a[1]; # das ist der erste Frame!
Page 17
Diese Sequenz von plots kann man jetzt mittels display anzeigen:
> display([a]);
Page 18
Eine zustzliche Spielerei erhlt man mit der Option insequence=true im display
-Befehl:
> display([a],insequence=true);
Page 19
Auf diese Weise lassen sich also Animationen erzeugen! Bild anklicken, mit der
rechten Maustaste Animation starten.
Dreidimensionale Darstellungen
spacecurve (plotting of 3d space curves)
Bekannt ist das bereits angesprochene plot3d, das auch auerhalb des plots-Paket zur
Verfgung steht. Eine weitere Mglichkeit, 3d-Plots zu erzeugen, bietet spacecurve
aus dem plots - Paket. Oftmals hat man nicht eine Flche im Raum vorliegen, sondern
eine Kurve, die man darstellen mchte. Das geht mit spacecurve:
> restart;with(plots):
spacecurve([sin(t),cos(t),t/20],t=0..12*Pi,
numpoints=1000,axes=boxed,scaling=constrained);
Page 20
>
surfdata (create a 3-d surface plotting from data)
Oftmals ist es so, dass man z.B. aus Experimenten, numerischen Berechnungen oder
Umfragen einen Satz von Daten erhlt, die von zwei Variablen abhngen. Im
eindimensionalen Fall konnte man eine entsprechende Liste einfach an plot bergeben.
Im Falle von Flchen ist das nicht so ohne Weiteres mglich. Hierzu gibt es die
surfdata-Prozedur.
Zur Demonstration arbeiten wir an dieser Stelle nicht mit Messdaten, sondern mit
simplen Sinus- und Cosinusfunktionen. Die knnte man natrlich ganz 'klassisch'
plotten mit
> plot3d({cos((x+y)/5),sin((x+y)/5)},x=-5..5,y=-5..5);
Page 21
Jetzt wollen wir (zwei) dreidimensionale Datenstze darstellen. Wir basteln uns die
Demodaten erst mal aus den Sinus- und Cosinus-Funktionen:
cosdata :=
[seq([ seq([i,j,evalf(cos((i+j)/5))], i=-5..5)],
j=-5..5)]:
Dies sind also im Prinzip 3dimensionale Arrays:
> cosdata[1,1,1];cosdata[1,1,2];cosdata[1,1,3];
# die x,y,z - Werte
-5
-5
-.4161468365
> cosdata[1,1];
# ein Tupel [x,y,z]
[ ] , , -5 -5 -.4161468365
> sindata :=
[seq([ seq([i,j,evalf(sin((i+j)/5))], i=-5..5)],
j=-5..5)]:
Analog zum 2-dimensionalen Fall, wre Folgendes naheliegend:
> plot3d( {sindata,cosdata}, axes=frame, labels=[x,y,z]
);
Error, (in plot3d) first argument must be either in standard or
parametric form
Das funktioniert wie bereits erwhnt nicht. Die korrekte Version ist
Page 22
> surfdata( {sindata,cosdata}, axes=frame);
>
implicitplot3d (three-dimensional implicit plotting)
Auch implizit gegebene Flchen kann man graphisch darstellen. Dazu dient der
Befehl implicitplot3d.
> f := x^3+y^3+z^3+1 = (x+y+z+1)^3;
:= f = + + + x
3
y
3
z
3
1 ( ) + + + x y z 1
3
> implicitplot3d(f , x=-2..2,y=-2..2,z=-2..2 ,
grid=[20,20,20] , # wieviele
Sttzstellen?
scaling=constrained ,
axes=boxed);
Page 23
Die Verwendung anderer Koordinaten erfolgt mit der Option coords, hier mit
sprischen Koordinaten , , r
> implicitplot3d(r=1 , r=0..1.2,phi=0..2*Pi,theta=0..Pi
,
axes=boxed , coords=spherical ,
grid=[25,25,25],scaling=constrained);
Page 24
Page 25
Einfhrung in Maple
Kap. 1: Grundlagen
Lsung von Differentialgleichungen mit Maple
Generelle Konzepte
Ein Standardproblem in vielen Bereichen der Anwendung ist das Lsen von
Differentialgleichungen. Dies sind Gleichungen, welche neben der gesuchten Funktion
auch noch ihre Ableitungen enthalten. Ein Beispiel:
=
x
( ) y x y
mit der Lsung = ( ) y x C e
x
oder
=
x
|
\
|
.
|
|
x
( ) y x ( ) y x
mit der Lsung = ( ) y x + C1 ( ) sin x C2 ( ) cos x
etc.
Die Formulierung in Maple lautet:
> diff(y(x),x)=y(x);
=
x
( ) y x ( ) y x
> diff(y(x),x$2)=y(x);
=
2
x
2
( ) y x ( ) y x
oder alternativ und flexibler
> D(y)(x)=y(x);
= ( ) ( ) D y x ( ) y x
Page 1
> D(D(y))(x)=y(x);
(D@@2)(y)(x)=y(x);
= ( ) ( ) ( ) D
( ) 2
y x ( ) y x
= ( ) ( ) ( ) D
( ) 2
y x ( ) y x
Maple kann solche Gleichungen unter Umstnden analytisch lsen. Das gilt insbesondere
fr lineare DGln und die meisten DGln erster Ordnung (d. h. in denen hchstens die
erste Ableitung vorkommt), da hier explizite Lsungsvorschriften existieren.
Der Maple-Befehl zur Lsung von DGln lautet dsolve:
> restart;
> dsolve(diff(y(x),x)=y(x),y(x));
= ( ) y x _C1 e
x
> dsolve(diff(y(x),x$2)+y(x)=0,y(x));
= ( ) y x + _C1 ( ) sin x _C2 ( ) cos x
Die alternative Formulierung ber den D-Operator:
> dsolve(D(y)(x)-y(x)=0,y(x));
= ( ) y x _C1 e
x
> dsolve(D(D(y))(x)=-y(x),y(x));
= ( ) y x + _C1 ( ) sin x _C2 ( ) cos x
> dsolve((D@@2)(y)(x)=-y(x),y(x));
= ( ) y x + _C1 ( ) sin x _C2 ( ) cos x
Man beachte: Maple schreibt immer die allgemeinste Lsung hin und fhrt dazu
Integrationskonstanten _C1,_C2,... ein.
In praktischen Problemen muss man diese Integrationskonstanten mittels
Anfangsbedingungen = ( ) y x
0
y
0
, = ( ) ( ) D y x
0
Dy
0
, ... festlegen. Man beachte, dass fr die
Anfangsbedingungen bei Ableitungen der gesuchten Funktion grundstzlich die
D-Operatorschreibweise benutzt werden muss! Dem Befehl dsolve werden DGL und
Anfangsbedingungen gemeinsam als Menge bergeben. Beispiele:
> dsolve({D(y)(x)-y(x)=0,y(0)=17},y(x));
= ( ) y x 17 e
x
> dsolve({diff(y(x),x$2)+y(x)=0,y(0)=17,D(y)(0)=2},y(x));
= ( ) y x + 2 ( ) sin x 17 ( ) cos x
Allgemein gilt, dass man fr DGln n-ter Ordnung genau n Anfangsbedingungen ( ) y x
0
,
( ) ( ) D y x
0
, ( ) ( ) D ( ) D y x
0
, ... angeben muss.
Diese Schreibweise wird leicht unbersichtlich. Es ist besser, die Differential-Gleichung
und die Anfangsbedingungen vorher zu definieren:
> dgl:=diff(y(x),x$2)+y(x)=0;
Page 2
:= dgl = +
|
\
|
.
|
|
2
x
2
( ) y x ( ) y x 0
> anfb:=y(0)=1,D(y)(0)=1; # Folge der Anfangsbedingunegn
:= anfb , = ( ) y 0 1 = ( ) ( ) D y 0 1
> dsolve(dgl,y(x)); # lse allgemein
= ( ) y x + _C1 ( ) sin x _C2 ( ) cos x
> dsolve({dgl,anfb},y(x)); # lse mit Anfangsbedingunegn
= ( ) y x + ( ) sin x ( ) cos x
Maple kann auch nichtlineare DGln (hier meist nur erster Ordnung, also nur mit
x
( ) y x )
lsen:
> dgl:= (y(x)^2-x)*diff(y(x),x)+x^2-y(x)=0;
:= dgl = + ( ) ( ) y x
2
x
|
\
|
.
|
|
x
( ) y x x
2
( ) y x 0
> dsolve(dgl,y(x),implicit);
= + + _C1
1
3
x
3
x ( ) y x
1
3
( ) y x
3
0
So erhlt man eine implizite Lsung der Gleichung. Wenn man die vollstndige Lsung
wissen will, kann man noch die Option explicit angeben:
> dsolve(dgl,y(x),explicit);
= ( ) y x +
1
2
%1
( ) / 1 3
2
x
%1
( ) / 1 3
,
= ( ) y x +
1
4
%1
( ) / 1 3
x
%1
( ) / 1 3
1
2
I 3
|
\
|
.
|
|

1
2
%1
( ) / 1 3
2
x
%1
( ) / 1 3
,
= ( ) y x
1
4
%1
( ) / 1 3
x
%1
( ) / 1 3
1
2
I 3
|
\
|
.
|
|

1
2
%1
( ) / 1 3
2
x
%1
( ) / 1 3
:= %1 + 12 _C1 4 x
3
4 + + + 4 x
3
9 _C1
2
6 _C1 x
3
x
6
Fragt sich, was bersichtlicher ist.
>
Umgang mit den Lsungen
Im Folgenden geht es darum, wie man die Maple-Ausgabe der Lsungen weiterverarbeiten
kann. Dazu nehmen wir uns ein physikalisches Beispiel her, nmlich den freien Fall. Die
Bewegungs-DGl hierfr ist
= m
|
\
|
.
|
|
2
t
2
( ) z t m g
mit der Masse m und der Schwerebeschleunigung g=9.81.
> restart;
> dgl:=m*diff(z(t),t$2)=-m*g; # m krzt sich eh raus!
Page 3
:= dgl = m
|
\
|
.
|
|
2
t
2
( ) z t m g
> anf:=z(0)=z0,D(z)(0)=v0;
:= anf , = ( ) z 0 z0 = ( ) ( ) D z 0 v0
> sol:=dsolve({dgl,anf},z(t));
:= sol = ( ) z t + +
1
2
g t
2
v0 t z0
Jetzt versuchen wir einmal, das Ergebnis fr g=9.81, z0=10 und v0=0 zu zeichnen. Um
hier nicht von vornherein Schiffbruch zu erleiden, muss man Maple allerdings erst einmal
mitteilen, welche numerischen Werte g, z0 und v0 haben sollen. Hierzu kann man
entweder mittels g:=9.81, z0:=... und v0:=... den Variablen selbst Werte zuweisen. Das ist
sicher fr g sinnvoll, da man kaum die Erdbeschleunigung manipulieren will. Fr z0 und
v0 ist das aber ungnstig, da dann eine Neuzuweisung die komplette Neuberechnung nach
sich zieht. Einfacher geht es mit dem Befehl substitute:
subs(var1=wert1,var2=wert2,...,ausdruck) ersetzt in ausdruck die Variable var1 mit dem
Wert wert1 usw., wie wir wissen. Also:
> sol:=subs(g=9.81,sol);
:= sol = ( ) z t + + 4.905000000 t
2
v0 t z0
Maple kann keine Gleichungen zeichnen. Probieren wir assign, dann ist z(t) (nicht z!)
bekannt:
> z(t);
( ) z t
> assign(sol);
> z;
z
> z(t);
+ + 4.905000000 t
2
v0 t z0
Alternativ kann man die rechte Seite der Gleichung mit dem Befehl rhs herausprparieren
und sie der Variablen Z zuweisen:
> Z:=rhs(sol); # right hand side
:= Z + + 4.905000000 t
2
v0 t z0
Nun geht's zum Plotten; noch ist aber z(t) und Z abhngig von t und zwei weiteren
Parametern. Das Standard-Kochrezept: mache aus der allgemeinen Lsung eine
Funktion mit allen vorkommenden Varioablen:
> z:=unapply(z(t),t,v0,z0); # z(t) als Parameter rechts
:= z ( ) , , t v0 z0 + + 4.905000000 t
2
v0 t z0
> Z:=unapply(Z,t,v0,z0); # Z als Parameter rechts
:= Z ( ) , , t v0 z0 + + 4.905000000 t
2
v0 t z0
> plot(z(t,0,10),t=0..2);
Page 4
> plot(Z(t,0,10),t=0..2);
Nun sollte das Teilchen nicht im Boden verschwinden, d.h. 0 Z ist eine Randbedingung
des Problems. Daher suchen wir uns die Nullstelle der Lsung fr den physikalischen
relevanten Bereich t>0:
> solve({Z(t,0,10)=0,t>0},t);
{ } = t 1.427843123
Page 5
Wie blich, wird die Lsung als Menge zurckgeliefert. Um damit weiterarbeiten zu
knnen, mssen wir die Lsung einzeln rausprparieren:
> solve({Z(t,0,10)=0,t>=0},t)[1];
= t 1.427843123
> t0:=rhs(solve({Z(t,0,10)=0,t>=0},t)[1]);
:= t0 1.427843123
> plot(Z(t,0,10),t=0..t0);
Systeme von DGln
> restart;
Ein anderer hufig auftretender Fall ist, dass man ein System von Differentialgleichungen
vorliegen hat, also etwas von dem Typ
= [ ] , ( ) ( ) D x t ( ) ( ) D y t

((
a11 a12
a21 a22
[ ] , ( ) x t ( ) y t
Auch das lst Maples dsolve-Befehl:
> dgls:=D(x)(t)=a11*x(t)+a12*y(t),D(y)(t)=a21*x(t)+a22*y(t);
:= dgls , = ( ) ( ) D x t + a11 ( ) x t a12 ( ) y t = ( ) ( ) D y t + a21 ( ) x t a22 ( ) y t
> dsolve({dgls},{x(t),y(t)});
( ) x t
1
2
_C1 a22 %3 _C1 a11 %3 _C1 %1 %3 _C2 a22 %2 _C2 a11 %2 + ( = {
_C2 %1 %2 + a21 ) / = ( ) y t + _C1 %3 _C2 %2 , }
:= %1 + + a22
2
2 a11 a22 a11
2
4 a12 a21
:= %2 e
( ) + / 1 2 t a22 / 1 2 t a11 / 1 2 t %1
Page 6
:= %3 e
( ) + + / 1 2 t a22 / 1 2 t a11 / 1 2 t %1
Etwas bersichtlicher wird das Ergebnis fr eine spezielle Wahl der Koeffizienten:
> a11:=0;a12:=1;a21:=-1;a22:=0;
:= a11 0
:= a12 1
:= a21 -1
:= a22 0
> dgls;
, = ( ) ( ) D x t ( ) y t = ( ) ( ) D y t ( ) x t
> dsolve({dgls},{x(t),y(t)});
{ } , = ( ) y t ( ) cos t _C1 ( ) sin t _C2 = ( ) x t + ( ) sin t _C1 ( ) cos t _C2
Die Lsung dieses Problems entspricht der von = + ( ) ( ) D ( ) D x t ( ) x t 0 mit
= ( ) y t ( ) ( ) D x t . In der Tat sind beide DGln quivalent, eine lineare DGL zweiter Ordnung
entspricht also einem System aus zwei linearen DGLs erster Ordnung:
> dgl2:=(D@@2)(x)(t)+x(t)=0;
:= dgl2 = + ( ) ( ) ( ) D
( ) 2
x t ( ) x t 0
> dsolve(dgl2,x(t));
= ( ) x t + ( ) cos t _C1 ( ) sin t _C2
Stellen wir die Lsung des Systems doch einmal fr die Anfangsbedingungen x(0)=1 und
y(0)=0 dar:
> anfb:=x(0)=1,y(0)=0;
:= anfb , = ( ) x 0 1 = ( ) y 0 0
> sol:=dsolve({dgls,anfb},{x(t),y(t)});
:= sol { } , = ( ) y t ( ) sin t = ( ) x t ( ) cos t
Es gibt jetzt mehrere Mglichkeiten, auf die Lsungen zuzugreifen, um sie z.B.
anschlieend zu zeichnen:
> rhs(sol[1]); rhs(sol[2]);
( ) sin t
( ) cos t
liefert das Gewnschte. Allerdings ist da wiederum die Reihenfolge nicht garantiert. Eine
andere Mglichkeit ist
> assign(sol);
> x(t);y(t);
( ) cos t
( ) sin t
> plot({x(t),y(t)},t=0..2*Pi);
Page 7
Es ist also zum Plotten nicht unbedingt ntig, mit unapply eine richtige Funktion aus dem
Ergebnis zu machen.
Beispiel: Gedmpfte Schwingung
> restart;
Das ist die DGL zweiter Ordnung, x ist die Auslenkung; die Dmpfung oder Reibung ist
proportional zur Geschwindigkeit ( ) ( ) D x t
> dgl:=(D@@2)(x)(t)+2*gamma*D(x)(t)+omega^2*x(t)=0;
:= dgl = + + ( ) ( ) ( ) D
( ) 2
x t 2 ( ) ( ) D x t
2
( ) x t 0
> anf:=x(0)=1,D(x)(0)=0; # x(t=0)=1, v(t=0)=0
:= anf , = ( ) x 0 1 = ( ) ( ) D x 0 0
> sol:=dsolve({dgl,anf},x(t));
:= sol = ( ) x t
1
2
( ) + %1 e
( ) ( ) ( ) ( ) + t
%1
1
2
( ) %1 e
( ) ( ) + ( ) ( ) + t
%1
Page 8
:= %1
2
2
> assign(sol);
> x(t);

1
2
( ) + %1 e
( ) ( ) ( ) ( ) + t
%1
1
2
( ) %1 e
( ) ( ) + ( ) ( ) + t
%1
:= %1
2
2
> x:=unapply(x(t),t,gamma,omega);
# immer gleich Funktion draus machen!
x ( ) , , t :=

1
2
( ) +
2
2
e
( ) ( ) ( ) ( ) + t

2
2
1
2
( )
2
2
e
( ) ( ) + ( ) ( ) + t

2
2
> plot(x(t,1/8,1),t=0..20); # so ist's schn plotbar
Numerische Lsung und graphische Darstellung
Ist nur eine numerische Lsung der DGl erwnscht oder mglich, kann man sich mit
Page 9
odeplot aus dem plots Packet behelfen. Dazu muss man aber in dsolve den Parameter
numeric angeben:
> restart;
> with(plots):
Wieder 'ne gedmpfte Schwingung, hier gleich Spezialfall , = 1 = 2
1
4
> dgl:=(D@@2)(x)(t) + D(x)(t)/4 + x(t)=0;
:= dgl = + + ( ) ( ) ( ) D
( ) 2
x t
1
4
( ) ( ) D x t ( ) x t 0
> anf:=x(0)=1,D(x)(0)=0;
:= anf , = ( ) x 0 1 = ( ) ( ) D x 0 0
> sol:=dsolve({dgl,anf},x(t),numeric);
:= sol proc( ) ... end rkf45_x
Was soll das? Zurckgegeben wird eine Prozedur zum Berechnen der Lsungen zu
beliebigen Zeitpunkten t:
> sol(1.0); # Lsung fr t = 1.0
(
(
, , = t 1.0 = ( ) x t .5757089568620288 =
t
( ) x t -.7446736249954592
Man erhlt fr jeden Wert von t eine Liste, in der die Zeit, der Wert von ( ) x t zu diesem
Zeitpunkt und der Wert der Ableitung aufgelistet sind. Bei Systemen oder DGln hherer
Ordnung stehen natrlich noch die anderen Gren in der Liste. Man kann jetzt entweder
selbst mittels dieser Liste sich eine Wertetabelle anlegen, z.B. mittels des Befehls seq (da
wir ja Zahlenwerte als Lsung haben, keine Funktion):
> seq([rhs(sol(i/10)[1]),rhs(sol(i/10)[2])],i=0..200):
und diese dann mittels plot anschauen:
> plot([%]); # Liste aller [t,x(t)] - Paare
Page 10
> seq([rhs(sol(i/10)[2]),rhs(sol(i/10)[3])],i=0..200):
plot([%]); # Liste aller [x(t),v(t)] - Paare
Page 11
Oder man benutzt Maples odeplot (ordinary differential equation) (geht aber nur mit t und
x(t), nicht mit den Ableitungen) :
> odeplot(sol,[t,x(t)],0..20,numpoints=200);
Page 12
Anhang fr Fortgeschrittene: das Paket DEtools
Wesentlich grere Darstellungsmglichkeiten bietet das Paket DEtools.
> restart;
> with(DEtools);
DEnormal DEplot DEplot3d DEplot_polygon DFactor Dchangevar GCRD , , , , , , , [
LCLM PDEchangecoords RiemannPsols abelsol adjoint autonomous bernoullisol , , , , , , ,
buildsol buildsym canoni chinisol clairautsol constcoeffsols convertAlg , , , , , , ,
convertsys dalembertsol de2diffop dfieldplot diffop2de eigenring , , , , , ,
endomorphism_charpoly equinv eta_k eulersols exactsol expsols exterior_power , , , , , , ,
formal_sol gen_exp generate_ic genhomosol hamilton_eqs indicialeq infgen , , , , , , ,
integrate_sols intfactor kovacicsols leftdivision liesol line_int linearsol matrixDE , , , , , , , ,
matrix_riccati moser_reduce mult newton_polygon odeadvisor odepde , , , , , ,
parametricsol phaseportrait poincare polysols ratsols reduceOrder regular_parts , , , , , , ,
regularsp riccati_system riccatisol rightdivision separablesol super_reduce , , , , , ,
symgen symmetric_power symmetric_product symtest transinv translate , , , , , ,
Page 13
untranslate varparam zoom , , ]
Wir wollen uns hier nur die Befehle DEplot und phaseportrait anschauen. Als Beispiel
wieder die Schwingungsgleichung von gerade eben.
> ?DEplot
> dgl:=(D@@2)(x)(t)+D(x)(t)/4+x(t)=0;
anf:=x(0)=1,D(x)(0)=0;
:= dgl = + + ( ) ( ) ( ) D
( ) 2
x t
1
4
( ) ( ) D x t ( ) x t 0
:= anf , = ( ) x 0 1 = ( ) ( ) D x 0 0
DEplot lst auch gleichzeitig die DGL. Die Syntax von DEplot ist gewhnungsbedrftig
- man muss eine Liste der Liste von Anfangsbedingungen bergeben, sprich [[anf]]:
> DEplot(dgl,x(t),t=0..20,[[anf]],stepsize=.05,
linecolor=red,thickness=1);
Man kann das ganze auch als ein System von 2 DGln erster Ordnung angeben, was ja bei
linearen DGLs geht; dadurch erhlt man zustzliche Gestaltungsmglichkeiten. Wie schon
erwhnt: physikalisch gesehen beschreibt die erste DGL das Verhalten der
Geschwindigkeit y, die zweite erkrt, was die Geschwindigkeit eigentlich ist:
Page 14
> dgls:=D(y)(t)+y(t)/4+x(t)=0,D(x)(t)=y(t);
anfb:=x(0)=1,y(0)=0;
:= dgls , = + + ( ) ( ) D y t
1
4
( ) y t ( ) x t 0 = ( ) ( ) D x t ( ) y t
:= anfb , = ( ) x 0 1 = ( ) y 0 0
Zunchst kann man die Position ( ) x t auftragen (Parameter scene):
> DEplot([dgls],[x(t),y(t)],t=0..20,[[anfb]],
scene=[t,x(t)],stepsize=.05,x=-1..1,
linecolor=red,thickness=0);
Ebenso knnte man die Geschwindigkeit ( ) y t behandeln. Hufig ist auch ein sogenanntes
Phasenportrait sinnvoll, bei dem ( ) y t gegen ( ) x t aufgetragen wird (siehe oben). Dazu kann
man die Option scene richtig whlen oder den Befehl phaseportrait benutzen.
> DEplot([dgls],[x(t),y(t)],t=0..20,[[anfb]],
scene=[x(t),y(t)],
stepsize=.05,x=-1..1,y=-1..1,
scaling=constrained,linecolor=black,
Page 15
thickness=2,arrows=NONE);
> phaseportrait([dgls],[x(t),y(t)],t=0..20,[[anfb]],
stepsize=.05,x=-1..1,y=-1..1,
scaling=constrained,linecolor=black,thickness=1);
Page 16
Eine alternative Formulierung wre:
> phaseportrait([dgls],[x(t),y(t)],t=0..5,{[0,2,1]},
scaling=constrained,linecolor=black);
Page 17
Hier wird statt [x(0)=2,y(0)=1] die Kurzform [0,2,1] verwendet und in eine
Mengen-Klammer gepackt (Anfangsbedingung: t=0, x(t=0)=2, y(t=0)=1). Eine Folge von
Anfangsbedingungen lsst sich jetzt mit dem seq-Befehl erzeugen:
> start:=seq([0,0,n/10],n=1..10);
start

(
(
, , 0 0
1
10
(
(
, , 0 0
1
5
(
(
, , 0 0
3
10
(
(
, , 0 0
2
5
(
(
, , 0 0
1
2
(
(
, , 0 0
3
5
(
(
, , 0 0
7
10
, , , , , , , :=
(
(
, , 0 0
4
5
(
(
, , 0 0
9
10
[ ] , , 0 0 1 , ,
und in phaseportrait einsetzen.
> phaseportrait([dgls],[x(t),y(t)],t=0..5,{start},
scaling=constrained,linecolor=black);
Page 18
Und hier das Ganze noch mit einer ueren treibenden Kraft:
> dgls := D(y)(t)+y(t)/4+x(t)=2*cos(3*t) , D(x)(t)=y(t);
:= dgls , = + + ( ) ( ) D y t
1
4
( ) y t ( ) x t 2 ( ) cos 3 t = ( ) ( ) D x t ( ) y t
> anfb := [0,1,0],[0,0,1];
:= anfb , [ ] , , 0 1 0 [ ] , , 0 0 1
> phaseportrait([dgls],[x(t),y(t)],t=0..50,{anfb},
stepsize=.05,x=-1..1.1,y=-2..1.5,
linecolor=[red,blue],thickness=1);
Page 19
>
Trotz der unterschiedlichen Anfangsbedingungen erhlt man fr lange Zeiten den gleichen
stationren Endzustand.
Page 20
Einfhrung in Maple
Kap. 1: Grundlagen
Programmierung und Prozeduren
Hinfhrung
Jedes grere Softwarepaket erlaubt Programmierung, auch Microsoft Word z.B.. Dadurch
lassen sich Vorhnge automatisieren, die sonst mhevoll in vielen Einzelschritten
eingegeben werden mssen. Jedes System benutzt i.d.R. seine eigene Syntax, so dass ein
gewisser Lernaufwand ntig ist. Das groe Problem fr Programmieranfnger ist aber nicht
die Syntax, sondern die Umsetzung eines geistigen Konzeptes in die Elemente der
Programmierung wie Schleifen, Bedingungen usw.. Wenn Sie als Programmierneuling dies
hier gleich lernen, werden Sie sich in Zukunft bei jeder beliebigen Programmiersprache sehr
leicht tun. dazu soll dieser Abschnitt hilfreich sein.
Beispiel: finde die Primzahlen zwischen 2 und N durch ganzzahliges Zahlen. Fr eine
Integerzahl i muss also berprft werden, ob sie durch 2, 3, 4, ... i-1 ohne Rest ganzzahlig
teilbar ist. Wenn das mit keiner dieser Zahlen mglich ist, ist sie eine Primzahl. Also sind
die Einzelschritte so:

| Gehe alle Integer-Zahlen i durch von 2 bis N: i = 2,3,4,5,....,N
| ---- nehme an, i sei Primzahl (PZ)
| ---- gehe zum Testen alle Integer-Zahlen t durch von 2 bis t-1: t = 2,3,4,5,...i-1
| -------- ist i ganzzahlig ohne Rest durch t teilbar, ist i keine PZ, setzte Annahme auf falsch
| ---- wenn Annahme "i ist Primzahl" am Ende immer noch richtig ist, drucke i als Primzahl
| ---- Ende "gehe zum Testen alle Integer-Zahlen t durch von 2 bis i-1: t = 2,3,4,5,...i-1"
| Ende "Gehe alle Integer-Zahlen i durch von 2 bis N: i = 2,3,4,5,....,N"
Dies formulieren wir jetzt in der Progarmmiersprache von Maple:
> N:=10; # zum Ausprobieren erst mal kleine Zahl
Page 1
:= N 10
> for i from 2 to N do
prim:=1;
for t from 2 to i-1 do
if (i mod t)=0 then prim:=0; fi;
od;
if prim=1 then print("Primzahl: ",i); fi;
od:
, "Primzahl: " 2
, "Primzahl: " 3
, "Primzahl: " 5
, "Primzahl: " 7
Bedingungen und Schleifen
Maple kennt die blichen Programmierstrukturen if, while, for, break Wer bereits in C
programmieren kann, wird sich zunchst in Maple etwas schwertun: die Syntax ist leider
ziemlich unterschiedlich.
if Bedingung1 then ...
[elif Bedingung2 then ...]
.
[else Bedingung3 ...]
fi;

while Bedingung do
.
od;
Beispiele:
> restart:
> j:=5; # bitte mit verschiedenen Werten ausprobieren!
:= j 5
> if j<0 then
print("Jetzt ist j negativ");
elif j=0 then
print("Diesmal ist j=0"):
else
print("Aber jetzt ist j positiv"):
fi:
"Aber jetzt ist j positiv"
print druckt einfach sein Argument aus und schert sich nicht um den
Kommandoabschluss. brigens: Schleifen und Bedingungen mssen alle in einer
Maplezeile stehen. Um das ganze etwas bersichtlicher zu gestalten, kann man nach einer
logischen Einheit per SHIFT-RETURN einen Zeilenumbruch erzwingen, ohne das Maple
Page 2
mit der Auswertung beginnt und eine neue Maplezeile anfngt.
Ein etwas schwierigeres Beispiel. Es soll die quadratische Gleichung = + + a x
2
b x c 0
gelst werden. Hier gibt es je nach Wert der Koeffizienten eine, zwei oder gar keine rellen
Lsungen. Das folgende Beispiel zeigt, was mit verschachtelten if / elif / else / if -
Konstrukten mglich ist. In der Praxis sollte man aber besser etwas bersichtlicher
programmieren!
> f:=a*x^2+b*x+c;
:= f + + a x
2
b x c
> solve(f=0,x);
,
1
2
+ b b
2
4 a c
a
1
2
b b
2
4 a c
a
Diese Lsungen taugen nichts, wenn = a 0 ist. Es soll nun eine vernnftige
Fallunterscheidung durchfhrt werden.
> a:=1; b:=3; c:=1; # zum Test: 2 reelle Lsungen
:= a 1
:= b 3
:= c 1
> a:=1; b:=3; c:=10; # weiterer Test: keine reelle Lsung
:= a 1
:= b 3
:= c 10
> a:=2; b:=4; c:=2; # und hier gibt's nur eine
:= a 2
:= b 4
:= c 2
> if a=0 then
if b=0 then
if c=0 then
print(`Diese Gleichung wird fr alle x
gelst!`);
x1:='x1';x2:='x2'; # vergiss eventuelle alte
Lsungen
else
print("Keine Lsung"); # 0*x^2+0*x+3 = 0 geht
nicht
x1:='x1';x2:='x2';
fi;
else # wenn also b<>0 ist bei a=0: lineare
Gleichung
print("Es gibt nur eine Lsung x1");
x1 := -c/b; x2 := 'x2';
fi;

Page 3
# jetzt ist a<>0
elif b^2-4*a*c<0 then
print("Es gibt keine reelle Lsung");
x1:='x1';x2:='x2';
elif b^2-4*a*c=0 then
print("Es gibt nur eine Lsung x1=x2 (doppelte
Nullstelle)");
x1 := -b/(2*a);x2 := x1;
else
print("Es gibt genau 2 reelle Lsungen x1,x2");
x1 := (-b-sqrt(b^2-4*a*c))/(2*a);
x2 := (-b+sqrt(b^2-4*a*c))/(2*a);
fi:
"Es gibt nur eine Lsung x1=x2 (doppelte Nullstelle)"
> x1;
-1
> x2;
-1
Mehrere Bedingungen knnen mit den logischen Operatoren or bzw. and verkpft. Will
man also Zahlen zwischen 2 und 5 haben, so macht man das folgendermaen:
> restart; x:=7;
:= x 7
> if x>=-2 and x<=5 then
print(x);
else
print("Diese Zahl liegt auerhalb!");
fi;
"Diese Zahl liegt auerhalb!"
Nun eine einfache Anweisung mithilfe einer while-Schleife:
> i:=1.1;
while i<10 do
i:=i^2;
od;
:= i 1.1
:= i 1.21
:= i 1.4641
:= i 2.14358881
:= i 4.594972986
:= i 21.11377674
Allgemeine Struktur fr for-Schleifen:
for Name from Start [by Step] to End do
.
od;
Page 4
Man beachte jeweils das Semikolon am Ende! Man kann hier auch einen Doppelpunkt
setzen; allerdings wird dann kein Zwischenergebnis aus der Schleife ausgegeben.
Beispiele:
> restart;
> for i from -2 by 5 to 18 do
j:=i^2;
od;
:= j 4
:= j 9
:= j 64
:= j 169
:= j 324
Dasselbe nochmal mit Doppelpunkt am Ende bei od:
j:=i^2;
od:
> j;
324
Das Semikolon nach der Anweisung innerhalb der Schleife ist vllig ohne Belang; es zhlt
nur, wie die Schleife abgeschlossen wurde.
j:=i^2:
print(j):
od:
4
9
64
169
324
Was auch geht:
> for i from -0.17 to +0.08 by 0.09 do print(i) od:
>
-.17
-.08
.01
The break construct (Zitat aus der Online-Hilfe):
When the special name break is evaluated, the result is to exit from the innermost
repetition (for/while/do) statement within which it occurs.
After exit, execution proceeds with the first statement following the repetition statement.
>
Prozeduren
Prozeduren erlauben ein Zusammenfassen von einzelnen Schritten mit Parameterbergabe,
Page 5
lokaler und globaler Parameterdefinition etc.:
name := proc(arglist) SHIFT-RETURN
global globale Variablen; SHIFT-RETURN
local lokale Variablen; SHIFT-RETURN
Befehle; SHIFT-RETURN
end; RETURN
Lokale und globale Variablen werden weiter unten erlutert, hier zunchst mal eine Beispiel
ohne eigene Variable in der Prozedur:
> restart:
Betrachten wir zum Beispiel die folgende Definition. Bisher haben wir mit dem ->
Operator daraus eine Funktion gemacht (die Maple brigens intern als Prozedur ablegt):
> f:=x->sin(x)/x;
:= f x
( ) sin x
x
> f(1);
( ) sin 1
> f(0);
Error, (in f) division by zero
Dies ist wohlgemerkt kein Fehler, der Funktionswert ist fr = x 0 tatschlich nicht
definiert. Es ist aber bekannt, dass der Grenzwert fr existiert und 1 ist. Damit kann man
diese Funktion stetig fortsetzen. Diese stetige Fortsetzung soll durch folgende Prozedur f
definiert werden.
> f := proc(x)
if (abs(x)< 0.00001) then
# das reicht fr die geg. Genauigkeit von Digits:=10 aus
1;
else
sin(x)/x;
fi
end;
:= f proc( ) end x if then else fi < ( ) abs x .00001 1 / ( ) sin x x
> f(1);
( ) sin 1
> f(0);
1
> plot(sin(x)/x,x=-1..1);
Page 6
Wie wir sehen, wird Maple beim Plotten meist mit den Singularitten von selbst fertig.
Jetzt plotten wir mal unsere Prozedur:
> plot(f(x),x=-1..1);
Error, (in f) cannot evaluate boolean
Wenn man Funktionen, die durch Prozeduren definiert sind, plotten will, muss man die
Namen in Anfhrungszeichen setzen, damit der Plot-Befehl auch erfhrt, was unsere
Funktion wirklich ist.
> plot('f(x)',x=-1..1);
Page 7
brigens sind die meisten Maplefunktionen selbst als Prozeduren realisiert und knnen
auch angesehen werden:
> interface(verboseproc=2): # set or query user interface
variables
> print(abs);
proc() end option ; builtin 72
abs ist eine der vorkompilierten Funktionen und kann von Maple nicht weiter
aufgeschlsselt werden.
> print(cos); # dieser Output verschwindet gerne ...
proc( ) ... end :: x algebraic
> interface(verboseproc=0):
> print(cos);
proc( ) ... end :: x algebraic
RETURN( ) (komplett gross geschrieben, mit Klammern) gibt sein Argument aus und
beendet die Prozedur. In Maple ist aber der Befehl nicht zwingend notwendig, wie wir
bereits gesehen haben. Wir verwenden ihn hauptschlich zum 'Notausstieg', siehe
Beispiele weiter unten. Zuvor noch eine kleine Warnung: der bergebenen Variablen kann
im Unterprogramm kein Wert zugewiesen werden:
> gehtnicht:=proc(x)
x:=17;
end;
:= gehtnicht proc( ) end x := x 17
> gehtnicht(3);
Page 8
Error, (in gehtnicht) illegal use of a formal parameter
Manchmal ist es wichtig zu testen, ob auch die richtigen Datentypen an den richtigen
Stellen bergeben wurden. Dann sollte man folgende Form des proc-Befehls verwenden:
name := proc(x::typ1,y::typ2,...)

Fr zulssige Typen siehe ?type. Nehmen wir als Beispiel die Fibonacci-Zahlen:
> fibon := proc(x::nonnegint)
if x=0 then 0
elif x=1 then 1
else fibon(x-1)+fibon(x-2) fi;
end;
fibon :: x nonnegint proc( ) :=
if then elif then else fi = x 0 0 = x 1 1 + ( ) fibon x 1 ( ) fibon x 2
end
> fibon(0);fibon(1);fibon(2); fibon(10);
0
1
1
55
> fibon(-1);
Error, fibon expects its 1st argument, x, to be of type nonnegint, but
received -1
> fibon(25);
75025
Fr groe Argumente scheitert die Berechnung. Grund: In diesem Programm wird die
Prozedur rekursiv aufgerufen. Das ist zwar sehr elegant programmiert, aber kostet enorm
viel Speicherplatz fr die Buchfhrung. Deshalb besser rekursive Funktionsaufrufe
vermeiden.
> restart;
> fibon := proc(n::nonnegint)
local v,m;
v:=array(0..n+1); # Dimensionierung zur Laufzeit geht!
v[0]:=0; v[1]:=1;
if n>1 then
for m from 2 to n do
v[m]:=v[m-1]+v[m-2];
od;
fi;
v[n]
end:
> fibon(0);fibon(1);fibon(2);
0
1
1
Page 9
Auch grere Zahlen sind hier kein Problem:
> fibon(25);fibon(100);
75025
354224848179261915075
Wozu sind globale und lokale Variablen gut? Ein Beispiel:
> test1:=proc(x,n)
local i,j;
for i from 0 to n do
print(sum(x^j,j=0..i));
od;
end:
> test2:=proc(x,n)
global i,j;
for i from 0 to n do
print(sum(x^j,j=0..i));
od;
end:
> i:='i':j:='j':x:=100: test1(x,4); i;
1
101
10101
1010101
101010101
i
> i:='i':j:='j':x:=100: test2(x,4); i;
1
101
10101
1010101
101010101
5
Die lokale Variable i wird bei test1 nur intern verwendet, nach Ausfhrung der
Anweisungen und Rcksprung ins Hauptprogramm ist i nicht mehr definiert. Bei globalen
Variablen gilt gerade das Gegenteil.
Achtung: Alle nicht explizit deklarierten Variablen werden von Maple als lokal
aufgefasst, wenn sie der Laufindex einer for-Schleife, einer seq-Anweisung oder auf der
linken Seite einer Zuweisung stehen. Alle weiteren Variablen werden global verwendet (in
alten Maple-Versionen vor VR5 war das schon mal anders..). Es ist guter Stil, alle
verwendeten Variablen zu deklarieren, damit man keine unliebsamen berraschungen
erlebt. Wenn man es vergit, gibt Maple auch i.d.R. eine Warnung aus.
Page 10
> i:='i':j:='j':x:='x': test2(x,4); # Aufruf mit
undefiniertem x
1
+ 1 x
+ + 1 x x
2
+ + + 1 x x
2
x
3
+ + + + 1 x x
2
x
3
x
4
Dies Beispiel zeigt ganz nett: wird einer Maple-Prozedur eine nicht belegte Variable
bergeben (hier x), so arbeitet Maple einfach mit dieser allgemeinen Variable weiter.
Variable Argumentenliste
Sollte man einmal nicht wissen, wieviele Variablen und welchen Typ man bentigt - kein
Problem. Maple legt automatisch eine Liste args der bergebenen Parameter an und
speichert in nargs die Zahl der Elemente:
> restart;
> test := proc() # gar kein Argument hinschreiben
local i;
if nargs <> 2 then
print("Falsche Anzahl von Argumente");
RETURN();
fi;
if not type(args[2],nonnegint) then
print("Zweites Argument muss eine nicht negative ganze
Zahl sein");
RETURN();
fi;
print(sum(args[1]^j,j=0..args[2]));
end:
> test(x,3);
+ + + 1 x x
2
x
3
> test(x);test(x,y,2);
"Falsche Anzahl von Argumente"
"Falsche Anzahl von Argumente"
> test(x,-1);
"Zweites Argument muss eine nicht negative ganze Zahl sein"
>
Page 11
Einfhrung in Maple
Kap. 1: Grundlagen
Lineare Algebra
Arrays
Den Typ array (ein weiterer Datentyp wie Mengen, Folgen und Listen) hatten wir schon
kurz kennengelerent. Ein eindimensionales Feld mit 4 Elementen wird z.B. definiert durch
> restart;
> a:=array(-1..2);
:= a ( ) array , .. -1 2 [ ]
Dabei ist 1 der erste und 2 der letzte Indexwert. Den einzelnen Elementen knnen Werte
zugeordnet werden durch
> a[-1]:=1;a[0]:=2; a[1]:=4;a[2]:=5;
:= a
-1
1
:= a
0
2
:= a
1
4
:= a
2
5
Den Inhalt kann man mit print oder mit eval anzeigen:
> eval(a);
.. -1 2 array( , [
= ( ) -1 1
= ( ) 0 2
= ( ) 1 4
= ( ) 2 5
])
> print(a);
.. -1 2 array( , [
Page 1
= ( ) -1 1
= ( ) 0 2
= ( ) 1 4
= ( ) 2 5
])
Statt der umstndlichen Zuweisung jedes einzelnen Elements kann man in der array -
Anweisung auch eine Liste als zweites Argument angeben.
> a:=array(-1..2,[1,2,4,5]):
> eval(a);
.. -1 2 array( , [
= ( ) -1 1
= ( ) 0 2
= ( ) 1 4
= ( ) 2 5
])
Das kommt jetzt in Tabellenform heraus. Anders wre es, wenn nur Indizes von 1 bis zu
einer weiteren natrlichen Zahl vorkommen:
> b:=array(1..3,[1,2,3]);
:= b [ ] , , 1 2 3
dann kommt es als Spaltenvektor heraus. Analog kann man auch mehrdimensionale Felder
definieren.
> array(1..2,1..2,[[1,2],[3,5]]);
# erst Zeilen, dann Spalten
((
1 2
3 5
Vektoren und Matrizen
Vektoren und Matrizen sind in Maple Spezialflle des allgemeineren Datentyps array. Bei
ihnen sind die Elemente automatisch von 1 an numeriert. Dafr kann man damit eine
Menge Operationen anstellen, z. B. Skalarprodukte bilden, wofr man mit array Schleifen
braucht. Die Operationen sind erst nach Aktivierung eines Zusatzpaketes verfgbar. Bei
neueren Maple-Versionen gibt es ein Paket mit Namen LinearAlgebra. Wir verwenden
aber das klassische, bei allen Versionen verfgbare Paket linalg:
> restart:
> with(linalg);
Warning, new definition for norm
Warning, new definition for trace
BlockDiagonal GramSchmidt JordanBlock LUdecomp QRdecomp Wronskian , , , , , , [
addcol addrow adj adjoint angle augment backsub band basis bezout , , , , , , , , , ,
blockmatrix charmat charpoly cholesky col coldim colspace colspan companion , , , , , , , , ,
concat cond copyinto crossprod curl definite delcols delrows det diag diverge , , , , , , , , , , ,
dotprod eigenvals eigenvalues eigenvectors eigenvects entermatrix equal , , , , , , ,
exponential extend ffgausselim fibonacci forwardsub frobenius gausselim , , , , , , ,
Page 2
gaussjord geneqns genmatrix grad hadamard hermite hessian hilbert htranspose , , , , , , , , ,
ihermite indexfunc innerprod intbasis inverse ismith issimilar iszero jacobian , , , , , , , , ,
jordan kernel laplacian leastsqrs linsolve matadd matrix minor minpoly mulcol , , , , , , , , , ,
mulrow multiply norm normalize nullspace orthog permanent pivot potential , , , , , , , , ,
randmatrix randvector rank ratform row rowdim rowspace rowspan rref , , , , , , , , ,
scalarmul singularvals smith stackmatrix submatrix subvector sumbasis swapcol , , , , , , , ,
swaprow sylvester toeplitz trace transpose vandermonde vecpotent vectdim , , , , , , , ,
vector wronskian , ]
Bei vector und matrix starten die Indizes grundstzlich bei 1. Deshalb knnen sie so
definiert
> V:=vector(3);
:= V ( ) array , .. 1 3 [ ]
und beschrieben werden
> V:=vector(3,[vx,vy,vz]);
:= V [ ] , , vx vy vz
> V[1];
vx
Ob eine Variable den gewnschten Datentyp aufweist, kann man mithilfe der Funktion
type berprfen.
> v:=array(-1..1,[1,2,3]):
> type(v,vector);
false
> type(V,vector);
true
So geht es natrlich auch (Arrays, die mit dem Index 1 anfangen, sind Vektoren bzw.
Matrizen):
> v:=array(1..3,[vx,vy,vz]);
:= v [ ] , , vx vy vz
> type(v,vector);
true
array lsst also einen wesentlich greren Spielraum in der Indizierung zu.

Wie rechnet man nun aber mit Vektoren in Maple?
> w:=vector(3,[wx,wy,wz]);
:= w [ ] , , wx wy wz
> w+v;
+ w v
Aha! So anscheinend nicht. Aber so:
> evalm(v+w);
[ ] , , + wx vx + wy vy + wz vz
oder:
> matadd(v,w);
Page 3
[ ] , , + wx vx + wy vy + wz vz
> evalm(v-w);
[ ] , , vx wx vy wy vz wz
> evalm(v*w);
Error, (in evalm/evaluate) use the &* operator for matrix/vector
multiplication
Die Multiplikation zweier Vektoren funktioniert also offensichtlich nicht mit dem
blichen *, sondern folgendermaen:
> evalm(v &* w);
+ + vx wx vy wy vz wz
oder
> multiply(v,w);
+ + vx wx vy wy vz wz
> evalm(2*v+w);
[ ] , , + 2 vx wx + 2 vy wy + 2 vz wz
Der bliche Multiplikationsoperator * ist in evalm der Multiplikation mit Skalaren
vorbehalten.
Weitere wichtige Operationen fr Vektoren sind die Berechnung der Norm eines Vektors
bzw. die Normierung eines Vektors auf die Norm 1. Dazu dienen die Funktionen norm
und normalize.
> norm(v);
( ) max , , vy vx vz
Das ist aber nicht die Standard-Norm, die man normalerweise kennt. Maple verwendet
ohne Angabe weiterer Optionen die sogenannte Maximum-Norm. Die bliche Norm
bekommt mit der zustzlichen Option 2:
> norm(v,2);
+ + vx
2
vy
2
vz
2
Die Normierung eines Vektors verwendet aber erstaunlicherweise ohne weitere Optionen
die Standard-Norm:
> ev := normalize(v);
:= ev

(
(
, ,
vx
%1
vy
%1
vz
%1
:= %1 + + vx
2
vy
2
vz
2
> assume(vx,real,vy,real,vz,real);
> norm(ev,2);
+ +
vx
%1
2
vy
%1
2
vz
%1
2
:= %1 + + vx
2
vy
2
vz
2
> simplify(%);
1
Multipliziert man v mit dem Transponierten von w statt mit w, so erhlt man eine Matrix,
Page 4
die das dyadische Produkt bzw. das Tensorprodukt der beiden Vektoren angibt:
> multiply(v,transpose(w));
(
(
((
vx wx vx wy vx wz
vy wx vy wy vy wz
vz wx vz wy vz wz
und so weiter. Statt evalm kann man auch matadd und multiply benutzen. Was kann
Maple noch mit Vektoren anstellen?
> z:= crossprod(v,w);
:= z [ ] , , vy wz vz wy vz wx vx wz vx wy vy wx
Dieser Vektor ist automatisch orthogonal zu v und w:
> multiply(z,v);
+ + ( ) vy~ wz vz~ wy vx~ ( ) vz~ wx vx~ wz vy~ ( ) vx~ wy vy~ wx vz~
> simplify(%);
0
Analog zu den Vektoren werden Matrizen auf ganz hnliche Weise erzeugt:
> A:=matrix(3,3,[a11,a12,a13 , a21,a22,a23 , a31,a32,a33]);
:= A
(
(
((
a11 a12 a13
a21 a22 a23
a31 a32 a33
Wir sehen: Maple ist bei Matrizen toleranter als bei Arrays. Eigentlich mte die
Deklaration so ausschauen:
> A:=matrix(3,3,[[a11,a12,a13],[a21,a22,a23],[a31,a32,a33]])
;
:= A
(
(
((
a11 a12 a13
a21 a22 a23
a31 a32 a33
Ansprechen einzelner Matrixelemente:
> evalm(A[2,3]); # richtig
a23
> evalm(A[2][3]); # falsch
Error, array defined with 2 indices, used with 1 indices
Rechenoperationen (benutze wieder evalm), deren Namen meist selbsterklrend sind:
> transpose(A);
(
(
((
a11 a21 a31
a12 a22 a32
a13 a23 a33
> Ai := inverse(A);
Page 5
:= Ai
(
(
(
(
(
(
(
(
(
(
(
+ a22 a33 a23 a32
%1
+ a12 a33 a13 a32

%1
a12 a23 a13 a22

%1
a21 a33 a23 a31
%1
a11 a33 a13 a31

%1
a11 a23 a13 a21
%1
a21 a32 a22 a31

%1
a11 a32 a12 a31
%1
a11 a22 a12 a21

%1
%1 a11 a22 a33 a11 a23 a32 a21 a12 a33 a21 a13 a32 a31 a12 a23 + + :=
a31 a13 a22 +
> multiply(A,Ai);
+
a11 ( ) + a22 a33 a23 a32
%1
a12 ( ) a21 a33 a23 a31
%1
a13 ( ) a21 a32 a22 a31
%1
a11 ( ) + a12 a33 a13 a32

%1
a12 ( ) a11 a33 a13 a31
%1
,
a13 ( ) a11 a32 a12 a31
%1
+ ,
+
a11 ( ) a12 a23 a13 a22
%1
a12 ( ) a11 a23 a13 a21
%1
a13 ( ) a11 a22 a12 a21
%1
(
(
(
+
a21 ( ) + a22 a33 a23 a32
%1
a22 ( ) a21 a33 a23 a31
%1
a23 ( ) a21 a32 a22 a31
%1
a21 ( ) + a12 a33 a13 a32

%1
a22 ( ) a11 a33 a13 a31
%1
,
a23 ( ) a11 a32 a12 a31
%1
+ ,
+
a21 ( ) a12 a23 a13 a22
%1
a22 ( ) a11 a23 a13 a21
%1
a23 ( ) a11 a22 a12 a21
%1
(
(
(
+
a31 ( ) + a22 a33 a23 a32
%1
a32 ( ) a21 a33 a23 a31
%1
a33 ( ) a21 a32 a22 a31
%1
a31 ( ) + a12 a33 a13 a32

%1
a32 ( ) a11 a33 a13 a31
%1
,
a33 ( ) a11 a32 a12 a31
%1
+ ,
+
a31 ( ) a12 a23 a13 a22
%1
a32 ( ) a11 a23 a13 a21
%1
a33 ( ) a11 a22 a12 a21
%1
(
(
(
Page 6
%1 a11 a22 a33 a11 a23 a32 a21 a12 a33 a21 a13 a32 a31 a12 a23 + + :=
a31 a13 a22 +
> simplify(%);
(
(
((
1 0 0
0 1 0
0 0 1
Ab und zu muss man halt etwas nachhelfen!
Natrlich kann Maple auch noch ganz andere Dinge anstellen, z. B. die Determinante
berechnen:
> restart; with(linalg):
B:=matrix(3,3,[[1,-1,sqrt(2)],
[-1,4,sqrt(2)],[sqrt(2),sqrt(2),2]]);
:= B
(
(
(
(
1 -1 2
-1 4 2
2 2 2
> det(B);
-8
Noch 'ne wichtige Anmerkung: Manchmal verhlt sich Maple seltsam bei der Ausgabe
oder Rckgabe (bei Prozeduren) oder Zuweisung von Vektoren und Matrizen oder auch
deren Elementen - es will den realen Inhalt einfach nicht herausrcken, sondern gibt nur
allgemeine Variablennamen aus. Abhilfe: Objekte wie Matrix/Vektor/Element immer mit
evalm(Matrix), evalm(Vector), evalm(Element) referenzieren.
Lineare Gleichungssysteme
Mit Matrizen und Vektoren lassen sich selbstverstndlich auch lineare
Gleichungssysteme erstellen und lsen. Beispiel zunchst 'klassisch':
> eq:=x-y+sqrt(2)*z=1,
-x+4*y+sqrt(2)*z=0,
sqrt(2)*x+sqrt(2)*y+2*z=-2;
:= eq , , = + x y 2 z 1 = + + x 4 y 2 z 0 = + + 2 x 2 y 2 z -2
> solve({eq},{x,y,z});
{ } , , = z +
5
8
2
3
4
= x
3
4
5
4
2 = y
1
2
1
2
2
Jetzt mit dem linalg - Paket:
> v:=vector(3,[1,0,-2]);
:= v [ ] , , 1 0 -2
> erg:=linsolve(B,v);
:= erg

(
(
, ,
3
4
5
4
2
1
2
1
2
2 +
5
8
2
3
4
Man sollte die Lsung kontrollieren:
Page 7
> multiply(B,erg);
+
1
4
3
4
2 2
|
\
|
.
|
|
+
5
8
2
3
4
+
5
4
3
4
2 2
|
\
|
.
|
|
+
5
8
2
3
4
, ,
+ + + 2
|
\
|
.
|
|

3
4
5
4
2 2
|
\
|
.
|
|

1
2
1
2
2
5
4
2
3
2
(
(
(
> simplify(%);
[ ] , , 1 0 -2
Bekanntlich hat das Gleichungssystem zumindest keine eindeutige Lsung wenn die
Determinante verschwindet, wenn also die Zeilen bzw. die Spalten linear abhngig sind:
> C:= matrix(3,3,[[1,2,3],[4,5,6],[5,7,9]]);
:= C
(
(
((
1 2 3
4 5 6
5 7 9
> det(C);
0
> x:=linsolve(C,v);
:= x
Maple schweigt sich aus! Etwas anderes ist es, wenn die rechte Seite richtig gewhlt wird:
> x:=linsolve(C,vector(3,[1,0,1]));
:= x

(
(
, , +
5
3
_t
1

4
3
2 _t
1
_t
1
dann erhlt man einen 1-dimensionalen Lsungsraum. Im ersten Fall ist also das
Gleichungssystem unlsbar, im zweiten Fall gibt es aber eine Schar von Lsungen.
> multiply(C,x);
[ ] , , 1 0 1
>
Eigenwerte und Eigenvektoren
Besonders wichtig ist Maples Eigenwertroutine. Die Aufgabe: Finde zu einer Matrix A
die Vektoren v und die Zahlen , fr die gilt:
= A v v
Zunchst kann man sich einmal das charakteristische Polynom ansehen:
> A:=matrix(3,3,[a11,a12,a13 , a21,a22,a23 , a31,a32,a33]);
:= A
(
(
((
a11 a12 a13
a21 a22 a23
a31 a32 a33
> charpoly(A,lambda);
2
a33 a22
2
a22 a33 a23 a32 a11
2
a11 a33 a11 a22 + + +
a11 a22 a33 a11 a23 a32 a21 a12 a21 a12 a33 a21 a13 a32 + +
Page 8
a31 a12 a23 a31 a13 a31 a13 a22 +
Die meistens verwendete Konvention ist, dass das charakteristische Polynom durch
( ) det A E mit der Einheitsmatrix E gegeben ist. Maple verwendet statt dessen
( ) det E A , was bei der Dimension n lediglich zu einem Vorfaktor ( ) 1
n
fhrt. Da die
Eigenwerte durch die Nullstelle dieses Polynoms in gegeben sind, spielt dieses
eventuell unterschiedliche Vorzeichen keine Rolle.
Der korrekte Befehl zur Berechnung der Eigenwerte und -vektoren wre jetzt eigenvals(A)
bzw. eigenvects(A). Da unser charakteristisches Polynom vom Grade 3 ist, kann Maple
das noch exakt (bis zum Grade 4) und gibt entsprechend ca. 17 Seiten Formeln aus. Man
kann das verhindern, wenn man die Option implicit angibt:
> eigenvals(A,implicit);
RootOf _Z
3
( ) a11 a22 a33 _Z
2
+ (
( ) + + + a21 a12 a11 a33 a13 a31 a22 a33 a11 a22 a23 a32 _Z a11 a22 a33 +
a31 a13 a22 a21 a12 a33 a11 a23 a32 a31 a12 a23 a21 a13 a32 + + + )
Ausgeben lassen knnte man sich das jetzt wieder mit allvalues ... Jetzt aber ein konkretes
Beispiel
> B:=matrix(5,5,[[2,1,0,0,0],[1,2,1,0,0],[0,1,2,1,0],
[0,0,1,2,1],[0,0,0,1,2]]);
:= B
(
(
(
(
(
(
(
(
2 1 0 0 0
1 2 1 0 0
0 1 2 1 0
0 0 1 2 1
0 0 0 1 2
> eigenvals(B);
, , , , 1 2 3 + 2 3 2 3
Das sieht ja recht kompakt aus. Versuchen wir es doch auch einmal mit den
Eigenvektoren:
> eigenvects(B);
[ ] , , 1 1 { } [ ] , , , , -1 1 0 -1 1 [ ] , , + 2 3 1 { } [ ] , , , , 1 3 2 3 1 , ,
[ ] , , 2 3 1 { } [ ] , , , , 1 3 2 3 1 [ ] , , 2 1 { } [ ] , , , , 1 0 -1 0 1 , ,
[ ] , , 3 1 { } [ ] , , , , -1 -1 0 1 1
Die Struktur der Liste ist Folgende:
[Eigenwert, Multiplizitt, {Eigenvektor1, Eigenvektor2, ...}], ...
Ein groes Problem bei Maple ist, dass es leider die Eigenwerte nicht nach der Gre
sortiert; zudem ist bei 2 aufeinanderfolgenden Aufrufen nicht garantiert, dass man dieselbe
Reihenfolge der Eigenwerte erhlt:
> eigenvects(B);
[ ] , , 2 1 { } [ ] , , , , 1 0 -1 0 1 [ ] , , + 2 3 1 { } [ ] , , , , 1 3 2 3 1 , ,
[ ] , , 2 3 1 { } [ ] , , , , 1 3 2 3 1 [ ] , , 1 1 { } [ ] , , , , -1 1 0 -1 1 , ,
[ ] , , 3 1 { } [ ] , , , , -1 -1 0 1 1
Noch unangenehmer: Selbst die Reihenfolge der Eigenvektoren innerhalb eines entarteten
Page 9
Unterraumes kann sich von Aufruf zu Aufruf ndern. Die Weiterverarbeitung muss daher
immer interaktiv erfolgen.Trotzdem soll hier eine Methode diskutiert werden, wie man die
nichtentarteten Eigenvektoren herausfiltert.
> ev:=eigenvects(B);
ev [ ] , , 1 1 { } [ ] , , , , -1 1 0 -1 1 [ ] , , + 2 3 1 { } [ ] , , , , 1 3 2 3 1 , , :=
[ ] , , 2 3 1 { } [ ] , , , , 1 3 2 3 1 [ ] , , 2 1 { } [ ] , , , , 1 0 -1 0 1 , ,
[ ] , , 3 1 { } [ ] , , , , -1 -1 0 1 1
> ev[1];
[ ] , , 1 1 { } [ ] , , , , -1 1 0 -1 1
Dies liefert den ersten Term der Folge. Das erste Element davon ist der Eigenwert:
> ev[1][1];
1
Das dritte Element davon ist der Eigenvektor:
> ev[1][3];
{ } [ ] , , , , -1 1 0 -1 1
aber noch in Mengenklammer - im Falle der Entartung gibt es mehrere Eigenvektoren, hier
gibt es nur einen. Diesen bekommt man mit
> ev[1][3][1];
[ ] , , , , -1 1 0 -1 1
Wir knnen jetzt die Eigenwerte und Eigenvektoren getrennt in Vektoren speichern.
Definiere:
> N:=5;
:= N 5
> eigenv:=vector(N); # da kommen die Eigenvektoren rein
:= eigenv ( ) array , .. 1 5 [ ]
> eigenw:=vector(N); # und hier die Eigenwerte
:= eigenw ( ) array , .. 1 5 [ ]
> for i from 1 to N do
eigenw[i]:=ev[i][1];
eigenv[i]:=ev[i][3][1];
od;
:= eigenw
1
1
:= eigenv
1
[ ] , , , , -1 1 0 -1 1
:= eigenw
2
+ 2 3
:= eigenv
2
[ ] , , , , 1 3 2 3 1
:= eigenw
3
2 3
:= eigenv
3
[ ] , , , , 1 3 2 3 1
:= eigenw
4
2
:= eigenv
4
[ ] , , , , 1 0 -1 0 1
:= eigenw
5
3
Page 10
:= eigenv
5
[ ] , , , , -1 -1 0 1 1
Nun zu einem weiteren Beispiel! Eine Matrix kann man natrlich auch mit Schleifen
besetzen:
> Anzahl:=5: C:=matrix(Anzahl,Anzahl);
:= C ( ) array , , .. 1 5 .. 1 5 [ ]
> for i from 1 to Anzahl do
for j from 1 to Anzahl do
if i=j-1 then
C[i,j]:=sqrt(j);
else
C[i,j]:=0;
fi;
od;
od;
> print(C);
(
(
(
(
(
(
(
((
0 2 0 0 0
0 0 3 0 0
0 0 0 2 0
0 0 0 0 5
0 0 0 0 0
> C:=evalm(C+transpose(C));
:= C
(
(
(
(
(
(
(
(
(
0 2 0 0 0
2 0 3 0 0
0 3 0 2 0
0 0 2 0 5
0 0 0 5 0
Somit hat man also eine Matrix erzeugt, die symmetrisch und damit invertierbar ist.
> eigenvals(C);
, , , , 0 11 11 3 3
> eigenvects(C);
(
(
, , 11 1 { }
(
(
, , , ,
1
11
11 2 1
3
11
11 3 3
1
11
11 5 3 ,
(
(
, , 11 1 { }
(
(
, , , ,
1
11
11 2 1
3
11
11 3 3
1
11
11 5 3 ,
(
(
, , 3 1 { }
(
(
, , , ,
1
3
3 2 1
1
3
1
3
3
1
3
5 ,
(
(
, , 0 1 { }
(
(
, , , ,
1
4
2 3 5 0
1
2
5 0 1 ,
(
(
, , 3 1 { }
(
(
, , , ,
1
5
2 3 5
3
5
5
1
5
5
1
5
5 3 1
>
Page 11
Ein bisschen Vektoranalysis
> restart; with(linalg): with(plots):
Definiere zunchst eine skalare Funktion zweier Variablen (Gaufunktion):
> V := (x,y) -> exp(-x^2-y^2);
:= V ( ) , x y e
( ) x
2
y
2
> plot3d(V(x,y),x=-2..2,y=-2..2,axes=boxed);
Der Gradient dieses skalaren Feldes beschreibt fr jeden Punkt in der [x y] - Ebene Betrag
und Richtung der Steigung, ist also in diesem Fall ein 2-dimensioanler Vektor:
(
(
,
x
( ) V , x y
y
( ) V , x y
> v:=grad(V(x,y),[x,y]);
:= v [ ] , 2 x e
( ) x
2
y
2
2 y e
( ) x
2
y
2
> fieldplot(v,x=-2..2,y=-2..2);
Page 12
Der Gradient zeigt also wie erwartet immer in Richtung der strksten Steigung, also
bergauf!
Bei den dreidimensionalen vektoriellen Feldern gibt es neben dem Gradienten noch die
beiden Differentialoperationen Divergenz und Rotation, die mit den Funktionen diverge
und curl berechnet werden knnen.
Divergenz von V (ist Skalar): + +
|
\
|
.
|
|
x
Vx
|
\
|
.
|
|
y
Vy
|
\
|
.
|
|
z
Vz
Rotation von V (ist Feld): x-Komponente =
|
\
|
.
|
|
y
Vz
|
\
|
.
|
|
z
Vy usw.
>
> V := (x,y,z) -> vector(3 , [x^2+y,y^2-z,z^2*x]);
:= V ( ) , , x y z ( ) vector , 3 [ ] , , + x
2
y y
2
z z
2
x
> diverge(V(x,y,z) , [x,y,z]);
+ + 2 x 2 y 2 z x
> curl(V(x,y,z) , [x,y,z]);
[ ] , , 1 z
2
-1
> diverge(%,[x,y,z]);
0
Dieses Ergebnis kann man auch erwarten, wenn man etwas Vektoranalysis kennt. Ebenso
sollte die Rotation eines Gradienten verschwinden.
> grad(g(x,y,z) , [x,y,z]);
(
(
, ,
x
( ) g , , x y z
y
( ) g , , x y z
z
( ) g , , x y z
> curl(% , [x,y,z]);
Page 13
[ ] , , 0 0 0
Fr vektorielle Funktionen F, deren Rotation verschwindet, kann man auch ein
Potential V finden, sodass = F ( ) grad V gilt. In der Physik fhrt man hier noch meist ein
Minuszeichen ein, das aber reine Konvention ist und den blichen Vorstellungen einer
potentiellen Energie entspricht, aber nicht unbedingt ntig ist. Als Beispiel soll hier die
(vektorielle) Coulomb-Kraft zwischen zwei Ladungen dienen. Sie ist gegeben durch
q
1
q
2
4 r
3
multipliziert mit dem Vektor r = (x, y, z). In Maple-Schreibweise:
> F := evalm(q1*q2/(4*Pi*epsilon)/(x^2+y^2+z^2)^(3/2) *
vector(3,[x,y,z]));
:= F

(
(
(
, ,
1
4
q1 q2 x
( ) + + x
2
y
2
z
2
( ) / 3 2
1
4
q1 q2 y
( ) + + x
2
y
2
z
2
( ) / 3 2
1
4
q1 q2 z
( ) + + x
2
y
2
z
2
( ) / 3 2
> curl(F,[x,y,z]);
[ ] , , 0 0 0
Daher muss ein Potential existieren. Dieses kann mit dem Befehl potential bestimmt
werden, der allerdings eine etwas kryptische Syntax hat. Die Funktion liefert einen Wert
vom Typ boolean und wird in der Form potential(Vektorfeld,[Koordinaten],'Potential')
verwendet. Der Wert ist true wenn ein Potential existiert und andernfalls false. Man muss
also zuvor gar nicht die Rotation bestimmen:
> potential(F , [x,y,z] , 'V');
true
> V;
1
4
q1 q2
+ + x
2
y
2
z
2

Das physikalische Potential wre gerade das Negative davon. Auerdem gibt diese
Funktion nur ein Potential an und liefert nicht alle mglichen Potentiale. Eine Kontrolle
des Potentials ist sinnvoll:
> grad(V,[x,y,z]);
(
(
(
, ,
1
4
q1 q2 x
( ) + + x
2
y
2
z
2
( ) / 3 2
1
4
q1 q2 y
( ) + + x
2
y
2
z
2
( ) / 3 2
1
4
q1 q2 z
( ) + + x
2
y
2
z
2
( ) / 3 2
> evalm(%-F);
[ ] , , 0 0 0
Page 14

Maplekurs

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Maplekurs

Hochgeladen von

Copyright:

Verfügbare Formate

Einfhrung in Maple (2SWSt, 3 LPs)

> prod2:=product((n^2-2)/(n^2+4) , n=0..infinity);

+ a12 a33 a13 a32

a12 a23 a13 a22

a11 a33 a13 a31

a21 a32 a22 a31

a11 a22 a12 a21

a11 ( ) + a12 a33 a13 a32

a21 ( ) + a12 a33 a13 a32

a31 ( ) + a12 a33 a13 a32

Das könnte Ihnen auch gefallen