Mathematica Kompaktkurs

Inhaltsübersicht

1. Einführung
2. Arithmetik
3. Fortgeschrittene Anwendungen
4. Analysis
5. Lösen von Gleichungen
6. Lineare Algebra
7. Grafik
8. Einige vollständige Beispiele

. Einführung

. Allgemeines

Moderne Computeralgebra-Systeme (CAS) wie Mathematica, Maple oder MuPad sind mächtige Mathe–Programme, die neben dem numerischen Rechnen (mit beliebiger Genauigkeit) auch symbolische Mathematik und die Visualisierung von Ergebnissen beherrschen. Entgegen anderslautenden Bekundungen der Hersteller enthalten diese Pakete zwar nicht das mathematische Wissen der Welt und ersetzen auch keinen Mathematiker, aber sie können einem immerhin viele zeitaufwändige Arbeiten abnehmen.

. Starten des Programmes und Erste Hilfe

Unter Unix kann Mathematica von einem Terminal aus mit dem Kommando "mathematica" gestartet werden. Das sollte normalerweise das graphische Benutzerinterface aktivieren. Mathematica ist ein interaktives System, das Eingaben vom Benutzer liest, diese auswertet, und das Ergebnis unmittelbar ausspuckt:

1 + 2

Eingaben werden in Mathematica immer durch gleichzeitiges Drücken von ⇧ und ↵ ausgewertet!

Die Ausgabe des Ergebnisses kann man unterdrücken, indem man ein Semikolon an die Eingabe anhängt. Vor allem bei umfangreichen Zwischenergebnissen hilft das, den Überblick zu bewahren.

Dieses Handbuch ist zu kurz, um auch nur die vorgestellten Funktionen von Mathematica im Detail zu behandeln. Für umfangreichere Informationen zu bestimmten Themen ist daher die Online-Hilfe unentbehrlich. Informationen zu speziellen Funktionen lassen sich zusätzlich mit "?" abrufen. (Abhängig von der verwendeten Mathematica Version, erscheinen Teile des Hilfe-Outputs als anklickbare Verknüpfungen zur Online-Hilfe und zum Mathematica Buch; wenn Sie Glück und die richtige Version haben wird die folgende Ausgabe mit einem  More...   abgeschlossen. Falls Sie draufklicken,  werden Sie zu detaillierteren Informationen und Beispielen (!) weitergeführt) :

?Log

Um eine Liste aller Funktionen zu erhalten, deren Namen auf ein bestimmtes Muster passen, kann man ein Sternchen in den gesuchten Namen einfügen:

?Eq*

?F*List

. Mathematica als Taschenrechner

Die Notation von Ausdrücken in Mathematica orientiert sich an der gebräuchlichen mathematischen Notation. Eine gültige Eingabe ist beispielsweise

(2^12 + 7.1)*(-1.5/2.5)

Es gelten die gebräuchlichen Vorrangsregeln für Operatoren, Ausdrücke können aber auch mit runden Klammern explizit gruppiert werden. Funktionsargumente werden in eckige Klammern eingeschlossen, um sie von gewöhnlichen Ausdrücken zu unterscheiden:

Sin[3.1]/Sqrt[2]

Die Namen aller in Mathematica vordefinieren Funktionen, Prozeduren und Konstanten beginnen mit einem Großbuchstaben.

Das Multiplikations-Zeichen kann häufig weggelassen werden, etwa ist 2  Sin[3  x] gleichbedeutend mit 2*Sin[3*x]. Auch Leerzeichen zwischen zwei (abgeschlossenen) Ausdrücken erwirken die Multikplikation der beiden: x y ist also x*y, xy (ohne Leerzeichen) wird dagegen als ein Symbol "xy" gewertet.

Auf die letzen beiden Ausgaben kann mit % (letzte Ausgabe) und %% (vorletzte Ausgabe) Bezug genommen werden. Meist ist es aber sinnvoller, wichtige Zwischenergebnisse in Variablen zu speichern, um später auf sie zurückgreifen zu können.

2. Arithmetik

. Exakte und Inexakte Arithmetik

Mathematica unterscheidet zwischen exakten und inexakten, also genäherten numerischen Ausdrücken. Exakte Rechnungen werden mit beliebiger Genauigkeit durchgeführt, bei inexakten kann es nach einigen Schritten zu Rundungsfehlern kommen. Kommazahlen und die N–Funktion erzwingen die numerische Auswertung eines Ausdrucks. N nimmt als optionalen Parameter die Anzahl der signifikanten Stellen des Ergebnisses:

Factorial[50]

N[%]

Sin[Pi/3]

N[%, 20]

Sin[Pi/3.0]

Vorsicht: Die Regeln, die Mathematica für numerische Rechnungen anwendet, sind kompliziert und können zu überraschenden Ergebnissen führen. Zudem ist umfangreiche Numerik Mathematica meist sehr langsam. In solchen Fällen kann es von Vorteil sein, die eigentlichen Berechnungen in C– oder Fortran–Programme auszulagern.

Ein Beispiel, warum man der Numerik von Mathematica (übrigens jeglicher Numerik) nicht immer trauen sollte:

x = 1.11111111111111111111;
Do[x = 2*x - x, {60}];
x == x + 1

Clear[x]

. Komplexe Zahlen

Neben dem Rechnen mit ganzen, rationalen und reellen Zahlen unterstützt Mathematica auch komplexe Arithmetik. Die imaginäre Einheit wird als "I" geschrieben. 
Mathematica implementiert die für komplexe Arithmetik wichtigen Funktionen Abs[z], Re[z], Im[z], Conjugate[z] und Arg[z]. Achtung: falls z in symbolischer Form als  z=x + y I  gegeben ist, wird angenommen, dass sowohl x als auch y selbst komplex sind !

z = 2  +  3 I

Abs[z]

Im[z]

Conjugate[z]

Arg[z]

z = x  +  y I

Re[z]

Simplify[Exp[x] == Exp[x + 2  I Pi]]

Wenn es nötig ist, zwischen exponentieller und trigonometrischer Schreibweise eines Ausdrucks zu wechseln, können ExpToTrig und TrigToExp verwendet werden:

ExpToTrig[Exp[I x]]

TrigToExp[%^2]

. Mathematische Funktionen und Konstanten

Alle gebräuchlichen mathematischen Konstanten...

... und Funktionen sind in Mathematica vordefiniert:

?Random

?Arc*

Neben diesen Standardfunktionen existieren viele spezielle Funktionen, wie die Gamma-Funktion Gamma, die Fehlerfunktion Erf, verschiedene Bessel–Funktionen (BesselJ, BesselY, BesselI, BesselK) oder die Kugelflächfenfunktionen SphericalHarmonicY. Mehr Informationen gibt es in der Online–Hilfe unter "special functions".

3. Fortgeschrittene Anwendungen

. Listen

Mehrere Objekte können mithilfe von Listen zusammengefasst werden. Die Grundrechenarten und viele andere Funktionen sind für Listen elementweise definiert. Dadurch verhalten sich bspw. Listen von Zahlen wie Vektoren oder "Listen von Listen" wie Matrizen:

v = {1, 2, 3, 4}

w = -v*2

w + v

Zum Erstellen neuer Listen ist die Funktion Table häufig praktisch: Folgendes Beispiel liefert eine Liste mit fünf identischen Elementen

Table[Sin[2], {5}]

Hier ist ein komplizierteres Beispiel. Das Ergebnis is eine 10×3–Matrix, in der die n–te Zeile die Zahlen n, (n^2), (n^3) enthält:

potenzen = Table[{n, n^2, n^3}, {n, 10}]

Alle Befehle, die ganzzahlige Laufvariablen verwenden (vor allem Table, Do, Sum, Product), benutzen dafür dieselbe Syntax. Mögliche Eingabeformen sind
{nmax}			nmax Wiederholungen ohne Laufvariable (erstes Beispiel)
{n,nmax}		n geht von 1 bis nmax in Schritten von 1
{n,nmin,nmax}	n geht von nmin bis nmax in Schritten von 1 (zweites Beispiel)
{n,nmin,nmax,dn}	n geht von nmin bis nmax in Schritten von dn

Part[x, n] liefert den n–ten Eintrag einer Liste x zurück. Für eine Matrix x ist das eine Liste, nämlich die n–te Zeile. Um die n–te Spalte zu erhalten, muss x vorher transponiert werden:

qzahlen = Part[Transpose[potenzen], 2]

Statt Part können auch doppelte eckige Klammern zum Indizieren von Listen verwendet werden. In beiden Fällen hat das erste Element den Index 1 (nicht etwa 0 wie in "C").

{potenzen[[3]], potenzen[[4, 3]]}

Die Funktion Apply wendet eine Funktion auf alle Listenlemente auf einmal an

Apply[Plus, qzahlen]

Map dagegen wendet eine Funktion auf jedes Listenelement einzeln an

Map[Sin, qzahlen]

. Selbstdefinierte Variablen und Funktionen

Symbole können verwendet werden, um Funktionen zu definieren oder beliebige Ausdrücke zu speichern. In allen späteren Rechnungen wird das Symbol automatisch durch den zugewiesenen Wert ersetzt:

\(\(\(rand\)\(=\)\(Random[]\)\(	\)\( (*\ 
        setze\ rand\ auf\ eine\ feste\ Zufallszahl\ *) \)\)\)

rand*2

Eigene Funktionen können auf ähnliche Weise definiert werden:

randint[min_, max_] := Random[Integer, {min, max}]

Table[randint[2, 10], {10}]

Zwei Punkte sind in diesem Beispiel wichtig: Der Unterstrich "_" hinter min und max und das " := " Symbol anstelle von " = " bei der Variablendefinition.

Variablen werden mit einem einfachen " = " definiert, Funktionen dagegen mit " := ". Auf der linken Seite der Zuweisung muss an die Argumentnamen einer Funktion ein Unterstrich angehängt werden.

Ungewünschte Definitionen können wieder gelöscht werden

\(\(\(Clear[v]\)\(		\)\( (*\ 
      ein\ Symbol\ löschen\ *) \)\)\)

\(\(\(Clear[r1, r2]\)\(	\)\( (*\ 
      mehrere\ Symbole\ löschen\ *) \)\)\)

Clear["Global`*"]

Eine spezielle Notation für Funktionen ist im Umgang mit Operationen wie Map oder Nest oft sehr praktisch. Pure functions sind Funktionen ohne Namen, die überall dort direkt eingefügt werden können, wo sonst ein Funktionsname erwartet würde. Statt

f[x_] = Sin[x]^2

N[Map[f, Range[1, 10]]]

kann man mit pure functions auch kürzer schreiben

N[Map[Sin[#]^2 &, Range[1, 10]]]

Hierbei werden die Funktionsargumente mit #, #2, #3, … bezeichnet und die Definition der Funktion mit einem Ampersand " &" beendet.

. Symbolische Mathematik, Umformen von Ausdrücken

Symbole, denen noch kein Wert zugewiesen wurde, verhalten sich wie Unbekannte. Sie können verwendet werden, um allgemeine Berechnungen vorzunehmen

Sum[q^n, {n, 1, Infinity}]

Integrate[Tan[c*y], y]

Einige offensichtliche Vereinfachungen werden automatisch vorgenommen, in komplizierteren Fällen muss man Simplify verwenden

Simplify[Sin[x]^2 + Cos[x]^2]

Simplify[(a^2 - b^2)/(a - b)]

Manche symbolischen Ausdrücke können nur unter bestimmten Annahmen vereinfacht werden. Zum Beispiel gilt Sqrt[x^2] == x nur für reelle x. In solchen Fällen müssen die Annahmen explizit an Simplify übergeben werden:

Simplify[Sqrt[x^2]]

Simplify[Sqrt[x^2], x < 0]

Simplify[Sin[x + 2  Pi n], n ∈ Integers]

Manchmal findet FullSimplify zusätzliche Vereinfachungen, die Simplify nicht entdeckt

Simplify[(I/4)/E^(2*I*x) - I/4*E^(2*I*x)]

FullSimplify[%]

Sqrt[x^2] konnte in obigem Beispiel nicht vereinfacht werden, da x als komplexe Variable angenommen wurde, für die die gewöhnlichen Potenzregeln nur eingeschränkt gelten. Die Anwendung dieser Potenzregeln kann mit PowerExpand erzwungen werden

PowerExpand[{(Sqrt[x])^2, (a*b)^c, (a^b)^c}]

Symbole in Ausdrücken können mithilfe des  /.  Operators ersetzt werden (unentbehrlich!)

(Sqrt[a]) /. a -> x^2 + y^2

a + b /. {a -> b^2, b -> c^3}

. Schleifen und If-Anweisungen

Die wichtigsten aus imperativen Programmiersprachen bekannten Schleifentypen sind auch in Mathematica vorhanden. (Die von Do verwendeten Zählvariablen wurden im Abschnitt "Listen" erklärt.)

Do[Print["Hallo Welt!"], {5}]

liste = {};
Do[liste = Append[liste,  Prime[n]], {n, 1000, 
        1005}]
liste

Schleifen können auch mit For und While formuliert werden.

Häufig ist es einfacher und schneller anstelle dieser allgemeinen Schleifen spezialisierte Operationen wie Table, Map, Nest, oder Apply zu verwenden

Table[Prime[i], {i, 1000, 1005}]

Map[Prime, Range[1000, 1005]]

Nest[Sin, x, 3]

Nest[Sin, 1.2, 3]

NestList[Sin, x, 3]

If-Anweisung funktionieren ganz ähnlich wie in anderen Programmiersprachen auch

wuerfel[] := Random[Integer, {1, 6}]

\(If[wuerfel[] == 
        wuerfel[], 
Print["Pasch"], 
Print["Kein Pasch"]]\)

. Eingabe von Formeln

Die Verwendung zweidimensionaler Formeln (etwa (Sqrt[2]) anstelle von Sqrt[2]) und mathematischer Symbole kann die Notation manchmal merklich vereinfachen. Für die gebräuchlichsten Symbole stehen im File–Menü einige Paletten zur Verfügung (in den meisten Fällen reicht "BasicInput"). Zwischen den Platzhaltern ■ und □ kann mit der ⇥-Taste hin- und hergewechselt werden.

Folgende Tabelle enthält einige nützliche Tastenkombinationen. Das Symbol "" steht dabei für die Esc-Taste, das "+" deutet an, dass die Tasten gleichzeitig zu drücken sind.

Einen Ausdruck wie

(1/(π (Sqrt[ x (1 - x)]) + y));

erhält man also entweder mithilfe der Paletten und ⇥, oder durch die Tastenfolge 1, Ctrl+⇧+6, Esc, pi, Esc, Ctrl+2, x(1-x), Ctrl+␣, +y.

4. Analysis

. Differentiation und Integration

Ableiten nach einer Unbekannten x

D[x Log[x], x]

Zweifache Ableitung nach x

D[Exp[x^2], {x, 2}]

Gemischte Ableitung (∂_y)(∂_x)

D[Sin[x y], x, y]

Unbestimmtes Integral...

Integrate[(1/(1 + x^2)), x]

und bestimmtes Integral werden mit Integrate berechnet. Im folgenden Fall ist das Ergebnis allerdings nicht geschlossen darstellbar:

Integrate[Sin[Sin[x]], {x, 0, 10}]

Numerische Integration löst das Problem

NIntegrate[Sin[Sin[x]], {x, 0, 10}]

Mehrfache Integrale lasssen sich einfach durch die Angabe mehrere Integrationsvariablen berechnen

Integrate[Exp[-(x^2 + y^2)], {x, 0, x1}, {y, 0, x2}]

. Reihenentwicklungen

Analytische Funktionen können mit Series in eine Potenzreihe entwickelt werden. Neben dem Entwicklungspunkt muss außerdem noch angegeben werden, bis zu welcher Ordnung entwickelt werden soll (hier 6 bzw. 4)

Series[Sin[x], {x, 0, 6}]

Series[Log[x + 1], {x, 0, 4}]

Mit Potenzreihen kann in gewissen Grenzen wie mit anderen Ausdrücken gerechnet werden

% + %%

. Summen, Produkte und Grenzwerte

Zusätzlich können auch Grenzwerte, (unendliche) Reihen und (unendliche) Produkte ausgewertet werden

Limit[Sin[x]/x, x -> 0]

Sum[Binomial[n, m], {m, 0, n}]

Sum[1/n^2, {n, 1, ∞}]

Product[1 + 1/k, {k, 1, n}]

Product[1 + 1/k^2, {k, 1, ∞}]

5. Lösen von Gleichungen

. Gewöhnliche Gleichungen

Um die Lösung einer beliebigen Gleichung zu finden, steht mit FindRoot ein numerischer Gleichungslöser zur Verfügung

FindRoot[Sin[x] == x^2, {x, 1}]

Man kann den Suchbereich von FindRoot auf ein beliebiges Intervall einschränken, indem man zusätzlich zum Startwert die Intervallgrenzen übergibt (obwohl das meistens nicht nötig ist):

FindRoot[Exp[x] == 5  x^3, {x, 1, 0, 2}]

Im Gegensatz zu FindRoot versucht Solve, die Gleichung aufzulösen und eine allgemeine Lösung zu bestimmen. Wo das nicht geht (etwa im ersten Beispiel oben) gibt es eine Fehlermeldung, sonst eine Liste der Lösungen

Solve[x^2 + p x + q == 0, x]

Auch wenn Solve alle Lösungen findet, sind diese oft nur numerisch darstellbar

Solve[x^6 + x == 10, x]

N[%]

Stattdessen kann man auch gleich die numerische Variante von Solve benutzen

NSolve[x^6 + x == 10, x]

Die vorgestellten Funktionen sind auch in der Lage, Gleichungssysteme in mehreren Variablesn zu lösen. Ein Beispiel

FindRoot[{Sin[x] == Cos[x], 
        x^2 + y^2 == 1}, {x,  .5}, {y,  .2}]

. Differentialgleichungen

Schließlich können auch Differentialgleichungen und Systemen von Differentialgleichungen sowohl exakt als auch numerisch gelöst werden.

DSolve[y''[x] == ω^2 y[x], y[x ], x]

DSolve[{y'[0] == a, y''[x] == ω^2  y[x]}, 
      y[x], x]

In dieser Form wird eine Ersetzungsregel für y[x] zurückgeliefert. Ist man auch an Ableitungen von y interessiert, ist vorteilhaft nicht nach y[x], sondern nach y aufzulösen:

{y[x], y'[x]} /. 
      DSolve[{y[0] == 0, y'[0] == 
            a, y''[x] == ω^2  y[x]}, y, x]

Auch für Differentialgleichungen können numerische Lösungen gesucht werden. NDSolve berechnet einige Lösungspunkte im angegebenen Intervall, die von der zurückgelieferten InterpolatingFunction interpoliert werden.

NDSolve[{y'[x] == Cos[x*y[x]], y[0] == 1}, 
      y[x], {x, -5, 5}]

Mit folgender Ersetzung kann man dieses Ergebnis wie eine reguläre Funktion benutzen (etwa zum Plotten).

f[x_] := Evaluate[y[x] /. %]

In ähnlicher Weise lassen sich auch partielle Differentialgleichungen lösen. Mehr Informationen dazu gibt es (wieder einmal) in der Online-Hilfe.

6. Lineare Algebra

. Matrizen und Vektoren

Wie bereits erläutert, verhalten sich Listen weitgehend wie Vektoren, da alle Grundrechenarten für sie elementweise definiert sind. Matrizen werden als Listen von Listen dargestellt

a = {a1, a2, a3};  b = {b1, b2, b3};

\(\(\(a . b\)\(	\)\( (*\ Skalarprodukt\ *) \)\)\)

\(\(\(Cross[a, b]\)\(	\)\( (*\ Kreuzprodukt\ *) \)\)\)

m = {{2, 1, 0}, {0, 3, -1}, {0, 0, 3}}

\(\(\(%\)\(//\)\(MatrixForm\)\(		\)\( (*\ Äquivalent\ zu\ MatrixForm[%]\ *) \)\)\)

\(\(\(m . a\)\(			\)\( (*\ 
      Lineare\ Abbildung\ eines\ Vektors\ *) \)\)\)

Um Matrizen zu erstellen gibt es natürlich Table, aber zusätzlich noch einige spezielle Funktionen. Eine 3×3 Matrix erstellen...

b = Table[i*j, {i, 3}, {j, 3}]

... oder eine 3×3 Diagonalmatrix...

d = DiagonalMatrix[{x1, x2, x3}]

... oder eine 3×3 Einheitsmatrix

IdentityMatrix[3]

b ist symmetrisch, stimmt als mit der eigenen Transponierten überein

Transpose[b] == b

Andere klassische Funktionen einer Matrix sind die Determinante und die Inverse

Det[d]

Inverse[d]

Clear[a, b, d, m]

. Lineare Gleichungssysteme

Lineare Gleichungssysteme können natürlich mit den allgemeinen Lösungsverfahren von Solve aufgelöst werden. Das ist der praktischere Weg, wenn bereits die Gleichungen selbst vorliegen. Wenn dagegen nur die Matrix m und der Vektor b in der Gleichung m . x == b bekannt sind, ist es einfacher, die Funktion LinearSolve zu verwenden:

LinearSolve[{{1, 2}, {3, 4}}, {a, b}]

Für homogene LGSe kann man auch zu NullSpace greifen, um eine Basis des Kerns der Matrix zu ermitteln

NullSpace[{{2, -2}, {4, -4}}]

Muss ein lineares Gleichungssystem mehrfach für verschiedene b aber konstantes m gelöst werden, kann es effizienter sein, zunächst eine LU-Dekomposition der Matrix durchzuführen:

lu = LUDecomposition[{{1, 2}, {3, 4}}]

LUBackSubstitution[lu, {a, b}]

. Eigenwerte und Eigenvektoren

Zur Berechnung der Eigenwerte und -vektoren einer Matrix stellt Mathematica die Funktionen Eigenvalues und Eigenvectors zur Verfügung. Für eine n×n Matrix liefert Eigenvalues immer n (nicht unbedingt verschiedene) Zahlen, während Eigenvectors bei weniger als n unabhängigen Eigenvektoren (wie im folgenden Beispiel) Nullvektoren anhängt.

m = {{2, 1, 0}, {0, 3, -1}, {0, 0, 3}};

Eigenvalues[m]

Eigenvectors[m]

Eigensystem berechnet gleichzeitig die Eigenwerte und -vektoren einer Matrix und gibt sie als Liste zurück.

{ew, ev} = Eigensystem[m]

5. Grafik

. Zweidimensional

Plot stellt eine Funktion auf einem reellen Intervall dar…

Plot[(x^2)/Log[x], {x, 0, 10}];

… oder auch mehrere Funktionen. Das folgende Beispiel zeigt auch, wie man eine Option an Plot übergibt (hier Frame -> True).

Plot[{BesselJ[0, x], BesselJ[1, x]}, {x, 0, 10}, 
        Frame -> True];

Parametrische Kurven in der Ebene werden von ParametricPlot dargestellt

ParametricPlot[{Cos[t]/t, Sin[t]/t}, {t, 0, 3  Pi}, 
        AspectRatio -> Automatic, ImageSize -> 200];

. Dreidimensional

Eine Funktion (ℝ^2) -> ℝ kann mit Plot3D veranschaulicht werden

Plot3D[((x^2) + 2  (y^2)) (E^(1 - x^2 - y^2)), {x, -2, 
          2}, {y, -2, 2}, ImageSize -> 200];

Parametrische Plots im Raum sind entweder Kurven, wenn nur ein Parameter verwendet wird, oder Oberflächen für zwei Parameter. Das zweite Beispiel zeigt den Betrag der Kugelflächenfunktion ((Subscript[Y, 2])^(-1))

ParametricPlot3D[{Cos[t], Sin[t], t/4}, {t, 0, 2  Pi}, 
        ImageSize -> 200];

r[t_, p_] := Abs[SphericalHarmonicY[2, -1, t, p]];

ParametricPlot3D[
        r[θ, ϕ] {Sin[θ] Cos[ϕ], 
            Sin[θ] Sin[ϕ], 
            Cos[θ]}, 
{θ, 0, Pi}, {ϕ, 0, 
          2  Pi}, AspectRatio -> 1, ImageSize -> 200];

. Andere Visualisierungsmöglichkeiten

Diskrete Punktmengen werden mit ListPlot gezeichnet. Die Option PlotJoined -> True verbindet die einzelnen Punkte.

ListPlot[Table[{i, Log[Fibonacci[i]]}, {i, 50, 100}]];

ContourPlot bietet eine weitere Möglichkeit, eine Funktion (ℝ^2) -> ℝ darzustellen:

ContourPlot[Sin[x y], {x, -1, 1}, {y, -1, 1}, 
        ImageSize -> 150];

7. Einige vollständige Beispiele

Die folgenden Abschnitte demonstrieren, wie man Mathematica in einigen einfachen konkreten Problemen einsetzt. Für die Grafiken verwenden wir dabei durchgehend folgende Optionen:

SetOptions[{ListPlot,  ParametricPlot, ContourPlot}, 
        ImageSize -> 150,  AspectRatio -> Automatic];

. Darstellung der n-ten Einheitswurzeln

Die Lösungen von Gleichungen liefert Solve in Form einer Liste von Ersetzungsregeln zurück:

Solve[z^4 == 1, z]

Um eine Liste aller n-ten Einheitswurzeln (aller Lösungen der Gleichung (z^n) == 1) zu bestimmen, kann man also schreiben

einheitsw[n_] := Module[{z}, z /. Solve[z^n == 1, z]]

Separiert man Real- und Imaginärteil erhält man hieraus die entsprechende Punktmenge in der Gaußschen Zahlenebene, die man schließlich mit ListPlot darstellen kann

ewxy = Map[{Re[#], Im[#]} &, einheitsw[8]]

ListPlot[ewxy, 
        PlotStyle -> {AbsolutePointSize[4]}];

. Koch-Kurve (zum Knobeln)

Dieses Beispiel demonstriert die rekursive Konstruktion einer Koch-Kurve. Ausgangsfigur ist dabei das folgende gleichseitige Dreieck.

dreieck = 
        List[{{-1, 0}, {1, 0}}, {{1, 0}, {0, (Sqrt[3])}}, {{0, (Sqrt[3])}, {-1, 
              0}}];

Diese Funktion erstellt eine graphische Darstellung einer Koch–Kurve n–ter Ordnung. Die Kurve selbst wird wird von verfeinerung berechnet, die obiges Dreieck in n rekursiven Schritten "verfeinert" und eine Kantenliste zurückliefert.

kochkurve[n_Integer] := 
      Graphics[Map[Line, verfeinerung[dreieck, n]]]

Diese Verfeinerung läuft wie folgt ab:

verfeinerung[kanten_,  0] := kanten;
verfeinerung[kanten_List,  n_Integer] := 
      verfeinerung[
Flatten[Map[auswoelben, kanten], 
          1], 
n - 1]

Schließlich das Auswölben einer Kante: Das mittlere Drittel jeder Kante wird entfernt und in die Lücke die Spitze eines kleineren gleichseitigen Dreiecks eingesetzt

<< Geometry`Rotations`
rotmat = RotationMatrix2D[60  Degree]

auswoelben[{a_, b_}] := 
      Module[{x, y, s}, 
x = 
          a + (b - a)/3; 
y = 
          b - (b - a)/3; 
s = 
          x + rotmat . (y - x); 
List[{a, x}, {x, 
            s}, {s, y}, {y, b}]]

GraphicsArray[Table[kochkurve[i], {i, 0, 4}]] // Show

. Symmetrische Matrizen

Reelle symmetrische Matrizen treten in vielen Zusammenhängen auf, etwa als Kovarianzmatrix Σ in mehrdimensionalen Normalverteilungen

\(p \((x)\) = 
      A\ e\^\(\(\(-1\)\/2\) \(\((x - μ)\)\^T\) \(Σ\^\(-1\)\) \((x - μ)\)\)\)

oder als Trägheitstensor J bei der Definition der Rotationsenergie in der klassischen Mechanik

(Subscript[E, rot]) (ω) = (1/2) (ω^T) 
        J ω

In beiden Fällen sind die mithilfe der Matrizen gebildeten Ausdrücke positiv definite quadratische Formen. Diese haben die besondere Eigenschaft, dass Punkte mit konstantem Funktionswert auf Hyperellipsoiden im jeweiligen Vektorraum liegen (etwa der Trägheitsellipsoid der ω-Vektoren mit konstanter Rotationsenergie). Das kann man im Zweidimensionalen folgendermaßen veranschaulichen.

quadform[mtx_, vec_] := vec . mtx . vec

\(\(\(m = {{2, 3}, {3, 6}};\)\(	\)\( (*\ 
      symmetrisch\ und\ pos . \ def . \ *) \)\)\)

Einen Überblick über das Aussehen der zugehörigen quadratischen Form kann man sich mit ContourPlot verschaffen

ContourPlot[
        quadform[m, {x, y}], {x, -10, 10}, {y, -10, 
          10}, 
PlotPoints -> 40, 
        ColorFunction -> Hue, Contours -> 30];

Wir drücken die quadratische Form gleich in Polarkoordinaten aus, um eine der Ellipsen einfach parametrisieren zu können

qform[r_, t_] = 
      Simplify[quadform[m, {r Cos[t], r Sin[t]}]]

Die Menge der Vektoren in der Ebene für die die Funktion konstant Eins ist, lässt sich dann wie folgt darstellen

r[t_] = Part[r /. Solve[qform[r, t] == 1, r], 2]

g = 
      ParametricPlot[{r[t]*Cos[t], r[t]*Sin[t]}, {t, 0, 2  Pi}]

Schließlich kann man noch die Eigenvektoren von m einblenden. Wie man sieht, sind die Eigenvektoren gerade die Hauptachsen der Ellipse, und die Länge der Hauptachsen ist jeweils der Kehrwert der Wurzel aus dem zugehörigen Eigenwert (warum?).

{ew, ev} = Eigensystem[m]

ev2 = Map[#/Sqrt[# . #] &, ev];

li = 
        Line[{ev2[[1]]/(Sqrt[ew])[[1]], {0, 0}, 
            ev2[[2]]/(Sqrt[ew])[[2]]}];

Show[{g, Graphics[{AbsoluteThickness[3], li}]}]