Übersicht über Maple
Aufruf, Hilfe
Der Aufruf aus dem KDE-Menü oder am Unix-Prompt:
unix> maple -x
oder unix> xmaple
startet die interaktive Sitzung mit der grafischen Oberfläche. Dort gibt es ein Kommando-Fenster mit dem Maple-Prompt ">" (worksheet) und eine Online-Hilfe unter ->Help.
Man beendet die Sitzung mit ->File ->Exit.
Das (alte) Kommandofenster im Textmodus startet man mit
unix> maple
Hilfe und Programmende:
> ?stichwort Hilfe zu "stichwort"
> quit beenden
Notation
Kommandos werden mit ";" oder mit ":" abgeschlossen, letzteres unterdrückt die Ausgabe des Ergebnisses ins Fenster.
Die letzten drei Resultate kann man als % %% %%% zurückrufen.
Symbolische Namen bestehen aus Groß-und Kleinbuchstaben (signifikant), Ziffern und dem Unterstrich.
Vordefinierte Konstanten:
Pi, I, gamma, Catalan
infinity, true, false, FAIL
Die Eulersche Zahl e ist übrigens nicht dabei, sie steht als exp(1) zur Verfügung.
Die wichtigsten Operatoren:
arithmetisch: + - * / ^ ** !
Vergleich: = <> < > <= >=
logisch: and or not
Zeichenverkettung: .
Zeichenketten werden eingegeben wie "hallo".
Zuweisung
> var := expr;
> unassign('var'); loescht Belegung von var
> restart; loescht alle Belegungen
Folgen, Mengen, Listen, Bereiche
a,b,c Folge (sequence)
{a,b,c} (ungeordnete) Menge (set)
[a,b,c] (geordnete) Liste (list)
a..b Bereich (range)
In einer Menge haben die Elemente keine feste Reihenfolge, Doppeleinträge werden unterdrückt. Ein Zugriff mit Index ist möglich, aber nicht sinnvoll.
Zugriff auf Elemente einer Liste (oder Folge):
> lst := [a,b,c,d];
> lst[2];
b
> lst[2..4];
[b,c,d]
Elementweise Anwendung einer Funktion auf eine Menge/Liste:
> map(fcn, set);
> map(fcn, list);
Auswertung
Ausdrücke mit Kommazahlen werden automatisch numerisch ausgewertet:
> 1./3;
> sin(1.);
Mit evalf (floating point) wird die Numerik erzwungen:
> evalf(expr);
> evalf(expr, n); mit Angabe der Genauigkeit
Ohne Angabe der Genauigkeit wird auf die globale Variable Digits zurückgegriffen (Voreinstellung: 10).
Beispiele:
> evalf(Pi);
3.141592654
> evalf(gamma, 20);
0.57721566490153286061
Symbolisch Auswertung (Substitution):
> eval(expr, var=value); mit (aufgeloester) Gleichung
> eval(expr, eqns); mit Menge/Liste von Gleichungen
z.B. > eval(sqrt(a^2 + b^2), a=5);
sqrt(25+b^2)
> eval(sqrt(a^2 + b^2), {a=5, b=c^2});
sqrt(25+c^4)
Funktionen
Vordefiniert sind u.a.
sqrt exp log ln log10
sin cos tan cot sec csc arcsin arccos ...
sinh cosh tanh coth sech csch arcsinh arccosh ...
Eine vollständige Übersicht bekommt man mit
> ?functions
> ?inifcn
Eigene Funktionen definiert man in einfachen Fällen so:
> f := x -> expr;
> f := (x,y) -> expr;
z.B. > gauss := x -> exp(-x^2);
gauss := x -> exp(-x^2)
> gauss(t);
exp(-t^2)
> radius := (x,y) -> sqrt(x^2 + y^2);
radius := (x, y) -> sqrt(x^2+y^2)
> radius(3,4);
5
Die allgemeine Form lautet:
> f := unapply(expr, x); Aufruf: f(x)
> f := unapply(expr, x, y); Aufruf: f(x,y)
z.B. > f := unapply( diff(sin(x), x), x);
f := x -> cos(x)
> f(u);
cos(u)
unapply verwandelt einen symbolischen Ausdruck in eine anonyme Funktion, die man mit Argument aufruft.
Umformung
Allgemein:
> simplify(expr);
> simplify(expr, sqrt); benutzt Regeln fuer sqrt, wenn moeglich
> simplify(expr, ln); benutzt Regeln fuer ln, wenn moeglich
siehe > ?simplify
Polynome:
> expand(expr);
> factor(expr);
> coeff(expr, var, n); Koeffizient von var^n
> collect(expr, var); Potenzen von var ausklammern
> collect(expr, var, factor); ... und Koeffizienten faktorisieren
> sort(expr, var); nach Potenzen von var ordnen
> factor(pol, real); numerische Faktorisierung
> factor(pol, complex); dasselbe, mit komplexen Nullstellen
Rationale Funktionen:
> normal(expr); bringt auf einen Nenner; faktorisiert
> normal(expr, expanded); dasselbe, Zaehler und Nenner ausmultipliziert
> expand(expr); Zaehler ausmultiplizieren, Bruch verteilen
> factor(expr); dasselbe wie "normal"
z.B. > normal( 1/(x+1)^2 - 2/x + 3*x );
2 4 3
-3 x + x - 2 + 3 x + 6 x
---------------------------
2
(x + 1) x
> r:= (u+v)^2*u/((u^2-v^2)*v);
2
(u + v) u
r := -----------
2 2
(u - v ) v
> expand(r);
3 2
u 2 u u v
----------- + ------- + -------
2 2 2 2 2 2
(u - v ) v u - v u - v
> normal(r);
u (u + v)
---------
v (u - v)
> normal(r, expanded);
2
u + u v
--------
2
u v - v
> expand(%);
2
u u v
-------- + --------
2 2
u v - v u v - v
Trigonometrische Funktionen:
> simplify(expr); benutzt sin(x)^2 + cos(x)^2 = 1
> expand(expr); mit Additionstheorem etc
> combine(expr); Produkte/Potenzen -> Summen
z.B. > simplify(1 + tan(x)^2);
1
-------
2
cos(x)
> expand(sin(x+2*y));
2
2 sin(x) cos(y) - sin(x) + 2 cos(x) sin(y) cos(y)
> combine(%);
sin(x + 2 y)
Summe und Produkt
> sum(expr, var=range); symbolisch
> add(expr, var=const_range); numerisch
z.B > sum(x^k, k=1..n);
> simplify(%);
(n + 1)
x - x
------------
x - 1
> sum(1/k^4, k=1..infinity);
4
Pi
---
90
> product(expr, var=range); symbolisch
> mul(expr, var=const_range); numerisch
Reihenentwicklungen
> series(expr, var, order);
> series(expr, var=value, order);
> asympt(expr, var, order);
z.B. > series(sin(x)/x, x, 10); um x=0
2 4 6 8 9
1 - 1/6 x + 1/120 x - 1/5040 x + 1/362880 x + O(x )
> series(tan(x), x=a, 6); um x=a
> asympt(t/sqrt(1+t^2), t, 3); Verhalten fuer grosses t
Wie man am Ordnungssymbol O(..) erkennt, ist das Resultat einer Reihenentwicklung kein Ausdruck der üblichen Art, sondern ein Objekt vom Typ "Taylor". Das entsprechende endliche Polynom (ohne O(..)) erhält man mit dem Befehl convert:
> ser := series(sin(x)/x, x, 10);
> pol := convert(ser, polynom);
Grenzwert
> limit(expr, var=value);
Differentiation
> diff(expr, var);
> diff(expr, var1, var2,..);
z.B. > diff(f, x); erste Abl.
> diff(f, x, x); zweite Abl.
> diff(f, x$2); dasselbe
> diff(f, x, y); partiell
Differentiation einer
> h := D(sin);
> h(x);
cos(x)
Das Resultat ist hier wieder eine anonyme Funktion, man braucht also kein unapply.
Für höhere und partielle Ableitungen gibt es mehrere Notationen, z.B. für die zweite Ableitung:
> D(D(sin));
-sin
> (D@@2)(sin);
-sin
Integration
> int(expr, var); unbestimmt
> int(expr, var=range); bestimmt
z.B. > int(sin(t), t);
> int(cos(t), t=0..Pi);
> evalf(Int(expr, range)); numerisch
> evalf(Int(expr, range), n);
Gleichungen
solve gibt die symbolische(n) Lösung(en) einer Gleichung als Ausdruck bzw. Folge von Ausdrücken zurück, auf einzelne Lösungen kann dann mit Index zugegriffen werden:
> solve(eqn, var);
> solve(expr, var); loest expr=0
z.B. > solve(a*x + b, x);
-b/a
> eqn := a*x = b*x + y;
> solve(eqn, x);
y
-----
a - b
> sol := solve(x^2 = 9, x);
sol := 3, -3
> sol[1];
3
> sol[2];
-3
Bei einem Gleichungssystem gibt man sowohl die Gleichungen als auch die Unbekannten als Mengen an und erhält die Lösung als Menge von aufgelösten Gleichungen zurück, die man mit eval weiter verarbeiten kann:
> solve({eqn1, eqn2}, {var1, var2});
z.B. > sol := solve({x+y=4, x-y=2}, {x,y});
sol := {y=1, x=3}
> eval(x, sol);
3
> eval(y, sol);
1
Gibt es mehrere Lösungen, dann entsteht eine Folge von Mengen:
> sol := solve({x^2 + y^2 = 2, x*y = 1}, {x,y});
sol := {x = 1, y = 1}, {x = -1, y = -1}
> sol[2];
{x = -1, y = -1}
> eval(y, sol[2]);
-1
In einigen komplizierteren Fällen drückt solve die Lösungen symbolisch durch die Nullstellen eines Polynoms aus und benutzt dazu die Notation RootOf(..) mit der formalen Variablen _Z. Eine explizite Darstellung kann man daraus mit allvalues erhalten.
Ein einfaches Beispiel:
> solve({x^2 + 2*x = 1, x*y = 1}, {x, y});
2 2
{x = RootOf(_Z + 2 _Z - 1), y = 2 + RootOf(_Z + 2 _Z - 1)}
> allvalues(%);
1/2 1/2 1/2 1/2
{x = 2 - 1, y = 1 + 2 }, {x = -1 - 2 , y = 1 - 2 }
Differentialgleichungen
Differentialgleichungen löst man mit dsolve. Für die Formulierung von Anfangsbedingungen ist es günstig, die Lösung als anonyme Funktion anzusetzen. Man löst z.B. die Gleichung
y'(x) = 2 y(x)
durch
> dgl := D(y)(x) = 2*y(x);
dgl := D(y)(x) = 2*y(x)
> loes := dsolve(dgl, y(x));
loes := y(x) = _C1*exp(2*x)
Man erhält also die allgemeine Lösung (Integrationskonstante _C1), und zwar als Gleichung.
Die Anfangsbedingung y(0) = 3 wird so eingebaut:
> anf := y(0) = 3;
anf := y(0) = 3
> loes := dsolve({dgl, anf}, y(x));
loes := y(x) = 3*exp(2*x)
Und so bekommt man die Lösung als (anonyme) Funktion:
> y := unapply(rhs(loes), x);
y := x -> 3*exp(2*x)
Für eine Gleichung 2. Ordnung, z.B. die Schwingungsgleichung
f''(t) + f(t) = 0 f(0) = 1 f'(0) = 0
sieht das so aus:
> dgl := D(D(f))(t) + f(t) = 0;
> anf1 := f(0) = 1;
> anf2 := D(f)(0) = 0;
> loes := dsolve({dgl, anf1, anf2}, f(t));
loes := f(t) = cos(t)
> f := unapply(rhs(loes), t);
f := t -> cos(t)
Vektoren und Matrizen
> with(LinearAlgebra); Paket laden
> v := Vector([1, 2, 4]); explizite Eingabe
> A := Matrix([[5, 6, 7], [11, 12, 13]]);
z.B. > Vector(3) 3-komp. Nullvektor
> Vector(5,2) 5-komp. Vektor mit Elementen = 2
> f:= k -> k^3; Vector(5,f); 5-komp. Vektor mit Kubikzahlen
> A := Matrix(2,3,symbol=a); symbolische Matrixelemente
> v[2]; Zugriff auf Element
> A[2,3];
> DotProduct(v, w); Skalarprodukt
> v . w; ...
> CrossProduct(v, w); Vektorprodukt
> v &x w; ...
> Multiply(A, B); Matrix-Multiplikation
> A . B; ...
> Norm(v, 2); Euklidische Norm
> Transpose(A); transponierte Matrix
> MatrixInverse(A); inverse Matrix
> Determinant(A); Determinante
> LinearSolve(A, B); loest A x = B
Grafik
> plot(f, range);
z.B. > plot(sin(x)/x, x=0..2*Pi);
> plot([fx, fy, range]); parametrisch
z.B. > plot([cos(phi), sin(phi), phi=0..Pi]);
> plot3d(expr, range1, range2); Flaeche in 3D
z.B. > plot3d(sin(x)^2 * sin(y)^2, x=-Pi..Pi, y=-Pi..Pi);
Die Grafik wird normalerweise in die Arbeitsfläche eingeblendet. Mit der rechten Maustaste oder über den Menüpunkt "Plot" kann man sie dann exportieren, entweder als EPS (empfohlen) oder als JPEG.
Man kann die Grafikausgabe auch ganz umlenken, indem man vor dem Plotbefehl ein plotsetup vornimmt:
> plotsetup(eps, plotoutput="filename", plotoptions="portrait");
> plotsetup(x11); (terminal: ->plot window)
> plotsetup(maplet); (->Maple application window)
> plotsetup(default); (->worksheet)
> plotsetup(help); (list supported devices)
So stehen noch mehr Grafikformate zur Verfügung, u.a. PNG, aber kein PDF.
Das aktuelle Arbeitsverzeichnis wird mit folgenden Befehlen angezeigt und gewechselt:
> currentdir(); Verzeichnis anzeigen
> currentdir("newdir"); Verzeichnis wechseln
(zeigt danach das _alte_ Verzeichnis an!)
> listdir("dir"); Inhalt anzeigen
Das Wechseln muss man (in der graphischen Oberfläche) ggf. erst freischalten:
->Tools ->Options ->Security
[x] Enable system/ssystem commands
Skripte
Ein Maple-Skript ist eine Textdatei, die Befehle enthält, wie man sie auch interaktiv eingeben würde.
Kommentare werden durch # eingeleitet.
Aufruf aus Maple:
> read "filename";
> read "filename": ohne Schirmausgabe
I/O
Der folgende Befehl liest n Spalten eines Datenfiles und speichert sie in der Matrix dat:
> dat := readdata("filename", n);
Und so schreibt man dieselbe Matrix in ein File:
> writedata("filename", dat);
In einem Skript mag es sinnvoll sein, Werte interaktiv (mit Prompt) einzugeben und Resultate einfach auf die Arbeitsfläche zu schreiben:
> z := readstat("prompt"); Tastatur-Eingabe lesen und auf z speichern
> print(expr, ..); Standard-Ausgabe (worksheet)
In der grafischen Oberfläche zeigt readstat z.Zt. (Maple 11-17) das Prompt in der Kopfleiste des Eingabefensters (KDE) oder überhaupt nicht (z.B. Fvwm) an, das hängt also vom Window-Manager ab und ist nicht in Ordnung.
Kontrollstrukturen
Die einfachste Schleife wird durch do ...end do gebildet und mit break verlassen, z.B. berechnet
n := 1;
do
if n > 100 then break end if;
n := 2*n;
end do;
die kleinste Zweierpotenz über 100. Dasselbe mit einer while-Bedingung am Anfang:
n := 1;
while n <= 100 do
n := 2*n;
end do;
Natürlich kann man eine Schleife auch mit einer Kontrollvariablen steuern:
for k from -6 to 6 by 2 do
if k = 0 then next end if;
print(1/k);
end do;
Hier wird der Fall k = 0 durch next übersprungen.
Die allgemeine if--Verzweigung hat folgende Form:
if condition then
statements
elif condition then
statements
elif condition then
statements
...
else
statements
end if;
Einstellungen
Die grafische Oberfläche kennt noch den (alten) Worksheet Mode, ist aber auf den neuen Document Mode voreingestellt, in dem man vollständige Dokumente gestalten kann. Insbesondere werden eingegebene Formeln sofort mathematisch dargestellt (2D Math Notation). Das sieht gut aus, hat aber seine Tücken: so führt ein Leerzeichen zwischen Funktionsname und Argumentklammer (z.B. "sin (phi)") dazu, dass das Argument als Faktor interpretiert wird, was kaum zu erkennen ist.
Man kann vorübergehend auf die alte, einzeilige Eingabe (Maple Input) umschalten (Schaltfläche oberhalb des Eingabefeldes) und auch den Worksheet Mode dauerhaft einstellen:
->Tools ->Options
->Display Input display: Maple Notation
->Interface Default format for new worksheets: Worksheet
Apply to Session (nur fuer die aktuelle Sitzung)
Apply Globally (dauerhaft)
Solche Einstellungen werden übrigens in ~/.maple/<version>/maplerc gespeichert.
Anhang
Sitzung speichern
Maple worksheets (Dateiname: *.mw bzw. *.mws für classical worksheet):
->File ->Save as... abspeichern
->File ->Open... laden
Daten formatiert lesen und schreiben
> fd := fopen("filename", mode, type);
mode = READ, WRITE or APPEND
type = TEXT (default) or BINARY
> fclose(fd);
> fd := open("filename", mode); "raw mode"
mode = READ or WRITE
> close(fd);
siehe > ?file_types
Lesen und schreiben mit C-artigen Formatierungen:
> printf(fmt, x1, x2, ..);
> sprintf(fmt, x1, x2, ..);
> fprintf(file, fmt, x1, x2, ..); file = name or fd
> scanf(fmt);
> sscanf(string, fmt);
> fscanf(file, fmt);
Batchbetrieb
Aufruf eines Skripts von der Kommandozeile aus (batch mode):
unix> maple -q scriptfile
unix> maple -q scriptfile >/dev/null ohne Output
Burkhard Bunk, 04.03.2014