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], .footerWrapper 6]

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.


{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


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).


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).


<<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.


// 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.



{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}},



// 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



//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}];



Show[Ebene1,Ebene2, Background -> GrayLevel[0.9], PlotLabel -> "Ebene und Gerade"];


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


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}];


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


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}];



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}];



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


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.


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.


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]]


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];


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]


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.


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]}}


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}}];


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}}]} ];


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


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.



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



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.


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



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.



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



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


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}}


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


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



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


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



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



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



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]}}];


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]}}];


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 -> -];


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;


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] <> "."]


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)"},


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} }];


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


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]


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`* "]

Documents

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], .footerWrapper 6]