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
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".
> var := expr;
> unassign('var'); loescht Belegung von var
> restart; loescht alle Belegungen
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);
> 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).
> 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)
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.
> 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)
> 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
> 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);
> limit(expr, var=value);
> 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.
> D(D(sin));
-sin
> (D@@2)(sin);
-sin
> 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);
> 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.
> 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 }
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.
> 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)
> 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
> 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
> read "filename";
> read "filename": ohne Schirmausgabe
> 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.
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;
->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.
->File ->Save as... abspeichern
->File ->Open... laden
> 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);
unix> maple -q scriptfile
unix> maple -q scriptfile >/dev/null ohne Output