Einführung in Mathematica

Literatur and Links :

Hyperlink["Wolfram References","http://reference.wolfram.com/mathematica/guide/Mathematica.html"]

Hyperlink["B.Baltes-Götz: Einführung in Mathematica 5.0 Skript URZ-Trier","http://www.uni-trier.de/urt/user/baltes/docs/mathe/v5/mathe5.pdf"]

Hyperlink["James M. Feagin - Quantum Methods with Mathematica", "http://www.amazon.de/gp/product/0387953655/ref=dp_proddesc_1?ie=UTF8&n=52044011"]

Hyperlink["Strnadl - Symbolische Mathematic in der Theoretischen Physik", "http://www.qudev.ethz.ch/phys4/mathematica-fs09/mathematica_strnadl.pdf"]

Funktionalität:

Vielseitiges Frontend zur Eingabe, Programmierung, Dokumentation, Präsentation

Tips zur Verwendung

Befehle können durch Drücken von Shift - Enter in einer Program - Zelle ausgeführt werden.

8+3

Integrate[(x^2),x]

Tastenkürzel für häufig verwendete Formen :

Strg-2 für Wurzel-Zeichen

(Sqrt[3])(Sqrt[34])

Strg-6 für Hochstellen

(d^2)

(5^2)

Strg-- für Tiefstellen (Achtung bei Variablendeklarationen mit tiefgestellten Indizes: dies  kann zu Problemen führen)

(Subscript[f, i])
(Subscript[f, 3])

Strg-Shift-/ für Brüche

(d/3)(3/2)

Esc - Taste zur Eingabe von Symoblen, z.b. Esc - p - Esc ergib π

α

Esc-int-Esc ergibt ∫ und Esc-dd-Esc ergibt d

Integrate[(x^2),x]

∫(x^2)\[DifferentialD]x

(∫_0^3)(x^2)\[DifferentialD]x

∫(x^2)\[DifferentialD]x

Esc - sumt - Esc ergibt (∑_(■=□)^□)□

(∑_(j=2)^3)9

(∑_(i=1)^3)f[i]

Esc - tr - Esc ergibt ᵀ für das Transponieren einer Matrix
Ctrl-, für neue Spalte
Ctrl-Enter für neue Zeile

(({{3, 2}, {3, 1}}))\[Transpose]

MatrixForm[{{3,3},{2,1}}]

MatrixForm[(({{3, 1}, {2, 4}}))\[Transpose]]

Eingabehilfe steht mittels Basic Math Assistant (Palettes - Menu) zur Verfügung

Die Hilfefunktion ist wie üblich über F1 aufrufbar.

Plus
Integrate
Sum
Series

Beispiele zur Strukturierung und Dokumentation

Alt-<Zahl> mit Auswahl auf rechten Rand der Zelle wandelt Aussehen der Zellen in Dokumentation oder ausführbaren Code um.

f[i]

f[x]

Einfügen von Bildern möglich

Interaktive Oberflächen

TabView[{x->Import[NotebookDirectory[]<>"Bild.jpg"],y->Import[NotebookDirectory[]<>"Bild2.jpg"],z->Import[NotebookDirectory[]<>"Bild3.jpg"]}]

clock[{h_,m_,s_}]:=Graphics[{Table[Text[t,0.9{Sin[t Pi/6],Cos[t Pi/6]}],{t,1,12}],Circle[],Green,Rotate[Line[{{0,0},{0,0.9}}],(-2Pi)s/60,{0,0}],Blue,Rotate[Line[{{0,0},{0,0.8}}],(-2Pi)(m+s/60)/60,{0,0}],Rotate[Line[{{0,0},{0,0.4}}],(-2Pi)Mod[h+m/60,12]/12,{0,0}]}]

OpenerView[{Dynamic[DateString[],UpdateInterval->1],Dynamic[clock@Take[DateList[],-3],UpdateInterval->1]}]

Symbolische Programmierung

Variablendeklaration

myvar=5

myvar

Durch anfügen eines Strichpunkts wird das Ausgabeecho unterdrückt.

myvar2=23;

Variablen können wie üblich addiert, subtrahiert, dividiert, ... werden

myvar2+myvar

myvar2/myvar

% bezeichnet das Resultat der letzten Ausgabe:

myvar +myvar2/3

%+3

Achtung : Variable bleibt solange im Kernel gespeichert, bis dieser beendet wird oder die Variable gelöscht wird. Dies führt sehr häufig zu unerwarteten Ergebnissen, wenn 'alte' Variablen wiederverwendet werden

myvar2

Clear[myvar2]

myvar2

Listen

mylist={1,2,45,5,3}

myvarlist={x1,x2,x3,x4}

mystringlist={"Das","ist","eine","Liste","aus","Zeichenketten"}

mygraphicslist={Graphics3D[{Green,Cuboid[]}],Graphics[{Pink,Rectangle[]}],Graphics[{Blue,Disk[]}]}

primeList=Table[Prime[n],{n,1,200}]

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

doubleslist=Table[{x,(x^2)},{x,0,10}]

Viele Funktionen können unmittelbar auf eine Liste angewendet werden und werden dann auf für jedes Listenelement ausgeführt.

mylist

mylist+f

mylist/20
mylist^2

Listen können wieder Listen enthalten :

mysublist={1,2,{91,32},{3,2,{3,2}}}

mysublist2={{1,mylist},{2,mygraphicslist}}

Zugriff auf einzelne Listenelemente mit [[<index>]] (oder zur besseren Übersichtlichkeit mit Esc-[[-Esc: [[]])

mysublist2[[2]]

mysublist2[[2,2]]

mysublist2[[2,2,1]]

mysublist2[[1,5]]

Header eines Ausdrucks (Expression) :

mysublist/.List->f

FullForm[mysublist]

Manipulation von Listen

Teile von Listen

Take[{1,2,3,4,5},3]

Drop[{1,2,3,4,5},3]

Select[{1,2,3,4,5},EvenQ]

Select[{1,2,3,4,5},#>2&]

Cases[{x,(x^2),(x^3),(x/3),(y/2),(n^2)},((_)/2)]

Cases[{x,(x^2),(x^3),(x/3),(y/2),(n^2)},((_)^(_))]

Zusammenhängen von Listen

Join[{a3,a4,a5,a6},{a1,a2,a3}]

Union entfernt doppelte Einträge und sortiert die Liste

Union[{a3,a4,a5,a6},{a1,a2,a3}]

Strukturierung von Listen

ebnen :

flatlist=Flatten[{{a3,{a3,a4},a5,a6},{a1,a2,a3}}]

partitionieren :

Partition[flatlist,3]

(* aufeinanderfolgende Paare *)
Partition[{1,0,1,1,1,0,1,0,0,0,1,1,0,0,0},2,1]

Funktionen

Funktionen werden durch einen Namen und eine beliebige Anzahl von Parametern in eckigen Klammern gefogt von ":=" definiert.

f[x_]:=x^2;

f[10]

{f[1],f[2],f[3],f[4]}
Table[f[i],{i,1,4}]

g[x_, y_] := x + y;
g[3, 1]

g[{3, 1}]

wird erst nach Definition erkannt:

g[{x_,y_}]:=x+y;

g[{3,1}]

Intern wird eine Datenbank mit allen Zuweisungen verwaltet und sequentiell bei Aufruf einer Funktion abgefragt.

f[x_]:=x+3;
f[x]:=3;
f[3]:=9;

Das kann gelegentlich zu unerwarteten Ergebnissen führen.

{f[1],f[2],f[3],f[4]}

{f [x],f[y]}

Abrufen der Zuweisungstabelle über ? (kurze Form) und ?? (lange Form):

?f

?Sin

??Sin

Möglichkeit der Definition von bedingten Funktionen :

s[x_/;x>3]:=(x^2)
s[x_]:=0

Plot[s[x],{x,0,10}]

Überladen von Funktionen - Mustererkennung

equivalent :

Remove[b]
Options[b]={ImageSize->150,PlotRange->{{-1,1},{-1,1}},Frame->True};

b[_]:=Graphics[Disk[],Options[b]]
?b
b[x_]:=Graphics[Disk[{0,0},x],Options[b]]
?b

b[0.3]

b[x_List]:=Graphics[Disk[x,0.3],Options[b]]
?b

b[{-0.7,-0.7}]

b[{pos:{_,_},r_}]:=Graphics[Disk[pos,r],Options[b]]
?b

b[{{0,0.8},0.2}]

b[x_String]:=Graphics[{Yellow,Disk[],Black,Text[x]},Options[b]]
?b

b["disk"]

Funktionsargumente können auch mit beliebigen Funktionen getestet werden :

b[x_?IntegerQ]:=Graphics[{ColorData[x,"ColorList"][[1]],Disk[]},Options[b]]

b[4]

Wenn kein Muster zutrifft, bleibt die Funktion unevaluiert:

b[{0,.8},3]

Kurzformen von Befehlen (Symbolische Notation) :

?f ist äquivalent zu Information[f]

Information[f]

(Sqrt[mylist])
Sqrt[mylist]

Unmittelbare (=) i. G. zu verzögerte (:=)Zuweisung:

Die Auswertung einer Funktion erfolgt entweder sofort beim Auswerten der Zelle, oder es wird nur die Zuweisung gespeichert und die Auswertung erfogt erst bei Aufruf der Funktion.

(* Unmittelbare Zuweisung - Immediate assignment *)
myrand1[x_]=x Random[];

(* Verzögerte Zuweisung - Delayed assignment *)
myrand2[x_]:=x Random[];

Table[myrand1[9],{x,1,10}]
Table[myrand2[3],{x,1,10}]

?myrand1
?myrand2

{ListPlot[Table[myrand1[3],{x,1,20}]],ListPlot[Table[myrand2[3],{x,1,30}]]}

Evaluierung kann auch bei := erzwungen werden :

myrand3[x_]:=Evaluate[x Random[]];

Table[myrand3[9],{x,1,10}]

Beispiel für Definition eines Spezialfalls  bzw. des allgemeinen Falls mit unmittelbarer bzw. verzögerter Zuweisung

fact[1]=1;
fact[n_]:=n fact[n-1]

Ansonsten gibt es eine unendliche Rekursion :

fact1[n_]:=n fact1[n-1]

fact1[2]

Löschen von Zuweisungen :

Clear[f]

?f

Remove[f]
?f

verschiedene Notationen :

Sqrt[3]

Präfixnotation :

Sqrt@3

Postfixnotation :

3//Sqrt

Infixnotation für Argumente mit 2 Parametern:

3~g~4
g[3,4]

{(x^2),(x^3),(y^2),2(y^9),3(x^2)}/.{((_)^2)->f[x,2]}

Anwenden von Funktionen auf Listen

Beispiel:

arg={{0,1,Red},{0,0,Green},{0,-1,Blue}};
Graphics[{#[[3]],Disk[{#[[1]],#[[2]]},1]}]&/@arg

Map (/@)

'Map[f,x_List]' wendet die Funktion f auf die Liste x an:

Map[f,{1,2,3,4,5}]

Kurzform

f/@{1,2,3,4,5}

equivalent to

f[#]&/@{1,2,3,4,5}

Pure Function

body & ist eine 'pure function', deren formale Argumente # (oder #1,#2,..) sind

Times[#1,#2]&[3,4]
Times[3,4]

oft sehr geschickt, da keine eigene Funktionsdefinition benötigt wird :

Graphics[Disk[#,0.2],Frame->True,ImageSize->150,PlotRange->{{-1,1},{-1,1}}]&/@{{0,0},{0.3,0}}

Graphics[Disk[#,0.2],Frame->True,ImageSize->150,PlotRange->{{-1,1},{-1,1}}]&/@Table[{i,i},{i,-1,1,0.2}]

Show[
Graphics[Disk[#,0.2],Frame->True,ImageSize->150,PlotRange->{{-1,1},{-1,1}}]&/@Table[{i,i},{i,-1,1,0.2}]
]

MapThread

MapThread[f,{{a1,a2,a3},{b1,b2,b3}}]

Show[
MapThread[
Graphics[{Red,Disk[#,#2]},Frame->True,ImageSize->150,PlotRange->{{-1,1},{-1,1}}]&,
{Table[{i,i},{i,-1,1,0.2}],
Table[j,{j,0,0.2,0.02}]}]
]

Show[
MapThread[
Graphics[{Hue[#3],Disk[#1,#2]},Frame->True,ImageSize->150,PlotRange->{{-1,1},{-1,1}}]&,
{Table[{i,i},{i,-1,1,0.2}],
Table[j,{j,0,0.2,0.02}],
Table[k,{k,0,1,0.1}]
}]
]

Apply (@@)

Ersetzt den ' Head' eines Ausdrucks

f@@{a1,a2,a3,a4}
f@@{{a1,a2},{a3,a4}}

@@@ ersetzt den Head einer Subliste

f@@@{{a1,a2},{a3,a4}}

nützliche Funktion ' Sequence' wenn man Listen - Header loswerden will

Plus[{3,1,2,4,5}]
Plus[3,1,2,4,5]
Plus[Sequence@@{3,1,2,4,5}]

Nest, NestList

wendet eine Funtion n - mal auf einen Ausdruck an

Nest[f,a,10]

NestList[(({{0.3, 0.1}, {0.3, 0.9}})).#&,{1,0},10]
ListPlot[%,PlotRange->All,Frame->True,AxesOrigin->{0,0}]

Manipulate[
ListPlot[NestList[(({{0.3, 0.1}, {0.3, 0.9}})).#&,{1,0},x],PlotRange->{{0,1.1},{-0.1,0.7}},Frame->True,AxesOrigin->{0,0}],{x,0,200,1}]

Ersetzungsregeln

{x,x^2,x^4,2,y}/.{x->2}

myvarlist
myvarlist/.{x1->3}

myvarlist/.{x1->x2}

Liste von Regeln

myrulelist={x1->x2,x2->x3,x3->1};

myvarlist/.myrulelist

Wiederholtes Ersetzen :

myvarlist//.myrulelist

Liste selbst bleibt unverändert :

myvarlist

Verzögertes Ersetzen :

{x1,x2,x1}/.{x1->RandomReal[]}
{x1,x2,x1}/.{x1:>RandomReal[]}

Ersetzen mit Hilfe von Mustern

{(x^2),(x^3),(y^2),2(y^9),3(x^2)}/.{((_)^2)->f[x,2]}

{(x^2.1),(x^3),(x^3.2),(x^5)}/.{((_)^(z_Integer))->f[x,z]}

Beispiel :

(* Laden des Packages ' PhysicalConstants' mit Definitionen von den wichtigsten Naturkonstanten *)
<< PhysicalConstants`

SpeedOfLight

boltzmannfaktor[ω_,T_]=Exp[-((ℏ ω)/(kb T))];

boltzmannfaktor[3,300]

boltzmannfaktor[3 (10^13)/Second,300 Kelvin]/.{ kb -> BoltzmannConstant,ℏ->PlanckConstant/(2π)}

Visualisierung und Graphik

Plots  analytischer Funktionen:

Beispiel photoelektrischer Effekt :

(* Laden eines Zusatzpakets *)
<<PhysicalConstants`

hb=PlanckConstant/Joule /Second;
ec=ElectronCharge/Coulomb;

(* max kinetische Energie der Elektonen - W in Elektronvolt *)
Clear[ekinmax]
ekinmax[ν_,W_]:=(hb ν/ec-W )/;(hb ν/ec >W )
ekinmax[ν_,W_]:=0

Plot[ekinmax[ν (10^12),2.46],{ν,0,2000},PlotRange->{-2.5,4},BaseStyle->{FontFamily->"Arial",FontSize->12},Frame->True,FrameLabel->{"ν [(10^12)Hz]","(Subscript[E, kin, max]) [eV]"}]

Etwas verschönern:

(* für Lithium W=2.46 eV*)
aplot=Plot[ekinmax[ν (10^12),2.46],{ν,0,2000},PlotRange->{-2.5,4},BaseStyle->{FontFamily->"Arial",FontSize->12},Frame->True,FrameLabel->{"ν [(10^12)Hz]","(Subscript[E, kin, max]) [eV]"}]

Beispiel Doppelspalt :

beta[k_,D_,θ_]:=((k D)/2)Sin[θ]
Int[I0_,k_,D_,θ_]:=I0 (((Sin[beta[k,D,θ]])^2)/((beta[k,D,θ])^2))

Manipulate[Plot[Int[1,2π/(λ*(10^(-9))),(10^(-5)),θ π/180 ],{θ,-10,10},PlotRange->All,PlotStyle->{Blue},BaseStyle->{FontFamily->"Arial",FontSize->12},Frame->True,FrameLabel->{"θ [°]","Intensity"}],{λ,200,1000}]

3D Plot - Beispiel Planckes Strahlungsgesetz mit Energiedichte

<<PhysicalConstants`

hb=PlanckConstant/Joule /Second;
kb=BoltzmannConstant/Joule Kelvin;
c=SpeedOfLight/Meter Second;

planck[ω_,T_]:=(((ω^3) ℏ)/((c^3) (-1+(E^((ω ℏ)/(kb T)))) (π^2)))/.ℏ->hb/(2π)

Plot3D[planck[ω (10^12),T ](10^9),{ω,0,10 (10^2)},{T,0,1000},PlotRange->All,ColorFunction->"ThermometerColors",AxesLabel->{"ω [\!\(\*SuperscriptBox[\(10\), \(\(12\)\(\\ \)\)]\)rad/s]","T [K]","u [\!\(\*FractionBox[\(J\\ s\), \(mrad\\ \*SuperscriptBox[\(cm\), \(3\)]\)]\)]"},BaseStyle->{FontSize->12,FontFamily->"Arial"}]

DensityPlot

DensityPlot[planck[ω (10^12),T ](10^9),{ω,0,10 (10^2)},{T,0,1000},FrameLabel->{"ω [\!\(\*SuperscriptBox[\(10\), \(\(12\)\(\\ \)\)]\)rad/s]","T [K]"},PlotRange->All]

DensityPlot[planck[ω (10^12),T ](10^9),{ω,0,10 (10^2)},{T,0,1000},FrameLabel->{"ω [\!\(\*SuperscriptBox[\(10\), \(\(12\)\(\\ \)\)]\)rad/s]","T [K]"},ColorFunction->"SunsetColors",PlotRange->All]

ContourPlot

ContourPlot[planck[ω (10^12),T ](10^9),{ω,0,10 (10^2)},{T,0,1000},FrameLabel->{"ω [\!\(\*SuperscriptBox[\(10\), \(\(12\)\(\\ \)\)]\)rad/s]","T [K]"},ColorFunction->"SunsetColors",PlotRange->All,ContourLabels->Automatic]

Visualisierung von Listen :

primeList=Table[Prime[n],{n,1,200}];

ListPlot[primeList,Frame->True,FrameLabel->{"nr","prime"},BaseStyle->{FontSize->12,FontFamily->"Arial"}]

ListPlot[Tooltip[primeList],Frame->True,FrameLabel->{"nr","prime"},BaseStyle->{FontSize->12,FontFamily->"Arial"},Filling->Axis]

Beispiel photoelektrischer Effekt:

(* für Lithium W=2.46 eV*)
lidata=Table[{i,ekinmax[i*(10^12),2.46 ]+RandomReal[0.1]},{i,0,1000,20}]

lplot=ListPlot[lidata,Frame->True,FrameLabel->{"ν [(10^12) Hz]","(Subscript[E, kin, max]) [eV]"},PlotRange->{-2.5,2},BaseStyle->{FontSize->12,FontFamily->"Arial"}]

Kombinieren von Graphen :

ekinmax2[ν_,W_]:=(hb ν/ec-W )

Plot[ekinmax2[ν (10^12),2.46],{ν,0,1000},PlotStyle->Red];
Show[aplot,lplot,%]

Vielzahl integrierter mathematischer Funktionen, Algorithmen

z.B. für 
Matrizenrechnung/Lineare Algebra
Gleichungssystemen
Analysis
Optimierungsaufgaben
Statistik
 ...

Algebra

Listen stellen Vektoren und Matrizen beliebiger Dimension dar.

vec={1,3,5}
mat={{1,0,1},{2,3,3},{1,9,3}}

Bessere Darstellung:

MatrixForm[vec]
MatrixForm[mat]

Matrizen- und Vectoroperationen:

Dot[] oder .

Dot[vec,vec]//MatrixForm
vec.vec

mat.mat//MatrixForm
mat *mat//MatrixForm
mat.vec//MatrixForm
mat*vec//MatrixForm

Achtung:

vec1={2,4,1}//MatrixForm
mat.vec1

funktioniert nicht da

vec1//FullForm

weitere Befehle:

Norm[vec]
MatrixPower[mat,3]
Inverse[mat]
Transpose[mat]
Eigenvalues[mat]//N

Analysis :

Differentialrechnung

f[x_]=x^2;

D[f[x],x]
D[f[x],{x,2}]

D[g[x,y],x,y]

h[x_,y_]:=x^3+y^2+3x y
D[h[x,y],x,y]

Integralrechnung

Unbestimmte Integrale :

∫f[x]\[DifferentialD]x

Integrate[1/(x^3+1),x]
%/.x->3

Bestimmte Integrale

Integrate[f[x],{x,0,3}]

Symbolische Form: Eingabe mit Esc - int - Esc, Esc - dd - Esc und Ctrl - _ bzw. Ctrl - % für die Integrationsgrenzen

(∫_0^3)1/(x^3+1)\[DifferentialD]x

Symbolische vs. Numerische Berechnung

(∫_0^3)1/(x^3+1)\[DifferentialD]x
N[(∫_0^3)1/(x^3+1)\[DifferentialD]x]

Numerische Berechnungen sind im allgemeinen schneller als symbolische, jedoch natürlich nicht mehr exakt.

intanalyt=NIntegrate[x/(((x^3+1))^3),{x,0,3}]//Timing
intexact=Integrate[x/(((x^3+1))^3),{x,0,3}]//Timing
Print["analytisch:",NumberForm[intanalyt[[2]],20]]
Print["analytisch:",NumberForm[N@intexact[[2]],20]]

Datenmanipulation und Analyse

COBE MicrowaveBackground - Ein perfekter Schwarzer Körper

importfile=NotebookDirectory[]<>"cmb.txt";
cobedata=Import[importfile,"Data"];

cobedata

cobetemperature=cobedata[[All,{1,2}]];
cobetemperaturefreq={100c#[[1]] (10^(-9)),#[[2]]}&/@cobetemperature;
datapointplot=ListPlot[cobetemperaturefreq,PlotRange->All,Frame->True,FrameLabel->{"ν [GHz]","u(ν) [MJy (st^(-1))]"},BaseStyle->{FontFamily->"Arial",FontSize->12}]

Zugriff zu Datenbanken mit Daten zu Elementen, Isotopen, Wetter, Astronomische Daten, Genome, ..

ElementData[1,"AtomicWeight"]

meltingpoints=Table[Tooltip[ElementData[i,"MeltingPoint"],ElementData[i]],{i,1,103}]

ListPlot[meltingpoints]

Wetterdaten :

today=DateList[][[{1,2,3}]]

DateListPlot[WeatherData["LSZH","Temperature",today],Joined->True]

Dynamische Interaktivität im Frontend

Manipulate[Plot[Int[1,2π/(λ*(10^(-9))),(10^(-5)),θ π/180 ],{θ,-10,10},PlotRange->All,PlotStyle->{Blue},BaseStyle->{FontFamily->"Arial",FontSize->12},Frame->True,FrameLabel->{"θ [°]","Intensity"}],{λ,50,2000}]

Schnittstellen zu externen Programmen (C, .Net, Java, ...)