1 / 85

Einführung

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}}]. Einführung.

alaqua
Download Presentation

Einführung

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  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 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 f[x_] := 1/15 x^5-1/2 ^4 + 8/9 x^3 Kurvenuntersuchung Nullstellen: f[x] =0 Der Befehle Solvelö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 f[x_] := ½ x^2 Die Fläche unter der Kurve 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 f[x_] := ½ x^2 Die Fläche unter der Kurve Um die Fläche darzustellen, muss ein Package zugeladen werden. Dies geschieht mit: <<Graphics`Master`

  11. Einführung f[x_] := ½ x^2 Die Fläche unter der Kurve 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 f[x_] := ½ x^2 Die Fläche unter der Kurve 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 f[x_] := ½ x^2 Die Fläche unter der Kurve 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, -3.547, 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, -3.547, 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, -3.547, 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 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, -3.547, 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, -3.547, 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, -3.547, 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, -3.547, 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, -3.547, 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, -3.547, 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, -3.547, 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, -3.547, 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, -3.547, 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, -3.547, 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, -3.547, 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, -3.547, 0.992}];

  30. Einführung Der ParametricPlot3D-Befehl Darstellung einer Geraden 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, -3.547, 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 Ebene = ParametricPlot3D[ Append[ {1, 1, 1} + s*{1, 0, 3} + t*{0, 2, -1}, FaceForm[Hue[0.21717164], Hue[0.027164]]] // 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]; 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]] 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}] {0.16807, 0.36015, 0.3087, 0.1323, 0.02835, 0.00243} 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] + 0.3 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}];

More Related