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 ® 8Thickness@0.005D<D;SetOptions@ListPlot, PlotStyle ® 8Red, PointSize@0.035D<D;

dünne Linien und Punkte :

SetOptions@8Plot, ListPlot, Graphics<,BaseStyle ® 8Medium, FontFamily ® "Times"<D;

SetOptions@Plot, PlotStyle ® 8Thickness@0.002D<D;SetOptions@ListPlot, PlotStyle ® 8Red, PointSize@0.005D<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, PointSize@.02D<DD

ComplexNumberPlot@list_,opts : OptionsPattern@ListPlotDD := Module@8<,ListPlot@Tooltip@8Re@ðD, Im@ðD<D & �� N@listD, opts,

AspectRatio ® Automatic, PlotStyle ® 8Red, PointSize@.02D<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, f@2.5D<, 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, Thickness@0.01`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<FColumn@EnD29.0006 eV115.453 eV257.425 eV450.291 eV680.337 eV

energy = TableBEnPiTeV

, 8i, Length@EnD<F;Plot@Evaluate@energyD, 8x, 0, 1<,PlotStyle ® 88Red, Thickness@0.01`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, PointSize@0.010D<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, PointSize@0.005D<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, PointSize@0.005D<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, PointSize@0.005D<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 + sDfm@aD1.998

fb@u_D := Block@8s = 1<, u + sDfb@aD1.998

� 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 = ampl@0.5, 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

fac@5.0D ��. 8fac@0D ® 1, fac@n_D ¦ n fac@n - 1D<ReplaceRepeated::rrlim : Exiting after fac@5.D scanned 65536 times. �

0. fac@-65531.D

..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, f@3.5D, f@1 + ID< �. f@x_IntegerD ¦ x2

8f@aD, 4, f@3.5D, f@1 + äD<

8f@aD, f@2D, f@3.5D, f@1 + ID< �. f@x_RealD ¦ x2

8f@aD, f@2D, 12.25, f@1 + äD<

8f@aD, f@2D, f@3.5D, f@1 + ID< �. f@x_ComplexD ¦ x2

8f@aD, f@2D, f@3.5D, 2 ä<

:fB23

F, f@2D, f@3.5D, f@1 + ID> �. f@x_RationalD ¦ x2

:49, f@2D, f@3.5D, 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, f@0.5D, f@1 + ID, f@3D<:1, f@0D, f@-1D, f@äD, f@0.5D, 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

even@n_D := If@OddQ@nD, n + 1, nDeven �� 81, 2, 3, 4, 5<82, 2, 4, 4, 6<

in diesem Beispiel werden die Elemente auf ein Muster getestet und alle erfolgreichen Tests gezählt

RandomInteger@81, 100<, 10D861, 80, 25, 36, 51, 7, 19, 92, 89, 94<

Count@%, _?EvenQD4

Count@%%, _?PrimeQD4

Mathematica_6.nb 27