Einführung in Mathematica (4)

Transkript

1 Einführung in Mathematica (4) Programmieren mit Mathematica Michael O. Distler, Computer in der Wissenschaft, SS 2012 (Vorlage von L. Tiator) Voreinstellungen Grafik - Initialisierung In[1]:= SetOptions Plot, ListPlot, ParametricPlot, Plot3D, Graphics, BaseStyle 18, FontFamily "Times", Italic ; SetOptions Plot, PlotStyle Thickness ; SetOptions ListPlot, PlotStyle Red, PointSize ; dünne Linien und Punkte : SetOptions Plot, ListPlot, Graphics, BaseStyle Medium, FontFamily "Times" ; SetOptions Plot, PlotStyle Thickness ; SetOptions ListPlot, PlotStyle Red, PointSize ; andere mögliche Fonts : BaseStyle 18, FontFamily "Helvetica" BaseStyle Large, 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 In[4]:= RootPlot sol_, opts : OptionsPattern ListPlot : Module, CellPrint ExpressionCell N sol, "Output" ; ListPlot Tooltip Re, Im & N x. sol, opts, AspectRatio Automatic, PlotStyle Red, PointSize.02

2 2 Mathematica_4.nb In[5]:= ComplexNumberPlot list_, opts : OptionsPattern ListPlot : Module, ListPlot Tooltip Re, Im & N list, opts, AspectRatio Automatic, PlotStyle Red, PointSize.02 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 In[19]:= f1 x_ : x 2 1 In[20]:= f1 a b Out[20]= 1 a b 2 Typische Definition einer Prozedur mit dem Befehl: Module[...] In[21]:= Polardiagramm r_, phi_, phi0_, phi1_ : Module x, y, x r Cos phi ; y r Sin phi ; ParametricPlot x, y, phi, phi0, phi1, AspectRatio Automatic

3 Mathematica_4.nb 3 In[22]:= Polardiagramm 1 Sin phi, phi, 0, 2 Π 1.5 Out[22]= In[23]:= Polardiagramm 1 Sin 5 phi, phi, 0, 2 Π Out[23]= 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.

4 4 Mathematica_4.nb If In[24]:= func1 x_ : If x 0, 1 x, oder die sphärische Besselfunktion j 0 x In[25]:= j0 x_ : If x 0, Sin x, 1 x In[26]:= Table func1 x, x, 2, 2 Table j0 x, x, 2, 2 Out[26]= 1 2, 1,, 1, 1 2 Out[27]= Sin 2 2, Sin 1, 1, Sin 1, Sin 2 2 Switch In[28]:= func2 n_ : Switch n, 0, f0 x, 1, f1 x, _, def x mit Map[...] bzw. /@ kann man verschiedene Werte der Funktion berechnen: In[29]:= func2 1, n, m, 0, 1, 2, x Out[29]= def x, def x, def x, f0 x, 1 x 2, def x, def x Which In[30]:= vorzeichen x_ : Which x 0, 1, x 0, 0, x 0, 1 In[31]:= vorzeichen 5.5, 0, a Out[31]= 1, 0, Which a 0, 1, a 0, 0, a 0, 1 Select und Cases Zum Auswählen aus einer Liste gibt es Select[...] und Cases[...]. In[32]:= Select 1, 2, 3, 4, 5, 6, 7, 8, 9, PrimeQ Out[32]= 2, 3, 5, 7

5 Mathematica_4.nb 5 oder z. B. die geraden und ungeraden Zahlen mit EvenQ und OddQ In[33]:= Select 1, 2, 3, 4, 5, 6, 7, 8, 9, EvenQ Out[33]= 2, 4, 6, 8 In[34]:= Cases f 1, g 2, f s, f 2.5, f _Integer Out[34]= f 1 Schleifen mit Do und For For[...] ist wie in C. Sollte aber in Mathematica vermieden werden. In[35]:= s 0; For i 1, i 10, i, s s i 2 s Out[37]= 385 Meist genügt eine einfache Do[...] - Schleife. In[38]:= s 0; Do s s i 2, i, 1, 10 s Out[40]= 385 Sowohl bei For als auch bei Do ergeben die Funktionen kein direktes Ergebnis. Man kann dies aber mit einem Print Befehl erreichen, z.b. In[41]:= s 0; Do s s i 2 ; Print s, i, 1,

6 6 Mathematica_4.nb was ist im nächsten Beispiel verkehrt? In[43]:= s 0; Do s s i 2 ; Print "i,s ", i, s, i, 1, 10 i,s 11 i,s 25 i,s 314 i,s 430 i,s 555 i,s 691 i,s 7140 i,s 8204 i,s 9285 i,s In vielen Fällen kann auch strukturierte Iteration verwendet werden. z.b. Sum[f, {i, imin, imax}] In[45]:= 10 i 2 i 1 Out[45]= 385 oder Product[f, {i, imin, imax}] In[46]:= 5 i i 1 Out[46]= 120

7 Mathematica_4.nb 7 Beispiel: Energieniveaus in der QM im 1-dim. Potentialtopf In[47]:= ListPlot 5, 0, 2, 0, 2, 800, 2, 800, 2, 0, 5, 0, Joined True, PlotStyle Red, Thickness 0.01`, AxesOrigin 5, 0, AxesLabel "x", "Potential V x " Potential V x Out[47]= 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) Suche nach Lösungen der transzendenten Gleichungen: x tan(x) = r 2 x 2 und x cot(x) = - r 2 x 2 In[48]:= r 7.244; U0 800 ev; f1 x_ : r 2 x 2 ; g1 x_ : x Tan x ; u1 x_ : x Cot x ; xs1 1., 4., 7. ; xs2 2., 5. ; En ; In[53]:= Plot f1 x, g1 x, u1 x, x, 0, r 10 Out[53]=

8 8 Mathematica_4.nb In[54]:= Out[54]= Plot f1 x, g1 x, u1 x, x, 0, r, PlotStyle Black, Red, Blue, PlotRange 1, In[55]:= Do x1 FindRoot g1 x f1 x, x, xs1 i ; e1 U0 z r 2. z x1 1, 2 ; AppendTo En, e1 ; If i 3, x2 FindRoot u1 x f1 x, x, xs2 i ; e2 U0 z r 2. z x2 1, 2 ; AppendTo En, e2, i, 1, 3 In[56]:= Column En Out[56]= ev ev ev ev ev

9 Mathematica_4.nb 9 In[57]:= energy Table En i, i, Length En ; ev Plot Evaluate energy, x, 0, 1, PlotStyle Red, Thickness 0.01`, Ticks None, Automatic, AspectRatio 1.3`, AxesLabel " ", "E in ev" E in ev Out[58]= Achtung: Wenn die Plotvariable eine Liste ist, muss Evaluate verwendet werden. Dies liegt am HoldAll Attribut der Plot-Funktion. Stückweise definierte Funktionen mit If Switch oder Which für einfache Beispiele kann man If[...], Switch[...] oder Which[...] verwenden In[59]:= p1 x_ : Sin x ; p2 x_ : x; p x_ : If x 0, p1 x, p2 x

10 10 Mathematica_4.nb In[61]:= Plot p x, p x, p x, x, 5, 2, PlotStyle Black, Red, Blue Out[61]= In[62]:= Integrate p x, x, 5, 5 Out[62]= 23 Cos 5 2 In[63]:= p' x Out[63]= If x 0, p1 x, p2 x In[64]:= p' x Evaluate Out[64]= If x 0, p1 x, p2 x mit Piecewise am besten und allgemeinsten benutzt man dafür die Funktion Piecewise[...] In[65]:= q x_ Piecewise p1 x, x 0, p2 x, x 0 Out[65]= Sin x x 0 x x 0 0 True im Falle, dass alle explizit angegebenen Bedingungen "False" sind, wird der letzte Wert 0 ausgegeben. 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"

11 Mathematica_4.nb 11 In[66]:= q x_ Piecewise p1 x, x 0, p2 x, 0 x 2, 2 2 x, x 2 Out[66]= Sin x x 0 x 0 x x x 2 0 True In[67]:= q' x Out[67]= Cos x x 0 1 x 0 0 x x x 2 Indeterminate True In[68]:= Plot q x, q x, q x, x, 5, 4, PlotStyle Black, Red, Blue, Exclusions None 1 Out[68]= In[69]:= Integrate q x, x, 5, 5 Out[69]= Cos 5 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 In[70]:= Remove f, a, b Map[f, expr], oder f /@ expr wendet die Funktion f auf alle Elemente von expr an.

12 12 Mathematica_4.nb In[71]:= Map f, 1, 2, 3 Out[71]= f 1, f 2, f 3 In[72]:= f a, b, c Out[72]= f a, f b, f c In[73]:= Sin a, b, c Out[73]= Sin a, Sin b, Sin c für Funktionen mit dem Attribut "Listable" geht dies auch einfacher In[74]:= Sin a, b, c Out[74]= Sin a, Sin b, Sin c In[75]:=?? Sin Sin z gives the sine of z. Attributes Sin Listable, NumericFunction, Protected Map ist dagegen allgemeiner, z.b. auch In[76]:= Sin x y Out[76]= Sin x Sin y Apply Apply[f, expr] oder expr ersetzt den Kopf von expr durch f. In[77]:= Apply f, 1, 2, 3 Out[77]= f 1, 2, 3 In[78]:= f a, b Out[78]= f a, b In[79]:= mittel l_list : Plus l Length l

13 Mathematica_4.nb 13 In[80]:= mittel 1, 2, 3, 4, 5, 6 Out[80]= 7 2 In[81]:= mittel c, d Out[81]= c d 2 Scan Scan[f, expr] wendet f auf jedes Element in expr an. Scan gibt jedoch keinen Wert zurück In[82]:= Scan f, 1, 2, 3 Jedoch kann man es sehr gut mit Print anwenden, da Print seinen eigenen Output erzeugt. In[83]:= Scan Print, 1, 2, In[84]:= Scan Print ^2 &, 2, 3, Through Through[{f,g,h} [x,y]] wendet eine Liste von Funktionen auf das gleiche Argument an. (Für weitere Anwendungen, siehe Online Help) In[85]:= Through f, g, h x, y Out[85]= f x, y, g x, y, h x, y In[86]:= Through Sin, Cos, Tan x Out[86]= Sin x, Cos x, Tan x Beispiel: Minimum, Maximum und Dimension einer Liste In[87]:= liste 2, 1, 6, 4, 0, 3 ;

14 14 Mathematica_4.nb In[88]:= min, max, n0 Through Min, Max, Length liste Out[88]= 6, 4, 6 Nest In[89]:= Nest f, x, 5 Out[89]= f f f f f x In[90]:= Nest &, x, 5 Out[90]= x NestList erzeugt eine Liste mit allen Unterelementen von Nest In[91]:= NestList f, x, 3 Out[91]= x, f x, f f x, f f f x FixedPoint Fixpunkt Berechnung In[92]:= FixedPoint g, expr, 10 Out[92]= g g g g g g g g g g expr In[93]:= FixedPoint Cos, 0.1 Out[93]= FixedPointList gibt alle Einzelschritte als Liste an In[94]:= FixedPointList Cos, 0.1 Out[94]= 0.1, , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,

15 Mathematica_4.nb 15 In[95]:= ListPlot, PlotStyle Red, PointSize Out[95]= Fixpunkte der Logistischen Abbildung x n 1 4 x n a x n, für a 0, 1 In[96]:= a 0.7; FixedPointList 4 a &, 0.2, 1000 ; In[97]:= ListPlot, PlotRange 0, 1, PlotStyle Red, PointSize Out[97]= In[98]:= a 0.8`; FixedPointList 4 1 a 1 &, 0.2`, 1000 ; ListPlot, PlotRange 0, 1, PlotStyle Red, PointSize Out[99]=

16 16 Mathematica_4.nb a = 0.998`; FixedPointList@4 ð1 Ha - ð1l &, 0.2, D; ListPlot@%, PlotRange 80, 1<, PlotStyle 8Red, PointSize@0.005D<D In[100]:= Out[101]= Fold In[102]:= Clear@a, b, cd In[103]:= Fold@g, x, 8a, b, c<d Out[103]= g@g@g@x, ad, bd, cd Beispiel für das Produkt Fold@Times, 1, 82, 3, 4, 5, 6<D In[104]:= Out[104]= 720 Beispiel für das Hornersche Schema Fold@ð1 x + ð2 &, 0, 8a, b, c, d, e<d In[105]:= Out[105]= e + x Hd + x Hc + x Hb + a xlll FoldList erzeugt eine Liste mit allen Unterelementen von Fold, wie auch bei NestList FoldList@g, x, 8a, b, c<d In[106]:= Out[106]= 8x, g@x, ad, g@g@x, ad, bd, g@g@g@x, ad, bd, cd< Thread Mit Thread[...] (thread = einfädeln, durchfädeln) lassen sich Listen umgruppieren, bzw. umsortieren.

17 Mathematica_4.nb 17 In[107]:= Thread k 1, 2, 3, a, b, c Out[107]= k 1, a, k 2, b, k 3, c In[108]:= Thread a, b, c 1, 2, 3 Out[108]= a 1, b 2, c 3 Beispiel mit Vektoren, z.b. bei Bewegungsgleichungen im 3-dimensionalen Raum In[109]:= F m x t, y t, z t Out[109]= m x t, m y t, m z t In[110]:= fr k0 Cos Α, 0, Sin Α Γ x t, 0, 0 Out[110]= k0 Cos Α Γ x t, 0, k0 Sin Α In[111]:= Thread F fr Out[111]= m x t k0 Cos Α Γ x t, m y t 0, m z t k0 Sin Α In[112]:= DSolve, x t, y t, z t, t Out[112]= x t t Γ m m C 1 k0 t Cos Α C 2, Γ Γ y t C 3 t C 4, z t C 5 t C 6 k0 t2 Sin Α 2 m Compile Compiled Functions sind rein numerische Funktionen, die sehr viel schneller als normale Funktionen evaluiert werden können. 1. Beispiel ohne Compile In[113]:= logistic1 n_integer : Module f, t, x, f x_, t_ Evaluate 3 t n x 1 x ; FoldList f, 0.223, Range n In[114]:= logistic ; Timing Out[114]= 4.906, Null 2. Beispiel mit Compile

18 18 Mathematica_4.nb logistic2an_integere := In[115]:= ModuleB8f, t, x<, f = CompileB8x, t<, EvaluateB 3 + t n x H1 - xlff; FoldList@f, 0.223, Range@nDDF logistic2@ D; Timing In[116]:= Out[116]= , Null< ListPlot@logistic2@ D, PlotStyle 8Red, PointSize@0.0025D<, ImageSize 500D In[117]:= Out[117]= logistic2@5d In[118]:= Out[118]= , , , , , < Logistic Map als Funktion des Parameters Μ : f Hx; ΜL = Μ xh1 - xl hier: Ausschnitt von Μ Î (3, 4]

19 Mathematica_4.nb 19 logistican_integere := ModuleB8f, t, x, list<, In[119]:= f = CompileB8x, t<, EvaluateB 3 + t n x H1 - xlff; Transpose@83 + Range@0, 1, 1 nd, FoldList@f, 0.223, Range@nDD<DF ListPlot@logistic@ D, PlotStyle 8Red, PointSize@0.0025D<, AxesLabel 8"Μ", "x "<, ImageSize 500D x Out[120]= Μ Eigene Operatoren definieren z.b. CirclePlus Eine Reihe von Operatoren wie CirclePlus Å, CircleTimes Ä, SmallCircle ë, 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 In[121]:= CirclePlusAa_, b_e := In[122]:= v1 Å v2 v1 + v2 Out[122]= 1 + v1 v2 a + b 1 + a*b

20 20 Mathematica_4.nb In[123]:= Out[123]= In[124]:= Out[124]= 0.8 In[125]:= 1 1 Out[125]= 1 Erweiterung der Operation auf beliebig viele Elemente In[126]:= v1 v2 v3 v4 Out[126]= 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. In[127]:= CirclePlus a_, b_, c : CirclePlus a, CirclePlus b, c Together In[128]:= v1 v2 v3 v4 Out[128]= 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 In[129]:= Out[129]= In[130]:=? CirclePlus CirclePlus x, y, displays as x y. Prozedurale Strukturen: Module und Block einfache Strukturen 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 :

21 Mathematica_4.nb 21 In[131]:= r 3; s Sqrt 4 r; r^2 s^2 Out[131]= 34 im folgenden Beispiel werden mit einer runden Klammer 2 Funktionen miteinander zu einer einfachen Prozedur verbunden: In[132]:= func y_ : Print "Das Argument der Funktion ist: ", y ; Plot Sin x y, x, 0, 2 Π In[133]:= func 5 Das Argument der Funktion ist: Out[133]= Module und Block 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 übersichtlicher und weniger fehleranfällig. Darüber hinaus können mit expr. verschiedene Befehle zusammengefasst 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 in beiden Fällen immer lokal. In[134]:= Remove s, u In[135]:= u : s 2 1 ohne lokale Variable verhalten sich beide genau gleich

22 22 Mathematica_4.nb In[136]:= Module, u Out[136]= 1 s 2 In[137]:= Block, u Out[137]= 1 s 2 setzt man u als lokale Variable, dann sind die Ergebnisse sehr verschieden: In[138]:= Module u, u Out[138]= u$1320 im ersten Fall erscheint nur eine interne Variable u$xxxx, die sich bei jedem weiteren Aufruf verändert In[139]:= Block u, u Out[139]= 1 s 2 im zweiten Fall erscheint die globale Variable u 1 s 2 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: In[140]:= Block s 1, u Out[140]= 2 In[141]:= Module s 1, u Out[141]= 1 s 2 im zweiten Beispiel unterscheidet Mathematica zwischen der äußeren und inneren Variablen s In[142]:= Module s 1, u s Out[142]= 2 s 2 Am besten verwendet man nur Variable und Parameter, die innerhalb des Moduls bzw. in einer Funktionsdefinition explizit aufgeführt werden: In[143]:= fm u_ : Module s 1, u s In[144]:= fm a Out[144]= 1 a

23 Mathematica_4.nb 23 In[145]:= fb u_ : Block s 1, u s In[146]:= fb a Out[146]= 1 a oder In[147]:= Module u, s 1, u : 1 s 2 ; u s Out[147]= 3 In[148]:= Block u, s 1, u : 1 s 2 ; u s Out[148]= 3 tückisches Beispiel innerhalb von Manipulate In[149]:= Manipulate Module g 9.81, l 1, eq1, lsg1, x, x0, x1, t, eq1 l x'' t g Sin x t 0, x 0 0, x' 0 v0 ; lsg1 NDSolve eq1, x t, x' t, t, 0, tmax Flatten; x1 t_ x t. lsg1; Plot x1 t, t, 0, tmax, v0, 4, 0, 10, Appearance "Labeled", tmax, 10, 1, 100 tmax v Out[149]=

24 24 Mathematica_4.nb In[150]:= Manipulate Block g 9.81, l 1, eq1, lsg1, x, x0, x1, t, eq1 l x'' t g Sin x t 0, x 0 0, x' 0 v0 ; lsg1 NDSolve eq1, x t, x' t, t, 0, tmax Flatten; x1 t_ x t. lsg1; Plot x1 t, t, 0, tmax, v0, 4, 0, 10, Appearance "Labeled", tmax, 10, 1, 100 tmax v Out[150]= das Problem hängt mit der Regelanwedung: x1 t_ x t. lsg1 zusammen In[151]:= Manipulate Module g 9.81, l 1, eq1, lsg1, x, x1, t, eq1 l x'' t g Sin x t 0, x 0 0, x' 0 v0 ; lsg1 NDSolve eq1, x t, x' t, t, 0, tmax Flatten; x1 t_ x t. lsg1; x t, lsg1, x1 t ColumnForm, v0, 4, 0, 10, Appearance "Labeled", tmax, 10, 1, 100 tmax v0 4 Out[151]= x$1441 t$1441 x$1441 t$1441 InterpolatingFunction 0., 10., 3, 11, 2, 369, 4, 0, 0, 0, 0, 0 x$1441 t$1441

25 Mathematica_4.nb 25 In[152]:= Manipulate Block g 9.81, l 1, eq1, lsg1, x, x1, t, eq1 l x'' t g Sin x t 0, x 0 0, x' 0 v0 ; lsg1 NDSolve eq1, x t, x' t, t, 0, tmax Flatten; x1 t_ x t. lsg1; x t, lsg1, x1 t ColumnForm, v0, 4, 0, 10, Appearance "Labeled", tmax, 10, 1, 100 tmax v0 4 Out[152]= x t x t InterpolatingFunction 0., 10., 3, 11, 2, 369, 4, 0, 0, 0, 0, 0., InterpolatingFunction 0., 10., 3, 11, 2, 369, 4, 0, 0, 0, 0, 0., , 0 dies lässt sich zwar vermeiden, wenn man bei der Ersetzung globale Variable verwendet In[153]:= Manipulate Module g 9.81, l 1, eq1, x1, eq1 l x'' t g Sin x t 0, x 0 0, x' 0 v0 ; lsg1 NDSolve eq1, x t, x' t, t, 0, tmax Flatten; x1 t_ x t. lsg1; x t, lsg1, x1 t ColumnForm, v0, 4, 0, 10, Appearance "Labeled", tmax, 10, 1, 100 tmax v0 4 Out[153]= x t x t InterpolatingFunction 0., 10., 3, 11, 2, 369, 4, 0, 0, 0, 0, 0., InterpolatingFunction 0., 10., 3, 11, 2, 369, 4, 0, 0, 0, 0, 0., , 0 Im nächsten Fall landet man aber in einer Endlosschleife, bei der Mathematica die CPU auf 100% hoch fährt. Eine Funktion, die innerhalb von Manipulate definiert wird, muss immer lokal sein!

26 26 Mathematica_4.nb In[154]:= Manipulate Module g 9.81, l 1, eq1, eq1 l x'' t g Sin x t 0, x 0 0, x' 0 v0 ; lsg1 NDSolve eq1, x t, x' t, t, 0, tmax Flatten; x1 t_ x t. lsg1; x t, lsg1, x1 t ColumnForm, v0, 4, 0, 10, Appearance "Labeled", tmax, 10, 1, 100 tmax v0 4 Out[154]= x t x t InterpolatingFunction 0., 10., 3, 11, 2, 369, 4, 0, 0, 0, 0, 0., x t an dieser Stelle muss man manuell stoppen, z.b. mit Quit In[155]:= Quit aber gerade bei Manipulate ist es sicherer, lokale Variable zu verwenden, daher sollte man in solchen Fällen besser Block[...] statt Module[...] benutzen. Beispiel: Kurvendiskussion (ohne lokale Variable) In[6]:= kd f_, a_, b_ : Module, Print "Die 1. Ableitung ist : ", f x ; Print "Die 2. Ableitung ist : ", f x ; Print "Die 3. Ableitung ist : ", f 3 x ; Print "Die Nullstellen sind : ", Solve f x 0, x ; Print "Die Stellen mit f' x 0 sind : ", Solve f x 0, x ; Print "Die Stellen mit f'' x 0 sind : ", Solve f x 0, x ; Print "Die Stammfunktion von f ist : ", f x x ; Plot f x, x, a, b In[7]:= f x_ : x 3 x In[8]:= kd f, 3, 3

27 Mathematica_4.nb 27 Die 1. Ableitung ist : 1 3 x 2 Die 2. Ableitung ist : 6 x Die 3. Ableitung ist : 6 Die Nullstellen sind : x 1, x 0, x 1 Die Stellen mit f' x 0 sind : x 1 3, x 1 3 Die Stellen mit f'' x 0 sind : x 0 Die Stammfunktion von f ist : x x4 4 Out[8]= Aufruf mit einer namenlosen "pure function" kd 2 2 &, 3, 3

28 28 Mathematica_4.nb 2 x2 Die 1. Ableitung ist : 2 x 2 Die 2. Ableitung ist : 2 x 2 2 x 2 Die 3. Ableitung ist : 6 x x 2 Die Nullstellen sind : x 2, x 2 Die Stellen mit f' x 0 sind : x 2, x 2 x 3 x 4 Die Stellen mit f'' x 0 sind : Die Stammfunktion von f ist : x2 2 Log x Beispiel: Prozedur zur Erzeugung einer Kurvenschar (mit lokalen Variablen) ampl v0_, tmin_, tmax_, color_ : Block x, t, res, lsg, res NDSolve x t x t 0, x 0 0, x 0 v0, x t, t, tmin, tmax ; lsg res; Plot x t. lsg, t, tmin, tmax, PlotStyle color a 1 ampl 0.5, 0, 10, Red ; a 1 ampl 0.5, 0, 10, Red ; a 2 ampl 1.0, 0, 10, Blue ; a 3 ampl 3.0, 0, 10, Green ;

29 Mathematica_4.nb 29 Show Table a i, i, 1, Regeln und Rekursionen 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... In[9]:= term. term neu Out[9]= neu In[10]:= h x, y, z. y alpha Out[10]= h x, alpha, z rekursive Regel, z.b. für Fakultät In[11]:= fac 5. fac 0 1, fac n_ n fac n 1 Out[11]= 5 fac 4 mit //. wird die Regel beliebig häufig angewandt, bis alles aufgelöst ist fac 5. fac 0 1, fac n_ n fac n das nächste Beispiel lässt sich aber auch nach beliebiger Anzahl nicht auflösen, daher ist irgendwann Schluss und es erscheint eine Fehlermeldung

30 30 Mathematica_4.nb fac 5.0. fac 0 1, fac n_ n fac n 1 ReplaceRepeated::rrlim: Exiting after fac 5. scanned times. 0. fac oder automatisch, wenn Regeln global definiert werden. log a_ b_ : log a log b log 2 x y 2 log 2 log x log y 2 log a_ n_ : n log a log 2 log x 2 log y Rekursionen Fibonacci Reihe Fibonacci The F n satisfy the recurrence relation F n F n 1 F n 2 with F 1 F 2 1. f n_ : f n 1 f n 2 f 1 f 2 1; f 3 2 f f 20 Timing 0., 6765

31 Mathematica_4.nb 31 f 30 Timing 1.437, f 32 Timing 3.875, Rekursive Funktionen mit "Gedächtnis" im vorigen Fall steigen die Rechenzeiten mit wachsendem n enorm an, im nächsten Fall merkt man kaum eine Verzögerung g n_ : g n g n 1 g n 2 g 1 g 2 1; g 3 2 g 20 Timing 0., 6765 g 30 Timing 0., g 100 Timing 0., Mustererkennen versciedene Muster (Pattern) Ein Muster (Pattern) ist ein Ausdruck, der besondere Musterobjekte enthalten kann. Das Musterobjekt 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

32 32 Mathematica_4.nb expr expr expr _. _ : a symb_ symb_expr symb symb expr symb symb expr symb_. FullForm _ Blank FullForm BlankSequence FullForm BlankNullSequence FullForm symb expr Pattern symb, BlankNullSequence expr FullForm _. Optional Blank Grundlegende Beispiele Remove f, a, b Zur Illustrierung werden wir jeweils die Muster in einer Regel verwenden. Die Leerstelle _ steht für irgend etwas, aber nur ein einzelnes Symbol oder eine Zahl, keine leere Menge

33 Mathematica_4.nb 33 f x, f y, h z, f x, y, f x, y, z, f. f _ uu uu, uu, h z, f x, y, f x, y, z, f Der für die Leerstelle eingesetzte Ausdruck erhält den Namen t, der dann auf der rechten Seite verwendet wird. Standardfall bei Funktionsdefinitionen, wie oben nur wenn es passt, dann erhält es den Namen t f x, f y, h z, f x, y, f x, y, z, f. f t_ t x, y, h z, f x, y, f x, y, z, f Die doppelte Leerstelle steht für irgendeine Reihe mit ein oder mehreren Elementen f x, f y, h z, f x, y, f x, y, z, f. f uu uu, uu, h z, uu, uu, f Die dreifache Leerstelle steht für irgendeine Reihe mit null oder mehreren Elementen f x, f y, h z, f x, y, f x, y, z, f. f uu uu, uu, h z, uu, uu, uu f x, f y, h z, f x, y, f x, y, z, f. f t t x, y, h z, x, y, x, y, z, Das Muster _:a steht für irgend etwas mit dem Defaultargument a f x, f y, h z, f x, y, f x, y, z, f. f t_: a t 2 x 2, y 2, h z, f x, y, f x, y, z, a 2 Dieses "Muster" passt nur auf sich selbst! Es ist gar kein Muster im eigentlichen Sinn. f x, f y, h z. f x x x, f y, h z Tritt eine Mustervariable zweimal auf, so muss jedes Mal dasselbe ersetzt werden f a, b, f 2, 2, f 3, 3.0. f x_, x_ g x f a, b, g 2, f 3, 3.

34 34 Mathematica_4.nb Mustererkennen für Ausdrücke mit Default-Argument bei einer Summe: x_ y_. ist der Default-Wert y 0 f, f a, f a b, f d c. f x_ y_. p x y f, p a, p a b, p c d bei einem Produkt: x_ y_. ist der Default-Wert y 1 f a, f a b, f b a, f a b c. f x_ y_. p x y p a, p a b, p a b, p a b c ebenso bei einem Exponenten ist der Default-Wert y 1 f a, f a b, f a bc. f x_ y_. p x y p a, p a b, p a bc praktische Beispiele zur Mustererkennung Beispiel 1: vereinfachte Taylorreihe, default: x 0 0 und bis O x 6 PotenzReihe f_, x_: x, x0_: 0, nm_: 6 : Series f, x, x0, nm PotenzReihe Sin x x x3 6 x5 O x PotenzReihe Sin x, x, x x x x x x 1. 6 O x 1. 7 PotenzReihe Sin x, x, 1.0, 3 Normal Expand x x x 3 Beispiel 2: Im ersten Fall passt die Regel nur auf erste Element, im zweiten Fall auf die ersten 3 Elemente

35 Mathematica_4.nb 35 1 x 2 y 2, 1 x 2 y 2, 2 x 2 2 y 2, 2 x 2 y 2. x 2 y 2 : z 2 1 z 2, 1 x 2 y 2, 2 x 2 2 y 2, 2 x 2 y 2 1 x 2 y 2, 1 x 2 y 2, 2 x 2 2 y 2, 2 x 2 y 2. a_. x 2 a_. y 2 a z 2 1 z 2, 1 z 2, 2 z 2, 2 x 2 y 2 Beispiel 3: Wurzel-Regel für positive reelle Zahlen (ähnlich wie PowerExpand) SqrtRules x_ y_ x y, 1 y_ 1 y, x_ y_ x y ; z a b x z b x y a b x z b x y z. SqrtRules a b x z b x y z z a b x z b x y. SqrtRules a y Mustererkennen für Ausdrücke eines Typs: _expr Das Muster Blank[expr], oder _expr, passt nur Ausdrücke mit Kopf expr. expr kann als Datentyp angesehen werden. hier passt nur das 2. Beispiel f a, f 2, f 3.5, f 1 I. f x_integer x 2 f a, 4, f 3.5, f 1

36 36 Mathematica_4.nb hier passt nur das 3. Beispiel f a, f 2, f 3.5, f 1 I. f x_real x 2 f a, f 2, 12.25, f 1 hier passt nur das 4. Beispiel, Complex schließt Real nicht ein f a, f 2, f 3.5, f 1 I. f x_complex x 2 f a, f 2, f 3.5, 2 auch Rational gilt als eigener Zahlen Typ f 2 3, f a, f 2, f 3.5, f 1 I. f x_rational x2 b 4 9, f a, f 2, f 3.5, f 1 b 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. Typische Verwendungsweise: f x_integer?positive : x Information "f", LongForm False Global`f f x_integer? Positive : x f 1, f 0, f 1, f I, f 0.5, f 1 I, f 3 1, f 0, f 1, f, f 0.5, f 1, 3 g x_?nonnegative : x g 1, 0, 1, I, 0.5, 1 I, 3 1, 0, g 1, g, , g 1, 3

37 Mathematica_4.nb 37 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. In[20]:= g x_, y_ : x y ; x y && y 0 In[21]:= g 2, 3, g 3, 3, g 2, 1 Out[21]= 8, g 3, 3, g 2, 1 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 In[12]:= IntegerQ 1, 3, 2., a12, 2 3 Out[12]= True, True, False, False, False In[13]:= EvenQ 1, 2, 3, 4, 5.0, 6. Out[13]= False, True, False, True, False, False In[14]:= PrimeQ 1, 2, 3, 129, 1001 Out[14]= False, True, True, False, False eine mögliche Anwendung, um sicher zustellen, dass in einer Rechnung eine Integerzahl gerade ist In[15]:= even n_ : If OddQ n, n 1, n In[16]:= even 1, 2, 3, 4, 5 Out[16]= 2, 2, 4, 4, 6 in diesem Beispiel werden die Elemente auf ein Muster getestet und alle erfolgreichen Tests gezählt In[17]:= RandomInteger 1, 100, 10 Out[17]= 57, 52, 98, 84, 23, 91, 24, 2, 52, 78

38 38 Mathematica_4.nb In[18]:= Count, _?EvenQ Out[18]= 7 In[19]:= Count, _?PrimeQ Out[19]= 2