Mathematica kompakt

Simone Szurmant, ADDITIVE GmbH
simone.szurmant@additive-net.de

Teil 1:   9:00-12:00 Uhr
- Wolfram Language Syntax
- Ressourcen für weiterführendes Selbststudium
- Interaktive Berechnungen mit Wow-Effekt

Teil 2: 13:00-15:00 Uhr
- Regeln und Muster 
- Pure functions und Map

Mathematica?

CellPrint[TextCell[Animate[
ParametricPlot[{trajectory[t,params0],trajectory[t,params1],trajectory[t,params2]},{t,0,time},PlotRange->{{0,540},{-45,110}},
PlotStyle->{Red,Green,Blue},ImageSize->800,
Epilog->{PointSize[.015],Red,Point[trajectory[time,params0]],Green,Point[trajectory[time,params1]],Blue,Point[trajectory[time,params2]]}],
{time,0.1,5.1},
Initialization:>{
MPH2=5280/60^2;
KPH2=1000/60^2;
trajectory[t_,{vel_,ang_,g_}]:={t vel Cos[ang],1/2 (-g t^2+2 t vel Sin[ang])};
trajectory[t_,{vel_,ang_,g_},"Horizontal"]:=t vel Cos[ang];
trajectory[t_,{vel_,ang_,g_},"Vertical"]:=1/2 (-g t^2+2 t vel Sin[ang]);
trajectory[t_,{vel_,ang_,g_,0|0.0}]:={t vel Cos[ang],1/2 (-g t^2+2 t vel Sin[ang])};
trajectory[t_,{vel_,ang_,g_,0|0.0},"Horizontal"]:=t vel Cos[ang];
trajectory[t_,{vel_,ang_,g_,0|0.0},"Vertical"]:=1/2 (-g t^2+2 t vel Sin[ang]);
trajectory[t_,{vel_,ang_,g_,k_}]:={(-Log[Sec[ang]/vel]+Log[k t+Sec[ang]/vel])/k,(Log[Cos[Sqrt[g] Sqrt[k] t-ArcTan[(Sqrt[k] vel Sin[ang])/Sqrt[g]]]]+1/2 Log[1+(k vel^2 Sin[ang]^2)/g])/k};
trajectory[t_,{vel_,ang_,g_,k_},"Horizontal"]:=(-Log[Sec[ang]/vel]+Log[k t+Sec[ang]/vel])/k;
trajectory[t_,{vel_,ang_,g_,k_},"Vertical"]:=(Log[Cos[Sqrt[g] Sqrt[k] t-ArcTan[(Sqrt[k] vel Sin[ang])/Sqrt[g]]]]+1/2 Log[1+(k vel^2 Sin[ang]^2)/g])/k;
params0={91.2 MPH2,38 °,32,0.0};
params1={91.2 MPH2,38 °,32,.001};
params2={91.2 MPH2,38 °,32,.002}
},SaveDefinitions->True],"Picture"]]

Mathematica ist mehr als nur ein Computeralgebrasystem: es eignet sich nicht nur für Berechnungen der unterschiedlichsten mathematischen Fragestellungen, sondern auch für interaktive Präsentationen, Datenanalyse, Simulationen und Visualisierungen - und vieles mehr.

ADDITIVE?

ADDITIVE ist seit über 25 Jahren Distributor für wissenschaftliche Software und verfügt über ein interdisziplinäres Team von Mitarbeitern mit überwiegend akademischer Ausbildung. 
Neben Lizenzberatung bieten wir umfangreichen Support, Schulungen und spezialisierte Lösungen für unsere Kunden. Bei uns steht der Anwender im Mittelpunkt!

Syntax und Oberfläche: Grundlage für die Arbeit mit Mathematica

Das Mathematica-Notebook

Das Mathematica-Notebook bildet die Schnittstelle zwischen dem Anwender und dem Mathematica-Kernel.

Grundzüge des Programms

Eingaben mit Mathematica werden mit Shift+Enter abgeschickt:

3+6

2+2

Funktionsnamen beginnen mit Großbuchstaben (Tipp:eigene Variablen klein schreiben) und sind in der Regel nicht abgekürzt. Die Argumente der Funktion werden in eckige Klammern gesetzt; die geschweiften Klammern bedeuten hier “für x von 0 bis 4 Pi”:

Plot[Sin[x],{x,0,4π}]

Funktionen können auch auf Listen angewandt werden - Listen werden durch geschweifte Klammern gebildet:

Plot[{Sin[x],Cos[x], Tan[x]},{x,0,4π}]

Im Regelfall zeigen geschweifte Klammern eine Liste an. Einige Funktionen, die einen Wertebereich erfordern, wie bspw. der Plot-Befehl, verwenden aber auch geschweifte Klammern.

In Mathematica ist alles ein “Symbol”, mit dem gerechnet werden kann:

Solve[x^2+ x+1==0,x]

Funktionen können verschachtelt werden:

Graphics3D[Sphere[RandomInteger[{-5,5},{10,3}]]]

Funktionen

Funktionen in Mathematica werden auf die folgende Weise definiert (Unterscheidung in direkte und verzögerte Zuweisung):

f[x_]:=(x^2)

g[x_] = (x^2)

Das x_ steht für einen beliebigen Ausdruck:

f[3.1415]

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

f[\[MathematicaIcon]]

Es ist auch möglich eine Fallunterscheidung z treffen, so dass die Funktion für unterschiedliche Übergabewerte andere Werte annimmt.

f[x_Integer]:=Sin[(1/(x-1))]
f[x_Real]:=N[Pi,50]

f[10]

f[10.1]

Der Opeartor /; steht für “Condition”. Er wird gefolgt von einem Boolschen Ausdruck. Bitte beachten Sie, dass das logische Gleich aus 2 Gleichheitszeichen besteht.

h[x_/;x==0]:=
h[x_/;x!=2]:="Prima"

h[1]

h[0]

Listen

Listen sind zentrale Konstrukte in Mathematica and  werden verwendet um Matrizen, Mengen, Folgen etc. darzustellen.

list={1,2,3,4,5,6,7,8,9,10}

Eine Liste kann aber auch anders, über eine Vorschrift definiert werden:

Table[(i^2),{i,1,100}]

Auf Listenelemente kann mit dem Befehl Part zugegriffen werden:

Part[list, 3]

Kurzschreibweise:

list[[3]]

Arbeiten mit Daten

Mathematica unterstützt den Import und Export vieler Dateiformate.....

...und Mathematica erlaubt den Zugriff auf Daten einer großen Anzahl von Fachgebieten.

$ImportFormats

$ExportFormats

Import["C:/Windows/Media/chimes.wav"]

data1= Import["C:/Windows/Media/chimes.wav", "Data"]

ListPlot[data1[[1]]]

Import["http://exampledata.wolfram.com/hailey.dem.gz",ColorFunction->"GreenBrownTerrain"]

Beim Export von Dateien müssen Pfad und Dateiformat als erstes Argument genannt werden.

testbild = Plot[Sin[x],{x,0,2Pi}]

Export["test.jpg", testbild]

Der folgende Befehl zeigt das Verzeichnis an, in welchem Ihre Dateien abgespeichert werden. Möchte man nicht dieses Standardverzeichnis verwenden, kann man statt des Dateinamens auch einen vollständigen Dateipfad angeben.

Directory[]

Das Verezeichnis kann angepasst werden:

SetDirectory["C:/"]

SetDirectory[NotebookDirectory[]]

Wo finde ich Informationen: Grundlagen für die Arbeit mit Mathematica

Documentation Center

Im Help-Menü kann das Documentation Center aufgerufen werden, welches auf vielfältige Art Hilfestellung leistet.

Über das Help-Menü kann das umfangreiche “Documentation Center” aufgerufen werden.
Alternativ: Markierung + F1

Solve

Eine Auswahlmenü (das während der Eingabe eines Befehls eingeblendet wird) hilft, wenn der vollständige Funktionsname unbekannt ist:

Pl

Sehr hilfreich bei der Arbeit mit Mathematica ist die Template-Hilfe (Aufruf über Pfeiltasten direkt bei der Eingabe oder später mit  Ctrl+⇧+K)

Plot

Paletten

Bei der Eingabe von mathematischen Ausdrücken hilft die “Basic Math”-Palette. Für das Schreiben von Texten gibt es die “Writing Assistant Palette”, für Präsentationen die “Sliding Show”-Palette usw.


Nach einer Eingabe erscheint eine “Suggestions Bar” unterhalb der letzen Ausgabe, die weiterführende Befehle anzeigt. Diese Hilfsmittel werden nicht in der Präsentationsansicht gezeigt.

Wolfram|Alpha Integration

Mit der Wolfram|Alpha-Integration in  Mathematica können Anweisungen auch umgangsprachlich eingegeben werden. Hierzu am Beginn einer Eingabezelle ein “=” eingeben:

Auch die vollständigen Wolfram|Alpha-Suchergebnisse lassen sich mit Mathematica abrufen (zwei “=” zu Beginn einer Zelle eingeben). Um Zwischenschritte anzuzeigen, klicken Sie auf “Step-by-Step-Solution”.

ChatGPT mit “Wolfram Superpowers”

Mathematica kann ab Version 13.3. in Notebooks large-language models (LLMs) verwenden.

‘ erzeugt eine neue Chat Input Cell

Benötigt wird Zugriif auf eines der untersützten LLMs oder der Wolfram Notebook Assistant + LLM Kit.
https://www.wolfram.com/notebook-assistant-llm-kit/

Neu ab Version 14: WolframGPT:  https://gpt.wolfram.com/

External Evaluate >

Durch Eingabe des Zeichens > zu Beginn einer Input-Zelle wird diese in eine ExternalEvaluate-Zelle umgeformt.

Beispiel mit Octave/Matlab

x = -2:0.25:2;
y = x;
[X,Y] = meshgrid(x);
F = X.*exp(-X.^2-Y.^2);
surf(X,Y,F)

Plot3D[x (E^(-(x^2)-(y^2))), {x,-2,2}, {y,-2,2}, ColorFunction->"Rainbow"]

Andere Möglichkeit:

ExternalEvaluate["Python",{"def f(x): return x**2","f(3)"}]

Übung: Finden Sie die Fehler!

Jede der folgenden Eingaben enthält einen Fehler. Der Sinn jeder Eingabe wird vor dem Beispiel angegeben. Identifizieren und korrigieren Sie die Fehler.

Verwenden Sie die Funktion Round , um die Zahl 2.3 zur nächsten ganzen Zahl zu runden.

Round (2.3)

Berechnen Sie das bestimmte Integral der Funktion x sin (x) für x von 0 bis 4.

Integrate[x sin[x],x,0,4]

Zeichnen Sie die Funktion x sin (x) für x zwischen 0 und 4.

Plot[xSin[x],{x,0,4}]

Übung: Documentation Center und Paletten verwenden

Öffnen Sie das Documentation Center. Schlagen Sie dort die Funktionen nach, um folgende Aufgaben lösen zu können:

Erweitern Sie (((1+x+y))^2), um 1+2x+(x^2)+2y+2x y+(y^(2 ))zu erhalten.

Erzeugen Sie eine Liste der ersten 40 Primzahlen

Öffnen Sie nun den Basic Math Assistant und lösen damit die folgenden Aufgaben:

Berechnen Sie das Integral von (x^2) sin (x)  für x von -4 π und 4 π.

Berechnen Sie die 5.te Wurzel aus e.

Wie führe ich einfache Berechungen aus: Grundlagen für die Arbeit mit Mathematica

Computeralgebra

Umformungen

Faktorisieren von Termen:

Factor[(x^4) (y^2)+2 (x^4) y z+(x^4) (z^2)+2 (x^3) (y^3)+2 (x^3) (y^2) z-2 (x^3) y (z^2)-2 (x^3) (z^3)+(x^2) (y^4)-2 (x^2) (y^3) z-6 (x^2) (y^2) (z^2)-2 (x^2) y (z^3)+(x^2) (z^4)-2 x (y^4) z-2 x (y^3) (z^2)+2 x (y^2) (z^3)+2 x y (z^4)+(y^4) (z^2)+2 (y^3) (z^3)+(y^2) (z^4)]

Vereinfachen von Ausdrücken:

Simplify[2Tan[x]/(1+Tan[x]^2)]

Vereinfachen von Ausdrücken unter bestimmten Annahmen:

Simplify[Cos[k Pi]^m,Element[k,Integers],Assumptions->Mod[m,2]==0]

Umformen auf einen gemeinsamen Nenner:

Together[(1/x)+(1/(x+1))+(1/(x+2))]

Lösen von Gleichungen

Der folgende Befehl löst ein lineares Gleichungssystem, das aus den Gleichungen x + 4y = 5 und 2x + 3y = 7 besteht.

LinearSolve[{{1,4},{2,3}},{5,7}]

sol=Solve[x^2+y^2==g&&x+2y==3,{x,y}]

{x,y}/.sol[[1]]

Integralberechnung

Eingabe über die Palette....

(∂_({x}))((Sin[x y])^3)

(∫_0^∞)(((∏_(k=0)^8)Sin[(x/(2 k+1))])/(x^9))\[DifferentialD]x

oder mithilfe der Mathematica-Befehle:

Integrate[((Sin[x])^4)((Cos[x])^3), x]

f[x_]:=x^5+6x^3

D[f[x],x]

f'[x]

f'[5]

f'''[-1]

Differentialgleichungen

Die wichtigste Funktion zum Lösen von Differentialgleichungen lautet DSolve.

loesungDGL=DSolve[{y'[x]+y[x]==a Sin[x],y[0]==0},y[x],x]

eineLoesung=y[x]/.loesungDGL/. a->3

Plot[eineLoesung, {x,-0.1,0.1}]

Plotten einer stückweise definierten Differentialgleichung (man beachte: wir erhalten eine “Function” als Rückgabewert, da wir nach y und nicht nach y[x] fragen.)

Numerische Berechnungen

Genauigkeit des Ergebnisses

Mathematica hingegen kann Zahlen theoretisch unbegrenzter Länge verarbeiten. Verwendet werden State-of-the-Art-Algorithmen sowie eigens von Wolfram Research entwickelte Verfahren.

Um ein approximiertes numerisches Ergebnis zu erhalten, gibt es in Mathematica eine eigene Funktion N.

N[(24262618023850825018385924805218290358209582934058023852/6284908609428690423869024869024869024890682108649028609286),100]

//N liefert ein numerisches Ergebnis und ist eine andere Schreibweise für N[x].

2^100//N

Gibt man eine ganze Zahl ein, so geht Mathematica davon aus, dass diese exakt ist. Bei Eingabe einer reellen Zahl (wie etwa 4.5) mit einem Dezimalpunkt wird angenommen, dass diese nur nur für eine begrenzte Anzahl von Dezimalstellen genau ist.

Beispiel: Reele Zahlen und Maschinengenauigkeit

NestList[11*#-1&, 0.1, 30]

Bei der Anwendung numerischer Funktionen wie NDSolve und NMinimize, verwendet Mathematica standardmässig Maschinengenauigkeit. Mit der Option WorkingPrecision->n kann die Rechengenauigkeit angepasst werden.

Beispiel: Numerische Integration mit Maschinengenauigkeit

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

Beispiel: Numerische Integration mit 30-stelliger Working Precision

NIntegrate[Sin[Sin[x]],{x,0,1},WorkingPrecision->30]

Das Setzen der WorkingPrecision legt einen Wert für die Genauigkeit der internen Berechnung fest. Im Laufe der Berechnungen können Genauigkeisstellen verlorengehen.

Um die Genauigkeit anzugeben, die das Ergebnis schlussendlich haben woll, verwendet man die Optionen PrecisionGoal bzw.  AccuracyGoal. Zu beachten ist, dass hohe Werte für diese Optionen die Rechenzeit deutlich verlängern können.

Beispiel: Resultat einer Numerischen Integration mit 25-stelliger Genauigkeit.

NIntegrate[Sin[Sin[x]],{x,0,1},WorkingPrecision->30,PrecisionGoal->25]

50-stellige Ergebnisgenauigkeit kann nicht mit 30-stelliger Rechengenauigkeit errreicht werden.

NIntegrate[Sin[Sin[x]],{x,0,1},WorkingPrecision->30,PrecisionGoal->50, MaxRecursion->20]

Numerisches Lösen von Gleichungen

Viele Funktionen, die i.A. ein symbolisches Ergebnis liefern, besitzen ein numerisches “Äquivalent”, z.B. Solve und NSolve, Sum und NSum...

NSolve[x y==z^2-x&&x y z==2&&x^2+y^2+z^2==5,{x,y,z},Reals]

NSolve[Gamma[x]-Log[x]==I/2&&Abs[x-2]<3/2,x]

NMinimize[{2x+3y,x+5y>=10,x-y>=2,x>=1},{x,y}]

Fitfunktionen

Zunächst benötigen wir einige Daten. Der folgende Befehl erzeugt eine Tabelle von Zahlen der Funktion  Exp[(x/5)] für x-Werte von 0 bis 20:

daten =Table[N[Exp[n/5]],{n,0,20}]

Mit dem Befehl Fit wird ein Fit ausgeführt:

fit=Fit[daten, {1,x,x^2, x^3}, x]

Nun plotten wir unsere Daten gegen den Fit:

Show[ListPlot[daten, PlotStyle->Red], Plot[{fit}, {x, 0, 21}]]

Der Befehl Interpolation liefert eine Funktionsobjekt zurück.

f=Interpolation[RandomReal[1,20]]

Plot[f[x],{x,1,20}]

Numerisches Lösen einer partiellen DGL

Gegeben: Region, Wärmeleitungsgleichung und Randbedingungen:

Ω=ImplicitRegion[!((x-5)^2+(y-5)^2≤3^2),{{x,0,5},{y,0,10}}];

RegionPlot[Ω]

op=(∂_t)u[t,x,y]-(InactiveLaplacian[u[t,x,y], {x,y}, Inactive])-20;

Die Randbedingungen: hier Dirichlet- und Neumann-Randbedingungen für elliptische Probleme:

(Subscript[Γ, D])=DirichletCondition[u[t,x,y]==0,x==0&&8≤y≤10];

(Subscript[Γ, N])=NeumannValue[-2*u[t,x,y],(-5+x)^2+(-5+y)^2== 9];

Lösen der PDE und speichern der Lösung:

uifHeat=NDSolveValue[{op==(Subscript[Γ, N]),(Subscript[Γ, D]),u[0,x,y]==0},u,{t,0,100},{x,y}∈Ω];

Animation der Lösung:

Animate[Plot3D[uifHeat[t,x,y],{x,y}∈uifHeat["ElementMesh"],PlotRange->{0,160}, ColorFunction->"SunsetColors"],{{t,10},0,40,2}, AnimationRunning->False,SaveDefinitions->True]

Wie zeichne ich und präsentiere Ergebnisse: Grundlagen für die Arbeit mit Mathematica

Zeichnen von Funktionen und Daten

Plot[((Sin[x])/x),{x,-10,10}]

Plot[{((Sin[x])/x),Sin[x]},{x,-2π,2π}]

Plot3D[Sin[x] Sin[y],{x,0,2π},{y,0,2π}]

data=Table[RandomReal[NormalDistribution[RandomReal[{-2,2}],RandomReal[{0.5,2}]], 100], {i,10}];

BoxWhiskerChart[data]

Viele verschiedene Optionen ermöglichen es dem Benutzer, den Plot an eigene Bedürfnisse anzupassen, bspw. Transparenz, Farbe, etc.

ParametricPlot3D[{(1.16^v) Cos[v] (1+Cos[u]),-(1.16^v) Sin[v] (1+Cos[u]),-2 (1.16^v) (1+Sin[u])},{u,0,2 π},{v,-15,6},PlotRange->All,Mesh->None,Boxed->False,Axes->False,PlotStyle->{Orange,Opacity[0.75],Specularity[White,20]},MaxRecursion->3,Background->Black,RotationAction->"Clip"]

Beispiel Image Processing: Wege durchs Labyrinth

Thinning[]

Pruning[%, ∞]

Beispiel Filter: Rauschunterdrückung

TotalVariationFilter[,0.35,Method->"Poisson"]

Dynamische Modelle

Das Grundprinzip, wie dynamische Elemente in Mathematica erzeugt werden, ist sehr einfach:

Plot[Sin[x],{x,0,2Pi}]

Manipulate[Plot[Sin[a x], {x, 0, 2Pi}], {a, 1, 10}]

Ein Beispiel mit mehreren Veränderlichen:

Manipulate[Plot[a1 Sin[n1 (x+p1)]+a2 Sin[n2 (x+p2)],{x,0,2 Pi},PlotRange->2],{n1,1,20},{a1,0,1},{p1,0,2 Pi},{n2,1,20},{a2,0,1},{p2,0,2 Pi}]

Neben der Möglichkeit eigene Applikationen zu erstellen können Sie auch auf die Demostrations-Datenbank von Wolfram zugreifen. Über 10.000 kleiner interaktiver Anwendungen können Sie dort abrufen.

Testen Sie eines der Beispiele auf demonstrations.wolfram.com; z.B. Learning Newton's Method.

Bei allen Demonstrations kann auch das entsprechende Notebook heruntergeladen und den eigenen Bedürfnissen angepasst werden.

Unter dem Begriff Deployment versteht Wolfram Research die Möglichkeit, kleine Anwendungen wie obige weiterzugeben - zum Beispiel an Personen ohne Mathematica.
1. Schritt: Speichern des Mathematica-Notebooks als CDF-Datei
2. Schritt: Nutzern ohne Mathematica die .cdf-Datei zur Verfügung stellen. Der kostenfreie CDF-Player kann von der Wolfram Webseite heruntergeladen werden.

Alle mit dem Befehl Manipulate interaktiv gestalteten Funktionen können innerhalb des CDF-Players bedient werden.

Hilfe und Selbststudium: Weiterführende Hinweise

Lernhilfen für Mathematica    https://www.wolfram.com/wolfram-u/

Einführungshandbuch für Mathematica von Stephen Wolfram: https://www.wolfram.com/language/elementary-introduction/3rd-ed/?source=nav

ADDITIVE Schulungen

MouseOver Forum zum Austausch mit anderen Lehrenden

ADDITIVE-Mathematica Informationen zu Mathematica

Wolfram|Alpha for Educators

Regeln und Muster: Regelbasiertes Programmieren in Mathematica

{0.0001, -12, -10^-7}/. x_ /; Abs[x] <10^-3 -> small

Was ist ein Muster?

Muster beschreiben einen Ausdruck. 
Ausdrücke auf der linken Seite einer Regel (⟶) oder einer Zuweisung (=) enthalten oft ein Muster.

Beispiel: das Muster n_ in der folgenden Zuweisung von f[n_] bezieht sich auf f[anything].

f[n_]:=(n/(n+1))

f[5]

f[]

f[a,b]

f[{a,b}]

Clear[f]

Kleiner Exkurs: Zuweisungen und Definitionen: Direkte und verzögerte Zuweisungen

Zuweisungen können direkt oder verzögert sein.

Bei einer direkten Zuweisung (lhs=rhs) wird die rechte Seite der Zuweisung ausgewertet, bevor die Definition gemacht wird.

In einer verzögerten Zuweisung (lhs:=rhs) wird die rechte Seite der Zuweisung solange nicht ausgewertet, bis die Definition angewendet wird.

Beispielsweise sind hier zwei Zuweisungen, die mit Hilfe einer Standardnormalverteilung eine zufällige Zahl zwischen 0 und 1 erzeugen. Der einzige Unterschied zwischen den beiden Zuweisungen ist, dass rand1 eine direkte Zuweisung und rand2 eine verzögerte Zuweisung verwendet.

rand1=RandomReal[]

rand2:=RandomReal[]

Bei einer verzögerten Zuweisung wird die Auswertung auf der rechten Seite der Definition aufgeschoben, bis die Definition verwendet wird. Bei den direkten Zuweisungen wird jedoch die rechte Seite der Zuweisung zu dem Zeitpunkt ausgewertet, zu dem die Definition gemacht wird. Dieser Wert wird dann dem Symbol rand1 zugewiesen.

Table[rand1,{3}]

Table[rand2,{3}]

Clear[rand1,rand2,f,x]

Syntax von Mustern

({{"Muster", Name, Bedeutung}, {"_", "Blank, "beliebiger Ausdruck"}, {"x_",  , benannter Ausdruck}, {"__", BlankSequence, beliebiger zusammengesetzter Ausdruck }, {"___", "BlankNullSequence", "beliebiger zusammengesetzter oder kein Ausdruck"}})

Clear[f,g,h]

f[x_]:= Length[{x}]

{f[x],f[x,y,z], f[]}

g[x__]:= Length[{x}]

{g[x],g[x,y,z], g[]}

h[x___]:= Length[{x}]

{h[x],h[x,y,z], h[]}

Clear[f,g,h]

Bedingungen an Muster

({{"Muster", "Ausdrücke, die Folgendes abgleichen", "Beispiel"}, {"_", "beliebig", "x, \"a string\", 45"}, {"_Real", "Ausdruck mit Kopf \!\(\*StyleBox[\"\\\"Real\\\"\", \"MR\", Rule[StripOnInput, False]]\)", "1.3528"}, {"_?Negative", "Ausdruck, der den Test auf \!\(\*StyleBox[\"\\\"Negative\\\"\", \"MR\",StripOnInput->False]\) besteht", "-129"}, {"{p_,  q_}", "Liste von zwei Ausdrücken", "{Bob,-0.398}"}})

"Kopf" eines Ausdrucks

Head[3]

Head[3.0]

Head[x*y]

Muster zur Fallunterscheidung bei der Funktionsdefinition

g[x_Integer]:=Sin[(1/(x-1))]
g[x_Real]:=N[Pi,50]
g[x_String]:=

Zum Testen der Definitionen wird eine Gegenprobe ausgeführt:

g[10.1]
g["test"]
g[1]

Für g=1 tritt ein Sonderfall ein. Daher ergänzen wir unsere Funktionsdefinition mit einer Bedingung mit der Funktion Condition - hier mit Kürzel /;

g[x_Integer/; x==1] := Print["Nicht definiert für x = 1"]

g[1]

Operator ? (PatternTest) wird auf eine Eigenschaftsfunktion und nicht auf einen Boolschen Ausdruck angewendet.

Kleiner1[x_]:= x<1

f1[x_?Kleiner1]:= "Hallo"
f1[x_]:= "World"

f1[3]
f1[-3]

f2[x_/;Kleiner1[x]]:= "Hallo"
f2[x_]:= "World"

f2[3]
f2[-3]

Muster am Beispiel von Cases

In diesem Abschnitt verwenden wir Cases,um all die Elemente aus einer Liste zurückzugeben,die einem Muster entsprechen.

?Cases

Das Muster _ (der Unterstrich) entspricht jedem Ausdruck.

Cases[{2,g[z],π,3.4,-5,{a,b}},_]

Abgleichen des Kopfs: Das Muster _Real entspricht allen Zahlen mit dem Kopf Real.

Cases[{2,g[z],π,3.4,-5,{a,b}},_Real]

Abgleichen mit Eigenschaften

Cases[{2,g[z],π,3.4,-5,{a,b}},_?Negative]

Abgleichen eines Paares: Das Muster {_,_} entspricht allen Listen, die zwei beliebige Ausdrücke enthalten.

Cases[{2,g[z],π,3.4,-5,{a,b}},{_,_}]

Weitere Funktionen mit Mustern

Hier sind einige künstliche Daten, um damit zu arbeiten—eine Liste von 25 zufälligen ganzen Zahlen zwischen -10 und 10.

data=RandomInteger[{-10,10},25]

Dies gibt all die Elemente in der Liste data zurück, die zwischen -3 und 3 liegen.

Cases[data,p_/;-3≤p≤3]

Alternativ können Sie die Elemente ausgeben, die nicht dem Muster entsprechen.

DeleteCases[data,p_/;-3≤p≤3]

Andere Funktionen verwenden die gleiche Syntax wie Cases, geben aber die Anzahl der Elemente zurück, die dem Muster entsprechen oder den Positionen dieser Elemente, die dem Muster entsprechen.

Count[data,p_/;-3≤p≤3]

Position[data,p_/;-3≤p≤3]

Was ist eine Regel?

Regeln ersetzen bestimmte Ausdrücke durch andere Ausdrücke.

Grundlegende Syntax:  x -> y

Rule[x,y]

Anwendungsbeispiel für eine Regel:

ReplaceAll[x + 5y + z, x->b]

Kurzschreibweise für den Befehl ReplaceAll:

x + 5y + z /. x->b

Wiederholte Anwendung von ReplaceAll:

x + 5y + z /. x->y /. y->2

Rückgaben mancher Funktionen wie z.B. Solve erfolgen in Regelschreibweise:

soln=AsymptoticSolve[(E^y)-Cos[x y]+x==0,{y,0},{x,0,7}]

Einfaches Beispiel

Gegeben sei eine 10x2-Matrix; interpretiert als XY-Koordinaten und als Linie gezeichnet:

vec={{0,0},{1,1},{2,0},{3,2},{4,0},{5,2},{6,1},{7,3},{8,0},{9,2},{10,0}}

Graphics[Line[vec],Axes->True]

vec2 =vec/. {p_, q_} -> {q,p}

Graphics[Line[vec2],Axes->True]

Beispiel mit mehreren Regeln

mat = {{5,3},{6,9}}

Nun wollen wir in dieser Matrix bestimmte Elemente ersetzen.

ergebnis =mat/.{5->α,3->β, 6->b,9->v}

MatrixForm[ergebnis]

Man kann die Ersetzungregel auch als verschachtelte Liste definieren. 
Das Ergebnis sind dann 2 Matrizen, die zu einer Liste von Ergebnissen zusammengesetzt werden.

ergebnis2 =mat/.{{5->α,3->β}, {6->b,9->v}}

MatrixForm[ergebnis2[[2]]]

Zusammenspiel Regeln und Muster

Bedingungen an Muster können auch in Regeln gestellt werden.
Hier die Einschränkung mit/; (Condition) in einer Regel:

{0.0001, -12, -10^-7}/. x_ /; Abs[x] <10^-3 -> small

Direkte vs verzögerte Regeln

Unterschied zwischen direkt und verzögert: 
bei einer direkten Regel wird der rechte Ausdruck bei Definition ausgewertet, bei einer verzögerten Regel erst bei der Anwendung:

{x,x,x}/. x-> RandomReal[]

Warum? RandomReal wird berechnet, fester Wert (“w”) zugeordnet; Ergebnis {w,w,w}

{x,x,x}/. x:> RandomReal[]

Ersetzung findet ohne Auswertung statt; ergibt {RandomReal[], RandomReal[] , RandomReal[]}

Analog: die direkte und verzögerte Zuweisung bei der Funktionsdefinition

f[x_]= RandomReal[];
g[x_]:= RandomReal[]

{f@x, f@x, f@x}

{g@x, g@x, g@x}

Replace, ReplaceAll und ReplaceRepeated

Achtung Unterschied: kein Muster ⟷ Muster

{6,-7,3,2,-1,-2, x}/.x->w

{6,-7,3,2,-1,-2, x}/.x_->w

{6,-7,3,2,-1,-2, x}/.x_Integer->w

{6,-7,3,2,-1,-2, x}/.x_/;x<0->w

Replace arbeitet nur auf einer festgelegten Ebene des Ausdrucks:

Replace[(2x+x y)^x, x-> 5]

ReplaceAll[(2x+x y)^x, x-> 5]

TreeForm[(2x+x y)^x]

Replace[(2x+x y)^x, x-> 5, {3}]

Replace und ReplaceAll wenden die Ersetzungsregeln nicht wiederholt an:

Replace[{f[f[x]],f[g[f[x]]]}, f[n_]->n]

ReplaceAll[{f[f[x]],f[g[f[x]]]}, f[n_]->n]

ReplaceRepeated[{f[f[x]],f[g[f[x]]]}, f[n_]->n]

Regeln als Funktionsrückgaben

Solve[x^5-x+11==0,x]

N[%]

NSolve[x^5-x+11==0,x]

soln=AsymptoticSolve[(E^y)-Cos[x y]+x==0,{y,0},{x,0,7}]

Wir können damit unsere numerische Lösung erhalten:

soln/.x->0.4

Plot[y/.soln,{x,-1,1}]

ℛ=Cylinder[{{1,2,3},{3,2,1}},1];

Minimize[z,{x,y,z}∈ℛ]

Graphics3D[{{Opacity[0.5],Green,ℛ},{Red,PointSize[Large],Point[{x,y,z}/.Last[%]]}}]

Pure functions und Map: Funktionales Programmieren in Mathematica

Do[Print[i], {i,0,3}]

For[i=0,i<4,i++,Print[i]]

n=0;While[n<4,Print[n];n++]

Map[Print,Range[3]];

Listen und Map

Map[f,list]

Anwendungsbeispiel:

Testwerte= {-Pi,2, E};

f[a_]:= NSolve[x^a + 2x+7 == 17, x, Reals]

loesung =Map[f, Testwerte]

Interpretation: für a= - Pi löst 0.49677... die Gleichung. Wie kommt man an den Wert:

ersteLoesung=x/.loesung[[1,1]]

(x^(-π))+ 2x+7 == 17/. x->ersteLoesung

Pure functions

Eine wichtige Kategorie von Funktionen in Mathematica sind die sog. Pure Functions:

Map[# + 3&,liste]

Integrate[1/(x^3-1),x]

Map[Integrate, {1/(x^3-1), 1/(x^4-1)}]

-> klappt nicht. Hierfür benötigen wir Pure Functions:

Map[Integrate[#, x]&, {1/(x^3-1), 1/(x^4-1)}]

#+2&[3]

# ist der Platzhalter, & das Zeichen für das Ende der Pure Function.

#1-#2&[a,b]

Es können auch mehrere Werte übergeben werden.

Kombination mit Map und NestList

In Kombination mit Map werden oft Pure Functions eingesetzt - insbesondere bei Funktionen, die nicht "Listable" sind.

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

Jetzt: Integrationswertebereiche bis 100, 1000, 10000

bereich={10, 100, 1000, 10000}

Befehl wie oben, # und & ergänzen

NIntegrate[Sin[x], {x,1,#}]& /@ bereich

Map[If[-1≤#≤1,((#)^2),#]&,{-2,.25,0,1}]

Select[data,-0.1<#<0.1&]

Rekursion mit NestList

f7[x_]:=x*11-2

NestList[f7, 0.200, 30]

NestList[#*11-2&, 0.200, 30]

Stufenspezifikation

Map[f, {a,b, c,d}]

Besondere Listenkonstrukte müssen berücksichtigt werden.

Map[f, {{a,b}, {c,d}}]

Map[f, {{a,b}, {c,d}}, 2]

Map[f, {{a,b}, {c,d}}, {2}]

Ohne Spezfikation des Level kann eine Lösung über die Anpassung der Listenstruktur erfolgen:

Flatten[{{a,b,c}, {d,e,f}}]

Map[f, Flatten[{{a,b,c}, {d,e,f}}]]

Da Map innerhalb von Listen angewendet wird und keine Informationen überschreibt (wie Apply), bleiben Strutkruen wie eine Summe erhalten.

Map[f,a+b+c]

Apply ersetzt den Kopf eines Ausdrucks - bei Anwendung auf diese Liste den Kopf “List”:

Apply[f, {a,b, c,d}]

...und hier den Kopf “Plus”:

Apply[f, a+b+c]

Bei vielen Listenkonstrukten ist dieses Verhalten gewünscht (auch auf den Level achten):

Apply[Plus,{{a,b},{c,d}}]

Apply[Plus,{{a,b},{c,d}},1]

Die Anzahl der @-Zeichen geben bei Apply den “Level” an.

Sqrt@{a,b}

Plus@@{a,b}

Plus@@{{a,b},{c,d}}

Plus@@@{{a,b},{c,d}}

Zum Weiterlesen im Wolfram Documentation Center:
Pure Functions

Hier können Sie mehr über die funktionale Programmierung in Mathematica lesen: 
Functional Programming im Documentation Center

Noch Fragen?

Fragen zu Lizenzformen, Testversionen, Funktionsumfang etc.: 
simone.szurmant@additive - net.de

Hilfestellung zu Installation, Applikationsentwicklung etc.: support@additive - net.de