Direkt zum InhaltDirekt zur SucheDirekt zur Navigation
▼ Zielgruppen ▼

Humboldt-Universität zu Berlin - Mathematisch-Naturwissen­schaft­liche Fakultät - Institut für Physik

Ü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 anonymen Funktion:

      > 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