Author: tibokafu

Damit hätten Sie nicht gerechnet – Mathematik mit Open Source

Teil 1: Im Anfang war die Zahl

von Tobias Kaulfuß

Dieser Artikel ist in ähnlicher Form im Freien Magazin und auf Pro-Linux.de erschienen.

In dieser Artikelreihe nehme ich Sie mit auf eine Reise in die Welt der Mathematik. Moderne angewandte Mathematik wird nur noch selten mit Bleistift und Papier betrieben. Häufig kommen sehr leistungsfähige und ausgeklügelte Computerprogramme zum Einsatz. Eine paar dieser Programme möchte ich Ihnen vorstellen.

1 Jenseits des Taschenrechners

Ja, es gibt tatsächlich mehr als den obligatorischen Taschenrechner, dessen „Wissenschaftlicher Modus“ schon einen Teil der geneigten Leserschaft in höchste Glücksgefühle versetzen mag: „Was für ein Nerd man doch ist.“ Ein anderer Teil wird wohl an dunkle, leider noch nicht ganz verdrängte Stunden der Schulzeit erinnert. Doch gerade Sie bitte ich weiter zu lesen. Es gibt auch keine Noten und Sie müssen nichts an der Tafel vorrechnen, versprochen.

Die wohl bekanntesten kommerziellen Softwarepakete für Mathematik sind Mathematica, Maple und Matlab. Ersteres wurde von dem genialen Stephen Wolfram entwickelt, der bereits mit 15 Jahren Artikel zur Teilchenphysik veröffentlichte. Er betreibt auch die „Suchmaschine“ Wolfram Alpha. Mathematica ist ein Computeralgebrasystem (CAS), das heißt, es kann nicht nur Zahlen verarbeiten, sondern auch Symbole, Buchstaben, Variablen, Funktionen, Matrizen und vieles mehr.

Maple ist ebenfalls ein CAS. Entwickelt wurde es in Kanada. Die Kanadier scheinen nicht viele Symbole zu kennen, jedenfalls haben sie kurzerhand ihr Nationalsymbol als Name und Logo für ihre Mathematiksoftware gewählt. Schwer zu sagen, ob ein Mangel an Symbolen der Grund dafür ist, dass Maple preiswerter ist als Mathematica. Der Preis könnte jedoch ein Grund dafür sein, dass Maple etwas häufiger an Universitäten verwendet wird, während Mathematica häufiger im professionellen Umfeld zu finden ist.

Einen etwas anderen Einsatzbereich hat Matlab. Hier stehen wieder Zahlen und Matrizen im Vordergrund. Es dient der numerischen Simulation, Datenerfassung und -analyse. Die Grenzen zwischen den verschiedenen Paketen sind jedoch fließend und viele Probleme lassen sich in allen genannten Programmen lösen.

2 Back to the root

Okay, die Überschrift ist ein bisschen geschummelt. Es reicht, wenn wir als normaler Benutzer arbeiten. Aber wie ein echter Superuser hacken wir zunächst einmal auf der Konsole.

Begeben wir uns zurück in die 60er Jahre des letzten Jahrhunderts und installieren das open source Programm Maxima. Maxima stammt von einem der ersten Computeralgebrasystemen Macsyma ab. Nach dem Start begrüßt uns der Input Promt:

$ maxima
Maxima 5.32.1 http://maxima.sourceforge.net
using Lisp SBCL 1.1.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)

Geben wir unser erstes Kommando ein: 1+2; und bestätigen mit Enter.

(%i1) 1+2;
(%o1)                                 3
(%i2)

Man beachte: Kommandos werden immer mit Semikolon beendet. Input Zeilen erkennt man an dem kleinen i, Output Zeilen, also die Ergebnisse der Berechnungen, an dem kleinen o. Beide werden fortlaufend nummeriert.

Addition, Subtraktion und Multiplikation beherrscht Maxima aus dem Effeff. Auch das Rechnen mit Klammern gehört zu den leichteren Übungen:

(%i2) 5-7;
(%o2)                                 - 2
(%i3) 7*6;
(%o3)                                 42
(%i4) 4*(3+2);
(%o4)                                 20

Unsere erste kleine Überraschung erleben wir, wenn wir versuchen zu dividieren:

(%i5) 10/2;
(%o5)                                 5
(%i6) 11/2;
                                     11
(%o6)                                --
                                     2
(%i7) 10/15;
                                       2
(%o7)                                  -
                                       3
(%i8) 5*(3/2);
                                     15
(%o8)                                --
                                     2
(%i9) 5+(3/2);
                                     13
(%o9)                                --
                                     2

Maxima gibt uns einen Bruch aus, freundlicherweise soweit wie möglich gekürzt. Möchte man eine Dezimalzahl ausgeben, verwendet man die Funktion float(). (Floating Point Number = Fließkommazahl).

(%i10) float(13/2);
(%o10)                               6.5
(%i11) float(sqrt(2));
(%o11)                        1.414213562373095

sqrt() berechnet die die Quadratwurzel (Square Root) einer Zahl.

Maxima kennt Konstanten wie die Kreiszahl Pi und Standardfunktionen wie Sinus und Kosinus.

(%i12) float(%pi);
(%o12)                         3.141592653589793
(%i13) sin(%pi);
(%o13)                                 0
(%i14) cos(3*%pi);
(%o14)                               - 1
(%i15) sin(float(%pi));
(%o15)                       1.224646799147353e-16

Die Zeile o15 zeigt uns, dass das Rechnen mit Dezimalzahlen mit Vorsicht zu genießen ist. 1.224646799147353e-16 bedeutet: 1.224646799147353 * 10-16 = 0.000000000000000122466799147353. Das ist zwar eine sehr kleine Zahl, jedoch nicht genau 0, was laut Zeile o13 doch das richtige Ergebnis sein sollte. Das Problem ist, dass Pi unendlich viele Nachkommastellen hat, Sie aber nicht unendlich viel Arbeitsspeicher haben, um alle diese Ziffern speichern zu können. (Das behaupte ich, ohne Ihren high end super duper Rechner zu kennen. Selbst die NSA würde sich schwer tun, wenn sie versuche Pi als Dezimalzahl zu speichern.) Auch werden Sie kaum unendlich viel Zeit haben, um alle Ziffern bei Bedarf zu berechnen. Sie müssen sich also mit einem Kompromiss begnügen: Nachkommastellen werden irgendwann abgeschnitten, was zu ungenauen Ergebnissen führt.

Man darf sich nicht Algebrasystem nennen, wenn man nicht das Rechnen mit Buchstaben beherrscht:

(%i16) 2*a;
(%o16)                               2 a
(%i17) (x^2+y)*3;
                                          2
(%o17)                            3 (y + x )
(%i18) expand((a+b)^2);
                                2           2
(%o18)                         b + 2 a b + a
(%i19) expand((a+b)^10);
       10         9       2 8       3 7       4 6       5 5       6 4
(%o19) b   + 10 a b + 45 a b + 120 a b + 210 a b + 252 a b + 210 a b
                                                7 3      8 2        9   10
                                         + 120 a b + 45 a b + 10 a b + a

Die Funktion expand() multipliziert die Klammer aus, wie man leicht in Zeile 18 anhand der ersten Binomischen Formel sieht.

(%i20) u: 10!;
(%o20)                             3628800
(%i21) factor(u);
                                 8 4 2
(%o21)                          2 3 5 7
(%i22) expand(%o21);
(%o22)                             3628800

In Zeile 20 passieren zwei Dinge: Die Fakultät von 10 wird berechnet, das heißt: 10! = 1*2*3*…*9*10 = 3628800. Diese Zahl wird dem Buchstaben u zugewiesen und kann dann mit dieser Abkürzung weiter verwendet werden. In Zeile 21 wird die Zahl u = 3628800 faktorisiert, also in Primzahlen zerlegt, deren Produkt gerade wieder u ist. Es gilt die Ausgabe richtig zu lesen, hier steht: 28 34 52 7. Das bedeutet 3628800 = 28 *34 *52 *7. Die Probe machen wir in Zeile 22, wo wir das Ergebnis o21 ausmultiplizieren.

Es ist ein sehr wichtiges Resultat der Mathematik, dass sich jede natürliche Zahl eindeutig in ein Produkt von Primzahlen zerlegen lässt. Das heißt, man kann jede Zahl faktorisieren und für jede Zahl tauchen immer die gleichen Primzahlen auf. (Wenn die Zahl selbst schon eine Primzahl ist, dann besteht die Faktorisierung natürlich nur aus einer Primzahl, nämlich der Zahl selbst). (Ja, dieser letzte Satz strotzt vor bestechender Logik!).

In der Mathematik nennt man das ganze Fundamentalsatz der Arithmetik oder Hauptsatz der elementaren Zahlentheorie. Diese martialischen Begriffe geben schon einen kleinen Hinweis auf die Bedeutung der Aussage. Ganz praktische Anwendung findet der Satz in modernen Verschlüsselungsverfahren, die Sie täglich bei der Arbeit mit dem Computer nutzen, zum Beispiel beim Onlinebanking. Der RSA Algorithmus basiert darauf, dass es sehr leicht ist, zwei Zahlen zu multiplizieren, aber sehr schwer und zeitaufwendig, eine große Zahl in ihre Primfaktoren zu zerlegen. Und wenn ich „große Zahl“ schreibe, dann meine ich eine Zahle mit hunderten oder gar tausenden Ziffern. Mehr zu Verschlüsselung und RSA folgt in einem anderen Artikel.

Ersteinmal zurück zu Maxima. Für das Rechnen mit Funktionen bietet das CAS vielfältige Möglichkeiten.

(%i23) f(x) := x^2+x-1;
                                      2
(%o23)                       f(x) := x + x - 1
(%i24) f(2);
(%o24)                                 5
(%i25) solve(f(x)=11,x);
(%o25)                         [x = 3, x = - 4]
(%i26) integrate(f(x),x);
                                  3   2
                                 x   x
(%o26)                           -- + -- - x
                                 3   2
(%i27) diff(f(x),x);
(%o27)                             2 x + 1
(%i28) integrate(f(x),x,1,2);
                                     17
(%o28)                               --
                                     6
(%i29) 'integrate(f(x),x);
                                /
                               [   2
(%o29)                         I (x + x - 1) dx
                               ]
                              /

Zunächst definieren wir die Funktion f(x) = x2 + x -1. Die Funktion wird an der Stelle x=2 ausgewertet, man erhält den Wert 5. Umgekehrt werden die x-Stellen gesucht, an denen f den Wert 11 annimmt, das ist für x = 3 und x = -4 der Fall. Die Funktion integrate() bildet eine Stammfunktion nach der gewählten Variablen x, während diff() die Ableitung bildet. Übergibt man integrate() zwei Integrationsgrenzen, dann wird das bestimmte Integral berechnet, was, wie jeder weiß, dem Flächeninhalt zwischen Funktionsgraphen und x-Achse entspricht. In Zeile 29 sieht man, dass das einfache Anführungszeichen ‚ die Berechnung unterdrückt und nur den Ausdruck ausgibt. In diesem Fall mit einem wunderschön gezeichneten Integralzeichen.

Hat man Gnuplot installiert, lassen sich mit maxima Funktionsgraphen zeichnen. Das Bild kann sogar (mehr schlecht als recht) in der Konsole ausgegeben werden:

(%i30) plot2d(sin(x),[x,0,2*%pi],[gnuplot_term,dumb]);
                       sin(x)
                           1 +---------------------+
                             |  ++  ++  +   +   + +|
                             |  +    ++            |
                             | +      +            |
                         0.5 |++       +          +|
                             |+        +           |
                             |+        ++          |
                             |+         +          |
                           0 |+.........++........+|
                             |           +        +|
                             |           ++       +|
                             |            +       +|
                        -0.5 |+           +      ++|
                             |             +     + |
                             |              ++   + |
                             | +    +   +   ++ ++ +|
                           -1 +--------------------+
                             0 1   2 3 4   5 6
                                       x
(%o30) /home/benutzername/maxout.gnuplot
/home/benutzername/maxplot.txt

Die Option [x,0,2*%pi] sorgt dafür, dass die Funktion nach der Variablen x im Intervall [0, 2Pi] gezeichnet wird. Für die Ausgabe auf der Konsole sorgt die Option [gnuplot_term,dumb].

Komfortabler ist es natürlich, eine Bilddatei zu erzeugen:

(%i31)plot2d(sin(x),[x,0,2*%pi]);
(%o31) /home/benutzername/maxout.gnuplot_pipes

Gnuplot erstellt jeweils Dateien im persönlichen Verzeichnis des Benutzers.

Sinuskurve mit Gnuplot

Das soll es mit dem Ausflug in die Anfänge der Computeralgebra vorerst gewesen sein. Beendet wird maxima mit dem Befehl quit();

3 „Wer die Vergangenheit kontrolliert, beherrscht die Zukunft. Wer die Zukunft beherrscht, erobert die Vergangenheit.“-Kane

Zurück in der Gegenwart gibt es für all diese mathematischen Spielereien eine moderne grafische Oberfläche: wxMaxima. Sie basiert, wer hätt’s gedacht, auf der Klassenbibliothek wxWidgets. wxMaxima verfügt über zahlreiche Menüs und Dialoge, welche die Bedienung des Programms vereinfachen. Die Anweisungen werden in sogenannte Zellen geschrieben. Um eine neu Zelle zu erzeugen, klickt man einfach in einen leeren Bereich der Arbeitsfläche. Das Menü Zellen bietet dann verschiedene Optionen um die Zellen auszuwerten.

wxMaxima

An dieser Stelle soll einstweilen Schluss sein. Im nächsten Artikel geht es dann weiter mit wxMaxima, Funktionen und dem Plotten eben dieser.