Mathematica Einführung

Bonn, 16.4.2009

Variablen

x=5   (*Wertzuweisung*)

x=48/36   (*exakte Zahlen*)

x=Pi/2   (*Mathematica-interne Objekte beginnen mit Großbuchstaben*)

Das Ergebnis ist wieder eine exakte Zahl- keine Umwandlung in numerische Größe !

Sin[x]   (*ebenso interne Funktionen*)

N[x]   (*Umwandlung in numerische Zahl *)

y=48/36.    (*Kommazahlen sind automatisch numerisch *)

y=N[Pi,1000]   (*mehr Nachkommastellen*)

y/7

x=(((a+b))^n)  (*symbolischer Ausdruck *)

x/(a+b)    (*symbolische Berechnung*)

n=3; x     (*Wertzuweisung und Ausgabe von x *)

Expand[%]    (* % ist letzter Ausdruck *)

D[x,a]   (*partielle Ableitung nach a *)

x=y=.  (* Wertzuweisungen entfernen*)

x

Listen

x={1,2,3,a,7.,"abr"}  (*beliebige Länge, beliebige Objekte*)

x[[2]]

x[[6]]

x[[2;;5]]  (*Teilliste vom 2. bis 5. Element *)

x={a,b,c,d,a}

Accumulate[x]

Count[x,a]

x={{1,2,3},{4,5,6},{7,8,9}}  (*Matrix ist Liste von Listen*)

TraditionalForm[{{1,2,3},{4,5,6},{7,8,9}}]

(({{1, 2, 3}, {4, 5, 6}}))

x[[1,2]]

x[[1;;2,2;;3]]  (*Untermatrix*)

Transpose[x]

x.x  (*Matrizenprodukt*)

x={1,{2,5,7,8,9},{"a","b","c"}} (*Einträge müssen nicht denselben Datentyp haben*)

x[[3,2]]

x[[3,5]]

Multipliktionstabelle

Table[i j,{i,1,10},{j,1,10}]

TraditionalForm[%]

Funktionen

In Mathematica ist (fast) alles eine Funktion:

Log[10,100]

Times[3,5]  (* auch die grundlegenden Rechenoperationen sind Funktionen *)

x=.;Integrate[Sin[x^2],{x,0,z}]

Plot[%,{z,0,10}]  (*Plot des Integrals*)

(∫_0^z)Cos[a x]\[DifferentialD]x

Plot3D[%,{a,0,5},{z,0,10}]

Manipulate[Plot3D[((Sin[a b z])/a),{a,0,5},{z,0,10}],{b,0,2}]
(*Hat man zuviele Parameter zum Plotten, dann kann man einzelne Parmeter mit Manipulate variabel machen*)

Selbstdefinierte Funktionen

Funktionen kann man selber definieren. Dabei Kleinbuchstaben für Funktionsnamen verwenden - interne Funktionen beginnen mit Großbuchstaben.

f[x_,y_]:=Exp[y Sin[x]]   (*Funktionsdefiniton mit Doppelpunkt, Variablen auf linker Seite mit Unterstrich *)

Plot3D[f[x,y],{x,0,6 Pi},{y,-3,3}]

?f

Clear[f]; ?f

g:=1+#^2&   (*Funktionsdefinition mit Platzhalter*)

g[2]

Plot[g[x],{x,-2,2}]

Die Argumente und Funktionswerte können beliebige Datentypen haben:

vokale[text_]:=StringCount[text,{"a","e","i","o","u"}]

vokale["ostereier"]

stammfunktion[f_,x_]:=Integrate[f[y],{y,-∞,x}]

stammfunktion[Exp,z^2]

x=.;stammfunktion[Exp[-#^2]&,x]

Clear[f]  (* Funktionsdefinition löschen *)

Iterative Anwendung von Funktionen

Durch iterative Anwendung von Funktionen kann man viele Operationen sehr effizient durchführen.

Nest[f,x,4]

NestList[f,x,4]

Fold[f,x,{a,b,c,d}]

FoldList[f,x,{a,b,c,d}]

Beipiel: Erzeugung eines Random Walk (symmetrische Irrfahrt)

zufall=RandomChoice[{-1,1},10000]

randomwalk=FoldList[Plus,0,zufall];

ListLinePlot[randomwalk]

ListLinePlot[randomwalk[[1;;1000]]]

Manipulate[ListLinePlot[randomwalk[[1;;u]]],{u,10,10000,10}]

multiplikativerzufall=RandomChoice[{1/2,3/2},10000];
geomrandomwalk=FoldList[Times,1,multiplikativerzufall];
ListLinePlot[geomrandomwalk]

Manipulate[ListLinePlot[geomrandomwalk[[1;;u]]],{u,10,10000,10}]

Das Voter - Modell

Initialisierung

r=20;s=40; (*Seitenlängen Gitter*)neigborhood={{1,0},{1,1},{0,1},{-1,1},{-1,0},{-1,-1},{0,-1},{1,-1}}; (*Nachbarschaft eines Pixels*)
plus[u_,v_]:=Mod[u+v,{r,s},{1,1}];   (*Addition auf Torus*)
xinit=RandomChoice[{Red,Green,Black,Yellow},{r,s}]; (*Anfangskonfiguration*)ArrayPlot[xinit]

Bewegungsgesetz

f[x_]:=Module[{i,j,dir,neuefarbe},
i=RandomInteger[{1,r}];j=RandomInteger[{1,s}];pos={i,j}; (*zufällige Wahl eines Pixels*)
dir=RandomChoice[neigborhood] ; (*zufällige Richtung zu Nachbarpixel*)
neuefarbe=Extract[x,plus[pos,dir]];(*Farbe des Nachbarpixels*)
ReplacePart[x,pos->neuefarbe ]]   (*Farbe am Pixel ersetzen*)

ArrayPlot[f[xinit]]

5 Übergänge hintereinander

xn=NestList[f,xinit,5]; ArrayPlot /@ xn 
(*ArrayPlot auf die einzelnen Elemente der Liste xn anwenden*)

5000 Übergänge

xn=NestList[f,xinit,5000];
Manipulate[ArrayPlot[xn[[i]]],{i,1,5000,50}]

Langzeitverhalten

Bei einer sehr großen Schrittzahl verbraucht die Liste zu viel Speicherplatz. Daher wenden wir die Funktion immer gleich n mal hintereinander an,und speichern nur alle n Schritte das Zwischenergebnis:

n=r s;fn[x_]:=Nest[f,x,n];
xkn=NestList[fn,xinit,100];
Manipulate[ArrayPlot[xkn[[i]]],{i,1,100,1}]