Einführung Die Definition einer Funktion

Präsentation zum Thema: "Einführung Die Definition einer Funktion"—  Präsentation transkript:

1 Einführung Die Definition einer Funktion
f[x_] := 1/15 x^5-1/2 ^4 + 8/9 x^3 Um die Funktion zu zeichnen, benötigt man den Plot-Befehl: Plot[f[x],{x,-3,4}] Günstiger ist es, die Definitions- und die Wertemenge einzuschränken: Plot[f[x],{x,-3,4}, PlotRange->{{-3,4},{-4,2}}]

2 Einführung Abschnittsweise Definition einer Funktion
Bei gebrochen-rationalen Funktionen werden bei den Polstellen senkrechte Geraden gezeichnet. Dieses ist nicht immer erwünscht. Aus diesem Grunde wäre es gut, wenn man bestimmte x-Werte bei der Zeichnung ignorieren könnte. In Mathematica ist dies durch die Definition der Funktion möglich. Und so sieht die Definition aus: f[x_/;x<-2.1] := (x^2 – 2 x – 8)/(x^2-4) f[x_/;x>-1.9&&x<1.9] := (x^2 – 2 x – 8)/(x^2-4) f[x_/;x>2.1] := (x^2 – 2 x – 8)/(x^2-4)

3 Einführung Die Definition einer Funktion
f[x_] := 1/15 x^5-1/2 ^4 + 8/9 x^3 Es gibt noch viele weitere Möglichkeiten, die Graphik sinnvoll zu gestalten: Plot[f[x],{x,-2,5},PlotRange->{{-2,5},{-4,3}}, GridLines->{{-2,-1,1,2,3,4,5},{-4,-3,-2,-1,1,2,3}}, Ticks->{{-2,-1,1,2,3,4,5},{-4,-3,-2,-1,1,2,3}}, DefaultFont->{"Verdana",16},Background->GrayLevel[0.88], PlotStyle->{{Thickness[0.006],Hue[0.8]}, {Thickness[0.006],Hue[0.7]}, {Thickness[0.006],Hue[0.278]}, {Thickness[0.007],Hue[0.924]}}, AxesStyle->{Thickness[0.009]}, AxesLabel->{"x","f(x)"},AspectRatio->1 ];

4 Einführung f[x_] := 1/15 x^5-1/2 ^4 + 8/9 x^3

5 Einführung Plot[{f[x],f‘[x]},……. f[x_] := 1/15 x^5-1/2 ^4 + 8/9 x^3
Will man mehrere Funktionen in ei-nem Koordinatenkreuz darstellen, sind die Funktionen aufzählend in geschweifte Klammern zu schrei-ben. Hier soll die erste Ableitung mit der Ausgangsfunktion dargestellt werden. Die erste Ableitung kann über f‘[x] angesprochen werden: Plot[{f[x],f‘[x]},…….

6 Einführung f7[k_,x_] := x^4 - k x^2
Es ist auch möglich, Funktionen mit mehreren Variablen zu de-finieren. Dies geschieht wie oben angegeben. Um die Funk-tion mit k = -2 zu zeichnen, muss in der Funktionsdefinition der Wert k = -2 eingesetzt werden: f7[-2,x]

7 Einführung f7[k_,x_] := x^4 - k x^2 (Aufgabe 7 auf der Seite 24)
Plot[{f7[-2,x],f7[2,x],- x^4}, {x,-3,3},PlotRange->{{-3,3},{-3,3}}, GridLines->{{-3,-2,-1,1,2,3},{-3,-2,-1,1,2,3}}, Ticks->{{-3,-2,-1,1,2,3},{-3,-2,-1,1,2,3}}, DefaultFont->{"Verdana",16},Background->GrayLevel[0.88], PlotStyle->{{Thickness[0.006],Hue[0.8]}, {Thickness[0.006],Hue[0.7]}, {Thickness[0.006],Hue[0.278]}, {Thickness[0.007],Hue[0.924]}}, AxesStyle->{Thickness[0.009]}, AxesLabel->{"x","f(x)"},AspectRatio->1 ];

8 Einführung Kurvenuntersuchung f[x_] := 1/15 x^5-1/2 ^4 + 8/9 x^3
Nullstellen: f[x] =0 Der Befehle Solve löst die Gleichung nach der angegebenen Variablen auf. Solve[f[x]==0,x] Extremstellen: f‘[x] =0 Solve[f‘[x]==0,x] Wendestellen: f‘‘[x] =0 Solve[f‘‘[x]==0,x]

9 Einführung Die Fläche unter der Kurve f[x_] := 1/2 x^2
Um die Fläche unter der Kurve zu berechnen, gibt es den Befehl Integrate. Syntax: Integrate[1/2 x^2,{x,1,2}] bzw. bei vorheriger Definition der Funktion: f[x_] := 1/2 x^2 Integrate[f[x], {x,1,2}]

10 Einführung Die Fläche unter der Kurve f[x_] := ½ x^2
Um die Fläche darzustellen, muss ein Package zugeladen werden. Dies geschieht mit: <<Graphics`Master`

11 Einführung Die Fläche unter der Kurve f[x_] := ½ x^2
Der Befehl lautet: Graph1=FilledPlot[1/2 x^2, {x,1,2}, PlotRange->{{-1,3},{-1,4}}, Fills->Hue[0.138]]; Damit wird die Fläche zwischen x=1, x=2, dem Graphen und der x-Achse mit der Farbe Hue[0.138] eingefärbt. Es wird nicht der ganze Graph gezeichnet.

12 Einführung Die Fläche unter der Kurve f[x_] := ½ x^2
Mit Hilfe von FilledPlot wird nur der Anteil des Graphen gezeichnet, der zur eingeschlossenen Fläche gehört. Mit Hilfe des normalen Plot-Befehls wird dann der Graph im benötigten Bereich (z.B. von 0 bis 3) gezeichnet. Graph2=Plot[ f[x],{x,0,3}, PlotRange->{{-1,3},{-1,4}}, usw.]

13 Einführung Die Fläche unter der Kurve f[x_] := ½ x^2
Mit Hilfe des Befehls Show können dann beide Graphiken gemeinsam gezeigt werden: Show[{Graph1,Graph2}]

14 Einführung Hausaufgabe f[x_] := (x-1)^2 (x+1)

15 Einführung Das Knox-Package f[x_] := (x-1)^2 (x+1)

16 Einführung Der ParametricPlot3D-Befehl
<<Graphics`ParametricPlot3D` $DefaultFont={"Verdana",16} Um den Befehl ParametricPlot3D benutzen zu können, muss das entsprechende Package geladen werden. Auch die Schriftart sollte man verändern, zumindest die Größe. Ebene1=ParametricPlot3D[ {1, -1, 0} + s*{0, 1, 0} + t*{1, 0, -1}, {s, -10, 10},{t, -10, 10}, PlotRange -> {{-4, 4}, {-4, 4}, {-4, 6}}, AxesStyle -> {Thickness[0.02]}, PlotPoints -> 2, AxesLabel -> {"x", "y", "z"}, FaceGrids -> All, Boxed -> False, ViewPoint -> {0.827, , 0.992}];

17 Einführung Der ParametricPlot3D-Befehl
Ebene1=ParametricPlot3D[ {1, -1, 0} + s*{0, 1, 0} + t*{1, 0, -1}, {s, -10, 10},{t, -10, 10}, PlotRange -> {{-4, 4}, {-4, 4}, {-4, 6}}, AxesStyle -> {Thickness[0.02]}, PlotPoints -> 2, AxesLabel -> {"x", "y", "z"}, FaceGrids -> All, Boxed -> False, ViewPoint -> {0.827, , 0.992}]; {1, -1, 0} + s*{0, 1, 0} + t*{1, 0, -1} Die Ebene wird wie ge-wohnt mit Ortsvektor und den beiden Richtungsvek-toren eingegeben. Die Parameter heißen s und t. Dem Plot wird der Name Ebene1 zugeordnet. {s, -10, 10},{t, -10, 10} Hier wird angegeben, welche Werte die Parameter s und t annehmen sollen

18 Einführung Der ParametricPlot3D-Befehl
Ebene1=ParametricPlot3D[ {1, -1, 0} + s*{0, 1, 0} + t*{1, 0, -1}, {s, -10, 10},{t, -10, 10}, PlotRange -> {{-4, 4}, {-4, 4}, {-4, 6}}, AxesStyle -> {Thickness[0.02],Hue[0.8]}, PlotPoints -> 2, AxesLabel -> {"x", "y", "z"}, FaceGrids -> All, Boxed -> False, ViewPoint -> {0.827, , 0.992}]; PlotRange -> {{-4, 4}, {-4, 4}, {-4, 6}} Mit Hilfe von PlotRange wird der jeweilige x-, y- und z-Bereich angege-ben, in dem die Funktion gezeichnet werden soll. AxesStyle -> {Thickness[0.02],Hue[0.8]} Die Achsen sollen dicker dargestellt werden. Man kann den Achsen auch eine Farbe zuordnen (mit Hue).

19 Einführung Der ParametricPlot3D-Befehl PlotPoints -> 2
Ebene1=ParametricPlot3D[ {1, -1, 0} + s*{0, 1, 0} + t*{1, 0, -1}, {s, -10, 10},{t, -10, 10}, PlotRange -> {{-4, 4}, {-4, 4}, {-4, 6}}, AxesStyle -> {Thickness[0.02],Hue[0.8]}, PlotPoints -> 2, AxesLabel -> {"x", "y", "z"}, FaceGrids -> All, Boxed -> False, ViewPoint -> {0.827, , 0.992}]; PlotPoints -> 2 Um keine Rasterung der Ebene zu erhalten, kann man die Anzahl auf 2 stellen. Normalerweise ist die Einstellung 20. AxesLabel -> {"x", "y", "z"}, FaceGrids -> All, Damit werden die Achsen beschriftet und die Gitterlinien in x-, y- und z-Richtung gezeichnet (kann manchmal ein bisschen unübersichtlich werden).

20 Einführung Der ParametricPlot3D-Befehl
<<Graphics`ParametricPlot3D` $DefaultFont //um den Befehl ParametricPlot3D benutzen zu können, muss das entsprechende Package geladen werden. Auch die Schriftart sollte man verändern, zumindest die Größe. Ebene1=ParametricPlot3D[ {1, -1, 0} + s*{0, 1, 0} + t*{1, 0, -1}, {s, -10, 10},{t, -10, 10}, PlotRange -> {{-4, 4}, {-4, 4}, {-4, 6}}, AxesStyle -> {Thickness[0.02]}, PlotPoints -> 2, AxesLabel -> {"x", "y", "z"}, FaceGrids -> All, Boxed -> False, ViewPoint -> {0.827, , 0.992}]; // Die Ebene wird wie gewohnt mit Ortsvektor und den beiden Richtungsvektoren eingegeben. Die Parameter heißen s und t. Dem Plot wird der Name Ebene1 zugeordnet.

21 Einführung Der ParametricPlot3D-Befehl
Ebene1=ParametricPlot3D[ {1, -1, 0} + s*{0, 1, 0} + t*{1, 0, -1}, {s, -10, 10},{t, -10, 10}, PlotRange -> {{-4, 4}, {-4, 4}, {-4, 6}}, AxesStyle -> {Thickness[0.02]}, PlotPoints -> 2, AxesLabel -> {"x", "y", "z"}, FaceGrids -> All, Boxed -> False, ViewPoint -> {0.827, , 0.992}]; {1, -1, 0} + s*{0, 1, 0} + t*{1, 0, -1}, //Hier wird angegeben, welche Werte die Parameter s und t annehmen sollen. {s, -10, 10},{t, -10, 10} //Mit Hilfe von PlotRange wird der jeweilige x-, y- und z-Bereich angegeben, in dem die Funktion gezeichnet werden soll. PlotRange -> {{-4, 4}, {-4, 4}, {-4, 6}},

22 Einführung Der ParametricPlot3D-Befehl
Ebene1=ParametricPlot3D[ {1, -1, 0} + s*{0, 1, 0} + t*{1, 0, -1}, {s, -10, 10},{t, -10, 10}, PlotRange -> {{-4, 4}, {-4, 4}, {-4, 6}}, AxesStyle -> {Thickness[0.02]}, PlotPoints -> 2, AxesLabel -> {"x", "y", "z"}, FaceGrids -> All, Boxed -> False, ViewPoint -> {0.827, , 0.992}]; // Die Achsen sollen dicker dargestellt werden. Man kann den Achsen auch eine Farbe zuordnen. AxesStyle -> {Thickness[0.02],Hue[0.8]}, //Um keine Rasterung der Ebene zu erhalten, kann man die Anzahl auf 2 stellen. Normalerweise ist die Einstellung 20. PlotPoints -> 2

23 Einführung Der ParametricPlot3D-Befehl
Ebene1=ParametricPlot3D[ {1, -1, 0} + s*{0, 1, 0} + t*{1, 0, -1}, {s, -10, 10},{t, -10, 10}, PlotRange -> {{-4, 4}, {-4, 4}, {-4, 6}}, AxesStyle -> {Thickness[0.02]}, PlotPoints -> 2, AxesLabel -> {"x", "y", "z"}, FaceGrids -> All, Boxed -> False, ViewPoint -> {0.827, , 0.992}]; //Damit werden die Achsen beschriftet und die Gitterlinien in x-, y- und z-Richtung gezeichnet (kann manchmal ein bisschen unübersichtlich werden). AxesLabel -> {"x", "y", "z"}, FaceGrids -> All, //Um die Graphik wird kein Kasten gesetzt. Der Betrachtungspunkt ist so gewählt, dass er mit der Darstellung im Buch übereinstimmt. Boxed -> False, ViewPoint -> {0.827, , 0.992}];

24 Einführung Der ParametricPlot3D-Befehl
Ebene1=ParametricPlot3D[ {1, -1, 0} + s*{0, 1, 0} + t*{1, 0, -1}, {s, -10, 10},{t, -10, 10}, PlotRange -> {{-4, 4}, {-4, 4}, {-4, 6}}, AxesStyle -> {Thickness[0.02]}, PlotPoints -> 2, AxesLabel -> {"x", "y", "z"}, FaceGrids -> All, Boxed -> False, ViewPoint -> {0.827, , 0.992}]; Show[Ebene1,Ebene2, Background -> GrayLevel[0.9], PlotLabel -> "Ebene und Gerade"];

25 Einführung Der ParametricPlot3D-Befehl Ebene1=ParametricPlot3D[
{1, -1, 0} + s*{0, 1, 0} + t*{1, 0, -1}, {s, -10, 10},{t, -10, 10}, PlotRange -> {{-4, 4}, {-4, 4}, {-4, 6}}, AxesStyle -> {Thickness[0.02]}, PlotPoints -> 2, AxesLabel -> {"x", "y", "z"}, FaceGrids -> All,Boxed -> False, ViewPoint -> {0.827, , 0.992}];

26 Einführung Der ParametricPlot3D-Befehl Ebene mit Steuerung der Farben
Ähnlich wie bei der Geraden, hat man mit der oben angegebenen Eingabe keinen Einfluss auf die Farbe der Ebene. Dies ist jedoch auch möglich, nur sieht dann die Eingabe anders aus. Die Eingabe der Gleichung ist identisch, mit FaceForm wird die Farbe der Oberseite bzw. Unterseite angegeben. Weiterhin muss Lighting auf False gesetzt werden. Ebene1=ParametricPlot3D[ Append[{1, 2, 3} + s*{-9, -4, -2} + t*{6, 3, 1}, FaceForm[Hue[0.7164], Hue[0.7164]]] // Evaluate, {s, -10, 10}, {t, -10, 10},Lighting -> False, AxesStyle -> {Thickness[0.02]}, PlotPoints -> 2, PlotRange -> {{-8, 8}, {-8, 8}, {-8, 8}}, AxesLabel -> {"x", "y", "z"}, FaceGrids -> All,Boxed -> False, ViewPoint ->{0.827, , 0.992}];

27 Einführung Der ParametricPlot3D-Befehl Ebene mit Steuerung der Farben
Ebene1=ParametricPlot3D[ Append[{1, 2, 3} + s*{-9, -4, -2} + t*{6, 3, 1}, FaceForm[Hue[0.7164], Hue[0.7164]]] // Evaluate, {s, -10, 10}, {t, -10, 10},Lighting -> False, AxesStyle -> {Thickness[0.02]}, PlotPoints -> 2, PlotRange -> {{-8, 8}, {-8, 8}, {-8, 8}}, AxesLabel -> {"x", "y", "z"}, FaceGrids -> All,Boxed -> False, ViewPoint ->{0.827, , 0.992}];

28 Einführung Der ParametricPlot3D-Befehl Darstellung einer Geraden
//Wenn man mit der voreingestellten Dicke der Geraden und der Farbe (hier: schwarz) zufrieden ist, kann man damit genauso verfahren wie mit der Ebene. Es taucht hier natürlich nur ein Parameter auf. Gerade1=ParametricPlot3D[ {1, -1, 2} + s*{-1, 1, 3} , {s, -10, 10}, PlotRange -> {{-4, 4}, {-4, 4}, {-4, 6}}, AxesStyle -> {Thickness[0.02]}, PlotPoints -> 2, AxesLabel -> {"x", "y", "z"}, FaceGrids -> All, Boxed -> False, ViewPoint -> {0.827, , 0.992}];

29 Einführung Der ParametricPlot3D-Befehl Darstellung einer Geraden
Ist man mit der Dicke bzw. Farbe nicht einverstanden, muss man eine andere Eingabe vornehmen. Die Eingabe erfolgt jetzt einzeln über die gesamten x-, y- und z-Komponenten. ParametricPlot3D[ {2s, 1 + s, 3 + 2s, {Thickness[0.015], Hue[0.98]}}, {s, -20, 20}, Lighting -> False, AxesStyle -> {Thickness[0.02]}, PlotRange -> {{-10, 10}, {-10, 10}, {-10, 10}}, AxesLabel -> {"x", "y", "z"}, FaceGrids -> All, Boxed -> False, ViewPoint -> {0.827, , 0.992}];

30 Einführung Der ParametricPlot3D-Befehl Darstellung einer Geraden
{2s, 1 + s, 3 + 2s, {Thickness[0.015], Hue[0.98]}}, {s, -20, 20}, Lighting -> False, AxesStyle -> {Thickness[0.02]}, PlotRange -> {{-10, 10}, {-10, 10}, {-10, 10}}, AxesLabel -> {"x", "y", "z"}, FaceGrids -> All, Boxed -> False, ViewPoint -> {0.827, , 0.992}];

31 Einführung Der ParametricPlot3D-Befehl Schnittgerade zweier Ebenen
Wenn man die Schnittgerade zweier Ebenen berechnen will, müssen die entsprechenden Variablen eliminiert werden. Dies geschieht mit folgendem Befehl: Eliminate[ {1,2,3}+s1*{-1,2,0}+t1*{1,1,-1}== {0,1,-2}+s2*{0,1,-1}+t2*{-1,-1,2}, {s1,t1}] Damit wird s2 in Abhängigkeit von t2 oder umgekehrt ausgegeben. Ergebnis: Löst man nach s2 auf, so ergibt sich: s2 = 3/2 (t2 – 6 )

32 Einführung Darstellung von Punkten im R3
Der Punkt ist ein dreidimensionales Grafikobjekt, er gehört zu den sog. Grafik-Primitiven. Andere Grafik-Primitiven sind Line, Polygon, Cuboid und Text. Diese werden mit Show[Graphics3D[..]] dargestellt. Am Beispiel von Point soll dies exemplarisch gezeigt werden Show[ Graphics3D[ {PointSize[0.05],Point[{1,1,1}]} ] Angegeben werden muss mindestens die Größe des Punktes. Um die Lage des Punktes anzugeben werden die Koordinaten in geschweiften Klammern aufgezählt.

33 Einführung Darstellung von Punkten im R3 Show[ Graphics3D[
{PointSize[0.05],Point[{1,1,1}]} ] Der Punkt wird in der einfachsten Syntax schwarz dargestellt, lediglich der Kasten für die drei Koordinaten wird gezeichnet. Es gibt aber weitere Möglichkeiten, um die Darstellung zu optimieren. So kann man z.B. die Farbe des Punktes verändern. Show[ Graphics3D[ {Hue[0.98],PointSize[0.05], Point[{1,1,1}]} ]

34 Einführung Darstellung von Punkten im R3
Als Attribute können diejenigen verwendet werden, die in z.B. ParametricPlot3D vorhanden sind. Show[Graphics3D[ {Hue[0.698], PointSize[0.05], Point[{1, 1, 1}]}, DefaultFont -> {"Verdana", 18}, Axes -> True, ViewPoint -> {-2.860, 1.922, 1.161}, PlotRange -> {{-8, 5}, {-8, 5}, {-8, 5}}, AxesLabel -> {"x", "y", "z"}, AxesStyle -> {Thickness[0.02]}, FaceGrids -> All, Boxed -> False]]

35 Einführung Darstellung von Punkten im R3 Show[Ebene, Punkt]
Punkt = Show[ Graphics3D[{Hue[0.698], PointSize[0.08], Point[{1, 1, 1}]}, DefaultFont -> {"Verdana", 18}, Axes -> True, AxesStyle -> {Thickness[0.02]}, ViewPoint -> {-2.860, 1.922, 1.161}, PlotRange -> {{-8, 5}, {-8, 5}, {-8, 5}}, AxesLabel -> {"x", "y", "z"}, FaceGrids -> All, Boxed -> False]] Ebene = ParametricPlot3D[ Append[ {1, 1, 1} + s*{1, 0, 3} + t*{0, 2, -1}, FaceForm[Hue[ ], Hue[ ]]] // Evaluate, {s, -10, 10}, {t, -10, 10}, Lighting -> False, ViewPoint -> {-2.860, 1.922, 1.161}, AxesStyle -> {Thickness[0.02]}, PlotPoints -> 2, DefaultFont -> {"Verdana", 18}, PlotRange -> {{-8, 5}, {-8, 5}, {-8, 5}}, AxesLabel -> {"x", "y", "z"}, FaceGrids -> All, Boxed -> False]; Show[Ebene, Punkt]

36 Einführung Darstellung von Punkten im R3 Show[Ebene, Punkt]

37 Einführung Drehen mit RealTime3D
Der Befehl <<RealTime3D` bewirkt, dass jede 3-D-Graphik mit Hilfe der Maus gedreht werden kann. Um wieder zum normalen Modus zurückzukehren, muss der Befehl <<Default3D` eingegeben werden. Probleme: Fast alle Formatierungen werden leider ignoriert. Wählt man z.B. eine xyz-Ansicht, wo alle Richtungen in einem optimalen Maßstab die Graphik darstellen, so wird dieses bei RealTime3D aufgelöst. Wird noch ergänzt

38 Einführung Binomial-Verteilung
Um die Befehle BarChart und Binomial verwenden zu können, müssen diese beiden Packages zugeladen werden << Statistics`DiscreteDistributions` << Graphics`Graphics` Binomial[7,3] Ausgabe: 35 Dieser Befehl berechnet den Binomialkoeffizienten:

39 Einführung Binomial-Verteilung
Um die Berechnung der Wahrscheinlichkeiten durchzuführen, definiert man sich eine Binomial-verteilungsfunktion. BW[p_, n_, k_] := Binomial[n, k]*p^k*(1 - p)^(n - k) Mit dem Aufruf z.B. von BW[0.4,10,3] kann dann die entsprechende Wahrscheinlichkeit bestimmt werden. BW[0.4,10,3] Ausgabe: 0,214991

40 Einführung Binomial-Verteilung
Für die graphische Darstellung der Verteilung müssen jedoch alle Wahrscheinlichkeiten berechnet werden. Table[{xwert,1/2*xwert*xwert},{xwert,-2,2,0.5}] //TableForm Dies kann mit dem Befehl Table durchgeführt werden. In der ersten geschweiften Klammer werden die zu berechnenden Terme angegeben. In der zweiten ge-schweiften Klammer steht folgendes: Variablenname, erster Wert, letzter Wert und die Schrittweite (hier von -2 bis 2 und der Schrittweite 0.5)

41 Einführung Binomial-Verteilung
Im Falle der zu berechnenden Wahrscheinlichkeiten lautet der Table-Befehl WV = Table[BW[0.3, 5, k], {k, 0, 5}] { , , , , , } Diese berechneten Werte sind in der Variablen WV gespeichert. Diese müssen jetzt noch mit dem Befehl BarChart graphisch dargestellt werden.

42 Einführung Binomial-Verteilung
BarChart[WV, BarLabels -> {0, 1, 2, 3, 4, 5}, BarStyle -> {Hue[0.12]}, DefaultFont -> {"Verdana", 16}, Background -> GrayLevel[0.88], AxesStyle -> {Thickness[0.009]}, PlotLabel -> "Wahrscheinlichkeitsverteilung", GridLines -> Automatic]

43 Einführung Binomial-Verteilung Bestimme die Wahrscheinlichkeiten von
n = 10; p = 0,3; P( 4  X  7) Man benötigt die bekannte Funktion : BW[p_, n_, k_] := Binomial[n, k]*p^k*(1 - p)^(n - k) Der Aufruf zur Berechnung lautet dann: WV = Table[BW[0.3, 10, k], {k, 4,7}] – Dieser Table-Befehl berechnet die Wahrscheinlicheiten für k = 4 bis 7. Anschließend müssen diese in einer Liste zusammengefassten Wahrscheinlichkeiten noch addiert werden. Dies geschieht mit: Apply[Plus,WV]

44 Einführung Das Knox-Package
AppendTo[$Path, c:\sporenberg\mathematica\knox4\\"] << commonfu.m << Calculus.m << linearal.m << quadrics.m Um das Knox-Package zu laden, muss der entsprechende Pfad angegeben werden. Dann müssen die einzelnen Packages geladen werden. graph = PlotTangentLine[1.8^x, {x, -1, 5}, PlotRange -> {{-1, 5}, {-1, 8}}, GridLines ->{ -1, 1, 2, 3, 4, 5}, -1, 1, 2, 3, 4, 5, 6, 7, 8}}, Ticks -> ->{ -1, 1, 2, 3, 4, 5}, -1, 1, 2, 3, 4, 5, 6, 7, 8}}, DefaultFont -> {"Verdana", 18}, Background -> GrayLevel[0.92], PlotStyle -> {{Thickness[0.01], Hue[0.738]}, {Thickness[0.009], Hue[0.7]}}, AxesStyle -> {Thickness[0.01]}, AxesLabel -> {"x", "f(x)"}, AspectRatio -> Automatic, TangentPoints -> {1}, TangentStyle -> {{Thickness[0.01], GrayLevel[0.2]}} ];

45 Einführung Das Knox-Package
Die zusätzlichen Befehle geben den x-Wert des Punktes an, in dem die Tangente gezeichnet werden soll. Zusätzlich könne noch die Dicke des Graphen sowie die Farbe angegeben werden. TangentPoints -> {1}, TangentStyle -> {{Thickness[0.01], Hue[0.15]}}

46 Einführung Das Knox-Package
Es können auch mehrere Punkte angegeben werden. Dies geschieht aufzählend. TangentPoints -> {1,2}, TangentStyle -> {{Thickness[0.01], Hue[0.15]}, {Thickness[0.01], Hue[0.25]}}

47 Einführung Das Knox-Package
Um ein Steigungsdreieck einzuzeichnen, muss mit Hilfe des Line-Befehls jeweils die entsprechende Linie gezeichnet werden. Linie1 = Line[{{1, 1.8^1}, {3, 1.8^3}}]; Linie2 = Line[{{1, 1.8^1}, {3, 1.8^1}}]; Linie3 = Line[{{3, 1.8^1}, {3, 1.8^3}}];

48 Einführung Das Knox-Package
Mit Hilfe von Show können dann verschiedene Graphiken zusammen dargestellt werden. Show[graph, {Graphics[{{Thickness[0.01], Hue[0.8], Linie1}}]}, {Graphics[{{Thickness[0.01], Hue[0.8], Linie2}}]}, {Graphics[{{Thickness[0.01], Hue[0.8], Linie3}}]} ];

49 Einführung Das Knox-Package PlotMidpointApprox[
3*E^(-1/2*x), {x, 0, 4, 4}, PlotRange -> {{0, 4}, {0, 3}}, AreaStyle -> Hue[0.762], PlotStyle -> {Thickness[0.0051], Hue[0.192]}, AxesStyle -> Thickness[0.008]}, {"Verdana", 18}, Background -> GrayLevel[0.088], PlotLabel -> "Flaechenberechnung", AxesLabel -> {"x", "f(x)"}]

50 Einführung Differenzialgleichungen
Mit Hilfe von NDSolve können Dif-ferentialgleichungen numerisch gelöst werden. Diff1=NDSolve[{x‘‘[t] x‘[t] + x[t]==0, x[0]==2,x‘[0]==0}, x[t], {t,0,20}] Mit Hilfe von Plot und Evaluate kann die Funktion gezeichnet werden Plot[Evaluate[x[t]/Diff1,{t,0,20}];

51 Einführung Differenzialgleichungen
Diff2=NDSolve[{x‘‘[t] + x[t] ==0, y‘‘[t] +2 y[t] ==0, x[0]==2, x‘[0]==0, y[0]==2, y‘[0]==0}, {x[t], y[t]}, {t,0,40}] Mit Hilfe von Plot und Evaluate können die Funktionen gezeichnet werden Plot[Evaluate[{x[t],y[t]}/Diff2,{t,0,20}];

52 Einführung Auswertung von Messreihen
Die gleichmäßig beschleunigte Bewegung Zeit in s 1,6087 2,3001 2,8012 3,2283 3,6185 3,9823 4,283 Zurückgelegter Weg 0,1 0,2 0,3 0,4 0,5 0,6 0,7 Diese Werte werden als Liste einer Variablen zugeordnet: DatenReihe={{0,0},{1,6087,0.1},{2.3001,0.2},{2.8012,0.3},{3.2283,0.4}, {3.6185,0.5},{3.9823,0.6},{4.283,0.7}} Mit Fit sucht Mathematica eine quadratische Gleichung, die diesen Werten am nächsten kommt. Die Funktion, die durch die gemessenen Punkte gehen soll, hat die Funktionsgleichung: f(x) = a * x2. Fitplot= Fit[Datenreihe, {x^2},x]

53 Einführung Auswertung von Messreihen
Die gleichmäßig beschleunigte Bewegung Mit Fit sucht Mathematica eine quadratische Gleichung, die diesen Werten am nächsten kommt. Fitplot= Fit[Datenreihe, {x^2},x] Die Funktion, die durch die gemessenen Punkte gehen soll, hat die Funktionsgleichung: f(x) = a * x2. d.h. die quadratische Funktion geht auf jeden Fall durch den Nullpunkt. Mit Hilfe der Fit-Funktion wird der Parameter a bestimmt Sollen die Messwerte durch eine allgemeine Funktion 2. Grades angenähert werden ( f(x) = a x2 + b x + c), so lautet der Fitbefehl: Fitplot= Fit[Datenreihe, {1,x,x^2},x] – dieses würde jedoch der Auswertung nicht gerecht werden, da die Kurve durch O(0/0) gehen muss

54 Einführung Auswertung von Messreihen
Die gleichmäßig beschleunigte Bewegung Fitplot= Fit[Datenreihe, {x^2},x] plot1 = ListPlot [Datenreihe, PlotRange -> {{0, 5}, {0, 0.7}}, PlotStyle -> {PointSize[0.03], RGBColor[1, 0, 0]}, DefaultFont -> {"Verdana", 18}, Background -> GrayLevel[0.9], AxesStyle -> {RGBColor[0, 0, 1], Thickness[0.01]}, GridLines -> Automatic, PlotLabel -> "Gleichm. beschl. Bewegung", AxesLabel -> {"t in s", "s in m"}]; Mit Hilfe des Befehls ListPlot werden die Datenpunkte der Datenreihe angezeigt.

55 Einführung Auswertung von Messreihen
Die gleichmäßig beschleunigte Bewegung Mit Hilfe des Befehls ListPlot werden die Datenpunkte der Datenreihe angezeigt.

56 Einführung Auswertung von Messreihen
Die gleichmäßig beschleunigte Bewegung plot2 = Plot[Fitplot, {x, 0, 5}, PlotRange -> {{0, 5}, {0, 0.7}}, DefaultFont -> {"Verdana", 18}, Background -> GrayLevel[0.9], PlotStyle -> {{Thickness[0.01], Hue[0.3]}, {Thickness[0.01], Hue[0.7]}}, AxesStyle -> {RGBColor[0, 0, 1], Thickness[0.01]}, GridLines -> Automatic, PlotLabel -> "Gleichm. beschl. Bewegung", AxesLabel -> {"t in s", "s in m"}]; Mit Hilfe des Plot-Befehls wird die Fit-Kurve gezeichnet.

57 Einführung Auswertung von Messreihen
Die gleichmäßig beschleunigte Bewegung Mit Hilfe des Plot-Befehls wird die Fit-Kurve gezeichnet.

58 Einführung Auswertung von Messreihen
Die gleichmäßig beschleunigte Bewegung Mit Hilfe von Show können jetzt beide Kurven übereinandergelegt werden. Show[plot2,plot1];

59 Einführung Auswertung von Messreihen
Das radioaktive Element Barium zerfällt. Zeit in min 1 2 3 4 5 6 Anzahl 1050 795 600 460 345 260 220 Es handelt sich hierbei um eine e-Funktion. Aus diesem Grund muss das Paket NonlinearFit zugeladen werden mit: <<Statistics`NonlinearFit` Der Befehl lautet NonlinearFit und hat folgende Syntax: NonlinearFit [Daten, Funktion(en), Variable, Parameter] Beim obigen Beispiel sähe das so aus: NonlinearFit[DatenBarium,a E^(-b x),x,{a,b}] DatenBarium={{0,1050},{1,795},{2,600},{3,460},{4,345},{5,260},{6,220}}

60 Einführung Auswertung von Messreihen
Mit Hilfe des Befehls NonlinearFit wird die entspre-chende Funktion erzeugt. BariumFunktion = NonlinearFit[DatenBarium, a E^(-b x), x, {a, b}] Ergebnis: e x Der Funktionsterm ist in der Variablen BariumFunktion gespeichert und kann mit Hilfe des Plot-Befehls gezeichnet werden.

61 Einführung Auswertung von Messreihen
BariumPlot = Plot[BariumFunktion, {x, 0, 10}, PlotRange -> {{0, 10}, {0, 1100}}, PlotStyle -> {Thickness[0.01], RGBColor[0, 0, 1]}, DefaultFont -> {"Verdana", 18}, GridLines -> Automatic, PlotLabel -> "Radioaktiver Zerfall", AxesLabel -> {"t in s", "Impulse"}];

62 Einführung Auswertung von Messreihen
Die einzelnen Messpunkte sollen jetzt dargestellt werden, um einen Vergleich mit der berechneten Funktion zu ermöglichen. Dieses geschieht mit dem ListPlot-Befehl: Plot1=ListPlot[DatenBarium, PlotStyle -> {PointSize[0.03], RGBColor[1, 0, 0]}, DefaultFont -> {"Verdana", 16}, Background -> GrayLevel[1], GridLines -> Automatic, PlotLabel -> "Radioaktiver Zerfall", AxesLabel -> {"t in s", "Impulse/10 s"}];

63 Einführung Auswertung von Messreihen Show[BariumPlot, Plot1]
Die Messpunkte und die e-Funktion, die aus den Messpunkten gebildet worden ist, können mit Hilfe von Show zusammen dargestellt werden. Show[BariumPlot, Plot1]

64 Einführung Auswertung von Messreihen
In der Physik werden häufig e-Funktionen halblogarithmisch dar-gestellt. Dies bedeutet, dass die x-Achse line-ar, die y-Achse aber logarithmisch einge-teilt wird. Der Vorteil ist, dass der Graph in dieser Darstellung eine Gerade ergibt.

65 Einführung Auswertung von Messreihen Dazu muss das gesamte Paket
<<Graphics`Graphics` geladen werden. Jetzt sind die beiden Befehle LogListPlot und LogPlot verfügbar. plot1Log = LogListPlot[datenBarium,PlotStyle->{PointSize[0.03],RGBColor[0,0,1]}, DefaultFont -> {"Verdana", 16}, Background -> GrayLevel[1], GridLines -> Automatic, PlotLabel -> "Radioaktiver Zerfall", AxesLabel -> {"t in min", "Impulse/10 s"}];

66 Einführung Text im Mathematica-Plot
Mit den beiden Befehlen FontForm und Text ist es möglich, einen Text an jede beliebige Stelle des Graphen zu positionieren.

67 Einführung Text im Mathematica-Plot
Mit Hilfe des Befehls FontForm wird der Text und die Schriftart/Schrift-größe definiert, abgespeichert in der Variablen text1. text1 = FontForm["Fläche unter der Kurve", {"Arial Black", 22}]; Mit Hilfe des Befehls Text wird die Farbe und die Position in der Graphik festgelegt, abgespeichert in der Variablen signum1. signum1 = {RGBColor[0.9, 0, 0], Text[text1, {0.7, 5}]}; Mit Hilfe von Show können dann alle Graphikelemente gleichzeitig angezeigt werden. Show[{graph1}, Graphics[{signum1, signum2, signum3}]];

68 Einführung Text im Mathematica-Plot
graph1 = FilledPlot[1/x^2, {x, 0.5, 1}, Fills -> CMYKColor[0, 0, 1, 0], PlotRange -> {{0, 1.5}, {-1.8, 8}}, DefaultFont -> {"Verdana", 16}, Background -> GrayLevel[1], GridLines -> {{0, 0.5, 1.0, 1.5}, {2, 4, 6, 8}}, Ticks -> {{0, 0.5, 1.0, 1.5}, {2, 4, 6, 8}}, PlotStyle -> {{Thickness[0.01], Hue[0.828]}}, AxesStyle -> {Thickness[0.009]}]; text1 = FontForm["Fläche unter der Kurve", {"Arial Black", 22}]; text2 = FontForm["Radius 1", {"Verdana", 14}]; text3 = FontForm["Radius 2", {"Verdana", 14}]; signum1 = {RGBColor[0.9, 0, 0], Text[text1, {0.7, 5}]}; signum2 = {RGBColor[0.3, 0.3, 1.0], Text[text2, {0.5, -1.2}]}; signum3 = {RGBColor[0.3, 0.3, 1.0], Text[text3, {1, -1.2}]}; Show[{graph1}, Graphics[{signum1, signum2, signum3}]];

69 Einführung Orbitale P[n_, l_, m_, {x_, y_, z_}] :=
Module[{r = Sqrt[x^2 + y^2+z^2]}, 4 Pi r^2(Exp[-r/n]r^l LaguerreL[n l, 2l + 1, 2 r/n])^2 Abs[ SphericalHarmonicY[l, m, ArcCos[z/r], ArcTan[x, y]]]^2]; DensityPlot[Evaluate[ P[3, 1, 0, {x, 0, z}]], {x, -20, 20}, {z, -20, 20}, ColorFunction -> (Hue[1 - #] &), Mesh -> False, PlotPoints -> 275, Frame -> False];

70 Einführung Taylorreihen – Version 1 g3 = Series[Sin[x], {x, 0, 3}]
f3[x_] = Normal[g3] f5[x_] = Normal[g5] Plot[{Sin[x], f3[x], f5[x]}, {x, -4 Pi, 4 Pi}, PlotRange -> {{-4, 4}, {-1.5, 1.5}}, DefaultFont -> {"Verdana", 16}, GridLines -> Automatic, Background -> GrayLevel[0.083], PlotStyle -> {{Thickness[0.008], Hue[0.18]}, {Thickness[0.008], Hue[0.0816]}, {Thickness[0.006], Hue[0.68]}, {Thickness[0.006], Hue[0.924]}}];

71 Einführung Taylorreihen Plot[{Sin[x], f3[x], f5[x]}, {x, -4 Pi, 4 Pi},
PlotRange -> {{-4, 4}, {-1.5, 1.5}}, DefaultFont -> {"Verdana", 16}, GridLines -> Automatic, Background -> GrayLevel[0.083], PlotStyle -> { {Thickness[0.008], Hue[0.18]}, {Thickness[0.008], Hue[0.086]}, {Thickness[0.006], Hue[0.68]}, {Thickness[0.006], Hue[0.924]}} ];

72 Einführung Taylorreihen – Version 2
f1[x_, n_] := Normal[Series[E^x, {x, 0, n}]] Plot[Evaluate[Flatten[{E^x, Table[f1[x, n], {n, 1, 4, 1}]}]], {x, -4, 4}, PlotRange -> {{-3, 3}, {0, 6}}, DefaultFont -> {"Verdana", 18}, GridLines -> Automatic, Background -> GrayLevel[0.083], PlotStyle -> {{Thickness[0.006], Hue[0.128]}, {Thickness[0.006], Hue[0.0816]},{Thickness[0.006], Hue[0.308]}, {Thickness[0.006], Hue[0.924]},{Thickness[0.005], Hue[0.728]}}];

73 Einführung Taylorreihen – Version 2
Plot[Evaluate[Flatten[{E^x, Table[f1[x, n], {n, 1, 4, 1}]}]], {x, -4, 4}, PlotRange -> {{-3, 3}, {0, 6}}, DefaultFont -> {"Verdana", 18}, GridLines -> Automatic, Background -> GrayLevel[0.083], PlotStyle -> {{Thickness[0.006], Hue[0.128]}, {Thickness[0.006], Hue[0.0816]}, {Thickness[0.006], Hue[0.308]}, {Thickness[0.006], Hue[0.924]}, {Thickness[0.005], Hue[0.728]}}];

74 Einführung Vollständige Kurvendiskussion Needs["Calculus`Limit`"];
ft = FormatType -> TraditionalForm; sy = t[0]; nst = Solve[t[x] == 0, x]; nst = nst  nst; d = 1; While[d <= Length[nst], If[Im[x /. nst[[d]]] != 0, nst = Drop[nst, {d}]; d = 0]; d++]; d = 1; While[d <= Length[nst], If[! TrueQ[(x /. nst[[d]])  Rationals] && runden == 1, nst[[d]] = N[nst[[d]], 3]]; d++] est = Solve[t'[x] == 0, x]; est = est  est; e = 1; While[e <= Length[est], If[Im[x /. est[[e]]] != 0, est = Drop[est, {e}]; e = 0]; e++]; e = 1; While[e <= Length[est], If[! TrueQ[(x /. est[[e]])  Rationals] && runden == 1, est[[e]] = N[est[[e]], 3]]; e++] epr = t''[x] /. est;

75 Einführung Vollständige Kurvendiskussion ept = Flatten[t[x] /. est];
wst = Solve[t''[x] == 0, x]; wst = wst  wst; While[f <= Length[wst], If[Im[x /. wst[[f]]] != 0, wst = Drop[wst, {f}]; f = 0]; f++]; f = 1; While[f <= Length[wst], If[! TrueQ[(x /. wst[[f]])  Rationals] && runden == 1, wst[[f]] = N[wst[[f]], 3]]; f++] wpr = Flatten[t'''[x] /. wst]; wpt = Flatten[t[x] /. wst]; asym = TrueQ[t[-x] == t[x]]; psym = TrueQ[t[-x] == -t[x]]; limp = Limit[t[x], x -> ]; limn = Limit[t[x], x -> -];

76 Einführung Vollständige Kurvendiskussion
Print["Zu diskutieren war die Funktion f(x) = " <> ToString[t[x], ft]] Print["Sie besitzt " <> ToString[Length[nst]] <> " reelle Nullstellen(n), nämlich " <> ToString[x /. nst, ft]] Print["Die Schnittpunkte mit der Ordinatenachse (= x-Achse) sind (0;" <> ToString[sy, ft] <> ")."] a = 1; While[a <= Length[est], Print["Sie besitzt " <> ToString[ If[epr[[a]] < 0, "ein Maximum", If[epr[[a]] > 0, "ein Minimum", "einen Sattelpunkt"]]] <> " im Punkt (" <> ToString[x /. est[[a]], ft] <> "; " <> ToString[ept[[a]], ft] <> ")"]; a++] c = 1; While[c <= Length[wst], If[wpr[[c]] == 0, Drop[wst, {c}]; Drop[wpt, {c}]]; c++]; b = 1;

77 Einführung Vollständige Kurvendiskussion If[Length[wst] == 0,
Print["Sie besitzt keine Wendestellen."], Print["Sie besitzt " <> ToString[Length[wst]] <> " Wendepunkte(e), und zwar: "]; While[b <= Length[wst], Print[ "(" <> ToString[x /. wst[[b]], ft] <> "; " <> ToString[wpt[[b]], ft] <> "),"]; b++]] Print["Sie ist " <> If[! asym, "nicht ", ""] <> "achsensymmetrisch zur Ordinatenachse (= x-Achse)."] Print["Sie ist " <> If[! psym, "nicht ", ""] <> "punktsymmetrisch zum Koordinatenursprung."] Print["Wenn x gegen + geht, nähern sich die Funktionswerte " <> ToString[limp, ft] <> "."] Print["Wenn x gegen - geht, nähern sich die Funktionswerte " <> ToString[limn, ft] <> "."]

78 Einführung Vollständige Kurvendiskussion
Plot[{t[x], t'[x]}, {x, Min[{If[Length[nst] != 0, x /. nst, 0], If[Length[est] != 0, x /. est, 0], If[Length[wst] != 0, x /. wst, 0], 0}] - 2, Max[{If[Length[nst] != 0, x /. nst, 0], If[Length[wst] != 0, x /. wst, 0], 0}] + 2}, AxesOrigin -> {0, 0}, DefaultFont -> {"Verdana", 16}, GridLines -> Automatic, Background -> GrayLevel[0.083], PlotStyle -> {{Thickness[0.007], Hue[ ]}, {Thickness[0.006], Hue[0.1216]}, {Thickness[0.007], Hue[0.78]}, {Thickness[0.007], Hue[0.924]}, {Thickness[0.005], Hue[0.68]}}, AxesLabel -> {"x", "f(x)"},

79 Einführung Vollständige Kurvendiskussion PlotRange -> {
{Min[{If[Length[nst] != 0, x /. nst, 0], If[Length[est] != 0, x /. est, 0], If[Length[wst] != 0, x /. wst, 0], 0}] - 1, Max[{If[Length[nst] != 0, x /. nst, 0], If[Length[wst] != 0, x /. wst, 0], 0}] + 1}, {Min[{If[Length[ept] != 0, ept, 0], If[Length[wst] != 0, wpt, 0], 0}] - 2, Max[{If[Length[ept] != 0, ept, 0], If[Length[wst] != 0, wpt, 0], 0}] + 2} }];

80 Einführung Vollständige Kurvendiskussion
Die Funktion wird als t[x_] eingegeben, z.B. t[x_] := 1/2 x^ x^3 + 3x – 5 Will man keine Dezimalwerte haben, z.B. für die Koordinaten der Nullstellen, so müssen die Vorfaktoren bei der Eingabe von t[x] entsprechend eingegeben werden

81 Einführung Vollständige Kurvendiskussion
t[x_] := 1/2 x^ x^3 + 3x – 5 Rot: t[x] Gelb: t‘[x]

82 Einführung Lösung von Ungleichungen
Das Lösen von Ungleichungen ist nicht so einfach wie man es sich vorstellen würde. Der Befehl Solve kann nämlich nicht verwendet werden. Vielmehr muss ein Standardpackage geladen werden. Dies geschieht mit: << Algebra`InequalitySolve` Der eigentliche Befehl ist InequalitySolve. InequalitySolve[ t + t^2 > 0, t] Ausgabe ist dann: Dabei bedeutet: | |  oder

83 Einführung Line – ein zweidimensionales Graphik-Element
Mit Hilfe des Line-Befehls können Linien gezeichnet werden. Die entsprechende Syntax lautet: Line[{{x1,y1},{x2,y2}}] Hier wird eine Linie durch die Punkte P1(x1/y1) und P2(x2,y2) gezogen. Show[Graphics[ {{Thickness[0.015], Hue[0.81], Line[{{1, 1}, {1, 4}}] } }, Axes -> True, AxesStyle -> {Thickness[0.02]}, DefaultFont -> {"Verdana", 16} ] ] Mit Hilfe von Graphics und Show kann die Linie angezeigt werden. Wie man sieht, sind auch alle anderen Optionen bei der Graphikausgabe möglich, z.B. die Formatierung der Linie, Schriftart etc. Es ist darauf zu achten, dass Axes-> True angegeben werden muss, wenn das Koordinatenkreuz mitgezeichnet werden soll

84 Einführung Line – ein zweidimensionales Graphik-Element
Show[Graphics[ {{Thickness[0.015], Hue[0.81], Line[{{1, 1}, {1, 4}}] } }, Axes -> True, AxesStyle -> {Thickness[0.02]}, DefaultFont -> {"Verdana", 16} ] ]

85 Einführung Wichtige Befehle Clear["context`* "]
Löschen aller Variablen: Clear["context`* "] Clear["Global`* "] Einen Pfad festlegen, um auf Packages zugreifen zu können AppendTo[$Path, "c:\mathematica\Unterverzeichnis\\ “]