Poolraum und Computerpraktika der Fakultät für Physik

MapleVorlesung.html

MapleVorlesung.mw


Dieses Maple-Tutorial stammt von http://comp.physik.kit.edu/Lehre/ERA/. Dort gibt es auch ein Übungsblatt. 

Hilfe zu allen Maplebefehlen erhalten Sie mit vorangestelltem Fragezeichen, z.B. 

> ?int
 

Dieses Worksheet können Sie schrittweise von oben nach unten mit der RETURN-Taste ausführen.  

Das folgende Kommando löscht alle Variablen und setzt Maple in den Anfangszustand zurück.  

( Alternativ erreicht man dies auch mit dem Restartbutton in der Toolleiste oben.) 

> restart;
 

Grundlegende Bedienung 

Die folgenden Ausführungen beziehen sich auf den "Worksheet Mode" im "Document Mode" gibt es teilweise Abweichungen!  

Einfache Rechenoperationen können direkt eingeben werden, jede Zeile wird mit einem Semikolon beendet. 

> 1+1;
 

2 (1.1)
 

Wird das Semikolon vergessen, gibt Maple (vor Version 2015) eine Warnung aus,  die Anweisung wird aber trotzdem ausgeführt.  

> 1+1
 

(1.2)
 

Um die Ausgabe des Ergebnisses bewusst zu unterdrücken, schreibt man einen Doppelpunkt (die Rechnung wird trotzdem ausgeführt). 

> 1+1:
 

Grundlegende mathematische Operationen +, -, *,  /, ^ (Potenzieren, auch mit **) Operationen sind verfügbar. 

> 5-2;
 

3 (1.3)
 

> 3*3;
 

9 (1.4)
 

> 8/4;
 

2 (1.5)
 

> 5/3;
 

`/`(5, 3) (1.6)
 

> 3^2;
 

9 (1.7)
 

> 3**2;
 

9 (1.8)
 

Maple rechnet grundsätzlich so genau wie möglich, daher bleibt der Bruch oben gekürzt stehen.  

Fliesskommazahlen sind grundsätzlich fehlerbehaftet und werden mit einem Punkt eingegeben. 

> 2.5*1.5;
 

3.75 (1.9)
 

Alle üblichen Funktionen sind direkt verfügbar. 

> sin(0.5);
 

.4794255386 (1.10)
 

> cos(0.5);
 

.8775825619 (1.11)
 

> ln(1.);
 

0. (1.12)
 

> exp(1.);
 

2.718281828 (1.13)
 

Die letzten Ergebnisse sind mit %, %%, %%%, usw. abrufbar. 

> cos(0.5);
 

> sin(0.5);
 

> %^2 + %%^2;
 

 

 

(1.14)
 

Alternativ kann via Strg-L auch direkt auf ein " Label " verwiesen werden 

> 2.718281828;
 

2.718281828 (1.15)
 

Maple wertet Funktionen erst in dem Moment aus, wenn dies explizit vom Benutzer gefordert wird.  

Damit wird höchste Genauigkeit erreicht, da Fliesskommazahlen hardwarebedingt immer fehlerbehaftet sind.  

> sin(1/2);
 

> cos(1/2);
 

 

(1.16)
 

evalf steht hier für 'evaluate floating point' und erzwingt die Fliesskommadarstellung, 

dabei können optional die Nachkommastellen mitangegeben werden. 

> evalf( sin(1/2) );
 

> evalf( sin(1/2), 20);
 

 

(1.17)
 

Maple kann viele analytische Umformungen durchführen, muss dazu aber oft aufgefordert werden. 

simplify ist daher eine wichtigstens Funktionen. 

> sin(1/2)^2 + cos(1/2)^2;
 

> simplify(%);
 

 

(1.18)
 

In der Fliesskommadarstellung geht dabei Genauigkeit verloren. 

> evalf( sin(0.5)^2 + cos(0.5)^2, 40);
 

.9999999999999999999999999999999999999999 (1.19)
 

Variablenzuweisungen werden mit := vorgenommen! 

> a := ln(2);
 

ln(2) (1.20)
 

> b := 3**2 + 5;
 

14 (1.21)
 

> b / exp(a);
 

7 (1.22)
 

Die Variablenbelegungen können mit unassign wieder gelöscht werden, allerdings der naiver Aufruf bewirkt nichts: 

> unassign(a);
 

> a;
 

ln(2) (1.23)
 

Die Variable a hat noch immer den Wert ln(2), da Maple in Wirklichkeite den Befehl 

> unassign( ln(2) );
 

erhalten hat, d.h. die Variable a wurde schon vor dem Aufruf von unassign durch ihren Wert ersetzt. Um die Variable mit Namen a zu löschen, muss man das Ersetzen durch ticks ' ' verzögern, bzw. verhindern: 

> unassign('a');
 

> a;
 

a (1.24)
 

FALLE!
Ein typischer Fehler ist ein Zuweisungsversuch nur mit dem Gleichheitszeichen
=.  

Dies ist für Maple kein Fehler, da so werden Gleichungen definiert werden, allerdings  

hat die Variable c danach noch immer keinen Wert. 

> c = 2 + 3;
 

(1.25)
 

> c;
 

c (1.26)
 

Maplebefehlen und einige eingebaute Konstanten kann man nichts zuweisen. 

> sin := 1;
 

Error, attempting to assign to `sin` which is protected.  Try declaring `local sin`; see ?protect for details.
 

> evalf := 1;
 

Error, attempting to assign to `evalf` which is protected.  Try declaring `local evalf`; see ?protect for details.
 

> I := 1;
 

Error, illegal use of an object as a name
 

Mit der komplexen Einheit I kann man komplexe Zahlen definieren 

> I^2;
 

-1 (1.27)
 

> z := 1 + 2*I;
 

`+`(1, `*`(2, `*`(I))) (1.28)
 

Pi ist natürlich auch da. 

> evalf( Pi );
 

3.141592654 (1.29)
 

Auch mit seeeehr vielen Stellen.  

> evalf( Pi, 1000);
 










(1.30)
 

Damit kann man auch trigonometrische Funktionen auswerten lassen. 

> sin(Pi);
 

0 (1.31)
 

> cos(Pi/4);
 

`+`(`*`(`/`(1, 2), `*`(`^`(2, `/`(1, 2))))) (1.32)
 

> tan(Pi/4);
 

1 (1.33)
 

Maple kennt auch die Eulersche Zahl e analytisch, im Worksheet Modus wird sie über die exp -Funktion eingegeben.  

> exp(1);
 

(1.34)
 

Brüche werden von Maple automatisch vereinfacht. 

> 1/2 + 2/3;
 

`/`(7, 6) (1.35)
 

Zähler und Nenner von Brüchen kann man mit denom und numer  extrahieren. 

> denom( 5/8 );
 

8 (1.36)
 

> numer( 5/8 );
 

5 (1.37)
 

Die Fliesskommadarstellungen bekommt man wieder mit evalf 

> evalf( 5/8 );
 

.6250000000 (1.38)
 

Auch komplexe Zahlen kann man zerlegen. 

> Re(z);
 

1 (1.39)
 

> Im(z);
 

2 (1.40)
 

Ebenso geht das konjugieren von komplexen Zahlen. Wenn Sie einen Operation nicht direkt beim Namen kennen, hilft die Onlinehilfe trotzdem oft weiter. Der nächste Befehl ist zwar nicht der gesuchte, doch in der untersten Zeile des Hilfetextes gibt es Verweise auf verwandte Themen. Der conjugate Befehl ist der, den wir brauchen.   

> ?conj
 

> conjugate(z);
 

`+`(1, `-`(`*`(2, `*`(I)))) (1.41)
 

Annahmen (Assumptions) 

Maple macht bei der Berechnung keinerlei Annahmen über den Wert von Variablen.
Insbesondere wird immer berücksichtigt, dass die Variablen komplexe Werte haben könnten.
 

Oft führt dies zu unerwartet komplizierten Ausdrücken, da manche Vereinfachungen z.B. nur 

für reele Werte gelten. 

Beispiel: 

> sqrt(a^2)
 

`*`(`^`(`*`(`^`(a, 2)), `/`(1, 2))) (2.1)
 

> simplify(%)
 

`*`(csgn(a), `*`(a)) (2.2)
 

Man kann Maple allerdings explizit Angaben über die Werte der Variablen mitteilen. 

(2.3)
 

 

Dies geht auf zwei Arten: 

Einmalige Annahmen: assuming 

Soll die Annahme nur für eine bestimmte Auswertung gelten, so kann man sie mit  

assuming hinten anstellen: 

simplify(sqrt(a^2)) assuming a::real 

abs(a) (2.1.1)
 

simplify(sqrt(a^2)) 

`*`(csgn(a), `*`(a)) (2.1.2)
 

Neben dem Typ, kann auch z.B. der Wertebereich angegeben werden 

simplify(sqrt(a^2)) assuming a<0 

`+`(`-`(a)) (2.1.3)
 

Mit den Bereichsangaben < oder > wird automatisch auch gesagt, dass der Wert reel ist. 

Bleibende Annahmen: assume 

Sollen Annahmen für eine ganze Rechnung gemacht werden, so nutzt man den Befehl assume 

> assume(t::real,a<0, a+c > 0)
 

 

Um zu Kennzeichnen, dass die Variablen "speziell" sind, wird ab diesem Zeitpunkt bei der
Ausgabe ein ~-Zeichen angehängt.
 

> a,t,c
 

a, t, c (2.2.1)
 

> simplify(sqrt((a+c)^2))
 

`+`(a, c) (2.2.2)
 

>
 

Mit about kann man die Eigenschaften von Variablen anzeigen lassen.
Will man die Annahme wieder loswerden, geschieht dies durch löschen der Variable mit unassign
 

> unassign('t','a','c')
 

> about(t,a,b)
 

t:
 

 nothing known about this object

a:
 nothing known about this object

14:
 All numeric values are properties as well as objects.
 Their location in the property lattice is obvious,
 in this case integer.
 

> simplify(sqrt((a+b)^2))
 

`*`(csgn(`+`(a, 14)), `*`(`+`(a, 14))) (2.2.3)
 

 

Bedienung des Worksheetinterfaces 

Sections und Subsections können sie über das "Insert"-Menü einfügen.  

>
 

Strg-J fügt eine neue " Execution Group " nach dieser, Strg-K fügt eine vor dieser ein. Strg-Entf löscht das aktuelle Element. 

> on
 

on (3.1)
 

Mit Strg-T geben Sie Text ein, mit Strg-M Mapleinput:  

> 1+1;
 

2 (3.2)
 

Subsections helfen... 

... beim Strukturieren von längeren Dokumenten . Mit Strg-. und Strg-, können Sie Execution Goups jeweils eine Ebene nach innen oder aussen bewegen. 

>
 

Die Undo-Funktion erhalten Sie mit Strg-Z und ALT-BACKSPACE, ansonsten gibt es Ausschneiden/Kopieren/Einfügen wie gehabt mit Strg-X, Strg-C, Strg-V. 

Execution Groups können Sie mit F3/F4 trennen und zusammenfassen: 

> sinh(1/2);
 

> cosh(1/2)^2 - %^2;
 

> simplify(%);
 

 

 

(3.3)
 

Differentiation und Integration 

 

Ableitungen von Ausdrücken berechnen Sie mit dem diff Befehl, wobei die freie Variable spezifiziert werden muss. 

> diff( x^2 + ln(x), x);
 

`+`(`*`(2, `*`(x)), `/`(1, `*`(x))) (4.1)
 

> diff( sin(x)/x, y);
 

0 (4.2)
 

Maple wendet nur stur Ableitungsregeln an, Vereinfachungen müssen danach explizit mit simplify vorgenommen werden. 

> diff( exp(-x^2), x, x, x);
 

> simplify(%);
 

 

(4.3)
 

Mehrfache Ableitungen können auch wie folgt eingegeben werden 

> diff( exp( -x^2), x$3);
 

(4.4)
 

 

Stammfunktionen berechnet man mit dem Befehl int . 

> int( x^n, x);
 

`/`(`*`(`^`(x, `+`(n, 1))), `*`(`+`(n, 1))) (4.5)
 

> int( x^n, n);
 

`/`(`*`(`^`(x, n)), `*`(ln(x))) (4.6)
 

Für bestimmte Integrale muss man einen range angeben. 

> int( x/sqrt(x^2+9), x=0..4);
 

(4.7)
 

Auch uneigentliche Integrale lassen sich analytisch angeben, obwohl keine analytische Stammfunktion existiert:  

> int( exp(-x^2), x=-infinity..+infinity);
 

(4.8)
 

Taylorreihen erhält man mit dem Befehl series  

> series(sin(x), x=0, 4);
 

series(`+`(x, `-`(`*`(`/`(1, 6), `*`(`^`(x, 3)))))O(`^`(x, 5)),x,5) (4.9)
 

Diese kann man mit convert (s.u.) in richtige Polynome umwandeln: 

> convert(%, polynom);
 

`+`(x, `-`(`*`(`/`(1, 6), `*`(`^`(x, 3))))) (4.10)
 

Umformungen 

Polynome können ausmultipliziert und faktorisiert werden. 

> x * (x-1) * (x+1) * (x-2);
 

`*`(x, `*`(`+`(x, `-`(1)), `*`(`+`(x, 1), `*`(`+`(x, `-`(2)))))) (5.1)
 

> expand(%);
 

`+`(`*`(`^`(x, 4)), `-`(`*`(2, `*`(`^`(x, 3)))), `-`(`*`(`^`(x, 2))), `*`(2, `*`(x))) (5.2)
 

> factor(%);
 

`*`(x, `*`(`+`(x, `-`(1)), `*`(`+`(x, 1), `*`(`+`(x, `-`(2)))))) (5.3)
 

Explizites Ausklammern von Ausdrücken geht auch. 

> poly := expand( x * y * y * (x-1) * (y-2) * (y-3) );
 

`+`(`*`(`^`(x, 2), `*`(`^`(y, 4))), `-`(`*`(5, `*`(`^`(x, 2), `*`(`^`(y, 3))))), `-`(`*`(x, `*`(`^`(y, 4)))), `*`(6, `*`(`^`(x, 2), `*`(`^`(y, 2)))), `*`(5, `*`(x, `*`(`^`(y, 3)))), `-`(`*`(6, `*`(x, ... (5.4)
 

> collect( poly, y );
 

`+`(`*`(`+`(`*`(`^`(x, 2)), `-`(x)), `*`(`^`(y, 4))), `*`(`+`(`-`(`*`(5, `*`(`^`(x, 2)))), `*`(5, `*`(x))), `*`(`^`(y, 3))), `*`(`+`(`*`(6, `*`(`^`(x, 2))), `-`(`*`(6, `*`(x)))), `*`(`^`(y, 2)))) (5.5)
 

> collect( poly, x );
 

`+`(`*`(`+`(`*`(`^`(y, 4)), `-`(`*`(5, `*`(`^`(y, 3)))), `*`(6, `*`(`^`(y, 2)))), `*`(`^`(x, 2))), `*`(`+`(`-`(`*`(`^`(y, 4))), `*`(5, `*`(`^`(y, 3))), `-`(`*`(6, `*`(`^`(y, 2))))), `*`(x))) (5.6)
 

Explizite analytische Umformungen muss man mit convert veranlassen. 

> convert( exp(I*omega*t), trig);
 

`+`(cos(`*`(omega, `*`(t))), `*`(I, `*`(sin(`*`(omega, `*`(t)))))) (5.7)
 

Hier passiert nichts, der Tangens ist schon eine trigonometrische Funktion.  

> convert( tan(alpha), trig );
 

(5.8)
 

Aber man kann ihn durch Sinus und Kosinus ausdrücken:  

> convert( tan(alpha), sincos );
 

`/`(`*`(sin(alpha)), `*`(cos(alpha))) (5.9)
 

Alle verfügbaren Konversionen sind unter ?convert aufgelistet. 

Mit combine können Ausdrücke analytisch zusammengeführt werden. 

> combine( ln(2) - ln(3), ln);
 

ln(`/`(2, 3)) (5.10)
 

Das Gegenteil leistet 

> expand( sin(2*theta) );
 

`+`(`*`(2, `*`(sin(theta), `*`(cos(theta))))) (5.11)
 

Manchmal sind lexikalische Ersetzungen hilfreich, diese kann man mit subs (für substitute) wie folgt vornehmen.  

Beachten Sie, dass Maple nur die Ausdrücke ersetzt, die lexikalisch auf die gegebene Ersetzungsregel passen! 

> `+`(`*`(`+`(`*`(`^`(y, 4)), `-`(`*`(5, `*`(`^`(y, 3)))), `*`(6, `*`(`^`(y, 2)))), `*`(`^`(x, 2))), `*`(`+`(`-`(`*`(`^`(y, 4))), `*`(5, `*`(`^`(y, 3))), `-`(`*`(6, `*`(`^`(y, 2))))), `*`(x)))
 

`+`(`*`(`+`(`*`(`^`(y, 4)), `-`(`*`(5, `*`(`^`(y, 3)))), `*`(6, `*`(`^`(y, 2)))), `*`(`^`(x, 2))), `*`(`+`(`-`(`*`(`^`(y, 4))), `*`(5, `*`(`^`(y, 3))), `-`(`*`(6, `*`(`^`(y, 2))))), `*`(x))) (5.12)
 

> subs( x = sin(alpha), y^2 = w, %);
 

`+`(`*`(`+`(`*`(`^`(y, 4)), `-`(`*`(5, `*`(`^`(y, 3)))), `*`(6, `*`(w))), `*`(`^`(sin(alpha), 2))), `*`(`+`(`-`(`*`(`^`(y, 4))), `*`(5, `*`(`^`(y, 3))), `-`(`*`(6, `*`(w)))), `*`(sin(alpha)))) (5.13)
 

Funktionsdefinitionen 

 

Bis hierher haben wir nur Polynomausdrücke definiert, aber noch keine Werte eingesetzt. 

> p := x * (x-2);
 

`*`(x, `*`(`+`(x, `-`(2)))) (6.1)
 

Auswerten an bestimmten Stellen geht mit 

> eval( p, x=1 );
 

-1 (6.2)
 

> eval( p, x=0.5 );
 

-.75 (6.3)
 

Funktionen werden mit dem Pfeiloperator -> definiert, was sich eng an die mathematische Notation hält. 

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

proc (x) options operator, arrow; `*`(x, `*`(`+`(x, `-`(2)))) end proc (6.4)
 

Jetzt kann man mit f wie gewohnt umgehen. 

> f( 1 );
 

-1 (6.5)
 

> f( 0.5 );
 

-.75 (6.6)
 

Nur beim Ableiten muss man aufpassen! 

> diff(f, x);
 

0 (6.7)
 

Das diff-Kommando erwartet nämlich Ausdrücke, doch f selbst ist eigentlich ein Mapleoperator. Das x bei der Definition war (wie in Programmiersprachen) nur eine lokale Variable und hat mit f selbst nix zu tun. 

> print(f);
 

proc (x) options operator, arrow; `*`(x, `*`(`+`(x, `-`(2)))) end proc (6.8)
 

> print(f(y));
 

`*`(y, `*`(`+`(y, `-`(2)))) (6.9)
 

Das x in der Definition war nur ein lokaler Platzhalter; die eigentliche Variable, nach der wir ableiten, muss erst noch eingesetzt werden: 

> diff(f(y), y);
 

`+`(`*`(2, `*`(y)), `-`(2)) (6.10)
 

> diff(f(w), w);
 

`+`(`*`(2, `*`(w)), `-`(2)) (6.11)
 

Ein häufiger Fehler ist eine Operatordefinition der folgendenen Form: 

> g(x) := 2*x;
 

`+`(`*`(2, `*`(x))) (6.12)
 

Gemeinerweise gibt es hier nämlich keine Fehlermeldung, doch ist das ganz und gar nicht das, was wir wollen: 

> g(1);
 

g(1) (6.13)
 

> g(0.5);
 

g(.5) (6.14)
 

> g(x);
 

`+`(`*`(2, `*`(x))) (6.15)
 

Hintergrund ist, dass Maple intern eine Liste von Definitionen speichert, auf die bei Bedarf zurückgegriffen wird.  

Dieser " Remember Table " dient der Performance, wird aber auch durch Maple-Prozeduren verwendet.  

Dass sich die Werte darin einfach überschreiben lassen kann man sich allerdings auch zu Nutze machen.
So lassen sich auch Folgen, die über Rekursionsbedingungen definiert sind konstruieren, z.B. die Fibonacci-Folge:
 

> h := x-> h(x-1) + h(x-2);
 

proc (x) options operator, arrow; `+`(h(`+`(x, `-`(1))), h(`+`(x, `-`(2)))) end proc (6.16)
 

> h(1):=1; h(2):=1;
 

> h(10);
 

 

 

(6.17)
 

Mehrdimensionale Funktionen gehen genauso: 

> r := (x,y) -> sqrt(x^2 + y^2);
 

proc (x, y) options operator, arrow; sqrt(`+`(`*`(`^`(y, 2)), `*`(`^`(x, 2)))) end proc (6.18)
 

> r(1,2);
 

`*`(`^`(5, `/`(1, 2))) (6.19)
 

Gleichungen und Gleichungssysteme 

Gleichungen werden mit einem Gleichheitszeichen definiert: 

> eq1 := exp(x)*c - sin(alpha) = 1;
 

(7.1)
 

Mit solve kann man analytisch nach verschiedenen Variablen auflösen lassen:  

> solve( eq1, x );
 

ln(`/`(`*`(`+`(1, sin(alpha))), `*`(c))) (7.2)
 

> solve( eq1, c );
 

`/`(`*`(`+`(1, sin(alpha))), `*`(exp(x))) (7.3)
 

> solve( eq1, alpha);
 

arcsin(`+`(`*`(exp(x), `*`(c)), `-`(1))) (7.4)
 

Auch lineare Geichungsystem können so gelöst werden: 

> eq2 := x + 2*y = 5;
 

`+`(x, `*`(2, `*`(y))) = 5 (7.5)
 

> eq3 := x - y = 1;
 

`+`(x, `-`(y)) = 1 (7.6)
 

> sol := solve({eq2, eq3}, {x, y});
 

{x = `/`(7, 3), y = `/`(4, 3)} (7.7)
 

Das Ergebnis wird als Menge (engl. set) in geschweiften Klamern {} ausgegeben. Auf die Elemente einer Menge kann man mit dem Klammeroperator [] zugreifen: 

> sol[1];
 

x = `/`(7, 3) (7.8)
 

> sol[2];
 

y = `/`(4, 3) (7.9)
 

PROBLEM: Maple sets sind mathematischen Mengen nachempfunden und sind ungeordnet. Beim nächsten Aufruf von solve kann die Reihenfolge der Elemente eine andere sein. Wie bekommt man dann eindeutig die Lösung für x extrahiert? Die Antwort liefert das Kommando subs! 

Im nächsten Beispiel wendet subs die Lösungsmenge des LGS als Ersetzungsregel auf die simplen Ausdrücke x und y an: 

> subs(sol, x);
 

`/`(7, 3) (7.10)
 

> subs(sol, y);
 

`/`(4, 3) (7.11)
 

Numerische Lösungen von Gleichungen bekommt man mit fsolve, wobei die Lösungsalgorithmen jeweils oft einen Startwert brauchen, in dessen Nähe sie nach Lösungen suchen sollen:  

> eq4 := x*cos(x) - 1;
 

`+`(`*`(x, `*`(cos(x))), `-`(1)) (7.12)
 

Ohne Gleichheitszeichen wird die rechte Seite implizit als =0 angenommen. 

> fsolve(eq4, x);
 

(7.13)
 

> fsolve(eq4, x=-1);
 

 

(7.14)
 

> fsolve(eq4, x=4);
 

4.917185925 (7.15)
 

> fsolve(eq4, x=-4);
 

-4.487669603 (7.16)
 

Macht ja auch Sinn, wenn man sich die Nullstellen mal genauer anschaut. 

> plot(eq4,x=-6..6);
 

Plot_2d
 

Exkursion: Datenstrukturen in Maple 

Maple kennt viele Datentypen, um mehrere Ausdrücke zusammenzufassen; die wichtigsten davon sind sets, lists und sequences. Auch Vektoren und Matrizen sind eigene Datentypen. Auf all dies Datentypen kann mit dem Klammeroperator [] zugegriffen werden. 

Listen sind das Äquivalent zu mathematischen Tupeln: Die Reihenfolge der Elemente ist relevant und jedes Element, das man reinsteckt, ist später auch drin: 

> alist := [1,1,1,x^3,sin(alpha),7,x^2];
 

[1, 1, 1, `*`(`^`(x, 3)), sin(alpha), 7, `*`(`^`(x, 2))] (8.1)
 

> alist[1];
 

1 (8.2)
 

> alist[5];
 

sin(alpha) (8.3)
 

Bei Zugriff auf nicht vorhandene Elemente gibt es eine Fehlermeldung: 

> alist[10];
 

Error, invalid subscript selector
 

Sets sind mathematischen Mengen nachempfunden, jedes Element kommt maximal einmal vor und die Reihenfolge ist nicht wichtig/bleibt nicht erhalten: 

> aset := {1,5,1,2,4,5,2,1,2,1};
 

{1, 2, 4, 5} (8.4)
 

> aset[1];
 

1 (8.5)
 

> aset[4];
 

5 (8.6)
 

Für sets gibt es Funktionen für Vereinigungsmengen, Schnittmengen, etc. Siehe ?set. 

> ?set
 

Es gibt auch sequences (Folgen), welche quasi Listen ohne eckige Klammern sind: 

> aseq := 1,x^2,5,sin(alpha);
 

1, `*`(`^`(x, 2)), 5, sin(alpha) (8.7)
 

> aseq[1];
 

1 (8.8)
 

> aseq[2];
 

`*`(`^`(x, 2)) (8.9)
 

Der Unterschied ist der, dass Listen bei der Übergabe an Funktionen als ein einzelnes Argument zählen, sequences dagegen als mehrere verschiedene Argumente. 

> d := (x,y) -> sinh(x) + cosh(y);
 

proc (x, y) options operator, arrow; `+`(sinh(x), cosh(y)) end proc (8.10)
 

> d(1);
 

Error, invalid input: d uses a 2nd argument, y, which is missing
 

> d(1,2);
 

`+`(sinh(1), cosh(2)) (8.11)
 

> darg := 1,2;
 

1, 2 (8.12)
 

> d(darg);
 

`+`(sinh(1), cosh(2)) (8.13)
 

Wichtige Befehle im Zusammenhang mit diesen Datentypen sind op (extrahiert elemente), nops (gibt die anzahl der gespeicherten Elemente zurück), seq (erzeugt eine sequence), map (wendet eine Funktion einer Variablen auf jedes Element einer Liste an), zip (wendet eine Funktion zweier Variablen auf die Elemente von zwei Listen an und erzeugt so eine neue Liste), add (addiert alle Listenelemente auf; nicht sum verwenden!), mul (multipliziert alle Listenelemente zusammen; nicht product verwenden!): 

> aseq := seq( i^2, i=-2..2);
 

4, 1, 0, 1, 4 (8.14)
 

> alist := [seq( i^2, i=-2..2)];
 

[4, 1, 0, 1, 4] (8.15)
 

> aset := {seq( i^2, i=-2..2)};
 

{0, 1, 4} (8.16)
 

> op(2, alist);
 

1 (8.17)
 

> nops(aset);
 

3 (8.18)
 

> map(x->x^2, alist);
 

[16, 1, 0, 1, 16] (8.19)
 

> zip((x,y)->x+y, alist, %);
 

[20, 2, 0, 2, 20] (8.20)
 

> add(x, x=%);
 

44 (8.21)
 

> mul(x, x=[2,3,4]);
 

24 (8.22)
 

An seq kann man auch Listen übergeben:  

> seq( sin(i), i=aseq);
 

sin(4), sin(1), 0, sin(1), sin(4) (8.23)
 

Erweitern von Listen geht mit op: 

> newlist := [-3, op(alist), 3];
 

[-3, 4, 1, 0, 1, 4, 3] (8.24)
 

Konversionen nimmt wieder convert vor: 

> avec := convert(alist, Vector);
 

Vector[column](%id = 18446883868162319534) (8.25)
 

Den Datentyp eines Mapleobjektes bekommt man mit whattype: 

> whattype( aseq );
 

(8.26)
 

> whattype( alist );
 

list (8.27)
 

> whattype( aset );
 

set (8.28)
 

> whattype( avec );
 

Vector[column] (8.29)
 

Man kann nummerierte Variablen auch direkt selbst erzeugen: 

> eq[1] := x+y=0;
 

> eq[2] := x-y=1;
 

 

(8.30)
 

Allerdings haben wir dabei nun eine Variable vom Typ table erzeugt, da nicht nur ganze Zahlen als Schlüssel erlaubt sind: 

> print(eq);
 

> whattype(eq);
 

 

(8.31)
 

> eq[sin(alpha)] := cos(alpha);
 

cos(alpha) (8.32)
 

> eq[1];
 

`+`(x, y) = 0 (8.33)
 

> eq[sin(alpha)];
 

cos(alpha) (8.34)
 

> eq_list := convert(eq, list);
 

[`+`(x, y) = 0, `+`(x, `-`(y)) = 1, cos(alpha)] (8.35)
 

> whattype(eq_list);
 

list (8.36)
 

> seq(i, i=eq);
 

eq (8.37)
 

> seq(i, i=eq_list);
 

`+`(x, y) = 0, `+`(x, `-`(y)) = 1, cos(alpha) (8.38)
 

Grafiken 

Maple stellt eine Vielzahl an Plotbefehlen zur Verfügung, die grösstenteils in das Package plots ausgelagert sind, welches man vorher laden muss: 

> with(plots);
 

[animate, animate3d, animatecurve, arrow, changecoords, complexplot, complexplot3d, conformal, conformal3d, contourplot, contourplot3d, coordplot, coordplot3d, densityplot, display, dualaxisplot, fiel...
[animate, animate3d, animatecurve, arrow, changecoords, complexplot, complexplot3d, conformal, conformal3d, contourplot, contourplot3d, coordplot, coordplot3d, densityplot, display, dualaxisplot, fiel...
[animate, animate3d, animatecurve, arrow, changecoords, complexplot, complexplot3d, conformal, conformal3d, contourplot, contourplot3d, coordplot, coordplot3d, densityplot, display, dualaxisplot, fiel...
[animate, animate3d, animatecurve, arrow, changecoords, complexplot, complexplot3d, conformal, conformal3d, contourplot, contourplot3d, coordplot, coordplot3d, densityplot, display, dualaxisplot, fiel...
[animate, animate3d, animatecurve, arrow, changecoords, complexplot, complexplot3d, conformal, conformal3d, contourplot, contourplot3d, coordplot, coordplot3d, densityplot, display, dualaxisplot, fiel...
[animate, animate3d, animatecurve, arrow, changecoords, complexplot, complexplot3d, conformal, conformal3d, contourplot, contourplot3d, coordplot, coordplot3d, densityplot, display, dualaxisplot, fiel...
(9.1)
 

Zu all diesen Befehlen gibt es eine Hilfe, die mehrere Beispiele enthält. Es lohnt sich, einige davon anzuschauen. Der simpelste Aufruf ist 

> plot(sin(x), x=0..2*Pi);
 

Plot_2d
 

Mit der rechten Maustaste können Sie diverse Einstellungen an dem Plot vornehmen, die Kontextleiste oben bietet dieselbe Funktionalität. Wichig ist die Exportfunktion (im Kontextmenü ganz unten). 

Es können auch mehrere Funktionen mit Optionen auf einmal geplottet werden, der Zeilenumbruch wird mit SHIFT-ENTER eingefügt (das macht lange Funktionsaufrufe übersichtlicher): 

> plot([sin(x), cos(x)],
x=0..2*Pi,
scaling=constrained,
axes=boxed);
 

Plot_2d
 

Man kann plots auch in Variablen speichern und erst später gemeinsam mit display anzeigen lassen: 

> plot1 := plot(sin(x), x=-Pi..Pi, color=blue):
 

> plot2 := plot(cos(x), x=-Pi..Pi, color=magenta):
 

> display(plot1, plot2);
 

Plot_2d
 

3D Plots bekommt man ebenso, wobei man mit der Maus die Graphik interaktiv drehen und hineinzoomen kann: 

> plot3d( sin(x)/x*cos(y)*y, x=-Pi..Pi, y=-Pi..Pi);
 

Plot_2d
 

Animationen lassen sich mit animate erstellen, wobei man in der Toolleiste viele Möglichkeiten hat, das Animationsverhalten zu beeinflussen. Animationen können als Animated-gif exportiert werden und so einfach im Internet für jedermann zugänglich gemacht werden. 

> animate( plot, [sin(k*x), x=0..2*Pi], k=1..10, frames=10);
 

Plot_2d
 

Man kann Animationen auch als eine Folge/Liste von Plots selbst erstellen und mit display animiert anzeigen lassen (Tabs können Sie eingeben, wenn Sie den "Toggle Tabs"-Button oben in der Toolleiste drücken): 

> plotseq := seq(
plot(sin(k*x), x=0..2*Pi),
k=1..10);
 

INTERFACE_PLOT(CURVES(Matrix(200, 2, {(1, 1) = .0, (1, 2) = .0, (2, 1) = 0.3303450657873698e-1, (2, 2) = 0.33028498598079804e-1, (3, 1) = 0.617776541183492e-1, (3, 2) = 0.6173836610090723e-1, (4, 1) =...
INTERFACE_PLOT(CURVES(Matrix(200, 2, {(1, 1) = .0, (1, 2) = .0, (2, 1) = 0.3303450657873698e-1, (2, 2) = 0.33028498598079804e-1, (3, 1) = 0.617776541183492e-1, (3, 2) = 0.6173836610090723e-1, (4, 1) =...
INTERFACE_PLOT(CURVES(Matrix(200, 2, {(1, 1) = .0, (1, 2) = .0, (2, 1) = 0.3303450657873698e-1, (2, 2) = 0.33028498598079804e-1, (3, 1) = 0.617776541183492e-1, (3, 2) = 0.6173836610090723e-1, (4, 1) =...
 

> display(plotseq, insequence=true);
 

Plot_2d
 

Parametrische Plots sind ebenfalls möglich, siehe  

> ?plot[parametric]
 

Maple kennt viele Koordinatensysteme und stellt nette Gimmicks bereit, diese in Plots zu veranschaulichen. Mit coordplot zeichnet Maple Koordinatenlinien, wobei ein Parameter jeweils fest bleibt: 

> coordplot(cartesian);
 

Plot_2d
 

> coordplot(polar);
 

Plot_2d
 

> coordplot3d(cylindrical);
 

Plot_2d
 

> coordplot3d(spherical);
 

Plot_2d
 

Im Package plottools werden noch weitere interessante Hilfsmittel angeboten. Es ist z.B. recht einfach, eine 3D Szene aus Polygonen darzustellen und von Maple anzeigen zu lassen. 

Lineare Algebra 

Diese Funktionalität wird im Package LinearAlgebra bereitgestellt, welches wir vorher laden müssen. 

> with(LinearAlgebra);
 

[`&x`, Add, Adjoint, BackwardSubstitute, BandMatrix, Basis, BezoutMatrix, BidiagonalForm, BilinearForm, CARE, CharacteristicMatrix, CharacteristicPolynomial, Column, ColumnDimension, ColumnOperation, ...
[`&x`, Add, Adjoint, BackwardSubstitute, BandMatrix, Basis, BezoutMatrix, BidiagonalForm, BilinearForm, CARE, CharacteristicMatrix, CharacteristicPolynomial, Column, ColumnDimension, ColumnOperation, ...
[`&x`, Add, Adjoint, BackwardSubstitute, BandMatrix, Basis, BezoutMatrix, BidiagonalForm, BilinearForm, CARE, CharacteristicMatrix, CharacteristicPolynomial, Column, ColumnDimension, ColumnOperation, ...
[`&x`, Add, Adjoint, BackwardSubstitute, BandMatrix, Basis, BezoutMatrix, BidiagonalForm, BilinearForm, CARE, CharacteristicMatrix, CharacteristicPolynomial, Column, ColumnDimension, ColumnOperation, ...
[`&x`, Add, Adjoint, BackwardSubstitute, BandMatrix, Basis, BezoutMatrix, BidiagonalForm, BilinearForm, CARE, CharacteristicMatrix, CharacteristicPolynomial, Column, ColumnDimension, ColumnOperation, ...
[`&x`, Add, Adjoint, BackwardSubstitute, BandMatrix, Basis, BezoutMatrix, BidiagonalForm, BilinearForm, CARE, CharacteristicMatrix, CharacteristicPolynomial, Column, ColumnDimension, ColumnOperation, ...
[`&x`, Add, Adjoint, BackwardSubstitute, BandMatrix, Basis, BezoutMatrix, BidiagonalForm, BilinearForm, CARE, CharacteristicMatrix, CharacteristicPolynomial, Column, ColumnDimension, ColumnOperation, ...
[`&x`, Add, Adjoint, BackwardSubstitute, BandMatrix, Basis, BezoutMatrix, BidiagonalForm, BilinearForm, CARE, CharacteristicMatrix, CharacteristicPolynomial, Column, ColumnDimension, ColumnOperation, ...
[`&x`, Add, Adjoint, BackwardSubstitute, BandMatrix, Basis, BezoutMatrix, BidiagonalForm, BilinearForm, CARE, CharacteristicMatrix, CharacteristicPolynomial, Column, ColumnDimension, ColumnOperation, ...
[`&x`, Add, Adjoint, BackwardSubstitute, BandMatrix, Basis, BezoutMatrix, BidiagonalForm, BilinearForm, CARE, CharacteristicMatrix, CharacteristicPolynomial, Column, ColumnDimension, ColumnOperation, ...
[`&x`, Add, Adjoint, BackwardSubstitute, BandMatrix, Basis, BezoutMatrix, BidiagonalForm, BilinearForm, CARE, CharacteristicMatrix, CharacteristicPolynomial, Column, ColumnDimension, ColumnOperation, ...
[`&x`, Add, Adjoint, BackwardSubstitute, BandMatrix, Basis, BezoutMatrix, BidiagonalForm, BilinearForm, CARE, CharacteristicMatrix, CharacteristicPolynomial, Column, ColumnDimension, ColumnOperation, ...
[`&x`, Add, Adjoint, BackwardSubstitute, BandMatrix, Basis, BezoutMatrix, BidiagonalForm, BilinearForm, CARE, CharacteristicMatrix, CharacteristicPolynomial, Column, ColumnDimension, ColumnOperation, ...
[`&x`, Add, Adjoint, BackwardSubstitute, BandMatrix, Basis, BezoutMatrix, BidiagonalForm, BilinearForm, CARE, CharacteristicMatrix, CharacteristicPolynomial, Column, ColumnDimension, ColumnOperation, ...
[`&x`, Add, Adjoint, BackwardSubstitute, BandMatrix, Basis, BezoutMatrix, BidiagonalForm, BilinearForm, CARE, CharacteristicMatrix, CharacteristicPolynomial, Column, ColumnDimension, ColumnOperation, ...
[`&x`, Add, Adjoint, BackwardSubstitute, BandMatrix, Basis, BezoutMatrix, BidiagonalForm, BilinearForm, CARE, CharacteristicMatrix, CharacteristicPolynomial, Column, ColumnDimension, ColumnOperation, ...
[`&x`, Add, Adjoint, BackwardSubstitute, BandMatrix, Basis, BezoutMatrix, BidiagonalForm, BilinearForm, CARE, CharacteristicMatrix, CharacteristicPolynomial, Column, ColumnDimension, ColumnOperation, ...
(10.1)
 

Vektoren und Matrizen werden wie folgt definiert: 

> e1 := Vector([1,0]);
 

Vector[column](%id = 18446883868162293758) (10.2)
 

> e2 := Vector([0,1]);
 

Vector[column](%id = 18446883868162293998) (10.3)
 

> A := Matrix([[0,1],[-1,0]]);
 

Matrix(%id = 18446883868162294118) (10.4)
 

> B := Matrix([[1,2],[3,4]]);
 

Matrix(%id = 18446883868162294238) (10.5)
 

Matrizenprodukte werden mit . gebildet, Skalarmultiplikation wie gehabt mit *: 

> A.e1;
 

Vector[column](%id = 18446883868162294358) (10.6)
 

> A.B;
 

Matrix(%id = 18446883868162294478) (10.7)
 

> B.A;
 

Matrix(%id = 18446883868162294598) (10.8)
 

> e1.e2;
 

0 (10.9)
 

> 2*e1 + 3*e2;
 

Vector[column](%id = 18446883868162295078) (10.10)
 

> 2*A - B;
 

Matrix(%id = 18446883868162295198) (10.11)
 

Matrizen und Vektoren lassen sich natürlich nicht addieren: 

> A + e1;
 

Error, (in rtable/Sum) invalid input: dimensions do not match: Matrix(1 .. 2, 1 .. 2) cannot be added to Vector[column](1 .. 2)
 

Matrizen mit speziellen Strukturen lassen sich mit Zusatzoptionen definieren, z.B. die 3x3 Einheitsmatrix: 

> Matrix(3, 3, shape=identity);
 

Matrix(%id = 18446883868162295318) (10.12)
 

Alle gängigen Matrixoperationen sind natürlich verfügbar: 

> Transpose(B);
 

Matrix(%id = 18446883868162295678) (10.13)
 

> Determinant(B);
 

-2 (10.14)
 

> MatrixInverse(B);
 

Matrix(%id = 18446883868162296038) (10.15)
 

> CharacteristicPolynomial(A, lambda);
 

`+`(`*`(`^`(lambda, 2)), 1) (10.16)
 

> Eigenvalues(A);
 

Vector[column](%id = 18446883868162290862) (10.17)
 

Mehrfachzuweisung funktionieren wie in Matlab: 

> evals, evects := Eigenvectors(A);
 

Vector[column](%id = 18446883868162282310), Matrix(%id = 18446883868162282430) (10.18)
 

Die Eigenvektoren sind nun als Matrix gegeben, wir müssen sie extrahieren.  

Dabei bedeutet 1..-1 der Bereich von 1 bis zum letzten Index (siehe ?Matrix) 

> evec1 := evects[1..-1,1];
 

Vector[column](%id = 18446883868162283510) (10.19)
 

> evec2 := evects[1..-1,2];
 

Vector[column](%id = 18446883868162283630) (10.20)
 

Zum Test, die Eigenvektore/Eigenwerte stimmen: 

> A.evec1;
 

> evals[1]*evec1;
 

> % - %%;
 

 

 

(10.21)
 

Differentialgleichungen 

Differentialgleichungen werden mit diff-Kommando und dem D Operator definiert: 

> ode := diff(y(x),x,x) = 2*y(x) + 1;
 

(11.1)
 

Das Kommando dsolve löst Differentialgleichungen mit und ohne Anfangsbedingungen, wobei Integrationskonstanten mit vorangestelltem Unterstrich bezeichnet werden, damit sie nicht mit benutzerdefinierten Variablen in Konflikt geraten: 

> dsolve(ode, y(x));
 

y(x) = `+`(`*`(exp(`*`(`^`(2, `/`(1, 2)), `*`(x))), `*`(_C2)), `*`(exp(`+`(`-`(`*`(`^`(2, `/`(1, 2)), `*`(x))))), `*`(_C1)), `-`(`/`(1, 2))) (11.2)
 

Anfangsbedingungen werden wie folgt geschrieben: 

> ics := y(0)=1, D(y)(0)=0;
 

y(0) = 1, (D(y))(0) = 0 (11.3)
 

> sol := dsolve({ode,ics}, y(x));
 

y(x) = `+`(`*`(`/`(3, 4), `*`(exp(`*`(`^`(2, `/`(1, 2)), `*`(x))))), `*`(`/`(3, 4), `*`(exp(`+`(`-`(`*`(`^`(2, `/`(1, 2)), `*`(x))))))), `-`(`/`(1, 2))) (11.4)
 

Nun haben wir als Lösung einen Ausdruck (als Gleichung) erhalten, aber noch keine Funkion: 

> sol;
 

y(x) = `+`(`*`(`/`(3, 4), `*`(exp(`*`(`^`(2, `/`(1, 2)), `*`(x))))), `*`(`/`(3, 4), `*`(exp(`+`(`-`(`*`(`^`(2, `/`(1, 2)), `*`(x))))))), `-`(`/`(1, 2))) (11.5)
 

Dazu extrahieren wir den Ausdruck für y(x) aus der Lösung: 

> sol_expr := rhs(sol);
 

`+`(`*`(`/`(3, 4), `*`(exp(`*`(`^`(2, `/`(1, 2)), `*`(x))))), `*`(`/`(3, 4), `*`(exp(`+`(`-`(`*`(`^`(2, `/`(1, 2)), `*`(x))))))), `-`(`/`(1, 2))) (11.6)
 

Mit unapply (unary apply: "Mach eine Funktion mit einer Variablen draus!") können wir aus dem Ausdruck eine Funktion machen: 

> sol_func := unapply(sol_expr, x);
 

proc (x) options operator, arrow; `+`(`*`(`/`(3, 4), `*`(exp(`*`(`^`(2, `/`(1, 2)), `*`(x))))), `*`(`/`(3, 4), `*`(exp(`+`(`-`(`*`(`^`(2, `/`(1, 2)), `*`(x))))))), `-`(`/`(1, 2))) end proc (11.7)
 

> sol_func(1);
 

`+`(`*`(`/`(3, 4), `*`(exp(`*`(`^`(2, `/`(1, 2)))))), `*`(`/`(3, 4), `*`(exp(`+`(`-`(`*`(`^`(2, `/`(1, 2)))))))), `-`(`/`(1, 2))) (11.8)
 

> evalf(%);
 

2.767275334 (11.9)
 

Systeme von DGLn gehen ähnlich. Ein wenig komplizierter sind numerische Lösungen von DGLn zu handhaben: 

> ode := diff(x(t),t,t) + sin(x(t)) = 0;
 

> ics := x(0)=1, D(x)(0)=0;
 

 

(11.10)
 

Maple liefert jetzt eine Prozedur zurück, die die Lösung an gegebenen Stellen berechnet. Es stehen eine Reihe von verschiedenen Lösungsmethoden und Optionen zur Verfügung: 

> sol := dsolve({ode,ics}, x(t), type=numeric);
 

proc (x_rkf45) local _res, _dat, _vars, _solnproc, _xout, _ndsol, _pars, _n, _i; option `Copyright (c) 2000 by Waterloo Maple Inc. All rights reserved.`; if `<`(1, nargs) then error (11.11)
 

> sol(1);
 

[t = 1., x(t) = HFloat(0.6000853096007004), diff(x(t), t) = HFloat(-0.7549639738727852)] (11.12)
 

Mit subs kann man aus dieser Liste wieder die interessierenden Teile extrahieren, zum direkten Plotten gibt es das Kommando odeplot: 

> odeplot(sol, [t,x(t)], t=0..10*Pi);
 

Plot_2d
 

Wenn die Darstellung zu holprig ist, kann man dsolve mit einem range argument aufrufen und odeplot mit der Option refine feiner plotten lassen (siehe die Hilfe zu diesen Befehlen für mehr Infos): 

> myrange := 0..10*Pi;
 

> sol := dsolve({ode,ics}, x(t), type=numeric, range=myrange);
 

> odeplot(sol, [t,x(t)], t=myrange, refine=2);
 

 

 

proc (x_rkf45) local _res, _dat, _vars, _solnproc, _xout, _ndsol, _pars, _n, _i; option `Copyright (c) 2000 by Waterloo Maple Inc. All rights reserved.`; if `<`(1, nargs) then error
Plot_2d
 

 

Differentialgleichungssysteme 

Gekoppelte Differentialgleichungen lassen sich auf die gleiche Weise lösen 

> unassign('b','z')
> ode1:=diff(x(t),t)=a*(y(t)-x(t));
> ode2:=diff(y(t),t)=b*x(t)-y(t)-x(t)*z(t);
> ode3:=diff(z(t),t)=x(t)*y(t)-c*x(t);
 

> ics:=x(0)=1,y(0)=1,z(0)=1;
 

 

 

 

(11.1.1)
 

> sol2:=dsolve({ode1,ode2,ode3,ics},type=numeric,range=0..100,parameters=[a,b,c]):
> sol2(parameters);
 

[a = undefined, b = undefined, c = undefined] (11.1.2)
 

> sol2(parameters=[2,1,5])
 

[a = 2., b = 1., c = 5.] (11.1.3)
 

> odeplot(sol2,[x(t),y(t)],t=0..200,refine=2);
 

Plot_2d
 

> odeplot(sol2,[y(t),z(t)],t=0..200,refine=2,axes=boxed);
 

Plot_2d
 

> sol2(200)
 

[t = 200., x(t) = HFloat(4.9999999945809535), y(t) = HFloat(5.0000000336325074), z(t) = HFloat(-2.9408157005381883e-8)] (11.1.4)
 

Dabei wurden die freien Parameter a, b und c bei der Definition von sol2 in dsolve explizit angegeben. (Maple gibt sonst eine Warnung aus). 

Sie lassen sich so danach auch leicht verändern: 

> sol2(parameters=[1,1,1]);
 

[a = 1., b = 1., c = 1.] (11.1.5)
 

> odeplot(sol2,[y(t),z(t)],t=0..200,refine=2,axes=boxed);
 

Plot_2d
 

Vektoranalysis 

Das Package VectorCalculus stellt eine Methode bereit, um die Hesse-Matrix einer mehrdimensionalen Taylorreihenentwicklung berechnen zu lassen (typisch für Analysis II). Man kann die entsprechenden Befehle auch in einer verkürzten Form benutzen, ohne das Package vorher zu laden: 

> VectorCalculus[Hessian]( x^3*sin(y), [x,y]);
 

(12.1)
 

Der Gradient ist ebenfalls zu finden, wenn auch in ungewohnter Notation, es handelt sich trotzdem um einen normalen Maplevektor: 

> mygrad := VectorCalculus[Gradient]( cos(x*y), [x,y]);
 

Vector[column](%id = 18446883868162299414) (12.2)
 

> A.mygrad;
 

Vector[column](%id = 18446883868162299534) (12.3)
 

Benutzerdefinierte Funktionen 

Kompliziertere Prozeduren lassen sich mit proc definieren. Beachten Sie wieder den Zeilenumbruch mit SHIFT-ENTER und die Tabeingabe. # kommentiert den Rest der Zeile aus: 

> h := proc(i)
local c, s;              # definiere lokale variablen
s := [];                 # definiere eine leere liste
for c from 1 to i do     # lasse c die werte 1 bis i durchlaufen
s := [op(s), c]; # haenge den wert fuer c an die liste s an
end do;
return s;                # gib die liste s zurueck
end proc;
 

proc (i) local c, s; s := []; for c to i do s := [op(s), c] end do; return s end proc (13.1)
 

Diese Funktion macht jetzt dasselbe wie das Kommando seq: 

> h(5);
 

[1, 2, 3, 4, 5] (13.2)
 

> [seq(i,i=1..5)];
 

[1, 2, 3, 4, 5] (13.3)
 

Folgen kann man auch mit dem $-Operator erzeugen: 

> i$i=1..5;
 

1, 2, 3, 4, 5 (13.4)
 

Daten einlesen 

Erzeugen Sie die folgende Textdatei "data.txt" im selben Verzeichnis wie dieses Worksheet mit dem Inhalt: 

5 5.1 

6 5.5 

7 6.5 

8.5 9 

Nun lesen wir 2 Spalten ein, wobei der Inhalt als Liste von Listen (eine listlist) zurckgegeben wird. 

> rawdata := readdata("data.txt", 2);
 

[[5., 5.1], [6., 5.5], [7., 6.5], [8.5, 9.]] (14.1)
 

In dieser Form kann man die Daten sofort mit listplot anzeigen lassen: 

> listplot(rawdata, scaling=constrained);
 

Plot_2d
 

Umformatierungen müssen per Hand vorgenommen werden. Z.B. Transponieren der Daten: 

> convert(rawdata, Matrix);
 

Matrix(%id = 18446883868162299654) (14.2)
 

> Transpose(%);
 

Matrix(%id = 18446883868162299774) (14.3)
 

> convert(%, listlist);
 

[[5., 6., 7., 8.5], [5.1, 5.5, 6.5, 9.]] (14.4)
 

Daten speichern 

Textdateien mit selbstdefnierter Formatierung der Ausgabe konnen mit fprintf (file print formatted) erzeugt werden. Der printf Befehl steht in ähnlicher Form in diversen anderen Programmiersprachen wie C++, Python und der Shell zur Verfügung und ist unter Linux quasi allgegenwärtig. 

> x:=1; y:=evalf(Pi);
 

 

1
3.141592654 (15.1)
 

Man öffnet einfach eine Datei zur Ausgabe, schreibt die Werte mit fprintf in die Datei und schliesst sie danach wieder. Die Textdatei wird im aktuellen Arbeitsverzeichnis angelegt (bei Aufruf von Maple von der Kommandozeile aus). Wenn Maple vom Desktop aus gestartet wurde, ist dies meist das eigene Homeverzeichnis. Die Syntax der verschiedenen Formatierungen ist auf der Hilfeseite aufgelistet: 

> ?fprintf
 

> fd := fopen("maple_ouput.txt", WRITE);
fprintf(fd, "x = %d, y = %g", x, y);
fclose(fd);
 

Es ist so z.B. leicht machbar, LaTeX-Tabellen aus Maple Daten zu erzeugen. 

 

(15.2)
 

 

Soviel zu einem ersten Überblick. Themen, die hier nicht behandelt wurden, sind 

- diverse Spezialfunktionen: Besselfunktionen, Hermite-Polynome, etc. 

- Kombinatorik/Stochastik 

- Gruppentheorie 

- Vektorfelder in verschiedenen Koordinatensystemen 

- Oberflächenintegrale und dergleichen 

- Maplets selber erstellen 

- Rechnen mit phys. Einheiten 

- lineare/nicht-lineare Fits 

- Codegenerierung für Fortran und C 

 

Aber dazu gibts viel Infos in der Hilfe und im WWW! 

Beachten Sie auch bitte das Übungsblatt, das die hier vorgestellten Techniken und den Umgang mit Maple vertieft.