Einführung  in  Mathematica

©2001-2006 Gerald Teschl (http://www.mat.univie.ac.at/~gerald/) und Susanne Teschl  (http://staff.technikum-wien.at/~teschl/)

Erste Schritte

Mathematica ist ein umfassendes Programmpaket, das sowohl symbolisch als auch numerisch rechnen kann. Im einfachsten Fall kann es wie ein Taschenrechner verwendet werden. Geben wir zum Beispiel 3 + 5 ein und drücken danach die ENTER-Taste beim Ziffernblock:

3  + 5

Ein Strichpunkt am Ende einer Anweisung unterdrückt die Ausgabe.  Sie können mehrere Anweisungen auf einmal eingeben, indem Sie diese durch Strichpunkte trennen:

x  =  5;  3*x

Das Multiplikationszeichen * muss nicht geschrieben werden,ein Leerzeichen genügt.  Vergessen Sie aber auf dieses Leerzeichen nicht - das kann nämlich einen grossen Unterschied machen,wie das folgende Beispiel zeigt:

xy + x y

xy ohne Leerzeichen wird also als Variable aufgefasst. Auch Groß-/Kleinschreibung wird von Mathematica unterschieden:

X + x

Sie haben bereits gesehen, dass jede Eingabe und jede Ausgabe mit einer Nummer versehen werden. Sie können auf den jeweiligen Ausdruck jederzeit zurückgreifen:

Out[1]/2

Die unmittelbar vorhergehende Ausgabe erhalten Sie mit einem Prozentzeichen:

%  +  3

Momentan ist x mit dem Wert 5 belegt:

1/(1 - x) + 1/(1 + x)

Mit Clear können Sie diese Belegung löschen:

Clear[x]

Nun ist x wieder unbelegt:

1/(1 - x)  +  1/(1 + x)

Zur Vereinfachung eines Ausdrucks können Sie Simplify verwenden. Vereinfachen wir beispielsweise die letzte Ausgabe:

Simplify[%]

Vielleicht ist Ihnen aufgefallen,dass Mathematica Ausdrücke in einer gut lesbaren Form ausgibt, also beispielsweise eine Potenz in der Form  (x^2) anstelle von x^2. Auch wir können Brüche, Potenzen usw., entweder mit den üblichen Symbolen /, ^ usw. eingeben, oder wir können die entsprechenden Symbole mit der Maus aus einer Palette auswählen. So kann etwa der Bruch

(x + 1)/x^2;

mit der Maus über die Palette BasicInput (zu finden im Menüpunkt  File->Palettes) auch in der Form

((x + 1)/(x^2));

eingegeben werden.  Der Strichpunkt am Ende der Eingabe bewirkt, dass die Ausgabe unterdrückt wird (der Ausdruck wird aber natürlich ausgewertet und auf das Ergebnis kann mit % oder Out[] zugegriffen werden).

Hilfe zu Mathematica-Befehlen finden Sie im Menü unter Help->Help Browser oder mit dem Befehl ?Befehl, z.B:

?Sin

Übung: Versuchen Sie, die Bezeichnung für die Zahl π in Mathematica herauszufinden.

Funktionen

Mathematica kennt eine Vielzahl von mathematischen Funktionen. Diese Funktionen beginnen immer mit einem Großbuchstaben. Die Argumente werden in eckigen Klammern angegeben. Einige der eingebauten Funktionen sind:

Zum Beispiel können wir die Wurzel aus 4 berechnen:

Sqrt[4]

Wenn wir aber etwa Sin[1] eingeben, so erhalten wir:

Sin[1]

Das ist vermutlich nicht das Ergebnis, das Sie erwartet haben! Mathematica wertet den Ausdruck hier symbolisch (und nicht numerisch) aus. Und da es für Sin[1] symbolisch keinen einfacheren Wert gibt, wird er unverändert ausgegeben (so, wie man eben auch π schreibt anstelle von 3.141...). Wir weisen Mathematica an numerisch zu rechnen, indem wir das Argument mit einem Komma versehen (in Mathematica wird das Komma als Punkt eingegeben):

Sin[1. ]

Eine zweite Möglichkeit ist die Verwendung des Befehls N[ ].  Lassen wir uns zum Beispiel damit einen numerischen Wert für π

N[Pi]

oder die Eulersche Zahl e ausgeben

N[E]

Natürlich können wir auch eigene Funktionen definieren:

f[x_] := x^2  +  Sin[x]  +  a

Der Unterstrich in x_ teilt Mathematica mit, dass x in diesem Ausdruck die unabhängige Variable (man spricht in Mathematica von einem "Pattern") ist. Die Verwendung von := weist Mathematica an, die rechte Seite jedes Mal neu auszuwerten, wenn f aufgerufen wird. Daher haben wir hier auch kein Out[...] bekommen.  Nun kann die neue Funktion f wie jede eingebaute Funktion verwendet werden (solange, bis Sie Mathematica beenden):

f[2]

f[x]

x = 3; f[x]

Achtung: man kann Funktionen auch nur mit einem = anstelle eines := definieren.  Dann wird die rechte Seite zuerst ausgewertet (mit allen 
aktuellen Belegungen, ergibt also hier z.B. mit x=3 den Wert a + 9 + Sin[3]): Dieser Wert wird dann (ein für alle Mal) als Funktionswert zugewiesen:

g[x_] = (x^2) + Sin[x] + a

g ist damit eine konstante Funktion, d.h., wir erhalten immer denselben Funktionswert, unabhängig vom Argument:

g[2]

Es gibt also zwei Möglichkeiten: Funktionen von vornherein mit := definieren, oder sicherstellen, dass die Variable x  nicht mit einem Wert belegt ist, also:

Clear[x];  g[x_] = (x^2) + Sin[x] + a

Mit Plot können Funktionen leicht gezeichnet werden:

Zeichnen wir zum Beispiel die Funktion Sin[x] im Intervall von 0 bis 2π:

Plot[Sin[x], {x, 0, 2  Pi}];

Meist ist der von Mathematica dargestellte Ausschnitt der y-Achse passend. Man kann ihn aber auch selbst mit PlotRange festlegen.   Wählen wir zum Beispiel für Log[x] das y-Intervall von -4 bis 4:

Plot[Log[x], {x, 0, 10}, PlotRange -> {-4, 4}];

Mathematica enthält neben den eingebauten Funktionen auch eine Reihe von Standard-Zusatzpaketen (Algebra, Graphik, diskrete und numerische Mathematik, Zahlentheorie, Statistik, ...), die viele zusätzliche Funktionen bereithalten. Bei Bedarf wird das entsprechende Zusatzpaket geladen:

Alternativ können Pakete auch mit Needs["dir`"] bzw. Needs["dir`package`"] geladen werden. (Achtung auf die Verwendung der richtigen Anführungszeichen!)

Übung: Zeichnen Sie die Funktion y = (1/(x - 1)) im x-Intervall von 0 bis 2 und im y-Intervall von -20 bis 20.

Gleichungen

Eine Gleichung wird in Mathematica mit einem doppelten Gleichheitszeichen eingegeben

Sin[x]^2 + Cos[x]^2 == 1

Mit Simplify kann man versuchen die Gleichheit zu überprüfen:

Simplify[%]

Unsere Gleichung ist also richtig (True bzw. False sind die englischen Wörter für wahr bzw. falsch).

Die quadratische Gleichung

gleichung = ((x^2) - 2 x  - 4 == 0);

kann mit dem Befehl Solve gelöst werden:

loesung =  Solve[gleichung, x]

Mathematica liefert dabei die Lösung in Form von sogenannte Ersetzungsregeln x-> wert. Der Vorteil dabei ist, dass man damit leichter weiter rechnen kann. Zum Beispiel können wir die beiden Lösungen in unsere Gleichung einsetzen und mit Simplify die Probe machen:

Simplify[(x^2) - 2  x - 4 /.  loesung]

Mit dem Ersetzungsoperator /. wird durch ausdruck /. x -> wert überall in ausdruck die Variable x durch wert ersetzt.

Falls es wie in unserem Fall mehrere Lösungen gibt, so kann man auf einzelne Lösungen mit dem Befehl

loesung[[1]]

zugreifen. Allgemein wird in Mathematica ein Ausdruck der From

{a, b, c, d, e};

als Liste bezeichnet. Man  kann auf den n-ten Teil einer Liste mit list[[n]] zugreifen:

%[[3]]

Zusammenfassend gilt:

Mathematica kann natürlich auch Systeme aus mehreren Gleichungen lösen,wie zum Beispiel:

Solve[{x + y == a, x - y == 0}, {x, y}]

Übung:  Lösen Sie die Gleichung (x^2) - x - 12 = 0.

Programme

Mathematica ist nicht nur ein Mathematikprogramm, sondern auch ein vollwertige Programmiersprache. Insbesondere stehen die üblichen Kontrollstrukturen und Schleifnen zur Verfügung:

({{"\!\(\* StyleBox[\"\\\"If[\\\"\",\n\"MR\"]\)\!\(\* StyleBox[\"\\\"test\\\"\",\n\"TI\"]\)\!\(\* StyleBox[\"\\\",\\\"\",\n\"MR\"]\) \!\(\* StyleBox[\"\\\"befehl1\\\"\",\n\"TI\"]\)\!\(\* StyleBox[\"\\\",\\\"\",\n\"MR\"]\) \!\(\* StyleBox[\"\\\"befehl2\\\"\",\n\"TI\"]\)\!\(\* StyleBox[\"\\\"]\\\"\",\n\"MR\"]\) ", Ist  test""wahr , führe"" ""befehl1 aus sonst befehl2}})

(befehl2 ist optional)

(das Inkrement dj in der Do-Schleife ist optional mit Defaultwert dj=1).

Beispiel: Der Befehl PrimeQ überprüft, ob eine Zahl nur durch sich selbst oder eins teilbar, also eine Primzahl ist:

PrimeQ[7]

Mit diesem Befehl und einer Do-Schleife können wir eine Liste von Primzahlen kleiner gleich einer vorgegebenen Zahl erzeugen. Lassen wir uns zum Beispiel alle Primzahlen kleiner gleich 10 ausgeben:

Do[
If[PrimeQ[n], Print[n]], 
{n, 
          1, 10}];

Mit dem Befehl Module können mehrere Befehle übersichtlich zusammengefasst werden:

({{"\!\(\* StyleBox[\"\\\"Module[\\\"\",\n\"MR\"]\)"{var1 "=" "wert1"",""" … "}""," """"befehle"" ], Die befehle werden mit lokalen  Werten für die aufgelisteten Variablen ausgeführt }})

Die einzelnen Befehle werden durch Strichpunkte getrennt.Das Ergebnis des letzten Befehls wird als Ergebnis des Blocks zurückgegeben.

Zum Beispiel können wir eine Funktion definieren, die die erste Primzahl ausgibt, die größer oder gleich einer vorgegebene Zahl ist:

\(\(\(FindPrime[n_] := 
      Module[{p = 
            n}, 
While[\(! PrimeQ[
              p]\), \(p++\)]; 
p]\)\(
\)
    \)\)

Dabei wird zuerst p mit n initialisiert.Dann wird p solange um eins erhöht (p++ ist äquivalent zu p=p+1),wie der Primzahltest fehlschlägt (das Rufzeichen negiert den Test: aus wahr wird falsch und aus falsch wahr; hier wird also p um 1 erhöht, solange PrimeQ[p] falsch). Am Ende wird der gefundene Wert von p ausgegeben:

FindPrime[1000]

Übung:  Verbessern Sie FindPrime, indem Sie berücksichtigen,dass Primzahlen (mit der Ausnahme von 2) immer ungerade sind (mit EvenQ[n] bzw. OddQ[n] können Sie testen, ob eine Zahl gerade oder ungerade ist).

Grafiken

Wir können auch mehrere Funktionen gleichzeitig darstellen:

Plot[{Sin[x],  Sin[2  x]},  {x,  0,  2  π},  
        Ticks -> {{0, (π/2), π, ((3 π)/2), 2 π},  
            Automatic}, 
        PlotStyle -> {{RGBColor[1, 0, 0]}, {RGBColor[0, 0, 
                1]}}];

Mit der Option Ticks können die Positionen der Achsenmarkierungen festgelegt werden und mit der Option Plotstyle können die einzelnen Funktionen in verschiedenen Farben dargestellt werden. Anstelle von Farben können auch verschiedene Linienformen verwendet werden:

Plot[{Sin[x],  Sin[2  x]},  {x,  0,  2  π},  
        Ticks -> {{0, (π/2), π, ((3 π)/2), 2 π},  
            Automatic}, 
        PlotStyle -> { {}, Dashing[{0.025,  0.025}]}];

Eine Fülle von weitern Optionen finden Sie in der Online-Hilfe.

Falls Sie eine Grafk ins Web stellen oder in einem Textverarbeitungsprogramm verwenden wollen, so kann sie mit dem Befehl

Display["graph.gif", %, "EPS"];

auf die Festplatte geschrieben werden. Das Verzeichnis in dem die Datei landet können Sie mit dem Befehl Direcory[] feststellen, bzw. mit SetDirectory["pfad"] ändern.

Was geht noch?

Natürlich beherrscht Mathematica alle gängigen mathematischen Funktionen und Operationen. Hier möchte ich Ihnen nur noch einen kleinen Ausblick in die grafischen Fähigkeiten von Mathematica geben.

Vielleicht haben Sie schon mal Bilder der Mandelbrotmenge, die als klassisches Beispiel einer fraktalen Menge gilt, gesehen. Um die Erzeugung dieser Bilder zu verstehen brauchen Sie nur zu wissen, was eine komplexe Zahl ist (wenn Sie das nicht wissen, erfreuen
Sie sich einfach an den Bildern;-). Für eine gegebene komplexe Zahl c werden rekursiv die Zahlen

(Subscript[z, 0])  =  0,    (Subscript[z, 1]) =  
        ((Subscript[z, 0])^2)  +  c,   (Subscript[z, 2])  =   ((Subscript[z, 1])^2)  + c,    ... 

berechnet und die Anzahl der Schritte k notiert, nach denen der Absolutbetrag von (Subscript[z, k]) größer als zwei ist. Da das unter Umständen nie passiert, wird nach einer festen Anzahl von Schritten, z.B. 60, abgebrochen.

Folgende Funktion berechnet die Anzahl der notwendigen Schritte:

Mandel = 
        Compile[{{c, _Complex}}, 
Block[{z = 
                0.  + 0.  I, k = 0}, 
While[
              Abs[z] < 2 && k < 60, z = (z^2) + c;  
              k = k + 1]; 
k]
];

Das doppelte & entspricht einer logischen Und-Verknüpfung; der Test ist also genau dann wahr, wenn beide Teile wahr sind. Außerdem wurde der ganze Block unter ein Compile[...] gesteckt. Das ist zwar nicht notwendig, es veranlasst Mathematica aber, die Funktion, unter der Annahme dass das Argument c komplex ist, zu compilieren, was einen erheblichen Geschwindikeitsvorteil bringt. Ausgegeben wird die Anzahl der dergeführten Schritte k.

Führt man diese Berechnung für verschiedene komplexe Werte c=x + I y durch und veranschaulicht das Ergebnis, indem man den Punkt mit den Koordinaten (x, y) entsprechend der Anzahl der zugehörigen Schritte einfärbt, so erhält man die zuvor erwähnten Bilder der Mandelbrotmenge. In Mathematica kann das mit folgendem Befehl geschehen:

DensityPlot[
        Mandel[x + I y], {x, -1.5, 0.5}, {y, -1, 1}, 
        ColorFunction -> Hue, Mesh -> False, 
        PlotPoints -> 400];

Hier werden Werte zwischen -1.5 ≤  x ≤  0.5 und -1 ≤  y ≤  1 berechnet. Die Option ColorFunction -> Hue bringt etwas Farbe ins Bild (ansonsten würden den Funktionswerten nur Graustufen zugeordnet), die Option Mesh -> False verhindert, dass ein langweiliges Koordinatengitter über unser schönes Bild gezeichnet wird, und PlotPoints -> 400 legt fest, wie viele Punkte berechnet werden sollen (der Defaultwert ist 25, womit das Bild noch etwas kantig aussieht).

Das mathematisch interessante an der Mandelbrotmenge (der rote Fleck in der Mitte) ist ihr fraktaler Rand, der ziemlich unregelmäßig und alles andere als glatt ist. Er wird auch nicht glätter, wenn Sie einen Ausschnitt davon vergrößern: egal, wie nahe Sie heranzoomen, der Rand bleibt immer gleich unregelmäßig, und es wiederholen sich immer wieder die gleichen Strukturen. Das ist eine Eigenschaft, die charakteristisch für fraktale Mengen ist und als "selbstähnlich" bezeichnet wird.

Übung: Zeichnen Sie den Bereich 0.365 ≤  x ≤  0.375 und 0.095 ≤  y ≤  0.1059.