Erste Schritte mit Mathematica 7.0

Einführung für Hörer der Algorithmischen Mathematik II

Andreas Eberle

Vorbemerkung

Bevor Sie diese Einführung durcharbeiten, sollten Sie Mathematica 7.0 auf Ihrem Computer installieren, oder das Programm im CIP-Pool nutzen. Als kurzer allererster Einstieg bietet sich sich der Überblick "Learn with guided examples" an, den Sie über den Welcome Screen (in der Menueleiste unter Help) von Mathematica 7.0 starten. Auch einige der Screencast Tutorials auf der Mathematica Webseite bieten einen guten Einstieg. Mehr Informationen dazu, sowie zur Installation von Mathematica im Rahmen der Campuslizenz finden Sie auf

http://www.uni-bonn.de/~eberle/Mathematica/index.html  .

Wenn Sie Mathematica installiert haben, empfiehlt es sich, diese Einführung als Mathematica Notebook von der Webseite oben herunterzuladen, und mit Mathematica zu öffnen. Sie können die Einführung dann interaktiv nutzen, d.h. Teile verändern und neu auswerten lassen.

Mathematica ist für Mathematiker sehr leicht zu erlernen und zu bedienen, da die zugrundeliegenden Strukturen der Denkweise der Mathematik angepasst sind. Zudem gibt es eine hervorragende Dokumentation. Das Documentation Center ist auf der Menueleiste unter "Help" zugänglich. Es erklärt nicht nur in übersichtlicher Weise alle Funktionen/Befehle von Mathematica, sondern liefert zu jedem Befehl auch immer gleich eine Reihe von Beispielen. Oft findet man hier schon ein Beispiel, das so ähnlich ist, wie das, was man selber machen möchte. Man kann sich dieses Beispiel dann einfach in das Mathematica-Notebook kopieren, und dort geeignet modifizieren. Dieses Vorgehen ist viel effizienter als jedesmal selber von vorne anzufangen. Innerhalb von kurzer Zeit kann man so auch ohne Vorkenntnisse schon sehr interessante Berechnungen durchführen, Simulationen erstellen, anspruchsvolle Graphiken, und sogar interaktive Demonstrationen erzeugen.

Überhaupt lernt man Mathematica am besten durch Ausprobieren - auch das Ansehen und Modifizieren von Mathematica Moduln, wie man Sie z.B. im Wolfram Demonstrations Project im Internet findet (siehe http://demonstrations.wolfram.com) ist hilfreich. Trotzdem gibt es einige Grundlagen, die man wissen sollte, bevor man loslegt. Das Ziel dieses Leitfadens ist es, diese Grundlagen kurz zusammenzustellen. Während Sie den Leitfaden lesen, sollten Sie die vorgestellten Funktionen am besten gleich selbst parallel ausprobieren.

Eingabe

Eingaben werden in Mathematica mit SHIFT+ENTER abgeschlossen - drückt man nur ENTER wird einfach in die nächste Zeile übergegangen, aber die Eingabe nicht ausgewertet. Alle Funktionen/Befehle lassen sich über direkt über die Tastatur eingeben. Schneller ist es aber oft, die folgende Eingabemethoden zu nutzen:

In der Regel wird jede Eingabe durch SHIFT+ENTER sofort ausgewertet, und das Ergebnis angezeigt. Will man das Ergebnis nicht sofort angezeigt bekommen, und z.B. ein Programm schreiben, dann schließt man die Zeile mit einem Semikolon ab. Auf diese Weise kann man mehrere Funktonen hintereinander in einer oder mehreren Zeilen ausführen lassen, z.B.:

x=3; y=x^2

Ein Mahematica-Notebook ist in Zellen gegliedert, die durch Striche am rechten Rand angezeigt werden. Man kann diese Striche anklicken, und dann durch Klick mit der rechten Maustaste oder über den Menuepunkt "Cell" verschiedene Operationen durchführen, z.B. Zellen löschen, kopieren, zusammenfügen, teilen etc. Man kann auch durch "Evaluate Cells" (im Menue unter "Evaluation" oder rechte Maustaste) die Anweisungen aus einer früheren Zelle wieder ausführen, und durch "Evaluate Notebook" alle Zellen im Notebook (wieder) ausführen. Falls Sie dieses Notebook noch nicht ausgeführt haben, sollten Sie nun "Evaluate Notebook" durchführen.

Zellen können verschiedene Stile haben, z.B. "Input Form", "Output Form", "Text". Wenn Sie ein neues Notebook in Standardform beginnen, ist die erste Zelle eine Input Zelle, d.h. Sie können hier Funktionen eingeben, und diese durch SHIFT+ENTER auswerten. Mathematica erzeugt dann als Ausgabe eine Output-Zelle.  Durch den Menuepunkt "Format->Style" (oder durch Anklicken, rechte Maustaste,  "Style", oder über den Classroom Assistant, "Writing and Formatting->Text Cells") können Sie eine Zelle z.B. in eine Textzelle verwandeln, und so Kommentare einfügen. Output-Zellen mit mathematischen Formeln können durch "Cell ->Convert to ->Traditional Form" (auch im Classroom Assistant unter "Calculator") in eine besser lesbare Form gebracht werden.

Auf die Resultate aus vorherigen Output-Zellen können Sie durch "%" zugreifen:

Also zum Beispiel:

%1 - 7

In der Regel ist es aber übersichtlicher, die Zwischenergebnisse in Variablen abzuspeichern, und diese dann wiederzuverwenden.

Variablen und Datentypen

Variablen

Variablen kann mit "=" einen Wert zuweisen:

y=12/8

a=b=(y+1)^2     (* weist a und b den Wert zu *)

Mit "x=." oder "Clear[x]" entfernt man die Wertzuweisung wieder:

a=. ;b=. ; a    (* Werte werden gelöscht, und a wird dann ausgegeben *)

Für Variablennamen sollte man Kleinbuchstaben verwenden, da große Anfangsbuchstaben für fest definierte Konstanten und Funktionen von Mathematica reserviert sind:

Sin[Pi/2]

Datentypen

Variablen können ganz unterschiedliche Datentypen haben, z.B. exakte Zahlen, approximative (Gleitkomma-) Zahlen, approximative Zahlen mit beliebiger Genauigkeit, komplexe Zahlen, Boolesche Variablen, Listen (eindimensionale Felder, Vektoren), Listen von Listen (mehrdimensionale Felder, Matrizen),  symbolische Ausdrücke, Funktionen, Plots, Wahrscheinlichkeitsverteilungen, ....... . Dabei wird der richtige Datentyp normalerweise automatisch zugewiesen - z.B. eine exakte Zahl wenn man "2/3" eingibt, und eine approximative Zahl, wenn man "2./3" eingibt.

Exakte und approximative Zahlen

u=2./3

pi=N[Pi] 
(* N[x] verwandelt x in eine approximative Zahl, liefert also den numerischen Wert mit 16 Nachkommastellen Genaigkeit *)

pi100=N[Pi,100]   (* approx. Zahl mit 100 Nachkommastellen *)

pi100^2

Listen, Vektoren, Matrizen

v={3,5,7}    (* Liste, Vektor *)

v[[2]]      (* Mit Doppelklammern x[[i]] greift man auf das i-te Element der Liste zu *)

σ={{3,5,7},{1,2,3},{0,0,1}}; y=σ .v
(* Matrizen sind Listen von Listen, . liefert das Matrixprodukt *)

Über den Classroom Assistant (->"Calculator"->"Advanced") kann man die Matrizen auch direkt in herkömmlicher Form eingeben. Die Umwandlung der Ausgabe in herkömmliche Form erfolgt mit "Traditional Form":

TraditionalForm[σ]
(* Ausgabe in herkömmlicher Form über Menue "Cell -> Convert to -> Traditional Form" oder via Classroom Assistant oder Umwandlung mit diesem Befehl *)

σ[[1,3]]    (* Zugriff auf Einträge der Matrix *)

σ[[All,3]]    (* Dritte Spalte der Matrix *)

Im Gegensatz zu herkömmlichen Matrizen können die Teillisten einer Liste von Listen auch unterschiedlich groß sein. Mit "Table" kann man Listen, Felder und Matrizen effizient erstellen:

tab=Table[i^j,{i,2,5},{j,i,1,-1}]      (* erstellt eine Tabelle (Liste von Listen) der Werte (i^j), wobei i von 2 bis 5, und j von i bis 1 in Schritten der Größe -1 läuft *)

tab^2    (* quadriert jeden einzelnen Eintrag *)

Flatten[tab]    (* Fasst die Teillisten der höchsten Ebene zu einer Liste zusammen *)

Symbolische Ausdrücke

p=(z+1)^5   (* Da z noch kein Wert zugewiesen wurde, wird das Polynom als symbolischer Ausdruck in der Variablen gespeichert *)

Expand[p]  (* Wir können den Ausdruck nun z.B. ausmutiplizieren ... *)

p^2       (* quadrieren ... *)

D[p,z]       (* ableiten ... *)

Plot[p,{z,-2,2}]       (* plotten ... *)

z=123455676; p       (* z einen exakten Wert zuweisen - dadurch wird auch p in eine exakte Zahl umgewandelt *)

z=.; p     (* die Wertzuweisung wieder entfernen. *)

u=v=y=.   (* löschen einiger oben definierter Variablen *)

In Mathematica sind weitgehende Rechenoperationen mit symbolischen Ausdrücken möglich - dadurch lassen sich viele mathematische Gedankengänge sehr transparent übertragen. Oft ist es vorteilhaft, zunächst möglichst weit symbolisch zu rechnen, und erst anschließend numerisch auszuwerten. Ähnlich wie in der Mathematik können Variablen in Mathematica Werte in allen möglichen Mengen annehmen.

Plots

Auch ein Plot kann der Wert einer Variable sein:

p1=Plot[Cos[x],{x,-2 Pi,2 Pi}]; p2=Plot[Sin[x],{x,0,10}] ;    (* Plots werden gespeichert, aber wegen des Semikolons noch nicht ausgegeben *)p3=ListPlot[{{0,0},{Pi/2,1},{Pi,0},{3 Pi /2,-1},{2 Pi,0}}, Filling->Axis];    (* p3 plottet die Liste der angegebenen Punkte im (ℝ^2) mit Strichen zur Achse *)

Show[p1,p2,p3]      (* gemeinsame Ausgabe in einer Grafik *)

Expand[(1+p1)^2  +p2]     (* Nun kann man sogar formal mit Plots rechnen *)

Funktionen

Alle Befehle in Mathematica sind Funktionen. Zum Beispiel ist 2+2 nur eine Abkürzung für die Funktionsauswertung

Plus[2,2]

Funktionen können beliebig viele Argumente von verschiedenen Datentypen haben, zusätzlich kann man bei vielen Funktionen noch Optionen hinzufügen, z.B. die Option "Filling->Axis" bei der ListPlot Funktion von oben. Die Argumente werden immer in eckigen Klammern und durch Kommas getrennt angegeben. Zum Beispiel:

Sum[1/i^4, {i,1,∞}]     (* Zwei Argumente - das erste ist ein formaler Ausdruck/Funktion, das zweite eine Liste aus Variable und zwei Zahlen *)

Interne Mathematica Funktionen

Eingebaute Mathematica Funktionen beginnen immer mit einem Großbuchstaben. Eine komplette gut strukturierte Übersicht über alle vorhandenen Funktionen liefert das Documentation Center, daß im Menue unter Help zugänglich ist.

Selbstdefinierte Funktionen

Neben den vorhandenen kann man eigene Funktionen analog zu folgendem Beispiel definieren:

f[x_,y_]:=Cos[x+Sqrt[y]]

Plot3D[f[x,y],{x,-3  Pi,3  Pi},{y,0,(3 Pi)^2}]

Beachte:

Mit "?f" wird die aktuelle Definition der Funktion f angezeigt:

?f

Mit "Clear[f]" kann man die Definition löschen:

Clear[f]; ?f

Reine Funktionen

Wie in der Mathematik auch, kann man eine Funktion in Mathematica auch direkt angeben, ohne Namen für die Argumente zu verwenden. Das erste Argument wird dann durch den Platzhalter "#" ersetzt, das zweite durch "#2" etc. Die Funktion wird mit "&" abgeschlossen. Der folgende Befehl liefert zum Beispiel eine Tabelle der Funktionswerte von 1 + (i^2)+(j^3) für i von 1 bis 5 und j von 1 bis 4:

wertetabelle=Array[1+#^2+#2^3&,{5,4}]   (* 1+#^2+#2^3& steht für die Funktion (i,j) ↦ 1+(i^2)+(j^3) *)

ListPlot3D[wertetabelle, Mesh->All]    (* 3D Plot der linear interpolierten diskreten Funktionswerte *)

Ersetzungsregeln

Anstatt Funktionen voranzustellen, kann man sie auch mit "//" hintenanfügen:

Pi //N       (* ist gleichbedeutend zu N[Pi] *)

Mit "/." kann man Teile von Ausdrücken oder auch ganze Funktionen ersetzen:

1+f[x]+f[y] /.x->3

x=. (* Zuweisung wieder entfernen *)

1+f[x]+f[y] /.f[x]->y

1+f[r+s^2]+f[r s]  /. f[t_]->Cos[t]

Clear[f]

Manipulate

Eine zum Experimentieren mit mathematischen Modellen extrem nützliche eingebaute Funktion ist "Manipulate". Diese erzeugt ein interaktives Ausgabefeld, in dem man mit Hilfe von Reglern oder Buttons angegebene Parameter (Variablen) verändern kann:

plot[α_,β_]:=Plot3D[Cos[α x+Sqrt[β y]],{x,-3  Pi,3  Pi},{y,0,(3 Pi)^2}]

Manipulate[plot[α,β],{{α,1},0,5},{{β,1},0,5}]    (* α und β sind variierbar zwischen 0 und 5 mit Anfangswert 1 *)

Vergleiche und bedingte Zuweisungen

Mit den Funtionen "If" und "Which" kann man analog zu anderen Programmiersprachen den Ausgabewert vom Wahrheitswert eines Vergleichs abhängig machen:

abs[x_]:=If[x≥0,x,-x] ; (* Definition des Absolutbetrags, =x falls x≥0, =-x sonst *)
Plot[abs[x],{x,-5,5}]

sgn[x_]:=Which[x<0,-1,x==0, 0,x>0,1] ; (* eine mögliche Definition des Signums, =-1 falls x<0, =0 falls x=0, =1 falls x>0 *)
Plot[sgn[x],{x,-5,5}]

Integrate[Exp[-c x^2],{x,-∞,∞}]   (* Das Integral existiert nur für Re[c]>0, daher ist die Ausgabe ein konditioneller Ausdruck *)

Die Notation für Vergleichs- und logische Operationen ist ähnlich wie in C:

x==y   (* gleich *);
x!=y (* ungleich *);
x<=y (* kleiner oder gleich *);
x==y==z (* alle gleich *);
x>y >z  (* streng monoton fallend *);
x<3&&y<7  (* und *);
x<3||y<7  (* oder *);
!(x<3&&y<7)  (* Negation *);
ausdruck1===ausdruck2  (* testen ob zwei Ausdrücke identisch sind *);

Logische Daten können in Mathematica die Werte True, False oder nicht definiert haben:

3>5

3 >a

Programme

Die Definition einer Funktion oder einer Variablen kann über eine Abfolge von Funktionen/Befehlen erfolgen. Auch rekursive Definitionen sind möglich.

fak[n_]:=n fak[n-1];fak[1]=1   (* eine mögliche rekursive Definition von n! Die nachträgliche Festlegung von f[1] bewirkt, daß die Funktion an dieser Stelle abweichend von der anderen Vorschrift definiert wird *)

fak[5]

Alternativ hätten wir genau dieselbe Funktionsdefinition auch wie folgt angeben können:

fak[n_]:=If[n==1,1,n fak[n-1]]; fak[173]

Schleifen

Für Schleifen stehen die Funktionen "Do", "While" und "For" zur Verfügung:

Do[Print[n],{n,-3,5,2}]  (* n läuft von -3 bis 5 in Schritten der Größe 2 *)

z=a;Do[z*=z+i,{i,3}]; z    (* i läuft von 1 bis 3, z*=z+i steht wie in C für z=z(z+i) *)

t=x;Do[t=1/(1+t),{5}];t    (* Die Schleife wird 5 mal durchlaufen *)

t=z=.

n=1;While[n<4,Print[n];n++]  (* durchläuft Schleife solange Bedingung erfüllt ist - der Schritt, bei dem die Bedingung erstmals falsch ist, wird NICHT mehr ausgeführt ! *)

For[n=1,n<4,n++,Print[n]]    (* dasselbe mit "For" statt "While"  *)

For[i = 1; t = x, i^2 < 10, i++, t = t^2 + i; Print[t]]  (* Kommas trennen die Argumente der Funktion "For", Semikolons trennen die einzelnen Schritte einer Befehlsfolge - anders als in C ! *)

Iterative Anwendung von Funktionen

Neben diesen üblichen Schleifenkonstruktionen bietet Mathematica sehr effiziente Befehle, die es erlauben, Funktionen wiederholt anzuwenden:

Nest[f,x,4]   (* f wird 4 mal hintereinander angewandt, x ist der Anfangswert *)

g[x_]:=Nest[(1+#)^2&,x,3]     (* Die Funktion x ↦ (((1+x))^2) wird 3 mal angewandt *)

g[x]

Clear[g]

Mit NestList erhält man die Liste aller Iterationsschritte:

NestList[(1+#)^2&,x,3]

Fold und FoldList sind Erweiterungen von Nest und NestList, bei denen in jedem Iterationsschritt noch ein zusätzliches Argument angegeben wird:

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

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

Die Nest und Fold Funktionen ermöglichen es oft, mathematische Modelle sehr einfach umzusetzen - hier nur einige erste Beispiele:

NestList[2 #&, 1, 10]  (* Zweierpotenzen *)

n=.; NestList[D[#,x]&,x^n,5]     (* Sukzessive Ableitungen *)

NestList[StringReplace[#,{"A"->"BA","B"->"AB"}]&,"A",5]

randomwalk[n_]:=NestList[#+RandomChoice[{-1,1}]&,0,n]  (* Kapitalentwicklung beim Münzwurfspiel mit Einsatz 1 in jeder Runde *)

randomwalk[20]

ListLinePlot[%]

f[x_,einsatz_]:=x+einsatz * RandomChoice[{-1,1}] (* Kapitalentwicklung in einem Schritt des Münzwurfspiels bei variablem Einsatz *)

zweierpotenzen=2^Range[10]       (* Range[n] erzeugt Liste {1,2,...,n} *)

FoldList[f,0,zweierpotenzen](* Kapitalentwicklung beim Münzwurfspiel mit Verdoppeln des Einsatzes in jeder Runde *)

ListLinePlot[%]

Clear[f]

Die Funktionen "NestWhile" und NestWhileList" führen eine Iteration durch solange eine Bedingung erfüllt ist.

NestWhileList[#/2&,123456,EvenQ]  (* Division durch 2 solange das Resultat gerade ist *)

Module

Bei der Entwicklung von Programmen mit Mathematica kann man zunächst die Schritte eines Unterprogramms einzeln nacheinander eingeben und durchführen, und so direkt kontrollieren, ob alle Schritte richtig funktionieren. Anschließend kann man dann Unterprogramme zu Modulen zusammenfassen, in denen die nur im Unterprogramm benötigten Variablen lokalisiert werden, und eine Funktion definieren, die das entsprechende Modul durchführt:

Mit "Module[{x,y=7,z,...}, ....]" erzeugt man ein Modul mit lokalen Variablen x,y,z,..., denen ggf. Anfangswerte (z.B. hier y=7) zugewiesen werden können. Hier sind zwei Beispiele:

ggt[m0_,n0_]:=
Module[{m=m0,n=n0},
               While[n≠0,{m,n}={n,Mod[m,n]}]; m    ]                          
 (* Euklidischer Algorithmus : 
Die lokalen Variablen sind m und n, Anfangswerte sind m0 und n0,    ausgegeben wird der finale Wert von m nach Beendigung der While Schleife. *)

ggt [62374257456,24543565321012]

fib[n_]:=
Module[{f},
f[i_]:=f[i-1]+f[i-2]; f[1]=f[2]=1;
f[n]
]                             
(* Fibonaccizahlen : lokale Variable ist die FUNKTION f ! *)

Table[fib[n],{n,1,20}]

Nach Beendigung des Moduls ist die lokale Funktion f nicht mehr definiert:

?f

Pseudozufallszahlen

Mit den Funktionen "RandomInteger", "RandomReal", "RandomChoice" werden Pseudozufallszahlen mithilfe eines Zufallszahlengenerators erzeugt:

RandomInteger[{1,6}]   (* Zufallszahl aus {1,2,3,4,5,6} *)

RandomReal[0.1,20]      (* 20 reelle Zufallszahlen aus [0,0.1] *)

RandomReal[WorkingPrecision -> 200]  (* Zufallszahl aus [0,1] mit 200 Nachkommastellen Genauigkeit *)

ArrayPlot[RandomInteger[1, {20, 40}]]   (* Ein 20\[Cross]40 Feld aus Zufallszahlen aus {0,1} *)

ArrayPlot[RandomChoice[{Red, Green, Blue}, {20, 40}]]

ListLinePlot[Accumulate[RandomChoice[{-1, 1}, 50]]]    (* Random walk *)

Zufallszahlengeneratoren und Startwerte

Mathematica 7.0 verwendet kanonisch einen Generator von Pseudozufallszahlen, der auf einen zellulären Automaten basiert. Der Startwert (seed) des Zufallszahlengenerators hängt u.a. von der genauen Uhrzeit ab - man erhält daher bei jedem Durchlauf des Programms andere Zufallszahlen. Mithilfe von "SeedRandom" kann man  andere Zufallszahlengeneratoren verwenden, und den Startwert festlegen. Auf diese Weise erhält man reproduzierbare Pseudozufallszahlen:

RandomReal[1,5]      (* 5 Zufallszahlen aus [0,1] *)

RandomReal[1,5]         (* erneutes Aufrufen liefert eine andere Zufallszahl *)

SeedRandom[1];RandomReal[1,5]    (* Setzen des Startwertes des Generators auf 1 *)

SeedRandom[1];RandomReal[1,5]    (* Setzen wir den Startwert wieder auf 1, dann erhalten wir dieselbe Folge von Zufallszahlen *)

lcdata = BlockRandom[SeedRandom[1, Method -> {"Congruential", "Multiplier" -> 11, "Increment" -> 0, "Modulus" -> 63}]; RandomReal[1, 400]];
(* Erzeugen von 400 Zufallszahlen mit einem linearen Kongruenzgenerator mit 1 als Startwert. "BlockRandom" lokalisiert die Verwendung des Kongruenzgenerators und des Saatwerts, d.h. außerhalb von BlockRandom werden Zufallszahlen wieder wie üblich erzeugt *)

ListPlot[lcdata]     (* Dieser Generator hat eine sehr kleine Periode, und ist daher kein guter Zufallszahlengenerator : *)

cadata=RandomReal[1,400]; ListPlot[cadata]  (* bei Verwenden des zellulären Automaten als Generator ergibt sich dagegen folgendes Bild: *)

Mehr Informationen zu den verschiedenen in Mathematica verfügbaren Zufallszahlengeneratoren, und zur möglichen Implementierung selbstentwickelter Zufallszahlenzahlengeneratoren findet man imTutorial "Random Number Generation" im Mathematica Documentation Center.

Wahrscheinlichkeitsverteilungen

Für die wichtigsten Wahrscheinlichkeitsverteilungen gibt es Mathematica Routinen zur Erzeugung von Pseudo-Zufallsstichproben, sowie zur Berechnung der Dichten/Massenfunktionen (PDF=probability density function), Verteilungsfunktionen (CDF=cumulative distribution function), von Erwartungswerten, und von verschiedenen Kenngrößen.

ExpectedValue[#^4&,PoissonDistribution[μ]]     (* Erwartungswert E[(Z^4)] einer Poissonverteilten Zufallsvariable Z mit Parameter μ *)

Plot[{PDF[NormalDistribution[0,1],x],CDF[NormalDistribution[0,1],x]},{x,-4,4}]    (* Dichte und Verteilungsfunktion der Standardnormalverteilung *)

verteilung=BinomialDistribution[40,0.3]; (* Die zugrundeliegende Verteilung ist eine Binomialverteilung mit Parametern n=40 und p=0.3 *)  
sample=RandomInteger[verteilung,30000]
(* sample ist eine Liste aus 30000 (Pseudo-) zufälligen Stichproben von dieser Verteilung *)

hist[k_]:=Histogram[Take[sample,k],{-.5,30.5,1}];   (* Histogramm der ersten k Zufallszahlen *)

freq[k_]:=ListPlot[Table[{i,k PDF[verteilung,i]},{i,0,30}],Filling->Axis,FillingStyle->{Black,Thickness[0.01]}];  
(* Balkendiagramm der unter k Zufallszahlen im Durchschnitt zu erwartenden Häufigkeiten h(i)=k·p(i) der Werte i=0,1,...,30 *)

Show[hist[30000],freq[30000]]             
(* Häufigkeit der Werte 0,1,....,30 unter allen 30000 Zufallszahlen (blaues Histogramm) im Vergleich zu den im Schnitt zu erwartenden Häufigkeiten (schwarze Balken) *)

Manipulate[Show[hist[k],freq[k]], {k,1,1000}]
(* Empirische und theoretische Häufigkeit der Werte unter den ersten k Zufallszahlen, k variabel zwischen 1 und 1000 *)

Lösen von Gleichungen

Wenn exakte Lösungen für eine Gleichung gefunden werden können, erhält man diese mit "Solve" -andernfalls kann man mit "FindRoot" numerisch eine Lösung mit einem Iterationsverfahren suchen:

Solve[x^6==1,x]

FindRoot[x== 5 Cos[x],{x,1}] (* Numerische Lösung durch Iterationsverfahren mit Startwert 1 *)

FindRoot[x== 5 Cos[x],{x,-1}] (* Numerische Lösung durch Iterationsverfahren mit Startwert 1 *)

Plot[{x,5Cos[x]},{x,-3,3}]

Mit "DSolve" und "NDSolve" kann man Differentialgleichungen symbolisch und numerisch lösen.