Ing Mathematik: Computeralgebrasysteme am Beispiel von Maxima


Einleitung

Bearbeiten

Was ist Maxima?

Bearbeiten
  • 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.
Wikipedia hat einen Artikel zum Thema:


Installation

Bearbeiten

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

Bearbeiten

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

Bearbeiten

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   berechnet werden. Konstante (wie die Zahl  ) 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

Bearbeiten

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

Bearbeiten

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

Bearbeiten

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);

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

Bearbeiten

if then else

Bearbeiten
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)
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

Bearbeiten

Klassische Zählschleife

Bearbeiten
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

Bearbeiten
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

Bearbeiten
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

Bearbeiten

Gleichheit von Termen

Bearbeiten

Sie wollen feststellen, ob die beiden Terme   und   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

Bearbeiten

Löse die quadratische Gleichung  

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

Bearbeiten

Finde eine Nullstelle im Intervall   für die Funktion  . 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

Bearbeiten

Finde alle Nullstellen des Polynoms  . 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

Bearbeiten

Löse das lineare Gleichungssystem  

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

Bearbeiten

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)

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

Bearbeiten

Vektoren

Bearbeiten

Vektoren addieren

Bearbeiten
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

Bearbeiten
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

Bearbeiten
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

Bearbeiten
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

Bearbeiten
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

Bearbeiten
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

Bearbeiten
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)

Bearbeiten
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

Bearbeiten
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

Bearbeiten
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

Bearbeiten
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)

Explizit gegebene Funktion

Bearbeiten

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

Bearbeiten

Script:

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

Ausgabe:

 

Parametrische Funktion

Bearbeiten

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

Bearbeiten

Script:

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

Ausgabe:

 

Mehrere Graphen in einem Fenster

Bearbeiten

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);

 

Raumkurven

Bearbeiten

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

Bearbeiten

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

Bearbeiten

Script:

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

Ausgabe:

 

Komplexe Zahlen

Bearbeiten
/* 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

Bearbeiten

Grenzwerte

Bearbeiten

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  :

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

Ausgabe:

                                       3
(%o1)                                  -
                                       2

Differenzialrechnung

Bearbeiten

Differenziation ist etwas was Maxima beherrscht. Z.B., differenziere die Funktion  

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

Bearbeiten

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

Bearbeiten

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

Bearbeiten
'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

Bearbeiten

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

Bearbeiten

Abfragefunktionen

Bearbeiten

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

Bearbeiten

Größenwert  , Zahlenwert  , Einheit  

 

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

Bearbeiten
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   ausgegeben. Dies ist die einfachste Form Zufallszahlen zu erzeugen. Maxima kennt noch eine Reihe weiterer Zufallsfunktionen, die aber hier nicht behandelt werden.

Ausblick

Bearbeiten

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.