Eine kleine Mathematica - Einführung

Christian Neumaier, WS 2006 / 2007

Mathematica als Taschenrechner

Um eine Berechnung zu starten die Tasten Shift + Enter gleichzeitig drücken.

-2  +  3*4

Wir speichern nun das Ergebnis in der Variable erg.

erg  =  -2  +  3*4

Beenden wir die Zeile mit einem Strichpunkt (;), so wird das Ergebnis der Berechnung nicht auf dem Bildschirm ausgegeben.

erg2 = -2 + 3*4;

erg2

Die folgende Rechnung möchten wir lieber nicht händisch durchführen.

2^2000

Mathematica kennt auch mathematische Konstanten.

Pi

Schön und gut, aber welchen numerischen Wert hat π?

N[Pi]

Eine andere Schreibweise ist die folgende.

Pi  // N

Wir können auch mehr Stellen berechnen.

N[Pi, 200]

Das Ergebnis der letzten Berechnung wird mit % bezeichnet.

% - 2

Bekannte Funktionen

Mathematica kennt die bekannten mathematischen Funktionen wie sin, cos, usw. Die Schreibweise unterscheidet sich ein wenig von der Standard-Notation.

Sin[Pi]

Im folgenden wird die eulersche Zahl e berechnet. Mathematica gibt standardmäßig symbolische Antworten.

Exp[1]

Wollen wir eine numerische Antwort, können wieder den Befehl N verwenden.

Exp[1]  // N

Sqrt[2]

Sqrt[2]  // N

Mod[a,b] berechnet den Rest, der bei ganzzahliger Division von a durch b entsteht. PowerMod[a,b,c] ist eine effiziente Methode, um Mod[a^b,c] zu berechnen.

Mod[27, 5]

PowerMod[27, 3, 5]

Mod[27^3, 5]

GCD[a,b] ermittelt den größten gemeinsamen Teiler von a und b.

GCD[30, 126]

Selbstdefinierte Funktionen

Wir wollen nun selbst eine Funktion f definieren als f(x, y) := (x^2) - 2  y + 1.

f[x_, y_] := x^2 - 2  y + 1

Mit ? bekommen wir Informationen über ein Objekt.

?f

f[0, 0]

f[1, 2]

Wir können auch symbolische Ausdrücke verwenden.

f[a, b]

f[c, 1]

Mit Clear können wir die Definition von f wieder löschen.

Clear[f]

?f

Programmieren

Mathematica besitzt eine eigene Programmiersprache mit den üblichen Schleifen- und Bedingungs- Konstrukten. Wir demonstrieren diese Konstrukte anhand verschiedener Implementierungen der Fakultäts - Funktion.

Die Standard Fakultäts- Funktion von Mathematica wird mit ! bezeichnet.

0!

1!

5!

Es folgt eine rekursive Definition der Fakultäts-Funktion.

RecursiveFactorial[0]  :=  1;
RecursiveFactorial[n_]  :=  
      n * RecursiveFactorial[n - 1]

RecursiveFactorial[0]

RecursiveFactorial[6]

RecursiveFactorial[-1]

Nun eine Implementierung mittels While-Schleife.

WhileFactorial[n_]  :=  
      Module [{n2 = n,  fact = 1},  
        While[n2 > 1,  fact  =  fact * n2;  n2--];  
        fact]

Die Variablen n2 und fact sollen nur lokal sichtbar sein; dies wird durch obigen Befehl Module bewirkt.

WhileFactorial[1]

WhileFactorial[7]

Es folgt eine ganz ähnliche Implementierung, die eine For-Schleife verwendet.

ForFactorial[n_]  :=  
      Module [{ret = 1,  i},  
        For[ i = 2,  i ≤ n,  i++,  ret  *=  i];  
        Return[ret]]

ForFactorial[5]

ForFactorial[10]

Zum Schluß eine Implementierung, die eine If-Verzweigung verwendet.

IfFactorial[n_] := If[n > 0, n*IfFactorial[n - 1], 1]

IfFactorial[10]

Funktionsplots

Mathematica kann auch zeichnen.

Plot[Cos[x], {x, -3 Pi, 2  Pi}]

Durch die Option AspectRatio->Automatic werden die Längenverhältnisse angepasst.

g = 
        Plot[Sin[x], {x, -Pi, 2  Pi},  
          AspectRatio  ->  Automatic];

Es geht auch mit Farbe.

h = 
        Plot[{Cos[x], Cos[2  x]},  {x, -Pi, 2  Pi},  
          AspectRatio -> Automatic,  
          PlotStyle -> {{RGBColor[1, 0, 0]},  {RGBColor[0, 0, 
                  1]}}];

Wir kombinieren die letzen beiden Graphen.

Show[g, h];

Listen

Die Elemente einer Liste werden zwischen { und } aufgezählt.

liste  =  {2, 3,  5,  a,  5,  1001}

Length[liste]

Auf das 3. Listenelement greift man folgendermaßen zu.

liste[[3]]

First und Last sind selbsterklärend.

First[liste]

Last[liste]

{liste[[1]] + 10,  liste[[4]]}

Auch mit Table können Listen erzeugt werden.

Table[i^2,  {i, -5, 5}]

TableForm[%]

Vektoren werden als Listen dargestellt.

vektor1 = {1, 2, 3};  vektor2 = {11, 12, 13};

vektor1 + vektor2

Das Skalarprodukt zweier Vektoren wird mit . bezeichnet.

vektor1  .  vektor1

Matrizen sind Listen von Listen.

mat = {{1, 2, 3}, {4, 5, 6}}

MatrixForm[mat]

Transpose[mat]  //  MatrixForm

mat . Transpose[mat]

MatrixForm[%]

Lösen von Gleichungen

Wir wollen die Lösungen einer quadratischen Gleichung finden.

loesungen = Solve[x^2 + 2  x - 1 == 0,  x]

Als Ergebnis bekommen wir eine Liste von Substitutionen (Ersetzungen). Die Funktionsweise von Substitutionen veranschaulicht folgendes Beispiel (ausdr /. subst bedeutet, dass im Ausdruck ausdr die Substitution subst angewendet wird).

x^2 + 2  x - 1  /.  x -> 1

subst1 = loesungen[[1, 1]]

subst2 = loesungen[[2]]

Machen wir die Probe, ob die Lösungen wirklich stimmen.

x^2 + 2  x - 1  /.  subst1

Dies sollte 0 ergeben. Manchmal muss man Mathematica mit Simplify etwas nachhelfen.

Simplify[%]

x^2 + 2  x - 1  /.  subst2 // Simplify

Ein Beispiel eines linearen Gleichungssystems mit genau einer Lösung.

eqns = {-x + 2  y == 3,  5  x  -  y  ==  9}

Solve[eqns,  {x, y}]

Im folgenden Beispiel gibt es unendlich viele Lösungen. In diesem konkreten Fall findet Mathematica alle Lösungen, aber das ist nicht immer so.

Solve[{2  x - 3  y == 0,  6  y - 4  x == 0}]

Animationen

Wir beginnen mit einem Plot der Funktion (x,y)↦sin(x)cos(y).

Plot3D[Sin[x]*Cos[y], {x, 0, 2  Pi}, {y, 0, 2  Pi}, 
        ViewPoint -> {1.021,  0.219,  3.221}];

Mit <<Graphics`Animation` wird eine Erweiterungspaket für Animationen geladen.

<< Graphics`Animation`

Auf hoher See...

Animate[
      Plot3D[Sin[x + i]*Cos[y + i], {x, -2 Pi, 2  Pi}, {y, -2 Pi, 
          2  Pi},  PlotPoints ->  50, Mesh -> False],  {i, 0, 
        2*Pi, Pi/10}, ViewPoint -> {1.021,  0.219,  3.221}]

Und und und ...

Weiterführende Informationen sind im Mathematica Help Browser (The Mathematica Book) zu finden.