Upload
duonganh
View
236
Download
0
Embed Size (px)
Citation preview
Einführung in Mathematica (6)
Programmieren mit Mathematica
Michael O. Distler, Computer in der Wissenschaft, SS 2010 (Vorlage von L. Tiator)
Voreinstellungen
� Grafik - Initialisierung
SetOptions@8Plot, ListPlot, ParametricPlot, Plot3D, Graphics<,BaseStyle ® 818, FontFamily ® "Times", Italic<D;
SetOptions@Plot, PlotStyle ® [email protected]<D;SetOptions@ListPlot, PlotStyle ® 8Red, [email protected]<D;
dünne Linien und Punkte :
SetOptions@8Plot, ListPlot, Graphics<,BaseStyle ® 8Medium, FontFamily ® "Times"<D;
SetOptions@Plot, PlotStyle ® [email protected]<D;SetOptions@ListPlot, PlotStyle ® 8Red, [email protected]<D;
andere mögliche Fonts :
BaseStyle ® 818, FontFamily ® "Helvetica"<BaseStyle ® 8Large, FontFamily ® "Helvetica", Italic, Bold<
� selbstdefinierte globale Funktionen
für selbstdefinierte Funktionen etc. eignet sich die Cell-Option : Cell Properties: Initialization Cell
solche Zellen können auch an beliebigen Stellen der Datei stehen und werden nach dem Laden der
Datei beim ersten Ausführen einer Zelle direkt gestartet
RootPlot@sol_, opts : OptionsPattern@ListPlotDD := Module@8<,CellPrint@ExpressionCell@N@solD, "Output"DD;ListPlot@Tooltip@8Re@ðD, Im@ðD<D & �� N@x �. solD, opts,
AspectRatio ® Automatic, PlotStyle ® 8Red, [email protected]<DD
ComplexNumberPlot@list_,opts : OptionsPattern@ListPlotDD := Module@8<,ListPlot@Tooltip@8Re@ðD, Im@ðD<D & �� N@listD, opts,
AspectRatio ® Automatic, PlotStyle ® 8Red, [email protected]<D D
Definition von Funktionen und Prozeduren
Prozeduren im herkömmlichen Sinne einer prozeduralen Sprache gibt es nicht.
Letztlich sind alle Definitionen gewöhnliche Regeln.
Die syntaktische Ähnlichkeit mit Prozeduren ist allerdings beabsichtigt.
� Typische Definition einer Funktion
f1@x_D := x2 + 1
f1@a + bD1 + Ha + bL2
� Typische Definition einer Prozedur mit dem Befehl: Module[...]
Polardiagramm@r_, 8phi_, phi0_, phi1_<D := Module@8x, y<,x = r Cos@phiD; y = r Sin@phiD;ParametricPlot@8x, y<,
8phi, phi0, phi1<, AspectRatio ® AutomaticDDPolardiagramm@1 + Sin@phiD, 8phi, 0, 2 Π<D
-1.0 -0.5 0.5 1.0
0.5
1.0
1.5
2.0
2 Mathematica_6.nb
Polardiagramm@1 + Sin@5 phiD, 8phi, 0, 2 Π<D
-1.5-1.0-0.5 0.5 1.0 1.5
-1.5
-1.0
-0.5
0.5
1.0
1.5
2.0
diese neue Funktion Polardiagramm tut das gleiche wie die Mathematica-Funktion PolarPlot
Bedingte Anweisungen
If[...] und Switch[...] sind ähnlich wie in C. Anstelle einer Kette von if..then..else..if..
kann man Which[...] verwenden.
func1@x_D := IfBx ¹ 0,1
x, ¥F
oder die sphärische Besselfunktion j0HxL
j0@x_D := IfBx ¹ 0,Sin@xD
x, 1F
Table@func1@xD, 8x, -2, 2<DTable@j0@xD, 8x, -2, 2<D9-
1
2, -1, ¥, 1,
1
2=
9Sin@2D2
, Sin@1D, 1, Sin@1D, Sin@2D2
=
Mathematica_6.nb 3
func2@n_D := Switch@n,0, f0@xD,1, f1@xD,_, def@xD D
mit Map[...] bzw. /@ kann man verschiedene Werte der Funktion berechnen:
func2 �� 8-1, n, m, 0, 1, 2, x<9def@xD, def@xD, def@xD, f0@xD, 1 + x2, def@xD, def@xD=
vorzeichen@x_D := Which@x > 0, 1, x == 0, 0, x < 0, -1Dvorzeichen �� 85.5, 0, a<81, 0, Which@a > 0, 1, a � 0, 0, a < 0, -1D<
Zum Auswählen aus einer Liste gibt es Select[...] und Cases[...].
Select@81, 2, 3, 4, 5, 6, 7, 8, 9<, PrimeQD82, 3, 5, 7<
oder z. B. die geraden und ungeraden Zahlen mit EvenQ und OddQ
Select@81, 2, 3, 4, 5, 6, 7, 8, 9<, EvenQD82, 4, 6, 8<
Cases@8f@1D, g@2D, f@sD, [email protected]<, f@_IntegerDD8f@1D<
Schleifen
For[...] ist wie in C. Oft genügt jedoch eine simple Do[...]-Schleife.
s = 0;
ForAi = 1, i £ 10, i++, s = s + i2E;s
385
4 Mathematica_6.nb
s = 0;
DoAs = s + i2, 8i, 1, 10<E;s
385
In vielen Fällen kann auch strukturierte Iteration verwendet werden.
z.B. Sum[f, {i, imin, imax}]
âi=1
10
i2
385
oder Product[f, {i, imin, imax}]
äi=1
5
i
120
� Beispiel: Energieniveaus in der QM im 1-dim. Potentialtopf
ListPlot@88-5, 0<, 8-2, 0<, 8-2, -800<, 82, -800<, 82, 0<, 85, 0<<,Joined ® True, PlotStyle ® 8Red, [email protected]`D<,AxesOrigin ® 8-5, 0<, AxesLabel ® 8"x", "Potential VHxL"<D
-4 -2 0 2 4x
-800
-600
-400
-200
Potential V HxL
Mit Stetigkeitsbedingungen der 1. und 2. Ableitung an den Rändern des Topfes findet man nach
einiger Rechnung 2 transzendente Gleichungen für symmetrische und antisymmetrische Lösungen
Cos(k x) und Sin(k x)
Mathematica_6.nb 5
� Suche nach Lösungen der transzendenten Gleichungen:
x tan(x) = r2 - x2 und x cot(x) = - r2 - x2
r = 7.244; U0 = 800 eV;
f1@x_D := r2 - x2 ;
g1@x_D := x Tan@xD;u1@x_D := -x Cot@xD;xs1 = 81., 4., 7.<; xs2 = 82., 5.<; En = 8<;Plot@8f1@xD, g1@xD, u1@xD<, 8x, 0, r<D
1 2 3 4 5 6 7
-10
10
20
Plot@8f1@xD, g1@xD, u1@xD<, 8x, 0, r<,PlotStyle ® 8Black, Red, Blue<, PlotRange ® 8-1, 10<D
1 2 3 4 5 6 7
2
4
6
8
10
6 Mathematica_6.nb
DoB x1 = FindRoot@g1@xD == f1@xD, 8x, xs1PiT<D;e1 = U0 Jz
rN2 �. z ® x1P1, 2T; AppendTo@En, e1D;
IfB i < 3, x2 = FindRoot@u1@xD == f1@xD, 8x, xs2PiT<D;e2 = U0 Jz
rN2 �. z ® x2P1, 2T; AppendTo@En, e2D F,
8i, 1, 3<[email protected] eV115.453 eV257.425 eV450.291 eV680.337 eV
energy = TableBEnPiTeV
, 8i, Length@EnD<F;Plot@Evaluate@energyD, 8x, 0, 1<,PlotStyle ® 88Red, [email protected]`D<<, Ticks ® 8None, Automatic<,AspectRatio ® 1.3`, AxesLabel ® 8" ", "E in eV"<D
100
200
300
400
500
600
E in eV
Achtung: Wenn die Plotvariable eine Liste ist, muss Evaluate verwendet werden. Dies liegt am
HoldAll Attribut der Plot-Funktion.
Stückweise definierte Funktionen
Mathematica_6.nb 7
Stückweise definierte Funktionen
für einfache Beispiele kann man If[...], Switch[...] oder Which[...] verwenden
p1@x_D := Sin@xD; p2@x_D := x;
p@x_D := If@x < 0, p1@xD, p2@xDDPlot@8p@xD, p¢@xD, p¢¢@xD<,
8x, -5, 2<, PlotStyle ® 8Black, Red, Blue<D
-5 -4 -3 -2 -1 1 2
-1.0
-0.5
0.5
1.0
1.5
2.0
Integrate@p@xD, 8x, -5, 5<D23
2+ Cos@5D
p'@xDIf@x < 0, p1¢@xD, p2¢@xDD
am besten und allgemeinsten benutzt man dafür die Funktion Piecewise[...]
q@x_D = Piecewise@88p1@xD, x < 0<, 8p2@xD, x ³ 0<<DSin@xD x < 0x x ³ 00 True
diese Darstellung kann auch bei der Eingabe mit Esc und Strg über die Tastatur erreicht werden:
erst "Esc pw Esc" dann "Strg ," , dann weiter mit "Tab" und für weitere Zeilen "Strg Return"
8 Mathematica_6.nb
q@x_D = PiecewiseA98p1@xD, x < 0<, 8p2@xD, 0 £ x < 2<, 92 ã2-x, x ³ 2==ESin@xD x < 0x 0 £ x < 2
2 ã2-x x ³ 20 True
q'@xDCos@xD x < 0
1 x � 0 ÈÈ 0 < x < 2
-2 ã2-x x > 2Indeterminate True
Plot@8q@xD, q¢@xD, q¢¢@xD<,8x, -5, 4<, PlotStyle ® 8Black, Red, Blue<D
-4 -2 2 4
-2
-1
1
2
Integrate@q@xD, 8x, -5, 5<D-2 + 3 ã3 + ã3 Cos@5D
ã3
im Gegensatz zur vereinfachten Definition mit If[...] etc, wird die Piecewise[...] Konstruktion in
Mathematica weitgehend auch mit anderen Funktionen wie D[...], Integrate[...], Limit[...],
DSolve[...] unterstützt
Funktionale Operationen
� Map[...]
Map[f, e], oder f /@ e wendet die Funktion f auf alle Elemente von e an.
Remove@a, bD
Mathematica_6.nb 9
Map@f, 81, 2, 3<D8f@1D, f@2D, f@3D<
f �� 8a, b, c<8f@aD, f@bD, f@cD<
Dies geht nicht nur für Listen
Sin �� Hx + yLSin@xD + Sin@yD
� Apply[...]
Apply[f, e] oder f @@ e ersetzt den Kopf von e durch f.
Apply@f, 81, 2, 3<Df@1, 2, 3D
f �� 8a, b<f@a, bD
mittel@l_ListD :=Plus �� l
Length@lDmittel@81, 2, 3, 4, 5, 6<D7
2
mittel@8c, d<Dc + d
2
� Nest
Nest@f, x, 5Df@f@f@f@f@xDDDDD
10 Mathematica_6.nb
NestB1 +1
ð1&, x, 5F
1 +1
1 +1
1+1
1+1
1+1
x
NestList erzeugt eine Liste mit allen Unterelementen von Nest
NestList@f, x, 3D8x, f@xD, f@f@xDD, f@f@f@xDDD<
� FixedPoint (Fixpunkt Berechnung)
FixedPoint@g, expr, 10Dg@g@g@g@g@g@g@g@g@g@exprDDDDDDDDDD
FixedPoint@Cos, 0.1D0.739085
FixedPointList@Cos, 0.1D80.1, 0.995004, 0.544499, 0.855387, 0.655927, 0.792483, 0.702079, 0.763501, 0.72242, 0.750208,
0.731547, 0.744142, 0.735669, 0.741382, 0.737536, 0.740128, 0.738383, 0.739558, 0.738766,
0.7393, 0.73894, 0.739183, 0.73902, 0.739129, 0.739055, 0.739105, 0.739072, 0.739094,
0.739079, 0.739089, 0.739082, 0.739087, 0.739084, 0.739086, 0.739085, 0.739086, 0.739085,
0.739085, 0.739085, 0.739085, 0.739085, 0.739085, 0.739085, 0.739085, 0.739085, 0.739085,
0.739085, 0.739085, 0.739085, 0.739085, 0.739085, 0.739085, 0.739085, 0.739085,
0.739085, 0.739085, 0.739085, 0.739085, 0.739085, 0.739085, 0.739085, 0.739085,
0.739085, 0.739085, 0.739085, 0.739085, 0.739085, 0.739085, 0.739085, 0.739085,
0.739085, 0.739085, 0.739085, 0.739085, 0.739085, 0.739085, 0.739085, 0.739085,
0.739085, 0.739085, 0.739085, 0.739085, 0.739085, 0.739085, 0.739085, 0.739085,
0.739085, 0.739085, 0.739085, 0.739085, 0.739085, 0.739085, 0.739085, 0.739085<
ListPlot@%, PlotStyle ® 8Red, [email protected]<D
20 40 60 80
0.739084
0.739086
0.739088
Fixpunkte der Logistischen Abbildung xn+1 = 4 xnHa - xnL, für a Î H0, 1L
Mathematica_6.nb 11
a = 0.7; FixedPointList@4 ð Ha - ðL &, 0.2, 1000D;ListPlot@%, PlotRange ® 80, 1<, PlotStyle ® 8Red, [email protected]<D
0 200 400 600 800 1000
0.2
0.4
0.6
0.8
1.0
a = 0.8`; FixedPointList@4 ð1 Ha - ð1L &, 0.2`, 1000D;ListPlot@%, PlotRange ® 80, 1<,PlotStyle ® 8Red, [email protected]<D
0 200 400 600 800 1000
0.2
0.4
0.6
0.8
1.0
12 Mathematica_6.nb
a = 0.998`; FixedPointList@4 ð1 Ha - ð1L &, 0.2`, 10 000D;ListPlot@%, PlotRange ® 80, 1<,PlotStyle ® 8Red, [email protected]<D
0 2000 4000 6000 8000 10 000
0.2
0.4
0.6
0.8
1.0
� Fold
Fold@g, x, 8a, b, c<Dg@g@g@x, 0.998D, bD, cD
Beispiel für das Produkt
Fold@Times, 1, 82, 3, 4, 5, 6<D720
Beispiel für das Hornersche Schema
Fold@ð1 x + ð2 &, 0, 8a, b, c, d, e<De + x Hd + x Hc + Hb + 0.998 xL xLL
FoldList erzeugt eine Liste mit allen Unterelementen von Fold, wie auch bei NestList
FoldList@g, x, 8a, b, c<D8x, g@x, 0.998D, g@g@x, 0.998D, bD, g@g@g@x, 0.998D, bD, cD<
� Thread
Mit Thread[...] (thread = einfädeln, durchfädeln) lassen sich Listen umgruppieren, bzw.
umsortieren.
Thread@k@81, 2, 3<, 8a, b, c<DD8k@1, 0.998D, k@2, bD, k@3, cD<
Mathematica_6.nb 13
Thread@8a, b, c< � 81, 2, 3<DFalse
Beispiel mit Vektoren, z.B. bei Bewegungsgleichungen im 3-dimensionalen Raum
F = m 8x¢¢@tD, y¢¢@tD, z¢¢@tD<8m x¢¢@tD, m y¢¢@tD, m z¢¢@tD<
fr = k0 8Cos@ΑD, 0, -Sin@ΑD< - Γ 8x¢@tD, 0, 0<8k0 Cos@ΑD - Γ x¢@tD, 0, -k0 Sin@ΑD<
Thread@F � frD8m x¢¢@tD � k0 Cos@ΑD - Γ x¢@tD, m y¢¢@tD � 0, m z¢¢@tD � -k0 Sin@ΑD<
DSolve@%, 8x@tD, y@tD, z@tD<, tD99x@tD ® -
ã-t Γ
m m C@1DΓ
+ C@2D +k0 t Cos@ΑD
Γ, y@tD ® C@3D + t C@4D, z@tD ® C@5D + t C@6D -
k0 t2 Sin@ΑD2 m
==
sol = %
99x@tD ® -ã
-t Γ
m m C@1DΓ
+ C@2D +k0 t Cos@ΑD
Γ, y@tD ® C@3D + t C@4D, z@tD ® C@5D + t C@6D -
k0 t2 Sin@ΑD2 m
==
Eigene Operatoren definieren
� z.B. CirclePlus
Eine Reihe von Operatoren wie CirclePlus Å , CircleTimes Ä , Del Ñ , Square � und weitere haben
in Mathematica keine vorgegebene Bedeutung. Sie können daher für eigene Zwecke definiert
werden, z.B.
Å ("Esc c+ Esc") für die relativistische Geschwindigkeitsaddition
CirclePlus@a_, b_D :=a + b
1 + a* b
v1 Å v2
v1 + v2
1 + v1 v2
14 Mathematica_6.nb
0.01 Å 0.01
0.019998
0.5 Å 0.5
0.8
1 Å 1
1
Erweiterung der Operation auf beliebig viele Elemente
v1 Å v2 Å v3 Å v4
v1Åv2Åv3Åv4
Man beachte den 2-fachen Underscore _ _ , dieser steht für ein oder mehrere Elemente. Er wird bei
der Eingabe zu einem längeren Strich zusammengezogen.
CirclePlus@a_, b_, c__D :=
CirclePlus@a, CirclePlus@b, cDD �� Together
v1 Å v2 Å v3 Å v4
v1 + v2 + v3 + v1 v2 v3 + v4 + v1 v2 v4 + v1 v3 v4 + v2 v3 v4
1 + v1 v2 + v1 v3 + v2 v3 + v1 v4 + v2 v4 + v3 v4 + v1 v2 v3 v4
0.4 Å 0.4 Å 0.4 Å 0.4
0.93473
?CirclePlus
CirclePlus@x, y, …D displays as xÅyÅ…. �
Prozedurale Strukturen: Module und Block
Die einfachste prozedurale Struktur ist eine Folge von Ausdrücken mit Semikolon getrennt.
Dabei wird das letzte Resultat, das ohne Semikolon geschrieben ist als Ergebnis ausgegeben :
r = 3; s = Sqrt@4D + r; r^2 + s^2
34
Mathematica_6.nb 15
func@y_D := HPrint@"Das Argument der Funktion ist: ", yD;Plot@Sin@x yD, 8x, 0, 2 Π<DL
func@5DDas Argument der Funktion ist: 5
1 2 3 4 5 6
-1.0
-0.5
0.5
1.0
Für Prozeduren mit lokalen Variablen verwendet man am besten Module[...] oder Block[...]
Module[{x,y,...}, expr]
Block[{x,y,...}, expr]
wobei "expr" wieder eine beliebige Folge von Ausdrücken sein kann, die mit Semikolon getrennt
werden.
Sie bieten die Möglichkeit, mit lokalen Variablen x,y,... zu arbeiten, die außerhalb des Befehls nicht
definiert sind, bzw. andere Werte besitzen können. Dadurch wird die Programmierung über-
sichtlicher und weniger fehleranfällig. Darüberhinaus können mit expr. verschiedene Befehle zusam-
mengefasst werden. Die beiden Befehle unterscheiden sich nur darin, dass bei Module auch die
Namen lokal sind, während die Namen bei Block global sind, die Werte sind immer lokal.
Remove@s, uDu := s2 + 1
ohne lokale Variable verhalten sich beide genau gleich
Module@8<, uD1 + s2
Block@8<, uD1 + s2
jedoch besteht der Sinn dieser prozeduralen Strukturen gerade darin,
lokale Variable zu definieren, die außerhalb keine Gültigkeit haben.
Darin unterscheiden sich dann Module und Block:
16 Mathematica_6.nb
jedoch besteht der Sinn dieser prozeduralen Strukturen gerade darin,
lokale Variable zu definieren, die außerhalb keine Gültigkeit haben.
Darin unterscheiden sich dann Module und Block:
Block@8s = 1<, uD2
Module@8s = 1<, uD1 + s2
im zweiten Beispiel unterscheidet Mathematica zwischen der äußeren und inneren Variablen s
Module@8s = 1<, u + sD2 + s2
Am besten verwendet man nur Variable und Parameter, die innerhalb des Moduls bzw. in einer
Funktionsdefinition explizit aufgeführt werden:
fm@u_D := Module@8s = 1<, u + [email protected]
fb@u_D := Block@8s = 1<, u + [email protected]
� Beispiel: Kurvendiskussion (ohne lokale Variable)
kd@f_, a_, b_D :=
ModuleB8<, Print@"Die 1. Ableitung ist :", f¢@xDD;Print@"Die 2. Ableitung ist :", f¢¢@xDD;PrintA"Die 3. Ableitung ist :", fH3L@xDE;Print@"Die Nullstellen sind :", Solve@f@xD � 0, xDD;Print@"Die Stellen mit f'HxL=0 sind :", Solve@f¢@xD � 0, xDD;Print@"Die Stellen mit f''HxL=0 sind :", Solve@f¢¢@xD � 0, xDD;PrintB"Die Stammfunktion von f ist :", à f@xD âxF;Plot@f@xD, 8x, a, b<DF
Mathematica_6.nb 17
f@x_D := x3 - x
kd@f, -3, 3DDie 1. Ableitung ist :-1 + 3 x2
Die 2. Ableitung ist :6 x
Die 3. Ableitung ist :6
Die Nullstellen sind :88x ® -1<, 8x ® 0<, 8x ® 1<<Die Stellen mit f'HxL=0 sind :::x ® -
1
3>, :x ®
1
3>>
Die Stellen mit f''HxL=0 sind :88x ® 0<<Die Stammfunktion von f ist :-
x2
2+x4
4
-3 -2 -1 1 2 3
-20
-10
10
20
� Beispiel: Prozedur zur Erzeugung einer Kurvenschar (mit lokalen Variablen)
ampl@v0_, tmin_, tmax_, color_, showgraph_D :=
Block@8t, res, lsg<,res = NDSolve@8x¢¢@tD + x@tD � 0, x@0D == 0, x¢@0D == v0<,x@tD, 8t, tmin, tmax<D; lsg = resP1T;Plot@x@tD �. lsg, 8t, tmin, tmax<, PlotStyle ® color,
DisplayFunction ®
If@showgraph � 1, $DisplayFunction, IdentityDDDa1 = [email protected], 0, 10, Red, 0D;a2 = ampl@1, 0, 10, Blue, 0D;a3 = ampl@3, 0, 10, Green, 0D;
18 Mathematica_6.nb
Show@Table@ai, 8i, 1, 3<D, DisplayFunction ® $DisplayFunctionD
2 4 6 8 10
-0.4
-0.2
0.2
0.4
wer sich etwas Schreibarbeit sparen will, kann eigene Funktionen definieren, z.B. für Show[...]
Man beachte den dreifachen underscore bei opt1__. An dieser Stelle können eine oder auch
mehrere Optionen folgen, oder auch gar keine!
MyShow@graph1_, opt1___, showgraph_D :=
Show@graph1, opt1,
DisplayFunction ®
If@showgraph � 1, $DisplayFunction, IdentityDDMyShow@Table@ai, 8i, 1, 3<D, Axes ® False, 1D
Arbeitsweise des Evaluators
� Anwendung von Regeln
Die grundlegende Arbeitsweise des Evaluators besteht darin, für den zu evaluierenden Ausdruck
Regeln zu finden, deren linke Seite anwendbar ist. Dies geschieht auf Verlangen bei der
Substitution...
Mathematica_6.nb 19
term �. term ® neu
neu
h@x, y, zD �. y ® alpha
h@x, alpha, zD
fac@5D �. 8fac@0D ® 1, fac@n_D ¦ n fac@n - 1D<5 fac@4D
fac@5D ��. 8fac@0D ® 1, fac@n_D ¦ n fac@n - 1D<120
[email protected] ��. 8fac@0D ® 1, fac@n_D ¦ n fac@n - 1D<ReplaceRepeated::rrlim : Exiting after [email protected] scanned 65536 times. �
..oder automatisch, wenn Regeln global definiert werden.
log@a_ b_D := log@aD + log@bDlogA2 x y2Elog@2D + log@xD + logAy2E
log@a_n_D := n log@aD%%
log@2D + log@xD + 2 log@yD
� Rekursive Funktionen mit "Gedächtnis"
im ersten Fall steigen die Rechenzeiten mit wachsendem n enorm an
f1@n_D := f1@n - 1D + f1@n - 2Df1@0D = 1; f1@1D = 1;
f1@10D �� Timing
80., 89<
20 Mathematica_6.nb
f1@30D �� Timing
84.719, 1346269<
f1@100D �� Timing
$Aborted
im zweiten Fall merkt man kaum eine Verzögerung
f2@n_D := f2@nD = f2@n - 1D + f2@n - 2Df2@0D = 1; f2@1D = 1;
f2@30D �� Timing
80., 1346269<
f2@100D �� Timing
80., 573147844013817084101<
� Die Reihenfolge der Evaluation
Zuerst werden der Kopf und die Elemente eines Ausdruckes evaluiert. Für einen Ausdruck der Form
f @ ..., g@ ...D, ... Dwerden dann Regeln in dieser Reihenfolge gesucht:
Benutzerdefinierte Regeln für f [ ..., g[...], ... ], assoziiert mit g.
g �: f@g@x_D, ...D := ...
Eingebaute Regeln für f [ ..., g[...], ... ], assoziiert mit g.
Benutzerdefinierte Regeln für f[ ... ], assoziiert mit f.
f@ ... D := ...
Eingebaute Regeln für f[ ... ], assoziiert mit f.
Das Resultat einer Regelanwendung wird dann weiter evaluiert.
Mustererkennen
Ein Muster (Pattern) ist ein Ausdruck, der besondere Musterobjekte enthalten kann. Das Musterob-
jekt Blank[ ] oder _ steht für beliebige Ausdrücke.
Blank[h] passt auf einen Ausdruck mit Kopf h.
BlankSequence[ ] und BlankNullSequence[ ] passen auf Folgen von Ausdrücken
Mathematica_6.nb 21
_
_expr
__
__expr
___
___expr
_.
_ : a
symb_
symb_expr
symb__
symb__expr
symb___
symb___expr
symb_.
FullForm@symb___exprDPattern@symb, BlankNullSequence@exprDD
FullForm@_.DOptional@Blank@DD
� Grundlegende Beispiele
Zur Illustrierung werden wir jeweils die Muster in einer Regel verwenden.
Die Leerstelle _ steht für irgend etwas
Remove@f, a, bD8f@xD, f@yD, h@zD, f@x, yD, f@x, y, zD, f@D< �. f@_D ¦ uu
8uu, uu, h@zD, f@x, yD, f@x, y, zD, f@D<
Das Muster _:a steht für irgend etwas mit dem Defaultargument a
8f@xD, f@yD, h@zD, f@x, yD, f@x, y, zD, f@D< �. f@_ : aD ¦ a2
9a2, a2, h@zD, f@x, yD, f@x, y, zD, a2=
Der für die Leerstelle eingesetzte Ausdruck erhält den Namen t, der dann auf der rechten Seite
verwendet wird.
22 Mathematica_6.nb
8f@xD, f@yD, h@zD, f@x, yD, f@x, y, zD, f@D< �. f@t_D ¦ t
8x, y, h@zD, f@x, yD, f@x, y, zD, f@D<
Die doppelte Leerstelle __ steht für irgendeine Reihe mit ein oder mehreren Elementen
8f@xD, f@yD, h@zD, f@x, yD, f@x, y, zD, f@D< �. f@__D ¦ uu
8uu, uu, h@zD, uu, uu, f@D<
Die dreifache Leerstelle ___ steht für irgendeine Reihe mit null oder mehreren Elementen
8f@xD, f@yD, h@zD, f@x, yD, f@x, y, zD, f@D< �. f@___D ¦ uu
8uu, uu, h@zD, uu, uu, uu<
Die Reihe mit null oder mehreren Elementen erhält den Namen t, der auf der rechten Seite weiterver-
wendet wird.
8f@xD, f@yD, h@zD, f@x, yD, f@x, y, zD, f@D< �. f@t___D ¦ t
8x, y, h@zD, x, y, x, y, z<
Dieses Muster passt nur auf sich selbst!
8f@xD, f@yD, h@zD< �. f@xD ¦ x
8x, f@yD, h@zD<
Tritt eine Mustervariable zweimal auf, so muss jedesmal dasselbe ersetzt werden
8f@a, bD, f@2, 2D, f@3, 3.0D< �. f@x_, x_D ¦ g@xD8f@a, bD, g@2D, f@3, 3.D<
� Mustererkennen für Ausdrücke mit Default-Argumentbei x_ + y_. ist der default Wert für y=0, bei x_*y_. und x_y_. ist der default Wert y=1
8f@D, f@aD, f@a + bD, f@d + cD< �. f@x_ + y_.D -> p@x, yD8f@D, p@a, 0D, p@b, aD, p@d, cD<
8f@aD, f@a bD< �. f@x_ y_.D -> p@x, yD8p@a, 1D, p@b, aD<
Mathematica_6.nb 23
9f@aD, fAabE= �. f@x_ y_.D -> p@x, yD8p@a, 1D, p@a, bD<
� praktische Beispiele zur Mustererkennung
Beispiel 1: vereinfachte Taylorreihe
PotenzReihe@f_, x_: x, x0_: 0, nm_: 6D := Series@f, 8x, x0, nm<DPotenzReihe@Sin@xDDx -
x3
6+
x5
120+ O@xD7
PotenzReihe@Sin@xD, x, 1.0D0.841471 + 0.540302 Hx - 1.L - 0.420735 Hx - 1.L2 - 0.0900504 Hx - 1.L3 +
0.0350613 Hx - 1.L4 + 0.00450252 Hx - 1.L5 - 0.00116871 Hx - 1.L6 + O@x - 1.D7
% �� Normal �� Expand
-0.000126367 + 1.0009 x - 0.00277243 x2 - 0.161896 x3 - 0.00498195 x4 + 0.0115148 x5 - 0.00116871 x6
Beispiel 2: Im ersten Fall passt die Regel nur auf erste Element, im zweiten Fall auf die ersten 3
Elemente
91 + x2 + y2, 1 - x2 - y2, 2 x2 + 2 y2, 2 x2 + y2= �. x2 + y2 :> z2
91 + z2, 1 - x2 - y2, 2 x2 + 2 y2, 2 x2 + y2=
91 + x2 + y2, 1 - x2 - y2, 2 x2 + 2 y2, 2 x2 + y2= �. a_. x2 + a_. y2 ¦ a z2
91 + z2, 1 - z2, 2 z2, 2 x2 + y2=
Beispiel 3: Wurzel-Regel für positive reelle Zahlen
SqrtRules = : x_ y_ -> x y ,1
y_->
1
y,
x_
y_->
x
y>;
24 Mathematica_6.nb
z a b x
z b x y
a b x z
b x y z
% �. SqrtRulesa b x z
b x y z
%% ��. SqrtRulesa
y
� Mustererkennen für Ausdrücke eines Typs: _expr
Das Muster Blank[expr], oder _expr, matcht nur Ausdrücke mit Kopf expr. expr kann als Datentyp
angesehen werden.
8f@aD, f@2D, [email protected], f@1 + ID< �. f@x_IntegerD ¦ x2
8f@aD, 4, [email protected], f@1 + äD<
8f@aD, f@2D, [email protected], f@1 + ID< �. f@x_RealD ¦ x2
8f@aD, f@2D, 12.25, f@1 + äD<
8f@aD, f@2D, [email protected], f@1 + ID< �. f@x_ComplexD ¦ x2
8f@aD, f@2D, [email protected], 2 ä<
:fB23
F, f@2D, [email protected], f@1 + ID> �. f@x_RationalD ¦ x2
:49, f@2D, [email protected], f@1 + äD>
� Prädikate im Mustererkennen
Ein Muster der Form pattern?test passt nur, falls test[expr] den Wert True ergibt, wobei expr der
zu vergleichende Ausdruck ist.
Dies ist die typische Verwendungsweise
Mathematica_6.nb 25
f@x_Integer?PositiveD := x
Information@"f", LongForm ® FalseDGlobal`f
f@x_Integer?PositiveD := x
8f@1D, f@0D, f@-1D, f@ID, [email protected], f@1 + ID, f@3D<:1, f@0D, f@-1D, f@äD, [email protected], f@1 + äD, 3 >
� Nebenbedingungen
Prädikate werden nur auf eine Mustervariable angewendet. Kompliziertere Bedingungen können auf
der rechten Seite der Regel angegeben werden. Die Nebenbedingung wird evaluiert, nachdem ein
Ausdruck in das Muster passt. Nur wenn das Resultat True ist, wird die Regel auch angewendet.
g@x_, y_D := xy �; x < y && y > 0
8g@2, 3D, g@3, 3D, g@-2, -1D<88, g@3, 3D, g@-2, -1D<
Testen von Eigenschaften
Es gibt in Mathematica eine Reihe von Funktionen zum Testen von Eigenschaften von Ausdrücken.
Diese Funktionen haben Namen, die mit Q enden, um anzuzeigenm dass sie eine Frage (Question)
stellen. Z.B. IntegerQ, EvenQ, OddQ, PrimeQ, etc
IntegerQ �� :1, -3, 2., a12,2
3>
8True, True, False, False, False<
EvenQ �� 81, 2, 3, 4, 5.0, 6.<8False, True, False, True, False, False<
PrimeQ �� 81, 2, 3, 129, 1001<8False, True, True, False, False<
eine mögliche Anwendung, um sicher zustellen, dass in einer Rechnung eine Integerzahl gerade ist
26 Mathematica_6.nb