unix> maple -x oder unix> xmaplestartet 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> mapleHilfe 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, FAILDie 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 GenauigkeitOhne Angabe der Genauigkeit wird auf die globale Variable Digits zurückgegriffen (Voreinstellung: 10).
> evalf(Pi); 3.141592654 > evalf(gamma, 20); 0.57721566490153286061Symbolisch 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 > ?inifcnEigene 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); 5Die 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 > ?simplifyPolynome:
> 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 NullstellenRationale 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 - vTrigonometrische 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 tWie 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); partiellDifferentiation 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]; -3Bei 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); 1Gibt 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]); -1In 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) = 0sieht 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 anzeigenDas 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_typesLesen 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