Ing Mathematik: Computeralgebrasysteme am Beispiel von Maxima


EinleitungBearbeiten

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:


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

Hallo WeltBearbeiten

Starten Sie Maxima 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 TaschenrechnerBearbeiten

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)

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 SkriptspracheBearbeiten

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").

VariablenBearbeiten

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

FunktionenBearbeiten

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öckeBearbeiten

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.

VerzweigungenBearbeiten

if then elseBearbeiten

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)

elseifBearbeiten

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)

SchleifenBearbeiten

Klassische ZählschleifeBearbeiten

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-doBearbeiten

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-doBearbeiten

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 GleichungenBearbeiten

Gleichheit von TermenBearbeiten

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öserBearbeiten

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 NullstellenBearbeiten

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 PolynomenBearbeiten

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ösenBearbeiten

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)

VereinfachungenBearbeiten

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)

Vektoren und MatrizenBearbeiten

VektorenBearbeiten

Vektoren addierenBearbeiten

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)

SkalarproduktBearbeiten

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)

MatrizenBearbeiten

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)

EinheitsmatrixBearbeiten

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)

NullmatrixBearbeiten

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)

DiagonalmatrizenBearbeiten

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 MatrizenelementeBearbeiten

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 MatrixBearbeiten

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 MatrixBearbeiten

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 EigenvektorenBearbeiten

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)

GrafikBearbeiten

Für das Zeichnen von Graphen, Flächen etc. sei auf das Numeriksystem Octave und den Funktionenplotter Gnuplot verwiesen. Damit lassen sich im Wesentlichen die meisten mathematikorientierten Grafiken komfortabel zeichnen.

Komplexe ZahlenBearbeiten

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

InfinitesimalrechnungBearbeiten

GrenzwerteBearbeiten

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

DifferenzialrechnungBearbeiten

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)

IntegralrechnungBearbeiten

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
...

TaylorreihenBearbeiten

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)

DifferenzialgleichungenBearbeiten

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

KombinatorikBearbeiten

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)

AusblickBearbeiten

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.