Ing Mathematik: Computeralgebrasysteme am Beispiel von Maxima

Zurück zu Gnuplot | Hoch zu Gesamtinhaltsverzeichnis | Vor zu Octave

Einleitung

Was ist Maxima?

• Maxima ist ein Computeralgebrasystem.
• Maxima ist Open Source (GPL-Lizenz).
• Maxima ist für viele Betriebssysteme erhältlich (z.B. für Linux, MS Windows, macOS).
• Maxima ist ein Interpreter.
• Maxima als Programmiersprache ist case-sensitive - d.h. Groß- und Kleinschreibung ist relevant bei der Eingabe von Befehlen.

Installation

Downloaden können Sie das Programm von der Seite [1]. Unter MS Windows können Sie dann das Setup-Programm ausführen. Die Installationsprozedur ist wie bei jedem anderen größeren Programm.

Auf der Maxima-Download-Seite für MS Windows wird empfohlen, die zwei Grafikprogramme

plot2d (x, [x,0,1]);
plotdf ([y,-x]);

auszuführen. Das sollten Sie auch machen. Öffnen Sie das Maxima-Programm. Dazu gibt es mehrere Möglichkeiten. Z.B. über Start (der Button links unten am Bildschirm) -> Maxima computer algebra system -> Maxima (command line). Geben Sie beiden Befehle nacheinander ein. Tritt dabei eine Fehlermeldung der Art

Maxima encountered a Lisp error:

 Error opening #P"C:/Users...
   Das System kann den angegebenen Pfad nicht finden.

auf, so müssen Sie den Pfad abändern. Das Problem ist wahrscheinlich, dass der Pfadname Sonderzeichen (Umlaute, ß etc.) aufweist. Lösung des Problems - geben Sie einen anderen Pfadnamen ohne Sonderzeichen ein (der Pfad muss natürlich existieren):

maxima_tempdir : "c:/tmp";

Testen Sie nochmal

plotdf ([y,-x]);

Es sollte sich eine Grafik, die ein Vektorfeld zeigt, öffnen.

Der folgende Text bezieht sich auf die Maxima-Versionen 5.43.2 und 5.47.0. Getestet wurden die Programme unter dem Betriebssystem MS Windows 10.

Hallo Welt

Starten Sie Maxima z.B. durch doppelklicken von ...\bin\maxima.bat im Explorer. Die drei Punkte müssen Sie durch das Installationsverzeichnis, in dem Sie Maxima installiert haben, ersetzen (z.B. durch C:\Programme\maxima). Es öffnet sich ein Konsolenfenster folgenden Inhalts:

Maxima 5.43.2 http://maxima.sourceforge.net
using Lisp SBCL 1.4.14
Distributed under the GNU Public License. See the file COPYING.
Dedicated to the memory of William Schelter.
The function bug_report() provides bug reporting information.
(%i1)

Hier geben wir folgenden Befehl ein

(%i1) print("Hallo, Welt");
Hallo, Welt
(%o1)                             Hallo, Welt
(%i2)

Der Prompt (z,B. (%i1)) ist natürlich nicht einzutippen, sondern wird vom Maxima-Interpreter geliefert. "i" soll auf eine Eingabezeile hinweisen ("input"). "o" steht für eine Ausgabezeile ("output"). Die Nummerierung ist in den folgenden Beispielen nicht durchgängig konsistent. Das ist aber egal, da Maxima die Nummern ohnehin automatisch vergibt. Nur wenn Sie, wie später erklärt, die Zeilennummer in einer Rechnung verwenden, müssen Sie darauf achtgeben. Ihre Eingabe müssen Sie mit einem Strichpunkt abschließen.

Maxima als Taschenrechner

Wir wollen nun eine einfache Rechnung mit Maximas Hilfe lösen, nämlich wieviel ist 3*5?

Eingabe:

(%i1) 3*5;

Ausgabe:

(%o1)                                 15
(%i2)

Alternativ kann man auch eine grafische Benutzeroberfläche namens wxMaxima benutzen. Starten Sie dieses Programm durch doppelklicken von ...\wxMaxima\wxmaxima.exe. Die drei Punkte stehen wie weiter oben erläutert für das Installationsverzeichnis von Maxima. Es öffnet sich die wxMaxima-GUI:

Tippen Sie einfach wie oben 3*5; ein:

Schließen Sie die Anweisung durch Drücken von STRG-RETURN ab:

Sie erhalten somit das selbe Ergebnis wie vorher im Konsolenfenster (wie sollte es auch anders sein?)!

Wünschen Sie aus irgend einem Grund keine Ausgabe am Bildschirm, so haben Sie den Befehl mit einem $ abzuschließen, z.B.

(%i3) 3 * 5$

Ein etwas komplexeres Beispiel ist Folgendes:

(%i4)	34/33 - 21/124;
                                    3523
(%o4)                               ----
                                    4092
(%i5)

Bereits hier läßt sich die Mächtigkeit von Maxima erahnen. Es wird ein exaktes Bruchergebnis geliefert und nicht eine genäherte Dezimalzahl.

Natürlich lassen sich mit Maxima auch Winkelfunktionen etc. berechnen. Beispielsweise soll hier $\sin(\pi /4)$ berechnet werden. Konstante (wie die Zahl $\pi$) werden in Maxima durch ein %-Zeichen eingeleitet.

(%i5)	sin(%pi/4);
                                      1
(%o5)                              -------
                                   sqrt(2)

Will man einen numerischen Ausgabewert erzwingen, so wird dem Befehl eine "numer"-Anweisung angefügt (beachten Sie: vor numer steht ein Beistrich, kein Strichpunkt):

(%i6) sin(%pi/4), numer;
(%o6)                        0.7071067811865475

Umgekehrt kann eine Dezimalzahl auch als Bruch dargestellt werden, z.B.:

(%i8) a : .25;
(%o8)                                0.25
(%i9) rat(a);

rat: replaced 0.25 by 1/4 = 0.25
                                       1
(%o9)/R/                               -
                                       4
(%i10)

Werden Anweisungen zu lang, so können Sie diese durch Eingabe von RETURN in mehrere Zeilen umbrechen, z.B.

(%i7) 5 *
3;
(%o7)                                 15
(%i8)

Auch auf frühere Ergebnisse können Sie wieder zugreifen, z.B. mit

(%i8) %o7;
(%o8)                                 15
(%i9)

oder

(%i9) %i7 / 2, numer;
(%o9)                                 7.5
(%i10)

Mit %; greifen Sie auf das letzte gelieferte Ergebnis zu.

Auch eine Hilfefunktion ist in Maxima eingebaut. Tippen Sie z.B. einfach "describe(sin);" (natürlich ohne Anführungszeichen) in das Maxima-Konsolenfenster ein, und Sie erhalten folgende Ausgabe:

(%i10) describe(sin);

-- Function: sin (<x>)

    - Sine.

  There are also some inexact matches for `sin'.
  Try `?? sin' to see them.

(%o10)                                true
(%i11)

Beenden können Sie Maxima durch Eingabe von "quit();" und die RETURN-Taste drücken.

Der Befehl "kill(all);" löscht den Speicher.

Maxima als Skriptsprache

Werden Anweisungen komplexer, so will man sie nicht immer von Neuem eintippen, sondern in Dateien speichern und diese Dateien zur Ausführung bringen.

Geben Sie den folgenden Programmcode in einen Texteditor Ihrer Wahl ein und speichern Sie diese Datei unter "c:\tmp\test1.max". Die Dateiendung ".max" ist nicht obligatorisch. In der Literatur finden sich auch andere Beispiele, z.B. ".mac".

/* Multiplikation */
4*66;

Die erste Zeile ist ein Kommentar, der vom Maxima-Interpreter ignoriert wird. Kommentare werden in Maxima in /* */geklammert. Die zweite Zeile ist die gewünschte Berechnung (eine Multiplikation).

Geben Sie nun folgenden "batch"-Befehl in die Maxima-Konsole ein:

(%i6) batch("c:/tmp/test1.max");

Als Ausgabe erhalten Sie:

read and interpret c:/tmp/test1.max
(%i7) 4*66
(%o7)                                 264
(%o8)                          c:/tmp/test1.max
(%i9)

Beachten Sie: Hier sind Unix-artige Slashs angeführt. Zumindest unter MS Windows können Sie auch Doppel-Backslashs verwenden ("c:\\tmp\\test1.max").

Variablen

Werte an Variablen werden mittels Doppelpunkt zugewiesen. Speichern Sie folgende Anweisungsfolge in der Datei c:\tmp\test1.max (dies ist auch im Folgenden die Datei in der unsere Skripte gespeichert werden):

a : 5*3;
b : a+4;

Führen Sie dieses Skript mittels "batch"-Befehl, wie bereits weiter oben gehandhabt, aus.

(%i9) batch("c:/tmp/test1.max);

Als Ausgabe erhalten Sie:

read and interpret c:/tmp/test1.max
(%i10) a:5*3
(%o10)                                15
(%i11) b:a+4
(%o11)                                19
(%o12)                         c:/tmp/test1.max
(%i13)

Dieses Merkmal mit dem Doppelpunkt ist sinnvoll. Denn wie man am nachfolgenden Beispiel ersehen kann, ist eine Zuweisung keine mathematische Gleichung. Somit ist der Doppelpunkt einleuchtender als das Gleichheitszeichen, welches viele andere Programmiersprachen für eine Wertzuweisung verwenden.

Eingabedatei:

a : 5*3;
a : a+2;

Ausgabe:

read and interpret c:/tmp/test1.max
(%i16) a:5*3
(%o16)                                15
(%i17) a:a+2
(%o17)                                17
(%o18)                         c:/tmp/test1.max
(%i19)

Einer Variablen können im Programmablauf verschiedene Datentypen zugewiesen werden.

a : "Hallo";
a : 2;
a : %pi, numer;

Ausgabe:

read and interpret c:/tmp/test1.max
(%i20) a:"Hallo"
(%o20)                               Hallo
(%i21) a:2
(%o21)                                 2
(%i22) ev(a:%pi,numer)
(%o22)                         3.141592653589793
(%o23)                         c:/tmp/test1.max
(%i24)

Maxima ist case-sensitiv, d.h. die Variablenbezeichner xyz, xYz, XYZ repräsentieren unterschiedliche Variablen.

Alle Variablen löscht der Befehl

remvalue(all);

Funktionen

Eine Funktion lässt sich in Maxima folgendermaßen darstellen

f(x) := x^2;
f(3);

Ausgabe:

read and interpret c:/tmp/test1.max
(%i25) f(x):=x^2
                                           2
(%o25)                            f(x) := x
(%i26) f(3)
(%o26)                                 9
(%o27)                         c:/tmp/test1.max
(%i28)

Alle Funktionen löscht der Befehl

remfunction(all);

Blöcke

Eingabedatei:

block(
  x1 : 1,
  x2 : 2,
  x3 : x1 + x2
);

Ausgabe:

read and interpret c:/tmp/test1.max
(%i2) block(x1:1,x2:2,x3:x1+x2)
(%o2)                                  3
(%o3)                          c:/tmp/test1.max
(%i4)

Die einzelnen Anweisungen werden durch Beistriche getrennt. Als Ergebnis wird die letzte Anweisung herangezogen.

Verzweigungen

if then else

x : 1;
if (x>2) then print("IF THEN-Zweig") else print("ELSE-Zweig");

Ausgabe:

read and interpret c:/tmp/test1.max
(%i80) x:1
(%o80)                                 1
(%i81) if x > 2 then print("IF THEN-Zweig") else print("ELSE-Zweig")
ELSE-Zweig
(%o81)                            ELSE-Zweig
(%o82)                         c:/tmp/test1.max
(%i83)

Eine if-Verweigung mit mehreren Anweisungen kann man so schreiben:

x : 1;
if (x>2) then 
(
  print("IF THEN-Zweig"), 
  print("IF-THEN-Zweig 2")
)
else
( 
  print("ELSE-Zweig"),
  print("ELSE-Zweig 2")
);

Ausgabe:

read and interpret c:/tmp/test1.max
(%i8) x:1
(%o8)                                  1
(%i9) if x > 2 then (print("IF THEN-Zweig"),print("IF-THEN-Zweig 2"))
          else (print("ELSE-Zweig"),print("ELSE-Zweig 2"))
ELSE-Zweig
ELSE-Zweig 2
(%o9)                            ELSE-Zweig 2
(%o10)                         c:/tmp/test1.max
(%i11)

elseif

x : 1;
if (x=0) then 
  print("IF THEN-Zweig")
elseif (x=1) then
  print("ELSE IF-Zweig")   
else 
  print("ELSE-Zweig");

Ausgabe:

read and interpret c:/tmp/test1.max
(%i92) x:1
(%o92)                                 1
(%i93) if x = 0 then print("IF THEN-Zweig") elseif x = 1
           then print("ELSE IF-Zweig") else print("ELSE-Zweig")
ELSE IF-Zweig
(%o93)                           ELSE IF-Zweig
(%o94)                         c:/tmp/test1.max
(%i95)

Schleifen

Klassische Zählschleife

for i:1 step 1 thru 5 do 
  print(i);

Ausgabe:

read and interpret c:/tmp/test1.max
(%i96) for i thru 5 do print(i)
1
2
3
4
5
(%o96)                               done
(%o97)                         c:/tmp/test1.max
(%i98)

Verbale Beschreibung: Von i gleich 1 bis 5 zähle hoch. Die Schrittweite sei 1. Schreibe die Zahlen i in das Konsolenfenster.

for-while-do

for i:1 step 1 while i<=5 do
  print(i);

Ausgabe:

read and interpret c:/tmp/test1.max
(%i26) for i while i <= 5 do print(i)
1
2
3
4
5
(%o26)                               done
(%o27)                         c:/tmp/test1.max
(%i28)

for-unless-do

for i:1 step 1 unless i>5 do
  print(i);

Ausgabe:

read and interpret c:/tmp/test1.max
(%i29) for i unless i > 5 do print(i)
1
2
3
4
5
(%o29)                               done
(%o30)                         c:/tmp/test1.max
(%i31)

Terme und Gleichungen

Gleichheit von Termen

Sie wollen feststellen, ob die beiden Terme $5(x-3)$ und $5x-15$ gleich sind. Mit Maxima ist das kein Problem. Die fast natürlichsprachige Anweisung für diesen Test lautet wie folgt:

is ( equal (
  5*(x - 3),
  5*x - 15
  )
);

Ausgabe:

read and interpret c:/tmp/test1.max
(%i14) is(equal(5*(x-3),5*x-15))
(%o14)                               true
(%o15)                         c:/tmp/test1.max
(%i16)

Das Ergebnis ist "true", d.h. die beiden Terme dies- und jenseits des Gleichzeichens sind identisch. Folgende Eingabedatei liefert ein "false" (= nicht ident):

is ( equal (
  5*(x - 3),
  5*x + 15
  )
);

Ausgabe:

read and interpret c:/tmp/test1.max
(%i17) is(equal(5*(x-3),5*x+15))
(%o17)                               false
(%o18)                         c:/tmp/test1.max
(%i19)

Dass diese Vergleiche auch Grenzen haben, sei an folgendem Beispiel dargestellt:

is ( equal (
  cos(a+b),
  cos(a)*cos(b) - sin(a)*sin(b)
  )
);

Ausgabe:

read and interpret c:/tmp/test1.max
(%i23) is(equal(cos(alpha+beta),cos(alpha)*cos(beta)-sin(alpha)*sin(beta)))
(%o23)                              unknown
(%o24)                         c:/tmp/test1.max
(%i25)

Hier kann Maxima nicht entscheiden, ob die beiden Terme gleich sind (unknown). Folgendes allerdings kann Maxima

trigexpand(cos(alpha+beta));

Ausgabe:

read and interpret c:/tmp/test1.max
(%i5) trigexpand(cos(alpha+beta))
(%o5)             cos(alpha) cos(beta) - sin(alpha) sin(beta)
(%o6)                          c:/tmp/test1.max
(%i7)

Der Gleichungslöser

Löse die quadratische Gleichung $x^{2}+x-5=10$

solve([x^2+x-5 = 10], [x]);

Ausgabe

                           sqrt(61) + 1      sqrt(61) - 1
(%o2)               [x = - ------------, x = ------------]
                                2                 2
(%o3)                          c:/tmp/test1.max
(%i4)

Numerische Nullstellen

Finde eine Nullstelle im Intervall $x\in (-2,4)$ für die Funktion $x^{2}+x-4$. Die Funktion muss kein Polynom sein.

find_root(x^2+x-4, x, -2, 4);

Ausgabe:

read and interpret c:/tmp/test1.max
(%i2) find_root(x^2+x-4,x,-2,4)
(%o2)                          1.56155281280883
(%o3)                          c:/tmp/test1.max
(%i4)

Nullstellen von Polynomen

Finde alle Nullstellen des Polynoms $x^{2}+2+5$. Die Funktion muss ein Polynom sein.

allroots(x^2+2*x+5);

Ausgabe:

read and interpret c:/tmp/test1.max
(%i17) allroots(x^2+2*x+5)
(%o17)             [x = 2.0 %i - 1.0, x = (- 2.0 %i) - 1.0]
(%o18)                         c:/tmp/test1.max
(%i19)

Hier sind beide Nullstellen komplex. Will man nur reelle Nullstellen eines Polynoms ermitteln, so geht dies mit diesem Befehl:

realroots(x^3+2*x^2+15*x+12);

Ausgabe:

(%i41) realroots(x^3+2*x^2+15*x+12)
                                      28718331
(%o41)                         [x = - --------]
                                      33554432
(%o42)                         c:/tmp/test1.max
(%i43)

Lineares Gleichungssystem lösen

Löse das lineare Gleichungssystem ${\begin{array}{c}2x+3y+z=5\\x-y-z=10\\x+2y-7z=1\end{array}}$

linsolve([2*x + 3*y + z = 5, x - y - z = 10, x + 2*y - 7*z = 1], [x,y,z]);

Ausgabe:

read and interpret c:/tmp/test1.max
(%i44) linsolve([2*x+3*y+z = 5,x-y-z = 10,x+2*y+(-7)*z = 1],[x,y,z])
(%o44)                      [x = 7, y = - 3, z = 0]
(%o45)                         c:/tmp/test1.max
(%i46)

Vereinfachungen

Ein Klammerausdruck soll vereinfacht (in diesem Fall ausmultipliziert) werden.

expand(5*(x-2) + x*(3+x));

Ausgabe:

read and interpret c:/tmp/test1.max
(%i26) expand(5*(x-2)+x*(3+x))
                                  2
(%o26)                           x  + 8 x - 10
(%o27)                         c:/tmp/test1.max
(%i28)

Listen

Eine Liste ist eine Zusammenfassung von Elementen und wird z.B. so erzeugt und evaluiert

l:[2, 10, "Text", x];
x:5;
ev(l);

Ausgabe:

(%i2) l:[2,10,"Text",x]
(%o2)                          [2, 10, Text, x]
(%i3) x:5
(%o3)                                  5
(%i4) ev(l)
(%o4)                          [2, 10, Text, 5]

Der Zugriff auf ein Listenelement erfolgt so

l:[2, 10, "Text", x]$
print(l[1]);

Ausgabe:

2
(%o10)                                 2

Gestartet wird mit dem Index 1.

Eine Liste lässt sich auch aus einem Ausdruck erstellen.

makelist(i+1, i, 0, 5, 1);

Ausgabe:

(%i25) makelist(i+1,i,0,5,1)
(%o25)                        [1, 2, 3, 4, 5, 6]

Der Ausdruck ist i+1, die Laufvariable ist i, i läuft von 0 bis 5 und die Schrittweite ist 1.

Auf Listen können viele Funktionen ausgeführt werden, z.B. eine Sortierung

l:[0, 5, 2, 3, 1, -4];
sort(l);

Ausgabe:

(%i31) l:[0,5,2,3,1,-4]
(%o31)                       [0, 5, 2, 3, 1, - 4]
(%i32) sort(l)
(%o32)                       [- 4, 0, 1, 2, 3, 5]

Vektoren und Matrizen

Vektoren

Vektoren addieren

u : [2, -2, 4]$
v : [1, 1, 0]$
u+v;

Ausgabe:

read and interpret c:/tmp/test1.max
(%i24) u:[2,-2,4]
(%i25) v:[1,1,0]
(%i26) u+v
(%o26)                            [3, - 1, 4]
(%o27)                         c:/tmp/test1.max
(%i28)

Skalarprodukt

u : [2, -3, 4]$
v : [1, 1, 0]$
u.v;

Ausgabe:

read and interpret c:/tmp/test1.max
(%i39) u:[2,-3,4]
(%i40) v:[1,1,0]
(%i41) u . v
(%o41)                                - 1
(%o42)                         c:/tmp/test1.max
(%i43)

Matrizen

A : matrix(
  [1,2,3],
  [4,5,6],
  [7,8,9]
);

Ausgabe:

read and interpret c:/tmp/test1.max
(%i37) A:matrix([1,2,3],[4,5,6],[7,8,9])
                                  [ 1  2  3 ]
                                  [         ]
(%o37)                            [ 4  5  6 ]
                                  [         ]
                                  [ 7  8  9 ]
(%o38)                         c:/tmp/test1.max
(%i39)

Einheitsmatrix

ident(3);

Ausgabe:

read and interpret c:/tmp/test1.max
(%i51) ident(3)
                                  [ 1  0  0 ]
                                  [         ]
(%o51)                            [ 0  1  0 ]
                                  [         ]
                                  [ 0  0  1 ]
(%o52)                         c:/tmp/test1.max
(%i53)

Nullmatrix

zeromatrix(3, 2);

Ausgabe:

read and interpret c:/tmp/test1.max
(%i60) zeromatrix(3,2)
                                   [ 0  0 ]
                                   [      ]
(%o60)                             [ 0  0 ]
                                   [      ]
                                   [ 0  0 ]
(%o61)                         c:/tmp/test1.max
(%i62)

Diagonalmatrizen

diagmatrix(3, 10);

Ausgabe:

read and interpret c:/tmp/test1.max
(%i74) diagmatrix(3,10)
                                [ 10  0   0  ]
                                [            ]
(%o74)                          [ 0   10  0  ]
                                [            ]
                                [ 0   0   10 ]
(%o75)                         c:/tmp/test1.max
(%i76)

Zugriff auf Matrizenelemente

A : matrix(
  [1,2,3],
  [4,5,6],
  [7,8,9]
);

A[1][2];
A[2][3] : 1000;
print(A);

Ausgabe:

read and interpret c:/tmp/test1.max
(%i68) A:matrix([1,2,3],[4,5,6],[7,8,9])
                                  [ 1  2  3 ]
                                  [         ]
(%o68)                            [ 4  5  6 ]
                                  [         ]
                                  [ 7  8  9 ]
(%i69) A[1][2]
(%o69)                                 2
(%i70) A[2][3]:1000
(%o70)                               1000
(%i71) print(A)
[ 1  2   3   ]
[            ]
[ 4  5  1000 ]
[            ]
[ 7  8   9   ]
                                [ 1  2   3   ]
                                [            ]
(%o71)                          [ 4  5  1000 ]
                                [            ]
                                [ 7  8   9   ]
(%o72)                         c:/tmp/test1.max
(%i73)

Matrizenmultiplikation (falksches Schema)

A : diagmatrix(3, 10);
B : matrix(
  [1,2,3],
  [4,5,6],
  [7,8,9]
);

A . B;

Ausgabe:

read and interpret c:/tmp/test1.max
(%i82) A:diagmatrix(3,10)
                                [ 10  0   0  ]
                                [            ]
(%o82)                          [ 0   10  0  ]
                                [            ]
                                [ 0   0   10 ]
(%i83) B:matrix([1,2,3],[4,5,6],[7,8,9])
                                  [ 1  2  3 ]
                                  [         ]
(%o83)                            [ 4  5  6 ]
                                  [         ]
                                  [ 7  8  9 ]
(%i84) A . B
                                [ 10  20  30 ]
                                [            ]
(%o84)                          [ 40  50  60 ]
                                [            ]
                                [ 70  80  90 ]
(%o85)                         c:/tmp/test1.max
(%i86)

Die transponierte Matrix

A : matrix(
  [1,2,3],
  [4,5,6],
  [7,8,9]
)$

transpose(A);

Ausgabe:

read and interpret c:/tmp/test1.max
(%i59) A:matrix([1,2,3],[4,5,6],[7,8,9])
(%i60) transpose(A)
                                  [ 1  4  7 ]
                                  [         ]
(%o60)                            [ 2  5  8 ]
                                  [         ]
                                  [ 3  6  9 ]
(%o61)                         c:/tmp/test1.max
(%i62)

Das Ganze lässt sich nicht nur mit Zahlen ausführen, sondern auch mit Buchstaben, wie im folgenden Beispiel gezeigt wird.

A : matrix(
  [a,b,c],
  [d,e,f],
  [g,h,i]
)$

transpose(A);

Ausgabe:

read and interpret c:/tmp/test1.max
(%i44) A:matrix([a,b,c],[d,e,f],[g,h,i])
(%i45) transpose(A)
                                  [ a  d  g ]
                                  [         ]
(%o45)                            [ b  e  h ]
                                  [         ]
                                  [ c  f  i ]
(%o46)                         c:/tmp/test1.max
(%i47)

Die inverse Matrix

A : matrix(
  [1,2,3],
  [4,5,6],
  [10,20,-10]
)$

invert(A);

Ausgabe:

read and interpret c:/tmp/test1.max
(%i68) A:matrix([1,2,3],[4,5,6],[10,20,-10])
(%i69) invert(A)
                              [   17   2     1  ]
                              [ - --   -   - -- ]
                              [   12   3     40 ]
                              [                 ]
                              [  5      1   1   ]
(%o69)                        [  -    - -   --  ]
                              [  6      3   20  ]
                              [                 ]
                              [  1           1  ]
                              [  -     0   - -- ]
                              [  4           40 ]
(%o70)                         c:/tmp/test1.max
(%i71)

Eigenwerte und Eigenvektoren

A : matrix (
  [5, 2],
  [1, 1]
)$

eigenvalues(A);
eigenvectors(A);

Ausgabe:

read and interpret c:/tmp/test1.max
(%i10) A:matrix([5,2],[1,1])
(%i11) eigenvalues(A)
(%o11)               [[3 - sqrt(6), sqrt(6) + 3], [1, 1]]
(%i12) eigenvectors(A)
(%o12) [[[3 - sqrt(6), sqrt(6) + 3], [1, 1]],
                                            sqrt(6) + 2         sqrt(6) - 2
                                    [[[1, - -----------]], 1, -----------]]
                                                 2                   2
(%o13)                         c:/tmp/test1.max
(%i14)

Grafik

2D

Explizit gegebene Funktion

Speichern Sie folgendes Script in die Datei c:/tmp/test1.max

f:explicit(cosh(x), x, -3, 3);
draw2d(f);

und starten Sie das Script mit dem Befehl

 batch("c:/tmp/test1.max");

Es öffnet sich ein Grafikfenster folgenden Inhalts:

Implizit gegebene Funktion

Script:

f:implicit(x+y**2=10, x, 0, 12, y, 0, 5);
draw2d(f);

Ausgabe:

Parametrische Funktion

Script:

f:parametric(t*cos(t), t*sin(t), t, 0, 6*%pi);
draw2d(nticks=200, f);

Ausgabe:

Mit nticks=200 wird der Graph glatter dargestellt.

Polare Funktion

Script:

f:polar(sin(2*t)*5 + 10, t, 0, 3*%pi);
draw2d(nticks=200, f);

Ausgabe:

Mehrere Graphen in einem Fenster

Script:

f:explicit(cosh(x)+2**x, x, -3, 3);
g:explicit(sin(x)*cos(x), x, -3, 3);
draw2d(color=red, f, color=green, g);

Ausgabe:

Die Liniendicke und der Linientyp lassen sich ändern.

f:explicit(cosh(x)+2**x, x, -3, 3);
g:explicit(sin(x) * cos(x), x, -3, 3);
draw2d(color=red, line_width=4, line_type=dots, f, color=green, line_type=solid, g);

Ausgabe:

Auch eine Legende kann eingefügt werden, z.B.

f:explicit(cosh(x)+2**x, x, -3, 3);
g:explicit(sin(x) * cos(x), x, -3, 3);
draw2d(color=red, line_width=4, line_type=dots, key="cosh", f, 
       color=green, line_type=solid, key="sin * cos", g);

3D

Raumkurven

Script:

f: parametric(u*cos(u),u*sin(u),u,u,0,6*%pi);
draw3d(nticks=200, line_width=2, title="Raumkurve", f);

Ausgabe:

Flächen

Script:

f:explicit(sin(x)+3*cos(y), x, 0, 10, y, 0, 10);
draw3d(surface_hide=true, f);

Ausgabe:

Eine Variante ist

f:explicit(sin(x)+3*cos(y), x, 0, 10, y, 0, 10);
draw3d(surface_hide=true, enhanced3d=true, f);

Ausgabe:

Die Farbpalette kann frei gewählt werden, z.B. als Graustufen-Palette:

f:explicit(sin(x)+3*cos(y), x, 0, 10, y, 0, 10);
draw3d(surface_hide=true, enhanced3d=true, palette=gray, f);

Ausgabe:

Oder man gibt eine Liste der Palette bestehend aus den Farben rot, grün, blau vor. Die Farbwerte können zwischen -36 bis + 36 variieren.

f:explicit(sin(x)+3*cos(y), x, 0, 10, y, 0, 10);
draw3d(surface_hide=true, enhanced3d=true, palette=[10, 5, -10], colorbox=false, f); 

Ausgabe:

Höhenlinien

Script:

f:explicit(sin(x)+3*cos(y), x, 0, 10, y, 0, 10);
draw3d(contour_levels=10, contour=map, f);

Ausgabe:

Komplexe Zahlen

/* Eine komplexe Zahl */
z : 4 + 5*%i;
/* Der Realteil von z */
realpart(z);
/* Der Imaginärteil von z */
imagpart(z);
/* Absolutbetrag von z */
cabs(z);
/* Argument (Winkel) von z */
carg(z);
/* Die Konjugierte */
conjugate(z);
/* Polardarstellung */
polarform(z);

Ausgabe:

read and interpret c:/tmp/test1.max
(%i6) z:4+5*%i
(%o6)                              5 %i + 4
(%i7) realpart(z)
(%o7)                                  4
(%i8) imagpart(z)
(%o8)                                  5
(%i9) cabs(z)
(%o9)                              sqrt(41)
(%i10) carg(z)
                                         5
(%o10)                              atan(-)
                                         4
(%i11) conjugate(z)
(%o11)                             4 - 5 %i
(%i12) polarform(z)
                                       %i atan(5/4)
(%o12)                      sqrt(41) %e
(%o13)                         c:/tmp/test1.max
(%i14)

Infinitesimalrechnung

Grenzwerte

Folgendes Beispiel ist Burg, Haf, Wille, Meister: Höhere Mathematik für Ingenieure, Band I: Analysis, 9. Aufl., Vieweg+Teubner, 2011, Seite 111 entnommen. Gesucht ist $\lim _{x\rightarrow \infty }{\frac {3x^{3}+2x-1}{2x^{3}+6}}$:

limit((3*x^3+2*x-1)/(2*x^3+6), x, inf);

Ausgabe:

                                       3
(%o1)                                  -
                                       2

Differenzialrechnung

Differenziation ist etwas was Maxima beherrscht. Z.B., differenziere die Funktion $f(x)=x^{2}+\cos {x}$

f : x^2 + cos(x);
diff(f, x);

Ausgabe:

read and interpret c:/tmp/test1.max
(%i8) f:x^2+cos(x)
                                            2
(%o8)                             cos(x) + x
(%i9) diff(f,x)
(%o9)                            2 x - sin(x)
(%o10)                         c:/tmp/test1.max
(%i11)

Integralrechnung

Auch die Integralrechnung beherrscht Maxima aus dem Effeff. Es soll die gleiche Funktion wie bei Differenzialrechnung integriert werden.

f : x^2 + cos(x);
integrate(f, x);

Ausgabe:

read and interpret c:/tmp/test1.max
(%i12) f:x^2+cos(x)
                                            2
(%o12)                            cos(x) + x
(%i13) integrate(f,x)
                                            3
                                           x
(%o13)                            sin(x) + --
                                           3
(%o14)                         c:/tmp/test1.max
(%i15)

Maxima stellt für einige Funktionen Beispielscode zur Verfügung. Für die Integration erhalten Sie diesen z.B. durch die Eingabe von

(%i4) example(integrate);

Als Ausgabe erhalten Sie (auszugsweise)

(%i5) test(f):=block([u],u:integrate(f,x),ratsimp(f-diff(u,x)))
(%o5) test(f) := block([u], u : integrate(f, x), ratsimp(f - diff(u, x)))
(%i6) test(sin(x))
(%o6)                                  0
(%i7) test(1/(1+x))
(%o7)                                  0
(%i8) test(1/(1+x^2))
(%o8)                                  0
(%i9) integrate(sin(x)^3,x)
                                  3
                               cos (x)
(%o9)                          ------- - cos(x)
                                  3
...

Taylorreihen

Berechnen Sie die Taylorreihe der Funktion f(x), um den Punkt 0 bis zur 6.Ordnung.

f : x^2 + cos(x);
taylor(f, x, 0, 6);

Ausgabe:

read and interpret c:/tmp/test1.max
(%i24) f:x^2+cos(x)
                                            2
(%o24)                            cos(x) + x
(%i25) taylor(f,x,0,6)
                                2    4    6
                               x    x    x
(%o25)/T/                  1 + -- + -- - --- + . . .
                               2    24   720
(%o26)                         c:/tmp/test1.max
(%i27)

Differenzialgleichungen

'diff(y,x) = y*x + cos(x);
ode2(%,y,x);

Ausgabe:

                               dy
(%o2)                          -- = x y + cos(x)
                               dx

             2
            x
            --
            2
(%o3) y = %e
                   sqrt(2) x + sqrt(2) %i        sqrt(2) x - sqrt(2) %i
    sqrt(%pi) (erf(----------------------) + erf(----------------------))
                             2                             2
   (--------------------------------------------------------------------- + %c)
                                 3/2
                                2    sqrt(%e)

Kombinatorik

Die n! (n-Fakultät) berechnet man in Maxima genauso, wie es geschrieben steht.

55!

Ausgabe:

 read and interpret c:/tmp/test1.max
(%i9) 55!
(%o9)
     12696403353658275925965100847566516959580321051449436762275840000000000000
(%o10)                         c:/tmp/test1.max
(%i11)

Maxima kann also mit wirklich großen Zahlen exakt umgehen.

Der Binomialkoeefizient lässt sich so berechen:

(%i21) binomial (12, 5);

Ausgabe:

(%o22)                                792
(%i23)

Sonstiges

Abfragefunktionen

Mit Maxima lassen sich auch einfach Abfragen durchführen, z.B. ob eine Zahl gerade, ungerade oder prim ist.

evenp(22);
oddp(22);
primep(347);

Ausgabe:

(%i1) batch("c:/tmp/test1.max");

read and interpret c:/tmp/test1.max
(%i2) evenp(22)
(%o2)                                true
(%i3) oddp(22)
(%o3)                                false
(%i4) primep(347)
(%o4)                                true
(%o5)                          c:/tmp/test1.max
(%i6)

Die Auswertung ist klar. Die Zahl 22 ist gerade (even), somit nicht ungerade (odd). Die Zahl 347 ist eine Primzahl.

Größe, Einheit und Dimension

Größenwert $G$, Zahlenwert $\{G\}$, Einheit $[G]$

$G=\{G\}\cdot [G]$

In Maxima z.B.:

Script:

load(ezunits);
f:250`N;
f``kN;
dimensions(f);

Ausgabe:

(%i33) f:250 ` N
(%o33)                              250 ` N
(%i34) f `` kN
                                    1
(%o34)                              - ` kN
                                    4
(%i35) dimensions(f)
                                  length mass
(%o35)                            -----------
                                         2
                                     time

Alle Einheiten, die Maxima kennt, lassen sich auch ausgeben.

(%o41) [A, AU, Bq, Btu, C, F, GA, GC, GF, GH, GHz, GJ, GK, GN, GOhm, GPa, GS,
GT, GV, GW, GWb, Gg, Gm, Gmol, Gs, Gy, H, Hz, J, K, MA, MC, MF, MH, MHz, MJ,
MK, MN, MOhm, MPa, MS, MT, MV, MW, MWb, Mg, Mm, Mmol, Ms, N, Ohm, Pa, R, S,
Sv, T, V, W, Wb, acre, amp, ampere, astronomical_unit, becquerel, candela, cd,
cfm, cm, coulomb, cup, day, degree, fA, fC, fF, fH, fHz, fJ, fK, fN, fOhm,
...
ps, psi, quart, rod, s, second, short_ton, siemens, sievert, slug, tablespoon,
tbsp, teaspoon, tesla, tsp, volt, watt, weber, week, yard, year]

Den Zahlenwert bzw. die Einheit liefert das Script

f:250`N;
qty(f);
units(f); 

Ausgabe:

(%i49) f:250 ` N
(%o49)                              250 ` N
(%i50) qty(f)
(%o50)                                250
(%i51) units(f)
(%o51)                                 N

Zufallszahlen

random(100);
random(100.0);

Ausgabe, z.B.:

(%i75) random(100)
(%o75)                                29
(%i76) random(100.0)
(%o76)                         14.34881410923412

Es wird eine gleichverteilte Zufallszahl im Intervall $[0,100[$ ausgegeben. Dies ist die einfachste Form Zufallszahlen zu erzeugen. Maxima kennt noch eine Reihe weiterer Zufallsfunktionen, die aber hier nicht behandelt werden.

Ausblick

Dies war eine kurze Einführung in das Rechnen mit Maxima. Maxima kennt noch viel mehr Befehle, als hier dargestellt wurden. Es sollten aber ein paar relevante Themen behandelt, oder zumindest kurz angesprochen worden sein. Als weiterführende Literatur siehe z.B.

• Maxima-Manual.
• www.austromath.at
• www.mathematikselberlernen.de
• Haager: Computeralgebra mit Maxima. 2. Auflage, Hanser, 2019, ISBN 978-3-446-44868-1

Zurück zu Gnuplot | Hoch zu Gesamtinhaltsverzeichnis | Vor zu Octave