Upload
anton-weitekamp
View
108
Download
0
Embed Size (px)
Citation preview
EinführungDie 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ührungAbschnittsweise 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)
5 4 3 2 1 1 2 3 4 5x
5
4
3
2
1
1
2
3
4
5
fx
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
];
Einführung
f[x_] := 1/15 x^5-1/2 ^4 + 8/9 x^3
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]},…….
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]
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
];
Einführung
f[x_] := 1/15 x^5-1/2 ^4 + 8/9 x^3
Kurvenuntersuchung Nullstellen: f[x] =0Der Befehle Solve löst die Gleichung nach der angegebenen Variablen auf.Solve[f[x]==0,x]
Extremstellen: f‘[x] =0Solve[f‘[x]==0,x]
Wendestellen: f‘‘[x] =0Solve[f‘‘[x]==0,x]
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^2Integrate[f[x], {x,1,2}]
Einführung
f[x_] := ½ x^2
Die Fläche unter der KurveUm die Fläche darzustellen, muss ein Package zugeladen werden. Dies geschieht mit:
<<Graphics`Master`
Einführung
f[x_] := ½ x^2
Die Fläche unter der KurveDer 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.
Einführung
f[x_] := ½ x^2
Die Fläche unter der KurveMit 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.]
Einführung
f[x_] := ½ x^2
Die Fläche unter der KurveMit Hilfe des Befehls Show können dann beide Graphiken gemeinsam gezeigt werden:
Show[{Graph1,Graph2}]
Einführung
f[x_] := (x-1)^2 (x+1)
Hausaufgabe
Einführung
f[x_] := (x-1)^2 (x+1)
Das Knox-Package
Einführung
<<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}];
EinführungDer ParametricPlot3D-Befehl
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.
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}
{s, -10, 10},{t, -10, 10}
Hier wird angegeben, welche Werte die Parameter s und t annehmen sollen
EinführungDer ParametricPlot3D-Befehl
Mit Hilfe von PlotRange wird der jeweilige x-, y- und z-Bereich angege-ben, in dem die Funktion gezeichnet werden soll.
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}}
AxesStyle -> {Thickness[0.02],Hue[0.8]}
Die Achsen sollen dicker dargestellt werden. Man kann den Achsen auch eine Farbe zuordnen (mit Hue).
EinführungDer ParametricPlot3D-Befehl
Um keine Rasterung der Ebene zu erhalten, kann man die Anzahl auf 2 stellen. Normalerweise ist die Einstellung 20.
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
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).
EinführungDer 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.
EinführungDer 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}},
EinführungDer 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
EinführungDer 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}];
EinführungDer 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"];
EinführungDer 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}];
4 2 0 2 4x
4
2
0
24
y
4
2
0
2
4
6
z
4 2 0 2 4x
EinführungDer 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}];
EinführungDer 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}];
5 0 5x
5
0
5
y
5
0
5
z
5 0 5x
EinführungDer 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}];
EinführungDer 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}];
EinführungDer 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}];
10 5 0 5 10x1050510
y10
5
0
5
10
z
10 5 0 5 10x
EinführungDer 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.
EinführungDer ParametricPlot3D-Befehl
36 t2 2s2Ergebnis:
Löst man nach s2 auf, so ergibt sich: s2 = 3/2 (t2 – 6 )
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
EinführungDarstellung von Punkten im R3
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.
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.
EinführungDarstellung von Punkten im R3
Show[Graphics3D[{PointSize[0.05],Point[{1,1,1}]}]]
Show[Graphics3D[{Hue[0.98],PointSize[0.05],Point[{1,1,1}]}]]
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]]
EinführungDarstellung von Punkten im R3
505 x
50
5 y
5
0
5
z
5
0
5
z
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];
EinführungDarstellung von Punkten im R3
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]
EinführungDarstellung von Punkten im R3
Show[Ebene, Punkt]5
05 x
50
5y
5
0
5
z
5
0
5
z
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
Einführung
Binomial-Verteilung
<< Statistics`DiscreteDistributions`<< Graphics`Graphics`
Um die Befehle BarChart und Binomial verwenden zu können, müssen diese beiden Packages zugeladen werden
Binomial[7,3]
Ausgabe: 35
Dieser Befehl berechnet den Binomialkoeffizienten:
3
7
Einführung
Binomial-Verteilung
BW[p_, n_, k_] := Binomial[n, k]*p^k*(1 - p)^(n - k)
Um die Berechnung der Wahrscheinlichkeiten durchzuführen, definiert man sich eine Binomial-verteilungsfunktion.
BW[0.4,10,3] Ausgabe: 0,214991
Mit dem Aufruf z.B. von BW[0.4,10,3] kann dann die entsprechende Wahrscheinlichkeit bestimmt werden.
Einführung
Binomial-Verteilung
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)
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.
Einführung
Binomial-Verteilung
{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.
Im Falle der zu berechnenden Wahrscheinlichkeiten lautet der Table-Befehl
WV = Table[BW[0.3, 5, k], {k, 0, 5}]
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]
Einführung
Binomial-Verteilung
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]
Bestimme die Wahrscheinlichkeiten von
n = 10; p = 0,3; P( 4 X 7)
Einführung
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]}} ];
EinführungDas Knox-Package
1 1 2 3 4 5x
1
1
2
3
4
5
6
7
8fx
TangentPoints -> {1}, TangentStyle -> {{Thickness[0.01], Hue[0.15]}}
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.
EinführungDas Knox-Package
Es können auch mehrere Punkte angegeben werden. Dies geschieht aufzählend.
1 1 2 3 4x
1
1
2
3
4
5
6
7
8fx
TangentPoints -> {1,2}, TangentStyle -> {{Thickness[0.01], Hue[0.15]},{Thickness[0.01], Hue[0.25]}}
EinführungDas Knox-Package
Um ein Steigungsdreieck einzuzeichnen, muss mit Hilfe des Line-Befehls jeweils die entsprechende Linie gezeichnet werden.
1 1 2 3 4x
1
1
2
3
4
5
6
7
8fx
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}}];
EinführungDas Knox-Package
Mit Hilfe von Show können dann verschiedene Graphiken zusammen dargestellt werden.
1 1 2 3 4x
1
1
2
3
4
5
6
7
8fx
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}}]} ];
EinführungDas 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)"}]
Information"PlotMidpointApproxR", LongForm FalsePlotMidpointApproxR[f[x],{x,xmin,xmax,dx}] plots f[x] between xmin and xmax and the approximation to the integral based on a pseudo-random partition of mesh size dx and the height of the rectangles determined by the midpoints of the subintervals. Other options are those of PlotLeftApprox.
1 2 3 4x
1
2
3fx Flächenberechnung
EinführungDas Knox-Package
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}];
2 4 6 8 10 12 14 16 18 20t
1
0.5
0.5
1
1.5
2
xtEinführung
Differenzialgleichungen
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}];
2 4 6 8 10 12 14 16 18 20t
1
0.5
0.5
1
1.5
2
xt, ytEinführung
Die gleichmäßig beschleunigte Bewegung
Zeit in s 0 1,6087 2,3001 2,8012 3,2283 3,6185 3,9823 4,283
Zurückgelegter Weg
0 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}}
EinführungAuswertung von Messreihen
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.
Die gleichmäßig beschleunigte Bewegung
EinführungAuswertung von Messreihen
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
Die gleichmäßig beschleunigte Bewegung
EinführungAuswertung von Messreihen
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.
Die gleichmäßig beschleunigte Bewegung
EinführungAuswertung von MessreihenMit Hilfe des Befehls ListPlot werden die
Datenpunkte der Datenreihe angezeigt.
1 2 3 4 5t in s
0.1
0.2
0.3
0.4
0.5
0.6
s in m Gleichm. beschl. Bewegung
Die gleichmäßig beschleunigte Bewegung
EinführungAuswertung von Messreihen
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.
Die gleichmäßig beschleunigte Bewegung
EinführungAuswertung von Messreihen
Mit Hilfe des Plot-Befehls wird die Fit-Kurve gezeichnet.
1 2 3 4 5t in s
0.1
0.2
0.3
0.4
0.5
0.6
s in m Gleichm. beschl. Bewegung
Die gleichmäßig beschleunigte Bewegung
EinführungAuswertung von MessreihenMit Hilfe von Show können jetzt beide Kurven übereinandergelegt werden.
1 2 3 4 5t in s
0.1
0.2
0.3
0.4
0.5
0.6
s in m Gleichm. beschl. Bewegung
Show[plot2,plot1];
Das radioaktive Element Barium zerfällt.
Zeit in min 0 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}}
EinführungAuswertung von Messreihen
Mit Hilfe des Befehls NonlinearFit wird die entspre-chende Funktion erzeugt.
BariumFunktion = NonlinearFit[DatenBarium, a E^(-b x), x, {a, b}]
Ergebnis: 1046.7 e -0.274009 x
Der Funktionsterm ist in der Variablen BariumFunktion gespeichert und kann mit Hilfe des Plot-Befehls gezeichnet werden.
2 4 6 8 10t in min
200
400
600
800
1000
Impulse Radioaktiver Zerfall
EinführungAuswertung 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"}];
2 4 6 8 10t in min
200
400
600
800
1000
Impulse Radioaktiver Zerfall
EinführungAuswertung 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"}];
1 2 3 4 5 6t in min
400
600
800
1000
Impulse10 s Radioaktiver Zerfall
EinführungAuswertung von Messreihen
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]
2 4 6 8 10t in min
200
400
600
800
1000
Impulse Radioaktiver Zerfall
EinführungAuswertung 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.
1 2 3 4 5 6 7 8t in min
100
150
200
300
500
700
1000
Impulse10 s Radioaktiver Zerfall
EinführungAuswertung von Messreihen
Dazu muss das gesamte Paket<<Graphics`Graphics`geladen werden. Jetzt sind die beiden BefehleLogListPlot 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"}];
0 1 2 3 4 5 6t in min
300
500
700
1000
Impulse10 s Radioaktiver Zerfall
EinführungAuswertung von Messreihen
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.
0.5 1 1.5
2
4
6
8
Fläche unter der Kurve
Radius 1 Radius 20.5 1 1.5
2
4
6
8
Einführung
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}]];
EinführungText 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}]};
0.5 1 1.5
2
4
6
8
0.5 1 1.5
2
4
6
8
Show[{graph1}, Graphics[{signum1, signum2, signum3}]];
EinführungText im Mathematica-Plot
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 - 1 - 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];
EinführungOrbitale
g3 = Series[Sin[x], {x, 0, 3}]g5 = Series[Sin[x], {x, 0, 5}]
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]}}];
EinführungTaylorreihen – Version 1
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]}}]; 4 3 2 1 1 2 3 4
1.5
1
0.5
0.5
1
1.5
EinführungTaylorreihen
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]}}];
EinführungTaylorreihen – Version 2
3 2 1 1 2
1
2
3
4
5
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]}}];
EinführungTaylorreihen – Version 2
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;
EinführungVollstä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 -> -];
EinführungVollstä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;
EinführungVollstä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] <> "."]
EinführungVollstä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[est] != 0, x /. est, 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[0.912718]}, {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)"},
EinführungVollstä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[est] != 0, x /. est, 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} }];
EinführungVollständige Kurvendiskussion
Die Funktion wird als t[x_] eingegeben, z.B.t[x_] := 1/2 x^4 - 2.0 x^3 + 3x – 5
Zu diskutieren war die Funktion fx x4
2 2. x3 3 x 5.
Sie besitzt 2 reelle Nullstellenn, nämlich1.51254, 3.76402Die Schnittpunkte mit der Ordinatenachse xAchsesind0;5..Sie besitzt ein Minimum im Punkt0.641784; 6.31184Sie besitzt ein Maximum im Punkt0.831746; 3.41627Sie besitzt ein Minimum im Punkt2.81004; 9.77188Sie besitzt 2 Wendepunkte e, und zwar :0.; 5.,2.; 7.,Sie ist nicht achsensymmetrisch zur Ordinatenachse xAchse.Sie ist nicht punktsymmetrisch zum Koordinatenursprung .
Wenn x gegen geht , nähern sich die Funktionswerte .
Wenn x gegen geht , nähern sich die Funktionswerte .
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
EinführungVollständige Kurvendiskussion
t[x_] := 1/2 x^4 - 2.0 x^3 + 3x – 5
2 1 1 2 3 4x
12.5
10
7.5
5
2.5
2.5
fx
Rot: t[x]Gelb: t‘[x]
EinführungVollständige Kurvendiskussion
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[-3 + 3 t + t^2 > 0, t]Ausgabe ist dann:
t 1
23 21t
1
2321
Dabei bedeutet: | | oder
EinführungLösung von Ungleichungen
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.
EinführungLine – 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} ] ]
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
EinführungLine – 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} ] ]
0.5 1 1.5 2
1.5
2
2.5
3
3.5
4
Löschen aller Variablen:
EinführungWichtige Befehle
Clear["context`* "]
Einen Pfad festlegen, um auf Packages zugreifen zu können
AppendTo[$Path, "c:\mathematica\Unterverzeichnis\\ “]
Clear["Global`* "]