Einführung in Mathematica

Carsten Rezny

Graphische Darstellung

Mathematica verfügt über umfangreiche Möglichkeiten zur graphischen Darstellung.

Ein einfacher Funktionsplot:

Plot[(x^2)Sin[x],{x,0,20}]

Mehrere Kurven in einem Plot:

Plot[{x^2,x^3},{x,-5,5}]

Es gibt sehr viele Plot-Optionen, hier nur ein paar Beispiele:

StreamPlot[{x^2,x^3},{x,-5,5},PlotRange->{-5,5}]

Plot[Exp[-(x^2)],{x,-3,3},Filling->Axis]

Auch Listen können geplottet werden:

ListPlot[Prime[Range[50]],Filling->Axis]

Für Funktionen in zwei Variablen gibt es Plot3D:

Plot3D[Sin[(x^2)+(y^2)],{x,-2,2},{y,-2,2}]

Eine andere Möglichkeit, eine Funktion in zwei Variablen darzustellen, ist DensityPlot:

Manipulate[DensityPlot[Sin[(x^2)+(y^2)],{x,-a,a},{y,-a,a}],{{a,1},0.01,5}]

Eine andere Möglichkeit, eine Funktion in zwei Variablen darzustellen, ist ContourPlot:

ContourPlot[Sin[(x^2)+(y^2)],{x,-3,3},{y,-3,3}]

Auch hier gibt es zahlreiche Optionen, um die Details der Ausgabe zu beeinflussen.

ContourPlot[Sin[(x^2)-(y^2)],{x,-3,3},{y,-3,3},Contours->4]

ContourPlot[Sin[(x^2)-(y^2)],{x,-3,3},{y,-3,3},Contours->30,ColorFunction->"StarryNightColors"]

Es gibt zahlreiche Farbschemata:

ColorData["Gradients"]

Ähnlich wie ContourPlot zeigt auch DensityPlot den Graphen der Funktion in der Draufsicht, verwendet aber statt Höhenlinien einen kontinuierlichen Farbverlauf.

DensityPlot[Sin[(x^2)-(y^2)],{x,-3,3},{y,-3,3},ColorFunction->"LightTerrain"]

Die Auflösung eines Plots wird durch die Optionen PlotPoints und MaxRecursion bestimmt. Zunächst bestimmt Plot die Funktionswerte an PlotPoints Stellen im darzustellenden Bereich. Wenn der Graph zwischen diesen Punkten noch zu “eckig” ist, werden bis zu MaxRecursion Zwischenwerte bestimmt.

Plot[((Sin[x])/x),{x,-10,10},PlotPoints->10,MaxRecursion->0]

Anschaulich wird das Verhalten mit Manipulate:

Manipulate[Plot[((Sin[x])/x),{x,-10,10},PlotPoints->pp,MaxRecursion->mr],
{pp,2,100,1},{mr,0,10,1}]

Zurück zur Option PlotRange:

Plot[(1/x),{x,-5,5}]

Plot[(1/x),{x,-5,5},PlotRange->All]

Wenn ein Plot beliebig große (oder kleine) Werte enthalten kann, bestimmt die Auflösung, wie weit All geht.

Plot[(1/x),{x,-5,5},PlotRange->All,PlotPoints->200]

Die Funktion ParametricPlot zeichnet parametrisierte Kurven.

Z.B. Kreise

ParametricPlot[{Sin[t],Cos[t]},{t,0,2π}]

Ellipsen

ParametricPlot[{Sin[t],.6 Cos[t]},{t,0,2π}]

Spiralen

ParametricPlot[{t ((Log[t])^2) Sin[t],t ((Log[t])^2) Cos[t]},{t,0,8π}]

oder Lissajous-Figuren

ParametricPlot[{Sin[3t],Sin[12t]},{t,0,2π}]

Manipulate[ParametricPlot[{Sin[3 t+u],Sin[12 t]},{t,0,2 π}],{u,0,2 π}]

Zufallszahlen und Statistik

Pseudozufallszahlen können einzeln oder als Liste aus einem frei wählbaren Bereich erzeugt werden.

RandomInteger[100]

RandomInteger[{1000,1999}]

RandomInteger[{1000,1999},10]

Für Gleitkommazahlen gibt es RandomReal; RandomComplex für komplexe Zufallszahlen. RandomReal arbeitet per default mit einer Präzision von sechs Stellen, was durch die Option WorkingPrecision beeinflusst werden kann.

RandomReal[10]

RandomReal[10,WorkingPrecision->25]

RandomComplex[10+10I,WorkingPrecision->25]

Der Zufallszahlengenerator berechnet eine Sequenz von annähernd gleich verteilten Zahlen, die durch ihren Startwert eindeutig bestimmt ist (daher Pseudo-Zufallszahlen). Der Startwert wird beim Start von Mathematica aus einer möglichst zufälligen Quelle gesetzt (/dev/random, Systemuhr). Zum Testen einer Rechnung ist es oft nützlich, reproduzierbare Zufallszahlen zu erhalten. Dafür kann man den Startwert manuell setzen:

SeedRandom[42]; RandomReal[]

RandomReal[]

SeedRandom[42]; RandomReal[]

Die Funktion BlockRandom kapselt den Zufallszahlengenerator, so dass die Verwendung von Random-Funktionen innerhalb von BlockRandom sich nicht auf später generierte Zufallszahlen auswirkt.

{RandomReal[],BlockRandom[SeedRandom[42];RandomReal[]],RandomReal[]}

Einige Statistikfunktionen:

list=RandomReal[50,1000];
Mean[list]

StandardDeviation[list]

Anstelle von gleichverteilten Zufallszahlen kann man auch andere Verteilungen verwenden.

RandomInteger[BinomialDistribution[100,0.7],30]

Werte zählen:

%//Tally

list=RandomInteger[BinomialDistribution[100,0.3],100000];

ListPlot[Tally[list],Filling->Axis]

Oder einfacher:

Histogram[list]

Es gibt eine größere Auswahl an Wahrscheinlichkeitsverteilungen: NormalDistribution, CauchyDistribution, PoissonDistribution, ...

Die Wahrscheinlichkeitsdichtefunktion (probability density function, PDF) einer Verteilung kann man auch direkt plotten:

DiscretePlot[PDF[PoissonDistribution[15],x],{x,0,50}]

Ein Beispiel für eine einfache Irrfahrt (Random Walk):

data=Module[{t=0},Table[t+=RandomReal[{-1,1}],{2000}]];

ListPlot[data]

Lösen von Gleichungen

Viele Gleichungen kann man mit Solve lösen.

eqn=(x^4)-4(x^3)+3x-1==0

sol=Solve[eqn,x]

Das Resultat ist eine geschachtelte Liste von Ersetzungsregeln. Dazu ein kurzer

Exkurs: Ersetzungsregeln

Ein Ausdruck der Form x->(y^2) ist eine Ersetzungsregel. Im Unterschied zur Zuweisung wird eine Ersetzungsregel nur auf Anforderung angewandt, nie automatisch.

Die Anwendung einer Ersetzungsregel geschieht mit dem Operator /. (ReplaceAll).

(x^2)+2x-1/.x->(y^2)

Der Pfeil-Operator -> kam schon bei Funktionsoptionen vor, die tatsächlich auch Ersetzungsregeln sind.

Ersetzungsregeln können auch Muster verwenden:

f[x^2]+f[y]-2f[(((u+1))^2)]/.f[((x_)^2)]->g[x]

Analog zu verzögerten Zuweisungen (:=) gibt es auch bei Ersetzungsregeln eine Variante mit verzögerter Auswertung der rechten Seite (:>).

a=2; rule=x->2a+1

rule=x:>2a+1

Ersetzungen werden nicht rekursiv durchgeführt. Wird ./ mit einer Liste von Ersetzungsregeln verwendet, werden die Regeln der Reihe nach probiert, bis eine passt.

x/.{x->1,x->3,x->7}

Eine geschachtelte Liste von Regeln erzeugt eine Liste von Resultaten:

x/.{{x->1},{x->3},{x->7}}

Exkurs Ende

Deshalb ist auch das Resultat von Solve eine Liste von Listen. Wendet man es auf die gelöste Gleichung an, erhält man

eqn/.sol

Simplify[%]

Für Gleichungen fünften und höheren Grades können die Lösungen im Allgemeinen nicht in geschlossener Form notiert werden.

Solve[(x^5)+4(x^3)-1==0,x]

Dennoch sind diese Lösungen exakte Zahlen, die Mathematica durch sogenannte Root-Objekte darstellt. Mit Root-Objekten kann man wie mit anderen Zahlen weiterrechnen.

(x^5)+4(x^3)-1/.x->Root[-1+4 ((#1)^3)+((#1)^5)&,1]

Simplify[%]

Wenn eine numerische Lösung gesucht ist, kann auch das deutlich schnellere NSolve verwendet werden:

NSolve[(x^5)+4(x^3)-1==0,x]

Clear[a,b,c]

Generische und nicht-generische Lösungen

Für parametrisierte Gleichungen wie

eqn=a (x^2)+b x +c==0;

liefert Solve nur generische Lösungen, also solche, die sich explizit auf die gesuchte Variable beziehen. Dabei macht Solve implizit Annahmen über die Parameter.

Solve[eqn,x]

In diesem Fall liefert Reduce eine allgemeinere Lösung, die auch die vorhandenen Parameter berücksichtigt:

Reduce[eqn,x]

Reduce liefert auch Lösungsbedingungen für Ungleichungen.

Reduce[(x^3)-2 (x^2)+1>0,x]

Im Unterschied zu Solve gibt Reduce keine Ersetzungsregeln zurück, sondern logische Ausdrücke von (Un-)Gleichungen. Im Fall von Gleichungen kann man diese mit ToRules wieder in Ersetzungsregeln umwandeln:

ToRules[Reduce[eqn,x]]

Numerische Lösungen

Wenn weder Solve noch Reduce eine Lösung finden, kann mit FindRoot numerisch nach Lösungen gesucht werden.

eqn=Log[(x^2)+1]==(Sqrt[x])

Reduce[eqn,x]

(Solve und Reduce benötigen unter Umständen recht lange.)

FindRoot sucht ausgehend vom angegebenen Startwert eine Lösung der Gleichung mit dem Newton-Verfahren. Wie viele Lösungen es gibt, erfährt man so nicht.

FindRoot[eqn,{x,0}]

FindRoot[eqn,{x,1}]

Differentialgleichungen

Differentialgleichungen werden in der Form

y'[x]==f[x,y[x]]

angegeben, z.B.:

y'[x]==1-2 y[x]^2

Analytische Lösungen sucht man mit DSolve:

DSolve[y'[x]==1-y[x]^2,y,x]

Das Resultat von DSolve ist wieder eine Liste von Ersetzungsregeln.

Viele Differentialgleichungen lassen sich nicht analytisch, sondern nur numerisch lösen. Das erledigt NDSolve:

NDSolve[
{
y'[x]==1/(1+y[x]^2),
y[0]==0
},
y,
{x,0,1000}
]

Auch hier gibt es sehr viele wietere Möglichkeiten.

Datei-Ein- und Ausgabe

Die allgemeinste Möglichkeit besteht mit den Funktionen Import und Export:

data=Import["dateiname.csv"];

Import versteht sehr viele Dateiformate, u.a. CSV, XLS  sowie viele weitere Daten-, Grafik- und Audioformate. (-> Listing of All Formats in der Online-Hilfe”.

Für schlichte Textdateien mit Zahlenreihen ist ReadList schneller:

data=ReadList["dateiname.dat"];

Falls eine Datei zu groß ist, um sie am Stück einzulesen, kann man sie mit OpenRead öffnen und dann  mit Read stückweise verarbeiten.

stream=OpenRead["file"];
While[(data=Read[stream]) ≠ EndOfFile,
DoSomethingWith[data];
];

ReadList, Read und Verwandte kennen viele Optionen, um das erwartete Datenformat zu spezifizieren.